Motivation of Threads. Preview. Motivation of Threads. Motivation of Threads. Motivation of Threads. Motivation of Threads 9/12/2018.

Transcription

1 Preview Motivation of Thread Thread Implementation User s space Kernel s space Inter-Process Communication Race Condition Mutual Exclusion Solutions with Busy Waiting Disabling Interrupt Lock Variable Strict Alternation With thread Without interrupts and context change, ability for the parallel entities to share an address space and data Faster creation-os don t need create a memory space for a new thread, don t need protection between threads in a process,.. Useful on system with multiple CPUs, where real parallelism is possible Peterson s Solution 1 2 Many software packages for modern personal computer are multithreaded. An application typically is implemented as a separate process with several threads of control. Each thread on an application do different job. Ex) A web browser with multiple threads 1. A thread for displaying images or text 2. A tread for retrieving data from network Ex) Word processor with multiple threads 1. A thread for displaying graphics 2. A thread for reading input from keyboard 3. A thread for performing spelling and grammar checking in the background 3 4 Process creation method was in common before thread become popular But process creation is very heavy weighted. If the new process will perform the same task as existing process, why incur all that overhead? Ex) client-server program A server is running as a single process waiting for request. When the server receives a request, the server creates a separate thread instead of a process that would list for service

2 Benefits of Thread Threads Implementation Resources Sharing- once a process holds a resource, threads in the process can share the same resource. Economy allocating memory and resources for each process creation is expensive. Threads share resources. Utilization of multi-processor system each thread in a process can run on one CPU in multi-processor system. It can greatly increase a process run time. Implementing thread in user space Threads are handled by the run-time system Run-time system might be developed by software vendor or a system support as library functions (ex. pthread). OS does not know the existence of threads. Run-time system keep tread tables for existing threads. Need scheduler for threads (running, ready, block) Implementing thread in the kernel s space Thread are handled by OS Kernel need keep a thread table per each thread. Must have scheduler for threads. 7 8 The kernel does not know anything about threads. It is just managing single-thread process. The first advantage user-level threads package can be implemented on an operating system that does not support threads. The treads run on top of a run-time system (correction of procedures that manage threads thread_create, thread_exit, thread_yield) 9 10 Each process needs its own private thread table to keep track of the threads in that process (managed by the run-time system). Thread table stack pointer, program counter, registers, state, and so on When a thread s state become ready or blocked state, all information regarding the thread is stored in its own thread table. When a running thread needed to be blocked (waiting for a job done by other thread), 1. it calls a run-time system procedure. 2. The run-time system procedure save the thread s information 3. Choose one thread from the ready queue 4. Load new thread s information and run it When a thread is finished running for the moment, the code of thread_yield, which is running in user s space, save the thread s information and call scheduler, which is also running on user s space do not need system call!!! (no trap is needed)

3 Implementing Threads in Kernel s Space User-level thread allows each process to have its own customized scheduling algorithm. User-level threads are generally fast to create and manage, but they have drawbacks. If the kernel is single-threaded, then any user-level thread performing a blocking system call will cause the entire process to block, even though other threads are available to run within the application. POSIX (Pthreads), Math (C-threads), Solaris 2 (UI-threads) Implementing Threads in Kernel s Space It is directly supported by operating system The kernel performs thread creation, scheduling and management (keep track a thread table for each thread) in kernel s space. Because thread management is done by the operating system, kernel threads are generally slower to created and manage than are user-level thread. Implementing Threads in Kernel s Space Since the kernel is managing the threads, if a thread performs a blocking system call, the kernel can schedule another thread in the application for execution. In a multiprocessor environment, the kernel can schedule threads on different processors. Window NT, Window 2000, Solaris 2, BeOS, Tru64 UNIX Three issues in interprocess communication Critical section (critical region) The part of program where the shared memory is accessed. 1. How one process can pass information to another 2. How to make sure two or more processes do not get into the critical section (mutual exclusion) 3. Proper sequencing (Synchronization) when dependencies are present (ex. A create outputs, B consume the outputs) Race Condition A situation where two or more processes are reading or writing some shared data and the final result depends on who runs precisely when, are called race condition. Mutual Exclusion in a critical section can avoid races condition: If we could arrange matters such that no two processes were ever in their critical regions at the same time, we can avoid races condition

4 Slots for file names When a process want to print a file, it enter a file name in a special spooler directory Printer daemon periodically check spooler directory any file need to be printed. Process A tried to send a job to spooler, Process A read in = 7, process A time out and go to ready state before updating in = in + 1. Process B tried to send a job to spooler. Process B read in = 7, load its job name in slot 7, update i = i + 1 = 8 and then go to block state for waiting for job. Process A is rescheduled by scheduler. Process A already read in = 7, Process A load its job name in slot 7, update i = i + 1 = 9 and then go to blocked state waiting for this job finish How to avoid race condition? Mutual exclusion some way of making sure that if one process is using a shared variable or file, the other processes will be excluded from doing the same thing. The choice of the algorithm for achieving mutual exclusion is a major design issue in any operating system. A solution for the race condition should have following four conditions 1. No two processes may be simultaneously inside their critical regions mutual exclusion 2. No process running outside its critical region may block other processes 3. No process should have to wait forever to enter critical region 4. No assumptions may be made about speeds or the number of CPUs Mutual Exclusion Solutions Busy waiting Sleep and Wakeup Disabling Interrupts Lock Variables Strict Alternation Peterson s Solution Test and Set Lock help from hardware

5 (Disabling Interrupt) Disabling Interrupt Once a process get into the critical section, interrupts set to disable. Other process cannot get CPU time until the process finish its job in the critical section. Since each user process has power to control interrupt, it might cause the end of system. We can build a simple program which can disable entire system since user has control system interrupt. (Disabling Interrupt) Ex) End of the system 1. A process get into the critical section. 2. It make disable all the interrupts which means all other process are sleeping until the job is done in the critical section. 3. The process has blocked outside critical section just before make enable all the interrupts and never return again, cause end of the system (Lock Variable) There are variable called Lock A process can enter in its critical section when Lock = 0. If Lock =0, set Lock =1 and enter in the critical section. Once a process finish its job in critical section, set Lock = 0 and let other process in the critical section Lock = 1 means there is a process running in the critical section, a process do busy waiting until Lock become 0. (Lock Variable) int lock = 0; while lock 0do ; (no-operation) // Busy waiting lock = 1; lock = 0; (Lock Variable) int lock = 0; while lock 0do ; (no-operation) lock = 1 lock = 0; Scenario) 1. Initially lock = A process P 1 tries get into critical section. The process P 1 check lock value = Process P 1 CPU time is over and go to ready state, before updating lock = Process P 2 tries get into critical section. P 2 check lock value lock = 0 5. P 2 set lock = 1 and go to critical section. 6. P 2 CPU time is over and P 1 is rescheduled. 7. P 1 already read lock = 0, P 1 set lock = 1 and go to Critical section. Now P 1 and P 2 are in the critical section at the same time Violating mutual exclusion (Strict Alternation) Variable turn can be i or j. if turn = i, process P i can go to the critical section. Once P i finish its job in critical section, P i set turn = j, let process P j enter critical secion Ex) two process algorithm P 0, P 1 while turn i do ; (no-operation) turn = j;

6 (Strict Alternation) turn is i or j while turn i do ; (no-operation) turn = j; Let assume initially turn = 0 1. P 0 is in CS while P 1 is in remaining section. 2. P 0 done C.S. and set turn = 1, P 1 is still in remaining section. 3. P 0 done remaining section and want to go to C.S. but turn= P 1 has fatal error in remainder section and trapped out by OS. 5. P 0 is waiting forever to enter the C.S. No process running outside its critical region may block other processes (Peterson s Solution) #define false 0 #define ture 1 #define n 2 int turn int interested[n] void enter_region(int process); { int other; other = 1 process interested[process] = true turn = process; while (turn ==process && interest[other]==ture) ; /*no operation */ } void leave_region(int process) { interest[process] = false; } void main() { enter_region (int i) leave_resion (int i) } (Peterson s Solution) 1. Initially, neither process is in the critical section 2. A process P 0 call enter_region (0) a) Set interested[0] = true; b) Set turn = 0 3. go to critical section 4. the process P 1 call enter_region(1) to get into its critical section a) set interested[1] = true; b) set turn = 1; 5. since interested[0] = true, it is keep looping for interest [0] = false 6. finally process P 0 finish its critical section and call leave_region(0) 1. set interested[0] = false 7. now P 1 find out interest[0] = false, P 1 goes to its critical section (Peterson s Solution) Prove for Peterson s Solution) Lets consider the case both P 0 and P 1 call enter_region(0) and enter_region(1) almost simultaneously. Lets interest[0]= true and interest[1] = true at the same time But turn can be only turn = 0 or turn = 1 which ever store is done last is the one that counts!! Case 1) turn = 0 Inside enter_region(0) Since turn =0 and interest [1] = ture, P 0 keep looping in no-operation until P 1 set interested[1] = false. Inside enter_region(1) Since turn = 0 and interest[0] = true, P 1 goes to its critical section. Case 2) turn = 1 Inside enter_region(0) Since turn =1 and interest [1] = ture,. P 0 goes to its critical section Inside enter_region(1) Since turn = 1 and interest[0] = true, P 1 keep looping in no-operation until P 0 set interested[0] = false