Computerarchitectuur en netwerken. InterProcess Communication (IPC)

Transcriptie

1 Computerarchitectuur en netwerken 5 InterProcess Communication (IPC) Lennart Herlaar 21 september 2016

2 Inhoud Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection file locking pipes Message passing Via het geheugen (shared memory) Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 1

3 Inter Process Communicatie Hoe kunnen processen met elkaar communiceren? Lennart Herlaar Computerarchitectuur en netwerken 5 2

4 Inter Process Communicatie Hoe kunnen processen met elkaar communiceren? Files: één proces schrijft data in een file, ander proces leest het eruit. Probleem: synchronisatie: hoe weet het ontvangende proces dat er iets nieuws in de file staat? Lennart Herlaar Computerarchitectuur en netwerken 5 2

5 Inter Process Communicatie Hoe kunnen processen met elkaar communiceren? Files: één proces schrijft data in een file, ander proces leest het eruit. Probleem: synchronisatie: hoe weet het ontvangende proces dat er iets nieuws in de file staat? Pipe: een file-achtig object dat echter niet op de schijf staat (pijpleiding). Een pipe heeft een schrijf-einde en een lees-einde Het producerende proces schrijft data in het schrijf-einde Het consumerende proces leest de data uit het lees-einde Lennart Herlaar Computerarchitectuur en netwerken 5 2

6 Inter Process Communicatie Hoe kunnen processen met elkaar communiceren? Files: één proces schrijft data in een file, ander proces leest het eruit. Probleem: synchronisatie: hoe weet het ontvangende proces dat er iets nieuws in de file staat? Pipe: een file-achtig object dat echter niet op de schijf staat (pijpleiding). Een pipe heeft een schrijf-einde en een lees-einde Het producerende proces schrijft data in het schrijf-einde Het consumerende proces leest de data uit het lees-einde Message passing: boodschapjes sturen Shared memory: gemeenschappelijk geheugen gebruiken Lennart Herlaar Computerarchitectuur en netwerken 5 2

7 File Sharing Filehandles (filedescriptors) kunnen geërfd worden door een kind-proces. ouder-proces opent een file ouder-proces creërt kind-proces kind-proces erft de filedescriptor beide processen kunnen nu de file lezen/schrijven fd = open("filenaam",...); pid = fork(); switch (pid) { case 0: /* kind proces */ write (fd,...); case -1: /* fout */ default: /* ouder */ write (fd,...); } Wat kun je zeggen over de inhoud van de file? Lennart Herlaar Computerarchitectuur en netwerken 5 3

8 O.S. Datastructuren 0 1 proces A 0 1 proces B open files file positie file positie open files file 1 file 2 file1: gemeenschappelijke file-pointer Lezen en schrijven van proces A en B achter elkaar in de file Contrast: wanneer A en B ieder afzonderlijk dezelfde file openen hebben ze elk een eigen file pointer. Lennart Herlaar Computerarchitectuur en netwerken 5 4

9 Inhoud Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection = file locking pipes Message passing Via het geheugen (shared memory) Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 5

10 I/O redirection 1 Scenario: Een ouderproces wil dat het kindproces van een bepaalde file leest Of wil dat het kindproces naar een bepaalde file schrijft Vraag: wie opent die file: ouder of kind? Als ouder het doet: kind moet de open file erven. Als kind het doet: ouder moet de filenaam meegeven aan het kind Zie 5.2 in het dictaat Lennart Herlaar Computerarchitectuur en netwerken 5 6

11 I/O redirection 2 In Unix en Windows console programma s hebben processen drie bijzondere file descriptors: standaard invoer (0): hiervan leest het proces = normaal het toetsenbord Lennart Herlaar Computerarchitectuur en netwerken 5 7

12 I/O redirection 2 In Unix en Windows console programma s hebben processen drie bijzondere file descriptors: standaard invoer (0): hiervan leest het proces = normaal het toetsenbord standaard uitvoer (1); hiernaar schrijft het proces = normaal het beeldscherm Lennart Herlaar Computerarchitectuur en netwerken 5 7

13 I/O redirection 2 In Unix en Windows console programma s hebben processen drie bijzondere file descriptors: standaard invoer (0): hiervan leest het proces = normaal het toetsenbord standaard uitvoer (1); hiernaar schrijft het proces = normaal het beeldscherm Er is nog een derde: standaard error (2) voor foutmeldingen Deze worden normaliter geërfd door kindprocessen Lennart Herlaar Computerarchitectuur en netwerken 5 7

14 I/O redirection 2 In Unix en Windows console programma s hebben processen drie bijzondere file descriptors: standaard invoer (0): hiervan leest het proces = normaal het toetsenbord standaard uitvoer (1); hiernaar schrijft het proces = normaal het beeldscherm Er is nog een derde: standaard error (2) voor foutmeldingen Deze worden normaliter geërfd door kindprocessen standaard invoer proces standaard error standaard uitvoer Lennart Herlaar Computerarchitectuur en netwerken 5 7

15 I/O redirection 3 We doen het volgende in een textuele shell: (ls op Unix of DIR in Windows geven een lijst van je files) ls > file of DIR > file Schrijft naar file in plaats van beeldscherm Lennart Herlaar Computerarchitectuur en netwerken 5 8

16 I/O redirection 3 We doen het volgende in een textuele shell: (ls op Unix of DIR in Windows geven een lijst van je files) ls > file of DIR > file Schrijft naar file in plaats van beeldscherm proces file Lennart Herlaar Computerarchitectuur en netwerken 5 8

17 I/O redirection 3 We doen het volgende in een textuele shell: (ls op Unix of DIR in Windows geven een lijst van je files) ls > file of DIR > file Schrijft naar file in plaats van beeldscherm proces file mail lennart < file Leest van file in plaats van toetsenbord Lennart Herlaar Computerarchitectuur en netwerken 5 8

18 I/O redirection 3 We doen het volgende in een textuele shell: (ls op Unix of DIR in Windows geven een lijst van je files) ls > file of DIR > file Schrijft naar file in plaats van beeldscherm proces file mail lennart < file Leest van file in plaats van toetsenbord file proces Lennart Herlaar Computerarchitectuur en netwerken 5 8

19 I/O redirection 3 We doen het volgende in een textuele shell: (ls op Unix of DIR in Windows geven een lijst van je files) ls > file of DIR > file Schrijft naar file in plaats van beeldscherm proces file mail lennart < file Leest van file in plaats van toetsenbord file proces Op Unix i.h.a. tussen de fork() en exec(). Lennart Herlaar Computerarchitectuur en netwerken 5 8

20 I/O redirection voorbeeld met fork pid = fork(); if (pid == 0) { // kind proces fileid = open ("filenaam", O_READ); dup2 (fileid, 0); close (fileid); exec (..); } file file begin file open file dup2 close Lennart Herlaar Computerarchitectuur en netwerken 5 9

21 I/O redirection voorbeeld zonder fork: filesdescr 0 wegzetten en later terug fileid = open ("filenaam", O_READ); saveid = dup(0); dup2 (fileid, 0); close (fileid);... start nu het kind... close (0); dup2 (saveid, 0); close (saveid); file file 0 file file stdin file stdin stdin stdin begin open dup dup2 close dup2 Lennart Herlaar Computerarchitectuur en netwerken 5 10

22 File locking Zie 4.7 en 7.3 in het dictaat Gelijktijdige toegang tot files: bescherm tegen gelijktijdige veranderingen Readers en writers probleem: Gelijktijdig schrijven (veranderen) gooit de file in de war Gelijktijdig lezen en schrijven kan bij lezen inconsistente informatie geven. Voorbeeld: bij een rekeningbestand moet een overschrijving in zijn geheel plaatsvinden voordat anderen er aan mogen komen maar updates op stukken die disjunct zijn zitten elkaar niet in de weg. Oplossing via file locks Als er meerdere processen bij betrokken zijn dan moet het O.S. het doen. Lennart Herlaar Computerarchitectuur en netwerken 5 11

23 Win32 file locking Bij het openen van de file specificeren: wat we met de file willen doen: READ en/of WRITE wat we andere processen toestaan: niets (exclusief), READ, WRITE of beide we kunnen nu delen van de file locken : LockFile(filehandle, beginbyte, eindbyte) lockt het deel tussen beginbyte en eindbyte UnlockFile(filehandle, beginbyte, eindbyte) unlockt het deel tussen beginbyte en eindbyte Als een ander proces een read resp. write wil doen op een gelockt stuk krijgt het een foutcode terug Lennart Herlaar Computerarchitectuur en netwerken 5 12

24 Win32 file locking Bij het openen van de file specificeren: wat we met de file willen doen: READ en/of WRITE wat we andere processen toestaan: niets (exclusief), READ, WRITE of beide we kunnen nu delen van de file locken : LockFile(filehandle, beginbyte, eindbyte) lockt het deel tussen beginbyte en eindbyte UnlockFile(filehandle, beginbyte, eindbyte) unlockt het deel tussen beginbyte en eindbyte Als een ander proces een read resp. write wil doen op een gelockt stuk krijgt het een foutcode terug begin eind A B read/write Lennart Herlaar Computerarchitectuur en netwerken 5 12

25 Unix file locking In Unix wordt file sharing niet opgegeven bij openen De fcntl() system call wordt gebruikt om delen van de file te locken Bij een lock kan opgegeven worden of het een read lock of write lock is en welk stuk van de file. read lock laat geen andere write locks toe op hetzelfde stuk, maar wel read locks write lock laat geen andere read locks of write locks toe op hetzelfde stuk F_SETLK geeft een error-code als er een lock conflict is F_SETLKW blokkeert in zo n geval Lennart Herlaar Computerarchitectuur en netwerken 5 13

26 Inhoud Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection file locking pipes = Message passing Via het geheugen (shared memory) Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 14

27 Pipes Wat is een pipe? Pipe: een file-achtig object dat in het geheugen staat. Een pipe heeft een schrijf-einde en een lees-einde Het producerende proces schrijft data in het schrijf-einde Het consumerende proces leest de data uit het lees-einde producer Pipe eigenschappen pipe consumer Het consumerende proces moet wachten als de pipe leeg is Het producerende proces moet wachten als de pipe te vol is. Als meer processen dezelfde pipe gebruiken dan is de data niet altijd goed gescheiden. Named pipes hebben een naam, net als files Anonymous pipe heeft geen naam. Lennart Herlaar Computerarchitectuur en netwerken 5 15

28 Pipes maken Win32 CreateNamedPipe om een named pipe te maken, CreateFile om te gebruiken (= gewone file aanroep) Anonymous pipe: CreatePipe om te maken. anonymous pipes kunnen overgeërfd worden door kind-processen. maar andere processen kunnen er niet bij. Named pipes kunnen door willekeurige processen gebruikt worden. Lennart Herlaar Computerarchitectuur en netwerken 5 16

29 Pipes maken Unix (anonymous pipes) Het ouder proces creëert een pipe met de pipe() system call De pipe() call levert twee filedescriptors op: een voor de leeskant en een voor de schrijfkant. Het ouder process creëert een kind-proces m.b.v fork() Een van de twee sluit de leeskant en de ander de schrijfkant (afhankelijk van welke richting gewenst is). Anonymous pipe kan alleen gebruikt worden tussen processen die een gezamenlijke voorouder hebben, die de pipe gemaakt heeft. Named pipes (Fifos) zitten in Unix gewoon in het filesysteem (en worden met de system call mkfifo aangemaakt). Lennart Herlaar Computerarchitectuur en netwerken 5 17

30 Pipe voorbeeld int pd[2]; pipe(pd); pid=fork(); if (pid == 0) // kind { close(pd[0]); // sluit lees-einde dup2(pd[1], 1); // kopieer schrijf-einde naar stdout close(pd[1]); // sluit originele schrijf-einde... } else { // ouder close(pd[1]); // sluit schrijf-einde dup2(pd[0], 0); // kopieer lees-einde naar stdin close(pd[0]); // sluit originele lees-einde... } Lennart Herlaar Computerarchitectuur en netwerken 5 18

31 Pipe en file descriptors kind ouder pd[0] 0 stdin stdout 1 pd[1] Kind: close(pd[0]); // sluit lees-einde dup2(pd[1], 1); // kopieer schrijf-einde naar stdout close(pd[1]); // sluit originele schrijf-einde Ouder: close(pd[1]); // sluit schrijf-einde dup2(pd[0], 0); // kopieer lees-einde naar stdin close(pd[0]); // sluit originele lees-einde Lennart Herlaar Computerarchitectuur en netwerken 5 19

32 Inhoud Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection file locking pipes Message passing = Via het geheugen (shared memory) Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 20

33 Message Passing Bij message passing kan een proces een message sturen naar een ander proces. Het ontvangende proces kan de messages één voor één ontvangen Elke message is een onverbrekelijke eenheid vergelijk: een pipe is een byte-stream De messages worden verzameld in message queues In Win16: per window is er een message queue In Win32: ook een message queue per thread Het verzendende proces kan kiezen: of naar een thread sturen (PostThreadMessage) of naar een window (SendMessage) Het ontvangende proces (thread) kan gewekt worden als er een boodschap aankomt. Lennart Herlaar Computerarchitectuur en netwerken 5 21

34 Message passing zender ontvanger queue recv message queue Lennart Herlaar Computerarchitectuur en netwerken 5 22

35 Inhoud Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection file locking pipes Message passing Via het geheugen (shared memory) = Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 23

36 Shared Memory Processen wisselen data uit via een shared segment Unix en Windows hebben speciale system calls om een stuk shared memory aan te vragen: via de page table wordt hetzelfde fysieke geheugen in de virtuele adresruimtes van processen gemapt Ook via memory-mapped files kan shared memory gebruikt worden Probleem: synchronisatie: hoe weet een proces dat er nieuwe gegevens zijn Hoe zorg je dat twee processen niet tegelijk in dezelfde variabele bezig zijn aankondigen mogelijk via messages, signals e.d. beschermen mogelijk zoals bij file locking Lennart Herlaar Computerarchitectuur en netwerken 5 24

37 Kritieke secties Een stuk programma waarin variabelen gemanipuleerd worden die in meer dan één thread gebruikt/gewijzigd worden heet een kritieke sectie Vergelijk het werken op dezelfde file vanuit meer dan één proces. Om chaos te voorkomen moet voorkomen worden dat meer dan één thread in de kritieke sectie komt In het college Gedistribueerd Programmeren wordt dit geleerd en geoefend Een van de oplossingen: vóór je de kritieke sectie ingaat moet je een lock doen aan het eind van de kritieke sectie doe je een unlock Lennart Herlaar Computerarchitectuur en netwerken 5 25

38 Synchronisatie Wie? Soms impliciet: synchrone I/O wacht tot de I/O klaar is bij aanvraag resource meestal vanzelf wachten kritieke secties in de kernel Soms moet het expliciet gebeuren: Een ouder proces wacht op een kindproces kritieke secties bij gebruik van shared memory of shared files Lennart Herlaar Computerarchitectuur en netwerken 5 26

39 Synchronisatie in Unix Proces wacht op kind-proces: wait() system call. wait(status) wacht tot een kind-proces termineert en geeft het proces ID van het betreffende kind terug. status ontvangt de exit status van het kind. Moderne Unix systemen: waitpid(pid) wacht op het opgegeven kind-proces. Ook procesgroepen mogelijk. Andere synchronisatiemogelijkheden: semaforen (college Gedistribueerd Programmeren). Ook in Win32. Lennart Herlaar Computerarchitectuur en netwerken 5 27

40 Signals 1 Een proces kan een software interrupt naar een ander proces (of zichzelf) sturen Processen kunnen kiezen welke signals ze willen hebben Dit wordt ook gebruikt om fouten af te vangen Of voor het signaleren van events in het O.S. (bijv. aankomst van message) Bij een signal wordt een aangegeven functie aangeroepen Lennart Herlaar Computerarchitectuur en netwerken 5 28

41 Signals 2 1 Declareer de signal handler: handler(signalnumber) { /* Hier de instructies voor als het signal komt */ } 2 Vertel het O.S. welke functie moet worden aangeroepen als de interrupt komt: signal(sigint, handler); Lennart Herlaar Computerarchitectuur en netwerken 5 29

42 Signals 3 /* stuur een signal naar proces pid */ kill (pid, SIGINT); In proces pid wordt nu de normale sequentiële executie onderbroken en de handler aangeroepen. Na afloop gaat de normale executie verder (tenzij handler die verbreekt). Een signal-handler vormt niet een thread De signal handler kan niet tijdelijk stoppen om het hoofdprogramma verder te laten gaan De handler kan wel onderbroken worden door een andere handler (LIFO) Synchronisatie werkt moeilijk Lennart Herlaar Computerarchitectuur en netwerken 5 30

43 Programma flow programma signal signal handler return Het is alsof er een methode-aanroep tussengeschoven wordt. Lennart Herlaar Computerarchitectuur en netwerken 5 31

44 Synchronisatie met signals pause() laat het proces wachten tot er een signal komt alarm(x) zorgt ervoor dat het O.S. na x sec. een signal genereert Bijv. sleep() is een combinatie van alarm() en pause() void sleep(int seconds) { signal(sigalrm, sleephandler); alarm(seconds); pause(); } void sleephandler(int signr) { /* doe verder niks */ } Lennart Herlaar Computerarchitectuur en netwerken 5 32

45 Signals 4 In het hoofdprogramma: signalled = false; incrit = true; < kritieke sectie > incrit = false; if (signalled) < doe operatie > In de signal routine: if (incrit) signalled = true; else < doe operatie > Veronderstelling: Lees/schrijf op een variabele is atomair. Lennart Herlaar Computerarchitectuur en netwerken 5 33

46 Samenvatting Manieren van communicatie tussen processen binnen één computer: Via files erven I/O redirection file locking pipes Message passing Via het geheugen (shared memory) Synchronisatie Signals Lennart Herlaar Computerarchitectuur en netwerken 5 34