Transcript Modelling Concurrency using FSP Section 7 1

Section 7
Modelling Concurrency using FSP
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
1
Parallel composition - 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).
thinktalkscratch
thinkscratchtalk
scratchthinktalk
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
Possible traces as
a result of action
interleaving.
2
Parallel composition - action interleaving
scratch
think
ITCH
talk
CONVERSE
0
1
0
2 states
1
scratch
2
3 states
scratch
think
talk
scratch
CONVERSE_ITCH
from ITCH
0
1
2
(0,0)
(0,1)
(0,2)
3
(1,2)
from CONVERSE
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
4
talk
(1,1)
5
think
(1,0)
2 x 3 states
3
Parallel composition - algebraic laws
Commutative:
Associative:
(P||Q) = (Q||P)
(P||(Q||R)) = ((P||Q)||R)
= (P||Q||R).
Clock radio example:
CLOCK = (tick->CLOCK).
RADIO = (on->off->RADIO).
||CLOCK_RADIO = (CLOCK || RADIO).
LTS?
Traces?
Number of states?
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
4
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.
MAKER = (make->ready->MAKER).
USER = (ready->use->USER).
||MAKER_USER = (MAKER || USER).
LTS?
Traces?
MAKER
synchronizes
with USER
when ready.
Number of states?
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
5
Modelling interaction - handshake
A handshake is an action acknowledged by another:
MAKERv2 = (make->ready->used->MAKERv2).
USERv2 = (ready->use->used ->USERv2).
3 states
3 states
||MAKER_USERv2 = (MAKERv2 || USERv2).
3 x 3
states?
make
0
ready
1
use
2
used
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
4 states
3
Interaction
constrains
the overall
behaviour.
6
Modelling interaction - multiple processes
Multi-party synchronization:
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).
makeA
makeB
0
makeA
1
ready
2
assemble
3
4
5
makeB
used
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
7
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).
Substituting the definition for MAKERS in FACTORY and applying the
commutative and associative laws for parallel composition results in
the original definition for FACTORY in terms of primitive processes.
||FACTORY = (MAKE_A || MAKE_B || ASSEMBLE).
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
8
Process labeling
a:P prefixes each action label in the alphabet of P with a.
Two instances of a switch process:
SWITCH = (on->off->SWITCH).
||TWO_SWITCH = (a:SWITCH || b:SWITCH).
a.on
b.on
a:SWITCH
b:SWITCH
0
1
a.off
0
1
b.off
An array of instances of the switch process:
||SWITCHES(N=3) = (forall[i:1..N] s[i]:SWITCH).
||SWITCHES(N=3) = (s[i:1..N]:SWITCH).
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
9
Process labelling by a set of prefix labels
{a1,..,ax}::P replaces every action label n in the
alphabet of P with the labels a1.n,…,ax.n. Further,
every transition (n->X) in the definition of P is
replaced with the transitions ({a1.n,…,ax.n} ->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).
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
10
Process prefix labels for shared resources
a.acquire
a.use
b.acquire
a:USER
b.use
b:USER
0
1
2
0
1
a.release
2
b.release
How does the model ensure
that the user that acquires
the resource is the one to
release it?
b.acquire
b.acquire
a.acquire
{a,b}::RESOURCE
0
1
a.acquire
b.use
a.release
b.release
a.use
RESOURCE_SHARE
0
1
2
3
4
b.release
CSC321 Concurrent Programming: §7 Modelling Concurrency
using FSP
a.release
11
Action relabelling
Relabelling functions are applied to processes to change
the names of action labels. The general form of the
relabelling function is:
/{newlabel_1/oldlabel_1,… newlabel_n/oldlabel_n}.
Relabelling to ensure that composed
processes synchronize on particular actions.
CLIENT = (call->wait->continue->CLIENT).
SERVER = (request->service->reply->SERVER).
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
12
Action relabelling
||CLIENT_SERVER = (CLIENT || SERVER)
/{call/request, reply/wait}.
call
reply
SERVER
CLIENT
0
1
call
0
2
1
call
0
2
reply
continue
CLIENT_SERVER
service
service
1
reply
2
3
continue
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
13
Action relabelling - prefix labels
An alternative formulation of the client server system is
described below using qualified or prefixed labels:
SERVERv2 = (accept.request
->service->accept.reply->SERVERv2).
CLIENTv2 = (call.request
->call.reply->continue->CLIENTv2).
||CLIENT_SERVERv2 = (CLIENTv2 || SERVERv2)
/{call/accept}.
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
14
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 labeled tau. Silent actions in different
processes are not shared.
Sometimes it is more convenient to specify the set of
labels to be exposed....
When applied to a process P, the interface
operator @{a1..ax} hides all actions in the
alphabet of P not labeled in the set a1..ax.
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
15
Action hiding
The following definitions are equivalent:
USER = (acquire->use->release->USER)
\{use}.
USER = (acquire->use->release->USER)
@{acquire,release}.
acquire
0
tau
1
2
Minimisation removes hidden
tau actions to produce an
LTS with equivalent
observable behaviour.
acquire
release
0
1
release
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
16
Exercise
A museum allows visitors to enter through the east entrance and
leave through the west exit. Arrivals and departures are signaled
to the museum controller by the turnstiles at the entrance and
exit. At opening time, the museum director signals the controller
that the museum is open and then the controller permits both
arrivals and departures. At closing time, the director signals that
the museum is closed , at which point only departures are
permitted by the controller.
Construct an FSP model of the museum using four processes:
EAST, WEST, CONTROL and DIRECTOR.
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
17
Exercise
/* museum
*/
const N = 5
EAST = (arrive -> EAST).
WEST = (leave -> WEST).
DIRECTOR = (open -> close -> DIRECTOR).
CONTROL = CLOSED[0],
CLOSED[i:0..N] = (when (i==0) open -> OPENED[0]
|when (i>0)
leave -> CLOSED[i-1]),
OPENED[i:0..N] = (close -> CLOSED[i]
|when (i<N) arrive -> OPENED[i+1]
|when (i>0) leave
-> OPENED[i-1]).
||MUSEUM = (EAST || WEST || DIRECTOR || CONTROL).
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
18
CSC321 Concurrent Programming: §7 Modelling Concurrency using FSP
19