APPROXIMATE COMPUTING
Contents
Part I:
• Introduction
Part II:
• Background
o Probabilistic Computing and Information Theory
o Error-Correcting Codes
o Monte Carlo Algorithms
o Elastic Circuits
o Elastic Circuits & Quality-Aware Computing (QAC)
o EnerJ Tool & Georgia Tech and IBM
Part III:
• Literature Review
o Approximation Techniques
o Approximation in Software vs Hardware
o Pros and Cons
• Literature Review
o Applications
o Real-life Examples
Part IV:
• Potential Vulnerabilities
o Lack of Error Control in Approximate Memory
o Security Threats to Approximate Storage
o Exploitation of Hardware Weakness
Part V:
• Recommendations for Improvement
o Improved Security for Memory Access
o Error Detection and Correction Mechanisms
o Decomposition of Critical and Non-Critical Data
o Regular Security Supervision and Testing
Part VI:
• Conclusion
Part VII:
• References
I. Introduction
Approximate computing is a design style that helps to improve energy efficiency and high-performance computing by challenging the traditional expectation of perfectness in computations (Han & Orshansky, 2013). This method will return slightly bit of inaccuracy instead of certain accurate result (Sampson et al., 2011). It is wildly used for applications, image and video processing, machine learning, and data analytics where minor errors and approximate result have little to no impact on the final output (Liu, Lombardi, & Schulte, 2020).
This type of design works well because many applications can handle a little imprecision without decreasing its performance quality. Nevertheless, to put it into practice correctly, it needs own special technique (Sampson et al., 2011). One of the examples are good model for coding, tools to test and debug the approximations. Also, its essential to ensure the systems final output is usable and good enough for that, otherwise the whole effort is just waste of energy, rather than saving it.
One key requirement is that approximation should be used only in non-essential systems or data. We can’t use it in systems where precision and extremely accurate data needed like control logic, security operations, medical applications, financial transactions and etc. The small errors or inaccuracy can cause the program to crash, and many more serious issues or even legal issues (“Approximate Computing”, 2024). So, the main goal here is balancing accuracy enough to be useful in right areas, in order to improve performance, to gain speed and save some energy (Esmaeilzadeh et al., 2012).
This research will cover the historical background of approximate computing, the techniques used in implementation approximation to both software and hardware levels, their cons and pros for each approach, some real-life examples, and applications. Additionally, it explores its potential vulnerabilities, and some recommendations for improvement.
II. Background
Approximate computing was not invented by a single individual, but rather the result of collective work. That was developed over decades by many researchers in different fields. However, some people and groups played significant roles on developing approximate computing at different levels.
• Probabilistic Computing and Information Theory:
During 1940s, Claude Shannon come up with an information theory. It explained the ways to deliver data with a bit of interference, but still maintain data integrity and communication systems to tolerate it (Shannon, 1948). Meanwhile, scientist
Von Neumann was analyzing probabilistic computing. Its key concept to show how computers could keep working even if some components have failed and malfunctioned (Von Neumann, 1956). Even though approximate computing was not the direct goal for these two researchers, they still helped to build a foundation for it by showing that small errors can be okay.
• Error-Correcting Codes:
Richard Hamming, another researcher who was working on similar concept as approximate computing around the same time. He developed an error-correcting codes, which could detect and correct small errors in data automatically in computers. For instance, if a single bit of data accidentally switched from 0 to 1, his code easily identifies the inaccuracy and fixes it (Hamming, 1950). He demonstrated that the system can keep running and functioning without a perfect precision. Nowadays this idea is still used in memory systems, CDs, DVDs, and other wireless communication technologies.
• Monte Carlo Algorithms:
The seed for approximate computing was introduced by Stanislaw Ulam and Nicholas Metropolis in the technique called Monte Carlo algorithms in the 1950s. In this method, they showed that “good enough” answer was better than waiting for a perfect answer for a long time (Metropolis & Ulam, 1949). At the time, this approach was a huge shift. To achieve it, this method used random sampling to get the close enough answer instead of the exact one. “Turns out, being good enough is genius!”.
• Elastic Circuits & Quality-Aware Computing (QAC):
In the 2000s, Anant Agarwal and his team from MIT created “elastic circuits”. They were focused on saving power by reducing a bit of accuracy. Which is great for things like video play, voice recognition, where 100% accuracy was not needed because you will not notice the difference (Sampson al., 2011). This method is used in mobile devices. For example, they will not calculate everything to the exact decimal, instead of that they will allow a little bit of error to save battery and energy. The similar concept used Rakesh Kumar and his team when worked on “Quality-Aware Computing” framework at UIUC, but he builds the approximation directly into the processor, which again helps to save some energy (Narayanan, 2010).
• EnerJ Tool & Georgia Tech and IBM:
The developers from The University of Washington have created a tool called EnerJ that allowed programmers to flag part of code as @Approx or simply “okay to be a little wrong” (Sampson, Ceze, & Grossman, 2011). Their tool helped to
manage the trade-off between accuracy and power usage, where small errors are acceptable. Which resulted in bringing approximation into software development. Shortly after that, Georgia Tech and IBM worked on designing chips and programs like compiler tools that allow minor errors and still works good (Esmaeilzadeh, 2012). They were focused on real life applications, hardware and software systems.
III. Literature Review
• Key Techniques in Approximate Computing:
Approximate computing is about trading off a bit of accuracy to gain major benefits in speed or energy efficiency. In other words, we allow the computer to be “good enough” instead of perfectly exact when full accuracy isn’t needed. This section covers four key techniques in approximate computing: approximate adders & multipliers, loop perforation, precision scaling, and voltage scaling — and explains what each is and how they are used and such (Mittal, 2016; Leon et al., 2025).
o Approximate Adders & Multipliers:
Approximate adders and multipliers are arithmetic circuits designed to produce nearly correct results using simpler, faster hardware. For example, an approximate adder might skip carrying over certain bits in addition, sacrificing a little accuracy for speed. It’s similar to rounding numbers when doing math in your head — the answer comes quicker but might be slightly off. Since these circuits skip some of the extra fine-tuning that exact ones do, they end up using way less power. In real world tasks like editing images or playing music, a tiny error here or there doesn’t even matter, so you get big energy savings without anyone noticing a difference (Han & Orshansky, 2013; Venkataramani et al., 2015).
o Loop perforation:
Loop perforation is a software technique where a program deliberately skips some iterations of a loop to save time. It works like so: instead of running every single iteration, the loop might skip, for example, every 3rd cycle — meaning it’s doing less work and finishing faster at the cost of a less precise result. It’s like reading a long book but skipping a few pages — you reach the end quicker but might miss some details. According to studies, loop perforation can greatly boost performance or cut energy use in certain applications, with only minimal loss in result quality (Sidiroglou-Douskos et al., 2011).
o Precision Scaling:
Precision scaling involves using lower-precision data (fewer bits) in a computation to improve efficiency. For example, using 16-bit or 8-bit numbers instead of 32-bit makes each calculation faster and less power hungry at the cost of some accuracy. This is like measuring with a ruler that has only centimeter marks instead of millimeter marks: it’s quicker but less exact. In practice, many signal processing and machine learning systems use just enough precision to meet quality needs and maximize speed. Studies show that reducing numeric precision can dramatically speed up processing and save energy while keeping results within acceptable quality limits (Mittal, 2016; Gupta et al., 2011).
o Voltage Scaling:
Voltage scaling is a hardware approach that lowers a processor’s supply voltage to save energy, while accepting a slight risk of errors. Running at a lower voltage cuts power use drastically, but if it goes too low the transistors become unreliable and may produce incorrect results. It’s akin to dimming a lamp to save electricity: you use much less power, but if you dim too far the light might flicker (similar to computation errors). Engineers deliberately undervolted systems to just above the point where errors would surge, achieving huge energy gains while keeping error rates low enough to tolerate. Studies show that aggressive voltage scaling can greatly reduce energy use in error-tolerant scenarios as long as the error rate is kept under control (Han & Orshansky, 2013; Venkataramani et al., 2015).
• Approximation in Software vs Hardware:
Approximate computing introduces intentional inaccuracy to gain efficiency. This can happen in software and hardware, or both. Each approach has benefits which will be explained in the following (Mittal, 2016).
o Software Approximation:
Software approximation basically means modifying programs to produce “good enough” results more efficiently. It works by skipping some computations, using simpler algorithms, or by reducing precision in calculations to save both time and energy. For example, a video streaming app might drop a few frames or use a lower resolution during playback, which users do not notice — but this significantly reduces CPU usage. An advantage is flexibility: developers can tune the approximation level in software without special hardware. However, the code must be designed carefully to
avoid obvious quality loss (you don’t want the user to notice a lack in quality), and its speedups are still limited by the underlying hardware’s capabilities (Leon et al., 2025; Venkataramani et al., 2015).
o Hardware Approximation:
Get Sıla Pekşen’s stories in your inbox
Join Medium for free to get updates from this writer.
Hardware approximation goes deeper. It involves designing circuits or processors that deliberately trade off accuracy for efficiency. It might use arithmetic units that introduce minor errors or lower-precision math (e.g., 16-bit instead of 32-bit) to be faster and use less power. One example is mobile AI chips and GPUs that use low-precision computation to speed up tasks like image or speech recognition while greatly reducing power usage. The big benefit of approximate hardware is a significant gain in performance and energy efficiency, because the chip can be simpler or run at reduced power. However, if more accuracy is needed, unfortunately, once the hardware is built, its approximation level is fixed and can’t easily be changed. Modern systems often combine both approaches by running error-tolerant software on power-efficient approximate hardware; this yields greater performance and efficiency than either approach alone while still delivering acceptable results (Jouppi et al., 2017; Gupta et al., 2011).
• Pros and Cons of Approximate Computing:
o Pros:
There are substantial benefits and drawbacks to approximate computing. On the bright side, it can result in a fantastic improvement in energy efficiency and execution speed. From multimedia processing to machine learning, many error-tolerant systems can tolerate small errors, enabling the system to trade accuracy for performance. Less effort and power are used when some computations are skipped or simplified. For instance, viewers often don’t notice when a few frames are dropped in a video feed. Similarly, a machine learning algorithm like k-means clustering can save up to 50× energy by tolerating a 5% drop in result accuracy. Even specialized hardware has made use of this tolerance; for example, Google’s Tensor Processing Unit (TPU) uses reduced-precision computations to effectively speed up AI operations (Jouppi et al., 2017; Venkataramani et al., 2015).
o Cons:
Despite all that, approximate computing isn’t perfect. It naturally introduces error into results, which means it’s not suitable for tasks that require complete precision — like medical equipment or banking systems. Even a tiny mistake could cause serious consequences. These industries typically avoid approximate methods. There’s also the issue of debugging and testing. You expect exact answers from systems, but with approximate computing, you’re kind of expecting it not to be exact, which makes validation trickier. Developers need special tools to ensure outputs stay within acceptable quality. And if approximation is pushed too far, results can become useless, negating any efficiency gains. Used smartly, though, like in mobile or AI applications, it can be a huge win — just not where perfect accuracy is critical (Leon et al., 2025; Gupta et al., 2011).
• Applications using approximate computing:
Approximate computing can successfully have better energy efficiency as it trades off accuracy in computation, storage, and communication for better performance. The main benefits of using approximate computing in applications are to save energy, fast response and cheaper cost.
o Machine learning:
Approximate computing works pretty well for tasks like machine learning where 100% accurate results are not necessary. Machine learning techniques work by teaching the computer by giving examples not rules and perfect accuracy is often impossible or unnecessary we can say. As machine learning already uses approximation to distinguish the data in the learning process, using approximate computing can be very convenient with it. Some of the techniques used in approximate computing for machine learning are quantization, pruning and in-memory computing (Ankur Agrawal et al. 2019). Quantization saves storage and makes the whole process relatively faster as it reduces the number of bits used in storing data. Pruning also helps with keeping only the necessary parts and making the models faster and smaller. Approximate computing can help with in-memory computing by making the calculations in the memory itself and reduce data movement. A real-life example where approximate computing is useful for machine learning is creating devices that can work with limited resources to run the ML modules like small sensors.
o Image and video processing:
One of the fields that can benefit very well from approximate computing is the image and video processing. To have a better understanding, image and video processing work by having the input picture or sequence of pictures (for a video), preprocessing it and extract the features of the picture. This process can be on pixel-by-pixel level or region-based level for advancement (Sekanina, Vasicek, Imrazek, 2017). Region based technique can benefit from approximate computing as it processes only the critical parts of the image like faces or objects and for videos as well the motion regions like humans are processed very high in details while the background is approximated. This reduces the timing while still maintaining good recognition quality.
o Internet of Things:
Internet of things refer to devices that are connected together on the internet to share and manipulate data. These devices usually do not require very high power and do not need perfect accuracy in performance which works very well with approximate computing. We have many examples of IoT devices that use approximate computing such as sensor for temperature and air quality, wearables like the fitness and health bands.
• Real life examples:
In our daily life a lot of products and systems are based on approximate computing. Some of the communication applications such as zoom or google meet use approximate computing for face enhancement and background blurring, Google translate is yet another example, it works on the concept of giving the correct meaning without the need of analyzing word by word separately. Approximate computing is used mostly by companies that prioritize energy efficiency over accuracy such as Intel, they use approximation for embedded systems in making mobiles and IoT devices. Google uses approximation such as tensor processing units which is used in google translate and assistant.
IV. Vulnerabilities of Approximate Computing (Storage Systems)
This approach has energy savings, it also intoduces potential security threats that traditional precise memory systems can’t catch.
• Lack of Error Control in Approximate Memory:
One of the dangerous threats of approximate computing is that intentionally introduces errors for performance or energy savings (GLSVLSI’19, 2019). If these errors are not controlled effectively, they can propagate throughout the system (GLSVLSI’19, 2019). In storage systems, these errors may affect not just a calculation or piece of data but could accumulate over time and causes catastrophic failures. This is especially risky for apptication where high data accuracy is crucial, such as medical systems, auto vehicles or financial apptications.
o Data Corruption Over Time:
As errors propagate, the quality of the data stored in approximate memory will decompose over time. This is problematic in systems that store and process large amounts of important information, as these errors could lead to serious consequences if they not checked yet.
• Security Threats to Approximate Storage:
Approximate storage contains both hardware and software components. Each of these contains vulnerable to various attacks (GLSVLSI’19, 2019). For example, attackers can use corrupted memory or vulnerabilities in software to manipulate data. These and other vulnerabilities takes down the trust for approximate storage.
o Attack on Data Integrity:
By targetting approximate memory, an attacker can corrupt or alter the data being stored with minimal resource use (Privacy Leakages, 2018). This could lead to compromised system operations where the data stored is either incorrect or unreliable, affecting the overall functioning of applications relying on that data.
• Exploitation of Hardware Weakness:
Approximate storage components are designed to tolerate small errors. They can abuse it (On the (In)security of Approximate Computing Synthesis, n.d.). For example, they can manipulate error levels or insert errors to corrupt the storage and cause a denial of service. These weakness can be difficult to detect.
o Attacks on Memory Access:
Since approximate storage may be less secure, attackers might target weak points. Potentially gaining unauthorized access to sensitive data or dangerous memory operations is how the memory access or controlled (Privacy Leakages, 2018).
V. Recommendations for Improving Security in Approximate Storage
o Improved Security for Memory Access:
Secure memory access controls are very important to prevent unauthorized access to approximate memory. Applying strong access controls such as multi-layer authorization or encryption for memory operations can increase the security. Using secure communication channels to transfer data to and from memory can protect the data during the storage process.
o Error Detection and Correction Mechanisms:
Error detection and correction mechanisms should be added into the storage systems (“Security in Approximate Computing”, 2020), These systems should be able to detect when limits are exceeeded and correct errors before they put data in danger. Regular checks for redundancy and memroy consistency help prevent serious data loss.
o Decomposition of Critical and Non-Critical Data:
Approximate computing in general, it is essential to separate critical data from non-critical data. Critical data (like medical records or financial transsactions) should always be stored in sensitive memory, while less critical data can be handled by approximate storage
(“Security in Approximate Computing”, 2020). This approach makes sure that sensitive infromation remains protected while still benefiting from the energy efficiency of approximate memory for non-essential tasks.
o Regular Security Supervision and Testing:
Security supervision should be regularly supervised to evaluate the effectiveness of the error management strategies and whole system completeness (GLSVLSI’19, 2019). This includes testing for vulnerabilities specific approximate storage and performing spread tests to simulate possible attacks. By continuously testing the system, developers can identify weaknesses and implement necessary security covers before they are used by attackers.
VI. conclusion
Approximate computing is not a physical device, but a design model that let small errors be in the system to make energy and performance works better. Especially in some areas like processing images, machine learnings like google or where we need to do data analytics. Since in these things the accuracy is not that important, we can use this design for them.
After the first idea, many techniques like computing with probability, error-correcting codes, Monte Carlo algorithms and some other things were there that it has evolved through them. There are some ways to let these inaccuracies occur for speed and energy saving. Some ways like include approximate adders and multipliers, preferring loops, precision and voltage scaling.
This design can be used in both software and hardware. If we use it in software it gives us more flexibility and if we use it in hardware, it offers more efficiency gains. This approximation is not suitable for tasks which needs exact accuracy, like medical or financial systems. However, if we apply it carefully, it can be beneficial.
I believe that this approximation model will have an important role in the future. Nowadays, everything is developing. This design in the future technologies can be really useful. Somewhere like AI and their related applications, system design or also multimedia. Every day we are trying to find ways to waste less energy. I assume it will become essential for low-power devices or some advanced designs, but of course there will be some problems like managing errors that should be managed carefully. (Sasan, 2022; Venkatesan, 2018)
VII. REFERENCES
Academic Citations:
• Agarwal, A., Ranganathan, P., & Simunic, T. (2003). Elastic circuits: Low power, high efficiency. Proceedings of the International Conference on Computer Design (ICCD), 109–117. IEEE.
• Damsgaard, H. J., Grenier, A., Katare, D., Taufique, Z., Shakibhamedan, S., Troccoli, T., Chatzitsompanis, G., Kanduri, A., Ometov, A., Ding, A. Y., Taherinejad, N., Karakonstantis, G., Woods, R., & Nurmi, J. (2024). Adaptive approximate computing in Edge AI and IoT applications: A review. Journal of Systems Architecture, 150, Article 103114. https://doi.org/10.1016/j.sysarc.2024.103114
• Esmaeilzadeh, H., Sampson, A., Ceze, L., & Burger, D. (2012). Neural acceleration for general-purpose approximate programs. 45th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO), 449–460. https://doi.org/10.1109/MICRO.2012.51
• Han, J., & Orshansky, M. (2013). Approximate computing: An emerging paradigm for energy-efficient design. Proceedings of the 18th IEEE European Test Symposium (ETS), 1–6. https://doi.org/10.1109/ETS.2013.6569370
• Henkel, J., Li, H., Raghunathan, A., Tahoori, M. B., Venkataramani, S., Yang, X., & Zervakis, G. (2022). Approximate computing and the efficient machine learning expedition. Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design (ICCAD). https://doi.org/10.1145/3508352.3549402
• Jouppi, N. P., Young, C., Patil, N., Patterson, D., Agrawal, G., Bajwa, R., … & Yoon, D. H. (2017). In-datacenter performance analysis of a Tensor Processing Unit. Proceedings of the 44th Annual International Symposium on Computer Architecture (ISCA), 1–12. https://doi.org/10.1145/3079856.3080246
• Leon, V., Hanif, M. A., Armeniakos, G., Jiao, X., Shafique, M., Pekmestzi, K., & Soudris, D. (2025). Approximate computing survey, Part I & II. ACM Computing Surveys, 57(7). https://doi.org/10.1145/3657456
• Liu, W., Lombardi, F., & Schulte, M. (2020). Approximate computing: From circuits to applications. Proceedings of the IEEE, 108(12), 2103–2117. https://doi.org/10.1109/JPROC.2020.3017881
• Metropolis, N., & Ulam, S. (1949). The Monte Carlo method. Journal of the American Statistical Association, 44(247), 335–341. https://doi.org/10.1080/01621459.1949.10483310
• Mittal, S. (2016). A survey of techniques for approximate computing. ACM Computing Surveys (CSUR), 48(4), 62. https://doi.org/10.1145/2893356
• Raha, A., Sutar, S., Jayakumar, H., & Raghunathan, V. (2017). Quality configurable approximate DRAM. IEEE Transactions on Computers, 66(7), 1172–1187. https://doi.org/10.1109/TC.2016.2633238
• Sampson, A., Dietl, W., Fortuna, E., Gnanapragasam, D., Ceze, L., & Grossman, D. (2011). EnerJ: Approximate data types for safe and general low-power computation. ACM SIGPLAN Notices, 46(6), 164–174. https://doi.org/10.1145/1993316.1993532
• Sekanina, L., Vasicek, Z., & Mrazek, V. (2017). Approximate circuits in low-power image and video processing: The approximate median filter. Radioengineering, 26(3), 623–632.
• Shannon, C. E. (1948). A mathematical theory of communication. Bell System Technical Journal, 27(3), 379–423. https://doi.org/10.1002/j.1538-7305.1948.tb01338.x
• Sidiroglou-Douskos, S., Misailovic, S., Hoffmann, H., & Rinard, M. (2011). Managing performance vs accuracy trade-offs with loop perforation. Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering (ESEC/FSE), 124–134. https://doi.org/10.1145/2025113.2025133
• Venkataramani, S., Ranjan, A., Roy, K., & Raghunathan, A. (2013). Security in approximate computing and approximate computing for security: Challenges and opportunities. Proceedings of the 2013 IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 85–90. https://doi.org/10.1109/ICCAD.2013.6691115
• Zhang, J., Jiang, Z., Han, J., & Lombardi, F. (2018). Privacy leakages in approximate adders. Proceedings of the 55th Annual Design Automation Conference (DAC). https://doi.org/10.1145/3195970.3196116
• Yan, L., Gao, X., Lu, L., Han, J., & Lombardi, F. (2019). Security threats in approximate computing systems. Proceedings of the Great Lakes Symposium on VLSI (GLSVLSI), 399–404. https://doi.org/10.1145/3299874.3319466
• Chippa, V. K., Mohapatra, D., Roy, K., & Raghunathan, A. (2013). On the (in)security of approximate computing synthesis. Proceedings of the 50th Annual Design Automation Conference (DAC), 1–9. https://doi.org/10.1145/2463209.2488876
• Hamming, R. W. (1950). Error detecting and error correcting codes. Bell System Technical Journal, 29(2), 147–160. https://doi.org/10.1002/j.1538-7305.1950.tb00463.x
• Sasan, A. (2022). Approximate computing: Techniques for reducing energy, performance, and accuracy tradeoffs. Springer.
• Venkatesan, R., Ye, Y., Raghunathan, A., & Chakradhar, S. T. (2018). Approximate circuits: Methodologies and applications. Springer.
Web Reference:
• Wikipedia contributors. (2024, April 15). Approximate computing. Wikipedia. https://en.wikipedia.org/wiki/Approximate_computing
