A High Performance Computing Platform for Component-Based Parallel Programming

secrettownpanamanianΚινητά – Ασύρματες Τεχνολογίες

10 Δεκ 2013 (πριν από 3 χρόνια και 6 μήνες)

90 εμφανίσεις

A High Performance Computing Platformfor
Component-Based Parallel Programming
Francisco Heron de Carvalho-Junior Jefferson de Carvalho Silva Lucas Pinheiro Queiroz
Ricardo Cordeiro Corr
Mestrado e Doutorado emCi
encia da Computac¸
Universidade Federal do Cear
Component-based programming has been applied to ad-
dress the requirements of High Performance Computing
(HPC) applications.Due the poor support of parallelism
on current infrastructures,the#component model and its
based framework for parallel applications have been pro-
posed,motivating the development of component based en-
vironments for parallel programming targeting high-end
computing architecture.
High Performance Computing (HPC),previously re-
stricted to very specific niches,is now becoming a main-
stream technology,due to the increasing importance of
parallel applications in computational sciences,commer-
cial and financial software and the evolution in the design
of processors and parallel architectures.However,a little
progress has been made to improve performance of high
level parallel programming abstractions [6] in comparison
to lower level ones [15,25],making parallel programming
still hard to incorporate into widespread platforms.
Recent years presented the application of service-
oriented component technology on HPC domain [4],try-
ing to fit its requirements.With components,it is possible
to glue several models into one simulation.Each model de-
scribes different aspects of the simulated phenomena,in dif-
ferent programming languages and sites of execution [28].
Thus,service-oriented component models are naturally dis-
tributed but the parallelism inside them uses ad hoc ap-
proaches or orthogonal extensions.These two approaches
make programming a difficult task and do not reach the full
generality of message passing parallel programming.The
goal of this paper is a implementation of an environment
for component-based development of parallel applications,
by means of#-components that belong to each one of a set
of component kinds.Moreover,it is planned to add com-
ponent kinds for supporting service-oriented distributed in-
teractions between applications using a CCA framework,
called Forr
o,to HPE (The Hash Programming Environ-
ment) [8].Forr
o enables integration of different synchro-
nization technologies,such as RMI and Globus,and allows
overlapping of computation and communication in remote
method invocations.
The rest of this paper is structured in five more sections.
Section 2 gives an overview of parallelismsupport in exist-
ing component models.Section 3 presents the#component
model.Section 4 presents the Hash Framework Architec-
ture,proposed as a basis to the development of frameworks
based on#-components.Section 5 presents HPE,a gen-
eral purpose parallel programming environment based on
#-components and its framework.Section 6 concludes this
paper,outlining works in progress and further works.
2.ParallelismSupport in Component Models
Distributed parallel applications run a set of parallel pro-
grams,one per cluster,interacting through a network using
service-oriented interfaces.Component programming on
these environments basically encapsulate each parallel pro-
gram in a component.We present some usual approaches
for parallelismin component model and their limitations.
PARDIS [16] introduces the notion of SPMD CORBA
objects,which are sets of identical objects that cooperates in
parallel.It uses an extension of CORBAIDL on method in-
vocations.Paco [26],similar to PARDIS,extends CORBA
IDL too,but MPI is mandatory for communication between
his objects which are integrated via CORBA BOA (Basic
Object Adapter).Paco++ [10] introduces portability to Paco
by using XML files instead of CORBAIDL.Such approach
is used by GridCCM [22] where a parallel component is a
collection of SPMD CORBA components.Data Parallel
Corba [27] gives support for data parallel programming in
CORBA which distinguishes normal CORBA objects from
parallel objects formed by part objects.
CCA compliant frameworks investigate several possibil-
ities to address parallelism.CCAffeine [1] and SciRun2
[29],for example,are inspired in parallel extensions of
CORBA.CCAffeine uses the cohort abstraction which are
a set of identical components that interact through message
passing.This approach is called SCMD (Single Compo-
nent Multiple Data),but the CCA community had launched
some initiatives to support MCMD (Multiple Component
Multiple Data) in a near future.
Fractal [5] connects components in a hierarchical way,
by using existing ones.The created component exports his
ports through an interface and,by means of group proxies,
enables support to collective dispatching of method calls.
3.The#(Hash) Component Model
The#component model proposes a general notion of
parallel components called#-components,which have the
ability to be deployed in a pool of computing nodes (clusters
or grids).For that,a#-component is formed by a set of com-
ponent parts,called units,each one deployed in a comput-
ing node,that interact to perform a parallel task.The main
idea behind#-components is the slicing of the processes of
a parallel programby adopting a concern-oriented perspec-
tive,as illustrated by the example in Figure 1 for a parallel
program that performs a simple linear algebra operation.It
shows#-components (dashed ellipses) that are distributed
across four process,involving one or more slices.We say
that a#programmers views a parallel program from the
horizontal perspective,by concerns,while traditional ones
views themfromthe vertical perspective,by processes.The
later ones ignore the role of peer/cooperating slices,making
difficulty the adoption of software engineering disciplines
in parallel programming [11,6].The#-components can
also deal with non-functional concerns that cross-cut pro-
cesses,like allocation of processes as exemplified in Figure
1.The#component model has been formalized using Cat-
egory Theory and Theory of Institutions [7,9].
Through overlapping composition,one can combine
#-components to form new#-components,hierarchically.
Each new unit of the new#-component is formed by slices
that correspond to the units of the combined#-components.
Such slices can be functional code which are exogenously
coordinated [18],by means of behavior expressions [24]
that describe the execution order of slices and can be trans-
lated to Petri nets [23,21] for allowing formal verification.
Figure 1.FromProcesses to#-Components
Aparallel programis a#-component addressing the concern
of an application,whose processes are units.
Some component models have been proposed with se-
mantics defined in terms of algebras that enables creation
of connectors fromcombination of other connectors [12,3].
Also,exogenous connectors have been a trend in software
architecture research [24,18].The#component model
goes one step ahead by treating connectors as components
(#-components) and exogenously.Such abstraction makes
possible that an architectural connector,which may be spec-
ified by a set of roles and a glue [2],may be viewed as a
#-component,whose units are the roles and configuration
is the glue.Under this perspective,the overlapping com-
position may be viewed as a kind of algebra that can be
formalized [9].
4.The Hash Framework Architecture
An architecture has been proposed to guide the design
of new environments that could be interoperable for allow-
ing scientists and engineers to share their components and
deploy them in high-end computer architectures [8].It is
composed by three components,the FRONT-END,CORE
and BACK-END,which have distinct roles in the govern-
ment of#-component’s life cycle.The communications be-
tween themwas defined by the WSDL language,compliant
to web-services technology.
The life cycle of a#-component (Figure 2) starts with
configuration of a new one,built from a set of discov-
ered ones retrieved from a repository.So,it can be pub-
lished (stored in a repository,for public access) or used lo-
cally.The deployment stage,which depends on the compo-
Figure 2.Life Cycle of#-Components
nent kind of the#-component,specifies that#-component
is ready to be used in an execution environment.Finally,
in production,a deployed#-component is launched with
some application,possibly being monitored.
Figure 3.The Components of Hash Frame-
work Architecture
Figure 3 depicts how the three components of the Hash
Framework Architecture are inter-related,and how they are
related to the main entities in a HPC environment (the area
inside the circle):users,components,and architectures.
The FRONT-END acts as a facade to the users,accessing
the CORE and BACK-END.the CORE manages the com-
ponents,while the BACK-END manages the architectures,
where components are deployed and where they execute.
4.1.Component Kinds
From the Hash Framework Architecture,a#compli-
ant programming system may be instantiated by support-
ing a set of appropriate component kinds.Components
kinds act as metadata of how to treat and deploy a set of#-
component that are concretely implemented using the same
software abstractions.They make explicit the deployment
procedures and composition restrictions for each kind of#-
component.Component kinds may also be mapped to ab-
stractions that are commonly used in a specific domain as
building blocks to compose applications,like in the design
of a Problem Solving Environments (PSE’s).For that rea-
son,we plan to investigate the connection between compo-
nent kinds and ontologies.Indeed,it is possible to establish
how component kinds of different PSE’s that comply to the
Hash Framework Architecture can be composed for interop-
erability.In the next session,some examples of component
kinds that has been adopted in HPE are presented.
5.HPE- The Hash Programming Environment
HPE is a components-based development and parallel
execution platform that complies with the Hash Frame-
work Architecture,implementing its interface via WSDL.
The FRONT-END has been implemented as a plug-in to the
Eclipse Platform,using GEF [20] for providing a graph-
ical editor for overlapping composition of#-components
during development.The CORE has been implemented as
a Web Service and presents a repository of#-components
organized in hierarchical packages,which are stored in a
set of distributed LOCATIONS,also accessed via Web Ser-
vices.The#-component descriptions are stored in the LO-
CATION’s using XML format.
5.1.The Component Kinds of HPE
The#-components of HPE belongs to one of the follow-
ing component kinds:computations,defining functional
concerns;data structures,whose units denote data struc-
tures manipulated by#-components of computation kind;
synchronizers,whose units deals with communication and
synchronization issues;architectures defines which proces-
sors are available and their characteristics;environments,
denoting which software or middleware infrastructure is
used to enable parallelism in an architecture;applications,
denoting de parallel programs,whose units are processes;
qualifiers,representing ad-hoc non-functional characteris-
tics of a#-component.
Figure 4.The Mono Based Back-End of HPE
5.2.The BACK-END of HPE
The Back-End implementation extends Mono [19],a
free components infrastructure compliant with CLI stan-
dard [14].Mono/CLI has the ability to manage and de-
ploy components,and their versions,across an architec-
ture.Hash-Mono (Figure 4),as we called this extension,
is a symmetric-processes distributed program that access
Mono API to deal with#-components,whose units corre-
spond to assemblies (components in CLI) deployed each
one per node inside different Mono instances (GAC).
Some features justify Mono adoption on HPE:side-by-
side control of component versions;multi-language sup-
port;good support for web-services technology,allowing
interoperability;and high performance virtual machine en-
gines that allowto execute native (unmanaged) code in crit-
ical points of execution.Moreover,languages that are com-
monly used in HPC have been ported to Mono,such as C,
C++,Fortran,Java,and Python.Such languages are,for
example,that ones supported by Babel [17],a tool used by
some CCAframeworks for interoperability across program-
ming languages commonly used in HPC domain.
For enabling#-components in a CLI platform,each
component kind supported by HPE is interpreted in
terms of software abstractions used in a CLI plat-
form.A unit U of a#-component C of kind compu-
tation or synchronization is implemented as a class K
that implements the interface IComputationKind or
ISynchronizerKind,respectively.Both interfaces ex-
tend the interface IActivateKind,whose compliant
classes must implement the method activate,which im-
plements the activation semantics of units in the#compo-
nent model.The slices of U that are units of inner compo-
nents of kind computation,synchronization,and data struc-
tures are mapped to attributes of K,whose type correspond
the class associated to them.In the method activate
of K,computation and synchronization slices are activated
(call to activate) in the order specified by the protocol of
the unit.#-components of kind application are also of kind
computation,by adding to their units another class that im-
plement a static method Main,the entry execution point of
the process.A unit of a#-component of kind data structure
is defined as a common CLI class that implements a data
structure manipulated by computations and synchronizers
during execution.Fusion between#-components is only
possible between#-components of kind data structures,be-
ing useful in situations where two computations or synchro-
nization must operate over the same data structure instance,
avoiding copies.Units of#-components of kind architec-
ture,environment,and qualifier carry metadata in XML for-
mat,which can be used to guide deployment procedure of a
component or application.
5.3.Integration with Forr¶o
o is a CCA compliant framework for enabling dis-
tributed computations,developed in JAVA for supporting
applications in petroleum engineering simulation.It has
two interesting features:the ability to support several dis-
tributed computing middleware and several models of par-
allel computation in the same application,by means of
workspaces;and the support for overlapping of computa-
tion and synchronization by means of iterators.Forr
o will
be integrated to the Back-End of HPE for supporting dis-
tributed parallel applications.In fact,the idea is to let#-
components of kind application to be Forr
o components.
For that,it will be also necessary to incorporate new com-
ponent kinds for supporting programming abstractions of
o,such as workspaces,locations,links,and bindings.
The Back-End will deal with one instance of Forr
o per
Mono instance.The Forr
o instances communicate with
each other via RMI,integrating the units of a#-component.
These units will interoperate with Forr
o by means of Mono-
IKVM[13],which permits Java code running side-by-side
with Mono/CLI as well as having Java and Mono objects to
interoperate with each other.
The IKVM project presents a set of tools that work to-
gether with Mono framework.These tools allow de devel-
oper to migrate,almost automatically,his/her Java applica-
tion to Mono or vice-versa.With this feature,our Back-End
will be able to send arguments to the migrated API of Forr
in order to use its installed components.This is an impor-
tant task that will enable our#-components to work on a
distributed parallel environment,increasing its features and
performance.This is the first step towards supporting grid
We conclude that this work can help developers to un-
derstand parallel programming in a high level abstraction
by using#-components.The HPE is the tool which will al-
low an easy deployment of parallel components in a high
performance architecture,like clusters,and turning them
available for third parties.The final task,the integration
with the Forr
o framework will port#-components to Forr
components adding features fromgrid computing.
This project is supported by CNPq Grant 475826/2006-
Bernholdt,and J.A.Kohl.The CCA Core Specification
in a Distributed Memory SPMD Framework.Concurrency
and Computation:Practice and Experience,14(5):323–345,
R.Allen and A.Garlan.A Formal Basis for Architectural
Connectors.ACM Transactions on Software Engineering
and Methodology (TOSEM),6(3):213–249,1997.
F.Arbab.Reo:A Channel-Based Coordination Model for
Component Composition.Mathematical Structures in Com-
puter Science,14(3):329–366,2004.
lan,M.Sottile,T.Epperly,and Dahlgreen Tamara.The
CCA Component Model For High-Performance Scientific
Computing.Concurrency and Computation:Practice and
F.Baude,D.Caromel,and M.Morel.From Distributed
Objects to Hierarchical Grid Components.In Interna-
tional Symposium on Distributed Objects and Applications.
Bernholdt D.E.,J.Nieplocha,and P.Sadayappan.Rais-
ing Level of Programming Abstraction in Scalable Program-
ming Models.In IEEE International Conference on High
Performance Computer Architecture (HPCA),Workshop on
Productivity and Performance in High-End Computing (P-
PHEC),pages 76–84.Madrid,Spain,IEEE Computer Soci-
F.H.Carvalho Junior and R.Lins.ACategorical Character-
ization for the Compositional Features of the#Component
Model.ACMSoftware Engineering Notes,31(2),2006.
F.H.Carvalho Junior,R.Lins,R.C.Correa,and G.A.
ujo.Towards an Architecture for Component-Oriented
Parallel Programming.Concurrency and Computation:
Practice and Experience,19(5):697–719,2007.Special
Issue:Component and Framework Technology in High-
Performance and Scientific Computing.Edited by David E.
F.H.Carvalho Junior,R.D.Lins,and A.T.C.Martins.An
Institutional Theory for#-Components.In Proceedings of
the Brazilian Symposiumon Formal Methods (SBMF’2006),
pages 137–152,2006.
erez,and T.Priol.Portable Parallel CORBA
Objects.In Prof.of the 7th Intl.Europar’2001 Conference,
pages 835–844.Springer,Aug.2001.
L.Torczon,and A.White.Sourcebook of Parallel Com-
puting.Morgan Kauffman Publishers,2003.
J.L.Fiadeiro,A.Lopez,and M.Wermelinger.Categori-
cal Semantics of Parallel ProgramDesign.Lecture Notes in
Computer Science,2793:190–234,2003.
Ikvm.net home page.http://www.ikvm.net/,2007.
E.International.Common Language Infrastructure (CLI),
Partitions I to VI.Technical Report 335,ECMA Interna-
tional,June 2006.
Fowler,D.Gannon,S.L.Johnsson,J.M.Mellor Crummey,
and L.Torczon.Telescoping Languages:AStrategy for Au-
tomatic Generation of Scientific Problem-Solving Systems
from Annotated Libraries.Journal of Parallel Distributed
K.Koahey and D.Gannon.PARDIS:AParallel Approach to
CORBA.In Proc.of the 6th IEEE Intl.Symposium on High
Performance Distributed Computing (HPDC’97),pages 31–
S.Kohn,G.Kumfert,J.Painter,and C.Ribbens.Divorcing
Language Dependencies froma Scientific Software Library.
In 10th SIAMConference on Parallel Processing.Springer-
K.Lau,P.V.Elizondo,and Z.Wang.Exogenous Con-
nectors for Software Components.Lecture Notes in Com-
puter Science (Proceedings of 2005 International SIGSOFT
Symposium on Component-Based Software Engineering -
The mono project.http://www.mono-project.com,2007.
B.Moore,D.Dean,A.Gerber,G.Wagenknecht,and P.Van-
derheyden.Eclipse Development Using the Graphical Edit-
ing Framework and Eclipse Modelling Framework.IBM
International Technical Support Organization,Feb.2004.
T.Murata.Petri Nets:Properties Analysis and Applications.
Proceedings of IEEE,77(4):541–580,Apr.1989.
erez,T.Priol,and A.Ribes.A Parallel Corba Compo-
nent Model for Numerical Code Coupling.In Proc.of the
3rd Intl.Workshop on Grid Computing (published in LNCS
2536),pages 88–99.Springer,Nov.2002.
C.A.Petri.Kommunikation mit Automaten.Technical Re-
port RADC-TR-65-377,Griffiths Air Force Base,New York,
F.Plasil and S.Visnovsky.Behavior Protocols for Software
Components.IEEE Transactions on Software Engineering,
D.E.Post and L.G.Votta.Computational Science Demands
a New Paradigm.Physics Today,58(1):35–41,2005.
e and T.Priol.MPI Code Encapsulating Using Paral-
lel CORBA Object.Cluster Computing,3:255–263,2000.
O.Standard.Data Parallel CORBA,v1.0.Technical Re-
port 2006-01-03,Object Management Group,Object Man-
agement Group,Jan.2006.
A.J.van der Steen.Issues in Computational Frameworks.
Concurrency and Computation:Practice and Experience,
S.Parker.SCIRun2:a CCA framework for high perfor-
mance computing.In Proceedings of the HIPS2004 - 9th
International Workshop on Highlevel Parallel Programming
Models and Supportive Environments,2004.