Illinois Concert System V4.0 is now available!

**************************** Concert V4.0 ****************************


Illinois Concert System V4.0 is now available!


The Illinois Concert system is a parallel programming system for
fine-grained object-oriented programming on parallel systems. Our
goal is to enable portable and efficient programming using concurrent
object-oriented programming (COOP) through compiler analysis and
tranformation [7,8] and runtime [4] techniques. These techniques are
particularly helpful for problems with irregular parallelism or
complex data structures.


NEW in this release:


                o Support for ICC++ (compiler and runtime only)
o Object optimizations
o Foreign function interface (ICC++ only)


COMING SOON:


                o SGI Power Challenge Array runtime
                o Additional development and simulation platforms
                    (some possibilities: HP/Exemplar/Sun Solaris)


The Concert System includes:


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


The Concert system supports the languages Concurrent Aggregates [1,2]
and ICC++ [9,10], a dialect of C++. Both are fine-grained
object-oriented language based on the actor model. These languages
also support aggregates (collections), multi-access abstractions, and
allow both data and task parallelism to be exploited seamlessly.


Applications/Kernels for which we have achieved good speedups on
distributed memory machines include: Hierarchical radiosity,
Barnes-Hut, Protein Molecular dynamics, Grobner Basis, and Phylogeny.
Codes under development include: volume rendering, fast multipole, and
adaptive mesh refinement. Many of these applications were previously
thought to require cache coherent shared memory machine to achieve
high performance.


*** 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, Bishwaroop Ganguly, Vijay Karamcheti, John
Plevyak, 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. This release consists of an optimizing compiler
and a fast runtime system for Concurrent Aggregates and ICC++, a C++
dialect. they are both fine-grained object oriented languages with
support for object collections (for more details about the language,
see [1,2]). The optimizing compiler is capable of obtaining C-like
sequential performance when data is available locally. This is
accomplished through interprocedural flow analysis [8], inlining and
high level transformation of locality tests and object locks [7]. The
compiler also includes optimizations such as global constant
propogation, strength reduction, common subexpression elimination,
constant folding, etc. The high-performance runtime system supports
program execution on the Thinking Machines CM5 and Cray T3D using FM
(Fast Messages) [6].


Currently, support for program development is available on SPARC
workstations running SunOS with a uniprocessor simulator of the CM5
execution (based on a light-weight threads package). Support for
Concurrent Aggregates also includes an emulator 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.


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.


[6] Vijay Karamcheti and Andrew A. Chien, FM - Fast Messaging on the Cray T3D
        Available from {\tt http://www-csag.cs.uiuc.edu/papers/t3d-fm-ma ual.ps


[7] John Plevyak and Xingbin Zhang and Andrew A. Chien,
        Obtaining Sequential Efficiency in Concurrent Object-Oriented Programs,
        Proceedings of the ACM Symposium on the Principles of Programming
        Languages, January 1995


[8] John Plevyak and Andrew A. Chien, Precise Concrete Type Inference
        of Object-Oriented Programs, Proceedings of OOPSLA, 1994


[9] Andrew Chien and Uday Reddy, ICC++ Language Definition. Available
        from http://www-csag.cs.uiuc.edu/concert.


[10] A. A. Chien, U. S. Reddy, J. Plevyak and J. Dolby, ICC++ -- A C++
          Dialect for High-Performance Parallel Computation. Proceedings of
          ISOTAS, 1996


**************************** Concert V4.0 ****************************


--

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