Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Efficiency by Incrementalization: An Introduction
Higher-Order and Symbolic Computation
Eliminating redundancies in sum-of-product array computations
ICS '01 Proceedings of the 15th international conference on Supercomputing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Dynamic Programming via Static Incrementalization
Higher-Order and Symbolic Computation
Computational Divided Differencing and Divided-Difference Arithmetics
Higher-Order and Symbolic Computation
Dynamic Programming via Static Incrementalization
ESOP '99 Proceedings of the 8th European Symposium on Programming Languages and Systems
Address Code and Arithmetic Optimizations for Embedded Systems
ASP-DAC '02 Proceedings of the 2002 Asia and South Pacific Design Automation Conference
Automated Software Engineering Using Concurrent Class Machines
Proceedings of the 16th IEEE international conference on Automated software engineering
Hi-index | 0.00 |
An aggregate array computation is a loop that computes accumulated quantities over array elements. Such computations are common in programs that use arrays, and the array elements involved in such computations often overlap, especially across iterations of loops, resulting in significant redundancy in the overall computation. This paper presents a method and algorithms that eliminate such overlapping aggregate array redundancies and shows both analytical and experimental performance improvements. The method is based on incrementalization, \ie, updating the values of aggregate array computations from iteration to iteration rather than computing them from scratch in each iteration. This involves maintaining additional information not maintained in the original program. We reduce various analysis problems to solving inequality constraints on loop variables and array subscripts, and we apply results from work on array data dependence analysis. Incrementalizing aggregate array computations produces drastic program speedup compared to previous optimizations. Previous methods for loop optimizations of arrays do not perform incrementalization, and previous techniques for loop incrementalization do not handle arrays.