Parallel computation of reachable dead states in a free-choicePetri NetCitation for published version (APA):Aalst, van der, W. M. P. (1996). Parallel computation of reachable dead states in a free-choice Petri Net.(Computing science reports; Vol. 9603). Technische Universiteit Eindhoven.

Document status and date:Published: 01/01/1996

Document Version:Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)

Please check the document version of this publication:

• A submitted manuscript is the version of the article upon submission and before peer-review. There can beimportant differences between the submitted version and the official published version of record. Peopleinterested in the research are advised to contact the author for the final version of the publication, or visit theDOI to the publisher's website.• The final author version and the galley proof are versions of the publication after peer review.• The final published version features the final layout of the paper including the volume, issue and pagenumbers.Link to publication

General rightsCopyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright ownersand it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights.

• Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain • You may freely distribute the URL identifying the publication in the public portal.

If the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, pleasefollow below link for the End User Agreement:www.tue.nl/taverne

Take down policyIf you believe that this document breaches copyright please contact us at:openaccess@tue.nlproviding details and we will investigate your claim.

Download date: 19. Oct. 2020

Eindhoven University of Technology Department of Mathematics and Computing Science

Parallel Computation of Reachable Dead States in a Free-choice Petri Net

ISSN 0926-4515

All rights reserved editors: prof.dr. RC. Backhouse

prof.dr. J.C.M. Baeten

Reports are available at: http://www.win.tue.nl/win/cs

by

W.M.P. van der Aalst

Computing Science Report 96/03 Eindhoven, March 1996

96/03

Parallel Computation of Reachable Dead States in a Free-choice Petri Net W.M.P. van der Aalst Department of Mathematics and Computing Science, Eindhoven University of Technology, P.O. Box 513,5600 MB, Eindhoven, The Netherlands, telephone: -31402474295, e-mail: wsinwa@win.tue.nl

Abstract. Free-choice Petri nets are a prominent tool for modeling and analyzing commu­nication protocols, multiprocessor systems, parallel programs, flexible manufacturing sys­tems and workflow scripts. Unfortunately, analysis is often hampered by the state-explosion phenomenon. Even for free-choice Petri nets, the reachability problem is known to be EXPSPACE-hard. In this paper we discuss a technique for the parallel computation of the reachable dead states. This technique is based on the partitioning of tokens instead of the Petri net.

Keywords: Petri nets; Parallel algorithms, Free-choice Petri nets; Analysis of Petri nets.

1 Introduction

Petri nets are used by both theoreticians and practitioners. From a theoretical point of view, Petri nets provide a formal model for concurrency with many elegant math­ematical properties. From a practical point of view, Petri nets are a graphical, easy to use, technique for the modeling of systems. A very important feature of Petri nets is the fact that the Petri net representation can be used as a starting point for various kinds of analysis. The construction of the coverability graph is a well-know tool for the analysis of Petri nets. Inherently difficult problems can be tackled with this tool. Unfortunately, algorithms for constructing the coverability graph require a lot of computing power. For many Petri nets, it is not possible to construct the coverability graph in reasonable time on sequential computers. Consequently, the use of parallelism to speed up the construction of the coverability graph could be attractive.

In this paper we focus on the analysis of dead states infree-choice Petri nets. Free­choice Petri nets are a very interesting class of Petri nets for which strong theoret­ical results and efficient analysis techniques exist. A state s is dead if no transi­tions are enabled in s, i.e. nothing can happen in state s. From an analysis point

1

of view, dead states are very important. Consider for example the situation shown in Figure I. A production process can be represented by a free-choice Petri net. The process transforms raw materials into end-products. Given an initial state, it is interesting to know the set of dead states reachable from the initial state. Based on the set of reachable dead states, we are able to establish the correctness of the production process. If we model an administrative procedure in terms of a free­choice Petri net, then the set of dead states reachable from some initial state con­tains important information with regards to the correctness of the administrative procedure. At the moment, the construction of the coverability graph is the obvi­ous way to determine the set of reachable dead states. Even for free-choice Petri nets the construction of the coverability graph may be intractable. Therefore, an effective parallel construction of the coverability graph to obtain dead states is de­sirable.

production process

Figure I: A production process modeled in terms of a free-choice Petri net.

In the context of Generalized Stochastic Petri nets, some attempts have been made to construct the Tangible Resource Set (TRS) in parallel. In Caselli, Conte, Bonardi & Fontanesi (1994) and Caselli, Conte & Marenzoni (1995) both SIMD and MIMD programming models are considered for the parallel construction the TRS. In our opinion, these approaches can also be used for the construction of the coverability graph. For an MIMD programming model, the master-slave paradigm is the obvi­ous approach to construct the coverability graph in parallel. The master manages the set of nodes in the coverability graph computed so far and distributes new nodes over the slaves. The slaves compute new nodes, which are returned to the master. One of the starting points for such a straightforward approach, is the assumption that nodes (i.e. reachable states) are indivisible.

In this paper we present an approach which is entirely different. The reachable

2

states represented by the nodes in the coverability graph are no longer atomic, i.e. the calculation of a new state may be distributed among several processors. We are able to use this approach by exploiting the structure the free-choice Petri net. In fact, we have 'discovered' a new property with respect to the dynamics of free­choice Petri nets. Based on this property we have developed two algorithms for the parallel computation of dead states. The algorithms are named TIGRA-I and TIGRA-ll. Compared to the traditional approach (i.e. the construction of the cov­erability graph on a single processor), these algorithms allow for superlinear speed­ups!

The remainder of this paper is organized as follows. In Section 2 we introduce some of the basic notations for free-choice Petri nets. Section 3 deals with the construction of the coverability graph to obtain all dead states. In Section 4 we present the State-split theorem. This theorem serves as the basis for the two algo­rithms presented in Section 5 and 6. To illustrate the usefulness of our approach, an example is presented in Section 7.

2 Free-choice Petri nets

Historically speaking, Petri nets originate from the early work of Carl Adam Petri (1962). Since then the use and study of Petri nets has increased considerably. For a review of the history of Petri nets and an extensive bibliography the reader is referred to Murata (1989).

The classical Petri net is a directed bipartite graph with two node types called places and transitions. The nodes are connected via directed arcs. Connections between two nodes of the same type are not allowed. Places are represented by circles and transitions by rectangles.

Definition 1 (Petri net) A Petri net is a triplet (P, T, F);

P is a finite set of places,

- T is a finite set of transitions ( P n T = 0),

F C; (P x T) U (T x P) is a set of arcs (flow relation)

A place p is called an input place of a transition t iff there exists a directed arc from p to t. Place p is called an output place of transition t iff there exists a directed arc

3

from t to p. We use .t to denote the set of input places for a transition t. The nota­tions t., .p and p. have similar meanings, e.g. p. is the set of transitions sharing p as an input place.

Places may contain zero or more tokens, drawn as black dots. The state, often re­ferred to as marking, is the distribution of tokens over places. We will represent a state as follows: IPI + 2P2 + Ip3 + Op4 is the state with one token in place PI, two tokens in P2, one token in P3 and no tokens in P4. We can also represent this state as follows: PI + 2P2 + P3.

The number of tokens may change during the execution of the net. Transitions are the active components in a Petri net: they change the state of the net according to the following firing rule:

(1) A transition t is said to be enabled iff each input place P of t contains at least one token.

(2) An enabled transition may fire. If transition t fires, then t consumes one to­ken from each input place p of t and produces one token for each output place P oft.

Given a Petri net (P, T, F) and an initial state M1, we have the following notations:

- Ml ..!. M 2: transition t is enabled in state Ml and firing t in Ml results in state M2

- Ml ---+ M 2: there is a transition t such that Ml ..!. M2

- Ml -4 Mn: the firing sequence 0' = tlt2t3 ... tn-l leads from state Ml to

M . M" M" 'n-' M state n, I.e. 1 ~ 2 -+ ... -+ n

- Ml ~ Mn: there is a firing sequence which leads from Ml to Mn

A state Mn is called reachable from Ml (notation Ml ~ Mn) iff there is a firing

M " M" 'n-' M sequence 0' = t 1t2 ... tn- 1 such that 1 ---+ 2 ---+ ... ---+ n'

Let 0' = tl t2 ... tn be a firing sequence of length n. For k such that 1 :5 k :5 n, we have the following notations:

- O'(k) = tk

4

A state M is a dead state iff no transition is enabled in M. For a state M and a place P. we use M (p) to denote the number of tokens in p in state M. For two states M andN. M:::; N iff for each place p: M(p):::; N(p).

Let us define some properties.

Definition 2 (Conservative) A Petri net P N is conservative iff there is a positive integer w(p) for every place p such that, given an arbitrary initial state M, the weighted sum of tokens is constantfor every reachable state M'.

Definition 3 (Live) A Petri net (P N, M) is live iff, for every reachable state M' and every transition t, there is a state Mil reachable from M' which enables t.

Definition 4 (Bounded) A Petri net (P N, M) is bounded iff, for every reachable state and every place p the number of tokens in p is bounded.

Definition 5 (Strongly connected) A Petri net is strongly connected iff, for every two places (transitions) x and y, there is a directed path leading from x to y.

In this paper we focus on a restricted class of Petri nets. The results presented in this paper apply to Petri nets satisfying the so-called free-choice property.

Definition 6 (Free-choice) A Petri net is a free-choice Petri net iff, for every two places Pl and P2 either (Pl • n P2.) = 0 or Pl. = P2.'

Figure 2 shows two Petri nets. Petri net (a) is a free-choice Petri net. Petri net (b) is not a free-choice Petri net. since t2 and t3 share the input place p2 and t3 is the only output transition of p3.

~O-----t p2

(a)

r:l ~Ph ~--~

(b)

Figure 2: Petri net (a) is a free-choice Petri net. (b) is not a free-choice Petri net.

Free-choice Petri nets have been studied extensively (Best. 1987; Desel & Esparza. 1995; Desel. 1992; Esparza. 1990; Hack. 1972) because they seem to be a good

5

compromise between expressive power and analyzability. It is a class of Petri nets for which strong theoretical results and efficient analysis techniques exist. One of the fundamental properties of a free-choice Petri net is the fact that it can be partitioned into clusters.

Definition 7 (Cluster) Let t be a transition in afree-choice Petri net. The cluster of t, denoted by [t], is the set.t U {t' E T I • t' = .t}. The cluster of a place p, also denoted by [P], is the set p. U {p' E P I (p'. n p. l =I 0}.

Note that a place p and a transition t belong to the same cluster (i.e. [P] = [tD iff p E .t. For free-choice Petri nets, we have the following property. If transition t is enabled, then any transition in [t] is enabled. A cluster c is called enabled iff the transitions in c are enabled.

3 Computing dead states

For bounded Petri nets it is possible to construct the so-called reachability graph. This graph contains a node for each state reachable from the initial state. 1\'10 nodes in the reachability graph M and N are connected by a directed arc if and only if there is a transition enabled in M whose firing results in state N. If we are able to construct the reachability graph, then it is easy to find all dead states reachable from the initial state. A node in the reachability graph corresponds to a reachable dead state if and only if it has no outgoing arcs. Unfortunately, it is not possible to use the reachability graph for an unbounded Petri net. If we try to construct the reachability graph for an unbounded net, then this graph will grow infinitely large. This is the reason we resort to the use of the so-called coverability graph. For any Petri net having an arbitrary initial state, the corresponding coverability graph is finite. To obtain the coverability graph, the symbol w is introduced. This symbol can be thought of as 'infinity' and for any integer n the following properties hold: w > n, w + n = w, w - n = wand w :::: w. The coverability graph for a Petri net (P N, Mol is constructed by the following algorithm.

Coverability graph algorithm

(1) Introduce the initial state Mo as the root node and label it "new".

(2) If there are no "new" nodes, then go to step (7). Otherwise select a state M which corresponds to a "new" node.

(3) If M is identical to a state on the path from the root node Mo to M, then label M "old" and return to step (2).

6

(4) If no transitions are enabled in state M, then label this state "dead" and return to step (2).

(5) For each transition t enabled in state M do the following:

(5.1) Obtain the state M' that results from firing t in state M.

(5.2) If there is a state Mil on the path from the root node Mo to M such that M'(p) ~ M"(p) for each place p and Mil i'M', then replace M'(p) by w for each p such that M'(p) > M"(p).

(5.2) Introduce M' as a new node, and draw an arc with label t from M to M'. Node M' is labeled "new".

(6) Remove the "new" label of M and return to step (2).

(7) Fuse all nodes which correspond to identical states, i.e. the nodes labeled "old" are removed. In the resulting coverability graph all nodes are distinct.

For a more detailed description of the algorithm to construct the coverability graph the reader is referred to Peterson (1981) or Murata (1989). Figure 3 shows two coverability graphs for the Petri nets shown in Figure 2. These graphs are obtained by the application of the algorithm we have just described.

2p2 )

(a)

T T ~ + ( 0) p3 )

(b)

Figure 3: Two coverability graphs for the Petri nets shown in Figure 2.

The coverability graph can be used for the study of various properties. A Petri net

7

(P N, Mo) is bounded if and only if the symbol w does not appear in corresponding coverability graph. Moreover, if a state M is reachable from Mo, then there exists a node M' such that M ~ M'. The coverability graph can also be used to find dead states. If the coverability graph contains a node with no outgoing arcs, then this node corresponds to one or more dead states. Coverability graph (a) shown in Figure 3 indicates that the corresponding Petri net shown in Figure 2 has one dead state: 2p2 (i.e. the state with two tokens in place p2). Unfortunately, some information may be lost by the use of the symbol w. A node containing the symbol w represents infinitely many states. Consider for example coverability graph (b) shown in Figure 3. The node wp3 with no outgoing arcs indicates that there are infinitely many states of the form kp3 (i.e. states with only tokens in place p3). In this case k may be any natural number. However, in general the symbol w may represent only even or odd numbers, or only numbers of at least some threshold value n. Nevertheless, we can use the coverability graph for finding all dead states if the number of dead states is bounded. If not, we can only find a characterization of the dead states. In the remainder of this paper we will focus on free-choice Petri nets with a finite number of dead states. However, the algorithms presented in the remaining sections can be used to generate as many dead states as desired.

In addition to the drawback that some information is lost, there is another draw­back associated with the use of the coverability graph. The construction of the coverability graph is an exhaustive analysis method which tends to require at lot of computing power and storage memory. For complex Petri-net models the con­struction of the coverability graph may be very time consuming. The complexity of the algorithm to construct the coverability graph can be worse than primitive re­cursive space. Even for free-choice Petri nets the reachability problem is known to be EXPSPACE-hard (Cheng, Esparza & Palsberg, 1993). Moreover, even for bounded free-choice Petri nets the problem of finding all dead states is NP-hard. Therefore, it is interesting to investigate whether a parallel computer can be used to find all dead states in a free-choice Petri net. In the remainder of this paper we present two parallel algorithms for the calculation of dead states in free-choice Petri net. These algorithms exploit the structure of a free-choice Petri net. We will show that in most situations a significant speedup is possible. Even if we execute these algorithms on a single processor, a significant speedup (compared to the stan­dard algorithm for the construction of the coverability graph) is possible.

8

4 State-split theorem

The two parallel algorithms for the calculation of dead states presented in this pa­per exploit the structure of a free-choice Petri net. For this purpose we present a new result for free-choice Petri nets. This result is embedded in a theorem called the State-split theorem. This theorem shows that it is possible to distribute the con­struction of the coverability graph of a free-choice Petri net if we are only interested in the reachable dead states. The State-split theorem is the core of this paper. We need this theorem to prove the correctness of the parallel algorithms presented in this paper. In order to prove the State-split theorem we need some preliminary re­sults.

The first preliminary result we present is the Advance lemma. This lemma shows that given a firing sequence it is possible to advance the firing of certain transitions.

Lemma 1 (Advance lemma) Let a = tl t z ... tk be a firing sequence of a free­choice Petri net such that a leads from state M to state M I, i.e. M ~ MI. If a cluster c is enabled in state M and ti is the first transition in a such that ti E c, , then M ~ MI with a' = titItZ'" ti-Iti+! ... tk.

Proof. In state M each of the transitions in c is enabled, i.e. ti is enabled in state M. The transitions t j with 1 :::; j < i are not disabled by the advanced firing of ti, because they belong to different clusters. Therefore, the firing sequence a' = titItZ'" ti-Iti+I ... tk is possible. Since a' is a permutation of a, we deduce that

M~M'. 0

We use the Advance lemma to prove the Substate-ordering lemma. The Substate­ordering lemma captures the essence of the State-split theorem. The Substate-orde­ring lemma is illustrated in Figure 4.

N

N'

M

", ~M::(~:r{I)J , , - M'

Figure 4: The Substate-ordering lemma.

9

Lemma 2 (Substate-ordering lemma) Let P N be afree-choice Petri net and N and N' states of P N such that N ~ N' and N' is dead. For any substate M of N (i.e. M ~ N), there is a dead state M' such that M ~ M' and M' + (N - M) ~ N'.

Proof. Let (T = tl t2 ... tk be an arbitrary firing sequence leading from N to N' (N ~ N'). We use induction upon the length k of (T.

If k = 0, then N = N'. Since N is dead (N = N') and M ::; N, M is also dead. Hence, M' = M is a dead state such that M ~ M' and M' + (N - M) ~ N'. Assume k > O. If M is dead, then for M' = M the lemma holds. Therefore, we may assume that M is not dead. Let ti be the first transition in (T which is enabled in M, i.e. ti is enabled in M and for alii ~ j < i: tj is not enabled in M. Note that such a transition exists, because M ~ N, M is not dead and N' is dead. The cluster [til is enabled in N and ti is the first transition in (T which belongs to [td.

We can use lemma 1 to prove that N ~ N' with (T' = titIt2'" ti_Iti+! ... tk. t· t·

Let NI and MI be states such that N -4 NI and M -4 MI. By the induction hypothesis we can show that there is a dead state M' such that MI ~ M' and M' + (NI - MI) ~ N'. By the definition of NI and MI we conclude that M ~ M' andM'+(N-M)~N'. 0

We use the Substate-ordering lemma to prove the State-split theorem illustrated in Figure 5.

Theorem 1 (State-split theorem) Let PN = (P, T, F) be afree-choice Petri net and let M and and M' be two states such that M ~ M' and M' is dead. If we split M up in n substates MI, M2, ... Mn (i.e. M = MI + M2 + ... + Mn), then there exist n dead states M{ , M~, ... M~ such that for any i (1 ::; i ~ n) Mi ~ M[ and M{ + M~ + ... M~ ~ M'.

Proof. LetMI, M2, ... Mn,M and M' be states of PN suchthatM = M I+M2+ ... +Mn and M ~ M'. We need to prove that there exist n dead states M{, M~, ... M~ such that for any i (1 ::; i ~ n) Mi ~ M; and M{ + M~ + ... M~ ~ M'.

Since (MI +M2+ ... Mn-I)+Mn ~ M', we can use Lemma 2 to deduce that there isadeadstateM~suchthatMn ~ M~andM~ + (MI +M2+' .. Mn_l ) ~ M'. lfn > 1, then we can repeat this step. Since (M~ + MI + M2 + ... Mn- 2) + M n - I ~ M', we can use Lemma 2 to deduce that there is a dead state M~_I such

that Mn- I ~ M~_I and M~_I + (M~ + MI + M2 + ... Mn - 2) ~ M'. This process can be repeated until all Mi have been removed, i.e. there are dead states

10

M'

Figure 5: The State-split theorem.

M{,M~, ... M~suchthatforanyi(1 ~ i ~ n)Mi ~ M' • M' ... n---+ •

M: and M{ + M~ + o

The State-split theorem shows that any firing sequence which leads to a dead state, can be composed of n + 1 firing sequences which are relatively independent. In fact the first n firing sequences can be calculated in parallel. This property is used to define two parallel algorithms for the calculation of dead states.

To conclude this section we focus attention on the following lemma which holds for any Petri net.

Lemma 3 Let M be the initial state of a Petri net P N = (P, T, F). Ifwe split M up in n substates M" M2, ... Mn (i.e. M = M, + M2 + ... + Mn), then any state M' = M{ + M~ + ... M~ such that for any i (1 ~ i ~ n) Mi ~ M: is reachable from M (i.e. M ~ M').

Lemma 3 is a well-known result, therefore the proof of this lemma has been omited.

11

5 Parallel computation of dead states (1)

In Section 3 we showed that the coverability graph can be used to characterize all reachable dead states. If the number of dead states is finite, then is is possible to construct a coverability graph which contains all reachable dead states. Unfortu­nately, only for small or very simple Petri nets the construction of the coverability graph is feasible. Based on these observations, we started a quest for a parallel algorithm to speed up the generation of dead states.

If we observe the coverability graph algorithm described in Section 3, then a sim­ple parallel algorithm which uses a workpool containing nodes which should be examined seem to be the obvious choice. In Caselli, Conte & Marenzoni (1995) multiple workpools are used, i.e. each processor generates a private set of reach­able states and periodic synchronization points are used to distribute the union of all known reachable states. It is also possible to use a single workpool by adopting the master-slave paradigm. The master manages a pool containing nodes which need to be examined. These nodes are distributed over slaves, which return new nodes to the master. In both cases nodes or states are indivisible, i.e. elements in a workpool correspond to complete nodes or states instead of parts of nodes or states.

We propose less straightforward approach which exploits the property recorded in the State-split theorem. Nodes in the coverability graph are no longer indivisible, i.e. multiple processors may be working on the calculation of parts of a state. In fact, we propose an approach where tokens instead of states are distributed over the processors.

The first parallel algorithm, named TIGRA, is quite simple. Given a parallel sys­tem with n processors and an initial state M, the tokens in M are partitioned over n substates M I , M2 , ••• Mn. Each of the processors stores one of these substates in its private memory, i.e. there is a one-to-one correspondence between the pro­cessors and the substates MI , M2 , ••• Mn. For each of the substates a coverability graph is constructed and the set of dead states reachable from the corresponding substate is recorded. This can be done in parallel, without any need for intermedi­ate synchronization. When each of the processors has completed the construction of the local set of dead states, all possible combinations of dead states are stored in a workpool. The states in the workpool are distributed over the processors. For each state one of the processors calculates the set of reachable dead states. The pro­gram terminates when all states in the workpool have been evaluated. The TIGRA algorithm can be sketched as follows.

12

TIGRA Algorithm

(1) Partition the set of tokens in state Minto n states Ml , M 2, ... Mn, i.e. M =

Ml + M2 + ... + Mn:

M l ,M2, ... ,Mn <- PARTITION(M)

(2) For each processor i compute the set of dead states D Si reachable from state M i :

DSi <- CONSTRUCT ..DEAD~TATES(M;)

(The set DSi contains all dead states ME reachable from Mi.)

(3) Construct the set of states S which contains all possible combinations of dead states, i.e. S = {M{ + M~ + ... + M~ I for all i : ME E DS;}:

S <- CONSTRUCT .ALLCOMBINATIONS(M{, M~, ... M~)

(4) Compute the set of dead states D S reachable from any state in S.

DS <- CONSTRUCT..DEAD~TATES(S)

(The states in the set S are distributed over the processors.)

The correctness of the TIORA algorithm can easily be verified using the State-split theorem.

Theorem 2 Let PN = (P, T, F) be afree-choice Petri net and let M be the initial state. The set DS constructed using the TIGRA algorithm contains all dead states reachable from state M.

Proof. Let MI be an arbitrary dead state reachable from the initial state M. We have to prove that MI is an element of DS. The first step of the TIORA algorithm partitions state Minto M 1 , M 2 , ••• Mn such that M = Ml + M2 + ... + Mn. By Theorem 1 we know that there exist n dead states M{, M~, ... M~ such that for any i (1 ~ i ~ n) M; -4 ME and M{ + M~ + ... M~ -4 MI. These dead states are computed in the second step of the algorithm. In the third step all possible states of the form M{ + M~ + ... M~ are constructed. In the fourth step all dead states reachable from these constructed states are calculated including state MI. 0

13

5.1 Performance of the TIGRA algorithm

It is difficult to evaluate the performance of the TIORA algorithm. First of all, the performance of the algorithm highly depends on the partitioning in step (1) of the algorithm. Secondly, the size of the Petri net is not a good measure for the size of the corresponding coverability graph. Even for moderate size Petri nets, the cov­erability graph may be very large. On the other hand, there are large Petri nets for which the coverability graph is surprisingly small. In other words the structure of the Petri net and the initial state may influence the size of the corresponding cover­ability graph dramatically. Finally, we are faced with the problem that the 'best' se­quential algorithm for the computation of reachable dead states is not known. This makes it difficult to determine the speedup of the TIORA algorithm. Nevertheless, we can make some statements about the performance of the TIORA algorithm.

Let us assume that we have a free-choice Petri net PN and an initial state M such that the number of reachable dead states is finite. Moreover, we assume that the number of nodes in the corresponding coverability graph is equal to T. T is a good measure for the time required to construct the coverability graph. Therefore, we define T to be the time required to find all dead states using the traditional approach on a single processor system. For the free-choice Petri net PN with the initial state M we define T~ to be the sum of the number of nodes of the coverability graphs constructed in step (2) and step (4) ofthe TIORA algorithm. The time required to process step (3) is proportional to the time required to process step (2) and step (4). Moreover, the time required to process step (3) is small compared to the time required to process step (2) and step (4). Therefore, T~ is a good measure for the time required to compute all reach­able dead states on a single processor system using the TIORA algorithm. In other words T~ is a measure for the processing time if we emulate n processors on a sin­gle processor system using the TIORA algorithm. Finally, we define Tn to be the maximum number of nodes in one of the coverabil­ity graphs constructed in step (2) plus the maximum number of nodes handled by one of the n processors in step (4) of the, TIORA algorithm. Clearly, Tn is a rea­sonable measure for the time required to compute all reachable dead states using the TIORA algorithm on an MIMD system with n processors.

Since the 'best' sequential algorithm is unknown, it is difficult to define a speedup measure to evaluate the improvement in time performance of the TIORA algorithm on a system with n processors compared to single processor system. Therefore we define two speedup measures. The first speedup measure Sn compares the perfor­mance of the TIORA algorithm on a system with n processors with the standard

14

technique based on one coverability graph:

T Sn=-

Tn

The second speedup measure S~ compares the performance of the TIORA algo­rithm on a system with n processors with the performance of the TIORA algorithm on a single processor system:

S' = T~ n Tn

We will use both speedup measures to characterize the time performance of the TIORA algorithm. If we use the measure Sn a superlinear speedup (i.e. Sn > n) is possible. This is a result of the fact that we compare two alternative algorithms. We also define two measures for the efficiency of the TIORA algorithm. The first measure of efficiency is based on Sn:

We can also define an efficiency measure based on S~:

E' = T~ n nTn

To show the potential of the TIORA-algorithm, we will analyze the Petri net shown in Figure 6. The number of tokens in place i is variable and equal to the number of processors n. In step (1) of the TIORA algorithm each token is assigned to a private processor. The size of the coverability graph for the Petri net shown in Fig­ure 6 highly depends in the initial number of tokens in place i. If place i contains just one token, then the corresponding coverability graph contains only 9 nodes. If place i contains just 10 token, then the corresponding coverability graph contains 24815 nodes. Table 1 shows some results for the Petri net shown in Figure 6. If the number of processors is equal to 8 and we start with 8 tokens in place i, then the speedup Sn is equal to 1027.10, i.e. the TIORA algorithm is more than 1000 times as fast as the conventual algorithm based on the construction of one cover­ability graph. This example shows that a superlinear speedup is possible if we use the measure Sn. If we use the measure S~ the speedup is linear, i.e. the speedup is equal to the number of processors.

The Petri net shown in Figure 6 is just an example of a 'problem instance'. It is difficult to estimate the speedup for an arbitrary problem instance. Nevertheless, the following lemma holds.

15

.. - .... --n tokens

p4

17

Figure 6: A free-choice Petri net with n tokens in place i.

n T Tn Sn En S' n E' n

I 9 9 1.00 1.00 1.00 1.00 2 45 9 5.00 2.50 2.00 1.00 3 159 9 17.67 5.89 3.00 1.00 4 450 9 50.00 12.50 4.00 1.00 5 1090 9 121.11 24.22 5.00 1.00 6 2354 9 261.55 43.59 6.00 1.00 7 4654 9 517.11 73.87 7.00 1.00 8 8579 9 1027.10 128.39 8.00 1.00 9 14939 9 1659.89 184.43 9.00 1.00

10 24815 9 2757.22 275.72 10.00 1.00

Table 1: Some results for the Petri net shown in Figure 6.

16

Lemma 4 For the TIGRA algorithm the following relation holds: Tn ::; T.

Proof. By Lemma 3 we know that any state generated in step (2) or step (4) of the TIGRA algorithm, is also present in the standard coverability graph. 0

Lemma 4 shows that 1 ::; Sn, i.e. the effect of the TIGRA algorithm is never nega­tive if we abstract from overhead. By the definitions of S~ and Sn we also deduce that S~ ::; n and S~ ::; Sn. For practical situations: T~ ::; T. This means that in practise even for a single processor system the TIGRA algorithm turns to be fruit­ful.

10 tokens

o

Figure 7: Place p7 constraints the degree of parallelism.

Let us consider another example where the degree of inherent parallelism can be parameterized. Figure 7 shows a free-choice Petri net. In the initial state there are 10 tokens in place i and k tokens in place p7. Note that k is a good measure for the degree of parallelism in the Petri net. If k = 1, then the tokens in i are processed sequentially. If k = 10, then all of the tokens in i may be processed in parallel. The number of available processors is n. Table 2 shows the speedup of the TIGRA

17

algorithm compared to the traditional technique to calculate dead states. Table 3 shows the normalized speedup S~. These tables show that the degree of inherent parallelism is an important factor. The TIGRA algorithm performs very good if there is a lot of potential parallelism in the free-choice Petri net.

Sn k-I 2 3 4 5 6 7 .8 9 n=l 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0

2 1.0 9.7 6.5 14.8 10.2 17.1 16.2 22.2 20.1 3 1.0 9.7 35.1 19.7 37.8 63.5 43.2 59.3 74.2 4 1.0 9.7 35.1 105.0 56.4 94.9 143.2 196.5 137.7 5 1.0 9.7 35.1 105.0 295.5 187.6 283.2 388.6 486.4 6 1.0 9.7 35.1 105.0 295.5 496.7 283.2 388.6 486.4 7 1.0 9.7 35.1 105.0 295.5 496.7 749.8 388.6 486.4 8 1.0 9.7 35.1 105.0 295.5 496.7 749.8 1028.8 486.4 9 1.0 9.7 35.1 105.0 295.5 496.7 749.8 1028.8 1287.6

10 1.0 9.7 35.1 105.0 295.5 496.7 749.8 1028.8 1287.6

Table 2: The speedup Sn for the Petri net shown in Figure 7.

Sf n k=1 2 3 4 5 6 7 8 9 10

n=l 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 2 1.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 2.0 3 1.0 2.0 3.0 3.0 3.0 3.0 3.0 3.0 3.0 3.0 4 1.0 2.0 3.0 4.0 4.0 4.0 4.0 4.0 4.0 4.0 5 1.0 2.0 3.0 4.0 5.0 5.0 5.0 5.0 5.0 5.0 6 1.0 2.0 3.0 4.0 5.0 6.0 6.0 6.0 6.0 6.0 7 1.0 2.0 3.0 4.0 5.0 6.0 7.0 7.0 7.0 7.0 8 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 8.0 8.0 9 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 9.0

10 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0

Table 3: The speedup S~ for the Petri net shown in Figure 7.

The performance ofTIGRA algorithm depends on the distribution oftokens in step (1) of the algorithm. In the examples presented in this section we have distributed the tokens evenly over the available processors. In general this seems to be a good heuristic. The assignment of a specific token to a processor can be randomized or handled manually. In both cases, we hope to balance the workload over the pro­cessors.

18

10 1.0

22.8 55.1

156.1 551.4 551.4 551.4 551.4 551.4

2757.2

6 Parallel computation of dead states (2)

The effectiveness of the TIORA algorithm is highly dependent on the degree of inherent parallelism of the Petri net in the initial state. Moreover, an unfortunate distribution of token in step (1) may result in an unsatisfactory speedup. To make the TIORA algorithm more robust, we propose a number of refinements resulting in the TIORA-II algorithm.

Suppose we have a parallel system composed of n = 2k (logical) processors. In the first step the tokens in the initial state M are partitioned over n substates M" M 2 , •••

, Mn. Each of the processors stores one of these substates in its private memory. For each of the substates a coverability graph is constructed and the set of dead states reachable from the corresponding substate is recorded. Then for each pair of processors, all possible combinations of dead states are stored in a workpool, i.e. there are n/2 workpools. For each of the workpools the states in the workpool are distributed over tJ"te two processors whose results have been used to fill the workpool. These processors calculate the dead states reachable from the states in the workpool. Then for every pair of workpools (i.e. 2+2 processors) all pos­sible combinations of dead states are stored in a new workpool. For each of the new workpools the states in the workpool are distributed over the four processors whose results have been used to fill the workpool. These processors calculate the dead states reachable from the states in the workpool. This is repeated until there is just one workpool. The dead states reachable from the states in this workpool correspond to the dead states reachable from the initial state M. The TIORA-II algorithm can be sketched as follows. .

TIGRA-II Algorithm

(l) Partition the set of tokens in state Minto n states M" M 2 , ••• Mn, set the variable I and for each i (1 :S i :S n) construct the singleton Sf containing M i :

M" M 2 , ••• ,Mn <- PARTITION(M) 1<- k Sf <- {M;} for all i : 1 :S i :S n goto step (3)

(2) Lower I by 1 and for each i : 1 :S i :S 2' calculate the set Sf which is com­posed of all possible combinations of two sets of dead states (DS;;!, and DS;;') using the processors that where used to calculate these two sets of dead states (i.e. {p I (i - 1)2k-

1 + 1 :S p:S i2k- I }):

19

/+-/-1 Si +- CONSTRUCT..ALLCOMBINATIONS(DS~t21,DSW)

for all i : 1 :::; i :::; 21 on processor(s) {p I (i - 1 )2k- 1 + 1 :::; p :::; i2k- l }

(3) For each set sl constructed in the preceding step, calculate the set of dead states DS! using the set of processors {p I (i - 1)2k-1 + 1 :::; p:::; i2k- I }:

DSl +- CONSTRUCT..DEAD.3TATES(Sf) for all i : 1 :::; i :::; 21 on processor(s) {p I (i - 1 )2k- 1 + 1 :::; P :::; i2k- l }

(4) If I is equal to 0, then the algorithm terminates and the set D S~ contains all reachable dead states. Otherwise, go to step (2).

ifl?,l then goto step (2) else DS +- DS~

fi

1 2

S3 , S3 2

3 4 5 6 7 8

S3 3

S3 4

S3 5

S3 6

S3 7

S3 8

DS3 , DS3 2

DS3 3 DS3

4 DS3

5 DS3

6 DS3

7 DS3

8

SZ ~ " ~ S2 'I , , , ,

DS2 , , DS2 2

DS2 I 3

DS2 ,4 , , ,

, S' ,

S' , , , ,

" ... ~ , , , ,

DS' , , DS' , 2 , , ,

~ , , , , , , , , , ,

DSO , , , , , , , , , , , ,

step (1)

step (3)

step(2)

step (3)

step(2)

step (3)

step(2)

step (3)

Figure 8: The TIGRA-II algorithm for k = 3.

20

Figure 8 illustrates the TIGRA-II algorithm for k = 3. In this case the number of processors is equal to 8 (n = 8). In step (1) the tokens are distributed over these processors. Then step (3) is executed. The results of step (3) are consolidated into 4 workpools (S;, Si, Sj and SD by executing step (2). Then step (3) is executed using 8 processors divided into 4 groups. This is repeated until there is just one group of processors working on one central workpool (Sr). To prove the correctness of the TIGRA-II algorithm we also need the State-split theorem.

Theorem 3 Let PN = (P, T, F) be afree-choice Petri net and let M be the ini­tial state. The set DS constructed using the TIGRA-/l algorithm contains all dead states reachable from state M.

Proof. We use induction in I to prove that for any I : 0 ::; I ::; k and any i : 1 ::; i ::; 21 the set D S; contains all dead states reachable from the state which can be constructed by adding the states Mp with p ranging from (i - 1 )2k- 1 + 1 to i2k-l.

For I = k the induction hypothesis holds.

For I < k we know that DS; is calculated using step (2) and step (3), i.e.: DS; = CONSTRUCT JJEAD_STATES(

CONSTRUCT -11LLCOMBINATIONS(DS;t"!.l' DS;;l)) By the induction hypothesis we know that DS~t!l contains all dead states reach­able from the state which can be constructed by adding the states Mp with p : ((2i - 1) - 1)2k-(I+l) + 1 ::; P ::; (2i - 1)2k-(l+1) and DS;;l contains all dead states reachable from the state which can be constructed by adding the states Mp withp: (2i _1)2k-(I+1) + 1::; p::; 2i2k-(l+1). Using theorem I we deduce that D Sf contains all dead states reachable from the state which can be constructed by adding the states Mp such that p: ((2i -1) -1 )2k-(l+1) + 1 ::; p ::; (2i -1 )2k-(I+l) or (2i - 1 )2k-(I+l) + 1 ::; p ::; 2i2k-(I+l), i.e. (i - 1 )2k- 1 + 1 ::; p ::; i2k-l. Hence, the induction hypothesis holds for any I : 0 ::; I ::; k. Since M is the state which can be constructed by adding the states Mp with p : (1 - 1)2k- O + 1 ::; p ::; 1 2k - O, we conclude that the set D S = D Sr contains all dead states reachable from the state M. 0

For the TIGRA-I1 algorithm we also use two speedup measures (Sn and Sn) and two measures for the efficiency (En and E~). These measures are defined analo­gous to the measures defined in Section 5. The performance of the TIGRA-I1 al­gorithm still depends on the distribution of tokens over the processors in step (1). We still use the heuristic to distribute tokens evenly over the processors. However,

21

compared to the TIORA algorithm the performance is less sensitive to the distri­bution of tokens in step (1). (In the remainder of this paper we will use the term TIORA-I to refer to the algorithm presented in Section 5.)

There are several enhancements possible to improve the performance of the TIORA­n algorithm. Consider for example the selection of pairs of processor sets in step (2). In the proposed algorithm the processors working on Ds~t21 and DS~tl are combined. However, any pair of dead state sets constructed in step (3) may be combined. Moreover, it is allowed to start with step (2) before step (3) terminates. This means that the construction of a set S1 may start as soon as two sets of the form D S~ +1 are available. By using such refinements, we are able to attain a near­optimal balance of work.

7 Example

To illustrate the application of the two algorithms, we use the Petri net shown in Figure 9. This net models a small production system with push and pull control. Tokens in the places bI, b2, b3 and b4 represent raw materials which are trans­formed by the production system to end-products which are represented by tokens in place bI5. Each of the places bI, b2, ... bI5 represents a buffer which contains zero or more products. Products are transformed by machines. Figure 9 shows that there are seven machines: MI, M2, ... M7. Each of the machines is modelled by a small Petri net containing two transitions and two places. Consider for ex­ample machine M6 containing the transitions start6 and end6 and the placesfree6 and busy6. A token in place free6 indicates that machine M6 is free. Note that a machine can process only one product at a time. M5, M6 and M7 are used to as­semble products. The transitions sI, s2 and s3 have been added to synchronize the products before they are assembled. A push control is used for machines process­ing the raw materials, i.e. each of the machinesMI, M2, M3 andM4 are 'eager' to work. A pull control is used for the other machines. Kanbans are used to reduce the work-in-progress. The tokens in place kI represent kanbans that are used to limit the total number of products in buffers b9, busy5 and bII. Kanbans in place k3 are required to produce end-products.' If place k3 is empty, then machine M7 is blocked. If transition s4 fires, then a new production kanban for M7 is released. Tokens in the place demand represent the demand for end-products. If there is no demand for end-products, then no new production kanbans are released.

We will use the free-choice Petri net shown in Figure 9 to compare the performance ofTIORA-I and TIORA-II. First, we consider the situation with 4 processors and 3 x 2 kanbans, i.e. n = 4 and each of the places kI, k2 and k3 contains two tokens.

22

~ao--EJ--(l)11 ~demand ~~ sl b9 ~~! ~ ______ !

b2 b6 kl s3 G-§-o-G--O ~El-CA... : 6 bl3 bl4 bl5

b3 b7 82 k2

~~ ,~ __ b_12

b4 b8 hlO f, ".. .. , , '

(-;---A~--:~l , I free6 " I , , " , : " start6 en~ : II .. I ~ ________ __ b.!l9_6 ___ _____ -"~~

Figure 9: A production process modeled in terms of a free-choice Petri net.

The number of end-products to be produced is equal to k. In the initial state, the number of tokens in each of the places bI, b2, b3, b4 and demand is equal to k. In the first step of the both the TIORA-I and TIORA-II algorithm, we assign the k tokens in bI to the first processor. The second processor takes care of the tokens in b2, etc. The construction of the coverability graph to obtain all reachable dead states, requires quite some time. If k = 4, then the coverability graph contains 269399 nodes. If we use the TIORA-I algorithm on a single processor computer, then the total number of nodes that need to be constructed is reduced to 1296. Ifwe use the TIORA-II algorithm, this number is reduced to 965. In Table 4 the results of the two algorithms are compared for k smaller of equal to 4. These figures show that the TIORA-II algorithm out-achieves the TIORA-I algorithm.

The degree of inherent parallelism is of the utmost importance for the speedup measures. Parallelism in the Petri net shown in Figure 9 is constrainted by sev­eralloops. Each of the machines contains a circuit which forces the products to be processed sequentially. Moreover, there are three additional 'kanban-circuits' to reduce the 'work-in-progress'. We can vary the degree of inherent parallelism by adding and removing kanbans. The results in Table 4 refer to the situation with 3 x 2 kanbans, i.e. each of the places kI, k2 and k3 contains two tokens. By adding two tokens to each of the places kI, k2 and k3, we are able to analyze the situation with 3 x 4 kanbans. Table 5 shows some results for this alternative situation. These results show that the increased degree of parallelism leads to higher speedups.

The results presented in this section illustrate the potential of the TIORA-I and

23

TIGRA-I, n = 4, 3 x 2 kanbans k T T4 T' 4 S4 S' 4 1 148 23 32 6.43 1.39 2 3834 159 174 24.11 1.09 3 42862 565 586 75.86 1.04 4 269399 1296 1323 207.87 1.02

TIGRA-I/, n - 4, 3 x 2 kanbans k T T4 T~ S4 S~ 1 148 12 25 12.33 2.08 2 3834 28 52 136.93 1.86 3 42862 234 264 183.17 1.13 4 269399 965 1001 279.17 1.04

Table 4: Some results for the Petri net shown in Figure 9.

TIGRA-I, n = 4, 3 x 4 kanbans k T T4 T~ S4 S~ 1 148 23 32 6.43 1.39 2 3834 159 174 24.11 1.09 3 45284 747 768 60.62 1.03 4 336099 2668 2695 125.97 1.01

TIGRA-I/, n = 4, 3 x 4 kanbans k T T4 T' 4 54 5~ 1 148 12 25 12.33 2.08 2 3834 28 52 136.93 1.86 3 45284 53 90 854.42 1.70 4 336099 89 141 3776.39 1.58

Table 5: Some results for the situation with 3 x 4 kanbans.

24

TIGRA-II algorithm. Unfortunately, it is very difficult to generalize these results. First of all, the performance of the algorithm highly depends on the partitioning of tokens (step (1». However, empirical results show that TIGRA-II is much more robust with respect to the partitioning of tokens than the TIGRA-I algorithm. Sec­ondly, the size of the Petri net is not a good measure for the size of the correspond­ing coverability graph. For example, a slight modification of the net may influence the size of the corresponding coverability graph dramatically. Therefore, it is very difficult to predict the efficiency of the two algorithms. Nevertheless, we are able to conclude that for practical situations: (1) the TIGRA-I algorithm outachieves the traditional approach using a single coverability graph and (2) the TIGRA-II algorithm outachieves the TIGRA-I algorithm.

8 Conclusion

The two algorithms presented in this paper allow for the efficient calculation of dead states in a free-choice Petri net. The TIGRA-I algorithm allows for superlin­ear speedups compared to the traditional approach. Unfortunately, the TIGRA-I algorithm is not very robust. Therefore, we developed the more robust TIGRA-II algorithm. Experiments show that tremendous speedups are possible. In fact, we can also use the two algorithms on a single processor system and obtain remarkable speedups compared to the traditional technique of constructing one coverability graph. These results are possible by exploiting the fundamental property retained in the State-split theorem.

References

AALST, W.M.P. VAN DER (1994), Using Interval Timed Coloured Petri Nets to Calculate Performance Bounds, in: G. Haring and G. Kotsis (eds.), Proceed­ings of the 7th International Conference of Modelling Techniques and Tools for Computer Performance Evaluation, Lecture Notes in Computer Science 794, Springer-Verlag, Berlin, 425-444.

BERTSEKAS, D.P. AND J.N. TSITSIKLIS (1989), Parallel and Distributed Com­putation: Numerical Methods, Prentice-Hall, Englewood Cliffs.

BEST, E. (1987), Structure theory of Petri nets: the free choice hiatus, in: W. Brauer, W. Reisig, and G. Rozenberg (eds.), Advances in Petri Nets 1986 Pan I: Petri Nets, central models and their propenies, Lecture Notes in Computer Science 254, Springer-Verlag, Berlin, 168-206.

CASELLI, S., G. CONTE, F. BONARDI, AND M. FONTANESI (1994), Experi­ences on SIMD Massively Parallel GSPN Analysis, in: G. Haring and G.

25

Kotsis (eds.), Proceedings of the 7th International Conference of Modelling Techniques and Tools for Computer Performance Evaluation, Lecture Notes in Computer Science 794, Springer-Verlag, Berlin, 265-283.

CASELLI, S., G. CONTE, AND P. MARENZONI (1995), Parallel State Spece Ex­ploration for GSPN Models, in: G. De Michelis and M. Diaz (eds.), Appli­cation and Theory of Petri Nets 1995, Lecture Notes in Computer Science 935, Springer-Verlag, Berlin, 181-200.

CHENG, A., J. ESPARZA, AND J. PALS BERG (1993), Complexity results for 1-safe nets, in: R.K. Shyamasundar (ed.), Foundations of software technology and theoretical computer science, Lecture Notes in Computer Science 761, Springer-Verlag, Berlin, 326-337.

DESEL, J. (1992), A proof of lhe Rank lheorem for extended free-choice nets, in: K. Jensen (ed.), Application and Theory of Petri Nets 1992, Lecture Notes in Computer Science 616, Springer-Verlag, Berlin, 134--153.

DESEL, J. AND J. ESPARZA (1995), Free choice Petri nets, Cambridge tracts in theoretical computer science 40, Cambridge University Press, Cambridge.

ESPARZA, J. (1990), Synthesis rules for Petri nets, and how lhey can lead to new results, in: J.C.M. Baeten and J.w. Klop (eds.), Proceedings of CONCUR 1990, Lecture Notes in Computer Science 458, Springer-Verlag, Berlin, 182-198.

HACK, M.H.T. (1972), Analysis production schemata by Petri nets, Master's thesis, Massachusetts Institute of Technology, Cambridge, Mass.

LEWIS, T.G. (1993), Foundations of Parallel Programming: A Machine Indepen­dent Approach, IEEE Computer Society Press, Los Alamitos.

MURATA, T. (1989), Petri Nets: Properties, Analysis and Applications, Proceed­ings of the IEEE 77,541-580.

PETERSON, J.L. (1981), Petri net theory and the modeling of systems, Prentice­Hall, Englewood Cliffs.

PETRI, C.A. (1962), Kommunikation mit Automaten, Ph.D. lhesis, Institut fUr instrumentelle Mathematik, Bonn.

QUINN, M.J. (1994), Parallel Computing: Theory and Practice, McGraw-Hill, New York.

26

Computing Science Reports

In this series appeared:

93/01

93/02

93/03

93/04

93/05

93/06

93/07

93/08

93/09

93/10

93/11

93/12

93/13

93/14

93/15

93/16

93117

93/18

93/19

93/20

93/21

93/22

93/23

93/24

93/25

93/26

93/27

93/28

93/29

93(30

R. van Geldrop

T. Verhoeff

T. Verhoeff

E.H.L Aarts J .H.M. Karst P.I. Zwietering

I.C.M. Baeten C. Verhoef

J.P. Veltkamp

P.O. Moerland

J. Verhoosel

K.M. van Bee

K.M. van Hee

K.M. van Hee

K.M. van Hee

K.M. van Hee

J.C.M. Baeten J.A. Bergstra

J.C.M. Baeten J .A. Bergstra R.N. Bol

H. Schepers J. Hooman

D. Alstein P. van der Stok

C. Verhoef

G-J. Houben

F.S. de Boer

M. Codish D. Dams G. File M. Bruynooghe

E. Poll

E. de Kogel

E. Poll and Paula Severi

H. Schepers and R. Gerth

W.M.P. van der Aalst

T. Kloks and D. Kratsch

F. Kamareddine and R. Nederpelt

R. Post and P. De Bra

J. Deogun T. Kloks D. Kratsch H. Muller

Department of Mathematics and Computing Science Eindhoven University of Technology

Deriving the Aho-Corasick algorithms: a case study into the synergy of program­ming methods, p. 36.

A continuous version of the Prisoner's Dilemma, p. 17

Quicksort for linked lists, p. 8.

Detenninistic and randomized local search, p. 78.

A congruence theorem for structured operational semantics with predicates, p. 18.

On the unavoidability of metastable behaviour, p. 29

Exercises in Multiprogramming. p. 97

A Fannal Detenninistic Scheduling Model for Hard Real-Time Executions in DEDOS. p. 32.

Systems Engineering: a Fonnal Approach Pan I: Syste~ Concepts, p. 72.

Systems Engineering: a Fonnal Approach Part II: Frameworks, p. 44.

Systems Engineering: a Fonnal Approach Part ill: Modeling Methods, p. 101.

Systems Engineering: a Fonnal Approach Part IV: Analysis Methods, p. 63.

Systems Engineering: a Fonnal Approach Part V: Specification Language, p. 89.

On Sequential Composition, Action Prefixes and Process Prefix, p. 21.

A Real-Time Process Logic, p. 31.

A Trace-Based Compositional Proof Theory for Fault Tolerant Distributed Systems, p. 27

Hard Real-Time Reliable Multicast in the DEDOS system, p. 19.

A congruence theorem for structured operational semantics with predicates and negative premises, p. 22.

The Design of an Online Help Facility for ExSpect, p.2l.

A Process Algebra of Concurrent Constraint Programming, p. 15.

Freeness Analysis for Logic Programs - And Correctness, p. 24

A Typechecker for Bijective Pure Type Systems, p. 28.

Relational Algebra and Equational Proofs, p. 23.

Pure Type SYStCIOS with Definitions, p. 38.

A Compositional Proof Theory for Fault Tolerant Real-Time Distributed Systems, p.31.

Multi-dimensional Petri nets, p. 25.

Finding all minimal separators of a graph, p. 11.

A Semantics for a fine A-calculus with de Bruijn indices, p.49.

GOLD, a Graph Oriented Language for Databases, p. 42.

On Vertex Ranking for Pennutation and Other Graphs, p. II.

93131 W. Korver

93/32 H. ten Eikelder and H. van Geldrop

93/33 L. Loyens and J. Moonen

93/34 I.c'M. Baeten and I.A. Bergstra

93/35 W. Ferrer and P. Severi

93/36 I.C.M. Baeten and I.A. Bergslra

93/37 J. Brunekreef J·P. Kaloen R. Koymans S. Mauw

93/38 C. Verhoef

93/39 W.P.M. Nuijlen E.H.L Aarts D.A.A. van Erp Taahnan Kip K.M. van Hee

93/40 P.D.V. van def Stok M.M.M.P.I. CIacssen D. Alstein

93/41 A. Bijlsma

93/42 P.M.P. Rambags

93/43 B.W. Watson

93/44 B.W. Watson

93/45 E.1. Luit I.M.M. Martin

93/46 T. KIoks D. Kratsch J. Spinrad

93/47 W. v.d. Aalst P. De Bra GJ. Houben Y. Komatzky

93/48 R. Gerth

94/01 P. America M. van def Kammen R.P. Nederpclt O.S. van Roosmalen H.C.M. de Swart

94/02 F. Kamareddinc R.P. Nederpelt

94/03 L.B. Hartman KM. van Hcc

94/04 I.c'M. Baeten J .A. Bergslra

94/05 P. Zhau 1. Hooman

94/06 T. Basten T. Kunz J. Black M. Coffin D. Taylor

94/07 K.R. Apt R. Bol

94/08 O.S. van Roosmalen

94/09 J.CM. Baeten 1.A. Bergslra

Derivation of delay insensitive and speed independent CMOS circuits, using directed commands and production rule selS, p. 40.

On the Correctness of some Algorithms to generate Finite Automata for Regular Expressions, p. 17.

IUAS. a sequential language for parallel matrix computations. p. 20.

Real Time Process Algebra with Infinitesimals. p.39.

Abstract Reduction and Topology, p. 28.

Non Interleaving Process Algebra. p. 17.

Design and Analysis of Dynamic Leader Election Protocols in Broadcast Networks, p. 73.

A general conservative extension theorem in process algebra. p. 17.

Job Shop Scheduling by Constraint Satisfaction, p. 22.

A Hierarchical Membership Protocol for Synchronous Distributed Systems, p. 43.

Temporal operators viewed as predicate transfonners, p. 11.

Automatic Verification of Regular Protocols in P(f Nets, p. 23.

A ta:WlTlomy of finite automata construction algoritluns, p. 87.

A taxonomy of finite automata minimization algorithms, p. 23.

A precise clock synchronization protocol,p.

Treewidth an4 Patwidth of Cocomparability graphs of Bounded Dimension, p. 14.

Browsing Semantics in the "Tower" Model, p. 19.

Verifying Sequentially Consistent Memory using Interface Refinement, p. 20.

The object-oriented paradigm, p. 28.

Canonical typing and II-conversion, -po 51.

Application of Marcov Decision Processe to Search Problems, p. 21.

Graph Isomorphism Models for Non Interleaving Process Algebra, p. 18.

Fonnal Specification and Compositional Verification of an Atomic Broadcast Protocol, p. 22.

Time and the Order of Abstract Events in Distributed Computations, p. 29.

Logic Programming and Negation: A Survey, p. 62.

A Hierarchical Diagrammatic Representation of Class Structure, p. 22.

Process Algebra with Partial Choice, p. 16.

94/10 T. verhoeff

94/11 J. Peleska C. Huizing C. Pelersohn

94/12 T. Kloks D. Kratsch H. Mliller

94/13 R. Seljee

94/14 W. Peremans

94/15 R.l.M. Vaessens E.H.L. Aarts 1.K. Lenstra

94/16 R.e. Backhouse H. Doornbos

94/17 S. Mauw M.A. Reniers

94/18 F. Kamareddine R. Nederpelt

94/19 B.W. Watson

94/20 R. Bloo F. Kamareddine R. Nederpelt

94/21 B.W. Watson

94122 B.W. Watson

94/23 S. Mauw and M.A. Reniers

94/24 D.Dams O. Grurnberg R. Gerth

94/25 T. KIoks

94/26 R.R. Hoogerwoord

94/27 S. Mauw and H. Mulder

94/28 C.W.A.M. van Overveld M. Verhoeven

94/29 J. Hooman

94/30 J .C.M. Baeten I.A. Bergstra Gh . .$tefanescu

94/31 B.W. Watson R.E. Watson

94/32 J.]. Vereijken

94/33 T. Laan

94/34 R. Bloo F. Kamareddine R. Nederpelt

94/35 I.CM. Baeten S. Mauw

94/36 F. Kamareddine R. Nederpelt

94/37 T. Basten R. Bol M. Voorhoeve

94/38 A. Bijlsma C.S. Scholten

The testing Paradigm Applied to Network Structure. p. 31.

A Comparison of Ward & Mellor's Transfonnation Schema with Slate4 & ActivitychartS, p. 30.

Dominoes, p. 14.

A New Method for Integrity Constraint checking in Deductive Databases, p. 34.

Ups and Downs of Type Theory, p. 9.

Job Shop Scheduling by Local Search, p. 21.

Mathematical Induction Made Calculational, p. 36.

An Algebraic Semantics of Basic Message Sequence Charts, p. 9.

Refining Reduction in the Laml:xla Calculus, p. 15.

The perfonnance of single-keyword and multiple-keyword pattern matching algorithms, p. 46.

Beyond "a-Reduction in Church's ).~, p. 22.

An introduction to the Fire engine: A C++ toolkit for Finite automata and Regular Expressions.

The design and implementation of the FIRE engine: A C++ toolkit for Finite automata and regular Expressions.

An algebraic semantics of Message Sequence Charts, p. 43.

Abstract Interpretation of Reactive Systems: Abstractions Preserving 'TICfL*, 3CfL* and CTL*, p. 28.

KI,J-free and W4-free graphs, p. 10.

On the foundations of functional programming: a programmer's point of view, p. 54.

Regularity of BPA·Systems is Decidable, p. 14.

Stars or Stripes: a comparative study of finite and transfinite techniques for surface modelling, p. 20.

Correctness of Real Time Systems by Construction, p. 22.

Process Algebra with Feedback, p. 22.

A Boyer-Moore type algorithm for regular expression pattern matching, p. 22.

Fischer's Protocol in Timed Process Algebra, p. 38.

A fonnalization of the Ramified Type Theory, pAO.

'The Barcndregt Cube with Definitions and Generalised Reduction, p. 37.

Delayed choice: an operator for joining Message Sequence Charts, p. 15.

Canonical typing and II-conversion in the Barendregt Cube, p. 19.

Simulating and Analyzing Railway Interlockings in ExSpcct, p. 30.

Point·free substitution, p. 10.

94(.39 A. Blokhuis T. KIoks

94/40 D. Alstein

94/41 T. KIoks D. Kratsch

94/42 J. Engelfriet I.I, Vereijken

94/43 R.C. Backhouse M. Bijsterveld

94/44 E. Brinksma 1. Davies R. Gerth S. Gfar W. Janssen B. Jonsson S. Katz G.Lowe M. Poel A. Pnueli C. Rwnp J. Zwiers

94/45 G,!. Hooben

94/46 R.8100 F. Kamareddine R. Nederpelt

94/47 R. Bloo F. Kamarcddine R. Nederpelt

94/48 Mathematics of Program Construction Group

94/49 I.C.M. Baeten I.A. Bergstra

94/50 H. Geuvers

94/51 T. KIoks D. Kratsch H. MilUer

94/52 W. Penczek R. Kuiper

94/53 R. Gerth R. Kuiper D. Peled W. Penczek

95/01 I.I. Lukkicn

95/02 M. Bezem R.801 J.F. Groote

95/03 I.C.M. Baeten C. Verhoef

95/04 1. Hidders

95/05 P. Severi

95/06 T.W.M. Vossen M.O.A. Verhoeven H.M.M. ten Eikelder E.H.L. Aarts

95/07 GAM. de Bruyn O.S. van Roosmalen

95/08 R. Bloo

95/09 J.C.M. Baeten I.A. Bergstra

95/10 R.e. Backhouse R. Verhoeven O. Weber

On the equivalence covering number of splitgraphs, p. 4.

Distributed Consensus and Hard Real-Time Systems, p.34.

Computing a perfect edge without vertex elimination ordering of a chordal bipartite graph, p. 6.

Concatenation of Graphs, p. 7.

Category Theory as Coherently Constructive Lattice Theory: An Illustration, p. 35.

Verifying Sequentially Consistent Memory, p. 160

Tutorial voor de ExSpcct-bibliotheek voor "Administratieve Logistiek", p. 43.

The A -cube with classes of terms modulo conversion, p.16.

On IT-conversion in Type Theory, p. 12.

Fixed-Point Calculus, p. 11.

Process Algebra with Propositional Signals, p. 25.

A short and flexible proof of Strong Normalazation for the Calculus of Constructions, p. 27.

Listing simplicial vertices and recognizing diamond-free graphs, p. 4.

Traces and Logic, p. 81

A Partial Order Approach to Branching Time Logic Model Checking, p. 20.

The Construction of a small CommunicationLibrary, p.16.

Fonnalizing Process Algebraic Verifications in the Calculus of Constructions, p.49.

Concrete process algebra, p. 134.

An Isotopic Invariant for Planar Drawings of Connected Planar Graphs, p. 9.

A Type Inference Algorithm for Pure Type Systems, p.20.

A Quantitative Analysis of Iterated Local Search, p.23.

Drawing Execution Graphs by Parsing, p. 10.

Preservation of Strong Normalisation for Explicit Substitution, p. 12.

Discrete Time Process Algebra, p. 20

MatWpad: A System for On-Line Prepararation of Mathematical Documents, p. 15

95/11

95/12

95/13

95/14

95/15

95/16

95/17

95/18

95/19

95{20

95{2l

95{22

95f23

95{24

95{25

95{26

95{27

95{28

95{29

95/30

95/31

95/32

95(33

95/34

95/35

9Mll

96/02

R. Seljee

S. Mauw and M. Renicrs

B.W. Watson and G. Zwaan

A. Poose, C. Verhoef, S.F.M. Vlijrnen (eds.)

P. Niebert and W. Penczek

D. Dams, O. Grumberg. R. Gerth

S. Mauw and E.A. van deT Meillen

F. Kamareddine and T. Laan

J.C.M. Baeten and J.A. Bergslra

F. van Raamsdonk and P. Severi

A. van Deursen

B. Arnold, A. v. Deufsen, M. Res

W.M.P. van def Aalst

F.P.M. Dignum. W.P.M. Nuijten, L.M.A. Janssen

L. Feijs

W.M.P. van der Aalst

P,D.V. van def Stok. 1. van def \Val

W. Fokkink, C. Verhoef

H. Jurjus

J. Hidders, C. Hoskcns, J. Parcdaens

P. Kelb, D. Dams and R. Gerth

W .M.P. van def Aalst

J. Engelfrict and JJ. Vcreijken

J. Zwanenburg

T. Basten and M. Voorhoeve

M. Voorhoeve and T. Basten

P. de Bra and A. Acns

Deductive Database Systems and integrity constraint checking, p. 36.

Empty Interworkings and Refinement Semantics of Interworkings Revised. p. 19.

A taxonomy of sublinear multiple keyword pallem matching algorithms, p. 26.

De proceedings: ACP'95, p.

On the Connection of Partial Order Logics and Partial Order Reduction Methods, p.12.

Abstract Interpretation of Reactive Systems! Preservation of CTL*, p. 27.

Specification of tools for Message Sequence Charts, p. 36.

A Reflection on Russell's Ramified Types and Kripke's Hierarchy of Truths, p. 14.

Discrete Time Process Algebra with Abstraction, p. 15.

On Nonnalisation. p. 33.

Axiomatizing Early and Late Input by Variable Elimination, p. 44.

An Algebraic Specification of a Language for Describing Fmancial Products, p. 11.

Petri net based scheduling, p. 20.

Solving a Time Tabling Problem by Constraint Satisfaction, p. 14.

Synchronous Sequence Charts In Action. p. 36.

A Gass of Petri nets for modeling and analyzing business processes, p. 24.

Proceedings of the Real-Time Database Workshop, p. 106.

A Conservative Look at tenn Deduction Systems with Variable Binding, p. 29.

On Nesting of a Nonmonotonic Conditional, p. 14

The Fonnal Model of a Pattern Browsing Technique, p.24.

Practical Symbolic Model Checking of the full ,Wcalculus using Compositional Abstractions, p. 17.

Handboek simulatie, p. 51.

Context-Free Graph Grammars and Concatenation of Graphs, p. 35.

Record concatenation with intersection types, p. 46.

An algebraic semantics for hierarchical Pff Nets. p. 32.

Process Algebra with Autonomous Actions, p. 12.

Multi-User Publishing in the Web: DreSS. A Document Repository Service Station, p. 12