ΛΕΙΤΟΥΡΓΙΚΑ ΣΥΣΤΗΜΑΤΑ. Διαδιεργασιακή Επικοινωνία

Transcript

1 ΛΕΙΤΟΥΡΓΙΚΑ ΣΥΣΤΗΜΑΤΑ Διαδιεργασιακή Επικοινωνία Υλικό από: Tanenbaum, Modern Operating Systems,Structured Computer Organization Stallings, Operating Systems: Internals and Design Principles. Silberschatz, Galvin and Gange, Operating Systems Concepts. Deitel, Deitel and Choffnes, Operating Systems Λειτουργικά Συστήματα, Γ.Α. Παπαδόπουλος, Πανεπιστήμιο Κύπρου Λειτουργικά Συστήματα, Κ. Διαμαντάρας, ΤΕΙΘ Systems Programming in C, A.D. Marshal, University of Cardiff Σύνθεση Κ.Γ. Μαργαρίτης, Τμήμα Εφαρμοσμένης Πληροφορικής, Πανεπιστήμιο Μακεδονίας Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

2 Διαδιεργασιακή επικοινωνία (1) Οι διεργασίες εκτελούνται η κάθε μια στο δικό της χώρο διευθύνσεων και δεν έχουν πρόσβαση στους χώρους διευθύνσεων των άλλων διεργασιών, ακόμη και αυτών που οι ίδιες δημιούργησαν. Τα νήματα, έχουν μεταξύ τους περισσότερα κοινά στοιχεία, πχ ενιαίο χώρο διευθύνσεων (καθολικές μεταβλητές) ή προσπέλαση σε αρχεία, όμως και πάλι κατά βάση εκτελούνται ανεξάρτητα μεταξύ τους. Οι διεργασίες και τα νήματα πρέπει να έχουν τρόπους επικοινωνίας με το λ.σ. και με άλλες διεργασίες ή νήματα, έτσι ώστε * να ενημερώνουν και να ενημερώνονται για τη κατάσταση άλλων διεργασιών ή νημάτων * να έχουν και να προσφέρουν πρόσβαση σε δεδομένα ή πόρους

3 Διαδιεργασιακή επικοινωνία (1) Οι διεργασίες εκτελούνται η κάθε μια στο δικό της χώρο διευθύνσεων και δεν έχουν πρόσβαση στους χώρους διευθύνσεων των άλλων διεργασιών, ακόμη και αυτών που οι ίδιες δημιούργησαν. Τα νήματα, έχουν μεταξύ τους περισσότερα κοινά στοιχεία, πχ ενιαίο χώρο διευθύνσεων (καθολικές μεταβλητές) ή προσπέλαση σε αρχεία, όμως και πάλι κατά βάση εκτελούνται ανεξάρτητα μεταξύ τους. Οι διεργασίες και τα νήματα πρέπει να έχουν τρόπους επικοινωνίας με το λ.σ. και με άλλες διεργασίες ή νήματα, έτσι ώστε * να ενημερώνουν και να ενημερώνονται για τη κατάσταση άλλων διεργασιών ή νημάτων * να έχουν και να προσφέρουν πρόσβαση σε δεδομένα ή πόρους

4 Διαδιεργασιακή επικοινωνία (2) Η Διαδιεργασιακή Επικοινωνία (Inter Process Communication, IPC) παρέχει ένα σύνολο μηχανισμών που επιτρέπει στις διεργασίες να συγχρονίζουν την εκτέλεσή τους να διαμοιράζονται / τροποποιούν κοινόχρηστα δεδομένα να διαμοιράζονται πόρους του συστήματος να ανταλλάσουν μεταξύ τους σήματα και δεδομένα Οι συνηθέστεροι μηχανισμοί διαδιεργασιακής επικοινωνίας είναι: Τα σήματα (signals) Η μοιραζόμενη μνήμη (κλειδώμτα, σημαφόροι, επόπτες) Η μεταβίβαση μηνυμάτων Οι δίαυλοι (pipes)

5 Διαδιεργασιακή επικοινωνία (3) Η διαδιεργασιακή επικοινωνία είναι απαραίτητη για την εύρυθμη λειτουργία ενός λ.σ. πολυ-προγραμματισμού, και πολύ περισσότερο ενός λ.σ. πολυ-πύρηνου ή και κατανεμημένου υπολογιστικού συστήματος. Ειδικότερα η μοιραζόμενη μνήμη και η μεταβίβαση μηνυμάτων παρέχουν το θεωρητικό πλαίσιο (αλγορίθμους και μοντέλα) καθώς και τους κατάλληλους μηχανισμούς για την υλοποίηση του συντρέχοντος (concurrent) προγραμματισμού, δηλαδή του παράλληλου ή/και κατανεμημένου προγραμματισμού. Η διαδιεργασιακή επικοινωνία προσφέρει πλεονεκτήματα όπως αρθρωτή ανάπτυξη κώδικα ταχύτερη εκτέλεση εφαρμογών (καλύτερη χρήση πόρων) πλαίσιο επίλυσης προβλημάτων συντρέχοντος, παράλληλλου ή/και κατανεμημένου υπολογισμού (λ.σ. και εφαρμογών)

6 Σήματα (signals) (1) Τα σήματα (signals) είναι απλές διακοπές λογισμικού (software interrupts). Τα σήματα αποτελούν το μηχανισμό που χρησιμοποιεί το λ.σ. για να ενημερώσει τις διεργασίες για βασικά συμβάντα, δηλαδή αποτελούν μια λογική αφαίρεση και επέκταση του μηχανισμού των διακοπών αφού αυτές γίνονται αντιληπτές μόνο από το λ.σ. Επίσης τα σήματα αποτελούν το μηχανισμό ενημέρωσης του λ.σ. για διάφορα συμβάντα λογισμικού (παγιδεύσεις, traps) τα οποία συλλαμβάνονται από ένα τμήμα του λ.σ. αι πρέπει να επιλυθούν. Τελικά τα σήματα επιτρέπουν την επικοινωνία των διεργασιών και των χρηστών τόσο με το λ.σ. (π.χ. σήμα τερματισμού διεργασίας ή επανεκκίνησης υπολογιστή) όσο και των διεργασιών μεταξύ τους. Τα σήματα μπορεί να είνα σύγχρονα, δηλαδή να προκαλούν συγχρονισμό διεργασιών, αλλά συνήθως είναι ασύγχρονα, δηλαδή οι διεργασίες που τα παραλαμβάνουν τα χειρίζονται στο δικό τους χρόνο.

7 Σήματα (signals) (2) Τα σήματα, όπως και οι διακοπές, έχουν διάφορα επίπεδα προτεραιότητας. Για παράδειγμα, σήματα που παράγονται όταν το λ.σ. διαγνώσει κάποιο σφάλμα (segmentation fault, illegal operation,..) ή όταν ο χρήστης ζητήσει αναστολή ή τερματισμό διεργασίας (ctrl-c ή kill στο Unix) θεωρούνται επείγοντα και η παραλαμβάνουσα διεργασία πρέπει τα εξυπηρετήσει άμεσα. Το σύστημα ορίζει τον αριθμό, τον τύπο και τη προτεραιότητα των σημάτων. Ορισμένα σήματα με σχετικά χαμηλό επίπεδο προτεραιότητας μπορούν να αποκλειστούν, να αγνοηθούν ή να καθυστερήσει η εξυπηρέτησή τους, με ευθύνη του προγραμματιστή (maskable -nonmaskable signals/interrupts). Τα σήματα που αποκλείονται ορίζονται σε μιά 'μάσκα' που τη διαχειριζόμαστε με ειδικές συναρτήσεις. Σε περίπτωση που η διεργασία παραλαβής δεν προβλέπει κάποιο χειρισμό ενός σήματος, το πιθανότερο είναι οτι η παραλαβή του σήματος καταλήγει στο τερματισμό της διεργασίας.

8 Σήματα (signals) (3) Γενικά το σύστημα έχει μια προεπιλεγμένη ενέργεια που ακολουθεί τη παραλαβή κάθε σήματος: * Το σήμα απλά διαγράφεται * Η διεργασία τερματίζεται * Δημιουργείται ένα αντίγραφο του χώρου εργασίας της διεργασίας (core file στο Unix) και η διεργασία τερματίζεται * Η διεργασία αναστέλεται Με χρήση ειδικών συναρτήσεων μπορούμε να καθορίσουμε τις ενέργειες που θα εκτελέσει ένα πρόγραμμα με τη παραλαβή ενός σήματος.

9 POSIX signals (1) Signal Value Action Comment SIGHUP 1 Term Hangup detected on controlling terminal or death of controlling process SIGINT 2 Term Interrupt from keyboard (CTRL C) SIGQUIT 3 Core Quit from keyboard SIGILL 4 Core Illegal Instruction SIGABRT 6 Core Abort signal from abort() SIGFPE 8 Core Floating point exception SIGKILL 9 Term Kill signal (Non maskable) SIGSEGV 11 Core Invalid memory reference SIGPIPE 13 Term Broken pipe: write to pipe with noreaders SIGALRM 14 Term Timer signal from alarm() SIGTERM 15 Term Termination signal SIGCHLD 20,17,18 Ign Child stopped or terminated SIGCONT 19,18,25 Cont Continue if stopped SIGSTOP 17,19,23 Stop Stop process (Non maskable) SIGTSTP 18,20,24 Stop Stop typed at tty (CRTL Z) SIGTTIN 21,21,26 Stop tty input for background process SIGTTOU 22,22,27 Stop tty output for background process Ορισμένα τυπικά σήματα POSIX. Πλήρης κατάλογος σημάτων από τη γραμμή εντολών: $kill l

10 POSIX signals (2) Αποστολή σήματος από γραμμή εντολών: $kill <signal number> <prosses id> Toν αριθμό διεργασίας τον βρίσκουμε με ps. Πχ $kill Δύο βασικές κλήσεις συστήματος διαχείρισης σημάτων: Αποστολή: kill(pid, sig) Κλήση συστήματος που στέλνει το σήμα sig στη διεργασία pid. Αν pid > 0 το σήμα αποστέλεται στην αντίστοιχη διεργασία. Αν το pid = 0 το σήμα αποστέλεται σε όλες τις διεργασίες, εκτός από αυτές του συστήματος. Παραλαβή: signal(sig, &action) ή sigaction (sig, &action, &oldaction) Κλήσεις συστήματος που παραλαμβάνουν το σήμα sig και το διαχειρίζονται με βάση τη συνάρτηση action() και την εφεδρική oldaction(), η δεύτερη συνήθως είναι NULL. Η signal() είναι υψηλοτέρου επιπέδου.

11 Κλήσεις συστήματος διαχείρισης διεργασιών και σημάτων POSIX s : error code pid : process ID residual χρόνος που απομένει H συνάρτηση signal(sig, &act) είναι περίπου ισοδύναμη με τη sigaction()

12 Παραδείγματα POSIX signals (1) #include <stdio.h> #include <stdlib.h> #include <signal.h> // Function to be called when ctrl c (SIGINT) signal is sent to process void signal_callback_handler(int signum) { int pid; printf("my pid is: %d\n", pid = getpid()); printf("caught signal %d and killing myself\n",signum); kill(pid, 9); int main() { // Register signal and signal handler signal(sigint, signal_callback_handler); while(1) { printf("program processing stuff here.\n"); sleep(1); return 0;

13 Παραδείγματα POSIX signals (2) #include <stdio.h> #include <stdlib.h> #include <signal.h> char user[40]; /* define an alarm signal handler. */ void catch_alarm(int sig_num) { printf("operation timed out. Exiting...\n\n"); exit(0); int main(int argc, char* argv[]) { /* set a signal handler for ALRM signals */ signal(sigalrm, catch_alarm); printf("username: "); /* start a 30 seconds alarm */ alarm(30); gets(user); /* remove the timer, now that we've got the user's input */ alarm(0); printf("user name: '%s'\n", user); return 0;

14 #include <stdio.h> #include <stdlib.h> #include <signal.h> Παραδείγματα POSIX signals (3.1) void sighup(); /* signal handling functions */ void sigint(); void sigquit(); Main() { int pid; /* get child process */ if ((pid = fork()) < 0) { /* unsuccesful fork */ perror("fork"); exit(1); if (pid == 0) { /* child */ signal(sighup,sighup); /* set function calls */ signal(sigint,sigint); signal(sigquit, sigquit); for(;;); /* loop for ever */

15 else /* parent */ { /* pid hold id of child */ printf("\nparent: sending SIGHUP\n\n"); kill(pid,sighup); sleep(3); /* pause for 3 secs */ printf("\nparent: sending SIGINT\n\n"); kill(pid,sigint); sleep(3); /* pause for 3 secs */ printf("\nparent: sending SIGQUIT\n\n"); kill(pid,sigquit); sleep(3); Παραδείγματα POSIX signals (3.2) void sighup() { signal(sighup,sighup); /* reset signal */ printf("child: I have received a SIGHUP\n"); void sigint() { signal(sigint,sigint); /* reset signal */ printf("child: I have received a SIGINT\n"); void sigquit() { printf("my DADDY has Killed me!!!\n"); exit(0);

16 Μοιραζόμενη μνήμη (1) Δύο διεργασίες A και Β προσπαθούν να προσπελάσουν μοιραζόμενη μνήμη (εδώ το spooler directory) 'ταυτόχρονα'. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

17 Μοιραζόμενη μνήμη (2) Process A Process Β Spooler directory next_free_slot =in (7) Timeout in=7 next_free_slot=in (7) Copy_file_in_next_free_slot in=next_free_slot+1 Do something else Timeout Copy_file_in_next_free_slot in=next_free_slot+1 Do Something else Timeout in=7 in=8 in=8

18 Συνθήκες ανταγωνισμού Οι συνθήκες κατά τις οποίες δύο ή περισσότερες διεργασίες διαμοιράζονται την ίδια περιοχή μνήμης (ή πόρο) και το τελικό αποτέλεσμα εξαρτάται από τη σειρά αλλά και το χρόνο εκτέλεσής τους, λέγονται συνθήκες ανταγωνισμού (race conditions). Η διόρθωση προγραμμάτων που περιλαμβάνουν συνθήκες ανταγωνισμού δεν είναι εύκολη. Τα σφάλματα παρουσιάζονται τυχαία και μόνο κατά τη διενέργεια αλλεπάλληλων ελέγχων. Ο έλεγχος του ανταγωνισμού αφορά αναπόφευκτα το λ.σ. διότι αυτό υλοποιεί τον διαμοιρασμό των πόρων και των δεδομένων (διαδιεργασιακή επικοινωνία), άρα οποιαδήποτε λύση θα αφορά και υποστήριξη από το λ.σ. Επίσης, σε επίπεδο προγραμματισμού εφαρμογών, πρέπει να προσφέρονται λύσεις κλήσεων συστήματος για συντρέχοντα (cocurrent) προγραμματισμό, δηλαδή εφαρμογές με πολλά νήματα ή διεργασίες.

19 Αμοιβαίος αποκλεισμός Για να αποφύγουμε τις συνθήκες ανταγωνισμού πρέπει να επιτύχουμε αμοιβαίο αποκλεισμό (mutual exclusion): όταν μια διεργασία επεξεργάζεται μια διαμοιραζόμενη μεταβλητή τότε η εκτέλεσή της δεν πρέπει να διακοπεί μέχρι να ολοκληρώσει τις ενέργεις που σχετίζονται με αυτή τη μεταβλητή. Το τμήμα του κώδικα της διεργασίας που αναφέρεται στην επεξεργασία της διαμοιραζόμενης μεταβλητής λέγεται κρίσιμη περιοχή (critical region) ή κρίσιμο τμήμα (critical section). Οι λειτουργίες μέσα στις κρίσιμες περιοχές πρέπει να εκτελούνται αδιαίρετα, δηλαδή ή πλήρως ή καθόλου. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

20 Κρίσιμες περιοχές (1) Αμοιβαίος αποκλεισμός με χρήση κρίσιμων περιοχών. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

21 Κρίσιμες περιοχές (2) Process A... κώδικας εισόδου στη κρίσιμη περιοχή: αν η περιοχή είναι ελεύθερη η διεργασία Α καταλαμβάνει τη κρίσιμη περιοχή και εισέρχεται. Αλλιώς σταματά εδώ κώδικας κρίσιμης περιοχής κώδικας εξόδου από τη κρίσιμη περιοχή: η διεργασία Α ελευθερώνει τη κρίσιμη περιοχή... Process Β... κώδικας εισόδου στη κρίσιμη περιοχή: αν η περιοχή είναι ελεύθερη η διεργασία Β καταλαμβάνει τη κρίσιμη περιοχή και εισέρχεται. Αλλιώς σταματά εδώ κώδικας κρίσιμης περιοχής κώδικας εξόδου από τη κρίσιμη περιοχή: η διεργασία Β ελευθερώνει τη κρίσιμη περιοχή...

22 Αποφυγή συνθηκών ανταγωνισμού Αμοιβαίος αποκλεισμός: Δύο διεργασίες δεν μπορεί να βρίσκονται ταυτόχρονα στην ίδια κρίσιμη περιοχή. Δεν επιτρέπονται ιδιαίτερες παραδοχές σχετικά με τη ταχύτητα ή τον αριθμό των επεξεργαστών. Ιδιότητα της ασφάλειας: Διεργασία που δε βρίσκεται σε κρίσιμη περιοχή δεν μπορεί να απαγορέψει άλλες διεργασίες να εισέλθουν. Αν δεν ισχύει η ιδιότητα της ασφάλειας μπορεί να καταλήξουμε σε αδιέξοδο (deadlock). Ιδιότητα της βιωσιμότητας: Καμία διεργασία δεν θα πρέπει να περιμένει για πάντα για να εισέλθει σε κρίσιμη περιοχή. Αν δεν ισχύει η ιδιότητα της βισωιμότητας μπορεί να καταλήξουμε σε λιμοκτονία (starvation).

23 Αναστολή διακοπών Η διεργασία που μπαίνει σε κρίσιμη περιοχή αναστέλει τις διακοπές. Απλή λύση αλλά απαιτεί εκτέλεση privileged instructions από τις διεργασίες (δικαιώματα kernel mode). Η λύση αυτή χρησιμοποιείται μόνο από τον πυρήνα, όταν πχ εκτελεί context switch και ενημερώνει πίνακες και λίστες διεργασιών, συσκευών, πόρων. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

24 Κλείδωμα (Lock, Spinlock) (1) Process 0... enter_region(lock); critical_region(); leave_region(lock);... Process 1... enter_region(lock); critical_region(); leave_region(lock);... H μεταβλητή τύπου κλειδώματος LOCK ελέγχει την πρόσβαση των διεργασιών 0 και 1 στη κρίσιμη περιοχή. Οι ρουτίνες enter_region() και leave_region() εξηγούνται παρακάτω. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

25 Εντολή TSL (Test and Set Lock) Η είσοδος στη κρίσιμη περιοχή εκτελείται με την εντολή TSL η οποία αντιγράφει τη τιμή του κλειδώματος σε ένα καταχωρητή και θέτει στο κλείδωμα τη τιμή 1 (κλειδωμένο) σε μια αδιαίρετη ενέργεια (atomic action). Η έξοδος από τη κρίσιμη περιοχή επαναφέρει την τιμή του κλειδώματς στο 0 (ξεκλείδωτο). Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

26 Εντολή XCHG (Exchange Register - Lock) Η εντολή TSL αντικαθίσταται από την XCHG η οποία ανταλλάσσει τις τιμές του καταχωρητή και του κλειδώματος σε μια αδιαίρετη ενέργεια (atomic action). Τα υπόλοιπα μένουν όπως και στη προηγούμενη περίοτωση. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

27 Lock, Spinlock (2) Ειδικός τύπος δεδομένων lock. Επεξεργασία μόνο με δύο αδιαίρετες ενέργειες (atomic actions). Έστω s μεταβλητή τύπου lock_type. Aρχικοποίηση s=0; // lock is free Προσοχή στο άδειο loop enter_region(s) ή lock(&s) while (s!=0) ; s=1; // either set lock and // enter or // spin and check leave_region(s) ή unlcok(&s) s=0; // exit and free lock Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

28 Lock, Spinlock: παράδειγμα (1) PROCESS 0 PROCESS 1 a = data; /* a = 10 */ a++; /* a = 11 */ b = data; /* b = 10 */ b ; /* b = 9 */ data = a; /* data = 11 */ data = b; /* data = 9 */ H τροποποίηση της μεταβλητής data είναι η κρίσιμη περιοχή. Πιθανή εκτέλεση χωρίς κλείδωμα προκαλεί σφάλμα.

29 Lock, Spinlock: παράδειγμα (2) PROCESS 0 PROCESS 1 lock (&a_lock); lock (&a_lock); /* spinning */ /* spinning */ /* spinning */ /* spinning */ a = data; a++; data = a; unlock (&a_lock); /* spinning */success!lock(&a_lock); b = data; b ; data = b; unlock (&a_lock); H τροποποίηση της μεταβλητής data είναι η κρίσιμη περιοχή. Προστατεύεται από το κλείδωμα a_lock.

30 Ενεργός Αναμονή Στην Ενεργό Αναμονή (Busy Waiting) οι διεργασίες που προσπαθούν να εισέλθουν στη κρίσιμη περιοχή εκτελούν ένα συνεχή βρόχο ερώτησης για τη κατάσταση του κλειδώματος και αναμονής. Προφανές μειονέκτημα τη σπατάλη κύκλων CPU για συνεχείς ερωτήσεις. Παρατήρηση: μια διεργασία για να ελέγξει / μεταβάλει τη κατάσταση ενός κλειδώματος πρέπει να εκτελεστεί. Σοβαρότερο μειονέκτημα η αντιστροφή προτεραιότητας. Έστω δύο διεργασίες Α και Β. Η Α επιστρέφει από Ε/Ε. Η Β έχει χαμηλότερη προτεραιότητα αλλά όσο η Α ήταν σε αναστολή λόγω Ε/Ε έχει εισέλθει σε μια κρίσιμη περιοχή. Τώρα η Α μπαίνει σε ενεργό αναμονή και κάθε φορά που χρονο-διακόπτεται ξανα-εκτελείται γιατί έχει μεγαλύτερη προτεραιότητα από τη Β. Άρα η Β δε θα εκτελεστεί ποτέ και η Α θα εκτελεί συνεχώς το βρόχο της ενεργού αναμονής. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

31 Λήθαργος και Αφύπνιση Στο Λήθαργο και Αφύπνιση (Sleep and Wakeup) οι διεργασίες που πρέπει να εισέλθουν στη κρίσιμη περιοχή προσπαθούν μια φορά και αν αποτύχουν μεταπίπτουν σε αναστολή αναμένοντας σήμα αφύπνισης. Απαιτούνται πιο σύνθετες υλοποιήσεις. Δεν σπαταλούνται πόροι (χρόνος CPU) όπως με την ενεργό αναμονή. Οι διεργασίες που περιμένουν δεν χρειάζεται να εκτελεστούν για να ελέγξουν την κατάσταση του κλειδώματος, αλλά 'ενημερώνονται' από το λ.σ. Αποφυγή αντιστροφής προτεραιότητας. Διαχωρισμός συγχρονισμού από την πρόσβαση σε κρίσιμη περιοχή ή κοινόχρηστα δεδομένα (για τη περίπτωση των σημαφόρων). Πχ Mutexes, Σημαφόροι (Semaphores) Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

32 Mutexes (1) Υλοποίηση mutex lock και mutex unlock. Διαφορά με την υλοποίηση του απλού κλειδώματος είναι το CALL thread_yield, δηλαδή κλήση συστήματος για αναστολή λειτουργίας. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

33 Mutexes (2) Λειτουργία παρόμοια με του lock αλλά με πρόσθεση του sleep() στο while loop. Sυνδυασμός κλειδώματος-ξεκλειδώματος και ληθάργου-αφύπνισης σε δύο αδιαίρετες ενέργειες (atomic actions). Έστω s μεταβλητή τύπου mutex. Aρχικοποίηση s=0; mutex_lock(&s) while (s!=0) sleep(); s=1; mutex_unlock(&s) s=0; // either enter or go to // sleep and wait for // wakeup signal // send wakeup signal Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

34 Mutexes και POSIX threads Η Pthread_mutex_trylock προσπαθεί μόνο μια φορά και σε περίπτωση αποτυχίας επιστρέφει κωδικό σφάλματος. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

35 Mutexes και POSIX threads: παράδειγμα THREAD 1 THREAD 2 pthread_mutex_lock (&mut); a = data; a++; data = a; pthread_mutex_lock (&mut); pthread_mutex_lock (&mut); /* blocked */ /* blocked */ /* blocked */ /* blocked */ pthread_mutex_lock (&mut); b = data; b ; data = b; pthread_mutex_unlock (&mut); Η διαφοροποίηση από τα κλειδώματα βρίσκεται στη κατάσταση Blocked αντί Ready/Running (spinning).

36 #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NITER int count = 0; void * ThreadAdd(void * a) { int i, tmp; for(i = 0; i < NITER; i++) { tmp = count; tmp = tmp+1; count = tmp; Παράδειγμα Pthread mutex (1) int main(int argc, char * argv[]) { pthread_t tid1, tid2; pthread_create(&tid1, NULL, ThreadAdd, NULL); pthread_create(&tid2, NULL, ThreadAdd, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); if (count!= 2 * NITER) printf("\n BOOM! count is [%d], should be %d\n", count, 2*NITER); else printf("\n OK! count is [%d]\n", count); pthread_exit(null);

37 #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NITER int count = 0; pthread_mutex_t mutx; Παράδειγμα Pthread mutex (2) void * ThreadAdd(void * a) { int i, tmp; for(i = 0; i < NITER; i++) { pthread_mutex_lock(&mutx); tmp = count; tmp = tmp+1; count = tmp; pthread_mutex_unlock(&mutx); int main(int argc, char * argv[]) { pthread_t tid1, tid2; pthread_mutex_init(&mutx, NULL); pthread_create(&tid1, NULL, ThreadAdd, NULL); pthread_create(&tid2, NULL, ThreadAdd, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); pthread_mutex_destroy(&mutx);... pthread_exit(null);

38 Σημαφόροι (Semaphores) (1) Dijkstra (1965): γενίκευση του μοντέλου 'λήθαργος-αφύπνιση' εμπνευσμένη από τη λειτουργία των σηματοδοτών. Ουρές διεργασιών σε αναμονή. Ειδικός τύπος δεδομένων, προστασία κρίσιμων περιοχών και συγχρονισμός διεργασιών σε δύο αδιαίρετες ενέργειες (atomic actions). Έστω s μεταβλητή τύπου semaphore. Aρχικοποίηση s = N; // Ν = 1 : binary semaphore // N > 1 : counting semaphore down(&s) ή wait(s) while (s<=0 ) sleep(); s=s--; // either enter or go to // sleep and wait for // wakeup signal up(&s) h post(s) // send wakeup signal s=s++; Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

39 Σημαφόροι (2) typedef struct { int count; /* 0,1 (binary) or 0,1,..,N (counting) */ queue q; /* queue of processes waiting on semaphore */ Semaphore; void down(semaphore s) { /* process asks for semaphore Disable interrupts; if (s >count > 0) { /* or s >count == 1 s >count ; /* or s >count = 0 Enable interrupts; return; /* process gets semaphore Add(s >q, current process); /* s >count == 0 already sleep(); /* put process in blocked queue, re dispatch Enable interrupts; Μια υλοποίηση σημαφόρου από τη πλευρά του λ.σ. */ */ */ */ */ */

40 Σημαφόροι (3) void up(semaphore s) { /* process releases semaphore Disable interrupts; if (isempty(s >q)) { /* nobody is waiting s >count++; /* or s >count = 1 else { process = RemoveFirst(s >q); /* select 1st process wakeup(process); /* put process on the ready queue /* or give all waiting processes a chance Enable interrupts; Μια υλοποίηση σημαφόρου από τη πλευρά του λ.σ. */ */ */ */ */ */

41 POSIX semaphores sem_init() -- Αρχικοποιεί ένα σημαφόρο. sem_destroy() -- Ακυρώνει ένα σημαφόρο. sem_getvalue() -- Αντιγράφει τη τιμή του σημαφόρου σε ακέραιο. sem_wait(), sem_trywait() -- Αναστέλει τη διεργασία (ή επιστρέφει σήμα) όσο ο σημαφόρος είναι δεσμευμένος από άλλη διεργασία. Αλλιώς προχωρεί και μειώνει τη τιμή του σημαφόρου. sem_post() -- Αύξηση της τιμής του σημαφόρου.

42 #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NITER #define SHARED 1 int count = 0; Παράδειγμα Pthread semaphore (1) void * ThreadAdd(void * a) { int i, tmp; for(i = 0; i < NITER; i++) { tmp = count; tmp = tmp+1; count = tmp; int main(int argc, char * argv[]) { pthread_t tid1, tid2; pthread_create(&tid1, NULL, ThreadAdd, NULL); pthread_create(&tid2, NULL, ThreadAdd, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); if (count!= 2 * NITER) printf("\n BOOM! count is [%d], should be %d\n", count, 2*NITER); else printf("\n OK! count is [%d]\n", count); pthread_exit(null);

43 #include <pthread.h> #include <semaphore.h> #include <stdio.h> #include <stdlib.h> #define NITER #define SHARED 1 int count = 0; sem_t mutx; void * ThreadAdd(void * a) { int i, tmp; for(i = 0; i < NITER; i++) { sem_wait(&mutx); tmp = count; tmp = tmp+1; count = tmp; sem_post(&mutx); int main(int argc, char * argv[]) { pthread_t tid1, tid2; sem_init(&mutx, SHARED, 1); // semaphore is SHARED with initial value = 1 pthread_create(&tid1, NULL, ThreadAdd, NULL); pthread_create(&tid2, NULL, ThreadAdd, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); sem_destroy(&mutx);... pthread_exit(null); Παράδειγμα Pthread semaphore (2)

44 Mutexes και Semaphores (1) Πρώτη βασική λειτουργία είναι η προστασία της κρίσιμης περιοχής. Ο συγχρονισμός επιτυγχάνεται μέσω του ελέγχου της σειράς πρόσβασης στη κρίσιμη περιοχή. Η συνήθης σύνταξη για κάθε συμμετέχουσα διεργασία είναι: Mutex is unlocked Process A: Lock_mutex(); do_worka_in_critical_region(); Unlock_mutex(); Process B: Lock_mutex(); do_workb_in_critical_region(); Unlock_mutex(); Tα τμήματα κώδικα στη κρίσιμη περιοχή θα εκτελεστούν ακολουθιακά, το ένα μετά το άλλο, αλλά χωρίς να γνωρίζουμε ποιό θα εκτελεστεί πρώτο και ποιό δεύτερο. Διαδοχικές εκτελέσεις μπορεί να οδηγήσουν σε διαφορετική σειρά εκτέλεσης. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

45 Mutexes και Semaphores (2) Δεύτερη βασική λειτουργία είναι ο συγχρονισμός της ροής εκτέλεσης εντολών σε διαφορετικές διεργασίες ή νήματα, χωρίς απαραίτητα να υπάρχει σε πρόσβαση σε κρίσιμη περιοχή. Η συνήθης σύνταξη είναι: semaphore is set to 0 Process A: do_worka1(); Wait(semaphore); do_worka2(); Process B: do_workb1(); Signal(semaphore); do_workb2(); Tα τμήματα κώδικα do_worka1() και do_workb1() μπορεί να εκτελεστούν με οποιαδήποτε σειρά, όπως και τα do_worka2() και do_workb2(). Όμως, σε κάθε περίπτωση η διεργασία Α θα περιμένει τη διεργασία Β να ολκληρώσει το τμήμα do_workb1(), αλλοιώς δε θα μπορέσει να συνεχίσει στο do_worka2(); Αυτό που διασφαλίζει η παραπάνω συνθήκη είναι οτι το τμήμα κώδικα do_worka2() θα εκτελεστεί μετά το do_workb1(). Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

46 Mutexes και Semaphores (3) Οι δυαδικές σημαφόροι (Ν = 1) αρκετά συχνά χρησιμοποιούνται και ως mutexes, δηλαδή για προστασία κρίσιμων περιοχών. Οι μετρητές σημαφόροι (Ν > 1) μπορούν να χρησιμοποιηθούν ώστε να επιτρέπουν την εκτέλεση το πολύ Ν διεργασιών (ή επαναλήψεων σε μια διεργασία). Συνδυασμός πολλαπλών σημαφόρων επιτρέπει την επιβολή συγκεκριμένης σειράς εκτέλεσης σε πολλαπλές διεργασίες. sem1, sem2 are set to 0 ProcA: do_worka1(); Wait(sem1); do_worka2(); ProcB: do_workb1(); Signal(sem1); wait(sem2); do_workb2(); ProcC: do_workc1(); Signal(sem2); do_workc2(); Κίνδυνοι αδιεξόδου ή/και λιμοκτονίας (αργότερα..) Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

47 Κλασσικά προβλήματα (1) Παραγωγός Καταναλωτής (Producer Consumer) Γνωστό και ως πρόβλημα πεπερασμένου ενταμιευτή. Μια διεργασία τοποθετεί δεδομένα σε μια ουρά FIFO (ενταμιευτή) μεγέθους Ν. Μια άλλη διεργασία αφαιρεί δεδομένα στην ίδια ουρά. Προβλήματα συντονισμού παραγωγής-κατανάλωσης και γεμάτης-άδειας ουράς. Επεκτάσεις του προβλήματος με πολλαπλούς παραγωγούς ή και καταναλωτές, διαφορετικούς ρυθμούς παραγωγής /κατανάλωσης κλπ. Κοιμώμενος Κουρέας (Sleeping Barber) Ο κουρέας έχει 1 θέση εξυπηρέτησης και Ν θέσεις αναμονής. Όταν δεν έχει δουλειά 'κοιμάται'. Προβλήματα διαχείρισης ουράς αναμονής και σημάτων ληθάργου-αφύπνισης για τον κουρέα. Επεκτάσεις του προβλήαμτος με πελάτες με διαφορετικές απαιτήσεις, με προτεραιότητες, με πολλαπλούς κουρείς κλπ. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

48 Κλασσικά προβλήματα (2) Αναγνώστες Συγγραφείς (Readers - Writers) Μια βάση (ή δομή) δεδομένων μπορεί να διαβαστεί ταυτόχρονα από πολλούς αναγνώστες αλλά πρέπει να δεσμευτεί για ένα μόνο συγγραφέα. Αν δώσουμε απόλυτη προτεραιότητα στους αναγνώστες ή τους συγγραφείς τότε οι άλλοι μπορεί να λιμοκτονήσουν. Μια λύση είναι να δίνουμε προτεραιότητα στους μεν ή στους δε αλλά με ανώτατο χρονικό όριο ανά διεργασία και ανώτατο αριθμό συνεχών διεργασιών του ίδιου τύπου. Γευματίζοντες Φιλόσοφοι (Dining Philosophers) N (συνήθως 5) φιλόσοφοι σκέφτονται γύρω από ένα τραπέζι και κατά καιρούς θέλουν να φάνε. Στο τραπέζι υπάρχουν 5 (Μ) πηρούνια. Ο καθένας πρέπει να πιάσει 2 πηρούνια (αριστερά και δεξιά του). Μοντελοποίηση συνθηκών αδιεξόδου και λιμοκτονίας.

49 Παραγωγός Καταναλωτής (1) Πρέπει να προστατευθούν οι πράξεις: count +/-1 και οι λειτουργίες insert if count == N, remove if count == 0... Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

50 Παραγωγός Καταναλωτής (2)... Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

51 Παραγωγός Καταναλωτής (3) Producer Consumer Count 5 insert_item(item) count+1..timeout if (count == 0) FALSE item=remove_item(); count=count-1 Timeout count= count=5-1=4 count=5+1=6...

52 Παραγωγός Καταναλωτής (4) Producer Consumer Count if (count==0)...timeout count=0... insert_item(item) count=count+1 count=1 if (count==1) wakeup(consumer) Consumer is not sleeping... Timeout sleep()... After some time... if (count==n) sleep()... count=n

53 Παραγωγός Καταναλωτής (5) Empty count.. N-1 N Producer Full Consumer Buffer Wait if buffer is Full (count == N) Wait if buffer is Empty (count == 0) Insert item in buffer Remove item from buffer count ++ count -- Signal if buffer was Empty (count == 1) Signal if was Full (count == N -1) Χρήση semaphores / mutexes για συγχρονισμό (Full, Empty) και για έλεγχο κρίσιμης περιοχής (τροποποίηση count) Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

54 int count=0; Πρόταση I count++; count--; /*Increment count */ /*Decrement count */ Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

55 Παράδειγμα εκτέλεσης I Producer down(&empty) down(&mutex) producing up(&mutex) up(&full) down(&empty) down(&mutex) down(&mutex) producing up(&mutex) up(&full) Consumer mutex=1 0 dwn(&full) down(&full) down(&mutex) consuming up(&mutex) up(&empty) full= N-2 N-1 1 down(&empty) down(&mutex) producing up(&mutex) up(&full) empty=n N-1 1 N Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

56 #include <pthread.h> #include <stdio.h> #include <semaphore.h> #define SHARED 1 #define N 100 Πρόταση I πλήρες πρόγραμμα (1) void *Producer(void *); void *Consumer(void *); /* the two threads */ sem_t empty, full, mutex; int data[n], count=0; int numiters; /* the global semaphores */ /* shared buffer and index /* max numiters = N */ */ int main(int argc, char *argv[]) { /* thread ids and attributes */ pthread_t pid, cid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); numiters = atoi(argv[1]); sem_init(&empty, SHARED, N); sem_init(&full, SHARED, 0); sem_init(&mutex, SHARED, 1); /* sem empty = N */ /* sem full = 0 */ /* sem mutex = 1 */ printf("main started\n"); pthread_create(&pid, &attr, Producer, NULL); pthread_create(&cid, &attr, Consumer, NULL); pthread_join(pid, NULL); pthread_join(cid, NULL); printf("main done\n");

57 Πρόταση I πλήρες πρόγραμμα (2) /* deposit 1,..., numiters into the data buffer */ void *Producer(void *arg) { int produced; printf("producer created\n"); for (produced = 0; produced < numiters; produced++) { sem_wait(&empty); sem_wait(&mutex); data[count] = produced; count++; sem_post(&mutex); sem_post(&full); /* fetch numiters items from the buffer and sum them */ void *Consumer(void *arg) { int total = 0, consumed; printf("consumer created\n"); for (consumed = 0; consumed < numiters; consumed++) { sem_wait(&full); sem_wait(&mutex); count--; total = total+data[count]; sem_post(&mutex); sem_post(&empty); printf("for %d iterations, the total is %d\n", numiters, total);

58 Πρόταση ΙI (N = 1) #define N 1 int count = 0;... sem_init(&empty, SHARED, N); sem_init(&full, SHARED, 0);... void Producer(void) { int item; while (TRUE) { item = produce_item(); sem_wait(&empty); insert_item(item); count = count + 1; sem_post(&full); void Consumer(void) { int item; while (TRUE) { sem_wait(&full); item = remove_ietm(); count = count 1; sem_post(&empty); consume_item(item); /* sem empty = 1 */ /* sem full = 0 */ Αυστηρός συγχρονισμός Buffer με μια μόνο θέση (Ν = 1) Ο παραγωγός πρέπει να περιμένει το καταναλωτή να διαβάσει για να συνεχίσει. Δεν απαιτείται προστασία του count γιατί οι semaphores empty και full έχουν πάντοτε αντίθετες τιμές.

59 Παράδειγμα εκτέλεσης II Producer Consumer wait(&empty) empty=1 full=0 count=0 0 count=count+1 1 wait(&full)... post(&full)... 1 wait&full) 0 count=count=1 0 wait(&empty) post(&empty) wait(&empty)... 0 Προσπαθήστε να εκτελέσετε διάφορα σενάρια, πχ τι θα συνέβαινε αν: * το Ν είχε τιμή 2, 10 ή 100; * αν υπήρχε κάποιο sleep() στο παραγωγό ή καταναλωτή; * η σειρά των down() ή των up() ήταν διαφορετική σε μια από τις δύο διεργασίες; Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

60 Πρόταση ΙI πλήρες πρόγραμμα (1) #include <pthread.h> #include <stdio.h> #include <semaphore.h> #define SHARED 1 void *Producer(void *); void *Consumer(void *); /* the two threads */ sem_t empty, full; /* the global semaphores */ int data; /* shared buffer */ int numiters, count = 0; int main(int argc, char *argv[]) { /* thread ids and attributes */ pthread_t pid, cid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); numiters = atoi(argv[1]); sem_init(&empty, SHARED, 1); sem_init(&full, SHARED, 0); /* sem empty = 1 */ /* sem full = 0 */ printf("main started\n"); pthread_create(&pid, &attr, Producer, NULL); pthread_create(&cid, &attr, Consumer, NULL); pthread_join(pid, NULL); pthread_join(cid, NULL); printf("main done\n");

61 Πρόταση IΙ πλήρες πρόγραμμα (2) /* deposit 1,..., numiters into the data buffer */ void *Producer(void *arg) { int produced; printf("producer created\n"); for (produced = 0; produced < numiters; produced++) { sem_wait(&empty); data = produced; count++; sem_post(&full); /* fetch numiters items from the buffer and sum them */ void *Consumer(void *arg) { int total = 0, consumed; printf("consumer created\n"); for (consumed = 0; consumed < numiters; consumed++) { sem_wait(&full); total = total+data; count--; sem_post(&empty); printf("for %d iterations, the total is %d\n", numiters, total);

62 Παρατηρήσεις Κάθε μεταβλητή ή δομή δεδομένων ή πόρος του συστήματος που διαμοιράζεται αποτελεί κρίσιμη περιοχή και πρέπει προστατεύεται. Κάθε φορά που απαιτείται συγχρονισμός μεταξύ διεργασιών ή νημάτων πρέπει να υπάρχει ανταλλαγή σημάτων, με τη μορφή signal-wait ή με signal handlers. Ανάλογα με το τύπο του διαμοιρασμού μπορεί να έχουμε 'προστασία' σε ολόκληρες δομές δεδομένων ή μόνο σε στοιχεία τους, πχ 'κλείδωμα' πίνακα, γραμμής ή στοιχείου, 'κλείδωμα' αρχείου, εγγραφής ή πεδίου. Επομένως μπορεί να έχουμε αντίστοιχες δομές κλειδωμάτων ή σημαφόρων. Ο προγραμματισμός με κλειδώματα και σηματοφόρους χρησιμοποείται κυρίως σε χαμηλό επίπεδο, για καλά ορισμένες δομές και συγκεκριμένες χρήσεις. Η βασική δυσκολία βρίσκεται στον έλεγχο όλων των δυνατών συνδυασμών και χρονικών ακολουθιών αμοιβαίου αποκλεισμού και signalling, ιδίως όταν ο διαμοιρασμός ή ο συγχρονισμός αναφέρεται σε πολλές διεργασίες / νήματα. Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

63 Επόπτες (1) Hoare and Hansen (1972): Ο επόπτης (monitor) είναι μια δομή ελέγχου διαδιεργασιακής επικοινωνίας υψηλοτέρου επιπέδου. O επόπτης περιλαμβάνει τα διαμοιραζόμενα δεδομένα και τις ρουτίνες πρόσβασης σε αυτά. Τα διαμοιραζόμενα δεδομένα μπορούν να προσπελαστούν μόνο μέσω των ρουτινών του επόπτη. Mε αυτό το τρόπο υπάρχει καλυτερη οργάνωση και έλεγχος της διαδιεργασιακής επικοινωνίας. Οι επόπτες είναι υλοποιημένοι με σημαφόρους αλλά η υλοποίηση αυτή είναι διαφανής στο προγραμμάτιστή. Δομές ελέγχου υψηλοτέρου επιπέδου, όπως οι επόπτες, τα ραντεβού (rendezvous), τα φράγματα (barriers) κλπ συνήθως διατίθενται σε πιο σύγχρονες γλώσσες υψηλοτέρου επιπέδου (πχ Java) ή σε μέσω ειδικών βιβλιοθηκών και ΑPIs για parallel/concurrent programming.

64 Επόπτες (2) process P1 P2 routines monitor monitor name { shared data declarations routine P1 ( ) {... monitor routine P2 ( ) { { initialization code

65 Επόπτες και μεταβλητές συνθήκης (1) Η ουρά αναμονής των διεργασιών ενός επόπτη μπορεί να συνδυαστεί με μεταβλητές συνθήκης (condition variables). Μια μεταβλητή συνθήκης μπορεί να χρησιμοποιηθεί μόνο με δύο λειτουργίες, τις wait και signal. Έστω μια μεταβλητή συνθήκης x. Αν μια διεργασία που έχει εισέλθει στον επόπτη εκτελεί τη λειτουργία x.wait(); Σημαίνει ότι η διεργασία αυτή αναστέλεται μέχρι μια άλλη διεργασία που έχει εισέλθει στον επόπτη εκτελέσει τη λειτουργία x.signal(); Η λειτουργία x.signal ελευθερώνει μόνο μια διεργασία (αν περιμένουν πολλές). Αν δεν υπάρχει διεργασία που περιμένει τότο η λειτουργία x.signal δεν έχει καμμία επίπτωση.

66 Επόπτες και μεταβλητές συνθήκης (2) process condition variables monitor routines

67 Ελεγκτές και μεταβλητές συνθήκης σε Java Threads (1) synchronized class MonitorProducerConsumer { private boolean full, empty; private integer count; public void insert(item data) { if(count == N) wait(full); insert_item(data); count++; if(count == 1) signal(empty); public Item remove() { Item data; if(count == 0) wait(empty); data = remove_item(); count ; if(count == N 1) signal(full);...

68 Ελεγκτές και μεταβλητές συνθήκης σε Java Threads (2) static MonitorProducerConsumer themonitor = new MonitorProducerConsumer(); public class Producer extends Thread { public void run() { while(true) { Item data = produce_item(); themonitor.insert(data);... public class Consumer extends Thread { public void run() { while(true) { Item data = themonitor.remove(data); consume_item(data);...

69 Μεταβίβαση Μηνυμάτων (1) Κλήσεις συστήματος για ανάγνωση-εγγραφή σε ουρές μηνημάτων (message queues) τις οποίες διαχειρίζεται το λ.σ. Send(to_pid, &data); Receive(from_pid, &data); Δεν υπάρχουν προβλήματα διαμοιρασμού μνήμης, η μέθοδος μπορεί εύκολα να επεκταθεί σε απομακρυσμένα συστήματα (πχ client-server) Απαιτείται: Εγκαθίδρυση σύνδεσης και πιστοποίηση ταυτότητας. Ενημέρωση αποστολής δεδομένων με κάποιο σήμα στον παραλήπτη. Σύνθεση, αποσύνθεση μυνημάτων (κάποια δομή). Επιβεβαίωση παραλαβής και αρίθμηση ακολουθίας μηνυμάτων.

70 Μεταβίβαση Μηνυμάτων (2) Μεταβίβαση Μηνυμάτων Μοιραζόμενη Μνήμη Διαφοροποίηση κυρίως από τη πλευρά των κλήσεων συστήματος (API). Από τη πλευρά του λ.σ. καταλήγουμε σε παρόμοια αντιμετώπιση: Κοινή προυπόθεση όλων των λύσεων: μηχανισμός κοινής πρόσβασης.

71 Μεταβίβαση Μηνυμάτων (3) User space Kernel space

72 Υλοποίηση μεταβίβασης μηνυμάτων Ζητήματα σχεδίασης του λ.σ. Άμεση ή έμμεση επικοινωνία (μέσω mailbox). Απλή ή πολλαπλή επικοινωνία (multicasting). Μια ή πολλές συνδέσεις ανάμεσα σε δύο διεργασίες. Μέγεθος ενταμιευτή ή mailbox (περιορισμένο ή όχι). Mέγεθος και δομή μηνύματος. Σταθερό ή μεταβλητό μέγεθος μηνύματος; Μονόδρομη ή αμφίδρομη σύνδεση. Ανασταλτική (Blocking) ή σύγχρονη (synchronous) - Mη-ανασταλτική (non-blocking) ή ασύγχρονη (asynchronous)

73 POSIX message queues mq_open( ) Opens a message queue. mq_close( ) Closes a message queue. mq_unlink( ) Removes a message queue. mq_send( ) Sends a message to a queue. mq_receive( ) Gets a message from a queue. mq_notify( ) Signals a task that a message is waiting on a queue. mq_setattr( ) Sets a queue attribute. mq_getattr( ) Gets a queue attribute.

74 #include <pthread.h> #include <mqueue.h> Παραγωγός Καταναλωτής με Μεταβίβαση Μηνυμάτων (1) int main(void) { mqd_t messagequeuedescr; /* Create the message queue for sending information between tasks. */ messagequeuedescr = mq_open(messagequeuepath, (O_CREAT O_EXCL O_RDWR)); /* Create the producer task using the default task attributes. Do not * pass in any parameters to the task. */ pthread_create(&producertaskobj, NULL, (void *)producertask, NULL); /* Create the consumer task using the default task attributes. Do not * pass in any parameters to the task. */ pthread_create(&consumertaskobj, NULL, (void *)consumertask, NULL); /* Allow the tasks to run. */ pthread_join(producertaskobj, NULL); pthread_join(consumertaskobj, NULL); return 0; Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

75 Παραγωγός Καταναλωτής με Μεταβίβαση Μηνυμάτων (2) void producertask(void *param) { mqd_t messagequeuedescr; msgbuf_t msg; messagequeuedescr = mq_open(messagequeuepath, O_WRONLY); while (1) { /* Create message msg */ /* Send message */ mq_send(messagequeuedescr, &msg.buf, sizeof(msgbuf_t), 0); void consumertask(void *param) { mqd_t messagequeuedescr; msgbuf_t rcvmsg; messagequeuedescr = mq_open(messagequeuepath, O_RDONLY); while (1) { /* Wait for a new message. */ mq_receive(messagequeuedescr, &rcvmsg.buf, sizeof(msgbuf_t), NULL); /* Cosnume message msg */ Tanenbaum, Modern Operating Systems 3 e, (c) 2008 Prentice-Hall, Inc. All rights reserved

76 Δίαυλοι (1) $parent child $who >pipe1; sort <pipe1 >pipe2; lpr <pipe2 Σχηματική παράσταση ανώνυμων και επώνυμων διαύλων

77 Ανώνυμοι δίαυλοι (1) Ανακατεύθυσνη του stdout μιας διεργασίας στο sdtin της επόμενης. Ουσιαστικά μια ουρά χαρακτήρων FIFO μεταξύ δύο διεργασιών. Παράδειγμα γραμμής εντολών φλοιού: $ls l sort more Χρήση σε εφαρμογή: (α) Δήλωση int pd[2] όπου pd[0] και pd[1] τα δύο άκρα του διαύλου. (β) Δημιουργία του διαύλου με τη κλήση pipe(pd); (γ) Η μια διεργασία γράφει στο άκρο pd[0] και η άλλη διεργασία διαβάζει στο άκρο pd[1] (ή αντίστροφα). (δ) Επικοινωνία και συγχρονισμός με read(), write().

78 Ανώνυμοι δίαυλοι (2) #include <stdio.h> #include <string.h> #include <sys/wait.h> #include <stdlib.h> int main(int argc, char *argv[]) { int p[2]; int i, pid, status; char buffer[20]; pipe(p); /* setting up the pipe */ if ((pid = fork()) == 0) /* in child */ { close(p[1]); /* child closes p[1] */ while ((i = read(p[0], buffer, 8))!= 0) { buffer[i] = '\0'; /* string terminator */ printf("%d chars :%s: received by child\n", i, buffer); close(p[0]); exit(0); /* child terminates */ /* in parent */ close(p[0]); /* parent writes p[1] */ write(p[1], "Hello there, from me?", sizeof("hello there, from me?")); write(p[1], "How are you? - Ercal", sizeof("how are you? - Ercal")); close(p[1]); /* finished writing p[1] */ while (wait(&status)!=pid); /* waiting for pid */ if (status == 0) printf("child finished\n"); else printf("child failed\n"); return(0);

79 Eπώνυμοι δίαυλοι Ανακατεύθυσνη του stdout μιας διεργασίας σε αρχείο χαρακτήρων. Ανακατεύθυνηση του stdin της επόμενης διεργασίας στο ίδιο αρχείο. Ουσιαστικά ένα αρχείο χαρακτήρων χρησιμοποείται ως μια ουρά χαρακτήρων FIFO μεταξύ δύο διεργασιών. Παράδειγμα γραμμής εντολών φλοιού: $mkfifo my_pipe $gzip 9 c < my_pipe > out.gz $rm my_pipe Χρήση σε εφαρμογή: Mέσω των συναρτήσεων διαχείρισης αρχείων.

80 Δίαυλοι και διεργασίες (1) Μέσω της συνάρτησης fp = popen(<executable_file_name>, <r/w>); Δημιουργείται μια διεργασία που εκτελεί το αρχείο που δίνεται ως όρισμα και ανοίγει ένα δίαυλο για εγγραφή ή ανάγνωση. Συνδυασμός τέτοιων κλήσεων μπορεί να δημιουργήσει σειρά από διεργασίες που επικοινωνούν μέσω διαύλων. Η συνάρτηση pclose(fp); καταργεί το δίαυλο.

81 Δίαυλοι και διεργασίες (1) #include <stdio.h> #include <stdlib.h> int main(void) { FILE *pipein_fp, *pipeout_fp; char readbuf[80]; /* Create one way pipe with name pipein with call to popen() */ /* ls writes to pipein; fgets() reads from pipein */ if (( pipein_fp = popen("ls", "r")) == NULL) { perror("popen"); exit(1); /* Create one way pipe with name pipeout with call to popen() */ /* fputs() writes to pipeout; sort reads from pipeout */ if (( pipeout_fp = popen("sort", "w")) == NULL) { perror("popen"); exit(1); /* Processing loop: read from pipein write to pipeout */ while(fgets(readbuf, 80, pipein_fp)) fputs(readbuf, pipeout_fp); /* Close the pipes */ pclose(pipein_fp); pclose(pipeout_fp); return(0);