Iterative Grid-Based Computing Using Mobile Agents

Transcription

1 Iterative Grid-Based Computing Using Moile Agents Hairong Kuang, Luomir F. Bic, Michael B. Dillencourt Information and Computer Science University of California, Irvine, CA , USA fhkuang, ic, Astract We descrie an environment for the distriuted solution of iterative grid-ased applications. The environment is uilt using the MESSENGERS moile agent system. The main advantage of paradigm-oriented distriuted computing is that the user only needs to specify applicationspecific sequential code, hile the underlying infrastructure takes care of the parallelization and distriution. The to paradigms discussed in this papers are the finite difference method, and individual-ased simulation. These paradigms present some interesting challenges, oth in terms of performance (ecause they require frequent synchronized communication eteen nodes) and in terms of repeataility (ecause the mapping of the user space onto the netork may change due to load alancing or due to changes in the underlying logical netork). We descrie their use, implementation, and performance ithin a moile agent-ased environment. Keyords: moile agents, programming paradigms, gridased computing, finite difference methods, individualased simulations 1. Introduction Developing distriuted application is significantly more difficult than developing sequential applications. Paradigmoriented distriuted computing greatly simplifies the task of distriuted computing. It makes use of the computation and communication skeletons, hile the application programmer only has to provide the application-specific components. The advantage of this approach is that it hides the details of distriuted computing such as task partitioning, communication, and synchronization. We have uilt a paradigm-oriented distriuted computing environment on top of the MESSENGERS moile agent infrastructure [2, 3]. The autonomous migration aility of agents makes them capale of utilizing a dynamically changing netork. Their inherent portaility allos them to handle the distriution of tasks in a heterogeneous environment in a transparent manner. Agent moility can also e exploited for load alancing and fault tolerance. Because of these features, moile agents lend themselves naturally to paradigm-oriented distriuted computing. In previous research, e investigated three common paradigms: ag-of-tasks, ranch-and-ound, and genetic programming [9, 10]. The reason for choosing those paradigms as that applications that fit those paradigms can e easily divided into multiple, highly independent tasks. In the ag-of-tasks paradigm, there is no communication at all eteen tasks. In the ranch-and-ound and genetic-programming paradigms, exchanges of information eteen tasks are non-essential communications,in the sense that they do not affect the correctness although they may e quite useful for optimization purposes. In this paper, e investigate more complicated paradigms in the area of iterative grid-ased computing. Iterative grid-ased applications are suitale candidates for distriuted computing. They usually require large amounts of computation, hich makes it orth distriuting tasks over multiple computers. Spatially oriented computations make it easy to partition the simulation space. Near neighor computations demand only near neighor communications, hich reduces the communication cost. The paradigms e investigated are the finite difference method for solving partial differential equations [14] and spatially oriented individual-ased simulations in hich the ehavior of entities is ased solely on their interactions ith neary entities [13]. Unlike the three paradigms discussed in [9, 10], iterative grid-ased paradigms require frequent synchronized communications that are also essential communications, meaning that they are necessary for correctness. The presence of essential communications increases the challenge of providing a distriuted implementation ith reasonale performance characteristics. In this paper, e descrie an implementation that addresses that challenge. We descrie the to iterative paradigms in detail in Section 2, and then present, in Section 3, the underlying implementation using

2 1. FDM() f 2. doule vals1[xsize][ysize], vals2[size][ysize]; 3. doule *oldvals, *nevals; 4. doule 4X = XLEN/XSIZE, 4Y = YLEN/YSIZE; 5. // initialization 6. for ( every element hx, Yi ) f 7. vals1[x][y] = Init(X,Y,XSIZE, YSIZE, 4X, 4Y); 8. g 9. oldvals = vals1; 10. nevals = vals2; 11. // iterative computation 12. until ( Termination condition ) f 13. for ( every element hx, Yi ) f 14. nevals[x][y] = Compute( X, Y, oldvals, 4X, 4Y, 4t); 15. g 16. nevals $ oldvals; 17. g 18. // output 19. for ( every element hx, Yi ) f 20. WriteResult( outfile, X, Y, oldvals ); 21. g 22. g Figure 1. The finite difference paradigm specification MESSENGERS. Performance results are discussed in Section Paradigms 2.1. Finite difference paradigm The finite difference method [14] is a common approach for solving differential equations. In the finite difference method, e have a discrete d-dimensional grid of element locations, and e ant to compute a value ux;t at each grid location x and for a regular sequence of times t. The value of ux;t+4t is a function of ux;t and the values of u at the neighors of x at time t. Figure 1 shos the structure of the finite difference paradigm for a 2D prolem. The algorithm starts y initializing the values of all elements (lines 6 8), and pointers to element uffers (lines 9 10). It then repeatedly computes the ne values of all elements for each time step until the termination condition is satisfied (lines 12 17). In each iteration of the computation, the value of each element gets updated (lines 13 15), and the pointers to the to element uffers are sapped (line 16). Finally, element values are ritten into the output file (lines 19 21). Specifying a finite difference paradigm prolem requires four functions. 1. Init: this is the initialization function that initializes the value of each element. 2. Termination condition: this specifies the criteria for terminating the computation. A fe special termination condition routines are provided, such as terminating after a user-specified numer of iteration or terminating hen the L 1, L 2,or L1 difference eteen successive arrays of grid values is elo a userspecified tolerance. 3. Compute: this is the main function of the paradigm. Given its on value and its neighors values in the previous time step, it ill produce the ne value for the current time step. 4. WriteResult: this is an output function, hich rites the value of an element to an output file. In addition, users need to specify several parameters. The geometry parameters include the dimension of the grid, the numer of nodes (SIZE) in each dimension, the length (LEN) of each dimension, and hether the grid is toroidal or not. The time interval (4t) is also required, as are parameters required y the termination condition. These parameters are specified through a graphical user interface, hich is an extension of the interface descried in [9] Individual-Based Simulation Paradigm Individual-ased simulation programs are idely used to simulate the ehaviors of a collection of entities, for example, the movements of molecule particles [5], the schooling ehavior of fish or irds [7, 13], and the evolution of an ecology environment [6]. The simulated entities move in a specified space over a period of time. At each time step, an entity decides its on ehavior y interacting ith its neary environment and surrounding entities. Typically, an entity has an associated radius of visiility, and its ehavior is affected only y entities ithin this radius. The state of an environment may include information, such as the temperature, the speed of a current, the amount of food, or the shape and the size of an ostacle. The state of an entity may include its position, moving speed, moving orientation, age, and so on. The individual-ased simulation paradigm is similar in several respects to the finite difference paradigm. First, in oth paradigms, the simulated space is partitioned into a grid. Secondly, oth are time-dependent iterative computations. Lastly, oth are near-neighor computations: the computation on each grid cell depends on only the states of the neighoring grid cells. Nevertheless, these to

3 paradigms also have differences. The finite difference computation is static, hile the individual-ased simulation is dynamic. In a finite difference computation, each grid has only one element, hich is not moving. In an individualased simulation, each grid cell has zero or more entities, moving around and interacting ith the environment and ith each other. A typical individual-ased simulation program starts y initializing the environment and the entities and then repeatedly executing simulation steps. In each step, the state of each entity and the state of the environment are updated. The state of each entity is updated ased on its surrounding environment and its interactions ith neary entities, all of hich lie ithin its radius of visiility. As a result of these interactions, an entity may move to a ne position, ne entities may e spaned, and old entities may e killed or die. Variants of the individual-ased simulation paradigm arise depending on ho the collision prolem is handled. This prolem arises ecause entities share resources (including space), and hence must contend for resources. For example, to entities may move to the same position, their paths may intersect, or they may decide to eat the same food. Collision detection and resolution is an important issue in individual-ased simulation. Our individual-ased simulation paradigm supports to frameorks of collision detection and resolution: the immediate state update method and the delayed state update method. In the delayed state update method, each entity makes a tentative decision ased on the old state of the previous time step. After all the entities are finished, possile collisions are detected and resolved. The advantage of the delayed state update method is that the decision making is easy, ut the collision detection and resolution are complicated, and sometimes ill cause a domino effect. An individual-ased simulation program using the delayed state update method needs to keep to sets of states. The old state stores the snapshot of the simulated space and the entities at the end of the previous time step, hile the current state stores the snapshot in the current time step. The structure of individual-ased simulation programs using the delayed state update method is very similar to that of finite difference programs, hich can e deduced in a straightforard ay. We omit its details here. In the immediate state update method, each entity makes a collision-free decision ased on the current state. After an entity s on state and its surrounding environment are updated, the old states are thron aay. Because an entity uses the most current states, collision detection and resolution is much easier to conduct. Collision detection and resolution can e comined ith the process of state update, so that a gloal collision detection and resolution stage is no longer needed. The immediate state update method requires less memory compared to the delayed state update method since the old state does not need to e kept. Figure 2 shos the structure of the individual-ased simulation paradigm using the immediate state update method. It solves a 2D prolem. First, the environment and all the entities get initialized (line 8 16). The hile loop (line 17 31) is the main ody of the program, hich simulates the ehavior of entities for a fixed numer of iterations. At each iteration, all the entities update their states separately (line 20 26). The program keeps only the most current state. Before an entity s state is updated, it is dequeued (line 21). The entity s state is modified in place and the environment is updated incrementally (line 23). An entity can detect and resolve possile collisions hile updating its state. Any updating of the environment that is independent of the effect of the entities is performed on lines The individual-ased simulation paradigm is quite complicated and even has many variants. Hoever, the details of the paradigm can e hidden from users. Specifying an individual-ased simulation application requires specifying only four functions: 1. neenv: this initializes the environment in a grid cell. 2. neentity: this initializes an entity. 3. updateentity: this updates the state of an entity at a time step. 4. updateenv: this updates the state of an environment on a grid cell at a time step. Users also need to specify the geometry of the simulation space. XLEN is the idth of the space, hile YLEN is the length of the space. XSIZE is the numer of grid cells at dimension x, hile YSIZE is the numer of grid cells at dimension y. 4t is the time interval eteen time steps. NUM OF ENTITIES is the initial numer of entities in the space. MAX TIME STEPS specifies the numer of simulation steps. R is the radius of visiility for an entity; this must e smaller than oth XLEN/XSIZE and YLEN/YSIZE. In addition, to data structure definitions must e provided, one descriing an environment (Env), the other descriing an entity (Entity). The data structures are defined y the user, ut the Entity structure must include the folloing fields: f g long id; doule x; doule y;

4 1. IBS() f 2. Env env[xsize][ysize]; 3. School entitygroup[xsize][ysize]; 4. School *entitylist; 5. Entity entities[num OF ENTITIES]; 6. Entity *curentity; 7. doule 4X=XLEN/XSIZE, 4Y=YLEN/YSIZE; 8. // initialize fish school and environment 9. for ( all the grid cell hi, ji )f 10. neenv( &env[i][j], i, j, XSIZE, YSIZE, 4X, 4Y); 11. neentitylist( &entitygroup[i][j] ); 12. g 13. for( i=0; i<num OF ENTITIES; i++ ) f 14. neentity(&entities[i], i ); 15. add entity i to the corresponding current grid cell; 16. g 17. // iterative simulation 18. hile( t<max TIME STEPS ) f 19. t++; 20. for ( each grid cell hi, ji ) f 21. hile( (curentity = popentity( &entitygroup[i][j] ))!= NULL ) f 22. entitylist = getneighors( curentity, entitygroup, R); 23. hentitylist; envi = updateentity( t, curentity, env, entitylist, 4X, 4Y, 4t ); 24. add each entity in entitylist to entitygroup; 25. g 26. g 27. for ( each grid cell hi, ji ) f 28. entitylist = updateenv( t, &env[i][j], i, j, 4X, 4Y, 4t ); 29. add each entity in entitylist to entitygroup; 30. g 31. g 32. g Figure 2. The individual-ased simulation paradigm specification The field id contains an identifier hich uniquely identifies an entity. The fields x and y specify the position of the entity in the 2-D simulated space. The visiility of these to fields allos the system to transparently manage entity lists. The entity list management issue is common to all the individual-ased simulation applications and also independent of specific applications. When an entity adjusts its position, e need to kno if it has moved out of the current grid cell. If the entity has moved out of the grid, it ill e deleted from the old list and added to a ne list. In our individual-ased simulation paradigm, e provide an entity list management lirary, hich includes a data structure descriing an entity list, and a list of operations to manipulate an entity list. For example, getneighors() function returns a list of entities ithin a specific radius of a given entity, neentitylist() creates an empty entity list ith a default size, AddEntity() adds an entity to an existing entity list, and PopEntity() pops the first entity from an entity list. Functions are also provided to navigate an entity list. These entity list operations can e called y the user-defined functions. 3. Implementation of Paradigms Using MES- SENGERS 3.1. Finite difference paradigm Meeting room (a) Meeting room i r r () r Figure 3. Logical netork for the finite difference paradigm in MESSENGERS System Figure 3(a) shos a logical netork to support the distriuted implementation of the finite difference paradigm. Each node represents a place to hich a messenger can hop. The Meeting room node is here the tolerance is gathered and computed. If the termination condition is satisfied, a termination notification ill e sent to all the nodes. An node is here the element values assigned to the node get iteratively updated. At each iteration, a ne value for each of the elements is computed, and oundary information is exchanged ith its neighors hen

5 all the oundaries ecome osolete. The nodes can e connected either as a to-dimensional grid (as shon in the figure) or as a ring, depending on ho the user grid is partitioned. If the user grid is partitioned into strips, the nodes are connected as a ring. The advantage of this type partition is that each partition has only to neighoring strips, hich simplifies the oundary exchange and synchronization. If the user grid is partitioned into rectangular locks, the nodes are connected as a 2D grid. The advantage of this partition technique is that each partition exchanges less oundary message ith its neighors. Figure 4. The structure of a rectangular partition The implementation uses four types of messengers as shon in Figure 3(). The initialization messenger (i) uilds the logical netork and injects the orker () messengers into offices, one per office. Each orker messenger initializes its partition and starts oundary messengers (). Then each partition is repeatedly updated y the orker messenger and the oundary messengers until the termination condition is satisfied. Figure 4 shos a structure of a partition hen the user grid is partitioned into rectangular locks, in hich the light gray area is the ghost oundary, the dark gray area is the oundary of the partition, and the hite area is the inner part of the partition. At each iteration, the orker messenger updates the grid cells in the hite area, hich do not depend on the values of the grid cells in the neighoring partitions. Each partition has eight oundary messengers, one per side and one per corner. Each oundary messenger alternates eteen to neighoring nodes. At each iteration, a oundary messenger updates the grid cells on the portion of the oundary it takes care of. It then carries its oundary information, hops to a neighoring, and deposits the data at the ghost oundary. At the next step, it orks at the neighoring node, updates a portion of its oundary, and then carries the oundary information ack to the departure node. Each node also has a messenger that gathers the tolerance information at the end of each iteration and carries it to the Meeting room. These are called report messengers (r). Once all the ant messengers have carried their information to the meeting room, the tolerance is computed. If the termination condition is met, the ant messenger ill hop ack to its and notify the orkers. The aove implementation uses several strategies to improve the performance. In principle, it attempts to update each oundary and send it to its neighor as early as possile. In this ay the communication and computation can e overlapped, and the idle aiting time can e avoided. At the eginning of each iteration, the orker messenger sends out a signal, hich akes up incoming oundary messengers and allos them to update the oundary and carry the oundary data to its neighoring node. Hoever, if some of the neighoring nodes are sloer and the oundary messengers have not arrived yet, the orker messenger does not ait for the sloer nodes. Instead it goes ahead and updates the inner part of the partition, ut it interrupts itself periodically to give late incoming oundary messengers a chance to ork. As a result, it eliminates the necessity of a arrier at each step, and therefore squeezes out the idle aiting time Individual-ased simulation paradigm Our distriuted implementation of the individual-ased simulation paradigm is similar to that of the finite difference paradigm, reflecting the similarities in the paradigms themselves. They have the same possile logical netorks and similar types of messengers, and near neighor oundary exchange is also required for each time step. One major difference arises ecause of the dynamic migration of the entities in individual-ased simulations. Because of this migration, near-neighor communication in the distriuted implementation requires to steps: first the emigrating entities move to the neighoring nodes, then the oundary information is exchanged. Another difference arises ecause of the more dynamic nature of the individual-ased simulation paradigm. In the finite difference paradigm, once the partition of the user grid is fixed, the load on each machine and the message size exchanged remains constant for the duration of the simulation. In the individual-ased simulation paradigm, ecause entities are moving in the space, the load on each machine and the message sizes are dynamically changing. Our implementation of the individual-ased simulation paradigm supports the same logical netork structures as in the individual-ased simulation paradigm. The Meeting room node is here the positions of all the entities are gathered and sent to the client to e visualized. An node is here a orker iteratively updates the states of the entities and environment assigned to the node. At each time step, a orker updates entities and environments, sends the

6 entities migrating to the neighoring spaces aay, and exchanges oundary information. The system has three types of messengers. The initialization messenger (i) uilds the logical netork and injects the orker () messengers into offices, one per office. Each orker messenger initializes its partition. It then repeatedly updates its grid cell until the termination condition is satisfied. At each iteration, it receives its neighors oundaries, computes entities ne states, sends emigrating entities to its neighors, receives immigrating entities, and sends the oundary to its neighors. A shuttle messenger (s) carries emigrating entities to its neighoring node and rings the neighor s oundary ack. An important issue in moile agent-ased implementations of individual-ased systems is the representation of migrating entities. In [2], each entity is represented as a separate agent. This allos an entity to freely migrate to its destination, ut it means that each migrating entity is a separate hop of an agent from one node to another. In our implementation, e use shuttle agents that synchronously carry dynamic clusters of entities from one node to another. This is argualy a less natural ay to address entity migration, ut it decreases netork traffic consideraly and hence increases performance and scalaility consideraly. What is really needed is an increase in the numer of agents that can hop in a short period of time ithout degrading system performance. Some ork in this direction is descried y Fukuda et al. [4] Repeataility An important goal of a simulation is repeataility: a user should have the option of rerunning a simulation and otaining exactly the same results. This can e very important for validating changes made at the application level or for tracking don elusive application ugs. Achieving repeataility in distriuted implementations presents some interesting challenges, due to the repartitioning of the user grid (i.e., changes if the mapping of the user grid onto the logical nodes). Repartitioning may occur ithin a run due to load alancing, and it may also occur from one run to another if the user runs the same simulation ut changes the configuration (e.g., changes the logical netork or the numer of machines). One issue that must e addressed to achieve repeataility is random numer generation. In order for to simulations to achieve the same result, the random choice made during the second run must e exactly the same as the corresponding random choice made during the first run. This can e achieved in various ays: for example, a stream of random numers can e associated ith each entity, or a stream of random numers can e associated ith each user grid cell. The paper [11] contains a comparison of these to approaches and a fe others as ell. The second issue that affects repeataility is the order in hich entities are processed. This order affects the result of the simulation hen the immediate state update method is used. We introduce an odd-even laeling scheme to specify a particular order in hich entities are updated. This scheme ensures that entities are processed in the same order, irrespective of the partitioning of the user grid. The scheme orks as follos: e lael each user grid cell ith its index (x; y), and then lael the cell ith a numer in the range 0 3. The lael is 0 if oth x and y are even, 1ifx is even and y is odd, 2 if x is odd and y is even, and 3 if oth x and y are odd. At each time step, e update the states of all entities located at user grid cells ith a particular lael (starting ith 0) efore proceeding on the next lael. The odd-even scheme is shon in Figure 5. In order to make this laeling scheme ork correctly, the oundary exchange eteen neighoring partitions needs to e expanded, and a condition must e imposed on the size of the user grid. The reason for the expanded oundary exchange is illustrated in Figure 5. The hite area is the collection of user cells that are allocated to the machine, and the gray area is the ghost oundary (i.e., the oundary data otained from the neighor as part of the oundary exchange). In order to correctly update the cell ith lael 3 in the loer left corner of the area allocated to the machine, e must have the updated contents of the cell ith lael 2 immediately elo it, hich in turn requires the cell ith lael 1 elo it and to its left, hich in turn requires the cell ith lael 0 elo it. To update this last cell, e need all its neighors. It is not hard to see that this example implies that to correctly update the hite area in all cases, the exchanged oundary must consist of a layer of 4 cells around the hite area. In other ords, this scheme requires expanding the size of the exchanged oundary y a factor of 4. Figure 5. Distriuted odd-even individualased simulation paradigm

7 The odd-even laeling scheme represents a coloring of the user grid in the graph-theoretical sense, namely that to cells that touch, either along an edge or at a corner, are assigned different laels. In fact, if to entities are located in to different grid cells that are assigned the same lael, the distance eteen them is at least as large as the length of the shortest side of a grid cell. In a typical individualased system model, there are parameters rv and rm, hich respectively represent the radius of visiility and the radius of motion. An entity s ehavior in a time step can only e affected y another entity if the second entity is ithin a distance of rv of the first, and an entity can move a distance of at most rm in one time unit. Generally it is assumed rm» rv. It must e true that the length of a user cell must e at least rv (note that this is enforced as descried in Section 2.2). If e strengthen this constraint y requiring that the length of the shortest side a user grid cell is at least (rv+rm), then an entity in a grid cell cannot affect an entity in a different grid cell ith the same lael. Hence, ith this strengthened constraint, the odd-even laeling scheme ill guarantee repeataility hen the immediate-update method is used. 4. Performance Evaluation 4.1. Finite difference paradigm We tested the finite difference paradigm using Metropolis Monte Carlo algorithm, hich solves the Ising model [1, 8]. The Ising model is one of the pillars of statistical mechanics. It consists of an array of spins hich can e pointing up or don, and interact ith neighoring spins. Each spin and its neighoring spins have an energetic preference to e the same value. Energy is given y E = JX i6=j SiSj here S is equal to +1 or -1 as spin state, hi; ji are nearest neighors, and J is the interaction strength. The Metropolis Monte Carlo algorithm uses Boltzman s rejector for energy fluctuation. In our experiments, the simulated space is a 2-D toroidal grid, of hich spin states are initialized randomly and changed for 500 steps. At each step, each spin makes a tentative flip and uses Boltzman s rejector to decide if this change is accepted or not. We varied the grid size to see ho the prolem size influenced the speedup. Figure 6 shos the speedup of the distriuted finite difference programs running on 9 machines. The horizontal axis represents the size of the user grid, hile the vertical axis represents the speedup, hich is the ratio of the execution time of the distriuted programs running on 1 machine Speedup Rectangular partition Strip partition 540x x x x x2250 Prolem size Figure 6. Performance of the distriuted finite difference programs running on 9 machines to the execution time of the distriuted program running on 9 machines. The figure shos that the speedup of the distriuted programs increases as the user grid size increases. This is ecause a program ith a larger user grid has a larger program size, hich represents a igger computation-tocommunication ratio. We can also see that programs ith a rectangular partition consistently have etter speedup than those ith a strip partition. This is ecause programs ith a rectangular partition have a smaller oundary than programs ith a strip partition. Therefore, programs ith a rectangular partition has smaller amount of communication data, hich leads to a etter speedup. execution time (s) interrupt rate = 0 interrupt rate = 1 interrupt rate = 2 interrupt rate = 3 540x x x x1350 prolem size Figure 7. Performance of the distriuted finite difference programs running on 9 machines hen interrupt rate varies In our implementation of the distriuted finite difference paradigm, the orker messenger interrupt itself periodically to give oundary messengers a chance to ork. Another type of experiments has een performed to see ho the interrupt rate influences the performance. We use programs ith a rectangular partition since they have a etter speedup.

8 Figure 7 shos the performance of the distriuted finite difference programs running on 9 machine hen the interrupt rate varies. The horizontal axis represents the size of the user grid, hile the vertical axis represents the execution time in seconds. Different lines represent the performance of the programs ith different interrupt rates. When the interrupt rate is equal to zero, the orker messenger does not interrupt itself during its computation at each iteration, hile hen the interrupt rate, denoted as r, is greater than zero, the orker messenger interrupts itself r times. The figure shos that the performance of the distriuted programs improves as the interrupt rate increases no matter the size of the program size. When the interrupt rate increases from zero to one, the performance improves the largest. As the interruption gets more frequent, the performance still improves ut not as significant. This is ecause the interruption of a computation rings extra context sitch cost Individual-ased simulation paradigm We tested the individual-ased simulation paradigm using a fish schooling model descried in [7]. This model assumes a 2-dimensional space here each fish periodically adjusts its position and velocity y coordinating its movement ith up to four of its neighors. We tested the paradigm using oth the delayed state method and the oddeven immediate state update method. To make the programs using these to methods comparale, e made a fe changes to the fish schooling model. After each fish calculates its ne velocity y coordinating ith its neighors, it ill discard the effort and adjust its position y moving a random angle. As a result, each fish moves around independently. Whatever method is used, each fish ill move at the same trace, hich guarantees the amount of computation ill e the same. The simulation space is a 2- dimensional 300 y 300 toroid in hich fish move as a single school of fish for 500 simulation steps. The positions of all the fish are logged in output files. Because of the uncertainty of distriuted programs, e run each program three times. The execution time presented is the average of three runs. Figure 8 compares the performance of the delayed state update method and the immediate state update method using the odd-even process order. The horizontal axis represents the numer of simulated fish, i.e., the prolem size, hile the vertical axis represents the execution time. The figure shos that the delayed state update method performs etter than the odd-even immediate state update method if run in the distriuted ay. This is ecause the odd-even immediate state update method has larger communication volume. While in the sequential situation, the odd-even immediate state update method runs faster hen the prolem size ecomes larger. This is ecause the odd-even immediate state update method uses less memory compared to the Execution time (s) Fish numer Sequential delayed state state update method Sequential immediate state update method Delayed state update method ith 9 machines Immediate state update method ith 9 machines Figure 8. Performance of the individual-ased simulation programs delayed state update method. Speedup Fish numer Delayed state update method Immediate state update method Figure 9. Speedup for the individual-ased simulation experiments Figure 9 shos the speedup of distriuted fish schooling simulation programs. The horizontal axis represents the numer of simulated fish, hile the vertical axis represents the speedup, hich is the ratio of the execution time of the sequential program to the execution time of distriuted programs hich run on 9 machines. The figure shos that the speedup of the distriuted programs increases as the prolem size increases. This is ecause the computationto-communication ratio increases ith the increase of the prolem size. From the figure, e can also see that the distriuted delayed state update programs have etter speedup than the distriuted odd-even immediate state update programs. This is ecause distriuted odd-even immediate state update programs send and receive four times message size as large as distriuted delayed state update programs each time hen the oundary information is exchanged. Distriuted odd-even programs also need to duplicate redundant computations.

9 Another issue related to the performance of distriuted individual-ased simulation programs is the load imalance on each machine. As e discussed in the previous section of the paper, ecause the simulated entities move around the space, the load on each machine ill dynamically change accordingly. In the experiments e performed, as the fish randomly alks in the space, the load statistically should e alanced. Hoever, in a snap shot of a experiment ith 5000 fish performed on 9 machines, e found the most heavily loaded machine has 622 fish, hile the least loaded machine has 490 fish. The most heavily loaded machine has 25.5% more load than the least loaded machine. Therefore, a load alance scheme hich can dynamically alance the load on each machine ill increase the performance of distriuted individual simulation. Although e did not present the performance of the load-alanced distriuted individualased simulated programs in this paper, our group has investigated the load alance mechanism in [12]. 5. Final Remarks Paradigm-oriented computing simplifies distriuted implementation y providing a coordination layer that insulates the application programmer from the details of the distriuted computation. We have descried the specification and implementation of environments supporting paradigms for solving finite difference equations and simulating individual-ased systems. Our performance evaluations have shon that significant speedups can e achieved on a netork of orkstations, cooperating ith each other using a system of moile agents. [7] A. Huth and C. Wissel. The simulation of the movement of fish schools. Journal of Theoretical Biology, 156: , [8] M. Kalos and P. Whitlock. Monte Carlo Methods, Vol. I. Basics. Wiley, Ne York, [9] H. Kuang, L. F. Bic, and M. B. Dillencourt. PODC: Paradigm-oriented distriuted computing. In Proceedings of the 7th IEEE Workshop on Future Trends of Distriuted Computing Systems (FTDCS 99), pages , Dec [10] H. Kuang, L. F. Bic, and M. B. Dillencourt. Paradigmoriented distriuted computing using moile agents. In Proceedings of the 20th IEEE International Conference on Distriuted Computing Systems (ICDCS 00), pages 11 19, Apr [11] H. Kuang, L. F. Bic, and M. B. Dillencourt. Repeataility, programmaility, and performance of iterative grid-ased computing. Technical report, Information and Computer Science, University of California, Irvine, [12] F. Merchant, L. F. Bic, and M. B. Dillencourt. Load alancing in individual-ased spatial applications. In Proceedings of the International Conference on Parallel Architectures and Compilation Techniques (PACT 98), Oct [13] C. Reynolds. Flocks, herds, and schools: A distriuted ehavioral model. Computer Graphics, 21(4):25 34, July [14] E. F. Van de Velde. Concurrent Scientific Computing. Springer-Verlag, References [1] K. Binder and D. Heermann. Monte Carlo Simulation in Statistical Physics. Springer-Verlag, Berlin, [2] M. Fukuda, L. F. Bic, and M. B. Dillencourt. Messages versus messengers in distriuted programming. Journal of Parallel and Distriuted Computing, 57: , [3] M. Fukuda, L. F. Bic, M. B. Dillencourt, and F. Merchant. Distriuted coordination ith messengers. Science of Computer Programming, 31(2), [4] M. Fukuda, N. Suzuki, L. M. Campos, and S. Koayashi. Programmaility and performance of M++ self-migrating threads. In Proceedings of the 3rd IEEE International Conference on Cluster Computing (CLUSTER 01), Oct [5] L. Greengard and V. Rokhlin. A fast algorithm for particle simulation. Journal of Computational Physics, 73: , [6] G. Hartvigsen and S. Levin. Evolution and spatial structure interact to influence plant-herivore population and community dynamics. In Proceedings of the Royal Society of London, Series B 264, pages , 1997.