Description
of the ATLAS platform.
ATLAS is a software platform specially oriented
to computer graphics applications that allows unsophisticated developers
to include advanced features in their applications with no or very little
extra information and effort.
The features of ATLAS include the splitting of
the application in distinct processes that may be distributed over a network,
a powerful configuration and scripting language, and several tools including
a journaling facility and an input system to easily construct reasonable
interfaces.
The most important aim that ATLAS wants to achieve
is a high level of transparency to the developer. Almost all services that
ATLAS offers to applications developed over it are
techniques that normally require a lot of specialized programming. The
emphasis in ATLAS 's design is to relief the programmer
from this effort.
Many facilities offered by ATLAS , like distribution
or the communications mechanism, must be totally managed by ATLAS
in order to achieve the maximum transparency to the developer. The
programmer need not know about these mechanisms and can concentrate on
the objectives of his application.
In terms of functionality, ATLAS includes these
objectives:
- Low level of parallelism: ATLAS
applications feature several distinct processes running
concurrently in the same or different machines in a network; processes
encapsulate ATLAS components or user modules. The
user implements routines that are accessible to other processes as
remote procedures. Since the application is split in several
processes, these need to communicate over the network and exchange
data between possibly different architectures. The distribution of
processes is managed by a centralized architecture (represented in the
figure) where the master process distr is the center of each
ATLAS application. This master process is then
the most crucial one in this architecture and also in the
communications mechanism because it is the communications center for
each application.
A sample execution of an ATLAS
application
- Configuration and macro language: The ATL language is a modular
language which is used by the developer to configure the application ---stating
which processes belong to it---, to describe the interface of a process
indicating the public routines that can be called by other modules, to
define the interaction among processes and the dialogues of the application
and also to obtain a rapid prototype. At run time the developer or the
final user can modify and recompile modules written in this language. To
the final user the ATL language is also useful because he can use it as
a powerful macro language that allows him to better control the execution,
or customize the environment. The virtual machine that interprets ATL code
allows both synchronous and asynchronous calls to external routines. Some
processes may therefore act as large batch processes that are executed
concurrently with the application.
- Flexible journaling mechanism: This mechanism records the actions
of the work session in order to be able to repeat this work session at
any other time. This is needed in incremental design applications (in particular
CAD-applications). The mechanism supports undo's and redo's and enforces
the consistency of data recorded in the journal after editions or modifications
of it.
- Fault-tolerance: Since the application is spread out among several
hosts, it becomes more exposed to transient or permanent failures (of the
communications or of any of the hosts involved). Fault-tolerance is transparently
provided based on the journaling mechanism and on heartbeat messages sent
by all processes so that their status can be assessed.
- Standardized input model: A great deal of effort in an application's
development is spent in its user interface. ATLAS provides
a uniform but flexible view of inputs that allows many different dialogue
modes in a uniform way.
- Reusability: Each user module is completely isolated from others
(in a separate process) except through a well defined interface described
in ATLAS 's programming language. Thus new components
can incorporate and use reliably old ones. This makes easy the integration
of new subsystems.
- Support to processes of constraints solving and parametric design:
ATLAS also includes some mechanisms like the global
identification mechanism which making a simple association of a tag to
every user input data solves some problems like checking of consistency
in the journaling mechanism, the problem caused by volatile references
in graphical input data and the use of symbolic data required by processes
of constraints solving.
Last update: February 3th, 1999
Marta Fairén mfairen@lsi.upc.es
UPC