Many business process models contain control flow errors, such as deadlocks or livelocks, which hinder proper execution. In this paper, we introduce a new tool that can instantaneously identify control flow errors in BPMN models, make them understandable for modelers, and suggest corrections to resolve them. We demonstrate that detection is instantaneous by benchmarking our tool against synthetic BPMN models with increasing size and state space complexity, as well as realistic models. Moreover, the tool directly displays detected errors in the model, including an interactive visualization, and suggests fixes to resolve them. The tool is open source, extensible, and integrated into a popular BPMN modeling tool.
use analyze every change & display results
BPMN Editor BPMN modeler
design quick fixes Language engineer
BPMN model analysis results
TM instantaneous analysis
Soundness Checker
The tool can check models after each change since analysis is instantaneous according to [
Fahland et al. [
In the remainder of the paper, we describe how instantaneous, comprehensible, and fixable control flow error detection is achieved in section 2. Then, we discuss tool maturity in section 3 before concluding in section 4.
The BPMN Analyzer has three main innovations: instantaneous, comprehensible, and
ifxable control flow error detection. In this section, we will present the innovations, and more
details can be found in our extended paper [
We demonstrate instantaneous control flow analysis by benchmarking our tool in three
scenarios. For all our benchmarks, we use the hyperfine benchmarking tool (version 1.18.0), which
calculates the average runtime when executing each control flow analysis ten or more times. We
ran the benchmarks on Ubuntu 22.04.4 with an AMD Ryzen 7700X processor (4.5GHz) and 32
GB of RAM (5600 MHz). All used BPMN models, our tools to generate them, and benchmarking
scripts to run them are available in [
First, we benchmarked how our tool handles BPMN models of growing size. We generated
500 synthetic BPMN models starting with five elements up to 4000. The models repeatedly
contain three activities and an exclusive/parallel block with two branches containing one activity
per branch (see [
Second, we benchmarked the tool against a synthetic data set of models that led to a state
space explosion. This represents a worst-case scenario for formal analysis. We generated a data
set of models [
Table 1 shows the average runtime of our tool when analyzing these models. The BPMN
Analyzer explores the entire state space while simultaneously analyzing the control flow, i.e.,
verifying soundness properties. The models’ state space grows exponentially, leading to the
same order of growth in runtime. Our analysis is not instantaneous anymore when approaching
17 parallel branches of length 1 (see Table 1). However, analysis is still instantaneous for more
reasonable models with five parallel branches of length 5 or 3 branches of length 20. Other tools
report 2-3s of runtime for most soundness properties and 30s for a model with five parallel
branches [
Third, we applied our tool to eight realistic models, where three models (e001, e002, e020)
are taken from [
We implemented two features to make control flow analysis understandable for everyone. First, we highlight the problematic elements that cause control flow errors by directly attaching red overlays to them in the model. In addition, there is a summary panel in the top-right stating if any errors are found.
Second, we use tokens to visualize errors interactively, i.e., show an execution leading to the error. Our analysis provides sample executions resulting in the found control-flow errors, which we visualize in the editor by showing how tokens move from the process start to an erroneous state. We are unaware of other tools that visualize errors directly and allow interactions, such as stopping/resuming and restarting.
In Figure 2, the visualization has been paused just before an unsafe state was reached. One token is already located at the marked sequence flow, while a second token is currently waiting at the exclusive gateway e1. The visualization can be resumed or restarted using the play and restart button on the left side. The gateway e1 will execute when resumed, resulting in two tokens at the subsequent sequence flow, i.e., an unsafe execution state. Furthermore, one can control the visualization speed using the bottom buttons next to the speedometer.
Besides detecting, highlighting, and visualizing control flow errors, the BPMN Analyzer suggests
ifxes like quick fixes in IDEs. Quick fixes cannot be provided for all errors, but we currently
cover many patterns leading to deadlocks, lack of synchronization, message starvation, and
reused end events. The quick fixes we support are described in detail in [
For example, Figure 2 shows a screenshot of our tool, where quick fixes are depicted as green
overlays containing a light bulb icon. A user can apply a quick fix by clicking on a green overlay
and instantly see the changes regarding control flow errors. If unhappy with the result, a user
can undo all changes since each quick fix is entirely revertible due to the command pattern. A
user might not like a quick fix if it not only fixes an error but also has unintended side efects,
such as introducing a diferent control flow error.
The BPMN Analyzer incorporates many findings from our previous work [
In future work, we aim to improve our tool by providing more quick fixes, considering advanced BPMN elements such as diferent events, and ranking quick fixes based on usefulness and previous user behavior. Finally, we aspire to test our tool in a real-world scenario to gather feedback and measure its impact on productivity.