Partitioned scheduling of multimode multiprocessorreal-time systems with temporal isolation

Partitioned scheduling of multimode multiprocessor
real-time systems with temporal isolation

Joël Goossens    Pascal Richard

We consider the partitioned scheduling problem of multimode real-time 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 mode-independent 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 real-time systems require both functionally correct executions and results that are produced on time. Currently, numerous techniques exist that enable engineers to design real-time 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, real-time 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 real-time systems, switching from the current mode (called the old-mode) to another one (the new-mode hereafter) requires to substitute the current executing task set with the set of tasks of the new-mode. There are tasks however — called mode-independent 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 modes111In practice, mode-independent tasks typically allow to model daemon functionalities and low-level control loops..

Transition scheduling protocols are often classified with respect to the way they schedule the old- and new-mode tasks during the transitions. In the literature (see for instance [13]), the following definitions are used.

Definition 1 (Synchronous/Asynchronous protocol)

A mode-change protocol is said to be synchronous if it schedules new-mode tasks only when all the old-mode tasks have completed. Otherwise, it is said to be asynchronous.

Definition 2 (Protocol with/without periodicity)

A mode-change protocol is said to be “with periodicity” if and only if it is able to deal with mode-independent 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. DO-178B, DO-254 and ISO 26262 standards). Additional motivation of our framework in the technologies like Ada 2012 and integrated tool-chain [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 counter-intuitive 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 implicit-deadline real-time 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 mode-independent 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 First-Fit 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 implicit-deadlines. Each task , is defined by a worst-case 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., implicit-deadline). 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 worst-case execution times).

The different transitions between modes in the real-time 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 worst-case 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 real-time system when the mode change request occurs.





Figure 1: Mode change transition graph example

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 mode-change 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).


Old Mode




New Mode

Figure 2: Mode change request with a synchronous mode change protocol upon 2 processors

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 real-world 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
Table 1: Task Set with two modes

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 worst-case transition delay upper bound. In the one hand, Mode 4 is the only predecessor of Mode 1, thus the worst-case 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 worst-case transition delay must be considered for checking transition deadlines. Hence, the worst-case 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:


The second upper bound can be defined by computing a worst-case 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 worst-case, 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 fixed-point equation:


The transition latency delay upon processor in a given mode is bounded by:


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 :


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 Mixed-Integer 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 real-time scheduling literature, mixed linear programming has been investigated for checking feasibility of uniprocessor real-time scheduling problems [14, 3, 16] and for optimally allocating real-time tasks [2]. To the best of our knowledge, mathematical programming has never been studied for analyzing real-time 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.

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 worst-case 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)

Table 2: Notations in mathematical programs

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:


Furthermore, every processor must satisfy that the total utilization of allocated MD and MI tasks is less than or equal to 1:


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:


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 fixed-point 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 worst-case 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 right-hand side of the following equation:


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:


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.

Figure 3: MILP formulation of the offline allocation method

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 two-identical 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 mode-independent (MI) tasks and 6 mode-dependent (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.



Figure 4: Case Study: possible transitions between modes
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
Table 3: Case Study: Task characteristics with two modes

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
25 48
40 41 100 85
Table 4: Computed transition delay upper bounds for mapping MD tasks in Modes 1 and 2

According to the worst-case 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 large-scaled 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 real-time system.

Two main approaches can be used to cope with large-scaled 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 well-known 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 First-Fit Decreasing algorithm [6]. First the First-Fit Decreasing algorithm sorts the MD tasks into non-increasing 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 First-Fit Decreasing. So, such an allocation of the tasks can always correspond to a First-Fit allocation. Since tasks can be renumbered so that the considered allocation correspond to a First-Fit 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 real-time systems.

Utilization bounds of bin packing algorithms have been studied in [6] for real-time sporadic tasks with implicit-deadlines. Precisely, let be the maximum number of tasks which can fit into one processor under EDF scheduling:


The maximum utilization bound of any reasonable algorithm, First-Fit and Best-Fit is [6] is defined:


Such a maximum utilization bound is tight for reasonable algorithms including First-Fit and Best-Fit [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 worst-case 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 worst-case allocation of MD tasks for every processor . Let the subset of MD tasks allocated on processor using such a principle, we then compute the worst-case 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 non-decreasing, 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 pseudo-polynomial time with dynamic programming [8]. So, large-scaled 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 worst-case, exactly one job of the MD task of the old mode must be completed. Thus, the objective is to:


The constraint to enforce the selected MD tasks are feasible with preallocated MI tasks is:


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.

subjected to (15)
Figure 5: 0–1 knapsack formulation of the MD task selection problem on processor

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 First-Fit allocation of MD tasks is equal to . Thus, the proposed allocation algorithm based on First-Fit 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 First-Fit 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 fixed-point 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 fixed-point equation leads to .

Hence, . This worst-case 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 implicit-deadline 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 First-Fit 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.


  • [1]
  • [2] Baruah, S., and Bini, E. Partitioned scheduling of sporadic task systems: an ilp-based 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. On-line 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 real-time multiprocessor systems. Real-Time 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 multi-mode real-time systems upon uniform multiprocessor platforms. In proceedings of the 15th IEEE International Conference on Emerging Technologies and Factory Automation (2010), no. MF-002178.
  • [10] Nélis, V. Energy-Aware Real-Time Scheduling in Multiprocessor Embedded Systems. PhD thesis, Université libre de Bruxelles, 2010.
  • [11] Nélis, V., Andersson, B., Marinho, J., and Petters, S. M. Global-EDF scheduling of multimode real-time systems considering mode independent tasks. In 23rd Euromicro Conference on Real-Time Systems (2011), pp. 205–214.
  • [12] Nélis, V., Goossens, J., and Andersson, B. Two protocols for scheduling multi-mode real-time systems upon identical multiprocessor platforms. In Proceedings of the 21st Euromicro Conference on Real-Time Systems (Dublin, Ireland, July 2009), pp. 151–160.
  • [13] Real, J., and Crespo, A. Mode change protocols for real-time systems: A survey and a new proposal. Real-Time Systems 26, 2 (March 2004), 161–197.
  • [14] Seto, D., Lehoczky, J. P., and Sha, L. Task period selection and schedulability in real-time systems. In Proceedings of the 19th IEEE Real-Time Systems Symposium (RTSS’98) (1998), pp. 188–198.
  • [15] Sáez, S., Real, J., and Crespo, A. An integrated framework for multiprocessor, multimoded real-time applications. In Reliable Software Technologies–Ada-Europe 2012. Springer, 2012, pp. 18–34.
  • [16] Zeng, H., and Natale, M. D. Improving real-time feasibility analysis for use in linear optimization methods. In 22nd Euromicro Conference on Real-Time Systems (ECRTS’10) (2010), pp. 279–290.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description