Partitioned scheduling of multimode multiprocessor
realtime systems with temporal isolation
Abstract
We consider the partitioned scheduling problem of multimode realtime systems upon identical multiprocessor platforms. During the execution of a multimode system, the system can change from one mode to another such that the current task set is replaced with a new one. In this paper, we consider a synchronous transition protocol in order to take into account modeindependent tasks, i.e., tasks of which the execution pattern must not be jeopardized by the mode changes. We propose two methods for handling mode changes in partitioned scheduling. The first method is offline/optimal and computes a static allocation of tasks schedulable and respecting both tasks and transition deadlines (if any). The second approach is subject to a sufficient condition in order to ensure online First Fit based allocation to satisfy the timing constraints.
1 . Introduction
Hard realtime systems require both functionally correct executions and results that are produced on time. Currently, numerous techniques exist that enable engineers to design realtime systems while guaranteeing that all their temporal requirements are met. These techniques generally model each functionality of the system by a recurrent task, characterized by a computing requirement and an activation rate. Commonly, realtime systems are modeled as a set of such tasks. However, some applications exhibit multiple behaviors issued from several operating modes (e.g., an initialization mode, an emergency mode, a fault recovery mode, etc.), where each mode is characterized by its own set of functionalities, i.e., its set of tasks. During the execution of such multimode realtime systems, switching from the current mode (called the oldmode) to another one (the newmode hereafter) requires to substitute the current executing task set with the set of tasks of the newmode. There are tasks however — called modeindependent tasks in the literature — which should execute in every mode and such that their activation pattern must not be jeopardized during the transition between those modes^{1}^{1}1In practice, modeindependent tasks typically allow to model daemon functionalities and lowlevel control loops..
Transition scheduling protocols are often classified with respect to the way they schedule the old and newmode tasks during the transitions. In the literature (see for instance [13]), the following definitions are used.
Definition 1 (Synchronous/Asynchronous protocol)
A modechange protocol is said to be synchronous if it schedules newmode tasks only when all the oldmode tasks have completed. Otherwise, it is said to be asynchronous.
Definition 2 (Protocol with/without periodicity)
A modechange protocol is said to be “with periodicity” if and only if it is able to deal with modeindependent tasks. Otherwise, it is said to be “without periodicity”.
In this research we consider identical multiprocessor platforms and partitioned scheduling, i.e. the tasks are statistically assigned to a processor of the platform, at runtime task/job migration is forbidden. Our motivation of this framework is driven by applications which require a temporal isolation between the various partitions/components. Such requirement are common for certified avionic or automotive applications (e.g. DO178B, DO254 and ISO 26262 standards). Additional motivation of our framework in the technologies like Ada 2012 and integrated toolchain [15] which enable the design and implementation of partitioned multimode multiprocessor applications.
1.1 . Related work
Numerous scheduling protocols have already been proposed in the uniprocessor case to ensure the transition between modes (see [13] for a survey of the literature about this uniprocessor problem). For multiprocessor platforms most of the contributions concern global scheduling approaches where job migrations are allowed (see e.g. the works of Nélis and colleagues [12, 9, 10, 11]).
Concerning the partitioned approach we can report [7] the short paper by Marinho et al. which formalizes the scheduling problem and shows two counterintuitive phenomenons. Emberson and Bate [4] proposed heuristics to handle the mode change; unfortunately they do not provide any timing guarantee to bound the transition delays.
This research.
In this work we consider the scheduling of sporadic implicitdeadline realtime tasks upon identical multiprocessor platforms. Each mode is characterized by a static task partitioning, each processor has its own local and optimal scheduler (EDF typically). We consider synchronous mode change protocol and modeindependent tasks which cannot migrate across the platform. Our contributions are twofold. We propose two methods for handling mode changes. The first method is offline/optimal and computes a static allocation of tasks schedulable and respecting both tasks and transition deadlines (if any). The second approach is subject to a sufficient condition in order to ensure online FirstFit based allocation will satisfy the timing constraints.
2 . Protocol definition and properties
2.1 . Software and hardware architecture
The software architecture is defined by a set of sporadic tasks with implicitdeadlines. Each task , is defined by a worstcase execution time , a minimal interval between two successive release . Thus, generates an infinite collection of jobs and every job must be completed before the earliest next job release (i.e., implicitdeadline). The task utilization is the fraction of time required by the task execution (upon a single processor). The platform utilization is defined by and the maximum task utilization is .
The multiprocessor platform is defined by identical processors () with a shared memory. We assume that task allocations and preemptions are performed without any incurring cost. In practice, the corresponding delays are taken into account in the timing analysis of tasks (i.e., definition of worstcase execution times).
The different transitions between modes in the realtime software can be described by an directed graph. Vertices are the modes and directed edges models are the transitions between a source mode to a destination mode. Edges are labeled by the worstcase transition delay between the two connected modes. According to the protocol that will be consider in this paper, the transition delay will only depend of the source mode whatever the destination mode (this will be discussed in details in the next section). That is the reason why labels on every edge are only indexed according to the source mode.
Usually, all possible transitions between modes can be defined at the design stage and thus such a graph is a priori known. We make no particular assumption on this graph that models all possible transition modes during the system life. Figure 1 presents a mode change graph example with 4 modes and 5 possibles transitions between them. Notice that from Mode 2, two possible mode changes are possible to reach either Mode 3 or Mode 4. This selected destination mode can thus depends on the state of the realtime system when the mode change request occurs.
2.2 . Protocol definition and objective
The tasks are executed according to the system modes. Transitions between modes are initiated by a specific event called a mode change request (MCR). Mode independent tasks (MI tasks) are executed in every mode whereas mode dependent tasks (MD tasks) that are executed in the mode in which they belong to. A mode dependent task is subjected to a transition deadline that ensures that the first job of must be completed after time units after a MCR initiating the mode in which belongs to. Such a deadline is used to take into account the mode transition latency (i.e., the delay to stop MD jobs after a mode change request). After a mode change request at time , the first released job of the MD task must complete occur before time instant: (or equivalently must be released before time instant: ).
We consider synchronous modechange protocol [13]. This means that whenever a MCR occurs, MD tasks in the running mode are no longer recurrent and the mode change is completed when all jobs of MD tasks are completed. At this time, the MD tasks of the new mode are then enabled simultaneously, i.e., those tasks can generate jobs (sporadically).
The system is characterized by a set of MI tasks that will still running continuously after every MCR. After a mode change request (MCR), every MD task is disabled. New tasks will be enabled when all old MD tasks will be completed. Thus, the task system and the synchronous mode change protocol leads to the following assumptions:

every MI task is running in every mode and its processor allocation is known a priori and will never change at runtime.

none of the MD tasks belongs to several modes.
We think that these assumptions correspond to many realworld applications. They allow to select which mode is activated according the environment whenever a MCR arises. Furthermore, as we shall see, it simplifies the definition of the mode transition change latency as it will be presented in Property 1.
In order to illustrate the synchronous protocol behavior, we present a simple example. Consider the tasks presented in Table 1. Every task is assumed here to be allocated to a given processor and we consider that old mode tasks and and the MI task are scheduled using EDF on each processor. Processor has a total utilization of 93% both in the old and new modes and processor has a total utilization of 100% in the old mode and 80% in the new one. Figure 2 presents the EDF schedule on each processor assuming that a mode change request arises at time 7. Up arrows represent task releases and down arrows represent deadlines. In Figure 2, only releases and deadlines of MD tasks are depicted. The two old mode tasks and complete their last jobs by time 11. So, at time 11 no more old mode job is pending. The transition delay to switch in the new mode is equal to 4 units of time since the MCR. According to the synchronous mode change protocol, the new mode task is enabled at time instant 11 (and simultaneously released in our exemple). The relative transition deadline of is and thus the first job of must be completed by time 18. As depicted in Figure 2, all deadlines are met, including the transition deadline of since its first job is completed by time 15.
Tasks  Types  Mode  

MI  all  1  3  0.33    
MD  old  3  5  0.80  20  
MI  all  4  5  0.80    
MD  old  1  5  0.20  20  
MD  new  3  5  0.60  11 
The delay between a MCR and the current (last) MD job completion defines the transition latency delay, denoted . Every MD task in the new mode must meet its transition mode deadline .
Definition 3
A mode change with a transition delay is valid if, and only if, every MD task in the new mode satisfies: .
Notice that if a mode transition graph can lead to several possible transition changes as previously illustrated in Figure 1. As a consequence, the transition latency delay to consider for checking transition deadlines according to Definition 3 depends on the current running mode. Let us consider the Figure 1 to exhibit two possible cases for determining a worstcase transition delay upper bound. In the one hand, Mode 4 is the only predecessor of Mode 1, thus the worstcase transition delay for checking transition deadlines (i.e., Definition 3) is . In the other hand, Mode 4 has two possible predecessor modes: Mode 3 and Mode 2. At design stage the worstcase transition delay must be considered for checking transition deadlines. Hence, the worstcase transition delay for verifying the transition deadlines of MD task running in Mode 4 is defined by .
2.3 . Transition latency delay upper bounds
Obviously, the transition latency delay depends on the time instant at which the MCR arises. Proving that new mode tasks meet their transition deadlines . Thus, since MCR occurrences are unpredictable, we need to compute a transition latency delay upper bound. The assumptions that MI tasks are statically allocated and that none of the MD tasks belongs to several modes ensure that the transition delay in a given mode only depends of the MD tasks executed in that mode.
Property 1
The transition latency delay only depends on the tasks executed in the current mode, and as a consequence, is independent of MD tasks that will be started in a subsequent mode.
Since task to processor allocations meet all timing requirements, then tasks meet all their timing requirements. So, all the MD jobs will be completed by its deadline on each processor. Let be the set of MD task assigned to in the current mode, a simple upper bound of the transition delay on processor is:
(1) 
The second upper bound can be defined by computing a worstcase busy period after a MCR. Let be the set of MI tasks allocated to , the transition latency delay on processors can be defined as follows:

the completion of every active MD job.

the interference of MI tasks until all MD jobs are completed.
Since we consider partitioned scheduling, we can consider each processor separately and we know that in the worstcase, a MCR can arise when all MD tasks have been released and none of them has been scheduled. This delay is bounded by the length of the synchronous busy period of tasks allocated to (i.e., initiated by a critical instant) in which one job of each MD task has to be executed and the interference due to MI tasks. This corresponds to the smallest solution of the following fixedpoint equation:
(2) 
The transition latency delay upon processor in a given mode is bounded by:
(3) 
It is simple to see that upper bounds 1 and 2 are incomparable: if relative deadlines are large numbers in comparison with execution requirements for every MD tasks, then the synchronous busy period will be shorter than all deadlines and hence . Conversely, if they are small numbers, then the busy period will be longer than relative deadlines and as a consequence: . As a consequence, a transition delay upper bound on the multiprocessor platform is defined by considering the two previously proposed upper bounds for every processor :
(4) 
2.4 . Optimization problems
The objective is to allocate mode dependent tasks so that the transition latency delays upper bound is minimized (i.e., Eq. 4). As shown in the previous section, the transition latency delay in a given mode only depends on the tasks executed in the current mode and thus, such an allocation is computed for each system mode.
We next present two different methods:

offline and optimal method based on a MixedInteger Linear Program (MILP) for defining the offline MD task allocations in order to minimize the mode change latency delay and meet all timing constraints.

online method in which MD task allocations are performed by an online algorithm and we provide a sufficient schedulability test that can be checked offline (i.e., at the design stage of the system).
3 . Exact offline allocation method
Allocating tasks to processors in order to minimize an objective function is a combinatorial problem known to be hard. Mathematical programming is a common way to model and solve optimally such problems. In the realtime scheduling literature, mixed linear programming has been investigated for checking feasibility of uniprocessor realtime scheduling problems [14, 3, 16] and for optimally allocating realtime tasks [2]. To the best of our knowledge, mathematical programming has never been studied for analyzing realtime systems subjected to mode changes.
We shall define a MILP for each mode that computes the MD task allocation while minimizing the transition latency delay from the considered mode. Transition deadlines are then checked using the optimal value computed by the MILP (i.e., transition timing constraints in Definition 3).
The proposed MILP tackles with two sets of constraints:

Constraints ensuring feasible task assignment: every MD task is assigned to a processor and the utilization of every processor is less than or equal to 1.

Constraints computing the transition delay upper bound.
We now details these two sets of constraints in separate sections, then the whole MILP will be presented. Table 2 summarizes notations that are used hereafter.
Symbols 
Comments 

number of identical processors  
Set of mode dependent tasks  
Set of mode dependent tasks upon  
Set of independent tasks  
Set of mode independent tasks upon  
task worstcase execution time  
task period  
task utilization  
binary variable =1 if is allocated upon  
binary variable for disjunctive constraints  
number of jobs of in the busy period  
busy period length on  
real number (Transition delay upper bound)  
HV  Arbitrary huge value (disjunctive constraints) 

3.1 . Feasible allocation
Let be a binary variable such that if MD task () is allocated to , otherwise. In order to ensure that every MD task will be allocated upon only one processor, the following constraint must be checked:
(5) 
Furthermore, every processor must satisfy that the total utilization of allocated MD and MI tasks is less than or equal to 1:
(6) 
3.2 . Transition delay upper bounds
As shown in Equation 4, the upper bound of the transition delay is computed as the minimal value between two distinct upper bounds. We first present them separately, and then we shall present how to extend these constraints in order to model the choice of the minimal value among and on every processor .
Let be the optimized value of the transition delay upper bound. Since Eq. 1, (minimizing such that ) directly computes . This leads to the following first set of constraints:
(7) 
We now consider defined in Equation 3. Due to ceiling functions, is not linear and furthermore corresponds to the maximum of the smallest solutions of a fixedpoint equations . The linearization of is based on the techniques introduced by [14]. Let , modeling the number of jobs of a MI task interfering in the transition delay. corresponds to the worstcase interference in interval of time . Since will be minimized for each processor (i.e., the busy period length), then . Thus, the longest busy period then corresponds to the complete execution of MD jobs that is equal to , plus the interference of MI tasks: . Such a busy period will be completed by time (i.e., before the release of subsequent jobs) and leads to an additional constraint in the mathematical program.
For convenience, we define as the busy period length on processor . does not correspond to a variable in the mathematical program, but every time will be used it will be replaced by the righthand side of the following equation:
(8) 
Hence, the constraint checking the end of the longest busy period can be stated as: .
The last problem is now to compute for every processor which upper bound among and will lead to the smallest value of . The corresponding constraints are disjunctive: . Such disjunctive constraints can be represented by linear constraints with a binary variable. Let and HV be an arbitrary high value, then the previous disjunctive constraint is modeled by the two linear constraints:
(9)  
(10) 
The disjunction of the two previous constraints is obtained as follows: if then the second constraint is always satisfied and thus only the first one is taken into account while computing the optimal solution; if , it is the reverse situation and thus the second constraint is effective during the optimization process. Now, replacing and by their corresponding values, the final set of constraints is finally obtained:
3.3 . MILP formulation
Constraints defined in previous sections are now merged to define the complete MILP formulation in Figure 3. We remove ’s by their definitions everywhere that have been used. Let be the number of tasks in the considered mode: , the MILP has:

constraints,

binary variables,

integer variables,

1 real variable.
Hence, the number of variables and constraints are polynomially bounded in the size of the input problem (i.e. platform and task set sizes for the considered mode). The MILP is solved for every existing mode at the design stage. The corresponding allocation tables are then stored in the system memory and used at running time for allocating MD tasks of the new mode whenever a MCR transition phase is completed.
3.4 . Case study
In order to illustrate the problem and the proposed methods, we shall consider a simple case study. The platform is composed of twoidentical processors. The system is based on two distinct running modes. The system is started in the first mode and then alternates indefinitely between the two modes as depicted in Figure 4. The task set is defined by: 4 modeindependent (MI) tasks and 6 modedependent (MD) tasks with in Mode 1: and in Mode 2: . The allocation of mode independent tasks is static and known a priori. The total utilization of MI tasks are respectively for and for . Tasks parameters are summarized in Table 3.
Tasks  Types  Mode  
MI  all  10  30  0.333    
MI  all  20  60  0.333    
MI  all  15  90  0.16    
MI  all  20  100  0.20    
MD  1  7  40  0.175  150  
MD  1  1  10  0.10  100  
MD  1  1  20  0.05  150  
MD  1  2  30  0.0666  200  
MD  1  3  25  0.12  200  
MD  2  50  100  0.50  150 
The mathematical program defined in Figure 3 has been solved for the task set presented in Table 3 in order to compute the optimal allocation of MD tasks for the two modes. We used Frontline solver [1] to solve MILP models.
3.4.1 Mode 1 and transition delay
For the first mode, the MILP leads to the following MD task allocations:

upon , the allocated MD tasks are: , its total utilization with MI tasks is .

upon , the allocated MD tasks are: , its total utilization with MI tasks is .
The computed optimal transition delay upper bound is , corresponding to the saturated constraint on , that is the maximal period of the MD tasks allocated upon (i.e., ). The constraint related to is saturated for task which has the greatest period among tasks allocated to . Table 4 gives the values of the transition latency delay upper bound for every processor. In this case study, since MD task periods are small, dominates for both processors . As a consequence, the values related to presented in Table 4 have been computed using fixed point equations since the corresponding constraints are not saturated in the final program due to disjunctive constraints (i.e., in the optimal program).
Modes /  Mode 1  Mode 2  

Processors  
25  48  –  –  
40  41  100  85 
According to the worstcase transition delay computed by the MILP, ’s transition deadline (i.e., ) must be checked. The MILP solution guarantees that the EDF will schedule all the tasks in the new mode. Thus, the sufficient condition to check this transition deadline is satisfied: .
3.4.2 Mode 2 and transition delay
According to total utilizations of MI task on each processor, the unique MD task (namely has an utilization of 0.5 and thus can only be allocated on . Hence, the MILP solver allocates to leading to the transition delay upper bound . This value corresponds to the second bound : the length of the synchronous busy period on (i.e., the interference of the MI tasks and during the completion of ). In this case, the upper bound corresponding to the maximum of MD task periods is dominated by the upper bound based on the busy period length. The corresponding values are presented in Table 4.
To complete the case study in the offline setting, MD task transition deadlines must be checked. Using the transition delay , one can easily check that the transition deadlines of are all satisfied.
4 . Online allocation method
Linear programs can be solved in polynomial time but introducing binary or integer variables in the math programming model leads to a strongly hard problem. Thus, solving such largescaled optimization problems is quite difficult in practice and the MILP solver is not able to converge to integral values of decision variables nor to establish optimality conditions. Another drawback of the offline approach is that task allocation tables corresponding the different system modes must be stored in the memory of the realtime system.
Two main approaches can be used to cope with largescaled optimization problems:

defining an offline heuristics (with a reasonable time complexity losing optimality) for solving the original allocation problem such as simulated annealing or genetic algorithms. As in the exact method, a static allocation table stores the mapping of all tasks.

using online allocation algorithms such as wellknown online bin packing heuristics [5] and providing conditions ensuring feasibility at runtime. In this case whenever a MCR occurs, the tasks to be started in the new mode are allocated with an online algorithm that is executed when the last task running in the old mode completes.
The latter approach is investigated hereafter assuming that (i) EDF is locally used on every processor to schedule the tasks and (ii) MD task allocations is performed by the FirstFit Decreasing algorithm [6]. First the FirstFit Decreasing algorithm sorts the MD tasks into nonincreasing order of their utilization, and then processes them in that order by allocating each MD task on the first processor into which it fits without exceeding its capacity. As in the offline setting, we assume that MI tasks are statically allocated and are not allowed to migrate at runtime. We make no particular assumption about the algorithm used to allocate MI tasks.
Two problems need to be solve for using online allocation after a MCR :

the computed allocation must be feasible. We shall use the results presented in [6] for checking that allocations will lead to feasible schedule on each processor.

the mode transition delay must be bounded in order to ensure that transition deadlines will be met for every MD task. We will define an algorithm that will solve several mathematical programs (i.e., one for each processor) for computing a transition delay upper bound of the platform.
We detail the solution to these problems in the two next sections.
4.1 . Feasible allocation
A reasonable allocation algorithm is one which fails to allocate a task only when there is no processor in the system which can hold it. MI tasks are statically allocated by designers and MD tasks are allocated by the FirstFit Decreasing. So, such an allocation of the tasks can always correspond to a FirstFit allocation. Since tasks can be renumbered so that the considered allocation correspond to a FirstFit allocation. As a consequence, the overall allocation process (MI and MD tasks) is reasonable. This property will allow to use known feasibility results on EDF scheduling of partitioned multiprocessor realtime systems.
Utilization bounds of bin packing algorithms have been studied in [6] for realtime sporadic tasks with implicitdeadlines. Precisely, let be the maximum number of tasks which can fit into one processor under EDF scheduling:
(11) 
The maximum utilization bound of any reasonable algorithm, FirstFit and BestFit is [6] is defined:
(12) 
Such a maximum utilization bound is tight for reasonable algorithms including FirstFit and BestFit [6]. So, there exists task set having a total utilization just beyond that bound cannot be partitioned over the processors. But, any task set having a total utilization less than or equal to this tight utilization bound is guaranteed to be feasible under EDF scheduling.
The sufficient schedulability test stated in Inequality (12) will be used to check whether a processor allocation will lead to a feasible EDF schedule or not.
4.2 . Transition latency upper bound
The second concerns is to compute the upper bound of any mode transition delay. Since online allocations are used whenever a MCR occurs, it is not possible to predict which allocation will define the worstcase transition delay at runtime. As a consequence, we need to define an upper bound of the mode transition delay while considering all possible MD task allocations. For that will first compute the worstcase allocation of MD tasks for every processor . Let the subset of MD tasks allocated on processor using such a principle, we then compute the worstcase delay using Equation 2. The upper bound of the transition delay will be the longest computed delay among all . We will see that choosing which MD tasks have to be considered is equivalent to solve a knapsack problem.
As shown previously, the transition delay only depends on the MD tasks currently running before a MCR. It follows from Equation 2 that is nondecreasing, and hence will be maximized when the cumulative length of MD tasks allocated to is as large as possible. For every processor , we have to compute which subset of maximizes the length of selected tasks: . Before detailing how to compute using mathematical programming, we summarize the overall approach for a given mode in Algorithm LABEL:alg:upperbound.
algocf[t] \end@dblfloat
Computing a subset of that maximizes the length of selected old jobs is equivalent to solve 0–1 knapsack problem. We recall the problem definition: given a knapsack with maximum capacity , and a set consisting of items, each item has some weight and benefit value (all , and are positive numbers), the problem to solve is: how to pack the knapsack to achieve maximum total value of packed items? This latter problem is known to be hard in the weak sense and can be solve in pseudopolynomial time with dynamic programming [8]. So, largescaled instances can be efficiently solved. Numerous techniques have been proposed for solving efficiently this combinatorial problem. Since the problem will be solve offline, we focus on exact methods.
We describe a mathematical formulation of selecting a subset of MD tasks leading to the longest transition delay on a given processor subjected that such the computed allocation leads to a feasible schedule (i.e., the processor utilization is less than or equal to one). In the worstcase, exactly one job of the MD task of the old mode must be completed. Thus, the objective is to:
(13) 
The constraint to enforce the selected MD tasks are feasible with preallocated MI tasks is:
(14) 
We next provide the mathematical program for computing : let be a binary variable equals to 1 if is in the selected subset, 0 otherwise and let be the set of MI tasks statically allocated to . The available utilization on before allocating MD tasks is bounded by . Thus, the optimization problem is to maximize the total length of selected job subjected to the constraint that the total utilization of allocated tasks upon is not greater than one (i.e., EDF can produce a feasible schedule upon ). The corresponding mathematical program is presented in Figure 5.
Maximize  
subjected to  (15)  
(16) 
4.3 . Case study
We illustrate the principles previously presented on the case study presented in Table 3 for Modes 1 and 2. In both cases, the sufficient feasibility condition of the online allocation process must be established and the transition delay upper bound must be computed to verify if MD task transition deadlines will be met at runtime.
4.3.1 Validation of Mode 1
FF/EDF Feasibility.
Using feasibility condition presented in Section 4.1 for the tasks running in the first mode, we have and . Hence, and the maximum utilization bound that can be guaranteed using a FirstFit allocation of MD tasks is equal to . Thus, the proposed allocation algorithm based on FirstFit allocation of MD tasks will always be able to allocate MD tasks if EDF is used on each processor since .
Checking Transition deadlines.
The MD tasks starting in the Mode 1 will be delayed be the completion of task completed in Mode 2 after a MCR. As shown previously, is the unique MD task in that mode and can only be allocated on . Thus, there is no subset selection problem and the unique solution is . Inserting such a value in the fixed point equation (i.e. Equation 3) leads to: . Notice that such computations have already be done while analyzing the processor in the Offline Method and we already concluded that transition deadlines of tasks are satisfied while switching from Mode 2 to Mode 1.
4.3.2 Validation of Mode 2
FF/EDF Feasibility.
In Mode 2, the operational task set is defined by and . Hence, and the maximum utilization allowed by the Lopez’s et al. sufficient schedulability condition is . As a consequence, the proposed online allocation process of MD tasks will lead to feasible schedules in Mode 2 upon FirstFit allocation of MD tasks and the partitioned EDF scheduling policy since the total utilization of tasks in Mode 2 is (i.e. the maximum guaranteed utilization bound).
Checking Transition deadlines.
The transition delay upper bound while launching MD tasks in Mode 2 is only due to the previous running mode before starting this new mode. In the case study, the predecessor of Mode 2 is the Mode 1. Hence, the transition delay upper bound will be computed as follow according to the tasks to stop in the first mode:

Processor : two MI tasks are preallocated (i.e. and ) leading to a cumulative utilization of . Thus, the remaining utilization for MD tasks is . Selecting MD tasks using the MILP presented in Figure 5 leads to select and and the corresponding value of the objective function is . Introducting that value while solving the fixedpoint equation leads to .

Processor : and are now preallocated and have a cumulative utilization equal to 0.36. Thus, the maximum possible cumulative utilization for MD tasks upon is bounded by 0.63. The solver selects all MD tasks and the objective function is maximized for . Thus, solving the fixedpoint equation leads to .
Hence, . This worstcase delay can be incurred whenever a mode change from Mode 1 to Mode 2 occurs. Thus, only task is concerned by this transition delay before starting the Mode 2. The transition deadline of is 150 and the sufficient condition is satisfied.
5 . Conclusion
The paper presented two methods for handling mode changes in partitioned scheduling upon multiprocessor platform. Tasks are scheduled using the EDF scheduling policy on every processor. We consider two kind of implicitdeadline tasks: mode independent tasks that are executed in all modes and mode dependent tasks that are run in a single mode. The considered mode change protocol is synchronous meaning that it stops any mode dependent tasks before launching the tasks in the new mode. This behavior ensures a temporal isolation of mode dependent tasks running in different modes. The first method is offline and computes a static allocation of MD tasks upon each processor and for each mode. The transition delay upper bounds for switch from the one mode to the subsequent one have been proposed. A transition delay is incurred by the new mode dependent task that must meet their transition deadlines. In the second approach we provide sufficient conditions for verifying that online FirstFit based allocation of mode dependent tasks will leads to feasible schedules and allow to satisfy task transition deadlines. Both approaches have been completely illustrated on a simple case study.
In future work, we want to extend the methods for allowing Mode Independent task to migrate when a mode change is occurring. This should allow a higher utilization of the platform and also to manage the workload balancing upon processors. Another perspective is to consider tasks with constrained and arbitrary deadlines.
References
 [1] http://www.solver.com/.
 [2] Baruah, S., and Bini, E. Partitioned scheduling of sporadic task systems: an ilpbased approach. In Proceedings of the Conference on Design and Architectures for Signal and Image Processing (Bruxelles, Belgium, November 2008).
 [3] Bini, E. Modeling preemptive EDF and FP by integer variables. In Proceedings of the 4th Multidisciplinary International Scheduling Conference (Dublin, Ireland, August 2009).
 [4] Emberson, P., and Bate, I. Minimising task migration and priority changes in mode transitions. In 13th IEEE Real Time and Embedded Technology and Applications Symposium, 2007 (2007), IEEE, pp. 158–167.
 [5] Galambos, G., and Woeginger, G. Online bin packing—a restricted survey. Mathematical Methods for Operations Research 42, 1 (1995), 25–45.
 [6] López, J. M., Díaz, J. L., and García, D. F. Utilization bounds for edf scheduling on realtime multiprocessor systems. RealTime Systems 28, 1 (2004), 39–68.
 [7] Marinho, J., Raravi, G., Nélis, V., and Petters, S. M. Partitioned scheduling of multimode systems on multiprocessor platforms: when to do the mode transition? RTSOPS (2011).
 [8] Martello, S., and Toth, P. Knapsack problems: algorithms and computer implementations. John Wiley & Sons, Inc., New York, NY, USA, 1990.
 [9] Meumeu, P., Nélis, V., and Goossens, J. Scheduling multimode realtime systems upon uniform multiprocessor platforms. In proceedings of the 15th IEEE International Conference on Emerging Technologies and Factory Automation (2010), no. MF002178.
 [10] Nélis, V. EnergyAware RealTime Scheduling in Multiprocessor Embedded Systems. PhD thesis, Université libre de Bruxelles, 2010.
 [11] Nélis, V., Andersson, B., Marinho, J., and Petters, S. M. GlobalEDF scheduling of multimode realtime systems considering mode independent tasks. In 23rd Euromicro Conference on RealTime Systems (2011), pp. 205–214.
 [12] Nélis, V., Goossens, J., and Andersson, B. Two protocols for scheduling multimode realtime systems upon identical multiprocessor platforms. In Proceedings of the 21st Euromicro Conference on RealTime Systems (Dublin, Ireland, July 2009), pp. 151–160.
 [13] Real, J., and Crespo, A. Mode change protocols for realtime systems: A survey and a new proposal. RealTime Systems 26, 2 (March 2004), 161–197.
 [14] Seto, D., Lehoczky, J. P., and Sha, L. Task period selection and schedulability in realtime systems. In Proceedings of the 19th IEEE RealTime Systems Symposium (RTSS’98) (1998), pp. 188–198.
 [15] Sáez, S., Real, J., and Crespo, A. An integrated framework for multiprocessor, multimoded realtime applications. In Reliable Software Technologies–AdaEurope 2012. Springer, 2012, pp. 18–34.
 [16] Zeng, H., and Natale, M. D. Improving realtime feasibility analysis for use in linear optimization methods. In 22nd Euromicro Conference on RealTime Systems (ECRTS’10) (2010), pp. 279–290.