A double-decomposition based parallel exact algorithm for the feedback length minimization problem

Introduction

Enterprises face more and more competition, which requires the competitors to develop new products in a short time. However, product development projects often involve many interrelated activities with complex information dependences (Lin et al., 2012; Bashir et al., 2022). Such activities usually follow uncertain processes and rework frequently, which makes it difficult for managers to control the project durations, costs and risks (Mohammadi, Sajadi & Tavakoli, 2014; Lin et al., 2018). Therefore, how to sequence interrelated activities to reduce negative impacts has drawn considerable attention (Attari-Shendi, Saidi-Mehrabad & Gheidar-Kheljani, 2019; Wen et al., 2021).

The design structure matrix (DSM) can clearly describe interrelated activities and interdependence, which is considered an effective tool in scheduling development projects (Browning, 2015; Wen et al., 2021). Figure 1A presents a typical DSM of a balancing machine project (Abdelsalam & Bao, 2007), where activities are listed on the left column and the top row following the same order; d_i,j(0 ≤ d_i,j ≤ 1, i ≠ j) denotes the degree of information dependence of activity i on j(marked in red). Since activity i precedes j, d_i,j represents the backward information flow from downstream to upstream in the activity sequence, which is above the diagonal and called feedback; d_j,i is the information flow in opposite direction, which is under the diagonal and called feedforward. In Fig. 1B, if the order of activities i and j is reversed, then d_i,j and d_j,i become a feedforward and a feedback, respectively. The information flows from other activities to i and j are also affected (marked in yellow), which means that adjusting the activity sequence can significantly affect the overall information flows in DSM (Lin et al., 2015; Meier et al., 2016).

Figure 1 indicates that due to the existence of feedbacks, upstream activities often execute in the absence of information. Once the downstream activities complete, feedbacks may cause upstream activities to rework. In fact, feedbacks usually involve suggestions, errors and modifications, which are the main reason for project delay and cost overrun (Haller et al., 2015; Lin et al., 2015; Wynn & Eckert, 2017). Therefore, some researches suggest minimizing the total feedback values of activity sequence to reduce negative effects (Qian et al., 2011; Nonsiri et al., 2014). However, these studies do not consider the influence of feedback length, i.e., long feedbacks across more activities may cause more upstream activities to rework than short ones. Hence, the objective of minimizing the total feedback length is proposed, which has been widely applied in DSM-based scheduling problems. For instance, Qian & Yang (2014) demonstrated the effectiveness of optimizing the feedback length to reduce the overall reworks through a case study of a pressure reducer project. Benkhider & Kherbachi (2020) used a composite objective that considers the feedback length to reduce the duration of Huawei P30 pro project; Gheidar-kheljani (2022) studied a two-objectives scheduling model that considers the feedback length and the cost of decreasing dependence among activities.

For a development project, let I = {1, 2, …, i, …, n} be an activity set, D = (d_i,j)_(n×n) be a DSM, and decision variable x_i,j = 1 if activity i precedes j, otherwise x_i,j = 0. Then, the feedback length minimization problem (FLMP) can be formulated as a 0-1 quadratic programming problem (Qian & Lin, 2013):

(1)${\displaystyle Min\sum _{i=1}^n\sum _{j=1,j\ne i}^n{d}_{i,j}{x}_{i,j}\left(\sum _{k=1,k\ne j}^n{x}_{k,j}-\sum _{k=1,k\ne i}^n{x}_{k,i}\right)}$ (2)${\displaystyle s.t.x_{i,j}+x_{j,i}=1,for1\le i<j\le n}$ (3)${\displaystyle x_{i,j}+x_{j,k}+x_{k,i}\le 2,fori\ne j\ne k}$ (4)${\displaystyle x_{i,j}\in \left\{0,1\right\},for1\le i,j\le n,i\ne j.}$

where 0–1 vector X = (x_1,2, …, x_i,j, …, x_n,n−1) denotes an activity sequence; objective function Eq. (1) minimizes the total feedback length, if x_i,j = 1, then feedback d_i,j and its length (${\sum }_{k=1,k\ne j}^n{x}_{k,j}-{\sum }_{k=1,k\ne i}^n{x}_{k,i}$) are counted into the objective value; constraint Eq. (2) guarantees that there is only one execution order for activity i and j; constraint Eq. (3) ensures that the execution order is transitive; constraint Eq. (4) guarantees that decision variables are binary.

Further, the original model can be simplified to a sequence-based model (Lancaster & Cheng, 2008; Shang et al., 2019). Let integer vector S = (s₁, s₂, …, s_h, …, s_k, …, s_n) be an activity sequence, where decision variable s_h is the activity at position h of the sequence, for example, s₃ = 5 means that activity 5 is assigned to position 3. Since position h is set before position k(h < k), d_sh,sk is the feedback from position k to h, and the sequence-based model can be formulated as follows:

(5)${\displaystyle Min\sum _{h=1}^{n-1}\sum _{k=h+1}^n{d}_{s_h,s_k}\left(k-h\right)}$ (6)${\displaystyle s.t.s_h,s_k\in I,s_h\ne s_k,d_{s_h,s_k}\in D,for1\le h<k\le n}$

where objective function Eq. (5) minimizes the total feedback length, (k − h) is the length of feedback d_sh,sk; constraint Eq. (6) limits the values of the decision variables (s_h, s_k ∈ I) and prohibits an activity from appearing in multiple positions (s_h ≠ s_k). Due to the concise expression of FLMP, we mainly analyze the sequence-based model in the rest of this article.

Researchers have proved that FLMP is NP-hard and extremely difficult to solve (Meier, Yassine & Browning, 2007). Therefore, many studies proposed heuristic approaches to obtain near-optimal activity sequences. These algorithms usually follow the classic heuristic framework, such as genetic algorithm, local search, which can obtain a reasonable solution within a short time, but cannot guarantee the global optimum. On the other hand, studies on exact approach are quite limited, and the existing algorithms are not practical due to the weak computational capability. Nevertheless, the research on specialized exact algorithms has promoted the exploration FLMP properties. Shang et al. (2019) found that FLMP has optimal sub-structure, which allows the original problem to be decomposed into multiple subproblems. Based on this property, they developed a parallel exact algorithm, which can solve FLMP with 25 activities in 1 h and is the state of the art exact approach in current literature (see the detailed review in ‘Literature review’).

This study focus on improving the computational capability of exact approach for FLMP, through fully utilizing the structural properties. We develop a double-decomposition based parallel branch-and-prune algorithm (DDPBP), to obtain the optimal activity sequence. The proposed algorithm first divides FLMP into forward and backward scheduling subproblems, then decomposes subproblems into several scheduling tasks and solving them concurrently. The resulting optimal subsequences are connected to be the global optimum. Furthermore, we propose an effective result-compression strategy to reduce communication costs in parallel process, and a novel hash-address strategy to boost the efficiency of sequence comparisons. Computational experiments on 480 FLMP instances show that DDPBP significantly reduces the time consumption for obtaining the optimal solution, and increases the problem scale that exact algorithms can solve to 27 activities within 1 h.

The rest of this article is organized as follows. ‘Literature review’ presents a literature review on exact and heuristic approaches for FLMP. In ‘FLMP analysis’, we recall the properties of FLMP, which is the foundation of the proposed algorithm. ‘Double-decomposition based algorithm’ introduces the main scheme and key phases of DDPBP, including the result-compression strategy. ‘Hash strategy’ provides the hash-address strategy applied in DDPBP. ‘Computational experiments’ conducts the comparisons between DDPBP and state of the art algorithms. ‘Analysis’ provides systematic analyses of parameters and key strategies. ‘Conclusions’ draws conclusions.

Literature review

This section presents a literature review about FLMP and the existing solution approaches, while some closely related problems are also mentioned. Table 1 summarizes the optimization objectives and the proposed algorithms discussed in the literature.

The high uncertainty of the development process makes it difficult to estimate the project duration, costs and risks. Therefore, many studies usually introduce alternative optimization objectives to reschedule the development process. One fundamental objective is to minimize the total feedback value, i.e., the overall strength of the information flows above the diagonal of DSM. Qian et al. (2011) simplified this scheduling problem by treating a group of activities as one abstract activity, then developed a hybrid heuristic approach to reduce the total feedback value of development projects; Lin et al. (2015) proposed an objective of minimizing the total feedback time based on the feedback value, and developed a local search based heuristic to optimize the project of a balancing machine; Attari-Shendi, Saidi-Mehrabad & Gheidar-Kheljani (2019) presented a multi-objective model that considers the total feedback value, technology risk and financial status to schedule the process of development projects. These researches have offered useful guidance in optimizing development process with interrelated activities. However, none of them considers the influence of the feedback length on the development process.

Altus, Kroo & Gage (1995) and Todd (1997) and many other studies have pointed that the feedback spanning across more activities usually leads to more reworks, which indicates that the length of feedback may significantly affect the development progress. Therefore, a more reasonable objective of finding the activity sequence with the minimum total feedback length is proposed. Over the years, many practical applications have confirmed that the feedback length minimization (FLMP) is an appropriate approximation of minimizing the project duration, costs and risks (see, e.g., Meier, Yassine & Browning, 2007; Lancaster & Cheng, 2008; Qian & Yang, 2014).

Due to the NP-hard nature of FLMP, it is extremely difficult to find the optimal activity sequence, even for small-scale problems. Thus, researchers turned to develop heuristic approaches to obtain near-optimal solutions. In particular, Lin et al. (2018) proposed an effective hybrid algorithm by integrating an insertion-based heuristic with simulated annealing. Khanmirza, Haghbeigi & Yazdanjue (2021) introduced the imperialist competitive algorithm to solve large-scale FLMP, which is enhanced by adaptively applying operators and tuning parameters. Wen et al. (2021) introduced an insertion-based heuristic algorithm (IBH) to solve a closely related problem that minimizes the total rework time. This algorithm follows the sequential improvement strategy to select operators, and experiments showed that IBH was competitive in scheduling interrelated activities. Most recently, Peykani et al. (2023) successively optimized the feedback length and project duration by a genetic algorithm based hybrid approach, in order to reschedule development project in resource constrained scenarios. These algorithms can obtain a reasonable solution in a short time, but cannot guarantee the global optimum.

As for exact approaches, only three studies focus on scheduling interrelated activities optimally. Qian & Lin (2013) reformulated FLMP as two equivalent linear programming models, then adopted the CPLEX MILP solver to optimally solve them. However, the largest FLMP that can be solved within 1 h is limited to 14 activities, and the performance of this approach is strongly affected by the density of DSM. Gheidar-kheljani (2022) proposed multi-objective model that minimizes the total feedback length and the cost of decreasing activity dependence. They applied CPLEX to solve small scale problems and designed a genetic algorithm for large problems. Shang et al. (2019) have proven that FLMP has optimal sub-structures, which allows the original problem to be divided into multiple subproblems. Based on this, they developed a hash-address based parallel branch-and-prune algorithm (HAPBP), which is the state of the art specialized exact approach in current literature. HAPBP divides FLMP into two subproblems, and concurrently schedules activities in forward and backward directions. This algorithm also employs a hash strategy to improve the efficiency of sequence comparison, by mapping activity sequences into hash values. Experiments confirm that HAPBP can solve FLMP up to 25 activities within 1 h. The shortcomings of this study are that the proposed parallel framework limits the algorithm to only use two cores of CPU, and the hash strategy is extremely space-consuming, which prevents HAPBP from fully utilizing available computing resources.

In summary, the studies on heuristic approach did not fully explore the structural properties of FLMP, and the existing heuristic algorithms are usually designed by using the classic heuristic frameworks. On the other hand, studies on specialized exact approaches for FLMP are quite limited, and there is clearly an urgent need for such dedicated exact algorithms capable of solving problem instances that cannot be solved by existing approaches. Decomposing FLMP into subproblems to reduce the problem complexity, then solving them concurrently, is highly appealing approach to obtain the optimal activity sequence. However, the existing parallel framework and applied strategies do not take advantage of FLMP properties and available computing resources, which strongly limits the computational capability. To fulfill these research gaps, we propose in this work an novel parallel exact algorithm to solve FLMP. The main contributions are summarized as follows.

• We develop a double-decomposition based parallel branch-and-prune algorithm (DDPBP), which can employ all available computing resources to solve FLMP optimally. The proposed algorithm first divides FLMP into forward and backward scheduling subproblems, then decomposes subproblems into several scheduling tasks, and applies multiple CPU cores to prune unpromising subsequences. The resulting optimal subsequences are connected to be the global optimum.

• We propose two strategies to further enhance the DDPBP algorithm. The result-compression strategy is designed to reduce communication costs among parallel processes, by extracting and sending key information from numerous intermediate results. Furthermore, a novel hash-address strategy is developed to quickly compare and locate subsequences with lower space costs, which significantly accelerates the process of subsequence pruning.

• Computational experiments confirm the competitiveness of the DDPBP algorithm on 480 random FLMP instances, compared to the state-of-the-art exact approaches. In particular, the proposed algorithm increases the problem scale that can be solved exactly to 27 activities within 1 h, and significantly reduces the solving time for problems with less than 27 activities. In addition, further analyses shed light on the significant contributions of the result-compression and hash-address strategies to the performance of DDPBP.

FLMP analysis

Decomposing the original problem into smaller subproblems is an effective way to solve complex problems (Chen & Li, 2005; Shobaki & Jamal, 2015; Mitchell, Frank & Holmes, 2022). In this section, we briefly introduce the properties of FLMP and the resulting prune criterion (Shang et al., 2019), which allows the algorithm to divide FLMP into two independent subproblems, and discard unpromising sequences effectively. All properties are mathematically proved in Appendix.

Prune criterion

We define that any two sequences are “similar”, if they consist of the same activities, such as sequences (1, 2, 3) and (3, 1, 2); otherwise, they are “dissimilar”, such as sequences (1, 2, 3) and (1, 2, 5). Based on the preceding properties, a prune criterion is proposed as follows:

Prune criterion: In region A_p(B_p), for a subsequence SA_p(SB_p), if its feedback value $f{v}_p^a\left(f{v}_p^b\right)$ is not the lowest among similar subsequences, then any sequence S starting (ending) with SA_p(SB_p) is not the global optimum, and SA_p(SB_p) should be pruned.

For a certain pair of regions A_p and B_p, assuming the optimal $S{B}_p^{\ast }$ of B_p is found, then all high-quality sequences S should end with $S{B}_p^{\ast }$. Therefore, the quality of S depends on the quality of SA_p, or vice versa. In other words, the prune criterion holds. In addition, for each group of similar SA_p, only the one with lowest $f{v}_p^a$ is kept, the rest (p! − 1) subsequences are pruned. The same is true for SB_p. We present an example to illustrate how the prune criterion works.

In Fig. 2, for a project with I = {1, 2, 3, 4, 5, 6, 7, 8}, set p = 4, A₄ = {1, 2, 4, 5} and B₄ = {3, 6, 7, 8}, assume that the optimal $S{B}_4^{\ast }$ of B₄ is found. Since $f{v}_4^a=6.2$ of SA₄ = (2, 4, 1, 5) is higher than $f{v}_4^a=5$ of SA₄ = (1, 5, 4, 2), it can be concluded that sequence S1 is not the global optimum. However, the prune criterion does not work on S1 and S3, because SA₄ = (1, 5, 4, 2) and SA₄ = (2, 1, 3, 4) are dissimilar.

Double-decomposition based algorithm

This section presents the details of the proposed Double-Decomposition based Parallel Branch-and-Prune (DDPBP) algorithm for solving FLMP, including the general concept, the main scheme, and key phases including task distribution and result combination.

General concept

Double-decomposition means that DDPBP can decompose the whole sorting problem from two perspectives. Based on the properties of FLMP, the original problem is divided into two independent subproblems that are related to regions A_p and B_p respectively. By introducing the parallel framework, DDPBP can construct active sequences in forward (from head to tail, A_p) and backward (from tail to head, B_p) directions concurrently. Figure 3 shows the search trees applied in DDPBP. In the forward tree, each node represents a subsequence from position 1 to p within a complete sequence, for example, node (7, 6, 5) is the first three activities of one complete sequence, and child node (7, 6, 5, 4) is built by adding activity 4 to the end of node (7, 6, 5). The backward tree follows the same structure, but represents the opposite direction. DDPBP traverses two trees in a breadth-first way, along with pruning unpromising nodes (marked by red line). When the exploration finishes, the remaining partial sequences (leaf nodes) are connected as complete sequences (marked by blue line), from which we can find the optimal solution.

These two exploring processes are totally independent without any information exchange, which can be distributed to two cores of CPU. However, this framework limits the full use of available computing resources. As multi-core computers are common nowadays, a more flexible framework that supports any number of cores, is necessary. Figure 4 presents a further decomposition in the forward and backward processes. For a FLMP with seven activities, assume that six cores are available, then we can assign half of cores to each process. For the forward process, in row 3, nodes are divided into three groups and sent to three cores for node pruning. Since each core only handles partial nodes, after all tasks are finished, DDPBP gathers the results and proceeds further node pruning. After all unpromising nodes are discarded, the remaining nodes are used to generate child nodes for the next row. The decomposition in the backward process follows the same way.

The second decomposition makes it possible to take full advantage of multiple cores to share the workloads. Although forward and backward processes do not communicate with each other, multiple threads within two processes still exchange data frequently. Researches show that the communication cost in parallel frameworks cannot be ignored (Tsai et al., 2021; Wang & Joshi, 2021). Therefore, how to reduce the impact of multi-thread communication is an important issue in this study.

Algorithm 1: Main scheme.
Input:D = (dij)n×n, cn, na;
/* Design structure matrix, core number, workloads of forward process */
Output:fl∗, S∗;
Task distribution phase:
/* Traverse the forward tree */				/* Traverse the backward tree */
1	For row p = 2:1:na			1	For row p = (n − 3): − 1:na
	1.1	If (Backward process finishes)			1.1	If (Forward process finishes)
		cna = cn;				cnb = cn;
		Else				Else
		cna = cn/2;				cnb = cn/2;
	1.2	SetAp← Forward-process			1.2	SetBp← Backward-process
		( D, SetAp−1, cna);				( D, SetBp+1, cnb);
1	End for			1	End for
Result combination phase:
/* Switches to the single thread */
2	Connect all SAna in SetAna with corresponding SBna in SetBna,
	and set $fl=f{v}_{na}^a+f{v}_{na}^b$;
3	Return the optimal sequence S∗ with the lowest feedback length F∗.

Task distribution phase

The task distribution phase realizes the double decomposition of the FLMP problem. The first decomposition is to concurrently schedule activities in forward and backward directions. The second decomposition is to distribute pruning tasks of each row to given cores within forward and backward processes. We use the forward process as an example to illustrate this idea, and the backward process follows the same procedure except exploring the backward tree.

As shown in Fig. 5, the forward process consists of four components, including task distribution, node pruning, result compression and result restoration. These components work sequentially on each row until reaching row p = na.

Task distribution: Suppose that cna cores are available. The algorithm receives n_p−1 nodes stored in SetA_p−1 from row p − 1, and is about to explore row p. Then these nodes are divided into cna equal parts, i.e., SetA_p−1{i}(1 ≤ i ≤ cna) with n_p−1/cna nodes, and sends them to cna cores respectively. This procedure is single thread.

Node pruning: As shown in Algorithm 2, in the forward process, assume that core i is exploring row p and receives partial nodes stored in SetA_p−1{i}. Step 1 adds a new activity to the end of node SA_p−1 to build child node SA_p, and calculates ${fv}_p^a$ using recursive Eq. (9) (if row p = 2, use Eq. (7) instead); Steps 3.1–3.2 locate the similar node of SA_p at SetT{i}(ha) and only save the node with lower ${fv}_p^a$ at this position, where SetT{i} is a temporary result set for core i and ha is a unique hash address for each group of similar nodes (see in ‘Hash strategy’). These steps repeat, until all the child nodes SA_p are checked.

Result compression: The hash-address strategy is introduced to boost the efficiency of searching similar nodes in SetT{i}. In ‘Hash strategy’, we propose hash functions to map each group of similar nodes into a unique hash address ha. In order to support all possible addresses, the size of SetT{i} is set as $C_n^p$, which equals to the total number of similar node groups in row p. However, since a core only handles a partial task, it does not need to use all the space of SetT{i}. In fact, the hash addresses appearing in a core are usually discrete and irregular, such as {1, 3, …, 20, 26}, which causes the final SetT{i} to be sparse. Hence, in order to reduce communication cost, after node pruning finishes, the algorithm extracts remaining nodes, corresponding $f{v}_p^a$ and hash addresses from SetT{i}, and sends them to the next component, instead of transmitting the entire SetT{i} (detailed analysis in ‘Effectiveness of result-compression strategy’).

Algorithm 2: Node pruning.
Input:D = (dij)n×n, SetAp−1{i};
/* Design structure matrix, Partial results from row p − 1 */
Output: SetT{i};
1	Based on SetAp−1{i}, construct child nodes SAp for parent nodes SAp−1;
2	If ( p = 2)
	Calculate $f{v}_p^a$ for each SAp using Eq. 7;
	Else
	Calculate $f{v}_p^a$ for each SAp using Eq. 9;
3	While (There exists an unchecked SAp)
	3.1	Select an unchecked SAp, and calculate hash address ha using Eq. 11;
	3.2	IfSetT{i}(ha) is empty
		Save SAp and $f{v}_p^a$ at SetT{i}(ha);
		Else
		Compare $f{v}_p^a$, and save the one with lower $f{v}_p^a$ at SetT{i}(ha);
3	End while
4	ReturnSetT{i}

Result restoration: After receiving nodes, $f{v}_p^a$ and hash addresses from multiple cores, the whole process switches from multi threads to single thread. For the results from core i, according to hash addresses ha, the algorithm assigns nodes and $f{v}_p^a$ to SetA_p(ha), where SetA_p with the size of $C_n^p$, contains the optimal node among each group of similar nodes in row p. If SetA_p(ha) is not empty, the algorithm keeps the one with lower $f{v}_p^a$ in this position, to further prune unpromising nodes. This procedure repeats until all results from different cores are checked. Then, the algorithm is ready to explore row p + 1.

Hash Strategy

During the forward and backward processes, the algorithm needs to find the similar nodes in SetT for each node of row p; however, the time complexity of determining whether two nodes are similar is O(n²), and locating the similar nodes in SetT is O(|SetT|∗n²), in the worst case. Hence, it is necessary to convert nodes into hash values, and perform hash value comparison instead of node comparison to boost the efficiency.

Shang et al. (2019) applied the hash-address strategy in the HAPBP algorithm, which transforms each group of similar nodes into a unique hash address in a result Set, by using hash function ha = ∑_i∈SAp(SBp)2ⁱ⁻¹. HAPBP can find the similar nodes for any node at Set(ha) directly. However, as shown in Fig. 6, this function allocates hash address for all groups of similar nodes in the search tree, no matter which rows these nodes belong to. In fact, the space complexity of this strategy is $O\left({\sum }_{p=2}^{⌊n/2⌋}{C}_n^p\right)$, which causes Set to support all addresses along with corresponding storage spaces, and become extremely space-consuming. It is difficult to maintain and transmit such a huge array in a parallel framework.

This study presents a new hash strategy that only maps similar nodes within a row to a consecutive hash address ha ($1\le ha\le C_n^p$), which has a space complexity of $O\left(C_n^{⌊n/2⌋}\right)$ in the worst case, and can significantly reduce space costs of SetT. For any node in row p: ${\displaystyle {SA}_p=\left(s_1,s_2,\dots ,s_i,\dots ,s_j,\dots ,s_p\right)}$

We first reorder SA_p as s_i < s_j(1 ≤ i < j ≤ p), then encode it as a hash address by the following hash functions: (11)${\displaystyle ha=h\left(s_1\right)+\sum _{i=2}^{p-1}h\left(s_i\right)+h\left(s_p\right)}$ (12)${\displaystyle h\left(s_1\right)=\left\{\begin{array}{c}\hfill \sum _{t=1}^{s_1-1}{C}_{n-t}^{p-1},s_1\ne 1\hfill \\ \hfill 0,s_1=1\hfill \end{array}\right.}$ (13)${\displaystyle h\left(s_i\right)=\left\{\begin{array}{c}\hfill \sum _{t=s_{i-1}+1}^{s_i-1}{C}_{n-t}^{p-i},s_{i-1}+1\ne s_i\hfill \\ \hfill 0,s_{i-1}+1=s_i\hfill \end{array}\right.}$ (14)${\displaystyle h\left(s_p\right)=s_p-s_{p-1}}$

where ha is unique for each group of similar nodes in row p. Therefore, when reaching any node SA_p in row p, we can find its similar nodes at SetT(ha) and compare them directly. We present an example {1, 2, 3, 4, 5} with n = 5, p = 3 to illustrate this idea.

As shown in Fig. 7, each group of similar nodes in row 3 is mapped to a unique ha(1 ≤ ha ≤ 10), and SetT only contains the information of row 3, which is quite space-saving and easy to split among different cores. Similar nodes (marked in red) are first reordered as (2, 4, 5), then Eq. (11) converts SA₃ = (s₁, s₂, s₃) = (2, 4, 5) into ha = 9 as follows: ${\displaystyle {ha}_{\left(2,4,5\right)}=h\left(s_1\right)+h\left(s_2\right)+h\left(s_3\right)=\sum _{t=1}^{2-1}{C}_{5-t}^{3-1}+\sum _{t=2+1}^{4-1}{C}_{5-t}^{3-2}+1=C_4^2+C_2^1+1=9}$

For SA₃ = (1, 4, 5), SA₃ = (1, 2, 4), we can achieve their ha as follows: ${\displaystyle {ha}_{\left(1,4,5\right)}=h\left(s_1\right)+h\left(s_2\right)+h\left(s_3\right)=0+\sum _{t=2}^3{C}_{5-t}^1+1=0+C_3^1+C_2^1+1=6}$ ${\displaystyle {ha}_{\left(1,2,4\right)}=h\left(s_1\right)+h\left(s_2\right)+h\left(s_3\right)=0+0+\left(4-2\right)=2}$

Since Eq. (11) is performed frequently during the search process, we can calculate combination number $C_n^m$ before the search process starts. The algorithm just selects appropriate values from a predefined array according to (m, n), instead of recalculating $C_n^m$.

The hash strategy is also applied to accelerate the combination phase. For any node SA_na in SetA_na with a hash address ha_a, the algorithm can use the following function to derive the hash address ha_b of the corresponding node SB_na in SetB_na: (15)${\displaystyle {ha}_b=C_n^{na}+1-{ha}_a}$

For instance, suppose that n = 6, na = 3, SA₃ = (4, 2, 1) and SB₃ = (5, 3, 6). After resorted two nodes, we can apply Eq. (11) to obtain ha_(4,2,1) = 2 and ha_(5,3,6) = 19. Based on Eq. (15), we achieve that $h{a}_{\left(5,3,6\right)}=C_6^3+1-h{a}_{\left(4,2,1\right)}=21-2=19$. In other words, Eq. (15) holds.

Computational experiments

This section reports computational experiments to evaluate the effectiveness of the DDPBP algorithm. Specifically, we first describe the benchmark instances and the experimental protocol. Then, we make comparisons between the proposed algorithm and state of the art algorithms in literature.

Analysis

This section provides systematic analyses for parameters and strategies applied in the algorithm. We first conduct a sensitivity analysis to see if there exist significant differences among different parameter settings. Then, to confirm the effectiveness of double-decomposition strategy, result-compression strategy and hash-address strategy, DDPBP is compared with three variants whose related components are removed.

Conclusions

Minimizing the total feedback length is an effective objective to optimize development projects. In this study, we presented an efficient double-decomposition based parallel branch-and-prune algorithm, to obtain the optimal activity sequence of FLMP. The proposed algorithm divides FLMP into several subproblems through an original double-decomposition strategy, then employs multiple CPU cores to solve them concurrently. In addition, we proposed a result-compression strategy to reduce communication costs in parallel process, and a hash-address strategy to boost the efficiency of sequence comparisons.

Computational experiments indicate that the proposed algorithm is able to increase the scale of FLMP that exact algorithms can solve within 1 h to 27 activities, and clearly outperforms the best exact algorithms in literature. Furthermore, additional experiments show the effects of two parameters on algorithm performances, and confirm the advantage of the double-decomposition strategy, the importance of the result-compression strategy and the hash-address strategy.

Some strategies applied in this study are general and could be introduced to solve other sorting problems. For example, the double-decomposition strategy first divides a sorting problem into forward and backward subproblems, then further decomposes them into several sorting tasks, which can significantly reduce the complexity of sorting problems. Furthermore, the hash-address strategy maps similar sequences into a unique value, which can be used to compare and search sequences.