BPMN and Beyond Business process modelling notation, workflow ...

Token Sets To speak about the synchronization of tokens in cycles needs the ability to express
that certain tokens belong together, whereas others do not. To express such a concept we introduce
token sets, i.e. sets of tokens which are viewed as a coherent group when a join fires. We will use
the token sets to assign new token sets to tokens at paths that have later to be synchronized and
to distinguish tokens in cycles by appropriately assigned token sets. In this section we prepare the
needed purely syntactical refinement, which is used in the next section to handle the problem of
cycles.
We will make sure that each token t is a member of exactly one token set tokenSet(t). We
assume that upon a start event a token set tokenSet(t) is generated for the start token t. When
new tokens t ′ appear during the computation, their tokenSet(t ′ ) has to be defined, as happens in
particular in the join rules. In the purely syntactical refinement defined in this section, the new
tokens are declared to belong to the same token set as the firing tokens.
We also have to refine the concept of Enabledness to guarantee that each time only tokens of
one token set ts are considered.
Enabled(in, ts) = (| token(in) ∩ ts |≥ inQty(in))
Similarly we impose on firingToken that each time only tokens belonging to one token set are
selected.
if firingToken(node) = {t 1 , . . . , t n } then forall 1 ≤ i ≤ n tokenSet(t i ) = tokenSet(t 1 )
This leads to the following refinement of the AND-join rule:
AndJoinGateTransition(node) = WorkflowTransition(node)
where
let {in 1 , . . . , in n } = inArc(node)
let {t 1 , . . . , t n } = firingToken(inArc(node))
let ts = tokenSet(t 1 )
CtlCond(node) = forall in ∈ inArc(node) Enabled(in, ts)
CtlOp(node) =
ConsumeAll({(t i , in i ) | 1 ≤ i ≤ n})
Produce(andJoinToken({t 1 , . . . , t n }), out)
tokenSet(andJoinToken({t 1 , . . . , t n })) := ts
ConsumeSyncAll({(t i , in)|in ∈ AllJoinArc(out), 1 ≤ i ≤ n} ∪ {(t i , in i ) | 1 ≤ i ≤ n})
ProduceSyncAll({(andJoinToken(t 1 , . . . , t n ), in)|in ∈ AllJoinArc(out)})
Synchronization at an OR-join only happens among tokens of the same token set. We therefore
refine the synchronization part of the control condition as follows, where ts is the given token set:
CtlCondSync(node, I , ts) =
forall i ∈ I syncToken(i) ∩ ts ≠ ∅ and forall i ∈ inArc(node) \ I syncToken(i) ∩ ts = ∅
With these preparations we can now refine the Or-join to work only on tokens of the token set
underlying the to-be-fired tokens on the selected arcs:
OrJoinGateTransition(node) = WorkflowTransition(node)
where
let I = {in 1 , . . . , in n } = select Consume (node)
let {t 1 , . . . , t n } = firingToken(I )
let ts = tokenSet(t 1 ) in
CtlCond(node) = (I ≠ ∅ and forall i ∈ I Enabled(i, ts) and CtlCondSync(node, I , ts))
CtlOp(node) =
Produce(orJoinToken(firingToken(I )), out)
tokenSet(orJoinToken(firingToken(I ))) := ts
ConsumeAll({(t i , in i ) | 1 ≤ i ≤ n})
ConsumeSyncAll({(t i , in)|in ∈ AllJoinArc(out), 1 ≤ i ≤ n} ∪ {(t i , in i ) | 1 ≤ i ≤ n})
ProduceSyncAll({(orJoinToken(t 1 , . . . , t n ), in)|in ∈ AllJoinArc(out)})
15