Prr r r - PowerPoint PPT Presentation

❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❛♥❞ ❙❡r✈✐❝❡ ❙❤❛♥❦❛r ❙❡♣t❡♠❜❡r ✶✽✱ ✷✵✶✹

❖✉t❧✐♥❡ ❧♦❝❦ ♣r♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡ Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

Pr♦❣r❛♠ SimpleLock(N) ♦✈❡r✈✐❡✇ ❧♦❝❦ ♣r♦❣r❛♠ ▲♦❝❦ ❢♦r t❤r❡❛❞s 0 ✱ · · · ✱ N − 1 ✴✴ N ≥ 1 ✐♥♣✉t ❢✉♥❝t✐♦♥s✿ acq() ✱ rel() ✱ end() ♥♦♥✲✐♥♣✉t ❢✉♥❝t✐♦♥✿ serve() ▼❛✐♥ ❜♦♦❧ xreq[N] ✿ xreq[i] tr✉❡ ✐✛ ✉s❡r i ❤❛s ♦♥❣♦✐♥❣ r❡q✉❡st ❜♦♦❧ xacq ✿ tr✉❡ ✐✛ ❛ ✉s❡r ❤♦❧❞s t❤❡ ❧♦❝❦ st❛rt t❤r❡❛❞ ❡①❡❝✉t✐♥❣ serve() ❋✉♥❝t✐♦♥ serve() ❝②❝❧❡ t❤r♦✉❣❤ ❡♥tr✐❡s ♦❢ xreq ✐❢ xreq[j] tr✉❡✿ s❡t xacq ✱ ✉♥s❡t xreq[j] ✱ ✇❛✐t ❢♦r xacq ❢❛❧s❡ ■♥♣✉t ❢✉♥❝t✐♦♥s acq() ✿ s❡t xreq[mytid] ✱ ✇❛✐t ❢♦r ✐t t♦ ❜❡ ❢❛❧s❡❀ r❡t✉r♥ rel() ✿ ✉♥s❡t xacq ❀ r❡t✉r♥ end() ✿ ❡①❡❝✉t❡ endSystem() ❀ r❡t✉r♥

Pr♦❣r❛♠ SimpleLock(N) ✕ ✶ ❧♦❝❦ ♣r♦❣r❛♠ program SimpleLock(int N) { ia {N ≥ 1} boolean[N] xreq ← false; boolean xacq ← false; int xp ← 0; Tid t ← startThread(serve()); ◆♦t❡ t❤❡ • ✬s return mysid; ✐❣♥♦r❡ t❤❡♠ ❢♦r ♥♦✇ function void serve() { ❧❛t❡r ✇❡ r❡❢❡r t♦ t❤❡♠ ❛s while (true) ✏❛t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥ts✑ a0: if • (xreq[xp]) a1: • xacq ← true; a2: • xreq[xp] ← false; while • (xacq) skip; a3: a4: xp ← mod(xp+1, N); }

SimpleLock(N) ✕ ✷ ❧♦❝❦ ♣r♦❣r❛♠ input void mysid.acq() ia {mytid in 0..N − 1} a5: xreq[mytid] ← true; a6: while • (xreq[mytid]) skip; atomicity assumption: return; reads and writes of } xacq, input void mysid.rel() { xreq[0], ..., xreq[N − 1] ia {mytid in 0..N − 1} a7: xacq ← false; progress assumption: return; weak fairness } for threads input void mysid.end() { } ia {true} endSystem(); }

❙♦♠❡ Pr♦♣❡rt✐❡s ♦❢ SimpleLock(N) ❧♦❝❦ ♣r♦❣r❛♠ ■♥♣✉t ❛ss✉♠♣t✐♦♥s ♦❢ acq() ❛♥❞ rel() ❛r❡ ✏✇❡❛❦✑ ♦♥❧② r❡q✉✐r❡ ❝❛❧❧❡r t✐❞ t♦ ❜❡ ✐♥ 0..N − 1 ❛❧❧♦✇ acq() ❝❛❧❧❡r t♦ ❤♦❧❞ ❧♦❝❦ ❛❧❧♦✇ rel() ❝❛❧❧❡r t♦ ♥♦t ❤♦❧❞ ❧♦❝❦ ❍❡♥❝❡ t❤❡ ♣r♦❣r❛♠ ❤❛s s♦♠❡ ♦❞❞ ❛❧❧♦✇❡❞ ❡✈♦❧✉t✐♦♥s ❡✳❣✳✱ t✇♦ ✉s❡rs ❤♦❧❞ ❧♦❝❦ s✐♠✉❧t❛♥❡♦✉s❧② ❬❜✉t ✐t ❞♦❡s ✐♠♣❧❡♠❡♥t SimpleLockService ❪ ■♥♣✉t ❛ss✉♠♣t✐♦♥s ❛r❡ s✉✣❝✐❡♥t t♦ ❡♥s✉r❡ ❢♦❧❧♦✇✐♥❣ SimpleLock(N) ✐s ❢❛✉❧t✲❢r❡❡ ✴✴ ♥♦ ❛❧❧♦✇❡❞ ❡✈♦❧✉t✐♦♥ ✐s ❢❛✉❧t② t❤❡ • ✬s ❛r❡ ❛ ✈❛❧✐❞ s❡t ♦❢ ❛t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥ts ✴✴ ❝♦❞❡ ❜❡t✇❡❡♥ t✇♦ s✉❝❝❡ss✐✈❡ • ✬s ✐s ❡✛❡❝t✐✈❡❧② ❛t♦♠✐❝

❖✉t❧✐♥❡ ❧♦❝❦ s❡r✈✐❝❡ ❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡ Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ ❖✈❡r✈✐❡✇ ❧♦❝❦ s❡r✈✐❝❡ ▲♦❝❦ ❢♦r t❤r❡❛❞s 0 ✱ · · · ✱ N − 1 ▼❛✐♥ ✈❛rs ✐♥❞✐❝❛t✐♥❣✿ ✇❤❡t❤❡r ❡♥❞✐♥❣❀ ✇❤✐❝❤ ✉s❡r ✭✐❢ ❛♥②✮ ❤❛s ❧♦❝❦ ■♥♣✉t ❢✉♥❝t✐♦♥s acq() ✱ rel() ✱ end() ◆♦ ♦✉t♣✉t ❢✉♥❝t✐♦♥ ❉❡✜♥❡s ❛❧❧ ❛❝❝❡♣t❛❜❧❡ ✐♦ s❡q✉❡♥❝❡s ❈♦♥str❛✐♥s ❜♦t❤ ❡♥✈✐r♦♥♠❡♥t ❛♥❞ ❧♦❝❦✱ ❡✳❣✳✱ acq.ia ✿ ♥♦t ❡♥❞✐♥❣✱ ❝❛❧❧❡r ✐♥ 0..N − 1 ✱ ❞♦❡s ♥♦t ❤♦❧❞ ❧♦❝❦ ❆t♦♠✐❝✐t② ❛ss✉♠♣t✐♦♥s✿ ✐♥♣✉t ♣❛rts ❛♥❞ ♦✉t♣✉t ♣❛rts Pr♦❣r❡ss ❛ss✉♠♣t✐♦♥s✿ acq() r❡t✉r♥s ❡✈❡♥t✉❛❧❧② ✐❢ ❧♦❝❦ ❜❡❝♦♠❡s r❡♣❡❛t❡❞❧② ❢r❡❡ rel() ❛♥❞ end() ❡❛❝❤ r❡t✉r♥s ❡✈❡♥t✉❛❧❧②

Pr♦❣r❛♠ SimpleLockService ✕ ✶ ❧♦❝❦ s❡r✈✐❝❡ service SimpleLockService(int N) { ic {N ≥ 1} boolean[N] acqd ← false; // acqd[i] true iff i has lock ending ← false; // termination initiated return mysid; input void mysid.acq() { ic {not ending and (mytid in 0..N − 1) and not acqd[mytid]} oc {forall(j in 0..N − 1: not acqd[j])} acqd[mytid] ← true; return; }

Pr♦❣r❛♠ SimpleLockService ✕ ✷ ❧♦❝❦ s❡r✈✐❝❡ input void mysid.rel() { ic {not ending and (mytid in 0..N − 1) and acqd[mytid]} acqd[mytid] ← false; oc {true} return; } input void mysid.end() { ic {not ending} ending ← true; oc {true} return; }

Pr♦❣r❛♠ SimpleLockService ✕ ✸ ❧♦❝❦ s❡r✈✐❝❡ atomicity assumption {input parts and output parts} progress assumption { // rel r❡t✉r♥s forall(i: (i in mysid.rel) ❧❡❛❞s✲t♦ (not i in mysid.rel)); // ✐❢ ♥♦ ♦♥❡ ❤♦❧❞s t❤❡ ❧♦❝❦ ❢♦r❡✈❡r t❤❡♥ acq r❡t✉r♥s forall(i: acqd[i] ❧❡❛❞s✲t♦ not acqd[i]) ⇒ forall(i: (i in mysid.acq) ❧❡❛❞s✲t♦ (not i in mysid.acq)); // end r❡t✉r♥s forall(i: (i in mysid.end) ❧❡❛❞s✲t♦ (not i in mysid.end)); } } ❈♦♥✈❡♥t✐♦♥✿ i ✱ j r❛♥❣❡ ♦✈❡r 0..N − 1

❖❜s❡r✈❛t✐♦♥s ♦♥ SimpleLockService(N) ❧♦❝❦ s❡r✈✐❝❡ Pr♦❣r❛♠ ✐s ❢❛✉❧t✲❢r❡❡❡ ♦t❤❡r✇✐s❡ ✐t✬s ✉s❡❧❡ss ❛s ❛ s❡r✈✐❝❡ ❆t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥ts ❛t ✭❛♥❞ ♦♥❧② ❛t✮ ♦✉t♣✉t ❝♦♥❞✐t✐♦♥s ♥❛t✉r❛❧ ❝♦♥s❡q✉❡♥❝❡ ♦❢ ❛t♦♠✐❝✐t② ❛ss✉♠♣t✐♦♥s Pr♦❣r❡ss st❛t❡❞ ❜② ❧❡❛❞s✲t♦ ✭❛♥❞ ♥♦t ❢❛✐r♥❡ss✮ ❛ss❡rt✐♦♥s ❈♦♠♣❛r✐♥❣ ❛❣❛✐♥st SimpleLock ✐♥♣✉t ❝♦♥❞✐t✐♦♥s str♦♥❣❡r t❤❛♥ SimpleLock ✬s ✐♥♣✉t ❛ss✉♠♣t✐♦♥s s♦ ♣r❡❝❧✉❞❡s s♦♠❡ ✭✏♦❞❞✑✮ ❡✈♦❧✉t✐♦♥s ♦❢ SimpleLock ❤❛s ✐♦ s❡q✉❡♥❝❡s ♥♦t ❛❝❤✐❡✈❛❜❧❡ ❜② SimpleLock(N)

❖✉t❧✐♥❡ ✐♠♣❧❡♠❡♥ts ❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡ Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

❖✈❡r✈✐❡✇✿ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡ ✐♠♣❧❡♠❡♥ts ❉❡✜♥❡ ❧♦❝❦✲s❡r✈✐❝❡ ✐♥✈❡rs❡ ♣r♦❣r❛♠ ♠♦st ❣❡♥❡r❛❧ ❡♥✈✐r♦♥♠❡♥t ❢♦r ❛ ❧♦❝❦ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ❉❡✜♥❡ ♣r♦❣r❛♠ Z ✿ ❝♦♥❝✉rr❡♥t❧② ❡①❡❝✉t❡s ✐♠♣❧❡♠❡♥t❛t✐♦♥ ❛♥❞ s❡r✈✐❝❡ ✐♥✈❡rs❡ ❉❡✜♥❡ t❤❡ ❛ss❡rt✐♦♥s t❤❛t Z ♠✉st s❛t✐s❢② s❛❢❡t②✿ Z s❛t✐s✜❡s ✐♥✈❡rs❡✬s ✐♥♣✉t ❝♦♥❞✐t✐♦♥s ♣r♦❣r❡ss✿ Z ✐♥✈❡rs❡✬s ♣r♦❣r❡ss ❛ss❡rt✐♦♥s Pr♦✈❡ t❤❛t Z s❛t✐s✜❡s ❛❜♦✈❡ ❛ss❡rt✐♦♥s

❖✉t❧✐♥❡ ✐♥✈❡rs❡ s❡r✈✐❝❡ ✐♠♣❧❡♠❡♥ts ❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ ■♥✈❡rs❡ ■♠♣❧❡♠❡♥ts ❝♦♥❞✐t✐♦♥s Pr♦✈✐♥❣ t❤❡ ■♠♣❧❡♠❡♥ts ❈♦♥❞✐t✐♦♥s Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

SimpleLockService ■♥✈❡rs❡ ✕ ✶ ✐♥✈❡rs❡ s❡r✈✐❝❡ ✐♠♣❧❡♠❡♥ts service SimpleLockService(int N) { program SimpleLockServiceInverse(int N, Sid lck) { // lck: lock system being tested ic {N ≥ 1} boolean[N] acqd ← false; ending ← false; return mysid; input void mysid.acq() { output doAcq() { ic oc {not ending and (mytid in 0..N − 1) and not acqd[mytid]} lck.acq(); oc ic {forall(j in 0..N − 1: not acqd[j])} acqd[mytid] ← true; return; }