TA-5M generates multi-threaded, multi-process C++. It distributes the implementation of platform-independent iUML models across multiple processes, where each process executes a user defined subset of a model’s functionality in the context of a user defined thread allocation strategy.
Separate C++ files are generated for each process, and whenever there is a remote (i.e. inter-process) object access or a remote operation invocation, TA-5M automatically generates the necessary code to implement this safely and efficiently.
Example Code
With TA-5M, this platform independent Action Language:
is translated into this target C++ Code:
Optionally, the original Action Language code is rendered as C++ comments in the target code so as to aid readability and traceability.
Run Time
The run time is an operating system and middleware independent layer which supports the execution of applications on any C++ target platform. In particular, it provides a mechanism for preventing threads from simultaneously accessing shared resources, and an infrastructure for supporting remote communication.
Adaptation Layer
TA-5M uses operating system resources (e.g. threads and semaphores) and middleware resources (e.g. remote procedure calls) to manage the distribution of models across multiple processes and threads.
It accesses these resources indirectly via an adaptation layer which decouples the run time from the details of any particular operating system and middleware.
TA-5M comes with adaptation layers for Windows & POSIX operating systems and Sockets & Corba middleware. This should support the needs of most users. However, users can also implement their own adaptation layers if they wish.
Graphical Debugger
TA-5M also comes with a debugger which allows the execution of applications on (possibly remote) target platforms to be controlled via a graphical user interface.
Locking Schemes
TA-5M supports both implicit and explicit locking schemes.
In the implicit scheme, code is automatically generated to lock objects in order to prevent multiple concurrent access to shared resources from causing run time corruptions or errors. For example, the following Action Language code:
tank = this -> R1
Results in generated that read-locks the object "tank" after the "navigate" down the association R1.
// ASL : tank = this -> R1
VAR_tank = VAR_this->R1_T_toA.navigate();
if (VAR_tank)
{
read_lock(VAR_tank);
}
In the explicit scheme, users have control over exactly when locks are acquired and released, e.g.
tank = this -> R1
$OBJECT_READ_LOCK tank
Distribution Strategy
TA-5M distributes code (ASL state actions, operations etc) and data (i.e. attribute data) across multiple processes based on the contents of a user defined configuration file. This file (plus supporting model tags) implicitly defines the location of every attribute of every class, and the location of every ASL statement in a model, e.g.
PROCESS "Process ONE" ONE 1 127.0.0.1 ...
PROCESS "Process TWO" TWO 2 127.0.0.1 ...
PROCESS "Process THREE" THREE 3 127.0.0.1 ...CLASS-PROCESS SIGEX RED ONE
CLASS-PROCESS SIGEX ORANGE TWO
CLASS-PROCESS SIGEX YELLOW THREE
Variants
TA-5M is available in portable and adaptable variants.
The portable variant provides a fixed set of mapping rules for transforming iUML models to C++ and the source code for the supporting run time libraries.
The adaptable variant provides a set of mapping rules which can be changed to meet the needs of particular projects or organisations by changing the iCCG configuration that produced the code generator. The adaptable variant comes with full source code.