The need for threads Mutual exclusion

Embedded Systems Programming

Lecture 3

Verónica Gaspes
www2.hh.se/staff/vero

Center for Research on Embedded Systems

School of Information Science, Computer and Electrical Engineering

November 11, 2008

 The need for threads Mutual exclusion

A simple embedded system

Follow (track) an object using sonar echoes. Control parameters

are sent over wireless. The servo controls wheels.

Distance Servo
Controller
data signals
Object Sonar Output
Input
Control
Params

Radio
Decoder
packets
Input
 The need for threads Mutual exclusion

The view from the processor

Sensor input port Servo output port

read write

Program

read

Radio input port

 The need for threads Mutual exclusion

The program

We will go through a series of

attempts to organize the program
leading to the need for threads.

We discuss new problems that

arise because of programming
with threads.

Next lecture we will show how to

implement threads.
 The need for threads Mutual exclusion

The program: busy waiting input

int sonar_read(){
while(SONAR_STATUS & READY == 0);
We can define functions.
return SONAR_DATA;
that create an illusion to
}
the rest of the program!

void radio_read(struct Packet *pkt){

We have assumed input
while(RADIO_STATUS & READY == 0);
ports that automatically
pkt->v1 = RADIO_DATA1;
reset status when data is
...
read.
pkt->vn = RADIO_DATAn;
}
 The need for threads Mutual exclusion

The program: busy waiting input

int sonar_read(){
while(SONAR_STATUS & READY == 0);
We can define functions.
return SONAR_DATA;
that create an illusion to
}
the rest of the program!

void radio_read(struct Packet *pkt){

We have assumed input
while(RADIO_STATUS & READY == 0);
ports that automatically
pkt->v1 = RADIO_DATA1;
reset status when data is
...
read.
pkt->vn = RADIO_DATAn;
}
 The need for threads Mutual exclusion

The program: busy waiting input

int sonar_read(){
while(SONAR_STATUS & READY == 0);
We can define functions.
return SONAR_DATA;
that create an illusion to
}
the rest of the program!

void radio_read(struct Packet *pkt){

We have assumed input
while(RADIO_STATUS & READY == 0);
ports that automatically
pkt->v1 = RADIO_DATA1;
reset status when data is
...
read.
pkt->vn = RADIO_DATAn;
}
 The need for threads Mutual exclusion

The program: busy waiting input

int sonar_read(){
while(SONAR_STATUS & READY == 0);
We can define functions.
return SONAR_DATA;
that create an illusion to
}
the rest of the program!

void radio_read(struct Packet *pkt){

We have assumed input
while(RADIO_STATUS & READY == 0);
ports that automatically
pkt->v1 = RADIO_DATA1;
reset status when data is
...
read.
pkt->vn = RADIO_DATAn;
}
 The need for threads Mutual exclusion

The program: output

void servo_write(int sig){

SERVO_DATA = sig;
}
 The need for threads Mutual exclusion

The program: algorithms

Control
void control(int dist, int *sig, struct Params *p);

Calculates the servo signal.

Decode
void decode(struct Packet *pkt, struct Params *p)

Decodes a packet and calculates new control parameters

 The need for threads Mutual exclusion

The program: algorithms

Control
void control(int dist, int *sig, struct Params *p);

Calculates the servo signal.

Decode
void decode(struct Packet *pkt, struct Params *p)

Decodes a packet and calculates new control parameters

 The need for threads Mutual exclusion

The program: algorithms

Control
void control(int dist, int *sig, struct Params *p);

Calculates the servo signal.

Decode
void decode(struct Packet *pkt, struct Params *p)

Decodes a packet and calculates new control parameters

 The need for threads Mutual exclusion

The program: a first attempt

main(){
struct Params params;
struct Packet packet;
int dist, signal;
while(1){
dist = sonar_read();
control(dist, &signal, &params);
servo_write(signal);

radio_read(&packet);
decode(&packet,&params);
}
}
 The need for threads Mutual exclusion

Problems?

radio
packets

sonar
echoes

We do not know what port will have new data next! The sonar
and the radio generate events that are unrelated to each other!

Our program will ignore all events of one kind that happen while
busy waiting for the other event!
 The need for threads Mutual exclusion

Problems?

radio
packets

sonar
echoes

We do not know what port will have new data next! The sonar
and the radio generate events that are unrelated to each other!

Our program will ignore all events of one kind that happen while
busy waiting for the other event!
 The need for threads Mutual exclusion

Problems?

radio
packets

sonar
echoes

We do not know what port will have new data next! The sonar
and the radio generate events that are unrelated to each other!

Our program will ignore all events of one kind that happen while
busy waiting for the other event!
 The need for threads Mutual exclusion

The problem explained

RAM and files vs. external input

Data is already in place (. . . radio packets are not!)
Even if there might be reasons for waiting, like for the disk
head moving to point to the right sector, contents does not
have to be created!
They produce data only because they are asked to (. . . remote
transmitters act on their own!)

The illusion that input is like reading from memory while blocking
waiting for data requires that we choose the source of input before
blocking!
 The need for threads Mutual exclusion

The problem explained

RAM and files vs. external input

Data is already in place (. . . radio packets are not!)
Even if there might be reasons for waiting, like for the disk
head moving to point to the right sector, contents does not
have to be created!
They produce data only because they are asked to (. . . remote
transmitters act on their own!)

The illusion that input is like reading from memory while blocking
waiting for data requires that we choose the source of input before
blocking!
 The need for threads Mutual exclusion

The problem explained

RAM and files vs. external input

Data is already in place (. . . radio packets are not!)
Even if there might be reasons for waiting, like for the disk
head moving to point to the right sector, contents does not
have to be created!
They produce data only because they are asked to (. . . remote
transmitters act on their own!)

The illusion that input is like reading from memory while blocking
waiting for data requires that we choose the source of input before
blocking!
 The need for threads Mutual exclusion

The problem explained

RAM and files vs. external input

Data is already in place (. . . radio packets are not!)
Even if there might be reasons for waiting, like for the disk
head moving to point to the right sector, contents does not
have to be created!
They produce data only because they are asked to (. . . remote
transmitters act on their own!)

The illusion that input is like reading from memory while blocking
waiting for data requires that we choose the source of input before
blocking!
 The need for threads Mutual exclusion

The problem explained

RAM and files vs. external input

Data is already in place (. . . radio packets are not!)
Even if there might be reasons for waiting, like for the disk
head moving to point to the right sector, contents does not
have to be created!
They produce data only because they are asked to (. . . remote
transmitters act on their own!)

The illusion that input is like reading from memory while blocking
waiting for data requires that we choose the source of input before
blocking!
 The need for threads Mutual exclusion

The program: a second attempt

while(1){
if(SONAR_STATUS & READY){
dist = SONAR_DATA;
control(dist,&signal,&params);
servo_write(signal);
} Destroy the functions for
if(RADIO_STATUS & READY){ reading and have only
packet->v1 = RADIO_DATA1; one busy waiting loop!
...;
packet->v2 = RADIO_DATAn;
decode(&packet,&params);
}
}
 The need for threads Mutual exclusion

Centralized busy waiting

The new implementation checks both status registers in one

big busy-waiting loop. This avoids waiting for the wrong
input.
We destroyed the simple read operations! VERY not modular!

100% CPU usage, no matter how frequent input data arrives.

Try to make the main loop run less often!

 The need for threads Mutual exclusion

Centralized busy waiting

The new implementation checks both status registers in one

big busy-waiting loop. This avoids waiting for the wrong
input.
We destroyed the simple read operations! VERY not modular!

100% CPU usage, no matter how frequent input data arrives.

Try to make the main loop run less often!

 The need for threads Mutual exclusion

Centralized busy waiting

The new implementation checks both status registers in one

big busy-waiting loop. This avoids waiting for the wrong
input.
We destroyed the simple read operations! VERY not modular!

100% CPU usage, no matter how frequent input data arrives.

Try to make the main loop run less often!

 The need for threads Mutual exclusion

Centralized busy waiting

The new implementation checks both status registers in one

big busy-waiting loop. This avoids waiting for the wrong
input.
We destroyed the simple read operations! VERY not modular!

100% CPU usage, no matter how frequent input data arrives.

Try to make the main loop run less often!

 The need for threads Mutual exclusion

The program: a third attempt

The cyclic executive

while(1){
sleep_until_next_timer_interrupt();
if(SONAR_STATUS & READY){
dist = SONAR_DATA; The CPU runns at a
control(dist,&signal,&params); fixed rate! The timer
servo_write(signal); period must be set to
} trade power
if(RADIO_STATUS & READY){ consumption against
packet->v1 = RADIO_DATA1; task response!
...;
packet->v2 = RADIO_DATAn;
decode(&packet,&params);
}
}
 The need for threads Mutual exclusion

Problems?

radio
packets

sonar
echoes

If processing time for the infrequent radio packets is much longer

than for the frequent sonar echoes . . .
 The need for threads Mutual exclusion

Concurrent execution

We could solve (in a rather ad-hoc way) how to wait

concurrently.
Now we need to express concurrent execution . . .

Imagine . . .
. . . that we could interrupt execution of packet decoding when a
sonar echo arrives so that the control algorithm can be ran. Then
decoding could resume! The two tasks fragments are interleaved.
 The need for threads Mutual exclusion

Concurrent execution

We could solve (in a rather ad-hoc way) how to wait

concurrently.
Now we need to express concurrent execution . . .

Imagine . . .
. . . that we could interrupt execution of packet decoding when a
sonar echo arrives so that the control algorithm can be ran. Then
decoding could resume! The two tasks fragments are interleaved.
 The need for threads Mutual exclusion

Interleaving by hand

void decode(struct Packet *pkt, struct Params p){

phase1(pkt,p);
try_sonar_task();
phase2(pkt,p);
try_sonar_task();
phase3(pkt,p);
}

void try_sonar_task(){ Again we break tha

if(SONAR_STATUS & READY){ logical organization of
dist = SONAR_DATA; the program in an
control(dist,&signal,&params); ad-hoc way! How many
servo_write(signal); phases of decode will
} we need to run the sonar
} often enough?
 The need for threads Mutual exclusion

Interleaving by hand

void decode(struct Packet *pkt, struct Params p){

phase1(pkt,p);
try_sonar_task();
phase2(pkt,p);
try_sonar_task();
phase3(pkt,p);
}

void try_sonar_task(){ Again we break tha

if(SONAR_STATUS & READY){ logical organization of
dist = SONAR_DATA; the program in an
control(dist,&signal,&params); ad-hoc way! How many
servo_write(signal); phases of decode will
} we need to run the sonar
} often enough?
 The need for threads Mutual exclusion

Interleaving by hand

void decode(struct Packet *pkt, struct Params p){

phase1(pkt,p);
try_sonar_task();
phase2(pkt,p);
try_sonar_task();
phase3(pkt,p);
}

void try_sonar_task(){ Again we break tha

if(SONAR_STATUS & READY){ logical organization of
dist = SONAR_DATA; the program in an
control(dist,&signal,&params); ad-hoc way! How many
servo_write(signal); phases of decode will
} we need to run the sonar
} often enough?
 The need for threads Mutual exclusion

Interleaving by hand

void decode(struct Packet *pkt, struct Params p){

phase1(pkt,p);
try_sonar_task();
phase2(pkt,p);
try_sonar_task();
phase3(pkt,p);
}

void try_sonar_task(){ Again we break tha

if(SONAR_STATUS & READY){ logical organization of
dist = SONAR_DATA; the program in an
control(dist,&signal,&params); ad-hoc way! How many
servo_write(signal); phases of decode will
} we need to run the sonar
} often enough?
 The need for threads Mutual exclusion

Interleaving by hand

More fine breaking up might be needed . . .

void phase2(struct Packet *pkt, struct Params *p){

while(expr){
try_sonar_task();
phase21(pkt,p);
}
}
 The need for threads Mutual exclusion

Interleaving by hand

More fine breaking up might be needed . . .

void phase2(struct Packet *pkt, struct Params *p){

int i = 0;
while(expr){
if(i%800==0)try_sonar_task();
i++;
phase21(pkt,p);
}
}

Code can become very unstructured and complicated very soon.

And then someone might come up with a new, better decoding

algorithm . . .
 The need for threads Mutual exclusion

Interleaving by hand

More fine breaking up might be needed . . .

void phase2(struct Packet *pkt, struct Params *p){

int i = 0;
while(expr){
if(i%800==0)try_sonar_task();
i++;
phase21(pkt,p);
}
}

Code can become very unstructured and complicated very soon.

And then someone might come up with a new, better decoding

algorithm . . .
 The need for threads Mutual exclusion

Interleaving by hand

More fine breaking up might be needed . . .

void phase2(struct Packet *pkt, struct Params *p){

int i = 0;
while(expr){
if(i%800==0)try_sonar_task();
i++;
phase21(pkt,p);
}
}

Code can become very unstructured and complicated very soon.

And then someone might come up with a new, better decoding

algorithm . . .
 The need for threads Mutual exclusion

Automatic interleaving?

There are 2 tasks, driven by independent input sources.

Handle sonar echoes running the

Handle radio packets by running
control algorithm and updating
the decoder.
the servo.

Had we had access to 2 CPUs we could place one task in each. We

can imagine some contruct that allows us to express this in our
program.
 The need for threads Mutual exclusion

Automatic interleaving?

There are 2 tasks, driven by independent input sources.

Handle sonar echoes running the

Handle radio packets by running
control algorithm and updating
the decoder.
the servo.

Had we had access to 2 CPUs we could place one task in each. We

can imagine some contruct that allows us to express this in our
program.
 The need for threads Mutual exclusion

Automatic interleaving?

There are 2 tasks, driven by independent input sources.

Handle sonar echoes running the

Handle radio packets by running
control algorithm and updating
the decoder.
the servo.

Had we had access to 2 CPUs we could place one task in each. We

can imagine some contruct that allows us to express this in our
program.
 The need for threads Mutual exclusion

Automatic interleaving?

There are 2 tasks, driven by independent input sources.

Handle sonar echoes running the

Handle radio packets by running
control algorithm and updating
the decoder.
the servo.

Had we had access to 2 CPUs we could place one task in each. We

can imagine some contruct that allows us to express this in our
program.
 The need for threads Mutual exclusion

Two CPUs

Sensor input port Servo output port

read write
CPU1
Controller

RAM parameters

CPU2 read
Controller

Radio input port

 The need for threads Mutual exclusion

Two CPU’s program

struct Params params;

void controller_main(){
int dist, signal; void decoder_main(){
while(1){ struct Packet packet;
dist = sonar_read(); while(1){
control(dist, radio_read(&packet);
&signal, decode(&packet,&params);
&params); }
servo_write(signal); }
}
}
We need some way of making one program of this! We will deal
with it next lecture!
 The need for threads Mutual exclusion

Concurrent Programming

Concurrent programming is the name given to programming

notation and techniques for expressing potential parallelism and
solving the resulting synchronization and communication problems.

A system supporting seemingly concurrent execution is called

multi-threaded.

A thread is a unique execution of a sequence of machine

instructions, that can be interleaved with other threads executing
on the same machine.
 The need for threads Mutual exclusion

Concurrent Programming

Concurrent programming is the name given to programming

notation and techniques for expressing potential parallelism and
solving the resulting synchronization and communication problems.

A system supporting seemingly concurrent execution is called

multi-threaded.

A thread is a unique execution of a sequence of machine

instructions, that can be interleaved with other threads executing
on the same machine.
 The need for threads Mutual exclusion

Concurrent Programming

Concurrent programming is the name given to programming

notation and techniques for expressing potential parallelism and
solving the resulting synchronization and communication problems.

A system supporting seemingly concurrent execution is called

multi-threaded.

A thread is a unique execution of a sequence of machine

instructions, that can be interleaved with other threads executing
on the same machine.
 The need for threads Mutual exclusion

Where should threads belong?

A programming language?
As in Java or Ada. Programs are well organized and are
independent of the OS.

Libs and OS?

Like C with POSIX threads? Good for multilanguage composition
given that OS standards are followed.

This course
For pedagogical purposes we choose to work with C and a small
kernel.
 The need for threads Mutual exclusion

Where should threads belong?

A programming language?
As in Java or Ada. Programs are well organized and are
independent of the OS.

Libs and OS?

Like C with POSIX threads? Good for multilanguage composition
given that OS standards are followed.

This course
For pedagogical purposes we choose to work with C and a small
kernel.
 The need for threads Mutual exclusion

Where should threads belong?

A programming language?
As in Java or Ada. Programs are well organized and are
independent of the OS.

Libs and OS?

Like C with POSIX threads? Good for multilanguage composition
given that OS standards are followed.

This course
For pedagogical purposes we choose to work with C and a small
kernel.
 The need for threads Mutual exclusion

Where should threads belong?

A programming language?
As in Java or Ada. Programs are well organized and are
independent of the OS.

Libs and OS?

Like C with POSIX threads? Good for multilanguage composition
given that OS standards are followed.

This course
For pedagogical purposes we choose to work with C and a small
kernel.
 The need for threads Mutual exclusion

Our first multithreaded program

struct Params params;

void controller_main(){
int dist, signal;
void decoder_main(){
while(1){
struct Packet packet;
dist = sonar_read();
while(1){
control(dist,
radio_read(&packet);
&signal,
decode(&packet,&params);
&params);
}
servo_write(signal);
}
}
}
main(){
spawn(decoder_main);
controller_main();
}
 The need for threads Mutual exclusion

The critical section problem

What will happen if the params struct is read (by the controller)
at the same time it is written (by the decoder)?

I.e., what if the scheduler happens to insert some decoder

instructions while some, but not all, of the controller’s reads have
been done?

This problem is central to concurrent programming where there is

any ammount of sharing!
 The need for threads Mutual exclusion

The critical section problem

What will happen if the params struct is read (by the controller)
at the same time it is written (by the decoder)?

I.e., what if the scheduler happens to insert some decoder

instructions while some, but not all, of the controller’s reads have
been done?

This problem is central to concurrent programming where there is

any ammount of sharing!
 The need for threads Mutual exclusion

The critical section problem

What will happen if the params struct is read (by the controller)
at the same time it is written (by the decoder)?

I.e., what if the scheduler happens to insert some decoder

instructions while some, but not all, of the controller’s reads have
been done?

This problem is central to concurrent programming where there is

any ammount of sharing!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Becomes interested,sells her old
car
Updates price tag
Gets angry!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in real life

Car dealer Car buyer

Displays used car
Puts up price tag

Displays luxury car

Updates price tag
Chooses to keep her old car
All good!
 The need for threads Mutual exclusion

Critical sections in programs

Imagine uppdating the same bank account from two places at

approximately the same time (e.g. your employer deposits your
salary at more or less the same time as you are making a small
deposit).

int account = 0;
account = account + 500; account = account + 10000;

When this is compiled there might be several instructions for each

update!
 The need for threads Mutual exclusion

Critical sections in programs

Imagine uppdating the same bank account from two places at

approximately the same time (e.g. your employer deposits your
salary at more or less the same time as you are making a small
deposit).

int account = 0;
account = account + 500; account = account + 10000;

When this is compiled there might be several instructions for each

update!
 The need for threads Mutual exclusion

Critical sections in programs

load account,r1
add 500,r1
store r1, account
load account, r2
add 10000, r2
store r2, account

Final balance is 10500

 The need for threads Mutual exclusion

Critical sections in programs

load account, r2
add 10000, r2
store r2, account
load account,r1
add 500,r1
store r1, account

Final balance is 10500

 The need for threads Mutual exclusion

Critical sections in programs

load account,r1
load account, r2
add 10000, r2
add 500,r1
store r2, account
store r1, account

Final balance is 500

 The need for threads Mutual exclusion

Critical sections in programs

Testing and setting

int shopper;

if(shopper == NONE) if(shopper==NONE)

shopper = HUSBAND shopper = WIFE

Possible interleaving
if(shopper == NONE)
if(shopper==NONE)

shopper = HUSBAND
shopper = WIFE
 The need for threads Mutual exclusion

Critical sections in programs

Testing and setting

int shopper;

if(shopper == NONE) if(shopper==NONE)

shopper = HUSBAND shopper = WIFE

Possible interleaving
if(shopper == NONE)
if(shopper==NONE)

shopper = HUSBAND
shopper = WIFE
 The need for threads Mutual exclusion

Our embedded system

Exchanging parameters
struct Params p;
while(1){ while(1){
... local_minD = p.minDistance;
p.minDistance = e1; local_maxS = p.maxSpeed;
p.maxSpeed = e2; ...
} }

Possible interleaving
p.minDistance = 1;
p.maxSpeed = 1;
local_minD = 1;
p.minDistance = 200;
p.maxSpeed = 150;
local_maxS = 150
 The need for threads Mutual exclusion

Our embedded system

Exchanging parameters
struct Params p;
while(1){ while(1){
... local_minD = p.minDistance;
p.minDistance = e1; local_maxS = p.maxSpeed;
p.maxSpeed = e2; ...
} }

Possible interleaving
p.minDistance = 1;
p.maxSpeed = 1;
local_minD = 1;
p.minDistance = 200;
p.maxSpeed = 150;
local_maxS = 150
 The need for threads Mutual exclusion

The classical solution

Apply an access protocol to the critical sections that ensures

mutual exclusion

Require that all parties follow the protocol

Access protocols are realized by means of a shared datastructure

known as amutex or a lock.
 The need for threads Mutual exclusion

The classical solution

Apply an access protocol to the critical sections that ensures

mutual exclusion

Require that all parties follow the protocol

Access protocols are realized by means of a shared datastructure

known as amutex or a lock.
 The need for threads Mutual exclusion

The classical solution

Apply an access protocol to the critical sections that ensures

mutual exclusion

Require that all parties follow the protocol

Access protocols are realized by means of a shared datastructure

known as amutex or a lock.
 The need for threads Mutual exclusion

Mutual exclusion

Exchanging parameters
struct Params p;
mutex m;
while(1){ while(1){
... lock (&m)
lock (&m); local_minD = p.minDistance;
p.minDistance = e1; local_maxS = p.maxSpeed;
p.maxSpeed = e2; unlock (&m)
unlock (&m); ...
}
}
 The need for threads Mutual exclusion

Comming next

Laboration 1
You will experiment with low level programming, busy waiting for
input and trying to put together 3 tasks by interleaving them by
hand.

Lecture 4 and more

We will investigate what it takes to implement automatic
interleaving and mutexes and how to use them in concurrent
programs.

Later on we will move to a more abstract view where objects and

messages are the central notions, threads and mutual exclusion are
taken care of automatically and busy waiting can be avoided!
 The need for threads Mutual exclusion

Comming next

Laboration 1
You will experiment with low level programming, busy waiting for
input and trying to put together 3 tasks by interleaving them by
hand.

Lecture 4 and more

We will investigate what it takes to implement automatic
interleaving and mutexes and how to use them in concurrent
programs.

Later on we will move to a more abstract view where objects and

messages are the central notions, threads and mutual exclusion are
taken care of automatically and busy waiting can be avoided!
 The need for threads Mutual exclusion

Comming next

Laboration 1
You will experiment with low level programming, busy waiting for
input and trying to put together 3 tasks by interleaving them by
hand.

Lecture 4 and more

We will investigate what it takes to implement automatic
interleaving and mutexes and how to use them in concurrent
programs.

Later on we will move to a more abstract view where objects and

messages are the central notions, threads and mutual exclusion are
taken care of automatically and busy waiting can be avoided!