April 9th, 2001

Titaniumc version 1.586 is now available.  User-visible changes since
the last public release include:

--- Backend/Runtime changes ---

* Added backends that support cluster of SMP (CLUMP) configuration

* Added udp-cluster-uniprocess and udp-cluster-smp backends that provide a
portable way to run distributed Titanium applications using UDP-based
messaging

* Streamlined the titanium array copy method and fixed some bugs in it

* Various fixes to and upgrades to Regions to make them more robust

* Upgraded garbage collector to the most recent Boehm-Weiser release

* The distributed backends are probably more stable than they've ever been
before, and include a fully functional implementation of "synchronized".

* System.gc() is now implemented and runs the garbage collector on demand 

* Runtime.totalMemory() and Runtime.freeMemory() are now implemented and
will give you on-the-fly information about your application's memory
footprint

* Various new environment variables are now recognized by the runtime
system to control and monitor various application behaviors (e.g. setting
TI_AMSTATS prompts the udp-* backends to output summary information about
the communication behavior of a distributed application)

--- Frontend changes ---

* Upgrade of local qualification inference (LQI) and the addition of
sharing type qualifiers / inference engine. LQI and sharing inference are
now on by default for all platforms when -O is given. This may provide a
noticeable performance improvement for distributed platforms.

* Foreach loops now support break & continue

* implemented .noOverlap() method on Titanium arrays

--- Optimization changes ---

* The -O switch to tcbuild now automatically selects the most aggressive
cc optimization options available on the current platform (that have been
shown to be stable for generated code).

* Method inlining has been added as a standard optimization. The optimizer
tries to inline calls to any methods or constructors declared with an
"inline" keyword, and calls to a few heavily-used methods in the Java
library

* Several improvements to bounds checking elimination/optimization

--- Miscellaneous changes --- 

* Augmented tc's error messages so they can be parsed by Emacs (C-x `) 

* Added a platform-independent tcrun script which can be used to spawn
Titanium applications from a standard interface, regardless of the backend

* Added ident strings to Titanium executables (try running "ident <appname>") 

* Various upgrades to the Titanium compiler to allow compiling with less
memory overhead

* Lots of miscellaneous bug fixes (see bug database for details) 

--- Updated backend information --- 

The Titanium backends have been largely rewritten to accommodate some
architectural changes (notably, adding support for CLUMPS and UDP-based
networking). A few of the backends have changed names.  Here are
descriptions of the backends currently available:

* sequential - the backend formerly known "uniproc". A single titanium
process - useful for testing and debugging.

* smp - the backend formerly known as "pthread". This parallel backend
runs the Titanium processes as Posix threads within a single shared memory
space, with fast "narrow" pointers. We no longer use the environment
variable "TI_NODES" - you should specify the number of parallel threads by
setting the environment variable TI_PFORP = "N/N" (for N threads).

* now-cluster-uniprocess - the high-performance cluster backend on the
Berkeley NOW. Each Titanium process runs on a separate node of the NOW.

* udp-cluster-uniprocess - the portable UDP-based cluster backend that
should run on basically any set of machines that have sshd and a basic
TCP/IP stack (they can also take advantage of rexec and GLUnix on the NOW
and Millennium, respectively).

* udp-cluster-smp - Same as above, but for a cluster of SMP's (CLUMP).
Each node in the network runs one or more Titanium processes as Posix
threads. We will post more details on how to use the udp-* backends soon.

* mill-cluster-uniprocess, mill-cluster-smp - these backends were designed
to support the Via network on Millennium, which is no longer available.
They may be used in the future to support other Via-based clusters.

* cray-t3e - Runs on the Cray T3E using shmem. This platform has a few
limitations (notably, the lack of a garbage collector).

* sp2, sp2clump, tera-thread - deprecated backends. The IBM SP2 backend is
likely to be revived in a future release.

--- Miscellaneous notes --- 

* The current compiler implements a per-process semantics for the "static"
keyword. This means that static fields have one copy in each Titanium
process, and "static synchronized" methods perform no synchronization.

* A new version of the Titanium language reference is available which
documents new features and language changes. 
Get it here:
http://www.cs.berkeley.edu/Research/Projects/titanium/doc/lang-ref.ps