ΟΛΟΚΛΗΡΩΜΕΝΑ ΣΥΣΤΗΜΑΤΑ ΥΛΙΚΟΥ ΛΟΓΙΣΜΙΚΟΥ ΤΜΗΜΑ ΜΗΧΑΝΙΚΩΝ ΗΛΕΚΤΡΟΝΙΚΩΝ ΥΠΟΛΟΓΙΣΤΩΝ ΚΑΙ ΠΛΗΡΟΦΟΡΙΚΗΣ ΠΑΝΕΠΙΣΤΗΜΙΟ ΠΑΤΡΩΝ ΔΙΠΛΩΜΑΤΙΚΗ ΕΡΓΑΣΙΑ

Transcript

1 ΟΛΟΚΛΗΡΩΜΕΝΑ ΣΥΣΤΗΜΑΤΑ ΥΛΙΚΟΥ ΛΟΓΙΣΜΙΚΟΥ ΤΜΗΜΑ ΜΗΧΑΝΙΚΩΝ ΗΛΕΚΤΡΟΝΙΚΩΝ ΥΠΟΛΟΓΙΣΤΩΝ ΚΑΙ ΠΛΗΡΟΦΟΡΙΚΗΣ ΠΑΝΕΠΙΣΤΗΜΙΟ ΠΑΤΡΩΝ ΔΙΠΛΩΜΑΤΙΚΗ ΕΡΓΑΣΙΑ Παραλληλοποίηση αλγορίθμου Aho-Corasick με τεχνολογία CUDA ΔΗΜΟΠΟΥΛΟΣ ΠΑΝΑΓΙΩΤΗΣ Α.Μ. : 122 Υπεύθυνος Καθηγητής: Σερπάνος Δημήτριος ΠΑΤΡΑ 2012

2 ΠΡΟΛΟΓΟΣ Στα πλαίσια του μεταπτυχιακού 'Ολοκληρωμένα Συστήματα Υλικού και Λογισμικού οι διπλωματικές εργασίες λαμβάνουν υπόψη τους τον γενικότερο στόχο και αντικείμενο του μεταπτυχιακού ο οποίος είναι η ειδίκευση των μεταπτυχιακών σε θέματα σχεδιασμού και υλοποίησης Υλικού αλλά και σχεδιασμού του Λογισμικού ώστε να εκμεταλλεύεται στο μέγιστο δυνατό την αρχιτεκτονική του Υλικού στην οποία εκτελείται. Έτσι στην παρούσα διπλωματική εκπονείται μία μελέτη για την απόδοση των αλγορίθμων αναζήτησης μοτίβων όταν αυτοί τροποποιηθούν κατάλληλα ώστε να εκμεταλλεύονται την αρχιτεκτονική του Υλικού των καρτών γραφικών. Για τον σκοπό αυτό στην παρούσα διπλωματική παρουσιάζεται στην αρχή το πρόβλημα της αναζήτησης ώστε να γίνει κατανοητό γιατί είναι επιτακτική η ανάγκη βελτιστοποίησης της απόδοσης των υπαρχόντων αλγορίθμων. Επίσης παρουσιάζονται οι κυριότεροι αλγόριθμοι αναζήτησης μοτίβων που χρησιμοποιούνται σήμερα και εξηγείται γιατί επιλέγεται ένας από αυτούς τους αλγόριθμους που στην συνέχεια θα τροποποιηθεί ώστε να εκμεταλλεύεται την ιδιαίτερη αρχιτεκτονική μιας κάρτας γραφικών. Έπειτα εξάγονται συμπεράσματα για την απόδοση που μας προσφέρει αυτή η νέα υλοποίηση του αλγορίθμου σε λογισμικό σε σχέση με την απλή υλοποίηση του αλγορίθμου και για διαφορετικά μεγέθη εισόδων.

3 ΠΕΡΙΕΧΟΜΕΝΑ 1 ΕΙΣΑΓΩΓΗ Αναζήτηση μοτίβων Παράλληλη Επεξεργασία με χρήση GP-GPU Στόχος Παρούσας Διπλωματικής ΤΟ ΠΡΟΒΛΗΜΑ ΤΗΣ ΑΝΑΖΗΤΗΣΗΣ Αλγόριθμοι αναζήτησης μονού-μοτίβου Απλός αλγόριθμος αναζήτησης Knuth-Morris-Pratt Karp-Rabin Boyer-Moore Αλγόριθμοι αναζήτησης πολλαπλού-μοτίβου Karp-Rabin πολλαπλού-μοτίβου Wu-Manber Commentz-Walter Aho-Corasick CUDA Αρχιτεκτονική Προγραμματιστικό Μοντέλο Επεκτάσεις της γλώσσας προγραμματισμού C για την CUDA Βελτιστοποίηση απόδοσης Πλεονεκτήματα και μειονεκτήματα της CUDA ΠΑΡΑΛΛΗΛΟΠΟΙΗΣΗ ΑΛΓΟΡΙΘΜΟΥ AHO-CORASICK Εύρεση παραλληλίας Παρουσίαση παράλληλου κώδικα Επιλογή παραμέτρων εκτέλεσης και βελτιστοποιήσεις στον κώδικα ΜΕΤΡΗΣΕΙΣ ΣΥΓΚΡΙΣΕΙΣ Χαρακτηριστικά υπολογιστικού συστήματος μετρήσεων Κεντρική Μονάδα Επεξεργασίας (CPU) Κάρτα γραφικών (GPU) Αποτελέσματα μετρήσεων Αποτελέσματα κλασικού αλγόριθμου Aho-Corasick... 64

4 5.2.2 Αποτελέσματα παράλληλου αλγόριθμου Aho-Corasick Σύγκριση αποτελεσμάτων ΣΥΜΠΕΡΑΣΜΑΤΑ ΜΕΛΛΟΝΤΙΚΕΣ ΚΑΤΕΥΘΥΝΣΕΙΣ ΒΙΒΛΙΟΓΡΑΦΙΑ... 74

5 1 ΕΙΣΑΓΩΓΗ 1.1 Αναζήτηση μοτίβων Ο όρος αναζήτηση μοτίβων αναφέρεται στο πρόβλημα του να βρεθεί μια ακολουθία από χαρακτήρες (string) που ονομάζεται μοτίβο (pattern) μέσα σε μια μεγαλύτερη ακολουθία από χαρακτήρες ή ένα κείμενο. Επίσης μέσα σε ένα κείμενο μπορεί να γίνεται αναζήτηση και για περισσότερα του ενός μοτίβου. Ένας πιο επίσημος ορισμός για την αναζήτηση μοτίβων είναι ο εξής: 'Έστω Σ ένα αλφάβητο (πεπερασμένο σύνολο) τότε βρες μέσα σε ένα σύνολο χαρακτήρων Κ που αποτελείται από στοιχεία του Σ ένα άλλο σύνολο χαρακτήρων Π που και αυτό αποτελείται από στοιχεία του Σ αλλά με μέγεθος μικρότερο ή ίσο του συνόλου Κ. Για το πώς λοιπόν θα επιτευχθεί η αναζήτηση μοτίβων έχουν αναπτυχθεί πάρα πολύ αλγόριθμοι και με διαφορετικές πολυπλοκότητες. Οι αλγόριθμοι αυτοί μπορούν να ταξινομηθούν με διάφορους τρόπους όπως φαίνεται αμέσως παρακάτω. Αλγόριθμοι για αναζήτηση μοτίβων Οι αλγόριθμοι για αναζήτηση μοτίβων μπορούν να ταξινομηθούν με βάση το πόσα μοτίβα μπορούν να ψάχνουν ταυτοχρόνως μέσα στο κείμενο. Έτσι λοιπόν υπάρχουν δύο κατηγορίες. Αλγόριθμοι ενός μοτίβου : Οι αλγόριθμοι αυτοί μπορούν και ψάχνουν μόνο για ένα μοτίβο μέσα στο κείμενο κάθε φορά. Αλγόριθμοι πεπερασμένου συνόλου από μοτίβα : Οι αλγόριθμοι αυτοί μπορούν και ψάχνουν μέσα στο κείμενο για περισσότερα από ένα μοτίβα κάθε φορά. Μια άλλη κατηγοριοποίηση είναι ανάλογα με το αν πριν την εφαρμογή του αλγορίθμου γίνετε κάποια προεργασία (preprocessing) στο μοτίβο ή στο κείμενο όπως φαίνεται στον Πίνακα 1. Κείμενο χωρίς προεργασία Κείμενο με προεργασία Μοτίβο χωρίς προεργασία Στοιχειώδεις Αλγόριθμοι Μέθοδοι Ευρετηρίου Μοτίβο με προεργασία Μηχανές Δομημένης Εύρεσης Μέθοδοι Υπογραφής Πίνακας 1: Ταξινόμηση Αλγορίθμων 'Έστω ότι m είναι το μέγεθος του μοτίβου και n είναι το μέγεθος του κειμένου μέσα στο οποίο ψάχνουμε το pattern. Οι πολυπλοκότητες μερικών γνωστών αλγορίθμων φαίνονται στον Πίνακα 2. 5

6 Αλγόριθμοι Χρόνος Προεργασίας Χρόνος Εύρεσης Απλός 0 (δεν έχει) O(nm) Rabin-Karp O(m) Μέσος O(n+m), Χειρότερος O(nm) Μηχανή Πεπερασμένου Αυτόματου O(m Σ ) O(n) Knuth-Morris-Pratt O(m) O(m+n) Boyer-Moore O(m + Σ ) Καλύτερος O(n/m), Χειρότερος O(mn) Bitap algorithm (shift-or, shift-and) O(m + Σ ) O(mn) Πίνακας 2: Πολυπλοκότητες Αλγορίθμων String Matching Εφαρμογή της αναζήτησης μοτίβων στην ασφάλεια Η αναζήτηση μοτίβων έχει ένα ευρύ πεδίο εφαρμογών, σχεδόν κάθε εφαρμογή στον υπολογιστή το χρησιμοποιεί, από τις βάσεις δεδομένων μέχρι τους απλούς κειμενογράφους. Μια σημαντική λοιπόν εφαρμογή της αναζήτησης μοτίβων, που αποτέλεσε και έναυσμα γι αυτή τη διπλωματική, είναι στην ασφάλεια των υπολογιστικών συστημάτων. Τα προγράμματα αντιμετώπισης ιών (antivirus) για να αναγνωρίσουν αν ένα πρόγραμμα είναι ιός συγκρίνουν το πρόγραμμα με μια βάση που περιέχει υπογραφές χρησιμοποιώντας κάποιον αλγόριθμο για αναζήτηση μοτίβων. Στα σύγχρονα υπολογιστικά συστήματα η Κεντρική Μονάδα Επεξεργασίας είναι αρκετά ισχυρή ώστε να εκτελεί σε πραγματικό χρόνο ένα πρόγραμμα αντιμετώπισης ιών (το οποίο τρέχει ένα αλγόριθμο για αναζήτηση μοτίβων) και παρόλα αυτά το λειτουργικό σύστημα να ανταποκρίνεται χωρίς καθυστερήσεις ή να εκτελεί μαζί με το πρόγραμμα αντιμετώπισης ιών και άλλα προγράμματα χωρίς προβλήματα. Υπάρχουν όμως και υπολογιστικά συστήματα ειδικού σκοπού τα οποία δεν έχουν τόσο δυνατή Κεντρική Μονάδα Επεξεργασίας ώστε να μπορούν να εκτελούν και προγράμματα αντιμετώπισης ιών μαζί με το πρόγραμμα που επιτελεί την λειτουργία του ειδικού σκοπού. Ένα τέτοιο παράδειγμα είναι τα υπολογιστικά συστήματα ειδικού σκοπού που κάνουν δρομολόγηση πακέτων του Διαδικτύου (routers). Έτσι λοιπόν αν υπήρχε τρόπος να εκτελείται σε πραγματικό χρόνο και ένα πρόγραμμα αντιμετώπισης ιών σε αυτά τα συστήματα ειδικού σκοπού, χωρίς να χρειάζεται να εγκαταστήσουμε σε αυτά γρηγορότερες και άρα ακριβότερες Κεντρικές Μονάδες Επεξεργασίας, τα οφέλη θα ήταν πάρα πολλά. Για παράδειγμα αν οι δρομολογητές (routers) είχαν την δυνατότητα να σκανάρουν σε πραγματικό χρόνο τα πακέτα που δρομολογούν για ιούς και κακόβουλο λογισμικό θα μπορούσαν να αποτρέψουν την διάδοση των ιών μέσω του Διαδικτύου και να αποτρέψουν κακόβουλες επιθέσεις. Μια προσέγγιση του πώς μπορεί να γίνει αυτό παρουσιάζεται παρακάτω. Απόδοση των αλγόριθμων της αναζήτησης μοτίβων Όταν λοιπόν μέσα σε ένα μεγάλο κείμενο είναι απαραίτητο να βρεθούν σε πολύ μικρό χρονικό διάστημα κάποια μοτίβα όπως προαναφέρθηκε παραπάνω στην περίπτωση που σκανάρονται σε πραγματικό χρόνο 6

7 τα πακέτα που λαμβάνει ένας δρομολογητής για υπογραφές ιών, θα πρέπει να υπάρχει διαθέσιμο κατάλληλο υλικό (hardware) ώστε σε συνδυασμό με έναν αλγόριθμο αναζήτησης να παράγει τα επιθυμητά αποτελέσματα στο πολύ μικρό αυτό χρονικό διάστημα. Για να τηρηθεί λοιπόν αυτό το χρονικό περιθώριο που υπάρχει θα πρέπει ή να χρησιμοποιηθεί καλύτερο υλικό ή καλύτεροι αλγόριθμοι αναζήτησης. Όσον αφορά την ταχύτητα των αλγορίθμων όπως φαίνεται και από τον Πίνακα 2 υπάρχουν αλγόριθμοι που είναι βέλτιστοι σε σχέση με το μέγεθος της εισόδου, οπότε αναγκαστικά για να τηρηθούν τα χρονικά περιθώρια που υπάρχουν θα πρέπει να βελτιστοποιηθεί το υλικό. Ο πιο προσφιλής τρόπος βελτίωσης της απόδοσης του υλικού είναι η αύξηση της συχνότητας λειτουργίας του. Ωστόσο εκτός από την αύξηση της συχνότητας λειτουργίας ένας άλλος τρόπος βελτίωσης της απόδοσης του υλικού είναι η αύξηση των επεξεργαστικών μονάδων του έτσι ώστε να εκτελείται ο αλγόριθμος σε πολλαπλές επεξεργαστικές μονάδες ταυτοχρόνως. Συγκεκριμένα για το πρόβλημα της αναζήτησης οι επεξεργαστικές μονάδες δεν χρειάζεται να είναι πολύπλοκες αλλά να μπορούν να εκτελούν την βασική πράξη της σύγκρισης σε διαφορετικά δεδομένα ταυτόχρονα (Single Instruction Multiple Data SIMD). Με αυτό τον τρόπο μπορούν να σκανάρονται ταυτοχρόνως πολλά πακέτα μαζί για ιούς σε κάθε επεξεργαστική μονάδα. Οι σύγχρονοι Κεντρικοί Επεξεργαστές (CPU) σήμερα προσφέρουν μέχρι και 4 επεξεργαστικούς πυρήνες άρα δεν προσφέρουν μεγάλη επιτάχυνση, όμως οι κάρτες γραφικών διαθέτουν πολύ περισσότερους επεξεργαστικούς πυρήνες οι οποίοι μπορούν να χρησιμοποιηθούν για γενικού σκοπού πράξεις (General Purpose Computing) όπως παρουσιάζεται στο επόμενο Κεφάλαιο Παράλληλη Επεξεργασία με χρήση GP-GPU Οι Μονάδες Επεξεργασίας Γραφικών (GPUs) είναι ειδικοί επεξεργαστές οι οποίοι αναλαμβάνουν την δημιουργία των τρισδιάστατων γραφικών απελευθερώνοντας έτσι την Κεντρική Μονάδα Επεξεργασίας (CPU) από αυτή την επίπονη επεξεργαστικά διαδικασία. Οι GPUs χρησιμοποιούνται σε ενσωματωμένα συστήματα (embedded systems), κινητά τηλέφωνα, προσωπικούς υπολογιστές, σταθμούς εργασίας και κονσόλες παιχνιδιών. Οι σύγχρονες GPUs χρησιμοποιούν αρχιτεκτονικές δομές μεγάλης παραλληλίας με πολλές επεξεργαστικές μονάδες εξειδικευμένες στην δημιουργία τρισδιάστατων γραφικών. Οι GPUs μπορεί να ενσωματωμένες σε ένα ολοκληρωμένο κύκλωμα ή ξεχωριστές επεξεργαστικές κάρτες που συνδέονται με την μητρική κάρτα (motherboard) μέσω θυρών επέκτασης (expansion slots) όπως PCIe και AGP. Οι ξεχωριστές επεξεργαστικές κάρτες (dedicated GPUs) έχουν ενσωματωμένη μνήμη RAM που την χρησιμοποιούν αποκλειστικά για τις δικές τους επεξεργαστικές λειτουργίες σε αντίθεση με τις ενσωματωμένες GPUs οι οποίες χρησιμοποιούν την μνήμη RAM του συστήματος. Οι ενσωματωμένες GPUs έχουν συνήθως μικρότερη επεξεργαστική ισχύ σε σχέση με τις ξεχωριστές κάρτες (dedicated video cards). Στην αρχή οι GPUs χρησιμοποιούνταν μόνο για την επιτάχυνση των λειτουργιών του texture mapping και polygon rendering. Στην συνέχεια προστέθηκαν και λειτουργίες για γεωμετρικούς υπολογισμούς όπως η περιστροφή (rotation) και η αλλαγή συστήματος συντεταγμένων. Οι τελευταίες εξελίξεις στις GPUs πρόσθεσαν προγραμματιζόμενους shaders οι οποίοι επιτρέπουν πλέον στις GPUs να εκτελούν περίπλοκους υπολογισμούς με πίνακες και διανύσματα όπως αυτοί που χρειάζονται σε λειτουργίες υπέρ- 7

8 δειγματοληψίας (oversampling), interpolation, anti-aliasing, υψηλής ακρίβειας χρωματικούς χάρτες και αποκωδικοποίηση βίντεο υψηλής ευκρίνειας (high-definition video decode). Τα τελευταία χρόνια ωστόσο μια νέα ιδέα για την χρήση των GPUs άρχισε να κερδίζει έδαφος: η χρησιμοποίηση των παράλληλων μονάδων επεξεργασίας για πράξεις γενικού σκοπού (General Purpose- Graphic Processing Units). Ο στόχος αυτής της ιδέας ήταν να εκμεταλλευτεί την τεράστια υπολογιστική δύναμη των πολλαπλών επεξεργαστικών πυρήνων των GPUs για να εκτελούνται πολύ πιο γρήγορα εφαρμογές που είναι απαιτητικές σε επεξεργαστική ισχύ όπως π.χ. υπολογιστική βιολογία (αποκωδικοποίηση DNA), κρυπτογραφία, κτλ. Οι GPUs ωστόσο δεν μπορούν αυτή την στιγμή να αντικαταστήσουν την Κεντρική Μονάδα Επεξεργασίας αλλά να βοηθήσουν επικουρικά το έργο της εκτελώντας ταυτοχρόνως μία εντολή σε διαφορετικά δεδομένα (SIMD). Έτσι προβλήματα που περιέχουν παραλληλία στα δεδομένα (μοντέλο SIMD), όπως είναι το string matching, έχουν μια μεγάλη αύξηση στην απόδοση όταν εκτελούνται σε κάρτες γραφικών. Στην Εικόνα 1.1 εικόνα φαίνονται οι επεξεργαστικές μονάδες και η αρχιτεκτονική των GP-GPUs. Εικόνα 1.1: Αρχιτεκτονική GP-GPUs Τελευταία η Nvidia δημοσίευσε μια Προγραμματιστική Διεπαφή Εφαρμογών (API) που είναι μια επέκταση της γλώσσας προγραμματισμού C και επιτρέπει συγκεκριμένες λειτουργίες από ένα πρόγραμμα C που απαιτούν μεγάλη επεξεργαστική ισχύ να εκτελούνται στην GPU. Αυτή την διεπαφή την ονόμασε CUDA (Compute Unified Device Architecture). Ωστόσο εκτός από αυτήν την διεπαφή της Nvidia πρόσφατα δημιουργήθηκε και μία άλλη διεπαφή η οποία ονομάζεται OpenCL (Open Computing Language) και υποστηρίζει ετερογενή συστήματα επεξεργασίας CPUs, GPUs και άλλα επεξεργαστικά συστήματα. Το OpenCL είναι ένα ανοιχτό βιομηχανικό πρότυπο που υποστηρίζεται από ένα consortium που ονομάζεται Khronos Group και αποτελείται από τις μεγαλύτερες εταιρίες του χώρου όπως Apple, IBM, Nvidia, AMD, Intel. 8

9 1.3 Στόχος Παρούσας Διπλωματικής Σε αυτή την διπλωματική θα γίνει προσπάθεια βελτίωσης του χρόνου εκτέλεσης κάποιου κατάλληλου αλγόριθμου από τους αλγόριθμους που παρουσιάζονται στο Κεφάλαιο 2 μετατρέποντας τον έτσι ώστε να εκτελείται παράλληλα στην κάρτα γραφικών (GP-GPU) αντί στην Κεντρική Μονάδα Επεξεργασίας (CPU). Ο λόγος που η παρούσα διπλωματική εστιάζει στους αλγόριθμους αναζήτησης είναι επειδή αυτοί έχουν ένα ευρύ πεδίο εφαρμογής. Έτσι μια επιτάχυνση στην απόδοση ενός αλγορίθμου αναζήτησης θα έχει ευεργετικά οφέλη για πολλούς τομείς όπως στην ασφάλεια (που είναι και το κίνητρο της παρούσας διπλωματικής), τα κινητά τηλέφωνα, κτλ. Για να επιτευχθεί αυτό θα χρησιμοποιηθεί μια κάρτα γραφικών της Nvidia και το περιβάλλον ανάπτυξης εφαρμογών για κάρτες γραφικών CUDA. Ο αλγόριθμος ο οποίος είναι κατάλληλος για παράλληλη εκτέλεση στην κάρτα γραφικών είναι ο Aho-Corasick η κανονική εκδοχή του οποίου παρουσιάζεται στο Κεφάλαιο 2 ενώ η τροποποιημένη εκδοχή του για να τρέχει στην κάρτα γραφικών παρουσιάζεται στο Κεφάλαιο 4. Επίσης το περιβάλλον ανάπτυξης εφαρμογών CUDA καθώς και άλλα παραδείγματα παραλληλοποίησης παρουσιάζονται στο Κεφάλαιο 3. Τα αποτελέσματα από την εκτέλεση του κανονικού και του τροποποιημένου αλγορίθμου Aho-Corasick παρουσιάζονται στο Κεφάλαιο 5 ενώ τα συμπεράσματα από αυτά τα αποτελέσματα και οι μελλοντικές κατευθύνσεις τις διπλωματικής παρουσιάζονται στο Κεφάλαιο 6. 9

10 2 ΤΟ ΠΡΟΒΛΗΜΑ ΤΗΣ ΑΝΑΖΗΤΗΣΗΣ Ένα από τα πιο κοινά προβλήματα που σχετίζονται με τις ακολουθίες χαρακτήρων (strings) είναι το πρόβλημα της εύρεσης μιας συγκεκριμένης ακολουθίας χαρακτήρων ή αλλιώς μοτίβο (pattern) μέσα σε ένα μεγαλύτερο κείμενο. Η αναζήτηση μοτίβων χρησιμοποιείται σήμερα κατά κόρον από μια ευρεία γκάμα ηλεκτρονικών συσκευών (από κινητά τηλέφωνα μέχρι υπολογιστές) οι οποίες έχουν και διαφορετική επεξεργαστική ισχύ. Επομένως είναι πολύ σημαντικό να υπάρχουν αποδοτικοί αλγόριθμοι που να επιτελούν αυτού του είδους τις αναζητήσεις ώστε να μπορούν να εκτελεστούν και σε υλικό με περιορισμένη επεξεργαστική ισχύ. Λόγω της σημαντικότητας του προβλήματος όλα αυτά τα χρόνια υπήρξε μεγάλη επιστημονική έρευνα γύρω από το πρόβλημα της αναζήτησης και έτσι σήμερα υπάρχει μια πληθώρα από αλγόριθμους που προσεγγίζουν το πρόβλημα από πολλές διαφορετικές πλευρές. Όλοι αυτοί οι αλγόριθμοι μπορούν να ταξινομηθούν με διάφορα κριτήρια ταξινόμησης. Η κυριότερη κατηγοριοποίηση γίνεται με βάση το αν ο αλγόριθμος μπορεί να αναζητεί μέσα σε ένα κείμενο ένα ή περισσότερα μοτίβα. Έτσι οι αλγόριθμοι χωρίζονται σε μονού-μοτίβου και πολλαπλού-μοτίβου. Οι αλγόριθμοι μονού-μοτίβου μπορούν και αυτοί να χρησιμοποιηθούν για αναζήτηση περισσότερων μοτίβων αρκεί κάθε φορά να επαναλαμβάνεται όλος ο αλγόριθμος για διαφορετικό μοτίβο. Αυτό όμως συνεπάγεται αυξημένο χρόνο εκτέλεσης σε σχέση με τους αλγόριθμους πολλαπλού-μοτίβου. Επομένως για την περίπτωση της ασφάλειας (προγράμματα αντιμετώπισης ιών) οι αλγόριθμοι που ενδείκνυνται είναι οι αλγόριθμοι πολλαπλού-μοτίβου αφού πρέπει να εξετάζουμε ένα αρχείο για πολλούς ιούς ταυτόχρονα. Έτσι στην παρούσα διπλωματική ο αλγόριθμος που θα επιλεγεί για να γίνει παραλληλοποίηση του θα είναι από την κατηγορία των αλγορίθμων του πολλαπλού-μοτίβου αφού έναυσμα αυτής της διπλωματικής αποτέλεσε η διερεύνηση της δυνατότητας προσθήκης προηγμένων χαρακτηριστικών ασφαλείας (όπως προγράμματα αντιμετώπισης ιών) σε ενσωματωμένα συστήματα. Μια άλλη κατηγοριοποίηση των αλγορίθμων μπορεί να γίνει ανάλογα με την κατεύθυνση στην οποία γίνεται η αναζήτηση έτσι υπάρχουν οι προθεματικοί (prefix) αλγόριθμοι στους οποίους η αναζήτηση γίνεται προς τα εμπρός στο παράθυρο αναζήτησης και οι επιθεματικοί (suffix) αλγόριθμοι όπου η αναζήτηση γίνεται προς τα πίσω στο παράθυρο αναζήτησης. Γενικά στους επιθεματικούς αλγόριθμους δεν διαβάζονται όλοι οι χαρακτήρες του μοτίβου με αποτέλεσμα αυτοί να τείνουν να έχουν υπό-γραμμική μέση περίπτωση. Στον Πίνακα 2.1 παρουσιάζονται μερικοί από τους αντιπροσωπευτικότερους αλγόριθμους κάθε κατηγορίας. Έτσι σε αυτό το κεφάλαιο θα παρουσιαστούν οι πιο γνωστοί από τους αλγόριθμους αναζήτησης μονού και πολλαπλού-μοτίβου, θα αναλυθεί η πολυπλοκότητα τους, θα παρουσιαστεί ο κώδικας τους σε C και θα δοθεί παράδειγμα χρήσης τους. Μονού-Μοτίβου Πολλαπλού-Μοτίβου Προθεματικοί Knuth-Morris-Pratt Aho-Corasick Επιθεματικοί Boyer-Moore Wu-Manber Πίνακας 2.1: Κατηγορίες αλγορίθμων αναζήτησης μοτίβου 10

11 2.1 Αλγόριθμοι αναζήτησης μονού-μοτίβου Απλός αλγόριθμος αναζήτησης Ο πιο απλός αλγόριθμος αναζήτησης ο οποίος είναι γνωστός και ως μέθοδος brute-force χρησιμοποιεί την απλή εξής μέθοδο: Στοιχίζει το μοτίβο (pattern) με την αρχή του κειμένου και ελέγχει αν το μοτίβο ταιριάζει με την αντίστοιχη ακολουθία χαρακτήρων του κειμένου. Αν δεν ταιριάζει τότε μετακινεί το μοτίβο κατά μια θέση προς τα δεξιά και επαναλαμβάνει την διαδικασία. Ο απλός αλγόριθμος αναζήτησης δεν έχει φάση προεργασίας και χρειάζεται ένα σταθερή ποσότητα μνήμης ανάλογα με το μοτίβο και το κείμενο αναζήτησης. Το πλεονέκτημα αυτού του αλγόριθμου είναι η ευκολία υλοποίησης του σε λογισμικό λόγω της απλότητας του. Τα κυριότερο μειονέκτημα του είναι η χαμηλή του απόδοση, αφού η χρονική του πολυπλοκότητα είναι O(mn) για ένα μοτίβο μήκους m και ένα κείμενο μήκους n. Ο απλός αλγόριθμος αναζήτησης εκτελεί περίπου 2n συγκρίσεις χαρακτήρων. Κώδικας σε C του Απλού αλγόριθμου αναζήτησης void BF(char *x, int m, char *y, int n) { int i, j; /* Searching */ for (j = 0; j <= n - m; ++j) { for (i = 0; i < m && x[i] == y[i + j]; ++i); if (i >= m) OUTPUT(j); } } Παράδειγμα Απλού αλγορίθμου αναζήτησης Πρώτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 4 το μοτίβο με το κείμενο δεν ταιριάζουν οπότε το μοτίβο μετακινείται κατά μια θέση δεξιά Δεύτερη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G 11

12 Στην θέση 2 το μοτίβο είναι διαφορετικό από το κείμενο, οπότε μετακινείται πάλι κατά μια θέση δεξιά Τρίτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 3 το μοτίβο είναι διαφορετικό από το κείμενο, οπότε μετακινείται πάλι κατά μια θέση δεξιά Τέταρτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 4 το μοτίβο είναι διαφορετικό από το κείμενο, οπότε μετακινείται πάλι κατά μια θέση δεξιά Πέμπτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 5 το μοτίβο είναι διαφορετικό από το κείμενο, οπότε μετακινείται πάλι κατά μια θέση δεξιά Έκτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Σε αυτή την απόπειρα το μοτίβο ταιριάζει με το κείμενο οπότε ο αλγόριθμος έχει βρει την θέση στην οποία αρχίζει το μοτίβο μέσα στο κείμενο. Σε αυτή την περίπτωση ο αλγόριθμος μπορεί να σταματήσει αν εκτελεί απλή αναζήτηση ή να συνεχίσει αν εκτελεί πολλαπλή αναζήτηση ώστε να βρει αν υπάρχουν και τις υπόλοιπες θέσεις που αρχίζει το μοτίβο μέσα στο κείμενο. Αν συνεχίσει θα μετακινήσει και πάλι το μοτίβο κατά μια θέση δεξιά Knuth-Morris-Pratt Ο αλγόριθμος Knuth-Morris-Pratt πήρε το όνομα του από τους ερευνητές που τον πρότειναν το Ο αλγόριθμος KMP για να επιταχύνει τον απλό αλγόριθμο αναζήτησης αυτό που κάνει είναι αντί να μετακινεί το μοτίβο κατά μια θέση δεξιά, κάθε φορά που το μοτίβο δεν ταιριάζει με το κείμενο σε κάποια θέση του, το μετακινεί περισσότερες χωρίς βέβαια να χάνει καμία εμφάνιση του μοτίβου μέσα στο κείμενο. Το πόσες θέσεις θα μετακινήσει το μοτίβο προς τα δεξιά ο αλγόριθμος KMP εξαρτάται κάθε φορά από τη θέση του χαρακτήρα μέσα στο μοτίβο που δεν ταιριάζει με το κείμενο. Έστω ότι στην θέση j του 12

13 κειμένου y αρχίζει να συγκρίνει ο αλγόριθμος KMP το κείμενο y[j,,j+m-1] με το μοτίβο x[0,,m-1] και έστω ότι ο πρώτος χαρακτήρας που το μοτίβο με το κείμενο δεν ταιριάζουν είναι στην θέση i με 0<i<m. Τότε θα είναι x[0,,i-1] = y[j,,j+i-1] = u και a = x[i] y[j+i] = b. Αντί λοιπόν να μετακινηθεί το μοτίβο κατά μια θέση τώρα μπορεί να μετακινηθεί περισσότερες θέσεις αρκεί να υπάρχει ένα πρόθεμα (prefix) v στο μοτίβο που να ταιριάζει με ένα επίθεμα (suffix) του κομματιού του κειμένου u όπως φαίνεται σχηματικά και στην Εικόνα 2.1. Ωστόσο για να μην υπάρξει πάλι αμέσως αποτυχία στο ταίριασμα θα πρέπει ο χαρακτήρας που ακολουθεί το v να είναι διαφορετικός από το χαρακτήρα a = x[i] που δεν ταίριαζε με το κείμενο. Αν υπάρχουν πολλά τέτοια προθέματα v στο μοτίβο επιλέγεται αυτό με το μεγαλύτερο μήκος και ορίζεται ως kmpnext[i] το μήκος αυτού του προθέματος, ενώ αν δεν υπάρχουν καθόλου τότε θέτεται ως kmpnext[i]η τιμή -1. Έτσι μετακινείται το μοτίβο κατά i-kmpnext[i] θέσεις δεξιά και ο αλγόριθμος ξαναρχίζει να συγκρίνει τα x[kmpnext[i]] και y[i+j] χωρίς να έχει χάσει κάποια εμφάνιση του μοτίβου x μέσα στο κείμενο y. Η τιμή του kmpnext[0] = -1. Ο πίνακας με τις τιμές του kmpnext μπορεί να υπολογιστεί σε O(m) χρόνο και καταλαμβάνει O(m) χώρο. Έτσι ο αλγόριθμος KMP έχει φάση προεργασίας που στοιχίζει O(m) και φάση εκτέλεσης που στοιχίζει O(m+n). Επίσης ο αλγόριθμος εκτελεί το πολύ 2n-1 συγκρίσεις χαρακτήρων κατά την φάση εκτέλεσης. Εικόνα 2.1: Μετακίνηση του μοτίβου στον αλγόριθμο KMP Κώδικας σε C του αλγόριθμου KMP void prekmp(char *x, int m, int kmpnext[]) { int i, j; i = 0; j = kmpnext[0] = -1; while (i < m) { while (j > -1 && x[i]!= x[j] ) j = kmpnext[j]; i++; j++; if (x[i] == x[j]) kmpnext[i] = kmpnext[j]; else kmpnext[i] = j; } } void KMP(char *x, int m, char *y, int n) { int i, j, kmpnext[xsize]; /* Preprocessing */ 13

14 prekmp(x, m, kmpnext); /* Searching */ i = j = 0; } while (j < n) { while (i > -1 && x[i]!= y[j] ) i = kmpnext[i]; i++; j++; if (i >= m) { OUTPUT(j -i); i = kmpnext[i]; } } Παράδειγμα αλγορίθμου KMP i x[i] G C A G A G A G kmpnext[i] Πίνακας 2.1: Υπολογισμός του kmpnext στην φάση προεργασίας Πρώτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 4 το μοτίβο με το κείμενο δεν ταιριάζουν οπότε το μοτίβο μετακινείται κατά: i kmpnext[i] = 3 (-1) = 4 θέσεις δεξιά Δεύτερη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Στην θέση 5 το μοτίβο με το κείμενο δεν ταιριάζουν οπότε το μοτίβο μετακινείται κατά: i kmpnext[i] = 0 (-1) = 1 θέση δεξιά Τρίτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G 14

15 G C A G A G A G Στην αυτή την απόπειρα υπάρχει πλήρες ταίριασμα του μοτίβου με το κείμενο άρα ο αλγόριθμος KMP έχει αναγνωρίσει επιτυχώς το μοτίβο μέσα στο κείμενο με μόλις τρεις απόπειρες. Τώρα για να αναγνωρίσει ο αλγόριθμος KMP και άλλες τυχόν θέσεις του μοτίβου μέσα στο κείμενο θα μετακινήσει το μοτίβο κατά i kmpnext[i] = 8 1 = 7 θέσεις δεξιά Karp-Rabin Ο αλγόριθμος Karp-Rabin χρησιμοποιεί την προσέγγιση των hash συναρτήσεων για να αποφύγει τις πολλαπλές συγκρίσεις χαρακτήρων στις περισσότερες περιπτώσεις. Έτσι αντί λοιπόν ο αλγόριθμος να κοιτάει σε κάθε θέση του κειμένου αν το μοτίβο ταιριάζει αυτό που κάνει είναι να κοιτάει κάθε φορά αν τα περιεχόμενα του παραθύρου σύγκρισης μοιάζουν με το μοτίβο. Για να μπορέσει ο αλγόριθμος να συγκρίνει την ομοιότητα του παραθύρου σύγκρισης με το μοτίβο χρησιμοποιεί μία hash συνάρτηση. Η hash συνάρτηση που θα χρησιμοποιηθεί θα πρέπει να έχει τις παρακάτω ιδιότητες: Υπολογιστικά αποδοτική Μεγάλη διάκριση για ακολουθίες χαρακτήρων hash(y[j+1,,j+m]) πρέπει να υπολογίζεται εύκολα από τα hash(y[j+1,,j+m-1]) και y[j+m]: hash(y[j+1,,j+m]) = rehash( y[j], y[j+m], hash(y[j+1,,j+m-1]) ) Έστω λοιπόν μια ακολουθία χαρακτήρων w μήκους m και μια hash συνάρτηση που ορίζεται ως εξής: hash(w[0,,m-1] = (w[0]x2 m-1 + w[1]x2 m w[m-1]x2 0 ) mod q, όπου q ένας μεγάλος αριθμός. Τότε θα μπορούμε εύκολα να υπολογίσουμε το rehash(a, b, h) = ((h - a x 2 m-1 ) x 2 + b) mod q. Ο αλγόριθμος Karp-Rabin έχει και αυτός φάση προεργασίας και φάση εκτέλεσης. Στην φάση προεργασίας υπολογίζεται η συνάρτηση hash σε χρόνο O(m). Κατά την φάση εκτέλεσης συγκρίνεται η τιμή της συνάρτησης hash(x) του μοτίβου με την τιμή της συνάρτησης hash(y[j,,j+m-1]) για 0 j n-m του παραθύρου σύγκρισης. Εάν αυτές οι δύο τιμές είναι ίδιες τότε συγκρίνεται χαρακτήρα προς χαρακτήρα το μοτίβο με το παράθυρο σύγκρισης, αλλιώς μετακινείται προς τα δεξιά κατά μια θέση το παράθυρο σύγκρισης. Η χρονική πολυπλοκότητα του αλγορίθμου είναι O(mn) στην χειρότερη περίπτωση ενώ στην μέση περίπτωση είναι O(m+n). Κώδικας σε C του αλγόριθμου Karp-Rabin #define REHASH(a, b, h ) ((((h) - (a)*d) << 1) + (b)) void KR(char *x, int m, char *y, int n) { int d, hx, hy, i, j; /* Preprocessing */ /* computes d = 2^(m-1) with the left shift operator */ 15

16 for (d = i = 1; i < m; ++i) d = (d << 1); for (hy = hx = i = 0; i < m; ++i) { hx = ((hx << 1) + x[i]); hy = ((hy << 1) + y[i]); } /* Searching */ j = 0; } while (j <= n-m) { if (hx == hy && memcmp(x, y + j, m) OUTPUT(j); ++j; hy = REHASH(y[j], y[j + m], hy); } Παράδειγμα αλγορίθμου Karp-Rabin hash(gcagagag) = Πρώτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G hash(y[1-8]) = Δεύτερη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G hash(y[2-9]) = Τρίτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G hash(y[3-10]) =

17 Τέταρτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G hash(y[4-11]) = Πέμπτη απόπειρα G C A G A G A G G C A T C G C A G A G A G T A T A C A G T A C G hash(y[5-12]) = Έκτη απόπειρα G C A G A G A G G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G hash(y[6-13]) = = hash(gcagagag) Τώρα που οι τιμές των hash συναρτήσεων είναι ίδιες ο αλγόριθμος εκτελεί 8 (όσο το μήκος του μοτίβου) συγκρίσεις χαρακτήρων για να διαπιστώσει ότι όντως το μοτίβο ταιριάζει ακριβώς με το παράθυρο σύγκρισης (χαρακτήρες 6 έως 13) του κειμένου. Από αυτό το σημείο και έπειτα ο αλγόριθμος μπορεί να επαναλάβει την ίδια διαδικασία αν θέλει να βρει και άλλες θέσεις που μπορεί να εμφανίζεται το μοτίβο μέσα στο κείμενο Boyer-Moore Ο αλγόριθμος Boyer-Moore θεωρείται από τους πιο αποδοτικούς αλγόριθμους αναζήτησης μοτίβων γι αυτό και χρησιμοποιείται στα περισσότερα προγράμματα για να επιτελέσει τις λειτουργίες τις αναζήτησης. Ο αλγόριθμος συγκρίνει τους χαρακτήρες του μοτίβου με τους χαρακτήρες του κειμένου από τα δεξιά προς τα αριστερά ξεκινώντας από τον δεξιότερο χαρακτήρα. Σε περίπτωση που οι δύο χαρακτήρες που συγκρίνονται δεν ταιριάζουν τότε ο αλγόριθμος χρησιμοποιεί δύο προ-υπολογισμένες συναρτήσεις για να μετακινήσει το παράθυρο σύγκρισης προς τα δεξιά. Αυτές οι δύο συναρτήσεις ονομάζονται καλούεπιθέματος μετακίνηση (good-suffix shift) και κακού-χαρακτήρα μετακίνηση (bad-character shift). Έστω ότι οι χαρακτήρες του μοτίβου και του κειμένου που δεν ταιριάζουν είναι οι x[i] = a και y[i+j] = b τότε x[i+1,, m-1] = y[i+j+1,, j+m-1] = u και x[i] y[i+j]. Η μετακίνηση καλού-επιθέματος προσπαθεί να ευθυγραμμίσει το τμήμα x[i+1,, m-1] = y[i+j+1,, j+m-1] με την πιο δεξιά εμφάνιση του στο μοτίβο x στην οποία προηγείται χαρακτήρας διαφορετικός από το x[i] όπως φαίνεται στην Εικόνα 2.2. Αν δεν υπάρχει 17

18 ένα τέτοιο τμήμα τότε η μετακίνηση προσπαθεί να ευθυγραμμίσει το μεγαλύτερο επίθεμα u του κειμένου y[i+j+1,, j+m-1] με ένα πρόθεμα του μοτίβου x όπως φαίνεται στην Εικόνα 2.3. Εικόνα 2.2: Μετακίνηση καλού-επιθέματος με επανεμφάνιση του u μέσα στο μοτίβο Εικόνα 2.3: Μετακίνηση καλού-επιθέματος με μέρος του u να επανεμφανίζεται μέσα στο μοτίβο Η μετακίνηση κακού-χαρακτήρα προσπαθεί ευθυγραμμίσει τον χαρακτήρα του κειμένου y[i+j] και με την πιο δεξιά εμφάνιση του μέσα στο μοτίβο x[0,,m-2] όπως φαίνεται στην Εικόνα 2.4. Αν το y[i+j] δεν υπάρχει μέσα στο μοτίβο x τότε καμία εμφάνιση του x μέσα στο y δεν μπορεί να περιέχει τον χαρακτήρα y[i+j] επομένως το αριστερό άκρο του παραθύρου σύγκρισης μετακινείται αμέσως μετά τον χαρακτήρα y[i+j] όπως φαίνεται στην Εικόνα 2.5. Εικόνα 2.4: Μετακίνηση κακού-χαρακτήρα με επανεμφάνιση του χαρακτήρα b στο μοτίβο Εικόνα 2.5: Μετακίνηση κακού-χαρακτήρα με μη επανεμφάνιση του χαρακτήρα b στο μοτίβο 18

19 Στον αλγόριθμο Boyer-Moore η μετακίνηση κακού-χαρακτήρα μπορεί να είναι αρνητική έτσι για την μετακίνηση του παραθύρου σύγκρισης επιλέγεται το μεγαλύτερο μεταξύ της μετακίνησης κακούχαρακτήρα και της μετακίνησης καλού-επιθέματος. Ένας πιο επίσημος ορισμός των δύο συναρτήσεων μετακίνησης δίνεται παρακάτω. Η συνάρτηση μετακίνησης καλού-επιθέματος αποθηκεύεται σε ένα πίνακα bmgs μεγέθους m+1. Έστω επίσης ότι Cs(i,s) = για κάθε k τέτοιο ώστε i < k < m, s k ή x[k-s] = x[k] Co(i,s,) = Αν s < i τότε x[i-s] x[i] Τότε για κάθε 0 i < m: bmgs[i+1] = min{s > 0: Cs(i,s) και Co(i,s) να ισχύουν} και bmgs[0] ορίζεται ως το μήκος της περιόδου του x. Για τον υπολογισμό του πίνακα bmgs χρησιμοποιείται και ένας πίνακας suff που ορίζεται ως: Για κάθε 1 i < m, suff[i] = max{k: x[i-k+1,, i] = x[m-k,,m-1]} Η συνάρτηση μετακίνησης κακού-χαρακτήρα αποθηκεύεται σε ένα πίνακα bmbc μεγέθους σ, όπου σ είναι το μέγεθος του αλφάβητου που χρησιμοποιείται στις ακολουθίες χαρακτήρων. Για κάθε : { { [ ] } Οι πίνακες bmgs και bmbc μπορούν να υπολογιστούν εξ αρχής σε χρόνο O(m+σ) και χρειάζονται χώρο O(m+σ). Η χρονική πολυπλοκότητα της φάσης εύρεσης στην χειρότερη περίπτωση είναι O(mn) και εκτελούνται το πολύ 3n συγκρίσεις χαρακτήρων. Ωστόσο για μεγάλα αλφάβητα (σε σχέση με το μήκος του μοτίβου) ο αλγόριθμος είναι εξαιρετικά γρήγορος και εκτελεί μόνο O(n/m) συγκρίσεις χαρακτήρων που είναι και το ελάχιστο όριο για κάθε αλγόριθμο αναζήτησης μονού-μοτίβου που προεπεξεργάζεται μόνο το μοτίβο. Κώδικας σε C του αλγόριθμου Boyer-Moore void prebmbc(char *x, int m, int bmbc[]) { int i; } for (i = 0; i < ASIZE; ++i) bmbc[i] = m; for (i = 0; i < m - 1; ++i) bmbc[x[i]] = m - i - 1; void suffixes(char *x, int m, int *suff) { int f, g, i; suff[m - 1] = m; g = m - 1; 19

20 } for (i = m - 2; i >= 0; --i) { if (i > g && suff[i + m - 1 -f] < i - g) suff[i] = suff[i + m f]; else { if (i < g) g = i; f = i; while ( g >= 0 && x[g] == x[g + m f]) --g; suff[i] = f - g; } } void prebmgs(char *x, int m, int bmgs[]) { int i, j, suff[xsize]; suffixes(x, m, suff); } for (i = 0; i < m; ++i) bmgs[i] = m; j = 0; for (i = m - 1; i >= -1; --i) if (i == -1 suff[i] == i + 1) for (; j < m i; ++j) if (bmgs[j] == m) bmgs[j] = m i; for (i = 0; i <= m - 2; ++i) bmgs[m suff[i]] = m i; void BM(char *x, int m, char *y, int n) { int i, j, bmgs[xsize], bmbc[asize]; /* Preprocessing */ prebmgs(x, m, bmgs); prebmbc(x, m, bmbc); } /* Searching */ j = 0; while ( j <= n - m) { for (i = m - 1; i >= 0 && x[i] == y[i + j]; --i); if (i < 0) { OUTPUT(j); j += bmgs[0]; } else j += MAX(bmGs[i], bmbc[y[i + j]] - m i); } Παράδειγμα αλγορίθμου Boyer-Moore 20

21 c A C G T bmbc Πίνακας 2.2: Μετακίνηση κακού-χαρακτήρα i x[i] G C A G A G A G syff[i] bmgs[i] Πίνακας 2.3: Μετακίνηση καλού-επιθέματος Πρώτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Μετακίνηση κατά 1 θέση δεξιά (bmgs[7] = bmbc[a] ) Δεύτερη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Μετακίνηση κατά 4 θέσεις δεξιά (bmgs[5] = bmbc[c] ) Τρίτη απόπειρα G C A T C G C A G A G A G T A T A C A G T A C G G C A G A G A G Σε αυτή την απόπειρα υπάρχει το πλήρες ταίριασμα του μοτίβου με το κείμενο άρα ο αλγόριθμος BM έχει αναγνωρίσει επιτυχώς το μοτίβο μέσα στο κείμενο με μόλις τρεις απόπειρες. Τώρα για να αναγνωρίσει ο αλγόριθμος BM και άλλες τυχόν θέσεις του μοτίβου μέσα στο κείμενο θα μετακινήσει το μοτίβο κατά 7 θέσεις δεξιά (bmgs[0]). 2.2 Αλγόριθμοι αναζήτησης πολλαπλού-μοτίβου Karp-Rabin πολλαπλού-μοτίβου 21

22 Ο αλγόριθμος Karp-Rabin μπορεί πολύ εύκολα από μονού-μοτίβου να μετατραπεί σε πολλαπλού-μοτίβου χρησιμοποιώντας τα παρακάτω βήματα: Φάση Προεργασίας 1. Υπολογισμός της hash συνάρτησης για κάθε μοτίβο και αποθήκευση αυτής της τιμής 2. Ταξινόμηση των μοτίβων με βάση την τιμή της hash συνάρτησης Φάση Εύρεσης 1. Υπολογισμός της hash συνάρτησης του παραθύρου σύγκρισης 2. Εύρεση αυτής της hash τιμής στον πίνακα με τις αποθηκευμένες hash τιμές της φάσης προεργασίας με χρήση δυαδικής αναζήτησης 3. Εάν η hash τιμή βρεθεί στον πίνακα τότε ακολουθεί επαλήθευση του αντίστοιχου μοτίβου όπως και στον κανονικό αλγόριθμο Karp-Rabin, αλλιώς μετακίνηση του παραθύρου σύγκρισης κατά μια θέση προς τα δεξιά. Ο αλγόριθμος Karp-Rabin μονού-μοτίβου δεν είναι αρκετά γρήγορος σε σχέση με τους αντίστοιχους αλγόριθμους μονού-μοτίβου όπως π.χ. ο Boyer-Moore, αλλά είναι πολύ γρήγορος στην περίπτωση της αναζήτησης πολλαπλού-μοτίβου. Ειδικά αν αντί για πίνακα και δυαδική αναζήτηση χρησιμοποιηθούν ειδικές δομές δεδομένων, όπως το φίλτρο Bloom, για το βήμα όπου ερευνάται αν η hash τιμή του παραθύρου σύγκρισης είναι ίδια με την hash τιμή κάποιου μοτίβου. Ο αλγόριθμος Karp-Rabin πολλαπλούμοτίβου για ένα σύνολο k μοτίβων και ένα κείμενο μήκους n έχει χρονική πολυπλοκότητα O(n+k) Wu-Manber Ο αλγόριθμος Wu-Manber βασίζεται σε δύο βασικούς μηχανισμούς, έναν μηχανισμό φιλτραρίσματος βασισμένο στην hash τεχνολογία και ένα μηχανισμό μετακίνησης με βάση μπλοκ χαρακτήρων βασισμένο στην μετακίνηση κακού-χαρακτήρα του αλγορίθμου Boyer-Moore. Ο αλγόριθμος Wu-Manber έχει δύο φάσεις, την φάση προεργασίας και την φάση εύρεσης. Στην φάση προεργασίας τα μοτίβα επεξεργάζονται και προκύπτουν τρείς πίνακες οι SHIFT, HASH και PREFIX οι οποίοι χρησιμοποιούνται κατά την φάση εύρεσης. Ο πίνακας SHIFT περιέχει τις τιμές μετακίνησης του παραθύρου σύγκρισης των μπλοκ χαρακτήρων. Ο πίνακας HASH περιέχει δείκτες σε συνδεδεμένες λίστες που αποθηκεύουν όλα τα μοτίβα με το ίδιο επίθεμα μέσα στο παράθυρο σύγκρισης. Τέλος ο πίνακας PREFIX έχει ίδια δομή με τον πίνακα HASH μόνο που δείχνει σε συνδεδεμένες λίστες που περιέχουν το μοτίβα με το ίδιο πρόθεμα μέσα στο παράθυρο σύγκρισης. Ο αλγόριθμος Wu-Manber για ένα κείμενο μήκους n, ένα σύνολο μοτίβων k, μέγεθος ενός μοτίβου m και μέγεθος μπλοκ χαρακτήρων b έχει χρονική πολυπλοκότητα για την φάση προεργασίας O(mk) και O(bn/m) για την φάση εύρεσης. Φάση Προεργασίας 22

23 Κατά την φάση προεργασίας στην αρχή υπολογίζεται το μήκος του παραθύρου σύγκρισης το οποίο είναι ίσο με το μήκος του μικρότερου μοτίβου έστω ότι αυτό το μήκος είναι m. Αυτό είναι και το αδύνατο σημείο του αλγόριθμου αφού αν ένα μοτίβο έχει πολύ μικρό μήκος π.χ. 2 τότε ο αλγόριθμος δεν πρόκειται ποτέ να μετακινήσει το παράθυρο σύγκρισης πάνω από 2 χαρακτήρες. Επίσης ο αλγόριθμος Wu-Manber χρησιμοποιεί μπλοκ από χαρακτήρες για να υπολογίσει τον πίνακα SHIFT, συνήθως το μέγεθος του μπλοκ των χαρακτήρων που χρησιμοποιείται είναι Β = 2 ή 3 χαρακτήρες. Υπολογισμός πίνακα SHIFT Έστω ένα σύνολο από μοτίβα P = {P 1, P 2,,P n } και έστω X ένα μπλοκ χαρακτήρων μέσα στο παράθυρο σύγκρισης και ότι η hash τιμή του X αντιστοιχεί στην θέση i του πίνακα SHIFT, δηλαδή hash(x) = i. Τότε η τιμή μετακίνησης που περιέχει ο πίνακας SHIFT ορίζεται ως εξής: [ ] { ( [ ] [ ] } όπου q στην παραπάνω εξίσωση είναι η δεξιότερη θέση που εμφανίζεται το X σε κάποιο από τα μοτίβα. Υπολογισμός πίνακα HASH Η θέση i του πίνακα HASH περιέχει ένα δείκτη σε μια συνδεδεμένη λίστα από μοτίβα που οι τελευταίοι Β χαρακτήρες των πρώτων m χαρακτήρων των μοτίβων έχουν την ίδια hash τιμή i. Υπολογισμός πίνακα PREFIX Ο πίνακας PREFIX υπολογίζεται όπως και ο πίνακας HASH μόνο που τώρα χρησιμοποιούνται οι πρώτοι Β χαρακτήρες των πρώτων m χαρακτήρων των μοτίβων. Φάση Εύρεσης Η φάση εύρεσης αποτελείται από τα παρακάτω βήματα: 1. Τοποθέτηση του παραθύρου σύγκρισης στην αρχή του κειμένου Τ. 2. Αν το παράθυρο σύγκρισης ξεπερνάει το τέλος του κειμένου τότε η φάση εύρεσης έχει τελειώσει αλλιώς γίνεται υπολογισμός της hash τιμής h των B χαρακτήρων του επιθέματος του κειμένου t m- B+1,,t m. 3. Αν η τιμή του πίνακα SHIFT[h] είναι μεγαλύτερη του μηδενός τότε μετακίνηση του παραθύρου σύγκρισης δεξιά τόσες θέσεις όσες αυτή η τιμή και μεταφορά στο βήμα 2, αλλιώς μεταφορά στο βήμα Εύρεση της hash τιμής h στον πίνακα HASH και των μοτίβων στην συνδεδεμένη λίστα που δείχνει η τιμή στον πίνακα HASH. 5. Υπολογισμός της hash τιμής h 1 των Β χαρακτήρων του προθέματος του κειμένου t m-b+1,,t m. 6. Υπολογισμός της hash τιμής h i των Β χαρακτήρων του προθέματος των μοτίβων που βρίσκονται στην συνδεδεμένη λίστα του βήματος 4. 23

24 7. Αν οι δύο hash h 1 και h i ταιριάζουν τότε θα πρέπει το μοτίβο που αντιστοιχεί στην hash τιμή h i να επιβεβαιωθεί με σύγκριση χαρακτήρα προς χαρακτήρα με το κείμενο. Σε κάθε περίπτωση το παράθυρο σύγκρισης θα μετακινηθεί κατά μια θέση δεξιά και θα υπάρξει μεταφορά στο βήμα 2. Κώδικας σε C του αλγορίθμου Wu-Manber Επειδή ο αλγόριθμος Wu-Manber είναι αρκετά πολύπλοκος παρακάτω παρουσιάζεται μόνο ο κύριος βρόχος της φάσης εύρεσης. Ο πλήρης κώδικας σε C του αλγορίθμου είναι διαθέσιμος μέσω ανώνυμης πρόσβασης ftp στην διεύθυνση cs.arizona.edu σαν μέρος του πακέτου glimpse (αρχείο mgrep.c στον φάκελο agrep). while (text <= textend) { h = (*text<<hbits)+(*(text-1)); /* The hash function (we use Hbits=5) */ if (Long) h = (h<<hbits)+(*(text-2)); /* Long=1 when the number of patterns warrants B=3 */ shift = SHIFT[h]; /* we use a SHIFT table of size 215 = */ if (shift == 0) { /* h = h & mask_hash can be used here if HASH is smaller then SHIFT */ text_prefix = (*(text-m+1)<<8) + *(text-m+2); p = HASH[h]; p_end = HASH[h+1]; while (p++ < p_end) { /* loop through all patterns that hash to the same value (h) */ if(text_prefix!= PREFIX[p]) continue; px = PAT_POINT[p]; qx = text-m+1; while (*(px++) == *(qx++)); /* check the text against the pattern */ if (*(px-1) == 0) { /* 0 indicates the end of a string */ report a match } shift = 1; } text += shift; } } Παράδειγμα αλγορίθμου Wu-Manber Ο αλγόριθμος Wu-Manber χρησιμοποιεί πολλές hash συναρτήσεις και πίνακες που είναι δύσκολο να παρουσιαστούν σε αυτή την διπλωματική γι αυτό παρακάτω παρουσιάζεται ένα πιο απλοποιημένο παράδειγμα. Επίσης γι αυτό το παράδειγμα θεωρείται ότι Β=2, δηλαδή οι μπλοκ χαρακτήρες έχουν μήκους 2 και ότι τα δεδομένα εισόδου είναι τα παρακάτω. Σύνολο Μοτίβων P = {ATATATA, TATAT, ACGATAT} Κείμενο T = AGATACGATATATAC Από το σύνολο μοτίβων εξάγεται ότι το μέγεθος του παραθύρου σύγκρισης είναι ίσο με το μήκος του μικρότερου μοτίβου, δηλαδή στην περίπτωση μας m = 5. Επίσης υπολογίζονται οι παρακάτω πίνακες SHIFT και HASH. Ο πίνακας PREFIX δεν χρησιμοποιείται στην περίπτωση μας γιατί το παράδειγμα είναι απλό και περιέχει λίγα μοτίβα. 24

25 Μπλοκ χαρακτήρων TA AT GA CG AC * Μετακίνηση Πίνακας 2.4: Πίνακας SHIFT Μπλοκ χαρακτήρων TA AT * Αριθμός μοτίβου στο P 1 2, 3 0 Πίνακας 2.5: Πίνακας HASH Πρώτη απόπειρα A G A T A C G A T A T A T A C Από τον πίνακα SHIFT η τιμή μετακίνησης για το μπλοκ χαρακτήρων ΤΑ είναι SHIFT[TA] = 0, επομένως από τον πίνακα HASH δίνεται ότι το μοτίβο που θα πρέπει να συγκριθεί χαρακτήρα προς χαρακτήρα με το κείμενο είναι το HASH[TA] = 1, δηλαδή το ATATATA. Η σύγκριση αποτυγχάνει οπότε το παράθυρο σύγκρισης μετακινείται κατά μια θέση δεξιά. Δεύτερη απόπειρα A G A T A C G A T A T A T A C Από τον πίνακα SHIFT μας δίνεται ότι SHIFT[AC] = 3 άρα το παράθυρο σύγκρισης μετακινείται κατά 3 θέσεις δεξιά. Τρίτη απόπειρα A G A T A C G A T A T A T A C Από τον πίνακα SHIFT η τιμή μετακίνησης για το μπλοκ χαρακτήρων ΑΤ είναι SHIFT[AT] = 0, επομένως από τον πίνακα HASH διαπιστώνεται ότι θα πρέπει να συγκριθούν χαρακτήρα προς χαρακτήρα τα μοτίβα 2 και 3. Το μοτίβο 2 αποτυγχάνει στην σύγκριση ενώ το μοτίβο 3 επιτυγχάνει στην σύγκριση. Στην συνέχεια ο αλγόριθμος Wu-Manber μετακινεί το παράθυρο σύγκρισης κατά μια θέση δεξιά και συνεχίζει τα ίδια βήματα μέχρι το παράθυρο σύγκρισης να ξεπεράσει το τέλος του κειμένου Commentz-Walter 25

26 Ο αλγόριθμος Commentz-Walter εφευρέθηκε στα τέλη της δεκαετίας του 1970 σαν μια πολλαπλούμοτίβου γενίκευση του υψηλής απόδοσης μονού-μοτίβου αλγόριθμου Boyer-Moore. Ο αλγόριθμος μετακινεί το παράθυρο σύγκρισης από τα αριστερά προς τα δεξιά αλλά συγκρίνει τους χαρακτήρες όπως και ο Boyer-Moore από τα δεξιά προς τα αριστερά. Ο αλγόριθμος χρησιμοποιεί μια μορφή αντεστραμμένου δέντρου των μοτίβων που ονομάζεται Trie και με βάση αυτό μπορεί να μετακινήσει δεξιά το παράθυρο σύγκρισης περισσότερους από ένα χαρακτήρες. Ο αλγόριθμος Commentz-Walter χωρίζεται και αυτός σε δύο φάσεις την φάση προεργασίας, που έχει χρονική πολυπλοκότητα O( P ), όπου P είναι το σύνολο των μοτίβων και την φάση εύρεσης που στην μέση περίπτωση έχει χρονική πολυπλοκότητα υπόγραμμική σε σχέση με την είσοδο αλλά στην χειρότερη περίπτωση έχει O(nl max ) όπου n είναι το μέγεθος της εισόδου και l max είναι το μέγιστο μήκος των μοτίβων. Ο αλγόριθμος Commentz-Walter δεν χρησιμοποιείται πολύ συχνά λόγω του ότι δεν έχει γραμμική πολυπλοκότητα στην χειρότερη περίπτωση και του ότι είναι δύσκολος στην υλοποίηση. Γι αυτό το λόγο δεν θα παρουσιαστεί παράδειγμα χρήσης του αλγόριθμου, ενώ ο κώδικας του θα δοθεί σε μορφή ψευδοκώδικα. Φάση Προεργασίας Ο αλγόριθμος Commentz-Walter χρησιμοποιεί κάποιες βασικές δομές δεδομένων και συναρτήσεις που παρουσιάζονται παρακάτω. Η δομή δεδομένων trie είναι ένα δέντρο Τ το οποίο έχει τις εξής ιδιότητες: 1. Κάθε κόμβος v εκτός από την ρίζα r έχει μία ετικέτα κάποιου χαρακτήρα a = l(v) από κάποιο αλφάβητο. 2. Η ρίζα του δέντρου r έχει ετικέτα τον κενό χαρακτήρα Ԑ. 3. Αν δύο κόμβοι v και v είναι αδέρφια (γιοί του ίδιου κόμβου v) τότε v v αν και μόνο αν l(v ) l(v ). Ένα μονοπάτι v 1,, v m στο δέντρο Τ όπου ο κόμβος v i+1 είναι γιός του κόμβου v i αντιστοιχεί στην λέξη l(v 1 )l(v 2 ) l(v m ) που συμβολίζεται ως w(v m ) αν και μόνο αν v 1 = r όπου r η ρίζα του δέντρου. Επίσης ορίζεται και το βάθος ενός κόμβο ως: ( { ( } Επομένως το βάθος του δέντρου Τ ορίζεται ως ( { ( } Έστω λοιπόν ένα σύνολο μοτίβων Κ = W 1,, W r. Αυτό το σύνολο αναπαρίσταται στον αλγόριθμο Commentz-Walter ως ένα trie Τ που περιέχει όμως τα αντεστραμμένα μοτίβα, δηλαδή για h = 1,, r υπάρχει ένας κόμβος v h στο δέντρο T που να αντιστοιχεί στην λέξη W h R. Επίσης για κάθε κόμβο v του δέντρου Τ ορίζεται μία συνάρτηση εξόδου ( { ( }, και δύο συναρτήσεις οι shift1 και shift2, οι οποίες βασίζονται σε δυο σύνολα κόμβων set1 και set2 όπως φαίνεται παρακάτω. ( { ( ( ( ( } ( { ( } 26

27 ( { ({ ( ( ( } } ( { ({ ( ( ( } ( } Επίσης ορίζεται ως { } και { } και ( ({ ( ( } { } Φάση Εύρεσης Από την φάση προεργασίας ορίστηκε ότι wmin είναι το μικρότερο μήκος από τα μοτίβα, οπότε ο αλγόριθμος Commentz-Walter ξεκινάει τοποθετώντας την ρίζα του δέντρου Τ που κατασκευάστηκε στην φάση προεργασίας στην θέση wmin+1 του κειμένου. Στην συνέχεια σκανάρει το κείμενο από τα δεξιά προς τα αριστερά μέχρι να βρει ένα χαρακτήρα του κειμένου που δεν ταιριάζει με τον αντίστοιχο χαρακτήρα του μοτίβου ή να αναγνωρίσει κάποιο μοτίβο. Έστω ότι οι χαρακτήρες του κειμένου d i-m+1,, d i ταιριάζουν με κάποιο μοτίβο και ότι στον χαρακτήρα d i-m δεν υπάρχει ταίριασμα τότε ο αλγόριθμος Commentz-Walter θα μετακινήσει την ρίζα του trie κατά έναν αριθμό που υπολογίζεται ως εξής: ( ( ( ( ( Ψευδοκώδικας αλγορίθμου Commentz-Walter Initial Phase: v = r; (v is the present node of T) i = wmin; (i points to the document letter above the nodes of depth 1) j = 0; (j indicates the depth of the present node v) while( i less than document length ) { Scan Phase: while( there is some son v' of v label by document character d i-j ) { v = v'; j = j + 1; output: (w,i) for each w of out(v) } Shift Phase: i = i + S( v, d i-j ); j = 0; } Where S( v, d i-j ) = max(shift1(v), char(d i-j )-j-1), shift2(v)) Aho-Corasick 27

28 Ο αλγόριθμος Aho-Corasick εφευρέθηκε το 1975 και από τότε μέχρι σήμερα πολλές παραλλαγές του αρχικού αλγορίθμου έχουν προταθεί που βελτιώνουν κάποιο σημείο του αλγορίθμου όπως η χρήση της μνήμης, ο χρόνος προεργασίας των μοτίβων κτλ. Σε αυτή την διπλωματική θα παρουσιαστεί ο αρχικός αλγόριθμος χωρίς τις διάφορες βελτιώσεις. Ο αλγόριθμος Aho-Corasick χωρίζεται και αυτός σε δύο φάσεις. Την φάση προεργασίας με χρονική πολυπλοκότητα O(mlog Σ ) όπου m είναι το συνολικό μέγεθος του συνόλου των μοτίβων και Σ το μέγεθος του αλφάβητου και την φάση εύρεσης με χρονική πολυπλοκότητα O(n + log Σ + k) όπου n είναι το μέγεθος του κειμένου και k ο αριθμός των φορών που τα μοτίβα υπάρχουν στο κείμενο. Ο αλγόριθμος Aho-Corasick συνδυάζει την ιδέα των μηχανών πεπερασμένων καταστάσεων με την τεχνική που χρησιμοποιεί ο αλγόριθμος Knuth-Morris-Pratt. Φάση Προεργασίας Σε αυτή την φάση ο αλγόριθμος κατασκευάζει την μηχανή πεπερασμένων καταστάσεων που αντιπροσωπεύουν το σύνολο το μοτίβων καθώς και τρείς συναρτήσεις τις goto, failure και output. Έστω λοιπόν K = { y 1,,y k } το σύνολο το μοτίβων που πρέπει να βρεθούν σε ένα τυχαίο κείμενο x. Η μηχανή πεπερασμένων καταστάσεων διαβάζει κάθε φορά ένα σύμβολο από το κείμενο x και μεταβαίνει σε κάποια κατάσταση με βάση το σύμβολο που διάβασε, ενώ κάποιες φορές παράγει και ως έξοδο κάποιο μοτίβο που αναγνώρισε. Η συμπεριφορά της μηχανής των πεπερασμένων καταστάσεων υπαγορεύεται από τις τρεις συναρτήσεις goto, failure και output. Μια κατάσταση που συνήθως συμβολίζεται με 0 είναι η λεγόμενη αρχική κατάσταση. Η συνάρτηση goto δέχεται ως είσοδο την τωρινή κατάσταση και το σύμβολο που διαβάστηκε από το κείμενο x και παράγει ως έξοδο την επόμενη κατάσταση στην οποία θα πρέπει να πέσει η μηχανή πεπερασμένων καταστάσεων ή αλλιώς το μήνυμα fail. Το μήνυμα fail σημαίνει ότι θα πρέπει να χρησιμοποιηθεί η συνάρτηση failure για να βρεθεί η επόμενη κατάσταση στην οποία θα πρέπει να μεταβεί η μηχανή πεπερασμένων καταστάσεων. Η σχηματική απεικόνιση της συνάρτησης goto για σύνολο μοτίβων {hers, his, she} φαίνεται στην παρακάτω Εικόνα 2.6. Εικόνα 2.6: Συνάρτηση goto Για παράδειγμα η ακμή από την κατάσταση 0 στην κατάσταση 1 που έχει ως ετικέτα το σύμβολο h σημαίνει ότι η συνάρτηση με είσοδο την κατάσταση 0 και το σύμβολο h παράγει ως έξοδο την κατάσταση 28

29 1 δηλαδή goto(0,h) = 1. Στην παραπάνω εικόνα η απουσία ακμών από κάποια κατάσταση σε κάποια άλλη σημαίνει ότι η συνάρτηση goto παράγει ως έξοδο το μήνυμα fail. Η συνάρτηση failure δέχεται ως είσοδο μια κατάσταση και παράγει ως έξοδο πάλι μια κατάσταση. Η συνάρτηση failure για το παραπάνω παράδειγμα φαίνεται στον παρακάτω Πίνακα 2.6. i failure(i) Πίνακας 2.6: Συνάρτηση failure Μερικές καταστάσεις στην μηχανή πεπερασμένων καταστάσεων χαρακτηρίζονται ως καταστάσεις εξόδου και δείχνουν σε ένα σύνολο μοτίβων που αναγνωρίζει η μηχανή πεπερασμένων καταστάσεων με την βοήθεια της συνάρτησης output, όπως φαίνεται στον παρακάτω Πίνακα 2.7. i output(i) {he} {she, he} {his} {hers} Πίνακας 2.7: Συνάρτηση output Κατασκευή Συναρτήσεων goto, failure, output Για την συνάρτηση goto χρειάζεται να κατασκευαστεί ένας γράφος από το σύνολο των μοτίβων. Στην αρχή ο γράφος αποτελείται μόνο από μια κορυφή η οποία αντιπροσωπεύει την αρχική κατάσταση 0. Στην συνέχεια ένα μοτίβο y από το σύνολο των μοτίβων προστίθεται στον γράφο σαν ένα κατευθυνόμενο μονοπάτι από την αρχική κατάσταση. Νέες κορυφές και ακμές προστίθενται στον γράφο έτσι ώστε αρχίζοντας από την αρχική κατάσταση και διανύοντας το μονοπάτι να σχηματίζεται το μοτίβο y. Το μοτίβο y προστίθεται στην συνάρτηση output για την κατάσταση στην οποία τερματίζει το μονοπάτι. Νέες ακμές στον γράφο προστίθενται μόνο όταν είναι απαραίτητο. Στο τέλος αφού έχουν προστεθεί όλα τα μοτίβα στον γράφο τοποθετείται μια ακμή από την αρχική κατάσταση στην αρχική κατάσταση για όλα τα σύμβολα που είναι διαφορετικά από τα πρώτα σύμβολα των μοτίβων. Η συνάρτηση failure κατασκευάζεται με την βοήθεια του γράφου της συνάρτησης goto. Στον γράφο της συνάρτησης goto ορίζεται ως βάθος μίας κατάστασης s το μήκος του μικρότερου μονοπατιού από την αρχική κατάσταση στην κατάσταση s. Έτσι στην Εικόνα 2.6 η αρχική κατάσταση έχει βάθος 0, οι καταστάσεις 1 και 3 έχουν βάθος 1, οι καταστάσεις 2,4 και 6 έχουν βάθος 2 κτλ. Η συνάρτηση failure θα πρέπει να υπολογιστεί για καταστάσεις με βάθος μεγαλύτερο του 1 καθώς δεν ορίζεται για την αρχική κατάσταση. Για κάθε κατάσταση s που έχει βάθος 1 η συνάρτηση failure ορίζεται ως failure(s) = 0. Για κάθε κατάσταση s που έχει βάθος d μεγαλύτερο του 1 η συνάρτηση failure υπολογίζεται χρησιμοποιώντας τις καταστάσεις r που έχουν βάθος d-1 όπως φαίνεται στα παρακάτω βήματα: 1. Αν goto(r,a) = fail για όλα τα a τότε δεν γίνεται καμία ενέργεια 2. Αλλιώς για κάθε σύμβολο a που goto(r,a) = s γίνονται οι ακόλουθες ενέργειες: a. Τίθεται state = failure(r) b. Εκτελείται η state <- failure(state) μηδέν ή περισσότερες φορές μέχρι να υπάρξει μια τιμή για το state τέτοια ώστε goto(state,a) fail c. Τίθεται failure(s) = goto(state,a) 29

30 Για παράδειγμα για να υπολογιστεί η συνάρτηση failure για τον γράφο της Εικόνας 2.6 τίθεται στην αρχή failure(1) = failure(3) = 0 αφού οι καταστάσεις 1 και 3 έχουν βάθος 1. Στην συνέχεια υπολογίζεται η συνάρτηση failure για της καταστάσεις 2, 4 και 6 που έχουν βάθος 2. Για τον υπολογισμό της failure(2) τίθεται state = failure(1) = 0 και αφού goto(0,e) = 0 υπολογίζεται ότι failure(2) = 0. Για τον υπολογισμό της failure(4) τίθεται state = failure(3) = 0 και επειδή goto(0,h) = 1 υπολογίζεται ότι failure(4) = 1. Το ίδιο γίνεται και για τις υπόλοιπες καταστάσεις. Κατά τον υπολογισμό της συνάρτησης failure αλλάζει και η συνάρτηση output που είχε υπολογιστεί κατά τον υπολογισμό της συνάρτησης goto. Όταν λοιπόν τεθεί failure(s) = s τότε οι έξοδοι της συνάρτησης output για τις καταστάσεις s και s ενώνονται. Στο παράδειγμα της Εικόνας 2.6 κάποια στιγμή κατά τον υπολογισμό της συνάρτησης failure τίθεται failure(5) = 2, αυτή την χρονική στιγμή θα πρέπει να ενωθεί το σύνολο των μοτίβων της συνάρτησης output για την κατάσταση 5 {she} με το σύνολο των μοτίβων της συνάρτησης output για την κατάσταση 2 {he} και να δημιουργηθεί το νέο σύνολο {he, she}. Φάση Εύρεσης Στην φάση εύρεσης ο αλγόριθμος διαβάζει κάθε φορά ένα σύμβολο από το κείμενο x και με αυτό το σύμβολο εκτελεί ένα κύκλο λειτουργίας. Ο αλγόριθμος τελειώνει όταν έχει διαβάσει όλα τα σύμβολα του κειμένου x. Ο κύκλος λειτουργίας της μηχανής πεπερασμένων καταστάσεων, αν s είναι η τωρινή κατάσταση και a το σύμβολο του κειμένου x, ορίζεται ως εξής: 1. Αν goto(s,a) = s η μηχανή πεπερασμένων καταστάσεων μεταβαίνει στην κατάσταση s και το επόμενο σύμβολο στο κείμενο x γίνεται το τωρινό σύμβολο εισόδου. Επίσης αν το output(s ) κενού τότε η μηχανή πεπερασμένων καταστάσεων παράγει ως έξοδο το σύνολο της συνάρτησης output(s ) μαζί με την θέση του τωρινού συμβόλου στο κείμενο x. Ο κύκλος λειτουργίας της μηχανής πεπερασμένων καταστάσεων έχει τώρα τελειώσει. 2. Αν goto(s,a) = fail η μηχανή πεπερασμένων καταστάσεων συμβουλεύεται την συνάρτηση failure για να βρει σε ποια κατάσταση θα μεταβεί. Αν failure(s) = s τότε η μηχανή πεπερασμένων καταστάσεων επαναλαμβάνει τον κύκλο με s σαν τωρινή κατάσταση και a σαν σύμβολο εισόδου. Αρχικά η μηχανή πεπερασμένων καταστάσεων έχει ως τωρινή κατάσταση την αρχική κατάσταση 0 και ως σύμβολο εισόδου το πρώτο σύμβολο του κειμένου x. Ψευδοκώδικας αλγορίθμου Aho-Corasick Aho-Corasick Finite State Machine Input: A text string x = a[1] a[2]... a[n] where each a[i] is an input symbol and a pattern matching machine M with goto function g, failure function f, and output function output Output: Locations at which keywords occur in x. begin state = 0 for i = 1 until n do begin 30

31 end end while g(state, a[i]) = fail do state = f(state) state = g (state, a[i]) if output (state)!= empty then begin print i print output (state) end Construction of the goto function Input: Set of keywords K = {y[1], y[2],... y[k]} Output: Goto function g and a partially computed output function output. Method: We assume output(s) is empty when state s is first created, and g(s, a) = fail if a is undefined or if g(s, a) has not yet been defined. The procedure enter(y) inserts into the goto graph a path that spells out y. begin end newstate = 0 for i = 1 until k do enter(y[i]) for all a such that g(0, a) = fail do g(0, a) = 0 procedure enter(a[1] a[2]... a[m]): begin state = 0; j = 1 while g(state, a[j])!= fail do begin state = g (state, a[j]) j = j + 1 end for p = j until m do begin newstate = newstate + 1 g(state, a[p]) = newstate state = newstate end output(state) = { a[1] a[2]... a[m]} end Construction of the failure function Input: Goto function g and output function output Output: Failure function f and output function output. begin queue = empty for each a such that g(0, a) = s!= 0 do begin queue = queue U {s} 31

32 end f(s) = 0 end while queue!= empty do begin let r be the next state in queue queue = queue - {r} for each a such that g(r, a) = s!= fail do begin queue = queue U {s} state = f(r) while g(state, a) = fail do state = f(state) f(s) = g(state, a) output(s) = output(s) U output(f(s)) end end Ολόκληρος ο πηγαίος κώδικας της υλοποίησης του αλγόριθμου Aho-Corasick σε γλώσσα προγραμματισμού C βρίσκεται στο CD που συνοδεύει την διπλωματική. Παράδειγμα αλγορίθμου Aho-Corasick Ο αλγόριθμος Aho-Corasick χρησιμοποιεί μια βασική δομή δεδομένων την Μηχανή Πεπερασμένων Καταστάσεων την οποία και κατασκευάζει από το σύνολο των μοτίβων. Για σύνολο μοτίβων και κείμενο όπως φαίνονται παρακάτω η Μηχανή Πεπερασμένων Καταστάσεων του αλγορίθμου Aho-Corasick φαίνεται στην Εικόνα 2.7. Με διακεκομμένη γραμμή απεικονίζεται η συνάρτηση failure, με συνεχή γραμμή απεικονίζεται η συνάρτηση goto και με διπλό κύκλο απεικονίζεται η συνάρτηση output. Σύνολο Μοτίβων P = {ATATATA, TATAT, ACGATAT} Κείμενο T = AGATACGATATATAC Εικόνα 2.7: Μηχανή Πεπερασμένων Καταστάσεων αλγορίθμου Aho-Corasick 32

33 Πρώτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(0,a) = 1 άρα τωρινή κατάσταση γίνεται η 1 και τελειώνει ο κύκλος λειτουργίας. Δεύτερος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(1,g) = fail άρα ο αλγόριθμος Aho-Corasick συμβουλεύεται την συνάρτηση failure για να βρει την επόμενη κατάσταση στην οποία θα πρέπει να μεταβεί η Μηχανή Πεπερασμένων Καταστάσεων. Άρα failure(1) = 0 και επειδή goto(0,g) = 0 τωρινή κατάσταση γίνεται η 0 και τελειώνει ο κύκλος λειτουργίας. Τρίτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(0,α) = 1 άρα τωρινή κατάσταση γίνεται η 1 και τελειώνει ο κύκλος λειτουργίας. Τέταρτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(1,t) = 4 άρα τωρινή κατάσταση γίνεται η 4 και τελειώνει ο κύκλος λειτουργίας. Πέμπτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(4,a) = 7 άρα τωρινή κατάσταση γίνεται η 7 και τελειώνει ο κύκλος λειτουργίας. Έκτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(7,c) = 4 άρα ο αλγόριθμος Aho-Corasick συμβουλεύεται την συνάρτηση failure για να βρει την επόμενη κατάσταση στην οποία θα πρέπει να μεταβεί η Μηχανή Πεπερασμένων Καταστάσεων. Άρα failure(7) = 5 και επειδή goto(5,c) = fail ο 33

34 αλγόριθμος Aho-Corasick θα συμβουλευτεί ξανά την συνάρτηση failure. Έτσι failure(5) = 1 και επειδή goto(1,c) = 3 τωρινή κατάσταση γίνεται η 3 και τελειώνει ο κύκλος λειτουργίας. Έβδομος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(3,g) = 6 άρα τωρινή κατάσταση γίνεται η 6 και τελειώνει ο κύκλος λειτουργίας. Όγδοος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(6,a) = 9 άρα τωρινή κατάσταση γίνεται η 9 και τελειώνει ο κύκλος λειτουργίας. Ένατος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(9,t) = 12 άρα τωρινή κατάσταση γίνεται η 12 και τελειώνει ο κύκλος λειτουργίας. Δέκατος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(12,a) = 15 άρα τωρινή κατάσταση γίνεται η 15 και τελειώνει ο κύκλος λειτουργίας. Εντέκατος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(15,t) = 17 άρα τωρινή κατάσταση γίνεται η 17 και τελειώνει ο κύκλος λειτουργίας. Όμως επειδή output(17) = 3 ο αλγόριθμος Aho-Corasick έχει αναγνωρίσει το τρίτο μοτίβο στο σύνολο των μοτίβων το οποίο τελειώνει στην θέση 11 του κειμένου. Δωδέκατος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C 34

35 Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(17,α) = fail άρα ο αλγόριθμος Aho-Corasick συμβουλεύεται την συνάρτηση failure για να βρει την επόμενη κατάσταση στην οποία θα πρέπει να μεταβεί η Μηχανή Πεπερασμένων Καταστάσεων. Άρα failure(17) = 10 και επειδή goto(10,a) = 13 τωρινή κατάσταση γίνεται η 13 και τελειώνει ο κύκλος λειτουργίας. Δέκατος Τρίτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(13,t) = 16 άρα τωρινή κατάσταση γίνεται η 16 και τελειώνει ο κύκλος λειτουργίας. Όμως επειδή output(16) = 2 ο αλγόριθμος Aho-Corasick έχει αναγνωρίσει το δεύτερο μοτίβο στο σύνολο των μοτίβων το οποίο τελειώνει στην θέση 13 του κειμένου. Δέκατος Τέταρτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(16,a) = 18 άρα τωρινή κατάσταση γίνεται η 18 και τελειώνει ο κύκλος λειτουργίας. Όμως επειδή output(18) = 1 ο αλγόριθμος Aho-Corasick έχει αναγνωρίσει το πρώτο μοτίβο στο σύνολο των μοτίβων το οποίο τελειώνει στην θέση 14 του κειμένου. Δέκατος Πέμπτος Κύκλος Λειτουργίας A G A T A C G A T A T A T A C Από την Μηχανή Πεπερασμένων Καταστάσεων έχουμε ότι goto(18,c) = fail άρα ο αλγόριθμος Aho-Corasick συμβουλεύεται την συνάρτηση failure για να βρει την επόμενη κατάσταση στην οποία θα πρέπει να μεταβεί η Μηχανή Πεπερασμένων Καταστάσεων. Άρα failure(18) = 13 και επειδή goto(13,c) = fail ο αλγόριθμος Aho-Corasick θα συμβουλευτεί ξανά την συνάρτηση failure. Έτσι failure(13) = 11 και επειδή goto(11,c) = fail ο αλγόριθμος Aho-Corasick θα συμβουλευτεί ξανά την συνάρτηση failure. Τελικά ο αλγόριθμος θα καταλήξει στο goto(1,c) = 3 και τωρινή κατάσταση θα γίνει η 3. Επειδή δεν υπάρχει άλλο σύμβολο εισόδου στο κείμενο T ο αλγόριθμος Aho-Corasick τελειώνει την λειτουργία του και παράγει ως έξοδο ένα πίνακα με τα μοτίβα που αναγνώρισε στο κείμενο Τ καθώς και την θέση στην οποία τελειώνει το κάθε μοτίβο μέσα στο κείμενο. 35

36 3 CUDA Το ακρωνύμιο CUDA προέρχεται από τα αρχικά των λέξεων Compute Unified Device Architecture και είναι μια αρχιτεκτονική παράλληλης επεξεργασίας που αναπτύχτηκε από την εταιρία που κατασκευάζει κάρτες γραφικών NVIDIA. Η CUDA είναι η υπολογιστική μηχανή στις κάρτες γραφικών της NVIDIA που μπορούν να χρησιμοποιηθούν σαν GP-GPU και είναι προσβάσιμη στους προγραμματιστές εφαρμογών μέσω προγραμματιστικών διεπαφών (APIs). Η CUDA δίνει στους προγραμματιστές πρόσβαση, μέσω APIs, στο σετ εντολών και την μνήμη των παράλληλων επεξεργαστικών πυρήνων των καρτών γραφικών με αποτέλεσμα να μετατρέπει τις κάρτες γραφικών σε μια ανοιχτή αρχιτεκτονική για γενικού σκοπού επεξεργασία σαν τις Κεντρικές Μονάδες Επεξεργασίας. Έτσι οι κάρτες γραφικών γίνονται ιδανικές για εκτέλεση εφαρμογών που απαιτούν πολλές επεξεργαστικές μονάδες αφού μπορούν να τρέχουν πολλά νήματα ταυτόχρονα και να αυξάνουν κατακόρυφα την απόδοση. Χρησιμοποιώντας λοιπόν προγραμματιστικές διεπαφές η NVIDIA κρύβει την αρχιτεκτονική των GPUs δημιουργώντας ένα αφηρημένο επίπεδο Υλικού. Αυτό το αφηρημένο επίπεδο Υλικού προσφέρει τα πλεονεκτήματα ότι απλοποιεί το προγραμματιστικό μοντέλο αποκρύπτοντας τις περίπλοκες λεπτομέρειες της αρχιτεκτονικής των καρτών γραφικών και ότι επιτρέπει στην NVIDIA να αλλάζει την αρχιτεκτονική των GPUs χωρίς να χαλάει τα προγράμματα που έχουν ήδη γραφτεί. Η CUDA δουλεύει με όλες της κάρτες γραφικών της NVIDIA από την σειρά G8X και έπειτα και τα προγράμματα που έχουν γραφτεί για της κάρτες γραφικών GeForce 8 θα δουλεύουν και με τις μελλοντικές κάρτες γραφικών χωρίς τροποποιήσεις. Ωστόσο κάποιες τροποποιήσεις ίσως είναι απαραίτητες ώστε το πρόγραμμα να εκμεταλλευτεί τους περισσότερους πυρήνες των μελλοντικών καρτών γραφικών και να αυξηθεί έτσι η απόδοση του προγράμματος. 3.1 Αρχιτεκτονική Οι κάρτες γραφικών στην αρχή προορίζονταν για την εξειδικευμένη κατηγορία της δημιουργίας και απεικόνισης υψηλής ανάλυσης τρισδιάστατων γραφικών. Αυτή η βασική λειτουργία που επιτελούσαν οι κάρτες γραφικών απαιτούσε μεγάλη υπολογιστική δύναμη και υψηλή παραλληλία στους υπολογισμούς, έτσι οι κάρτες γραφικών σχεδιάστηκαν με τρόπο που χρησιμοποιούσε τα περισσότερα τρανζίστορ για υπολογισμούς παρά για caching δεδομένων και έλεγχο ροής προγράμματος όπως στις παραδοσιακές Κεντρικές Μονάδες Επεξεργασίας. Αυτό φαίνεται σχηματικά στην Εικόνα

37 Εικόνα 3.1: Σύγκριση αρχιτεκτονικής CPU και GPU Πιο συγκεκριμένα οι κάρτες γραφικών είναι ιδανικές για την επίλυση προβλημάτων που περιέχουν παραλληλία στα δεδομένα. Έτσι το ίδιο πρόγραμμα (ή εντολή) εκτελείται παράλληλα σε πολλά διαφορετικά δεδομένα (Single Instruction Multiple Data SIMD). Επειδή το ίδιο πρόγραμμα εκτελείται σε πολλά διαφορετικά δεδομένα δεν υπάρχει η ανάγκη για πολύ εξελιγμένο σύστημα ελέγχου. Επίσης επειδή υπάρχει παράλληλη εκτέλεση μεγάλων σετ δεδομένων η καθυστέρηση πρόσβασης στην μνήμη μπορεί να καλυφθεί από τους υπολογισμούς αυτούς χωρίς την ανάγκη για μεγάλες μνήμες cache. Ενώ λοιπόν στην αρχή οι κάρτες γραφικών μπορούσαν να επιλύσουν με την εξειδικευμένη αρχιτεκτονική τους μόνο το πρόβλημα της δημιουργίας τρισδιάστατων γραφικών στην συνέχεια έγινε εμφανές ότι και άλλα υπολογιστικά προβλήματα εμπίπτουν στην κατηγορία των προβλημάτων με παραλληλία στα δεδομένα όπως η επεξεργασία σήματος, η εξομοίωση νόμων της φυσικής, η κρυπτογραφία, η υπολογιστική βιολογία κτλ. Η αρχιτεκτονική CUDA είναι χτισμένη γύρω από μια μεταβλητή συστοιχία από πολύ-νηματικούς Streaming Multiprocessors (SM). Αυτοί οι πολυεπεξεργαστές μπορούν να τρέχουν πολλαπλά νήματα ο καθένας τους αφού αποτελούνται από 8 Scalar Processors (SP) πυρήνες, δύο ειδικά σχεδιασμένες λειτουργικές μονάδες για υπερβατικούς υπολογισμούς, μια πολύ-νηματική μονάδα εντολών και on-chip διαμοιραζόμενη μνήμη μεταξύ των SP. Έτσι με αυτή την αρχιτεκτονική που φαίνεται στην Εικόνα 3.2 ένας πολυεπεξεργαστής μπορεί να δημιουργεί, διαχειρίζεται και να εκτελεί ταυτόχρονα πολλά νήματα στο Υλικό με μηδενικό κόστος για χρονοπρογραμματισμό των νημάτων. 37

38 Εικόνα 3.2: Αρχιτεκτονική κάρτας γραφικών Το πρόγραμμα που τρέχει στην κάρτα γραφικών σπάει σε μπλοκ από νήματα τα οποία στέλνονται για εκτέλεση στους πολυεπεξεργαστές που διαθέτει η κάρτα γραφικών. Κάθε φορά που ένα μπλοκ νημάτων τελειώνει την εκτέλεση του, κάποιο άλλο ξεκινάει την εκτέλεση του στον πολυεπεξεργαστή που άφησε ελεύθερο το προηγούμενο μπλοκ νημάτων. Έτσι όσους περισσότερους πολυεπεξεργαστές έχει μια κάρτα γραφικών τόσο πιο γρήγορα εκτελεί το πρόγραμμα, δηλαδή η αρχιτεκτονική CUDA προσφέρει εύκολη επεκτασιμότητα χωρίς να χρειάζεται ξανά μεταγλώττιση του πηγαίου κώδικα. Για να καταφέρει να διαχειριστεί εκατοντάδες νήματα που τρέχουν αρκετά διαφορετικά προγράμματα κάθε πολυεπεξεργαστής υλοποιεί μια νέα αρχιτεκτονική που ονομάζεται SIMT (Single Instruction Multiple Thread). Ο πολυεπεξεργαστής αντιστοιχεί κάθε νήμα σε ένα scalar processor πυρήνα και έτσι κάθε νήμα που ανήκει σε διαφορετικό SP εκτελείται ανεξάρτητα με τη δικιά του διεύθυνση εκτέλεσης και κατάστασης καταχωρητών. Η SIMT μονάδα του πολυεπεξεργαστή χρησιμοποιεί σύνολα από 32 παράλληλα νήματα τα οποία ονομάζει warp. Τα νήματα που συνθέτουν ένα warp ξεκινάνε όλα μαζί από την ίδια διεύθυνση προγράμματος αλλά μετά εκτελούνται ανεξάρτητα και είναι ελεύθερα να ακολουθήσουν διαφορετικές διακλαδώσεις στον κώδικα. 38

39 Όταν ένας πολυεπεξεργαστής παίρνει ένα μπλοκ από νήματα για εκτέλεση το σπάει σε warps τα οποία χρονοδρομολογούνται για εκτέλεση από την SIMT μονάδα. Κάθε χρονική στιγμή που θα πρέπει να εκτελεστεί μια εντολή η μονάδα SIMT επιλέγει ένα warp το οποίο είναι έτοιμο για εκτέλεση και εκτελεί την επόμενη εντολή προγράμματος στα ενεργά νήματα. Ένα warp εκτελεί μια κοινή εντολή προγράμματος κάθε φορά, επομένως πλήρη απόδοση έχουμε όταν όλα τα νήματα του warp ακολουθούν το ίδιο μονοπάτι εκτέλεσης. Αν τα νήματα του warp ακολουθούν διαφορετικά μονοπάτια εκτέλεσης λόγω συνθηκών διακλάδωσης εξαρτώμενες από δεδομένα τότε τα νήματα του warp εκτελούνται σειριακά μέχρι το μονοπάτι εκτέλεσης να ξανά συμπέσει. Από την σκοπιά της ορθότητας του προγράμματος ο προγραμματιστής μπορεί να αγνοήσει αυτή την συμπεριφορά της SIMT μονάδας αλλά από την σκοπιά της απόδοσης θα πρέπει σίγουρα να την λάβει υπόψη του καθώς μπορεί να πετύχει μεγάλη αύξηση στην απόδοση. Κάθε πολυεπεξεργαστής έχει on-chip μνήμη τεσσάρων τύπων όπως φαίνεται και στην Εικόνα 3.2: Ένα σετ από 32 τοπικούς καταχωρητές ανά επεξεργαστή (SP). Την μνήμη shared ή αλλιώς cache μνήμη δεδομένων που μοιράζεται από όλους τους επεξεργαστές (SP). Την cache μνήμη constant που μοιράζεται σε όλους του επεξεργαστές και είναι μόνο για διάβασμα Την cache μνήμη texture που και αυτή μοιράζεται σε όλους τους επεξεργαστές και είναι μόνο για διάβασμα. Την global μνήμη (device memory) που μοιράζεται σε όλα τα νήματα και όλους του επεξεργαστές και είναι για διάβασμα και γράψιμο. Επίσης η global μνήμη μπορεί προσπελαστεί και από των κώδικα που εκτελείται στην CPU. Επομένως τα νήματα ενός μπλοκ για να μπορέσουν να εκτελεστούν δεν θα πρέπει να χρησιμοποιούν περισσότερη μνήμη shared και καταχωρητές από όσους είναι διαθέσιμοι για κάθε πολυεπεξεργαστή. Επίσης για να ξεχωρίζει η NVIDIA την αρχιτεκτονική των διαφόρων καρτών της χρησιμοποιεί έναν αριθμό που ονομάζεται επεξεργαστική ικανότητα. Ο αριθμός αυτός αποτελείται από δύο αριθμούς, έναν πρωτεύον και ένα δευτερεύον αριθμό. Οι κάρτες γραφικών με ίδιο πρωτεύοντα αριθμό έχουν την ίδια αρχιτεκτονική. Ο δευτερεύον αριθμός αντιστοιχεί σε μια αυξανόμενη βελτίωση του αρχικού αρχιτεκτονικού πυρήνα που ίσως εμπεριέχει και νέες δυνατότητες. 3.2 Προγραμματιστικό Μοντέλο Η CUDA επεκτείνει την γλώσσα προγραμματισμού C δημιουργώντας ένα προγραμματιστικό μοντέλο που επιτρέπει στους προγραμματιστές την εύκολη δημιουργία κώδικα που να εκμεταλλεύεται την αρχιτεκτονική των σύγχρονων καρτών γραφικών. Το προγραμματιστικό μοντέλο της CUDA διαφέρει σημαντικά από τα τρία πιο δημοφιλή σήμερα προγραμματιστικά μοντέλα: το μονό-νηματικό μοντέλο για superscalar επεξεργαστές, το Single Instruction Multiple Data (SIMD) μοντέλο και το πιο πρόσφατο General Purpose GPU μοντέλο. Το προγραμματιστικό μοντέλο της CUDA είναι πιο κοντά στο GPGPU μοντέλο αλλά διαφέρει σημαντικά στο ότι στο GPGPU μοντέλο τα διάφορα νήματα για να επικοινωνήσουν θα πρέπει να χρησιμοποιήσουν την off-chip μνήμη με αποτέλεσμα να επέρχεται περιορισμός στην απόδοση. Στην CUDA 39

40 όμως το σύνολο των δεδομένων σπάει σε μικρότερα κομμάτια που αποθηκεύονται στην on-chip μνήμη με αποτέλεσμα πολλαπλά νήματα να μοιράζονται αυτά τα δεδομένα χωρίς το κόστος μεταφοράς από την offchip μνήμη. Με αυτό τον τρόπο μειώνονται οι φορές που πρέπει να διαβαστούν δεδομένα από την offchip μνήμη με αποτέλεσμα να αυξάνει η απόδοση. Επίσης ένα άλλο χαρακτηριστικό του προγραμματιστικού μοντέλου της CUDA είναι ότι συνήθως η πρόσβαση στην off-chip μνήμη δεν παγώνει την χρήση των scalar processors, αφού το νήμα που περιμένει τα δεδομένα από την off-chip μνήμη αντικαθίσταται από κάποιο άλλο νήμα το οποίο είναι έτοιμο για εκτέλεση. Ωστόσο το σημαντικότερο χαρακτηριστικό του προγραμματιστικού μοντέλου της CUDA είναι ότι οι προγραμματιστές δεν γράφουν κώδικα για να χειρίζονται τα νήματα αφού η CUDA χειρίζεται αυτόματα τα νήματα. Αυτό έχει σαν αποτέλεσμα το προγραμματιστικό μοντέλο της CUDA να γίνεται πιο απλό και να αποκλείεται από τα προγράμματα των προγραμματιστών μια ολόκληρη κατηγορία λαθών που σχετίζεται με την διαχείριση των νημάτων όπως για παράδειγμα τα λάθη αδιεξόδων όπου δύο ή περισσότερα νήματα αποκλείουν το ένα το άλλο από την αλλαγή των ίδιων δεδομένων. Παρόλο που η CUDA χειρίζεται αυτόματα τα νήματα αυτό δεν σημαίνει ότι οι προγραμματιστές δεν ασχολούνται καθόλου με αυτά. Οι προγραμματιστές θα πρέπει να αναλύσουν το πρόβλημα ώστε να βρουν ένα τρόπο να διαιρέσουν τα δεδομένα του προβλήματος σε μικρότερα κομμάτια που μπορούν να διανεμηθούν και να επεξεργαστούν ανεξάρτητα στους scalar processors της κάρτας γραφικών. Αυτό είναι και το σημαντικότερο βήμα για να έχει καλή απόδοση το πρόγραμμα που θα τρέχει στην κάρτα γραφικών. Ένα παράδειγμα εφαρμογής που τα δεδομένα της μπορούν να σπαστούν με τον παραπάνω τρόπο είναι ο έλεγχος των πακέτων δικτύου που περνάνε από ένα δρομολογητή για υπογραφές ιών. Έτσι με την χρήση της CUDA θα μπορούσε να χρησιμοποιηθεί ένα νήμα για κάθε υπογραφή ιού οπότε όλα τα νήματα να χρησιμοποιούν τα ίδια δεδομένα (πακέτα δικτύου) που θα υπάρχουν στην κοινή μνήμη. Άρα σε ένα κύκλο λειτουργίας θα είχε ελεγχθεί ένα πακέτο ενάντια σε όλες της υπογραφές των ιών. Φυσικά κάτι τέτοιο προϋποθέτει ότι όλα τα δεδομένα χωράνε στην τοπική και στην κοινή μνήμη της κάρτας γραφικών ώστε να μην χρειάζονται προσπελάσεις στην off-chip μνήμη. Ωστόσο όλες οι εφαρμογές δεν έχουν τον ίδιο βαθμό παραλληλοποίησης όπως το παράδειγμα που αναφέρθηκε παραπάνω λόγω της εξάρτησης των δεδομένων. Επομένως οι προγραμματιστές θα πρέπει να αναλύσουν τους αλγόριθμους και τα δεδομένα ώστε να βρουν τον βέλτιστο αριθμό νημάτων και μπλοκ νημάτων που θα κρατούν την GPU σε πλήρη λειτουργία. Βεβαίως εκτός από τον αριθμό των επεξεργαστών νημάτων που περιορίζουν τον αριθμό των νημάτων που μπορούν να εκτελεστούν ταυτόχρονα, ένα όριο θέτει και ο αριθμός των καταχωρητών που απαιτεί ένα νήμα για να εκτελεστεί. Το προγραμματιστικό μοντέλο της CUDA επιτρέπει στους προγραμματιστές να ορίσουν συναρτήσεις της γλώσσας προγραμματισμού C, οι οποίες ονομάζονται kernels, που μπορούν να εκτελεστούν N φορές παράλληλα από N διαφορετικά νήματα. Κάθε νήμα που εκτελεί ένα kernel έχει ένα μοναδικό αριθμό thread ID που είναι προσβάσιμος μέσα από τον κώδικα του kernel έτσι κάθε νήμα μπορεί να εκτελέσει διαφορετικό κώδικα μέσα στον kernel χρησιμοποιώντας την μεταβλητή threadidx που παρέχει η CUDA και αποθηκεύει αυτό το μοναδικό αριθμό. Η μεταβλητή threadidx είναι ένας τρισδιάστατος πίνακας έτσι τα νήματα μπορούν να οργανωθούν σε πίνακες ενός, δύο ή τριών διαστάσεων σχηματίζοντας αντίστοιχης διάστασης μπλοκ νημάτων που ονομάζονται thread block. Για ένα μονοδιάστατο μπλοκ νημάτων ο δείκτης ενός νήματος και το thread ID είναι ίδια. Για ένα δισδιάστατο μπλοκ νημάτων μεγέθους (D x,d y ) το thread ID ενός νήματος με δείκτη (x,y) είναι (x + yd x ). Για ένα τρισδιάστατο μπλοκ νημάτων μεγέθους (D x,d y,d z ) το thread ID ενός νήματος με δείκτη (x,y,z) είναι (x + yd x + zd x D y ). Τα νήματα μέσα σε ένα μπλοκ νημάτων 40

41 μπορούν να συνεργάζονται μεταξύ τους μοιράζοντας δεδομένα μέσω της shared memory όπως φαίνεται στην Εικόνα 3.2 καθώς και να συγχρονίζουν την εκτέλεση τους και την πρόσβαση στην μνήμη. Επίσης οι προγραμματιστές μέσω της συνάρτησης syncthreads() μπορούν να αναγκάζουν όλα τα νήματα ενός μπλοκ να περιμένουν πριν συνεχίσουν την εκτέλεση τους. Ένας kernel λοιπόν μπορεί να εκτελεστεί από πολλά ίδιας διάστασης μπλοκ νημάτων τα οποία οργανώνονται σε μονοδιάστατους ή δισδιάστατους πίνακες που ονομάζεται grid. Κάθε μπλοκ νημάτων μέσα το grid μπορεί να αναγνωριστεί από ένα μονοδιάστατο ή δισδιάστατο δείκτη που είναι προσβάσιμος μέσα στο kernel μέσω της μεταβλητής blockidx. Η διάσταση του μπλοκ νημάτων είναι επίσης προσβάσιμη μέσα στο kernel μέσω της μεταβλητής blockdim. Η παραπάνω περιγραφείσα οργάνωση των νημάτων φαίνεται σχηματικά στην Εικόνα 3.3. Εικόνα 3.3: Οργάνωση νημάτων στην CUDA Τα μπλοκ νημάτων πρέπει να εκτελούνται ανεξάρτητα το ένα από το άλλο και με τυχαία σειρά. Αυτός ο περιορισμός επιτρέπει στον χρονοδρομολογητή να εκτελεί τα μπλοκ νημάτων με οποιαδήποτε σειρά σε 41

42 οποιοδήποτε αριθμό επεξεργαστικών πυρήνων επιτρέποντας με αυτό τον τρόπο στους προγραμματιστές να γράφουν κώδικα ο οποίος είναι scalable. Τα νήματα στην CUDA έχουν πρόσβαση σε διαφορετικές μνήμες της κάρτας γραφικών όπως φαίνεται στην Εικόνα 3.4. Κάθε νήμα έχει μια ιδιωτική τοπική μνήμη. Κάθε μπλοκ νημάτων έχει μια κοινή μνήμη (shared memory) που είναι προσβάσιμη από όλα τα νήματα του μπλοκ και έχει την ίδια ζωή με αύτη που έχει και το μπλοκ νημάτων. Τέλος όλα τα νήματα έχουν πρόσβαση στην global μνήμη η οποία διατηρεί τα δεδομένα της ανάμεσα στις διαφορετικές εκτελέσεις kernel της ίδιας εφαρμογής. Εικόνα 3.4: Ιεραρχία μνήμης Όπως φαίνεται και στην Εικόνα 3.5 μια εφαρμογή CUDA περιέχει κώδικα ο οποίος εκτελείται σειριακά στον host και κώδικα ο οποίος εκτελείται παράλληλα σε μια διαφορετική φυσική συσκευή την κάρτα 42

43 γραφικών. Το προγραμματιστικό μοντέλο της CUDA υποθέτει ότι ο host και η κάρτα γραφικών έχουν ο καθένας την δική του ξεχωριστή μνήμη. 43

44 44

45 Εικόνα 3.5: Εκτέλεση μιας εφαρμογής CUDA 3.3 Επεκτάσεις της γλώσσας προγραμματισμού C για την CUDA Οι επεκτάσεις της CUDA για την C έχουν σκοπό να προσφέρουν στους προγραμματιστές πρόσβαση το προγραμματιστικό μοντέλο της CUDA μέσα από ένα όσο πιο μικρό γίνεται σετ επεκτάσεων για την γλώσσα προγραμματισμού C. Τα αρχεία πηγαίου κώδικα που περιέχουν αυτές τις επεκτάσεις θα πρέπει να μεταγλωττιστούν με χρήση του μεταγλωττιστή nvcc που προσφέρει η NVIDIA. Τα αρχεία πηγαίου κώδικα μπορούν να περιέχουν κώδικα ο οποίος εκτελείται στην CPU (host κώδικας) και κώδικα ο οποίος εκτελείται στην κάρτα γραφικών GPU (device κώδικας). Ο μεταγλωττιστής nvcc μεταγλωττίζει μόνο τον device κώδικα ενώ για τον host κώδικα καλεί τον μεταγλωττιστή C που έχει το σύστημα. Αυτές οι επεκτάσεις επιτρέπουν στους προγραμματιστές να δηλώνουν τους kernel σαν απλές συναρτήσεις στην C και μέσω της χρήσης νέας σύνταξης να ορίζουν το μέγεθος του grid και του block κάθε φορά που καλείται ο kernel. Για να ξεχωρίζει μια συνάρτηση της CUDA από της απλές συναρτήσεις της C θα πρέπει μπροστά από την συνάρτηση να υπάρχει ένας από τους τρείς χαρακτηρισμούς τύπου συναρτήσεων που φαίνονται παρακάτω: device : Αυτός ο χαρακτηρισμός σημαίνει ότι η συνάρτηση εκτελείται στην κάρτα γραφικών και μπορεί μόνο να κληθεί από device κώδικα, δηλαδή από κώδικα που εκτελείται στην κάρτα γραφικών. global : Αυτός ο χαρακτηρισμός σημαίνει ότι η συνάρτηση εκτελείται στην κάρτα γραφικών και μπορεί να κληθεί μόνο από host κώδικα, δηλαδή είναι ένας kernel. host : Αυτός ο χαρακτηρισμός σημαίνει ότι η συνάρτηση εκτελείται στην CPU και μπορεί να κληθεί μόνο από host κώδικα. Ο χαρακτηρισμός host μπορεί να παραληφθεί αφού σημαίνει ότι η συνάρτηση είναι μια απλή συνάρτηση της γλώσσας προγραμματισμού C. Ωστόσο υπάρχουν συναρτήσεις που μπορεί να έχουν δύο χαρακτηρισμούς host και device και σημαίνει ότι οι συναρτήσεις αυτές θα πρέπει να μεταγλωττιστούν και για εκτέλεση στην κάρτα γραφικών αλλά και για εκτέλεση στην CPU. Για να ξεκινήσει την εκτέλεση του ένας kernel θα πρέπει να έχει οριστεί για αυτό το kernel το μέγεθος του grid και του block. Γι αυτό το λόγο χρησιμοποιείται μια νέα σύνταξη μετά το όνομα του kernel η <<<G,B>>> όπου G είναι το μέγεθος του grid και B είναι το μέγεθος του block όπως φαίνεται και στο παρακάτω απόσπασμα κώδικα. // Kernel definition global void VecAdd(float* A, float* B, float* C) {... } int main() {... // Kernel invocation VecAdd<<<1, N>>>(A, B, C); } 45

46 Όπως υπάρχουν χαρακτηρισμοί τύπου συναρτήσεων έτσι υπάρχουν και χαρακτηρισμοί τύπου μεταβλητών ώστε να δηλώνουν την περιοχή της μνήμης στην κάρτα γραφικών που αναφέρεται η μεταβλητή. Παρακάτω φαίνονται οι διαφορετικοί τύποι χαρακτηρισμού των μεταβλητών: device : Ορίζει μία μεταβλητή που βρίσκεται στην κάρτα γραφικών. Αν δεν χρησιμοποιηθεί σε συνδυασμό με κάποιον άλλο από τους παρακάτω χαρακτηρισμούς τότε η μεταβλητή αναφέρεται στην global μνήμη, έχει ζωή όσο και η εφαρμογή και είναι προσπελάσιμη από όλα τα νήματα ενός grid καθώς και από host κώδικα μέσω ειδικών συναρτήσεων που θα αναφερθούν παρακάτω. constant : Μπορεί να χρησιμοποιηθεί και σε συνδυασμό με τον χαρακτηρισμό device και ορίζει μια μεταβλητή που αναφέρεται στην constant μνήμη, έχει την ίδια ζωή με την εφαρμογή και είναι προσπελάσιμη από όλα τα νήματα ενός grid αλλά και από host κώδικα. shared : Μπορεί να χρησιμοποιηθεί και σε συνδυασμό με τον χαρακτηρισμό device και ορίζει μια μεταβλητή που αναφέρεται στην shared μνήμη, έχει την ζωή ενός block και είναι προσπελάσιμη μόνο από τα νήματα του ίδιου block. Εκτός από τους βασικούς τύπους δεδομένων που προσφέρει η γλώσσα προγραμματισμού C η CUDA τους επεκτείνει σε μια διανυσματική μορφή. Έτσι στα ονόματα των βασικών τύπων της C (u)char, (u)short, (u)int, (u)long, (u)float, (u)double προστίθεται ένας αριθμός από το 1 έως το 4 στο τέλος ( ο τύπος double παίρνει μόνο τους αριθμούς 1 και 2) που δείχνει από πόσα στοιχεία αποτελείται ο αντίστοιχος διανυσματικός τύπος. Τα στοιχεία διανυσματικών τύπων δεδομένων που προσφέρει η CUDA είναι προσπελάσιμα από τα γράμματα x, y, z, w αντίστοιχα. Στο παρακάτω απόσπασμα κώδικα φαίνεται η χρήση αυτών των τύπων δεδομένων. // Kernel definition global void VecAdd(float* A, float* B, float* C) { int3 element = make_int3(4,5,6); int field1 = element.x; int field3 = element.z; } Επίσης υπάρχει και άλλος ένας τύπος δεδομένων που χρησιμοποιείται για να ορίζει της διαστάσεις του grid και του block και βασίζεται στον τύπο uint3. Αυτός ο τύπος δεδομένων είναι ο dim3 και έχει την ιδιότητα ότι αν μια διάσταση στην μεταβλητή δεν οριστεί τότε αυτή παίρνει αυτόματα την τιμή 1. Όπως έχει ήδη αναφερθεί στο Κεφάλαιο 3.2 υπάρχουν ήδη κάποιες ορισμένες μεταβλητές που αποθηκεύουν το μέγεθος του grid και του block (griddim και blockdim)καθώς και τους δείκτες του εκάστοτε block μέσα στο grid (blockidx) και του εκάστοτε νήματος μέσα στο block (threadidx). Επίσης υπάρχει και η μεταβλητή warpsize που περιέχει το μέγεθος του warp. Το προγραμματιστικό μοντέλο της CUDA ορίζει ότι υπάρχουν δύο ξεχωριστές μνήμες η host και η device. Ένας kernel μπορεί να λειτουργήσει μόνο με την device μνήμη για αυτό παρέχονται από την CUDA 46

47 συναρτήσεις για την δημιουργία, καταστροφή και αντιγραφή device μνήμης καθώς και για μεταφορά δεδομένων μεταξύ της host και της device μνήμης. Αυτές οι συναρτήσεις είναι οι εξής: cudamalloc() : Χρησιμοποιείται για να δεσμεύσει συγκεκριμένου μεγέθους μνήμη στην device μνήμη και επιστρέφει ένα δείκτη σε αύτη την μνήμη. cudafree() : Χρησιμοποιείται για να απελευθερώσει την device μνήμη που είχε πριν δεσμευτεί με την συνάρτηση cudamalloc. cudamemcpy() : Χρησιμοποιείται για να μεταφέρει δεδομένα μεταξύ της host και της device μνήμης. Ένα παράδειγμα χρήσης των παραπάνω συναρτήσεων φαίνεται στο παρακάτω απόσπασμα κώδικα. // Host code int main() { int N =...; size_t size = N * sizeof(float); // Allocate input vectors h_a and h_b in host memory float* h_a = malloc(size); float* h_b = malloc(size); // Allocate vectors in device memory float* d_a; cudamalloc((void**)&d_a, size); float* d_b; cudamalloc((void**)&d_b, size); float* d_c; cudamalloc((void**)&d_c, size); // Copy vectors from host memory to device memory cudamemcpy(d_a, h_a, size, cudamemcpyhosttodevice); cudamemcpy(d_b, h_b, size, cudamemcpyhosttodevice); // Invoke kernel int threadsperblock = 256; int blockspergrid = (N + threadsperblock 1) / threadsperblock; VecAdd<<<blocksPerGrid, threadsperblock>>>(d_a, d_b, d_c); // Copy result from device memory to host memory // h_c contains the result in host memory cudamemcpy(h_c, d_c, size, cudamemcpydevicetohost); } // Free device memory cudafree(d_a); cudafree(d_b); cudafree(d_c); Ένα σύστημα μπορεί να έχει περισσότερες από μια κάρτες γραφικών, έτσι η CUDA παρέχει συναρτήσεις που απαριθμούν τα devices και παρέχουν τις ιδιότητες τους. Με αυτό τον τρόπο ο προγραμματιστής μπορεί να επιλέξει σε ποιο device θα εκτελέσει κάθε kernel ανάλογα με τις απαιτήσεις που μπορεί να έχει ο κάθε kernel. Οι δύο αυτές συναρτήσεις είναι οι cudagetdevicecount και cudadeviceprop. Επίσης η CUDA προσφέρει μια συνάρτηση για να συγχρονίζει την εκτέλεση των νημάτων. Αυτή η συνάρτηση είναι η 47

48 syncthreads() και επιβάλει σε όλα τα νήματα ενός block να περιμένουν πριν επιτραπεί σε κάποιο να συνεχίσει. Συνήθως αυτή η συνάρτηση χρησιμοποιείται για να συγχρονίσει την πρόσβαση των νημάτων στην shared μνήμη. Οι επεκτάσεις που παρουσιάστηκαν παραπάνω είναι οι πιο βασικές που απαιτούνται για να γραφτεί μια εφαρμογή CUDA. Υπάρχουν και άλλες για πιο εξειδικευμένες λειτουργίες και όποιος θέλει μπορεί να ανατρέξει στο Κεφάλαιο 7 για να βρει περισσότερες αναφορές και έγγραφα για την CUDA. 3.4 Βελτιστοποίηση απόδοσης Τα βήματα που κάνει ένας πολύ-επεξεργαστής για να εκτελέσει μια εντολή για ένα warp νημάτων είναι τα εξής: Διαβάζει την εντολή που πρέπει να εκτελέσει για κάθε νήμα του warp Εκτελεί την εντολή Γράφει τα αποτελέσματα για κάθε νήμα του warp Επομένως για να πετύχει αυξημένη απόδοση ένα πρόγραμμα θα πρέπει να ελαχιστοποιεί την χρήση εντολών που έχουν χαμηλή απόδοση, να μεγιστοποιεί την χρήση του διαθέσιμου εύρους ζώνης μεταφοράς της μνήμης και να επιτρέπει στον χρονοδρομολογητή νημάτων να επικαλύπτει μεταφορές δεδομένων από την μνήμη με μαθηματικές πράξεις. Για να γίνει βέβαια αυτό το πρόγραμμα θα πρέπει να έχει υψηλό αριθμό μαθηματικών πράξεων για κάθε δεδομένο που διαβάζεται από την μνήμη και να υπάρχουν πολλά ενεργά νήματα σε κάθε πολύ-επεξεργαστή. Επίσης οι εντολές ελέγχου της ροής εκτέλεσης ενός προγράμματος (if, switch, do, for, while) μπορούν να επιφέρουν σημαντική μείωση στην απόδοση ενός προγράμματος με το να προκαλούν στα νήματα ενός warp να ακολουθούν διαφορετικό μονοπάτι εκτέλεσης. Όταν συμβαίνει αυτό τα διαφορετικά μονοπάτια εκτέλεσης θα πρέπει να εκτελεστούν σειριακά αυξάνοντας τον συνολικό αριθμό των εντολών εκτέλεσης για το συγκεκριμένο warp. Όταν όλα τα διαφορετικά μονοπάτια εκτέλεσης τελειώσουν και επανέλθουν στο κύριο μονοπάτι εκτέλεσης τότε όλα τα νήματα του warp μπορούν να εκτελούν παράλληλα την ίδια εντολή εκτέλεσης και έτσι να αυξάνει πάλι η απόδοση της εφαρμογής. Το εύρος ζώνης για μεταφορά δεδομένων διαφέρει στα διάφορα είδη μνημών που έχει μια κάρτα γραφικών. Έτσι για την global μνήμη επειδή δεν είναι cached θα πρέπει να ακολουθηθούν μερικές οδηγίες κατά την πρόσβαση σε αυτή την μνήμη για να υπάρξει μέγιστη απόδοση του εύρους ζώνης. Η global μνήμη έχει την ικανότητα να μεταφέρει 32-bit, 64-bit ή 128-bit δεδομένων σε καταχωρητές των πολύεπεξεργαστών με την χρήση μόνο μιας εντολής. Έτσι λοιπόν για να μπορέσει ο μεταγλωττιστής να μετατρέψει την ανάθεση τιμής στην μεταβλητή που φαίνεται στο παρακάτω απόσπασμα κώδικα device type temp[32]; type data = temp[tid]; 48

49 σε μια μοναδική εντολή φορτώματος από την μνήμη στους καταχωρητές θα πρέπει το μέγεθος του type να είναι ίσο με 4, 8 ή 16 και οι μεταβλητές του τύπου δεδομένων type να είναι έχουν διεύθυνση μνήμης πολλαπλάσια του μεγέθους του type. Για τους τύπους δεδομένων που παρέχει η CUDA όπως π.χ. float4, int2 η παραπάνω απαίτηση ισχύει. Ένα άλλο επίσης σημαντικό χαρακτηριστικό της global μνήμης είναι ότι οι ταυτόχρονες προσπελάσεις της μνήμης από τα μισά νήματα ενός warp μπορούν να συγχωνευτούν σε μία ή δύο προσπελάσεις μνήμης. Για τις κάρτες γραφικών με υπολογιστική ικανότητα 1.0 και 1.1 πρέπει να ικανοποιούνται οι παρακάτω τρείς συνθήκες: Τα νήματα πρέπει να προσπελαύνουν είτε λέξεις των 32-bit που έχει ως αποτέλεσμα μια συναλλαγή με την μνήμη μεγέθους 64-byte ή λέξεις των 64-bit που έχει ως αποτέλεσμα μια συναλλαγή με την μνήμη μεγέθους 128-byte ή λέξεις των 128-bit που έχει ως αποτέλεσμα δύο συναλλαγές με την μνήμη μεγέθους 128-byte. Και οι 16 λέξεις θα πρέπει να βρίσκονται στο ίδιο τμήμα της μνήμης μεγέθους ίσο με το μέγεθος της συναλλαγής με την μνήμη ή διπλάσιο όταν πρόκειται για προσπελάσεις λέξεων των 128-bit. Τα νήματα πρέπει να προσπελαύνουν τις λέξεις με συγκεκριμένη ακολουθία, δηλαδή το ν-οστό νήμα στο μισό warp θα πρέπει να προσπελαύνει την ν-οστή λέξη. Για κάρτες γραφικών με υπολογιστική ικανότητα μεγαλύτερη του 1.2 οι προσπελάσεις της global μνήμης από τα μισά νήματα ενός warp συγχωνεύονται σε μια προσπέλαση αρκεί όλες οι λέξεις να βρίσκονται στο ίδιο τμήμα μνήμης μεγέθους: 32 bytes αν τα νήματα προσπελαύνουν 8-bit λέξεις 64 bytes αν τα νήματα προσπελαύνουν 16-bit λέξεις 128 bytes αν τα νήματα προσπελαύνουν 32-bit ή 64-bit λέξεις Στις κάρτες γραφικών με υπολογιστική ικανότητα μεγαλύτερη του 1.2 τα νήματα δεν χρειάζεται να προσπελαύνουν τις λέξεις με συγκεκριμένη ακολουθία, ενώ είναι επίσης εφικτό πολλαπλά νήματα να προσπελαύνουν την ίδια διεύθυνση μνήμης και πάλι να γίνεται η συγχώνευση. Η μνήμη constant είναι cached οπότε το διάβασμα από αυτή την μνήμη κοστίζει πολύ μόνο όταν τα δεδομένα που χρειάζεται να διαβαστούν δεν είναι στην cache (υπάρχει δηλαδή cache miss) αλλιώς η προσπέλαση στοιχίζει περίπου όσο και το διάβασμα ενός καταχωρητή αρκεί βέβαια όλα τα νήματα ενός μισού warp να προσπελαύνουν την ίδια διεύθυνση μνήμης. Σε αντίθετη περίπτωση το κόστος αυξάνει γραμμικά ανάλογα με τον αριθμό των νημάτων που διαβάζουν από διαφορετική θέση. Οι μελλοντικές κάρτες γραφικών ωστόσο για να εκμεταλλευτούν πλήρως την ταχύτητα της constant μνήμης θα πρέπει όλα τα νήματα του warp και όχι τα μισά να προσπελαύνουν την ίδια διεύθυνση μνήμης. Η μνήμη texture είναι και αυτή cached όπως και η constant επομένως το κόστος προσπέλασης είναι το ίδιο με αυτό της μνήμης constant. Ωστόσο η μνήμη texture είναι βελτιστοποιημένη για να διαβάζει δυσδιάστατους πίνακες δεδομένων. Έτσι όταν τα νήματα ενός warp διαβάζουν από διευθύνσεις μνήμης που είναι κοντά η μία στην άλλη τότε επιτυγχάνεται η μέγιστη απόδοση. Επίσης ένα άλλο σημαντικό 49

50 χαρακτηριστικό της texture μνήμης είναι ότι έχει σταθερή καθυστέρηση στο διάβασμα των δεδομένων ακόμα και αν αυτό το διάβασμα επιφέρει cache miss. Η μνήμη shared βρίσκεται on-chip οπότε η προσπέλαση σε αυτήν είναι πολύ πιο γρήγορη συγκριτικά με την προσπέλαση στην μνήμη global. Στην πραγματικότητα η προσπέλαση στην shared μνήμη από όλα τα νήματα ενός warp στοιχίζει όσο και η προσπέλαση σε ένα καταχωρητή αρκεί να μην υπάρχουν bank conflicts ανάμεσα στα νήματα. Για να πετύχει υψηλή απόδοση η shared μνήμη είναι χωρισμένη σε ίσου μεγέθους τμήματα τα οποία ονομάζονται banks και τα οποία μπορούν να προσπελαστούν ταυτοχρόνως. Έτσι αν οι προσπελάσεις σε n διαφορετικές διευθύνσεις της shared μνήμης πέφτουν σε n διαφορετικά banks τότε αυτές οι προσπελάσεις μπορούν να εξυπηρετηθούν ταυτοχρόνως επιφέροντας n φορές αύξηση στην απόδοση της μνήμης. Ωστόσο αν δύο ή περισσότερα νήματα θέλουν να διαβάσουν από διευθύνσεις μνήμης που πέφτουν στο ίδιο bank τότε υπάρχει bank conflict και οι διευθύνσεις διαβάζονται σειριακά με αποτέλεσμα να υπάρχει μειωμένη απόδοση. Τα banks της shared μνήμης οργανώνονται με τέτοιο τρόπο ώστε διαδοχικές λέξεις των 32-bits να ανατίθενται σε διαδοχικά banks της μνήμης. Έτσι για κάρτες γραφικών με επεξεργαστική ικανότητα 1.x και μέγεθος warp 32 νήματα έχει 16 banks shared μνήμης. Μια αίτηση προσπέλασης της shared μνήμης για ένα warp σπάει σε δύο αιτήσεις, μια για τα πρώτα μισά νήματα του warp και άλλη μια για τα δεύτερα μισά νήματα του warp. Επομένως δεν μπορεί να υπάρξει bank conflict μεταξύ νημάτων που το ένα ανήκει στο πρώτο μισό του warp και άλλο στο δεύτερο μισό του ίδιου warp. Επίσης η shared μνήμη έχει ένα μηχανισμό με τον οποίο μια λέξη των 32-bit μπορεί να διαβαστεί και να μεταδοθεί ταυτοχρόνως σε αρκετά νήματα κατά την διάρκεια μιας προσπέλασης μνήμης. Τα διαφορετικά είδη προσπέλασης της shared μνήμης φαίνονται στην Εικόνα

51 Εικόνα 3.6: Αριστερά πρόσβαση χωρίς bank conflict. Κέντρο πρόσβαση με bank conflict. Δεξιά πρόσβαση χωρίς bank conflict λόγω μηχανισμού μετάδοσης. Η πρόσβαση στους καταχωρητές δεν επιφέρει κόστος στην απόδοση μια εφαρμογής ωστόσο μπορεί να υπάρξουν καθυστερήσεις λόγω εξαρτήσεων read-after-write. Αυτές όμως οι καθυστερήσεις μπορούν να αγνοηθούν αν υπάρχουν τουλάχιστον 192 ενεργά νήματα ανά πολύ-επεξεργαστή ώστε να κρύβουν της καθυστερήσεις. Επίσης μπορούν να υπάρξουν καθυστερήσεις λόγω bank conflict στην μνήμη των καταχωρητών. Το μόνο που μπορεί να κάνει ο προγραμματιστής μιας εφαρμογής για να αποφύγει αυτές τις καθυστερήσεις είναι να επιλέγει αριθμό νημάτων ανά μπλοκ που να είναι πολλαπλάσιο του 64. Για να επιτευχθεί μέγιστη χρησιμοποίηση των υπολογιστικών πόρων της κάρτας γραφικών θα πρέπει να επιλεγεί προσεκτικά ο αριθμός των νημάτων ανά μπλοκ καθώς και ο αριθμός των μπλοκ ενός grid. Έτσι θα 51

52 πρέπει καταρχήν ο αριθμός των μπλοκ τουλάχιστον να είναι όσος και ο αριθμός των πολύ-επεξεργαστών. Τρέχοντας όμως ένα μπλοκ ανά πολύ-επεξεργαστή θα έχει ως αποτέλεσμα ο πολύ-επεξεργαστής να μην χρησιμοποιείται κατά την διάρκεια που υπάρχει συγχρονισμός των νημάτων και κατά το διάβασμα από την μνήμη της συσκευής. Έτσι είναι προτιμότερο να υπάρχουν δύο ή περισσότερα μπλοκ ανά πολύεπεξεργαστή ώστε να υπάρχει επικάλυψη μεταξύ των μπλοκ που περιμένουν και αυτών που μπορούν να εκτελεστούν. Επίσης θα πρέπει η ποσότητα της shared μνήμης που έχει εκχωρηθεί για κάθε μπλοκ να είναι το πολύ η μισή της συνολικής ποσότητας shared μνήμης ανά πολύ-επεξεργαστή. Συνήθως ο συνολικός αριθμός των μπλοκ ανά grid πρέπει να είναι τουλάχιστον 100 ενώ 1000 μπλοκ είναι καλύτερα ώστε οι εφαρμογές να εκμεταλλευτούν την αρχιτεκτονική της επόμενης γενιάς των καρτών γραφικών. Ωστόσο με υψηλό αριθμό μπλοκ ανά grid ο αριθμός των νημάτων ανά μπλοκ θα πρέπει να είναι πολλαπλάσιος του 64 όπως αναφέρθηκε στην προηγούμενη παράγραφο αλλά όχι πολύ μεγάλος γιατί υπάρχει κίνδυνος να μην υπάρχουν αρκετοί καταχωρητές ανά νήμα ώστε να τρέξει ο kernel. Συνήθως ο αριθμός των νημάτων ανά μπλοκ είναι 192 ή 256. Η βελτιστοποίηση της απόδοσης μιας εφαρμογής CUDA κινείται γύρω από τους παρακάτω τρεις βασικούς άξονες: Μεγιστοποίηση της παράλληλης εκτέλεσης Βελτιστοποίηση της χρήσης της μνήμης Βελτιστοποίηση της χρήσης των εντολών Η μεγιστοποίηση της παράλληλης εκτέλεσης γίνεται με την δόμηση του αλγορίθμου κατά τέτοιο τρόπο ώστε να επιτευχθεί όσο το δυνατόν περισσότερο μέγιστη παραλληλία στα δεδομένα. Αφού αποκαλυφθεί η παραλληλία στα δεδομένα θα πρέπει να αντιστοιχιστεί στην επεξεργαστική ικανότητα της κάρτας γραφικών όσο πιο αποδοτικά γίνεται με προσεκτική επιλογή των παραμέτρων εκτέλεσης του kernel. Η βελτιστοποίηση της χρήσης της μνήμης γίνεται με την ελαχιστοποίηση των μεταφορών μεταξύ της μνήμης του host και της μνήμης της συσκευής. Επίσης θα πρέπει να ελαχιστοποιηθεί όσο γίνεται και η χρήση της global μνήμης με χρησιμοποίηση όσο γίνεται περισσότερο της shared μνήμης. Όσον αφορά την βελτιστοποίηση της χρήσης εντολών θα πρέπει να αποφεύγονται αριθμητικές εντολές με χαμηλή απόδοση και εντολές ελέγχου της ροής εκτέλεσης λόγω της SIMT φύσης των καρτών γραφικών. 3.5 Πλεονεκτήματα και μειονεκτήματα της CUDA Το πραγματικό πρόβλημα με την παράλληλη επεξεργασία είναι ότι υπάρχουν πάρα πολλές λύσεις ασύμβατες μεταξύ τους με αποτέλεσμα να είναι δύσκολο να κάποιος να κάνει την κατάλληλη επιλογή ανάλογα με τις δικές του απαιτήσεις και δεδομένα. Επίσης στην επιλογή κάποιας λύσης εκτός από την αρχιτεκτονική του επεξεργαστή παίζει επίσης σημαντικό ρόλο το πρόγραμμα νέων επεξεργαστών του κατασκευαστή, τα εργαλεία προγραμματιστικής ανάπτυξης που παρέχονται, η ποσότητα του ειδικού κώδικα που χρειάζεται για μετατροπή του απλού αλγόριθμου σε παράλληλο, ο βαθμός συμβατότητας του κώδικα με μελλοντικές εκδόσεις του επεξεργαστή καθώς και η αναμενόμενη μακροβιότητα του κατασκευαστή του επεξεργαστή. Σε σχέση λοιπόν με όλα τα παραπάνω η λύση της Nvidia στην παράλληλη επεξεργασία είναι η καλύτερη όπως θα αναλυθεί και παρακάτω. Η παραλληλία δεν είναι κάτι καινούργιο 52

53 για τις κάρτες γραφικών επομένως η Nvidia έχει μεγάλη εμπειρία στον τομέα αυτό και σε συνδυασμό με το ότι η Nvidia εισάγει μια νέα γενιά καρτών γραφικών κάθε περίπου 18 μήνες έχει σαν αποτέλεσμα να υπάρχουν πάνω από 50 εκατομμύρια CUDA ικανές κάρτες γραφικών. Έτσι ο καθένας μπορεί να έχει πρόσβαση σε ένα φτηνό παράλληλο επεξεργαστή αλλά και τα προγράμματα που γράφονται για κάρτες γραφικών με την CUDA μπορούν να εκτελεστούν σε μια πληθώρα υπολογιστών. Επίσης η Nvidia είναι μια μεγάλη εταιρία που δεν κινδυνεύει με κλείσιμο στο άμεσο μέλλον ενώ η CUDA αποκτάει μια ιδιαίτερη δυναμική μεταξύ των προγραμματιστών αλλά και της πανεπιστημιακής κοινότητας για υψηλής απόδοσης υπολογιστικές εφαρμογές. Τέλος είναι επίσης πολύ σημαντικό το ότι η CUDA παρέχεται δωρεάν από την Nvidia. Τα μειονεκτήματα της CUDA από την άλλη είναι πολύ λίγα. Οι κάρτες γραφικών μόλις πριν λίγο καιρό γίνανε γενικού σκοπού προγραμματιζόμενες συσκευές (GP-GPU) με αποτέλεσμα οι προγραμματιστικές διεπαφές και τα εργαλεία να μην έχουν αναπτυχθεί πλήρως. Επίσης οι κάρτες γραφικών δεν υποστηρίζουν ακόμα διπλή ακρίβεια στις πράξεις δεδομένων αν και η καινούργια γενιά των καρτών γραφικών της Nvidia με την αρχιτεκτονική Fermi υποστηρίζει τέτοιου είδους πράξεις. Ένα ακόμα σημαντικό μειονέκτημα είναι ότι οι κάρτες γραφικών περιέχουν μεγάλους επεξεργαστές οι οποίοι καταναλώνουν πολύ ενέργεια για να λειτουργήσουν και παράγουν μεγάλες ποσότητες θερμότητας. Επομένως η επέκταση συστημάτων με πολλές κάρτες γραφικών ώστε να αυξηθεί η απόδοση πρέπει να γίνεται με προσεκτική επιλογή στα υποσυστήματα ψύξης και ενέργειας του υπολογιστή. Τέλος η CUDA είναι μια τεχνολογία που καλύπτεται από δίπλωμα ευρεσιτεχνίας (παρόλο που διατίθεται δωρεάν) και λειτουργεί μόνο με τις κάρτες γραφικών της Nvidia γι αυτό κάποιοι προγραμματιστές περιμένουν να ωριμάσει η OpenCL που είναι μια λύση ανεξάρτητη από αρχιτεκτονικές και υποστηρίζεται από αρκετούς κατασκευαστές (μεταξύ αυτών και η Nvidia). Όμως την παρούσα χρονική στιγμή η OpenCL βρίσκεται σε πολύ πρώιμο στάδιο σε σχέση με την CUDA οπότε και για αυτή την διπλωματική επιλέχθηκε η λύση της Nvidia. 53

54 4 ΠΑΡΑΛΛΗΛΟΠΟΙΗΣΗ ΑΛΓΟΡΙΘΜΟΥ AHO-CORASICK Για την παραλληλοποίηση του αλγορίθμου θα πρέπει να ληφθεί υπόψη η αρχιτεκτονική του υλικού στην οποία προορίζεται να εκτελεστεί ο τροποποιημένος αλγόριθμος. Με αυτό τον τρόπο οι αλλαγές που θα γίνουν στον πηγαίο κώδικα θα έχουν ως αποτέλεσμα την εκμετάλλευση των ιδιαίτερων χαρακτηριστικών της αρχιτεκτονικής και την αύξηση της απόδοσης του αλγορίθμου. Η αρχιτεκτονική των καρτών γραφικών της Nvidia παρουσιάστηκε στο Κεφάλαιο 3, σε αυτό το κεφάλαιο θα παρουσιαστούν οι αλλαγές που πρέπει να γίνουν ώστε ο κώδικας που θα προκύψει να εκμεταλλεύεται στο έπακρο την αρχιτεκτονική των καρτών γραφικών της Nvidia. Για την τροποποίηση του κλασικού αλγορίθμου Aho-Corasick θα χρησιμοποιηθούν οι προγραμματιστικές διεπαφές (APIs) καθώς και οι επεκτάσεις τις γλώσσας προγραμματισμού C που παρουσιάστηκαν στο προηγούμενο κεφάλαιο. 4.1 Εύρεση παραλληλίας Όπως έχει ήδη προαναφερθεί οι κάρτες γραφικών είναι ιδανικές για να εκτελούν μια εντολή ταυτόχρονα σε διαφορετικά δεδομένα (SIMD), επομένως το πρώτο βήμα που θα πρέπει να γίνει είναι η εύρεση παραλληλίας στα δεδομένα του αλγορίθμου. Η CUDA χειρίζεται τα νήματα με αυτόματο τρόπο όμως αυτό δεν απαλλάσσει τους προγραμματιστές από το να συμπεριλάβουν στην ανάλυση τους τα νήματα. Έτσι θα πρέπει να χωρίσουν τα δεδομένα σε μικρότερα κομμάτια για διανομή μεταξύ των νηματικών επεξεργαστών. Ο αλγόριθμος Aho-Corasick αποτελείται όμως από δυο φάσεις, την φάση προεργασίας και την φάση εύρεσης, οπότε θα πρέπει να εξεταστεί αν υπάρχει κάποια παραλληλία στα δεδομένα σε αυτές τις δύο φάσεις. Φάση Προεργασίας Στην φάση προεργασίας ο αλγόριθμος κατασκευάζει τους βασικούς πίνακες που συνθέτουν την μηχανή πεπερασμένων καταστάσεων που χρησιμοποιεί αργότερα για την εύρεση των μοτίβων στο κείμενο εισόδου. Ο ψευδοκώδικας των αλγορίθμων που κατασκευάζουν τους πίνακες παρουσιάστηκε στο Κεφάλαιο Σε αυτό το κεφάλαιο θα αναλυθούν αυτοί οι ψευδοκώδικες για να βρεθεί τυχόν παραλληλία στα δεδομένα. Αλγόριθμος κατασκευής συνάρτησης goto Ο ψευδοκώδικας του αλγορίθμου παρουσιάζεται ξανά για λόγους ευκολίας παρακάτω. begin end newstate = 0 for i = 1 until k do enter(y[i]) for all a such that g(0, a) = fail do g(0, a) = 0 54

55 procedure enter(a[1] a[2]... a[m]): begin state = 0; j = 1 while g(state, a[j])!= fail do begin state = g (state, a[j]) j = j + 1 end for p = j until m do begin newstate = newstate + 1 g(state, a[p]) = newstate state = newstate end output(state) = { a[1] a[2]... a[m]} end Η μεγαλύτερη κατανάλωση χρόνου και άρα η μείωση της απόδοσης των αλγορίθμων οφείλεται κατά κύριο λόγο στους βρόγχους. Επομένως αν οι βρόγχοι του παραπάνω αλγόριθμου είναι δυνατόν να παραλληλοποιηθούν και να εκτελεστούν ταυτόχρονα τότε θα αυξηθεί κατακόρυφα η απόδοση του αλγορίθμου. Πρώτος βρόγχος είναι ο for i = 1 until k do enter(y[i]) όπου y[i] είναι το ι-οστό μοτίβο από τα k που αναγνωρίζει ο αλγόριθμος. Αυτός ο βρόγχος μπορεί πολύ εύκολα να παραλληλοποιηθεί αν ανατεθεί σε k νήματα να τρέξουν παράλληλα την συνάρτηση enter. Επομένως θα πρέπει τώρα να αναλυθεί η συνάρτηση enter για να επιβεβαιωθεί μήπως υπάρχει σύγκρουση στα δεδομένα που αποτρέπουν την παράλληλη εκτέλεση της συνάρτησης. Η συνάρτηση enter δεν γίνεται να εκτελεστεί παράλληλα αφού για δύο ή περισσότερα μοτίβα που αρχίζουν με το ίδιο γράμμα και g(0,a) είναι fail θα έχει ως αποτέλεσμα η συνθήκη στο βρόγχο while g(state, a[j])!= fail do να μην είναι αληθής με αποτέλεσμα δύο ή περισσότερα νήματα να εκτελέσουν παράλληλα τον κώδικα for p = j until m do begin newstate = newstate + 1 g(state, a[p]) = newstate state = newstate end Αυτό όμως δημιουργεί το πρόβλημα ότι η μεταβλητή g(state,a[p]) παίρνει τελικά την τιμή που της δίνει το τελευταίο νήμα που εκτελέστηκε, ενώ αν ο κώδικας είχε εκτελεστεί σειριακά τότε για τα επόμενα μοτίβα μετά το πρώτο αντί να εκτελεστεί ο παραπάνω βρόγχος θα έπρεπε να είχε εκτελεστεί ο βρόγχος while g(state, a[j])!= fail do begin state = g (state, a[j]) j = j

56 end Επομένως ο παραπάνω αλγόριθμος δεν μπορεί να εκτελεστεί παράλληλα λόγω εξαρτήσεων ελέγχου και δεδομένων. Αλγόριθμος κατασκευής συνάρτησης failure Ο ψευδοκώδικας του αλγορίθμου παρουσιάζεται ξανά παρακάτω για λόγους ευκολίας. begin end queue = empty for each a such that g(0, a) = s!= 0 do begin queue = queue U {s} f(s) = 0 end while queue!= empty do begin let r be the next state in queue queue = queue - {r} for each a such that g(r, a) = s!= fail do begin queue = queue U {s} state = f(r) while g(state, a) = fail do state = f(state) f(s) = g(state, a) output(s) = output(s) U output(f(s)) end end Ο πρώτος βρόγχος του αλγορίθμου μπορεί πολύ εύκολα να παραλληλοποιηθεί αφού το μέγεθος του πίνακα goto είναι γνωστό, επομένως αν κάθε χαρακτήρας a ανατεθεί σε ένα νήμα τότε σε χρόνο O(1) μπορεί να έχει εκτελεστεί ο βρόγχος. Το πρόβλημα έγκειται στον δεύτερο βρόγχο που δεν είναι γνωστό κάθε χρονική στιγμή πόσα στοιχεία περιέχει η ουρά queue ώστε να αντιστοιχηθούν όλα αυτά τα στοιχεία ένα σε κάθε νήμα. Ο αλγόριθμος κατασκευής της συνάρτησης failure κάνει μια αναζήτηση κατά πλάτος κάθε φορά ξεκινώντας από ένα κόμβο της συνάρτησης goto που βρίσκει στην ουρά και όσους κόμβους βρίσκει από το κόμβο που ξεκίνησε τους βάζει πάλι στην ουρά. Επομένως δεν είναι γνωστό από την αρχή πόσα στοιχεία περιέχει η ουρά κάθε χρονική στιγμή και άρα δεν μπορεί να εκτελεστεί όλος ο βρόγχος παράλληλα. Επομένως ούτε και αυτός ο αλγόριθμος μπορεί να εκτελεστεί παράλληλα. Φάση Εύρεσης Στην φάση εύρεσης ο αλγόριθμος χρησιμοποιεί της συναρτήσεις που κατασκευάστηκαν στην φάση προεργασίας και ψάχνει μέσα στο κείμενο που του έχει δοθεί ως είσοδος για τα μοτίβα. Ο αλγόριθμος που εκτελεί την εύρεση παρουσιάζεται ξανά για λόγους ευκολίας παρακάτω. 56

57 begin end state = 0 for i = 1 until n do begin while g(state, a[i]) = fail do state = f(state) state = g (state, a[i]) if output (state)!= empty then begin print i print output (state) end end Ο αλγόριθμος εύρεσης διαβάζει από την είσοδο ένα χαρακτήρα κάθε φορά και χρησιμοποιώντας τις συναρτήσεις goto, failure και την τωρινή κατάσταση υπολογίζει την επόμενη κατάσταση στην οποία πρέπει να πέσει η μηχανή πεπερασμένων καταστάσεων. Επομένως ούτε αυτός ο αλγόριθμος μπορεί να παραλληλοποιηθεί αφού κάθε χαρακτήρας από την είσοδο πρέπει να διαβαστεί σειριακά για κάνει η μηχανή πεπερασμένων καταστάσεων τις σωστές μεταβάσεις. Ωστόσο ο αλγόριθμος εύρεσης μπορεί έμμεσα να παραλληλοποιηθεί αν σπάσει η είσοδος σε πακέτα και κάθε πακέτο ανατεθεί να εκτελεστεί παράλληλα σε ένα νήμα. Τα νήματα θα χρησιμοποιήσουν όλα τις ίδιες συναρτήσεις goto και failure άλλα το κάθε νήμα θα έχει μια δικιά του μηχανή πεπερασμένων καταστάσεων και μια δικιά του κατάσταση στην οποία θα βρίσκεται η μηχανή πεπερασμένων καταστάσεων. Επομένως οι αλγόριθμοι της φάσης προεργασίας θα εκτελούνται στο host περιβάλλον και μετά οι πίνακες που ορίζουν τις συναρτήσεις goto, failure και output θα μεταφέρονται στην κάρτα γραφικών όπου και στην οποία θα εκτελείται παράλληλα ο τροποποιημένος αλγόριθμος εύρεσης. Τα αποτελέσματα στην συνέχεια θα μεταφέρονται από την κάρτα γραφικών πίσω στο host περιβάλλον όπου και θα αποθηκεύονται σε κατάλληλο αρχείο. 4.2 Παρουσίαση παράλληλου κώδικα Παρουσίαση δεδομένων που χρησιμοποιεί ο κώδικας Ο αλγόριθμος aho-corasick χρησιμοποιεί μια μηχανή πεπερασμένων καταστάσεων που αναπαριστά τα μοτίβα. Η μηχανή αυτή είναι ένας πίνακας όπου κάθε γραμμή του πίνακα αντιπροσωπεύει μία κατάσταση. Σε αυτή την υλοποίηση του αλγορίθμου επιλέχτηκε ως μέγιστος αριθμός καταστάσεων Αυτός ο αριθμός καταστάσεων επαρκεί ώστε η μηχανή πεπερασμένων καταστάσεων να μπορεί να αναγνωρίσει μέχρι και διαφορετικά μοτίβα. Οι χαρακτήρες που αναγνωρίζονται στα αρχεία εισόδου είναι το extended ASCII σύνολο των 256 χαρακτήρων. Επίσης το μέγιστο μήκος ενός μοτίβου είναι 1024 χαρακτήρες, ενώ ο αριθμός των αποτελεσμάτων που αποθηκεύετε από των κώδικα είναι 320. Ωστόσο ο αλγόριθμος δεν σταματάει να εκτελείται μέχρι να τελειώσει το αρχείο εισόδου αλλά αποθηκεύονται μόνο τα πρώτα 320 αποτελέσματα. 57

58 Τα αρχεία εισόδου σπάνε σε 1024 πακέτα ίδιου μεγέθους. Το μέγεθος των πακέτων εξαρτάται από το μέγεθος του αρχείου εισόδου. Τα αρχεία εισόδου είναι αρχεία κειμένου που περιέχουν μόνο extended ASCII χαρακτήρες. Ο κώδικας του αλγόριθμου aho-corasick εκτελείται παράλληλα στην κάρτα γραφικών για τα 1024 πακέτα με αποτέλεσμα να έχουμε αύξηση στην απόδοση. Επομένως τα δύο κύρια δεδομένα που χρησιμοποιεί ο αλγόριθμος είναι η μηχανή πεπερασμένων καταστάσεων και τα πακέτα εισόδου. Αυτά θα πρέπει να αποθηκευτούν στην κάρτα γραφικών για να μπορέσει να εκτελεστεί στην συνέχεια ο κώδικας του αλγορίθμου στους επεξεργαστικούς πυρήνες της κάρτας γραφικών. Επίσης στην κάρτα γραφικών θα πρέπει να αποθηκευτούν και τα αποτελέσματα από την εκτέλεση του αλγόριθμου με σκοπό να μεταφερθούν έπειτα πίσω στο host περιβάλλον. Επιλογή τύπου μνήμης της κάρτας γραφικών Όπως αναφέρθηκε στο Κεφάλαιο 3 η κάρτα γραφικών έχει τέσσερα διαφορετικά επίπεδα μνήμης με διαφορετικές επιδόσεις η κάθε μια. Επομένως η επιλογή του τύπου μνήμης που θα χρησιμοποιήσει περισσότερο ο κώδικας θα έχει επίπτωση στην απόδοση του κώδικα. Η μηχανή πεπερασμένων καταστάσεων που αποτελείται από έναν πίνακα μόνο διαβάζεται από την μνήμη επομένως ένας κατάλληλος τύπος μνήμης στην κάρτα γραφικών θα ήταν η μνήμη constant. Η μνήμη constant είναι cached και τόσο γρήγορη όσο η μνήμη shared. Ωστόσο το μειονέκτημα αυτής της μνήμης είναι ότι είναι πολύ μικρή σε μέγεθος μόνο 64KB, ενώ η μηχανή πεπερασμένων καταστάσεων έχει μέγεθος περίπου 15MB. Για τον ίδιο λόγο του μεγέθους αποκλείεται και η μνήμη shared. Επομένως η μόνη μνήμη που μπορεί να χωρέσει η μηχανή πεπερασμένων καταστάσεων είναι η μνήμη global. Τα αρχεία εισόδου σπάνε σε πακέτα ωστόσο τα πακέτα πρέπει να βρίσκονται ταυτόχρονα στην κάρτα γραφικών διότι ο αλγόριθμος εκτελείται παράλληλα για όλα τα πακέτα. Τα πακέτα όπως και η μηχανή πεπερασμένων καταστάσεων μόνο διαβάζονται επομένως μία κατάλληλη θέση αποθήκευσης θα ήταν στην μνήμη constant της κάρτας γραφικών, όμως αυτό δεν είναι δυνατόν λόγω πάλι του μικρού μεγέθους της μνήμης. Επομένως τα πακέτα θα πρέπει να αποθηκευτούν και αυτά στην μνήμη global. Τα αποτελέσματα είναι τα πρώτα 320 για κάθε πακέτο επομένως αφού έχουμε 1024 πακέτα το μέγεθος των αποτελεσμάτων είναι μεγαλύτερο από την shared μνήμη άρα κάθε φορά που υπάρχει ένα αποτέλεσμα θα πρέπει να αποθηκεύεται κατ ευθείαν στην μνήμη global. Επομένως και οι τρεις κύριες δομές δεδομένων του αλγορίθμου θα πρέπει να αποθηκευτούν στην μνήμη global που είναι η πιο αργή από τις τέσσερις με αποτέλεσμα να υπάρχει αρνητική επίπτωση στην απόδοση εκτέλεσης του αλγορίθμου. Στο επόμενο Κεφάλαιο 4.3 παρουσιάζονται τεχνικές για να βελτιωθεί αυτή η αρνητική επίπτωση από την αργή μνήμη global. 4.3 Επιλογή παραμέτρων εκτέλεσης και βελτιστοποιήσεις στον κώδικα Επιλογή παραμέτρων εκτέλεσης Όπως παρουσιάστηκε στο Κεφάλαιο 3.2 τα προγράμματα που εκτελούνται στην κάρτα γραφικών σπάνε σε μικρότερα μπλοκ τα οποία εκτελούνται παράλληλα στους πολύ-επεξεργαστές της κάρτας γραφικών. Κάθε 58

59 Multiprocessor Warp Occupancy Ολοκληρωμένα Συστήματα Υλικού Λογισμικού Πανεπιστήμιο Πατρών μπλοκ περιέχει έναν αριθμό από νήματα τα οποία εκτελούνται παράλληλα στις επεξεργαστικές μονάδες του κάθε πολύ-επεξεργαστή. Επομένως η επιλογή παραμέτρων εκτέλεσης έγκειται στην επιλογή του αριθμού των μπλοκ και του αριθμού των νημάτων που θα περιέχει κάθε μπλοκ. Κάθε κάρτα γραφικών έχει διαφορετική επεξεργαστική ικανότητα άρα ανάλογα με τις παραμέτρους εκτέλεσης ο αλγόριθμος θα έχει και διαφορετική απόδοση. Για παράδειγμα αν μια κάρτα έχει 30 πολύ-επεξεργαστές και ο αριθμός των μπλοκ που επιλεχθεί είναι 2 τότε απόδοση θα είναι μειωμένη γιατί δεν θα χρησιμοποιούνται όλοι οι πολύεπεξεργαστές της κάρτας γραφικών. Ωστόσο η επιλογή των παραμέτρων εκτέλεσης δεν είναι εύκολη αφού η επιλογή του αριθμού των νημάτων κάθε μπλοκ εξαρτάται και από τον αριθμό των καταχωρητών που χρησιμοποιεί κάθε νήμα καθώς επίσης και το μέγεθος την μνήμης shared. Η Nvidia για να βοηθήσει τους προγραμματιστές να επιλέγουν κάθε φορά τις βέλτιστες παραμέτρους εκτέλεσης έχει δημιουργήσει ένα εργαλείο το Cuda Occupancy Calculator. Εισάγοντας σε αυτό το εργαλείο την επεξεργαστική ικανότητα, των αριθμό των νημάτων ανά μπλοκ, τους καταχωρητές ανά νήμα και το μέγεθος την μνήμης shared ανά μπλοκ παρουσιάζονται διάφορες γραφικές παραστάσεις που βοηθούν τον προγραμματιστή να επιλέξει τις βέλτιστες παραμέτρους εκτέλεσης. Για την περίπτωση του αλγορίθμου aho-corasick όπως φαίνεται και από το Κεφάλαιο 4.1 θα πρέπει ο αλγόριθμος να εκτελείται παράλληλα για όλα τα πακέτα εισόδου. Επομένως αφού κάθε νήμα θα ψάχνει σε ένα πακέτο και τα πακέτα εισόδου είναι 1024 θα πρέπει να επιλεγεί ένας αριθμός νημάτων ανά μπλοκ που να διαιρείται με το Η κάρτα γραφικών στην οποία θα εκτελεστεί ο αλγόριθμος είναι επεξεργαστικής ικανότητας 1.3, δηλαδή έχει 30 πολύ-επεξεργαστικούς πυρήνες, bytes μνήμη shared ανά μπλοκ και μέγιστο αριθμό νημάτων ανά μπλοκ 512. Άρα θα πρέπει ο αριθμός νημάτων ανά μπλοκ να είναι μικρότερος ή ίσος από 512. Επιλέγοντας αριθμό νημάτων ανά μπλοκ 128 τότε ο αριθμός των μπλοκ θα είναι 8. Επίσης από την μεταγλώττιση του κώδικα με την ενεργοποίηση του PTXAS flag βρίσκουμε ότι ο αριθμός των καταχωρητών ανά νήμα που χρησιμοποιεί ο αλγόριθμος είναι 7 και το μέγεθος της μνήμης shared είναι Εισάγοντας αυτό τα δεδομένα στον εργαλείο της Nvidia παράγονται οι παρακάτω γραφικές παραστάσεις. 32 Varying Block Size My Block Size Threads Per Block 59

60 Multiprocessor Warp Occupancy Multiprocessor Warp Occupancy Ολοκληρωμένα Συστήματα Υλικού Λογισμικού Πανεπιστήμιο Πατρών 32 Varying Register Count My Register Count Registers Per Thread 32 Varying Shared Memory Usage My Shared Memory Shared Memory Per Block Επίσης από το Cuda Occupancy Calculator φαίνεται ότι η χρησιμοποίηση του κάθε πολύ-επεξεργαστή ανέρχεται στο 100%. Επομένως οι παράμετροι εκτέλεσης με αριθμό νημάτων ανά μπλοκ 128 και αριθμό μπλοκ 8 είναι βέλτιστες για κάρτες γραφικών με επεξεργαστική ικανότητα 1.3. Βελτιστοποιήσεις μνήμης global Η μνήμη global είναι πολύ αργή σε σχέση με την μνήμη shared και constant, οπότε για να βελτιωθεί λίγο η απόδοση θα χρησιμοποιηθούν διάφορες τεχνικές που αναφέρονται παρακάτω. Κάθε ένα από τα

61 πακέτα επεξεργάζεται ταυτοχρόνως από ένα διαφορετικό νήμα στην κάρτα γραφικών. Όλα τα νήματα ζητούν να διαβάσουν από μια θέση από τον πίνακα που αντιπροσωπεύει την μηχανή πεπερασμένων καταστάσεων του αλγορίθμου. Από ποια θέση του πίνακα θα διαβάσει το κάθε νήμα εξαρτάται κάθε φορά από τον χαρακτήρα εισόδου που διάβασε από το πακέτο και από την τωρινή κατάσταση στην οποία βρίσκεται η μηχανή πεπερασμένων καταστάσεων. Κάθε νήμα έχει την δική του κατάσταση στην μηχανή πεπερασμένων καταστάσεων. Επομένως το διάβασμα από την πίνακα που είναι αποθηκευμένη η μηχανή πεπερασμένων καταστάσεων γίνεται με τυχαίο τρόπο. Ο μόνος τρόπος λοιπόν για βελτιωθεί λίγο η απόδοση είναι να αποθηκευτεί η μηχανή πεπερασμένων καταστάσεων σαν μνήμη texture. Η αποθήκευση με την μορφή μνήμης texture έχει το πλεονέκτημα ότι είναι cached με μέγεθος 8KB οπότε αν έχουμε cache hit αυξάνουμε την απόδοση κατά το διάβασμα της μηχανής πεπερασμένων καταστάσεων. Ο αλγόριθμος κάθε φορά διαβάζει τον επόμενο χαρακτήρα από τα 1024 πακέτα και ανάλογα με τον χαρακτήρα που διάβασε κάνει και την ανάλογη μετάβαση στην μηχανή πεπερασμένων καταστάσεων του κάθε νήματος. Επομένως κάθε νήμα διαβάζει κάθε φορά από συγκεκριμένη θέση στην global μνήμη που είναι αποθηκευμένα τα πακέτα. Άρα αποθηκεύοντας τα πακέτα με κατάλληλη μορφή τότε θα έχουμε coalesced access στην μνήμη από τα νήματα και αύξηση στην απόδοση. Για να γίνει αυτό είναι απαραίτητο τα πακέτα να αποθηκευτούν σε ένα πίνακα ακολουθώντας αποθήκευση κατά στήλες. Έτσι στην πρώτη γραμμή του πίνακα θα είναι αποθηκευμένος ο πρώτος χαρακτήρας κάθε πακέτου, στην δεύτερη γραμμή του πίνακα θα είναι αποθηκευμένος ο δεύτερος χαρακτήρας του κάθε πακέτου κοκ. Χρήση μνήμης shared Η μηχανή πεπερασμένων καταστάσεων χρειάζεται μια μεταβλητή για να αποθηκεύει την τρέχουσα κατάσταση της. Κάθε νήμα έχει την δικιά του κατάσταση στην μηχανή πεπερασμένων καταστάσεων επομένως χρειάζεται ένας πίνακας τόσων θέσεων όσα και τα νήματα. Επειδή αυτός ο πίνακας που κρατάει την κατάσταση για κάθε νήμα διαβάζεται και γράφεται αρκετές φορές για κάθε χαρακτήρα που διαβάζει το νήμα από το πακέτο, θα πρέπει να αποθηκεύεται στην μνήμη shared για να μην έχουμε καθυστέρηση κατά της προσπελάσεις του πίνακα από τον κώδικα. Επίσης ένας άλλος πίνακας που αποθηκεύεται στην μνήμη shared για τον ίδιο λόγο είναι ο πίνακας που κρατάει τον αριθμό τον αποτελεσμάτων για κάθε νήμα. Τέλος ένα ακόμα δεδομένο που χρειάζεται να αποθηκευτεί στην μνήμη είναι ο επόμενος χαρακτήρας που διαβάζουν τα νήματα από τα πακέτα εισόδου. Η μνήμη shared είναι οργανωμένη σε 16 banks των 32-bit το καθένα, όμως οι χαρακτήρες που διαβάζουν τα νήματα από τα πακέτα εισόδου είναι 8-bit, επομένως για να μην υπάρχει bank conflict θα πρέπει να χρησιμοποιηθεί ένα stride ίσο με 4. Χρήση μνήμης καταχωρητών Στην μνήμη καταχωρητών αποθηκεύονται οι μεταβλητές που κρατάνε το global αναγνωριστικό του νήματος καθώς και το αναγνωριστικό του νήματος μέσα στο block. Επίσης αποθηκεύεται το μέγεθος των πακέτων καθώς και το pitch (το μέγεθος των γραμμών των πακέτων) αφού τα πακέτα είναι αποθηκευμένα στην global μνήμη σαν μονοδιάστατος πίνακας. 61

62 5 ΜΕΤΡΗΣΕΙΣ ΣΥΓΚΡΙΣΕΙΣ Για την ανάλυση των μετρήσεων θα πρέπει να παρουσιαστούν τα χαρακτηριστικά του υπολογιστικού συστήματος που έγιναν οι μετρήσεις καθώς και η υπολογιστική δυνατότητα και τα χαρακτηριστικά της κάρτας γραφικών. Οι μετρήσεις θα γίνουν στα ίδια δεδομένα και για τις δύο υλοποιήσεις του αλγορίθμου, κλασικού και παράλληλου. Στην συνέχεια του κεφαλαίου θα γίνουν συγκρίσεις μεταξύ των αποτελεσμάτων των δύο αλγόριθμων ώστε να εξαχθούν ασφαλή συμπεράσματα για την ταχύτητα του καθενός σε συνάρτηση με τα δεδομένα εισόδου. 5.1 Χαρακτηριστικά υπολογιστικού συστήματος μετρήσεων Το υπολογιστικό σύστημα στο οποίο έγιναν οι μετρήσεις είναι ένα PC με λειτουργικό σύστημα Windows 7 Professional με εγκατεστημένο το Service Pack 1. Στο λειτουργικό σύστημα είχαν επίσης εγκατασταθεί όλες οι τελευταίες ενημερώσεις ασφαλείας από την Microsoft πέραν του Service Pack 1. Το λειτουργικό σύστημα είναι 64-bit αρχιτεκτονικής και έχει μνήμη RAM μεγέθους 2 GB. Επίσης στο υπολογιστικό σύστημα είναι εγκατεστημένο το σετ εργαλείων ανάπτυξης της Nvidia CUDA Toolkit στην έκδοση 3.2. Η έκδοση του driver της κάρτας γραφικών που είναι εγκατεστημένη είναι η Η ανάπτυξη του κώδικα έγινε με την βοήθεια του Visual Studio 2008 και του Parallel Nsight plugin Κεντρική Μονάδα Επεξεργασίας (CPU) Η Κεντρική Μονάδα Επεξεργασίας (ΚΜΕ) του υπολογιστικού συστήματος είναι της εταιρίας Intel και το συγκεκριμένο μοντέλο στο οποίο εκτελέστηκε ο κλασικός αλγόριθμος είναι το Core 2 Duo E8400. Αυτή η ΚΜΕ έχει συχνότητα λειτουργίας 3 GHz και δύο επεξεργαστικούς πυρήνες. Ωστόσο στην υλοποίηση του κλασικού αλγορίθμου δεν χρησιμοποιήθηκε κώδικας που να λαμβάνει υπόψη του τους δύο επεξεργαστικούς πυρήνες για να έχουμε ένα καλύτερο μέτρο σύγκρισης ως προς την απόδοση της παράλληλης υλοποίησης. Φυσικά όπου ήταν δυνατόν απενεργοποιήθηκαν οι βελτιστοποιήσεις του μεταγλωττιστή για την παραγωγή πολύ-νηματικών εκτελέσιμων αρχείων. Περισσότερες λεπτομέρειες για τα τεχνικά χαρακτηριστικά του επεξεργαστή υπάρχουν στο παρακάτω σύνδεσμο: Intel Core2 Duo Processor E Κάρτα γραφικών (GPU) 62

63 Η κάρτα γραφικών είναι της εταιρίας Nvidia και το συγκεκριμένο μοντέλο στο οποίο εκτελέστηκε ο παράλληλος αλγόριθμος είναι το GeForce GTX 295. Η συγκεκριμένη κάρτα γραφικών είναι επεξεργαστικής ικανότητας 1.3 και έχει τα παρακάτω χαρακτηριστικά που φαίνονται στον Πίνακα 5.1. Χαρακτηριστικά Μηχανής GPU: CUDA Cores 480 ( 240 per GPU ) Graphics Clock (MHz) Processor Clock (MHz) 576 MHz 1242 MHz Texture Fill Rate (billion/sec) 92.2 Χαρακτηριστικά Μνήμης: Memory Clock (MHz) 999 Standard Memory Config 1792 MB GDDR3 ( 896MB per GPU ) Memory Bandwidth (GB/sec) Πίνακας 5.1: Χαρακτηριστικά κάρτας γραφικών Περισσότερες λεπτομέρειες για τα τεχνικά χαρακτηριστικά της κάρτας γραφικών υπάρχουν στον παρακάτω σύνδεσμο: GeForce GTX Αποτελέσματα μετρήσεων Για την μέτρηση των αλγορίθμων χρησιμοποιήθηκαν διάφορα μεγέθη λεξικών και αρχείων εισόδου όπως φαίνεται στον παρακάτω πίνακα: Αρχεία Λεξικών (αριθμός λέξεων) Αρχεία Εισόδου (μέγεθος MB) Πίνακας 5.2: Μεγέθη λεξικών και αρχείων εισόδου Τα αρχεία των λεξικών και της εισόδου περιέχουν μόνο extended ASCII χαρακτήρες αφού μόνο αυτό το σύνολο χαρακτήρων αναγνωρίζεται από την παρούσα υλοποίηση του αλγορίθμου Aho-Corasick. Ο κλασικός και ο παράλληλος αλγόριθμος τρέξανε πολλές φορές με την βοήθεια ενός power shell script και για όλους τους συνδυασμούς λεξικών και αρχείων εισόδου. Ως χρόνος εκτέλεσης κρατήθηκε ο μέσος όρος των παραπάνω χρόνων εκτέλεσης. Σε κάθε εκτέλεση τα αρχεία με τα πρώτα 320 αποτελέσματα 63

64 συγκρίνονταν μεταξύ τους για το αν είναι ίδια αλλά κρατιόνται μόνο τα αποτελέσματα της τελευταίας εκτέλεσης. Οι μέσοι χρόνοι εκτέλεσης αποθηκεύονται σε ένα αρχείο Excel (xlsx) από το power shell script Αποτελέσματα κλασικού αλγόριθμου Aho-Corasick Στον παρακάτω πίνακα φαίνονται οι χρόνοι του κλασικού αλγόριθμου Aho-Corasick μετρημένοι σε ms: Μέγεθος Μέγεθος Εισόδου Λεξικού ,1 702,0 1160,6 2339,8 3489,8 5840, ,1 920,0 1519,4 3038,8 4545,9 7608, ,1 1000,9 1637,9 3285,3 4935,8 8221, ,2 1030,6 1726,8 3433,6 5160,5 8601, ,4 993,3 1634,8 3274,6 4910,7 8424, ,1 1049,7 1739,2 3491,2 5225,9 8921, ,5 1149,4 1918,7 3815,7 5704,8 9828, ,0 1160,8 1937,6 3856,3 5781,4 9848, ,7 1171,6 1947,3 3885,9 5826,5 9852, ,9 1170,1 1934,7 3898,4 5817,3 9942,0 Πίνακας 5.3: Χρόνοι κλασικού αλγορίθμου 64

65 Μέγεθος Εισόδου Χρόνοι (ms) Ολοκληρωμένα Συστήματα Υλικού Λογισμικού Πανεπιστήμιο Πατρών Χρόνοι κλασικού αλγορίθμου MB 300MB 200MB 100MB 60MB 30MB 30MB 60MB 100MB 200MB 300MB 500MB Μέγεθος Λεξικού Γράφημα 5.1: Χρόνοι κλασικού αλγορίθμου Αποτελέσματα παράλληλου αλγόριθμου Aho-Corasick Στον παρακάτω πίνακα φαίνονται οι χρόνοι του παράλληλου αλγόριθμου Aho-Corasick μετρημένοι σε ms: Μέγεθος Μέγεθος Εισόδου Λεξικού ,2 188,4 309,5 616,6 923,4 1532, ,0 215,3 351,7 701,2 1048,9 1743, ,7 224,4 368,7 733,1 1099,1 1827, ,5 233,4 385,8 766,5 1149,0 1911, ,2 242,0 396,9 788,2 1186,5 1969, ,2 241,3 396,9 790,5 1185,9 1971, ,3 344,6 567,0 1122,5 1692,9 2810, ,3 383,9 632,1 1252,0 1894,3 3140, ,5 405,0 667,0 1320,0 2000,0 3318,4 65

66 Μέγεθος Εισόδου Χρόνοι (ms) Ολοκληρωμένα Συστήματα Υλικού Λογισμικού Πανεπιστήμιο Πατρών ,7 405,9 669,3 1322,0 2005,8 3329,6 Πίνακας 5.4: Χρόνοι παράλληλου αλγορίθμου Χρόνοι παράλληλου αλγορίθμου MB 300MB 200MB 100MB 60MB 30MB 30MB 60MB 100MB 200MB 300MB 500MB Μέγεθος Λεξικού Γράφημα 5.2: Χρόνοι παράλληλου αλγορίθμου 5.3 Σύγκριση αποτελεσμάτων Όπως φαίνεται λοιπόν η υλοποίηση του παράλληλου αλγορίθμου είναι πάντα πιο γρήγορη από την υλοποίηση του κλασικού αλγορίθμου για κάθε συνδυασμό μεγέθους εισόδου και μεγέθους λεξικού. Στους παρακάτω πίνακες φαίνεται η επιτάχυνση της παράλληλης υλοποίησης σύμφωνα με τον νόμο του Amdahl για κάθε μέγεθος εισόδου ξεχωριστά και για όλα τα μεγέθη λεξικών: Μέγεθος Λεξικού Μέγεθος Εισόδου 30ΜΒ Κλασικός Παράλληλος Επιτάχυνση ,1 96,2 3, ,1 109,0 4,27 66