1 / 28

Communicating Sequential Processes

Communicating Sequential Processes. Based on: C. A. R. Hoare, Communicating Sequential Processes, CACM, 21(8):666-677, November, 1978. 1. 1. 1. 1. Outline. Background and motivation Concepts and notation Examples. 2. 2. 2. 2. Background. Imperative programming models

nathan-mueller
Download Presentation

Communicating Sequential Processes

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Communicating Sequential Processes Based on: C. A. R. Hoare, Communicating Sequential Processes, CACM, 21(8):666-677, November, 1978. 1 1 1 1

  2. Outline • Background and motivation • Concepts and notation • Examples 2 2 2 2

  3. Background Imperative programming models Commands: assignment, sequence, alternative, iterative I/O as library functions, not primitive Concurrency and parallelism Multi-processor disguised as mono-processor Need for expressing concurrency explicitly Shared memory vs. message passing 3 3 3 3

  4. Motivation New programming model based on message passing I/O regarded as primitive constructs Concurrency (parallel composition of processes) as fundamental structuring method => Concurrent Sequential Processes (CSP) 4 4 4 4

  5. Key Features of CSP Dijkstra’s guarded commands [B1 -> S1 [] B2 -> S2 ] For introducing and controlling non-determinism (or choice) Dijkstra’s parallel commands [P1 || P2] For concurrency Input and output commands p?x; q!x For receiving and sending messages Input commands in guards and repetitive commands [p?x -> S]; *[p?x -> S] Branching or repetition based on inputs Simple pattern matching For discriminating the structures of input messages and For accessing their components 5 5 5 5

  6. Example • Q: What does the process X do? X:: *[c: character; west?c  [c  asterisk  east!c [] c  asterisk  west?c; [c  asterisk  east!asterisk; east!c c  asterisk  east!up_arrow ] ] ]

  7. Outline Background and motivation Concepts and notation Basic and structured statements Examples 7 7 7 7

  8. Concepts and Notation • Commands • Specify behavior of device executing the commands • May have side effect (internal or external) • May succeed or fail (“strict” for structured commands) • Basic vs. structured • Basic: null (skip), assignment, input, output • Structured: alternative, repetitive, parallel <command> ::= <simple command> | <structured command> <simple command> ::= <null command> | <assignment command> | <input command> | <output command> <structured command> ::= <alternative command> | <repetitive command> | <parallel command> <null command> ::= skip <command list> :: {<declaration>; <command>;} <command>

  9. Parallel Commands (||) • List of processes separated by || • Process: sequence of commands preceded by an optional label • E.g., [stdin?line || stdout!“hello”] • Semantics • Concurrent execution of constituent processes • All processes start simultaneously • Terminate successfully if all terminate successfully <parallel command> ::= [<process> { || <process>}] <process> ::= <process label> <command list>

  10. Process • Unit of program in CSP • Sequence of commands with an optional label (Q: Why label?) • E.g., skip, X:: skip • Subscripted label to specify a series of concurrently running processes • E.g., X(1):: skip, X(i):: skip, X(i,j):: skip, X(i: 0..99):: skip • Semantics: X(i: 1..n)::CL for [X(1):: CL1 || X(2):: CL2 || … || X(n):: CLn] I.e., CLj is CL[j/i] <process> ::= <process label> <command list> <process lablel> ::= <empty> | <identifier> :: | <identifier>(<label subscript> {, <label subscript>}) :: <label subscript> ::= <integer constant> | <range> <integer constant> ::= <numeral> | <bound variable> <bound variable> ::= <identifier> <range> ::= <bound variable>:<lower bound>..<upper bound> <lower bound> ::= <integer constant> <upper bound> ::= <integer constant>

  11. Example [cardreader?cardImage || lineprinter! lineimage] [west:: DISASSEMBLE || X:: SQUASH || east:: ASSEMBLE] Convention: Capitalized words for process definitions [room:: ROOM || fork(i: 0..4):: FORK || phil(i: 0..4):: PHIL] Q: How many concurrent processes?

  12. Assignment • Simple vs. structured value • 0, true, 10 + y, x + y, … • (10, 20), (x, y), point(10, 20), done() • Signal: structured value with no component • Q: Why structured values? c(e1, e2, …, en) <assignment command> ::= <target variable> := <expression> <expression> ::= <simple expression> | <structured expression> <structured expression> ::= <constructor>(<expression list>) <constructor> ::= <identifier> | <empty> <expression list> ::= <empty> | <expression> {, <expression>} <target variable> ::= <simple variable> | <structured target> <structured target> ::= <constructor>(<target variable list>) <target variable list> ::= <empty> | <target variable> {, <target variable>}

  13. Matching Assignment x := e c(x1, x2, …, xn) := c(e1, e2, …, en) • Fails if the value of expression is undefined or if that value doesn’t match the target variable • A simple target variable matches any value of its type. • A structured target variable matches a structured value if • they have the same constructor • they have the same number of components • Each component matches the corresponding component

  14. Example 1. x := x + 1 2. (x, y) := (y, x) 3. x := cons(left, right) 4. cons(left, right) := x Q: Match? Differ from 3? 5. insert(n) := insert(2*x + 10) 6. x := P() 7. P() := x Q: Match? 8. insert(n) := has(n) Q: Match?

  15. Input and Output Commands • Specify communication between two CSPs, say P1 and P2, e.g., [P1:: x: integer; P2?x || P2:: P1!10] • Communication occurs if I/O commands correspond: • The source of an input command in P1 is P2. • The destination of an output command in P2 is P1. • The target variable of the input in P1 matches the expression of the output in P2. • Semantics • Simultaneous execution of corresponding I/O commands • Effect: similar to an assignment <input command> ::= <source> ? <target variable> <output command> ::= <destination> ! <expression> <source> ::= <process name> <destination> ::= <process name> <process name> ::= <identifier> | <identifier> ( <subscripts> ) <subscripts> ::= <integer expression> {, <integer expression>}

  16. Example 1. cardreader?cardimage 2. lineprinter!lineimage 3. X?(x, y) 4. DIV!(3*a + b, 13) Q: if 3 and 4 correspond? 5. console(i)?c 6. console(j - 1)!“A” 7. X(i)?V() 8. sem!P()

  17. Alternative Commands • Specify execution of exactly one of its constituent guarded commands, e.g., [x  y  m := x [] y  x  m := y] • Guarded commands with ranges (i:1..n)G  CL stands for G1 CL1 [] G2 CL2 [] … [] Gn CLn • Multiple guard elements with an optional input command at the end [x > 0; y: integer; user?y  user!(y/x)] <alternative command> ::= [<guarded command> {[] <guarded command>}] <guarded command> ::= <guard> -> <command list> | (<range>{,<range>})<guard> -> <command list> <guard> ::= <guard list> | <guard list>; <input command> | <input command> <guard list> ::= <guard element> {; <guard element>} <guard element> ::= <boolean expression> | <declaration>

  18. Exercise • Write a process that reads a number from a user and returns its sign, i.e., -1 for negative, 0 for 0, and 1 for positive. • Write a process that reads three numbers from a user and returns them sorted in ascending order.

  19. Repetitive Commands • Specify as many iterations as possible of its constituent alternative command. • Terminate with no effect when all guards fails. i: integer; i := 0; *[i < size; content(i)  n  i := i + 1] *[c: character; west?c  east!c] *[(i:1..10)continue(i); console(i)?c  X!(i, c); console(i)!ack(); continue(i) := (c  sign_off)] *[n: integer; X?insert(n)  INSERT [] n: integer; X?has(n)  SEARCH; X!(i < size)] *[X?V()  val := val + 1 [] val > 0; Y?P()  val := val – 1] <repetitative command> := *<alternative command>

  20. Exercise • Write a process that finds a maximum value of an array. • Write a process that performs a binary search on a sorted array.

  21. Example: Coroutines Read a sequence of cards of 80 characters each, and print the characters on a line printer a 125 characters per line. Each card should be followed by an extra space, and the last line should be completed with spaces if necessary. [west:: DISASSEMBLE || X:: COPY || east:: ASSEMBLE] *[cardimage: (1..80)character; cardfile?cardimage  i: integer; i:= 1; *[i  80  X!cardimage(i); i := i + 1]; X!space] *[c: character; west?c  east!c] lineimage:(1..125)character; i: integer; i := 1; *[c: character; X?c  lineimage(i) := c; [i  124  i := i + 1 [] i = 125  lineprinter!lineimage; i = 1]]; [i = 1  skip [] i > 1  *[i  125  lineimage[i] := space; i := i + 1]; lineprinter!lineimage]

  22. Example: Subroutines Construct a process to accept a positive dividend and divisor, and to return their integer quotient and remainder. [DIV:: *[x, y: integer; X?(x, y)  quot, rem: integer; quot := 0; rem := x; *[rem  y  rem := rem – y; quot := quot + 1]; X!(quot, rem)] • Compute a factorial by the recursive method, to a given limit. [fact(i:1..limit):: *[n: integer; fact(i - 1)?n  [n = 0  fact(i - 1)!1 [] n > 0  fact(i + 1)!(n – 1); r: integer; fact(i + 1)?r; fact(i - 1)!(n * r)]] || fact(0):: USER]

  23. Example: ADT Represent a set of not more than 100 integers as a process, S, which accepts two kinds of instruction from its calling process X: S!insert(n): insert the integer n in the set S!has(n); …; S?b: query if n is included in the set S:: content: (0..99)integer; size: integer; size := 0; *[n: integer; X?has(n)  SEARCH; X!(i < size) [] n: integer; X?insert(n)  SEARCH; [i < size  skip [] i = size; size < 100  content(size) := n; size := size + 1]] where SEARCH is i: integer; i := 0; *[i < size; content(i)  n  i := i + 1] Q: What happen if attempted to insert more than 100 elements? Q: What happen if attempted to insert a new element while the previous insertions is still being processed?

  24. Example: ADT Extend the set ADT to provide a fast method of scanning all members of the set, e.g., S!scan(); more: boolean; more := true; *[more; x: integer; S?next(x) … use x … [] more; S?noneleft() more := false] Add a third guarded command to S: … [] X?scan()  i: integer; i := 0; *[i < size  X!next(content(i)); i := i + 1]; X!noneleft()

  25. Exercise Extend the set ADT to introduce two new operations S!remove(x) S!least(); …; x: integer; [S?x … use x … [] S?noneleft() …]

  26. Exercise Define a bounded stack ADT by providing typical stack operations such as push, pop, top, and isEmpty.

  27. Example: ADT Define a set ADT by using an array of processes to achieve a high degree of parallelism. (Idea: Each has at most one value, and values kept as sorted.) S(i:1..100):: *[n: integer; S(i – 1)?has(n)  S(0)!false; [] n: integer; S(i – 1)?insert(n)  *[m: integer; S(i – 1)?has(m)  [m  n  S(0)!(m = n) [] m > n  S(i + 1)!has(m)] [] m: integer; S(i – 1)? insert(m)  [m < n  S(i + 1)!insert(n); n := m [] m = n  skip [] m > n  S(i + 1)!insert(m)]]] User process S(0) interacts with the processes as follows: S(1)!has(n); …; [(i:1..100)S(i)?b  …]

  28. Exercise Extend the previous solution to respond to a command to yield the least element of the set and to remove it from the set. The user program will invoke the facility by a pair of commands: S(1)!least(); [x: integer; S(1)?x  … use x … [] S(1)?noneleft()  …] or, the user wishes to scan and empty the set, he may write: S(1)!least(); more: boolean; more := true; *[more; x: integer; S(1)? X  … use x …; S(1)!least() [] more; S(1)?noneleft()  more := false]

More Related