Static and adaptive distributed data replication using genetic algorithms

Transcription

1 J. Parallel Distrib. Comput. 64 (24) Static and adaptive distributed data replication using genetic algorithms Thanasis Louopoulos a, Ishfaq Ahmad b, a Department of Computer Science, The Hong Kong University of Science and Technology, Kowloon, Hong Kong b Department of Computer Science and Engineering, The University of Texas at Arlintgon, P.O. Box 1915, 248 D/E Nedderman Hall, 416 Yates St., Arlington, TX , USA Received 4 May 21; received in revised form 12 March 24 Abstract Fast dissemination and access of information in large distributed systems, such as the Internet, has become a norm of our daily life. However, undesired long delays experienced by end-users, especially during the pea hours, continue to be a common problem. Replicating some of the objects at multiple sites is one possible solution in decreasing networ traffic. The decision of what to replicate where, requires solving a constraint optimization problem which is NP-complete in general. Such problems are nown to stretch the capacity of a Genetic Algorithm (GA) to its limits. Nevertheless, we propose a GA to solve the problem when the read/write demands remain static and experimentally prove the superior solution quality obtained compared to an intuitive greedy method. Unfortunately, the static GA approach involves high running time and may not be useful when read/write demands continuously change, as is the case with breaing news. To tacle such case we propose a hybrid GA that taes as input the current replica distribution and computes a new one using nowledge about the networ attributes and the changes occurred. Keeping in view more pragmatic scenarios in today s distributed information environments, we evaluate these algorithms with respect to the storage capacity constraint of each site as well as variations in the popularity of objects, and also examine the trade-off between running time and solution quality. 24 Elsevier Inc. All rights reserved. Keywords: Data replication; Genetic algorithms; Static and dynamic allocation; Internet; World wide web; Greedy method 1. Introduction Data replication across a read intensive networ can potentially lead in increased traffic savings which can indirectly reduce the response time experienced by end-users. On the other hand in the presence of updates, maintaining large number of copies can be a performance bottlenec. There are three main issues when taling about replication in traditional distributed systems namely, allocation [15], consistency [2] and fault tolerance [3]. Recently, the high download times experienced during pea hours in the www [9], spurred interest on replicating data objects over the web [7,23,3] and providing mechanisms to allow user requests to be redirected towards a geographically close replica Corresponding author. Fax: address: iahmad@cse.uta.edu (I. Ahmad). [28]. Under the web context, consistency and fault tolerance are not of primary importance while allocation still remains a challenge. Surprisingly, the current trend is to perform coarse grain replication in the form of server mirroring, i.e., duplicating all the contents of a web server [27]. As the web grows larger and larger and caching limitations become apparent [1,1] it is reasonable to expect that the importance of fine grain replication, e.g., replicating pages, will increase. The first standpoint from where we address the problem of data replication is a cold networ start where no replicas exist and the read and update frequencies remain static. The target is to define an appropriate replica distribution that minimizes the networ traffic. We formulate the problem as a constraint optimization one and show that the relevant decision problem is NP-complete. We then propose a greedy heuristic called simple replication algorithm (SRA) and a genetic algorithm-based heuristic called genetic replication algorithm (GRA) /$ - see front matter 24 Elsevier Inc. All rights reserved. doi:1.116/j.jpdc

2 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) We evaluate both algorithms extensively and compare them against random search for the case where each object has equal probability to be accessed by any of the sites in the networ, as well as when the request/site pattern follows a normal distribution. Linear Programming (LP) is used to estimate an upper bound for the optimal solution resulting by exhaustive search, while the integer parts of the solution found by LP (Linear Integer Programming LIP) are evaluated in order to define a lower bound for the optimal. Results show that in most cases both algorithms achieve performance in between these two bounds, with GRA constantly outperforming SRA, especially under the uniform assumption for the requests. The second data replication aspect we tacle with, is the case where replica allocation was already performed but due to changes in the exhibited requests adaptations are needed. Both SRA and GRA are static algorithms. Once the replica distribution for the objects is obtained, changes in access patterns would result in the algorithms being run from scratch, which is potentially time consuming. For this reason we propose an extension of the GRA algorithm called Adaptive GRA (AGRA) that given an already realized replication scheme and the changes in read and write requests for particular objects, it quicly adapts the replica distribution to reflect the new demands. The reduced search space on which AGRA operates allows it to provide high solution quality within acceptable for a dynamic environment time limits. The rest of the paper (a smaller version of which appeared in [24]) is organized as follows: Section 2 elaborates the problem and describes a cost model for the total data transfer cost. The same section includes the NP-completeness of the problem. Section 3 describes the greedy and evolutionary static methods, while Section 4 introduces AGRA. Sections 5 and 6, respectively, present the experimental results and the related wor. Section 7 includes the concluding remars. 2. The data replication problem (DRP) First, we describe the inputs to (DRP) and introduce a notation (see Table 1) that will be subsequently used. Consider a distributed system comprising M sites, with each site having its own processing power, memory and storage media. Let S (i), s (i) be the name and the total storage capacity (in simple data units e.g. blocs), respectively, of site i where 1 i M. The M sites of the system are connected by a communication networ. A lin between two sites S (i) and S (j) (if it exists) has a positive integer C(i,j) associated with it, giving the communication cost for transferring a data unit between sites S (i) and S (j). If the two sites are not directly connected by a communication lin then the above cost is given by the sum of the costs of all the lins in a chosen path from site S (i) to site S (j). We assume that C(i,j)= C(j,i) and is nown a priori to represent the cumulative cost of the shortest path between S (i) and S (j). Let there be N objects, named {O 1,O 2,..., O N }. The size Table 1 Symbol Meaning O o S (i) s (i) b (i) M N r (i) R (i) w (i) W (i) C(i,j) SP SN (i) R D B (i) th object Size of object ith site Total storage capacity of S (i) Remaining storage capacity of S (i) Number of sites in the networ Number of objects in the distributed system Number of reads from site i for object Associated cost of the r (i) reads Number of writes from site i for object Associated cost of the w (i) writes Communication cost (per unit) between sites i and j Primary site of th object Nearest site of site i, which holds object Replication scheme of the th object Total data transfer cost function Benefit value, that is, the NTC saves we can achieve by replicating the jth object at the ith site. of object O is denoted by o and is measured in simple data units. Let r (i) and w (i) be the total number of reads and writes, respectively, initiated from S (i) for O during a certain time period. The replication policy assumes the existence of one primary copy for each object in the networ. Let SP,bethe site which holds the primary copy of O, i.e., the only copy in the networ that cannot be deallocated, hence referred to as primary site of the th object. Each primary site SP, contains information about the whole replication scheme R of O. This can be done by maintaining a list of the sites that the th object is replicated at, called from now on the replicators of O. Moreover, every site S (i) stores a two-field record for each object. The first field, is the primary site SP of it and the second the nearest site SN (i) of site i, which holds a replica of object. In other words, SN (i) is the site for which the reads from S (i) for O, if served there, would incur the minimum possible communication cost. It is possible that SN (i) = S (i), if S (i) is a replicator or the primary site of O. Another possibility is that SN (i) = SP, if the primary site is the closest one holding a replica of O. When a site S (i) reads an object, it does so by addressing the request to the corresponding SN (i). For the updates we assume that every site can update every object. This assumption, does not affect the ability to use our model in practical cases, where we have to enforce some privilege checing. Updates of an object O are performed, by sending the updated version to its primary site SP, which afterwards broadcasts it to every site in its replication scheme, R. The simplicity of this policy, allows us to develop a general cost model in Section 2.2 that can be used with minor changes to formalize various replication and consistency strategies.

3 1272 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) The object transfer cost model We are interested in minimizing the total networ transfer cost (NTC), due to object movement, since the communication cost of control messages has minor impact to the overall performance of the system. There are two components affecting NTC. First is the NTC created from the read requests. Let R (i) denote the total NTC, due to S (i) s reading requests for object O, addressed to the nearest site SN (i). This cost is given by the following equation: R (i) = r (i) O C(i,SN (i) ), (1) where SN (i) ={Sitej j R min C(i,j)}. The second component of NTC is the cost due to writes. Let W (i) be the total NTC, due to S (i) s writing requests for object O, addressed to the primary site SP. W (i) is comprised of the cost occurring when S (i) sends the updated object to SP and the cost due to SP broadcasting the updates to the rest of the replicators as shown in the following equation: W (i) = w (i) O C(i,SP ) + C(SP,j). (2) (j R ) j =1 Here, we made the indirect assumption that in order to perform a write we need to ship the whole updated version of the object. This of course is not always the case, as we can move only the updated parts of it, in order to augment efficiency. Modelling such policies can also be done using our framewor, e.g., by defining separately the object size, mean read size and the mean update size. The cumulative NTC, denoted as D, due to reads and writes is given by D = M N (R (i) i=1 =1 + W (i) ). (3) Let X i = 1ifS (i) holds a replica of object O, and otherwise. X i s define an M N replication matrix, named X, with boolean elements. The total NTC is now refined as { M N D= (1 X i )[r (i) O min {C(i,j) X j = 1} i=1 =1 +w (i) O C(i,SP ) + X i ( M x=1 w (x) ) } O C(i,SP ). (4) Sites which are not replicators of object O create NTC equal to the communication cost of their reads from the nearest replicator, plus that of sending their writes to the primary site of O. Sites belonging to the replication scheme of O are only associated with the cost of sending/receiving all the updated versions of it, since reads are performed locally. Using the above formulation DRP is defined as 1. Find the assignment of, 1 values at the X matrix, that minimizes D. 2. Subject to the storage capacity constraint: N X i O s (i) =1 (1 i M). 3. Subject to the primary copies policy X SP = 1 (1 N) Proof of NP-completeness The DRP as presented above is a constrained optimization problem. The equivalent decision problem can be stated as Given a networ instance, with only primary copies existing (no replicas) and an integer K, is there an assignment of, 1 values to X matrix such as D K and the storage capacity constraint is satisfied? It is easy to see that a non-deterministic algorithm, which chooses,1 assignment values row by row, while checing the storage constraint after completing each row of X, can decide the problem in polynomial time O(MN). Thus, DRP belongs to NP. In order to prove that it is also complete in NP, we will reduce it to the Knapsac Problem [26] the general statement of which is nown to be NP-complete and is presented below: Instance: Finite set U, for each u U a size s(u), a value ν(u), B, K, all positive integers. Question: Is there a subset U U such that u U s(u) B and u U ν(u) K? For every instance of the Knapsac problem, we can build a networ so that a solution to the Knapsac would also be a solution to a DRP instance. The networ is built as follows. We use a one by one mapping of objects belonging to U to the objects of the networ (to do so we order the set U), i.e., (N = U ) (O = s() 1 N). We pic up a random number of sites M 1(M 2) and allocate all the networ objects to each one of them assigning also u U s(u) storage capacity, i.e., X i = 1 s (i) = s(u) (1 i M 1 1 N). u U Then, we randomly decide which of the M 1 copies of an object would be the primary one. Having defined all the primary copies, we add another empty site with storage capacity B, hence referred to as Knapsac site Kns because an assignment of objects to it that solves Knapsac would also solve DRP. We set C(i,j) = 1 (1 i, j M),W (i) = (1 i M 1 N) and set

4 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) = ν() u U s(u)/s() ( U)1. The NTC occurred due to the requests from all the other sites apart from Kns is zero, since the read requests are satisfied locally and no updates exist. Every object allocation scheme for Kns that minimizes NTC is a solution to DRP since the NTC of the rest part of the networ remains zero. All lin costs are equal to 1, so each object allocated in Kns reduces the total NTC r (Kns) by r (Kns) O or ν() u U s(u) regardless of the already allocated ones. Let U be the set of objects allocated to Kns. Let Dinitial denote the NTC occurred when each of M 1 sites contain all the objects and Kns is empty and Dns denote the NTC occurred after completing object allocation in Kns. Then, the initial DRP decision problem can be restated as: Assuming the networ instance which yields NTC equal to Dinitial, is there a subset U of the set of objects that if allocated at Kns site with respect to its capacity, the total NTC D will be D K, where K can be any integer? The inequality D K can be restated as: Dinitial N=1 O x U ν(x) K, or C x U ν(x) E or finally as: x U ν(x) K (where K, K, E are any integers and C is constant). In order to answer the question whether a U, such as x U ν(x) K exists or not, we must answer the relevant Knapsac question ( u U ν(u) K ). Therefore, for every Knapsac instance we can construct a networ as above, so that a solution to the Knapsac would also be a solution to the DRP thus, the DRP is reducable to the Knapsac and since it also belongs to NP it is NPcomplete. 3. Static allocation In this section we describe the simple replication algorithm based on the greedy method (SRA) and the genetic replication algorithm GRA. Both algorithms define a replication scheme for the objects assuming that no replicas exist and read/write frequencies are nown and remain static in nature Data replication using a greedy algorithm For each site S (i) and object O we define the replication benefit value B (i), as follows: ( R (i) Mx=1 ) B (i) w (x) O C(i,SP ) W (i) =. (5) O The above value represents the expected benefit in NTC terms, if we replicated O at S (i). This benefit is computed by using the difference between the NTC occurred from the current read requests and the NTC arising due to the updates to that replica amortized to the object size. Negative values of B (i) mean that replicating th object, is inefficient from the local view of ith site. This does not necessarily mean that we are not able to reduce the total NTC by creating such a replica, but that the local NTC observed from the ith site will be increased. To present our algorithm, we maintain a list L (i) for S (i) containing all the objects that can be replicated. An object O can be replicated at S (i) only if the remaining storage capacity b (i) of the site is greater than its size and the benefit value is positive. We also eep a list LS containing all the sites that have the opportunity to replicate an object. In other words, a site S (i) LS if and only if L (i) =. The SRA Algorithm performs in steps. In each step a site S (i) is chosen from LS in a round-robin fashion and the benefit values of all objects belonging to L (i) are computed. The one with the highest benefit is replicated and the lists LS, L (i) together with the corresponding nearest site value SN (i), are updated accordingly. The SRA algorithm is outlined as follows: The SRA Algorithm: (1) Initialize LS and all L i. (2) WHILE LS DO (3) BMAX =, OMAX = NULL () i. /*BMAX holds the current max B value. () i OMAX holds the identity of the Object for which B = */ BMAX*/ (4) Pic up a site S i LS in a Round-Robin way. (5) FOR each O L i DO (6) () i Compute B. (7) () i IF BMAX B () i THEN BMAX = B, OMAX = (8) () i ELSE IF ( B OR b i < o ) THEN L i = L i { O }. (9) Replicate O OMAX. (1) L i = L i { O }. /*Remove OMAX object from the list of potentials to be replicated*/ (11) FOR all sites in LS update the relevant () i SN OMAX field. /* Update nearest sites */ (12) b i = b i o. /*New remaining capacity*/ (13) IF L i = THEN LS. = LS { S i } /*Remove S i if there are no other candidates (objects) to be replicated*/ (14) ENDWHILE 1 By setting the reads as above we ensure they are integers. If non-integer reads were also allowed i.e. we had formalized DRP using R/W frequencies and not the actual number of requests, we could have simply used r (Kns) = υ() / s().

5 1274 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) The are MN iterations of the while-loop (2) in the worst case where each site has sufficient capacity to store all objects and the update ratios are low enough so as no object incurs negative benefit value. The time complexity for each execution of the while-loop is governed by the for-loop in (5) and the update of neighbors fields in (11) (O(M+N) in total). Hence, we conclude that the complexity of our algorithm in the worst case is O(M 2 N + MN 2 ). We presented SRA as a centralized algorithm. In its distributed version we assign L (i) s to their corresponding sites and LS to the networ leader, which can be a monitor site. All the main calculations (5) (1) are done locally, while (11) requires a broadcast of O OMAX to all sites in order to update their SN (i) OMAX field. The selection of S(i) in (4) is done by the leader who is responsible for notifying the sites accordingly. It should be mentioned that since the algorithm replicates objects according to their local benefit value, it provides high solution quality, when independent read frequencies are significantly larger, compared to the total number of updates. This is better illustrated in our experiments at Section 5. r (i) 3.2. The evolutionary method Genetic algorithms (GAs), introduced by Holland in 1975 [22], are search methods based on the evolutionary concept of natural mutation and the survival of the fittest individuals. Given a well-defined search space they apply three different genetic search operations, namely, selection, crossover, and mutation, to transform an initial population of chromosomes, with the objective to improve their quality. An outline of a generic GA is as follows. Generate initial population. Perform selection step. while stopping criterion not met do Perform crossover step. Perform mutation step. Perform selection step. end while. Report the best chromosome as the final solution. We demonstrate GRA s design in detail, by presenting our encoding mechanism and then the selection, crossover and mutation operators. Some additional notation related to GA is summarized in Table 2. A chromosome encoding a replication scheme is a bitstring consisting of M genes (one for each site). Every gene is composed of N bits (one for each object). A 1 value in the th bit of the ith gene, denotes that ith site holds a replica of th object, otherwise it is. Using this encoding the total length of a chromosome is MN bits. The following scheme Table 2 Symbol D D prime f f N p N g μ c μ m Meaning Total data transfer cost function Total data transfer cost function, of the initial alloc. scheme Fitness value Average fitness value of the population Population size (number of chromosomes) Total number of generations Crossover rate Mutation rate explains the above: Example chromosome Site 1 Site M N Objects A gene (site) is valid if and only if the total storage cost of allocating the required objects (1 s in the gene) does not exceed the site s capacity; otherwise the gene is invalid. We also define a chromosome to be valid/invalid according to the existence of an invalid gene. Fitness value f: The quality of each chromosome is measured by computing its fitness value. Our objective function D, defined in Section 2.2, helps us define f. In order to maintain uniformity over various problem domains, we normalize the fitness value to a convenient range of to 1. The above need excludes us from picing up directly f = D, since D can tae arbitrary high values. For our algorithm we consider our initial allocation scheme an object appears in the networ only at its primary site, that is R ={SP } (1 N) and the NTC occurred in it, denoted by D prime. It is reasonable to expect that every replication scheme invoes NTC D such that D<D prime, meaning that from our starting allocation scheme with no replicas, there is still a lot of NTC to be saved by using replication of data. Considering the above, the definition of the normalized fitness value is straightforward: f = D prime D. D prime In the rare case that f<, we reset chromosome s fitness value to be by copying the initial allocation scheme in it. Generation of the initial population: We initialize half of the population by using the SRA algorithm, randomly picing up sites at its fourth step. The other half of the population is generated in a total random way. Moreover, half of the chromosomes produced by SRA are subjected to random perturbation of 1/4th of their values. The chromosome validity is checed and maintained throughout all the random decisions. The use of SRA together with random generation, results in the initial chromosomes being adequately homogeneous in their fitness values, while at the same time diverse enough in their building blocs (substrings). Furthermore, the average population fitness is high, even when

6 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) due to increased updates SRA fails to produce a good solution. SRA s complexity is O(M 2 N + MN 2 ) for M sites and N objects. Therefore, the total initialization time required is O(N p M 2 N +N p MN 2 ), where N p stands for the population size, Crossover/mutation/selection: We selected a two-point crossover mechanism to include in GRA. After the pairing of chromosomes, two bits are randomly selected and either the portion of the bit-string in between them or the two fractions not included by them, are swapped. The decision of which parts to juxtapose is random. The whole operation is performed with probability μ c, nown as crossover rate and may result in producing invalid chromosomes. Clearly, if this is the case, the only possible invalid genes, are the two (or one) containing the crossover points, since completely interchanging valid genes, cannot result in an invalid chromosome. To repair a gene validity violation, we exchange the parts of it that were not previously swapped. Mutation is performed by simply flipping every bit with a certain probability μ m, nown as the mutation rate. Although mutation is not the primary search operation and some algorithms omit it, it is very useful in our design. The reason is that in order for our algorithm to have practical applications it should achieve good performance when tacling very large chromosomes (our test case in many experiments is 8 sites and 4 objects). A two point-crossover alone would not be able to explore the solution space fast while a multiple point crossover would result in increased constraint violations. Moreover, multiple point crossover is nown to be highly disruptive [18]. Mutation aids in both the exploration and the exploitation of our solution space. Changing a bit value can result in violating the storage constraint, as well as deallocating an object from its primary site. In such case mutation of the specific bit is not performed. Selection constitutes of two parts: evaluation of a chromosome and offspring allocation. Evaluation is performed by measuring its fitness value f, which depicts the quality of solution the chromosome represents. Offspring allocation is done by using the proportionate scheme (simple genetic algorithm [22]). This scheme allocates to the ith chromosome, f i / f offspring for the next generation. SGA implements this scheme by using the roulette wheel selection, i.e., allocating a sector of the wheel equaling 2πf i / f to the ith chromosome and then create an offspring if a generated number in the range of to 2π, falls inside the assigned sector of the string. The chromosomes under evaluation are N p exactly, since after applying crossover and mutation the resulting chromosomes are immediately copied bac in the place of their fathers. Instead of following this approach that can lead to large sampling errors, we selected the stochastic remainder technique [18] to incorporate in GRA. Following this method, a chromosome is assigned offspring according to the integer part of the proportionate fitness value in a deterministic way and the fractional parts are put in a roulette wheel, in order for the remaining offspring to be defined. Moreover, instead of evaluating N p chromosomes (Simple Selection), we used the (μ + λ) Selection borrowed from evolutionary strategies [31]. Under this strategy from the initial population of μ = N p size, two more subpopulations are created of total size λ, one from crossover and the other from mutation operator. The chromosomes of all these three populations (μ + λ) compete for the μ slots of the next generation. This choice although resulting in higher execution time (needs up to three times more fitness evaluations), was necessary because due to the hard constraint nature of the problem, applying mutation and crossover can result in worsening a generation. Finally, we implemented the elitistic approach, under which the best chromosome found until one generation before replaces the worst chromosome of the population. We allow the elite chromosome to be copied bac once every five generations, in order to prevent premature convergence. Large values of μ c and μ m, force a GA to explore the solution space, while low values favor exploitation. Optimal tuning of these, require extensive experimentations [18]. Typical values of the above parameters that guarantee good solution quality for some domains are: N p ={3, 1}, μ c ={.9,.6}, μ m ={.1,.1}, respectively [14,19]. Of course, even with the best decisions on the above parameters, optimal solutions cannot be guaranteed, due to the algorithm s probabilistic nature. Unless otherwise stated the GRA s parameters after a series of experiments were fixed to: N p = 5, N g = 8, μ m =.1, μ c =.9. As far as the time complexity of GRA is concerned, selection is clearly the hardest operation, because it involves the evaluation of fitness values, which in terms demands the computation of the objective function D(O(M 2 N)). Thus, the complexity of GRA in the worst case is O(N g N p M 2 N + initialization). 4. Adaptive replication Let R be the old replication scheme for the objects and R the newly defined one. Let D R and D R, represent the total NTC created by R and R, respectively, both computable using Eq. (4). Furthermore, let X be an M N (,1) matrix with its element X i being 1 if O is replicated at S (i) under the R scheme, and otherwise. When realizing R some replicas must be deleted and others must be created. We assume that replica creation is done by transferring a copy of the object from the respective primary site 2. Assuming that replica deletion incurs no cost, the total NTC, denoted by for I RR, realizing R is given by I RR = N i=1 =1 M X i(1 X i )O C(i,SP ), (6) 2 A more sophisticated policy would enable sites to get objects from any of the replicators. This gives rise to the scheduling problem of selecting replica deletions and creations so as to minimize the NTC. Tacling the above is out of the scope of this paper and is part of our future wor.

7 1276 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) Initial allocation matrix for a networ of 4 servers and 5 objects. Changes in the request patterns of O and O 2 occur INITIALIZATION AGRA evolves the two populations together and the unconstrained allocation schemes for O and O 2 are defined. 1 AFTER EVOLUTION 1 The allocation schemes ofo and O 2 outputed by GRA, form part of the initial populations of two separate miniga s. The rest of the initial population is generated randomly. Fig. 1. Example of AGRA execution. TRANSCRIPTION PHASE After copying bac the allocation schemes of the 1 1 two objects the capacity limit of S (3) is violated The object with the lowest benefit value (O 2 ), according to Eq.8 is selected for deallocation, resulting to the final replication matrix where X i is the allocation variable for the replication scheme R. The total benefit, denoted by V RR, for moving from the R scheme to the R is given by V RR = D R (D R + I RR ). (7) The adaptive data replication problem (ADRP) can be defined as: Given the X matrix find the values of X that maximize V RR, subject to the storage capacity constraints. ADRP s scope is much different than DRP (Section 2). We use DRP to represent the allocation decisions made during nighttime by a monitor site that gathers statistics about object requests and taes decisions accordingly (we also made the indirect assumption that the actual cost for realizing a replication scheme during nighttime is insignificant and thus, can be omitted). On the other hand, ADRP is used to describe the situation when the replication scheme realized during nighttime, does not perform well during daytime, presumably because the exhibited request frequencies differ largely from the estimations used. For this purpose an algorithm that fine tunes, within reasonable time limits, the existing scheme instead of defining one from scratch is needed. Following, we present a genetic algorithm-based approach called AGRA The AGRA Each chromosome in the population of AGRA is a bitstring of length M representing the assignments of O. AGRA taes as input the new patterns exhibited for O and computes a set of near optimal replication schemes for the specific object, without taing into account the storage capacity of the sites. Afterwards, the R s are incorporated to the initial GRA solutions, repairing any storage constraint violations by deallocating least beneficial objects. The modified population is then inserted to a micro-gra and evolved for few generations in order to determine an even better solution. Fig. 1 illustrates the above. The initialization of the first generation is performed in AGRA by randomly creating half of the population while the rest of it being obtained by solutions previously found from GRA. We mae sure that the current replication scheme of O, always participates in the starting population. The three operations of GA (selection, crossover, mutation) come afterwards to define the population of the next generation. The fitness value of AGRA is given by f A = V RR = D R (D R + I RR ). D R D R In case f A <, the chromosome s fitness value is set bac to by copying the initial R to the chromosome. Fortunately, by nowing D R, f A can be computed in O(M 2 ) time through evaluating only the impact O has to the total NTC. The sampling space of AGRA is regular (as opposed to GRA where we used (μ+λ) selection) containing only the offspring and some part of the parents (those not subjected to crossover and mutation). Again, the stochastic remainder technique is used with the fractional parts being allocated in a roulette wheel. The rationale behind these choices as with all others concerning AGRA s design, is to reduce the running time. The number of generations A g is set to 5 and the population size A p to 1. The elitistic approach was followed as in GRA. Single point crossover was selected with equal probabilities of crossing the left and the right part of the chromosomes. Mutation means again simply flipping a bit. Constant crossover and mutation rates are used with values of 8% and 1%, respectively. After A g generations, the GA part of the algorithm terminates having converged largely to high fitness solutions representing R s that distribute O to a degree that minimizes the NTC effects of R/W requests. The best R found by AGRA is transcripted to half of the initial population of GRA, including the corresponding elite chromosome (current networ replica distribution), while the remaining R s are randomly transcripted to the other half. Such transcription can result in storage capacity violation which needs to be resolved efficiently. Other than randomly deallocating objects until the constraint is satisfied, we followed a greedy method and calculate the negative impact each possible one object deallocation has in V RR.

8 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) Furthermore, instead of computing the actual performance difference which would require O(M 2 ) time, we used the following estimation, computable in O(M) time: E (i) E (i) = B (i) / M X i j=1. (8) depicts a site-object affinity measure. The object with the lowest value is evicted from S (i) free space. B (i) is the local benefit as defined in Eq. (5). The rationale behind amortizing the local benefit to the number of replicas existing in the networ is to favor deallocations of objects for which many replicas exist. Having transcripted the R s to the initial solutions there are two valid options: we stop here and pic up the chromosome of highest fitness value to realize the corresponding total replication scheme, use the resulting population, as the initial population of a mini_gra intended to run for small number of generations such as 5 1. We use and evaluate both policies. Before concluding this section we would lie to mae some remars on the usability of AGRA. The powerful technique of defining an optimal unconstrained replica distribution for a single object and transcript the solution to the total replication scheme, (repairing any capacity violations) can be incorporated in GRA s design as a separate operator, along with crossover, mutation and selection. Indeed, from the performance of the AGRA+5/1 GRA (Section 5), we expect that the performance of GRA would be considerably improved, since this operator forces GRA to search more promising regions of the solution space. We chose though to present this technique as a separate algorithm since it seemed reasonable to differentiate the static design of GRA which involved high running time from a method that is fast and can achieve good solution quality even when running without the mini-gra. 5. Experimental results Here, we present the results of our experiments carried out on a 2 MHz Ultra Sparc 2 machine. Two major experiments were conducted, one to evaluate the static algorithms and one the adaptive method. Comparing the performance of the static algorithms to the optimal solution obtained by exhaustive search, would have been the best way to illustrate the merits of our approaches. Exhaustive search though, was able to provide the optimum within reasonable running time, only for very small networ instances (typically five sites six objects). Since such problem sizes have little practical meaning we followed another approach. We decided to use the primal dual method for (LP) [36] as implemented in MATLAB [37], in order to find an upper bound for the optimal solution. Some object allocations in the LP solution are fractional. By cutting off these allocations (LIP Linear Integer Programming) we obtained a lower bound for the optimal. The experimental results show that our algorithm performance fall in most cases between these two bounds. Even as we used the above technique we were able to obtain results for only medium sized networs (typically 15 sites 4 8 objects). For this reason, we also conducted a separate experiment series with large networ instances and compare the relative performance of the algorithms. The solution quality in all cases, is measured according to the NTC percentage that is saved under the replication scheme found by the algorithms, compared to the initial one, i.e., when only primary copies exist. Finally, in the last experimental set we evaluated the performance of AGRA both as a standalone algorithm and in combination with the micro-gra Worload We generate the networ structures in the following manner. The lin costs were uniformly distributed between 1 and 1. This effectively represents the number of hops a TCP/IP pacet should mae in order to reach its destination, a lin cost measurement that is commonly used, see for example [2]. Objects were created so as to resemble a generic web worload [5,39], i.e., object sizes followed a pareto distribution and their popularity the Zipf law [38]. The minimum object size was 4 K. Primary sites were chosen randomly. The total number of requests considered for large networ instances were 1 million, while for medium sized networs 1,. Two distinct cases were considered as to request generation. In the first one, each site has the same probability of requesting an object, while in the second case object requests are normally distributed to the sites. This is done in order to test the performance of our algorithms at the presence of hot spots. In all the experiments, the basic capacity of sites (C%) is proportional to the total size of objects. In order to ensure the creation of sites with diverse enough storing capabilities, the actual capacity of a site was a random value between (C/2)% and (3C/2)%. Evaluating AGRA requires altering the original R/W patterns. Half of the new requests were randomly assigned to sites, while for the other half the assignment followed a normal distribution. This is again done to simulate hot spots. For each networ instance, 15 different networs were generated. In all the experiments we recorded the average quality of replication schemes obtained (% NTC saving), together with the average execution time of the algorithms and the average number of replicas created in those 15 runs Performance of SRA and GRA First, we assess the performance of SRA and GRA as compared to LP, LIP and random search, by varying the number of sites and objects. We fixed the site capacity to C =3% and the update ratio to U =5%. Figs. 2 and 3 show the results when requests are normally distributed across the sites. The first observation is that GRA outperforms SRA in

9 1278 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) SRA GRA LP LIP Rand SRA GRA LP LIP Rand Servers Objects Replicas Replicas Servers Objects 14 Execution time (c) Servers Fig. 2. vs. sites (N = 2, C = 3%, U = 5%, normal), replicas created vs. sites (N = 2, C = 3%, U = 5%, normal) and (c) execution time vs. sites (N = 2, C = 3%, U = 5%, normal). terms of solution quality in all cases, while Random Search produces the lowest quality replication schemes among all the tested algorithms. The LP/LIP combination to approximate the global optimum is shown to be efficient since in most cases their performance difference is small (Figs. 4 and 5 further illustrate this). In the majority of problem instances GRA s performance falls between these two bounds while SRA does so in less cases. Fig. 2 shows an almost constant performance for the algorithms. The observation Execution time (c) Objects Fig. 3. vs. objects (M =1, C =3%, U =5%, normal), replicas created vs. objects (M = 1, C = 3%, U = 5%, normal) and (c) execution time vs. objects (M = 1, C = 3%, U = 5%, normal). should be attributed to the fact that by adding a site in the networ, we introduce additional traffic due to its local requests, together with more storage capacity to be used for replication. GRA explores and balances these diverse effects better than the greedy method. In Fig. 3 the performance of algorithms varies due to the fact that the generated networ instances, had significantly different characteristics as

10 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) SRA GRA LP LIP Rand Capacity % SRA GRA LP LIP Rand Capacity % Update ratio Update ratio Fig. 4. vs. capacity (M =15, N =4, U =2%, normal) and vs. update ratio (M = 15, N = 4, C = 8%, normal). Fig. 5. vs. capacity (M =15, N =4, U =2%, uniform) and vs. update ratio (M = 15, N = 4, C = 8%, uniform). to the site capacities and request distributions among sites. Such diversibility on the generated instances has less impact as the networ size increases (Figs. 6 and 7). Fig. 2 and 3 show an almost linear increase on the replicas created by all algorithms. Figs. 2(c) and 3(c) show the execution times for LP and GRA. LP s running time increases exponentially while GRA s running time is shown to be linear with a low growth rate, especially versus the number of sites (Fig. 2(c)). SRA (not shown in figure) required three orders of magnitude less running time compared to GRA, while LIP s running time is dominated by LP. Random Search s execution time was fixed to five times the one of GRA. In the second set of experiments we investigated the impact, site capacity and update ratio have on the traffic savings obtained by the algorithms. We did so for two distinct cases, one for normal distribution of requests to the sites (Fig. 4) and one for uniform (Fig. 5). Creating replicas for an object that is already extensively replicated, is unliely to result in significant traffic savings, since only a small portion of the sites will be affected and perform their reads with lower cost. It is also apparent that the update ratio sets an upper limit on the possible traffic reduction through replication, so that even with unlimited storage capacities at the sites, the replicate everything everywhere policy can be inadequate. Figs. 4 and 5 show that the cost savings tend to increase significantly at the beginning as the capacity increases, while after a certain point where the most read intensive objects are replicated, adding more storage space results to only marginal performance improvement. In the same figures we should note that GRA and SRA achieve comparable performance, primarily due to the small update ratio (U = 2%). Figs. 4 and 5 depict the algorithms performance as the update ratio increases. It is clear that all algorithms exhibit an exponential performance degradation, which is more apparent in the uniform case. Comparison between Figs. 4 and 5 shows that the solution quality difference between SRA and GRA increases to the update ratio, with the effect being more apparent when no hot spots exist in the networ, Fig. 5. In order to understand why this happens, we should recall that SRA maintains a localized networ perception. Increasing the updates, results in objects having decreased local benefit and forces SRA to tae them out of the replication candidate list. In contrast, GRA with its randomized replica creation mechanism is able to select better replication schemes, especially in the uniform case where no super beneficial objects exist. The same plots also show that even when GRA s performance fails to be

11 128 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) SRA GRA SRA GRA Capacity % Capacity % 7 6 (c) Update ratio Update ratio Fig. 6. : vs. capacity (M = 3, N = 6, U = 5%, normal), vs. update ratio (M = 3, N = 6, C = 8%, normal) and (c) vs. update ratio (M = 3, N = 6, C = 3%, normal). between LP and LIP 3, it is still very close to them, i.e., to the optimum. From the first two series of experiments it became clear that GRA achieves solution quality close to the optimum in the majority of cases. It also became apparent that Random Search is unable to explore the problem space efficiently, while algorithms based on linear/integer programming will 3 For example, in Fig. 5 LP and LIP have negligible differences. (c) Update ratio Update ratio Fig. 7. vs. capacity (M = 3, N = 6, U = 5%, uniform, vs. update ratio (M = 3, N = 6, C = 8%, uniform) and (c) vs. update ratio (M = 3, N = 6, C = 3%, uniform). incur prohibitively high running time. For instance for a networ consisting of 1 sites and 3 objects the resulting linear program will have 33,1 variables and 33,41 constraints, stretching the capabilities of any commercially available optimizer to its limits. Moreover, the running time explored in the paper referred to the linear programming relaxation of the problem (the one where fractional allocations are allowed), the actual (,1) integer programming which is required, will most liely incur higher running time as additional constraints are added (variables should be either or 1). In the third class of experiments we investigated how SRA and GRA perform when the networ size is large (S = 3, O = 6). Random Search gave inferior results to both

12 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) algorithms and is excluded from the plots. We were not able to obtain results from LP/LIP for this test case, due to the high running time of the algorithms. Figs. 6 and 7, illustrate the results both when one of the parameters determining the degree of replication (capacity/update ratio) is predominant in the networ Fig. (6(a,b) and 7(a,b)) and when both constraints play significant role Fig. 6(c) and 7(c). From the figures it is clear that GRA achieves higher performance compared to SRA and that this performance difference is greater when the request distribution is uniform. The same trends exhibited in Figs. 4 and 5, are also present here, i.e., exponential decrease to the update ratio and an initial increase followed with an almost constant performance afterwards as storage space is added. We should notice here that Fig. 7 shows an almost constant performance for SRA, while GRA s performance increases in a rather linear way 4. This is due to the fact that with U = 5% the point where further adding capacity results in only marginal savings is quicly reached 5. Summarizing, GRA achieves more traffic savings (in many cases beyond 7%), than the greedy method and responds better to changes in the networ size, the update ratios or the sites capacities. Furthermore, the quality of solutions obtained in a medium size networ were close to optional. On the other hand, the greedy method apart from achieving good quality of solutions for small update ratios, runs in about orders of magnitude less time. Both algorithms were found to outperform random search. Linear programming was shown to incur high running time Performance of AGRA Our test case is a networ of M = 3, N = 6, U = 2%, C = 2%. To illustrate the main merits of AGRA we have considered the case where either reads or writes increase. The dual case of decrease is not included here but the results are equivalent. Ch denotes the percentage of rising in either reads or writes for an object that has changed its R/W pattern. OCh represents the percentage of objects in the networ changing patterns and R, U, represent the percentage of changes being performed towards a read or write increase, respectively. So, for example in the networ considered, Ch= 6%, OCh= 3%, R = 8% and U = 2%, means that among the 6 total objects 144 have experienced an increase by 6% in their reads, while 36 a same increase in their write requests. We consider various scenarios. Given a replication scheme (supposedly determined by a static algorithm), we 4 The performance fluctuation in Fig. 6 and 7 and some paradoxes created due to it, should be attributed to variations between different networ instances. 5 Indeed, in further experiments with U = 1 3% the obtained plots followed the trends in Fig. 4 and 5. evaluate this scheme according to the new read-write patterns and determine the current value (current legend label) of NTC savings. Then we run the AGRA algorithm (current+agra legend label) using the current scheme. We also run AGRA with five generations of mini_gra (AGRA+5 GRA legend label) and then 1 generations of mini_gra (AGRA+1 GRA legend label). Next, we run only GRA with 8 (current+8 GRA legend label). Finally, we run 8 generations of GRA (8 GRA legend label) but not with the current scheme, but with a population generated from scratch. Fig. 8 show how the different policies perform as to the increase percentage (Ch). As it rises, the savings that GA policies achieve rise or drop depending on whether the increase refers to reads Fig. 8 or writes Fig. 8(c). The performance difference between AGRA and its combinations as compared to the static approaches is considerable (almost 15% in Fig. 8(c)). Moreover, if we do not have a dynamic method to adapt the replication scheme of the networ, the existing scheme can be totally outdated and inefficient when the percentage of increase is significant, e.g., the 1% case in Fig. 8(c). Fig. 9 shows similar trends when the increase percentage (Ch) is fixed and the percentage of changing objects (OCh) varies. In Figs. 8 and 9, the performance of all policies when only reads are increased seems to converge to different upper bounds. This should be attributed to the fact that GA policies replicate intensively at the beginning, so as to exploit the available capacity to the maximum. After a certain point though, further replication is constrained due to storage limitations and thus, the savings tend to increase less rapidly. When only the number of updates increase, AGRA policies perceive an almost linear behavior Fig. 8(c) and 9(c) due to the fact that increasing the updates of a certain percentage of objects, only means that these objects should not be distributed widely. There are still though, enough read intensive objects which should be replicated and the deallocation criterion together with the unconstrained mini-ga, shift the replication scheme towards them. Fig. 1 and show the performance of the algorithms as the pattern change shifts from 1% increase in updates towards 1% increase in reads. An interesting result is that among all the static methods, running GRA with a random initial population (8 GRA) is the best choice, for the cases were reads are increased while the (Current+8 GRA) policies are better when changes are performed in towards updates, or involve relatively low increase percentage (Fig. 8). The results obtained are encouraging towards the use of AGRA and its transcription/estimation method in dynamic environments. As we can see from all the above figures, AGRA s performance as stand-alone is significantly better than the current scheme, while its combination with the mini-gra constantly outperforms all other static policies and is only worse by no more than 2% from (8 GRA) in the case were all changes are towards read increase. The (8 GRA) policy though, has prohibitively high execution

13 1282 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) Current Current + AGRA AGRA + 5 GRA AGRA + 1 GRA Current + 8 GRA 8 GRA 75 Current Current + AGRA AGRA + 5 GRA AGRA + 1 GRA Current + 8 GRA 8 GRA NTC % savings (c) Request increase % Request increase % Request increase % Fig. 8. vs. Ch% (OCh= 2%, R/W = 1/%), vs. Ch% (OCh= 2%, R/W = 5/5%) and (c) NTC% savings vs. Ch% (OCh = 2%, R/W = /1%). NTC % savings (c) Changing objects% Changing objects% Changing objects% Fig. 9. vs. OCh% (Ch = 6%, R/W = 1/%), vs. OCh% (Ch = 6%, R/W = 5/5%) and (c) vs. OCh% (Ch = 6%, R/W = /1%).

14 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) Current Current + AGRA AGRA + 5 GRA AGRA + 1 GRA Current + 8 GRA 8 GRA time (around 1 s for this networ size), while AGRA as stand-alone is two orders of magnitude faster. Moreover, the number of changing objects have a marginal effect in the execution time of AGRA. Summarizing the results of the experimental evaluation we conclude that when static patterns are considered the GRA algorithm promises good performance in expense of high running time. In dynamic environments though AGRA performs really well especially when combined with the mini-gra. This is because the mini-gra using the adaptive part of AGRA enhances the exploration power of our static design. As a result, the combination of the two algorithms proves to be very efficient in the very first five generations of mini-gra, while the quality improvement with 1 generations or more is only marginal. The running time of AGRA with mini-gra is acceptable for the requirements of a dynamic environment, while the quality of solutions obtained is if not higher at least comparable to the more time consuming static genetic algorithm method. 6. Related wor Read% 4 6 Read% Fig. 1. vs. R/W% (Ch = 4%, OCh = 2%), vs. R/W% (Ch = 1%, OCh = 2%). The data replication problem as presented in Section 2 is an extension of the classical file allocation problem (FAP). Chu [13] studied the file allocation problem with respect to multiple files in a multiprocessor system. Casey [11] extended this wor by distinguishing between updates and read file requests. Eswaran [16] proved that Casey s formulation was NP complete. In [25] Mahmoud et al. provide an iterative approach that achieves good solution quality when solving the FAP for infinite site capacities. A complete although old survey on the FAP can be found in [15]. Apers [4] considered the data allocation problem (DAP) in distributed databases where the query execution strategy influences allocation decisions. Bellatreche et al. [8] proposed an iterative approach to allocate rules and data in distributed deductive databases (rule allocation problem RAP), while Kwo et al. [33] proposed several algorithms to solve the data allocation problem in distributed multimedia databases (without replication), also called as video allocation problem (VAP). Most of the research papers outlined in [15], aim at formalizing the problem as an optimization one, sometimes using multiple objective functions. Networ traffic, throughput of servers and response time exhibited by users are considered for optimization. Although a lot of effort was devoted in providing comprehensive models, little attention was paid in proposing good heuristics to solve an often NPhard problem. Furthermore access patterns are assumed to remain static and solutions in the dynamic case are obtained by reexecuting a perhaps time consuming linear programming technique. Some on-going wor is related to dynamic replication of objects in distributed systems when the read-write patterns are not nown a priori. Awerbuch s et al. wor in [6] is significant from a theoretical point of view, but the adopted strategy that before commuting an update replicas of the object must be deleted, can prove difficult to implement in a real-life environment. In [35] Wolfson et al. proposed an algorithm which leads to optimal single file replication in case of a tree networ. The performance of the scheme for general networ topologies is not clear though. Dynamic replication protocols were also considered under the Internet environment. Heddaya et al. [21], proposed a protocol that load balances the worload among replicas. It burdens, however, routers with eeping trac of the replicas. In [29] Rabinovich et al. proposed a protocol for dynamically replicating the contents of an internet service provider ISP so as to improve the client-server proximity without overloading any of the servers. However, the update cost was not included, while the use of threshold values is liely to mae the performance sensitive to their values.

15 1284 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) Taing into account the more pragmatic scenario in today s distributed information environments, we decided to tacle the case of allocating replicas so as to minimize the networ traffic under storage constraints with read from the nearest and update through the primary site policies. Recently genetic algorithms have been used for various optimization problems including multiprocessor scheduling [32], graph partitioning [12], tas mapping [34] and multiprocessor document allocation [17]. We tae advantage of their capability to explore fast and efficient the solution space of a problem in order to design static and adaptive algorithms for data replication. The main merits of using a genetic algorithm approach in the dynamic case lies in the proposed adaptive GA that uses existing nowledge about replica distribution in order to quicly define a new scheme. 7. Conclusions In this paper, we addressed the data replication problem and developed a cost model, which is applicable to large distributed systems. We proposed a greedy algorithm to solve the problem. Having obtained initial solutions from our greedy approach, we designed a genetic algorithm. We evaluated both approaches and assessed the trade-off between running time/solution quality. Experimental analysis illustrated that the GA design constantly outperforms the greedy method in terms of solution quality. On the other hand SRA is much faster than GRA. Moreover, for small and medium sized networs SRA s performance is comparable to that of GRA. However, for an environment where static algorithms are less than useful, we propose AGRA which adapts to the changing environment very quicly and readjusts the replication scheme with solutions that are comparable to static algorithms. Therefore, AGRA combined with the mini_gra is the ultimate choice in a dynamic environment. References [1] M. Abrams, C. Standridge, G. Abdulla, S. Williams, E. Fox, Caching Proxies: Limitations and Potentials, Electronics Proceedings of the Fourth World Wide Web Conf 95: The Web Revolution, Boston MA, December 11 14, [2] T. Anderson, Y. Breitbart, H.F. Korth, A. Wool, Replication, consistency and practicality: are these mutually exclusive?, ACM SIGMOD 98, Seattle, June [3] D. Agrawal, A.J. Bernstein, A nonblocing quorum consensus protocol for replicated data, IEEE Trans. Parallel Distributed Systems 2(2), (April 1991), [4] P.M.G. Apers, Data allocation in distributed database systems, ACM Trans. Database Systems 13(3), (September 1988), [5] M.F. Arlitt, C.L. Williamson, Internet Web Servers: Worload Characterization and Performance implications, IEEE/ACM Trans. Networing 5(5), (October 1997), [6] B. Awerbuch, Y. Bartal, A. Fiat, Optimally-competitive distributed file allocation, 25th Annual ACM STOC, Victoria, BC, Canada, 1993, pp [7] M. Baentsch, L. Baum, G. Molter, S. Rothugel, P. Sturm, Enhancing the web infrastructure from caching to replication, IEEE Internet Comput. (March April 1997), [8] L. Bellatreche, K. Karlapalem, L. Qing, An Iterative Approach for Rules and Data Allocation in Distributed Deductive Database Systems, in Seventh International Conference on Information and Knowledge Management (ACM CIKM 98), Washington DC, November 1998, pp [9] T. Berners-Lee, R. Cailliau, A. Luotonen, H. Nielsen, A. Secret, The world-wide web, Comm. Assoc. Comput. Mach. 37(8), (August 1993), [1] A. Bestavros, WWW traffic reduction and load balancing through server-based caching, IEEE Concurrency: Special Issue on Parallel and Distributed Technology, vol. 5, January March 1997, pp [11] R.G. Casey, Allocation of copies of a file in an information networ, Proceedings of the Spring Joint Computer Conference, IFIPS, 1972, pp [12] R. Chandraseharam, S. Subhramanian, S. Chaudhury, Genetic algorithm for node partitioning problem and applications in VLSI design, IEE Proc., 14(5), (September 1993), [13] W.W. Chu, Optimal file allocation in a multiple computer system, IEEE Trans. Comput. C-18 (1) (1969) [14] K.A. DeJong, W.M. Spears, An analysis of the interacting roles of population size and crossover in genetic algorithms, Proceedings of the First Worshop Parallel Problem Solving from Nature, Springer, Berlin 199, pp [15] L.W. Dowdy, D.V. Foster, Comparative models of the file assignment problem, ACM Comput. Surveys 14(2) (June 1982), [16] K.P. Eswaran, Placement of records in a file and file allocation in a computer networ, Inform. Process. (1974) [17] O. Frieder, H.T. Siegelmann, Multiprocessor document allocation: a genetic algorithm approach, IEEE Trans. Knowledge Data Eng. 9(4), (July/August 1997), [18] D.E. Goldberg, Genetic algorithms in search, optimization and machine learning, Addison-Wesley, Reading, MA, [19] J.J. Grefenstette, Optimization of control parameters for genetic algorithms, IEEE Trans. Systems Man and Cybernetics SMC-16(1), (January/February 1986), [2] J.S. Gwertzman, M. Seltzer, The case for geographical push-caching, Proceedings of the Fifth Worshop on Hot Topics in Operating Systems (HotOS-V), IEEE Computer Society Press, Los Alamitos, CA., 1995, pp [21] A. Heddaya and S. Mirdad, WebWave: globally load balanced fully distributed caching of hot published documents, in Proceedings of the 17th International Conference on Distributed Computing Systems. [22] J.H. Holland, Adaptation in natural and artificial systems, University of Michigan Press, Ann Arbor, MI, [23] T. Louopoulos, I. Ahmad, Replicating the contents of a WWW Multimedia Repository to Minimize Download Time, IPDPS, Cancun, Mexico, May 2. [24] T. Louopoulos, I. Ahmad, Static and adaptive data replication algorithms for fast information access in large distributed systems, IEEE International Conference on Distributed Computing Systems, Taipei, Taiwan, 2. [25] S. Mahmoud, J.S. Riordon, Optimal allocation of resources in distributed information networs, ACM Trans. Database Systems 1(1) (March 1976), [26] S. Martello, P. Toth, Knapsac Problems: Algorithms and Computer Implementations, Wiley, Interscience Series in Discrete Mathematics and Optimization, New Yor, 199. [27] J. Mogul, Networ behavior of a busy Web server and its clients, Research Report 95/5, DEC Western Research, Palo Alto CA, [28] Networ Appliances NetCache, White paper at: [29] M. Rabinovich, I. Rabinovich, R. Rajaraman, A. Aggarwal, A dynamic object replication and migration protocol for an Internet

16 T. Louopoulos, I. Ahmad / J. Parallel Distrib. Comput. 64 (24) hosting service, IEEE International Conference on Distributed Computing Systems, May [3] M. Rabinovich, O. Spatsche, Web Caching and Replication, Addison-Wesley, 22. [31] H. Scwefel, Evolution and Optimum Seeing, Wiley, New Yor, [32] Yu-Kwong Kwo, I. Ahmad, Efficient scheduling of arbitrary tas graphs to multiprocessors using a parallel genetic algorithm, J. Parallel Distributed Comput. 47(1), (November 1997), [33] Y.K. Kwo, K. Karlapalem, I. Ahmad, N.M. Pun, Design and Evaluation of data allocation algorithms for distributed database systems, IEEE J. Selected Areas Comm. (Special Issue on Distributed Multimedia Systems), 14(7) (September 1996) [34] L. Wang, H. J. Siegel, V.P. Roychowdhury, A genetic-algorithmbased approach for tas matching and scheduling in heterogeneous computing environments, Proceedings of the Fifth Heterogeneous Computing Worshop, 1996, pp [35] O. Wolfson, S. Jajodia, Y. Huang, An adaptive data replication algorithm, ACM Trans. Database Systems 22(4), (June 1997). [36] S.P. Bradley, A.C. Hox, T.L. Magnanti, Applied Mathematical Programming, Addison-Wesley, Reading, MA, [37] [38] G.K. Zipf, Human Behavior and the Principle of Least-Effort, Addison-Wesley, Cambridge, MA, [39] P. Barford, A. Bestavros, A. Bradley, M. Crovella, Changes in Web client access patterns: Characteristics and caching implications, WWW J 2 (1) (1999) Ishfaq Ahmad received a Ph.D. degree in Computer Science from Syracuse University, New Yor, USA, in His recent research focus has been on developing distributed multimedia systems, video compression techniques, scheduling and mapping algorithms for scalable architectures, heterogeneous computing systems, and web management. His research wor in these areas is published in over 15 technical papers in refereed journals and conferences, with best paper awards at Supercomputing 9 (New Yor), Supercomputing 91 (Albuquerque), and 21 International Conference on Parallel Processing (Spain). He is currently a full professor of Computer Science and Engineering in the CSE Department of the University of Texas at Arlington. Prior to joining UT Arlington, he was an associate professor in the Computer Science Department at HKUST in Hong Kong. At HKUST, he was also the director of the Multimedia Technology Research Center, an officially recognized research center that he conceived and built from scratch. The center commercialized several of its technologies to its industrial partners worldwide. He has been on the program committee of more than 5 international conferences and is an Associate Editor of Cluster Computing, Journal of Parallel and Distributed Computing, IEEE Transactions on Circuits and Systems for Video Technology, IEEE Concurrency, and IEEE Distributed Systems Online. Thanasis Louopoulos received his Diploma in Computer Engineering and Informatics from theuniversity of Patras, Greece, in He was awarded a Ph.D. degree in Computer Science by the Hong Kong University of Science and Technology (HKUST) in 22. After receiving his Ph.D. he wored as a Visiting Scholar in HKUST. Currently, he is doing his military service. His research areas of interest include content distribution networs, P2P systems, and web services.