Procesul ușor ( în engleză light-weight process , LWP) este un mijloc de realizare a sarcinilor multiple într-un sistem de operare pentru computer, în sensul tradițional al termenului. Pe Unix System V și Solaris , un proces ușor rulează în spațiul utilizatorului peste un singur fir de execuție al nucleului , partajând spațiul de adrese virtuale și resursele sistemului de fire cu alte procese ușoare din același proces. Firele multiple la nivel de utilizator gestionate de biblioteca de fire pot fi găzduite în unul sau mai multe procese ușoare, permițând multitasking la nivel de utilizator, care poate avea unele beneficii de performanță [1] .
Unele sisteme de operare nu au un strat separat de procese ușoare între firele nucleului și firele utilizator. Aceasta înseamnă că firele de execuție ale utilizatorului sunt implementate direct de firele nucleului. În astfel de cazuri, termenul „proces ușor” înseamnă de obicei un fir de nucleu, iar termenul „proces” poate însemna un fir de execuție. În nucleul Linux , firele de execuție ale utilizatorului sunt implementate pentru a permite anumitor procese să partajeze resurse, permițând uneori aplicarea termenului „procese ușoare” acestor fire [2] . În mod similar, în SunOS versiunea 4 (predecesorul Solaris ), firele de execuție ale utilizatorului au fost numite procese ușoare [1] .
Firele nucleului sunt gestionate în întregime în nucleu. Ele nu trebuie să fie asociate cu un proces, nucleul le poate crea atunci când este necesar pentru a efectua o anumită sarcină. Firele de nucleu nu pot rula în modul utilizator. Procesele ușoare (pe sistemele în care sunt un strat separat) se asociază cu firele nucleului și oferă context la nivel de utilizator. Aceasta include o referire la resursele partajate ale procesului căruia îi aparține procesul ușor. Când un proces ușor este suspendat, conținutul registrelor la nivel de utilizator trebuie să fie stocat până când este reluat, iar firul principal de nucleu trebuie să stocheze și propriile registre la nivel de kernel.
[ clarifica ]
Crearea unui proces ușor este mai costisitoare și durează mai mult decât un thread de utilizator. Când se creează un proces ușor , se face mai întâi un apel de sistem pentru a crea firul de nucleu corespunzător.[ clarifica ] , adică se realizează o comutare la modul kernel. Aceste comutatoare de mod implică de obicei copiarea parametrilor între nucleu și spațiul utilizatorului, iar nucleul ia de obicei pași suplimentari pentru a verifica dacă parametrii sunt corecti. O comutare de context între procesele ușoare necesită o salvare preventivă a registrelor, apoi o tranziție la modul kernel, unde apoi salvează registrele firului de nucleu și, după ce se face toată programarea necesară a procesului ușor, valorile registrului corespunzătoare \u200b sunt restaurate în modul kernel și în modul utilizator. [unu]
Din acest motiv, unele biblioteci la nivel de utilizator sunt implementate pentru a crea mai multe fire la nivel de utilizator pe deasupra unui proces ușor. Firele de utilizare pot fi create, distruse, sincronizate și comutate între ele în întregime în spațiul utilizatorului, fără a fi nevoie de apeluri de sistem sau tranziții în modul kernel. Acest lucru oferă o îmbunătățire semnificativă a performanței în timpul creării firelor și comutărilor de context. [1] Cu toate acestea, există dificultăți în implementarea unui planificator de fire la nivel de utilizator care funcționează bine cu nucleul.
În timp ce biblioteca utilizatorului este ocupată cu planificarea firelor de execuție ale utilizatorului, nucleul este ocupat cu planificarea proceselor ușoare subiacente. Fără coordonare între nucleu și biblioteca de streaming, nucleul poate lua decizii de programare suboptime. De asemenea, poate duce la un [Deadlock|Deadlock] în care firele de execuție ale utilizatorului răspândite în mai multe procese ușoare încearcă să obțină aceleași resurse fiind folosite de un alt fir de execuție care nu rulează în prezent. [unu]
O soluție la această problemă este activarea programatorului. Aceasta este o metodă de coordonare a nucleului și a bibliotecii de fire. Nucleul notifică programatorul bibliotecii de fire de execuție cu privire la anumite evenimente (cum ar fi când un fir de execuție este programat să se blocheze), iar biblioteca de fire de execuție poate decide ce să facă. Acest apel de notificare de la kernel se numește „upcall”.
Biblioteca la nivel de utilizator nu are control asupra mecanismului de nivel superior, primește doar notificări de la kernel și programează firele de execuție ale utilizatorului pe procesele ușoare existente, nu pe procesoare. Programatorul nucleului decide cum să programeze procese ușoare pe procesoare. Aceasta înseamnă că procesele ușoare sunt reprezentate în biblioteca de fire ca „procesoare virtuale” [3] .
Solaris a implementat un strat de proces ușor separat de la versiunea 2.2. Înainte de versiunea 9, Solaris a furnizat un raport multi-la-multe dintre procese ușoare și fire de execuție ale utilizatorului. Cu toate acestea, acest lucru a fost depreciat din cauza complexității pe care a provocat-o, ceea ce îmbunătățește și performanța programatorului de nucleu [1] .
UNIX System V și derivatele sale moderne, cum ar fi IRIX , SCO OpenServer , HP-UX și IBM AIX oferă mapări de la mulți la mulți dintre firele de execuție ale utilizatorului și procesele ușoare [3] [4] .