From Task Graphs to Petri Nets

From Task Graphs to Petri Nets Anthony Spiteri Staines Department of Computer Inf. Systems, Faculty of ICT, University of Malta Abstract This paper describes the similarities between task graphs and Petri nets and explains how a well formed task graph can be converted or transformed into a Petri net for verification, validation and checking using incidence matrix analysis, invariants and the reachability graph. A case study is presented, results and conclusions are given. Keywords, Petri nets, Task Graphs, Transformation, Verification, Well formedness I. INTRODUCTION Graph based models are becoming increasingly important for representing different computer and computational problems. One of the key points in these models is that they are decomposable. [1]-[4] Different modeling notations and diagrams used are just variants of basic directed or undirected graphs. Task Graphs (TGs) are used to model the flow of events or tasks in a predefined order in a system [13]. Precedence constraints are important for the temporal ordering of events in a system. Most computational problems are decomposable into a collection of independent operations. These operations or tasks are normally depicted as vertices or nodes in a cycle free digraph. The graph edges show the dependencies between the tasks. Tasks are executable in parallel or serially, depending on the inputs available. Problems that can be broken down either into individual tasks that have some form of ordering and precedence constrains or task dependencies can be represented using task graphs. Basic TGs share some common features with other forms of graphs and diagrams from the UML like activities, sequence and communication diagrams [12]. At the basic level TGs have a main or central i)start node and a ii) termination node. The tasks would branch off from the start or source node. Tasks start only when the preceding tasks have completed. Petri nets are graphical and mathematical formalisms that are based on bipartite digraphs, sharing common properties with TGs. Petri nets offer modeling for concurrent, asynchronous, distributed, parallel, nondeterministic and other forms of behavior [5],[6]. Consequently both TGs and Petri nets are visual formalisms. They exhibit some structural similarities, thus intuitive transformation is possible. Extensive work has been carried out in both areas. 36 Both TGs and Petri nets have additional notations and elements that can increase their modeling power and use. However, the use of additional notations, apart from increasing the modeling power, implies that the final model is increasingly complex and applicable only to specific scenarios. TGs provide an interesting medium to study and analyze the behavior of different types of computational problems in the field of modern computing and real time scenarios. TGs are directly and indirectly related to other formalisms and constructs. Repeated patterns can be identified here. Unfortunately, TGs need to be properly validated and verified. It is possible to construct TGs that have some mistakes in them. TGs share some similar properties with Petri nets as both are based on digraphs. A solution to verify TGs is to transform them into basic Petri nets for validation, verification and execution. Obviously there are size related problems both to TGs and Petri nets. The more complex and large the model, the more difficult it is to verify. This can be called the state explosion problem that is common with large Petri nets. Reduction techniques can deal with simplifying this problem. This paper addresses TGs and their possible transformation into basic Petri nets from a practical perspective. The reason for transforming TGs into Petri nets is for detailed verification, analysis and experimentation. Petri nets have special properties that can be used to comprehend the static structure of simple or basic task graphs [11]. Classical task graphs are normally acyclical, however it is possible to include cycles depending on what is being modeled. Simple Petri nets share some similarities with augmented marked graphs [1],[2]. II. BACKGROUND Task graphs are used for computations that are based on logical temporal ordering of tasks or sub-tasks. TGs are useful for modeling program flows and control, inter program or inter process communication and synchronization, system dependencies in large scale software [13]. Thus they are useful for control systems, A.I., modeling game theory, intelligent agents, semantic web, fault representation, distributed computer systems, O.S. task loading, etc.

Basic TGs are acyclical, consisting of fork or join nodes. For modeling loops, conditional branching, etc. different types of nodes have to be added, such as branch or merge nodes. These types of TGs are called extended TGs (ETGs) [10]. Both Petri nets and TGs have a visual graphical way or representation. TGs share some similarities with automata, state machine diagrams, network flow graphs and other various graph formalisms. III. PROBLEM FORMULATION Task graphs are well suited for modeling a diversity of computer system problems. However they suffer from some issues, evidenced when creating and using them. These can be considered as design or structural problems. Unfortunately the verification of TGs is not a straightforward or simple task. The complexity of verification is that the structures created, which are a collection of systematic components, have to demonstrate proper behavior and communication. The more complex the model the more difficult it is to examine its properties. There are different methods that can be used to verify the task graphs, however some of the methods based on proofs, etc are quite tedious and take a considerable amount of effort. More practical and simple approaches are necessary from a user s perspective. When considering simple task graphs the problem of verification is mainly structurally related. These issues can be summarized as follows: i) the TG could have proper source or termination missing. i.e. the source node and the sink nodes might be missing or improperly connected. ii) a TG can have conditions or a structure that leads to a deadlock state. iii) TG can have a state that never is initialized or reached. This can happen because of certain conditions. iv) unbounded states could exist in the TG. v) no proper synchronization between the tasks can exist. A task graph that is free from these problems is said to be a well formed TG. Well formed task graphs free from unnecessary complexities are highly desirable and important for proper behavior analysis. Studying networks like TGs provides many useful ways for visualizing, representing and analyzing interconnected components. IV. PROPOSED SOLUTION Petri nets seem to be more expressive than normal or classic task graphs. They offer a wide range of modeling and dynamic properties that can be mathematically and formally verified. The transformation of TGs into Petri nets is rather intuitive and easy to follow. If complex types of TGs are considered then we deviate from the original TGs. 37 The reachability analysis of an equivalent Petri net model can be used to verify the main properties of a TG and if it is a well formed. Different classes of Petri nets offer different types of verification. These could be useful for more complex TGs. Simple TGs that are free from conditional branching can be simply transformed in to choice free Petri nets. This implies that each place in the Petri net, unless it is represents a sink or source node, has exactly one input and output arc. If the TG is extended to include conditional branching, in the corresponding Petri net there is choice, but only one transition is enabled by this choice. Petri net analysis of TGs can be extended to acyclical as well as cyclical TGs and even more complex types of TGs. A. Types of Task Graphs Considered Only simple or basic task graphs are considered in this work. It can be inferred that basic TGs will cover the mainstream needs. Another reason is that other classes of extended task graphs do not follow the regular behavior and intention of basic task graphs. I.e. the behavior of nodes in the graph can vary greatly thus creating unnecessary complexities. These types of task graphs can be called higher order task graphs. The behavior of extended or higher order task graphs deviates from the original intention of TGs and their practical use. B. Definitions about Basic Task Graphs Some assumptions are necessary to explain our task graphs. By definition, a task graph is an ordered pair of elements G=(V,E), where V is a finite set of vertices V={v 1,v 2,.,v n } and E is a finite set of edges E ={e 1,e 2,..,e n }. The nodes or vertices represent the tasks and the edges connect and order the tasks or activities. The finite set V can be considered as containing two special types of nodes. I.e. a i) source node and a ii) sink node. An edge e is connected between two vertices. I.e. an edge ej is an ordered connected pair (v j,v k ) where v j,v k V. v j v k, normally the TG is free from self loops. Also as the TG is a digraph edges expressed as v 1,v 2 normally (v 1,v 2 ) (v 2,v 1 ). I.e. the graph is loop free. Edges can have labels, values, weights or costs associated with them. For simple TGs the edges are of similar type. Task ordering is implied in the relationships or precedence constraints in the task graph. The given path between two vertices v 1 and v n is represented as a set of ordered set of vertices (v 1,v 2,.,v n ); where (v j,v j+1 ) is an edge of a graph given as 1 j n-1 but it does not necessary always hold as the TG is a digraph and for a given path (v 1,v n-1,.,v n ); normally (v i,v i+1 ) (v i+1,v i ). Two vertices (v i,v j ) are said to be path connected iff there exists some path from v i to v j.

The cost of a path (v j,v n ) can be given as the sum of the n cost of the edges. E.g. C = 1 w ( v, ) j 1 j v. j 1 A cycle in the graph is represented as a connection back into a previous task but not into the task itself or as a loop. To extend the task graphs it is possible to extend the set of vertices or nodes V to contain other elements and the set of edges E to contain other edge types. C. Some Considerations about Task Graphs Some assumptions about the TGs considered are necessary: i) A task is called simple if it has exactly one outgoing and exactly one ingoing edge. ii) The execution of the task graph has to occur from the initial source or start node. iii) The termination of the task graph has to occur at the sink or final node. The basic node type of the TG can be extended to contain two types of main nodes apart from the source and sink nodes. These task nodes can be an And node or an Or node. The And nodes are the normal and most common ones. And nodes are depicted using circles and they imply that all previous tasks have to be complete before the task of the And node is performed. On the other hand the Or nodes are depicted using a square or rectangular shape. The Or nodes imply that previous tasks do not need to be all completed for the Or task to start. To transform an Or node into its Petri net counterpart, more detail is required. The Or node introduces choice or conflict in the Petri net. Hence both the TG and Petri net are more complex. D. Assumptions for the Transformation For considering the transformation, the task graphs must be limited in size. I.e. the larger the task graph, more than 100 task nodes, the more complex will the transformation be, but it is still achievable. For this precise reason this work focuses on TGs that are limited in size or reduced. E. Transformation into Petri nets Transformation of TGs into Petri nets is straightforward and intuitive. There are exceptions when considering the source and sink nodes. Another exception is the Or node which requires different treatment from the other nodes. The high level algorithm briefly outlined below, explains the transformation approach. -------------------------------------------------------------- Algorithm 1: Convert TG into a basic Petri net --------------------------------------------------------------- INPUT : Well formed simple TG OUTPUT: Basic Petri net PROCEDURE STEP 1: Select unconverted TG. 38 STEP 2: Start Transformation STEP 3: Traverse TG from start\source node STEP 4: If start node create Place -> Output arc- >start transition STEP 5: Loop IF no exception represent TG edge in Petri net as output arc-> and represent TG normal node in PN as a transition. IF exception e.g. OR node in TG Represent previous tasks as parallel Transitions But have a single input place and a single output Place (i.e. choice in Petri net) do connect Until ( sink node/ termination node is reached) STEP 6 End Transformation Algorithm 2: Connect STEP 1: Connect input arc/s to place & transition STEP 2: Connect output arc/s to transition and place STEP 3: End F. Verification and Validation Possibilities The TG in the form of Petri nets offer many possibilities for verification and validation. The simpler the Petri net, the easier is its verification and validation. At a basic level the Petri net can be represented using two matrices, i) input flows and ii) output flows. These matrices will have certain properties that show repetitive pattern behavior of the task graph. I.e. inside the matrix it is possible to find sub matrixes with circulant properties. From the input and output flow matrixes, the incidence matrix for the Petri net can be derived. This is C ij =I ij -O ij where I ij is the input flow matrix and O ij is the output flow matrix. The incidence matrix expresses important structural properties of the net. I.e. if the sum of a complete row containing non zero values is zero then this implies that the number of outputs and inputs of a transition are equal. Different properties like i) reachability, ii) boundedness, iii) safeness, iv) conservativeness, v)liveness, vi) reversibility, vii) homestates, viii)cyclical or acyclical behavior etc. can all be used to verify and validate the Petri net TG model. These qualities can be confirmed or checked using place and transition invariants. Transition invariants confirm that there is a repetitive firing cycle. These properties can be used to confirm that the Petri net is deadlock free and is structurally sound and safe. I.e. in simple terms it is properly constructed and error free for the intended purpose of representing the TG.

G. Task Graph Execution via Petri Nets The resultant Petri net offers straightforward execution. This is not directly possible with the task graph. Execution of the Petri net is quite straightforward and involves the firing of the transitions that represent the task nodes in the TG. The execution of the Petri net on a simulation tool or other indicates the correctness of the net which in turn indicates the validity of the task graph. The reachability graph or tree, also known as the marking graph, can be constructed to prove the correctness or execution of the Petri net. The depth of the reachability graph indicates the complexity of the task graph. H. Reducibility/Reduction One of the greatest problems, in the construction and verification of Petri nets and TGs, is space related. The objective of reduction is always to simplify and increase the effectiveness of Petri net analysis [7]-[9]. Given an ever increasing model size, space requirements become the bottleneck. Any methods for reducing the model size are welcome because the modeling and state space problems are reduced. For task graphs and Petri nets the concept of reducability can be normally applied because it is possible to find subnets or sub graphs from main structures. The TG reduction implies finding patterns like sequential behavior and combining sequential tasks into a single general task. The same principle can be applied for parallel tasks. Reduction in this case from the view of the Petri net, implies fusion or augmentation of places in series or sequential and fusion of sequential transitions. Parallel places and transitions can also be reduced. The principle of reduction is just mentioned. It otherwise requires detailed treatment beyond the scope of this work. The most important point is that whatever reduction rules are applied to the Petri net, the main properties must still be preserved for it to make sense. Fig. 1 Task Graphs to Petri Net Correspondence for Transformation Fig.2. A Simple Task Graph 39

V. A CASE STUDY EXAMPLE A simple toy example of a TG having several task nodes, an and or parallel node and an or node is used to illustrate the main concepts. The diagram in fig. 2 shows the TG that is to be transformed into a Petri net. Using the information in fig. 1 and the algorithm previously outlined, the transformation is very simple. The resultant Petri net is shown in fig. 3. It is noted that a cycle has been added in the net. Fig.3. Resultant Petri Net 40 This is from the sink place p13 to the source place p1 via transition t12. The cycle is shown as a dotted line. A. Incidence Matrix Analysis VI. RESULTS AND FINDINGS An incidence, change or flow matrix C ij for the Petri net is simple to construct and represents the ordered input and output flows. The rows represent places {p 1..p 13 } and the columns the transitions {t 1..t 12 }. The Incidence matrix is given as C ij = I ij -O ij. Where I ij are the input flows i.e. the flows from a place to a transition and O ij are the output flows, i.e. the flows from a transition to places. The incidence matrix represents the structure of the net. The individual sum of the elements of a non empty row having exactly two elements 1 and -1, imply that the place represented by that row, has exactly one input and one output. I.e. it can be defined as a simple or straight forward place. The individual sum of the elements of an non empty column having exactly two elements 1 and -1, imply that the transition represented by that column has exactly one input and one output arc, and also one input and one output place. I.e. the transition can be defined or called a simple transition. This is significant because it means that the transition represents a simple task. A simple task has only one point of entry and one point of exit. Source, sink, and or nodes do not qualify as simple tasks. The incidence matrix can be used to perform simple structural checks about the accuracy of the Petri net and the TG. Many interesting inferences can be derived from this. B. Invariant Analysis A place invariant is denoted by the existence of vector m t v Z iff v Cij = 0. A transition invariant is denoted by the existence of a vector M y Z iff C ij y = 0 denoting a repeatable pattern or firing sequence. The Petri net is completely covered by place and transition invariants. This is significant because it implies deterministic behavior. C. Coverability Graph For this simple Petri net the coverability graph can be constructed just by fining the transitions and recording the current markings. The marking graph is denoted as follows: t t2 t M M M... n 0 1 1 2. M n

TABLE I RESULTS SUMMARY FOR TASK GRAPH PETRI NET VALIDATION Property Details Result 1 Completeness Indicates if the TG is complete. It is derived from the Petri net OK, YES 2 Well- Formedness 3 Simple Task Graph Or Task Graph has some simple properties 4 Complex Tasks 5 Petri Net Verifiability Fig.4. Incidence Matrix Obtained from various Petri net properties. Obtained from Petri net invariants, cycle, incidence matrix etc. Observed from Incidence matrix and connectivity of the net Major Petri net static and behavioural properties like invariants, boundedness, reachability, liveness etc. 6 Executability Petri net is fully executable YES YES, signifies that the task graph has some simple tasks. Task Graph has some Complete, Implies that the there are no errors in the Petri net and it has significant properties Observed from executing the Petri net and the reachability graph 41 The coverability graph, reachability graph or marking graph for the given Petri net is finite. The coverability graph has not been shown. There are different ways of representing the coverability graph. The coverabilty graph is similar to a state transition diagram for the task graph. D. Main Properties From the invariant analysis, execution and the reachability tree or graph, the proper behavior of the Petri net can be explained. This Petri net is i) bounded, it can be classified as a ii) 1-safe net implying that every place in the net can hold one token exactly but not more. It is a iii) conservative net, i.e. there is no loss of tokens, iv) liveness has been obtained through the adding of the cycle. V) behavior is cyclical. The markings of the Petri net are vi) reversible and the net has vii) homestates because it returns to the original state. There are no dead markings and every transition can fire. The Petri net forms a complete circuit this is because of the addition of transition t12. E. Relevance for Validating the Task Graph The analysis of the Petri net in fig. presents some interesting findings. Even though at a first glance the task graph looks simple this might not be the case. The fact that there is an or task introduces choice. Obviously by default if the places are given a restricted capacity that at maximum they can contain only one token, the net would still be a 1-safe net. Here this is not necessary as the place and transition invariants and the marking graph show that places will have a restricted capacity of 1 at maximum. The fact that the Petri net is completely covered by place invariants and transition invariants indicates that there is no design flaw or problem in the task graph even if the task graph has some different type of nodes. If the OR task nodes were to be removed the TG and the resultant Petri net will be further simplified. Completeness of the task graph is indicated because it has a start and end or termination point, i.e. a source and sink node. The well formedness property can be inferred from the Petri net analysis because of the limited coverability graph, the existence of invariants and the properties like boundedness and1-safeness. Table 1 presents a concise form of the results for the TG conversion and analysis using Petri nets. The details have been omitted for the sake of simplicity. Other results like the maximum number of possible markings, the drawing of the marking graph, etc. are available. It can be clearly inferred that the TG is safe and complete in the sense that there are no apparent problems inherent in this structure. There is a strongly connected component in the net.

VII. CONCLUSIONS Simple task graphs have been considered for transformation into Petri nets. This can be done quite simply and basic Petri net verification techniques can indicate if there are problems with the TG. It is possible to have Or nodes then other types like Xor and even logic gates can be added to the task digraph and it might no longer be called a TG but will resemble more of a logic or control circuit. As the circuit can represent main levels of complexity, assumptions about the TGs considered will be necessary. Problems will arise if complex TGs with over 100 nodes are considered. The solution is to reduce the TGs by removing repetition as explained. The atomicity of the solution is based on reduction and repeated simplification of the TG. REFERENCES [1] Cheung, K. S. 2008. Augmented Marked Graphs and the Analysis of Shared Resource Systems, Petri Net, Theory and Applications, Vedran Kordic (Ed.), ISBN: 978-3-902613-12-7, InTech, DOI: 10.5772/5326. Available http://www.intechopen.com/books/petri_net_theory_and_application s/augmented_marked_graphs_and_the_analysis_of_shared_resource _systems. [2] Cheung, K.S. and Chow, K.O. 2007. Compositional Synthesis of Augmented Marked Graphs, Control and Automation, ICCA, IEEE, pp. 2810-2814. [3] Hawryszkiewycz, I.T. 2001. Introduction to Systems Analysis and Design, Prentice Hall, ISBN: 1740092805, 978174009280 [4] Burns, A. and Wellings, A. 2009. Real Time Systems and Programming languages, Addison Wesley Longmain, ISBN: 978-0- 321-41745-9 [5] Zhou, M. and Venkatesh, K. 1999. Modeling, Simulation, and Control of Flexible Manufacturing Systems A Petri Net Approach, Series in Intelligent Control and Intelligent Automation vol. 6 World Scientific, MA USA. [6] Murata, T. 1989.Petri nets: Properties, analysis and applications, Proc. of IEEE, vol.: 77, issue:4, pp. 541-580. [7] M.B. and Clarke, L.A. 1996. A compact Petri net representation and its implications for analysis, IEEE Transactions on Software Engineering, vol. 22, issue 11, pp. 794 811. [8] Sloan, R.H. and Buy, U. 1996. Reduction Rules for Time Petri Nets, Acta Informatica, Vol. 33, Issue 5, Springer-Verlag, pp. 687-706. [9] Stemersch, G. and Boel, R.K. 2005. Structuring acyclical Petri Nets for Reachability Analysis and Control, International Journal of Intelligent Control and Systems, vol. 10, no. 2, pp. 175-187. [10] Ghodsi, M. and Kant, K. 1991. Well-Formed Generalized Task Graphs, Proceedings of the 3 rd IEEE Symposium on Parallel and Distributed Processing, pp. 344 351. [11] Cortés, L.A. Eles, P. and Peng, Z. 2002. Verification of Real-Time Embedded Systems using Petri Net Models and Timed Automata, Proc. of RTCSA Conference, pp. 191-199. [12] OMG UML 2 Superstructure Specification 2012., OMG, http://www.omg.org/technology/documents/formal/uml.htm [13] Liu, J.W. S. 2000. Real-Time Systems, Pretence Hall, NJ. 42