Deadlock Definition deadlock (baglås) er en tilstand som en mængde af processer kan være i en mængde processer er i deadlock hvis alle processerne står i følgende situation: processen venter på en hændelse som kun en anden af processerne kan udføre. Typisk: "vente" = processen er blokeret fordi der ventes på adgang til en ressource "hændelse" = en anden proces frigiver ressourcen.

Ressourcer I relation til deadlock er de interessante ressourcer dem som kun 1 proces må bruge ad gangen. Ydre enheder printer skærm Filer/databaser reservationssystem kundekonti lagerstyring

Kritisk region reserver() { if reserveret < pladser // fejlmulighed then reserveret = reserveret + 1; // ved samtidighed } indsæt(beløb) { // fejlmulighed saldo = saldo + beløb; // ved samtidighed } // OBS - pseudokode, der ikke nævner filoperationer ! Kritisk region er en del af et program udførelse svarer til at besidde en ressource kun en proces ad gangen må udføre denne region af programmet har ikke præcis definition (modsat eks. deadlock)

Hvorfor procesblokering ? Multiple processer Automatisk ("preemptive") skedulering Tilgængelige, fælles ressourcer Race conditions (kritisk region) Procesblokering f.eks. v.hj.a. semaforer Fejl, inkonsistens Deadlock

Proces-blokering med semaforer..; down(sem); up(sem); Kritisk region Semaforer tilbyder: down, p: tester om ressource er ledig blokerer proces hvis ikke ledig up, v: frigiver ressource igen vækker blokerede processer Udføres atomisk Semaforens heltalsværdi udtrykker antallet af ledige ressourcer normalt 0 eller 1 kan generaliseres til n ressourcer af samme type

Filosof-problem uden blokering philosopher(int i) { while (TRUE) { think(); take_fork(i); take_fork((i+1) % 5); eat(); put_fork(i); put_fork(i+1); } take_fork(int f) { printf("Taking fork %d",f); } put_fork(int f) {..}

Filosof-problem med 1 ressource philosopher(int i) { while (TRUE) { think(); take_fork(i); take_fork((i+1) % 5); eat(); put_fork(i); put_fork(i+1); } down(sem); up(sem); Kritisk region Gaflerne opfattes som 1 (udelelig) ressource Maksimal 1 filosof ad gangen kan spise Deadlock ? (4 filosoffer udfører "down" mens 1 filosof er i kritisk region)

Betingelser for deadlock 1. Gensidig udelukkelse kun 1 proces ad gangen kan besidde en given ressource 2. "Hold and Wait" en proces der besidder en ressource kan forespørge efter andre ressourcer og evt. blokere 3. "No preemption" man kan ikke tvinge processer til at afgive ressourcer 4. Cirkulær venten (Hvis betingelse 4 er opfyldt, er betingelse 2 også)

Deadlock: graf-notation R1R2 P1P2 Proces P1 "besidder" ressource R1 Proces P2 venter på ressource R2. (Proces P2 er blokeret)

Cirkulær sti svarer til deadlock R1R2 P1P2 Grafen er et øjebliksbillede af programudførelsen

Deadlock ? A, B, C: Processer X, Y, Z: Ressourcer A besidder X og Y. C venter på Z. B venter på Y. A venter på Z.

Filosof-problem med 5 ressourcer philosopher(int i) { while (TRUE) { think(); take_fork(i); take_fork((i+1)%5); eat(); put_fork(i); put_fork(i+1); } take_fork(int f) { down(sem_f); printf("Taking fork %d",f); // pseudokode } put_fork(int f) { printf("Putting fork %d",f); up(sem_f); } Kan der opstå deadlock ? 5 filosoffer Definer selv værst tænkelige situation

Fjernelse af opstået deadlock Nedlæg en proces så den nedlagte proces' ressourcer bliver ledige Rollback "checkpoints", øjebliksbilleder kan ses som procesnedlæggelse efterfulgt af genstart databasesystemer "Ekspropriation" af ressource

Forebyggelse af deadlock Undersøg dit design: Kan du vise at ressource-grafen aldrig vil have cirkulære stier ? Brug en generel metode som forhindrer en af de fire betingelser: Gensidig udelukkelse ? Hold and wait Metode: bestil alle ressourcer på forhånd "No preemption" ? Cirkulær venten Metode: forespørg ressourcer i bestemt rækkefølge

"Forhånds-bestilling" philosopher(int i) { while (TRUE) { think(); take_forks(i); eat(); put_forks(i+1); } take_forks(int i) { int left = i, right = (i+1) % 5; down(sem_left,sem_right); } semop() tilbyder flere semafor-operationer i samme kald til semop() semafor-værdier ændres kun hvis alle ændringer kan gennemføres uden blokering læs detaljer på man-sider

Sortering af ressourcer philosopher(int i) { while (TRUE) { think(); take_forks(i); eat(); put_forks(i+1); } take_forks(int i) { int left =.., right =.., first = min(left,right), second = max(left,right); down(first); down(second); } Alle ressourcer nummereres og sorteres Ressource med mindste nummer bestilles først

Deadlock og udsultning Hvis en ventende proces er blokeret, bruger processen ikke cpu-tid. Hvis en ventende proces udfører "busy waiting", bruger processen cpu-tid. Kaldes "udsultning" jf. filosofferne. Processerne er også i deadlock. Jf. "test og sæt lås" ved hjælp af låsefiler: char lock[] = "LockFile" while (open(lock,O_RDWR|O_CREAT|O_EXCL,0666)<0) { sleep(1); }

Hvilke beskeder sendes ? kunde Over- tjener filosof kunde Besked: Jeg søger en plads ved bordet Filosofproces startes hvis der er plads Overtjener gives besked når plads bliver ledig Beskeder sendes tilbage med status ("spiser", "tænker")

Overtjener: 2 ventepunkter ?? // overtjener.c {opret beskedkø 1 til kunder} {opret beskedkø 2 til filosoffer} while (TRUE) { msgrcv(1,..); // ventepunkt 1 help_customer(..); msgrcv(2,..); // ventepunkt 2 opdater_plads_oversigt(..); }; // bedre at bruge 1 beskedkø: // msgrcv(..,mess,..); // if (bestilling(mess)) {

Overtjener: 1 ventepunkt // overtjener.c {opret beskedkø til kunder og filosoffer} while (TRUE) { msgrcv(..,mess,..); // 1 ventepunkt if (kundebesked(mess)) help_customer(mess); else opdater_plads_oversigt(mess); };