CMPS 105 Systems Programming. Prof. Darrell Long E2.371

Transcription

1 + CMPS 105 Systems Programming Prof. Darrell Long E2.371

2 + Chapter 12: Thread Control

3 + Thread Limits: Portability

4 + Thread Attributes n Thread attributes control the behavior of threads n Attribute objects n thread attributes n mutex attributes n etc n Thread control functions n Initialization function sets up attributes to default values n Destruction function frees attributes n Get attribute functions n Set attribute functions

5 + Thread Attributes: init and destroy n pthread_attr_init() - initializes attr with all the default thread attributes n int pthread_attr_init(pthread_attr_t* attr); n pthread_attr_destroy() destroys attr n int pthread_attr_destroy(pthread_attr_t* attr);

6 + Thread Attributes: n pthread_attr_setdetachstate() sets the detached state of a thread n int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); n Two legal values: n PTHREAD_CREATE_DETACHED n PTHREAD_CREATE_JOINABLE n pthread_attr_getdetachstate() gets the current detach-state attribute n int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

7 + Create a detached thread

8 + Thread Attributes: getstack, setstack n We have finite virtual address space n Each thread gets a stack in that address space n We may want to reduce/increase the default stack size n pthread_attr_setstack() set stack location and size n int pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t stacksize) n pthread_attr_getstack() get stack location and size n int pthread_attr_getstack(const pthread_attr_t* restrict attr, void** restrict stackaddr, size_t* restrict stacksize)

9 + Thread Attributes: getstacksize, setstacksize n If we want to change the default stack size: n pthread_attr_getstacksize() get the size of the thread s stack n int pthread_attr_getstacksize(const pthread_attr_t *restrict attr, size_t *restrict stacksize); n pthread_attr_setstacksize() set the size of the thread s stack n int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

10 + Thread Attributes: getguardsize, setguardsize n Memory guards are set up to keep stacks from running into one another, to manipulate the default guard values n pthread_attr_getguardsize() get current guard size n int pthread_attr_getguardsize(const pthread_attr_t* restrict attr, size_t* restrict guardsize); n pthread_attr_setguardsize() set current guard size n int pthread_attr_setguardsize(pthread_attr_t* attr, size_t* restrict guardsize);

11 + Synchronization Attributes n Mutex attributes n Reader-writer lock attributes n Condition variable attributes n Barrier attributes

12 + Mutex Attributes: init and destroy n Represented by pthread-mutexattr_t n Mutex attributes n Process-shared n Robust n Type n pthread_mutexattr_init() initializes mutex to default values n int pthread_mutexattr_init(pthread_mutexattr_t *attr); n pthread_mutexattr_destroy() destroy mutex attributes n pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

13 + Mutex Attributes: process-shared n Provide more efficient mutex implementation n PTHREAD_PROCESS_PRIVATE n pthread_mutexattr_getpshared() get process-shared attribute n int pthread_mutexattr_getpshared(const pthread_mutexattr_t* restrict attr, int* restrict pshared); n pthread_mutexattr_setpshared() set process-shared attribute n int pthread_mutexattr_setpshared(pthread_mutexattr_t* attr, int* restrict pshared);

14 + Mutex Attributes: Robust n Robust is for mutexes that are shared among processes n PTHREAD_MUTEX_STALLED no action taken when process terminates holding mutex (default) n PTHREAD_MUTEX_ROBUST make pthread_mutex_lock() return EOWNERDEAD instead of 0 n pthread_mutexattr_getrobust() get robust attribute n int pthread_mutexattr_getrobust(const pthread_mutexattr_t* restrict attr, int* restrict robust); n pthread_mutexattr_setrobust() set robust attribute n int pthread_mutexattr_setrobust(pthread_mutexattr_t* attr, int* restrict robust);

15 + Thread Attributes: Robust consistency n If we get an EOWNERDEAD from pthread_mutex_lock() we need to call: n pthread_mutex_consistent() Allows mutex to behave normally after it is unlocked n int pthread_mutex_consistent(pthread-mutex_t* mutex);

16 + Thread Attributes: gettype, settype n Type determines whether it can be locked again by a thread that owns it n Default type is normal n pthread_mutexattr_gettype() get mutex type n int pthread_mutexattr_gettype(const pthread_mutexattr_t* restrict attr, int* restrict type); n pthread_mutexattr_settype() set mutex type n int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int* type);

17 +

18 +

19 + Reader-Writer Locks Attributes n pthread_rwlockattr_init() Initialize attribute for readerwriter lock n int pthread_rwlockattr_init(pthread_rwlockattr_t* attr); n pthread_rwlockattr_destroy() Destroy attribute for readerwriter lock n int pthread_rwlockattr_destroy(pthread_rwlockattr_t* attr);

20 + RD/RW Lock Attributes: Process Shared n pthread_rwlockattr_getpshared() Get process-shared attribute n int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t* restrict attr, int* restrict pshared); n pthread_rwlockattr_setpshared() Set process-shared attribute n int pthread_rwlockattr_setpshared(pthread_rwlockattr_t* attr, int* pshared);

21 + Condition Variables n pthread_condattr_init() initialize condition variable attribute n int pthread_condattr_init(pthread_condattr_t* attr); n pthread_condattr_destroy() destroy condition variable attribute n int pthread_condattr_destroy(pthread_condattr_t* attr); n pthread_condattr_getpshared() get process shared attribute of conditional variable n int pthread_condattr_getpshared(const pthread_condattr_t* restrict attr, int* restrict pshared); n pthread_condattr_setpshared() set process shared attribute of conditional variable n int pthread_condattr_setpshared(pthread_condattr_t* attr, int pshared);

22 + Conditional Variables: Clocks n The clock attribute controls which clock is used for pthread_cond_timedwait() n pthread_condattr_getclock() get clock ID n int pthread_condattr_getclock(const pthread_condattr_t* restrict attr, int* restrict clock_id); n pthread_condattr_setpshared() set clock ID n int pthread_condattr_setclock(pthread_condattr_t* attr, int clock_id);

23 + Barrier Attributes n pthread_barrierattr_init() initialize barrier attribute n int pthread_barrierattr_init(pthread_barrierattr_t* attr); n pthread_barrierattr_destroy() destroy barrier attribute n int pthread_barrierattr_destroy(pthread_barrierattr_t* attr); n pthread_barrierattr_getpshared() get process shared attribute of barrier n int pthread_barrierattr_getpshared(const pthread_barrierattr_t* restrict attr, int* restrict pshared); n pthread_barrierattr_setpshared() set process shared attribute of barrier n int pthread_barrierattr_setpshared(pthread_barrierattr_t* attr, int pshared);

24 + Reentrant functions n A reentrant function can be interrupted in the middle of its execution and safely reentered again n A function is thread-safe if it can be called by multiple threads at the same time n A function is async-signal safe if it is safe to reenter it from an asynchronous signal handler

25 + Non Thread-Safe Functions

26 + File Locks n ftrylockfile() Check lock associated with given FILE n int ftrylockfile(file* fp); n flockfile() Lock given file n void flockfile(file* fp); n funlockfile() Unlock given file n void funlock(file* fp); n File lock is recursive, so locking while holding it does not cause a deadlock

27 + Character-at-a-time Locking n These functions should be surrounded by calls to flockfile() and funlockfile() n getchar_unlocked() get char from stdin n int getchar_unlocked(void); n getc_unlocked() get char from file fp n int getc_unlocked(file* fp); n putchar_unlocked() write char to stdout n int putchar_unlocked(int c); n putc_unlocked() write char to file fp n int putc_unlocked(int c, FILE* fp);

28 +

29 + Thread Specific Data n We may want to keep data specific to a thread, which is hard in a shared address space n why? n errono and other process based interfaces n keeping private data n We keep data private using a key: n pthread_key_create() Creates a key in order to store thread-private info n int pthread-key_create(pthread_key_t* keyp, void (*destructor) (void *)); n Destructor is called when thread exits

30 + Thread-Specific Data cont. n pthread_key_delete() Deletes key n int pthread_key_delete(pthread_key_t key); n Note: Calling pthread_key_delete() does not invoke the destructor n pthread_once() - solves race-conditions associated with keys n pthread_once_t initflag = PTHREAD_ONCE_INIT; n int pthread_once(pthread_once_t* initflag, void (*initfn)(void));

31 + Cancel Options n pthread_setcancelstate() changes cancelability state of thread n int pthread_setcancelstate(int state, int* oldstate); n PTHREAD_CANCEL_ENABLE n PTHREAD_CANCEL_DISABLE n pthread_testcancel() add cancellation points to program n int pthread_testcancel(void); n if a cancellation is pending it will cancel thread n unless cancellation is disabled

32 + Cancel Options n pthread_setcanceltype() set the type of cancellation of the thread n int pthread_setcancel(int type, int* oldtype); n Types: n PTHREAD_CANCEL_DEFERRED n PTHREAD_CANCEL_ASYNCHRONOUS

33 + Threads and Signals n Each thread has its own signal mask n Threads share signal disposition n All threads share signal handler actions n pthread_sigmask() examine and change blocked signal for a thread n int pthread_sigmask(int how, const sigset_t* restrict set, sigset_t* restrict oset);

34 + Threads and Signals n sigwait() wait for a signal n int sigwait(const sigset_t* restrict set, int* restrict signop); n pthread_kill() kill for threads n int pthread_kill(pthread_t thread, int signo);

35 + n pthread_atfork() establish fork handlers to clean up and lock state n pthread_atfork(void (*prepare),(void), void (*parent)(void), void (*child)(void)); n prepare handler is called in the parent before the fork n acquires all locks defined by parent n parent handler is called in the parent after the fork before the child has returned n unlocks all the clocks acquired by the prepare handler n child handler is called before the child returns n release all locks acquired by prepare handler