Pthreads

1
Pthreads

• include ltpthread.hgt
• include ltstdio.hgt
• int sum //global data shared by all threads
• void sum_dog (void ) //thread signature
• main(int argc, char argv)
• pthread_t tid // thread identifier
• pthread_attr_t attr // set of attributes
  for the thread. E.g., stack size, scheduling
  //attributes, etc.
• pthread_attr_init (attr) // get default
  attributes
• pthread_create(tid, attr, sum_dog,
  argv1) // create the thread. Now two
  //threads executing concurrently.
• compute_some_stuff()
• pthread_join (tid, NULL) //wait for thread
  to exit before continuing
• printf(Sum_dog has spoken d\n, sum)

2
void sum_dog(void param) int puppy_upper,
i puppy_upper atoi(param) //string to
int. for (i 0 ilt puppy_upper i)
sum i pthread_exit(0)
3
Shared Data

• All threads share
• Global variables
• Static variables in function in which they are
  created.
• Local variables are private to threads.
• In program sum is shared by the main thread and
  the spawned thread.
• Local variables i, and puppy_upper are private to
  the spawned thread.

4
Pthreads

• include ltpthread.hgt
• include ltstdio.hgt
• int sum //global data shared by all threads
• void sum_dog (void ) //thread signature
• main(int argc, char argv)
• pthread_t tid, tid1 // thread identifier
• pthread_attr_t attr // set of attributes
  for the thread. E.g., stack size, scheduling
  //attributes, etc.
• pthread_attr_init (attr) // get default
  attributes
• pthread_create(tid, attr, sum_dog,
  argv1) // create the thread. Now two
• pthread_create(tid1, attr, sum_dog,
  argv1) // create the thread. Now three
  //threads executing concurrently.
• compute_some_stuff()
• pthread_join (tid, NULL) //wait for thread
  to exit before continuing
• printf(Sum_dog has spoken d\n, sum)

5
void sum_dog(void param) int puppy_upper,
i static int x 0 puppy_upper
atoi(param) //string to int. for (i 0
ilt puppy_upper i) sum i
pthread_exit(0)
6
Pthread 2
Main Thread
Pthread 1
CPU
7
Shared Among all Threads
sum
Sum_Dog
Sum_Dog1
Main Thread
Shared between thread functions.
x
Private copy for each Sum_Dog function.
Puppy_Upper
i
8
Producer-Consumer Problem

• Paradigm for cooperating processes (threads),
  producer process produces information that is
  consumed by a consumer process.
• unbounded-buffer places no practical limit on the
  size of the buffer.
• bounded-buffer assumes that there is a fixed
  buffer size.

9
Constraints

• Do not over-write an item not yet consumed.
• Do not write to a full buffer
• Do not read from a previously read item.
• Do not read from an empty buffer.

10
in 1 counter 1
Producer
X
Consumer
out 0
11
in 2 counter 2
Producer
X X
Consumer
out 0
12
in 2 counter 1
Producer
x
Consumer
out 1
13
in 3 counter 2
Producer
x x
Consumer
out 1
14
Thread-based Producer/Consumer

• include ltpthread.hgt
• int counter 0, BUFFER_SIZE 10 /shared
  between threads
• void Producer(void NULL)
• int in 0
• while (1)
• while (counter BUFFER_SIZE) // do nothing,
  busy wait
• // produce an item and put in nextProduced
• bufferin nextProduced
• in (in 1) BUFFER_SIZE
• counter

15

• void Consumer (void NULL)
• int out 0
• while (1) while (counter 0) // do
  nothing, busy wait
• nextConsumed bufferout
• out (out 1) BUFFER_SIZE
• counter--
• // consume the item in nextConsumed

16

• Executed Separately work as expected.
• Execute concurrently, causes race condition.

17

• Consider this execution interleaving
• S0 producer execute register1 counter
  register1 5S1 producer execute register1
  register1 1 register1 6 S2 consumer
  execute register2 counter register2 5
  S3 consumer execute register2 register2 - 1
  register2 4 S4 producer execute counter
  register1
• counter 6 S5 consumer execute counter
  register2 counter 4

Preempted