Executing Petri nets in a distributed manner is, in general, a non-trivial task. To achieve portability of the simulation, as a precondition for scalability, it is desirable to keep the majority of the simulation components stateless. This paper presents a first approach to model distributed Place/Transition nets (P/T nets) using stateless services and only a (stateful) database. The presented theory has been implemented in a web API based service. First tests look promising.
To cope with the critical parts of a distributed Petri net simulation focus is put on the net partitioning, firing uniqueness and atomic token consumption. In regards to data storage transition firings and token consumption are both write operations. Write operations usually tend to be problematic in a concurrent environment.
PNSE’19 – Petri Nets and Software Engineering Transition Firing and Token Consumption As actively simulating transitions in a distributed fashion imposes severe difficulties in regards to the uniqueness of firing and/or self-concurrency, the presented approach focuses on simulating active tokens. Tokens, however, may also occur as passive entities. Actively simulated tokens will be referred to as main tokens. Places are not modeled, but tokens and transitions hold them implicitly.
The simulation is organized in multiple infinite loops. A node selects a random token as the main token and loads all tokens of all presets of all attached transitions into memory. The node then iterates through all transitions and tries to fire a random active transition. Firing is done by issuing a transaction to the underlying data storage, that assures uniqueness.
If conflicts occur (two or more nodes handle the same token), the transaction will succeed, that is committed into the database first.
The simulator consists of an evaluation unit layer and a database service. The database service holds the current state of the net, while the evaluation layer only temporarily copies data, that is required to compute transition firings. As the evaluation layer is stateless and only communicates to the database, it is easily scalable. The database layer is harder to scale, but several well-engineered solutions exist and can be utilized.
The evaluation layer was implemented using Java Spring, with later application to colored nets and reference nets in mind, where transition firings and binding searches become more advanced in the order of magnitudes.
As scalability is one of the proposed main features, the simulator is designed to be used with container and PaaS solutions in mind, especially Docker and Kubernetes. Kubernetes offers excellent means to keep an application robust and scale it up to several replicas. Automatic scaling solutions (based on CPU load) also exist.
Next things to address are the incorporation of existing tools and formats (like PNML) and the evaluation of graph databases (like Neo4j), as well as the transition to higher level Petri net formalisms.