Download presentation

Presentation is loading. Please wait.

1
**CSP Communicating Sequential Processes**

Prabhaker Mateti

2
**CSP Overview Models distributed computing Idealistic send/receive**

primitives: send/receive only no shared variables (across outer processes) Idealistic send/receive no buffering sending a value from one process and the receiving of that value in another process appears externally as one event

3
**CSP Synchronous Message Passing**

Send ! ex: R ! (x*y + c) to process R send the value of expression x*y + c sender names the receiving process R waits until receiver R is ready to receive Receive ? ex: S ? v receiver names the sender process S names the receptacle v a variable declared to be a compatible type waits until sender S is ready to send Deadlock is possible

4
**G1 S1 [] G2 S2 [] ...[] Gn Sn Gi must not have sends**

Gi can include at the tail a receive Example: val > 0; Y?P() Q Suppose val = 0. The above input is not attempted. Suppose val > 0, but Y is not ready to send. Then, we are not committed to perform this input. Suppose val > 0, and Y is ready to send. Then, we perform this input, and execute Q.

5
**Additional CSP Notation**

Comments := assignment C1; C2 Sequential composition: C2 after C1 C1 || C2 Simult parallel; not C1; C2 or C2;C1 C2 || C1 Same as C1 || C2 if G1 S1 [] G2 S2 [] ...[] Gn Sn fi If statement; Hoare used [ …]; [] is fat bar do G1 S1 [] G2 S2 [] ...[] Gn Sn od Loop; Hoare used *[ … ] Multiple Gi can be true; non-determinism Skip Do-nothing (no-op) statement ; Also used to end declarations

6
Small Set of Integers Design a server that can provide the abstraction of a Small Set of Integers Make it as distributed as possible Make it as symmetric as possible Simplifying Assumptions Finite, say 100 integers any/all integers can be elements query “have you got x” replied with Boolean request “insert x”, no replies if duplicate, no problem if ran out of room, problem … but silently discard

7
**Small Set of Integers: Design**

An array S of 102 processes S(i: ) each process holds an integer or is empty-handed S(i) has an integer implies S(i-1) also has an integer integer of S(i-1) < integer of S(i) S(101) is a sink S(0) is the “receptionist”

8
Small Set of Integers S(i: ) :: do n: integer; S(i-1)?has(n) S(0)!false [] n: integer; S(i-1)?insert(n) do m: integer; S(i-1)?has(m) if m <= n S(0)!(m = n) [] m > n S(i+1)!has(m) fi [] m: integer; S(i-1)?insert(m) if m < n S(i+1)!insert(n); n := m [] m = n skip [] m > n S(i+1)!insert(m) od od

9
**Small Set of Integers: S(i)**

do n: integer; S(i-1)?has(n) S(0)!false [] n: integer; S(i-1)?insert(n) do m: integer; S(i-1)?has(m) if m <= n S(0)!(m = n) [] m > n S(i+1)!has(m) fi [] m: integer; S(i-1)?insert(m) if m < n S(i+1)!isrt(n); n := m [] m = n skip [] m > n S(i+1)!insert(m) od Each S(i) starts out empty handed Any has(whatever) is replied with false. The first inserted value is saved in n After the first insert, the process spends its life in the second loop. Note: we have no breaks or exits.

10
**Small Set of Integers: has(m)**

do n: integer; S(i-1)?has(n) S(0)!false [] n: integer; S(i-1)?insert(n) do m: integer; S(i-1)?has(m) if m ≤ n S(0)!(m = n) [] m > n S(i+1)!has(m) fi [] m: integer; S(i-1)?insert(m) if m < n S(i+1)!isrt(n); n := m [] m = n skip [] m > n S(i+1)!insert(m) od processes are arranged in a “row” 0 index at left, 101 at right S(i-1)?has(m) (black color) implies S(i) is not empty handed S(i-1) does not have m n is the number S(i) is holding elements are sorted from l-to-r m = n: we have it m < n: no one else has m either reply to the receptionist S(0)

11
**Small Set of Integers: insert(m)**

do n: integer; S(i-1)?has(n) S(0)!false [] n: integer; S(i-1)?insert(n) do m: integer; S(i-1)?has(m) if m <= n S(0)!(m = n) [] m > n S(i+1)!has(m) fi [] m: integer; S(i-1)?insert(m) if m < n S(i+1)!isrt(n); n := m [] m = n skip [] m > n S(i+1)!insert(m) od no S(j) has m (j < i) Case m = n request to insert a duplicate element do nothing Case m > n to be inserted m is higher ask S(i+1) to insert m Case m < n the number n held by S(i) is higher ask neighbor S(i+1) to hold n S(i) now holds m

12
**Small Set of Integers: S(0) and S(101)**

S(101) is a sink S(101) :: do S(100)?has(m) S(0)!false [] S(100)?insert(m) skip od S(0) is the “receptionist” S(0) :: Client ?has(n) S(1)!has(n); if (i: l.. 100) S(i)? b Client ! b fi [] Client ? insert(n) S(1)?insert(n)

13
**Small Set of Integers: Questions**

Does “distributed” mean “concurrent” and/or “parallel” How do we delete? Can we redesign this into a lossless set of integers?

14
**Matrix Multiplication**

15
**Matrix Multiplication**

[ M(i: 1..3,0) ::WEST || M(0, j: 1..3) ::NORTH || M(i: 1..3,4) ::EAST || M(4, j: 1..3) ::SOUTH || M(i: 1..3, j: 1..3)::CENTER ] Declarations omitted for clarity NORTH = do true M(1, j)!0 od EAST = do M(i,3)?x skip od CENTER = do M(i, j - 1)?x M (i, j+1)!x; M (i-1, j)?sum; M (i+1, j)!(A (i, j)*x+sum) od

16
**Sieve of Eratosthenes Print all primes less than 10000 Design**

2, 3, 5, 7, 11, 13, … Design Use an array SIEVE of processes SIEVE(i) filters multiples of i-th prime sqrt(10000) processes are needed SIEVE(0) and SIEVE(101)

17
**Sieve of Eratosthenes [SIEVE(i: 1..100):: SIEVE( i - 1)?p; print ! p;**

mp := p; do SIEVE(i - 1)? m do m > mp --> mp := mp + p od; if m = mp --> skip [] m < mp --> SIEVE(i + l)!m fi od || SIEVE(0):: print!2; n := 3; do n < > SIEVE(1)!n; n := n + 2 od || SIEVE(101):: do SIEVE(100)?n --> print ! n od || print:: do (i: ) SIEVE(i)?n --> .“print-the-number” n od ]

18
**Shared Variables Duality: variables v. processes**

Provide a “shared variable” V as a process V User processes do: V ! exp equiv of V := exp V ? u equiv of u := V, u local to this process semaphores, by intention, are shared variables.

19
**Semaphores in CSP S:: val: integer; val := 0; /* or any +int */ do**

(i:I..100)X(i)?V() val := val + 1 II (i:l..100) val > 0; X(i)?P() val := val - 1 od Within the loop: (unnamed) processes these 200 processes share the integer val yet there is no mutex problem here; why? Array X of 100 client processes can do S!P() or S!V()

20
**Buffered Message Passing**

CSP send/receive have no buffering == Synchronous Message Passing A Buffer process can be inserted between the (original) sender and (original) receiver. This gives a Semi Asynchronous Message Passing. Sends do not block (until the Buffer becomes full)

21
**Modeling Remote Proc Call**

RPC client server ! proc5(e1, e2); server? proc5(r1, r2, r3) RPC Server do … [] client?proc4(…) … [] client?proc5(v1, v2) … client!proc5(e3, e4, e5) [] … od

22
Fairness [ X:: Y!stop() ll Y:: c := true; do c; X?stop() c := false [] c n := n + 1 od ] Will/Must this terminate? We (programmers) should not assume fairness in the implementation

23
**Process Algebras mathematical theories of concurrency Events**

on, off, valve.open, valve.close, mouse?(x,y), screen!bitmap Primitive processes STOP (communicates nothing), SKIP (represents successful termination) Event Prefix: e P Deterministic Choice Nondeterministic Choice Interleaving Interface Parallel Hiding has an entire book by Hoare

24
**CSP Implementations Occam is based on CSP**

Machine Lang of Transputer CPU, 1990s Andrews book, Section 10.x CSP in Java == JCSP Software Release at Communicating Process Architectures Conference == CPA CSP in Jython and Python, CPA 2009 Limbo, Newsqueak are prog langs from Bell Labs, included in the Inferno OS, 2004 Concurrent Event-driven Programming in occam-π for the Arduino, CPA 2011 Experiments in Multi-core and Distributed Parallel Processing using JCSP, CPA 2011 LUNA: Hard Real-Time, Multi-Threaded, CSP-Capable Execution Framework, CPA 2011

25
CSP References C. A. R. Hoare, ``Communicating Sequential Processes,'' Communications of the ACM, 1978, Vol. 21, No. 8, has an entire book by Hoare. For now, do not read it (!!) Andrews, Chapter on Synchronous Message Passing. U of Kent, CSP for Java (JCSP),

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google