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

The BPMN standard forsees also that in each round a loopCounter is updated, which can be used
in the loopCond (as well as a loopMaximum location). The standard document does not explain
however whether the input is taken only once, at the entry of the iteration, or at the beginning
of each iteration step. There are reasonable applications for both interpretations, so that the issue
should be clarified. This is partly a question of whether the function inputs, which is applied to
the selected input set currInput(node) to provide the input for the iterBody of the to be iterated
activity, is declared to be a static or a dynamic function.
The preceding discussion is summarized by the following rule for nodes with loopType(node) =
Standard. For a natural definition of while and until in a way that is compatible with the synchronous
parallelism of ASM execution see [12, Ch.4]. We use an abstract function loopToken to
denote how (if at all) the information on loop instances and incoming tokens is elaborated during
the iteration.
LoopTransition(node) = [if Enabled(in) then]
let t = firingToken(in)
LoopEntry(node, t)
seq
if testTime(node) = before then
while loopCond(node, t) LoopBody(node, t)
if testTime(node) = after then
until loopCond(node, t) LoopBody(node, t)
[seq LoopExit(node, t)]
where
LoopBody(n, t) =
loopCounter(node, t) := loopCounter(node, t) + 1
iterBody(node, loopToken(t, loopCounter(node, t) + 1)[, inputs(currInput(node))])
The auxiliary machines LoopEntry and LoopExit are defined as follows (the possibly missing
parts, in case there is no incoming/outgoing sequence flow or no input/output, are in square
brackets). Note that the predicate LoopCompleted(n) is not defined in the standard document. It
seems that the standard permits to exit a loop at any place, for example by a link intermediate
event (Fig.10.46 p.126) or by a so-called Go To Object (Fig.10.45 ibid.), so that the question has
to be anwered whether this is considered as completion of the loop or not (see the example for
“improper looping” in Fig.10.51 p.129).
LoopEntry(n, t) =
loopCounter(n, t) := 0
[Consume(t, in)]
[currInput(n) := select InputSets (SomeAvail(inputSets(n)))]
LoopExit(n, t) =
if Completed(n, t) then
[ProduceOutput(outputSets(n), currInput(n))]
[Produce(loopExitToken(t, loopCounter(n, t)), out)]
Completed(n, t) = LoopCompleted(n, t) if n ∈ Loop(t)
Multi-Instance Loops The iteration condition of activities in the set MultiInstance of multiinstance
loops is integer-valued, an expression (location in ASM terms) denoted miNumber, called
MI-Condition in the standard document. A miOrdering for the execution of the instances is defined,
which is either parallel or sequential. In the latter case the order seems to implicitly be understood
as the order of integer numbers, so that we can use for the description of this case the ASM construct
foreach (for a definition see the appendix Sect. 10) followed by the submachine LoopExit defined
above. Also in this case a loopCounter is “updated at runtime”, though here it is allowed to
only be “used for tracking the status of a loop” and not in miNumber, which is assumed to
be “evaluated only once before the activity is performed” [15, Sect.9.4.1]. We reflect in the rule
26