Coordinate parallel processes with Split, Join, and Synchronize

00:03

Coordination activities in FlexSim allow you to coordinate tasks and processes in your process flow by using Split,

00:10

Join, and Synchronize activities.

00:15

You may wish to use coordination activities to properly allocate resources, to sequence or schedule tasks,

00:23

for flow control and bottleneck management, or to analyze different scenarios and strategies for setting up activities.

00:32

First, find the coordination activities in the ProcessFlow Library.

00:38

Here, Split, Join, and Synchronize activities are added to the blank ProcessFlow shown.

00:47

When a token enters a Split activity, the token is split into multiples and released through each outgoing connector.

00:56

The number of tokens released depends on the number of outgoing connectors.

01:01

Open the Split Quick Properties.

01:05

Notice that a label, or “splitID”, is added to each outgoing token containing a reference to the original token.

01:14

You can customize this label if needed.

01:18

The splitID can also be useful if you want to join or synchronize these tokens later in your process.

01:26

The Join activity waits until it receives a token from each incoming connector before joining them and then releasing a single token.

01:35

While you can have as many incoming connectors as you wish, because it releases a single token,

01:41

this activity can only have one outgoing connector.

01:46

Open the Join Quick Properties.

01:50

You can set this activity up to join tokens with matching splitID, which means joining tokens based on a specified label.

01:60

Additionally, the Use Max Wait Time and Use Max Idle Time selections

02:06

allows you to release the tokens after a maximum amount of wait or idle time has elapsed,

02:11

even if tokens have not arrived from all incoming connectors.

02:16

The Synchronize activity waits until it has a token from each incoming connector, and then releases the tokens at the same time.

02:26

For this activity, you must have the same number of incoming and outgoing connectors.

02:32

It is also important to check the ranking of the connectors,

02:35

as the activity will route tokens based on this rank.

02:40

For example, here is a process flow with a Synchronize activity.

02:46

Tokens entering through the rank 1 incoming connector will exit through the rank 1 outgoing connector.

02:54

Similarly, tokens entering through the rank 2 incoming connector will exit through the rank 2 outgoing connector.

03:03

Back in the ProcessFlow with the coordination activities,

03:07

open the Synchronize Quick Properties to see that splitIDs can be used to synchronize tokens in this activity as well.

03:15

Now, take some time to review an example of each type of coordination activity.

03:22

The first example is set up to illustrate the Join activity.

03:27

The Model shown contains a Source that creates three types of items, each represented by a distinct color.

03:36

The ProcessFlow is set up with a Join activity that will wait for one of each item

03:41

and then release a single token to travel to the next step in the process.

03:47

In this case, the token will travel to the list indicating that an order is ready to fulfill.

03:54

To help visualize this process as the simulation runs, List Quick Properties is opened,

04:02

and View Entries is clicked and anchored below the ProcessFlow.

04:07

When the simulation is Run and stepped forward, within the Join activity,

04:13

you can see the waves, or group of entities, that will be joined together.

04:18

If you then pause the simulation and click a Wave to view its details,

04:22

you see that the second Wave has one out of three items available,

04:26

while the first Wave has two out of three items available and is waiting for a green item.

04:33

The simulation is restarted, and when the green item arrives, the wave is fulfilled.

04:40

Now, the Join activity releases a single token to the List, indicating that an order is ready.

04:50

The next example is set up to show Split and Synchronize activities.

04:56

Here, a StandardQueue creates a box that can be transported to the Processor by a single Operator,

05:03

while the LargeQueue creates a heavier box that requires both Operators to transport it.

05:10

The ProcessFlow is set up so that if the item is a standard box, then the token travels through the process flow in the standard process shown.

05:20

However, if the item is a heavier box, two things happen:

05:26

the visual adjusts to a larger box size, and the Split activity creates two tokens, one to acquire each Operator.

05:36

Then, a Synchronize activity waits for both tokens to reach the LargeQueue before they can move to the next task,

05:44

which is loading the box.

05:47

A second Synchronize waits until both Operators have loaded the box before releasing them to travel to the Processors,

05:56

a third waits for both boxes to reach the Processors before unloading can begin,

06:03

and a fourth waits until both boxes are unloaded before they are ready for release.

06:09

When the simulation is Run, the Operators carry the standard boxes individually.

06:16

When a Large box arrives, in the ProcessFlow, notice that the token is split as both Operators are acquired.

06:26

Then, the tokens wait at each Synchronize activity until they can both move forward in the process.

06:34

Now you can use Coordination activities to build logic that joins, splits, and synchronizes tasks and processes in your model.