Enterprise software systems are usually large and complex. They can have complicated architecture and millions of diferent states. It is dificult to imagine a process of designing new software system or analysis of developed system without various modeling techniques. Visual presentation of the software system structure and behavior provides possibilities which can facilitate better analysis. Graphical notation of the Petri net formalism is often used for software system description. An extension of Petri net is the high-level Petri net formalism can be successfully used for the description of modular software systems. There are a lot of related tools that can be used for “static” visualization of high-level Petri net. The current work considers possible methods of dynamic visualization of high-level Petri nets which describe software system from behavioral perspective.
Complexity of enterprise software systems steadily grows year by year, release by release [
Modern software systems are characterized by large number of independent processes. For
instance, they are often implemented in service-oriented style. Service-oriented architecture (SOA)
represents a system as a set of independent components which provide services to another modules
via communication protocols over a network. Components often have shared resources, for example,
common data storage. As a result, enterprise systems confront two important issues: data integration
and data sharing [
Modern enterprise systems are too complex to analyze them as a single artefact. So that displaying software systems as a plain graph will not be helpful. There are several approaches to reduce the perception of complexity such as grouping or abstraction. For example, a dozen of modules of the b) system could be grouped by any common feature and could be considered as a single element with hidden details.
Hierarchical high-level Petri net is an extended formalism with the basic idea of constructing a
large model by combining a number of small Petri nets into a larger net [
But visualization of “static” structure of the system does not cover all aspects of systems description. Behavioral (or “dynamic’) aspect of a system is as important as its structure. In this paper we try to ifnd ways to answer the question “How to visualize dynamics of a complex hierarchical system?”
As Petri nets language is not only a mathematical formalism but graphical notation as well, it could be used for software system visualization. We have already mentioned in Introduction section that modern enterprise software systems are developed with a module-based approach. Modules can be fully separated on the same level of hierarchy or nested into other modules, and anyway their internal states are independent and communication between modules carried out overall network. But nonetheless the modules often share common resources such as data. The extension of ordinary Petri nets is the high-level Petri net formalism. It could be used for building visualizations of such systems. Each module of the system can be represented as a single ordinary Petri net. And then, a set of ordinary Petri nets can be aggregated to a hierarchical high-level Petri net to represent system as a whole.
There are several approaches for high-level Petri net visualization. One of them is hierarchical
layered-layout visualization [
This method is useful for static analysis of Petri net structure, when users are able to collapse needless element nets to hide redundant structures and expand element nets which are needed to be analyzed to investigate them in detail. But this approach does not support any dynamic features. In this work, we are going to consider dynamic visualization of real behavior of the system.
Let’s imagine that user has already had a software system prototype or a fully developed system. And the model of the system is described in the high-level Petri net formalism. It is possible to run the system on a test data and gather produced logs. Surely the logging part of the system should be prepared in advance: logs should be presented entirely and in appropriate format. Each event record should contain at least: • timestamp; • identifier of log activity (it’s needed to define a related transition of the Petri net model); • thread identifier (for multi-thread or multi-agent environments).
These logs can be used for replaying and visualizing system behavior on a high-level Petri net model.
In this project, our aim is to achieve convenient visualization techniques by combining ideas from graph drawing, process visualization, and introducing completely new ideas.
Existing approaches to visualize process dynamics in information systems came mostly from process modeling and process mining fields. In process modeling, many tools have been developed to edit process models, show them graphically. They allow us to view and change model structure. Such tools often enhanced with a simulation module/plug-in that is able to execute model step-by-step showing changes in model state to the user.
Let us consider several examples of modeling tools and editors. One of the tools applied in business
process management education is WoPeD [
Another tool to deal with ordinary Petri nets is called Carassius [
Carassius supports simulation of ordinary Petri nets. In this mode, a user can study how a system modeled by the Petri net is executed due to P/T-net semantics. Figure 2 shows how Petri net simulation looks in Carassius. Here the intensity of blue coloring depicts the time from the firing of a transition. Yellow token is the one that has been produced at the last simulation step.
At the same time, approaches have been proposed to visualize static structure of high-level Petri
nets of diferent types. Coloured Petri nets are one of the most commonly used type of high-level
Petri nets. They support a concept of hierarchy and complex control-flow constructs. CPN Tools [
Reference nets is another type of high-level Petri nets which support the concept of hierarchy. Also
these nets support data-flow modeling. Renew [
What is common in all these tools supporting Petri net modeling? Models are shown using basic graph drawing algorithms. Moreover, special algorithms for Petri net drawing can apply the fact that an ordinary Petri net is s bipartite graphs. Petri net structure can be shown in a flat view independently of their type. They have nodes and arcs of diferent types which are shown by rectangular, ellipse, and arrow forms of diferent appearance. Petri net marking is usually shown by tokens in place nodes. These tokens graphically depicted as dots or small circles inside larger places. Marking can also be shown by a number of tokens in a corresponding place (like in Figure 4).
It is important to mention that usually editors can not really show dynamics. They show static pictures or GUI with structure and state of modeled system. These pictures are able to change because of the user action.
Rather diferent approach for visualizing process dynamics can be found in process mining. ProM
Framework [
Fuzzy mining [
As earlier, we have a graph-based process model. Nodes represent process activities, while arcs represent relations between these activities. For example, an arc connects two nodes if there is a directly-follows relation between the two corresponding activities. Thus, the process structure is shown. But we also can see black tokens which are actually moving through the model. Active arcs are shown in red coloring. We can also see frequency of activities: frequent ones became dark-red after several times.
Another tool with the same capability is called Inductive visual miner [
Both these approaches show to the user how real behavior from and event log can be replayed on the
corresponding process model. Commercial tools like Fluxicon Disco [
Visual representation of process dynamics as process movies has been also researched for declarative
on-line discovery [
The goal of our project is to combine ideas of static graph-based model visualization for high-level Petri nets with the concept of “process movies” from process mining which allow us to show process dynamics recorded in event logs.
There are several dificulties related to dynamic visualization of software system behavior with highlevel Petri nets. If the system is displayed as a whole, users will disperse concentration due to high amount of redundant information. On the other hand, if the most system modules (element nets) are collapsed as it feasibly in layered-layout approach, users will have a chance to lose important details hidden in collapsed nets. Therefore, a method of auto hiding/exposition of element nets should be proposed to maintain completeness-clarity visualization balance between details and system complexity.
Let us summarize the main objective of the project. The main objective is to develop visual analytics methods which will successfully catch process dynamics in multi-agent systems represented as highlevel Petri nets. Proposed methods should take into attention key properties of multi-agent systems: their complex and hierarchical multilevel structure; dynamic asynchronous agent activities, communications and collaborations; large number of events and activities in such distributed systems. It is of most importance to support user with visual tools to highlight the most important fraction of system behaviour while shading immaterial detail. As navigation device shows only roads which are important for driver, visual analytics tool should assist a researcher by highlighting the most significant model parts.
We are going to introduce the four variables intended for automatic decision making on the displaying/hiding element Petri nets during dynamic visualization of high-level Petri net model of the system based on logs: • rate of event importance; • time interval of calculation; • distance between time intervals; • displaying threshold.
Let us consider proposed values on the example of a typical learning management information system (LMS). The system has a lot of diferent modules. Also, this system has been modeled using the high-level Petri net formalism. In graphical notation, each module of the system is depicted as an element Petri net. Also, system logs were translated into Petri net run. For example, the system has an event - user submitted login and password. This event could be transformed into the following part of the run: input tokens 1 (login), 2 (password) were removed from the place 1 and output token 3 was added to the 2 with firing of transition .
One of the modules is an academic discipline support module. This module provides functions related to learning process such as updating course info, uploading homework exercises by students.
The idea is to assign weights or measure of importance for each activity of the system. This measure should be allocated by user to distinguish significant events and secondary events. The value of rate of event importance will be taken into account to make a decision whether to display the element net to which the activity belongs or not. The value of rate of event importance belongs to the interval . [0; + )8
For instance, the system has logs for two types of activities: visiting “discipline info” page by any user, and changing a course material. We can assume that the activity of changing course materials is much more important than the activity of visiting info-page by a single user. It doesn’t make sense to display the element net of the discipline each time when users visit the info-page. At the same time we expect that the element net will be displayed at the moment of changing course materials because it may lead to additional activities such as user notification, database updates, uploading new files, etc. Thus, based on a subjective opinion we can assign “0” rate of event importance to info-page visit event and “20” to material course update event.
In order to analyze dynamic behavior of the system, we propose to split up logs of each module by time intervals and make a decision of displaying an element net for each interval separately. Let’s examine new activity of the academic discipline support module of the LMS — uploading homework exercises by students. Event of this type are a meaningful activity with rate of event importance greater than zero. We can assume that in terms of behavioral analysis, we don’t care about infrequent homework loadings. Contrariwise, we definitely know that frequency of uploads rises sharply before a deadline. The deadline may lead to updating course materials (new home tasks, for example), changing discipline description or even to the finish of the academic discipline. Time interval of calculation provides the ability to measure the frequency of process activities (events). On the subject of the previous example, we would like to display element net of the module before a deadline, when rate of posting homework by students is bigger than 100 per hour. “Hour” is a time interval of calculation. The value of time intervals of calculation could be tuned for each element Petri net of high-level Petri net individually.
Time gap between intervals — time between beginnings of two nearest time intervals of calculation. The value of time gap between intervals should not be greater than time interval of calculation and could be tuned for each element Petri net of high-level Petri net individually as well as time intervals of calculation.
Displaying threshold is the final value for decision making about displaying the certain element net for a chosen time interval. It should be compared with level of interval importance (see Equation 1) — sum of events from the chosen time interval multiplied by events’ rate event of importance. If the result of calculation is greater than the value of displaying threshold, then the element net should be drawn fully. If the result of calculation is smaller than the value of displaying threshold, then the element net should be hidden for a time interval. The value of threshold of displaying could be unique for each element net.
a) b) = time interval identifier, = type of chosen event, = number of k-type events within the i interval, = rate event of importance of k-type event. modules — the ) part.
Let’s consider a simple example. There is a pack of logs for a software system with three diferent in tokens 1 and 2
of the module . This system has the high-level Petri net representation. Figure 7 shows the system with all modules at the ) part and shows the system with hidden submodules at , and ). Modules and
are submodules of the module , and they are “packed” want to lose visualization of the element net of the the module when 1 happens. This event relates has three types of events: 1, 2
and 3. Event 1 is very important activity and we don’t to transition
The following values were chosen as parameters for completeness-clarity balance method: • time interval of calculation = 1 hour; • distance between time intervals = 40 minutes; • displaying threshold = 90. • time interval 1 - from 00:00AM to 01:00AM contains 1 1, 4 2 and 19 3; • time interval 2 - from 00:40AM to 01:40AM contains 0 1, 4 2 and 13 3; • time interval 3 - from 01:20AM to 02:40AM contains 0 1, 10 2 and 8 3; Using Equation 1 we can calculate level of interval importance (LoII) for each interval: • • 1 = 1 ∗ 90 + 4 ∗ 10 + 19 ∗ 0 = 130; 2 = 0 ∗ 90 + 4 ∗ 10 + 13 ∗ 0 = 40; • 3 = 0 ∗ 90 + 10 ∗ 10 + 8 ∗ 0 = 100.
And finally we can compare each LoII with displaying threshold (DT) = 90. The results of calculation show that element net will be displayed for 1, 3 and will be hidden for 2:
Time interval LoII of interval Element net will be displayed
Time interval 1 Time interval 2 Time interval 3
Figure 9 shows three states of the system: the left state at the 1 (we can see the 1 event - 1 is firing), the central state during the 2 (the module is hidden) and the right one is about 3, when the element net for the module appears again due to 2 event. Please note that for the example module has its own events and the time when the element net is displayed difers from the module .
In this paper we presented the first ideas on how process dynamics can be visualized based on hierarchical high-level Petri nets. The paper documents a first part of development of dynamic visualization tool of high-level Petri net. The result of the research will provide methods of dynamic Petri net visualization and make it possible to develop visualization tool.
The visualization tool will be executed together with simulation/log processing engine. This engine will be a back-end part of the product which will scan real software systems’ logs and send related commands to visualization tool. Working together log processing engine and visualization tool will provide the user with the ability to analyze structure and behavior of chosen software system.
Dynamic visualization based on real logs can help to find bottlenecks and unwanted processes interaction. Also, it will help to analyze interaction of diferent modules with shared resources. A hierarchical approach of the software system visualization will allow user to get rid of redundant details by wrapping layers of hierarchy. It means that dynamic visualization of the software system via highlevel Petri net will combine advantages of static (structural) and dynamic (behavioral) visualization for more convenient analysis of the software systems.
This work is supported by the Basic Research Program at the National Research University Higher School of Economics.