Accelerating error-tolerant applications with approximate function reuse

Abstract

Function reuse is a promising approach to accelerate single-threaded applications and exceed the limits of instruction-level parallelism. This approach exploits the observation that certain functions are executed several times with the same inputs, producing the same output repeatedly. Therefore, by saving these results once in a reuse table, it is possible to skip all subsequent calls with the same set of inputs, instead replacing it by a table look-up. However, the table tends to get very large due to the diversity of inputs, impacting negatively on access times, area (in case of hardware implementations) and power. In this work, we combine function reuse with approximation, exploiting the characteristic that some applications are naturally error-tolerant, to collapse similar table entries together – thereby compressing the table and increasing reuse rates. By using benchmarks from the AxBench suite, we show that precise function reuse achieves only very small reuse rates due to the vast diversity of inputs. However, by applying approximation, it is possible to trade less than 10% quality degradation for more than 50% reuse rate. • We introduce a novel approach for imprecise computing: approximative function reuse. • Our technique mitigates the major drawback of reuse: the size of the reuse table. • Compared to previous reuse techniques, our approach provides higher reuse rates, with minor impact on quality. • We analyze the tradeoff between quality output and reuse rate for several applications.