Ε-85: Ειδικά Θέµατα Λογισµικού

Transcript

1 Ε-85: Ειδικά Θέµατα Λογισµικού Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων Χειµερινό Εξάµηνο «Προγραµµατισµός Νηµάτων Προτύπου POSIX» Παναγιώτης Χατζηδούκας (Π.Δ. 407/80) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 1

2 Σχετικά αρχεία: Χρήσητων POSIX Threads #include <pthread.h> #include <sched.h> #include <semaphore.h> ηµιουργία εκτελέσιµου > gcc pthread -o hello hello.c lpthread > gcc D_REENTRANT -o hello hello.c lpthread Κανονική εκτέλεση προγράµµατος >./hello E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 2

3 ΑπλόΠαράδειγµα void *func ( ) { /* define local data */ /* function code */ pthread_exit(&exit_value); main ( ) { pthread_t tid; int exit_value; pthread_create (&tid, 0, func, NULL); pthread_join (tid, &exit_value); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 3

4 Σύγκρισηµε ιεργασίες Σκοπός ιεργασίες Νήµατα Αναγνωριστικό ηµιουργία νέου νήµατος pid_t getpid() fork() pthread_t pthread_self() pthread_create() Εκκίνηση νέου νήµατος exec() Αναµονήεκτέλεσης νήµατος Έξοδοςκαι καταστροφή νήµατος wait() exit() pthread_join() pthread_exit() E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 4

5 ιεργασίες main ( ) { fork ( ); fork ( ); fork ( ); Νήµατα main() { Σύγκρισηκώδικα pthread_create(0,func(),0,0); pthread_create(0,func(),0,0); pthread_create(0,func(),0,0); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 5

6 ηµιουργίανήµατος int pthread_create (pthread_t *thread, const pthread_attr_t *attr, void *(*routine)(void *), void *arg); Οι ιδιότητες του νήµατος (µέγεθος στοίβας, πολιτική δροµολόγησης) µπορούν να καθοριστούν ρητά ή να τροποποιηθούν Αν attr == NULL τότε χρησιµοποιούνται οι προκαθορισµένες τιµές Η κλήση επιστρέφει 0 για επιτυχία, έναν αριθµό σφάλµατος για αποτυχία EAGAIN: Έλλειψη διαθέσιµων πόρων EINVAL: Μη αποδεκτή ιδιότητα EPERM: Το πρόγραµµα δεν έχει τα απαραίτητα δικαιώµατα Όλες οι συναρτήσεις των POSIX threads επιστρέφουν τιµές σφάλµατος εν θέτουν κάποια τιµή στη µεταβλητή errno Ένα νέο νήµα εκτελεί τη συνάρτηση που ορίζεται από το όρισµα routine arg είναι το µοναδικό όρισµα σε αυτή τη συνάρτηση Το αναγνωριστικό του νήµατος αποθηκεύεται στο *thread E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 6

7 #include <pthread.h> ηµιουργίανήµατος pthread_t tid; int res; extern void *start_routine(void *arg); void *arg; res = pthread_create(&tid, NULL, start_routine, arg); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 7

8 struct data { int i; float f; ΠέρασµαΠολλών Παραµέτρων void *routine(void *arg) { struct data *d = (struct data *) arg; d->i = ; return 0; int main() { pthread_t tid; struct data main_data; main_data.i = 6; pthread_create(&tid, NULL, routine, (void *) &main_data);... E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 8

9 ΑναµονήΤερµατισµού Νήµατος int pthread_join (pthread_t thread, void **status); Το πρώτο όρισµα της συνάρτησης είναι το αναγνωριστικό του νήµατος και όχι ένας δείκτης σε αυτό Η τιµή επιστροφής της συνάρτησης που εκτελέστηκε από το νήµα αποθηκεύεται στoν χώρο που ορίζεται από την µεταβλητή status Πρέπει οπωσδήποτε να οριστεί ένα νήµα Η κλήση pthread_join() είναι blocking, αφού αναστέλλεται η εκτέλεση του νήµατος που την καλεί έως ότου τερµατίσει το νήµα που έχει οριστεί E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 9

10 ΑναµονήΤερµατισµού Νήµατος #include <pthread.h> pthread_t tid; int res; int status; res = pthread_join(tid, &status); res = pthread_join(tid, NULL); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 10

11 Παράδειγµαµε ιεργασία void *work(void *arg); int main(int argc, char **argv) { int i = 1; int pid, status; pid = fork(); if(pid == 0) { printf( Child\n ); work((void*) i); exit(0); printf( Father of %d\n, pid); waitpid(pid, &status, 0); return 0; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 11

12 void *work(void *arg); Παράδειγµαµε Νήµα int main(int argc, char **argv) { int i = 1; pthread_t thread; pthread_create(&thread, NULL, work,(void *) i); pthread_join(thread, NULL); printf( Child ended, exiting \n ); return 0; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 12

13 ΤερµατισµόςΝήµατος void pthread_exit (void *status); Ένα νήµα τερµατίζει όταν επιστρέψει η συνάρτηση που εκτελεί ή ρητά καλώντας την pthread_exit() Ένα αποδεσµευµένο νήµα που τερµατίζει απελευθερώνει αµέσως τους πόρους του Αν είναι το τελευταίο νήµα στη διεργασία τότε αυτή τερµατίζει Ένα µη αποδεσµευµένο νήµα που τερµατίζει θα ελευθερώσει κάποιουςπόρους µα το αναγνωριστικό του και η τιµή εξόδου θα παραµείνουν στο σύστηµα σε µια κατάσταση όπως οι zombie διεργασίες µέχρις ότου ένα άλλο νήµα απαιτήσει την τιµή εξόδου του καλώντας pthread_join() Αν κληθεί η exit() τότε όλα τα νήµατα καταστρέφονται και η διεργασία τερµατίζει Αν επιστρέψει το βασικό νήµα της διεργασίας (main), ισοδυναµεί µε κλήση της exit() int status; pthread_exit(&status); return((void *)&status); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 13

14 Αποδέσµευσηνήµατος int pthread_detach(pthread_t tid); Αποδεσµεύει ένα νήµα Η κλήση pthread_join() δεν θα χρησιµοποιηθεί για το συγκεκριµένο νήµα Η κλήση χρησιµοποιείται για να ενηµερωθεί το λειτουργικό σύστηµαότι δεν χρειάζεται από το πρόγραµµα η τιµή που επιστρέφει ένα νήµα Η αποδέσµευση ενός νήµατος σηµαίνει ότι το νήµα και οι πόροι του (π.χ. η στοίβα που µπορεί να έχει µέγεθος 1MB) µπορούν να επαναχρησιµοποιηθούν µόλις αυτό τερµατίσει Το αναγνωριστικό του µπορεί να επαναχρησιµοποιηθεί άµεσα Τερµατισµός διεργασιών και κλήση wait Το αναγνωριστικό ενός αποδεσµευµένου νήµατος είναι ακαθόριστο Τα νήµατα αποδεσµεύονται µε την κλήση pthread_detach(), µετά από την κλήση pthread_join(), και όταν ένα νήµα τερµατίζει ενώ η ιδιότητα PTHREAD_CREATE_DETACHED είχε τεθεί κατά τη δηµιουργία του E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 14

15 ηµιουργίακαι Αναµονή Νηµάτων void * func(void * arg) { sleep(1); return NULL; int main(int argc, char * argv[]) { pthread_t id[4]; int i; for (i = 0; i < 4; i++) { pthread_create(&id[i], NULL, func, NULL); for (i = 0; i < 4; i++) { pthread_join(id[i], NULL); return 0; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 15

16 ηµιουργίακαι Αναµονή Νηµάτων void * func(void * arg) { int sec = (int) arg + 1; sleep((int) sec); return arg; /* pthread_exit(arg); */ int main(int argc, char * argv[]) { pthread_t id[4]; int i, result; for (i = 0; i < 4; i++) { pthread_create(&id[i], NULL, func, (void *) i); for (i = 0; i < 4; i++) { pthread_join(id[i], (void *) &result); /* result == i */; return 0; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 16

17 ιάφορεςκλήσεις pthread_t pthread_self (void); Επιστρέφει την ταυτότητα του τρέχοντος νήµατος int pthread_equal (pthread_t tid1, pthread_t tid2); Συγκρίνει τις ταυτότητες δύο νηµάτων. Επιστρέφει 0 αν είναι ίδια. Για τη σύγκριση δεν πρέπει να χρησιµοποιείται ο τελεστής ισότητας (==) int sched_yield(void); Ενηµερώνει το δροµολογητή του συστήµατος ότι το τρέχον νήµα θα ελευθερώσει τον επεξεργαστή εφόσον ένα άλλο νήµα βρίσκεται σε αναµονή για εκτέλεση int pthread_setconcurrency(int threads); Επιτρέπει σε µια διεργασία να απαιτήσει έναν συγκεκριµένο ελάχιστο αριθµό νηµάτων επιπέδου πυρήνα για την εκτέλεση των POSIX threads. Σε κάποιες αρχιτεκτονικές µπορεί να οδηγήσει σε αποδοτικότερη δροµολόγηση νηµάτων E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 17

18 ΑναγνωριστικόΝήµατος pthread_t pthread_self (void); int pthread_equal (pthread_t tid1, pthread_t tid2); ========================================================== #include <pthread.h> pthread_t tid, tid1, tid2; int res; tid = pthread_self(); res = pthread_equal(tid1, tid2); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 18

19 ΑποδέσµευσηΝήµατος int pthread_detach (pthread_t tid1, pthread_t tid2); ========================================================== #include <pthread.h> pthread_t tid; int res; res = pthread_create(&tid, NULL, func, (void *) &arg); res = pthread_detach(tid); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 19

20 Συγχρονισµός Έστω η εντολή ticket = next_ticket++; /* 0 1 */ Στη γενική περίπτωση αυτό που πραγµατοποιείται είναι το εξής: ticket = temp = next_ticket; /* 0 */ ++temp; /* 1, µη ορατό */ next_ticket = temp; /* 1 */ E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 20

21 Εκτέλεσηµε ύο Νήµατα Thread 0 tkt = tmp = n_tkt; (0) ++tmp; (1) n_tkt = tmp; (1) Thread 1 tkt = tmp = n_tkt; (1) ++tmp; (2) n_tkt = tmp; (2) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 21

22 υνατόσενάριο Εκτέλεσης Thread 0 tkt = tmp = n_tkt; (0) ++tmp; (1) n_tkt = tmp; (1) Thread 1 tkt = tmp = n_tkt; (0) ++tmp; (1) n_tkt = tmp; (1) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 22

23 ΜηχανισµοίΣυγχρονισµού Κλειδιά αµοιβαίου αποκλεισµού (Mutexes) Μεταβλητές συνθήκης (Condition variables) Σηµαφόροι (Semaphores) Κλειδιά πολλαπλών αναγνωστών (Reader-Writer locks) Κλειδιά ενεργού αναµονής (Spinlocks) Φράγµατα εκτέλεσης (Barriers) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 23

24 ΚλειδιάΑµοιβαίου Αποκλεισµού Ένα Mutex (Mutual Exclusion) είναι ένα στοιχείο που επιτρέπει πολλαπλά νήµατα να συγχρονίζουν την πρόσβασή τους σε κοινούς πόρους (π.χ. µεταβλητές) Όπως οι δυαδικοί σηµαφόροι, ένα mutexέχει δύο καταστάσεις, lockedκαι unlocked Μόνο ένα νήµα µπορεί να κλειδώσει ένα mutex Εφόσον ένα mutexέχει κλειδωθεί, τα υπόλοιπα νήµατα θα µπλοκάρουνόταν προσπαθήσουν να κλειδώσουν το ίδιο mutex, µέχρις ότου το νήµα ξεκλειδώσει το mutex Στο σηµείο αυτό ένα από τα νήµατα που περίµεναν θα αποκτήσουν το mutex, συνεχίζοντας την εκτέλεση του κώδικα E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 24

25 ΣτατικήΑρχικοποίηση mutex ήλωση και αρχικοποίηση ενός mutex: pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER; Κλείδωµα του mutex: pthread_mutex_lock(&mymutex); Ξεκλείδωµα του mutexαφού η κρίσιµη περιοχή κώδικα έχει εκτελεστεί: pthread_mutex_unlock(&mymutex); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 25

26 υναµικήαρχικοποίηση mutex ήλωση ενός mutex: pthread_mutex_t mymutex; Αρχικοποίηση του mutex: pthread_mutex_init(&mymutex, (pthread_mutex_attr_t *) NULL); Κλείδωµα του mutex: pthread_mutex_lock(&mymutex); Ξεκλείδωµα του mutexόταν η κρίσιµη περιοχή κώδικα έχει εκτελεστεί: pthread_mutex_unlock(&mymutex); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 26

27 υναµικά έσµευση mutex ήλωση ενός δείκτη σε mutex: pthread_mutex_t * mymutex; έσµευση µνήµης για το mutex (mymutex = malloc ) Προαιρετικά µπορεί να χρησιµοποιηθεί και µια µεταβλητή ιδιοτήτων για το mutex pthread_mutexattr_t mymutex_attr; pthread_mutexattr_init(&mymutex_attr); Αρχικοποίηση του mutex: pthread_mutex_init(&mymutex, &mymutex_attr); Κλείδωµα και ξεκλείδωµα του mutex όπως πριν Καταστροφή του mutex pthread_mutex_destroy(&mymutex); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 27

28 Κλείδωµαµε Έλεγχο int pthread_mutex_trylock(pthread_mutex_t * mutex); Επιτρέπει ένα νήµα να δοκιµάσει να κλειδώσει ένα mutex Αν το mutex είναι διαθέσιµο τότε το νήµα κλειδώνει το mutex Αν το mutexείναι ήδη κλειδωµένο τότε η συνάρτησηενηµερώνει τον χρήστη επιστρέφοντας µια ειδική τιµή (EBUSY) Με τον τρόπο αυτό µπορούν να υλοποιηθούν spinlocks while (pthread_mutex_trylock(&mut) == EBUSY) /*sched_yield()*/; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 28

29 Σύνοψη - Mutexes pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int pthread_mutex_init (pthread_mutex_t *mutex, pthread_mutexattr_t *attr); int pthread_mutex_destroy (pthread_mutex_t *mutex); ========================================================= #include <pthread.h> pthread_mutex_t static_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t *dynamic_mutex; dynamic_mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t)); pthread_mutex_init (&dynamic_mutex, NULL); pthread_mutex_destroy (&dynamic_mutex); free(dynamic_mutex); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 29

30 Σύνοψη - Mutexes int pthread_mutex_lock (pthread_mutex_t *mutex); int pthread_mutex_trylock (pthread_mutex_t *mutex); int pthread_mutex_unlock (pthread_mutex_t *mutex); ========================================================== pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; void * func(void * arg) { int res; res = pthread_mutex_trylock(&mutex1); /* EBUSY */; return 0; int main() { pthread_t t; pthread_mutex_lock(&mutex1); pthread_create(&t, NULL, func, NULL); sleep(2); pthread_mutex_unlock(&mutex1); return 0; E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 30

31 #include <pthread.h> Παράδειγµα pthread_mutex_t pi_lock = PTHREAD_MUTEX_INITIALIZER; double pi = 0.0; void *work(void *arg) {... pthread_mutex_lock(&pi_lock); pi += localsum; pthread_mutex_unlock(&pi_lock);... E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 31

32 #include <pthread.h> Υπολογισµόςτου π (1/2) double pi = 0.0; pthread_mutex_t pi_lock; double intervals; void *process(void *arg) { double width, localsum = 0, x; int i, int iproc = (*((char *) arg) - '0'); width = 1.0 / intervals; for (i=iproc; i<intervals; i+=2) { x = (i + 0.5) * width; localsum += 4.0 / (1.0 + x * x); localsum *= width; pthread_mutex_lock(&pi_lock); pi += localsum; pthread_mutex_unlock(&pi_lock); return(null); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 32

33 Υπολογισµόςτου π (2/2) int main(int argc, char **argv) { pthread_t thread0, thread1; void * retval; /* Get the number of intervals */ intervals = atoi(argv[1]); pthread_mutex_init(&pi_lock, NULL); pthread_create(&thread0, NULL, process, "0 ); pthread_create(&thread1, NULL, process, "1"); pthread_join(thread0, &retval); pthread_join(thread1, &retval); printf("estimation of pi is %f\n", pi); exit(0); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 33

34 ΠροβλήµαταΣυγχρονισµού Αδιέξοδα (deadlocks) Αντιστροφή προτεραιότητας (Priority Inversion) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 34

35 Αδιέξοδα Αδιέξοδοµπορεί να συµβεί όταν οι µεταβλητές συγχρονισµού (mutexes) δεν κλειδώνονται µε την ίδια σειρά. Κανένα νήµα δεν επιτρέπει το άλλο να συνεχίσει την εκτέλεσή του: Thread 0 Thread 1 pthread_mutex_lock(&mut1); pthread_mutex_lock(&mut2); pthread_mutex_lock(&mut2); pthread_mutex_lock(&mut1); Επίσης όταν ένα mutexκλειδώνεται από το ίδιο νήµα δύο φορές (αναδροµικά) pthread_mutex_lock(&mut1); pthread_mutex_lock(&mut1); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 35

36 Πιθανό σενάριο ΑντιστροφήΠροτεραιότητας Ένα νήµα χαµηλής προτεραιότητας κλειδώνει το mutex m Ένα νήµα µεσαίας προτεραιότητας εκτελείται διακόπτοντας το νήµα χαµηλής προτεραιότητας Ένα νήµα υψηλής προτεραιότητας εκτελείται διακόπτοντας το νήµα µεσαίας προτεραιότητας, και πρέπει να κλειδώσει το mutex mώστε να προχωρήσει Αποτέλεσµα Το mutexείναι κλειδωµένο από το νήµα χαµηλής προτεραιότητας που όµως δεν εκτελείται Ουσιαστικά µπλοκάρει το νήµα υψηλής προτεραιότητας και δεν το επιτρέπει να πάρει το mutex και να προχωρήσει E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 36

37 ΛύσειςΑντιστροφής Προτεραιότητας Πρωτόκολλο κληρονοµικότητας προτεραιότητας για mutexes: Ένα νήµα κληρονοµεί την υψηλότερη προτεραιότητα όλων των νηµάτων που µπλοκάρουν επειδή αυτό έχει δεσµεύσει ένα mutex Στο προηγούµενο παράδειγµα, όταν το νήµα υψηλής προτεραιότητας µπλοκάρει στο mutex m που έχει κλειδωθεί από το νήµα χαµηλής προτεραιότητας, η προτεραιότητα του πρώτου µεταφέρεται προσωρινά στο δεύτερο αυξάνοντας τις πιθανότητες να δροµολογηθεί γρηγορότερα Πρωτόκολλο µέγιστης προτεραιότητας Συσχετίζει µια προτεραιότητα µε ένα mutex, η ελάχιστη τιµή της οποίας είναι ίση µε τη µεγαλύτερη προτεραιότητα νήµατος που µπορεί να κλειδώσει το mutex Όταν ένα νήµα κλειδώνει ένα mutex, η προτεραιότητά του αυξάνεται σε αυτή του mutex E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 37

38 ΠολυνηµατικήΑσφάλεια Μιασυνάρτηση είναι thread-safe αν µπορεί να κληθεί µε ασφάλεια ταυτόχρονα από πολλαπλά νήµατα Μια reentrant συνάρτηση µπορεί να έχει ταυτόχρονα πολλές ενεργές κλήσεις, σε διάφορα σηµεία εκτέλεσής της, χωρίς να επηρεάζονται µεταξύ τους. Μια thread-safe συνάρτηση είναι είτε re-entrant είτε προστατεύεται από πολλαπλές ταυτόχρονες εκτελέσεις της µε κάποια µορφή αµοιβαίου αποκλεισµού. Η χρήση της reentrant (thread safe)έκδοσης των καθιερωµένων συναρτήσεων πραγµατοποιείται µε ορισµό _REENTRANT E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 38

39 ΠολυνηµατικήΑσφάλεια Όλεςσχεδόν οι συναρτήσεις είναι thread-safe, µε ελάχιστες εξαιρέσεις ctime, asctime getenv, putenv getopt gethostbyname, gethostbyaddr, getservbyname, getservbyport rand strtok, strerror Συναρτήσεις που χρησιµοποιούν στατικά αντικείµενα δεν είναι thread-safe E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 39

40 ΕπίτευξηΑσφάλειας 1. Προστασίαόλου του κώδικα της συνάρτησης µε ένα mutex Αποτελεί την ευκολότερη λύση αλλά µπορεί να µειώσει την απόδοση λόγω της σειριακής εκτέλεσης του κώδικα 2. Πέρασµα στατικών ανά νήµα δεδοµένων ως όρισµα (π.χ. strtok_r) Αυτό είναι δύσχρηστο και εκθέτει την εσωτερική υλοποίηση της συνάρτησης (rand_r, malloc) 3. Χρήση ιδιωτικών δεδοµένων νηµάτων (pthread_key_t) Κάθε νήµα έχει τα δικά του προσωπικά δεδοµένα που µόνο αυτό µπορεί να προσπελάσει E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 40

41 Παράδειγµα Μια thread-safe έκδοση της συνάρτηση rand Επιστρέφει 0 σε επιτυχία, µη µηδενική τιµή σε περίπτωση σφάλµατος (αποτυχία κλειδώµατος / ξεκλειδώµατος του mutex) Το όρισµα ranp δείχνει σε έναν ακέραιο µεταξύ 0 και RAND_MAX #include <pthread.h> #include <stdlib.h> int rand_r(int *ranp){ static pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER; int error; if (error = pthread_mutex_lock(&lock)) return error; *ranp = rand(); return pthread_mutex_unlock(&lock); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 41

42 ΜεταβλητέςΣυνθήκης Μιαµεταβλητή συνθήκης (Condition variable) είναι ένας µηχανισµός συγχρονισµού που επιτρέπει πολλαπλά νήµατα να περιµένουν σε µια συνθήκη, µέχρι κάποιο χρονικό σηµείο πέρα από οποίο µπορούν να συνεχίσουν Οι µεταβλητές συνθήκης διαφέρουν από τα mutexesεπειδή δεν προστατεύουν κώδικα αλλά κάποια λειτουργία Ένα νήµα θα περιµένει σε µια µεταβλητή συνθήκης έως ότου η µεταβλητή το ενηµερώσει ότι µπορεί να συνεχίσει Κάποιο άλλο νήµα σηµατοδοτεί τη µεταβλητή συνθήκης, επιτρέποντας άλλα νήµατα να συνεχίσουν Κάθε µεταβλητή συνθήκης, ως διαµοιραζόµενο δεδοµένο, συσχετίζεται και µε ένα συγκεκριµένο mutex E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 42

43 ΜεταβλητέςΣυνθήκης Μετις µεταβλητές συνθήκης αποφεύγεται ο συνεχής έλεγχος της κατάστασης των δεδοµένων Ένα νήµα που τροποποιεί την τιµή των δεδοµένα ειδοποιεί τα ενδιαφερόµενα µέσω µιας µεταβλητής συνθήκης Παράδειγµα: Σχήµα παραγωγού καταναλωτή µε χρήση ουράς δεδοµένων Το νήµα-καταναλωτής εξάγει και επεξεργάζεται στοιχεία της ουράς εφόσον αυτή δεν είναι άδεια, διαφορετικά µπλοκάρει Το νήµατα-παραγωγός προσθέτει στοιχεία στην ουρά και ειδοποιεί µε τη µεταβλητή συνθήκης το νήµα καταναλωτή που περιµένει Η αλληλεπίδραση των νηµάτων βασίζεται στο πλήθος των στοιχείων που υπάρχουν στην ουρά E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 43

44 Ορισµόςκαι Αρχικοποίηση int pthread_cond_init(pthread_cond_t * cond); Μια µεταβλητή συνθήκης περιγράφεται µε τον τύπο pthread_cond_t Στατική αρχικοποίηση: pthread_cond_t condition = PTHREAD_COND_INITIALIZER; υναµική αρχικοποίηση: pthread_cond_init(&condition); Μια µεταβλητή συνθήκης συσχετίζεται πάντοτε µε ένα mutex E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 44

45 ΑναµονήΣυνθήκης int pthread_cond_wait(pthread_cond_t *condition, pthread_mutex_t *mutex); Το νήµα αναστέλλει την εκτέλεση του µέχρι να σηµατοδοτηθεί η µεταβλητή συνθήκης Το νήµα πρέπει να έχει ήδη κλειδώσει το συσχετιζόµενο mutex To νήµα αναστέλλεται ενώ το mutexξεκλειδώνεται αυτόµατα ώστε να επιτραπεί η χρήση του από άλλα νήµατα Όταν το νήµα ενεργοποιηθεί µε την ειδοποίηση του µέσω της µεταβλητής συνθήκης, αυτόµατα το mutexείναι κλειδωµένο από το ίδιο E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 45

46 Ειδοποίηση-Αφύπνιση Νήµατος int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); Με την pthread_cond_signalένα νήµα ειδοποιεί κάποιο άλλο νήµα που περιµένει σε κάποια µεταβλητή συνθήκης Με την pthread_cond_broadcast, ένα νήµα ειδοποιεί όλα τα νήµατα που περιµένουν σε κάποια µεταβλητή συνθήκης Το νήµα που πρόκειται να σηµατοδοτήσει µια µεταβλητή συνθήκης συνήθως έχει κλειδώσει το mutexπου συσχετίζεται µε αυτή. Στην περίπτωση αυτή πρέπει να ελευθερώσει το mutex ώστε να συνεχιστεί η εκτέλεση της pthread_cond_wait E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 46

47 ΤρόποςΧρήσης 1. Ένανήµα κλειδώνει ένα mutexπου σχετίζεται µε µια µεταβλητή συνθήκης 2. Το νήµα ελέγχει τη συνθήκη για να δει αν µπορεί να συνεχίσει 3. Εφόσον µπορεί (η µεταβλητή συνθήκης είναι αληθής): 1. Το νήµα εκτελεί την δουλειά του και 2. Ξεκλειδώνει το mutex 4. Εφόσον δεν µπορεί (η µεταβλητή συνθήκης είναι ψευδής): 1. Το νήµα αναστέλλεται καλώντας την pthread_cond_wait(&c,&m), και το mutex ξεκλειδώνεται αυτόµατα από το σύστηµα 2. Κάποιο άλλο νήµα καλεί την pthread_cond_signal(&c) για να θέσει τη συνθήκη σε αληθή κατάσταση 3. Το νήµα ξυπνάει από την αναµονή έχοντας το mutexαυτόµατα κλειδωµένο και εκτελεί τη δουλειά του 4. Το νήµα ξεκλειδώνει το mutex όταν έχει ολοκληρώσει E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 47

48 Παράδειγµα 1 Thread 0 Thread 1 T1: pthread_mutex_lock(&m); T2: while(!condition_ok) T3:while(pthread_cond_wait(&c,&m)); T4: T5: T6: T7: T8: go_ahead_and_do_it(); T9: pthread_mutex_unlock(&m); pthread_mutex_lock(&m); condition_ok = TRUE; pthread_cond_signal(&c); pthread_mutex_unlock(&m); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 48

49 Παράδειγµα 2 Thread 0 Thread 1 for(...) { pthread_mutex_lock(&mut); count++; if (count== N){ /* Wake-up thread 1 */ pthread_cond_signal(&cond); pthread_mutex_unlock(&mut); //Do work pthread_mutex_lock(&mut); while(count<n) { pthread_cond_wait(&cond, &mut); pthread_mutex_unlock(&mut); //Do work E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 49

50 Παράδειγµα 3 Threads 0,1,,N-1 Thread N for(...) { pthread_mutex_lock(&mut); count++; if (count== N){ /* Wake-up thread N */ pthread_cond_signal(&cond); pthread_mutex_unlock(&mut); //Do work pthread_mutex_lock(&mut); while(count<n) { pthread_cond_wait(&cond, &mut); pthread_mutex_unlock(&mut); //Do work E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 50

51 Thread 0 Παράδειγµα 4 Thread 1,2,,N for(...) { pthread_mutex_lock(&mut); count++; if (count== N){ /* Wake-up threads 1..N */ pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut); //Do work pthread_mutex_lock(&mut); while(count<n) { pthread_cond_wait(&cond, &mut); pthread_mutex_unlock(&mut); //Do work E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 51

52 Παρατηρήσεις Παρατηρήσεις Μια µεταβλητή συνθήκης συσχετίζεται πάντα µε ένα mutex (κοινό δεδοµένο µε αναγκαιότητα αµοιβαίου αποκλεισµού) Η αναµονή επιστρέφει πάντα µε το mutex κλειδωµένο Οι µεταβλητές συνθήκες είναι για σηµατοδότηση κι όχι για αµοιβαίο αποκλεισµό Μια µεταβλητή συνθήκης και η συνθήκη συνδέονται µεταξύ τους και πρέπει να διαχειρίζονται µε ανάλογο τρόπο Η συνθήκη πρέπει να ελέγχεται κάθε φορά αν είναι αληθής Αναχαιτισµένεςαφυπνίσεις: Πριν επιστρέψει η ρουτίνα αναµονής µε το mutexκλειδωµένο, ένα άλλο νήµα µπορεί να έχει κλειδώσει το mutexκαι να αλλάξει τη κατάσταση της συνθήκης Χαλαρές συνθήκες:ίσως είναι ευκολότερο να χρησιµοποιείται µια προσέγγιση της πραγµατικής κατάστασης (π.χ. ίσως υπάρχει δουλειά ) Ψευδείς αφυπνίσεις: Επιστροφή της wait χωρίς να έχει σηµατοδοτηθεί η µεταβλητή συνθήκης (π.χ. σε πολυεπεξεργαστικά συστήµατα) E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 52

53 ΜεταβλητέςΣυνθήκης υνατή η χρήση της µεταβλητής συνθήκης χωρίς συνθήκη Tο mutexπρέπει να κλειδωθεί πριν την κλήση της waitκαι να ελευθερωθεί µετά την επιστροφή της Παράδειγµα: pthread_mutex_lock(&mut); pthread_cond_wait(&cond, &mut); pthread_mutex_unlock(&mut); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 53

54 ΜεταβλητέςΣυνθήκης Επέκταση pthread_cond_timedwait(&condition, &mutex, (struct timespec *)expiration); Αναµονή νήµατος σε µια µεταβλητή συνθήκης, θέτοντας κατάλληλο χρονικό περιορισµό. Αν συµβεί timeout, τότε η ρουτίνα επιστρέφει ETIMEDOUT. =========================================================== struct timespec timeout; /* Wait on the condition variable for 2 seconds */ timeout.tv_sec = time(null) + 2; timeout.tv_nsec = 0; pthread_cond_timedwait(&condition, &mutex, &timeout); E-85: Ε.Θ.Λ: Προγραµµατισµός Συστηµάτων Υψηλών Επιδόσεων 54