Task 1.2: Simple Threads Programming with Proper Synchronization- Modify your pr

Question

Task 1.2: Simple Threads Programming with Proper Synchronization-

Modify your program by introducing pthread mutex variables, so that accesses to the shared variable are properly synchronized. Try your synchronized version with the command line parameter set to 1, 2, 5, 10, 100 and 200.

Accesses to the shared variables are properly synchronized if (i) each iteration of the loop in SimpleThread() increments the variable by exactly one and (ii) each thread sees the same final value. It is necessary to use a pthread barrier [2] in order to allow all threads to wait for the last to exit the loop.

You must surround all of your synchronization-related changes with preprocessor commands, so that I can easily compile (with the gcc preprocessor option –Dmacro[=defn]) and get the version of your program developed in Task 1.1. E.g.,

for(num = 0; num < 20; num++) {

#ifdef PTHREAD _SYNC

/* put your synchronization-related code here */
#endif

val = SharedVariable;

printf("*** thread %d sees value %d ", which, val); SharedVariable = val + 1;

…….

}

One acceptable output of your program is (assuming 4 threads):                                

*** thread 0 sees value 0

*** thread 0 sees value 1
*** thread 0 sees value 2
*** thread 0 sees value 3
*** thread 0 sees value 4
*** thread 1 sees value 5
*** thread 1 sees value 6
*** thread 1 sees value 7
*** thread 1 sees value 8
*** thread 1 sees value 9
*** thread 2 sees value 10
*** thread 2 sees value 11
*** thread 2 sees value 12
*** thread 3 sees value 13
*** thread 3 sees value 14
*** thread 3 sees value 15

*** thread 3 sees value 16
*** thread 3 sees value 17
*** thread 2 sees value 18
*** thread 2 sees value 19
……

Thread 0 sees final value 80
Thread 2 sees final value 80
Thread 1 sees final value 80
Thread 3 sees final value 80

Explanation / Answer

#include <stdio.h>
#include <pthread.h>
#include <math.h>
#include <stdlib.h>

#define NUMTHREADS 4 // not sure if this is command line argument.

int SharedVariable = 0;
pthread_mutex_t lock;
pthread_barrier_t barr;

void threadFunc(void arg) {

int threadId = *((int*)arg);
int i;

// 20 is the number given in example
for(i = 0; i< 20; i++) {
// macro for compilation
#ifdef PTHREAD_SYNC
pthread_mutex_lock(&lock);
#endif
// incrementing shared variable
printf("thread %d sees value %d ", threadId, SharedVariable);
SharedVariable++;

#ifdef PTHREAD_SYNC
pthread_mutex_unlock(&lock);
#endif

}

// barrier so that all thread will read the shared variable value and display the final value.
pthread_barrier_wait(&barr);
printf("Thread %d sees final value %d ", threadId,SharedVariable);
return NULL;

}

int main() {

int i,err;
// NUMTHREADS is 4 as in the example.
// The question mentions nothing about the command line argument.
// if it is number of threads or number of iterations.
pthread_t threads[NUMTHREADS];
int threadIds[NUMTHREADS]={0};

// initialixing mutex.
pthread_mutex_init(&lock, NULL);
// initialixing barrier.
pthread_barrier_init(&barr, NULL, NUMTHREADS);

for(i = 0; i < NUMTHREADS; i++) {

// giving thread ids.
threadIds[i]=i;

// creating threads
err = pthread_create(&threads[i], NULL, threadFunc, (void*)&threadIds[i]);
if(err){
printf("ERROR creating THREADS, return code %d ",err);
exit(-1);
}
}

// waiting for all the threads to finish.
for(i = 0; i < NUMTHREADS; i++) {
pthread_join(threads[i], NULL);
}

return 0;
}

Sample output:

thread 1 sees value 0
thread 1 sees value 1
thread 1 sees value 2
thread 1 sees value 3
thread 1 sees value 4
thread 1 sees value 5
thread 1 sees value 6
thread 1 sees value 7
thread 1 sees value 8
thread 1 sees value 9
thread 1 sees value 10
thread 1 sees value 11
thread 1 sees value 12
thread 1 sees value 13
thread 1 sees value 14
thread 3 sees value 15
thread 3 sees value 16
thread 3 sees value 17
thread 3 sees value 18
thread 3 sees value 19
thread 3 sees value 20
thread 3 sees value 21
thread 3 sees value 22
thread 3 sees value 23
thread 3 sees value 24
thread 3 sees value 25
thread 3 sees value 26
thread 3 sees value 27
thread 3 sees value 28
thread 3 sees value 29
thread 3 sees value 30
thread 3 sees value 31
thread 3 sees value 32
thread 3 sees value 33
thread 3 sees value 34
thread 2 sees value 35
thread 2 sees value 36
thread 2 sees value 37
thread 2 sees value 38
thread 2 sees value 39
thread 2 sees value 40
thread 2 sees value 41
thread 2 sees value 42
thread 2 sees value 43
thread 2 sees value 44
thread 2 sees value 45
thread 2 sees value 46
thread 2 sees value 47
thread 2 sees value 48
thread 2 sees value 49
thread 2 sees value 50
thread 0 sees value 51
thread 0 sees value 52
thread 0 sees value 53
thread 0 sees value 54
thread 1 sees value 55
thread 2 sees value 56
thread 2 sees value 57
thread 1 sees value 58
thread 0 sees value 59
thread 0 sees value 60
thread 0 sees value 61
thread 0 sees value 62
thread 0 sees value 63
thread 0 sees value 64
thread 0 sees value 65
thread 0 sees value 66
thread 0 sees value 67
thread 0 sees value 68
thread 0 sees value 69
thread 0 sees value 70
thread 0 sees value 71
thread 0 sees value 72
thread 0 sees value 73
thread 1 sees value 74
thread 2 sees value 75
thread 2 sees value 76
thread 1 sees value 77
thread 1 sees value 78
thread 0 sees value 79
Thread 3 sees final value 80
Thread 0 sees final value 80
Thread 1 sees final value 80
Thread 2 sees final value 80

Related Questions

Navigate

• Browse (All)
• Browse T
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.