Desktop Client: What is a Call Activity (Callable Process) and how does that impact simulation?

This article generally applies to iGrafx Process and iGrafx Process for Six Sigma Client tools where simulation is possible. The setup, however, can be defined by iGrafx FlowCharter.

In BPMN there are callable processes that can be referred to by a Call Activity or Global Task. At its simplest, a 'Call Activity' is some process that's re-used across the enterprise. It's shared among various functional areas, or is 'Global.' There are, of course, various ways to do the same thing, either with an embedded, collapsed, or 'call activity' process. So in many cases a 'call activity' is not required. The process designer has to decide if a Call Activity is desired; e.g. they want to call a process with multiple pools, or pass arguments in that will be different depending on where the process is called from, and/or want the scope of execution unique to each call.

The following is from the BPMN 2.0 specification:

A Call Activity identifies a point in the Process where a global Process or a Global Task is used. The Call Activity acts as a “wrapper” for the invocation of a global Process or Global Task within the execution. The activation of a call Activity results in the transfer of control to the called global Process or Global Task. The BPMN 2.0 Call Activity corresponds to the Reusable Sub-Process of BPMN 1.2. A BPMN 2.0 Sub-Process corresponds to the Embedded Sub-Process of BPMN 1.2 (see the previous section).

(and)

A Call Activity can override properties and attributes of the element being called, potentially changing the behavior of the called element based on the calling context.

So some further background about Processes and Call Activities, in BPMN:

The term “Call Activity” has two parts. The term “Activity” refers to the shape being edited. The term “Call” refers to the shape “calling” something else. The “something else being called” can be either a “Callable Process” or a “Global Task”.
A “Process” corresponds to:
1. a single “Pool” (which itself can be split into lanes) in a diagram with one or more “Pools” or
2. a diagram with no “Pools”
In addition, a “Process” is either “Callable” or “Embedded”
1. ”Embedded” means the activities in the process are really part of the parent process. This means, no context has to be passed to the Embedded Process, i.e., from a simulation point of view, transactions simply flow from the parent into the child Embedded Process and, for example, all the transaction attribute values are available in the Embedded Process. An Embedded Process can be either Collapsed or Expanded.
2. ”Callable” means that a separate process is invoked with or without specific “Arguments”. This means that NO context flows between the caller and the Callable Process outside of the Arguments. A Callable Process is never Expanded.
A Global Task should really be thought of as a Callable Process that isn’t going to be modeled (already an existing atomic action like a preexisting service).
1. A Global Task can also have “Arguments”
2. A Global Task can also have a Task Type

Here are some User Interface (UI) tips that might help you when trying to model in iGrafx:

In iGrafx, when you specify you want a shape to “link” to a SubProcess, you simply have to right-click (as of v14.1) on the shape and choose "Add Subprocess" (or you can create a new diagram with a start point and create a link to that diagram). In the BPMN Guide you can specify an Activity will link to a “Collapsed SubProcess”. But that DOES NOT specify if that process is a “Callable Process” or a “Collapsed Embedded Process”. That is a Property of the Process (i.e., Diagram) being called. Therefore, you could go to the SubProcess Diagram’s Property page (or there is a shortcut on the Task page of the calling shape to get to that properties dialog) and specify whether this Process to be “Callable” or not.
If a Process (Diagram) is specified as “Callable”, you can define the Arguments that can be passed to it by callers. From the calling shape, you can specify the Argument Values to pass to the Callable process. In this case, the UI treats this as a “Callable” Process. The Start Point determines which “Pool” (via a Start Shape in that Pool) is the actual “Called” Process.
If you DON’T specify the Process (Diagram) as Callable, it works as an Embedded SubProcess in terms of transaction data flow. In this case, the UI treats this as a “Collapsed Embedded” Process.
You can also specify a call to a “Global Task”. The details of the Global Task are not modeled, so all the specification of “Global Task” in iGrafx goes on the shape that is “Calling” this Global Task. Therefore, any BPMN Activity can be marked as a “Call Activity” that doesn’t specify a Process to Call. Instead it simply specifies the “Task Type” of the Global Task so it appears as an indicator on the shape. iGrafx also allows you to create “pseudo” Arguments for the Global Task and to set Argument Values when calling the Global Task. Both the Argument “definition” and “setting of values” are specified at the same time on the Task Page. The reason this is done is so that if you export to XML, it will retain this information for the target system.

Please note that you can create situations where you are using “Collapsed Embedded” Processes incorrectly from a BPMN point of view; i.e., a diagram with multiple Pools should NOT be an Embedded Process. You can, however, create all the BPMN “Process” constructs to get the desired behavior and diagram display (and XML export) via the iGrafx UI.

A 'Call Activity' and the 'Callable' process (global or reusable processes) it calls can be simulated. A Callable Process will simulate with separate instances containing unique data, controlled by arguments (data inputs and outputs) to the process. The callable process (and call activity) is a BPMN construct; you may want to review the definition of Call Activity from the BPMN specification to become more familiar with this concept.

The callable subprocess is a 'Truly Private' Subprocess. It is Useful for the following (iGrafx simulation-related behavior in italics; the last 2 bullets):

Re-using processes (by referencing them from other processes)
Interactions with external systems
Creating structure for export via XML (XPDL/BPDM)
Function calls to external VBA code
Preventing undesired interactions, particularly for data, between transactions (truly private processes, independent of each other) [Resources will be shared]
Creating a cleaner name space for attributes (attributes only available for this subprocess).

When the Callable Process is used (Called), it creates a separate and distinct process (instance) for each transaction that enters (calls) the subprocess, and supersedes any “Private Subprocess” behavior specified.

Arguments to a callable process:

Arguments may be defined, passed in/out, and used. The scope can be

In: Pass in a value, no return value is expected
Out: Returns a value, no input value is expected
In/Out: Pass in and return a value
Local: Not passed, but can be used locally within the called process
(*Note: Returned (out, in/out) argument values are available to the calling shape after Task; after the Task page Step tab action is complete).

Arguments create “Me-only” (M.) process instance attributes
The Name is only valid in the called process
Values are unique for each process instance; i.e. the set of transactions active in the specific process instance, and not other process instances.

Transaction and Attribute behavior (handling) in the Callable Process:

Transactions

A new transaction is created when the process is instantiated
NOT related by family to transactions outside this process instance
Duplication will create a family (New Family option still available)

Attributes

Family (F.) attribute settings will not affect transactions in other process instances, nor the parent process(es) transactions
Scenario (S.) attributes still available
Transaction (T.) attributes

Initialized from T. values of the parent process calling transaction
Changes in T. values in the process instance will not affect the T. values in the parent process calling transaction

Me (M.) values are only available to the distinct (unique) process instance

See the iGrafx Help system (Help menu > iGrafx Help) for further information on Call Activity and Callable processes, including Properties dialog box options.