This topic will explain how task executers receive and execute
task sequences. If you are using complex task logic in your simulation model, you might need to
understand the concepts in this topic so that you are aware of how FlexSim handles task
logic behind the scenes. This knowledge will help you understand and troubleshoot potential
task logic problems---especially related to task dispatching logic and its related issues,
such as task priorities and preemption.
Task Sequences and Tasks
Sometimes you might see the terms task and task sequence used
interchangeably in this manual and in other FlexSim resources. While loose terminology
usage isn't terribly problematic, there are very specific, and unique, technical meanings of the
terms task and task sequence which are important to understand.
Task - A single instruction or action that is performed by a task executer.
Examples are load,
Task Sequence - A collection of one or more tasks that are meant to be performed
in sequence, generally uninterrupted, by a task executer. In addition to containing a sequence of tasks
to perform, a task sequence holds values for priority and preemption, and can also store user-defined
By default, a task executer will
work on all the tasks in an entire task sequence from start to finish. Then, once the task executer has
finished every task in the task sequence, it will finish/destroy the task sequence, and then look for
a next task sequence to execute.
Task Sequences vs. Tasks: What This Means for Dispatching
Comprehending the difference between task sequences and tasks is important to understanding and
controlling dispatching logic in FlexSim. If
we think of a task as the most basic unit of work in FlexSim, a task sequence is the most
basic unit of dispatching. Task sequences, not individual tasks, can be dispatched and moved around to different queues
or lists. They can be prioritized and selected based on custom criteria, etc. Further, a task sequence enforces a
specific ordering of task execution.
How Task Executers Handle Task Sequences
Task executers primarily keep track of two things:
Active task sequence - The task sequence the task
executer is currently working on.
You can see a task executer's active task sequence in the
tree by navigating to its
Task sequence queue - A queue of task sequences the
task executer has been assigned to work on.
During a simulation run, when a task executer receives a task sequence:
The new task sequence will be added to the task executer's task sequence queue.
If the task executer does not currently have an active task sequence, it will select
a task sequence from its queue. Usually, a task executer will complete task sequences in
the order they are received. In other words, it will do the tasks using FIFO logic
(first in, first out). However, if you use task sequences with different priorities, the
task executer will complete the task sequences in the order of their priority
The selected task sequence will become the active task sequence.
The task executer will complete the tasks in the task sequence, generally uninterrupted, in the order they
were added to the task sequence.
After the active task sequence is complete, the task executer will select another
task sequence from the queue and the process will repeat itself.
Dispatchers vs. Task Executers
A dispatcher object is similar to a task executer, except that it does not have an active task sequence.
It only has a task sequence queue. This is what distinguishes the Dispatcher class from the TaskExecuter
and its sub-classes.
Task Executer Events and Triggers
Task executers have a specific series of events and triggers that they go through while
working on tasks. (See
Concepts About Events for information about events and triggers.) A few of the important
On Start Task
Fires whenever the task executer begins performing a task
On Finish Task
Fires whenever the task executer finishes performing a task.
On Resource Available
Fires whenever the task executer has finished a task sequence, and
is ready to execute another task sequence.
Fires when a task executer loads an item as part of a load task
Fires when a task executer unloads an item as part of an unload task
You can set custom animations or process flow activities to begin when any of
these triggers are fired. You could also use triggers to design look-for-work systems in
which task executers pull task sequences from a global list when their On Resource Available
trigger fires. See
Executer Concepts - Events for a more thorough explanation of the available events and
triggers for task executers.