Ja ich möchte in dem Anhang hier zunächst auf die Schlossalgorithmen noch mal zurückkommen und

hier konkret das kreiseln mit der CAS-Operation. Wir haben gesehen zum Anfang, dass eben diese CAS-

Operation, die wir ja verwenden, eben eine intrinsische Funktion des Compilers, des GCCs,

und die EQUIER-Funktion, die wir da verwendet haben. Wir haben den Assembler Code für das Test&Set

gesehen. Es ist denn hier noch mal die Funktionalequivalente Funktion auf Basis dieses CAS

dargestellt, wo denn deutlich wird, wie sozusagen diese intrinsische Operation im Compiler,

den praktischen Assembler Code generiert wird. Das sind dann diese Zeilen, die man hier im

Wesentlichen von 5 bis 7 sieht, wo denn die eigentliche Umsetzung dieser CAS-Operation

geschieht. Drumherum ist denn das, was notwendig ist, um sozusagen diese CAS-Primitive auf einer

C-Hochsprachen-Ebene entsprechend des Schlossalgorithmus, des SpinLogs, letztendlich nutzen zu können.

Hier sieht man auch diesen sogenannten Log-Präfix, der praktisch dann bedeutet, dass die nachfolgende

Operation, also hier ComperexchangeByte, letztlich atomar zur Ausführung kommen wird, sodass man also

sicherstellt, dass genau dann diese Aktion hier vergleichen und dann bedingt zu schreiben, also die

Semantik von diesem CAS dann wirklich atomar geschieht. Und wir sehen hier eben auch die Schleife,

die konstruiert worden ist, dass je nach Ergebnis des Vergleichs man dann halt zurückspringt zu der

Zeile 4, faktisch dann halt mit dem nächsten Befehl, der in der Zeile 5 mit dem Löschen des

Inhalts vom Register ERX durchgeführt wird, sodass im Register ERX dann halt eine Null drin steht.

Also das ist die Schleifenoperation, die wir halt haben. Hier schleifen sozusagen, hier kreiselt

denn der Prozess, der auf Eintritt in den kritischen Abschnitt wartet oder der eben auf Freigabe der

Sperre im Endeffekt wartet, immer herum. Diese XOR-Funktion hier oben löscht den Inhalt von ERX,

damit ist da der Wert Null drin und Null heißt eben FALS letztendlich. Und wir wollen ja eben auch

überprüfen, ob an dieser Adresse, die hier durch diesen Register ICX gegeben ist, ob denn an dieser

Adresse halt praktisch ein Wert steht, der letztendlich bedeutet, ob denn diese Schlossvariable

gesetzt oder gelöscht ist. Also TRUE oder FALS letztendlich ist. Der Wert, mit dem man denn halt

vergleichen möchte, wird hier oben gesetzt in der Zeile 3, also vor der Schleife ins Register DL,

ist der Wert 1, das ist also der TRUE Wert. Man überprüft also, ob praktisch an dieser Schlossvariable

TRUE steht. Wenn dies der Fall ist, dann wird praktisch an diese Schlossvariable der Wert ERX

hingeschrieben. Das ist eine implizite Maßnahme in dieser Operation. Die geht also für die Schreiboperation

davon aus, dass der Wert, der geschrieben wird, an dieser Adresse im Register ERX steht. Deshalb

muss man vorher hier eben auch die Löschoperation durchführen. Und am Ende, wenn man aus der

Compare Exchange Operation rauskommt, entsteht im Register ERX eben der Wert drin, der da vorher

an dieser Adresse stand. Das entspricht durchaus diesen Austauschoperationen. Man schreibt an ERX

etwas aus dem Register, man schreibt an ECX etwas aus dem Register ERX halt hin und bekommt

dann in ERX genau den Wert zurückgeliefert, der hier an dieser Adresse letztendlich stand.

So ist denn die Operation definiert. Deshalb können wir hier auf dem Register AL, also nicht der

komplette Registeranteil, sondern der niedrigwertige Anteil, dann abfragen, ob denn der Wert 0 ist oder

1 ist. Und wenn es eben ungleich 0 ist, dann springen wir wieder hoch. Das heißt, dann würden wir ja

eine Sperre sehen und dann müssen wir eben so lange warten, bis wir halt eine Null rausbekommen.

Das ist genau dann diese Bedeutung. Das heißt, aus dieser Operation Zeile 10 gehen wir dann halt

raus mit der Sicherheit, dass die Sperre 0 war, aber sie ist natürlich dann gesetzt im Endeffekt.

Nun, das was man hier auch noch erkennt, ist eben, dass neben der atomaren Sequenz, wenn man mal 6 und 7

zusammen nimmt in den Zeilen, im Wesentlichen in die Compare Exchange Operation, in der Schleife wenig

normale nicht atomare Operationen durchgeführt werden, wie das XOR, das Test Byte oder dieser

Sprungbefehl. Wir können sagen, es sind jetzt zwei Befehle, die etwas mit der Atomarität zu tun haben

und dann drei Befehle, die dann eigentlich davon unabhängig sind. Und die Tatsache, dass dieses

Verhältnis zwischen dem atomaren Befehl und dem nicht atomaren Befehl eigentlich recht ungünstig

ist, führt dann dazu, dass wir hier ein Skalierungsproblem haben. Das ist sozusagen, man sieht hier so ein

Stück weit der Code, der verantwortlich ist, dass man von dem sogenannten Buzz Lock Burst ausgehen

muss, der hier entstehen kann, wenn sehr viele gleichzeitig Prozesse hier zugleich diesen Code

ausführen. Je mehr Prozesse nämlich gleichzeitig in diese Schleife eintreten, also hier ab Zeile 4,