Bottleneck Identification in Resource-Constrained Project Scheduling via
Constraint Relaxation
Luk
´
a
ˇ
s Nedb
´
alek
1,2
and Anton
´
ın Nov
´
ak
2
1
Faculty of Mathematics and Physics, Charles University, Prague, Czech Republic
2
Czech Institute of Informatics, Robotics and Cybernetics, Czech Technical University in Prague, Czech Republic
Keywords:
Scheduling, RCPSP, Bottlenecks, Constraint Relaxation.
Abstract:
In realistic production scenarios, Advanced Planning and Scheduling (APS) tools often require manual in-
tervention by production planners, as the system works with incomplete information, resulting in suboptimal
schedules. Often, the preferable solution is not found just because of the too-restrictive constraints specifying
the optimization problem, representing bottlenecks in the schedule. To provide computer-assisted support for
decision-making, we aim to automatically identify bottlenecks in the given schedule while linking them to
the particular constraints to be relaxed. In this work, we address the problem of reducing the tardiness of a
particular project in an obtained schedule in the resource-constrained project scheduling problem by relaxing
constraints related to identified bottlenecks. We develop two methods for this purpose. The first method adapts
existing approaches from the job shop literature and utilizes them for so-called untargeted relaxations. The
second method identifies potential improvements in relaxed versions of the problem and proposes targeted
relaxations. Surprisingly, the untargeted relaxations result in improvements comparable to the targeted relax-
ations.
1 INTRODUCTION
In the modern manufacturing industry, Advanced
Planning and Scheduling (APS) tools are used to
schedule production automatically. However, not all
parameters and information are available to the APS
systems in practice. Thus, the solutions obtained
with the scheduling tools may not be preferable to the
users. This leads to repeated interactions of the pro-
duction planners with the APS system, adjusting the
problem parameters to obtain an acceptable schedule.
We address a common problem in production—
reducing the delay of a selected project in an existing
production schedule. We achieve this by identifying
manufacturing bottlenecks in the schedule and related
constraints. Bottlenecks represent resources or con-
straints with the most significant impact on produc-
tion performance. The algorithm identifies these bot-
tlenecks and suggests appropriate relaxations in the
form of a modified schedule. The modified schedule
is then offered to the decision maker to compare the
improvements, and the changes can then be accepted,
rejected, or augmented to suit the current needs.
See an example in Figure 1. In the original sched-
ule, the target project J
8
should preferably have been
Capacity
Capacity
JobsResource 1
Resource 1
Jobs
Time
Time
Relaxed schedule
Original schedule
Due date Target project
Capacity constraint relaxation
Tardiness improvement
Figure 1: Example of an original and relaxed schedule with
8 jobs and a single resource. The Jobs segments show the
(overlapping) scheduling of jobs in time. The Resource 1
segments show the cumulative consumption of the single
resource by the scheduled jobs. In the Relaxed schedule
the Capacity constraint relaxation refers to the temporary
increase of the resource capacity.
completed earlier, but the resource capacity is insuf-
ficient. The target project could be completed earlier
by relaxing the capacity constraint, as shown in the
relaxed schedule. This relaxation can then be inter-
340
Nedbálek, L. and Novák, A.
Bottleneck Identification in Resource-Constrained Project Scheduling via Constraint Relaxation.
DOI: 10.5220/0013253700003893
Paper published under CC license (CC BY-NC-ND 4.0)
In Proceedings of the 14th International Conference on Operations Research and Enterprise Systems (ICORES 2025), pages 340-347
ISBN: 978-989-758-732-0; ISSN: 2184-4372
Proceedings Copyright © 2025 by SCITEPRESS – Science and Technology Publications, Lda.

preted as, e.g., adjusting the start of a shift for a single
employee.
The above example is a particularly simple case of
the problem; in reality, activities of different projects
have complex interactions across multiple resources,
making the identification of the constraints to be re-
laxed a difficult problem. In some sense, this ap-
proach is similar to the concept of duality known in
continuous optimization (e.g., shadow prices in Lin-
ear Programming), which does not apply to discrete
optimization problems.
We develop two different methods to address the
problem. The first method adapts existing approaches
from the literature, which address the problem in
simpler scheduling models. The second method uti-
lizes relaxations that focus specifically on the target
project. To compare the methods, we present a set of
problem instances designed to model the addressed
scheduling problem, and we evaluate the two meth-
ods using the presented problem instances.
2 RELATED WORK
Following the work of Wang et al. (2016), we focus
on Execution bottleneck machines, which are bottle-
necks in a constructed schedule for a given problem
instance, i.e., not for the model of the production but
for the specific data. The identified execution bottle-
necks may vary between problem instances and their
constructed schedules. Focusing on execution bottle-
necks aims to improve performance for the specific
problem instance, i.e., case-based relaxation.
2.1 Bottlenecks in the RCPSP
To the best of our knowledge, no relevant research
focuses mainly on identifying bottlenecks in the
RCPSP. The closest research on bottlenecks can be
found for the Job-Shop problem—scheduling on unit-
capacity resources.
Luo et al. (2023) studied how identifying bottle-
neck machines can guide the scheduling process of a
genetic algorithm. In their case study, Arkhipov et al.
(2017) proposed a heuristic approach for estimating
project makespan and resource load profiles. Those
estimations are, in turn, used to identify bottleneck re-
sources. However, the identified bottleneck resources
were not addressed further.
2.2 Relaxing the Identified Bottlenecks
Lawrence et al. (1994) studied how identified bottle-
necks shift between machines in response to introduc-
ing relaxations to the original problem. They relaxed
“short-run” bottlenecks by increasing the capacity of
the identified bottleneck resources and then observed
whether the bottlenecks shifted to a different machine.
The authors observed that while such relaxations are
effective at relaxing local bottlenecks, they also in-
crease the “bottleneck shiftiness”.
In their study, R. Zhang et al. (2012) addressed
the Job-Shop problem by first relaxing its capacity
constraints, solving the modified relaxed problem and
identifying bottlenecks in its solution. The obtained
information was used to guide a proposed simulated
annealing algorithm to find a solution to the original
problem. Thus, the relaxation served only as an inter-
mediate step toward obtaining a solution, rather than
being the desired result.
2.3 Contribution
The specific contributions of this paper are:
• We extend two standard Job-Shop bottleneck
identification indicators for application to the
RCPSP. We then develop a method utilizing the
extended indicators for proposing untargeted re-
source constraint relaxations.
• We develop an approach for proposing targeted
relaxations specifically for the RCPSP extended
with time-variant resource capacities.
3 PROBLEM STATEMENT
3.1 Scheduling Model
We assume the PSm | intree |
∑
j
w
j
T
j
variant of the
RCPSP with several extensions to model the ad-
dressed problem.
We define a problem instance I as a 4-tuple
(J ,P , R ,T ), where J = {1,...,n} is the set of jobs,
P is the set of all precedences constraints, R =
{1,...,m} is the set of resources, T ∈ N is the time
horizon of the problem instance.
Each job j ∈ J has a processing duration p
j
and a
due date d
j
. A tardiness weight w
j
defines the penalty
for each time period the job is tardy, i.e., not com-
pleted before its due date. Preemption of jobs is not
allowed. The order of jobs is constrained with prece-
dence constraints i→ j or (i, j) ∈ P . We define the
precedence graph G = (J ,P ), which is assumed to be
an inforest, consisting of a set of connected in-trees.
Jobs are assigned to resources R with time-variant
renewable capacities. The capacity of a resource
k ∈ R during a time period t ∈ {1,. . .,T } is denoted
Bottleneck Identification in Resource-Constrained Project Scheduling via Constraint Relaxation
341

as R
(t)
k
. We assume the capacities of resources to
represent the availability of workers operating the re-
source. Such capacities can (to some extent) be al-
tered in correspondence to changing the number of
operating workers. For a job j, the per-period con-
sumption of a resource k is denoted as r
jk
. We as-
sume that jobs can simultaneously consume multiple
resources. The resource capacity functions R
(t)
k
are
assumed to be periodic with a period of 24. With
this, we model working shifts for the operating work-
ers (e.g., one, two, or three-shift operations).
The set of projects P = { j ∈ J | ∄i : j→i} is the
set of roots of the precedence in-trees. A job j ∈ P is
called a project. For a job j, due date d
j
∈ N
0
is given
if j ∈ P; +∞ otherwise, and tardiness weight w
j
≥ 0
is specified if j ∈ P; 0 otherwise, i.e., the tardiness
penalty and its weight is applied to the last job of each
connected component representing a single project.
3.2 Constraint Programming
Formulation
The above scheduling problem can be stated as the
following constraint programming model:
min
∑
j∈J
w
j
T
j
(1)
s.t. C
i
≤ S
j
∀i→ j ∈ P (2)
∑
j∈J
c
(t)
jk
≤ R
(t)
k
∀t ∈ {1,...,T } ∀k ∈ R (3)
where S = (S
1
,. . . ,S
n
) ∈ N
n
0
C = (S
1
+ p
1
,. . . ,S
n
+ p
n
)
T
j
= max(0,C
j
− d
j
)
c
(t)
jk
= r
jk
if S
j
≤ t < C
j
; 0 otherwise
The expression (1) is the optimization minimiza-
tion objective — the weighted tardiness of jobs.
Equation (2) formulates the precedence constraints.
and Equation (3) describes the resource capacity con-
straints — in every time period, the combined con-
sumption of jobs scheduled during the period cannot
exceed any of the resource’s capacities.
We assume we have access to a solver capable
of solving (1)–(3) in a reasonable time (i.e., to pro-
vide computer-assisted decision-making to produc-
tion planners) through the use of constraint program-
ming solvers, such as CP-SAT or IBM CP Optimizer.
3.3 Constraints Relaxation
Some constraints, such as job precedences, job du-
rations, or resource consumption, are inherent to the
problem (i.e., defining technological processes, phys-
ical constraints, etc.) and cannot be relaxed. The
available capacities of the resources can be modified
when they reflect, e.g., the number of the available
workforce at the specific stage of the production pro-
cess.
We consider resource capacity additions and
capacity migrations as the possible relaxations of
scheduling constraints (3). Capacity addition is
a 4-tuple (k,s,e, c), where over the time periods
{s,. . . ,e − 1} the capacity of the resource k is in-
creased by c. Analogously, capacity migration is a
5-tuple (k
from
,k
to
,s, e,c), where over the time peri-
ods {s,. ..,e − 1} the capacity of the resource k
from
is lowered by c and the capacity of the resource k
to
is
increased by the same amount c. For a modified in-
stance I
∗
, the sets of all migrations and additions are
denoted as M
I
∗
and A
I
∗
, respectively.
In a real-world production system, migrating ca-
pacities can be more cost-effective than adding new
capacities. For example, reassigning workers from an
underutilized machine to a bottleneck machine is typ-
ically less expensive than extending workers’ shifts
into overtime or planning an entirely new and irreg-
ular shift. Therefore, capacity migrations are usu-
ally preferred. However, if the required capacity ad-
justments cannot be achieved through capacity migra-
tions, capacity additions can be utilized.
3.4 General Procedure
The general procedure for solving the presented prob-
lem, identifying bottlenecks, relaxing corresponding
constraints, and solving the modified problem in-
stance works as follows:
1. Obtain a solution S to the problem instance I .
2. Select a target project p ∈ P for tardiness improve-
ment. We consider an improvement to be any non-
zero decrease in the project’s tardiness.
3. Identify bottlenecks in the solution S to I .
4. Relax constraints corresponding to the identified
bottlenecks. To do so, we utilize capacity migra-
tions and capacity additions, as described in Sec-
tion 3.3. Such relaxations are captured in a modi-
fied problem instance I
∗
.
5. Find solution S
∗
to I
∗
.
6. Evaluate the obtained solution S
∗
. Specifically,
how the introduced relaxations improve the tar-
diness of the target project.
ICORES 2025 - 14th International Conference on Operations Research and Enterprise Systems
342

4 SOLUTION PROCEDURE
We present two algorithms designed for identifying
and relaxing bottlenecks in the RCPSP. Both algo-
rithms aim to improve the tardiness of a selected
project by introducing relaxations to the capacity con-
straints. We divide the approaches into two groups
— untargeted and targeted relaxations depending on
whether they consider the target project when identi-
fying bottlenecks. Thus, untargeted relaxations affect
the selected project only indirectly.
4.1 Untargeted Relaxations
In this section, we propose adaptations of existing
bottleneck identification indicators from the Job-Shop
literature. Utilizing the adapted indicators, we pro-
pose the Identification Indicator-based Relaxing Al-
gorithm (IIRA) for untargeted relaxations of capacity
constraints in an obtained schedule.
4.1.1 Adapted Identification Indicators
We adapt two existing bottleneck identification indi-
cators. The Machine Utilization Rate (MUR), first
utilized as a bottleneck identification indicator by
Lawrence et al. (1994), considers the ratio of ex-
ecuted work on a resource to the total time the re-
source was used. The Average Uninterrupted Active
Duration (AUAD), initially proposed by Roser et al.
(2001), computes the average length of uninterrupted
execution periods, where an uninterrupted execution
period is a sequence of scheduled immediately con-
secutive jobs.
Both identification indicators consider the rela-
tionship between the total duration of job executions
on a resource and the duration for which the resource
is idle. In a Job-Shop scheduling problem, this rep-
resents all the available information. In the RCPSP,
however, we can utilize different resource capacities
and variable resource loads for computing more com-
plex identification indicators.
We propose Machine Resource Utilization Rate
(MRUR) as the adaptation of MUR and Average Un-
interrupted Active Utilization (AUAU) as the adapta-
tion of AUAD. For resource k, the MRUR is defined
as:
MRUR
k
def
=
∑
j∈J
(p
j
· r
jk
)
∑
C
max
t=1
R
(t)
k
,
where C
max
def
= max
j∈J
C
j
. For resource k, the AUAU
is defined as:
AUAU
k
def
=
∑
A
k
i=1
PRU
(i)
k
A
k
,
where the Period Resource Utilization (PRU) PRU
(i)
k
of resource k during the uninterrupted active period i
is defined as
PRU
(i)
k
def
=
∑
j∈J
UAP(i)
k
p
j
· r
jk
∑
a
E
k,i
t=a
S
k,i
R
(t)
k
.
For resource k ∈ R , (a
S
k,1
,a
E
k,1
),. . . ,(a
S
k,A
k
,a
E
k,A
k
) is
the sequence of uninterrupted active periods, where
a
S
k,i
∈ {1,. . . ,T − 1} denotes the start of the period i
and a
E
k,i
∈ {a
S
ki
+ 1, . . .,T } denotes the end of the pe-
riod i. An uninterrupted active period is a (maximal)
set of jobs scheduled consecutively or in parallel with
no idle time on the considered resource during the pe-
riod. In the formula for PRU
(i)
k
,
J
UAP(i)
k
def
= { j ∈ J
k
: a
S
k,i
≤ S
j
≤ a
E
k,i
}
is the set of jobs executed on resource k during the
uninterrupted active period i, where
J
k
= { j ∈ J : r
jk
> 0}.
4.1.2 Identification Indicator-Based Relaxing
Algorithm
The function of Identification Indicator-based Relax-
ing Algorithm (IIRA) is illustrated in Figure 2 and is
formally described in Algorithm 1.
First, the bottleneck resource is identified us-
ing a specified bottleneck identification indicator I ∈
{AUAU, MRUR} (lines 2 and 3). The granular load
of the bottleneck resource (line 4) indicates the re-
source’s utilization over granular periods — granu-
lar periods each represent G time periods for efficient
computation. Convolution with a chosen kernel func-
tion is used to obtain the improvement potential of
granular periods (line 5) and periods with the most
improvement potential are then selected for capacity
increase, relaxing the represented capacity constraints
(lines 6 and 7). The convolution “distributes” the lo-
cal information about the machine load to adjacent
periods to estimate which periods to focus on. Fi-
nally, a new solution to the modified problem instance
is found (line 8), capacity functions are reduced to
only contain additional capacities consumed by jobs,
and migrations and additions are identified.
4.2 Targeted Relaxations
As an alternative to untargeted relaxations, in this sec-
tion, we present a method for detecting bottlenecks
and relaxing related constraints in the RCPSP which
focuses on a specified target project and its tardiness.
Bottleneck Identification in Resource-Constrained Project Scheduling via Constraint Relaxation
343

Modified Schedule
Original Schedule
Identify bottleneck resource
Convolve with
improvement kernel
function
Relax capacity
over identified
improvement period
Compute
resource load and
granular resource load
Jobs
R1
Capacity
R2
Capacity
R2
Capacity
R1
Capacity
Jobs
Figure 2: Illustration of the IIRA. Starting with the original schedule, the bottleneck resource is identified using the identifi-
cation indicator, granular resource load is computed for the resource, utilizing convolution, a specific improvement period is
chosen for capacity relaxation, and a modified schedule is obtained.
Algorithm 1: Identification Indicator-based Relaxing Algo-
rithm (IIRA).
Parameters: Identification indicator I, convolution
kernel C, granularity G, improvement periods
limit P
max
, iterations limit I
max
, capacity improve-
ment ∆.
Input: Solution S to problem instance I .
1: repeat:
2: Evaluate S
∗
using I, obtaining: I
k
∀k ∈ R
3: Identify bottleneck resource: k
′
← argmax
k
I
k
4: Compute granular resource load L
k
′
(G)
5: Period improvement potential: Ψ ← L
k
′
(G)∗ C
6: Select periods with highest Ψ(i): p
1
,. . . , p
P
max
7: Increase capacity R
′
k
′
over the periods by ∆
8: Find solution S
∗
to the modified instance I
∗
9: Reduce capacity changes in R
′
1
,. . . ,R
′
m
10: Find migrations M
I
∗
and additions A
I
∗
11: for I
max
iterations
Output: Modified instance I
∗
and its solution S
∗
,
additions A
I
∗
, migrations M
I
∗
.
The proposed Schedule Suffix Interval Relaxing Al-
gorithm is based on finding improvement intervals in
partially relaxed versions of the given problem. A
small subset of the improvement intervals is then se-
lected, and capacity constraints corresponding to the
selected improvement intervals are relaxed. The tar-
geted relaxation aims to identify relaxations specifi-
cally for the target project requiring small changes to
improve the tardiness of the project.
4.2.1 Preliminaries
To formulate Schedule Suffix Interval Relaxing Al-
gorithm (SSIRA), we state the necessary definitions
and the key ideas. First, we define the suffix-relaxed
schedule, which is a modification of an obtained
schedule where the algorithm finds improvement in-
tervals.
Definition 1 (Suffix-relaxed schedule). Let S =
(S
1
,. . . ,S
n
) be a schedule to a problem instance I .
Given a time period t ∈ {1,. . . , T }, the suffix-relaxed
schedule for the time period t is given by σ
(t)
=
(σ
(t)
1
,. . . ,σ
(t)
n
), where
σ
(t)
j
def
=
(
S
j
if S
j
≤ t;
max
n
σ
(t)
i
+ p
i
: i→ j ∈ P
o
otherwise.
The precedence graph is acyclic; thus, all values
of σ
(t)
i
are well-defined. The suffix-relaxed schedule
essentially relaxes resource capacity constraints for
all jobs that start after the time period t in the original
schedule. The main idea is to incrementally observe
how jobs that are constrained by insufficient capac-
ities and precedence constraints could be scheduled
earlier.
We define the left-shift closure as a tool for guid-
ing the search for improvement intervals towards im-
proving the tardiness of the target project. The left-
shift closure of a job j defines the set of all jobs that
need to be scheduled earlier for the job j to decrease
its completion time.
Definition 2 (Left-shift closure). Let S = (S
1
,. . . ,S
n
)
be a schedule to problem instance I . The left-shift
closure of a job j ∈ J is the set L( j) ⊆ J , where:
i) j ∈ L( j).
ii) All precedence predecessors immediately preced-
ing in the schedule are included.
iii) All jobs sharing a common resource immediately
preceding in the schedule are included.
ICORES 2025 - 14th International Conference on Operations Research and Enterprise Systems
344

iv) If j is scheduled exactly at any start of a re-
source’s availability interval, all jobs scheduled
at the end of the previous availability interval are
included. For a given resource, an availability in-
terval is a sequence of consequtive time periods
where the resource’s capacity is non-zero.
Condition i) is a trivial base case. Condition ii)
states that a immediate precedence predecessor i of
the job j (i.e., i→ j ∈ P ) is included in L( j) if the
jobs are scheduled consecutively, i.e. C
i
= S
j
. Condi-
tion iii) involves all jobs scheduled consecutively be-
fore the job j, which share at least one required re-
source. In this case, the consumption of the shared re-
source by the preceding job can be sufficiently large to
prevent the job j from being scheduled earlier. Condi-
tion iv) involves jobs at the end of the previous work-
ing shift. Assuming sufficient slack in precedence
constraints, the job j starts exactly at the start of a
working shift because it could not have been sched-
uled at the end of the previous working shift due to the
lack of remaining capacities on its required resources.
4.2.2 Schedule Suffix Interval Relaxing
Algorithm
The schematic highlight of SSIRA is displayed in Fig-
ure 3 and is formally given in Algorithm 2. First,
improvement intervals are identified using the FIND-
INTERVALSTORELAX function (line 3). Resource
capacities are then relaxed based on these intervals
(line 4). Finally, as in the IIRA, a solution to the modi-
fied instance is found, capacity functions are reduced,
and migrations and additions are identified.
The FINDINTERVALSTORELAX function, de-
scribed in Algorithm 3, finds improvement intervals
in suffix-relaxed schedules and selects the best inter-
vals based on a given ordering. Suffix-relaxed sched-
ules are computed for each time period (line 1), repre-
senting all possible job-interval relaxations. The left-
shift closure of the target project is computed (line 2).
This closure represents the set of jobs considered for
improvement. For jobs within the closure, poten-
tial improvement intervals are identified (lines 3–6),
where the starting time of each interval is the earliest
relaxed starting time across all suffix-relaxed sched-
ules (line 5). Finally, a given number of intervals is
selected based on a specified sort key (line 7).
5 EXPERIMENTS
We evaluate the performance of an untargeted bottle-
neck detection method called Identification Indicator-
based Relaxing Algorithm (IIRA) and a targeted
method called Schedule Suffix Interval Relaxing Al-
Algorithm 2: Schedule Suffix Interval Relaxing Algorithm
(SSIRA).
Parameters: Iterations limit I
max
, improvement in-
tervals limit IT
max
, interval sort key K .
Input: Solution S to instance I , target project p.
1: I
∗
← I , S
∗
← S ▷ Modified instance and solution
2: repeat:
3: χ
1
,. . . ,χ
IT
max
← FINDINTERVALSTORELAX
4: Increase capacities R
∗
1
,. . . ,R
∗
m
in the intervals
5: Find solution S
∗
to the modified instance I
∗
6: Reduce capacity changes in R
∗
1
,. . . ,R
∗
m
7: Find migrations M
I
∗
and additions A
I
∗
8: for I
max
iterations
Output: Modified instance I
∗
and its solution S
∗
,
additions A
I
∗
, migrations M
I
∗
.
Algorithm 3: FindIntervalsToRelax.
Input: Problem instance I , its solution S, improve-
ment intervals limit IT
max
, interval sort key K ,
target project p.
1: Compute suffix-relaxed schedules σ
(1)
,. . . ,σ
(T )
2: Compute left-shift closure L(p)
3: X ←
/
0
4: for j ∈ L(p) :
5: s ← min
t
n
σ
(t)
j
: σ
(t)
j
< S
j
o
6: X ← X ∪

( j, s, s + p
j
)

7: Find first χ
1
,. . . ,χ
IT
max
from X ordered by K
Output: Improvement intervals χ
1
,. . . ,χ
IT
max
,
a set of 3-tuples ( j, s, e) ∈ J × {1,...,T }
2
.
gorithm (SSIRA). We first design benchmark in-
stances that model the addressed problem and choose
ranges of parameters for each algorithm, creating
evaluation parameter sets. Then, we conduct the ex-
periments, make several observations about the out-
comes, and discuss the achieved results.
5.1 Setup
We use and modify specific instances from the
PSPLIB single-mode instance set. The modifica-
tions include splitting the precedence graph to create
individual project components, introducing job due
dates, introducing time-variable resource capacities,
and scaling down job durations and resource con-
sumptions for otherwise infeasible instances. We pro-
pose eight problem instance groups, each consisting
of five individual instances of similar properties (e.g.,
precedence graph structure or project due dates).
We use the IBM CP Optimizer for finding optimal
solutions. The solver time limit for finding a single
solution was set to 10 seconds. Subsequent solving of
Bottleneck Identification in Resource-Constrained Project Scheduling via Constraint Relaxation
345

Modified Schedule
Original Schedule
Find improvement intervals in
suffix-relaxed schedules
Find improvement intervals
and select best intervals
by selected sorting order
Relax capacities during
selected improvement intervals
Selected by
time period sorting
Jobs
R1
Capacity
R2
Capacity
R2
Capacity
R1
Capacity
Jobs
Figure 3: Illustration of the SSIRA. Starting with the original schedule, improvement intervals are found in suffix-relaxed
schedules, the best improvement intervals are selected, corresponding capacities are relaxed, and a new schedule is obtained.
Table 1: Improving solutions found for the proposed prob-
lem instances. The Improved value states the number of in-
stances the algorithm found an improving solution for, the
Unique value states how many were uniquely found w.r.t.
the other algorithm, and the Best value states how many
were the best-improving solutions.
Algorithm Criteria Solutions % (of 40)
Improving 29 72.5%
72.5%
72.5%
IIRA Unique 0 0%
Best 22 55%
Improving 35 87.5%
87.5%
87.5%
SSIRA Unique 6 15%
Best 25 62.5%
modified instances utilizes solver warm-starting. The
experiments and the created instances can be found
on GitHub
1
.
For both algorithms IIRA and SSIRA, all com-
binations of parameter values are considered, form-
ing a total of 288 combinations for the IIRA and 36
combinations for the SSIRA. Algorithms are evalu-
ated with each combination of values on every prob-
lem instance.
The following metrics are computed:
• Tardiness improvement ∆T
p
def
= T
p
−T
∗
p
. This met-
ric is also meaningful for the IIRA (i.e., un-
targeted), where we measure ∆T
p
for the target
project p.
• Solution difference ∆S
def
=
∑
j∈J



C
j
−C
∗
j



.
5.2 Comparative Results
Table 1 summarizes achieved improvements. The
SSIRA found improvements for more instances than
1
https://github.com/Krtiiik/RCPSPSandbox
0 10 20 30 40 50 60 70 80
Improvement ∆T
p
0
400
800
1200
1600
2000
2400
2800
Schedule difference ∆S
SSIRA (improvement sort)
SSIRA (time sort)
IIRA (AUAU)
IIRA (MRUR)
Figure 4: An example evaluation displays schedule differ-
ences versus achieved improvement. Surprisingly, the IIRA
often finds better solutions than SSIRA.
the IIRA, moreover, IIRA did not improve any in-
stance which the SSIRA would not improve.
As expected, greater tardiness improvements gen-
erally induce larger schedule differences. The SSIRA
utilizing the K
∆S
sort key tends to propose the least
favorable solutions in terms of the induced schedule
difference and is the most inconsistent in finding im-
proving solutions. The SSIRA with the K
t
sort key
finds improving solutions consistently across many
instances. However, for some instances, the IIRA
is able to find better solutions than the SSIRA. In
Figure 4, we present an example of results concern-
ing tardiness improvement related to induced sched-
ule difference showcasing the aforementioned trends.
5.3 Discussion
The SSIRA finds an improvement more often than the
IIRA. We believe this is because the SSIRA, unlike
the IIRA, utilizes targeted relaxations focusing on the
target project. However, the IIRA was still able to
ICORES 2025 - 14th International Conference on Operations Research and Enterprise Systems
346

find many improving solutions, sometimes even sur-
passing the performance of the targeted relaxations
proposed by the SSIRA. This is an unexpected result,
as the initial assumption was that targeted relaxations
would achieve better improvements than general re-
laxations. It seems to us that targeted relaxations of
the SSIRA might be too specific, not providing suffi-
cient slack in the modified constraints and thus mak-
ing the model too sensitive to minor variations when
finding solutions for the relaxed problem. In addition,
focusing only on the jobs from the left-shift closure
of the target project might be a good heuristic, but it
might be too restrictive. Another possibility is that
the SSIRA often proposes multiple relaxations simul-
taneously, incorrectly assuming their independence.
6 CONCLUSION
We addressed the problem of bottleneck identification
in production schedules as a computer-aided tool for
production planners. First, we formulated an exten-
sion of the standard RCPSP as a simplified model
of production. Then, we focused on execution-level
machine bottlenecks in obtained schedules. Follow-
ing the identification of such bottlenecks, we pro-
posed constraint relaxations for related resource ca-
pacity constraints to find a solution of better quality.
We extended two well-known Job-Shop bottle-
neck identification indicators for the RCPSP. We pro-
posed the IIRA, utilizing the extended indicators and
untargeted relaxations. We also proposed the SSIRA,
designed to utilize targeted relaxations.
We observed that the SSIRA is more consistent in
finding improving solutions than the IIRA. However,
for many instances, the IIRA is able to find great im-
provements with lower induced schedule differences
than those proposed by the SSIRA. Thus, untargeted
methods utilizing bottleneck identification indicators
appear to be promising in the RCPSP, even for a spe-
cific (targeted) project.
Future work might involve modeling the relax-
ations as an optimization problem to better capture the
complex dependencies of the considered constraints,
or further exploring the use of bottleneck identifica-
tion indicators in the RCPSP and its applications in re-
lated problems such as 3-dimensional spatial RCPSP
(J. Zhang et al., 2024).
ACKNOWLEDGEMENTS
This work was supported by the Grant Agency
of the Czech Republic under the Project GACR
22-31670S, and was co-funded by the European
Union under the project ROBOPROX (reg. no.
CZ.02.01.01/00/22 008/0004590).
REFERENCES
Arkhipov, D. I., Batta
¨
ıa, O., and Lazarev, A. A. (2017).
Long-term production planning problem: scheduling,
makespan estimation and bottleneck analysis. IFAC-
PapersOnLine, 50(1):7970–7974. 20th IFAC World
Congress.
Lawrence, S. R. and Buss, A. H. (1994). Shifting produc-
tion bottlenecks: causes, cures, and conundrums. Pro-
duction and Operations Management, 3(1):21–37.
Luo, J., Vanhoucke, M., and Coelho, J. (2023). Auto-
mated design of priority rules for resource-constrained
project scheduling problem using surrogate-assisted
genetic programming. Swarm and Evolutionary Com-
putation, 81:101339.
Roser, C., Nakano, M., and Tanaka, M. (2001). A
practical bottleneck detection method. In Proceed-
ing of the 2001 Winter Simulation Conference (Cat.
No.01CH37304), WSC-01. IEEE.
Wang, J.-Q., Chen, J., Zhang, Y., and Huang, G. Q. (2016).
Schedule-based execution bottleneck identification in
a job shop. Computers & Industrial Engineering,
98:308–322.
Zhang, J., Li, L., Demeulemeester, E., and Zhang,
H. (2024). A three-dimensional spatial resource-
constrained project scheduling problem: Model and
heuristic. European Journal of Operational Research,
319(3):943–966.
Zhang, R. and Wu, C. (2012). Bottleneck machine identifi-
cation method based on constraint transformation for
job shop scheduling with genetic algorithm. Informa-
tion Sciences, 188:236–252.
Bottleneck Identification in Resource-Constrained Project Scheduling via Constraint Relaxation
347