WARE

• Command line interface runs under all Windows platforms.

• Runs on Linux/UNIX platforms under the WINE Windows emulator

• Fully compatible with ASH WARE Inc.'s eTPU2+ DevTool and several eTPU debuggers (e.g. Lauterbach, iSystem).

• Long Term Release Support - Ten year availability and support for all releases that have active customers. [You maintain your support contract and we'll support the release.]

• Generates highly optimized eTPU code that in all known cases beats existing solutions in terms of worst case thread length (WCTL), latency (execution speed), code density, data RAM usage, and reduced data RAM access count (affects latency.)

• Supports dual eTPU engine model on eTPU1 via a stack option. Only true global variables are shared between engines; code does not conflict when running on both engines. (This fixes an inherent bug in many users' code base, with no code changes!)

• Generates no statically-known "dead code", helping meet DO178B/C 100% code coverage requirements for avionic applications.

• Performance warnings when sub-optimal code is encountered (e.g. 8 or 16 bit variables in sub-optimal locations, signed division, etc.).

• Supports both inline and stand-alone assembly of the existing assembly language syntax.

• Auto-generates everything needed for host integration (but also supports #pragma write capability):

  • Location information for all global and channel frame variables.

  • Function number & entry table type information.

  • Global and channel frame initialization data.

  • Code array and calculated MISC.

  • Numerous Report Files - such as .map, .lst. Our analysis file provides detailed information on things such as maximum stack depth and worst case thread length

• Performance Validation including validation of critical indices such as WCTL.

• Built-in error handling library.

• Supports multiple data packing modes to allow users to compile for reduced data memory (SDM) size, or for smaller & faster code at the potential cost of greater SDM usage.

• Besides outputting in forms for actual inclusion in the target, the code & debug information is output in standard ELF/DWARF2.0 format for use by the eTPU2+ DevTool simulation environment and other debugging tools.

• Includes an enhanced mode with a small amount of additional syntax beyond C99 that provides a more intuitive and less failure prone Windows event/response style mapping of software (eTPU functions, threads, data) to the underlying eTPU hardware.

• The supported basic data types (signed and unsigned where appropriate) are:

• _Bool, char (unsigned int8), short (int16), int (int24), long int (int32), long long int (synonymous with int32)

• fract8, short _Fract (fract16), _Fract (fract24)

• Embedded C Specification (TR18037) named registers are supported.

• Legacy Merging - Merge existing generated code as-is (.COD files) with newly-written code using ASH WARE's eTPU Development Tool Suite. Keep the old, move forward with the new.

• The ETEC library functions provide programmers with methods to explicitly control atomicity, synchronization and coherency within their code.

• Translation unit orthogonality with a "classic" two-stage compile/link building process (though for compatibility purposes, all code can still be included into a single translation unit)

• Fully supports the existing eTPU C programming model for channel hardware access, condition code access, and entry table definition.

• Ash-Print - Instrument your code to provide user-defined and formatted simulation trace files.

• Assembler supports existing customer's syntax both 'inline' and 'Stand-Alone'

• Supports a static Worst Cast Thread Length (WCTL) analysis capability!  WCTL (including both 'steps' and 'RAM-accesses') is available in the Analyses file. Click here to view the analyses file generated for Freescale's Set 1.

• #pragma verify_wctl, supports a requirements-based approach to WCTL such that the build will fail if user-specified requirements are not met.

• Although the default ETEC programming model / calling convention is stack-based (thereby preventing the dual eTPU coherency issue), ETEC does provide the option of compiling with a global scratchpad model.  Although it should be used carefully, there are cases where it simplifies the porting of existing code and/or can result in tighter code.

• For the eTPU2, an engine scratchpad programming model / calling convention is available.  This can provide the benefits of the global scratchpad approach but without the dual eTPU coherency issue (eTPU2-only).

• Fragment support improves WCTL when using shared code.  Fragments improve structure and readability and in many cases this eliminates the need for the dreaded 'goto'.

• Fast 'switch' reduces code size & improves WCTL of a 'C' switch. An enumeration is generated at link-time which generally eliminates one jump from the 'dispatch' such that the dispatch-offset is the ultimate destination (very COOL!) 

• Exposes a set of intrinsic functions that allow users to access all ALU/MDU operations from C code.

• The ETEC toolkit has been C compiler validated using the Perennial CVSA test suite.  Contact us for details.

​