A gravitational task model for target sensitive real-time applications

Transcription

1 A gravitational task model for target sensitive real-time applications Raphael Guerra, Gerhard Fohler Technische Universität Kaiserslautern, Germany Abstract The commonly used task models for real-time systems focus on execution windows expressing earliest start times and deadlines of tasks for feasibility. Within these windows, execution of tasks is considered of uniform utility. Some applications, however, have target demands in addition: a task should be executed at a target point in time for maximum utility, but can execute around this point, albeit at lower utility. Examples for such applications include control and media processing. In this paper, we present a gravitational based task model to address these issues. Tasks are considered as massive bobs hanging on a pendulum: a single task, left to itself, will execute at the bottom, the target point. If a force, such as the weight of other tasks, is applied, it can be shifted around this point. Thus, tasks importance and their utility around target points can be expressed. Additionally, we show a scheduling example of how this model can be used to find the best compromise of tasks interests based on the equilibrium state of a pendulum. Nonetheless, this task model is not restricted to a particular scheduling algorithm. Results from a simulation study show the effectiveness of the approach. 1 Introduction Real-time systems are fundamentally concerned with satisfying timing constraints of applications. Traditionally, deadline has been the major concern. However, deadlinebased timeliness criteria fail to capture the utility of activities when they can vary as a function of the time of execution. Furthermore, it imposes that this utility is directly related to the urgency of the application [7]. With traditional task models, a job is able to express a time interval (execution window) where it is allowed to execute: the util- The work presented in this paper has been supported in part by the EU IST project FRESCOR (FP6/2005/IST/ ) ity of executing anywhere within the execution window is considered to be the same. Some applications have target sensitive constraints: their jobs have a target point at which execution results in highest utiliy. The time of execution of their jobs accept a certain degree of flexibility around their target point, albeit at lower utility. In a classic task model, target sensitivity can be enforced by tightening the deadline, at the expense of decreasing the maximum feasible utilization. Let us consider two examples of applications that are sensitive to the time of execution: media processing and control systems. High quality media processing, such as for consumer electronics, is time-constrained because frame display has to be done periodically at fixed points. Frame buffering is not an option in these applications [5], time variation frame display has bad impact on the perceived quality of the video [4]. With traditional task models, the periodicity of the frame display is enforced by tight start times and deadlines; deadlines alone would allow too early execution. However, if the decoding takes too long and cannot be completed by its deadline, the whole frame has to be skipped or the deadline extended. Enlarging the deadline of the frame decoding, in general, introduces time variation in the frame display. However, the perceived quality may be higher if the frame is displayed with a small delay, rather than not at all, but only when this delay is small and its utility clear. Therefore, multimedia applications can benefit from a target sensitive task model. In control theory, sampling and actuation should be performed instantaneously at target points, which is not possible in real computing systems. Besides, computer controlled systems are traditionally implemented using realtime periodic tasks that have to run under the constraint of scarce resources. Although ideally all activities should be executed in their target points, shifting them a little bit can acceptable, provided system response remains acceptable. However, this variation in the execution of the control tasks degrades the controller quality and QoS guarantees need to be given. Depending on the conditions of the system, this variation might lead to a total failure of the application [8]. The sensitivity to the target execution point here is even

2 more severe than in the multimedia case. When more than one job want to execute at the same time, finding the best compromise between their interests is not trivial. Approaches based on time utility function (TUF) [10] can express the importance of jobs but are not able to find the best compromise among them. This problem gets even harder when we consider the interaction among several jobs with different importances. Our solution to this problem is based on a physical system: the pendulum; it is an object that is attached to a pivot point and can swing freely. The rest position of a single object in a pendulum is the central point. An object placed in this position will not swing, and the system is said to be in an equilibrium state. If there is more than one object, they will push each other aside and their rest position will depend on their relations between weight and size. The heavier an object is, the stronger is the force that drags it to the central point. We consider jobs as objects in a pendulum and the target points as the central point. Then, the equilibrium state of the physical problem gives us the best compromise between the jobs interests. We call our model gravitational task model. The gravitational model is able to express job utility as a function of time, which extendes the traditional deadlinebased timeliness criteria. These task models lack the mechanisms to allow a task to express the best compromise between time utility and system utilization. Since the target point can only be enforced by tightening the deadline, the feasibility of the task set is over-constrained. In the gravitational task model, a job can express its target point, yet providing some flexibility to shift around based on its importance and the effects on utility of such deviation. Therefore, jobs can actually execute at their target points when the system is idle without the need of tight deadlines. Under overloaded conditions it allows to determine the best compromise among their interests. Furthermore, we can find the best compromise with linear complexity for a chain of jobs. The rest of this paper is organized as follows: section 2 will describe some relevant previous works in the field; section 3 will describe in detail our proposed task model and how it was derived based on the pendulum analogy; section 4 will describe how to schedule the tasks exploiting all properties of the gravitational task model; section 5 brings simulation results that assess our work; and, finally, section 6 draws the conclusions. 2 Related work Work presented in literature investigates ways to provide different QoS levels to real-time applications in a system. The basic idea of them is to maximize the task acceptance by relaxing their time constraints. In this direction, [3] proposes a scheduling based on time utility functions to define the order to execute the tasks. The scheduler uses an heuristic to find an ordering on average close to the optimum in O(n 3 ) assuming any kind of utility function and no idle cycle between the tasks. In [11], the same problem is solved in O(n 2 ) assuming only non-increasing TUFs. The result is used in ethernet packet scheduling. The idea is that the utility of a packet only decreases the later it reaches the destination. This work is extended in [12] and [6] to support variable cost functions and mutual exclusion of resources, respectively. However, these methods do not consider the exact point of execution to maximize the system utility, only the task ordering. In [9], an utility function based approach to express the importance of tasks in order to assign resources to them is proposed. The proposal is very broad, since it covers every resource that a task might need, but no scheduling method is presented. It investigates how utility functions could be used to solve it. The gravitational task model complements it as we can express and apply the utility functions explained there. In systems with deadline-based timeliness criteria, earliness-tardiness schedulers [1] associate a penalty to how early and how late a job finishes its execution with respect to its deadline and minimizes the overall penalty of the system. A drawback of this approach is that tasks are actually allowed to miss their deadlines. The elastic scheduling of [2] presents a method that improves the acceptance of tasks in overload situations. In order to accept an task, it increases the period size of periodic tasks to reduce the utilization of the system based on a spring system analogy. This work only considers the deadline and the size of periods as time constraints. Elastic scheduling and graviational task model can complement each other: elastic determines execution windows, which the gravitational model can use as input. 3 Gravitational task model In this paper, we assume non-preemptive jobs j i with earliest start time est i, relative deadline dl i, worst case execution time WCET i, target point tp i and importance imp i. We assume the target point in the middle of the execution window and the same flexibility to be shifted to the left or to the right. A task is allowed to express an utility decay as a function of the distance to the target point. Jobs can be instances of recurring tasks or not, and they are ordered according to their target points. Finally, the importance represents the flexibility of a job to be shifted away from its target point when interacting with other jobs (the importance is proportional to the need of the job to execute at its target point). Our model is based on a pendulum analogy. Nonetheless, if we are not able to directly map the real-time system into the pendulum, as we will see later in this section. So,

3 first we explain what is a pendulum and the basic idea of the pendulum analogy. Then we point out the issue that prevents its direct mapping to the real-time system and the actual solution. 3.1 Inspiration from physics A pendulum is an object attached to a pivot point that can swing freely. A basic example is the simple gravity pendulum or bob pendulum. As depicted in figure 1, it consists of a bob at the end of a massless string, which, when given an initial push, will swing back and forth under the influence of gravity over its central (lowest) point in a circular trajectory. Placed in the lowest point, the bob will rest there (rest position). If the bob pendulum contains more than one bob, they cannot be all at the same time in the lowest part, and hence, will push each other aside to find a new rest position. It is said that the system is, then, in an equilibrium state. How far from the central point a bob will rest depends on its weight and the size of the other bobs. the equilibrium condition is reduced to make the sum of all torques zero. This condition is expressed in equation system 1, where the first equation expresses that all bobs are in touch with each other and the second equation expresses that no bob is swinging. Since all bobs are in touch, the angle θ i between two consecutive bobs is constant and can be found as a function of the radii (see equation 2). Its solution is given in equation 3, where α 1 is the angle of the first bob in the equilibrium state. The position of all the other bobs can then be calculated using the first equation of equation system 1. As we can see, the complexity to calculate the equilibrium state is linear with the number of bobs. { α 1 α i = i j=2 θ j 1, i =2..N F (1) i (R r i )=0 cos(θ i )= (R r i) 2 +(R r i+1 ) 2 (r i + r i+1 ) 2 2(R r i )(R r i+1 ) tg(α 1 )= P i (R r i ) sin ( i j=2 θ j 1 (2) P ( i ) (3) i (R r i ) cos j=2 θ j 1 ) 3.2 Analogy pendulum-task model Figure 1. Bob pendulum task set analogy The pendulum system depicted in Figure 2 consists of N bobs with radius r i, weight W i, hanging by massless strings of length R r i with a trajectory of radius R. The angle θ i between two consecutive bobs is constant and can be calculated as a function of the radii of the bobs and length of the strings, as shown in equation 2. The equilibrium state of a system is defined as the state when the sum of all torques and forces in the system are zero. The torque of a bob is the component of its weight perpendicular to the string ( F i ) multiplied by the length of the string (R r i ). These conditions assure that the system is neither spinning nor translating, respectively. However, in a pendulum system no translation is possible, so We now draw the analogy between the bob pendulum and a real-time task set. A bob can be placed at any point of the circular trajectory in the swinging range, but due to the weight effect it is dragged to the central (lowest) point. This point is the target of the bob, where it will rest unless other forces are present in the system. In a similar way, a job can be executed at any time within its execution window, but it will execute in its target point unless other jobs interfere with it. If the bob pendulum contains more than one bob, they will push each other aside. Their rest position in the equilibrium state depends on the weight and size of each bob. Just like two bobs cannot be at the same place at the same time, two tasks cannot be executed at the same time. So, the importance of a job has a property similar to the weight of a bob: the more important a task is, the closer to its target point it has to be executed, hence pushing other tasks execution away. Finally, the size of a bob is equivalent to the WCET of a job. This analogy is depicted in Figure 1 and summarized in Table 1. There is an issue with the analogy that prevents a direct mapping of the pendulum to the task model. As can be seen in figure 2, if we consider jobs represented by the projection of bobs over a straight line tangent to the swinging trajectory (equivalent to the timeline), overlapping occurs. A direct mapping from bob size to the WCET of a job would lead to a situation where parts of different jobs would have to execute at the same time.

4 pendulum bob weight swinging range central point equilibrium state task set task importance execution window target point best compromise Table 1. Bob pendulum analogy. Figure 3. Multiple targets particle analogy. Figure 2. The overlapping issue pendulum task set particle beginning of a job execution weight importance swinging range execution window - WCET pivot point target point bob distance WCET equilibrium state best compromise Table 2. Particle pendulum analogy. In order to overcome the overlapping problem, we change the first constraint of equation system 1. Instead of assuming the angle θ i between two consecutive jobs as constant, we consider that the distance d i between the projection of their centers over the tangent line is constant. The final analogy is depicted in figure 3. In this analogy, we consider a job as a particle (a massive dot) instead of a rigid body (previously a bob). We have to decide which part of the execution interval the target point corresponds to, because the execution of a job is an interval of time, while the target point is an instant in time. Nonetheles, this is an implementation decision and does not affect the main idea of the scheduling algorithm. Our decision was to assign the beginning of the job execution to the target point. Thus, the distance d i corresponds to WCET i and R i is equal to (dl i WCET i )/2. (dl i WCET i ) is the new swinging range, since it is the interval within the execution window where a job can start to execute being able to complete before its deadline. The target point is the projection of the pivot point (P i ), hence jobs with different target points are compared to particles hanging on different pivot points. The new analogy is summarized in table 2. 4 Scheduling An example in this section will explain how to schedule tasks using the gravitational task model so that the best compromise between the tasks interests is found. For the sake of simplicity, we will first explain the scheduling algorithm assuming that all tasks have the same target point, though different execution windows. Then we extend the solution to cover tasks with different target points. Finally, we will explain the on-line acceptance of jobs and illustrate the scheduling with an example. 4.1 All jobs with the same target point The best compromise among the jobs interest is given by the equilibrium state of the particle pendulum analogy. In order to adress the new distance constraint between two particles we change the first equation of equation system 1, obtaining equation system 4. In this new equation system, the term R i sin(α i ) represents how much a job is shifted away from its target point in the tangent line (see figure 3).

5 { Ri+1 sin(α i+1 ) R i sin(α i )=d i, i =1..N 1 F i (R r i )=0 (4) After a few algebraic steps in the first equation we reach the result in 5. R i sin(α i ) = R i+1 sin(α i+1 ) d i = R i+2 sin(α i+2 ) d i d i+1... = R N sin(α N ) j=i d j (5) Finally, replacing (5) in the second equation of the equation system 4, we reach the result in equation (6). R N sin(α N ) is the shift of the last particle from its target point. As we can see, the complexity to compute the equilibrium state remains linear. N F i R i =0 N W i sin(α i ) R i =0 W i sin(α i )R i + W N sin(α N )R N =0 W i (R N sin(α N ) j=i d j )+ W N sin(α N )R N =0 particle in equation (6), we normalize it to the size of the string (R i ), hence obtaining W i =2 importance i /(dl i WCET i ). Using equation (6) makingr i =(dl i WCET i )/2, d i = WCET i and W i =2 importance i /(dl i WCET i ), we find the best compromise for the task set. R N sin(α N ) represents the shift of job j N from its target point. In this calculation, we assume that if a job is on the right side of its target point, its angle α i and the shift are positive; otherwise, the value is negative. The scheduling is said to be feasible if, in the equilibrium state, sin(α i ) <= 1for all jobs j i. In other words, no job misses its deadline. 4.2 Jobs with different target points As mentioned in the analogy section, jobs with different target points are compared to particles hanging from different pivot points. The only difference, in this case, in the equilibrium condition is that now we have d i = R i+1 sin(α i+1 ) R i sin(α i )+(P i+1 P i ),where(p i+1 P i ) accounts for the distance between the pivot points. If the particles have the same pivot point, we have the same condition as before. With this new condition, equation (5) becomes R i sin(α i )=R N sin(α N ) 1 j=i (d j) P i + P N,and the solution to the equilibrium state using this condition is shown in equation (7). The analogy described in the previous section remains the same, but now we have the term P i that accounts for the target point of job j i (tp i ). Given that we assume the target point as the instant when the job starts its execution, that a job has to start its execution at least WCET units of time before its deadline and that its in the middle of its feasible range, we have that tp i = est i +(dl i WCET i )/2. The equations that translate one environment into the other are summarized in table 3. W i ( j=i d j )+ R N sin(α N )= N W i sin(α N )R N =0 1 W i ( 1 j=i d j ) W i A question to be answered is how to map task importance into particle weight. In a particle pendulum environment, two particles with the same weight hanging by strings of different lengths are not pushed aside evenly. In fact, the particle hanging by the longer string creates a bigger torque, hence moving closer to the target point. However, in a real-time system environment, two jobs with the same importance and different execution windows should be treated evenly when pushing each other. In order to achieve this, when mapping the importance of a job to the weight of a (6) 1 R N sin(α N )= W i ( 1 j=i (d j)+p i P N ) W i (7) This equation can be solved with linear complexity with respect to the number of jobs if we compute initially j=1 (d j) and then, for every iteration of the outer sum, we just subtract d i from it. pendulum task set W i 2 imp i /(dl i WCET i ) R i (dl i WCET i )/2 P i tp i d i WCET i Table 3. Equations.

6 It is important to point out, though, that equation (7) can be used only given that there is no idle period between two consecutive jobs in the equilibrium state. We call it a chain of jobs. It was not an issue when we aasumed all particles hanging from the same pivot point, since in this case all jobs will definitely push one another aside. Finding these idle periods is out of the scope of this work. Here we overcome this issue by simply adding jobs one by one in their scheduled order and recomputing the equilibrium state. So, if the currently added job pushes another job, we recompute the equilibrium state for this chain of jobs. If there are n chains of jobs in the current schedule, notice that it is possible that after adding a job in the last chain a ripple effect might happen. In this case, adjacent chains are considered as one chain and its equilibrium state is recomputed. While the complexity of the equilibrium fomula is linear, the complexity of the idle period detection algorithm is O(N 2 ) with respect to the number of jobs. 4.3 On-line job acceptance A job that arrives on-line is ordered with the other jobs according to its target point and allowed to execute unless another job is already scheduled to execute in the same position. In this case, we have to find a new equilibrium state. A restriction is that the currently executing job cannot be pushed backward, i.e back in time. In this situation, the importance of the incoming task normalized to the string length is used as a force. It will be allowed to execute only if its force is sufficient to push aside all jobs scheduled ahead of it. Once it is fit somewhere, it can be treated as any other job in the particle pendulum analogy (with a string of length R, weight W, and so on). This way, another on-line job that arrives in the system will not have to distinguish between previously scheduled jobs and on-line jobs when trying to push them aside. If an on-line job pushes scheduled jobs beyond their execution windows, we can either assume that the on-line job is more important than the other jobs and drop them or do not accept the incoming job, since the system has already committed to execute the previously scheduled ones. The complexity of the online admission is, hence, linear with the number of jobs being pushed. The pushed jobs can be easily found, since we know the computational demand of the incoming job and, hence, how far jobs should be pushed forward. 4.4 Example Consider the task set shown in Table 4. Within the first hyperperiod ([0, 12]), we have the following jobs ordered by target point: τ 1,1, τ 2,1, τ 3,1 and τ 1,2,whereτ i,j represents the j th instance of task τ i. Given this order, we now refer to them as jobs j 1, j 2, j 3 and j 4, respectively. Their target points are 2, 2.5, 4 and 8, respectively. Following the algorithm described in section 4.2 to determine the equilibrium point, we first place j 1 at time 2. Then we get j 2 and try to put it at time 2.5, butj 1 finishes its execution at time 4, so we have to find the equilibrium state for them. We want to compute R 2 sin(α 2 ), given that W 1 =2 imp 1 /(dl 1 WCET 1 )=2 1/(6 2) = 0.5, W 2 =2 10/(6 1) = 4, P 1 = tp 1 =2, P 2 =2.5, d 1 = WCET 1 = 2 and d 2 = 1. Using these values in Equation 7, we get that R 2 sin(α 2 ) = So, R 1 sin(α 1 )=R 2 sin(α 2 ) d 1 P 1 + P 2 = So,j 1 is shifted 1.25 units of time to the left and j 2 is shifted 0.25 units of time to the right of its target point, hence being scheduled to execute at times 0.75 and 2.75, respectively. Then we schedule j 3 at time 4 and no job is pushed, since j 2 finishes at time Finally, we schedule j 4 at time 8 and no job is pushed, since j 3 finishes at time 8. This scheduling is depicted in figure 4. τ 1 τ 2 τ 3 start time period deadline WCET importance Table 4. Task set. Figure 4. Scheduling before on-line job arrival. Now suppose that an on-line job j a arrives at time 3 with deadline 10, WCET 2 and importance 2. Its target point will

7 be 7 and if we recompute the equilibrium state we will have job j 1 executing at time 0.45, j 2 at time 2.45, j 3 at time 3.45, j 4 at time 9.45 and the incoming job at time However, it means that j 2 is pushed back, which is not allowed since it is currently being executed. j 3 can be shifted from 4 to 3.75 but no further, and hence, the incoming job applies its force to push j 4 forward. j 4 has to be pushed to time At this position, F 4 = W 4 sin(α 4 )= 2 imp 4 /(dl 4 WCET 4 ) 1.75/R 4 = The force of j a is 2 imp/(dl a WCET a )=4/8 =0.5, hence enough to push j 4 forward. So, j a is accepted and the new scheduling for jobs that did not start yet is: j 3 at time 3.75, j 4 at time 9.75 and the incoming job at time Thefinal scheduling with the pendulum analogy is depicted in figure 5. average deviation Grav Task Model with deadline=period EDF with deadline=period EDF with deadline=0.5*period EDF with deadline=0.35*period task set utilization Figure 6. Average deviation to the target point. Figure 5. Scheduling after on-line job arrival. the results depicted in figure 6, we can see that tightening the deadline of the tasks in EDF leads to a smaller deviation. As we constrain the deadline restriction under EDF, the number of feasible task sets decreases drastically. Moreover, the curve for deadline of 50% of the period under EDF stops for task set utilization of 70% and the curve for deadline of 35% of the period stops for a task set utilization of 50%. The reason is that if there is no feasible task set in a given category or the fraction of feasible task sets is very small or zero, the result is meaningless. As it can be seen in figure 7, the acceptance ratio of task sets scheduled with EDF is close to zero or zero for task sets with utilization greater than 70%, when the deadline is 50% of the period, and for task sets with utilization greater than 50%, when the deadline is 35% of the period. 5 Evaluation In order to assess our method, we performed simulations that compare it to EDF with different configurations. In our setup, we vary the system utilization in the range [0.1, 0.9] with granularity 0.1. For each utilization, our results are the average of 1000 different task sets. Each task set is composed of 5 periodic tasks with period and importance uniformly distributed in the interval [1, 10] with earliest start time 0. The computation times are randomly chosen so that the generated task set has the desired utilization. Here, we present only representative results of the experiments. In a first experiment, we measured the average deviation of the jobs s execution to their target points for task sets with different utilization. For this experiment, we consider only the feasible task sets for a given system utilization. In acceptance ratio Grav Task Model with deadline=period EDF with deadline=0.5*period EDF with deadline=0.35*period% task set utilization Figure 7. Task sets acceptance ratio.

8 In the second experiment we show, for each task set utilization category, the fraction of task sets that have an average deviation from the target point less than or equal to 0.3. As we can see in the graph depicted in figure 8, the tighter the deadline is, the greater the number of task sets within the desired range of average deviation are. Notice that for EDF, the number of tasks in this range increases as the utilization increases. It happens because under low utilization EDF simply schedules the task to execute as early as possible. We can see from the curves for EDF that tight deadlines significantly improve the average deviation, but our method with the gravitational task model outperforms EDF with a great range of advantage, even when the deadline for EDF is very short. fraction of task sets Grav Task Model with deadline=period EDF with deadline=period EDF with deadline=0.5*period EDF with deadline=0.35*period task set utilization Figure 8. Fraction of task sets scheduled with average deviation to the target point <= Conclusion In this paper, we have introduced a new task model inspired by a pendulum exposed to gravitation. Unlike traditional task models, which do not distinguish at which point a task executes, as long as it is within the start time-deadline window, the gravitational task model allows to express a distribution of utility. A job can express a point of highest utility, called target point, at which it accrues highest utility. Executing somewhat before or after is feasible, but at lower utility. Application examples include media processing and control. Traditional task models can achieve similar results only in part and at the expensive of flexibility or feasibility, as it was shown in our simulation results. In the gravitational task model, we relate tasks as massive particles hanging on a pendulum: the weight of the particle expresses the tasks importance, the distance execution time, and swinging range execution window. In the equilibrium state, the weight of the particles determines their offset from the central point of the pendulum, which relates to the distance of the jobs from the target points. Thus, more important jobs (heavy particles) will move less important ones. The equilibrium state expresses the compromise between the jobs importance. Therefore, the gravitational task model can be used to express target points without compromising flexibility or feasibility, as well as to express the importance of jobs and to determine tradeoff points among them. We outline the application of the task model for scheduling tasks with different importance and for aperiodic task guarantees. These serve as example only, the gravitation model is not bound to a particular scheduling algorithm. We present results of a simulation study which show effectiveness of the model to reduce deviation from target points, using EDF scheduling as reference. The scheduling algorithm presented here serves as illustration for the application of the gravitational task model only. We plan to study this applicability for further algorithms and possibily to develop new algorithms. Next steps include explicit consideration for full preemption, definition the best task ordering and support for other utility functions than the circular one obtained from the pendulum analogy. 7 Acknowledgment The authors wish to express their gratitude to Sanjoy Baruah for the positive discussions and comments on earlier versions of the work presented in this paper. Many thanks to the members of the real-time systems group at TU Kaiserslautern for the good discussions and reviewing of the paper, notably Alexander Neundorf, Ramon Sierna Oliver and Anand Kotra. Special thanks also to Sebastian Reyes for his kind support on the physical model. The authors acknowledge furthermore the interesting discussions with Scott Brandt and the comments of the reviewers of this paper. References [1] Kerem Bülbül, Philip Kaminsky, and Candace Yano. Preemption in single machine earliness/tardiness scheduling. J. of Scheduling, 10(4-5): , [2] Giorgio C. Buttazzo, Giuseppe Lipari, Marco Caccamo, and Luca Abeni. Elastic scheduling for flexible workload management. IEEE Transactions on Compututer, 51(3): , [3] Ken Chen and Paul Muhlethaler. A scheduling algorithm for tasks described by time value function. Real- Time Syst., 10(3): , 1996.

9 [4] Mark Claypool and Jonathan Tanner. The effects of jitter on the perceptual quality of video. Proc. ACM Multimedia 99(Part 2), pages , [5] Damir Isovic, Gerhard Fohler, and Liesbeth F.M. Steffens. Timing constraints of MPEG-2 decoding for high quality video: misconceptions and realistic assumptions. In 15th Euromicro Conference on Realtime Systems (ECRTS 03), Porto, Portugal, July [6] Peng Li. A utility accrual scheduling algorithm for real-time activities with mutual exclusion resource constraints. IEEE Trans. Comput., 55(4): , Member-Haisang Wu and Senior Member- Binoy Ravindran and Member-E. Douglas Jensen. [7] Peng Li, Binoy Ravindran, and E. Douglas Jensen. Adaptive time-critical resource management using time/utility functions: Past, present, and future. In COMPSAC 04: Proceedings of the 28th Annual International Computer Software and Applications Conference - Workshops and Fast Abstracts - (COMP- SAC 04), pages 12 13, Washington, DC, USA, IEEE Computer Society. [8] Pau Marti, Gerhard Fohler, Krithi Ramamritham, and Josep M. Fuertes. Jitter compensation in real-time control systems. In Proceedings of the 22nd IEEE Real-Time Systems Symposium, London, UK, Dec [9] D. Prasad, A. Burns, and M. Atkins. The valid use of utility in adaptive real-time systems. Real-Time Syst., 25(2-3): , [10] Binoy Ravindran, E. Douglas Jensen, and Peng Li. On recent advances in time/utility function real-time scheduling and resource management. In ISORC 05: Proceedings of the Eighth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC 05), pages 55 60, Washington, DC, USA, IEEE Computer Society. [11] Jinggang Wang and Binoy Ravindran. Time-utility function-driven switched Ethernet: Packet scheduling algorithm, implementation, and feasibility analysis. IEEE Trans. Parallel Distrib. Syst., 15(2): , [12] Haisang Wu, Umut Balli, Binoy Ravindran, and E. Douglas Jensen. Utility accrual real-time scheduling under variable cost functions. In RTCSA 05: Proceedings of the 11th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA 05), pages , Washington, DC, USA, IEEE Computer Society.