Tema 4 - Planificator

Scopul acestei teme este realizarea unui planificator de procese. Acesta trebui sa foloseasca trei algoritmi de planificare:

• Round Robin
• Round Robin cu Prioritati
• Completly Fair Scheduler (CFS)

• Intelegerea functionarii planificatorului
• Implementarea unor algoritmi de planificare
• Intelegerea sistemului de procese

1. Codul sursa trebuie sa fie indentat (-0.1p)
2. Tema trebuie sa contina un fisier Readme in care sa explicati cum ati facut tema (-0.1p)
3. Tema nu are voi sa aiba scurgeri (leak-uri) de memorie (-0.5p)
4. Aveti voie sa folositi doar limbajul C
5. O temă care trece toate testele automate va obține 10 puncte din 10 (daca nu trișează folosind API interzis, caz în care nu va fi punctată).

Tema se rezolva individual. Orice tentativa de copiere va rezulta in 0p pentru tema respectiva. Vom utiliza si sisteme automate de detectare a copierii. Daca avem dubii, va vom adresa intrebari suplimentare legate de tema.

Daca aveti intrebari legate de tema, va rugam sa scrieti un issue pe repository-ul de github repository cu titlul de forma [scheduler] <titlul intrebarii voastre>. Aveti nevoie de un cont de github pentru a scrie intrebari.

Daca doriti sa primiti un email cand se pun intrebari noi sau cand apar raspunsuri, accesati github repository si faceti click pe Watch.

Rularea se va face cu urmatorii parametrii:

sde_scheduler algorithm quantum first_process 

• algoritm: rr, rrp sau cfs
• quantum: quanta de timp
• first_process: fisierul executabil al primului process

Planificatorul este parte a sistemului de operare. Deoarece scrierea de cod in sistemul de operare este dificila, s-a implementat un simulator de procese in spatiul utilizator.

Fiecare process are la baza un fisier cu extensia pse (Process Executable). Acesta este o insiruire de instructiuni pe care fiecare process le va execta in ordine. Instructiunile sunt de doua tipuri:

• Procesare
• Apel de sistem

Instructiunea procesare este reprezentata de un p urmat de numarul de intervale de timp in care procesul va procesa. Spre exemplu,

p 5

inseamna ca acest proces va avea nevoie de 5 intervale de timp de procesare.

Fiecare process are la dispozitie trei apeluri de sistem:

• Sleep
• Fork
• Exit

Procesul va informa planificatorul ca doreste sa doarma pentru un numar de intervale de timp. Pana acest interval nu este depasit, procesul nu poate fi planificat din nou.

s 3

Procesul informeaza sistemul de operare ca doreste sa creeze un alt process folosind un fisier drept fisier executabil. Planificatorul va crea un nou process si il va lua in considerare pentru planificare.

In exemplul de mai jos, procesul doreste sa execute un nou proces avand fisierul fisier.pse drept fisier executabil.

f fisier.pse

Procesul informeaza sistemul de operare ca a terminat de executat. Planificatorul trebuie sa dealoce resursele procesului si sa nu mai ia in considerare procesul pentru planificari ulterioare.

Apelul de sistem este executat cand procesul ajunge la sfarsitul fisierului executabil.

Simulatorul de procese are urmatoarele functii:

// Starts a new process and allocates a PCB using the process filename specified
// if filename is NULL, it allocates an EMPTY process
struct sde_pcb * sde_process_start (int pid, const char *filename);
 
// Runs the process with the specified and pcb an preempts it after //quantum// intervals of processing or for a system call.
int sde_process_run (int quantum, int pid, struct sde_pcb *pcb);
 
// Ends the process with the speficied pid and the deallocates the pcb.
void sde_process_end (int pid, struct sde_pcb *pcb);

Acesta functie creeaza un process nou si initializeaza PCB-ul proesului. Functia intoarce SDE_PROCESS_OK daca procesul nou este creat cu succes sau o valoare negativa in caz contrar.

Planificatorul apeleaza functia acesta in urma unui apel de sistem SDE_PROCESS_SYSCALL_FORK.

Daca procesul nou nu poate fi creat, planificatorul va afisa o eroare.

Aceasta functie simuleaza executia unui process. Ea primeste urmatorii parametrii:

• quantum: quanta de timp pe care procesul o are la dispozitie sa execute
• pid: pid-ul procesului
• pcb: PCB-ul procesului

La iesire, functia intoarce una din urmatoarele valori:

• SDE_PROCESS_PREEMPTED: procesul s-a execuatat cu success si a fost preemptat datorita expirarii quantei
• SDE_PROCESS_SYSCALL: procesul s-a executat cu success si fost oprit datorita unui apel de sistem
• o valoare negativa: procesul s-a executat cu o eroare

In caz de eroare, planificatorul va afisa eroare si va inchide procesul.

Acesta functie opreste un process si dealloca PCB-ul procesului.

Planificatorul apeleaza functia acesta in urma unui apel de sistem SDE_PROCESS_SYSCALL_EXIT.

Structura in care este retinuta PCB (Process Control Block) este urmatoarea:

struct sde_pcb 
{
	// process executable file
	FILE *f;
 
	int status;	// the status of the process (SDE_STATUS_READY, SDE_STATUS_RUNNING, SDE_STATUS_WAITING)
 
	// the following fields are filled with new vales after each call to sde_process_run
	int quantum;	// the amount of units left from the process quantum
	int units;	// the amount of units the process still needs to execute before reading a new instruction
	int syscall;	// the number of the syscall the process requested (if it requested)
	int sleep;	// the amount of units the process has requested to sleep
	char *extra;	// extra information for the system calls (fork: the filename for the new processe's executable file), must be deallocated after use
 
	// add your extra items here, for example pointers to the next and previous structures (if using lists)
};

Acesta structura este folosita pentru comunicarea cu simulatorul de procese. Pentru fiecare process, simulatorul aloca o structura PCB. De fiecare data cand rulati un process, trebuie sa ii trimiteti simulatorului structura PCB a procesului ce doriti sa fie rulat.

Acesta structura simuleaza structura PCB folosita de un sistem de operare real.

La fiecare oripre a unui proces, campurile din pcb vor fi stetate astfel:

• pcb→quantum partea din quanta de timp ramasa nefolosita (de exemnplu procesul a executat un apel de sistem inainte de expirarea quantei)
• pcb→units numarul de intervale pe care procesul le mai are de executat din instructiune (procesul a fost preemptat datorita expirarii quantei de timp si nu a executat toata instructiunea)
• pcb→sleep (numai pentru SDE_PROCESS_SYSCALL si pcb→suscall SDE_PROCESS_SYSCALL_SLEEP) numarul de intervale de timp in care procesul va dormi (procesul nu poate fi planificat mai repede de acest numar de intervale)
• pcb→extra (numai pentru SDE_PROCESS_SYSCALL si pcb→suscall SDE_PROCESS_SYSCALL_FORK) numele fisierului din care va fi incarcat executabilul pentru noul process
• pcb→syscall (numai pentru SDE_PROCESS_SYSCALL) va fi setat la una din valorile: SDE_PROCESS_SYSCALL_SLEEP, SDE_PROCESS_SYSCALL_FORK sau SDE_PROCESS_SYSCALL_EXIT

Procesul gol, numit empty process, are ca scop executarea instructiunii hlt (halt) in cazul in care nu exista niciun alt proces de planificat. Acest tip de proces exista si in realitate si opreste procesorul pentru un timp scurt. In acesta simulare, procesul va executa instructiunile:

p 1
s 1

<node info> Pentru procesul gol, apelul de sistem sleep nu este luat in considerare, procesul va fi planificat ori de cate ori nu exista alt process ce poate fi planificat. </note>

Alocarea PID-ului se va face dupa urmatorul algoritm:

1. procesul planificatorului (cel care va fi planificat daca nu exista alta optiune) are PID-ul 0
2. se va folosi mereu primul PID nefolosit
3. la depasirea MAX_PID (declarat in sde_schedule.h), se va incepe din nou de la 0 si sa va cauta merei primul PID liber

De exemplu, daca MAX_PID este 5:

1. primul process are PID-ul 1
2. al doilea PID-ul 2
3. primul process se opreste (PID-ul 1 devine liber)
4. al treilea process va avea PID-ul 3
5. al patrulea process va avea PID-ul 4
6. al cincelea process va avea PID-ul 5
7. procesul al patrulea se opreste
8. procesul 5 se opreste
9. al saselea process va avea PID-ul 1 (e primul liber)
10. al saptelea process va avea PID-ul 4 (e primul mai in ordine liber)
11. urmatorul process va avea PID-ul 5

Pentru acest algoritm, toate procesele au aceeasi prioritate si sunt planificate una dupa alta. Dupa ce un process a fost planificat, acesta va fi plasat in capatul cozii.

Procesele noi vor fi plasate in capatul cozii.

Se va pastra o coada cu procesele care sunt in astepta (sleep). Acestea vor fi puse in coada in ordinea in care au dat sleep. Inainte de fiecare planificare, se por extrage din coada de asteptare procesele ce pot fi rulate si vor fi adaugate in capatul cozii.

Procesul care tocmai a rulat va fi adaugat ultimul in coada.

Acest algoritm este identic cu cel precedent, cu urmatoarea modificare: toate procesele pornesc cu prioritatea 5. De fiecare data cand un process isi depaseste quanta de timp, acest este penalizat cu 1. De fiecare data cand procesul iese inainte de a-si depasi quanta acesta este rasplatit cu 1.

Prioritatea nu poate fi mai mica decat 0 sau mai mare decat 5.

La planificare, se iau in considerare doar procesele cu prioritatea cea mai mare. Daca nici unul din ele nu poate fi planificat (sunt in sleep), se iau in considerarea procesele cu prioritatea mai mica. Daca nici aici nu este nici unul care poate fi planificat, se iau in considerarea urmatoarele si tot asa mai departe.

Acest algoritm este folisit de Linux. Mai multe detalii puteti gasi la adresa CFS: Completely fair process scheduling in Linux. Varianta implementata aici va tine seama de:

• virtualtime
• qunata de timp variabila in functie de numarul de procese, quanta de timp efectiva este qunata de timp initiala impartita la numarul de procese, quanta de timp nu poatre fi mai mica de 1.

Tema se va incarca pe vmchecker. Logati-va pe site cu utilizatorul de pe moodle, selectati cursul Systemes d'Explotation (FILS) si incarcati arhiva temei.

Fisierul readme are urmatorul format:

Numele vostru intreg
Grupa

Descrierea rezolvarii temei, de ce ati ales anumite solutii, etc.

Pentru a incarca tema, urmariti pasii:

1. Creati o arhiva zip (nu rar, ace, 7zip sau alt format) care sa contina:
   • toate fisierele header (*.h)
   • toate fisierele sursa (*.c)
   • fisierul Makefile (este deja facut in sablonul temei)
   • fisierul Readme
2. logati-va pe vmchecker
3. selectati cursul Systemes d'Explotation(FILS)
4. selectati 4. Scheduler
5. incarcati arhiva

Dupa ce incarcati arhiva, vmchecker va rula:

unzip archive.zip homework
cd homework
make build
make run