Admin. Threads, CPU Scheduling. Yesterday s Lecture: Threads. Today s Lecture. ITS 225: Operating Systems. Lecture 4

Transcription

1 ITS 225: Operating Systems Admin Lecture 4 Threads, CPU Scheduling Jan 23, 2004 Dr. Matthew Dailey Information Technology Program Sirindhorn International Institute of Technology Thammasat University Some material Silberschatz, Galvin and Gagne, 2002 Vote on extending deadline for PA1 to xx xx xx:xx Pros: more time to learn about Linux/Unix, vi, etc. Cons: less time to work on PA2/3, which will be more challenging programs 3-minute papers 10 points total, 12 lectures (including yesterday) I will drop your two lowest-score papers, so you can miss 2 classes without penalty But really 3 minutes from now on! THINK about what you will write throughout the class! Yesterday s Lecture: Threads Today s Lecture Last time we learned what threads are: Separate threads of execution Shared address space And why they are good: Lower memory utilization Lower thread creation overhead Faster context switching Problems/questions from last time Finish up threads Implementations: In user space or kernel space? 1

2 Thread Implementations: User/Kernel User-level thread libraries: No help from the kernel Creation and context switching are fast But, if one thread blocks, entire process blocks No multiprocessing support Kernel threads: Supported directly by OS: operations are system calls Creation and context switching are slow But if one thread blocks, other kernel threads continue Different threads can run in parallel on multiprocessor No kernel support for threads Example: Pthreads Many-to-One One-To-One Many to Many (or M-to-N) All user threads are kernel threads. Most common model for kernel threads. Examples: Linux, Windows 95/98/2000/NT/XP Maximum flexibility Harder to use and implement Requires a userlevel AND a kernel-level scheduler Windows NT/2000 ThreadFiber 2

3 Pthreads Pthreads example (text p. 140) User-level thread library Available on most Unix systems Easy to learn and use But not fully concurrent (e.g. printf() blocks all threads) For kernel threads, try Linux Threads or Win32 threads Linux tools have built-in Pthread support Debugger (gdb) lets you examine individual thread stacks C libraries are reentrant or thread-safe Two threads running same library function concurrently do not interfere with each other. sum = 0; if ( upper > 0 ) { for ( i = 1; i <= upper; i++ ) { sum += i; pthread_exit( 0 ); int upper = atoi( (int)param ); int i; void *runner( void *param ) { /* The thread will begin control in this function. * Calculates sum from i=1 to i=n of i. */ exit( 0 ); /* Wait for thread to exit */ pthread_join( tid, NULL ); printf( "sum = %d\n", sum ); /* Create one thread */ pthread_create( &tid, &attr, runner, argv[1] ); /* Get default attributes */ pthread_attr_init( &attr ); if ( atoi( argv[1] ) < 0 ) { fprintf( stderr, "%s error: %d must be integer >= 0\n", atoi( argv[1] )); exit( -1 ); if ( argc!= 2 ) { fprintf( stderr, "usage: %s <integer value>\n", argv[0] ); exit( -1 ); /* Check arguments */ pthread_t tid; /* the thread identifier */ pthread_attr_t attr; /* set of thread attributes */ int main ( int argc, char *argv[] ) { void *runner( void *param ); /* The function run by the thread */ int sum; /* Data shared by all threads */ #include <pthread.h> #include <stdio.h> What have we learned? CPU Scheduling What threads are and how they differ from processes User vs. kernel threads Thread models (N-to-1, 1-to-1, M-to-N) Pthread library introduction CPU Scheduling: Which process to select from ready queue? Preemption vs. non-preemption Evaluating scheduling algorithms Algorithms (FCFS, SJF, RR, Priority, Multilevel Queue) 3

4 CPU Scheduling: What Policy? CPU Burst --- I/O Burst Cycle Multiprogramming goal: run some process at all times Policy determines how you allocate resources to processes No single policy is best for all situations! Best policy depends on goal of the system Single-user desktop PC Compute server for scientific applications Interactive time-sharing system Empirically, most programs alternate between CPU bursts and I/O bursts. This makes multiprogramming desirable. CPU Burst Times Short-term Scheduler Varies with application and HW. But histogram almost always looks exponential. Most bursts short, a few are long. Selects next job from ready queue. Ready queue not necessarily FIFO! Must run when: A process switches from running to waiting (I/O, wait(), etc.) A process terminates If preemptive, can also run when: A process switches from running to ready (Interrupt) A process switches from waiting to ready (I/O completion) 4

5 Preemption: Pros and Cons Note on Dispatch Latency OS s like Windows 3.1 and early Apple MacOS were non-preemptive. Badly-behaved apps could kill the system. Preemption, then, seems good. BUT: Interrupt during shared user data update Can cause inconsistency or corruption Remedy: synchronization (Chapter 7) Interrupt during system call Could cause kernel data inconsistency or corruption Remedy: disable interrupts during kernel data updates Must keep disable time super short or might miss interrupts Preemption increases complexity for OS designer AND programmers The dispatcher is a piece of kernel code that: Switches context Flips protection bit to user mode Jumps to correct location in user program Dispatch latency is the time it takes from the interrupt to the final jump Evaluation Criteria Algorithm 1: First Come, First Served (FCFS) Generally want to maximize CPU utilization (% of time CPU is in use) Throughput (# of processes completed per unit time) Generally want to minimize Turnaround time (time from submission to completion = admit time + ready time + CPU time + I/O time) Wait time: amount of time spend in ready queue Response time: time from submission to first output (important in interactive systems) Usually optimize average but there are other choices A non-preemptive scheme. Like Bangkok Bank when only one service desk is open. One long-running process can clog the queue for a long time. Process Burst time P1 24 P2 3 0 P3 3 Gantt Chart Avg wait time: ( ) / 3 = 17 ms Opposite order wait time: ( ) = 3 ms. Much improved! 5

6 Algorithm 2: Shortest Job First (SJF) Preemptive SJF Always assign job with shortest next CPU burst to CPU Can be preemptive or non-preemptive Provably optimizes average wait time. Process Arrival Burst P1 0 7 P2 2 4 P3 4 1 P Non-preemptive SJF Avg wait time: ( ) / 4 = 4 ms FCFS wait time: ( ) / 4 = 4.75 ms P Process Arrival Burst P1 0 7 P2 2 4 P3 4 1 P P Average waiting time = ( )/4 = 3 ms SJF is provably optimal: moving a shorter process earlier always decreases short process wait time more than it increases long process wait time. 16 Implementing SJF Burst time prediction with exponential average SJF is great, but how do you implement it? You don t know a priori how long a job s burst time is You have to try to predict the burst time 1. t n = actual lenght of n CPU burst 2. t n a, 0 a 1 4. Define : th = predicted value for the next CPU burst t = a t + ( -a) t. n= 1 n 1 n 6

7 Priority Scheduling Round-Robin SJF is a special case of priority scheduling: Always schedule the ready process with highest priority Preemptive or non-preemptive SJF priority: inverse of CPU burst time Priorities backwards or forwards? Unix: -20 is highest priority, +20 is lowest Internally-derived priorities: computed by OS Externally-derived priorities: forced by users/managers Problem: starvation Low-priority process might have to wait indefinitely Solution: process aging (gradually increase priority of old processes) For time-sharing systems Similar to FCFS but preemptive Ready queue is a circular queue Define a short time quantum, e.g. 20 ms Before starting a process, set timer to generate interrupt after quantum expires If CPU burst time < quantum, process gives up CPU voluntarily else, timer generates interrupt after quantum expires interrupt causes context switch to kernel mode running process is moved to tail of the ready queue switch to next process in queue Round Robin Example (Quantum = 20) Multilevel Queues Process Burst Time P 4 24 P 4 P Long wait times but short response times How to determine time quantum? Too short: too many context switches (too much overhead) Too long: approaches FCFS performance Rule of thumb: large enough to handle 80% of the CPU bursts Use more than one ready queue E.g. foreground queue for interactive programs and background queue system maintenance, batch programs Use different scheduling algorithm for each queue E.g. RR for the foreground queue, FCFS for background queue New problem: how to split time between the queues? Absolute priority: can cause starvation Time division: e.g. 80% foreground, 20% background 7

8 Multilevel Feedback Queues What have we learned? Don t fix a process in a queue: let it move One example: several queues with different priorities Let I/O bound processes float upward (higher priority) Move CPU hogs downward (lower priority) Move processes waiting a too long gradually upward Flexible system but complex implementation What CPU scheduling is Preemptive vs. non-preemptive scheduling How to evaluate different algorithms The most common algorithms: FCFS SJF Priority scheduling Round-robin Multilevel queue scheduling Multilevel feedback queue scheduling (Extra credit 3-minute papers) 8