Docstoc

notes

Document Sample
notes Powered By Docstoc
					CCA
Common Component Architecture



       Welcome to the
Common Component Architecture
          Tutorial
                                         ACTS Workshop
                                         26 August 2005


             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   1
  CCA
  Common Component Architecture




                                  Agenda & Table of Contents
       Time                       Title                                   Slide No. Presenter
11:00-11:05am                     Welcome                                        1 David Bernholdt, ORNL
11:05am-12:00n                    What can Component Technology do               5 David Bernholdt, ORNL
                                  for Scientific Computing
                                  An Introduction to Components & the           16 David Bernholdt, ORNL
                                  CCA
12:00-12:30pm                     CCA Tools                                     64 Jim Kohl, ORNL
 12:30-1:30pm                     Lunch
 1:30-2:10pm                      Language Interoperable CCA                   105 Jim Leek, LLNL
                                  Components with Babel
 2:10-2:55pm                      CCA Applications                             123 Jaideep Ray, SNL
 2:55-3:00pm                      Closing                                      169 Jaideep Ray, SNL
 3:00-3:30pm                      Break (relocate to Wheeler Hall, UCB)
 3:30-6:30pm                      Hands-On                                Hands-On All
                                                                             Guide


                                                                                                           3
 CCA
 Common Component Architecture




         The Common Component Architecture
                  (CCA) Forum
• Combination of standards body and user group for the CCA
• Define Specifications for High-Performance Scientific
  Components & Frameworks
• Promote and Facilitate Development of Domain-Specific
  Common Interfaces
• Goal: Interoperability between components developed by
  different expert teams across different institutions
• Quarterly Meetings, Open membership…
                                 Mailing List: cca-forum@cca-forum.org
                                       http://www.cca-forum.org/         4
CCA
Common Component Architecture




What Can Component Technology
  do for Scientific Computing?




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   5
CCA
Common Component Architecture




                                Managing Code Complexity
      Some Common Situations:
      • Your code is so large and complex it has become fragile and
        hard to keep running
      • You have a simple code, and you want to extend its capabilities
        – rationally
      • You want to develop a computational “toolkit”
                 – Many modules that can be assembled in different ways to perform
                   different scientific calculations
                 – Gives users w/o programming experience access to a flexible tool
                   for simulation
                 – Gives users w/o HPC experience access to HPC-ready software
      How CCA Can Help:
      • Components help you think about software in manageable
        chunks that interact only in well-defined ways
      • Components provide a “plug-and-play” environment that allows
        easy, flexible application assembly
                                                                                      6
CCA
Common Component Architecture




              Example: Computational Facility for
                Reacting Flow Science (CFRFS)
• A toolkit to perform
  simulations of unsteady
  flames
• Solve the Navier-Stokes
  with detailed chemistry
   – Various mechanisms
     up to ~50 species, 300
     reactions
   – Structured adaptive
     mesh refinement              “Wiring diagram” for a typical CFRFS
                                  simulation, utilizing 12 components.
• CFRFS today:
         – 61 components          CCA tools used: Ccaffeine, and
         – 7 external libraries   ccafe-gui
         – 9 contributors         Languages: C, C++, F77                 7
CCA
Common Component Architecture




              Helping Groups Work with Software
      Some Common Situations:
      • Many (geographically distributed) developers creating
        a large software system
                 – Hard to coordinate, different parts of the software don’t work
                   together as required
      • Groups of developers with different specialties
      • Forming communities to standardize interfaces or
        share code
      How CCA Can Help:
      • Components are natural units for
                 – Expressing software architecture
                 – Individuals or small groups to develop
                 – Encapsulating particular expertise
      • Some component models (including CCA) provide
        tools to help you think about the interface separately
        from the implementation
                                                                                    8
CCA
Common Component Architecture




                           Example: Quantum Chemistry
• Integrated state-of-the-art
  optimization technology
  into two quantum
  chemistry packages to
  explore effectiveness in
  chemistry applications      Schematic of CCA-based molecular
• Geographically distributed structure determination quantum
  expertise:                  chemistry application.
          – California - chemistry
          – Illinois - optimization    Components based on: MPQC,
          – Washington – chemistry,    NWChem (quantum chem.), TAO
            parallel data management   (optimization), Global Arrays, PETSc
• Effective collaboration              (parallel linear algebra)
  with minimal face-to-face            CCA tools used: Babel, Ccaffeine,
  interaction                          and ccafe-gui
                                       Languages: C, C++, F77, Python         9
CCA
Common Component Architecture




                Example: TSTT Unstructured Mesh
                      Tool Interoperability
                                                                       Geometry
                                                                       Information

      • Common interface for
                                                                       (Level A)



        unstructured mesh
        geometry and topology
                 – 7 libraries: FMDB,         Full
                                              Geometry
                   Frontier, GRUMMP,          Meshes
                                              (Level B)
                   Mesquite, MOAB,
                                                                    Mesh
                   NWGrid, Overture                                 Components
                                                                    (Level C)
                 – 6 institutions: ANL,
                   BNL/SUNY-Stony Brook, Illustration of geometry domain
                   LLNL, PNNL, RPI, SNL hierarchy used in TSTT mesh
                                          interface.
      • Reduces need for N              2

        pairwise interfaces to               CCA tools used: Babel (SIDL),
        just N                               Chasm
                                             Library languages: C, C++, F77, F90     10
CCA
Common Component Architecture




                                Language Interoperability
      Some Common Situations:
      • Need to use existing code or libraries written in
        multiple languages in the same application?
      • Want to allow others to access your library from
        multiple languages?
      • Technical or sociological reasons for wanting to use
        multiple languages in your application?
      How CCA Can Help:
      • Some component models (including CCA) allow
        transparent mixing of languages
      • Babel (CCA’s language interop. tool) can be used
        separately from other component concepts
                                                               11
 CCA
 Common Component Architecture




                                 Examples

hypre                                  LAPACK07
• High performance                     • Update to LAPACK linear
                                         algebra library
  preconditioners and linear               – To be released 2007
  solvers                                  – Library written in F77, F95
• Library written in C                 • Will use Babel-generated
                                         interfaces for: C, C++,
• Babel-generated object-                F77, F95, Java, Python
  oriented interfaces                  • Possibly also ScaLAPACK
  provided in C, C++, Fortran            (distributed version)
 “I implemented a Babel-based interface for the hypre library of linear
 equation solvers. The Babel interface was straightforward to write and
 gave us interfaces to several languages for less effort than it would take
 to interface to a single language.”
                                        -- Jeff Painter, LLNL. 2 June 2003
                       CCA tools used: Babel, Chasm                           12
CCA
Common Component Architecture




                                      Coupling Codes
      Some Common Situations:
      • Your application makes use of numerous third-party libraries
                 – Some of which interact (version dependencies)
      • You want to develop a simulation in which your code is coupled
        with others
                 –      They weren’t designed with this coupling in mind
                 –      They must remain usable separately too
                 –      They are all under continual development, individually
                 –      They’re all parallel and need to exchange data frequently
      How CCA Can Help:
      • Components are isolated from one another
                 – Interactions via well-defined interfaces
                 – An application can include multiple versions of a component
      • Components can be composed flexibly, hierarchically
                 – Standalone application as one assembly, coupled simulation as
                   another
      • CCA can be used in SPMD, MPMD, and distributed styles of
        parallel computing
      • CCA is developing technology to facilitate data and functional
        coupling of parallel applications
                                                                                    13
CCA
Common Component Architecture




        Example: Global Climate Modeling and
          the Model Coupling Toolkit (MCT)
      • MCT is the basis for
        Community Climate
        System Model (CCSM3.0)
        coupler (cpl6)
      • Computes interfacial fluxes
        and manages redistribution
        of data among parallel
        processes
      • Written in F90, Babel-
        generated bindings for
        C++, Python                   Schematic of CCSM showing
                                      coupler managing data
      • CCA tools used: Babel,        exchanges between atmosphere,
        Chasm                         sea ice, ocean, and land models.
                                      (From http://www.ccsm.ucar.edu/models/ccsm3.0/cpl6/)
                                                                                             14
CCA
Common Component Architecture




       Example: Integrated Fusion Simulation
• Proof-of-principle of using
  CCA for integrated whole-
  device modeling needed
  for the ITER fusion reactor
• Couples radio frequency
  (RF) heating of plasma
  with transport modeling       “Wiring diagram” for integrated fusion
• Coarse-grain                  simulation.
  encapsulation of pre-
                                Components based on: AORSA,
  existing programs
                                Houlberg’s transport library
• Follow-on plans for RF,       New components: Driver, State
  transport, and magneto-       CCA tools used: Babel, Chasm,
  hydrodynamics                 Ccaffeine, ccafe-gui
                                Languages: C++, F90, Python              15
CCA
Common Component Architecture




 An Introduction to Components
            and the
Common Component Architecture




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   16
CCA
Common Component Architecture




                                Goals of This Module

      • Introduce basic concepts and vocabulary of
        component-based software engineering and
        the CCA

      • Highlight the special demands of high-
        performance scientific computing on
        component environments

      • Give you sufficient understanding of the CCA
        to begin evaluating whether it would be useful
        to you
                                                         17
CCA
Common Component Architecture




                                What are Components?
      • No universally accepted definition in computer
        science research, but key features include…

      • A unit of software development/deployment/reuse
                 – i.e. has interesting functionality
                 – Ideally, functionality someone else might be able to (re)use
                 – Can be developed independently of other components

      • Interacts with the outside world only through well-
        defined interfaces
                 – Implementation is opaque to the outside world

      • Can be composed with other components
                 – “Plug and play” model to build applications
                 – Composition based on interfaces                                18
CCA
Common Component Architecture




               What is a Component Architecture?

      • A set of standards that allows:
                 – Multiple groups to write units of software (components)…
                 – And have confidence that their components will work with
                   other components written in the same architecture

      • These standards define…
                 – The rights and responsibilities of a component
                 – How components express their interfaces
                 – The environment in which components are composed to
                   form an application and executed (framework)
                 – The rights and responsibilities of the framework


                                                                              19
  CCA
  Common Component Architecture
                                                                                                   •




                         A Simple Example:
                  Numerical Integration Components
    Interoperable components
    (provide same interfaces)                                                FunctionPort


                                             IntegratorPort   FunctionPort
                                                                             NonlinearFunction
                                                                             FunctionPort
                                                MidpointIntegrator

GoPort                      IntegratorPort                                     LinearFunction
                                                                             FunctionPort
               Driver
                                             IntegratorPort   FunctionPort
                                                                                  PiFunction
                                                     RandomGeneratorPort
                                                                             RandomGeneratorPort
                                              MonteCarloIntegrator

                                                                             RandomGenerator
                                                                                                   20
  CCA
  Common Component Architecture




                          An Application
              Built from the Provided Components

                                                                             FunctionPort


                                             IntegratorPort   FunctionPort
                                                                             NonlinearFunction
                                                                             FunctionPort
                                                MidpointIntegrator

GoPort                      IntegratorPort                                     LinearFunction
                                                                             FunctionPort
               Driver
                                             IntegratorPort   FunctionPort
                                                                                  PiFunction
   Hides compexity: Driver                           RandomGeneratorPort
   doesn’t care that                                                         RandomGeneratorPort
   MonteCarloIntegrator                       MonteCarloIntegrator
   needs a random
                                                                             RandomGenerator
   number generator
                                                                                                   21
  CCA
  Common Component Architecture




                                      Another Application…

                                                                             FunctionPort


                                             IntegratorPort   FunctionPort
                                                                             NonlinearFunction
                                                                             FunctionPort
                                                MidpointIntegrator

GoPort                      IntegratorPort                                     LinearFunction
                                                                             FunctionPort
               Driver
                                             IntegratorPort   FunctionPort
                                                                                  PiFunction
                                                     RandomGeneratorPort
                                                                             RandomGeneratorPort
                                              MonteCarloIntegrator

                                                                             RandomGenerator
                                                                                                   22
  CCA
  Common Component Architecture




                                             Application 3…

                                                                               FunctionPort


                                               IntegratorPort   FunctionPort
                                                                               NonlinearFunction
                                                                               FunctionPort
                                                  MidpointIntegrator

GoPort                      IntegratorPort                                       LinearFunction
                                                                               FunctionPort
               Driver
                                               IntegratorPort   FunctionPort
                                                                                    PiFunction
                                                       RandomGeneratorPort
                                                                               RandomGeneratorPort
                                                MonteCarloIntegrator

                                                                               RandomGenerator
                                                                                                     23
  CCA
  Common Component Architecture




                                             And Many More…

     Dashed lines                                                              FunctionPort
   indicate alternate
      connections                              IntegratorPort   FunctionPort
                                                                               NonlinearFunction
                                                                               FunctionPort
                                                  MidpointIntegrator

GoPort                      IntegratorPort                                       LinearFunction
                                                                               FunctionPort
               Driver
                                               IntegratorPort   FunctionPort
                                                                                    PiFunction
                                                       RandomGeneratorPort
                                                                               RandomGeneratorPort
                                                MonteCarloIntegrator
 Create different applications
  in "plug-and-play" fashion                                                   RandomGenerator
                                                                                                     24
CCA
Common Component Architecture




                 Be Aware: “Framework” Describes
                           Many Things
• Currently in scientific computing, this term often means different
  things to different people

• Basic software composition environment
           – Examples: CCA, CORBA Component Model, …
• An environment facilitating development of applications in a particular
  scientific domain (i.e. fusion, computational chemistry, …)
           – Example: Earth System Modeling Framework, http://www.esmf.ucar.edu
           – Example: Computational Facility for Reacting Flow Science,
             http://cfrfs.ca.sandia.gov
• An environment for managing complex workflows needed to carry out
  calculations
           – Example: Kepler: http://kepler-project.org
• Integrated data analysis and visualization environments (IDAVEs)

• Lines are often fuzzy
           – Example: Cactus, http://www.cactuscode.org
• Others types of frameworks could be built based on a basic software
  composition environment
                                                                                  25
CCA
Common Component Architecture




                      Relationships:
              Components, Objects, and Libraries
      • Components are typically discussed as objects or
        collections of objects
                 – Interfaces generally designed in OO terms, but…
                 – Component internals need not be OO
                 – OO languages are not required
      • Component environments can enforce the use of
        published interfaces (prevent access to internals)
                 – Libraries can not
      • It is possible to load several instances (versions) of a
        component in a single application
                 – Impossible with libraries
      • Components must include some code to interface
        with the framework/component environment
                 – Libraries and objects do not                      26
CCA
Common Component Architecture




                                What is the CCA?
   • Component-based software engineering has been
     developed in other areas of computing
              – Especially business and internet
              – Examples: CORBA Component Model, COM, Enterprise
                JavaBeans

   • Many of the needs are similar to those in HPC scientific
     computing

   • But scientific computing imposes special requirements
     not common elsewhere

   • CCA is a component environment specially designed to
     meet the needs of HPC scientific computing
                                                                   27
CCA
Common Component Architecture




                        Special Needs of Scientific HPC

      • Support for legacy software
                 – How much change required for component environment?
      • Performance is important
                 – What overheads are imposed by the component
                   environment?
      • Both parallel and distributed computing are important
                 – What approaches does the component model support?
                 – What constraints are imposed?
                 – What are the performance costs?
      • Support for languages, data types, and platforms
                 – Fortran?
                 – Complex numbers? Arrays? (as first-class objects)
                 – Is it available on my parallel computer?
                                                                         28
CCA
Common Component Architecture




                                CCA as Actual Code
      • We have developed an environment which
        implements the CCA design pattern
      • The CCA specification defines standard interfaces to
        be used by components and frameworks, and the
        protocol by which components and frameworks
        interact
      • A suite of tools that allow you to write and use
        components
                 – Language interoperability tools: Chasm, Babel
                 – Frameworks: Ccaffeine, SCIRun2, XCAT-C++
      • You do not have to use our tools
                 – You can create your own
                 – You can adapt ours for special needs
                                                                   29
CCA
Common Component Architecture




            A Word About the CCA Specification

      • The CCA spec is currently defined using the
        Scientific Interface Definition Language (SIDL)
                 – SIDL is also used by the Babel language interoperability tool
      • The CCA spec could be translated into other
        languages if desired
                 – It was defined in C++ before SIDL was mature
      • We use the term “CCA compliant” to designate things
        that conform to any reasonable translation of the
        CCA spec
                 – The CCA Forum is considering refining the terminology to
                   express different categories or levels of interoperability


                                                                                   30
CCA
Common Component Architecture




                                    CCA Concepts:
                                Language Interoperability
      • Most language                           • Babel provides a common
        interoperability                          solution for all supported
        approaches are “point-                    languages
        to-point” solutions                     • Scientific Definition
                                 f77
                                                  Interface Language
                                                  (SIDL) used to express
           C                            f90       interfaces
                                                           f77

       C++                             Python
                                                  C                    f90/95

                                Java                                  Python
                                                 C++
Few other component models support all languages                   More on
and data types important for scientific computing                 Babel later!
                                                           Java                  31
CCA
Common Component Architecture




                                CCA Concepts: Components
                                IntegratorPort   FunctionPort   FunctionPort


                                   MidpointIntegrator              NonlinearFunction



      • A component encapsulates some computational
        functionality
      • Components provide/use one or more interfaces
                 – A component with no interfaces is formally okay, but isn’t
                   very interesting or useful
      • In SIDL, a component is a class that implements
        (inherits from) gov.cca.Component
                 – This means it must implement the setServices method to tell
                   framework what ports this component will provide and use
                 – gov.cca.Component is defined in the CCA specification
                                                                                       32
CCA
Common Component Architecture




                                         CCA Concepts: Ports
                                IntegratorPort   FunctionPort   FunctionPort


                                   MidpointIntegrator              NonlinearFunction

       • Components interact through well-defined interfaces, or ports
                  – A port expresses some computational functionality
                  – In Fortran, a port is a bunch of subroutines or a module
                  – In OO languages, a port is a abstract class or interface
       • Ports and connections between them are a procedural
         (caller/callee) relationship, not dataflow!
                  – e.g., FunctionPort could contain: evaluate(in Arg, out Result)
       • A single component can implement multiple ports
                  – Different “views” of the same functionality
                  – Related pieces of functionality
       • Multiple components can implement the same port
                  – Different implementations of the same functionality
                  – Basis for interoperability of component software
                                                                                       33
CCA
Common Component Architecture




                          CCA Concepts: Provides Ports
                                IntegratorPort   FunctionPort   FunctionPort


                                   MidpointIntegrator              NonlinearFunction

       • Components may provide ports – implement the
         class or subroutines of the port ( “Provides” Port )
       • In SIDL, ports are interfaces that extend (inherit from)
         gov.cca.Port
          – gov.cca.Port is defined in the CCA spec and has no
            methods – simply allows manipulation as a port,
            enables plug-and-play
       • In SIDL, a component that provides a port must
         implement (inherit from) the port’s interface
          – These are usually defined by software developers,
            not in the CCA specification.
          – gov.cca.ports.GoPort and gov.cca.ComponentRelease
            are two special cases – they are defined by the
            CCA specification, and thus have special meaning                           34
  CCA
  Common Component Architecture
                                                                                                              •••




                            Components and Ports in UML
                                                            … which in turn, must extend
                                                             the CCA spec’s port interface
                                    <<interface>>
                                  gov.cca.Component                    <<interface>>
                                                                        gov.cca.Port
              setServices(services: gov.cca.Services)

 …must implement the
                                                                        <<interface>>
  CCA spec’s com-                                                 integrator.IntegratorPort
  ponent interface to be
  a component…                                             integrate(lowBound: double,
                                                             upBound: double, count: int): double

                                                                           … and must implement
                                                      Midpoint              the port(s) it wants to
                                                                            provide…
                                           Our class for the Midpoint
         = Inheritance
                                            Integrator component…                             SIDL keywords   35
CCA
Common Component Architecture




                                  CCA Concepts: Uses Ports
                                IntegratorPort   FunctionPort   FunctionPort


                                   MidpointIntegrator              NonlinearFunction

  • Components may use ports – call methods or
    subroutines in the port ( “Uses” Port )
  • Calling methods on a port you use requires that you first
    obtain a “handle” for the port
             – Done by invoking getPort() on the user’s gov.cca.Services object
             – Free up handle by invoking releasePort() when done with port
  • Best practice is to bracket actual port usage as closely
    as possible without using getPort()/releasePort() too
    frequently
             – Can be expensive operations, especially in distributed computing
               contexts
             – Performance is in tension with dynamism
                • can’t “re-wire” components while one of their ports is “in use”
                                                                                       36
CCA
Common Component Architecture




   Components Must Keep Frameworks Informed
                                IntegratorPort   FunctionPort   FunctionPort


                                   MidpointIntegrator              NonlinearFunction

      • Components must tell the framework about the ports
        they are providing and using
                 – Framework will not allow connections to ports it isn’t aware of
      • Register them using methods on the component’s
        gov.cca.Services object
                 – addProvidesPort() and removeProvidesPort()
                 – registerUsesPort() and unregisterUsesPort()
                 – All are defined in the CCA specification
      • Ports are usually registered in the component’s
        setServices() method
                 – Can also be added/removed dynamically during execution


                                                                                       37
CCA
Common Component Architecture




         Interfaces, Interoperability, and Reuse
                                           • “Common” or “community”
      • Interfaces define how                interfaces facilitate reuse and
        components interact…                 interoperability
      • Therefore interfaces are key          – Typically domain specific
        to interoperability and reuse         – Formality of “standards” process
                                                varies
        of components
                                              – Significant initial investment for
                                                long-term payback
      • In many cases, “any old
        interface” will do, but…           • Biggerstaff’s Rule of Threes
      • Achieving reuse across                – Must look at at least three systems
        multiple applications requires          to understand what is common
        agreement on the same                   (reusable)
                                              – Reusable software requires three
        interface for all of them
                                                times the effort of usable software
                                              – Payback only after third release
    More about community interface development efforts in “Applications” module
                                                                                      38
CCA
Common Component Architecture




                                CCA Concepts: Frameworks

      • The framework provides the means to “hold”
        components and compose them into applications
      • Frameworks allow connection of ports without
        exposing component implementation details
      • Frameworks provide a small set of standard services
        to components

      • Currently: specific frameworks are specialized for
        specific computing models (parallel, distributed, etc.)
      • Future: better integration and interoperability of
        frameworks
                                                                  39
CCA
Common Component Architecture




                       See the Hands-On for Examples

 See the Hands-On portion of the tutorial for examples of…

 • CCA components

 • Provides and uses ports

 • Using a CCA framework to assemble and run
   applications

 • and more…
         If there is no hands-on session in this tutorial, you can
         download the Hands-On Guide and code from our
         website to study at home
                                                                     40
CCA
Common Component Architecture




                                Adapting Existing Code into
                                       Components         Example in
                                                    the hands-on!
      Suitably structured code (programs, libraries) should be
         relatively easy to adapt to the CCA. Here’s how:
      1. Decide level of componentization
                 – Can evolve with time (start with coarse components, later
                   refine into smaller ones)
      2. Define interfaces and write wrappers between them
         and existing code
      3. Add framework interaction code for each component
                 – setServices()
      4. Modify component internals to use other
         components as appropriate
                 – getPort(), releasePort() and method invocations
                                                                               41
CCA
Common Component Architecture




                    CCA Supports Local, Parallel and
                        Distributed Computing
                                           Integrator                   Linear Fun
• “Direct connection” preserves high
  performance of local (“in-process”)                   Provides/Uses
                                                             Port
  and parallel components
   • Framework makes connection                  Direct Connection
   • But is not involved in invocation

• Distributed computing has same           Integrator
  uses/provides pattern, but                        Provides
  framework intervenes between user                   Port
  and provider                                                      Network
    • Framework provides a proxy                                   Connection
      provides port local to the uses
      port                                                              Linear Fun
    • Framework conveys invocation                            Proxy
      from proxy to actual provides port                     Provides/
                                                             UsesPort
                                                                                     42
CCA
Common Component Architecture




             CCA Concepts: “Direct Connection”
               Maintains Local Performance
      • Calls between components equivalent to a C++
        virtual function call: lookup function location, invoke it
                 – Overhead is on the invocation only, not the total execution
                   time
                 – Cost equivalent of ~2.8 F77 or C function calls
                 – ~48 ns vs 17 ns on 500 MHz Pentium III Linux box
      • Language interoperability can impose additional
        overheads
                 – Some arguments require conversion
                 – Costs vary, but small for typical scientific computing needs
      • Calls within components have no CCA-imposed
        overhead                         More about performance in
                                                           the “Applications” module
                                                                                       43
CCA
Common Component Architecture




                           Maintaining HPC Performance
      • The performance of your application is as important
        to us as it is to you
      • The CCA is designed to provide maximum
        performance
                 – But the best we can do is to make your code perform no
                   worse
                 – Are the additional benefits worth the small CCA overhead?
      • Facts:
                 – Measured overheads per function call are low
                 – Most overheads easily amortized by doing enough work per
                   call
                 – Converting from shared data structures to using abstract
                   interfaces (CCA or not) can impose a larger overhead than
                   adding CCA on top of an existing interface
                 – Awareness of costs of abstraction and language
                   interoperability facilitates design for high performance
                                                                               44
 CCA
 Common Component Architecture
                                                                        ••••


         CCA Concepts: Framework Stays “Out
         of the Way” of Component Parallelism
• Single component multiple data    P0       P1           P2           P3
  (SCMD) model is component
  analog of widely used SPMD
  model
• Each process loaded with the
  same set of components wired
  the same way
•Different components in same
 process “talk to each” other via
 ports and the framework
                                     Components: Blue, Green, Red
•Same component in different
 processes talk to each other              Framework: Gray
 through their favorite                  MCMD/MPMD also supported
 communications layer (i.e.
 MPI, PVM, GA)                           Other component models
                                         ignore parallelism entirely        45
CCA
Common Component Architecture




             “Multiple-Component Multiple-Data”
                     Applications in CCA
    • Simulation composed of multiple SCMD sub-tasks
    • Usage Scenarios:
              – Model coupling (e.g. Atmosphere/Ocean)
              – General multi-physics applications
              – Software licensing issues                                     Driver
                                                                  Atmosphere Ocean Land
                                                                            Coupler
    • Approaches
              – Run single parallel framework                    Processors
                         • Driver component that partitions processes and builds rest of
                           application as appropriate (through BuilderService)
              – Run multiple parallel frameworks
                         • Link through specialized communications components
                         • Link as components (through AbstractFramework service)
                                                                                           46
CCA
Common Component Architecture
                                                                ••••




                  MCMD Within A Single Framework
Working examples available                P0    P1   P2    P3
using Ccaffeine framework,
with driver coded in Python


            Framework

              Application driver & MCMD
              support component
              Components on all
              processes

            Components only on
            process group A

            Components only on
            process group B                Group A    Group B
                                                                 47
CCA
Common Component Architecture




                                Advanced CCA Concepts
                                 Brief introductions only, but more
                                  info is available – just ask us!
•       The Proxy Component pattern (Hands-On Ch. 6, papers)
•       Component lifecycle (tutorial notes, Hands-On)
•       Components can be dynamic (papers)
•       AbstractFramework (papers)
           – Frameworks may present themselves as components to other
             frameworks
           – A “traditional” application can treat a CCA framework as a library
• Coupling codes: parallel data redistribution and parallel
  remote method invocation (papers)
• Frameworks can provide a specialized programming
  environment (tutorial notes, papers)
                                                                                  48
CCA
Common Component Architecture




                           The Proxy Component Pattern
      • Component interfaces offer an        Performance Monitoring with TAU
        obvious place to collect
        information about method                           Before:
        invocations for performance,          Component1                Component2
        debugging, or other purposes
               – No intrusion on component
                 internals
      • A “proxy” component can be
        inserted between the user and
        provider of a port without either                   After:
        being aware of it
      • Proxies can often be generated       Component1     Proxy for      Component2
        automatically from SIDL definition                 Component2
        of the port
      Sample uses for proxy components:
      • Performance: instrumentation of
                                                           MasterMind          TAU
        method calls                                       (database)        (measure-
      • Debugging: execution tracing,                                          ment)
        watching data values
      • Testing: Capture/replay
                                                                                         49
CCA
Common Component Architecture




                                                  Additional
                Component Lifecycle                material
                                                   in notes
      • Composition Phase (assembling application)
                 – Component is instantiated in framework
                 – Component interfaces are connected appropriately

      • Execution Phase (running application)
                 – Code in components uses functions provided by another
                   component

      • Decomposition Phase (termination of application)
                 – Connections between component interfaces may be broken
                 – Component may be destroyed

                In an application, individual components may be in
                          different phases at different times
                  Steps may be under human or software control              50
CCA
Common Component Architecture




                                Components can be Dynamic
      • BuilderService allows programmatic composition of
        components
                 – Components can be instantiated, destroyed, connected, and
                   disconnected under program control
                 – Framework service defined in CCA spec
      Sample uses of BuilderService:
      • Python “driver” script which can assemble and control
        an application
                 – i.e. MCMD climate model
      • Adaptation to changing conditions
                 – Swap components in and out to give better performance,
                   numerical accuracy, convergence rates, etc.
      • Encapsulation of reusable complex component
        assemblies
                 – Create a “container component” which exposes selected
                   ports from the enclosed components
                                                                               56
CCA
Common Component Architecture




                                Coupling Codes
                                                                    Driver
• Components provide a natural way to                   Atmosphere Ocean Land
  think about coupling codes together                           Coupler
       – i.e. multi-scale, multi-physics simulations   Processors
• Coupled codes may naturally run on
  different numbers of processors, even
  different machines
• Coupling may involve exchanging data
       – Parallel data redistribution (aka “MxN”
         problem)
• Coupling may involve parallel                                        PRMI
  procedure calls
       – Parallel remote method invocation (PRMI)
• Research areas in which CCA is
  developing tools
                                                                                57
CCA
Common Component Architecture




                                Is CCA for You?
• Much of what CCA does can be done without such tools if
  you have sufficient discipline
         – The larger a group, the harder it becomes to impose the necessary
           discipline
• Projects may use different aspects of the CCA
         – CCA is not monolithic – use what you need
         – Few projects use all features of the CCA… initially
• Evaluate what your project needs against CCA’s
  capabilities
         – Other groups’ criteria probably differ from yours
         – CCA continues to evolve, so earlier evaluations may be out of date
• Evaluate CCA against other ways of obtaining the desired
  capabilities
• Suggested starting point:
         – CCA tutorial “hands-on” exercises
                                                                                59
CCA
Common Component Architecture




                        Take an Evolutionary Approach

      • The CCA is designed to allow selective use and
        incremental adoption

      • “Babelize” interfaces incrementally
                 – Start with essential interfaces
                 – Remember, only externally exposed interfaces need to be
                   Babelized

      • Componentize at successively finer granularities
                 – Start with whole application as one component
                            • Basic feel for components without “ripping apart” your app.
                 – Subdivide into finer-grain components as appropriate
                            • Code reuse opportunities
                            • Plans for code evolution
                                                                                            60
CCA
Common Component Architecture




                                View it as an Investment

      • CCA is a long-term investment in your software
                 – Like most software engineering approaches

      • There is a cost to adopt

      • The payback is longer term

      • Remember Biggerstaff’s Rule of Threes
                 – Look at three systems, requires three times the effort,
                   payback after third release




                                                                             61
CCA
Common Component Architecture




                       CCA is Still Under Development

      • We’ve got…
                 – A stable component model
                 – Working tools
                 – Active users

      • But…
                 – We know its not perfect
                 – We’re not “done” by any stretch

      • Talk to us…
                 – If you’re evaluating CCA and and need help or have
                   questions
                 – If you don’t think CCA meets your needs
                 – If you’ve got suggestions for things we might do better
                                                                             62
CCA
Common Component Architecture




                                What Can CCA Do Today?

      • Ccaffeine framework for HPC/parallel
                 – XCAT and other options for distributed computing

      • Language interoperability
                 – Fortran 77/90/95, C, C++, Java, Python
                 – Support for Fortran/C user-defined data structures under
                   development

      • Primarily support Linux platforms so far
                 – IBM AIX, Sun Solaris, Mac OS X likely to work, but few users
                   so far
                 – Working on Cray X1, XT3
                 – Porting is demand-driven


                                                                                  63
CCA
Common Component Architecture




        CCA Tools – Language
   Interoperability and Frameworks




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   64
CCA
Common Component Architecture




                                      Goal of This Module
                                              CCA/Frameworks
                                Component A                    Component B



                                                               CCA IDE
                                               Babel   Chasm


      • Describe tools for multi-lingual, scientific
        component ‘plug-and-play’


      IDE = Interactive Development Environment                              65
CCA
Common Component Architecture




                                   Tools Module Overview
                                              CCA/Frameworks
                                Component A                    Component B



                                                               CCA IDE
                                               Babel   Chasm
      • Language interoperability tools

      • Frameworks

      • CCA Interactive Development Environment
                                                                             66
CCA
Common Component Architecture
                                                 Babel                                      Versioned

           Babel Facilitates Scientific
     Programming Language Interoperability
      • Programming language-neutral interface descriptions
      • Native support for basic scientific data types
                 – Complex numbers
                 – Multi-dimensional, multi-strided arrays
      • Automatic object-oriented wrapper generation
                                 f77                                         f77

  C                                      f90                 C                                f90
                                Babel            vs.
C++                                     Python             C++                             Python

                                Java                                        Java
                         Supported on Linux, AIX, and Solaris 2.7, works on OSX;
           C (ANSI C), C++ (GCC), F77 (g77, Sun f77), F90 (Intel, Lahey, GNU, Absoft), Java (1.4)
                                                                                                    67
CCA
Common Component Architecture
                                                 Babel

            Babel Generates Object-Oriented
          Language Interoperability Middleware
                                                            Stubs

                                       Babel                 IORs
    comp.sidl                                                                         libcomp.so
                                      Compiler            Skeletons

                                                     Implementations
                                                                                        Babel
                                user creates                                           Runtime


1.          Write your SIDL file to define public methods
2.          Generate server side in your native language using Babel
3.          Edit Implementations as appropriate
4.          Compile and link into library/DLL


      IOR = Intermediate Object Representation     SIDL = Scientific Interface Definition Language   68
 CCA
 Common Component Architecture
                                                  Babel


Clients in any supported language can access
      components in any other language
                      C           C++        F77          F90       Java    Python
                    Stubs        Stubs      Stubs        Stubs      Stubs   Stubs



                                                  IORs


                                               Skeletons


                                            Implementations


                                                Component
                                         (any supported language)              Babel
                                                                            presentation
       IOR = Intermediate Object Representation
                                                                             coming up!    69
CCA
Common Component Architecture
                                                     Chasm                           Versioned


              Chasm Provides Language
        Interoperability for Fortran, C, and C++
      • Extracts interfaces from C/C++ and Fortran90 codes
      • Uses library of XSLT stylesheets for language
        transformations  easily extended
                 – Generates XML and SIDL representations
                 – Generates Fortran90 Babel implementation glue
      • Provides Fortran array descriptor library used by Babel



                           Supported on Linux, AIX, and Solaris 2.7, works on OSX;
                           C (ANSI C), C++ (GCC), F90 (Intel, Lahey, GNU, Absoft)


                                                                                             71
CCA
Common Component Architecture
                                                 Chasm

               The Entire Chasm Process Involves
                        Three Basic Steps
                      .f90      gfortran         .ptd

                                                                              .sidl

                                gfortran2xml        .impl.xml

                                                                    xalan   _Impl.F90
                       user creates            comp.impl.xml

                                                                            _Mod.F90

   1. Start with a Fortran (or C/C++) source file
   2. Create an XML description of the component (or port)
   3. Generate the SIDL specification and glue code files

      XML = Extensible Markup Language             PTD = Parse Tree Dump                72
CCA
Common Component Architecture




                                   Tools Module Overview
                                              CCA/Frameworks
                                Component A                    Component B



                                                               CCA IDE
                                               Babel   Chasm
      • Language interoperability tools

      • Frameworks

      • CCA Interactive Development Environment
                                                                             76
CCA
Common Component Architecture




        Frameworks are Specialized to Different
             Computing Environments
                                           Integrator                   Linear Fun
• “Direct connection” preserves high
  performance of local (“in-process”)                   Provides/Uses
                                                             Port
  and parallel components
   • Framework makes connection                  Direct Connection
   • Framework not involved in
     invocation
                                           Integrator
• Distributed computing has same                    Provides
  uses/provides pattern, but the                      Port
  framework intervenes between user                                Network
  and provider                                                    Connection
    • Framework provides a proxy port
      local to the user’s uses port                                     Linear Fun
    • Framework conveys invocation                           Proxy
      from proxy to actual provides port                    Provides/
                                                            Uses Port
                                                                                     77
CCA
Common Component Architecture




     Graphical User Interfaces (GUIs) Deliver
           Plug-and-Play Experience
      • Plug & play for:
                 – Application software assembly
                 – Visualization pipelines
                 – Workflow management
      • Assembling “wiring” diagrams is almost
        universal.
                 – Software assembly: Ccaffeine, XCAT, SciRUN
                 – Workflow: XCAT, SciRUN
                 – Visualization: SciRUN
         None of these (yet) plug into your favorite Integrated Development Environment
                         (e.g., Eclipse, MS Dev. Studio, Java Studio, …).
                                                                                          78
CCA
Common Component Architecture
                                           Ccaffeine Framework                          Versioned


                            Ccaffeine is a Direct-Connect,
                             Parallel-Friendly Framework
      • Supports SIDL/Babel components
                 – Conforms to latest CCA specification (0.7)
                 – Also supports legacy CCA specification (0.5)
                            • Any C++ allowed with C and Fortran by C++ wrappers
      • Provides command-line and GUI for composition
                 – Scripting supports batch mode for SPMD
                 – MPMD/SPMD custom drivers in any Babel language



                       Supported on Linux, AIX, OSX and is portable to modern UNIXes.


                                                                                                79
 CCA
 Common Component Architecture
                                       Ccaffeine Framework


Ccaffeine Involves a Minimum of Three Steps

       • As easy as 1-2-3:
                  – Write your component.
                  – Describe it with an XML file.
                  – Add a line to your Ccaffeine input file to load the
                    component at runtime.


       • Proceed to plug & play...

               There are many details and automated tools that help manage components.

                                                                                         80
CCA
Common Component Architecture
                                            Ccaffeine Framework (ccafe-gui)                Versioned

Optional
                                                 Ccaffeine GUI
      • Process
                 – User input is broadcast SPMD-wise from Java.
                 – Changes occur in GUI after the C++ framework replies.
                 – If your components are computing, GUI changes are blocked.

      • Components interact through port connections
                 – provide ports implement class or subroutines        “Provides” Port

                 – use ports call methods or subroutines in the port. “Uses” Port
                 – Links denote caller/callee relationship not data flow

                                IntegratorPort   FunctionPort      FunctionPort


                                    MidpointIntegrator                 NonlinearFunction


                                                        Java is required.
                                                                                                   81
  CCA
  Common Component Architecture
                                     Ccaffeine Framework (ccafe-gui)


                            Building an Application (1 of 2)
 • Components are code + XML metadata
 • Using metadata, a Palette of available components is constructed.
 • Components are instantiated by user action (i.e. by dragging from
   Palette into Arena).
 • Framework calls
   component’s constructor,
   then setServices




create            Driver               Driver
create            LinearFunction       LinearFunction
create            MonteCarloIntegrator MonteCarloIntegrator

                                                                       83
CCA
Common Component Architecture
                                Ccaffeine Framework (ccafe-gui)


                          Building an Application (2 of 2)
 1. Click Configure port to
 start parameter input
 dialogue.



 2. For each connection:
 click a uses port
 then click a provides port
 to establish a connection.



 3. Click Go port to start
 the application.

Right-clicking a connection line breaks the connection -- enabling component substitution.

                                                                                             84
CCA                                XCAT-C++ Framework                       Alpha
Common Component Architecture




                       XCAT is a Web-based
                Distributed Component Framework
      • Remote references
                 – Port types described in C++ header files or in WSDL documents
      • User Interface
                 – C++ and Python interface to CCA BuilderService
                 – Uses SWIG for Python-C++ translations
      • Component creation
                 – Remote creation via SSH
      • Component communication
                 – Proteus multi-protocol library
                 – Communication libraries can be loaded at run-time

                                      Tested on Linux.

      WSDL = Web Service Definition Language                                       87
CCA
Common Component Architecture
                                  XCAT-C++ Framework

                         XCAT is Designed for High-Performance
                                 Scientific Applications




                                                                 88
CCA                                SCIRun2 Framework         Alpha
Common Component Architecture




       SCIRun2 is a Cross-Component Model,
        Distributed Component Framework
• Semi-automatically bridges component models
           – Templated components connected at
             run-time generate bridges
• Parallel Interface Definition Language
  (PIDL) – a SIDL variant
• User interface – GUI and textual
           – Dynamic composition
• Component and framework creation
           – Remote via SSH
• Component communication
           – C++ RMI with co-location optimization
           – MPI/ Parallel Remote Method Invocation (PRMI)


                                    Supported on Linux.
                                                                 90
CCA
 Common Component Architecture
                                                SCIRun2 Framework

Master Framework Coordinates Slave Frameworks in Each
               Remote Address Space
                                   SCIRun2 Framework (Master Framework)


                      Component Loader                       Component Loader
                      (Slave Framework)                      (Slave Framework)



                             Component                          Component
                                                                                   Connection
                          Provides Ports                       Provides Ports
                                                                                     Table
                        Component Code         PRMI          Component Code      (Referencing remote
                            (User)                               (User)             Components)


                        Component Code                       Component Code
                        (PIDL-Generated)                     (PIDL-Generated)     Component ID
                                                                                     Table
                             Uses Ports                         Uses Ports       (Referencing remote
                                                                                    provides ports)




                 Service Object                                 Service Object

                                           Builder Service

                                                                                                       91
CCA
Common Component Architecture
                                         SCIRun2 Framework

                                        Basic How-To
     1. Add component source files and makefile to
        SCIRun2 sources
                         May need to define ports in SIDL
     2. Add component information to the component
        model xml file
     3. Build component using SCIRun2 make scripts
                         Alternatively, build component using Babel
     4. Start the framework and graphical (default) or text
        builder
     5. Graphically connect component to other CCA-based
        or non CCA-based components
                         May need to create bridge components to go between
                          models
     6. Press the “Go” button on the driver component
                                                                               92
CCA
Common Component Architecture




                                   Tools Module Overview
                                              CCA/Frameworks
                                Component A                    Component B



                                                               CCA IDE
                                               Babel   Chasm
      • Language interoperability tools

      • Frameworks

      • CCA Interactive Development Environment
                                                                             96
CCA                                             CCA IDE                   Alpha
Common Component Architecture




       Component Development Environment
          Provided via Eclipse Plug-ins

      • Provides a high-level graphical environment
                 – Creating new SIDL-based components
                 – Componentizing legacy codes
                            • C, C++, Java and Fortran
      • Automatic code generation




                                    Supported on Linux, Windows, MacOS.

                                                                              97
 CCA
 Common Component Architecture
                                                     CCA IDE

Component Development Environment Starts at the
            Eclipse Platform Level

Plug-ins for:
• SIDL Editor

• Wizards

• Preliminary
automated build
support




                                 Imperative that you start by creating a new project!
                                                                                        98
 CCA
 Common Component Architecture
                                 CCA IDE


  Wizards are Available for Adding Packages and
  Classes or Generating SIDL from Legacy Codes

• Intuitive
interfaces to port
and component
definition

• Helper wizards
for setting port,
component and
(in the future)
application
properties




                                                  99
CCA
Common Component Architecture




                                        Module Summary
                                              CCA/Frameworks
                                Component A                    Component B



                                                               CCA IDE
                                               Babel   Chasm


      • Described tools for multi-lingual, scientific component
        ‘plug-and-play’
                 – Language interoperability through Babel and Chasm
                 – CCA Frameworks provide mechanisms for composition
                 – CCA Interactive Development Environment via Eclipse plug-in

                                                                                 104
CCA
Common Component Architecture

                   Language Interoperable
                    CCA Components via




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   105
CCA
Common Component Architecture




                                Goal of This Module

        Legacy codes  Babelized CCA Components

      • Introduction
      • Example
                 – “Hello World”
      • Babelized CCA components




                                                      106
 CCA
 Common Component Architecture




Language Interoperability Facilitates Building
      Multiple Language Applications
                                             Scripting Driver
                                                (Python)


          Simulation Framework                                  Visualization System
                   (C)                                                  (Java)


 Numerical Routines                       Solver Library
       (f77)                                  (C++)


                                 Callback Handlers
                                      (Python)
                                                                                       107
CCA
Common Component Architecture




             Babel Toolkit Consists of Two Parts:
             Code Generator + Runtime Library
                                                        HTML
                                                        XML
                                                                 Babel
                                                         C      Runtime
                                                        C++

    SIDL                         Babel                  F77
  interface                                                    Application
                                Compiler                F90
 description
                                                        Java

                                                    Python



      SIDL = Scientific Interface Definition Language                        108
 CCA
 Common Component Architecture




The Basic Middleware Generation Process is
           Fairly Straightforward
                                                       Stubs

                                  Babel                 IORs
  mycode.sidl                                                        libmycode.so
                                 Compiler             Skeletons

                                                   Implementations




 1.          Write your SIDL file to define public methods
 2.          Generate middleware in your native language using Babel
 3.          Fill in the implementation details as appropriate
 4.          Compile and link into library/DLL
        IOR = Intermediate Object Representation                                109
CCA
Common Component Architecture




                                Babel Module’s Outline

       • Introduction
       • Example
                 – “Hello World”
       • Babelized CCA components




                                                         110
CCA
Common Component Architecture




  greetings.sidl: A Sample SIDL File for our
           “Hello World” Example
   package greetings version 1.0 {
                    interface Hello {
                                void setName( in string name );
                                string sayIt ( );
                    }
                    class English implements-all Hello {          }
   }



                                                                      111
CCA
 Common Component Architecture
                                                                                   •




       At a Minimum, the Library Developer
      Generates Single-Language Middleware
                                              C++ Stubs

                                  Babel          IORs
greetings.sidl                                                  libgreetings.so
                                 Compiler
                                            C++ Skeletons

                                                 C++
                                            Implementations
                                                              legacy_library.so


 1. Execute `babel --server=C++ greetings.sidl`
 2. Fill in the implementation details to dispatch to legacy code
 3. Compile and link into a library/DLL
                                                                                  112
CCA
Common Component Architecture




     Implementation Details Must be Filled in
            Between Splicer Blocks
 namespace greetings {
 class English_impl {
   private:
     // DO-NOT-DELETE splicer.begin(greetings.English._impl)
     string d_name;
     // DO-NOT-DELETE splicer.end(greetings.English._impl)

 string
 greetings::English_impl::sayIt()
 throw ()
 {
   // DO-NOT-DELETE splicer.begin(greetings.English.sayIt)
   string msg(“Hello “);
   return msg + d_name + “!”;
   // DO-NOT-DELETE splicer.end(greetings.English.sayIt)
 }
                                                               113
  CCA
  Common Component Architecture




To Allow the Library User To Use Another Language,
    the Library Developer Must Generate Stubs

                                                               Babel
                                                              Runtime


                                              F90 Stubs
                                   Babel
  greetings.sidl                             IOR Headers     Application
                                  Compiler

                                                           libgreetings.so

                                                            Could be done
  1.          Execute `babel --client=F90 greetings.sidl` by the User!
  2.          Invoke stub versions of the methods
  3.          Compile and link with generated code, library, & Runtime
  4.          Place DLL in suitable location
                                                                             114
CCA
Common Component Architecture
                                                                 ••




       So an F90 Version of the “Hello World”
             Application is Pretty Basic
   program helloclient
     use greetings_English
     implicit none
     type(greetings_English_t) :: obj
     character (len=80)        :: msg
     character (len=20)        :: name

         name=’World’                 These subroutines were
         call new( obj )              specified in the SIDL.
         call setName( obj, name )
         call sayIt( obj, msg )
         print *, msg                Other basic subroutines
         call deleteRef( obj )       are “built in” to SIDL
                                     classes (and interfaces).
   end program helloclient
                                                                 115
                                                                            • • • • • •
CCA
Common Component Architecture




                                Using Babel, Step-by-Step

                                 SIDL




               C Stub                               C Skel      C Impl

                                                    C++ Skel    C++ Impl
                                                                            C++
               C++ Stub
                                    Intermediate                            Library
               F77 Stub                Object       F77 Skel    F77 Impl
                                   Representation
               F90 Stub                  (C)        F90 Skel    F90 Impl

               Java Stub                            Java Skel   Java Impl

               Py Stub                              Py Skel     Py Impl


                                                                                          116
CCA
Common Component Architecture




                                Babel Module’s Outline

       • Introduction
       • Example
                 – “Hello World”
       • Babelized CCA components




                                                         117
CCA
Common Component Architecture




                               How to write a
                       Babelized CCA Component (1/3)
      1. Define “Ports” in SIDL
                 – CCA Port =
                            •   a SIDL Interface
                            •   extends gov.cca.Port

      package functions version 1.0 {
          interface Function extends gov.cca.Port {
              double evaluate( in double x );
          }
      }




                                                       118
CCA
Common Component Architecture




                               How to write a
                       Babelized CCA Component (2/3)
2. Define “Components” that implement those Ports
      – CCA Component =
                 •        SIDL Class
                 •        implements gov.cca.Component (and any provided ports)

  class LinearFunction implements functions.Function,
                                  gov.cca.Component {
        double evaluate( in double x );
        void setServices( in cca.Services svcs );
  }

  class LinearFunction implements-all
         functions.Function, gov.cca.Component { }
                                                                                  119
CCA
Common Component Architecture




                               How to write a
                       Babelized CCA Component (3/3)
 Repo
 (XML)
                                              C Stubs

                                                IORs
                                 Babel
functions.sidl                               C Skeletons     libfunctions.so
                                Compiler
                                                 C
                                           Implementations



      3. Use Babel to generate the interoperability glue
                 – Execute `babel --server=C –RRepo functions.sidl`
      4. Fill in Implementations as needed
                                                                               121
CCA
Common Component Architecture




                                Contact Information
      • Project:                     http://www.llnl.gov/CASC/components
                 –      Babel: language interoperability tool
                 –      Alexandria: component repository
                 –      Quorum: web-based parliamentary system
                 –      Gauntlet: testing framework
      • Project Team Email:                          components@llnl.gov
      • Mailing Lists:                            majordomo@lists.llnl.gov
                 subscribe babel-users [email address]
                 subscribe babel-announce [email address]
      • Bug Tracking: https://www.cca-forum.org/bugs/babel/
                     or email to babel-bugs@cca-forum.org

                                                                             122
CCA
Common Component Architecture




                        CCA Applications




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   123
CCA Common Component Architecture




                   Modern Scientific Software Development
•         Complex codes, often coupling multiple types of physics, time or length
          scales, involving a broad range of computational and numerical
          techniques
•         Different parts of the code require significantly different expertise to
          write (well)
                                                     Time Evolution
•         Generally written
          by teams rather
                                                     Physics Modules
          than individuals
                                                                                   Adaptive Solution
                                                                   Mesh
                                           Optimization
                                                                                     Diagnostics
                                                               Discretization          Steering
                                    Derivative Computation
                                                             Algebraic Solvers       Visualization


                                                               Data Reduction      Collaboration

                                                             Data Redistribution

                                                                                                       124
CCA
Common Component Architecture




                                          Overview

      • Examples (scientific) of increasing complexity
                 –      Laplace equation
                 –      Time-dependent heat equation
                 –      Nonlinear reaction-diffusion system
                 –      Quantum chemistry
                 –      Climate simulation
      • Tools
                 – MxN parallel data redistribution
                 – Performance measurement, modeling and scalability studies
      • Community efforts & interface development
                 – TSTT Mesh Interface effort
                 – CCTTSS’s Data Object Interface effort


                                                                               125
CCA
Common Component Architecture




                                   Laplace Equation

                                2 (x,y) = 0  [0,1] x [0,1]
                                (0,y)=0 (1,y)=sin (2y)
                                /y(x,0) = /y(x,1) = 0

             Physics Modules

                       Mesh

               Discretization          Visualization

            Algebraic Solvers


                                                                126
CCA
Common Component Architecture




               Laplace Equation with Components
•      The Driver
       Component
          – Responsible for
            the overall
            application flow
          – Initializes the
            mesh,
            discretization,
            solver and
            visualization
            components
          – Sets the physics
            parameters and
            boundary
            condition
            information




                                                  127
CCA
Common Component Architecture




               Laplace Equation with Components
•      The Driver
     • Component
         The Mesh
          –Component for
             Responsible
             the overall
            – Provides
             application flow
                geometry,
          – Initializes the
                topology, and
             mesh,
                boundary
             discretization,
                information
             solver and
            – Provides the
             visualization
                ability to attach
             components
                user defined data
          – Sets the physics
                as tags to mesh
             parameters and
                entities
             boundary
            – Is used by the
             condition
                driver,
             information
                discretization and
                visualization
                components
                                                  128
CCA
Common Component Architecture




               Laplace Equation with Components
•      The Driver
     • Component
         The Mesh
          –Component for
             Responsible
          • the overall
              The Discretization
            –Component
                Provides
             application flow
                geometry and
               – Provides
          – Initializes the a finite
                topology
             mesh, element
                information
                   discretization of
             discretization,
            – Providesoperators
                   basic the
             solver and
                ability to attach
                   (gradient,
             visualization
                user defined data
                   Laplacian, scalar
             components
                to mesh entities
          – Sets terms)
                   the physics
            – – used by the
                Is Driver
             parameters and
                driver,
                   determines which
             boundary
                discretization and
                   terms
             condition are
                visualization
                   included
             information and
                components
                   their coefficients
               – Boundary
                   conditions,
                   assembly etc                   129
CCA
Common Component Architecture




               Laplace Equation with Components
•      The Driver
     • Component
         The Mesh
          –Component for
             Responsible
          • the overall
              The Discretization
            –Component
                Provides
             application flow
            • geometry and
                 The Solver
               –Component
          – Initializes the a finite
                   Provides
                topology
             mesh, element
                  – Provides
                information access
                   discretization of
             discretization,
            – Providesoperators
                      to vector and
                   basic the
             solver and
                      matrix operations
                ability to attach
                   (gradient,
             visualization
                      (e.g., create,
                user defined data
                   laplacian,
             components scalar
                      destroy, get,
                to mesh entities set)
                   terms)
          – Sets the physics
            – – – Provides a
                Is used by the
                   Provides
             parameters and
                      “solve”
                driver,
                   mechanisms for
             boundary
                      functionality
                discretization and for a
                   general Dirichlet
             condition
                      linear operator
                visualization
                   and Neumann
             information
                components
                   boundary
                   condition
                   manipulations
                                                  130
CCA
Common Component Architecture




               Laplace Equation with Components
•      The Driver
     • Component
         The Mesh
          –Component for
             Responsible
          • the overall
              The Discretization
            –Component
                Provides
             application flow
            • geometry and
                 The Solver
               –Component
          – Initializes the a finite
                   Provides
               •topologyVisualization
             mesh,The
                   element
                  – Component
                information access
                      Provides
                   discretization of
             discretization,
            – Providesoperators
                      to vector and
                   basic the
                      –
             solver andUses the mesh
                      matrix operations
                ability to attach
                   (gradient,
             visualizationcomponent to
                user (e.g., create,
                      defined scalar
                   laplacian, data
             components a vtk file of
                          print
                      destroy, get,
                to mesh entities set)
                          
          – Sets terms) on the
                   the physics
            – – –Providesthe a
                      Provides
                          by
                Is used unstructured
             parameters and
                      “solve”
                driver,
             boundary triangular mesh
                   mechanisms for
                      functionality
                discretization andfor a
                      –
                   general Dirichlet
             condition Assumes user
                      linear operator
                visualization
                   and Neumann
             information  data is attached
                components
                   boundary
                          to mesh vertex
                   condition
                          entities
                   manipulations
               – Computes                         131
CCA
Common Component Architecture




                         Time-Dependent Heat Equation
                                   /t = 2 (x,y,t)  [0,1] x [0,1]
                                (0,y,t)=0 (1,y,t)=.5sin(2y)cos(t/2)
                                       /y(x,0) = /y(x,1) = 0
                                      (x,y,0)=sin(.5x) sin (2y)
              Time Evolution

             Physics Modules

                       Mesh

               Discretization              Visualization

            Algebraic Solvers


             Distributed Arrays          Data Redistribution
                                                                         132
CCA
Common Component Architecture




                                Some things change…
      • Requires a time integration component
                 – Based on the LSODE library
      • Uses a new visualization component
                 – Based on AVS
      • The visualization component requires a
        Distributed Array Descriptor component
                 – Similar to HPF arrays
      • The driver component changes to
        accommodate the new physics

                                                      133
CCA
Common Component Architecture




                   … and some things stay the same

      • The mesh component doesn’t change
      • The discretization component doesn’t change
      • The solver component doesn’t change
                 – What we use from the solver component changes
                 – Only vectors are needed




                                                                   134
CCA
Common Component Architecture




                           Heat Equation Wiring Diagram




                                                          Reused
                                                          Integration
                                                          Visualization
                                                          Driver/Physics

                                                                           135
CCA
Common Component Architecture




                      What did this exercise teach us?
      • Easy to incorporate the functionalities of components
        developed at other labs and institutions given a well-
        defined interface.
                 – In fact, some components (one uses and one provides) were
                   developed simultaneously across the country from each other
                   after the definition of a header file.
                 – Amazingly enough, they usually “just worked” when linked
                   together (and debugged individually).
      • In this case, the complexity of the component-based
        approach was higher than the original code
        complexity.
                 – Partially due to the simplicity of this example
                 – Partially due to the limitations of the some of the current
                   implementations of components

                                                                                 136
CCA
Common Component Architecture




        Nonlinear Reaction-Diffusion Equation

 •       Flame Approximation
            – H2-Air mixture; ignition via 3 hot-spots
            – 9-species, 19 reactions, stiff chemistry
 •       Governing equation

                         Yi
                              .Yi  wi
                                        
                         t
 •       Domain
            – 1cm X 1cm domain
            – 100x100 coarse mesh
            – finest mesh = 12.5 micron.
 •       Timescales
            – O(10ns) to O(10 microseconds)

                                                         137
CCA
Common Component Architecture




                                Numerical Solution

      •       Adaptive Mesh Refinement: GrACE
      •       Stiff integrator: CVODE
      •       Diffusive integrator: 2nd Order Runge Kutta
      •       Chemical Rates: legacy f77 code
      •       Diffusion Coefficients: legacy f77 code
      •       New code less than 10%




                                                            138
CCA
Common Component Architecture




                 Reaction-Diffusion Wiring Diagram




                                           Reused
                                           Slow Time Scale Integration
                                           Fast Time Scale Integration
                                           Driver/Physics
                                                                         139
  CCA
  Common Component Architecture




                                     Evolution of the Solution



Temperature




                                  No OH at t = 0
OH Profile




                                                                 140
CCA
Common Component Architecture




                                The need for AMR
      • H2O2 chemical subspecies profile
                 – Only 100 microns thick (about 10 fine level cells)
                 – Not resolvable on coarsest mesh




                                                                        141
CCA
Common Component Architecture




             Unconstrained Minimization Problem
 • Given a rectangular 2-dimensional domain and
   boundary values along the edges of the domain
 • Find the surface with minimal area that satisfies the
   boundary conditions, i.e., compute
     min f(x), where f: R  R
 • Solve using optimization
   components based on
   TAO (ANL)




                                                           142
CCA
Common Component Architecture




     Unconstrained Minimization Using a Structured Mesh




                                                 Reused
                                                 TAO Solver
                                                 Driver/Physics




                                                                  143
CCA
Common Component Architecture




                                Computational Chemistry:
                                 Molecular Optimization

       • Investigators: Yuri Alexeev (PNNL), Steve Benson (ANL),
         Curtis Janssen (SNL), Joe Kenny (SNL), Manoj Krishnan
         (PNNL), Lois McInnes (ANL), Jarek Nieplocha (PNNL),
         Jason Sarich (ANL), Theresa Windus (PNNL)

       • Goals: Demonstrate interoperability among software
         packages, develop experience with large existing code
         bases, seed interest in chemistry domain

      • Problem Domain: Optimization of
        molecular structures using quantum
        chemical methods



                                                                   144
CCA
Common Component Architecture




                     Molecular Optimization Overview
    • Decouple geometry optimization from electronic structure
    • Demonstrate interoperability of electronic structure components
    • Build towards more challenging optimization problems, e.g.,
      protein/ligand binding studies




         Components in gray can be swapped in to create new applications
                            with different capabilities.
                                                                           145
    CCA
    Common Component Architecture




    Wiring Diagram for Molecular Optimization




•    Electronic structures components:                  •   Optimization components: TAO (ANL)
                                                            http://www.mcs.anl.gov/tao
       •      MPQC (SNL)
              http://aros.ca.sandia.gov/~cljanss/mpqc   •   Linear algebra components:
       •      NWChem (PNNL)                                  •   Global Arrays (PNNL)
                                                                 http://www.emsl.pnl.gov:2080/docs/global/ga.html
              http://www.emsl.pnl.gov/pub/docs/nwchem
                                                             •   PETSc (ANL)
                                                                 http://www.mcs.anl.gov/petsc
                                                                                                               146
CCA
Common Component Architecture




                                Actual Improvements

             Molecule           NWChem    NWChem/TAO       MPQC      MPQC/TAO


               Glycine            33           19            26         19


             Isoprene             56           45            75         43


        Phosposerine              79           67            85         62


               Aspirin            43           51            54         48


           Cholesterol            33           30            27         30


                                 Function and gradient evaluations
                                                                                147
CCA
Common Component Architecture




             Componentized Climate Simulations
      • NASA’s ESMF project has a component-based design for Earth
        system simulations
                 – ESMF components can be assembled and run in CCA compliant
                   frameworks such as Ccaffeine.
      • Zhou et al (NASA Goddard) has integrated a simple coupled
        Atmosphere-Ocean model into Ccaffeine and is working on the
        Cane-Zebiak model, well-known for predicting El Nino events.
      • Different PDEs for ocean and atmosphere, different grids and
        time-stepped at different rates.
                 – Synchronization at ocean-atmosphere interface; essentially,
                   interpolations between meshes
                 – Ocean & atmosphere advanced in sequence
      • Intuitively : Ocean, Atmosphere and 2 coupler components
                 – 2 couplers : atm-ocean coupler and ocean-atm coupler.
                 – Also a Driver/orchestrator component.


                                                                                 148
 CCA
 Common Component Architecture




                   Coupled Atmosphere-Ocean Model Assembly




• Climate Component :
       • Schedule
       component coupling
• Data flow is via pointer
NOT data copy.
       • All components in
       C++; run in Ccaffeine
• Multiple ocean models
with the same interface
       • Can be selected by
                                 Port link
       a user at runtime
                                 Data flow

                                                             149
CCA
 Common Component Architecture




                                 Simulation Results


                                            …changes a field variable (e.g.,wind)
                                            in the atmosphere !




A non-uniform ocean field variable
   (e.g., current)




                                                                                    150
CCA
Common Component Architecture




          Concurrency At Multiple Granularities

   • Certain simulations need multi-granular concurrency
      – Multiple Component Multiple Data, multi-model runs

   • Usage Scenarios:
      – Model coupling (e.g. Atmosphere/Ocean)
      – General multi-physics applications
      – Software licensing issues                      Driver
                                             Atmosphere Ocean Land
   • Approaches
                                                       Coupler
      – Run single parallel framework
         • Driver component that partitions processes and builds rest
           of application as appropriate (through BuilderService)
      – Run multiple parallel frameworks
         • Link through specialized communications components
         • Link as components (through AbstractFramework service;
           highly experimental at present)
                                                                        151
CCA
Common Component Architecture




                                          Overview

      • Examples (scientific) of increasing complexity
                 –      Laplace equation
                 –      Time-dependent heat equation
                 –      Nonlinear reaction-diffusion system
                 –      Quantum chemistry
                 –      Climate simulation
      • Tools
                 – MxN parallel data redistribution
                 – Performance measurement, modeling and scalability studies
      • Community efforts & interface development
                 – TSTT Mesh Interface effort
                 – CCTTSS’s Data Object Interface effort


                                                                               152
CCA
Common Component Architecture




                “MxN” Parallel Data Redistribution:
                         The Problem…
      •       Create complex scientific
              simulations by coupling together
              multiple parallel component
              models
               – Share data on “M”
                  processors with data on “N”
                            • M != N ~ Distinct Resources
                              (Pronounced “M by N”)
                 – Model coupling, e.g.,
                   climate, solver / optimizer
                 – Collecting data for
                   visualization
                            • Mx1; increasingly MxN (parallel
                              rendering clusters)
      •       Define common interface
               – Fundamental operations for
                  any parallel data coupler
                            • Full range of synchronization
                              and communication options

                                                                153
CCA
Common Component Architecture




                                Hierarchical MxN Approach
     • Basic MxN Parallel Data Exchange
                – Component implementation
                – Initial prototypes based on CUMULVS & PAWS
                           • Interface generalizes features of both
     • Higher-Level Coupling Functions
                – Time & grid (spatial) interpolation, flux conservation
                – Units conversions…
     • “Automatic” MxN Service via Framework
                – Implicit in method invocations, “parallel RMI”

                                                http://www.csm.ornl.gov/cca/mxn/

                                                                                   154
    CCA
    Common Component Architecture




               CCA Delivers
               Performance
Local
•       No CCA overhead within components
•       Small overhead between components
•       Small overhead for language interoperability   Maximum 0.2% overhead for CCA vs
                                                       native C++ code for parallel molecular
•       Be aware of costs & design with them in mind   dynamics up to 170 CPUs
           – Small costs, easily amortized

Parallel
•       No CCA overhead on parallel computing
•       Use your favorite parallel programming model
•       Supports SPMD and MPMD approaches
Distributed (remote)
•       No CCA overhead – performance depends
        on networks, protocols
•       CCA frameworks support OGSA/Grid
                                                       Aggregate time for linear solver
        Services/Web Services and other                component in unconstrained minimization
        approaches                                     problem w/ PETSc
                                                                                                 155
CCA
Common Component Architecture




         Overhead from Component Invocation

     • Invoke a component with
       different arguments                   Function arg
                                                            f77     Component
                                             type
                          • Array
                          • Complex
                          • Double Complex
     • Compare with f77 method               Array          80 ns   224ns
       invocation
     • Environment
               – 500 MHz Pentium III
               – Linux 2.4.18                Complex        75ns    209ns
               – GCC 2.95.4-15
     • Components took 3X longer
     • Ensure granularity is
       appropriate!                          Double
                                             complex        86ns    241ns
     • Paper by Bernholdt, Elwasif,
       Kohl and Epperly
                                                                                156
CCA
Common Component Architecture




           Scalability : Component versus Non-component. I


 •       Quantum chemistry
         simulation
 •       Sandia’s MPQC code
            – Both componentized
              and non-
              componentized
              versions
 •       Componentized version
         used TAO’s
         optimization algorithms
 •       Problem :Structure of
         isoprene HF/6-
         311G(2df,2pd)

                                      Parallel Scaling of MPQC w/ native and TAO optimizers
                                                                                              157
CCA
Common Component Architecture




           Scalability : Component versus Non-component. II


•      Hydrodynamics; uses CFRFS set
       of components
•      Uses GrACEComponent
•      Shock-hydro code with no
       refinement
•      200 x 200 & 350 x 350 meshes
•      Cplant cluster
        – 400 MHz EV5 Alphas
        – 1 Gb/s Myrinet
•      Negligible component overhead
•      Worst perf : 73% scaling
       efficiency for 200x200 mesh on
       48 procs

    Reference: S. Lefantzi, J. Ray, and H. Najm, Using the Common Component Architecture to Design High Performance
    Scientific Simulation Codes, Proc of Int. Parallel and Distributed Processing Symposium, Nice, France, 2003.

                                                                                                                      158
CCA
Common Component Architecture




                        Performance Measurement In A
                              Component World
      • CCA provides a novel means of profiling & modeling
        component performance
      • Need to collect incoming inputs and match them up
        with the corresponding performance, but how ?
                 – Need to “instrument” the code
                            • But has to be non-intrusive, since we may not “own” component
                              code
      • What kind of performance infrastructure can achieve
        this?
                 – Previous research suggests proxies
                            • Proxies serve to intercept and forward method calls


                                                                                              159
CCA
Common Component Architecture




                                “Integrated” Performance
                                 Measurement Capability
                                                                   Before:
      Measurement infrastructure:                      Component                Component2
                                                       1
      • Proxy
                 – Notifies MasterMind of all method
                   invocations of a given
                   component, along with
                   performance dependent inputs                     After:
                 – Generated automatically using
                   PDT                                 Component   Proxy for      Component2
                                                                   Componen
      •         MasterMind                             1
                                                                   t2
                 – Collects and stores all
                   measurement data
      • TAU
                                                                   MasterMind        TAU
                 – Makes all performance
                   measurements


                                                                                             160
CCA
Common Component Architecture




          Component Application With Proxies




                                               161
CCA
Common Component Architecture




                                          Overview

      • Examples (scientific) of increasing complexity
                 –      Laplace equation
                 –      Time-dependent heat equation
                 –      Nonlinear reaction-diffusion system
                 –      Quantum chemistry
                 –      Climate simulation
      • Tools
                 – MxN parallel data redistribution
                 – Performance measurement, modeling and scalability studies
      • Community efforts & interface development
                 – TSTT Mesh Interface effort
                 – CCTTSS’s Data Object Interface effort


                                                                               162
CCA
Common Component Architecture




                                      The Next Level
• Common Interface Specification
          –      Provides plug-and-play interchangeability
          –      Requires domain specific experts
          –      Typically a difficult, time-consuming task
          –      A success story: MPI
• A case study… the TSTT/CCA mesh interface                          Geometry
                                                                     Information
          – TSTT = Terascale Simulation Tools and                    (Level A)


            Technologies (www.tstt-scidac.org)
          – A DOE SciDAC ISIC focusing on meshes
            and discretization                    Full
          – Goal is to enable                     Geometry
                                                  Meshes
                     • hybrid solution strategies        (Level B)

                     • high order discretization                     Mesh
                                                                     Compone
                     • Adaptive techniques                           nts
                                                                     (Level C)


                                                                                 163
CCA
Common Component Architecture




           Proliferations of interfaces – the N2 problem
      Current Situation
      • Public interfaces for numerical libraries are unique
      • Many-to-Many couplings require Many2 interfaces
         • Often a heroic effort to understand the inner workings of both
           codes
         • Not a scalable solution


                            Dist. Array
                                                   ISIS++
                                Overture
                                                   PETSc
                                PAOMD
                                                   Trilinos
                            SUMAA3d
                                                                            164
 CCA
 Common Component Architecture




                      Common Interface Specification
Reduces the Many-to-Many problem to a Many-to-One problem
  – Allows interchangeability and experimentation
  – Challenges
                 • Interface agreement
                 • Functionality limitations
                 • Maintaining performance


                    Dist. Array
                                        T          ISIS++
                                               E
                     Overture           S
                                               S   PETSc
                                        T
                     PAOMD                     I
                                        T          Trilinos
                    SUMAA3d
                                                              165
CCA
Common Component Architecture




                                TSTT Philosophy

      • Create a small set of interfaces that existing
        packages can support
                 – AOMD, CUBIT, Overture, GrACE, …
                 – Enable both interchangeability and interoperability
      • Balance performance and flexibility
      • Work with a large tool provider and application
        community to ensure applicability
                 – Tool providers: TSTT and CCA SciDAC centers
                 – Application community: SciDAC and other DOE applications




                                                                              166
CCA
Common Component Architecture




                                   CCTTSS Research Thrust Areas
                                     and Main Working Groups

                        • Scientific Components
                                Lois Curfman McInnes, ANL (curfman@mcs.anl.gov)

                        • “MxN” Parallel Data Redistribution
                                Jim Kohl, ORNL (kohlja@ornl.gov)

                        • Frameworks
                                – Language Interoperability / Babel / SIDL
                                Gary Kumfert, LLNL (kumfert@llnl.gov)

                        • User Outreach
                                David Bernholdt, ORNL (bernholdtde@ornl.gov)


                                                                                  167
CCA
Common Component Architecture




                                           Summary
 • Complex applications that use components are possible
            –     Combustion
            –     Chemistry applications
            –     Optimization problems
            –     Climate simulations
 • Component reuse is significant
            –     Adaptive Meshes
            –     Linear Solvers (PETSc, Trilinos)
            –     Distributed Arrays and MxN Redistribution
            –     Time Integrators
            –     Visualization
 • Examples shown here leverage and extend parallel software and
   interfaces developed at different institutions
            – Including CUMULVS, ESI, GrACE, LSODE, MPICH, PAWS, PETSc, PVM, TAO,
              Trilinos, TSTT.
 •       Performance is not significantly affected by component use
 •       Definition of domain-specific common interfaces is key

                                                                                    168
CCA
Common Component Architecture




                    A Few Notes in Closing




             CCA Forum Tutorial Working Group
              http://www.cca-forum.org/tutorials/
                  tutorial-wg@cca-forum.org
This work is licensed under a Creative Commons Attribution 2.5 License   169
 CCA
 Common Component Architecture




                                 Resources: Its All Online
• Information about all CCA tutorials, past, present, and
  future:
              http://www.cca-forum.org/tutorials/

• Specifically…
       – Latest versions of hands-on materials and code:
                     http://www.cca-forum.org/tutorials/#sources
                  • Hands-On designed for self-study as well as use in an organized tutorial
                  • Should work on most Linux distributions, less tested on other unixen
                  • Still evolving, so please contact us if you have questions or problems
       – Archives of all tutorial presentations:
                     http://www.cca-forum.org/tutorials/archives/

• Questions…
                                    tutorial-wg@cca-forum.org
                                                                                               170
CCA
Common Component Architecture




                                   Getting Help
      • We want to help insure you have a good experience
        with CCA, so let us know if you’re having problems!
      • Tutorial or “start-up” questions
                 – tutorial-wg@cca-forum.org
      • Problems with specific tools
                 – check documentation for updated contact info
                 – cca-tools bundle (includes Chasm, Babel, Ccaffeine): Rob
                   Armstrong, rob@sandia.gov
                 – Chasm: Craig Rasmussen, crasmussen@lanl.gov
                 – Babel: babel-users@llnl.gov
                 – Ccaffeine: ccafe-users@cca-forum.org
      • General questions, or not sure who to ask?
                 – cca-forum@cca-forum.org
                                                                              171
CCA
Common Component Architecture




                                CCA is Interactive
      • Collectively, CCA developers and users span a broad
        range of scientific interests.
                 – There’s a good chance we can put you in touch with others
                   with relevant experience with CCA
      • CCA Forum Quarterly Meetings
                 – Meet many CCA developers and users
                 – http://www.cca-forum.org/meetings/
      • “Coding Camps”
                 – Bring together CCA users & developers for a concentrated
                   session of coding
                 – Held as needed, typically 3-5 days
                 – May focus on a particular theme, but generally open to all
                   interested participants
                 – If you’re interested in having one, speak up (to individuals or
                   cca-forum@cca-forum.org)
      • Visits, Internships, etc.
                                                                                     172
CCA
Common Component Architecture




                                 Acknowledgements:
                                Tutorial Working Group
    • People: Benjamin A. Allan, Rob Armstrong, David E.
      Bernholdt, Randy Bramley, Tamara L. Dahlgren, Lori
      Freitag Diachin, Wael Elwasif, Tom Epperly,
      Madhusudhan Govindaraju, Ragib Hasan, Dan Katz,
      Jim Kohl, Gary Kumfert, Lois Curfman McInnes, Alan
      Morris, Boyana Norris, Craig Rasmussen, Jaideep
      Ray, Sameer Shende, Torsten Wilde, Shujia Zhou
    • Institutions: ANL, Binghamton U, Indiana U, JPL,
      LANL, LLNL, NASA/Goddard, ORNL, SNL, U Illinois, U
      Oregon
    • Computer facilities provided by the Computer
      Science Department and University Information
      Technology Services of Indiana University, supported
      in part by NSF grants CDA-9601632 and EIA-0202048.
                                                             173
CCA
Common Component Architecture




                            Acknowledgements: The CCA

  • ANL –Steve Benson, Jay Larson, Ray Loy, Lois Curfman McInnes,
    Boyana Norris, Everest Ong, Jason Sarich…
  • Binghamton University - Madhu Govindaraju, Michael Lewis, …
  • Indiana University - Randall Bramley, Dennis Gannon, …
  • JPL – Dan Katz, …
  • LANL - Craig Rasmussen, Matt Sotille, …
  • LLNL – Tammy Dahlgren, Lori Freitag Diachin, Tom Epperly, Scott
    Kohn, Gary Kumfert, …
  • NASA/Goddard – Shujia Zhou
  • ORNL - David Bernholdt, Wael Elwasif, Jim Kohl, Torsten Wilde, …
  • PNNL - Jarek Nieplocha, Theresa Windus, …
  • SNL - Rob Armstrong, Ben Allan, Lori Freitag Diachin, Curt
    Janssen, Jaideep Ray, …
  • Tech-X Corp. – Johan Carlsson, Svetlana Shasharina, Ovsei
    Volberg, Nanbor Wang
  • University of Oregon – Allen Malony, Sameer Shende, …
  • University of Utah - Steve Parker, …
  and many more… without whom we wouldn’t have much to talk about!
                                                                       174
CCA
Common Component Architecture




                                         Thank You!




                                Thanks for attending this tutorial


                          We welcome feedback and questions




                                                                     175

				
DOCUMENT INFO
Categories:
Tags:
Stats:
views:4
posted:4/1/2012
language:
pages:152