Compiling Communicating
Processes into Delay-Insensitive
VLSI Circuits
Alain J. Martin
Department of Computer Science
California Institute of Technology
Communicating Hardware
Processes
Inspired by:
• Hoare's communicating sequential processes
(CSP).
• Dijkstra's guarded commands.
Based on:
• Concurrent processes communicating by
messagepassing.
Communicating Hardware
Processes
Data Types
• Only basic type is the boolean.
• Other types are collections of booleans
represented using PASCAL record notation.
• Example: alu = record
op : alu.15..alu.12
x : alu.11..alu.8
y : alu.7..alu.4
z : alu.3..alu.0
end
• 8-bit integer x : x.0, x.1, ..., x.7.
Communicating Hardware
Processes
Assignment:
• For a boolean b:
• The command b:=true
assigns the value true to b
(also denoted b+ or b ).
• The command b:=false
assigns the value false to b
(also denoted b- or b ).
• Given two integers x and y of the same length n:
y := x ==> y.0, y.1, ..., y.(n-1) := x.0, x.1, ..., x.(n-1).
Communicating Hardware
Processes
Arrays:
• Arrays are used when the identity of the element
in a set of variables that is to be used for some
action is determined during the computation.
• Example:
reg[i.z] := aluf (reg[i.x], reg[i.y], i.op)
Note: instruction i is of of type alu
Communicating Hardware
Processes
Composition Operators
• There are three composition operators:
• The sequential operator: ;.
• The concurrent, or parallel, operator: ||.
• The coincident, or bullet, operator: ..
Communicating Hardware
Processes
Sequential Operator
• S 1;S 2 means first execute S 1 then execute S 2 .
• The ``;'' operator is associative:
(S 1 ; S 2 ); S 3 = S 1 ; (S 2 ; S 3 )
• The ``;'' operator is NOT commutative:
S 1 ; S 2 <> S 2 ; S 1
Communicating Hardware
Processes
Parallel Operator
• S 1 || S 2 means S 1 and S 2 are executed in
parallel.
• The || operator is associative and commutative:
(S 1 || S 2 ) || S 3 = S 1 || (S 2 || S 3 )
S 1 || S 2 = S 2 || S 1
Communicating Hardware
Processes
Bullet Operator
• S1.S2 means S1 and S2 complete simultaneously.
• The . operator is associative and commutative:
(S 1 . S 2 ) . S 3 = S 1 . (S 2 . S 3 )
S1.S2=S2. S1
Communicating Hardware
Processes
Other Properties
• If S 1 and S 2 are noninterfering,
S 1 || S 2 is equivalent to the execution of either
. S2.
• The operator precedence is: (1) . (2) ; (3) ||:
S 0 . S 1 ; S 2 || S 3 ===> ((S 0 . S 1 ); S 2 ) || S 3
S 1 ; S 2 or S 2 ; S 1 or S 1
Communicating Hardware
Processes
Control Structures
• Selection
• Repetition
• Deterministic and nondeterministic versions
Communicating Hardware
Processes
Deterministic selection:
[G1 ==> S1 [] ... [] Gn ==> Sn ]
• G1, ..., Gn are boolean expressions called guards.
• S1 , ..., Sn are parts of a program, or commands.
• Gi ==> Si :a guarded command
if Gi evaluates to true then Si is executed.
• At any time, at most one guard is true.
• If no guard is true, the execution is suspended.
• Exact one guarded command will be executed
Communicating Hardware
Processes
Nondeterministic selection:
[G1 ==> S1 | ... | Gn ==> Sn ]
• Identical to deterministic selection except that
multiple guards can be true at the same time.
• If multiple guards are true, one is selected
arbitrarily.
• Exact one guarded command will be executed
Communicating Hardware
Processes
Deterministic repetition:
*[G1 ==> S1 [] ... [] Gn ==> Sn ]
• G1, ..., Gn are boolean expressions.
• S1 , ..., Sn are parts of a program.
• Gi ==> Si :a guarded command
if Gi evaluates to true then Si is executed.
• After Si completes, control returns to the start.
• At any time, at most one guard is true.
• If no guard is true, the repetition terminates.
• Zero, one or more guarded commands can be executed
Communicating Hardware
Processes
Nondeterministic repetition:
*[G1 ==> S1 | ... | Gn ==> Sn ]
• Identical to deterministic repetition except that
multiple guards can be true at the same time.
• If multiple guards are true, one is selected
arbitrarily.
Communicating Hardware
Processes
• Wait command:
[G]= [G ==> skip]
• Infinite repetition:
*[S] = *[true ==> S]
• Reactive Process Structure
*[[G1 ==> S1 [] ... [] Gn ==> Sn ]]
Wait until some Gi holds; execute Si ;
repeat forever.
Communicating Hardware
Processes
Replication Construct
• Used to represent a list of syntactic objects.
<op i : n..m : S(i)> =
S(n), if n = m
S(n) op (<op i : n+1..m : S(i)>), if n < m
• op is any constructor (;,.,||) or separator ([],|,``,'',`` ''),
• i is an integer variable, called the running index,
• the range, defined by n..m, where n and m are
integer constants, is not empty, i.e., n <= m,
• S(i) is any program part in which i appears free.
Communicating Hardware
Processes
Replication Construct
• Example:
[<[] i : 0..3 : G(i) ==> S(i)>] =
[
]
G(0) ==> S(0)
[] G(1) ==> S(1)
[] G(2) ==> S(2)
[] G(3) ==> S(3)
Communicating Hardware
Processes
Procedures
• Procedure parameters are either input or output.
• Example:
procedure p(x : input; y : output); S
• The procedure call p(a, b) is equivalent to:
x := a; S; b := y
Communicating Hardware
Processes
Functions
• Function parameters are always inputs.
• Example:
function y(x); S
where S is the same program part as in
procedure p.
Communicating Hardware
Processes
Concurrent Processes
• Main building block of a computation is a process.
• Body of a concurrent computation is of the form:
p1 || p2 || . . . || pn
where p1 through pn are processes.
• Several instances of the same process type can
be called by assigning different names.
• Unlike procedures, each instance of a process
can be called only once.
Communicating Hardware
Processes
Communication Commands,Ports, & Channels
• Processes communicate by using communication
commands on ports.
• Ports are declared in the heading of a process:
p = process(R, L)
• A port of a process is paired with a port of another
process to form a channel.
p1 =process(X) . . . end
p2 =process(Y) . . . end
p1 || p2
chan(p1.X, p2.Y)
Communicating Hardware
Processes
• Example:
p1 =process(X) . . . end
p2 =process(Y) . . . end
p1 || p2
chan(p1.X, p2.Y)
• Equivalent to:
p1 =process(C) . . . end
p2 =process(C) . . . end
p1 || p2
chan(C)
p1
p1
X
Y
C
p2
p2
Communicating Hardware
Processes
Semantics of Synchronization
• Number of completed receive actions cR cannot
exceed the number of completed send actions cS:
cR <= cS
• Without buffering, if two processes p1 and p2 share
a channel with port X in p1 and port Y in p2 , then
cX = cY
Communicating Hardware
Processes
Probe
• If p1 reaches the n th X-action before p2 reaches
the n th Y-action, the completion of X is suspended
until p2 reaches Y.
• The X-action is said to be pending.
• The predicate ``X is pending'' is denoted qX.
•The probe X in process p1 is the same value as qY.
Communicating Hardware
Processes
Communication
• Matching communication actions ``pass messages''
• X? is an input command on the input port X.
• Y! is an output command on the output port Y.
• X?u and Y!v implement the assignment v := u.
Communicating Hardware
Processes
Stream Merge:
X
Y
Merge
Z
MERGE = process(X?int(8), Y?int(8), Z!int(8))
u : int(8)
*[ [ X ==>X?u; Z!u
| Y ==>Y?u; Z!u
] ]end
Communicating Hardware
Processes
One-place Buffer:
L
Buf
BUF1=process(L?int(8), R!int(8))
x : int(8)
*[L?x; R!x]
end
R
Communicating Hardware
Processes
N-place Buffer
Buf(n).L
p(0).L
P(0).R
P(1).R
P(0) P(1).L P(1) p(2).L
P(n-1).R
P(n-1)Buf(n).R
BUF(n) =process(L?int(8), R!int(8))
p(i : 0..n-1) : BUF1
<|| i : 0..n-1 : p(i)>
chan<i : 0..n-2 : (p(i).R,p(i+1).L))>
p(0).L = BUF(n).L
p(n-1).R = BUF(n).R
end
Communicating Hardware
Processes
Lazy Stack
in
Stack element:
head
put get
in out
Empty=[ in ==> in?x;Full
[] out ==> get?x;out!x;Empty Tail
]
Full =[ out ==> out!x;Empty
[] in ==> put!x;in?x;Full
]
out