Top Banner

of 10

Dynamic Scheduling Rta Periodic Tasks Mp A

Apr 03, 2018

Download

Documents

thotaln
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    1/10

    Proceedings qf the 29th Annual Hawaii International Conference on System Sciences - 1996

    Dynamic Schedulingof Real-TimeAperiodic Taskson Multiprocessor ArchitecturesBabak Hamidzadeh Yacine Atif

    Department of Computer ScienceHong Kong University of Science & TechnologyClear Water Say, Kowloon, Hong Kong.Abstract

    The application ofstatic optimization techniquessuch as branch-and-bound to real-time task schedulinghas been investigated. Few pieces of work, however,have been reported which propose and investigate on-line optimization techniques for dynamic scheduling ofreal-time tasks. In such task domains, the d@iculty ofscheduling is exacerbated by the fact that the cost ofscheduling itself contributes directly to the performanceof the algonthms and ,that it cannot be ignored. Thispaper proposes a class of algorithms that employ novel,on-line optimization techniques to dynamicallyschedule a set of sporadic real-time tasks. Thesealgorithms explicitly account for the scheduling costand its effect on the ability to meet deadlines. The paperaddresses issues related to real-time task scheduling inthe context of a general graph-theoretic frameworkIssues related to where and when the task of schedulingis performed are also crddressed. We compare two on-line scheduling strategies, namely an inter-leavingstrategy and an overlapping strategy. In t he formerstrategy, scheduling and execution are inter-leaving intime. Each scheduling phase performed by one

    processor of the syste,m is followed by an executionphase. In the latter strategy, scheduling and executionare overlapping in time. A specified processor, in thisstrategy, is dedicated to pe$orm scheduling. Results ofexpenmentsshow that the proposed algorithms performbetter than existing approaches, in terms of meetingdeadlines and total execution costs, over a large rangeof workloads.

    1. IntroductionMultiprocessor architectures provide a richcomputing environment from which a wide range ofproblem domains, including real-time applications, canbenefit. Efficient and effective scheduling and resourcemanagement techniques can play a major role ineffectively un1eashin.g the potential power ofmultiprocessor architectures in solving hard problems.One of the major schleduling problems that has beenaddressed extensively in the literature [ I.21 is that ofassigning a set of tasks to different processors in the

    system, in order to minimize the total response time ofthe total task set. These techniques try to achieve thisobjective by focusing on evenly balancing the loadamong the processors and on reducing communicationcosts in the system. Many multiprocessor schedulingproblems have been recognized as hard optimizationproblems [3], finding solutions to which may takeprohibitively long times.Scheduling algorithms for multiprocessorarchitectures, including those for real-time applicationscan be divided into two main categories of static anddynamic scheduling. In static scheduling, the allocationof resources is determined off-line prior to the start oftask execution. Dynamic scheduling algorithms performsequencing and resource allocation on-line in the hope ofusing more comprehensive and up-to-date knowledge ofthe tasks and the environment. Tasks can also be dividedinto two broad categories based on their invocation(arrival) patterns over time, namely periodic andaperiodic [4]. Periodic tasks are those which are invokedexactly once during each period. Aperiodic tasks can beregarded as tasks with arbitrary arrival times whosecharacteristics are not known a priori. Dynamicscheduling techniques are particularly of interest inscheduling aperiodic tasks in multiprocessorarchitectures, due to the unknown characteristics of thesetasks prior to run time.In real-time applications, the tasks to be assignedto different processors of a multiprocessor syst em havetime constraints complying with which is critical for thecorrectness of the answers produced by the system. Ibiscondition adds to the problem of scheduling ordinarytasks, a predictability element which creates a newdimension of complexity in solving such problems. Inreal-time applications, merely reducing response imes isnot a sufficient condition for acceptable levels ofperformance. The predictability requirement in theseapplications is used to guarantee compliance with thetasks time constraints or to predict deadline violationprior to task execution.The degree of required predictability andguarantee of deadline compliance varies in differentapplications. According to these requirements, real-timetasks have been divided into thr ee broad categories ofhard, soft and semi-hard real time [5]. Hard real-time

    4691060-3425/96 $5.00 0 1996 IEEE ,

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    2/10

    Proceedings of the 29th Annual Hawaii International Conference on System Sciences - 1996tasks are those tasks that have to be executed andwhose deadlines (and other time constraints) must bemet. Failure to execute a hard real-time task whilecomplying with the tasks deadline may havecatastrophic consequences. Soft real-time tasks arethose tasks which can tolerate occasional deadlineloss without drastically affecting the overall integrityof the system operations. The semi-hard real-timecategory [5], represents a realistic class of tasks thatare less strict than hard real-time tasks. This class ofreal-time tasks emphasizes the predictability ofcomplying with a tasks deadline. Semi-hard tasks aredefined as those tasks which must meet theirdeadlines, if they are accepted and are scheduled to beexecuted. Note that with this kind of tasks, the utilityof not executing a task at all is much higher thanexecuting that task and missing its deadline. Once atask is predicted to miss its deadline, the system canbe notified to take contingency actions to preventnegative consequences of not performing that task.Characterizing this class of tasks has importantimplications for the design of dynamic schedulingalgorithms for aperiodic tasks which we intend toaddress in this paper.When scheduling real-time tasks dynamicallyon the processors of a multiprocessor architecture, itis very important to address several issues about thescheduling algorithm, such as the time slots at whichthe algorithm is invoked, the duration of eachinvocation time slot, the distribution of the schedulingtask itself among different processors, and thecomplexity of the algorithm. These major issues inreal-time task scheduling have rarely been addressed.They are important factors because each one by itselfand in relation with the other factors, creates severaltradeoffs that can directly affect the quality of theanswers produced by t he scheduler and the degree ofpredictability and guarantee that the schedulingalgorithm can provide in meeting the task timeconstraints. Below, we discuss these issues andpossible approaches to them. We then propose ourapproach to addressing these issues.Two approaches to the issue regarding thedistribution of the scheduling task among differentprocessors can be taken, namely centralizedscheduling and distributed scheduling. Centralizedscheduling strategies assign a single processor toperform all scheduling operations. With distributedscheduling strategies, on the other hand, more thanone processor may be assigned to perform thescheduling operations. Another possible approach indistributed scheduling is to have each processor beresponsible for assigning available tasks to itselfwhen it finishes its previously assigned tasks.

    The issue regarding the times at which thescheduling algorithm is executed addressesproblemssuch as whether or not the scheduling task iscontinuously in progress in parallel with other taskexecutions. Two approaches to address this issue areinterleaved scheduling and execution and overlappedscheduling and execution. In the interleavedscheduling and execution, the scheduling task isperformed in repeated cycles of single schedulingperiods followed by task execution periods. Inoverlapped scheduling and execution, the schedulingtask is continuous and concurrent with the executionof other tasks. We have chosen the centralizedscheduling approach. We expect this approach to lenditself well to overlapped scheduling-and-execution,since it allows the scheduling task to be performed onone processor while the other tasks are performedelsewhere in the system.The issue regarding the duration of eachscheduling time slot addresses problems such as thefrequency at which the scheduled tasks are deliveredto working processors and the frequency with whichnewly-arrived tasks are sought for consideration inthe scheduling process. This is an important issue indynamic scheduling of aperiodic, real-time tasks andhas mostly been ignored. The existing app roachesconcentrate on finding a feasible solution for theentire batch of tasks in the current scheduling periodwithout regard for arriving tasks, for keeping otherprocessors idle, and/or for missing the deadlines ofscheduled tasks in the current period, due to longscheduling times.The complexity of the scheduling algorithmaddresses the tradeoff between the scheduling costand the schedule quality in terms of metrics such asdeadline compliance. Most existing approachesprovide an analysis of their algorithm complexitywithout investigating the effect of schedulingcomplexity on the quality of the schedule. Usingcomplex scheduling algorithms, provides us withcloser-to-optimal solutions and with betterpredictability in terms of deadline compliance. Themore complex the scheduling algorithms are,however, the more overhead cost they will incur andthe more system resources have to be allocated tothese algorithms which could, otherwise, be used fortask execution.Our approach to the problem of dynamicallyscheduling aperiodic real-time tasks is that ofoverlapped scheduling and execution using acentralized scheduling technique. Our algorithmscontinuously perform repeated periods of scheduling,duration of each of which is directly controlled by thealgorithm, in order to account for the tradeoffbetween scheduling time and scheduling quality and

    470

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    3/10

    Proceedings ofthe 29th Annual Hawaii International Conference on System Sciences - 1996in order to achieve good1 esponse times. A centralizedscheduling technique allows us to provide thepredictability and the deadline compliance guarantee hatscheduling r eal-time tasks requires in a multiprocessorarchitecture. We evaluate:our techniques via comparisonof their performance in complying with deadlines and inminimizing total response times with those of existingdynamic scheduling techniques similar to those proposedfor the Spring kernel [6]. In the experiments, weinvestigate the tradeoff between the loss of r esources dueto dedicating a processor to scheduling in centralizedscheduling and the gain in schedule quality in t erms ofguaranteed deadline compliance and in terms of reducedresponse times. We also compare he performance of theoverlapped scheduling and execution paradigm withthose of the interleaved scheduling and executionparadigm. The results of our experiments showsignificant performance improvements in comparisonwith the other existing techniques.The remainder of the paper is organized asfollows. Section 2 contains a specification of the taskmodel and the statement of the problem. Section 3provides a description of our algorithms and theircharacteristics. Section 4 contains the results of ourperformance-comparison experiments and a discussionof those results. Section 5 concludes the paper with asummary of the results and plans for our future work.2. Task Model and IProblem Statement

    In this paper, we address the problem ofscheduling a set T of n aperiodic, non-preemptable, semi-hard real-time tasks with earliest start times and deadlineson a Uniform Memory-Access (UMA) multiprocessorarchitecture. In a UMA architecture[7], aninterconnection network is situated between theprocessors and the global shared memory, as shown infigure 1. In this architecture, each processor incurs aboutthe same delay when referencing any location in theshared memory. The inlterconnection network can be acommon bus, a crossbar switch or a multistage net work.This type of architecture, s suitable for and is commonlyused in real-time aplplications, since it facilitatessynchronization and colmmunication among processorsthrough the use of shared global variables in the commonmemory.Each task ?;: n T is characterized by a processingtime Pi, arrival time Aj earliest start time or ready time Sjand a deadline Di. The tasks earliest start times arerepresentatives of delays that may be encountered inacquiring access o r esources such as the interconnectionnetwork in our model. Our objective is to maximize thenumber of tasks whose deadlines are met, once they ar eaccepted for execution, and to minimize the tasks totalresponse times

    PO PI P2 P3

    it3 s 8

    lnrerconncction Network

    Shared Memory

    Figure 1. Uniform MemoryAccess UMA) architecture3. Continuous On-Line Scheduling (COLS)

    In a system employing COLS, a dedicatedprocessor performs continuous scheduling periods whichoverlap with the remaining working processors. Theinput to each scheduling period j is the set of availabletasks (i.e. Batch(j)) in the system at the time whenscheduling starts. The result of each scheduling per iod jis a feasible partial or complete schedule which isdelivered for execution by the processing elements of thesystem. A partial schedule is one that contains only asubset of the tasks in Batch(i). A complete schedule is asequence containing all the tasks in Batch(j). In theremainder of this section we provide a graph-theoreticframework for our scheduling algorithms. We thenprovide a specification of the algorithm and itsmechanisms for selecting appropriate parameter values.3.1. Graph-Theoretic Scheduling

    Real-time task scheduling on a multiprocessorarchitecture can be regarded as the problem of searchingfor a permutation of a set of given tasks T and theirassignments to the processor s in the system such thatonce executed, they are guaranteed to meet theirassociated deadlines. Schedules all of whose tasks meettheir deadlines when they are executed are referred to asfeasible schedules. The search for a feasible schedule isperformed on a certain representation of the task space.Graphs are a common structure for representing the taskspace. An example [8,9] of the space of partial schedulesof a task set T is shown in Figure 2 for a set of four tasksT = {T,, Tz, T3, T4} to be scheduled on a UMAarchitecture P with two working processorsPE, and PE2.The nodes {vi} E V in the task space G(V,E) of thisproblem, represent partial schedules of T on P and theedges (vi,vi) E E represent transformation functions thatextend the partial schedule at one end of the edge by anassignment (T;,PE,) where Ti is the next task to bescheduled and PE, is the least loaded processor accordingto the current partial schedule. Thus, the feasible(complete) schedules, if they exist, will be at the leaf

    471

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    4/10

    nodes of such a tree. The search space has twodimensions: the processors dimension in depth and thetasks dimension in breadth. Different levels of the searchtree represent the target processors, whereas the branchesat each level represent the permutations among theremaining tasks to be scheduled.

    (+-][-+-) (+g [+-) - _Figure 2. ExampleSearchSpaceor scheduling

    T = {T,, T2, T3, T4} on P = { PE,, PE2}The search starts at the root node representing anempty schedule. In each iteration, the search continues bytrying to extend the current schedule with one more task-to-processor assignment. This is done by choosing one ofthe successors of the current node (representing thecurrent schedule) to be the new schedule. The choice ofthe next node to be expanded among the list of candidatenodes is an important decision that can significantlyaffect the performance of the scheduling algorithm.

    Expansion of a node in the graph is defined as the processof generating the successor s of that node in the graph.The successors of a node vi are the set of all the k nodes{v ,, ._., +s) which are connected to that node via direct

    links (v;, v,), . ( vi,vk) . The graph is generated, basedon information provided by the node to be expanded.When a dead-end is reached (i.e. an infeasible schedule isfound), the search process backtracks to the parent of thecurrent node. Backtracking, is done by discarding thecurrent partial schedule, and extending it by a differenttask but on the same processor since that processor is stillthe least-loaded one.Based on the size of the task space and theavailability of information about the complete task set T,the complete search space may or may not be generatedand stored prior to the start of the scheduling pr ocess. Inthe case of large task spaces and the case where thecomplete set of tasks is not known, such as aperiodic taskmodels, it is more practical to generate portions of the

    Proceedings of the 29th Annual Hawaii Intemational Conference on System Sciences - 1996task space on-line, as needed by the schedulingalgorithm. In a dynamic scheduling algorithm, issuesregarding what portion of the solution space should begenerated and how large that portion should be areimportant, since they are linked to the scheduling costand schedule quality. In the following sub-sections, wedescribe COLSs policy regarding allocation ofscheduling time and generation (examination) of portionsof the task space.3.2. Scheduling Procedure

    To perfor m the tasks by their deadlines, COLSfinds feasible schedules for a set of tasks during ascheduling period. It then delivers those schedules to theassigned processors for execution. COLS uses a novelon-line parameter tuning and prediction technique todetermine the time of a scheduling period. The allocatedtime to scheduling in this algorithm is self-adjusted basedon what is known on-line about the nature of the problemand the problem instance and also the predicted load ofthe processors at the delivery time. The algorithmcontinually self-adjusts its scheduling time based onparameters such as processor loads, slack, and taskarrival rate. The time at which the first processor in thesystem becomes idle is used to stop the schedulingprocess, n order to deliver the currently scheduled tasks,so that the processor idle times are minimized. Otherparameters such as slack and task arrival rate affect thescheduling time such that the larger the slack, the greateris the allocated time to scheduling, and the lower thearrival rate, the greater is the allocated time toscheduling. A pseudo-code of the algorithm is given inthe appendix of this paper.During an iteration of a scheduling period j, apartial feasible schedule of the set of arrived tasks iscalculated by removing the most promising node from alist of candidate nodes (i.e. the open list), generating theimmediate children of that node (expanding a node),testing the feasibility (see following sub-sections) of thepartial schedule represented by each child node andadding the feasible child nodes to the open list. If aheuristic exists based on which to prioritize the nodes onthe open list, the algorithm will use it to sort the new listwith the most promising node in front of the list.A partial schedule implies the possibility ofscheduling only a fraction of the arrived tasks andrejecting the remainder of tasks if their deadlines arepredicted to be missed, or postponing their schedulinguntil the next scheduling period if they are not ready orare not scheduled yet. Each scheduling period isterminated when there are no more partial or completefeasible schedules to examine or when allocated time tothat particular period runs out.

    472

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    5/10

    Proceedings of the 29th Annual Hawaii International Conference on System Sciences - 19963.3. Allocation of Scheduling Time

    The allocated time of scheduling period j iscontrolled by a stopping criterion as shown in figure3. Inthe formula for the stopping criterion of COLS, Batch(j)denotes the set of tasks considered in scheduling period j.Slack (Tr) is defined as the maximum time by which thestart of Tls execution can be delayed from the beginningof scheduling period j or :;I, without missing its deadlineDp Load (PE,) in the formula, denotes the load on theprocessing element PE,, at the beginning of thescheduling period, and h denotes the task arrival rate.T&,J may represent the elapsed time and may depend onthe number of nodes expanded during the jth period andthe processing speed of the processor on which thescheduling algorithm is performed. ;

    T.T j) .SMin Max ( Main-Slack, MinJ..oad} , [

    FIraiqMinSlack - Mm [Slack (TJ IT, E Bard (J) ]

    Figure 3. Stopping Criterion of COLTThe term in figure 3 is included in order to limitthe amount of time allocatfed o scheduling period so thatnone of the deadlines of tasks in the current batch areviolated due to scheduling cost. This term, however,ignores the waiting time on a processing elements readyqueue which may delay the execution of the scheduleupon completion of the scheduling time. The term wasthus added to the criterion to account for possible

    queuing delays. The term! in the stopping criterion isincluded, in order to stop a scheduling period early inbursty arrivals, so that incoming tasks are accounted forsoon after their arrivals. Under low arrival rates, thestopping criterion will allow longer scheduling periods tooptimize the tasks in the: current bat ch and to allow areasonable number of tasks to arrive to form the nextbatch. Note that the primary factor in designing thestopping criterion of COLS is to maximize the number oftasks whose deadlines are met by honoring their slacksand by maximizing utilization of processing elements viaminimization of their idle. times.At the end of each scheduling period, the partialfeasible schedule found during that period is delivered tothe ready queuesof the working processors or execution.If the period is terminated, due to failure to extend furthera feasible partial schedule (say F) to include more tasks,F is delivered for execution as the outcome of schedulingperiod j.

    3.4. Feasibility TestCOLS predicts deadline violation of tasks basedon a feasibility test that takes into account the schedulingtime of a period, as well as the current time, deadline,earliest start time and processing time of tasks.Accounting for the scheduling time in the feasibility testensures that no task will miss its deadline due to the useof resources for scheduling. The test is designed to make

    sure that a task is feasible at the end of the schedulingperiod, as well as the time at which the feasibility test isperformed.

    IF Oc + Rem-T,fj) + Smrt cl,pE,j 5 S, )THEN F is infeasibleELSE

    IF (tc + Rem-T,(j) + End (,,PEt 2 D, )THEN F is feasibleELSE F is infeasible

    Figure 4. Feasibility test of COLSThe test for adding a task q to the current feasible

    partial schedule F to obtain partial schedule F inscheduling period j is performed as shown in figure 4.Note that, according to the specified feasibility test, wemark tasks whose earliest start times are later than theirscheduled start time as infeasible. The scheduling ofthese tasks is postponed until later. This is a choice weselected over scheduling these tasks by introducingdelays into the schedule to execute them later when theirearliest start times are honored. In the test, t, denotes hecurrent time, Rem-T,(j) denotes the remaining time ofscheduling period j,Srarr (r PE denotes the scheduled tstart time of task Tt relative to other tasks in F onprocessor PEk, and .&~d(,,~s,) denotes the scheduledfinish time of task Tl relative to other tasks in F onprocessor PEk.4. Experimental evaluation

    In this section, we evaluate the performance of theCOLS algorithm and discuss the results of ourcomparison experiments with an algorithm similar to thatdesigned for the Spring kernel [6]. The experiments weredesigned to evaluate the deadline compliance capabilityof the candidate algorithms and their ability to reducetotal execution cost under different parameterconfigurations. The COLS algorithm was explained inprevious sections. In the following, we provide a briefdescription of Springs limited-backtracking algorithms.These algorithms were selected for comparison with the

    473

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    6/10

    Proceedings of the 29th Annual Hawaii International Conference on System Sciences - 1996COLS algorithms, because hey too ar e based on a graph-theoretic framework and because they are one of the fewexisting techniques which attempt an on-lineoptimization approach for solving hard schedulingproblems involving real-time aperiodic tasks. We werealso interested in investigating the cost of dedicating oneprocessor to perform the on-line scheduling in anoverlapping mode compared to the inter-leaving mode ofthe limited backtrack ing algorit hms.In other sub-sections, we describe the designissues involved in our experiments. We then provideresults of our experiments and discuss their possibleinterpretations.4.1. Limited-Backtracking Algorithms of Spring

    The limited-backtracking algorithms are graph-based algorithms which attempt to dynamically schedulea set of incoming tasks by exploring the solution spacefor an appropriate sequence containing the complete setof tasks in a batch. The set of tasks in one batch aredetermined by the set of tasks that have arrived into thesystem at a time prior to the start of a scheduling period.Feasibility tests are designed to detect an infeasiblesequence of tasks. Once an infeasible node is reached, thesubtree below that node is pruned and the algorithm hasthe option of backtracking out of that node to exploreother options or to stop and announce failure. Byannouncing failure, the algorithm rejects the entire taskset in a batch. In order to keep the scheduling cost low,the algorithms employ a limited backtracking techniquewhich is as follows. Assuming no backtracking, thealgorithm follows a single path in the solution spaceattempting to reach a leaf node that schedules all tasksfeasibly. If such a leaf node is reached, the algorithmannounces success and delivers the tasks for execution.If, on the other hand, the single examined path is deemedinfeasible, the algorithm discards all the tasks in thecurrent batch and attempts to schedule tasks in a newbatch. With one level of backtracking, the algorithm willhave another chance to explore other schedules and so on.These algorithms ignore the effect of scheduling costs onschedule quality and on delivery of feasible schedules.Some of the tasks scheduled by Spring may have missedtheir deadline by the time they are submitted forexecution. The level of backtracking in these algorithmsis a fixed parameter. The algorithms also ignore the effectof accepting partial feasible schedules to find which ofthe scheduling algorithm uses much resources.For the purpose of our experiments, weimplemented an interleave scheduling and executionversion of the limited backtracking algorithms. In thisscheme, a processor PE, performs scheduling of a batchof tasks as explained in the previous paragraphs. As partof this scheduling period, the scheduling processor (PE,)assigns tasks to all processors, including to itself. Once

    474

    the scheduling of the batch is completed, the taskassignments are delivered to processors. The processors,including PE,, will then execute the tasks that areassigned to them. PE, will start the next schedulingperiod j, once it has executed all the tasks that it assignedto itself during scheduling period j- 1.4.2. Experiment Design

    In the experiments, a Poisson job arrival processwas used to simulate a natural sequence of aperiodic taskarrivals. The time window t, within which arrivals areobserved, was set to 200 time units. The arrival rate hranged from 0.5 to 5. We modeled the delay in obtainingaccess to the interconnection network for executing taskI;: by that tasks earliest start time S, Sis are assigned avalue, selected with uniform probability, from theinterval (Ai>S-), where Smur = Si xM. M is aparameter used to model the degree to which the Sis andAi'S are set apart. We chose 3 as the value of thisparameter for our experiments.

    The processing times Pi of tasks Ti are uniformlydistributed within the interval between I and 50 timeunits. Deadlines Di are uniformly distributed in theinterval (Endi, Dm,) where Endi is the finish time of Tiassuming it starts at Si (i.e. Endi = Si + Pi), and D,, is amaximum value a deadline can have and is calculated asDm,,r= Endi x SF. SF is a parameter that controls thedegree of laxity in task deadlines and ranges from 1 to 10in our experiments. Larger SF values represent largerslack, whereas small SF values represent tight deadlines.Note that as SF becomes larger, it will be possible to findfeasible schedules with less scheduling effort.Our target architecture is a Uh4A multiprocessormodel with 10 processing elements. Note that for COLS9 out of the 10 processing elements actually performtasks, whereas in the limited backtracking algorithms, all10 processing elements are involved in task execution.The results of our experiments do reflect the performanceof COLS with 9 working processors versus theperformance of the limited backtracking algorithms with10 working processors.The metrics of performance in our experimentswere chosen to be deadline compliance (hit ratio) and-total execution cost. Deadline compliance or hit ratiomeasures the percentage of tasks which have completedtheir execution by their deadline. The execution costmeasures the total execution time spent on schedulingand executing all t he tasks in a run. By this metric, wewanted to study both the load-balancing performance andthe effect of scheduling cost. In both algorithms, wemeasure the scheduling cost as the logical time spent ingenerating the nodes of the tree representing the solutionspace. Since the time to generate a node in the tree

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    7/10

    Proceedings of the 29th Annual Hawaii International Conference on System Sciences - 1996depends on the processing speed of the processingelement on which the algorithm r uns, we defined anexpansion rate parameter ER to have a generic measureof scheduling effort in logical time units. ER defines thenumber of nodes that a particular processor can generateand examine per unit of time. The value of ER waschosen to be 5 nodes/unit-of-time in the experiments.One of our algorit hm parameters is the constantcoefficient k of the term k/h in the stopping criterion ofCOLS (see igure 3). This parameter mplies the expectedtask batch size for each scheduling period of COLS andwas set to 5 for the experiments. Finally, the degree ofbacktracking in the limited-backtracking algorithmsconstitutes another parameter of our experiments. Inprevious experiments [5], we have studied theperformance of the limitejd backtracking algorithms withdifferent backtracking levels ranging from 1 to 10. Theresults of this experiment show that there does not exist afixed value for the level of backtracking which canproduce good performance under different parameterconfigurations. Too small or too large backtracking

    levels are shown to produce poorer results. For ourexperiments reported here, we chose backtracking level 2(BT-2), since this level of backtracking (or others closeto it) were shown to provide the best performance undera variety of conditions. The remainder of this sectiondiscusses he results of the experiments.4.3. Comparison of Deadline Compliance

    In the remainder of this section, we present theresults of our experiments in which we compared theperformance of the COLS and the limited-backtrackingalgorithm with backtrac:king level 2 (referred to asBT-2). Figures 5 through 10 show the performance of thetwo algorithms in terms of the ratio of the task deadlinesthat were met using a. Uh4A architecture with 10processors. Recall that COLS is using only 9 processorsfor computation since one processor is dedicated toperform continuously the on-line scheduling task. As isshown in the tigures, COLS outperforms BT-2 under allparameter configurations.

    Figure 5. Comparison ofdeadline compliance (X=0.5)

    Figures 5,6 and 7 show the results as the degreeof laxity varies for arrival rate values 0.5, 3 and 5,respectively. As is evident from these figures, the gapbetween COLS and BT-2 widens as the arrival rateincreases, so much that for arrival rates 3 and 5, COLSoutperforms BT-2 by a factor of 2 and 4, respectively.Figures 8, 9 and 10 show the results as the arrival ratevaries for slack-factor values 3, 5 and 10. The figuresshow again, that COLS outper forms BT-2 by widemargins, particularly for lower degreesof laxity.

    0 2 4 Laxity6 8 10Figure 6. Comparison of deadline compliance (X=3)

    0 2 4 Laxity6 8 I(

    Figure 7. Comparison of deadline complian ce (h=5

    80

    hi 40t

    0 2 4Rnre of Amimi~

    Figure 8. Comparison of deadlline compliance (SF=3)

    475

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    8/10

    Proceedings of the 29th Annual Hawai i International Conference on System Sciences - 1996These results demonstrate the potentialimprovement in predictability and in the ability toguarantee deadline compliance when additionalresources are allocated for performing more sophisticatedscheduling and when the time and complexity of thescheduling task are controlled directly.

    0 2 4Rate of Arrivals

    Figure 9. Comparison of deadlline compliance (SF=5)

    0 2 4Rate of Arrivals

    Figure 10. Comparison of deadlline compliance (SF=IO)4.4. Comparison of Total Execution Costs

    Another interesting metric of performance incomparing the two algorithms is the total time eachalgorithm spends to schedule and execute the total task-set, as the number of processors increases. Figures 11 to15 depict the total execution times of COLS and BT-2 asthe number of processors increases. As is shown in thesefigures, COLS has lower response times than BT-2,although it is using 10% less of its processing power fortask execution than BT-2.Figures 11, 12 and 13 show the results for arrivalrate values 0.5,3 and 5 while the degree of laxity is fixedto 5. The figures demonstrate the ability of COLS toreduce response times more effectively than BT-2 as thenumber of processors increases. COLS seems to saturateits load-balancing performance under higher number of

    processors. This is due to the limited depth to which it isallowed to search, due to limited time tha t is allocated forits scheduling periods

    0 2 4 6 8 10Number of Processon

    Figure 11.. Comparison o f execution caste (SF=5, h =O..S/

    Figure 12. Comparison of execution caste (SF=5, )L=3)

    \2200 \ b -\ \E \ / P - -, \x \ / \

    e2coO Yc

    4-l 2 4 6 8 11Number of Processon

    Figure 13. Comparison of execution caste (SF=S, x=5)

    476

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    9/10

    0 2 4 6 8 10Number of Pmcesrors

    Figure 14.. Comparison of execurioncosfe (SF=3, L3)Figures 14 and 15 show a progression ofperformance as the degr ee of laxity increases. Thesefigures demonstrate the total task execution costs forslack-factor values 3, 5 and 10, respectively when thearrival rate is fixed to a value of 3. As is shown in the

    figures, COLS consistently performs at a reduce d totalexecution costs compared to BT-2.

    0 2 4 6 8 10Numkr of Pmcessors

    Figure 15. Comparison of execution aste SF=3, RIO)We hope that results of these experiments willdemonstrate the potential1 n improving performance bydedicating resource to performing sophisticated on-lineoptimization and by explicitly accounting for thetradeoffs between scheduling time and the quality of theschedules produced.

    5. ConclusionIn this paper, we have propo sed a set of dynamic

    scheduling algorithms called Continuous On-LineScheduling (COLS) that are aimed at scheduling a set ofaperiodic semi-hard deadlines on the processors of aUMA architecture. Semi-hard deadlines were termed tobe a class of real-time tasks n which not executing a task

    Proceedings afthe 29th Annual Hawaii International Conference on System Sciences - 1996

    has higher utility than executing the task and missing itsdeadline. COLS was designed to explicitly address afundamental tradeoff in dynamic scheduling, namely thebalancebetween he time allocated to scheduling and hequality of the resulting schedules. The algorithmperforms dynamic scheduling by dedicating a processorto perform scheduling continuously, in parallel with ot hertask executions. COLS controls scheduling cost toproduce high deadline compliance ratios in the availabletime. COLS automatically calculates the amount of timeto allocate to scheduling in different scheduling periodsusing a stopp ing criterion that, once met, will interruptthe scheduling process, in order to deliver the set ofscheduled asks for execution. COLSs stopping criterionis basedon a combination of different parameterssuch asslack, task arrival rates, and processor loads. From theresults of our experiments we conclude that veryeffective stopping criteria can be design ed to a dapt theduration of scheduling periods automatically, in order toobtain high deadline compliance. We also conclude thatcentralized scheduling in multiprocessor architectures,particularly for real-time applications has a greatpotential in improving performance and s thus worthy offurther investigation. Our experiments show that thedeadline compliance of COLS is higher compared toother existing algorithms under a wide range ofparametervalues for a number of parameters.The resultsalso show that COLS out performs the existing t echniquesin terms of total execution costsAs part of our future research, we plan toinvestigate the effect of different heuristics on theperformance of our algorithms. We also plan to exploreand compare a number of different problemrepresentationsand their effect on deadline complianceof real-time tasks.Acknowledgments

    We would like to give many thanks to ProfessorKrithi Ramamritham, discussions with whom has guidedthis research hroughout ts life cycle. We would also iketo thank Professor Shashi Shekhar, Professor VipinKumar, and Professor Laveen Kanal for theircontributions and comments. We are grateful to thereferees or reviewing this paper and providing valuablecomments. This resea rchhas been supported, n part, bya grant from The ResearchGrant Council of Hong Kong(Grant No. DAG 94/95EG29).References

    1. T. L. &savant and J. G. Kuhl, Taxonomy ofScheduling in General-Purpose DistributedComputing Systems, IEEE Tr ansact ions onSoftware Engineering, vol. 14, no.2, pp.l41-1.54, ebruary 1988.

    47 7

    eedings of the 1996 Hawaii International Conference on System Sciences (HICSS-29)-3425/96 $10.00 1996 IEEE

  • 7/28/2019 Dynamic Scheduling Rta Periodic Tasks Mp A

    10/10

    2. M. G. Norman and P. Thanisch, Models ofMachines and Computation for Mapping inMulticomputers, ACM Computing Surveys,vol. 25 no.3, pp.263-302, September 1993.3. M.R. Garey and D. S. Johnson, ComplexityResults for Multiprocessor Scheduling UnderResource Constraints, SIAM Journal of

    Computing, pp.397-411, 1975.4. A. Burns, Scheduling Hard Real-TimeSystems: A Review, Software EngineeringJournal .vol.6, no.3, pp.1 16-28, May 1991.5. B. Hamidzadeh and Y. Atif, DeadlineCompliance of Aperiodic Semi-Hard Real-Time Tasks, Submitted to the ACMSIGMETRICS, 1996.6. J. A. Stankovic and K. Ramamritham, TheDesign of the Spring Kernel, Proceedings ofthe Real-Time Systems Symposium, pp. 146-157, IEEE, Dec. 19877. K. Hwang, Advanced Computer Architecture:Parallelism, Scalability, Programmability,McGraw-Hill Inc., 1993.8. W. Zhao and K. Ramamritham, Simple adIntegrated Heuristic Algorithms for SchedulingTasks with Time and Resource Constraints,Journal of Systems and Software, 1987.9. W. Zhao, K. Ramamritham, and J. A.Stankovic, Preemptive Scheduling UnderTime and Resource Constraints, I EEETransactions on Computers, August 1987.

    Appendix: Pseudo-code for COLSPROCEDURE COLS (startmode);VAR queuesucc-list : queue-of-nodes;x,current-node.new-start : node;BEGIN

    (* Search procedure *)WHILE NOT [ leaf(head(queue))OR (stopping-criterion)

    OR empty (queue) ] DO

    Proceedings of the 29th Annual Hawaii Zntemational Conference on System Sciences - 1996

    BEGIN1 current-node := head(queue);I delete(current-node,queue);I succ-list := successors(currentgode);I FOR each x IN succ-list DOI BEGINI I IF feasible(x) THENI I insert(x,queue);I ENDEND(* End of the search procedure *)(* head(queue) contains the complete/partial

    schedule. If a dead-end is reached i.e empty(queue) istrue, then current-node contains the last feasible partialschedule *)

    (* Deliberation procedure *)I IF leaf(head(queue)) THENI assign-complete-schedule(head(queue));I ELSEI IF (stopping-criterion) THENI assign-partial-schedule(head(queue));I ELSEI assign-partial-schedule(current-node);I(* End of the deliberation procedure *)

    (* Prepare the next scheduling-phase byallocating scheduling-time, building the next bench oftasks to be scheduled and predicting the processors loadwhen the previous schedule is assigned. *)

    SC:= adjust-scheduling-time;current-task-set := Remaining-Task-S uArrived-Task-Set;current-load := predict-load (all-processors);new-start := create-node(current-task-set,current-load);(* Resume scheduling of current-task-set

    according to the predicted processors load *)COLS (new-start);

    END.

    478