Precision vs. energy consumption: How Approximate Computing can make algorithms more energy-efficient

This is a blog post-version of the recent live talk of Prof. Dr. Christian Plessl in the clean-IT openXchange series. In his live talk, Plessl introduced the principles of approximate computing and how they can be used to reduce the energy consumption of computers. The recording of the live talk can be found in the clean-IT Forum on openHPI.

Introduction

As Moore’s Law reaches its inevitable conclusion, engineers are looking for new ways to increase performance and decrease energy consumption. Approximate computing is one of the approaches being considered for this purpose. This blog post will explain approximate computing and how it can be applied to certain algorithms. It will also dive deeper into application examples, such as low-precision computing and submatrix algorithms.

What is Approximate Computing?

Approximate computing is a paradigm that sacrifices precision, correctness, and reliability in order to increase performance and energy efficiency. While this might sound like a risky endeavor, there are applications that allow these sacrifices easily.

Figure 1: Approximate Computing can be implemented into algorithms or software to increase energy efficiency without altering the application level or the underlying hardware

Get Nils Koenig’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Low Precision Computing

Low-precision computing is one way to reduce energy consumption and improve performance, especially for iterative algorithms. This method involves using a lower precision format for operations that allow a certain margin for errors while using higher precision for other operations that need to be exact. For example, one could use a low precision for the first several iterations of an algorithm — where the statistical error would be higher for both low and high-precision formats, anyway — and then move to a higher precision for later iterations when a lower error is important.

Figure 2: Statistical error from low and high-precision calculation through multiple iterations of an algorithm. For the first few iterations, using higher precision does not result in a lower error than using lower precision (https://arxiv.org/abs/1703.02283).

Submatrix Algorithm

Another approach to approximate computing is the submatrix algorithm. This method involves dividing a matrix into multiple, dense matrices, which can be processed independently. The submatrices are then added back together to form an approximated result. While this doesn’t necessarily produce the exact same result as processing the entire matrix as one, this approach allows for high parallelization.

Figure 3: Matrices can be split up and processed independently. While this process might introduce errors to the result, the process can be parallelized, which can increase energy efficiency (https://ieeexplore.ieee.org/document/9355245).

Conclusion

Approximate computing is a versatile paradigm that can be applied at different levels. It does not require disruptive technology or futuristic, post-silicon devices, and can be tailored to existing hardware. In this blog post, we explored how it can be used to increase performance and reduce energy consumption, through methods such as low-precision computing and submatrix algorithms.