2005 Sun Microsystems, Inc Network Circle, Santa Clara, CA U.S.A. Sun Sun Berkeley BSD UNIX X/Open Company, Ltd. / Sun Sun Microsystems Su

Transcription

1 Sun Microsystems, Inc Network Circle Santa Clara, CA U.S.A

2 2005 Sun Microsystems, Inc Network Circle, Santa Clara, CA U.S.A. Sun Sun Berkeley BSD UNIX X/Open Company, Ltd. / Sun Sun Microsystems Sun docs.sun.com AnswerBook AnswerBook2 Solaris Sun Microsystems, Inc. / SPARC SPARC International, Inc. / SPARC Sun Microsystems, Inc. OPEN LOOK Sun TM Sun Microsystems, Inc. Sun Xerox Sun Xerox Xerox OPEN LOOK GUI Sun Sun Sun Microsystems, Inc. FAR Federal Acquisition Regulations @15490

3 RPC

4 ID Fork

5

6

7 5 Solaris fork Fork-One Fork-all Fork exec exit LWP POSIX setjmp longjmp LWP I/O I/O I/O I/O I/O getc putc MT

8 MT Solaris POSIX <thread.h> <pthread.h> _REENTRANT _POSIX_C_SOURCE libthread libpthread POSIX -lrt TNF truss mdb dbx Solaris Solaris POSIX API API Solaris

9 Solaris

10 fork() Solaris A grep tgrep B Solaris barrier.c

11 Solaris TM (Solaris Operating System, Solaris OS POSIX Solaris POSIX Solaris POSIX Solaris UNIX SVR4 Solaris C C Solaris SPARC x86 UltraSPARC SPARC64 AMD64 Pentium Xeon EM64T Solaris 10 Hardware Compatibility List "x86" AMD64 Intel Xeon/Pentium Solaris 10 Hardware Compatibility List 1 2 POSIX

12 8 Solaris POSIX 9 A POSIX B Solaris Sun docs.sun.com SM Web Sun docs.sun.com URL Alan Burns Geoff Davies Concurrent Programming Addison-Wesley 1993 Michel Raynal Distributed Algorithms and Protocols Wiley 1998 Silberschatz Peterson Galvin Operating System Concepts Addison-Wesley 1991 M. Ben-Ari Principles of Concurrent Programming Prentice-Hall 1982 Steve Kleiman Devang Shah Bart Smalders Programming with Threads Prentice Hall 1996 P 1 AaBbCc123.login ls -a machine_name% you have mail

13 P 1 AaBbCc123 machine_name% su Password: AaBbCc123 rm filename AaBbCc123 class 6 shell C shell Bourne shell Korn shell P 2 Shell Shell C shell C shell machine_name% machine_name# Bourne shell Korn shell $ Bourne shell Korn shell # 13

14 14

15 1 1 UNIX (multithreading, MT) Process Thread POSIX pthread Solaris thread Solaris single-threaded Multithreading fork(2) UNIX ID POSIX POSIX Sun Microsystems TM pthread 15

16 1 1 User-level or Application-level thread Lightweight process Bound thread Unbound thread Attribute object Mutual exclusion lock Condition variable Read-write lock Counting semaphore Parallelism Concurrency LWP Solaris 9 LWP Solaris 9 LWP Solaris 9 LWP Solaris 9 LWP Solaris 9 LWP POSIX (mutex) UNIX POSIX Portable Operating System Interface a POSIX IEEE Std ISO/IEC POSIX IEEE Std :2001 ISO/IEC 9945:2002 UNIX 3 Solaris

17 GUI 1 17

18 RPC (remote procedure call, RPC) UNIX Solaris 9 Solaris POSIX libpthread Solaris libthread C

19 ID PC POSIX (SCHED_FIFO) (SCHED_RR) (SCHED_OTHER) SCHED_FIFO SCHED_RR FIFO SCHED_FIFO SCHED_RR POSIX Realtime SCHED_OTHER SCHED_OTHER 149 LWP (PTHREAD_SCOPE_PROCESS) (PTHREAD_SCOPE_SYSTEM) Solaris 9 pthread 1 19

20 64 64 Solaris C 64 LP64 long ILP32 int long EB 32 4GB MB 2MB LP64 libkvm /dev/mem /dev/kmem /proc /proc Solaris

21

22 22

23 2 POSIX POSIX Solaris NULL pthread_attr_init() 50 pthread_create pthread_create(3c) int pthread_create(pthread_t *tid, const pthread_attr_t *tattr, void*(*start_routine)(void *), void *arg); 23

24 #include <pthread.h> pthread_attr_t() tattr; pthread_t tid; extern void *start_routine(void *arg); void *arg; int ret; /* default behavior*/ ret = pthread_create(&tid, NULL, start_routine, arg); /* initialized with default attributes */ ret = pthread_attr_init(&tattr); /* default behavior specified*/ ret = pthread_create(&tid, &tattr, start_routine, arg); attr pthread_create() start_routine start_routine start_routine 23 pthread_create pthread_create() ID tid NULL pthread_create() pthread_create() tattr pthread_create pthread_create() pthread_create() EAGAIN : EINVAL : tattr

25 pthread_join() pthread_join pthread_join(3c) int pthread_join(thread_t tid, void **status); #include <pthread.h> pthread_t tid; int ret; void *status; /* waiting to join thread "tid" with status */ ret = pthread_join(tid, &status); /* waiting to join thread "tid" without status */ ret = pthread_join(tid, NULL); 52 status NULL status pthread_join() ESRCH pthread_join() pthread_join pthread_join() pthread_join() 2 25

26 ESRCH : ID EDEADLK : A B EINVAL : ID pthread_join() 2 1 fetch() fetch() pthread_join() pbe malloc 2 1 void mainline (...) { struct phonebookentry *pbe; pthread_attr_t tattr; pthread_t helper; void *status; pthread_create(&helper, NULL, fetch, &pbe); /* do something else for a while */

27 2 1 pthread_join(helper, &status); /* it s now safe to use result */ void *fetch(struct phonebookentry *arg) { struct phonebookentry *npbe; /* fetch value from a database */ npbe = search (prog_name) if (npbe!= NULL) *arg = *npbe; pthread_exit(0); struct phonebookentry { char name[64]; char phonenumber[32]; char flags[16]; 2 27

28 pthread_detach(3c) pthread_join(3c) detachstate PTHREAD_CREATE_JOINABLE pthread_detach int pthread_detach(thread_t tid); #include <pthread.h> pthread_t tid; int ret; /* detach thread tid */ ret = pthread_detach(tid); pthread_detach() tid tid pthread_detach() pthread_detach pthread_detach() pthread_detach() EINVAL : tid ESRCH : tid C C TSD key (void *)

29 pthread_key_create int pthread_key_create(pthread_key_t *key, void (*destructor) (void *)); #include <pthread.h> pthread_key_t key; int ret; /* key create without destructor */ ret = pthread_key_create(&key, NULL); /* key create with destructor */ ret = pthread_key_create(&key, destructor); pthread_key_create(3c) NULL pthread_key_create() destructor pthread_key_create() key destructor NULL destructor NULL destructor destructor pthread_key_create pthread_key_create() pthread_key_create() 2 29

30 EAGAIN : key ENOMEM : pthread_key_delete(3c) Solaris pthread_key_delete int pthread_key_delete(pthread_key_t key); #include <pthread.h> pthread_key_t key; int ret; /* key previously created */ ret = pthread_key_delete(key); pthread_setspecific() pthread_getspecific() pthread_key_create() pthread_key_delete() pthread_key_delete() key pthread_key_create() pthread_key_delete pthread_key_delete() pthread_key_delete() EINVAL : key

31 pthread_setspecific(3c) pthread_setspecific int pthread_setspecific(pthread_key_t key, const void *value); #include <pthread.h> pthread_key_t key; void *value; int ret; /* key previously created */ ret = pthread_setspecific(key, value); pthread_setspecific pthread_setspecific() pthread_setspecific() ENOMEM : EINVAL : key pthread_setspecific() pthread_getspecific(3c) value pthread_getspecific void *pthread_getspecific(pthread_key_t key); 2 31

32 #include <pthread.h> pthread_key_t key; void *value; /* key previously created */ value = pthread_getspecific(key); pthread_getspecific pthread_getspecific 2 2 errno mywindow 2 2 body() {... while (write(fd, buffer, size) == -1) { if (errno!= EINTR) { fprintf(mywindow, "%s\n", strerror(errno)); exit(1);

33 2 2 errno errno mywindow stdio IO errno mywindow errno mywindow mywindow mywindow _mywindow() pthread_getspecific() pthread_getspecific() mywindow_key win 2 3 thread_key_t mywin_key; FILE *_mywindow(void) { FILE *win; win = pthread_getspecific(mywin_key); return(win); #define mywindow _mywindow() void routine_uses_win( FILE *win) {

34 2 3 void thread_start(...) {... make_mywin();... routine_uses_win( mywindow )... mywin_key make_mywin() mywindow mywindow _mywindow() mywindow void make_mywindow(void) { FILE **win; static pthread_once_t mykeycreated = PTHREAD_ONCE_INIT; pthread_once(&mykeycreated, mykeycreate); win = malloc(sizeof(*win)); create_window(win,...);

35 2 4 pthread_setspecific(mywindow_key, win); void mykeycreate(void) { pthread_key_create(&mywindow_key, free_key); void free_key(void *win) { free(win); mywin_key make_mywin() pthread_key_create() key destructor create_window() win pthread_setspecific() win pthread_getspecific() key pthread_setspecific() pthread_key_create() destructor destructor pthread_setspecific() key pthread_self(3c) thread identifier pthread_self pthread_t pthread_self(void); 2 35

36 #include <pthread.h> pthread_t tid; tid = pthread_self(); pthread_self pthread_self() thread identifier ID pthread_equal(3c) pthread_equal int pthread_equal(pthread_t tid1, pthread_t tid2); #include <pthread.h> pthread_t tid1, tid2; int ret; ret = pthread_equal(tid1, tid2); pthread_equal tid1 tid2 pthread_equal() tid1 tid2 pthread_once(3c) pthread_once pthread_once()

37 pthread_once int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)); #include <pthread.h> pthread_once_t once_control = PTHREAD_ONCE_INIT; int ret; ret = pthread_once(&once_control, init_routine); once_control pthread_once pthread_once() pthread_once() EINVAL : once_control init_routine NULL sched_yield(3rt) sched_yield int sched_yield(void); #include <sched.h> int ret; ret = sched_yield(); 2 37

38 sched_yield sched_yield() -1 errno ENOSYS : sched_yield pthread_setschedparam(3c) pthread_setschedparam int pthread_setschedparam(pthread_t tid, int policy, const struct sched_param *param); #include <pthread.h> pthread_t tid; int ret; struct sched_param param; int priority; /* sched_priority will be the priority of the thread */ sched_param.sched_priority = priority; policy = SCHED_OTHER; /* scheduling parameters of target thread */ ret = pthread_setschedparam(tid, policy, &param);

39 pthread_setschedparam pthread_setschedparam() pthread_setschedparam() EINVAL : ENOTSUP : pthread_getschedparam(3c) pthread_getschedparam int pthread_getschedparam(pthread_t tid, int policy, struct schedparam *param); #include <pthread.h> pthread_t tid; sched_param param; int priority; int policy; int ret; /* scheduling parameters of target thread */ ret = pthread_getschedparam (tid, &policy, &param); /* sched_priority contains the priority of the thread */ priority = param.sched_priority; 2 39

40 pthread_getschedparam pthread_getschedparam() ESRCH : tid pthread_kill(3c) pthread_kill int pthread_kill(thread_t tid, int sig); #include <pthread.h> #include <signal.h> int sig; pthread_t tid; int ret; ret = pthread_kill(tid, sig); pthread_kill() sig tid tid sig signal(5) sig tid pthread_kill pthread_kill() pthread_kill() EINVAL : sig ESRCH : tid

41 pthread_sigmask(3c) pthread_sigmask int pthread_sigmask(int how, const sigset_t *new, sigset_t *old); #include <pthread.h> #include <signal.h> int ret; sigset_t old, new; ret = pthread_sigmask(sig_setmask, &new, &old); /* set new mask */ ret = pthread_sigmask(sig_block, &new, &old); /* blocking mask */ ret = pthread_sigmask(sig_unblock, &new, &old); /* unblocking */ how how SIG_BLOCK new new SIG_UNBLOCK new new SIG_SETMASK new new new NULL how NULL new old NULL old pthread_sigmask pthread_sigmask() pthread_sigmask() EINVAL : how Fork 146 pthread_atfork pthread_atfork(3c) 2 41

42 pthread_atfork int pthread_atfork(void (*prepare) (void), void (*parent) (void), void (*child) (void) ); pthread_atfork pthread_atfork() pthread_atfork() ENOMEM : Fork pthread_exit(3c) pthread_exit void pthread_exit(void *status); #include <pthread.h> void *status; pthread_exit(status); /* exit with status */ pthread_exit() ID status pthread_join() status ID 52 pthread_exit status pthread_create pthread_exit()

43 POSIX pthread_cancel() "joining" pthread_create() pthread_detach join joining main() main() exit() main() pthread_exit pthreads pthread_testcancel pthread_cond_wait pthread_cond_timedwait(3c) sigwait(2) cancellation(5) 45 pthread_setcancelstate 2 43

44 C pthread_setcancelstate(3c) pthread_setcanceltype(3c) pthread_testcancel() POSIX pthread_cancel(3c) pthread_cancel int pthread_cancel(pthread_t thread); #include <pthread.h> pthread_t thread; int ret; ret = pthread_cancel(thread); pthread_setcancelstate(3c) pthread_setcanceltype(3c)

45 pthread_cancel pthread_cancel() ESRCH : ID pthread_setcancelstate(3c) pthread_setcancelstate int pthread_setcancelstate(int state, int *oldstate); #include <pthread.h> int oldstate; int ret; /* enabled */ ret = pthread_setcancelstate(pthread_cancel_enable, &oldstate); /* disabled */ ret = pthread_setcancelstate(pthread_cancel_disable, &oldstate); pthread_setcancelstate pthread_setcancelstate() pthread_setcancelstate() EINVAL : PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_DISABLE 2 45

46 pthread_setcanceltype(3c) pthread_setcanceltype int pthread_setcanceltype(int type, int *oldtype); #include <pthread.h> int oldtype; int ret; /* deferred mode */ ret = pthread_setcanceltype(pthread_cancel_deferred, &oldtype); /* async mode*/ ret = pthread_setcanceltype(pthread_cancel_asynchronous, &oldtype); pthread_setcanceltype pthread_setcanceltype() EINVAL : PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_ASYNCHRONOUS pthread_testcancel(3c) pthread_testcancel void pthread_testcancel(void);

47 #include <pthread.h> pthread_testcancel(); pthread_testcancel() pthread_testcancel() pthread_testcancel() pthread_testcancel() pthread 43 pthread_testcancel pthread_testcancel() pthread_cleanup_push(3c) pthread_cleanup_pop(3c) pthread_cleanup_push pthread_cleanup_push(3c) (LIFO) void pthread_cleanup_push(void(*routine)(void *), void *args); #include <pthread.h> /* push the handler "routine" on cleanup stack */ pthread_cleanup_push (routine, arg); pthread_cleanup_push pthread_cleanup_push() pthread_cleanup_pop(3c) 2 47

48 pthread_cleanup_pop void pthread_cleanup_pop(int execute); #include <pthread.h> /* pop the "func" out of cleanup stack and execute "func" */ pthread_cleanup_pop (1); /* pop the "func" and DONT execute "func" */ pthread_cleanup_pop (0); pthread_exit(3c) pthread_cleanup_pop() pthread_cleanup_pop pthread_cleanup_pop()

49 3 pthreads API POSIX Solaris pthreads 8 pthread_create(3c) 49

50 pthreads pthread_attr_init(3c) pthread_attr_init int pthread_attr_init(pthread_attr_t *tattr); #include <pthread.h> pthread_attr_t tattr; int ret; /* initialize an attribute to the default value */ ret = pthread_attr_init(&tattr); 3 1 (tattr) 3 1 tattr scope PTHREAD_SCOPE_PROCESS detachstate PTHREAD_CREATE_JOINABLE ID stackaddr NULL stacksize 0 priority

51 3 1 tattr inheritsched PTHREAD_EXPLICIT_SCHED schedpolicy SCHED_OTHER Solaris pthread_attr_init pthread_attr_init() ENOMEM : pthread_attr_destroy(3c) pthread_attr_destroy int pthread_attr_destroy(pthread_attr_t *tattr); #include <pthread.h> pthread_attr_t tattr; int ret; /* destroy an attribute */ ret = pthread_attr_destroy(&tattr); pthread_attr_destroy pthread_attr_destroy() EINVAL : tattr 3 51

52 (PTHREAD_CREATE_DETACHED) ID pthread_attr_setdetachstate(3c) pthread_attr_setdetachstate(3c) int pthread_attr_setdetachstate(pthread_attr_t *tattr,int detachstate); #include <pthread.h> pthread_attr_t tattr; int ret; /* set the thread detach state */ ret = pthread_attr_setdetachstate(&tattr,pthread_create_detached); PTHREAD_CREATE_JOINABLE pthread_join() main() 42 pthread_create() ID join 3 1 #include <pthread.h> pthread_attr_t tattr; pthread_t tid; void *start_routine;

53 3 1 void arg int ret; /* initialized with default attributes */ ret = pthread_attr_init (&tattr); ret = pthread_attr_setdetachstate (&tattr,pthread_create_detached); ret = pthread_create (&tid, &tattr, start_routine, arg); pthread_attr_setdetachstate pthread_attr_setdetachstate() EINVAL : detachstate tattr pthread_attr_getdetachstate(3c) pthread_attr_getdetachstate int pthread_attr_getdetachstate(const pthread_attr_t *tattr, int *detachstate; #include <pthread.h> pthread_attr_t tattr; int detachstate; int ret; 3 53

54 /* get detachstate of thread */ ret = pthread_attr_getdetachstate (&tattr, &detachstate); pthread_attr_getdetachstate pthread_attr_getdetachstate() EINVAL : detachstate NULL tattr pthread_attr_setguardsize(3c) attr guardsize pthread_attr_setguardsize(3c) #include <pthread.h> int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); guardsize guardsize SIGSEGV guardsize attr guardsize attr guardsize guardsize PAGESIZE sys/mman.h PAGESIZE guardsize PAGESIZE guardsize pthread_attr_setguardsize() attr pthread_attr_getguardsize() pthread_attr_setguardsize pthread_attr_setguardsize()

55 EINVAL : attr guardsize guardsize pthread_attr_getguardsize(3c) attr guardsize pthread_attr_getguardsize #include <pthread.h> int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize); guardsize PAGESIZE sys/mman.h PAGESIZE guardsize PAGESIZE guardsize pthread_attr_setguardsize() attr pthread_attr_getguardsize() pthread_attr_getguardsize pthread_attr_getguardsize() EINVAL : attr guardsize guardsize pthread_attr_setscope(3c) PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_PROCESS pthread_attr_setscope int pthread_attr_setscope(pthread_attr_t *tattr,int scope); #include <pthread.h> 3 55

56 pthread_attr_t tattr; int ret; /* bound thread */ ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM); /* unbound thread */ ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_PROCESS); pthreads #include <pthread.h> pthread_attr_t attr; pthread_t tid; void start_routine; void arg; int ret; /* initialized with default attributes */ ret = pthread_attr_init (&tattr); /* BOUND behavior */ ret = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM); ret = pthread_create (&tid, &tattr, start_routine, arg);

57 pthread_attr_setscope pthread_attr_setscope() EINVAL : tattr pthread_attr_getscope(3c) pthread_attr_getscope int pthread_attr_getscope(pthread_attr_t *tattr, int *scope); #include <pthread.h> pthread_attr_t tattr; int scope; int ret; /* get scope of thread */ ret = pthread_attr_getscope(&tattr, &scope); pthread_attr_getscope pthread_attr_getscope() EINVAL : scope NULL tattr pthread_setconcurrency(3c) pthread_setconcurrency() Solaris 9 LWP 3 57

58 pthread_setconcurrency #include <pthread.h> int pthread_setconcurrency(int new_level); pthread_setconcurrency pthread_setconcurrency() EINVAL : new_level EAGAIN : new_level pthread_getconcurrency(3c) pthread_setconcurrency() pthread_getconcurrency #include <pthread.h> int pthread_getconcurrency(void); pthread_setconcurrency() pthread_getconcurrency() pthread_getconcurrency pthread_getconcurrency() pthread_setconcurrency() pthread_setconcurrency() pthread_getconcurrency() pthread_attr_setschedpolicy(3c) POSIX SCHED_FIFO SCHED_RR SCHED_OTHER pthread_attr_setschedpolicy(3c) int pthread_attr_setschedpolicy(pthread_attr_t *tattr, int policy);

59 #include <pthread.h> pthread_attr_t tattr; int policy; int ret; /* set the scheduling policy to SCHED_OTHER */ ret = pthread_attr_setschedpolicy(&tattr, SCHED_OTHER); SCHED_FIFO ID 0 (PTHREAD_SCOPE_SYSTEM) (RT) (PTHREAD_SCOPE_PROCESS)) ID 0 SCHED_FIFO SCHED_FIFO TS SCHED_RR ID 0 (PTHREAD_SCOPE_SYSTEM)) (RT) (PTHREAD_SCOPE_PROCESS) SCHED_RR TS ID 0 SCHED_FIFO SCHED_RR POSIX 19 pthread_attr_setschedpolicy pthread_attr_setschedpolicy() EINVAL : tattr ENOTSUP : pthread_attr_getschedpolicy(3c) 3 59

60 pthread_attr_getschedpolicy int pthread_attr_getschedpolicy(pthread_attr_t *tattr, int *policy); #include <pthread.h> pthread_attr_t tattr; int policy; int ret; /* get scheduling policy of thread */ ret = pthread_attr_getschedpolicy (&tattr, &policy); pthread_attr_getschedpolicy pthread_attr_getschedpolicy() EINVAL : policy NULL tattr pthread_attr_setinheritsched(3c) pthread_attr_setinheritsched int pthread_attr_setinheritsched(pthread_attr_t *tattr, int inherit); #include <pthread.h> pthread_attr_t tattr; int inherit; int ret;

61 /* use the current scheduling policy */ ret = pthread_attr_setinheritsched(&tattr, PTHREAD_EXPLICIT_SCHED); inherit PTHREAD_INHERIT_SCHED pthread_create() PTHREAD_EXPLICIT_SCHED pthread_create() pthread_attr_setinheritsched pthread_attr_setinheritsched() EINVAL : tattr ENOTSUP : pthread_attr_getinheritsched(3c) pthread_attr_setinheritsched() pthread_attr_getinheritsched int pthread_attr_getinheritsched(pthread_attr_t *tattr, int *inherit); #include <pthread.h> pthread_attr_t tattr; int inherit; int ret; /* get scheduling policy and priority of the creating thread */ ret = pthread_attr_getinheritsched (&tattr, &inherit); 3 61

62 pthread_attr_getinheritsched pthread_attr_getinheritsched() EINVAL : inherit NULL tattr pthread_attr_setschedparam(3c) pthread_attr_setschedparam int pthread_attr_setschedparam(pthread_attr_t *tattr, const struct sched_param *param); #include <pthread.h> pthread_attr_t tattr; int newprio; sched_param param; newprio = 30; /* set the priority; others are unchanged */ param.sched_priority = newprio; /* set the new scheduling param */ ret = pthread_attr_setschedparam (&tattr, &param); param

63 pthread_attr_setschedparam pthread_attr_setschedparam() EINVAL : param NULL tattr pthreads pthread_attr_getschedparam(3c) pthread_attr_setschedparam() pthread_attr_getschedparam int pthread_attr_getschedparam(pthread_attr_t *tattr, const struct sched_param *param); #include <pthread.h> pthread_attr_t attr; struct sched_param param; int ret; /* get the existing scheduling param */ ret = pthread_attr_getschedparam (&tattr, &param); sched_param 3 63

64 #include <pthread.h> #include <sched.h> pthread_attr_t tattr; pthread_t tid; int ret; int newprio = 20; sched_param param; /* initialized with default attributes */ ret = pthread_attr_init (&tattr); /* safe to get existing scheduling param */ ret = pthread_attr_getschedparam (&tattr, &param); /* set the priority; others are unchanged */ param.sched_priority = newprio; /* setting the new scheduling param */

65 3 2 ret = pthread_attr_setschedparam (&tattr, &param); /* with new priority specified */ ret = pthread_create (&tid, &tattr, func, arg); pthread_attr_getschedparam pthread_attr_getschedparam() EINVAL : param NULL tattr pthread_attr_setstacksize(3c) pthread_attr_setstacksize int pthread_attr_setstacksize(pthread_attr_t *tattr, size_t size); #include <pthread.h> pthread_attr_t tattr; size_t size; int ret; size = (PTHREAD_STACK_MIN + 0x4000); /* setting a new size */ ret = pthread_attr_setstacksize(&tattr, size); 3 65

66 stacksize size 67 size size PTHREAD_STACK_MIN pthread_attr_setstacksize pthread_attr_setstacksize() EINVAL : size PTHREAD_STACK_MIN tattr pthread_attr_getstacksize(3c) pthread_attr_setstacksize() pthread_attr_getstacksize int pthread_attr_getstacksize(pthread_attr_t *tattr, size_t *size); #include <pthread.h> pthread_attr_t tattr; size_t size; int ret; /* getting the stack size */ ret = pthread_attr_getstacksize(&tattr, &size);

67 pthread_attr_getstacksize pthread_attr_getstacksize() EINVAL : tattr SIGSEGV PTHREAD_CREATE_JOINABLE pthread_join(3c) pthread_join(3c) 1MB 32 2MB 64 mmap() MAP_NORESERVE / ABI 3 67

68 PTHREAD_STACK_MIN PTHREAD_STACK_MIN NULL #include <pthread.h> pthread_attr_t tattr; pthread_t tid; int ret; size_t size = PTHREAD_STACK_MIN + 0x4000; /* initialized with default attributes */ ret = pthread_attr_init(&tattr); /* setting the size of the stack also */ ret = pthread_attr_setstacksize(&tattr, size); /* only size specified in tattr*/ ret = pthread_create(&tid, &tattr, start_routine, arg); pthread_attr_setstack(3c) pthread_attr_setstack(3c) int pthread_attr_setstack(pthread_attr_t *tattr,void *stackaddr, size_t stacksize);

69 #include <pthread.h> pthread_attr_t tattr; void *base; size_t size; int ret; base = (void *) malloc(pthread_stack_min + 0x4000); /* setting a new address and size */ ret = pthread_attr_setstack(&tattr, base,pthread_stack_min + 0x4000); stackaddr stacksize stackaddr NULL stacksize base base NULL pthread_create(3c) stacksize pthread_attr_setstack(3c) pthread_attr_setstack() EINVAL : base tattr stacksize PTHREAD_STACK_MIN #include <pthread.h> pthread_attr_t tattr; pthread_t tid; int ret; 3 69

70 void *stackbase; size_t size; /* initialized with default attributes */ ret = pthread_attr_init(&tattr); /* setting the base address and size of the stack */ ret = pthread_attr_setstack(&tattr, stackbase,size); /* address and size specified */ ret = pthread_create(&tid, &tattr, func, arg); pthread_attr_getstack(3c) pthread_attr_setstack() pthread_attr_getstack int pthread_attr_getstack(pthread_attr_t *tattr,void * *stackaddr, size_t *stacksize); #include <pthread.h> pthread_attr_t tattr; void *base; size_t size; int ret;

71 /* getting a stack address and size */ ret = pthread_attr_getstackaddr (&tattr, &base, &size); pthread_attr_getstack pthread_attr_getstackaddr() EINVAL : tattr 3 71

72 72

73

74 SPARC Platform Edition 32 long long long long 32 int char float SPARC Platform Edition Intel pthread_mutexattr_init 76 pthread_mutexattr_destroy 77 pthread_mutexattr_setpshared 78 pthread_mutexattr_getpshared 78 pthread_mutexattr_settype 79 pthread_mutexattr_gettype 80 pthread_mutexattr_setprotocol 82 pthread_mutexattr_getprotocol 83 pthread_mutexattr_setprioceiling 84 pthread_mutexattr_getprioceiling 85 pthread_mutex_setprioceiling 86 pthread_mutex_getprioceiling 86 pthread_mutexattr_setrobust_np

75 pthread_mutexattr_getrobust_np 4 2 Solaris POSIX 4 2 Solaris POSIX USYNC_PROCESS PTHREAD_PROCESS_SHARED USYNC_PROCESS_ROBUST POSIX USYNC_THREAD PTHREAD_PROCESS_PRIVATE pthread_mutexattr_init(3c) pthread_mutexattr_init int pthread_mutexattr_init(pthread_mutexattr_t *mattr); #include <pthread.h> pthread_mutexattr_t mattr; int ret; /* initialize an attribute to default value */ ret = pthread_mutexattr_init(&mattr); pshared PTHREAD_PROCESS_PRIVATE mattr opaque mattr PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_PRIVATE 4 75

76 pthread_mutexattr_destroy(3c) pthread_mutexattr_init() opaque pthread_mutexattr_init pthread_mutexattr_init() ENOMEM : pthread_mutexattr_destroy(3c) pthread_mutexattr_init() pthread_mutexattr_destroy int pthread_mutexattr_destroy(pthread_mutexattr_t *mattr) #include <pthread.h> pthread_mutexattr_t mattr; int ret; /* destroy an attribute */ ret = pthread_mutexattr_destroy(&mattr); pthread_mutexattr_destroy pthread_mutexattr_destroy() EINVAL : mattr pthread_mutexattr_setpshared(3c)

77 pthread_mutexattr_setpshared int pthread_mutexattr_setpshared(pthread_mutexattr_t *mattr, int pshared); #include <pthread.h> pthread_mutexattr_t mattr; int ret; ret = pthread_mutexattr_init(&mattr); /* * resetting to its default value: private */ ret = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE); pshared PTHREAD_PROCESS_SHARED Solaris mutex_init() USYNC_PROCESS pshared PTHREAD_PROCESS_PRIVATE pthread_mutexattr_setpshared pthread_mutexattr_setpshared() EINVAL : mattr pthread_mutexattr_getpshared(3c) pthread_mutexattr_setpshared() 4 77

78 pthread_mutexattr_getpshared int pthread_mutexattr_getpshared(pthread_mutexattr_t *mattr, int *pshared); #include <pthread.h> pthread_mutexattr_t mattr; int pshared, ret; /* get pshared of mutex */ ret = pthread_mutexattr_getpshared(&mattr, &pshared); mattr pshared PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_PRIVATE pthread_mutexattr_getpshared pthread_mutexattr_getpshared() EINVAL : mattr pthread_mutexattr_settype(3c) type pthread_mutexattr_settype #include <pthread.h> int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type); PTHREAD_MUTEX_DEFAULT type

79 PTHREAD_MUTEX_NORMAL : PTHREAD_MUTEX_ERRORCHECK : PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_DEFAULT : Solaris PTHREAD_PROCESS_DEFAULT PTHREAD_PROCESS_NORMAL pthread_mutexattr_settype pthread_mutexattr_settype EINVAL : type EINVAL : attr pthread_mutexattr_gettype(3c) pthread_mutexattr_settype() type pthread_mutexattr_gettype #include <pthread.h> 4 79

80 int pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *type); PTHREAD_MUTEX_DEFAULT type PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_DEFAULT 78 pthread_mutexattr_settype pthread_mutexattr_gettype pthread_mutexattr_gettype() 0 pthread_mutexattr_setprotocol(3c) pthread_mutexattr_setprotocol #include <pthread.h> int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol); attr pthread_mutexattr_init() protocol pthread.h protocol PTHREAD_PRIO_NONE PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT PTHREAD_PRIO_NONE PTHREAD_PRIO_INHERIT thrd1 thrd1 PTHREAD_PRIO_INHERIT thrd1 thrd1 thrd1 (thrd3) thrd

81 PTHREAD_PRIO_INHERIT PTHREAD_PRIO_INHERIT PTHREAD_PRIO_INHERIT _POSIX_THREAD_PRIO_INHERIT pthread_mutexattr_setrobust_np() robustness EOWNERDEAD pthread_mutex_init() pthread_mutex_init() pthread_mutex_init() pthread_mutex_lock() ENOTRECOVERABLE pthread_mutex_destroy() pthread_mutex_init() EOWNERDEAD EOWNERDEAD PTHREAD_PRIO_PROTECT PTHREAD_PRIO_PROTECT thrd2 thrd2 thrd2 thrd2 thrd2 sched_setparam() PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT pthread_mutexattr_setprotocol pthread_mutexattr_setprotocol() 0 pthread_mutexattr_setprotocol() 4 81

82 ENOSYS : _POSIX_THREAD_PRIO_INHERIT _POSIX_THREAD_PRIO_PROTECT ENOTSUP : protocol pthread_mutexattr_setprotocol() EINVAL : attr protocol EPERM : pthread_mutexattr_getprotocol(3c) pthread_mutexattr_getprotocol #include <pthread.h> int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol); attr pthread_mutexattr_init() protocol PTHREAD_PRIO_NONE PTHREAD_PRIO_INHERIT PTHREAD_PRIO_PROTECT pthread_mutexattr_getprotocol pthread_mutexattr_getprotocol() 0 pthread_mutexattr_getprotocol() ENOSYS : _POSIX_THREAD_PRIO_INHERIT _POSIX_THREAD_PRIO_PROTECT pthread_mutexattr_getprotocol()

83 EINVAL : attr EPERM : pthread_mutexattr_setprioceiling(3c) pthread_mutexattr_setprioceiling #include <pthread.h> int pthread_mutexattr_setprioceiling(pthread_mutexatt_t *attr, int prioceiling, int *oldceiling); attr pthread_mutexattr_init() prioceiling prioceiling SCHED_FIFO prioceiling oldceiling pthread_mutexattr_setprioceiling pthread_mutexattr_setprioceiling() 0 pthread_mutexattr_setprioceiling() ENOSYS : _POSIX_THREAD_PRIO_PROTECT pthread_mutexattr_setprioceiling() EINVAL : attr prioceiling EPERM : 4 83

84 pthread_mutexattr_getprioceiling(3c) pthread_mutexattr_getprioceiling #include <pthread.h> int pthread_mutexattr_getprioceiling(const pthread_mutexatt_t *attr, int *prioceiling); attr pthread_mutexattr_init() _POSIX_THREAD_PRIO_PROTECT attr pthread_mutexattr_getprioceiling() prioceiling prioceiling SCHED_FIFO prioceiling pthread_mutexattr_getprioceiling pthread_mutexattr_getprioceiling() 0 pthread_mutexattr_getprioceiling() ENOSYS : _POSIX_THREAD_PRIO_PROTECT pthread_mutexattr_getprioceiling() EINVAL : attr EPERM : pthread_mutexattr_setprioceiling(3c)

85 pthread_mutex_setprioceiling #include <pthread.h> int pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int prioceiling, int *old_ceiling); pthread_mutex_setprioceiling() mutex prioceiling pthread_mutex_setprioceiling() pthread_mutex_setprioceiling() pthread_mutex_setprioceiling() old_ceiling pthread_mutex_setprioceiling() pthread_mutex_setprioceiling pthread_mutex_setprioceiling() 0 pthread_mutexatt_setprioceiling() ENOSYS : _POSIX_THREAD_PRIO_PROTECT pthread_mutex_setprioceiling() EINVAL : prioceiling EINVAL : mutex ENOSYS : EPERM : pthread_mutexattr_getprioceiling(3c) 4 85

86 pthread_mutex_getprioceiling #include <pthread.h> int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex, int *prioceiling); pthread_mutex_getprioceiling() mutex prioceiling pthread_mutex_getprioceiling pthread_mutex_getprioceiling() 0 pthread_mutexatt_getprioceiling() ENOSYS : _POSIX_THREAD_PRIO_PROTECT pthread_mutex_getprioceiling() EINVAL : mutex ENOSYS : EPERM : pthread_mutexattr_setrobust_np(3c) pthread_mutexattr_setrobust_np #include <pthread.h> int pthread_mutexattr_setrobust_np(pthread_mutexattr_t *attr, int *robustness);

87 _POSIX_THREAD_PRIO_INHERIT pthread_mutexattr_setrobust_np() attr pthread_mutexattr_init() robustness pthread.h robustness PTHREAD_MUTEX_ROBUST_NP PTHREAD_MUTEX_STALLED_NP PTHREAD_MUTEX_STALLED_NP PTHREAD_MUTEX_ROBUST_NP pthread_mutex_lock() PTHREAD_MUTEX_STALLED_NP EOWNWERDEAD pthread_mutex_lock() EOWNWERDEAD pthread_mutex_consistent_np() pthread_mutex_consistent_np() pthread_mutex_lock() ENOTRECOVERABLE pthread_mutex_destroy() pthread_mutex_int() EOWNERDEAD EOWNERDEAD pthread_mutexattr_setrobust_np pthread_mutexattr_setrobust_np() 0 pthread_mutexattr_setrobust_np() ENOSYS : _POSIX_THREAD_PRIO INHERIT pthread_mutexattr_setrobust_np() 4 87

88 ENOTSUP : robustness pthread_mutexattr_setrobust_np() EINVAL : attr robustness pthread_mutexattr_getrobust_np(3c) pthread_mutexattr_getrobust_np #include <pthread.h> int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *attr, int *robustness); _POSIX_THREAD_PRIO_INHERIT pthread_mutexattr_getrobust_np() attr pthread_mutexattr_init() robustness pthread_mutexattr_getrobust_np pthread_mutexattr_getrobust_np() 0 pthread_mutexattr_getrobust_np() ENOSYS : _POSIX_THREAD_PRIO INHERIT pthread_mutexattr_getrobust_np() pthread_mutexattr_getrobust_np() EINVAL : attr robustness

89 pthread_mutex_init 91 pthread_mutex_consistent_np 91 pthread_mutex_lock 93 pthread_mutex_unlock 94 pthread_mutex_trylock 95 pthread_mutex_destroy SCHED_OTHER pthread_mutex_init(3c) mp pthread_mutexattr_init() mattr NULL Solaris 204 mutex_init(3c) pthread_mutex_init int pthread_mutex_init(pthread_mutex_t *mp, const pthread_mutexattr_t *mattr); #include <pthread.h> pthread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER; pthread_mutexattr_t mattr; int ret; /* initialize a mutex to its default value */ 4 89

90 ret = pthread_mutex_init(&mp, NULL); /* initialize a mutex */ ret = pthread_mutex_init(&mp, &mattr); mattr NULL PTHREAD_MUTEX_INITIALIZER pthread_mutex_init pthread_mutex_init() EBUSY : mp EINVAL : mattr EFAULT : mp pthread_mutex_consistent_np mutex

91 pthread_mutex_consistent_np #include <pthread.h> int pthread_mutex_consistent_np(pthread_mutex_t *mutex); _POSIX_THREAD_PRIO_INHERIT pthread_mutex_consistent_np() PTHREAD_PRIO_INHERIT pthread_mutex_lock() EOWNWERDEAD pthread_mutex_lock() pthread_mutex_consistent_np() pthread_mutex_lock() pthread_mutex_unlock() pthread_mutex_trylock() pthread_mutex_consistent_np() pthread_mutex_consistent_np pthread_mutex_consistent_np() pthread_mutex_consistent_np() ENOSYS : _POSIX_THREAD_PRIO_INHERIT pthread_mutex_consistent_np() pthread_mutex_consistent_np() EINVAL : mattr pthread_mutex_lock(3c) mutex pthread_mutex_lock int pthread_mutex_lock(pthread_mutex_t *mutex); 4 91

92 #include <pthread.h> pthread_mutex_t mutex; int ret; ret = pthread_ mutex_lock(&mp); /* acquire the mutex */ pthread_mutex_lock() Solaris 207 mutex_lock PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_DEFAULT pthread_mutex_lock pthread_mutex_lock() EAGAIN : EDEADLK : _POSIX_THREAD_PRIO_INHERIT PTHREAD_PRIO_INHERIT pthread_mutexattr_setrobust_np() robustness PTHREAD_MUTEX_ROBUST_NP

93 EOWNERDEAD : pthread_mutex_consistent_np() pthread_mutex_lock() pthread_mutex_init() pthread_mutex_lock() ENOTRECOVERABLE EOWNERDEAD EOWNERDEAD ENOTRECOVERABLE : EOWNERDEAD ENOMEM : pthread_mutex_unlock(3c) mutex Solaris 207 mutex_unlock pthread_mutex_unlock int pthread_mutex_unlock(pthread_mutex_t *mutex); #include <pthread.h> pthread_mutex_t mutex; int ret; ret = pthread_mutex_unlock(&mutex); /* release the mutex */ 4 93

94 pthread_mutex_unlock() mutex pthread_mutex_unlock() mutex PTHREAD_MUTEX_RECURSIVE pthread_mutex_unlock pthread_mutex_unlock() EPERM : pthread_mutex_trylock(3c) mutex Solaris 208 mutex_trylock pthread_mutex_trylock int pthread_mutex_trylock(pthread_mutex_t *mutex); #include <pthread.h> pthread_mutex_t mutex; int ret; ret = pthread_mutex_trylock(&mutex); /* try to lock the mutex */ pthread_mutex_trylock() pthread_mutex_lock() mutex pthread_mutex_trylock pthread_mutex_trylock() EBUSY : mutex

95 EAGAIN : mutex _POSIX_THREAD_PRIO_INHERIT PTHREAD_PRIO_INHERIT pthread_mutexattr_setrobust_np() robustness PTHREAD_MUTEX_ROBUST_NP EOWNERDEAD : pthread_mutex_consistent_np() pthread_mutex_lock() pthread_mutex_init() pthread_mutex_trylock() ENOTRECOVERABLE EOWNERDEAD EOWNERDEAD ENOTRECOVERABLE : EOWNERDEAD ENOMEM : pthread_mutex_destroy(3c) mp Solaris 206 mutex_destroy pthread_mutex_destroy int pthread_mutex_destroy(pthread_mutex_t *mp); #include <pthread.h> pthread_mutex_t mp; 4 95

96 int ret; ret = pthread_mutex_destroy(&mp); /* mutex is destroyed */ pthread_mutex_destroy pthread_mutex_destroy() EINVAL : mp #include <pthread.h> pthread_mutex_t count_mutex; long long count; void increment_count() { pthread_mutex_lock(&count_mutex); count = count + 1; pthread_mutex_unlock(&count_mutex);

97 4 1 long long get_count() { long long c; pthread_mutex_lock(&count_mutex); c = count; pthread_mutex_unlock(&count_mutex); return (c); 4 1 increment_count() get_count() 64 count 32 long long

98 pthread_mutex_lock(&m1); /* use resource 1 */ pthread_mutex_lock(&m2); /* use resources 1 and 2 */ pthread_mutex_unlock(&m2); pthread_mutex_unlock(&m1); pthread_mutex_lock(&m2); /* use resource 2 */ pthread_mutex_lock(&m1); /* use resources 1 and 2 */ pthread_mutex_unlock(&m1); pthread_mutex_unlock(&m2); n n pthread_mutex_trylock() pthread_mutex_lock(&m1); pthread_mutex_lock(&m2); /* no processing */ pthread_mutex_unlock(&m2); pthread_mutex_unlock(&m1); for (; ;) { pthread_mutex_lock(&m2); if(pthread_mutex_trylock(&m1)==0) /* got it */ break; /* didn t get it */ pthread_mutex_unlock(&m2); /* get locks; no processing */ pthread_mutex_unlock(&m1); pthread_mutex_unlock(&m2);

99 pthread_mutex_trylock() typedef struct node1 { int value; struct node1 *link; pthread_mutex_t lock; node1_t; node1_t ListHead; ListHead ListHead ListHead 4 5 C 4 5 node1_t *delete(int value) { 4 99

100 4 5 node1_t *prev, *current; prev = &ListHead; pthread_mutex_lock(&prev->lock); while ((current = prev->link)!= NULL) { pthread_mutex_lock(&current->lock); if (current->value == value) { prev->link = current->link; pthread_mutex_unlock(&current->lock); pthread_mutex_unlock(&prev->lock); current->link = NULL; return(current); pthread_mutex_unlock(&prev->lock); prev = current; pthread_mutex_unlock(&prev->lock); return(null);

101 4 6 typedef struct node2 { int value; struct node2 *link; pthread_mutex_t lock; node2_t; C 4 7 void Hit Neighbor(node2_t *me) { while (1) { pthread_mutex_lock(&me->lock); if (pthread_mutex_lock(&me->link->lock)!= 0) { /* failed to get lock */ pthread_mutex_unlock(&me->lock); continue; break; me->link->value += me->value; me->value /=2; pthread_mutex_unlock(&me->link->lock); pthread_mutex_unlock(&me->lock); 4 101

102 SCHED_OTHER pthread_condattr_init 104 pthread_condattr_destroy 104 pthread_condattr_setpshared 105 pthread_condattr_getpshared 4 5 Solaris POSIX 4 5 Solaris POSIX USYNC_PROCESS PTHREAD_PROCESS_SHARED USYNC_THREAD PTHREAD_PROCESS_PRIVATE

103 pthread_condattr_init(3c) pthread_condattr_init int pthread_condattr_init(pthread_condattr_t *cattr); #include <pthread.h> pthread_condattr_t cattr; int ret; /* initialize an attribute to default value */ ret = pthread_condattr_init(&cattr); pshared PTHREAD_PROCESS_PRIVATE pshared cattr opaque cattr PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_PRIVATE pthread_condattr_destroy(3c) pthread_condattr_init() opaque pthread_condattr_init pthread_condattr_init() ENOMEM : EINVAL : cattr pthread_condattr_destroy(3c) 4 103

104 pthread_condattr_destroy int pthread_condattr_destroy(pthread_condattr_t *cattr); #include <pthread.h> pthread_condattr_t cattr; int ret; /* destroy an attribute */ ret = pthread_condattr_destroy(&cattr); pthread_condattr_destroy pthread_condattr_destroy() EINVAL : cattr pthread_condattr_setpshared(3c) pthread_condattr_setpshared int pthread_condattr_setpshared(pthread_condattr_t *cattr, int pshared); #include <pthread.h> pthread_condattr_t cattr; int ret;

105 /* all processes */ ret = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED); /* within a process */ ret = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE); pshared PTHREAD_PROCESS_SHARED Solaris mutex_init() USYNC_PROCESS pshared PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE Solaris cond_init() USYNC_THREAD PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_SHARED pthread_condattr_setpshared pthread_condattr_setpshared() EINVAL : cattr pshared pthread_condattr_getpshared(3c) cattr pshared pthread_condattr_getpshared int pthread_condattr_getpshared(const pthread_condattr_t *cattr, int *pshared); #include <pthread.h> pthread_condattr_t cattr; int pshared; 4 105

106 int ret; /* get pshared value of condition variable */ ret = pthread_condattr_getpshared(&cattr, &pshared); PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_PRIVATE pthread_condattr_getpshared pthread_condattr_getpshared() EINVAL : cattr pthread_cond_init 108 pthread_cond_wait 109 pthread_cond_signal 111 pthread_cond_timedwait 113 pthread_cond_reltimedwait_np 114 pthread_cond_broadcast 116 pthread_cond_destroy pthread_cond_init(3c) cv pthread_condattr_init()

107 pthread_cond_init int pthread_cond_init(pthread_cond_t *cv, const pthread_condattr_t *cattr); #include <pthread.h> pthread_cond_t cv; pthread_condattr_t cattr; int ret; /* initialize a condition variable to its default value */ ret = pthread_cond_init(&cv, NULL); /* initialize a condition variable */ ret = pthread_cond_init(&cv, &cattr); cattr NULL cattr NULL Solaris 209 cond_init PTHREAD_COND_INITIALIZER PTHREAD_COND_INITIALIZER null pthread_cond_init() pthread_cond_init pthread_cond_init() EINVAL : cattr EBUSY : 4 107

108 EAGAIN : ENOMEM : pthread_cond_wait(3c) mp cv Solaris 211 cond_wait pthread_cond_wait int pthread_cond_wait(pthread_cond_t *cv,pthread_mutex_t *mutex); #include <pthread.h> pthread_cond_t cv; pthread_mutex_t mp; int ret; /* wait on condition variable */ ret = pthread_cond_wait(&cv, &mp); pthread_cond_signal() pthread_cond_broadcast() pthread_cond_wait() pthread_cond_wait()

109 pthread_cond_wait() pthread_cond_wait() pthread_cond_wait() while() pthread_mutex_lock(); while(condition_is_false) pthread_cond_wait(); pthread_mutex_unlock(); pthread_cond_wait() pthread_cond_wait pthread_cond_wait() EINVAL : cv mp cv pthread_cond_signal(3c) Solaris 213 cond_signal pthread_cond_signal int pthread_cond_signal(pthread_cond_t *cv); #include <pthread.h> pthread_cond_t cv; int ret; 4 109

110 /* one condition variable is signaled */ ret = pthread_cond_signal(&cv); pthread_cond_wait() SCHED_OTHER pthread_cond_signal() 4 8 pthread_cond_wait() pthread_cond_signal() pthread_mutex_t count_lock; pthread_cond_t count_nonzero; unsigned count; decrement_count() { pthread_mutex_lock(&count_lock); while (count == 0) pthread_cond_wait(&count_nonzero, &count_lock); count = count - 1; pthread_mutex_unlock(&count_lock); increment_count() { pthread_mutex_lock(&count_lock); if (count == 0) pthread_cond_signal(&count_nonzero);

111 4 8 pthread_cond_wait() pthread_cond_signal() count = count + 1; pthread_mutex_unlock(&count_lock); pthread_cond_signal pthread_cond_signal() EINVAL : cv 4 8 pthread_cond_wait() pthread_cond_signal() pthread_cond_timedwait(3c) pthread_cond_wait() abstime pthread_cond_timedwait() pthread_cond_timedwait int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mp, const struct timespec *abstime); #include <pthread.h> #include <time.h> pthread_cond_t cv; pthread_mutex_t mp; timestruct_t abstime; int ret; /* wait on condition variable */ 4 111

112 ret = pthread_cond_timedwait(&cv, &mp, &abstime); pthread_cond_timewait() pthread_cond_timedwait() Solaris 211 cond_timedwait pthread_cond_timedwait() pthread_cond_timedwait() 4 9 pthread_timestruc_t to; pthread_mutex_t m; pthread_cond_t c;... pthread_mutex_lock(&m); to.tv_sec = time(null) + TIMEOUT; to.tv_nsec = 0; while (cond == FALSE) { err = pthread_cond_timedwait(&c, &m, &to); if (err == ETIMEDOUT) { /* timeout, do something */ break; pthread_mutex_unlock(&m); pthread_cond_timedwait pthread_cond_timedwait()

113 EINVAL : cv abstime ETIMEDOUT : abstime 4 9 pthread_cond_reltimedwait_np(3c) pthread_cond_timedwait() pthread_cond_reltimedwait_np() pthread_cond_reltimedwait_np int pthread_cond_reltimedwait_np(pthread_cond_t *cv, pthread_mutex_t *mp, const struct timespec *reltime); #include <pthread.h> #include <time.h> pthread_cond_t cv; pthread_mutex_t mp; timestruct_t reltime; int ret; /* wait on condition variable */ ret = pthread_cond_reltimedwait_np(&cv, &mp, &reltime); pthread_cond_reltimedwait_np() pthread_cond_reltimedwait_np() Solaris cond_reltimedwait(3c) pthread_cond_reltimedwait_np() 4 113

114 pthread_cond_reltimedwait_np() pthread_cond_reltimedwait_np pthread_cond_reltimedwait_np() EINVAL : cv reltime ETIMEDOUT : reltime cv pthread_cond_broadcast(3c) pthread_cond_wait() pthread_cond_broadcast int pthread_cond_broadcast(pthread_cond_t *cv); #include <pthread.h> pthread_cond_t cv; int ret; /* all condition variables are signaled */ ret = pthread_cond_broadcast(&cv); pthread_cond_broadcast() Solaris 213 cond_broadcast pthread_cond_broadcast() pthread_cond_broadcast() pthread_cond_broadcast()

115 4 10 pthread_mutex_t rsrc_lock; pthread_cond_t rsrc_add; unsigned int resources; get_resources(int amount) { pthread_mutex_lock(&rsrc_lock); while (resources < amount) { pthread_cond_wait(&rsrc_add, &rsrc_lock); resources -= amount; pthread_mutex_unlock(&rsrc_lock); add_resources(int amount) { pthread_mutex_lock(&rsrc_lock); resources += amount; pthread_cond_broadcast(&rsrc_add); pthread_mutex_unlock(&rsrc_lock); add_resources() resources pthread_cond_broadcast() 4 115

116 pthread_cond_wait() pthread_cond_broadcast pthread_cond_broadcast() EINVAL : cv pthread_cond_destroy(3c) cv Solaris 210 cond_destroy pthread_cond_destroy int pthread_cond_destroy(pthread_cond_t *cv); #include <pthread.h> pthread_cond_t cv; int ret; /* Condition variable is destroyed */ ret = pthread_cond_destroy(&cv); pthread_cond_destroy pthread_cond_destroy() EINVAL : cv

117 pthread_cond_signal() pthread_cond_broadcast() pthread_cond_signal() pthread_cond_broadcast() pthread_cond_wait() pthread_cond_signal() pthread_cond_broadcast() 4 11 (less) (more) 4 11 typedef struct { char buf[bsize]; int occupied; int nextin; int nextout; pthread_mutex_t mutex; 4 117

118 4 11 pthread_cond_t more; pthread_cond_t less; buffer_t; buffer_t buffer; 4 12 buffer pthread_cond_wait() pthread_cond_wait() less less pthread_cond_wait() 4 12 less pthread_cond_wait() more pthread_cond_signal() 4 12 void producer(buffer_t *b, char item) { pthread_mutex_lock(&b->mutex); while (b->occupied >= BSIZE) pthread_cond_wait(&b->less, &b->mutex);

119 4 12 assert(b->occupied < BSIZE); b->buf[b->nextin++] = item; b->nextin %= BSIZE; b->occupied++; /* now: either b->occupied < BSIZE and b->nextin is the index of the next empty slot in the buffer, or b->occupied == BSIZE and b->nextin is the index of the next (occupied) slot that will be emptied by a consumer (such as b->nextin == b->nextout) */ pthread_cond_signal(&b->more); pthread_mutex_unlock(&b->mutex); assert() NDEBUG assert() assert() assert() /* now: either b->occupied

120 mutex_unlock() assert() char consumer(buffer_t *b) { char item; pthread_mutex_lock(&b->mutex); while(b->occupied <= 0) pthread_cond_wait(&b->more, &b->mutex); assert(b->occupied > 0); item = b->buf[b->nextout++]; b->nextout %= BSIZE; b->occupied--; /* now: either b->occupied > 0 and b->nextout is the index of the next occupied slot in the buffer, or b->occupied == 0 and b->nextout is the index of the next (empty) slot that will be filled by a producer (such as

121 4 13 b->nextout == b->nextin) */ pthread_cond_signal(&b->less); pthread_mutex_unlock(&b->mutex); return(item); E. W. Dijkstra Dijkstra P 1 V 1 P 1 P V V 2 Dijkstra P V P prolagen proberen te verlagen V verhogen Dijkstra EWD 74 sem_wait(3rt) sem_post(3rt) Dijkstra P V sem_trywait(3rt) P

122 V sem_post(3rt) go to POSIX fork() pshared ID ID open retrieve close remove sem_open sem_getvalue sem_close sem_unlink sem_open sem_open sem_getvalue sem_close sem_unlink sem_init 125 sem_post

123 sem_wait 126 sem_trywait 127 sem_destroy sem_init(3rt) sem value sem_init int sem_init(sem_t *sem, int pshared, unsigned int value); #include <semaphore.h> sem_t sem; int pshared; int ret; int value; /* initialize a private semaphore */ pshared =0; value =1; ret = sem_init(&sem, pshared, value); pshared pshared Solaris 214 sema_init 4 123