This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

11institutetext: Technical University of Munich, Germany
11email: {meyerphi,esparza}@in.tum.de
22institutetext: IBM Research, Zurich, Switzerland
22email: hvo@zurich.ibm.com

Computing the concurrency threshold of sound free-choice workflow nets

 Philipp J. Meyer 11    Javier Esparza 11    Hagen Völzer 22
Abstract

Workflow graphs extend classical flow charts with concurrent fork and join nodes. They constitute the core of business processing languages such as BPMN or UML Activity Diagrams. The activities of a workflow graph are executed by humans or machines, generically called resources. If concurrent activities cannot be executed in parallel by lack of resources, the time needed to execute the workflow increases. We study the problem of computing the minimal number of resources necessary to fully exploit the concurrency of a given workflow, and execute it as fast as possible (i.e., as fast as with unlimited resources).

We model this problem using free-choice Petri nets, which are known to be equivalent to workflow graphs. We analyze the computational complexity of two versions of the problem: computing the resource and concurrency thresholds. We use the results to design an algorithm to approximate the concurrency threshold, and evaluate it on a benchmark suite of 642 industrial examples. We show that it performs very well in practice: It always provides the exact value, and never takes more than 30 milliseconds for any workflow, even for those with a huge number of reachable markings.

1 Introduction

A workflow graph is a classical control-flow graph (or flow chart) extended with concurrent fork and join. Workflow graphs represent the core of workflow languages such as BPMN (Business Process Model and Notation), EPC (Event-driven Process Chain), or UML Activity Diagrams.

In many applications, the activities of an execution workflow graph have to be carried out by a fixed number of resources (for example, a fixed number of computer cores). Increasing the number of cores can reduce the minimal runtime of the workflow. For example, consider a simple deterministic workflow (a workflow without choice or merge nodes), which forks into kk parallel activities, all of duration 1, and terminates after a join. With an optimal assignment of resources to activities, the workflow takes time kk when executed with one resource, time k/2\lceil k/2\rceil with two resources, and time 11 with kk resources; additional resources bring no further reduction. We call kk the resource threshold. In a deterministic workflow that forks into two parallel chains of kk sequential activities each, one resource leads to runtime 2k2k, and two resources to runtime kk. More resources do not improve the runtime, and so the resource threshold is 2. Clearly, the resource threshold of a deterministic workflow with kk activities is a number between 11 and kk. Determining this number can be seen as a scheduling problem. However, most scheduling problems assume a fixed number of resources and study how to optimize the makespan [11, 16], while we study how to minimize the number of resources. Other works on resource/machine minimization [6, 5] consider interval constraints instead of the partial-order constraints given by a workflow graph.

0ii1p1p_{1}1p2p_{2}1p3p_{3}2p4p_{4}2p5p_{5}1p6p_{6}1p7p_{7}2p8p_{8}2p9p_{9}0oot1t_{1}t2t_{2}t3t_{3}t4t_{4}t5t_{5}t6t_{6}t7t_{7}t8t_{8}
((a)) Sound free-choice workflow net NN
0ii1p1p_{1}1p2p_{2}1p3p_{3}2p4p_{4}1p6p_{6}1p7p_{7}2p8p_{8}2p9p_{9}0oot1t_{1}t2t_{2}t3t_{3}t6t_{6}t7t_{7}t8t_{8}
((b)) A run of NN
Figure 1: A sound free-choice workflow net and one of its runs

Following previous work, we do not directly work with workflow graphs, but with their equivalent representation as free-choice workflow Petri nets, which has been shown to be essentially the same model [10] and allows us to directly use a wealth of results of free-choice Petri nets [7]. Fig. 1(a) shows a free-choice workflow net. The actual workflow activities, also called tasks, which need a resource to execute and which consume time are modeled as the places of the net: Each place pp of the net is assigned a time τ(p)\tau(p), depicted in blue. Intuitively, when a token arrives in pp, it must execute a task that takes τ(p)\tau(p) time units before it can be used to fire a transition. A free choice exists between transitions t4t_{4} and t6t_{6}, which is a representation of a choice node (if-then-else or loop condition) in the workflow.

If no choice is present or all choices are resolved, we have a deterministic workflow such as the one in Fig. 1(b). In Petri net terminology, deterministic workflows correspond to the class of marked graphs. Deterministic workflows are common in practice: in the standard suite of 642 industrial workflows that we use for experiments, 63.7%63.7\% percent are deterministic. We show that already for this restricted class, deciding if the threshold exceeds a given bound is NP-hard. Therefore, we investigate an over-approximation of the resource threshold, already introduced in [4]: the concurrency threshold. This is the maximal number of task places that can be simultaneously marked at a reachable marking. Clearly, if a workflow with concurrency threshold kk is executed with kk resources, then we can always start the task of a place immediately after a token arrives, and this schedule already achieves the fastest runtime achievable with unlimited resources. We show that the concurrency threshold can be computed in polynomial time for deterministic workflows.

For workflows with nondeterministic choice, corresponding to free-choice nets, we show that computing the concurrency threshold of free-choice workflow nets is NP-hard, solving a problem left open in [4]. We even prove that the problem remains NP-hard for sound free-choice workflows. Soundness is the dominant behavioral correctness notion for workflows, which rules out basic control-flow errors such as deadlocks. NP-hardness in the sound case is remarkable, because many analysis problems that have high complexity in the unsound case can be solved in polynomial time in the sound case (see e.g. [7, 1, 8]).

After our complexity analysis, we design an algorithm to compute bounds on the concurrency threshold using a combination of linear optimization and state-space exploration. We evaluate it on a benchmark suite of 642 sound free-choice workflow nets from an industrial source (IBM) [9]. The bounds can be computed in a total of 7 seconds (over all 642 nets). On the contrary, the computation of the exact value by state-space exploration techniques times out for the three largest nets, and takes 7 minutes for the rest. (Observe that partial-order reduction techniques cannot be used, because one may then miss the interleaving realizing the concurrency threshold.)

The paper is structured as follows. Section 2 contains preliminaries. Sections 3 and 4 study the resource and concurrency thresholds, respectively. Section 5 presents our algorithms for computing the concurrency bound, and experimental results. Finally, Section 6 contains conclusions.

2 Preliminaries

2.0.1 Petri nets.

A Petri net NN is a tuple (P,T,F)(P,T,F) where PP is a finite set of places, TT is a finite set of transitions (PT=P\cap T=\emptyset), and F(P×T)(T×P)F\subseteq(P\times T)\cup(T\times P) is a set of arcs. The preset of xPTx\in P\cup T is x=def{y(y,x)F}{{}^{\bullet}x}\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\left\{y\mid(y,x)\in F\right\} and its postset is x=def{y(x,y)F}{x^{\bullet}}\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\left\{y\mid(x,y)\in F\right\}. We extend the definition of presets and postsets to sets of places and transitions XPTX\subseteq P\cup T by X=defxXx{{}^{\bullet}X}\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\bigcup_{x\in X}{{}^{\bullet}x} and X=defxXx{X^{\bullet}}\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\bigcup_{x\in X}{x^{\bullet}}. A net is acyclic if the relation FF^{*} is a partial order, denoted by \preceq and called the causal order. A node xx of an acyclic net is causally maximal if no node y satisfies xyx\prec y.

A marking of a Petri net is a function M:PM\colon P\to\mathbb{N}, representing the number of tokens in each place. For a set of places SPS\subseteq P, we define M(S)=defpSM(p)M(S)\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\sum_{p\in S}M(p). Further, for a set of places SPS\subseteq P, we define by MSM_{S} the marking with MS(p)=1M_{S}(p)=1 for pSp\in S and MS(p)=0M_{S}(p)=0 for pSp\notin S.

A transition tt is enabled at a marking MM if for all ptp\in{{}^{\bullet}t}, we have M(p)1M(p)\geq 1. If tt is enabled at MM, it may occur, leading to a marking MM^{\prime} obtained by removing one token from each place of t{{}^{\bullet}t} and then adding one token to each place of t{t^{\bullet}}. We denote this by M𝑡MM\xrightarrow{t}M^{\prime}. Let σ=t1t2tn\sigma=t_{1}t_{2}\ldots t_{n} be a sequence of transitions. For a marking M0M_{0}, σ\sigma is an occurrence sequence if M0t1M1t2tnMnM_{0}\xrightarrow{t_{1}}M_{1}\xrightarrow{t_{2}}\ldots\xrightarrow{t_{n}}M_{n} for some markings M1,,MnM_{1},\ldots,M_{n}. We say that MnM_{n} is reachable from M0M_{0} by σ\sigma and denote this by M0𝜎MnM_{0}\xrightarrow{\sigma}M_{n}. The set of all markings reachable from MM in NN by some occurrence sequence σ\sigma is denoted by N(M)\mathcal{R}^{N}\left(M\right). A system is a pair (N,M)(N,M) of a Petri net NN and a marking MM. A system (N,M)(N,M) is live if for every MN(M)M^{\prime}\in\mathcal{R}^{N}\left(M\right) and every transition tt some marking M′′N(M)M^{\prime\prime}\in\mathcal{R}^{N}\left(M^{\prime}\right) enables tt. The system is 1-safe if M(p)1M^{\prime}(p)\leq 1 for every MN(M)M^{\prime}\in\mathcal{R}^{N}\left(M\right) and every place pPp\in P.
Convention: Throughout this paper we assume that systems are 1-safe, i.e., we identify “system” and “1-safe system”.

2.0.2 Net classes.

A net N=(P,T,F)N=(P,T,F) is a marked graph if |p|1|{{}^{\bullet}p}|\leq 1 and |p|1|{p^{\bullet}}|\leq 1 for every place pPp\in P, and a free-choice net if for any two places p1,p2Pp_{1},p_{2}\in P either p1p2={p_{1}^{\bullet}}\cap{p_{2}^{\bullet}}=\emptyset or p1=p2{p_{1}^{\bullet}}={p_{2}^{\bullet}}.

2.0.3 Non-sequential processes of Petri nets.

An (A,B)(A,B)-labeled Petri net is a tuple N=(P,T,F,λ,μ)N=(P,T,F,\lambda,\mu), where λ:PA\lambda\colon P\rightarrow A and μ:TB\mu\colon T\rightarrow B are labeling functions over alphabets A,BA,B. The nonsequential processes of a 1-safe system (N,M)(N,M) are acyclic, (P,T)(P,T)-labeled marked graphs. Say that a set P′′P^{\prime\prime} of places of a (P,T)(P,T)-labeled acyclic net enables tTt\in T if all the places of P′′P^{\prime\prime} are causally maximal, carry pairwise distinct labels, and λ(P′′)=t\lambda(P^{\prime\prime})={{}^{\bullet}t}.

Definition 1

Let N=(P,T,F)N=(P,T,F) be a Petri net and let MM be a marking of NN. The set 𝒩𝒫(N,M){\mathcal{NP}({N,M})} of nonsequential processes of (N,M)(N,M) (processes for short) is the set of (P,T)(P,T)-labeled Petri nets defined inductively as follows:

  • The (P,T)(P,T)-labeled Petri net containing for each place pPp\in P marked at MM one place p^\widehat{p} labeled by pp, no other places, and no transitions, belongs to 𝒩𝒫(N,M){\mathcal{NP}({N,M})}.

  • If Π=(P,T,F,λ,μ)𝒩𝒫(N,M)\Pi=(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu)\in{\mathcal{NP}({N,M})} and P′′PP^{\prime\prime}\subseteq P^{\prime} enables some transition tt of NN, then the (P,T)(P,T)-labeled net Πt=(PP^,T{t^},FF^,λλ^,μμ^)\Pi_{t}=(P^{\prime}\uplus\widehat{P},T^{\prime}\uplus\{\,\widehat{t}\,\},F^{\prime}\uplus\widehat{F},\lambda\uplus\widehat{\lambda},\mu\uplus\widehat{\mu}), where

    • P^={p^pt}\widehat{P}=\{\,\widehat{p}\mid p\in{t^{\bullet}}\}, with λ^(p^)=p\widehat{\lambda}(\,\widehat{p}\,)=p, and μ^(t^)=t\widehat{\mu}(\,\widehat{t}\,)=t;

    • F^={(p′′,t^)p′′P′′}{(t^,p^)p^P^}\widehat{F}=\{(\,p^{\prime\prime},\widehat{t}\,)\mid p^{\prime\prime}\in P^{\prime\prime}\}\cup\{(\,\widehat{t},\widehat{p}\,)\mid\widehat{p}\in\widehat{P}\};

    also belongs to 𝒩𝒫(N,M){\mathcal{NP}({N,M})}. We say that Πt\Pi_{t} extends Π\Pi.

We denote the minimal and maximal places of a process Π\Pi w.r.t. the causal order by min(Π)\min(\Pi) and max(Π)\max(\Pi), respectively.

As usual, we say that two processes are isomorphic if they are the same up to renaming of the places and transitions (notice that we rename only the names of the places and transitions, not their labels).

Fig. 2 shows two processes of the workflow net in Fig. 1(a). (The figure does not show the names of places and transitions, only their labels.) The net containing the white and grey nodes only is already a process, and the grey places are causally maximal places that enable t6t_{6}. Therefore, according to the definition we can extend the process with the green nodes to produce another process. On the right we extend the same process in a different way, with the transition t4t_{4}.

0ii1p1p_{1}1p2p_{2}1p3p_{3}2p4p_{4}1p6p_{6}1p7p_{7}2p8p_{8}t1t_{1}t2t_{2}t3t_{3}t6t_{6}
((a))
0ii1p1p_{1}1p2p_{2}1p3p_{3}2p4p_{4}1p2p_{2}1p7p_{7}2p5p_{5}t1t_{1}t2t_{2}t3t_{3}t4t_{4}
((b))
Figure 2: Nonsequential processes of the net of Fig. 1(a)

The following is well known. Let (P,T,F,λ,μ)(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu) be a process of (N,M)(N,M):

  • For every linearization σ=t1tn\sigma=t_{1}^{\prime}\ldots t_{n}^{\prime} of TT^{\prime} respecting the causal order \preceq, the sequence μ(σ)=μ(t1)μ(tn)\mu(\sigma)=\mu(t_{1}^{\prime})\ldots\mu(t_{n}^{\prime}) is a firing sequence of (N,M)(N,M). Further, all these firing sequences lead to the same marking. We call it the final marking of Π\Pi, and say that Π\Pi leads from MM to its final marking.
    For example, in Fig. 2 the sequences of the right process labeled by t1t2t3t4t_{1}t_{2}t_{3}t_{4} and t1t3t2t4t_{1}t_{3}t_{2}t_{4} are firing sequences leading to the marking M={p2,p5,p7}M=\{p_{2},p_{5},p_{7}\}.

  • For every firing sequence t1tnt_{1}\cdots t_{n} of (N,M)(N,M) there is a process (P,T,F,λ,μ)(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu) such that T={t1,,tn}T^{\prime}=\{t_{1}^{\prime},\ldots,t_{n}^{\prime}\}, μ(ti)=ti\mu(t_{i}^{\prime})=t_{i} for every 1in1\leq i\leq n, and μ(ti)μ(tj)\mu(t_{i}^{\prime})\preceq\mu(t_{j}^{\prime}) implies iji\leq j.

2.0.4 Workflow nets.

We slightly generalize the definition of workflow net as presented in e.g. [1] by allowing multiple initial and final places. A workflow net is a Petri net with two distinguished sets II and OO of input places and output places such that (a) I==O{{}^{\bullet}I}=\emptyset={O^{\bullet}} and (b) for all xPTx\in P\cup T, there exists a path from some iIi\in I to some oOo\in O passing through xx. The markings MIM_{I} and MOM_{O} are called initial and final markings of NN. A workflow net NN is sound if

  • MN(MI):MON(M)\forall M\in\mathcal{R}^{N}\left(M_{I}\right):M_{O}\in\mathcal{R}^{N}\left(M\right),

  • MN(MI):(M(O)|O|)(M=MO)\forall M\in\mathcal{R}^{N}\left(M_{I}\right):(M(O)\geq|O|)\Rightarrow(M=M_{O}), and

  • tT:MN(MI):t\forall t\in T:\exists M\in\mathcal{R}^{N}\left(M_{I}\right):t is enabled at MM.

It is well-known that every sound free-choice workflow net is a 1-safe system with the initial marking MIM_{I} [2, 7]. Given a workflow net according to this definition one can construct another one with one single input place ii and output place oo and two transitions ti,tot_{i},t_{o} with ti={i},ti=I{{}^{\bullet}t_{i}}=\{i\},{t_{i}^{\bullet}}=I and to=O,to={o}{{}^{\bullet}t_{o}}=O,{t_{o}^{\bullet}}=\{o\}. For all purposes of this paper these two workflow nets are equivalent.

Given a workflow net NN, we say that a process Π\Pi of (N,MI)(N,M_{I}) is a run if it leads to MOM_{O}. For example, the net in Fig. 1(b) is a run of the net in Fig. 1(a).

2.0.5 Petri nets with task durations

We consider Petri nets in which, intuitively, when a token arrives in a place pp it has to execute a task taking τ(p)\tau(p) time units before the token can be used to fire any transition. Formally, we consider tuples N=(P,T,F,τ)N=(P,T,F,\tau) where (P,T,F)(P,T,F) is a net and τ:P\tau\colon P\rightarrow\mathbb{N}.

Definition 2

Given a nonsequential process Π=(P,T,F,λ,μ)\Pi=(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu) of (N,M)(N,M), a time bound tt, and a number of resources kk, we say that Π\Pi is executable within time tt with kk resources if there is a function f:Pf\colon P^{\prime}\rightarrow\mathbb{N} such that

  • (1)

    for every p1,p2Pp_{1}^{\prime},p_{2}^{\prime}\in P^{\prime}: if p1p2p_{1}^{\prime}\prec p_{2}^{\prime} then f(p1)+τ(λ(p1))f(p2)f(p_{1}^{\prime})+\tau(\lambda(p_{1}^{\prime}))\leq f(p_{2}^{\prime});

  • (2)

    for every pPp^{\prime}\in P^{\prime}: f(p)+τ(λ(p))tf(p^{\prime})+\tau(\lambda(p^{\prime}))\leq t; and

  • (3)

    for every 0u<t0\leq u<t there are at most kk places pPp^{\prime}\in P^{\prime} such that f(p)u<f(p)+τ(p)f(p^{\prime})\leq u<f(p^{\prime})+\tau(p^{\prime}).

We call a function ff satisfying (1) a schedule, a function satisfying (1) and (2) a tt-schedule, and a function satsifying (1)-(3) a (k,t)(k,t)-schedule of Π\Pi.

Intuitively, f(p)f(p^{\prime}) describes the starting time of the task executed at pp^{\prime}. Condition (1) states that if p1p2p_{1}^{\prime}\preceq p_{2}^{\prime}, then the task associated to p2p_{2}^{\prime} can only start after the task for p1p_{1}^{\prime} has ended; condition (2) states that all tasks are done by time tt, and condition (3) that at any moment in time at most kk tasks are being executed. As an example, the process in Fig. 1(b) can be executed with two resources in time 66 with the schedule i,p1,p20i,p_{1},p_{2}\mapsto 0; p3,p41p_{3},p_{4}\mapsto 1; p7,p63p_{7},p_{6}\mapsto 3, and p8,p94p_{8},p_{9}\mapsto 4.

Given a process Π=(P,T,F,λ,μ)\Pi=(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu) of (N,M)(N,M) we define the schedule fminf_{\min} as follows: if pmin(Π)p^{\prime}\in\min(\Pi) then fmin(p)=0f_{\min}(p^{\prime})=0, otherwise define fmin(p)=max{fmin(p′′)+τ(λ(p′′))p′′p}f_{\min}(p^{\prime})=\max\{f_{\min}(p^{\prime\prime})+\tau(\lambda(p^{\prime\prime}))\mid p^{\prime\prime}\preceq p^{\prime}\}. Further, we define the minimal execution time tmin(Π)=max{f(p)+τ(λ(p′′))pmax(Π)}t_{\min}(\Pi)=\max\{f(p^{\prime})+\tau(\lambda(p^{\prime\prime}))\mid p^{\prime}\in\max(\Pi)\}. In the process in Fig. 1(b), the schedule fminf_{\min} is the function that assigns i,p1,p2,p70i,p_{1},p_{2},p_{7}~\mapsto~0, p3,p41p_{3},p_{4}~\mapsto~1, p6,p83p_{6},p_{8}~\mapsto~3, p94p_{9}~\mapsto~4, and o6o~\mapsto~6, and so tmin(Π)=6t_{\min}(\Pi)=6. We have:

Lemma 1

A process Π=(P,T,F,λ,μ)\Pi=(P^{\prime},T^{\prime},F^{\prime},\lambda,\mu) of (N,M)(N,M) can be executed within time tmin(Π)t_{\min}(\Pi) with |P||P^{\prime}| resources, and cannot be executed faster with any number of resources.

Proof

For k|P|k\geq|P^{\prime}| resources condition (3) of Definition 2 holds vacuously. Π\Pi is executable within time tt iff conditions (1) and (2) hold. Since fminf_{\min} satisfies (1) and (2) for t=tmin(Π)t=t_{\min}(\Pi), Π\Pi can be executed within time tmin(Π)t_{\min}(\Pi). Further, tmin(Π)t_{\min}(\Pi) is the smallest time for which (1) and (2) can hold, and so Π\Pi cannot be executed faster with any number of resources.

3 Resource threshold

We define the resource threshold of a run of a workflow net, and of the net itself. Intuitively, the resource threshold of a run is the minimal number of resources that allows one to execute it as fast as with unlimited resources, and the resource threshold of a workflow net is the minimal number of resources that allows one to execute every run as fast as with unlimited resources.

Definition 3

Let NN be a workflow net, and let Π\Pi be a run of NN. The resource threshold of Π\Pi, denoted by RT(Π)RT({\Pi}) is the smallest number kk such that Π\Pi can be executed in time tmin(Π)t_{\min}(\Pi) with kk resources. A schedule of Π\Pi realizes the resource threshold if it is a (RT(Π),tmin(Π))(RT({\Pi}),t_{\min}(\Pi))-schedule.

The resource threshold of NN, denoted by RT(N)RT({N}), is defined by RT(N)=max{RT(Π)Π is a run of (N,MI)}RT({N})=\max\{RT({\Pi})\mid\Pi\mbox{ is a run of $(N,M_{I})$}\}. A schedule of NN is a function that assigns to every process Π𝒩𝒫(N,M)\Pi\in{\cal NP}(N,M) a schedule of Π\Pi. A schedule of NN is a (k,t)(k,t)-schedule if it assigns to every run Π\Pi a (k,t)(k,t)-schedule of Π\Pi. A schedule of NN realizes the resource threshold if it assigns to every run Π\Pi a (RT(N),tmin(Π))(RT({N}),t_{\min}(\Pi))-schedule.

Example 1

We have seen in the previous section that for the process in Fig. 1(b) we have tmin(Π)=6t_{\min}(\Pi)=6, and a schedule with two resources already achieves this time. So the resource bound is 22. The workflow net of Fig. 1 has infinitely many runs, in which loosely speaking, the net executes t4t_{4} arbitrarily many times, until it “exits the loop” by choosing t6t_{6}, followed by t7t_{7} and t8t_{8}. It can be shown that all processes have resource threshold 22, and so that is also the resource threshold of the net.

In the rest of the section we obtain two negative results about the result threshold. First, it is difficult to compute: Determining if the resource threshold exceeds a given threshold is NP-complete even for acyclic marked graphs, a very simple class of workflows. Second, we show that even for acyclic free-choice workflow nets the resource threshold may not be realized by any online scheduler.

3.1 Resource threshold is NP-complete for acyclic marked graphs

We prove that deciding if the resource threshold exceeds a given bound is NP-complete even for acyclic sound marked graphs. The proof proceeds by reduction from the following classical scheduling problem, proved NP-complete in [17]:

Given: a finite, partially ordered set of jobs with non-negative integer durations, and non-negative integers tt and kk.
Decide: Can all jobs can be executed with kk machines within tt time units in a way that respects the given partial order, i.e., a job is started only after all its predecessors have been finished?

More formally, the problem is defined as follows: Given jobs 𝒥={J1,,Jn}{\cal J}=\{J_{1},\ldots,J_{n}\}, where JiJ_{i} has duration τ(Ji)\tau(J_{i}) for every 1in1\leq i\leq n, and a partial order \preceq on 𝒥{\cal J}, does there exist a function f:𝒥f\colon{\cal J}\rightarrow\mathbb{N} such that

  • (1)

    for every 1i,jn1\leq i,j\leq n: if JiJjJ_{i}\prec J_{j} then f(Ji)+τ(Ji)f(Jj)f(J_{i})+\tau(J_{i})\leq f(J_{j});

  • (2)

    for every 1in1\leq i\leq n: f(Ji)+τ(Ji)tf(J_{i})+\tau(J_{i})\leq t; and

  • (3)

    for every 0u<t0\leq u<t there are at most kk indices ii such that f(Ji)u<f(Ji)+τ(Ji)f(J_{i})\leq u<f(J_{i})+\tau(J_{i}).

These conditions are almost identical to the ones we used to define if a nonsequential process can be executed within time tt with kk resources. We exploit this to construct an acyclic workflow marked graph that “simulates” the scheduling problem. A proof of the following theorem can be found in the Appendix.

Theorem 3.1 ()

The following problem is NP-complete:

Given: An acyclic, sound workflow marked graph NN, and a number kk.
Decide: Does RT(N)kRT({N})\leq k hold?

3.2 Acyclic free-choice workflow nets may have no optimal online schedulers

A resource threshold of kk guarantees that every run can be executed without penalty with kk resources. In other words, there exists a schedule that achieves optimal runtime. However, in many applications the schedule must be determined at runtime, that is, the resources must be allocated without knowing how choices will be resolved in the future. In order to formalize this idea we define the notion of an online schedule of a workflow net NN.

Definition 4

Let NN be a Petri net, and let Π\Pi and Π\Pi^{\prime} be two processes of (N,M)(N,M). We say that Π\Pi is a prefix of Π\Pi^{\prime}, denoted by ΠΠ\Pi\lhd\Pi^{\prime}, if there is a sequence Π1,,Πn\Pi_{1},\ldots,\Pi_{n} of processes such that Π1=Π\Pi_{1}=\Pi, Πn=Π\Pi_{n}=\Pi^{\prime}, and Πi+1\Pi_{i+1} extends Πi\Pi_{i} by one transition for every 1in11\leq i\leq n-1.

Let ff be a schedule of (N,M)(N,M), i.e., a function assigning a schedule to each process. We say that ff is an online schedule if for every two runs Π1,Π2\Pi_{1},\Pi_{2}, and for every two prefixes Π1Π1\Pi_{1}^{\prime}\lhd\Pi_{1} and Π2Π2\Pi_{2}^{\prime}\lhd\Pi_{2}: If Π1\Pi_{1}^{\prime} and Π2\Pi_{2}^{\prime} are isomorphic, then f(Π1)=f(Π2)f(\Pi_{1}^{\prime})=f(\Pi_{2}^{\prime}).

Intuitively, if Π1\Pi_{1}^{\prime} and Π2\Pi_{2}^{\prime} are isomorphic then they are the same process Π\Pi, which in the future can be extended to either Π1\Pi_{1} or Π2\Pi_{2}, depending on which transitions occur. In an online schedule, Π\Pi is scheduled in the same way, independently of whether it will become Π1\Pi_{1} or Π2\Pi_{2} in the future. We show that even for acyclic free-choice workflow nets there may be no online schedule that realizes the resource threshold. That is, even though for every run it is possible to schedule the tasks with RT(N)RT({N}) resources to achieve optimal runtime, this requires knowing how it will evolve before the execution of the workflow.

Proposition 1

There is an acyclic, sound free-choice workflow net for which no online schedule realizes the resource threshold.

Proof

Consider the sound free-choice workflow net (N,MI)(N,M_{I}) of Fig. 3.

0ii1p1p_{1}1p2p_{2}2p3p_{3}5p4p_{4}3p5p_{5}2p6p_{6}2p7p_{7}2p8p_{8}0p9p_{9}0oot1t_{1}t2t_{2}t3t_{3}t4t_{4}t5t_{5}t6t_{6}t7t_{7}
Figure 3: A workflow net with two runs. No online scheduler for three resources achieves the minimal runtime in both runs.

It has two runs: Πg\Pi_{g}, which executes the grey and green transitions, and Πr\Pi_{r}, which executes the grey and red transitions. Their resource thresholds are RT(Πg)=RT(Πr)=3RT({\Pi_{g}})=RT({\Pi_{r}})=3, realized by the following schedules fgf_{g} and frf_{r} in Fig. 4:

01122334455resource 1p4p_{4}resource 2p3p_{3}p5p_{5}resource 3p1p_{1}p2p_{2}p8p_{8}01122334455p4p_{4}p1p_{1}p3p_{3}p6p_{6}p2p_{2}p8p_{8}p7p_{7}
Figure 4: Schedules fgf_{g} and frf_{r} for the two runs Πg\Pi_{g} and Πr\Pi_{r} of the net of Fig. 3.

Indeed, observe that fgf_{g} and frf_{r} execute Πg\Pi_{g} and Πr\Pi_{r} within time 55, and even with unlimited resources no schedule can be faster because of the task p4p_{4}, while two or fewer resources are insufficient to execute either run within time 55.

The schedule of (N,MI)(N,M_{I}) that assigns fgf_{g} and frf_{r} to Πg\Pi_{g} and Πr\Pi_{r} is not an online schedule. Indeed, the process containing one single transition labeled by t1t_{1} and places labeled by i,p1,p2,p3i,p_{1},p_{2},p_{3} is isomorphic to prefixes of Πg\Pi_{g} and Πr\Pi_{r}. However, we have fg(p3)=01=fr(p3)f_{g}(p_{3})=0\neq 1=f_{r}(p_{3}). We now claim:

  • (a)

    Every schedule fgf_{g} of Πg\Pi_{g} that realizes the resource threshold (time 55 with 3 resources) satisfies fg(p3)=0f_{g}(p_{3})=0.
    Indeed, if fg(p3)1f_{g}(p_{3})\geq 1, then fg(p5)3f_{g}(p_{5})\geq 3, fg(p9)6f_{g}(p_{9})\geq 6, and finally fg(o)6f_{g}(o)\geq 6, so fgf_{g} does not meet the time bound.

  • (b)

    Every schedule frf_{r} of Πr\Pi_{r} that realizes the resource threshold (time 55 with 3 resources) satisfies fr(p3)>0f_{r}(p_{3})>0.
    Observe first that we necessarily have fr(p4)=0f_{r}(p_{4})=0, and so a resource, say R1R_{1}, is bound to p4p_{4} during the complete execution of the workflow, leaving two resources left. Assume fr(p3)=0f_{r}(p_{3})=0, i.e., a second resource, say R2R_{2}, is bound to p3p_{3} at time 0, leaving one resource left, say R3R_{3}. Since both p1p_{1} and p2p_{2} must be executed before p8p_{8}, and only R3R_{3} is free until time 22, we get fr(p8)2f_{r}(p_{8})\geq 2. So at time 22 we still have to execute p6,p7,p8p_{6},p_{7},p_{8} with resources R2,R3R_{2},R_{3}. Therefore, two out of p6,p7,p8p_{6},p_{7},p_{8} must be executed sequentially by the same resource. Since p6,p7,p8p_{6},p_{7},p_{8} take 22 time units each, one of the two resources needs time 44, and we get fr(o)6f_{r}(o)\geq 6.

By this claim, at time 0, an online schedule has to decide whether to allocate a resource to p3p_{3} or not, without knowing which of t3t_{3} or t4t_{4} will be executed in the future. If it schedules f(p3)=0f(p_{3})=0 and later t4t_{4} occurs, then Πr\Pi_{r} is executed and the deadline of 5 time units is not met. The same occurs if it schedules f(p3)>0f(p_{3})>0, and later t3t_{3} occurs.

4 Concurrency threshold

Due to the two negative results presented in the previous section, we study a different parameter, introduced in [4], called the concurrency threshold. During execution of a business process, information on the resolution of future choices is often not available, and further no information on the possible duration of a task (or only weak bounds) are known. Therefore, the scheduling is performed in practice by assigning a resource to a task at the moment some resource becomes available. The question is: What is the minimal number of resources needed to guarantee the optimal execution time achievable with an unlimited number of resources?

The answer is simple: since there is no information about the duration of tasks, every reachable marking of the workflow net without durations may be also reached for some assignment of durations. Let MM be a reachable marking with a maximal number of tokens, say kk, in places with positive duration, and let d1d2dkd_{1}\leq d_{2}\leq\cdots\leq d_{k} be the durations of their associated tasks. If less than kk resources are available, and we do not assign a resource to the task with duration dkd_{k}, we introduce a delay with respect to the case of an unlimited number of resources. On the contrary, if the number of available resources is kk, then the scheduler for kk resources can always simulate the behaviour of the scheduler for an unlimited number of resources.

Definition 5

Let N=(P,T,F,I,O,τ)N=(P,T,F,I,O,\tau) be a workflow Petri net. For every marking MM of NN, define the concurrency of MM as conc(M)=defpDM(p){\mathrm{conc}({M})}\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\sum_{p\in D}M(p), where DPD\subseteq P is the set of places pPp\in P such that τ(p)>0\tau(p)>0. The concurrency threshold of NN is defined by

CT(N)=defmax{conc(M)MN(M)}.\displaystyle CT({N})\stackrel{{\scriptstyle\scriptscriptstyle\text{def}}}{{=}}\max\left\{{\mathrm{conc}({M})}\mid M\in\mathcal{R}^{N}\left(M\right)\right\}.

The following lemma follows easily from the definitions.

Lemma 2

For every workflow net NN: RT(N)CT(N)RT({N})\leq CT({N}).

Proof

Follows immediately from the fact that for every schedule ff of a run of NN, there is a schedule gg with CT(N)CT({N}) machines such that g(p)f(p)g(p)\leq f(p) for every place pp.

In the rest of the paper we study the complexity of computing the concurrency threshold. In [4], it was shown that the threshold can be computed in polynomial time for regular workflows, a class with a very specific structure, and the problem for the general free-choice case was left open. In Section 4.1 we prove that the concurrency threshold of marked graphs can be computed in polynomial time by reduction to a linear programming problem over the rational numbers. In Section 4.2 we study the free-choice case. We show that deciding if the threshold exceeds a given value is NP-complete for acyclic, sound free-choice workflow nets. Further, it can be computed by solving the same linear programming problem as in the case of marked graphs, but over the integers. Finally, we show that in the cyclic case the problem remains NP-complete, but the integer linear programming problem does not necessarily yield the correct solution.

4.1 Concurrency threshold of marked graphs

The concurrency threshold of marked graphs can be computed using a standard technique based on the marking equation [15]. Given a net N=(P,T,F)N=(P,T,F), define the incidence matrix of NN as the |P|×|T|\left|P\right|\times\left|T\right| matrix N\vec{N} given by:

N(p,t)={1 if ptt1 if ptt0 otherwise\vec{N}(p,t)=\left\{\begin{array}[]{rl}1&\mbox{ if $p\in{t^{\bullet}}\setminus{{}^{\bullet}t}$}\\ -1&\mbox{ if $p\in{{}^{\bullet}t}\setminus{t^{\bullet}}$}\\ 0&\mbox{ otherwise}\end{array}\right.

In the following, we denote by M\vec{M} the representation of a marking MM as a vector of dimension |P|\left|P\right|. Let NN be a Petri net, and let M1,M2M_{1},M_{2} be markings of NN. The following results are well known from the literature (see e.g. [15]):

  • If M2M_{2} is reachable from M1M_{1} in NN, then M2=M1+NX\vec{M_{2}}=\vec{M_{1}}+\vec{N}\cdot\vec{X} for some integer vector X0\vec{X}\geq 0.

  • If NN is a marked graph and M2=M1+NX\vec{M_{2}}=\vec{M_{1}}+\vec{N}\cdot\vec{X} for some rational vector X0\vec{X}\geq 0, then M2M_{2} is reachable from M1M_{1} in NN.

  • If NN is acyclic and M2=M1+NX\vec{M_{2}}=\vec{M_{1}}+\vec{N}\cdot\vec{X} for some integer vector X0\vec{X}\geq 0, then M2M_{2} is reachable from M1M_{1} in NN.

Given a workfkow net N=(P,T,F,I,O,τ)N=(P,T,F,I,O,\tau), let D:P\vec{D}\colon P\mapsto\mathbb{N} be the vector defined by D(p)=1\vec{D}(p)=1 if pDp\in D and D(p)=0\vec{D}(p)=0 if pDp\notin D, where DD is the set of places with positive duration. We define the linear optimization problem

N=max{DMM=MI+NX,M0,X0}\displaystyle\ell^{N}=\max\left\{\vec{D}\cdot\vec{M}\mid\vec{M}=\vec{M_{I}}+\vec{N}\cdot\vec{X},\vec{M}\geq 0,\vec{X}\geq 0\right\} (1)

Since the solutions of M=MI+NX\vec{M}=\vec{M_{I}}+\vec{N}\cdot\vec{X} contain all the reachable markings of (N,MI)(N,M_{I}), we have NCT(N)\ell^{N}\geq CT({N}). Further, using these results above, we obtain:

Theorem 4.1

Let NN be a workflow net, and let N\ell^{N}_{\mathbb{Q}} and N\ell^{N}_{\mathbb{Z}} be the solution of the linear optimization problem (1) over the rationals and over the integers, respectively. We have:

  • NNCT(N)\ell^{N}_{\mathbb{Q}}\geq\ell^{N}_{\mathbb{Z}}\geq CT({N});

  • If NN is a marked graph, then ==CT(N)\ell_{\mathbb{Q}}=\ell_{\mathbb{Z}}=CT({N}).

  • If NN is acyclic, then =CT(N)\ell_{\mathbb{Q}}\geq\ell_{\mathbb{Z}}=CT({N}).

In particular, it follows that CT(N)CT({N}) can be computed in polynomial time for marked graphs, acyclic or not. (The result about acyclic nets is used in the next section.)

4.2 Concurrency threshold of free-choice nets

We study the complexity of computing the concurrency threshold of free-choice workflow nets. We first show that, contrary to numerous other properties for which there are polynomial algorithms, deciding if the concurrency threshold exceeds a given value is NP-complete.

Theorem 4.2 ()

The following problem is NP-complete:

Given: A sound, free-choice workflow net N=(P,T,F,I,O)N=(P,T,F,I,O), and a number k|T|k\leq|T|.
Decide: Is the concurrency threshold of NN at least kk?

Proof

A detailed proof can be found in the appendix, here we only sketch the argument. Membership in NP is nontrivial, and follows from results of [1, 7]. We prove NP-hardness by means of a reduction from Maximum Independent Set (MIS):

Given: An undirected graph G=(V,E)G=(V,E), and a number k|V|k\leq|V|.
Decide: Is there a set 𝐼𝑛V{\it In}\subseteq V such that |𝐼𝑛|k\left|{\it In}\right|\geq k and {v,u}E\left\{v,u\right\}\notin E for every u,v𝐼𝑛u,v\in{\it In}{}?

Given a graph G=(V,E)G=(V,E), we construct a sound free-choice workflow net NGN_{G} in polynomial time as follows:

  • For each e={v,u}Ee=\{v,u\}\in E we add to NGN_{G} the “gadget net” NeN_{e} shown in Fig. 5(a), and for every node vv we add the gadget net NvN_{v} shown in Fig. 5(b).

  • For every e={v,u}Ee=\{v,u\}\in E, we add an arc from the place [e,v]4[e,v]^{4} of NeN_{e} to the transition v1v^{1} of NvN_{v}, and from [e,u]4[e,u]^{4} to the transition u1u^{1} of NuN_{u}.

  • The set II of initial places contains the place e0e^{0} of NeN_{e} for every edge ee; the set OO of output places contains the places v2v^{2} of the nets NvN_{v}.

0e0e^{0}2[e,v]2[e,v]^{2}2[e,u]2[e,u]^{2}0[e,v]4[e,v]^{4}0[e,u]4[e,u]^{4}[e,v]1[e,v]^{1}[e,u]1[e,u]^{1}[e,v]3[e,v]^{3}[e,u]3[e,u]^{3}
((a)) Net NeN_{e}
1v2v^{2}v1v^{1}
((b)) Net NvN_{v}
Figure 5: Gadgets for the proof of Theorem 4.2.

It is easy to see that NGN_{G} is free-choice and sound, and in the Appendix we show the result of applying the reduction to a small graph and prove that GG has an independent set of size at least kk iff the concurrency threshold of (NG,MI)(N_{G},M_{I}) is at least 2|E|+k2|E|+k. The intuition is that for each edge eEe\in E, we fire the transition [e,u]1[e,u]^{1} where u𝐼𝑛u\notin{\it In}{}, and for each v𝐼𝑛v\in{\it In}{}, we fire the transition v1v^{1}, thus marking one of [e,u]2[e,u]^{2} or [e,v]2[e,v]^{2} for each edge eEe\in E and the place v2v^{2} for each v𝐼𝑛v\in{\it In}{}.

4.3 Approximating the concurrency threshold

Recall that the solution of problem (1) over the rationals or the integers is always an upper bound on the concurrency threshold for any Petri net (Theorem 4.1). The question is whether any stronger result holds when the workflows are sound and free-choice. Since computing the concurrency threshold is NP-complete, we cannot expect the solution over the rationals, which is computable in polynomial time, to provide the exact value. However, it could still be the case that the solution over the integers is always exact. Unfortunately, this is not true, and we can prove the following results:

Theorem 4.3

Given a Petri net NN, let N\ell^{N}_{\mathbb{Q}} and N\ell^{N}_{\mathbb{Z}} be as in Theorem 4.1.

  • (a)

    There is an acyclic sound free-choice workflow net NN such that CT(N)<NCT({N})<\ell^{N}_{\mathbb{Q}}.

  • (b)

    There is a sound free-choice workflow net NN such that and let CT(N)<NCT({N})<\ell^{N}_{\mathbb{Z}}.

Proof

For (a), we can take the net obtained by adding to the gadget in Fig. 5(a) a new transition with input places [e,v]4[e,v]^{4} and [e,u]4[e,u]^{4}, and an output place oo with weight 22. We take e0e^{0} as input place. The concurrency threshold is clearly 22, reached, for example, after firing [e,v]1[e,v]^{1}. However, we have N=3\ell^{N}_{\mathbb{Q}}=3, reached by the rational solution X=(1/2,1/2,,1/2)\vec{X}=(1/2,1/2,\ldots,1/2). Indeed, the marking equation then yields the marking MM satisfying M([e,v]2)=M([e,u]2)=M(o)=1/2M([e,v]^{2})=M([e,u]^{2})=M(o)=1/2.

For (b), we can take the workflow net of Fig. 6. It is easy to see that the concurrency threshold is equal to 11. The marking M\vec{M} that puts one token in each of the two places with weight 11, and no token in the rest of the places, is not reachable from MIM_{I}. However, it is a solution of the marking equation, even when solved over the integers. Indeed, we have M=MI+NX\vec{M}=\vec{M_{I}}+\vec{N}\cdot\vec{X} for X=(1,0,1,1,0,0,1)\vec{X}=(1,0,1,1,0,0,1). Therefore, the upper bound derived from the marking equation is 22.

0ii011000oot1t_{1}t2t_{2}t3t_{3}t4t_{4}t5t_{5}t6t_{6}t7t_{7}
Figure 6: A sound free-choice workflow net for which the linear programming problem derived from the marking equation does not yield the exact value of the concurrency bound, even when solved over the integers.

5 Concurrency threshold: a practical approach

We have implemented a tool111The tool is available from https://gitlab.lrz.de/i7/macaw. to compute an upper bound on the concurrency threshold by constructing a linear program and solving it by calling the mixed-integer linear programming solver Cbc from the COIN-OR project [14]. Additionally, fixing a number kk, we used the state-of-the art Petri net model checker LoLA [18] to both establish a lower bound, by querying LoLA for existence of a reachable marking MM with conc(M)k{\mathrm{conc}({M})}\geq k; and to establish an upper bound, by querying LoLA if all reachable markings MM^{\prime} satisfy conc(M)k{\mathrm{conc}({M^{\prime}})}\leq k.

We evaluated the tool on a set of 1386 workflow nets extracted from a collection of five libraries of industrial business processes modeled in the IBM WebSphere Business Modeler [9]. For the concurrency threshold, we set D=POD=P\setminus O. These nets also have multiple output places, however with a slightly different semantics for soundness allowing unmarked output places in the final marking. We applied the transformation described in [12] to ensure all output places will be marked in the final marking. This transformation preserves soundness and the concurrency threshold.

All of the 1386 nets in the benchmark libraries are free-choice nets. We selected the sound nets among them, which are 642. Out of those 642 nets, 409 are marked graphs. Out of the remaining 233 nets, 193 are acyclic and 40 cyclic. We determined the exact concurrency threshold of all sound nets with LoLA using state-space exploration. Fig. 7 shows the distribution of the threshold.

050501001001501502002002502501234567891011121314152026293366Number of netsConcurrency threshold802161311171726972231445121221
Figure 7: Distribution of the concurrency threshold of the 642 nets analyzed.

On all 642 sound nets, we computed an upper bound on the concurrency threshold using our tool, both using rational and integer variables. We computed lower and upper bounds using LoLA with the value k=CT(N)k=CT({N}) of the concurrency threshold. We report the results for computing the lower and upper bound separately.

All experiments were performed on the same machine equipped with an Intel Core i7-6700K CPU and 32 GB of RAM. The results are shown in Table 1. Using the linear program, we were able to compute an upper bound for all nets in total in less than 7 seconds, taking at most 30 milliseconds for any single net. LoLA could compute the lower bound for all nets in 6 seconds. LoLA fails to compute the upper bound in three cases due to reaching the memory limit of 32 GB. For the remaining 639 nets, LoLA could compute the upper bound within 7 minutes in total.

We give a detailed analysis for the 9 nets with a state space of over one million. For three nets with state space of sizes 10910^{9}, 101010^{10} and 101710^{17}, LoLa reaches the memory limit. For four nets with state spaces between 10610^{6} and 10810^{8} and concurrency threshold above 25, LoLA takes 2, 10, 48 and 308 seconds each. For two nets with a state space of 10810^{8} and a concurrency threshold of just 11, LoLA can establish the upper bound in at most 20 milliseconds. The solution of the linear program can be computed in all 9 cases in less than 30 milliseconds.

Net size Analysis time (sec)
|P|\left|P\right| |T|\left|T\right| |N|\left|\mathcal{R}^{N}\right| CT(N)CT({N}) N\ell^{N}_{\mathbb{Q}} N\ell^{N}_{\mathbb{Z}} CT(N)kCT({N})\geq k CT(N)kCT({N})\leq k
Median 21 14 161000\ \,\cdot 10^{00} 3 0.01 0.01 0.01 0.01
Mean 28.4 18.6 310143\cdot 10^{14} 3.7 0.01 0.01 0.01 0.58*
Max 262 284 210172\cdot 10^{17} 66 0.03 0.03 1.18 307.76*
Table 1: Statistics on the size and analyis time for the 642 nets analyzed. The times marked with * exclude the 3 nets where LoLA reaches the memory limit.

Comparing the values of the upper bound, first we observed that we obtained the same value using either rational or integer variables. The time difference between both was however negligible. Second, quite surprisingly, we noticed that the upper bound obtained from the linear program is exact in all of our cases, even for the cyclic ones. Further, it can be computed much faster in several cases than the upper bound obtained by LoLA and it gives a bound in all cases, even when the state-space exploration reaches its limit. By combining linear programming for the upper bound and state-space exploration for the lower bound, an exact bound can always be computed within a few seconds.

6 Conclusion

Planning sufficient execution resources for a business or production process is a crucial part of process engineering [13, 3, 19]. We considered a simple version of this problem in which resources are uniform and tasks are not interruptible. We studied the complexity of computing the resource threshold, i.e., the minimal number of resources allowing an optimal makespan. We showed that deciding if the resource threshold exceeds a given bound is NP-hard even for acyclic marked graphs. For this reason, we investigated the complexity of computing the concurrency threshold, an upper bound of the resource threshold introduced in [4]. Solving a problem left open in [4], we showed that deciding if the concurrency threshold exceeds a given bound is NP-hard for general sound free-choice workflow nets. We then presented a polynomial-time approximation algorithm, and showed experimentally that it computes the exact value of the concurrency threshold for all benchmarks of a standard suite of free-choice workflow nets.

References

  • [1] van der Aalst, W.M.P.: Verification of workflow nets. In: Application and Theory of Petri Nets 1997, 18th International Conference, ICATPN ’97, Toulouse, France, June 23-27, 1997, Proceedings. pp. 407–426 (1997)
  • [2] van der Aalst, W.M.P.: Workflow verification: Finding control-flow errors using petri-net-based techniques. In: Business Process Management, Models, Techniques, and Empirical Studies. pp. 161–183 (2000)
  • [3] Bessai, K., Youcef, S., Oulamara, A., Godart, C., Nurcan, S.: Resources allocation and scheduling approaches for business process applications in cloud contexts. In: 4th IEEE International Conference on Cloud Computing Technology and Science Proceedings, CloudCom 2012, Taipei, Taiwan, December 3-6, 2012. pp. 496–503 (2012)
  • [4] Botezatu, M., Völzer, H., Thiele, L.: The complexity of deadline analysis for workflow graphs with multiple resources. In: Business Process Management - 14th International Conference, BPM 2016, Rio de Janeiro, Brazil, September 18-22, 2016. Proceedings. pp. 252–268 (2016)
  • [5] Chuzhoy, J., Codenotti, P.: Resource minimization job scheduling. In: Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, 12th International Workshop, APPROX 2009, and 13th International Workshop, RANDOM 2009, Berkeley, CA, USA, August 21-23, 2009. Proceedings. pp. 70–83 (2009)
  • [6] Chuzhoy, J., Guha, S., Khanna, S., Naor, J.: Machine minimization for scheduling jobs with interval constraints. In: 45th Symposium on Foundations of Computer Science (FOCS 2004), 17-19 October 2004, Rome, Italy, Proceedings. pp. 81–90 (2004)
  • [7] Desel, J., Esparza, J.: Free choice Petri nets. Cambridge University Press (1995)
  • [8] Esparza, J., Hoffmann, P., Saha, R.: Polynomial analysis algorithms for free choice probabilistic workflow nets. In: Quantitative Evaluation of Systems - 13th International Conference, QEST 2016, Quebec City, QC, Canada, August 23-25, 2016, Proceedings. pp. 89–104 (2016)
  • [9] Fahland, D., Favre, C., Jobstmann, B., Koehler, J., Lohmann, N., Völzer, H., Wolf, K.: Instantaneous soundness checking of industrial business process models. In: Business Process Management, 7th International Conference, BPM 2009, Ulm, Germany, September 8-10, 2009. Proceedings. pp. 278–293 (2009)
  • [10] Favre, C., Fahland, D., Völzer, H.: The relationship between workflow graphs and free-choice workflow nets. Inf. Syst. 47, 197–219 (2015)
  • [11] Hall, N.G., Sriskandarajah, C.: A survey of machine scheduling problems with blocking and no-wait in process. Operations Research 44(3), 510–525 (1996)
  • [12] Kiepuszewski, B., ter Hofstede, A.H.M., van der Aalst, W.M.P.: Fundamentals of control flow in workflows. Acta Inf. 39(3), 143–209 (2003)
  • [13] Liu, L., Zhang, M., Lin, Y., Qin, L.: A survey on workflow management and scheduling in cloud computing. In: 14th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing, CCGrid 2014, Chicago, IL, USA, May 26-29, 2014. pp. 837–846 (2014)
  • [14] Lougee-Heimer, R.: The common optimization interface for operations research: Promoting open-source software in the operations research community. IBM Journal of Research and Development 47(1), 57–66 (2003)
  • [15] Murata, T.: Petri nets: Properties, analysis, and applications. Proceedings of the IEEE 77(4), 541–576 (1989)
  • [16] Pinedo, M.L.: Scheduling: Theory, Algorithms, and Systems. Springer International Publishing (2016)
  • [17] Ullman, J.: NP-complete scheduling problems. Journal of Computer and System Sciences 10(3), 384–393 (1975)
  • [18] Wolf, K.: Generating petri net state spaces. In: Petri Nets and Other Models of Concurrency - ICATPN 2007, 28th International Conference on Applications and Theory of Petri Nets and Other Models of Concurrency, ICATPN 2007, Siedlce, Poland, June 25-29, 2007, Proceedings. pp. 29–42 (2007)
  • [19] Xu, J., Liu, C., Zhao, X.: Resource allocation vs. business process improvement: How they impact on each other. In: Business Process Management, 6th International Conference, BPM 2008, Milan, Italy, September 2-4, 2008. Proceedings. pp. 228–243 (2008)

Appendix

See 3.1

Proof

Since NN is acyclic, every transition can occur at most once in a firing sequence. Further, since NN is a sound marked graph, it has exactly one run, which is isomorphic to NN (This follows immediately from the fact that nonsequential processes are sound marked graphs themselves). Therefore, in order to decide if RT(N)kRT({N})\leq k holds in nondeterministic polynomial time, we just guess the starting time f(p)f(p) of every place pp of NN, and check that it satisfies conditions (1)-(3) in the definition of resource threshold.

To prove NP-hardness, let J1,,JnJ_{1},\ldots,J_{n}, τ\tau, t>0t>0, and kk be an instance of the scheduling problem above. We construct an acyclic workflow marked graph N=(P,T,F,τ)N=(P,T,F,\tau^{\prime}) and a number kk^{\prime} such that RT(N)kRT({N})\leq k^{\prime} iff the jobs can be executed in time tt with kk machines. The procedure for the construction of NN is as follows:

  • Add input and output places pI,pOp_{I},p_{O}, transitions tI,tOt_{I},t_{O}, arcs (pI,tI),(tO,pO)(p_{I},t_{I}),(t_{O},p_{O}).

  • For every job JiJ_{i} minimal w.r.t. \preceq: add a place pip_{i}, a transition tit_{i}^{\prime}, and arcs (tI,pi),(pi,ti)(t_{I},p_{i}),(p_{i},t_{i}^{\prime}).

  • For every job JiJ_{i} maximal w.r.t. \preceq: add a place pip_{i}, a transition tit_{i}, and an arc (ti,pi),(pi,tO)(t_{i},p_{i}),(p_{i},t_{O}).

  • For every other job JiJ_{i} add a place pip_{i}, transitions ti,tit_{i},t_{i}^{\prime}, and arcs (ti,pi),(pi,ti)(t_{i},p_{i}),(p_{i},t_{i}^{\prime}).

  • For every pair JiJjJ_{i}\preceq J_{j}, add a place pi,jp_{i,j} and arcs (ti,pi,j),(pi,j,tj)(t_{i}^{\prime},p_{i,j}),(p_{i,j},t_{j}).

  • Set τ(pi)=τ(Ji)\tau^{\prime}(p_{i})=\tau(J_{i}) for every place pip_{i} and τ(p)=0\tau^{\prime}(p^{\prime})=0 for every other place pp^{\prime}.

Let NN be the net constructed so far. Now test if tmin(N)tt_{\min}(N)\leq t. If tmin(N)>tt_{\min}(N)>t, then there is no execution of J1,,JnJ_{1},\ldots,J_{n} in time tt with any amount of machines, so we force a negative answer (e.g. by setting k=0k^{\prime}=0). Otherwise, we add a place ptp_{t} and two arcs (tI,pt),(pt,tO)(t_{I},p_{t}),(p_{t},t_{O}) and set τ(pt)=t\tau^{\prime}(p_{t})=t. Then tmin(N)=tt_{\min}(N)=t and we set k=k+1k^{\prime}=k+1. By the definition of NN, we have that J1,,JnJ_{1},\ldots,J_{n} can be executed in time tt with kk machines iff NN can be executed in time tt with k=k+1k^{\prime}=k+1 resources.

See 4.2

Proof

Let N=(P,T,F,I,O)N=(P,T,F,I,O) be a sound free-choice workflow net. It is well known that the system (N¯,MI)(\overline{N},M_{I}), where N¯\overline{N} is the result of adding to NN a new transition t¯\overline{t} with preset OO and postset II is live and bounded (This is shown in [1] for workflow nets with one input and one output place, and the same proof can be used in the general case as well.) In particular, every firing sequence σt¯\sigma\overline{t} of (N¯,MI)(\overline{N},M_{I}) leads back to the initial marking MIM_{I}, since otherwise it would lead to a marking MMIM^{\prime}\geq M_{I} such that MMIM^{\prime}\neq M_{I}, and so (N¯,MI)(\overline{N},M_{I}) would not be bounded. It follows that every reachable marking of (N¯,MI)(\overline{N},M_{I}) is reachable by means of a firing sequence that does not contain t¯\overline{t}, and so in particular (N,MI)(N,M_{I}) and (N¯,MI)(\overline{N},M_{I}) have the same concurrency threshold.

Let MmaxM_{\max} be a marking witnessing the concurrency threshold of (N¯,MI)(\overline{N},M_{I}). By the Shortest Sequence Theorem [7], there exists a firing sequence MI𝜎MmaxM_{I}\xrightarrow{\sigma}M_{\max} such that |σ|n(n+1)(n+2)/6|\sigma|\leq n(n+1)(n+2)/6, where n=|T|n=|T|. Therefore, the nondeterministic algorithm that guesses a firing sequence of length at most n(n+1)(n+2)/6n(n+1)(n+2)/6 steps, and halts if the current marking has at least kk tokens in the places of DD, runs in polynomial time.

We prove NP-hardness by means of a reduction from Maximum Independent Set (MIS):

Given: An undirected graph G=(V,E)G=(V,E), and a number k|V|k\leq|V|.
Decide: Is there a set 𝐼𝑛V{\it In}\subseteq V such that |𝐼𝑛|k\left|{\it In}\right|\geq k and {v,u}E\left\{v,u\right\}\notin E for every u,v𝐼𝑛u,v\in{\it In}{}?

We illustrate the reduction on the instance of MIS shown in Fig. 9(a), where {v1,v4,v5}\{v_{1},v_{4},v_{5}\} is a maximum independent set. Fig. 9(b) shows the result of the reduction. Here we represent the set DD by weights of places as for the equation (1). We use the weight 22 for a place pp as a compact representation of two places with weight 1 each and the same pre- and postset as pp.

Given a graph G=(V,E)G=(V,E), we construct a sound free-choice workflow net NGN_{G} in polynomial time as follows:

  • For each e={v,u}Ee=\{v,u\}\in E we add to NGN_{G} the “gadget net” NeN_{e} shown in Fig. 8(a), and for every node vv we add the gadget net NvN_{v} shown in Fig. 8(b).

  • For every e={v,u}Ee=\{v,u\}\in E, we add an arc from the place [e,v]4[e,v]^{4} of NeN_{e} to the transition v1v^{1} of NvN_{v}, and from [e,u]4[e,u]^{4} to the transition u1u^{1} of NuN_{u} (see Fig. 9(b)).

  • The set II of initial places contains the place e0e^{0} of NeN_{e} for every edge ee; the set OO of output places contains the places v2v^{2} of the nets NvN_{v}.

0e0e^{0}2[e,v]2[e,v]^{2}2[e,u]2[e,u]^{2}0[e,v]4[e,v]^{4}0[e,u]4[e,u]^{4}[e,v]1[e,v]^{1}[e,u]1[e,u]^{1}[e,v]3[e,v]^{3}[e,u]3[e,u]^{3}
((a)) Net NeN_{e}
1v2v^{2}v1v^{1}
((b)) Net NvN_{v}
Figure 8: Gadgets for the proof of Theorem 4.2.
v1v_{1}v2v_{2}v3v_{3}v4v_{4}v5v_{5}
((a)) Graph GG
0{v1,v2}\left\{v_{1},v_{2}\right\}22000{v1,v3}\left\{v_{1},v_{3}\right\}22000{v2,v3}\left\{v_{2},v_{3}\right\}22000{v2,v4}\left\{v_{2},v_{4}\right\}22000{v2,v5}\left\{v_{2},v_{5}\right\}22001v1v_{1}1v2v_{2}1v3v_{3}1v4v_{4}1v5v_{5}
((b)) Workflow net NGN_{G}
Figure 9: A graph and its corresponding workflow net. A maximum independent set and a marking achieving the concurrency threshold are highlighted in green.

It is easy to see that NGN_{G} is free-choice and sound. For the latter, observe that after firing either [e,v]1[e,v]^{1} and [e,v]3[e,v]^{3}, or [e,u]1[e,u]^{1} and [e,u]3[e,u]^{3}, for every edge eEe\in E, the same marking is reached, namely the one putting a token on all the places of the form [x,y]4[x,y]^{4}. From this marking we can then fire all the vi1v_{i}^{1} transitions to reach the final marking.

We claim that GG has an independent set of size at least kk iff the concurrency threshold of (NG,MI)(N_{G},M_{I}) is at least 2|E|+k2|E|+k.

For the first part, assume GG has an independent set 𝐼𝑛V{\it In}\subseteq V. For every eEe\in E let vev_{e} be a vertex of ee that does not belong to 𝐼𝑛{\it In}{}. Fire the transition [e,ve]1[e,v_{e}]^{1}. Let MM be the marking so reached. Since 𝐼𝑛{\it In}{} is an independent set, we have M([e,v]4)=1M([e,v]^{4})=1 for every v𝐼𝑛v\in{\it In}{} and for every edge ee containing vv. So MM enables v1v^{1} for every v𝐼𝑛v\in{\it In}{}. Fire transition v1v^{1} of NvN_{v} for every v𝐼𝑛v\in{\it In}{}, reaching the marking MM^{\prime}. We then have M([e,ve]2)=1M^{\prime}([e,v_{e}]^{2})=1 for every eEe\in E, and M(v2)=1M^{\prime}(v^{2})=1 for every v𝐼𝑛v\in{\it In}{}. So the concurrency threshold of MM^{\prime} is at least 2|E|+|𝐼𝑛|2|E|+k2|E|+|{\it In}{}|\geq 2|E|+k.

For the second part, assume that the concurrency threshold of (NG,MI)(N_{G},M_{I}) is at least 2|E|+k2|E|+k. This can only be achieved by a marking MM marking exactly one of [e,u]2[e,u]^{2} or [e,v]2[e,v]^{2} for every e={u,v}Ee=\left\{u,v\right\}\in E, and additionally marking at least kk of the places v2v^{2}. We claim that 𝐼𝑛={vVM(v2)=1}{\it In}=\left\{v\in V\mid M(v^{2})=1\right\} is an independent set. Indeed, in a sequence reaching MM, for every e={v,u}Ee=\{v,u\}\in E only one of [e,v]4[e,v]^{4} or [e,u]4[e,u]^{4} can become marked, but not both; so no occurrence sequence leading to MM contains both v1v^{1} and u1u^{1}, and so MM does not mark both v2v^{2} and u2u^{2}. So GG has an independent set of size at least kk.