Illinois Concert System V2.0.1 now Available!

************************ Concert V2.0.1 ************************


Illinois Concert System V2.0.1 is now available!


The Illinois Concert system is a parallel programming system that supports
fine-grained object-oriented programming on massively parallel systems.
In particular, our research goals are to support portable, efficient
programming using concurrent object-oriented techniques and novel compiler
and runtime techniques. These techniques are of particular interest in
problems with irregular parallelism.


The Concert System includes:


                o Program Emulator for interactive program development
                o Compiler and Runtime (for Suns and the CM5)
                o Performance tools
                o Symbolic Debugger (source level)


The Concert system uses the Concurrent Aggregates language [1,2], a
fine-grained object-oriented language based on the actor model. The
language also supports aggregates, multi-access abstractions. This allows
both data and task parallelism to be exploited seamlessly. To date the
Concert system has been used to build a number of application kernels
(over 30,000 lines of Concurrent Aggregates programs), including:


o Particle-in-Cell
o Adaptive Mesh Refinement code
o The SIMPLE Code
o Box of Rocks (irregular N-body)
o Molecular Dynamics (subset of GROMOS)
o Digital Logic Simulator
o Truth Maintenance System
o Printed Circuit Board Router


The Concert system is available from: http://www-csag.cs.uiuc.edu


If you are unable to access the http server, please send email to
achien@cs.uiuc.edu


The Concert System was built in the Concurrent Systems Architecture Group
in the Department of Computer Science at the University of Illinois at
Urbana-Champaign. Project team members include: Andrew A. Chien, Julian
Dolby, Vijay Karamcheti, John Plevyak, Mahesh Subramaniam, and Xingbin
Zhang.


DISCLAIMER: The Concert system is experimental software while we
believe it is robust and usable, appropriate expectations about
support apply.


BACKGROUND:


The Concert System: Compiler and Runtime Support for Portable, Efficient
Fine-grained Concurrent Object-oriented Programming


Concurrent object-oriented languages, particularly fine-grained
approaches, manage the complexity of large scale concurrent programming by
providing modularity through encapsulation, while exposing large degrees
of concurrency. Fine-grained approaches allow the user to express a
program using its natural grain size and exposing maximal concurrency,
leaving the task of efficient execution to the compiler and runtime.
Grain size tuning is used to match the execution grain size to that
efficiently supported by the underlying machine.


The ultimate goal of the Concert project is to support efficient execution
of a variety of concurrent object-oriented languages on a number of
machines. The current release consists of an optimizing compiler and a
fast runtime system for Concurrent Aggregates, a fine-grained object
oriented language with support for object collections (for more details
about the language, see [1,2]). Currently, the compiler inlines method
calls, based on information about the receiver type. The high-performance
runtime system supports program execution on the Thinking Machines CM5.
Subsequent releases will include the use of dynamic data structure
analysis for more aggressive optimizations, as well as runtime support for
additional parallel machines.


Currently, support for program development is available on SPARC
workstations, and includes an emulator, a uniprocessor simulator of the
CM5 execution (based on a light-weight threads package), and a symbolic
debugger. Performance monitoring information is also provided which
interfaces with the Pablo performance visualization package. The release
also includes basic libraries for linear algebra functions, as well as a
variety of data parallel operations on object collections. Several large
example programs are also part of the release and encompass both numeric
applications (Multigrid, particle-in-cell, an adaptive mesh refinement
code, efficient mandelbrot set generation), and symbolic applications
(Discrete-event logic simulation, the PCB routing,parallel search).


More papers and information on Concert can be obtained from
                http://www-csag.cs.uiuc.edu


Any other questions regarding the Concert system can be addressed to
                concert@red-herring.cs.uiuc.edu


REFERENCES
----------


[1] Andrew A. Chien, "Concurrent Aggregates: Supporting Modularity in
        Massively-Parallel Programs", MIT Press, Cambridge, MA, 1993.


[2] Andrew A. Chien, Vijay Karamcheti, John Plevyak and Xingbin Zhang,
        "Concurrent Aggregates Language Report 2.0", September 1993,


[3] Andrew Chien, Vijay Karamcheti, and John Plevyak. "The Concert System -
        Compiler and Runtime Support for Efficient Fine-Grained Concurrent
        Object-Oriented Programs". Technical Report UIUCDCS-R-93-1815,
        Department of Computer Science, University of Illinois, June 1993.


[4] Vijay Karamcheti and Andrew Chien. "Concert - Efficient Runtime Support
        for Concurrent Object-Oriented Programming Languages on Stock Hardware".
        In Proceedings of SUPERCOMPUTING'93, November 1993.


[5] John Plevyak, Vijay Karamcheti and Andrew Chien. "Analysis of Dynamic
        Structures for Efficient Parallel Execution". In Proceedings of
        the Sixth Workshop on Languages and Compilers for Parallelism,
        August 1993.
--
Professor Andrew A. Chien 1304 W. Springfield Avenue
Department of Computer Science Urbana, IL 61801
University of Illinois Email: achien@cs.uiuc.edu
Phone: (217)333-6844
FAX: (217)333-3501
--

Return to the comp.compilers page.
Search the comp.compilers archives again.