MOCCA A Distributed CCA Framework based on H2O

1
MOCCA A Distributed CCA Framework based on H2O

• Maciej Malawski, Dawid Kurzyniec, Vaidy Sunderam

2
Outline

• CCA and H2O a good match
• H2O as underlying platform
• Goals of MOCCA (Metacomputing Oriented CCA
  framework)
• MOCCA technical overview
• Initial performance results
• Towards Babel compatibility
• Future directions and research perspectives

3
Why CCA and H2O

• CCA
• Component standard for HPC
• Uses and provides ports described in SIDL
• Support for scientific data types
• Existing tightly coupled (CCAFFEINE) and loosely
  coupled, distributed (XCAT) frameworks
• H2O
• Distributed resource sharing platform
• Providers setup H2O kernel (container)
• Allowed parties can deploy pluglets (components)
• Separation of roles decoupling
• Providers from deployers
• Providers from each other
• RMIX efficient multiprotocol RMI extension

4
H2O Resource sharing platform

• Providers own resources
• They independently share them over the network
• access control policies
• Clients discover, locate, and utilize resources
• Resources configurable via plugins
• Aggregation and reselling cascading pairwise
  relationships

5
H2O Component Model

• Nomenclature
• container kernel
• component pluglet
• Pluglet remotely accessible object
• implements Pluglet interface, used by kernel to
  signal/trigger pluglet state changes
• Remote access based on the RMI model
• Pluglets export functional remote interfaces

Interface Pluglet void init(RuntimeContext
cxt) void start() void stop() void
destroy()
tutorial/step1/srv/Hello.java
public interface Hello extends Remote String
hello() throws RemoteException
6
Example scenarios of H2O
7
RMIX Communication Substrate

• Extensible framework
• Remote Method Invocations paradigm
• Pluggable protocol providers
• Multiple protocols supported
• JRMPX, ONC-RPC, SOAP
• Request-Response and Asynchronous calls
• Combines simplicity, flexibility, and performance

8
RMIX multiple protocols

• Protocol switching
• Protocol negotiation
• Various protocol stacks for different situations
• SOAP interoperability
• SSL security
• ARPC, custom (Myrinet, Quadrics) efficiency

9
H2O Current research areas

• (More) Interoperability
• Support for Globus proxy credentials
• Naming services JNDI bridge to multiple
  implementations
• Peer-to-peer grids
• JXTA transport provider for RMIX enables RMI
  over JXTA sockets
• JXTA-JNDI naming provider peer-to-peer resource
  sharing and discovery
• Fault-tolerant MPI across shared resources
• FT-MPI H2O staging, sharing, heterogeneity,
  scalability

10
H2O Feature Summary

• Resource sharing
• Deploying components on shared resources
• Component isolation and hot-swapping
• Pluglets deployed in separate class loaders
• Performance
• Pluglets run in a single process efficient local
  bindings
• Distributed communication efficient binary
  protocols
• Support for asynchronous calls
• Security
• SSL transport, JAAS authentication, Java sandbox
  model, security policies
• Interoperability
• Multiple RMI protocols SOAP, JRMP, RPC,
• API support for native code resource staging,
  linking dynamic libraries

11
Requirements for a Metacomputing-oriented CCA
Framework

• Facilitated deployment - provide easy mechanisms
  for creation of components on distributed shared
  resources
• Efficient communication - both for distributed
  and local components
• Flexible - allow flexible configuration of
  components and various application scenarios
• Support native components, i.e. components
  written in non-Java programming languages and
  compiled for specific architecture.
• Interoperable with Grid standards (Web services)

12
Existing CCA Frameworks

• CCAFFEINE
• Tightly coupled
• Support for Babel
• MPI support
• XCAT
• Loosely coupled
• Globus-compatible
• Java-based
• DCA
• MPI based
• MxN problems
• SCIRun2
• Metacomponent model
• LegionCCA
• Based on Legion Metacomputing system

13
MOCCA implementation in H2O

• Each component running in separate pluglet
• Thanks to H2O kernel security mechanisms,
  multiple components may run without interfering
• Two-level builder hierarchy
• ComponentID pluglet URI
• MOCCA_Light pure Java implementation (no SIDL)

14
Remote Port Call
15
How to use MOCCA(step by step)

• Implement component code extending CCA interfaces
  (cca.Port, cca.Component)
• Compile component classes into JAR file
• Publish application JARs on HTTP server
• Use the Java client API or write a Jython script
  to assemble application from components
• Specify components and their connections
• Specify locations of H2O kernels where to
  instantiate components
• Running the script automatically deploys
  necessary pluglets into H2O kernels and spawns
  application

16
Example script

• builder MoccaMainBuilder()
• uriKernel1 URI.create("http//emily.mathcs.emory
  .edu7800/")
• uriKernel2 URI.create("http//zeus10.cyf-kr.edu.
  pl7800/")
• userBuilderID builder.addNewBuilder(uriKernel1,
  "MyBuilderPlugletA")
• providerBuilderID builder.addNewBuilder(uriKerne
  l2, "MyBuilderPlugletB")
• properties MoccaTypeMap()
• properties.putString("mocca.plugletclasspath",
  "http//emily.mathcs.emory.edu/mocca
  /mocca-samples.jar")
• properties.putString("mocca.builderID",
  userBuilderID.getSerialization())
• userID builder.createInstance("My
  StarterComponent",
• 
  "mocca.samples.pingpong.impl.MoccaStarterComponent
  ,
• properties)
• properties.putString("mocca.plugletclasspath",
• "http//emily.mathcs.emory.ed
  u/mocca/mocca-samples.jar")
• properties.putString("mocca.builderID",
  providerBuilderID.getSerialization())
• providerID builder.createInstance("MyPingCompon
  ent",
• 
  "mocca.samples.pingpong.impl.PingPongComponent",
• properties)
• connectionID builder.connect(userID,
• "PingPongUsesPort",
  

17
Automatic Flow Composer Example

• Compose application graph from initial data (e.g.
  initial ports) or incomplete graph
• First implemented for XCAT framework
• Easy migration to MOCCA
• Modification of code required (xcat.Port)
• Similar performance for XCAT and MOCCA (exchange
  of text documents)

18
Communication Intensive Application Benchmark

• Simplified scenario
• 2 components
• Provides port receive and send-back array of
  double (ping-pong)
• Tested on local Gigabit Ethernet and on
  transatlantic Internet between Atlanta and Krakow
• 2.4 Ghz Linux machines
• Comparison with XCAT

19
Small Data Packets

• Factors
• SOAP header overhead in XCAT
• Connection pools in RMIX

20
Large Data Packets

• Encoding (binary vs. base64)
• CPU saturation on Gigabit LAN (serialization)
• Variance caused by Java garbage collection

21
Support for Babel Components

• Currently MOCCA_Light pure Java framework
• Approach
• Use Java bindings to Babelized components
• Automatically generate wrapping code

• Issues
• Babel remote bindings
• Remote references
• Package hierarchy gov.cca.Port extends
  gov.llnl.sidl.BaseInterface, sidl.BaseInterface

22
Future directions of MOCCA

• Support for multilingual components
• Goal to enable loading of Babel CCAFFEINE
  components into MOCCA
• Automatic generation of wrappers from SIDL
• Support for dynamic component reconfiguration and
  adaptiveness
• CCA standard allows for dynamic creation of ports
  and connecting/reconnecting at runtime
• Framework needs to support such behavior
• Especially interesting for interactive
  (portal/PSE) usage
• Investigation of using hierarchical components
• By using CCA BuilderService components may act as
  sub-frameworks creating hierarchies of
  subcomponents inside them

23
Beyond CCA ?

• Supporting multiple component standards
• Goal to enable loading of components written for
  different standards (e.g. Corba CCM, other)
• Examples of similar solutions CCAFFEINE supports
  classic and Babel components SCIRun2
  implementing meta-component model
• Using MOCCA as promising platform for feasibility
  studies in various aspects of Grid components
• For experiments with advanced features
• Scheduling and load-balancing
• Fault-tolerance
• Semantic description and composition
• As a platform for higher-level grid services and
  tools

24
References

• Maciej Malawski, Dawid Kurzyniec, and Vaidy
  Sunderam. MOCCA towards a distributed CCA
  framework for metacomputing, Accepted for 10th
  International Workshop on High-Level Parallel
  Programming Models and Supportive Environments
  (HIPS2005), http//mathcs.emory.edu/dcl/h2o/papers
  /h2o_hips05.pdf
• H2O Project homepage http//www.mathcs.emory.edu/
  dcl/h2o/