Διεργασίες Διεργασίες Διαδιεργασιακή Επικοινωνία (IPC)

Διεργασία Κώδικας, Δεδομένα, και Στοίβα Κατάσταση προγράμματος Συνήθως έχει τον δικό της χώρο διευθύνσεων (address space) Κατάσταση προγράμματος CPU καταχωρητές Program counter Δείκτης στοίβας Μόνο μία διεργασία μπορεί να εκτελείται στην CPU σε κάθε χρονική στιγμή!

οπτική γωνία διεργασίας Μοντέλο διεργασιών οπτική γωνία CPU οπτική γωνία διεργασίας A Πολυπλογραμματισμός τεσσάρων προγραμμάτων Ιδεατό μοντέλο 4 ανεξάρτητες διεργασίες Οι διεργασίες εκτελούνται ανεξάρτητα Μόνο ένα πρόγραμμα ενεργό σε κάθε χρονική στιγμή B C A B C D B D D C B A Time

Δημιουργία Διεργασιών Οι διεργασίες δημιουργούνται με δύο τρόπους Αρχικοποίηση συστήματος: διεργασίες γεννώνται αυτόματα όταν το ΛΣ εκκινείται. Εκτέλεση κλήσης συστήματος για δημιουργία διεργασίας Οι κλήσεις συστήματος μπορούν να προέρχοναι από: user shells εκτελούμενες διεργασίες

Τερματισμός διεργασιών Οι συνθήκες τερματισμού διεργασίας μπορεί να είναι Εθελούσιες Ακούσιες Κανονική έξοδος (Normal exit) Εξοδος σφάλματος (Error exit) Καταστροφικό σφάλμα Θανάτωση από άλλη διεργασία

Ιεραρχίες Διεργασιών Γονική διεργασία δημιουργεί θυγατρική διεργασία Οι θυγατρικές διεργασίες μπορούν να δημιουργήσουν τα δικά τους παιδιά Διαμόρφωση ιεραρχίας UNIX “process group”

Καταστάσεις Διεργασίας Created Η διεργασία βρίσκεται σε μία από τις 5 καταστάσεις Created Ready Running Blocked Exit Μεταβάσεις μεταξύ καταστάσεων 1 - Διεργασία καταχωρείται στην ουρά εκτέλεσης (ready queue) 2 - Επιλογή Scheduler 3 - Επιλογή άλλης διεργασίας από Scheduler 4 - Διεργασία αναμένει συμβάν (π.χ. I/O) 5 - Συμβάν 6 - Εξοδος διεργασίας 7 - Διεργασία τερματίζεται από άλλη 1 Ready 2 5 3 Blocked (waiting) Running 4 7 6 7 Exit

Διεργασίες στο ΛΣ … Δύο επίπεδα διεργασιών Το χαμηλότερο επίπεδο χειρίζεται θέματα διακοπών και χρονοπρογραμματισμό διαδικασιών Πάνω από αυτό υπάρχουν οι ακολουθιακές διεργασίες. Μέσο παρακολούθησης τους ο πίνακας διεργασιών (process table). Processes 1 N-2 N-1 … Scheduler

Καταχωρήσεις πίνακα διεργασιών Process management Registers Program counter CPU status word Stack pointer Process state Priority / scheduling parameters Process ID Parent process ID Signals Process start time Total CPU usage File management Root directory Working (current) directory File descriptors User ID Group ID May be stored on stack Memory management Pointers to text, data, stack or Pointer to page table

Τι συμβαίνει στην περίπτωση ενός σήματος διακοπής ή trap? Το υλικό φυλάσσει τον PC (στη στοίβα ή σε ειδικό καταχωρητή) To υλικό φορτώνει νέο PC, προσδιορίζει το είδος της διακοπής Ρουτίνα Assembly φυλάσσει τους καταχωρητές Ρουτίνα Assembly διαμορφώνει την στοίβα Ρουτίνα Assembly καλεί την C για να εκτελέσει την ρουτίνα εξυπηρέτησης Η ρουτίνα εξυπηρέτησης καλεί τον scheduler Ο Scheduler επιλέγει μία διεργασία για να εκτελεστεί (πιθανά αυτή που διεκόπει …) Ρουτίνα Assembly φορτώνει PC & καταχωρητές για την επιλεγμένη διεργασία

Διαδιεργασιακή Επικοινωνία (IPC) Η κάθε διεργασία εκτελείται ακολουθιακά Ανταλλαγή δεδομένων μεταξύ διεργασιών Exchange data between multiple processes Allow processes to navigate critical regions Maintain proper sequencing of actions in multiple processes

Παράδειγμα: το πρόβλημα του πεπερασμένου buffer Shared variables const int n; typedef … Item; Item buffer[n]; int in = 0, out = 0, counter = 0; Ατομικές Εντολές: Counter += 1; Counter -= 1; Producer Item pitm; while (1) { … produce an item into pitm … while (counter == n) ; buffer[in] = pitm; in = (in+1) % n; counter += 1; } Consumer Item citm; while (1) { while (counter == 0) ; citm = buffer[out]; out = (out+1) % n; counter -= 1; … consume the item in citm … }

Πρόβλημα: Καταστάσεις Ανταγωνισμού Οι συνεργαζόμενες διεργασίες μοιράζονται χώρο μνήμης Και οι δύο μπορούν να διαβάζουν/γράφουν την μνήμη Πρόβλημα: δεν μπορεί να εξασφαλιστεί η ατομικότητα (read - write) Η σειρά εκτέλεσης έχει σημασία. Μπορεί να προκύψουν λανθασμένα αποτελέσματα Πρέπει να εξαληφθούν οι καταστάσεις ανταγωνισμού. P1 P2 x=3 R1 <= x R1 = R1+1 R1 => x R3 <= x R3 = R3+1 R3 => x x=5 R1 <= x R3 <= x R3 = R3+1 R1 = R1+1 R1 => x R3 => x x=6!

Κρίσιμες Περιοχές Η χρήση κρίσιμων περιοχών για την επίτευξη mutual exclusion και αντιμετώπιση καταστάσεων ανταγωνισμού 4 συνθήκες για τον αμοιβαίο αποκλεισμό Δεν επιτρέπονται δύο διεργασίες ταυτόχρονα στην κρίσιμη περιοχή Δεν γίνονται υποθέσεις για την ταχύτητα ή τον αριθμό των CPUs Μία διεργασία που δεν βρίσκεται εντός της κρίσιμης περιοχής δεν μπορεί να μπλοκάρει κάποια άλλη διεργασία Κάθε διεργασία πρέπει να περιμένει πεπερασμένο χρόνο για την είσοδο στη κρίσιμη περιοχή. A enters critical region A leaves critical region Process A B leaves critical region B enters critical region B tries to enter critical region Process B B blocked Time

Ενεργός αναμονή: αυστηρή εναλλαγή Process 0 Process 1 while (TRUE) { while (turn != 0) ; /* loop */ critical_region (); turn = 1; noncritical_region (); } while (TRUE) { while (turn != 1) ; /* loop */ critical_region (); turn = 0; noncritical_region (); } Χρήση μίας διαμοιραζόμενης μεταβλητής (turn) για να υποδεικνύεται η σειρά των διεργασιών Η διεργασία που βρίσκεται σε αναμονή διαρκώς ελέγχει την μεταβλητή για να δει αν μπορεί να εισέλθει στην κρίσιμη περιοχή spin lock : η αναμένουσα διεργασία περιστρέφεται (spins) σε κλειστό βρόγχο ανάγνωσης της μεταβλητής. Αποφεύγονται οι συνθήκες ανταγωνισμού (race conditions), αλλά δεν ικανοποιείται το κριτήριο 3 για τις κρίσιμες περιοχές.

Busy waiting: working solution #define FALSE 0 #define TRUE 1 #define N 2 // # of processes int turn; // Whose turn is it? int interested[N]; // Set to 1 if process j is interested void enter_region(int process) { int other = 1-process; // # of the other process interested[process] = TRUE; // show interest turn = process; // Set it to my turn while (turn==process && interested[other]==TRUE) ; // Wait while the other process runs } void leave_region (int process) { interested[process] = FALSE; // I’m no longer interested }

Συγχρονισμός μέσω υλικού Οι προηγούμενες μέθοδοι είναι σύνθετες και δαπανούν χρόνο CPU. Λύσεις υλικού: Test & set: δοκιμή και θέση μίας μεταβλητής με μία εντολή. Ατομική εναλλαγή (swap): μεταγωγή καταχωρητών & μνήμης με μία εντολή. Απενεργοποίηση διακοπών: Η διεργασία δεν χάνει τον έλεγχο της CPU εκτός εάν το αιτηθεί η ίδια.

Αμοιβαίος αποκλεισμός μέσω υλικού Μοναδική διαμοιραζόμενη μεταβλητή κλειδώματος Απαιτεί ενεργό αναμονή. Εφαρμόσιμη στην περίπτωση πολλαπλών διεργασιών Πιθανό πρόγραμμα Σε συγκεκριμένα σενάρια εκτέλεσης οι διεργασίες μπορούν να οδηγηθούν σε αέναη αναμονή. int lock = 0; Code for process Pi while (1) { while (TestAndSet(lock)) ; // critical section lock = 0; // remainder of code }

Εξάλειψη της ενεργούς αναμονής Πρόβλημα: οι παραπάνω λύσεις δαπανούν CPU χρόνο Οι λύσεις υλικού και λογισμικού απαιτούν spin locks. Χρήση μηνυμάτων απενεργοποίησης (sleep) κατά την διάρκεια αναμονής. Πρόβλημα: priority inversion (οι διεργασίες με υψηλότερη προτεραιότητα περιμένουν αυτές με την χαμηλότερη) Λύση: Χρήση σημαφορέων (semaphores) Μηχανισμός συγχρονισμού που δεν απαιτεί ενεργό αναμονή. Υλοποίηση Ο σημαφορέας S προσπελαύνεται με δύο ατομικές λειτουργίες Down(S): while (S<=0) {}; S-= 1; Up(S): S+=1; Down() ή for P() Up() ή V() Αναγκή για υλοποίηση που να μην προϋποθέτει busy wait στην κλήση Down()

Σημαφορείς και κρίσιμες περιοχές Shared variables Semaphore mutex; Code for process Pi while (1) { down(mutex); // critical section up(mutex); // remainder of code }

Σημαφορείς με blocking Δύο λειτουργίες: Sleep(): απενεργοποιεί την τρέχουσα διεργασία Wakeup(P): επιτρέπει στην διεργασία P να ξαναλειτουργήσει. Semaphore : class Τιμή παρακολούθησης του σημαφορέα Λίστα διεργασιών που αναμένουν για το σημαφορέα Ατομικές ενέργειες Semaphore code Semaphore::down () { value -= 1; if (value < 0) { // add this process to pl Sleep (); } Semaphore::up () { Process P; value += 1; if (value <= 0) { // remove a process P // from pl Wakeup (P); class Semaphore { int value; ProcessList pl; void down (); void up (); };

Σημαφορείς για γενικό συγχρονισμό Θέλουμε να εκτελέσουμε το B στην P1 μόνο μετά την εκτέλεση του A στην P0 Χρήση ενός σημαφορέα που αρχικοποιείται στο 0 Χρήση του up() για να αφυπνιστεί η P1 τον κατάλληλο χρόνο. Shared variables // flag initialized to 0 Semaphore flag; Process P0 . // Execute code for A flag.up (); Process P1 . flag.down (); // Execute code for B

Τύποι σημαφορέων Δύο διαφορετικοί τύποι σημαφορέων Counting semaphore Counting semaphores Binary semaphores Counting semaphore Η τιμή μπορεί να αυξάνεται απεριόριστα Binary semaphore Μόνο δύο τιμές είναι δυνατές 1 semaphore διαθέσιμος 0 διεργασία έχει δεσμεύσει τον σημαφορέα

Monitors Ενας monitor είναι ένας μηχανισμός συγχρονισμού υψηλού επιπέδου Ενας monitor έχει πολλαπλά σημεία εισόδου (entry points) Μόνο μία διεργασία μπορεί να δεσμεύσει τον monitor ανά πάσα στιγμή. Επιβάλλει αμοιβαίο αποκλεισμό Οι monitors παρέχονται από γλώσσες υψηλού επιπέδου Οι μεταβλητές προστατεύονται από ταυτόχρονη πρόσβαση Οι διαδικασίες (Procedures) στο monitor διαθέτουν αμοιβαίο αποκλεισμό. Υλοποίηση Monitor Η υλοποίηση εξαρτάται από την γλώσσα προγραμματισμού και τον compiler Εσωτερικά χρησιμοποιούνται semaphores

Χρήση Monitor monitor mon { int foo; int bar; double arr[100]; void proc1(…) { } void proc2(…) { void mon() { // initialization code }; Οι μεταβλητές foo, bar και arr είναι προσβάσιμες μόνο από τις proc1 και proc2 Μόνο μία διεργασία μπορεί να εκτελείται είτε στο proc1 ή στο proc2 την ίδια στιγμή.