Information Technology Reference
In-Depth Information
such toolkits are JavaSymphony (Fahringer and
Jugravu, 2005), Java CoG Kit (von Laszewski
et al., 2003), GSBL (Bazinet et al., 2007), GAT
(Allen et al., 2005) and MyCoG.NET (Paventhan
et al., 2006). Hence, the application logic results
mixed up with code for using Grid services, making
maintainability, testing and portability to differ-
ent Grid libraries and platforms somewhat hard.
Furthermore, gridifying existing code requires
to rewrite significant portions of it to use those
APIs. These problems are partially addressed by
tools that take an executable, along with user pa-
rameters (e.g. input arguments, CPU and memory
requirements, etc.), and wrap the executable with
a component that isolates the details of the Grid.
Some tools falling in this category are GEMLCA
(Delaittre et al., 2005), LGF (Baliś & Wegiel,
2008) and GridSAM (McGough et al., 2008).
However, the output of these tools are coarse
grained applications whose execution cannot be
configured to make better use of Grid resources
(e.g. parallelize and/or distribute individual ap-
plication components). Overall, this represents
a trade-off between ease of gridification versus
flexibility to configure the runtime aspects of
gridified applications (Mateos et al., 2008a).
To address these issues, we propose JGRIM, a
novel method for porting Java applications onto
service-oriented Grids, this is, based on Web
Services. JGRIM minimizes the requirement of
source code modification when gridifying Java
applications, and provides simple mechanisms to
effectively tune transformed applications. JGRIM
follows a
two-step
gridification methodology, in
which developers first implement and test the
logic of their applications, and then Grid-enable
them by undemandingly and non invasively
injecting Grid services. Therefore, we conceive
gridification as shaping the source code of an
ordinary application according to few coding
conventions, and then adding Grid concerns to it.
In a previous paper (Mateos et al., 2008b), we re-
ported preliminary comparisons between JGRIM
and other approaches for gridifying software in
terms of source code metrics. In this article we
also report JGRIM execution performance on an
Internet-based Grid, measuring execution time
and network usage of two resource-intensive
applications. The rest of the article analyzes the
most relevant related works, describes JGRIM,
and presents the experimental evaluations.
RELATED WORK
Motivated by the complex and challenging nature
of porting conventional applications to the Grid
(Gentzsch, 2009), research in tools and methods
to easily gridify ordinary software is growing at
an astonishingly rate. Besides providing APIs
for developing and executing Grid applications,
many of these tools actually materialize alterna-
tive approaches to support easy gridification of
existing applications. For an exhaustive survey
on technologies to port applications to the Grid,
see (Mateos et al., 2008a). Below we describe a
representative subset of such tools.
ProActive (Baduel et al., 2006) is a platform
for parallel distributed computing that provides
technical services
, a support which allows users
to address non-functional concerns (e.g. load
balancing and fault tolerance) by plugging certain
external configuration to the application code at
deployment time. ProActive applications com-
prise one or more mobile entities whose creation,
migration and lookup are performed by explicit
code provisioning. Likewise, the JPPF (2008)
framework supports distributed scheduling for
CPU-intensive tasks on distributed environments.
In both cases, after porting an application to a
Grid, the application logic results mixed up with
Grid-related code. Therefore, gridification as well
as software maintenance thereafter become dif-
ficult. Furthermore, GridGain (GridGain Systems,
2008) attempts to minimize this problem by using
Java annotations to seamlessly exploit distributed
processors. However, GridGain does not target
Search WWH ::
Custom Search