Luận án tiến sĩ: Resource management for dynamic, distributed real-time systems

31 4 System Model 34 5 Robust Task Allocation for Dynamic Distributed Real-time Sys-tems 37 5.1 Robust allocation for the one-dimensional problem.. However,the deployment of distributed

Dynamic, Distributed Real-time

Systems

A dissertation presented to

the faculty ofthe Russ College of Engineering and Technology

In partial fulfillment

of the requirements for the degreeDoctor of Philosophy

Dazhang GuNovember 2005

the Russ College of Engineering and Technology of Ohio University

3247487 2007

UMI Microform Copyright

All rights reserved This microform edition is protected against unauthorized copying under Title 17, United States Code.

ProQuest Information and Learning Company

300 North Zeeb Road P.O Box 1346 Ann Arbor, MI 48106-1346

by ProQuest Information and Learning Company

Resource Management for Dynamic, Distributed Real-time Systems

Dennis IrwinDean, Russ College of Engineering and Technology

Director of Dissertation: Lonnie R Welch

A current challenge facing resource management is the need to deploy real-timesystems in dynamic operational environments The systems are often affected by un-predictable environmental factors that cannot be known a priori and have no mean-ingful worst-case estimates As a result, traditional resource allocation techniques

do not apply Current attempts to address these systems have been limited

This research addresses the resource management problem for dynamic, uted real-time systems (DDRTSs) A resource allocation approach is developed forthese systems that offers explicit real-time guarantees with maximized tolerance (ro-bustness) of unpredictable environment changes This work has developed (1) areal-time computing model that incorporates environmental factors, (2) metrics thatcharacterize robustness, and (3) resource allocation algorithms that find feasible,robust allocations The approach is validated by both theoretical analysis and ex-perimentation The main contribution of the work is a reliable resource managementsolution for DDRTSs, which allows real-time applications to be versatile in real worldenvironments

distrib-Approved:

Lonnie R WelchProfessor of Electrical Engineering and Computer Science

Table of Contents

3.1 Problem taxonomy 26

3.2 Classification of existing work 29

3.3 New problems 31

4 System Model 34 5 Robust Task Allocation for Dynamic Distributed Real-time Sys-tems 37 5.1 Robust allocation for the one-dimensional problem 39

5.1.1 Order of dynamic real-time systems 39

5.1.2 Robustness analysis 41

5.2 A multi-dimensional robustness metric 48

5.2.1 Search space reduction 50

5.3 Robust allocation for the multi-dimensional problem 54

5.4 Experiments 58

5.5 Summary 66

6 Robust Task Allocation with Improved Robustness Metric 67 6.1 An accurate robustness metric 68

6.2 A robust allocation algorithm 72

6.3 Analysis of the algorithm 74

6.3.1 A robustness lower bound for linear workload functions 74

6.3.2 A robustness lower bound for general workload functions 76

6.3.3 Proofs of optimality bounds 79

6.4 Experiments 83

6.5 Comparisons of the robustness metrics 91

6.6 Summary 94

7 Robust Allocation of Tasks with Service Levels 96 7.1 Service level extensions to the system model 96

7.2 A robust allocation algorithm 97

7.3 Analysis of the algorithm 99

7.4 Experiments 102

7.5 Summary 106

List of Figures

1.1 A generic air defense system 101.2 The QARMA architecture 134.1 Example of a general control system 35

5.1 Asymptotic approximation ratio as a function of order k and dent utilization δ 485.2 Contour lines of robustness metric in two dimensions 495.3 Different tangents between feasibility boundary and robustness metriccontour 525.4 Illustration of the search for an allocation with the maximum robust-ness metric 535.5 Comparisons of robustness values found by RAFF-n, RABB-n, andbounds from absolute and asymptotic approximation ratios underRMS or EDF scheduling for three orders of DDRTS 595.6 Comparisons of robustness values found by RAFF-n, RARN-n, RAHC-

indepen-n, and RASA-n for large problem instances under RMS and EDFscheduling for three orders of DDRTS 625.7 Comparisons of running times of RAFF-n, RARN-n, RAHC-n, andRASA-n for large problem instances under RMS or EDF schedulingfor three orders of DDRTS 635.8 Significance test for RAFF-n with RMS and EDF scheduling systemsunder three orders of DDRTS 64

6.1 Deficiencies of two previous metrics 686.2 Illustration of the new metric with l = 2 and l = 3 716.3 Comparisons of the approximation algorithm performance with itsanalytical lower bound in small, medium, and large instances 856.4 Comparisons of robustness quality and running time in small probleminstances 866.5 Comparisons of robustness quality and running time in medium prob-lem instances 87

6.6 Comparisons of robustness quality and running time in large probleminstances 886.7 Significance test for Approx in medium and large problem instances 896.8 Comparison of number of violations 916.9 Comparison of maximum workloads 936.10 Comparison of accuracy of metrics in robustness characterization 94

7.1 An illustration of the algorithm’s search process 997.2 Utility comparison among the approximation algorithm (Approx), ran-dom search (RN), and simulated annealing (SA) 1037.3 Running time comparison among the approximation algorithm (Ap-prox), random search (RN), and simulated annealing (SA) 1047.4 Comparison between the utility by the approximation algorithm (Ap-prox) and its theoretical lower bound 1057.5 Robustness comparison among the approximation algorithm (Approx),random search (RN), and simulated annealing (SA) 105

List of Tables

3.1 R|T|O|E taxonomy for task allocation in distributed real-time systemswith environmental variables 273.2 Distribution of dominating problems 32

5.1 Max robustness value found with RARN-n, RAFF-n, RABB-n rithms under three scenarios 666.1 An illustration of the robustness metric 706.2 Table of execution time parameters 75

algo-Chapter 1

Introduction

Distributed real-time systems provide guarantees on timing requirements whileboosting performance through concurrency in computing resources They are usefulfor building large and complex real-time applications Systematic resource manage-ment is necessary to properly allocate resources to achieve the guarantees However,the deployment of distributed real-time systems into dynamic operational environ-ments poses a new problem for resource management Performance of these systemsare affected by environmental factors that cannot be known a priori, and traditionalresource allocation techniques do not apply A current area of active research isresource allocation with an objective of robustness, which seeks to maximize an al-location’s tolerance of unpredictable environment changes without jeopardizing fea-sibility Such robust allocation reduces the necessity of reallocations, which aretime-consuming both to compute and to enact Additionally, reallocations are notappropriate for stateful real-time applications whose complex states are costly torecover The problem is being studied by researchers A heuristic mixed-integerprogramming approach was proposed by Gertphol et al (2002) to maximize the al-lowable increase in load for a static allocation Several heuristic algorithms were used

in Shestak et al (2005) to find robust allocations for periodic task strings Juedes

et al (2004) developed heuristic algorithms to find robust allocations for dent, periodic real-time tasks

Figure 1.1: A generic air defense system.

The notion of tasks that have dependencies on environmental factors originatedfrom the study of a generic air defense system in Welch and Shirazi (1999) The sys-tem is sketched in Figure 1.1 The detect task identifies threats to a defended entity.The task runs periodically and performs the functions of filtering and evaluatingradar tracks When a threat is detected, the detect task triggers the engage task,which fires a missile at the threat After a missile is in flight, the guide missile taskkeeps the missile on the correct course The guide missile task executes periodically;uses sensor data to track the threat; recalculates the flight path for the missile; andissues guidance commands to the missile During operation, there may be multiplereplicas of the three tasks running concurrently When the number of radar tracksgrows too large for a single replica of the detect task to process within the requiredtime, one or more replicas are created and the radar tracks are partitioned amongthem In a similar manner, the guide missile task is replicated as necessary to meetdeadlines, and replication is also used for the engage task when heavy workloads areanticipated

All three of the tasks have resource needs that are environment dependent Theexecution time of the detect task is primarily workload-dependent Since the task

evaluates each radar track to determine if it is a potential threat, its execution time

is a function of the number of radar tracks in the environment The workload of theengage task is also variable since it is activated by the number of tracks deemed asthreats Similarly, the work performed by the guide missile depends on the number

of missiles in flight Thus, an important problem to solve for this system is how

to allocate resources to the tasks in a manner that allows real-time constraints to

be met and that minimizes the need for reallocations (which create overhead in thesystem) Also, it is desirable to know the maximum numbers of missiles and radartracks that can be sustained by a given configuration

Execution times of tasks in these dynamic distributed real-time systems, orDDRTSs, must be regarded as functions of unpredictable environmental factors be-cause the running time of an algorithm generally depends on sizes of their inputs.The algorithms implemented in real-time tasks are no exception, Gu et al (2004).Ravindran et al (2000) realized that employing the systems in unpredictable envi-ronments may affect these input sizes and result in varying execution times of tasksthat cannot be known in advance Meaningful worst-case execution times (WCET ’s)cannot be given Therefore, Tia et al (1995); Hu et al (2001); Wandeler et al (2004);Manolache et al (2004) all pointed out that traditional periodic task scheduling andallocation based on worst-case estimation are not applicable

Existing approaches to address such systems include adaptive resource allocation,probabilistic deadline guarantee, and proactive robust allocation However, these ap-proaches have not yet provided satisfactory resource allocation solutions for dynamicreal-time systems

Adaptive resource allocation reacts to changes in environment and a system’sresource needs by passively reallocating the system, Welch et al (1998, 1999); Ravin-dran et al (2000) Thus it is vulnerable to frequent environment changes that triggercostly reallocations and result in thrashing, and no guarantees can be made Further,

it is often infeasible to reallocate stateful applications in real-time

The probabilistic model characterizes unpredictable task execution times as dom variables, and the objective is to derive statistical confidence in deadline misses,

ran-Tia et al (1995); Hu et al (2001) The task allocation problem was studied for tems with dependencies and multiple processors by Manolache et al (2004) How-ever, the allocation search and evaluation were expensive The probabilistic modelsinherently lack any hard deadline guarantee.

sys-Proactive robust allocation approaches, such as Gertphol et al (2002); Ali et al.(2003); Shestak et al (2005), are still primitive They employ coarse robustness met-rics, which can result in poor allocations The robustness metric of Ali et al (2003)was based on l-2 norm It measures the radius of maximum environment perturba-tion environment without violating feasible boundaries However, the metric onlypartially characterizes feasible regions by using an intangent sphere, and more seri-ously, no algorithm was developed to optimize it Furthermore, existing approachesignore real-time scheduling and feasibility CPUs were assumed to be fair-shared

in Gertphol et al (2002) A special scheduler based on tightness was assumed byShestak et al (2005), but no feasibility guarantee was developed

These shortcomings are addressed by this research First, a new model thatexplicitly incorporates environmental factors is presented It characterizes task exe-cution time as functions of the environment Second, metrics that accurately charac-terize the robustness of allocations are introduced Robust task allocation problemsare defined based on the metrics Third, allocation algorithms are designed thatuse the metrics to find feasible and robust allocations They are approximationalgorithms with fast running time and scalability, which are necessary for moderndistributed systems that may contain hundreds of processors and thousands of tasks.Theoretical bounds for their solution quality are derived, allowing guarantees to bemade on the minimum robustness that can be achieved by the algorithms Perfor-mance of the algorithms are experimentally validated by comparisons with baselinealgorithms implementing standard search techniques

The resource allocation algorithm developed in this research will benefit resourcemanagers, one of which is shown in Figure 1.2 QARMA, short for the Quality-basedAdaptive Resource Management Architecture by Fleeman et al (2004), serves as abasis for integration of existing CORBA services and management mechanisms into

Files Configuration Tool

Specification

Software Performance Detector Host Detector

QARMA Resource Management Service

Service

Software Performance Monitor

Host Monitor

Enactor Service

User Applications Computing Environment &

Resource and Environment

Resource &

Software

Instrumetnation

user management commands

Figure 1.2: The QARMA architecture

a single, coherent framework for resource management, and it is easily extendable toallow the use of new resource management mechanisms It consists of three majorcomponents: the System Repository Service, the Resource Management Service, andthe Enactor Service The System Repository stores both static and dynamic informa-tion that describe the software systems and resources in the computing environment.Information is provided from specification files and gathered by various monitors atrun-time The Resource Management Service (dashed box) is responsible for usinginformation in a system repository to decide what actions should be performed toensure that performance requirements are satisfied and system performance is op-timized The Enactor Service receives instructions from the resource managementservice about actions to perform and enacts them The actions may include the ad-justment of quality settings, the assignment or migration of tasks, and the replication

of tasks The algorithm as part of the Resource Management Service will offer bothfeasibility and robustness in these adjustments

This document is organized as follows Chapter 2 reviews the related work ter 3 develops a taxonomy for resource allocation problems for DDRTS Chapter 4introduces a new model for real-time computing that considers the effects of dynamicenvironment Chapter 5 and 6 develop algorithms and analysis to solve the problem

Chap-of robust resource allocation Chapter 7 further considers the robust resource

allo-cation for the systems that have service attributes and require utility optimization.Chapter 8 draws the conclusion.

Chapter 2

Literature Review

This chapter reviews related work Work that addresses systems in dynamic vironment is examined first Then work on task allocation in general is reviewed Aproblem of maximum allowable increase in load was introduced in Gertphol et al.(2002) Its goal was to find a feasible allocation that maximizes a system runtimeparameter A mixed-integer-programming (MIP) algorithm was designed to findthe allocation The work used end-to-end latency requirements and considered bothcomputation and communication latencies However, for these end-to-end real-timetasks, no real-time scheduling issues were considered to guarantee feasibility, such assub-release time and deadline assignments in Bettati and Liu (1992); Liu (2000a)

en-It was assumed that all execution times can vary, but the variances were treated aslinear functions of just one system parameter The proposed algorithm solved theproblem using MIP but a simplifying heuristic had to be applied first No provableoptimality bound was provided Its performance was tested through simulations Anorm-based robustness metric was proposed in Ali et al (2003) Multiple runtimeparameters were considered The metric was defined as a radius for maximum al-lowable perturbation along any direction in the parameter space without violatingsystem performance bounds The upper and lower bounds defined for system perfor-mance form a hyperplane in the space, and the radius is the perpendicular distancefrom the operating point to the plane However, the metric directly used l2 norm

of the parameters, which cannot reflect importance differences among parameters

More seriously, only the generic robustness metric was proposed, and no optimizationalgorithm was actually developed.

Juedes et al (2004) studied a robust task allocation problem for dynamic tems with one workload variable The problem was to find the maximum allowableworkload (MAW) for the system, when real-time tasks can be feasibly scheduled onevery processor using rate-monotonic scheduler The task’s execution times weremodeled to have a workload-independent portion and a dependent portion, which isnon-decreasing with respect to workload An algorithm was developed that searchesthe workload using binary search and allocates tasks under each of the workloadusing greedy first-fit The schedulable utilization of rate-monotonic scheduling wasused to test feasibility on each processor Several heuristic algorithms were intro-duced to experimentally compare with the performance of this approach, and theywere simulated annealing, hill-climbing and random search An approximation ratiofor the maximal allowable workload was proved in Juedes et al (2003) for identicalprocessors and tasks with well-behaved execution times defined by two conditions,which are satisfied by many algorithmic running-time functions Aber et al (2004)expanded the set of allocation algorithms to include tabu search, genetic algorithm,dynamic programming, and optimal branch-and-bound search The experimentalresults indicated that the greedy first-fit algorithm performs quite well in finding theMAW compared to these heuristic or exhaustive algorithms, and it offers great cost-efficiency in time and space complexity However, the work was limited to only oneworkload variable, although having multiple variables is very likely in many systems.Zhao et al (2005) further considered the problem of robust allocation when tasksare replicable, and several heuristics were developed

sys-A different approach regarded task’s unpredictable execution times as randomvariables and statistical guarantees for deadline misses were derived The semi-periodic task model by Tia et al (1995) assumed execution times are profiled withprobability histograms, and two methods were presented to compute each task’sdeadline miss probability The first method assumed fix-priority scheduler in order todevelop a probabilistic time-demand analysis Traditional time-demand analysis was

extended to consider randomness in task’s execution time and probabilistic boundswere developed The second method separated the semi-periodic task into a fixedexecution time task and a sporadic task, which arrives with a probability depending

on the partitioning Then the former was scheduled with RM or EDF normally, whilethe latter was run in a sporadic server or slack stealer However, the analysis wasrestricted to a single processor, and task allocation was treated by simply eveningthe worst-case total utilization on every processor Manolache et al (2004) similarlyviewed execution time as a probability-density distribution In addition, tasks haddependencies and there are multiple processors Given probability thresholds fordeadline misses in tasks, the optimization goal was to minimize their sum of deviationbeyond the thresholds Tabu-search was used to explore the space of processorassignment and task priority The approach was shown to achieve a much bettergoal than allocating simply based on average execution times However, the searchand deviation evaluation were expensive

Event stream model by Wandeler et al (2004) attributed varying execution times

to a finite set of event types that incur different workloads It was argued whenthere is certain regularity among events, it can be exploited to give better workloadestimation than using worst-case estimation The workload estimation was based ontype-rate curves characterizing event regularity, which can be analytically generatedusing finite state machine The capture of the regularity in MPEG-2 I-P-B framesequence was demonstrated In practice however, the type-rate curves have to beprofiled when no pre-knowledge is given, and they may be as poor as worst-caseestimation

Varying task execution times were treated by Chen et al (2000) as distributedgeneralized multi-frame tasks (DGMF) Each task has multiple frames with differentexecution times, deadlines, and periods The release of a latter frame must be laterthan the release of a former frame plus period of the frame Each frame of a taskcan be executed on a different host A deadline was given separately for each frame

An optimal but computationally intensive feasibility test was given for the lability of a set of the DGMF tasks, using concept similar to critical instance A

schedu-less expensive schedulability criterion was also given It derived solutions for priorityassignment in several special cases: the deadline-monotonic assignment is optimal fortasks with same frame deadlines and for tasks with equal frame execution times; therate-monotonic assignment is optimal for tasks with frame deadline equaling period.However, the sequence of frames with varied execution times had to be known inadvance.

Solving task allocation problems in general allows distributed real-time systems

to employ multiple processors to increase concurrency while providing real-time formance guarantees Although the benefit of employing multiple processors is sig-nificant for larger real-time systems, the problem of the task allocation is difficult Atask’s execution portion is often divided into distributable and individually schedu-lable modules to exploit parallelism offered by multiple processors However, themodules may cost varied execution time depending on the processor, and they may

per-be constrained by certain precedence due to the task’s execution flow Further, theprecedence, often formed as communication, may incur varied communication delaybased on the processors the communicating tasks reside on In addition, timing re-quirements on the system are often not imposed on individual schedulable modules,but on an end-to-end path of modules Over the years, researchers have formulatedmany models to simplify the problem and focused on different aspects But thesereduced models were still often found to be NP-hard, as in Bettati and Liu (1992);

Xu (1993); Lee et al (1999a); Lo (1988) Solutions have been proposed to tacklethese problems, but many are optimal in very special cases and only heuristics ingeneral Next the work is reviewed

For tightly-coupled processors, such as multi-processor computers and vectorcomputers, it is possible to employ a global scheduler and perform global level real-time multi-processor scheduling, Liu (2000a) If tasks to be scheduled on multi-processor computers have deadlines but are preemptable, Martel (1982) designed anoptimal algorithm that runs in polynomial time However, communication delay orcontext switching can be expensive For tasks that are not preemptable and havedependency, Xu (1993) proposed a optimal global scheduling algorithm based on

branch-and-bound search, which starts with an EDF assignment and incrementallyimproves upon it However, the running time was prohibitive, and results in theexperiment were no more than three processors.

Lee et al (1999a) studied a theoretical problem of multi-dimensional QoS cation for tasks that consume multiple finite resources It relaxed the earlier singleresource restriction in Lee et al (1999b) Each QoS is mapped to a utility value, andthe objective is to maximize the overall system utility The problem was shown to beNP-hard by a reduction from knapsack Dynamic programming and mixed integerprogramming solutions were developed In order to reduce running time, an approx-imation algorithm was designed Using convex-hull based on the norm of penalizedresource vector, utility-resource pairs of system tasks were filtered and converted to

allo-a one-dimensionallo-al list, sorted in increallo-asing order of utility Then in this order, theutility modes of tasks in the list were used to pack tasks onto vectors of resources.The utilities of tasks keep being refined until a task’s mode cannot increased further.Meanwhile, a search is conducted on the multi-dimensional penalty factor to refinethe maximum Experiment showed that its solution quality was over 95% optimaland its running time was a hundredth

However, distributed real-time systems are often not run on tightly-coupled tems, and scheduling is done locally Running real-time tasks on loosely-coupledsystems generally involves two steps: (1) the allocation of tasks (or their schedulablemodules) onto processors, and (2) the scheduling the allocated tasks (modules) onevery processor

sys-When the real-time tasks are independent, problems of both steps can be fairlyeasily solved Mature results from real-time scheduling on single processors can beused Oh and Baker (1998) derived a sufficient utilization bound for first-fit allocation

on processors scheduled rate monotonically Similarly, Lopez et al (2004) derived asufficient utilization bound for processors scheduled by EDF

When there exist dependencies among the real-time tasks, problems of both stepsbecome very difficult It generally involves modifying task (modules) release timesand sub-deadlines to preserve the dependency, allocating tasks subject to schedulable

utilizations of local schedulers, and partitioning sub-deadlines to ensure end-to-endlatencies can meet specified deadlines To start from a simpler problem, some re-searchers assumed the allocation is already specified, and they focused instead onthe solution to the scheduling step Although the reduced problem still turned outNP-hard, Bettati and Liu (1992), feasibility analysis and optimality proofs could begiven in a few special cases.

Bettati and Liu (1990) studied the problem where an end-to-end task has a chain

of n subtask located on n processors The problem was treated as a flow shop lem, and schedules was constructed on each processor based on the effective releasetime and deadline set for subtasks Bettati proved that the priority driven EEDF isoptimal for non-preemptive “identical-length” tasks When release time and dead-line are multiples of execution time, EEDF are directly applied When release timeand deadline are arbitrary, they are modified based on Garey and John’s forbiddenregions concept He also proved that a non-priority driven algorithm A is optimal fornon-preemptive “homogeneous” tasks The algorithm identifies a bottleneck proces-sor that has the largest execution time and schedules subtasks on the processor usingEEDF Then the schedule is propagated forward by executing subtask on succeedingprocessors once the previous finishes, and it is propagated backward by releasingsubtask on preceding processors at a time exactly the execution time amount earlierthan the next Bettati and Liu (1992) considered a recurring flow shop model in asimple task sets case The tasks were assumed to be “identical-length” tasks withidentical release times, and only one loop in the processor sequence was allowed Anoptimal algorithm R was given It starts with a schedule on the repeated processorthat delays the effective release time of later issues of subtasks of Ti from the firstissues by the amount qt and performs EEDF Based on this schedule, schedules ofother processors set subtask release times accordingly The paper considered arbi-trary task set by using a heuristic that boosts subtasks execution times to be aslarge as the maximum on each host, and then employing the algorithm for the now

prob-“homogeneous” tasks Periodic tasks with precedence relations were addressed with

a periodic flow shop model in Bettati and Liu (1992) A task was viewed as a chain

of jobs that have been allocated to processors, and it is associated with a period,

a release time and a deadline All recurring jobs of a task on each processor weremodeled as a subtask, and all subtasks on a processor were assumed to be scheduledlocally according to RMS However, subtasks are generally not periodic, and they arejust related by sibling job precedences To make them periodic for the application

of uniprocessor scheduling algorithm, heuristics were developed that derive subtaskdeadlines from those of parent tasks to distribute the slack, and synchronizationprotocols are used to control the release of sibling subtasks Dependencies amongsubtasks in a task were removed by setting their jobs’ phase δpi later than its pre-ceding job This is because the preceding job can be guaranteed to have a responsetime less than δpi according to the classic uniprocessor schedulability analysis fortasks with arbitrary deadline by Lehoczky (1990) The value of δ for each processorcan be derived from the processor’s total utilization Therefore, a task’s response

time is bounded by Pm

j=1δj However, it was shown that the maximum utilization

on each processor could drop to as low as 1/m for m processors

Kao and Garcia-Molina (1994) suggested complex end-to-end tasks can be composed into two classes of subtask deadline-assignment problems: serial subtaskproblem (SSP) and parallel subtask problem (PSP) The objective was to minimizeand evenly distribute miss ratios among tasks Three subtask deadline assignmentscheme were proposed for PSP: using task’s deadline (UD), x-fold division of taskdeadline (DIV-x), and subtraction of constant from the deadline (GF) The lattertwo make global tasks more competitive against local tasks For SSP problem, theapproach was to evenly distribute the slack of a task among subtasks by proportion oftheir expected execution time (EQF) Simulation found EQF+(DIV-x or GF) yieldslow miss ratio under high load and many local tasks

de-Natale and Stankovic (1994) considered a graph of dependencies and studiedthe sub-deadline assignment problem for processes that have same-host end-to-endrequirements but contain synchronous remote communications By performing sub-release time and deadline assignment, synchronous communication type of depen-dency can be removed and unpredictable blocking can be prevented A process

(task) is modeled to have multiple schedulable units, subtasks, and has a releasetime and a deadline When given an allocation of processes onto hosts, an offlinealgorithm analyzes subtask dependencies and task end-to-end requirements to gen-erate an assignment of sub-release time and deadline for the subtasks as well asmessages between processes that are also modeled as subtasks The purpose is toallow deadlines be met for all processes on all hosts Then the subtasks with thesettings will be scheduled by a local scheduler The assignment of sub-release timeand deadline is constrained to meet all process deadlines while a certain metric, such

as laxity, is optimized This will find an assignment that maximizes the minimalnormalized laxity among all subtasks The problem is formed as a “slicing problem.”The subtask dependency graph is first transformed into a dual graph (vertex ↔edge) Then a theorem stated that all the minimal slices are located on a path fromend to end Then a breadth-first visit was proposed to iterate all such paths andthe path of the theorem can be found with the minimum sum of subtasks’ metrics.The maximization process then evenly divides the metric sum into subtasks, sinceotherwise some subtask will have metric less than the average

Generally, it is too restrictive to assume that an application system has a determined allocation, and the appropriate allocation has to be found Due to theincreased complexity, optimal allocations generally involve exponential-time exhaus-tive search guided by heuristics, branch-and-bound pruning, and cutoff to expeditethe process Techniques like tabu search, simulated annealing, genetic algorithmwere also experimented In the special case of two processors, a graph-based algo-rithm is able to offer optimal solution in polynomial time Others soften the problem

pre-by modeling for certain underlying architecture like COTS OS, FCFS scheduler anddeveloping fast heuristic algorithms experimentally shown to be effective However,

no general guarantees could be given The work is reviewed next

In Stone (1977), a task was modeled to contain modules with heterogenous tion time on different processor, and the modules communicate with one another andincur different communication time if they are placed on different processors Thegoal was to minimize the total time spent on the task The problem was formulated

execu-as a max flow/min cut problem A graph wexecu-as formed from the communication linkamong modules with edge capacity equaling the link delay Processors were thenintroduced as nodes, and they shared edges with all task nodes The edge capacitywith processor was designed so that the cut value equals the sum of execution time

of task nodes on the processor in the same partition Thus by minimizing an n-waycut, the sum of both total execution time and total communication is minimized Inthe two processor case, processors are source and sink, and Ford-Fulkerson and othermore efficient algorithms can find the allocation in polynomial time However, whenthere are more processors, exponential enumeration was needed

An extension was made by Lo (1988) Tasks had execution costs and are linkedwith communication costs (without precedence) The task assignment was con-structed as a n-way cut graph problem, so that a cut corresponds to an allocation andthe cost of cut equals total execution and communication cost A heuristic solutionwas proposed that combines recursive invocation of max flow/min cut algorithm forthe two processor case with greedy task merge and assignment Further, interfer-ence cost was introduced between tasks, simulation showed the addition yields betterconcurrency by using more processors

Chu and Lan (1987) studied how to minimize a task’s response time by uting its modules with precedences FCFS was assumed for host scheduler Theobjective function was to minimize the communication and computation load onbottleneck (maximally loaded) hosts The reduction of precedence induced delaywas addressed with queuing model It was used, in addition to communication vol-ume, to group modules to be assigned together on a host After search space wasreduced with the grouping, an exhaustive search was used to find allocation thatminimizes the bottleneck value

distrib-Burns et al (1993) studied the real-time task allocation on a point-to-point lel hardware that has no shared communication media Schedulability test on individ-ual host is derived from the Audsley’s test in Audsley et al (1991) A recursion-basednumerical method is used to solve the test equations Task allocation is performedusing simulated annealing, which utilizes the schedulability test The energy function

paral-included weighted components of task response times, processor utilization, nodesused, memory used, and redundant replica A similar simulated annealing approachwas proposed in Tindell et al (1992) A token protocol was assumed for communica-tion in order to analyze its delay in schedulability test Task deadlines were modified

to factor in this communication delay The energy function to minimize was alsocomponentized Audsley schedulability analysis was used for corresponding energycomponent

In Ramamritham (1995), tasks have periodicity, precedence, communication, andreplication It was assumed sites were connected by multiple-access network that haspredictable delivery, such as the point-to-point in Burns et al (1993) or the springsystem in Ramamritham (1990) A heuristics directed exhaustive search was devel-oped Allocation and scheduling are performed for precedence related subtasks Acommunication graph is first produced by a pair-wise heuristic constraining place-ment of tasks (latest start time)LSF/(maximum immediate successors first)MISFthen guides the search A vertex will be discarded and cause backtrack if constraintsare violated, or a feasible schedule is not possible When a vertex is expanded, time

is advanced a given amount and ready tasks by then are allocated to multiple idleresources All combinations of the ready tasks to resources are inserted as childvertices

In Hou and Shin (1997), real-time tasks are decomposed into modules with dence relations, which are statically allocated to processors The objective functionwas to maximize the probability of tasks’ timely completion and to minimize thechance of failure in the way communication links and computation nodes are allo-cated to the tasks A modules allocation scheme (MA) uses branch-and-bound tosearch for an assignment in the level of modules Modules are then converted intojobs on processors, and precedences are preserved by constructing proper job releasetimes and deadlines At each expanded node, a polynomial module scheduling al-gorithm (MS) provides a schedule for allocated modules Based on a few optimisticassumptions, a node would be discarded if the schedule is clearly infeasible, and thisallows the search to speed up

prece-In Peng et al (1997), real-time tasks are decomposed into computation and munication modules that have precedences and dependent execution times Theobjective function is to minimize the maximal response time among tasks (systemhazard) Branch-and-bound is used to search processor allocation on the task level.Nodes on an open list are pruned if their θlb(x) are worse than the best solution (leavenode) found so far System hazard lower bound is evaluated on node x by consideringloads from allocated tasks and optimistic (relaxed) load estimates for unallocatedtasks Modules of these tasks are scheduled as jobs on processors, whose releasetimes and deadlines were constructed to reflect precedences A special schedulingalgorithm is assumed for each processor, and it can produce schedules with leasthazards, which provides the system-hazard lower bound at node x Experimentsshowed a low node-expansion percentage However, only 4 processors were tested inthe experiments.

com-Ali et al (2002) studied the static allocation of tasks onto heterogeneous COTShosts Several heuristics were tested and compared with Mixed-integer-programming(MIP) The host-restrict-aware max-min heuristic was shown to have good qualitywithout the expensive time of MIP The heuristic is based on the max-min heuristic,which incrementally picks a task to allocate that has the maximum value (among alltasks) of the minimal load that its allocation can cause to its possible host choices.The load includes CPU and network input/output The host-restrict-aware heuristic

is applied by allocating task set in increasing order of its number of possible hosts

In each iteration, the number is increased, and the restricted tasks are allocatedbefore rest of the tasks Failure (exceeding load capacities) of the latter will lead tothe next iteration Although communication was considered in load calculation, noprecedence, delay, or timing requirement was considered

real-of problems The existing work will be classified under the taxonomy as availablesolutions in respective subspaces, and directed by the taxonomy, new problems will

be identified These open problems will lead to subsequent research

3.1 Problem taxonomy

The taxonomy table in Table 3.1 is designed to describe problems of resourceallocation that considers environmental factors These factors are modeled as exter-nal variables The taxonomy will help real-time researchers classify solved problems

Field Attributes Values Description

1 divisible

2 indivisible

1 single

2 multiple

variables

3 nondecreasing

variable increases

1.survivability

2 survivability constraint

specific configuration is required to ensure survival, e.g a minimal number of replicas

3 security constraint

access control is enforced among tasks and resources according to security clearance

1 unbounded

2 bounded

1 continuous

2 discrete

4 chaotic/unknown there exist no formula capable of characterizing the variable behavior

whether multiple resources can be simultaneously employed by a task, i.e whether task may simultaneously use multiple processors

whether there exist extra constraints to observed values, e.g sensor's working bandwidth

optimization objective

(Om)

relavance (Er)

the number of service variables that are used in the system

Table 1 R|T|O|E taxonomy for task allocation in distributed real-time systems with external variables

variation property (Ev)

and constraints (Oa)

Table 3.1: R|T|O|E taxonomy for task allocation in distributed real-time systemswith environmental variables

while identifying new problems Problems of increased complexities may be solvedincrementally and systematically with hints from lesser ones It will also providereal-time system engineers/practitioners a quick means to investigate viability andsearch for a solution when presented with a new application area by customers Theframework is general enough so that supported real-time systems are not limited tothose with external variables.

The table uses a 4-field notation describing the resource allocation problem omy, R|T|O|E The four main fields stand for Resource description, Task description,Objective and constraint description, and Environmental variable description Eachmain field contains multiple attributes that can assume different values for variousproblems In shorthand, R|T|O|E can be expanded as:

taxon-Rc|T d, T b, T p, T s, T c, T e|Om, Oc, Oa|Er, Eb, Ec, Ev

Notably, the environmental variable description is isolated into a separate fieldrather than as a part of task description This separation reflects that they are notproperties of system task, but rather some properties external and thus orthogonal

to the system Information regarding these external properties can be employedfor better optimization objectives, which will work under an enlarged and enclosedsystem that captures both the environment and the real-time system in it

Values for an attribute are arranged in the order of difficulty A problem withlower attribute value is often easier to solve satisfactorily by making use of limitingand simplifying assumptions, but its solution usually has more narrow applicationdomains; conversely, a difficult problem may have broader applications, but it islikely to get stuck with too little information to develop a satisfactory solution Theexisting work is a good indicator of the appropriate boundary, and it is classifiednext

3.2 Classification of existing work

The existing work is examined next with respect to the taxonomy in order todetermine how each of the problems can be classified A short description is givenafter each classification, and more details can be found in the literature review

P1 1|2,1,0,0,-,4(3)|1,3,0|1,1,2,4 was addressed by Juedes et al (2004) Atask allocation problem with a single environmental variable was studied for dy-namic systems that use multiple processors The real-time tasks were scheduledrate monotonically on each processor Task’s execution times were modeled tohave a workload independent portion and a dependent portion, which is non-decreasing with respect to workload The problem was to find the maximalallowable workload (MAW) for the system

P2 1|2,1,2,0,-,2|1,1,0|1,1,1,4 was addressed by Gertphol et al (2002) Aproblem of maximal allowable increase in load was introduced The goal was

to find a feasible allocation that maximizes a system run-time parameter Thework considered communication latencies and end-to-end latency requirements.All execution times were assumed to vary, but they were modeled as linear func-tions of only one system run-time parameter The parameter was maximizedwithout violating constraints on end-to-end latency and throughput

P3 1|2,1,2,0,-,5|1(2),1,0|2,1,1,4 was addressed by Ali et al (2003), where anorm based robustness metric was proposed which captures multiple perturba-tion parameters It was defined as a radius for maximal allowable perturbationalong any direction of the parameter space without violating system perfor-mance bounds The paper only proposed a general robustness metric, and noactual resource allocation algorithm was provided

P4 1|2,1,0,0,-,5|0,3,0|2,1,2,1 was addressed by Chen et al (2000), in whichvaried task execution times were treated as distributed generalized multi-frametasks Task allocation was pre-given and the objective was to ensure feasibility.Each task had multiple distributable frames with different execution times,

deadlines, and periods But the number of frames was finite and the sequence

of frames with varied execution times had to be known in advance for eachtask

P5 1|2,1(2),0,0,-,5|4,1,0|2,1,2,2 was addressed by Tia et al (1995) Theapproach regarded task’s unpredictable execution times as random variablesand statistical confidence guarantee was made about deadline misses Thesemi-periodic task model assumed execution times are profiled with proba-bility histogram, and methods were given to compute every task’s deadlinemiss probability However, the analysis was restricted to a single processor.Manolache et al (2004) similarly viewed the execution time as a probabilisticdensity distribution In addition, dependencies and multiple processors wereconsidered When deadline miss probability thresholds were given for tasks,its optimization goal was to minimize their deviations beyond the thresholds.The approach was shown to achieve much better goal than allocating simplybased on average execution times

P6 1|2,1,0,0,-,5|0,3,0|2,1,2,3 was addressed by Wandeler et al (2004) Itsevent stream model attributed varying execution times to a finite set of eventtypes that incur different workloads Sometimes, the variations of event typesfollow certain regular pattern It was shown that, when there is the regularityamong events, it can be exploited to give better estimation of workload byconsecutive events than using worst case estimation

Additionally, the taxonomy can also be used to classify problems without externalvariables For instance,

2|1,-,0,2,1/2,3|3,-,0|0,-,-,- was addressed by Lee et al (1999b,a) The lem dealt with multi-dimensional QoS allocation for tasks that use multiplefinite resources Each QoS was mapped to a utility value, and the objectivewas to maximize the overall system utility The problem was shown to be NP-hard by a reduction from knapsack Dynamic programming and mixed integer

prob-programming solutions were provided In order to reduce running time, anapproximation algorithm was also given.

3.3 New problems

Equipped with the taxonomy, some insights can be gained The entire space ofthe problems is huge, but not all may be practically interesting If the focus is onenvironmental variables, there are 32 problems total by combination, and many ofthem are still new and untouched by previous work It is important for any interestingnew problem to have a potentially satisfactory solution, and two approaches seemappropriate to make the selection: bottom up, and top down

In the bottom up approach, complexity of new problems are estimated Baseproblems are identified, and they can be used to build a problem complexity hier-archy After solutions are obtained to simple lower-level problems, the next level ofproblems will be attacked systematically To be able to compare complexity, values

of the attributes have to be ranked For the attribute Er, we assumed single ≤multiple since the latter subsumes the former For attribute Eb, we assumed un-bounded ≤ bounded since end points introduce additional constraint equations Forthe attribute Ec, we assumed continuous ≤ discrete since the latter may incur com-binatorial problems, which was concurred through the research development of Lee

et al (1999a,b) For Ev, we assumed function of time ≤ statistical ≤ regular pattern

≤ chaotic because the characterization power becomes less and less specific (Here

≤ denotes less or equal in complexity.)

Based on this comparison, five base problems can immediately be identified:Er,Eb,Ec,Ev = (1,1,1,1), (2,1,1,1), (1,2,1,1), (1,1,2,1), (1,1,1,2) Simi-lar to recursion, this builds the base case Problems of higher complexity are found

at larger attribute values, that is, an (R|T |O|a, b, c, d) problem may benefit fromthe solutions to (R|T |O|a − 1, b, c, d), (R|T |O|a, b − 1, c, d), (R|T |O|a, b, c − 1, d) or(R|T |O|a, b, c, d − 1) recursively

Table 2 Distribution of dominating problems

Table 3.2: Distribution of dominating problems

The second approach is top down Since there already exist some work thathave partially or completely solved some of the problems, they should be able toprovide us with a reference frame regarding what problems are promising For this,the concept of dominance is used as follows: problem P0 dominates P if Er0 ≥

Er, Eb0 ≥ Eb, Ec0 ≥ Ec, and Ev0 ≥ Ev For instance, problem Er,Eb,Ec,Ev

= 2,1,2,3 dominates Er,Eb,Ec,Ev = 1,1,1,2 By using dominance, there is acomplexity reference frame for new problems using existing works If P0 is found todominate P and researchers have worked out a complete solution for P0 then it isvery likely the new problem P can be solved too But it does not mean solution to

P0 automatically solves its dominated P , since problems differ and different tools areneeded So to “dominate” here more properly means to hint, therefore,

{P 4, P 5, P 6}∩{P 1, P 2, P 4, P 5, P 6}∩{P 1, P 2, P 4, P 5, P 6} ∩{P 1, P 2, P 4, P 5, P 6} ={P 4, P 5, P 6}, which is three hints It is noticeable that the rest of the base problemsalso receive high hints (from 3 to 5), except for (1,2,1,1).

Another important factor to consider is whether a problem has practical nificance Problems that do not make sense should be eliminated The choice tosolve a new problem is often driven by the need for practical applications In themotivating problem described in the introduction, there are multiple external vari-ables (radar tracks, threats, and missiles), and their values are discrete, unbounded,and not characterizable by any formula The problem can thus be captured asE=(2,1,2,4) in short Obtaining a solution to this problem will be critical and life-saving The following chapters will describe the research to develop the solution toproblem 1|2,1,0,0,-,3/4|1,3,0|2,1,2,4 in chapter 5 and 6, and the solution toproblem 1|2,1,0,2,2,4|3,3,0|2,1,2,4 in chapter 7

sig-Chapter 4

System Model

As the first step in solving (2,1,2,4) problems, a new real-time computingparadigm is introduced The model captures features relevant to the problems It isbased on periodic real-time tasks characterized by environment-dependent executiontime functions, as opposed to the traditional model with hard periodic real-time taskscharacterized by worst case execution times In this paradigm, occasional deadlinemisses can be tolerated when unpredictable environmental factors drive a demandbeyond the limit of available resources This chapter introduces the new systemmodel by beginning with a traditional model, and then making necessary extensions

to incorporate environmental factors An example will follow to illustrate the model

Traditional Model The system model used in this work is derived from thestandard periodic task model given in Liu (2000b) In this model, the softwaresystem consists of a set of n periodic tasks S = {T1, T2, , Tn} Each Ti is releasedperiodically with period pi and has a deadline equal to its period The executiontime of each task Ti ∈ S is a constant ei that represents the worst case executiontime of Ti There is a set of m processors H = {P1, P2, , Pm}

Model Extensions Traditional models do not capture dynamic environmentalfactors, since the execution times are modeled as constants The models are inade-quate for some real-time systems operating in dynamic environments For example, a

Action Planning Analysis

Environmental factors Sensor

Figure 4.1: Example of a general control system

general distributed control system is depicted in Figure 4.1 It has filter, analysis, tion planning, and actuation tasks One or more of the tasks may contain algorithmsand execution times that are affected by unpredictable environmental factors Sys-tems with these properties include building surveillance, air defense, and intelligentvehicles Accurate modelling of such systems will supply the necessary information toallocate resources to them so that they are resilient to many unpredictable scenarios.The changing environmental factors that affect a system are modeled as l en-vironmental variables, ~w = (w1, w2, , wl), where wi (1 ≤ i ≤ l) is a non-negativeinteger Each task Ti ∈ S has an execution time ei( ~w) that is a function of theseenvironmental variables The system utilization is likewise a function of the envi-

a task implementing an object-identification algorithm, whose running time depends

on the number of objects in a room According to the model, l = 1, and w1 is thenumber of objects As another example, an air defense system contains filtering,situation assessment, and missile guidance tasks These tasks can depend on suchfactors as the number of radar tracks and the number of missiles Thus, l = 2, w1 isthe number of radar tracks and w2 is the number of missiles The model can makethe following characterization: T1, the filtering task, has an execution time function

e1(w1, w2) = w1+ w2; for T2, the situation assessment task, e2(w1, w2) = w1; T3, themissile guidance task, e3(w1, w2) = w2 Tasks T1,T2,T2 have periods p1 = p2 = p3 = 2seconds There are 3 processors: P1, P2, P3 In an allocation M , task T1 is on P1,task T2 is on P2, and task T3 is on P3.

Chapter 5

Robust Task Allocation for

Dynamic Distributed Real-time

Systems

In this chapter, a task allocation strategy is developed that not only tees the feasibility of allocations but also explicitly maximizes the robustness offeasible allocations in unpredictable environments Intuitively, a robust allocationallows the system to absorb a large amount of environmental variation, while con-tinuing to deliver feasible real-time services Significance of the robustness lies inthe fact that no new allocation has to be recomputed, and no reallocation needs

guaran-to be enacted Both actions can be very time consuming, and deadline violationsmay result from a poorly allocated system, when changes in environmental vari-ables frequently trigger reallocations The problem is classified in the taxonomy as1|2,1,0,0,-,3|1,3,0|2,1,2,4 The problem definition is introduced next

Problem definition: Define a robustness metric R = R(W1, W2 , Wl) (R ∈ R+)that characterizes the ranges, [0, Wk] (1 ≤ k ≤ l), of environmental variable values al-lowed simultaneously by an allocation For any instantaneous value of (w1, w2, , wl)falling within these ranges, the allocation should be feasible (no deadline misses)

Next find the allocation S → H under which the robustness metric R is maximized,while the allocation satisfies the following feasibility constraints,

- when EDF scheduling is used, ∀j : 1 ≤ j ≤ m, P

It is also necessary to guarantee the quality of robustness it finds These issues will

be addressed in this chapter

The problem is not a regular constrained optimization problem, because the straints are not given explicitly but are functions of allocations and they need to bediscovered Exhaustively enumerating all allocations is not desirable because of theexpensive running time Therefore, to still be able to obtain assurance on quality,allocation strategies are used that may help provide explicit bounds on these con-straints One such strategy is the well-known greedy first-fit heuristic The analysiswill be able to leverage the existing results such as the worst case utilization bound

con-by Oh and Baker (1998) for rate monotonically scheduled systems and a similarbound developed by Lopez et al (2004) for EDF systems

The chapter is organized as follows Section 5.1 discusses finding robust tions in the case of one environmental variable An approximation ratio is developedfor the robustness found by a greedy first-fit based allocation algorithm The re-sult will build the foundation for subsequent extensions to multiple environmentalvariables Section 5.2 develops a robustness metric appropriate for the case of multi-dimensional environmental variables, and then properties of the metric are examined.Section 5.3 proposes an allocation algorithm that works for the multi-dimensional

alloca-case, and an approximation ratio is also derived Section 5.4 experimentally studiesthe performance of the algorithm and compares it with several baseline algorithms.Finally, section 5.5 summarizes the chapter.

5.1 Robust allocation for the one-dimensional

problem

When a dynamic distributed real-time system (DDRTS ) is affected by a gle environmental variable w, the robust allocation means a feasible allocation (alldeadlines are met) that maintains feasible for any possible value of w in the range[0, Wmax] Thus Wmax is regarded as the robustness metric of an allocation andmaximized An allocation algorithm has been developed based on greedy first-fitthat maximizes robustness using this metric, named the maximal allowable work-load, Juedes et al (2004) The algorithm is next referred to as RAFF-1, or theRobust Allocation algorithm based on First-Fit under 1 environmental variable Atwo-component approximation ratio of the algorithm was developed in Juedes et al.(2003) for rate-monotonic (RM ) systems by assuming two well-behaved conditions

sin-In this section, the approximation ratio for the robustness of allocations by RAFF-1will be derived for more general cases and with better results Processors may bescheduled either by RMS or EDF, and both cases will be discussed The section be-gins with an examination of a DDRTS ’s dependency on the environment, and thenthe order of such dependency is characterized The characterization will later behelpful to show that systems of higher orders can attain much better approximationratios

In the one-dimensional case, the environment affects a DDRTS through the able w that alters execution times of tasks according to profile functions, ei(w) Thefunction characterizes the time complexity of algorithms implemented in each task