shared objects mutual exclusion
play

Shared Objects & Mutual Exclusion DM519 Concurrent Programming - PowerPoint PPT Presentation

Apr 30, 2023 •249 likes •1.49k views

Chapter 4 Shared Objects & Mutual Exclusion DM519 Concurrent Programming 1 1 Repetition (Finite State Processes; FSP) Finite State Processes (FSP) can be defined using: P = x -> Q // action Q // other process variable

  1. Chapter 4: Shared Objects & Mutual Exclusion u Concepts: l Process interference l Mutual exclusion DM519 Concurrent Programming 7 7

  2. Chapter 4: Shared Objects & Mutual Exclusion u Concepts: l Process interference l Mutual exclusion u Models: l Model-checking for interference l Modelling mutual exclusion DM519 Concurrent Programming 7 7

  3. Chapter 4: Shared Objects & Mutual Exclusion u Concepts: l Process interference l Mutual exclusion u Models: l Model-checking for interference l Modelling mutual exclusion u Practice: l Thread interference in shared objects in Java l Mutual exclusion in Java l Synchronised objects, methods, and statements DM519 Concurrent Programming 7 7

  4. 4.1 Interference The ”Ornamental Garden Problem ”: People enter an ornamental garden through either of two turnstiles. Management wishes to know how many are in the garden at any time. (Nobody can exit). 0 Counter DM519 Concurrent Programming 8 8

  5. 4.1 Interference The ”Ornamental Garden Problem ”: People enter an ornamental garden through either of two turnstiles. Management wishes to know how many are in the garden at any time. (Nobody can exit). 1 0 Counter DM519 Concurrent Programming 8 8

  6. 4.1 Interference The ”Ornamental Garden Problem ”: People enter an ornamental garden through either of two turnstiles. Management wishes to know how many are in the garden at any time. (Nobody can exit). 1 0 2 Counter DM519 Concurrent Programming 8 8

  7. 4.1 Ornamental Garden Problem (cont’d) Counter DM519 Concurrent Programming 9 9

  8. 4.1 Ornamental Garden Problem (cont’d) Counter Java implementation: DM519 Concurrent Programming 9 9

  9. 4.1 Ornamental Garden Problem (cont’d) Counter Java implementation: The concurrent program consists of: DM519 Concurrent Programming 9 9

  10. 4.1 Ornamental Garden Problem (cont’d) Counter Java implementation: The concurrent program consists of: • two concurrent threads (west & east); and DM519 Concurrent Programming 9 9

  11. 4.1 Ornamental Garden Problem (cont’d) Counter Java implementation: The concurrent program consists of: • two concurrent threads (west & east); and 2 • a shared counter object DM519 Concurrent Programming 9 9

  12. Class Diagram 20 40 20 counter DM519 Concurrent Programming 10 10

  13. Ornamental Garden Program The go() method of the Garden applet… class Garden extends Applet { NumberCanvas counterD, westD, eastD; Turnstile east, west; ... private void go() { counter = new Counter(counterD); west = new Turnstile(westD,counter); east = new Turnstile(eastD,counter); west.start(); east.start(); } } …creates the shared Counter object & the Turnstile threads. DM519 Concurrent Programming 11 11

  14. The Turnstile Class class Turnstile extends Thread { NumberCanvas display; Counter counter; public void run() { try { display.setvalue(0); for (int i=1; i<=Garden.MAX; i++) { Thread.sleep(1000); display.setvalue(i); counter.increment(); } } catch (InterruptedException _) {} } } DM519 Concurrent Programming 12 12

  15. The Turnstile Class class Turnstile extends Thread { NumberCanvas display; The Turnstile thread simulates periodic Counter counter; arrival of visitors by invoking the counter public void run() { object’s increment() method every second try { display.setvalue(0); for (int i=1; i<=Garden.MAX; i++) { Thread.sleep(1000); display.setvalue(i); counter.increment(); } } catch (InterruptedException _) {} } } DM519 Concurrent Programming 12 12

  16. The Shared Counter Class The increment() method of the Counter class increments its internal value and updates the display. class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } } DM519 Concurrent Programming 13 13

  17. Running The Applet 39 20 20 After the East and West turnstile threads each have incremented the counter 20 times , the garden people counter is not always the sum of the counts displayed. DM519 Concurrent Programming 14 14

  18. Running The Applet 39 20 20 After the East and West turnstile threads each have incremented the counter 20 times , the garden people counter is not always the sum of the counts displayed. Why? DM519 Concurrent Programming 14 14

  19. The Shared Counter Class (cont’d) class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } } DM519 Concurrent Programming 15 15

  20. The Shared Counter Class (cont’d) class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } javac Counter.java } javap -c Counter > Counter.bc DM519 Concurrent Programming 15 15

  21. The Shared Counter Class (cont’d) class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } javac Counter.java } javap -c Counter > Counter.bc DM519 Concurrent Programming 15 15

  22. The Shared Counter Class (cont’d) class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } javac Counter.java } javap -c Counter > Counter.bc aload_0 // push “this” onto stack getfield #2 // get value of “this.value” iconst_1 // push 1 onto stack iadd // add two top stack elements putfield #2 // put result into “this.value” DM519 Concurrent Programming 15 15

  23. The Shared Counter Class (cont’d) class Counter { int value; NumberCanvas display; void increment() { value = value + 1; display.setvalue(value); } javac Counter.java } javap -c Counter > Counter.bc aload_0 // push “this” onto stack getfield #2 // get value of “this.value” Thread switch ? iconst_1 // push 1 onto stack iadd // add two top stack elements putfield #2 // put result into “this.value” DM519 Concurrent Programming 15 15

  24. Concurrent Method Activation Java method activation is not atomic ! Thus, threads east and west may be executing the code for the increment method at the same time. west Shared code: east Counter.class: PC PC program aload_0 // this program counter getfield #2 // x counter iconst_1 iadd putfield #2 // x DM519 Concurrent Programming 16 16

  25. Pedagogification; The Counter Class (cont’d) class Counter { void increment() { value = value + 1; display.setvalue(value); } } DM519 Concurrent Programming 17 17

  26. Pedagogification; The Counter Class (cont’d) class Counter { void increment() { int temp = value; // read Simulate.HWinterrupt(); value = temp + 1; // write display.setvalue(value); } } DM519 Concurrent Programming 18 18

  27. Pedagogification; The Counter Class (cont’d) class Counter { void increment() { int temp = value; // read Simulate.HWinterrupt(); value = temp + 1; // write display.setvalue(value); } } The counter simulates a hardware interrupt during an increment() , between reading and writing to the shared counter value . DM519 Concurrent Programming 18 18

  28. Pedagogification; The Counter Class (cont’d) class Counter { void increment() { int temp = value; // read Simulate.HWinterrupt(); value = temp + 1; // write display.setvalue(value); } } The counter simulates a hardware interrupt during an increment() , between reading and writing to the shared counter value . class Simulate { // randomly force thread switch! public static void HWinterrupt() { if (random()<0.5) Thread.yield(); } } DM519 Concurrent Programming 18 18

  29. Running The Applet Now the erroneous behaviour occurs almost all the time! DM519 Concurrent Programming 19 19

  30. Garden Model (Structure Diagram) GARDEN DM519 Concurrent Programming 20 20

  31. Garden Model (Structure Diagram) GARDEN VAR: models read and write access to the shared counter value. DM519 Concurrent Programming 20 20

  32. Garden Model (Structure Diagram) GARDEN VAR: models read and write access to the shared counter value. TURNSTILE: Increment is modelled inside TURNSTILE, since Java method activation is not atomic (i.e., thread objects east and west may interleave their read and write actions ) . DM519 Concurrent Programming 20 20

  33. Ornamental Garden Model (FSP) DM519 Concurrent Programming 21 21

  34. Ornamental Garden Model (FSP) const N = 4 range T = 0..N DM519 Concurrent Programming 21 21

  35. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). DM519 Concurrent Programming 21 21

  36. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) DM519 Concurrent Programming 21 21

  37. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DM519 Concurrent Programming 21 21

  38. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. DM519 Concurrent Programming 21 21

  39. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) DM519 Concurrent Programming 21 21

  40. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. DM519 Concurrent Programming 21 21

  41. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? DM519 Concurrent Programming 21 21

  42. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? α (value:VAR) ? DM519 Concurrent Programming 21 21

  43. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? α (value:VAR) ? α ({east,west,display}::value:VAR) ? DM519 Concurrent Programming 21 21

  44. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? α (value:VAR) ? α ({east,west,display}::value:VAR) ? α (TURNSTILE) ? DM519 Concurrent Programming 21 21

  45. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? α (value:VAR) ? α ({east,west,display}::value:VAR) ? α (TURNSTILE) ? α (east:TURNSTILE) ? DM519 Concurrent Programming 21 21

  46. Ornamental Garden Model (FSP) const N = 4 range T = 0..N VAR = VAR[0], VAR[u:T] = (read[u] -> VAR[u] | write[v:T] -> VAR[v]). TURNSTILE = (go -> RUN), RUN = (arrive -> INCREMENT | end -> TURNSTILE), INCREMENT = (value.read[x:T] -> value.write[x+1] -> RUN) +{value.write[0]}. DISPLAY =(value.read[T]->DISPLAY)+{value.write[T]}. ||GARDEN = (east:TURNSTILE || west:TURNSTILE || display:DISPLAY || {east,west,display}::value:VAR) /{ go / {east,west}.go , end / {east,west}.end}. α (VAR) ? α (value:VAR) ? α ({east,west,display}::value:VAR) ? α (TURNSTILE) ? α (east:TURNSTILE) ? α (display:DISPLAY) ? DM519 Concurrent Programming 21 21

  47. Checking For Errors - Animation Scenario checking - use animation to produce a trace. DM519 Concurrent Programming 22 22

  48. Checking For Errors - Animation Scenario checking - use animation to produce a trace. Is the model correct? DM519 Concurrent Programming 22 22

  49. Checking For Errors - Animation Scenario checking - use animation to produce a trace. Is the model correct? “Never send a human to do a machine’s job” - Agent Smith (1999) DM519 Concurrent Programming 22 22

  50. Checking For Errors - Compose With Error Detector Exhaustive checking - compose the model with a TEST process which sums the arrivals and checks against the display value: DM519 Concurrent Programming 23 23

  51. Checking For Errors - Compose With Error Detector Exhaustive checking - compose the model with a TEST process which sums the arrivals and checks against the display value: TEST = TEST[0], TEST[v:T] = (when (v<N) west.arrive->TEST[v+1] |when (v<N) east.arrive->TEST[v+1] |end -> CHECK[v]), DM519 Concurrent Programming 23 23

  52. Checking For Errors - Compose With Error Detector Exhaustive checking - compose the model with a TEST process which sums the arrivals and checks against the display value: TEST = TEST[0], TEST[v:T] = (when (v<N) west.arrive->TEST[v+1] |when (v<N) east.arrive->TEST[v+1] |end -> CHECK[v]), CHECK[v:T] = (display.value.read[u:T] -> (when (u==v) right -> TEST[v] |when (u!=v) wrong -> ERROR)). DM519 Concurrent Programming 23 23

  53. Checking For Errors - Exhaustive Analysis ||TESTGARDEN = (GARDEN || TEST). Use LTSA to perform an exhaustive search for ERROR : DM519 Concurrent Programming 24 24

  54. Checking For Errors - Exhaustive Analysis ||TESTGARDEN = (GARDEN || TEST). Use LTSA to perform an exhaustive search for ERROR : Trace to property violation in TEST: go east.arrive east.value.read.0 west.arrive west.value.read.0 east.value.write.1 west.value.write.1 end display.value.read.1 wrong DM519 Concurrent Programming 24 24

  55. Checking For Errors - Exhaustive Analysis ||TESTGARDEN = (GARDEN || TEST). Use LTSA to perform an exhaustive search for ERROR : Trace to property violation in TEST: go east.arrive east.value.read.0 LTSA produces west.arrive the shortest west.value.read.0 path to reach east.value.write.1 the ERROR state. west.value.write.1 end display.value.read.1 wrong DM519 Concurrent Programming 24 24

  56. Interference And Mutual Exclusion Destructive update, caused by the arbitrary interleaving of read and write actions, is termed interference . DM519 Concurrent Programming 25 25

  57. Interference And Mutual Exclusion Destructive update, caused by the arbitrary interleaving of read and write actions, is termed interference . Interference bugs are extremely difficult to locate. DM519 Concurrent Programming 25 25

  58. Interference And Mutual Exclusion Destructive update, caused by the arbitrary interleaving of read and write actions, is termed interference . Interference bugs are extremely difficult to locate. The general solution is: • Give methods mutually exclusive access to shared objects. DM519 Concurrent Programming 25 25

  59. Interference And Mutual Exclusion Destructive update, caused by the arbitrary interleaving of read and write actions, is termed interference . Interference bugs are extremely difficult to locate. The general solution is: • Give methods mutually exclusive access to shared objects. Mutual exclusion can be modelled as atomic actions. DM519 Concurrent Programming 25 25

  60. 4.2 Mutual Exclusion In Java Concurrent activations of a method in Java can be made mutually exclusive by prefixing the method with the keyword synchronized . DM519 Concurrent Programming 26 26

  61. 4.2 Mutual Exclusion In Java Concurrent activations of a method in Java can be made mutually exclusive by prefixing the method with the keyword synchronized . We correct the Counter class by deriving a class from it and making its increment method synchronized: DM519 Concurrent Programming 26 26

  62. 4.2 Mutual Exclusion In Java Concurrent activations of a method in Java can be made mutually exclusive by prefixing the method with the keyword synchronized . We correct the Counter class by deriving a class from it and making its increment method synchronized: class SynchronizedCounter extends Counter { SynchronizedCounter(NumberCanvas n) { super(n); } synchronized void increment() { super.increment(); } } DM519 Concurrent Programming 26 26

  63. The Garden Class (revisited) If the fixit checkbox is ticked, the go() method creates a SynchronizedCounter : class Garden extends Applet { private void go() { if (!fixit.getState()) counter = new Counter(counterD); else counter = new SynchCounter (counterD); west = new Turnstile(westD,counter); east = new Turnstile(eastD,counter); west.start(); east.start(); } } DM519 Concurrent Programming 27 27

  64. Mutual Exclusion - The Ornamental Garden DM519 Concurrent Programming 28 28

  65. Mutual Exclusion - The Ornamental Garden Java associates a lock with every object. DM519 Concurrent Programming 28 28

  66. Mutual Exclusion - The Ornamental Garden Java associates a lock with every object. The Java compiler inserts code to: DM519 Concurrent Programming 28 28

  67. Mutual Exclusion - The Ornamental Garden Java associates a lock with every object. The Java compiler inserts code to: • acquire the lock before executing a synchronized method DM519 Concurrent Programming 28 28

  68. Mutual Exclusion - The Ornamental Garden Java associates a lock with every object. The Java compiler inserts code to: • acquire the lock before executing a synchronized method • release the lock after the synchronized method returns. DM519 Concurrent Programming 28 28

  69. Mutual Exclusion - The Ornamental Garden Java associates a lock with every object. The Java compiler inserts code to: • acquire the lock before executing a synchronized method • release the lock after the synchronized method returns. Concurrent threads are blocked until the lock is released. DM519 Concurrent Programming 28 28

  70. Java Synchronized Statement Synchronized methods: synchronized void increment() { super.increment(); } synchronized void decrement() { super.decrement(); } DM519 Concurrent Programming 29 29

  71. Java Synchronized Statement Synchronized methods: synchronized void increment() { super.increment(); } synchronized void decrement() { super.decrement(); } Variant - the synchronized statement : class Turnstile{ ... public void run() { ... synchronized(counter) { counter.increment(); } ... DM519 Concurrent Programming 29 29

  72. Java Synchronized Statement Synchronized methods: synchronized void increment() { super.increment(); } synchronized void decrement() { super.decrement(); } Variant - the synchronized statement : object reference class Turnstile{ ... public void run() { ... synchronized(counter) { counter.increment(); } ... DM519 Concurrent Programming 29 29

  73. Java Synchronized Statement Synchronized methods: synchronized void increment() { super.increment(); } synchronized void decrement() { super.decrement(); } Variant - the synchronized statement : object reference class Turnstile{ Use synch methods ... public void run() { whenever possible. ... synchronized(counter) { counter.increment(); } ... DM519 Concurrent Programming 29 29

  74. Java -> Java Bytecode DM519 Concurrent Programming 30 30

  75. Java -> Java Bytecode 1 class X { 2 int x; 3 void m() { 4 synchronized(this) { 5 x++; 6 } 7 } 8 } DM519 Concurrent Programming 30 30

Recommend

Distributed Systems Mutual Exclusion &amp; Election Algorithms Mutual Exclusion &amp; Election

Distributed Systems Mutual Exclusion &amp; Election Algorithms Mutual Exclusion &amp; Election

Distributed Systems Mutual Exclusion &amp; Election Algorithms Mutual Exclusion &amp; Election Algoritms Paul Krzyzanowski pxk@cs.rutgers.edu Except as otherwise noted, the content of this presentation is licensed under the Creative Commons

196 views • 5 slides
The Synchronization Toolbox The Synchronization Toolbox Mutual Exclusion Mutual Exclusion Race

The Synchronization Toolbox The Synchronization Toolbox Mutual Exclusion Mutual Exclusion Race

The Synchronization Toolbox The Synchronization Toolbox Mutual Exclusion Mutual Exclusion Race conditions can be avoiding by ensuring mutual exclusion in critical sections. Critical sections are code sequences that are vulnerable to races.

708 views • 34 slides
CSC2/458 Parallel and Distributed Systems Mutual Exclusion and Leader Elections Sreepathi Pai

CSC2/458 Parallel and Distributed Systems Mutual Exclusion and Leader Elections Sreepathi Pai

CSC2/458 Parallel and Distributed Systems Mutual Exclusion and Leader Elections Sreepathi Pai March 29, 2018 URCS Outline Mutual Exclusion Using Voting Misras Token Recovery Algorithm Election Algorithms Outline Mutual Exclusion Using

589 views • 31 slides
Global view mutual exclusion despite process crash failures? But Which is the weakest

Global view mutual exclusion despite process crash failures? But Which is the weakest

Summary Global view of the paper On the Weakest Failure Detector For Crash failures and failure detectors Read/Write-Based Mutual Exclusion Mutual exclusion Technical content Carole D ELPORTE , Hugues F AUCONNIER

571 views • 7 slides
Mutual Exclusion 1 Goals of the lecture Time domain vs Causalit y domain

Mutual Exclusion 1 Goals of the lecture Time domain vs Causalit y domain

Mutual Exclusion 1 Goals of the lecture Time domain vs Causalit y domain Lamp o rt's Mutual Exclusion Algo rithm F o rmal V erication Key Lemmas Safet y Liveness F airness

322 views • 16 slides
Mutual Exclusion, Async Completions Why We Wait 7C. Asynchronous Event Completions We await

Mutual Exclusion, Async Completions Why We Wait 7C. Asynchronous Event Completions We await

4/15/2017 Mutual Exclusion, Async Completions Why We Wait 7C. Asynchronous Event Completions We await completion of non-trivial operations 7D. Mutual Exclusion data to be read from disk a child process to be created 7E.

277 views • 8 slides
Distributed Mutual Exclusion Algorithms Course: Distributed Computing Faculty: Dr. Rajendra

Distributed Mutual Exclusion Algorithms Course: Distributed Computing Faculty: Dr. Rajendra

Distributed Mutual Exclusion Algorithms Course: Distributed Computing Faculty: Dr. Rajendra Prasath Spring 2019 About this topic This course covers various concepts in Mutual Exclusion in Distributed Systems. We will also focus on different

1.02k views • 43 slides
Implementing Mutual Exclusion We assume that each thread, i , is of the form loop non critical

Implementing Mutual Exclusion We assume that each thread, i , is of the form loop non critical

Concurrent programming slides T.S. Norvell (c) 2001 Implementing Mutual Exclusion We assume that each thread, i , is of the form loop non critical stuff acquire( i ) critical section release( i ) end loop Requirements: Mutual exclusion.

263 views • 8 slides
Peterson s lock: Establishing A derivation mutual exclusion Claim: If the following invariant

Peterson s lock: Establishing A derivation mutual exclusion Claim: If the following invariant

Peterson s lock: Establishing A derivation mutual exclusion Claim: If the following invariant holds when T i is in CS, so does mutual exclusion Combines ideas from Like-to and Selfless locks ( in j ( in j turn = i ) ) in i

463 views • 8 slides
Distributed Mutual Exclusion Last time Synchronizing real, distributed clocks

Distributed Mutual Exclusion Last time Synchronizing real, distributed clocks

Distributed Mutual Exclusion Last time Synchronizing real, distributed clocks Logical time and concurrency Lamport clocks and total-order Lamport clocks Goals of distributed mutual exclusion Much like regular mutual

616 views • 30 slides
Operating System Principles: Mutual Exclusion and Asynchronous Completion CS 111 Operating

Operating System Principles: Mutual Exclusion and Asynchronous Completion CS 111 Operating

Operating System Principles: Mutual Exclusion and Asynchronous Completion CS 111 Operating Systems Peter Reiher Lecture 8 CS 111 Page 1 Fall 2016 Outline Mutual Exclusion Asynchronous Completions Lecture 8 CS 111 Page 2 Fall

963 views • 48 slides
Analyzing Irregular Mutual Analyzing Irregular Mutual Exclusion in Parallel Programs Exclusion

Analyzing Irregular Mutual Analyzing Irregular Mutual Exclusion in Parallel Programs Exclusion

Analyzing Irregular Mutual Analyzing Irregular Mutual Exclusion in Parallel Programs Exclusion in Parallel Programs Diego Novillo, Ron Unrau, Jonathan Schaeffer Diego Novillo, Ron Unrau, Jonathan Schaeffer Computing Science Department

616 views • 8 slides
I interference freedom Interlock Instructions that reads updates shared Hue instructor memory as

I interference freedom Interlock Instructions that reads updates shared Hue instructor memory as

f Schreder Cs 1410 9 7 2019 Concurrencym process thread core processor finale progress shared memory communication t synchronization cooperation Synchronization mutual exclusion critical sectors problem await B wait busy spinning classic

635 views • 18 slides
Todays Topics - Coordination and Agreement Chapter 12. Distributed Mutual Exclusion. 12.2

Todays Topics - Coordination and Agreement Chapter 12. Distributed Mutual Exclusion. 12.2

Distributed Systems Lecture 9 1 Todays Topics - Coordination and Agreement Chapter 12. Distributed Mutual Exclusion. 12.2 Consensus 12.5 figures to insert fig. 12.2,12.3 Distributed Systems Lecture 9 2 Distributed Mutual Exclusion

586 views • 19 slides
28. Parallel Programming II 28.1 Shared Memory, Concurrency Shared Memory, Concurrency,

28. Parallel Programming II 28.1 Shared Memory, Concurrency Shared Memory, Concurrency,

28. Parallel Programming II 28.1 Shared Memory, Concurrency Shared Memory, Concurrency, Excursion: lock algorithm (Peterson), Mutual Exclusion Race Conditions [C++ Threads: Williams, Kap. 2.1-2.2], [C++ Race Conditions: Williams, Kap. 3.1] [C++

320 views • 16 slides
Spin Lock Performance Introduction Shared memory multiprocessors o Various different

Spin Lock Performance Introduction Shared memory multiprocessors o Various different

CS533 Concepts of Operating Systems Spin Lock Performance Introduction Shared memory multiprocessors o Various different architectures o All have hardware support for mutual exclusion Various flavors of atomic read-modify instruction

392 views • 27 slides
Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity

Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity

Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity Concurrency Control Deadlock Handling Election Algorithms Reaching Agreement Operating System Concepts Silberschatz, Galvin and Gagne

276 views • 25 slides
Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity

Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity

Chapter 17 Distributed Coordination Event Ordering Mutual Exclusion Atomicity Concurrency Control Deadlock Handling Election Algorithms Reaching Agreement Operating System Concepts 17.1 Silberschatz, Galvin and Gagne

955 views • 49 slides
Mutual exclusion protocols cannot be implemented in CCS-like languages Rob van Glabbeek &amp;

Mutual exclusion protocols cannot be implemented in CCS-like languages Rob van Glabbeek &amp;

Mutual exclusion protocols cannot be implemented in CCS-like languages Rob van Glabbeek &amp; Peter H ofner Data61, CSIRO, Sydney, Australia University of New South Wales, Sydney, Australia June 2017 Based on work presented in Walter

629 views • 42 slides
CPSC 213 data structure that could be accessed by multiple threads Shared Variables in

CPSC 213 data structure that could be accessed by multiple threads Shared Variables in

Readings for These Next Four Lectures Synchronization The Importance of Mutual Exclusion Text Shared data Memory Bus CPUs Memory (Cores) CPSC 213 data structure that could be accessed by multiple threads Shared Variables in

316 views • 4 slides
Resource Access Control Radek Pel anek Introduction Mutual Exclusion Scheduling with

Resource Access Control Radek Pel anek Introduction Mutual Exclusion Scheduling with

Introduction Mutual Exclusion Scheduling with Resources Resource Access Control Radek Pel anek Introduction Mutual Exclusion Scheduling with Resources Notions Resources: notions resource something needed to advance execution of a task;

954 views • 58 slides
Last Class: Synchronization S ynchronization Mutual exclusion Critical sections

Last Class: Synchronization S ynchronization Mutual exclusion Critical sections

Last Class: Synchronization S ynchronization Mutual exclusion Critical sections Locks Synchronization primitives are required to ensure that only one thread executes in a critical section at a time. Computer Science

190 views • 15 slides
Part III Synchronization Critical Section and Mutual Exclusion The question of whether computers

Part III Synchronization Critical Section and Mutual Exclusion The question of whether computers

Part III Synchronization Critical Section and Mutual Exclusion The question of whether computers can think is just like the question of whether submarines can swim 1 Fall 2015 Edsger W. Dijkstra Pr Proc oces ess s Sy Sync nchr hron

380 views • 26 slides
Distributed Algorithms Distributed Algorithms Distributed Mutual Exclusion Olivier Dalle (*)

Distributed Algorithms Distributed Algorithms Distributed Mutual Exclusion Olivier Dalle (*)

Distributed Algorithms Distributed Algorithms Distributed Mutual Exclusion Olivier Dalle (*) olivier.dalle@sophia.inria.fr (*) Large parts of this lecture borrowed from Sukumar Ghosh's book. Olivier Dalle 1 Distributed Algorithms Mutual

675 views • 52 slides

More recommend