Posix Threads (Pthreads)

Transcription

1 Posix Threads (Pthreads) Reference: Programming with POSIX Threads by David R. Butenhof, Addison Wesley, 1997

2 Threads: Introduction main: startthread( funk1 ) startthread( funk1 ) startthread( funk2 ) wait exit main wait exit funk1 funk1 funk2 exit exit exit

3 Threads: Advantages Intuitive Modeling True parallelization Server Wait for connection Launch thread Client 1 Client 2 Client 3 Client processing... Client processing... Client processing

4 Threads: Synchronization Race conditions: Object to process Processing Thread Assembly Thread 1. Object not ready for processing 4. Wait for signal 2. Place object 3. Signal object ready for processing

5 Threads: Synchronization Deadlocks: Thread 1 Thread 2 1. Seize object A 3. Seize object B... Release object A Release object B 2. Seize object B 4. Seize object A... Release object B Release object A

6 Threads: Reentrancy Thread 1 process( /etc/data/results.txt ) Thread 2 process( /tmp/data.txt ) process( param ) 1. token = strtok( param ) 6. while ( token!= NULL ) token = strtok( NULL ) process( param ) 2. token = strtok( param ) 3. while ( token!= NULL ) token = strtok( NULL )

7 Pthreads: pthread_create typedef void *START_PROC_t( void * ); typedef START_PROC_t *START_PROC_p_t; int pthread_create( pthread_t *thread, const pthread_attr_t *attr, START_PROC_p_t start_proc, void *arg ); thread pointer to thread ID storage attr pointer to thread attributes object; may be NULL thread pointer to work function arg argument to pass to work function returns: 0 for success, non 0 for error

8 Pthreads: pthread_create Example static START_PROC_t funk1; int main( int argc, char **argv ) { pthread_t tid1; int arg1 = 1; status = pthread_create( &tid1, NULL, funk1, &arg1 ); if ( status!= 0 )... return 0; }

9 Pthreads: pthread_join int pthread_join(pthread_t thread, void **retval); Waits for a thread to terminate; returns immediately if thread has already terminated. thread ID of thread to join retval pointer to storage for joined thread s return value; may be NULL returns: 0 for success, non 0 for error

10 Pthreads: pthread_join, Example int main( int argc, char **argv ) { pthread_t tid1; int arg1 = 1; status = pthread_create( &tid1, NULL, funk1, &arg1 ); if ( status!= 0 )... status = pthread_join( tid1, NULL ); if ( status!= 0 )... return 0; }

11 Pthreads: pthread_cancel int pthread_cancel(pthread_t thread); Gracefully terminates a thread. thread The thread to terminate. Returns: 0 if successful, non zero otherwise.

12 Pthreads: pthread_cancel, Example int main( int argc, char **argv ) { pthread_t tid1; int arg1 = 1; status = pthread_create( &tid1, NULL, funk1, &arg1 ); if ( status!= 0 )... sleep( 60 ); status = pthread_cancel( tid1 ); if ( status!= 0 )... return 0; }

13 pth_util.h /************** BEGIN SPECIAL CONDITION: STATUS ******************** * To use any of the following macros you must first define variable * 'int status.' This is less than ideal, but we'll go with it for * now. */ #define PTH_CREATE( p1, p2, p3, p4 ) \ ((status = pthread_create( (p1), (p2), (p3), (p4) )) == 0? (void)0 : \ PTH_err( status, "pthread_create", FILE, LINE ) \ ) #define PTH_CANCEL( p1 ) \ ((status = pthread_cancel( (p1) )) == 0? (void)0 : \ PTH_err( status, "pthread_cancel", FILE, LINE ) \ )... /************** END SPECIAL CONDITION: STATUS ********************/

14 pth_util.c void PTH_err( int status, const char *msg, const char *file, int line ) { const char *status_str = strerror( status ); fprintf( stderr, "Error %d (%s); %s in %s at line %d\n", status, status_str, msg, file, line ); abort(); }

15 Exercise 1. From the class website download pth_utils.h, pth_utils.c and thread_exercise1.c. 2. Complete the code in thread_exercise1.c. This will create three threads that separately add the numbers between 1 and 1,000,000; 1,000,0001 and 2,000,000; and 2,000,001 and 3,000,000,000 then combine the results. 3. Add PTH_EXIT (which invokes pthread_exit) to pth_utils.h.

16 Threads: Mutexes A mutex is an object that is used for thread synchronization. mutex_a Thread 1 process( /etc/data/results.txt ) Thread 2 process( /tmp/data.txt ) process( param ) 1. sieze mutex_a 3. token = strtok( param ) 4. while ( token!= NULL ) token = strtok( NULL ) 7. release mutex_a process( param ) 2. sieze mutex_a (wait) 8. token = strtok( param ) 9. while ( token!= NULL ) token = strtok( NULL ) 12. release mutex_a

17 Pthreads: pthread_mutex_init int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ); mutex Pointer to storage for a mutex identifier. attr Pointer to a mutex attributes object; may be NULL. returns: 0 if successful, non zero otherwise

18 Pthreads: PTHREAD_MUTEX_INITIALIZER This macro may be used to initialize static mutexes: static pthread_mutex_t mutex_ = PTHREAD_MUTEX_INITIALIZER; No error checking is performed.

19 Pthreads: pthread_mutex_destroy int pthread_mutex_destroy( pthread_mutex_t *mutex ); mutex Pointer to storage for a mutex identifier. returns: 0 if successful, non zero otherwise Do not try to destroy an uninitialized mutex. Do not try to destroy a locked mutex. Once a mutex has been destroyed it may be reinitialized.

20 Pthreads: Mutex Locking/Unlocking int pthread_mutex_lock( pthread_mutex_t *mutex ); Sieze a mutex; if the mutex is already locked wait until it is unlocked. int pthread_mutex_trylock( pthread_mutex_t *mutex ); Sieze a mutex; if the mutex is already locked return immediately with a status of EBUSY. int pthread_mutex_unlock( pthread_mutex_t *mutex ); Release a mutex; do not try to release an unlocked mutex. Return: 0 if success, non zero otherwise.

21 Pthreads: pthread_mutexattr_t int pthread_mutexattr_init(pthread_mutexattr_t *attr); Initialize a Pthread mutex attrbutes object. int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); Destroy a Pthread mutex attrbutes object. int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type); Set the type of a Pthread mutex object. attr Pointer to Pthread mutex attributes object storage. type Type of a Pthread mutex object.

22 Pthreads: Mutex Type PTHREAD_MUTEX_NORMAL Recursive acquistion of a mutex will result in a deadlock. Attempting to unlock a mutex owned by another thread will result in undefined behavior. PTHREAD_MUTEX_ERRORCHECK Attempted recursive acquistion of a mutex will return a status of EDEADLK. Attempting to unlock a mutex owned by another thread will return a status of EPERM. PTHREAD_MUTEX_RECURSIVE Recursive acquistion of a mutex is allowed. Attempting to unlock a mutex owned by another thread will return a status of EPERM. PTHREAD_MUTEX_DEFAULT Recursive acquistion of a mutex will result in undefined behavior. Attempting to unlock a mutex owned by another thread will result in undefined behavior. This functionality may not be available on all systems; check your documentation.

23 Pthreads: Mutex Type, Example static void init_mutex( void ) { pthread_mutexattr_t attrs; int status; } status = pthread_mutexattr_init( &attrs ); if ( status!= 0 ) err( status, "pthread_mutexattr_init" ); status = pthread_mutexattr_settype( &attrs, PTHREAD_MUTEX_ERRORCHECK ); if ( status!= 0 ) err( status, "pthread_mutexattr_settype" ); status = pthread_mutex_init( &mutex_var_, &attrs ); if ( status!= 0 ) err( status, "pthread_mutex_init" ); status = pthread_mutexattr_destroy( &attrs ); if ( status!= 0 ) err( status, "pthread_mutexattr_destroy" );

24 Pthreads: Mutex Type, Example (cont d) static void cleanup( void ) { int status = pthread_mutex_destroy( &mutex_var_ ); if ( status!= 0 ) err( status, "pthread_mutex_destroy" ); }

25 Exercise 1. Write and test the function int get_random_int( int min, int max ). This function uses the function rand() (declared in stdlib.h) to generate and return a random integer between min and max, inclusive. The algorithm for doing this is given by: rand() % (max min + 1) + min 2. Write a program, mutex_exercise, with a counter and two threads: One thread increments the counter up to a maximum value of 5, reports the counter value (via printf()) and sleeps for a random number of seconds no less than 2 and no more than 5. The other thread decrements the counter to a minimum value of 0, reports the counter value and sleeps for a random number of seconds no less than 1 and no more than 4. Use a mutex to ensure that the two threads do not try to adjust the counter or report its value at the same time.

26 Threads: Sometimes a Mutex is Not Enough Object to process Processing Thread 1. Seize mutex 2. Object not ready for processing 3. Release mutex 8. Wait for signal mutex_a Assembly Thread 4. Seize mutex 5. Place object 6. Signal object ready for processing 7. Release mutex

27 Pthreads: Condition Variables Condition variables allow you to release a mutex and initiate a wait as an atomic process. Object to process Processing Thread 1. Seize mutex 2. Object not ready for processing 3. Wait on condition via mutex mutex_a cond_a Assembly Thread 4. Seize mutex 5. Place object 6. Signal object ready for processing 7. Release mutex

28 Pthreads: pthread_cond_init int pthread_mutex_init( pthread_cond_t *cond, const pthread_condattr_t *attr ); cond Pointer to storage for a condition variable identifier. attr Pointer to a condition variable attributes object; may be NULL. returns: 0 if successful, non zero otherwise

29 Pthreads: PTHREAD_COND_INITIALIZER This macro may be used to initialize static condition variables: static pthread_cond_t cond_ = PTHREAD_COND_INITIALIZER; No error checking is performed.

30 Pthreads: pthread_cond_destroy int pthread_cond_destroy( pthread_cond_t *cond ); cond Pointer to storage for a condition variable identifier. Returns: 0 if successful, non zero otherwise Do not try to destroy an uninitialized condition variable. Do nottry to destroy a blocking condition variable. Once a condition variable has been destroyed it may be reinitialized.

31 Pthreads: Using Condition Variables int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); Release mutex, block on cond. int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); Release mutex, block on cond for at most abstime. int pthread_cond_signal(pthread_cond_t *cond); Unblock at least one thread waiting on cond. int pthread_cond_broadcast(pthread_cond_t *cond); Unblock all threads waiting on cond.! A condition variable always wakes with its mutex locked. Return: 0 on success, non 0 otherwise. pthread_cond_timedwait returns ETIMEDOUT in the case of a time out.

32 Pthreads: Condition Variable Example Baker Thread bake_pie(); while ( 1 ) { bool bake_another = false; PTH_MUTEX_LOCK( &mutex_ ); if ( num_pies_ < max_pies_ ) { ++num_pies_; bake_another = true; PTH_COND_SIGNAL( &driver_cond_ ); } else PTH_COND_WAIT( &baker_cond_, &mutex_ ); PTH_MUTEX_UNLOCK( &mutex_ ); if ( bake_another ) bake_pie(); } 1. Bake a pie. 2. Lock If there s room in the queue: a) Add the pie to the queue. b) Signal the driver. 4. If there s no room in the queue: a) wait 5. Unlock If possible, bake another pie.

33 Pthreads: Condition Variable Example (cont.) Driver Thread while ( 1 ) { bool deliver = false; PTH_MUTEX_LOCK( &mutex_ ); if ( num_pies_ > 0 ) { --num_pies_; deliver = true; PTH_COND_SIGNAL( &baker_cond_ ); } else PTH_COND_WAIT( &driver_cond_, &mutex_ ); PTH_MUTEX_UNLOCK( &mutex_ ); if ( deliver ) deliver_pie(); } 1. Lock If a pie is in the queue: a) Remove it from the queue. b) Signal the baker. 3. If no pie is waiting a) Wait 4. Unlock If necessary, deliver the pie

34 Exercises 1. Add the macro PTH_COND_TIMEDWAIT (which invokes pthread_cond_timedwait) to pth_utils.h. 2. Modify mutex_exercise so that: It contains a condition variabe When the incrementing thread successfully increments the counter it signals the condition variable; if it can t increment the counter it waits on the condition variable. When the decrementing thread successfully decrements the counter it signals the condition variable; if it can t decrement the counter it waits on the condition variable.

35 Pthreads: pthread_once typedef void ONCE_PROC_t( void ); typedef ONCE_PROC_t *ONCE_PROC_p_t; int pthread_once( pthread_once_t *control, ONCE_PROC_p_t init_proc ); For performing global initialization once. control Variable to control initialization; MUST be statically allocated, MUST be initialized with PTHREAD_ONCE_INIT. init_proc Address of initialization function. Returns: 0 for success, non zero otherwise.

36 Pthreads: pthread_once, Example int main( int argc, char **argv ) { int status; PTH_CREATE( &thr1_, NULL, thr_start, NULL ); PTH_CREATE( &thr2_, NULL, thr_start, NULL ); PTH_CREATE( &thr3_, NULL, thr_start, NULL );... } static void init( void ) { puts( "init starting" ); // perform global initialization here puts( "init ending" ); } static void *thr_start( void *arg ) { static pthread_once_t init_once = PTHREAD_ONCE_INIT; int status; PTH_ONCE( &init_once, init );... } Output: init starting init ending

37 Pthreads: Mutex Attributes See: pthread_mutexattr_setpshared; PTHREAD_PROCESS_SHARED: allow mutexes to control threads in multiple processes. PTHREAD_PROCESS_PRIVATE: mutexes may not be accessed outside the initializing process. See: pthread_mutexattr_setprioceiling; Sets the maximum priority for the critical section guarded by a mutex. See: pthread_mutexattr_setprotocol; Controls the priority and scheduling of threads that own the target mutex. Systems are not required to implement this functionality; check your documentation.

38 Pthreads: Condition Variable Attributes See: pthread_condattr_setpshared; PTHREAD_PROCESS_SHARED: allow a condition variable to control threads in multiple processes. PTHREAD_PROCESS_PRIVATE: condition variables may not be accessed outside the initializing process. Systems are not required to implement this functionality; check your documentation.

39 Pthreads: Thread Attributes See: pthread_attr_setdetachstate pthread_attr_setguardsize pthread_attr_setinheritsched pthread_attr_setschedparam pthread_attr_setschedpolicy pthread_attr_setscope pthread_attr_setstackaddr pthread_attr_setstacksize Systems are not required to implement all of this functionality; check your documentation.