Advanced search
1 file | 364.21 KB

Refactoring intermediately executed code to reduce cache capacity misses

Author
Organization
Abstract
The growing memory wall requires that more attention is given to the data cache behavior of programs. In this paper, attention is given to the capacity misses i.e. the misses that occur because the cache size is smaller than the data footprint between the use and the reuse of the same data. The data footprint is measured with the reuse distance metric, by counting the distinct memory locations accessed between use and reuse. For reuse distances larger than the cache size, the associated code needs to be refactored in a way that reduces the reuse distance to below the cache size so that the capacity misses are eliminated. In a number of simple loops, the reuse distance can be calculated analytically. However, in most cases profiling is needed to pinpoint the areas where the program needs to be transformed for better data locality. This is achieved by the reuse distance visualizer, RDVIS, which shows the intermediately executed code for critical data reuses. In addition, another tool, SLO, annotates the source program with suggestions for locality ptimization. Both tools have been used to analyze and to refactor a number of SPEC2000 benchmark programs with very positive results.
Keywords
refactoring, basic block vectors, reuse distance, cache misses, least common ancestor function

Downloads

  • Beyls 2008 JILP 10 paper7.pdf
    • full text
    • |
    • open access
    • |
    • PDF
    • |
    • 364.21 KB

Citation

Please use this url to cite or link to this publication:

Chicago
Beyls, Kristof, and Erik D’Hollander. 2008. “Refactoring Intermediately Executed Code to Reduce Cache Capacity Misses.” The Journal of Instruction-level Parallelism 10.
APA
Beyls, Kristof, & D’Hollander, E. (2008). Refactoring intermediately executed code to reduce cache capacity misses. THE JOURNAL OF INSTRUCTION-LEVEL PARALLELISM, 10.
Vancouver
1.
Beyls K, D’Hollander E. Refactoring intermediately executed code to reduce cache capacity misses. THE JOURNAL OF INSTRUCTION-LEVEL PARALLELISM. 2008;10.
MLA
Beyls, Kristof, and Erik D’Hollander. “Refactoring Intermediately Executed Code to Reduce Cache Capacity Misses.” THE JOURNAL OF INSTRUCTION-LEVEL PARALLELISM 10 (2008): n. pag. Print.
@article{676267,
  abstract     = {The growing memory wall requires that more attention is given to the data cache behavior of programs. In this paper, attention is given to the capacity misses i.e. the misses that occur because the cache size is smaller than the data footprint between the use and the reuse of the same data. The data footprint is measured with the reuse distance metric, by counting the distinct memory locations accessed between use and reuse. For reuse distances larger than the cache size, the associated code needs to be refactored in a way that reduces the reuse distance to below the cache size so that the capacity misses are eliminated.   In a number of simple loops, the reuse distance can be calculated analytically. However, in most cases profiling is needed to pinpoint the areas where the program needs to be transformed for better data locality. This is achieved by the reuse distance visualizer, RDVIS, which shows the intermediately executed code for critical data reuses. In addition, another tool, SLO, annotates the source program with suggestions for locality ptimization. Both tools have been used to analyze and to refactor a number of SPEC2000 benchmark programs with very positive results.},
  author       = {Beyls, Kristof and D'Hollander, Erik},
  issn         = {1942-9525},
  journal      = {THE JOURNAL OF INSTRUCTION-LEVEL PARALLELISM},
  keyword      = {refactoring,basic block vectors,reuse distance,cache misses,least common ancestor function},
  language     = {eng},
  title        = {Refactoring intermediately executed code to reduce cache capacity misses},
  url          = {http://www.jilp.org/vol10/v10paper7.pdf},
  volume       = {10},
  year         = {2008},
}