Development and execution of an impact cratering application on a computational Grid 1

Impact cratering is an important geological process of special interest in Astrobiology. Its numerical simulation comprises the execution of a high number of tasks, since the search space of input parameter values includes the projectile diameter, the water depth and the impactor velocity. Furthermore, the execution time of each task is not uniform because of the different numerical properties of each experimental configuration. Grid technology is a promising platform to execute this kind of applications, since it provides the end user with a performance much higher than that achievable on any single organization. However, the scheduling of each task on a Grid involves challenging issues due to the unpredictable and heterogeneous behavior of both the Grid and the numerical code. This paper evaluates the performance of a Grid infrastructure based on the Globus toolkit and the GridWay framework, which provides the adaptive and fault tolerance functionality required to harness Grid resources, in the simulation of the impact cratering process. The experiments have been performed on a testbed composed of resources shared by five sites interconnected by RedIRIS, the Spanish Research and Education Network.


Introduction
Impact cratering is an important geological process of special interest in Astrobiology that affects the surface of nearly all celestial bodies such as planets and satellites.The detailed morphologies of impact craters (see [23] for a detailed description) show many variations from small craters to craters with central peaks.Furthermore, a water layer at the target influences lithology and morphology of the resultant crater.Therefore, marine-target impact cratering simulation plays an important role in studies which involve hypothetical Martian seas [22].
Our target application analyzes the threshold diameter for cratering the seafloor of a hypothetical martian sea during the first steps of an impact.Results of this analysis can be used to develop a search criteria for future investigations, including techniques that will be used in future Mars exploration missions to detect buried geological structures using ground penetrating radar surveys, as the ones included in the ESA Mars Express and planned for NASA 2005 missions.The discovery of marine-target impact craters on Mars would also help to address the ongoing debate of whether large water bodies occupied the northern plains of Mars and help to constrain future paleoclimatic reconstructions [22].In any case, this kind of study requires a huge amount of computing power, which is not usually available within a single organization.
In order to determine the range for the critical diameter of the projectile which can crater the seafloor, we will perform a high number of simulations.Each computational task solves the equations of motion for compressible media combined with the equations of state, over a subset of input parameter values, namely: projectile diameter, the water depth and the impactor velocity.Additionally, the execution time of each computational task is not uniform because of the different numerical properties of each experimental configuration.
Grid technology provides a way to access the geographically distributed resources needed for executing compute-intensive Parameter Sweep Applications (PSA), like the one described above.In spite of the relatively simple structure of a PSA, its reliable and efficient execution on computational Grids involves several issues, mainly due to the nature of the Grid itself.In particular, one of the most challenging problems that the Grid computing community has to deal with is the fact that Grids present unpredictable changing conditions, namely: high fault rate and dynamic resource availability, load and cost.Adaptive scheduling has been widely studied in the literature [1][2][3]26,27] and is generally accepted as the cure to the dynamism of the Grid.Moreover, the different execution times for different tasks makes critical the use of an adaptive approach.The GridWay framework [17] achieves the robust and efficient execution of PSAs by combining adaptive scheduling and execution, to reflect the dynamic Grid characteristics; and re-use of common files between tasks, to reduce the file transfer overhead.The aim of this paper is to describe and analyze the results obtained in the simulation of the impact cratering process in a Grid infrastructure based on Globus and GridWay.
In Section 2 we present the highly heterogeneous testbed used in this work.The functionality and internals of the GridWay framework are briefly described in Section 3. The target application is outlined in Section 4. We demonstrate that a Grid testbed based on Globus and GridWay provides the functionality and reliability needed to execute the simulation tasks.The performance results are described in Section 6, where some performance metrics in order to evaluate the Grid computing platform are proposed: the Grid speedup metric, which quantifies the benefits of being part of a Grid, and the resource load variability, which could be used to adjust the components of the Grid infrastructure in order to achieve higher efficiencies.Finally, some conclusions are presented in Section 7.

The research testbed
The management of jobs within the same department is addressed by many research and commercial sys-tems [8]: Condor, Load Sharing Facility, Sun Grid Engine, Portable Batch System, LoadLeveler, etc.Some of these tools, such as Sun Grid Engine Enterprise Edition [16], also allow the interconnection of multiple departments within the same administrative domain.Other tools, such as Condor Flocking [9], even allow the interconnection of multiple domains, as long as they run the same distributed resource management software.However, they are unsuitable in computational Grids where resources are scattered across several administrative domains, each with its own security policies and distributed resource management systems.
The Globus toolkit [10] provides the services and libraries needed to enable secure multiple domain operation within different resource management systems and access policies.Globus is a core Grid middleware that provides the following components, which can be used separately or together, to support Grid applications: Grid Security Infrastructure (GSI), Grid Resource Allocation Manager (GRAM), Global Access to Secondary Storage (GASS), Monitoring and Discovery Service (MDS), GridFTP and Replica Management Services.
Table 1 shows the characteristics of the machines in the research testbed, based on the Globus toolkit 2.X [10].The testbed joins resources from five sites, all of them connected by the Spanish Research and Education Network, RedIRIS.The geographical distribution and interconnection network of sites are shown in Fig. 1.This organization results in a highly heterogeneous testbed, since it presents several resources (PCs, clusters, SMP servers), processor architectures and speeds, Resource Management Systems (RMS), network links, etc.In the following experiments, cepheus is used as client, and holds all the input files and receives the simulation results.In the case of clusters, we have limited to 5 the number of simultaneously used nodes, in order not to saturate these systems since they are at production level.

The GridWay framework
The Globus toolkit [10] supports the submission of applications to remote hosts by providing resource discovery, resource monitoring, resource allocation, and job control services.However, the user is responsible for manually performing all the submission stages in order to achieve any functionality: selection, preparation, submission, monitoring, migration and termination [24,25].Hence, the development of applica-  tions for the Grid continues requiring a high level of expertise due to its complex nature.Moreover, Grid resources are also difficult to efficiently harness due to their heterogeneous and dynamic nature.In a previous work [17], we have presented a new Globus experimental framework that allows an easier and more efficient execution of jobs on a dynamic Grid environment in a "submit and forget" fashion.The GridWay framework provides resource selection, job scheduling, reliable job execution, and automatic job migration to allow a robust and efficient execution of jobs in dynamic and heterogeneous Grid environments based on the Globus toolkit [10].

GridWay architecture
The architecture of the GridWay framework is depicted in Fig. 2. The user interacts with the frame-work through a programming or command line interface, which forwards client requests (submit, kill, stop, resume) to the dispatch manager.The dispatch manager periodically wakes up, and tries to submit pending and rescheduled jobs to Grid resources.Once a job is allocated to a resource, a submission manager and a performance monitor are started to watch over its correct and efficient execution (see [17] for a detailed description of these components).
The framework has been designed to be modular, thus allowing extensibility and improvement of its capabilities.The following modules can be set on a per job basis: -The resource selector module, which is used by the dispatch manager to build a prioritized list of candidate resources following the preferences and requirements provided by the user.-The performance evaluator module, which is used by the performance monitor to periodically evaluate the application performance, usually by analyzing a performance profile generated by the running application or by a monitor started along with the application.

Job execution
Job execution is performed in three steps by the following modules: -The prologue module, which is responsible for creating the remote experiment directory and transferring the executable and all the files needed for remote execution, such as input or restart files corresponding to the execution architecture.These files can be specified as local files in the experiment directory or as remote files stored in a file server through a GridFTP URL.For the files declared by the user as shared, a reference is added to the remote GASS cache, so they can be re-used by other jobs submitted to the same resource.-The wrapper module, which is responsible for executing the actual job and obtaining its exit code.-The epilogue module, which is responsible for transferring back output files, and cleaning up the remote experiment directory.At this point, references to shared files in the GASS cache are also removed.

Grid scheduling policy for PSAs
GridWay achieves an efficient execution of PSAs by combining: adaptive scheduling, adaptive execution, and reuse of common files [19].In fact, one of the main characteristics of the GridWay framework is the combination of adaptive techniques for both the scheduling and execution [18] of Grid jobs: -Adaptive scheduling: Reliable schedules can only be issued considering the dynamic characteristics of the available Grid resources [2,3,6].In general, adaptive scheduling can consider factors such as availability, performance, load or proximity, which must be properly scaled according to the application needs and preferences.GridWay periodically gathers information from the Grid and from the running or completed jobs to adaptively schedule pending tasks according to the application demands and Grid resource status [19].-Adaptive execution: In order to obtain a reasonable degree of both application performance and fault tolerance, a job must be able to migrate among the Grid resources adapting itself to events dynamically generated by both the Grid and the running application [1,20,26].GridWay evaluates each rescheduling event to decide if a migration is feasible and worthwhile [17].Some reasons, like job cancellation or resource failure, make GridWay immediately start a migration process.Other reasons, like "better" resource discovery, make GridWay start a migration process only if the new selected resource presents a higher enough rank.In this case, the time to finalize and the migration cost are also considered [21].-Reuse of common files: Efficient execution of PSAs can only be achieved by re-using shared files between tasks [6,13].This is specially important not only to reduce the file transfer overhead, but also to prevent the saturation of the file server where these files are stored, which can occur in large-scale PSAs.Reuse of common files between tasks simultaneously submitted to the same resource is achieved by storing the executable file and some files declared by the user as shared in the GASS cache [19].
In the case of adaptive execution, the following rescheduling events, which can lead to a job migration if it is considered feasible and worthwhile, are considered [17,18]: -Grid-initiated rescheduling events: * "Better" resource discovery (opportunistic migration [21]).* Job cancellation or suspension.* Resource or network failure.
* Change in the application demands.
In this work, we do not take advantage of all the GridWay features for adaptive execution, since they are not supported by the application.In order to fully support adaptive execution, the application must provide a set of restart files to resume execution from a previously saved checkpoint.Moreover, the application could optionally provide a performance profile to detect performance degradations in terms of application intrinsic metrics, and it could also dynamically change its host requirements and preferences to guide its own scheduling process.We only consider adaptive execution to provide fault tolerance by restarting the execution from the beginning (see the following section).

Fault tolerance
GridWay provides the application with the fault detection capabilities needed in such a faulty environment: -The GRAM job manager notifies submission failures as GRAM callbacks.This kind of failures includes connection, authentication, authorization, RSL parsing, executable or input staging, credential expiration and other failures.-The job manager is probed periodically.If the job manager does not respond, then the GRAM gatekeeper is probed.If the gatekeeper responds, a new job manager is started to resume watching over the job.If the gatekeeper fails to respond, a resource or network failure occurred.This is the approach followed in Condor/G [11].-The standard output of prologue, wrapper and epilogue is parsed in order to detect failures.In the case of the wrapper, this is useful to capture the job exit code, which is used to determine whether the job was successfully executed or not.If the job exit code is not set, the job was prematurely terminated, so it failed or was intentionally cancelled.
When an unrecoverable failure is detected, GridWay retries the submission of prologue, wrapper or epilogue a number of times specified by the user and, when no more retries are left, it performs an action chosen by the user among two possibilities: stop the job for manually resuming it later, or automatically generate a rescheduling event.

Related projects
The AppLeS project [2] has previously dealt with the concept of adaptive scheduling on Grids.AppLeS is currently focused on defining templates for characteristic applications, like APST for parameter sweep and AMWAT for master/worker applications.Also, Nimrod/G [3] dynamically optimizes the schedule to meet the user-defined deadline and budget constraints.On the other hand, the need for a nomadic migration approach for adaptive execution on Grids has been previously discussed in the context of the GrADS project [20].The tools developed by the above projects have been successfully applied to several applications, like drug design with Nimrod/G [4], computational biology with AppLes [5], and numerical relativity with GrADS and Cactus [1].
The aim of the GridWay project is similar to that of the above projects: simplify distributed heterogeneous computing.However, it has some remarkable differences.Our framework provides a submission agent that incorporates the runtime mechanisms needed for transparently executing jobs in a Grid by combining both adaptive scheduling and execution.Our modular architecture for job adaptation to a dynamic environment presents the following advantages: -It is not bounded to a specific class of application generated by a given programming environment, which extends its application range.We would like to mention that the experimental framework does not require new system software to be installed in the Grid resources.The framework is currently functional on any Grid testbed based on Globus.We believe that this is an important advantage because of socio-political issues; cooperation between different research centers, administrators and users is always difficult.

Impact cratering simulations
The impact process can be described as a transfer of energy process.The initial kinetic energy of the projectile does work on the target to create a hole -the crateras well as heating the material of both projectile and target.We focus our attention in high-velocity impacts which can be separated into several stages dominated  by a specific set of major physical and mechanical processes.
The main stages are contact and shock compression, transient cavity growth by crater material ejection, and finally, transient cavity modification.Impact cratering begins with a sufficient compression of target and projectile materials.The energy released by deceleration of the projectile results in the formation of shock waves and its propagation away from the impact point.The projectile's initial kinetic energy redistributes into kinetic and internal energy of all colliding material.The internal energy heats both the projectile and target and, for strong enough shock waves, this may result in melting and vaporization of material near the impact zone.
To describe the impact process we solve equations of motion for compressible media using a hydrocode.The standard set of equations of motion expresses 3 basic law: mass, momentum, and energy conservation.It must be combined with the equations of state (EOS), a system of relationships which allow us to describe the thermodynamic state for materials of interest.In its basic form, an EOS should define what is the pressure in the material at a given density and temperature.In an extended form, an EOS should define also the phase state of the material (melting, vapor, dissociation, ionization process) as well as all useful derivatives of basic parameters and transport properties (sound speed, heat capacity, heat conductivity, etc.).
Numerical simulations use the Eulerian mode of SALE-B, a 2D hydrocode modified by Boris Ivanov based on SALES-2 [12].The original hydrocode, Simplified Arbitrary Lagrangian-Eulerian (SALE), permits to study the fluid-dynamics of 2D viscous fluid flows at all speeds, from the incompressible limit to highly supersonic, with an implicit treatment of the pressure equation, and a mesh rezoning/remapping philosophy [7].The PDE solved are the Navier-Stokes equations.The fluid pressure is determined from an EOS and supplemented with an artificial viscous pressure for the computation of shock waves.SALES-2 can also model elastic and plastic deformation and tensile failure.
We deal in this study with vertical impacts, as they reduce to 2D problems using the radial symmetry.All simulations were conduced with spherical projectiles.The non-uniform computational mesh of the coarse simulations consists of 151 nodes in horizontal direction and 231 nodes in vertical direction and the total nodes describes half of the crater domain because of axial symmetry.The mesh size progressively increases outwards from the center with a 1.05 coefficient to have a larger spatial domain.The central cell region around the impact point where damage is greater, more extended than the crater area, is a regular mesh 80 nodes resolution in both x and y direction, and also describes half of the damaged zone.We use a resolution of 10 nodes to describe the radial projectile.
For a fixed water depth, we used 8 cases of projectile diameter in the range of 60 m to 1 Km, and 3 cases of impactor velocity: 10, 20 and 30 Km/s.Calculations were performed for 3 cases of water depth: 100, 200 and 400 m.Once fixed the projectile velocity and the water depth of the hypothetical ocean, we search to determine the range for the critical diameter of the projectile which can crater the seafloor [15].Therefore, in this study we have to compute 72 cases.Its execution on a Grid environment allows to obtain the diameter range of interest within the research cycle time Figures 3 and 4 show the timeframes of the opening cavities at 1 second time using the 60 and the 80 m impactor, respectively, with 200 m water depth and a velocity of 10 Km/s for the impactor.The shape difference between the 60 m case and the 80 m case illustrates the water effect.Due to the water layer, in that case, the impactor diameter has to be larger than 80 m to crater the seafloor.

GridWay programming model
The GridWay application programming and command line interface allow scientists and engineers to express their computational problems in a Grid environment.The capture of the job exit code allows users to define complex jobs, where each depends on the output and exit code from the previous job.They may even involve branching, looping and spawning of subtasks, allowing the exploitation of the parallelism on the work flow of certain type of applications [14].
Figure 5 shows a fragment of the job template used in the following experiments.Files are specified as "source destination" pairs separated by commas, where the destination file can be omitted if it has the same name as the source file.
The experiment files consist of the executable (∼0.5 MB), some parameter files (12 KB) for each task, and a table with values for the EOS equations (1.3 MB, when compressed) shared by all the tasks.The final name of the executable is obtained by resolving the variable $GW ARCH at runtime for the selected host.Similarly, the final names of the parameter files are obtained by resolving the variable $GW TASK ID at runtime for the current task.Once the job finishes, the standard output (0.5 MB) and the files with the figures of the simulation timeframes in PNG format (0.5 MB) are transferred back to the client.
The experiments have been performed with a resource selection script that queries MDS for potential execution hosts, attending the following criteria: -Host requirements are specified as a LDAP filter, which is used by the resource selector to query MDS and so obtain a preliminary list of potential hosts.In the experiments below, we impose a minimum main memory of 100 MB, enough to accommodate each task: (Mds-Memory-Ram-Total-sizeMB>=100) The resource selector also performs an user authorization filter (via a GRAM ping request) on those hosts.-A rank is assigned to each potential host following the preferences specified by the user in a ranking expression, which is a script that receives the monitoring data of the resources and outputs the rank value.Since our target application is a computingintensive simulation, the ranking expression benefits those hosts with less workload and so better performance.The following expression was considered: where F LOP S is the peak performance achievable by the host CPU, and CP U 15 is the average load in the last 15 minutes.

Computational results and performance evaluation
The execution time for each task is different and, what is more important, unknown beforehand, since the convergence of the iterative algorithm strongly depends on input parameters and the testbed resources are heterogeneous.Moreover, there is an additional difference generated by the changing resource load and availability.Therefore, adaptive scheduling is crucial for this application.Figure 6 shows the dynamic throughput, in terms of average turnaround time per job (i.e. the elapsed time divided by the number of completed jobs), as the experiment evolves.Total experiment time was 4.64 hours (4 hours, 38 minutes and 33 seconds), so the achieved throughput was 3.87 minutes (3 minutes and 52 seconds) per job, or likewise, 15.51 jobs per hour.
Figures 7 and 8 show the schedule performed by GridWay, in terms of number of jobs allocated to each resource and site, respectively.Most of the allocated jobs were successfully executed, but others failed and were dynamically rescheduled.Given these results, we can calculate the fault rate for each resource or site.The two failing resources (sites) show a fault rate of 25% and 45%, respectively, which result in an overall fault rate of 21%.These failures are mainly due to a known Globus problem (bug id 950) related to the NFS file systems and the PBS resource manager used in the clusters, which causes the job manager not to be able of getting the standard output and error of the job.This problem is mitigated, but not avoided, on babieca, where a patch related to this bug was applied.
Figure 9 shows the achieved throughput, also in terms of average turnaround time per job, by each site and by the whole testbed for the above schedule.In the right axis, the distributed or Grid speed-up, i.e. the performance gain obtained by each site, is also shown.We introduced Grid speed-up as a valuable metric for resource users and managers on each site in order to realize the benefits of being part of a Grid.Performance metrics like this can help to curb their selfishness sharing resources on the Grid [25].It is defined as follows: where T Grid is the Grid turnaround time,i.e. the waiting time from the application execution request until all the tasks are completed and all the results are available when all the resources in the testbed are used, and T site is the site turnaround time, i.e. the turnaround time when only the resources of a given site are used.This metric should be obtained or estimated in a distributed way for each site.
Table 2 shows the mean, standard deviation and coefficient of variance (CV) for the transfer and execution times on each resource.Table 3 shows the same statistics for the wall times on each resource.These values are nearly the same as for the execution time, since that is the dominating term.
In the case of the transfer time, we can see differences due to the heterogeneity of network links and resource configurations.For example, khafre runs the 2.2 version of the Globus toolkit, which has a polling period for the GRAM job manager of 30 seconds (whereas the 2.4 version polling period is 10 seconds).That produces a mean transfer time of one minute (two polling periods) with a very low standard deviation.The results also report a very high standard deviation in babieca, which has a nearly flat probability density function, that revealed several problems in the GRAM job manager.It is interesting to note that the best mean transfer time corresponds to platon, although it is located in a different site from the client.This is due to the file reuse policy implemented by GridWay, as platon is a SMP node with two processors that executes two simultaneous tasks sharing common files.
In the case of the execution time, there are two sources of variance: the dynamism and heterogeneity of the Grid resources and the different time needed by each task to converge.Processor speeds have the greater impact on the mean, while the use of RMS like PBS in some clusters or the existence of SMP nodes make the standard deviation to be greater.

Conclusions
The Globus toolkit provides a way to access the distributed resources needed for executing the compute and data intensive applications required in several research and engineering fields.However, the user is responsible for manually performing all the submission steps in order to achieve any functionality, and the adaptive execution of applications is not supported.The GridWay framework provides the runtime mechanisms needed for submitting applications and dynamically adapting their execution.
The suitability of a Grid environment based on the GridWay framework and the Globus toolkit has been demonstrated for the execution of a high throughput computing application that simulates impact cratering.The application comprises the execution of a high a number of tasks that exhibit different execution times due to both the heterogeneity and dynamism of the Grid resources and the convergence properties of the algorithm.Such computing platform will help to develop a search criteria for future investigations and exploration missions to Mars.Moreover, if they are successful in their hunt, they would also help to address the ongoing debate of whether large water bodies existed on Mars and, therefore, they would help to constrain future paleoclimatic reconstructions.
The Grid speed-up has been introduced as a valuable metric for resource users and managers in order to realize the benefits of sharing resources over the Grid.On the other hand, the study of the execution and transfer time provides a measure of the variability in the resource load and could be monitored when adjusting the components of a Grid in order to improve its performance.

Fig. 1 .
Fig. 1.Geographical distribution of the sites in Spain and interconnection network provided by RedIRIS.

Fig. 3 .
Fig. 3. Timeframes of the opening cavities at 1 second time using the 60 m impactor with 200 m water depth and a velocity of 10 Km/s for the impactor.

Fig. 4 .
Fig. 4. Timeframes of the opening cavities at 1 second time using the 80 m impactor with 200 m water depth and a velocity of 10 Km/s for the impactor.

Fig. 6 .
Fig. 6.Dynamic throughput, in terms of average turnaround time per job.

Fig. 7 .-
Fig. 7. Schedule performed by GridWay, in terms of jobs allocated to each resource.

Fig. 8 .
Fig. 8. Schedule performed by GridWay, in terms of jobs allocated to each site.

Fig. 9 .
Fig. 9. Throughput, in terms of average turnaround time per job (left-hand axis and values on top of columns) and distributed speed-up (right-hand axis and values inside columns), for each site and for the whole testbed (rightmost column, labelled as "All").

Table 1
Characteristics of the machines in the research testbed

Table 2
Mean, standard deviation and coefficient of variance (CV) for the transfer and execution times on each resource