Transactional Memory

Εθνικό Μετσόβιο Πολυτεχνείο Σχολή Ηλεκτρολόγων Μηχ. και Μηχανικών Υπολογιστών Εργαστήριο Υπολογιστικών Συστημάτων Transactional Memory 9 ο Εξάμηνο

Τακτικές Συγχρονισμού Κλειδώματα (locks) Coarse-grain Fine-grain Non-blocking Lock-free Wait-free Transactional Memory 2

Δυσκολία προγραμματισμού εύκολο να κάνουμε coarse-grain υλοποιήσεις Συγχρονισμός Γιατί δε μας αρέσουν τα locks... για να εκμεταλλευτούμε όμως τον παραλληλισμό πρέπει να κάνουμε fine-grain υλοποιήσεις...... και εκεί ξεκινάει ο εφιάλτης 3

Δυσκολία προγραμματισμού εύκολο να κάνουμε coarse-grain υλοποιήσεις Συγχρονισμός Γιατί δε μας αρέσουν τα locks... για να εκμεταλλευτούμε όμως τον παραλληλισμό πρέπει να κάνουμε fine-grain υλοποιήσεις...... και εκεί ξεκινάει ο εφιάλτης Convoying ένα νήμα που κρατάει ένα lock γίνεται schedule out τα υπόλοιπα νήματα περιμένουν την απελευθέρωση του lock ακόμα και μετά την απελευθέρωση του lock υπάρχει μία ουρά από νήματα που περιμένουν να πάρουν το lock 3

Αντιστροφή προτεραιοτήτων (Priority inversion) ένα νήμα T1 υψηλής προτεραιότητας περιμένει να ελευθερωθεί κάποιο lock ένα άλλο νήμα T2 χαμηλότερης προτεραιότητας εκτελείται πριν το T1 Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Mars Pathfinder (1997) αποστολή της NASA για αποστολή του εξερευνητικού οχήματος Sojourner στον Άρη λίγες μέρες μετά την προσεδάφιση στον Άρη το λογισμικού του συστήματος κάνει επανεκκινήσεις Γιατί; Priority inversion Concurrent programming is hard: After the failure, JPL engineers spent hours and hours running the system on the exact spacecraft replica in their lab with tracing turned on, attempting to replicate the precise conditions under which they believed that the reset occurred. Early in the morning, after all but one engineer had gone home, the engineer finally reproduced a system reset on the replica. Analysis of the trace revealed the priority inversion. Πηγή: wikipedia Πηγή:http://research.microsoft.com/en-us/um/people/mbj/Mars_Pathfinder/Mars_Pathfinder.html 4

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { withdraw(a, amount); deposit(b, amount); } 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Νήμα 1: transfer(a, B, 10); Νήμα 2: transfer(b, A, 20); 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Νήμα 1: transfer(a, B, 10); lock(a); Νήμα 2: transfer(b, A, 20); lock(b); 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Νήμα 1: transfer(a, B, 10); lock(a); lock(b); Νήμα 2: transfer(b, A, 20); lock(b); lock(a); 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Νήμα 1: transfer(a, B, 10); lock(a); lock(b); DEADLOCK! Νήμα 2: transfer(b, A, 20); lock(b); lock(a); 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Νήμα 1: transfer(a, B, 10); lock(a); lock(b); Η σύνθεση κλειδωμάτων είναι δύσκολη. DEADLOCK! Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Νήμα 2: transfer(b, A, 20); lock(b); lock(a); Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 5

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { } withdraw(a, amount); deposit(b, amount); Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Νήμα 1: transfer(a, B, 10); Νήμα 2: transfer(c, D, 20); Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Νήμα 1: transfer(a, B, 10); lock(bank); Νήμα 2: transfer(c, D, 20); lock(bank); Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Νήμα 1: transfer(a, B, 10); lock(bank);... critical section... Νήμα 2: transfer(c, D, 20); lock(bank);... stall... Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Νήμα 1: transfer(a, B, 10); lock(bank);... critical section... Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα No Concurrency! δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Νήμα 2: transfer(c, D, 20); lock(bank);... stall... Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. 6

Συγχρονισμός Γιατί δε μας αρέσουν τα locks... Composability void transfer (account A, account B, int amount) { lock(bank); withdraw(a, amount); deposit(b, amount); unlock(bank); } Νήμα 1: transfer(a, B, 10); lock(bank);... critical section... Η σύνθεση κλειδωμάτων είναι δύσκολη. Χρειάζεται καθολική πολιτική για το κλείδωμα No Concurrency! δεν μπορεί πάντα να αποφασιστεί εκ των προτέρων Νήμα 2: transfer(c, D, 20); lock(bank);... stall... Fine-grain locking: εκμετάλλευση παραλληλισμού, καλή επίδοση και κλιμακώσιμο, αλλά δυσκολία προγραμματισμού. Coarse-grain locking: δεν υπάρχει παραλληλία, χαμηλή επίδοση 6

Παράδειγμα: Java 1.4 HashMap Map: key value (-) δεν είναι thread-safe 7

Η λύση της Java 1.4: synchronized layer ρητό, coarse-grain locking από τον προγραμματιστή Synchronized HashMap Coarse-grain synchronized HashMap (+) thread-safe, εύκολο στον προγραμματισμό (-) περιορίζει τον (όποιον) ταυτοχρονισμό, χαμηλή κλιμακωσιμότητα μόνο ένα thread μπορεί να επεξεργάζεται το HashMap κάθε φορά Fine-grain locking HashMap (Java 5) ένα lock ανά bucket (+) καλή επίδοση και κλιμακωσιμότητα (-) δυσκολία προγραμματισμού 8

Επίδοση: Locks 9

Ιδανικά θα θέλαμε: Transactional Memory (TM) προγραμματιστική ευκολία αντίστοιχη με coarse-grain locking απόδοση συγκρίσιμη με fine-grain locking Transactional memory ο χρήστης σημειώνει κομμάτια κώδικα τα οποία πρέπει να εκτελεστούν ατομικά (transactions) το TM σύστημα είναι υπεύθυνο για την σωστή εκτέλεση Μεταφέρουμε την πολυπλοκότητα του fine-grain συγχρονισμού στο TM σύστημα. 10

Προγραμματισμός με ΤΜ void transfer (account A, account B, int amount) { lock(a); lock(b); withdraw(a, amount); deposit(b, amount); unlock(b); unlock(a); } Προστακτικός vs. Δηλωτικός προγραμματισμός Περιγραφή συγχρονισμού σε υψηλό επίπεδο ο προγραμματιστής λέει τι, όχι πώς Το υποκείμενο σύστημα υλοποιεί το συγχρονισμό εξασφαλίζει ατομικότητα, απομόνωση & σειριοποίηση Επίδοση; void transfer (account A, account B, int amount) { tx_begin(); withdraw(a, amount); deposit(b, amount); tx_end(); } εξαρτάται από το κρίσιμο τμήμα και την υλοποίηση του TM 11

Memory transaction μία ατομική και απομονωμένη ακολουθία λειτουργιών μνήμης εμπνευσμένη από τις δοσοληψίες στις Βάσεις Δεδομένων Ατομικότητα (Atomicity) θα γίνουν είτε όλες οι εγγραφές στη μνήμη ή καμία (all or nothing), όλες οι εγγραφές στη μνήμη abort, καμία εγγραφή στη μνήμη Απομόνωση (Isolation) Transactions κανένα άλλο τμήμα κώδικα δεν μπορεί να δεί τις εγγραφές ενός transaction πριν το Σειριοποίηση (Serializability) τα αποτελέσματα των transactions είναι συνεπή (ίδια με αυτά της σειριακής/σειριοποιημένης εκτέλεσης) τα transactions φαίνονται ότι κάνουν σειριακά η συγκεκριμένη σειρά ωστόσο δεν είναι εγγυημένη 12

Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα 13

Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα 13

Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. unlock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. unlock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. tx_begin() tx_begin() tx_begin() unlock(l) acq. unlock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. tx_begin() tx_end() tx_begin() rd B wr B tx_end() tx_begin() x conflict unlock(l) acq. unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. tx_begin() tx_end() tx_begin() rd B wr B tx_end() tx_begin() x conflict tx_begin() unlock(l) acq. tx_end() unlock(l) 13

Νήμα 1 Νήμα 2 Νήμα 3 Νήμα 1 Νήμα 2 Νήμα 3 Locks vs. TM 3 νήματα εκτελούν ένα κρίσιμο τμήμα lock(l) lock(l) lock(l) acq. unlock(l) acq. tx_begin() tx_end() tx_begin() rd B wr B tx_end() tx_begin() x conflict tx_begin() unlock(l) acq. tx_end() unlock(l) Αναμενόμενο κέρδος σε περίπτωση μη-conflict Επιβράδυνση σε conflicts (R-W ή W-W) λόγω χαμένης δουλείας 13

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο 1 2 3 4 14

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Hand-over-hand locking 1 2 3 4 14

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Hand-over-hand locking 1 2 3 4 Ακόμα και fine-grain υλοποιήσεις μπορεί να μην εκμεταλλεύονται πλήρως τον παραλληλισμό Παράδειγμα: ένα lock στον κόμβο 1 μπλοκάρει νήματα που θα μπορούσαν να εκτελεστούν ταυτόχρονα 14

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Transactions 1 2 3 4 15

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Transactions 1 2 3 4 Transaction A READ 1,2,3 15

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Transactions 1 2 3 4 Transaction A READ 1,2,3 Transaction B READ 1,2,4 15

Tree update από 2 νήματα Στόχος: τροποποίηση κόμβων 3 και 4 με thread-safe τρόπο Transactions 1 2 3 4 Transaction A Transaction B READ 1,2,3 READ 1,2,4 WRITE 3 WRITE 4 Τα δύο updates μπορούν να γίνουν ταυτόχρονα: δεν υπάρχει conflict 15

Transactional HashMap Απλά εσωκλείουμε τη λειτουργία σε ένα atomic block το σύστημα εξασφαλίζει την ατομικότητα Transactional HashMap (+) thread-safe, εύκολο στον προγραμματισμό Καλή επίδοση & κλιμακωσιμότητα? Εξαρτάται από την υλοποίηση του TM και το σενάριο εκτέλεσης, αλλά τυπικά ναι 16

Επίδοση: Locks vs. TM 17

Ευκολία προγραμματισμού παραπλήσια με αυτή των coarse-grain locks ο προγραμματιστής δηλώνει, το σύστημα υλοποιεί Επίδοση παραπλήσια με αυτή των fine-grain locks Πλεονεκτήματα ΤΜ εκμεταλλεύεται αυτόματα τον fine-grain ταυτοχρονισμό δεν υπάρχει tradeoff ανάμεσα στην απόδοση & την ορθότητα Failure atomicity & recovery δεν «χάνονται» locks όταν ένα νήμα αποτυγχάνει failure recovery = transaction abort + restart Composability σύνθεση επιμέρους ατομικών λειτουργιών / software modules σε μία ενιαία ατομική λειτουργία ασφαλής & κλιμακώσιμη 18

Υλοποίηση ΤΜ Τα ΤΜ συστήματα πρέπει να παρέχουν ατομικότητα και απομόνωση χωρίς να θυσιάζεται ο ταυτοχρονισμός Ζητήματα υλοποίησης Data versioning (ώστε να μπορεί να γίνει abort/rollback) Conflict detection & resolution (για να ανιχνεύουμε πότε πρέπει να γίνει abort) Επιλογές Hardware transactional memory (HTM) Software transactional memory (STM) Hybrid transactional memory Hardware accelerated STMs Dual-mode systems 19

Data Versioning Διαχείριση unted (νέων) και ted (παλιών) εκδόσεων δεδομένων για ταυτόχρονα transactions 1. Lazy versioning (write-buffer based) 2. Eager versioning (undo-log based) 20

Lazy versioning Καταγραφή των αλλαγών σε write buffer, ενημέρωση της μνήμης κατά το Begin Transaction Write X = 15 Thread Write Buffer X: 10 Memory Commit Transaction Abort Transaction 21

Lazy versioning Καταγραφή των αλλαγών σε write buffer, ενημέρωση της μνήμης κατά το Begin Transaction Thread Write X = 15 Thread X: 10 Memory Write Buffer X: 10 Memory X: 15 Write Buffer Commit Transaction Abort Transaction 21

Lazy versioning Καταγραφή των αλλαγών σε write buffer, ενημέρωση της μνήμης κατά το Begin Transaction Thread Write X = 15 Thread X: 10 Memory Write Buffer X: 10 Memory X: 15 Write Buffer Commit Transaction Abort Transaction Thread X: 10 Memory X: 15 Write Buffer 21

Lazy versioning Καταγραφή των αλλαγών σε write buffer, ενημέρωση της μνήμης κατά το Begin Transaction Thread Write X = 15 Thread X: 10 Memory Write Buffer X: 10 Memory X: 15 Write Buffer Commit Transaction Abort Transaction Thread X: 15 Memory X: 15 Write Buffer 21

Lazy versioning Καταγραφή των αλλαγών σε write buffer, ενημέρωση της μνήμης κατά το Begin Transaction Thread Write X = 15 Thread Write Buffer X: 15 Write Buffer X: 10 Memory X: 10 Memory Commit Transaction Thread Abort Transaction Thread X: 15 Memory X: 15 Write Buffer X: 10 Memory X: 15 Write Buffer 21

Begin Transaction Thread Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Undo Log X: 10 Memory 22

Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Begin Transaction Thread Write X = 15 Thread X: 10 Memory Undo Log X: 10 Memory X:10 Undo Log 22

Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Begin Transaction Thread Write X = 15 Thread X: 10 Memory Undo Log X: 15 Memory X:10 Undo Log 22

Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Begin Transaction Thread Write X = 15 Thread X: 10 Memory Commit Transaction Thread Undo Log X: 15 Memory X:10 Undo Log X: 15 Memory X:10 Undo Log 22

Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Begin Transaction Thread Write X = 15 Thread Undo Log X:10 Undo Log X: 10 Memory X: 15 Memory Commit Transaction Thread Abort Transaction Thread X: 15 Memory X:10 Undo Log X: 15 Memory X:10 Undo Log 22

Eager versioning Άμεση ενημέρωση μνήμης, διατήρηση undo log για την περίπτωση abort Begin Transaction Thread Write X = 15 Thread Undo Log X:10 Undo Log X: 10 Memory X: 15 Memory Commit Transaction Thread Abort Transaction Thread X: 15 Memory X:10 Undo Log X: 10 Memory X:10 Undo Log 22

Lazy versioning (write-buffer based) Data versioning καταγραφή νέων δεδομένων σε write-buffer μέχρι το πραγματική ενημέρωση μνήμης κατά το (+) γρήγορο abort, fault tolerant (απλά «πετάμε» τον writer-buffer) (-) αργά s (πρέπει τα δεδομένα να γραφτούν στη μνήμη) Eager versioning (undo-log based) απευθείας ενημέρωση μνήμης διατήρηση undo πληροφορίας σε log (+) γρήγορο (τα δεδομένα είναι ήδη στη μνήμη) (-) αργό abort, ζητήματα fault tolerance (τι γίνεται αν ένα thread αποτύχει κατά τη διάρκεια ενός transaction) 23

Conflict detection Ανίχνευση και διαχείριση conflicts ανάμεσα σε transactions read-write conflict: ένα transaction A διαβάζει τη διεύθυνση X, η οποία έχει γραφτεί από ένα τρέχων transaction B. write-write conflict: δύο transactions γράφουν στην ίδια διεύθυνση μνήμης X Πρέπει να παρακολουθούνται το read-set & write-set ενός transaction read-set: οι διευθύνσεις που διαβάζονται εντός του transaction write-set: οι διευθύνσεις που γράφονται εντός του transaction Conflict resolution τι γίνεται όταν ανιχνευθεί ένα conflict διάφορες πολιτικές stall writer wins ter wins... 24

1. Pessimistic (eager) detection Έλεγχος για conflicts σε κάθε load ή store Conflict detection Χρήση contention manager για να αποφασίσει να κάνει stall ή abort Απαισιοδοξία: «Θα έχω conflicts οπότε ας ελέγχω μετά από κάθε πρόσβαση στη μνήμη... Αν χρειαστεί να γίνει abort θα γλιτώσω άσκοπη δουλειά.» 2. Optimistic (lazy) detection Έλεγχος για conflicts κατά το Σε περίπτωση conflict, προτεραιότητα στο ting transaction Αισιοδοξία: «Δεν θα έχω conflicts οπότε ελέγχω μόνο κατά την διάρκεια του.» 25

Pessimistic detection Case 1 TIME Success 74

Pessimistic detection Case 1 TIME wr B Success 77

Pessimistic detection Case 1 TIME wr B wr C Success 78

Pessimistic detection Case 1 TIME wr B wr C Success 79

Pessimistic detection Case 1 Case 2 TIME wr B wr C Success Early Detect 80

Pessimistic detection Case 1 Case 2 TIME wr C wr B Success Early Detect 81

Pessimistic detection Case 1 Case 2 TIME wr C wr B Success Early Detect 82

Pessimistic detection Case 1 Case 2 TIME wr C wr B stall Success Early Detect 83

Pessimistic detection Case 1 Case 2 TIME wr C wr B stall Success Early Detect 84

Pessimistic detection Case 1 Case 2 Case 3 TIME wr C wr B stall Success Early Detect Abort 85

Pessimistic detection Case 1 Case 2 Case 3 TIME wr B stall wr C Success Early Detect Abort 86

Pessimistic detection Case 1 Case 2 Case 3 TIME wr B stall wr C Success Early Detect Abort 87

Pessimistic detection Case 1 Case 2 Case 3 TIME wr B wr C stall restart Success Early Detect Abort 88

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr B wr C stall restart Success Early Detect Abort No progress 91

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart Success Early Detect Abort No progress 92

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart Success Early Detect Abort No progress 93

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart restart Success Early Detect Abort No progress 94

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart restart Success Early Detect Abort No progress 95

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart restart restart Success Early Detect Abort No progress 96

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart restart restart Success Early Detect Abort No progress 97

Pessimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B stall restart restart restart restart Success Early Detect Abort No progress 98

Optimistic detection TIME 99

Optimistic detection Case 1 TIME Success 100

Optimistic detection Case 1 TIME wr B Success 101

Optimistic detection Case 1 TIME wr B wr C Success 102

Optimistic detection Case 1 TIME wr B wr C Success 103

Optimistic detection Case 1 Case 2 TIME wr B wr C Success Abort 104

Optimistic detection Case 1 Case 2 TIME wr B wr C restart Success Abort 107

Optimistic detection Case 1 Case 2 TIME wr B wr C Success restart Abort 108

Case 1 Case 2 Case 3 Optimistic detection TIME wr B wr C Success restart Abort Success 109

Case 1 Case 2 Case 3 Optimistic detection TIME wr B wr C Success restart Abort Success 110

Case 1 Case 2 Case 3 Optimistic detection TIME wr C wr B Success restart Abort Success 111

Case 1 Case 2 Case 3 Optimistic detection TIME wr C wr B Success restart Abort Success 112

Optimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr C wr B restart Success Abort Success Forward progress 113

Optimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr B wr C restart restart Success Abort Success Forward progress 116

Optimistic detection Case 1 Case 2 Case 3 Case 4 TIME wr B wr C restart restart Success Abort Success Forward progress 117

1. Pessimistic conflict detection (+) ανιχνεύει τα conflicts νωρίς Conflict Detection Tradeoffs αναιρεί λιγότερη δουλειά, μετατρέπει μερικά aborts σε stalls (-) δεν εγγυάται την πρόοδο προς τα εμπρός, πολλά aborts σε κάποιες περιπτώσεις 2. Optimistic conflict detection (+) εγγυάται την πρόοδο προς τα εμπρός (-) ανιχνεύει τα conflicts αργά, άσκοπη δουλειά (-) starvation 28

ΗΤΜ συστήματα Lazy + optimistic: Stanford TCC Lazy + pessimistic: MIT LTM, Intel VTM, Sun s Rock Eager + pessimistic: Wisconsin LogTM TM Implementation Space (παραδείγματα) STM συστήματα Lazy + optimistic (rd/wr): Sun TL2 Lazy + optimistic (rd) / pessimistic (wr): MS OSTM Eager + optimistic (rd) / pessimistic (wr): Intel STM Eager + pessimistic (rd/wr): Intel STM 29

Hardware TM 2011 IBM Blue Gene/Q 2012 IBM zec12 mainframe 2013 Intel TSX (Haswell, Broadwell ) 2014 IBM Power8 Κοινά χαρακτηριστικά εκμετάλλευση των ήδη υπάρχοντων μηχανισμών για coherency conflict detection σε επίπεδο cache line false sharing περιορισμένο μέγεθος read/write sets aborts για διάφορους λόγους εκτός από data conflict cache line eviction, interrupt best-effort: δεν εγγυώνται forward progress ένα transaction μπορεί να μην κάνει ποτέ είναι ευθύνη του χρήστη να εγγυηθεί forward progress με ένα non-transactional path 30

Intel TSX Διαθέσιμο στους επεξεργαστές Haswell και μεταγενέστερους. Η πρώτη υλοποίηση HTM διαθέσιμη σε εμπορικούς επεξεργαστές. Στις πρώτες εκδόσεις επεξεργαστών Haswell και Broadwell το TSX είναι buggy Αύγουστος 2014: «Errata prompts Intel to disable TSX in Haswell, early Broadwell CPUs» http://techreport.com/news/26911/errata-prompts-intel-to-disable-tsx-in-haswell-early-broadwell-cpus HSW136. Software Using Intel TSX May Result in Unpredictable System Behavior http://www.intel.com/content/dam/www/public/us/en/documents/specification-updates/xeon-e3-1200v3-spec-update.pdf Λύση; Απενεργοποίηση του TSX από το BIOS. 31

Παρέχονται δύο interfaces για την χρήση του 1. Restricted Transactional Memory (RTM) 4 νέες εντολές assembly για τη διαχείριση transactions Intel TSX interfaces μεγαλύτερη ευελιξία ο προγραμματιστής επιλέγει τι θα γίνει σε περίπτωση abort 2. Hardware Lock Elision (HLE) 2 νέα προθέματα εντολών assembly ένα critical section προστατεύετεται από ένα lock, το σύστημα προσπαθεί πρώτα να το εκτελέσει σε transaction, αν αποτύχει εκτελείται με την απόκτηση του lock ο κώδικας που προκύπτει εκτελείται και σε παλιότερους επεξεργαστές χωρίς TSX (τα προθέματα αντιμετωπίζονται σαν nops) 32

XBEGIN <fallback address> δηλώνει την αρχή ενός transaction Intel TSX - RTM <fallback address>: η διεύθυνση του κώδικα που θα εκτελεστεί σε περίπτωση abort XEND δηλώνει το τέλος ενός transaction XTEST δείχνει αν εκτελείται transaction ή όχι XABORT <abort code> αναγκάζει το τρέχων transaction να κάνει abort <abort code>: χρησιμοποιείται για την διάκριση μεταξύ διαφορετικών λόγων για abort 33

Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; Το transaction ξεκίνησε επιτυχώς start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT(); Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set... Critical Section... TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set Transactional path σε πέρίπτωση abort το hardware αναλαμβάνει να κάνει rollback και η ροή του προγράμματος επιστρέφει στην κλήση της TX_BEGIN() TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... Commit TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set Transactional path σε πέρίπτωση abort το hardware αναλαμβάνει να κάνει rollback και η ροή του προγράμματος επιστρέφει στην κλήση της TX_BEGIN() } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... Commit TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set Transactional path σε πέρίπτωση abort το hardware αναλαμβάνει να κάνει rollback και η ροή του προγράμματος επιστρέφει στην κλήση της TX_BEGIN() Transaction aborted } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... Commit TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set Transactional path σε πέρίπτωση abort το hardware αναλαμβάνει να κάνει rollback και η ροή του προγράμματος επιστρέφει στην κλήση της TX_BEGIN() Transaction aborted Αν δεν έχει ξεπεραστεί το όριο των aborts κάνουμε retry το transaction 34

Ξεκίνα ένα transaction Intel TSX RTM example int aborts = MAX_TX_RETRIES; lock_t = fallback_global_lock; start_tx: int status = TX_BEGIN(); if (status == TX_BEGIN_STARTED) { if (fallback_global_lock is locked) TX_ABORT();... Critical Section... Commit TX_END(); } else { /* status!= TX_BEGIN_STARTED */ if (--aborts > 0) /* retry transaction */ goto start_tx; } acquire_lock(fallback_global_lock);... Critical Section... release_lock(fallback_global_lock); Το transaction ξεκίνησε επιτυχώς Προσθήκη του fallback lock στο read-set Transactional path σε πέρίπτωση abort το hardware αναλαμβάνει να κάνει rollback και η ροή του προγράμματος επιστρέφει στην κλήση της TX_BEGIN() Transaction aborted Αν δεν έχει ξεπεραστεί το όριο των aborts κάνουμε retry το transaction Αλλιώς «κλείδωσε» το lock και εκτέλεσε το κρίσιμο τμήμα non-transactional path 34

Intel TSX HLE 2 νέα προθέματα εντολών assembly XACQUIRE XRELEASE Παράδειγμα: elision ενός TAS lock /* acquire lock */ while ( sync_lock_test_and_set(&lock_var) == 0) /* do nothing */;... Critical section with lock acquired... /* release lock */ sync_lock_release(&lock_var); /* elide lock */ while ( hle_acquire_test_and_set(&lock_var) == 0) /* do nothing */;... Critical section with lock acquired... /* release lock */ hle_release_clear(&lock_var); Το σύστημα εκτελεί αρχικά το κρίσιμο τμήμα με transaction Αν γίνει abort παίρνει το lock και επανεκτελεί το κρίσιμο τμήμα 35