Lecture 09: Programming with PThreads
Concurrent and Mul core Programming
Department of Computer Science and Engineering Yonghong Yan [email protected] www.secs.oakland.edu/~yan
1 Topics (Part 1)
• Introduc on • Principles of parallel algorithm design (Chapter 3) • Programming on shared memory system (Chapter 7) – OpenMP – PThread, mutual exclusion, locks, synchroniza ons – Cilk/Cilkplus • Analysis of parallel program execu ons (Chapter 5) – Performance Metrics for Parallel Systems • Execu on Time, Overhead, Speedup, Efficiency, Cost – Scalability of Parallel Systems – Use of performance tools
2 Short Review
• Parallel algorithm design 1. Tasks and Decomposi on • Theory and prac ce (axpy, matvec and matmul) 2. Processes and Mapping 3. Minimizing Interac on Overheads
• Prac ce on task and decomposi on – AXPY, Matrix vector mul plica on, matrix matrix mul plica on
3 OpenMP: Worksharing Constructs
Sequential code for(i=0;i #pragma omp parallel shared (a, b) { int id, i, Nthrds, istart, iend; OpenMP parallel id = omp_get_thread_num(); region Nthrds = omp_get_num_threads(); istart = id * N / Nthrds; iend = (id+1) * N / Nthrds; for(i=istart;i 4 Standard OpenMP Implementa on • Direc ves implemented OpenMP Code Translation via code modifica on and int main(void) _INT32 main() { { int a,b,c; inser on of run me int a,b,c; library calls /* microtask */ #pragma omp parallel \ void __ompregion_main1() – Basic step is outlining of code private(c) { in parallel region do_sth(a,b,c); _INT32 __mplocal_c; return 0; /*shared variables are kept intact, • Run me library } substitute accesses to private responsible for managing variable*/ do_sth(a, b, __mplocal_c); threads } – Scheduling loops … – Scheduling tasks /*OpenMP runtime calls */ __ompc_fork(&__ompregion_main1 – Implemen ng ); synchroniza on … } • Implementa on effort is reasonable Each compiler has custom run- me support. Quality of the run me system has major impact on performance. OpenMP Implementa on Applica on main () { writer #pragma omp parallel prin ("Hello,world.!\n"); OpenMP API main () { … __ompc_fork(0, &__ompregion_main1, reg__7); … } Compiler void __ompregion_main1(__ompv_g d_a__0, writer __ompv_slink_a__0) {… prin ((const _INT8 *)(_INT8(*)[15LL]) "Hello,world.!\n"); OpenMP RTL API } …. Library for (i=1; i< threads_to_create; i++) writer { return_value = pthread_create( &(__omp_level_1_pthread[i].uthread_id), &__omp_pthread_a r, Pthread API (pthread_entry) __ompc_level_1_slave, (void *)((unsigned long int)i)); … Execu on Model Start Parallel region1 N-1 threads Ini aliza on M-1 ------Nested threads Execute Micro_task signal Wait on Condi on var. Execute nested Micro_task Parallel region n ------signal Execute Execute Micro_task Micro_task Pthread_exit() Clean up End Level 1 slave thread Nested slave thread Master thread Reused PThread • Processing Element abstrac on for so ware – PThreads – OpenMP/Cilk/others run me use PThreads for their implementa on • The founda on of parallelism from computer system • Topic Overview – Thread basics and the POSIX Thread API – Thread crea on, termina on and joining – Thread safety – Synchroniza on primi ves in PThreads What is a Thread • OS view – An independent stream of instruc ons that can be scheduled to run by the OS. • So ware developer view – A “procedure” that runs independently from the main program • Imagine mul ple such procedures of main run simultaneously and/ or independently – Sequen al program: a single stream of instruc ons in a program. – Mul -threaded program: a program with mul ple streams • Mul ple threads are needed to use mul ple cores/CPUs • A thread is a virtual representa on of a hardware core 9 Thread as “func on instance” A thread is a single stream of control in the flow of a program: X = ! for (i = 0; i < n; i++) y[i] = dot_product(row(A, i),b); for (i = 0; i < n; i++) y[i] = create_thread(dot_product(row(A, i), b)); • think of the thread as an instance of a func on that returns before the func on has finished execu ng. Processes • processes contain informa on about program resources and program execu on state, including: – Process ID, process group ID, user ID, and group ID – Environment, Working directory, Program instruc ons – Registers, Stack, Heap – File descriptors, Signal ac ons – Shared libraries, Inter-process communica on tools (such as message queues, pipes, semaphores, or shared memory). • When we run a program, a process is created – E.g. ./a.out, ./axpy, etc – fork () system call Threads • Threads use, and exist within, the process resources • Scheduled and run as independent en es • Duplicate only the bare essen al resources that enable them to exist as executable code Threads • A thread maintains its own: – Stack pointer – Registers – Scheduling proper es (such as policy or priority) – Set of pending and blocked signals – Thread specific data. • Mul ple threads share the process resources • A thread dies if the process dies • "lightweight” for crea ng and termina ng threads that for processes POSIX threads (Pthreads) • Threads used to implement parallelism in shared memory mul processor systems, such as SMPs • Historically, hardware vendors have implemented their own proprietary versions of threads – Portability a concern for so ware developers. • For UNIX systems, a standardized C language threads programming interface has been specified by the IEEE POSIX 1003.1c standard. – Implementa ons that adhere to this standard are referred to as POSIX threads 14 The POSIX Thread API • Commonly referred to as Pthreads, POSIX has emerged as the standard threads API, supported by most vendors. – Implemented with a pthread.h header/include file and a thread library • Func onali es – Thread management, e.g. crea on and joining – Thread synchroniza on primi ves • Mutex • Condi on variables • Reader/writer locks • Pthread barrier – Thread-specific data • The concepts discussed here are largely independent of the API – Applied to other thread APIs (NT threads, Solaris threads, Java threads, etc.) as well. PThread API • #include • gcc -lpthread 16 Thread Crea on • Ini ally, main() program comprises a single, default thread – All other threads must be explicitly created int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void * arg); • thread: An opaque, unique iden fier for the new thread returned by the subrou ne • a r: An opaque a ribute object that may be used to set thread a ributes You can specify a thread a ributes object, or NULL for the default values • start_rou ne: the C rou ne that the thread will execute once it is created • arg: A single argument that may be passed to start_rou ne. It must be passed by reference as a pointer cast of type void. NULL may be used if no argument is to be passed. Opaque object: A le er is an opaque object to the mailman, and sender and receiver know the informa on. Thread Crea on • pthread_create creates a new thread and makes it executable, i.e. run immediately in theory – can be called any number of mes from anywhere within your code • Once created, threads are peers, and may create other threads • There is no implied hierarchy or dependency between threads 18 Example 1: pthread_create #include for(t=0;t • pthread_exit is used to explicitly exit a thread – Called a er a thread has completed its work and is no longer required to exist • If main()finishes before the threads it has created – If exits with pthread_exit(), the other threads will con nue to execute – Otherwise, they will be automa cally terminated when main()finishes • The programmer may op onally specify a termina on status, which is stored as a void pointer for any thread that may join the calling thread • Cleanup: the pthread_exit()rou ne does not close files – Any files opened inside the thread will remain open a er the thread is terminated Thread A ribute int pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void * arg); • A ribute contains details about – whether scheduling policy is inherited or explicit – scheduling policy, scheduling priority – stack size, stack guard region size • pthread_attr_init and pthread_attr_destroy are used to ini alize/destroy the thread a ribute object • Other rou nes are then used to query/set specific a ributes in the thread a ribute object 21 Passing Arguments to Threads • The pthread_create() rou ne permits the programmer to pass one argument to the thread start rou ne • For cases where mul ple arguments must be passed: – Create a structure which contains all of the arguments – Then pass a pointer to the object of that structure in the pthread_create()rou ne. – All arguments must be passed by reference and cast to (void *) • Make sure that all passed data is thread safe: data racing – it can not be changed by other threads – It can be changed in a determinant way • Thread coordina on Example 2: Argument Passing #include sleep(1); struct thread_data *my_data = (struct thread_data *) threadarg; taskid = my_data->thread_id; hello_msg = my_data->message; printf("Thread %d: %s\n", taskid, hello_msg); pthread_exit(NULL); } Example 2: Argument Passing int main(int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; Thread 3: Klingon: Nuq neH! int t; Thread 0: English: Hello World! char *messages[NUM_THREADS]; Thread 1: French: Bonjour, le monde! messages[0] = "English: Hello World!"; Thread 2: Spanish: Hola al mundo messages[1] = "French: Bonjour, le monde!"; Thread 5: Russian: Zdravstvytye, mir! messages[2] = "Spanish: Hola al mundo"; Thread 4: German: Guten Tag, Welt! messages[3] = "Klingon: Nuq neH!"; Thread 6: Japan: Sekai e konnichiwa! messages[4] = "German: Guten Tag, Welt!"; messages[5] = "Russian: Zdravstvytye, mir!"; Thread 7: La n: Orbis, te saluto! messages[6] = "Japan: Sekai e konnichiwa!"; messages[7] = "Latin: Orbis, te saluto!"; for(t=0;t Suspend execu on of calling thread un l thread terminates #include • It is a logical error to a empt simultaneous mul ple joins on the same thread 25 Example 3: Pthread Joining #include double result=0.0; printf("Thread %ld starting...\n",tid); for (i=0; i<1000000; i++) { result = result + sin(i) * tan(i); } printf("Thread %ld done. Result = %e\n",tid, result); pthread_exit((void*) t); } Example 3: Pthread joining int main (int argc, char *argv[]) Main: crea ng thread 0 { Main: crea ng thread 1 pthread_t thread[NUM_THREADS]; Thread 0 star ng... pthread_attr_t attr; long t; Main: crea ng thread 2 void *status; Thread 1 star ng... Main: crea ng thread 3 /* Initialize and set thread detached attribute */ Thread 2 star ng... pthread_attr_init(&attr); Thread 3 star ng... pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEThread 1 done. Result = -3.153838e+06 ); Thread 0 done. Result = -3.153838e+06 for(t=0; t • All threads have access to the same global, shared memory • Threads also have their own private data • Programmers are responsible for synchronizing access (protec ng) globally shared data. Thread Consequences • Shared State! – Accidental changes to global variables can be fatal. – Changes made by one thread to shared system resources (such as closing a file) will be seen by all other threads – Two pointers having the same value point to the same data – Reading and wri ng to the same memory loca ons is possible – Therefore requires explicit synchroniza on by the programmer • Many library func ons are not thread-safe – Library Func ons that return pointers to sta c internal memory. E.g. gethostbyname() • Lack of robustness – Crash in one thread will crash the en re process 29 Thread-safeness • Thread-safeness: in a nutshell, refers an applica on's ability to execute mul ple threads simultaneously without "clobbering" shared data or crea ng "race" condi ons • Example: an applica on creates several threads, each of which makes a call to the same library rou ne: – This library rou ne accesses/modifies a global structure or loca on in memory. – As each thread calls this rou ne it is possible that they may try to modify this global structure/memory loca on at the same me. – If the rou ne does not employ some sort of synchroniza on constructs to prevent data corrup on, then it is not thread- safe. Thread-safeness Thread-safeness The implica on to users of external library rou nes: • If you aren't 100% certain the rou ne is thread-safe, then you take your chances with problems that could arise. • Recommenda on – Be careful if your applica on uses libraries or other objects that don't explicitly guarantee thread-safeness. – When in doubt, assume that they are not thread-safe un l proven otherwise – This can be done by "serializing" the calls to the uncertain rou ne, etc. Example 4: Data Racing #include • The primary mo va on – To realize poten al program performance gains • Compared to the cost of crea ng and managing a process – A thread can be created with much less OS overhead • Managing threads requires fewer system resources than managing processes • All threads within a process share the same address space • Inter-thread communica on is more efficient and, in many cases, easier to use than inter-process communica on pthread_create vs fork • Timing results for the fork() subrou ne and the pthreads_create() subrou ne – Timings reflect 50,000 process/thread crea ons – units are in seconds – no op miza on flags Why pthreads • Poten al performance gains and prac cal advantages over non- threaded applica ons: – Overlapping CPU work with I/O • For example, a program may have sec ons where it is performing a long I/O opera on • While one thread is wai ng for an I/O system call to complete, CPU intensive work can be performed by other threads. • Priority/real- me scheduling – Tasks which are more important can be scheduled to supersede or interrupt lower priority tasks. • Asynchronous event handling – Tasks which service events of indeterminate frequency and dura on can be interleaved – For example, a web server can both transfer data from previous requests and manage the arrival of new requests. AXPY with PThreads • y = α·x + y – x and y are vectors of size N • In C, x[N], y[N] – α is scalar • Decomposi on and mapping to pthreads A task will be mapped to a pthread 37 AXPY with PThreads 38