Embedded Systems Programming A simple embedded system The ...

The need for threads Mutual exclusion The C execution model Context Switch
Embedded Systems Programming
Lecture 3
The need for threads Mutual exclusion The C execution model Context Switch
A simple embedded system
Follow (track) an object using sonar echoes. Control parameters
are sent over wireless. The servo controls wheels.
Verónica Gaspes
www2.hh.se/staff/vero
Object
Sonar
Distance
data
Input
Servo
Controller
signals
Output
Control
Params
Center for Research on Embedded Systems
School of Information Science, Computer and Electrical Engineering
Decoder
Radio
packets
Input
The need for threads Mutual exclusion The C execution model Context Switch
The view from the processor
Concurrent waiting
The need for threads Mutual exclusion The C execution model Context Switch
Sensor input port
Servo output port
radio
packets
read
write
Program
sonar
echoes
read
Radio input port
We ended up with the cyclic executive: one big loop busy waiting
on all input sources!

The need for threads Mutual exclusion The C execution model Context Switch
Concurrent execution
About laboration 1
The need for threads Mutual exclusion The C execution model Context Switch
radio
packets
sonar
echoes
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.
In lab 1 you will program 3 functions
Writing prime numbers to the LCD
Blinking with a symbol in the LCD
Turing on and off a symbol in the LCD using the joystick
In lab 1 you will then write a big program to do all things at once.
You will then test the cyclic executive and interleaving by hand (to
experience the difficulties with it!)
The need for threads Mutual exclusion The C execution model Context Switch
Automatic interleaving
Two CPUs
The need for threads Mutual exclusion The C execution model Context Switch
Sensor input port
Servo output port
There are 2 tasks, driven by independent input sources.
read
CPU1
Controller
write
Handle sonar echoes running the
control algorithm and updating
the servo.
Handle radio packets by running
the decoder.
RAM
parameters
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.
CPU2
Controller
read
Radio input port

The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Two CPU’s program
struct Params params;
void controller_main(){
int dist, signal;
while(1){
dist = sonar_read();
control(dist,
&signal,
&params);
servo_write(signal);
}
}
We need some way of making one program of this!
void decoder_main(){
struct Packet packet;
while(1){
radio_read(&packet);
decode(&packet,&params);
}
}
Our first multithreaded program
void controller_main(){
int dist, signal;
while(1){
dist = sonar_read();
control(dist,
&signal,
&params);
servo_write(signal);
}
}
struct Params params;
void decoder_main(){
struct Packet packet;
while(1){
radio_read(&packet);
decode(&packet,&params);
}
}
main(){
spawn(decoder_main);
controller_main();
}
The need for threads Mutual exclusion The C execution model Context Switch
The critical section problem
The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in real life
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!
Car dealer
Displays used car
Puts up price tag
Displays luxury car
Updates price tag
Car buyer
Becomes interested,sells her old
car
Gets angry!

The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in real life
The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in programs
Car dealer
Displays used car
Puts up price tag
Displays luxury car
Updates price tag
Car buyer
Chooses to keep her old car
All good!
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 The C execution model Context Switch
Critical sections in programs
The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in programs
load account,r1
add 500,r1
store r1, account
load account, r2
add 10000, r2
store r2, account
load account,r1
add 500,r1
store r1, account
load account, r2
add 10000, r2
store r2, account
Final balance is 10500
Final balance is 10500

The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in programs
The need for threads Mutual exclusion The C execution model Context Switch
Critical sections in programs
load account,r1
add 500,r1
store r1, account
Final balance is 500
load account, r2
add 10000, r2
store r2, account
Testing and setting
int shopper;
if(shopper == NONE)
shopper = HUSBAND
Possible interleaving
if(shopper == NONE)
if(shopper==NONE)
shopper = WIFE
if(shopper==NONE)
shopper = HUSBAND
shopper = WIFE
The need for threads Mutual exclusion The C execution model Context Switch
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; ...
} }
The need for threads Mutual exclusion The C execution model Context Switch
The classical solution
Apply an access protocol to the critical sections that ensures
mutual exclusion
Require that all parties follow the protocol
Possible interleaving
p.minDistance = 1;
p.maxSpeed = 1;
p.minDistance = 200;
p.maxSpeed = 150;
local_minD = 1;
local_maxS = 150
Access protocols are realized by means of a shared datastructure
known as amutex or a lock.

The need for threads Mutual exclusion The C execution model Context Switch
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 The C execution model Context Switch
Execution of a C program
The following slides will help us understand what we will need to
do to implement threads and automatic interleaving.
SP
Stack
Locals of a()
x =
Globals
v = 0
w v = 0
u = 0
PC
Code
a(){
int x;
}
...
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
Stack
Code
Stack
Code
SP
Locals of a()
x =
a(){
int x;
SP
Locals of a()
x = 9
a(){
int x;
PC
...
PC
x = 9;
w = 6;
...
}
}
Globals
Globals
v = 0
w v = 0
u = 0
v = 0
w = 6
u = 0

The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
Stack
Code
Stack
Code
SP
Locals of a()
x = 9
a(){
int x;
Locals of a()
x = 9
a(){
int x;
b(int y){
PC
x = 9;
w = 6;
b(55);
SP
Locals of b()
y = 55
x = 9;
w = 6;
b(55);
PC
...
}
}
}
Globals
Globals
v = 0
w = 6
u = 0
v = 0
w = 6
u = 0
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
Stack
Code
Stack
Code
SP
Locals of a()
x = 9
Locals of b()
y = 55
a(){
int x;
x = 9;
w = 6;
b(55);
}
PC
b(int y){
...
y = c();
}
SP
Locals of a()
x = 9
Locals of b()
y = 55
Locals of c()
z = 23
a(){
int x;
x = 9;
w = 6;
b(55);
}
b(int y){
...
y = c();
}
PC
c(){
int z = 23;
...
}
Globals
Globals
v = 0
w = 6
u = 0
v = 0
w = 6
u = 0

The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
Stack
Code
Stack
Code
SP
Locals of a()
x = 9
Locals of b()
y = 55
Locals of c()
z = 23
a(){
int x;
x = 9;
w = 6;
b(55);
}
b(int y){
...
y = c();
}
PC
c(){
int z = 23;
w = 77;
...
}
SP
Locals of a()
x = 9
Locals of b()
y = 55
Locals of c()
z = 23
a(){
int x;
x = 9;
w = 6;
b(55);
}
b(int y){
...
y = c();
}
PC
c(){
int z = 23;
w = 77;
return z;
}
Globals
Globals
v = 0
w = 77
u = 0
v = 0
w = 77
u = 0
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
The need for threads Mutual exclusion The C execution model Context Switch
Execution of a C program
Stack
Code
Stack
Code
SP
Locals of a()
x = 9
Locals of b()
y = 23
a(){
int x;
x = 9;
w = 6;
b(55);
PC
b(int y){
...
y = c();
}
c(){
int z = 23;
w = 77;
return z;
}
SP
Locals of a()
x = 9
PC
a(){
int x;
b(int y){
c(){
int z = 23;
x = 9;
w = 6;
...
w = 77;
b(55);
y = c();
... return z;
}
}
}
}
Globals
Globals
v = 0
w = 77
u = 0
v = 0
w = 77
u = 0

The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
2 CPUs
What is it about
struct Params params;
Imagine we had 2 CPUs, then we could run two programs at the
same time!
One way of programming this in only 1 CPU is to keep track of 2
stack pointers and 2 program counters! How to do this is the
content of lecture 4.
The need for threads Mutual exclusion The C execution model Context Switch
What might a program look like
void controller_main() {
int dist, signal;
while(1){
dist = sonar_read();
control(dist,
&signal,
&params);
servo_write(signal);
}
}
void decoder_main() {
struct Packet packet;
while(1){
radio_read(&packet);
decode(&packet,&params);
}
}
We want to provide means for these two mains to execute
concurrently! As if we had 2 CPUs!
The need for threads Mutual exclusion The C execution model Context Switch
Introducing setjmp/longjmp (non-local goto)
Notice that the function spawn
takes a function as an argument!
The role of spawn is to provide
one extra Program Counter and
Stack Pointer
main(){
spawn(decoder_main);
controller_main();
}
We should also provide a way of
interleaving fragments of the
threads.
First we will introduce a way of
yielding execution so that another
thread can take over. Later we
will also see how this function
might be called.
#include
#include
jmp_buf bf;
main(int argc, char*argv[]){
int x = atoi(argv[1]);
while(1){
if( setjmp(bf) ) break;
f(argv[2],x);
}
printf("... Got here!\n\n");
}
void f(char * s, int n){
int y = n-1;
printf(s);
if(y==0) longjmp(bf,1) ;
else f(s, y);
}

The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
setjmp/longjmp
Using setjmp/longjmp
1 The type jmp buf is declared in the library . It is
known to be an array.
2 The operation setjmp(bf) saves the program counter and
the stack pointer to the jmp buf bf.
It returns 0.
3 The operation longjmp(bf,n) loads the content of bf to the
program counter and the stack pointer.
It returns n.
longjmp(bf,n) returns after the registers have been restored so it
looks as if it is setjmp(bf) that returns n!
jmp_buf buf;
Locals of a
x = 9
v =
a () {
int x, v;
...
}
The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Using setjmp/longjmp
Using setjmp/longjmp
jmp_buf buf;
jmp_buf buf;
Locals of a
a () {
Locals of a
a () {
x = 9
v = 0
int x, v;
x = 9
v = 0
int x, v;
...
...
v = setjmp(buf);
v = setjmp(buf);
...
b();
}
}

The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Using setjmp/longjmp
Using setjmp/longjmp
jmp_buf buf;
jmp_buf buf;
Locals of a
a () {
Locals of a
a () {
x = 9
v = 0
int x, v;
x = 9
v = 0
int x, v;
Locals of b
y = 2
...
v = setjmp(buf);
...
b () {
int y;
Locals of b
y = 2
...
v = setjmp(buf);
...
b () {
int y;
b();
...
b();
...
c();
}
}
}
}
The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Using setjmp/longjmp
Using setjmp/longjmp
jmp_buf buf;
jmp_buf buf;
Locals of a
a () {
Locals of a
a () {
x = 9
v = 0
int x, v;
x = 9
v = 0
int x, v;
Locals of b
y = 2
Locals of c
...
v = setjmp(buf);
...
b();
b () {
int y;
...
c();
c () {
int z;
...
Locals of b
y = 2
Locals of c
...
v = setjmp(buf);
...
b();
b () {
int y;
...
c();
c () {
int z;
...
longjmp(buf,7);
z = 23
}
}
}
z = 23
}
}
}

The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Using setjmp/longjmp
Using setjmp/longjmp
jmp_buf buf;
jmp_buf buf;
Locals of a
a () {
Locals of a
a () {
x = 9
v = 0
int x, v;
x = 9
v = 7
int x, v;
Locals of b
y = 2
Locals of c
...
v = setjmp(buf);
...
b();
b () {
int y;
...
c();
c () {
int z;
...
longjmp(buf,7);
...
v = setjmp(buf);
...
b();
b () {
int y;
...
c();
c () {
int z;
...
longjmp(buf,7);
z = 23
}
}
...
}
}
}
...
}
The need for threads Mutual exclusion The C execution model Context Switch
The need for threads Mutual exclusion The C execution model Context Switch
Using setjmp/longjmp for our purposes
The trick
setjmp(buf);
STACKPTR(buf) = malloc(...);
The macro STACKPTR will select the stack pointer part of the
buffer.
We assign to it the address of a new chunk of memory.
The size of this chunk of memory is the size of a function-call
stack frame.
This is very much platform dependent!
spawn will do the trick
setjmp(buf);
STACKPTR(buf) = malloc(...);
before calling the function to be executed. The function will then
run with its own stack!
After this, the context-switching between threads is just
setjmp(A);longjmp(B);
setjmp(B);longjmp(C);
setjmp(C);longjmp(A);

The need for threads Mutual exclusion The C execution model Context Switch
Completing the trick
We will have to keep track of the threads, so we introduce a data
structure describing a thread.
struct Thread_Block{
void (*fun)(int) // function to run
int arg; // argument to the above
jmp_buf context, // pc and sp
... // ...
};
typedef struct Thread_Block Thread
We will keep track of threads using global variables for
1 a queue of Threads: the ready queue
2 and the current thread.
Defining spawn
The need for threads Mutual exclusion The C execution model Context Switch
void spawn(void (*fun)(int), int arg){
Thread t = malloc(...);
t->fun = fun;
t->arg = arg;
if(setjmp(t->context)!=0){
// this will be done when a longjmp leads here:
current->fun(current->arg);
// What has to be done when the thread
// we spawn for fun terminates
}
// DO the stack pointer trick:
STACKPTR(t->context) = malloc(...);
// enqueue t in the ready queue!
}
The need for threads Mutual exclusion The C execution model Context Switch
The ready queue, the current thread and yield
Dispatch
The need for threads Mutual exclusion The C execution model Context Switch
Yielding control
By keeping the runnable threads
in a queue, we can define a
function yield() to switch
execution to another thread.
yield() must
enqueue the current thread in the ready queue
pick a new thread from the ready queue and make it the
current thread
perform the setjmp(A);longjmp(B); trick (also called
dispatch)
void dispatch(Thread next){
if(setjmp(current->context)==0){
current = next;
longjmp(next->context,1);
}
}
The function returns directly when control later enters via the fake
return from setjmp.