ScatterD: Spatial Deployment Optimization with Hybrid Heuristic /Evolutionary Algorithms

Jules White, Brian Dougherty, Chris Thompson, and Douglas C. SchmidtDepartment of Electrical Engineering and Computer Science,

Vanderbilt University, Nashville, TN, USA{jules,briand,schmidt}@dre.vanderbilt.edu & chris.m.thompson@vanderbilt.edu

Abstract

Distributed real-time and embedded (DRE) systems canbe composed of hundreds of software components runningacross tens or hundreds of networked processors that arephysically separated from one another. A key concern inDRE systems is determining the spatial deployment topol-ogy, which is how the software components map to theunderlying hardware components. Optimizations, such asplacing software components with high-frequency commu-nications on processors that are closer together, can yieldanumber of important benefits, such as reduced power con-sumption due to decreased wireless transmission power re-quired to communicate between the processing nodes.

Determining a spatial deployment plan across a seriesof processors that will minimize power consumption is hardsince the spatial deployment plan must respect a combina-tion of real-time scheduling, fault-tolerance, resource,andother complex constraints. This paper presents a hybridheuristic/evolutionary algorithm, called ScatterD, for au-tomatically generating spatial deployment plans that min-imize power consumption. This work provides the follow-ing contributions to the study of spatial deployment opti-mization for power consumption minimization: (1) it com-bines heuristic bin-packing with an evolutionary algorithmto produce a hybrid algorithm with excellent deploymentderivation capabilities and scalability, (2) it shows how aunique representation of the spatial deployment solutionspace integrates the heuristic and evolutionary algorithms,and (3) it analyzes the results of experiments performedwith data derived from a large-scale avionics system thatcompares ScatterD with other automated deployment tech-niques. These results show that ScatterD reduces powerconsumption by between 6% and 240% more than standardbin-packing, genetic, and particle swarm optimization al-gorithms.

1 Introduction

Modern mobile sensor networks, cooperative robotswarms, and fractionated spacecraft are examples of dis-tributed real-time and embedded (DRE) systems. A sen-sor platform can have 10’s or 100’s of processing units,spatially separated on several physical platforms, and con-nected through multiple ad-hoc network links between theprocessors. Moreover, several hundred software compo-nents can be distributed across these multiple networkedprocessors.

The software in these types of DRE systems has tradi-tionally been tightly-coupled to the underlying hardware.In satellites, for example, each software component is oftendesigned to only function with the APIs provided by a spe-cific hardware setup on a single satellite. The deploymenttopology of the software components (e.g., how softwareis mapped to hardware processors) is thus dictated by thistight-coupling.

Recent trends in DRE development have begun decou-pling the software from the underlying hardware. For ex-ample, so-called fractionated spacecraft [8] are being de-signed to operate in groups and provide a common runtimeenvironment for satellite software [30]. The standardizedruntime interfaces allow migration of software functional-ity between satellites with minimal effort to reconfigure andadapt the capabilities of the satellites for different objec-tives. The same software can be deployed to a group ofsatellites in multiple unique spatial deployment topologies.

The increased flexibility in deployment topologies al-lows designers to exploit spatial characteristics of the physi-cal platform to optimize the power consumption of the over-all system. For example, two software components thatcommunicate at a high rate can be spatially co-located onthe same computing node to avoid communicating througha power consumptive wireless communication link. More-over, variations in performance per watt between processorsor cores can be exploited by the deployment topology to useprocessing nodes that consume less power.

Effective spatial deployment of distributed systems canalso lower power consumption simply by more effectivelyutilizing hardware. By packing software more tightly onto

hardware, fewer hardware resources and less power can beused. For example, roughly four pounds of cooling, powersupply, and other supporting hardware are needed for eachpound of processing hardware in a plane. Reducing hard-ware not only decreases DRE system cost, but also facil-itates increased ranges for planes/cars, decreased fuel andpower consumption, and reduced waste. Each pound of pro-cessor savings on a plane has been estimated to decreasefuel costs by $200 and decrease greenhouse gas productionfrom less burned fuel [47].

Determining how to optimize the spatial deployment ofsoftware to hardware in DRE systems to minimize powerconsumption is hard [6, 10] due to the large number of com-plex constraints that must be satisfied [28, 34, 40, 38, 23, 7].Developers must ensure that each software component re-ceives sufficient processing time to meet any real-timescheduling constraints [25]. Resource constraints, suchas total available memory on each processor, must alsobe respected by the spatial mapping of software to hard-ware [46, 13]. Finally, components can have complex place-ment or co-location constraints, such as requiring specificsoftware components to be deployed to processors a min-imum distance from the perimeter of a vehicle or robot toprovide crash survivability [13].

Open problem. A key challenge for DRE system de-velopers is that the techniques for determining the best wayto deploy software components onto hardware to optimizepower consumption have not kept pace with the decou-pling efforts. Manual techniques for determining spatial de-ployment topologies—which are commonly used by DREsystem developers—do not scale well and produce solu-tions that consume more power and hardware than is nec-essary. Assigning real-time tasks in both multi-processorand single-processor machines has been shown to be NP-Hard [9]. Some techniques are available for scheduling soft-ware on multi-core systems on a chip, but these techiquesare not designed for optimizing deployment across multiplechips that are spatially separated.

Research using integer programming and constraint pro-gramming has been performed on optimizing power con-sumption and performance of software components mappedto multi-core chips [28, 34, 40, 38, 23, 7]. This prior work,however, has focused on scenarios where all cores are phys-ically located on the same chip. A research gap thereforeexists for techniques that can perform deployment optimiza-tion across cores on multiple chips, distributed across mul-tiple networked platforms, and spatially separated from oneanother.

Solution approach→ Hybrid heuristic/evolutionaryalgorithms. Existing work on bin-packing algorithms formulti-processor scheduling and evolutionary algorithms fornon-linear optimization have addressed specific points inthe spatial deployment problem space. The chief problem

is that a comprehensive approach for adapting and using thedisparate techniques together has not been developed. Toaddress this problem, we present a spatial deployment algo-rithm, called theScatter Deployment Algorithm(ScatterD),which is a hybrid deployment solver that can optimize forpower consumption. ScatterD can adhere to a combinationof deployment constraints that cannot be satisfied by a sin-gle technique. ScatterD also leverages a novel represen-tation of the deployment design space based on input per-mutations to a bin-packing algorithm, as discussed in Sec-tion 3.4.

This paper provides the following contributions to thestudy of automated spatial deployment techniques for min-imizing power consumption:

• We describe how ScatterD’s hybrid heuris-tic/evolutionary algorithm optimizes spatial de-ployment topologies by utilizing variations in networklink and processing node power consumption tominimize overall system power requirements,

• We show ScatterD’s novel representation of deploy-ment design spaces based on input permutations toa bin-packing algorithm can be used to combine aheuristic bin-packing with an evolutionary algorithmand overcome many limitations of applying either in-dependently,

• We show how evolutionary algorithms using this modi-fied design space representation can be seeded with theoutput from a heuristic bin-packer to improve searchconvergence speed,

• We present empirical results demonstrating the im-provements in power consumption yielded by theScatterD deployment algorithm versus heuristic bin-packing algorithms and evolutionary algorithms, and

• We present empirical results that show that the Scat-terD algorithm is significantly more scalable than aconstraint satisfaction programming (CSP) approach.

The remainder of this paper is organized as follows: Sec-tion 2 presents a case study used throughout the paper tomotivate the challenges of devising a complex spatial de-ployment plan for fractionated spacecraft deployment; Sec-tion 3 presents the ScatterD hybrid heuristic/evolutionarydeployment algorithm; Section 4 analyzes the results fromexperiments with ScatterD; Section 5 compares ScatterDwith related work on deployment automation; and Section 6presents concluding remarks and lessons learned.

2 A Fractionated Spacecraft Case Study

This section presents a case study of a weather satellitedesigned using a fractionated spacecraft architecture [8].

Figure 1. A Fractionated Spacecraft Spatial Deployment Problem

We use this case study throughout the paper to motivate thechallenges of devising complex spatial deployment plans.

2.1 Overview of Fractionated Spacecraft

The fractionated spacecraft weather satellite is con-trolled by a ground station. The satellite runs a set ofsoftware components (such asImage Acquisition forcapturing weather images,Feature Identificationfor identifying important characteristics of the images, andFeature Reporting for relaying image information toa ground station) that is dictated by the ground controlstation. The ground control station can also dynamicallychange the spatial deployment of the software componentsto satellites to improve performance, change power con-sumption characteristics, or adapt to hardware failures.

The example fractionated spacecraft deployment prob-lem in Figure 1 shows how developers must determine adeployment plan that maps the three imaging software com-ponents in the upper left hand to the group of satellites.The generated deployment topology must ensure that eachsoftware component meets its real-time deadlines, memoryconsumption does not exceed a maximum limit, communi-cation links provide sufficient bandwidth and connectivityfor processing, and as little power as possible is used.

We use this fractionated spacecraft scenario to showcaseseveral key challenges in Section 2.2. The example has beenreduced in scale to simplify the process of illustrating thecomplexities of DRE system deployment. Production de-ployment problems involve hundreds of software compo-

nents and thousands of messaging interactions, as opposedto the three shown in this example.

2.2 Spatial Deployment Challenges for DRE Sys-tems

A deployment topology is a mapping of software com-ponents and their associated tasks to a hardware proces-sor components. In real-time systems, either fixed prior-ity scheduling algorithms, such as rate-monotonic (RM)scheduling [48], or dynamic priority scheduling algorithms,such as earliest-deadline-first (EDF) [48], control the exe-cution ordering of the individual tasks on the processors.A fundamental constraint of finding a spatial deploymenttopology for DRE systems is that the topology must ensurethat no processor is assigned more tasks than it can sup-port. Finding a deployment topology for a series of softwarecomponents that ensures schedulability of all tasks has beenshown to be NP-Hard [9].

Since the problem is NP-Hard, developers must makevarious assumptions (such as estimates of the worst-caseexecution time of software tasks) and employ a variety ofheuristic deployment algorithms. A number of algorithmsassume processor homogeneity and use variations of heuris-tic bin-packing algorithms [16, 14, 35, 15, 9]. For example,rate-monotonic first fit scheduling allocates components toprocessors using a first fit bin-packing algorithm.

Although these algorithms help facilitate automated gen-eration of deployment topologies for real-time systems,they do not account for how variations in deployment topol-

ogy affect the power consumption of a DRE system. Net-work links—particularly wireless ad-hoc network links—vary in power consumption based on the transmissionpower required to send a signal across the space betweentwo processing nodes. Moreover, hardware node variationsin clock speed, voltage, and other attributes can impact theperformance per watt that they provide. It is critical to ac-count for these variations in DRE systems when designing aspatial deployment topology that optimizes for power con-sumption. The remainder of this section explores key chal-lenges of using existing deployment algorithms to optimizethe deployment topology of a DRE system for power con-sumption.

(a) A Software Deployment Topology for the Fractionated Spacecraft

(b) A Software Deployment Topology for the Fractionated Spacecraftwith Superior Performance per Watt

Figure 2. Comparison of Two Spatial Deploy-ment Topologies for Processor Power Con-sumption

2.3 Challenge 1: Accounting for Variations inPerformance Per Watt of Processing Cores

Current deployment techniques, such as bin-packing, aredesigned to minimize the number of computational nodesthat are utilized by a deployment topology, but do not pro-vide assurance or optimization of the power consumed bythe deployment topology. The goal of solving a bin-packingproblem is to take a set of items with varying sizes and packthem into a series of limited size bins using as few bins aspossible. Properties of the power consumption of the binsare not considered in the problem. In many spatial deploy-ment domains, such as the fractionated spacecraft imagingplatform shown in Figure 1, power is severely limited andminimizing its consumption is a key concern.

Heuristic bin-packing algorithms [16, 14, 35, 15, 9]. typ-ically use an incremental algorithm that sorts items and binsbased on their sizes and then use a packing strategy, such asfirst-fit, to allocate each item to a bin. Specialized variationsof bin-packing [16, 14, 35, 15, 9] are used to pack tasks ontoprocessors while ensuring real-time schedulability.

For example, both deployment topologies in Figures 2(a)& 2(b) yield a solution that consumes two bins (e.g., satel-lites). A bin-packing algorithm would consider both solu-tions to be equally valid–both use exactly two processingcores. Clearly, however, the solution in Figures 2(b) is su-perior since it usesSat 5 andSat 3, which have a higherperformance per watt score. A bin-packing algorithm can-not discern the advantage of usingSat 3 andSat 5 com-pared toSat 4 andSat 5. The method that ScatterDuses to overcome this challenge is discussed in Section 3.5.

2.4 Challenge 2: Handling Variations in NetworkLink Power Consumption

A key determinant of power consumption in DRE sys-tems with mobile ad-hoc networks is radio transmission forwireless network links [20]. The power consumption of awireless link is directly related to the transmit power re-quired to propagate the transmission over the physical areaseparating the computational nodes and the frequency thatthe network link is in use. The spatial deployment topol-ogy determines how often network communication is per-formed, how far apart the nodes are that are involved in thecommunication, and the types of wireless communicationtechniques required.

For example, the radio communication link in Fig-ure 1 betweenSat 1 and Sat 3 spans a shorter dis-tance than the link fromSat 2 to Sat 3 and thus con-sumes less power. Clearly, if theImage AcquisitionandFeature Identification components commu-nicate across one of these links, deploying the componentsto Sat 1 andSat 3 and using their radio link will con-

sume less power. It is critical that a spatial deploymenttechnique account for these types of variation in power con-sumption between spatial deployment topologies. Again,work has been done on using heuristic algorithms for taskdeployment [16, 14, 35, 15, 9] and integer programmingfor optimizing scheduling [11, 5, 39], but no approach cur-rently optimizes the spatial deployment topology for powerconsumption concerns.

Research using integer programming and constraint pro-gramming has been performed on optimizing power con-sumption on multi-core chips [28, 34, 40, 38, 23, 7]. Thisprior work, however, has focused on scenarios where all ofthe cores are physically located on the same chip. When theprocessing nodes are not physically co-located one the samechip or on the same physical platform, expensive wirelesscommunications must be performed. Since these techniquesdo not account for the power consumption of the networklinks, they may not produce an ideal deployment topology.

For example, each satellite in Figure 1 has sufficientCPU capacity to schedule the real-time tasks associatedwith both the Image Acquisition and FeatureIdent orFeature Ident andFeature Reporting.Scheduling the tasks of all three software components onone satellite’s processor is not possible. As shown inFigures 3(a) & 3(b), from the point of view of a multi-core power consumption algorithm, grouping either setof two software components onto the same satellite isequivalent–both will yield a solution that utilizes two pro-cessing nodes with identical power consumption. Clearly,however, spatially co-locating theImage Acquisitionand Feature Ident software components, as shownin Figure 3(b), is a better solution since they communi-cate at 58hz and consume more power communicating be-tween each other than theFeature Ident andFeatureReporting sotware components. Colocating the tasksin the same space saves that power from being consumedthrough network communication. Section 3.5 discusseshow ScatterD uses an evolutionary algorithm to drive aheuristic bin-packer to explore multiple solutions with dif-fering network power consumption characteristics.

2.5 Challenge 3: Deployment Automation Tech-nique Scalability

A fundamental constraint of deriving deploymenttopologies for DRE systems is that all software componentsmust meet their real-time deadlines on the processors towhich they are deployed. This basic constraint is known asthemulti-processor scheduling problemand has been shownto be NP-Hard [9]. Since the problem is NP-Hard, many op-timization algorithms with exponential time-complexity arehard to apply.

A number of optimization techniques are available for

(a) A Software Deployment Topology Using Two Nodes

(b) A Software Deployment Topology Using Two Nodes and Less Band-width

Figure 3. Comparison of Two Spatial Deploy-ment Topologies Based on Network Utiliza-tion

similar linear and non-linear problems. For example, anumber of similar deployment problems can be modeledas constraint satisfaction problems (CSPs) [45, 37] or in-teger programming problems [11, 5, 39]. The drawbackwith these approaches is that they are based on exponentialtime algorithms that do not scale up to large spatial deploy-ment problems with 10s of computational nodes, 100s ofsoftware components, 1000s of software component com-munication interactions, and multiple interconnecting net-works. Numerous optimization tricks can be applied, suchas Bender’s Decomposition [24, 22], but research has stillonly shown the ability to scale to 10’s of software compo-nents and communication interactions. As discussed in Sec-tion 3.3, ScatterD combines an evolutionary algorithm withheuristic bin-packing to avoid the scalability limitations ofusing an exponential algorithm.

3 The ScatterD Deployment Algorithm

This section describes ScatterD, which is a hybridheuristic/evolutionary algorithm for optimizing spatialde-ployment topologies for minimizing power consumption.ScatterD allows DRE system developers to automaticallyderive deployment topologies that meet a combination ofreal-time scheduling, memory, co-location, and spatial con-

straints. This section first presents a formal model of spatialdeployment for power consumption minimization and thenprovides an overview of evolutionary algorithms. The sec-tion next discusses how ScatterD combines an evolutionaryand bin-packing algorithm into a hybrid algorithm and pro-vides an example of how particle swarm optimization (PSO)is turned into a hybrid heuristic/evolutionary algorithm withScatterD.

3.1 Formal Model of DRE Deployment

To optimize a spatial deployment topology for powerconsumption, a formal model should first be built that de-scribes the constraints and objective function to optimize.A spatial deployment problem for power consumption min-imization can be described as a 7-tuple:

Dp =< C, N, s(~T ), r(~T ), p(~T ), co(~T ), e(~T ) >

where:

• C is the set of components that must be deployed tothe hardware processing nodes

• N is the set of hardware processing nodes

• ~T is a deployment topology described as a vectorwhere theith position holds the index of the node thatith component is deployed to (e.g., Component 1 toNode 3,T1 = 3)

• s(~T ) is a function that returns 0 if the deploymenttopology assigns components to nodes such that nocomponent will miss any real-time deadlines and oth-erwise returns the total number of deadlines that willbe missed. The precise definition of this functionvaries based on the scheduling policy, such as rate-monotonic or earliest deadline first, that is used. Inthis paper, we use a recurrence relation for checkingrate-monotonic schedulability [48].

• r(~T ) is a function that returns 0 if the deploymenttopology assigns components to nodes such that nonode has its resources, such as RAM, overconsumedand otherwise returns the total number of nodes withoverconsumed resources.

• p(~T ) is a function that returns 0 if the deploymenttopology meets spatial attribute-based constraints,such as enusring that components that require a min-imum distance from a specific point in the satellite areassigned an appropriate location. Otherwise, the func-tion returns the number of these constraints that areviolated.

• co(~T ) is a function that returns 0 if the deploymenttopology assigns components to nodes such that nocomponent co-location constraints, such as requiringtwo components to be deployed to different nodes, areviolated. Otherwise, the number of co-location viola-tions is returned.

• e(~T ) is an objective function that calculates the powerconsumed by a specific deployment topology.

The constraints are described by functions so that theycan be adapted to a particular spatial deployment scenario.For example, if the scheduling technique changes, a differ-ent function can be provided fors(~T ). Similarly, if a set ofconstraints is not present, a particular function may alwaysreturn 0.

A correct deployment topology,~T , requires that:

|~T | = |C| (1)

∀Ti ⊂ ~T , (Ti ≥ 0) ∧ (Ti ≤ |N | − 1) (2)

~T ⇒ (co(~T ) + p(~T ) + r(~T ) + s(~T ) = 0) (3)

First, as shown in (1), the deployment topology vector,~T , must specify a deployment location for every compo-nent. Second, as seen in (2), the node index specified byeach position in the deployment vector,~T , must refer to avalid 0-based index in the node array. Finally, in (3), thesolution must not to violate any scheduling or other con-straints. The goal of an optimized deployment topology isto assure that these correctness constraints are upheld, whileminimizing the value ofe(~T ).

3.2 Evolutionary Algorithms Background

Evolutionary algorithms [4, 21], such as particle swarmoptimization (PSO) [29, 42] and genetic programming [32,33], are a promising technique for generating deploymenttopologies. With an evolutionary algorithm, a set of ran-domly generated initial solutions [27] is created and thenevolved over a series of generations to reach a final solution.The evolutionary process uses a scoring criteria to identifythe best solutions and promote their propagation in the evo-lution. At the end of the evolutionary process, the highestscoring solution is output as the best result.

Members of a solution population are typically modeledas vectors, where the vector components represent genes orpositions of particles. In a PSO algorithm, for example,the vectors represent positions within a multi-dimensionaldesign space. Permuting the vector corresponds to changingthe design of the solution.

Figure 4. Representing a Spatial DeploymentTopology as a Vector

For example, Figure 4 shows an example method of map-ping a PSO particle position to a spatial deployment prob-lem. On the left-hand side of Figure 4, the deploymenttopology vector,~T = [1, 2, 2] corresponds to a deploymenttopology where the first software component is deployed tothe first hardware node, the second software the to secondhardware node, and the third component to the second hard-ware node. As the PSO evolution proceeds, the design atstep i is permuted to the deployment topology~T = [2, 1, 2]at step i+1, corresponding to the first component being de-ployed to the second hardware node, the second componentto the first hardware node, and the third component to thesecond hardware node.

The key problem of applying evolutionary algorithms tospatial deployment problems is their poor behavior whenthe solution space contains large numbers of points in thesearch space corresponding to solutions that do not meetthe design constraints. In a complex spatial deploymentproblem with real-time scheduling constraints, resource,co-location, and other constraints, randomly generating aset of initial solutions is unlikely to generate a set of validinitial solutions that satisfy the constraints (e.g.,co(~T ) +

p(~T ) + r(~T ) + s(~T ) = 0) [17]. Moreover, evolving so-lutions through arbitrary evolutionary schemes, such as ge-netic mating [17], is also unlikely to yield new valid solu-tions where the constraints are satisfied.

One approach to handling this issue is to devise a scor-ing solution that always ranks valid solutions higher thaninvalid solutions, but also scores invalid solutions on theirrelativeclosenessto being correct. For example, an invalidsolution can be scored based on the number of constraints itviolates:

−1 ∗ (co(~T ) + p(~T ) + r(~T ) + s(~T ))

. The challenge with this strategy is that the number of vi-

olated constraints is not necessarily an accurate predictorof the solution’s distance from a correct solution. For in-stance, a solution with a single violated constraint, may re-quire changing every component to hardware allocation inorder to meet the constraints. If the solution is not close tovalid, the design may be promoted in the evolutionary pro-cess due to its good score, even though it is not remotelyclose to a good solution.

Another remedy is to devise a repair operation that cantake an arbitrary invalid solution and modify it to yield avalid solution. With complex spatial deployment problems,however, the constraints are too complex to determine howto modify an arbitrary invalid solution to satisfy the deploy-ment constraints.

3.3 ScatterD Hybrid Evolutionary AlgorithmModifications

To overcome these challenges of applying evolution-ary algorithms to spatial deployment problems, ScatterD isbased on a combination of first-fit bin-packing and an evo-lutionary algorithm. The evolutionary algorithm that is usedwith ScatterD is pluggable. We demonstrate the use of Scat-terD with both PSO and a genetic deployment algorithm be-low.

In these evolutionary algorithms, a population of candi-date deployment topologies,P , is randomly generated andthen evolved over a series of time steps. At each time step,the population members are scored using a fitness measure-ment,F (~pi). An evolutionary operator,evolve(~pi), is thenapplied to each solution to either modify it before the nexttime step, remove it from the search process, or combine itwith another solution to produce a new population meme-ber. The evolutionary operator’s output is highly dependenton the scores received by the individual candidate designs.

In general, an evolutionary algorithm operates as fol-lows:

1. Each member of the population in the evolutionarysearch process is assigned a random initial vector,~pi = ~random. In a genetic algorithm, the vector rep-resents the genes in the candidate design. In a PSOalgorithm, the vector specifies the position of a searchparticle in the multidimensional search space.

2. Each population member position is scored using a fit-ness metric,F (~pi).

3. An evolutionary operator,evolve(~pi), is applied toeach population member to produce the populationmembers for the next iteration of the algorithm.

4. Steps 2-3 are repeated until the maximum number ofsteps is reached or the process converges on a singlesolution.

5. The highest scoring population member is output asthe result.

3.4 Combining Bin-packing with an EvolutionaryAlgorithm

To overcome the challenges of applying evolutionary al-gorithms to spatial deployment problems, ScatterD is basedon a combination of first-fit bin-packing and an evolution-ary algorithm. The most straightforward method of apply-ing an evolutionary algorithm to spatial deployment is tomodel each population member’s vector as a deploymenttopology, ~T = ~pi. The fitness function for the evolution-ary optimization can then be set to the power consumptioncalculation function,F (~pi) = e(~T ). Since the schedulingand other deployment constraints must also be upheld, thefitness function can refined and defined as:

V (~pi) = co(~pi) + p(~pi) + r(~pi) + s(~pi)

F (~pi) =

{

e(~pi) if V (~pi) = 0,

−1 ∗ V (~pi) otherwise.(4)

Since the spatial deployment solution space is highlyconstrained, using an arbitrary evolutionary operator,evolve(~pi), to updatepi is likely to produce a large numberof solutions for which the constraints do not hold and henceF (~pi) = −1 ∗ V (~pi). Moreover, randomly assigning initialvectors,~pi = ~random, is unlikely to yield a valid deploy-ment topology. The evolution may therefore progress usingpotentially highly inaccurate estimates of how close the so-lution is to yielding a spatial deployment topology that isvalid and minimizes power consumption. Section 3 presentsempirical results for a number of deployment problems thatshow this inaccuracy in solution quality estimation is a sig-nificant detriment to the spatial deployment topology searchprocess.

To minimize the probability that invalid spatial deploy-ment topologies are explored by the evolutionary optimiza-tion, ScatterD uses several specialized techniques to over-come these limitations. The two key challenges that Scat-terD must use these techniques to address are (1) determin-ing how to generate the initial vectors to maximize the prob-ability that they correspond to valid deployment topologiesand (2) ensuring that as the vectors are are evolved, theprobability that they are invalid is minimized.

ScatterD combines an evolutionary algorithm with a bin-packing algorithm to address these two issues. The keychange made to the evolutionary algorithm is that the popu-lation member’s vectors are not interpreted as directly rep-resenting a deployment topology~T but instead representa bin-packing order for a subset of the components. Thisintermediate input is input into a bin-packing algorithm toproduce the actual deployment topology,~T .

The hypothesis is that since a bin-packer uses specializedheuristic knowledge to deploy components, it is more likelyto derive a deployment topology that is valid, comparedwith a randomized evolutionary scheme. A bin-packer,however, is designed to produce a single solution, whichas shown in Section 2.2 is not necessarily optimized forpower consumption minimization. The semi-random pack-ing vector, produced by the evolutionary algorithm, servesto vary the constraints in the bin-packing problem and coaxthe heuristic bin-packing algorithm into producing multiplesolutions. The evolutionary process thus becomes a driverfor exploring the solution space via semi-randomized exe-cutions of a bin-packing algorithm.

3.5 Packing Order Vectors

In a standard heuristic bin-packer, such as first-fit bin-packing or best-fit bin-packing, the algorithm sorts the soft-ware components according to a heuristic, such as highestCPU consumption. In ScatterD’s modified scheme, the bin-packer first places a semi-random subset of the componentsusing the ordering obtained by interpreting the vector of apopulation member,~pi, from the evolutionary algorithm asa packing order for a subset of the components. Only afterthose components are placed is the bin-packer allowed tosort and place the remaining components using its standardheuristics.

The key step in combining the two algorithms is produc-ing a modified bin-packing algorithm that packs softwarecomponents onto hardware nodes in two phases. In the firstphase, the packing order vector is input into the bin-packingalgorithm and the bin-packer iteratively removes the com-ponent at the head of the list, finds the first hardware nodethat will support it, and deploys it there. The packing ordervector covers a random subset of the components that mustbe deployed. Any components packed in the first stage areremoved from the master list of components to pack.

In the second phase, the bin-packing algorithm appliesits standard heuristics to sort the remaining components.After the components are sorted, the bin-packer iterativelychooses the item at the head of the list of remaining itemsto pack and places it on the first valid hardware node place-ment. A placement on a specific hardware node is consid-ered valid if it does not produce any constraint violations,e.g., it does not causeV (~pi > 0. This process proceedsuntil all of the components are placed on nodes.

The modified evolutionary algorithm works as followswith the hybrid modifications:

1. Each population member in the evolutionary searchprocess is assigned a random initial vector,~pi =

~random.

2. For i = 0, i < |pi|, a first-fit bin-packing algorithm

takes the software component referred to by positioni

and places it on a hardware node. The node that eachcomponent is placed on is recorded in the deploymenttopology vector,T = dpi.

3. The software components that are not placed on a nodein Step 2 are placed into a list,R.

4. The software components inR are sorted using a bin-packing heuristic, such as CPU consumption.

5. Each software component inR is placed on a hardwarenode using a standard bin-packing algorithm. Thenode that each component is placed on is recorded inthe deployment topology vector,dpi.

6. The score for each population member is calculatedusing a fitness metric, as a function of the deploy-ment plan,F ( ~dpi), and not directly from the popula-tion member’s vector,~pi.

7. An evolutionary operator,evolve(~pi), is applied toeach population member to produce the populationmembers for the next iteration of the algorithm.

8. Steps 2-7 are repeated until the maximum number ofsteps is reached or the process converges on a singlesolution.

9. The highest scoring deployment topology,dpi, is re-turned as the result.

3.6 Example: Using ScatterD to Create a HybridHeuristic Particle Swarm Optimization

PSO is an evolutionary algorithm designed to simulatethe flocking behavior of birds searching for food. A virtualflock of birds, called particles, is created and each particle isscored using a fitness metric,F (~pi). Particles are attractedto the best scoring position and attempt to move towards it.Each particle also remembers the best solution it has seenso far and uses this position in determining its movement.As the particles move, new global and personal bests arediscovered, altering the flocking behavior of the particles.

In general, the PSO algorithm operates as follows:

1. Each member of the population in the evolutionarysearch process is assigned a random initial position,~pi = ~random.

2. Each population member position is scored using a fit-ness metric,F (~pi).

3. The particle position,pk, with the overall best score ismarked as the global best,~G = ~pk.

4. Each particle has its score compared to the particle’spersonal best score obtained so far. If the score ishigher, the personal best position,~pbi, is set to the cur-rent position,~pbi = ~pi.

5. The position of each particle,pi ∈ P , is used to calcu-late a velocity for the particle:

~vi = ~vi + R1C1(~pi − ~pbi) + R2C2(~pi − ~G)

The coefficientsR1 andR2 are random numbers be-tween zero and one. The coefficientsC1 andC2 areused to alter the influence of the global and personalbest particle positions on the velocity calculation.

6. Each particle’s position for the next iteration of theevolution is updated by adding its new velocity,~pi =~pi + ~vi.

7. Steps 2-5 are repeated until the maximum number ofsteps is reached or the process converges on a singlesolution.

8. The highest scoring particle position is output as theresult.

Modifying PSO to operate with the ScatterD is straight-forward. The scoring function is modified to interpret theparticle positions as packing order vectors for a bin-packer.The modified PSO algorithm works as follows:

1. Each particle in the evolutionary search process is as-signed a random initial position,~pi = ~random.

2. For i = 0, i < |pi|, a first-fit bin-packing algorithmtakes the software component referred to by positioni

and places it on a hardware node. The node that eachcomponent is placed on is recorded in the deploymenttopology vector,T = dpi.

3. The software components that are not placed on a nodein Step 2 are placed into a list,R.

4. The software components inR are sorted using a bin-packing heuristic, such as CPU consumption.

5. Each software component inR is placed on a hardwarenode using a standard bin-packing algorithm. Thenode that each component is placed on is recorded inthe deployment topology vector,dpi.

6. The score for each particle’s position is calculated us-ing a fitness metric as a function of the deploymentplan,F ( ~dpi), and not the particle position,~pi.

7. The particle position with the overall highest scoringdeployment plan is marked as the global best,~G = ~pi.The global best position isnot set to the deploymenttopology vector of that node.

8. Each particle has its deployment plan’s score com-pared to the particle’s personal best score obtained sofar. If the score is higher, the personal best position,~pbi, is set to the current position,~pbi = ~pi.

9. The position of each particle,~pi ∈ P , is used to calcu-late a velocity for the particle:

~vi = ~vi + R1C1(~pi − ~pbi) + R2C2(~pi − ~G)

10. Each particle’s position for the next iteration of theevolution is updated by adding its new velocity,~pi =~pi + ~vi.

11. Steps 2-10 are repeated until the maximum number ofsteps is reached or the process converges on a singlesolution.

12. The highest scoring deployment plan,dpi, is output asthe result.

Heuristic algorithms, such as bin-packing, are typicallyfocused on finding exactly one solution to a problem. Inthe case of spatial deployment, this characteristic preventsthe algorithms from exploring many potential designs thatmay provide excellent power consumption characteristics.Evolutionary algorithms, in contrast, lack the specializedproblem-specific heuristic knowledge of an algorithm, suchas bin-packing, but are excellent at exploring a number ofdesign alternatives.

By combining the two approaches into a single algo-rithm, ScatterD leverages the key advantages of each alo-girhtmic approach. ScatterD’s soution space representationas bin-packing algorithm input permutations helps to de-crease the probability that invalid solutions will be exploredthrough arbitrary evolutionary population member permu-tations. The use of an evolutionary exploration techniquealso allows the evaluation of multiple candidate solutionsand comparisons based on power consumption characteris-tics that are missed with a standard heuristic bin-packer.

4 Empirical Results

This section analyzes empirical results obtained by ap-plying the ScatterD techniques, bin-packing, PSO, and agenetic algorithm to an example fractionated spacecraft sys-tem. The fractionated spacecraft example was producedby modifying a production avionics dataset [19] obtainedfrom Lockheed Martin Aeronautics through the SPRUCEproject (www.sprucecommunity.org), which is aweb-accessible portal that pairs academic researchers withindustry challenge problems complete with representativeproject data. We compared the ability of each deploymentalgorithm to reduce the power consumption provided by thebaseline spatial deployment topology from the aeronauticsdataset.

4.1 Experimental Platform

The fractionated spacecraft example contains a spatialdeployment topology and software architectural informa-tion for a spacecraft system with∼50 processors,∼300software components, and 15,000 periodic messages. Real-time scheduling constraints are included in the example, in-cluding task rates and CPU consumption. The example alsocontains information on the messaging interactions betweenthe software components. A total of∼15,000 messaging in-teractions are described by their rate, message size, messagetype, and source/destination software components.

We obtained the data in the following experiments byaugmenting the original fractionated spacecraft examplewith power consumption information for the processors andnetwork communications. The software architecture re-mained static throughout the experiments while we variedthe power consumed by the processors to simulate differentdeployment scenarios with hardware varying from work-station Xenon processors to wireless sensor motes. Powerdissipation of the various processors was based on publicpower dissipation data published by Intel and empirical re-sults from sensor motes published by Anastasi et al. [2]. Allnetwork communications were modeled to take place over awireless 802.11b network and power consumption was cal-culated using the results produced by Feeney et al. [20].

For each experiment we compared the deploymentsproduced by six different automated deployment tech-niques against the baseline deployment from the aeronau-tics dataset. The six algorithm variations that we comparedwere:

1. Bin-packing – A first-fit heuristic bin-packer was cho-sen due to their widespread use for deployment prob-lems.

2. ScatterD PSO – The PSO variant of ScatterD.

3. ScatterD Genetic – The genetic algorithm variant ofScatterD.

4. PSO with Bin-packing Seeding – A PSO algorithmwas seeded with the results of randomized first-fit bin-packing. Packing-order vectors were not utilized inthis variant.

5. Genetic with Bin-packing Seeding – A genetic algo-rithm was seeded with the results of randomized first-fit bin-packing. Packing-order vectors were not uti-lized in this variant.

6. PSO – the same PSO algorithm used for the ScatterDPSO was used but without the packing-order vectorsand initial seeding from a bin-packing algorithm.

7. Genetic Algorithm – the same genetic algorithm usedfor the ScatterD was used, but without the packing-order vectors and initial seeding from a bin-packingalgorithm.

Variations of PSO and genetic algorithms with and withoutthe ScatterD enhancements were chosen to compare the im-provements yielded by the ScatterD techniques. A first-fitbin-packing algorithm was chosen because they are widelyused in deployment problems.

For both the genetic and PSO algorithms, a populationsize of 20 was used and a total of 20 search iterations (gen-erations) were run. The PSO algorithm used a local learningcoefficient of 1 and a global learning coefficient of 2. Thegenetic algorithm allowed a total of 10% of the populationto be passed through to the next generation, selected the top25% of solutions for mating, and applied a mutation proba-bility of 5%.

Each algorithm was implemented in Java (the im-plementations are available in open-source form throughthe Ascent Design Studio atcode.google.com/p/ascent-design-studio). The comparisons were per-formed on an Apple MacBook Pro with 4gb of RAM, a3.06ghz Intel Core 2 Duo Processor, and Mac OS X 10.5.7.A version 1.6 Java Virtual Machine (JVM) was used to con-duct the experiments. The JVM was run in client mode us-ing a heap size of 40 megabytes (-Xms40m) and a maxi-mum memory size of 256 megabytes (-Xmx256m).

4.2 Experiment 1: Deployment Across a Homo-geneous Set of Workstation Processors

This experiment tested the capabilities of each algorithmto reduce the power consumption of the avionics softwarein a deployment across a homogeneous set of 6 core In-tel Xenon L7455 processors. Power consumption improve-ments were calculated by comparing the power consump-tion of the deployments produced by each algorithm to theoriginal baseline deployment from the aeronautics dataset.

Hypothesis: ScatterD should provide significantreductions in power consumption compared to bin-packing. Initially, we believe that ScatterD’s ability tosearch multiple spatial deployment permutations wouldlead to solutions with far superior power consumption char-acteristics than those produced by the bin-packing algo-rithm. We also hypothesized that neither the standard PSOor genetic algorithms would produce good solutions due tothe complexity of the design space.

Analysis of results.The results from the experiment areshown in Figure 5. The ScatterD Genetic algorithm pro-duced the largest power consumption reduction, followedclosely by ScatterD PSO. Interestingly, the bin-packing al-gorithm produced a power savings that was within≈94%of the solution produced by ScatterD Genetic.

Figure 5. Homogeneous Xenon Deployment

After careful analysis, it became clear that because theprocessors are homogenous, the first-fit bin-packing heuris-tic performs extremely well. Moreover, because the Xenonprocessor draw a substantial amount of power compared tothe network transmissions, idling processors was the mostimportant concern in this problem. In this particular case,the emphasis on processor idling and the homogeneity ofthe cores allowed the bin-packing algorithm to nearly equalthe more complex searches from ScatterD.

In this experiment, the standard PSO algorithm was un-able to find a valid solution within the allotted time. Thestandard genetic algorithm also produced a poor solution.Throughout the experiments, both of these algorithms pro-duced poor results compared to the rest, demonstrating theimportance of ScatterD’s hybrid heuristic optimizations.

4.3 Experiment 2: Deployment Across a Homo-geneous Set of Low-power Processors

This experiment compared deployments across a groupof Intel XScale processors, which consume substantiallyless power than the Xenon workstation processors. Thelower power consumption of the processors meant that re-ductions in network traffic would play a more important rolein reducing the power consumption in this scenario.

Hypothesis: An emphasis on network traffic reduc-tion would produce far more power conserving de-ployment topologies from ScatterD versus bin-packing.Since the cost of CPU time was decreased, we assumed thatScatterD’s advantages in network traffic optimization wouldallow it to produce much better solutions than bin-packing.

Analysis of results. The results for this experiment areshown in Figure 6. The ScatterD Genetic algorithm pro-duced the biggest reduction in power consumption. In thiscase, the ScatterD Genetic algorithm saved roughly 25%

Figure 6. XScale Deployment

more power than the first-fit bin-packing algorithm. TheScatterD PSO algorithm also beat the bin-packing algo-rithm by roughly 3%.

The Genetic and PSO algorithms that did not use the fullset of ScatterD optimizations were unable to produce a so-lution better than the bin-packing algorithm. The PSO al-gorithm did not find a solution in the allotted search timeframe. Moreover, the genetic algorithm produce a solutionthat saved less than 50% of the power of the first-fit bin-packing algorithm’s solution. In this scenario, the packing-order vector and bin-packing seeding optimizations of Scat-terD produced a clear advantage over standard PSO and ge-netic algorithms.

4.4 Experiment 3: Deployment Across a Homo-geneous Set of Sensor Motes

This experiment compared the deployment topologiesproduced by the algorithms when deploying the softwareonto a set of low power wireless sensor motes. The powerconsumption of the motes was modeled after the results pro-duced by Anastasi et al. [2]. The extremely low power con-sumption of the processors meant that reductions in networktraffic would play a far larger role in reducing the powerconsumption than in other scenarios.

Hypothesis: Network traffic reduction would be thedominant factor in determining which algorithm pro-duced the lowest power spatial deployment topology.The significantly lower power consumption of CPU pro-cessing relative to network power consumption should favoralgorithms that reduce network traffic the most. We antic-ipated that ScatterD would show further improvements inpower consumption versus the previous two experiments.

Analysis of results. The results for this experiment areshown in Figure 7. The ScatterD Genetic algorithm pro-

Figure 7. Sensor Motes Deployment

duced the biggest reduction in power consumption. More-over, the ScatterD Genetic’s deployment topology saved240% more power than the bin-packing algorithm. TheScatterD PSO algorithm also saved 167% more powerthan the bin-packing algorithm. The standard bin-packingseeded PSO and genetic algorithms also tied or surpassedthe bin-packing algorithm. The standard genetic algorithmdid not produce a power conservative deployment topology.The PSO algorithm did not find a valid solution.

As hypothesized, ScatterD significantly outperformedthe standard bin-packing algorithm since takes into accountnetwork power consumption variations. Moreover, withoutthe ScatterD optimizations, the standard genetic and PSOalgorithms had difficulty in the highly constrained deploy-ment search spaces. For deployments across low-powerwireless sensor networks or in other low-power scenarios,ScatterD produces the biggest reductions in power con-sumption.

4.5 Experiment 4: Deployment Across a Hetero-geneous Set of High and Low Power Proces-sors

This experiment combined the power consumption mod-els from the previous three experiment into a single de-ployment scenario across a set of heterogeneous processors.This scenario was designed to mimic a large-scale systemcombining a variety of servers, mobile devices, and wirelesssensors. One third of the processors were modeled as high-powered Xenons. One third of the processors were modeledas lower powered XScale processors. Finally, the remainingprocessors were modeled as wireless sensor motes.

Hypothesis: Accounting for power consumption vari-ations in processor cores would be the most significantfactor in reducing power consumption. With a variety of

processor power consumption profiles, we believed that ac-counting for these variations would be more important thanreducing network traffic. Again, we anticipated that Scat-terD would outperform the other algorithms.

Analysis of results. The results for this experimentare shown in Figure 8. The ScatterD Genetic algorithm

Figure 8. Heterogeneous XScale and XenonDeployment

again produced the biggest reduction in power consump-tion. Suprisingly, the reduction in power consumption wasover 1500% greater than the bin-packing algorithm. TheGenetic PSO algorithm also exceeded the power reductionof the bin-packing algorithm by over 1300%.

While analyzing the results, we derived a simple modi-fication to the problem that provided a substantial improve-ment for the bin-packing algorithm. Instead of providingthe processors to the algorithms in an arbitrary order, wefirst sorted the list so that the lowest power processors werein the front of the list. The intuition is that a first-fit bin-packing algorithm will use these lowest power processorfirst, before moving on to more power consumptive proces-sors. We also found that this simple modification yieldedimprovements from the other techniques as well.

The results of applying this modification to the problemand re-running it are shown in Figure 9. The modificationsapproximately doubled the power reductions produced bythe bin-packing algorithm. The ScatterD PSO algorithmprovided roughly 100% more power consumption savingscompared to the bin-packing algorithm. The ScatterD Ge-netic algorithm also produced the best overall power con-sumption score.

Figure 9. Heterogeneous XScale and XenonDeployment with Bin-packing Sorting Opti-mization

4.6 Experiment 5: Measuring Power Consump-tion Improvements from Reduced NetworkTraffic

This experiment measured the power consumption im-provements yielded by the algorithms through reduced net-work traffic. Processor time was modeled as consumingzero power to allow us to only measure variations in powerconsumption from network traffic reductions.

Hypothesis: Significant improvements in power con-sumption can be achieved by co-locating software com-ponents with high traffic interactions. Although reducingthe number of processors in a spatial deployment topologycan produce significant power consumpton improvements,we believed that network traffic reduction could also play animportant role. Bin-packing would provide some reductionin network traffic by packing software more tightly ontothe processors and co-locating more components as a side-effect. ScatterD should be able to outperform bin-packingwith its more complex search techniques.

Analysis of results. The results for this experiment areshown in Figure 10. The ScatterD PSO algorithm producedthe biggest reduction in power consumption. The ScatterDPSO algorithm saved 70% more power than the bin-packingalgorithm. The ScatterD Genetic algorithm reduced powerconsumption by 60% more than the bin-packing algorithm.The standard variants of PSO and genetic deployment algo-rithms did not perform as well as bin-packing.

Figure 10. Deployment with Wireless NetworkOnly Power Consumption Optimization

5 Related Work

A number of prior research efforts are related to the spa-tial deployment problem presented in this paper. This sec-tion provides a taxonomy of these related works and com-pares and contrasts them to ScatterD. The related works arecategorized based on the type of algorithm used in the de-ployment process.

Multi-processor scheduling. Bin-packing algorithmshave been successfully applied to the NP-Hard problem ofmulti-processor scheduling [9]. Multi-processor schedulingrequires finding an assignment of real-time software tasks tohardware processors, such that no tasks miss any deadlines.A number of bin-packing modifications are used to opti-mize the assignment of the tasks to use as few processors aspossible [16, 14, 35, 15, 9]. The chief issue of using theseexisting bin-packing algorithms for spatial deployment op-timization to minimize power is that they focus on minimiz-ing total processors used.

In certain specialized scenarios, such as when all proces-sors are identical and network communication is not a majorpower concern, these algorithms are suitable for perform-ing power consumption optimization. If processors vary inperformance per watt or power consumptive wireless com-munication is involved, however, these algorithms will notmake ideal placement decisions. In contrast, ScatterD, isdesigned to account for these variations in power consump-tion and make appropriate placement decisions.

Kirovski et al. [31] have developed heuristic techniquesfor assigning tasks to processors in resource constrainedsystems to minimize power consumption. Their techniqueoptimizes a combination of variations in processor powerconsumption and voltage scaling. These techniques, how-

ever, do not account for network communication in thepower optimization process.

Okuma and others [38, 1] have developed schedulingtechniques for real-time task scheduling on variable volt-age processor cores. The scheduling algorithm both opti-mizes task ordering and voltage levels to minimize powerconsumption. Changes in processing time from loweringprocessor voltage are also considered in the scheduling pro-cess. Others, such as Aydin et al. [3, 25], have also investi-gated real-time task scheduling but across multiple proces-sors [50]. These techniques, however, do not consider hownetwork power consumption impacts the overall system.

Task graph scheduling to minimize energy consump-tion in embedded systems.Energy consumption optimiza-tion has also been investigated in the context of the schedul-ing of conditional and unconditional task graphs to underly-ing hardware processors [43, 41]. This work attempts to op-timize power consumption while ensuring that tasks executeon processors in a required order and meet minimum per-formance requirements. In general, however, this work hasfocused on embedded systems that are spatially co-locatedand does not account for network usage energy consump-tion.

Power optimization for multicore systems on a chip.A large amount of research has focused on power consump-tion minimization in multicore systems on a chip [28, 34,40, 38, 23, 7]. These research efforts have investigatedmethods of leveraging differing voltages and capabilitiesofspecific processing cores to optimize the power consump-tion of the system while guaranteeing performance con-straints. This work mainly focuses on the core assignmentaspects of the allocating computing cores to software tasks.

Power optimization for network systems on a chip.Others have considered network power consumption in thecontext of network systems on a chip, which allow for vari-able speed interconnect links [26, 44]. These techniques op-timize task placement and network link speed in the contextof a single chip. Spatially-separated systems on differentchips are not considered in this work.

Hardware/software co-synthesis. Hardware/Softwareco-synthesis research has yielded techniques for determin-ing the number of processing units, task scheduling, andother parameters to optimize systems for power consump-tion while meeting hard real-time constraints. Dick etal. [17, 18], have used a genetic algorithm for the co-synthesis problem. As with other single-chip work, how-ever, this research is directed towards systems that are notspatially separated from one another.

Client/Server Task Partitioning for Power Optimiza-tion. Network power consumption and processor powerconsumption have both been considered in work on par-titioning client/server tasks for mobile computing [49, 12,36]. In this research, the goal is to determine how to parti-

tion tasks between a server and mobile device to minimizepower drain on the device. This work, however, is focusedonly on how power is saved by moving processing respon-sibilities between a single client and server.

6 Concluding Remarks and Lessons Learned

Power consumption in DRE systems can be minimizedby carefully choosing a good spatial deployment topol-ogy. The spatial deployment topology determines how farapart communicating software components are and thushow much transmit power is needed for wireless commu-nication. Moreover, processing nodes vary in performanceper watt for different tasks and these variations can be ex-ploited to optimize the energy consumption footprint of thesystem.

Designing automated algorithms to perform deploy-ment optimization is hard,e.g., deployment with real-timescheduling constraints is an NP-Hard problem [9]. Expo-nential algorithms, such as integer programming, often donot scale well for industrial size problems. Evolutionaryalgorithmic techniques, such as genetic algorithms, tend toprovide poor performance in the highly-constrained solu-tion spaces that are typical of spatial deployment problems.

This paper described how ScatterD combines heuristicbin-packing with an evolutionary algorithm to obtain sub-stantial performance increases in spatial deployment topol-ogy derivation. In the empirical results presented in Sec-tion 4, we observed substantial power consumption im-provements with the hybrid ScatterD algorithm comparedto strictly evolutionary techniques. Moreover, ScatterD pro-duced deployment topologies that saved 4.5% more powerin server deployments (Experiment 1, Section 4.2) andsaved over 240% more power in wireless sensor mote de-ployment scenarios (Experiment 3, Section 4.4).

We learned the following lessons from our work re-searching and developing the ScatterD hybrid heuris-tic/evolutionary deployment algorithm:

• Power consumption can be reduced significantly bycarefully balancing network utilization and proces-sor efficiency tradeoffs.The empirical data from Sec-tion 4 showed that accounting for both network andprocessor power consumption provides superior re-sults to focusing exclusively on either one individually.

• Solution space representation is criticalto the abil-ity of an evolutionary algorithm to efficiently generatespatial deployment topologies. By modeling the so-lution space as permutations of the input to a heuris-tic bin-packing algorithm, we observed a roughlyfour-fold increase in the number of good deploymenttopologies that were explored.

• Combining heuristic and evolutionary algorithmsover comes a number of problemsof applying eitherindependently to spatial deployment topology deriva-tion. For example, by combining first-fit bin-packingwith PSO, a hybrid algorithm can be created that hasa lower probability of generating invalid solutions dur-ing the evolutionary solution permutation process.

• Determining the appropriate method of integratingheuristic and evolutionary algorithms is not easy,significant experimentation is required to find a wayof integrating the two techniques that yields good re-sults. For example, preliminary experiments that weperformed that used evolutionary techniques to adjustthe relative weights of bin-packing items did not per-form nearly as well as modeling the solution space aspacking-order vectors.

• Other combinations of heuristic and evolutionaryalgorithms may provide superior results. Eachheuristic algorithm has unique problem characteristicsfor which it produces excellent results. In future work,therefore, we plan to investigate other combinationsof heuristic and evolutionary algorithms that performwell on spatial deployment optimization problems.

An implementation of the ScatterD deployment al-gorithm is available in open-source form as part ofthe Ascent Design Studio (code.google.com/p/ascent-design-studio).

References

[1] T. AlEnawy and H. Aydin. Energy-aware task allocation forrate monotonic scheduling. InProceedings of the 11thIEEE Real-time and Embedded Technology andApplications Symposium (RTAS05), pages 213–223, 2005.

[2] G. Anastasi, A. Falchi, A. Passarella, M. Conti, andE. Gregori. Performance measurements of motes sensornetworks. InProceedings of the 7th ACM internationalsymposium on Modeling, analysis and simulation ofwireless and mobile systems, pages 174–181. ACM NewYork, NY, USA, 2004.

[3] H. Aydin and Q. Yang. Energy-aware partitioning formultiprocessor real-time systems. InProceedings of 17thInternational Parallel and Distributed ProcessingSymposium (IPDPS), pages 113–121, 2003.

[4] T. Back. Evolutionary Algorithms in Theory and Practice:Evolution Strategies, Evolutionary Programming, GeneticAlgorithms. Oxford University Press, USA, 1996.

[5] M. Bastarrica, A. Shvartsman, and S. Demurjian. A BinaryInteger Programming Model for Optimal ObjectDistribution. In2nd Int. Conf. on Principles of DistributedSystems.

[6] H. Beitollahi and G. Deconinck. Fault-Tolerant PartitioningScheduling Algorithms in Real-Time Multiprocessor

Systems.Pacific Rim International Symposium onDependable Computing, IEEE, 0:296–304, 2006.

[7] L. Benini, D. Bertozzi, A. Guerri, and M. Milano.Allocation, scheduling and voltage scaling on energy awarempsocs.Lecture Notes in Computer Science, 3990:44,2006.

[8] O. Brown, P. Eremenko, and B. Hamilton. The valueproposition for fractionated space architectures.Sciences,99(1):2538–2545, 2002.

[9] A. Burchard, J. Liebeherr, Y. Oh, and S. Son. NewStrategies for Assigning Real-time Tasks to MultiprocessorSystems.IEEE Transactions on Computers,44(12):1429–1442, 1995.

[10] A. Carzaniga, A. Fuggetta, S. Richard, D. Heimbigner,A. van der Hoek, A. Wolf, and COLORADO STATE UNIVFORT COLLINS DEPT OF COMPUTER SCIENCE.ACharacterization Framework for Software DeploymentTechnologies. Defense Technical Information Center, 1998.

[11] K. Chakrabarty, S. Iyengar, H. Qi, and E. Cho. GridCoverage for Surveillance and Target Location inDistributed Sensor Networks.IEEE Transactions onComputers, pages 1448–1453, 2002.

[12] G. Chen, B. Kang, M. Kandemir, N. Vijaykrishnan,M. Irwin, and R. Chandramouli. Studying energy trade offsin offloading computation/compilation in Java-enabledmobile devices.IEEE Transactions on Parallel andDistributed Systems, pages 795–809, 2004.

[13] W. Damm, A. Votintseva, A. Metzner, B. Josko,T. Peikenkamp, and E. Bode. Boosting Re-use ofEmbedded Automotive Applications Through RichComponents.Proceedings of Foundations of InterfaceTechnologies, 2005, 2005.

[14] S. Davari and S. Dhall. An On-line Algorithm forReal-time Tasks Allocation. InIEEE Real-time SystemsSymposium, pages 194–200, 1986.

[15] S. Davari and S. Dhall. On a Periodic Real-Time TaskAllocation Problem. In19th Annual InternationalConference on System Sciences, pages 133–141, 1986.

[16] S. Dhall and C. Liu. On a Real-time Scheduling Problem.Operations Research, 26(1):127–140, 1978.

[17] R. Dick and N. Jha. MOGAC: A multiobjective geneticalgorithm for the co-synthesis of hardware-softwareembedded systems. InProceedings of the 1997 IEEE/ACMinternational conference on Computer-aided design, pages522–529. IEEE Computer Society Washington, DC, USA,1997.

[18] R. Dick and N. Jha. MOCSYN: Multiobjective core-basedsingle-chip system synthesis. InProceedings of theconference on Design, automation and test in Europe.ACM New York, NY, USA, 1999.

[19] B. Dougherty, J. White, J. Balasubramanian, C. Thompson,and D. C. Schmidt. Deployment Automation with BLITZ.In Emerging Results track at the 31st InternationalConference on Software Engineering, Vancouver, CA, May2009.

[20] L. Feeney and M. Nilsson. Investigating the energyconsumption of a wireless network interface in an ad hocnetworking environment. InIEEE INFOCOM, volume 3,pages 1548–1557. INSTITUTE OF ELECTRICALENGINEERS INC (IEEE), 2001.

[21] D. Fogel, N. Inc, and C. La Jolla. What is EvolutionaryComputation?Spectrum, IEEE, 37(2):26–28, 2000.

[22] P. Hladik, H. Cambazard, A. Deplanche, and N. Jussien.Solving a real-time allocation problem with constraintprogramming.The Journal of Systems & Software,81(1):132–149, 2008.

[23] I. Hong, D. Kirovski, G. Qu, M. Potkonjak, M. Srivastava,S. Inc, and M. View. Power optimization ofvariable-voltage core-based systems.IEEE Transactions onComputer-Aided Design of Integrated Circuits and Systems,18(12):1702–1714, 1999.

[24] J. Hooker. Planning and scheduling by logic-based bendersdecomposition.OPERATIONS RESEARCH-BALTIMORETHEN LINTHICUM-, 55(3):588, 2007.

[25] H. Hsu, J. Chen, and T. Kuo. Multiprocessor synthesis forperiodic hard real-time tasks under a given energyconstraint. InProceedings of the conference on Design,automation and test in Europe: Proceedings, pages1061–1066. European Design and Automation Association3001 Leuven, Belgium, Belgium, 2006.

[26] J. Hu and R. Marculescu. Energy-aware mapping fortile-based NoC architectures under performanceconstraints. InProceedings of the 2003 conference on AsiaSouth Pacific design automation, pages 233–239. ACMNew York, NY, USA, 2003.

[27] X. Hu and R. Eberhart. Solving Constrained NonlinearOptimization Problems with Particle Swarm Optimization.In Proceedings of the Sixth World Multiconference onSystemics, Cybernetics and Informatics, volume 5, pages203–206, 2002.

[28] T. Ishihara and H. Yasuura. Voltage scheduling problemfordynamically variable voltage processors. InProceedings ofthe 1998 international symposium on Low powerelectronics and design, pages 197–202. ACM New York,NY, USA, 1998.

[29] J. Kennedy and R. Eberhart. Particle Swarm Optimization.In Neural Networks, 1995. Proceedings., IEEEInternational Conference on, volume 4, 1995.

[30] J. Kinnebrew, N. Shankaran, G. Biswas, and D. Schmidt. ADecision-Theoretic Planner with Dynamic ComponentReconguration for Distributed Real-Time Applications. InPoster paper at the Twenty-First National Conference onArtificial Intelligence, Boston, MA, July 2006.

[31] D. Kirovski and M. Potkonjak. System-level synthesis oflow-power hard real-time systems. InProceedings of the34th annual conference on Design automation, pages697–702. ACM New York, NY, USA, 1997.

[32] J. Koza.Genetic Programming: On the Programming ofComputers by Means of Natural Selection. MIT Press,1992.

[33] J. Koza and J. Rice.Genetic Programming. Springer, 1992.[34] W. Kwon and T. Kim. Optimal voltage allocation

techniques for dynamically variable voltage processors.ACM Transactions on Embedded Computing Systems(TECS), 4(1):211–230, 2005.

[35] S. Lauzac, R. Melhem, and D. Mosse. An efficient RMSAdmission Control and its Application to MultiprocessorScheduling. InInternational Parallel ProcessingSymposium, pages 511–518, 1998.

[36] Z. Li, C. Wang, and R. Xu. Task allocation for distributedmultimedia processing on wirelesslynetworked handhelddevices. InParallel and Distributed ProcessingSymposium., Proceedings International, IPDPS 2002,Abstracts and CD-ROM, pages 79–84, 2002.

[37] A. Nechypurenko, E. Wuchner, J. White, and D. C.Schmidt. Application of Aspect-based Modeling andWeaving for Complexity Reduction in Development ofAutomotive Distributed Realtime Embedded Systems. InProceedings to the Sixth International Conference onAspect-Oriented Software Development, Vancouver, BritishColumbia, Mar. 2007.

[38] T. Okuma, T. Ishihara, and H. Yasuura. Real-time taskscheduling for a variable voltage processor. InProc.International Symposium on System Synthesis, pages24–29, 1999.

[39] B. Powell and A. Perkins. Fleet Deployment Optimizationfor Liner Shipping: An Integer Programming Model.Maritime Policy & Management, 24(2):183–192, 1997.

[40] G. Quan and X. Hu. Energy efficient fixed-priorityscheduling for real-time systems on variable voltageprocessors. InProceedings of the 38th conference onDesign automation, pages 828–833. ACM New York, NY,USA, 2001.

[41] D. Roychowdhury, I. Koren, C. Krishna, and Y. HL. Avoltage scheduling heuristic for real-time task graphs. InDependable Systems and Networks, 2003. Proceedings.2003 International Conference on, pages 741–750, 2003.

[42] Y. Shi and R. Eberhart. Empirical Study of Particle SwarmOptimization. InProceedings of the 1999 Congress onEvolutionary Computation, volume 3, pages 1948–1950.Piscataway, NJ: IEEE Service Center, 1999.

[43] D. Shin and J. Kim. Power-aware scheduling of conditionaltask graphs in real-time multiprocessor systems. InProceedings of the 2003 international symposium on Lowpower electronics and design, pages 408–413. ACM NewYork, NY, USA, 2003.

[44] D. Shin and J. Kim. Power-aware communicationoptimization for networks-on-chips with voltage scalablelinks. In Proceedings of the 2nd IEEE/ACM/IFIPinternational conference on Hardware/software codesignand system synthesis, pages 170–175. ACM New York, NY,USA, 2004.

[45] R. Simmons, D. Apfelbaum, D. Fox, R. Goldman,K. Haigh, D. Musliner, M. Pelican, and S. Thrun.Coordinated Deployment of Multiple, HeterogeneousRobots. InIntelligent Robots and Systems, 2000.(IROS2000). Proceedings. 2000 IEEE/RSJ InternationalConference on, volume 3, 2000.

[46] J. Stankovic. Strategic Directions in Real-time andEmbedded Systems.ACM Computing Surveys (CSUR),28(4):751–763, 1996.

[47] N. R. C. Steering Committee for the Decadal Survey ofCivil Aeronautics.Decadal Survey of Civil Aeronautics:Foundation for the Future. The National Academies Press,2996.

[48] K. Tindell and J. Clark. Holistic schedulability analysis fordistributed hard real-time systems.Microprocessing andMicroprogramming, 40(2):117–134, 1994.

[49] C. Wang and Z. Li. A computation offloading scheme onhandheld devices.Journal of Parallel and DistributedComputing, 64(6):740–746, 2004.

[50] C. Xian, Y. Lu, and Z. Li. Energy-aware scheduling forreal-time multiprocessor systems with uncertain taskexecution time. InProceedings of the 44th annualconference on Design automation, pages 664–669. ACMNew York, NY, USA, 2007.