1 / 17

Pthreads

Pthreads. #include <pthread.h> #include <stdio.h> int sum ; //global data shared by all threads void *sum_dog (void *) ; //thread signature main(int argc, char *argv[]) { pthread_t tid ; // thread identifier

rasha
Télécharger la présentation

Pthreads

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Pthreads #include <pthread.h> #include <stdio.h> 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, argv[1]) ; // 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 ; i< 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 <pthread.h> #include <stdio.h> 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, argv[1]) ; // create the thread. Now two pthread_create(&tid1, &attr, sum_dog, argv[1]) ; // 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 ; i< 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 <pthread.h> 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 buffer[in] = 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 = buffer[out]; 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 = 5}S1: 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

More Related