Αποδοτική εκτέλεση προγραμμάτων OpenMP σε συστάδες Η/Υ

Transcript

1 Πτυχιακή Εργασία Σιταράς Φώτιος Αύγουστος 2009 Αποδοτική εκτέλεση προγραμμάτων OpenMP σε συστάδες Η/Υ Επιβλέπων: Βασίλειος Δημακόπουλος 1

2 2

3 Περιεχόμενα Κεφάλαιο 1: Εισαγωγή Η εξέλιξη των Η/Υ Παράλληλα Συστήματα Σύστημα Κοινής Μνήμης Σύστημα Κατανεμημένης Μνήμης Αντικείμενο Πτυχιακής Εργασίας Δομή της Εργασίας...9 Κεφάλαιο 2: Το πρότυπο OpenMP Εισαγωγή στο OpenMP Προγραμματιστικό Μοντέλο Οδηγίες OpenMP Σύνταξη Οδηγιών Παράλληλα Τμήματα Οδηγίες Διαμοίρασης Έργου Οδηγίες Συγχρονισμού Συνθήκες Οδηγιών Συναρτήσεις Βιβλιοθήκης Συναρτήσεις Περιβάλλοντος Χρόνου Εκτέλεσης Συναρτήσεις Κλειδαριών Μεταβλητές Περιβάλλοντος...17 Κεφάλαιο 3: OMPi Compiler Επισκόπηση του OMPi Ο Compiler του OMPi Διαδικασία Μετασχηματισμού για Νήματα Διαδικασία Μετασχηματισμού για Διεργασίες Το Σύστημα Runtime του OMPi Είσοδος σε Παράλληλη Περιοχή Χειρισμός Δομών Διαμοίρασης Έργου Η Διεπαφή με το EELIB Βιβλιοθήκες Νημάτων OMPi και Clusters...28 Κεφάλαιο 4: Υποστήριξη Πολλαπλών Νημάτων Ανά Κόμβο Εισαγωγή Η Βιβλιοθήκη OPRC Διαδικασία Αρχικοποίησης Το Νήμα Server Εκτέλεση Παράλληλης Περιοχής Συγχρονισμός Διαδικασία Περάτωσης Εκτέλεσης Διαχείριση της ORT...39 Κεφάλαιο 5: Πειραματικά Αποτελέσματα Εισαγωγικές Πληροφορίες για τα Πειράματα EPCC Microbenchmarks Πείραμα 1: Σταθερός αριθμός 4 νημάτων

4 5.2.2 Πείραμα 2: Σύγκριση με τη βιβλιοθήκη διεργασιών του OMPi Πείραμα 3: Κλιμακωτή Εκτέλεση Παράλληλες Εφαρμογές...47 Κεφάλαιο 6: Σύνοψη και Μελλοντική Εργασία

5 Κεφάλαιο 1 Εισαγωγή 1.1 Η εξέλιξη των Η/Υ Σε όλη την ιστορία του, ο άνθρωπος προσπαθούσε να βελτιώσει και να διευκολύνει την καθημερινότητά του. Επόμενο ήταν λοιπόν, γύρω στον 17ο αιώνα να αρχίσει να κατασκευάζει και μηχανές υπολογισμών. Κάποιες μηχανές υπολόγιζαν λογαρίθμους, άλλες μπορούσαν να προσθαφαιρέσουν και σιγά σιγά με την επινόηση της άλγεβρας Boole και των διάτρητων καρτών, έμπαιναν οι βάσεις για την έναρξη μιας νέας επαναστατικής εποχής. Την πρώτη περιγραφή ενός Η/Υ με την μορφή που έχει σε γενικές γραμμές σήμερα, την παρατηρούμε σε μια εργασία του John von Neumann το 1945 και ο πρώτος Η/Υ κάνει την εμφάνισή του το 1946 με το όνομα ENIAC. Η εργονομία του όμως για τα σημερινά τουλάχιστον δεδομένα είναι πολύ μικρή. Ο ENIAC είχε πολύ μεγάλο όγκο, ήταν θορυβώδης, αποτελούταν από πάρα πολλές λυχνίες που καίγονταν συχνά και κατανάλωνε πολύ μεγάλη ενέργεια. Ήταν όμως αδιαμφισβήτητα ένα μεγάλο βήμα προς το σήμερα. Έκτοτε ο άνθρωπος επένδυσε αρκετή φαιά ουσία στο να βελτιστοποιήσει κάθε τομέα αυτού του εγχειρήματος. Είτε αυτό ήταν το μέγεθος, είτε η κατανάλωση ενέργειας, είτε η χωρητικότητα μνήμης, είτε ακόμα σημαντικότερα η επεξεργαστική ισχύς. Ενώ ο ENIAC μπορούσε να εκτελέσει 5000 προσθέσεις ανά δευτερόλεπτο, ένας σημερινός υπολογιστής μπορεί να εκτελέσει δισεκατομμύρια τέτοιες πράξεις. Ο άνθρωπος ξεκίνησε ένα κυνήγι με την ταχύτητα προσπαθώντας να φτιάξει όλο και πιο γρήγορους ηλεκτρονικούς υπολογιστές δημιουργώντας όλο και πιό γρήγορους επεξεργαστές. Η εξέλιξη αυτή όμως, βρήκε ένα τοίχο μπροστά της. Ο άνθρωπος πλέον περιοριζόταν από τους νόμους της φύσης και το υλικό και έτσι θα έπρεπε να βρει νέους τρόπους. Ας το δούμε ως μια καθημερινή δραστηριότητα. Αν σε ένα σπίτι έχουμε να κάνουμε 3 δουλειές. Τότε θα ξεκινήσει ένα άτομο (επεξεργαστής) και θα τις τελειώσει σε 3 χρονικές στιγμές. Αν όμως είχαμε 3 άτομα (επεξεργαστές), τότε οι δουλειές θα τελείωναν σε 1 χρονική στιγμή αν αναθέταμε σε κάθε άτομο μια δουλειά και αυτά την εκτελούσαν παράλληλα. Η λύση λοιπόν δόθηκε από τα παράλληλα συστήματα και επόμενο ήταν να αναπτυχθούν νέοι κλάδοι στην πληροφορικοί που έχουν ως αντικείμενο την παράλληλη επεξεργασία και τον παράλληλο προγραμματισμό. 1.2 Παράλληλα Συστήματα Όταν μιλάμε για παράλληλα συστήματα ουσιαστικά αναφερόμαστε σε ένα σύστημα με πολλές επεξεργαστικές μονάδες (CPUs) που συνεργάζονται και επικοινωνούν για την επίτευξη του αποτελέσματος. Οι επεξεργαστές δηλαδή αναλαμβάνουν διάφορα μέρη του προβλήματος και στη συνέχεια επικοινωνούν για να συγκεντρώσουν και να συνδυάσουν τα επιμέρους αποτελέσματα τους ώστε να συμπληρώσουν το τελικό επιθυμητό αποτέλεσμα. 5

6 Η ανάπτυξη των παράλληλων συστημάτων έχει δημιουργήσει νέες απαιτήσεις στους προγραμματιστές. Για να προγραμματίσει κάποιος ένα παράλληλο σύστημα χρειάζεται να λάβει υπόψιν του την αρχιτεκτονική και να διαχειριστεί με ειδικό τρόπο τα συστατικά του προγράμματος (συναρτήσεις, μεταβλητές κ.α.) καθώς πλέον θα είναι κοινόχρηστα για περισσότερες υπολογιστικές οντότητες (νήματα, διεργασίες). Υπάρχουν δύο βασικά συστήματα παράλληλων αρχιτεκτονικών. Το σύστημα κοινής μνήμης και το σύστημα κατανεμημένης μνήμης. Ανάλογα με το σύστημα που έχουμε, ο προγραμματιστής θα πρέπει να ακολουθήσει διαφορετικές προγραμματιστικές λογικές και μεθόδους. Το ποιο είναι πιο αποδοτικό εξαρτάται από το πρόβλημα που έχουμε να αντιμετωπίσουμε Σύστημα Κοινής Μνήμης Στα συστήματα κοινής μνήμης οι επεξεργαστές έχουν πρόσβαση σε ένα κοινό χώρο διευθύνσεων. Η επικοινωνία μεταξύ των επεξεργαστών γίνεται μέσω αυτής της κοινής μνήμης αλλάζοντας τις τιμές των μεταβλητών. Οι μεταβλητές καθώς και οι αλλαγές που γίνονται σε αυτές, είναι ορατές από όλους τους επεξεργαστές που έχουν πρόσβαση στην κοινή μνήμη. Μπορεί όλη αυτή η λογική να φαίνεται αποτελεσματική και απλά δομημένη και πράγματι είναι, όμως για μικρό αριθμό επεξεργαστών. Αυτό συμβαίνει για το λόγο οτι σε τέτοια συστήματα η μορφή του δικτύου διασύνδεσης μεταξύ των επεξεργαστών είναι ένας δίαυλος. Αν αυξήσουμε τον αριθμό των επεξεργαστών, θα αυξηθεί και ο αριθμός των επικοινωνιών, αλλά η χωρητικότητα του διαύλου μένει σταθερή με αποτέλεσμα η απόδοση να πέφτει. Έτσι δεν μπορούμε να έχουμε τέτοια συστήματα με μεγάλο αριθμό επεξεργαστών. Για τον προγραμματισμό, τα παράλληλα συστήματα κοινής μνήμης ακολουθούν το μοντέλο κοινού χώρου διευθύνσεων. Γίνεται χρήση είτε διεργασιών, είτε νημάτων που δημιουργούνται από τη διεργασία εκτέλεσης του προγράμματος και διαθέτουν κοινόχρηστες μεταβλητές. Βέβαια σε αυτό το μοντέλο χρησιμοποιούνται περισσότερο τα νήματα καθώς οι διεργασίες έχουν δικό τους ξεχωριστό χώρο διευθύνσεων η κάθε μια και θα πρέπει η ύπαρξη κοινής μνήμης να διασφαλιστεί με κλήσεις συστήματος. Αντίθετα τα νήματα που έχουν δημιουργηθεί από την ίδια διεργασία, βλέπουν το χώρο διευθύνσεων της διεργασίας που τα δημιούργησε αλλά έχουν δικό τους μετρητή προγράμματος. Ακόμα όμως και με την ύπαρξη των διεργασιών και των νημάτων, ο προγραμματιστής για να προγραμματίσει σε μοντέλο κοινού χώρου διευθύνσεων θα πρέπει πάλι να λάβει υπόψιν του τον τρόπο λειτουργίας αυτών. Για αυτό το λόγο, έχει αναπτυχθεί ένα πρότυπο προγραμματισμού για παράλληλα συστήματα κοινής μνήμης, το OpenMP. Για το OpenMP γίνεται εκτενής αναφορά στο Κεφάλαιο 2, μιας και αποτελεί μέρος αυτής της εργασίας Σύστημα Κατανεμημένης Μνήμης Στο σύστημα κατανεμημένης μνήμης, οι επεξεργαστές έχουν ο καθένας τη δικιά του ιδιωτική μνήμη και συνδέονται μεταξύ τους μέσω ενός δικτύου με το οποίο επικοινωνούν. Κάθε επεξεργαστής μπορεί άμεσα να προσπελάσει και να επεξεργαστεί μόνο τα δεδομένα που βρίσκονται στην ιδιωτική του μνήμη. Αν κάποιος επεξεργαστής 6

7 επιθυμεί να προσπελάσει κάποιο δεδομένο (μεταβλητή) που δεν έχει στη μνήμη του, τότε στέλνει ένα μήνυμα στο δίκτυο το οποίο θα παραλάβει ο επεξεργαστής που έχει το δεδομένο. Στη συνέχεια ο τελευταίος θα του το στείλει με μήνυμα στο δίκτυο. Ένα σύστημα κατανεμημένης μνήμης είναι το cluster. Πρόκειται ουσιαστικά για μια συστάδα υπολογιστών συνδεδεμένων μεταξύ τους με ένα δίκτυο οι οποίοι συνεργάζονται για την επίλυση ενός προβλήματος. Η αλήθεια είναι οτι σε αυτό το μοντέλο δεν έχουμε το πρόβλημα μεγέθους που είχαμε στο μοντέλο κοινής μνήμης. Εδώ μπορούμε να έχουμε οσοδήποτε αριθμό κόμβων και άρα επεξεργαστών και οποιαδήποτε τοπολογία δικτύου με την οποία αυτοί θα συνδέονται. Βέβαια αν το πρόβλημα μας απαιτεί οτι πολλά δεδομένα θα πρέπει να είναι προσπελάσιμα από πολλές διεργασίες, τότε ο φόρτος επικοινωνιών γίνεται μεγάλος και ως επόμενο έχουμε επιβάρυνση στο χρόνο εκτέλεσης του προγράμματος που φτάνει ακόμα και σε χειρότερες επιδόσεις από την περίπτωση του σειριακού. Για τον προγραμματισμό ενός συστήματος κατανεμημένης μνήμης ακολουθείται το μοντέλο μεταβίβασης μηνυμάτων. Χρησιμοποιούνται συνήθως διεργασίες σε αντιστοιχία 1 προς 1 με κάθε επεξεργαστή. Όπως είπαμε η επικοινωνία σε αυτό το μοντέλο γίνεται με τη βοήθεια μηνυμάτων μέσω του δικτύου διασύνδεσης των επεξεργαστών. Συνήθως για τον προγραμματισμό όλης της διαδικασίας ανταλλαγής μηνυμάτων χρησιμοποιείται το πακέτο MPI [1]. Το MPI προσφέρει ρουτίνες για την αποστολή και παραλαβή μηνυμάτων, καθώς και ρουτίνες που προσφέρουν μια ποικιλία από λειτουργίες χωρίς να χρειάζεται ο προγραμματιστής να ασχοληθεί ή ακόμα και να γνωρίζει τις λεπτομέρειες του δικτύου που υπάρχει από κάτω. Η χρήση της επικοινωνίας μέσω μηνυμάτων μεταξύ των κόμβων, προκύπτει από το γεγονός, οτι στο μοντέλο αυτό δεν έχουμε κοινόχρηστη μνήμη. Σιγά σιγά αναπτύχθηκε η λογική της δημιουργίας εικονικής κοινής μνήμης επάνω από τη φυσικά κατανεμημένη μνήμη, από το TreadMarks [2]. Πρόκειται ουσιαστικά για κοινή μνήμη που υλοποιείτε από λογισμικό, το λεγόμενο sdsm, δίνοντας την ψευδαίσθηση ύπαρξής της στους επεξεργαστές του μοντέλου. Τη λογική αυτή ακολούθησαν και άλλα sdsm συστήματα παρουσιάζοντας ίδια λειτουργικότητα αλλά διαφορές στον τρόπο διατήρησης της συνέπειας μνήμης. Άξιο επισήμανσης λόγω της σχετικότητας με το αντικείμενο της παρούσας πτυχιακής εργασίας, είναι και η ύπαρξη clusters που αποτελούνται από μονάδες συστημάτων κοινής μνήμης. Με λίγα λόγια συνδυάζει τις δύο προαναφερθείσες αρχιτεκτονικές όπου πολλοί υπολογιστές που αποτελούνται από πολλές επεξεργαστικές μονάδες συνδυάζονται και επικοινωνούν για την επίλυση ενός προβλήματος. 1.3 Αντικείμενο Πτυχιακής Εργασίας Το αντικείμενο της εργασίας αφορά τη βελτιστοποίηση του OMPi στην εκτέλεση προγραμμάτων σε συστάδες υπολογιστών. Ο OMPi (Κεφάλαιο 3) είναι ένας μεταγλωττιστής source-to-source προγραμμάτων OpenMP (Κεφάλαιο 2) σε γλώσσα προγραμματισμού C. Ο OMPi ήδη υποστηρίζει εκτέλεση προγραμμάτων OpenMP σε συστάδες υπολογιστών χωρίς όμως να εκμεταλλεύεται την κοινή μνήμη που μπορεί να υπάρχει σε κάποιο κόμβο, στην περίπτωση που αυτός είναι αρχιτεκτονικής κοινής μνήμης. 7

8 Το OpenMP όπως αναφέρθηκε προηγουμένως είναι ένα προγραμματιστικό πρότυπο για προγραμματισμό σε μοντέλο κοινού χώρου διευθύνσεων. Σε συστάδες υπολογιστών (clusters), δεν υπάρχει κοινόχρηστη μνήμη και πρέπει οι επικοινωνίες να γίνουν μέσω μηνυμάτων. Για να εκτελέσουμε προγράμματα OpenMP σε συστάδες υπολογιστών χρησιμοποιούμε ειδικό λογισμικό που μας παρέχει εικονική κοινή μνήμη, το SVM (Shared Virtual Memory). Ο OMPi σε αντίθεση με άλλους μεταφραστές που χρησιμοποιούν και είναι στενά συνδεδεμένοι με ένα SVM, μπορεί να λειτουργήσει με πολλά SVM όπως το Mocha, το Treadmarks κ.α. Επίσης χρησιμοποιεί ένα υβριδικό μοντέλο επικοινωνιών, καθώς για τις κοινές μεταβλητές χρησιμοποιεί την κοινόχρηστη μνήμη ενώ για τις επικοινωνίες μεταξύ των διεργασιών χρησιμοποιεί MPI. Ο OMPi αποτελείται από πολλές βιβλιοθήκες χρόνου-εκτέλεσης οι οποίες διαφέρουν ως προς τις υπολογιστικές οντότητες που παρέχουν. Υπάρχουν βιβλιοθήκες νημάτων πυρήνα (POSIX, Solaris), νημάτων χρήστη (POSIX, Marcell) και διεργασιών. Η τελευταία είναι απαραίτητη στον OMPi, για την εκτέλεση προγραμμάτων OpenMP σε συστάδες υπολογιστών καθώς δημιουργεί διεργασίες ως υπολογιστικές οντότητες για την εκτέλεση του προγράμματος, οι οποίες επικοινωνούν μέσω μηνυμάτων. Στην περίπτωση που οι κόμβοι είναι αρχιτεκτονικής κοινής μνήμης μπορεί να δημιουργήσει περισσότερες από μια διεργασίες για να αξιοποιήσει την επεξεργαστική ισχύ των πυρήνων του κόμβου, αυτές όμως θα επικοινωνούν μέσω MPI και άρα δεν μπορούν να εκμεταλλευτούν την ύπαρξη κοινής μνήμης. Στόχος λοιπόν είναι η εκμετάλλευση αυτής της κοινής μνήμης καθώς και της επεξεργαστικής ισχύος αυτών των κόμβων με την δημιουργία και προσάρτηση μιας βιβλιοθήκης χρόνου-εκτέλεσης (runtime library) στις ήδη υπάρχουσες βιβλιοθήκες του OMPi, η οποία: Παρέχει τοπικά νήματα επιπέδου-πυρήνα σε κάθε κόμβο αντί για διεργασίες. Τα νήματα χαρακτηρίζονται ως ελαφριές διεργασίες καθώς έχουν μικρότερο κόστος δημιουργίας και διαχείρισης από τις διεργασίες. Χρησιμοποιεί την φυσική τοπική κοινόχρηστη μνήμη του κόμβου για την επικοινωνία των νημάτων και περιορίζει όσο το δυνατόν τις επικοινωνίες MPI μεταξύ των οντοτήτων υπολογισμού. 1.4 Δομή της Εργασίας Ακολουθεί μια περιληπτική περιγραφή της δομής των κεφαλαίων της παρούσας εργασίας. Κεφάλαιο 2: Παρουσίαση και περιγραφή του προτύπου OpenMP για παράλληλο προγραμματισμό πάνω σε μοντέλο κοινού χώρου διευθύνσεων. Γίνεται επίσης και ανάλυση των εντολών που αποτελούν το πρότυπο. Κεφάλαιο 3: Παρουσίαση και περιγραφή του μετασχηματιστή OMPi. Αναλύεται ο τρόπος λειτουργίας καθώς και τα μέρη που τον αποτελούν. Κεφάλαιο 4: Ο OMPi χρησιμοποιώντας την νέα βιβλιοθήκη χρόνου-εκτέλεσης που προστέθηκε για καλύτερη συμπεριφορά σε εκτέλεση προγραμμάτων OpenMP σε συστάδες υπολογιστών. Κεφάλαιο 5: Περιγράφονται και αναλύονται τα αποτελέσματα από την εκτέλεση διάφορων εφαρμογών για την συγκριτική μελέτη του OMPi με τη νέα βιβλιοθήκη. 8

9 Κεφάλαιο 6: Γίνεται ένας επίλογος της όλης εργασίας και δίνονται κάποιες συμβουλές για περαιτέρω μελλοντική εργασία πάνω στον OMPi. 9

10 Κεφάλαιο 2 Το πρότυπο OpenMP 2.1 Εισαγωγή στο OpenMP Η όλο και συνεχόμενη ανάπτυξη των παράλληλων συστημάτων, ειδικότερα κοινής μνήμης, έφερε και νέες προγραμματιστικές απαιτήσεις στους προγραμματιστές αυτών των συστημάτων. Ο προγραμματιστής θα πρέπει να διαχειριστεί με πιό εξειδικευμένο τρόπο τα συστατικά του προγράμματος (συναρτήσεις, μεταβλητές κ.α.) καθώς αυτά προσπελάζονται από περισσότερες οντότητες και πρέπει να προστατευθούν για να είναι συνεπείς. Η δημιουργία ενός παράλληλου προγράμματος απέχει πολύ σε όγκο εντολών από οτι ένα αντίστοιχο σειριακό πρόγραμμα που κάνει την ίδια δουλειά. Λόγω αυτών των δυσκολιών, δημιουργήθηκε η ανάγκη για τη δημιουργία ενός προτύπου για την διευκόλυνση της συγγραφής παράλληλων προγραμμάτων. Αυτό το πρότυπο είναι το OpenMP (Open Multi-Processing). Το OpenMP [3] είναι μια διεπαφή δημιουργίας παράλληλων εφαρμογών σε συστήματα κοινής μνήμης. Υποστηρίζει τις γλώσσες προγραμματισμού Fortran, C και C++ και υποστηρίζεται από πολλές αρχιτεκτονικές. Αποτελείται από ένα σύνολο: Οδηγιών προς τον μεταγλωττιστή. Τα λεγόμενα pragmas ή directives, τα οποία εισάγει ο προγραμματιστής στο πρόγραμμα του. Ουσιαστικά πρόκειται για οδηγίες που δίνει ο προγραμματιστής στο μεταγλωττιστή για το τι θέλει να παραλληλοποιήσει και πως. Συναρτήσεις βιβλιοθήκης. Είναι συναρτήσεις τις οποίες καλεί ο προγραμματιστής σε οποιοδήποτε σημείο του προγράμματος για να αλλάξει των αριθμό των νημάτων που θα εκτελέσουν μια παράλληλη περιοχή, να χρησιμοποιήσει τις κλειδαριές του OpenMP κ.α. Μεταβλητές περιβάλλοντος. Είναι μεταβλητές που ορίζουν εκ των προτέρων τον τρόπο εκτέλεσης των παράλληλων περιοχών του προγράμματος. Η συγγραφή ενός προγράμματος OpenMP θα μπορούσαμε να πούμε οτι είναι κλιμακωτή καθώς μπορεί ο προγραμματιστής να δημιουργήσει το σειριακό πρόγραμμα και πολύ εύκολα εισάγοντας τις οδηγίες OpenMP στο πρόγραμμα του, σταδιακά να το κάνει παράλληλο. Βέβαια το να αποκρύπτονται οι λεπτομέρειες της παραλληλίας και της διαχείρισης των νημάτων από τον προγραμματιστή δεν είναι και πάντα θετικό. Το OpenMP δεν εξασφαλίζει την μέγιστη αποδοτικότητα της παραλληλίας σε κοινή μνήμη και επίσης δεν είναι εφικτή η διαχείριση ενός υποσυνόλου νημάτων από τα νήματα που θα εκτελέσουν ένα μέρος του κώδικα. Παρόλα στα θετικά του OpenMP θα μπορούσαμε να αναφέρουμε τη δυνατότητα υποστήριξης δυναμικού ορισμού του αριθμού των νημάτων που θα εκτελέσουν μια παράλληλη περιοχή OpenMP κατα τη διάρκεια του προγράμματος καθώς και την υποστήριξη λεπτού και αδρού καταμερισμού του παραλληλισμού. 2.2 Προγραμματιστικό Μοντέλο Το OpenMP όπως αναφέρθηκε προηγουμένως είναι ένα πρότυπο παράλληλου 10

11 προγραμματισμού σε συστήματα κοινής μνήμης. Επομένως το προγραμματιστικό του μοντέλο, αφορά τη δημιουργία και τη συνύπαρξη νημάτων για την εκτέλεση του προγράμματος. Τα νήματα αυτά επικοινωνούν με κοινές μεταβλητές. Η δημιουργία τους είναι πολύ κοντά στην λογική fork-join που έχουμε στις διεργασίες. int main () { int id; } omp_set_num_threads(4); #pragma omp parallel { int id = omp_get_thread_num(); printf("hello, i am thread #%d\n", id); } return 0; Έξοδος: Hello, i am thread #0 Hello, i am thread #1 Hello, i am thread #2 Hello, i am thread #3 Το αρχικό νήμα του προγράμματος, το νήμα δηλαδή που ξεκινάει την εκτέλεση του προγράμματος, όταν συναντήσει μια περιοχή που πρέπει να παραλληλοποιηθεί (#pragma omp parallel), δημιουργεί μια ομάδα νημάτων των οποίων ο αριθμός ορίζεται είτε δυναμικά, είτε στατικά. Αυτά με την σειρά τους θα εκτελέσουν το τμήμα παραλληλίας που τους αντιστοιχεί. Για το παραπάνω παράδειγμα, το αρχικό νήμα θα δημιουργήσει μια ομάδα 4 νημάτων (omp_set_num_threads(4)) που θα εκτελέσουν τον κώδικα που βρίσκεται μέσα στο block του parallel. Το αρχικό νήμα περιμένει στο τέλος της παράλληλης περιοχής τα νήματα που δημιούργησε να τελειώσουν τη δουλειά τους, οπότε και καταστρέφεται και η ομάδα. Στη συνέχεια το αρχικό νήμα συνεχίζει την εκτέλεση του κώδικα σειριακά. Τα νήματα δηλαδή συγχρονίζονται και επικοινωνούν σε ένα πρόγραμμα OpenMP αυτόματα. Βέβαια η κοινοχρησία των πόρων απαιτεί και την προστασία αυτών, αλλά το OpenMP προσφέρει πληθώρα οδηγιών και παραμέτρων για αυτή τη δουλειά. Λόγω της παραπάνω λογικής που ακολουθείται από το αρχικό νήμα για τη δημιουργία νημάτων, η συγγραφή ενός OpenMP προγράμματος θα μπορούσαμε να πούμε οτι είναι κλιμακωτή. Γράφουμε το παράλληλο πρόγραμμα αρχικά όπως θα γράφαμε ένα αντίστοιχο σειριακό και στη συνέχεια προσθέτουμε τις οδηγίες στις περιοχές που θέλουμε να παραλληλοποιήσουμε. Έτσι βαθμιαία το πρόγραμμα από σειριακό, μετατρέπετε σε παράλληλο με νήματα. 2.3 Οδηγίες OpenMP Σε αυτό την την ενότητα θα ασχοληθούμε με τις οδηγίες του OpenMP πάνω στις γλώσσες C και C++, καθώς η παρούσα πτυχιακή εργασία και γενικότερα ο OMPi, αφορά των μετασχηματισμό των οδηγιών του OpenMP πάνω σε αυτές τις γλώσσες. 11

12 Στις ενότητες που ακολουθούν, αναλύεται η σύνταξη καθώς και οι παράμετροι των οδηγιών αυτών. Αναλύεται επίσης η δομή της παράλληλης περιοχής και γίνεται μια γενικότερη περιγραφή των οδηγιών αυτών χωρίζοντάς τες σε οδηγίες διαμοιρασμού εργασίας (workshare regions) και οδηγίες συγχρονισμού Σύνταξη Οδηγιών Οι οδηγίες OpenMP ακολουθούν μια καθορισμένη σύνταξη που χωρίζεται σε τρία μέρη. Πρώτα εμφανίζεται η έκφραση #pragma omp. Όλες οι οδηγίες στο πρότυπο ξεκινούν με αυτόν τον τρόπο. Δεν ορίζει κάτι συγκεκριμένο και ουσιαστικό ως προς τον τρόπο που θα μετασχηματιστεί το τμήμα που ακολουθεί. Στη συνέχεια τοποθετείται το όνομα της οδηγίας. Υπάρχουν οδηγίες συγχρονισμού και οδηγίες παραλληλίας. Τελευταίες μετά το όνομα της οδηγίας τοποθετούνται οι συνθήκες της περιοχής που ακολουθεί γενικότερα. Εδώ δεν έχουμε κάποια ειδική σειρά στον τρόπο με τον οποίο θα τοποθετήσουμε τις συνθήκες των οδηγιών. Οι οδηγίες θα πρέπει να εφαρμόζονται σε δομημένα τμήματα κώδικα, με ένα σημείο εισόδου και ένα σημείο εξόδου. Από τη στιγμή που οι οδηγίες OpenMP είναι pragmas και directives πρόκειται ουσιαστικά για οδηγίες προς τον μεταγλωττιστή. Είναι οδηγίες που λένε στον μεταγλωττιστή με ποιό τρόπο θα μετασχηματίσει το block εντολών που βρίσκεται μέσα στις αγκύλες του pragma. Για αυτό ακριβώς το λόγο, αν ο μεταγλωττιστής δεν υποστηρίζει OpenMP απλά αγνοεί τα pragmas και τα directives και μεταφράζει το πρόγραμμα σαν να μην υπήρχαν. Ουσιαστικά το πρόγραμμα γίνεται σειριακό Παράλληλα Τμήματα Για να ορίσουμε ένα τμήμα κώδικα ως παράλληλο τμήμα θα πρέπει να τοποθετήσουμε στην αρχή του την έκφραση #pragma omp parallel... και ο κώδικας που θα βρίσκεται μέσα σε αγκύλες θα εκτελεστεί παράλληλα. Όταν το αρχικό νήμα του προγράμματος, το νήμα master δηλαδή, συναντήσει αυτήν την έκφραση, θα δημιουργήσει μια ομάδα με τον απαιτούμενο αριθμό νημάτων και κάθε ένα από αυτά θα εκτελέσει τον κώδικα που βρίσκεται μέσα στις αγκύλες. Στην ομάδα των νημάτων που θα εκτελέσουν τον κώδικα συμπεριλαμβάνεται και το νήμα master και μάλιστα έχει αριθμό αναγνωριστικού το 0. Στο τέλος της περιοχής υπονοείται πως υπάρχει συγχρονισμός μεταξύ των νημάτων, δηλαδή θα πρέπει να φτάσουν όλα εκεί για να τελειώσει η παράλληλη περιοχή και να συνεχίσει το αρχικό νήμα, την εκτέλεση του υπόλοιπου προγράμματος. Μπορούμε μέσα σε ένα παράλληλο τμήμα να τοποθετήσουμε ένα ή και περισσότερα παράλληλα τμήματα. Τα τελευταία ονομάζονται εμφωλευμένα (nested). Το OpenMP υποστηρίζει εμφωλευμένη παραλληλία αλλά εξαρτάται από τον μεταγλωττιστή αν θα την υλοποιήσει και πως. Κάθε νήμα που βρίσκει μια εμφωλευμένη παράλληλη περιοχή, παίρνει το ρόλο του νήματος master για αυτή την παράλληλη περιοχή. Δημιουργεί δηλαδή την ομάδα με τον απαιτούμενο αριθμό νημάτων που θα εκτελέσουν τον κώδικα της εμφωλευμένης περιοχής και αυτά εκτελούν για λογαριασμό τους τον κώδικα που τους αντιστοιχεί. Και σε αυτήν την περίπτωση το νήμα master που δημιούργησε την ομάδα συμμετέχει σε αυτήν και εκτελεί και αυτό τον κώδικα που του αντιστοιχεί. Μπορούμε να έχουμε πολλά επίπεδα παραλληλίας στα οποία ακολουθείτε η παραπάνω λογική. 12

13 Υπάρχουν πολλοί τρόποι για να ορίσουμε το πόσα νήματα θα εκτελέσουν μια παράλληλη περιοχή. Το OpenMP προσφέρει συναρτήσεις βιβλιοθήκης, μεταβλητές περιβάλλοντος καθώς και συνθήκες που τοποθετούνται στις εκφράσεις των οδηγιών με τις οποίες μπορούμε να διαχειριστούμε των αριθμό των νημάτων που θα εκτελέσουν μια παράλληλη περιοχή. Εκ των προτέρων, πριν την εκτέλεση δηλαδή του προγράμματος μπορούμε με την μεταβλητή περιβάλλοντος OMP_NUM_THREADS, με την κλήση της συνάρτησης omp_set_num_threads() μέσα στο πρόγραμμα και τοποθετώντας τη συνθήκη num_threads() στην έκφραση του pragma είναι οι τρεις τρόποι που μας παρέχει το OpenMP για να ορίσουμε τον αριθμό των νημάτων. Το OpenMP προσφέρει και τη δυνατότητα ο αριθμός των νημάτων να προσαρμόζεται δυναμικά για συγκεκριμένη παράλληλη περιοχή. Αυτό επιτυγχάνεται με δύο τρόπους, είτε εκ των προτέρων πριν την εκτέλεση του προγράμματος με την μεταβλητή περιβάλλοντος OMP_DYNAMIC, είτε με την συνάρτηση omp_set_dynamic() Οδηγίες Διαμοίρασης Έργου Το OpenMP μας παρέχει τρεις δομές οδηγιών διαμοίρασης έργου. Την οδηγία for, την οδηγία sections και την οδηγία single. Οι δομές αυτές χρησιμεύουν στο διαχωρισμό και τη διαμοίραση της εργασίας που πρόκειται να εκτελεστεί μέσω ενός τμήματος κώδικα, στα νήματα. Για να χρησιμοποιήσουμε μια οδηγία διαμοίρασης έργου θα πρέπει να την τοποθετήσουμε μέσα σε μια παράλληλη περιοχή. Αυτό συνεπάγεται οτι με την ύπαρξη μιας τέτοιας οδηγίας δεν θα δημιουργηθεί μια καινούρια ομάδα νημάτων και οτι η διαμοίραση θα γίνει μεταξύ των νημάτων που συμμετέχουν στην ομάδα. Κατ επέκταση δεν έχουμε συγχρονισμό των νημάτων κατά την είσοδο σε μια δομή διαμοίρασης έργου, υπονοείται όμως συγχρονισμός στο τέλος. Βέβαια προσθέτοντας σε οποιαδήποτε από αυτές τις οδηγίες τη συνθήκη nowait, ο συγχρονισμός στο τέλος παραλείπεται. Ας δούμε όμως πιο αναλυτικά αυτές τις τρεις δομές διαμοίρασης έργου περιγράφοντας τη χρησιμότητά τους καθώς και τον τρόπο που διαμοιράζουν το έργο μεταξύ των νημάτων. Οδηγία for. Αμέσως μετά την ύπαρξη αυτής της οδηγίας θα πρέπει αυστηρά να εμφανίζεται μια δομή επανάληψης for την οποία και θα παραλληλοποιήσει. Δε χρειάζεται να τοποθετήσουμε αγκύλες για να ορίσουμε τον κώδικα της οδηγίας καθώς αυτός ορίζεται από τις αγκύλες της for. Με την οδηγία αυτή ουσιαστικά διαμοιράζονται οι επαναλήψεις της for που ακολουθεί, μεταξύ των νημάτων. Το πως θα διαμοιραστούν αυτές οι επαναλήψεις θα το δούμε πιο αναλυτικά αργότερα όταν θα μιλήσουμε για τις συνθήκες των οδηγιών. To OpenMP προς χάριν συντόμευσης και λόγω της συχνής παραλληλοποίησης των δομών for προσφέρει τη δυνατότητα του ορισμού αυτής της οδηγίας μαζί με τον ορισμό της παράλληλης περιοχής με την συγγραφή: #pragma omp parallel for for(;;) //code Οδηγία sections. Με την οδηγία sections ορίζουμε τμήματα εργασιών κάθε ένα από τα οποία θα εκτελεστεί από ένα μόνο νήμα. Ουσιαστικά αναθέτουμε σε κάθε νήμα δομημένα block κώδικα που μπορούν να μην έχουν καμία σχέση όσον αφορά τη λειτουργικότητα αυτών. Άρα τα νήματα παράλληλα μπορούν να 13

14 εκτελούν διαφορετικές εργασίες. Για να ορίσουμε οτι ένα μέρος κώδικά μέσα στην οδηγία αποτελεί ξεχωριστή περιοχή που θα εκτελέσει ένα μόνο νήμα της ομάδας θα πρέπει να το τοποθετήσουμε μέσα σε αγκύλες στην αρχή των οποίων θα υπάρχει η οδηγία #pragma omp section. Οδηγία single. Η ύπαρξη αυτής της οδηγίας συνεπάγεται οτι το πρώτο νήμα της ομάδας που θα τη συναντήσει θα είναι αυτό και μόνο που θα εκτελέσει τον κώδικα που υπάρχει μέσα στις αγκύλες της. Όλα τα άλλα νήματα θα προσπεράσουν την οδηγία και θα περιμένουν μέχρι να τελειώσει τον κώδικα το νήμα που βρίσκεται μέσα σε αυτήν, καθώς όπως προαναφέρθηκε, υπονοείται συγχρονισμός μετά από κάθε δομή διαμοίρασης έργου. Τέλος, είναι καλό να αναφερθεί και η ύπαρξη της οδηγίας master. Η συγκεκριμένη οδηγία μπορεί να μη θεωρείται οδηγία διαμοίρασης έργου, αλλά έχει παρόμοια συμπεριφορά με αυτήν της single. Και σε αυτήν την οδηγία, τον κώδικα που περικλείεται από αυτήν την εκτελεί ένα μόνο νήμα της ομάδας με τη διαφορά όμως οτι εδώ το νήμα θα είναι αυστηρά το master. Σε αντίθεση με τις οδηγίες διαμοίρασης εργασίας εδώ δεν υπονοείται συγχρονισμός στο τέλος Οδηγίες Συγχρονισμού Το OpenMP παρέχει και οδηγίες για τον συγχρονισμό μεταξύ των νημάτων όσον αφορά την εκτέλεση κώδικα καθώς και τη συνέπεια των κοινόχρηστων μεταβλητών που υπάρχουν μεταξύ τους. Ακολουθεί περιγραφή των οδηγιών αυτών. Οδηγία critical. Με αυτή την οδηγία ορίζουμε μια κρίσιμη περιοχή κώδικα. Στην κρίσιμη περιοχή μπορεί να βρίσκεται μόνο ένα νήμα, ενώ όλα τα άλλα περιμένουν πριν από αυτή μέχρι να τελειώσει τη δουλειά του και να μπορέσουν και αυτά στη συνέχεια να αποκτήσουν το δικαίωμα να μπουν σε αυτήν. Η κρίσιμη περιοχή είναι απαραίτητη σε τμήματα κώδικα που πρόκειται να εκτελεστούν παράλληλα και αλλάζουν κοινόχρηστες μεταβλητές. Με την ύπαρξη ενός μόνο νήματος τη φορά μέσα στην κρίσιμη περιοχή διασφαλίζεται η ακεραιότητα των τιμών των μεταβλητών. Οδηγία atomic. Η atomic κάνει ουσιαστικά την ίδια δουλειά με την critical με τη διαφορά οτι χρησιμοποιείται για απλές εντολές που αλλάζουν την τιμή μιας κοινόχρηστης μεταβλητής και ανανεώνει την θέση μνήμης αυτής με τη νέα τιμή. Οδηγία barrier. Με τη χρησιμοποίηση αυτής της οδηγίας δίνουμε εντολή στα νήματα της ομάδας να συγχρονιστούν σε εκείνο το σημείο. Μόλις ένα νήμα συναντήσει αυτήν την οδηγία σταματάει και περιμένει όλα τα νήματα της ομάδας να φτάσουν σε εκείνο το σημείο. Όταν τελικά όλα τα νήματα συναντήσουν την οδηγία μπορούν να συνεχίσουν όλα μαζί να εκτελούν τον κώδικα που ακολουθεί. Ένα από τα ελαττώματα του OpenMP είναι οτι δεν μπορούμε να περιορίσουμε την οδηγία barrier σε ένα υποσύνολο νημάτων της ομάδας και πρέπει να την εφαρμόσουμε σε όλα. Οδηγία flush. Η οδηγία αυτή προσφέρει συνέπεια μνήμης. Ουσιαστικά επιβάλει την άμεση εγγραφή των κοινόχρηστων μεταβλητών που έχει ως ορίσματα η οδηγία ή αν σε περίπτωση που δεν έχει ορίσματα, όλων των κοινόχρηστων μεταβλητών στη μνήμη. Πρόκειται δηλαδή για ένα είδος συγχρονισμού μνήμης. Οδηγία ordered. Η οδηγία ordered επιβάλει την εκτέλεση ενός τμήματος κώδικα 14

15 με την ακολουθιακή του σειρά. Είναι χρήσιμη για τμήματα κώδικα που υπάρχουν μέσα σε παράλληλες περιοχές και θέλουμε να εκτελεστούν ακολουθιακά όπως θα εκτελούνταν στο σειριακό πρόγραμμα Συνθήκες Οδηγιών Οι οδηγίες OpenMP επιδέχονται και κάποιες συνθήκες που μπορούμε να εισάγουμε ώστε να ρυθμίσουμε τον τρόπο που θα παραλληλοποιηθεί ο κώδικας που ακολουθεί καθώς και την πολιτική κοινοχρησίας ή μη, των μεταβλητών του κώδικα που ακολουθεί. Οι συνθήκες αυτές, όπως είδαμε και στην ενότητα τοποθετούνται μετά το όνομα της οδηγίας. Ακολουθεί μια περιγραφή και αναφορά των συνθηκών που χρησιμοποιούνται στο OpenMP. if(συνθήκη). Μόνο αν η συνθήκη μέσα στο if είναι αληθής, θα εκτελεστεί ο κώδικας που ακολουθεί παράλληλα. Αν όχι, τότε ο κώδικας θα εκτελεστεί σειριακά σαν να μην υπήρχε η οδηγία. shared(λίστα μεταβλητών). Οι μεταβλητές που βρίσκονται στη λίστα μεταβλητών, θα είναι κοινόχρηστες για όλα τα νήματα που θα εκτελέσουν τον κώδικα της παράλληλης περιοχής. private(λίστα μεταβλητών). Οι μεταβλητές που βρίσκονται στη λίστα μεταβλητών, θα είναι ιδιωτικές για κάθε νήμα που θα εκτελέσει τον κώδικα της παράλληλης περιοχής. Οι μεταβλητές αυτές δεν είναι αρχικοποιημένες. fisrtprivate(λίστα μεταβλητών). Οι μεταβλητές της λίστας μεταβλητών αποτελούν ιδιωτικά αντίγραφα από τις αντίστοιχες μεταβλητές του νήματος master για το κάθε νήμα. Είναι αρχικοποιημένες με τις τιμές του νήματος master. lastprivate(λίστα μεταβλητών). Οι ιδιωτικές μεταβλητές της λίστας μεταβλητών θα περάσουν τις τιμές που έχουν από την τελευταία επανάληψη ή τμήμα που εκτελέστηκε της παράλληλης περιοχής στις αντίστοιχες καθολικές μεταβλητές. nowait. Όπως αναφέρθηκε και προηγουμένως, η συγκεκριμένη συνθήκη χρησιμοποιείται για να ακυρωθεί ο συγχρονισμός στο τέλος της οδηγίας, αν αυτός υπάρχει. num_threads(αριθμός). Με αυτόν τον τρόπο μπορούμε να ορίσουμε τον αριθμό των νημάτων που θα συμμετέχουν στην ομάδα και θα εκτελέσουν την παράλληλη περιοχή που ακολουθεί. schedule(τύπος [,μέγεθος κόκκου]). Χρησιμοποιώντας αυτήν τη συνθήκη ρυθμίζουμε το μέγεθος της εργασίας καθώς και τον τρόπο με τον οποίο θα διαμοιραστούν οι επαναλήψεις του βρόγχου μεταξύ των νημάτων. Υπάρχουν τέσσερις τύποι για δρομολόγησης. static: οι επαναλήψεις χωρίζονται στατικά σε κομμάτια ίσα με το μέγεθος που έχει οριστεί και διαμοιράζονται κυκλικά στα νήματα της ομάδας. Αν δεν έχει οριστεί κάποιο μέγεθος, τότε η εξ ορισμού συμπεριφορά του είναι τμήματα εργασίας μεγέθους n/p, όπου n ο αριθμός των επαναλήψεων και p ο αριθμός των νημάτων της ομάδας. dynamic: οι επαναλήψεις χωρίζονται σε κομμάτια ίσα με το μέγεθος που έχει 15

16 οριστεί στη συνθήκη και διαμοιράζονται στα νήματα. Όταν ένα νήμα τελειώσει το δικό του κομμάτι, παίρνει δυναμικά το επόμενο. Αν δεν οριστεί μέγεθος συνήθως η εξ ορισμού συμπεριφορά, είναι τμήματα μεγέθους 1. guided: οι επαναλήψεις χωρίζονται σε κομμάτια ίσα με το μέγεθος που έχει οριστεί και διαμοιράζονται στα νήματα. Όταν ένα νήμα τελειώσει το δικό του κομμάτι, παίρνει δυναμικά το επόμενο του οποίου το μέγεθος όλο και μικραίνει εκθετικά. runtime: όταν έχουμε αυτόν τον τύπο τότε ο αλγόριθμος δρομολόγησης θα καθοριστεί από την αντίστοιχη μεταβλητή περιβάλλοντος. reduction(πράξη: λίστα μεταβλητών). Με την εν λόγω συνθήκη δημιουργείτε για κάθε μια μεταβλητή στη λίστα μεταβλητών ένα τοπικό αντίγραφο για κάθε νήμα. Τα αντίστοιχα αυτά τοπικά αντίγραφα συνδυάζονται στο τέλος με κριτήριο την πράξη στον ορισμό της συνθήκης για να συμπληρώσουν με ασφάλεια την τιμή της καθολικής μεταβλητής. 2.4 Συναρτήσεις Βιβλιοθήκης Το OpenMP παρέχει και μια σειρά συναρτήσεων. Για να χρησιμοποιήσουμε τις συναρτήσεις αυτές θα πρέπει να κάνουμε include στο πρόγραμμα μας τη βιβλιοθήκη omp.h. Τις συναρτήσεις του OpenMP θα μπορούσαμε να τις διαχωρίσουμε σε δύο κατηγορίες. Τις συναρτήσεις περιβάλλοντος χρόνου εκτέλεσης και τις συναρτήσεις κλειδαριών. Η πρώτη κατηγορία αφορά συναρτήσεις που έχουν να κάνουν με τον έλεγχο αλλά και τη λήψη πληροφοριών σχετικά με διάφορες μεταβλητές του OpenMP που αφορούν το πρόγραμμα ενώ η δεύτερη κατηγορία αφορά τις κλειδαριές για την προστασία κώδικα που αφορά κοινόχρηστες μεταβλητές Συναρτήσεις Περιβάλλοντος Χρόνου Εκτέλεσης Με τις συναρτήσεις αυτής της κατηγορίας μπορούμε να πάρουμε πληροφορίες αλλά και να ρυθμίσουμε κάποιες παραμέτρους του προγράμματος. Ακολουθεί αναφορά και περιγραφή των συναρτήσεων αυτών. void omp_set_num_threads(int). Με την κλήση αυτής της συνάρτησης ορίζεται ο αριθμός των νημάτων που θα εκτελέσουν το επόμενο παράλληλο τμήμα. Η κλήση θα πρέπει να γίνει σε σειριακό μέρος του προγράμματος και μπορεί να την καλέσει μόνο το νήμα master. Τα αποτελέσματα της κλήσης της προκύπτουν συναρτήσει της ύπαρξης δυναμικού ορισμού του αριθμού των νημάτων ή όχι. Αν επιτρέπεται ο δυναμικός ορισμός των νημάτων τότε η συνάρτηση ορίζει τον μέγιστο αριθμό των νημάτων που θα εκτελέσουν το επόμενο παράλληλο τμήμα. Σε αντίθετη περίπτωση, ορίζει τον ακριβή αριθμό των νημάτων που θα εκτελέσουν την παράλληλη περιοχή. int omp_get_num_threads(void). Η συνάρτηση αυτή μας επιστρέφει τον αριθμό των νημάτων που εκτελούν την παράλληλη περιοχή στην οποία βρισκόμαστε. Αν η συνάρτηση κληθεί έξω από παράλληλη περιοχή, δηλαδή σε σειριακό μέρος κώδικα, θα επιστρέψει την τιμή 1 εννοώντας την ύπαρξη του νήματος master. int omp_get_thread_num(void). Η συνάρτηση μας επιστρέφει τον αριθμό του αναγνωριστικού του νήματος που την κάλεσε. Όπως προαναφέρθηκε, το νήμα 16

17 master έχει το αναγνωριστικό 0 και όλα τα άλλα νήματα παίρνουν τιμές στα αναγνωριστικά τους από το 1 μέχρι και το συνολικό αριθμό τους μείον ένα. int omp_get_max_threads(void). Επιστρέφει το μέγιστο αριθμό νημάτων που θα εκτελέσουν την επόμενη παράλληλη περιοχή. Η τιμή που θα πάρει είναι ουσιαστικά η μέγιστη εκ των τιμών της μεταβλητής περιβάλλοντος OMP_NUM_THREADS και της τιμής που έχει τεθεί με την κλήση της συνάρτησης omp_set_num_threads(). void omp_set_nested(int). Με τη συνάρτηση αυτή ενεργοποιείτε ή απενεργοποιείτε η δυνατότητα εμφωλευμένων παράλληλων τμημάτων. Αν δοθεί η τιμή 0 απενεργοποιείτε αυτή η δυνατότητα, ενώ για άλλες τιμές έχουμε τα αντίθετα αποτελέσματα. int omp_get_nested(void). Επιστρέφει 0 αν η δυνατότητα εμφωλευμένης παραλληλίας είναι απενεργοποιημένη και 1 σε αντίθετη περίπτωση. void omp_set_dynamic(int). Με τη συνάρτηση αυτή ενεργοποιείτε ή απενεργοποιείτε η δυνατότητα δυναμικού ορισμού του αριθμού των νημάτων. Αν δοθεί η τιμή 0 απενεργοποιείτε αυτή η δυνατότητα, ενώ για άλλες τιμές έχουμε τα αντίθετα αποτελέσματα. int omp_get_dynamic(void). Επιστρέφει 0 αν η δυνατότητα δυναμικού ορισμού του αριθμού των νημάτων είναι απενεργοποιημένη και 1 σε αντίθετη περίπτωση. int omp_in_parallel(void). Επιστρέφει 1 αν βρισκόμαστε σε περιοχή που εκτελείται παράλληλα από πολλά νήματα και 0 σε αντίθετη περίπτωση. int omp_num_procs(void). Επιστρέφει τον αριθμό των επεξεργαστών που υπάρχουν στο σύστημα Συναρτήσεις Κλειδαριών Οι κλειδαριές στον παράλληλο προγραμματισμό είναι απαραίτητες για τη συνέπεια και την ορθότητα των αποτελεσμάτων από τη στιγμή της ύπαρξης κοινόχρηστων μεταβλητών. Ουσιαστικά με τις κλειδαριές μπορούμε να ορίσουμε κρίσιμες περιοχές, περιοχές δηλαδή στις οποίες δεν μπορούν να βρίσκονται ταυτόχρονα παραπάνω από ένα νήματα. To OpenMP παρέχει το δικό του τύπο κλειδαριάς omp_lock_t και omp_nest_lock_t. Ο δεύτερος τύπος αναφέρεται σε περιπτώσεις εμφωλευμένης παραλληλίας. Ακολουθεί αναφορά και περιγραφή των συναρτήσεων αυτών. void omp_init_lock(omp_lock_t*). Με την κλήση αυτής της συνάρτησης, η οποία είναι απαραίτητη αν στο πρόγραμμα μας έχουμε κλειδαριές, αρχικοποιείται ουσιαστικά η κλειδαριά που της έχουμε περάσει ως όρισμα. void omp_set_lock(omp_lock_t*). Όταν ένα νήμα φτάσει στην κλήση αυτής της συνάρτησης υπάρχουν δύο περιπτώσεις. Είτε να είναι κλειδωμένη η κλειδαριά από κάποιο άλλο νήμα και έτσι να περιμένει σε εκείνο το σημείο μέχρι να ξεκλειδωθεί η κλειδαριά και να μπορέσει εκείνο με τη σειρά του να την κλειδώσει, είτε να είναι ελεύθερη η κλειδαριά όπου στην περίπτωση αυτή κλειδώνει αυτό με τη σειρά του την κλειδαριά και εκτελεί τον κώδικα μέσα σε αυτή. void omp_unset_lock(omp_lock_t*). Με την κλήση αυτή, το νήμα που είχε την 17

18 κλειδαριά, την απελευθερώνει για να μπορέσει το επόμενο νήμα να την κλειδώσει με τη σειρά του και να αποκτήσει πρόσβαση στο τμήμα κώδικα. int omp_test_lock(omp_lock_t*). Επιστρέφει 1 σε περίπτωση που η κλειδαριά έχει αρχικοποιηθεί επιτυχώς και 0 σε αντίθετη περίπτωση. 2.5 Μεταβλητές Περιβάλλοντος Εκτός από τις οδηγίες και τις συναρτήσεις βιβλιοθήκης, το OpenMP προσφέρει και τη δυνατότητα χρήσης μεταβλητών περιβάλλοντος για τη ρύθμιση της εκτέλεσης των παράλληλων προγραμμάτων. Οι μεταβλητές περιβάλλοντος παίρνουν τιμή πριν την εκτέλεση του προγράμματος και γράφονται με κεφαλαία γράμματα. Ακολουθεί αναφορά και περιγραφή των μεταβλητών περιβάλλοντος που προσφέρει το OpenMP. OMP_NUM_THREADS. Με την τιμή αυτής της μεταβλητής ορίζουμε τον αριθμό νημάτων που μπορούν να εκτελέσουν μια παράλληλη περιοχή στο πρόγραμμά μας. Ο αριθμός αυτός των νημάτων μπορεί να αλλάξει κατά τη διάρκεια εκτέλεσης είτε με τη συνθήκη οδηγίας num_threads(), είτε με τη κλήση της συνάρτησης βιβλιοθήκης omp_set_num_threads(). Βέβαια η αλλαγή αυτή του αριθμού μπορεί να γίνει μόνο προς τα κάτω γιατί η μεταβλητή περιβάλλοντος ορίζει ουσιαστικά το μέγιστο αριθμό των νημάτων που μπορούν να χρησιμοποιηθούν. OMP_NESTED. Η μεταβλητή παίρνει τιμή 1 για ενεργοποίηση της δυνατότητας πολυεπίπεδου παράλληλου φωλιάσματος και 0 για απενεργοποίηση. Βέβαια όπως προαναφέρθηκε το αν και πως θα υλοποιηθεί τελικά το πολυεπίπεδο παράλληλο φώλιασμα εξαρτάται και από την υλοποίηση του μεταγλωττιστή. OMP_DYNAMIC. Η μεταβλητή παίρνει την τιμή 1 αν θέλουμε η δυνατότητα του δυναμικού ορισμού του αριθμού των νημάτων να είναι ενεργοποιημένη και 0 για το αντίθετο αποτέλεσμα. OMP_SCHEDULE. Αφορά τον τρόπο με τον οποίο θα παραλληλοποιηθούν οι επαναλήψεις του βρόγχου της for στην οποία έχει τεθεί η οδηγία διαμοιρασμού εργασίας #pragma omp for μαζί με την συνθήκη για δρομολόγηση schedule(runtime). 18

19 Κεφάλαιο 3 OMPi Compiler 3.1 Επισκόπηση του OMPi Ο OMPi [4] είναι ένας μετασχηματιστής πηγαίου σε πηγαίο κώδικα προγραμμάτων OpenMP γραμμένων σε γλώσσα C. Αποτελείται ουσιαστικά από δύο τμήματα. Το τμήμα του μεταγλωττιστή και το τμήμα runtime. Η συνεργασία αυτών των τμημάτων είναι στενή καθώς ο μεταγλωττιστής αναλαμβάνει να μετατρέψει το πρόγραμμα C/OpenMP σε ένα πρόγραμμα C προσθέτοντας κάποιες κλήσεις στο σύστημα runtime του OMPi. Ο μεταφραστής θα συνδέσει αυτές τις κλήσεις με την αντίστοιχη βιβλιοθήκη runtime που έχει επιλεγεί στον OMPi, καθώς αυτός διαθέτει διάφορες βιβλιοθήκες οι οποίες θα αναλυθούν αργότερα. Το OpenMP ουσιαστικά δημιουργεί νήματα εκτέλεσης για τις περιοχές που θέλουμε να παραλληλοποιήσουμε. Ο OMPi δίνει πολλές επιλογές για το πως και τι θα είναι αυτά τα νήματα εκτέλεσης ή καλύτερα αυτές οι υπολογιστικές οντότητες. Είναι δομημένος έτσι ώστε τα νήματα να μετατρέπονται σε αόριστες υπολογιστικές οντότητες τις οποίες αναλαμβάνει το σύστημα runtime να τις υλοποιήσει και να τις χειριστεί. Ο OMPi περιέχει μια ποικιλία βιβλιοθηκών που παρέχουν διαφορετικές υπολογιστικές οντότητες που υλοποιούν τα νήματα εκτέλεσης του OpenMP. Αποτελείται από δύο βιβλιοθήκες νημάτων POSIX επιπέδου πυρήνα, των οποίων η διαφορά έγκειται στο σημείο οτι η μια δεν υποστηρίζει πολυεπίπεδο (nested) προγραμματισμό, και για η εκτέλεση παράλληλων περιοχών που βρίσκονται σε επίπεδο παραλληλισμού μεγαλύτερου του πρώτου γίνονται σειριακά από 1 νήμα και η άλλη υποστηρίζει περιορισμένο, και αυτό λόγω του οτι ο OMPi δημιουργεί εξ αρχής έναν ορισμένο αριθμό από υπολογιστικές οντότητες και χρησιμοποιεί αριθμητικά μόνο αυτές κατά την εκτέλεση. Υπάρχουν άλλες δύο βιβλιοθήκες νημάτων Solaris επιπέδου πυρήνα με την ίδια πολιτική για τον πολυεπίπεδο προγραμματισμό. Για την καλύτερη και πιό αποδοτική υποστήριξη του πολυεπίπεδου προγραμματισμού ο OMPi περιλαμβάνει και δύο βιβλιοθήκες νημάτων χρήστη (POSIX, Marcell). Η τελευταία βιβλιοθήκη που προστέθηκε στον OMPi, παρέχει διεργασίες ως υπολογιστικές οντότητες καθώς και μια διεπαφή για τη χρήση διάφορων DSM, που υλοποιούν την εικονική κοινή μνήμη από κάτω. Η προσθήκη της εν λόγω βιβλιοθήκης έγινε για την εκτέλεση προγραμμάτων OpenMP σε cluster όπου δεν υπάρχει κοινή μνήμη και όπως προαναφέρθηκε στο προηγούμενο κεφάλαιο, το OpenMP είναι πρότυπο προγραμματισμού για μοντέλο κοινού χώρου διευθύνσεων. Το πρόβλημα επιλύεται μέσω της εικονικής κοινής μνήμης που υλοποιεί το DSΜ. Υποστηρίζει έναν αριθμό από πυρήνες DSM συμπεριλαμβανομένου των, TreadMarks [2], JiaJia [6], Mocha [7], Mome [8] και Parade [9]. 3.2 Ο Compiler του OMPi Ο compiler του OMPi παίρνει ως είσοδο το πρόγραμμα σε C/OpenMP και παράγει ένα πηγαίο πρόγραμμα στο οποίο έχει ενσωματώσει κλήσεις προς το σύστημα runtime του. Το compiling περνάει από μια σειρά σταδίων (Σχήμα 3.1). Πρώτα το λεγόμενο 19

20 parsing κατά το οποίο ο parser διασχίζει το πρόγραμμα και δημιουργεί ένα αφηρημένο συντακτικό δέντρο που αντιπροσωπεύει το πρόγραμμα. Στη συνέχεια το δέντρο αυτό δίνεται ως είσοδο στο επόμενο στάδιο, αυτό του μετασχηματισμού. Κατά το στάδιο του μετασχηματισμού διασχίζεται κάθε κόμβος του δέντρου και όπου βρεθεί δήλωση OpenMP αυτός αντικαθίσταται από αντίστοιχο κώδικα C με τον αρχικό C/OpenMP, και με τη διαφορά επίσης, οτι περιέχει κάποιες κλήσεις στο σύστημα runtime. Σχήμα 3.1: Διαδικασία μετάφρασης του OMPi. Κατά τη διάρκεια του μετασχηματισμού επιτελείται και η πιό περίπλοκη εργασία. Μπορεί κάποιες οδηγίες OpenMP να έχουν σχετικά απλή λύση για το πως θα μετασχηματιστούν σε C κώδικα, αλλά υπάρχουν οδηγίες όπως η parallel που περιλαμβάνει και συνθήκες οι οποίες θέλουν ειδική μεταχείριση. Το βασικό πρόβλημα παρατηρείται στις μεταβλητές. Κάποιες θα πρέπει να είναι κοινές και στην περίπτωση που έχουμε νήματα αυτό φαντάζει εύκολο για τις καθολικές (global) μεταβλητές μιας και θεωρούνται κοινές εξ ορισμού. Υπάρχει όμως και η περίπτωση όπου έχουμε κοινές μεταβλητές μεταξύ των νημάτων αλλά δεν είναι καθολικές. Για παράδειγμα αν αυτές οι μεταβλητές δηλώνονται σε μια συνάρτηση στην οποία υπάρχει οδηγία παράλληλου τμήματος OpenMP. Σε αυτήν την περίπτωση ο OMPi αντικαθιστά αυτές τις μεταβλητές με δείκτες των οποίων τη διεύθυνση την περνά σε τμήμα κώδικα που θα πρέπει να εκτελέσουν τα νήματα. Εκτενέστερη αναφορά όμως θα δούμε στο επόμενο κεφάλαιο όπου περιγράφεται αναλυτικά η διαδικασία του μετασχηματισμού σε μια παρόμοια περίπτωση. Στην τρίτη και τελευταία φάση του compilation, γίνεται μια διάσχιση του πλέον 20

21 μετασχηματισμένου δέντρου και παράγεται ο C κώδικας. Αυτός με τη σειρά του θα μεταφραστεί από τον C μεταφραστή του συστήματος ο οποίος θα αναλάβει να το συνδέσει και με τη βιβλιοθήκη runtime που έχει επιλεγεί για να υλοποιήσει τις υπολογιστικές οντότητες Διαδικασία Μετασχηματισμού για Νήματα Σε αυτήν την ενότητα γίνεται μια ανάλυση των ιδιαιτεροτήτων που ακολουθεί ο μεταγλωττιστής του OMPi κατά το μετασχηματισμό ενός προγράμματος OpenMP στην περίπτωση που έχει επιλεγεί βιβλιοθήκη που παρέχει νήματα ως υπολογιστικές οντότητες. Επίσης γίνεται και μια περιγραφή του τρόπου με τον οποίο χειρίζεται τις μεταβλητές για τα νήματα ειδικά στην περίπτωση που αυτές πρέπει να είναι κοινές μεταξύ τους. Ο μετασχηματισμός που απαιτεί τη μεγαλύτερη ανάλυση είναι αυτός της οδηγίας parallel. Οι άλλες οδηγίες έχουν απλούστερους μετασχηματισμούς. Όταν ο parser βρει μια οδηγία parallel, μεταφέρει τον κώδικα που βρίσκεται μέσα στην οδηγία σε μια συνάρτηση την οποία ονομάζει _thrfunc#_. Στην θέση της # τοποθετεί έναν αριθμό που ουσιαστικά είναι ο αύξοντας αριθμός της συνάρτησης που χρειάστηκε να δημιουργήσει, άρα στην πρώτη εμφάνιση κάποιας οδηγίας parallel θα βάλει τον αριθμό 0. Στην θέση της οδηγίας και του κώδικα αυτής, τοποθετεί μια κλήση προς το σύστημα runtime του OMPi με το όνομα ort_execute_parallel(). Η συνάρτηση αυτή δέχεται 3 ορίσματα. Πρώτα τον αριθμό των νημάτων που έχει οριστεί μέσω της συνθήκης της οδηγίας num_threads, αν δεν υπάρχει η συνθήκη τότε δίνεται η τιμή -1. Δεύτερο όρισμα είναι η συνάρτηση που θα εκτελέσουν τα νήματα (_thrfunc#_) και τρίτο μια δομή με τις μεταβλητές που θα πρέπει να είναι κοινές μεταξύ των νημάτων. Η ort_execute_parallel() θα αναλάβει να δώσει στα νήματα τη δουλειά που θα εκτελέσουν και η οποία βρίσκεται στον κώδικα της _thrfunc#_ καθώς και να τους δώσει τις κοινές μεταβλητές. Τον κώδικα της συνάρτησης των νημάτων τον εκτελεί και το νήμα master, ενώ στο τέλος συγχρονίζονται όλα μεταξύ τους. Ας δούμε όμως καλύτερα ένα πιο συγκεκριμένο παράδειγμα. Έστω οτι έχουμε τον παρακάτω κώδικα OpenMP και θέλουμε να τον μεταγλωττίσουμε με τον OMPi για να τον παραλληλοποιήσει: int a; void function(void) { int b, c, d; } #pragma omp parallel private(d) a = b + c + d; Παρατηρούμε πως κάποιες μεταβλητές θα πρέπει να γίνουν κοινές μεταξύ των νημάτων. Η μεταβλητή a δεν θέλει ιδιαίτερη μεταχείριση καθώς είναι καθολική και εξ ορισμού είναι κοινή στα νήματα. Στην οδηγία OpenMP υπάρχει η συνθήκη private(d) που έχει την έννοια οτι η μεταβλητή d θα πρέπει να είναι ιδιωτική για κάθε νήμα, πράγμα εύκολο καθώς μπορούμε απλά να τη δηλώσουμε στον ως μεταβλητή του κώδικα της συνάρτησης που θα εκτελέσουν τα νήματα. Το πρόβλημα παρουσιάζεται 21

22 στις μεταβλητές b, c οι οποίες θα πρέπει να γίνουν κοινές στα νήματα. Για την επίλυση αυτού του προβλήματος ο OMPi μετατρέπει τις εν λόγω μεταβλητές σε δείκτες και τις περνάει ως όρισμα στη συνάρτηση που θα εκτελέσουν τα νήματα. Πιο συγκεκριμένα, παράγει τον παρακάτω ισοδύναμο κώδικα: static void *_thrfunc0_(void * _arg) { struct{int(*b);int(*c);}*_shvars = ort_get_shared_vars(_arg); int (* b) = _shvars->b; int (* c) = _shvars->c; int d; } (*a) = (*b) + (*c) + d; return (void *) 0; void function(void) { int b, c, d; } struct { int (* b); int (* c); } _shvars = { &b, &c }; ort_execute_parallel(-1, _thrfunc0_, &_shvars); Στη συνάρτηση function έχει προστεθεί ο ορισμός μιας δομής, που ουσιαστικά περιλαμβάνει τους δείκτες προς τις κοινές μεταβλητές τις τιμές των οποίων αρχικοποιεί ώστε να δείχνουν στις σωστές διευθύνσεις. Στην ίδια συνάρτηση επίσης έχει αντικατασταθεί η οδηγία OpenMP, parallel με την κλήση της συνάρτησης ort_execute_parallel() στην οποία έχουν δοθεί 3 ορίσματα. Το πρώτο δηλώνει οτι την παράλληλη περιοχή θα την εκτελέσει ο εξ ορισμού αριθμός νημάτων, το δεύτερο είναι η διεύθυνση της συνάρτησης που θα εκτελέσουν τα νήματα και ουσιαστικά πρόκειται για τον κώδικα που υπήρχε μέσα στην οδηγία και το τρίτο είναι η δομή με τις διευθύνσεις των κοινών μεταβλητών. Η ort_execute_parallel() αναλαμβάνει να δώσει στον κατάλληλο αριθμό νημάτων, δουλειά. Τους δίνει να εκτελέσουν τη συνάρτηση _thrfunc0_. Στα νήματα που θα εκτελέσουν δουλειά συμπεριλαμβάνεται και το νήμα master. Στην _thrfunc0_, τα νήματα καλούν τη συνάρτηση runtime, ort_get_shared_vars() η οποία επιστρέφει τη διεύθυνση της δομής που περιλαμβάνει τις διευθύνσεις για τις κοινές μεταβλητές. Ο κώδικας που υπήρχε μέσα στην οδηγία parallel έχει μετασχηματιστεί πλέον και στη θέση των κοινών μεταβλητών έχουν τοποθετηθεί δείκτες Διαδικασία Μετασχηματισμού για Διεργασίες Η βιβλιοθήκη των διεργασιών αναπτύχθηκε για την εκτέλεση προγραμμάτων OpenMP σε συστάδες υπολογιστών (clusters). Το OpenMP όπως έχει αναφερθεί είναι ένα πρότυπο για την ανάπτυξη προγραμμάτων πάνω σε κοινόχρηστη μνήμη, η οποία σε μια συστάδα υπολογιστών δεν υπάρχει. Παρόλα αυτά δεν μπορούμε να 22

23 περιορίσουμε ή να αλλάξουμε το πρότυπο ώστε να λαμβάνει υπόψιν του την ανυπαρξία κοινής μνήμης. Υπάρχουν εργαλεία πάνω σε προγραμματισμό συστάδων υπολογιστών που προσφέρουν την ψευδαίσθηση ύπαρξης κοινής μνήμης μεταξύ των κόμβων (DSM). Οι διεργασίες δε μοιράζονται τίποτα εξ ορισμού άρα θα πρέπει να τύχουν ειδικής μεταχείρισης όλες οι μεταβλητές που πρέπει να διαμοιραστούν είτε αυτές είναι καθολικές, είτε όχι. Ας δούμε όμως καλύτερα τη διαδικασία του μετασχηματισμού και του χειρισμού των μεταβλητών μέσα από το παρακάτω παράδειγμα, το οποίο δίνουμε ως είσοδο στον OMPi να το παραλληλοποιήσει χρησιμοποιώντας ως υπολογιστικές οντότητες, διεργασίες: int a = 1, b; void function(void) { int c, d; } #pragma omp parallel private(d) a = b + c + d; Από το παράδειγμα γίνεται σαφές πως οι μεταβλητές a, b θα πρέπει να είναι κοινές μεταξύ των διεργασιών που θα συμμετέχουν στον υπολογισμό και λόγω του οτι οι διεργασίες δεν έχουν κάτι κοινό μεταξύ τους θα πρέπει να λάβουν και αυτές, ειδικής μεταχείρισης. Θα πρέπει να τοποθετήσουμε τις μεταβλητές αυτές στην κοινή μνήμη που παρέχει το σύστημα sdsm. Για να συμβεί αυτό θα πρέπει να γίνουν κάποιοι μετασχηματισμοί στο πρόγραμμα. Το πρόγραμμα που παράγεται με τους μετασχηματισμούς είναι το παρακάτω: int _sglini_a = 1, (*a), (*b); static void *_thrfunc0_(void * _arg) { struct{int(*c);}*_shvars = ort_get_shared_vars(_arg); int (* c) = _shvars->c; int d; } (*a) = (*b) + (*c) + d; return (void *) 0; void function(void) { int c; struct shvt { int (* c); }_shvars = { &c 23

24 } }; ort_execute_parallel(-1, _thrfunc0_, (void *) &_shvars); static void attribute ((constructor)) _init_shvars_(void); static void _init_shvars_(void) { ort_sglvar_allocate((void **)&b, sizeof(int), (void *) 0); ort_sglvar_allocate((void**)&a,sizeof(int),(void *)_sglini_a); } Ο μετασχηματιστής για τις καθολικές μεταβλητές ακολουθεί κάποια βήματα. Πρώτα μετατρέπει τις μεταβλητές σε δείκτες και προσθέτει και μια αντίστοιχη μεταβλητή (_sglini_a) για να κρατήσει την αρχική τιμή της μεταβλητής. Στη συνέχεια προσθέτει τον ορισμό μιας συνάρτησης constructor στην οποία υπάρχουν κλήσεις της ort_sglvar_allocate() προς το σύστημα runtime. Τοποθετείται μια κλήση για κάθε μια καθολική μεταβλητή. Η συνάρτηση αυτή δέχεται 3 ορίσματα εκ των οποίων το πρώτο είναι η διεύθυνση του δείκτη της καθολικής μεταβλητής, το δεύτερο είναι το μέγεθος της και το τελευταίο είναι η αρχική τιμή της μεταβλητής. Η ort_sglvar_allocate() αναλαμβάνει να δεσμεύσει χώρο στην κοινή μνήμη και να τοποθετήσει τις τιμές των δεικτών των καθολικών μεταβλητών σε αυτή στο κατάλληλο offset. Αξίζει να σημειωθεί βέβαια και ο λόγος για τον οποίο γίνεται η χρήση της συνάρτησης constructor. Αν έχουμε πολλά ανεξάρτητα προγράμματα που θέλουμε να συνδέσουμε, θα είναι δύσκολο να ξέρουμε πόσες είναι οι καθολικές μεταβλητές. Με το να ορίσουμε μια συνάρτηση constructor που θα εκτελεστεί πριν την main και θα μας εξασφαλίσει οτι όλες αυτές οι μεταβλητές θα μπουν στην κοινή μνήμη, λύνουμε το πρόβλημά μας. Ας μην ξεχνάμε όμως και την ύπαρξη των μη καθολικών μεταβλητών που θα πρέπει να είναι κοινές μεταξύ των διεργασιών. Αν και στα νήματα αυτό το πρόβλημα λύθηκε με τη χρήση δεικτών και το πέρασμα των τιμών τους στη συνάρτηση που εκτελούν τα νήματα, αυτό δε θα ίσχυε στην περίπτωση των διεργασιών καθώς οι διευθύνσεις αυτές για την κάθε διεργασία δε θα ήταν έγκυρες. Ο λόγος είναι οτι οι διεργασίες δεν μπορούν να βλέπουν η μια τη στοίβα της άλλης και άρα οι μηκαθολικές μεταβλητές μιας διεργασίας είναι απροσπέλαστες από άλλη. Το πρόβλημα αυτό στον OMPi λύνεται τοποθετώντας τη στοίβα της αρχικής διεργασίας 0, στην κοινή μνήμη. Με αυτόν τον τρόπο, οι δείκτες θα δείχνουν σε χώρο της κοινής μνήμης και οι διευθύνσεις τους θα είναι έγκυρες. Αυτή η διαδικασία επιτυγχάνεται από τον compiler με μια σειρά από μετασχηματισμούς που θα συζητηθούν στην επόμενη ενότητα. 3.3 Το Σύστημα Runtime του OMPi Το σύστημα runtime του OMPi [5] ασχολείται με τις υπολογιστικές οντότητες που θα αναλάβουν την εκτέλεση των τμημάτων κώδικα που θα πρέπει να παραλληλοποιηθούν. Αποτελείται από δύο τμήματα τα οποία είναι ανεξάρτητα μεταξύ τους αλλά διέπονται από στενή συνεργασία. Το πρώτο τμήμσ είναι το ORT, το οποίο συνδυάζει και χειρίζεται τις υπολογιστικές οντότητες του OMPi. Παρόλα αυτά δε γνωρίζει το είδος τους γιατί δεν τις υλοποιεί. Το δεύτερο τμήμα, το EELIB, είναι αυτό 24

25 που θα υλοποιήσει και θα παρέχει τις υπολογιστικές οντότητες στο ORT. Όπως έχει αναφερθεί, στον OMPi υπάρχουν πολλές βιβλιοθήκες που παρέχουν πληθώρα υπολογιστικών οντοτήτων και κάθε μια τηρεί την ανεξαρτησία των δύο αυτών τμημάτων. Κατά την εκκίνηση του προγράμματος, εισάγεται από το μετασχηματιστή η κλήση προς το σύστημα runtime, ort_initialize(). Σε αυτήν τη συνάρτηση το νήμα master, θα αναλάβει να αρχικοποιήσει κάποιες σημαντικές για τη συνέχεια της εκτέλεσης, παραμέτρους. Αρχικά, λαμβάνει τις τιμές των μεταβλητών περιβάλλοντος και σύμφωνα με τις τιμές τους αρχίζει μια διαδικασία αρχικοποιήσεων. Στη συνέχεια καλείται η αντίστοιχη συνάρτηση αρχικοποίησης του έτερου τμήματος (ee_initialize), στην οποία δηλώνεται ο αριθμός των υπολογιστικών οντοτήτων που θα χρειαστούν. Η ιδιαιτερότητα του OMPi είναι οτι δημιουργεί εκ των προτέρων τις υπολογιστικές οντότητες και τις αφήνει να περιμένουν. Όταν χρειαστεί έναν αριθμό από αυτές, τις ξυπνάει δίνοντάς τους δουλειά. Η τελευταία και πολύ σημαντική αρμοδιότητα της εν λόγω συνάρτησης αρχικοποίησης, είναι η δημιουργία της δομής ελέγχου (eecb) του νήματος master. Σε αυτήν τη δομή υπάρχουν όλες οι πληροφορίες που χρειάζεται το τμήμα ORT για να δρομολογήσει τις οντότητες που του παρέχει το τμήμα EELIB Είσοδος σε Παράλληλη Περιοχή Όταν ο compiler συναντήσει την οδηγία parallel στο πρόγραμμα την αντικαθιστά με την κλήση συστήματος runtime, ort_execute_parallel(). Η συνάρτηση αυτή σύμφωνα και με τις τιμές των παραμέτρων της, που αφορούν τον αριθμό των οντοτήτων που θα εκτελέσουν την παράλληλη περιοχή, τη συνάρτηση που θα εκτελέσουν καθώς και τις παραμέτρους της συνάρτησης, είναι υπεύθυνη μέσα από κλήσεις προς το EELIB να υλοποιήσει τη διαδικασία παραλληλοποίησης. Επικοινωνεί αρχικά με το EELIB για να ζητήσει έναν αριθμό από οντότητες που θέλει να του παρασχεθούν, ανάλογα πάντα και με το τι ισχύει για τον πολυεπίπεδο παραλληλισμό και το δυναμικό ορισμό αριθμού οντοτήτων σε εκείνο το σημείο. Αν η επιθυμία της γίνει αποδεκτή τότε ζητάει από το EELIB να ξυπνήσει αυτόν τον αριθμό οντοτήτων για να αποτελέσουν την ομάδα εκτέλεσης, χωρίς όμως να γνωρίζει το είδος τους. Με τη σειρά τους οι οντότητες αυτές θα πρέπει να πάρουν δουλειά από το ORT για αυτόν το λόγο καλούν τη συνάρτηση ort_get_thread_work(). Με την κλήση της συνάρτησης αυτής αναλαμβάνει η ORT να δώσει όλες τις απαραίτητες πληροφορίες για τη δουλειά που έχουν να επιτελέσουν οι οντότητες μέσω μιας δομής. Οι πληροφορίες δίνονται μέσω του block ελέγχου του πατέρα-νήματος της ομάδας (αρχικό νήμα) που έχει δημιουργηθεί. Αυτές αφορούν το αναγνωριστικό του νήματος μέσα στην ομάδα, το επίπεδο του παραλληλισμού, το δείκτη προς το block του πατέρα, το μέγεθος της ομάδας καθώς και το δείκτη προς τη συνάρτηση που θα πρέπει να εκτελέσουν. Όλες αυτές οι πληροφορίες είναι απαραίτητες για τις οντότητες και μόλις τις παραλάβουν ξεκινούν να εκτελούν τον κώδικα που τους αναλογεί. Εκτός από τις οντότητες που έχουν ξυπνήσει, στη δουλειά συμμετέχει και ο πατέρας, παίρνοντας το αναγνωριστικό 0 για την ομάδα. Αν υπάρχει υποστήριξη για πολυεπίπεδο παραλληλισμό και κάποιο από τα μέλη της ομάδας συναντήσει μια παράλληλη περιοχή, γίνεται αυτό πατέρας για τη νέα ομάδα οντοτήτων. Κατά συνέπεια δημιουργείτε ένα δέντρο που αυξάνεται και μειώνεται ανάλογα αν αρχίζει ή 25

26 τελειώνει μια παράλληλη περιοχή αντίστοιχα Χειρισμός Δομών Διαμοίρασης Έργου Στο OpenMP, υπάρχουν τρεις δομές διαμοίρασης έργου, το for, το section και το single. Η εξ ορισμού συμπεριφορά των δομών αυτών είναι εμποδιστική, με την έννοια ότι στο τέλος τους υπονοείται ένας συγχρονισμός μεταξύ των οντοτήτων. Με την προσθήκη της συνθήκης nowait στην οδηγία της δομής, παραλείπεται αυτός ο συγχρονισμός και οι οντότητες συνεχίζουν αμέσως την εκτέλεσή τους. Η υλοποίηση σε κώδικα αυτών των δομών συνεπάγεται τη χρήση μεταβλητών-μετρητών για την καταμέτρηση των οντοτήτων που έχουν ολοκληρώσει τον κώδικα. Για παράδειγμα, αν μια δομή section έχει τρία sections, θα πρέπει να δώσει τη δουλειά αυτών στις τρεις πρώτες υπολογιστικές οντότητες που θα φτάσουν σε αυτό. Οι υπόλοιπες ανάλογα με τις συνθήκες που έχει οριστεί η οδηγία (nowait) είτε θα περιμένουν τις οντότητες που έχουν δουλειά να την ολοκληρώσουν, είτε όχι. Παρόλα αυτά, δεν αρκεί ένας μετρητής καθώς μπορούν περισσότερες από μια δομές διαμοίρασης να είναι ενεργές, λόγω της ύπαρξης της συνθήκης nowait. Ο OMPi επιλύει αυτό το πρόβλημα επιτρέποντας ένα προκαθορισμένο αριθμό ενεργών δομών ταυτόχρονα. Ενεργή χαρακτηρίζεται μια δομή αν έχει εισέλθει σε αυτήν τουλάχιστον ένα νήμα και δεν την έχουν ολοκληρώσει όλα τα νήματα της ομάδας. Μετά από αυτόν τον αριθμό, κάθε δομή διαμοίρασης έργου που συναντάται, περιμένει μέχρι να ολοκληρωθεί η διαδικασία κάποιας προηγούμενης. Για την εκτέλεση σε clusters, ακολουθεί μια διαφορετική λογική. Σε αυτήν την περίπτωση ο OMPi δεν επιτρέπει πολλές ενεργές δομές διαμοίρασης έργου και κατά συνέπεια, ο κώδικας όλων των δομών διαμοίρασης έργου καταλήγει σε συγχρονισμό των οντοτήτων. Με λίγα λόγια αν έχει τοποθετηθεί η συνθήκη nowait, αγνοείται Η Διεπαφή με το EELIB Τα δύο τμήματα του συστήματος runtime του OMPi, μπορεί να είναι ανεξάρτητα μεταξύ τους αλλά διέπονται από στενή επικοινωνία και ανταλλαγή πληροφοριών. Το ORT δε γνωρίζει τον τύπο και το είδος των υπολογιστικών οντοτήτων αλλά μπορεί να τις δρομολογεί και να τις χειρίζεται μέσω των συναρτήσεων που προσφέρει το EELIB. Οι τελευταίες αποτελούν την διεπαφή του ORT προς τα διάφορα EELIB που είναι υπεύθυνα να του παρέχουν τον αριθμό των οντοτήτων που θα ζητήσει, εκτός βέβαια από το νήμα master παρόλο που και αυτό συμμετέχει στην υπολογιστική διαδικασία. Εκτός αυτού, το EELIB παρέχει στο ORT και τρεις κλειδαριές, την κανονική, την κλειδαριά πολυεπίπεδου παραλληλισμού και την κλειδαριά spin. Οι δύο πρώτες αποτελούν μέρος του προτύπου του OpenMP, ενώ η τρίτη έχει προστεθεί για ανάγκες του ORT. 26

27 Σχήμα 3.2: Διεπαφή τμήματος ORT με τα διάφορα EELIBS. Η πρώτη επαφή με το τμήμα EELIB, εμφανίζεται με την έναρξη της εκτέλεσης του προγράμματος καθώς μέσω της συνάρτησης αρχικοποίησης του, το ORT καλεί την συνάρτηση αρχικοποίησης του EELIB. Με αυτό τον τρόπο το EELIB ενημερώνει το ORT για τις δυνατότητες του, που αφορούν τον πολυεπίπεδο προγραμματισμό, την δυνατότητα δυναμικού ορισμού αριθμού οντοτήτων καθώς και πόσες οντότητες μπορεί να δημιουργήσει. Το EELIB παρέχει και άλλες τρεις συναρτήσεις για τη διεπαφή του με το ORT. ee_request(), με την οποία το ORT ζητάει συγκεκριμένο αριθμό οντοτήτων από το EELIB. Το EELIB με τη σειρά του απαντάει με τον αριθμό που μπορεί εκείνο να παρέχει στο ORT. Αυτός ο αριθμός εξαρτάται από μια σειρά παραμέτρων (βλ ). ee_create(), με την οποία το ORT ζητάει από το EELIB να δημιουργήσει τον αριθμό οντοτήτων που τελικά μπορεί να υποστηρίξει. Στις παραμέτρους της συνάρτησης προωθεί στο EELIB και κατά επέκταση στις οντότητες που θα συμμετέχουν στους υπολογισμούς, τις απαραίτητες πληροφορίες για τη δουλειά τους όπως, τη συνάρτηση που θα εκτελέσουν, το επίπεδο παραλληλίας στο οποίο θα βρίσκονται καθώς και πληροφορίες που έχουν να κάνουν με τον πατέρα της ομάδας. ee_waitall(), την οποία καλεί το αρχικό νήμα όταν ολοκληρώσει τον κώδικα 27