Κατανεμημένη συμφωνία (distributed consensus) Κατανεμημένα Συστήματα 1

Κατανεμημένη συμφωνία (distributed consensus) Κατανεμημένα Συστήματα 1 lalis@inf.uth.gr

Το πρόβλημα της συμφωνίας Σε ένα κατανεμημένο σύστημα, οι διεργασίες μπορεί ανά πάσα στιγμή να έχουν διαφορετική πληροφορία Αυτό δημιουργεί πρόβλημα οποτεδήποτε πρέπει να ληφθεί μια κοινή απόφαση από όλες τις διεργασίες κάθε διεργασία πρέπει να έχει στην διάθεση της ακριβώς την ίδια πληροφορία, αλλιώς ίσως λάβει διαφορετική απόφαση από τις υπόλοιπες Έχουμε ήδη δει μια «έκδοση» του προβλήματος, στο πλαίσιο της αξιόπιστης μετάδοσης δεδομένων πάνω από αναξιόπιστο δίκτυο: αφού πάντα μπορεί να χαθεί το τελευταίο μήνυμα, χρειάζεται πάντα ένα ακόμα μήνυμα για να το επιβεβαιώσει Κατανεμημένα Συστήματα 2 lalis@inf.uth.gr

Το πρόβλημα της συντονισμένης επίθεσης (με χαμένα μηνύματα) Attack? Attack? Δύο στρατηγοί έχουν στήσει ενέδρα, αλλά πρέπει να συμφωνήσουν για την ώρα της επίθεσης Επικοινωνούν μέσω αγγελιοφόρων, που μπορεί να «χαθούν» (να πιαστούν αιχμάλωτοι από τον εχθρό) Πως μπορεί να επιτευχθεί συμφωνία; ΑΔΥΝΑΤΟ! Κατανεμημένα Συστήματα 3 lalis@inf.uth.gr

Μια διαφορετική έκδοση του προβλήματος Το δίκτυο δεν(!) χάνει μηνύματα Υπάρχουν όμως βλάβες διεργασιών Πάλι προκύπτει πρόβλημα συμφωνίας Μπορεί να αποδειχθεί ότι στην γενικότερη περίπτωση δεν υπάρχει αλγόριθμος που λύνει το πρόβλημα με προκαθορισμένο αριθμό μηνυμάτων Κατανεμημένα Συστήματα 4 lalis@inf.uth.gr

Το πρόβλημα της συντονισμένης επίθεσης (με βλάβες silent crash διεργασιών) Attack? Attack? Attack? Πολλοί στρατηγοί, ο καθένας σε διαφορετική θέση, πρέπει να αποφασίσουν αν θα επιτεθούν μαζί Κάποιοι στρατηγοί μπορεί να λιποτακτήσουν Όλοι οι υπόλοιποι πρέπει να αποφασίσουν το ίδιο Κατανεμημένα Συστήματα 5 lalis@inf.uth.gr

Κατανεμημένη συμφωνία (distributed consensus) Κάθε διεργασία P i προτείνει (ανεξάρτητα) μια τιμή v i Οι διεργασίες επικοινωνούν μεταξύ τους για να πάρουν μια κοινή απόφαση Τερματισμός: κάθε «ορθή» διεργασία P i (που δεν παρουσιάζει βλάβη) αποφασίζει μια τελική τιμή d i Συνέπεια: μετά τον τερματισμό, όλες οι διεργασίες (που δεν έχουν βλάβη) θα έχουν αποφασίσει το ίδιο i,j: failed(p i ) failed(p j ) d i = d j Αν όλες οι διεργασίες προτείνουν την ίδια τιμή, τότε αυτή θα είναι η τιμή που θα αποφασισθεί ( i: v i = v) failed(p j ) d j = v Κατανεμημένα Συστήματα 6 lalis@inf.uth.gr

Κατανεμημένη συμφωνία με συντονιστή (coordinated consensus) Ο συντονιστής P c στέλνει d c σε όλες τις διεργασίες Οι διεργασίες επικοινωνούν μεταξύ τους για να πάρουν μια κοινή απόφαση Τερματισμός: κάθε «ορθή» διεργασία P i (που δεν παρουσιάζει βλάβη) αποφασίζει μια τελική τιμή d i Συνέπεια: μετά τον τερματισμό, όλες οι διεργασίες (που δεν έχουν βλάβη) θα έχουν αποφασίσει το ίδιο i,j: failed(p i ) failed(p j ) d i = d j Αν ο συντονιστής δεν παρουσιάσει βλάβη, τότε θα αποφασισθεί η τιμή που αυτός πρότεινε failed(p c ) failed(p i ) d i = d c Κατανεμημένα Συστήματα 7 lalis@inf.uth.gr

Πρωτόκολλο για συμφωνία χωρίς βλάβες Κάθε P i στέλνει την πρόταση της v i σε όλες τις διεργασίες, και περιμένει τις δικές τους προτάσεις Αφού λάβει τις προτάσεις από όλες τις διεργασίες, υπολογίζει την τελική απόφαση της d i μέσω μιας συνάρτησης decide(v 1, v 2,, v Ν ) Η decide είναι κοινή και ντετερμινιστική Τερματισμός: αφού δεν υπάρχουν βλάβες, κάθε διεργασία θα λάβει τιμές από όλες τις υπόλοιπες Συνέπεια: αφού όλες οι διεργασίες θα λάβουν όλες τις τιμές, και αφού οι τιμές θα είναι ακριβώς οι ίδιες σε όλες τις διεργασίες, θα αποφασίσουν την ίδια τιμή Κατανεμημένα Συστήματα 8 lalis@inf.uth.gr

d(v1,v2,v3) v1 P1 d(v1,v2,v3) v1 v2 v1 v3 d(v1,v2,v3) P2 v2 P3 v2 v3 v3 Κατανεμημένα Συστήματα 9 lalis@inf.uth.gr

Τερματισμός Ασύγχρονο σύστημα: Oι διεργασίες θα αποφασίσουν κάποια στιγμή H απρόβλεπτη καθυστέρηση μετάδοσης μηνυμάτων δεν επηρεάζει την ορθότητα ως προς τον τερματισμό Αφού τα μηνύματα δεν χάνονται (και δεν υπάρχουν βλάβες), κάθε διεργασία θα λάβει μια πρόταση από κάθε άλλη διεργασία, και άρα τελικά θα αποφασίσει Σύγχρονο σύστημα: Oι διεργασίες θα αποφασίσουν το αργότερο σε Τmax Κατανεμημένα Συστήματα 10 lalis@inf.uth.gr

Init: vals[n] = {?,...,?}; v = pickvalue(); d =?; Communication round: for-each p { send(p,<val,myid,v>); } On deliver(<val,p,pv>): vals[p] = pv; if (for-all p: vals[p]!=?) { d = decide(vals); } Κατανεμημένα Συστήματα 11 lalis@inf.uth.gr

Init: vals[n] = {?,...,?}; v = pickvalue(); d =?; Communication round: for-each p { send(p,<val,myid,v>); } sleep(tmax); di = decide(vals); On deliver(<val,p,pv>): vals[p] = pv; Κατανεμημένα Συστήματα 12 lalis@inf.uth.gr

Συμφωνία με 1 βλάβη crash σε σύγχρονο σύστημα Η διεργασία P k μπορεί να παρουσιάσει βλάβη, ενώ επιχειρεί να στείλει την πρόταση της v k Η v k μπορεί να μην φτάσει σε όλες τις διεργασίες, π.χ., ίσως φτάσει στην διεργασία P i, όχι όμως στην P j Η απόφαση της P i ίσως διαφέρει από αυτήν της P j Λύση: οι διεργασίες (που δεν παρουσιάζουν βλάβη) πρέπει να ανταλλάξουν τις τιμές που έχουν λάβει, ώστε να είναι σίγουρο πως όλες οι διεργασίες θα λάβουν την v k αν την έχει λάβει έστω και μια διεργασία Σημείωση: βεβαίως, η v k μπορεί προηγουμένως να μην έφτασε σε καμία διεργασία, οπότε ο επιπλέον γύρος επικοινωνίας θα γίνει «άδικα» Κατανεμημένα Συστήματα 13 lalis@inf.uth.gr

1ος γύρος P1 P1=v1, P2=v2, P3=? v2 v1 v3 P1=v1, P2=v2, P3=v3 P2 v2 v3 P3 2ος γύρος P1 P1=v1, P2=v2, P3=v3 v1,v2,v3 v1,v2,? P1=v1, P2=v2, P3=v3 P2 v1,v2,v3 P3 Κατανεμημένα Συστήματα 14 lalis@inf.uth.gr

1ος γύρος P1 P1=v1, P2=v2, P3=? v2 v1 v3 P1=v1, P2=v2, P3=? P2 v2 v3 P3 2ος γύρος P1 P1=v1, P2=v2, P3=? v1,v2,? v1,v2,? P1=v1, P2=v2, P3=? P2 v1,v2,? P3 Κατανεμημένα Συστήματα 15 lalis@inf.uth.gr

Init: vals[n] = {?,...,?}; v = pickvalue(); d =?; Communication rounds: vals[myid] = v; for-each p { send(p,<val,myid,vals>); } sleep(tmax); for-each p { send(p,<val,myid,vals>); } sleep(tmax); di = decide(vals); On deliver(<val,p,pvals>): for-each k { if (vals[k] ==?) { vals[k] = pvals[k]; } } Κατανεμημένα Συστήματα 16 lalis@inf.uth.gr

Λύση για (το πολύ) f βλάβες Στην χειρότερη περίπτωση, μπορεί να συμβαίνει μια νέα βλάβη σε κάθε «επόμενο» γύρο επικοινωνίας Κάθε φορά χρειάζεται ακόμα ένας γύρος επικοινωνίας Για f βλάβες: χρειάζονται f+1 γύροι επικοινωνίας, για την ανταλλαγή των τιμών ανάμεσα στις διεργασίες Σε κάθε γύρο, κάθε διεργασία στέλνει τις τιμές που έλαβε μέχρι τον προηγούμενο γύρο για λογαριασμό κάθε διεργασίας (και την δική της), και ανανεώνει τις τοπικές τιμές με βάση τις τιμές που λαμβάνει από τις υπόλοιπες διεργασίες Όταν ολοκληρωθεί ο τελευταίος γύρος επικοινωνίας, κάθε διεργασία αποφασίζει με βάση τις τιμές που έχει Κατανεμημένα Συστήματα 17 lalis@inf.uth.gr

Init: vals[n] = {?,...,?}; v = pickvalue(); d =?; Communication rounds: vals[myid] = v; for (r=1; r <= f+1; r++) { for-each p { send(p,<val,myid,vals>); } sleep(tmax); } d = decide(vals); On deliver(<val,p,pvals>): for-each k { if (vals[k] ==?) { vals[k] = pvals[k]; } } Κατανεμημένα Συστήματα 18 lalis@inf.uth.gr

0: P1=1, P2=?, P3=?, P4=? P1 P2 P4 0: P1=?, P2=2, P3=?, P4=? 0: P1=?, P2=?, P3=?, P4=4 P3 0: P1=?, P2=?, P3=3, P4=? Κατανεμημένα Συστήματα 19 lalis@inf.uth.gr

1ος γύρος P1 0: P1=1, P2=?, P3=?, P4=? {1,?,?,?} {?,2,?,?} P2 {?,?,?,4} P4 0: P1=?, P2=2, P3=?, P4=? 0: P1=?, P2=?, P3=?, P4=4 P3 {?,?,3.?} 0: P1=?, P2=?, P3=3, P4=? Κατανεμημένα Συστήματα 20 lalis@inf.uth.gr

1: P1=1, P2=2, P3=3, P4=? P1 P2 1: P1=1, P2=2, P3=3, P4=4 P3 1: P1=1, P2=2, P3=3, P4=? Κατανεμημένα Συστήματα 21 lalis@inf.uth.gr

2ος γύρος P1 1: P1=1, P2=2, P3=3, P4=? {1,2,3,?} {1,2,3,4} P2 1: P1=1, P2=2, P3=3, P4=4 P3 {1,2,3.?} 1: P1=1, P2=2, P3=3, P4=? Κατανεμημένα Συστήματα 22 lalis@inf.uth.gr

2: P1=1, P2=2, P3=3, P4=4 P1 P3 2: P1=1, P2=2, P3=3, P4=? Κατανεμημένα Συστήματα 23 lalis@inf.uth.gr

3ος γύρος P1 2: P1=1, P2=2, P3=3, P4=4 {1,2,3,4} P3 {1,2,3.?} 2: P1=1, P2=2, P3=3, P4=? Κατανεμημένα Συστήματα 24 lalis@inf.uth.gr

3: P1=1, P2=2, P3=3, P4=4 P1 P3 3: P1=1, P2=2, P3=3, P4=4 Κατανεμημένα Συστήματα 25 lalis@inf.uth.gr

Ορθότητα Τερματισμός Κάθε γύρος διαρκεί Tmax Απαιτούνται f+1 γύροι επικοινωνίας Συνέπεια Έστω ότι μετά από f βλάβες και f+1 γύρους επικοινωνίας, η διεργασία P i έχει λάβει v k για την P k, ενώ η P j όχι Για να φτάσουμε σε αυτό το αποτέλεσμα, σε κάθε γύρο, όλες οι διεργασίες που ήδη είχαν την v k πρέπει να παρουσίασαν βλάβη, και η τιμή v k πρέπει να έφτασε σε τουλάχιστον 1 νέα διεργασία που δεν την είχε ήδη Αυτό συνεπάγεται πως υπήρξαν τουλάχιστον f+1 βλάβες Άτοπο! Κατανεμημένα Συστήματα 26 lalis@inf.uth.gr

Παρατήρηση Μπορεί να μην συμβεί καμία βλάβη ή κάποιες βλάβες μπορεί να συμβούν μαζικά στον ίδιο γύρο Η απόφαση μπορεί να ληφθεί νωρίτερα Αν μια διεργασία λάβει τιμές για όλες τις διεργασίες (κανένα στοιχείο του πίνακα δεν είναι κενό), μπορεί να αποφασίσει, και να στείλει την απόφαση στις υπόλοιπες Αν μια διεργασία σε δύο διαδοχικούς γύρους λάβει μηνύματα μόνο από τις ίδιες διεργασίες, μπορεί να αποφασίσει, και να στείλει την απόφαση στις υπόλοιπες Κατανεμημένα Συστήματα 27 lalis@inf.uth.gr

Λύση κατανεμημένης συμφωνίας σε ασύγχρονο σύστημα Κατανεμημένα Συστήματα 28 lalis@inf.uth.gr

Συμφωνία σε ασύγχρονο σύστημα Το πρόβλημα της κατανεμημένης συμφωνίας με έστω 1 βλάβη crash δεν λύνεται σε ασύγχρονο σύστημα Μια διεργασία P i δεν γνωρίζει κατά πόσο υπάρχει ένα μήνυμα που βρίσκεται καθοδόν από την διεργασία P j δεν υπάρχει άνω όριο καθυστέρησης μετάδοσης μηνυμάτων Όσο η P i δεν έχει λάβει ένα μήνυμα που περιμένει από την P j, δεν μπορεί να προχωρήσει σε απόφαση Αν η P i αποφασίσει χωρίς να περιμένει το μήνυμα, μπορεί να αποφασίσει με βάση διαφορετικές τιμές από τις άλλες διεργασίες Αν η P i περιμένει για το μήνυμα που λείπει, τότε, αν η P j παρουσίασε βλάβη προτού στείλει αυτό το μήνυμα, τότε η P i θα περιμένει για πάντα Κατανεμημένα Συστήματα 29 lalis@inf.uth.gr

? Σενάριο Α v2 P1 v1 v3 το μήνυμα που έστειλε η P3 στην P1 απλά καθυστερεί P2 v2 v3 P3? Σενάριο Β v2 P1 v1 v3 η P3 παρουσίασε βλάβη προτού στείλει το μήνυμα στην P1 P2 v2 v3 P3 Κατανεμημένα Συστήματα 30 lalis@inf.uth.gr

Άτυπη απόδειξη Έστω πως το πρόβλημα της συμφωνίας λύνεται με ακριβώς Μ μηνύματα ανάμεσα στις Ν διεργασίες Έστω πως το τελευταίο μήνυμα του πρωτοκόλλου είναι ένα μήνυμα m που στέλνεται από την P j προς στην P i Έστω πως η P j παρουσιάζει βλάβη προτού στείλει το m Αφού υποθέσαμε πως το πρόβλημα έχει λύση, η P i μπορεί να πάρει πάντα σωστή απόφαση χωρίς το m Τότε το πρόβλημα λύνεται με Μ-1 μηνύματα άτοπο! Κατανεμημένα Συστήματα 31 lalis@inf.uth.gr

Γενικότερα... Για 1 βλάβη crash δεν υπάρχουν «συμβατικές» λύσεις (με προκαθορισμένο αριθμό μηνυμάτων) για τα προβλήματα συμφωνίας σε ασύγχρονο σύστημα Μια «λύση» είτε δεν θα είναι ορθή σε όλες τις περιπτώσεις, είτε υπάρχει περίπτωση να οδηγήσει σε ατέρμονη αναμονή κάποιας διεργασίας Δεν υπάρχει λύση για το consensus Δεν υπάρχει λύση για το coordinated consensus Δεν υπάρχει λύση για το reliable & total multicast Κατανεμημένα Συστήματα 32 lalis@inf.uth.gr

Παράκαμψη / λύση προβλήματος Fail-stop (ειδοποίηση για βλάβη διεργασίας) τίθεται θέμα του κατά πόσο η ειδοποίηση είναι FIFO σε σχέση με τα μηνύματα που έχει στείλει η διεργασία Eventually-reliable fault detectors Απόκρυψη βλαβών (με restart & persistence) πρακτικά δεν υφίστανται βλάβες, μόνο αργές διεργασίες Probabilistic/randomized algorithms Κατανεμημένα Συστήματα 33 lalis@inf.uth.gr

Πρωτόκολλα ατομικής δέσμευσης Απόφαση GO / ABORT Αν έστω και μια διεργασία ψηφίσει ABORT, όλες οι διεργασίες πρέπει να αποφασίσουν ABORT Κλασικό πρόβλημα για κατανεμημένες δοσοληψίες σε κατανεμημένα συστήματα βάσεων δεδομένων Η «συνολική δοσοληψία» μπορεί να οριστικοποιήσει τα αποτελέσματα της μόνο αν όλες οι «υπο-δοσοληψίες» δεσμευτούν να οριστικοποιήσουν τα επιμέρους αποτελέσματα τους Κατανεμημένα Συστήματα 34 lalis@inf.uth.gr

2 Phase Commit (2PC) Συντονιστής: (1) ζητά από τις διεργασίες να στείλουν την ψήφο τους, (2) αποφασίζει με βάση τις απαντήσεις που λαμβάνει, (3) στέλνει την απόφαση του, που είναι δεσμευτική για όλους αν δεν λάβει απάντηση από κάποια διεργασία μέσα σε εύλογο χρονικό διάστημα αποφασίζει («συντηρητικά») ABORT Υπόλοιπες διεργασίες: (1) περιμένουν να λάβουν την ερώτηση του συντονιστή, (2) στέλνουν την απάντηση τους, (3) περιμένουν να λάβουν την απόφαση αν μια διεργασία απαντήσει ABORT, γνωρίζει ότι η τελική απόφαση θα είναι αρνητική (δεν χρειάζεται να περιμένει) αν μια διεργασία απαντήσει GO, είναι υποχρεωμένη να περιμένει την τελική απόφαση του συντονιστή Κατανεμημένα Συστήματα 35 lalis@inf.uth.gr

(1) (2) (3) p1 p1 p1 vote GO GO GO p2 p3 p2 p3 p2 p3 όλες οι διεργασίες στέλνουν GO ο συντονιστής αποφασίσει GO Κατανεμημένα Συστήματα 36 lalis@inf.uth.gr

(1) (2) (3) p1 p1 p1 vote GO αργεί GO ABORT p2 p3 p2 p3 p2 p3 όλες οι διεργασίες στέλνουν GO ο συντονιστής αποφασίζει ABORT Κατανεμημένα Συστήματα 37 lalis@inf.uth.gr

(1) (2) (3) p1 p1 p1 vote ABORT GO ABORT p2 p3 p2 p3 p2 p3 μια διεργασία στέλνει ABORT ο συντονιστής αποφασίσει (υποχρεωτικά) ABORT Κατανεμημένα Συστήματα 38 lalis@inf.uth.gr

Pc: int d; // coord decision int pv; // process vote for-each p: send(p,<vote>); d = GO; // be optimistic for-each p { if!recv(<vote,pv>,timeout) { d = ABORT; break; } else if (pv == ABORT) { d = ABORT; break; } } for-each p: send(p,<decide,d>); Pi: int d; // decision int v; // my vote // wait for coord to ask me if!recv(pc,<vote>,timeout) { send(pc,<vote,abort>); d = ABORT; return; } v = pickvote(go,abort); send(pc,<vote,v>); if (v == ABORT) { d = ABORT; return; } // wait for coord decision recv(pc,<decide,d>); Κατανεμημένα Συστήματα 39 lalis@inf.uth.gr

Παρατηρήσεις Το 2PC λύνει το πρόβλημα της κατανεμημένης συμφωνίας, εφόσον ο συντονιστής δεν παρουσιάζει βλάβες (ή αυτές αποκρύπτονται με restart-persistence) και σε ασύγχρονο σύστημα για απεριόριστο αριθμό βλαβών των υπολοίπων διεργασιών Ο συντονιστής δεν μπλοκάρει ποτέ Μια διεργασία μπλοκάρει μόνο αν ψηφίσει θετικά, αλλά όχι για πάντα αφού, τελικά, σίγουρα θα λάβει την τελική απόφαση του συντονιστή εναλλακτικά μπορεί να επικοινωνήσει με τις υπόλοιπες μήπως κάποια ψήφισε αρνητικά ή έλαβε την απόφαση του συντονιστή Κατανεμημένα Συστήματα 40 lalis@inf.uth.gr

Πιθανοτικοί αλγόριθμοι Σε ασύγχρονο σύστημα με βλάβες crash δεν υπάρχει λύση με προκαθορισμένο αριθμό μηνυμάτων Υπάρχουν όμως «μη-ντετερμινιστικές» λύσεις! Βασική ιδέα: η απόφαση λαμβάνεται μέσα από ένα ισχυρό σχήμα πλειοψηφίας το οποίο, εφόσον σχηματιστεί, είναι εγγυημένα μη αναστρέψιμο Με αυτή την προσέγγιση το πρόβλημα του distributed consensus μπορεί να λυθεί και σε ασύγχρονο σύστημα Οι λύσεις έχουν πεπερασμένο αναμενόμενο χρόνο τερματισμού, και τελικά τερματίζουν με πιθανότητα 1 Κατανεμημένα Συστήματα 41 lalis@inf.uth.gr

Αλγόριθμος για f βλάβες και N>=2f+1 Έστω ότι η απόφαση είναι δυαδικού χαρακτήρα Συνεχόμενοι γύροι επικοινωνίας Κάθε διεργασία P i στέλνει πρόταση v i (αρχικά 0 ή 1) με βάρος w i (αρχικά 1), και περιμένει να λάβει Ν-f προτάσεις από άλλες διεργασίες Θέτει v i := v, αν έλαβε πρόταση v με βάρος >Ν/2, ή αν η τιμή v συγκέντρωσε την πλειοψηφία των N-f προτάσεων (σε περίπτωση ισοπαλίας, επιλέγεται μια συγκεκριμένη τιμή π.χ. 0), και θέτει w i ίσο με τον αριθμό των προτάσεων για v Αποφασίζει v αν έλαβε >f προτάσεις v με βάρος >Ν/2, οπότε στέλνει πρόταση v με βάρος Ν-f για τους δύο επόμενους γύρους επικοινωνίας Κατανεμημένα Συστήματα 42 lalis@inf.uth.gr

v=pick(0,1); w=1, d; /* my vote, vote weight & decision */ nv[2]; nw[2]; /* # 0/1 votes, # 0/1 votes with weight >N/2 */ r=0; /* current round nr */ do { nv[0]=0; nv[1]=0; nw[0]=0; nw[1]=0; /* reset counters */ for-each p: {send(p,<r,v,w>);} /* send vote & weight for round r */ while (nv[0]+nv[1]<n-f) { /* wait for N-f votes */ recv(<r,v,w >); if (r >r) { /* this is for a future round */ send(myid,<r,v,w >); /* resend message to self */ } else if (r ==r) { nv[v ]++; /* inc # votes for this value */ if (w >N/2) {nw[v ]++;} /* inc # weighted votes */ } } if (nw[1]>0) {v=1;} else if (nw[0]>0 {v=0;} /* pick nxt vote */ else if (nv[1]>nv[0]) {v=1;} else {v=0;} w=nv[v]; /* set weight */ r++; } while (nw[v]<=f); /* v received f+1 votes with >N/2 weight */ d = v; /* decide for this value */ for-each p: {send(p,<r,d,n-f>); send(p,<r+1,d,n-f>);} /* enforce d */ Κατανεμημένα Συστήματα 43 lalis@inf.uth.gr

Ορθότητα Κάθε γύρος επικοινωνίας τερματίζει υπάρχουν τουλάχιστον N-f διεργασίες, που δεν έχουν παρουσιάσει βλάβη και συνεπώς θα στείλουν πρόταση Αν μια διεργασία αποφασίσει στον γύρο k, τότε όλες οι διεργασίες θα έχουν αποφασίσει στον γύρο k+2 Αν όλες οι διεργασίες προτείνουν την ίδια τιμή, αυτή η τιμή θα αποφασισθεί σε 2 γύρους Αν τουλάχιστον 1+(N+f)/2 διεργασίες προτείνουν την ίδια τιμή, αυτή θα αποφασισθεί σε 3 γύρους Διαφορετικά, η απόφαση και ο αριθμός γύρων που θα χρειαστούν δεν είναι γνωστά εκ των προτέρων βασιζόμαστε στην τύχη για το ότι κάποια στιγμή (τελικά) θα σχηματιστεί ικανή πλειοψηφία Κατανεμημένα Συστήματα 44 lalis@inf.uth.gr

Απόφαση σε 2 γύρους Όλες οι διεργασίες αρχίζουν με την ίδια τιμή, π.χ. 0 Χειρότερο σενάριο: f διεργασίες παρουσιάζουν βλάβη κατά/πριν τον 1 ο γύρο επικοινωνίας Στον πρώτο γύρο N-f διεργασίες θα στείλουν την πρόταση 0 με βάρος 1 N-f διεργασίες θα λάβουν N-f (>N/2) τέτοιες προτάσεις N-f διεργασίες θα επιλέξουν 0 με βάρος N-f Στον δεύτερο γύρο N-f διεργασίες θα στείλουν την τιμή 0 με βάρος Ν-f (>N/2) N-f διεργασίες θα λάβουν Ν-f (>f) τέτοιες προτάσεις N-f διεργασίες θα αποφασίσουν 0 Κατανεμημένα Συστήματα 45 lalis@inf.uth.gr

Απόφαση σε 3 γύρους 1+(N+f)/2 διεργασίες αρχίζουν με την ίδια τιμή, π.χ. 0 Χειρότερο σενάριο: f από αυτές (που προτείνουν 0) παρουσιάζουν βλάβη κατά/πριν τον πρώτο γύρο Στον πρώτο γύρο 1+(Ν-f)/2 διεργασίες θα προτείνουν 0 με βάρος 1-1+(Ν-f)/2 διεργασίες θα προτείνουν 1 με βάρος 1 Ν-f διεργασίες θα επιλέξουν 0 με βάρος 1+(Ν-f)/2 Στον δεύτερο γύρο Ν-f διεργασίες θα στείλουν την πρόταση 0 με βάρος 1+(Ν-f)/2 Ν-f διεργασίες θα επιλέξουν 0 με βάρος Ν-f Στον τρίτο γύρο Ν-f διεργασίες θα στείλουν την τιμή 0 με βάρος Ν-f (>N/2) Ν-f διεργασίες θα αποφασίσουν 0 Κατανεμημένα Συστήματα 46 lalis@inf.uth.gr

Τερματισμός Η απόφαση θα παρθεί όταν οι ίδιες N-f διεργασίες καταφέρουν να επικοινωνήσουν αποκλειστικά μεταξύ τους για 3 συνεχόμενους γύρους Στην χειρότερη περίπτωση, στον γύρο k (Ν-f)/2 διεργασίες θα επιλέξουν την τιμή 0 με βάρος 1 (Ν-f)/2 διεργασίες θα επιλέξουν την τιμή 1 με βάρος 1 Στον γύρο k+1 Ν-f διεργασίες θα επιλέξουν την ίδια τιμή με βάρος (Ν-f)/2 Στον γύρο k+2 Ν-f διεργασίες θα επιλέξουν την ίδια τιμή με βάρος Ν-f Στον γύρο k+3 όλες οι διεργασίες θα αποφασίσουν την ίδια τιμή Κατανεμημένα Συστήματα 47 lalis@inf.uth.gr

Βυζαντινή συμφωνία σε σύγχρονο σύστημα Κατανεμημένα Συστήματα 48 lalis@inf.uth.gr

Το πρόβλημα της συντονισμένης επίθεσης (με βυζαντινές βλάβες) Attack? Attack? Attack? Πολλοί στρατηγοί, ο καθένας σε διαφορετική θέση, πρέπει να αποφασίσουν αν θα επιτεθούν μαζί Κάποιοι στρατηγοί μπορεί να είναι προδότες Όλοι οι υπόλοιποι πρέπει να αποφασίσουν το ίδιο Κατανεμημένα Συστήματα 49 lalis@inf.uth.gr

Βυζαντινοί στρατηγοί (byzantine generals) Βυζαντινή διεργασία = προδότης/διεφθαρμένος Αν ένας στρατηγός είναι προδότης, μπορεί να στείλει διαφορετική/παραπλανητική πληροφορία στους άλλους με απώτερο στόχο να μην επιτευχθεί συμφωνία παρ ότι οι υπόλοιποι στρατηγοί μπορεί να έχουν την (λανθασμένη) εντύπωση ότι αυτή έχει επιτευχθεί Δεν υπάρχει άμεσος τρόπος εντοπισμού των στρατηγών που είναι προδότες (no truth test) Εξετάζουμε το coordinated byzantine agreement Κατανεμημένα Συστήματα 50 lalis@inf.uth.gr

Παρατήρηση Μια διεργασία που παρουσιάζει βυζαντινή βλάβη μπορεί να «αποφασίσει» να μην στείλει ένα μήνυμα σε επιλεγμένες ή όλες τις διεργασίες Σε σύγχρονο σύστημα (αφού δεν χάνονται μηνύματα), αυτό απλά θα αποκαλύψει την βυζαντινή διεργασία Το χειρότερο που μπορεί να κάνει μια βυζαντινή διεργασία είναι να παριστάνει την ορθή, προσπαθώντας να παραπλανήσει τις υπόλοιπες Χειρότερο σενάριο: όλες οι βυζαντινές διεργασίες συνωμοτούν και δρουν συντονισμένα έτσι ώστε να παραπλανήσουν τις υπόλοιπες ορθές διεργασίες Κατανεμημένα Συστήματα 51 lalis@inf.uth.gr

Δεν υπάρχει λύση για Ν=3f και f=1 βλάβη (α) v1 P1(c) v1 (β) v1 P1(c) v2 v1 v1 P2 P3 P2 P3 v2 v2 {v1,v2} {v1,v2} {v2,v1} P 2 : ότι αποφασίσει στο (α) πρέπει να αποφασίσει και στο (β), αφού λαμβάνει ακριβώς τα ίδια μηνύματα P 3 : με την ίδια λογική, στο (β) θα αποφασίσει κάτι διαφορετικό από την P 2 Δεν υπάρχει συμφωνία! Κατανεμημένα Συστήματα 52 lalis@inf.uth.gr

Δεν υπάρχει λύση Ν<3f+1 και f βλάβες Ας υποθέσουμε πως υπάρχει αλγόριθμος για να επιτευχθεί συμφωνία με Ν = 3f διεργασίες Αυτός μπορεί να χρησιμοποιηθεί από 3 διεργασίες P 1, P 2, P 3, όπου οι P 1 και P 2 προσομοιώνουν καθεμιά από Ν/3 ορθές διεργασίες, ενώ η P 3 προσομοιώνει τις υπόλοιπες f=ν/3 βυζαντινές διεργασίες Τότε φτιάξαμε ένα σύστημα με 3 διεργασίες που επιτυγχάνει συμφωνία για 1 βυζαντινή βλάβη (άτοπο) Κατανεμημένα Συστήματα 53 lalis@inf.uth.gr

Λύση για Ν=3f+1 διεργασίες και f=1 βλάβη Συνάρτηση απόφασης decide(v 1,,v N-1 ): επιστρέφει την τιμή που πλειοψηφεί ή @ αν δεν υπάρχει πλειοψηφία Κάθε διεργασία περιμένει να λάβει τιμή από τον συντονιστή μετά από Tmax, θέτει ως τιμή @ Κάθε διεργασία προωθεί την τιμή του συντονιστή στις υπόλοιπες διεργασίες, και αποφασίζει με βάση τις τιμές που έλαβε από τον συντονιστή και τις υπόλοιπες Ο συντονιστής δεν έχει βλάβη: κάθε ορθή διεργασία θα αποφασίσει την τιμή που έστειλε ο συντονιστής Ο συντονιστής έχει βλάβη: στην χειρότερη περίπτωση, κάθε ορθή διεργασία θα αποφασίσει @ Κατανεμημένα Συστήματα 54 lalis@inf.uth.gr

(α) v1 P1(c) v1 v1 (β) v1 P1(c) v2 v3 {v1,v1,v2} P2 v1 v1 v1 P4 v2 v3 v1 P3 {v1,v2,v3} P2 v2 v1 v1 P4 v3 v3 v2 P3 {v3,v1,v2} {v1,v1,v3} {v2,v1,v3} Σενάριο (α): κάθε ορθή διεργασία αποφασίζει για την τιμή v1 που είναι η πρόταση του συντονιστή Σενάριο (β): κάθε ορθή διεργασία έχει λάβει τις τιμές v1, v2, v3, και αποφασίζει @ Κατανεμημένα Συστήματα 55 lalis@inf.uth.gr

Αλγόριθμος για Ν >= 3f+1: υποθέσεις Ο παραλήπτης ενός μηνύματος μπορεί να ταυτοποιήσει (εγγυημένα) τον αποστολέα με άμεσες (φυσικές) συνδέσεις για κάθε ζευγάρι διεργασιών με μηχανισμούς κρυπτογραφίας για την ταυτοποίηση του αποστολέα ενός μηνύματος, π.χ., ψηφιακές υπογραφές Μια διεργασία μπορεί να αντιληφθεί ότι μια διεργασία δεν έστειλε ένα μήνυμα (σε Tmax), ως όφειλε ισχύει για σύγχρονο σύστημα Μια βυζαντινή διεργασία μπορεί να αλλάξει την τιμή που της στέλνει μια άλλη (ορθή/βυζαντινή) διεργασία, προτού την προωθήσει στις υπόλοιπες Κατανεμημένα Συστήματα 56 lalis@inf.uth.gr

Αλγόριθμος για Ν >= 3f+1 A(N,0): 1. Ο συντονιστής στέλνει πρόταση v σε κάθε P i 2. Κάθε P i θέτει v i := v ή v i := @ αν δεν έλαβε κάποια τιμή από τον συντονιστή σε Tmax Α(N,f): 1-2.Όπως στο Α(N,0) 3. Η P i ενεργεί αναδρομικά ως συντονιστής για την τιμή v i που έλαβε, εκτελώντας το A(N-1,f-1) 4. Η P i θέτει ως τιμή v j την απόφαση που λαμβάνεται μέσω Α(N-1,f-1) για την τιμή που προωθεί (ως συντονιστής) κάθε άλλη διεργασία P j (λόγω #3) 5. Λαμβάνει την τελική απόφαση μέσω d(v 1,,v N-1 ) Κατανεμημένα Συστήματα 57 lalis@inf.uth.gr

Παρατηρήσεις Η εκτέλεση του A(N,f) οδηγεί σε Ν-1 εκτελέσεις του A(N-1,f-1), κάθε μια από τις οποίες οδηγεί σε Ν-2 εκτελέσεις του A(N-2,f-2), κτλ. Η απόδειξη ορθότητας γίνεται με επαγωγή Απαιτούνται f+1 γύροι (φάσεις) επικοινωνίας σε καθέναν από τους οποίους πραγματοποιούνται πολλές «ταυτόχρονες» ανταλλαγές μηνυμάτων που αφορούν το συγκεκριμένο «επίπεδο» της αναδρομής Απαιτούνται Ο(N f+1 ) μηνύματα κύκλος 1: Ν-1 μηνύματα κύκλος 2: (Ν-1) (Ν-2) μηνύματα κύκλος 3: (N-1) (N-2) (N-3) μηνύματα... Κατανεμημένα Συστήματα 58 lalis@inf.uth.gr

Δομή μηνυμάτων πρωτοκόλλου Μια τιμή v που παραλαμβάνεται στο γύρο k φέρει k διαφορετικά αναγνωριστικά <v:j k : :j 2 :j 1 > μέσω των οποίων καταγράφεται η «πορεία» της Αν η P i λάβει στον γύρο k την τιμή <v:j k :.. :j 2 :j 1 >, στον επόμενο γύρο προωθεί την τιμή <v:i:j k :.. :j 2 :j 1 > στις «υπόλοιπες» διεργασίες P j, j j 1..j k, j i Ο αριθμός των κύκλων επικοινωνίας καθορίζει το πόσες φορές θα διασταυρωθεί κάθε τιμή v που λαμβάνει μια διεργασία (με βάση τις τιμές που στέλνουν όλες οι διεργασίες που δεν συμμετείχαν στην προώθηση της) Κατανεμημένα Συστήματα 59 lalis@inf.uth.gr

Λογική διασταύρωσης πληροφορίας Για Ν=4 με f=1 διεργασίες 1 ος γύρος: η P 2 θα λάβει 1 τιμή από την P 1 (συντονιστής) 2 ος γύρος: η P 2 θα λάβει ως διασταύρωση αυτής της τιμής 2 επιπλέον τιμές από τις P 3 και P 4 Για Ν=7 με f=2 διεργασίες 1 ος γύρος: η P 2 θα λάβει 1 τιμή από την P 1 (συντονιστής) 2 ος γύρος: η P 2 θα λάβει ως διασταύρωση αυτής της τιμής 5 επιπλέον τιμές από τις P 3, P 4, P 5, P 6, P 7 3 ος γύρος: για κάθε μια τέτοια τιμή (π.χ. αυτήν της P 3 ), η P 2 θα λάβει ως διασταύρωση αυτής της τιμής 4 επιπλέον τιμές (π.χ. 4 τιμές από τις P 4, P 5, P 6, P 7 ) Σε κάθε επίπεδο αναδρομής κάθε διεργασία αποφασίζει με βάση τη τιμή που έλαβε «απ ευθείας» από μια διεργασία και τις (διασταυρωμένες) τιμές που λαμβάνει από τις υπόλοιπες Κατανεμημένα Συστήματα 60 lalis@inf.uth.gr

oι τιμές που βλέπει η P 2 p1 v1 v2 v3 p2 p3 p4 v4 v5 v6 v7 v8 v9 p3 p4 p2 p4 p2 p3 απόφαση της P 2 p2 p3 p4 v1:p1; v1:p1; v6:p3:p1; v8:p4:p1; v2:p1; v4:p2:p1; v2:p1; v9:p4:p1; v3:p1; v5:p2:p1; v7:p3:p1; v3:p1; d d d d2 d3 d4 Κατανεμημένα Συστήματα 61 lalis@inf.uth.gr

oι τιμές που βλέπει η P 2 p1 v1 v3 v6 p2 p4 p7 v7 v8 v9 v10 v11 v17 v18 v19v20v21 v32 v33 v34v35v36 p3 p4 p5 p6 p7 p2 p3 p5 p6 p7 p2 p3 p4 p5 p6 v5 v2 p6 p3 v27 v28 v29v30v31 v12 v13 v14v15v16 p2 p3 p4 p5 p7 p2 p4 p5 p6 p7 v4 p5 v22 v23 v24v25v26 p2 p3 p4 p6 p7 Κατανεμημένα Συστήματα 62 lalis@inf.uth.gr

p3 v37 v38 v39 v40 p4 p5 p6 p7 p2 v57 v58 v59 v60 p4 p5 p6 p7 p2 v77 v78 v79 v80 p3 p5 p6 p7 p2 v97 v98 v99 v100 p3 p4 p6 p7 p2 v117v118v119v120 p3 p4 p5 p7 p2 p4 v41 v42 v43 v44 p3 p5 p6 p7 p4 p2 v9 p5 v45 v46 v47 v48 p3 p4 p6 p7 p3 v14 p5 Κατανεμημένα Συστήματα 63 lalis@inf.uth.gr v137v138v139v140 p3 p4 p5 p6 v7 v12 v8 v13 v1 v2 p6 v49 v50 v51 v52 p3 p4 p5 p7 p7 v53 v54 v55 v56 p3 p4 p5 p6 v61 v62 v63 v64 v65 v66 v67 v68 v69 v70 v71 v72 v73 v74 v75 v76 p2 p5 p6 p7 p2 p4 p6 p7 p2 p4 p5 p7 p2 p4 p5 p6 v3 p4 v17 v18 v19 v21 v20 p3 p5 p6 p7 v81 v82 v83 v84 v85 v86 v87 v88 v89 v90 v91 v92 v93 v94 v95 v96 p2 p5 p6 p7 p2 p3 p6 p7 p2 p3 p5 p7 p2 p3 p5 p6 v4 p5 v22 p3 v23 v24 v26 p4 v25 p6 p7 v101v102v103v104 v105v106v107v108 v109v110v111v112 v113v114v115v116 p2 p4 p6 p7 p2 p3 p6 p7 p2 p3 p4 p7 p2 p3 p4 p6 v5 p6 v27 p3 v28 v29 p4 v30 v31 p5 p7 v121v122v123v124 v125v126v127v128 v129v130v131v132 v133v134v135v136 p2 p4 p5 p7 p2 p3 p5 p7 p2 p3 p4 p7 p2 p3 p4 p6 v6 p7 v32 p3 v33 v34 p4 v35 v36 p5 p6 v141v142v143v144 v145v146v147v148 v149v150v151v152 v153v154v155v156 p2 p4 p5 p6 p2 p3 p5 p6 p2 p3 p5 p6 p2 p3 p4 p5 v10 v15 p6 v11 v16 p7

Κατανεμημένα Συστήματα 64 lalis@inf.uth.gr v1:p1; v1:p1; v12:p3:p1; v17:p4:p1; v22:p5:p1; v27:p6:p1; v32:p7:p1; v12; v61:p4:p3:p1; v65:p5:p3:p1; v69:p6:p3:p1; v73:p7:p3:p1; v17; v81:p3:p4:p1; v85:p5:p4:p1; v89:p6:p4:p1; v93:p7:p4:p1; v22; v101:p3:p5:p1; v105:p4:p5:p1; v109:p6:p5:p1; v113:p7:p5:p1; v27; v121:p3:p6:p1; v125:p4:p6:p1; v129:p5:p6:p1; v133:p7:p5:p1; v32; v141:p3:p7:p1; v145:p4:p7:p1; v149:p5:p7:p1; v153:p6:p7:p1; d3:1 d d4:1 d d5:1 d d6:1 d d7:1 d v1:p1; d3:1; d4:1; d5:1; d6:1; d7:1; d2 d απόφαση της P 2

Αλγόριθμος για Ν>=f+2 με υπογεγραμμένες τιμές: υποθέσεις Ο παραλήπτης ενός μηνύματος μπορεί να ταυτοποιήσει (εγγυημένα) τον αποστολέα Μια διεργασία μπορεί να αντιληφθεί ότι μια διεργασία δεν έστειλε ένα μήνυμα (σε Tmax), ως όφειλε Μια βυζαντινή διεργασία δεν μπορεί να αλλάξει την τιμή που της έστειλε μια άλλη ορθή διεργασία Όμως, μια βυζαντινή διεργασία μπορεί να αλλάξει τις τιμές που στέλνουν άλλες βυζαντινές διεργασίες Κατανεμημένα Συστήματα 65 lalis@inf.uth.gr

Αλγόριθμος για Ν>=f+2 με υπογεγραμμένες τιμές 0. Αρχικά V i :={} 1. Ο συντονιστής P c στέλνει πρόταση <v:c> σε κάθε P i 2. Αν P i λάβει <v:c> και δεν έχει ήδη λάβει τιμή <v':c>, θέτει V i :={v} και στέλνει <v:c:i> στις άλλες διεργασίες 3. Αν P i λάβει < <<v:c>:j 1 >: :j k >, θέτει V i :=V i +{v}, και αν k<f τότε στέλνει < <<v:c:j 1 >: :j k >:i> σε κάθε P j, j j 1..j k, j i (που δεν συμμετείχε στην προώθηση της v) 4. Όταν η P i δεν περιμένει άλλα μηνύματα, αποφασίζει v αν είναι το μόνο στοιχείο του V i, διαφορετικά @ Κατανεμημένα Συστήματα 66 lalis@inf.uth.gr

Τερματισμός Κάθε τιμή που στέλνει ο συντονιστής προωθείται (το πολύ) f φορές έχουμε f+1 γύρους επικοινωνίας Αν η μετάδοση μηνυμάτων έχει άνω όριο Τmax, κάθε διεργασία μπορεί να αποφασίσει σε (f+1)tmax ανεξάρτητα από τον αριθμό των μηνυμάτων που έχει λάβει μέχρι τότε από κάθε διεργασία Μια βυζαντινή διεργασία (ίσως ο ίδιος ο συντονιστής) μπορεί να αποφασίσει να μην στείλει κάποιο μήνυμα αυτό δεν επηρεάζει τον τερματισμό Κατανεμημένα Συστήματα 67 lalis@inf.uth.gr

Συνέπεια με ορθό συντονιστή Η P c στέλνει την ίδια τιμή <v:c> σε κάθε P i Κάθε P i θα λάβει <v:c>, αν είναι ορθή θα θέσει V i :={v} Οι βυζαντινές διεργασίες δεν μπορούν να προωθήσουν διαφορετική τιμή για λογαριασμό του συντονιστή δεν μπορούν να αλλάξουν την υπογεγραμμένη τιμή του Το «χειρότερο» που μπορεί να κάνει μια βυζαντινή διεργασία είναι να μην στείλει καθόλου μηνύματα αυτό δεν επηρεάζει το V i Συνεπώς, την στιγμή της απόφασης, κάθε ορθή διεργασία P i θα έχει V i ={v}, και θα αποφασίσει v Κατανεμημένα Συστήματα 68 lalis@inf.uth.gr

Συνέπεια με βυζαντινό συντονιστή Αρκεί να δείξουμε i,j: failed(p i ) failed(p j ) v V i v V j Ισχύει αν P i και P j λάβουν τις ίδιες τιμές 1. Αν η P i λάβει <v:c>, θα στείλει <<v:c>:i> στην P j 2. Αν η P i λάβει < <<v:c>:j1>: :jk> (α) αν j {j1,,jk}, τότε η P j έχει ήδη λάβει την v (β) διαφορετικά (i) k<f: η P i θα στείλει < <<v:c:j1>: :jk>:i> στην P j (ii) k=f: αφού o συντονιστής έχει βυζαντινή βλάβη, τουλάχιστον μια από τις P j1,,p jk είναι ορθή και άρα έχει ήδη προωθήσει την τιμή v στην P j Κατανεμημένα Συστήματα 69 lalis@inf.uth.gr

Βυζαντινές βλάβες σε ασύγχρονο σύστημα; Όπως για τις βλάβες crash, δεν υπάρχει αλγόριθμος που να καταλήγει εγγυημένα σε συμφωνία, με προκαθορισμένο αριθμό γύρων επικοινωνίας και μηνυμάτων Υπάρχουν όμως πιθανοτικοί/τυχοδιωκτικοί αλγόριθμοι δεν υπάρχει άνω όριο στους γύρους επικοινωνίας / μηνύματα κάθε διεργασία επιλέγει για τον επόμενο γύρο επικοινωνίας την τιμή που πλειοψήφησε στον προηγούμενο γύρο προσαρμόζει το βάρος της πρότασης της αντίστοιχα Τερματισμός επιτυγχάνεται όταν σχηματιστεί ικανή (μη αναστρέψιμη) πλειοψηφία ακόμα και αν όλες οι βυζαντινές διεργασίες συνεργαστούν συντονισμένα για να αποτρέψουν την συμφωνία Κατανεμημένα Συστήματα 70 lalis@inf.uth.gr