mental framework demonstrates that our MHS enhances through the evolutionary approach, the user satisfaction level by a factor of two as compared to the ...
A User Centered Evolutionary Scheduling Framework Horst F. Wedde, Muddassar Farooq, Mario Lischka Informatik III, University of Dortmund, 44221, Dortmund, Germany phone: + 49 231 755-5325, fax:+ 49 231 755-5323 e-mail: {wedde, farooq, lischka}@ls3.cs.uni-dortmund.de Abstract—The need for supporting CSCW applications with heterogeneous and varying user requirements call for adaptive and reconfigurable schedulers accommodating a mixture of real-time, proportional share, fixed priority and other policies, thus overcoming frustrating processor bottlenecks. In this paper we try to overcome this anomaly by proposing an evolutionary strategy for a Meta Hierarchical Scheduler (MHS) in which a user is actively involved in the design cycle of a scheduler. Our framework analyzes user requirements by formulating an abstract model for an optimum scheduler with the help of an evolutionary algorithm that satisfies the needs. Finally a C source code for this MHS is generated using a code generator for the Linux kernel. Our experimental framework demonstrates that our MHS enhances through the evolutionary approach, the user satisfaction level by a factor of two as compared to the satisfaction level achieved by the standard Linux scheduler. Keywords—Adaptable Schedulers, Hierarchical Scheduling, Evolutionary Schedulers, Linux Scheduler, Contextfree grammars
I. Introduction The emergence of the Internet market toward the end of the last century has not only revolutionized the PC market but also lead to establishing new paradigms for business processes. We experienced enormous advancements in processor technology, its accompanying peripherals on the one hand, and in different user-centered software applications exploiting these advancements on the other hand. This resulted in a huge paradigm shift for utility of personal computers (PC) i.e. from their traditional use in automating tasks to a cardinal component of a computer supported collaborative work (CSCW) environment. Nowadays a user in a CSCW environment could start a download from a remote site, attend a multimedia conference at the same time, take notes for minutes of the meetings, read/send important documents, and run a complex simulation in the background. In CSCW applications the processor usage pattern becomes frequently unpredictable because of changing user needs. Conflicting but coexisting scheduling requirements make it an uphill and difficult task to create a generic scheduler that could easily, efficiently if not optimally, adapt to the user needs in collaborating communities. Previous and Related Word: Traditionally the field of scheduler design has been enthralled by allocating a
fair share of the processor time to each task to bound their response time or to minimize deadline failure rate [5][4]. Lately, a considerable effort was made to realize hybrid approaches with the help of a scheduling hierarchy [2] [3][8].This hierarchical scheduling paradigm enabled schedulers to schedule a mix of heterogeneous applications. But all of these approaches had fixed design that neglected changing user needs. HLS (Hierarchical Loadable Schedulers) approach discussed in [8] provides no mechanism to a user to specify his requirements and then analyze them to find the best hierarchy for him. Moreover a user has no control over the allocation of free time to those applications that are important to him. One could easily conclude that in all of the abovementioned approaches including HLS, the users’ community was never involved in the design cycle of schedulers. This non-existence of communication channel between a user of PC and the scheduler of PC provided us with the grist for the mill in doing research in an interesting field of user centered scheduler design (UCSD). In this project we try to overcome above-mentioned anomaly by giving a pivotal position to a user in formulating scheduling policies eventually to evolve into an Abstract Scheduler Model (ASM). We use a variant of HLS [8] as a substructure in our framework SAADI. We ask a user to specify a syntactic structure of his applications, their relative importance and value to him, and their scheduling semantics. This information plays an important role in the work-flow of generating our adaptable, reconfigurable and evolvable scheduler for the Linux operating system. Organization of the Paper:This paper describes the complete formal framework with the help of which we automate the process of generating scheduling hierarchies and then invoke an evolutionary algorithm to extensively search the hierarchy space to find the best performing scheduling hierarchy for a particular scenario. Section II describes a formal model that form the basis for a hierarchy that could meet a user’s requirements. Section III provides an overview of the evolutionary algorithm used in SAADI. Section IV discusses the results obtained from the experimental evaluation of SAADI, and compares its performance to the standard Linux scheduler. Finally we conclude our work with an out-
look for our future work. II. Formal Representation As a first step towards ASM we formulate a Meta Hierarchical Scheduler (MHS) as a variant of HLS [8] [7]. HLS provides a framework that helps in organizing simple schedulers into a hierarchy to form complex scheduling policies. Figure 1 shows an example of of a simple scheduling hierarchy in an HLS. A fixed-priority root scheduler schedules a cpu-reservation based scheduler (RES) with a high priority and a join-scheduler (J) with a low priority. A join scheduler distributes the free time received from its parent schedulers to its child schedulers/tasks. Hence a video-application gets its quantum of CPU time because of its higher priority but the join-scheduler ensures that the time sharing scheduler (TS) will get a certain amount of CPU time as well (preventing a possible starvation of the word-processor or voice-recognition software). In contrast to HLS we will now build a framework for incorporating user requirements into a scheduler design for a customized PC Linux operating system. For describing our ASM approach we will introduce a few basic formal concepts.
Convention 1 (Set of Guarantees) The following set of guarantees G is incorporated in our ASM G = {ps, psbe, resbs, f p, all, null} where ps means proportional share, psbe proportional share with bounded error, resbs means a periodic reservation, fp means fixed priority, all means complete CPU time, null means no guarantees about CPU time. A set of guarantees that is supported by ASM will be instrumental for transforming user requirements specified in an SDL file, into an abstract representation for the scheduling problem. This abstract representation is transformed into a scheduling hierarchy with the help of a context-free grammar. Convention 2 (Set of Schedulers) At the mo(g ) ment ASM supports a scheduler set Sr( goi ) where Sr = {P S, RESBS, T S, F P, O(1)}, gi ∈ G is an input guarantee that a scheduler s ∈ Sr receives from its predecessor scheduler sp ∈ Sr , and go is an output guarantee that a scheduler s ∈ Sr provides to its successor scheduler sc ∈ Sr . O(1) is a standard Linux scheduler by Ingo Molnar [6] that provides a null guarantee. Similarly we may denote guarantee for object O through scheduler RESBS, by resbO .
FP High
Definition 3 (Schedulable Set) A schedulable set Sl is defined as [ [ [ Sl = Sr ∪ Ak ∪ Tij
Low
RES J
Video Player
k=1...n TS
Word Processor
i = 1...m j = 1...l
Here Ak is an application with a single thread of execution, and Tij represents thread j of a multi-threaded application i.
Voice Recognition
Fig. 1. An example of HLS.
Definition 1 (Schedulable Object) A Schedulable S Object Sj p can be an application (Ak ), a thread k of an application j (Tkj ) or another scheduler s, that will be scheduled by its parent scheduler Sp . A schedulable object helps in practicing object oriented software design because with the same object we can represent a scheduler or a thread of an application. This simplifies the implementation of the run queue of a scheduler. S
Definition 2 (Guarantee) A guarantee gSkp is a contract between a scheduler Sp and a schedulable object Sk regarding the allocation of CPU time by Sp to Sk S according to the type of guarantee as long as gSkp is enforced.
The run queue of a scheduler is simply a schedulable set. The scheduler scans a schedulable set and allocates the CPU to its schedulable objects, according to their guarantee parameters(Definition 2). Definition 4 (Schedulable Relation) A schedulable relationship SRlm between schedulable object m and scheduler l exists if 1. ∃
l ≺ m → m is a successor of l
2. m, an schedulable object, receives on this arc l guarantee gm provided by scheduler l A schedulable relation facilitates the assignment of schedulable objects to a scheduler, and hence builds a legal hierarchy that could meet a user’s requirements.
Definition 5 (Root Scheduler) A root scheduler Sroot ∈ Sr , Sroot ∈ / {O(1), F P, T S} is the one that gets as input guarantee Sroot(gi ) = All i.e it has all of CPU time at its disposal. Definition 6 (Meta Hierarchical Scheduler) A structure M HS = {Sroot , G, Sl , SRlm } in our ASM is called a Meta Hierarchical Scheduler, where (1) Sroot is the root scheduler of the current hierarchy (Definition 5) (2) G is the set of guarantees supported in the ASM (Convention 1) (3) Sl is the schedulable set (Definition 3) synthesized from SAADI-SDL in a manner that satisfies the following conditions [
Ak ≺ mk = ∅
By using the constructs of SAADI-SDL, a user could specify the processing requirements of different applications and of their relative importance. At this time schedulable application set consists of single/multithreaded batch, periodic (multimedia and network applications) and interactive applications. Our ASM model parses SAADI-SDL and analyzes the requirements to generate scheduler individuals for the first generation of our evolutionary algorithm with the help of a context-free grammar. All individuals must satisfy Definition 6. We define the following concepts to illustrate the mapping of the application requirements to an abstract representation. Definition 7 (Guarantee Operator) A Guarantee Operator fg is a mapping between requirements of applications Rsdl , to a set of guarantees (Convention 1) supported in SAADI fg : Rsdl 7→ P ot(G)
k=1...n
[
III. The Evolutionary Algorithm in SAADI
Tij ≺ mij = ∅
where Pot(G) is a set of all subsets of a set of guarantees (Convention 1) supported in SAADI. Definition 8 (Guarantee Word) A Guarantee Word Wg of length n is a set of n tuples of guarantees.
j = 1...l
(4) SRlm ⊆ Sr × Sr is subject to the following conditions (a) l ∈ Sr , m ∈ Sr , ∀l, m : l 6= m (b) ∀l, m, ∃SRlm ⇒ @SRml ∧ @SRkm :: k ∈ Sr , ∀k 6= l (c) if m=RESBS ⇒ ∃SRlm ⇔ l = RESBS (d) if m=PS ⇒ ∃SRlm ⇔ l ∈ {P S, RESBS} (go )
(e) ∀l, m, ∃SRlm ⇔ Sm( gi) = Sl
l = gm
MHS is the central definition in our discussion. It is extensively used to define a legal scheduling hierarchy. By a legal hierarchy, we mean MHS could satisfy the demands of a user. Later on we will define a context-free grammar to generate MHSs with the help of varying conditions for (1) through (4) rules in the MHS definition. (1) indicates that which scheduler could act as a root scheduler in a scheduling hierarchy. (3) ensures that the threads must be the leaf nodes in a scheduling hierarchy. (4) provides a framework for making a scheduler as the successor of another scheduler. Rule 4 is also used in reducing the depth and breadth of a hierarchy. Now we will introduce our evolutionary algorithm used in SAADI project.
Let us assume that a SDL has n applications S = P ermutation(fg (A1 ) × fg (A2 ) × ... × fg (An )), fg (Ai ) ∈ P ot(G), 1 ≤ i ≤ n. Pot(G) is defined in (Definition 7). Now these tuples could be combined into a guarantee word using the following mapping Wg : S 7→ T ∗ , Wg (a1 , ..., an ) 7→ {a1 #a2 #...#an } where a1 ,a2 ,a3 ....an are guarantees required by threads and # are separation characters. We need this definition because we mutate and recombine guarantee words and then generate a MHS for them using a context-free grammar. Example: Now we will use an example to illustrate our genetic operators. Let us assume that a user is interested in executing four threads t1 t2 t3 t4 . t1 is a video decoder that displays a frame of a video application every 30 milli-seconds, t2 receives the video frames over the Internet every 30 milli-seconds, t3 is a complex simulation running in the background that needs about 20% processing time of the CPU, and t4 is a graphical user interface(GUI) thread. ASM analyzes these requirements and translates them using Definition 7 into a set of guarantees that could cover the requirements. t1 and t2 both require fixed cpu-reservations periodically, and hence are resbs guarantees (see Convention 2), t3 requires a certain proportion of CPU time and hence is a proportional share (ps) guarantee and for t4 we do the best effort scheduling (null guarantee). Using the notation in Definition 7, the guarantee operator fg
works as follows fg : r1 → 7 {resbs, ps} r2 7→ {resbs, ps} r3 7→ {ps} r4 7→ {null} where r1 is periodic cpu reservation requirement for t1 , r2 is periodic cpu reservation requirement for t2 , r3 is 20% CPU time requirement for t3 , r4 is minimum response time requirement for t4 repectively while Pot(G) = {{resbs,ps},{resbs,ps},{ps},{null}} for this scenario. From Pot(G) we generate two guarantee words w1 = ”resbs#resbs#ps#null” and w2 =”ps#ps#ps#null as a simple basis for an evaluation step in our evolutionary algorithm to be formally specified later on. Each word is assigned to a syntax tree, from which a scheduling hierarchy will be derived that should help to meet the requirements. For our example, the syntax tree for w1 is displayed as the left part of Figure 2, the resulting scheduling hierarchy is the right side. For further evolutionary steps we create more varieties of guarantee words from Pot(G)–and hence more scheduling hierarchies–for eventually reaching an optimum. We use mutation and recombination operators for the purpose. During mutation, we select, with certain mutation probability mθm a position in a word and then replace the guarantee at this position with another equivalent guarantee that would cover the underlying requirements e.g. an resbs guarantee can be converted into an equivalent ps guarantee [8]. In w1 let us apply the mutation operator at position 1. Now the new guarantee word w3 = ”ps#resbs#ps#null”. Similarly we define recombination (1-point crossover) with a certain recombination probability rθr both on w1 and w2 at position 1. Hence after the cross over we get w4 =”resbs#ps#ps#null” and w3 . Finally, a guarantee word w ∈ W will be part of the next population W 0 with at least the probabilf itness(hw ) according to stochastic universal ity Pm i=1 f itness(hi ) sampling [1], where f itness(hw ) and f itness(hi ) represent quality measures for the hierarchies generated from guarantee words w and i respectively. Then ASM takes one scheduler individual and generates source code for it using a code generator for the Linux 2.5.58 kernel. Using our testing infrastructure we run compile, reboot and evaluation cycles for each individual of a generation. Evaluation of an individual is done by running user specified tasks under the control of our testing infrastructure and assigning a fitness value to it . The fitness value is a quality measure for an individual according to some user defined optimum behavior. Once all individuals of a generation have been tested then we generate individuals for second generation using our genetic operators like recombination, mutation and selection. However in our approach we restrict the search space to legal individuals only (Definition 6)(In our example for mutation, the legal replacement is equivalence to the previous guaran-
tee). This process is repeated until an individual with a fitness values of 0.95 is found or thirteen generations have been tested. Algorithm 1 (SAADI’s Evolutionary Algorithm) Formal representation of our standard evolutionary algorithm is as following 1. read(f ): f ∈ {SDL − F iles}; 2. parse(f ) to get {T hreads} ∧ {Guarantee} (see Definition 1) 3. k:generation counter:=0 4. guarantee word(see Definition 8):g(0):= fomulateWord from {T hreads} ∧ {Guarantee} 5. S initialize P (0) := {h1 (0), h2 (0), . . . , hn (0)} l=1...n hl := generateMHS by using g(0) 6. ∀hl ∈ P (0) do (a) scheduler := codeGenerator(hl ) (b) compile(scheduler) ∧ rebootcomputer (c) f itness := evaluate(hl ) 7. while(f itness ≤ 0.95 ∨ k 6= 13) (a) recombine : g 0 (k) := rθr (g(k)) where rθr is recombination probability (b) mutate : g 00 (k) := mθm (g(k)) where mθm is mutation probability (c) newM HS : Q := g 0 (k) and g 00 (k)
generateM HS by using
(d) select : P (k + 1) := sθs (P (k)) sθs is selection probability
∪
Q where
(e) ∀hl ∈ P (k + 1) do i. scheduler := codeGenerator(hl ) ii. compile(scheduler) ∧ rebootcomputer iii. f itness := evaluate(hl ) (f ) k:= k + 1 endwhile A. Fitness Functions In SAADI we are catering for interactive, soft real-time and batch threads. Interactive threads need minimum response time, soft real-time applications demand a minimum deadline failure rate and batch applications
desire a minimum turnaround time. Moreover a user could also indicate an acceptable response time, deadline failure rate and turnaround time and assign a degree of importance to a thread. Free time in a MHS(please recall that MHS is a first step towards a general ASM (Definition 6)) may be allocated according to the importance of threads specified by a user.
2. if ∃ a scheduler type ρ and a guarantee type σ, such that d(r) = ρ − σ − Scheduler → create a scheduler s of type ρ and create an incoming guarantee g of type σ for s let G0 = ∅ ∀c ∈ c(r) : G0 = G0 ∪ generateMHS(c) ∀g 0 ∈ G0 : add g 0 as contract to s return {g}
Definition 9 (Fitness of a Thread) If o(t) is the defined optimum value of a given Thread t and m(t) the measured value, imp(t) the importance of a thread t ∈ T, and let max = max{imp(t)|t ∈ T } and min = min{imp(t)|t ∈ T }. Then the fitness f(t) of thread t is defined as: ( o(t) max + min − imp(t) o(t) < m(t) : m(t) f (t) = ∗ max else : 1
3. else: let G0 = ∅ ∀c ∈ c(r) : G0 = G0 ∪ generateMHS(c) return G0 ALL
RESBS Scheduler
RESBS-ALL-Scheduler
resbs t1
RESBS RESBS
resbs
t2
ps PS Scheduler ps ps
RESBS t3
RESBS
Let us assume that a video application requires 5 millseconds of CPU time after 30 milli-seconds. A user might tolerate a failure to display 5 frames in a second. He assigns importance of 2 to it. Now o(t) = 5 and imp(t) = 2 we measured m(t) = 6 during experiments. Using Definition 9 we could say that we achieved 77% (f(t)=0.77) (max=10 and min = 1) satisfaction level of the user for this thread. We use all these important parameters to define the fitness value for a MHS. Definition 10 (Fitness of a MHS) If f(t) is the fitness of thread t, then the fitness(H) of a MHS H with a complete set of schedulable threads T is defined as follows: P tT f (t) f itness(H) = P max+min−imp(t) tT
max
The operations on the guarantee words are handled through a context-free grammar, that ensures that from a guarantee word (Definition 8) we generate a MHS (Definition 6). The formal details of creating such a grammar can be found in [9]. Due to page limitations this may suffice as we hope the previous example gives a good idea. The following algorithms are used to generate a MHS from a generated syntax tree and optimize its depth and width. Algorithm 2 (generateMHS (Root r)) Input: Node r denoted by d(r) is the root of a subMHS t(subtree rooted at t), and successors of d(r) represented by c(r) are ordered from left to right on threads’ id, and the guarantee word w = g1 g2 , . . . gn Output: G, a set of guarantees offered by a subMHS t let w be gi . . . gn with 1 ≤ i ≤ n 1. if d(r) is a terminal → set w = gi+1 . . . gn and return {gi }
PS-RESBS-Scheduler
resbs
null t4
RESBS RESBS
resbs
TS Scheduler
PS PS
PS
ps TS-PS-Scheduler NULL null
Fig. 2. An exemplary syntax tree and the derived MHS The example in Figure 2 has been discussed before. For an optimized MHS we sketch our following algorithm: Algorithm 3 (OptimizeMHS(ROOT r)) Given a scheduler s, root of a subMHS and its guarantee contracts G(s), each g ∈ G(s) has an owner o(g), which is child of s. 1. ∃g ∈ G(s) : o(g) is a scheduler and o(g) and s are of the same scheduler type → move all contracts G(o(g))from o(g) to s, remove o(g) from the subMHS 2. ∃g ∈ G(s) : o(g) is a scheduler and ∃g1 ∈ G(s), g2 ∈ G(o(g)) : g1 and g2 are of the same type → move g2 from o(g) to s and remove o(g) from the subMHS, if G(o(g)) = ∅ 3. ∃g1 , g2 ∈ G(s) : o(g1 ),o(g2 ) are schedulers and are of the same type → move all contracts G(o(g2 ))from o(g2 ) to o(g1 ), remove o(g2 ) from the subMHS 4. ∃g1 , g2 ∈ G(s) : o(g1 ),o(g2 ) are schedulers and 0 0 0 0 ∃g1 ∈ G(o(g1 )), g2 ∈ G(o(g2 )) : g1 and g2 are of the same type 0 → move g2 from o(g2 ) to o(g1 ) and remove o(g2 ) from the subMHS, if G(o(g2 )) = ∅ The first two rules reduce the depth of the MHS while third and fourth reduce the breadth of the MHS.
IV. Evaluation of results
V. Conclusion
We designed and developed a real testing infrastructure to validate our ideas presented in the above sections. Our basic aim of designing such a comprehensive infrastructure is to measure the response time for interactive threads, the turnaround time for batch threads and the number of deadline failures for soft real-time threads. We used the Linux Trace Tool Kit (LTT) available inside the Linux kernel to maintain a history of important events that are of interest to us. We developed a complete inspector package that analyzes the trace file from LTT and measures the parameters important for optimization. Using Definition 9 and Definition 10 it calculates the fitness value for the tested MHS. The authors of [9] provide details of this analyzer package. In oder to get the fitness value for a scheduler individual , one needs to compile the Linux kernel with the individual and then restart the computer under control of our testing infrastructure. Then the individual is evaluated by running different applications. This compile, restart and evaluation cycle takes from 20 to 25 minutes. In this paper, due to page limitations we just report the results for one SDL file in which the test user specified 7 interactive, 4 periodic and 4 batch threads( they need about 65% cpu-time), hence it represents a highly loaded computer. We have experienced that in thirteen generations we do achieve an individual whose fitness value is 0.8 or above, good enough to stop the search process. Through our evolutionary algorithm we were able to find the best performing individual in the 10th generation that had fitness value of 0.81. As mentioned-above we decided to stop the search process after 13 generations because the maximum fitness value did not improve significantly afterwards. We think that the workload specified in SDL was quite high and it left little room for improvement in this maximum fitness value of 0.81. The best performing individual in generation 1 had fitness value of 0.67. However our evolutionary algorithm was able to remove poorly performing individuals quickly. The poorly performing individual in generation 1 had fitness value of 0.07 while the poor performing individual in generation 13 had 0.4 fitness value. Similarly the average fitness value increased from 0.4 in generation 1 to 0.6 in generation 13. To demonstrate the superior performance of the best MHS found by our evolutionary algorithm, we tested the standard Linux 2.5.58 scheduler under the same load as mentioned above. We choose the Linux 2.5.58 kernel because SAADI is also implemented on it. To get a dependable measure of the fitness value for the Linux kernel, we repeated our experiments ten times and got fitness values for the standard Linux scheduler in the range from 0.25 to 0.43 with an average of 0.33. This shows the superiority of SAADI over the standard Linux scheduler because the best performing individual of SAADI has 0.81 fitness value which is about two times better than the standard Linux scheduler.
Best Effort Scheduling policies are currently widely employed in the schedulers of general purpose operating systems. They try to achieve fairness among applications that they need to schedule. This approach does not consider usage patterns of users, and hence is not adaptive and evolvable with respect to dynamically evolving applications that have particular demands for their correct functionality. In this paper we introduced an Evolutionary Strategy that finds an optimum Meta Hierarchical Scheduler (MHS) that satisfies the requirements of a user. An abstract MHS is translated into a Linux scheduler C code by a C code generator. We have defined and developed a sophisticated testing infrastructure to evaluate the fitness of different individuals during a run of our evolutionary algorithm. The best individual obtained from our evolutionary algorithm is almost two times better as compared to the existing Linux scheduler. Currently SAADI provides an off-line interaction framework to a user. The user tells his intentions using SDL, and then SAADI invokes a MHS generation process and the evolutionary algorithm to find an optimum MHS. In this first step we proved the conceptual validity of our model. In the near future we will transform the framework into a real-time online module inside a kernel and provide easy system calls and a graphical user interface (GUI) for an administrative user to interact with the system. This enhancement will provide a truly evolvable on-line scheduler that adapts itself to dynamically changing operating environments. This will be reported in forthcoming publications. VI. Acknowledgements The authors would like to thank the members of project group SAADI for providing an infrastructure that facilitated the implementation of the ideas presented in this paper. References [1] J.E. Baker. Reducing bias and inefficiency in the selection algorithm. In Proceedings of the Second International Conference on Genetic Algorithms, pages 14–21, 1987. [2] D. Golub. Operating system support for coexistence of real-time and convential scheduling. Technical report cmu-cs-94-212, School of Computer Science, Carnegie Mellon Univesity, 1994. [3] P. Goyal, X. Guo, and M.H. Vin. A hierarchical CPU scheduler for multimedia operating systems. In Usenix Association Second Symposium on Operating Systems Design and Implementation (OSDI), pages 107–121, 1996. [4] W.A. Horn. Some simple scheduling algorithms. Naval Research Logistics Quarterly, 21:177–185, 1974.
[5] C.L. Liu and J.W. Layland. Scheduling algorithms for multiprogramming in a hard real-time enviornment. Journal of the Association for Computing Machinery, 20(1):46–61, 1973. [6] I. Molnar. Ultra scalable O(1) scheduler. http://people.redhat.com/mingo/O(1)-scheduler/. [7] J. Regehr. Using hierarchical scheduling to support soft real-time applications on general-purpose operating systems. Phd thesis, University of Virginia, 2001. [8] J. Regehr and J.A. Stankovic. HLS: A framework for composing soft real-time schedulers. In Proceedings of the 22nd IEEE Real-Time Systems Symposium (RTSS 2001), pages 3–14, London, UK, December 2001. [9] H.F. Wedde, M. Farooq, and M. Lischka et. al. SAADI–An Integrated Approach of Adaptable Schedulers. Technical report-pg424, School of Computer Science, University of Dortmund, 2003.
