Differences
This shows you the differences between two versions of the page.
|
sde:teme:tema_ro_4_python [2020/04/29 21:03] alexandru.radovici |
— (current) | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== 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) | ||
| - | |||
| - | In rezolvarea temei veti porni de la scheletul pe care il gasiti pe [[https://github.com/UPB-FILS/sde/tree/master/devoir/devoir4|github]]. | ||
| - | |||
| - | ===== Informații generale ===== | ||
| - | |||
| - | <note important> | ||
| - | Deadline: **29 Aprilie, 23:55**\\ | ||
| - | Punctaj: **2 puncte** din nota\\ | ||
| - | Incarcarea temei: [[https://vmchecker.cs.pub.ro|vmchecker.cs.pub.ro]]\\ | ||
| - | Incarcarea cu intarziere: **0.1 punct / zi** (maxim 4 zile)\\ | ||
| - | </note> | ||
| - | |||
| - | ===== Cunoștințe evaluate ===== | ||
| - | |||
| - | * Intelegerea functionarii planificatorului | ||
| - | * Implementarea unor algoritmi de planificare | ||
| - | * Intelegerea sistemului de procese | ||
| - | |||
| - | ===== Reguli ===== | ||
| - | |||
| - | - Tema trebuie sa contina un fisier Readme in care sa explicati cum ati facut tema (-0.1p) | ||
| - | - Aveti voie sa folositi doar limbajul Python | ||
| - | - 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ă). | ||
| - | - O tema care este implementata doar pentru a trece testele, va fi depunctata pentru acele teste. | ||
| - | |||
| - | |||
| - | ===== Copierea ===== | ||
| - | |||
| - | 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. | ||
| - | |||
| - | ===== Intrebari ===== | ||
| - | |||
| - | Daca aveti intrebari legate de tema, va rugam sa scrieti un issue pe repository-ul de github [[https://github.com/upb-fils/sde.git|repository]] cu titlul de forma //[scheduler] <titlul intrebarii voastre>//. Aveti nevoie de un cont de github pentru | ||
| - | a scrie intrebari. | ||
| - | |||
| - | <note warning> | ||
| - | **NU PUBLICATI COD SURSA**. Acesta va fi considerata copiere si se va penaliza cu 0p pe tema pentru voi. | ||
| - | </note> | ||
| - | |||
| - | Daca doriti sa primiti un email cand se pun intrebari noi sau cand apar raspunsuri, accesati github [[https://github.com/upb-fils/sde|repository]] si faceti click pe //Watch//. | ||
| - | |||
| - | ===== Planificator ===== | ||
| - | Rularea se va face cu urmatorii parametrii: | ||
| - | |||
| - | <code bash> | ||
| - | python3 main.py algorithm quantum first_process | ||
| - | </code> | ||
| - | |||
| - | * //algoritm//: rr, rrp sau cfs | ||
| - | * //quantum//: quanta de timp | ||
| - | * //first_process//: fisierul executabil al primului process | ||
| - | |||
| - | ==== Procese ==== | ||
| - | 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 executa in ordine. Instructiunile sunt de doua tipuri: | ||
| - | * Procesare (p - process) | ||
| - | * Apel de sistem (f - fork, s - sleep sau exit) | ||
| - | |||
| - | ==== Instructiuni ale unui process ==== | ||
| - | |||
| - | === Procesare === | ||
| - | Instructiunea de procesare este reprezentata de un p urmat de numarul de intervale de timp in care procesul va procesa. | ||
| - | Spre exemplu, | ||
| - | <code> | ||
| - | p 5 | ||
| - | </code> | ||
| - | inseamna ca acest proces va avea nevoie de 5 intervale de timp de procesare. | ||
| - | |||
| - | === Apeluri de sistem === | ||
| - | Fiecare process are la dispozitie trei apeluri de sistem: | ||
| - | |||
| - | * Sleep | ||
| - | * Fork | ||
| - | * Exit | ||
| - | |||
| - | == Sleep == | ||
| - | 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. | ||
| - | |||
| - | <code> | ||
| - | s 3 | ||
| - | </code> | ||
| - | |||
| - | == Fork == | ||
| - | 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. | ||
| - | |||
| - | <code> | ||
| - | f fisier.pse | ||
| - | </code> | ||
| - | |||
| - | <note info> | ||
| - | Apelul de sistem **fork** functioneaza diferit in acesta simulare fata de un sistem de operare propriu-zis. In acesta simulare, | ||
| - | apelul de sistem va crea un nou process si va incarca un nou fisier executabil. | ||
| - | </note> | ||
| - | |||
| - | == Exit == | ||
| - | 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 ==== | ||
| - | Simulatorul de procese (process.py) expune clasa ''Process'' care are urmatoarele metode: | ||
| - | |||
| - | <code python> | ||
| - | #Constructorul, creeaza un nou proces | ||
| - | __init__ (pid, filename) | ||
| - | |||
| - | # Ruleaza procesul pe care este apelata metoda si il preemteaza dupa //quantum// intervale de procesare sau pentru un apel de sistem. | ||
| - | run (quantum) | ||
| - | |||
| - | # Incheie executia procesului pe care este apelata metoda. Este datoria voastra sa anulati toate referintele la acel proces (in fisierul main.py) | ||
| - | end () | ||
| - | </code> | ||
| - | |||
| - | === __init__ === | ||
| - | Constructorul creeaza un process nou. | ||
| - | |||
| - | Planificatorul apeleaza functia acesta in urma unui apel de sistem PROCESS_SYSCALL_FORK. | ||
| - | |||
| - | Daca procesul nou nu poate fi creat, planificatorul va afisa o eroare. | ||
| - | |||
| - | === run === | ||
| - | Aceasta functie simuleaza executia unui process. Ea primeste urmatorii parametrii: | ||
| - | * //quantum//: quanta de timp pe care procesul o are la dispozitie sa execute | ||
| - | |||
| - | La iesire, functia intoarce una din urmatoarele valori: | ||
| - | * //PROCESS_PREEMPTED//: procesul s-a execuatat cu success si a fost preemptat datorita expirarii quantei | ||
| - | * //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. | ||
| - | |||
| - | |||
| - | === end === | ||
| - | Acesta functie opreste un process. | ||
| - | |||
| - | Planificatorul apeleaza functia acesta in urma unui apel de sistem PROCESS_SYSCALL_EXIT. | ||
| - | |||
| - | <note> | ||
| - | Dupa fiecare rularea a unui proces, se va scadea numarul de unitati de procesare executate de process din ''process.sleep'' al fiecarui process din coada de sleep. (valoarea este de fapt cuanta_de_timp - process.quantum). | ||
| - | </note> | ||
| - | |||
| - | === Clasa Process === | ||
| - | Clasa Process contine definitiile unor constante declarate sub forma unor variabile statice si urmatoarele proprietati ale instantei: | ||
| - | * file - fisierul executabilului | ||
| - | * pid - process id | ||
| - | * quantum - unitatile ramase din cuanta procesului | ||
| - | * units - unitarile pe care procesul mai trebuie sa le execute inainte de a citi o noua instructiune | ||
| - | * syscall - numarul apelului de sistem, daca e cazul | ||
| - | * sleep - numarul de unitati in care procesul va "dormi" | ||
| - | * extra - detalii pentru apelul de sistem (in cazul fork, aici se va retine fisierul executabil pentru noul proces) | ||
| - | |||
| - | Se recomanda sa adaugati proprietati extra, ca va pot ajuta in rezolvarea temei. | ||
| - | |||
| - | Acesta structura simuleaza structura PCB folosita de un sistem de operare real. | ||
| - | |||
| - | La fiecare oprire a unui proces, proprietatile vor fi setate astfel: | ||
| - | * //process.quantum// partea din quanta de timp ramasa nefolosita (de exemplu procesul a executat un apel de sistem inainte de expirarea quantei) | ||
| - | * //process.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) | ||
| - | * //process.sleep// (numai pentru //PROCESS_SYSCALL// si process.syscall //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) | ||
| - | * //process.extra// (numai pentru //PROCESS_SYSCALL// si process.syscall //PROCESS_SYSCALL_FORK//) numele fisierului din care va fi incarcat executabilul pentru noul process | ||
| - | * //process.syscall// (numai pentru //PROCESS_SYSCALL//) va fi setat la una din valorile: //PROCESS_SYSCALL_SLEEP//, //PROCESS_SYSCALL_FORK// sau //PROCESS_SYSCALL_EXIT// | ||
| - | |||
| - | <note> | ||
| - | Avem spre exemplul urmatorul process: | ||
| - | <code> | ||
| - | p 5 | ||
| - | s 3 | ||
| - | </code> | ||
| - | |||
| - | Procesul va fi rulat cu o quanta de timp de 3 unitati. | ||
| - | |||
| - | Dupa prima rulare a lui status = process.run (3): | ||
| - | * ''status'' va avea valoarea //Process.PROCESS_PREEMPTED// | ||
| - | * ''process.quantum'' va avea valoarea 0, deoarece procesului nu i-a mai ramas nici o unitate din quanta de timp | ||
| - | * ''process.units'' va avea valoarea 2, deoarece procesul mai are de rulat inca 2 unitati de timp pentru as-i termina procesarea (el avea initial p 5) | ||
| - | |||
| - | Dupa a doua rulare a lui status = process.run (3): | ||
| - | * ''status'' va avea valoarea //Process.PROCESS_SYSCALL// | ||
| - | * ''process.syscall'' va avea valoarea //Process.PROCESS_SYSCALL_SLEEP// | ||
| - | * ''process.quantum'' va avea valoarea 1, deoarece procesul a executat 2 unitati (ramase de la executia precedenta) dupa care a executat un apel de sistem | ||
| - | * ''prodess.units'' va avea valoarea 0, deoarece procesul nu mai are de executat nici o unitate de timp | ||
| - | |||
| - | |||
| - | Procesul va putea fi planificat din nou numai dupa ce alte procese au executat cel putin 3 unitati de timp (din cauza instructiunii s 3). | ||
| - | |||
| - | Puteti adauga atribute noi in clasa daca aveti nevoie, precum timpul virtual de executie pentru algoritmul CFS, prioritati pentru RRP, etc. | ||
| - | </note> | ||
| - | |||
| - | === Procesul scheduler === | ||
| - | Procesul gol, numit //sheduler//, 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: | ||
| - | <code> | ||
| - | p 1 | ||
| - | s 1 | ||
| - | </code> | ||
| - | |||
| - | <note> | ||
| - | Procesul gol va avea mereu pid-ul 0. | ||
| - | </note> | ||
| - | |||
| - | <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-urilor ==== | ||
| - | Alocarea PID-ului se va face dupa urmatorul algoritm: | ||
| - | - procesul planificatorului (cel care va fi planificat daca nu exista alta optiune) are PID-ul 0 | ||
| - | - se va folosi mereu primul PID nefolosit | ||
| - | - la depasirea MAX_PID (declarat in main.py), se va incepe din nou de la 0 si sa va cauta mereu primul PID liber | ||
| - | |||
| - | De exemplu, daca MAX_PID este 5: | ||
| - | - primul process are PID-ul 1 | ||
| - | - al doilea PID-ul 2 | ||
| - | - primul process se opreste (PID-ul 1 devine liber) | ||
| - | - al treilea process va avea PID-ul 3 | ||
| - | - al patrulea process va avea PID-ul 4 | ||
| - | - al cincelea process va avea PID-ul 5 | ||
| - | - procesul al patrulea se opreste | ||
| - | - procesul 5 se opreste | ||
| - | - al saselea process va avea PID-ul 1 (e primul liber) | ||
| - | - al saptelea process va avea PID-ul 4 (e primul mai in ordine liber) | ||
| - | - urmatorul process va avea PID-ul 5 | ||
| - | |||
| - | ==== Algoritmii de planificare ==== | ||
| - | |||
| - | === Round Robin === | ||
| - | Pentru acest algoritm, toate procesele au aceeasi prioritate si sunt planificate unul dupa altul. 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 asteptare (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. | ||
| - | |||
| - | === Round Robin cu Prioritati === | ||
| - | 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. | ||
| - | |||
| - | <note>Depasirea quantei de timp presupune ca dupa rularea procesului, ''process.units'' este diferit de 0.</note> | ||
| - | |||
| - | 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. | ||
| - | |||
| - | === Completly Fair Scheduler === | ||
| - | Acest algoritm este folosit de Linux. Mai multe detalii puteti gasi la adresa [[https://opensource.com/article/19/2/fair-scheduling-linux|CFS: Completely fair process scheduling in Linux]]. Varianta implementata aici va tine seama de: | ||
| - | * virtualtime | ||
| - | * cuanta de timp variabila in functie de numarul de procese, cuanta de timp efectiva este cuanta de timp initiala impartita la numarul de procese, cuanta de timp nu poate fi mai mica de 1. | ||
| - | |||
| - | <note> | ||
| - | Dupa fiecare rularea a unui proces, se va adauga numarul de unitati de procesare executate de process la ''virtualruntime'' (valoarea este de fapt cuanta_de_timp - process.units). | ||
| - | </note> | ||
| - | |||
| - | <note warning> | ||
| - | In rezolvarea temei veti pleca de la scheletul implementat in fisierele ''process.py'' si ''main.py'', unde in anumite locuri este apelata functia ''print''. In verificarea temei se va compara textul afisat de tema voastra cu fisiere de referinta. Din acest motiv sa recomandam sa nu modificati/stergeti apelurile functiei ''print''. | ||
| - | </note> | ||
| - | |||
| - | ===== Trimiterea temei ===== | ||
| - | Tema se va incarca pe [[https://vmchecker.cs.pub.ro|vmchecker]]. Logati-va pe site cu utilizatorul de pe moodle, selectati cursul //Systemes d'Explotation (FILS)// si incarcati [[#arhiva-temei|arhiva temei]]. | ||
| - | |||
| - | ==== Readme ==== | ||
| - | Fisierul readme are urmatorul format: | ||
| - | |||
| - | <code> | ||
| - | Numele vostru intreg | ||
| - | Grupa | ||
| - | |||
| - | Descrierea rezolvarii temei, de ce ati ales anumite solutii, etc. | ||
| - | </code> | ||
| - | |||
| - | |||
| - | ==== Arhiva temei ==== | ||
| - | Pentru a incarca tema, urmariti pasii: | ||
| - | |||
| - | - Creati o arhiva zip (nu rar, ace, 7zip sau alt format) care sa contina: | ||
| - | * toate fisierele python (*.py) | ||
| - | * fisierul Readme | ||
| - | - logati-va pe [[https://vmchecker.cs.pub.ro|vmchecker]] | ||
| - | - selectati cursul //Systemes d'Explotation(FILS)// | ||
| - | - selectati //4. Scheduler// | ||
| - | - incarcati arhiva | ||
| - | |||
| - | |||
| - | <note> | ||
| - | Arhiva trebuie sa contina toate fisierele (principale) in radacina, nu in subdirectoare. NU arhivati directorul temei, arhivati DIRECT fisierele. | ||
| - | </note> | ||
| - | |||
| - | Dupa ce incarcati arhiva, vmchecker va rula: | ||
| - | |||
| - | <code bash> | ||
| - | unzip archive.zip homework | ||
| - | cd homework | ||
| - | make -f Makefile.check | ||
| - | </code> | ||
| - | |||
| - | |||
| - | |||
| - | |||
