Overview

Consortium

Results

Articles

SystemC(TM)

SystemC(TM) Plus Methodology

Events

Links


ODETTE Synthesiser




 

HOME


ODETTE page at OFFIS


SystemC(TM) Plus Methodology

 
OSSS
 
Design Flow
 
Tool Architecture
 
Synthesis
 
Veification
 
Co-Simulation
 
Generic Class Library
 
Application Specific
Class Library
 
Downloads
 
Publications

 

Presentation of the ODETTE synthesis tool

Language Reference Manual - specification of input language subset supported by the ODETTE synthesis tool

Guidelines for using ODETTE Synthesiser

 


The overall ODETTE synthesis process is not supported by a single stand-alone tool but it is based on a tool suite.
Synthesis process starts from a OSSS hardware specification based on an extended SystemC(TM) synthesis subset containing object-oriented language features of C++. Such input specification is transformed into an intermediate format by a SystemC(TM) front-end.
After that a synthesis tool developed by OFFIS processes this intermediate format, transforms all object-oriented constructs into behavioural equivalent constructs at a lower level of abstraction and generates synthesisable SystemC(TM) or VHDL code at RT or behavioural level
The generated SystemC(TM) or VHDL code can be further processed with common logic synthesis tools.

Figure 1: Fuctionality of the ODETTE synthesis tool

 


The ODETTE Synthesiser is one of the major results of the ODETTE project. Synthesis means here high level synthesis on top of the existing tools like the CoCentric® SystemC Compiler or Behavioural Compiler®, which are still necessary to perform behavioural and logic synthesis.

The ODETTE Synthesiser itself is meant to provide the functionality to translate an object-oriented hardware model represented in an intermediate file format into a behavioural equivalent model without object-oriented constructs. The resulting model yields the same simulation results as the input model and is capable of being processed by backend-synthesis tools.

 


The synthesis process performed by the ODETTE synthesis tool consists of basically three different phases:

  • analysis phase
  • optimisation phase
  • translation phase,
  •  

    Analysis

    The analysis-phase collects information, which is needed in the following optimisation and translation phases. For the optimisation phase for instance the following information has to be collected:

  • which methods of an object are called in the modelled system
  • which objects are locally/globally instantiated
  • how many clients are connected to each global object
  • which methods of a global object are called
  • which attributes of an object are accessed
  • which class memberships does a polymorphic object effectively take on in the modelled system
  •  

    Optimisation

    The optimisation-phase can apply information collected in analysis phase to:

  • avoid the hardware implementation of methods, which are never being called in a certain system
  • avoid the hardware-implementation of memory for attributes which are never used
  • reduce the state space needed for polymorphic objects to a minimum needed
  • optimise access to global objects if the number of calling clients and the called methods are known,
  •  

    Translation

    In general the translation-phase needs the following information to perform translation of object-oriented constructs:

  • the name and exact type of each variable and constant
  • for every class the names and exact types of each data member (including inherited ones)
  • for every class the names and signatures of each implemented method (including inherited ones)
  • the name and port list (including types of ports) of every module
  • the name of every process in a module, the information whether it is synchronous or asynchronous and its sensitivity list
  • which kind of scheduling strategy is used for controlling access to a global object
  • which ports are connected to which signals
  • how many bits have to be provided for the encoding of every data type
  • how many bits have to be provided for encoding method calls
  • whether a method-call is addressed to a local or a global object
  •  


    Actually Implemented Functionality

    The ODETTE Synthesiser is in advanced prototype stage. A lot of features have been implemented up to now and the software in its actual state meets the requirement to be capable of synthesising an object-oriented hardware description written in object-oriented SystemC(TM).

    The final prototype supports all object-oriented SystemC(TM) features and generates behavioural SystemC(TM) code that can be simulated as well as be synthesised with the CoCentric® SystemC(TM) Compiler.

    The short overview of the supported features at the time of writing this document is given in the following:

     

    User interface

  • A console-based user interface to the synthesis tool has been implemented that can be easily upgraded to support additional commands and features.
  •  

    Optimisations

  • Unused data members are detected and eliminated. Three different levels can be chosen for this optimisation
  • no optimisation: dead data members are not eliminated
  • class based: the set of dead data members is determined for each class and dead data members are eliminated
  • instance base: the set of dead data members is determined for each instance of a class individually and dead data members are eliminated
  • Unused functions/function declarations are excluded from synthesis and are simply removed.
  •  

    Synthesis

  • Conventional C++ classes, regarding the SystemC(TM) Plus Coding Guidelines or more precisely instances of classes can be synthesised. This includes support for
  • member functions
  • constructors
  • complex members (objects and arrays as data members)
  • member initialisation
  • operator overloading
  • Class templates are supported for synthesis, including
  • scalar template parameters
  • type parameters, e.g. user defined classes
  • inheritance from class templates
  • Polymorphic objects can be synthesised, including
  • assignments from and to simple and polymorphic objects
  • assignments from and to polymorphic signals
  • polymorphic objects as function parameters
  • dynamic dispatching of virtual functions
  • Inheritance is supported, including
  • multiple inheritance
  • virtual base classes
  • Hierarchical designs are supported
  • Module templates are supported
  • Global objects can be synthesised, including
  • assignments to global objects
  • guarded calls to global functions and procedures of global objects
  • automatic generation of necessary hardware for synthesising a global object, including scheduler, server object, guard evaluator and multiplexer. The scheduler can be either one taken from the OOHWLIB (static priority, round robin or modified round robin) or the user can think of an own schedule strategy and implement an own scheduler. All necessary connections and modules are generated automatically.
  • Code generation

  • SystemC code generation
  • VHDL code generation
  • still in development
  •  

    Due to the flexible architecture of the synthesiser, a lot of additional features and support for certain constructs that have not been implemented yet, can be easily added to the tool. These enhancements even include support of additional constructs or data types that have not been regarded for synthesis and for the synthesisable input language subset in the first place.