- By
**conor** - Follow User

- 119 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about ' Symbolic Concurrent Semantics of Safe Petri nets' - conor

**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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Symbolic Concurrent Semantics of Safe Petri nets

Application to Time Petri Nets

Claude Jard, ENS Cachan / IRISA, Rennes, France

&

Thomas Chatain, ENS Cachan / LSV, Cachan, France

Why are we interested in PN and unfoldings?

- Supervision and diagnosis: inferring causal dependencies from observations in a distributed system (guided unfolding) -> already in use on Alcatel platforms
- Composition of QoS contracts in WS orchestrations (need a partial order view of the behaviours) -> concurrent semantics for ORC

In such application domains, we do not need strong decidability results and thus consider extensions of PN with data, time, probas, …

Focus of the talk

- Generalize our symbolic approach about unfoldings of time Petri nets
- Better understand time specificities in a concurrent setting
- Safe colored PN with linear real constraints
- Concurrent semantics for such nets
- Translations of Time PN

Background: PNs

- Places P = {a,b,c}, Transitions T = {u,v,w}

Consumed (pre(p,t)), read (cont(p,t)) or written (post(p,t)) by transitions

- Marking: p M(p) {0,1},
- initially: M0(a)= M0(b)=1, M0(c)=0
- t fireable iff ppre(t)cont(t), M(p)=1
- Sequential move by firing t:
- p, M(p):=M(p)-pre(p,t)+post(p,t)

Why do we need read arcs?

- To be able to test the presence of tokens without serialisation

Concurrent semantics: processes

- v and w can be executed concurrently

Processes

(partially ordered

executions):

Unfolding: union of all the processes

Prefix (*≤1):

Notion of conflict

- fg = (f ≤ g) (cont(f) pre(g) )
- Conflict(F) =
- f,g F, pre(f) pre(g)

or

- (fi)i[1,n] F, fn=f1 i[1,n-1] fi fi+1

Unfolding: the puzzle game

Maximal co-sets of places

correspond to markings

-> notion of

finite complete prefix

-> bounded in space by the

size of the marking graph

(can be exponentially smaller)

-> but the time complexity

can be exponential

(size of the prefix to the power

of the degree of concurrency)

w

Our Safe Colored PNs

- Places P: finite set of real variables
- Transitions T: labeled (G(t)) with linear expressions over pre(t)+cont(t)+post(t)’
- Initial expression: ζ0

Concurrent semantics

- Set of events:
- U={e=(e,e,Ce,Me)}

- ⊥=(∅ζ0[x/x⊥]x∈M0, M0) ∈ U
- pre(e) cont(e) f∈e Mf
- Me=post(e)
- Ce=G(e)[x/xe]x∈pre(e)cont(e) [x’/xe]x∈post(e)
- e is conflict-free

f∈e Cf Ce satisfiable

e∈ U

Unfolding / Process / Trace

- Unfolding is the union of processes
- Processes are the conflict-free and downward-causally-closed subsets of the unfolding
- Linear extensions of processes are the sequential traces
- No hope to obtain in general a complete finite prefix

Safe Time PNs

- Syntax:
- TPN=(P,T,pre,post,efd,lfd,M0)
- efd: T|R
- lfd: T |R{}
- Sequential semantics:
- dob: P|R
- (M,dob) -t,-> (M’,dob’) iff
- - pre(t)M
- - maxppre(t) dob(p) + efd(t) ≤
- - t’T, pre(t’)M ≤ maxppre(t’) dob(p) + lfd(t’)
- - maxpPdob(p) ≤
- M’=(M\pre(t)) post(t)
- dob’(p)= if ppost(t), dob(p) otherwise

TPN to CPN : read arcs are added to take into account

the time dependencies

-> duplication of transitions

-> try to minimize the number of read arcs

Short term perspectives

- Experiments
- Existence of finite complete prefixes ? OK
- Coding of some TPN extensions ? Stopwatches, parametric PNs…
- Study a similar approach for networks of Timed Automata. Experiment with different semantics for time.

Download Presentation

Connecting to Server..