Lecture Notes Week 4. Once the CPU is up and running, the routine scheduler() is never called again except in the routine sched().

Transcription

1 1 XV6 Scheduler The xv6 scheduler user pure Round Robin It definitely as starvation and is definitely non-optimal The xv6 scheduler is in procc Two routines comprise the scheduler: scheduler() and sched() When a CPU first starts, no true context switch can take place, so it is faked in mainc after userinit() runs Recall that userinit() manually creates the first process (can t use fork() just yet) and places it in the RUNNABLE state // Common CPU s e t u p code static mpmain( ) c p r i n t f ( cpu%d : s t a r t i n g \n, cpu >id ) ; i d t i n i t ( ) ; // load i d t r e g i s t e r xchg(&cpu >s t a r t e d, 1 ) ; // t e l l s t a r t o t h e r s ( ) we re up s c h e d u l e r ( ) ; // s t a r t running p r o c e s s e s Once the CPU is up and running, the routine scheduler() is never called again except in the routine sched() Note This is an area where practice diverges from theory Texts tell us that a context switch occurs when one process leaves the CPU and another enters the CPU This implies, for many students, that the switch is direct the first process actually loads the second process Not so The reality is made explicit in the xv6 scheduler 1 sched() This function causes the currently executing process to removed from the processor and the scheduler context for this processor to be loaded (each processor has its own scheduler context) 2 scheduler() This function loops through the list of processes looking for ones that are in the RUNNABLE state The first one it finds is scheduled Note Note This code is very, very tricky It is important to trace the code down into swtch to see the context switch happen It is equally important to note that the function swtch() is called but not really returned from The assembly code for the context switch routine is in swtchs 1

2 # Context switch # # swtch ( struct context old, struct context new ) ; # # Save c u r r e n t register context in old # and then load register context from new g l o b l swtch swtch : movl 4(%esp ), %eax movl 8(%esp ), %edx # Save old c a l l e e save r e g i s t e r s pushl %ebp pushl %ebx pushl %e s i pushl %e d i # Switch s t a c k s movl %esp, (%eax ) movl %edx, %esp # Load new c a l l e e save r e g i s t e r s popl %e d i popl %e s i popl %ebx popl %ebp r e t So, who calls sched()? 1 exit() Voluntary yield (process is done) 2 yield() See trapc 3 sleep() Voluntary yield 2

3 // Enter s c h e d u l e r Must hold only p t a b l e l o c k // and have changed proc >s t a t e sched ( ) int i n t e n a ; i f (! holding(& p t a b l e l o c k ) ) panic ( sched p t a b l e l o c k ) ; i f ( cpu >n c l i!= 1) panic ( sched l o c k s ) ; i f ( proc >s t a t e == RUNNING) panic ( sched running ) ; i f ( r e a d e f l a g s ()&FL IF ) panic ( sched i n t e r r u p t i b l e ) ; i n t e n a = cpu >i n t e n a ; swtch(&proc >context, cpu >s c h e d u l e r ) ; cpu >i n t e n a = i n t e n a ; // Per CPU p r o c e s s s c h e d u l e r // Each CPU c a l l s s c h e d u l e r ( ) a f t e r s e t t i n g i t s e l f up // Scheduler never r e t u r n s I t loops, doing : // choose a p r o c e s s to run // swtch to s t a r t running t h a t p r o c e s s // e v e n t u a l l y t h a t p r o c e s s t r a n s f e r s c o n t r o l // v i a swtch back to the s c h e d u l e r s c h e d u l e r ( ) struct proc p ; for ( ; ; ) // Enable i n t e r r u p t s on t h i s p r o c e s s o r s t i ( ) ; // Loop over p r o c e s s t a b l e l o o k i n g f o r p r o c e s s to run a c q u i r e (& p t a b l e l o c k ) ; for ( p = p t a b l e proc ; p < &ptable proc [NPROC] ; p++) i f (p >s t a t e!= RUNNABLE) continue ; // Switch to chosen p r o c e s s I t i s the p r o c e s s s j o b // to r e l e a s e p t a b l e l o c k and then r e a c q u i r e i t // b e f o r e jumping back to us 3

4 proc = p ; switchuvm ( p ) ; p >s t a t e = RUNNING; swtch(&cpu >scheduler, proc >context ) ; switchkvm ( ) ; // Process i s done running f o r now // I t should have changed i t s p >s t a t e b e f o r e coming back proc = 0 ; r e l e a s e (& p t a b l e l o c k ) ; The yield() function can be called directly (voluntary) or through trap() (involuntary) xv6 does not invoke yield() on a syscall trap ( s t r u c t trapframe t f ) i f ( t f >trapno == T SYSCALL) switch ( t f >trapno ) case T IRQ0 + IRQ TIMER : i f ( cpu >id == 0) a c q u i r e (& t i c k s l o c k ) ; t i c k s ++; wakeup(& t i c k s ) ; r e l e a s e (& t i c k s l o c k ) ; l a p i c e o i ( ) ; break ; // Force p r o c e s s to g i v e up CPU on c l o c k t i c k // I f i n t e r r u p t s were on while l o c k s held, would need to check nlock i f ( proc && proc >s t a t e == RUNNING && t f >trapno == T IRQ0+IRQ TIMER) y i e l d ( ) ; The relationship between the timer length and the involuntary yield exposes some weaknesses with MLFQ with budgeting in xv6 (P3) 4

5 2 Project 3: MLFQ Scheduler 1 Walk-through of project description 2 Think carefully about the design 3 Implementation should be such that small pieces can be tested before you move on 5