Quiz: Simple Sol Threading Model. Pthread: API and Examples Synchronization API of Pthread IPC. User, kernel and hardware. Pipe, mailbox,.

Transcription

1 CS341: Operating System Lect18 : 10 th Sept 2014 Dr. A. Sahu Dept of Comp. Sc. & Engg. Indian Institute of Technology Guwahati 1 Quiz: Simple Sol Threading Model User, kernel and hardware Pthread: API and Examples Synchronization API of Pthread IPC Pipe, mailbox,. 2 Next arrival of T1 wc1 wc2 wc3 wc4 K*wc1 K *wc2 K * wc3 K * wc4 EDF Test: New EDF Test (wc i /p i ) < 1 at max freq = F max K* [ (wc i /p i )] = 1 at freq = F max /K 3 4 Many application run multiple process/thread to do a collaborative work Multi process Apps Example: Chrome Browser, IE9, Adobe PDF, Multi threaded Apps Core Video studio, Adobe Phtoshop, MS Excel From user point of view all are same.. they can take benefit of multicore 5 6 1

2 Most modern applications are multithreaded Threads run within application Multiple tasks with the application can be implemented by separate threads Update display, Fetch data, Spell checking, Answer a network request Process creation is heavy weight while thread creation is light weight Thread as Light Weight Process Cansimplifycode code, increaseefficiency efficiency Kernels are generally multithreaded (1) Request (2) Create a new thread to service the request Client Server Thread (3) Resume listening for additional client requests Responsiveness may allow continued execution if part of process is blocked, especially important for user interfaces Resource Sharing threads share resources of process, easierthanshared shared memory or message passing (to be discussed IPC/send/pipe) Economy cheaper than process creation, thread switching lower overhead than context switching Scalability process can take advantage of multiprocessor architectures Multicoreor multiprocessor systems putting pressure on programmers, challenges include: Dividing activities, Balance Data splitting, Data dependency Testing and debugging Parallelismimplies a system can perform more than one task simultaneously Concurrencysupports more than one task making progress Single processor / core, scheduler providing concurrency Types of parallelism Data parallelism distributes subsets of the same data across multiple cores, same operation on each Task parallelism distributing threads across cores, each thread performing unique operation As # of threads grows, so does architectural support for threading CPUs have cores as well as hardware threads SPARC T4with 8 cores, and 8 hardware threads per core Intel Core i7: 4 cores, 2 thread per core 2

3 Concurrent execution on single-core Code Data Files Code Data Files Single Core T1 T2 T3 T4 T1 T2 T3 T4 T1 Time Parallelism on a multi-core system: Core 1 T1 T3 T1 T3 T1 T3 Registers Thread Stack Registers Stack Registers Stack Registers Stack Thread Core 2 T2 T4 T2 T4 T2 T4 Time Single threaded process Multi threaded process MutithreadedApps Code, Data and Files are shared Easy to create, terminate and schedule/manage in user level, Faster as compared to process Data shared: Lock OS treat all thread of one process as one process. If one Thread block by I/O all the thread get blocked Multiprocess Apps Code, Data and Files are not shared. So creation and termination is costly Data/Information shared through communication IPC : Pipe, Socket, send/recieve 15 Adv thread: Thread have less overhead to start/terminate than process Very little memory copying is required Threads are faster to start than processes. To start a process, the whole process area must be duplicated for the new process copy to start. 16 Adv of Thread: Faster task switching Faster switching between threads The CPU caches and program context can be maintained between threads in a process But Btreloaded lddin case of switching to other process. Adv of Thread: Data sharing For tasks that require sharing large amounts of data All threads share a process s memory pool 17 Disadvantage of thread over process DisAdvThread: Synchronization overhead of shared data Shared data that is modified requires special handling in the form of locks, mutexes To ensure that data is not being read while written, nor written by multiple threads at the same time. 18 3

4 DisAdvThread:Shared process memory space All threads in a process share the same memory space. If something goes wrong in one thread and causes data corruption or an access violation, then this affects and corrupts all the threads in that process DisAdv Thread: Program debugging multi threaded programs present difficulties in finding and resolving bugs Synchronization issues, non deterministic timing and accidental data corruption all conspire to make debugging more difficult 19 Many application run multiple process to do a collaborative work Example: Chrome Browser, IE9, Adobe PDF, They need to share some information to do the collaboration Information sharing Message passing read/write or send/recive Pipe Socket 20 Identifies performance gains Adding additional cores to an application that has both serial and parallel components Sis serial portion, Nprocessing cores Sp S N Let an application is 75% parallel & 25% serial Moving from 1 to 2 cores results in speedup of 1.6 times As Napproaches infinity, speedup approaches 1 / S Serial portion has disproportionate effect on performance gained by adding additional cores S User threads management done by userlevel threads library Three primary thread libraries: POSIX Pthreads, Windows threads, Java threads Kernel threads Supported by the Kernel Examples virtually all general purpose operating systems, including: Windows, Solaris, Linux Kernels are generally multithreaded (kthread) Pthread : user level thread To make concurrency cheaper the execution aspect of process is separated out into threads. OS manages/schedule threads and processes All thread operations are implemented in the kernel OS managed threads are called kernel level threads or light weight processes Window NT: Thread, Solaris: LWP 23 The kernel knows about and manages the threads No runtime system is needed in this case. Kernel A Athread dtbl table that tkeeps track of all llthreads in the system. In addition, process table to keep track of processes. OS kernel provides system call to create and manage threads 24 4

5 ADV: As kernel has full knowledge of all threads Scheduler may decide to give more time to a process having large number of threads than process having small number of threads. ADV: kthreadsare especially good for apps that frequently block. DISADV: The kthreadsare slow and inefficient. threads operations are hundreds of times slower than that of user level threads. DISADV: Since kernel must manage and schedule threads as well as processes. It require a full thread control block (TCB) for each thread to maintain information about threads. As a result there is significant overhead and increased in kernel complexity. 25 Kthreadsmake concurrency much cheaper than process because, much less state to allocate and initialize. However, for fine grained concurrency kthreads still suffer from too much overhead. Thread operations still require system calls. Ideally, we require thread operations to be as fast as a procedure call. For fine grained concurrency we need "cheaper" threads. To make threads cheap and fast, they need to be implemented at user level. 26 User Level threads are managed Entirely by the run time system (user level library). Kernel knows nothing about user level threads Manages them as if they were single threaded processes. User Level threads are small and fast Each Uthreadis represented by a PC,register,stack, and small thread control block. Done via procedure call. i.eno kernel involvement Creating a new thread, switichingbetween threads, and synchronizing threads are Uthreadsare 100xfaster than Kthreads The most obvious advantage of this technique uthread package can be implemented on an OS that does not support kthreads. uthreadsdoes not require modification to OS Simple Representation Each thread is represented simply by a PC, registers, stack andasmallcontrolblocktcba all stored in the user process address space. Simple Management Creating a thread, thread switching and synch threads All be done without intervention of the kernel. Fast and Efficient Thread switching is not much more expensive than a procedure call 29 Uthreadsare not a perfect solution as with everything else, they are a trade off. Since, Uthreadsare invisible to the OS they are not well integrated with the OS, As a result, 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 run and unschedulinga process with a thread holding a lock. Solving this requires communication between betweenkernel and user level thread manager. 30 5

6 Lack of coordination between threads and OS Process as whole gets one time slice irrespective of whether process has one thread or 1000 threads within. Uthreadsrequires non blocking systems calli.e., a multithreaded kernel. Otherwise, entire process will blocked in the kernel, even if there are runablethreads left in the processes. For example, if one thread causes a page fault, the process blocks. Many to One One to One Many to Many 31 Many user level threads mapped to single kernel thread One thread blocking causes all to block Multiple threads may not run in parallel on muticore system because only one may be in kernel at a time Few systems currently use this model Examples: Solaris Green Threads GNU Portable Threads User thread Each user level thread maps to kernel thread Creating a user level thread creates a kernel thread More concurrency than many to one Number of threads per process sometimes restricted due to overhead Examples: Windows, Linux, Solaris 9 and later User thread Kernel thread Kernel thread Allows many user level threads to be mapped to many kernel threads Allows the operating system to create a sufficient number of kernel threads Solaris prior to version 9 Windows with thethreadfiberpackage User thread Similar to M:M, except that it allows a user thread to be boundto kernel thread Examples IRIX, HP UX, Tru64 UNIX Solaris 8 and earlier User thread Kernel thread Kernel thread 6

7 Uthread, Kthread Hthread(hardware thread) : MIT term HART Provided by hardware CPU Mapping Kthreadto Hthread(Same model) Mapping Uthreadto tohthread(by passing Kthread) HART Allow creation an Uthreadif a Hthreadis free Thread affinity Suppose a thread is suitable to a particular Hthread Benefit of cache and resources 37 #define _GNU_SOURCE #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <errno.h> #define handle_error_en(en, msg) \ do { errno= en; perror(msg); exit(exit_failure); while (0) intmybenchmark() { while(1); intmain(intargc, char*argv[]){ // a.out3 # run the apps on core id =3 intproc,s; // Check on System Monitor Apps cpu_set_t t cpuset; pthread_t thread; thread = pthread_self(); Proc=atoi(argv[1]); CPU_ZERO(&cpuset); CPU_SET(Proc, &cpuset); s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset); MYBenchmark(); exit(exit_success); 38 Thread libraryprovides programmer API for creating and managing threads Two primary ways of implementing Library entirely in user space Kernel level library supported by the OS May be provided either as user level or kernellevel A POSIX standard (IEEE c) API for thread creation and synchronization Posix( Portable OS Interface) API specifies behavior of the thread library, implementation is up to development of the library Common in UNIX operating systems Solaris, Linux, Mac OS X #include <stdio.h> #include <stdlib.h> #include <pthread.h> void *thr_func( void *ptr ){ char *message; message = (char *) ptr; printf("%s \n", message); int main() { pthread_t thr1, thr2; const char *MSG1="Thr 1, *MSG2="Thr 2"; int iret1, iret2; iret1 = pthread_create( &thr1, NULL, thr_func, (void*) MSG1); iret2 = pthread_create( &thr2, NULL, thr_func, (void*) MSG2); pthread_join(thr1, NULL); pthread_join(thr2, NULL); exit(0); $ g++ -pthread pthread1.c o pthread1 7

8 #define NTH 10 void SimpleCnt() { for(int i=0;i<10;i++) counter++; int counter = 0; int main() { thread_t th[nth]; int i, j; for(i=0; i < NTH; i++) { thread_create(&th[i],null,simplecnt,null); for(j=0; j < NTH; j++) { pthread_join( th[j], NULL); printf("final Ctr val: %d\n", counter); #define NTH 10 pthread_mutex_t M = 0; void MutexCnt() { for(int i=0;i<10;i++){ pthread_mutex_lock( &M ); counter++; pthread_mutex_unlock( &M); int counter = 0; int main() { thread_t th[nth]; int i, j; for(i=0; i < NTH; i++) { thread_create(&th[i],null,mutexcnt,null); for(j=0; j < NTH; j++) { pthread_join( th[j], NULL); printf("final Ctr val: %d\n", counter); Thanks. spin lock CS critical section Resets lock upon exit 48 8