Prozesssynchronisation: Befehlssatzebene Wolfgang Schr ... fileSystemprogrammierung...

SystemprogrammierungProzesssynchronisation: Befehlssatzebene

Wolfgang Schroder-Preikschat

Lehrstuhl Informatik 4

19. Januar 2011

c©wosch (Lehrstuhl Informatik 4) Systemprogrammierung WS2010/11 1 / 34

C | X Befehlssatzebene 1 Vorwort

Prozesssynchronisation auf der Befehlssatzebene

Alleinstellungsmerkmal dieser Abstraktionsebene sind allgemein die inder CPU manifestierten Fahigkeiten eines Rechensystems, hier:

(a) in Bezug auf die Bereitstellung von Spezialbefehlen und

(b) hinsichtlich der Semantik dieser Befehle zur Prozessverarbeitung

Techniken zur Synchronisation gleichzeitiger Prozesse konnen demzufolgenur auf sehr einfache, elementare Konzepte zuruckgreifen

zu (a) die Moglichkeit, externe/interne Prozesse aussperren zu konnen

Unterbrechungssperre ✗

Schlossvariable, Umlaufsperre ✗

zu (b) die Moglichkeit, kritische Abschnitt so ausformulieren zu konnen,dass gleichzeitige Prozesse nicht ausgesperrt werden

nichtblockierende Synchroniation ✗


C | X Befehlssatzebene 2 Unterbrechungssteuerung

Gliederung

1 UnterbrechungssteuerungPrinzipImplementierung

2 SchlossvariableDefinitionImplementierungDiskussion

3 Nichtblockierende SynchronisationPrinzipElementaroperationAnwendungDiskussion

4 Zusammenfassung

5 Anhang


C | X Befehlssatzebene 2 Unterbrechungssteuerung 2.1 Prinzip

Kontrolle asynchroner Programmunterbrechungen

Ansatz: asynchrone Programmunterbrechungen entweder verhindern odertolerieren, und zwar durch Verzogerung der. . .

uberlappenden Aktivitat 7→ pessimistisches Verfahren

Spezialbefehle der

{

Ebene 2: cli, sti (x86)Ebene 3: sigprocmask (POSIX)

}

”hart“

uberlappten Aktivitat 7→ optimistisches Verfahren

durch Spezialbefehle und Programme der Ebene 2:

CISC → CAS (IBM 370, m68020+), CMPXCHG (i486+)RISC → LL/SC (DEC Alpha, MIPS, PowerPC)

ohne Spezialbefehle ; BS/BST”weich“

Unterbrechungen sperren: einfach — aber nicht immer zweckmaßig

Faustregel: harte Synchronisation ist moglichst zu vermeiden



Wiedersehen mit einem alten Problem: Uberlapptes Zahlen

int wheel = 0;

Plotzlich. . .void __attribute__ ((interrupt))

niam () {

wheel++;

}

Schlecht. . .main () {

for (;;)

printf("%u\n", wheel++);

}

Wettlaufsituation

kritischer Abschnitt: ++

Laufgefahr vorbeugen

ELOP int fai(int*)

Besser. . .main () {

for (;;)

printf("%u\n", fai(&wheel));

}

unteilbares Zahlen konstruktiv und problemadaquat sicherstellen



Verhinderung vs. Tolerierung von Interrupts

Verhinderung

int fai (int *ref) {

int aux;

asm volatile ("cli");

aux = (*ref)++;

asm volatile ("sti");

return aux;

}

Komplexbefehl der Ebene 3

privilegierte Befehle cli/sti

Elementaroperation des BS

Tolerierung

int fai (int *ref) {

int aux = 1;

asm volatile ("xaddl %0,%1"

: "=g" (aux), "=g" (*ref)

: "0" (aux), "1" (*ref));

return aux;

}

Komplexbefehl der Ebene 2

unprivilegierter Befehl xadd

Elementaroperation der CPU

Beachte: Multiprozessorbetrieb

die Befehle haben nur lokale Signifikanz fur”ihren“ Prozessor(kern)


C | X Befehlssatzebene 2 Unterbrechungssteuerung 2.2 Implementierung

Unterbrechungssperre: x86

typedef unsigned short irq_t; /* flags register placeholder */

void irq_block(); /* disable interrupts at CPU */

void irq_admit(); /* enable interrupts at CPU */

irq_t irq_avert(); /* save CPU interrupt level then block */

void irq_treva(irq_t); /* restore saved CPU interrupt level */

void irq_block() {

asm volatile("cli");

}

void irq_admit() {

asm volatile("sti");

}

irq_t irq_avert() {

irq_t flags;

asm volatile(

"pushf; pop %0; cli"

: "=g" (flags));

return flags;

}

void irq_treva(irq_t flags) {

asm volatile(

"push %0; popf"

: : "g" (flags));

}


C | X Befehlssatzebene 2 Unterbrechungssteuerung 2.2 Implementierung

Schutz kritischer Abschnitte durch Unterbrechungssperre

solo-Optionen: Unterbrechungssperretypedef irq_t solo_t;

#define CS_ENTER(solo) irq_block()

#define CS_LEAVE(solo) irq_admit()

fur unverschachtelte KA

ohne Zustandssicherung

#define CS_ENTER(solo) *solo = irq_avert()

#define CS_LEAVE(solo) irq_treva(*solo)

fur verschachtelte KA

mit Zustandssicherung

Beachte: Unabhangige gleichzeitige Prozesse

werden unnotig zuruckgehalten, obwohl sie den KA nicht durchlaufen

Beachte: Unterbrechungsverzogerung

die großte WCET a aller durch Unterbrechungssperre gesicherten KA

erhohtes Risiko des Verlusts von Unterbrechungsanforderungen

aAbk. fur (engl.) worst case execution time.


C | X Befehlssatzebene 3 Schlossvariable

Gliederung




4 Zusammenfassung

5 Anhang


C | X Befehlssatzebene 3 Schlossvariable 3.1 Definition

Schlossvariable (engl. lock variable)

Datentyp, der zwei grundlegende Operationen definiert:

acquire (auch: lock) |= Eintrittsprotokoll

verzogert einen Prozess, bis das zugehorige Schloss offen ist

bei geoffnetem Schloss fahrt der Prozess unverzogert fort

verschließt das Schloss (”von innen“), wenn es offen ist

release (auch: unlock) |= Austrittsprotokoll

offnet ein Schloss, ohne den offnenden Prozess zu verzogern

Implementierungen dieses Konzepts werden auch als Schlossalgorithmen

(engl. lock algorithms) bezeichnet


C | X Befehlssatzebene 3 Schlossvariable 3.2 Implementierung

Schlossalgorithmus: Prinzip — mit Problem(en)

typedef struct lock {

volatile bool busy; /* status of critical section */

... /* optional stuff needed for other variants */

} lock_t;

Laufgefahr

void lv_acquire (lock_t *lock) {

while (lock->busy);

lock->busy = true;

}

void lv_release (lock_t *lock) {

lock->busy = false;

}

die Phase vom Verlassen derKopfschleife bis zum Setzen derSchlossvariablen ist kritisch

gleichzeitige Prozesse konnen dasSchloss geoffnet vorfinden, dannjeweils schließen und gemeinsamden kritischen Abschnitt belegen

Abprufen und setzen (engl. test and set, TAS) der Schloßvariablen

muss als Elementaroperation und wirklich atomar ausgelegt sein



Schlossvariable atomar abprufen und setzen

Kritischer Abschnitt: solo t

int tas(lock_t *lock) {

bool busy;

CS_ENTER(&lock->gate);

busy = lock->busy;

lock->busy = true;

CS_LEAVE(&lock->gate);

return busy;

}

Elementaroperation: x86

int tas(volatile bool *lock) {

bool busy;

busy = true;

asm volatile("lock xchgb %0,%1"

: "=q" (busy), "=m" (*lock)

: "0" (busy));

return busy;

}

lock t mit solo-Option:

Verdrangungssperre oder

Unterbrechungssperre

untauglich fur Multiprozessoren

lock”read-modify-write“

atomarer Buszyklus

xchgb Operandenaustausch

tauglich fur Multiprozessoren



Umlaufsperre (engl. spin lock)

”Drehschloss“

void lv_acquire (lock_t *lock) {

while (TAS(lock));

}

TAS kommt in zwei Varianten (S. 12):

7→ int tas(lock t *)7→ int tas(volatile bool *)

Gefahr von Leistungsabfall

pausenloses Schleifen allein nur mit TAS:(a) erhoht das Risiko, Anforderungen von Programmunterbrechungen oder

Prozessverdrangungen zu verpassen

die Unterbrechungs- bzw. Verdrangungssperre ist fast nur noch gesetzt

(b) hindert andere Prozessoren am Buszugang bzw. sorgt fur eine uberaushohe Last im Koharenzprotokoll des Zwischenspreichers

der Prozessor fuhrt fast nur noch”read-modify-write“-Zyklen durch

das Problem verscharft sich massiv, wenn (viele) gleichzeitige Prozesseden Wettstreit (engl. contention) um das

”Drehschloss“ aufnehmen



Sensitive Umlaufsperre

Nichtinvasives Wartenvoid lv_acquire (lock_t *lock) {

do {

while (lock->busy);

} while (TAS(lock));

}

nur lesender Zugriff beim Warten

Zwischenspeicherzeile gemeinsambenutzbar (MESI, [4])

einmal”read-modify-write“ (TAS)

beruhigend fur den Busverkehr

Zurucktretendes Wartenvoid lv_acquire(lock_t *lock) {

while (true) {

while (lock->busy);

if (!TAS(lock)) break;

lv_backoff(lock);

}

}

Eigenschaften wie zuvor, zusatzlich:

Wettstreit (engl. contention) ausdem Wege gehend

zusatzliche Wartezeit (”back-off“)

nach gescheitertem TAS

prozessspezifisch, ansteigend

Exponentielles Zurucktreten (engl. exponential back-off)

beschrankte Wartezeitverdopplung mit jedem gescheitertem Versuch


C | X Befehlssatzebene 3 Schlossvariable 3.3 Diskussion

Aktives Warten (engl. busy waiting)

Unzulanglichkeit der Schlossalgorithmen: der aktiv wartende Prozess. . .

kann keine Anderung der Bedingung herbeifuhren, auf die er wartet

behindert andere Prozesse, die sinnvolle Arbeit leisten konnten

schadet damit letztlich auch sich selbst

Je langer der Prozess den Prozessor fur sich behalt, umso langer

muss er darauf warten, dass andere Prozesse die Bedingung

erfullen, auf die er selbst wartet.

in den meisten Fallen sind Effizienzeinbußen in Kauf zu nehmen

es sei denn, jeder Prozess hat seinen eigenen realen Prozessor(kern)

Allgemein ein nur bedingt effektives Verfahren

notwendige Bedingung kurze Laufzeit des zu schutzenden KA

hinreichende Bedingung CPU-Abgabe nach gescheitertem Versuch


C | X Befehlssatzebene 3 Schlossvariable 3.3 Diskussion

Aktives Warten ohne Prozessorabgabe

”Spin locking considered harmful“

xxxxxx

xxxxxx

xxxxxx

xxx

xxx

xxx

xxxxxx

xxxxxx

xxxxxx

xxx

xxx

xxx

P1

P2

acquire release

acquire release

ZeitscheibeTs Tq Tq/Ts

P1 12 12 1.0P2 8 8 1.0

xxxxxx

xxxxxx

xxxxxx

xxxxxxxxxxxxxxxxxxxx



xxx

xxx

xxx

xxx

xxx

xxx

xxx

xxx

xxxZeitscheibeP1

P2

acquire

acquire

release

release

Zeitscheibe Ts Tq Tq/Ts

P1 12 24 2.0P2 17 23 1.35

Verbesserung: Prozessorabgabe in der Warteschleife (vgl. S. 34)

laufend 7→ bereit in Laufbereitschaft bleiben ps forgo

laufend 7→ blockiert schlafend die Schlossfreigabe erwarten ps sleep


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation

Gliederung




4 Zusammenfassung

5 Anhang


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.1 Motivation

Blockierende Synchronisation”considered harmful“

Probleme von Schlossvariablen, Semaphore und Monitore

Leistung (engl. performance) insbesondere in SMP-Systemen [1]

”spin locking“ reduziert ggf. massiv Busbandbreite

Robustheit (engl. robustness)”single point of failure“

ein im kritischen Abschnitt scheiternder Prozess kannschlimmstenfalls das ganze System lahm legen

Einplanung (engl. scheduling) wird behindert bzw. nicht durchgesetzt

un- bzw. weniger wichtige Prozesse konnen wichtigeProzesse

”ausbremsen“ bzw. scheitern lassen

Prioritatsverletzung, Prioritatsumkehr [3]

Mars Pathfinder [5, 2]

Verklemmung (engl. deadlock) einiger oder sogar aller Prozesse


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.2 Prinzip

Optimistisches Verfahren der SynchronisationNebenlaufigkeit unterstutzen, nicht einschranken wie beim wechselseitigen Ausschluss

Koordinierung sich einander ggf. uberlappender Aktivitaten, ohne dabeigleichzeitige Prozesse auszuschließen

toleriert (pseudo-) parallele Programmausfuhrungen

parallel Multiprozessor, wirkliche Parallelitatpseudoparallel Uniprozessor, Parallelitat durch Unterbrechungen

die Verfahren greifen auf nichtprivilegierte Befehle der ISA zuruck

CISC TAS, FAA, CAS bzw. CMPXCHGRISC LL/SC

d.h., sie funktionieren im Benutzer- wie auch im Systemmodus

Beachte

kein wechselseitiger Ausschluss ⇒ Verklemmungsvorbeugung

die benutzten Befehle mussen”echte“ Elementaroperationen


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.2 Prinzip

Muster nichtblockierender Synchronisation (NBS)

erledige NBS mit CAS;wiederhole

ziehe lokale Kopie des Inhalts der Adresse einer globalen Variablen;verwende die Kopie, um einen neuen lokalen Wert zu berechnen;versuche CAS: sichere den lokalen Wert an die Adresse, wenn ihrInhalt immer noch mit dem Wert der lokalen Kopie identisch ist;

solange CAS scheitert;basta.

pros Tolerierung beliebiger Uberlappungsmustertransparent fur die Einplanung: keine PrioritatsumkehrVerklemmungsvorbeugung: kein wechselseitiger AusschlussRobustheit: keine hangenden Sperren bei Programmabbruchen

cons Wiederverwendung sequentieller Altsoftware unmoglichGefahr von Verhungerung (engl. starvation) in simplen LosungenEntwicklung nebenlaufiger Varianten im Regelfall nicht trivial


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.3 Elementaroperation

Bedingte Wertzuweisung: Compare and Swap, CAS

int cas(word_t *ref, word_t exp, word_t val) {

solo_t gate; /* assume bus resp. interrupt lock */

bool done;

CS_ENTER(&gate);

if (done = (*ref == exp)) *ref = val;

CS_LEAVE(&gate);

return done;

}

ref die Adresse des atomar, bedingt zu andernden Speicherworts

exp der unter der Adresse ref erwartete alte Wert

val der unter der Adresse ref zu speichernde neue Wertdie Speicherung erfolgt nur, wenn der unter ref gespeicherteWert dem erwarteten Wert exp gleichtlag Gleichheit vor, liefert die Funktion true, anderenfalls false


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.3 Elementaroperation

Bedingte Wertzuweisung: CAS als Spezialbefehl (x86)

ZF = (eax == *ref) ? (*ref = val, true) : (eax = *ref, false)

int cas(word_t *ref, word_t exp, word_t val) {

unsigned char done; /* "sete" writes to low byte of operand */

asm volatile(

"lock\n\t" /* next comes atomic read-modify-write */

"cmpxchgl %2,%1\n\t" /* conditional exchange of operands */

"sete %0" /* transfer value of zero flag (ZF bit) */

: "=q" (done), "=m" (*ref)

: "r" (val), "m" (*ref), "a" (exp)

: "memory");

return done;

}

lock setzt die Bussperre fur den nachfolgenden Befehlzwingend fur Multi(kern)prozessorsysteme, optional sonst

cmpxchgl compare & exchange: ZF = true → Speicherung erfolgtsete definiert Variable done mit dem Wert der ZF-Flagge


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.4 Anwendung

Sperrfreie (engl. lock-free) WartestapelmanipulationLCFS (Abk. fur engl. last come, first served)

Aufnahme in die Liste. . .void lf_push(chain_t *head, chain_t *item) {

do item->link = head->link; /* is elected head */

while (!CAS(&head->link, item->link, item)); /* try push item */

}

Entnahme aus der Liste. . .chain_t *lf_pull(chain_t *head) {

chain_t *item;

do if ((item = head->link) == 0) break; /* access head */

while (!CAS(&head->link, item, item->link)); /* try pull item */

return item;

}

#define CAS(r,e,v) cas((word_t*)r, (word_t)e, (word_t)v)



Problem ABATransaktion gelingt trotz zwischenzeitlicher Anderungen

Phanomen der nichtblockierenden Synchronisation auf Basis eines CAS,d.h., einer ELOP, die inhaltsbasiert arbeitet1

angenommen zwei Faden, F1 und F2, stehen im Wettstreit um einegemeinsame Variable V

F1 liest den Wert A von V , speichert diesen als Kopie, wird dannallerdings vor dem CASV fur unbestimmte Zeit verzogert

F2 durchlauft dieselbe Sequenz, schafft jedoch mittels CASV den WertB an V zuzuweisenanschließend wird (in einem weiteren Durchlauf dieser Sequenz)wieder der ursprungliche Wert A an V zugewiesen

F1 setzt seine Ausfuhrung mit CASV fort, erkennt, dass V den Wert A

seiner Kopie speichert und uberschreibt V

im Ergebnis kann dieses Uberlappungsmuster dazu fuhren, dass F1

mittels CASV einen falschen Wert nach V transferiert

1Bei Adressreservierung wie z.B. mit LL/SC besteht dieses Problem nicht.c©wosch (Lehrstuhl Informatik 4) Systemprogrammierung WS2010/11 24 / 34


Problem ABA: Wartestapel mit Wettlaufsituation

Ausgangszustand der (LCFS) Liste: head A B C , head ist refCAS :

CAS-Parameter

b Op. *ref exp val Liste

1. F1 pull A A B unverandert

2. F2 pull A A B ref B C

3. F2 pull B B C ref C

4. F2 push C C A ref A C

5. F1 pull A A B ref B / A C verloren

1. F1 wird im pull vor CAS unterbrochen, behalt lokalen Zustand bei

2.–4. F2 fuhrt die Operationen komplett aus, aktualisiert die Liste

5. F1 beendet pull mit dem zum Zeitpunkt 1. gultigen lokalen Zustand



Kritische Variable mittels”Zeitstempel“ absichern

Abhilfe besteht darin, den umstrittenen Zeiger (namlich item) um einenproblemspezifischen Generationszahler zu erweitern

Etikettieren Zeiger mit einem Anhanger (engl. tag) versehenAusrichtung (engl. alignment) ausnutzen, z.B.:

sizeof (chain t) ; 4 = 22 ⇒ n = 2

⇒ chain t ∗ ist Vielfaches von 4

⇒ chain t ∗Bits[0:1] immer 0

Platzhalter fur n-Bit Marke/Zahler in jedem Zeiger

DCAS Abk. fur (engl.) double compare and swapMarke/Zahler als elementaren Datentyp auslegen

unsigned int hat Wertebereich von z.B. [0, 232 − 1]

zwei Maschinenworte (Zeiger, Marke/Zahler) andern

push bzw. pull verandern sodann den Zeigerwert um eine Generation


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.5 Diskussion

Generationszahler”considered harmful“?

Abhilfe (engl. workaround) zum ABA-Problem ; Bedingte Losung

die Effektivitat des Losungsansatzes steht und fallt mit dem fur denGenerationszahler definierten endlichen Wertebereich

dessen Auslegung letztlich vom jeweiligen Anwendungsfall abhangt

Uberlappungsmuster gleichzeitiger Prozesse haben Einfluss auf denfur den Generationszahler zur Verfugung zu stellenden Wertebereich

bestimmt durch Zusammenspiel und Anzahl der wettstreitigen Fadenein Bit kann reichen, ebenso, wie ein unsigned int zu klein sein kann

diese, dem jeweiligen Anwendungsfall zu entnehmenden Muster zuentdecken, ist zumeist schwer und nicht selten unmoglich

Vorbeugung (engl. prevention) muss zuerst kommen — sofern machbar:

beliebige Uberlappungsmuster konstruktiv (Entwurf) ausschließenoder auf Adressreservierungsverfahren der Hardware zuruckgreifen

unterstutzt nicht jede Hardware, ist nur typisch fur RISCz.B. ELOP-Paar load linked, store conditional (LL/SC) verwenden


C | X Befehlssatzebene 4 Nichtblockierende Synchronisation 4.5 Diskussion

Wiederholungsversuche — Aktives Warten?

Scheitern der etwa durch CAS2 abzuschließenden Transaktion zieht dieWiederholung des kompletten Vorbereitungsvorgangs nach sich

je hoher der Grad an Wettstreitigkeit unter gleichzeitigen Prozessen,umso hoher die Wahrscheinlichkeit, dass CAS scheitert

ein zur Umlaufsperre sehr ahnliches Problem ergibt sich, das jedochdurch sensitive Techniken gleicher Art losbar ist (vgl. S. 13–14)

Haufigkeit von”read-modify-write“-Zyklen pro Durchlauf minimieren

prozessspezifisches Zurucktreten vom erneuten Transaktionsversuchvariable Wartezeiten, um Konflikte bei Wiederholungen zu vermeiden

Unterschied zur Umlaufsperre

gleichzeitige Prozesse mussen nicht untatig darauf warten, dass einkritischer Abschnitt frei ist, d.h., das TAS gelingt

sie verlassen die Schleife jedoch erst, wenn das CAS gelingt, kommenin der Schleife allerdings mit ihren (lokalen) Berechnungen voran

2Fur LL/SC-artige Elementaroperationen gilt dies ebenfalls.c©wosch (Lehrstuhl Informatik 4) Systemprogrammierung WS2010/11 28 / 34

C | X Befehlssatzebene 5 Zusammenfassung

Gliederung




4 Zusammenfassung

5 Anhang


C | X Befehlssatzebene 5 Zusammenfassung

Resumee

Unterbrechungssteuerung ist leicht, aber nicht immer zweckmaßigverlangt von den Prozessen besondere Rechte: privilegierte Befehle

unbeteiligte gleichzeitige Prozesse werden unnotig ausgesperrtexterne Ereignisse (Interrupts) konnen verloren gehenungeeignet fur Multi(kern)prozessorsysteme: lokale Signifikanz

die Schlossvariable kommt meist mit Umlaufsperre zum Einsatzpessimistischer Ansatz zum Schutz kritischer Abschnitte: leicht

gleichzeitige Prozesse werden als sehr wahrscheinlich angenommenbezogen auf den jeweils zu schutzenden kritischen Abschnitt

im Regelfall bedingen Leistungsanforderungen sensitive Verfahren

Haufigkeit von”read-modify-write“-Zyklen pro Durchlauf minimieren

prozessspezifisches Zurucktreten vom erneuten Schließversuch mit TASvariable Wartezeiten, um Konflikte bei Wiederholungen zu vermeiden

als blockierende Synchronisation besteht hohe Verklemmungsgefahr

nichtblockierende Synchronisation ist frei von Verklemmungenoptimistischer Ansatz zum Schutz kritischer Abschnitte: schwer

die Verfahren mussen ebenfalls sensitiv fur Plattformeigenschaften sein


C | X Befehlssatzebene 5 Zusammenfassung 5.1 Bibliographie

Literaturverzeichnis

[1] Bryant, R. ; Chang, H.-Y. ; Rosenburg, B. S.:Experience Developing the RP3 Operating System.In: Computing Systems 4 (1991), Nr. 3, S. 183–216

[2] Jones, M. B.:What really happened on Mars?http://www.research.microsoft.com/~mbj/Mars_Pathfinder/Mars_Pathfinder.html ,1997

[3] Lampson, B. W. ; Redell, D. D.:Experiences with Processes and Monitors in Mesa.In: Communications of the ACM 23 (1980), Febr., Nr. 2, S. 105–117

[4] Papamarcos, M. S. ; Patel, J. H.:A Low-Overhead Coherence Solution for Multiprocessors with Private Cache Memories.In: Proceedings of the 11th Annual International Symposium on Computer Architecture(ISCA ’84), June 5–7, 1984, Ann Arbor, Michigan, USA, ACM Press, 1984, S. 348–354

[5] Wilner, D. :Vx-Files: What really happened on Mars?Keynote at the 18th IEEE Real-Time Systems Symposium (RTSS ’97), Dez. 1997


C | X Befehlssatzebene 6 Anhang

Gliederung




4 Zusammenfassung

5 Anhang


C | X Befehlssatzebene 6 Anhang 6.1 Umlaufsperre

Zurucktreten vom aktiven Warten mit Prozessorabgabe

void lv_backoff(lock_t *lock) {

time_t t0, t1, t2;

t0 = ps_pitch(pd_being());

t1 = t_stamp();

lv_suspend(lock);

t2 = t_stamp();

if (t_pitch(t1, t2) < t0)

ps_delay(t0 - t_pitch(t1, t2));

}

Prozessverwaltung

ps pitch definiert den Abstandzum nachsten Versuch

ps delay verzogert den Prozess:Prozessorabgabe

Zeitverwaltung

t stamp liefert einen Zeitwert

t pitch berechnet Zeitabstand

Beachte: Benutzte Abstraktionsebene

Prozessorabgabe setzt ein Prozesskonzept voraus, das typischerweisevon einem Betriebssystem bereitgestellt wird

in dieser Implementierungsvariante wird die Umlaufsperre zu einemKonzept der Maschinenprogrammebene


C | X Befehlssatzebene 6 Anhang 6.1 Umlaufsperre

Prozessorabgabe: passives Warten auf Freigabe der Sperre

Laufbereit bleibendvoid lv_suspend(lock_t *lock) {

ps_forgo();

}

Effektivitat hangt stark ab von derUmplanungsstrategie:

RR der Prozess kommt ans Endeder Bereitliste ,

sonst seine (stat./dyn.) Prioritatbestimmt die Listenposition

ggf. landet er ganz vorneso dass er weiterlauft /

Sperrfreigabe erwartend

void lv_suspend(lock_t *lock) {

ps_sleep(&lock->bell);

}

schlafen legende Schlossvariable

(engl. sleeping lock)

Bedingungssynchronisation

Angepasste Sperrfreigabe

void lv_release (lock_t *lock) {

lock->bolt = 0;

ps_rouse(lock);

}

Wach bleiben oder schlafen legen. . .

eine Frage des jew. Anwendungsprofils und der Einplanungsstrategie


Prozesssynchronisation: Befehlssatzebene Wolfgang Schr ... fileSystemprogrammierung...

Documents

Transcript of Prozesssynchronisation: Befehlssatzebene Wolfgang Schr ... fileSystemprogrammierung...