Reachable state space generation for structured models which use functional transitions Afonso Sales† and Brigitte Plateau Grenoble INP – LIG Laboratory (CNRS - Grenoble INP - INRIA - UJF - UPMF) – France {Afonso.Sales, Brigitte.Plateau}@imag.fr
Abstract—This paper presents a new approach to obtain the Reachable State Space (RSS) of a structured model which uses functional transitions. We use Multi-valued Decision Diagrams (MDD) to store sets of reachable spaces and Stochastic Automata Networks (SAN) formalism to describe structured models. We focus our contribution in the proposal of a method to generate a compact MDD description taking advantage of the modular structure of SAN formalism, which also allows to represent the transition rate matrix of a continuous-time Markov chain by means of a sum of generalized Kronecker products. The method is tested on some models and the conclusion presents future work. Keywords-State Space Generation; Decision Diagrams; Kronecker Algebra; Stochastic Automata Networks
I. I NTRODUCTION Structured modeling formalisms are based on the description of a complex system by its parts. Such approach usually includes a large number of unreachable states that are invalid combinations of valid local states. This problem has been studied for Stochastic Petri Nets (SPN) [1], [2], [3], Stochastic Automata Networks (SAN) [4], [5] and many others formalisms [6], [7]. The comprehensive studies about properties of Petri nets [8], [9] have already offered many insights in dealing with compact and efficient descriptions of reachable state spaces (RSS) for SPN models. Basically, Buchholz and Kemper [10], Ciardo, L¨uttgen and Siminiceanu [11] and Miner [12] have proposed efficient ways to deal with large reachable state spaces found in SPN models within huge product state spaces. Similar solutions for SAN formalism [5] do not exist for generic models and we believe that much work can still be done. The main purpose of this paper is to adapt the concept of Multi-valued Decision Diagrams (MDD) [13] already used for SPN formalism [2], [14] to SAN formalism. Although saturation-based state-space generation method has been extended to models that are not (or should not be, for efficiency reasons) described using Kronecker operators [15], [16], [17], our method is an extension of saturation-based state-space generation presented in [18]. Such an adaptation requires considerable work to handle the concept of local and synchronizing events with constant and functional rates †
Author receives grants from CAPES-Brazil (BEX 2304/04-0).
during the generation of the RSS. In fact, the most important contribution of this paper is the description of a method to obtain the RSS of a SAN model which uses functional transitions and efficiently stores it with a MDD structure. We apply our approach to some models in order to analyze the number of nodes, memory consumption and the generation CPU times to obtain the resultant MDD. Since it is, at the authors best knowledge, the first method to generate a MDD to represent the RSS of a general SAN model with functional transitions, this paper presents an analysis of the computational efficiency for the proposed method. Our aim is to stress some advantages of using functional transitions taking advantage of a very compact and manageable representation coming from a model description point of view. The rest of this paper is organized as follows. In Section II, we give a brief description of SAN formalism, which we have chosen for presenting our method, and MDD structure. In Section III, we show how functional rates and probabilities are handled during the generation of the RSS and we also present our Kronecker-based encoding scheme (reachability descriptor) employed by our RSS generation method. Section IV shows some modeling examples and experimental results. Finally, the conclusion summarizes our contribution and suggest future work to improve the proposed method. II. BACKGROUND AND RELATED WORK Although our RSS generation method (presented in Section III) can be applicable to general discrete-state models of event-based concurrent systems, we focus our discussion on SAN formalism, which has a transition rate matrix representation of a continuous-time Markov chain through a sum of generalized Kronecker products (i.e., matrix entries can be expressed by functions). We also present in this section a brief description of MDDs which are efficient and compact data-structures to represent extremely large state spaces. A. Stochastic Automata Networks (SAN) SAN formalism was proposed by Plateau [19] and its basic idea is to represent a whole system by a collection
of N subsystems with an independent behavior (local transitions) and occasional interdependencies (functional rates and synchronizing events). Each subsystem is described as a stochastic automaton (i.e., an automaton in which the transitions are labeled with probabilistic and timing information). The framework proposed by Plateau defines a modular way to describe continuous and discrete-time Markovian models [20]. SAN has exactly the same application scope as the Markov chains formalism [21], [22]. Product state space Sˆ of a SAN model is obtained by the cartesian product S (N ) × . . . × S (1) , where S (i) = {0, 1, . . . , ni − 1} is the local state space of ith automaton and ni is the number of local states. The global state x ˜ of a SAN model is defined by the cross-product of the local states of all automata. Let x ˜init ∈ Sˆ be the initial global state of a SAN model, x ˜ ∈ Sˆ is a reachable state if it can be reached from global state x ˜init and the set of reachable ˆ states is denoted by S ⊆ S. A SAN model has a set of events (E) which triggers changes of the global states x ˜ of the model. Each event is represented by an identifier and a rate of occurrence, which describes how often a given event occurs. There are two types of events: local events, which change the SAN global state passing from a global state to another that differs only by one local state; and synchronizing events, which can change simultaneously more than one local state (i.e., two or more automata can change their local states simultaneously). In other words, the occurrence of a synchronizing event forces all concerned automata to fire a transition corresponding to this event. Each transition may be fired as result of the occurrence of any number of events. In general, non-determinism among possible different events is dealt according to Markovian behavior (i.e., any of the events may occur and their occurrence rates define how often each one of them will occur). Nevertheless, if the occurrence of a given event can lead to more than one state from a given local state, then an additional routing probability must be informed. If only one transition can be fired by an event from a given local state, the routing probability (equal to 1.0) can be omitted. Another way to represent interaction among automata is the use of functional rates and probabilities. Event occurrence rates and routing probabilities may be expressed by a constant value (a positive real number) or a function of state of other automata. The use of functions is an oneway interaction among automata, since it affects only the automaton in which it appears. Figure 1 presents a SAN model with 2 automata, 4 local events, 1 synchronizing event, constant routing probabilities (π1 and π2 ), and 1 functional rate. The initial global state x ˜init = (x(1) , x(2) ) = 00. The rate of event e1 is not a constant rate, but a functional rate f described by the SAN notation employed by the PEPS software tool [23]. The interpretation of a function can be viewed as the evaluation
of an expression of non-typed programming languages (e.g., C language). Each comparison is evaluated to value 1 (true) and value 0 (false). The firing of the transition from state 0 to state 1 occurs with rate λ if automaton A(2) is in state 0, or γ if automaton A(2) is in state 2. If automaton A(2) is in state 1, the transition from 0 to 1 does not occur (rate equal to zero). A(2)
A(1) 0
0 e2(π1)
e4 e2
e2(π2)
e1
e5 1
f=
2
1
Type Event Rate loc e1 f syn e2 µ e3 σ loc loc e4 δ loc e5 τ
e3 st A(2) == 0 × λ + st A(2) == 2 × γ
Figure 1.
Example of a SAN model
The use of functions is a powerful feature of SAN, since it allows to describe very complex behaviors in a very compact format. The computational costs to handle functional rates has decreased with the developments of numerical solutions for SAN models [23]. B. State spaces represented by MDDs Binary Decision Diagrams (BDD) [9] have emerged as an alternative structure to store the RSS of a SPN model, intending to alleviate the state space explosion problem of large Markovian systems. In the first work [24], a vector data structure (array) was proposed to store a subset S of a cross-product S (N ) × . . . × S (1) of N sets. Later, multilevel data structures (e.g., AVL or Splay trees [25]) were used to provide efficient operations (e.g., searching and insertion) during the exploration of S. Further work from Miner and Ciardo [2], [14] propose the use of MDDs. MDD is an extension of BDD applied to a non-binary boolean logic. An event-based and component-based system model produces state spaces whose characteristic function is of the form S (N ) × . . . × S (1) → {0, 1}, where N is the number of system components. Thus, a subset S ⊆ S (N ) ×. . .×S (1) can be represented naturally by a MDD via its characteristic function fS such that fS (˜ x) = 1 ⇔ x ˜ ∈ S. Definition 1. A Multi-valued Decision Diagram (MDD) is a directed acyclic edge-labeled multi-graph with the following properties [18]: • Nodes are organized into N + 1 levels, where p.lvl indicates the level of node p; • Level N has only one single non-terminal node r (the root), whereas levels N −1 through 1 have one or more non-terminal nodes; • Level 0 has two terminal nodes: 0 and 1; • A non-terminal node p at level l contains nl arcs pointing to nodes at level l − 1. An arc of node p from position x(l) ∈ S (l) which points to node q is denoted by p[x(l) ] = q;
•
No two nodes are duplicates. Two distinct non-terminal nodes p and q at level l are duplicates iff ∀x(l) ∈ S (l) , p[x(l) ] = q[x(l) ].
Figure 2 shows a MDD which represents the state space S, subset of a cross-product of a system divided by four subsystems (i.e., N = 4). S (4) = {0, 1, 2, 3}
Level 4
4 0
S (3) = {0, 1}
Level 3
3
Level 2
S (1) = {0, 1}
1
1 0
Figure 2.
3
0
0 1
0 2
0 1
A. Handling functional rates and probabilities For structured models which allow transition labels to be expressed by functions (e.g., SAN models), the state space for which the evaluation of a function is different from zero can be naturally represented by a MDD.
2001, 2111, 2121,
2 12
Level 1
Level 0
S = { 0101, 1001, 1101,
3
0
0 1
2 0
2
3 1
0
S (2) = {0, 1, 2}
1
our contribution discussing the modifications in our RSS generation method compared to the previous work [18].
3001, 3111, 3121}
1
2 2
1 1
1
A state space S represented by a MDD
In Figure 2, non-terminal nodes are depicted by circles and terminal nodes are depicted by squares. A given state x ˜ = (x(N ) , . . . , x(1) ) of S is element of a subset represented by a N -level MDD if and only if the path through the MDD, starting at the level-N node, following downward pointer x(l) at level l, reaches terminal node 1. Dashed arcs and nodes are paths which lead only to terminal node 0 and in the rest of the paper, for reasons of clarity, will be omitted. MDDs can be used to represent a set S of integer tuples by storing the characteristic function fS of the set. So sets can be manipulated using MDD operations on their characteristic functions, e.g., union on sets corresponds to disjunction on MDDs. The complexity of these operations depends on the number of nodes in the arguments’ MDDs and not on the number of states represented by the MDDs [18]. III. RSS GENERATION FOR MODELS WHICH USE FUNCTIONAL TRANSITIONS
Saturation-based state-space generation is a successful symbolic technique based on decision diagrams applied to generating state spaces of structured models. Our RSS generation method is an extension of the saturation-based state-space generation presented in [18], extension which allows transition labels to be expressed by functions. In this section, we present our approach using MDD to generate the RSS of a SAN model which uses functional transitions. In particular, we focus our contribution on a RSS generation method which is based on a generalized Kronecker representation (reachability descriptor) for structured models, thus using all benefits from saturation-based generation, without any kind of restriction over the arguments of the functions. Section III-A shows how we can handle functional rates and probabilities in our RSS generation method and Section III-B presents how we can obtain the reachability descriptor of a SAN model. In Section III-C, we finalize
Definition 2. F uncM ddid is a MDD representing the set of states for which the evaluation of function fid is different ˆ fid (˜ from zero, i.e., for all x ˜ ∈ S, x) 6= 0. Given a SAN model of N automata, Sˆ(ω) is the crossproduct of the set of local states of automata A(i) (i ∈ ω), where ω ⊆ [1..N ] is a set of indices of automata. Let x ˜(ω) (i) be a state vector of local state x such that i ∈ ω, we denote by f (˜ x(ω) ) the evaluation of function f with the (ω) input x ˜ ∈ Sˆ(ω) . Given a SAN model which has F distinct functions, any MDD F uncM ddid associated to a function fid (where id ∈ [1..F ]) can be obtained by Algorithm 1. Computing this MDD (F uncM ddid ) is conceptually a simple task, since it can be obtained by the union of all states for which the evaluation of function fid is different from zero. In Algorithm 1, note that Sˆ(ωid ) is the set of inputs (domain) used in order to evaluate function fid instead of all global states x ˜ ∈ Sˆ of the model. Algorithm 1 FuncMdd(in id: integer): MDD 1: F uncM ddid ← ∅; 2: for each x ˜(ωid ) ∈ Sˆ(ωid ) do 3: if (fid (˜ x(ωid ) ) 6= 0) then 4: stmdd ← StateToMdd(˜ x(ωid) ); 5: F uncM ddid ← Union(F uncM ddid, stmdd); 6: end for 7: return F uncM ddid ; We will not discuss here the computational cost of each operation described in Algorithm 1. For more details, see [26]. Although, the computational cost to generate F uncM dd of a function which has Sˆ as a domain (Algorithm 1) can be prohibitive, representing by a MDD a set of specific states related to a function (F uncM dd) is an approach which allows an efficient way to perform intersection operations among several F uncM dd. This approach plays an important role in our RSS generation method and it will become apparent in Section III-B1. B. Reachability descriptor (RD) Reachability descriptor (RD) is an algebraic formula which represents in a compact way the transitions among global states of a model. RD is based on the Markovian descriptor [27] of a SAN model and it has a generalized Kronecker representation (i.e., matrix entries can be expressed
by functions). RD representation is concerned only with the transitions among global states of a model, and not with the rate at which they may occur. Then no information corresponding to event rates are represented in RD. Indeed, RD is just the descriptor restricted to the reachability relation without considering the rates. In [18], next-state function N (˜ x) specifies the set of states which can be reached from state x ˜ in one step. The next-state function is represented by a nested disjunctiveconjunctive format based on a Kronecker representation. In our approach, the next-state function is represented by our reachability descriptor. RD is represented by a particular tensor format (Definition 5) which arranges the matrix elements according to the subspaces where they can be identically null. The benefits of this tensor format will become clear in Section III-C. The matrices employed in RD of a model are based on local and synchronizing matrices employed in the Markovian ˘ (i) be the local reachdescriptor of the same model. Let R l ability matrix derived from its corresponding local matrix (i) ˘ e(i) be the synchronizing Ql of automaton A(i) and let R reachability matrix derived from its corresponding synchro(i) nizing matrix Qe of automaton A(i) and event e ∈ E of Markovian descriptor, the matrix elements can be classified as: ˘ (i) is equal to 0 (zero) if the entry • null: an entry in R in the corresponding matrix Q(i) is equal to zero; •
•
˘ (i) is equal to 1 constant-assimilated: an entry in R (one) if the entry in the corresponding matrix Q(i) is equal to a (positive) constant value or a function whose evaluation is always different from zero for all elements of its domain; ˘ (i) is expressed by a function if functional: an entry in R the entry in the corresponding matrix Q(i) is a function which has at least one element of its domain evaluated to zero.
Property 1. A (local or synchronizing) reachability matrix ˘ (i) of automaton A(i) of a tensor term in RD can be R represented by the sum of C (i) reachability matrices: ˘ (i) = R
(i) C X
˘ (i) R c
c=1
˘ (i) belongs to only one Proof: An element of matrix R (i) equivalence class Cc of indice c, where c ∈ [1..C (i) ]. (i) (i) Indeed, ∀c1 , c2 ∈ [1..C (i) ], Cc1 ∩ Cc2 = ∅. ˘ c(i) is defined by: The matrix R ∀x(i) , y (i) ∈ S (i) , (i) ˘ c(i) (x(i) , y (i) ) = f(x(i) ,y(i) ) = f(x(i) ,y(i) ) ∈ Cc ⇒ R (i) (i) (i) ˘ (x , y ) R (i) ˘c(i) (x(i) , y (i) ) = 0 f(x(i) ,y(i) ) 6∈ Cc ⇒ R Thus, we have: ∀x(i) , y (i) ∈ S (i) , ˘ c(i) (x(i) , y (i) ) 6= 0 ⇒ ∀c1 ∈ [1..C (i) ], where c1 6= c, R (i) ˘ c1 (x(i) , y (i) ) = 0 R ˘ (i) = Then, we finally have: R
(i) C X
˘ (i) R c
c=1
Definition 5. Using the distributivity over addition property [27] and the equivalence relations R on the elements of reachability matrices (Definition 3), reachability descriptor R of a SAN model of N automata is given by a generalized tensor formula2 : (j)
R=
N C N l X X O j=1 c=1 i=1
Ce(N )
(1)
˘ (i) R g j,c
+
e X C X
e∈Es c(1) =1
···
N X O
c(N ) =1 i=1
g
˘ (i) (i) R e,c
˘ (i) (if j = i) or I|S (i) | (if j 6= i), C (i) and ˘ (i) = R where R j,c l,c l (i) Ce are the number of equivalence classes on the elements ˘ (i) and R ˘ e(i) respectively, and Es is the set of of matrices R l synchronizing events of the SAN model.
Definition 3. Given a (local or synchronizing) reachability ˘ (i) of automaton A(i) of a tensor term in RD, a matrix R functional element f(x(i) ,y(i) ) on row x(i) and column y (i) of this matrix and f −1 (0) the preimage of 0 (zero) under function f (i.e., f −1 (0) = {˜ x(ω) ∈ Sˆ(ω) | f (˜ x(ω) ) = 0}), we define an equivalence relation R(i) on the elements of ˘ (i) such that f(x(i) ,y(i) ) R(i) f(z(i) ,w(i) ) ⇔ f −1(i) (i) (0) = R (x ,y ) −1 (i) (i) (i) (i) (i) f(z (0), where x , y , z , w ∈ S . (i) ,w (i) )
1) Merging F uncM dd of a tensor term t: In order to propose a RSS generation method for models which use functional transitions, we present in this section our approach to generate a single MDD associated to the functional elements that appear in the matrices of a tensor term t of RD. Thus, such MDD represents the set of states for which the evaluation of all functions of t is different from zero.
˘ (i) (i ∈ [1..N ]), Definition 4. Given a reachability matrix R (i) 1 C is the number of equivalence classes with respect to (i) equivalence relation R(i) and Cc is the equivalence class of indice c (where c ∈ [1..C (i) ]) of the elements of this matrix.
Definition 6. Given a tensor term t ∈ T (where T is the set of tensor terms of RD), T F M ddt is a MDD representing the set of states for which the evaluation of all functional elements which appear in the matrices of term t is different from zero.
1 The
equivalence class of null element (zero) is not considered.
2 For
a formal and complete description, see [26].
Given a tensor term t = ⊗N
g i=1
˘ (i) of RD, such term R
can be classified as: constant-assimilated, if all non-null ˘ (i) of this term are elements of reachability matrices R constant-assimilated; or functional, if there is at least one functional element that can be evaluated to zero in the ˘ (i) of this term. reachability matrices R Definition 7. Given an event e ∈ E and a tensor term te ∈ T associated to this event, ωe is the set of indices of automata which are concerned by event e and ωte is the set of indices of automata whose states are inputs of functions which appear in the matrices of term te . Remembert that such tensor terms have been produced so that functional elements in the same matrix have the same ˘ (i) F uncM dd (Definition 2). Given a reachability matrix R te ˘ t(i) associated of automaton A(i) of tensor term te = ⊗N R e g i=1
to event e ∈ E, all functional elements in this matrix have (i) the same MDD denoted by F uncM ddte . Hence, we are interested in obtaining a single MDD (representing the state ˘ t(i) is null) by means of the intersection of space where no R e (i) all F uncM ddte . In the next section, we explain the use of T F M ddt in our saturation-based RSS generation method and why it is important to arrange the matrix elements according to the subspaces where they can be identically null. C. Saturation using functional transitions The Saturation algorithm presented in [18] uses a nextstate function representation split by events and subsystems. However, such representation uses (ordinary) Kronecker product form. In order to allow functional transition rates (without any kind of restriction over their arguments) in our saturation-based RSS generation method, the next-state function is represented by reachability descriptor (which has a generalized Kronecker representation), where Nt is a cross-product of N local next-state functions: Nt = (l) NN,t × · · · × N1,t (Nl,t : S (l) → 2S , for N ≥ l ≥ 1). Moreover, we use MDD T F M ddt to represent the set of states for which the evaluation of all functional elements which appear in the matrices of a tensor term t is different from zero. For models using only constant elements (constant values), we can easily determine if a global transition may occur from a global state x ˜ ∈ Sˆ of a model via the non-null entries of the matrices of a tensor term in RD. Given a constantassimilated tensor term te ∈ T associated to event e ∈ E of a SAN model, a transition represented by the matrices of te may occur from the global state x ˜ ∈ Sˆ if next-state function x) 6= ∅. Nte (˜ On the other hand, for a tensor term which has functional elements that can be evaluated to zero (i.e., a functional tensor term), we must take this possibility of zero transition rates into account via T F M dd of this term. So, in the
context of our analysis, given a functional tensor term te ∈ T associated to event e ∈ E of a SAN model, a transition represented by the matrices of te may occur from x) 6= ∅ and the global state x ˜ ∈ Sˆ if next-state function Nte (˜ x ˜ ∈ T F M ddte . In Section III-B, we proposed a particular tensor format for the reachability descriptor, which decomposes the matrix elements. Such decomposition ensures all functional elements in a reachability matrix have the same “kernel” (i.e., the same set of arguments where they can be null). Then all functions fid (id ∈ [1..F ]), which are functional ˘ (i) of automaton transitions in a given reachability matrix R A(i) , generate an identical F uncM dd. Therefore, given a ˘ (i) and a function fid which is an reachability matrix R ˘ (i) is a null matrix when its element in this matrix, R functions are evaluated to x ˜ 6∈ F uncM ddid . ˘ (i) (˜ ˘ (i) of Property 2. Let R x) be the reachability matrix R (i) automaton A evaluated to the global state x ˜. Given a ˘ (i) and a function fid which is an element on row matrix R x(i) and column y (i) of this matrix, we have: ˘ (i) (˜ x ˜ 6∈ F uncM ddid ⇔ R x) = fid (˜ x) = 0 ˘ (i) Proof: Since all elements in a reachability matrix R belong to only one equivalence class, all functional elements in this matrix have the same kernel (i.e., the same set of arguments where they can be null) and as a result the same F uncM dd. Then, we have: x ˜ 6∈ F uncM ddid ˘ (i) (x(i) , y (i) ) = 0 fid (˜ x) = 0 ⇒ R x ˜ ∈ F uncM ddid ˘ (i) (˜ ˘ (i) (x(i) , y (i) ) 6= 0 if R x) = fid (˜ x) 6= 0 ⇒ R Such condition that all functions of a matrix have the same kernel is a strong condition. It is sufficient that functions of a single row in the matrix have the same kernel. The proof of this conjecture will be the subject of further work. The classical Saturation algorithm for generating RSS of a structured model relies on storing reached states by MDDs and on encoding the next-state function as a Kronecker expression on sparse boolean matrices [18]. It exploits the possibility of firing any events affecting a given MDD node and its descendant nodes, thereby bringing the node to its saturated shape. Furthermore, nodes are considered in a bottom-up fashion (i.e., when a node is processed, all its descendant nodes are already saturated). A node is considered as saturated if it encodes a set of states which is a fixed point with respect to the firing of any event at its level or at a lower level. In contrast to previous work [18], we present a RSS generation method for SAN models, which allows event occurrence rates and routing probabilities may be expressed by functions (without any kind of restriction over their arguments). Our method also relies on storing reached states
Generate(in x˜: state) : node 1. declare l: lvl; 2. declare r, p: node; 3. p ← 1; 4. for l = 1 to N do 5. r ← NewNode(l); 6. r[x(l) ] ← p; 7. Saturate(r); 8. p ← r; 9. return r; Locals(in t: tensor, nf : node, p: node): set of states 1. declare l: lvl; 2. declare x: state; 3. declare Idx: set of state; 4. l ← p.lvl; 5. Idx ← ∅; 6. for all x(l) ∈ S (l) do 7. if (p[x(l) ] 6= ∅) then 8. if (l ∈ ωt) then 9. if (nf [x(l) ] 6= ∅) then 10. Idx ← Idx ∪ {x(l) }; 11. else 12. if (Nl,t (x(l) ) 6= ∅) then 13. Idx ← Idx ∪ {x(l) }; 14. return Idx;
Figure 3.
Saturate(in,out p: node) 1. declare l: lvl; 2. declare e: evnt; 3. declare te : tensor; 4. declare rf, nf, q, u: node; 5. declare x, y: state; 6. declare change: bool; 7. repeat 8. change ← false; 9. for each e ∈ E do 10. for each te ∈ T(l) do 11. rf ← RootNode(T F M ddte ); 12. for each x(l) ∈ Locals(te, rf, p) do 13. if (te is functional) then 14. if (rf.lvl = l) then 15. nf ← rf [x(l)]; 16. else 17. nf ← rf ; 18. else 19. nf ← ∅; 20. q ← Fire(te , nf, p[x(l) ]); 21. for each y (l) ∈ Nl,te (x(l) ) do 22. u ← Union(q, p[y (l)]); 23. if (u 6= p[y (l) ]) then 24. p[y (l) ] ← u; 25. change ← true; 26. until (change = false)
Pseudo-code of our RSS generation method for models which use functional transitions
as a MDD, nevertheless, next-state function is represented by reachability descriptor (i.e., by a generalized Kronecker representation) and we use yet T F M dd (Definition 6) for functional transitions. In Figure 3, we present the pseudo-code of our method for models which use functional transitions. Bold lines emphasize the major changes in our method in contrast to previous work [18]. In Figure 3, routine Generate is the initialization of the method, routine Locals retrieves from a node the set of locally “enabled” states to fire an event, routine Saturate controls node saturation condition, and routine Fire fires (recursively) events at lower levels. Saturating a node requires firing all possible events from this node3 . This is the reason why Saturate executes Fire. Saturate and Fire are mutually recursive: every new node generated during the execution of Fire will be saturated by the execution of Saturate. Our iteration set (routine Saturate, lines 9-10) is based on the set of tensor terms of RD (which are associated to the events). Given an event e ∈ E, a tensor te ∈ T associated to this event, ωe ∈ [1..N ] and ωte ∈ [1..N ], we denote Top(te ) = max ωe ∪ωte and Bot(te ) = min ωe ∪ωte . Given l ∈ [1..N ] an indice of an automaton, T(l) is the set of tensor terms defined as T(l) = {e ∈ E, te ∈ T : Top(te ) = l}. The major change in routine Locals is related to functional tensor terms (lines 8-10). Locals checks whether a functional transition represented by the matrices of t may occur from a local state x(l) encoded in node p (i.e., p[x(l) ] 6= ∅). So if x(l) is the input of any function which appears in the matrices of t (i.e., l ∈ ωt ), we must check whether local state x(l) is encoded in T F M dd of this tensor term t at level l (which 3 Remember
Fire(in t: tensor, nf : node, p: node): node 1. declare l: lvl; 2. declare s, nchild: node; 3. declare x, y: state; 4. l ← p.lvl; 5. if (l < Bot(t)) then return p; 6. s ← NewNode(l); 7. for each x(l) ∈ Locals(t, nf, p) do 8. if (t is functional) then 9. if (nf.lvl = l) then 10. nchild ← nf [x(l) ]; 11. else 12. nchild ← nf ; 13. else 14. nchild ← ∅; 15. q ← Fire(t, nchild, p[x(l) ]); 16. for each y (l) ∈ Nl,t (x(l) ) do 17. s[y (l) ] ← Union(q, s[y (l)]); 18. Saturate(s); 19. return s;
that a node and its descendant nodes encode a set of states.
implies that the function is non-zero when x(l) is a parameter value and the transition can be triggered), i.e., nf [x(l) ] 6= ∅. Node nf (“node of function”) is an auxiliary node which points to the node of T F M ddt at level l being examined. IV. E XPERIMENTAL RESULTS In this section, we show some modeling examples in order to evaluate the CPU time and memory efficiency of our RSS generation method implemented in the PEPS software tool [23]. For each example, we present a SAN model using functional rates and an equivalent SAN model using only constant rates, where extra synchronizing events, or even automata, have replaced these functions. We understand by equivalent models, the same stochastic behavior in both descriptions (i.e., both models have the same underlying Markov chain). Our aim is to explore the effect of using functional rates in our RSS generation method, comparing the results between these equivalent models. The numerical results presented in this section were obtained on a 2.2 GHz AMD Opteron workstation (with 8 dual-core processors) under Linux (Debian 2.6.23-1-amd64) operating system with 32 GBytes of memory, using only one processor and no virtual memory. For each experiment, we executed our method several times, excluding the best and worst results. They presented a low standard deviation and the average of such results are shown in Table I. A. Dining philosophers The classical Dining Philosophers is modeled by the SAN model presented in Figure 4 (a). In this SAN model, each philosopher is modeled by an automaton P (i) (where i ∈ [1..N ]) which has three states: T (thinking) denotes the philosopher thinks for a while; R (right) indicates the
philosopher took his right-fork; and L (left) denotes the philosophers took his left-fork. In this model, all events have a constant rate of occurrence and the initial state is: for all i ∈ [1..N ], philosopher P (i) is in state T . It is important to mention that the last philosopher (P (N ) ) is left-handed, i.e., in order to avoid a deadlock situation, he tries to take his left fork before his right fork. This problem can also be modeled using only local events with constant and functional rates. In Figure 4 (b), we present an equivalent SAN model to the model presented in Figure 4 (a), where synchronizing events (ri and li ) are replaced by local events. Moreover, the rate of synchronizing events ri and li in Figure 4 (b) is not a constant value, but a functional value expressed by functions f ri and f li respectively. The arguments of those functions are the states of neighboring philosophers, i.e., the states of philosophers P (i+1) and P (i−1) . l2 rN
R t2 T
R
R
r1
tN T
rN
l2 r2
l3
L
L
L
. ... .. .
r1
t1 l1
..
P
T
r1
rN
(2)
P (1)
P (N ) l1
lN
rN−1
l1
Type Event Rate Type Event Rate Type Event Rate syn r1 α1 syn l1 β1 loc t1 µ1 .. .. .. .. .. .. .. .. .. syn rN αN syn lN βN loc tN µN
(a) constant rates
P (1) T r1 R t2 T
L
L
R
r2
tN T
rN
l2 R
L
P (N )
lN
..
P (2)
t1 l1
. ... .. .
Type Event Rate Type Event Rate Type Event Rate loc r1 f r1 loc l1 f l1 loc t1 µ1 loc r2 f r2 loc l2 f l2 loc t2 µ2 .. .. .. .. .. .. .. .. .. loc rN f rN loc lN f lN loc tN µN
f l1 = (st(P (N ))! = R) × β1 f l2 = (st(P (1)) == T ) × β2
. ..
f r1 = (st(P (2))! = L) × α1 f r2 = (st(P (3))! = L) × α2
. ..
f lN = (st(P (N −1)) == T ) × βN f rN = (st(P (1))! = L) × αN (b) functional rates
Figure 4.
Dining Philosophers - SAN models
Comparing the results of both SAN models, the CPU time to generate the RSS for models with functional rates is slightly smaller than models with constant rates. For the model with functional rates, a given function f has only two automata as arguments (i.e., |ωf | = 2). The CPU time to generate all F uncM dd is really small, since these functions have a small domain size. In this case, as the local state space of any automaton is equal to 3 states, a given function has
a domain size equal to 3 × 3 = 9 states. Our experiments indicate that the use of functions (which have a small domain size) can slightly reduce computation time. In terms of peak memory, models with functional rates require less memory than models with constant rates. Those models represent the best-case scenario for our RSS generation method, since we can generate a huge state space (e.g., for N = 1, 000, | S |= 5.09 × 10382 states) in less than one second, while memory consumption is still low. B. Alternate Service Pattern (ASP) This model describes a small open network composed of four queues (Q1 , Q2 , Q3 and Q4 ) with finite capacities K1 , K2 , K3 and K4 respectively. The customers arrive in Q1 and Q2 with constant rates λ1 and λ2 respectively. Customers may leave from Q1 to Q3 , if and only if there is room in that queue (blocking behavior), whereas customers may leave from Q2 to Q3 only if there is room in that queue or leave the model otherwise (loss behavior). Customers may also leave from Q3 to Q4 with blocking behavior. While Q1 , Q2 and Q4 have a same average service rate for all customers (respectively µ1 , µ2 and µ4 ), Q3 has an Alternate Service Pattern behavior. The service rate of this queue varies according to N different service patterns (µ31 , . . . , µ3N ). Q3 can exchange its service pattern simultaneously with the end of service of a customer. So, when a customer is served by service pattern Pi , Q3 may serve the next customer in the same pattern with a given probability πii , or it can alternate to another service pattern Pj , with a given probability πij PN (for all service patterns Pi : j=1 πij = 1). The SAN model for this example is composed of one automaton for each single-service pattern queue (Q1 , Q2 and Q4 ) and two automata for the alternate service pattern queue (Q3 ). Let A(i) (i ∈ [1..4]) be the automaton representing the number of customers in Qi , and A(5) the automaton representing the current service pattern in Q3 . Local events e1 and e2 represent the arrival in queues Q1 and Q2 respectively, and local event e4 represents the departure from Q4 . Synchronizing events e13 and e34 represent the routing between queues Q1 and Q3 and Q3 and Q4 , respectively, and synchronizing event e23 represents both the routing from Q2 to Q3 and the departure from Q2 due to lack of room in Q3 (loss). In Figure 5 (a), we present the SAN model with constant rates for this example considering N = 2. The extension to a higher number of service patterns corresponds to the addition of more local states to automaton A(5) , which always has N local states. Note that there are two synchronizing events (e341 and e342 ) to model the change between the possible service patterns. Events e341 and e342 have constant rates equal to µ31 and µ32 respectively. In fact, a SAN model for an example with N service patterns has N synchronizing events e341 , e342 , . . . , e34N , each of them with constant rate µ31 , µ32 , . . . , µ3N respectively.
In Figure 5 (b), we present an equivalent SAN model to the model presented in Figure 5 (a), where there is only one synchronizing event e34 . Note that event e34 obviously synchronizes A(3) and A(4) , but it also synchronizes A(5) due to the (possible) exchange of service pattern. The use of routing probabilities related to event e34 represents the stochastic distribution of all the possible exchanges between the service patterns. Event e34 has a functional rate expressed by function f34 and it depends on the state of automaton A(5) . A(1)
A(2)
A(3)
A(4)
A(5)
0
0
0
0
P1
e13
e23
K1
e2 K2
e13 e23 e13 e23
K3
e4
...
e1
e341 e342 e341 e342
...
e13
e2
...
e23
...
e1
e4
e341 e342 e341 e342
e23
e341 (π12)
e342 (π21)
K4
e341 (π11)
P2
e342 (π22)
N
s234
Station 4
P back3
P out3
P3
P m4
P back4
P out4
P4
0
0
0
0
0
0
0
0
s123 b3 b3 s123 b 3 b3
N
r3 s234 r3 s234
N
ok3 s123 ok3 s123
N
s234 s234
r4 ok4 r4 ok4
N
s234 b4 b4 s234 b 4 b4
N
r4 out r4 out
N
ok4 s234 ok4 s234
N
out
...
r3 ok3 r3 ok3
s234
N
P m3
e34(π12)
out
N
e34
e4 K4
P2
e34(π22)
Type Event Rate Type Event Rate Type Event Rate loc e1 λ1 loc e2 λ2 loc e4 µ4 µ1 syn e23 µ2 syn e34 f34 syn e13
f34 = (st(A(5)) == P1) × µ31 + (st(A(5)) == P2) × µ32
(b) functional rates
Figure 5.
N
ok2 s123 ok2 s123
...
e23
r2 s234
...
K3
N
r2 s234
...
e34
e34(π11)
0
N
Station 3
e34 e34(π21)
N
s123
P2
0
...
e2 K2
e4
...
e23
...
e1 K1
e34
...
... e13
e2
N
ok1 in
s123
P out2
0
s123 b2 b2 s123 b 2 b2
...
e23
r1 s123
ok1 in
P back2
0
...
e1
b1
r1 s123
P m2 r2 ok2 r2 ok2
...
e13
b1
...
P1
0
...
0 e13 e23 e13 e23
0
...
0
0
in b1 in b1
...
0
0
...
0
P1
...
A(5)
P out1
...
A(4)
P back1
...
A(3)
Station 2
P m1
N
(a) constant rates A(2)
Station 1
r1 ok1 r1 ok1
Type Event Rate Type Event Rate Type Event Rate loc e1 λ1 loc e2 λ2 loc e4 µ4 syn e13 µ1 syn e23 µ2 syn e341 µ31 syn e342 µ32
A(1)
In Figure 6 (a), each station i (where i ∈ [1..4]) of the system is modeled by four automata: P mi indicates the number of pieces which are being processed by the station simultaneously; P backi denotes the number of pieces which must be re-processed; P outi indicates the number of pieces ready to leave the station; and Pi denotes the number of kanbans available in the station. Each automaton of a station has N + 1 states (from 0 to N ), where N is the number of kanbans available in the station. All events in this model are synchronizing and all event rates are constant values. The initial state of this model is: for all i ∈ [1..4], automaton P mi is in state 0; automaton P backi is in state 0; automaton P outi is in state 0; and automaton Pi is in state N .
ASP - SAN models
Type Event Rate syn r4 αr4 syn ok4 αok4 syn b4 α b 4 syn out αout
Station 2
P m1
P back1
P out1
0
0
0
P2
0
0
N
N
Station 3
r2 s234
N
ok2 s123 ok2 s123
N
s234
N
Station 4
P m3
P back3
P out3
P3
P m4
P back4
P out4
0
0
0
0
0
0
0
r3 s234
N
Type Event Rate syn r2 αr2 syn ok2 αok2 syn b2 α b 2 syn s234 fs234
s234 b4 b4 s234 b 4 b4
N
ok4
r4 out r4 out
N
Type Event Rate syn r3 αr3 syn ok3 αok3 syn b3 α b 3 loc in fin
...
s234
r4 ok4 r4 ok4
...
Type Event Rate syn r1 αr1 syn ok1 αok1 b1 α b 1 syn syn s123 αs123
N
s234
...
N
ok3 s123 ok3 s123
...
r3 s234
...
s123 b 3 b3 s123 b3 b3
...
r3 ok3 r3 ok3
s234
...
ok1
r2 s234
...
N
P out2
0
s123 b2 b2 s123 b 2 b2
...
N
r1 s123
P back2
0
...
b1
P m2 r2 ok2 r2 ok2
ok1
r1 s123
b1
...
in b1 in b1
...
r1 ok1 r1 ok1
...
This example presents a model of a manufacturing system with four similar stations, where “kanbans” (tags) control the flow of pieces. In Figure 6 (a), we show a SAN model that was inspired by SPN model presented in [2]. The overall flow of pieces is as follows: a piece come in station 1 first, then it is separated into two pieces that enters stations 2 and 3, and then these two pieces are connected into a single piece again that enters station 4, from which the piece leaves the manufacturing system. A piece can access a station only if a kanban is available at that station and, once processed, it undergoes a check to verify whether it needs to be reprocessed by the same station. In particular, a piece can leave station 1 only if there is a kanban at both stations 2 and 3, and it can leave station 2 (station 3) only if there is also a piece ready to leave station 3 (station 2) and a kanban available in station 4.
Type Event Rate syn r3 αr3 syn ok3 αok3 syn b3 α b 3 syn in αin
(a) constant rates
N
C. Kanban system
Type Event Rate syn r2 αr2 syn ok2 αok2 syn b2 α b 2 syn s234 αs234
Station 1
...
For the model with functional rates, function f34 has only one automaton as argument (A(5) ). As seen in Table I, the CPU time to generate all F uncM dd is really small (about 10−5 seconds) and the CPU time to generate M ddS for models with functional rates is also smaller than models with constant rates.
Type Event Rate syn r1 αr1 syn ok1 αok1 b1 α b 1 syn syn s123 αs123
ok4
N
Type Event Rate syn r4 αr4 syn ok4 αok4 syn b4 α b 4 loc out αout
fin = ((st(P m1) + st(P back1) + st(P out1)) < N ) × αin fs234 = ((st(P m4) + st(P back4) + st(P out4)) < N ) × αs234 (b) functional rates
Figure 6.
Kanban system - SAN models
This model can be presented in a different manner, Figure 6 (b), where automata P1 and P4 are no longer represented. Events in and out are now locals. Event in has its rate multiplied by function fin and this function is used to assure that the number of kanbans in station 1 not exceeding N , i.e., the sum of state indices of automata P m1 , P back1 and P out1 must not be greater than N . Moreover, synchronizing event s234 has a functional rate expressed by function fs234 . Function fs234 has a similar purpose in station 4 to function fin in station 1.
MDD nodes N |S| Final Peak Dining Philosophers (constant rates) 10 5.74 × 103 35 56 100 1.62 × 1038 395 596 1,000 5.09 × 10382 3,995 5,996 Dining Philosophers (functional rates) 10 5.74 × 103 35 83 100 1.62 × 1038 395 893 382 1,000 5.09 × 10 3,995 8,993 Alternate Service Pattern (constant rates) 5 1.64 × 1011 5 607 15 4.91 × 1011 5 607 11 25 8.18 × 10 5 607 Alternate Service Pattern (functional rates) 11 5 1.64 × 10 5 607 15 4.91 × 1011 5 607 25 8.18 × 1011 5 607 Kanban (constant rates) 10 1.01 × 109 256 287 100 1.73 × 1019 11,416 11,447 1,000 1.42 × 1030 1,014,016 1,014,047 Kanban (functional rates) 10 1.01 × 109 234 1,653 100 1.73 × 1019 11,214 1,042,233 1,000 1.42 × 1030 -
Memory (KB = 1,024 bytes) Final Peak 7 72 719
34 1,411 121,344
7 72 719
34 1,155 92,425
9 9 9
943 1,043 1,145
9 9 9
904 905 907
42 3,123 1,466,148
94 4,541 1,592,595
38 3,056 -
397 474,021 -
CPU time (seconds) to generate all F uncM dd M ddS 1.70 × 10−4 1.86 × 10−3 5.08 × 10−2 1.38 × 10−5 1.91 × 10−5 2.29 × 10−5 5.55 × 10−3 1.90 × 101 -
1.54 × 10−3 1.84 × 10−2 2.44 × 10−1 1.25 × 10−3 1.51 × 10−2 1.81 × 10−1 8.77 × 10−1 9.22 × 10−1 1.02 × 100 8.71 × 10−1 8.85 × 10−1 9.02 × 10−1 1.01 × 10−2 3.51 × 100 3.38 × 103 1.52 × 10−2 7.20 × 100 -
Table I R ESULTS FOR OUR MODELS
As seen from the results compiled in Table I, the CPU time to generate M ddS for SAN models with constant rates is smaller than SAN models with functional rates. SAN models with functional rates use two functions (fin and fs234 ) instead of automata P1 and P4 , which were used in SAN models with constant rates, and the domain of each function is equal to (N + 1)3 states. For those models with functional rates, the memory consumption grows fast due to the explicit generation approach used to obtain F uncM dd of a function. There is a great difference between the memory peak for these SAN models. This difference in memory peak prevents from analysing models with functional rates. So, the results for N > 100 are not shown in Table I. Note that the explicit generation approach to generate F uncM dd of a SAN model with functional rates is the bottleneck of our RSS generation method. In order to take advantage of the use of functions in the system modeling, it is always important to consider the domain size of a function. Functions which have a huge domain size can limit the RSS generation of a model. Despite such limitation, our method generates a large RSS (M ddS of about 1019 states), with a memory consumption which fits into any current workstation’s memory, in a reasonable CPU time (under a half minute). V. C ONCLUSION Saturation-based state-space generation is a successful symbolic method based on decision diagrams applied to generating state spaces of structured models. We presented in this paper an extension of the saturation method presented in [18], which permits the use of functional transitions. In this paper, our RSS generation method employs the use of SAN formalism to describe structured models. However,
any other high-level structured formalism, which has a generalized Kronecker representation, could be employed. Our method exploits all saturation’s benefits (concerning time and memory-efficiency) taking advantage of a compact representation coming from a SAN model description point of view [22]. Matrix decomposition to obtain a particular tensor format for the reachability descriptor (Section III-B) and the use of F uncM dd to represent the set of states for which the evaluation of a function is different from zero (Section III-A) are crucial elements for achieving our RSS generation method. Our method is able to construct a MDD representing the RSS of the SAN model (which uses functional transitions) of the dining philosophers problem from about 10382 states. This is a huge improvement when compared to the current RSS vector representation of SAN models. To our knowledge, the method presented in this paper is the first work to construct a huge reachable state space of a model which uses functional transitions. State space generation is the first step to analyze a model. For later analysis of the transition matrix, RD must consider the event rates. Additionally, we need to distinguish the equivalence classes according to function values (not only when these values are different from zero). Our experiments indicate that the use of functions (which have a small domain size) achieves the generation of large RSS with a small computational time, while keeping a low memory consumption. Regarding future work, we plan to find an efficient way to generate all F uncM dd in order to remove this restriction and compare the generality and effectiveness of our method with other methods which are not based on Kronecker algebra but, rather, on a description of the next-state function using MDDs.
R EFERENCES [1] M. Ajmone-Marsan, G. Balbo, G. Conte, S. Donatelli, and G. Franceschinis, Modelling with Generalized Stochastic Petri Nets. John Wiley and Sons, 1995. [2] A. S. Miner and G. Ciardo, “Efficient Reachability Set Generation and Storage Using Decision Diagrams,” in Proceedings of the 20th ICATPN, ser. LNCS, vol. 1639. Williamsburg, USA: Springer-Verlag, 1999, pp. 6–25. [3] P. Buchholz and P. Kemper, “Hierarchical reachability graph generation for Petri nets,” Formal Methods in Systems Design, vol. 21, no. 3, pp. 281–315, 2002. [4] A. Benoit, P. Fernandes, B. Plateau, and W. J. Stewart, “On the benefits of using functional transitions and Kronecker algebra,” Performance Evaluation, vol. 58, no. 4, pp. 367– 390, 2004. [5] A. Benoit, B. Plateau, and W. J. Stewart, “Memory-efficient Kronecker algorithms with applications to the modelling of parallel systems,” Future Generation Computer Systems, vol. 22, no. 7, pp. 838–847, 2006. [6] S. Gilmore, J. Hillston, L. Kloul, and M. Ribaudo, “PEPA nets: a structured performance modelling formalism,” Perfor. Evaluation, vol. 54, no. 2, pp. 79–104, 2003. [7] W. H. Sanders and J. F. Meyer, “Stochastic Activity Networks: Formal Definitions and Concepts,” in Lectures on Formal Methods and Performance Analysis : First EEF/Euro Summer School on Trends in Computer Science, ser. LNCS, vol. 2090. Berg En Dal, The Netherlands: Springer-Verlag, July 2001, pp. 315–343. [8] W. Reisig, Petri nets: an introduction.
Springer, 1985.
[9] E. Pastor, O. Roig, J. Cortadella, and R. M. Badia, “Petri net Analysis Using Boolean Manipulation,” in Proceedings of the 15th ICATPN, ser. LNCS, vol. 815. Zaragosa, Spain: Springer-Verlag, 1994, pp. 416–435. [10] P. Buchholz and P. Kemper, “On generating a hierarchy for GSPN analysis,” ACM Performance Evaluation Review, vol. 26, no. 2, pp. 5–14, 1998. [11] G. Ciardo, G. L¨uttgen, and R. Siminiceanu, “Saturation: An Efficient Iteration Strategy for Symbolic State-Space Generation,” in Proceedings of the 7th TACAS, ser. LNCS, vol. 2031. Springer-Verlag, 2001, pp. 328–342. [12] A. S. Miner, “Saturation for a General Class of Models,” IEEE Transactions on Software Engineering, vol. 32, no. 8, pp. 559–570, 2006. [13] T. Kam, T. Villa, R. K. Bryaton, and A. SangiovanniVincentelli, “Multi-valued decision diagrams: theory and applications,” Multiplie-Valued Logic, vol. 4, no. 1-2, pp. 9–62, 1998. [14] A. S. Miner, “Effcient state space generation of GSPNs using decision diagrams,” in International Conference on Dependable Systems and Networks (DSN 2002), Washington, DC, June 2002, pp. 637–646.
[15] A. S. Miner and S. Cheng, “Improving efficiency of implicit Markov chain state classification,” in Proceedings of the 1st QEST. Washington, DC, USA: IEEE Computer Society, 2004, pp. 262–271. [16] G. Ciardo and A. J. Yu, “Saturation-based symbolic reachability analysis using conjunctive and disjunctive partitioning,” in Proceedings of the 13th CHARME, ser. LNCS, vol. 3725. Saarbr¨ucken, Germany: Springer, 2005, pp. 146–161. [17] M. Wan and G. Ciardo, “Symbolic State-Space Generation of Asynchronous Systems Using Extensible Decision Diagrams,” in Proceedings of the 35th SOFSEM, ser. LNCS, vol. 5404. Spindleruv Ml´yn, Czech Republic: Springer, 2009, pp. 582–594. [18] G. Ciardo, G. L¨uttgen, and A. S. Miner, “Exploiting interleaving semantics in symbolic state-space generation,” Formal Methods in System Design, vol. 31, no. 1, pp. 63–100, 2007. [19] B. Plateau, “On the stochastic structure of parallelism and synchronization models for distributed algorithms,” in Proceedings of the 1985 ACM SIGMETRICS conference on Measurements and Modeling of Computer Systems. Austin, Texas, USA: ACM Press, 1985, pp. 147–154. [20] B. Plateau and K. Atif, “Stochastic Automata Networks for modelling parallel systems,” IEEE Trans. on Software Engineering, vol. 17, no. 10, pp. 1093–1108, 1991. [21] W. J. Stewart, Introduction to the numerical solution of Markov chains. Princeton University Press, 1994. [22] L. Brenner, P. Fernandes, and A. Sales, “The Need for and the Advantages of Generalized Tensor Algebra for Kronecker Structured Representations,” International Journal of Simulation: Systems, Science & Technology, vol. 6, no. 3-4, pp. 52–60, February 2005. [23] L. Brenner, P. Fernandes, B. Plateau, and I. Sbeity, “PEPS2007 - Stochastic Automata Networks Software Tool,” in Proceedings of the 4th QEST. Edinburgh, UK: IEEE Computer Society, 2007, pp. 163–164. [24] G. Ciardo and A. S. Miner, “Storage Alternatives for Large Structured State Spaces,” in 9th International Conference on Modelling Techniques and Tools for Computer Performance Evaluation, ser. LNCS, vol. 1245. St. Malo, France: Springer-Verlag, 1997, pp. 44–57. [25] G. Ciardo, R. L. Jones, A. S. Miner, and R. Siminiceanu, “SMART: Stochastic Model Analyzer for Reliability and Timing,” in Tools of Aachen 2001 International Multiconference on Measurement, Modelling and Evaluation of ComputerCommunication Systems, Aachen, Germany, September 2001, pp. 29–34. [26] A. Sales, “R´eseaux d’Automates Stochastiques: G´en´eration de l’espace d’´etats atteignables et Multiplication vecteurdescripteur pour une s´emantique en temps discret,” Ph.D. dissertation, Institut Polytechnique de Grenoble, France, 2009. [27] P. Fernandes, B. Plateau, and W. J. Stewart, “Efficient descriptor - Vector multiplication in Stochastic Automata Networks,” Journal of the ACM, vol. 45, no. 3, pp. 381–414, 1998.
