JavaSymphony is a high-level Java-based programming paradigm
for parallel and distributed systems.
JavaSymphony is a part of the ASKALON
- a programming environment and performance tool set
for cluster and grid
provides high-level programming constructs which abstract low-level
programming details and simplify the tasks of controlling parallelism,
locality, and load balancing. JavaSymphony can be
used to program
distributed as well as shared memory applications.
JavaSymphony provided programming model to support shared memory
architectures, ranging from distributed NUMA and SMP parallel computers
to modern many-core processors. It provided a unifed
user-controlled locality-aware mapping of applications, objects and
tasks on shared and distributed memory infrastructures with a uniform
interface that shields the programmer from the low-level resource
access and communication mechanisms.
JavaSymphony helps the user to avoid complicated constructs for communication
between different machines and remote computation, adding a powerful set
of features to standard Java. A short overview of
these features follows:
- Dynamic Virtual Architectures. The programmer can dynamically
define and modify virtual distributed architectures (VAs) that impose a
virtual hierarchy on a system of physical computing nodes.
- Lock/Unlock VAs. The access to VAs can be restricted while they
are about to be modified.
- Access to System Parameters. System parameters could be retrieved
for the computing nodes, and the use of such nodes can be restricted if
they don't meet specific requirements.
- Automatic and User-Controlled Mapping of Objects. The user can specify
or not where a object will be placed. The object can mapped to a remote cluster, node, processor or a core.
- Single-threaded and Multi-threaded Objects. The methods of a remote
object could be executed in parallel by a set of threads or sequential,
by a single thread.
- Lock/Unlock Objects. The other parties can be restricted to access
an object for important execution region.
- Object Migration. The object can be migrated to other computing
nodes automatic or at the user request.
- Local and Remote Reference. One local reference for an object can
be transformed in a remote reference, which allows access to this object
from remote machines.
- Synchronous, Asynchronous and One-side Method Invocation. The remote
invocation of a method can be blocking or not, and the result can be retrieve
in the same moment (synchronous), at a later time (asynchronous) or just
- Persistent Object. The programmer can store or load objects to/from
- Fine grained locality control. Locality
of objects and invoked methods on these objects can be controlled
at cluster, machine, processor and core level on multi-core
architectures and clusters.
In order to build/run JavaSymphomny applications, three software components
Note: Both JS Shell and the application have to be executed on a computing machine
where NA is running. A few configuration file are used to general settings
of the distributed environment like list of possible workstations and communication
ports, number of threads for a NA, etc.
For some language requirements for building an application see language
- JavaSymphony library has to be installed on the developer's machine
and its path added to the classpath in order to build JavaSymphony applications
- Network Agent (NA) programm has to be running on each host which
is intended to be used for the JavaSymphony
applications. This is a Java application and a shell script is provided
for running it. An optional communication port can be specified for each
- JS Shell is a graphical interface written in Java which allows administrative
operations for the computing nodes. Computing nodes which will be used
and where the network agent is running are organized with this interface.
A shell script for running this application is also provided.
You can download JavaSymphony here .