SwarmFabSim: A Simulation Framework for Bottom-up Optimization

in Flexible Job-Shop Scheduling using NetLogo

M. Umlauft

1 a

, M. Schranz

1 b

and W. Elmenreich

2 c

Lakeside Labs GmbH, Klagenfurt, Austria

Institute of Networked and Embedded Systems, University of Klagenfurt, Klagenfurt, Austria

Keywords:

Swarm Intelligence, Flexible Job-Shop Scheduling, Agent-based Modeling.

Abstract:

This paper models and simulates a semiconductor production plant organized by the job-shop principle as a

self-organizing system using swarm intelligence algorithms in an agent-based simulation tool. We model a

set of agents, including machines, workcenters, lots and processes. To simulate our model, we use NetLogo,

one of the most widely used agent-based simulation platforms. The framework for the simulation was built

as a structured system of code modules using a callback architecture that allows to exchange the used swarm

algorithm easily. The user can conﬁgure their own fab model and simulations via the user interface and

conﬁguration ﬁles. The resulting log ﬁles include several key performance indicators: makespan, average

ﬂow factor, and lot tardiness. We offer the framework including sample swarm algorithms running on NetLogo

version 6.1 and later as open source on GitHub.

1 INTRODUCTION

The factory-wide scheduling of a production plant or-

ganized by the ﬂexible job-shop principle is an NP-

hard challenging problem (Garey et al., 1976). A typ-

ical example for such a highly dynamic process or-

ganized by the job-shop principle is the production

of integrated circuits (ICs) in the semiconductor in-

dustry (Geng, 2018). For our use case, we consider

the so-called front end of line processing, where the

structures of the ICs are created on silicon wafers.

Our implementation is inspired by the real-world re-

quirements of the semiconductor manufacturer Inﬁ-

neon Technologies

. In a fab, they need to sched-

ule between 400 and 1200 different stations in their

production plant. Typically, they produce more than

1500 different products in around 300 different pro-

cess steps, including lithography, doping, oxidation,

etching, and measuring (Geng, 2018).

As traditional optimization methods like linear op-

timization reach their limits in these settings due to

excessive computation time (Garey et al., 1976), we

propose this industrial setting as a novel ﬁeld of ap-

https://orcid.org/0000-0002-0118-2817

https://orcid.org/0000-0002-0714-6569

https://orcid.org/0000-0001-6401-2658

https://www.inﬁneon.com

plication for swarm intelligence. Swarm intelligence

algorithms use local rules and interactions and can be

simulated with agent-based modeling. Swarms in na-

ture typically solve complex problems using compa-

rably simple rules for their swarm agents. One ex-

ample is the foraging strategies of ants, which need

to solve the problem of coordinating exploration, i.e.,

searching for new, unknown food sources and ex-

ploitation, i.e., establishing transport routes to carry

the food into the nest (Dorigo and Stützle, 2004). Pre-

vious work has shown that such swarm algorithms

can be successfully adapted to technical applications

where a problem has to be solved in a complex

(technical) environment; for an overview, see e.g.,

(Schranz et al., 2020). Such swarm-based solutions

are of great interest because of their simple imple-

mentation and features of scalability, robustness, and

adaptivity (Prehofer and Bettstetter, 2005). However,

while a ﬁnal swarm algorithm has a small compu-

tational footprint, deﬁning a swarm algorithm for a

given problem is a non-trivial task (Elmenreich and

de Meer, 2008), which typically involves extensive

evaluations using a simulation of the target system

(Elmenreich et al., 2009). In many cases, the target

system contains a highly dynamic process that cannot

be optimized using analytical methods.

Therefore, in Section 2 we apply an agent-based

modeling and simulation approach for this industrial

Umlauft, M., Schranz, M. and Elmenreich, W.

SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo.

DOI: 10.5220/0011274700003274

In Proceedings of the 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications (SIMULTECH 2022), pages 271-279

ISBN: 978-989-758-578-4; ISSN: 2184-2841

271

setting using the agent-based simulation tool Net-

Logo (Section 2.1). In Section 2.2 we introduce

a modeling concept using different types of agents,

including workcenters, machines, and lots. These

agents are then implemented in the main contribu-

tion of this paper, the SwarmFabSim framework us-

ing NetLogo (Section 3), a system consisting of sev-

eral structured code modules that interact using a call-

back architecture. The user interface, Section 3.1,

and conﬁguration ﬁles, Section 3.2, allow the user

to interact and conﬁgure the SwarmFabSim frame-

work according to the requirements of their own fab

model. Note that despite taking inspiration from

semiconductor manufacturing, our approach is ap-

plicable to other industries using ﬂexible job-shop

scheduling by simply changing the conﬁguration ﬁles

describing the concrete setting. We offer implemen-

tation insights on the architecture in Section 3.3, de-

scribe the base algorithms included with the frame-

work in Section 3.4, and explain the log ﬁles with

the implemented key performance indicators used for

evaluation in Section 3.5. After describing the func-

tionality, we present an example of a speciﬁc swarm

algorithm implemented on the basis of the Swarm-

FabSim framework in Section 3.6, namely a hormone

algorithm and the results from applying it to several

simulation scenarios. Finally, Section 4 shows the

related work on agent-based modeling environments

and other job-shop simulation environments, and Sec-

tion 5 concludes the paper.

2 AGENT-BASED MODELING

FOR FLEXIBLE JOB-SHOP

SCHEDULING

Scheduling is one of the most studied combinatorial

problems typically addressed with linear optimiza-

tion. Nevertheless, these methods can only cope with

a subset of the plant and do not exploit the full opti-

mization potential (Lawler et al., 1993). So far, no op-

timal solution for job-shop scheduling has been devel-

oped using linear optimization that can be computed

in polynomial time (Zhang et al., 2009).

Therefore, we apply a novel approach, namely

swarm intelligence algorithms, which we simulate us-

ing agent-based modeling (ABM). We model the pro-

duction plant as a self-organizing system of homoge-

neous or heterogeneous agents inspired by ﬁsh, ants,

or birds’ natural swarm behavior. This approach al-

lows us to optimize the production plant from the

bottom-up instead of calculating a global optimiza-

tion solution. The beneﬁts are low calculatory over-

head and high adaptability to local changing environ-

mental conditions (Heylighen, 2001), such as starva-

tion or machine downs. This is because the agents fol-

low their own rules and make decisions based on lo-

cal information instead of trying to calculate an over-

all solution. Applying ABM transforms the problem

from ﬁnding an overall solution to deﬁning a dis-

tributed algorithm that ﬁnds the solution from the bot-

tom up.

ABM simulation is better suited to implementing

swarm algorithms than system-dynamics (stock and

ﬂow) simulation or continuous simulation using dif-

ferential equations. In agent-based simulation, swarm

members can be modeled as agents who follow local

rules and typically interact/communicate with other,

nearby agents, the local environment, or information.

(Wilensky and Rand, 2015) give the following

guidelines when to use ABM:

• Medium numbers: several dozen up to about

100000 agents. Our modeling problem consists of

up to several thousand agents (products and ma-

chines).

• Heterogeneity: in ABM, agents can be as hetero-

geneous as necessary. ABM, therefore, lends it-

self well to modeling different product and ma-

chine types.

• Complex but local interactions, as used in swarm

algorithms, are typical for ABM.

• ABM allows for rich environments, which can

have agent-like rules. This can be used to, e.g.,

model complex machine queue manipulations in

our case.

• Time: ABM is a model of process, which is a per-

fect ﬁt to our problem domain.

• Adaptation: almost no other simulation method

can model adaptation well. In ABM, agents’ ac-

tions are typically contingent on past history; i.e.,

agents can learn. This ﬁts the swarm model very

well.

2.1 NetLogo for ABM Simulation

NetLogo (Wilensky, 1999) is one of the most widely

used agent-based simulation platforms worldwide, is

free, well documented, actively maintained with a

mature code base, and offers many extensions. While

NetLogo is well known for its usage in education (esp.

about agent-based modeling and complex systems), it

has also been shown to be a mature platform able to

perform simulations of several thousand agents in fea-

sible computing time (Railsback and Grimm, 2019;

Railsback et al., 2017). For our own performance re-

sults, see Section 3 below. The NetLogo homepage

SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

272

lists 3000+ research papers that have used NetLogo

as the simulation platform in the last 10 years.

NetLogo offers an interactive user interface and

easy visualization for rapid prototyping and an eas-

ily conﬁgurable batch mode (called BehaviorSpace)

to perform mass simulations with multiple parameter

settings and the desired number of replications where

it logs results to ﬁles. These resulting log ﬁles can

then be post-processed with any tool of choice (R,

Excel, etc.) to be statistically evaluated. In addi-

tion, NetLogo can be directly interfaced with other

programming languages such as Python (Gunaratne

and Garibay, 2021) or R (Thiele, 2014), supporting

co-simulation approaches.

Simulation in NetLogo is time-based on a discrete

scale using ticks. Different types of agents can be im-

plemented using so-called “breeds” and can interact

with each other either directly, based on proximity on

a plane of patches, based on their connection via a

network topology, or indirectly by leaving stigmergic

information in the environment.

2.2 Modeling Job-Shop Scheduling

From the considered production plant described in

Section 1, we identiﬁed machines, workcenters, pro-

cesses, lots and recipes as possible agents (ﬁnd

more details on challenges in agent identiﬁcation

in (Schranz et al., 2021)).

The semiconductor production plant can be rep-

resented with a directed graph G = (V, E), where the

nodes V consist of all machines M

, where m is the

machine type, and the edges E are deﬁned between

two machines M

and M

if there exists a lot l

type t with a recipe R

that contains the processes P

and P

that can be executed at machine M

and ma-

chine M

, respectively, in direct succession. Addi-

tionally to this consideration, the edges E deﬁne the

neighborhood of each machine M

. The machines

can be single lot oriented (processing one lot after

the other), or batch-oriented (processing several lots

at once, such as a furnace). They know which pro-

cesses they can perform and what their current utiliza-

tion is. Furthermore, they can make local decisions,

e.g., re-ordering their queues.

A set of machines that can run the same or similar

processes P form a workcenter W ⊂ M. The modeled

production plant contains several sets or workcenters

of machines W

= {M

, M

, . . . }.

In the semiconductor industry, the standard unit

of production is a lot that consists of 25 wafers, each

equipped with a transponder with a unique identiﬁer.

In our model, we do therefore not consider single

wafers, but only lots

. Each product type t is deﬁned

by a recipe R

which prescribes the processing steps

in the order necessary to manufacture this product. As

there typically are multiple machines that can perform

the same process, a lot l

can choose which of the suit-

able machines M

to use for each necessary process

step P

Historically, semiconductor manufacturing used

dispatching to assign lots to machines. In dispatching,

all machines M

that can perform a certain process

step P

share one queue Q

and lots are assigned to

machines by changing their position in the queue via

priority levels so that the next free machine will take

the lot with the highest urgency.

As fabs are being modernized, producers switch

to scheduling, where each machine M

has its own

queue Q

and use schedulers to optimize the assign-

ments of lots to queues for a whole workcenter of ma-

chines. Lots still get assigned priority levels that can

change their position in their assigned queue.

Therefore, in our model, as each lot is produced

step by step according to its recipe, there are two de-

cisions to be made at each step:

1. The position of the lot in the queue. In our im-

plementation, the queue can be re-ordered every

time a machine becomes free and wants to take a

lot from the queue.

2. If the model is run in scheduling mode, whenever

a lot needs to move to the next machine, it has to

choose the respective queue Q

of machine M

from all machines M

that can perform the next

process step P

These decision points are reﬂected in the call-

back API in our simulator implementation (see Sec-

tion 3.3).

3 SIMULATION OF AN ABM FOR

A SMART FACTORY

We implemented the SwarmFabSim simulation

framework in NetLogo (compatible from version

6.1 up). Our framework supports dispatching and

scheduling modes, single lot oriented and batch ma-

chines, and an arbitrary number of machine and lot

types (only limited by available memory and CPU

power). In a performance test of a conﬁguration of

10 000 lots being processed in SwarmFabSim, a Win-

dows 11 system with an AMD Ryzen Threadripper

3960X 24-Core Processor with 128 GB RAM run-

ning NetLogo 6.2.0 takes 24 hours and 52 minutes

If applied to other industries, the industry-speciﬁc unit

of production would be used in the model.

SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo

273

to compute 30 simulation runs being scheduled with

the baseline algorithm (described in Section 3.4).

For prototyping and demonstrations, SwarmFab-

Sim can be started from the user interface (see Sec-

tion 3.1). The actual scenario to be simulated is de-

ﬁned in a set of conﬁg ﬁles (Section 3.2). To run mass

simulations for simulation studies, we use the built-in

BehaviorSpace conﬁguration tool where you can set

multiple parameter settings and the desired number

of replications. The resulting log ﬁles (Section 3.5)

can then be post-processed with any tool of choice

(R, Excel, etc.) to be statistically evaluated.

The NetLogo source code of SwarmFabSim plus

several conﬁguration ﬁles are available as open-

source in a GitHub repository: https://swarmfabsim.

github.io.

3.1 The User Interface

Figure 1: SwarmFab Simulation User Interface.

The simulation can be run in interactive mode from

the user interface shown in Figure 1. The user must

ﬁrst choose several settings, such as which conﬁg ﬁle,

algorithm, and scheduling mode to use and can then

start the simulation by ﬁrst pressing “Setup” and then

either run the simulation with “Go” or single-step

through the simulation with the “Step” button. The

“world” on the right then shows the machines and the

lots as they move through the fab.

3.2 Conﬁg Files

The simulation scenario is deﬁned via a set of plain

text conﬁg ﬁles:

META: the meta conﬁg ﬁle contains the ﬁle names

of the MFILE, RFILE, and LFILE conﬁg ﬁles.

MFILE: contains the machine deﬁnitions. For each

machine type m, it deﬁnes the process id of the

process P

the machine can perform, the number

of machines, the processing time, the batch size

(a batch size of one deﬁnes a single lot oriented

machine), and, in case of a batch machine, a max-

imum waiting time W T that this machine will wait

for a batch to ﬁll up before it starts processing.

RFILE: contains all recipes R

used for production

of the different lot types t. The recipes are sim-

ple lists of the necessary process steps P

in the

required order.

LFILE: deﬁnes how many lots should be produced

for each lot of type t according to the respective

recipe R

3.3 Architecture and Implementation

Details

As shown in Figure 2, the main simulation loop

is contained in the ﬁle SwarmFab-Simulation.nlogo.

Besides the main code entry point and the general

declarations, this ﬁle also describes the UI, the Info

tab (for documentation) and the BehaviorSpace set-

tings. Auxiliary framework code is contained in the

following ﬁles: conﬁg-reader.nls, lots+products.nls,

machines.nls, vizualizations.nls.

Figure 2: Simulation Framework Architecture.

The callback architecture is realized via the API

(application programming interface) deﬁned in ﬁle

hooks.nls: whenever an algorithm can possibly take

an action, the main code calls a hook function con-

tained in hooks.nls from which the respective algo-

rithm function is then called. To install an algorithm,

a ﬁle with the name algorithm-name.nls that imple-

ments the algorithm according to the hook API has

SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

274

to be provided, the algorithm has to be added to the

UI chooser “algorithm” and the algorithm functions

have to be added to the respective hook functions in

hooks.nls for callback. Algorithms can use helper

functions that are provided in the ﬁle helper-api.nls.

Due to this decoupling, the algorithm implementer

never has to touch or even read the actual framework

code. The hook API contains the following functions:

init called upon startup (mandatory).

choose-queue(lot): is called for the algorithm to

choose which machine a given lot shall go to next.

When the simulation is in dispatching mode, this

function is not called, and the lot is automatically

put into the common queue that serves all ma-

chines capable of the necessary next process step.

take-from-queue(machine): after a machine has

ﬁnished a process and has become free again, it

takes a new lot from its queue. This callback pro-

vides the algorithm a chance to re-prioritize lots

in the queue (mandatory).

move-out: this function is called just as a lot is about

to leave a machine at the end of processing. At

this point, an algorithm can collect data or update

data at the machine (mandatory).

tick-start, tick-end: are called at the start and end of

every tick respectively. Can be used to update

data, such as evaporating pheromones (manda-

tory, but can be empty).

do-plotting: allows the algorithm to update the plot

window on the UI (optional).

3.4 Base Algorithms

The framework provides the following three base al-

gorithms as demo code for algorithm implementers

and as a baseline for performance comparisons.

Demo, Basic these algorithms are provided mainly

as demonstration for algorithm implementers.

They demonstrate different approaches to select-

ing a queue, how to make algorithm data persis-

tent between callbacks and how to use the plot

window from an algorithm.

Baseline is a memoryless/stateless algorithm pro-

vided as a reference for performance compar-

isons. For the choose-queue callback it differen-

tiates between single lot oriented and batch ma-

chines. For the former, it chooses the shortest

queue, while for the latter it looks for the queue

where the least amount of lots of the current type

is missing to ﬁll an already waiting, semi-ﬁlled

batch. If there are no partially ﬁlled batches in

any of the potential queues, it chooses the queue

with the least overall queue length (considering

all batches of all other lot types) to start a new

batch of the current type. For the take-from-queue

callback, it differentiates between single lot ori-

ented machines where it uses a FIFO approach

and batch machines, where, if a full batch is avail-

able, that batch is chosen. If several full batches

exist, one is chosen at random. If no full batch

exists, the machine waits up to a maximum wait-

ing time W T (as speciﬁed in the MFILE conﬁg

ﬁle, see Section 3.2). After the W T timeout, the

largest batch is chosen (in case of contention, one

is chosen at random). If a batch ﬁlls up during

W T , it is chosen immediately.

3.5 Log File Output

When the SwarmFab simulation is run from Behav-

iorSpace (the standard method to run multiple simu-

lations for a study in NetLogo), it produces two types

of result log ﬁles: a *-kpi.csv ﬁle and a *-table.csv

ﬁle. Both ﬁles use a plain text, comma-separated

value format which can be post-processed with any

tool of choice for handling tabular data, such as R,

Excel, etc. Further values of interest can be logged by

adding them to the settings in BehaviorSpace.

3.6 Case Study: The Hormone

Algorithm for Fab Optimization

Artiﬁcial hormone algorithms are inspired by the bi-

ological endocrine system adjusting the metabolism

of tissue cells in our body (Turing, 1952; Sobe et al.,

2015). In our case study, we use artiﬁcial hormones

to express the urgency of a lot and the need for at-

tracting incoming lots by the machines. Artiﬁcial hor-

mone is produced by the machines in the production

process and can diffuse through the production sys-

tem along with the lot processing steps. Lots, being

swarm members, are attracted by the hormone level of

a machine. For each processing step, a corresponding

hormone type exists. Hormones can be at any ma-

chine, and different hormone types can be at the same

machine. Every simulation tick hormone degrades

exponentially at a given rate α. Machines produce

hormone to attract lots. The hormone production is

guided by the queue length of the incoming lots. The

more lots are already waiting at a machine, the less

hormone is produced. In contrast, a machine that is

about to run out of lots to be processed will produce

more hormone. Machines are linked via recipes. If

a recipe has a process of two machines in subsequent

steps, the downstream machine (that will process the

SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo

275

lot later) is linked to the upstream machine (that pro-

cesses the machine before).

Table 1: Parameter settings for the artiﬁcial hormone algo-

rithm (Elmenreich et al., 2021).

Parameter Value

Evaporation α .3

Pull factor smoothing β 1

Upstream diffusion γ .5

Downstream diffusion δ .2

Attraction ε .8

The algorithm is based on ﬁve parameters that al-

low ﬁne-tuning the respective mechanisms; the used

parameters are depicted in Table 1. A more detailed

description of the algorithm and its parameters can be

found in (Elmenreich et al., 2021).

We evaluated the artiﬁcial hormone algorithm in

three scenarios modeled after processes in a typical

semiconductor fab. Each scenario differs signiﬁcantly

by the number of machines, with scenario SFAB be-

ing the smallest and scenario LFAB being the largest

setup. The LFAB scenario also has a higher num-

ber of product types and lots per type than the SFAB

and MEDIUM scenarios. The parameters for the three

scenarios are depicted in Table 2.

Table 3 depicts the distribution parameters used

to create machines for a simulation, where N(µ,σ

)

depicts a Normal Distribution and U(a, b) a uniform

distribution. Negative values from the normal distri-

bution have been capped for parameters that cannot

be negative, like process time.

For the evaluation, each scenario setting has been

run 30 times, and the average value is compared to the

performance of the baseline and the basic algorithms.

Processing 30 runs on a Windows 11 system with an

AMD Ryzen Threadripper 3960X 24-Core Processor

with 128 GB RAM running NetLogo 6.2.0 takes 0.35

hours for the SFAB scenario and 424 hours for the

LFAB scenario. The algorithm is evaluated according

to three performance metrics: Average ﬂow factor, av-

erage tardiness, and average uptime utilization. Tardi-

ness describes how much additional time (due to lots

waiting in a queue) has been accumulated until pro-

duction of the lot. Flow factor describes the relation

between the actual production time and the minimum

production time. Uptime utilization represents how

much time a machine has been in operation.

Tables 4, 5, and 6 depict a comparison between

the performance of the reference algorithms basic and

baseline and the artiﬁcial hormone algorithm. All

three scenarios depict promising improvements for

average ﬂow factor (FF), average tardiness (TARD),

and average uptime utilization (UTIL).

4 RELATED WORK

In most cases, factory simulation is done using dis-

crete event process ﬂow simulation with simulators

speciﬁc to the respective application domain. For

semiconductor manufacturing, examples include Au-

toMod / AutoSched AP

or D-Simlab/D-Simcon

For our research, the level of detail supported in these

types of simulators is usually too high. Also, as they

do not support agent-based modeling, they do not lend

themselves to modeling swarm algorithms.

A simulation language that is not speciﬁc to a cer-

tain application domain is GPSS (General Purpose

Simulation System), a discrete time simulation lan-

guage originally developed by IBM. It is used pri-

marily as a process ﬂow-oriented simulation language

which is particularly well-suited for problems such as

modeling factory operations. While its popularity has

declined over the years, several implementations still

exist, such as GPSS World by Minuteman

or JGPSS

by the Polytechnic University of Catalonia. A ranked

list of the most popular discrete simulation software

platforms in commercial use is given in (Dias et al.,

2016).

An example of using NetLogo to simulate a pro-

duction process with a multiple ant colony approach

is shown in (Gwiazda et al., 2020). The authors show

how NetLogo can be used to model the production

process and how a swarm intelligence algorithm –

such as an ant algorithm – can be implemented in an

agent-based modelling simulator and used to solve the

job shop problem.

Zahmani and Atmani use a Netlogo simulation

to create job shop problems with a given value for

jobs and machines. The NetLogo simuation is cou-

pled with a genetic algorithm for discovering well-

working allocations of dispatching rules. (Habib Zah-

mani and Atmani, 2021) Pulikottil et al. review the

various frameworks and different technologies that

support multi-agent system use in manufacturing, the

various applications of multi-agent systems in this do-

main, and the current challenges in the development

of multi-agent systems in smart manufacturing. (Pu-

likottil et al., 2021) Alves et al. address the job shop

scheduling problem with a hybrid approach including

optimization and agents negotiating dynamically. The

agent-based model implemented in NetLogo is con-

nected with Matlab to exchange optimized schedul-

ing solutions. (Alves et al., 2018) Bagheri et al. de-

scribe the promising application of an artiﬁcial im-

https://automod.de/autosched-ap/

http://www.d-simlab.com/

http://www.minutemansoftware.com/simulation.htm

https://jgpss.liam.upc.edu/en/about

SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

276

Table 2: Parameters used to create the three evaluation scenarios.

Parameter SFAB MEDIUM LFAB

Number of machine types 25 50 100

Number of machines per type U(2, 5) U(2, 10) U(2, 10)

Number of products 50 50 100

Recipe length U(90, 110) U(90, 110) U (90, 110)

Number of lots per type U(1, 10) U(1, 10) U(2, 10)

Table 3: Machine parameters used in the simulation.

Machine Parameter Value

Raw process time N(µ,σ

) with µ =

1.16, σ

= 0.32

Probability batch machine 50%

Batch size batch machines U(2, 8)

Waiting time batch machines U (1, 2)

Table 4: Evaluation of Artiﬁcial Hormone Algorithm in

large scenario (LFAB).

Basic Baseline Hormone

Improvement

over Baseline

FF 3.60 3.47 3.03 12.29%

TARD 3287.3 3126.8 2566.4 17.05%

UTIL 24.33 22.71 21.91 3.28%

Table 5: Evaluation of Artiﬁcial Hormone Algorithm in

medium scenario (MEDIUM).

Basic Baseline Hormone

Improvement

over Baseline

FF 3.46 3.21 2.87 9.64%

TARD 2757.8 2481.8 2081.4 14.52%

UTIL 21.42 23.87 23.53 1.60%

Table 6: Evaluation of Artiﬁcial Hormone Algorithm in

small scenario (SFAB).

Basic Baseline Hormone

Improvement

over Baseline

FF 6.64 6.51 5.84 10.12%

TARD 7118.3 6971.1 6077.2 12.56%

UTIL 34.95 35.90 34.49 4.40%

mune algorithm for the ﬂexible job-shop scheduling

problem. The ﬂexible job-shop scheduling problem

has high relevance to the problem described in this

paper but does not have batch machines, which are

typical for semiconductor fabs. The artiﬁcial immune

algorithm is implemented in C++ and evaluated with

a set of tests based on reference data sets. (Bagheri

et al., 2010) Zhang et al. show how agent-based mod-

eling can be applied to job-shop production simu-

lation conceptually. (Zhang et al., 2019) Shukla re-

views multi-agent systems for production scheduling

problems in manufacturing systems. They show how

multi-agent systems can provide advantages over tra-

ditional approaches and present a conceptual frame-

work for implementing production scheduling sys-

tems using multi-agent systems. (Shukla, 2018)

There are many ABM simulation platforms that

can be used to implement a job-shop production simu-

lation. For a comprehensive overview see e.g., CoM-

SES Net / OpenABM

. In the following we list the

most well-known ones besides NetLogo:

Mason is a joint effort between George Mason Uni-

versity’s Evolutionary Computation Laboratory

and the GMU Center for Social Complexity. It is

a discrete-event multi-agent simulator core writ-

ten in Java as a basis for custom-written simula-

tions. It has been in development since 2003. At

the time of writing, it is actively supported

Repast The Repast Suite is a family of advanced,

free, and open source agent-based modeling

toolkits that have been under development for

over 15 years. There are different versions of the

toolkit based on Java, C++, and Python

Mesa is an open source ABM framework written in

Python. Its goal is to be the Python 3-based alter-

native to NetLogo, Repast, or MASON allowing

for easy integration with Python’s data analysis

tools. The tool has been developed since 2015

Anylogic is a commercial platform that supports

System Dynamics, Process-centric discrete event

modeling, and Agent Based Modeling. It is used

in several industries, including manufacturing,

supply chain, transportation and logistics, etc

MARS (Multi-Agent Research and Simulation) runs

on .NET Core. It is developed at the Department

of Computer Science at Hamburg University of

Applied Sciences

https://www.comses.net/resources/

modeling-frameworks/

https://cs.gmu.edu/~eclab/projects/mason/

https://repast.github.io/

https://mesa.readthedocs.io/en/latest/

https://www.anylogic.com/

https://mars-group.org/

SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo

277

5 CONCLUSION

This paper has depicted the use of NetLogo to

model and simulate a factory producing according

to the job-shop manufacturing principle. We con-

tributed SwarmFabSim, a modular simulation frame-

work written in NetLogo that can apply various al-

gorithms to optimize a make-to-order manufacturing

system and supports multiple conﬁgurable scenarios.

The evaluation framework was used to assess the ef-

fectiveness of an artiﬁcial hormone algorithm com-

pared to a naïve basic implementation and a reference

baseline algorithm. The evaluation was based on three

key performance indicators: Flow factor, delay, and

utilization. The simulations show promising results

of the artiﬁcial hormone algorithm in three reference

scenarios with signiﬁcant improvements over the ref-

erence algorithms. The implementation of the simula-

tion environment is published as open source in a Git

repository

. Readers are welcome to contribute with

their ideas and developments.

ACKNOWLEDGEMENT

This work was performed in the course of project

ML&Swarms supported by KWF-React EU under

contract number KWF-20214|34789|50819.

REFERENCES

Alves, F., Varela, M. L. R., Rocha, A. M. A., Pereira, A. I.,

Barbosa, J., and Leitão, P. (2018). Hybrid system

for simultaneous job shop scheduling and layout opti-

mization based on multi-agents and genetic algorithm.

In International Conference on Hybrid Intelligent Sys-

tems, pages 387–397. Springer.

Bagheri, A., Zandieh, M., Mahdavi, I., and Yazdani, M.

(2010). An artiﬁcial immune algorithm for the ﬂex-

ible job-shop scheduling problem. Future Generation

Computer Systems, 26(4):533–541.

Dias, L. M., Vieira, A. A., Pereira, G. A., and Oliveira,

J. A. (2016). Discrete simulation software ranking—a

top list of the worldwide most popular and used tools.

In 2016 Winter Simulation Conference, pages 1060–

1071. IEEE.

Dorigo, M. and Stützle, T. (2004). Ant Colony Optimiza-

tion. A Bradford Book, The MIT Press.

Elmenreich, W. and de Meer, H. (2008). Self-organizing

networked systems for technical applications: A dis-

cussion on open issues. In K.A. Hummel, J. S., editor,

Proceedings of the Third International Workshop on

Self-Organizing Systems, pages 1–9. Springer Verlag.

https://swarmfabsim.github.io

Elmenreich, W., D’Souza, R., Bettstetter, C., and de Meer,

H. (2009). A survey of models and design methods for

self-organizing networked systems. In Proceedings of

the Fourth International Workshop on Self-Organizing

Systems, volume LNCS 5918, pages 37–49. Springer

Verlag.

Elmenreich, W., Schnabl, A., and Schranz, M. (2021).

An artiﬁcial hormone-based algorithm for production

scheduling from the bottom-up. In Proceedings of the

13th International Conference on Agents and Artiﬁ-

cial Intelligence. SciTePress.

Garey, M. R., Johnson, D. S., and Sethi, R. (1976).

The complexity of ﬂowshop and jobshop scheduling.

Mathematics of Operations Research, 1(2):117–129.

Geng, H., editor (2018). Semiconductor Manufacturing

Handbook. McGraw-Hill Education.

Gunaratne, C. and Garibay, I. (2021). NL4Py: Agent-

based modeling in Python with parallelizable NetL-

ogo workspaces. SoftwareX, 16:100801.

Gwiazda, A., Bana

s, W., S˛ekala, A., Topolska, S., and

Hryniewicz, P. (2020). Modelling of production pro-

cess using multiple ant colony approach. Interna-

tional Journal of Modern Manufacturing Technolo-

gies, XII(1):201–213.

Habib Zahmani, M. and Atmani, B. (2021). Multiple dis-

patching rules allocation in real time using data min-

ing, genetic algorithms, and simulation. Journal of

Scheduling, 24(2):175–196.

Heylighen, F. (2001). The science of self-organization and

adaptivity. The Encyclopedia of Life Support Systems,

5(3):253–280.

Lawler, E. L., Lenstra, J. K., Kan, A. H. R., and Shmoys,

D. B. (1993). Sequencing and scheduling: Algorithms

and complexity. Handbooks in Operations Research

and Management Science, 4:445–522.

Prehofer, C. and Bettstetter, C. (2005). Self-organization

in communication networks: Principles and design

paradigms. IEEE Communications Magazine, pages

78–85.

Pulikottil, T., Estrada-Jimenez, L. A., Rehman, H. U.,

Barata, J., Nikghadam-Hojjati, S., and Zarzycki, L.

(2021). Multi-agent based manufacturing: current

trends and challenges. In 2021 26th IEEE Interna-

tional Conference on Emerging Technologies and Fac-

tory Automation (ETFA), pages 1–7. IEEE.

Railsback, S., Ayllón, D., Berger, U., Grimm, V., Lytinen,

S., Sheppard, C., and Thiele, J. C. (2017). Improving

execution speed of models implemented in netlogo.

Journal of Artiﬁcial Societies and Social Simulation.

Railsback, S. F. and Grimm, V. (2019). Agent-based and

individual-based modeling: a practical introduction.

Princeton university press, "2nd" edition.

Schranz, M., Umlauft, M., and Elmenreich, W. (2021).

Bottom-up job shop scheduling with swarm intelli-

gence in large production plants. In Proceedings of

the 11th International Conference on Simulation and

Modeling Methodologies, Technologies and Applica-

tions, pages 327–334.

Schranz, M., Umlauft, M., Sende, M., and Elmenreich, W.

(2020). Swarm robotic behaviors and current applica-

tions. Frontiers in Robotics and AI, 7:36.

SIMULTECH 2022 - 12th International Conference on Simulation and Modeling Methodologies, Technologies and Applications

278

Shukla, O. J. (2018). Agent Based Production Scheduling

in Job Shop Manufacturing System. . . . PhD thesis,

MNIT Jaipur.

Sobe, A., Elmenreich, W., Szkaliczki, T., and Böszörmenyi,

L. (2015). SEAHORSE: Generalizing an artiﬁcial hor-

mone system algorithm to a middleware for search and

delivery of information units. Computer Networks,

80:124–142.

Thiele, J. C. (2014). R marries NetLogo: introduction to the

RNetLogo package. Journal of Statistical Software,

58:1–41.

Turing, A. M. (1952). The chemical basis of morphogene-

sis. Philosophical Transactions of the Royal Society of

London. Series B, Biological Sciences, 237(641):37–

72.

Wilensky, U. (1999). Netlogo. http://ccl.northwestern.edu/

netlogo/.

Wilensky, U. and Rand, W. (2015). An Introduction to

Agent-Based Modeling: Modeling Natural, Social,

and Engineered Complex Systems with NetLogo. MIT

Press.

Zhang, G., Shao, X., Li, P., and Gao, L. (2009). An effec-

tive hybrid particle swarm optimization algorithm for

multi-objective ﬂexible job-shop scheduling problem.

Computers & Industrial Engineering, 56(4):1309–

1318.

Zhang, T., Xie, S., and Rose, O. (2019). Agent-based sim-

ulation of job shop production. Simul. Notes Eur.,

29(3):141–148.

SwarmFabSim: A Simulation Framework for Bottom-up Optimization in Flexible Job-Shop Scheduling using NetLogo

279