Babel Logo

High-Performance Language Interoperability

  1. Home
  2. Documentation
  3. Getting Started
  4. F.A.Q.
  5. Download
  6. Resources
  7. Team
  8. Success Stories
Supported Languages

About Babel

Babel is a high-performance language interoperability tool. The project is mainly developed at the Center for Applied Scientific Computing (CASC) at Lawrence Livermore National Laboratory (LLNL). Babel started as an internal Lab Directed Research and Development (LDRD) project in 2000 and has been under constant development since then. It is now funded mainly under the U.S. Department of Energy (DOE) Office of Science's SciDAC program.

Babel currently fully supports C, C++, FORTRAN 77, Fortran 90/95, Fortran 2003/2008, Python, and Java. It won a prestigious R&D 100 award in 2006 for "The world's most rapid communication among many programming languages in a single application.".

Our tool is based on the Scientific Interface Description Language (SIDL). SIDL is tailored to the needs of the scientific community and features support for complex numbers, structs, and dynamic multidimensional arrays. Babel is a compiler that generates glue code from SIDL interface descriptions. SIDL provides a modern object oriented programming model, even on top of traditional procedural languages. This includes automatic reference counting and resource (de)allocation. Code written in one language can be called from any of the supported languages.

Babel focuses on high-performance language interoperability within a single address space. Full support for Remote Method Invocation (RMI) allows for the development of parallel distributed applications.

We also provide tools to automatically generate documentation from SIDL descriptions. An equivalent XML representation eases development of third-party tools.


Babel is released under the GNU Lesser General Public (LGPL) license, which is an OSI Certified open source license. It can be freely copied, modified, and distributed under the terms of this license.

Related Projects

Babel 2.0 also includes an experimental version of Braid, which is an ongoing effort to support PGAS languages such as Chapel, UPC, and X10. See the release notes for more information on the status of Braid.

R&D 100


All manuals are evolving documents. Please submit errors to the Babel team via e-mail or our bugtracking system.


Other Slides








20th Century

This page is a quick guide to get you started with Babel. See our Supercomputing '07 Tutorial [PDF, 6MB] for a more comprehensive resource. You can either copy and paste the code from this website or download a tar archive with all the necessary files.

Building Babel

If your distribution provides precompiled packages for Babel, you probably want to use those. Otherwise, make sure your system satisfies Babel's prerequisites. In an ideal world, the following command sequence should give you a working Babel installation. The configure script supports a large number of options; see configure --help for a quick reference. You can change the installation path using --prefix=<path>. Configure will automatically disable languages, if it cannot find the required tools.

$ tar -xzf babel-X.Y.Z.tar.gz
$ cd babel-X.Y.Z
$ ./configure && make && make install

It's always a good idea to make sure your installation passes Babel's regression tests. Executing make check should give you something like

$ make check
703. struct/runSIDL/[s.Simple.XML->XML] ....................   PASS
704. struct/runSIDL/[s.StructTest.XML->XML] ................   PASS
705. struct/runSIDL/[s.XML->XML] ...........................   PASS
Tue, 02 Mar 2010  at  17:16:35 
by user@hostname
Wallclock Time: 175.499 secs
            Total      Passed      Xfailed      Failed      Broken
Tests         705         695           10           0           0
Parts       25564       25493           71           0

"Hello World" in Babel

Next, we need a SIDL file that declares the public interface of our component. Copy and paste the following in a file called greetings.sidl. The example illustrates a small stateful hello world component.

package greetings version 1.0 {
  class Hello {
    void setName(in string name);
    void sayHello();

A C++ Implementation

Let's assume we want to implement Hello in C++. Babel can assist you in generating a Makefile and the rough program structure. Execute the following command to do so (make sure Babel is somewhere in your PATH).

$ mkdir libC++ && cd libC++
$ babel --makefile --server=C++ ../greetings.sidl

This will generate several files. The only files you should ever need to edit are GNUMakefile, greetings_Hello_Impl.hxx and greetings_Hello_Impl.cxx. The Makefile is mostly fine; just replace the line LIBNAME=impl with LIBNAME=greetings near the top of the file. This will produce static and dynamic libtool libraries named a libgreetings.

The remaining files contain the implementation of our class. The generated files contain structured comments, so-called splicer blocks, that specify user-defined sections. Babel will maintain these sections across multiple invocations. Edit these files as outlined below to provide implementations for setName and sayHello.


// DO-NOT-DELETE splicer.begin(greetings.Hello._implementation)
std::string _name;
// DO-NOT-DELETE splicer.end(greetings.Hello._implementation)


// DO-NOT-DELETE splicer.begin(greetings.Hello._includes)
// DO-NOT-DELETE splicer.end(greetings.Hello._includes)

// user defined constructor
void greetings::Hello_impl::_ctor() {
  // DO-NOT-DELETE splicer.begin(greetings.Hello._ctor)
  name = "Unknown";
  // DO-NOT-DELETE splicer.end(greetings.Hello._ctor)

 * Method:  setName[]
greetings::Hello_impl::setName_impl (
  /* in */const ::std::string& name ) 
  // DO-NOT-DELETE splicer.begin(greetings.Hello.setName)
  _name = name;
  // DO-NOT-DELETE splicer.end(greetings.Hello.setName)

 * Method:  sayHello[]
greetings::Hello_impl::sayHello_impl () 

  // DO-NOT-DELETE splicer.begin(greetings.Hello.sayHello)
  std::cout << "Hello World from " << _name << std::endl;
  // DO-NOT-DELETE splicer.end(greetings.Hello.sayHello)

That's it. Run make to get everything built.

A Fortran 90 Client

Suppose, you want to use the newly created Babel component in a Fortran 90 application. Again, we use babel to generate an initial Makefile and the necessary glue code.

$ babel --client=F90 --makefile ./greetings.sidl

Copy and paste the following little driver program in a file called driver.F90.

program driver
  use greetings_Hello
  implicit none
  type(greetings_Hello_t)     :: obj
  type(sidl_BaseInterface_t)  :: ex
  character(len=20)           :: name
  name='The Babel Team'
  call new(obj, ex)
  call setName(obj, name, ex)
  call sayHello(obj, ex)
end program driver

We also need to do some adjustments to the Makefile to get a client library built and link everything together. Make the following modifications to the pre-generated GNUMakefile file.

# please name the server library here


# extra librarys that the implementation needs to link against
EXTRALIBS=-L./libC++ -lgreetings


all : lib$(LIBNAME).la $(SCLFILE) driver


driver: lib$(LIBNAME).la driver.lo
	babel-libtool --mode=link --tag=FC $(FC) -static -o driver \
        $(FCFLAGS) $(EXTRAFLAGS) $^ $(LIBS) \

If everything works as expected, typing make on your command prompt should give you a statically linked executable that produces the following output.

Hello world from The Babel Team

  1. Technical Overview
  2. What exactly is Babel's implementation?

    Babel has two major parts: a compiler (more precisely a code generator), and a runtime library. The compiler is written in Java, and the runtime library is in ANSI C. Some language bindings also have ancillary runtime libraries which could be in C or other languages.

    What do you mean by "front-end" or "back-end" in the context of the Babel compiler?

    The front-ends are just parsers. We currently have two: a SIDL parser and an XML parser. There exists at least one case in our user community of a custom front-end as well. The back-ends are the (language specific) code writers. The IOR and XML outputs are also back-ends. Basically front ends assemble the syntax tree, back ends walk the tree and generate output.

    What's the difference between the Babel distribution and the Babel-Runtime distribution?

    Babel-Runtime is a proper subset of the entire Babel distribution. In fact, we spawn the Babel-Runtime distribution from the main tree by executing the commands cd babel-X.X.X/runtime/; make dist. The entire Babel distribution includes the code generator, regression tests, documentation, and examples.

    Who would prefer the Babel-Runtime distribution over the entire Babel distribution?

    The Babel-Runtime distribution is the minimal amount of stuff needed for a 3rd party to distribute their Babelized codes to a non Babel-savvy customer. Alternatively, someone who encounters Babelized code and doesn't want to bother with all of Babel, may find just the Babel-Runtime a suitable option.

    Who would prefer the entire Babel distribution over just the Babel-Runtime distribution?

    If you're writing SIDL files or want to generate language bindings, the entire Babel distribution is clearly what you'll want.

  3. Babel configure/build
  4. What tools does Babel use for its configuration/build?

    GNU make, Autoconf, Automake, Libtool , Python's distutils, custom Autoconf macros (in M4), shell scripts, and python scripts. And plenty of compilers from multiple vendors in a bunch of languages.

    Must I have all languages covered to configure/build Babel on my platform?

    Most languages can be disabled with the --disable-X flag to the configure script. This includes every language except C, which is mandatory (and C++ which almost always comes with C anyway). For more details, try configure --help.

    What tools do I need to configure/build Babel on my platform?

    GNU make, Bourne shell, libxml2, a C compiler and Sun's Java Development Kit. You'll also need Python if you do make check. Plus you'll need compilers for any other language bindings you want your installation to support. If you're using Fortran 90, you'll also need Chasm.

    What tools do I need to configure/build Babel-Runtime on my platform?

    GNU make, Bourne shell, libxml, and a C compiler. Java not strictly necessary. Plus you'll need compilers for any other language bindings you want your installation to support. If you're using Fortran 90, you'll also need Chasm.

    Why is Babel's configure/build so complex?

    We're doing something hard and the tools available are not very sophisticated.

    The nature of the problem Babel is attempting to solve - language interoperabilty - is complex, obscure, and platform specific. For make check to be meaningful, we probe the dark corners of language interoperability issues that most programmmers have learned to avoid (e.g. character strings in Fortran). Additionally, Java and Python have separate build systems (or partial build systems) built into the language itself... which complicates any external build that tries to manage it. Plus we compensate when some languages aren't available on some platforms.

    Supporting the build takes an obscenely large percentage of Babel's development effort. We've even published a technical report measuring how much it costs us, and investigated if our costs are commensurate with other projects at LLNL, the DOE, and even a few large academic projects.

    Does Babel require me to use its build system in my application?

    Absolutely not. Once Babel is installed, You should only need to have the babel script in your path to launch the code generator; have the runtime library headers in your include path for compilation to succeed; and have the runtime libraries in your library search path and add the right libraries on the command line at link time.

    If I start using Babel, I'll want to ship Babel in my code bundle. Then do I have to buy into Babel's build?

    No. In that case, you can pre-generate the language bindings and only ship the Babel-Runtime. You can redistribute the Babel-Runtime as a subdirectory of your own code, reusing all of our configure scripts and makefiles therein with minimal infection of your own build. Of course, your top-level configure script will have to reference ours, and your top-level makefile will have to propagate the all check clean install targets to our toplevel makefile. To see how this works in action, simply look at the main Babel distribution, the runtime subdirectory is exactly that separable Babel-Runtime distribution.

    Babel's build has found a lot of useful information that I want to reuse in my software. How do I do it?

    We would be very interested in exporting as much knowledge as possible from our build to our customers. The recommended mechanism is to use the babel-config script that gets installed with babel. Type babel-config --help for information on how to use this tool.

    Can I use a parallel make?

    Starting with Babel 2.0, you can.

    I typed make check an hour ago and its still going. What's wrong?

    Nothing. We do a lot of testing and it can take hours on slow machines.

    Why does Babel's build insist on a specific version of automake/autoconf/etc.?

    Past painful experiences led us to write special autoconf macros to detect and disable regeneration of build files when versions don't match. It only cares if you modified input files to automake or autoconf, and your version of these tools don't match ours. If you must hand modify any build file to get Babel working on your platform, then you've discovered a bug in the build. We strongly encourage you to submit a bug report to us.

  5. SIDL
  6. Do you have an EBNF spec for the SIDL Grammar?

    Yes, its an appendix in the Babel Users' Guide.

    The User Guide's treatment of SIDL is pretty fast and furious, got anything kinder or gentiler?

    At the time this question was asked, we agreed. Since then, We've restructured the Babel Users' Guide and hope it is more useful now.

  7. Babel Code Generator
  8. How do I run the code generator?

    If you downloaded the babel-runtime, then you won't find the code generator. The code generator comes only with the entire package. The entire code generator is compiled into a single JAR file, including the DTDs. Babel should install a babel script which conveniently sets the appropriate CLASSPATH and launches the JAR file.

    What's a "repository" for the code generator?

    A repository is a place to store pre-compiled SIDL files. Using the -R option in babel adds directories to the repository search path and functions similar to the way one uses -I to include header files in C/C++. It just so happens that this pre-compiled format is simply XML and can be generated babel using the --text=xml.

  9. Language Bindings
  10. Fortran 2003 finally got native C bindings, why still use Babel?

    By using Babel you get several advanced features, such as object-oriented programming and virtual method calls. You can also save time by letting Babel sort out the right type declarations for you multi-dimensional arrays. See README for a more complete list of features to decide whether Babel is for you. We also spent a lot of time to figure out the subset of Fortran 2003 that works on all platforms/compilers. It makes it also possible to mix Fortran and other languages like Python, Java, or Chapel. Babel can even generate the appropriate Makefile for your platform to link the two together.

    Why aren't there (Language X) bindings?

    Just because we don't advertise bindings for your favorite language, does not necessarily mean they don't exist. Babel's user community has grown to the point where there are "unofficial" language bindings in the works.

Latest Release

Users' Guide: [PS] [PDF] [HTML (single page)] [HTML (multiple pages)] [HTML.tar.gz]

Source Code:
Version Date Announce Readme Complete archive
2.0.0 (latest release) 2012-01-06 [TXT] [HTML] [TXT] [HTML] [GZIP] [BZIP2] [XZ]

A list of available patches to official Babel releases is available at the Babel patches node of the CCA Forum wiki. All software is released under the GNU Lesser General Public (LGPL) license.

Older Releases

Version Date Announce Complete Runtime Only
1.4.0 2008-11-11 [text] [TAR] [TAR]
1.2.0 2007-11-1 [text] [TAR] [TAR]
1.1.0 2007-3-26 [text] [TAR] [TAR]
1.0.8 2007-11-11 [text] [TAR] [TAR]
1.0.4 2007-03-1 [text] [TAR] [TAR]
1.0.2 2006-11-13 [text] [TAR] [TAR]
1.0.0 2006-7-21 [text] [TAR] [TAR]
0.99.2 (1.0 rc2) 2006-6-28 [text] [TAR] [TAR]
0.99.0 (1.0 rc1) 2006-4-24 [text] [TAR] [TAR]
0.11.2 2006-4-24 [text] [TAR] [TAR]
0.11.0 2005-12-23 [text] [TAR] [TAR]
0.10.12 2005-11-10 [text] [TAR] [TAR]
0.10.10 2005-8-19 [text] [TAR] [TAR]
0.10.8 2005-7-29 [text] [TAR] [TAR]
0.10.6 2005-6-17 [text] [TAR] [TAR]
0.10.4 2005-6-14 [text] [TAR] [TAR]
0.10.2 2005-3-28 [text] [TAR] [TAR]
0.10.0 2005-1-26 [text] [TAR] [TAR]
0.9.8 2004-10-26 [text] [TAR] [TAR]
0.9.6 2004-9-9 [text] [TAR] [TAR]
0.9.4 2004-8-19 [text] [TAR] [TAR]
0.9.2 2004-5-5 [text] [TAR] [TAR]
0.9.0 2004-2-1 [text] [TAR] [TAR]
0.8.8 2003-10-29 [text] [TAR] [TAR]
0.8.6 2003-07-23 [text] [TAR] [TAR]
0.8.4 2003-04-07 [text] [TAR] [TAR]
0.8.2 2003-03-28 [text] [TAR] [TAR]
0.8.0 2003-01-13 [text] [TAR] [TAR]
0.7.4 2002-08-21 [text] [TAR]  
0.7.2 2002-08-09 [text]    
0.7.0 2002-05-07 [text]    
0.6.3 2002-01-23 [text]    
0.6.2 2002-01-04 [text]    
0.6.1 2001-12-07 [text]    
0.6.0 2001-10-19 [text]    
0.5.1 2001-08-10 [text]    
0.5.0 2001-07-30 [text]    

Subversion (svn) Access

Our subversion repository is on; contact to request an account. Anonymous SVN access is currently not available due to security concerns. Our regression testing produces nightly snapshots. We're happy to provide those on request as well.


We use Roundup for bugtracking.

Bugs can also be submitted vie e-mail to Please make reasonable effort to insure its a novel bug in our database. Also include as much information about platform, configuration information (e.g. attach config.status file), and details about what happens and what you expected to happen.

Mailing Lists

Active Members


Summer Interns

Component Frameworks
CCA Form

Babel has been an active member of CCA from the beginning. The CCA specification is written in SIDL. Point of Contact: Rob Armstrong, Sandia National Lab


The Cooperative Parallelism Project (COOP) uses Babel RMI to let applications manage and distribute their work in flexible ways. COOP is a Multiple Program, Multiple Data (MPMD) model, so different parts of a parallel application can run different executables.

This project has contributed resources to accellerate Babel RMI development and develop nonblocking RMI. Point of Contact: David Jefferson, Lawrence Livermore National Lab


SCIRun2 uses Babel RMI for their distributed communication fabric. This group also heavily contributed to our current C++ binding. Point of Contact: Steve Parker, University Utah.


NWChem uses MPI processor groups, Global Arrays, and CCA (w/ Babel) to increase parallelism [KAWN05]. Point of Contact: Theresa Windus, Pacific Northwest National Lab


MPQC used CCA (/w Babel) to combine their quantum chemistry models and decouple the chemistry from the optimization. Then they employed the TAO optimization package, with PETSc and Global Arrays for linear solves. This led to a net reduction of required iterations for overall solution. [KBASJMKNJFW04] Point of Contact: Curtis Janssen: Sandia National Lab

Electron Effects in Heavy Ion Accelerators

The Computational Models for Electron Effects (CMEE) takes widely-used physics routines for modeling electron effects like gas ionization and secondary electron emission from metals and uses Babel to make them widely available. The resulting code is used in applications such as accelerator physics and plasma drives for satellites. In addition to having legacy codes in Fortran 77, they also report integrating new codes in Fortran 90, C, and Python.

Before incorporating Babel, this project had used combinations of Pyfort and SWIG or f2py and SWIG, which reportedly gave them 90% of what they wanted. However, a new customer (U.S. Air Force) added the requirement of Java interfaces. Rather than discard their substantial investment in Python-based string parsing code, they replaced all other point-to-point language tools with SIDL/Babel. This is the first known case of a Babel customer having a critical need for Java calling Python. They report taking a half-person day to demonstrate Java calling Python in their own code. Point of Contact: Peter Stoltz, Tech-X

Cell Biology

PNNL scientists are using TSTT tools to build the Virtual Microbial Cell Simulation (VMCS) to solve DOE heavy metal waste bioremediation problems. The VMCS is a general biological application that couples individual microbes, each modeled as its own genome-scale metabolic network, into a larger, self-organizing spatial network. The communication between the organisms is provided by multi-dimensional flow and transport models. TSTT mesh generation, mesh quality improvement, and discretization tools developed at different sites, and written in different languages, are used in concert through the SIDL-based TSTT interfaces. The VCMS has been used to study the flocculation behavior of communities of Shewanella microbes in oxygen rich environments. These simulations confirmed that there is an oxygen gradient from the edges of the floc into the center and provided new insight into the behavior of these microbes. Point of Contact: Harold Trease, Pacific Northwest National Lab

Material Science

Material scientists at Lawrence Livermore National Laboratory are using PSI (which uses Babel RMI) to couple multiscale material science applications. Point of Contact: Rich Becker, Lawrence Livermore National Laboratory


The Framework for Modernization and Componentization of Fusion Modules (FMCFM) is developing SIDL interfaces for legacy codes, particularly in the subareas of equilibrium and transport. Based on the Fortran-centric APIs from the European Integrated Tokamak Modeling Task Force (ITM-TF), this project is actively brokering a compromise position that involves SIDL as a secondary interface to the native Fortran 90 on one hand, and working technically with the Babel team to pursue the inclusion of structs (derived types) and optional arguments in a future release. Point of Contact: Johann Carlsson, Tech-X Corp

Subsurface Transport

Researchers at the Center for Advanced Study of the Environment (CASE), University of North Carolina, Chapel Hill, are applying CCA tools and technology in their problem solving environment (PSE) for subsurface flow and transport phenomena [CMWR04] Using LaTeX as a specification language for sets of differential equations, their PSE compiler translates a symbolic flow/transport problem into a component-based simulation. A variety of externally developed solver, integrator, and utility components have been identified and coordinated through a shared knowledge base to satisfy the needs of the simulation along with a simple Babel-wrapped component description of the model itself. The resulting component-based program is then submitted for parallel execution using the Ccaffeine CCA framework.

This team reports several benefits of the CCA approach. The component-based paradigm enables isolated unit testing of various solver/integrator components and provides a flexible platform for experimentation, where users can swap key portions of the component network without requiring full knowledge of the overall algorithms and internal organization. The high-level structure of the component-based representation encourages an intuitive understanding of the overall solver organization for users, versus traditional monolithic codes. The well-defined SIDL component interfaces also alleviate complexity in the design of the PSE compiler, abstracting the functional relationships among components and hiding specific implementation details that are not directly relevant at the PSE compiler level Point of Contact: Jans Prins, UNC

Training Simulators: Nuclear Power Plant

Researchers in University of Malaga, Spain used CCA (/w Babel) along with Real-Time CORBA (RT-CORBA) to create a nuclear power plant simulator to train operators [DGRRST05]. They chose to use RT-CORBA for the user interface and data logging subsystems where predictable response time is required. They use CCA for the simulator kernel where high performance and support for Fortran are needed.

This team started with a software system where data was shared among software subsystems using global variables. Using the CCA, they created a loosely coupled simulator kernel, where each component has a well defined interface indicating what data it requires and provides. During the configuration phase, the simulator kernel defines a communication schedule to satisfy the data dependencies among models. By componentizing the simulator, they lowered their development costs and produced a more flexible simulator.

Radio Astronomy

The eMiriad project at UIUC is developing a domain-specific component framework based on Babel to integrate several legacy libraries to make a radio astronomy application. This project will make a variety of tools available to scientists through common interfaces. In particular, they are integrating AIPS, MIRIAD, and AIPS++, which together represent approximately 480 FTE-years of effort [in review]. They chose Babel as their middleware because it is particularly well suited to their domain, radio astronomy imaging. The support for multi-dimensional arrays, Fortran, good interoperability with parallel computing, and the quality of peer-to-peer language bindings were leading factors in choosing Babel. Babel's language interoperability capabilities enable developers to work in their most effective programming language and provide a general scripting interface for the integrated system using Python. Point of Contact: Athol Kemball, UIUC


Scalable Linear Solvers. The hypre library of scalable solvers and preconditioners [FY02] was the first tester of SIDL/Babel. Written mostly in ANSI C, the hypre team's original intention was to throw away the four hand-written, non-portable, partial Fortran wrappers and use Babel as the binding for all languages other than the core C interface. After years of experience, performance studies showing the Babel overhead to be unmeasurable in large parallel jobs [KKPR01] and the benefits of polymorphism, the long-range plan has shifted to Babel being the only interface published to customers. Point of Contact: Jeff Painter, LLNL


Sparse Linear Algebra Sparskit is a basic toolkit (written in F77) for sparse linear algebra, with a significant portion (80%) now componentized for the CCA toolkit. The Sparskit components are also being integrated into the Terascale Optimal PDE Simulation (TOPS) center's solver component. New algebraic multilevel methods (in C), from the Itsol package - a library of iterative solvers for general sparse linear systems of equations, an extension of Sparskit - have now been merged as components into the CCA Toolkit. TAU's component-based performance analysis tools have been applied to the Sparskit linear algebra components. This study found that components of a fine granularity, like those in Sparskit, still execute with acceptable overheads rates of less than 3.4% in common application usage. Point of Contact: Masha Sosonkina, Ames Lab


TSTT SciDAC ISIC Point of Contact: Lori Diachin, Lawrence Livermore National Laboratory

Computer-Assisted Source Refactoring

Researchers at LLNL are developing a methodology to analyze and refactor large amounts of sourcecode. Applications include finding/breaking cyclic dependencies, removing blacklisted programming constructs, automatic wrapping in Babel, and possibly even semi-automated componentization [QYKEDSW05] The CCA itself is developing a simple but effective scripted approach to automated conversion from a language-specific CCA-Lite form to full Babel/SIDL based on Chasm [RSSM06] By comparison, the LLNL project is larger and more general. It employs the Rose Compiler Framework, the Eclipse IDE, and the VizzAnalyzer software visualization tool to manipulate the entire C, C++, or Fortran source in memory with as much detail as a commercial compiler. This project uses Babel to connect Rose (implemented in C++) to Eclipse and VizzAnalyzer, which are both implemented in Java. This project also motivated and developed the back-door initializer feature in Babel to wrap native objects in a temporary Babel veneer. Point of Contact: Thomas Epperly, LLNL

Performance Monitoring & Tuning
TAU is a robust and portable measurement interface and system for software performance evaluation. Using SIDL to describe TAU's measurement API, full support was enabled across applications written in Fortran, C++, C, Java, and Python. Without such support, the API for each new target language would be independently developed and maintained. Such a complex task becomes even more difficult given the ongoing sequence of extensions evolving in the TAU measurement API. Babel helps the TAU team focus on improving the quality of performance measurement and analysis tools, instead of dealing with low-level language compatibility. CCA/Babel has also enabled incorporation of dynamic selection of measurement options into the TAU performance evaluation tools. Users can choose from a variety of measurement options interactively at runtime, without re-compilation of applications. Proxy components are automatically generated to mirror a component's interface, allowing dynamic interposition of proxies between callers and callees, via hooks into the intermediate Babel communication layer. Such inter-component interaction measurements can correlate performance to application parameters, used for constructing more sophisticated performance models. Point of Contact: Sameer Shende, University of Oregon

Last Modified: 01/2012, LLNL-AM-426190 [CASC]    [LLNL]    [CCA] LLNL Privacy and Legal Notice