Ce poți găti din calmar: rapid și gustos

Problemă

Analogia se bazează pe o frizerie ipotetică cu un frizer. Coaforul are unul locul de muncași o zonă de recepție cu multe scaune. Când frizerul termină de tuns clientul, îl eliberează pe client și apoi se duce în zona de recepție pentru a vedea dacă sunt clienți care așteaptă. Dacă există, îl invită pe unul dintre ei și își tunde părul. Dacă nu așteaptă clienți, se întoarce pe scaun și doarme în el.

Fiecare client care vine se uită la ce face frizerul. Dacă coaforul doarme, clientul îl trezește și se așează pe un scaun. Dacă coaforul lucrează, atunci clientul vine la receptie. Dacă în zona recepției există un scaun liber, clientul se așează și își așteaptă rândul. Dacă nu există scaun liber, clientul pleacă. Pe baza unei analize naive, descrierea de mai sus ar trebui să se asigure că frizeriei funcționează corect, frizerul tăind părul oricui în timp ce există clienți și apoi dormind până la sosirea următorului client. În practică, pot apărea multe probleme care ilustrează probleme comune planificare.

Toate problemele provin din faptul că toate acțiunile atât ale coaforului, cât și ale clientului (verificarea zonei de recepție, intrarea în coafor, luarea unui loc în zona de recepție etc.) durează un timp necunoscut. De exemplu, un client poate intra și observa că coaforul lucrează, apoi se duce în zona recepției. În timp ce merge, frizerul termină tunsoarea pe care o face și merge să verifice zona de recepție. Din moment ce nu este nimeni acolo (clientul nu a sosit inca), se intoarce la locul lui si doarme. Coaforul asteapta acum clienta, iar clientul il asteapta pe coafor. Într-un alt exemplu, doi clienți pot ajunge în același timp când în zona de recepție există un singur loc liber. Observă că coaforul lucrează, se duc la recepție, iar amândoi încearcă să ia singurul scaun.

Multe disponibile solutii posibile. Elementul principal al fiecăruia este un mutex, care asigură că doar unul dintre participanți poate schimba starea. Frizerul ar trebui să prindă această excepție mutex înainte de a verifica clienții și să o elibereze atunci când începe fie să doarmă, fie să lucreze. Clientul trebuie să apuce mutexul înainte de a intra în magazin și să-l elibereze odată ce a luat loc fie în zona de recepție, fie la coafor. Acest lucru rezolvă ambele probleme menționate în secțiunea anterioară. Semaforele sunt, de asemenea, necesare pentru a indica starea sistemului. De exemplu, numărul de persoane din sala de așteptare ar putea fi menținut.

Opțiunea cu mai mulți frizeri are complexitatea suplimentară de a coordona mai mulți frizeri între clienții în așteptare.

Problema clasica. Cititori și scriitori

Având în vedere o anumită zonă de memorie partajată, această structură de date poate fi accesată de un număr arbitrar de „cititori” și un număr arbitrar de „scriitori”.

Mai mulți cititori pot accesa în același timp scriitorii nu sunt permisi în acest moment. Un singur scriitor poate avea acces, alți scriitori și cititori trebuie să aștepte.

Prima solutie

Cititorul poate intra în secțiunea critică dacă nu există scriitori.

Această decizie este nedreaptă, deoarece favorizează cititorii

Un flux abundent de solicitări din partea cititorilor poate duce la ca un scriitor să nu primească niciodată acces la o secțiune critică – o situație de „foame”.

A doua soluție

Vom acorda preferință scriitorilor, adică cititorul nu este inclus în secțiunea critică dacă există cel puțin un scriitor în așteptare.

Această decizie dă prioritate scriitorilor și este, de asemenea, nedreaptă, deoarece „foametea” este posibilă

(de foame) cititori.

A treia soluție

Nu acorda prioritate nimanui, foloseste doar un mutex.

Bilete pentru pregătirea examenului de Informatică. Trofimov Vladislav, Makhonin Kirill

Sisteme de fișiere

FAT - Tabel de alocare a fișierelor

FAT12 pentru dischete

FAT16 conduce până la 2 GB

UFAT vă permite să utilizați caractere non-latine în nume

Numele FAT32 este stocat în antetul fișierului

MBR – înregistrarea de pornire principală (dimensiunea clusterului, locația de pornire a sistemului de operare)

FAT – tabel de markup.

nume de fișier

proprietățile fișierului

poziţia de pornire pe disc

ÎN ultimul octet la fragmentarea unui fișier este următoarea adresă. fragment de fișier.

Fiecare fragment următor are la început o legătură cu fragmentul anterior.

HPFS – Sistem de fișiere de înaltă performanță

Super block - analog al înregistrării master boot

Bloc de suliță – informații în termeni procentuali despre ocuparea fiecărui bitmap (index de bitmap)

Bitmap – bitmap, analog cu FAT, arată ce date sunt scrise (dimensiune 8MB)

Bilete pentru pregătirea examenului de Informatică. Trofimov Vladislav, Makhonin Kirill

NTFS – Sistem de fișiere cu tehnologii noi

Log MFT – înregistrare de pornire, analog al mbr

MFT – link către adresa jurnalului de evenimente (înregistrări despre fiecare fișier de pe disc (nume, proprietar, creator, atribute, dată) ultima schimbare, prezența legăturilor soft și hard) cu dimensiunea de 1 KB sau orice alte fișiere de până la 1 KB). Ocupă 12%. Dacă nu este suficient, sistemul va muta granița.

Inversarea priorității are loc atunci când două fire cu o prioritate ridicată ( ÎN) și prioritate scăzută ( N) împărtășesc o resursă comună ( R). Să presupunem, de asemenea, că există un al treilea fir în sistem a cărui prioritate este între priorități ÎNŞi N. Să-i spunem medie ( CU). Dacă firul B devine gata când firul este activ NŞi N a blocat resursa R, apoi fluxul ÎN va deplasa fluxul NŞi R va rămâne blocat. Când ÎN vei avea nevoie de o resursă R, atunci ea însăși va intra într-o stare blocată. Dacă numai firul este în starea gata N, atunci nu se va întâmpla nimic rău, N va elibera resursa blocată și va fi anticipată de thread ÎN. Dar dacă în acest moment firul este blocat ÎN, firul este în starea pregătită CU, a cărui prioritate este mai mare decât aceasta N, atunci el este cel care va deveni activ și N va fi forțat să iasă din nou și va câștiga controlul abia după CUîși va termina munca. O astfel de întârziere poate duce la faptul că timpul critic de service al firului ÎN va fi ratat. Dacă ÎN Acesta este un flux greu în timp real, atunci o astfel de situație este inacceptabilă.

Ce mecanisme de protecție folosesc dezvoltatorii RTOS pentru a se proteja împotriva acestei probleme? Cel mai utilizat și dovedit mecanism este moştenire prioritară.

Mecanismul de moștenire a priorităților, din păcate, nu poate rezolva întotdeauna problemele asociate cu blocarea unui fir cu prioritate ridicată pe o resursă blocată. În cazul în care mai multe fire de execuție cu prioritate medie și joasă împart unele resurse cu un fir de execuție cu prioritate mare, este posibil ca firul de execuție cu prioritate înaltă să fie nevoit să aștepte prea mult până când fiecare dintre firele inferioare își eliberează resursa și serviciul critic. perioada se va pierde. Totuși, astfel de situații (partajarea resurselor unui fir cu prioritate înaltă) trebuie monitorizate de dezvoltatorii de sisteme de aplicații. În principiu, moștenirea priorității este cel mai comun mecanism de protecție împotriva problemei inversării priorității.

O altă metodă, puțin mai puțin obișnuită, se numește Protocolul plafonului prioritar. Această metodă constă în adăugarea proprietăților standard ale obiectelor de sincronizare a unui parametru determinat de prioritatea maximă a firului de execuție care accesează acest obiect. Dacă această opțiune este setată, atunci prioritatea oricărui fir care accesează acest obiect de sincronizare va fi mărită la nivelul specificat și, astfel, nu poate fi preempțiată de niciun fir care ar putea avea nevoie de resursa pe care a blocat-o. După ce resursa este deblocată, prioritatea firului de execuție este redusă la nivelul său inițial. Astfel, obținem ceva ca o moștenire preliminară a priorităților. Cu toate acestea, această metodă are o serie de dezavantaje serioase. În primul rând, dezvoltatorul are sarcina de a „antrenează” obiectele de sincronizare la nivelul lor de prioritate. În al doilea rând, pot exista întârzieri în lansarea firelor de execuție cu prioritate ridicată în timp ce firele de execuție cu prioritate scăzută sunt procesate. În general, acest mecanism poate fi utilizat cel mai eficient în cazul în care există un fir dur în timp real și mai multe fire de execuție cu prioritate inferioară care partajează resurse cu acesta.

11.Comunicarea între procese (English Inter-Process Communication, IPC) - un set de metode pentru schimbul de date între mai multe fire într-unul sau mai multe procese. Procesele pot fi rulate pe unul sau mai multe computere conectate printr-o rețea. Metodele IPC sunt împărțite în metode de mesagerie, sincronizare, memorie partajată și apelare la distanță (RPC). Metodele IPC depind de debitul și de latența comunicării între fire și de tipul de date transferate.

IPC, împreună cu conceptul de spațiu de adrese, este baza pentru delimitarea spațiului de adrese.

12. Probleme clasice de comunicare între procese

Problema prânzului filosofilor

În 1965, Dijkstra a formulat și a rezolvat problema sincronizării, pe care a numit-o problema filozofilor de prânz. Problema poate fi formulată astfel: cinci filozofi stau la o masă rotundă și fiecare are câte o farfurie cu spaghete. Spaghetele sunt atât de alunecoase încât fiecare filosof are nevoie de două furculițe pentru a le descurca. Există o furculiță între fiecare două farfurii.

Viața unui filozof constă în perioade alternante de mâncare și gândire. Când unui filozof îi este foame, încearcă să obțină două furculițe, stânga și dreapta, în orice ordine. Dacă reușește să ia două furculițe, mănâncă o vreme, apoi pune furculițele la loc și continuă să se gândească. Întrebarea este dacă este posibil să se scrie un algoritm care să modeleze aceste acțiuni pentru fiecare filozof și să nu se blocheze niciodată.

O situație în care toate programele continuă să ruleze pe termen nelimitat, dar nu pot face niciun progres, se numește înghețare a procesului.

Din punct de vedere practic, există probleme de eficiență: doar un singur filosof poate mânca spaghete la un moment dat. Dar există cinci furculițe, așa că doi filosofi trebuie să aibă voie să mănânce în orice moment. Filosoful poate începe să mănânce numai dacă niciunul dintre vecinii săi nu mănâncă.

Problema cititorilor și a scriitorilor

O altă problemă binecunoscută este problema cititorului-scriitor, care modelează accesul la baza de date. Imaginați-vă o bază de date de rezervare a avionului pe care multe procese încearcă să o acceseze. Puteți permite citirea simultană a datelor din baza de date, dar dacă un proces scrie informații în baza de date, accesul la alte procese trebuie refuzat, chiar și accesul de citire. Cum se programează cititorii și scriitorii?

Atâta timp cât există cel puțin un proces de citire activ în baza de date, accesul la alți cititori este permis, iar aceștia continuă să vină și să vină. Pentru a evita această situație, trebuie să schimbați puțin programul: dacă procesul de scriere așteaptă accesul la baza de date, noul proces de citire nu primește acces, ci sta în coadă în spatele procesului de scriere.

Problema bărbierului adormit

În salonul de coafură există un frizer, scaunul lui și n scaune pentru vizitatori. Dacă nu există oameni dornici să folosească serviciile lui, frizerul se așează pe scaun și doarme. Dacă un client vine la coafor, trebuie să-l trezească pe frizer. Daca soseste un client si vede ca frizerul este ocupat, fie se aseaza pe scaun (daca este loc), fie pleaca (daca nu este loc). Frizerul și patronii trebuie programați pentru a evita o condiție de cursă.

Soluția propusă folosește trei semafore: clienții, pentru a număra vizitatorii în așteptare (nu se ia în calcul clientul care stă în scaunul frizerului - nu mai așteaptă); frizeri, numărul de frizeri (0 sau 1) care stau inactiv în așteptarea unui client și un mutex pentru a implementa excluderea reciprocă. Variabila de așteptare este folosită și pentru a număra vizitatorii în așteptare.

13. Impas este o situație în care un grup de procese se află într-o situație de blocaj dacă fiecare proces din grup așteaptă un eveniment care poate fi apelat doar de un alt proces din același grup.

Resursele paginate pot fi luate fără durere din procesul care le deține.

O resursă nepaginată nu poate fi luată fără durere dintr-un proces.

Algoritm pentru utilizarea resurselor în vedere generală:

2. Utilizarea resurselor

3. Returnarea resurselor

Stare de blocaj:

1. Condiție de excludere reciprocă. Fiecare resursă la un moment dat este fie atribuită exact unui proces, fie disponibilă.

2. Condiția de deținere și așteptare. Procesele care dețin în prezent resurse primite anterior pot solicita resurse noi.

3. Condiție pentru absența descarcării forțate a resurselor. Resursele dobândite anterior nu pot fi luate cu forța dintr-un proces. Procesul de deținere trebuie să elibereze resurse în sine.

4. Condiție ciclică de așteptare. Trebuie să existe o secvență circulară de două sau mai multe procese, fiecare așteptând accesul la o resursă deținută de următorul membru al secvenței.

Detectarea și eliminarea blocajelor:

1. Recuperarea folosind eliberarea forțată a resurselor este selecția deliberată a resurselor dintr-un proces și este utilizată în principal pe sistemele de procesare a datelor în serie. Are un dezavantaj: nu toate resursele pot fi luate din proces.

2. Recuperare prin rollback. Constă în crearea de puncte de control de către dezvoltatori în aplicații. După ce apare un impas, procesul revine la cel mai apropiat punct de control și își începe activitatea din nou din acel punct.

3. Recuperarea prin distrugerea proceselor Constă în distrugerea unuia dintre procesele aflate în impas. Dacă uciderea nu ajută, următorul proces este oprit până când blocajul este rezolvat.

Evitarea blocajelor:

O stare este sigură dacă nu este blocată și există o anumită ordine în planificator în care fiecare proces este protejat (chiar dacă toate procesele doresc să obțină numărul maxim de resurse).

Prevenirea blocajului:

1. Atacul de condiție de excludere reciprocă

Dacă sistemul nu are o resursă alocată pentru utilizarea exclusivă a unui proces, atunci un blocaj nu va apărea niciodată. Alocarea resurselor atunci când nu este cu adevărat necesară trebuie evitată și este important să se încerce să se asigure o situație în care un număr minim de procese să poată revendica resursa.

2. Atacul de așteptare și condiții de așteptare

Programarea unui proces în așa fel încât să necesite toate resursele imediat înainte ca programul să înceapă să ruleze.

Dezavantajele acestei soluții:

· Nu toate procesele știu de câte și de ce resurse vor avea nevoie înainte de a începe lucrul.

Resursele nu vor fi utilizate optim

3. Atacarea condiției de absență a descărcării forțate a resurselor

Nu există o modalitate normală de a evita blocajul deoarece... Eliminarea forțată a unei resurse dintr-un proces în timp ce acesta rulează este practic imposibilă.

4. Atacul ciclic cu condiția de așteptare

· Managementul resurselor afirmă în general că un proces are dreptul la o singură resursă la un moment dat. Este posibil ca această regulă să nu fie activată pentru toate procesele.

· Numerotarea generală a tuturor resurselor și introducerea unei reguli conform căreia un proces trebuie să solicite mai multe dispozitive în funcție de succesiunea numerotării acestora. Funcționează numai pe cantități relativ mici de resurse.

5. Algoritmul bancherului

O stare sigură este cea pentru care există cel puțin o secvență de evenimente care nu va duce la blocaj.

Esența algoritmului:

· Să presupunem că sistemul are dispozitive „x”.

· Sistemul de operare acceptă o solicitare de la un proces utilizator dacă cererea maximă a acestuia nu depășește „x”.

· Utilizatorului i se garantează că, dacă sistemul de operare este capabil să-și satisfacă cererea, atunci toate dispozitivele vor fi returnate în sistem într-o perioadă de timp finită.

· Starea curentă a sistemului se numește fiabilă dacă sistemul de operare poate furniza tuturor proceselor execuția lor într-un timp finit.

· Conform algoritmului banker, alocarea dispozitivelor este posibilă numai dacă starea sistemului rămâne fiabilă.

Concluzii: Există diferite moduri de a rezolva blocajele.

· Eliberarea de către operator a procesului de rulare până la dispariția blocajului.

· Reporniți sistemul de la un punct de control

Punct de verificare - starea completă a PC-ului salvat pe suport extern.

14. Resurse paginabile

Vezi locul 13 (nu există nimic pe internet, info 146%).

15.Resurse nepaginate

Vezi al 13-lea.

16. GRĂSIME (Tabelul de alocare a fișierelor în engleză - „tabelul de alocare a fișierelor”) este o arhitectură clasică de sistem de fișiere, care, datorită simplității sale, este încă utilizată pe scară largă pentru unități flash și carduri de memorie. În trecutul recent, a fost folosit în dischete, hard disk-uri și alte medii de stocare.

Dezvoltat de Bill Gates și Mark McDonald în 1976-1977. Folosit ca sistem de fișiere principal în sistemele de operare din familiile DOS și Windows (până la Windows 2000).

Structura FAT urmează standardul ECMA-107 și este definită în detaliu printr-o specificație oficială de la Microsoft cunoscută sub numele de FATGEN.

Lungimea maximă posibilă a fișierului în FAT32 este de 4 GB minus 2 octeți. Aplicațiile Win32 pot deschide fișiere de această lungime fără procesare specială. Alte aplicații ar trebui să utilizeze întreruperea Int 21h, funcția 716C (FAT32) cu steag-ul deschis setat la EXTEND-SIZE (1000h).

În sistemul de fișiere FAT32, sunt alocați 4 octeți pentru fiecare cluster din tabelul de alocare a fișierelor, în timp ce în FAT16 - 2 și în FAT12 - 1.5.

Cei mai semnificativi 4 biți ai unui element de tabel FAT32 pe 32 de biți sunt rezervați și nu participă la formarea numărului clusterului. Programele care citesc direct tabelul PAT32 trebuie să mascheze acești biți și să îi protejeze împotriva modificărilor atunci când sunt scrise noi valori.

Sisteme de fișiere (NTFS)

Sistem de fișiere este o modalitate de organizare a datelor pe medii de stocare. Sistemul de fișiere determină unde și cum vor fi scrise fișierele pe mediul de stocare și oferă sistemului de operare acces la acele fișiere.

Sistemele de fișiere moderne au cerințe suplimentare: capacitatea de a cripta fișierele, controlul accesului pentru fișiere și atribute suplimentare. De obicei, sistemul de fișiere este scris la începutul hard diskului.

NTFS(abreviere Sistem de fișiere cu tehnologie nouă - Sistem de fișiere Noua tehnologie ) este un sistem de fișiere standard pentru familia de sisteme de operare Microsoft Windows NT.

Introdus pe 27 iulie 1993 împreună cu Windows NT 3.1. NTFS se bazează pe sistemul de fișiere HPFS (o abreviere Sistem de fișiere de înaltă performanță - Sistem de fișiere de înaltă performanță), creat de Microsoft împreună cu IBM pentru sistemul de operare OS/2.

Principalele caracteristici ale NTFS: capabilități încorporate pentru a limita accesul la date pentru diferiți utilizatori și grupuri de utilizatori, precum și pentru a atribui cote (restricții privind cantitatea maximă de spațiu pe disc ocupată de anumiți utilizatori), utilizarea unui sistem de jurnalizare pentru a crește fiabilitatea sistemului de fișiere.

Specificațiile sistemului de fișiere sunt proprietare. De obicei, dimensiunea clusterului este de 4 Kb. În practică, nu este recomandat să creați volume mai mari de 2TB. Hard disk-urile tocmai au atins această dimensiune, poate că în viitor ne așteaptă un nou sistem de fișiere.

În timpul instalării Windows XP, vi se solicită să formatați discul în sistem. GRĂSIME sau NTFS. Acest lucru înseamnă FAT32.

Toate sistemele de fișiere sunt construite pe principiul: un cluster - un fișier. Aceste. un cluster stochează date dintr-un singur fișier.

Principala diferență pentru utilizator obișnuitîntre aceste sisteme este dimensiunea clusterului. „Cu mult timp în urmă, când discurile erau mici și fișierele foarte mici”, acest lucru era foarte vizibil.

Să ne uităm la exemplul unui volum de pe un disc cu o capacitate de 120 GB și un fișier de 10 KB în dimensiune.

Pentru FAT32 dimensiunea clusterului va fi de 32Kb, iar pentru NTFS - 4Kb.

ÎN FAT32 un astfel de fișier va ocupa 1 cluster, lăsând 32-10=22Kb de spațiu nealocat.

ÎN NTFS un astfel de fișier va ocupa 3 clustere, lăsând 12-10 = 2Kb de spațiu nealocat.

Astfel, trecerea de la FAT32 La NTFS permite o utilizare mai optimă hard disk când există un număr mare de fișiere mici în sistem.

Și comunicarea între procese ( comunicarea între procese) într-un sistem de operare multitasking. Problema este să ne asigurăm că frizerul lucrează când există clienți și se odihnește când nu există clienți.

YouTube enciclopedic

1 / 1

✪ Întâlnire ineficientă. Filmul „Afonya”

Subtitrări

Problemă

Analogia se bazează pe o frizerie ipotetică cu un frizer. Coaforul are un loc de lucru și o zonă de recepție cu mai multe scaune. Când frizerul termină de tuns clientul, îl eliberează pe client și apoi se duce în zona de recepție pentru a vedea dacă sunt clienți care așteaptă. Dacă există, îl invită pe unul dintre ei și își tunde părul. Dacă nu așteaptă clienți, se întoarce pe scaun și doarme în el.

Fiecare client care vine se uită la ceea ce face frizerul. Dacă coaforul doarme, clientul îl trezește și se așează pe un scaun. Daca coaforul lucreaza, atunci clientul merge in zona de receptie. Dacă în zona recepției există un scaun liber, clientul se așează și își așteaptă rândul. Dacă nu există scaun liber, clientul pleacă. Pe baza unei analize naive, descrierea de mai sus ar trebui, teoretic, să asigure că frizeriei funcționează corect, frizerul tăind părul oricui în timp ce există clienți și apoi dormind până sosește următorul client. În practică, există mai multe situații conflictuale care ilustrează probleme comune de planificare.

Toate aceste situații conflictuale sunt legate de faptul că acțiunile atât ale coaforului, cât și ale clientului (verificarea zonei de recepție, intrarea în coafor, luarea unui loc în zona de recepție etc.) durează un timp necunoscut și/sau poate apărea simultan. De exemplu, un client poate intra și observa că coaforul lucrează, apoi se duce în zona recepției. În timp ce merge, frizerul termină tunsoarea pe care o face și merge să verifice zona de recepție, și o face mai repede decât clientul care se îndreaptă acolo. Intrucat inca nu este nimeni in zona de receptie (clientul nu a sosit inca), se intoarce la el si doarme. Coaforul asteapta acum clienta, iar clientul il asteapta pe coafor. Într-un alt exemplu, doi clienți pot ajunge în același timp când în zona de recepție există un singur loc liber. Observă că coaforul lucrează, se duc la recepție, iar amândoi încearcă să ia singurul scaun.

Problema frizerului adormit este adesea atribuită lui Edsger Dijkstra (1965), unul dintre pionierii informaticii.

Soluţie

Există mai multe soluții posibile la această problemă. Elementul principal al fiecăreia dintre soluții este un mutex - un mecanism care asigură că starea ( stat) la un moment dat doar unul dintre participanți poate. Frizerul trebuie să încuie mutexul înainte de a verifica clienții și să-l elibereze atunci când începe fie să doarmă, fie să lucreze. Clientul trebuie să achiziționeze același mutex înainte de a intra în frizerie și să-l elibereze imediat ce ocupă loc fie în zona de recepție, fie la frizer. Acest lucru rezolvă ambele probleme menționate în secțiunea anterioară. De asemenea, este posibil să se utilizeze un mecanism semafor mai general pentru a indica starea curentă a sistemului. De exemplu, folosind un semafor puteți exprima numărul de persoane din zona de recepție.

Versiunea cu mai mulți frizeri a aceleiași probleme are complexitatea suplimentară de a coordona mai mulți frizeri între clienții în așteptare.

Vezi și:

Lr1.doc

Sisteme de operare.

Subiect: Subsistemul de control al procesului. Problema coaforului adormit.

Ţintă: Familiarizați-vă cu principalele metode care sunt utilizate în subsistemele de control al proceselor.

Material pentru studiul preliminar:

1. Conceptul și organizarea proceselor.

2. Implementarea proceselor în sistemul de operare Windows.

3. Instrumente limbaj C pentru lucrul cu procese.

Material teoretic.

Procesele trebuie adesea să comunice între ele. De exemplu, într-o conductă de nucleu, rezultatul primului proces trebuie să fie transmis celui de-al doilea și așa mai departe, în lanț. Prin urmare, este nevoie de o interacțiune organizată corespunzător între procese (IPC, comunicare între procese), dacă este posibil, fără a utiliza întreruperi.

Problema este împărțită în trei puncte. Am menționat deja primul: transferul de informații de la un proces la altul. Al doilea este legat de controlul procesului: cum să vă asigurați că două procese nu se intersectează în situații critice (imaginați-vă două procese, fiecare dintre ele încercând să preia ultimul megaoctet de memorie). Al treilea se referă la coordonarea acţiunilor proceselor: dacă procesul O trebuie să furnizeze date și procesul ÎN tipăriți-le, apoi procesul ÎN trebuie să aștepte și să nu înceapă imprimarea până la sosirea datelor din proces O.

Este important să înțelegeți că două dintre cele trei puncte descrise se aplică în mod egal firelor. Primul - transferul de informații - nu este o problemă în cazul firelor de execuție, deoarece firele de execuție au un spațiu de adrese comun (transferul de informații între fire de execuție cu spații de adrese diferite este deja o problemă de transfer de informații între procese). Celelalte două se referă la fel de bine la fire: aceleași probleme și aceleași soluții. Vom lua în considerare aceste situații în contextul proceselor, dar rețineți că același raționament se aplică firelor.

^ 1. Condiția de cursă.

Pe unele sisteme de operare, procesele care rulează împreună pot partaja un fel de stocare de date partajată. Fiecare proces poate citi și scrie informații din depozitul de date partajat. Această stocare este o locație în memoria principală (eventual în structura de date kernel) sau un fișier partajat. Locația memoriei partajate nu afectează natura interacțiunii sau problemele care apar. Să ne uităm la comunicarea între procese folosind un exemplu simplu, dar foarte comun: un spooler de imprimare.

Dacă un proces trebuie să imprime un fișier, acesta plasează numele fișierului într-un director spooler special. Un alt proces, demonul de imprimare, verifică periodic fișierele de tipărit, tipărește fișierul și șterge numele acestuia din director.

Imaginați-vă că directorul spooler este format dintr-un număr mare de segmente, numerotate 0, 1, 2, ..., fiecare dintre acestea putând stoca un nume de fișier. Există, de asemenea, două variabile comune: afară, indicând următorul fișier de imprimat și în, arătând spre următorul segment liber. Aceste două variabile pot fi stocate într-un singur fișier (format din două cuvinte) care este accesibil tuturor proceselor. Lăsați segmentele de la 0 la 3 să fie goale momentan (aceste fișiere au fost deja tipărite), iar segmentele de la 4 la 6 sunt ocupate (aceste fișiere așteaptă rândul pentru a fi tipărite). Procese mai mult sau mai puțin simultane A și B decideți să puneți fișierul în coadă pentru imprimare. Situația descrisă este prezentată schematic în Fig. 2.14.

În conformitate cu legea lui Murphy (sunt cam așa: „Dacă se poate întâmpla ceva rău, cu siguranță se va întâmpla”), este posibilă următoarea situație. Proces O citește valoarea (7) a variabilei înși îl stochează într-o variabilă locală next_free_slot. După aceasta, are loc o întrerupere a temporizatorului și procesorul trece la proces ÎN. Proces ÎN, la rândul său, citește valoarea variabilei înși îl stochează (din nou 7) în variabila locală next_free_slot.În acest moment, ambele procese consideră că următorul segment liber este al șaptelea. Proces ÎN salvează numele fișierului în directorul spooler și înlocuiește valoarea în pe 8, apoi continuă să-și facă sarcinile de non-tastare. În cele din urmă, controlul vine asupra procesului O, și continuă de unde a plecat. Acesta accesează variabila next_free_slot, citește valoarea sa și scrie numele fișierului în al șaptelea segment (desigur, ștergând numele fișierului scris acolo de către proces ÎN). Apoi înlocuiește valoarea în pana la 8 (next_free_slot+1 = 8). Structura directorului spooler este intactă, deci demonul de imprimare nu va suspecta nimic greșit, dar fișierul de proces ÎN nu vor fi tipărite.

Situațiile în care două (sau mai multe) procese citesc sau scriu date în același timp, iar rezultatul final depinde de care dintre ele a venit primul se numesc condiții de cursă.

Zone critice.

Cum să eviți concurența? Principala modalitate de a preveni problemele în aceasta și orice altă situație care implică partajarea memorie, fișiere și orice altceva, este de a împiedica mai mult de un proces să scrie și să citească simultan date partajate. Cu alte cuvinte, excluderea reciprocă este necesară. Aceasta înseamnă că, în momentul în care un proces utilizează datele partajate, altui proces i se va interzice să facă acest lucru. Problema descrisă mai sus a apărut din cauza procesului ÎN a început să lucreze cu una dintre variabilele partajate înainte de proces O a terminat-o. Alegerea operațiunii primitive adecvate pentru a implementa excluderea reciprocă este o considerație majoră în proiectarea sistemului de operare.

Problema eliminării condițiilor de cursă poate fi formulată la nivel abstract. Pentru o anumită perioadă de timp, procesul este ocupat cu calcule interne și alte sarcini care nu duc la condiții de cursă. Alteori, procesul accesează date partajate sau efectuează o altă acțiune care ar putea duce la o condiție de cursă. Partea programului care accesează datele partajate se numește regiunea critică sau secțiunea critică. Dacă putem evita să avem două procese în regiuni critice în același timp, putem evita condițiile de cursă.

Deși această cerință elimină condițiile de cursă, nu este suficient să se asigure că procesele paralele funcționează împreună și utilizează datele în mod eficient. Pentru a face acest lucru, trebuie îndeplinite patru condiții:

1. Este imposibil ca un proces să aștepte pentru totdeauna pentru a ajunge în regiunea critică.

2. Două procese nu ar trebui să fie simultan în zone critice.

3. Programul nu trebuie să facă presupuneri cu privire la viteza sau numărul de procesoare.

4. Un proces situat în afara regiunii critice nu poate bloca alte procese.

Într-o formă abstractă, comportamentul necesar al procesului este prezentat în Fig. 2.15. Procesul A intră la timp în regiunea critică T 1 . Puțin mai târziu, la un moment dat T 2 , proces ÎNîncearcă să intre în regiunea critică, dar eșuează pentru că există deja un proces în regiunea critică O,și două procese nu ar trebui să fie în zone critice în același timp. Prin urmare procesul ÎN suspendat temporar până la momentul respectiv T 3 când procesul O părăsește regiunea critică. La un moment dat T 4 proces ÎN părăsește și regiunea critică și ne întoarcem la starea inițială, când nu existau procese în regiunea critică.

Semafoare.

În 1965, E. W. Dijkstra a propus utilizarea unei variabile întregi pentru a număra semnalele de declanșare stocate pentru utilizare ulterioară. El a propus un nou tip de variabile, așa-numitele semafoare, a cărui valoare poate fi zero (în absența semnalelor de activare stocate) sau un număr pozitiv corespunzător numărului de semnale de activare întârziate.

Dijkstra a propus două operațiuni, josŞi Sus(generalizări dormiŞi trezeşte-te). Operațiunea jos compară valoarea semaforului cu zero. Dacă valoarea semaforului este mai mare decât zero, operația jos o reduce (adică consumă unul dintre semnalele de activare stocate) și pur și simplu readuce controlul. Dacă valoarea semaforului este zero, procedura jos nu readuce controlul asupra procesului, iar procesul este plasat în starea de așteptare. Toate operațiunile de verificare a valorii unui semafor, schimbarea acestuia și transferarea procesului în starea de așteptare sunt efectuate ca o acțiune elementară unică și indivizibilă. Acest lucru asigură că, odată ce o operațiune a început, niciun proces nu va avea acces la semafor până când operația nu este finalizată sau blocată. Simplitatea operațiunii este extrem de importantă pentru a rezolva problema de sincronizare și pentru a preveni condițiile de cursă.

Operațiunea Sus crește valoarea semaforului. Dacă acest semafor are unul sau mai multe procese de așteptare asociate cu el care nu pot finaliza o operațiune anterioară de down, unul dintre ele este selectat de sistem (de exemplu, aleatoriu) și i se permite să își termine operația de down. Astfel, după operație Sus aplicat unui semafor asociat cu mai multe procese de așteptare, valoarea semaforului va rămâne 0, dar numărul de procese de așteptare va scădea cu unu. Operația de creștere a valorii semaforului și de activare a procesului este, de asemenea, indivizibilă. Niciun proces nu poate fi blocat în timp ce o operație este în desfășurare Sus cum nici un proces nu a putut fi blocat în timp ce operațiunea se desfășura trezeşte-teîn modelul anterior.

În originalul Dijkstra folosit în schimb josŞi Sus denumirile P și respectiv V. Nu vom folosi denumirile originale în viitor, deoarece aceste denumiri nu înseamnă nimic pentru cei care nu cunosc limba daneză (și spun puțin celor care cunosc limba). Pentru prima dată desemnări josŞi Sus a apărut în Algol 68.

Rezolvarea problemei producătorului și consumatorului folosind semafore .

După cum se arată în Lista 2.4, problema semnalelor de declanșare pierdute poate fi rezolvată prin utilizarea semaforelor. Este foarte important ca acestea să fie implementate într-o manieră indivizibilă. Modul standard este implementarea operațiunilor josŞi Sus sub formă de solicitări de sistem, sistemul de operare interzicând toate întreruperile pe perioada verificării semaforului, modificându-i valoarea și eventual transferând procesul într-o stare de așteptare. Deoarece sunt necesare doar câteva instrucțiuni de procesor pentru a efectua toate aceste acțiuni, dezactivarea întreruperilor nu dăunează. Dacă sunt utilizate mai multe procesoare, fiecare semafor trebuie protejat cu o variabilă de blocare folosind instrucțiunea TSL pentru a se asigura că doar un procesor accesează semaforul la un moment dat. Este important de înțeles că utilizarea comenzii TSL este fundamental diferită de așteptarea activă, în care producătorul sau consumatorul așteaptă ca un buffer să se umple sau să se golească. O operațiune cu un semafor va dura câteva microsecunde, în timp ce o așteptare activă poate dura o perioadă de timp semnificativ mai lungă.

Lista 2.4 Problemă cu semaforele producătorului și consumatorului

#define N 100 /* numărul de segmente din buffer */

Typedef int semafor; /* semaforele sunt un tip special de variabile întregi */ semaphore mutex =1; /* controlul accesului în zona critică */

Semafor gol = N ; /* numărul de segmente tampon goale /

Semaforul plin = DESPRE; /* numărul de segmente tampon complete */

voidproducer(void)

În timp ce (adevărat)

( /* TRUE - constantă egală cu 1*/

Item = protiuce_item(); /* creează date pentru a fi stocate în tampon */

Jos(&gol); /* scade contorul segmentelor buffer goale */

Jos(&mutex): /* intră în regiunea critică */

Insert_item(articol); /* plasează un nou element în buffer */

Sus(&mutex): /* ieșire din regiunea critică */

Sus(&ful1); /* incrementează contorul segmentelor tampon pline */

Consumator nul (nulat)

( /* buclă fără sfârșit */

Jos(&plin); /* reduce numărul de segmente de buffer complet */

Jos(&mutex); /* intră în zona critică */

Item = remove_item(); /* elimină elementul din buffer */

Sus(&mutex); /* ieși din zona critică */

Sus(&gol): /* mărește contorul segmentelor tampon goale */

Consume_item(articol): /* procesare element */

Soluția prezentată folosește trei semafore: unul pentru a număra segmentele tampon umplute (deplin), altul pentru numărarea segmentelor goale (gol) iar al treilea este conceput pentru a preveni accesul simultan la tamponul producătorului și al consumatorului (mutex). Contravaloarea deplin inițial egal cu zero, contor gol egal cu numărul de segmente din buffer, a mutex este egal cu 1. Semaforele, a căror valoare inițială este egală cu 1, utilizate pentru a exclude prezența simultană a două procese în regiunea critică se numesc semafoare binare. Excluderea reciprocă se realizează dacă fiecare proces realizează operația josînainte de a intra în zona critică Şi sus după ce ieși din ea.

Acum că avem primitivele de comunicare între procese, să revenim la secvența de întreruperi prezentată în tabel. 2.2. În sistemele care utilizează semafore, o modalitate naturală de a ascunde o întrerupere este asocierea unui semafor setat inițial la zero pe fiecare dispozitiv I/O. Imediat după pornirea dispozitivului I/O, procesul de control efectuează operația jos pe semaforul corespunzător, intrând astfel într-o stare de blocare. Dacă apare o întrerupere, se execută gestionarea întreruperilor Sus pe semaforul corespunzător, punând procesul în starea gata. Într-un astfel de model, al cincilea pas în tabel. 2.2 este de a efectua Sus pe semaforul dispozitivului, astfel încât următorul pas planificatorul să poată rula programul, controlul dispozitivului. Desigur, dacă în acest moment mai multe procese sunt într-o stare pregătită, planificatorul poate alege un alt proces, mai semnificativ.

În exemplul prezentat în Lista 2.4, semaforele au fost folosite de doi în diverse moduri. Această diferență este suficient de semnificativă pentru a merita o mențiune specială. Semafor mutex folosit pentru a implementa excluderea reciprocă, adică pentru a preveni accesul simultan la buffer și la variabilele asociate a două procese.

Semaforele rămase au fost utilizate pentru sincronizare deplinŞi gol sunt necesare pentru a se asigura că anumite secvențe de evenimente au loc sau nu. În cazul nostru, ei se asigură că producătorul se oprește când bufferul este plin, iar consumatorul se oprește când tamponul este gol.

^ Declarația problemei:

Problema coaforului care doarme este o demonstrație alegorică a subsistemului de control al procesului și a fost formulată de Dijkstra în 1968. Problema este formulată astfel: Coaforul este format dintr-o sală de așteptare O și o cameră în care se află un scaun de coafor. Z. Prin ușile D se poate ajunge din camera O în camera Z, iar din camera Z în stradă. Dacă frizerul intră în sala de așteptare și nu găsește pe nimeni acolo, atunci se culcă. Dacă un client intră la coafor și îl găsește pe coafor dormind, îl trezește. Numărul de locuri în sala de așteptare este limitat și egal cu N.

Conform acestei sarcini, este necesar să se determine elementele care vor fi programate de procesele individuale, să se dezvolte un algoritm și să-l implementeze în mod programatic.

Soluția sugerează utilizarea a trei semafore:

clienti, a număra vizitatorii în așteptare (un client care stă pe scaunul frizerului nu este numărat - nu mai așteaptă);

frizerie, numărul de frizeri (0 sau 1) care stau inactiv și așteaptă un client;

mutex pentru a implementa excluderea reciprocă.

Se folosește și variabila aşteptare, conceput pentru a număra vizitatorii în așteptare. Este o copie a variabilei clienţilor. Prezența acestei variabile în program se datorează faptului că este imposibil să citiți valoarea curentă a semaforului. În această soluție, un client care vizitează un salon de coafură trebuie să numere numărul de clienți care așteaptă. Dacă sunt mai puțini vizitatori decât scaune, noul vizitator rămâne, altfel pleacă.

1. Tema și scopul lucrării.

2. Alocarea de laborator.

3. Algoritmul programului.

4. Rezultate obţinute.

5. Concluzii asupra lucrării cu analiza modelului de interacțiune proces implementat.

Dimensiune: px

Începeți să afișați de pe pagină:

Transcriere

1 Probleme clasice de sincronizare, partea 2 Cititori și scriitori Producători și consumatori Coafor dormit

2 Cititori și scriitori Având în vedere o zonă de memorie partajată, această structură de date poate fi accesată de un număr arbitrar de „cititori” și un număr arbitrar de „scriitori” Mai mulți cititori pot accesa în același timp, scriitorii nu au voie în acest moment Doar un singur scriitor pot accesa, alți scriitori și cititori trebuie să aștepte

3 Soluția 1 Prima soluție: un cititor poate intra în secțiunea critică dacă nu există scriitori Această soluție este nedreaptă, deoarece dă preferință cititorilor. Un flux puternic de solicitări din partea cititorilor poate duce la un scriitor să nu obțină niciodată acces la secțiunea critică: un „ situație de foamete (foamete)

4 Soluția 2 Dați preferință scriitorilor, adică cititorul nu este inclus în secțiunea critică dacă există cel puțin un scriitor în așteptare pthread_mutex_t m; pthread_cond_t cw, cr; int rcnt, wcnt; int wwcnt; // numărul de scriitori în așteptare void rdlock() ( pthread_mutex_lock(&m); în timp ce (wcnt > 0 wwcnt > 0) pthread_cont_wait(&cr, &m); rcnt++; pthread_mutex_unlock(&m); )

5 Soluția 2 void wrlock() ( pthread_mutex_lock(&m); în timp ce (wcnt > 0 rcnt > 0) ( wwcnt++; pthread_cond_wait(&cw, &m); wwcnt--; ) wcnt++; pthread_mutex_unlock(&m); () ( void unlock(&m); ) // )

6 Soluția 2 Această soluție dă prioritate scriitorilor și este, de asemenea, nedreaptă Posibilă înfometare a cititorilor A treia soluție: nu da prioritate nimănui, folosește doar un mutex

7 Problemă producător-consum Având în vedere un buffer de dimensiune fixă ​​(N) în care se află coada. Producătorii adaugă elemente la sfârșitul cozii, dacă tamponul este plin, producătorii merg la somn Consumatorii preiau elemente din partea din față a cozii, dacă tamponul este gol, consumatorii merg la somn

8 Producători-consumatori int buf[n]; int cap, coada; pthread_mutex_t m; pthread_cond_t cc; // consumer condvar pthread_cond_t pc; // producător condvar void put(int x) ( pthread_mutex_lock(&m); while ((tail + 1) % N == head) pthread_cond_wait(&pc, &m); buf = x; tail = (tail + 1) % N; if ((cap + 1) % N == coadă) pthread_cond_signal(&cc pthread_mutex_unlock(&m);

9 Producători-Consumatori int get(void) ( int val; pthread_mutex_lock(&m); while (head == tail) pthread_cond_wait(&cc, &m); val = buf; if ((tail + 1) % N == head) pthread_cond_signal (&pc); cap = (cap + 1) % N pthread_mutex_unlock(&m);

10 Frizerul adormit Coaforul are un scaun de tuns și N scaune pentru vizitatori. Dacă nu sunt vizitatori, frizerul doarme. În caz contrar, vizitatorul stă pe scaunul de așteptare. Dacă toate scaunele sunt ocupate, vizitatorul pleacă

11 Coafor dormit pthread_mutex_t m; pthread_t chair_thr; // cine tăiem părul int wait_cnt; // câți vizitatori așteaptă pthread_cond_t bc; // frizer condvar pthread_cond_t cc; // consumator condvar void barber(void) ( while (1) ( pthread_mutex_lock(&m); while (chair_thr == NULL && wait_cnt == 0) pthread_cond_wait(&bc, &m); pthread_mutex_unlock(&m); make_haircut(_dlock(); mutex_rea(); &m); chair_thr = NULL; pthread_cond_signal(&cc);

12 Coafor de dormit int consumer(void) ( pthread_mutex_lock(&m); if (chair_thr!= NULL && wait_cnt == N) ( // fără spațiu, lăsând pthread_mutex_unlock(&m); return -1; ) while (chair_thr!= NULL) ( wait_cnt++; pthread_cond_wait(&cc, &m); wait_cnt--; ) chair_thr = pthread_cond_signal(&bc);

13 Procesul de detectare a blocajului 1: blocare(&a); blocare(&b); Procesul 2: blocare(&b); blocare(&a); Procesul 1 A Procesul 2 B Arc de resurse capturat de la proces la resursă Arc de resurse așteptat de la resursă la proces Dacă există un ciclu în grafic, sistemul este într-o stare de blocaj

14 Grupuri de procese Un grup de procese procese combinate pentru a îndeplini o sarcină (de exemplu, pentru a executa o conductă) Un grup de procese acționează ca o singură unitate atunci când primesc semnale, în special de la un terminal (de exemplu, Ctrl-C SIGINT) Când lucrează cu un terminal (procesele grupurilor principale și de fundal) Identificatorul grupului de procese este identificatorul unuia dintre procesele din grup

15 Crearea unui grup #include pid_t getpgid(pid_t pid); int setpgid(pid_t pid, pid_t pgid); Grupul de procese poate fi obținut doar dintr-un proces din sesiunea curentă, iar dacă pid == 0, grupul de procese al procesului curent este returnat. Pentru setpgid pid == 0 înseamnă procesul curent, pgid == 0 un grup de procese cu pgid-ul procesului curent

16 Crearea grupului, cazuri speciale setpgid(0, 0); Procesul creează un nou grup de procese și se plasează în el (executat în copil) setpgid(0, pgid); Procesul se plasează într-un grup de procese existent (în copil) setpgid(pid, pid); Procesul creează un nou grup de procese și plasează acolo procesul specificat (în tată)

17 Grupuri de procese și terminal Un terminal poate avea un grup de procese principal și un număr arbitrar de grupuri de procese de fundal. suspendat) Primește semnale SIGINT, SIGQUIT de la terminal

18 Grup de procese terminal principal pid_t tcgetpgrp(int fd); int tcsetpgrp(int fd, pid_t pgrp); fd orice descriptor de fișier de terminal (de exemplu, 0 intrare standard) tcsetpgrp setează grupul principal de procese al terminalului

19 Exemplu: ls -l wc -l int main(void) ( pipe(fds); if (!(pid1 = fork())) ( setpgid(0, 0); tcsetpgrp(0, getpid()); dup2( fds, 1); close(fds("/bin/ls", "-l", NULL) setpgid(pid1, pid1); (0, pid1); dup2(fds, 0); close(fds)("/usr/bin/wc"; setpgid(pid2, pid1); wait(0);

20 de procese Daemon

21 Programarea proceselor Componenta Scheduler a nucleului sistemului de operare Schedulerul determină ce proces dintre cele gata de rulare este atribuit execuției pe CPU Tipuri de planificatoare: Batch Time sharing Timp real

22 Planificarea loturilor Scopul este de a asigura maxim debitului VS (adică numărul maxim de sarcini finalizate) Nucleul trece de la un proces la altul în următoarele condiții: Procesul care rulează a ieșit Execuția a întâmpinat o eroare fatală sau procesul și-a epuizat resursele alocate Procesul de execuție a inițiat un operație care nu poate fi efectuată imediat Procesul a solicitat o schimbare voluntară

23 Planificarea partajării timpului Scop: Împărtășirea timpului CPU între procesele care sunt gata de executare Nucleul trece de la un proces la altul în următoarele condiții Procesul a ieșit O eroare a apărut în timpul execuției Procesul a inițiat o operație care nu poate fi efectuată imediat Procesul intervalul de timp de execuție a expirat Procesul a solicitat o comutare voluntară

24 Clasificarea proceselor După comportament „I/O-bound” - procesul schimbă în mod activ cu dispozitive externe și petrece mult timp așteptând I/O (exemplu: server web, editor de text) „CPU-bound” - procese care intens ocupă spațiul de timp al procesorului (exemplu: compilarea programelor, sarcinile de calcul, redarea imaginilor etc.)

25 Clasificarea proceselor În funcție de scop: cei interactivi își petrec cea mai mare parte a timpului așteptând intrarea utilizatorului când sosesc, acestea trebuie să fie activate rapid, astfel încât să nu aibă senzația de „frânare” (compilatorii, aplicatii numerice...)

26 Parametrii de programare pentru procesele de partajare a timpului Valoare Nice: [-20, 19] cu cât valoarea este mai mică, cu atât prioritatea este mai mare. 0 prioritate implicită Prioritate grup de procese: grpnice Prioritate utilizator: usrnice Prioritate completă: nice + grpnice + usrnice tăiat la interval [-20; 19] Prioritate normalizată normprio = 20 - fullnice, este în interval cu cât valoarea este mai mare, cu atât este mai mare prioritatea

27 Programarea în Linux Programarea proceselor este împărțită în epoci La începutul fiecărei epoci, fiecărui proces i se atribuie o bază cuantică bază_quantum = normprio/4 + 1 contor numărul de quante „neprocesate” din epocă, inițial counter = bază_quantum Pentru fiecare cuantă când procesul este executat, valoarea contorului este redusă cu 1 Prioritate: priority = counter + normprio Procesul cu cea mai mare prioritate este selectat

28 Programarea în Linux O epocă se termină când toate procesele sunt gata de rulare counter == 0 La începutul epocii următoare: base_quantum = counter/2 + normprio/4 + 1 Astfel, se acordă prioritate proceselor legate de I/O

29 Programare în timp real Scop: asigurarea unui timp minim de răspuns, adică timpul de la apariția unui eveniment până la execuția unui proces care așteaptă acest eveniment Tipuri de planificare în timp real Pe baza unui program fix Pe baza priorităților statice

30 Programare în timp real Nucleul trece de la un proces la altul în următoarele condiții Procesul a ieșit O eroare a apărut în timpul execuției Procesul a inițiat o operație care nu poate fi efectuată imediat Un proces cu o prioritate ridicată este gata de executat Intervalul de timp al procesului a expirat Procesul a solicitat o schimbare voluntară

31 Prioritate statică Fiecare proces în timp real are o prioritate statică Procesele cu timp partajat au o prioritate statică de 0, adică sunt atribuite execuției numai dacă nu există procese în timp real gata de executat

32 Tipuri de planificare r.v SCHED_FIFO fără tăiere de timp, procesul se execută până când apare un proces cu prioritate mai mare sau procesul începe I/O sau este oprit. Execuția SCHED_RR (round-robin) este cuantificată, procesele cu aceeași prioritate sunt executate pe rând

33 Inversarea priorității Să presupunem că procesul cu prioritate scăzută P1 a dobândit o resursă R. În acest moment, procesul cu prioritate ridicată P2, care necesită resursa R, este gata de executare Procesul P2 așteaptă eliberarea resursei R de procesul P1. În acest moment, procesul cu prioritate medie poate fi atribuit procesului P3, ceea ce va întârzia în continuare timpul în care resursa R este eliberată de procesul P1

34 Inversarea priorității Problema apare deoarece procesele care așteaptă să elibereze o resursă primesc implicit prioritatea procesului care a achiziționat resursa. Întârzierea execuției unui proces cu prioritate ridicată poate avea consecințe dezastruoase. Nu există o soluție clară a problemei. Opțiune posibilă: atribuiți prioritatea maximă a procesului de așteptare (moștenirea prioritară).

35 Gestionarea priorităților în Linux int nice(int inc); void sched_yield(void); int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);

Cuprins 1 Controlul postului 1 1.1 Concepte de bază ................................................ 1 1.2 Funcționalități suplimentare ale postului control ..................... 2 1.3 Terminal de control.............. ............. .....

Universitatea de Stat din Nijni Novgorod poartă numele. N.I Lobachevsky Facultatea de Matematică Computațională și Cibernetică Sisteme de operare: aspecte de paralelism CPU scheduling Linev A.V. Subiect de discuție: Fire

Algoritmi de planificare a firelor de execuție Algoritmi de planificare preventivă și non-preemptivă Algoritmii non-preemptive se bazează pe faptul că firul activ are voie să se execute în timp ce el însuși, din proprie inițiativă,

CAPITOLUL 15 Controlul jobului Controlul jobului, o caracteristică standardizată în POSIX.1 și furnizată de multe alte standarde, permite unui singur terminal să execute mai multe joburi. Exercita

Cea mai importantă parte Sistemul de operare care afectează direct funcționarea computerului este subsistemul de control al procesului. Un proces (sau cu alte cuvinte, o sarcină) este o abstractizare care descrie

Titlu Cursul 5. Programarea sarcinilor Sisteme de operare 6 noiembrie 2012 Cursul 5 1 / 39 Planificare Început Obiective de planificare Algoritmi de bază Definiție Politica de programare: (Strategia de planificare)

Modulul 3. MANAGEMENTUL PROCESULUI 1. Distribuie timpul procesorului între mai multe procese existente simultan în sistem și, de asemenea, se ocupă de crearea și distrugerea proceselor, asigură

Planificarea proceselor Multitasking Un sistem de operare este multitasking dacă este capabil să intercaleze execuția mai multor procese, dând impresia că mai mult de un proces rulează la un moment dat.

Cursul 8. Fire POSIX Utilizarea eficientă a IPC - memorie partajată și semafoare este încă limitată de costul generarii de noi procese cu apelul de sistem fork/2, chiar și atunci când se utilizează tehnologia

Curs 2. Subsistemul de control al proceselor. Managementul proceselor într-un sistem multitasking constă în alocarea resurselor nucleului pentru fiecare proces care rulează și schimbarea contextului proceselor

UNIX Curs 4 UNIX. L.4 1 PROCESE UNIX OS Un proces este o sarcină în timpul execuției sale. P - imagine program, inclusiv afișarea în memorie a fișierului executabil obținut la compilare, segmente

Lucrări de laborator 4 INTRODUCERE ÎN PROCESE Scopul lucrării Să se familiarizeze cu conceptul de proces. Aflați cum să obțineți o listă de procese disponibile în sistem și să gestionați starea acestora. 1. Informații teoretice

Procese și fire Sisteme de operare Cursul 2 Ulyanovsk, Universitatea Tehnică de Stat Ulyanovsk, departamentul " Sisteme informatice» 1 / 12 Model de proces Patru programe care lucrează în modul multitasking a); model conceptual de patru

Elementele de bază ale semnalelor sistemului de operare Unix Noțiunile de bază ale sistemului de operare Unix 28.2.08 Slide 1 din 34 Astăzi Ce este un semnal? Terminologie Probleme vechi cu semnalele POSIX și semnalele Linux Lucrul cu seturi de semnale Fundamente ale sistemului de operare Unix 28.2.08 Slide

UNIVERSITATEA NAȚIONALĂ DE CERCETARE NUCLEARĂ „MEPhI” Departamentul de Informatică și Procese de Control (17) Curs „Sisteme de operare moderne” Cursul 7 Planificare Moscova 2016 Cuprins 1. De bază

Semnale Un mijloc de interacțiune asincronă între procese Trimis de: Un proces către alt proces Nucleul sistemului de operare către un proces pentru a indica evenimentele care afectează procesul Nucleul sistemului de operare către un proces ca răspuns la incorecte

4.1 Procese 4.1.1 Conceptul unui proces Un proces (sarcină) este un program în modul de execuție. Fiecare proces este asociat cu spațiul său de adrese, din care poate citi și în care poate

Sisteme de operare. Dezvoltare și implementare. Tanenbaum E., Woodhull A. Ed. a III-a. - Sankt Petersburg: Peter, 2007. 704 p. A treia ediție a lucrării clasice a lui Andrew Tanenbaum „Sisteme de operare. Proiectare și implementare”

Sisteme de operare Cursul 2 Procese și fire (threads). 2.1 Procese 2.1.1 Concept de proces Un proces (sarcină) este un program în modul de execuție. Fiecare proces este asociat cu spațiul său de adrese,

Conducte cu nume O conductă care este accesată printr-un punct de ancorare a sistemului de fișiere Nucleul creează un obiect canal numit pentru fiecare intrare în sistemul de fișiere int mkfifo(const char

1 Lucrul cu procese în sistemele POSIX Conceptul de „proces”, împreună cu conceptul de „fișier”, se referă la conceptele de bază ale sistemului de operare. Un proces poate fi înțeles ca un program în execuție. Cu procesul

Lecția 6. Conceptul de proces. Stări de proces. Expediere. Planul de lecție. 1. Proces. Clasificarea proceselor. 2. Resurse. Clasificarea resurselor. 3. Managementul proceselor. 4. Planificarea procesului.

Titlu Cursul 6. Algoritmi de blocare Sisteme de operare 19 noiembrie 2012 Cursul 6 1 / 46 Obiective de planificare Cerințe pentru excluderile reciproce Cerințe În orice moment în timp într-un singur punct critic

Procese și fire de execuție Conceptele de „proces” și „thread” Un proces (sarcină) este un program în modul de execuție. Thread este cea mai mică parte a unui program a cărei execuție poate fi programată.

SISTEME INTEGRATE DE INFORMAȚIE ȘI CONTROL ÎN TIMP REAL Cursul 4: Programarea static-dinamică a calculelor în sisteme de avionică modulară integrată Departamentul ASVC, Laboratorul de Calcul

CONSORȚIUL DE SUPERCOMPUTERE AL UNIVERSITĂȚILOR RUSE Proiect Crearea unui sistem de pregătire a personalului cu înaltă calificare în domeniul tehnologiilor de supercomputer și al software-ului specializat

Cursul 10. Abordări ale sincronizării. Cuprins Problema cititor-scriitor Se blochează Abordări ale sincronizării Problema cititor-scriitor Problema cititor-scriitor Există o zonă de memorie care este accesată

Planificarea proceselor în proprietățile Windows NT 1) Procesele Windows NT sunt implementate sub formă de obiecte și sunt accesate prin intermediul serviciului obiect. 2) Procesul Windows NT este multi-threaded

Nume Deadlock Rețele Petri Cerințe pentru algoritmi Cursul 6. Algoritmi de blocare Sisteme de operare 11 noiembrie 2016 Cursul 6 1 / 65 Exemplu: compararea datelor POSIX Nume Deadlock

Implementarea paralelismului folosind „obiecte eficiente” Rezolvarea problemelor de organizare a paralelismului aplicației are loc în mod tradițional, folosind multitasking preventiv. Această schemă este adecvată

Sisteme de operare Cursul 3 Procese 1 Concept de proces Sistemul de operare în timpul funcționării execută unul sau mai multe programe, programează sarcini (un set de programe, comenzi pentru executarea acestuia).

UNIX Curs 6 UNIX. L.6 1 SEMNALE Întreruperi și situații speciale Întreruperi. Dispozitive I/O externe, ceas de sistem etc. întrerupe CPU asincron. La primirea unui semnal de întrerupere, nucleul de operare

Titlu Cursă 7. Algoritmi de blocare Sisteme de operare 24 martie 2016 Curs 7 1 / 48 Exemplu: Compararea datelor POSIX Deadlock rețele Petri Cerințe pentru algoritmi Exemplu Exemplu (sfârșit)

RTOS Sisteme de operare în timp real Page 1 Prezentare Definirea unui sistem de operare Caracteristici ale sistemelor de operare încorporate Procese, sarcini, fire de execuție Timp sistem Comunicare între procese Procesare

UNIX Curs 5 UNIX. L.5 1 Zombi și orfani Să mai adăugăm o a cincea stare celor patru stări cunoscute ale procesului: execuția procesului în modul kernel; executarea procesului în modul task; suspans; pregătire

Concurență 1 Introducere 2 3 Fire de execuție în Java Fire de execuție în C# Introducere Concurența poate apărea la patru niveluri Nivel de instrucțiune a mașinii Nivel de instrucțiuni în limbaj de programare de nivel înalt

Academia Tehnologică de Aviație de Stat din Rybinsk, numită după P.A. Solovyova „APROBAT” Decan al FRI A.I. Dvorson PROGRAM DE LUCRU La disciplina „Sisteme de operare” pentru direcția 230100 „Informatică”

Laboratorul 4. Opțiuni Opțiunea 1: Trebuie să rezolvați problema „Moș Crăciun” folosind biblioteca PTHREAD, sub rezerva următoarelor restricții: Moș Crăciun doarme tot timpul până când este plecat sau tot

1 Facilități de comunicare între procese Deoarece spațiile de adrese ale fiecărui proces sunt izolate unele de altele, sistemul trebuie să ofere proceselor un mijloc de comunicare. Cea mai simplă interacțiune

Relații între procese.. Sisteme de operare 2011/12 Tatyana Romanova 17 septembrie 2011 1 / 29 Planifică pentru astăzi Terminale. Grupuri de procese. Sesiuni. Conceptul de semnale. Fiabil și nesigur

Obiecte kernel Windows Tipuri de obiecte kernel jetoane de acces / evenimente token de acces / fișiere de evenimente / mapare fișiere / porturi de finalizare I/O / e-mail de job

Universitatea de Stat din Nijni Novgorod poartă numele. N.I Lobachevsky Facultatea de Matematică Computațională și Cibernetică Sisteme de operare: aspecte de paralelism Sincronizare-1 Linev A.V. Subiect de discuție Când

Interfața HAL Sistemul de operare FX-RTOS Versiunea 2.2 Cuprins Introducere... 3 Despre acest manual... 3 Terminologie... 3 Descrierea funcției API Format... 3 Interfețe HAL... 5 Gestionarea întreruperilor...

Universitatea de Stat din Nijni Novgorod poartă numele. N.I Lobachevsky Facultatea de Matematică Computațională și Cibernetică Sisteme de operare: aspecte de paralelism Procese și fire Linev A.V. Subiect de discutie

Tehnologie de cotă adaptivă pentru construirea de sisteme foarte fiabile Belokhvostikov Eduard inginer al departamentului de servicii al SWD Software Construcția de sisteme complexe Echipa mare, locația dezvoltatorilor

* 1. Rezolvarea problemei blocajului resurselor. Blocajul apare atunci când două sau mai multe sarcini se blochează reciproc, deoarece sarcina fiecărei părți blochează o resursă necesară celeilalte

Teme pentru acasă 4 (2015) Problema H41: Citirea sincronă-2 Condiția acestei probleme repetă aproape textual condiția problemei H32, în locul semnalelor trebuie folosite doar semafore. Scrieți un program

CUASI-PLANIFICATOR PENTRU UTILIZAREA MODULELOR DE CALCUL INDLE ALE UNUI SISTEM DE CALCUL MULTIPROCESOR SUB CONTROLUL SUPPZ A.V. Baranov, E.A. Kiselev, D.S. Supercomputer interdepartamental Lyakhovets

32. Principii de construire a sistemelor de operare. Procesul de calcul și implementarea acestuia folosind sistemul de operare. Managementul proceselor de calcul, intrare/ieșire, memorie reală. Principii pentru construirea sălilor de operație

Paralelism Multithreading De ce să creăm sisteme paralele? Limitări naturale Este imposibil să creșteți la nesfârșit performanța procesoarelor cu un singur nucleu. Exemplu 1 ciclu de ceas al unui procesor de 4 GHz 0,25 ns.

Cursul 6. Utilizarea descriptorilor de fișiere. Descriptor de fișier utilizator Cere de sistem pentru lucrul cu un fișier: 1. deschide/creează 1 deschide/creează un fișier cu opțiunile specificate și modul de acces int

Departamentul VGKS Curs POST „Software de sistem” Lucrare de laborator 1 (4 ore) Subiect: „Crearea de fire în API-ul Win32 pentru sistemul de operare MS Windows.” Un fir este creat de funcția CreateThread, care are următoarele

GOUVPO „Universitatea de Stat de Telecomunicații și Informatică Regiunea Volga” Secțiunea 6. Software complexe de control. Sisteme de operare Lector: în timp real prof. Departamentul de Centrale Nucleare

Universitatea de Stat din Nijni Novgorod poartă numele. N.I Lobachevsky Facultatea de Matematică Computațională și Cibernetică Sisteme de operare: aspecte ale paralelismului Problema „Producători-Consumatori” Consumatorii.

„Sisteme de operare” Test. Exercita. Managementul proceselor. Aceasta este cea mai dificilă sarcină de explicat, dar voi încerca să explic astfel încât măcar ceva să fie clar. Deci, ni se oferă un tabel și un proces,

Cursul 22 Sortarea topologică. 22.1. Reprezentarea unui arbore arbitrar ca arbore binar. 22.1.1. Spre deosebire de un arbore binar, un arbore arbitrar nu poate fi gol (prin definiție trebuie

Ministerul Educației al Republicii Belarus Instituția de învățământ „Universitatea de Stat de Informatică și Radioelectronică din Belarus” Departamentul de calcul electronic D. S. Likhachev DEZVOLTARE

Lucrări de laborator 4 Scop: Lucrările de laborator sunt menite să dobândească experiență practică în crearea unei aplicații folosind limbajul de programare C++ pentru calcule matematice. numit:

Modulul 1. INFORMAȚII GENERALE DESPRE SISTEME DE OPERARE, MEDII ȘI MEDII 1. Un sistem de operare este 1) un set de programe de control și procesare 2) componente calculatoareși sisteme de calcul

PROGRAMARE SISTEM ÎN WINDOWS Pobegailo A.P. Programare sistem în Windows. Sankt Petersburg: BHV-Petersburg, 2006. - 1056 p.: ill. ISBN 5-94157-792-3 Problemele legate de programarea sistemului sunt tratate în detaliu

COMPILATOR: Ryaby V.V., lector superior la Departamentul de Suport Matematic al Calculatoarelor Electronice, Universitatea de Stat din Belarus; Pobegailo A.P., profesor asociat al Departamentului de Tehnologie

Synchronization Primitives 2011 Care este principala problemă cu metodele software de excludere reciprocă? Este imposibil să se garanteze continuitatea execuției acțiunilor individuale: Programul poate fi întrerupt în orice moment