ΕΘΝΙΚΟ ΚΑΙ ΚΑΠΟΔΙΣΤΡΙΑΚΟ ΠΑΝΕΠΙΣΤΗΜΙΟ ΑΘΗΝΩΝ

Transcript

1 ΕΘΝΙΚΟ ΚΑΙ ΚΑΠΟΔΙΣΤΡΙΑΚΟ ΠΑΝΕΠΙΣΤΗΜΙΟ ΑΘΗΝΩΝ ΣΧΟΛΗ ΘΕΤΙΚΩΝ ΕΠΙΣΤΗΜΩΝ ΤΜΗΜΑ ΠΛΗΡΟΦΟΡΙΚΗΣ ΚΑΙ ΤΗΛΕΠΙΚΟΙΝΩΝΙΩΝ ΠΡΟΓΡΑΜΜΑ ΜΕΤΑΠΤΥΧΙΑΚΩΝ ΣΠΟΥΔΩΝ "ΤΕΧΝΟΛΟΓΙΑ ΣΥΣΤΗΜΑΤΩΝ ΥΠΟΛΟΓΙΣΤΩΝ" ΔΙΠΛΩΜΑΤΙΚΗ ΕΡΓΑΣΙΑ ΥΛΟΠΟΙΗΣΗ ΓΕΝΙΚΕΥΜΕΝΟΥ ΠΟΛΛΑΠΛΑΣΙΑΣΜΟΥ ΓΡΑΦΟΥ ΣΕ ΚΑΡΤΑ ΓΡΑΦΙΚΩΝ Ευάγγελος Ν. Νικολόπουλος Επιβλέπων: Ιωάννης Ιωαννίδης, Καθηγητής ΑΘΗΝΑ ΟΚΤΩΒΡΙΟΣ 2017

2 ΔΙΠΛΩΜΑΤΙΚΗ ΕΡΓΑΣΙΑ Υλοποίηση γενικευμένου πολλαπλασιασμού γράφου σε κάρτα γραφικών Ευάγγελος Ν. Νικολόπουλος Α.Μ.: Μ1398 ΕΠΙΒΛΕΠΩΝ: Ιωάννης Ιωαννίδης, Καθηγητής ΕΞΕΤΑΣΤΙΚΗ ΕΠΙΤΡΟΠΗ: Ιωάννης Ιωαννίδης, Καθηγητής Μέμα Ρουσσοπούλου, Αναπληρωτής Καθηγητής Οκτώβριος 2017

3 ΠΕΡΙΛΗΨΗ Η αλματώδης τεχνολογική εξέλιξη των καρτών γραφικών τα τελευταία χρόνια, η σχέση κόστους προς επεξεργαστική ισχύ καθώς και η εισαγωγή μοντέλων προγραμματισμού γενικού σκοπού σε αυτές, τις καθιστούν ελκυστική επιλογή για πληθώρα εφαρμογών. Οι κάρτες γραφικών μας προσφέρουν μαζική παραλληλία και συνεπώς μεγάλη επεξεργαστική ισχύ. Σε αυτή την εργασία ασχολούμαστε με επεξεργασία γράφων σε κάρτες γραφικών. Συγκεκριμένα υλοποιούμε το μοντέλο του γενικευμένου πολλαπλασιασμού γράφων με το οποίο μπορούμε να εκφράσουμε ενδιαφέροντα προβλήματα σε δεδομένα γράφων όπως είναι η εύρεση των φίλων των φίλων κάθε χρήστη ενός κοινωνικού δικτύου. Δείχνουμε πως μπορούμε να εκμεταλλευτούμε τη μαζική παραλληλία, ανάλογα με τις ιδιότητες κάθε κόμβου του γράφου, προκειμένου να ελαχιστοποιήσουμε τον χρόνο εκτέλεσης. Παρουσιάζουμε μια νέα υβριδική προσέγγιση ταξινόμησης μικρών πινάκων σε κάρτες γραφικών. Στη συνέχεια μέσα από ένα σύνολο από πειράματα με γράφους με διαφορετικές ιδιότητες δείχνουμε ότι η υλοποίηση σε κάρτα γραφικών είναι γρηγορότερη στις περιπτώσεις από μια σε επεξεργαστή γενικού σκοπού και με χαμηλότερο κόστος υλικού. Τέλος παρουσιάζουμε εν συντομία σχετικές εργασίες σε κάρτες γραφικών τόσο σε επεξεργασία γράφων όσο και κλασικών τελεστών βάσεων. ΘΕΜΑΤΙΚΗ ΠΕΡΙΟΧΗ: Επεξεργασία δεδομένων γράφων ΛΕΞΕΙΣ ΚΛΕΙΔΙΑ: πολλαπλασιασμός γράφων, κάρτα γραφικών, βελτιστοποίηση, μαζική παραλληλία

4 ABSTRACT In recent years graphics processing units (GPUs) have become an attractive choice for use in a variety of applications due to their rapid technological development that has introduced a "strong" cost-to-processing power ratio and general purpose programming models. GPUs offer massive parallelism and thus great processing power. In this work we deal with graph processing on GPUs. Specifically, we implement the generalized graph multiplication model which can be used to express interesting graph processing problems such as finding friends of friends of every user of a social network. We show how we can take advantage of mass parallelism, depending on the properties of each graph node, in order to minimize execution time. We present a new hybrid approach of sorting small tables using GPUs. Then, through a set of experiments on graphs with different properties, we show that the implementation on GPUs may achieve faster execution times than a general purpose processor (CPU) while having lower hardware cost. Finally, we briefly present related work in both graph processing and traditional database operators on GPUs. SUBJECT AREA: Graph Processing KEYWORDS: graph multiplication, graphics processing unit, optimization, massive parallelism

5 Στην οικογένεια και ιδιαίτερα στον παππού μου, Βαγγέλη Νικολόπουλο.

6 ΕΥΧΑΡΙΣΤΙΕΣ Θα ήθελα να ευχαριστήσω τον επιβλέπων καθηγητή κ. Ιωαννίδη καθώς και τον Μάνο Καρβούνη και στον Σταμάτη Χριστοφορίδη για την αρχική ιδέα και τις καθημερινές συζήτησης που είχαμε σε όλη τη διάρκεια της παρούσας εργασίας.

7 ΠΕΡΙΕΧΟΜΕΝΑ ΠΡΟΛΟΓΟΣ ΕΙΣΑΓΩΓΗ ΓΕΝΙΚΕΥΜΕΝΟΣ ΠΟΛΛΑΠΛΑΣΙΑΣΜΟΣ ΓΡΑΦΩΝ Πράξη Συνένωσης Πράξη Σύνθεσης Παράδειγμα Προβλήματος ΓΠΓ ΠΡΟΓΡΑΜΜΑΤΙΣΤΙΚΟ ΠΕΡΙΒΑΛΛΟΝ CUDA Εισαγωγή στην CUDA Η Αρχιτεκτονική Το Προγραμματιστικό Μοντέλο Η Δομή του Κώδικα Μοντέλο Παραλληλισμού Ιεραρχία Μνήμης Καταχωρητές (Registers) Κοινή Μνήμη (Shared Memory) Καθολική Μνήμη (Global Memory) Σταθερή Μνήμη (Constant Memory) Τοπική Μνήμη (Local Memory) ΕΠΕΞΕΡΓΑΣΙΑ ΓΡΑΦΟΥ Επιθυμητό Αποτέλεσμα Βασικό Πλάνο Εκτέλεσης Αποθήκευση Γράφου Compressed Sparse Row Υλοποίηση GPU Πλάνο Εκτέλεσης σε GPU Ακραίες περιπτώσεις υλοποίησης GPU Ταξινόμηση Μικρών Πινάκων στη GPU ΠΕΙΡΑΜΑΤΙΚΗ ΑΞΙΟΛΟΓΗΣΗ Επίδραση Ορίου Μεγάλων Κόμβων Επίδραση Ορίου Μικρών Κόμβων Αξιολόγηση Υβριδικής Ταξινόμησης Σύγκριση με υλοποίηση σε CPU... 40

8 6. ΣΧΕΤΙΚΕΣ ΕΡΓΑΣΙΕΣ ΣΥΜΠΕΡΑΣΜΑΤΑ ΠΙΝΑΚΑΣ ΟΡΟΛΟΓΙΑΣ ΣΥΝΤΜΗΣΕΙΣ ΑΡΚΤΙΚΟΛΕΞΑ ΑΚΡΩΝΥΜΙΑ ΑΝΑΦΟΡΕΣ... 47

9 ΚΑΤΑΛΟΓΟΣ ΣΧΗΜΑΤΩΝ Σχήμα 1: Παράδειγμα γράφου, οι κόμβοι συμβολίζουν χρήστες ενός κοινωνικού δικτύου ενώ οι ακμές σχέσεις "ακολουθεί" μεταξύ των χρηστών. πχ ο χρήστης 1 ακολουθεί τον χρήστη Σχήμα 2: Περισσότερα τρανζίστορ της GPU είναι αφιερωμένα στην επεξεργασία δεδομένων Σχήμα 3: Εξέλιξη υπολογιστικής ισχύος στη πορεία του χρόνου σε Intel CPUs και Nvidia GPUs Σχήμα 4: Εξέλιξη μέγιστης θεωρητικής ταχύτητας μνήμης στη πορεία του χρόνου σε Intel CPUs και Nvidia GPUs Σχήμα 5: Αρχιτεκτονική GTX Σχήμα 6: Αρχιτεκτονική ενός Streaming Multiprocessor της γενιάς Pascal Σχήμα 7: Τα threads ενός kernel οργανώνονται σε blocks και τα blocks σε ένα Grid Σχήμα 8: Ιεραρχία και συνδέσεις μνημών στην αρχιτεκτονική της CUDA [4] Σχήμα 9: Οι ακμές που προκύπτουν για τον κόμβο 0 μετά τη πράξη της ένωσης (αριστερά) και μετά τη πράξη της ομαδοποίησης, με τα βάρη τους (δεξιά) Σχήμα 10: Δομή Compressed Sparse Row (CSR) Σχήμα 11: Ανάθεση blocks σε εξερχόμενες ακμές, κάθε χρώμα συμβολίζει ένα διαφορετικό block από νήματα Σχήμα 12: Ενημέρωση του πίνακα ομαδοποίησης από πολλαπλά νήματα Σχήμα 13: Διαδικασία μεταφοράς του αποτελέσματος από τον πίνακα ομαδοποίησης (a) στον πίνακα εξόδου (d) Σχήμα 14: Μεταφορά αποτελέσματος με χρήση της κοινής μνήμης Σχήμα 15: Πίνακας ομαδοποίησης για κόμβους με λίγα αποτελέσματα Σχήμα 16: Bitonic sorting network για 8 στοιχεία Σχήμα 17: Δομή υβριδικής ταξινόμησης Σχήμα 18: Μονοπάτι συγχώνευσης Σχήμα 19: Παράδειγμα χρήσης μονοπατιού συγχώνευσης με 4 νήματα Σχήμα 20: Επίδραση ορίου μεγάλων κόμβων στον γράφο GSH Σχήμα 21: Επίδραση ορίου μικρών και μεσαίων κόμβων στον γράφο Arabic Σχήμα 22: Αξιολόγηση υβριδικής ταξινόμησης στον γράφο Arabic, σύγκριση με bitonic sort Σχήμα 23: Σύγκριση CPU-GPU με χρήση του γράφου LiveJournal Σχήμα 24: Σύγκριση CPU-GPU με χρήση του γράφου Hollywood Σχήμα 25: Σύγκριση CPU-GPU με χρήση του γράφου Arabic Σχήμα 26: Σύγκριση CPU-GPU με χρήση του γράφου GSH

10 ΚΑΤΑΛΟΓΟΣ ΠΙΝΑΚΩΝ Πίνακας 1: Πίνακας αποτελεσμάτων για τον κόμβο Πίνακας 2: Αρχική και τελική κατάσταση πίνακα ομαδοποίησης Πίνακας 3: Οι Γράφοι που χρησιμοποιήθηκαν Πίνακας 4: Χαρακτηριστικά καρτών GTX1060 και GTX

11 ΠΡΟΛΟΓΟΣ Η διπλωματική εργασία πραγματοποιήθηκε στην Αθήνα το ακαδημαϊκό έτος και έχει στόχο τη μελέτη και την ανάπτυξη ενός πλάνου εκτέλεσης για τον υπολογισμό του πολλαπλασιασμού γράφων, αποδοτικά σε κάρτες γραφικών.

12 1. ΕΙΣΑΓΩΓΗ Οι γράφοι αποτελούνται από κόμβους και ακμές που τους συνδέουν, τόσο οι κόμβοι όσο και οι ακμές μπορεί να έχουν κάποια τιμή, οι ακμές μπορεί να είναι κατευθυνόμενες ή όχι. Αποτελούν τη βασική μοντελοποίηση δεδομένων για προβλήματα που εκτείνονται σε ένα ευρύ σύνολο από περιοχές όπως κοινωνικά και οδικά δίκτυα, το Διαδίκτυο, τη βιολογία κ.ά. Μετά από επεξεργασία τους μπορούμε να εξάγουμε χρήσιμα συμπεράσματα όπως τη συντομότερη διαδρομή μεταξύ δύο σημείων στο χάρτη ή τη σχέση μεταξύ δύο ιστοσελίδων στο Διαδίκτυο. Μας ενδιαφέρει λοιπόν να μπορούμε να επεξεργαστούμε αποδοτικά και γρήγορα έναν γράφο. Ένας γράφος μπορεί να χαρακτηριστεί από απλές μετρικές όπως το πλήθος των κόμβων και των ακμών του αλλά και από πιο πολύπλοκες όπως τον συντελεστή συγκέντρωσης (clustering coefficient) και τη διάμετρό του. Από τη φύση τους οι γράφοι συνήθως έχουν κακή τοπικότητα (locality) και ακανόνιστη μορφή, συχνά υπάρχουν λίγοι πολύ δημοφιλείς κόμβοι και πολλοί λιγότερο δημοφιλείς. Αυτά είναι χαρακτηριστικά που δυσκολεύουν την αποδοτική εκτέλεση αλγόριθμων σε δεδομένα γράφων και για τον λόγο αυτό απαιτούν ειδική μεταχείριση. Το 2010 παρουσιάστηκε για πρώτη φορά στο σύστημα Pregel [1] το μοντέλο Think Like A Vertex (TLAV) και από τότε έχουν υλοποιηθεί διάφορα συστήματα σε διαφορετικά περιβάλλοντα που το υλοποιούν. Στο TLAV ο χρήστης, όπως λέει και το όνομά του, σκέφτεται σαν κόμβος και ορίζει μια συνάρτηση υπολογισμού που θα εκτελέσει ο κόμβος λαμβάνοντας μηνύματα μέσω των εισερχόμενων ακμών του από άλλους κόμβους και στέλνοντας μηνύματα μέσω των εξερχόμενων ακμών του, με τη σειρά του, στους επόμενους κόμβους. Με το μοντέλο αυτό μπορούμε να υλοποιήσουμε δημοφιλής αλγόριθμους επεξεργασίας και ανάλυσης γράφων όπως PageRank [2], εύρεση συντομότερου μονοπατιού από έναν προς όλους τους άλλους κόμβους του γράφου (Single Source Shortest Path SSSP) και άλλα. Με το μοντέλο του γενικευμένου πολλαπλασιασμού γράφων (ΓΠΓ), που θα μας απασχολήσει στη παρούσα εργασία, μπορούμε να μοντελοποιήσουμε άλλα επίσης ενδιαφέροντα προβλήματα όπως, εύρεση των φίλων των φίλων κάθε χρήστη ενός κοινωνικού δικτύου, μετρικές ομοιότητας και άλλα. Προκειμένου να επιταχύνουμε την εκτέλεση του ΓΠΓ θα χρησιμοποιήσουμε εξειδικευμένο υλικό και συγκεκριμένα κάρτες γραφικών. Με τη αλματώδη εξέλιξη της τεχνολογίας των καρτών γραφικών τα τελευταία χρόνια έχουμε στη διάθεσή μας πολύ μεγαλύτερη θεωρητική υπολογιστική ισχύ, με χαμηλό κόστος, σε σχέση με έναν επεξεργαστή γενικού σκοπού. Αν και αρχικά οι κάρτες γραφικών αναπτύχθηκαν για επεξεργασία γραφικών και ο κύριος προσανατολισμός τους παραμένει αυτός, η εισαγωγή προγραμματιστικών μοντέλων γενικού σκοπού κάνει τη χρήση τους πολύ δελεαστική. Σε διάφορα προβλήματα προσπαθούμε να εκμεταλλευτούμε την επεξεργαστική ισχύ τους ώστε να επιταχύνουμε τους υπολογισμούς μας. Οι κάρτες γραφικών προφέρουν ένα πολύ μεγάλο αριθμό από επεξεργαστικούς πυρήνες καθώς και ομοιόμορφη καθυστέρηση αλλά και πολύ γρήγορη πρόσβαση στη κύρια μνήμη τους. Στη παρούσα εργασία θα παρουσιάσουμε την υλοποίηση ΓΠΓ σε κάρτες γραφικών. Οι συνεισφορές της εργασίας είναι (α) ο καθορισμός και η υλοποίηση ενός πλάνου εκτέλεσης ΓΠΓ με αποδοτική αξιοποίηση των πόρων της κάρτας γραφικών (β) παρουσίαση μιας νέας προσέγγισης ταξινόμησης μικρών πινάκων σε κάρτα γραφικών που κρίθηκε απαραίτητο να αναπτύξουμε και (γ) ένα σύνολο από πειράματα που αξιολογούν τις προηγούμενες συνεισφορές. Η συνέχεια της εργασίας οργανώνεται ως εξής: Στο Κεφάλαιο 2 παρουσιάζουμε το μοντέλο του ΓΠΓ, τις ιδιότητες και τις πράξεις που το αποτελούν. Στο Κεφάλαιο 3 Ε. Νικολόπουλος 12

13 παρουσιάζουμε το προγραμματιστικό περιβάλλον CUDA της Nvidia στο οποίο υλοποιήθηκε η παρούσα εργασία. Στο Κεφάλαιο 4 περιγράφουμε το πλάνο εκτέλεσης και την υλοποίηση του ΓΠΓ στη κάρτα γραφικών καθώς και τις βελτιστοποιήσεις που κάναμε. Στο Κεφάλαιο 5 αξιολογούμε πειραματικά την υλοποίησή μας σε σχέση με μια CPU υλοποίηση. Στο Κεφάλαιο 6 περιγράφουμε σχετικές εργασίες και επιρροές μας. Ενώ στο Κεφάλαιο 7 καταλήγουμε με τα συμπεράσματα που προέκυψαν από τη παρούσα εργασία. Ε. Νικολόπουλος 13

14 2. ΓΕΝΙΚΕΥΜΕΝΟΣ ΠΟΛΛΑΠΛΑΣΙΑΣΜΟΣ ΓΡΑΦΩΝ Έστω ότι αναπαριστούμε έναν γράφο G με χρήση πίνακα γειτνίασης (adjacency matrix). Ο πίνακας γειτνίασης είναι ένας πίνακας 2 διαστάσεων, στο κελί (i, j) αντιστοιχίζουμε τις ιδιότητες της ακμής του γράφου από τον κόμβο i στον κόμβο j (i, j). Ορίζουμε το μοντέλο των Γενικευμένων Πολλαπλασιασμών Γράφων (ΓΠΓ) γενικεύοντας τη πράξη του κλασσικού πολλαπλασιασμού πινάκων G G με αντικατάσταση της πράξης του πολλαπλασιασμού και της πρόσθεσης με τελεστές συνένωσης (concatenation CON) και σύνθεσης (aggregation AGG). Ο τελεστής ΓΠΓ ορίζεται ως: 2.1 Πράξη Συνένωσης G G = G 2, όπου G 2 ij = AGG N 1 k=0 (G ik CON G kj ) Η πράξη της συνένωσης, πραγματοποιείται με μια διαδικασία ένωσης (join), ενώνει κάθε εισερχόμενη ακμή ενός κόμβου c με κάθε εξερχόμενη ακμή του δημιουργώντας μια νέα ακμή. Έτσι, αν (s, c) μια εισερχόμενη και (c, t) μια εξερχόμενη ακμή του κόμβου c η πράξη της ένωσης παράγει μια νέα ακμή (s, t). Παρατηρούμε ότι με τη πράξη αυτή ενώνουμε τους κόμβους που απέχουν 2 βήματα (hops) απόσταση μεταξύ τους, τον s και τον t. Κατά τη πράξη της ένωσης μπορούμε να εφαρμόσουμε έναν τελεστή ένωσης ( con operator) οριζόμενο από τον χρήστη (User Defined Function UDF). Ο τελεστής θα παράγει τη τιμή (label) της καινούργιας ακμής με βάση τις αρχικές ακμές των ακμών που ενώθηκαν, μπορεί για παράδειγμα να είναι το μέγιστο, το ελάχιστο, ο μέσος όρος, το άθροισμα κοκ. 2.2 Πράξη Σύνθεσης Η πράξη της σύνθεσης, πραγματοποιείτε με μια διαδικασία ομαδοποίησης (group by), ομαδοποιεί τις ακμές με κοινό κόμβο αφετηρίας και προορισμού. Κατά τη ομαδοποίηση, εφαρμόζεται ο οριζόμενος από τον χρήστη τελεστής σύνθεσης ( agg operator) που καθορίζει την τιμή της ακμής που προκύπτει μετά την ομαδοποίηση. Ο τελεστής μπορεί να είναι, όπως και στην πράξη της συνένωσης, το μέγιστο, το ελάχιστο, ο μέσος όρος, το άθροισμα κοκ. 2.3 Παράδειγμα Προβλήματος ΓΠΓ Θεωρούμε κατευθυνόμενο τον γράφο κοινωνικού δικτύου (Σχήμα 1) με τους κόμβους να αναπαριστούν χρήστες και τις ακμές να αναπαριστούν σχέσεις «ακολουθεί». Ο χρήστης 0 ακολουθεί τους χρήστες 1, 2, 3 και 4. Ο χρήστης 1 τον χρήστη 3 κοκ. Θέλουμε να απαντήσουμε στο ερώτημα «Ποιους χρήστες ακολουθούν οι ακόλουθοι κάθε χρήστη και μέσω πόσων διαφορετικών μονοπατιών;» Δηλαδή για τον χρήστη 0 η απάντηση είναι ότι ακολουθεί: Τον χρήστη 3 μέσω ενός μονοπατιού, τον χρήστη 5 μέσω ενός μονοπατιού, τον χρήστη 6 μέσω 2 μονοπατιών (μέσω των χρηστών 2 και 3) και τον χρήστη 7 μέσω 3 μονοπατιών (μέσω των χρηστών 2, 3 και 4). Με χρήση των τελεστών «τίποτα» (nil) για con και «μέτρηση» (count) για agg μπορούμε να απαντήσουμε τη συγκεκριμένη ερώτηση με ένα σύστημα που υλοποιεί ΓΠΓ. Επίσης μπορούν να υπολογιστούν ερωτήματα όπως εύρεσης συντομότερου μονοπατιού από όλους τους κόμβους προς όλους τους άλλους του γράφου (Multiple Source Shortest Path MSSP) με ακολουθία από πολλαπλασιασμούς G G G. Για τη συνέχεια της παρούσας εργασίας και για λόγους απλότητας θα υποθέτουμε τελεστές con και agg το άθροισμα και έναν μόνο πολλαπλασιασμό G G. Ενώ θα γίνει αναφορά και στο πως μπορούν να υλοποιηθούν περισσότεροι του ενός πολλαπλασιασμού. Ε. Νικολόπουλος 14

15 Σχήμα 1: Παράδειγμα γράφου, οι κόμβοι συμβολίζουν χρήστες ενός κοινωνικού δικτύου ενώ οι ακμές σχέσεις "ακολουθεί" μεταξύ των χρηστών. πχ ο χρήστης 1 ακολουθεί τον χρήστη 3. Ε. Νικολόπουλος 15

16 3. ΠΡΟΓΡΑΜΜΑΤΙΣΤΙΚΟ ΠΕΡΙΒΑΛΛΟΝ CUDA Η CUDA είναι μια πλατφόρμα παράλληλων υπολογισμών γενικού σκοπού σε κάρτες γραφικών, παρέχει μια διεπαφή προγραμματισμού εφαρμογών και παρουσιάστηκε από την NVIDIA το 2007 [3]. 3.1 Εισαγωγή στην CUDA Η CUDA (Compute Unified Device Architecture) είναι μια παράλληλη αρχιτεκτονική καρτών γραφικών σχεδιασμένη από την NVIDIA. Ταυτόχρονα αποτελεί ένα προγραμματιστικό μοντέλο που παρέχει διεπαφές προγραμματισμού εφαρμογών (Application Interface API ) καθώς και μεταγλωττιστές σε γλώσσες υψηλού επιπέδου όπως C, C++, Python, Fortran. Επιτρέπει στον προγραμματιστή να σχεδιάζει εφαρμογές γενικού σκοπού που μπορούν να εκτελεστούν παράλληλα σε συμβατή κάρτα γραφικών. Οι απαιτήσεις της αγοράς για υψηλή απόδοση στην επεξεργασία τρισδιάστατων γραφικών σε πραγματικό χρόνο, αποτέλεσαν μοχλό ώστε να εξελιχθούν οι επεξεργαστές γραφικών (Graphics Processing Unit GPU). Οι GPUs σήμερα είναι πολυπύρηνοι, πολυνηματικοί επεξεργαστές υψηλού παραλληλισμού και παρέχουν σημαντικά υψηλότερη υπολογιστική ισχύ καθώς και μεγαλύτερο εύρος μνήμης (Memory Bandwidth) έναντι των πολυπύρηνων επεξεργαστών γενικού σκοπού (Central Processing Unit CPU). Τα χαρακτηριστικά αυτά πηγάζουν από το γεγονός ότι είναι κατασκευασμένες για παράλληλη επεξεργασία μεγάλου όγκου δεδομένων και έτσι, η ανάγκη ύπαρξης δομών ελέγχου ροής κ.α. εντός του ολοκληρωμένου, που αυξάνουν τη πολυπλοκότητα κατασκευής και μειώνουν την υπολογιστική απόδοση, είναι πολύ μικρότερη, όπως βλέπουμε στο Σχήμα 2. Σχήμα 2: Περισσότερα τρανζίστορ της GPU είναι αφιερωμένα στην επεξεργασία δεδομένων. Στο Σχήμα 3 βλέπουμε την αύξηση της υπολογιστικής ισχύος των καρτών γραφικών ανά γενεά σε σύγκριση με τις αντίστοιχες γενεές επεξεργαστών γενικού σκοπού. Ενώ στο Σχήμα 4 παρουσιάζεται η αντίστοιχη εξέλιξη του εύρους μνήμης. Παρατηρούμε ότι στους δύο αυτούς τομείς οι GPUs όχι μόνο υπερτερούν σημαντικά αλλά εξελίσσονται και γρηγορότερα. Ε. Νικολόπουλος 16

17 Σχήμα 3: Εξέλιξη υπολογιστικής ισχύος στη πορεία του χρόνου σε Intel CPUs και Nvidia GPUs. Σχήμα 4: Εξέλιξη μέγιστης θεωρητικής ταχύτητας μνήμης στη πορεία του χρόνου σε Intel CPUs και Nvidia GPUs Ε. Νικολόπουλος 17

18 3.2 Η Αρχιτεκτονική Η Geforce 8800 GTX ήταν η πρώτη κάρτα γραφικών σχεδιασμένη από την NVIDIA με βάση την αρχιτεκτονική CUDA. Αποτέλεσε την πρώτη γενιά αρχιτεκτονικής CUDA και φέρει την κωδική ονομασία Tesla. Ακολούθησε η γενιά Fermi με βελτιώσεις στην ιεραρχία μνήμης καθώς και αύξηση του αριθμού των μικροεπεξεργαστών, του αριθμού των νημάτων που μπορεί να εκτελέσει ταυτόχρονα, της υπολογιστική ισχύος, του μεγέθους μνήμης αλλά και του εύρους και της ταχύτητας του ρολογιού της μνήμης. Την αρχιτεκτονική Fermi διαδέχτηκαν η Kepler, η Maxwell με τη τρέχουσα γενεά να είναι η Pascal. Στο Σχήμα 5 παρουσιάζεται η αρχιτεκτονική της Geforce GTX1060 της αρχιτεκτονικής Pascal που χρησιμοποιήθηκε για τη παρούσα εργασία. Όπως μπορούμε να δούμε, είναι δομημένη ως μια κλιμακωτή συστοιχία από πολυεπεξεργαστές ροής (Streaming Multiprocessors SMs), καθένας από τους οποίους απαρτίζεται από έναν αριθμό από μικροεπεξεργαστές ροής (Streaming Processors) ή πυρήνες (cores). Κάθε SM είναι σχεδιασμένος ώστε να μπορεί να εκτελεί εκατοντάδες νήματα (threads) ταυτόχρονα όπως θα δούμε στη συνέχεια. Επίσης οι πυρήνες είναι οργανωμένοι σε 32άδες, κάθε τέτοιο σύνολο από πυρήνες αποτελεί ένα warp. Οι πυρήνες ενός wrap εκτελούν όλοι την ίδια εντολή κάθε δεδομένη στιγμή (Single Instruction Multiple Data - SIMD). Αυτό είναι κάτι που ο προγραμματιστής πρέπει να λάβει υπόψιν του κατά την υλοποίηση έτσι ώστε να μεγιστοποίηση την απόδοση της εφαρμογής του [4]. Ε. Νικολόπουλος 18

19 Σχήμα 5: Αρχιτεκτονική GTX1060 Συγκεκριμένα η GTX1060 διαθέτει 1280 cores, σε 10 SMs των 128 Cores και 6GB GDDR5 κύριας μνήμης. Στο Σχήμα 6 παρατηρούμε τη δομή ενός SM μιας Pascal GPU. Κάθε SM περιλαμβάνει 128 πυρήνες και είναι χωρισμένος σε 4 μέρη (warps) καθένα από τα οποία έχει ένα αρχείο καταχωρητών, έναν χρονοπρογραμματιστή (scheduler) και 8 special function units (SFU) οι οποίες αναλαμβάνουν πολύπλοκους υπολογισμούς, όπως τριγωνομετρικοί υπολογισμοί, υπολογισμούς ρίζας και άλλους. Προκειμένου να υπάρχει διάκριση των ιδιοτήτων της GPU από γενεά σε γενεά, ορίζεται το Compute Capability (x, y), ως ένας αριθμός που δηλώνει μια μεγάλη έκδοση (x) και μια μικρή έκδοση (y). GPUs που φέρουν την ίδια μεγάλη έκδοση, ανήκουν στην ίδια γενεά αρχιτεκτονικής. Η μικρή έκδοση χαρακτηρίζει βελτιώσεις σε μια αρχιτεκτονική, που μπορεί με τη σειρά τους να φέρουν και πρόσθετες ιδιότητες. H GTX1060 είναι Compute Capability 6.1. Ε. Νικολόπουλος 19

20 Σχήμα 6: Αρχιτεκτονική ενός Streaming Multiprocessor της γενιάς Pascal 3.3 Το Προγραμματιστικό Μοντέλο Στο προγραμματιστικό μοντέλο της CUDA ονομάζουμε συσκευή (Device) την κάρτα γραφικών και μηχάνημα φιλοξενίας (Host) τον ηλεκτρονικό υπολογιστή στον οποίο είναι προσαρτημένη. Η εφαρμογή μας εκτελείτε στον Host και τα κομμάτια που μας ενδιαφέρει να εκτελεστούν παράλληλα ανατίθενται στη κάρτα. Ενόσω το Device είναι απασχολημένο εκτελώντας μέρη της εφαρμογής μας, ο Host δύναται να συνεχίζει να εκτελεί άλλα, ανεξάρτητα, τμήματα της εφαρμογής στο CPU περιμένοντας για τα αποτελέσματα από το Device. Γι αυτό λέγεται ότι πρόκειται για ένα ετερογενές προγραμματιζόμενο σύστημα. Όπως αναφέραμε και νωρίτερα, προκειμένου να μπορούμε να προγραμματίζουμε αυτό το σύστημα, η NVIDIA παρέχει δωρεάν τα απαραίτητα APIs, έτσι μπορούμε να σχεδιάζουμε και να υλοποιούμε εφαρμογές με τη χρήση των γλωσσών προγραμματισμού C/C++, Python και Fortran ενώ παρέχει και διάφορες βιβλιοθήκες. Ε. Νικολόπουλος 20

21 Θα περιγράψουμε τη περίπτωση της γλώσσας C με την οποία έχει υλοποιηθεί και η συγκεκριμένη εργασία. Η CUDA επεκτείνει το συντακτικό της C με ένα σετ από δεσμευμένες λέξεις, οι οποίες χρησιμοποιούμενες ως προθέματα στον κώδικα, επιτρέπουν στον προγραμματιστή να καθορίζει ποια τμήματα αυτού προβλέπονται για εκτέλεση στο Device. Τέλος, διατίθενται ο μεταγλωττιστής nvcc (nvcc compiler), ο οποίος παράγει από τον κώδικά μας ένα εκτελέσιμο για GPU Η Δομή του Κώδικα Ο κώδικας κάθε εφαρμογής CUDA χωρίζεται σε δυο μέρη, το κομμάτι που εκτελείται στον Host (Host Code) και το κομμάτι που εκτελείται στο Device (Device Code). Κάθε αυτόνομο κομμάτι κώδικα, που υλοποιεί μια συγκεκριμένη εργασία που θέλουμε να εκτελεστεί στο Device, ονομάζεται Kernel. Ένας kernel ορίζεται ως μια συνάρτηση στο κομμάτι του Device Code με χρήση του προθέματος global. Το κομμάτι του Host Code είναι ένα κλασικό πρόγραμμα C που ξεκινάει την εκτέλεση από τη συνάρτηση main() και περιλαμβάνει εκτός από τον κώδικα που θα εκτελεστεί στον Host και τις κλήσεις προς τους kernels. Το κομμάτι του Device Code περιλαμβάνει τουλάχιστον έναν ή και περισσότερους kernels και ότι άλλες βοηθητικές συναρτήσεις και παράμετροι χρειάζονται για την εκτέλεση αυτών. Συναρτήσεις που τοποθετούνται στο κομμάτι του Device Code, ορίζονται σε καθολικό επίπεδο με χρήση του προθέματος device. Η συνήθης ροή εκτέλεσης μιας εφαρμογής είναι: ξεκινώντας από τον Host, η δέσμευση απαραίτητου χώρου μνήμης στο Device και η μεταφορά των απαραίτητων δεδομένων σε αυτό, η κλήση σε έναν ή περισσότερους kernels διαδοχικά, που θα επεξεργαστούν εν παραλλήλω τα δεδομένα αυτά και, μετά το πέρας της εκτέλεσης του kernel, η μεταφορά των αποτελεσμάτων από το Device πίσω στο Host Μοντέλο Παραλληλισμού Το μοντέλο προγραμματισμού που χρησιμοποιεί η CUDA το ονομάζει Single Instruction Multiple Threads (SIMT). Αυτό προτάσσει την εκτέλεση της ίδιας εντολής ή του ίδιου σετ εντολών, από πολλά, παράλληλα, ανεξάρτητα μεταξύ τους νήματα (Threads). Είναι παρόμοιο με το μοντέλο Single Instruction Multiple Data (SIMD) που συναντάται στις τεχνολογίες SSE, MMX και AVX των σύγχρονων επεξεργαστών, με τη διαφορά ότι κάθε thread διαθέτει τα προσωπικά του δεδομένα, τους προσωπικούς του καταχωρητές (Registers) και τον προσωπικό του μετρητή εντολών (instruction counter), που του επιτρέπουν να εκτελείται και να διακλαδίζεται αυτόνομα και ανεξάρτητα από τα υπόλοιπα threads. Πράγμα μη εφικτό στο μοντέλο SIMD, όπου συνήθως, ένα διάνυσμα από δεδομένα, μοιράζεται από κοινού τα παραπάνω αναφερθέντα στοιχεία, ανά πυρήνα επεξεργαστή [5]. Κάθε kernel επομένως, αποτελεί ένα σετ εντολών, που θα εκτελεστεί εν παραλλήλω από έναν μεγάλο αριθμό από threads. Τα threads που δημιουργούνται με την κλήση ενός kernel, ομαδοποιούνται σε ένα πλέγμα (Grid), το οποίο υποδιαιρείται σε Blocks από threads. Εντός του κάθε block, τα threads υποδιαιρούνται περαιτέρω σε ομάδες των 32 όπως αναφέραμε και νωρίτερα που ονομάζονται warps. (βλ. Σχήμα 7Σχήμα 6) Ε. Νικολόπουλος 21

22 Σχήμα 7: Τα threads ενός kernel οργανώνονται σε blocks και τα blocks σε ένα Grid. Τα blocks μοιράζονται προς εκτέλεση στους διαθέσιμους SMs, δοθέντος ότι υπάρχουν αρκετοί διαθέσιμοι πόροι για να τα υποστηρίξουν (καταχωρητές, επαρκείς τοπική μνήμη κτλ.). Αν οι πόροι δεν επαρκούν, τότε αυτομάτως στον κάθε SM θα μοιραστούν λιγότερα Blocks, με τέτοιο τρόπο ώστε αυτά να μπορούν να εκτελεστούν. Στην αρχιτεκτονική Pascal και συγκεκριμένα στο Compute Capability 6.1 που είχαμε στη διάθεση μας, γίνεται θεωρητικά να εκτελεστούν 32 blocks των 1024 threads σε κάθε SM, δηλαδή 320 blocks για τους 10 SMs της GTX1060. Στη πράξη αυτός ο αριθμός δεν είναι σχεδόν ποτέ εφικτός καθότι οι πόροι του κάθε SM, όπως θα αναλύσουμε στη συνέχεια είναι περιορισμένοι, έτσι τα threads ανά block αλλά και τα ενεργά blocks ανά SM είναι συνήθως μικρότερα των θεωρητικών τιμών. Ενδεικτικά για το Compute Capability 6.1 έχουμε 64K registers και 96KB shared memory ανά SM. Την ευθύνη για τον σωστό ορισμό του μέγιστου αριθμού των threads που μπορούν να υποστηριχτούν ανά εφαρμογή και πως αυτά μπορούν να υποδιαιρεθούν κατά τον ιδανικότερο τρόπο σε blocks την φέρει ο προγραμματιστής. Κάθε block εντός του Grid ταυτοποιείται μοναδικά με χρήση της προκαθορισμένης μεταβλητής blockidx, ενώ κάθε thread εντός του κάθε block ταυτοποιείται μοναδικά με τη προκαθορισμένη μεταβλητή threadidx. Ο αριθμός των Blocks μέσα σε ένα Grid καθορίζεται από την μεταβλητή griddim και τέλος ο αριθμός των threads ανά block καθορίζεται από την μεταβλητή blockdim. Οι μεταβλητές griddim, blockdim, threadidx και blockidx είναι δομές των τριών διαστάσεων, που σημαίνει ότι μπορούμε να ορίζουμε blocks της μιας, των δύο ή και των τριών διαστάσεων από threads, καθώς και Grids της μιας, των δυο ή των τριών διαστάσεων από blocks. 3.4 Ιεραρχία Μνήμης Στο διάγραμμα στο Σχήμα 8 βλέπουμε τις διάφορες κατηγορίες μνήμης που περιέχει μια GPU στην αρχιτεκτονική της CUDA και πως αυτές συνδέονται μεταξύ τους. Οι διάφοροι τύποι μνημών που διαθέτει μια GPU είναι οι: Καταχωρητές ή Registers Ε. Νικολόπουλος 22

23 Κοινή Μνήμη ή Shared Memory Καθολική Μνήμη ή Global Memory Σταθερή Μνήμη ή Constant Memory Τοπική Μνήμη ή Local Memory L1 και L2 Προσωρινή μνήμη ή Cache Σχήμα 8: Ιεραρχία και συνδέσεις μνημών στην αρχιτεκτονική της CUDA [4]. Όλα τα είδη μνημών μιας GPU έχουν συγκεκριμένες ιδιότητες, όπως ταχύτητα προσπέλασης, μέγεθος, εμβέλεια και χρόνο ζωής. Το να γνωρίζουμε αυτές τις ιδιότητες για τον κάθε τύπο μνήμης μας βοηθάει να διαλέξουμε ποια και πότε θα χρησιμοποιήσουμε προκειμένου η εφαρμογή μας να εκτελείτε σωστά και με την καλύτερη δυνατή απόδοση. Στη συνέχεια θα αναλύσουμε τους παραπάνω τύπους μνημών και τις ιδιότητές τους Καταχωρητές (Registers) Οι καταχωρητές βρίσκονται εντός των SMs και κάθε SM διαθέτει τους δικούς του. Η ταχύτητα προσπέλασης ενός καταχωρητή είναι πάρα πολύ μεγάλη, αλλά ο διαθέσιμος αριθμός τους ανά block είναι περιορισμένος. Κάθε απλή μεταβλητή που δηλώνεται εντός ενός Kernel και δεν φέρει κάποιο συγκεκριμένο πρόθεμα, αυτόματα τοποθετείται σε κάποιον καταχωρητή. Το ίδιο συμβαίνει και με πίνακες για τους οποίους το μέγεθος, η δομή και η δεικτοδότηση είναι γνωστά κατά τη μεταγλώττιση της εφαρμογής. Ε. Νικολόπουλος 23

24 Η εμβέλεια των καταχωρητών έχει το εύρος ενός thread, που σημαίνει ότι κάθε thread έχει τις μεταβλητές του υποθηκευμένες σε δικούς του, προσωπικούς, καταχωρητές. Συνεπώς και η διάρκεια ζωής τους είναι η διάρκεια ζωής του εκάστοτε thread Κοινή Μνήμη (Shared Memory) Κάθε SM διαθέτει ένα περιορισμένο μέγεθος κοινής μνήμης, προσπελάσιμης από όλα τα threads που εδρεύουν εντός του ίδιου block. Αυτό καθορίζει την διάρκεια ζωής της να είναι ίδια με αυτή του εκάστοτε block. Επίσης, κάνει την ταχύτητα προσπέλασής της να είναι πάρα πολύ μεγάλη, περίπου 100 φορές πιο γρήγορη από αυτή της καθολικής μνήμης. Όμοια με τους καταχωρητές, είναι και αυτή προσπελάσιμη προς εγγραφή και ανάγνωση μόνο εντός ενός kernel, άρα και η εμβέλειά της είναι αυτή του kernel. Αντίθετα όμως με τους καταχωρητές, εδώ απαιτείται συγχρονισμός στη περίπτωση όπου, διαφορετικά threads του ίδιου block, επιθυμούν να προσπελάσουν τα ίδια δεδομένα εντός της. Προκειμένου να τοποθετηθεί μια μεταβλητή στην κοινή μνήμη, πρέπει να τη δηλώσουμε εντός του kernel με χρήση του προθέματος shared Καθολική Μνήμη (Global Memory) Η καθολική μνήμη βρίσκεται εντός της κάρτας γραφικών, αλλά όχι εντός του γραφικού επεξεργαστή. Τοποθετείται πριν το δίαυλο διασύνδεσης της κάρτας γραφικών με τον ηλεκτρονικό υπολογιστή και έχει αρκετό μέγεθος, εως και 24GB σήμερα. Λέγεται έτσι γιατί είναι η μόνη που είναι προσβάσιμη για εγγραφή και ανάγνωση, τόσο από τον CPU όσο και από την GPU. Πρακτικά είναι ο μόνος τρόπος με τον οποίο μπορούν να μεταφερθούν δεδομένα στη κάρτα γραφικών. Γενικά, η προσπέλαση της καθολικής μνήμης είναι σχετικά αργή, αν και γρηγορότερη από τη πρόσβαση από τον CPU στη RAM. Αυτό δεν την καθιστά προτιμητέα για συχνή προσπέλαση εντός του kernel, καθότι κάθε προσπέλαση σε αυτή κοστίζει πολλαπλούς κύκλους ρολογιού και αυτό ρίχνει δραματικά την απόδοση της εφαρμογής μας. Είναι προσπελάσιμη από όλα τα threads ενός kernel και γενικά απαιτείται προσοχή στον συγχρονισμό, διότι δεν υπάρχει μηχανισμός ελέγχου των επιμέρους threads μεταξύ blocks. Συγχρονισμός στην προσπέλασή της επιτυγχάνεται ουσιαστικά, διασπώντας το πρόβλημα σε επιμέρους kernels και συγχρονίζοντας τις κλήσεις σε αυτούς, μέσα από το Host Code. Η διάρκεια ζωής της είναι ίδια με αυτή της εφαρμογής. Για να τοποθετήσουμε μια μεταβλητή στην καθολική μνήμη, την δηλώνουμε στο κομμάτι του Device Code σε καθολικό επίπεδο (δηλ. εκτός του kernel) με χρήση του προθέματος device. Εναλλακτικά, για μεταφορά δεδομένων στην κάρτα γραφικών, δεσμεύουμε χώρο στην καθολική μνήμη από το Host Code με χρήση της συνάρτησης cudamalloc() και μεταφέρουμε τα δεδομένα στον χώρο αυτό με χρήση της συνάρτησης cudamemcpy(). Με την ίδια συνάρτηση επιτυγχάνεται και η αντίστροφη διαδικασία, μεταφορά δεδομένων δηλ. από την κάρτα γραφικών πίσω στον Host. Στην περίπτωση που έχουμε δεσμεύσει μνήμη με χρήση της συνάρτησης cudamalloc(), πριν το τέλος της εφαρμογής, απαιτείται αποδέσμευση του χώρου με χρήση της συνάρτησης cudafree() Σταθερή Μνήμη (Constant Memory) Η σταθερή μνήμη είναι μια νοητή μνήμη, η φυσική θέση της οποίας βρίσκεται στον ίδιο χώρο με την καθολική μνήμη. Είναι προσπελάσιμη για εγγραφή και ανάγνωση από το κομμάτι του Host Code μέσω των συναρτήσεων cudamemcpytosymbol() και cudamemcpyfromsymbol() αντίστοιχα, ενώ διατίθεται μόνο για ανάγνωση σε όλα τα threads όλων των kernels. Μεταβλητές οι οποίες θέλουμε να τοποθετηθούν στην σταθερή Ε. Νικολόπουλος 24

25 μνήμη, ορίζονται στο καθολικό κομμάτι του Device Code (δηλ. εκτός του kernel) με χρήση του προθέματος constant. Αντίθετα με την καθολική μνήμη, μόνο ένα μικρό μέρος μπορεί να οριστεί για χρήση ως σταθερή μνήμη και αυτό ανέρχεται στα 64KB για όλες τις αρχιτεκτονικές. Η ταχύτητα προσπέλασής της είναι ίδια με αυτή της καθολικής μνήμης, δηλαδή αρκετά αργή, αλλά είναι cached. Ακριβώς επειδή είναι διαθέσιμη μόνο για ανάγνωση οι SMs μπορούν να αποθηκεύουν προσωρινά μέρος της τοπικά έτσι ώστε τα threads να έχουν γρήγορη πρόσβαση σε αυτή. Όμοια με τη καθολική μνήμη, η σταθερή μνήμη έχει διάρκεια ζωής, αυτής της εφαρμογής. Στη παρούσα εργασία δεν αξιοποιούμε την σταθερή μνήμη καθώς δεν υπάρχει τόσο μικρό κομμάτι σταθερών δεδομένων που να μπορούμε να αποθηκεύσουμε εκεί Τοπική Μνήμη (Local Memory) Η τοπική μνήμη βρίσκεται ουσιαστικά στην καθολική μνήμη, επομένως η ταχύτητα προσπέλασης της είναι πολύ μικρή. Σε αυτή θα τοποθετηθούν οι μεταβλητές που έχουμε ορίσει εντός του kernel και δεν χωράνε να τοποθετηθούν στον περιορισμένο χώρο των καταχωρητών. Η εμβέλεια και η διάρκεια ζωής τους είναι αυτή ίδια με των τοπικών μεταβλητών του thread. Δεν υπάρχει τρόπος να ορίσουμε συγκεκριμένες μεταβλητές να τοποθετηθούν εντός της τοπικής μνήμης. Αυτή είναι μια διαδικασία που θα την αναλάβει αυτόβουλα ο compiler για περιπτώσεις. Ο προγραμματιστής πρέπει να λάβει υπόψιν αυτή τη συμπεριφορά κατά τη διαδικασία υλοποίησης του kernel. Ε. Νικολόπουλος 25

26 4. ΕΠΕΞΕΡΓΑΣΙΑ ΓΡΑΦΟΥ Σε αυτό το κεφάλαιο θα παρουσιάσουμε συνοπτικά, μέσα από ένα παράδειγμα, το πλάνο εκτέλεσης ΓΠΓ σε κλασικό επεξεργαστή CPU. Με βάση αυτό θα συνεχίσουμε με την GPU υλοποίηση. 4.1 Επιθυμητό Αποτέλεσμα Για τον γράφο στο Σχήμα 1 το αποτέλεσμα της πρώτης φάσης, δηλαδή του join, είναι: 0: {5, 6, 7, 6, 7, 7, 3} 1: {6, 7} 2, 3, 4, 5, 6, 7: {} Δηλαδή, ο κόμβος 0 έχει εξερχόμενες ακμές προς τους κόμβους 5, 6, 7, 6, 7, 7 και 3, ο κόμβος 1 προς τους 6 και 7 ενώ οι υπόλοιποι κόμβοι δεν έχουν εξερχόμενες ακμές μετά τη πράξη της ένωσης (άρα δεν υπάρχουν ακμές με 2 βήματα για αυτούς τους κόμβους). Στο Σχήμα 9 (αριστερά) φαίνονται οι εξερχόμενες ακμές που προκύπτουν για τον κόμβο 0. Στη δεύτερη φάση, τη φάση του group by, προκύπτουν τα βάρη των ακμών: 0: {3:1, 5:1, 6:2, 7:3} 1: {6:1, 7:1} 2, 3, 4, 5, 6, 7: {} Δηλαδή, η ακμή (0, 5) έχει βάρος 1, η ακμή (0, 6) έχει βάρος 2 κοκ. Στο Σχήμα 9 (δεξιά) φαίνονται οι εξερχόμενες ακμές με τα βάρη που προκύπτουν για τον κόμβο 0. Τελικά το επιθυμητό αποτέλεσμα είναι: για κάθε κόμβο αφετηρίας, ένας πίνακας με ζεύγη αριθμών όπως ο Πίνακας 1. Ο πρώτος αριθμός υποδηλώνει τον κόμβο προορισμού και ο δεύτερος το βάρος της ακμής. Παρατηρούμε εύκολα ότι το μέγεθος του πίνακα αυτού είναι φραγμένο στο πλήθος των κόμβων. Πίνακας 1: Πίνακας αποτελεσμάτων για τον κόμβο 0. (3, 1) (5, 1) (6, 2) (7, 3) Σχήμα 9: Οι ακμές που προκύπτουν για τον κόμβο 0 μετά τη πράξη της ένωσης (αριστερά) και μετά τη πράξη της ομαδοποίησης, με τα βάρη τους (δεξιά). Ε. Νικολόπουλος 26

27 4.2 Βασικό Πλάνο Εκτέλεσης Στη παράγραφο αυτή θα περιγράψουμε τη διαδικασία υπολογισμού του ΓΠΓ με σειριακό τρόπο. Σε αυτή τη διαδικασία θα βασιστούμε στη συνέχεια για να περιγράψουμε τον αντίστοιχο αλγόριθμο για τη κάρτα γραφικών. Ας θεωρήσουμε και πάλι τον γράφο στο Σχήμα 1. Θέλουμε να βρούμε τους χρήστες που ακολουθούν, οι χρήστες που ακολουθεί ο χρήστης 0 και πόσα διαφορετικά μονοπάτια οδηγούν εκεί. Προκειμένου να επιταχυνθεί η διαδικασία θα κάνουμε τη πράξη της ομαδοποίησης ταυτόχρονα με τη πράξη της ένωσης με σταδιακό τρόπο (incrementally). Ορίζουμε έναν πίνακα ομαδοποίησης μεγέθους όσο και το πλήθος των κόμβων του γράφου (Πίνακας 2 αριστερά) και τον αρχικοποιούμε με 0 σε όλα τα κελιά. Εξερευνούμε κάθε εξερχόμενη ακμή του κόμβου 0 του γράφου μας και τις εξερχόμενες ακμές των κόμβων που καταλήγουν οι πρώτες. Έτσι αρχικά επισκεπτόμαστε τον κόμβο 1 μέσω της ακμής (0, 1) και από εκεί τον κόμβο 3 μέσω της ακμής (1, 3). Ο κόμβος 3 είναι ένας κόμβος που ανήκει στο αποτέλεσμα μας αφού τον συναντήσαμε στο δεύτερο βήμα, θα ενημερώσουμε τη θέση 3 του πίνακα εκτελώντας τη πράξη της ομαδοποίησης (μέτρηση) και άρα θα αυξήσουμε κατά 1 τη τιμή του κελιού. Συνεχίζουμε την ίδια διαδικασία για τις υπόλοιπες εξερχόμενες ακμές του κόμβου 0. Από την ακμή (0, 2) θα επισκεφτούμε τους κόμβους 5, 6 και 7. Από την ακμή (0, 3) τους κόμβους 6 και 7. Τέλος από την ακμή (0, 4) τον κόμβο 7. Τελικά ο πίνακας ομαδοποίησης θα φτάσει στη μορφή που βλέπουμε στο δεξί μέρος του Πίνακας 2. Πίνακας 2: Αρχική και τελική κατάσταση πίνακα ομαδοποίησης Στη φάση αυτή έχει υπολογιστεί το αποτέλεσμα της ομαδοποίησης και αρκεί μια προσπέλαση του πίνακα για να προκύψει το τελικό αποτέλεσμα στη μορφή που περιγράψαμε στη παράγραφο 4.1. Προσπελαύνουμε τον πίνακα, αγνοούμε τα κελιά που έχουν τιμή 0 (άρα δεν υπάρχει καμία ακμή από τον κόμβο αφετηρίας προς αυτόν τον κόμβο) ενώ όπου συναντάμε κάτι διαφορετικό το μεταφέρουμε στον πίνακα αποτελέσματος, μαζί με τη θέση του κελιού, καθώς η θέση αναφέρεται στον αναγνωριστικό αριθμό του εκάστοτε κόμβου. Τελικά προκύπτει το αποτέλεσμα όπως στον Πίνακας 1. Ένας τετριμμένος τρόπος παραλληλοποίησης του παραπάνω πλάνου είναι να θεωρήσουμε πολλούς αρχικούς ενεργούς κόμβους και να αναθέσουμε 1 κόμβο σε 1 νήμα, αυτό σημαίνει ότι θα χρειαστούμε πολλούς πίνακες ομαδοποίησης, έναν για κάθε νήμα. Άρα το επιπλέον κόστος σε μνήμη είναι O(N T) όπου Ν το πλήθος των κόμβων και Τ το πλήθος των νημάτων. Τέλος να αναφέρουμε ότι στη συγκεκριμένη προσέγγιση ένα πρόβλημα απόδοσης που συναντάμε είναι η προσπέλαση του πίνακα ομαδοποίησης όταν αυτός είναι αραιός. Όταν δηλαδή οι περισσότερες θέσεις είναι μηδενικές θα προτιμούσαμε να μην τις προσπελάσουμε καθόλου. Υπάρχουν τεχνικές για να αποφύγουμε τη προσπέλαση όλου του πίνακα οι οποίες ξεφεύγουν από το πλαίσιο της συγκεκριμένης εργασίας αλλά χρησιμοποιούνται στα τελικά πειράματα. Ε. Νικολόπουλος 27

28 4.3 Αποθήκευση Γράφου Compressed Sparse Row Ένας συνηθισμένος τρόπος αποθήκευσης ενός γράφου είναι η Compressed Sparse Row (CSR) μορφή. Στο Σχήμα 10 βλέπουμε τη CSR δομή του γράφου από το Σχήμα 1. Στον πίνακα Edges αποθηκεύουμε τους κόμβους προορισμού των ακμών ομαδοποιημένους ανά κόμβο αφετηρίας. Ενώ στον πίνακα Offsets αποθηκεύουμε τη θέση έναρξης των εξερχόμενων ακμών κάθε κόμβου. Έτσι αν θέλουμε να βρούμε τις εξερχόμενες ακμές του κόμβου 2 θα πάμε στη θέση 2 του πίνακα Offsets και θα δούμε την τιμή 5 που σημαίνει ότι οι εξερχόμενες ακμές του κόμβου 2 ξεκινάν στη θέση 5 του πίνακα Edges. Για να βρούμε που τελειώνουν οι εξερχόμενες ακμές του κόμβου 2 θα δούμε στο κελί 3 του πίνακα Offsets το σημείο που ξεκινάνε οι εξερχόμενες ακμές του κόμβου 3, δηλαδή το 8, και θα συμπεράνουμε ότι οι ακμές του κόμβου 2 τελειώνουν ακριβώς πριν, δηλαδή στη θέση 7. Τελικά θα βρούμε από τη θέση 5 έως και τη θέση 7 του πίνακα Edges, τις εξερχόμενες ακμές του κόμβου 2. Δηλαδή τις ακμές (2, 5), (2,6) και (2,7) όπως ακριβώς είναι και στο Σχήμα 1. Επιπλέον αν θέλαμε να αποθηκεύσουμε βάρη ή ταμπέλες (labels) στις ακμές θα μπορούσαμε να το κάνουμε στον πίνακα Edges μαζί με τον κόμβο προορισμού. Όπως βλέπουμε το CSR χρησιμοποιεί μόλις 4 bytes (1 ακέραιο) για κάθε ακμή, αφού αποθηκεύει μόνο τον κόμβο προορισμού και 4 bytes (1 ακέραιο) για κάθε κόμβο. Ο πίνακας Offsets περιέχει 1 επιπλέον στοιχείο, στη θέση 8 ενώ οι κόμβοι φτάνουν μέχρι το 7, ώστε να ξέρουμε που τελειώνουν οι ακμές του τελευταίου κόμβου. Σχήμα 10: Δομή Compressed Sparse Row (CSR) 4.4 Υλοποίηση GPU Θα περιγράψουμε τη διαδικασία υπολογισμού του ΓΠΓ στη κάρτα γραφικών. Θεωρούμε ότι ο γράφος χωράει να αποθηκευτεί ολόκληρος με τη CSR μορφή εντός της μνήμης της κάρτας γραφικών. Ο περιορισμός αυτός μας απαγορεύει να επεξεργαστούμε πολύ μεγάλους γράφους. Όπως αναφέραμε στο κεφάλαιο 3 οι κάρτες γραφικών είναι επεξεργαστές που προσφέρουν μαζική παραλληλία, για να τις αξιοποιήσει η εφαρμογή μας θα πρέπει να εκμεταλλεύεται χιλιάδες νήματα ταυτόχρονα. Η βασική προσέγγιση που κάναμε στη παράγραφο 4.2 απαιτεί O(N T) μνήμη όμως, επειδή στη GPU το πλήθος των νημάτων (Τ) είναι πολύ μεγάλο και η μνήμη περιορισμένη, η λύση αυτή δεν είναι εφικτή. Στη προσέγγιση που κάνουμε στη συνέχεια μεταφέρουμε τη παραλληλία εντός του ενεργού κόμβου. Έτσι έχουμε έναν ενεργό κόμβο κάθε στιγμή στη κάρτα γραφικών και κατ επέκταση έναν πίνακα ομαδοποίησης και πολλά νήματα που τον ενημερώνουν και παράγουν το τελικό αποτέλεσμα με τη μορφή που περιγράψαμε στη παράγραφο Πλάνο Εκτέλεσης σε GPU Προκειμένου να μεταφέρουμε τη παραλληλία εντός του ενεργού κόμβου, θα αναθέσουμε σε κάθε block από νήματα μια εξερχόμενη ακμή του κόμβου αφετηρίας και σε κάθε νήμα από μια εξερχόμενη ακμή του ενδιάμεσου κόμβου. Ενώ όλα μαζί τα νήματα θα ενημερώνουν τον πίνακα ομαδοποίησης. Θεωρούμε και πάλι τον γράφο στο Σχήμα 1 αποθηκευμένο στη μνήμη της κάρτας με τη CSR μορφή που βλέπουμε στο Σχήμα 10. Θεωρούμε ενεργό κόμβο τον 0, θέλουμε να βρούμε λοιπόν τους χρήστες που ακολουθούν οι χρήστες που ακολουθεί ο χρήστης 0 και μέσω πόσων διαφορετικών Ε. Νικολόπουλος 28

29 μονοπατιών. Επίσης ας θεωρήσουμε ότι έχουμε 4 blocks με 4 νήματα το καθένα, συνολικά 16 νήματα. Σε πρώτη φάση όλα τα νήματα κάθε block θα διαβάσουν το σημείο από το οποίο ξεκινούν οι εξερχόμενες ακμές του κόμβου 0 στον πίνακα των ακμών (Edges) και θα διαβάσει από μία εξερχόμενη ακμή του κόμβου κάθε block. Οπότε το block 0 διαβάζει την ακμή (0, 1), το block 1 την ακμή (0, 2), το block 2 την ακμή (0, 3) και το block 3 την ακμή (0, 4). Σχήμα 11: Ανάθεση blocks σε εξερχόμενες ακμές, κάθε χρώμα συμβολίζει ένα διαφορετικό block από νήματα. Στη συνέχεια κάθε block θα επιστρέψει στον πίνακα Offsets προκειμένου να αναγνωρίσει τις εξερχόμενες ακμές του κόμβου που έχει καταλήξει. Έτσι το block 1 που έχει αναλάβει την ακμή (0, 2) θα διαβάσει τη θέση 2 και τη θέση 3 του πίνακα offsets από το CSR για να βρει ότι οι εξερχόμενες ακμές του κόμβου 2 ξεκινούν στη θέση 5 του πίνακα Edges και είναι 3. Στη συνέχεια θα μείνουν ενεργά τα 3 από τα 4 νήματα του block 1 αφού ο κόμβος 2 έχει 3 εξερχόμενες ακμές, αυτά τα 3 νήματα θα διαβάσουν τις ακμές από τον αντίστοιχο πίνακα και θα ανακαλύψουν ότι καταλήγουν στου κόμβους 5, 6 και 7. Την ίδια διαδικασία ακολουθούν και τα υπόλοιπα blocks για διαφορετικούς κόμβους. Στο Σχήμα 11 βλέπουμε τις περιοχές του γράφου που έχει αναλάβει κάθε block. Κάθε χρώμα συμβολίζει και ένα διαφορετικό block, το block 1 που περιγράψαμε πριν είναι το μαύρο χρώμα. Ένα ακόμα παράδειγμα, το block 3 (κόκκινο) διαβάζει την εξερχόμενη ακμή (0, 4), βλέπει ότι ο κόμβος 4 έχει μια εξερχόμενη ακμή, αφήνει 1 νήμα ενεργό και αυτό το νήμα διαβάζει την εξερχόμενη ακμή (0, 7). Φυσικά αν τα blocks είναι λιγότερα από τις εξερχόμενες ακμές του αρχικού κόμβου ή τα νήματα λιγότερα από τις εξερχόμενες ακμές του ενδιάμεσου κόμβου τότε απλά συνεχίζουν επαναληπτικά τη παραπάνω διαδικασία. Όταν ένα νήμα ανακαλύπτει έναν κόμβο προορισμού προχωράει στην διαδικασία ενημέρωσης του πίνακα ομαδοποίησης. Γυρνώντας στο παράδειγμά μας όλα τα νήματα έχουν διαβάσει τους κόμβους προορισμού και μεταφέρονται στην αντίστοιχη θέση του πίνακα ομαδοποίησης, το νήμα του κίτρινου block πάει στη θέση 3, τα νήματα του μαύρου στις θέσεις 5, 6 και 7 κοκ. Σε αυτές τις θέσεις θα κάνουν μια πράξη ατομικής πρόσθεσης με το 1 ώστε να υπολογιστεί το αποτέλεσμα όπως φαίνεται στο Σχήμα 12. Η συνάρτηση ατομικής πρόσθεσης (atomicadd) υποστηρίζεται από τη CUDA, παίρνει ως είσοδο μια θέση μνήμης και έναν αριθμό, προσθέτει τον αριθμό στη τρέχουσα τιμή της θέσης μνήμης που δόθηκε και επιστρέφει τη παλιά τιμή της θέσης μνήμης. Επιπλέον δίνει την εγγύηση ότι αν πολλά νήματα προσπαθήσουν να εκτελέσουν μια πράξη ατομικής πρόσθεσης στην ίδια θέση μνήμης η πράξη θα εκτελεστεί σωστά, δεν θα παρουσιαστεί δηλαδή κάποιο race condition [6]. Σχήμα 12: Ενημέρωση του πίνακα ομαδοποίησης από πολλαπλά νήματα. Ε. Νικολόπουλος 29

30 Σε αυτό το σημείο έχουμε ενημερώσει πλήρως τον πίνακα ομαδοποίησης πρέπει όμως να μεταφέρουμε το αποτέλεσμα στον πίνακα εξόδου με την επιθυμητή μορφή. Μια προσέγγιση είναι να προσπελάσουμε, παράλληλα, 2 φορές τον πίνακα για να το πετύχουμε αυτό. Αρχικά χωρίζουμε τον πίνακα σε ίσα μέρη όσα και το πλήθος των νημάτων μας, κάθε νήμα διαβάζει το μέρος που του αντιστοιχεί και μετράει το πλήθος των μη μηδενικών κελιών που συναντάει. Δημιουργούμε έναν πίνακα μεγέθους όσο και το πλήθος των νημάτων όπου κάθε νήμα θα αποθηκεύσει το πόσα μη μηδενικά στοιχεία βρήκε. Στη συνέχεια υπολογίζουμε το prefix sum αυτού του πίνακα, δηλαδή σε κάθε θέση του πίνακα αποθηκεύουμε το άθροισμα όλων των προηγούμενων στοιχείων. Με αυτόν τον τρόπο έχουν οριστεί οι θέσεις στις οποίες μπορεί να γράψει το αποτέλεσμα που αντιστοιχεί σε κάθε νήμα. Δηλαδή ας υποθέσουμε ότι 4 νήματα είναι υπεύθυνα για τη μεταφορά του αποτελέσματος από τον πίνακα ομαδοποίησης στον πίνακα εξόδου. Και κάθε νήμα έχει ένα thread_id από 0 μέχρι 3. Τότε το νήμα 0 προκειμένου να διαβάσει αποδοτικά τον πίνακα ομαδοποίησης θα αναλάβει τα κελιά των οποίων το υπόλοιπο της ακέραιας διαίρεσης με το 4 είναι μηδέν, δηλαδή τα 0 και 4. Το νήμα 1 τα κελιά 1 και 5 κοκ. Στο Σχήμα 13 κάθε χρώμα αντιστοιχεί σε ένα νήμα, ο πίνακας (a) είναι ο πίνακας ομαδοποίησης, στον πίνακα (b) κάθε νήμα αθροίζει το πλήθος των μη μηδενικών τιμών του (a) που του αντιστοιχούν, το μπλε και το κίτρινο νήμα έχουν από 1 αποτέλεσμα ενώ το πράσινο 2. Στη συνέχεια υπολογίζεται το Prefix Sum, του πίνακα (b) στον πίνακα (c). Ο πίνακας (c) έχει τώρα τις τιμές που δείχνουν ποιες θέσεις του πίνακα εξόδου μπορεί να χρησιμοποιήσει κάθε νήμα. Η διαδικασία αυτή γίνεται για να μπορούν όλα τα νήματα να μεταφέρουν ταυτόχρονα το αποτέλεσμα χωρίς να χρειάζεται κάποιος συγχρονισμός μεταξύ τους. Στη συνέχεια τα νήματα διασχίζουν και πάλι τον πίνακα ομαδοποίησης αλλά αυτή τη φορά μεταφέρουν τα αποτελέσματα στον πίνακα εξόδου (d). Έτσι το κόκκινο νήμα που δεν έχει αποτέλεσμα δεν θα κάνει τίποτα, το μπλε θα γράψει το ένα του αποτέλεσμα ξεκινώντας από τη θέση 0 (άρα στη θέση 0), το κίτρινο θα ξεκινήσει από τη θέση 1 και τέλος το πράσινο από τη θέση 2 και θα γράψει τα 2 του αποτελέσματα στις θέσεις 2 και 3. Κατά τη μεταφορά τα νήματα θέτουν τα κελιά του πίνακα ομαδοποίησης σε 0 ώστε να εκτελεστεί η επόμενη επανάληψη. Σχήμα 13: Διαδικασία μεταφοράς του αποτελέσματος από τον πίνακα ομαδοποίησης (a) στον πίνακα εξόδου (d). Η παραπάνω διαδικασία εφαρμόζεται γενικά σε αντίστοιχα προβλήματα σε κάρτες γραφικών [7]. Στη δική μας περίπτωση δεν δουλεύει καλά στην πολύ συνηθισμένη περίπτωση όπου ο πίνακας ομαδοποίησης είναι σχετικά αραιός καθώς πρέπει να τον διατρέξουμε ολόκληρο και να προσπεράσουμε πολλά μηδενικά στοιχεία που δεν συνεισφέρουν στο αποτέλεσμα. Ε. Νικολόπουλος 30

31 Προτείνουμε μια διαφορετική προσέγγιση που εκμεταλλεύεται το γεγονός ότι η πράξη της ατομικής πρόσθεσης επιστρέφει τη προηγούμενη τιμή που είχε το αντίστοιχο κελί. Έτσι όταν κάποιο νήμα δει ότι αλλάζει τη τιμή του κελιού από μηδέν σε ένα αποθηκεύει στη κοινή μνήμη (shared memory) τη θέση του κελιού που άλλαξε, για να το κάνει αυτό αρκεί ένας δείκτης για κάθε block που είναι κοινός μεταξύ των νημάτων ενός block και δείχνει στην επόμενη διαθέσιμη θέση για εγγραφή αποτελέσματος. Αυτός ο δείχτης ενημερώνεται με ατομική πρόσθεση από κάθε νήμα που θέλει να γράψει ένα αποτέλεσμα στη κοινή μνήμη. Μόλις γεμίσει η κοινή μνήμη όλα τα νήματα του block συνεργάζονται ώστε να μεταφερθεί το αποτέλεσμα στον πίνακα εξόδου. Και εκεί υπάρχει ένας δείκτης που ενημερώνεται με ατομική πρόσθεση, αυτός όμως είναι κοινός για όλα τα blocks, άρα βρίσκεται στη κύρια μνήμη και είναι πιο αργό να τον προσπελάσουμε και να τον ενημερώσουμε, γι αυτό ελαχιστοποιούμε της ενημερώσεις του μέσω της χρήσης της κοινής μνήμης. Ουσιαστικά τον χρησιμοποιούμε μόνο όταν γεμίσει η κοινή μνήμη και εκεί απλά τον ενημερώνουμε μια φορά και κρατάμε τη παλιά τιμή του. Με αυτόν τον τρόπο μεταφέρουμε τους κόμβους οι οποίοι έχουν τουλάχιστον ένα αποτέλεσμα στον πίνακα εξόδου. Τους μεταφέρουμε όμως πριν ολοκληρωθεί η διαδικασία εξερεύνησης του γράφου άρα δεν έχουμε και τη τελική τιμή τους. Αρκεί όμως μια απλή προσπέλαση στον πίνακα εξόδου στο τέλος, όπου διαβάζουμε τους κόμβους προορισμού που έχουν γραφτεί εκεί (και άρα έχουν αποτέλεσμα) και παίρνουμε τη τελική τιμή τους από τον πίνακα ομαδοποίησης (τον οποίο το μηδενίζουμε για να εκτελεστεί η επόμενη επανάληψη). Σχήμα 14: Μεταφορά αποτελέσματος με χρήση της κοινής μνήμης. Στο Σχήμα 14 βλέπουμε τη διαδικασία που περιγράψαμε για το παράδειγμά μας. Ο πίνακας ομαδοποίησης ενημερώνεται από τα νήματα και κάθε νήμα που αλλάζει τη τιμή του κελιού από μηδέν σε ένα γράφει τη διεύθυνση του κελιού που άλλαξε στη κοινή μνήμη του block του. Οπότε το μοναδικό νήμα που ανήκει στο κίτρινο block άλλαξε τη τιμή του κελίου 3 από μηδέν σε ένα και έγραψε στη κοινή μνήμη του κίτρινου block το αναγνωριστικό του κόμβου (3). Για το κελί 6 φαίνεται ότι συναγωνίστηκαν τα νήματα από το μαύρο και το πράσινο block και απ ότι φαίνεται κατάφερε το νήμα του πράσινου block να αλλάξει τη τιμή από μηδέν σε ένα άρα αυτό θα γράψει στη κοινή του μνήμη το αναγνωριστικό του κόμβου (6). Στη συνέχεια (ή κατά τη διάρκεια της εκτέλεσης σε περίπτωση που γεμίσει η κοινή μνήμη κάποιου block) οι κόμβοι 3, 5, 6 και 7 μεταφέρονται στον πίνακα εξόδου και μένει μια απλή προσπέλαση σε αυτόν, μόλις ολοκληρωθεί η διαδικασία ενημέρωσης του πίνακα ομαδοποίησης, ώστε να πάρουμε τις τελικές τιμές από αυτόν και να τις μεταφέρουμε στον πίνακα εξόδου. Σε αντίθεση με τη προηγούμενη προσέγγιση, εδώ δεν διασχίζουμε ολόκληρο τον πίνακα ομαδοποίησης που έχει μέγεθος όσο και το πλήθος των κόμβων αλλά τον πίνακα αποτελέσματος ακριβώς για όσα αποτελέσματα έχει και πηγαίνουμε απ ευθείας στις αντίστοιχες θέσεις του πίνακα ομαδοποίησης γνωρίζοντας τις θέσεις στις οποίες περιμένουμε να βρούμε αποτελέσματα. Ε. Νικολόπουλος 31

32 4.4.2 Ακραίες περιπτώσεις υλοποίησης GPU Η τεχνική μου μόλις περιγράψαμε, όπως θα δούμε και στα πειράματα, είναι αρκετά καλή για τις περισσότερες περιπτώσεις αλλά υστερεί λίγο όταν τα αποτελέσματα είναι πολλά, όταν δηλαδή ο πίνακας ομαδοποίησης είναι πυκνός. Τότε ίσως αξίζει να εκτελέσουμε το πλάνο που περιγράψαμε στην αρχή της παραγράφου Σημαντικότερο όμως μειονέκτημα έχει όταν τα αποτελέσματα είναι εξαιρετικά λίγα. Αυτό πρακτικά συμβαίνει όταν ο κόμβος αφετηρίας και οι κόμβοι με τους οποίους συνδέεται έχουν λίγες εξερχόμενες ακμές. Στη περίπτωση αυτή πολλά νήματα και blocks της κάρτας γραφικών παραμένουν ανενεργά και άρα δεν την αξιοποιούμε πλήρως με αποτέλεσμα τη κακή απόδοση. Όμως είναι πολύ εύκολο και γρήγορο να υπολογίσουμε εξ αρχής το άνω όριο του πλήθους των αποτελεσμάτων που περιμένουμε. Αρκεί να αθροίσουμε το πλήθος των εξερχόμενων ακμών των γειτόνων του κόμβου αφετηρίας. Συνεπώς μπορούμε να αναγνωρίσουμε τους κόμβους με λίγα (ή αντίστοιχα πολλά) αποτελέσματα και να τους διαχειριστούμε διαφορετικά. Έχουμε περιγράψει στην αρχή της παραγράφου τη διαδικασία που θα ακολουθήσουμε όταν ο ενεργός κόμβος περιμένουμε να έχει πολλά αποτελέσματα. Τώρα θα δούμε τι κάνουμε για τους κόμβους με λίγα αποτελέσματα. Η λύση που προτείνουμε είναι αρκετά διαφορετική από τη προηγούμενη, καταρχήν δεν θα χρησιμοποιήσουμε πίνακα ομαδοποίησης μεγέθους όσο και οι κόμβοι του γράφου αλλά θα έχει μέγεθος όσο το πάνω όριο των αποτελεσμάτων που περιμένουμε (δηλαδή μικρό). Συνεπώς μπορούμε να εκτελέσουμε πολλούς ενεργούς κόμβους ταυτόχρονα, συγκεκριμένα θα αναθέσουμε έναν ενεργό κόμβο σε κάθε block και θα έχουμε ενεργούς κόμβους ίσους με το πλήθος των blocks μας. Το πρώτο μέρος του πλάνου εκτέλεσης είναι ίδιο με εκείνο των υπόλοιπων κόμβων με τη διαφορά ότι το αναλαμβάνει ένα μόνο block και δεν ενημερώνει των πίνακα ομαδοποίησης υπολογίζοντας το αποτέλεσμα σταδιακά. Αντίθετα, αποθηκεύει κάθε κόμβο που συναντάει ανεξάρτητα του αν είναι πρώτη φορά που τον συναντά ή όχι. Έτσι για τον γράφο από το Σχήμα 1 και με ενεργό κόμβο το 0 πάλι, προκύπτει ο πίνακας ομαδοποίησης που βλέπουμε στο Σχήμα 15. Παρατηρούμε ότι ο κόμβος 6 υπάρχει 2 φορές καθώς τον έχουμε επισκεφτεί μέσω του κόμβου 2 και 3, ο κόμβος 7 υπάρχει 3 φορές μέσω των κόμβων 2, 3 και 4 ενώ οι κόμβοι 3 και 5 από μία φορά. Προκειμένου να υπολογίσουμε το αποτέλεσμα αρκεί να ταξινομήσουμε τον πίνακα και να τον προσπελάσουμε μια φορά κρατώντας έναν αθροιστή για το πόσες φορές συναντάμε τον ίδιο αριθμό. Μια κλασική τεχνική υπολογισμού του Group By σε βάσεις δεδομένων. Σχήμα 15: Πίνακας ομαδοποίησης για κόμβους με λίγα αποτελέσματα Ταξινόμηση Μικρών Πινάκων στη GPU Σε αυτή τη παράγραφο θα περιγράψουμε τον αλγόριθμο ταξινόμησης που χρησιμοποιούμε για τους κόμβους με λίγα αποτελέσματα που περιγράψαμε παραπάνω. Οι ιδιαιτερότητες του προβλήματος μας είναι ότι οι πίνακες πρέπει να ταξινομηθούν εντός του block που έχουν παραχθεί και, όπως θα δούμε στα πειράματα, είναι μικροί μεν αλλά όχι αρκετά μικροί για να χωράνε στη κρυφή μνήμη ενός block όπως υποθέτουν στο [8]. Επίσης έχουν διαφορετικά μεγέθη, δηλαδή δεν είναι όλοι ίδιοι μεταξύ τους. Μια καθιερωμένη τεχνική για ταξινόμηση πολύ μικρών πινάκων σε κάρτες γραφικών είναι τα δίκτυα ταξινόμησης όπως το bitonic sorting network [9]. Το δίκτυο αυτό φαίνεται στο Σχήμα 16. Οι αριθμοί τοποθετούνται στο αριστερό μέρος μη ταξινομημένοι, ένας σε κάθε οριζόντια γραμμή και διασχίζουν το δίκτυο κάνοντας τις συγκρίσεις στα σημεία που υπάρχουν κάθετα βέλη, η φορά του βέλους δείχνει τη φορά της ταξινόμησης, στο τέλος Ε. Νικολόπουλος 32

33 οι αριθμοί βγαίνουν ταξινομημένοι. Το bitonic sort μας δίνει σταθερό αριθμό συγκρίσεων, συγκεκριμένες συγκρίσεις που πρέπει να γίνουν σε κάθε βήμα (πχ. Στο βήμα 1 το στοιχείο 0 με το 1, το 2 με το 3 κοκ..), έχει χαμηλή πολυπλοκότητα O(n log 2 (n)) και μπορεί να υλοποιηθεί παράλληλα και αποδοτικά. Αν έχουμε ικανό αριθμό από νήματα, δηλαδή όσοι και οι αριθμοί που θέλουμε να ταξινομήσουμε η παράλληλη πολυπλοκότητα (ή τα παράλληλα βήματα που θα εκτελεστούν) είναι O(log 2 (n)). Σχήμα 16: Bitonic sorting network για 8 στοιχεία. Τα μειονεκτήματα που συναντάμε είναι δύο. Καταρχήν, το πλήθος των αριθμών που θέλουμε να ταξινομήσουμε πρέπει να είναι δύναμη του 2, δηλαδή της μορφής n = 2 κ. Διαφορετικά πρέπει να προσθέσουμε κάποιο padding δηλαδή έξτρα αριθμούς, είτε μηδενικά είτε πολύ μεγάλους που θα μετακινηθούν στο τέλος του πίνακα και θα τους αγνοήσουμε. Χρειάζονται αποκλειστικά και μόνο για να γίνουν οι συγκρίσεις. Αυτό σε έναν πίνακα με 2100 στοιχεία σημαίνει ότι θα πρέπει να προσθέσουμε = 1996 στοιχεία padding, σχεδόν να διπλασιάσουμε την είσοδο μας δηλαδή. Το δεύτερο πρόβλημα είναι ότι το bitonic network δουλεύει πολύ αποδοτικά όταν όλα τα στοιχεία βρίσκονται στη κοινή μνήμη του block, αν δεν χωράνε όμως, στα τελευταία βήματα πρέπει να γίνουν συγκρίσεις μεταξύ στοιχείων που απέχουν πολύ στη μνήμη αυτό οδηγεί σε μη αποδοτική προσπέλαση της μνήμης. Για να ξεπεράσουμε τα παραπάνω προβλήματα προτείνουμε μια υβριδική προσέγγιση όπως και στo [7]. Θα χωρίσουμε τον πίνακα που θέλουμε να ταξινομήσουμε σε μικρότερα μέρη που να χωράνε στη κοινή μνήμη και να έχουν πλήθος στοιχείων την μορφής n = 2 κ έτσι αρκεί να προσθέσουμε padding μόνο για το τελευταίο μέρος το οποίο θα έχει όμως πολύ μικρότερο μέγεθος. Για παράδειγμα, αν η κοινή μνήμη χωράει 512 στοιχεία, τον πίνακα με τα 2100 στοιχεία που αναφέραμε προηγουμένως θα τον χωρίσουμε σε 5 μέρη. Τα 4 πρώτα θα έχουν 512 στοιχεία ενώ το τελευταίο = 52 και θα αρκεί να προσθέσουμε 12 στοιχεία για να φτάσουμε τα 64 που είναι η επόμενη δύναμη του 2. Θα ταξινομήσουμε αυτά τα μέρη με τη μέθοδο του bitonic network που περιγράψαμε παραπάνω όπως και στο [7]. Στη συνέχεια αρκεί να συγχωνεύσουμε τους ταξινομημένους πίνακες. Θα το κάνουμε με δεντρικό τρόπο ανα 2 όπως φαίνεται στο Σχήμα 17. Σχήμα 17: Δομή υβριδικής ταξινόμησης. Λόγω της φύσης του προβλήματος μας τα κομμάτια που καλούμαστε να συγχωνεύσουμε είναι λίγα, το πολύ χρειάζονται 3 επίπεδα συγχώνευσης. Σε μια σειριακή υλοποίηση η διαδικασία συγχώνευσης 2 ταξινομημένων πινάκων σε έναν νέο επίσης ταξινομημένο είναι πολύ απλή και έχει γραμμική πολυπλοκότητα. Ορίζουμε ένα νέο πίνακα με μέγεθος Ε. Νικολόπουλος 33

34 όσο το άθροισμα των 2 που θέλουμε να συγχωνεύσουμε, ξεκινώντας από την αρχή κάθε πίνακα συγκρίνουμε τα στοιχεία τους και επιλέγουμε κάθε φορά το μικρότερο για να το τοποθετήσουμε στον πίνακα αποτελέσματος. Η διαδικασία αυτή είναι από τη φύση της σειριακή, στη κάρτα γραφικών κάτι τέτοιο δεν είναι αποδεκτό. Πρέπει πάντα να εκμεταλλευόμαστε τη παραλληλία διαφορετικά η απόδοση θα είναι πολύ κακή. Το μονοπάτι συγχώνευσης [10] [11] μας επιτρέπει να εκτελέσουμε με παράλληλο τρόπο τη συγχώνευση δύο πινάκων. Ας θεωρήσουμε τους ταξινομημένους πίνακες A και Β με μεγέθη Ν και Μ αντίστοιχα, τοποθετούμε τον έναν οριζόντια και τον άλλο κάθετα όπως φαίνεται στο Σχήμα 18. Σχήμα 18: Μονοπάτι συγχώνευσης Στον πίνακα δύο διαστάσεων που δημιουργείτε ανάμεσά τους εφαρμόζουμε για κάθε κελί [i, j] συνάρτηση που παίρνει τη τιμή 1 όταν Β[i] > A[j] και 0 διαφορετικά. Παρατηρούμε ότι μεταξύ των κελιών με τιμή 1 και των κελιών με τιμή 0 έχουμε ένα σύνορο (κίτρινη γραμμή) που αναγκαστικά θα ξεκινάει από το κελί [0,0] και θα καταλήγει στο [Ν, Μ]. Αν φέρουμε διαγώνιο με κλίση 45 μοιρών (μπλε γραμμή) και από το σημείο που αυτή τέμνει το σύνορο φέρουμε οριζόντια και κάθετο θα χωρίσουμε τους αρχικούς πίνακες Α και Β σε 2 μέρη Α1, Α2 και Β1, Β2. Η διαγώνιος που φέραμε δεν είναι τυχαία, ξεκινάει μεταξύ όγδοου και ένατου κελιού του πίνακα Α, γι αυτό από όλα τα σημεία της που βρίσκονται μεταξύ κελιών αν φέρουμε οριζόντια και κάθετη τότε πάντα η ένωση των πινάκων που βρίσκονται πάνω από αυτή θα έχει μέγεθος 8. Αν παίρναμε τη πρώτη τομή τότε το Α1 θα είχε 8 στοιχεία και το Β1 κανένα, αν παίρναμε τη δεύτερη τότε θα είχε το Α1 7 και το Β1 1, την επόμενη 6 και 2 κοκ. Επιπλέον, επειδή διαλέξαμε το μοναδικό σημείο που ανήκει και στο σύνορο, το (Α 1 Β 1 ) θα έχει και την ιδιότητα ότι κάθε στοιχείο του θα είναι μικρότερο ή ίσο με τα στοιχεία του (Α 2 Β 2 ). Αυτό συμβαίνει για τον εξής λόγο, το μονοπάτι συγχώνευσης συμβολίζει τη διαδρομή που θα ακολουθούσαμε αν επιλέγαμε από τον κάθε πίνακα το μικρότερο στοιχείο κάθε φορά, όπως σε μια κλασική συγχώνευση ταξινομημένων πινάκων. Κάθε στιγμή όμως μιας τέτοιας συγχώνευσης τα στοιχεία που έχουμε μεταφέρει στον πίνακα εξόδου είναι μικρότερα ή ίσα από τα στοιχεία που έχουν απομείνει στον πίνακα. Τελικά διαλέγουμε το σημείο της διαγώνιου που τέμνει το σύνορο για να έχουμε και τις δύο παραπάνω ιδιότητες, δηλαδή να ορίζουμε εμείς το μέγεθος του (Α 1 Β 1 ) και επιπλέον όλα τα στοιχεία του να είναι μικρότερα ή ίσα από εκείνα του (Α 2 Β 2 ). Είναι προφανές ότι γνωρίζουμε και το μέγεθος της δεύτερης ένωσης ως διαφορά της πρώτης με το μέγεθος του (Α Β). Αυτό τελικά σημαίνει ότι μπορούμε να συγχωνεύσουμε Ε. Νικολόπουλος 34

35 παράλληλα τα (Α 1 Β 1 ) και (Α 2 Β 2 ) και να τα τοποθετήσουμε το ένα μετά το άλλο γνωρίζοντας εκ των προτέρων τις θέσεις που θα καταλάβει κάθε ένωση. Σχήμα 19: Παράδειγμα χρήσης μονοπατιού συγχώνευσης με 4 νήματα. Στο Σχήμα 19 βλέπουμε πως χρησιμοποιούμε το μονοπάτι συγχώνευσης για να συγχωνεύσουμε παράλληλα τους 2 πίνακες με χρήση 4 νημάτων. Καταρχήν υπολογίζουμε το μέγεθος της αναμενόμενης εξόδου Α Β = Α + Β = = 17 στοιχεία. Θέλουμε να ισομοιράσουμε κατά το δυνατόν τη δουλειά στα νήματα οπότε το πρώτο θα πάρει 5 στοιχεία και τα υπόλοιπα 3 νήματα από 4. Άρα θα φέρουμε 3 διαγώνιους, η πρώτη θα ξεκινάει μετά το 5 ο κελί του Α, η δεύτερη μετά το 9 ο (5+4) και για τη τρίτη θα μεταφερθούμε άλλες 4 θέσεις προς τα κάτω. Στα σημεία που οι διαγώνιοι μας τέμνουν το σύνορο θα φέρουμε οριζόντιες και κάθετους για να προκύψουν τα μέρη που βλέπουμε με τους χρωματισμούς. Κάθε χρώμα αντιστοιχεί στα τμήματα που έχει να συγχωνεύσει κάθε νήμα και τις θέσεις στις οποίες πρέπει να γράψει το αποτέλεσμα της συγχώνευσης. Έτσι η διαδικασία γίνεται πλήρως παράλληλα. Στη πραγματικότητα δεν χρειάζεται να κατασκευάσουμε τον πίνακα με τα 0/1, αρκεί να κάνουμε μια δυαδική αναζήτηση στις διαγώνιους που μας ενδιαφέρουν. Κοιτάμε τα «κελιά» γύρω από το σημείο που βρισκόμαστε και συγκεκριμένα το πάνω δεξιά και το κάτω αριστερά κελί, αν βρούμε 0 και 0 κινούμαστε προς τα κάτω και αριστερά, αν βρούμε 1 και 1 προς τα πάνω και δεξιά, αλλιώς, αν βρούμε 0 και 1, έχουμε βρει σημείο τομής με το μονοπάτι συγχώνευσης. Επίσης κάθε νήμα θα αναλάβει από μια διαγώνιο (εκτός από ένα νήμα που δεν θα έχει δουλειά σε αυτή τη φάση) και σε λογαριθμικό αριθμό από βήματα θα βρει το σημείο τομής. Στη συνέχεια με γραμμική πολυπλοκότητα θα συγχωνεύσει τους πίνακες οπότε έχουμε Ο(T logν) δουλεία συνολικά, όπου Τ το πλήθος των νημάτων και Ν το μέγεθος του μεγαλύτερου από τους αρχικούς πίνακες, και Ο(logN) παράλληλα βήματα για τη φάση της διαμέρισης. Και Ο(Μ + Ν), με Μ και Ν τα μεγέθη των πινάκων, συνολική δουλειά για τη φάση της συγχώνευσης ενώ χρειάζονται Ο( (Μ+Ν) ) παράλληλα βήματα. Τ Ε. Νικολόπουλος 35