Requirements: The U.C. Berkeley Titanium compiler, known as titaniumc, compiles Titanium programs into C. A C compiler is required to compile the generated code, and the compiler itself is written in C++. We recommend GNU gcc and g++, but any ANSI C/C++ compiler can be used. For parallel platforms, either pthreads or a messaging layer is required.
The Titanium compiler is available on the Berkeley NOW and Clumps machines, and can easily be accessed from Solaris and Linux uniprocessors by mounting /project/cs/titanium/srs on your machine. Some additional hints on using Titanium in the Berkeley environment are included in the tcbuild introduction. To report bugs in the implementation, access the Titanium bug database (restricted to UC Berkeley on-campus access).
We manage installations of the Titanium compiler at the following locations (some of these may vary in the exact compiler version which is available). This is for informational purposes only - some of the systems listed are managed by institutions with no official affiliation with the Titanium project or UC Berkeley.
|System Name||Architecture/Comments||Compiler Location|
|Any system at UC Berkeley EECS mounting /project/cs/titanium/srs||Linux x86, includes support for Millennium||/project/cs/titanium/srs/i686-pc-linux-gnu/bin/tcbuild (stable)
/project/cs/titanium/srs/i686-pc-linux-gnu/bin/tcbuild-nightly (nightly snapshot)
|Solaris 2.6 (deprecated)||/project/cs/titanium/srs/sparc-sun-solaris2.6/bin/tcbuild|
|Millennium CITRIS||Linux Itanium-2/Myrinet||/project/cs/titanium/b/temp/citris/dist/bin/tcbuild|
|flyer.cse.mtu.edu||MTU Quadrics/Elan3 AlphaServer||/usr/local/berkeley/titanium/dist/bin/tcbuild (devel-debug)|
|jacquard.nersc.gov||Opteron/Infiniband||"module load titanium", or:
/usr/common/ftg/titanium/dist/bin/tcbuild-gcc-trace (debug, IntelC-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-pathcc-trace (debug, pathcc-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-gcc (debug, gcc-based)
|seaborg.nersc.gov||IBM SP Power3/Colony||
"module load titanium", or:|
/usr/common/ftg/titanium/dist-dev/bin/tcbuild-trace (32-bit, debug)
/usr/common/ftg/titanium/dist-dev/bin/tcbuild64-trace (64-bit, debug)
|IBM SP Power4/Federation||
/usr/local/apps/titanium/dist-dev/bin/tcbuild-trace (32-bit, debug)
/usr/local/apps/titanium/dist-dev/bin/tcbuild64-trace (64-bit, debug)
|Virginia Tech SystemX||PowerPC-G5/Infiniband||
/nfs/storage1/users/bonachea/.tc-dist/dist/bin/tcbuild-trace-xlc (debug, xlc-based)
/nfs/storage1/users/bonachea/.tc-dist/dist/bin/tcbuild-trace-gcc (debug, gcc-based)
|thunder.llnl.gov||Linux Itanium2 Quadrics/Elan4||/g/g13/bonachea/.tc-dist/dist/bin/tcbuild|
|n2001.lbl.gov||n2001 Linux Myrinet/InfiniBand/Elan cluster||"module load titanium", or:
/usr/local/pkg/titanium/dist/bin/tcbuild-icc-trace (debug, IntelC-based)
/usr/local/pkg/titanium/dist/bin/tcbuild-trace (debug, gcc-based)
The Titanium debugger, sdb, is also available for many platforms. The source code is available, as is a User's Manual in html or gzipped postscript and an example Titanium program. See Carleton Miyamoto's sdb page for up-to-date information on sdb.
Because Titanium is compiled to C, users do not have full access to the AWT and certain other Java libraries directly from Titanium. However, a rudimentary interace to a separate Java process can be built using native methods. An example of Titanium code that communicates with a separate JVM process is available; it demonstrates graphical output for a naive particle simulation. Because of limitations on the underlying message layer, the this example current runs only on shared memory machines and uniprocessors.
The released version of Titanium runs on most uniprocessors and SMPs
running either Solaris, Linux, IRIX, AIX, or Microsoft Windows. We also have distributed backends
which support clusters of uniprocessors and clusters of SMPs (CLUMPS)
with varying network interconnects,
as well as a number of backends for various supercomputer architectures
(e.g. Cray T3E, IBM SP2, etc.)
Both Solaris threads and Posix threads implementations exist, so ports to other operating systems that support Posix threads or something similar should be straightforward. The runtime system currently uses the Boehm-Weisser garbage collector on operating systems supported by that software (most major OS's) - other more exotic OS's not supported by the Boehm-Weisser collector (most notably Cray Unicos) run without garbage collection.
The output of the Titanium compiler is C code, although the tcbuild script that is normally used to invoke the Titanium compiler automatically calls the C compiler as well. This backend compiler is normally the Gnu C compiler (gcc), although others have been used. (The intention is to make the C output Ansi compliant so that any reasonable C compiler could be used as the backend.)
Distributed backends exist for a variety of cluster network layers, such as VIA, Solaris AM-Myrinet (Berkeley NOW project), LAPI (IBM SP2 and SPPower3 machines), standard UDP (the portable alternative) and MPI 1.1 (high-performance portable option). Efforts are underway to support other runtime layers. Please let the Titanium developers know if you are interested in porting Titanium to a new platform.