Σημαφόροι

Προγραμματισμός ΙΙΙ 1 [email protected]

Σημαφόροι(Σηματοφόροι / Σηματοφορείς)


• Ο σημαφόρος είναι ένας ΑΤΔ με πράξεις init, down(wait, P) και up (signal, V).

• Η init(s,v) αρχικοποιεί τον σημαφόρο s με την ακέραια τιμή v που πρέπει να είναι >=0.

• Η down(s) μειώνει την τιμή του σημαφόρου s κατά ένα –αν η τιμή του s είναι =0, τότε το καλών νήμα περιμένει μέχρι η τιμή του s να γίνει >0.

• Η up(s) αυξάνει την τιμή του σημαφόρου s κατά ένα –ξεμπλοκάροντας ίσως ένα νήμα που επιχειρεί να μειώσει την τιμή του s μέσω της down.

• Οι πράξεις down και up υλοποιούνται έτσι ώστε να μπορεί να κληθούν ταυτόχρονα χωρίς πρόβλημα.

Σημαφόροι (semaphores)


• Αν ένα ή περισσότερα νήματα έχουν μπλοκαριστεί στην down και ένα νέο νήμα εκτελέσει την downτότε μπλοκάρει και αυτό.

• ‘Οταν υπάρχουν πολλά νήματα μπλοκαρισμένα στην down και εκτελεσθεί η up αφυπνίζεται ένα από αυτά– random: η αφύπνιση γίνεται με τυχαία σειρά– fair: η αφύπνιση γίνεται έτσι ώστε κανένα νήμα να μην παραμείνει μπλοκαρισμένο απ’ άπειρο

– fifo: η αφύπνιση γίνεται με σειρά FIFO, δηλαδή με την σειρά που τα νήματα κάλεσαν την down

Σημαφόροι και «δικαιοσύνη»


• Δυαδικός σημαφόρος (binary semaphore) – μπορεί να λάβει τιμές 0 ή 1.

• Γενικός σημαφόρος ή σημαφόρος μετρητής (general / counting semaphore) – μπορεί να λάβει τιμές >= 0.

• Οι δυαδικοί σημαφόροι (μπορεί να) έχουν απλούστερη υλοποίηση καθώς χρειάζεται μόνο ένα bitγια να κρατά τις τιμές τους.

• Ένας γενικός σημαφόρος μπορεί να υλοποιηθεί με βάση δυαδικούς σημαφόρους.

Τύποι σημαφόρων


Κρίσιμο τμήμα με σημαφόρους

Pi:while (1) {

… down(s); /* entry code */do_critical_section();up(s); /* exit code */…

}

sem s;init(s,1);


{?} s ?

Σχόλιοπριν αρχίσει η εκτέλεση

P0:while (1) {

down(s); do_CS();up(s);…

}

sem s;init(s,1);

P1:while (1) {


}

Κατάσταση σημαφόρου

P2:while (1) {


}

τιμήουρά αναμονής


s 1

Σχόλιοαρχικοποίηση σημαφόρου με την τιμή 1

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

{}


Σχόλιοαρχή εκτέλεσης P0

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 1 {}



P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 1 {}


Σχόλιοπροσπάθεια P0 να εισέλθει στο ΚΤ, σημαφόρος μειώνεται κατά 1

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


ΣχόλιοP0 μπαίνει στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


Σχόλιοπροσπάθεια P1 να εισέλθει στο ΚΤ, σημαφόρος έχει τιμή 0 επομένως P1 μπλοκάρεται

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P1}



P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P1}


Σχόλιοπροσπάθεια P2 να εισέλθει στο ΚΤ, σημαφόρος έχει τιμή 0 επομένως P2 μπλοκάρεται

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P1,P2}


Σχόλιοέξοδος P0 από το ΚΤ, οπότε αφυπνίζεται το P1 (το οποίο μπλόκαρε πριν το P2)

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P2}


Σχόλιοτο P1 μπαίνει στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P2}


ΣχόλιοP0 εκτελεί κώδικα εκτός ΚΤ, P1 παραμένει στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P2}


ΣχόλιοP0 εκτελεί κώδικα εκτός ΚΤ, έξοδος P1 από το ΚΤ, οπότε αφυπνίζεται το P2

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


Σχόλιοτο P2 και μπαίνει στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


ΣχόλιοP0+P1 εκτελούν κώδικα εκτός ΚΤ, P2 είναι μέσα στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


ΣχόλιοP1 επιχειρεί να μπεί στο ΚΤ, και μπλοκάρεται

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P1}


ΣχόλιοP0 επιχειρεί να μπεί στο ΚΤ, και μπλοκάρεται

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P1,P0}


Σχόλιοέξοδος P2 από το ΚΤ, οπότε αφυπνίζεται το P1

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P0}


Σχόλιοτο P1 και εισέρχεται στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P0}


ΣχόλιοP2 συνεχίζει την εκτέλεση του

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {P0}


Σχόλιοέξοδος P1 από το ΚΤ, οπότε αφυπνίζεται το P0

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


Σχόλιοτο P0 και εισέρχεται στο ΚΤ

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}



P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 0 {}


Σχόλιοέξοδος P0 από το ΚΤ, και αφού κανένα νήμα δεν περιμένει στον σημαφόρο, αυξάνεται η τιμή του κατά 1

P0:while (1) {


}

sem s;init(s,1);

P1:while (1) {


}


P2:while (1) {


}

s 1 {}


• Ένας δυαδικός σημαφόρος παίρνει τιμές 0,1.• Αν δεν υπάρχουν νήματα μπλοκαρισμένα στην down, και η τιμή του σημαφόρου είναι ήδη 1, τυχόν κλήσεις της up δεν έχουν κανένα αποτέλεσμα, και η τιμή του σημαφόρου παραμένει 1.

• Αν θέλουμε να μην «χάνονται» οι κλήσεις της upόταν δεν υπάρχουν μπλοκαρισμένα νήματα στην down, χρησιμοποιούμε γενικό σημαφόρο.

Προσοχή!


• Δίνονται 3 νήματα P0, P1 και P2.• Έστω ότι πρέπει να υλοποιηθεί ένα «σημείο» συγχρονισμού ανάμεσα στα νήματα ως εξής:

• Αν το P0 φτάσει στο σημείο Α του κώδικα του πριν το P1 φτάσει στο σημείο Β του κώδικα του ή/και πριν το P2 φτάσει στο σημείο Γ του κώδικα του, τότε το P0 μπορεί να συνεχίσει την εκτέλεση του.

• Αν το P1 φτάσει στο σημείο Β του κώδικα του πριν το P0 φτάσει στο σημείο Α του κώδικα του, τότε το P1 πρέπει να περιμένει.

• Αν το P2 φτάσει στο σημείο Γ του κώδικα του πριν το P0 φτάσει στο σημείο Α του κώδικα του, τότε το P2 πρέπει να περιμένει.

Παράδειγμα



P0:…up(s);up(s);…

sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 0 {}


ΣχόλιοP0 εκτελεί up και αυξάνει την τιμή κατά 1


sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 1 {}


ΣχόλιοP0 εκτελεί up (ξανά!) αλλά η τιμή παραμένει 1


sem s;init(s,0);

P1:… down(s);…


P2:…down(s); …

s 1 {}




sem s;init(s,0);

P1:… down(s);…


P2:…down(s); …

s 1 {}


ΣχόλιοP1 εκτελεί down και μειώνει την τιμή κατά 1


sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 0 {}




sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 0 {}


ΣχόλιοP2 εκτελεί down και μπλοκάρεται … επ’ αόριστο!


sem s;init(s,0);

P1:… down(s); …


P2:…down(s); …

s 0 {P2}


• Η προηγούμενη εκτέλεση αντιστοιχεί σε ένα από τα διάφορα πιθανά σενάρια ταυτόχρονης εκτέλεσης.

• Υπάρχουν άλλα σενάρια όπου– το P2 δεν μπλοκάρει, αλλά μπλοκάρει το P1– δεν μπλοκάρει ούτε το P1 ούτε το P2

• Το αποτέλεσμα εξαρτάται από την εναλλαγή των διαφόρων νημάτων.

• Καθώς δεν μπορούμε να ελέγξουμε την εναλλαγή, το παραπάνω πρόγραμμα έχει μη ντετερμινιστικήσυμπεριφορά.

• Η λύση είναι να χρησιμοποιήσουμε γενικό σημαφόρο.

Σχόλιο




sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 0 {}


ΣχόλιοP0 εκτελεί up και αυξάνει την τιμή κατά 1

P0:… up(s);up(s);…

sem s;init(s,0);

P1:…down(s);…


P2:…down(s);…

s 1 {}


ΣχόλιοP0 εκτελεί up (ξανά!) και αυξάνει την τιμή κατά 1


sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 2 {}




sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 2 {}




sem s;init(s,0);

P1:… down(s);…


P2:…down(s);…

s 1 {}



P0:…up(s);up(s); …

sem s;init(s,0);

P1:… down(s); …


P2:…down(s); …

s 0 {}


Σχόλιοόλα τα νήματα συνεχίζουν την εκτέλεση τους


sem s;init(s,0);

P1:… down(s);…


P2:… down(s);…

s 0 {}


Υλοποίηση Σημαφόρων


• Ένας σημαφόρος είναι ένας ακέραιος μαζί με μια ουρά αναμονής όπου τοποθετείται ένα νήμα όταν επιχειρήσει να μειώσει την τιμή του ακεραίου και η τιμή του είναι ήδη 0.

• Οι λειτουργίες down/up εκτελούν «ατομικές» πράξεις στον ακέραιο και την ουρά.

• Οι πράξεις down/up μπορεί να υλοποιηθούν με ενεργή αναμονή.

• Οι πράξεις down/up μπορεί να υλοποιηθούν με βάση τις πράξεις suspend/resume.

Υλοποίηση δυαδικών / γενικών σημαφόρων


typedef struct bs {int locked; /* αμοιβαίος αποκλεισμός */int val; /* τιμή σημαφόρου */

} bsem;

void init(bsem *s, int val) {s->locked=0; s->val=val;

}

void down(bsem *s) {int done=0;do {

while (TAS(&s->locked));if (s->val>0) {s->val=0; done=1;}s->locked=0;

} while (!done);}

void up(bsem *s) {s->val=1;

}


typedef struct bs {int val; /* τιμή σημαφόρου */

} bsem;

void init(bsem *s, int val) {s->val=val;

}

void down(bsem *s) {beg_atomic();while (s->val == 0) {yield();}s->val=0;end_atomic();

}

void up(bsem *s) {s->val=1;

}


typedef struct bs {Queue q;int v;

} bsem;

void init(bsem *s, int v) {queue_init(&s->q);s->v=v;

}

void down(bsem *s) {beg_atomic();if (s->v==0) {suspend(&s->q);}else {s->v=0;}end_atomic();

}

void up(bsem *s) {beg_atomic();if (!queue_empty(&s->q) {resume(&s->q);}else {s->v=1;}end_atomic();

}


typedef struct gs {Queue q;int v;

} gsem;

void init(gsem *s, int v) {queue_init(&s->q);s->v=v;

}

void down(gsem *s) {beg_atomic();if (s->v==0) {suspend(&s->q);}else {s->v--;}end_atomic();

}

void up(gsem *s) {beg_atomic();if (!queue_empty(&s->q) {resume(&s->q);}else {s->v++;}end_atomic();

}


• Η υλοποίηση των δυαδικών ή γενικών σημαφόρων γίνεται συνήθως από το ίδιο το λειτουργικό σύστημα.

• Εκεί υλοποιείται και ο μηχανισμός εναλλαγής νημάτων, οπότε υπάρχει ακριβής έλεγχος του.

• Μπορούν να γίνουν επιπλέον βελτιστοποιήσεις, π.χ. κατάλληλη δομή διεργασίας έτσι ώστε η προσθήκη σε και απομάκρυνση από μια ουρά αναμονής να μπορούν να υλοποιηθούν αποδοτικά.

• Σπάνια ένα (λειτουργικό) σύστημα δίνει την δυνατότητα στον προγραμματιστή (εφαρμογών) να απενεργοποιήσει την εναλλαγή.

Σχόλιο


• Μπορούμε να υλοποιήσουμε γενικούς σημαφόρους χρησιμοποιώντας δυαδικούς σημαφόρους.

• Χρησιμοποιούμε (α) ένα δυαδικό σημαφόρο mtx για αμοιβαίο αποκλεισμό για την πρόσβαση στα δεδομένα του σημαφόρου, και (β) ένα δυαδικό σημαφόρο qπου χρησιμοποιούμε σαν ουρά αναμονής.

• Η αναμονή στην ουρά (σημαφόρο q) γίνεται στην down όταν η τιμή του σημαφόρου είναι 0.

• Πριν το καλών νήμα μπλοκάρει στον σημαφόρο q, πρέπει να αυξήσει τον σημαφόρο mtx έτσι ώστε ένα άλλο νήμα να μπορέσει (κάποια στιγμή) να εκτελέσει τον κώδικα της up, και να το αφυπνίσει.

Γενικοί σημαφόροι με δυαδικούς


typedef struct gs {int val,qlen; /* μετρητής, μέγεθος ουράς */bsem mtx,q; /* προστασία πρόσβασης, ουρά */

} gsem;

void init(gsem *s, int val) {s->val=val; s->qlen=0;binit(&s->mtx,1); binit(&s->q,0);

}

void down(sem *s) {bdown(&s->mtx); if (s->val > 0) {s->val--; bup(&s->mxt);} else {s->qlen++; bup(&s->mtx); bdown(&s->q);}

}

void up(sem *s) {bdown(&s->mtx);if (s->qlen == 0) {s->val++;} else {s->qlen--; bup(&s->q);}bup(&s->mtx);

}


• Υπάρχει περίπτωση προσπεράσματος με ταυτόχρονη εκτέλεση της down.

• Aφού το νήμα P0 αυξήσει τον σημαφόρο s->mxt(δηλαδή ελευθερώσει την είσοδο στην down) και πριν προλάβει να μειώσει τον σημαφόρο s->q(δηλαδή να τοποθετηθεί στην ουρά), μπορεί να προσπεραστεί από ένα άλλο νήμα P1.

• Παρ’ όλα αυτά, ο επ’ άπειρο παραγκωνισμός του νήματος P0 είναι απίθανος --γιατί;

Πρόβλημα A


typedef struct gs {int val,qlen; /* μετρητής, μέγεθος ουράς */bsem mtx,q; /* προστασία πρόσβασης, ουρά */

} gsem;

void init(sem *s, int val) {s->val=val; s->qlen=0;binit(&s->mtx,1); binit(&s->q,0);

}

void down(sem *s) {bdown(&s->mtx); if (s->val > 0) {s->val--; bup(&s->mxt);} else {s->qlen++; bup(&s->mtx); bdown(&s->q);}

}


}


• Επιπλέον υπάρχει περίπτωση ασυνέπειας με ταυτόχρονη εκτέλεση των down και up.

• Δύο (ή περισσότερα) νήματα μπορεί να φτάσουν και να διακοπεί η εκτέλεση τους στο σημείο της προσπέρασης, και στη συνέχει να εκτελεσθεί δύο (ή περισσότερες) φορές η up.

• Το αποτέλεσμα είναι ότι θα «χαθεί» μια κλήση (ή περισσότερες κλήσεις) up στον σημαφόρο s->q(αφύπνιση από την ουρά) και ένα ή περισσότερα νήματα θα μείνουν μπλοκαρισμένα στην down.

• Είναι μια περίπτωση συνθήκης ανταγωνισμού.

Πρόβλημα B



P0: down(s)

bdown(&s->mtx); if (s->val > 0) {s->val--; bup(&s->mxt);} else {s->qlen++; bup(&s->mtx); bdown(&s->q);}

sem s;init(s,0);


{?} s->mtx ?

{?} s->q ?

s->val = ?, s->qlen = ?

P1: down(s)


P2: up(s)

bdown(&s->mtx); if (s->qlen == 0) {s->val=1;} else {s->qlen--; bup(&s->q);} bup(&s->mtx);

P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{} s->q 0

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{} s->q 0

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 2

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{} s->q 0

s->val = 0, s->qlen = 2

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 2

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 0

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 1

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{} s->q 1

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 1

s->val = 0, s->qlen = 1

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 1

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 0

{} s->q 1

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)


«χάνεται»!



sem s;init(s,0);


{} s->mtx 1

{} s->q 1

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{} s->q 0

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)




sem s;init(s,0);


{} s->mtx 1

{P0} s->q 0

s->val = 0, s->qlen = 0

P0: down(s)


P1: down(s)


P2: up(s)


P3: up(s)



• Το πρόβλημα είναι ότι αίρεται ο αμοιβαίος αποκλεισμός στην down πριν ένα νήμα προλάβει να μπλοκάρει στην ουρά αναμονής q.

• Αυτό πρέπει αναγκαστικά να γίνει έτσι ώστε να επιτρέψουμε σε κάποιο άλλο νήμα να εκτελέσει κάποια στιγμή την up και να αφυπνίσει τα νήματα που περιμένουν στην q.

• Έτσι όμως επιτρέπουμε και σε άλλα νήματα να εκτελέσουν την down «μερικώς», και να αυξήσουν την τιμή qlen χωρίς να υπάρχει ούτε ένα νήμα που περιμένει στον σημαφόρο q.

Το πρόβλημα


• Πρέπει να απαγορέψουμε σε παραπάνω από ένα νήματα να αυξήσουν την τιμή της qlen.

• Χρειαζόμαστε ένα ακόμα δυαδικό σημαφόρο q2, που χρησιμοποιούμε για αμοιβαίο αποκλεισμό μεταξύ των νημάτων που καλούν την down.

• Ουσιαστικά, η ουρά αναμονής που υλοποιούσαμε μέσω του σημαφόρου q σπάει στα δύο, με το πρώτο νήμα να μπλοκάρει στον q και όλα τα υπόλοιπα νήματα που καλούν down «ταυτόχρονα» να μπλοκάρουν στον σημαφόρο q2.

Λύση


typedef struct gs {int val,qlen; bsem mtx,q,q2; /* …, σειριοποίηση στην down */

} gsem;

void init(sem *s, int val) {s->val=val; s->qlen=0;binit(&s->mtx,1); binit(&s->q,0); binit(&s->q2,1);

}

void down(sem *s) {bdown(&s->q2);bdown(&s->mtx); if (s->val > 0) {s->val--; bup(&s->mxt);}else {s->qlen++; bup(&s->mtx); bdown(&s->q);} bup(&s->q2);

}


}


typedef struct gs {int val,qlen; bsem mtx,q,q2; /* …, σειριοποίηση στην down */

} gsem;

void init(sem *s, int val) {s->val=val; s->qlen=0;binit(&s->mtx,1); binit(&s->q,0); binit(&s->q2,1);

}

void down(sem *s) {bdown(&s->mtx); if (s->val > 0) {s->val--; bup(&s->mxt);}else {

bdown(&s->q2);s->qlen++; bup(&s->mtx); bdown(&s->q);bup(&s->q2);

}}


}

Σημαφόροι

Documents

Transcript of Σημαφόροι