Response-Time Analysis for Multi-Mode Tasks in Real-Time Multiprocessor Systems

Recently, traditional real-time systems that played a dedicated role in a limited environment have been evolving to interact with dynamically varying environments. In modern real-time systems, characteristics of real-time tasks such as computational demand and resource allocation can vary over time according to different circumstances, which is referred to as mode transition . In this paper, we focus on the problem of timing guarantees of a set of multi-mode tasks associated with mode transitions and develop an ofﬂine schedulability analysis, which does not require any online information; this is an important problem in the real-time systems area. The proposed schedulability analysis not only generalizes an existing framework designed for single-mode tasks, but also signiﬁcantly improves the state-of-the-art framework designed for multi-mode tasks. Building on the proposed analysis, we also address the problem of enforcing the order of tasks within each mode transition and propose a task-level transition order assignment algorithm, yielding further improvement in schedulability performance. Through simulations, our proposed framework is shown to improve schedulability up to 777.3% over an existing schedulability analysis for multi-mode tasks, depending on the experiment setting under our evaluation environment.


I. INTRODUCTION
Traditional real-time systems for dedicated roles with specialized hardware have been evolving to interact with dynamically changing environments through ubiquitous networks and sensor devices. Such modern real-time systems continually sense the physical environment and receive feedback from sensors. As a result, the characteristics of real-time tasks such as computational demand and resource allocation vary over time according to different circumstances, which is referred to as mode transition. A compelling example is an unmanned reconnaissance aircraft, involving landing, takeoff, and normal/specialized reconnaissance modes, each representing a different goal under the corresponding environment it faces [1], [2]. Such mode transition may require activation of a new task, and deactivation or changes in existing tasks.
The associate editor coordinating the review of this manuscript and approving it for publication was Jenny Mahoney.
Such changing characteristics of real-time systems on varying environments necessitate designing distinct task models that potentially characterize multiple execution modes, referred to as multi-mode task models. Multi-mode task models are generalized from a traditional real-time task model specified by a collection of independent recurrent tasks, each of which generates a series of jobs. While a task in the traditional task model [3] is characterized by fixed values for three parameters (i.e., minimum job separation, worstcase execution time (WCET), and relative deadline), multimode task models assume multiple values for each parameter of a task. For uniprocessor systems, timing guarantees on the multi-mode task models have been extensively studied by considering various mode-transition protocols, scheduling algorithms, and system domains [5]- [11] (also see the survey in [2]).
In contrast, few studies have been conducted for multiprocessor real-time systems in the classes of partitioned and global scheduling. For partitioned scheduling, Niz and VOLUME 8, 2020 This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/ Phan considered a criticality transition of tasks [12], whereas Huang and Chen addressed the situation where each task changes its execution independent of other tasks [13].
Regarding global scheduling, a few studies proposed modetransition protocols that incur additional delay for a mode transition and tried to minimize the delay without any deadline miss [14]- [16]. The mode-transition protocol in our preliminary conference paper [17] is distinct from such studies in that it supports a system-wide mode transition where all tasks may switch to their new parameters without additional delay or task drop. Extending an existing popular schedulability analysis framework for single-mode tasks, called the deadline-based schedulability analysis (DA) [18], our previous study succeeded in developing a new schedulability analysis for multi-mode tasks in the presence of a mode transition. Despite the advantages of the transition protocol in our previous study, such advantages have not been fully utilized owing to the limited analytical capability of the DA framework.
In this study, we target the system-wide mode transition protocol without imposing additional transition delay and task drop (to be detailed in Section II-B), and we develop a sufficient, offline response-time analysis (RTA) framework [19] that guarantees timely execution of all tasks in the presence of system-wide mode transitions; RTA significantly improves the analytical capability over DA, as RTA analyzes the worst-case scenario that each task may experience less pessimistically than DA. The key technique of RTA distinguished from DA is the slack reclamation scheme that effectively utilizes the notion of slack (of each task) defined as the minimum interval length between the finishing time and the deadline of any job of a task. We present how the slack reclamation scheme systematically identifies the slack of each task, and incorporate it into RTA to improve the schedulability by reducing the pessimism in analyzing the worst-case scenario that the task may experience. We make RTA independent of online information, such as the time instant when the transition starts, and task release and execution patterns; otherwise, the system would have to monitor/predict the information, and hence the analysis could not provide any offline guarantee.
Also, we further improve the analytical capability of our RTA framework by proposing a mechanism that controls the order for tasks to complete their mode transitions within a system-wide mode transition. In a prior system-wide mode transition protocol, the transitions of tasks occur concurrently in every individual mode transition. Thus, the order for tasks to complete their mode transitions within a system-wide mode transition depends on job release patterns and the mode transition request time. If the transition order of tasks in each system-wide mode transition can be controlled and thus predetermined offline by the system designer, we can further improve schedulability by reducing interference.
We perform extensive simulations to show the effectiveness of the proposed RTA framework. Our proposed framework is shown to improve schedulability up to 777.3%, over an existing schedulability analysis for multi-mode tasks, depending on the experiment setting under our evaluation environment. In particular, schedulability improves as the number of modes increases.
In summary, this paper makes the following contributions.
• Development of a new RTA framework for a mode transition (without any additional transition delay) in realtime multiprocessor systems, which outperforms the DA framework; • Development of a new interference calculation method to be used for the new RTA framework; • Development of a slack reclamation scheme to further improve the schedulability; • Identification of the problem of task-level transition order assignment, and development of a grouping framework for the transition-order assignment using the derived properties under a given condition; and • Demonstration of the effectiveness of the RTA framework via simulation. The remainder of this paper is organized as follows. Section II presents our system model and the transition protocol we consider, and recapitulates an existing RTA framework for single-mode tasks. Section III presents challenges and overview of developing RTA framework for multi-mode tasks. Section IV develops a new RTA framework for a mode transition. Section V develops a task-level transition-order assignment framework. Section VI evaluates the effectiveness of this framework. Section VIII discusses related work, and Section IX concludes the paper.

II. BACKGROUND
In this section, we first describe the system model, assumptions, and notations to be used throughout this paper. Then, we summarize an existing RTA framework for single-mode tasks, which will be used as the basis for our RTA framework for multi-mode tasks.

A. SYSTEM MODEL, ASSUMPTIONS AND NOTATIONS
We consider a periodic task model [3], [20] associated with µ different operation modes. We let M g , M h , and M g ⇒ M h denote the g-th mode, the h-th mode, and a mode transition from M g to M h where g and h are positive integers that satisfy 1 ≤ g ≤ h = g + 1 ≤ µ. A task set τ is denoted by τ g when the parameters of tasks in τ are associated with M g . A task τ g i in τ g is specified by τ ) but also addition/deletion of tasks. For convenience of presentation, 1 Note that all the analytical results in this paper are also applicable to sporadic tasks in which p g i represents the minimum separation, not the exact separation. we let τ denote the set of all tasks existing in at least one mode; if a task τ i does not exist in a mode M g , τ g i represents a dummy task (p g i = 1, e g i = 0, d g i = 1), and does not affect the actual execution of other tasks. Whenever g is irrelevant, we omit it, i.e., using τ i , p i , e i , and d i instead of τ We call the interval between the release time and deadline of a job J i , the scheduling window of J i . We assume a quantum-based time slot, and consider the length of a quantum as one time unit without loss of generality. All task parameters are specified in multiples of this quantum.
We target multiprocessor systems containing m identical processors. We consider global, preemptive, and workconserving scheduling algorithms under which the execution of a job can migrate from one processor to another; a job can be preempted at any time, and there should be no idle processors as long as there is a job ready to be scheduled. We also assume that a job cannot be executed in parallel.

B. TRANSITION PROTOCOL
We consider a series of transitions of a task set τ , and each transition is separated from its predecessor and successor transitions, meaning that any time unit in the interval between the start and end of a transition (e.g., [t 1 , t 2 ) for M g ⇒ M h in Fig. 1) cannot be included in the other transitions' one (e.g., Fig. 1). In other words, the scheduling window of a job with a mode can overlap only with either that of any job with its previous and current modes, or that of any job with its current and next modes. Within a single transition, multiple tasks can change their task parameters; recall that addition or deletion of tasks is also expressed as a change of task parameters by using dummy tasks, as explained in Section II-A. Note that we assume the mode transition protocol itself does not impose additional transition delay and task drop as most existing studies do.
To support a transition that does not result in missing/delaying any task's control update, we follow the protocol in [21], as explained next. For a mode transition M g ⇒ M h , suppose that a mode transition request (MTR) is released at t 1 and the transition is completed at the completion of at least one job from every task. The transition completion cannot be later than t 2 when it is the earliest time at which jobs of all tasks with M h are released or in active already, as shown in Fig. 1; M h starts at no later t 2 . We consider two types of tasks: (i) tasks whose parameters are not affected by the transition (i.e., Then, the protocol does not affect release patterns of each task in (i) at all, e.g., τ 1 in the figure.
For each task τ i in (ii), the next release time (i.e., the earliest release time of jobs of τ i after t 1 ) is not different from the time without the transition. However, there is a difference in that at the next release time, a job of τ h i (associated with a new mode M h ) is released instead of that of τ g i (associated with an old mode M g ), e.g., at t 2 , a job of τ h 2 is released in the figure. After the release of the job with M h , jobs of τ h i are periodically released until another MTR is released. Note that if τ g i is a dummy task, then a job of τ h i is released when an MTR is released; for example, τ g 3 in Fig. 1 is a dummy task, so a job of τ h 3 is released as soon as the MTR is released at t 1 . Therefore, this transition protocol supports not only each task's transition without missing/delaying its control update, but also immediate task migration from other systems caused by any failure.
While many existing mode transition protocols require discarding unfinished jobs of the old-mode tasks, or must wait until a given time instant for synchronous release of jobs of the new-mode tasks (see the survey in [2]), this protocol does not perform such functions. Therefore, the protocol is suitable for real-time control systems, which require timely control VOLUME 8, 2020 updates, even in the presence of transitions. For example, consider commercial flight between Detroit and LA (which are run multiple times every day) or robots repeating the same sequence of tasks (assembly, pick and place). In those applications, mode transitions caused by progress of application execution can be predicted based on a history of application execution. When it comes to mode transitions caused by unpredictable events such as component/subsystem failures, the mode transitions will be difficult to deal with, but the mode transitions are prepared (assigning and scheduling tasks) in advance using ''case'' statements, e.g., in case the left engine fails, we invoke new functions while removing existing functions.

C. EXPRESSION OF THE SYSTEM MODEL AND TRANSITION PROTOCOL
To provide better understanding of the proposed system model and transition protocol, this subsection expresses them using the existing well-defined semantics and syntax of specification language provided in [22]. The study utilizes notions of multiple types of tasks, jobs, actions and guards; action A presents the operation (e.g., abort, update, etc.) that each job/task should conduct during a mode transition, while guard G does the conditions (e.g., offsets after a mode-transition signal) for such an action to be in effect. To this end, we first categorize types of tasks and jobs under a mode transition of our considered protocol, and then describe their behaviors (during the mode transition) with notions of actions and guards.
A task τ i under a mode transition M g ⇒ M h (i.e., an active task in an interval between an MTR and the completion of the mode-transition) of our mode-transition protocol is categorized into the following two types.
• UNCHANGED : Tasks that are active in both M g and M h and all task parameters are not changed, and • CHANGED : Tasks that are active in both M g and M h and at least one parameter of τ i is changed.
Although there exist two more definitions of the task types in [22], which are OLD and NEW (i.e., τ i that are active in M g but not in M h , and vise versa, respectively), τ i in our modetransition protocol does not belong to OLD and NEW since we use a dummy task to present τ i that is not active in one of the two modes. That is, an OLD task in [22] is presented by a CHANGED task whose parameters for M g and M h are given and (p h i = 1, e h i = 0, d h i = 1), respectively. A NEW task in [22] is also presented by a CHANGED task whose parameters for M g and M h are (p g i = 1, e g i = 0, d g i = 1) and given, respectively.
In addition, a job J i under a mode transition M g ⇒ M h is categorized as follows, which is the same as [22].
• PENDING: Unfinished jobs that are not currently executing.
• EXECUTING: Unfinished jobs that are currently executing.
• NEW: New jobs that will be released after the mode transition request. Next, we apply the following mode-transition action for PENDING and EXECUTING jobs in [22] to our mode transition protocol.
• CONTINUE: The jobs continue to be scheduled by a given scheduling algorithm with their current task parameters. In [22], ABORT and UPDATE actions are provided for PENDING and EXECUTING jobs, which aborts the corresponding jobs (if ABORT) and updates the jobs' task parameters (if UPDATE); however, our mode transition protocol does not enforce such actions to PENDING and EXECUT-ING jobs.
For NEW jobs that should be released after a MTR, the following mode-transition actions can be applied.
• RELEASE: New jobs whose parameters are of M h (i.e., destination mode) are released immediately as long as associated guards are true • RELASE_O: New jobs whose parameters are of M g (i.e., source mode) will be released after an MTR as long as associated guards are true. Note that the release of the first NEW job with the destination mode's parameters is delayed until an associated guard becomes satisfied. When it comes to action guards provided in [22], our mode-transition protocol uses the following guard only.
• OFFSET_LR: The corresponding action is applied after the pre-defined offset time units elapse from the last release time of the corresponding task. To summarize, our mode transition protocol M g ⇒ M h is expressed by the existing well-defined semantics and syntax of specification language provided in [22]. That is, under a mode transition M g ⇒ M h , a task τ i is expressed by UNCHANGED or CHANGED, and a job J i is expressed by PENDING, EXECUTING or NEW. The action applied to a PENDING or EXECUTING job always follows CONTINUE without any action guard, meaning that a PENDING or EXE-CUTING job continues to be scheduled by the given scheduling algorithm until its completion. Then, RELEASE with ''OFFSET_LR: p g i '' is applied to a NEW job J i of a CHANGED task τ i , and RELASE_O with ''OFFSET_LR: p g j '' is applied to a NEW job J j of a UNCHANGED task τ j . This implies that a NEW job J i will be released (after a MTR) when p g i time units elapse after from the last release time of the a CHANGED task τ i . Also, a NEW job J j will be released (after a MTR) when p g j time units elapse after from the last release time of the a UNCHANGED task τ j .

D. EXISTING RTA FRAMEWORK
To assure no deadline miss of a set of single-mode tasks, many schedulability analysis techniques have been developed. Among them, the RTA (response-time analysis) technique is popular owing to not only its applicability to many scheduling algorithms such as earliest deadline first (EDF) FIGURE 2. τ g = {τ 1 (period and relative deadline=3, execution time=2), τ 2 (3,2), τ 3 (12, 4)} as well as τ h = {τ 1 (6, 4), τ 2 (6, 4), τ 3 (12, 4)} is schedulable by FP assuming the priority of τ 1 , τ 2 , τ 1 and τ 2 is the same, but higher than that of τ 3 on two processors without any transition. However, the task set is not schedulable in the presence of a transition from τ g to τ h at t = 9. and fixed-priority (FP), but also its schedulability performance, e.g., it is (one of) the best schedulability tests of EDF and FP on a multiprocessor platform [19], [23], [24].
For completeness, we now summarize the response-time analysis technique for single-mode tasks in real-time multiprocessor systems, which was originally described in [19] and has been recapitulated in many papers, e.g., [25]. The technique employs the notion of interference [26]. The interference on τ k in [a, b) (denoted by I (τ k , a, b)) is defined as the cumulative length of all intervals in [a, b) such that a job of τ k is ready to execute, but cannot execute owing to other higher-priority jobs' execution. Furthermore, the interference of τ i on τ k in [a, b) (denoted by I (τ k ← τ i , a, b)) is defined as the cumulative length of all intervals in [a, b) such that a job of τ k cannot execute although it is ready to execute, but a job of τ i executes instead. Because a job of τ k cannot execute only when m other jobs execute, the following equation holds under any global work-conserving algorithm [26]: A property between I (τ k , a, b) and I (τ k ← τ i , a, b) has been derived in [26] as follows: Using Eqs. (1) and (2), the technique calculates an upperbound of the time duration between the release and the completion of any job of τ k (called the response time of τ k ). To do this, we compute the maximum interference of τ i ( = τ k ) on τ k in an interval of length starting from the release of any job of τ k (denoted by I(τ k ← τ i , )), as follows: t|the release time of any job of τ k I (τ k ← τ i , t, t + ). (3) Note that we define I(τ k ← τ i , ) only for 0 ≤ ≤ d k , because we are interested in satisfying the timing requirements.
If the sum of the execution time of τ k (i.e., e k ) and the maximum interference on τ k in an interval of length (≤ d k ) starting from the release time of any job of τ k is equal to or less than , any job of τ k successfully finishes its execution within time units after its release. This leads to the following response-time analysis framework, using Eqs. (1) and (2).
Lemma 1 (Theorem 6 in [19]): When a set of single-mode tasks τ is scheduled by a global, preemptive, and workconserving algorithm, an upper-bound of the response time k holds in the following expression, starting from r Then, if r k ≤ d k holds for all τ k ∈ τ , τ is schedulable by the target scheduling algorithm. Note that the iteration of Eq.
implying that τ k is unschedulable. While the interference I(τ k ← τ i , ) varies with target scheduling algorithms, upper-bounds on the interference under EDF, FP, and any work-conserving algorithm were given in [19]. We present their generalizations in Section IV.

III. CHALLENGES AND OVERVIEW OF DEVELOPING RTA FRAMEWORK FOR MULTI-MODE TASKS
Developing the RTA framework for multi-mode tasks is much more complex than the DA framework case, where the main challenges arise in RTA when addressing the following questions: Q1. How to identify the worst-case scenario inducing the maximum interference on each task in the presence of a mode transition, and how to effectively incorporate it into the RTA framework? (Subsections IV-A, IV-B, and IV-C) Q2. How to safely upper-bound the slack value of each task (which is a key part of an effective RTA framework) in the presence of a mode transition? (Subsection IV-D) Fig. 2 demonstrates the difficulty of addressing Q1 by showing that timing guarantees with a transition cannot be achieved even if the timing guarantees of both task sets before and after the transition are made. As shown in Figs. 2(a) and (b), the traditional RTA framework [27] for single-mode tasks guarantees the schedulability of a task set τ g and that of another task set τ h on two processors when each task set is scheduled by fixed priority (FP) [20] assuming the priority of τ 1 , τ 2 , τ 1 and τ 2 is the same, but higher than that of τ 3 .

VOLUME 8, 2020
However, if τ g makes a transition to τ h at t = 9, τ 3 misses its deadline at t = 12, as shown in Fig. 2(c). Therefore, we need to develop a new RTA framework that can accommodate mode transitions.
As regards Q2, the slack value of each task (defined by the minimum interval between the finishing time and deadline of any job of the task) is essential to significantly reduce the worst-case interference from higher-priority tasks on a task of interest. For single-mode tasks, the traditional RTA framework conducts the slack reclamation scheme by iteratively reducing the worst-case response time of each task to derive upper-bounded slack values. However, such slack reclamation cannot be directly applied to multi-mode tasks in the presence of mode transitions because the execution pattern of other tasks in the presence of previous transitions affects the response times (as well as slack values) of tasks under the current transition, which does not occur in singlemode systems; we elaborate this phenomenon in detail in Section IV-D. By considering the trade-off between schedulability and computational overhead, we propose two different slack reclamation schemes in which (i) the slack value of each task is derived considering the transition history of previous modes, referred to as chaining slack reclamation, or (ii) the slack value is derived independently (but providing restricted analytical capability), referred to as independent slack reclamation.
Thus far, Q1 and Q2 focused on a system-wide mode transition protocol where the transitions of tasks occur concurrently in every individual system-wide mode transition. Thus, the order for tasks to complete their mode transitions within a system-wide mode transition depends on job release patterns and the mode transition request time. If the transition order of tasks in each system-wide mode transition can be controlled and thus predetermined offline by the system designer, we can further improve schedulability by reducing interference. That is, while the thus-developed analysis for addressing Q1 and Q2 provides safe guarantees on timing requirements, it can be pessimistic owing to its applicability to any arbitrary transition order of tasks in each system-wide mode transition. This entails the following question to improve schedulability of the RTA framework assuming predetermined task transition order in each system-wide mode transition.
Q3. How to improve schedulability by enforcing a transition order of tasks in a mode transition? (Section V) Based on the investigation of how interference is reduced when a task-level transition order is enforced (called a sequential transition, as opposed to a concurrent transition), we address two issues: (i) how to guarantee timing requirements with a specific transition order of tasks? and (ii) how to find a transition order that guarantees the timing requirements of a task set specified by (i)? We achieve (i) by adapting the proposed schedulability analysis to a given transition order of tasks. For (ii), we derive some properties toward an optimal order under a given (restricted) condition, and then develop an effective transition order assignment.

IV. RTA FRAMEWORK FOR A MODE TRANSITION
In this section, we propose a new RTA framework for a mode transition, by generalizing the existing RTA framework considering a single mode in Lemma 1. We first extend it to consider a mode transition for a given task of interest. Then, we calculate upper-bounds of the interference for such a task in the presence of a mode transition under any workconserving algorithm, EDF or FP. We finally present how to conduct slack reclamation to improve schedulability of the proposed RTA framework.

A. EXTENSION OF THE EXISTING RTA FRAMEWORK
The schedulability analysis framework in Subsection II-D assumes there is only one mode of each task, so we must extend the framework to multiple modes.
A task executing in the presence of a mode transition such that a job of τ u k cannot execute although it is ready for execution, because a job of τ , ) as follows.
For response time analysis of a given task τ k in the presence of a transition M g ⇒ M h , we also consider two modes of the task because a task in one mode has different task parameters from the same task in a different mode. This means that we should calculate the response time of both τ g k and τ h k for a transition M g ⇒ M h . Thus, we generalize the response-time analysis framework in Lemma 1 as follows.
Lemma 2: Suppose that a task set τ makes a transition M g ⇒ M h and is scheduled by a global, preemptive, and work-conserving algorithm. Then, an upper-bound of the holds in the following expression, starting from r If r u k ≤ d u k holds for all τ u k ∈ τ and u ∈ {g, h}, then τ is schedulable by the algorithm.
Note that the iteration of Eq.
The lemma holds by Lemma 1 and the definitions of Then, how to set the upper-bound of interference I(τ u k ← τ g⇒h i , ) is the most critical part of the response-time analysis for a mode transition, as addressed in the following subsection.

B. INTERFERENCE CALCULATION
Because the interference depends on the scheduling algorithm, we now calculate two different types of upper-bounds for the interference. First, we compute the maximum amount of execution of jobs of a given task under any workconserving algorithm. Second, we calculate a tighter inter-ference upper-bound for a specific scheduling algorithm; as examples, we derive upper-bounds for EDF and FP.

1) INTERFERENCE UNDER ANY-WORK CONSERVING ALGORITHM
For single-mode tasks, it has been identified which release and execution patterns maximize the amount of execution of a single task τ g i 's jobs in an interval of length . As shown in Fig. 3(a), the patterns are either (i) the first job of τ i executes as late as possible and starts its execution at the beginning of the interval (see an interval starting at t a ), or (ii) the last job of τ i executes as early as possible and finishes its execution at the end of the interval (see an interval ending at t b ). Both patterns derive the same amount of execution of τ g i 's jobs [19], [23], and the amount of execution in case of (i) (denoted by W g i ( )) is calculated by [19] as follows.
where F g i ( ) represents the amount of execution of jobs of τ g i in an interval of length , when the first job is released at the beginning of the interval and all jobs of τ g i in the interval execute as early as possible. Then, we can mathematically express F g i ( ) as follows: Further, s g i denotes the slack value of τ g i , which represents the minimum interval length between the finishing time and the deadline of any job of τ g i . Then, any job of τ g i completes its execution at least s g i time units ahead of its deadline. We will present how to compute s g i in Section IV-D. Regarding multi-mode tasks, it is more difficult to determine the maximum amount of execution of jobs of τ i because the amount depends not only on release and execution patterns, but also on the time of an MTR. However, we note an interesting property of the maximum amount, as stated in the following observation.
Observation 1: Suppose that τ makes a transition from τ g to τ h in an interval of length , in which the scheduling window of at least one job of τ g i and at least one job of τ h i (partially or entirely) overlap with the interval as shown in Figs. 3(b) and 3(c). Then, the amount of execution of jobs of both τ g i and τ h i in the interval is maximized with one of the following release and execution patterns: (i) when the first job of τ g i is executed as late as possible and starts its execution at the beginning of the interval of length , and the last job of τ h i is executed as early as possible as shown in Fig. 3(b), and (ii) when the last job of τ h i is executed as early as possible and finishes its execution at the end of the interval of length , and the first job of τ g i is executed as late as possible as shown in Fig. 3(c).
Then, the following lemma proves the correctness of Observation 1.

in the interval of length is maximized with one of release and execution patterns (i) and (ii).
Proof: Suppose that a release and execution pattern not belonging to (i) and (ii) makes the larger amount of execution of jobs of both τ g i and τ h i in the interval of length than those belonging to (i) and (ii). If a release and execution pattern belongs to neither (i) nor (ii), then shifting the release pattern towards (i) or (ii) yields the larger (or equal) amount of execution for jobs of both τ g i and τ h i . This contradicts the supposition, and thus the lemma holds.
A naive approach requires an exhaustive search for the release time of an MTR because we develop a schedulability analysis that an MTR can be released at any time in the interval of interest. By applying Observation 1, we are able to evaluate only the following two types of patterns: P1. Release and execution patterns of (i) with a situation where the scheduling window of a given number of jobs of τ g i (denoted by δ g ) overlaps with the interval of interest. P2. Release and execution patterns of (ii) with a situation where the scheduling window of a given number of jobs of τ h i (denoted by δ h ) overlaps with the interval of interest.
P1 with δ g = 1 is depicted in Fig. 3 i as shown in Fig. 3(b). With the reasoning, the amount of execution of jobs of τ Then, an interval of length where the first job of τ h i starts its execution at the beginning of is calculated by adding d  Fig. 3(c). The amount of execution of jobs of τ h i in the interval of interest (ending at t b ) is equal to δ h · e h i , and that of τ Fig. 3  from it (i.e., ( )) is calculated as follows: As a job can interfere with another job only when the job is executed, I(τ u k ← τ g⇒h i , ) (u is either g or h, and ≤ d u k ) in Lemma 2 is upper-bounded by W g⇒h i ( ) under any workconserving algorithm.

2) INTERFERENCE UNDER FP AND EDF
FP schedules jobs according to pre-determined task-level priorities. Therefore, under FP, if τ i has a higher priority than τ k , then I(τ u k ← τ , ) = 0. EDF determines jobs' priorities based on their deadlines; a job with an earlier deadline has a higher priority than a job with a later deadline. Therefore, a job J A can interfere with another job J B only when the deadline of J A is no later than that of J B . We derive a property that can be used to derive an upper-bound of the interference under EDF, as stated in the following observation.
Observation 2: Suppose that τ makes a transition from τ g to τ h in an interval of length , in which at least one job of τ g i and at least one job of τ h i (partially or entirely) overlap with the interval as shown in Fig. 3(e). Then, the amount of execution of jobs of τ  Fig. 3(e)), and the deadline of the last job of τ h i is equal to the end of the interval, and the first job of τ g i executes as late as possible as shown in Fig. 3(e).
Then, the following lemma proves the correctness of Observation 2.
Lemma 6: The amount of execution of jobs of both τ g i and τ h i in the interval of length under EDF is maximized with the release and execution patterns (iii).
Proof: Suppose that a release and execution pattern not belonging to (iii) makes the larger amount of execution of jobs of both τ g i and τ h i under EDF in the interval of length than those belonging to (iii). If we shift the job releases of (iii) to slightly later, the last job's deadline is later than the end of the interval, which means that the last job cannot interfere with a job whose deadline is the end of the interval under EDF. Shifting the job releases to the other direction also does not increase the amount of interference. This contradicts the supposition, and thus the lemma holds.
Let β h denote the number of jobs of τ h i whose scheduling windows overlap the interval of interest when the release and execution patterns accord with Observation 2, e.g., β h = 1 in Fig. 3(e). Then, the amount of execution of jobs of τ h i in the interval is equal to β h · e h i , and that of τ g i is calculated by     [19], as shown in Fig. 3(d)), and the case when the MTR occurs in the interval E g⇒h i ( , β h ) with different β h . In summary, the upper-bound (denoted by Because a job with a later deadline cannot interfere with a job with an earlier deadline,  for every task τ i do 5: while true do 6: for τ x i ∈ τ x do 8: Calculate new r x i using Theorem 1 with the upper-bounds according to the scheduling algorithm. 9: if r x i < d x i then 10: This means, however, that when we compute τ k 's response time, we need the response times of other tasks τ i ( = τ k ) as shown in Eqs. (14) and (15). To solve this chicken and egg problem, the response time analysis for single-mode tasks [19] employs iterations for slack reclamation. In the first loop, all slack values are assumed to be zero, and we calculate all tasks' response times. After the calculation, the slack value is updated only if the response time is strictly less than the relative deadline (meaning a positive slack value). Then, with the updated slack values, this process is repeated until all response times are no larger than their relative deadlines (schedulable) or there is no more update of slack values (unschedulable).
This slack reclamation process is correct because of two reasons. First, the response time analysis finds a task that triggers the first deadline miss; therefore, when we calculate the response time of a task, we can assume that all other tasks do not miss their deadlines, i.e., non-negative slack values. Second, there exists only one mode of each task; the response time of a task is only affected by task parameters of a given task set with a single, fixed mode.
However, such slack reclamation cannot be directly applied to multi-mode tasks because the slack values of tasks in each mode transition M g ⇒ M g+1 are affected by the behavior of the previous transitions, which is explained as follows. Suppose that a task set τ experiences two transitions M g−1 ⇒ M g and M g ⇒ M g+1 , and we want to utilize a slack value s g k of τ . In each sequence, the slack values of each task τ i for mode M x and M y are initialized to 0 (Line 3) and each task τ i is considered one by one (Line 4). For each task τ i , s x i (likewise, s y i ) is set to the difference between the response time derived by Theorem 1 and the absolute deadline of τ i with the upper-bound for M x , i.e., S i (likewise, without the upper-bound for M y ) as shown in Lines 7-12 (likewise, Lines 13-18). If there is no update for both modes M x and M y , the schedulability of τ i is judged; if τ i is deemed schedulable, S i for the next mode is updated by the slack value of τ y i (Lines 19-25). Then, the task set is deemed schedulable if every task is deemed schedulable for every mode transition (Line 29). Note that the RTA framework with CSR does not require any information involving release or execution patterns of jobs and the release time of an MTR; instead, it only requires the order of system-wide mode transitions. Fig. 4 presents how slack values s x i and s y i are updated while Alg. 1 is conducted. As shown in Fig. 4, the RTA is conducted g times each with its corresponding mode transition  (O(µ)). Then, each task τ i is considered one by one in ∪ τ y (O(maxD)). In Lines 7-12, Theorem 1 is utilized (O(n)) for each task τ x i ∈ τ x (O(n)); the same is conducted for τ y i ∈ τ y in Lines 13-18. Therefore, the time complexity of Algorithm 1 As shown in Alg. 1, the RTA framework with CSR is conducted for every mode transition M x ⇒ M y , which may require high computational overhead for a large value of g. To relieve such overhead, we propose another slack reclamation scheme, called independent slack reclamation (ISR). The RTA framework with ISR assumes no information of the tasks of the previous modes in τ g , and s g i is fixed to zero meaning that we only use the fundamental assumption that there is no deadline miss so far. Thus, the RTA framework with ISR is conducted for the current transition M g ⇒ M h and reclaims a slack value of τ h only, not that of τ g . Hence, Alg. 1 is simplified when ISR is applied instead of CSR; the change is as follows. M x ⇒ M y indicates M g ⇒ M h only (Line 2). s x i is not updated (Lines 9-11). Also, S i needs not to be updated by s y i for the next mode transition's s x i because s x i is fixed to zero under ISR (Line 21). Now, we discuss which information is necessary to the system designer in order to utilize the proposed RTA framework. Since we aim at developing offline schedulability analysis for online scheduling algorithm for multi-mode tasks, we assume that only offline information of the target system is available. Basically, task parameters (i.e., p i , e i , and d i ) for each mode M g (1 ≤ g ≤ µ) are only the given information before using our RTA framework. When we use ISR, no further information is necessary; on the other hand, the sequence of mode transitions should be known when we apply CSR. When it comes to task parameters, p i and d i are naturally determined by a system designer, and e i should be safely derived (i.e., upper-bounded) in the course of program analysis via various static or dynamic techniques; for example, the worst-case execution time estimation upon multiple inputs. Then, the system designer can utilize our RTA framework.

V. RTA FRAMEWORK FOR A SEQUENTIAL MODE TRANSITION
In this section, we discuss how to improve schedulability of the proposed RTA framework by enforcing a constraint in order of individual tasks' mode transitions when each mode transition M g ⇒ M h is performed, and develop an effective transition order assignment framework based on deriving key observations.

A. SEQUENTIAL TRANSITION PROTOCOL
In the previous section, we presented the proposed RTA framework for multi-mode tasks in the presence of a mode transition conducted by the mode-transition protocol described in Section II-B. The protocol assumes that tasks' transitions occur concurrently starting from the MTR in every individual system-wide mode transition, and thus tasks will complete their mode transitions in arbitrary order, which cannot be controlled by the system designer offline. Because of this property, the proposed RTA framework should be independent of job release and execution patterns and the release time of an MTR, but it over-estimates the interference, to be discussed below.
In Fig. 1, after the release of an MTR for a transition M g ⇒ M h at t 1 , the first jobs of τ h 1 and τ h 3 are released earlier than t 2 , while that of τ h 2 is released at t 2 . Therefore, the scheduling window of any job of τ h 2 does not overlap with that of any job of tasks in M g . If we enforce such a transition order of tasks within a single transition (e.g., M g to M h ), we can rule out other tasks in mode M g in the calculation of the amount of interference to τ h 2 during the transition M g ⇒ M h . This reduces the interference and increases the possibility of τ h 2 's schedulability.
To exploit the merit of such interference reduction, we propose a new mode-transition protocol that allows only one task's transition at a time (whose order can be predetermined by the system designer offline), which is referred to as a sequential transition. The sequential transition is opposed to the transition protocol described in Section II-B in that it allows multiple tasks to transit from one mode to another concurrently, which we call a concurrent transition. A sequential transition can improve the schedulability performance over a corresponding concurrent transition, and this improvement can be achieved at the expense of increasing the system's transition time. Within a sequential transition, a task's transition may be delayed until completion of the preceding task's transition, thereby prolonging the system's transition time.
There are two challenges in making timing guarantees under the sequential transition: (i) how to guarantee schedulability with a given sequential transition, and (ii) how to find the effective transition order of tasks, whose schedulability is guaranteed by (i), which will be addressed in Subsections V-B and V-C, respectively.

B. NEW RTA FRAMEWORK FOR A SEQUENTIAL TRANSITION
We aim at developing a new RTA framework to accommodate a sequential transition by modifying the one for a concurrent transition proposed in Theorem 1. Suppose that a task set τ makes a sequential transition M g ⇒ M h in a given order. To express the relative transition order of tasks, let τ On the other hand, any job of τ We can now derive a new RTA framework for a sequential transition, as stated in the following theorem.
Note that Eq. (18) holds only when τ i has a higher priority than τ k ; otherwise, u W From the definition of W g⇒h i ( ), the upper-bound of the amount of interference with a sequential transition (i.e., g W g⇒h i ( ) or h W g⇒h i ( )) is always less than or equal to that with a concurrent transition (i.e., W g⇒h i ( )). Therefore, the following observation is useful in developing the transition order assignment framework discussed in the next subsection.
Observation 3: Suppose that τ makes a transition M g ⇒ M h . If τ g k and τ h k are deemed schedulable with a concurrent transition (proven by Theorem 1), then they are also deemed schedulable for any sequential transition order (proven by Theorem 2).

C. TASK-LEVEL TRANSITION ORDER ASSIGNMENT
As we stated in Subsection V-A, the transition order of tasks within each sequential transition can be predetermined offline by the system designer, and as shown in Eqs. (16) and (17), enforcing a task-level transition order will reduce (or at least stay) the interference on each task, yielding the possibility of finding additional schedulable task sets that are not deemed schedulable with a concurrent transition. Then, an important question arises: ''How can we find an effective transition order of tasks to improve schedulability for a sequential transition?'' The most critical factor to address this question is to exploit a slack value s k of a task τ k on our RTA framework. That is, s k is affected by the amount of the worst-case interference on τ k from other tasks τ i ∈ τ \ τ k (e.g., W g⇒h i ( )) as we discussed in Subsection IV-D, and the amount of such interference on τ k is determined by the transition order of other tasks in a sequential transition as we also discussed in Subsection V-A. This indicates that even if τ k is deemed schedulable in a given task-level transition order, it may not be unschedulable if the order is changed. For example, for three given tasks, τ a and two higher priority tasks τ b and τ c in the presence of a transition M g ⇒ M h , τ a suffers from different amount of interference (and different slack values of τ a ) depending on whether τ Such phenomenon on slack values may enforce us to use an exhaustive search, which requires investigating O(|τ |!) transition orders, and thus, we need to develop an efficient means to find an effective task-level transition order to improve schedulability. To achieve this goal, we consider the DA framework proposed in our preliminary conference paper [17], where slack values are not used and useful properties are derived, and we use the properties for our RTA framework.
Note that if an interval of length is fixed to d u k and slack values s g i and s h i are fixed to 0, our RTA framework becomes the existing DA framework for multi-mode tasks [17]. That is, the following equation is used instead of Eqs. (14) and (15) in Theorem 1.
where u X g⇒h i Following the same reasoning, our RTA framework in Theorem 2 is equivalent to the DA framework for a sequential transition, i.e., Eq. (20) (18) and (19) in Theorem 2. Note that the DA framework is only exploited for assigning a transition order of tasks, and we apply our RTA framework using Theorem 2 to judge schedulability after a transition order of tasks is determined using useful properties under the DA framework. We then investigate how the transition order of a given task affects the interference of other tasks on the task itself under the DA framework, as stated in the following observation.
is minimized, if the order of τ k 's transition is the earliest. Likewise, the case for τ g k and both cases for τ h k also hold. Using the above observation, we now derive some properties of our task-level transition order assignment under the DA framework. Let us focus only on the schedulability of τ k (i.e., both τ g k and τ h k ), rather than on other tasks. If τ h k is schedulable with a concurrent transition under the DA framework (proven by Theorem 1 with Eq. (20) , placing τ k 's transition order in the earliest position not only maximizes the possibility of the schedulability of τ g k as shown in Observation 4, but also guarantees the schedulability of τ h k by Observation 3 (regardless of the transition order). However, such a favorable assignment for τ k 's schedulability may increase the interference of τ k on other tasks. To address this, we introduce two notations.
First, we use τ g k i + 1)) holds for all τ i ∈ τ \ {τ k } and u ∈ {g, h} under the DA framework. Its physical meaning is that the interference of τ g⇒h k on other tasks is dominated by that of τ g k . Thus, min( u W g⇒h k ) regardless of the transition order. Second, let τ * denote a set of tasks in τ , which are schedulable with a concurrent transition under the DA framework; then, any task τ k ∈ τ * with M g and that with M h are schedulable with a sequential transition for any task-level transition order according to Observation 3.
Let us focus on a task τ k which satisfies that (i) τ h k is schedulable with a concurrent transition under the DA framework, and (ii) τ g k I (τ \τ * ) > τ h k holds. Then, we determine the order of τ k by considering two aspects: (a) τ k is schedulable or not; and (b) τ k makes other tasks schedulable or not. For (a), we should place τ k 's transition in the earliest position, because this placement maximizes the chance of the schedulability of τ g k by Observation 4 and τ h k is schedulable with any task-level transition order by Observation 3. For (b), placing τ k 's transition first yields a lower min ) for a given τ g i is independent of the task-level transition order. Therefore, in terms of (i) and (ii), τ k 's transition should be performed earliest. Note that we do not consider tasks in τ * for (b) because they are schedulable for any sequential order based on Observation 3.
With this reasoning, we develop a task-level transitionorder assignment framework that identifies three groups in Alg. 2. In Steps 2 and 3, the algorithm identifies two groups of tasks, whose transition orders should be placed the earliest (τ (1)) and latest (τ (3)) as shown in Steps 5 and 7, respectively; the remaining tasks belong to the second group (τ (2)) as shown in Step 6.
The remaining step is then to determine a transition order of tasks within individual groups τ (1), τ (2), and τ (3) in Steps 5-7 in Alg. 2. The following lemma finds an optimal transition order for tasks in τ (1) and τ (3).
). If so, add τ i to τ (1). 3: Check whether τ g k I (τ \τ * ) < τ h k and τ g k is schedulable with a concurrent transition (i.e., Theorem 1 with Eq. (20) with u X g⇒h i ). If so, add τ i to τ (3). 4 > τ h k ). As to τ h i , it is also schedulable with any task-level transition order by Observation 3, meaning that the transition order of a task τ k in τ (1) does not affect the schedulability of τ h i for all τ i ∈ τ (1) \ {τ k }. The schedulability of tasks in τ (2) ∪ τ (3) is also not affected by the relative order of tasks in τ (1) according to Observation 5. In summary, the relative transition order of tasks in τ (1) does not change the schedulability of every task in τ . This holds for τ (3) with the same reasoning. Therefore, the lemma holds.
By applying Alg. 2 with any arbitrary order for tasks in τ (1) and τ (3), we can derive an optimal task-level transition order under the DA framework except for the relative transition order of tasks in τ (2). To determine a transition order for tasks in τ (2), we may apply an exhaustive search (if |τ (2)| is small) or a heuristic transition order assignment algorithms.
So far, we have discussed how to effectively assign a tasklevel transition order under the DA framework to simplify the interference relationships among tasks. Then we apply our original RTA framework in Theorem 2 based on the task-level transition order determined by Alg. 2. This heuristic approach is quite effective owing to the effectiveness of Alg. 2 under the DA framework, whose performance will be demonstrated via simulation results in the next section.

VI. EVALUATION
In this section, we demonstrate the effectiveness of the proposed RTA frameworks in which a concurrent transition and a sequential transition are associated with CSR and ISR.
We randomly generate task sets for a multiprocessor platform using a well-known task set generation method, referred to as UUnifast-discard [28]. Typically, three input parameters are considered for UUnifast-discard: (i) the number of processors m (2, 4, 8, and 16) As we consider multi-mode systems, we additionally consider the number of modes µ (from 2 to 10 for positive integer values). We generate 1000 task sets for every fourtuple (m, n, U , µ). For a given task utilization for τ i (u i ), p i is uniformly selected in [1,1000]; C i is computed based on the given utilization and p i (i.e., e i = p i · u i ); and d i is set to p i . The randomly generated task parameters are known to sufficiently cover the general cases of real systems such as antenna controller software in an unmanned aerial vehicle as shown in the previous studies [35], [36].
As a baseline schedulability analysis, we take the DA framework for multi-mode tasks proposed in our preliminary conference paper [17]. For all generated task sets with the four-tuple (i.e., 1000 · 4 · 9 · 8 · 9 task sets), we compare the number of schedulable task sets with µ − 1 different transitions M g ⇒ M h (1 ≤ g ≤ h = g + 1 ≤ µ) using their corresponding schedulability analyses 2 : • A concurrent transition tested by DA, RTA with CSR and RTA with ISR (denoted by DA con , RTA(C) con , and RTA(I) con , respectively); • A sequential transition tested by DA, RTA with CSR and RTA with ISR -the entire order is determined randomly (denoted by DA seq , RTA(C) seq , and RTA(I) seq , respectively); and • A sequential transition tested by DA, RTA with CSR and RTA with ISR -the entire order is grouped by Alg. 2, and then the relative order of tasks in each group is determined randomly (denoted by DA * seq , RTA(C) * seq , and RTA(I) * seq , respectively). Here, DA con is conducted by Theorem 1 in [17], and RTA(C) con and RTA(I) con are conducted by Theorem 1 in Subsection IV-C. Further, DA seq and DA * seq follow the analysis presented in Theorem 2 in [17], and the others are conducted by Theorem 2 in Subsection V-B. We present the simulation results for implicit-deadline tasks scheduled by FP only, as those for implicit-deadline tasks scheduled by EDF (or those for constrained-tasks scheduled by FP or EDF) exhibit a similar trend. 2 A task set is deemed schedulable if it passes a corresponding schedulability test for every transition M g ⇒ M h with a given µ.   of n = 1.5m, U = 0.2, and µ = 2. Fig. 5(b), (d), and (f) show it of (a), (c), and (e) for µ = 10 instead of µ = 2. From the figures, we note the following.
O1. Each schedulability analysis of the RTA(C) series (i.e., RTA(C) con , RTA(C) seq , and RTA(C) * seq ) outperforms each corresponding schedulability analysis of the RTA(I) series, which also holds between RTA(I) series and DA series. O2. As the value of µ increases, the performance gap between the RTA(C) series and the RTA(I) series becomes pronounced. O3. For an increasing value of U , schedulability analyses utilizing task order assignment in Algo. 2 (i.e., − * seq ) shows less performance degradation than the others. O4. As the number of tasks n increases, the schedulable ratio of DA series decreases at a rate higher than the other series.
O1 holds owing to different analytic capabilities between the existing DA framework, and the two proposed RTA frameworks with CSR and ISR. That is, although three analyses commonly exploit interference calculations presented in Subsection IV-B, the DA framework does not utilize a slack value of each task while the RTA framework with CSR uses it for both τ g i and τ h i (and the RTA framework with ISR only uses it for τ h i ). Further, the DA framework considers interference on τ k within an interval of length d k while the others gradually increase such interval length from e k up to d k during judging schedulability. Because of such different capabilities, each schedulability analysis of the RTA(C) series dominates the corresponding RTA(I) series in terms of schedulable ratio, which also holds between RTA(I) and DA. For example, as shown in Fig 5(a), the schedulable ratio of RTA(C) * seq , RTA(I) * seq , and DA * seq for 0.5m are 69.2%, 64.4%, and 50.3%, respectively.
O2 demonstrates the superiority of CSR compared to ISR when it comes to multiple modes, meaning a larger number of schedulable task sets are found by the RTA framework with CSR than the RTA framework with ISR. This implies that it is crucially important to capture how slack values of tasks in two consecutive modes are correlated and to incorporate them into the analysis for improving schedulability for multimode tasks, which is successfully fulfilled by CSR but not ISR. For example, RTA(C) * seq and RTA(I) * seq for n = 1.5m, U = 0.2m, m = 4, and µ = 2 show the nearly same performance (in Fig. 5(c)) while there is about 20% performance gap between RTA(C) * seq and RTA(I) * seq for µ = 10 (in Fig. 5(f)) (66.6% vs. 46.0%).
O3 stems from the advantage of interference reduction by utilizing task ordering assignment. High-utilization tasks may have fewer slacks while inducing a large amount of interference to lower priority tasks. Thus, reducing interference from g W g⇒h i ( ) to W g i ( ) is a more effective approach for achieving better schedulability rather than exploiting small amount of slacks. For example in Fig. 5(a), DA * seq performs better than RTA(C) seq for U = 0.5m even though RTA(C) seq utilizes slack values of both τ g and τ h while DA * seq does not (51.2% vs. 50.5%).
In contrast, O4 holds owing to the advantage of slack reclamation subject to low-utilization tasks. The increasing number of tasks in a task set with fixed system utilization results in decreasing average task utilization. Low task utilization possibly induces much slack for each task, and thus it can compensate pessimistic interference calculation of a large number of tasks in a task set. For example in Fig. 5(b), the performance gap between RTA(C) seq and DA * seq becomes larger even though DA * seq exploits task order assignment in Algo. 2 while RTA(C) seq does not; the schedulable ratio of RTA(C) seq is about 37% while that of DA * seq is 16% for n = 5m. Table 2 shows the schedulable ratio of considered schedulability tests for n = 1.5m, U = 0.2m, µ = 10 (corresponding to Fig. 5(f)). As shown the table, RTA(C) * seq (our best performing test) improves DA * seq (the existing one) by 17.1/2.2 = 777.3%.

VII. DISCUSSION
The underlying assumption under Liu and Layland's task model is that the worst-case execution time C i of each task encompasses the worst-case timing overheads stemming from preemptions/migrations. However, considering such timing overheads in every case is pessimistic since such a case happens rarely in practice. This pessimism can be mitigated by upper-bounding the number of preemptions that a job can experience. Since we consider FP and EDF scheduling classified as a task-or job-level fixed priority assignment scheme, the job priority never changes once it is assigned. Instead, the priority order of jobs of currently running jobs can be changed due to a newly-released job. Therefore, a preemption occurs only when a job is released and the job's priority is higher than the currently-executing jobs. Also, a migration occurs only when the preempted job resumes its execution on a core different from the one on which the job was executed before the preemption. Thus, the number of preemptions that a job can experience cannot be larger than the number of higher-priority jobs released during the job's execution. Also, the number of migrations that the job can experience cannot be larger than the number of preemptions that the job undergoes. Therefore, we can upper-bound the number of migrations that a job can experience, by the number of higherpriority jobs released during the job's execution.
The Liu and Layland model also assumes that the worstcase execution time C i of each task implicitly includes the worst-case blocking time resulted from mutual exclusion of critical sections on shared resources such as main memory, memory bus, and shared cache. The resource-locking protocol ensures that one job never enters its critical section at the instance when another concurrent job enters its own critical section, which has been extensively studied in a number of existing work for real-time systems [39], [40]. The resource-locking protocol to be developed for our proposed RTA framework for multi-mode tasks potentially improves analytic capability as it reduces response time of τ k by relieving a pessimistic assumption of the Liu and Layland's task model regarding worst-case execution time C i of each task.
In addition to the theoretical upper-bound, we also discuss how many migrations can occur during the considered scheduling via well-known experimental results. As shown in the previous experimental results in [37], the average actual number of preemptions incurred by each implicit-deadline (i.e., d i = p i ) task set scheduled by EDF during 100,000 time units is 1,068.3 for m = 2 and 2,319.8 for m = 8, indicating that possibility of the occurrence of a preemption at each time unit ranges from 1.0% to 2.3%, depending on the number of processors. Although our proposed RTA framework does not explicitly include any method to upper-bound the number of preemptions that occur during each job's execution, such experimental results imply that it is acceptable to ignore preemption cost when the migration cost is not very high.
In this paper, we considered the system in which tasks' parameters undergo multiple transitions, while the scheduling policy (i.e., job prioritization policy) does not change. When it comes to dynamic scheduling in which the scheduling policy changes according to online schedulability analysis, we may consider another system model proposed in [38] where task parameters and the scheduling policy change during operation. Also, the applicability of the current version of our proposed RTA framework is limited to the modetransition protocol for predetermined (fixed) sequence of mode transitions (CSR case), or the analytical capability of that is sacrificed when the sequence of mode transitions is not known (ISR case). It would be worth relieving such the limitations to improve the applicability of our RTA framework while improving the schedulability.

VIII. RELATED WORK
Starting from [29], a number of studies proposed task models considering potential mode transitions for uniprocessor platforms, such as the generalized multiframe (GMF) model [30], the digraph real-time (DRT) model [6], the acyclic task model [31], and the variable rate-dependent behavior (VRB) task model (also known as the adaptive variable-rate (AVR) model) [1], [8], [32], [33]. In the GMF model, each task invokes static types of jobs sequentially, each with potentially different WCETs and relative deadlines. The DRT model is a more expressive one, in which the release of different types of jobs are represented by a directed graph; each vertex in the directed graph indicates a specific type of job labeled with an ordered pair of WCETs of the corresponding job and relative deadline, and each edge represents the order in which jobs are generated by the corresponding task. A job in the acyclic task model has any arbitrary execution time, which assumes that the absolute deadline and the arrival time of the next job of a task are determined by the arrival time of the job plus the utilization multiplied by the execution time of the job. Tasks in the VRB model are related to angular velocity of a specific device (e.g., the crankshaft, gears, or wheels). Such a device's activation rate is proportional to the angular velocity thereof, which determines the execution mode assuming different corresponding task parameters.
For multiprocessor platforms, there have been few studies addressing multi-mode tasks for partitioned and global scheduling, respectively. For partitioned scheduling, Niz and Phan addressed the system-wide mode transition for multimode tasks in which each task's criticality may change during a mode transition while the other parameters (i.e., p i , e i and d i ) do not change [12]. They considered zero-slack rate-monotonic scheduling [34] and proposed a partitioned scheduling scheme maximizing the schedulable utilization while ensuring the absence of criticality violation. Huang and Chen addressed a mode transition (which is different from our protocol) for single-criticality tasks and proposed binpacking task allocating algorithms guaranteeing utilization bound of tasks [13]. For global scheduling, three studies [14]- [16] developed system-wide mode-transition protocols aiming at minimizing the transition delay occurring in the presence of a mode transition without deadline miss under a target global scheduling. The first work [14] suggested the notion of a relative enablement deadline for each task and proved the correctness of the proposed transition protocol by showing that every transition delay is no larger than the enablement deadline of each task. The other two studies aimed at incorporating single-mode tasks (i.e., independent of mode transitions) into the transition protocol [15] and reducing transition delay by exploiting a rate-based global dynamic-priority scheduling algorithm [16]. Unlike such studies, our study in the preliminary conference paper [17] supports a transition without imposing additional transition delay or task drop. Our previous study extended the existing DA framework developed for single-mode tasks on multiprocessor platforms to judge schedulability of multi-mode tasks in the presence of a given single mode transition.

IX. CONCLUSION
In this paper, we focused on the problem of guaranteeing the timing requirements of task sets with system-wide mode transitions in real-time multiprocessor systems. We developed an offline schedulability analysis that does not require any online information, and generalizes the existing RTA framework designed for single-mode tasks and the DA schedulability analysis designed for multi-mode tasks. To improve the analysis, we enforced the transition order of tasks, and proposed a transition sequence assignment algorithm by deriving the useful properties of an effective transition order under a given restricted condition. Our proposed RTA framework is shown to improve performance up to 777.3% depending on the experiment setting under our evaluation environment. In the future, we would like to extend our study towards the mechanism providing less computational complexity or supporting other platforms/frameworks such as heterogeneous multiprocessor platforms and hierarchical scheduling frameworks.

ACKNOWLEDGMENT
An earlier (shorter) version of this paper was presented at the IEEE RTSS 2013 [17]. VOLUME 8, 2020