PThreads

Question 1

What does this code do?

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; /* mutex lock for buffer /
pthread_cond_t c_cons = PTHREAD_COND_INITIALIZER; / consumer waits on this cond var /
pthread_cond_t c_prod = PTHREAD_COND_INITIALIZER; / producer waits on this cond var */

Answer 1

Initializes the following:

• pthread mutex
• pthread conditional variable c_cons
• pthread conditional variable c_prod

Question 2

What does this block of code do?

pthread_t tid1, tid2;  /* thread identifiers */
int i;

if(pthread_create(&tid1, NULL, producer, NULL) != 0) {
	fprintf(stderr, "Unable to create producer thread\n");
	exit(1);
}

if(pthread_create(&tid2, NULL, consumer, NULL) != 0) {
	fprintf(stderr, "Unable to create consumer thread\n");
	exit(1);
}

Answer 2

The code creates 2 threads

one thread is identified as tid1

one thread is identified as tid2

one thread runs the function producer

one thread runs the function consumer

Question 3

What does this code do?

pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
printf("Parent quiting\n");

Answer 3

The code waits for the created threads to exit

The code actually joins the threads. “Joining” is one way to accomplish synchronization between threads.

Question 4

What does the consumer code do?

int i;

while(1) {

	pthread_mutex_lock (&m);
		if (num < 0) {
			exit(1);
		} /* underflow */

		while (num == 0) {  /* block if buffer empty */
			pthread_cond_wait (&c_cons, &m);
		}

			/* if executing here, buffer not empty so remove element */
			i = buffer[rem];
			rem = (rem+1) % BUF_SIZE;
			num--;
		pthread_mutex_unlock (&m);

	pthread_cond_signal (&c_prod);
	printf ("Consume value %d\n", i);  fflush(stdout);

}

Answer 4

• it runs the while loop forever or until the num var is less than 0
• Inside the while loop:
  1. Acquires the mutex lock (mutex m)

2. Blocks if the buffer is empty by performing a blocking wait for a signal: pthread_cond_wait
3. The critical section of the mutex performs the following:
   - waits for the signal on c_cons variable
   - remove the next global buffer element
   - decrement the num variable
4. Unlock the mutex
5. call pthread_cond_signal to send a signal on the c_prod variable that the buffer is not full (waiting in the producer variable)

Question 5

What does this producer code do?

int i;
for (i=1; i<=20; i++) {

	pthread_mutex_lock (&m);	
		if (num > BUF_SIZE) {
			exit(1);  /* overflow */
		}

		while (num == BUF_SIZE) {  /* block if buffer is full */
			pthread_cond_wait (&c_prod, &m);
		}

		buffer[add] = i;
		add = (add+1) % BUF_SIZE;
		num++;
	pthread_mutex_unlock (&m);

	pthread_cond_signal (&c_cons);
	printf ("producer: inserted %d\n", i);
	fflush (stdout);
}

Answer 5

the producer code does the following:

• loops from 1 to 20
• acquires the mutex lock

What critical section code does:

• exits if the num is greater than the BUF_SIZE var
• blocks the buffer is full –> pthread_cond_wait on c_prod var
• adds an element to the global buffer
• increases the num var

-unlocks the mutex

• sends signal to consumer that buffer is not empty
  pthread_cond_signal on var c_cons

repeats loop

Question 6

How are threads terminated?

Answer 6

pthread_exit()

pthread_cancel() (cancelled by another thread)

Calls to exec() or exit() which kills entire process and kills the threads

If main() finishes first

Question 7

How do you detach a thread?>

Answer 7

pthread_detach()

Question 8

What is the pthread struct?

Answer 8

pthread_t

Question 9

What is the struct for the pthread attribute? How do you initialize it? What does it specify?

Answer 9

pthread_attr_t

pthread_attr_t attr;
pthread_attr_init(&attr);

Specifies the following:
- defines the features of a new thread
such as stack size, joinable, priority, inheritance, scheduling policy, system/process scope

Default are joinable threads

Question 10

Difference between joinable and detached threads:

Answer 10

Joinable:
- parent creates children threads
- children threads rejoin parent
if the parent exits earlier than the children threads, there are zombie threads

Detached:

• parent thread creates children threads
• the children threads do work and then are detached
• this indicates storage for the thread can be reclaimed when that thread terminates

Question 11

What does the following code do?

#include 
#include 

void *foo (void arg) { / thread main */
printf(“Foobar!\n”);
pthread_exit(NULL);
}

int main (void) {

int i;
pthread_t tid;

pthread_attr_t attr;
pthread_attr_init(&attr); // Required!!!
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, foo, NULL);

return 0; }

Answer 11

• includes the pthread header to include pthread functionality
• foo function is the routine for each of the threads which prints Foobar
• Inside main:
• thread var is initialized
• attr var is initialized
• pthread_attr_init is called to initialize attributes
• pthread_attr_setdetachstate creates threads as detached
• sets the system scope
• creates the thread with the routine of function foo and with the attributes set

Question 12

What is the purpose of pthread conditional variables?

Answer 12

• condition variables are synchronization constructs which allow blocked threads to be notified once a specific condition occurs
• Wait, signal, and broadcast that can be performed on condition variables
• PThreads has pthread condition signal and pthread condition broadcast, that we can use to either notify one thread that’s waiting on a condition variable using the signal operation, or to notify all threads that are waiting on a condition variable using the pthread condition broadcast operation.

Question 13

What does the following do?

pthread_attr_destroy(&attr);
pthread_mutex_destroy(&count_mutex);
pthread_cond_destroy(&count_threshold_cv);
pthread_exit (NULL);

Answer 13

Destroys the following:

• pthread attribute
• count_mutex
• conditional variable count_threshold_cv
• exits the pthread_exit