Concurrency en race condities

Concurrency

Concurrente processen
Con-cur-rent adj. 1.occurring or existing at the same time
or side by side. 2. ....
(The RANDOM HOUSE college dictionary)
Concurrency betekent hier dat processen
gelijktijdig of naast elkaar actief zijn.
– Meerdere processen op een computer.
– Meerdere threads binnen een proces.
– Meerdere processen in een gedistribueerde
omgeving.
– Een over meerdere computers gedistribueerde taak.
College OS 2010 – 2011 2

Concurrente processen
• Concurrentie geeft noodzaak tot
– Communicatie
• Overdracht van informatie
– Synchronisatie
• Wachten op resultaat van een andere taak
– Coördinatie
• Toegang tot gedeelde resources
College OS 2010 – 2011 3

Niet-atomaire opdrachten
• Bij gelijktijdige benadering van een item door
twee taken/threads kunnen problemen
optreden.
• B.v. C-expressie: n++
• Pseudo-assembler:
mov rega, n # inhoud n naar register a
inc rega # increment op register a
mov n, rega # inhoud register a naar n
• Drie operaties. Een interrupt, dus een threadswitch
kan overal optreden.
• n++ is niet-atomair.
College OS 2010 – 2011 4

Mogelijke executie
• Tel aantal aanwezigen: n++ bij ingang,
n-- bij uitgang.
• Thread “in” OS Thread “uit”
mov rega, n (interrupt)
save rega
dispatch thread 2
mov rega, n
dec rega
mov n, rega
restore rega
dispatch thread 1
inc rega
mov n, rega
• Resultaat: n is één keer opgehoogd,
vertrekkende bezoeker is gemist.
College OS 2010 – 2011 5

Race condities
• Relatieve executie-snelheid van processen is
onbepaald.
• Fout kan optreden afhankelijk van toevallige
volgorde van uitvoering. Alleen kans nul op
een fout is acceptabel.
• We noemen dit “race conditie”
• Andere voorbeelden:
– wait + signal
– readers / writers
College OS 2010 – 2011 6

Kritieke sectie
• Bij toegang tot gemeenschappelijke
variabelen race conditie mogelijk.
• Deel van programma heet “kritieke sectie”
• Aantal taken in kritieke sectie moet beperkt:
– Toestemming nodig bij binnenkomst
– Afmelden
• Hoe?
– B.v. met JAVA synchronized methods - maar hoe
werken die?
College OS 2010 – 2011 7

Afzetten interrupts
• Voorkomt wisselen naar andere taak tijdens
kritieke sectie
• Maar
– Vertraagt afhandeling belangrijke interrupts
– Mag dus maar heel eventjes
– Taak mag nooit in deze kritieke sectie blijven
“hangen”
– Mag natuurlijk nooit door gebruiker
– Werkt niet voor SMP (Shared Memory
Multiprocessor), Dual- en Quad-cores
College OS 2010 – 2011 8

• Producent
while (1) {
}
produceer(&pdata);
while (beurt !=
Afscherming in software?
producent); /*wacht*/
buffer = pdata;
beurt = consument;
• Consument
while (1) {
while (beurt !=
consument); /*wacht*/
cdata = buffer;
beurt = producent;
gebruik(&cdata);
NB. Toekenning van een enkel bit/byte/woord kan wel atomair
(maar pas op met de cache!!)
Werkt hier wel, maar dwingt strikte afwisseling af.
Beslissing hangt niet alleen van wachtende processen af.
}
College OS 2010 – 2011 9

• Eén voor één toelaten
Eisen afscherming
• 100 % betrouwbaar (geen racecondities!)
• Geen “starvation”
– “Bounded waiting”: bovengrens aan wachttijd
• er mag maar een eindig aantal andere processen voor
gaan
– “Progress”: beslissing over toelating
• betreft alleen reeds wachtende processen
• wordt in eindige tijd genomen
• Oudste oplossing van Dekker
College OS 2010 – 2011 10

Poging 1
enum {false, true} nul_wil = false, een_wil = false;
• Thread 0
while (een_wil);
nul_wil = true;
/* kritieke sectie 0 */
nul_wil = false;
• Thread 1
Wat gaat er mis?
while (nul_wil);
een_wil = true;
/* kritieke sectie 1 */
een_wil = false;
College OS 2010 – 2011 11

Poging 2
enum {false, true} nul_wil = false, een_wil = false;
• Thread 0
nul_wil = true;
while (een_wil);
/* kritieke sectie 0 */
nul_wil = false;
• Thread 1
Wat gaat er nu mis?
een_wil = true;
while (nul_wil);
/* kritieke sectie 1 */
een_wil = false;
College OS 2010 – 2011 12

int beurt = 0;
• Thread 0
nul_wil = true;
beurt = 1;
while (een_wil &&
beurt == 1);
/* kritieke sectie 0 */
nul_wil = false;
Oplossing van Peterson
enum {false, true} nul_wil = false, een_wil = false;
• Thread 1
een_wil = true;
beurt = 0;
while (nul_wil &&
beurt == 0);
/* kritieke sectie 0 */
een_wil = false;
College OS 2010 – 2011 13

Afscherming voor N taken met arbiter
(Luuk Groenewegen)
enum KRITIEK {erin, eruit} IkWil[Nproc], JeMag[Nproc];
Client(int N)
{ while(1)
{ /* Niet kritiek */
IkWil[N] = erin;
wachtop(JeMag[N] == erin);
/* kritiek */
IkWil[N] = eruit;
wachtop(JeMag[N] ==
eruit);
}
}
Arbiter()
{ i = 0;
while(1)
{
if (IkWil[i] == erin)
{ JeMag[i] = erin;
wachtop(IkWil[i] ==
eruit);
JeMag[i] = eruit;
}
i = (i + 1) % Nproc;
}
}
College OS 2010 – 2011 14

Busy waiting
• Heet ook wel “spin lock”
• Taak test herhaald waarde van een variabele
– Gebruikt steeds CPU tijd
– Sluit misschien taak in kritieke sectie uit van CPU
– Probleem met name voor wachtende taak met hoge
prioriteit
• Voordeel op multi-processor: geen context
switches bij wachten op taak op andere
processor
College OS 2010 – 2011 15

Afscherming in software
• Peterson‟s en Dekker‟s algoritmen
Bakkerswinkel algoritme
(en veel meer, b.v. protocol van Eisenberg en
McGuire)
– Busy waiting, spin locks
– Lastig goed te krijgen
• Arbiter processen
– Busy waiting
– Extra proces, veel context switches
– Veel makkelijker
College OS 2010 – 2011 16

Ondersteuning vanuit het systeem
• Je wil twee functies hebben die
– Toegang tot de kritieke sectie verzorgen
– Met als argument - welke kritieke sectie
• Het systeem (het O.S. of de programmeertaal)
moet maar zorgen dat het goed gaat.
• Dus:
– enter_crit(section_id);
– leave_crit(section_id);
• Systeem gebruikt
– Software met spin-lock en/of
– Hardware ondersteuning
College OS 2010 – 2011 17

HW ondersteuning: Test-and-set instructie
Atomaire machine instructie (ook op SMP)
TAS address
– reserveert bus,
leest van address,
zet status bit voor nul/niet nul,
schrijft 1 naar address,
geeft bus vrij
– Werkt ook op shared-memory multi-processor
systemen
– Gebruik (pseudo-assembler):
try_address: TAS address
BNZ try_address # branch if not zero
critical section # if (*address == 0)
CLR address # clear address
College OS 2010 – 2011 18

• TAS mag in user code.
Test-and-set 2
• Maar is ook een “spin-lock”, dus o.a. problemen met
prioriteiten mogelijk.
• Combineer dan b.v. met uitzetten interrupts. Pseudocode:
while (TRUE) {
interrupts off;
if (not testAndSet(address)) break;
interrupts on; }
Critical section;
*address = 0;
interrupts on;
• Dan ook alleen kleine kritieke secties en vertrouwde
routines
College OS 2010 – 2011 19

Compare-and-swap
• TAS schrijft altijd - duur voor SMP cache
• Compare-and-swap instructie CS in de
instructieset IBM 370 en Motorola 68000.
(Boek Milenkovic)
– CS is een ondeelbare instructie (ook op een multiprocessor
kan ook een andere processor niet
tussendoor aan het geheugen zitten)
– “Optimistische” afscherming
• Ga kritieke sectie in
• Test net voor terugschrijven kritieke variabele
– Schrijft alleen bij succes
College OS 2010 – 2011 20

Werking CS instructie
– Globvar: variabele in geheugen
– Oldreg: kopie van “oude” Globvar in register.
– Newreg: nieuwe waarde voor Globvar in register.
Vergelijk Oldreg met Globvar
Zet de waarden in het Condition Code register
Als (Oldreg == Globvar)
dan Globvar = Newreg /* succes! */
anders Oldreg = Globvar /* opnieuw */
– Er is ook een variant die eerst twee waarden
vergelijkt (robuuster).
College OS 2010 – 2011 21

Event counters
• Object met unsigned integer waarde en 3 methoden:
unsigned int advance();
– Incrementeer waarde atomair en geef oude waarde terug
(combineert eigenlijk Event Counter en Sequencer)
unsigned int read();
– Geef waarde terug (kan inmiddels alweer verhoogd zijn)
unsigned int wait(unsigned int value);
– Blokkeer tot minimaal “value” is bereikt (kan inmiddels
alweer verhoogd zijn)
College OS 2010 – 2011 22

Gezamenlijk
Afscherming met event counter
EventCounter enter, leave; // start op 0
// Per proces/thread
unsigned int number;
number = enter.advance(); // vraag nummer
leave.wait(number); // tel vertrek
// Kritieke sectie
leave.advance(); // meld vertrek
College OS 2010 – 2011 23

Advance met Compare & Swap
• Pseudo-assembler:
Advance: mov reg1, counterValue
again: mov reg2, reg1
inc reg2
cs reg2, reg1, counterValue
bne again
push reg1 // returnwaarde
• Interrupts kunnen gewoon aan blijven
• Mag door user-code worden uitgevoerd
• Hoe zit het hier met prioriteiten?
College OS 2010 – 2011 24

Voor- en nadelen event counter
• “Wait” kan als system call zonder busy
waiting worden geïmplementeerd
• Voor afscherming kritieke sectie twee
counters nodig, plus hulpvariabele
• Waarde kan erg groot worden
College OS 2010 – 2011 25

Semaforen
• Semaforen zijn objecten met
– Een niet-negatieve, heeltallige waarde
– Twee methoden:
• P(sem) - indien waarde van sem > 0, verlaag waarde met 1
indien waarde == 0, blokkeer taak
• V(sem) - indien er geblokkeerde taken zijn, deblokkeer er één
anders, verhoog waarde met 1
– P heet ook wel: get_semaphore, take_semaphore, down, ….
– V heet ook wel: give_semaphore, up, ….
– NB. Je kan de waarde niet direct manipuleren
• Binaire semaforen: alleen waarden nul en één
– Een tweede V() verhoogt niet verder.
College OS 2010 – 2011 26

• Oplossing 1:
Semaforen voor afscherming
– Maak 1 semafoor aan “mutex”, beschikbaar voor
alle taken.
– Gebruik:
P(mutex);
/* Kritieke sectie */
V(mutex);
– Gevolg: veel nodeloos wachten.
College OS 2010 – 2011 27

Een te fijnmazige afscherming
• Bij elke gedeelde variabele een semafoor:
– Gebruik b.v. (A en B gedeeld)
P(sem_A);
temp = A;
P(sem_B);
A = B;
V(sem_A);
B = temp;
V(sem_B);
– Bewerkelijk; kans op deadlock
• Het beste: een semafoor voor een bij elkaar
horende groep variabelen.
College OS 2010 – 2011 28

• Taak afhankelijk van
andere.
• Precedentiegraaf:
Taak A
Taak B
Taak E
Synchronisatie
Taak C
Taak D
Taak F
TaakA(){ ... ; V(AB); V(AC);}
TaakB(){ P(AB); ... ; V(BD);
V(BE);}
TaakC(){ P(AC); ... ; V(CD);}
TaakD(){ P(BD); P(CD) ; ... ;
V(DF);}
TaakE(){ P(BE); ... ; V(EF);}
TaakF(){ P(EF); P(DF); ... ;}
College OS 2010 – 2011 29

Tellende semafoor - een toepassing
• Ringbuffer
• Producent vraagt een leeg
vakje en maakt dat vol
Producer() {
while (1) {
produce();
empty.P();
fill_buffer();
full.V();
}
}
• Werkt dit ook bij 4
producenten?
Producent
L
L
College OS 2010 – 2011 30
L
L
V
L V
V
V
Consument

Oplossing met meer producenten
• Producenten moeten
– het onderling eens zijn
over de te schrijven
buffer.
– op juiste volgorde
full.V() uitvoeren
(waarom)?
• Tellende, of algemene
semaforen:
– empty en full
• Binaire semafoor of
“mutex”:
– writing
Producer() {
}
while (1) {
}
produce();
empty.P();
writing.P();
fill_buffer();
writing.V();
full.V();
College OS 2010 – 2011 31

Maak een tellende semafoor met binaire
(oplossing is niet goed - waarom?)
class countingSemaphore
{
procedure Wait();
begin
mutex.WaitB();
s = s - 1;
if s < 0 then begin
mutex.SignalB();
delay.WaitB()
end
else
mutex.SignalB()
end;
procedure Signal();
begin
mutex.WaitB();
s = s + 1;
if s

Maak een tellende semafoor met binaire
(de goede oplossing - waarom?)
procedure Wait(var s
semaphore);
end;
begin
mutex.WaitB();
s = s - 1;
if s < 0 then begin
mutex.SignalB();
delay.WaitB()
end;
mutex.SignalB();
procedure Signal(var s
semaphore);
end;
begin
mutex.WaitB();
s = s + 1;
if s

Problemen met semaforen
• Programmeur blijft verantwoordelijk voor
correcte afscherming
– Kan die omzeilen
– Kan fouten maken
• Een taak die crasht in de kritieke sectie houdt
die bezet
• Wachten op twee of meer condities tegelijk is
lastig.
College OS 2010 – 2011 34

• Niet te omzeilen
Meer eisen aan afscherming
– Impliceert data-hiding
• Eenvoudig in het gebruik
– Gebruiker moet zich er nauwelijks van bewust zijn
College OS 2010 – 2011 35

“Monitors”
• Als taalelement o.a. in “Concurrent Pascal”
en in JAVA
• Als concept overal toepasbaar
• Een monitor is een module waarin niet meer
dan één taak tegelijk actief kan zijn
• Binnen een monitor ook condities of “events”
waarop kan worden gewacht
College OS 2010 – 2011 36

– Binnen een monitor
kan slechts één proces
tegelijk actief zijn
– Tijdelijk verlaten via
"wait(condition)"
– Weer terug na
"signal(condition)"
– Wat gebeurt er met
het proces dat "signal"
doet?
Met een plaatje
Uitgang
Toegang
Operaties
Events
één proces tegelijk
Data
Initialisatie
College OS 2010 – 2011 37

Bouw een semafoor met een monitor
monitor semafoor {
}
static unsigned int waarde = 0;
static condition V_called;
void P(){
}
if (waarde == 0) wait(V_called);
waarde--;
void V(){
}
waarde++;
signal(V_called);
College OS 2010 – 2011 38

monitor buffer {
static int full = 0;
static int empty = Nbuf;
static condition produced;
static condition consumed;
static int i_prod = 0;
static int i_cons = 0;
datum buf[Nbuf];
void get(datum *out){
}
if (full == 0)
wait(produced); ....
Bufferbeheer
}
void put(datum in){
}
if (empty == 0)
wait(consumed);
empty--; full++;
buf[i_prod] = in;
i_prod = (i_prod + 1) %
Nbuf;
signal(produced);
College OS 2010 – 2011 39

public class buffer {
int store[];
int filled;
int empty;
int readFrom;
int writeTo;
buffer (int size){
empty = size;
filled = 0;
store = new int[size];
readFrom = 0;
writeTo = 0;
}
En nu in Java
public synchronized void write(int value)
{
while (empty == 0){
try { wait(); }
catch(InterruptedException e) {
System.err.println(e.toString());
}
}
store[writeTo] = value;
writeTo++;
if (writeTo == (empty + filled))
writeTo = 0;
filled++;
empty--;
notifyAll();
}
College OS 2010 – 2011 40

Read in Java
public synchronized int read(){
int value;
while (filled == 0) {
try {
wait(); } catch(InterruptedException e) {
System.err.println(e.toString()); }
}
value = store[readFrom];
readFrom++;
if (readFrom == (empty + filled)) readFrom = 0;
filled--;
empty++;
notifyAll();
return value;
}
}
College OS 2010 – 2011 41

Semantiek wait/signal
• Als er geen taak wacht, gaat “signal” verloren.
• Keuze:
– signal bevrijdt 1 wachtende
– of bevrijdt alle wachtenden (NotifyAll() in Java).
• Na signal één taak tegelijk actief in monitor. Welke?
– Taak „S‟ die signal deed
• „Wait‟ conditie kan weer ongeldig worden.
– Taak „W‟ die wait deed
• Wat gebeurt er met taak „S‟; wanneer mag die weer?
Is de toestand dan nog juist voor hem?
– Veel gebruikt: signal alleen als laatste opdracht in
monitor.
• Is minder krachtig.
College OS 2010 – 2011 42

Readers/writers
• N lezers of één schrijver
• Lezers voorrang, of schrijvers, of afwisselen
• Afwisselen – keus in voorbeeld:
– Als er wordt gelezen en een schrijver wacht, laat
geen nieuwe lezers toe
– Als een schrijver klaar is, laat eerst alle wachtende
lezers toe
• Functies:
– startRead()
– endRead()
– startWrite()
– endWrite()
College OS 2010 – 2011 43

monitor ReadersAndWriters {
static int Readers = 0;
static int SomeoneIsWriting = 0;
static condition ReadingAllowed,
WritingAllowed;
startRead () {
if (SomeoneIsWriting ||
Readers++;
Readers/writers monitor
queue(WritingAllowed))
wait(ReadingAllowed);
signal(ReadingAllowed);
}
endRead () {
Readers--;
if (Readers == 0)
signal(WritingAllowed);
}
}
startWrite () {
}
if ((Readers > 0) ||
endWrite () {
}
SomeoneIsWriting)
wait(WritingAllowed);
SomeoneIsWriting = 1;
SomeoneIsWriting = 0;
if (queue(ReadingAllowed))
signal(ReadingAllowed);
else
signal(WritingAllowed);
College OS 2010 – 2011 44

Readers/writers met semaforen
startRead() endRead() startWrite()
{ { {
}
down(reader); down(mutex); down(reader);
down(mutex); readers--; down(writer);
if (readers == 0) if (readers == 0) }
{ {
down(writer); up(writer); endWrite()
} } {
readers++; up(mutex); up(writer);
up(reader); } up(reader);
up(mutex); }
Kijk goed hoe het werkt. Wie krijgt voorrang? Wat verandert er als ik de eerste twee down()
statements in startRead() omwissel? En in startWrite()?
College OS 2010 – 2011 45

Conclusie
Monitors
• Toegang strikt beperkt tot één taak
– B.v. niet zo geschikt voor readers/writers
• Nette, modulaire structuur
– Wel neiging om een beetje veel af te schermen
– Niet erg flexibel toepasbaar
• Geschikt voor shared-memory multiprocessoren
– Niet zondermeer voor netwerken
College OS 2010 – 2011 46

Inter-proces communicatie
IPC

Uitwisseling van informatie
• Alle mechanismen tot nu toe voor shared
memory
– bruikbaar voor afscherming en synchronisatie
– informatie-uitwisseling via shared memory
• Informatie-uitwisseling met boodschappen
– send(&message, to_desitination)
– receive(&message, from_sender)
• Wat zijn de eigenschappen van send en
receive?
College OS 2010 – 2011 48

• Synchroon:
Synchroon / asynchroon
– Ontvanger en afzender blokkeren totdat boodschap
is uitgewisseld.
• Asynchoon: alle andere mogelijkheden, b.v.
– Gebufferd of
– Non-blocking
College OS 2010 – 2011 49

Gebufferde communicatie
• Afzender plaatst boodschap in buffer en gaat
meteen door
• Ontvanger wacht tot er een boodschap is
• Eén, meerdere of onbeperkt veel buffers
• Bij volle buffers
– foutmelding aan afzender en oudste of nieuwste
boodschap verloren, of
– afzender blokkeert tot er een buffer vrij komt
• Kost extra kopieerslag(en)
College OS 2010 – 2011 50

Non-blocking
• Afzender verzoekt systeem boodschap te versturen
– systeem neemt adres boodschap over
– afzender kan meteen verder
• maar mag niet aan boodschap zitten
– systeem zorgt voor verzending
– systeem meldt als boodschap is overgenomen
• signaal of
• “polling”
• Ontvangst gaat analoog
• Blocking receive kan bij non-blocking send en v.v.
• Non-blocking kan ook gebufferd
College OS 2010 – 2011 51

UNIX read/write
• int read(int fd, void *buf, size_t nbyte)
– geeft feitelijk gelezen aantal bytes terug
– leest in principe nbyte bytes, maar kan o.a. van een
socket of pipe of bij EOF ook minder teruggeven
– O_NDELAY en O_NONBLOCK staan ook toe dat 0
bytes worden gelezen
• int write(int fd, void *buf, size_t nbyte)
– geeft feitelijk geschreven aantal bytes terug
– schrijft in principe nbyte bytes
– O_NDELAY en O_NONBLOCK staan ook toe dat er
minder worden geschreven
• Zie man pages…...
College OS 2010 – 2011 52

Adressering
• Adres tegenpartij moet bekend zijn
– verbinding is eerder opgezet
• B.v. UNIX pipe
– “well-known address”
• B.v. adres van ftp server op een bepaalde machine
– door bemiddeling verkregen adres
• B.v. een in een http document gevonden e-mail adres
• Bemiddelaar heeft i.h.a. een well-known address
– verbinding bekend, tegenpartij niet
• B.v. mailbox
– beperkte broadcast
• B.v. gebruikt op LAN
College OS 2010 – 2011 53

Synchroon
Asynchroon
Een heel onvolledige indeling
Afzender specificeert ontvanger
Wel Niet
Ontvanger specificeert
afzender
Wel Niet
Handen
schudden
Telefoon
Ontvanger specificeert
afzender
Wel Niet
UNIX pipe Brief WWW pagina Brief in fles
e-mail
Radio
Sommige
vergaderingen
Reclame
drukwerk
College OS 2010 – 2011 54

UNIX pipe
• Verbinding tussen ouder en kind
– Of tussen verdere verwanten op een machine
• Nodig: twee integer file descriptors: int f_id[2];
• Ouder roept eerst “pipe(f_id)” aan
– Krijgt 2 file-ids terug (SUN Solaris). Wat wordt
geschreven naar de een, kan worden gelezen uit de
ander.
• Ouder roept vervolgens “fork()” aan.
– Ouder leest / schrijft b.v. f_id[0]
– Kind leest / schrijft dan f_id[1]
– Een bi-directionele verbinding!
• Ouder en kind kunnen hun kant weer doorgeven
College OS 2010 – 2011 55

F_id[0]
F_id[1]
Na pipe()
Solaris pipes
F_id[0]
F_id[1]
Na fork()
F_id[1]
F_id[0]
F_id[0] F_id[1]
Na close()
College OS 2010 – 2011 56

LINUX en Posix
• De pipe() functie werkt hetzelfde, maar de
verbinding is uni-directioneel
– Lezen uit f_id[0],
– Schrijven naar f_id[1];
• Voor een bi-directionele verbinding zijn dus
twee aanroepen nodig.
• Socketpair(PF_UNIX, SOCK_STREAM, 0, f_id)
– werkt bijna hetzelfde als de Solaris pipe() functie
College OS 2010 – 2011 57

F_id[0]
F_id[1]
Na pipe()
LINUX en POSIX pipes
F_id[0]
F_id[1]
Na fork()
F_id[1]
F_id[0]
F_id[0] F_id[1]
Na close()
College OS 2010 – 2011 58

UNIX shells en pipes
sh> ls * | grep o1 | less
shell maakt pipe aan: f_id[0] en f_id[1]
shell forkt kind1 af
kind1 verbindt stdout met f_id[1], sluit f_id[0]
kind1 start ls
shell sluit f_id[1]; maakt pipe aan: f_id[2] en f_id[3]
shell forkt kind2 af
kind2 verbindt stdin met f_id[0], stdout met f_id[3], sluit
f_id[2]
kind2 start grep
shell sluit f_id[0], f_id[3]; forkt kind3 af
kind3 verbindt stdin met f_id[2]
kind3 start less
shell sluit f_id[2], wacht
College OS 2010 – 2011 59

Internet sockets
• Socket: een eindpunt voor communicatie
• Opzet asymmetrisch: server en cliënt
• Server maakt socket aan; bindt deze aan poortnummer
en protocol (TCP of UDP).
– Volledig adres: machine-adres + poortnummer
– Well-known adresses: zie /etc/services
• Client maakt socket aan; zoekt verbinding met poort
op machine.
• Bij succes:
– Server krijgt nieuwe file-id voor verbinding met deze
cliënt
– Poort + machine beschikbaar voor volgend contact
– Gebruik TCP socket verder als bij pipe
College OS 2010 – 2011 60

node nr. 146.50.7.64
server process
socket()
bind()
s0
s0
Internet sockets in een plaatje
port 2345
s
node nr. 146.50.5.23
client process
socket()
listen()
loop: {
}
....
accept()
....
s0
s0
s1
s0
s0 s2
port 2345
port 2345
port 2345
connect()
College OS 2010 – 2011 61
s
s
s
s

Sockets, vervolg
• Met UDP is ook een datagram service
mogelijk, adressering per pakket
• Met elke socket verbinding is een
poortnummer geassocieerd, meestal
automatisch toegewezen
College OS 2010 – 2011 62

Van asynchroon naar synchroon en v.v.
Partij A
Send(&message, destination)
Receive(&ack, destination)
Partij B
Receive(&message, sender)
Send(&ack, sender)
• Maar B weet niet of bevestiging bij A is aangekomen.
• Voor synchroon naar asynchroon is een derde partij
nodig die als buffer kan optreden + nog wat speciale
voorzieningen.
College OS 2010 – 2011 63

Gebruik message passing
• Overdracht informatie: duidelijk
• Synchronisatie: duidelijk
• Afscherming gegevens en resources:
– Gebruik server proces dat gegevens en/of
resources beheert.
– Cliënten sturen verzoek aan server, die operaties
voor hun uitvoert en resultaat terugstuurt.
• Cliënt/server systemen algemeen:
– B.v. file server, print server
– Servers vaak “multi-threaded”
• Echte gedistribueerde systemen worden
mogelijk
College OS 2010 – 2011 64

Hoofd thread:
• ontvang verzoek
• start service thread
Multi-threaded server
– geef verzoek aan service
thread
• ga terug naar “ontvang
verzoek”
Service thread
• handel verzoek af
• communiceer resultaat
met cliënt
• beëindig thread
• Zo hoeft een volgende service-aanvraag niet op
afhandeling vorige te wachten.
• Aanmaken threads is goedkoop.
• Threads synchroniseren onderling met semaforen of
monitors..
College OS 2010 – 2011 65

Cliënt proces
procedure aanroep
De remote procedure call
“Marshalling”
Server proces
Call-back routine
Stub routine
Server stub
Pak data in/uit
Pak data in/uit
Send Receive Send Receive
• Oversturen data niet triviaal:
– Formaat conversie bij eenvoudige types
– Verschillen in bereik
– Pointers niet meer geldig - problemen met
bomen etc.
College OS 2010 – 2011 66

Marshalling Problemen
• Data formaten:
– Big-endian vs. little-endian
– Char, int, float representatieverschillen
• Verschillen in bereik
– Alignment eisen bij structs
• Bouw een struct b.v. als
struct PORTABLE {
double a;
long l;
short s, dummy;
char c[3], filler[5]; }
– Pointers hebben op de andere machine geen
betekenis
• Serialiseer bomen e.d.
College OS 2010 – 2011 67

Message passing fouten
• Failures:
(Voor alle message passing technieken, maar
a fortiori voor RPC omdat die transparant
zouden moeten zijn)
– Kan server niet vinden
– Verloren boodschappen:
• Request boodschap
• Reply
– Server crash na ontvangst request
– Cliënt crash na versturen request
College OS 2010 – 2011 68

• Hardware:
Gedistribueerde systemen
– “Losse” nodes verbonden door een netwerk
• Lokaal … wereldwijd
– Mogelijk inhomogeen
– Nodes kunnen shared-memory systemen zijn
• Software
– Een gedistribueerd OS
• B.v. Amoeba
– Verschillende OS met “homogenisatie laag”
• B.v. Java, PVM
College OS 2010 – 2011 69

Structuur van het O.S.
• Een paar O.S. taken liggen onder alle processen
– Met name dat deel dat process-switching verzorgt
• Of, de rest van het O.S. draait
– Geheel als aparte kernel. Niet als proces.
– In kernel mode als onderdeel van elk proces (o.a. UNIX).
– Als een aantal aparte processen
• UNIX:
Proces 1
O.S.
Functies
Proces 2
O.S.
Functies
Proces 3
O.S.
Functies
Process switching code
Proces 4
O.S.
Functies
User mode
Kernel mode
College OS 2010 – 2011 70

Microkernel
• Amoeba (Tanenbaum) heeft microkernel structuur
– Microkernel ondersteunt
User
process
• Process switching
• Interprocess communication (IPC) op basis van RPC
• Distributie
User
process
M.M.
process
User
process
File
server
process
Microkernel Microkernel
M.M.
process
College OS 2010 – 2011 71