An Aggregation Method for Evaluating the Performance of a Production Line Operating Under the Slowdown Policy ^†

Abstract

The performance evaluation of production systems is essential for optimizing throughput caused by machine failures and operational constraints. In this study, we introduce an aggregation method designed to evaluate serial production lines (SPLs) that operate under the Slowdown Policy (SP). The SP dynamically adjusts machine service rates based on buffer levels, reducing blocking and ensuring a stable production rate. We propose an aggregation-based analytical approach that simplifies the evaluation of large-scale production systems while maintaining accuracy. To validate the method, a five-machine, four-buffer production line was analyzed, and the aggregation results were compared with those of a simulation. The results showed that our method provides a fast and good approximation of system performance.

1. Introduction

Throughput analysis is essential in the design, control, and optimization of production systems. However, these systems often suffer from inefficiencies due to machine failures, repair delays, and operational constraints. Failures interrupt production and maintenance delays increase downtime and repair costs, while blockages and starvation impact system performance. A blockage occurs when a machine cannot continue processing because the buffer is full, whereas starvation happens when a machine has no workpieces to process due to an empty buffer.

To mitigate these inefficiencies, control policies to reduce stoppages and improve system performance can be implemented. One such policy is the Slowdown Policy (SP) [1], which dynamically adjusts the service rate of machines based on the buffer level. The studied system consists of unreliable machines separated by buffers with limited capacity. Each machine is characterized by three exponentially distributed parameters: failure time, repair time, and processing rate. Under the SP, the processing rate of the machine is adjusted dynamically to reduce its blocking rate and idle time.

Given the complexity of such production systems, analytical evaluation is challenging for long lines. In this paper, we develop an aggregation method to estimate system performance efficiently.

The remainder of this paper is structured as follows: Section 2 presents a literature review on existing performance evaluation methods. Section 3 provides a short description of the Slowdown Policy control in a two-machine, one-buffer system. Section 4 introduces the aggregation method for evaluating multi-machine production lines operating under the SP. Section 5 presents an illustrative example where a five-machine, four-buffer production line was analyzed. Finally, Section 6 concludes the paper and suggests future research directions.

2. Literature Review

The evaluation of production system performance is influenced by several factors, such as system topology, operational balance, reliability, and system size. Simulation techniques are frequently employed to study complex systems and verify the accuracy of analytical models [2,3]. Analytical methods are favored for steady-state and transient performance assessment due to their computational efficiency [4]. However, their applicability is mostly limited to small-scale systems, typically comprising up to four machines [5]. Markov chain models are frequently employed in such cases but are computationally high [6]. More recently, artificial intelligence-based approaches have gained interest for estimating production line parameters and performance metrics.

On the other hand, for many years, approximate analytical techniques such as decomposition and aggregation methods have been designed to efficiently estimate key performance metrics (e.g., production rate and WIP) of different production line configurations. The decomposition method operates by decomposing the production system into smaller subsystems (two-machine, one buffer), assessing their individual starvation and blocking probabilities, and iteratively calculating performance metrics until convergence is reached. Due to its computational speed and accuracy, the decomposition method is considered a reliable approach for real-world applications. The aggregation method (AM) is another commonly employed approximate analytical technique. The AM operates iteratively by merging the initial two machines and an intermediate buffer into a single equivalent machine with modified failure and repair rates. This process continues until all machines are aggregated into a single equivalent unit. Aggregation-based equations provide fast approximations, making the AM suitable for practical industrial applications.

2.1. Exact Methods

Hunt (1956) [7] developed an equilibrium model based on Poisson arrivals and exponential processing times. Later, Muth (1973) [8] proposed mathematical models and queueing approaches for two- and three-machine systems. Buzacott (1968) [9] analyzed unreliable production lines without buffers. Later, an exact method to compute performance indicators for a two-machine, one-buffer system was developed in [10]. Berman (1982) [11] applied a Markovian method to compute production rates for two-machine, one-buffer systems with Erlang-distributed processing times. Other exact methods were introduced in later studies. In [12], the author analyzed reliable serial production systems with Poisson arrivals and exponential processing times. A Markov-based performance evaluation method for small systems (up to three machines) was proposed in [13]. Papadopoulos et al. (1989) [14] proposed iterative algorithms to analyze multi-station serial production lines, assuming exponential processing times. Other studies incorporated quality control and rework processes in serial production lines. For example, in [15], the authors analyzed reliable serial production systems with a quality control mechanism. The integration of quality and productivity measures in serial production lines was addressed by Cochran and Erol (2001) [16], who proposed models considering production rate and scrap rate together. In [17], the authors applied Gershwin’s (1994) [6] Markovian approach to evaluate serial production systems with two unreliable machines and one finite buffer. Tan (2003) [18] developed state-space models for pull-controlled manufacturing lines, while Kim and Gershwin (2005) [19] introduced Markov process models to analyze systems with finite and infinite buffer sizes by considering quality concept. Later, Tancrez et al. (2011) [20] applied phase-type distributions to approximate SPLs with finite buffers and general processing times. A linear programming method for SPLs with random processing times and finite buffers was proposed in [21]. Göttlich et al. (2015) [22] introduced sampling techniques using mixed-integer programming and differential equations to evaluate the performance of serial production lines. Fernandes et al. (2013a) [23] employed stochastic automata networks (SANs) to analyze reliable production lines with exponential service times. Their results demonstrated higher accuracy and efficiency compared with traditional Markovian queueing networks. Recent studies have integrated energy efficiency into SPL modeling. For example, energy consumption, WIP, and production rates in SPLs with Bernoulli machines were analyzed in [24]. Matta and Simone (2016) [25] analyzed unreliable SPLs with operation-dependent failures and time-dependent failures. Huang et al. (2020) [26] proposed a preventive maintenance approach integrating deep reinforcement learning for unreliable SPLs. Scrivano and Tolio (2021) [27] used Markov chains to analyze production lines incorporating manual and automated operations. With increasing focus on energy-efficient production, the authors of [28] developed an analytical model combining productivity and energy performance in two-machine SPLs with a buffer.

On the other hand, several studies have explored control policies in two-machine, one-buffer lines to optimize production efficiency. Gebennini et al. (2013, 2015) [29,30] introduced the restart policy, where the first machine idles when the buffer is full, reducing blockage frequency. Such policies help mitigate inefficiencies by dynamically adjusting machine operations. Nahas et al. (2025) [1] proposed a new control policy called the slowdown policy where the speed of the first machine is reduced to an optimal value when the buffer is full.

2.2. Decomposition Methods

Early studies on decomposition methods (DMs) for serial production lines (SPLs) focused on modeling systems with identical processing times [31]. Later, Hillier and Boling (1967) [32] evaluated the steady-state production rate and work-in-progress (WIP) for finite queue lines with Erlang-distributed processing times. In [33], the authors expanded decomposition methods by analyzing SPLs with Poisson arrivals and exponential processing times. Further advancements were made in the 1980s. Boxma and Konheim (1981) [34] applied a DM to tandem, split, and merge lines, using the equilibrium theorem. Altıok (1982) [12] developed a DM for reliable SPLs. Altıok and Perros (1987) [35] analyzed open queueing networks with Poisson arrivals and exponential processing times. Choong and Gershwin (1987) [36] proposed a DM for random failures and processing times, while Jafari and Shanthikumar (1987) [13] developed a DM for unreliable SPLs with limited buffers and scrapable parts. Dallery et al. (1988, 1989) [37,38] proposed two robust DM algorithms: the DDX algorithm for discrete material flows and an algorithm for continuous material transfer lines. These methods efficiently computed production rates while considering blocking and starvation. Jun and Perros (1990) [39] proposed a DM for finite-buffer SPLs, showing that a finite buffer in front of the first machine improved performance. The closed-loop production line with pallet constraints was analyzed in [40]. A matrix-based polynomial for single-buffer SPLs was introduced in [41]. Tolio et al. (1998) [42] highlighted unrealistic assumptions in classical analytical methods and proposed a DM variant considering multiple failure modes and finite buffers. Han et al. (1998) [43] integrated quality inspection machines into a DM.

Further studies addressed convergence issues and performance improvements. Dallery and Bihan (1999) [44] introduced the generalized exponential method, which improved accuracy by handling machine repair times via a two-moment approximation. Bihan and Dallery (2000) [45] extended this to a three-moment approximation, improving precision for SPLs with limited buffers. Later, a DM for non-homogeneous SPLs was proposed in [46]. In [47], a DM was applied to kanban-controlled serial production systems. Colledani et al. (2005) [48] expanded DMs to multi-product SPLs with different failure characteristics.

More recent work has adapted DMs to real-world manufacturing systems. Li (2004) [49] developed a decomposition-based approach for automotive production lines, validating results through simulations and industrial case studies. Alden et al. (2006) [50] reported that General Motors saved over $2.1 billion using production rate estimation. In [51], the authors integrated quality control machines into DM.

With growing interest in continuous flow models, Xia et al. (2012) [52] extended Dallery and Bihan’s [44] models for inhomogeneous SPLs, introducing a generalized exponential distribution approach. Shin and Moon (2014) [53] proposed a quasi-birth-and-death process-based algorithm for unbalanced SPLs.

More recently, Liberopoulos (2018) [54] introduced a DM for SPLs with geometrically distributed processing times. Wang et al. (2022) [55] analyzed Bernoulli serial lines, considering energy wastage from machine downtime. Helber et al. (2023) [56] introduced a neural network-based DM to handle the large expansion of machine state spaces in unreliable large SPLs.

2.3. Aggregation Methods

The aggregation method (AM) is a widely used approximate analytical approach for evaluating the performance of serial production lines (SPLs). De Koster (1987) [57] introduced the AM for large flow lines, extending the two-machine line analysis of [58,59]. In his study, he assumed exponentially distributed failure and repair times with finite buffers. Liu and Lin (1994) [60] later proposed an AM-based approach for unbalanced and reliable SPLs.

Several studies have applied AMs to real-world production lines. An AM-based performance estimation method for paint shops in automotive assembly was developed in [61], showing its efficiency through analytical formulas. Chiang et al. (2000) [62] applied AMs for unreliable SPLs using bottleneck detection. Colledani et al. (2008) [63] extended AM to multi-structure production lines, incorporating both serial and split machine configurations. Li (2013) [64] analyzed Toyota’s engine assembly system, transforming it into a serial line using AM to identify bottlenecks and optimize buffer allocation. Chen et al. (2016) [65] expanded the Markov-based model of Meerkov et al. [66] for multi-machine Bernoulli lines.

More recently, Wang et al. (2019) [67] applied AM for performance evaluation in SPLs, while Bai et al. (2021) [3] proposed an iterative AM-based method for multi-machine lines with finite buffers. An aggregation method for batch-discrete SPLs, incorporating Bernoulli reliability models was introduced in [68]. Wang et al. (2024) [69] proposed an AM-based analytical model to evaluate production rate and energy consumption in specialized SPLs.

3. Slowdown Policy for a Two-Machine System

Consider a production system consisting of two unreliable machines and a buffer with limited capacity placed between them (Figure 1). Machine M1 processes workpieces and transfers them to machine M2 with temporary storage in the buffer. Due to random failures and repairs, the system’s performance is influenced by blocking (when the buffer is full and M1 cannot continue working) and starvation (when the buffer is empty and M2 has no work to process).

To improve system efficiency, Nahas et al. (2025) [1] introduced the Slowdown Policy (SP) control. This approach dynamically adjusts the service rate of machine M₁ to reduce blocking while maintaining the desired production rate. The system operates in two modes: Standard (STD) and Slowdown (SWD) operation modes (Figure 2). In STD mode, machine M₁ runs at its normal speed μ₁, and the buffer level fluctuates between 0 and N − 1. When the buffer reaches full capacity (i.e., n = N), machine M₁ slows down to a reduced service rate μ₁^∗, initiating the SWD mode. In this mode, machine M₁ continues operating at μ₁^∗ until the buffer becomes empty (i.e., n = 0). At this point, the system switches back to STD mode, restoring machine M₁ to its original speed μ₁.

Figure 3 illustrates the state transition diagram of the two-machine production system under the Slowdown Policy (SP), detailing all possible states and transitions between the Standard (STD) and the Slowdown (SWD) operation Modes. Each state is represented by the quadruple (mode, n, α₁, α₂), where n is the buffer level, and α₁, α₂ indicate the operational status of machines M₁; and M₂;. The left side corresponds to STD mode, where M₁; operates at its normal speed μ₁, while the right side represents SWD mode, where M₁; slows down to μ₁* when the buffer is full (n = N). The system transitions between these states based on machine operations, failures, and repairs, with mode switching occurring when the buffer reaches its capacity limits: switching to SWD mode when full (n = N) and reverting to STD mode when empty (n = 0).

4. Aggregation Method for Multi-Machine Lines with the Slowdown Policy

Consider a production system consisting of n unreliable machines and (n − 1) intermediate buffers connected in series (Figure 4). Each machine is characterized by three parameters: average processing rate (μ_i), average repair rate (r_i), and failure rate (p_i).

The aggregation method is proposed to evaluate long production lines operating under the SP. Instead of analyzing individual machine−buffer interactions, the method iteratively combines adjacent machine−buffer pairs into artificial machines. Unlike traditional decomposition methods which rely on iteratively solving balance equations for each machine and buffer pair, the aggregation approach reduces the size of the system by replacing adjacent machine−buffer subsystems with equivalent machines. This leads to a significantly smaller state space and lower computational complexity. Decomposition methods can become computationally high due to convergence issues in the iterative process, especially in large systems [70]. In contrast, aggregation methods are generally simpler to implement and faster, making them well-suited for quick approximations in long production lines [71].

In our method, we apply downstream aggregation, beginning from the last machine M_n and moving backward to generate an equivalent machine representation. The subsystem [M_n−1, B_n−1, M_n] is replaced by an equivalent machine M_n−1,n. Once M_n−1,n is obtained, we aggregate it with M_n−2 and B_n−2. This process is repeated until we reach M₁, at which point we obtain an equivalent machine representing the entire line.

Figure 5 provides a detailed breakdown of the operational states of M2 in the context of the Slowdown Policy. This policy separates the states into two distinct sections to define the equivalent failure rate, repair rate, and processing rate:

-

M₂ Up: This section includes all states where M2 is operational, either in Standard (STD) mode or Slowdown (SWD) mode.

-

M₂ Down or starved: This section includes all states where M2 is down or starved, meaning it has failed and is undergoing repair or starved.

Using state probability distributions and transition rates, the equivalent machine parameters are derived as follows:

-

Equivalent Failure Rate

The failure rate of the equivalent machine M_i,i+1 considers both machine failures and slowdown effects:

$$p_{eq}=p_{i+1}+{\displaystyle \frac{{\mu }_i{p}_s\left(0,1,1\right)}{p_v}}$$

where

p_i+1 = probability that M_i+1 fails.

p_s(0, 1, 1) = probability that M_i is in STD mode, M_i and M_i+1 are up, and the buffer is empty.

${\mu }_i$ = processing rate in Slowdown mode.

$p_v$ = probability that M_i+1 is up and not starved.

-

Equivalent Repair Rate

The equivalent repair rate accounts for repairs and the slowdown effect when the buffer is empty:

$$r_{eq}=r_{i+1}+{\displaystyle \frac{{\mu }_i{p}_s\left(0,1,1\right)-r_{i+1}\left(p_s\left(0,0,1\right)+p_s\left(0,1,1\right)\right)}{p_t}}$$

where

r_i+1= repair rate of M_i+1

p_s(0,0,1) = probability that M_i is in STD mode and down, M_i+1 is up, and the buffer is empty.

p_i = probability that M_i+1 is down or starved.

This expression adjusts the repair rate by incorporating the influence of the slowdown policy on buffer-starved and repair states.

-

Equivalent Processing Rate

Since M_i+1 determines the system throughput, the equivalent processing rate remains

$${\mu }_{eq}={\mu }_{i+1}$$

where

µ_i+1 = processing rate of M_i+1

This reflects that under downstream aggregation, the effective throughput of the subsystem is determined by the last machine in the pair.

Probabilities $p_s\left(0,0,1\right) \mathrm{and} p_s\left(0,1,1\right)$ are obtained from the steady-state distribution derived in [1]. Readers interested in the full derivation and probability computation can refer to that work for detailed explanations.

5. Illustrative Example: A Five-Machine Line

To validate the proposed method, a five-machine, four-buffer production line was analyzed. The system data are given in

Table 1. Data for the illustrative example.

Machine 1	Machine 2	Machine 3	Machine 4	Machine 5
{µ1, µ1*, r1, p1, p1*}	{µ2, µ2*, r2, p2, p2*}	{µ3, µ3*, r3, p3, p3*}	{µ4, µ4*, r4, p4, p4*}	{µ5, r5, p5}
{1.63,1.3,0.0222,0.00148,0.00118}	{1.81,1.21,0.129,0.0236,0.0158}	{1.69,0.782,0.046,0.002,0.00095}	{1.78,1.6,0.027,0.0082,0.0074}	{1.82,0.027,0.0011}

. The results obtained from the aggregation method were compared with discrete-event simulation outcomes. Buffers were varied from 10 to 30, and throughput performance with and without the SP was analyzed.

The comparison (

Table 2. Comparison results.

Scenario	1	2	3	4	5
Bi	10	15	20	25	30
Aggregation method	0.94	1.01	1.06	1.12	1.14
Simulation	0.9767	0.9861	1.0837	1.0803	1.0809
Error (%)	3.9	2.36	2.23	3.54	5.18

) shows that the aggregation method closely approximated simulation results obtained using ProModel version 10.2.0.3428 (a discrete-event simulation software), with deviations below 5% in most cases. These findings confirm that aggregation offers a computationally efficient alternative for evaluating production systems operating under the Slowdown Policy.

6. Limitations

The proposed aggregation method relies on the assumption that machine failure, repair, and processing times follow exponential distributions. This Markovian framework simplifies the derivation of equivalent parameters. However, it may not accurately represent systems where time-to-failure or processing times show significant variability or deterministic distributions. In such cases, the performance estimates derived from the proposed aggregation method may deviate from real system behavior. Addressing these limitations would require the use of semi-Markov processes or simulation-based techniques, which we identify as important avenues for future research.

7. Conclusions

This study presents an aggregation-based methodology for evaluating multi-machine production lines operating under the Slowdown Policy. Initially developed for a two-machine system, the SP dynamically adjusts machine service rates to mitigate blocking and starvation effects, ensuring a more stable production flow.

The methodology was extended to longer production lines by iteratively aggregating adjacent machine-buffer pairs into equivalent machines. Using a downstream aggregation approach, we developed equivalent failure, repair, and processing rates, enabling a computationally efficient alternative to simulation.

The proposed aggregation method was validated through a five-machine system, comparing analytical results with discrete-event simulation outcomes. The results demonstrated that the aggregation approach closely approximated simulation results, with errors below 5% in most cases.

Ongoing work focuses on evaluating the method’s robustness by applying it to a large number of randomly generated production lines of lengths 3, 5, 7, and 10. Comparative studies with existing approaches are also planned. It is worth noting that this method relies on the assumption of exponential distributions for failure, repair, and processing times. Extending the framework to accommodate non-exponential behaviors remains an important direction for future research.