Introduc)on to pthreads. Shared memory Parallel Programming

Transcription

1 Introduc)on to pthreads Shared memory Parallel Programming

2 pthreads Hello world Compute pi pthread func)ons Prac)ce Problem (OpenMP to pthreads) Sum and array Thread-safe Bounded FIFO Queue

3 pthread Hello World #include <stdio.h> #include <stdlib.h> #include <pthread.h> int thread_count; void *hello(void *id) { long myid = (long) id; prinp("hello from thread %ld of %d\n", myid, thread_count); return NULL;

4 pthread Hello World int main(int argc, char *argv[]) { long i; pthread_t *threads; thread_count = atoi(argv[1]); threads = malloc(thread_count*sizeof(pthread_t)); for (i = 0; i < thread_count; i++) pthread_create(&(threads[i]), NULL, hello, (void *) i); prinp("hello from the main thread\n"); for (i = 0; i < thread_count; i++) pthread_join(threads[i], NULL); free(threads);

5 Compute Approxima)on of Pi // includes not shown #define MAXTHREADS 100 int numintervals; int localintervals; double width; int numthreads; pthread_t threads[maxthreads]; double par)alresults[maxthreads];

6 Main Func)on (part 1) int main(int argc, char**argv) { int i; double pi; numthreads = atoi(argv[1]); numintervals = atoi(argv[2]); //Assume numintervals is a mul)ple of numthreads localintervals = numintervals / numthreads; width = 1.0/numIntervals; for (i = 0; i < numthreads; i++) { pthread_create(&threads[i], NULL, ComputePi, (void *)i);

7 Main Func)on (part 2) for (i = 0; i < numthreads; i++) { pthread_join(threads[i], NULL); for (i = 0; i <numthreads; i++) { pi = par)alresults[i] + pi; prinp("pi = %1.20f\n", pi);

8 ComputePi (part 1) void * ComputePi(void *arg) { int myid; int i; int start; int stop; double midpoint; double sum; myid = (int) arg; sum = 0.0;

9 ComputePi (part 2) start = myid*localintervals; stop = start+localintervals; for (i = start; i < stop; i++) { midpoint = width * ((double) i - 0.5); sum = sum + f(midpoint); par)alresults[myid] = width * sum;

10 Basic pthread Rou)nes pthread_create pthread_exit pthread_join pthread_detach pthread_mutex_init pthread_mutex_destro y pthread_mutex_lock pthread_mutex_trylock pthread_mutex_unlock Pthread_cond_init Pthread_cond_destroy Pthread_cond_wait Pthread_cond_signal Pthread_cond_broadcast

11 pthread_create int pthread_create ( pthread_t *thread_handle, const pthread_alr_t *alribute, void * (*thread_func)on)(void *), void *arg); pthread_t mythread; pthread_alr_t alr; int myarg; pthread_create ( &mythread, &alr, myfunc)on, (void *) &myarg);

12 pthread_exit void pthread_exit(void *value_ptr); pthread_exit( (void *) & myretcode) Consider punng a pthread_exit call in main if some threads may be running when main completes

13 pthread_join int pthread_join(pthread_t thread, void **value_ptr) pthread_join( otherthread, &retcode) retcode is value returned by the call to pthread_exit otherthread must be joinable

14 pthread_detach int pthread_detach(pthread_t thread) pthread_detach(pthread_self()) When the thread exits the space associated with the thread state can be recovered

15 pthread_mutex_init int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexalr_t *alr) pthread_mutex_init(&mymutex, NULL)

16 pthread_mutex_lock int pthread_mutex_lock(pthread_mutex_t *mutex) pthread_mutex_lock(&mymutex);

17 pthread_mutex_trylock int pthread_mutex_trylock(pthread_mutex_t *mutex) status = pthread_mutex_trylock(&mymutex)

18 pthread_mutex_unlock int pthread_mutex_unlock(pthread_mutex_t *mutex) pthread_mutex_unlock(&mymutex)

19 pthread_cond_init int pthread_cond_init(pthread_cond_t *cond, const pthread_condalr_t *alr) pthread_cond_init(&mycondvar, NULL) A mutex should be used with each condi)on variable

20 pthread_cond_signal int pthread_cond_signal(pthread_cond_t *cond) pthread_cond_signal(&mycondvar)

21 pthread_cond_wait int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *mutex) pthread_cond_wait(&mycondvar, &mymutex) Unlocks mymutex and wait for a signal mymutex is locked when a signal is received

22 pthread_cond_broadcast int pthread_cond_broadcast(pthread_cond_t *cond) pthread_cond_broadcast(&mycondvar)

23 Translate the OpenMP Code Segment to pthreads //x is an array of ints, size is a power of 2 rounds = (int) log2( (double) size); for ( j = 1, k = 2; j <= rounds; j++, k = k*2) { numthds = size / k; #pragma omp parallel default(shared) private(i) num_threads(numthds) { i = omp_get_thread_num(); i = i*k; if (x[i] < x[i+k/2]) x[i] = x[i+k/2]; prinp("%d\n ", x[0]);

24 Find Sum Create threads to find the sum of a segment of an array of ints Combine the segment sums into a single sum

25 Global Declara)ons #include <stdio.h> #include <pthread.h> #define ARRAYSIZE 1000 #define NUMTHREADS 4 #define SEGMENTSIZE 250 int data[arraysize]; pthread_t threads[numthreads]; pthread_mutex_t mutex; int globalsum;

26 Main Func)on int main(int argc, char ** argv) { int i; int start[numthreads]; for (i = 0; i <ARRAYSIZE; i++) data[i] = i; //ar)ficial test data for (i = 0; i < NUMTHREADS; i++) start[i] = i*segmentsize; pthread_mutex_init(&mutex, NULL); for (i = 0; i < NUMTHREADS; i++) pthread_create(&threads[i], NULL, par)alsum, (void *) &start[i]); for (i = 0; i < NUMTHREADS; i++) pthread_join(threads[i], NULL); prinp("global Sum = %d\n", globalsum); pthread_mutex_destroy(&mutex); pthread_exit(null);

27 Par)alSum void * par)alsum(void * start) { int begin; int localsum; int i; begin = *(int *) start; localsum = 0; for (i = 0; i < SEGMENTSIZE; i++) localsum = localsum + data[i+begin]; pthread_mutex_lock(&mutex); globalsum = globalsum + localsum; pthread_mutex_unlock(&mutex); pthread_exit(null);

28 Par)al Sum Modifica)on Modify the Par)al Sum program so it does not use a mutex. Use pthread_exit to return the local sum to the main program.

29 Shared Bounded Queue Implements a thread safe FIFO bounded queue Assumes one thread creates the queue and only one thread destroys the queue Func)ons implemented CreateQueue DestroyQueue insert delete

30 Queue.h (part 1) //includes not shown struct Queue { ; pthread_mutex_t mutex; pthread_cond_t notempty; pthread_cond_t notfull; void ** items; int maxsize; int currentsize; int front; int rear;

31 Queue.h (part 2) struct Queue *CreateQueue(int size); void insert(struct Queue *q, void *d); void delete(struct Queue *q, void **d); void DestroyQueue(struct Queue*q);

32 CreateQueue struct Queue *CreateQueue(int size) { struct Queue *q; ; q = (struct Queue *) malloc(sizeof(struct Queue)); q->maxsize = size; q->currentsize = 0; q->front = 0; q->rear = 0; q->items = (void **) malloc(size*sizeof(void *)); pthread_mutex_init(&q->mutex, NULL); pthread_cond_init(&q->notempty, NULL); pthread_cond_init(&q->notfull, NULL); return q;

33 Insert void insert(struct Queue *q, void *d) { pthread_mutex_lock(&q->mutex); while (q->currentsize == q->maxsize) { pthread_cond_wait(&q->notfull, &q->mutex); q->items[q->rear] = d; q->rear = (q->rear+1)%q->maxsize; q->currentsize++; pthread_cond_signal(&q->notempty); pthread_mutex_unlock(&q->mutex);

34 Delete void delete(struct Queue *q, void **d) { pthread_mutex_lock(&q->mutex); while (q->currentsize == 0) { pthread_cond_wait(&q->notempty, &q->mutex); *d = q->items[q->front]; q->front = (q->front+1)%q->maxsize; q->currentsize--; pthread_cond_signal(&q->notfull); pthread_mutex_unlock(&q->mutex);

35 Producer/Consumer Example Revisited Producer/Consumer example using a shared queue The producers produce posi)ve integers The consumer sums the integers it consumes When the consumer gets a -1 it quits and returns the sum it computed to the main thread

36 Producer void * producer(void * arg) { int i; int *j; struct Queue *q = (struct Queue *) arg; for (i = 0; i < 1000; i++) { j = (int *) malloc(sizeof(int)); *j = i; insert (q, (void *) j); pthread_exit(null);

37 Consumer (part 1) void *consumer(void * arg) { bool done; int sum =0; int *retval; int *j; struct Queue *q = (struct Queue *) arg; done = false;

38 Consumer (part 2) while(!done) { delete(q, (void **) &j); if (*j == -1) else done = true; sum = sum + *j; retval = (int *) malloc(sizeof(int)); *retval = sum; pthread_exit( (void *) retval);

39 Main (part 1) int main(int argc, char **argv) { int *retval; struct Queue *q; int numprods; int numcons; pthread_t prods[maxprods]; pthread_t cons[maxcons]; int sum; int i; int *j; numprods = atoi(argv[1]); numcons = atoi(argv[2]); q = CreateQueue(10);

40 Main (part 2) for (i = 0; i < numprods; i++) { pthread_create(&prods[i], NULL, producer, (void *) q); for (i = 0; i < numcons; i++) { pthread_create(&cons[i], NULL, consumer, (void *) q); for (i = 0; i <numprods; i++) { pthread_join(prods[i], NULL);

41 Main (part 3) for (i = 0; i <numcons; i++) { j = (int *) malloc(sizeof(int)); *j = -1; insert (q, (void *) j); for (i = 0; i <numcons; i++) { pthread_join(cons[i], (void **) &retval); sum = sum + (int) *retval; prinp("total %d\n", sum); DestroyQueue(q);

42 Prac)ce Problem pthread Version struct Args { int thread_num; int k; ; void *compare(void * args) { struct Args *a = (struct Args *) args; int k = a->k; int i = a->thread_num * k; if (x[i] < x[i+k/2]) x[i] = x[i+k/2]; pthread_exit(null);

43 Prac)ce Problem pthread Version rounds = (int) log2( (double) size); for ( j = 1, k = 2; j <= rounds; j++, k = k*2) { numthds = size / k; for (i = 0; i < numthds; i++) { args = (struct Args *) malloc(sizeof(struct Args)); args->thread_num = i; args->k = k; pthread_create(&threads[i], NULL, compare, (void *) args); for (i = 0; i < numthds; i++) pthread_join(threads[i], NULL); prinp("%d\n ", x[0]);