Project Abstract
Concurrency expression in most popular programming languages is still
quite low level and based on constructs such as semaphores and monitors,
that have not changed in twenty years. Libraries that are emerging (such
as the upcoming Java concurrency library JSR-166) show that programmers
are demanding higher-level concurrency semantics be available in
mainstream languages and major new research results have emerged more
recently in concurrency. Communicating Sequential Processes (CSP),
Calculus of Communicating Systems (CCS) and Pi have higher-level
synchronization behaviours defined implicitly through the composition of
events at the interfaces of concurrent processes. Join calculus, on the
other hand has explicit synchronization based on a localized conjunction
of events defined as reduction rules. The Join semantics appear to be
more appropriate to mainstream programmers; who want explicit
expressions of synchronization that do not breach the Object Oriented
idea of modularisation. Join readily expresses the dynamic creation and
destruction of processes and channels which is sympathetic to dynamic
languages like Java.
The research described here investigates if the Object Oriented
programming language Java can be modified so that all expressions of
concurrency and synchronization can use higher-level syntax and
semantics inspired by the Join calculus. Of particular interest is to
determine if a true integration can be made of Join into Java. This
works seeks to develop a true language extension not just a class
library. This research also investigates the impact of the Join
constructs on the programming of well-known concurrency software
patterns including the size and complexity of the programs. Finally, the
impact on the performance on programs written in the language extension
is also studied.
The major contribution of the thesis is the design of a new superset of
Java called Join Java and the construction and evaluation of the first
prototype compiler for the language. The Join Java language can express
virtually all published concurrency patterns without explicit recourse
to low-level monitor calls. In general, Join Java programs are more
concise than their Java equivalents. The overhead introduced in Join
Java by the higher-level expressions derived from the Join calculus is
manageable. The synchronization expressions associated with monitors
(wait and notify) which are normally located in the body of methods can
be replaced by Join Java expressions (the Join patterns) which form part
of the method signature. This provides opportunities in the future to
enhance further the inheritance possibilities of Join Java possibly
minimizing the impact of inheritance anomalies.
|
What's New
- I have submitted my thesis - Jan 5 2005
- Benchmarking of applications complete - September 2004
- New version of compiler completed - January 2004
|
