Proc. of a conference on Functional programming languages and computer architecture
Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
Incremental computation via function caching
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An elimination algorithm for bidirectional data flow problems using edge placement
ACM Transactions on Programming Languages and Systems (TOPLAS)
Compiler transformations for high-performance computing
ACM Computing Surveys (CSUR)
Value locality and load value prediction
Proceedings of the seventh international conference on Architectural support for programming languages and operating systems
MICRO 30 Proceedings of the 30th annual ACM/IEEE international symposium on Microarchitecture
Complete removal of redundant expressions
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Caching function calls using precise dependencies
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
ICS '01 Proceedings of the 15th international conference on Supercomputing
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An architectural alternative to optimizing compilers
ASPLOS I Proceedings of the first international symposium on Architectural support for programming languages and operating systems
Exploring Sub-Block Value Reuse for Superscalar Processors
PACT '00 Proceedings of the 2000 International Conference on Parallel Architectures and Compilation Techniques
Improving processor performance through compiler-assisted block reuse
Improving processor performance through compiler-assisted block reuse
Caching Function Results: Faster Arithmetic by Avoiding Unnecessary Computation
Caching Function Results: Faster Arithmetic by Avoiding Unnecessary Computation
Dynamic reuse of subroutine results
Journal of Systems Architecture: the EUROMICRO Journal
Hi-index | 0.00 |
Value reuse technique eliminates the redundant evaluation of expressions, using the support of hardware at runtime to eliminate them. The potential performance of a value reuse mechanism not only depends on the number of instances it has eliminated, but as well as on the time spent in detecting the instance to be eliminated. In order to have better value reuse, we move from instruction level reuse to function reuse, so that one can detect more eliminative instances with reasonable effort. This removes the extra time spent on detecting the possibility of instruction execution elimination. The results of the mathematical library functions evaluated can be reused. Since they can be treated as instructions, i,e. functions which do not have side-effects with the application, one can eliminate the function call itself. In this paper, we propose a Technique to re-use the evaluated values for math library functions. Execution time is decreased up to 6%. Reduction in the number of calls due to instrumentation of code for function reuse for math library routines is up to 99% at a particular call-site in the application