Abstract In the design of electronic embedded systems,the allocation of data structures to memory banks is a mainchallenge faced by designers. Indeed, if this optimizationproblem is solved correctly, a great improvement in termsof efficiency can be obtained. In this paper, we consider thedynamic memory allocation problem, where data structureshave to be assigned to memory banks in different time periodsduring the execution of the application. We propose a GRASPto obtain high quality solutions in short computational time,as required in this type of problem. Moreover, we also explorethe adaptation of the ejection chain methodology, originallyproposed in the context of tabu search, for improved out-comes. Our experiments with real and randomly generatedinstances show the superiority of the proposed methods com-pared to the state-of-the-art method.
Communicated by E. Viedma.
M. Sevaux · A. RossiUniversité de Bretagne-Sud, Lab-STICC, CNRS Centre derecherche , B.P. 92116, 56321 Lorient Cedex, France
M. SotoUniversité de Technologie de Troyes, Troyes, France
A. DuarteDept. Ciencias de la Computación, Universidad Rey Juan Carlos,c/Tulipán s/n, 28933 Móstoles, Madrid, Spain
R. Martí (B)Dept. de Estadística e Investigación Operativa, Universidad de Valencia,c/ Dr. Moliner 50, 46100 Burjassot (Valencia), Spaine-mail: [email protected]
1 Introduction
The continuous advances in nano-technology have made pos-sible a significant development in embedded systems (suchas smartphones) to surf the Web or to process HD pic-tures. While technology offers more and more opportunities,the design of embedded systems becomes more complex.Indeed, the design of an integrated circuit, whose size is cal-culated in billions of transistors, thousands of memories, etc.,requires the use of competitive computer tools. These toolshave to solve optimization problems to ensure a low cost interms of silicium area and running time. There exist somecomputer assisted design (CAD) tools such as Gaut (Coussyet al. 2006) to generate the architecture of a circuit from itsspecifications. However, the designs produced by CAD soft-wares are generally not energy aware, which is of course amajor drawback.
In the design of embedded systems, memory allocation isamong the main challenges that electronic designers have toface. Indeed, electronics practitioners, to some extent, con-sider that minimizing power consumption is equivalent tominimizing the running time of the application to be executedby the embedded system (Chimientia et al. 2002). Moreover,the power consumption of a given application can be esti-mated using an empirical model as in Julien et al. (2003),and parallelization of data access is viewed as the main actionpoint for minimizing execution time, and consequently powerconsumption.
This paper is focused on memory allocation in embeddedsystems because of its significant impact on power consump-tion as shown by Wuytack et al. (1996). We have addressedvarious simpler versions of the memory allocation problem:in Soto et al. (2011), we have proposed a mixed linear formu-lation and a variable neighborhood search algorithm for thestatic version, and studied an even more simplified version
of this problem in Soto et al. (2010). We have also dealt withthe dynamic memory allocation problem in Soto et al. (2011)for which an integer linear formulation and two iterativeapproaches have been devised. Note that the term dynamicrefers to the nature of the electronic design problem, but dataare all known before the execution of the solution method. Inthis paper, we propose a GRASP with ejection chains for thedynamic memory allocation problem in embedded systemsand compare it with the previous iterative approaches.
The considered memory architecture is similar to the oneof a TI C6201 device Julien et al. (2003). It is composedof m memory banks whose capacity is c j kilo Bytes (kB)for all j ∈ {1, . . . , m} and an external memory denoted bym + 1, which does not have a practical capacity limit. Theprocessor needs q milliseconds for accessing data structureslocated in a memory bank, and it spends q times more (i.e.,p × q milliseconds) when data structures are in the externalmemory.
Time horizon is split into T time intervals whose dura-tions may be different. The application to be implemented isassumed to be given as C source code, whose n data structures(i.e. variables, arrays, structures) have to be loaded in mem-ory banks or the external memory. The size of data structuresi for i ∈ {1, . . . , n} is expressed in kB. During each timeinterval t , the application requires accessing a given subsetAt of its data structures. We denote with a pair (a, b) whendata structures a and b are simultaneously accessed. The setDt contains all these pairs in time period t .
The combinatorial nature of this problem comes from thefact that the processor can access all the memory banks simul-taneously. For example, given a specific time interval, to com-pute a +b we may access a and b simultaneously. If they areallocated to different memory banks, we can access both ofthem at the same time, with the associated time saving, butif they are allocated to the same memory bank, we have toperform two different accesses. Thus, the cost of accessingsimultaneously data structures a and b is d(a,b), and if theyare allocated to the same memory bank, the total access costis 2 × d(a,b), i.e., accessing sequentially a and b. However,if a or b are allocated to the external memory, the cost isp × d(a,b), and if both are allocated to the external memorythe cost is 2 × p × d(a,b). Note that when we perform anoperation such as a = a + 1, the accessing cost can be either2×d(a,a) or 2× p×d(a,a) depending whether a is in a mem-ory bank or the external memory. Finally, a data structure canbe accessed in isolation (i.e., not in a pair) when for example,we perform the operation a = 5, then its cost is d(a,0) if itis in a memory bank, and p × d(a,0) if it is in the externalmemory.
If we want to take into account the dynamic structure of theproblem, the cost of changing a data structure between mem-ory banks or with the external memory from the previous timeinterval to the current one is related to its size. In particular,
Table 1 Costs to evaluate a solution in a specific time interval
Type Value Description
Access d(a,b) if a and b are in different memory banks
2× d(a,b) if a and b are in the same memory bank
p × d(a,b) if a or b is in the external memory
2p × d(a,b) if a and b are in the external memory
Change ℓ× sa a changed between memory banks
v × sa a changed between a memory bankand the external memory
if data structure a is in a memory bank at time interval t − 1and in a different memory bank at time interval t we have acost of ℓ × sa where ℓ is the duration of this physical movein milliseconds per kilo Bytes (ms/kB) and sa is the size ofthe data structure a. Alternatively, if we change the allocationof a data structure between a memory bank and the externalmemory, the cost is v × sa where now the factor is givenby v ms/kB. The later cost is particularly relevant becauseof hardware requirements. All the data structures are initially(say in t = 0) allocated to the external memory and thereforewe assume this as initial solution for each data structure allo-cated to a memory bank in t = 1. We assume that v ≥ ℓ andv < p because a Direct Memory Access controller is sup-posed to be part of the memory architecture, which allowsfor a direct access to data structures. Table 1 summarizes allthe costs described above for a specific time interval.
This paper is organized as follows. Section 2 shows how torepresent a solution and evaluate it on an illustrative example.Sections 3 and 4 present, respectively, the GRASP and theejection chains methods. The proposed method is first tunedin our preliminary experimentation and then compared to pre-vious iterative approaches in Sect. 5. Finally, Sect. 6 presentsconclusions and future work for this problem.
2 Step by step example
For the sake of illustration, this section presents a detailedcomputation of the cost of a solution. From now, we representa solution x as a matrix with data structures in rows andtime intervals in columns. Thus, given a data structure i in{1, . . . , n}, and a time interval t in {1, . . . , T }, x(i, t) = jwith j in {1, . . . , m + 1} indicates that data structure i isallocated to memory bank j at time period t .
Consider an example in which we have to allocaten = 12 data structures in m = 3 memory banks andthe external memory, with T = 4 time periods. Addi-tionally, consider that the size of the data structures isgiven by {65, 18, 95, 88, 99, 12, 19, 81, 10, 4, 79, 80} andeach memory bank has a capacity of 111 kB. Then, a feasiblesolution x is given by the following (12, 4)-matrix
As mentioned above, the entries in the matrix indicate theindexes of the memory banks (where 4 refers to the exter-nal memory). For example, in row 4, column 1, we havex(4, 1) = 2 which means that data structure 4 is allocatedto memory bank 2 at time interval 1. If we consider the datastructures at the same time interval (a column of the matrix)that are assigned to the same memory bank, we can see thatthe sum of their sizes do not exceed the capacity of this bank.For example, in the second column, we can see that mem-ory bank 1 appears in rows 6, 7, and 12 (i.e. x(6, 2) = 1,x(7, 2) = 1, and x(12, 2) = 1). If we sum the sizes of thesedata structures, we obtain s6 + s7 + s12 = 12 + 19 + 80 =111, which is exactly the capacity of memory bank 2. It iseasy to check that solution x verifies the capacity constraintsof the three memory banks in the four time periods. Figure 1illustrates the first two time periods (t = 1 and t = 2) of thissolution in a diagram, in which memory banks appear as ver-tical boxes, labeled as MB1, MB2 and MB3 respectively, andthe external memory as a rectangular horizontal box labeledas MB4.
Consider now that in the first time period we have to accessthe data structures A1 = {1, 2, 3, 4, 7, 9} with six pairsaccessed simultaneously: D1 = {(1, 2), (1, 3), (1, 4), (1, 7),
(2, 3) (2, 9)}, with associated costs: 62, 68, 37, 83, 18, and33. To compute the total cost associated with the first timeperiod, we note in Fig. 1 that data structures 1 and 2 arein different memory banks (data structure 1 is in MB1 and
Fig. 1 Example
data structure 2 is in MB2), therefore we consider their accesscost of 62. Similarly for pairs (1,3), (1,4), (2,3), and (2,9)since their data structures are in different memory banks. Onthe contrary, the cost of pair (1,7) is 2 × d(1,7) since datastructures 1 and 7 are both in MB1. The total access cost istherefore 62 + 68 + 37 + 2 × 83 + 18 + 33 = 384. Tocomplete the cost computation at time period t = 1, wehave to consider that initially (i.e., at t = 0), the n = 12data structures are in the external memory and therefore,the data structures in the three memory banks, 1, 2, 3,4, 6, 7, 9, and 10, have an associated cost of change ofv × (65 + 18 + 95 + 88 + 12 + 19 + 10 + 4) = 311v.Therefore, the total cost at t = 1 is 384 + 311v.
Similarly, we compute the cost of period t = 2, consider-ing that A2 = {2, 3, 4, 5, 6, 10, 11, 12} and the following fivepairs are accessed simultaneously: D2 = {(2, 10), (3, 11),
(3, 12), (4, 5), (4, 6)}, with associated costs: 99, 45, 71, 17,and 98. To calculate the access cost in this time interval, wehave to consider that data structure 4 is allocated to MB2 butdata structure 5 is allocated to the external memory (as indi-cated with an arrow in Fig. 1), and therefore the cost of pair(4,5) is p×d(4,5) = 17p. Similarly with pair (3,11) given thatdata structure 11 is in the external memory. Therefore the totalaccess cost is now 99 + 45p + 71 + 17p + 98 = 268 + 62p.The cost of change computed at t = 2 accounts for the factthat data structure 1 is in the external memory (indicated witha circle in Fig. 1), and it is in MB1 at t = 1. This has an asso-ciated cost of v × s1 = 65v. Similarly, data structure 12 isallocated to the external memory at time t = 1, and to MB1 attime t = 2 (highlighted with a circle in the figure). Thereforethe cost is v × s12 = 80v. Then, the total cost generated attime period 2 is 268 + 62p + 145v.
3 GRASP
The GRASP metaheuristic was developed in the late 1980s(Feo and Resende 1989). Each GRASP iteration consistsin constructing a trial solution with some greedy random-ized procedure and then applying local search from the con-structed solution. This two-phase process is repeated untilsome stopping condition is satisfied. The best local optimumfound over all local searches is returned as the solution ofthe heuristic. Some successful and recent applications of thismethodology can be fond in Duarte et al. (2011) or Resendeet al. (2010). We refer the reader to Resende and Ribeiro(2010) for recent surveys of this metaheuristic.
Algorithm 1 shows the pseudo-code for a generic GRASPfor minimization. The greedy randomized construction seeksto produce a diverse set of good-quality starting solutionsfrom which to start the local search phase. Let x be the par-tial solution under construction in a given iteration and let Cbe the candidate set with all the remaining data structures that
Algorithm 1: GRASP algorithm1 f ∗ ← ∞2 while stopping criterion not satisfied do3 x ← ∅4 Compute C with the candidate data structures that can be
added to x5 while C ̸= ∅ do6 forall the c ∈ C do7 compute g(c), gmin = minc∈C g(c) and
gmax = maxc∈C g(c)
8 Define RCL← {c ∈ C | g(c) ≤ gmin + α(gmax − gmin)}with α ∈ [0, 1]
9 Select c∗ at random from RCL(C)10 Add c∗ to partial solution: x ← x ∪ {c∗}11 Update C with the candidate data structures that can be
added to x
12 x ← LocalSearch(x)13 if f (x) < f (x∗) then14 x∗ ← x ; f ∗ ← f (x)
15 return x∗
can be added to x . The GRASP construction uses a greedyfunction g(c) to measure the contribution of each candidatedata structure c ∈ C to the partial solution x . A restrictedcandidate list RC L is the subset of candidate data structuresfrom C with good evaluations according to g. In particular,if gmin and gmax are the minimum and maximum evalua-tions of g in C respectively, then RC L = {c ∈ C | g(c) ≤gmin + α(gmax − gmin)}, where α is a number in [0, 1]. Ateach step, the method randomly selects a data structure c∗
from the restricted candidate list and adds this data structureto the partial solution. The construction is repeated in theinner while loop (steps 4–10) until there are no further can-didates. If C = ∅ and x is infeasible, then a repair procedureneeds to be applied to make x feasible (steps 12–14). Once afeasible solution x is available, a local search improvementis applied. The resulting solution is a local minimum. TheGRASP algorithm terminates when a stopping criterion ismet (typically a maximum number of iterations, time limit,or a target solution quality). The best overall solution x∗ isreturned as the output of the heuristic.
3.1 Constructive methods
To construct a solution we have to allocate the data structures,one by one, to the memory banks or the external memory ineach time period. In this section we propose two differentapproaches; the first one sequentially constructs a solutionstarting with time period t = 1 and moving to next timeperiod once the allocation of all data structures in the currentone is completed. On the other hand, the second construc-tive method gives priority to the allocation of data structuresthat might generate the largest cost, regardless of their timeperiod.
3.1.1 Sequential approach
In the sequential approach, SEQ, we first complete the assign-ments in a period and then we start the assignments in thenext one. From the costs in Table 1, it is clear that the bestoption for a pair of data structures is to be allocated to dif-ferent memory banks; however, they have a limited capacityand some data structures have to be eventually allocated tothe same bank or in the external memory.
Consider a partial solution in which we have assigned thedata structures to the memory banks in time periods 1 to t−1and we have already assigned some of the data structuresin period t . Let Ct be the candidate set of unassigned datastructures at time period t . To determine the data structureand memory bank for the next assignment in our construc-tion process, we compute for each data structure i ∈ Ct itsevaluation g(i, t, j) to any possible memory bank j , or to theexternal memory (for which j = m + 1).
To compute g(i, t, j), we consider two types of costs. Thefirst one is the cost related to the access to data structure i inthe memory bank j at time interval t . This cost is denoted bytotal_access(i, t, j) and defined by:
total_access(i, t, j) =|Ni,t |∑
k=1
access( j, x(ak, t), d(i,ak ),t )
(1)
where Ni,t is the set of data structures which are in conflictwith data structure i at time interval t , thus ak ∈ Ni,t . Twodata structures i and ak are said to be in conflict at timeperiod t if (i, ak) ∈ Dt . Function access( j1, j2, d) definedin Eq. (2) computes the access cost produced by a conflictwhose cost is d and where its corresponding data structuresare allocated to memory banks j1 and j2 respectively. Thusaccess( j, x(ak, t), d(i,ak ),t ) is the access cost generated byconflict (i, ak) at time interval t where data structure i isallocated to memory bank j and x(ak, t) ∈ {1, . . . , m + 1}is the memory bank where ak is allocated.
The other cost involved in the evaluation function g(i, t, j)is the cost related to the change of a data structure betweenmemory banks or between the external memory and a mem-ory bank in consecutive time intervals. It is computed asfollows:
123
GRASP with ejection chains for the dynamic memory 1519
change(i, j1, j2)=
⎧⎪⎪⎨
⎪⎪⎩
0, if j1 = j2ℓ× si , if j1 ̸= j2 and jk ̸=
m+1,∀k = 1, 2v × si , otherwise
(3)
Thus, the evaluation function g(i, t, j) is given by:
when the data structure i is not accessed during time periodt , we have to consider the cost of change from the alloca-tion in time interval t − 1, x(i, t − 1), and its trial allo-cation in t . Thus, the evaluation function is g(i, t, j) =change(i, x(i, t − 1), j) for all i /∈ At .
Equation (4) computes the increment in the cost of thecurrent partial solution under construction, if data structurei ∈ At is assigned to a memory bank or to the external mem-ory. However, feasible assignments only are considered; i.e.,those for which data structure i can be added to a memorybank without exceeding its capacity. Once all feasible assign-ments have been evaluated, we compute the minimum andmaximum of those values as:
gmin(t) = mini∈Ct
{g(i, t, j) ∀ j ∈ {1, . . . , m + 1}}
gmax(t) = maxi∈Ct
{g(i, t, j) ∀ j ∈ {1, . . . , m + 1}}
Then, as shown in Algorithm 1, we compute the restrictedcandidate list RC L(t) with the pairs of data structures inconflict and memory banks for which the evaluation is withinthe customary GRASP limits. Specifically,
RC L(t) = {(i, j) : i ∈ Ct and g(i, t, j)
≤ gmin(t) + α(gmax(t)− gmin(t))},where α is a number in [0, 1]. At each step, the method ran-domly selects a pair (i, j) from the restricted candidate listand performs the associated assignment (i.e., it assigns i to jat time interval t). The constructive algorithm, called SEQ,terminates when all the data structures have been assigned,for all the time periods.
3.1.2 Conflict priority approach
Our second constructive method, CPA, has two stages. Inthe first one we allocate the pairs of data structures from Dtfor any time period t , and in the second one we allocate theremaining elements not in At for any time period t .
In the first stage we define D as the ordered set of pairsin
⋃Tt=1 Dt in decreasing values of the cost d(a,b),t . The
restricted candidate list RCL is here simply computed as afraction of the pairs in D. Specifically, we consider a per-centage α of the largest elements in D. We then select onepair (a⋆, b⋆) in RCL at random and allocate its elements intheir time period t . To do that, we compute g(a⋆, t, j) and
g(b⋆, t, j) ∀ j ∈ {1, . . . , m + 1} and perform the best alloca-tion. Once a pair has been allocated, it is removed from D.This operation is repeated as long as D ̸= ∅. Note that theconstruction of the restricted candidate list does not followthe conventional adaptive scheme. In other words, the d(a,b),tvalues do not change from one construction step to the next.However, note also that finding the best allocation for theselected pair involves the computation of an adaptive valuesince g(i, t, j) depends on the previous assignments.
In the second stage we allocate the remaining elements(i.e., those not present in the pairs). As previously defined,let Ct be the candidate set of unassigned data structures attime period t . We define C as the ordered set of pairs (i, t)in
⋃Tt=1 Ct in decreasing values of the size si . As in the
first stage, RCL contains a fraction α of the largest elements,from which we select one pair (a⋆, t) at random. Finally, weallocate a⋆ in time t in the best memory bank according tog(i, t, j) and update C . The method finishes when all theelements in C have been allocated.
The randomized nature of the constructive process permitsto generate different solutions in each construction. We haveempirically found that in some instances the allocation ofall the elements in the external memory banks produces atrivial solution with a relatively good value. Therefore, wehave included this trivial solution as the first construction ofthis method.
3.2 Local search
Since there is no guarantee that a randomized greedy solutionis optimal, local search is usually applied after each construc-tion step to attempt to find a local optimal solution, or at leastto obtain an improved solution with smaller cost than that ofthe constructed solution. This idea originates in the seminalpaper by Feo and Resende (1989) for set covering and waslater referred to as GRASP (Feo and Resende 1995).
Given a feasible solution x of a combinatorial optimiza-tion problem, we define a neighborhood N (x) of x to consistof all feasible solutions that can be obtained by making apredefined modification to x . We say a solution x∗ is locallyoptimal if f (x∗) ≤ f (x) for all x ∈ N (x∗), where f isthe objective function that we are minimizing. Given a feasi-ble solution, a local search procedure finds a locally optimalsolution by exploring a sequence of neighborhoods, startingfrom it. At the i-th iteration it explores the neighborhood ofsolution xi . If there exists some solution y ∈ N (xi ) suchthat f (y) < f (xi ), it sets xi+1 = y and proceeds to itera-tion i + 1. Otherwise, x∗ = xi is declared a locally optimalsolution and the procedure stops.
Insertions are used as the primary mechanism to movefrom a solution to another in the local search for the memoryallocation problem. Specifically, given a solution x and a datastructure i allocated to memory bank j at time period t (i.e.,
x(i, t) = j), we define move(i, t, j ′) as the removal of ifrom its current memory bank j , followed by its insertion inmemory bank j ′ at time period t . This operation results inthe solution y, as follows:
y(i, t) = j ′
y(i, t) = x(i, t) for t ̸= t ′
y(i ′, t) = x(i ′, t) for i ′ ̸= i and for all t
Given a solution x and a data structure i in memory bank jat time period t , we define h(i, t, j) as its contribution to thesolution value. If data structure i is accessed in one or morepairs in t , it can be computed as:
This expression is similar to (4) in which we compute the costfor accessing data structure i in the memory bank j to executethe operation at time interval t . The second and third terms in(5) compute respectively the cost of change of i from periodt−1 to t and from t to t +1. The later term was not involvedin (4) since we computed there the cost of a partial solutionunder construction in which no data structure was assignedto period t + 1 at that stage. Therefore, h(i, t, j) sums allthe costs generated with the assignment of data structure i in{1, . . . , n} to its current location j in {1, . . . , m + 1} at timeinterval t in {1, . . . , T }.
Considering that we have n data structures at a given timeperiod t (where we start with t = 1), there are n possiblecandidates for an insertion move. In other words, we canconsider an allocation change for any data structure in thistime period for improving the solution. However, instead ofenumerating all these possibilities (i.e. scanning the entireneighborhood of the solution), we implement the so-calledfirst strategy, in which we perform the first insertion movethat improves the solution. In order to study first those datastructures that are more likely to provide improving moves,our local search method first computes the contribution of allthe data structures in a time period and orders them accordingto these values. Then, it scans the data structures in this order,where the data structure with the largest contribution comesfirst. As a result, it first explores those data structures witha large contribution since we can consider them as “badlyallocated” and tries to re-allocate them in a different, andbetter, memory bank.
Algorithm 2 shows the main steps of the local searchmethod. In line 1, the time period t is initialized to 1. In line 4,we order the elements in conflict (accessed simultaneously)in time period t, At , according to their contribution. Once weselect a data structure i ∈ At allocated to memory bank j attime period t , we compute h(i, t, j ′) for all memory banks.In line 6, we select the best memory bank j⋆. If j⋆ ̸= j (line8), which indicates that h(i, t, j⋆) < h(i, t, j), we move (in
Algorithm 2: Local search1 t ← 12 while t ≤ T do3 improved ←false4 At ← Sort Elements I nCon f licts(t)5 forall the i ∈ At do6 j⋆ ← arg min
1≤ j ′≤mh(i, t, j ′)
7 j ← Current Memor y Bank(i)8 if j ̸= j⋆ then9 move(i, t, j⋆)
10 improved ←true
11 if improved = true and t ̸= 1 then12 t ← t − 1
13 else14 t ← t + 1
line 9) data structure i from memory bank j to j⋆ if there isroom in bank j⋆, since it results in a reduction of the solutionvalue. Specifically, we perform move(i, t, j⋆) and the valueof the solution is reduced by h(i, t, j) − h(i, t, j⋆). Oncewe have explored the possible assignments of data structurei to a different memory bank, and eventually moved it, weresort to the next data structure in the ordered list to studyits associated moves. When we explore all the data struc-tures with a positive contribution, we stop the scan of thecandidate list (there is no point in moving data structureswith a null contribution). At this stage, we set t = t − 1 ift > 1 in line 12 and explore the previous time period. Therational behind this strategy is to perform a backward step tore-allocate the elements linked with those recently moved inthe current time period. Alternatively, if we have not foundany improvement move in t , we set t = t + 1 in line 14, andapply the improvement method in the next time period. Inany case, we compute the contribution of the data structuresand proceed in the same fashion. The local search LS termi-nates when no data structure is moved after scanning all thetime periods. It returns the associated local optimum.
4 Ejection chains
Consider the example in Sect. 2 in which we have to allo-cate n = 12 data structures in m = 3 memory banks andthe external memory, in T = 4 time periods. We apply thegreedy randomized constructive method to this instance withparameter values q = 1, p = 16, ℓ = 1 and v = 4, andwe obtain a solution with a value of 15,692. Now we applyour local search method based on insertions to improve thistrial solution, and we observe that the data structure withthe largest contribution is data structure 6, allocated to theexternal memory (with index 4) at time period t = 3. Figure2 shows a representation of the allocation of the data struc-
123
GRASP with ejection chains for the dynamic memory 1521
Fig. 2 Memory banks at t = 3
tures in memory banks at this time period. Data structure 6has a contribution value of h(6, 3, 4) = 2,384, and the localsearch computes its alternative assignments at time period 3:h(6, 3, 1) = 533, h(6, 3, 2) = 622, and h(6, 3, 3) = 545,which are significantly lower than the value of its currentassignment. Since there is room in memory bank 1 for datastructure 6, we perform the move, insert(6, 3, 1) and obtaina new solution with value 15,692− 2,384 + 533 = 13,841.We now resort to the next data structure in the ordered listaccording to their contribution. It is data structure 4 allo-cated to the external memory (with index 4) at t = 3 and acontribution to the solution value of h(4, 3, 4) = 1,424. Wewould move this data structure to memory bank 1 consideringthat its associated contribution is h(4, 3, 1) = 793; however,there is no room in memory bank 1 for this data structure (ithas a remaining capacity of 34 units and this data structurehas a size of 88). As a matter of fact, we cannot move thisdata structure to any other memory bank due to the associ-ated evaluation or the size constraints. We therefore resort tothe next data structure in the list and continue in this fashion.
The previous example illustrates that some insertions can-not be performed because there is no room in the destinationmemory bank. This suggests that we could consider to makeroom there by moving one of its data structures elsewhere,implementing what is known in local search as a compoundmove or ejection chain. Glover and Laguna (1997) intro-duced compound moves, often called variable depth meth-ods, constructed from a series of simpler components. As it iswell-known, one of the pioneering contributions to this kindof moves was Lin and Kernighan (1973). Within the classof variable depth procedures, a special subclass called ejec-tion chain procedures has recently been proved useful. Anejection chain EC is an embedded neighborhood construc-tion that compounds the neighborhoods of simple moves tocreate more complex and powerful moves. It is initiated byselecting a set of data structures to undergo a change of state(e.g., to occupy new positions or receive new values). Theresult of this change leads to identifying a collection of othersets, with the property that the data structures of at leastone must be “ejected from” their current states. State-change
steps and ejection steps typically alternate, and the optionsfor each depends on the cumulative effect of previous steps(it is usually impacted by the latest step). In some cases, acascading sequence of operations may be triggered, repre-senting a domino effect. Successful applications of this strat-egy can be found in Lozano et al. (2012); Martí et al. (2009,2011).
In the memory allocation problem, when data structurei in memory bank j at time period t has a relatively largecontribution to the objective function, the local search selectsit to evaluate its insertion in a different memory bank, say j ′,in order to reduce this contribution. In some cases however,this move is not feasible because j ′ does not have enoughcapacity for i (i.e. because the difference between its capacityand the sum of the sizes of the data structures in j ′ is lowerthan the size of this data structure). The EC local search thenconsiders to move one of the data structures in j ′, say i ′, toanother memory bank on time period t , say j ′′, to make roomin j ′ for i . We may say that the insertion of i in j ′ caused i ′ tobe ejected to j ′′, or, in other words, that we apply the ejectionchain move(i, t, j ′)+move(i ′, t, j ′′) of depth 2. Clearly, thebenefit of moving a data structure in j ′′ to another memorybank, say j ′′′, could also be evaluated if one would like toconsider chains of depth three. Longer chains are possible byapplying the same logic.
In EC, we define chain(i, dplimit) as the ejection chainthat starts from moving vertex i and performs a maximumof dplimit consecutive insertion moves. Once a data struc-ture i with a relatively large contribution at time period t isidentified, EC starts by scanning alternative memory banks,in a random order, to allocate it. The chain then starts bymaking chain(i, dplimit) = {move(i, t, j ′)} where j ′ isthe first alternative memory bank considered. If this depth-1move is improving and feasible (there is room in j ′ for i),it is executed and the chain stops. Otherwise, we search formove(i ′, t, j ′′) associated with a data structure i ′ in j ′. Ifthe compound move of depth-2 is an improving and feasiblemove (there is room in j ′ for i and in j ′′ for i ′), the moveis executed and the chain stops; otherwise the chain contin-ues until the compound move becomes improving and feasi-ble or the depth of the chain reaches the pre-specified limitdplimit . If none of the compound moves from depth-1 todplimit examined is an improving and feasible move, alter-native memory banks (values of j and j ′) and data structures(values for i ′ and associated trial data structures) are consid-ered in a recursive exploration. If none of them is improvingand feasible, no move is performed and the exploration con-tinues with the next i data structure in the candidate list.
Algorithm 3 shows the pseudo-code of the EC method.It starts by setting t = 1 at line 1. Then, at line 4, it ordersdata structures i in Dt according to their contribution. Line6 sets the depth parameter d to 1, and defines at line 7 anauxiliary variable, ieject , with the element to be moved (ini-
Algorithm 3: Ejection chain1 t ← 12 while t ≤ T do3 improved ←false4 Dt ← SortElementsInConflicts(t)5 forall the i ∈ C do6 d ← 17 ieject ← i8 impEC ←false9 while (d ≤ dplimit) and impEC =false do
10 j⋆ ← arg min j∈M B h′(ieject , t, j)11 j ←CurrentMemoryBank(ieject )12 if j ̸= j⋆ then13 S←EjectedElements(ieject , t, j⋆)14 if S = ∅ then15 impEC ←true16 improved ←true
17 else18 d ← d + 119 ieject ← arg max
k∈Sh′(k, t, j⋆)
20 if improved = true and t ̸= 1 then21 t ← t − 1
22 else23 t ← t + 1
tially equal to i). The while loop at line 9 allows the methodto perform ejection chain steps as long as it improves, or themaximum depth limit, dplimit is reached. The best memorybank j⋆ to move ieject , including those banks with no roomfor it, is identified in line 10. The move move(ieject , t, j⋆)is performed at line 13 and the method computes the set Swith all the elements in memory bank j⋆ that create enoughroom to allocate ieject when removing them from j⋆. Thevariables are then updated, including the ieject , which nowis the best element in S in terms of its contribution (line 19).Lines 20–23 apply the same logic to scan the time periodsdescribed in the LS method.
EC is a local optimizer and hence it performs only improv-ing chains, although it is worth mentioning that these chainsare compound of several insertion moves, and all of them areimproving moves. Although the general design of the com-pound moves permits the implementation of non-improvingsingle moves, for the sake of reducing the CPU time, werestrict ourselves to improving moves.
5 Computational results
In this section, we first perform some preliminary experi-ments to set the appropriate search parameters and to com-pare our different methods. Then, we compare our best vari-ant with the iterative approaches and ILP formulation in Sotoet al. (2011), which are considered the state of the art and the
only methods when solving the Dynamic Memory Alloca-tion Problem. All algorithms have been implemented in JavaSE 6 and run on an Intel Core i7 2600 CPU at 3.4 GHz with3 GB RAM.
We have tested our metaheuristics using 45 real and arti-ficial instances previously reported in Soto et al. (2011).Real instances originate from electronic design problemsaddressed in the Lab-STICC laboratory. Artificial instancesoriginate from DIMACS (Porumbel 2009) and they havebeen enriched by randomly generating conflict costs, num-ber and capacity of memory banks, sizes and number ofaccess to data structures. Artificially large instances allowus to assess our metaheuristics for the practical use for forth-coming needs, as technology tends to integrate more andmore functionalities in embedded systems. In line with pre-vious studies, the problem parameters are set as in the realelectronic applications. The time q spent by the processor toaccess data structures to memory banks is set to 1 ms, thefactor p to access data structures to external memory is set to16, as with TI C6201. The cost v for moving a data structurefrom the external memory to memory banks and vice versais set to 4 ms/kB and cost for moving data structures betweenmemory banks is equal to 1 ms/kB.
Table 2 shows the main features of the instances: name,number of data structures (n), number of conflicts (D), mem-ory banks (M), and time intervals (T ). Instances are sortedby non decreasing sizes (by considering first the number ofdata structures and then the number of conflicts). This order-ing gives a rough estimation about the hardness of solvinga specific instance. All these instances can be downloadedfrom http://www.optsicom.es/dmap/dmap.zip.
We perform our preliminary experimentation with 8 rep-resentative instances with different sizes and characteris-tics. They are: fpsol2i2dy, mpeg2enc2dy, mug100-25dy,myciel7dy, queen5-5dy, r125.1cdy, treillisdy, and zeroin-i1dy. In the first experiment we compare the two construc-tive methods described in Sect. 3.1, SEQ and CPA. Table 3shows, for each variant, the average objective function value(Value), the average percent deviation from the best solutionsobtained within this experiment (Dev. Exp.), and the num-ber of instances (Best) in which the method is able to matchthe best solutions obtained within this experiment (out of8 instances). These measures are local in the sense that thebest solutions are those found within the experiment. Theyare used because they allow us to discriminate among theprocedures being tested and identify the better alternatives.However, as a point of reference, Table 3 also includes theaverage deviation achieved by each variant against the best-known solutions (Dev. BK.). This is a global measure in thesense that the best-known solutions are those found across allexperiments in this paper, which as far as we know representsthe best-known published solutions. Finally, the last row ofthe table summarizes the information, reporting the average
Value, CPU, Dev. Exp., Dev. BK., and the sum of the Bestvalues.
Table 3 shows that constructive method CPA clearly out-performs the sequential method, SEQ. Specifically, CPApresents an average deviation with respect to the best solutionfound in the experiment and with respect to the best knownsolution of 0.04 and 111.89 %, respectively, obtained in19.4 s, which compares favorably with the average deviationof 3.08 and 118.86 % obtained with SEQ in 18.7 s. Moreover,CPA is able to obtain seven best solutions in this experimentwhile SEQ obtains three out of the eight considered instances.
In our second experiment, we compare the two completeGRASPs formed by the constructive methods coupled withthe local search. We denote them as CPA+LS and SEQ+LS.Table 4 shows for each method and each of the eight instancesconsidered, the value of the best solution found across tenconstructions with local search, Value, as well as the otherfour statistics described above: CPU, Dev.Exp., Dev. BK, andBest.
Table 4 shows that the CPA+LS method obtains betterresults than the SEQ+LS in shorter running times. In par-ticular CPA+LS presents an average percent deviation of
123
1524 M. Sevaux et al.
Table 4 GRASP methods
Instances SEQ+LS CPA+LS
Name Value CPU Dev.Exp. (%) Dev. BK. (%) Best Value CPU Dev.Exp. (%) Dev. BK. (%) Best
Table 5 GRASP with ejectionchains Method Value CPU Dev.Exp. (%) Dev.BK (%) Best
GRASP(10)+EC(2) 655,395.44 90.5 8.47 17.27 3
GRASP(10)+EC(3) 655,009.06 100.25 8.44 17.25 4
GRASP(10)+EC(4) 654,848.31 95.625 8.44 17.24 5
GRASP(10)+EC(5) 654,848.31 93.375 8.44 17.24 5
GRASP(10) 911,946.14 28.25 33.84 45.81 0
GRASP(100) 868,135.70 219.75 27.88 39.67 2
4.61 % (Dev. Exp.) and 38.66 % (Dev. BK.) obtained in11.1 s, while SEQ+LS exhibits an average of 21.18 % (Dev.Exp.) and 50.96 % (Dev. BK.) obtained in 21.18 s. Addi-tionally, CPA+LS matches six best solutions in this experi-ment while SEQ+LS obtains two out of the eight instancesconsidered. This experiment confirms again the superiorityof CPA over the SEQ algorithm. Therefore, in the follow-ing experiments we considered the CPA+LS as the GRASPmethod.
In our final preliminary experiment, we compare the con-tribution of the ejection chain post-processing (EC) andthe influence of the depth limit parameter, dplimit , in thismethod. Table 5 reports the average results of value, CPU,Dev.Exp, Dev. BK, and the number of best solutions foundwith the GRASP (CPA+LS) runs for 10 and 100 iterationsand the same GRASP method run for 10 iterations in whichwe apply the EC(dplimit) post-processing, with a givenvalue of the depth parameter, after the application of the LS.We have tested the values 2, 3, 4, and 5 for the depth limitparameter.
Results in Table 5 indicate that the ejection chain post-processing (EC) significantly improves the GRASP method.Specifically, comparing GRASP(10) with GRASP(10)+EC(4) it is clear that EC drastically reduces the GRASPdeviation (GRASP(10) exhibits an average Dev. BK. of45.81 % while GRASP(10)+EC(4) is able to drop this valueto 17.24 %). However, the EC post-processing has an asso-
ciated running time and therefore the total running time ofGRASP(10)+EC(4) is, as expected, larger than GRASP(10).This is why we include in this table GRASP(100) to showthat even if we run GRASP for a longer running time thanGRASP+EC, it is not able to reach by itself the high qualitysolutions obtained with the combination of both methods.In particular, GRASP(100) obtains an average Dev. BK. of39.67 % in 219.75 s while GRASP(10)+EC(4) only needs95.62 s to obtain a Dev. BK. of 17.24 %. On the other hand,comparing the results obtained with GRASP+EC with dif-ferent values of the dplimit , we observe small differenceswith a slight improvement in the number of best solutionsfound when it is equal to 4 or 5.
In our final experiment, we compare our best algorithms,CPA, GRASP and GRASP+EC with the iterative metaheuris-tic (IM), proposed in Soto et al. (2011), which is the bestpublished method so far. The objective of this experiment istwo-fold. On the one hand, to compare our proposals withthe state-of-the-art method, and on the other hand, to experi-mentally test that the inclusion of more elaborated strategiesdrive us to better outcomes when executing all the methodsfor the same computing time. Table 6 summarizes the resultsof this experiment over the entire set of instances. The indi-vidual results of each method and each instance can be foundin Table 7 in the Appendix.
Table 6 reports the average value of the objective function,the CPU time in seconds, the deviation value with respect to
123
GRASP with ejection chains for the dynamic memory 1525
Table 6 Final comparison
Method Value CPU Dev.BK (%) Best
IM 1,378,609.24 300.72 62.66 14
CPA 1,375,151.61 300.48 461.34 3
GRASP 1,110,087.76 300.45 20.12 9
GRASP+EC 1,060,597.74 130.55 6.30 21
the best known value, and the number of instances in whichthe method is able to match the best known solution (Best). Inorder to have a fair comparison, IM, CPA, and GRASP wereexecuted for the same computing time on each instance (withan average computing time of about 300 s). GRASP+ECwas executed for shorter running times (about 130 s) sincethis method requires less time to obtain higher quality solu-tions.
Results in Table 6 clearly indicate the superiority ofGRASP and GRASP+EC with respect to the previous methodIM. In particular, GRASP presents an average percentagedeviation of 20.12 % and 9 best solutions, GRASP+EC6.30 % and 21 best solutions, while the previous IM methodpresents an average percentage deviation of 62.66 % and 14best solutions on average. Finally, the CPA method obtains,as expected, low quality solutions which indicates that sim-ple approaches do not work well on this difficult problem. Itis worth mentioning that if we run IM, CPA or GRASP forshorter running times they obtain lower quality solutions thanthose reported in this table; on the contrary, the combinationof GRASP with EC is able to obtain very good solutions(the best known in most of the cases) in significantly shorterrunning times, requiring less than half of their CPU time.
We applied the non-parametric Friedman test for multi-ple correlated samples to the best solutions obtained by eachof the four methods. This test computes, for each instance,the rank value of each method according to solution quality(where rank 1 is assigned to the best method and rank 4 to theworst one). Then, it calculates the average rank values of eachmethod across all the instances solved. If the averages differgreatly, the associated p-value or significance will be small.The resulting p-value of 0.000 obtained in this experimentclearly indicates that there are statistically significant differ-ences among the methods tested. Specifically, the rank valuesproduced by this test are 1.82 (GRASP+EC), 2.15 (GRASP),2.59 (IMA), and 3.44 (CPA).
We finally compare our best variant (GRASP+EC) withthe previous best method (IM) with the well-known Wilcoxontest for pairwise comparisons, which answers the question:do the two samples (solutions obtained with GRASP+EC and
IM in our case) represent two different populations? Theresulting p-value of 0.001 indicates that the values comparedcome from different methods (using the typical significancelevel of α = 0.05 as the threshold between rejecting or notrejecting the null hypothesis).
6 Conclusion
In this paper we propose several heuristics based on GRASPand ejection chains for the dynamic memory allocationproblem. The proposed GRASP heuristics consist of tworandomized greedy construction procedures and a localsearch procedure. An ejection chain intensification algorithmwas also proposed and tested as a post-processing of theGRASP.
We performed a computational comparison of our pro-posals and a previous method. It clearly shows that ourGRASP with ejection chains is able to improve the previ-ous method for the problem considered. The performanceof our method is definitely enhanced by the context-specificstrategies described in Sects. 3 and 4 that we developed forthis problem. However, we hope other researchers might findeffective and GRASP with ejection chains could become astandard hybrid method in future implementations.
Acknowledgments This research was partially supported by thegrant-invited -Professors-UBS-2012 of France, and by the the Min-isterio de Economía y Competitividad of Spain (TIN2009-07516and TIN2012-35632-C02), and the Generalitat Valenciana (Prometeo2013/049).
Appendix: Best known solutions
Table 7 shows in the first column the name of the instance,in the second column the best known value, which appearsin bold when our new methods are able to improve it in thisexperiment w.r.t the best previously identified. The next col-umn presents the solution value reached by the ILP formu-lation in Soto et al. (2011) solved with Xpress-MP, that isused as a heuristic when the time limit of 1 h is reached:the best solution found so far is then returned by the solver.Note that in some large instances, this method is not able toprovide a solution within the 3,600 s of time limit consid-ered. The following three columns show the deviation valuewith respect to the best known value for the IM, CPA, andGRASP methods, and the associated CPU time in secondswhich is the same for the three algorithms. Finally, the lasttwo columns show the Dev. BK value and the CPU time forthe GRASP+EC method, respectively.
123
1526 M. Sevaux et al.
Table 7 Final comparison
Instance Best known ILP IM (%) CPA (%) GRASP (%) CPU(s) GRASP+EC (%) CPU(s)
GRASP with ejection chains for the dynamic memory 1527
References
Chimientia A, Fanucci L, Locatellic R, Saponarac S (2002) VLSIarchitecture for a low-power video codec system. Microelectron J33(5):417–427
Coussy P, Casseau E, Bomel P, Baganne A, Martin E (2006) A formalmethod for hardware IP design and integration under I/O and timingconstraints. ACM Trans Embed Comput Syst 5(1):29–53
Duarte A, Martí R, Resende MGC, Silva RMA (2011) Grasp withpath relinking heuristics for the antibandwidth problem. Networks58(3):171–189
Feo TA, Resende MGC (1989) A probabilistic heuristic for a computa-tionally difficult set covering problem. Oper Res Lett 8:67–71
Glover F, Laguna M (1997) Tabu search. Kluwer Academic Publishers,New York
Julien N, Laurent J, Senn E, Martin E (2003) Power consumption mod-eling and characterization of the TI C6201. IEEE Micro 23(5):40–49
Lin S, Kernighan B (1973) An effective heuristic algorithm for thetraveling salesman problem. Operat Res 21:498–516
Lozano M, Duarte A, Gortzar F, Martí R (2012) Variable neighbor-hood search with ejection chains for the antibandwidth problem. JHeuristics 18:919–938
Martí R, Duarte A, Laguna M (2009) Advanced scatter search for themax-cut problem. INFORMS J Comput 21(1):26–38
Martí R, Pantrigo JJ, Duarte A, Campos V (2011) Scatter search andpath relinking: a tutorial on the linear arrangement problem. Int JSwarm Intell Res 2(2):1–21
Porumbel D (2009) DIMACS graphs: benchmark instances and bestupper bound.
Resende MGC, Martí R, Gallego M, Duarte A (2010) Grasp and pathrelinking for the max–min diversity problem. Comput Operat Res37:498–508
Resende MGC, Ribeiro CC (2010) Handbook of Metaheuristics. In:Potvin JY, Gendrau M (eds) Greedy randomized adaptive searchprocedures, 2nd edn. Kluwer Academic Publishers, New York, pp283–320
Soto M, Rossi A, Sevaux M (2010) Métaheuristiques pour l’allocationde mémoire dans les systèmes embarqués. In: Proceedings ofROADEF 11e congrès de la société Française de Recherche Opéra-tionelle est d’Aide à la Décision. Toulouse, France, pp 35–43
Soto M, Rossi A, Sevaux M (2011) A mathematical model and ametaheuristic approach for a memory allocation problem. Journalof Heuristics 18(1):149–167
Soto M, Rossi A, Sevaux M (2011) Two iterative metaheuristicapproaches to dynamic memory allocation for embedded systems.In: Merz P, Hao JK (eds) Evolutionary computation in combinatorialoptimization—11th European Conference, EvoCOP 2011, Torino,Italy. Proceedings, vol 6622 of Lecture Notes in Computer ScienceSpringer, 250–261
Wuytack S, Catthoor F, Nachtergaele L, De Man H (1996) Power explo-ration for data dominated video application. In: Proceedings of IEEEInternational Symposium on Low Power Electronics and Design.Monterey, USA, pp 359–364
