Labor Embedded Control

Model Compiler for reConfigurable Architectures - MOCCA

With the increasing efficiency and availability of run-time reconfigurable (RTR) computer architectures and devices RTR systems become important candidates for the acceleration of a broad range of problems. However, years after its inception, reconfigurable computing still faces a wide gap between the capabilities offered by the hardware and the availability of mature methodologies and tools for the development of their targeted application domains.

We have developed a process and a supporting tool for the object-oriented system-level specification, design and implementation of applications for RTR-architectures. In our approach both, the application under development and the reconfigurable target platform are specified with models. The models are described with the Unified Modelling Language (UML) and an action language. A dedicated UML model compiler, MOCCA (MOdel Compiler for reConfigurable Architectures), implements our methodology in that it automatically performs system validation, platform mapping and application synthesis.

UML-Based Co-Design Approach

Figure 1 shows the basic activities and artifacts of our development approach. The illustrated approach incorporates the general methodology of hardware-software co-design into the concept of Model Driven Architecture (MDA). It is a particular goal of MDA to separate the application from the platform, comprising of hardware, operating systems, compilers etc., used for its implementation. This not only supports the retargeting of the application but can also simplify the mapping of a given application to a particular platform.

In our approach the application and the target platform are defined by means of independent models, described with UML and an action language. The application is defined by means of objects communicating through structured messages. The definition of the function, structure, and behavior of the objects is captured in an executable and platform independent design model (PIM). The target platform model (TPM) specifies all information necessary for platform mapping and synthesis. The TPM specifies the architecture of the target hardware. Thereby we specify hardware nodes, like reconfigurable devices and microprocessors, their communication paths, and the capabilities that these components provide for application implementation.

Given a PIM of the application we proceed by transforming it to a platform specific model (PSM). The PSM is defined by mapping the PIM to the TPM. Initially, we fix the hardware specific parameters of the implementation by mapping the objects of the application to the target architecture. Finally, if the implementation requires additional operating system support, e.g. for inter-object synchronization and communication, the according elements of the PIM are bound to the resources provided by the respective target platform devices.

The final step of the development process is synthesis, which is illustrated in Figure 2. Given a platform specific model of our application we proceed by transforming it into an implementation model which is finally synthesized into a ready-to-run implementation. The synthesis of software and hardware modules is parameterized by the implementation language specific patterns and rules which are incorporated into the synthesis tools and the target platform model.

Model Compiler for Reconfigurable Architectures

The described approach is backed by a dedicated tool called MOCCA. MOCCA takes as input UML-models that define the design-, implementation-, and deployment platforms being used inn the specific system and the design-model of the developed application. The structure of the application is defined with classes, interfaces, packages, and the varous relationships. Behavior is defined with operations. For low-level behavior definition a dedicated action-language (MOCCA Action Language (MAL)) is being used.

MOCCA Development Environment Overview

MOCCA transforms the given application model into a ready-to-run implementation. The implementation typically consists of a software executable and may also consist of a number of configuration bitstreams for configurable logic resources in the system. The generated implementation can be executed directly on the implementation platform, without any need for user interaction. Currently the compiler supports the generation of C++ and Java code on the software side, and VHDL and Verilog (partly supported) on the hardware side. In the generated implementation the object-paradigm being used for modelling is preserved down to implementation in hardware and software.

Platform mapping may be executed completely automated, but also complete or partial mappings of the application model to the implementation platform may be provided by the user. Again, these mappings are defined completely in UML. Partial mappings are completed by the compiler. For this extensive analyses of the system structure and behavior, accompanied by suitable transformations are performed.

More information about MOCCA can be found in the MOCCA Collaboration Platform. Note, however, that the access to this platform is currently restricted to the MOCCA developers.