Logic-based Benders decomposition with a partial assignment acceleration technique for avionics scheduling

Pre-runtime scheduling of large-scale electronic systems, as those in modern aircraft, can be computationally challenging. In this paper, we study a distributed integrated modular avionic system of practical relevance where the scheduling includes to assign communication messages to time slots and to sequence tasks on modules. For this problem, the challenge is the huge number of tasks to be scheduled and the intricate interaction between the communication and task scheduling. We present a method based on Logic-Based Benders Decomposition (LBBD) to solve this problem. In a master problem, formulated as a mixed-integer program, communication messages are assigned to time slots and in a subproblem, formulated as a constraint program, tasks are scheduled. Our LBBD scheme is accelerated by using cut strengthening, a subproblem relaxation, and components for preprocessing and initialisation of the scheme. The cut strengthening is of the kind that systematically investigates subsets of variables to include in the cut by solving additional subproblems. To further enhance the eﬃciency of the scheme, we propose a new strategy that extends cut strengthening to also try to construct feasible solutions by using information from solving the additional subproblems. Our computational evaluation is based on publicly available instances with up to 2530 messages and 54,731 tasks. It shows that our method outperforms previous methods for the problem with respect to both solution times and RAM usage. A further evaluation of the diﬀerent components in the method shows that our new acceleration strategy is important to achieve these results.


Introduction
A crucial aspect to consider when designing an aircraft is that the avionic system, the electronics in the aircraft, can never be allowed to fail in a way that has consequences for the operation of the aircraft. Over the years, the aircraft industry has moved in the direction of defining an increased amount of functionality through software implementations, and this is a development that is expected to continue. Modern systems are designed to be iteratively developed, flexible, modular and ready for functionality that is not yet known. This also means that the same hardware can be used for many different functions and that the appropriate hardware resources need to be allocated to the specific software functions to ensure safe operation of the aircraft.
The design principle Integrated Modular Avionics (IMA) is one contributor to meet the expectations on future safety-critical electronic systems (Gaska et al., 2015;Wang and Niu, 2018). This has been evolved through large research initiatives such as Scarlett that included industrial partners such as Airbus and Saab. In this architecture, there is one layer that hosts the application modules that run the actual software. This layer is physically separated from the layer that hosts communication modules and these merely act as an infrastructure that supports the communication between the application modules. To pass data between the communication modules, a Time-Triggered Ethernet (TTEthernet) can be used (Gaska et al., 2015;Wang and Niu, 2018). TTEthernet can handle both timetriggered communication and rate-constrained communication (e.g. AFDX, used by both Airbus and Boeing) as well as best-effort traffic (Robati et al., 2017).
In more general terms, a system designed according to this principle can be referred to as a distributed modular electronic system that communicates via TTEthernet. An important characteristic of such design is the need to schedule when different functions are allowed to use the hardware resources. Because the system is complex and safety-critical, computationally cheap on-line scheduling algorithms, such as those used in e.g. PCs, are not a viable option (Xu and Parnas, 2000). The scheduling must instead be made off-line (at compile time) and in a way that guarantees the availability of required hardware resources. A recent example of off-line scheduling of an IMA system with a TTEthernet is found in Zhou et al. (2020) and earlier references on scheduling of IMA systems are reviewed in Blikstad et al. (2018).
For large-scale systems, as those in a modern aircraft, the scheduling can pose a great computational challenge. This is both described in the engineering literature (Gaska et al., 2015;Wang and Niu, 2018) and confirmed in our interdisciplinary research collaboration between Linköping University and Saab. Within this collaboration, we combine engineering knowledge with optimisation research in the study of an advanced IMA system with a specific time-triggered Ethernet communication. In previous work, we have proposed scheduling methods, see Blikstad et al. (2018) and , for this problem.
This paper will present a new and more efficient method for solving this scheduling problem. Since the technical background has been detailed in previous work (Blikstad et al., 2018;, we try to omit as many engineering details as possible in the problem statement. Instead, we will focus on the structure of the problem, which will mainly be described using optimisation nomenclature. The motivation for developing more efficient solution methods for the problem is that, in practice, the scheduling needs to be done each time an engineer makes a software change during the development of the system. This is typically done on a daily basis during several years. The scheduling determines if there is room for the new function or if changes are needed, and hence it is important for the engineers to get the feedback from the scheduling as quickly as possible. Briefly, the problem can be described as a rich multiprocessor scheduling problem that also includes a communication network. The communication is scheduled by assigning messages to time slots and once these decisions are made, the remaining problem gets a relatively pure and simple task-scheduling structure. This property is exploited in the method design by applying Logic-Based Benders Decomposition (LBBD) where communication messages are assigned to time slots in an assignment-type master problem and the subproblem is used to sequence the tasks. The master problem is formulated as a Mixed-Integer Programming (MIP) model while the subproblem is formulated as a Constraint Programming (CP) model. LBBD, introduced in Hooker (2000) and Hooker and Ottosson (2003), is a decomposition approach that has been successfully applied to large-scale discrete optimisation problems (Hooker, 2019). In particular, excellent computational performance has been reported when it has been used in the design of exact methods that hybridise MIP and CP techniques to solve resource allocation and scheduling problems (Hooker, 2007;Lombardi and Milano, 2012;Coban and Hooker, 2013;Sun et al., 2019;Emde et al., 2020). In general, the efficiency of LBBD methods rely on acceleration techniques tailored to the problem structure (Rahmaniani et al., 2017;Hooker, 2019). The most common ones described in Hooker (2019) are to strengthen the master problem by a subproblem relaxation, to design improved cuts (e.g. analytical Benders cuts), and to perform cut strengthening. In addition, heuristic strategies can be used to further improve the computational performance.
Preliminary results from applying LBBD to our scheduling problem, together with known acceleration techniques (subproblem relaxation and cut strengthening), showed great promise and confirmed that the decomposition takes advantage of the problem structure. However, it was not sufficient to solve our largest instances. To overcome this, we have developed a new acceleration technique that extends cut strengthening with a component that tries to construct feasible solutions based on information from the cut strengthening.
Our extension can briefly be described as follows. In general, a LBBD cut specifies a set of master problem variables that cannot take their current values in a solution to the problem. Cut strengthening means that this set is reduced to obtain a smaller and hence stronger cut. One way to find a stronger cut is to perform a search that systematically evaluates different subsets of variables. In our extended strategy, we include an additional step in such search; this step is applied each time a subset of variables has been evaluated and what is done depends on the outcome of this evaluation. Either, if the current subset is confirmed to yield a cut, we form a restriction of the original problem with respect to the variables not included in the current subset. If this restricted problem is feasible, its solution is also a feasible solution to the original problem. Or, if the current subset does not yield a cut, a restriction is instead constructed with respect to the variables included in this subset. Again, if a feasible solution to this restricted problem is found, we have found a feasible solution to the original problem.
Note that in any search for stronger cuts by systematically investigating subsets of variables, the subproblem needs to be relaxed with respect to the variables that are currently not included in the subset. In most descriptions of cut-strengthening algorithms, this aspect is not much highlighted. We believe that this is mainly due to the fact that the formulations of these relaxations often follow naturally from the problem formulation, such as in Cambazard et al. (2004); Hooker (2007); Coban and Hooker (2013); Lam et al. (2020); . However, in order to make our extension, a more rigorous framework is needed. For this purpose, we introduce a partial assignment subproblem. Based on this, both standard cut strengthening and our extension to also search for feasible solutions can be described. A key component in this derivation is to make well-chosen relaxations and restrictions of this partial assignment subproblem. The proposed extension can be integrated with different cut-strengthening algorithms. We have chosen to use the one based on Depth-First Binary Search (DFBS) since it yields irreducible feasibility cuts and since it has been shown to perform well for strengthening of feasibility cuts for several types of problems .
The acceleration technique that we introduce in this paper is developed to efficiently solve our avionics scheduling problem. However, to make the generic aspects of this work easily accessible for continued research, the paper is structured with this in mind. Especially, we believe that our generic way to present how cut strengthening can be derived from a partial assignment subproblem, and also how it can be generalised into the acceleration technique that we propose, is of value for continued work. To the best of our knowledge, we are the first to integrate cut strengthening in LBBD and search for feasible solutions in such systematic way.
To evaluate our LBBD method, we use the set of publicly available avionics scheduling instances 1 introduced in . This set includes 120 instances with up to 2530 messages and 54,731 tasks to schedule. First our new method is compared to two problem-tailored methods from previous work, an exact constraint generation procedure introduced in Blikstad et al. (2018) and extended in , and a matheuristic method introduced in . Our results show that the new method outperforms the previous ones both with respect to solution time and RAM usage. Thereafter, we perform additional experiments to illustrate the impact that the acceleration strategies and other components of our method have on the computational performance. This evaluation confirms that our extension of cut strengthening to also search for feasible solutions has a significant impact on the computational performance.
This paper is structured as follows. Section 2 gives a literature review that includes acceleration strategies for LBBD based on cut strengthening and heuristically finding feasible solutions, respectively, and LBBD schemes for scheduling of hard real-time systems. Section 3 first describes -in a general context -how a search based on investigating subsets of variables to strengthen a cut can be extended into a partial assignment acceleration technique. Then, the specific integration with DFBS is described and we highlight how DFBS can be seen a special case of our acceleration technique. Section 4 describes how to apply LBBD, including known acceleration techniques, and our partial assignment acceleration technique to our avionics scheduling problem. The computational evaluations of our method are presented in Section 5. Section 6 gives concluding remarks and discusses future research directions.

Literature review
Since our acceleration technique integrates cut strengthening and the search for feasible solutions, we describe related works in these respective areas. Our new technique is applied to scheduling of an avionic system, which is a hard real-time system. To schedule real-time systems often involves making some allocation decision integrated with scheduling of tasks, which is a structure that lends itself well for LBBD. Therefore we also present related works on applying LBBD to schedule hard real-time systems.

Logic-based Benders decomposition and cut strengthening
It is well established that acceleration techniques are necessary to obtain good computational performance for classical Benders schemes (Rahmaniani et al., 2017). One of the techniques highlighted in Rahmaniani et al. (2017) is cut strengthening, which also has been successfully used to improve the computational performance of LBBD schemes (Hooker, 2019;. A common way to strengthen cuts in LBBD is to evaluate subsets of the set of variables that are included in an original cut. Each evaluation is made by solving a subproblem, and by systematically solving such subproblems, a strengthened cut can be found. Cut-strengthening algorithms that rely on solving additional subproblems have been used to improve the computational performance of LBBD schemes, and problem-specific examples can be found in Hooker (2007), Benini et al. (2008), Coban and Hooker (2013), Riedler and Raidl (2020), Lam et al. (2020), andLindh et al. (2022).
The standard subproblem in a LBBD scheme is formulated based on a complete master problem solution. A feasibility cut is found if this subproblem is infeasible and then this original cut will include all master problem variables. To evaluate a subset of the variables included in an original cut, a subproblem must be formulated with respect to this subset of master problem decisions only. To be able to conclude that a subset of the decisions will yield a feasibility cut, the remaining decisions must be handled in an exact way or in a way that gives a relaxation of the subproblem. In the literature that we have reviewed, this aspect is not much highlighted and instead the motivations for how to formulate the subproblems and how to handle evaluations of subsets of decisions have been problem specific. As part of our description in Section 3, we provide a more formal and problem-agnostic framework for how to formulate such relaxations.
Most common in previous work is that the problem formulations and the decompositions are such that each master problem decision corresponds to adding a demand for resources that need to be considered in a subproblem -and by omitting such assignment, a relaxation is directly obtained. In Hooker (2007), the master problem assigns tasks to facilities, and in the subproblem for each facility, the assigned tasks must be scheduled. In Coban and Hooker (2013), the master problem assigns tasks to segments of time, and in the subproblem for each segment of time, the tasks must be scheduled. In Riedler and Raidl (2020), the master problem assigns requests to vehicles, and in the subproblem for vehicle, a tour is constructed. Similarly, in Lindh et al. (2022), the master problem assigns tasks to work shifts and machines to the tasks, and in the subproblem, tasks are scheduled within the work shifts while respecting the machine assignments. For these applications, removing an assignment corresponds to not schedule a task or serve a request, hence creating a relaxation. A similar structure is also observed for the problems studied in Lam et al. (2020), where the hybrid branch-and-check-type LBBD solver Nutmeg (Lam et al., 2020) is applied to facility allocation and scheduling, plant location, vehicle routing with location congestion, and satellite scheduling.
In Benini et al. (2008), there is a slightly different approach to formulating the relaxation of the subproblem. Their LBBD scheme is of multi-stage type with a master problem that assigns tasks to cores, and then there are two subproblems. In the first subproblem, memory to be used for communication between tasks are assigned to communication channels given a task-to-core assignment from a master problem solution. In the second subproblem, they search for a task schedule that is feasible given the memory-to-communication channel assignment. Both subproblems can supply feasibility cuts if infeasible and the relaxations used when strengthening these cuts are not formulated by simply removing the tasks. The reason for this is that both subproblems contain tasks whose length is determined by the task-to-core and the memory-to-communication channel assignments. In the first subproblem, a relaxation is formed by giving tasks their minimum length if there is no task-to-core assignment that determines their length. To obtain a relaxation in the second subproblem, the memory requirements are ignored if there is no memory-to-communication channel. Both the type of relaxation used in Benini et al. (2008) and the relaxations described for Hooker (2007), Coban and Hooker (2013), Riedler and Raidl (2020), Lam et al. (2020), andLindh et al. (2022) above fit well within the framework to be introduced in Section 3.
When comparing cut-strengthening algorithms that involve solving additional subproblems, there is a distinction between algorithms that generate cuts that are irreducible (locally minimal) with respect to the subproblem that is solved, and those that do not. A unified description of the three algorithms greedy, deletion filter, and DFBS is presented in  along with an evaluation of their impact on the computational efficiency when used for strengthening of feasibility cuts. The algorithms deletion filter and DFBS give irreducible cuts, while greedy is an algorithm without guarantees. In general, to guarantee that the obtained cut is irreducible usually comes at the cost of solving additional subproblems. In the comparison made in , the deletion filter and DFBS gave the best computational performance in the evaluation made with over 2000 instances from three different problem formulations. This result indicates that it is worth spending time on solving additional subproblems to find irreducible cuts as it appears to contribute to the general progress of the LBBD scheme.
There is a strong connection between the strategies used to systematically search for the variables to include in a strengthened cut and algorithms used for finding an Irreducible Infeasible Subset of constraints (IIS) for an optimisation problem. For example, the deletion filter algorithm was first introduced to find an IIS for linear programs (Chinneck and Dravnieks, 1991), and DFBS has been applied to find an IIS both in the context of CPs (Junker, 2001(Junker, , 2004 and in the context of general mathematical programs (Atlihan and Schrage, 2008).
Examples of algorithms where additional subproblems are solved to evaluate subsets of variables to find stronger cuts are the following. In Hooker (2007) and Coban and Hooker (2013), a greedy strategy is used to determine which subsets of variables to evaluate and this strategy includes sorting of the variables to exploit problem structure. The cut-strengthening algorithm in Lam et al. (2020) is an application of the deletion filter for finding an IIS (Parker and Ryan, 1996). The cut-strengthening algorithms in Riedler and Raidl (2020) rely on finding several IISs for each infeasible subproblem and they present different strategies for using this information. Their strategy for finding an ISS includes a deletion filter search. In Benini et al. (2008), the authors present a greedy algorithm but they also briefly mention and implement an extended cut-strengthening algorithm that finds irreducible cuts. This extension includes embedding their greedy algorithm within an algorithm for finding an IIS for a CP model, as described in Junker (2001). The computational results indicated that the cut-strengthening algorithm that finds irreducible feasibility cuts performs better than their greedy algorithm.
There are also strategies for strengthening of LBBD cuts that are not based on systematically solving additional subproblems. In Cambazard et al. (2004), a conflict refiner called QuickXplain (Junker, 2001(Junker, , 2004) is used to produce a minimal conflict set from an infeasible CP subproblem. The minimal conflict set is then used to construct a possibly strengthened feasibility cut. In Kim and Hooker (2002), the authors briefly mention the possibility to find a minimal capacity cut to improve the convergence of the LBBD scheme for a fixed-charge network flow problem. Another strategy is to theoretically analyse a cut and extend it into a so-called analytical cut that is viable for a larger set of master problem solutions (Hooker, 2019). Examples of how to formulate such cuts are found in Hooker (2007) and Coban and Hooker (2013). In the context of combinatorial Benders decomposition, introduced in Codato and Fischetti (2006), they construct a feasibility cut from an IIS that is found using an algorithm for LPs introduced in Parker and Ryan (1996).

Heuristic search for feasible solutions within a logic-based Benders scheme
The use of heuristics to accelerate classical Benders schemes is a well-established concept (Rahmaniani et al., 2017;Raidl, 2015). It does, however, not appear to be an extensive literature on how to use heuristics to accelerate LBBD schemes, but we provide here some examples of how heuristics have been used for finding feasible solutions. In Raidl et al. (2021), a LBBD scheme for a bi-level capacitated vehicle routing problem is introduced. There, both the master problem and the subproblem are solved by variable neighbourhood search. Excellent computational results were reported for this heuristic approach, but a drawback was that the heuristically obtained cuts can remove solutions that should be feasible. To overcome this, a verification and correction procedure was introduced in Raidl et al. (2020), and this was used to find and correct cuts that are invalid. In Riedler and Raidl (2020), LBBD is applied to a dial-a-ride problem and, inspired by the results in Raidl et al. (2021), they made an attempt to solve the subproblem heuristically. However, in this case, the validation procedure required to ensure that an optimal solution is found cancelled out the gains from applying a heuristic. In Bajestani and Beck (2011) and Emeretlis et al. (2016), a LBBD scheme is introduced for an aircraft repair shop scheduling problem and a multi-core task-allocation-andscheduling problem, respectively. In both papers, a heuristic is applied to find a feasible solution to the original problem and this is used to put a bound on the objective value of the master problem.
This review does not include classical Benders schemes, but there is one approach that we would like to highlight since it inspired how we propose to extend cut-strengthening procedures with a component that tries to construct feasible solutions. In Saharidis and Ierapetritou (2010), they introduce an approach where, if the subproblem was proven to be infeasible, an auxiliary problem was solved to find a maximal feasible subset of constraints (somewhat complementary to an IIS) from the infeasible subproblem constraints. From this maximal feasible subset of constraints, a bound on the optimal objective value of the original problem is derived and used to form a cut. Our strategy is similar since we use information from the cut strengthening to find a part of the master problem solution that might be part of a feasible solution, and then we try to construct a feasible solution from that.

Logic-based Benders decomposition and hard real-time system scheduling
Below we give a survey of LBBD schemes that have been developed to schedule hard real-time systems. In He et al. (2008), LBBD is applied to a problem that includes both the assignment and scheduling of tasks in a distributed system where the processors communicate by a Time-Triggered Protocol (TTP). In the master problem, tasks are assigned to processors, and in the subproblem there is a search for a feasible schedule for the tasks and messages together with a valid bus access configuration. The master problem is solved using a Satisfiability Modulo Theories (SMT) solver while a CP solver is applied to the subproblem. This method solves instances with up to 10 processors and 50 tasks.
A TTP is also used for communication between the processors in the distributed embedded system addressed in Zhang et al. (2018). There, they introduce a LBBD scheme for a problem that contains both the assignment and scheduling of tasks. In the master problem, tasks are assigned to processors, while the subproblem is used to search for a valid bus access configuration. The master problem is solved using an SMT solver while the subproblem is solved via a geometric programming approach. Their LBBD method solves instances with up to 8 processors and 30 tasks. In the hard real-time system studied in Cambazard et al. (2004), the processors communicate via a token-ring.
Their scheduling problem contains both the assignment and scheduling of tasks and they use a LBBD method that includes the cut-strengthening algorithm described in Section 2.1. Their master problem assigns tasks to processors and a feasible task schedule is searched for in the subproblem. Both the master problem and the subproblem are solved using a CP solver and their method is used to solve instances with up to 7 processors and 40 tasks.
A heterogeneous multi-core platform is studied in Emeretlis et al. (2016) where a LBBD scheme is developed for an assignment and scheduling problem. In their master problem, tasks are assigned to cores and the subproblem is used to find a feasible task schedule. The master problem is solved using a MIP solver while a CP solver is applied to the subproblem. Their LBBD method solves instances with up to 4 heterogenous cores and 129 tasks. A different multi-core architecture, the Cell BE processor, is addressed in Benini et al. (2008). As described in Section 2.1, a multi-stage LBBD scheme is introduced for this problem where the master problem is solved by a MIP solver and both subproblems are solved by a CP solver. Their LBBD method solves instances with up to 6 cores and 29 tasks.
There are some differences between the avionics problem that we address and the problem formulations that are reviewed above. A structural difference is that we do not assign tasks to processors as this is determined by the engineers that design the system. Instead, the assignment aspect of our problem is to decide in which slots the messages are to be sent. Also, our problem is a pure feasibility problem while the others, except Cambazard et al. (2004), have an objective. The largest instance we have found in previous work included 10 processors (or cores) and 129 tasks. Our instances are magnitudes larger with 21 modules (processors), 2530 messages, 3968 communication slots, and 54,731 tasks.

A partial assignment acceleration technique
The acceleration technique to be described extends the DFBS algorithm for strengthening of feasibility cuts in LBBD (e.g. ) to include a search for feasible solutions. The key components in this extension do however not depend on the integration with DFBS, and therefore we describe the generic aspects independently to make it easier to include the extension also in other search algorithms.
A problem formulation and a basic LBBD scheme is provided in Section 3.1, and this description builds on the notation used in . The derivation of our acceleration technique is based on the formulation of a partial assignment subproblem, to be introduced in Section 3.2. This problem is however merely of theoretical interest since it is too computationally expensive to be used as a subproblem in an acceleration technique. Instead, the method relies on solving computationally cheaper relaxations and restrictions of this subproblem and Section 3.3 introduces a framework for how to formulate these. The integration with DFBS, detailed in Section 3.4, provides a systematic way to solve these relaxations and restrictions to efficiently generate strong cuts and possibly also feasible solutions to the problem.

Logic-based Benders decomposition
Given a problem on the form [P] min f (x), the decomposition is such that the binary variables x = (xi)i∈I are the master problem variables and the variables y, that belong to the domain Dy, are the subproblem variables. In line with having a LBBD structure, there are constraints C(x) that include only on the master problem variables as well as constraints C(y) that include only the subproblem variables. Furthermore, there are constraints C(x, y) that include both x and y and thereby connect the master problem decisions with the subproblem decisions. The objective function, f (x), depends only on the master problem variables so that the subproblem becomes a feasibility problem. The notation v(·) will be used to refer to the optimal objective value of an optimisation problem, e.g. the optimal value of problem P is denoted by v (P).
Below, we describe a general LBBD scheme for problem P. In iteration k of this scheme, the master problem is where B k (x) denotes the set of already generated feasibility cuts. The first iteration is k = 1 with B 1 (x) = ∅. It is common to strengthen the master problem by a subproblem relaxation component, and this can include both additional variables and constraints. In our models, this is indicated by the notation [Subproblem relaxation].
Let an optimal solution to master problem MP k be denoted byx k . In iteration k, the subproblem is formed by making the assignment x =x k in problem P, which yields If subproblem SP k has a feasible solutionȳ k , then the solution (x k ,ȳ k ) is optimal in problem P. If subproblem SP k is infeasible, then the feasibility cut cuts off the current master problem solution. In a LBBD scheme, this cut can be added to the set of feasibility cuts B k (x) to form the next set of feasibility cuts B k+1 (x). The iterations continue until a feasible solution to a subproblem is found or the master problem is proved infeasible. Adding these types of cuts is sufficient for convergence of the scheme, but might be computationally inefficient. Above, the definition of a cut b k (I) has one term for i ∈ I :x k i = 0 and one term for i ∈ I :x k i = 1. It is however common that the constraints C(x, y) are such that only the decisionsx k i = 1 imply a restriction on the y-variables (e.g. scheduling problems where the decision indicates if a job is assigned to a machine or not). In such cases it is sufficient to only consider a cut b k (Ī k ), whereĪ k = {i ∈ I :x k i = 1}, and, in the remainder of the derivation presented below, replace each occurrence of I withĪ k . In Section 4, b k (Ī k ) will be denoted by b(Ī k ) for short.
If it is known that a subproblem will be infeasible by making only a partial assignmentx k i , i ∈ L ⊂ I, a cut b k (I) can be replaced by a stronger feasibility cut b k (L) in iteration k and the LBBD scheme will still converge. This is the fundamental property that allows for acceleration techniques based on cut strengthening.

Irreducible feasibility cuts and the partial assignment subproblem
This section introduces the partial assignment subproblem that is a key component in the derivation of the acceleration technique. Since the strengths of the generated cuts are of importance, we also introduce the notion of a cut being irreducible with respect to such partial assignment subproblem.
The partial assignment subproblem is obtained by, in iteration k of the LBBD scheme, making the partial assignment xi =x k i , i ∈ L, in problem P. It is formulated as and if this problem is infeasible, the notation v PAS k (L) = ∞ is used for its objective value. In iteration k, the partial assignment subproblem PAS k (I) coincides with subproblem SP k , and PAS k (∅) coincides with problem P. For other partial assignments, the difference between SP k and PAS k (L) is that the latter includes the master problem variables xi, i ∈ I \ L. This makes the partial assignment subproblem a hybrid between the master problem and subproblem, and as such it is not attractive from a computational point of view. However, the purpose of introducing PAS k (L) is not to solve it directly and instead we will derive computationally tractable relaxations and restrictions from it. Before that, we establish some properties of the partial assignment subproblem.
The reason for introducing a hybrid between the master problem and the subproblem is that it can be solved with two different purposes in mind, either (i) to determine if the partial assignment xi = x k i , i ∈ L, is infeasible, or (ii) to complete the partial assignment xi = x k i , i ∈ L, into a feasible solution for problem P. If infeasibility is established in case (i), the feasibility cut b k (L) can be added to the master problem. In case (ii), any feasible solution to PAS k (L) will be a feasible solution to problem P. Further, in the case when x k is feasible also in SP k , an optimal solution to PAS k (L) is optimal in problem P.
The following result is of use when comparing two partial assignments.
Proof. The result follows immediately since the same objective function is used in PAS k (L1) and PAS k (L2) and since each feasible solution to PAS k (L1) is feasible also in PAS k (L2).
From this relation follows two domination criteria. First, the knowledge that a partial assignment subproblem is infeasible for a subset L1 ⊆ I can be used to deduce that the partial assignment subproblems for all subsets L2 ⊃ L1, where L2 ⊆ I, are infeasible. Second, if a partial assignment for a subset L2 ⊆ I has been completed into a feasible solution to P , it is known that the partial assignment subproblem is feasible for all subsets L1 ⊂ L2.
To be able to refer to a cut being the strongest possible, in a local sense, with respect to this partial assignment subproblem, we make the following definition.
Definition 1. Let PAS k (L), L ⊆ I, be a partial assignment subproblem in iteration k of a LBBD scheme. A feasibility cut b k (L1), L1 ⊆ I is called irreducible with respect to a partial assignment subproblem if PAS k (L1) is infeasible and Later this definition will be extended to the type of relaxation of the partial assignment subproblem that will be introduced. The definition made then will coincide with what is usually referred to as an irreducible feasibility cut in the context of cut-strengthening algorithms, e.g. .
Typically, a LBBD scheme is derived to exploit problem structure in the sense that iteratively solving the master problem and the subproblem becomes more efficient than solving problem P. In such cases, it is clear that the decomposition that separates the master problem decisions and the subproblem decisions is profitable from a computational point of view. This also means that the partial assignment subproblem, which is a hybrid that contains both types of decisions, is not likely to be viable as a subproblem in an acceleration technique. The next section introduces how to form computationally tractable relaxations and restrictions of the partial assignment subproblem to be used in the acceleration technique instead of the complete partial assignment subproblem.

Subset-consistent relaxations and restrictions of the partial assignment subproblem
We begin by recalling that the partial assignment subproblem can be solved with different purposes in mind, either to show that a partial assignment is infeasible or to complete it into a feasible solution to problem P. By making a relaxation Rel or a restriction Res of the partial assignment subproblem such that the resulting problem no longer includes the master problem decisions, the resulting problem is likely to be much easier to solve. It always holds that if a relaxation lacks a feasible solution, so does the problem from which this relaxation is derived. Furthermore, any feasible solution to a restriction of a problem is feasible also in the problem from which this restriction is derived. Therefore, the cases (i) and (ii) introduced above can be extended into: (I) A relaxation subproblem RelPAS k (L), obtained by making a relaxation Rel of PAS k (L), can be used to determine that a partial assignment xi = x k i , i ∈ L, is infeasible in PAS k (L) and to find a feasibility cut b k (L).
(II) A restriction subproblem ResPAS k (L), obtained by making a restriction Res of PAS k (L), can be used to complete a partial assignment xi = x k i , i ∈ L, into a feasible solution for problem P. (III) Due to that PAS k (L) is not solved exactly, it can hold that a partial assignment xi = x k i , i ∈ L is neither infeasible in RelPAS k (L) nor possible to complete into a feasible solution to problem P by solving ResPAS k (L).
The introduction of case (III) can be considered as the price that is paid for replacing the partial assignment subproblem by a relaxation and a restriction. Further, the definitions of Rel and Res will determine both how common case (III) becomes and how computationally challenging RelPAS k (L) and ResPAS k (L) will be. Since these relaxations and restrictions are used in the acceleration technique only, the existence of case (III) will have no impact on the convergence of the LBBD scheme since the convergence depends only on finding one feasibility cut.
One aspect that contributes to the efficiency of cut-strengthening algorithms such as DFBS is the use of domination criteria that make it possible to deduce if a subproblem in the tree search is feasible or not based on the outcome from evaluations of other subproblems. For the partial assignment subproblem, such domination criteria follow from the result in Proposition 1. To make it possible to formulate the same type of domination criteria in our acceleration technique, some care is required when defining the relaxations and restrictions. We therefore introduce a certain property that is of importance in this context. Definition 2. Let PAS k (L), L ⊆ I, be a partial assignment subproblem in iteration k of a LBBD scheme.
Note that in the literature, the relaxations used in cut strengthening for LBBD (e.g., Hooker (2007), Coban and Hooker (2013), Lombardi and Milano (2012), ) are all subset consistent even if this has not been explicitly stated. Also, for simple problem structures, most reasonable relaxations and restrictions are subset consistent, and then this definition only removes some pathological cases. However, for our application presented in Section 4, especially the restriction needs to be carefully crafted to become subset consistent.
The following result summarises the domination criteria that follow immediately from the definitions of relaxations and restrictions, both in the general sense and according to the definition of subset consistence above.
Proposition 2. Let PAS k (L), L ⊆ I, be a partial assignment subproblem in iteration k of an LBBD scheme. Let RelPAS k (L) be obtained by making a subset-consistent relaxation of PAS k (L) and let ResPAS k (L) be obtained by making a subset-consistent restriction of PAS k (L).
and all restrictions of PAS k (L2) are infeasible.
If the relaxation of the partial assignment subproblem is subset consistent, the concept of a cut being irreducible with respect to the partial assignment subproblem can be extended to this relaxation as follows.
Definition 3. Let PAS k (L), L ⊆ I, be a partial assignment subproblem in iteration k of an LBBD scheme and let RelPAS k (L) be obtained by making a subset-consistent relaxation of PAS k (L). A feasibility cut b k (L1), L1 ⊆ I is called irreducible with respect to a subset-consistent relaxation of a partial assignment subproblem if RelPAS k (L1) is infeasible and RelPAS k (L2) is feasible for all L2 ⊂ L1.
Note that a feasibility cut that is irreducible with respect to a subset-consistent relaxation RelPAS k (L1) of a partial assignment subproblem PAS k (L1) may not be irreducible with respect to PAS k (L1) itself due to the relaxation made. Note also that irreducibility is a local property and that there can be more than one cut that is irreducible.
The introduction of a partial assignment subproblem and the concepts of subset-consistent relaxations and restrictions provide a foundation for extending cut-strengthening algorithms to also include a search for feasible solutions. Next section introduces how this can be done when integrated with DFBS.

Integration with depth-first binary search
The partial assignment acceleration technique is applied in iteration k of a LBBD scheme if subproblem SP k is infeasible and a feasibility cut B k (L fc ), L fc ⊆ I, has been identified. To apply the technique, both a subset-consistent relaxation Rel and subset-consistent restriction Res of the partial assignment subproblem PAS k (L), L ⊆ I, must be known and they will be used to construct the relaxation and restriction subproblem, respectively.
We begin by outlining the search strategy in the DFBS algorithm using the notation introduced in this paper. For details we refer to the pseudo code presented in Appendix A. The output from the search is an irreducible feasibility cut defined by the set of variables L ifc ⊆ L fc . The search starts with the set L ifc being empty. The set of variables that are the current candidates for being included L ifc is denoted by T and initially T = L fc . During the search, there is also an auxiliary set O that is used to keep track of variables that are neither among the current candidates in T nor among the variables that certainly not will be part of the irreducible cut under construction; initially O = ∅.
In each major iteration of the search, the goal is to identify one new variable to include in L ifc . This is done by iteratively reducing the set T until only one variable remains and then this variable is added to L ifc . In each such minor iteration, T it is partitioned into the the subsets T1 ⊆ T and T2 = T \ T1. Then, relaxation subproblem gives the valuable information that T2 can be discarded from further search and the update T = T1 is made. If is also made. These updates conclude a minor iteration.
Each time L ifc has been extended with a new variable, the problem RelPAS k (L ifc ) is solved. If this problem is infeasible, an irreducible feasibility cut has been found and the search is terminated. If the problem is feasible, the search is continued with a new major iteration. Such major iteration is initialised with T = O and O = ∅.
To extend the DFBS algorithm with our search for feasible solutions, the following changes are made. First, the output of the search is extended with a set S of feasible solutions to problem P; initially S = ∅. Second, the following step is performed in the algorithm each time a relaxation subproblem RelPAS k (L), L ⊆ L fc , has been solved.
Hence, we use the outcome from solving the relaxation subproblem to make educated guesses about which restriction subproblems that are promising to try to solve in the search for feasible solutions. The pseudo-code for our resulting partial assignment acceleration technique is presented in Algorithm 1 and there the above introduced notation for the DFBS pseudo code is used. Note that the domination criteria of Definition 2 and Proposition 2 can be checked before constructing a subproblem to determine if its feasibility can be concluded from previous results or not.
In this paper, we suggest that the DFBS algorithm is used in the acceleration technique but in principle, any cutstrengthening algorithm that systematically evaluates subsets of variables can be used. Examples of such strategies can be found in .

Solving the avionics scheduling problem
This section introduces the avionics scheduling problem and describes the LBBD scheme implemented to solve it. A detailed problem statement has been given in previous work (Blikstad et al., 2018;, and therefore we only provide a condensed version and of it here together with a detailed description of the model formulation. Our description has been adapted to the decomposition to be made and we directly present a decomposed model comprising a master problem, a subproblem, and a description of how master problem decisions are propagated to the subproblem. A compact MIP model for the same problem is presented in . The decomposition is such that the master problem schedules the communication while the subproblem schedules the tasks. The intricacy of the model is within the connection between communication and task scheduling, which we here handle implicitly in the propagation of master problem decisions to the subproblem. Some illustrations of the scheduling problem and a part of a solution are found in Appendix D and can be viewed alongside reading this section. We provide a detailed description of how to formulate a relaxation subproblem and a restriction subproblem derived from a partial assignment subproblem for the avionics scheduling problem. Further, we present a preprocessing algorithm that is used to identify cuts by detecting inconsistencies when generating a subproblem and a strategy to find a good initial solution to the master problem. The implementation of our method is made based on the description Data: A subset-consistent relaxation Rel and a restriction Res that applied to PAS k (L), L ⊆ I, gives RelPAS k (L) and ResPAS k (L), respectively, for LBBD iteration k Data: A feasibility cut b k (L fc ) for which RelPAS k (L fc ) is infeasible Result: An irreducible feasibility cut b k (L ifc ) and a set of feasible solutions S to problem P Algorithm 1: Pseudo-code of the DFBS cut-strenghtening algorithm in Section 3 and complemented with our problem specific preprocessing and initialisation strategies. The MIP models are solved using Gurobi Optimizer (GUROBI Optimizer, 2022) and the CP models are solved using IBM ILOG CP Optimizer (Laborie et al., 2018). The commercial MIP solver Gurobi Optimizer is chosen because of its general strong performance, see e.g. the comparisons in Mittelmann (2021) on the MIPLIB2017 instances (Gleixner et al., 2021). We chose the commercial CP solver IBM ILOG CP Optimizer for solving the subproblem since it is known to be efficient for scheduling problems (Laborie et al., 2018). The constraints from IBM ILOG CP Optimizer that we use in the CP formulation are introduced in detail in Appendix B.

Problem statement
The considered avionics scheduling problem is a feasibility problem where the purpose is to find a feasible schedule of predefined length with respect to a set of constraints, or to prove that no such schedule exists. The schedule is of length P and periodic, which means it is repeated over and over again while the system is running.
Let I be the set of tasks and let M be the set of messages. Further, let N be the sets of communication slots. A solution to the problem -or a schedule -is defined by -a start time, within the time interval [0, P ], for each task i ∈ I, and -an assignment of a communication slot n ∈ N to each message m ∈ M.
Each task i ∈ I is pre-assigned to a module on which it must be scheduled without preemption for the duration of its execution requirement ei, and without overlapping any other task. For each task i ∈ I, there are sub-intervals indexed by the set Qi and in a feasible schedule, task i must be assigned to one of the sub-intervals q ∈ Qi. If a task i ∈ I is assigned to sub-interval q ∈ Qi it must start after the release time t r iq and finish before the deadline t d iq . There are two types of modules, Application Modules (AMs) and Communication Modules (CMs). Let the set of AMs be denoted by H AM and let the set of CMs be denoted by H CM . Further, let H = H AM ∪ H CM and let I h denote the set of tasks on module h ∈ H. Typically, the AMs have very few tasks, each with a long execution requirement, while the CMs have a huge number of tasks and these tasks have a short execution requirement. Tasks on an AM are repeated with period P/64, which means that it is sufficient to find a schedule for an AM for the time interval [0, P/64]. Tasks on a CM are repeated with period P . The notation used to model the periodicity is that pi denotes the period of a task i ∈ I and that the term task instance and an index k ∈ {1, . . . , P/pi} is used to refer to the k th of the P/pi instances of task i in a schedule of length P .
There are various precedence relations that the tasks need to comply with, and these are modelled using the concept of dependencies. Let D be the set of such dependencies. A dependency (i, i , l, l ) ∈ D restricts the duration between the start of an instance l ∈ {1, . . . , P/pi} of a task i ∈ I to the start of an instance l ∈ {1, . . . , P/p i } of another task i ∈ I to be within the interval given by a minimal time lag l min-dep ii ll and a maximal time lag l max-dep ii ll . An overview of the system, from a hardware perspective, is given in Figure 1. As illustrated, each AM is connected to a single CM and each CM has at least one AM connected to it. A CM together with its AMs is called a system node. The CMs are connected by a Communication Network (CN) via which they can send messages to each other. A message always has one sending CM and one or more receiving CMs. Note that peripherals can be connected to a system node via the node's CM. The scheduling of the peripherals is not part of the avionics scheduling problem, but their communication with the CM is. In this paper, we only consider problem instances with one CN and thus simplify the notation for CNs. However, the method and problem definition can be extended to problems with more than one CN. When a message m ∈ M is assigned to a slot n ∈ N it claims l msg m units of the capacity available in this slot. Each slot n ∈ N has a maximum capacity of l slot n units to be claimed by the messages assigned to the slot. To send and receive messages on the CN require the involvement of tasks on the CMs and give rise to additional constraints. In particular, to model co-allocation of messages in the same slot requires care. To describe the connection between message and task scheduling, we use the concepts message tasks and message components, and introduce constraints on these. This part of the description deviates from that in previous work and is tailored to the decomposition to be made.
For each message m ∈ M, message components of task types 1 and 2 are introduced for the CM that the message is sent from and message components of task types 3 and 4 are introduced for each CM that the message is sent to. Let the set T Hm ⊆ {1, 2, 3, 4} × H index such message components for each message m ∈ M. Also, for message m ∈ M, let I m mth include the message component of task type t on CM h, (t, h) ∈ T Hm. Each message component is associated with an execution requirement e mth and sub-intervals [t r mthq , t d mthq ], q ∈ Q mth , (t, h) ∈ T Hm, m ∈ M. There is also a set D mc that includes dependencies between message components and dependencies between tasks and message components.
When all messages have been assigned a slot, the message components cease to exist and all information from them are propagated to message tasks according to the description in Section 4.2.2. Then, for each slot n ∈ N , there  Figure 1: An overview of a system with n nodes. All nodes have the same structure and therefore their contents are only displayed for nodes 1 and n exist message tasks of task types 1 and 2 for each CM that sends a message in this slot and there exist message tasks of task type 3 and 4 for each CM that receives at least one message in this slot. Let the set T Hn ⊆ {1, 2, 3, 4} × H index such message tasks for each slot n ∈ N . Also, for slot n ∈ N , let I n nth include the message tasks of task type t on CM h, (t, h) ∈ T Hn.
The message tasks have some properties that are independent of the message components assigned to them. For the message tasks of task type 3, there is a slot-unique release time t queue-r n and deadline t queue-d n , and on each CM, these types of tasks must be scheduled in the same order as the slots they are sent in. Furthermore, the start time of message tasks of task type 2 must be exactly t send n , n ∈ N . The existence of a message task i ∈ I n nth is associated with an initialisation time e init th , t ∈ {1, 2, 3, 4}, h ∈ H, that becomes part of its execution requirement. How to derive the complete execution requirements, sub-intervals and the dependencies for message tasks based on the assignment of slots to messages is detailed in Section 4.2.2. Note that when message tasks have been created based on a complete assignment of slots to messages, the problem separates over the system nodes that hence can be independently scheduled.

Mathematical model and basic logic-based Benders decomposition scheme
Generic notation for a basic LBBD scheme was introduced in Section 3. Here, we provide a mathematical model for the avionics scheduling problem that maps directly to the notation introduced for the decomposed problem in Section 3. Briefly speaking, this means that the master problem variables, used for scheduling of communication, are denoted by x and that the subproblem variables, used for the scheduling of tasks, are denoted by y. Crucial for our decomposition is that the intricate constraints that involve both the communication and the tasks scheduling are handled in the propagation of the master problem solution to the definition of the subproblem.

Master problem
The master problem is a MIP model used to schedule the communication. To assign slots to messages, we introduce for (m, n) ∈ I, I = M × N , the binary variable xmn = 1, if slot n is assigned to message m, 0, otherwise.
In iteration k of a LBBD scheme, the solution to the master problem is denoted byx k mn , (m, n) ∈ I, and the subset I k = {(m, n) ∈ I :x k mn = 1} ⊆ I is used to refer to the current assignment of slots. The constraints on x = (xmn) (m,n)∈I are m∈M l msg m xmn ≤ l slot n , n ∈ N .
Constraints (3) ensure that each message is assigned exactly one slot and constraints (4) make sure that the maximum capacity of each slot is respected. Since the avionics scheduling problem is a feasibility problem, f (x) = 0. However, to improve the computational performance, the objective function is introduced to stabilise the search. In each iteration k, this objective minimises the number of slot changes with respect to the previous assignment of slotsĪ k−1 . It is an adaptation of one of the objective functions used in Blikstad et al. (2018) and . In the first iteration,Ī 0 is defined by a solution to the model described in Section 4.5. The structure of constraints (3) yield that a solution to the master problem in iteration k is uniquely defined by the setĪ k . For this reason, it is sufficient to force one of the variables inĪ k to change its value in order to make the current solution infeasible. This can be achieved by the (not strengthened) feasibility cut This cut can be replaced by a (possibly strengthened) feasibility cut b(L k ), whereL k ⊆Ī k is a subset of variables that define a feasibility cut in the current iteration. The feasibility cuts present in the master problem in an iteration k are given by To strengthen the master problem, we use a [Subproblem relaxation] that introduces start times of tasks also in the master problem. The constraints include both some aspects that connect the communication and task scheduling and some parts of the task scheduling. However, a majority of the tasks are not prevented from overlapping, since this would be computationally expensive. This part of the master problem model is rather detailed and not central for the main contributions of this paper, and for this reason it is presented in Appendix C.
Using the definitions above, the master problem for the avionics scheduling problem in iteration k of the LBBD scheme is xmn ∈ {0, 1}, (m, n) ∈ I.

Message tasks
When a solution to a master problem is known and it is decided in which slots to send the messages, the message tasks can be constructed from the message components. The construction of the message tasks is an important component in formulating the subproblem since it propagates information from the master problem solution to the subproblem. A master problem solution from iteration k is here only represented by the set of indicesĪ k since it is sufficient to specify which slot assignments that have been made.
Let the setMn(Ī k ) = {m ∈ M : (m, n) ∈Ī k } include the messages that are assigned to slot n ∈ N . For slot n ∈ N , a message task of task type t on CM h, (t, h) ∈ T Hn, exists if the set ∪ m∈Mn(Ī k ) I m mth is non-empty. Let T Hn(Ī k ) index the message tasks for slot n ∈ N for which this is the case. Using this notation, a message task for slot n ∈ N of task type t on CM h, (t, h) ∈T Hn(Ī k ) is constructed from the message components given by the set ∪ m∈Mn(Ī k ) I m mth and associated with the execution requirement The sub-intervals for message tasks, denoted by [t r nthq , t d nthq ], q ∈ Q nth , (t, h) ∈T Hn(Ī k ), n ∈ N , are implicitly defined by To simplify notation in the models to be presented, we introduce a mapping from each tuple (n, t, h), (t, h) ∈ T Hn(Ī k ), n ∈ N , to a single task index and let the set I mt (Ī k ) include all corresponding message tasks. By this construction, the message tasks can be referred to in the same manner as tasks in I. The quantities e nth , t r nthq , t d nthq and q ∈ Q nth introduced for message tasks indexed by (n, t, h), (t, h) ∈T Hn(Ī k ), n ∈ N , will in the following also be denoted by ei, t r iq , t d iq and q ∈ Q ih for i ∈ I mt (Ī k ). Also, we introduce the notation pi for the period of task i ∈ I mt (Ī k ). The set I mt (Ī k ) can be partitioned with respect to the CMs and the notation I mt h (Ī k ) is used to refer to the set of message tasks on CM h ∈ H CM .
To propagate information from the dependencies that involve message components, given by the set D mc , to dependencies that instead involve the message tasks, new dependencies are created where each message component is replaced by the message task it is included in. Denote this new set of dependencies by D mt (Ī k ) and note that ifĪ k represents a complete master problem solution, then all dependencies in D mc will be included in D mt (Ī k ).
In addition to the dependencies described above, the set D mt (Ī k ) also includes the following dependencies that are directly defined for the message tasks. Given an order of the slots in N , the message tasks of task type 3 on a CM h ∈ H CM , (3, h) ∈T Hn(Ī k ), must be scheduled in the same order. This is enforced by a dependency for each pair of message tasks (3, h) ∈T Hn(Ī k ) and (3, h) ∈T H n (Ī k ) such that slot n ∈ N directly precedes slot n ∈ N in this slot order. Each such dependency is with respect to the first instance of the respective tasks and they all have the minimum time lag 0 and the maximum time lag P/64. When all information from the master problem solution has been propagated to the message tasks, we apply a customised preprocessing component that further reduce the set of feasible solutions before solving the subproblem. The preprocessing component propagates requirements associated with the created message tasks, their sub-intervals, execution requirements, and dependencies, while performing consistency checks. The checks can sometimes conclude in advance that the subproblem is infeasible, but if this is not the case, the next step after the preprocessing component is to create the subproblem.

Subproblem
Given a master problem solution and information propagated to the message tasks, the subproblem is a CP model used to schedule the tasks. The start time of task i ∈ I ∪ I mt (Ī k ) is represented by the interval variable yi = start time of task i.
The domain Dy of the variables y = (yi) i∈I∪I mt (Ī k ) is defined by the constraints ForbidStart(yi, Qi(t)), i ∈ I ∪ I mt (Ī k ), where Qi(t) is a step function that, for each time point t, takes the value 1 if t ∈ ∪q∈Q i [t r iq , t d iq ] and 0 otherwise. The schedule is periodic with main period P , and from a system perspective there is no start and end of the schedule. This is reflected in the definitions of dependencies that specify precedence relations between tasks in a cyclic manner. However, since the schedule is created for the interval [0, P ], it is, for some tasks, possible to determine the order within this interval. This is done by considering the sub-intervals of the tasks and the time lags of the dependency. Let the subsets D s ⊆ D and D mt-s (Ī k ) ⊆ D mt (Ī k ) include all dependencies whose task instances have a known order within the interval [0, P ]. If for dependency (i, i , l, l ) ∈ D s , instance l of task i always need to start before instance l of task i within the interval [0, P ], the dependency is remodeled as a dependency (i , i, l , l) with l min-dep . The analogous reformulation is made also for dependencies in D mt-s (Ī k ). Further, let the subsets D u = D \ D s and D mt-u (Ī k ) = D mt (Ī k ) \ D mt-s (Ī k ) include the dependencies for which the order within the interval [0, P ] is unknown. For a dependency (i, i , l, l ) ∈ D u ∪ D mt-u (Ī k ), let the binary variable y dep ii ll indicate if instance l of task i starts before instance l of task i in the interval [0, P ]. This variable is included in the subproblem so that both options can be considered when solving the problem.
The constraints on x and y are Constraints (14) and constraints (15) ensure that all tasks on an AM and on a CM, respectively, are scheduled without overlap. For dependencies that involve tasks in the same period only, constraints (16)-(17) make sure that the precedence relations and time lags are respected. The fulfilment of the remaining dependencies is enforced by constraints (18). Using the definitions above, the subproblem for the avionics scheduling problem in iteration k of the LBBD scheme is [A-SP k ] min 0, and it can be solved independently for each system node.

Partial assignments and subproblems for the acceleration technique
This section introduces the relaxation subproblem and the restriction subproblem to be used in the acceleration technique when solving the avionics scheduling problem. These are derived as a subset-consistent relaxation and a subset-consistent restriction, respectively, of a partial assignment subproblem. A partial assignment is defined by the subset L ⊆Ī k of the assignments made in the master problem solution in iteration k of the LBBD scheme. A partial assignment subproblem, as defined by PAS k (L), is obtained by using the constraints and domains introduced above for the avionics scheduling problem together with the restriction xmn =x k mn , (m, n) ∈ L. For both the relaxation subproblem and the restriction subproblem, message tasks will be created according to the description in Section 4.2.2, but for a partial assignment only. LetL ⊆Ī k denote an assignment that will define the message tasks to be constructed. For the relaxation, message tasks are created forL = L, while for the restriction, message tasks are created for an extended setL =L = {(m, n) ∈Ī k : (m , n) ∈ L for some m ∈ M}. This extended set includes all assignments for a slot that has at least one assignment in L. In addition to that, the main difference between the relaxation and the restriction is how the remaining assignments, given by the setĪ k \L, are handled. Before turning to the details of the respective subproblems, we begin with a joint description of how to construct the message tasks given a setL.
Analogously to the definition forĪ k , we let the setMn(L) = {m ∈ M : (m, n) ∈L} include the messages that are assigned to slot n ∈ N in the partial assignment given by the setL. For slot n ∈ N , a message task of task type t on CM h, (t, h) ∈ T Hn, is created if the set ∪ m∈Mn(L) I m mth is non-empty. Following the derivation in Section 4.2.2, an execution requirement ei, sub-intervals [t r iq , t d iq ], q ∈ Q ih , and a period pi are introduced for i ∈ I mt (L), where I mt (L) is the set of created message tasks. Further, the set I mt h (L) includes the created message tasks on CM h ∈ H CM . The dependencies in the set D mt (L) are created from the dependencies in the set D mc according to the description in Section 4.2.2. If there are dependencies in D mc that involve message components that have not been included in a message task, these are left in this set and not transferred to D mt (L).

Relaxation subproblem
The relaxation of the partial assignment subproblem is made so that the resulting problem has the same structure as the LBBD subproblem. When the message tasks and dependencies forL = L have been created according to the description above, the main component of the relaxation is to discard the restrictions on the remaining task components and their dependencies. The requirement that message tasks of task type 3 need be scheduled in the same order as their slots is here only applicable for the message tasks that have been created. For these tasks, the set D mt (L) is extended with dependencies as described in Section 4.2.2. Following the derivation in Section 4.2.3, we let the subsets D s ⊆ D and D mt-s (L) ⊆ D mt (L) include all dependencies that have a known order within the interval [0, P ]. Dependencies for which the order within the interval [0, P ] is not known are included in the subsets D u = D \ D s and D mt-u (L) = D mt (L) \ D mt-s (L). Further, for dependency (i, i , l, l ) ∈ D u ∪ D mt-u (L), the binary variable y dep ii ll indicates if instance l of task i starts before instance l of task i in the interval [0, P ] or not. The introduced message tasks are constructed to directly correspond to the assignments made by the constraints xmn =x k mn , (m, n) ∈ L in PAS k (L). To make the partial assignment given by L and discard the assignments not included in L corresponds to relaxing the constraints C(x) by changing the equalities in constraints (3) into ≤inequalities. By construction, this relaxed version of the constraints C(x) and the domain requirements for x become trivially fulfilled and therefore, both C(x) and the domain for x are omitted in the relaxation subproblem. The remaining constraints C((x k mn ) (m,n)∈L , y) & C(y), together with the domain for y, give a relaxation subproblem for the subset L in iteration k of a LBBD scheme. It is formulated as and it can be solved independently for each system node.
Proposition 3. The problem A-RelPAS k (L) is a subset-consistent relaxation of the partial assignment subproblem for the avionics scheduling problem.
Proof. The relaxation is constructed so that there is a direct correspondence between the created message tasks and the restriction xmn =x k mn , (m, n) ∈ L in PAS k (L). Further, the remaining message components are discarded in a way that only relaxes the problem. This means that, given two partial assignments L1 and L2 such that L1 ⊆ L2 ⊆ I hold, all restrictions imposed by the assignments in L1 will be imposed also in L2 so that any solution to A-RelPAS k (L2) will be feasible also in A-RelPAS k (L1). Therefore v A-RelPAS k (L1) ≤ v A-RelPAS k (L2) holds and the relaxation is subset consistent.

Restriction subproblem
The restriction of the partial assignment subproblem is made so that the resulting problem has a structure that is similar to the LBBD subproblem, but with some additional types of constraints. The restriction is defined by creating message tasks in two steps. First, message tasks and the dependencies for the extended setL (that includes all messages that were assigned to a slot where at least one of the assignments is included in L) are created according to the description for partial assignments above. The use of the extended setL yields a restriction of PAS k (L) as it means that the condition xmn =x k mn , (m, n) ∈ L in PAS k (L) is replaced by the stronger condition xmn =x k mn , (m, n) ∈L. Thereafter, message tasks for the remaining assignments, given by the setĪ k \L, are created. The construction of this second set of message tasks follows the same structure as described above forL, but with some differences to be pointed out. Especially, when a set or parameter is defined differently than to before, this is marked with a· in addition to the original parameter notation.
The set of messages that are assigned to slot n ∈ N in the partial assignment given by the setĪ k \L is denoted byMn(Ī k \L) and we note that ∪n∈N (Mn(L) ∪Mn(Ī k \L)) = M holds. For the assignmentsĪ k \L, the messages assigned to the same slot in the solution to the master problem will be restricted to be together in a slot, but they are allowed to change slot -as long as they do it together and without using the same slot as any other messages. This corresponds to adding the restrictions xmn = x m n for m, m ∈Mn(Ī k \L), n ∈ N , and xmn + x m n ≤ 1, m ∈Mn(Ī k \L), m ∈ M \Mn(Ī k \L), n ∈ N . When adding these constraints to PAS k (L), they will impose a restriction on the problem. Note, however, that an important aspect of the construction is that this restriction is weaker than that made for the assignment given byL.
The construction of the message tasks for the assignmentĪ k \L is done to directly correspond to the weaker type of restriction introduced above. For slot n ∈ N , a message task of task type t on CM h, (t, h) ∈ T Hn, is created if the set ∪ m∈Mn(Ī k \L) I m mth is non-empty. Then, the setT Hn(Ī k \L) is used to index the message tasks for slot n ∈ N . In line with the description in Section 4.2.2, a message task for slot n ∈ N of task type t on CM h, (t, h) ∈T Hn(Ī k \L) is constructed from the message components given by the set ∪ m∈Mn(Ī k \L) I m mth and associated with an execution requirement.
Since message tasks indexed byT Hn(Ī k \L), n ∈ N , are associated with messages that are allowed to change slot, their sub-intervals are defined differently than those forL. For n ∈ N , letNn be the set of slots that messages m ∈Mn(Ī k \L) can be assigned to. The sub-intervals [t r nthq ,t d nthq ], q ∈ Q nth , for message tasks indexed by (t, h) ∈T Hn(Ī k \L), n ∈ N , are implicitly defined by As in Section 4.2.2, we introduce a mapping from each tuple (n, t, h), (t, h) ∈T Hn(Ī k ), n ∈ N , to a single task index and let the setÎ mt (Ī k \L) include all corresponding message tasks. Analogously, we define an execution requirement ei, sub-intervals [t r iq ,t d iq ], q ∈ Q ih , and a period pi for i ∈Î mt (Ī k \L), andÎ mt h (Ī k \L) for h ∈ H CM . Note further that I mt h (L) ∪Î mt (Ī k \L) = I mt h (Ī k ) holds. After the dependencies in the set D mt (L) were created, some dependencies remained in the set D mc . With the second set of message tasks, the remaining dependencies can be created and added to the set D mt (L); thereby the complete set of dependencies for message tasks becomes D mt (L ∪ (Ī k \L)) = D mt (Ī k ). As in Section 4.2.3, the subsets are introduced, and so is the binary variable y dep ii ll , (i, i , l, l ) ∈ D u ∪ D mt-u (Ī k ). The requirement that message tasks of task type 3 on a CM h, (3, h) ∈ T Hn(Ī k ), must be scheduled in the same order as their slots was in the previous models handled by dependencies. In the restriction subproblem, this is instead enforced in an equivalent manner by introducing and constraining two sequence variables per CM. Here, the notations t = 2 and t = 3 will be used for short to refer to tasks of type 2 and 3, respectively, and we introduce the set I msg (I mt h (Ī k ) : t = 3)) that includes the message tasks of task type 2 that sends the messages received by the message tasks of task type 3 on CM h ∈ H CM . The sequence variables are, for each CM h ∈ H CM , S(yi|i ∈ I mt h (Ī k ) : t = 3) and S(yi|i ∈ I msg (I mt h (Ī k ) : t = 3)), using the notation introduced in Appendix B. A consistent order between the message tasks of type 2 and type 3 is then, for each CM that receives messages, enforced by a separate Disjunctive constraint for each sequence variable and a SameSequence constraint between the sequence variables.
The message tasks for the assignmentsL andĪ k \L, respectively, are constructed to directly correspond to the assignments made by the constraints xmn =x k mn , (m, n) ∈L, and xmn = x m n , m, m ∈Mn(Ī k \L), n ∈ N . In addition, the constraints xmn + x m n ≤ 1, m ∈Mn(Ī k \L), m ∈ M \Mn(Ī k \L), n ∈ N make sure that the messages that are not assigned to be in the same slot will use different slots (this is below equivalently formulated as a Disjunctive-constraint on message tasks of task type 2). To include these three constraints in PAS k (L) corresponds to making a restriction of PAS k (L) that at the same time makes the conditions xmn =x k mn , (m, n) ∈ L, the constraints C(x) and the domain for x redundant to include in PAS k (L). The remainder of this restriction of PAS k (L) then only includes the constraints C(x k , y) and C(y), together with the domain for y and these yield a restriction subproblem for the subset L in iteration k of a LBBD scheme. It is formulated as Disjunctive((yi|i ∈ I mt (Ī k ) : t = 2), (ei|i ∈ I mt (Ī k ) : t = 2)), The sub-intervals are considered in the definition of the step functionQi(t) that, for each time point t, takes the value , and 0 otherwise. Proposition 4. The problem A-ResPAS k (L) is a subset-consistent restriction of the partial assignment subproblem for the avionics scheduling problem.
Proof. For both types of message tasks introduced, a restriction of the partial assignment subproblem is made. For the assignmentL, this restriction is stronger than that made for the assignmentĪ k \L. This means that, given two partial assignments L1 and L2 such that L1 ⊆ L2 ⊆ I hold, any solution to A-ResPAS k (L1) will be feasible also in A-ResPAS k (L2). Therefore the relation v A-ResPAS k (L1) ≤ v A-ResPAS k (L2) holds and the restriction is subset consistent.

Preprocessing cuts
We have included two greedy problem-specific strategies to find, typically strong, cuts before attempting to solve the subproblem and applying the acceleration technique. As previously described, the subproblem is constructed by propagating information from the master problem solution to the message tasks. Thereafter, we apply customised preprocessing to reduce the set of feasible solutions in the subproblem. The preprocessing component propagates information associated with the created message tasks, such as sub-intervals, execution requirements, and dependencies, while performing consistency checks. If an inconsistency is detected, a set of involved tasks and message tasks is identified. As detailed below, this information is used in two strategies to find subsets of master problem variables that either might form feasibility cuts or can take their current values in a feasible solution. By solving a relaxation subproblem it is determined if a subset yields a cut and thereafter, a restriction subproblem is solved as in the acceleration technique described in Section 3.4. If the relaxation subproblem was feasible, the same set of variables is used to define the restriction subproblem, and otherwise the complement of this subset is used. Since we are interested in finding master problem variables to include in a cut, the strategies consider the message components rather than the message tasks they are included in, as the former correspond directly to the messages.
The first strategy uses a graph to identify promising master problem variables. This graph has a node for each task and each message component. Two nodes are connected by an edge if there is a dependency between the tasks or the message components that the nodes represent, or if these tasks or message components are direct neighbours in the master problem solution (i.e. no other tasks or message component has a start time between their start times). A subset of master problem variables is constructed for each step δ = 0, . . ., below, where a master problem variable is included in a subset if at least one of its corresponding message components are identified to be of interest. For δ = 0, only the message components that are directly involved in the given inconsistency are considered. Then, for the remaining steps δ = 1, . . ., all message components that can be reached by a path of at most δ edges from a node that is part of the inconsistency are considered. Thereby, the subset is extended for each step. The procedure stops when a feasibility cut or a feasible solution is found, or when all master problem variables are included in the subset.
The second strategy evaluates a single subset as follows. For each task and message task associated with the inconsistency, one or, in case of a tie, more message components of type 2 that are the closest neighbours are identified, and the corresponding master problem variables are included in the subset.

Creating an initial solution
Since our master problem has an objective that minimises the number of slot changes compared to the assignment in a previous iteration, it is beneficial to initialise our LBBD scheme with a high-quality solution. This is done by solving a subproblem that includes the message components instead of message tasks, and where the assignment of slots to messages is determined by the subintervals assigned to message components of type 2.
A particular property of the message components of type 2 in the instances we consider is that they have zero-valued execution requirements as their corresponding message tasks have fixed execution requirements. As an approximation when creating an initial solution, we assume that at most 5 messages can be co-allocated in a slot by changing the execution requirement of message components of type 2 into e m2h = e init th /5, (t, h) ∈ T Hm, m ∈ M : t = 2.
The model is constructed in line with the other subproblems but includes message components instead of message tasks. This difference is handled as follows. Analogous to Section 4.2.2, introduce a mapping from each tuple (m, t, h), (t, h) ∈ T Hm, m ∈ M, to a single task index and let the set I mc include all corresponding message components. The quantities e mth , t r mthq , t d mthq and q ∈ Q mth introduced for message component indexed by (m, t, h), (t, h) ∈ T Hm, m ∈ M, will in the following also be denoted by ei, t r iq , t d iq and q ∈ Q ih for i ∈ I mc . Introduce the notation pi for the period of task i ∈ I mc . Also, let the notation I mc h refer to the set of message components on module h ∈ H. The start time of task i ∈ I ∪ I mc is represented by the interval variable yi. Each task i ∈ I ∪ I mc is assigned a sub-interval by a ForbidStart-constraint, using the step function Qi(t) that, for each time point t, takes the value 1 if t ∈ ∪q∈Q i [t r iq , t d iq ] and 0 otherwise. Let the subset D mc-s ⊆ D mc include dependencies for which the order within the interval [0, P ] is known. Also, let subset D mc-u = D mc \ D mc-s include the dependencies for which the order within the interval [0, P ] is not known. For a dependency (i, i , l, l ) ∈ D u ∪ D mc-u , let the binary variable y dep ii ll indicate if instance l of task i starts before instance l of task i in the interval [0, P ] or not. The model used to create an initial solution then becomes and it includes the same types of constraints as the subproblem and the relaxation subproblem.

Computational results
To evaluate the efficiency of our LBBD method, we used the publicly available instances for the avionics scheduling problem that were introduced in . The instances, the computational environment, and the specific settings of the LBBD method are described in Section 5.1. In Section 5.2, the LBBD method is compared with two previously developed methods for the avionics scheduling problem. A deeper analysis of the characteristics of the partial acceleration technique and the obtained cuts is given in Section 5.3. In the final two sections, we present results from additional experiments that illustrate the impact that the partial assignment acceleration technique and the [Subproblem relaxation] component have on the computational performance.

Benchmark instances and computational environment
The computational evaluations have been performed on instance categories A-D introduced in . The instances are publicly available 2 and were developed in collaboration with Saab to be industrially relevant for the development of future avionic systems. Categories A-D contain instances of increasing difficulty and the largest instance has 20 modules, 2530 messages, and 54,731 tasks. The average number of tasks, dependencies, messages, AMs, and CMs in the instance categories are given in Table 1.
The LBBD method has been implemented using Python 3.7. The MIP models are solved using Gurobi Optimizer version 9.0 and the CP models are solved using IBM ILOG CP Optimizer version 12.10. All tests are carried out on a computer with two Intel Xeon Gold 6130 Processors (16 cores, 2.1 GHz) with 96 GB RAM for the LBBD method and 384 GB RAM for the other methods.
In the LBBD method, the master problem is solved to optimality without any time-limit. The LBBD subproblem is, for each node in the avionic system, given 20 minutes, while the relaxation subproblems and the restriction subproblems are given 5 minutes per node. If our LBBD method cannot solve the LBBD subproblem within the time-limit, we report a time-out error. If a relaxation subproblem is not solved within the time-limit, the result is treated as being feasible with respect to the cut strengthening, but of course, it is not treated as such when checking domination criteria for future relaxation subproblems. If a restriction subproblem is not solved within the time-limit, nothing is done, and again, this result is not used in any domination criteria. We have observed that if a LBBD subproblem or a relaxation subproblem is not solved within its time-limit, increasing the time-limit, even to hours, does not usually help. The partial assignment acceleration technique and DFBS cut strengthening are implemented such that when a subset of indices is split into two subsets, this is done by randomly dividing the set into two subsets of equal size.
One -somewhat surprising -finding during the computational study was the sometimes huge differences in solution times between very similar instances of the subproblems. As instances with such properties might be of interest for further studies and solver benchmarking, we made a separate report (Karlsson and Rönnberg, 2022) on this topic. There, we introduce multiprocessor scheduling instances 3 , with a pure structure of only including multiple time windows and time lags, that reproduce these computational challenges in a more generic setting.

Computational comparison with previous approaches
To evaluate the performance of our LBBD method, we have chosen to compare it against two methods previously developed for the avionics scheduling problem. In previous work, we have also tried to solve the problem by directly applying either a MIP or a CP solver, but this is not a viable option for the instances considered in this paper. The first method in our comparison is an exact MIP-based constraint generation approach that was introduced in Blikstad et al. (2018) and then improved in . In the comparison, we use the improved version which is also an exact method. The master problem of the constraint generation procedure finds an assignment of sub-intervals to tasks. A feasible schedule is then searched for in a subproblem where each task must be performed within the sub-interval it was assigned to in the master problem solution. If no feasible schedule is found, constraints are added to the master problem and the subproblem. The second method is a MIP-based matheuristic introduced in . The matheuristic extends the constraint generation procedure by solving the master problem with a MIP-based adaptive large neighbourhood search. Below, the constraint generation procedure and the matheuristic are referred to as MIP-CG and MIP-matheuristic, respectively. In the evaluation, we have used the same settings for MIP-CG and MIP-matheuristic as in , but with an update to Python 3.7 and Gurobi 9.0. Note that MIP-CG and MIP-matheuristic were given access to computers with 384 GB RAM since the methods were developed with this type of RAM availability in mind. In comparison, the LBBD method was given access to computers with 96 GB RAM.
In the computational evaluation, we compare the LBBD method, the MIP-CG method, and the MIP-matheuristic method for the instances in Categories A-D. The metric of practical interest is how long it takes to find a feasible solution or conclude that none exists. Therefore, we recorded -for each instance and each method -how much time that was needed to find a feasible solution (or determine infeasibility), if this was done within a time limit of 24 hours. The result is illustrated in Figure 2 that shows the number of solved instances after a given time.
For the smallest instance category, Category A, all 30 instances were solved within 2 hours by all methods. For Category B, the LBBD method performed best and solved all 30 instances within 1 hour while MIP-CG and MIP-matheuristic solved 25 and 28 instances, respectively, within 24 hours. For Category C, the LBBD method solved all 30 instances within 5 hours. This can be compared to the MIP-CG and the MIP-matheuristic methods that solved 16 and 26 instances, respectively, within 24 hours. For the most challenging category, Category D, the LBBD method solved 28 out of 30 instances within 24 hours, while MIP-CG and MIP-matheuristic solved 1 and 19 instances, respectively, within 24 hours. It should also be noted that if the MIP-CG and the MIP-matheuristic methods get 72 hours per instance, they solve 5 and 28 instances, respectively, for Category D. Across all the 120 instances, no time-out error was reported for the LBBD method.
To summarise, the LBBD method solves more instances within the time limit while relying on less RAM than the other methods, regardless of instance category. For all but the smallest instances, the solution times are also much shorter. There are a few reasons, we believe, for these results. The first reason is that the LBBD method often finds a solution in its first subproblem, without any feedback. For Categories A-D, the number of instances that are solved without any feedback for the LBBD scheme are 25, 12, 6, and 6, respectively. The second reason is that the LBBD method successfully exploit the task-scheduling structure of the avionics scheduling problem by using a subproblem that can be efficiently solved with IBM ILOG CP Optimizer although being very large. This made it possible to formulate a master problem in the LBBD method where the tasks do not need to be assigned to small sub-intervals as in MIP-CG and MIP-matheuristic and thereby the master problem became much easier to solve. Since the master problem is the computational bottleneck for MIP-CG and MIP-matheuristic, this plays a significant role.

Detailed results for the partial assignment acceleration technique
To characterise the behaviour of the partial assignment acceleration technique and the obtained cuts, we compiled data from the experiments with the LBBD method in the previous section. Table 2 contains, for each instance category, the average number of feasibility cuts added to the master problem, the average size of the added feasibility cuts, and the average number of solved relaxation subproblems. Only data from instances that were solved within 24 hours is included in these averages. Table 3 contains, for each instance category, the number of instances solved by an ordinary LBBD subproblem, by a restriction subproblem constructed after an infeasible relaxation subproblem, by a restriction subproblem constructed after a feasible relaxation subproblem, and by a restriction subproblem constructed after a time-out relaxation subproblem.
The average number of feasibility cuts added to the master problem in order to solve an instance was small for all categories. In Category A, no feasibility cuts were needed at all. For Categories B-D, the average number of feasibility cuts were 0.1, 2.0, and 2.0, respectively. Especially interesting is that the obtained feasibility cuts were very small compared to the original cut. For the solved instances in Categories B-D the average size was 2.8, 1.5, and 26.3, respectively. These figures are to be compared to the size of the original cuts for these instances, which are 447, 908, and 1923, for Categories B-D, respectively. The average size of an added feasibility cut for the instances in Category D is larger than for Category B and C, but it was primarily due to a single LBBD iteration that generated a feasibility cut of size 1339 due to time-outs in the relaxation subproblems. Without this feasibility cut, the average size of an added feasibility cut for the instances that were solved in Category D was 2.5. The last column in Table 2 shows that not that many relaxation subproblems need to be solved in order to find the strengthened cuts. For Categories A-D, the average number of relaxation subproblems were 0.2, 1.6, 11.8, and 29.4, respectively. Table 3 shows in which of the components of the LBBD method that the solution to an instance was found. For Category A, the solutions to 26 out of 30 instances were found by solving a LBBD subproblem and only for 4 instances, the solution was found by solving a restriction subproblem. This can be compared to Category D, for which the solutions to 7 out of 28 instances were found by solving a LBBD subproblem and the solutions to 21 out of 28 instances were found by solving a restriction subproblem. For Category B, the solutions to 24 out of 30 instances were found by solving a LBBD subproblem and the solutions to 6 instances were found by solving a restriction subproblem. For Category C, the solutions to 15 out of 30 instances were found by solving a LBBD subproblem and the solutions to 15 instances were found by solving a restriction subproblem.
For the instances that were solved by a restriction subproblem, we could not discern any pattern with respect to how and when this was formulated. Rather, solutions were found by solving restriction subproblems constructed after both infeasible and infeasible relaxation subproblems. However, at least one instance per category was solved by a restriction subproblem constructed after a relaxation subproblem that timed out.

Impact of the different components of the partial assignment acceleration technique
To investigate the impact that the different components of the partial assignment acceleration technique and the preprocessing cuts have on the computational performance of the LBBD method, we have performed additional experiments with and without some of these components. The different variants are denoted as follows. LBBD\{restr} is the LBBD method with the restriction subproblem removed; LBBD\{precut} is the LBBD method with the preprocessing cuts removed; LBBD\{restr,precut} is the LBBD method with both the restriction subproblem and the preprocessing cuts removed; LBBD\{restr,precut,DFBS} is the LBBD method with all types of cut strengthening removed. The pseudo-code for the partial assignment acceleration technique without the restriction subproblem, i.e. DFBS cut strengthening, is given in Appendix A. In these tests we used the instances in Categories C and D and the time-out was 24 hours. The number of solved instances for each variant after a given time is illustrated in Figure 3.
For the complete LBBD method, 30 and 28 instances of Categories C and D, respectively, were solved within 24 hours. The corresponding number of solved instances for LBBD\{restr} was 27 and 19 for Categories C and D, respectively. For LBBD\{precut}, 29 and 27 instances of Categories C and D, respectively, were solved within 24 hours. These result were better than for LBBD\{restr}, but still worse than for the complete LBBD method. For LBBD\{restr,precut}, the number of solved instances in Categories C and D was the same as LBBD\{restr}. The most drastic reduction in performance was observed when removing all types of cut strengthening. Within 24 hours, LBBD\{restr,precut,DFBS} could only solve 17 and 8 instances of Categories C and D, respectively.
The results show that all the components contribute to the computational performance of the complete LBBD method. They also show, especially for the largest instances, that our approach to extend cut strengthening with a component that tries to construct feasible solutions has a significant impact on the computational performance.

The impact of the initial solution and the subproblem relaxation component
This section gives an evaluation of the impact that our initial solution and [Subproblem relaxation] components have on the computational performance. To evaluate the former, we made changes to the initial iteration in two ways and then the experiments were made both with and without the subproblem relaxation. In the first variant, which is denoted LBBDrand with the [Subproblem relaxation] component and LBBDrand\{sr} without it, the initial solution was a random assignment of messages to slots, and then the search was stabilised with respect to this solution. In the second variant, which is denoted LBBDnofirst with the [Subproblem relaxation] component and LBBDnofirst\{sr} without it, the objective function of the master problem was omitted in the first iteration and no initial solution was used. In this case, the first master problem solution becomes the first feasible solution that Gurobi Optimizer finds for the master problem. We also tested the complete LBBD method without a subproblem relaxation, and this we denote by LBBD\{sr}. To provide start times for tasks and message components in the master problem solution for the preprocessing cuts even without a subproblem relaxation, the start time variables were included in the master problem together with constraints (C.8). The experiments were made for the instances in Categories C and D and the time-out was 24 hours. The number of solved instances after a given time are illustrated in Figure 4. The most striking result is that the computational performance for the complete LBBD method is very similar to that for LBBD\{sr} and LBBDrand. Within 24 hours, 30, 30, and 28 instances of Category C were solved, respectively, and the corresponding number of instances of Category D are 28, 29, and 28. The best results are hence obtained for the complete LBBD method without a subproblem relaxation. Important to note, however, is that if a random initial solution is used when the [Subproblem relaxation] component is omitted, then the results are drastically worse. For LBBDrand\{sr}, 17 and 11 instances of Categories C and D, respectively, were solved within 24 hours. This clearly indicates that replacing a random assignment with the assignment created from our initial solution component and including the [Subproblem relaxation] component do have an impact on the computational performance, but they appear to play a similar role and one of the additions can therefore be omitted.
The results of using the first solution found by Gurobi Optimizer are also interesting. For LBBDnofirst, 25 and 22 instances of Categories C and D, respectively, were solved within 24 hours. For LBBDnofirst\{sr}, 19 and 7 instances of Categories C and D, respectively, were solved within 24 hours. These results are not as good as when the complete LBBD method is used and it should be noted that they are also worse than if a random assignment was used to stabilise against.

Concluding remarks
This paper introduces a method based on LBBD for solving a large-scale and industrially relevant avionics scheduling problem. This problem can be described as a rich multiprocessor scheduling problem that also includes the scheduling of a communication network. The decomposition is such that the master problem is of assignment type and the subproblem is a feasibility problem of scheduling type. The master problem is solved by the MIP-solver Gurobi Optimizer and the subproblem is solved by the CP-solver IBM ILOG CP Optimizer. The method outperforms previous exact and matheuristic methods for this problem, both with respect to solution times and RAM usage. As seen in the computational results, our new acceleration technique is an important component to achieve this.
The new acceleration technique is obtained by extending DFBS cut strengthening of feasibility cuts for LBBD with a heuristic search for feasible solutions. Our search uses information from the cut strengthening by selecting subsets of variables that have not been chosen to be part of the strengthened cut. A restriction subproblem is formed by making a so-called subset-consistent restriction of a partial assignment subproblem where these variables are assigned the values they had in the master problem solution. If a feasible solution to the restriction subproblem is found, then this solution is feasible also in the original problem. Since our extension can have the potential to also be useful for other applications and in other acceleration techniques, we have described it in a generic way. This description includes the introduction of a partial assignment subproblem, to which a subset-consistent restriction is applied to form the restriction subproblem. In the literature, the descriptions of how to form the subproblems in a cut-strengthening algorithm are problem specific. By introducing the partial assignment subproblem, and how to make subset-consistent relaxations of it to obtain a relaxation subproblem, we also contribute to a more structured and general description of how to form such subproblems.
There are three key observations that we believe contribute to explain the efficiency of our acceleration technique when included in our LBBD scheme and applied to the avionics scheduling problem. Firstly, the non-strengthened feasibility cuts are very large compared to the irreducible feasibility cuts obtained from the DFBS cut strengthening. Secondly, the problem structure is such that it is possible to form a subset-consistent relaxation and a subset-consistent restriction that are computationally profitable. By this we mean that they carry enough relevant information and are strong enough to be meaningful to solve while they have a structure that allows them to be solved quickly. Lastly, the addressed problem is a feasibility problem and this means that any feasible solution found when solving the restriction subproblem will do. Together, these three properties make it possible for the acceleration technique to generate high-quality information and feedback in a reasonable amount of time.
A possible future research direction is to apply the acceleration technique suggested in this paper to other LBBD schemes. A good starting point can be problems that only include feasibility cuts, such as the ones in  and Lam et al. (2020), and in particular problems that are decomposed to get an assignmenttype master problem and a scheduling-type subproblem. A challenge when generalising the technique is to derive a computationally profitable restriction subproblem that gets a simple structure without omitting too much of the feasible space. Another interesting research direction would be to apply this type of acceleration technique in a LBBD method that includes optimality cuts. In Hooker (2007) and Coban and Hooker (2013), for example, optimality cuts are strengthened in a way that is similar to the cut-strengthening algorithm used in this paper and therefore there is potential to include our acceleration technique in their type of scheme. Finally, we note that our strategy for choosing when to apply the search for feasible solutions is rather simple, and it might be worth to further investigate if a more elaborate strategy can improve the computational performance.
As part of strengthening the master problem, we ensure that message components of the same type do not overlap each other and that the order between message components of type 2 and type 3 are consistent. To accomplish this, we keep track of the order the messages are sent in a major frame. The following variables assist with these aspects. For m , m ∈ M : m < m , let the binary variable w S mm , be equal to 1 if message m is placed before message m or equal to 0 if message m is placed before message m. Also, for m , m ∈ M : m < m , let the binary variable w mm indicate if message m is placed before message m in a slot. Let   To provide an illustration of the structure of our problem instances and solutions, we present an example of a so-called communication chain and provide a part of a feasible schedule. Because of the size and complexity of the problem instances, we cannot present a full instance nor a full schedule in the paper. However, further details about the instances and how they are generated can be found at https://gitlab.liu.se/eliro15/avionics_inst and in .
A majority of the tasks in a problem instance originate from passing data between different parts of the system. A sequence of tasks that handle a specific set of data is referred to as a communication chain. These chains are designed to make the schedule comply with the system requirements dictated by communication protocols and design decisions made by the engineers. Most of these chains handle communication between software processes at different AMs, but there are also similar chains for the communication between a software process at an AM and a peripheral connected to a CM.
In essence, passing data between two software processes at different AMs via the CN requires that 11 tasks on 4 different modules are performed in a specific order, enforced by dependencies between the tasks. One of these 11 tasks is responsible for sending the CN message in a CN slot. For our illustration, we introduce the two communication chains A and B along with their tasks, messages and dependencies. Communication chain A includes task A1 on AM1, tasks A2-A5 on CM1, message A on the CN, tasks A6-A10 on CM2 and taskA11 on AM2. Similarly, communication chain B includes task B1 on AM1, tasks B2-B5 on CM1, message B on the CN, tasks B6-B10 on CM2 and finally taskB11 on AM2. In addition to the dependencies within a chain, there is also a requirement that the tasks that deques the data from the CN are scheduled in the same order as their messages were sent in.
The two communication chains A and B are illustrated in Figures D.5 and D.6. In these figures, the illustrated size of a task is not proportional to its execution requirement. In Figure D.5, the two communication chains send data in different CN slots and there is no interaction between their tasks except that they cannot overlap and data must be dequeued in the order it is sent. Since the message for communication chain A is sent before that of chain B, task A6 has to be scheduled before task B6, but except from that, there is no order enforced between tasks from different chains. In Figure D.6, the messages of the two communication chains are sent in the same slot, referred to as co-allocation of messages. This means that some pairs of their tasks must be merged and scheduled together, with a total execution requirement that is shorter than if they were not merged. In Figure D.6, co-allocation of messages A and B forces a merge of tasks A4 and B4, tasks A5 and B5, tasks A6 and B6, and tasks A7 and B7.
Our illustrations above contain only 22 tasks while, for example, in our instance set D (with the largest instances) the average number of tasks is 41,655, making them and their solutions difficult to illustrate. In Figure D.7, we instead provide 1/32 of a schedule for the rather small instance B21, and this part of the schedule contains a total of 403 tasks. In this illustration, the lengths of the tasks are proportional to their execution requirements, but the dependencies between them are not illustrated.