Question

Debugging and testing multithreaded programs is made more difficult compared to dealing with single-threaded programs by:

1. the necessity to divide activities into separate and concurrent tasks

2. the existence of many more different execution paths made possible by parallel thread execution

3. multithreading library APIs with confusing semantics

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Consider the following code that creates N threads using the POSIX threading library. The thread function threadFun receives as parameter a thread index (from 0 to N-1).

#define NTHREADS 4 // number of test threads
void* threadFun(void* p) {
    LINE A
     // remainder of the function is irrelevant for this question
}
void main() {
  int i;
  pthread_t tid[N]; 
  pthread_attr attr;
  pthread_attr_init(&attr);
  for (i=0; i

What is the right set of statements for LINE A and LINE B that correctly initialize the thread index variable from 0 to N-1, regardless of the timing of each thread's scheduling? HINT: watch for memory that can be modified inadvertently by other threads.

1.

LINE A: index = *(int)p;

LINE B: pthread_create(&tid[i], &attr, threadFun, &i);

2.

LINE A: index = (int)*p;

LINE B: pthread_create(&tid[i], &attr, threadFun, (void*)i);

3.

LINE A: index = (int)p;

LINE B: pthread_create(&tid[i], &attr, threadFun, (void*)i);

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

What kind of thread cancellation is demonstrated in the threadFun() thread function? int done = 0; // global variable // the thread function void* threadFun(void* p) { ... while (! done) { ... // do some work } pthread_exit(0); }

1. deferred cancellation

2. loop cancellation

3. forceful cancellation

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

What does NOT belong specifically to a thread, but is shared by all threads of a process (pick one or more):

1. data section

2. stack

3. program counter

4. contents of the general purpose registers

5. heap

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

What is NOT an advantage of using a thread pool to implement a multithreaded application?

1. The thread pool size can be adjusted based on demand from concurrent requests.

2. Using an existing thread to service a request takes less time than waiting to create a new thread.

3. Threads in the pool share a common request queue that requires synchronized access.

Answer 1

1. = Option 2

Debugging and testing multithreaded programs is made more difficult compared to dealing with single-threaded programs by the existence of many more different execution paths made possible by parallel thread execution.

2. = option A

LINE A: index = *(int)p;

LINE B: pthread_create(&tid[i], &attr, threadFun, &i); is the correct answer.

3 = Loop Cancellation

Loop Cancellation is the type of  thread cancellation is demonstrated in the threadFun() thread function? int done = 0; // global variable // the thread function void* threadFun(void* p) { ... while (! done) { ... // do some work } pthread_exit(0); }

4. Option A = Data Section and Program Counter

Options A and D

These are the options that NOT belong specifically to a thread, but is shared by all threads of a process

5.Option C

Threads in the pool share a common request queue that requires synchronized access is one of the not an advantages.