Q-CSF: Quantum-aware Compositional Scheduling Framework for Hierarchical Real-time Systems

Component-based design has received considerable attention owing to its advantages in terms of security and safety when developing modern embedded systems. To effectively allocate computing resources to components in these systems, real-time component-based scheduling theory has been studied from various perspectives. The main advantage of component-based scheduling theory is that it guarantees the schedulability of an independent component and composability of multiple components. However, the existing component scheduling theory cannot be directly applied to real hardware platform due to an impractical assumption that resource allocation must be conducted across the continuum of real numbers, whereas actual operating systems (or virtualization systems) allocate resources in units of scheduling time quantum. In this study, we proposed a new efficient resource allocation and supply mechanism for quantumized hardware platforms while using real-number-based component interface. In simulation results with randomly-generated workloads, our approach reduced the overhead of existing approaches by up to 97.1% in an individual component. In composition of multiple components, our approach has up to 0.41 better acceptance ratio than existing approaches.


I. INTRODUCTION
T RADITIONAL embedded systems that perform dedicated functions in restricted environments are evolving toward cyber physical systems (CPS), which operate more complicated functions involving both physical and computing aspects [1], [2]. A compelling example of CPS is the autonomous driving system (ADS), whose functions include 1) sensing and controlling physical devices, and 2) perception and planning with algorithms. The most important requirement for such functions is the timing guarantee, such that each periodic task must be completed in a predefined time (i.e., a deadline) [1]. For instance, the adaptive cruisecontrol system [1] of an ADS correctly operates only when its embedded camera and LiDAR tasks deliver sensing data in a timely manner to the motor-control task through associated computing interfaces.
There have been a few approaches that attempted to realize real-time CPS design [3]- [7]. Among them, the componentbased method has received considerable attention, owing to its advantages in terms of security and safety [3], [7]. Component-based design aims to simplify CPS design by splitting it into sub-procedures and multiple components. For example, an ADS includes various components such as a driving system that includes engine and braking tasks, and a control system that encompasses steering tasks. Furthermore, merging developed components into a combined system necessitates component abstraction. The high-level idea of component abstraction is providing interfaces that communicate between components and externals while hiding complicated architectural details. Because each component is individually developed and operated, the component-based systems are normally attack-and fault-resilient, compared to traditional systems.
Component-based design has been incorporated into realtime systems by exploiting component scheduling theory. Component scheduling framework (CSF) [3], [7] aims to effectively allocate computing resources (e.g., processors and networks) to multiple components. Then, virtualization technique on operating systems promotes to schedule task (or component) and allocate computing resources under cloud platforms [8]- [13]. Among them, RT-Xen [12], [13] is one representative example on a real-time cloud platform, which supports the timely execution for components in a Xen virtualization environment.
In the CSF, each component has its own workload, which can be a set of tasks or a set of components. Component can schedule its workload by its own scheduler. If a parent component has multiple child components as its workload (refer to Figure 1), the parent component need to schedule its child components. Each component has its component interface which specifies resource demands in terms of time duration. From the perspective of the parent component, a child component can be transformed into a task by its component interface. Then, the schedulability of each component is guaranteed by comparing the worst-case resource-supply (e.g., derived by the supply bound function) and resource demand (e.g., derived by the request bound function). However, the original component scheduling theory [3] makes an impractical assumption that the resource allocation can be conducted in units of real numbers, whereas actual operating systems or virtualization systems allocate resources in units of quantum time. To address this problem, an existing study [13] utilized integer-based resource-supply and resource-demand policies, but it found that it did not derive effective scheduling algorithms and relevant implementations. In this study, we proposed a new efficient supply bound function for quantumized hardware platforms while using real-number-based component interface. This paper makes the following contributions: • We develop a new quantum-aware compositional scheduling framework (Q-CSF) of which every scheduling decision is quantum-based for hierarchical real-time systems. • With Q-CSF, we propose an integer-based supply bound function (iSBF) to the address resource-allocation problems using quantumized hardware platforms. •  The rest of the paper is structured as follows: Section II presents the system model and background. Section III explains the challenges and our framework. Section IV evaluates the proposed framework, and Section V discusses related work. Finally, Section VI concludes the paper.

II. SYSTEM MODEL AND BACKGROUND
In this section, we present our system model and assumptions (Section II-A), problem forumation (Section II-B), and a theoretical background (Section II-C) for real-time hierarchical systems. We summarize our notations in Table 1.

A. SYSTEM MODEL AND ASSUMPTIONS
We consider hard real-time systems where missing deadlines cause the system failure, whereas soft real-time systems tolerates some deadline misses. Therefore, our performance metrics is resource efficiency or acceptance ratio 1 .
Our target system is a hierarchical (compositional) realtime system comprising a set of real-time components, where a component may include a set of child components, in a treelike manner as shown in Figure 1. A component is noted by C = (W, Γ, A) where W is a workload (described below), Γ is the resource model as the interface of the component (described below) and A is the scheduling algorithm (e.g., deadline monotonic (DM) or earliest deadline first (EDF)) that is used to schedule W . In this study, we only consider deadline monotonic (DM) scheduling algorithm in which a task having a smaller relative deadline has a higher priority. For simplicity of representation, we denote C = (W, Γ, A) by C = (W, Γ) because A is fixed to DM 2 . Component Workload. A workload W in a component C consists of n real-time tasks: W = {τ 1 , τ 2 , · · · , τ n }. We consider a constrained-deadline sporadic task, where the deadline of the task (D i ) is equal to or less than the period of the task (T i ), and the next job of the task releases at any random time instant after the release time of the current job plus the period of the task. Each task τ i is characterized by  3 , and • D i ∈ N is the relative deadline (the relative time of the deadline of a real-time job from the release time of the job while absolute deadline indicates the deadline of a real-time job from time 0). A task τ i generates an infinite sequence of jobs {J 1 i , J 2 i , · · · }: if a job J j i is released (or arrived) at t, then the absolute deadline of J j i is t + D i , and the next job J j+1 i may be released at any time after t + T i . The term "deadline" indicates the relative deadline unless specified otherwise. A task τ i is schedulable if every job J j i of τ i completes its execution before its absolute deadline. Under the DM scheduling policy, workload W is schedulable if every task τ i in W is schedulable. Resource Model. In component-based system design, component interfaces eliminate implementation details and facilitate their easy use of components. In CSF [7], the resource model abstracts (computing) resource demand for a real-time component as the component interface. The representative resource model is periodic resource model (PRM) [3], Γ = (Π, Θ), which consists of the resource period, Π ∈ N, and the (computing) resource supply within the resource period, Θ ∈ R + . PRM Γ = (Π, Θ) means that the resource model Γ can supply Θ units of resources (such as 2ms CPU execution) in every Π time units (such as 10ms).

B. PROBLEM FORMULATION
The problem of CSF has not much considered under quantumized platforms (resource cannot be supplied in fraction of time quantum). In this paper, we consider the following problems: In this subsection, we introduce the background knowledge of the schedulability analysis of real-time systems and compositional (hierarchical) systems. To analyze the schedulability of real-time systems, we must investigate the worst-case resource demand of each task to complete its execution miss and resource supply provided by the platform for a given time interval. Hence, by identifying the upper-bounded resource demand of each task and the lower-bounded resource supply for a given time interval, we can judge whether each task is schedulable. The request-bound function (RBF) gives the worst-case resource demand 4 of task τ i among workload W for a given time duration t under the DM scheduling algorithm. We can then compute RBF as follows: where HP (τ i ) is the task set having a higher priority than τ i . The following example shows how to calculate the resource demand of a task among a given workload.   Figure 2 draws the resource demand of RBF(W, 2, t) and RBF(W, 3, t) according to Equation (1). Note that RBF(W, 1, t) is a constant function.
We then consider the worst-case resource supply: for nonhierarchical systems, the worst-case resource supply for a given time interval t is t. Thereafter, we can check whether the workload is schedulable. The following lemma presents the schedulability condition under the DM scheduling algorithm.
Lemma 1 (from [14]). A given workload W is schedulable under the DM scheduling algorithm if Next, we consider the schedulability of a componentbased (hierarchical) system (e.g., Figure 1). Checking the schedulability of a real time component is different from that of a traditional (non-hierarchical) system (Lemma 1). To analyze schedulability in CSF, we introduce a Supply Bound Function (SBF) [7] that gives the worst-case resource supply of PRM Γ in a given time interval t. Figure 3 illustrates the worst-case pattern of resourcesupply of PRM Γ for a time interval t. Let's consider arbitrary resource supply from PRM Γ. Resource may be supplied in the beginning of the period, the middle of the period, or The worst-case resource starvation the end of the period. The the worst-case resource-supply happens when resource is not supplied until the deadline of the first job of some task. Then, we consider the worst-case resource starvation scenario 5 among all possible resourcesupply pattern: the resource of the previous resource period (before time zero) is supplied at the beginning of the resource period, and the first resource is supplied at the end of the resource period. Then, the length of the worst-case resource starvation is 2(Π−Θ), as shown in Figure 3. Next, the worstcase of the following resource supply happens when resource is supplied at the end of the following resource period.
Then, we compute SBF as follows: where l = Π − Θ and k = max(0, t−l Π ). Note that l and k indicate the unserviced time across the period (i.e., the difference between Π and Θ) and the number of whole resource supplies within the time interval 6 , respectively.
Extending Lemma 1 with the SBF, the next lemma shows the schedulability condition of a real-time component.
Next, we present a way to compute the component interface if the component workload is given. The abstraction problem indicates how to find a resource-efficient component interface (i.e., PRM model Γ = (Π, Θ)) for a given component workload. The existing work [3], [7] considers the abstraction problem to find a proper resource supply Θ for a given component workload W and a given resource period Π. Then, the problem is computing the minimum Θ that can schedule W with component period Π. By solving the equation in Lemma 2 using W and Π, we find the proper Θ. Refer to the details of the computations in [3], [15].
However, the solution of the abstraction problem is a realnumber interface even if all the workload parameters are This work is licensed under a Creative Commons Attribution 4.0 License. For more information, see https://creativecommons.org/licenses/by/4.0/ This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/ACCESS.2021.3120743, IEEE Access integers. Hence, the solution is not directly applicable to quantum-based real platforms. The next example shows why the solution is a real-number. (7, 1, 7). Assume that component period is given by Π = 3. If Θ = 1, then Equation (4) of Lemma 2 does not hold for τ 2 because RBF(W, 2, t) > SBF(Γ, t) for all t ≤ 7. It means that workload W is not schedulable when Γ = (3, 1). If Θ = 2, then Equation (4) holds for both τ 1 and τ 2 . If Θ = 1.7, then Equation (4) still holds for both τ 1 and τ 2 . For τ 2 , we observed that RBF(W, 2, t) ≤ SBF(Γ, t) at time 7: RBF(W, 2, 7) = 3 and SBF(Γ, 7) = 1 * 1.7 + max(0, 1.4) = 3.1. The above calculation indicates that the minimum Θ exists between 1 and 1.7, meaning that the solution of the abstraction problem is a real-number.

III. THE QUANTUM-AWARE COMPOSITIONAL SCHEDULING FRAMEWORK
We introduce the challenge of the quantum-aware resource supply in Section III-A and present our approaches in Section III-B. Then, we analyze the schedulability of our approaches and present the algorithm to compute the resourceefficient resource model in Section III-C.

A. CHALLENGES FOR QUANTUM-AWARE RESOURCE SUPPLY
In real digitized embedded systems, we cannot supply a fractional unit of resources (e.g., allocate 0.7 processor time quantum to task A). Possible resource allocation is to assign a task into the processor while executing the task for least one time quantum. However, the solution of abstraction problem is a real-number interface, even if all workload parameters are integers (refer to Example 2). To utilize the solution of the abstraction problem (i.e., resource-efficient real-number PRM interface), we require a quantum-aware resource supply mechanism.
One naive way to provide a quantum-aware resource supply is to use nPRM, which is the PRM Γ = (Π, Θ) where Π ∈ N and Θ ∈ N. To supply sufficient resources for the component workload, we transform the real-number PRM Γ = (Π, Θ) into the nPRM Γ as follows: The next example shows the difference between the PRM and the nPRM when abstracting the component workload into the component interface.
Example 3. Suppose that the workload of a component is abstracted to the PRM (3, 1.6). For the same workload, we can abstract it into the nPRM (3,2). Although the nPRM can support quantumized resource supply, it has 0.133 larger overhead than the PRM in terms of utilization: 2/3−1.6/3 = 0.1333.
As shown in Example 3, the drawback of nPRM is inefficient resource utilization, which is severe for smaller Π. Our challenge for quantum-aware resource supply is to reduce inefficiency even for small Π.

B. A NEW RESOURCE SUPPLY MODEL FOR Q-CSF
In this subsection, we propose a new resource supply model for quantumized platforms, called integer Supply Bound Function (iSBF), which calculate the minimum resource supply considering scheduling quantum in real hardware platforms. For given PRM Γ and time interval t, we propose an iSBF as follows: , and QS(k, Θ) = kΘ − (k −1)Θ . We illustrate the worstcase resource-supply pattern considering quantumization in Figure 4. To express the quantumized resource supply, we define the function QS(k, Θ). It computes the maximum integer resource-supply during k + 1 periods, which is the floor value of the cumulative resource-supply from time 0 to k + 1 period. We note that the worst-case resource starvation considering the maximum integer resource-supply is 2Π − Θ − QS(1, Θ)), which is also expressed in the design of Equation (5).
Next, we examine characteristics of iSBF. First, iSBF can compute the worst-case integer units of resource supply for a given time interval from a specific resource model. Second, the remaining resource supply after the quantumization of the resource supply (fractional part of resource supply) is accumulated to the next resource supply. Third, the worstcase resource starvation of iSBF (2Π − Θ − QS(1, Θ)) is larger than that of SBF (2Π − 2Θ), owing to quantumized resource supply.
The next example shows the difference of SBF and iSBF, illustrating in Figure 5.  Compute Θ 1 satisfying Equation (7) 5: Compute Θ 2 satisfying Equation (8) 6: Proof: The task set is schedulable under DM scheduling algorithm if each task is schedulable. Consider a task τ i . Because the scheduling algorithm is DM, task τ i completes its execution before the deadline of the task D i if the execution requirement from tasks whose priorities are higher than τ i and the execution requirement of τ i is satisfied with resources supplied by iSBF with Γ at time t ∈ [0, D i ], i.e., ∃t, RBF(W, i, t) ≤ iSBF(Γ, t).
We present an example to check the schedulability of a real-time component under Q-CSF.
Although we can check schedulability of a real-time component with a given resource model and a given component workload, we do not know how to find the resource-efficient resource model yet. Our next step is to find the resourceefficient PRM for a given component workload under Q-CSF, which is called abstraction process. Theorem 1 checks the schedulability of a component when workload W and PRM Γ are given. Utilizing Equation (6) of Theorem 1, we present Algorithm 1 (an abstraction algorithm for Q-CSF), which computes the minimum-bandwidth schedulable PRM when workload W is given.
At a high-level view, Algorithm 1 computes the minimum Θ i to schedule the workload W for each task τ i , and it assigns the maximum of Θ i to Θ to schedule all tasks. In Lines 1-9, we consider each task τ i in workload W . In Lines 2-7, we consider each time interval t that is less than or equal to the deadline of the task D i . In Line 3, we compute the maximum requested resource demand y for task τ i and time t by the RBF function (Equation (1)). In Lines 4-6, we compute the minimum budget for the given τ i and t , which is denoted by Θ t i . To compute Θ t i , we consider two cases depending on the relation of RBF and iSBF. Because RBF is a step function and iSBF is a piecewise linear function, there exist two different cases for the minimum budget Θ t i that satisfy iSBF (Γ, t ) ≥ RBF (W, i, t ), as shown in Equation (6) of Theorem 1. In the first case, the requested resource demand y is divisible by Θ t i . In Line 4, we compute the budget for case 1, denoted by Θ 1 , as follows: which is illustrated in Figure 7(a). In the second case, the requested resource demand y is not divisible by Θ t i . In Line 5, we compute the budget for case 2, denoted by Θ 2 , as follows: which is illustrated in Figure 7(b). In Line 6, we set Θ t i to the minimum of Θ 1 and Θ 2 (computed in Lines 4-5) because either Θ 1 or Θ 2 can satisfy iSBF(Γ, t ) ≥ RBF(W, i, t ).
In Line 8, we set Θ i to the minimum value among Θ t i for all t because we only need any Θ t i ≤ T i that satisfies iSBF(Γ, t ) ≥ RBF(W, i, t ), as shown in Equation (6). In Line 10, we set Θ to the maximum value among Θ i for all τ i because Θ must satisfy ∃t ≤ D i , RBF(W, i, t) ≤ iSBF(Γ, t) for all τ i , as shown in Equation (6). In Line 11, we return the minimum-bandwidth schedulable Γ = (Π, Θ) with the Θ that is calculated through the algorithm.
We present the complexity of Algorithm 1. In Algorithm 1, we need to keep the value of Θ i for each task. Therefore, the space complexity is O(n) where n is the number of tasks. Next, we consider the time complexity of Algorithm 1: the number of for-loop in Line 1 is n and the number of for-loop in Line 2 is up to max(D i ). Therefore, the time complexity is pseudo-polynomial, O(nd) where d = max(D i ).

IV. EVALUATION
We evaluate our framework inside a single component (Section IV-B). We also evaluate our framework for an entire hierarchical systems having multiple components (Section IV-C). We also provide the detailed simulation results with numerical data, which is available online 7 .

A. SIMULATION SETUP
We compare Q-CSF with two versions of the original CSF [3], [7]: • Q-CSF: our proposed approach under quantumized platforms. • CSF [3], [7]: an original CSF approach with the realnumber resource model, which cannot be used in quantumized platforms. • CSF(ceil): CSF approach with the ceiling value of the real number resource model, which is a naive extension of the original CSF for quantumized platforms. For evaluation metrics, we consider the utilization of resource model and the interface overhead in the componentlevel simulation. The utilization of resource model can be calculated by ... The interface overhead can be calculated by the difference between the utilization of resource model and the utilization of component workload: U w − U Γ . In system-level simulation, we consider the acceptance ratio for evaluation metrics.
We describe simulation environment. We use a desktop computer with Intel i9 CPU with 32GB memory. Simulation code is written in Java language (simulation data generation and shedulability analysis) and Python language (drawing simulation result graph with python Matplotlib library 8 ). Our simulation workloads (task sets) is generated according to widely-used workload generation techniques [13], [16]. For a workload, we vary its utilization bound (U b ) from 0.3 to 0.7 in steps of 0.05, which results in 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, and 0.7. For a task, • Task period (T i ) is an integer that is uniformly drawn from [50, 300] unless specified. • Task deadline (D i ) is an integer that is uniformly drawn from [0.8 * T i , T i ]. • Task utilization (u i ) is a real number that is uniformly drawn from [0.002, 0.1] unless specified. • Task execution time (C i ) is calculated based on task period and task utilization:   We repeat the task generation until the utilization of the workload is larger than U b . Then, we discard the task added last.

B. COMPONENT-LEVEL SIMULATION
We evaluate the resource efficiency of Q-CSF in a component with a random workload (its generation is described in Section IV-A). Impact of Task Period. We evaluate Q-CSF for different task period ranges, which are periods uniformly drawn from [50, 200] (called small task periods), periods uniformly drawn from [200, 500] (called medium task periods), and periods uniformly drawn from [500, 1000] (called large task periods). The number of workloads for each data point is 3, 000 workloads and the number of total workloads is 81, 000, which is computed as 3000 × 9 × 3. Figure 8 shows the average utilization of the resource model for the random component workloads varying the utilization bound U b for different ranges of the task period. The required utilization of the CSF(ceil) is 6.92% larger than the CSF in the worst case. However, the required utilization of Q-CSF is only 1.18%, 0.48%, and 0.26% larger than the CSF in small, medium, and large task periods, respectively. For the current quantum-based hardware platform, the CSF that supplies a fractional unit of resources is not directly applicable. Hence, the Q-CSF supplying an integer unit of resources is more resource-efficient than the CSF(ceil).
To analyze the results of the simulation (Figure 8) in detail, we present Figure 9, which shows the average interface overhead. We observed that the interface overhead of CSF(ceil) is 35.25% larger than CSF in the worst case. However, the interface overhead of Q-CSF is only 4.87%, 2.15%, and 1.20% larger than CSF in small, medium, and large task periods, respectively. We observed that the interface overhead increases with the relatively smaller task periods. Q-CSF reduced the interface overhead of CSF(ceil) by up to 86.16%. Impact of Task Utilization. We evaluated the Q-CSF for different distribution of task utilization: one uniform distri-bution (uniformly over [0.002, 0.1]) and three bimodal distribution (uniformly over either [0.002, 0.05] or [0.05, 0.1]), with respective probabilities of 8/9 and 1/9 (light), 6/9 and 3/9 (medium), and 4/9 and 5/9 (heavy). The number of workloads for each data point was 3,000 and the number of total workloads is 108,000, which is computed as 3000 × 7 × 4. Figure 10 shows the average interface overheads of resource models for the random component workloads varying the utilization bound U b for different distribution of task utilization. We observed that the interface overhead of CSF(ceil) is 42.42% larger than CSF in the worst case. However, the interface overhead of Q-CSF is only 1.43%, 1.22%, 1.33% and 1.45% larger than the CSF in uniform, bimodal (light), bimodal (medium), and bimodal (heavy) distributions, respectively. Regardless of distribution, Q-CSF shows similar overheads. Q-CSF reduced the interface overhead of CSF(ceil) by up to 96.58%.

C. SYSTEM-LEVEL SIMULATION
To evaluate the Q-CSF in hierarchical scheduling systems, we consider a two-level hierarchical scheduling system with multiple child components: the system schedules child components using the DM scheduler and each child component schedules its own workload (task set) using the DM scheduler. Similar to Section IV-B, we randomly generate workloads (two-level hierarchical scheduling systems). For each system, we we vary its utilization bound (U b ) from 0.55 to 0.90 in steps of 0.05, which results in 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, and 0.90. For a component C j , • Component utilization (λ j ) is a real number uniformly drawn from 0.05, min(0.3, U b − λ j ) . • We repeat the process to generate a task (using the default parameters from Section IV-B) until the utilization of the task set is larger than λ j . • Then, we discard the task added last. We repeat the process to generate a component until the sum of the utilization of child components is greater than U b − VOLUME 4, 2016 Theory Practicality Description Shin and Lee [3], [7] the very first work for component-based scheduling theory Bini et al. [17] abstraction methods for different service mechanisms for multiprocessor platforms Shin et al. [18] a method to minimize the utilization of clusters for multiprocessor cluster systems Gu et al. [19] CSF extension to mixed-criticality systems Yang et al. [20] a new notion of budget-based mixed-criticality scheduling Easwaran et al. [15] an explicit deadline periodic resource model Kim et al. [21] elimination of abstraction overhead Chen et al. [22] a new interface abstraction for both schedulability and associativity RT-Xen [12] real-time Xen virtualization without theory support Lee et al. [13] RT-Xen extension to support CSF theory This Q-CSF a new CSF theory considering quantum-based platforms, e.g., RT-Xen We evaluate the Q-CSF for different component periods: two identical periods, Π = 25 and Π = 50, and one random period, which is uniformly drawn from [25,75]. The number of workloads for each data point is 3,000 and the number of total workloads is 72,000, which is computed as 3000×8×3. Figure 11 shows the average acceptance ratio of the resource model for the random systems varying the utilization bound U b for different component periods. We observed that the difference of the average acceptance ratio between CSF and CSF(ceil) is 0.436 in the worst case. However, the average acceptance ratio of Q-CSF is close to CSF: the difference of the average acceptance ratio between CSF and Q-CSF is only 0.022, 0.030, and 0.024 in a small component period (Π = 25), a large component period (Π = 50), and a random component period, respectively. We observed that Q-CSF has up to 0.44, 0.18, and 0.20 better acceptance ratio than CSF(ceil) in a small component period, a large component period, and a random component period, respectively. For the larger component period, the difference of acceptance ratio among three approaches is small. However, for smaller component period, Q-CSF is much better than CSF(ceil) and close to the ideal CSF. For random component period, the trend is similar to the case of the smaller component period.

V. RELATED WORK
Beginning with the seminal work of Shin and Lee [3], [7], scheduling theory for the component-based real-time systems was extensively studied in various domains. Pertaining to multiprocessor platforms, Bini et al. [17] proposed abstraction methods for different types of service mechanisms such as periodic servers, static partitions, and the fluid-based time partitions. Additionally, Shin et al. [18] targeted cluster-based real-time systems and proposed a compositional scheduling algorithm that minimizes the utilization of individual clusters. Regarding mixed-criticality systems, Gu et al. [19] tried to overcome the shortcomings of the common assumption of mixed-criticality systems that all high-criticality tasks require additional computing resources simultaneously at a mode transition. To these ends, they proposed parameters to model the expected number of high-critical tasks simultaneously while demanding more resources and incorporating them into the compositional scheduling model for better resource usage. Yang et al. [20] introduced a new notion of budget-based mixed-criticality scheduling for component-based real-time systems.
For practicality, a few studies have focused on minimizing the abstraction overhead of component-based scheduling. Easwaran et al. [15] proposed an explicit deadline periodic resource model that applied the notion of a deadline to an existing periodic resource model to reduce the abstraction overhead. Furthermore, Kim et al. [21] attempted to eliminate abstraction overhead associated with the resourcesupply and resource-demand. Chen et al. [22] identified some important properties of component-based real-time systems and proposed a new interface abstraction and composition framework to achieve both schedulability and associativity.
As system virtualization mechanisms have been developed [23], a several component-based scheduling mechanisms have been proposed to support virtualized real-time systems. RT-Xen [12] received a considerable attention, owing to its simplicity and efficiency in terms of system implementation and computing-resource utilization. The first version of RT-Xen did not support the component-based scheduling theory, and the study of Shin and Lee [3] was limited in that it did not consider a scheduling quantum. To overcome these shortcomings, Lee et al. [13] improved RT-Xen to consider the notion of time quantum while applying component-based scheduling theory. However, there exists the resource inefficiency in previous work in [13] due to rounding up the real-number of resource as quantum values. In this paper, we aim at relieving such limitations with a novel SBF, scheduling analysis, and component interface calculation methods for real digitalized hardware platforms.

VI. CONCLUSION
The compositional scheduling framework is an effective paradigm to supports real time properties in componentbased embedded systems. However, it is not directly applicable to real quantumized hardware platforms due to lack of consideration on quantumized resouce allocation. In this study, we proposed quantum-aware compositional schedul-ing framework, Q-CSF, to address the issue of time quantum in real digitalized hardware platforms. We present integerbased supply bound function (iSBF) to allocate resource for quantumized platforms. We also present schedulability analysis and interface computation algorithm under Q-CSF. In simulation results, we showed that Q-CSF has only a 4.8% overhead in component-level experiments and an up to 0.026 smaller acceptance ratio in system-level experiments, compared with theoretical CSF approaches.
In future work, we would like to investigate time quantum issue on multiprocessor component-based systems and mixed-criticality component-based systems.