Test-Path Scheduling for Interposer-Based 2.5D Integrated Circuits Using an Orthogonal Learning-Based Differential Evolution Algorithm

Abstract

2.5D integrated circuits (ICs), which utilize an interposer to stack multiple dies side by side, represent a promising architecture for improving system performance, integration density, and design flexibility. However, the complex interconnect structures present significant challenges for post-fabrication testing, especially when scheduling test paths under constrained test access mechanisms. This paper addresses the test-path scheduling problem in interposer-based 2.5D ICs, aiming to minimize both total test time and cumulative inter-die interconnect length. We propose an efficient orthogonal learning-based differential evolution algorithm, named OLELS-DE. The algorithm combines the global optimization capability of differential evolution with an orthogonal learning-based search strategy and an elites local search strategy to enhance the convergence and solution quality. Comprehensive experiments are conducted on a set of benchmark instances with varying die counts, and the proposed method is compared against five state-of-the-art metaheuristic algorithms and CPLEX. Experimental results demonstrate that OLELS-DE consistently outperforms the competitors in terms of test cost reduction and convergence reliability, confirming its robustness and effectiveness for complex test scheduling in 2.5D ICs.

1. Introduction

Integrated circuits (ICs) have advanced rapidly over the past half-century, with the number of transistors that can be integrated into a given area growing exponentially. The continuous miniaturization of transistors has reduced the gate delay and effectively decreased the overall area of ICs, thereby lowering both design and manufacturing costs. To meet the growing market demand for high-performance, low-cost, and low-power ICs, the semiconductor industry has increasingly focused on adopting advanced 3-dimensional (3D) integration technologies based on through-silicon vias (TSVs). This approach enables the stacking of circuits and dies with different functions, allowing interconnection between dies and substrates through TSVs. However, the widespread commercial application of 3D ICs remains limited due to unresolved challenges, such as thermal management, yield, and test cost. As a transitional solution, 2.5-dimensional (2.5D) packaging technology based on TSV-enabled passive silicon interposers has garnered significant attention [1]. In 2.5D ICs, multiple active dies are placed side by side on the interposer using micro-bumps ($\mu$bumps) rather than vertically stacked. An illustration of the general 2.5D IC structure is presented in Figure 1. The interposer acts as a bridging layer that enables communication both between individual dies and between the dies and the package. This communication is established through two types of interconnects. Horizontal interconnects include $\mu$bumps and a redistribution layer (RDL), which is a multilayer metal structure for lateral signal routing. Vertical interconnects consist of $\mu$bumps, TSVs, and C4 bumps, enabling vertical connections from the dies through the interposer to the package substrate. The technology of 2.5D IC offers advantages such as reduced manufacturing complexity and shorter production cycles, and it has been successfully applied to heterogeneous system integration [2,3].

Although advancements in integrated circuit manufacturing have improved performance, larger and more complex systems remain increasingly prone to defects. Thorough testing is therefore necessary to ensure acceptable yield. Defects in interposer interconnects can originate during interposer fabrication, die bonding, or assembly. Common defect types include hard shorts and opens, as well as resistive shorts and opens. These defects can degrade performance by increasing interconnect delay [4]. Interconnects are typically manufactured using mature process technologies. However, variations in fabrication can still cause actual electrical behavior to deviate from design specifications, leading to small-delay defects. Effective defect screening during production is thus essential to ensure interconnect reliability and performance [5].

The primary testing challenge for interposer interconnects of 2.5D ICs lies in the limited accessibility, as standard probe needles can only contact the interposer’s bottom side. To address this, the IEEE 1149.1 standard [6] test-access port (TAP) and boundary-scan architecture are widely used [7]. For example, Wang et al. [8] proposed a boundary-scan structure in which dedicated test loops are established between each pair of C4 bumps. Each loop spans from one C4 bump to another and can be efficiently implemented using scan-chain structures. However, as the number of dies on the interposer increases, the boundary-scan test path becomes excessively long. The time required to shift test patterns through such a path increases sharply, leading to prohibitively high test times. A common solution is to divide the single, lengthy scan path into multiple shorter, parallel paths. This reduces test duration but requires additional TSVs and $\mu$bumps to route extra test access signals. The added interconnects increase test infrastructure costs. Therefore, efficient test path design for high-density 2.5D ICs requires a careful scheduling strategy that balances minimizing test time with controlling manufacturing complexity and cost.

The test scheduling problem of 2.5D ICs is a complex combinatorial optimization problem. It has been proven to be NP-hard [5,7,8]. As test scheduling models become more intricate and the problem scale grows, traditional exact methods—such as integer linear programming (ILP)—often become computationally intractable and fail to produce effective solutions. In contrast, evolutionary algorithms use population-based random search strategies and have shown strong capabilities in solving large-scale combinatorial optimization problems. Among them, the differential evolution (DE) algorithm is valued for its simple structure and robust performance, and it has been successfully applied to many engineering problems [9]. Applying DE to the 2.5D IC test scheduling problem can produce near-optimal scheduling schemes. This reduces test costs and provides an effective way to address the challenges of 2.5D IC test scheduling. Based on these considerations, we propose a new test-path scheduling strategy using an orthogonal learning-based DE algorithm with elites local search mechanism (OLELS-DE). The main contributions of this study can be summarized as follows:

• An accurate and comprehensive mathematical model is established for the test-path scheduling problem in 2.5D ICs. The model simultaneously considers total test time and cumulative inter-die interconnect length, effectively capturing the trade-off between testing efficiency and interconnect overhead under practical design constraints.
• Simple yet efficient encoding and decoding schemes are designed to transform the discrete test scheduling problem into a continuous optimization problem. This transformation allows a wide range of continuous meta-heuristic algorithms to be applied, significantly improving flexibility and scalability in solving large-scale scheduling instances.
• An improved DE variant, termed OLELS-DE, is adopted by integrating an orthogonal learning strategy into the optimization framework of DE. Furthermore, a selective elite learning mechanism is incorporated to enhance the convergence speed and solution quality while preserving global search capabilities.
• Comprehensive experiments on multiple benchmark instances demonstrate that the proposed method consistently outperforms five state-of-the-art metahueristic algorithms and CPLEX. The results confirm the superiority of OLELS-DE in terms of optimization quality, convergence stability, and adaptability to increasing problem scales.

The remainder of this paper is organized as follows. Section 2 introduces some related works including the test scheduling methods in ICs and the procedure of DE algorithms. Section 3 describes the test scheduling problem studied in this paper and provides its mathematical model; then, this section also presents the designed orthogonal learning-based DE algorithm to solve the test scheduling problem in 2.5D ICs in detail. Section 4 conducts experiments to validate the effectiveness of our proposed optimization method. Finally, Section 5 draws a conclusion of this paper and outlines the future directions.

2. Related Works

2.1. Test Scheduling Methods in ICs

To minimize test cost, it is essential to optimize the scheduling of test sequences in ICs. Early studies mainly focused on bus-based system-on-chip (SoC) architectures. For example, Chakrabarty [10] formulated test scheduling in core-based systems as a multiprocessor scheduling problem. The objective was to minimize test time under given tasks and resource constraints, using a mixed ILP method. Iyengar et al. [11] addressed the joint design of the test access mechanism (TAM) and wrapper optimization for SoCs. They proposed a packing algorithm and a new TAM enumeration method to further reduce core test time. Giri et al. [12] used a genetic algorithm to jointly optimize test scheduling and packaging design in core-based SoCs. They also proposed a locally optimal best-fit bin-packing heuristic to determine core placement and minimize test time. Harmanani and Farah [13] presented a simulated annealing algorithm that integrates wrapper design with TAM-optimized scheduling to reduce SoC test time. Zadegan et al. [14] described test scheduling methods under both session-based and session-free resource and power constraints in the IEEE P1687 environment [15].

With advances in IC manufacturing and the emergence of advanced packaging, research has increasingly turned to the test scheduling challenges of 2.5D and 3D ICs. For example, Noia et al. [16] used ILP to optimize two test architectures for 3D stacked ICs. Chi et al. [17] proposed a multi-access TAM to minimize interconnection cost in 2.5D ICs. Lu et al. [18] studied parallel TAM interconnection methods after 2.5D bonding and developed test designs that significantly reduce test length. Ko and Huang [19] introduced a two-stage memory built-in self-test (BIST) controller scheduling method for 3D IC synthesis, enabling parallel memory testing and reducing both test time and circuit area overhead. Krishnendu Chakrabarty’s team at Duke University has conducted extensive research on 2.5D ICs. In [5,8], they proposed interconnection test solutions for TSVs, RDL, and $\mu$bumps to detect short, open, and delay faults in 2.5D ICs. They also introduced test path design and scheduling techniques to minimize total test cost, including both time and hardware overhead. In [20], they proposed a BIST architecture that can locate defects within chips and inter-chip interconnections, along with a power-aware test scheduling technique to reduce test cost under power constraints. In [21], they presented two ExTest scheduling strategies to handle pin constraints in 2.5D IC testing, enabling interconnection testing among tiles in a SoC. They also proposed optimization schemes and subgroup configurations to minimize testing time. In [22], Wang et al. developed an efficient multicast test architecture to reduce test time while satisfying power and fault coverage constraints, along with a tailored scheduling technique for multicast testing.

Due to the complexity and scale of IC test scheduling, traditional mathematical methods often require substantial computation time. As a result, researchers have explored advanced optimization algorithms. For example, Zhu et al. [23] proposed a metaheuristic algorithm that combines grey wolf optimization with DE. By integrating DE into the grey wolf optimizer to update the Alpha solution, they improved the ability to escape local optima and demonstrated effectiveness on 3D SoC test scheduling problems. Deng et al. [24] introduced an improved DE algorithm for TAM partitioning and test scheduling in SoCs. They incorporated a hybrid mutation mechanism based on probability estimation operators, significantly enhancing parallel testing and reducing test time. SenGupta et al. [25] addressed test cost minimization for both non-stacked and stacked core-based ICs under power constraints, proposing an algorithm comparable to simulated annealing. Chandrasekaran et al. [26] tested and optimized benchmark circuits with varying TAM widths using multiple intelligent optimization algorithms. Their results showed that an enhanced artificial bee colony algorithm outperformed other methods. Deng et al. [27] proposed an enhanced DE algorithm with dynamic subpopulations and adaptive search strategies to balance scan chain design for test encapsulation and solve the 2.5D IC test scheduling problem. Li et al. [28] developed a constrained multi-objective coevolutionary algorithm for the test-chain scheduling problem, aiming to optimize hardware cost and test time simultaneously. Yang et al. [29] proposed a constrained multi-objective evolutionary algorithm to optimize the BIST test chain configurations in 2.5D ICs.

2.2. Differential Evolution

DE is a simple yet powerful evolutionary algorithm introduced by Storn and Price [30] for global optimization. It consists of four main components: initialization, mutation, crossover, and selection. The general procedure of DE is presented in Algorithm 1.

Algorithm 1: Differential evolution algorithm

Initialization: The population consists of N individuals ${\mathit{x}}_i^0\in {\mathbb{R}}^D$, initialized randomly within the bounds of the search space:

$$x_{i,j}^0=L_j+\mathrm{rand}(0,1)·(U_j-L_j),i=1,\dots ,N;j=1,\dots ,D$$

(1)

where D is the problem dimension, and $L_j$ and $U_j$ are the lower and upper bounds for the j-th dimension, respectively.

Mutation: For each target vector ${\mathit{x}}_i^g$, a mutant vector ${\mathit{v}}_i^g$ is generated by the commonly used DE/rand/1 strategy as follows:

$${\mathit{v}}_i^g={\mathit{x}}_{r_1}^g+F·({\mathit{x}}_{r_2}^g-{\mathit{x}}_{r_3}^g)$$

(2)

where $r_1,r_2,r_3\in \{1,\dots ,N\}$ are distinct and different from i, and $F\in [0,2]$ is a scaling factor. Another common mutation strategy is DE/best/1, which generates the mutant vector as follows:

$${\mathit{v}}_i^g={\mathit{x}}_{best}^g+F·({\mathit{x}}_{r_1}^g-{\mathit{x}}_{r_2}^g)$$

(3)

where ${\mathit{x}}_{best}^g$ represents the best solution in the current population with the best fitness value.

Crossover: A trial vector ${\mathit{u}}_i^g$ is created by combining the target and mutant vectors:

$$u_{i,j}^g=\left\{\begin{array}{cc}{v}_{i,j}^g\hfill & \mathrm{if}\mathrm{rand}(0,1)<CR\mathrm{or}j=j_{\mathrm{rand}}\hfill \\ x_{i,j}^g\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(4)

where $CR\in [0,1]$ is the crossover rate, and $j_{\mathrm{rand}}$ ensures at least one component comes from ${\mathit{v}}_i^g$.

Selection: The population for the next generation is determined by greedy selection:

$${\mathit{x}}_i^{g+1}=\left\{\begin{array}{cc}{\mathit{u}}_i^g\hfill & \mathrm{if}f\left({\mathit{u}}_i^g\right)\le f\left({\mathit{x}}_i^g\right)\hfill \\ {\mathit{x}}_i^g\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(5)

These steps are iteratively executed until the termination criterion is met, and the best solution obtained during the process is returned.

2.3. Orthogonal Learning-Based Differential Evolution

In recent years, researchers have explored the integration of effective learning models from mathematics, machine learning, and related fields to improve the performance of DE. Notable examples include orthogonal learning [31,32,33], opposition-based learning [9,34,35], and Q-learning [36,37,38]. These approaches demonstrate that incorporating learning strategies can help DE more intelligently identify promising information during the evolutionary process. Among them, orthogonal learning—originating from the orthogonal experimental design methodology—stands out for its strong capabilities in efficient testing and predictive analysis. In our recent work, we proposed an enhanced DE variant, named OLELS-DE [39], which integrates the orthogonal learning mechanism with an elite local search strategy. The effectiveness of OLELS-DE has been validated on a range of complex optimization problems. In this study, we will adopt OLELS-DE to address the test-path scheduling problem in 2.5D ICs. A brief overview of its execution procedure is provided in this part.

OLELS-DE is built upon the well-known DE variant JADE [40], which introduces an external archive-based mutation strategy known as DE/current-to-pbest/1. This strategy generates mutant solutions according to the following formulation:

$${\mathit{v}}_i^g={\mathit{x}}_i^g+F·({\mathit{x}}_{pbest}^g-{\mathit{x}}_i^g)+F·({\mathit{x}}_{r_1}^g-{\tilde{\mathit{x}}}_{r_2}^g)$$

(6)

The vector ${\mathit{x}}_{pbest}^g$ is randomly selected from the top $100p\%$ of solutions in the current population $\mathit{P}$, where $p\in (0,1)$ defines the size of the elite group. To enhance diversity, JADE incorporates an external archive $\mathit{A}$, which stores parent solutions that are outperformed by their offspring during the selection process. In the mutation operator, ${\mathit{x}}_{r_1}^g$ is a randomly selected individual from the current population $\mathit{P}$, while ${\tilde{\mathit{x}}}_{r_2}^g$ is drawn from the union of the population and the archive, i.e., $\mathit{P}\cup \mathit{A}$. The greediness of this operator is regulated by the parameter p, which is typically set to $0.05$ in JADE by default.

In OLELS-DE, the number of consecutive iterations during which the current best solution remains unchanged by the mutation operator is tracked by a counter parameter, denoted as T. When this value reaches the predefined threshold $T_{\max }$, the population is considered to have lost its vitality, indicating a risk of stagnation or premature convergence. To empirically distinguish between these two scenarios based on the population distribution, a population diversity estimation mechanism based on the Euclidean distance is employed as follows:

$$div={\displaystyle \frac{∥{\mathit{x}}_{best}-{\mathit{x}}_{mid}∥}{0.5\sqrt{{\sum }_{j=1}^D{(U_j-L_j)}^2}}}$$

(7)

where ${\mathit{x}}_{best}$ and ${\mathit{x}}_{mid}$ denote the current best individual and the median-ranking individual in the population, respectively. To perform the orthogonal learning mechanism, two solutions, denoted as ${\mathit{x}}_{s_1}$ and ${\mathit{x}}_{s_2}$, are selected to undergo the orthogonal experimental design process, resulting in the generation of an orthogonal solution ${\mathit{x}}_o$:

$${\mathit{x}}_o={\mathit{x}}_{s_1}\oplus {\mathit{x}}_{s_2}$$

(8)

If $\mathit{div}>0.5$, the population is likely distributed across diverse regions of the search space, indicating that diversity is still maintained and the algorithm may be facing a stagnation issue. In this case, ${\mathit{x}}_{s_1}={\mathit{x}}_{best}$ and ${\mathit{x}}_{s_2}={\mathit{x}}_{pbest}$ are selected to make the orthogonal learning process more exploitative. Otherwise, the population is likely trapped in a local region, indicating premature convergence. Under such circumstances, ${\mathit{x}}_{s_1}={\mathit{x}}_{pbest1}$ and ${\mathit{x}}_{s_2}={\mathit{x}}_{pbest2}$ are used in the orthogonal learning to enhance exploration.

To fully leverage the information obtained from orthogonal learning, not only is the orthogonal solution ${\mathbf{x}}_o$ preserved, but all the combined vectors generated according to the orthogonal array are also retained. These vectors form a combined group denoted as ${\mathit{P}}_c=({\mathit{x}}_{c_1},\dots ,{\mathit{x}}_{c_m})$, where m is the number of combinations. To further enhance the diversity of component-wise values, a disturbance mechanism is introduced to generate a perturbed group ${\mathit{P}}_c^{\prime }=({\mathit{x}}_{c_1}^{\prime },\dots ,{\mathit{x}}_{c_m}^{\prime })$. The disturbance model is defined as follows:

$${\mathit{x}}_{c_i}^{\prime }=\mathcal{N}({\mathit{x}}_{c_i},{\sigma }_i)+0.1·(r_1·{\mathit{x}}_{s_1}-r_2·{\mathit{x}}_{c_i}),i=1,\dots ,m$$

(9)

Here, $r_1$ and $r_2$ are two independent random variables uniformly distributed in the interval $(0,1)$, and ${\sigma }_i$ denotes the standard deviation of the Gaussian distribution used for sampling. The value of ${\sigma }_i$ is calculated as:

$${\sigma }_i={\displaystyle \frac{∥{\mathit{x}}_{s_1}-{\mathit{x}}_{c_i}∥}{\mathit{max}\_\mathit{dist}}},i=1,\dots ,m$$

(10)

where $max\_dist$ represents the maximum Euclidean distance between any two individuals within the group ${\mathit{P}}_c$.

After the application of the orthogonal learning mechanism, if the best solution still fails to improve, a local search mechanism based on elite solutions is employed to further exploit valuable search information. Specifically, a subset of $E_p$ elite individuals with superior fitness values is selected to perform a Gaussian-based local search in their vicinity, defined as:

$$x_{i,j}^{\prime }=\mathcal{N}(x_{i,j},\sigma ),i=1,\dots ,E_p;j=1,\dots ,D$$

(11)

Here, $\sigma$ denotes the standard deviation of the Gaussian distribution and is set to a constant value of 0.1. The number of elite solutions $E_p$ decreases linearly over iterations, from an initial value of $N/10$ down to 3, in order to balance exploration and exploitation throughout the search process.

3. Proposed Method

3.1. Problem Description

The integration of multiple dies onto the passive silicon interposer, a hallmark of 2.5D IC technology, has achieved significant progress. Researchers are actively exploring both the feasibility and the challenges of stacking an increasing number of dies [41]. However, the number of possible test-path configurations grows exponentially with the number of dies. As shown in [20], the number of possible configurations $N_c$ for $N_d$ dies can be calculated using the following recursive equation:

$$N_c\left(N_d\right)=\sum _{i=1}^{N_d}\left({\displaystyle \genfrac{}{}{0pt}{}{N_d-1}{i-1}}\right)·i!·N_c(N_d-i)$$

(12)

Based on this formulation, the total number of possible test-path configurations for 12 dies is 12,470,162,233. Using a single long test path usually leads to excessive test time. In contrast, multiple short test paths can greatly reduce test time but increase hardware overhead. Therefore, efficient optimization techniques are needed to find configurations that balance test time and hardware cost.

In this study, we focus on the boundary-scan architecture proposed in [8]. In this architecture, scan paths are divided into scan-in and scan-out paths. A test path with one or more scan-in chains is called an input test access mechanism (in-TAM). A path with one or more scan-out chains is called an output TAM (out-TAM). The optimization problem is defined as follows. Given a 2.5D IC with $N_d$ dies, let $c_a$ be the cost on the automatic test equipment (ATE) per unit length, i.e., per boundary scan cell. Let $c_{b_1}$ be the cost of fabricating an additional in-TAM, and $c_{b_2}$ be the cost of fabricating an additional out-TAM. The goal is to determine a test-path configuration and scheduling strategy that minimizes the total test cost C. The cost C includes both test application time and area overhead, capturing the trade-off between performance and hardware resource usage.

3.2. Mathematical Model

The variables used in the mathematical model are summarized in

Table 1. Variable notations used in the mathematical model.

Notation	Description
$N_d$	Number of dies.
$N_p$	Number of in-TAMs.
$N_q$	Number of out-TAMs.
$N_t$	Number of interconnects being tested.
$I_i$	Number of $\mu$bumps connected to the input ports of die i.
$O_i$	Number of $\mu$bumps connected to the output ports of die i.
$i,h$	Index of dies, $i,h\in \{1,2,\dots ,N_d\}$.
j	Index of in-TAMs, $j\in \{1,2,\dots ,N_p\}$.
k	Index of out-TAMs, $k\in \{1,2,\dots ,N_q\}$.
$y_{i,j}$	Binary variable whose value equals to 1 if the scan-in chain of die i is in
	in-TAM j, and 0 otherwise.
$z_{i,k}$	Binary variable whose value equals to 1 if the scan-out chain of die i is in
	out-TAM k, and 0 otherwise.
$e_{i,h}$	Binary variable whose value equals to 1 if die h is placed directly after die i
	within the same in-TAM or out-TAM, and 0 otherwise.
$L_{in}$	Length of the longest test paths among all in-TAMs.
$L_{out}$	Length of the longest test paths among all out-TAMs.
$W{L}_{in}$	Maximum test wire length among all in-TAMs.
$W{L}_{out}$	Maximum test wire length among all out-TAMs.
$d_{i,h}$	Physical distance between die i and die h.
$are{a}_{TSV}$	Physical area of a TSV.
$are{a}_{\mu bump}$	Physical area of a $\mu$bump.
f	Test frequency.
$c_{ATE}$	Tester usage cost per second.
$c_{interposer}$	Test cost per unit area of the interposer.
$c_{die}$	Test cost per unit area of the die.
$c_a$	Test cost incurred on the ATE per unit length.
$c_{b_1}$	Test cost of fabricating an additional in-TAM.
$c_{b_2}$	Test cost of fabricating an additional out-TAM.
C	Total test cost.

.

To formulate the model, we first define two integer decision variables: $N_p$ and $N_q$, representing the number of in-TAMs and out-TAMs, respectively. These two variables are subject to the following constraints:

$$N_p\le N_d,N_q\le N_d$$

(13)

where $N_d$ denotes the total number of dies on the interposer. These constraints reflect the architectural limitations: each die provides at most one TDI and one TDO port, thus bounding the number of available in-TAMs and out-TAMs by the number of dies.

Next, we introduce two binary decision variables, $y_{i,j}$ and $z_{i,k}$, which are used to determine the allocation of scan chains for each die. Specifically, $y_{i,j}=1$ if the scan-in chain of die i is assigned to in-TAM j, and 0 otherwise. Similarly, $z_{i,k}=1$ if the scan-out chain of die i is assigned to out-TAM k, and 0 otherwise. These variables are subject to the following constraints:

$$\sum _{j=1}^{N_p}{y}_{i,j}=1,\sum _{k=1}^{N_q}{z}_{i,k}=1,1\le i\le N_d$$

(14)

$$\sum _{i=1}^{N_d}{y}_{i,j}\ge 1,\sum _{i=1}^{N_d}{z}_{i,k}\ge 1,1\le j\le N_p,1\le k\le N_q$$

(15)

Constraint (14) ensures that each die is connected to exactly one in-TAM and one out-TAM. Constraint (15) guarantees that every in-TAM and out-TAM is associated with at least one die on the interposer.

Then, we define two variables, $L_{in}$ and $L_{out}$, to represent the lengths of the longest test paths among all in-TAMs and out-TAMs, respectively. These values are computed using the following expressions:

$$L_{in}=\underset{1\le j\le N_p}{max}\sum _{i=1}^{N_d}{y}_{i,j}·I_i$$

(16)

$$L_{out}=\underset{1\le k\le N_q}{max}\sum _{i=1}^{N_d}{z}_{i,k}·O_i$$

(17)

Here, $I_i$ and $O_i$ denote the number of $\mu$bumps connected to the input and output ports of die i, respectively.

Furthermore, we take into account the ordering of dies within each in-TAM and out-TAM. The sequence in which dies are arranged significantly influences the routing complexity. If the dies are ordered arbitrarily, it can result in longer test wire lengths. It is important to distinguish between “test wire length” and “test length”. Specifically, test wire length refers to the physical routing length of a test path, while test length denotes the number of boundary scan cells in that path. Although the test length remains unaffected by the routing, excessively long test wires may introduce timing issues, degrade the test quality, and increase the routing congestion. The binary variable $e_{i,h}$ is introduced to represent the ordering of dies within in-TAMs and out-TAMs. Specifically, $e_{i,h}=1$ indicates that die h is directly placed after die i within the same in-TAM or out-TAM; otherwise, $e_{i,h}=0$. The following constraints are applied to enforce a valid ordering:

$$e_{i,i}=0,1\le i\le N_d$$

(18)

$$e_{i,h}+e_{h,i}\le 1,1\le i,h\le N_d$$

(19)

$$\sum _{h=1}^{N_d}{e}_{i,h}=1,1\le i\le N_d$$

(20)

$$\sum _{i=1}^{N_d}{e}_{i,h}=1,1\le h\le N_d$$

(21)

Constraint (18) ensures that a die cannot be positioned directly after itself. Constraint (19) guarantees that the ordering between any two dies is unidirectional—if die h is directly behind die i, then die i cannot be directly behind die h. Constraints (20) and (21) enforce that each die has exactly one direct successor and one direct predecessor within the sequence.

We define two variables, $W{L}_{in}$ and $W{L}_{out}$, to denote the maximum test wire length among all in-TAMs and out-TAMs, respectively. The physical distance between die i and die j is denoted as $d_{i,j}$. For a given in-TAM or out-TAM, the total test wire length is computed as the sum of the distances between all consecutive dies in that TAM. The values of $W{L}_{in}$ and $W{L}_{out}$ are calculated as follows:

$$W{L}_{in}=\underset{1\le j\le N_p}{max}\sum _{i=1}^{N_d}\left[\left(\sum _{h=1}^{N_d}{d}_{i,h}·e_{i,h}\right)·y_{i,j}\right]$$

(22)

$$W{L}_{out}=\underset{1\le k\le N_q}{max}\sum _{i=1}^{N_d}\left[\left(\sum _{h=1}^{N_d}{d}_{i,h}·e_{i,h}\right)·z_{i,k}\right]$$

(23)

In both equations, the inner summation ${\sum }_{h=1}^{N_d}{d}_{i,h}·e_{i,h}$ captures the distance between die i and its direct successor die.

With the variables defined above, the total test cost C can be calculated as follows:

$$C=c_a·max(L_{in},L_{out})+c_{b_1}·N_p+c_{b_2}·N_q$$

(24)

The cost parameters $c_a$, $c_{b_1}$, and $c_{b_2}$ are defined as follows:

$$c_a={\displaystyle \frac{c_{ATE}}{f}}·\left(2·{log}_2(N_t+2)+1\right)$$

(25)

$$c_{b_1}=are{a}_{TSV}·c_{interposer}+are{a}_{\mu bump}·c_{die}$$

(26)

$$c_{b_2}=are{a}_{TSV}·c_{interposer}$$

(27)

Here, $c_{ATE}$ denotes the tester usage cost per second and f is the test frequency. $N_t$ represents the total number of interconnects being tested. The parameters $are{a}_{TSV}$ and $are{a}_{\mu bump}$ represent the physical area of a TSV and a $\mu$bump, respectively. $c_{interposer}$ and $c_{die}$ refer to the cost per unit area of the interposer and die, respectively.

The optimization objective is to minimize the total test cost C. If multiple test-path configurations produce the same test cost, the one with the smaller maximum test wire length, i.e., $max(W{L}_{in},W{L}_{out})$, is preferred due to its potential benefits in routing complexity and signal quality.

3.3. Encoding and Decoding Schemes

As introduced in Section 2.3, the population in OLELS-DE is represented using real-valued encoding. Therefore, specialized encoding and decoding schemes are needed to apply OLELS-DE to the test-path scheduling problem in 2.5D ICs. To address this, we have designed simple yet effective encoding and decoding mechanisms tailored for this context. An example illustrating these schemes is shown in Figure 2.

During encoding, each individual in the population represents a scheduling solution. For $N_d$ dies on the interposer, each individual is encoded as a $2N_d$-dimensional vector. Each entry is initialized as a random real number within the range $(0,N_d)$. The vector is then divided into two parts, each assigned sequential numbers. One part corresponds to the scan-in chains, and the other to the scan-out chains.

To evaluate solutions, a decoding method is applied corresponding to the encoding scheme. Each part of the vector is sorted in ascending order, and their assigned numbers are exchanged accordingly. Then, each dimension’s value is rounded up. Identical values indicate dies assigned to the same scan chain. For each group of equal values, the corresponding die identifiers are extracted to determine the test sequence within that scan chain. This procedure yields the interconnect test scheduling results.

Based on the derived test scheduling results, key parameters such as the number of in-TAMs ($N_p$), the number of out-TAMs ($N_q$), and the lengths of the longest scan-in and scan-out test paths ($L_{in}$ and $L_{out}$, respectively) can be accurately determined. These parameters are further utilized to compute the total test cost associated with the specific test scheduling solution.

3.4. Scheduling with OLELS-DE

By employing the proposed encoding and decoding schemes, OLELS-DE can effectively address the test-path scheduling problem in 2.5D ICs. The flowchart illustrating this process is shown in Figure 3, and the detailed scheduling procedure is provided in Algorithm 2.

The main objective of this algorithm is to minimize the overall test cost while considering the routing complexity represented by the maximum test wire length. The algorithm begins by initializing the generation counter $g=0$ and counter parameter $T=0$. An initial population $\mathit{P}\left(0\right)$ consisting of N individuals is randomly generated using a specifically designed encoding scheme. After the initialization, each individual is decoded to derive its corresponding scheduling solution. The test cost and maximum wire length of each solution are evaluated, and the best individual in terms of test cost is recorded as ${\mathit{x}}_{best}$. The algorithm then enters the iterative optimization process.

Algorithm 2: Test scheduling with OLELS-DE

During each generation, if the counter T is less than the predefined threshold $T_{max}$, the population is evolved using DE/current-to-pbest/1 mutation strategy. For each individual ${\mathit{x}}_i$ in the population, a mutant vector ${\mathit{v}}_i$ is generated. Through the crossover operation, a trial vector ${\mathit{u}}_i$ is created and decoded into a scheduling solution. The fitness of the trial vector is evaluated by calculating the associated test cost and maximum wire length. The selection operation is then performed between the original individual and the trial vector, and the one with better performance (lower cost or shorter wire length if cost is equal) is retained for the next generation. The best individual in the current population is updated accordingly, and the counter T is increased if no improvement is observed.

Once the stagnation threshold $T_{max}$ is reached, the algorithm invokes the orthogonal learning mechanism to enhance exploration. The population diversity is first evaluated. If the diversity is sufficiently high, the global best individual and a randomly selected p-best individual are used to construct a new candidate through orthogonal learning. Otherwise, two p-best individuals are selected to encourage broader search. The orthogonal learning mechanism generates a new solution ${\mathit{x}}_o$ along with a set of auxiliary combined solutions ${\mathit{P}}_c^{\prime }$. These individuals are decoded and evaluated similarly. The current population is then updated by selecting the best N individuals from the union of the original population, the orthogonal solution, and the combined population. If no improvement in ${\mathit{x}}_{best}$ is observed after the orthogonal learning phase, the algorithm activates a local search mechanism around the elite solutions to escape potential local optima. This elite local search performs fine-grained perturbations on elite solutions and replaces it if a better solution is found. This iterative process continues until the stopping criterion is satisfied. Finally, the best scheduling solution ${\mathit{x}}_{best}$ and its associated test cost C are returned as the output of the algorithm.

4. Experimental Validation

In this section, we present a series of experiments to evaluate the effectiveness of the proposed optimization method for solving the test-path scheduling problem in 2.5D ICs. We begin by describing the experimental setup. Subsequently, small-scale experiments are performed to validate the accuracy of the formulated mathematical model and the effectiveness of the proposed optimization algorithm. Then, large-scale experiments are conducted to assess the performance of OLELS-DE through comprehensive comparative analysis with other state-of-the-art optimization methods. Finally, experiments are performed to analyze the sensitivity of the proposed algorithm to several critical parameters.

4.1. Experimental Setup

4.1.1. Instance Data

In the experiments, we consider a 2.5D IC design constructed using the ITC’02 SoC test benchmark [42], which includes 12 dies (labeled die 1 to die 12), as well as another 2.5D IC design from [43], comprising additional 12 dies (labeled die 13 to die 24). The number of I/O ports for each die is detailed in

Table 2. The design data of the dies on the interposer for cost optimization.

Die index	1	2	3	4	5	6	7	8	9	10	11	12
No. inputs	175	1523	584	438	1693	553	1999	919	3846	1928	4812	6379
No. outputs	201	1408	1261	491	1961	848	1462	1024	1997	1572	3719	6788
Die index	13	14	15	16	17	18	19	20	21	22	23	24
No. inputs	1178	1846	811	754	678	1326	485	537	914	1230	1365	1487
No. outputs	1768	2769	1217	1132	1017	1989	728	805	1371	1845	2047	2231

. These test cases, representing both current and emerging 2.5D IC technologies, provide a comprehensive platform for assessing testing methodologies. The results can effectively demonstrate the efficacy and scalability of different test-path scheduling approach for complex, multi-die architectures.

We assume that a production volume of 100,000 2.5D ICs, meaning that 100,000 chips are tested. According to the data reported in [42], the area of a typical $\mu$bump ($are{a}_{\mu bump}$) is set to 1600 μm², based on a $\mu$bump pitch of 40 μm. The area of a typical TSV ($are{a}_{TSV}$) is set to 10,000 μm², assuming a TSV pitch of 100 μm. The test frequency (f) is fixed at 10 MHz. The cost-related parameters are set as follows: the cost of the interposer per unit area ($c_{interposer}$) is $1.4$\times {10}^{-9}$/μm², the cost of the die per unit area ($c_{die}$) is $4.24$\times {10}^{-8}$/μm², and the tester usage cost ($c_{ATE}$) is set to $0.028 per second.

4.1.2. Compared Methods

To comprehensively evaluate the performance of the proposed OLELS-DE algorithm, we compare it with six representative optimization methods: JADE [40], EFDE [44], MGDE [45], WOA [46], HHO [47], and CPLEX [48]. Among them, JADE, EFDE, and MGDE are three DE variants. Specifically, JADE serves as the baseline for OLELS-DE; EFDE integrates an efficient fitness-based dynamic mutation strategy with adaptive control parameters; and MGDE adopts a multi-individual guidance mechanism while evolving control parameters over time based on feedback information. WOA (Whale Optimization Algorithm) and HHO (Harris Hawks Optimization) are two swarm intelligence-based approaches: WOA is inspired by the bubble-net hunting strategy of humpback whales, whereas HHO models the cooperative hunting behavior of Harris’ hawks. Finally, CPLEX, a mathematical optimization solver developed by IBM, is employed in the experiments to solve the mathematical model described in Section 3.2 and to provide reference values for the scheduling solutions.

Unless otherwise specified, all parameters for the compared algorithms are configured according to their original publications. The population size N is uniformly set to 100 for the adopted three DE variants and two swarm intelligence-based algorithms. The maximum number of iterations $G_{max}$ is set to 500 for small-scale experiments in Section 4.2 and 2000 for large-scale experiments in Section 4.3. These algorithms terminate upon reaching the iteration limit $G_{max}$ or the maximum allowed CPU runtime. For OLELS-DE, the threshold parameter $T_{max}$ is set to 50. A sensitivity analysis of OLELS-DE with respect to N and $T_{max}$ will be presented in Section 4.4.

4.1.3. Evaluation Metrics

Since the DE variants and swarm intelligence-based algorithms adopted in this study are stochastic metaheuristic methods, each algorithm is independently executed 20 times on each test instance to ensure statistical robustness and reliability. In contrast, CPLEX, as an exact mathematical optimization solver, is executed only once per instance. To facilitate a fair and comprehensive comparison among different methods, the following evaluation metrics are employed:

• Test cost values: For each algorithm, the best, worst, and mean test cost values obtained over multiple runs are reported. This metric directly reflects the optimization quality in terms of the primary objective—minimizing the overall testing cost. Reporting the best, worst, and mean values can assess not only the optimal performance but also the stability and consistency of each optimization method.
• CPU runtime: The computational time required for each algorithm to complete the predetermined number of iterations is recorded. This metric reflects the time efficiency of the algorithm under identical iteration settings, enabling a fair comparison of their computational complexity.
• Statistical test methods: To evaluate the statistical significance of performance differences among algorithms, two non-parametric test methods are conducted at a 0.05 significance level. The Wilcoxon signed-rank test is used for pairwise comparisons between OLELS-DE and each compared algorithm, as it does not require data normality and is well suited for paired sample analysis. The Friedman test is applied to assess the overall performance ranking of all algorithms across multiple instances, providing a global evaluation of whether observed differences are statistically significant.

The five adopted metaheuristic algorithms and the proposed OLELS-DE algorithm are implemented in MATLAB R2022a, and the CPLEX experiments are conducted using the MATLAB interface of CPLEX Optimization Studio V12.10. All experiments are performed on a computer equipped with a 12th Gen Intel^® Core^TM i7-12700K CPU (Intel Corporation, Santa Clara, CA, USA) running at 3.61 GHz, 32 GB of RAM, and the 64-bit version of Windows 11.

4.2. Validation of Model and Algorithm’s Accuracy

In this subsection, a basic case study with small-scale experiments is conducted to validate the accuracy of both the mathematical model and the proposed optimization algorithm. Specifically, ten dies (die 1 to die 10) from Table 2 are selected as candidates to be placed on the interposer for testing. The test wire lengths between different die pairs are listed in

Table 3. The test wire length between different pairs of dies in the basic case study. These non-dimensional values are randomly generated within a reasonable range to represent relative distances.

${\mathit{d}}_{\mathit{i},\mathit{h}}$	die 1	die 2	die 3	die 4	die 5	die 6	die 7	die 8	die 9	die 10
die 1	0	48	82	18	99	11	19	92	90	20
die 2	48	0	98	48	78	71	47	22	66	96
die 3	82	98	0	97	35	29	73	22	78	50
die 4	18	48	97	0	81	34	47	83	41	62
die 5	99	78	35	81	0	54	14	46	34	47
die 6	11	71	29	34	54	0	58	25	91	31
die 7	19	47	73	47	14	58	0	94	48	92
die 8	92	22	22	83	46	25	94	0	97	62
die 9	90	66	78	41	34	91	48	97	0	10
die 10	20	96	50	62	47	31	92	62	10	0

. These values are non-dimensional and represent relative, rather than absolute, distances, which vary depending on the distribution of dies. The values are randomly generated within a reasonable range for the purpose of this study.

For comparison purposes, we employ the basic DE algorithm using both the DE/rand/1 and DE/best/1 mutation strategies to solve the test-path scheduling problem. We also include the results obtained by the ILP-based method as reported in [8] for reference. Additionally, two baseline methods are considered for validation. The first baseline (BL1) assigns an independent scan-in and scan-out chain to each die, enabling full parallel testing of all dies. The second baseline (BL2) uses a single scan-in and scan-out chain to test all dies sequentially. The scheduling results produced by OLELS-DE and other optimization methods for this basic case are summarized in

Table 4. Scheduling results obtained by different methods in the basic test case study with 10 dies. In this table, “Test Wire Length” is dimensionless, and “Test Cost” is expressed in dollars.

Methods	OLELS-DE	DE/Rand/1	DE/Best/1	ILP	BL1	BL2
In-TAM paths	9, 6, 1 ‖ 10, 3, 7 ‖ 2, 4, 5, 8	1, 2, 5 ‖ 9 ‖ 3, 6, 10 ‖ 4, 7, 8	1, 2, 10 ‖ 9 ‖ 7, 6 ‖ 3, 4, 5, 8	1, 6, 9 ‖ 2, 4, 5, 8 ‖ 3, 7, 10	1 ‖ 2 ‖ 3 ‖ 4 ‖ 5 ‖ 6 ‖ 7 ‖ 8 ‖ 9 ‖ 10	1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Out-TAM paths	8, 5, 2 ‖ 1, 3, 7, 10 ‖ 4, 6, 9	3, 8 ‖ 7 ‖ 10 ‖ 5, 2, 4 ‖ 1, 6, 9	6, 10 ‖ 3, 9 ‖ 5, 7 ‖ 2, 1, 4, 8	5, 10 ‖ 1, 2, 3, 7 ‖ 4, 6, 8, 9	1 ‖ 2 ‖ 3 ‖ 4 ‖ 5 ‖ 6 ‖ 7 ‖ 8 ‖ 9 ‖ 10	1, 2, 3, 4, 5, 6, 7, 8, 9, 10
No. In-TAM (p)	3	4	4	3	10	1
No. Out-TAM (q)	3	5	4	3	10	1
Test Length (L)	4574	3860	3846	4574	3846	13,658
Test Wire Length	247	141	224	219	0	637
Test Cost (C)	63.33	66.76	65.26	63.33	122.76	120.49

.

As shown in the results, the proposed OLELS-DE algorithm achieves a competitive test cost of $63.33, which matches the cost obtained by the ILP method [8], demonstrating the accuracy and effectiveness of the optimization approach. In contrast, both DE/rand/1 and DE/best/1 result in higher costs, $66.76 and $65.26, respectively, due to suboptimal scheduling paths. Although DE/rand/1 and DE/best/1 achieve slightly shorter test lengths, they introduce more TAMs (e.g., DE/rand/1 uses 4 in-TAMs and 5 out-TAMs), which increases hardware resource consumption and associated cost. The test wire length obtained by OLELS-DE (247) is reasonably low, striking a balance between resource usage and routing complexity. Compared with the baseline methods, OLELS-DE significantly outperforms both BL1 and BL2 in terms of cost. BL1, which uses independent scan chains for each die, results in the highest cost ($122.76) due to excessive TAM usage. BL2, although using minimal TAMs, leads to the longest test length (13,658), resulting in a cost of $120.49.

These experimental results confirm that OLELS-DE not only achieves optimal or near-optimal cost efficiency comparable to the exact method ILP, but also significantly outperforms the basic DE algorithms and baseline strategies in balancing test time, TAM usage, and wire length.

4.3. Performance Comparison

In this subsetion, we rigorously evaluate the effectiveness of the proposed OLELS-DE algorithm through comprehensive comparative experiments against five state-of-the-art metaheuristic algorithms and CPLEX across nine specially designed test instances (labeled P1 to P9). The number of dies to be tested in these instances ranges from 20 to 100, increasing in increments of 10. For comparative analysis,

Table 5. Scheduling performance of OLELS-DE and six compared methods on P1–P9 instances, including cost metrics, CPU runtime, and Wilcoxon signed-rank test results (Wilc.). The units for the metrics “best”, “worst”, and “mean” are in dollars, and the unit for the “time” metric is in seconds.

Instance	Metric	OLELS-DE	JADE	EFDE	MGDE	WOA	HHO	CPLEX
P1	best	102.19 1	107.30	106.71	109.76	105.45	110.81	102.19
	worst	105.31	122.63	124.03	127.21	123.32	127.75	102.19
	mean	104.26	114.89	117.82	118.13	111.24	119.34	102.19
	time	6.95	6.27	15.69	5.91	4.99	12.11	1800
	Wilc.	$--$	(−) 2	(−)	(−)	(−)	(−)	(+)
P2	best	124.47	144.06	139.53	152.00	131.98	142.72	125.32
	worst	129.82	166.33	166.48	171.44	163.34	170.53	125.32
	mean	126.03	152.32	151.98	163.28	145.71	156.47	125.32
	time	11.71	19.08	26.23	7.97	5.76	32.92	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(=)
P3	best	137.26	169.05	170.96	179.89	149.41	152.78	138.85
	worst	140.61	203.26	203.26	218.41	168.95	186.33	138.85
	mean	138.66	182.84	185.42	197.92	158.37	167.40	138.85
	time	33.55	23.87	30.02	10.49	6.54	36.08	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(=)
P4	best	162.43	196.85	204.88	226.05	170.53	183.62	171.37
	worst	170.23	245.80	250.00	258.02	203.09	210.71	171.37
	mean	164.99	223.95	225.59	242.58	186.91	194.91	171.37
	time	34.50	28.89	34.50	13.06	7.02	42.58	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P5	best	179.65	247.35	226.14	274.99	199.79	205.04	181.12
	worst	186.72	280.76	353.94	318.61	252.69	237.23	181.12
	mean	182.72	262.92	276.88	296.10	217.15	219.77	181.12
	time	43.38	34.09	38.38	15.65	7.68	46.12	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(+)
P6	best	213.60	299.47	296.13	325.72	232.41	237.32	224.84
	worst	222.79	337.47	414.56	370.05	286.31	303.44	224.84
	mean	217.26	315.47	321.45	346.80	250.53	258.68	224.84
	time	51.18	39.35	44.18	18.49	9.08	51.80	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P7	best	216.73	325.16	320.01	347.81	239.15	247.07	240.41
	worst	233.77	371.24	468.80	411.59	308.12	283.71	240.41
	mean	227.51	341.86	385.99	389.32	261.79	263.36	240.41
	time	60.43	44.79	48.26	41.40	9.54	60.01	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P8	best	230.11	361.97	342.49	399.73	250.99	265.98	271.57
	worst	245.60	425.02	520.39	467.24	349.10	299.35	271.57
	mean	236.54	386.86	391.88	438.72	285.89	281.40	271.57
	time	68.79	50.34	51.11	50.74	10.04	67.88	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P9	best	223.09	371.63	387.00	425.22	242.74	248.83	253.06
	worst	249.64	496.11	563.80	480.73	306.40	292.31	253.06
	mean	236.86	410.42	464.17	448.83	278.80	271.19	253.06
	time	79.17	56.80	54.52	56.74	10.19	75.59	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)

¹ The best value in each row is highlighted in bold. ² (+) indicates that the compared algorithm is significantly better than OLELS-DE; (=) indicates no significant difference; (−) indicates that the compared algorithm is significantly worse.

presents the best, worst, and average test costs achieved by each algorithm across multiple independent runs, along with their corresponding CPU runtimes and statistical results obtained by the Wilcoxon signed-rank test. It should be noted that, since CPLEX fails to solve most instances to optimality within a reasonable time limit, we report its results based on runs capped at 1800 s (0.5 h) of CPU time for P1–P4 and 3600 s (1 h) for P5–P9. For OLELS-DE and other metaheuristic algorithms, the reported runtime refers to the CPU time consumed after completing 2000 iterations.

4.3.1. General Performance

From the experimental results, it is immediately evident that OLELS-DE demonstrates superior or highly competitive performance across the majority of the nine test instances. In most cases, it ranks first in at least two of the three reported metrics (i.e., best, worst, and mean test costs) while maintaining competitive results in the remaining cases. Even when not achieving the lowest value, its mean test cost is consistently close to the best performer, indicating strong competitiveness. For example, in instance P1, the mean test cost of OLELS-DE is $104.26, which is better than those of JADE ($114.89), EFDE ($117.82), MGDE ($118.13), WOA ($111.24), and HHO ($119.34). In larger instances, such as P9 with 100 dies, OLELS-DE reaches a mean test cost of $236.86, notably outperforming all compared methods.

In terms of robustness, which is measured by the gap between the best and worst results across 20 runs, OLELS-DE again demonstrates remarkable consistency. Taking P6 as an example, the difference between its best and worst test cost is only $9.19, while the same range for JADE, EFDE, MGDE, WOA, and HHO is $38, $118.43, $44.33, $53.9 and $66.12, respectively. Even in large and complex instances like P8 and P9, OLELS-DE maintains a relatively tight variance, showcasing its reliability. This robustness is especially crucial in practical test scheduling scenarios, where deterministic performance is often preferred over erratic optimization behavior. The performance of the compared five metaheuristic algorithms varies noticeably with problem scale. Among them, JADE generally performs better than EFDE and MGDE due to its adaptive parameter mechanism, yet it still significantly trails behind OLELS-DE in both quality and stability. The other two algorithms, WOA and HHO, based on swarm intelligence heuristics, are more prone to stagnation and suboptimal convergence, particularly in larger instances. This is reflected by their steep increase in test costs from P5 to P9, suggesting weaker scalability. For instance, on P9, the worst test cost of HHO reaches $292.31, and EFDE and MGDE go as high as $563.80 and $480.73, respectively, which are more than double the cost of OLELS-DE. For CPLEX, although it can obtain competitive results for instances P1–P4, its applicability diminishes rapidly with problem size. Even with extended CPU time limits, it fails to solve most large-scale instances to optimality, and in some cases returns solutions inferior to those of OLELS-DE.

The consistently superior results of OLELS-DE can be attributed to its layered exploration and exploitation strategy, along with the elite learning mechanism, which together promote diversified search in the early stages and intensified refinement in the later stages. This balance allows the algorithm to avoid local optima while effectively converging toward global solutions. Compared to conventional DE variants that often lack adaptive control of exploration depth or elite knowledge reuse, OLELS-DE integrates these mechanisms in a structured and cooperative manner.

4.3.2. Statistical Analysis

Building upon the performance trends discussed in Section 4.3.1, a statistical analysis is further conducted to rigorously verify whether the observed differences among algorithms are significant. To this end, two widely accepted non-parametric statistical tests are employed: Wilcoxon signed-rank test and Friedman test with post hoc multiple comparisons.

The Wilcoxon signed-rank test results presented in Table 5 reveal that OLELS-DE consistently outperforms all five compared metaheuristic algorithms (JADE, EFDE, MGDE, WOA, and HHO) across nearly all test instances. This is evidenced by the predominance of “(−)” symbols, indicating that each competitor is significantly worse than OLELS-DE in terms of the test cost. No instance shows a metaheuristic algorithm significantly outperforming OLELS-DE (i.e., no “(+)” signs). In contrast, the comparison with the exact solver CPLEX shows a more nuanced picture: CPLEX significantly surpasses OLELS-DE on instances P1 and P5, performs equivalently on P2 and P3, but is significantly outperformed by OLELS-DE on larger instances from P4 onwards. These findings align with the expected computational limitations of exact solvers when facing large-scale, complex problems within reasonable time budgets.

Complementing the pairwise Wilcoxon analysis, the Friedman test is conducted to provide a global ranking of the algorithms based on their performance across all nine test instances. As summarized in

Table 6. Average ranking of algorithms based on Friedman test across all test instances.

Algorithms	OLELS-DE	JADE	EFDE	MGDE	WOA	HHO	CPLEX
Average Ranking	1.3333 1	4.8889	5.7778	6.7778	3.2222	4.3333	1.6667

¹ Values in bold indicate the best average ranking value.

, OLELS-DE achieves the lowest (best) average rank of 1.3333, closely followed by CPLEX at 1.6667, whereas the remaining algorithms exhibit considerably inferior rankings, with MGDE and EFDE occupying the bottom positions.

Subsequent post hoc multiple comparison procedures, including Bonferroni–Dunn, Holm, and Hochberg corrections, are applied to ascertain the statistical significance of OLELS-DE’s superiority over each competitor individually.

Table 7. p-values obtained through post hoc methods include Bonferroni–Dunn, Holm, and Hochberg.

OLELS-DE v.s.	z	Unadjusted p	Bonferroni–Dunn p	Holm p	Hochberg p
MGDE	5.346	0 1	0.000001	0.000001	0.000001
EFDE	4.364	0.000013	0.000076	0.000064	0.000064
JADE	3.491	0.00048	0.002882	0.001921	0.001921
HHO	2.946	0.00322	0.009318	0.009659	0.009659
WOA	1.855	0.043617	0.381704	0.127235	0.127235
CPLEX	0.327	0.743421	0.460524	0.743421	0.743421

¹ Values in bold indicate statistically significant differences with p-values below the significance level of 0.05.

confirms that OLELS-DE significantly outperforms MGDE, EFDE, JADE, and HHO at a highly stringent significance level (adjusted p-values all below 0.01). The difference between OLELS-DE and WOA is also significant at a less strict threshold (unadjusted $p=0.043617$), while no statistically significant difference is observed between OLELS-DE and CPLEX (unadjusted $p>0.7$).

Collectively, these statistical test results substantiate the consistent and robust superiority of OLELS-DE over state-of-the-art metaheuristic approaches and demonstrate its competitiveness with exact optimization methods, especially on large-scale 2.5D IC test scheduling problems.

4.3.3. Convergence Performance

To further assess the optimization dynamics and stability of the compared algorithms, convergence curves are plotted to visualize the evolution of the test cost over iterations. Figure 4 depicts the convergence behavior of the proposed OLELS-DE algorithm compared with five other metaheuristic algorithms across nine test instances. Each curve corresponds to the run that achieves the best test cost among 20 independent runs, thereby reflecting the most efficient convergence process observed for each algorithm. It is evident that OLELS-DE consistently exhibits the most favorable convergence patterns across all instances, excelling in both convergence speed and final solution quality. In nearly every case, OLELS-DE rapidly reduces the test cost within the first few hundred iterations and then stabilizes at a near-optimal value with minimal oscillation. This behavior underscores the effectiveness of its orthogonal learning-based search mechanism and elite learning-based local search strategy, which together enable fast exploitation while preserving strong global search capability.

In contrast, the performance of other compared algorithms appears more volatile and often suboptimal. JADE and EFDE, although capable of early cost reduction, frequently stagnate at higher values, indicating premature convergence. MGDE shows slower and less stable descent, especially on larger instances (e.g., P6–P9), suggesting difficulty in escaping local optima and adjusting to increased problem complexity. WOA and HHO, while sometimes achieving rapid early progress, often exhibit oscillating or irregular convergence patterns, reflecting weak solution refinement and susceptibility to randomness in their search dynamics.

Importantly, the advantage of OLELS-DE becomes more obvious as the problem scale increases. On medium-scale instances (e.g., P1–P3), the gap in final test cost among some algorithms is relatively small. However, on larger instances (P6–P9), OLELS-DE maintains its performance with minimal degradation, while the compared methods suffer significant slowdowns or fail to reach competitive solutions even after 2000 iterations. This indicates that OLELS-DE not only achieves strong convergence but also scales effectively with problem complexity, which is an essential property for practical applications involving large-scale 2.5D ICs. Moreover, the convergence curves of OLELS-DE are notably smoother and more stable, revealing its inherent robustness and low variance. This stands in contrast to the jagged, fluctuating paths observed in HHO, MGDE, and EFDE, which are often affected by poor parameter control or excessive randomness. The elite learning mechanism in OLELS-DE ensures that high-quality solutions are retained and exploited efficiently, avoiding regression or instability in the optimization trajectory.

4.3.4. Computational Runtime Comparison

Figure 5 presents the CPU runtime of each algorithm after completing 2000 iterations as the number of dies increases, based on the “time” values reported in Table 5. The curves clearly illustrate how computational cost scales with problem size and reveal distinct runtime characteristics for different algorithms.

WOA consistently records the lowest runtime and the flattest growth trend: its CPU time rises only slightly from 4.99 s at 20 dies to 10.19 s at 100 dies. This reflects very low per-iteration overhead, making WOA the fastest method; however, its solution quality is comparatively poor as previously discussed. JADE and EFDE show moderate and stable runtime growth. JADE’s CPU time increases from 6.27 s to 56.80 s, while EFDE ranges from 15.69 s to 54.52 s. Both exhibit steady scaling behaviour, with balanced runtime–quality performance. OLELS-DE exhibits a predictable upward trend from 6.95 s at 20 dies to 79.17 s at 100 dies. Although its CPU runtime is higher than WOA and somewhat higher than JADE/EFDE, it remains within practical limits. Crucially, this additional computational cost is offset by significantly better solution quality, as demonstrated in the earlier cost and statistical analyses. HHO follows a similar trajectory to OLELS-DE but with slightly higher average runtime and inferior cost performance. MGDE runs quickly on medium instances but shows a sudden runtime surge for larger cases (notably P7–P9), likely due to algorithm-specific overhead that becomes prominent at higher complexity, undermining its scalability.

4.3.5. Results Evaluation with Runtime-Based Stopping Criterion

To further evaluate the practical efficiency of the proposed OLELS-DE algorithm under different termination strategies, an additional set of experiments is conducted in which the maximum CPU runtime is used as the stopping criterion instead of a fixed number of iterations. Specifically, the metaheuristic algorithms are terminated after a fixed 180 s CPU budget, and CPLEX is stopped after the same time allowed previously (1800 s for P1–P4, 3600 s for P5–P9). This setting ensures that metaheuristic algorithms are provided with an equal computational budget in real time, thereby enabling a fair evaluation of their search efficiency and solution improvement potential over extended runs. Comprehensive results are presented in

Table 8. Scheduling performance of OLELS-DE and six compared methods on P1–P9 instances with a time-based stopping criterion, including cost metrics, CPU runtime, and Wilcoxon signed-rank test results (Wilc.). The units for the metrics “best”, “worst”, and “mean” are in dollars, and the unit for the “time” metric is in seconds.

Instance	Metric	OLELS-DE	JADE	EFDE	MGDE	WOA	HHO	CPLEX
P1	best	102.19 1	104.58	108.18	106.91	102.19	109.98	102.19
	worst	104.98	114.45	115.85	119.95	116.06	125.03	102.19
	mean	103.79	109.62	113.32	114.49	108.03	117.15	102.19
	time	180	180	180	180	180	180	1800
	Wilc.	$--$	(−) 2	(−)	(−)	(−)	(−)	(+)
P2	best	122.51	130.79	132.19	137.30	128.14	139.48	125.32
	worst	126.99	158.14	160.94	167.84	166.38	166.54	125.32
	mean	124.60	146.47	147.85	153.38	139.22	152.28	125.32
	time	180	180	180	180	180	180	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P3	best	136.51	166.33	152.33	179.68	141.46	150.34	138.85
	worst	139.58	188.29	196.48	203.10	178.78	173.86	138.85
	mean	137.95	177.14	176.01	189.05	155.24	161.52	138.85
	time	180	180	180	180	180	180	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P4	best	160.46	194.68	197.16	210.44	167.02	183.09	171.37
	worst	164.58	226.63	272.78	242.50	207.17	198.69	171.37
	mean	163.09	212.57	217.54	223.83	181.46	189.33	171.37
	time	180	180	180	180	180	180	1800
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P5	best	178.67	219.72	234.93	252.76	190.95	200.52	181.12
	worst	184.64	266.37	271.31	300.12	217.29	232.05	181.12
	mean	180.26	247.54	251.03	276.52	201.98	212.04	181.12
	time	180	180	180	180	180	180	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P6	best	210.20	267.38	276.65	303.20	218.14	232.41	224.84
	worst	218.20	314.19	355.56	345.45	284.00	288.56	224.84
	mean	213.49	292.08	312.75	325.75	242.50	256.79	224.84
	time	180	180	180	180	180	180	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P7	best	216.80	302.81	305.87	340.99	229.43	236.41	240.41
	worst	230.65	338.46	467.32	383.99	279.39	282.14	240.41
	mean	224.13	322.67	338.49	363.95	251.28	263.68	240.41
	time	180	180	180	180	180	180	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P8	best	222.33	332.50	349.19	374.07	232.74	245.37	271.57
	worst	239.61	370.42	520.25	447.49	319.04	301.38	271.57
	mean	230.32	354.36	396.59	410.16	277.01	273.71	271.57
	time	180	180	180	180	180	180	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)
P9	best	222.05	349.73	367.29	388.19	235.89	245.63	253.06
	worst	237.99	402.69	556.54	457.17	305.85	285.82	253.06
	mean	229.37	378.26	454.98	432.71	264.13	266.00	253.06
	time	180	180	180	180	180	180	3600
	Wilc.	$--$	(−)	(−)	(−)	(−)	(−)	(−)

¹ The best value in each row is highlighted in bold. ² (+) indicates that the compared algorithm is significantly better than OLELS-DE; (−) indicates that the compared algorithm is significantly worse.

, and Figure 6 visually contrasts the best test cost obtained by each algorithm under iteration-limited ($G_{max}$ = 2000) and time-limited (Runtime = 180 s) conditions. This setup evaluates each method’s efficiency in utilizing a constrained computational budget.

Compared with the iteration-limited results, OLELS-DE maintains its leading performance under the time cap, consistently achieving the lowest or near-lowest scheduling cost across all problem instances. This robustness indicates that OLELS-DE’s search process is both fast and effective, enabling it to reach even higher-quality solutions when granted additional runtime beyond the fixed-iteration setting.

Notably, several algorithms exhibit improved relative performance under the time-based stopping condition. In particular, JADE, MGDE and HHO show smaller performance gaps to OLELS-DE than in the iteration-limited case, suggesting that their solution quality benefits substantially from the extended computational time and that they can converge to competitive solutions when allowed to run longer. WOA also benefits moderately from the time limit, as its lightweight search operations allow more iterations to be executed within the extended runtime, partially compensating for its lower per-iteration effectiveness. In contrast, EFDE exhibit a decline in relative performance under the time cap in some test instances (e.g., P5 and P8). This can be attributed to its higher per-iteration computational overhead and slower convergence speed, which limit the ability to fully exploit the additional runtime and refine solutions effectively.

From a broader perspective, the results demonstrate that algorithms capable of sustaining improvement throughout extended runs can gain a comparative advantage when more runtime is available. OLELS-DE’s combination of effective local search and balanced exploration–exploitation still ensures that it outperforms all other metaheuristics in most instances, while also remaining competitive with CPLEX for larger problems where the latter cannot complete an exhaustive search within its own time budget.

4.4. Sensitivity Analysis

In this subsection, we conduct experiments to analyze the sensitivity of the proposed OLELS-DE algorithm to two critical parameters when solving the test scheduling problems in 2.5D ICs. The first is the population size N, which directly affects the diversity of search directions and search efficiency. The second is the threshold parameter $T_{max}$, which determines the execution frequency of the designed orthogonal learning-based search mechanism and elite-based local search strategy.

4.4.1. Sensitivity Analysis of Population Size N

The population size N plays a crucial role in determining the search behavior of OLELS-DE. Generally speaking, a small N may lead to insufficient diversity in the population, thereby increasing the risk of premature convergence or stagnation to suboptimal solutions. Conversely, an excessively large N can enhance diversity but often dilutes the selective pressure, potentially slowing down convergence. Moreover, a larger population size inevitably increases the number of fitness evaluations required in each iteration, which results in longer CPU runtime for the same number of iterations. Therefore, it is necessary to determine an appropriate N that balances solution quality and computational efficiency.

In the experiments, we select five candidate values of N, i.e., $N\in \{50,100,150,200,250\}$. The scheduling results of OLELS-DE with different settings of N are presented in

Table 9. Scheduling performance of OLELS-DE with different population sizes N on P1–P9 instances. The results including cost metrics, CPU runtime, and Wilcoxon signed-rank test results (Wilc.). The units for the metrics “best”, “worst”, and “mean” are in dollars, and the unit for the “time” metric is in seconds.

Instance	Metric	N = 50	N = 100	N = 150	N = 200	N = 250
P1	best	102.19 1	102.19	102.72	103.13	103.62
	worst	105.90	105.31	104.82	105.31	105.31
	mean	104.45	104.26	104.06	104.05	104.38
	time	5.02	6.95	22.88	43.98	55.28
	Wilc.	(=) 2	$--$	(=)	(=)	(=)
P2	best	125.58	124.47	123.52	125.10	125.41
	worst	134.02	129.82	129.61	130.14	131.21
	mean	128.02	126.03	126.20	127.21	127.58
	time	7.57	11.71	39.87	53.97	68.60
	Wilc.	(−)	$--$	(=)	(−)	(−)
P3	best	137.00	137.26	136.93	136.87	137.72
	worst	149.96	140.61	142.01	141.44	141.77
	mean	141.40	138.66	139.35	139.35	139.57
	time	16.94	33.55	45.21	61.19	77.20
	Wilc.	(−)	$--$	(=)	(=)	(−)
P4	best	165.66	162.43	160.86	160.52	161.87
	worst	178.95	170.23	168.81	167.09	168.30
	mean	169.42	164.99	164.60	164.63	164.68
	time	19.62	34.50	51.85	70.28	89.03
	Wilc.	(−)	$--$	(=)	(=)	(=)
P5	best	182.40	179.65	179.35	177.72	180.71
	worst	198.23	186.72	185.10	185.90	185.53
	mean	189.67	182.72	182.82	182.59	183.58
	time	22.15	43.38	57.97	78.25	99.59
	Wilc.	(−)	$--$	(=)	(=)	(−)
P6	best	220.23	213.60	210.70	213.00	212.38
	worst	252.99	222.79	221.17	224.40	222.96
	mean	231.28	217.26	217.84	218.13	218.41
	time	25.81	51.18	76.18	89.51	113.35
	Wilc.	(−)	$--$	(=)	(=)	(=)
P7	best	230.65	216.73	222.31	223.16	220.62
	worst	257.27	233.77	231.49	232.85	231.84
	mean	244.56	227.51	227.15	226.90	227.06
	time	28.14	60.43	81.15	96.29	134.02
	Wilc.	(−)	$--$	(=)	(−)	(−)
P8	best	236.59	230.11	228.53	227.48	227.84
	worst	281.23	245.60	237.08	237.11	242.73
	mean	254.20	236.54	232.76	233.48	234.44
	time	30.49	68.79	91.18	103.55	151.82
	Wilc.	(−)	$--$	(=)	(=)	(=)
P9	best	233.40	223.09	225.90	224.19	227.11
	worst	275.91	249.64	236.48	231.82	236.68
	mean	258.83	236.86	230.32	228.66	230.75
	time	29.33	79.17	110.07	137.63	179.98
	Wilc.	(−)	$--$	(=)	(=)	(=)

¹ The best value in each row is highlighted in bold. ² (=) indicates no significant difference between N = 100 with other settings; (−) indicates that other settings of N are significantly worse than N = 100.

. The results show that N = 100 achieves competitive or superior mean costs across most instances while keeping the runtime within a reasonable range. In contrast, smaller populations such as N = 50 tend to produce worse solutions, as confirmed by the Wilcoxon signed-rank test indicating significant performance degradation in most cases. Larger populations ($N\ge 150$) occasionally yield marginally better best-case results, but these gains are inconsistent and come at the expense of substantially increased runtime, which is often more than double that of N = 100. Considering both solution quality and computational efficiency, N = 100 is identified as the most suitable population size for OLELS-DE.

4.4.2. Sensitivity Analysis of Parameter $T_{max}$

In the OLELS-DE algorithm, the parameter $T_{max}$ controls the detection frequency of premature convergence and stagnation, thereby determining how often the orthogonal learning-based search mechanism and elite-based local search strategy are activated. A smaller $T_{max}$ triggers these strategies more frequently, which can enhance exploitation capability and improve solution quality by helping the search escape from local optima. However, this also increases computational overhead due to the additional search operations. Conversely, a larger $T_{max}$ reduces the activation frequency, lowering the runtime but potentially compromising solution quality because of insufficient exploitation.

To examine its impact, experiments are conducted with $T_{max}\in \{10,30,50,70,90,100\}$ on the P1–P9 instances, and the results are summarized in

Table 10. Scheduling performance of OLELS-DE with different $T_{max}$ settings on P1–P9 instances. The results including cost metrics, CPU runtime, and Wilcoxon signed-rank test results (Wilc.). The units for the metrics “best”, “worst”, and “mean” are in dollars, and the unit for the “time” metric is in seconds.

Instance	Metric	${\mathit{T}}_{max}$ = 10	${\mathit{T}}_{max}$ = 30	${\mathit{T}}_{max}$ = 50	${\mathit{T}}_{max}$ = 70	${\mathit{T}}_{max}$ = 90	${\mathit{T}}_{max}$ = 100
P1	best	102.19 1	103.59	102.19	103.04	103.62	103.62
	worst	105.31	104.82	105.31	106.71	106.71	108.00
	mean	104.24	104.19	104.26	104.73	104.70	105.43
	time	13.27	9.59	6.95	6.19	6.13	5.15
	Wilc.	(=) 2	(=)	$--$	(−)	(=)	(−)
P2	best	124.89	124.07	124.47	124.24	124.84	127.41
	worst	128.42	127.08	129.82	130.21	131.03	135.25
	mean	126.36	125.92	126.03	127.07	127.19	130.11
	time	22.96	19.98	11.71	10.49	9.47	7.49
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P3	best	137.00	136.69	137.26	137.96	138.39	137.90
	worst	140.80	140.62	140.61	141.57	142.01	143.90
	mean	138.96	139.08	138.66	139.69	140.49	141.14
	time	42.08	37.69	33.55	24.35	20.24	17.22
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P4	best	162.20	162.60	162.43	162.96	164.03	165.57
	worst	167.10	168.43	170.23	169.32	169.79	174.16
	mean	164.63	164.57	164.99	165.94	166.32	168.97
	time	48.72	40.78	34.50	29.07	23.79	20.96
	Wilc.	(=)	(=)	$--$	(=)	(−)	(−)
P5	best	181.65	179.17	179.65	181.65	181.96	183.98
	worst	187.81	186.82	186.72	187.79	191.58	194.76
	mean	183.63	182.49	182.72	184.91	186.30	190.36
	time	59.97	48.93	43.38	36.84	33.59	28.54
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P6	best	212.19	212.57	213.60	216.43	213.72	220.35
	worst	222.20	221.61	222.79	225.24	226.25	232.17
	mean	217.92	216.44	217.26	220.55	220.86	226.24
	time	73.77	64.25	51.18	39.75	32.25	30.21
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P7	best	220.44	223.29	216.73	225.00	224.37	228.76
	worst	238.60	238.16	233.77	235.62	242.73	242.68
	mean	227.40	228.96	229.51	231.18	232.08	236.14
	time	83.30	70.54	60.43	54.95	44.27	40.29
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P8	best	227.59	228.45	230.11	231.57	228.41	235.81
	worst	242.94	246.04	245.60	247.92	249.28	257.33
	mean	234.98	236.54	237.79	239.43	242.99	245.20
	time	91.47	78.08	68.79	59.08	49.34	42.58
	Wilc.	(=)	(=)	$--$	(−)	(−)	(−)
P9	best	225.51	222.71	223.09	229.56	228.95	230.58
	worst	242.04	243.28	249.64	250.67	249.88	250.22
	mean	234.37	234.80	237.86	239.86	239.45	246.38
	time	109.33	89.03	79.17	56.45	48.64	43.60
	Wilc.	(=)	(=)	$--$	(=)	(=)	(−)

¹ The best value in each row is highlighted in bold. ² (=) indicates no significant difference between T_max = 50 with other settings; (−) indicates that other settings of T_max are significantly worse than T_max = 50.

. The results show that when $T_{max}$ is small (e.g., $T_{max}$ = 10 or 30), the algorithm often achieves competitive or even best results in terms of mean and best scheduling cost across multiple instances, confirming the benefit of frequent execution of the orthogonal learning-based search mechanism and elite-based local search strategy. However, excessively large values of $T_{max}$ (≥90) generally lead to notable degradation in solution quality, as the algorithm becomes less responsive to premature convergence and stagnation. In contrast, the runtime consistently decreases as $T_{max}$ increases, with reductions of over 50% observed in some large-scale instances when moving from $T_{max}$ = 10 to $T_{max}$ = 100, primarily due to the reduced number of additional search activations. Statistical analysis further indicates that $T_{max}$ = 30 and $T_{max}$ = 50 deliver similar performance without significant differences, while $T_{max}\ge 90$ performs significantly worse in most cases. As illustrated in Figure 7, which takes instances P7 and P9 as representative examples, the average test cost (blue curve) remains low for smaller $T_{max}$ values but increases noticeably when $T_{max}$ exceeds 70, while the CPU runtime (red dashed curve) exhibits a clear decreasing trend with increasing $T_{max}$—a pattern that fully aligns with the above observations.

Based on these observations, $T_{max}$ = 10 offers slightly better solution quality in certain cases but at a substantial runtime cost, whereas $T_{max}$ = 50 provides a more favorable trade-off between solution quality and computational efficiency. Therefore, $T_{max}$ = 50 is adopted as the default parameter setting for OLELS-DE in this study.

5. Conclusions

This paper presents an effective solution to the test-path scheduling problem in interposer-based 2.5D ICs by introducing an orthogonal learning-based differential evolution algorithm, termed OLELS-DE. The proposed method augments traditional differential evolution with an orthogonal learning-based search strategy and an elite learning mechanism, jointly improving convergence speed and solution quality. A cost mathematical model is formulated to simultaneously minimize total test time and cumulative interconnect length, enabling a balanced and practical optimization framework under real-world design constraints. Extensive experiments on nine benchmark test instances demonstrate that OLELS-DE consistently outperforms five state-of-the-art metaheuristic algorithms and CPLEX in both solution quality and convergence behavior. Furthermore, the algorithm exhibits strong scalability, maintaining robustness and efficiency as the number of dies increases. These results highlight the potential of OLELS-DE as a reliable and scalable optimization method for complex test scheduling tasks in advanced multi-die integration.

Future research will focus on several directions to further enhance the applicability and performance of OLELS-DE. First, adaptive parameter control strategies will be investigated to dynamically adjust search behavior according to the problem landscape. Second, the current scheduling model adopts a simplified formulation without explicit power and thermal constraints, enabling a controlled setting for fair algorithm comparisons. However, in practical 2.5D IC testing, excessive parallel testing can cause power delivery issues and thermal hotspots. Future work will extend the model to incorporate dynamic power budgets and temperature-aware constraints, improving its realism and applicability in industrial environments. Third, the methodology will be generalized to other integration scenarios, such as chiplet-based and 3D-stacked systems. Finally, to verify its industrial practicality, OLELS-DE will be applied to real industrial test cases, ensuring its effectiveness beyond synthetic benchmarks.