Prr r r - - PowerPoint PPT Presentation

▶
pr r r
SMART_READER_LITE
LIVE PREVIEW

Prr r r - - PowerPoint PPT Presentation

Jun 17, 2023 448 likes •799 views

Prr r r tr t rr Prr

slide-1
SLIDE 1

❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❛♥❞ ❙❡r✈✐❝❡

❙❤❛♥❦❛r ❙❡♣t❡♠❜❡r ✶✽✱ ✷✵✶✹

slide-2
SLIDE 2

❖✉t❧✐♥❡

❧♦❝❦ ♣r♦❣r❛♠

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

slide-3
SLIDE 3

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♥

slide-4
SLIDE 4

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()); return mysid; function void serve() { while (true) a0: if • (xreq[xp]) a1:

  • xacq ← true;

a2:

  • xreq[xp] ← false;

a3: while • (xacq) skip; a4: xp ← mod(xp+1, N); }

◆♦t❡ t❤❡ •✬s ✐❣♥♦r❡ t❤❡♠ ❢♦r ♥♦✇ ❧❛t❡r ✇❡ r❡❢❡r t♦ t❤❡♠ ❛s ✏❛t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥ts✑

slide-5
SLIDE 5

SimpleLock(N)

✕ ✷

❧♦❝❦ ♣r♦❣r❛♠

input void mysid.acq() ia {mytid in 0..N−1} a5: xreq[mytid] ← true; a6: while • (xreq[mytid]) skip; return; } input void mysid.rel() { ia {mytid in 0..N−1} a7: xacq ← false; return; } input void mysid.end() { ia {true} endSystem(); } atomicity assumption: reads and writes of xacq, xreq[0], ..., xreq[N−1] progress assumption: weak fairness for threads }

slide-6
SLIDE 6

❙♦♠❡ 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♦♠✐❝

slide-7
SLIDE 7

❖✉t❧✐♥❡

❧♦❝❦ s❡r✈✐❝❡

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

slide-8
SLIDE 8

❙✐♠♣❧❡ ▲♦❝❦ ❙❡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✉❛❧❧②

slide-9
SLIDE 9

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]}

  • c {forall(j in 0..N−1: not acqd[j])}

acqd[mytid] ← true; return; }

slide-10
SLIDE 10

Pr♦❣r❛♠ SimpleLockService ✕ ✷

❧♦❝❦ s❡r✈✐❝❡

input void mysid.rel() { ic {not ending and (mytid in 0..N−1) and acqd[mytid]} acqd[mytid] ← false;

  • c {true}

return; } input void mysid.end() { ic {not ending} ending ← true;

  • c {true}

return; }

slide-11
SLIDE 11

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

slide-12
SLIDE 12

❖❜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)

slide-13
SLIDE 13

❖✉t❧✐♥❡

✐♠♣❧❡♠❡♥ts

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

slide-14
SLIDE 14

❖✈❡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

slide-15
SLIDE 15

❖✉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✈✐❝❡

slide-16
SLIDE 16

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() {

  • utput doAcq() {

ic oc {not ending and (mytid in 0..N−1) and not acqd[mytid]} lck.acq();

  • c ic {forall(j in 0..N−1: not acqd[j])}

acqd[mytid] ← true; return; }

slide-17
SLIDE 17

SimpleLockService ■♥✈❡rs❡

✕ ✷

✐♥✈❡rs❡ s❡r✈✐❝❡ ✐♠♣❧❡♠❡♥ts

  • utput doRel() input void mysid.rel() {

ic oc {not ending and (mytid in 0..N−1) and acqd[mytid]} acqd[mytid] ← false; lck.rel();

  • c ic {true}

return; } input void mysid.end() {

  • utput doEnd() {

ic oc {not ending} ending ← true; lck.end();

  • c ic {true}

return; }

slide-18
SLIDE 18

SimpleLockService ■♥✈❡rs❡

✕ ✸

✐♥✈❡rs❡ s❡r✈✐❝❡ ✐♠♣❧❡♠❡♥ts

atomicity assumption {input parts and output parts} progress assumption condition { forall(i: (i in mysid lck.rel)

❧❡❛❞s✲t♦

(not i in mysid lck.rel)); forall(i: acqd[i] ❧❡❛❞s✲t♦ not acqd[i]) ⇒ forall(i: (i in mysid lck.acq)

❧❡❛❞s✲t♦

(not i in mysid lck.acq)); forall(i: (i in mysid lck.end)

❧❡❛❞s✲t♦

(not i in mysid lck.end)); } }

slide-19
SLIDE 19

❖✉t❧✐♥❡

❝♦♥❞✐t✐♦♥s ✐♠♣❧❡♠❡♥ts

❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡

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

Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

slide-20
SLIDE 20

Pr♦❣r❛♠ ♦❢ ❧♦❝❦ ❛♥❞ ✐♥✈❡rs❡ s❡r✈✐❝❡

❝♦♥❞✐t✐♦♥s ✐♠♣❧❡♠❡♥ts

program Z(int N) { ic {N ≥ 1} inputs(); outputs(); // aggregate sys- tem Z is closed Sid lck ← startSystem(SimpleLock(N)); Sid lsi ← startSystem(SimpleLockServiceInverse(N, lck)); return mysid; atomicity assumption {} progress assumption {weak fairness} }

slide-21
SLIDE 21

❆ss❡rt✐♦♥s t❤❛t Z(N) ♠✉st s❛t✐s❢②

❝♦♥❞✐t✐♦♥s ✐♠♣❧❡♠❡♥ts

B✵ : ■♥✈ [(i at lsi.doAcq.ic) ⇒ forall(j: not acqd[j])] B✶ : (i in lck.rel) ❧❡❛❞s✲t♦

(not i in lck.rel)

B✷ : forall(i:

acqd[i] ❧❡❛❞s✲t♦ not acqd[i]) ⇒ forall(i: (i in lck.acq) ❧❡❛❞s✲t♦ (not i in lck.acq))

B✸ : (i in lck.end) ❧❡❛❞s✲t♦

(not i in lck.end)

❘❡❝❛❧❧ ❝♦♥✈❡♥t✐♦♥s

i✱ j r❛♥❣❡ ♦✈❡r 0..N−1

❢r❡❡ ✈❛r✐❛❜❧❡s ❛r❡ ✉♥✐✈❡rs❛❧❧② q✉❛♥t✐✜❡❞ ❡✳❣✳✱ B✸ ❡q✉✐✈❛❧❡♥t t♦ forall(i: B✸)

slide-22
SLIDE 22

❖✉t❧✐♥❡

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❙✐♠♣❧❡ ▲♦❝❦ Pr♦❣r❛♠ ❙✐♠♣❧❡ ▲♦❝❦ ❙❡r✈✐❝❡ Pr♦✈✐♥❣ ▲♦❝❦ ■♠♣❧❡♠❡♥ts ❙❡r✈✐❝❡

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

Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r ✉s✐♥❣ ▲♦❝❦ ❙❡r✈✐❝❡

slide-23
SLIDE 23

❊✛❡❝t✐✈❡ ❛t♦♠✐❝✐t② ♦❢ Z(N)

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

system lck(N) <main> fn serve(){...•• · · · ...} input acq(){...•...} input rel(){...} input end(){...} system lsi(N,lck) <main>

  • utput doAcq(){•oc ...}
  • utput doRel(){•oc ...}
  • utput doEnd(){•oc ...}

st❡♣ Z✳✐♥✐t✿

Z✳♠❛✐♥✱ lck✳✐♥✐t✱ lsi✳♠❛✐♥

st❡♣ doAcq✳❝❛❧❧✿

lsi.doAcq.oc• −

→ lck.acq• st❡♣ acq✳r❡t✿

lck.acq• −

→ lsi.doAcq✳❡♥❞ st❡♣ doRel✿

lsi.doRel.oc• −

→ lck.rel − → lsi.doRel✳❡♥❞ st❡♣ doEnd✿

lsi.doEnd.oc• −

→ lck.end − → lsi.doEnd✳❡♥❞ st❡♣s ✐♥ lck.serve() ❞❡✜♥❡❞ ❜② ✐ts •✬s ✈❛❧✐❞ ✐♥ Z ❜❡❝❛✉s❡ lck ❣❡ts ♦♥❧② ❛❧❧♦✇❡❞ ✐♥♣✉ts ✭❢r♦♠ lsi✮

slide-24
SLIDE 24

Pr♦♦❢ ♦❢ s❛❢❡t② ❝♦♥❞✐t✐♦♥✿ B✵

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❘❡❝❛❧❧ B✵✿ ✐❢ t❤r❡❛❞ ❛t doAcq.ic t❤❡♥ ❡✈❡r② acqd[j] ✐s ❢❛❧s❡

  • ✐✈❡♥ Z✬s ❡✛❡❝t✐✈❡ ❛t♦♠✐❝✐t②✱ B✵ ✐s ❡q✉✐✈❛❧❡♥t t♦ ■♥✈ C✵

C✵ : ((i on lck.acq•) and not lck.xreq[i]) ⇒

forall(j: not lsi.acqd[j])

■♥✈ C✶ ❛♥❞ ■♥✈ C✷ ❤♦❧❞ ✴✴ ♦♣❡r❛t✐♦♥❛❧ r❡❛s♦♥✐♥❣ C✶ : (lck.alive and (not t on a3)) ⇒ forall(j: not acqd[j]) C✷ : (t on a3) ⇒

((acqd[xp]

  • r

(not acqd[xp] and (xp on a6) and not xreq[xp])) and forall(j, j = xp: not acqd[j]))

■♥✈ C✵ ❤♦❧❞s ❢r♦♠ ■♥✈ C✶ ❛♥❞ ■♥✈ C✷ ✴✴ ♦♣❡r❛t✐♦♥❛❧ r❡❛s♦♥✐♥❣

slide-25
SLIDE 25

Pr♦♦❢ ♦❢ ♣r♦❣r❡ss ❝♦♥❞✐t✐♦♥✿ B✶ ❛♥❞ B✸

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❘❡❝❛❧❧ B✶✿ t❤r❡❛❞ ✐♥ lck.rel ❡✈❡♥t✉❛❧❧② ❧❡❛✈❡s lck.rel B✶ ❤♦❧❞s

lck.rel✳❜♦❞② ❤❛s ♥♦ ❧♦♦♣s ❛♥❞ ♥♦ ❜❧♦❝❦✐♥❣

t❤r❡❛❞ ❤❛s ✇❡❛❦ ❢❛✐r♥❡ss ✭❢r♦♠ lck ♣r♦❣r❡ss ❛ss✉♠♣t✐♦♥✮ ❘❡❝❛❧❧ B✸✿ t❤r❡❛❞ ✐♥ lck.end ❡✈❡♥t✉❛❧❧② ❧❡❛✈❡s lck.end B✸ ❤♦❧❞s ❥✉st ❧✐❦❡ B✶

slide-26
SLIDE 26

Pr♦♦❢ ♦❢ ♣r♦❣r❡ss ❝♦♥❞✐t✐♦♥✿ B✷ ✕ ✶

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❘❡❝❛❧❧ B✷✿ D✵ ⇒ D✶✱ ✇❤❡r❡ D✵ : acqd[i] ❧❡❛❞s✲t♦

not acqd[i]

D✶ : (k in lck.acq) ❧❡❛❞s✲t♦

(not k in lck.acq)

❲❡ ✇✐❧❧ ❡st❛❜❧✐s❤ t❤❡ ❢♦❧❧♦✇✐♥❣ D✷ : ❬t ❛t a0✱ xp = j✱ j ✐♥ lck.acq❪ ❧❡❛❞s t♦ ❬xp ♥♦t ✐♥ lck.acq❪ D✹ : ❬t ❛t a0✱ xp = j❪ ❧❡❛❞s t♦ ❬t ❛t a0✱ xp = mod(j+1,N)❪ D✷ ❛♥❞ D✹ ✐♠♣❧② D✶

slide-27
SLIDE 27

Pr♦♦❢ ♦❢ ♣r♦❣r❡ss ❝♦♥❞✐t✐♦♥✿ B✷ ✕ ✷

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❲❡ ❡st❛❜❧✐s❤ D✷ : ((t on a0) and xp = j and xreq[j]) ❧❡❛❞s✲t♦

((t on a3) and xp = j and acqd[j])

Pr♦♦❢ ✏j in lck.acq✑ ❡q✉✐✈❛❧❡♥t t♦ ✏j at a6✑ ✴✴ Z✬s ❛t♦♠✐❝✐t② ❬j ❛t a6✱ t ❛t a0✱ xp = j❪ ❧❡❛❞s t♦ ✴✴ ✈✐❛ ✇❢❛✐r t ❬j ❛t a6✱ t ❛t a3✱ xreq[j] ✐s ❢❛❧s❡❪ ❧❡❛❞s t♦ ✴✴ ✈✐❛ ✇❢❛✐r j ❬j ♥♦t ❛t a6✱ t ❛t a3✱ xreq[j] ✐s ❢❛❧s❡❪

slide-28
SLIDE 28

Pr♦♦❢ ♦❢ ♣r♦❣r❡ss ❝♦♥❞✐t✐♦♥✿ B✷ ✕ ✸

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❲❡ ❡st❛❜❧✐s❤ D✸ : ((t on a3) and xp = j and acqd[j]) ❧❡❛❞s✲t♦

((t on a0) and xp = mod(j+1,N))

Pr♦♦❢ ❬D✷✬s r❤s❪ ❧❡❛❞s t♦ ✴✴ ✈✐❛ D✵✱ j.doRel ❬xacq ❢❛❧s❡✱ t ♦♥ a3❪ ❧❡❛❞s t♦ ✴✴ ✈✐❛ ✇❢❛✐r t ❬t ❛t a0✱ xp ✐s mod(j+1,N)❪ D✷ ❛♥❞ D✸ ✐♠♣❧② D✹ : ((t on a0) and xp = j) ❧❡❛❞s✲t♦

((t on a0) and xp = mod(j+1,N))

slide-29
SLIDE 29

❆ss❡rt✐♦♥❛❧ Pr♦♦❢ ♦❢ B✵✕B✸

♣r♦♦❢ ✐♠♣❧❡♠❡♥ts

❙❡❡ t❡①t

slide-30
SLIDE 30

❖✉t❧✐♥❡

✉s✐♥❣ ❧♦❝❦ s❡r✈✐❝❡

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

slide-31
SLIDE 31

❖✈❡r✈✐❡✇

✉s✐♥❣ ❧♦❝❦ s❡r✈✐❝❡

Pr♦❣r❛♠ ProdCons1 st❛rt s②st❡♠s✿ ♣r♦❞✉❝❡r✱ ❝♦♥s✉♠❡r✱ ❧♦❝❦ s❡r✈✐❝❡ ♣r♦❞✉❝❡r ❛♥❞ ❝♦♥s✉♠❡r ✉s❡ ❧♦❝❦ s❡r✈✐❝❡ ❙❤♦✇ t❤❛t ProdCons1 ✐s ❢❛✉❧t✲❢r❡❡ s❤♦✇ t❤❛t ✐t s❛t✐s✜❡s ✐♥♣✉t ❝♦♥❞✐t✐♦♥s ♦❢ ❧♦❝❦ s❡r✈✐❝❡ s②st❡♠ ❖❜t❛✐♥ ❛t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥ts ✴✴ ❡✛❡❝t✐✈❡ ❛t♦♠✐❝✐t② ❊st❛❜❧✐s❤ ❞❡s✐r❡❞ ♣r♦♣❡rt✐❡s st✐❧❧ ❤♦❧❞ ✇❤❡♥ ❧♦❝❦ s❡r✈✐❝❡ ✐s r❡♣❧❛❝❡❞ ❜② ❛ ❧♦❝❦ ✐♠♣❧❡♠❡♥t❛t✐♦♥

slide-32
SLIDE 32

Pr♦❣r❛♠ Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r✲▲♦❝❦ ✕ ✶

✉s✐♥❣ ❧♦❝❦ s❡r✈✐❝❡

program ProdConsLck(...) { ia {...} <hide lck inputs>; lck ← startSystem(SimpleLockService()); cons ← startSystem(Consumer(lck)); prod ← startSystem(Producer(lck, cons)); return [0, mysid]; atomicity assumption {} // none progress assumption {weak fairness} }

slide-33
SLIDE 33

Pr♦❣r❛♠ Pr♦❞✉❝❡r✲❈♦♥s✉♠❡r✲▲♦❝❦ ✕ ✷

✉s✐♥❣ ❧♦❝❦ s❡r✈✐❝❡

SimpleLockService(N): ... input mysid.acq(): ic {...}

  • oc {...}

input mysid.rel(): ... input mysid.end(): ... Consumer(lck): start- Thd(consum()); fn consum(): while (...) lck.acq(); ... lck.rel(); lck.end(); endSystem(); input mysid.put(): ... Producer(lck,cons): start- Thd(prod()); fn produce(): while (...) lck.acq(); cons.put(); lck.rel(); endSystem();

❙✐♥❣❧❡ ❛t♦♠✐❝✐t② ❜r❡❛❦♣♦✐♥t ✐♥ ❡♥t✐r❡ ♣r♦❣r❛♠ t❡①t

ProdCons✳✐♥✐t✿ st❛rt −

→ ♦♥❧② ✷ t❤r❡❛❞s ❛t lck.acq

cons✳st❡♣✿ lck.acq −

→ lck.acq ♦r ❡①✐t

prod✳st❡♣✿ lck.acq −

→ lck.acq ♦r ❡①✐t