Empowering Business Process Simulation Through Automated Model Transformations Paolo Bocciarelli, Andrea D’Ambrogio, Andrea Giglio and Emiliano Paglia Department of Enterprise Engineering, University of Rome “Tor Vergata”, Rome, Italy {paolo.bocciarelli, dambro, andrea.giglio, emiliano.paglia}@uniroma2.it Daniele Gianni “Guglielmo Marconi” University
[email protected] Keywords: eBPMN, transformation
BPM,
BPMN,
MDA,
model
Abstract Simulation is one of the most relevant techniques that can be used in the business process management domain to effectively enact a continuous enhancement of business processes (BPs). However, the effectiveness of BP simulation is still limited for several reasons (e.g., lack of simulation know-how of BP analysts, simulation model parameters that can be hard to gather, large semantic gap between the business process model and the simulation model). To overcome these limitations, this paper proposes a modeldriven method that introduces a set of model transformations to automate the generation of executable simulation code of a BP from its abstract definition in BPMN, the standard language for specifying business processes. The simulation code is specified in eBPMN, a Java-based domain-specific language that has been designed and implemented according to the BPMN execution semantics.
1.
INTRODUCTION
Business process analysis is a central activity of every business process management (BPM) effort that targets the continuous enhancement of operational processes. BPM is usually referred to a business process lifecycle that describes the different phases of a business process (BP), from inception to dismissal. Even though a standard and formal definition of such a lifecycle does not exist, according to a widely-adopted perspective, it commonly includes the following phases [12, 21]: i) Process Design, which deals with the specification and design (or re-design) of a business process; ii) System Configuration, in which the designed process is implemented into a BP management system (e.g., a BP execution engine); iii) Process Execution and Monitoring, in which the implemented process is executed on top of a BP management system and the related outcomes are gathered to enable process monitoring and optimization. Analyzing a business process is of paramount importance both at process design/configuration time, to predict its
dynamic behavior and avoid costly and time-consuming late reworks, and at process execution time, to identify bottlenecks and define strategies to redesign and improve the process whenever failures or performance downgrades occur. As argued in [23], effective BP analysis approaches should focus on the use of adequate modeling and simulation techniques, which enable enterprise management to figure out how to optimize BPs in order to maximize the technical quality and eventually the quality of business. Nevertheless, despite its relevance, the effective and structured use of simulation approaches for BP analysis is still limited in practice for various reasons [10, 14, 22]. First, although most of existing BPM tools provide simulation features, they often exhibit several limitations in terms of customizability and configurability. Moreover, the use of simulation techniques may require specific know-how to specify and implement simulation models and gathering the data required for simulation model parameterization may be hard to carry out. Finally, the business process model defined at process design time may be semantically and syntactically different from the corresponding simulation model and filling the gap between the two can be an error-prone and effort consuming activity. This paper proposes an approach that overcomes the aforementioned limitations by use of automated model transformations that take as input the process model and yield as output the corresponding simulation model, ready to be executed. The process model is specified in BPMN (Business Process Model and Notation), the standard language for BP modeling [17], while the simulation model is coded in eBPMN, a domain-specific language which has been designed and implemented according to the execution semantics of BPMN [5]. More specifically, the proposed method enables business analysts to define standard BPMN models that are annotated with performance-oriented requirements (in terms of, e.g., throughput and response time) and characteristics (e.g., workloads, service times) of the modeled BP [2]. The annotated model is then automatically transformed first into an extended model specified by use of PyBPMN (i.e.,
Performability-oriented BPMN [1]) and the into eBPMN code, which is finally executed to predict BP behavior and evaluate the design or optimization alternatives that allow to satisfy the performance requirements and improve the process quality. The reminder of this paper is organized as follows: Section 2 reviews relevant contributions dealing with BP analysis. Section 3 briefly provides an overview of the eBPMN language. Section 4 illustrates the proposed model-driven method to carry out an eBPMN-based BP analysis. Section 5 illustrates an example application and, finally, Section 6 outlines the conclusions.
2.
RELATED WORK
This section reviews the several contribution dealing with the use of model-driven and/or simulation-based techniques for BP analysis. This work exploits a previous contribution that introduces eBPMN [5], a Java-based and domain-specific language that has been designed and implemented according to the execution semantics of BPMN [17], and briefly outlines a model-driven method that exploits eBPMN in order to automatically build BP executable simulation code from standard BPMN models. This work extends such a contribution by introducing a complete and detailed understanding of the model transformations at the core of the method along with an example application to show how eBPMN constitutes an effective and valuable tool to ease the simulation-based analysis of BPs. Large effort has been spent in academia and industry to provide methods and tools for analyzing and predicting the BP behavior. In this respect, a survey that compares several methods and tools ranging from general purpose tools based on discrete event simulation to specific business process modeling and simulation tools can be found in [13]. Most commercial tools for BP management or BP modeling provide features to predict the behavior of BPs starting from their abstract models. Nevertheless, the effectiveness of such approaches is very often limited as they exhibit a low degree of customizability or result not customizable at all, being usually tied to a specific technology or notation. In [23] it is argued how executable process models can be used to analyze the expected behaviour of BPs. According to this principle, eBPMN has been designed with the aim of making BPMN models executable. In this context, similar approaches can be found, e.g., in [20, 24]. The use of fUML in simulation processes is discussed in [20], which proposes new mechanisms for delegating the execution control, in order to provide a basic support for discrete-event simulation. The limitations of the reference implementation of fUML are discussed in [24]. Such contribution states that fUML does not include the concept of time and does not provide
mechanisms to observe elements during the simulation. In this respect a new implementation of fUML is synthetically discussed, which aims to provide all the features required to effectively use fUML for simulation purposes. Such abovementioned approaches are founded on the adoption of the fUML notation. In this respect, it should be noted how fUML could be easily reused in the BPM context, according to the following considerations: i) [25] states that fUML activity diagrams and BPMN models can be considered semantically equivalent; ii) the abstract BP model can be specified as a fUML activity diagram either directly or transforming a BPMN model by use of existing model-driven approaches, as discussed in [3]. Nevertheless, as underlined in [20, 24], fUML shows several limitations and the reference implementation needs to be extended in order to be used in real-world simulation cases. Differently from contributions that make use of fUML, this work is founded on the use of a domain-specific simulation language, built according to the BPMN 2.0 specification. Recent and significant contributions that investigate the use of model driven techniques to support simulation-based analysis have can be found in [6] and [11]. In [11] the Automated Model Generation (AMG) is introduced and investigated under a wide perspective and an approach to automatically generate complex simulation models from existing data has been described. In [6] a model driven development framework for supporting modeling and simulation activities, called MDD4MS, is proposed. The study provides a proof of concept implementation of MDD4MS tools, based on the DEVS formalism, to enact discrete event BP simulation. A BPMN extension to enable the association of performance information to task and activity constructs is introduced in [14]. The proposed approach exploits such an extension to estimate an overall measure of the BP performance by simulating a model of human agents performance. The performance metrics are finally used to optimize the allocation of tasks to agents. Finally, the most relevant limitations to a widespread use of simulation in the BPM domain are summarized in [22], which proposes the use of CPN (Colored Petri Net) Tools [13] as a successful tool to predict BPs behavior. Unfortunately, despite the expressiveness of CPN and the benefits deriving by its application to get a precise characterization of resource availability, the CPN modeling language requires skills that very likely a business analyst is not familiar with. Differenty from such contributions, the proposed approach exploits model-driven techniques and relies on the use of model transformation languages, which can be considered an effective way to overcome the aforementioned obstacles to the use of simulation. Indeed, the proposed approach exhibits a high degree of automation so that it can be effectively used
by business analysts who do not have specific expertise in the fields of simulation or performance engineering. Moreover, the extensive use of model-driven techniques also provide a high degree of customizability that facilitates the tailoring of the proposed model transformations to specific needs (e.g., to support different BPMN/eBPMN versions or to enforce the expressiveness of PyBPMN).
3.
eBPMN OVERVIEW
This section briefly recalls the architecture of eBPMN. A detailed description of eBPMN is out of the scope of this paper, interested readers are referred to [5]. The eBPMN language has been built on top of SimArch [9], a layered architecture to ease the specification and the implementation of discrete event simulation models. More specifically, as depicted in Figure 1, eBPMN is positioned at Layer 3 and uses and extends the Layer 2 services, elements and interfaces to provide a complete simulation language for specifying BP simulation models at Layer 4. An architectural view of the eBPMN implementation is summarized in the class diagram depicted in Figure 2, where classes provided by the SimArch reference implementation are shown in gray background color. Layer 4 Simulation Model Layer Layer 3 Simulation Components Layer Layer 2 Discrete Event Simulation Layer Layer 1 Distributed Discrete Event Simulation Layer Layer 0 Distributed Computing Infrastructure Layer
Distributed Infrastructure Implementation
Figure 1. SimArch layered architecture In order to provide the constructs to build BPMNbased simulation models at Layer 4, eBPMN extends the SimArch reference implementation according to the rationale illustrated below. The FlowElement class extends the ComponentLevelEntity, that is the superclass for the set of classes that provide the implementation of BPMN flow objects. The implementation of BPMN connecting objects is provided by the SequenceFlow class and the MessageFlow class, which in turn extend the Layer 3 BasicLink class. The event handling is fully based on the SimArch reference implementation. Moreover, in order to make more specific
the general Layer 2 Event class, the following classes have been included: i) the EventType enumeration class that provides the two types of events managed by eBPMN (i.e., an incoming message and an incoming token), ii) the Data interface that constitutes the event payload and that is implemented by both the Token class and the Message class. From a conceptual perspective, in a BPMN model, a sequence flow represents a set of flow elements executed according to a well defined process workflow. A process is instantiated and its execution is initiated when one of its start events occur. To simulate the execution of a BPMN process, eBPMN introduces the token concept. Each start event that occurs creates a token on its outgoing sequence flow. The token traverses the sequence flow edges and routes throughout the BPMN process to be managed by other eBPMN elements, according to the relevant execution semantics. In this work eBPMN is the domain-specific language adopted to simulate the behavior of BPs. Nevertheless, as one of the most important objective of this work is to provide a method tailored for business analysts purposes and skills, the use the proposed method does not require the knowledge of eBPMN syntax and semantics. The use of a model-driven approach allows to hide from the business analysts’ perspective the complexity of the underlying simulation infrastructure. As detailed in the next sections, the execution of appropriate model-to-model and model-totext transformations allows to obtain and execute the eBPMN code, starting from the BPMN-based specification of the BP under study. The following section shows how eBPMN can be effectively adopted to carry-out a simulation-based analysis of BPs and, ultimately, to concretely support BPM efforts.
4.
MODEL-DRIVEN METHOD
Models and executable models are at the basis of the method introduced in this section. To concretely support BPM, a BP model should describe a given BP under several perspectives. It should not be limited to representation of the flow of activities but also to the definition of resources characterization and temporal properties. Executable models can be used to analyze the BP behavior in terms of performance-related properties (e.g., throughput, response time, utilization) [23]. In this respect, this work exploits PyBPMN and eBPMN to achieve the following objectives: • Use of eBPMN: methods proposed in previous contributions adopt a two steps approach that first generates an intermediate and abstract model (e.g., an UML Activity Diagram) and then uses such a model to generate a performance model specified by use of a queueingbased formalisms, such as EQN (Extended Queueing
Layer 2
SimJEntity
SimJEvent
1
LocalProcessEngine
1
Link
Port
LocalEntity
PLocalEvent
*
Event 1
*
Layer 3
1
BasicLink
1 1
outputPort 1 inputPort 1
BasicPort
SequenceFlow
EventType
ComponentLevelEntity
incomingToken incomingMessage 1
1
*
Layer3ToLayer2Interface
1 FlowElement
MessageFlow
*
Data 1
ServiceTask
Activity
Gateway
Task
ExclusiveGateway
EventNode
Pool
Message
Token
SendTask ReceiveTask
InclusiveGateway
ParallelGateway
Figure 2. eBPMN architecture Networks) [18]. Differently, this work integrates and exploits the eBPMN language, a domain specific simulation language built according to the BPMN 2.0 execution semantics. As a consequence, the proposed method does not require the definition of any UML or EQN intermediate models. Moreover, being directly derived from BPMN, eBPMN contributes to provide a more accurate simulation of the BP behavior. • Use of visual tools and PyBPMN: in order to allow the specification of the non-functional properties of BPs and to drive the automated execution of the simulationbased analysis, methods proposed in our past works are founded on the lightweight PyBPMN extension. One of the most relevant limitations of such an approach is the unavailability of visual tools to edit PyBPMN models. This work introduces a novel model transformation that allows BP analysts to specify the BPMN model by use of BPMN 2.0-compliant visual tools, annotate such model and transparently derive the PyBPMN model. In such a way the BP analyst is only required to input a textual annotation that specifies the performance properties of the BP, without being aware of the implementation details of PyBPMN (e.g., its metamodel and schema). The use of PyBPMN allows to decouple the userbased representation of the problem (i.e., the BPMN model) from the related internal representation (i.e., the PyBPMN extension), thus allowing a full reuse of previous contributions that provide model-driven methods for automatically building performance models
of business processes [2, 3]. As regards to the use of visual tools, it should be underlined that alternative solutions, based on the BPMN native extension mechanism [17], have been evaluated. However, even though such an approach is promoted as the standard BPMN extension mechanism, it is affected by the following limitations [19]: • it does not define a methodological approach to design the extension; • the BPMN specification does not provide any visual notation to represent the extension. As a consequence, the concrete support of the extension mechanism by open source and commercial tools is still limited in practice. The Eclipse Foundation provides a well documented method to build a plugin, based on the BPMN Modeler [8], whose implementation is based on the BPMN native extension mechanism. In such an approach, the BPMN extension is provided as an Ecore metamodel that is in turn used to create the Java code to define novel BPMN flow object. Differently, the proposed method (and specifically the PyBPMN extension) leverages model-driven standards and tools so that it can be easily customized to fit specific needs. According to Figure 3, at the first step the business analyst, who is in charge of gathering both functional and non-functional requirements of the BP under studym specifies the relevant BPMN model. While the functional
Flow of documents Functional requirements
Control flow
Non-functional requirements
Business Process Analyst Business Process Specification
BPMN model
BPMN-to-PyBPMN Model-to-Model transformation PyBPMN model
Service Specification (WSDL/Q-WSDL)
Service Discovery & Selection Candidate Configurations (PyBPMN models)
PyBPMN-to-eBPMN Model-to-Text transformation eBPMN code
eBPMN execution
Simulation results
Business Process Simulation
Predictions OK Results evaluat.
Results BPMN execution evaluat.
Predictions inadequate
Figure 3. Model-driven method for BP simulation and execution requirements are used to define the flow of tasks and activities that are part of the BPMN model, the non-functional requirements are included as text annotations associated to the related activity node and swimlane instances. Such comments have to be specified according to the following syntax: AttributeName = {tag1= value1, tag2=value2, ...} where metaclasses and attributes are specified according to the PyBMN extension and tags are parameters that quantify the attribute according to given datatypes, as specified in [4]. As an example, to specify that an activity requires 200 ms to be executed, the following comment must be attached to the corresponding activity node. serviceTime = {value=200, unit=’ms’, source=’est’, dir=’decr’, statQ=’max’} where the tags value, unit, source, dir and statQ give the value, the unit of measure, the origin, the type of order relation used to compare values and the the type of statistical value of the attribute, respectively. Then the BPMN-to-PyBPMN model-to-model transformation is executed in order to derive the PyBPMN model that corresponds to the BPMN input model. As the initial BPMN model may include Service Tasks to model the execution of services, a service discovery
may also take place to retrieve the WSDL 1 descriptions of concrete web services that match the abstract service interfaces specified in the PyBPMN model. The method proceeds by first executing the PyBPMN-to-eBPMN model-to-text transformation, which takes as input the PyBPMN model and yields as output the eBPMN simulation code, and then executing the eBPMN code on top of the SimArch simulation engine. The simulation results may help the business analyst to evaluate design trade-offs or what-if scenarios and also to assess at design time the satisfiability of non-functional requirements. In case the performance predictions satisfy the required BP requirements and constraints, the BP execution can be run on top of a BPMN 2.0-compliant execution engine. It should be noted that the BP execution can be generally carried out by use of different execution engines, by introducing appropriate model-to-text transformations that take as input the BPMN model and yields as output the required executable code. As an example, the use of a BPEL engine has been discussed in our past contributions [1, 2, 3, 4]. The following sub-sections describe the two model transformations at the basis of the proposed method.
4.1.
BPMN to PyBPMN model trasformation
According to Section 4 the model-driven BP simulation method starts with a BPMN model that includes both functional and non-functional requirements. Non-functional requirements are specified as text annotations associated to specific BPMN elements, according to the syntax described in Section 4. The BPMN-to-PyBPMN model-to-model transformation takes as input the annotated BPMN model and yields as output the corresponding PyBPMN model, which conforms to the PyBPMN metamodel. The PyBPMN metamodel can be considered as the BPMN metamodel with further extension-specific metaclasses. PyBPMN is a conservative extension of BPMN, being specified by simply extending some BPMN metaclasses, in other words without altering the integrity of the BPMN 2.0 standard metamodel [17]. This approach leads to a PyBPMN implementation that is obtained by extending a standard BPMN 2.0 metamodel implementation, such as the one developed and maintained within the Eclipse Model Development Tool project [8]. Given the constraint that the standard BPMN metamodel cannot be modified, it is not possible for an original BPMN 1 The proposed method is fully compliant with both standard WSDL and extended descriptions of the concrete services. In the former case it is assumed that the business analyst is able to estimate and annotate in the model the required non-functional characteristics of the related concrete services, while in the latter case such non-functional properties are directly derived from the extended description, carried out, e.g., by use of Q-WSDL [7].
aProcess : Process
annotation: TextAnnotation text = “ serviceTime = {value=‘v’, unit=‘u’, source=‘s’, dir=‘d’, statQ=‘q’}”
source : BPMN
anAssociation : Association sourceRef = annotation targetRef = targetTask
targetTask : Task
target: PyBPMN
paServ : PaService
serviceTime : NFP_Duration
4.2.
PyBPMN to eBPMN model trasformation
aProcess : Process
anAssociation : Association sourceRef = paServ targetRef = targetTask
targetTask : Task
value = v unit = u source = s dir = d statQ = q
Figure 4. Rationale of the BPMN-to-PyBPMN model transformation
metaclass (e.g., the Task metaclass) to directly reference a PyBPMN metaclass. To overcome such a limitation, the relationship between the PyBPMN and BPMN metaclasses is implemented by use of the BPMN 2.0 Association metaclass, which links two instances of BaseElement type or a derived type. To be compliant with the BPMN 2.0 specification, PyBPMN metaclasses have been derived from the BPMN Artifact metaclass (that inherits from the BaseElement type), according to what the specification states in terms of granting modelers or modeling tools the possibility to extend BPMN diagrams by adding new types of Artifacts. The BPMN-to-PyBPMN transformation is implemented by use of the OMG QVT-Operational (QVT-O) language [16]. The transformation maps the PyBPMN text annotations in the source model to the corresponding PyBPMN instances in the target model, according to the rationale is shown in Figure 4. The annotations in the BPMN model are comments defined as instances of the TextAnnotation metaclass, which derives from the Artifact metaclass. The TextAnnotation metaclass has a text attribute to store the annotation as a string. The reference between the TextAnnotation and the instance to be annotated is achieved by use of an instance of the Association metaclass. As an example, if a task is annotated according to the PaService syntax described in Section 4, the corresponding TextAnnotation instance found in the source model is transformed to a PaService instance in the target model, with the serviceTime attribute values set according to what specified in the annotation. Due to the fact that BPMN metaclasses are valid PyBPMN metaclasses too, all other instances in the source model are left unmodified by the transformation. The QVT-O transformation takes as input and generates as output models serialized as XMI documents, the OMG interchange format for sharing models using XML [15].
According to Section 4 the model-driven BP simulation method proceeds with the PyBPMN-to-eBPMN model-totext transformation, which takes as input the PyBPMN model serialized into XMI and yields as output the corresponding eBPMN code. Such a transformation is implemented by the use of the OMG’s Model-to-Text (M2T) language and is specified in terms of a set of templates. Each templates includes a set of placeholders, delimited by square brackets, which contain expressions defined over input metamodel elements. As an example, the M2T template to configure properties of a Task object is specified as follows: [template public generate(pa : PaService)] [let as : Association = pa.eContainer(Process). eContents(Association)-> select(sourceRef.id = pa.id)-> first()] [let task : Task = as.targetRef] [task.id /].serviceTime = new NFP_Duration("[pa.serviceTime.value /]", "[pa.serviceTime.unit /]", "[pa.serviceTime.source /]", "[pa.serviceTime.dir /]", "[pa.serviceTime.statQ /]"); [/let] [/let] [/template] The M2T transformation calls the matching generate template for every t element of type Task and every pa element of type PaService type in the source PyBPMN model. The attributes of instance t are set according to those in the PyBPMN model. In order to avoid conflicts among labels, the instance name is equal to the id attribute of the PyBPMN model, which is unique in the model by definition, according to BPMN 2.0 specification. In particular, the basic concept behind the transformation is that container elements (pools) are processed first, followed by flow objects (activities, events, gateways), artifacts and connection objects (sequence flows and message flows). The M2T transformation is applied iterating over the hierarchical structure of the model, as follows: • starting from the root element of the model (of type Definitions), for each participant a Pool object is created; • the processRef attribute of the participant is used to select the corresponding Process element in the model;
– for each FlowElement object in the process, the corresponding generation template is called and the new object is added to the parent Pool object; • for each Artifact in the process, if the object is of the PaService derived type, the corresponding template is called; – the template generates the code used to update the performance-oriented attributes of the element. The Association element with source attribute matching the PaService object is first selected. Then, using the target reference of the Association object, the corresponding Task object is selected; – the performance-oriented attributes of the Task are updated according to the PaService attributes; • for each MessageFlow element in the model, the corresponding generation template is called.
5.
EXAMPLE APPLICATION
As an example application of the proposed method, an automatic supply management system that involves the following three actors is considered: • Provision Manager: actor in charge of initiating and coordinating the entire process. It is in charge of both exchanging messages with other actors and managing warehousing and inventory activities. • Account Manager: actor in charge of managing the account book records. It exposes a service in order to receive accounting notifications. • Supplier Manager: actor in charge of managing supplier-related issues. It exposes a service used by the Provision Manager to send purchase requests. The example BP is activated upon reception of a sale transaction request. The Provision Manager prepares a message with the sale details and sends it to the Account Manager. Then, the Provision Manager initiates a check of the inventory. Depending on the current stock availability, different scenarios may be enacted: • with a probability p = 0.85 requested goods are available and thus no action is taken; • with a probability p = 0.1 the goods availability is below a first level threshold, and a service for the procurement from a local warehouse is started;
• with a probability p = 0.05 the goods availability is below a second level threshold, and a process to purchase from an external supplier is started. At the end of the process a report is produced. As discussed in Section 4, the model-driven BP simulation method starts with a BPMN model annotated with performance properties according to the PyBPMN extension. Figure 5 illustrates the annotated BPMN model for the example application. As an example, to specify that an activity, e.g., ’Order Payment’, requires 200 ms to be executed, the following comment must be attached to the corresponding activity node: serviceTime = {value=’200’, unit=’ms’, source=’rec’, dir=’decr’, statQ=’max’} As stated earlier, comments in the BPMN model are specified as instances of the TextAnnotation metaclass with a Text attribute containing the comment: Once the BPMN model has been annotated with performance requirements, the BPMN-to-PyBPMN transformation is executed to map the TextAnnotation instances in the BPMN source model to PyBPMN instances in the target model, leaving all other BPMN instances unmodified. In the specific case of the service time annotation, the TextAnnotation instance is mapped to the following PaService instance: The so obtained PyBPMN XMI code is then used as input for the next step, which executes the PyBPMN-to-eBPMN model-to-text transformation to produce the following eBPMN code:
Figure 5. Annotated BPMN Model of the example process Task Task_OrderPayment = new Task("Order Payment", layer2Interface); Task_OrderPayment.serviceTime = new NFP_Duration("200", "ms", "rec", "decr", "max"); which creates a Task object and specifies the relevant service time attribute, according to values found in the PyBPMN model.
6.
CONCLUSIONS
This paper has introduced a model-driven method to enact the simulation-based analysis of BPs. The proposed method relies on two automated model transformations that take as initial input a BPMN model, appropriately annotated with performance properties, and yield as final output the corresponding simulation code in eBPMN, a domain-specific language designed and implemented according to the BPMN execution semantics. The obtained level of automation makes the method easy to use even by business analysts who are not familiar with simulation or performance engineering theory. The current eBPMN implementation includes the core set of BPMN constructs and thus represents a first step toward the
development of a full-featured BP simulation-based analysis environment.
REFERENCES [1] P. Bocciarelli and A. D’Ambrogio. A BPMN Extension for Modeling Non Functional Properties of Business Processes. In Proceedings of the Symposium on Theory of Modeling and Simulation, DEVS-TMS ’11, Boston, MA, USA, 2011. [2] P. Bocciarelli and A. D’Ambrogio. PerformabilityOriented Description and Analysis of Business Processes. In J. A. Beckmann, editor, Business Process Modeling: Software Engineering, Analysis and Applications. Nova Publishers, 2011. [3] P. Bocciarelli and A. D’Ambrogio. Automated Performance Analysis of Business Processes. In Proceedings of the Symposium On Theory of Modeling and Simulation, DEVS-TMS ’12, page 10, Orlando, FL, USA, 2012. [4] P. Bocciarelli and A. D’Ambrogio. A Model-driven Method for Enacting the Desing-time QoS Analysis of Business Processes. Software & Systems Modeling, 2013.
[5] P. Bocciarelli, A. D’Ambrogio, and E. Paglia. A Language for Enabling Model-driven Analysis of Business Processes. In Proceedings of the 2nd International Conference on Model-Driven Engineering and Software Development, MODELSWARD ’14, Lisbon, Portugal, to appear. SciTePress.
[18] C. H. Sauer, E. A. MacNair, and S. Salza. A language for extended queueing network models. IBM Journal of Research and Development, 24(6):747–755, 1980.
[6] D. Cetinkaya. Model Driven Development of Simulation Models: Defining and Transforming Conceptual Models into Simulation Models by Using Metamodels and Model Transformations. PhD thesis, University of Delft, The Netherlands, November 2013.
[19] L. J. R. Stroppi, O. Chiotti, and P. D. Villarreal. Extending bpmn 2.0: Method and tool support. In R. M. Dijkman, J. Hofstetter, and J. Koehler, editors, BPMN, volume 95 of Lecture Notes in Business Information Processing, pages 59–73. Springer, 2011.
[7] A. D’Ambrogio. A Model-driven WSDL Extension for Describing the QoS of Web Services. In Proceedings of the IEEE International Conference on Web Services, ICWS ’06, pages 789–796, Washington, DC, USA, 2006. IEEE Computer Society.
[20] J. Tatibouet, A. Cuccuru, S. G´erard, and F. Terrier. Principles for the realization of an open simulation framework based on fUML (WIP). In Proceedings of the Symposium on Theory of Modeling & Simulation DEVS Integrative M&S Symposium, DEVS 13, pages 4:1–4:6, San Diego, CA, USA, 2013. Society for Computer Simulation International.
[8] Eclipse Foundation. BPMN2 Modeler, 2013. Website: http://www.eclipse.org/bpmn2modeler/documentation.php. [9] D. Gianni, A. D’Ambrogio, and G. Iazeolla. A software architecture to ease the development of distributed simulation systems. Simulation, 87(9):819–836, 2011. [10] G. Hook. Business process modeling and simulation. In S. Jain, R. R. C. Jr., J. Himmelspach, K. P. White, and M. C. Fu, editors, Winter Simulation Conference, pages 773–778. WSC, 2011. [11] Y. Huang. Automated Simulation Model Generation. PhD thesis, University of Delft, The Netherlands, November 2013. [12] J. Januszczak and G. Hook. Simulation standard for business process management. In Proceedings of the Winter Simulation Conference, WSC ’11, pages 741– 751. Winter Simulation Conference, 2011. [13] K. Jensen, L. M. Kristensen, and L. Wells. Coloured Petri Nets and CPN Tools for modelling and validation of concurrent systems. International Journal on Software Tools for Technology Transfer, 9(3-4):213– 254, 2007. [14] F. Kamrani, R. Ayani, and A. Karimson. Optimizing a business process model by using simulation. In IEEE Workshop on Principles of Advanced and Distributed Simulation (PADS), pages 1–8, Atlanta, GA, May 2010. [15] OMG. XML Metadata Interchange (XMI) Specification, version 2.1.1. 2007. [16] OMG. Meta Object Facility (MOF) Query/View/Transformation, version 1.0, 2008.
2.0
[17] OMG. Business Process Modeling Notation (BPMN), version 2.0. 2011.
[21] A. ter Hofstede, W. van der Aalst, A. ter Hofstede, and M. Weske. Business Process Management: a Survey. In M. Weske, editor, Business Process Management, volume 2678 of Lecture Notes in Computer Science, pages 1019–1019. Springer Berlin / Heidelberg, 2003. [22] W. van der Aalst, J. Nakatumba, A. Rozinat, and N. Russell. Business Process Simulation: How to get it right? In Handbook on Business Process Management, International Handbooks on Information Systems, pages 317–342. Springer-Verlag, 2010. [23] W. M. van der Aalst. Business Process Management: a Comprehensive Survey. ISRN Software Engineering, 2013, 2013. [24] P. Weyprecht and O. Rose. Model-driven development of simulation solution based on SysML starting with the simulation core. In Proceedings of the 2011 Symposium on Theory of Modeling & Simulation: DEVS Integrative M&S Symposium, TMS-DEVS ’11, pages 189–192, San Diego, CA, USA, 2011. Society for Computer Simulation International. [25] S. A. White. Process modeling notations and workflow patterns. Workflow Handbook, pages 265–294, 2004. [26] F. Yang, W. Shen, W. Tan, and H. Ghenniwa. A framework for service enterprise workflow simulation based on multi-agent cooperation. In Proc. of the IEEE Int. Conference on Systems, Man and Cybernetics, Istanbul, Turkey, 10-13 October 2010, pages 2587– 2594. IEEE, 2010.
