1. Motivation. Problemstellung: Dateninkonsistenzen (data races) aufgrund von konkurrierenden Zugriffen auf gemeinsame Daten sollen verhindert werden.

Transkript

1 1. Motivation Problemstellung: Dateninkonsistenzen (data races) aufgrund von konkurrierenden Zugriffen auf gemeinsame Daten sollen verhindert werden Ferienakademie 2009 Kurs 1: Data Coloring 1

2 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 2

3 2. Definitionen low-level data races Beispiel (Java): public void increment() { counter++; entspricht 3 JVM-Instruktionen: z.b.: counter = 5 Thread A LOAD R1,counter; // R1 = 5 LOAD R1,counter; ADD R1,1; STORE R1,counter; Thread B Kontextwechsel LOAD R1,counter; // R1 = 5 ADD R1,1; STORE R1,counter; // counter = 6 ADD R1,1; STORE R1,counter; // counter = 6 Problem: counter wurde insgesamt nur einmal erhöht! (low-level data race) Ferienakademie 2009 Kurs 1: Data Coloring 3

4 2. Definitionen high-level data races class Coord { double x, y; public Coord(double px, double py) { x = px; y = py; synchronized Coord getxy() { return new Coord(x, y); synchronized void setx(double px) { x = px; synchronized void sety(double py) { y = py; Coord c = new Coord(5,6); Thread A c.setx(0); c.sety(0); Kontextwechsel Thread B Coord res; res = c.getxy(); Problem: Thread B könnte das Zwischenresultat (x = 0; y = 6) lesen. (high-level data race) Ferienakademie 2009 Kurs 1: Data Coloring 4

5 2. Definitionen high-level data races Ein high-level data race kann also auftreten, wenn auf eine Menge von Variablen, auf die atomar zugegriffen werden soll, auch teilweise zugegriffen werden kann. Dadurch kann es vorkommen, dass ein Thread falsche Werte liest, obwohl sowohl die Zugriffe auf die einzelnen Variablen als auch die Zugriffe auf die Menge jeweils untereinander synchronisiert sind Ferienakademie 2009 Kurs 1: Data Coloring 5

6 2. Definitionen Begriffe code-centric synchronisation: klassische Synchronisation über Semaphore, Monitore o.ä.; Locks werden beim Zugriff auf Variablen festgelegt. data-centric synchronisation: Zusicherungen (consistency constraints) werden nicht beim Zugriff auf Variablen, sondern bei der Deklaration festgelegt. Beispiel: Data Coloring consistency constraint: Zusicherung bzgl. der Konsistenz z.b.: auf Variable x darf nur ein Thread gleichzeitig zugreifen. consistency domain: Darf auf mehrere verschiedene Variablen nicht gleichzeitig zugegriffen werden, werden diese in einer Domäne gekapselt. z.b.: auf eine der Variablen x und y darf nur ein Thread gleichzeitig zugreifen Ferienakademie 2009 Kurs 1: Data Coloring 6

7 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 7

8 3. Nachteile von code-centric synchronisation code-centric: (mit Semaphor) P(Semaphor s) // Ressource belegen { while(s <= 0) { s--; V(Semaphor s) // Ressource freigeben { s++; s := 1; // Initialisierung P(s); // Operationen ausführen V(s); Locks müssen direkt im Code eingebaut werden (non-local reasoning). Man hat keine Möglichkeit, bei der Deklaration einer Variable explizit festzulegen, zu welcher Domäne sie gehört. High-level data races sind sehr schwer zu vermeiden, da die verschiedenen Locks in der richtigen Reihenfolge angefordert und wieder freigegeben werden müssen Ferienakademie 2009 Kurs 1: Data Coloring 8

9 3. Nachteile von code-centric synchronisation Lösung des Coord-Beispiels mit Semaphoren: class Coord { double x, y; Semaphor s_x, s_y, s_xy; public Coord(double px, double py) { x = px; y = py; Coord getxy() { return new Coord(x, y); void setx(double px) { x = px; void sety(double py) { y = py; void method() { P(s_xy); P(s_x); P(s_y); setx(0); sety(0); // oder: getxy(); V(s_y); V(s_x); V(s_xy); Man muss hier sowohl Locks für x und y als auch ein Lock für die beiden Variablen gemeinsam anfordern, damit kein high-level data race auftreten kann. Außerdem ist auch die Reihenfolge entscheidend Ferienakademie 2009 Kurs 1: Data Coloring 9

10 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 10

11 4. Funktionsweise von Data Coloring Object obj color(); // dem Objekt wird eine Farbe zugewiesen. // Operationen auf obj ausführen color_step(obj); // Farbe wird wieder freigegeben. Bei der Deklaration wird einer Variablen durch den color()-aufruf eine Farbe zugewiesen. Greift man irgendwo im Code auf eine eingefärbte Variable zu, wird ein kritischer Abschnitt bzgl. der Farbe betreten. Durch den Aufruf von color_step() wird der kritische Abschnitt wieder beendet. wichtig: Damit diese Schritte entsprechend umgesetzt werden, braucht man einen speziellen Compiler Ferienakademie 2009 Kurs 1: Data Coloring 11

12 4. Funktionsweise von Data Coloring Beispiel: Es soll eine einzigartige Instanz eines Objekts erzeugt werden: Hier kann es passieren, dass zwei neue Objekte erzeugt werden, wenn vor dem Zurückschreiben der Variable singleton ein Kontextwechsel stattfindet. (low-level data race) static Object singleton = null; // der Variable wird eine (zufällige) Farbe zugewiesen. Object getuniqueinstance() { Object ret; if (singleton == null) ret = singleton = new Object(); else ret = singleton; return ret; Ferienakademie 2009 Kurs 1: Data Coloring 12

13 4. Funktionsweise von Data Coloring Das Problem soll mit Data Coloring gelöst werden: static Object singleton color() = null; // der Variable wird eine (zufällige) Farbe zugewiesen. Object getuniqueinstance() { Object ret; if (singleton == null) // kritischer Abschnitt bzgl. der Domäne (Farbe) von singleton // wird betreten. ret = singleton = new Object(); else ret = singleton; color_step(&singleton); // Domäne (Farbe) wird wieder freigegeben return ret; Ferienakademie 2009 Kurs 1: Data Coloring 13

14 4. Funktionsweise von Data Coloring Man legt bei der Deklarierung/Allokierung einer Datenstruktur fest, zu welcher consistency domain (Farbe) sie gehört: Achtung: Nicht das Objekt wird eingefärbt, sondern die Referenz! static Object singleton color() = null; // der Variable wird eine (zufällige) Farbe zugewiesen. Object getuniqueinstance() { Object ret; if (singleton == null) // kritischer Abschnitt bzgl. der Domäne (Farbe) von singleton // wird betreten. ret = singleton = new Object(); else ret = singleton; color_step(&singleton); // Domäne (Farbe) wird wieder freigegeben return ret; Ferienakademie 2009 Kurs 1: Data Coloring 14

15 4. Funktionsweise von Data Coloring Wenn ein Thread auf eine Datenstruktur zugreift, betritt er automatisch einen kritischen Abschnitt für die entsprechende consistency domain: static Object singleton color() = null; // der Variable wird eine (zufällige) Farbe zugewiesen. Object getuniqueinstance() { Object ret; if (singleton == null) // kritischer Abschnitt bzgl. der Domäne (Farbe) von singleton // wird betreten. ret = singleton = new Object(); else ret = singleton; color_step(&singleton); // Domäne (Farbe) wird wieder freigegeben return ret; Ferienakademie 2009 Kurs 1: Data Coloring 15

16 4. Funktionsweise von Data Coloring Das Ende eines kritischen Abschnitts muss manuell festgelegt werden (color step): static Object singleton color() = null; // der Variable wird eine (zufällige) Farbe zugewiesen. Object getuniqueinstance() { Object ret; if (singleton == null) // kritischer Abschnitt bzgl. der Domäne (Farbe) von singleton // wird betreten. ret = singleton = new Object(); else ret = singleton; color_step(&singleton); // Domäne (Farbe) wird wieder freigegeben return ret; Ferienakademie 2009 Kurs 1: Data Coloring 16

17 4. Funktionsweise von Data Coloring Aber: Data-centric synchronisation reicht nicht aus. Beispiel: void transfer(account a, Account b, int n) { a.withdraw(n); b.add(n); Auch wenn die Daten der einzelnen Konten konsistent sind (durch data-centric synchronization), kann es vorkommen, dass vor b.add(n) ein Kontextwechsel stattfindet. => Ein anderer Thread liest einen alten Kontostand des Kontos b. Man beobachtet also Inkonsistenzen zwischen verschiedenen Domänen Ferienakademie 2009 Kurs 1: Data Coloring 17

18 4. Funktionsweise von Data Coloring Beispiel: void transfer(account a, Account b, int n) { a.withdraw(n); b.add(n); z.b.: Kontostand a: 50; Kontostand b: 30; Kontostand c: 100 Thread A Thread B transfer(a,b,40); transfer(b,c,60); a.withdraw(40); b.add(40); Kontextwechsel b.withdraw(60); c.add(60); Die transfer-operation sollte atomar bzgl. beider Konten sein Ferienakademie 2009 Kurs 1: Data Coloring 18

19 4. Funktionsweise von Data Coloring Operation-centric synchronization Wird benötigt, wenn Daten aus verschiedenen consistency domains geschützt werden müssen (z.b. Transaktion zwischen zwei Bankkonten). alle color steps innerhalb der Transaktion werden erst am Ende des atomic-blocks atomar ausgeführt. Also ist der atomic-block ein kritischer Abschnitt bzgl. allen Domänen, die im Block angesprochen werden. void transfer(account a, Account b, int n) { atomic(all_colors) { // defer_color_steps(l,all_colors) a.withdraw(n); b.add(n); // l:color_step(all_colors) Ferienakademie 2009 Kurs 1: Data Coloring 19

20 4. Funktionsweise von Data Coloring Komposition von Funktionen: int find(key key) { // search, access key, initialize index color_step(key, this); return index; Value get(int index) { // initialize value from index color_step(this); return value; void remove(int index) { // remove value at index color_step(this); Value getandremove(key key) { atomic(this) { // defer_color_step(l, this) Value value = null; int index = find(key); if (index!= -1) { value = get(index); remove(index); // l:color_step(this) return value; Der atomic-block in getandremove wird benötigt, da sonst ein color step in einer der aufgerufenen Methoden dafür sorgen könnte, dass der kritische Abschnitt in getandremove beendet und die Konsistenz verletzt wird Ferienakademie 2009 Kurs 1: Data Coloring 20

21 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 21

22 5. Vorteile von data-centric synchronisation code-centric: (mit Semaphor) data-centric: P(Semaphor s) // Ressource belegen { while(s <= 0) { s--; V(Semaphor s) // Ressource freigeben { s++; s := 1; // Initialisierung P(s); // Operationen ausführen V(s); Object obj color(); // dem Objekt wird eine Farbe // zugewiesen. // Operationen auf obj ausführen // Sobald eine Aktion auf einer eingefärbten // Variable ausgeführt wird, sind alle // Variablen derselben Farbe geschützt. color_step(obj); // Farbe wird wieder freigegeben Ferienakademie 2009 Kurs 1: Data Coloring 22

23 5. Vorteile von data-centric synchronisation Vorteile: consistency constraints werden explizit bei den zu schützenden Daten festgelegt. kritische Abschnitte werden vom Compiler automatisch eingefügt, wenn auf eingefärbte Daten zugegriffen wird. consistency domains: mehrere Variablen/Objekte können gleich eingefärbt werden. aber: color step muss ausgeführt werden, damit der Compiler weiß, wann der kritische Bereich vorbei ist. data-centric: Object obj color(); // dem Objekt wird eine Farbe // zugewiesen. // Operationen auf obj ausführen // Sobald eine Aktion auf einer eingefärbten // Variable ausgeführt wird, sind alle // Variablen derselben Farbe geschützt. color_step(obj); // Farbe wird wieder freigegeben Ferienakademie 2009 Kurs 1: Data Coloring 23

24 5. Vorteile von data-centric synchronisation Lösung des Coord-Beispiels mit Semaphoren: class Coord { double x, y; Semaphor s_x, s_y, s_xy; public Coord(double px, double py) { x = px; y = py; Coord getxy() { return new Coord(x, y); void setx(double px) { x = px; void sety(double py) { y = py; void set() { P(s_xy); P(s_x); P(s_y); setx(0); sety(0); V(s_y); V(s_x); V(s_xy); Man muss hier sowohl Locks für x und y als auch ein Lock für die beiden Variablen gemeinsam (bzw. für das Coord-Objekt) anfordern, damit kein high-level data race auftreten kann Ferienakademie 2009 Kurs 1: Data Coloring 24

25 5. Vorteile von data-centric synchronisation Lösung des Coord-Beispiels mit Data Coloring: class Coord { double x color(green), y color(green); public Coord(double px, double py) { x = px; y = py; Coord getxy() { return new Coord(x, y); void setx(double px) { x = px; void sety(double py) { y = py; void set() { setx(0); sety(0); // oder: getxy(); Sobald auf x oder y zugegriffen wird, wird die Farbe grün gesperrt. also kann kein highlevel data race auftreten Ferienakademie 2009 Kurs 1: Data Coloring 25

26 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 26

27 6. Probleme bei Data Coloring Falsche Einfärbung: Gemeinsam benutzte Bereiche sind nicht eingefärbt. Beispiel: Wenn mehrere Threads die Methode aufrufen, können Inkonsistenzen auftreten. int counter; void increment() { counter++; Lösung: Man betrachtet die Zugriffe auf nicht eingefärbte Variablen und entscheidet, ob manche Variablen eingefärbt werden sollten Ferienakademie 2009 Kurs 1: Data Coloring 27

28 6. Probleme bei Data Coloring Falsche Einfärbung: Daten, die eigentlich zu einer consistency domain gehören sollten, sind verschieben eingefärbt (kann zu race conditions führen). Beispiel: int zehner color(green); int einer color(red); void count() { einer++; if(einer = 0) zehner++; color_step(einer, zehner); void plus11() { zehner++; einer++; color_step(einer, zehner); Lösung: Finden der Inkonsistenzen mit einem Debugger Ferienakademie 2009 Kurs 1: Data Coloring 28

29 6. Probleme bei Data Coloring Falsche Einfärbung: Daten, die zu verschiedenen consistency domains gehören sollen, haben dieselbe Farbe. Lösung: Analyse, welche Variablen welche Farbe haben Ferienakademie 2009 Kurs 1: Data Coloring 29

30 6. Probleme bei Data Coloring Weglassen eines color steps: Ein Thread gibt eine Farbe nicht wieder frei, was dazu führen kann, dass das Programm nicht mehr ausgeführt werden kann (Deadlock). Aber: keine Verletzung der Sicherheit Beispiel: int counter color(); void increment() { counter++; Lösung: Identifizierung des Threads und der Farbe Ferienakademie 2009 Kurs 1: Data Coloring 30

31 6. Probleme bei Data Coloring Verletzung der Atomarität: Mehrere color steps der gleichen Farbe werden in einer Methode vollzogen. Beispiel: int zehner color(red); int einer color(red); void count() { einer++; color_step(einer); // hier kann die Konsistenz verloren gehen if(einer = 0) zehner++; color_step(einer); Lösung: Programmanalyse, Traversierung des Call-Graphen Ferienakademie 2009 Kurs 1: Data Coloring 31

32 6. Probleme bei Data Coloring Problem: color step muss immer manuell ausgeführt werden. Lösung: exit policy: Festlegung einer Regel, wann der color step automatisch ausgeführt wird. z.b.: Immer wenn eine Methode terminiert, wird implizit ein color step für alle geblockten Farben aufgerufen Ferienakademie 2009 Kurs 1: Data Coloring 32

33 6. Probleme bei Data Coloring Problem: Pointer (beispielsweise in C/C++) und Aliasing Data Coloring funktioniert nur auf Variablen; sobald Pointer und Aliasing ins Spiel kommen, kann das Erzeugen von kritischen Abschnitten nicht mehr zuverlässig funktionieren. Lösung: Compiler checkt die Adressen von jedem Pointerzugriff auf eine mögliche Einfärbung; Statt Referenzen werden die Objekte eingefärbt. Aber: Sehr viel Overhead; Compiler hat möglichweise keinen Zugriff auf das ganze Programm (z.b. bei dynamisch gelinkten Bibliotheken) Ferienakademie 2009 Kurs 1: Data Coloring 33

34 6. Probleme bei Data Coloring Alternative Lösung: Hardware-Lösung (Colorama): zwei Hardwarefunktionen: Alle Speicheradressen, auf die ein Prozessor zugreift, werden überwacht; bei Bedarf wird ein kritischer Abschnitt erzeugt. Austritt aus einem kritischen Abschnitt: Gemäß der exit policy, die beim Kompilieren verwendet wird, wird der kritische Abschnitt wieder verlassen Ferienakademie 2009 Kurs 1: Data Coloring 34

35 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Fazit 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 35

36 7. Fazit Es liegt nahe, consistency constraints direkt in den Datenstrukturen (data-centric synchronisation) anstatt in den Methoden (code-centric synchronisation) zu definieren. Statistiken zeigen, dass sehr viele kritische Abschnitte data-centric sind (z.b.: MySQL 5: 84%; WebSphere: 75%). Das Auffinden und Beheben von Synchronisationsproblemen ist relativ einfach. Data Coloring deckt durch data-centric synchronization und operation-centric synchronization alle Synchronisationsprobleme ab Ferienakademie 2009 Kurs 1: Data Coloring 36

37 7. Fazit Aber: Bislang ist kein Compiler für Data Coloring verfügbar Nur die Konzepte sind vorhanden (veröffentlicht von Luis Ceze, 2007) Auch die Hardwarelösung Colorama ist nur ein Konzept Ferienakademie 2009 Kurs 1: Data Coloring 37

38 Gliederung 1.Motivation 2.Definitionen 3.Nachteile von code-centric synchronisation 4.Funktionsweise von Data Coloring 5.Vorteile von Data Coloring 6.Probleme bei Data Coloring 7.Warum Data Coloring? 8.Fragen Ferienakademie 2009 Kurs 1: Data Coloring 38