Piet van Oostrum 18 april 2002 Wat is een proces? Een

Processen
CSN
– CS4 –
Processen en Threads
Wat is een proces?
I Een onafhankelijke activatie van een programma
I Kan afzonderlijk gestart/gestopt worden
I Heeft eigen resources (vb. geheugen)
Piet van Oostrum
I Heeft een eigen “leven” zolang het actief is
I Kan met het O.S. en andere processen communiceren
18 april 2002
I Bescherming tegen andere processen
Waarom?
I Administratieve eenheid - kan gemakkelijk verwijderd worden (resources)
I Concurrency
CSN-CS4
1
CSN-CS4
1
CPU allocatie
Scheduling
I Meestal zijn er meer processen dan processors
I Scheduling = het mechanisme waarbij het O.S. kiest wanneer een ander
proces de CPU krijgt, en welk proces dat moet zijn.
I Dus de processen moeten de CPU(s) delen
I Ieder proces krijgt een “virtuele” processor (eigen registers e.d.)
I Het O.S. wisselt de echte CPU(s) tussen de virtuele CPU’s (scheduling)
I Processen kunnen verschillende prioriteiten hebben
I Scheduler = het deel van het O.S. dat dit doet
I Preemptive scheduling = Het O.S. kan de CPU van een proces afpakken,
zonder dat dit proces daarvoor toestemming hoeft te geven
I Non-preemptive of Cooperative scheduling = Het O.S. kan de CPU alleen aan
een ander proces geven op de tijdstippen dat het draaiende proces aangeeft.
Een proces kan dan het hele systeem ophangen.
I Timeslice Bij preemptive scheduling krijgt een proces meestal een maximum
tijd (timeslice) toegewezen. Als het proces deze opmaakt, wordt geschedulet.
(via klokinterrupt)
CSN-CS4
2
CSN-CS4
Scheduling 2
3
Scheduling en interrupts
I Vb. Win16 en Mac OS9: Er wordt alleen gescheduled als er een
systeemaanroep plaatsvindt.
(Maar een DOS-box wordt preemptive gescheduled)
I Win32: 16-bits processen als Win16, 32-bits processen preemptive
WACHT
proces A
WACHT
proces B
?
I Unix: Preemptive in user mode, non-preemptive in de kernel
I Context switch = het omschakelen van de context van het ene proces naar het
andere
I Context = alles wat in het O.S. of de hardware specifiek is voor een proces
Registerinhouden
Stack
page tables
O.S. administratie
apparaat A
interrupt A
apparaat B
interrupt B
CSN-CS4
4
CSN-CS4
slides4.pdf — April 18, 2002 — 1
?
5
Scheduler
Scheduling Algoritmes
I Prioriteiten kunnen toegekend worden op basis van soort programma
(multimedia, achtergrond, . . . )
runnable
low priority
runnable
time slice op
medium priority
time slice op
start
I Prioriteiten kunnen dynamisch aangepast worden:
scheduler
I Meestal worden rekenintensieve (CPU-bound) processen op lagere prioriteit
gezet dan processen die veel I/O doen (I/O-bound).
scheduler
runnable
running
high priority
I Interactieve processen nog hoger (systeem “voelt lekker aan”).
scheduler
I Methode: Als een proces zijn timeslice opmaakt krijgt hij een lagere prioriteit
wakeup()
WAIT()
exit
error
I Als een proces wacht op I/O krijgt hij een hogere prioriteit
I Als het wachten op gebruiker (toetsenbord/muis) is, dan nog hoger
zombie
stopped
blocked
I Lagere prioriteits processen krijgen grotere timeslices
I Soms worden prioriteiten langzaam opgehoogd
CSN-CS4
6
CSN-CS4
7
Real-time scheduling
Real-time scheduling
I Real-time = werk dat gebonden is aan de echte tijd.
I Het moet mogelijk zijn aan te geven dat vóór een bepaalde tijd een
gedefinieerde taak afgehandeld moet zijn.
I bijv. het afspelen van geluid en video.
I of: het besturen van een vliegtuig of chemische installatie
I Real-time processen moeten absolute voorrang krijgen boven niet real-time
I Bijv. door extra hoge prioriteiten
I Een proces moet kunnen aangeven dat op een bepaalde tijd hij de CPU moet
hebben (of een ander aan te wijzen proces)
I Dit moet ook goed gaan als er meerdere real-time processen zijn.
I Scheduling op deadline of slack time.
deadline = de tijd dat een proces klaar moet zijn.
Scheduler kiest het proces dat de vroegste deadline heeft.
slack time = de tijd waarmee je een proces nog uit kan stellen voor het te
laat is.
Scheduler kiest het proces met de kleinste slack time.
I De scheduler moet garanderen dat op de gevraagde tijd het proces de CPU
krijgt
I De meeste “gewone” operating systems zijn niet goed voor real-time
CSN-CS4
CSN-CS4
8
I bijv. Unix kan te lang in de kernel bezig zijn.
9
Proces Management
Wachten in Win32
I Proces starten
I Wacht tot het kind-proces klaar is:
WaitForSingleObject(process_handle)
I Proces stoppen
I WaitForSingleObject() is een algemene systeemaanroep die ook voor
andere wachtobjecten gebruikt wordt.
I Wacht tot een ander proces klaar is
I Proces onderbreken (tijdelijk)
I Vb. File handles (asynchrone I/O), process handles (wacht tot proces klaar is).
Win32 proces starten:
I WaitForMultipleObjects() kan gebruikt worden om op meer objecten te
wachten. Naar keuze op één of alle.
I CreateProcess (10 parameters, o.a. programma-file)
I Geeft o.a. een process handle terug in STARTUPINFO datastructuur
(9e parameter)
I via de process handle kan het ouder-proces op kind-proces wachten of het
“killen”
CSN-CS4
10
CSN-CS4
slides4.pdf — April 18, 2002 — 2
11
Unix process management
Copy-on-Write
I Unix proces creatie en programma-executie zijn gescheiden!!
I Het O.S. maakt niet echt een kopie van de data
I fork() aanroep: creëert een nieuw proces
I De data pagina’s worden gemarkeerd als read-only
I kindproces is een kloon van ouderproces
I Wanneer één van de processen in een pagina iets verandert, wordt er een kopie
voor dit proces gemaakt, en beide pagina’s worden op read/write gezet
I Instructies kunnen geshared worden (memory management)
I Data (stack/heap): ieder proces eigen kopie
I voordeel: zowel de snelheid als de flexibiliteit.
I Nadeel: Bij een groot datadeel veel kopiewerk
I en: misschien wordt het direct weggegooid
CSN-CS4
12
CSN-CS4
13
Unix fork voorbeeld
Unix exec
pid = fork();
I exec (programmafile, arg0, arg1, ...)
if (pid == 0) {
/* hier zijn we in het kind proces ...
do whatever you want to do
*/
}
else if (pid == -1) {
/* error (niet genoeg geheugen of
teveel processen of zo)
probeer het later nog eens
*/
}
else {
/* hier zijn we in het ouder proces
pid is nu de ‘‘proces id’’ van het kind
*/
}
I In het lopende proces wordt het hele virtuele geheugen vervangen door het
nieuw opgestarte programma uit programmafile.
I Alle data dat het proces had wordt vergeten
I Open files, permissies e.d. kunnen wel overgeerfd worden.
I Het procesnummer (pid) blijft hetzelfde.
I arg0, arg1, ... zijn de “command line argumenten”.
I Er zijn verwchillende vormen van deze aanroep, waarbij de argumenten op
verschillende manieren kunnen worden meegegeven.
I Exec wordt vaak in de kind-tak van een fork gedaan
CSN-CS4
14
Unix fork en exec
CSN-CS4
15
fork – exec – wait
pid = fork();
ouder proces
kind proces
fork
if (pid == 0) {
/* kind, start ander programma */
exec
kind proces
fork
exec (....);
exec
}
else {
/* ouder proces,
wacht tot kind klaar is */
wait
exit
exit
waitpid (pid, ...)
kind wordt zombie
}
wait
CSN-CS4
16
CSN-CS4
slides4.pdf — April 18, 2002 — 3
17
Vormen van concurrency
Proces vs. thread
Proces
I Interrupts: device driver loopt tegelijk met
andere device drivers
andere OS instructies
processen
I Heeft resources (geheugen, open files, permissies, etc.)
I Wordt als één geheel gestart en gestopt (bijv. bij fout)
Thread
I Processen: proces loopt tegelijk met andere processen
I Binnen een proces: Threads
Threads zijn “mini-procesjes” binnen een gewoon proces
Ook wel lightweight process genoemd
Kunnen door OS of door het proces zelf geregeld worden
Multithreaded proces
I Is eenheid voor de scheduling
I Heeft eigen machine-registers (o.a. PC)
I Heeft eigen stack (binnen virtueel geheugen van proces)
I Heeft toegang tot alle resources van het proces
I Kan variabelen van andere threads benaderen
CSN-CS4
18
CSN-CS4
Thread Management
19
Threads in O.S.
Wie beheert de threads?
1. Het O.S
Het O.S. kent het begrip “thread”
Starten, stoppen, synchroniseren van threads via system calls
De scheduler schedulet threads, niet processen
2. Het proces zelf (“run-time systeem”)
Het O.S. weet niets over threads
Het proces zelf heeft een thread scheduler (o.a. m.b.v. timers)
Kan op elk systeem geimplementeerd worden
Vb. netscape, java op win16 en Unix.
I Het O.S. kent twee datastructuren: thread en proces
I Een proces heeft één of meer threads (hoofdcode geldt ook als thread)
Voordelen
I Als een thread niet verder kan, kan het O.S. een andere thread schedulen.
I Threads kunnen concurreren met andere threads in hetzelfde of andere
processen
I bij een multiprocessor systeem kunnen meerdere threads tegelijk actief zijn
(vb. Windows NT)
Nadeel
I Thread management kost meer tijd (system call)
CSN-CS4
20
CSN-CS4
21
Threads in runtime systeem
Multithreading problemen
I Het O.S. weet niks over threads
I Globale systeemvariabelen moeten een per-thread kopie hebben
I Thread management gebeurt binnen het proces mbv bibliotheekfuncties
I vb. Unix system calls leveren foutcode af in de variabele errno
Voordelen
fid = fopen ("filenaam", ...);
I Kan in elk O.S. gebruikt worden
I Is efficiënt (weinig extra tijd nodig)
I Speciale code nodig om blokkerende system calls te behandelen bijv. met
asynchrone I/O
Nadelen
I O.S. scheduler kan er geen rekening mee houden
I Als één thread blokkeert, zijn alle threads geblokkeerd
/* mogelijk probleempunt */
if (fid < 0) {
/* error -- errno = foutcode */
}
nbytes = read (fid, buffer, bufsize);
/* mogelijk probleempunt */
if (nbytes < 0) {
/* error -- errno = foutcode */
}
I Geen multiprocessor ondersteuning
CSN-CS4
22
CSN-CS4
slides4.pdf — April 18, 2002 — 4
23
Reentrant library
Voorbeelden
I Bibliotheekfuncties moeten geen globale variabelen gebruiken (static alleen
read-only)
Netscape
I Per HTML document of plaatje een aparte thread
I Een functie heet reentrant als hij op ieder willekeurig punt onderbroken kan
worden en een nieuwe “kopie” opgestart zodat ze elkaar niet in de weg zitten
I Document wordt opgebouwd terwijl andere threads wachten op netwerk
verkeer
I Eventueel per-thread data.
I Gezamenlijke window → synchronisatie nodig
I Wanneer globale data essentieel zijn, dan moeten wijzigen erop beschermd zijn
(synchronised):
I Gezamenlijke cache voor eerder opgehaalde documenten en plaatjes →
synchronisatie nodig
mutex_lock (semafoor);
...
/* wijzigingen op globale datastructuur */
...
mutex_unlock (semafoor)
Tekenprogramma
I Aparte thread voor het tekenen op het scherm
I Aparte thread voor user interface
I lock en unlock operaties moeten samenwerken met de thread scheduler.
CSN-CS4
24
I Aparte threads voor ingewikkelde berekeningen
CSN-CS4
Multithreaded server
hoofd thread
I Hoofd-thread wacht
quests” van clienten
thread per request
start thread
request
“re-
I Per request wordt een thread gestart
wacht
op
volgende
request
I Hoofd-thread wacht intussen op
nieuwe requests
I request-threads kunnen wachten
op I/O en blokkeren niet de hele server
I Gemeenschappelijke datastructuur (bijv. database) mogelijk.
reply
CSN-CS4
op
26
slides4.pdf — April 18, 2002 — 5
25