Transcript Document
Haskell-Coloured Petri Nets
Implementation and Applications
( a work-in-progress talk ) Canterbury, Kent 05 August 2004
Claus Reinke
(high-level) Petri nets
• • • •
Petri nets
are a
generalisation of finite automata for concurrent and distributed systems
: – distributed state – local state transitions
places
hold
multisets of resources
, marked by anonymous ("black")
tokens transitions
consume resources
from input places and
produce resources
on output places
high-level nets
annotate ("colour") tokens with
data objects of some programming language
, manipulated by transition inscriptions in the same language
HCPN
•
Haskell-Coloured Petri Nets
[Reinke 1999] are high level Petri nets using Haskell as the inscription language • some related tools (and inscription languages): – – – –
Design/CPN
[Jensen et.al. 1989-2003]: Standard ML
CPN Tools
[Jensen et.al. 2003-]: Standard ML
Graph
[Schepers et.al. 1988-1992]: Kiel Reduction Language
Genomic Object Net
[Matsuno et.al. 2003] : unspecified functional language (HFPN are a hybrid functional Petri net formalism, used for representing and simulating bio-pathways) –
Cell Illustrator
[Gene Networks Inc. 2003]: commercial version of GON
building net models
(building blocks) • basic actions: – consumer – producer • composition/communication: – asynchronous (buffered) – synchronous (no buffer) – concurrency (independent) – conflict (sharing) – coincidence (synchronisation)
example: critical region
(mutually exclusive access to shared resource) • system to be modelled: – two processes A and B, one shared resource – each process does some non-critical computations, – but occasionally needs
exclusive
access to the shared resource, – when it gets access to the shared resource, it will enter its "critical region" to work with the resource, – when done with the resource, the process will release it, and continue with non-critical computations • a standard os/concurrency example
critical region – stage 1
(mutually exclusive access to shared resource)
critical region – stage 2
(mutually exclusive access to shared resource)
example: critical region
(mutually exclusive access to shared resource)
towards HCPN models
– places have Haskell
types
– consumer arcs can be labelled with
patterns
, transitions with
boolean guards
(pattern match failure or false guards disable) Just a (a>0) – producer arcs can be labelled with
expressions
1+2 – synchronised actions share
input variable environments
Just x "done" y (y/=0) x/y
building net models
(techniques) •
find the sequential components
in your system, and model their state transitions as
finite automatons
•
compose the sequential subsystems as a net
–
asynchronous communication
via buffer places (may be producer/consumer
causal relationship
, or
conflict about shared resources
) –
synchronisation of transitions
in separate subsystems •
identify identical subsystems
– use
labeled sum types
to distinguish tokens in subsystems –
fold the subsystems
together, using functional abstraction • model
static system aspects
in the
net structure
• model
dynamic aspects
in the
net markings
• think about
system invariants
• ..
example: starving philosophers
• actually, "dining philosophers":-) • system to be modelled: – three philosophers sit a round table – between each pair of philosophers is a fork – the philosophers think about the worlds problems – when a philosopher gets hungry, he takes his right and left fork, and starts to eat – when a philosopher has sated his appetite, he puts both forks back down and resumes his higher pursuits • typical abstraction of real-world concurrency problems, especially a more complex variant of shared resources
philosophers – stage 1
philosophers – stage 2
philosophers – stage 3
example: starving philosophers
philosophers – stage 4
(adding colour)
philosophers – stage 5
(folding structure into colour)
example: folded philosophers
we could fold further, until we're left with one transition/place; the trick is to find the right balance between structure and colour
example: erlang resource locker
a variable number of processes sharing several resources one process mover can move
non-critical
processes to different node
example: erlang resource locker
a variable number of processes sharing several resources one process mover can move
non-critical
processes to different node
embedding HCPN in Haskell (I)
• implementing a HCPN toolchain requires at least – graphical editor – net simulator – functional inscription language evaluator • that is too much work (about 3 years?)!
• to avoid re-implementing Haskell, need
eval
.., but: Haskell doesn't offer runtime reflection • so we
generate Haskell code from HCPN
instead • the transition firing rule is tightly interwoven with evaluation of Haskell patterns and guards, so we should
deal with nets and inscriptions in the same code generation step
embedding HCPN in Haskell (II)
places and markings • the places of a net form a heterogeneous collection – maps to a record, with a field for each place –
(may need to revisit this when nets get modular)
• each place marking is a homogeneous multiset – use lists for now –
(probably inefficient for large markings; revisit then)
• so the places of a net map to a record type, and net markings map to records of this type, nice and simple: data Mark = Mark { place_n mark = Mark { place_n = [ :: [ type_of_place_n ] } initial_marking_of_place_n ]}
embedding HCPN in Haskell (IIIa)
transitions, arc labels, guards • firing rule for an HCPN transition: –
transition is enabled
iff on each input place there is a token matching the label on the corresponding input arc and the guard evaluates to True under the bindings introduced by the pattern matches –
enabled transition fires
by consuming the enabling tokens from its input places and producing tokens on its output places; the values of the latter tokens are determined by the expression labels on the corresponding output arcs under the bindings introduced via the enabling pattern matches • each transition can be enabled by multiple bindings
trans_n
:: Mark -> [Mark]
embedding HCPN in Haskell (IIIb)
transitions, arc labels, guards c a Just x t "done" b y (y/=0) x/y t :: Mark -> [Mark] t m = do (Just x,a_rest) <- select (a m) (y,b_rest) <- select (b m) if (y/=0) then return m{a = a_rest ,b = b_rest ,c = ("done"):(c m) ,d = (x/y):(d m) } else fail "guard failed" d
embedding HCPN in Haskell (IV)
whole net and simulation loop net_declarations data Mark = Mark { place_n mark = Mark { place_n t_n :: Mark -> [Mark] = [ :: [ type_of_place_n ] } initial_marking_of_place_n ]} net = Net{ Trans{name=" t_n ",action= t_n} } main = run net mark run net marking = print marking >> if null enabledTs then putStrLn "no more enabled transitions!" else do trans <- choose enabledTs putStrLn (fst $ fst trans) run net (snd trans) where enabledTs = enabled net marking
embedding HCPN in Haskell (V)
graphics • • • nowadays, Haskell has (once again..) GUI libs • chose
wxHaskell
(no frills, but portable, aims for the long run, and was agreed on as the lib to build on by the Haskell GUI folks; first higher-level libs based on it already on the way) •
build graphical net editor and Haskell code exporter
• invert simulation loop [done] (drive it by timer events so it can be slowed down to a visible 2 steps/sec) [done]
interface simulation loop to graphics
[done] – load and display net graphics – map transition and place names to node ids in loaded net – generate showMarking function that updates marking
compilation&loading of generated code from editor
– [in progress] –
interpret error messages
in terms of source
net!
experience so far..
•
Petri nets and Haskell combine nicely
(Haskell is good for abstract languages/machines and Petri nets are great for concurrency concepts) could now use Haskell, e.g., in OS lectures instead of just compiler lectures, or in concurrent system design!
•
HCPN now have initial tool support
export, graphical simulation) – (graphical editing, code
you can use them!
• original estimate was 2 weeks for editor and simulator; textual simulation was only a day, but fiddling with graphics issues and overall design took longer (lack of recent GUI experience; GUI lib still in development);
now slightly over a month of work;
• • • doing practical stuff in Haskell (with GUI) is fun!
lots of by-hand refactoring
(mostly to grow or change design, i.e., for experimentation and development, not for cleanup!)
lots remains to be done
(continued fiddling and bug fixing, but also support for hierarchical nets, other arc types, state space generation/exploration, ..)