Σημειώσεις Εργαστηρίου - Ασκήσεις. Διδάσκων: Κωνσταντίνος Αντωνής Επίκουρος Καθηγητής Δρ. Μηχανικός Η/Υ & Πληροφορικής Πανεπιστημίου Πατρών

Transcript

1 ΠΑΝΕΠΙΣΤΗΜΙΟ ΘΕΣΣΑΛΙΑΣ ΣΧΟΛΗ ΘΕΤΙΚΩΝ ΕΠΙΣΤΗΜΩΝ ΤΜΗΜΑ ΠΛΗΡΟΦΟΡΙΚΗΣ ΕΡΓΑΣΤΗΡΙΟ ΜΑΘΗΜΑΤΟΣ «ΛΕΙΤΟΥΡΓΙΚΑ ΣΥΣΤΗΜΑΤΑ» Σημειώσεις Εργαστηρίου - Ασκήσεις Διδάσκων: Κωνσταντίνος Αντωνής Επίκουρος Καθηγητής Δρ. Μηχανικός Η/Υ & Πληροφορικής Πανεπιστημίου Πατρών Λαμία, Μάρτιος

2 Περιεχόμενα 1 Διεργασίες Θέτοντας και επιστρέφοντας την τιμή της προτεραιότητας διεργασίας Χρησιμοποιώντας την κλήση συστήματος fork() Χρησιμοποιώντας την οικογένεια των κλήσεων συστήματος exec() Συναρτήσεις execl() Συναρτήσεις execv() Καθορίζοντας περιορισμούς στις συναρτήσεις exec() Η συνάρτηση wait () Η συνάρτηση getpid () Διαβάζοντας και αναθέτοντας τιμές σε περιβαλλοντικές μεταβλητές Χρησιμοποιώντας την system() για τη δημιουργία διεργασιών Οι κλήσεις συστήματος exit (), kill () και abort () Ασκήσεις Άσκηση 1η Άσκηση 2η Άσκηση 3 η Κοινή μνήμη στο POSIX Συναρτήσεις Ασκήσεις Άσκηση 1 η Άσκηση 2 η Άσκηση 3η Νήματα στο POSIX Διαχείριση Νημάτων Συγχρονισμός Νημάτων Συγχρονισμός Νημάτων με Σημαφόρους Μεταβλητές Συνθήκης Χρονοπρογραμματισμός νημάτων Πεδίο ανταγωνισμού διεργασιών Χρονοπρογραμματισμός στο Pthread Ασκήσεις Άσκηση 1 η Άσκηση 2 η Άσκηση 3 η

3 3

4 1 Διεργασίες 1.1 Θέτοντας και επιστρέφοντας την τιμή της προτεραιότητας διεργασίας Το επίπεδο προτεραιότητας μιας διεργασίας μπορεί να αλλάξει με χρήση της συνάρτησης nice. Κάθε διεργασία διαθέτει μια τιμή που καλείται nice που χρησιμοποιείται για να υπολογίζει το επίπεδο προτεραιότητας της καλούμενης διεργασίας. Μία διεργασία κληρονομεί την προτεραιότητα της διεργασίας που τη δημιούργησε. Η προτεραιότητα μιας διεργασίας μπορεί να υποβαθμιστεί αυξάνοντας την τιμή nice. Μόνο οι διεργασίες διαχειριστή και πυρήνα μπορούν να αναβαθμίσουν την προτεραιότητά τους. Η δήλωση της συνάρτησης nice είναι η εξής: #include <unistd.h> int nice(int incr); Μια χαμηλή τιμή της nice αυξάνει το επίπεδο προτεραιότητας της διεργασίας. Η παράμετρος incr είναι η τιμή που προστίθεται στην τρέχουσα τιμή της nice για την καλούμενη διεργασία. Η παράμετρος incr μπορεί να είναι αρνητική ή θετική. Η τιμή της nice όμως είναι μη αρνητικός αριθμός. Η θετική τιμή του incr αυξάνει την τιμή της nice, άρα μειώνει το επίπεδο προτεραιότητας. Μια αρνητική τιμή του incr θα μειώσει την τιμή της nice, αυξάνοντας έτσι την προτεραιότητα. Εάν η τιμή της incr τροποποιήσει την τιμή της nice πάνω ή κάτω από τα όρια, τότε η τιμή της nice τίθεται στο υψηλότερο ή χαμηλότερο όριο, αντίστοιχα. Όταν επιστρέφει επιτυχώς η συνάρτηση nice επιστρέφει τη νέα τιμή nice της διεργασίας. Αν δεν επιστρέψει με επιτυχία, η συνάρτηση θα επιστρέψει 1 και η τιμή της nice δεν αλλάζει. #include <sys/resource.h> int getpriority(int which, id_t who); int setpriority(int which, id_t who, int value); Η συνάρτηση setpriority θέτει την τιμή nice μιας διεργασίας, μιας ομάδας διεργασιών ή ενός χρήστη. Η συνάρτηση getpriority επιστρέφει την προτεραιότητα μιας διεργασίας, μιας ομάδας διεργασιών ή ενός χρήστη. Η παράμετρος which καθορίζει μια διεργασία, μια ομάδα διεργασιών ή ένα χρήστη. Μπορεί να πάρει τις ακόλουθες τιμές: PRIO_PROCESS, καθορίζει μια διεργασία PRIO_PGRP, καθορίζει μια ομάδα διεργασιών PRIO_USER, καθορίζει ένα χρήστη Με βάση την τιμή της παραμέτρου which, η τιμή της παραμέτρου who είναι ο αριθμός που αντιστοιχεί στην ταυτότητα (id number) μιας διεργασίας, μιας ομάδας διεργασιών ή ενός χρήστη. Η τιμή 0 της who υποδεικνύει την τρέχουσα διεργασία, την τρέχουσα ομάδα διεργασιών ή τον τρέχοντα χρήστη. Η τιμή της παραμέτρου value για τη συνάρτηση setpriority θα είναι η νέα τιμή της nice για τη συγκεκριμένη διεργασία, ομάδα διεργασιών ή χρήστη. Η τιμή της nice σε ένα περιβάλλον UNIX κινείται από 20 έως 19. Σε αντίθεση με τη συνάρτηση nice η τιμή που περνιέται στη setpriority είναι η πραγματική τιμή της nice που θέλουμε και όχι κάποιο offset που πρόκειται να προστεθεί στην τρέχουσα τιμή της nice. 4

5 Σε μια διεργασία με πολλαπλά νήματα, η τροποποίηση της προτεραιότητας θα επηρεάσει την προτεραιότητα όλων των νημάτων αυτής της διεργασίας. Σε περίπτωση επιτυχίας η getpriority θα επιστρέψει την τιμή nice για τη συγκεκριμένη διεργασία. Σε περίπτωση επιτυχίας η setpriority θα επιστρέψει την τιμή 0. Σε περίπτωση αποτυχίας και οι δύο συναρτήσεις επιστρέφουν την τιμή 1. Η τιμή 1 είναι μια νόμιμη τιμή nice για μία διεργασία. Για να αποφασιστεί εάν έχει συμβεί κάποιο σφάλμα πρέπει να ελεγχθεί η εξωτερική μεταβλητή errno. 1.2 Χρησιμοποιώντας την κλήση συστήματος fork() Η κλήση συστήματος fork() δημιουργεί μια νέα διεργασία ως αντίγραφο της διεργασίας που εκτελεί την κλήση και καλείται γονική. Η fork επιστρέφει δύο τιμές εφόσον εκτελεστεί επιτυχώς, μία στη γονική διεργασία και μία στη θυγατρική διεργασία. Επιστρέφει 0 στην θυγατρική διεργασία και την ταυτότητα της νέας διεργασίας (PID) στην γονική διεργασία. Οι δύο διεργασίες συνεχίζουν να εκτελούνται από την επόμενη από την fork εντολή του προγράμματος. Εάν η fork αποτύχει, που σημαίνει ότι καμία θυγατρική διεργασία δεν δημιουργήθηκε, επιστρέφεται -1 στην γονική διεργασία. #include <unistd.h> pid_t fork(void); Η fork () θα αποτύχει εφόσον το σύστημα δεν διαθέτει τους απαραίτητους πόρους για τη δημιουργία μιας άλλης διεργασίας. Εάν υπάρχει όριο στον αριθμό των διεργασιών που μια διεργασία μπορεί να δημιουργήσει ή υπάρχει όριο στον αριθμό των διεργασιών σε όλη την έκταση του συστήματος και το όριο αυτό έχει παραβιαστεί, η fork () θα αποτύχει. Στην περίπτωση αυτή το errno παίρνει την τιμή που δείχνει το ακριβές σφάλμα. 1.3 Χρησιμοποιώντας την οικογένεια των κλήσεων συστήματος exec() H οικογένεια των συναρτήσεων exec() αντικαθιστά την εικόνα της διεργασίας που κάνει την κλήση, με μία νέα εικόνα διεργασίας. Η fork () δημιουργεί μια νέα διεργασία ως πιστό αντίγραφο της γονικής διεργασίας, ενώ η συνάρτηση exec() αντικαθιστά την εικόνα της διεργασίας αντίγραφο με μία νέα. Η εικόνα της νέας διεργασίας είναι ένα κανονικό εκτελέσιμο αρχείο εκτελείται αμέσως. Το εκτελέσιμο μπορεί να καθοριστεί είτε σαν μονοπάτι είτε σαν όνομα αρχείου. Οι συναρτήσεις αυτές μπορούν να περάσουν ορίσματα γραμμής εντολής στη νέα διεργασία. Περιβαλλοντικές μεταβλητές μπορούν επίσης να καθοριστούν. Δεν υπάρχει επιστρεφόμενη τιμή εφόσον η συνάρτηση αποτύχει επειδή η εικόνα της διεργασίας που έκανε την κλήση γράφεται από πάνω. Σε περίπτωση αποτυχίας επιστρέφεται -1 στη διεργασία που έκανε την κλήση exec(). Όλες οι exec () συναρτήσεις μπορούν να αποτύχουν κάτω από τις ακόλουθες συνθήκες: Απαγορεύεται η πρόσβαση στο εκτελέσιμο αρχείο Το αρχείο δεν υπάρχει Το αρχείο δεν είναι εκτελέσιμο Υπάρχουν προβλήματα με συμβολικούς συνδέσμους, δηλαδή όταν υπάρχει επανάληψη κατά τη χρήση συμβολικών συνδέσμων κατά την ανάλυση του 5

6 μονοπατιού προς το εκτελέσιμο αρχείο, ή οι συμβολικοί σύνδεσμοι κάνουν το μονοπάτι προς το εκτελέσιμο αρχείο να είναι πολύ μεγάλο. Οι συναρτήσεις exec() χρησιμοποιούνται μαζί με την fork(). Η fork() δημιουργεί και αρχικοποιεί μία θυγατρική διεργασία αντιγράφοντας την γονική. Η θυγατρική διεργασία τότε αντικαθιστά την εικόνα της εκτελώντας μια exec(). Το παρακάτω παράδειγμα δείχνει τη χρήση του συνδυασμού των fork και exec. // RtValue = fork(); if(rtvalue == 0) execl( /path/direct, direct,. ); Στο παραπάνω παράδειγμα η συνάρτηση fork() καλείται και επιστρέφει μια τιμή που αποθηκεύεται στην μεταβλητή RtValue. Εάν η RtValue έχει την τιμή 0, τότε μιλάμε για τη θυγατρική διεργασία. Η execl() συνάρτηση καλείται τότε. Η πρώτη παράμετρος είναι το μονοπάτι προς το εκτελέσιμο αρχείο, η δεύτερη παράμετρος είναι η εντολή εκτέλεσης, και η τρίτη παράμετρος είναι το όρισμα. Το direct είναι ένα πρόγραμμα που εμφανίζει σε λίστα όλους τους καταλόγους και τους υποκαταλόγους ενός δοθέντος καταλόγου. Υπάρχουν έξι (6) παραλλαγές συναρτήσεων exec(), όπου καθεμία έχει τον δικό της τρόπο κλήσης και χρήση Συναρτήσεις execl() Οι συναρτήσεις execl(), execle() execlp() περνούν το όρισμα της γραμμής εντολής σαν λίστα. Ο αριθμός των ορισμάτων γραμμής εντολής πρέπει να είναι γνωστός κατά την ώρα της μετάφρασης ώστε να είναι χρήσιμες αυτές οι συναρτήσεις. int execl (const char *path, const char *arg0, /*, (char *) 0 */); path είναι το μονοπάτι προς το εκτελέσιμο πρόγραμμα. Μπορεί να καθοριστεί είτε σαν απόλυτο μονοπάτι είτε σαν σχετικό μονοπάτι με βάση τον τρέχοντα κατάλογο. Τα επόμενα ορίσματα είναι η λίστα των ορισμάτων του εκτελέσιμου προγράμματος από το arg0 έως το argn. Μπορούν να υπάρχουν μέχρι n ορίσματα. Το τέλος της λίστας ακολουθείται από ένα δείκτη NULL. int execle (const char *path, const char *arg0, /*, (char *) 0 *, char *const envp[] */); Η συνάρτηση αυτή είναι ακριβώς ίδια με την execl με τη μόνη διαφορά ότι παίρνει μία επιπλέον παράμετρο, την envp[]. Η παράμετρος περιέχει το νέο περιβάλλον για τη νέα διεργασία. Η envp[] είναι ένας δείκτης σε ένα πίνακα που τερματίζεται με null και περιέχει strings που τερματίζονται με null. Κάθε string είναι της μορφής: name = value, όπου name είναι το όνομα της μεταβλητής περιβάλλοντος και value είναι το string που πρέπει να αποθηκευτεί. Η envp[] μπορεί να καθοριστεί με τον ακόλουθο τρόπο: char *const envp[]= PATH=/opt/kde2:/sbin, HOME=/home, NULL; Οι PATH και HOME είναι οι μεταβλητές περιβάλλοντος στην περίπτωση αυτή. int execlp (const char *file, const char *arg0, /*, (char *) 0 */); file είναι το όνομα του εκτελέσιμου προγράμματος. Χρησιμοποιεί την PATH μεταβλητή περιβάλλοντος για να εντοπίσει τα εκτελέσιμα. Τα υπόλοιπα ορίσματα είναι όπως στην execl() συνάρτηση. 6

7 Ακολουθούν μερικά παραδείγματα σύνταξης των execl() συναρτήσεων χρησιμοποιώντας αυτά τα ορίσματα: char *const args[] = direct,., NULL; char *const envp[] = files=50, NULL; execl ( /path/direct, direct,., NULL) ; execle ( /path/direct, direct,., NULL, envp) ; execlp ( direct, direct,., NULL) ; Συναρτήσεις execv() Οι συναρτήσεις execv(), execve() και execvp() περνούν τα ορίσματα γραμμής εντολής σε ένα διάνυσμα δεικτών προς strings που τερματίζουν με NULL. Ο αριθμός των ορισμάτων γραμμής εντολής πρέπει να είναι γνωστός κατά την ώρα της μετάφρασης ώστε να είναι χρήσιμες οι συναρτήσεις αυτές. Το argv[0] είναι συνήθως η εντολή εκτέλεσης. int execv (const char *path, char *const arg[]); path είναι το μονοπάτι προς το εκτελέσιμο αρχείο. Μπορεί να καθοριστεί είτε ως απόλυτο είτε ως σχετικό μονοπάτι ως προς τον τρέχοντα κατάλογο. Το επόμενο όρισμα είναι ένα διάνυσμα που τερματίζεται σε NULL και περιέχει τα ορίσματα γραμμής εντολής σαν strings που τερματίζονται σε NULL. Το arg[] μπορεί να καθοριστεί με τον ακόλουθο τρόπο: char *const arg[]= traverse,., >, 1000, NULL; Παρακάτω φαίνεται ένα παράδειγμα κλήσης της execv(): execv ( traverse, arg); Στην περίπτωση αυτή το πρόγραμμα traverse εμφανίζει σε λίστα όλα τα αρχεία του τρέχοντος καταλόγου που είναι μεγαλύτερα από 1000 bytes. int execve (const char *path, char *const arg[], char *const envp[]); Η συνάρτηση αυτή είναι ίδια ακριβώς με την execv, εκτός του ότι περιέχει μια επιπλέον παράμετρο, την envp[], που έχει περιγραφεί προηγουμένως. int execvp (const char *file, char *const arg[]); file είναι το όνομα του εκτελέσιμου προγράμματος. Το επόμενο όρισμα είναι ένα διάνυσμα που τερματίζεται σε NULL και περιέχει τα ορίσματα γραμμής εντολής σαν strings που τερματίζονται σε NULL. Παρακάτω υπάρχουν παραδείγματα σύνταξης των εντολών execv() που χρησιμοποιούν αυτά τα ορίσματα: char *const arg[]= traverse,., >, 1000, NULL; char *const envp[]= files=50, NULL ; execv( /path/traverse, arg) ; execve( /path/traverse, arg, envp) ; execvp( traverse, arg) ; Σε κάθε ένα από τα παραπάνω παραδείγματα κάθε execv() συνάρτηση δημιουργεί μια διεργασία που εκτελεί το πρόγραμμα traverse. 7

8 1.3.3 Καθορίζοντας περιορισμούς στις συναρτήσεις exec() Υπάρχει ένα όριο στο μέγεθος των argv[] και envp[] που μπορούν να περαστούν στις συναρτήσεις exec(). Η συνάρτηση sysconf() μπορεί να χρησιμοποιηθεί για να καθοριστεί το μέγιστο μέγεθος των ορισμάτων γραμμής εντολής καθώς και το μέγεθος των περιβαλλοντικών παραμέτρων για τις exec() συναρτήσεις που δέχονται την παράμετρο envp[]. Για να επιστρέψει το μέγεθος, η name πρέπει να έχει την τιμή _SC_ARG_MAX. #include <unistd.h> long sysconf(int name); Ένας άλλος περιορισμός όταν χρησιμοποιείται η exec () και οι άλλες συναρτήσεις που δημιουργούν διεργασίες είναι ο μέγιστος αριθμός των ταυτόχρονων διεργασιών που επιτρέπονται ανά ταυτότητα χρήστη. Για να επιστρέψει αυτό τον αριθμό η name πρέπει να έχει την τιμή _SC_CHILD_MAX. 1.4 Η συνάρτηση wait () Όπως αναφέρθηκε παραπάνω η κλήση συστήματος exec() φορτώνει ένα δυαδικό αρχείο στη μνήμη (καταστρέφοντας την εικόνα του προγράμματος που περιέχει την κλήση συστήματος exec() στη μνήμη) και ξεκινάει την εκτέλεσή του. Με αυτόν τον τρόπο, οι δύο διεργασίες (γονική και θυγατρική) είναι ικανές να επικοινωνήσουν και μετά να ακολουθήσουν διαφορετική πορεία. Η γονική διεργασία μπορεί στη συνέχεια να δημιουργήσει περισσότερες θυγατρικές, ή αν δεν έχει τίποτε άλλο να κάνει όσο οι θυγατρικές διεργασίες τρέχουν, μπορεί να καλέσει μία κλήση συστήματος wait() για να μεταφέρει τον εαυτό του έξω από την ουρά ετοιμότητας, μέχρι τον τερματισμό των θυγατρικών διεργασιών. Έτσι η γονική διεργασία περιμένει τη θυγατρική διεργασία να ολοκληρωθεί με την κλήση συστήματος wait(). Όταν η θυγατρική διεργασία ολοκληρωθεί (με έμμεση ή ρητή κλήση της exit()) η γονική διεργασία επανενεργοποιείται από την κλήση της wait(), ενώ ολοκληρώνεται χρησιμοποιώντας την κλήση συστήματος exit(). Κατά την ολοκλήρωσή της η θυγατρική διεργασία μπορεί να επιστρέψει μία τιμή κατάστασης (τυπικά έναν ακέραιο) στην γονική της διεργασία (μέσω της κλήσης συστήματος wait()). Όλοι οι πόροι της διεργασίας συμπεριλαμβανομένων της φυσικής και εικονικής μνήμης, των ανοιχτών αρχείων και των buffers Ε/Ε επανακτώνται από το λειτουργικό σύστημα. Όταν η γονική διεργασία πρέπει να περιμένει για την ολοκλήρωση της θυγατρικής της, τότε η παράμετρος της wait() είναι Η συνάρτηση getpid () Η συνάρτηση αυτή μας επιστρέφει την ταυτότητα της τρέχουσας διεργασίας (process id). Αν μας ενδιαφέρει η ταυτότητα της διεργασίας πατέρα της τρέχουσας διεργασίας, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση getppid(). 1.6 Διαβάζοντας και αναθέτοντας τιμές σε περιβαλλοντικές μεταβλητές Οι περιβαλλοντικές μεταβλητές είναι strings που τερματίζονται με NULL και αποθηκεύουν πληροφορίες που εξαρτώνται από το σύστημα, όπως είναι τα μονοπάτια σε καταλόγους που περιέχουν εντολές, βιβλιοθήκες, και διαδικασίες που χρησιμοποιούνται από διεργασίες. Μπορούν επίσης να χρησιμοποιηθούν για να μεταδώσουν χρήσιμες πληροφορίες που ορίζονται από το χρήστη από τη γονική προς 8

9 τη θυγατρική διεργασία. Παρέχουν ένα μηχανισμό για την παροχή συγκεκριμένων πληροφοριών σε διεργασία χωρίς να χρειάζεται αυτές να περαστούν μέσα από τον κώδικα. Οι μεταβλητές αυτές είναι προκαθορισμένες και κοινές σε όλα τα κελύφη διεργασίες στο σύστημα αυτό. Οι μεταβλητές αυτές αρχικοποιούνται από τα αρχεία εκκίνησης. Παρακάτω φαίνονται μερικές κοινές μεταβλητές συστήματος: $HOME $PATH $MAIL $USER $SHELL $TERM το απόλυτο μονοπάτι που οδηγεί στο βασικό κατάλογο μια λίστα από καταλόγους για την αναζήτηση εντολών το απόλυτο μονοπάτι του γραμματοκιβωτίου η ταυτότητα του χρήστη το απόλυτο μονοπάτι του κελύφους ο τύπος του τερματικού Μπορούν να αποθηκευτούν σε ένα αρχείο ή σε μια λίστα που θα περιέχει τις μεταβλητές περιβάλλοντος. Η λίστα αυτή θα περιέχει δείκτες σε strings που τερματίζονται σε NULL. Η μεταβλητή: extern char *environ δείχνει στην παραπάνω λίστα όταν η διεργασία αρχίσει να εκτελείται. Τα strings αυτά έχουν τη μορφή: name = value, όπως εξηγήθηκε νωρίτερα. Οι διεργασίες που αρχικοποιούνται με τις συναρτήσεις execl(), execlp(), execv(), execvp() κληρονομούν το περιβάλλον της γονικής διεργασίας. Οι διεργασίες που αρχικοποιούνται με τις συναρτήσεις execve() και execle() καθορίζουν το περιβάλλον της νέας διεργασίας. Υπάρχουν συναρτήσεις και προγράμματα που μπορούν να κληθούν για να ερευνηθούν, να προστεθούν ή να τροποποιηθούν τέτοιες μεταβλητές. Η getenv() χρησιμοποιείται για να αποφασιστεί εάν μια συγκεκριμένη μεταβλητή έχει πάρει τιμή. Η παράμετρος name περιέχει το όνομα της μεταβλητής στην οποία γίνεται η αναφορά. Η συνάρτηση θα επιστρέψει NULL εάν η συγκεκριμένη μεταβλητή δεν έχει πάρει τιμή. Εάν η μεταβλητή έχει πάρει τιμή, η συνάρτηση θα επιστρέψει ένα δείκτη σε ένα string που περιέχει την τιμή. Δηλαδή, η σύνταξη των χρήσιμων εδώ συναρτήσεων είναι η παρακάτω: #include <stdlib.h> char *getenv(const char *name); int setenv(const char *name, const char *value, int overwrite); void unsetenv(const char *name); Για παράδειγμα: char *Path; Path = getenv( PATH ); Το string Path παίρνει την τιμή που περιέχεται στην προκαθορισμένη μεταβλητή PATH. Η setenv() χρησιμοποιείται για να αλλάξει ή να προσθέσει μια μεταβλητή στο περιβάλλον της καλούσας διεργασίας. Η παράμετρος name περιέχει το όνομα της μεταβλητής που πρέπει να αλλάξει ή να πάρει τιμή. Παίρνει την τιμή που έχει η παράμετρος value. Εάν η παράμετρος overwrite έχει μη μηδενική τιμή τότε γίνεται αλλαγή τιμής. Αντίθετα, αν η overwrite έχει τιμή 0, το περιεχόμενο της μεταβλητής περιβάλλοντος δεν μεταβάλλεται. Η setenv() επιστρέφει 0 όταν ολοκληρωθεί 9

10 επιτυχώς και -1 διαφορετικά. Η unsetenv() διαγράφει την τιμή της μεταβλητής που περιέχεται στην παράμετρο name. 1.7 Χρησιμοποιώντας την system() για τη δημιουργία διεργασιών Η συνάρτηση system() χρησιμοποιείται για να τρέξει μια εντολή ή ένα εκτελέσιμο πρόγραμμα. Η system() προκαλεί την εκτέλεση της δυάδας fork - exec και ενός κελύφους (shell). Η system() εκτελεί ένα fork και η θυγατρική διεργασία καλεί μία exec() με ένα κέλυφος που εκτελεί τη δοσμένη εντολή ή πρόγραμμα. Η σύνταξή της είναι η παρακάτω: #include <stdlib.h> int system(const char *string); H παράμετρος string μπορεί να είναι μια εντολή συστήματος, ή το όνομα ενός εκτελέσιμου αρχείου. Εάν ολοκληρωθεί επιτυχώς, η συνάρτηση επιστρέφει την κατάσταση τερματισμού της εντολής ή την τιμή του προγράμματος (αν το πρόγραμμα επιστρέφει κάποια). Σφάλματα μπορεί να συμβούν σε αρκετά επίπεδα, π.χ. η fork() ή η exec() μπορεί να παρουσιάσουν σφάλμα ή το κέλυφος μπορεί να μην μπορεί να εκτελέσει την συγκεκριμένη εντολή ή το πρόγραμμα. Η συνάρτηση επιστρέφει μια τιμή στην γονική διεργασία. Η συνάρτηση επιστρέφει 127 εάν αποτύχει η exec() και -1 εάν συμβεί κάποιο άλλο σφάλμα. 1.8 Οι κλήσεις συστήματος exit (), kill () και abort () Υπάρχουν δύο συναρτήσεις που μία διεργασία μπορεί να καλέσει για να τερματίσει, οι exit () και abort (). Η exit () συνάρτηση προκαλεί τερματισμό της διεργασίας με κανονικό τρόπο. Όλα τα ανοικτά αρχεία που σχετίζονται με τη διεργασία κλείνουν. Η συνάρτηση πετά όλες τις ανοικτές ροές που περιέχουν δεδομένα που δεν έχουν αποθηκευτεί σε προσωρινό αποθηκευτικό χώρο, και κλείνει τις ροές αυτές. Η παράμετρος status αντιπροσωπεύει την κατάσταση εξόδου της διεργασίας. Επιστρέφεται στην γονική διεργασία που βρίσκεται σε αναμονή, η οποία και επανεκκινείται. Η τιμή της status μπορεί να είναι 0, EXIT_FAILURE, ή ΕΧΙΤ_SUCCESS. Η τιμή 0 σημαίνει ότι η διεργασία τερματίστηκε επιτυχώς. Η γονική διεργασία που βρίσκεται σε αναμονή έχει πρόσβαση όνο στα 8 λιγότερης σημαντικότητας bits της status. Εάν η γονική διεργασία δεν περιμένει για τη διεργασία να ολοκληρωθεί, η διεργασία αυτή υιοθετείται από την διεργασία init. Η συνάρτηση abort () προκαλεί τον μη κανονικό τερματισμό της καλούσας διεργασίας. Ένας μη κανονικός τερματισμός της διεργασίας προκαλεί το ίδιο αποτέλεσμα με την fclose () σε όλες τις ανοικτές ροές. Η γονική διεργασία που βρίσκεται σε αναμονή θα λάβει ένα σήμα ότι η θυγατρική της διεργασίας τερματίστηκε μη κανονικά. Μια διεργασία πρέπει να τερματίζει με αυτόν τον τρόπο μόνο εφόσον συμβεί κάποιο λάθος το οποίο δεν μπορεί να αντιμετωπιστεί προγραμματιστικά. #include <stdlib.h> void exit (int status); void abort (void); Η συνάρτηση kill () μπορεί να χρησιμοποιηθεί για να προκαλέσει τον τερματισμό μιας άλλης διεργασίας. Η συνάρτηση kill () στέλνει ένα σήμα στη συγκεκριμένη 10

11 διεργασία που έχει καθοριστεί ή κατέχει την παράμετρο pid. Η παράμετρος sig είναι το σήμα που στέλνεται στην καθορισμένη διεργασία. Τα σήματα βρίσκονται στο header file <signal.h>. Για να τερματιστεί μια διεργασία μέσω της kill (), η παράμετρος sig πρέπει να έχει την τιμή SIGKILL. Η καλούσα διεργασία πρέπει να έχει το απαραίτητο δικαίωμα για να στείλει ένα σήμα σε μία διεργασία, ή κατέχει ένα πραγματικό ή αποτελεσματικό user id που ταιριάζει με το πραγματικό ή το αποθηκευμένο user id της διεργασίας που λαμβάνει το σήμα. Η καλούσα διεργασία μπορεί να έχει το δικαίωμα να στέλνει μόνο συγκεκριμένα σήματα σε διεργασίες και όχι άλλα. Εάν η συνάρτηση αποστείλει το σήμα επιτυχώς, επιστρέφεται 0 στην καλούσα διεργασία. Εάν αποτύχει, επιστρέφεται -1. Η καλούσα διεργασία μπορεί να στείλει το σήμα σε μία ή περισσότερες διεργασίες κάτω από τις ακόλουθες συνθήκες: pid > 0 To σήμα θα σταλεί στη διεργασία της οποίας το PID είναι ίσο με το pid. pid = 0 Το σήμα θα σταλεί σε όλες τις διεργασίες των οποίων η ταυτότητα της ομάδας διεργασιών (group id) είναι ίδια με αυτή της καλούσας διεργασίας. pid = -1 το σήμα θα σταλεί σε όλες τις διεργασίες για τις οποίες η καλούσα διεργασία έχει δικαίωμα να αποστείλει αυτό το σήμα. pid < -1 Το σήμα θα αποσταλεί σε όλες τις διεργασίες των οποίων η ταυτότητα της ομάδας διεργασιών (group id) είναι ίση με την απόλυτη τιμή του pid και για την οποία η καλούσα διεργασία έχει δικαίωμα να αποστείλει το σήμα. #include <signal.h> int kill (pid_t pid, int sig); Το Pthreads του POSIX παρέχει επίσης τη συνάρτηση pthread_kill(pthread_t tid, int signal), η οποία επιτρέπει σε ένα σήμα να παραδοθεί σε ένα συγκεκριμένο νήμα (tid). 1.9 Ασκήσεις Άσκηση 1η Να κατασκευάσετε ένα πρόγραμμα το οποίο δημιουργεί μια νέα διεργασία. Η θυγατρική διεργασία θα δημιουργεί ένα νέο κατάλογο και θα τοποθετεί εκεί ένα αρχείο που θα περιέχει το αποτέλεσμα της εκτέλεσης της εντολής ps -Α. Η γονική διεργασία στο μεταξύ θα περιμένει. Μόλις ολοκληρωθεί η διεργασία παιδί, η γονική διεργασία θα διαβάζει το αρχείο αυτό και χρησιμοποιώντας την ταυτότητα κάθε διεργασίας θα προσπαθεί να βρει ποιες είναι οι προτεραιότητες των διεργασιών στο σύστημα και θα τις ταξινομεί με φθίνουσα σειρά (από την πιο υψηλή προς την πιο χαμηλή). Αν υπάρχει σύμπτωση προτεραιοτήτων, πρώτη θα μπαίνει η διεργασία με τη μικρότερη ταυτότητα. Η υλοποίηση της άσκησης θα γίνει ως εξής: το όνομα του καταλόγου και του αρχείου που θα κατασκευαστούν θα δίνονται από τη γραμμή εντολής. Αν χρησιμοποιηθούν πίνακες πρέπει να είναι δυναμικοί και σε καμιά περίπτωση στατικοί. Για το λόγο αυτό να χρησιμοποιηθούν οι γνωστές συναρτήσεις δέσμευσης μνήμης malloc και realloc. Επίσης, το πρόγραμμα που θα κατασκευαστεί θα πρέπει να κάνει έλεγχο λαθών κατά τη σύνταξη της εντολής με κατάλληλη έκδοση διαγνωστικών μηνυμάτων. 11

12 1.9.2 Άσκηση 2η Να κατασκευάσετε ένα πρόγραμμα στο οποίο μια διεργασία αφού ελέγχει την τιμή της προτεραιότητάς της, αν αυτή είναι μικρότερη από το 8, τότε θα την υποβαθμίζει σε 8. Έπειτα ελέγχει ποιος είναι ο βασικός της κατάλογος, κατασκευάζει ένα κατάλογο με όνομα temp, στη συνέχεια βρίσκει τις πληροφορίες για τα περιεχόμενα του βασικού της καταλόγου και αποθηκεύει τα δεδομένα σε ένα αρχείο με όνομα contents.txt στον κατάλογο temp. Στη συνέχεια δημιουργεί μία νέα διεργασία. Η θυγατρική διεργασία θα ανοίγει το αρχείο contents.txt και θα διαβάζει τις πληροφορίες για τα αρχεία και τους καταλόγους που περιέχονται στο βασικό κατάλογο. Θα εμφανίζει τα περιεχόμενα χωρισμένα σε δύο στήλες: στην μία οι κατάλογοι και στην άλλη τα αρχεία. Τα δεδομένα θα εμφανίζονται στις στήλες ταξινομημένα με βάση το χρόνο. Στο διάστημα αυτό η πατρική της διεργασία περιμένει την ολοκλήρωσή της Άσκηση 3 η Να κατασκευάσετε ένα πρόγραμμα το οποίο θα εκτελεί μια λειτουργία αναζήτησης. Ο χρήστης θα δίνει στη γραμμή εντολής το όνομα ενός αρχείου που θα περιέχει ένα σύνολο 50 αριθμών, καθώς επίσης και ένα ακέραιο αριθμό. Η βασική σας διεργασία θα δημιουργεί τόσες διεργασίες, όσος είναι ο παραπάνω αριθμός. Πριν όμως δημιουργήσει τις διεργασίες αυτές θα ζητά από το πληκτρολόγιο έναν αριθμό προς αναζήτηση στο σύνολο των παραπάνω αριθμών. Οπότε κάθε μία από τις παραπάνω διεργασίες - παιδιά θα εκτελεί αναζήτηση για τον αριθμό αυτό σε διαφορετικό σύνολο αριθμών από τις άλλες, απαιτείται δηλαδή η διάσπαση του αρχικού συνόλου σε μικρότερα σύνολα. Να δώσετε αριθμό διεργασιών στην είσοδο που να διαιρείται ακριβώς με το 50. Η διεργασία που θα βρει τον αριθμό στο δικό της σύνολο απαντά εμφανίζοντας τον αριθμό της θέσης που τον εντόπισε, καθώς και την ταυτότητά της. Οι διεργασίες που δεν θα βρουν τον αριθμό δεν χρειάζεται να απαντήσουν. Όταν τελειώσουν όλες οι διεργασίες παιδιά, τότε η διεργασία πατέρας τερματίζει. 12

13 2 Κοινή μνήμη στο POSIX 2.1 Συναρτήσεις Αρκετοί μηχανισμοί διαδιεργασιακής επικοινωνίας (IPC) είναι διαθέσιμοι για τα συστήματα POSIX, συμπεριλαμβανομένων της κοινής μνήμης και του περάσματος μηνυμάτων. Εδώ, θα διερευνήσουμε το POSIX API για κοινή μνήμη. Μία διεργασία πρέπει πρώτα να δημιουργήσει ένα τμήμα κοινής μνήμης χρησιμοποιώντας την κλήση συστήματος shmget() (η shmget() προέρχεται από το SΗared Memory GET). Το παράδειγμα που ακολουθεί δείχνει την χρήση της shmget(): segment_id= shmget(ipc_private,size,s_irusr S_IWUSR); Η πρώτη παράμετρος καθορίζει το κλειδί (ή τον αναγνωριστή) του τμήματος (segment) της κοινής μνήμης. Αν έχει την τιμή IPC_PRIVATE, τότε δημιουργείται ένα νέο τμήμα κοινής μνήμης. Η δεύτερη παράμετρος καθορίζει το μέγεθος (σε bytes) του τμήματος της κοινής μνήμης. Τέλος, η τρίτη παράμετρος ορίζει τον τρόπο που θα χρησιμοποιηθεί το τμήμα της κοινής μνήμης δηλαδή για ανάγνωση, εγγραφή ή και τα δύο. Θέτοντας τον τρόπο πρόσβασης σε S_IRUSR S_IWUSR, υποδεικνύουμε ότι ο ιδιοκτήτης μπορεί να διαβάσει ή να γράψει στο τμήμα της κοινής μνήμης. Μία επιτυχημένη κλήση της shmget() επιστρέφει έναν ακέραιο αναγνωριστή για το τμήμα της κοινής μνήμης. Άλλες διεργασίες που θέλουν να χρησιμοποιήσουν αυτήν την περιοχή της κοινής μνήμης πρέπει να προσδιορίσουν αυτόν τον αναγνωριστή. Οι διεργασίες που επιθυμούν να έχουν πρόσβαση στο τμήμα της κοινής μνήμης πρέπει να το επισυνάψουν στο χώρο διευθύνσεών τους, χρησιμοποιώντας την κλήση συστήματος shmat() (SΗared Memory ATtach). Η κλήση της shmat() αναμένει επίσης τρεις παραμέτρους. Η πρώτη είναι ο ακέραιος αναγνωριστής του τμήματος της κοινής μνήμης το οποίο θα επισυναφθεί. Η δεύτερη είναι ένας δείκτης σε μία θέση στη μνήμη που υποδεικνύει που θα επισυναφθεί η κοινή μνήμη. Αν περάσουμε μία τιμή NULL, το λειτουργικό σύστημα επιλέγει την τοποθεσία για λογαριασμό του χρήστη. Η τρίτη παράμετρος καθορίζει μέσω μίας ένδειξης (flag) αν η περιοχή της κοινής μνήμης βρίσκεται σε κατάσταση μόνο-ανάγνωσης ή εγγραφής-ανάγνωσης αν της δώσουμε την τιμή 0, επιτρέπουμε και ανάγνωση και εγγραφή στην κοινή περιοχή. Η τρίτη παράμετρος ορίζει μία ένδειξη τρόπου πρόσβασης. Αν της θέσουμε την τιμή 1, επιτρέπει στην περιοχή κοινής μνήμης να επισυναφθεί με τρόπο πρόσβασης μόνοανάγνωσης αν της τεθεί η τιμή 0, επιτρέπει και ανάγνωση και εγγραφή στην κοινή περιοχή. Επισυνάπτουμε μία περιοχή κοινής μνήμης με χρήση της shmat() ως εξής: shared_memory=(char *) shmat (id, NULL, 0); Μία επιτυχημένη κλήση της shmat() επιστρέφει ένα δείκτη στην αρχική θέση της μνήμης στην οποία έχει επισυναφθεί η περιοχή κοινής μνήμης. Μόλις μία περιοχή κοινής μνήμης επισυναφθεί στο χώρο διευθύνσεων μίας διεργασίας, η διεργασία μπορεί να προσπελάσει την κοινή μνήμη σαν μία συνηθισμένη προσπέλαση μνήμης, χρησιμοποιώντας το δείκτη που επιστράφηκε από την shmat(). Σε αυτό το παράδειγμα, η shmat() επιστρέφει ένα δείκτη προς μία συμβολοσειρά χαρακτήρων. Συνεπώς, θα μπορούσαμε να γράψουμε στην κοινή περιοχή μνήμης όπως παρακάτω: 13

14 sprintf(shared_memory, Writing to shared memory ); Οι ενημερώσεις στο τμήμα της κοινής μνήμης είναι ορατές από όλες τις διεργασίες που μοιράζονται αυτό το τμήμα. Τυπικά, μία διεργασία που χρησιμοποιεί ένα υπάρχον τμήμα κοινής μνήμης πρώτα επισυνάπτει την περιοχή κοινής μνήμης στο χώρο διευθύνσεών της και στη συνέχεια προσπελαύνει (και πιθανόν ενημερώνει) την περιοχή κοινής μνήμης. Όταν μια διεργασία δεν χρειάζεται πια πρόσβαση στο τμήμα της κοινής μνήμης, αποσπά το τμήμα αυτό από το χώρο διευθύνσεών της. Για να αποσπάσει μία περιοχή κοινής μνήμης, η διεργασία μπορεί να περάσει το δείκτη της περιοχής κοινής μνήμης στην κλήση συστήματος shmdt(), όπως παρακάτω: shmdt(shared_memory); Τέλος, ένα τμήμα κοινής μνήμης μπορεί να αφαιρεθεί από το σύστημα με την κλήση συστήματος shmctl(), στην οποία περνιέται ο αναγνωριστής του κοινού τμήματος μαζί με τη σημαία IPC_RMID. Παράδειγμα #include <stdio.h> #include <sys/shm.h> #include <sys/stat.h> int main () /* the identifier for the shared memory segment */ int segment_id; /* a pointer to the shared memory segment */ char *shared_memory; /* the size (in bytes) of the shared memory segment */ const int size = 4096; /* allocate a shared memory segment */ segment_id = shmget(ipc_private, size, S_IRUSR S_IWUSR); /* attach the shared memory segment */ shared_memory = (char *) shmat(segment_id, NULL, 0); /* write a message to the shared memory segment */ sprintf(shared_memory, Hi there! ); /* now print out the string from shared memory */ printf( *%s\n, shared_memory); /* now detach the shared memory segment */ shmdt(shared_memory); /* now remove the shared memory segment */ 14

15 shmctl(segment_id, IPC_RMID, NULL); return 0; 2.2 Ασκήσεις Άσκηση 1 η Η άσκηση αυτή σας ζητά να υλοποιήσετε ένα διαμοιραζόμενο C πρόγραμμα με κατάλληλη χρήση των IPC shared memory calls. Οι κλήσεις αυτές χρησιμοποιούνται για να επιτρέπουν την κοινή χρήση τμημάτων μνήμης από διαφορετικές διεργασίες. Οι διεργασίες θα δημιουργηθούν με χρήση της fork. Η ακολουθία Fibonacci είναι η σειρά αριθμών 0,1,1,2,3,5,8,... Τυπικά, μπορεί να εκφραστεί ως: fib 0 = 0 fib 1 = 1 fib n = fib n-1 + fib n-2 Γράψτε ένα πρόγραμμα σε C χρησιμοποιώντας την κλήση συστήματος fork(), που να παράγει την ακολουθία Fibonacci στη θυγατρική διεργασία. Ο αριθμός της ακολουθίας θα δίνεται στη γραμμή εντολών. Για παράδειγμα, αν δίνεται ο αριθμός 5, οι πρώτοι 5 αριθμοί στην ακολουθία Fibonacci θα παράγονται από τη θυγατρική διεργασία. Κάνετε τη γονική διεργασία να περιμένει τον τερματισμό της θυγατρικής διεργασίας προτού να βγει από το πρόγραμμα. Η θυγατρική διεργασία θα γράφει το αποτέλεσμα στην κοινή μνήμη. Η γονική διεργασία θα διαβάζει την πληροφορία αυτή από την κοινή μνήμη και θα τυπώνει το αποτέλεσμα που έγραψε η θυγατρική διεργασία. Εκτελέστε τον αναγκαίο έλεγχο ώστε να εξασφαλίσετε ότι δεν περνιέται αρνητικός αριθμός στη γραμμή εντολών και ελέγξτε και λάθη σύνταξης κατά την κλήση του προγράμματος Άσκηση 2 η Η άσκηση αυτή σας ζητά να υλοποιήσετε ένα διαμοιραζόμενο C πρόγραμμα με κατάλληλη χρήση των IPC shared memory calls. Οι κλήσεις αυτές χρησιμοποιούνται για να επιτρέπουν την κοινή χρήση τμημάτων μνήμης από διαφορετικές διεργασίες. Οι διεργασίες θα δημιουργηθούν με χρήση της fork. Η βασική διεργασία θα δημιουργεί ένα χώρο κοινής μνήμης. Η διεργασία παιδί θα αναζητά μια λέξη σε ένα αρχείο. Το όνομα του αρχείου στο οποίο θα γίνεται η αναζήτηση και η λέξη θα περνιούνται εξωτερικά από τη γραμμή εντολής. Όταν η διεργασία βρίσκει τη λέξη στο αρχείο θα γράφει στην κοινή μνήμη τον αριθμό της γραμμής που τη βρήκε, αλλιώς -1, ενώ η διεργασία πατέρας αφού διαβάσει τον αριθμό της γραμμής από την κοινή μνήμη θα τυπώνει ολόκληρη τη γραμμή στην οθόνη Άσκηση 3η Η άσκηση αυτή σας ζητά να υλοποιήσετε ένα διαμοιραζόμενο C πρόγραμμα με κατάλληλη χρήση των IPC shared memory calls. Οι κλήσεις αυτές χρησιμοποιούνται για να επιτρέπουν την κοινή χρήση τμημάτων μνήμης από διαφορετικές διεργασίες. Οι διεργασίες θα δημιουργηθούν με χρήση της fork. 15

16 Πολλαπλασιασμός πινάκων με Unix shared memory Υποθέστε Α και Β είναι λ Χ μ και μ Χ ν πίνακες. Το προϊόν τους, C =Α *Β είναι ένας λ Χ ν πίνακας. Η πράξη που θα πρέπει να κάνετε φαίνεται καλύτερα με ένα σχήμα. Μιας και κάθε C [i, j] υπολογίζεται ανεξάρτητα, μπορούμε να χρησιμοποιήσουμε λ Χ ν διεργασίες, κάθε μια από τις οποίες υπολογίζει μια θέση του πίνακα C. Γράψτε δύο προγράμματα main και compute. Το πρώτο παίρνει σαν όρισμα το αρχείο με τους πίνακες και το δεύτερο παίρνει τρία command line arguments, Row, Column, καθώς και τη διεύθυνση κοινής μνήμης που πρέπει να γνωρίζει το πρόγραμμα αυτό ώστε να αποθηκεύσει τον πίνακα C. Το πρόγραμμα main πρέπει να κάνει τα εξής: 1. Να διαβάζει δύο πίνακες Α και Β σε μια κοινή μνήμη. Έστω λ Χ μ και μ Χ ν οι διαστάσεις των δύο πινάκων. 2. Να εκτυπώνει τους δύο πίνακες. 3. Κατόπιν, η main δημιουργεί λ * ν διεργασίες, μια για κάθε είσοδο του προϊόντος πίνακα C = Α * Β. Κάθε μία από τις διεργασίες αυτές τρέχει το πρόγραμμα compute με τα κατάλληλα ορίσματα χρησιμοποιώντας την execvp. 4. Η main περιμένει να τελειώσουν όλες οι άλλες διεργασίες και μετά εκτυπώνει τον πίνακα C. Το πρόγραμμα compute πρέπει να κάνει τα εξής: 1. Όταν το πρόγραμμα compute τρέχει, λαμβάνει έναν αριθμό γραμμής Row και ένας αριθμός στήλης Column από την γραμμή εντολών. 2. Κατόπιν, εκτελεί τον πολλαπλασιασμό της γραμμής με την στήλη και γράφει το αποτέλεσμα στην κατάλληλη θέση του πίνακα C. 3. Μετά από αυτό, πρόγραμμα compute τερματίζει. Το πρόγραμμα main θα λαμβάνει ως είσοδο ένα αρχείο με την εξής μορφή. l m < # of rows and columns of matrix A a11 a12 a13... a1m < row 1 of A 16

17 a21 a22 a23... a2m < row 2 of A... al1 al2 al3... alm < row l of A u v < # of rows and columns of matrix B b11 b12 b13... b1v < row 1 of B b21 b22 b23... b2v < row 2 of B... bu1 bu2 bu3... buv < row u of B 17

18 3 Νήματα στο POSIX 3.1 Διαχείριση Νημάτων H Pthreads αναφέρεται στο πρότυπο POSIX (ΙΕΕΕ c) καθορίζοντας ένα API για τη δημιουργία και το συγχρονισμό των νημάτων. Πρόκειται για μία προδιαγραφή για τη συμπεριφορά των νημάτων και όχι για υλοποίηση. Οι σχεδιαστές των λειτουργικών συστημάτων μπορούν να υλοποιήσουν την προδιαγραφή με οποίο τρόπο επιθυμούν. Πολλά συστήματα, συμπεριλαμβανομένων των Solaris, Linux, Mac OS X και Tru64 UNIX, υλοποιούν την προδιαγραφή Pthreads. Υλοποιήσεις διαμοιραζόμενου λογισμικού (shareware) για τα διάφορα λειτουργικά συστήματα Windows είναι επίσης διαθέσιμες στο ευρύ κοινό. Το πρόγραμμα C που παρουσιάζεται στο παρακάτω σχήμα επιδεικνύει το βασικό API Pthreads για την κατασκευή ενός πολυνηματικού προγράμματος, το οποίο υπολογίζει το άθροισμα ενός μη αρνητικού ακεραίου σε ένα ξεχωριστό νήμα. Σε ένα πρόγραμμα που χρησιμοποιεί το Pthreads, τα ξεχωριστά νήματα ξεκινούν την εκτέλεση σε μία συγκεκριμένη συνάρτηση. Στο σχήμα αυτό πρόκειται για τη συνάρτηση runner(). Όταν ξεκινήσει αυτό το πρόγραμμα, ένα μόνο νήμα ελέγχου ξεκινάει στη main(). Μετά από κάποιες αρχικοποιήσεις, η main() δημιουργεί ένα δεύτερο νήμα που ξεκινάει τον έλεγχο στη συνάρτηση runner(). Και τα δύο νήματα διαμοιράζονται την καθολική μεταβλητή sum. #include <pthread.h> #include <stdio.h> int sum; void *runner(void *param); int main(int argc, char *argv[]) pthread_t tid; pthread_attr_t attr; if (argc!=2) fprintf(stderr, usage: a.out <integer value>\n ); return -1; if (atoi(argv[1]) <0) fprintf(stderr, %d must be >= 0\n, atoi(argv[1])); return -1; pthread_attr_init(&attr); pthread_create(&tid,&attr,runner,argv[1]); 18

19 pthread_join(tid,null); printf( sum=%d\n,sum); void *runner(void *param) int i, upper=atoi(param); sum=0; for(i=1; i<=upper; i++) sum+=i; pthread_exit(0); Σχήμα: Πολυνηματικό πρόγραμμα C που χρησιμοποιεί το API Pthreads Ας δούμε με περισσότερη προσοχή αυτό το πρόγραμμα. Όλα τα προγράμματα Pthreads πρέπει να περιλαμβάνουν το αρχείο επικεφαλίδας pthread.h. Η δήλωση pthread_t tid διακηρύσσει τον αναγνωριστή για το νήμα που θα δημιουργήσουμε. Κάθε νήμα έχει ένα σύνολο ιδιοτήτων, συμπεριλαμβανομένων του μεγέθους της στοίβας και πληροφορίας χρονοπρογραμματισμού. Η δήλωση pthread_attr_t attr αντιπροσωπεύει τις ιδιότητες του νήματος. Θέτουμε τις τιμές για τις ιδιότητες στην κλήση της συνάρτησης pthread_attr_init(&attr). Επειδή δεν ορίσαμε ρητά καμία ιδιότητα, χρησιμοποιούμε τις προκαθορισμένες ιδιότητες που παρέχονται. Ένα ξεχωριστό νήμα δημιουργείται με την κλήση συνάρτησης pthread_create(). Πέρα από τον αναγνωριστή και τις ιδιότητες του νήματος, περνάμε επίσης το όνομα της συνάρτησης στην οποία θα ξεκινήσει την εκτέλεση στην περίπτωσή μας, στη συνάρτηση runner(). Τέλος, περνάμε την ακέραια παράμετρο η οποία δόθηκε στη γραμμή εντολών, argv[1]. Στο σημείο αυτό, το πρόγραμμα έχει δύο νήματα: το αρχικό (ή γονικό) νήμα στη main() και το νήμα του αθροίσματος (ή παιδί) το οποίο πραγματοποιεί την πράξη του αθροίσματος στη συνάρτηση runner(). Μετά τη δημιουργία του νήματος του αθροίσματος, το γονικό νήμα θα περιμένει την ολοκλήρωσή του καλώντας τη συνάρτηση pthread_join(). Το νήμα του αθροίσματος θα ολοκληρώσει όταν θα καλέσει τη συνάρτηση pthread_exit(). Μόλις επιστρέψει το νήμα του αθροίσματος, η διεργασία γονέας θα βγάλει στην έξοδο την τιμή της κοινής μεταβλητής sum. 3.2 Συγχρονισμός Νημάτων Θα πρέπει να δοθεί προσοχή στο γεγονός ότι πριν την προσπέλαση των νημάτων σε κοινή μνήμη πρέπει να γίνεται κλείδωμα ώστε να συγχρονιστούν τα νήματα και να μην υπάρξει ασυνέπεια στις τιμές. Για το λόγο αυτό παρουσιάζεται παρακάτω ένα παράδειγμα νημάτων που περιλαμβάνει συγχρονισμό. 19

20 #include <pthread.h> #include <stdio.h> int a=0; pthread_mutex_t mutex=pthread_mutex_initializer; void *mythread(void *string) int i; int rc; int local; for (i=0; i<30; i++) rc=pthread_mutex_lock(&mutex); local=a; sleep(1); local=local+1; a=local; rc=pthread_mutex_unlock(&mutex); printf("%d:%s\n",i,string); int main() char *e_str="hello!"; char *f_str="bonjour!"; pthread_t e_th1; pthread_t f_th1; pthread_t e_th2; pthread_t f_th2; int rc; rc=pthread_create(&e_th1, NULL, mythread, (void *)e_str); if (rc) exit(-1); 20

21 rc=pthread_create(&f_th1, NULL, mythread, (void *)f_str); if (rc) exit(-1); rc=pthread_create(&e_th2, NULL, mythread, (void *)e_str); if (rc) exit(-1); rc=pthread_create(&f_th2, NULL, mythread, (void *)f_str); if (rc) exit(-1); pthread_join(e_th1, NULL); pthread_join(f_th1, NULL); pthread_join(e_th2, NULL); pthread_join(f_th2, NULL); printf("main finished. a=%d\n",a); pthread_exit(null); Για περισσότερες πληροφορίες για την λειτουργία της κάθε μια από τις παραπάνω συναρτήσεις μπορείτε να χρησιμοποιήσετε την εντολή man και την συνάρτηση για την οποία ενδιαφέρεστε κάθε φορά. 3.3 Συγχρονισμός Νημάτων με Σημαφόρους Παρακάτω δίνονται οι απαραίτητες συναρτήσεις της βιβλιοθήκης semaphore.h του POSIX API για το συγχρονισμό νημάτων με τη χρήση σημαφόρων για το πρόβλημα της εισόδου αυτών σε κρίσιμες περιοχές. int sem_init(sem_t *sem, int pshared, unsigned int value); Η συνάρτηση sem_init() χρησιμοποιείται για την αρχικοποίηση της τιμής ενός σημαφόρου. Το όρισμα pshared πρέπει να έχει τιμή 0 για σημαφόρους τοπικούς για μια διεργασία. int sem_wait(sem_t * sem); Η συνάρτηση sem_wait() εκτελεί τη λειτουργία wait, δηλαδή τη μοναδιαία μείωση της τιμής του σημαφόρου. int sem_post(sem_t * sem); Η συνάρτηση sem_post() εκτελεί τη λειτουργία signal, δηλαδή τη μοναδιαία αύξηση της τιμής του σημαφόρου. int sem_getvalue(sem_t * sem, int *value); Η συνάρτηση sem_getvalue επιστρέφει μέσω της παραμέτρου value την τιμή του σημαφόρου sem. 21

22 int sem_destroy(sem_t * sem); Η συνάρτηση sem_destroy() χρησιμοποιείται για την αποδέσμευση των πόρων ενός σημαφόρου. Στο παρακάτω πρόγραμμα χρησιμοποιείται ένας δυαδικός σημαφόρος για αμοιβαίο αποκλεισμό δύο νημάτων σε ένα διαμοιραζόμενο πόρο. Για τη μετάφραση του προγράμματος θα χρησιμοποιηθεί η παρακάτω εντολή: gcc -o sem-ex sem-ex.c -Wall -Werror -lpthread #include <unistd.h> /* Symbolic Constants */ #include <sys/types.h> /* Primitive System Data Types */ #include <errno.h> /* Errors */ #include <stdio.h> /* Input/Output */ #include <stdlib.h> /* General Utilities */ #include <pthread.h> /* POSIX Threads */ #include <string.h> /* String handling */ #include <semaphore.h> /* Semaphore */ /* prototype for thread routine */ void handler ( void *ptr ); /* global vars */ /* semaphores are declared global so they can be accessed in main() and in thread routine, here, the semaphore is used as a mutex */ sem_t mutex; int counter; /* shared variable */ int main() int i[2]; pthread_t thread_a; pthread_t thread_b; i[0] = 0; /* argument to threads */ i[1] = 1; sem_init(&mutex, 0, 1); /* initialize mutex to 1 - binary semaphore */ /* second param = 0 - semaphore is local */ /* Note: you can check if thread has been successfully created by checking return value of pthread_create */ pthread_create (&thread_a, NULL, (void *) &handler, (void *) &i[0]); pthread_create (&thread_b, NULL, (void *) &handler, (void *) &i[1]); pthread_join(thread_a, NULL); pthread_join(thread_b, NULL); sem_destroy(&mutex); /* destroy semaphore */ 22

23 /* exit */ exit(0); /* main() */ void handler ( void *ptr ) int x; x = *((int *) ptr); printf("thread %d: Waiting to enter critical region...\n", x); sem_wait(&mutex); /* down semaphore */ /* START CRITICAL REGION */ printf("thread %d: Now in critical region...\n", x); printf("thread %d: Counter Value: %d\n", x, counter); printf("thread %d: Incrementing Counter...\n", x); counter++; printf("thread %d: New Counter Value: %d\n", x, counter); printf("thread %d: Exiting critical region...\n", x); /* END CRITICAL REGION */ sem_post(&mutex); /* up semaphore */ pthread_exit(0); /* exit thread */ 3.4 Μεταβλητές Συνθήκης Μια μεταβλητή συνθήκης είναι μια μεταβλητή τύπου pthread_cond_t και χρησιμοποιείται με τις κατάλληλες συναρτήσεις για αναμονή και έπειτα για συνέχιση διεργασίας. Ο μηχανισμός μεταβλητής συνθήκης επιτρέπει στα νήματα να παγώνουν την εκτέλεσή τους και να απελευθερώνουν τον επεξεργαστή μέχρι η συνθήκη να γίνει αληθής. Μια μεταβλητή συνθήκης πρέπει πάντα να συσχετίζεται με ένα mutex για να αποφευχθούν συνθήκες ανταγωνισμού που μπορεί να δημιουργηθούν όταν ένα νήμα ετοιμάζεται για αναμονή και ένα άλλο νήμα μπορεί να απελευθερώσει τη συνθήκη πριν το πρώτο νήμα πραγματικά αναμένει εισάγοντας έτσι ένα αδιέξοδο. Το νήμα θα περιμένει ατέρμονα για ένα σήμα (signal) που δεν θα σταλεί ποτέ. Κάθε mutex σημαφόρος μπορεί να χρησιμοποιηθεί, δεν υπάρχει αποκλειστικός σύνδεσμος με τη μεταβλητή συνθήκης. Σχετικές συναρτήσεις: Δημιουργια/Καταστροφη: o pthread_cond_init o pthread_cond_t cond = PTHREAD_COND_INITIALIZER; o pthread_cond_destroy Αναμονή σε συνθήκη: o pthread_cond_wait ξεκλειδώνει ένα σημαφόρο και αναμένει τη μεταβλητή συνθήκης να γίνει signal. o pthread_cond_timedwait τοποθέτηση χρονικού ορίου για το χρόνο μπλοκαρίσματος. 23

24 Ξεπάγωμα νημάτων που αναμένουν σε συνθήκη: o pthread_cond_signal επανεκκινεί ένα από τα νήματα που αναμένουν σε μια μεταβλητή συνθήκης. o pthread_cond_broadcast επανεκκινεί όλα τα νήματα που αναμένουν σε μια μεταβλητή συνθήκης. Παράδειγμα #include <stdio.h> #include <stdlib.h> #include <pthread.h> pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER; void *functioncount1(); void *functioncount2(); int count = 0; #define COUNT_DONE 10 #define COUNT_HALT1 3 #define COUNT_HALT2 6 main() pthread_t thread1, thread2; pthread_create( &thread1, NULL, &functioncount1, NULL); pthread_create( &thread2, NULL, &functioncount2, NULL); pthread_join( thread1, NULL); pthread_join( thread2, NULL); printf("final count: %d\n",count); exit(0); // Write numbers 1-3 and 8-10 as permitted by functioncount2() void *functioncount1() for(;;) // Lock mutex and then wait for signal to relase mutex pthread_mutex_lock( &count_mutex ); // Wait while functioncount2() operates on count // mutex unlocked if condition varialbe in functioncount2() signaled. pthread_cond_wait( &condition_var, &count_mutex ); count++; 24

25 printf("counter value functioncount1: %d\n",count); pthread_mutex_unlock( &count_mutex ); if(count >= COUNT_DONE) return(null); // Write numbers 4-7 void *functioncount2() for(;;) pthread_mutex_lock( &count_mutex ); if( count < COUNT_HALT1 count > COUNT_HALT2 ) // Condition of if statement has been met. // Signal to free waiting thread by freeing the mutex. // Note: functioncount1() is now permitted to modify "count". else pthread_cond_signal( &condition_var ); count++; printf("counter value functioncount2: %d\n",count); pthread_mutex_unlock( &count_mutex ); if(count >= COUNT_DONE) return(null); 3.5 Χρονοπρογραμματισμός νημάτων Tα νήματα διαχωρίζονται μεταξύ νημάτων επιπέδου-χρήστη και επιπέδου-πυρήνα. Στα λειτουργικά συστήματα που τα υποστηρίζουν, είναι τα νήματα επιπέδου-πυρήνα και όχι οι διεργασίες που χρονοπρογραμματίζονται από το λειτουργικό σύστημα. Ο χειρισμός των νημάτων επιπέδου-χρήστη γίνεται από μία βιβλιοθήκη νημάτων, ενώ ο πυρήνας αγνοεί την ύπαρξή τους. Για να τρέξουν σε μία ΚΜΕ, τα νήματα επιπέδουχρήστη πρέπει να αντιστοιχηθούν σε ένα συσχετιζόμενο νήμα επιπέδου-πυρήνα, αν και αυτή η αντιστοίχηση μπορεί να είναι έμμεση και μπορεί να χρησιμοποιεί μία ελαφριά διεργασία (LightWeight Process LWP) Πεδίο ανταγωνισμού διεργασιών Μία διάκριση μεταξύ των νημάτων επιπέδου-χρήστη και επιπέδου-πυρήνα σχετίζεται με τον τρόπο που αυτά χρονοπρογραμματίζονται. Σε συστήματα που υλοποιούν τα μοντέλα πολλά-προς-ένα και πολλά-προς-πολλά η βιβλιοθήκη νημάτων 25

26 χρονοπρογραμματίζει τα νήματα επιπέδου-χρήστη να τρέξουν σε μία διαθέσιμη LWP, ένα σχήμα γνωστό ως πεδίο ανταγωνισμού διεργασιών (Process-Contention Scope PCS), αφού ο ανταγωνισμός για την ΚΜΕ λαμβάνει χώρα μεταξύ των νημάτων που ανήκουν στην ίδια διεργασία. Όταν λέμε ότι η βιβλιοθήκη νημάτων χρονοπρογραμματίζει τα νήματα επιπέδου-χρήστη να τρέξουν σε διαθέσιμη LWP, δεν εννοούμε ότι τα νήματα τρέχουν πραγματικά στην ΚΜΕ αυτό θα απαιτούσε το λειτουργικό σύστημα να χρονοπρογραμματίσει τα νήματα πυρήνα σε μία φυσική ΚΜΕ. Για να αποφασιστεί ποιο νήμα πυρήνα θα χρονοπρογραμματιστεί σε μία ΚΜΕ, ο πυρήνας χρησιμοποιεί το πεδίο ανταγωνισμού συστήματος (System-Contention Scope - SCS). Ο ανταγωνισμός για την ΚΜΕ με το χρονοπρογραμματισμό SCS λαμβάνει χώρα μεταξύ όλων των νημάτων του συστήματος. Τα συστήματα που χρησιμοποιούν το μοντέλο ένα-προς-ένα (όπως Windows XP, Solaris 9 και Linux) χρονοπρογραμματίζουν τα νήματα χρησιμοποιώντας μόνο το SCS. Τυπικά, το PCS γίνεται με βάση την προτεραιότητα ο χρονοπρογραμματιστής επιλέγει τα νήματα που θα εκτελεστούν βάσει της υψηλότερης προτεραιότητας. Οι προτεραιότητες των νημάτων επιπέδου-χρήστη έχουν οριστεί από τον προγραμματιστή και δεν προσαρμόζονται από τη βιβλιοθήκη νημάτων, παρόλο που κάποιες βιβλιοθήκες μπορεί να επιτρέπουν στον προγραμματιστή να αλλάξει την προτεραιότητα ενός νήματος. Είναι σημαντικό να σημειωθεί ότι το PCS τυπικά θα διακόψει το εκτελούμενο νήμα για χάρη ενός νήματος υψηλότερης προτεραιότητας. Ωστόσο, δεν υπάρχει εγγύηση για εναλλαγή σε τακτά χρονικά διαστήματα μεταξύ των νημάτων με ίση προτεραιότητα Χρονοπρογραμματισμός στο Pthread Θα ασχοληθούμε με το API του POSIX Pthreads, το οποίο επιτρέπει τον καθορισμό μεταξύ PCS και SCS κατά τη διάρκεια της δημιουργίας των νημάτων. Το Pthreads αναγνωρίζει τις ακόλουθες τιμές για το πεδίο ανταγωνισμού: PTHREAD_SCOPE_PROCESS χρονοπρογραμματίζει τα νήματα χρησιμοποιώντας χρονοπρογραμματισμό PCS. PTHREAD_SCOPE_SYSTEM χρονοπρογραμματίζει τα νήματα χρησιμοποιώντας χρονοπρογραμματισμό SCS. Στα συστήματα που υλοποιούν το μοντέλο πολλά-προς-πολλά η πολιτική PTHREAD_SCOPE_PROCESS χρονοπρογραμματίζει τα νήματα επιπέδου-χρήστη στις διαθέσιμες LWPs. Ο αριθμός των LWPs διατηρείται από τη βιβλιοθήκη νημάτων, πιθανόν χρησιμοποιώντας ενεργοποιήσεις χρονοπρογραμματιστή. Η πολιτική χρονοπρογραμματισμού PTHREAD_SCOPE_SYSTEM θα δημιουργήσει και θα συνδέσει μία LWP για κάθε νήμα επιπέδου-χρήστη σε ένα σύστημα πολλάπρος-πολλά αντιστοιχίζοντας αποδοτικά τα νήματα χρησιμοποιώντας πολιτική έναπρος-ένα. Το IPC του Pthreads παρέχει τις ακόλουθες δύο συναρτήσεις για την ανάκτηση και τον ορισμό της πολιτικής πεδίου ανταγωνισμού: pthread_attr_setscope (pthread_attr_t *attr, int scope) pthread_attr_getscope (pthread_attr_t *attr, int *scope) Η πρώτη παράμετρος και στις δύο συναρτήσεις περιέχει ένα δείκτη προς το σύνολο των ιδιοτήτων για το νήμα. Η δεύτερη παράμετρος για τη συνάρτηση pthread_attr_setscope() παίρνει την τιμή PTHREAD_SCOPE_SYSTEM ή PTHREAD_SCOPE_PROCESS, υποδεικνύοντας την τιμή που θα τεθεί στο πεδίο ανταγωνισμού. Για την pthread_attr_getscope() η δεύτερη παράμετρος περιέχει ένα 26

27 δείκτη προς μία ακέραιη τιμή, η οποία τίθεται στην τρέχουσα τιμή του πεδίου ανταγωνισμού. Αν συμβεί κάποιο σφάλμα, κάθε μία από τις δύο αυτές συναρτήσεις επιστρέφει μη μηδενική τιμή. Παρακάτω παρουσιάζεται ένα πρόγραμμα Pthread, που πρώτα καθορίζει το υπάρχον πεδίο ανταγωνισμού και το θέτει σε PTHREAD_SCOPE_PROCESS. Μετά δημιουργεί πέντε ξεχωριστά νήματα τα οποία θα τρέξουν χρησιμοποιώντας πολιτική χρονοπρογραμματισμού SCS. Σημειώστε ότι σε κάποια συστήματα, επιτρέπονται μόνο συγκεκριμένες τιμές πεδίου ανταγωνισμού. Για παράδειγμα, τα συστήματα Linux και Mac OS X επιτρέπουν μόνο πολιτική PTHREAD_SCOPE_SYSTEM. #include <pthread.h> #include <stdio.h> #define NUM_THREADS 5 int main(int argc, char *argv[]) int i, scope; pthread_t tid[num_threads]; pthread_attr_t attr; /* get the default attributes */ pthread_attr_init(&attr); /* first inquire on the current scope */ if (pthread_attr_getscope (&attr, &scope)!= 0) fprintf(stderr, Unable to get scheduling scope\n ); else if (scope == PTHREAD_SCOPE_PROCESS) printf( PTHREAD_SCOPE_PROCESS ); else if (scope == PTHREAD_SCOPE_SYSTEM) printf( PTHREAD_SCOPE_SYSTEM ); else fprintf(stderr, Illegal scope value. \n ); /* set the scheduling algorithm to PCS or SCS */ pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* create the threads */ for (i = 0; < NUM_THREADS; i++) pthread_create(&tid[i],&attr,runner,null); /* now join on each thread */ for (i = 0; i < NUM_THREADS; i++) pthread_join(tid[i], NULL); 27

28 /* Each thread will begin control in this function */ void *runner(void *param) /* do some work... */ pthread_exit(0); 3.6 Ασκήσεις Άσκηση 1 η Αντικείμενο της άσκησης είναι ο υπολογισμός του π (=3.14..) με χρήση νημάτων. Για τον παραπάνω σκοπό θα χρησιμοποιηθεί η μέθοδος Monte Carlo, που υπολογίζει την τιμή του π με τη βοήθεια τυχαίων αριθμών και στατιστικών πιθανοτήτων. Επιλέγοντας τυχαία σημεία μέσα στο τετράγωνο που περικλείει ένα κύκλο ακτίνας r=100, αποδεικνύεται εύκολα ότι ο λόγος του αριθμού των σημείων που βρίσκονται στον κύκλο προς το συνολικό αριθμό τους ισούται με ¼ π. Από τη παραπάνω σχέση προκύπτει ο τρόπος υπολογισμού της τιμής του π. Για να κάνετε τον υπολογισμό δώστε στο πρόγραμμά σας συνολικά 100 σημεία. Η αρχική διεργασία θα δημιουργεί νήματα, όπου κάθε νήμα θα υπολογίζει για ένα σημείο αν ανήκει ή όχι μέσα στον κύκλο. Το πρόγραμμα θα διατηρεί σε κοινή μνήμη ένα μετρητή. Κάθε νήμα όταν βρίσκει σημείο που είναι μέσα στον κύκλο θα αυξάνει το μετρητή κατά ένα. Η αρχική διεργασία θα βρίσκει το τελικό αποτέλεσμα όταν όλα τα νήματα έχουν τελειώσει. Να προσέξετε το γεγονός της προσπέλασης της κοινής μεταβλητής του μετρητή από τα διαφορετικά νήματα, εφαρμόζοντας μεθόδους αμοιβαίου αποκλεισμού Άσκηση 2 η Παρακάτω δίνεται ένας αλγόριθμος που υπολογίζει το μέγιστο ενός συνόλου ακεραίων: max = x[0]; for (i = 1; i < n; i++) if (x[i] > max) max = x[i]; Αυτό βασίζεται στο γεγονός ότι έχουμε μόνο μία CPU και κάνουμε n - 1 συγκρίσεις για να βρούμε το μέγιστο. Μπορούμε να κάνουμε κάτι καλύτερο εάν υπάρχουν περισσότερες από μία CPUs ; Η απάντηση είναι φυσικά «ναι». Ας δούμε πως. Βήμα 1 Ας χρησιμοποιήσουμε ένα thread για να προσομοιώσουμε μια CPU. Έστω ότι έχουμε n διαφορετικούς ακεραίους x 0, x 1,..., x n-1. Αρχικά, αρχικοποιούμε έναν πίνακα 28