Experimental Comparison of Heuristic and Optimal Resource ...

Experimental Comparison of Heuristic and Optimal Resource Allocation Algorithms for Maximizing Allowable Workload in Dynamic, Distributed Real-Time Systems Eric Aber, Frank Drews, Dazhang Gu, David Juedes, Andrew Lenharth, David Parrott, Lonnie Welch, Hang Zhao, David Fleeman ∗ April 15, 2004

Abstract This paper introduces a maximal allowable workload task allocation problem (MAW) to address a class of distributed real-time systems that have unpredictable execution times due to varying workload. It is known that worst case execution time analysis is not well suited for these systems. This problem seeks to maximize the upper bound of permissible workload in an allocation so that it can sustain major workload fluctuations without the need for reallocation. An answer to the problem is significant in that it increases robustness of the system by reducing expensive reallocation costs such as process migration, which degrades system performance. Previously in [12], we presented and compared several heuristic algorithms experimentally, including simulated annealing, hill-climbing and random search. This paper expands the set of algorithms to include tabu search, genetic algorithm, dynamic programming, and optimal branch-and-bound. The main contribution of this paper is the performance comparisons among these various well known heuristic and optimal algorithms applied to the MAW problem. Through simulation experiments, relative solution quality and time complexity of the algorithms were evaluated and tradeoffs were revealed.

1 Introduction The use of distributed real-time and embedded applications in such critical areas as air defense, robotic control, and satellite constellations gives rise to new problems concerning the management of resources in such systems. These systems are generally characterized by unpredictable environmental behaviors that prohibit the specification of meaningful arrival rates of events driving transient computations. Meanwhile, periodic computations may be required to process data of varying sizes. Moreover, the size of the data to be processed in an arbitrary period sometimes cannot be determined at the time of system engineering, nor can a meaningful upper bound be found for the size of the data. Thus, a useful worst-case execution time cannot be obtained for such periodic processes a priori. Systems with these real-time constraints are best described as dynamic real-time systems. Traditional methods for achieving real-time performance do not always work well in dynamic environments because they overwhelmingly concentrate on periodic tasks with a priori workloads. In early work, Abdelzaher and Shin [2, 3] examined a branch-and-bound algorithm for off-line scheduling of communicating tasks and messages with known arrival rates and resource requirements, where the optimization objective was the minimization of the maximum task lateness. Peng, Shin, and Abdelzaher [18] gave another branch-and-bound algorithm for allocating communicating periodic tasks with the objective of minimizing the maximum normalized system response time, called the system hazard. The Q-RAM project uses a similar objective function for optimizing resource allocations; however, it works for utility-based soft real-time applications [19, 20, 14]. Other authors have presented ∗ Center for Intelligent, Distributed, and Dependable Systems, School of Electrical Engineering and Computer Science, Ohio University, Athens, Ohio 45701 U.S.A., {eric.m.aber.1, drews, dazhang.gu.1, juedes, andrew.d.lenharth.1, david.d.parrott.1, welch, hang.zhao.1, fleeman}@ohio.edu

algorithmic approaches for assigning real-time tasks based on general purpose local search heuristics. Coli and Palazzari [6], DiNatale and Stankovic [7], Nicholson [16], and Tindell et al. [22] gave algorithms based on simulated annealing to optimally allocate periodic tasks to resources. Algorithms based on genetic algorithms were proposed by Baccouche [5], Greenwood et al. [11], and Sandnes [21]. In contrast to much of the aforementioned work on resource allocation in real-time systems, the research described here does not assume an upper bound on the size of the input data or an upper bound on the worst-case execution time for each task. Instead, it assumes that for each task Ti , there exists an (arbitrary) function Ti .r(w) that gives an upper bound on the running time of task Ti on inputs of size w. Our objective is to produce an allocation of resources to tasks that remains feasible for the largest possible system workload w. This is the maximum allowable workload (MAW) problem, and it has several variants based on the underlying process scheduling algorithm. MAW-RMS uses fixed priority rate monotonic scheduling, while MAW-EDF uses the earliest deadline first scheduling approach. Maximizing the allowable workload produces resource allocations that are robust with respect to workload increases. Robustness metrics have been a source of recent work [9, 4]. In particular, the recent work by Gertphol et al. [9] presents a robustness metric that is very close to maximum allowable workload. They define a performance metric “MAIL,” which stands for “maximum allowable increase in load” and present several heuristic algorithms for finding resource allocations that allow a maximum increase in load. Briefly, they attempt to produce an allocation of resources to tasks so that the system can absorb the largest increase in the load level.

1.1

The Optimization Problem

Here we use the following model for real-time systems. Each real-time system consists of a collection m processors P = {P1 , . . . , Pm } and a collection of n independent periodic tasks T = {T1 , . . . , Tn }. Each task Ti has a period Ti .p and a deadline Ti .d = Ti .p. Furthermore, each task Ti has a collection of functions Ti .rj (w) that describe the running-times of task Ti on each processor Pj with workload w. It is assumed that Ti .rj (w) is a monotonically non-decreasing function in w. For shorthand, we describe a real-time system by the tuple hT, P i. The maximum allowable workload problem is formalized as follows. Optimization Problem: (Maximum Allowable Workload) MAW-RMS/MAW-EDF Input: hT, P i Output: An allocation of tasks to processors, alloc : T −→ P and a workload w such that the allocation alloc is feasible whenever all tasks do not exceed the workload w. Here, we say that an allocation is feasible if all tasks on a single processor meet their deadlines when scheduled using RMS [15]. The optimization problem MAW-EDF can be defined by replacing RMS with EDF in the above definition. Objective Function: Maximize w. Note that the optimum solution for MAW-RMS or MAW-EDF has the property that the allocation is feasible with workload w but not feasible with workload w + 1. We also note that it is easy to see that the optimization problem MAW-EDF is NP-hard since it can be used to solve bin-packing [8]. Therefore, it seems likely that MAWRMS is also NP-hard. Hence, it is likely that we will not be able to find an efficient exact algorithm for it. In this paper we introduce and examine several heuristic algorithms and compare them with first-fit (FF).

1.2

A Motivating Example

The notion of tasks having workload-dependent execution times originated from the study of a generic air defense system [23]. The detect task identifies threats to a defended entity. The task runs periodically and performs the functions of filtering and evaluating radar 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 task keeps 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, and issues guidance commands to the missile. All three of these tasks have resource needs that are environment-dependent. Unlike traditional approaches to real-time computing, which characterize the resource needs of a task by a worst case execution time (WCET) [15], we characterize the resource needs of these tasks by execution profile functions.

These functions compute the resource need as a function of workload. For instance, the execution profile of the detect task has a resource requirement of f (r) = 0.0869r2 + 15.4374r + 614.8615 microseconds, where ”r” is the number of radar tracks, and it has both input dependent and input independent terms. These profile functions can be obtained by analyzing execution profiles at various workloads and performing an appropriate curve fitting [24]. Concurrency is often used in order to meet real-time constraints of the tasks. During operation, there may be many replicas of the three tasks in the air defense system, e.g.: when the number of radar tracks grows too large for a single replica of the detect task to process all tracks within the required time bound, one or more replicas are created and the radar tracks are partitioned among them. Additionally, pipeline concurrency is obtained by the replication. Thus, the key issue is how to allocate the tasks and subtasks in a manner that allows real-time constraints to be met and minimizes the need for reallocations (which creates overhead in the system).

1.3

Contribution and Organization of the Paper

In [12], we proposed an algorithmic approach based on first fit combined with binary search over the allowable workload. Moreover, we presented and compared several heuristics experimentally, including simulated annealing, hill-climbing and random search. This paper will significantly extend the set of algorithms. In section 2, we present the following collection of algorithms to attack the MAW-RMS problem: first-fit, random search, simulated annealing, hill climbing, tabu search, genetic algorithm, dynamic programming, and a branch-and-bound approach. Section 3 gives experimental comparisons to reveal their relative quality of solution and performance. Conclusions are drawn in section 4.

2 Heuristic Algorithms for MAW-RMS In this section, we examine a collection of sub-optimal algorithms to solve the general version of MAW-RMS. It is general in that the running time of each task may depend on the machine on which it is being executed. First-Fit First, we briefly describe the first fit approach to MAW-RMS that was introduced in [12]. The algorithm employs an algorithm by Oh and Baker [17] that was presented in [12]. Given a workload w for each task in the system, Algorithm 1 tests to see if the algorithm by Oh and Baker will find an allocation of tasks to processors that satisfies all the real-time constraints with this workload. The algorithm by Oh and Baker tests to see if the first-fit allocation of tasks to processors via the Liu and Layland m(21/m − 1) utilization criteria uses the required number of processors. Algorithm 1 uses binary search to find a w such that the algorithm by Oh and Baker determines that the real-time system with workload w is feasible, but the real-time system with workload w + 1 is not feasible. Algorithm 1 produces the appropriate allocation of resources as a result. We refer to Algorithm 1 as First-Fit (FF). Algorithm 1 First Fit Approximation Algorithm for MAW-RMS Input: hT, P i. Output: An allocation alloc : T −→ P and a workload w Comment: Uses binary search to find a w such that Algorithm Oh and Baker’s algorithm [17] returns “Feasible” for w and “Not Feasible” for w + 1. set w = 1; while Oh and Baker’s algorithm on input (T, P, w) returns “Feasible” do set w = w ∗ 2; end while

set low = w/2; set high = w; while high − low > 1 do set w = low+high ; 2 if Oh and Baker’s algorithm [17] on input (T, P, w) returns “Feasible” then set low = w; else set high = w; end if end while return alloc and w = low

The heuristics presented in this section make use of the following basic approach: first find an allocation of tasks to resources alloc : T −→ P , and then find the maximum workload w that can be used. Once an allocation of tasks to resources is fixed, the maximum feasible workload can be found quickly using Algorithms 2 and RMA test on each processor [15]. All heuristic approaches presented here use these algorithms to find the largest feasible workload for a given allocation. The algorithms differ in how the space of possible resource allocations is searched.

Algorithm 2 Generic Algorithm that Finds the Optimal Workload for an Allocation Input: hT, P i and an allocation alloc : T −→ P Output: w such that the allocation with workload w is feasible, but the allocation with workload w + 1 is not. set w = 1; repeat w = w ∗ 2; call RMA test per processor [15] to see if alloc is feasible with workload = w; until alloc is not feasible with workload w set low = 1; set high = w;

while (high − low > 1) do set w = high+low ; 2 call RMA test per processor [15] to see if alloc is feasible with workload = w; if (feasible) then set low = w; else set high = w; end if end while return low;

Random Search As a baseline, we implemented a random search algorithm which searches the space of all possible allocations through a fixed number of iterations. Random search is referred to as RN. In our experimental results section, we tested our random search algorithm with 100000 iterations. Simulated Annealing In [12], we proposed an approach based on the local search procedure simulated annealing [13]. The simulated annealing process starts at a high temperature T0 with an initial solution. The solution is then changed randomly. If the change improves the solution, then the new solution replaces the old one. If the change −∆ makes the value of the workload solution worse by ∆, the change is accepted with a probability e T0 . In general, large negative changes may be accepted at high temperatures, but only small negative changes are accepted at low temperatures. Our simulated annealing algorithm has four basic parameters that affect its performance: the initial temperature, the stop temperature, the cooling constant c, and the iteration constant m. For the experiments, we used an initial temperature T0 of 50 degrees and a stop temperature of 0.3 degrees. The iteration constant m was set to 2100, and hence the inner loop generated 2100 new allocations. The function F generates new allocations by randomly picking one task Ti and one processor Pj , and moving task Ti to processor Pj . After m iterations, the current temperature T0 is cooled based on a geometric cooling schedule T0 = T0 · c, c ∈ (0, 1), where c is the (constant) cooling rate, which was set to c = 0.9 [1]. Hence, the simulation performs approximately 100000 iterations. Another crucial variable in the simulated annealing algorithm is the choice of an initial allocation. In our simulations, we tested the simulated annealing algorithm with the result of first fit [12] as the initial allocation. It is referred to as SA(FF) in the next section. Hill Climbing Our next approach is based on the hillclimbing technique. This algorithm starts with an initial allocation of tasks to processors, and then performs a local search on the space of all allocations from that starting point. For a given allocation of tasks to processors, the local search algorithm examines the collection of all neighbors of the allocation. In our algorithm, a neighbor consists of an allocation that differs from the original allocation on at most one task. Since there are n processors and m allocations, it follows that there are exactly (n−1)·m neighbors of any allocation. The algorithm examines the maximum possible workload for each allocation in the neighborhood, and picks the allocation that produces the largest value as the next choice of an allocation. This process continues until the algorithm can no longer improve the value of the solution. Since it is possible for hillclimbing to become stuck in a local maximum, the choice of an appropriate starting allocation is crucial. Here we use one version of hillclimbing which is given an initial allocation using first fit. We refer to this version of hill climbing as HC(FF). Tabu Search In the new tabu search algorithm, we define a neighborhood as allocations that have only one application running on a different host than the original allocation. We choose the initial allocation to be the result from the first fit algorithm [12]. Every time an application i is moved to a new host, we record which host i was originally on, so that moving the application i back onto the previous host becomes a tabu choice for the next 2 · m · n steps. For each step, our tabu search algorithm takes the best non-tabu allocation as next step’s base allocation. If during a step, all available choices are found to be tabu choices, we refer to the f requency matrix to pick a choice that has occured the least in the last 2 · m · n · 20 steps. The result returned by this algorithm is the best result from all allocations investigated. Overall, m · (n − 1) · M AX IT ERAT ION allocations were investigated. In section 3, results of this tabu search will be referred to as TA(FF).

Genetic Algorithm Our next new approach is a simple genetic algorithm approach [10]. An initial population of allocations is formed randomly. Each individual allocation (chromosome) is represented by a binary string mathematically defined as C =< P1 , P2 , ..., Pn >, where C represents a chromosome, Pi is a binary string representing a processor, n is the number of tasks, and |Pi | = dlog2 ne. The individuals are then evaluated for fitness by using Algorithm 2. The most fit individual from each population is then transfered to the next generation (referred to as elitism). The algorithm then selects pairs of individuals from the previous generation and allows these individuals to reproduce. Selection of individuals for reproduction is done by using a biased roulette wheel technique[10]; where individuals with higher fitnesses are chosen with a higher probability than those with lower fitnesses. Reproduction takes two steps: crossover and mutation. Crossover is done at one position creating two front segments and two rear segments. The front segment from one parent and the rear segment from another parent are concatenated to form a new individual, and the reverse forms another individual. The newly produced individuals are then mutated randomly by bit flipping, which is subject to a mutation rate. One or both of the individuals are then added to the new population depending on how many individuals are currently in the new population. Next, we attempt to produce optimal solutions to the MAW-RMS problem: the first approach is based on dynamic programming and the second one is based on branch-and-bound. Dynamic Programming We next describe a dynamic programming style heuristic for the problem. The heuristic is easiest to describe for EDF; however, straightforward modifications can be made to this description to cover RMS. The approach treats each processor that schedules tasks via EDF as a bin with a fixed number of available slots (e.g., 100). This approach determines, for a given workload w, whether there is an allocation of tasks to processors that is feasible. Given a collection of tasks T1 , . . . , Tn and a workload w, we compute a discretized value of the total task utilization ui = d TiT.r(w) ∗ 100e. We then ask the question: Is it possible to pack n blocks i .p u1 , . . . , un (that correspond to the discretized running times of the tasks) into m bins of size 100 (that correspond to the m processors). This discretized problem can be solved via dynamic programming as follows. Define a two dimensional boolean array N (k, p~), where 1 ≤ k ≤ n and p~ ∈ {0, . . . , 100}m , to be true if and only if there exists a packing of the blocks u1 , . . . , uk into m bins B1 , . . . , Bm of size p1 , . . . , pm , respectively. Notice that N (k, [p1 , . . . , pm ]) =

m _

N (k − 1, [p1 , . . . , pj − uk , . . . , pm ]),

j=1

and that N (0, p~) is always true. Now, if N (n, [100, 100, . . . , 100]) is true, then it is possible to schedule all n tasks running at workload w on the m processors. In the case of heterogenous processors, a processor dependent utilization uk (j) will be substituted above. Notice that because we discretized the task utlizations, it is possible that there is a feasible allocation of tasks to processors even though N (n, [100, . . . , 100]) is false. In our dynamic programming based heuristic, we use the dynamic programming approach that we have described as a feasibility test to determine whether it is possible to run the n tasks at workload w on the m processors. We then apply the standard binary search based approach to find the optimum value for w and its associated allocation. Branch-and-Bound To establish an upper bound on the optimality of allocations computed by our various algorithms, we have developed an optimal branch-and-bound algorithm. The problem is logically organized as a tree, such that the leaves correspond to allocations, and nodes correspond to decision points. Each node represents the choice of a processor for a task. The ith level in a tree corresponds to choosing an allocation for task i. Since for every task there are j choices of processors to run the task on, each node will have j children. This gives ij possible allocations or leaves in the tree. To avoid traversing the entire tree in search of a feasable allocation, we prune branches from the tree as we search. A branch is pruned if the allocation choice just made for a task causes the processor to fail the RMA test. Since the runtime cost of branch-and-bound is potentially high, a lower bound on the maximum allowable workload is computed by performing the first fit algorithm. From here, an exponential back off search is performed

with the branch and bound algorithm until an upper bound is established; the upper bound being a workload which is not feasible. The exponential back off works by taking a base workload b and a variable workload vw. If an allocation is found for b + vw, then the search is repeated with vw = 2 ∗ vw. b is initialized to the workload returned by the first fit algorithm, and vw is initialized to 1. These upper and lower bounds are then used as the bounds in the binary search algorithm using branch-and-bound, until the allocation with the highest workload is found. This branch and bound algorithm can be optimized by folding in the RMA checks into the algorithm. This is done by maintaining an array f , indexed by host, such that if a host Pj has n tasks allocated to it, fj = P T .r (w) (n + 1)(21/(n+1) − 1) − alloc(Ti )=Pj i Tij.p . This reduces the allocation check to a comparison between the utilization of the process at that host and the remaining free processor time if there were n+1 tasks. The differences between RMA utilization limits can be precomputed, thus reducing the amount of computations at each stage. Further optimizations can be performed by rotating the starting location of the search for processors at each level, thus choosing an initial path through the tree that has a more uniform distribution of tasks to processors, rather than choosing an initial path that assigns all tasks to one processor. It is believed that this heuristic increases the chances of finding an allocation quicker. These optimizations provide a 3x speed improvement over the simple implementation, but are not implemented in the version of the algorithm used in this paper.

3

Experiment

To test the approaches described in the previous sections, we performed two seperate sets of tests. In the first set of tests, we considered only the heuristic algorithms in the MAW-RMS problem. The test instances consisted of groups of m ∈ {20, 50, 80, . . . , 200} tasks running on 5 processors. In the second set of tests, the optimal algorithms were compared with the greedy first-fit and random algorithms. Because of the exponential complexity of the optimal algorithms, this collection of tests consisted of groups of m ∈ {10, 15, . . . , 35} tasks running on 3 processors. Each processor in these tests was described by its profile in terms of its speed factor. The values of the speed factors for each processor were chosen from the range [10, 30] at random. Each periodic task was given a period in the range [10000, 50000] milliseconds, selected uniformly at random. The running-time function (in terms of the number of milliseconds) for each task was determined by generating a random pseudo-polynomial with coefficients chosen uniformly at random from the range [0, 100]. The random pseudo polynomials were generated as follows. All terms in the pseudo polynomials came from the set T P = {x2 log x, x2 , x log x, x}. The pseudo polynomials were chosen at random so that the probability of the largest term in the pseudo-polynomial was determined by the following table. Largest Term Probability Largest Term Probability x 1/2 x log x 1/4 x2 1/8 x2 log x 1/8 In each pseudo polynomial, each lower order term was included with probability equal to one-half. This approach produced low degree pseudo polynomials with high probability. The running time profile of each Task is related to a profile host with speed factor 1. Consequently, the running time of a given task was translated between machines by dividing the running time of the task in accordance with its running time profile by the speed factor of the assigned machine.

3.1

Experimental Results

Figure 1(a) shows the performance of our heuristic algorithms on the first set of test data. Simulated annealing tended to outperform first fit when the number of applications was small while the tabu search and the hill climbing algorithms were comparable. The tabu search, hill climbing, and simulated annealing always perform at least as good as first fit and many times provide better allocations. This performance increase lessens as the number of applications increases. At the 30 application scenario, all the algorithms but genetic and random found better solutions than first fit. The genetic algorithm and the random algorithm turn out to be the worst allocation algorithms regardless of the scenario. Poor performance of the genetic algorithm could be attributed to not seeding the algorithm with a first-fit allocation.

2

6 SA(FF) HC(FF) GA TA(FF) RN

1

2

-1

Average Improvement of FF [%]

Average Improvement of FF [%]

0

RN OPT DP

4

-2 -3 -4 -5 -6

0 -2 -4 -6 -8 -10

-7

-12

-8 -9

-14 0

50

100 Number of Tasks

150

200

10

15

20

25

30

35

Number of Tasks

(a) Using the heuristic algorithms

(b) Using the optimal algorithm

Figure 1: Average percental improvement of workload on first fit While most of the algorithms tested in the first set produce reasonable solutions, their total running times were significantly different. Table 1(a) provides the running times for each of the algorithms in the first set of test scenarios. Tasks FF(s) 10 0.01 20 0.01 30 0.01 40 0.01 50 0.01 80 0.01 110 0.01 140 0.01 170 0.02 200 0.02

RN(s) 4.06 5.41 6.64 7.91 9.52 13.51 15.47 19.44 22.92 26.24

SA(s) 4.35 5.73 6.83 7.95 9.85 13.68 14.77 18.16 21.09 23.34

HC(s) 0.01 0.01 0.02 0.02 0.04 0.04 0.06 0.1 0.14 0.18

GA(s) 2.56 3.58 4.62 5.66 7 10.15 12.18 15.3 18.31 20.94

(a) algorithms on first set of test data

TS(s) 0.73 1.85 2.46 5.06 8.32 17.58 26.89 43.3 60.62 76.35

Tasks FF(s) 10 0.01 15 0.01 20 0.01 25 0.01 30 0.01 35 0.01

RN(s) 3.08 3.89 3.38 3.48 4.52 5.6

OPT(s) 0.01 1.31 0.01 0.68 0.08 674.48

DP(s) 244.89 392.97 388.14 425.47 669.19 791.1

(b) algorithms on second set of test data

Table 1: Running time of two classes of algorithms with 100000 iterations The second set of experiments show the performance of the branch-and-bound and dynamic programming algorithm compared to the first fit and random allocations. Figure 1(b) shows the results of the algorithms on the second set of data. The results of the second set of data clearly show that the optimal branch and bound always performs as good as first fit and many times outperforms it. Additionally, the dynamic programming algorithm performs slightly less than optimal but still outperforms the first fit. At the 10 application scenario, all of the algorithms in the second set obtain better results than first fit. As the number of tasks grow, the random algorithm produces less and less desirable allocations. The second set of algorithms simulated have exponential complexities. Table 1(b) shows the running time of these algorithms and also the running times of the first fit and random allocation algorithms. The simulations were stopped at 35 tasks due to the algorithmic time complexity.

4 Conclusions This paper studied the maximum allowable workload (MAW) problem for real-time systems with tasks having varying and unpredictable workloads. The problem is meaningful in providing robust allocations in these practical dynamic real-time systems. We have introduced several heuristic algorithms and compared their performance in extensive simulations. The experiment results indicate that FF performs reasonably well compared to the other approaches while offering great cost-efficiency in time and space complexity. This suggests that despite its simplicity, FF turns out to be a reasonable approach for robust resource allocation in dynamic real-time systems.

References [1] E. H. L. Aarts, J. H. M. Korst, and P. J. M. van Laarhoven. Simulated annealing. In E. Aarts and J. K. Lenstra, editors, Local Search in Combinatorial Optimization, 1997, John Wiley&Sons Ltd., pages 91–120. John Wiley&Sons, West Sussex (England), 1997. [2] T. F. Abdelzaher and K. G. Shin. Optimal combined task and message scheduling in distributed real-time systems. In Proceedings of the 16th IEEE Real-Time Systems Symposium, pages 162–171. IEEE Computer Society Press, 1995. [3] T. F. Abdelzaher and K. G. Shin. Combined task and message scheduling in distributed real-time systems. IEEE Transactions on Parallel and Distributed Systems, 10(11):1179–1191, 1999. [4] S. Ali, A. A. Maciejewski, H. J. Siegel, and J. K. Kim. Definition of a robustness metric for resource allocation. In Proceedings of the 17th International Parallel and Distributed Processing Symposium (IPDPS 2003), 2003. [5] L. Baccouche. Efficient static allocation of real-time tasks using genetic algorithms. In Internal Report, Imag Intitute, Laboratoire de Genie Informatique, 1995. [6] M. Coli and P. Palazzari. A new method for optimisation of allocation and scheduling in real-time applications. In Proceedings of the Seventh Euromicro Workshop on Real-Time Systems, pages 262–269, 1995. [7] M. DiNatale and J. A. Stankovic. Aplicability of simulated annealing methods to real-time scheduling and jitter control. In Proceedings of the IEEE Real-Time Systems Symposium, 1995. [8] M.R. Garey and D.S. Johnson. Computers and Intractability: A Guide to the Theory of NP-completeness. W.H. Freeman and Company, San Francisco, 1979. [9] S. Gertphol, Y. Yu, S. B. Gundula, V. K. Prasanna, S. Ali, J. K. Kim, A. A. Maciejewski, and H. J. Siegel. A metric and mixed-integer-programming-based approach for resource allocation in dynamic real-time systems. In Proceedings of the 16th International Parallel and Distributed Processing Symposium (IPDPS 2002), 2002. [10] David Goldberg. Genetic Algorithms in Search Optimization and Machine Learning. Addison-Wesley, 1989. [11] G. Greenwood, C. Lang, and S. Hurley. An evolutionary stragegy for scheduling periodic tasks in real-time systems. In Applied Decision Technologies, pages 171–188, 1995. [12] D. Juedes, F. Drews, L. Welch, and D. Fleeman. Heuristic resource allocation algorithms for maximizing allowable workload in dynamic, distributed, real-time systems. In The 12th Workshop on Parallel and Distributed Real-Time Systems (WPDRTS2004), Santa Fe, Mexico, USA, 2004. [13] S. Kirkpatrick, C. D. Gelatt Jr., and M. P. Vecchi. Optimization by simulated annealing. Science, (220):671–680, 1983. [14] C. Lee, J. Lehoczky, R. Rajkumar, and D. Siewiorek. On quality of service optimization with discrete qoS options. In Proceedings of the Fifth IEEE Real-Time Technology and Applications Symposium (RTAS ’99), pages 276–286, Washington - Brussels - Tokyo, June 1999. IEEE. [15] C. L. Liu and J. W. Layland. Scheduling algorithms for multiprogramming in a hard real-time environment. Journal of the Association for Computing Machinery, 20(1):46–61, 1973. [16] M. Nicholson. Allocating and scheduling hard real-time tasks on a point-to-point distributed system. In Proceedings of the Workshop on Parallel and Distributed Real-Time Systems, 1993. [17] D-I. Oh and T. P. Baker. Utilization bounds for N -processor rate monotonic scheduling with stable processor assignment. Real Time Systems Journal, 15(1):183–193, 1998. [18] D. T. Peng, K. G. Shin, and T. F. Abdelzaher. Assignment and scheduling of communicating periodic tasks in disributed real-time systems. IEEE Transactions on Software Engineering, 23(12), 1997. [19] R. Rajkumar, C. Lee, J. P. Lehoczky, and D. P. Siewiorek. A QoS-based resource allocation model. In Proceedings of the IEEE Real-Time Systems Symposium, 1997. [20] R. Rajkumar, C. Lee, J. P. Lehoczky, and D. P. Siewiorek. Practical solutions for QoS-based resource allocation problems. In Proceedings of the IEEE Real-Time Systems Symposium, 1998. [21] F. E. Sandnes. A hybrid genetic algorithm applied to automatic parallel controller code generation. In Proceedings of the eighth Euromicro Workshop on Real-Time Systems, pages 70–75, 1996. [22] K. Tindell, A. burns, and A. Wellings. Allocating real-time tasks (an np-hard problem made easy). Journal of Real-Time Systems, 4(2):145–165, 1992. [23] Lonnie R. Welch and Behrooz A. Shirazi. A dynamic real-time benchmark for assessment of qos and resource management technology. In Proceedings of the IEEE Real-Time Technology and Applications Symposium, pages 36–45, 1999. [24] Y. Zhou. Execution time analysis for dynamic real-time systems. Master’s thesis, School of Electrical Engineering and Computer Scienc, Ohio University, 2002.