Sistemi Operativi 1. Mattia Monga. a.a. 2008/09. Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia

Transcript

1 1 Mattia Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia mattia.monga@unimi.it a.a. 2008/09 1 c 2009 M.. Creative Commons Attribuzione-Condividi allo stesso modo 2.5 Italia License. Immagini tratte da [?] e da Wikipedia. 1

2 374 Lezione XXI:

3 375 Round robin su 16 code di priorità Quando un processo viene bloccato senza aver esaurito il suo quanto di tempo, una volta risvegliato, viene rimesso in testa alla coda Nelle code sono presenti solo processi ready Algoritmo di : Individua la coda di priorità piú alta non vuota e manda in esecuzione il processo in testa alla coda Il processo IDLE garantisce la terminazione di questo algoritmo

4 376 Per la gestione dei processi sono utilizzate le seguenti strutture dati: in kernel/proc.h struct proc proc[nr TASKS + NR PROCS]; tabella dei processi composta dai singoli PCB di ciascun processo (questa struttura è in parte replicata nei server PM e FS) struct proc rdy head[nr SCHED QUEUES];/ ptrs to ready list headers / struct proc rdy tail[nr SCHED QUEUES];/ ptrs to ready list tails / in kernel/glo.h struct proc prev ptr; / previously running process / struct proc proc ptr; / pointer to currently running process / struct proc next ptr; / next process to run after restart() /

5 377 Ready queue

6 Process table 1 / kernel/proc.h / 2 struct proc { 3 /... / 4 proc nr t p nr; / number of this process (for fast access) / 5 struct priv p priv; / system privileges structure / 6 char p rts flags; / SENDING, RECEIVING, etc. / 7 8 char p priority; / current priority / 9 char p max priority; / maximum priority / 10 char p ticks left; / number of ticks left / 11 char p quantum size; / quantum size in ticks / 12 /... / 13 struct proc p nextready;/ pointer to next ready process / 14 struct proc p caller q; / head of list of procs wishing to send / 15 struct proc p q link; / link to next proc wishing to send / 16 message p messbuf; / pointer to passed message buffer / 17 proc nr t p getfrom; / from whom does process want to receive? / 18 proc nr t p sendto; / to whom does process want to send? / 19 /... / 20 }; 378

7 Privilege table 1 / kernel/priv.h / 2 struct priv { 3 proc nr t s proc nr; / number of associated process / 4 /... / 5 short s trap mask; / allowed system call traps / 6 sys map t s ipc from; / allowed callers to receive from / 7 sys map t s ipc to; / allowed destination processes / 8 long s call mask; / allowed kernel calls / 9 sys map t s notify pending; / bit map with pending notifications / 10 irq id t s int pending; / pending hardware interrupts / 11 sigset t s sig pending; / pending signals / 12 /... / 13 }; struct priv priv[nr SYS PROCS]; / system properties table / C è n è una per ogni processo di sistema, mentre tutti i processi utente condividono la stessa 379

8 Process numbers 1 / include/minix/com.h / 2 / Kernel tasks. These all run in the same address space. / 3 #define IDLE 4 / runs when no one else can run / 4 #define CLOCK 3 / alarms and other clock functions / 5 #define SYSTEM 2 / request system functionality / 6 #define KERNEL 1 / pseudo process for IPC and / 7 #define HARDWARE KERNEL / for hardware interrupt handlers / 8 #define NR TASKS #define PM PROC NR 0 / process manager / 11 #define FS PROC NR 1 / file system / 12 #define RS PROC NR 2 / reincarnation server / 13 #define MEM PROC NR 3 / memory driver (RAM disk, null, etc.) / 14 #define LOG PROC NR 4 / log device driver / 15 #define TTY PROC NR 5 / terminal (TTY) driver / 16 #define DRVR PROC NR 6 / device driver for boot medium / 17 #define INIT PROC NR 7 / init goes multiuser / / Number of processes contained in the system image. / 20 #define NR BOOT PROCS (NR TASKS + INIT PROC NR + 1) 380

9 381 Display privilege table (F4) FLAGS P:preemptable, B:billable, S:system TRAPS E:echo, S:send, R:receive, B:both, N:notification

10 382 Tabella dei processi Viene inizializzata in fase di boot dalla procedura main con il PCB dei processi di sistema Il primo processo ad essere eseguito in user mode è il PM Il processo INIT è il primo processo utente ad essere eseguito ed è il genitore di tutti gli altri processi utente del sistema Tutti i processi (di sistema e utente) sono discendenti di RS (reincarnation server) fatta eccezione per System e PM che non hanno genitori

11 383 Sospensione e riabilitazione dei processi Running Blocked Blocked Ready Tutti processi presenti sul sistema sono sospesi sempre e solo a seguito di: Interrupt Eccezioni Syscall Questi eventi si traducono in messaggi La sospensione (dequeue) viene decretata a seguito di una send/receive/sendrec che non trova pronto il destinatario/mittente del messaggio La riabilitazione (enqueue) viene decretata a seguito di una consegna o ricezione di un messaggio atteso

12 384 Assegnazione della CPU Ready Running L esecuzione effettiva di un processo, cioè la sua esecuzione da parte del processore viene quindi governata dalla procedura restart, che costituisce la componente terminale della procedura di risposta a interrupt/eccezione o syscall

13 385 Restart 1 restart: 2 3 ; Restart the current process or the next process if it is set. 4 5 cmp ( next ptr), 0 ; see if another process is scheduled 6 jz 0f 7 mov eax, ( next ptr) 8 mov ( proc ptr), eax ; schedule new process 9 mov ( next ptr), : mov esp, ( proc ptr) ; will assume P STACKBASE == 0 11 lldt P LDT SEL(esp) ; enable process segment descriptors 12 lea eax, P STACKTOP(esp) ; arrange for next interrupt 13 mov ( tss+tss3 S SP0), eax ; to save state in process table 14 restart1: 15 decb ( k reenter) 16 o16 pop gs 17 o16 pop fs 18 o16 pop es 19 o16 pop ds 20 popad 21 add esp, 4 ; skip return adr 22 iretd ; continue process

14 386 Implementazione dello La politica di è gestita da: enqueue dequeue sched pick proc

15 dequeue 1 / kernel/proc.c / 2 void dequeue(rp) 3 register struct proc rp; / this process is no longer runnable / 4 { 5 / A process must be removed from the queues, for example, because 6 it has blocked. If the currently active process is removed, a new process 7 is picked to run by calling pick proc(). 8 / 9 register int q = rp >p priority; / queue to use / 10 register struct proc xpp; / iterate over queue / 11 register struct proc prev xp; / Now make sure that the process is not in its ready queue. Remove the 14 process if it is found. A process can be made unready even if it is not 15 running by being sent a signal that kills it. 16 / 17 prev xp = NIL PROC; 18 for (xpp = &rdy head[q]; xpp!= NIL PROC; xpp = &( xpp) >p nextready) { if ( xpp == rp) { / found process to remove / 21 xpp = ( xpp) >p nextready; / replace with next chain / 22 if (rp == rdy tail[q]) / queue tail removed / 23 rdy tail[q] = prev xp; / set new tail / 24 if (rp == proc ptr rp == next ptr) / active process removed / 25 pick proc(); / pick new process to run / 26 break; 27 } 28 prev xp = xpp; / save previous in chain / 29 } 30 } 387

16 pick proc 1 / kernel/proc.c / 2 void pick proc(){ 3 / Decide who to run now. A new process is selected by setting next ptr. 4 When a billable process is selected, record it in bill ptr, so that the 5 clock task can tell who to bill for system time. 6 / 7 register struct proc rp; / process to run / 8 int q; / iterate over queues / 9 10 / Check each of the queues for ready processes. The number of 11 queues is defined in proc.h, and priorities are set in the image table. 12 The lowest queue contains IDLE, which is always ready. 13 / 14 for (q=0; q < NR SCHED QUEUES; q++) { 15 if ( (rp = rdy head[q])!= NIL PROC) { 16 next ptr = rp; / run process rp next / 17 if (priv(rp) >s flags & BILLABLE) 18 bill ptr = rp; / bill for system time / 19 return; 20 }}} 388

17 enqueue 1 / kernel/proc.c / 2 void enqueue(rp) 3 register struct proc rp; / this process is now runnable / 4 { 5 / Add rp to one of the queues of runnable processes. This function is 6 responsible for inserting a process into one of the queues. 7 The mechanism is implemented here. The actual policy is 8 defined in sched() and pick proc(). 9 / 10 int q; / queue to use / 11 int front; / add to front or back / / Determine where to insert to process. / 14 sched(rp, &q, &front); / Now add the process to the queue. / 17 if (rdy head[q] == NIL PROC) { / add to empty queue / 18 rdy head[q] = rdy tail[q] = rp; / create a new queue / 19 rp >p nextready = NIL PROC; / mark new end / 20 } 21 else if (front) { / add to head of queue / 22 rp >p nextready = rdy head[q]; / chain head of queue / 23 rdy head[q] = rp; / set new queue head / 24 } 25 else { / add to tail of queue / 26 rdy tail[q] >p nextready = rp; / chain tail of queue / 27 rdy tail[q] = rp; / set new queue tail / 28 rp >p nextready = NIL PROC; / mark new end / 29 } / Now select the next process to run. / pick proc(); }} 389

18 390 sched 1 / kernel/proc.c / 2 void sched(rp, queue, front) 3 register struct proc rp; / process to be scheduled / 4 int queue; / return: queue to use / 5 int front; / return: front or back / 6 { 7 / This function determines the policy. It is called whenever a 8 process must be added to one of the queues to decide where to 9 insert it. As a side effect the process priority may be updated. 10 / 11 static struct proc prev ptr = NIL PROC; / previous without time / 12 int time left = (rp >p ticks left > 0); / quantum fully consumed / 13 int penalty = 0; / change in priority / / Check whether the process has time left. Otherwise give a new quantum 16 and possibly raise the priority. Processes using multiple quantums 17 in a row get a lower priority to catch infinite loops in high priority 18 processes (system servers and drivers). 19 / 20 if (! time left) { / quantum consumed? / 21 rp >p ticks left = rp >p quantum size; / give new quantum / 22 if (prev ptr == rp) penalty ++; / catch infinite loops / 23 else penalty ; / give slow way back / 24 prev ptr = rp; / store ptr for next / 25 }

19 391 sched (cont.) 1 / Determine the new priority of this process. The bounds are determined 2 by IDLE s queue and the maximum priority of this process. Kernel tasks 3 and the idle process are never changed in priority. 4 / 5 if (penalty!= 0 &&! iskernelp(rp)) { 6 rp >p priority += penalty; / update with penalty / 7 if (rp >p priority < rp >p max priority) / check upper bound / 8 rp >p priority=rp >p max priority; 9 else if (rp >p priority > IDLE Q 1) / check lower bound / 10 rp >p priority = IDLE Q 1; 11 } / If there is time left, the process is added to the front of its queue, 14 so that it can immediately run. The queue to use simply is always the 15 process current priority. 16 / 17 queue = rp >p priority; 18 front = time left; 19 }

20 392 IDLE 1 ; kernel/klib386.s 2 idle task: 3 ; This task is called when the system has nothing else to do. The HLT 4 ; instruction puts the processor in a state where it draws minimum power. 5 push halt 6 call level0 ; level0(halt) 7 pop eax 8 jmp idle task 9 halt: 10 sti 11 hlt 12 cli 13 ret ; Call a function at permission level 0. This allows kernel tasks to do 16 ; things that are only possible at the most privileged CPU level. 17 ; 18 level0: 19 mov eax, 4(esp) 20 mov ( level0 func), eax 21 int LEVEL0 VECTOR 22 ret idle task opera con TASK PRIVILEGE, mentre l esecuzione di hlt necessita di INTR PRIVILEGE