pthreads CS449 Fall 2017

Transcription

1 pthreads CS449 Fall 2017

2 POSIX Portable Operating System Interface Standard interface between OS and program UNIX-derived OSes mostly follow POSIX Linux, macos, Android, etc. Windows requires separate posix runtime environment Interface includes: System calls, signals, process management C Standard Library interface Utilities and shell commands Thread management

3 Pthreads (POSIX threads) Standard programming API for threads Implementation varies for different OSes: Can be implemented through user threads Can be implemented through kernel threads Regardless, Pthreads programs must run correctly (although performance may differ)

4 Linux Thread Implementation Native POSIX Thread Library (NPTL) Native: Implemented using kernel threading Rely on kernel to create / schedule threads POSIX Thread: Follows the Pthread standard Library: Implemented in the form of a library Underlying system calls vary between Linux versions Compare: Windows Thread API API (in the form of system calls) not POSIX But also uses kernel threading

5 Compiling with Pthreads Need pthread option for linking and compiling gcc o threadtest threadtest.c -pthread During Compiling: Defines macros that enables thread-safe code in header files (e.g. _REENTRANT) During Linking: Links in the library libpthread.so DO NOT use lpthread option Will link in libpthread.so library but not define macros Some C library calls will become thread-unsafe (E.g. errno global variable used in file operations) Program will run but will malfunction from time to time

6 Pthread API In <pthread.h>, int pthread_create(pthread_t * tid, const pthread_attr_t * attr, void * (*start_routine)(void *), void * arg); è Creates a new thread that executes start_routine() with argument arg è Updates *tid to thread ID of new thread int pthread_yield(void); è Yields CPU to another thread void pthread_exit(void * value_ptr); è Terminates current thread int pthread_join(pthread_t tid, void ** value_ptr); è Waits for thread tid to terminate

7 pthread_create() #include <stdio.h> #include <pthread.h> void *do_stuff(void *p) { } printf("hello from %s thread\n", (char *)p); int main() { pthread_t tid; char *arg1 = "child", *arg2 = "parent"; } pthread_create(&tid, NULL, do_stuff, arg1); do_stuff(arg2); return 0;

8 Output Hello from parent thread Hello from Hello from child thread What happened? A race between the parent and child threads Parent tries to flush output buffer to stdout (after return from main and before exiting program) Child tries to fill output buffer by calling printf() è Parent flushes output buffer when it is half-filled Non-deterministic: depending on speed of each thread, the correct output could have printed!

9 #include <stdio.h> #include <pthread.h> pthread_yield void *do_stuff(void *p) { } printf("hello from %s thread\n", (char *)p); int main() { pthread_t tid; char *arg1 = "child", *arg2 = "parent"; } pthread_create(&tid, NULL, do_stuff, arg1); do_stuff(arg2); pthread_yield(); // yield to child before returning return 0;

10 Output Hello from parent thread Hello from child thread Hello from child thread Race still exists Parent voluntarily yields current processor Parent will be placed at the end of queue of ready threads But no guarantee of ordering No guarantee of when the parent will start running again Not a form of synchronization Still non-deterministic

11 pthread_join #include <stdio.h> #include <pthread.h> void *do_stuff(void *p) { } printf("hello from %s thread\n", (char *)p); int main() { pthread_t tid; char *arg1 = "child", *arg2 = "parent"; } pthread_create(&tid, NULL, do_stuff, arg1); do_stuff(arg2); pthread_join(tid, NULL); // wait for child to terminate return 0;

12 Output Hello from parent thread Hello from child thread Now no race exists pthread_join(): synchronizes between two threads Current thread waits for specified thread to finish Still non-deterministic (in a way) Child thread may print before the parent thread But both outputs are deemed legal, so no race How about the race between the two printf()s? Printf internally does locking to ensure output is not interleaved Locking is another form of synchronization we will learn later

13 pthread_create() int pthread_create( ); pthread_t *tid, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg tid: (buffer for) a unique thread ID attr: thread attributes or NULL for the default start_routine: pointer to function to execute arg: the argument to pass to this function

14 Start Routine Runs on a New Stack pthread_create() internally: arg start_routine attr tid pthread_create pthread_create old $EIP $ESP (parent) pthread_create old $EBP <parent stack>

15 Start Routine Runs on a New Stack <child stack> pthread_create() internally: 1. Allocates new stack for new thread using mmap() arg start_routine attr tid pthread_create pthread_create old $EIP $ESP (parent) pthread_create old $EBP <parent stack>

16 Start Routine Runs on a New Stack COPY arg <child stack> pthread_create() internally: 1. Allocates new stack for new thread using mmap() 2. Copies arg from parent stack to new stack $ESP (parent) arg start_routine attr tid pthread_create old $EIP pthread_create old $EBP <parent stack> pthread_create

17 Start Routine Runs on a New Stack arg $ESP (child) pthread_create() internally: 1. Allocates new stack for new thread using mmap() 2. Copies arg from parent stack to new stack 3. Has new thread call start_routine on new stack $ESP (parent) start_routine old $EIP start_routine old $EBP <child stack> arg start_routine attr tid pthread_create old $EIP pthread_create old $EBP <parent stack> start_routine pthread_create

18 Start Routine Argument Passing void *(*start_routine)(void *) Why void * as parameter type? What if routine requires a non-pointer argument? What if routine requires multiple arguments? Why not use variable arguments (like in printf)? Printf can discover number of arguments through format string Pthread_create() cannot discover number of arguments to copy to new stack, because it knows nothing about start_routine But a single void * arg still works! Non-pointer arg x? Just pass a pointer to x (e.g. &x) Two args x and y? Pass pointer to struct with x and y. E.g. A.x = x; A.y = y; pthread_create(,,, &A);

19 Start Routine Value Returning void *(*start_routine)(void *) Why void * as return type? Same logic as for arguments Non-pointer return value? Return a pointer to value location Two args x and y? Return a pointer to struct value location Warning: location cannot be stack location Child stack is destroyed after start_routine returns (Returned pointer will immediately become a dangling pointer) Allocate heap location for returning. E.g. int *ret = malloc(sizeof(int)); *ret = // store return value in heap return ret;

20 pthread_exit() void pthread_exit(void * value_ptr); Called implicitly on start_routine return value_ptr: the value that is returned by start_routine Why is this needed? Return value is stored in a register (e.g. $EAX) or on the stack Threads have separate registers and stacks, so storing to child register / stack will not update parent register / stack Pthread_exit() stores the return value in a location specified by the parent (through pthread_join(), in next slide) Also performs some cleanup (e.g. deallocating thead stack) Programmer call pthread_exit explicitly within routine If no return value, pass NULL as value_ptr

21 pthread_join() int pthread_join( pthread_t tid, void ** value_ptr); Waits for child thread to finish (and produce return value) tid: ID of thread to wait for termination value_ptr: the pointer to location that parent thread wants child thread to store the return value Type is void ** because return value is void * Child will store a void * value by derefencing value_ptr If parent is not interested in the return value, NULL can be passed as value_ptr and return value will be ignored

22 pthread_exit() / pthread_join() void* thread_func(void *arg) { } int *ret = malloc(sizeof(int)); // malloc location *ret = 10; // store value in heap pthread_exit(ret); // store ret to val int main() { } pthread_t tid; int *val; pthread_create(&tid, NULL, thread_func, NULL); pthread_join(tid, (void**)&val); // now val == ret printf( *val=%d\n, *val); // *val == *ret == 10

23 A More Efficient (but Less Portable) Version void* thread_func(void *arg) { } // Force an int return value into a void* pthread_exit(10); // passing int as void* int main() { } pthread_t tid; int val; pthread_create(&tid, NULL, thread_func, NULL); pthread_join(tid, (void**)&val); // now val == 10 printf( val=%d\n, val); // prints 10 as before Less portable: what if int is 32 bits, void* is 16 bits? Converting int to void* will truncate 16 bits But C programmers often do it anyway for efficiency