Titanium Software and Documentation


Installing the Titanium compiler and runtime system

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.

Using Titanium at Berkeley

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).

Known Installations of the Titanium compiler

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


Solaris 2.8 /project/cs/titanium/srs/sparc-sun-solaris2.8/bin/tcbuild
Millennium CITRIS Linux Itanium-2/Myrinet /project/cs/titanium/b/temp/citris/dist/bin/tcbuild
lemieux.psc.edu Quadrics/Elan3 AlphaServer /usr/local/packages/titanium/dist/bin/tcbuild
/usr/local/packages/titanium/dist/bin/tcbuild-trace (debug)
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 (IntelC-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-gcc-trace (debug, IntelC-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-pathcc (pathcc-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-pathcc-trace (debug, pathcc-based)
/usr/common/ftg/titanium/dist/bin/tcbuild-gcc (gcc-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 (32-bit)
/usr/common/ftg/titanium/dist-dev/bin/tcbuild-trace (32-bit, debug)
/usr/common/ftg/titanium/dist-dev/bin/tcbuild64 (64-bit)
/usr/common/ftg/titanium/dist-dev/bin/tcbuild64-trace (64-bit, debug)
Titanium Instructions
IBM SP Power4/Federation /usr/local/apps/titanium/dist-dev/bin/tcbuild (32-bit)
/usr/local/apps/titanium/dist-dev/bin/tcbuild-trace (32-bit, debug)
/usr/local/apps/titanium/dist-dev/bin/tcbuild64 (64-bit)
/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-xlc (xlc-based)
/nfs/storage1/users/bonachea/.tc-dist/dist/bin/tcbuild-trace-xlc (debug, xlc-based)
/nfs/storage1/users/bonachea/.tc-dist/dist/bin/tcbuild-gcc (gcc-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 (IntelC-based)
/usr/local/pkg/titanium/dist/bin/tcbuild-icc-trace (debug, IntelC-based)
/usr/local/pkg/titanium/dist/bin/tcbuild (gcc-based)
/usr/local/pkg/titanium/dist/bin/tcbuild-trace (debug, gcc-based)

The Titanium debugger

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.

Building GUIs in Titanium

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.

Porting Titanium

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.

Back to main page
Last updated Tuesday April 29, 2014
Comments to Titanium developers