ANNOUNCEMENT: Illinois Concert V3.0 Release

**************************** Concert V3.0 ****************************


Illinois Concert System V3.0 is now available!


The Illinois Concert system is a parallel programming system for
fine-grained object-oriented programming on massively 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 targetted to problems with irregular
parallelism.


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 Concurrent Aggregates language [1,2],
and the next release will support ICC++, a dialect of C++ [9]. 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.


*** 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


NEW in this release:


                o C-like sequential performance! [7]
                o T3D runtime using FM (Fast Messages) [6]
                o Stack-based execution
                o User controlled data distributions including
                    a libraries for block-cyclic distributions.


COMING SOON:


                o ICC++ front end (a dialect of C++) [9]
                o Convex Exemplar runtime
                o Additional development and simulation platforms
                    (some possibilities: HP/SGI/Sun Solaris)


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, Hao-Hua Chu, Julian Dolby, Mark Gardner, 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, a fine-grained
object oriented language with support for object collections (for more
details about the language, see [1,2]). The next release will support
ICC++, a dialect of C++ which adds fine-grained concurrency and
object-level concurrency control. 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, 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.


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] The Concurrent Systems Architecture Group, The ICC++ Language Report,
        Version 1.0, University of Illinois, Department of Computer Science
        Tech Report.


**************************** Concert V3.0 ****************************


--
John Plevyak (plevyak@uiuc.edu) 2233 Digital Computer Lab, (217) 244-7116
                          Concurrent Systems Architecture Group
                          University of Illinois at Urbana-Champaign
                          1304 West Springfield
                          Urbana, IL 61801
<A HREF="http://www-csag.cs.uiuc.edu/individual/jplevyak">My Home Page</A>
--

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