Deployment Examples

The following are deployment examples of our various libraries. The goal of HLSLibs is to create an open community for exchange of knowledge and IP for HLS (High-Level Synthesis) that can be used to accelerate both research and design. The libraries are targeted to enable a faster path to hardware acceleration by providing easy-to-understand, high-quality fundamental building blocks that can be synthesized into both FPGA and ASIC. HLSLibs are delivered as an open-source project on GitHub under the Apache 2.0 license and contributions are welcome.

Quantized Waveform

AC Datatypes

The Algorithmic C datatypes include a numerical set of datatypes and an interface datatype for modeling channels in communicating processes in C++. The numerical datatypes provide an easy way to model static bit-precision with minimal runtime overhead. They include bit-accurate integer, fixed-point, floating-point and complex datatypes. The numerical datatypes were developed in order to provide a basis for writing bit-accurate algorithms to be synthesized into hardware.

 


The Algorithmic C (AC) datatypes include a numerical set of datatypes and an interface datatype for modeling channels in communicating processes in C++. The numerical datatypes provide an easy way to model static bit-precision with minimal runtime overhead. They include bit-accurate integer, fixed-point, floating-point and complex datatypes. The numerical datatypes were developed in order to provide a basis for writing bit-accurate algorithms to be synthesized into hardware. The Algorithmic C Datatypes are used in Catapult High-Level Synthesis, a tool that generates optimized RTL from algorithms written as sequential ANSI-standard C/C++ specifications.

Operators and methods on both the integer and fixed-point types are clearly and consistently defined so that they have well defined simulation and synthesis semantics. They enable algorithm, system and hardware designers to precisely model bit-true behavior in C++ specifications while accelerating simulation speeds by 10-200x faster versus alternate bit-accurate integer and fixed-point datatypes. The bit-accurate complex and floating-point types are unique in that they are not available in alternative datatype packages such as SystemC. Bit-accurate complex types are important because they allow computation of additive and multiplicative operations on a mixture of complex operands based on bit-accurate integer and fixed-point types and return the require type so that results are represented without any loss of precision.



The advantages of the AC datatypes over the existing integer and fixed-point datatypes are the following:


Arbitrary-Length: This allows a clean definition of the semantics for all operators that is not tied to an implementation limit. It is also important for writing general IP algorithms that don’t have artificial (and often hard to quantify and document) limits for precision. For example, Catapult provides generic math functions such as division and square root for arbitrary-length datatypes.

Precise and Consistent Definition of Semantics: Special attention has been paid to define and verify the simulation semantics and to make sure that the semantics are appropriate for synthesis. No simulation behavior has been left to compiler dependent behavior. Also, asserts have been introduced to catch invalid code during simulation. There is consistency of semantics across datatypes. Whenever possible, the return type of operators does not loose precision.


Correctness: The simulation and synthesis semantics have been verified for many size combinations using a combination of simulation and equivalence checking.

Simulation Speed: The implementation of ac_int uses sophisticated template specialization techniques so that a regular C++ compiler can generate optimized assembly language that will run much faster than the equivalent SystemC datatypes. For example, ac_int of bit widths in the range 1 to 32 can run 100x faster than the corresponding sc_bigint/sc_biguint datatype and 3x faster than the corresponding sc_int/sc_uint datatype.

Compilation Speed and Smaller Executable: Code written using ac_int datatypes compiles 5x faster even with the compiler optimizations turned on (required to get fast simulation). It also produces smaller binary executables.



WHAT YOU GET


The zipped folder contains a reference manual, release notes, header files and a python script for pretty printing of the AC Datatypes in the gdb debugger.

  • ac_channel.h - Header to model streaming communication between blocks in C++.
  • ac_complex.h - Header for complex (real, imaginary) datatype.
  • ac_fixed.h - Header for bit-accurate fixed-point types.
  • ac_float.h - Header for bit-accurate floating-point types. The mantissa is an ac_fixed (two's complement) and the exponent is an ac_int.
  • ac_int.h - Header for bit-accurate integer types. It also provides other utility functions and contains the base classes to implement arbitrary length arithmetic.

  • ac_sc.h - Header containing conversion function to and from SystemC datatypes and tracing function to use the AC Datatypes within SystemC.
  • ac_pp.py - Python script for pretty printing of the AC Datatypes in the gdb debugger
  • Reference Manual - Overview of Algorithmic C Datatypes
  • Release Notes - Algorithmic C (AC) Datatypes Release Notes Software Version 3.7