Imprecise Task Scheduling and Overload Management using OR-ULD J¨orgen Hansson Dept. of Computer Science Link¨oping University Sweden
[email protected]
Marcus Thuresson Omicron Ceti AB Kista Sweden
[email protected]
Abstract This paper evaluates the OR-ULD (Overload Resolution using Utility Loss Density) algorithm for imprecise computation workloads, where tasks are decomposed into one mandatory task and one optional task. OR-ULD is a valuedriven overload resolution algorithm running in O(n log n) time, where n is the number of tasks. The algorithm is invoked only in case of transient overloads. By representing error using value-functions, we get a general model for representing quality tradeoffs. Our performance studies show that, OR-ULD overall performs better than the MF (Mandatory First) algorithm in reducing the total error and the total weighted error. In addition, OR-ULD minimizes the number of discarded optional tasks. The approach provides the flexibility that enables multiple strategies to be used to resolve overloads, e.g., overloads may be resolved by replacing transactions with contingency transactions, and non-critical regular transactions may be dropped or postponed. Keywords: imprecise computation, overload management, scheduling, total error
1 Introduction It is not always possible to schedule every task so that it meets its deadline. This phenomenon is called a transient overload and represents a system state where the requests for service exceeds available resources for a limited time causing missed task deadlines. Transient overloads may occur when faults in the computational environment reduce computational resources available to the system, or when emergencies arise. Since new tasks may arrive at run-time and since schedulers in dynamic real-time systems are not clairvoyant, dynamic real-time systems are prone to tran-
Sang H. Son Dept. of Computer Science University of Virginia Charlottesville, USA
[email protected]
sient overloads. In hard real-time systems it is of outmost importance that all deadlines are met; a missed deadline results in system failure. Since no lateness is allowed there exists an implicit requirement that worst-case execution time and worst-case arrival rates must be used when scheduling tasks with critical time constraints. In firm real-time systems deadlines should be met but occasional violations are acceptable and do not lead to any damage in the environment. A result that is produced too late, i.e., after its deadline, is however of no value to the system. One proposed technique to resolve transient overloads in real-time systems is the imprecise computation model [13, 10, 12, 8]. The proposed technique gives the user an imprecise and approximate result of acceptable quality while important time constraints are met during transient overloads. The imprecise computation model can be utilized in a wide variety of applications areas, e.g., databases, networking, machine vision, signal processing, and dependability in real-time systems. Hansson et al. [5, 3] proposed a strategy for resolving transient overloads by reallocating resources among tasks that have been admitted to the system. A utility-loss density driven overload resolution algorithm (OR-ULD — Overload Resolution using Utility Loss Density) was defined. The algorithm dynamically resolves transient overloads, in real-time database systems using the proposed strategy. In that work hard real-time transactions have a contingency action that requires fewer resources and less time than the original transaction. When an overload occurs, non-critical transactions are discarded in a controlled way, and hard transactions are replaced with their contingency action, ensuring the timeliness of hard deadlines. In this work we evaluate the applicability and efficiency of OR-ULD for imprecise task workloads, as defined by Shih et al. [13] and Liu et al. [10]. The problem addressed is overload management of sporadic preemptable imprecise
di deadline of task i , i.e., the time at which the execution of the task should be finished;
tasks under transient overloads. In this context, we conduct a simulation-based performance analysis of the OR-ULD algorithm. The performance of OR-ULD is compared to a baseline and two reference algorithms: MF (Mandatory First) [6] and EDF (Earliest Deadline First) [9]. Kim et al. showed that MF has higher schedulability than OAR (Online tasks with Arbitrary Ready times) [7] and NORA (No Off-line tasks and on-line tasks Ready upon Arrival) [12]. Moreover, MF and OAR have similar behavior, producing schedules of comparable quality. EDF is chosen as a reference algorithm since its behavior is well-known. Overall, simulation results show that OR-ULD performs better than MF, reducing the total error, the total weighted error, and maximizing the utility gained. EDF yields poor overload behavior, and is known to cause a domino effect of missed deadlines. Not surprisingly, both MF and OR-ULD outperforms EDF. The remainder of this paper is organized in the following manner. Section 2 describes the details about the imprecise scheduling problem and discusses related work. Further, it presents the necessary preliminaries and terminology used in this paper. Section 3 describes the basics of OR-ULD and how imprecise tasks are modeled. The performance analysis of OR-ULD is reported in section 4. Finally, in section 5 we summarize our contributions.
wi worst-case execution time of task i ; i remaining execution time of task i ; ti termination time of task i ; si slack time for task i (si
=
di
ai
w i );
i weight of task i , i.e., the relative importance of task i in the task set T ; vi (ti ) value function of task i , representing the utility contributed to the system at time ti . The value function represents the criticality and the relative importance of a task compared to other tasks. Each successfully completing task incurs a positive utility (benefit) to the system. If a hard task does not successfully complete, then infinite negative utility (penalty) is imposed on the system. Missing a firm deadline imposes no penalty. The degree to which an optional task refines a result is represented using value functions. Hence, if an optional task does not complete successfully, it does not contribute any benefit to the system and, hence, the lost utility represents the weighted error (see equations 1 and 2)
2 Preliminaries The underlying workload assumptions are:
vim (t) =
A1 Each task, dentoed i , is decomposed into one mandatory part ( im ) and one optional part ( io ). A2 Mandatory and optional tasks are preemptable and have hard and firm deadlines, respectively. Moreover, tasks are sporadic.
vio (t) =
vim > 0 t di 1 t > di
(1)
vio > 0 t di 0 t > di
(2)
The workload consists of a set T = f 1 ; 2 ; :::; n g of preemptable tasks. Since each task i is decomposed, the workload really consists of T = f 1m ; 1o ; 2m ; 2o ; :::; nm ; no g. A schedule S , is said to be precise if the total error e, incurred by execution of the schedule S is zero. The basic imprecise scheduling problem is to find a schedule for a given set T of n tasks, which is optimal in the sense that it is feasible and has a minimum total error [10]. When the system load is normal, both mandatory and optional tasks are executed and a precise result is produced. During transient overloads, optional tasks may be dropped so that all mandatory tasks can meet their deadlines. The performance metrics that we focus on are (i) minimizing the total error, (ii) minimizing the total weighted error, and (iii) maximize the total utility gain. In addition, we study the completion ratio in order to understand the behavior of the algorithms.
A3 Each mandatory task im and optional task io is predeclared and pre-analyzed with known worst-case execution times wim and wio . This information is made available to the scheduler and the admission controller as tasks arrive in the system. A4 Optional tasks refine the acceptable result produced by the mandatory tasks. Optional tasks have to run to completion in order to refine the result fully, i.e., partial execution of optional tasks is preferably avoided. The following variables are used throughout this report for describing the temporal scopes of tasks (Note, a variable of a mandatory task im (optional task io ) is written as, e.g., o dm i (di )).
ai arrival time of task i (the time task i arrived at the queue for incoming jobs at the scheduler; tasks are assumed to be ready for execution upon their arrival); 2
due to dropping the task, and ix denotes the time saved by executing ORA x on an arbitrary task i . The utility loss for dropping a task is id = vi (t di ) vi (t > di ). Hence, the utility loss density is the ratio of utility loss and the time saved by executing an ORA, i.e., id =i .
3 Overload Management using the OR-ULD Algorithm The Overload Resolver architecture and algorithm was proposed by [5, 3] to resolve transient overloads in realtime database systems. The architecture of the Overload Resolver consists of the following components: a dynamic admission controller, a scheduler, an overload resolver, and a dispatcher. Subsequent sections describe the components and their interrelations in more detail.
3.3 Imprecise Tasks and OR-ULD The worst-case execution time of i is given by the total worst-case execution time of im and io (i.e., wi = wim + wio ). Moreover, task criticality is assigned according to the specification, i.e., im is always hard, and io is always firm. The utility of the subtasks are, just as the worst-case execution time, based on what is specified for i . The total utility that task i gains when completed before its deadline di is divided between im and io based on their worst-case execution times. Regarding penalty, im inherits the penalty of the standard task, which in this case is infinite penalty since im is critical. Further, io has its own penalty specified, in this case it is zero since io has a firm deadline. The precedence constraint that exists between mandatory and optional subtasks of each task increases the complexity of the scheduling problem. In order to reduce the complexity, we want to encode the constraint into the deadlines and ready times of the subtasks. The solution that we have chosen is a refinement of the proposed method of Blazewicz [1]. In our refined solution, we consider the slack time of the task i as well as deadlines and ready times. Assigning the modified deadline to the mandatory task according to [1], will result in an assignment of all slack time of i to the mandatory task, im . Instead, it is desirable to divide the slack time between the two subtasks based on their execution time. It is important to give the optional task io some slack time if we want to assure that the right optional task, i.e., the one with highest utility, is scheduled before one with lower utility. If an optional task, io , does not get any slack time at all, the chance that it will be scheduled and completed within its deadline decreases significantly. Since we treat im and io as two separate tasks and the scheduler needs to have knowledge of both tasks when i arrives into the system, we cannot change the arrival time for io as proposed by Blazewicz [1]. Instead we only manipulate the deadline of im . This is possible since we use EDF as the underlying priority assignments policy. In order to decode the precedence constraint between im and io into the deadline dm i without really changing it, we introduce the concept of virtual deadline vdm i . The virtual deadline vdm i for the mandatory task is computed according to equation 3. The deadline of the optional task, i , does not o change at all, i.e., doi = di . Since, vdm i di and we are usm o ing EDF, i will get higher priority than i . Consequently im will be scheduled before io , which satisfies the prece-
3.1 Admission, Scheduling and Dispatching All tasks that request to enter the system arrive at the admission controller. The admission controller then performs a schedulability test upon arrival of the new task . The schedulability test determines whether a new task should be admitted for execution or not. Let TA denote the set of all previously admitted tasks ordered as follows: TA = f 1 ; :::; n j8 i di 1 di g. The schedulability test used in this work is the RED (Robust Earliest Deadline) acceptance test [2]. Admission of is determined on the schedulability of workload T = TA [ f g given the worst-case execution times of the tasks in the set T . Hence, no transient overloads will pass the admission controller undetected. If the task passes the acceptance test it is admitted and sent to the scheduler. Once tasks are admitted to the system their required processing times are reserved. The only way this reservation can be revoked is if a transient overload occurs later. If the admission controller detects a transient overload, i.e., the schedulability test for the task set T fails, the admission controller invokes the overload resolver in order to examine if resource reallocation should be performed. Admitted tasks are assigned priorities based on the EDF. The dispatcher performs dispatching according to the schedule produced by the scheduler.
3.2 Overload Resolution The overload resolver acts as a negotiator, deciding if it is possible and advantageous to de-allocate enough processing time from previously reserved intervals in order to admit new tasks. The overload resolver examines earlier resource reservations and analyzes if it can find an overload resolution plan (ORP) that is advantageous for the system. The overload resolution plan that the overload resolver generates consists of one or more overload resolution actions (ORAs). For imprecise workloads the only possible type of ORA is to drop tasks.1 Further, ix denotes the loss of utility 1 The strategy enables overloads to be resolved by multiple strategies. In previous work we studied how overloads can be resolved by dropping tasks or replacing tasks that have a contingency action [5, 4].
3
When generating the ORA ”drop io ”, we calculate the amount of utility loss, ido as follows: ido = vio (t doi ) vio (t > doi ). The time saved by executing this ORA, ido is computed as follows: ido = io ooi , where ooi is the cost of aborting io . It should be noted that the concept of ORAs may seem unnecessarily complicated for workloads consisting of only imprecise tasks. However, for more complex workloads consisting of both imprecise tasks and regular tasks of different criticality, the approach provides the flexibility that enables multiple strategies to be used to resolve overloads. For example, overloads may be resolved by replacing transactions with contingency transactions, and non-critical regular transactions may be dropped or postponed. The concept of ORAs captures the utility loss of different actions and, hence, the cost of ORAs can be compared so that overloads are resolved in a cost-efficient way.
dence constraint.
vdm i
=
m am i + w i + si
wim wi
(3)
The virtual deadline is used for scheduling purposes as long as the mandatory task im is capable to finish execution before it. If im gets the prognosis that it will miss its virtual o m deadline, vdm i , the optional task i is dropped and i is scheduled with the real deadline instead, i.e., di . This way we are able to encode the precedence constraint between the two tasks as long as it exists.
3.4 Invocation of Overload Resolver When task i arrives, the admission controller first tries to admit im based on the virtual deadline vdm i . If admission of im succeeds, i.e., there is no overload present, the admission controller tries to admit io . However, if im based on vdm i fails passing the acceptance test, the overload resolver is invoked in order to find an ORP that releases enough process time to admit im . If the overload resolver is unable to release enough processing time to admit im based on vdm i , then io is dropped and the virtual deadline vdm is replaced i with the real deadline di . The admission controller, and possibly the overload resolver, is then reactivated for im . If im does not pass the acceptance test and the resolver fails to find an ORP a second time, then im is rejected. Hence, the system fails. If im passes the acceptance test then the admission controller tries to admit io . Similarly, if io passes the test it gets admitted, and the overload resolver is invoked only if it does not pass the test. If it is determined that the io should be rejected, then vdm i is replaced with the real deadline di .
3.6 Selection of ORAs An ORP consists of a set of ORAs that release time in the critical overload interval, selected based on their utility loss density, i.e., id =i . De-allocation of processing time is done in the interval referred to as the critical overload interval. Informally, the critical overload interval (COI) starts once the overload is detected at time t0 (current time), and ends at the time of the deadline of the first task missing its deadline (a formal definition is found in [3]). If enough processing time can be released in this interval, then the overload will be resolved. Moreover, de-allocating time only outside the critical overload interval will have no effect on resolving the overload. When generating an ORP, ORAs are added to the ORP until enough processing time has been released in the critical overload interval. The ORP is executed if, and only if, (i) the ORP releases enough processing time in the critical overload interval such that the new task can be admitted, and (ii) the utility loss of rejecting the new task exceeds the total utility that will be lost due to dropping tasks that have previously been accepted but now are selected for dropping. OR-ULD attempts to select the best ORAs for saving the required amount of time in the critical overload interval. Selection of ORAs is made by relating the utility loss caused to the amount of resources that are de-allocated by an ORA. OR-ULD computes the utility loss density ( ix =ix ) for each ORA, and lets the set of actions be ordered by their utility loss density. The algorithm consists of the following steps:
3.5 Generating Overload Resolution Plans The responsibility of the overload resolver is to find an eligible overload resolution plan (ORP) that minimizes the utility loss and de-allocates the time required in order to admit a new task. The ORP consists of one or more overload resolution actions (ORAs). Given a workload only consisting of imprecise tasks there exists only one possible overload resolution action, namely to drop a previously admitted task. Dropping a task results in a utility loss relative to our initial expectations, and might result in wasted CPU time if the dropped task has started its execution. The new task that is admitted will on the other hand eventually result in a utility gain when it completes, which must be contrasted against the lost utility of dropped tasks. Since we have two types of tasks, im and io , we have to consider this when generating ORAs. In subsequent sections, we describe how ORAs are generated, i.e., drop io . It should be noted, that dropping a mandatory task impose an infinite penalty to the system and, hence, will not be performed.
(i) Generate the set of possible ORAs in COI and compute their utility loss density. (ii) Sort ORAs by utility loss density. (iii) Iterate through the ORAs in order of decreasing utility 4
loss density, and add them to the ORP until sufficient time has been saved.
In order to determine the overload performance of the OR-ULD algorithm we measure the total error (section 4.1), total weighted error (section 4.2), and completion ratio (section 4.3), while varying the task arrival rate. In the simulation experiments we use an imprecise task workload defined as follows (the characteristics of the mandatory and the optional tasks is described in table 2). The size of tasks is uniformly distributed in the interval specified by the Size parameter in table 2. The size wim of a mandatory task im is 60% of the size of task i . This is realistic since it is likely that a mandatory task has a longer execution time than the optional one, since im guarantees the quality of i and io then refines the result produced by im . The benefit contributed by a task im ( io ) is proportional to the ratio between the worst-case execution time wim (wio ) wm and wi . Formally, vim = vi wio , and vi0 = vi vim . This is i a likely distribution since it regards the amount of work performed by the tasks. To stress the importance of mandatory tasks meeting their deadlines, they impose infinite penalty on the systems if they are missed.
(iv) Determine, based on total utility loss, whether to admit execute the ORP in order to admit the new transaction, or to reject the new transaction. In [3] we showed that the computational complexity of the algorithm is O(n log n), where n is the number of transactions. See [5, 3] for further details about the algorithm. ORAs are task specific and, hence, generation of ORAs is preferably done at the time when a task is admitted to the system (as opposed to generating ORAs when an overload occurs in which case there is a higher cost). Generated ORAs are inserted and stored in a table that carries information about utility loss, time saved, and the utility loss density. Similarly, since ORAs are task specific, ORAs belonging to a certain task are removed from the table once that task terminates. Hence, the table only holds valid ORAs that may release processing resources among admitted tasks. The time saved by an ORA is calculated first when an overload is to be resolved and when the ORAs are to be sorted.
Table 2. Task Workload Parameters Parameter oper
#
Sla k P eriod U tility P enalty
4 Performance Analysis The primary objective is to determine that OR-ULD has as predictable behavior under transient overloads when presented a workload consisting of imprecise tasks. By predictable we mean that the algorithm can ensure time constraints of the mandatory tasks and that optional tasks are controllably dropped such that error is minimized. We have conducted a simulation-based performance analysis to evaluate the performance and behavior of OR-ULD against the reference algorithms EDF, MF, and Baseline. The baseline is a version of EDF that have an admission controller detecting overloads. When detecting an overload the baseline performs a mode switch and only admits mandatory tasks from then on. The purpose of the baseline algorithm is solely to serve as a baseline, indicating when no feasible schedules can be found. We have performed the evaluation by modeling certain system parameters. The simulation parameters have been given values that we believe to be representative and realistic. Parameters and values are described in table 1.
N umCP U 2 P ro Op ArrivalRate
Value 1+1 10.0 1-15
1
Mandatory ( im )
Optional ( im )
9.0 - 11.0 Sporadic
9.0 - 11.0 Sporadic
d(11 15) 0:6e b(11 15) 0:4
( )w
vi t
1
-
m i =wi
( )w
vi t
o i =wi
0.0
We use the EDF [9], MF [6], and a baseline as reference algorithms when evaluating the performance of OR-ULD. MF is designed for imprecise workloads, and to minimizing the largest weighted error. The MF algorithm also increases schedulability, compared to OAR [7] and NORA [12], by scheduling all mandatory tasks present in the system before scheduling any optional task. Mandatory tasks are scheduled first in EDF order, in the remaining time optional tasks are scheduled in order to minimize the largest weighted error. Each of the simulation experiments was conducted by running a series of simulations and summarizing the results of them. In our simulations, each data point of the completion ratio values represents the average completion ratio, and 95% of the values are within 5% of the average value.
4.1 Analysis: Total Error
Table 1. System Parameters Parameter
Task ( i ) 11 - 15 9.0 - 11.0 Sporadic 100 - 300 -
The total error does not consider the weights of tasks, i.e., the utility of tasks, but only the amount of missed execution time. The total error, denoted e, is defined as
Description Number of processors in the system Processing time per operation in ms Arrival rate of tasks (task/sec)
2 One of the processors is dedicated to handling scheduling services, the second handles task processing.
5
4
4
Total Error Improvement Ratio
Total Error
x 10
1
OR−ULD EDF MF
3.5
0.9
0.8
Total Error Improvement Ratio
3
Total Error
2.5
2
1.5
0.7
0.6
0.5
0.4
0.3 1
0.2 0.5
0
0.1
0
5
10 Arrival Rate (Transactions/sec)
0
15
(a) Total error
1
2
3
4
5 6 7 8 Arrival Rate (Transactions/sec)
9
10
(b) Total error improvement for OR-ULD, compared with MF
Figure 1. Performance analysis of OR-ULD wrt total error
P
e = o 2T ei where ei = $io i , $i is the processi ing time of task i , and i is the actual execution time assigned to task i and are in the range [0,$io ] [12]. Figure 1(a) shows that OR-ULD produce lower total error than MF and EDF while feasible schedules can be found (until approximately eight tasks per second). As mentioned earlier, MF performs better under extreme workloads. Figure 1(b) shows the improvement ratio of the total error for OR-ULD compared with MF. The improvement ratio is calculated as shown in equation 4. 1
eOR ULD ; where ealg eMF
=
X i 2T
$i
i
Figure 2(a) shows that OR-ULD produces lower total error than MF and EDF while feasible schedules still can be found (until approximately eight tasks per second). As mentioned earlier, MF performs better under extreme workloads. Figure 2(b) shows the improvement ratio of the total weighted error for OR-ULD compared with MF. The improvement ratio is calculated as shown in equation 5. 1
(4)
where
With an arrival rate of five tasks per second, OR-ULD produces a total error that is approximately an improvement of 90%. The improvement ratio then gets smaller, but never is less than approximately 33%, which is a significant improvement. Overall, OR-ULD produces a considerably smaller total error than MF, the exception is extreme workloads. Again, MF and OR-ULD clearly outperform EDF.
T W E alg
T W E OR ULD T W E MF =
X
i 2T
vi (t)
(5)
X
i 2T ^fi di
vi (fi )
With an arrival rate of five tasks per second, OR-ULD produces a total weighted error that is approximately an improvement of 94% over MF. The improvement ratio gradually gets smaller, but never under approximately 34%, which is a significant improvement. Comparing with total error, we see an even greater improvement, which indicates OR-ULD manages the value functions of the tasks better than MF does. Overall, OR-ULD produces a considerably smaller total weighted error than MF, again the exception is extreme workloads.
4.2 Analysis: Total Weighted Error
P
The total weighted error is defined as [6]: o 2T i i ei . In our case, the weight i of i is included in the value function vi (t). The value function also considers the actual processing time i assigned to i , i.e., we can see the utility gained as i i . P We therefore define P the totalvweighted error accordingly: i 2T vi (t) i 2T ^fi di i (fi ).
4.3 Analysis: Completion Ratio Figure 3 shows the completion ratio, i.e., the ratio of the number of tasks that meet their deadlines and the total number of tasks requesting resources, for tasks im and io (de6
4
4
Total Weihgted Error Improvement Ratio
Total Weighted Error
x 10
1
OR−ULD EDF MF
3.5
0.9
Total Weighted Error Improvement Ratio
Total Weighted Error(Maximum−Obtained)
0.8 3
2.5
2
1.5
1
0.7
0.6
0.5
0.4
0.3
0.2 0.5
0
0.1
0
5
10 Arrival Rate (Transactions/sec)
0
15
(a) Total weighted error
1
2
3
4
5 6 7 8 Arrival Rate (Transactions/sec)
9
10
(b) Total error improvement ratio for OR-ULD, compared with MF
Figure 2. Performance analysis of OR-ULD wrt total weighted error Since it is of paramount importance that time constraints are met for the mandatory tasks im , we observe the ORULD enforces this constraint satisfactorily. During extreme overloads, it performs close to optimal, with respect to the number of mandatory tasks completing on time, as set out by the Baseline. OR-ULD enforces this constraint by gradually dropping optional tasks. The reason that OR-ULD does not achieve optimal results during extreme overloads is the sporadic nature of the workload and the fact that the dynamic scheduler is not clairvoyant. MF ensures the timeliness of mandatory tasks optimally, i.e., it gives the same performances as the baseline, but produces schedules with higher error than OR-ULD.
noted M and O respectively) as a function of the total arrival rate. The EDF algorithm is known to be unable to handle transient overload well, as showed in figure 3. The figure shows that EDF starts missing deadlines of mandatory tasks at an arrival rate of approximately five tasks per second (which is expected since the workload utilization is approximately eighty percent). Another observation regarding EDF is that the completion ratio for optional tasks is higher than for mandatory tasks. This behavior was first discovered by Pang et al. [11], who showed that the EDF priority assignment policy discriminates longer tasks significantly. Consequently, these results are expected since we have a 60/40 relationship between wim and wio . Observing the results of the MF algorithm, we see that the completion ratio for mandatory tasks is equal to that of the Baseline, which is expected since MF schedules all mandatory tasks before scheduling any optional tasks. However, this strategy is pessimistic for non-extreme workloads, causing a low completion ratio for optional tasks. MF starts missing optional deadlines doi , at an arrival rate of approximately four tasks per second. This is lower than for OR-ULD, EDF, and the Baseline, indicating that the system is not yet overloaded. MF actually misses optional tasks when it is still possible to finish them on time. The pessimistic behavior of the MF algorithm also shows when studying the utility ratio, total error, and the total weighted error. In addition, studying the completion ratio of optional tasks shows that OR-ULD is better than MF.
5 Conclusions In this paper, we have extended and evaluated the ORULD algorithm for scheduling imprecise tasks in order to minimize total error and total weighted error. The OR-ULD algorithm was proposed in earlier work for resolving transient overloads [5, 3, 4]. In that study the workload consisted of firm transactions and hard transactions having contingency transactions, where either the original transaction or the contingency transaction is executed. For imprecise task workloads simulation results show that OR-ULD outperforms the MF algorithm during light to high workloads, producing schedules with better total error and total utility than the MF does. In addition, OR-ULD discards fewer optional tasks than the MF algorithm. The OR-ULD approach allows for handling workloads 7
editors, Modelling and Performance Evaluation of Computer Systems, pages 57–65, Amsterdam, Holland, 1976. Commission of the European Communities, Joint Research Centre, Ispra Establishment, North-Holland.
Completion Ratio
1
[2] G. C. Buttazzo and J. A. Stankovic. RED: A robust earliest deadline scheduling algorithm. In Proceedings of 3rd International Workshop on Responsive Computing Systems, 1993.
Completion Ratio
0.8
0.6
[3] J. Hansson. Value-Driven Multi-Class Overload Management in Real-Time Database Systems. PhD thesis, Department of Computer Science, Link¨oping University, 1999.
OR−ULD/M OR−ULD/O EDF/M EDF/O BL/M BL/O MF/M MF/O
0.4
0.2
0 0
5
[4] J. Hansson, S. F. Andler, and S. H. Son. Value-driven multiclass overload management. In Proceedings of the 6th Conference on Real-Time Computing Systems and Applications (RTCSA’99). IEEE Computer Press, 1999. 10 Arrival Rate (Transactions/sec)
[5] J. Hansson, S. H. Son, J. A. Stankovic, and S. F. Andler. Dynamic transaction scheduling and reallocation in overloaded real-time database systems. In Proceedings of the 5th Conference on Real-Time Computing Systems and Applications (RTCSA’98), pages 293–302. IEEE Computer Press, 1998.
15
Figure 3. Performance analysis of OR-ULD wrt completion ratio of mandatory and optional tasks
[6] J-h. Kim, K. Song, K. Choi, and G. Jung. Performance evaluation of on-line scheduling algorithms for imprecise computation. In Proceedings of the 5th International Conference on Real-Time Computing Systems and Applications (RTCSA’98). IEEE Computer Society Press, 1998.
not only consisting of imprecise tasks. Complex applications tend to have complex workloads, where tasks have different requirements. For example, workloads may consist of imprecise tasks, independent tasks, and tasks with contingency actions, or combinations thereof. Hence, policies for scheduling and overload management must be able to handle these complex workloads. Based on the results presented in this paper and previous results [3], it can be concluded that the OR-ULD algorithm is able to handle imprecise workloads and multi-class workloads consisting of firm tasks and hard tasks with contingency actions. The approach enables resolution of transient overloads by using multiple strategies, i.e., dropping optional tasks, replacing tasks with contingency actions, and/or drop non-critical and independent tasks. The advantage of OR-ULD is that it is possible to balance these decisions against each other. This is done by analyzing the consequences of an overload resolution action with respect to utility. This means that for a transient overload situation one can determine whether it is more beneficial to invoke the contingency action of a critical task, or to drop an optional task of an imprecise task, in order to enable admission of a new critical task. Hence, these results imply that OR-ULD could be applied to more general dynamic scheduling problems than NORA, OAR, and MF, which are restricted to imprecise workloads.
[7] C. Lee, W. Ryu, K. Song, G. Jung, and S. Park. On-line scheduling algorithms for reducing the largest weighted error incurred by imprecise tasks. In Proceedings of the 5th International Conference on Real-Time Computing Systems and Applications (RTCSA’98), pages 137–144. IEEE Computer Society Press, 1998. [8] J. Y-T. Leung. A Survey of Scheduling Results for Imprecise Computation Tasks, chapter 3, pages 35–42. The Kluwer International Series in Engineering and Computer Science Real-Time Systems. Kluwer Academic Publishers, 1995. [9] C. L. Liu and J. W. Layland. Scheduling algorithms for multiprogramming in hard real-time environment. Journal of the ACM, 20:46–61, January 1973. [10] J. W. S. Liu, K. J. Lin, W. K. Shih, A. C. Yu, J. Y. Chung, and W. Zhao. Algorithms for scheduling imprecise computations. In Andre’ van Tilborg and Gary M. Koob, editors, Foundations of Real-Time Computing - Scheduling and Resource Management. Kluwer Academic Publishers, 1991. [11] H. Pang, M. Livny, and M. J. Carey. Transaction scheduling in multiclass real-time database systems. In Proceedings of the Real-Time Systems Symposium. IEEE Computer Society Press, December 1992. [12] W-K. Shih and J. W. S. Liu. On-line scheduling of imprecise computations to minimize error. In Proceedings of the Real-Time Systems Symposium. IEEE Computer Society Press, December 2-4, 1992. [13] W-K. Shih, J. W. S. Liu, and J-Y. Chung. Fast algorithms for scheduling imprecise computations. In Proceedings of the Real-Time Systems Symposium. IEEE Computer Society Press, 1989.
References [1] J. Blazewicz. Scheduling dependent tasks with different arrival times to meet deadlines. In H. Beilner and E. Gelenbe,
8
