CPSC 341 OS & Networks. Threads. Dr. Yingwu Zhu

Transcription

1 CPSC 341 OS & Networks Threads Dr. Yingwu Zhu

2 Processes Recall that a process includes many things An address space (defining all the code and data pages) OS resources (e.g., open files) and accounting information Execution state (PC, SP, regs, etc.) Creating a new process is costly because of all of the data structures that must be allocated and initialized FreeBSD: 81 fields, 408 bytes which does not even include page tables, etc. Communicating between processes is costly because most communication goes through the OS Overhead of system calls and copying data

3 Parallel Programs Recall the Web server example that forks off copies of itself to handle multiple simultaneous requests Or any parallel program that executes on a multiprocessor To execute these programs we need to Create several processes that execute in parallel Cause each to map to the same address space to share data They are all part of the same computation Have the OS schedule these processes in parallel (logically or physically) This situation is very inefficient Space: PCB, page tables, etc. Time: create data structures, fork and copy addr space, etc.

4 Rethinking Processes What is similar in these cooperating processes? They all share the same code and data (address space) They all share the same privileges They all share the same resources (files, sockets, etc.) What don t they share? Each has its own execution state: PC, SP, and registers Key idea: Why don t we separate the concept of a process from its execution state? Process: address space, privileges, resources, etc. Execution state: PC, SP, registers Exec state also called thread of control, or thread

5 Threaded Applications Web browsers: display and data retrieval Web servers Many others

6 Threads Modern OSes (Mach, Chorus, NT, modern Unix) separate the concepts of processes and threads The thread defines a sequential execution stream within a process (PC, SP, registers) The process defines the address space and general process attributes (everything but threads of execution) A thread is bound to a single process Processes, however, can have multiple threads Threads become the unit of scheduling Processes are now the containers in which threads execute Processes become static, threads are the dynamic entities

7 Threads Basic unit of CPU utilization Each thread contains its own (my privacy!) Thread ID PC Register set Stack All threads in a process share (do not pollute the public area!) Text section (program) Heap Data section (global variables) File descriptors

8 Threads in a Process

9 Process/Thread Separation Separating threads and processes makes it easier to support multithreaded applications Creating concurrency does not require creating new processes Concurrency (multithreading) can be very useful Improving program structure Handling concurrent events (e.g., Web requests) Writing parallel programs So multithreading is even useful on a uniprocessor

10 Why Multithreading? Creating processes are expensive! Responsiveness Web browsers: one thread for interactivity while others are retrieving images Resource Sharing share memory and resources of the process they belong to Sharing code and data allow different threads of activity within the same address space Economy Processes are expensive to create, and do context-switch In Solaris Process creating is about 30 times slower Context-switch is about 5 times slower Utilization of MP Architectures A single-threaded process can only run on one CPU

11 Threads: Concurrent Servers

12 Threads: Concurrent Servers

13 Thread Type User threads Kernel threads Three primary thread libraries: POSIX Pthreads (user & kernel): our case study Win32 threads (kernel-level) Java threads (depending on OS)

14 Kernel Threads Supported by the Kernel OS-managed threads are called kernel-level threads or lightweight processes NT: threads Solaris: lightweight processes (LWP) Advantages Non-blocking thread execution (Similar to processes, when a kernel thread makes a blocking call, only that thread blocks ) Multi-processors (threads on different processors) No need to worry about starving other threads, preemptive scheduling

15 Kernel Thread Limitations Kernel-level threads make concurrency much cheaper than processes Much less state to allocate and initialize However, for fine-grained concurrency, kernel-level threads still suffer from too much overhead Thread operations still require system calls Ideally, want thread operations to be as fast as a procedure call Kernel-level threads have to be general to support the needs of all programmers, languages, runtimes, etc. For such fine-grained concurrency, need even cheaper threads

16 User Thread To make threads cheap and fast, they need to be implemented at user level Kernel-level threads are managed by the OS User-level threads are managed entirely by the run-time system (user-level library) User-level threads are small and fast A thread is simply represented by a PC, registers, stack, and small thread control block (TCB) Creating a new thread, switching between threads, and synchronizing threads are done via procedure call No kernel involvement; No kernel resources allocated to the threads User-level thread operations 100x faster than kernel threads

17 User Thread Limitations But, user-level threads are not a perfect solution As with everything else, they are a tradeoff User-level threads are invisible to the OS They are not well integrated with the OS As a result, the OS can make poor decisions Scheduling a process with idle threads Blocking a process whose thread initiated an I/O, even though the process has other threads that can execute Unscheduling a process with a thread holding a lock A single thread can monopolize the timeslice thus starving the other threads within the same process Solving this requires communication between the kernel and the user-level thread manager

18 Kernel vs. User Threads Kernel-level threads Integrated with OS (informed scheduling) Slow to create, manipulate, synchronize User-level threads Fast to create, manipulate, synchronize Not integrated with OS (uninformed scheduling) Understanding the differences between kernel and user-level threads is important For programming (correctness, performance) For test-taking

19 Kernel vs. User Threads Another possibility is to use both kernel and user-level threads Can associate a user-level thread with a kernel-level thread Or, multiplex user-level threads on top of kernel-level threads Java Virtual Machine (JVM) Java threads are user-level threads On older Unix, only one kernel thread per process Multiplex all Java threads on this one kernel thread On NT, Solaris, OSF Can multiplex Java threads on multiple kernel threads Can have more Java threads than kernel threads Why?

20 Kernel vs. User Threads

21 Case Study: Pthread How to Compile Creating and destroying threads How to use POSIX threads

22 Reading Materials Reading posted suppl. material on threads 4.1 in the chapter

23 How to compile? $ gcc Wall o proj proj.c pthread or $ g++ Wall o proj proj.cpp pthread The option specifies that pthreads library should be linked (libpthread: pthread APIs) causes the complier to properly handle multiple threads in the code that it generates Other platform/compiler may user other options, eg., -lpthread #include <pthread.h> All thread functions and data types are declared in the header file

24 Creating Threads int pthread_create (pthread_t *thread_id, pthread_attr_t *attr, void *(*thread_fun)(void *), void *args); - The #1 para returns thread ID (a unique ID per thread) The #2 para pointing to thread attr. NULL represents using the default attr. settings; controls details of how the thread interacts with the rest of the program - The #3 para as pointer to a function the thread is to execute, of the type: void* (*) (void*) The function receives an argument in #4 and return data from the thread to the creator; entry point of the created thread s execution! - The #4 para is the arguments to the function - Return 0 on success; failure otherwise

25 Creating Threads pthread_create() A call to pthread_create returns immediately, and the original thread continues executing the instructions following the call Meanwhile, the new thread begins executing the thread function. Simply put, they run concurrently competing for CPU cycles. Hard to predict the execution order (that is why we study Synchronization later)

26 Creating Threads #include <pthread.h> #include <stdio.h> void * entry_point(void *arg) { printf("hello world!\n"); return NULL; } int main(int argc, char **argv) { pthread_t thr; if(pthread_create(&thr, NULL, &entry_point, NULL)) { printf("could not create thread\n"); return -1; } if(pthread_join(thr, NULL)) { printf("could not join thread\n"); return -1; } return 0; }

27 Thread Terminates & Return Value Pthreads terminate when the function returns, or the thread calls pthread_exit() int pthread_exit(void *status); status is the return value of the thread A thread_fun returns a void*, so calling return (void *) is the equivalent of this function the pthread_exit() routine does not close files; any files opened inside the thread will remain open after the thread is terminated

28 Example #include <pthread.h> #include <stdio.h> void * entry_point(void *arg) { printf("hello world!\n"); pthread_exit(null); //return NULL; } int main(int argc, char **argv) { pthread_t thr; if(pthread_create(&thr, NULL, &entry_point, NULL)) { printf("could not create thread\n"); return -1; } if(pthread_join(thr, NULL)) { printf("could not join thread\n"); return -1; } return 0; }

29 Joining Threads int pthread_join(pthread_t thread_id, void **status) #1 para: the thread ID of the thread to wait for #2 para: receive the finished thread s return value One thread can wait (or block) on the termination of another by using pthread_join() You can collect the exit status of all threads you created by pthread_join(), via status Similar to system call wait() in processes

30 Example #include <pthread.h> #include <stdio.h> void * entry_point(void *arg) { printf("hello world!\n"); pthread_exit(null); //return NULL; } int main(int argc, char **argv) { pthread_t thr; if(pthread_create(&thr, NULL, &entry_point, NULL)) { printf("could not create thread\n"); return -1; } if(pthread_join(thr, NULL)) { printf("could not join thread\n"); return -1; } return 0; }

31 Kill Threads Kill a thread before it returns normally using pthread_cancel() But Make sure the thread has released any local resources; unlike processes, the OS will not clean up the resources Why? Threads in a process share resources

32 #include <pthread.h> #include <stdio.h> /* Parameters to print_function. */ struct char_print_parms { }; /* The character to print. */ Passing Data to Threads char character; /* The number of times to print it. */ int count; /* Prints a number of characters to stderr, as given by PARAMETERS, which is a pointer to a struct char_print_parms. */ void* char_print (void* parameters) { } /* Cast the cookie pointer to the right type. */ struct char_print_parms* p = (struct char_print_parms*) parameters; int i; for (i = 0; i < p->count; ++i) fputc (p->character, stderr); return NULL;

33 Passing Data to Threads int main () { pthread_t thread1_id; pthread_t thread2_id; struct char_print_parms thread1_args; } /* Create a new thread to print 30,000 x s. */ thread1_args.character = x ; thread1_args.count = 30000; pthread_create (&thread1_id, NULL, &char_print, (void*)&thread1_args); /* Create a new thread to print 20,000 o s. */ thread1_args.character = o ; thread1_args.count = 20000; pthread_create (&thread2_id, NULL, &char_print, (void*)&thread1_args); return 0;

34 Passing Data to Threads One argument as void* Common practice Pass a pointer to some structure or array of data The above program example has a problem thread1_args Solution?

35 Passing Data to Threads int main () { pthread_t thread1_id; pthread_t thread2_id; struct char_print_parms thread1_args; struct char_print_parms thread2_args; /* Create a new thread to print 30,000 x s. */ thread1_args.character = x ; thread1_args.count = 30000; pthread_create (&thread1_id, NULL, &char_print, (void*)&thread1_args); /* Create a new thread to print 20,000 o s. */ thread2_args.character = o ; thread2_args.count = 20000; pthread_create (&thread2_id, NULL, &char_print, (void*)&thread2_args); return 0; }

36 Problems/Bugs? Wait! We have one more BUG!

37 Passing Data to Threads One argument as void* Can not use local structure!!!! Why? (what if the main thread exits first!) Common practice Pass a pointer to some structure or array of data

38 Example on Passing Data struct thread_data{ int thread_id; int sum; char *message; }; struct thread_data thread_data_array[num_threads]; //global void *PrintHello(void *threadarg) { struct thread_data *my_data;... my_data = (struct thread_data *) threadarg; taskid = my_data->thread_id; sum = my_data->sum; hello_msg = my_data->message;... } int main (int argc, char *argv[]) {... thread_data_array[t].thread_id = t; thread_data_array[t].sum = sum; thread_data_array[t].message = messages[t]; rc = pthread_create(&threads[t], NULL, PrintHello, (void *) &thread_data_array[t]);... }

39 Returning Results from Threads Thread function returns a pointer to void: void * Pitfalls in return value

40 Pitfall #1 void *thread_function ( void *) { int code = DEFAULT_VALUE; return ( void *) code ; } Only work in machines where integers can convert to a point and then back to an integer without loss of information

41 Pitfall #2 void *thread_function ( void *) { char buffer[64]; // fill up the buffer with sth good return ( void *) buffer; } This buffer will disappear as the thread function returns

42 Pitfall #3 void *thread_function ( void *) { static char buffer[64]; // fill up the buffer with sth good return ( void *) buffer; } It does not work in the common case of multiple threads running the same thread funciton

43 Right Way void *thread_function ( void *) { char* buffer = (char *)malloc(64); // fill up the buffer with sth good return ( void *) buffer; }

44 Right Way int main() { void *exit_state; char *buffer;. pthread_join(tid, &exit_state); buffer = (char *) exit_state; printf( from thread %d: %s\n, tid, buffer); free(exit_state); }

45 Exercise Write a multithreaded program that calculates the summation of a non-negative integer in a separate thread ( N) The non-negative integer is from command-line parameter

46 Exercise Write a multithreaded program that calculates the summation of a non-negative integer in a separate thread ( N) The non-negative integer is from command-line parameter Option 1: The summation result is kept in a global variable: int sum; // shared by threads Option 2: The summation result is returned.

47 Step 1: write a thread function void *thread_sum(void *arg) { int i; int m = (int)(*arg); sum = 0; //initialization for (i = 0; i <= m; i++) sum += i; pthread_exit(0); }

48 Step 2: write the main() int sum; int main(int argc, char *argv[]) { pthread_t tid; if (argc!= 2) { printf( Usage: %s <integer-para>\n, argv*0+); return -1; } int i = atoi(argv[1]); if (i < 0) { printf( integer para must be non-negative\n ); return -2; } pthread_create(&tid, NULL, thread_sum, &i); //need to check return value pthread_join(tid, NULL); //need to check return value printf( sum = %d\n, sum); }

49 Exercise Write a program that creates 10 threads. Have each thread execute the same function and pass each thread a unique number. Each thread should print Hello, World (thread n) five times where n is replaced by the thread s given number. Be sure the program doesn t terminate until all the threads are complete. (Try running your program on more than one machine. Are there any differences in how it behaves?)

50 Exercise Which of the following components of program state are shared across threads in a multithreaded process? a. register values b. heap memory c. Global variables d. stack memory

51 What is output? #include <pthread.h> #include <stdio.h> int value = 0; void* runner(void* param); int main(int argc, char* argv[]) { int pid; pthread_t tid; pid = fork(); if (!pid) { pthread_create(&tid, NULL, runner, NULL); pthread_join(tid, NULL); printf( CHILD: value= %d\n, value); } else if (pid>0) { wait(null); printf( PARENT: value = %d\n, value); } } void* runner (void* param) { value = 5; phread_exit(0); }