Chapter 3 Concurrent Execution DM519 Concurrent Programming 1 - - PowerPoint PPT Presentation

▶
chapter 3 concurrent execution
SMART_READER_LITE
LIVE PREVIEW

Chapter 3 Concurrent Execution DM519 Concurrent Programming 1 - - PowerPoint PPT Presentation

Feb 24, 2024 477 likes •923 views

Chapter 3 Concurrent Execution DM519 Concurrent Programming 1 Repetition (Concepts, Models, and Practice) u Concepts: l We adopt a model-based approach for the design and construction of concurrent programs u Safe model => safe

slide-1
SLIDE 1

DM519 Concurrent Programming

Chapter 3 Concurrent Execution

1

slide-2
SLIDE 2

DM519 Concurrent Programming

Repetition (Concepts, Models, and Practice)

uConcepts:

lWe adopt a model-based approach for the design and construction of concurrent programs

u Safe model => safe program

uModels:

lWe use finite state models to represent concurrent behaviour
 (Finite State Processes and Labelled Transition Systems)

  • uPractice:

lWe use Java for constructing concurrent programs

2

slide-3
SLIDE 3

DM519 Concurrent Programming

Repetition (Models; Lts, Fsp)

Model = simplified representation of the real world uBased on Labelled Transition Systems (LTS ): 


  • uDescribed textually as Finite State Processes

(FSP):

EngineOff = (engineOn -> EngineOn), EngineOn = (engineOff -> EngineOff
 |speed -> EngineOn). Focuses on concurrency aspects (of the program)


  • everything else abstracted away

3

slide-4
SLIDE 4

DM519 Concurrent Programming

Repetition (Finite State Processes; Fsp)

Finite State Processes (FSP):

P : STOP // termination : (x -> P) // action prefix : (when (…) x -> P) // guard : P | P’ // choice : P +{ … } // alphabet extension : X // process variable

  • ♦ action indexing

x[i:1..N] -> P or x[i] -> P ♦ process parameters P(N=3) = … ♦ constant definitions const N = 3 ♦ range definitions range R = 0..N Which constructions do not add expressive power? (and are thus only "syntactic sugar").

4

slide-5
SLIDE 5

DM519 Concurrent Programming

Repetition (Java Threads)

Subclassing java.lang.Thread:

  • Implementing java.lang.Runnable:

class MyThread extends Thread { public void run() { // ... } } class MyRun implements Runnable { public void run() { // ... } } Thread t = new MyThread(); t.start(); // ... Thread t = new Thread(new MyRun()); t.start(); // ...

5

slide-6
SLIDE 6

DM519 Concurrent Programming

Chapter 3: Concurrent Execution Concepts: processes - concurrent execution

and interleaving process interaction

  • Models:

parallel composition of asynchronous processes interleaving interaction - shared actions process labelling, and action relabelling and hiding structure diagrams

  • Practice: Multithreaded Java programs

6

slide-7
SLIDE 7

DM519 Concurrent Programming

Definition: Parallelism

uParallelism (aka. Real/True Concurrent Execution)

  • lPhysically simultaneous processing

uInvolves multiple processing elements (PEs) 
 and/or independent device operations

A

Time

B C

7

slide-8
SLIDE 8

DM519 Concurrent Programming

Definition: Concurrency

A

Time

B C

uConcurrency (aka. Pseudo-Concurrent Execution)

  • lLogically simultaneous processing

uDoes not imply multiple processing elements (PEs) uRequires interleaved execution on a single PE

8

slide-9
SLIDE 9

DM519 Concurrent Programming

Parallelism vs Concurrency

Both concurrency and parallelism require controlled access to shared resources.

  • We use the terms parallel and concurrent interchangeably (and generally

do not distinguish between real and pseudo-concurrent execution).

  • Also, creating software independent of the physical setup, makes us

capable of deploying it on any platform.

uParallelism uConcurrency

A

Time

B C A

Time

B C

9

slide-10
SLIDE 10

DM519 Concurrent Programming

3.1 Modelling Concurrency

uHow do we model concurrency?

  • lArbitrary relative order of actions from different processes

(interleaving but preservation of each process order)

x

Possible execution sequences?

  • y

Asynchronous model of execution

  • x ; y
  • y ; x
  • x || y

10

slide-11
SLIDE 11

DM519 Concurrent Programming

3.1 Modelling Concurrency

u How should we model process execution speed?

  • lWe choose to abstract away time:

uArbitrary speed!

+: independent of architecture, processor speed, 
 scheduling policies, …

  • : we can say nothing of real-time properties

a b x y

11

slide-12
SLIDE 12

DM519 Concurrent Programming

  • scratchàthinkàtalk
  • thinkàscratchàtalk
  • thinkàtalkàscratch

Possible traces as a result of action interleaving? If P and Q are processes then (P||Q) represents the concurrent execution of P and Q. The operator ‘||’ is the parallel composition operator. ITCH = (scratch->STOP). CONVERSE = (think->talk->STOP).

  • ||CONVERSE_ITCH = (ITCH || CONVERSE).

12

Parallel Composition - Action Interleaving

slide-13
SLIDE 13

DM519 Concurrent Programming

Parallel Composition - Action Interleaving

2 states 3 states (0,0) (0,1) (0,2) (1,2) (1,1) (1,0) from CONVERSE from ITCH 2 x 3 states Cartesian product?

13

slide-14
SLIDE 14

DM519 Concurrent Programming

Parallel Composition - Algebraic Laws

Commutative: (P||Q) = (Q||P) Associative: (P||(Q||R)) = ((P||Q)||R) = (P||Q||R). Small example: MALTHE = (climbTree->fall->MALTHE). OSKAR = (run->jump->OSKAR).

  • ||MALTHE_OSKAR = (MALTHE || OSKAR).

LTS? Traces? Number of states?

14

slide-15
SLIDE 15

DM519 Concurrent Programming

Modelling Interaction - Shared Actions

If processes in a composition have actions in common, these actions are said to be shared. 
 Shared actions are the way that process interaction is modelled. While unshared actions may be arbitrarily interleaved, a shared action must be executed at the same time by all processes that participate in the shared action. MAKE1 = (make->ready->STOP). USE1 = (ready->use->STOP).

  • ||MAKE1_USE1 = (MAKE1 || USE1).

uShared Actions:

MAKE1 synchronises with USE1 when ready. LTS? Traces? Number of states?

15

slide-16
SLIDE 16

DM519 Concurrent Programming

Modelling Interaction - Example

3 states 3 states 3 x 3 states? MAKE1 = (make->ready->STOP). USE1 = (ready->use->STOP).

  • ||MAKE1_USE1 = (MAKE1 || USE1).

make ready make make ready ready ready ready ready use use use

No…!

16

slide-17
SLIDE 17

DM519 Concurrent Programming

Modelling Interaction - Example

3 states 3 states MAKE1 = (make->ready->STOP). USE1 = (ready->use->STOP).

  • ||MAKE1_USE1 = (MAKE1 || USE1).

make ready use Interaction may constrain the overall behaviour ! 4 states! ready make make ready ready ready ready ready use use

17

slide-18
SLIDE 18

DM519 Concurrent Programming

Example

P = (x -> y -> P). Q = (y -> x -> Q).

  • ||R = (P || Q).

LTS? Traces? Number of states? 2 states 2 states

18

P = (a -> P | b -> P).
 Q = (c -> Q) + {a}.
 
 ||PQ = (P || Q). LTS? Traces?

slide-19
SLIDE 19

DM519 Concurrent Programming

Modelling Interaction - Example

MAKER = (make->ready->MAKER). USER = (ready->use->USER).

  • ||MAKER_USER = (MAKER || USER).

LTS? Traces? Can we make sure the MAKER does not “get ahead of” the USER
 (i.e. never make before use); and if so, how?

19

slide-20
SLIDE 20

DM519 Concurrent Programming

Modelling Interaction - Handshake

A handshake is an action acknowledged by another process: MAKERv2 = (make->ready->used->MAKERv2). USERv2 = (ready->use->used->USERv2).

  • ||MAKER_USERv2 = (MAKERv2 || USERv2).

20

slide-21
SLIDE 21

DM519 Concurrent Programming

Modelling Interaction - Multiple Processes

Multi-party synchronisation: MAKE_A = (makeA->ready->used->MAKE_A). MAKE_B = (makeB->ready->used->MAKE_B). ASSEMBLE = (ready->assemble->used->ASSEMBLE).

  • ||FACTORY = (MAKE_A || MAKE_B || ASSEMBLE).

21

slide-22
SLIDE 22

DM519 Concurrent Programming

Composite Processes

A composite process is a parallel composition of primitive processes. These composite processes can be used in the definition of further compositions. ||MAKERS = (MAKE_A || MAKE_B). ||FACTORY = (MAKERS || ASSEMBLE). ||FACTORY = ((MAKE_A || MAKE_B)|| ASSEMBLE). substitution of def’n of MAKERS associativity! ||FACTORY = (MAKE_A || MAKE_B || ASSEMBLE). Further simplification?

22

slide-23
SLIDE 23

DM519 Concurrent Programming

Process Labelling

a:P prefixes each action label in the alphabet of P with a. SWITCH = (on->off->SWITCH). ||TWO_SWITCH = (a:SWITCH || b:SWITCH). Two instances of a switch process: LTS? (a:SWITCH)

23

slide-24
SLIDE 24

DM519 Concurrent Programming

Process Labelling

a:P prefixes each action label in the alphabet of P with a. SWITCH = (on->off->SWITCH). ||TWO_SWITCH = (a:SWITCH || b:SWITCH). Two instances of a switch process: ||SWITCHES(N=3) = (forall[i:1..N] s[i]:SWITCH).
 ||SWITCHES(N=3) = (s[i:1..N]:SWITCH). Create an array of instances of the switch process:

24

slide-25
SLIDE 25

DM519 Concurrent Programming

Process Labelling By A Set Of Prefix Labels

{a1,..,an}::P replaces every action label x in the alphabet of P with the labels a1.x,…,an.x.
 Further, every transition (x -> X) in the definition of P is replaced with the transitions ({a1.x,…,an.x} -> X). Process prefixing is useful for modelling shared resources: RESOURCE = (acquire->release->RESOURCE). USER = (acquire->use->release->USER). ||RESOURCE_SHARE = (a:USER || b:USER || {a,b}::RESOURCE).

25

slide-26
SLIDE 26

DM519 Concurrent Programming

Process Prefix Labels For Shared Resources

How does the model ensure that the user that acquires the resource is the one to release it? RESOURCE = (acquire->release->RESOURCE). USER = (acquire->use->release->USER). ||RESOURCE_SHARE = (a:USER || b:USER || {a,b}::RESOURCE).

26

slide-27
SLIDE 27

DM519 Concurrent Programming

Example

X = (x -> STOP). LTS? Traces? Number of states? ||SYS_1 = {a,b}:X. ||SYS_2 = {a,b}::X. LTS? Traces? Number of states?

27

{a...}:X creates one process per prefix {a...}::X creates one process with all prefixes

slide-28
SLIDE 28

DM519 Concurrent Programming

Action Relabelling

Relabelling to ensure that composed processes synchronise on particular actions: Relabelling functions are applied to processes to change the names of action labels. The general form of the relabelling function is:
 /{newlabel1/oldlabel1,… newlabeln/oldlabeln}. CLIENT = (call->wait->continue->CLIENT). SERVER = (request->service->reply->SERVER).

28

slide-29
SLIDE 29

DM519 Concurrent Programming

Action Relabelling

||C_S = (C || S). CLIENT = (call->wait->continue->CLIENT). SERVER = (request->service->reply->SERVER).

C S C_S

C = (CLIENT /{reply/wait}). S = (SERVER /{call/request}).

29

slide-30
SLIDE 30

DM519 Concurrent Programming

Action Relabelling - Prefix Labels

SERVERv2 = (accept.request

  • >service->accept.reply->SERVERv2).
  • CLIENTv2 = (call.request
  • >call.reply->continue->CLIENTv2).
  • ||CLIENT_SERVERv2 = (CLIENTv2 || SERVERv2)

/{call/accept}. An alternative formulation of the client server system is described below using qualified or prefixed labels:

30

slide-31
SLIDE 31

DM519 Concurrent Programming

Action Hiding - Abstraction To Reduce Complexity

When applied to a process P, the hiding operator \{a1,..,ax} removes the action names a1..ax from the alphabet of P and makes these concealed actions "silent".
 These silent actions are labelled tau.
 Silent actions in different processes are not shared. USER = (acquire->use->release->USER) \{use}.

31

slide-32
SLIDE 32

DM519 Concurrent Programming

Action Hiding - Abstraction To Reduce Complexity

When applied to a process P, the interface

  • perator @{a1,..,ax} hides all actions in the

alphabet of P not labelled in the set a1..ax. Sometimes it is more convenient to specify the set of labels to be exposed.... USER = (acquire->use->release->USER) @{acquire,release}.

32

slide-33
SLIDE 33

DM519 Concurrent Programming

Action Hiding

USER = (acquire->use->release->USER) \{use}.

  • USER = (acquire->use->release->USER)

@{acquire,release}. The following definitions are equivalent:

Minimisation removes hidden tau actions to produce an LTS with equivalent

  • bservable behaviour.

33

slide-34
SLIDE 34

DM519 Concurrent Programming

Structure Diagrams

P

a b

Process P with alphabet {a,b}.

m

Parallel Composition (P||Q)

c x b

Q

d x

P

a c x

X Y

a

S

y x

Composite process ||S = (X||Y) @ {x,y}

34

/ {m/a,m/b } ,c/d

slide-35
SLIDE 35

DM519 Concurrent Programming

Structure Diagrams

We use structure diagrams to capture the structure of a model expressed by the static combinators: 
 parallel composition, relabelling and hiding. range T = 0..3 BUFF = (in[i:T]->out[i]->BUFF).

a:BUFF b:BUFF a.out TWOBUFF

  • ut

in in

  • ut

in

  • ut

||TWOBUF =
 
 (a:BUFF || b:BUFF) /{in/a.in, a.out/b.in, out/b.out} @{in,out}.

35

slide-36
SLIDE 36

DM519 Concurrent Programming

Structure Diagrams

Structure diagram for CLIENT_SERVER ? CLIENT

call request

SERVER

call reply wait reply service continue

CLIENT = (call->wait->continue->CLIENT). SERVER = (request->service->reply->SERVER).
 
 ||CLIENT_SERVER = (CLIENT||SERVER)
 /{reply/wait,
 call/request}.

36

slide-37
SLIDE 37

DM519 Concurrent Programming

Structure Diagrams

Structure diagram for CLIENT_SERVERv2 ? CLIENTv2

call accept

SERVERv2

call service continue

SERVERv2 = (accept.request

  • >service->accept.reply->SERVERv2).

CLIENTv2 = (call.request

  • >call.reply->continue->CLIENTv2).

||CLIENT_SERVERv2 = (CLIENTv2 || SERVERv2) /{call/accept}.

37

Simply use the shared prefix.

slide-38
SLIDE 38

DM519 Concurrent Programming

Structure Diagrams - Resource Sharing

38

a:USER

printer

b:USER

printer

printer: RESOURCE

acquire release

PRINTER_SHARE

RESOURCE = (acquire->release->RESOURCE). USER = (printer.acquire->use->printer.release->USER). ||PRINTER_SHARE = (a:USER || b:USER || {a,b}::printer:RESOURCE). Shared resources are shown as “rounded rectangles”:

slide-39
SLIDE 39

DM519 Concurrent Programming

Java

39

slide-40
SLIDE 40

DM519 Concurrent Programming

Threaddemo Model

THREAD = OFF,

  • OFF = (toggle->ON

|abort->STOP),

  • ON = (toggle->OFF

|output->ON |abort->STOP).


  • ||THREAD_DEMO = 


(a:THREAD || b:THREAD)
 /{stop/{a,b}.abort}. Interpret: toggle, abort 
 as inputs;

  • utput 


as output a:T b:T

stop a.toggle a.output b.output b.toggle

THREAD_DEMO

40

slide-41
SLIDE 41

DM519 Concurrent Programming

Threaddemo Code: Mythread

class MyThread extends Thread { private boolean on;

  • MyThread(String name) { super(name); this.on = false; }
  • public void toggle() { on = !on; }
  • public void abort() { this.interrupt(); }
  • private void output() {

System.out.println(getName()+“: output”);
 } public void run() { try { while (!interrupted()) { if (on) output(); sleep(500); } } catch(Int’Exc’ _) {} System.out.println(“Done!”);
 }}}

41

slide-42
SLIDE 42

DM519 Concurrent Programming

Threaddemo Code: Threaddemo

class ThreadDemo { public static void main(String[] args) { MyThread a = new MyThread(“a”); MyThread b = new MyThread(“b”); a.start(); b.start(); while (true) { switch (readChar()) { case ‘a’: a.toggle(); 
 break; case ‘b’: b.toggle(); 
 break; case ‘i’: stop(a,b); 
 return; } } } private stop(MyThread a, MyThread b) { a.abort(); b.abort(); } }

42

slide-43
SLIDE 43

DM519 Concurrent Programming

Summary

uConcepts

lConcurrent processes and process interaction

uModels

lAsynchronous (arbitrary speed) & interleaving (arbitrary order). lParallel composition as a finite state process with action interleaving. lProcess interaction by shared actions. lProcess labelling and action relabelling and hiding. lStructure diagrams

uPractice

lMultiple threads in Java.

43