ACM Home Page
Please provide us with feedback. Feedback
Improving the ratio of memory operations to floating-point operations in loops
Full text PdfPdf (2.49 MB)
Source ACM Transactions on Programming Languages and Systems (TOPLAS) archive
Volume 16 ,  Issue 6  (November 1994) table of contents
Pages: 1768 - 1810  
Year of Publication: 1994
ISSN:0164-0925
Authors
Steve Carr  Michigan Technological Univ., Houghton
Ken Kennedy  Rice Univ., Houston, TX
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 6,   Downloads (12 Months): 54,   Citation Count: 43
Additional Information:

abstract   references   cited by   index terms   review   collaborative colleagues  

Tools and Actions: Request Permissions Request Permissions    Review this Article  
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/197320.197366
What is a DOI?

ABSTRACT

Over the past decade, microprocessor design strategies have focused on increasing the computational power on a single chip. Because computations often require more data from cache per floating-point operation than a machine can deliver and because operations are pipelined, idle computational cycles are common when scientific applications are executed. To overcome these bottlenecks, programmers have learned to use a coding style that ensures a better balance between memory references and floating-point operations. In our view, this is a step in the wrong direction because it makes programs more machine-specific. A programmer should not be required to write a new program version for each new machine; instead, the task of specializing a program to a target machine should be left to the compiler.But is our view practical? Can a sophisticated optimizing compiler obviate the need for the myriad of programming tricks that have found their way into practice to improve the performance of the memory hierarchy? In this paper we attempt to answer that question. To do so, we develop and evaluate techniques that automatically restructure program loops to achieve high performance on specific target architectures. These methods attempt to balance computation and memory accesses and seek to eliminate or reduce pipeline interlock. To do this, they estimate statically the balance between memory operations and floating-point operations for each loop in a particular program and use these estimates to determine whether to apply various loop transformations.Experiments with our automatic techniques show that integer-factor speedups are possible on kernels. Additionally, the estimate of the balance between memory operations and computation, and the application of the estimate are very accurate—experiments reveal little difference between the balance achieved by our automatic system that is made possible by hand optimization.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

 
1
 
2
ALLEN, F. AND COCKE, J. 1972. A catalogue of optimizing transformations. In Design and Opttmzzation of Compilers. Prentice-Hail, Englewood Cliffs, N.J., 1-30.
3
 
4
5
 
6
 
7
CALLAHAN, D., COOPER, K., HOOD, R., KENNEDY, K., AND TORCZON, L. 1987. ParaScope: A parallel programming environment. In Proceedings of the 1st International Conference on Supercomputing. Springer-Verlag, Berlin.
 
8
 
9
 
10
 
11
CHAITIN, G., AUSLANDER, M., CHANDBA, A., COCKE, J., HOPKINS, M., AND MARKSTEIN, P. 1981. Register allocation via coloring. Comput Lang. 6, 45-57.
12
13
14
 
15
16
 
17
 
18
KUCK, D., KUHN, R., LEASURE, B., AND WOLFE, M. 1984. The structure of an advanced retargetable vectorizer. In Supercomputers: Destgn and Apphcattons. IEEE Computer Society Press, Los Alamitos, Calif., 163-178
19
 
20
MEADOWS, L, NAKAMOTO, S., AND SCHUSTER, V 1992. A vectonzing, sot~ware pipelinmg campller for LIW and superscalar architectures In Proceedings of RISC '92.
 
21
22
23
24
 
25

CITED BY  43


REVIEW

"Max Hailperin : Reviewer"

A key result from Carr's 1992 dissertation is presented: a system for automatically choosing the unrolling factor to use in transforming loop nests using unroll-and-jam and scalar replacement. The goal is to alleviate memory-boundness without   more...