• Team project for Computer Engineering students
• Course number: L.079.09702
• Terms: WS 20/21

Many applications may perform inaccurate (or even erroneous) computations and still produce acceptable results. These applications show an inherent resiliency against inaccuracies since they: 

1. are designed to deal with noisy, imprecise, or incomplete input data,
2. target human perception (we cannot identify small differences in an image or audio signals),
3. cannot compute an exact or optimal result (e.g., a simulation which relies on models and heuristics, or accurate computations result in extremely long runtimes), or 
4. cannot compute the correct answer (e.g., for a recommender system, such as a search engine, a correct answer does not necessarily exist).

The design paradigm Approximate Computing exploits the resiliency of applications through the intentional design of incorrect software and hardware to trade off accuracy (or quality) against a target metric (e.g., runtime, energy consumption, or hardware area). However, it is vital that the approximate application meets the minimum quality constraints and ensures that the produced results are indeed acceptable. The application's user or designer usually defines the quality constraints. The images below show an example of outputs produced by a JPEG compression hardware and motivate the importance of applying approximations intelligently to produce acceptable results while achieving the best-possible improvements. 
The image on the left-hand side shows the compressed output image generated with the original, precise system.

The center image and the image on the right show examples of approximate outcomes. 
JPEG compression hardware subjected to approximations produced these two images. Some bits have been truncated from the computations for the hardware generating the center image, resulting in an outcome beyond acceptable quality. The approximations of the hardware creating the image on the right-hand side have been applied more intelligently, making it almost indistinguishable from the reference (left image). For both the image in the middle and the image on the right-hand side, power savings of around 53% over the original implementation have been achieved, highlighting the benefits of Approximate Computing and the advantages of the approximation technique that generated the image on the right.

For Approximate Computing on the circuit level, we have two frameworks in our group: CIRCA and VEGAxC. The goal of the project is to extend both frameworks by novel methods.

CIRCA:

CIRCA is an approximation framework for digital circuits that implements a typical approximation flow, iterating the following steps:

1. explore the search space and find new approximate circuits (AxCs), 
2. generate the explored AxCs, 
3. determine circuit parameters, and 
4. verify the quality of the individual AxCs after generation.

CIRCA is designed as an experimentation environment in the field of Approximate Computing to evaluate new methods and foster comparative studies. Hence, CIRCA's design is general and modular so that CIRCA is not limited to specific techniques, i.e., CIRCA can be extended by new search algorithms, approximation techniques, or verification techniques. In the past, we have focused our research on the implementation and evaluation of search methods. This project focuses on CIRCA's extension by new approximation techniques and a comparative study.

VEGAxC:

VEGAxC proposes a novel approximation flow by first formally verifying the quality of every AxC in the search space rather than verifying an AxC after it has been explored and generated, as done in the typical flow. In its current state, VEGAxC verifies the search space and returns a set of quality bounds for certain components of the input circuit. If the components adhere to their given quality bounds, VEGAxC guarantees that the resulting AxC will satisfy the user-specified quality bounds of the overall circuit. A subsequent approximation flow that utilizes the quality bound information to generate AxCs, however, is missing. Thus, the group will design and implement such a flow ­- ideally, utilizing the new approximation techniques in CIRCA.

The goals of the project are the followings:

• Implement new approximation techniques in CIRCA.
• (Optional) conduct a comparative study for the approximation techniques.
• Design and implement an approximation flow that connects VEGAxC and CIRCA.
• (Optional) analyze and improve the performance of VEGAxC.

If you need further information, do not hesitate to contact Linus Witschen.