US5805863A - Memory pattern analysis tool for use in optimizing computer program code - Google Patents

Memory pattern analysis tool for use in optimizing computer program code Download PDF

Info

Publication number
US5805863A
US5805863A US08/579,418 US57941895A US5805863A US 5805863 A US5805863 A US 5805863A US 57941895 A US57941895 A US 57941895A US 5805863 A US5805863 A US 5805863A
Authority
US
United States
Prior art keywords
program code
loop
memory
conditions
optimization
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Expired - Fee Related
Application number
US08/579,418
Inventor
Po-Hua Chang
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Intel Corp
Original Assignee
Intel Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Intel Corp filed Critical Intel Corp
Priority to US08/579,418 priority Critical patent/US5805863A/en
Assigned to INTEL CORPORATION reassignment INTEL CORPORATION ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: CHANG, PO-HUA
Application granted granted Critical
Publication of US5805863A publication Critical patent/US5805863A/en
Anticipated expiration legal-status Critical
Expired - Fee Related legal-status Critical Current

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • G06F8/44Encoding
    • G06F8/443Optimisation
    • G06F8/4441Reducing the execution time required by the program code
    • G06F8/4442Reducing the number of cache misses; Data prefetching
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00Error detection; Error correction; Monitoring
    • G06F11/30Monitoring
    • G06F11/34Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
    • G06F11/3466Performance evaluation by tracing or monitoring

Definitions

  • the present invention pertains to the field of computer software. More particularly, the present invention relates to a memory pattern analysis tool for assisting in the optimization of computer program code.
  • Optimization generally refers to the process of improving computer program code by modifying the code to run faster, to use memory more efficiently, or both. Optimization is generally performed using two basic approaches: 1) code restructuring, and 2) data placement and restructuring.
  • code restructuring methods exist for improving the memory hierarchy performance of software, such as scalar replacement, loop interchange, loop distribution, loop fusion, loop blocking, unroll-and-jam, strip-mine-and preload, and strip-mine-and-interchange. These techniques can sometimes be combined to achieve an even higher level of performance.
  • data placement and restructuring techniques exist for improving memory hierarchy performance, such as data alignment in COMMON block, padding and aligning structures, placing scalar variables on the same cache block, and array merging.
  • a basic problem in optimizing software is determining which of the above optimization methods to apply to a given portion of code.
  • Certain compilers are available which will automatically select and apply various loop transformations in order to restructure program code.
  • the compilers often determine and apply only certain transformations that are possible for a portion of code, not the transformations that are best suited, or even appropriate, for that portion of code. Consequently, the resulting optimization may be less than optimal.
  • One reason for this deficiency is that the compilers do not have information describing the dynamic memory utilization of the program.
  • Cache simulators have been developed which generate certain dynamic information, such as the number of cache hits and misses.
  • cache simulators are limited to cache performance statistics, and the problem remains of determining which optimizations to apply.
  • the compilers do not focus on certain critical portions of the code that have a substantial impact on memory hierarchy performance, such as memory references which occur within loops. Hence, what is needed is a tool which overcomes these deficiencies, for assisting in the optimization of software.
  • a method of assisting optimization of computer program code including at least one memory reference is provided.
  • Performance data relating to the memory reference is computed during execution of the program code.
  • the performance data is applied to a number of sets of conditions, with each set of conditions corresponding to one of a number of optimization techniques. After determining if each set of conditions is satisfied, an output is generated, for each set of conditions that is satisfied, indicating that the corresponding optimization technique may be beneficial if applied to the program code.
  • FIG. 1 is a block diagram of a computer system in which the present invention is implemented.
  • FIG. 2 is a block diagram of a memory pattern analysis tool.
  • FIG. 3A is a flowchart showing steps for instrumenting, compiling, and linking a program to a memory pattern analysis tool.
  • FIG. 3B is a flowchart illustrating the step of executing an instrumented program.
  • the present invention includes a memory pattern analysis tool that indicates which of a number of possible memory optimizations may be helpful if applied to a particular sequence of program code.
  • the present invention is particularly useful in optimizing programs written in languages that are amenable to large numbers of loops, such as FORTRAN or C; however, the present invention is not limited to such languages.
  • the present invention includes method steps which, in the preferred embodiment, are embodied in computer software. These steps may be performed by a general-purpose processor programmed with instructions that cause the processor to perform the necessary steps. In alternative embodiments, the necessary steps may be performed by specific hardware components that contain hard-wired logic for performing the steps or any combination of programmed general-purpose computer components and customed hardware components.
  • FIG. 1 illustrates a computer system 1 in which the present invention is implemented.
  • the computer system 1 includes a central processing unit (CPU) 10 capable of performing instructions according to the present invention.
  • the CPU 10 is coupled to a main memory 12 and a cache memory 14 by a system bus 28.
  • a number of peripheral components 18-21 are coupled to a peripheral component interconnect (PCI) bus 26.
  • the PCI bus 26 is connected to the system bus 28 by a bus bridge 16.
  • the peripheral components 18-21 may include any of a number of commonly used input/output devices, such as a display monitor, a keyboard, a mouse or other cursor control device, and a magnetic disk drive, CD-ROM drive, or other mass storage device.
  • instructions according to the present invention may be stored in memory 12 or on a magnetic disk, CD-ROM, or other mass storage device accommodated by one of the peripheral components 18-21, or any combination of these devices.
  • the present invention includes a method for identifying which of a number of possible optimization techniques may be beneficial for a given sequence of computer program code. It is assumed for purposes of this description that a program to be optimized contains a number of loops, and that a number of instructions within those loops contain memory references.
  • a memory reference is defined herein as a reference made within an instruction to a location in memory, such that a load, store, or modify operation is performed within the CPU 10 when the instruction is executed.
  • the program to be optimized is initially instrumented by a compiler to cause certain predetermined information to be generated pertaining to each dynamic instance of a memory reference during execution of the program. Upon execution of the program, the trace is generated. From the trace, the loops in the program are identified.
  • a number of dynamic performance parameters are computed relating to the memory references occurring within that loop. These parameters include dynamic memory usage information and cache statistics. For each loop, these performance parameters are then applied to a number of sets of conditions. Each set of conditions is associated with a particular known memory optimization technique. A set of conditions forms the criteria for determining whether the corresponding optimization technique will likely be useful if applied to the program. An indication is generated, for each set of conditions that is satisfied, that the optimization corresponding to that set of conditions may be a beneficial. In addition, for each loop in the program, a list of the memory references contained within the loop is generated along with a listing of the computed performance parameters for each memory reference.
  • FIG. 2 provides a block diagram of the memory pattern analysis tool 32.
  • the tool 32 includes a cache simulator 34 that is logically coupled to a symbolic reference analyzer 36.
  • the tool 32 is embodied in the form of a library file which is linked to the program to be optimized prior to execution of the program.
  • the tool 32 receives as input a memory reference trace generated as the program is executed and outputs memory optimization suggestions and the performance parameters mentioned above.
  • the compiler first detects the memory references which are present in the source code (step 301).
  • the compiler instruments i.e., inserts additional procedure code into
  • the source code step 302
  • the compiler configures the program to generate, during execution, a trace comprising one record for every dynamic instance of a memory reference.
  • Each record includes the following information: 1) the instruction address of the instruction containing the memory reference; 2) the instruction type of the instruction containing the memory reference (i.e., load, store, or modify); 3) the memory address being accessed as a result of the memory reference; and 4) the location in the source code of the memory reference (file name, line number, and column number in which the memory reference appears).
  • the program is instrumented, the program is compiled (step 303) and linked with the tool 32, which is a library file (step 304), to produce an executable program.
  • the program is then executed (step 305) in conjunction with a data set, causing both the memory reference trace to be generated and the tool 32 to be invoked as the program is executed.
  • FIG. 3B is a flowchart illustrating the step of executing the program (step 305) in greater detail.
  • First the individual loops in the program are detected from the memory reference trace using a loop detection algorithm (step 310).
  • loop detection algorithm In the preferred embodiment, loop nests of up to two levels will be detected.
  • Various loop detection algorithms are known and are suitable for this task.
  • a number of performance parameters are computed for each loop in the program (step 311). These performance parameters include cache statistics and other parameters which will be described below.
  • the cache statistics are generated by the cache simulator 34 portion of the tool 32, while the other parameters are computed by the symbolic reference analyzer 36 portion.
  • Various cache simulators are currently known and can be used to generate the cache statistics.
  • An example of a suitable cache simulator is the CPROF program, developed at the University of Wisconsin.
  • a number of sets of conditions are provided, with each set of conditions being associated with a different known optimization technique.
  • Each set of conditions represents criteria for determining whether the corresponding optimization technique will likely be useful if applied to the program.
  • the performance parameters are applied to each set of conditions (step 312).
  • the tool 32 outputs a list including the memory references contained within the loop, certain ones of the performance parameters associated with each memory reference in the loop, and any optimizations for which the corresponding set of conditions has been satisfied (step 313).
  • the tool 32 computes the performance parameters for each loop and stores these parameters in a data structure.
  • the data structure has the following information and organization:
  • a "sub-loop” is a loop contained within a loop.
  • a “nearby loop” is a loop that is located within a predetermined number of lines of source code of another loop.
  • a "list of references” is a list of the memory references contained within a loop.
  • n is the number of times a loop is iterated.
  • min is the minimum memory address that is made from a reference point (i.e., from the point in the program at which a reference occurs).
  • maximum is the maximum memory address that is made from a reference point.
  • x -- stride is the change in memory address per inner loop iteration, divided by the reference size.
  • the reference size is the number of bytes of memory occupied by the reference, which depends upon the data type of the reference. Dividing by the reference size puts x -- stride in terms of array elements, as opposed to memory address space.
  • x -- is -- constant -- stride is a Boolean variable which is TRUE only if x -- stride is a constant.
  • y -- stride is the change in memory address per outer loop iteration, divided by the reference size.
  • the reference size is the number of bytes of memory occupied by the reference, which depends upon the data type of the reference. Dividing by the reference size puts x -- stride in terms of array elements, as opposed to memory address space.
  • y -- is -- constant -- stride is a Boolean variable which is TRUE only if y -- stride is constant.
  • x -- length is the largest memory address difference of a reference in a loop invocation, divided by the reference size (to put X-length in terms of array elements).
  • "#cache -- hits" is the number of cache hits. This parameter is computed buy the cache simulator 34.
  • a "source reference” is a reference of a relation which is read in performing a memory operation.
  • a "destination reference” is a reference of a relation which is written in performing a memory operation.
  • "same -- x -- stride -- occurrences" is the number of times that two references have made the same change in x -- stride.
  • x -- difference is the constant (if defined) difference between memory addresses of two references.
  • conditions are provided for the following code restructuring optimizations: 1) scalar replacement, 2) loop interchange, 3) loop distribution, 4) loop fusion 5) loop blocking, 6) unroll-and-jam, 7) strip-mine-and-preload, and 8) strip-mine-and-interchange.
  • code restructuring optimizations 1) scalar replacement, 2) loop interchange, 3) loop distribution, 4) loop fusion 5) loop blocking, 6) unroll-and-jam, 7) strip-mine-and-preload, and 8) strip-mine-and-interchange.
  • a combination of one or more of the preceding transformations may be recommended. Loops having rectangular, triangular, and trapezoidal-shaped iteration space will be focused on for evaluating loop transformations.
  • conditions are provided corresponding to the following data placement and restructuring optimizations: 1) data alignment and COMMON block, 2) padding and aligning structures, and 3) array merging.
  • x -- difference/opr -- size is a small constant ⁇ >0
  • x -- stride and y-stride apply to a given reference in a loop, while x -- stride' and y-stride' apply to a different reference in the loop;
  • Opera -- size refers to the operand size
  • a small constant depends on the number of registers that are available and, in the preferred embodiment, is a constant less than or equal to four.
  • the tool 34 will generate an output indicating that scalar replacement may be a beneficial transformation for the subject loop.
  • the tool 34 will generate an output indicating that scalar replacement may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that loop interchange followed by scalar replacement may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that a combination of unroll-and-jam and scalar replacement may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that loop interchange may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that loop distribution may be a beneficial transformation for the subject loop: the loop has a number of non-interfering references that have high conflict misses (i.e., a miss ratio greater than 10%).
  • One way of determining the existence of interfering references is to determine whether there is overlap between the two references, i.e., whether the highest address accessed by one reference is lower than the lowest address accessed by the other reference.
  • overlap is only an indication of the possibility of interfering references and not an absolute test.
  • a example of a function for computing interfering references based on overlap is as follows:
  • ref1 is a first reference in a loop
  • ref2 is a second reference in the loop
  • ref1.min is the lowest address accessed by the first reference
  • ref1.max is the highest address accessed by the first reference
  • ref2.min is the lowest address accessed by the second reference
  • ref2.max is the highest address accessed by the second reference.
  • any nearby loops to the subject loop are detected before applying the conditions. If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop fusion may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that loop blocking may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that loop unroll-and-jam may be a beneficial transformation for the subject loop:
  • the tool 34 will generate an output indicating that strip-mine-and-preload may be a beneficial transformation for the subject loop:
  • x -- length is large (i.e., larger than the size of the cache).
  • the tool 34 will generate an output indicating that strip-mine-and-interchange may be a beneficial transformation for the subject loop:
  • x -- length is large (i.e., larger than the size of the cache),
  • the tool 34 will generate an output indicating that data alignment in COMMON block may be beneficial:
  • the tool 34 will generate an output indicating that padding and aligning structures may be beneficial: There are references that have large numbers of non-aligned accesses. What constitutes a "high number" may be determined according to the user's needs.
  • the tool 34 will generate an output indicating that array merging may be beneficial:
  • the tool 32 For each loop, after all sets of conditions have been applied, the tool 32 outputs a list including the memory references contained within the loop, certain ones of the performance parameters associated with each memory reference in the loop, such as cache statistics, and any optimizations for which the corresponding set of conditions has been satisfied.
  • the output generated for each loop has the following information and format:

Abstract

A method of facilitating optimization of computer program code. The code includes instructions for performing a plurality of loops, with each loop including at least one memory reference. The program code is instrumented to cause a memory reference trace to be generated when the program code is executed. The loops in the program code are identified from the trace. For each loop, a plurality of performance parameters relating to the memory references contained within the loop, including dynamic memory usage information and cache statistics, are computed based on the information in the trace. The performance parameters are then applied to a plurality of sets of conditions. Each set of conditions corresponds to one of a plurality of known optimization techniques to determine whether each set of conditions is satisfied for each loop. The optimization techniques include loop transformations and data restructuring techniques. For each set of conditions that is satisfied for a particular loop, an output is generated identifying the optimization technique which corresponds to that set of conditions as a suggested optimization for the loop.

Description

FIELD OF THE INVENTION
The present invention pertains to the field of computer software. More particularly, the present invention relates to a memory pattern analysis tool for assisting in the optimization of computer program code.
BACKGROUND OF THE INVENTION
An important aspect of designing computer software is optimization. Optimization generally refers to the process of improving computer program code by modifying the code to run faster, to use memory more efficiently, or both. Optimization is generally performed using two basic approaches: 1) code restructuring, and 2) data placement and restructuring. Several well-known code restructuring methods exist for improving the memory hierarchy performance of software, such as scalar replacement, loop interchange, loop distribution, loop fusion, loop blocking, unroll-and-jam, strip-mine-and preload, and strip-mine-and-interchange. These techniques can sometimes be combined to achieve an even higher level of performance. In addition, several well-known data placement and restructuring techniques exist for improving memory hierarchy performance, such as data alignment in COMMON block, padding and aligning structures, placing scalar variables on the same cache block, and array merging.
Existing technology for optimizing software has certain disadvantages, however. For example, a basic problem in optimizing software is determining which of the above optimization methods to apply to a given portion of code. Certain compilers are available which will automatically select and apply various loop transformations in order to restructure program code. However, in so doing, the compilers often determine and apply only certain transformations that are possible for a portion of code, not the transformations that are best suited, or even appropriate, for that portion of code. Consequently, the resulting optimization may be less than optimal. One reason for this deficiency is that the compilers do not have information describing the dynamic memory utilization of the program. Cache simulators have been developed which generate certain dynamic information, such as the number of cache hits and misses. However, cache simulators are limited to cache performance statistics, and the problem remains of determining which optimizations to apply. Further, the compilers do not focus on certain critical portions of the code that have a substantial impact on memory hierarchy performance, such as memory references which occur within loops. Hence, what is needed is a tool which overcomes these deficiencies, for assisting in the optimization of software.
SUMMARY OF THE INVENTION
A method of assisting optimization of computer program code including at least one memory reference is provided. Performance data relating to the memory reference is computed during execution of the program code. The performance data is applied to a number of sets of conditions, with each set of conditions corresponding to one of a number of optimization techniques. After determining if each set of conditions is satisfied, an output is generated, for each set of conditions that is satisfied, indicating that the corresponding optimization technique may be beneficial if applied to the program code.
Other features of the present invention will be apparent from the accompanying drawings and from the detailed description which follows.
BRIEF DESCRIPTION OF THE DRAWINGS
The present invention is illustrated by way of example and not limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which:
FIG. 1 is a block diagram of a computer system in which the present invention is implemented.
FIG. 2 is a block diagram of a memory pattern analysis tool.
FIG. 3A is a flowchart showing steps for instrumenting, compiling, and linking a program to a memory pattern analysis tool.
FIG. 3B is a flowchart illustrating the step of executing an instrumented program.
DETAILED DESCRIPTION
A method of assisting optimization of computer program code is described. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be evident, however, to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.
The present invention includes a memory pattern analysis tool that indicates which of a number of possible memory optimizations may be helpful if applied to a particular sequence of program code. The present invention is particularly useful in optimizing programs written in languages that are amenable to large numbers of loops, such as FORTRAN or C; however, the present invention is not limited to such languages.
The present invention includes method steps which, in the preferred embodiment, are embodied in computer software. These steps may be performed by a general-purpose processor programmed with instructions that cause the processor to perform the necessary steps. In alternative embodiments, the necessary steps may be performed by specific hardware components that contain hard-wired logic for performing the steps or any combination of programmed general-purpose computer components and customed hardware components.
FIG. 1 illustrates a computer system 1 in which the present invention is implemented. The computer system 1 includes a central processing unit (CPU) 10 capable of performing instructions according to the present invention. The CPU 10 is coupled to a main memory 12 and a cache memory 14 by a system bus 28. A number of peripheral components 18-21 are coupled to a peripheral component interconnect (PCI) bus 26. The PCI bus 26 is connected to the system bus 28 by a bus bridge 16. The peripheral components 18-21 may include any of a number of commonly used input/output devices, such as a display monitor, a keyboard, a mouse or other cursor control device, and a magnetic disk drive, CD-ROM drive, or other mass storage device. In the preferred embodiment, instructions according to the present invention may be stored in memory 12 or on a magnetic disk, CD-ROM, or other mass storage device accommodated by one of the peripheral components 18-21, or any combination of these devices.
The present invention includes a method for identifying which of a number of possible optimization techniques may be beneficial for a given sequence of computer program code. It is assumed for purposes of this description that a program to be optimized contains a number of loops, and that a number of instructions within those loops contain memory references. A memory reference is defined herein as a reference made within an instruction to a location in memory, such that a load, store, or modify operation is performed within the CPU 10 when the instruction is executed. As will be described below in detail, the program to be optimized is initially instrumented by a compiler to cause certain predetermined information to be generated pertaining to each dynamic instance of a memory reference during execution of the program. Upon execution of the program, the trace is generated. From the trace, the loops in the program are identified. For each loop, a number of dynamic performance parameters are computed relating to the memory references occurring within that loop. These parameters include dynamic memory usage information and cache statistics. For each loop, these performance parameters are then applied to a number of sets of conditions. Each set of conditions is associated with a particular known memory optimization technique. A set of conditions forms the criteria for determining whether the corresponding optimization technique will likely be useful if applied to the program. An indication is generated, for each set of conditions that is satisfied, that the optimization corresponding to that set of conditions may be a beneficial. In addition, for each loop in the program, a list of the memory references contained within the loop is generated along with a listing of the computed performance parameters for each memory reference.
FIG. 2 provides a block diagram of the memory pattern analysis tool 32. The tool 32 includes a cache simulator 34 that is logically coupled to a symbolic reference analyzer 36. In the preferred embodiment, the tool 32 is embodied in the form of a library file which is linked to the program to be optimized prior to execution of the program. During execution of the program, the tool 32 receives as input a memory reference trace generated as the program is executed and outputs memory optimization suggestions and the performance parameters mentioned above.
Associated with the program to be optimized is a compiler for converting the program to object code. Referring now to FIG. 3A, the compiler first detects the memory references which are present in the source code (step 301). Next, the compiler instruments (i.e., inserts additional procedure code into) the source code (step 302) to configure the source code to generate a memory reference trace during execution. Specifically, the compiler configures the program to generate, during execution, a trace comprising one record for every dynamic instance of a memory reference. Each record includes the following information: 1) the instruction address of the instruction containing the memory reference; 2) the instruction type of the instruction containing the memory reference (i.e., load, store, or modify); 3) the memory address being accessed as a result of the memory reference; and 4) the location in the source code of the memory reference (file name, line number, and column number in which the memory reference appears). After the program is instrumented, the program is compiled (step 303) and linked with the tool 32, which is a library file (step 304), to produce an executable program. The program is then executed (step 305) in conjunction with a data set, causing both the memory reference trace to be generated and the tool 32 to be invoked as the program is executed.
FIG. 3B is a flowchart illustrating the step of executing the program (step 305) in greater detail. First the individual loops in the program are detected from the memory reference trace using a loop detection algorithm (step 310). In the preferred embodiment, loop nests of up to two levels will be detected. Various loop detection algorithms are known and are suitable for this task.
After detection of the loops, a number of performance parameters are computed for each loop in the program (step 311). These performance parameters include cache statistics and other parameters which will be described below. The cache statistics are generated by the cache simulator 34 portion of the tool 32, while the other parameters are computed by the symbolic reference analyzer 36 portion. Various cache simulators are currently known and can be used to generate the cache statistics. An example of a suitable cache simulator is the CPROF program, developed at the University of Wisconsin.
A number of sets of conditions are provided, with each set of conditions being associated with a different known optimization technique. Each set of conditions represents criteria for determining whether the corresponding optimization technique will likely be useful if applied to the program. For each loop, the performance parameters are applied to each set of conditions (step 312). The tool 32 outputs a list including the memory references contained within the loop, certain ones of the performance parameters associated with each memory reference in the loop, and any optimizations for which the corresponding set of conditions has been satisfied (step 313).
Performance Parameters
During execution of the program, the tool 32 computes the performance parameters for each loop and stores these parameters in a data structure. The data structure has the following information and organization:
______________________________________                                    
loop                                                                      
-> a list of sub-loops                                                    
-> a list of nearby loops                                                 
-> a list of references                                                   
-> n                                                                      
reference (maintained for each reference in the loop)                     
-> min                                                                    
-> max                                                                    
-> x.sub.-- stride                                                        
-> x.sub.-- is.sub.-- constant.sub.-- stride                              
-> y.sub.-- stride                                                        
-> y.sub.-- is.sub.-- constant.sub.-- stride                              
-> x.sub.-- length                                                        
-> #cache.sub.-- misses                                                   
-> #cache.sub.-- hits                                                     
-> #non.sub.-- aligned.sub.-- accesses                                    
-> a list of relations                                                    
relation                                                                  
-> source reference                                                       
-> destination reference                                                  
-> same.sub.-- x.sub.-- stride.sub.-- occurrences                         
-> x.sub.-- difference                                                    
______________________________________                                    
The terms set forth in the data structure above are defined as follows:
A "sub-loop" is a loop contained within a loop.
A "nearby loop" is a loop that is located within a predetermined number of lines of source code of another loop.
A "list of references" is a list of the memory references contained within a loop.
"n" is the number of times a loop is iterated.
"min" is the minimum memory address that is made from a reference point (i.e., from the point in the program at which a reference occurs).
"max" is the maximum memory address that is made from a reference point.
"x-- stride" is the change in memory address per inner loop iteration, divided by the reference size. The reference size is the number of bytes of memory occupied by the reference, which depends upon the data type of the reference. Dividing by the reference size puts x-- stride in terms of array elements, as opposed to memory address space.
"x-- is-- constant-- stride" is a Boolean variable which is TRUE only if x-- stride is a constant.
"y-- stride" is the change in memory address per outer loop iteration, divided by the reference size. As with X-- stride, the reference size is the number of bytes of memory occupied by the reference, which depends upon the data type of the reference. Dividing by the reference size puts x-- stride in terms of array elements, as opposed to memory address space.
"y-- is-- constant-- stride" is a Boolean variable which is TRUE only if y-- stride is constant.
"x-- length" is the largest memory address difference of a reference in a loop invocation, divided by the reference size (to put X-length in terms of array elements).
"#cache-- misses" is the number of cache misses. This parameter is computed buy the cache simulator 34.
"#cache-- hits" is the number of cache hits. This parameter is computed buy the cache simulator 34.
"#non-- aligned-- accesses" is the number of non-aligned accesses that are made from the reference.
A "relation" is two references that appear in the same loop and have made the same change in x-- stride.
A "source reference" is a reference of a relation which is read in performing a memory operation.
A "destination reference" is a reference of a relation which is written in performing a memory operation.
"same-- x-- stride-- occurrences" is the number of times that two references have made the same change in x-- stride.
"x-- difference" is the constant (if defined) difference between memory addresses of two references.
Optimizations
In the preferred embodiment, conditions are provided for the following code restructuring optimizations: 1) scalar replacement, 2) loop interchange, 3) loop distribution, 4) loop fusion 5) loop blocking, 6) unroll-and-jam, 7) strip-mine-and-preload, and 8) strip-mine-and-interchange. In certain cases, a combination of one or more of the preceding transformations may be recommended. Loops having rectangular, triangular, and trapezoidal-shaped iteration space will be focused on for evaluating loop transformations. In addition, conditions are provided corresponding to the following data placement and restructuring optimizations: 1) data alignment and COMMON block, 2) padding and aligning structures, and 3) array merging.
1. Scalar Replacement
Two scenarios are considered for scalar replacement: 1) loops having loop-dependent dependencies, and 2) loops having loop-independent dependencies. The following code is an example of a loop-dependent dependency: ##EQU1##
The following set of conditions applies to loop-dependent dependencies:
(1) There are no non-constant stride references in the loop, and
(2) There are references in the loop such that:
a) x-- stride=1, x-- stride'=1,
b) x-- difference/opr-- size is a small constant <>0, and
c) y-- stride=y-- stride'.
In the above set of conditions, and in each of the following sets of conditions, the following clarifications apply:
x-- stride and y-stride apply to a given reference in a loop, while x-- stride' and y-stride' apply to a different reference in the loop;
opr-- size refers to the operand size; and
"a small constant" depends on the number of registers that are available and, in the preferred embodiment, is a constant less than or equal to four.
Hence, if the above conditions are satisfied, then the tool 34 will generate an output indicating that scalar replacement may be a beneficial transformation for the subject loop.
The following is an example of scalar replacement with loop-independent dependencies. ##EQU2##
If the following conditions are satisfied in the case of loop-independent dependences, then the tool 34 will generate an output indicating that scalar replacement may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references in the loop, and
(2) There are references in the loop such that:
a) x-- stride'=x-- stride=0,
b) y-- stride'=y-- stride <>0, and
c) x-- difference/opr-- size=y-- stride * a small constant.
The following is an example of loop interchange and scalar replacement: ##EQU3##
If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop interchange followed by scalar replacement may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride accesses in the loop, and
(2) There is at least one reference such that:
a) x-- stride=small constant <>0, and
b) y-- stride=0,
and
(3) There is no reference in the loop such that:
a) x-- stride=1, and
a) y-- stride=n
The following is an example of unroll-and-jam and scalar replacement: ##EQU4##
If the following conditions are satisfied, then the tool 34 will generate an output indicating that a combination of unroll-and-jam and scalar replacement may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references, in the loop, and
(2) There are pair-wise references such that:
a) x-- stride=x-- stride',
b) y-- stride=y-- stride'=a constant <>0, and
c) x-- difference/opr-- size=(y-- stride * a small constant) <>0
2. Loop Interchange
If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop interchange may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references in the loop, and
(2) There is at least one reference such that:
a) #cache-- misses is high
b) y-- stride=1,
c) x-- stride=constant,
d) x-- stride <>0, and
e) x-- stride <>1.
3. Loop Distribution
If the following condition is satisfied, then the tool 34 will generate an output indicating that loop distribution may be a beneficial transformation for the subject loop: the loop has a number of non-interfering references that have high conflict misses (i.e., a miss ratio greater than 10%).
References "interfere" when the accessing of an array element of one reference causes a value of the other reference to be overwritten. One way of determining the existence of interfering references is to determine whether there is overlap between the two references, i.e., whether the highest address accessed by one reference is lower than the lowest address accessed by the other reference. However, it should be appreciated that overlap is only an indication of the possibility of interfering references and not an absolute test. A example of a function for computing interfering references based on overlap is as follows:
______________________________________                                    
Interfere(ref1, ref2) {                                                   
   if (no.sub.-- overlap(ref1.min, ref1.max, ref2.min, ref2.max))         
      return FALSE;                                                       
   return TRUE;                                                           
   }                                                                      
______________________________________                                    
where:
ref1 is a first reference in a loop,
ref2 is a second reference in the loop,
ref1.min is the lowest address accessed by the first reference,
ref1.max is the highest address accessed by the first reference,
ref2.min is the lowest address accessed by the second reference, and
ref2.max is the highest address accessed by the second reference.
It should be appreciated that other functions for computing interfering references may also be used.
4. Loop Fusion
The following is an example of loop fusion:
______________________________________                                    
for (i=0; i<N; i++)                                                       
   for (j=0; j<N; j++)                                                    
      a(i,j) = 1/b(i,j) * c(i,j);                                         
for (i=0; i<N; i++)                                                       
   for (j=0; j<N; j++)                                                    
      d(i,j) = a(i,j) + c(i,j);                                           
becomes                                                                   
for (i=0; i<N; i++)                                                       
   for (j=0; j<N; j++) {                                                  
      a(i,j) = 1/b(i,j) * c(i,j);                                         
      d(i,j) = a(i,j) = c(i,j);                                           
______________________________________                                    
For loop fusion, any nearby loops to the subject loop are detected before applying the conditions. If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop fusion may be a beneficial transformation for the subject loop:
(1) the subject loop and the nearby loop are of equal length (n is the same for the two loops), and
(2) there are references in different loops that exhibit locality, i.e.:
a) x-- stride'=x-- stride <>0
b) y-- stride'=y-- stride, and
c) overlap(ref1, ref2),
where "overlap" is defined above with respect to loop fusion.
5. Loop Blocking
The following is an example of loop blocking:
______________________________________                                    
do 110 J = 1, M                                                           
do 110 K = 1, N                                                           
do 110 I = 1, L                                                           
         C(I,K) = C(I,K) + A(I,J) * B(J,K)                                
110 continue                                                              
becomes                                                                   
do 110 J = 1, M, 4                                                        
do 110K = 1, N                                                            
       do 110 I = 1, L                                                    
        C(I,K) = C(I,K) +                                                 
           A(I,J) * B(J, K) +                                             
           A(I, J+1) * B(J+1, K)+                                         
           A(I, J+2) * B(J+2,K) +                                         
           A(I,J+3) * B(J+3, K)                                           
110 continue                                                              
______________________________________                                    
If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop blocking may be a beneficial transformation for the subject loop:
There is at least one reference for which:
a) x-- stride=0, and
b) y-- stride=n * a small constant <>0
or,
1) There are no non-constant stride references, and
2) There is at least one reference such that:
a) x-- stride=1,
b) y-- stride=(n * a small constant),
c) x-- length is large,
d) #cache-- miss rate is high,
e) x-- stride'=x-- stride,
f) y-- stride'=y-- stride,
g) x-- difference/opr-- size=y-- stride * a small constant <>0, and
h) overlap(ref1, ref2).
6. Unroll-and-jam
If the following conditions are satisfied, then the tool 34 will generate an output indicating that loop unroll-and-jam may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references in the loop, and
(2) There is a reference such that:
a) x-- stride=1,
b) y-- stride=0, and
c) the reference is in a loop nest of depth>1,
or,
1) There are no non-constant stride references in the loop, and
2) there are pair-wise references such that:
a) x-- difference/opr-- size=y-- stride * a small constant <>0,
b) x-- stride'=x-- stride, and
c) y-- stride'=y-- stride=(n * a small constant).
7. Strip-mine-and-preload
If the following conditions are satisfied, then the tool 34 will generate an output indicating that strip-mine-and-preload may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references in the loop,
(2) There is a small number of references (e.g., less than or equal to four), and
(3) for all references in the loop:
a) x-- stride=1, and
b) x-- length is large (i.e., larger than the size of the cache).
8. Strip -mine-and-interchange
If the following conditions are satisfied, then the tool 34 will generate an output indicating that strip-mine-and-interchange may be a beneficial transformation for the subject loop:
(1) There are no non-constant stride references in the loop,
(2) There is a small number of references in the loop, and
(3) For all references:
a) x-- stride=1,
b) x-- length is large (i.e., larger than the size of the cache), and
c) y-- stride=0 or n.
9. Data Alignment in COMMON Block
If the following conditions are satisfied, then the tool 34 will generate an output indicating that data alignment in COMMON block may be beneficial:
There are pair-wise references that:
a) x-- difference <>0, and
b) remainder ((x-- difference/opr-- size)/CACHE-- SIZE)=0
or small constant,
c) x-- stride=x-- stride'=1,
d) y-- stride=y-- stride',
e) x-- length is large,
f) x-- length' is large, and
g) there is a high cache miss ratio in the loop.
10. Padding and Aligning Structures
If the following condition is satisfied, then the tool 34 will generate an output indicating that padding and aligning structures may be beneficial: There are references that have large numbers of non-aligned accesses. What constitutes a "high number" may be determined according to the user's needs.
11. Array Merging
If the following conditions are satisfied, then the tool 34 will generate an output indicating that array merging may be beneficial:
In an inner loop, there are pair-wise references that:
(1) the last change in x-- stride does not equal 1, and
(2) the last change in x-- stride equals the last change in x-- stride',
(3) rel->same-- x-- stride-- occurrences/total>0.8, where total=#cache-- hits+#cache-- misses, and
(4) x-- stride <>0, x-- stride <>1.
Output
For each loop, after all sets of conditions have been applied, the tool 32 outputs a list including the memory references contained within the loop, certain ones of the performance parameters associated with each memory reference in the loop, such as cache statistics, and any optimizations for which the corresponding set of conditions has been satisfied. In one embodiment, the output generated for each loop has the following information and format:
______________________________________                                    
  LOOP loop-number!                                                       
reference.sub.-- name(memory instruction address) source file             
name, function name, line number, column number!                          
MIN=min                                                                   
MAX=max                                                                   
X.sub.-- STRIDE=x.sub.-- stride                                           
NUM.sub.-- CACHE MISSES=#cache.sub.-- misses                              
NUM.sub.-- CACHE HITS=#cache.sub.-- hits                                  
NUM.sub.-- NON.sub.-- ALIGNED ACCESSES=#non.sub.-- aligned.sub.--         
accesses                                                                  
reference.sub.-- name(memory instruction address) source file             
name, function name, line number, column number!                          
______________________________________                                    
RECOMMENDED POTENTIAL LOOP TRANSFORMATIONS
list of optimization techniques for which conditions have been met.!
Thus, an exemplary output might appear as follows:
 ______________________________________                                    
LOOP 1!                                                                   
reference1(1638353829,541803) example.c, main, 8, 10!                     
MIN=138671840                                                             
MAX=138712768                                                             
X.sub.-- STRIDE=8                                                         
NUM.sub.-- CACHE MISSES=1280                                              
NUM.sub.-- CACHE HITS=0                                                   
NUM.sub.-- NON.sub.-- ALIGNED ACCESSES=0                                  
reference2(163833829,534401) example.c, main, 8, 14!                      
MIN=138712800                                                             
MAX=138753728                                                             
X.sub.-- STRIDE=8                                                         
NUM.sub.-- CACHE MISSES=1280                                              
NUM.sub.-- CACHE HITS=0                                                   
NUM.sub.-- NON.sub.-- ALIGNED ACCESSES=0                                  
RECOMMENDED POTENTIAL LOOP TRANSFORMATIONS:                               
array merging of references                                               
(example.c, main, 8, 10) and (example.c, main, 8, 14)                     
______________________________________                                    
Note that, although only certain performance parameters such as cache statistics are output for each reference in the exemplary embodiment, all performance parameters or different selected performance parameters may be output in other embodiments, according to the user's needs.
Thus, a method of assisting optimization of computer program code has been described. Although the present invention has been described with reference to specific exemplary embodiments, it will be evident that various modifications and changes may be made to these embodiments without departing from the broader spirit and scope of the invention as set forth in the claims. Accordingly, the specification and drawings are to be regarded in an illustrative rather than a restrictive sense.

Claims (38)

What is claimed is:
1. A method of facilitating optimization of computer program code, the method comprising the steps of:
applying performance data relating to execution of the program code to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, to determine whether each set of conditions is satisfied; and
for each set of conditions that is satisfied, generating an output identifying the corresponding optimization technique, said generating being independent of performance of said corresponding optimization technique.
2. A method according to claim 1, wherein the program code includes at least one memory reference, the method further comprising the step of generating the performance data, the performance data relating to the at least one memory reference.
3. A method according to claim 2, wherein the program code includes at least one loop, and wherein the step of generating the performance data comprises the step of generating performance parameters for each loop in the program code.
4. A method according to claim 3, further comprising the step of identifying each loop in the program code.
5. A method according to claim 3, wherein the step of generating performance parameters comprises the step of generating data representing dynamic memory access characteristics associated with the at least one memory reference.
6. A method according to claim 5, further comprising the step of simulating a cache memory to generate cache miss information, wherein the performance parameters further comprise cache miss information.
7. A method according to claim 1, wherein the program code includes at least one memory reference the method further comprising the step of providing a memory reference trace corresponding to an execution of the program code, the trace including data relating to each dynamic instance of the at least one memory reference during the execution of the program code.
8. A method according to claim 7, wherein the execution data comprises an instruction address, an instruction type, a memory address, and a location in the program code.
9. A method according to claim 7, further comprising the step of modifying the program code to cause the memory reference trace to be generated when the program code is executed.
10. A method according to claim 7, wherein the step of providing comprises the step of executing the program code to generate the memory reference trace.
11. A method according to claim 3, wherein the optimization technique is a loop transformation.
12. A machine-implemented method of identifying optimizations for computer program code, the code including instructions representing a plurality of loops, each loop including at least one memory reference, the method comprising the steps of:
instrumenting the program code to cause a memory reference trace to be generated when the program code is executed, the trace to include information relating to each dynamic instance of said at least one memory reference during execution of the program code;
executing the instrumented program code to generate the trace;
identifying the loops in the program code from the trace;
computing, for each loop, a plurality of performance parameters relating to the memory references contained within said loop based on the information on each said memory reference;
applying the performance parameters to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, to determine whether each set of conditions is satisfied for each loop; and
for each set of conditions that is satisfied for a particular loop, outputting an indication identifying the optimization technique corresponding to said set.
13. A method according to claim 12, wherein the step of computing, for each loop, a plurality of performance parameters comprises the step of computing parameters representing dynamic memory usage characteristics associated with each memory reference.
14. A method according to claim 13, further comprising the step of simulating a cache memory to generate cache miss statistics, wherein the performance parameters further comprise cache miss statistics.
15. A computer system configured to facilitate memory optimization of a first sequence of computer program instructions, the first sequence of computer program instructions including one or more loops, each of the loops including one or more memory references, the computer system comprising:
a processor; and
a memory coupled to the processor, the memory having stored therein a second sequence of computer program instructions for configuring the processor to receive and use the memory reference trace to compute, for each memory reference, a plurality of performance parameters associated with execution of the first sequence of computer program instructions, the second sequence of computer program instructions further for configuring the processor to apply the performance parameters to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, the second sequence of computer program instructions further for configuring the processor to output an indication, when one of the sets of conditions is satisfied, identifying the corresponding optimization technique as a recommended optimization technique wherein the outputting of the recommendation is independent of performance of the optimization technique.
16. A computer system according to claim 15, wherein the memory reference trace includes, for each memory reference, an instruction address, an instruction type, a memory address, and a source location.
17. A computer system according to claim 15, wherein the second sequence of computer program instructions is further for configuring the processor to simulate a cache memory and to compute cache performance parameters for the code.
18. A device for facilitating memory optimization of computer code, the code including one or more loops, each of the loops including one or more memory references, the apparatus comprising:
means for computing a plurality of performance parameters relating to the memory references during execution of the program code;
means for applying the performance parameters to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, to determine whether each set of conditions is satisfied; and
means for generating an output, for each set of conditions that is satisfied, identifying the corresponding optimization technique as a recommended optimization such that said identifying is independent of performance of said optimization technique.
19. A device according to claim 18, wherein the program code includes at least one loop, and wherein the means for computing performance data comprises means for computing a plurality of performance parameters for each loop.
20. A device according to claim 19, further comprising means for identifying each loop in the program code.
21. A device according to claim 18, wherein the performance parameters comprise parameters for indicating dynamic memory access characteristics associated with each memory reference.
22. A device according to claim 18, wherein the performance parameters further comprise cache miss information.
23. A device according to claim 18, further comprising means for providing a memory reference trace corresponding to an execution of the program code, the trace including data relating to each dynamic instance of a memory reference during the execution of the program code.
24. A device according to claim 23, wherein the data comprises an instruction address, an instruction type, a memory address, and a location in the program code.
25. A device according to claim 23, further comprising means for modifying the program code to cause the memory reference trace to be generated when the program code is executed.
26. A device according to claim 25, wherein the means for providing comprises means for executing the program code to generate the memory reference trace.
27. A program storage device readable by a machine, the storage device tangibly embodying a sequence of instructions executable by the machine to perform method steps for assisting optimization of computer program code, wherein the program code may include a plurality of memory references, the method steps comprising the steps of:
computing performance data relating to the memory references during execution of the program code;
applying the performance data to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, to determine whether each set of conditions is satisfied; and
generating an output, for each set of conditions that is satisfied, indicating that the corresponding optimization is recommended for the program code, said generating being independent of performance of said optimization.
28. A program storage device according to claim 27, wherein the program code may include at least one loop, and wherein the step of computing performance data comprises the step of computing a plurality of performance parameters for each loop in the program code.
29. A program storage device according to claim 28, wherein the method steps further comprise the step of identifying each loop in the program code.
30. A program storage device according to claim 27, wherein the performance parameters comprise parameters for indicating dynamic memory access characteristics associated with each memory reference.
31. A program storage device according to claim 27, wherein the method steps further comprise the step of simulating a cache memory.
32. A program storage device according to claim 31, wherein the performance parameters further comprise cache miss information.
33. A program storage device according to claim 27, wherein the method steps further comprise the step of providing a memory reference trace corresponding to an execution of the program code, the trace including execution data relating to each dynamic instance of a memory reference during the execution of the program code.
34. A program storage device according to claim 33, wherein the execution data comprises an instruction address, an instruction type, a memory address, and a location in the program code.
35. A program storage device according to claim 33, wherein the method steps further comprise the step of modifying the program code to cause the memory reference trace to be generated when the program code is executed.
36. A program storage device according to claim 33, wherein the step of providing comprises the step of executing the program code to generate the memory reference trace.
37. An apparatus for identifying optimizations for computer program code, the code including instructions for performing a plurality of loops, each loop including at least one memory reference, the method comprising the steps of:
means for identifying the loops in the program code;
means for computing performance information relating to each loop, the performance information including dynamic memory access information on the memory references associated with each loop;
means for applying the performance information to a plurality of sets of conditions, each set of conditions corresponding to one of a plurality of optimization techniques, to determine whether each set of conditions is satisfied for each loop; and
means for outputting an indication, for each set of conditions that is satisfied, identifying the corresponding optimization technique as a suggested optimization for said loop, wherein said outputting is independent of performance of said optimization technique.
38. An apparatus according to claim 37, further comprising means for simulating a cache memory to generate cache miss information relating to execution of the program code, the performance information further including the cache miss information.
US08/579,418 1995-12-27 1995-12-27 Memory pattern analysis tool for use in optimizing computer program code Expired - Fee Related US5805863A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US08/579,418 US5805863A (en) 1995-12-27 1995-12-27 Memory pattern analysis tool for use in optimizing computer program code

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US08/579,418 US5805863A (en) 1995-12-27 1995-12-27 Memory pattern analysis tool for use in optimizing computer program code

Publications (1)

Publication Number Publication Date
US5805863A true US5805863A (en) 1998-09-08

Family

ID=24316822

Family Applications (1)

Application Number Title Priority Date Filing Date
US08/579,418 Expired - Fee Related US5805863A (en) 1995-12-27 1995-12-27 Memory pattern analysis tool for use in optimizing computer program code

Country Status (1)

Country Link
US (1) US5805863A (en)

Cited By (38)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5915114A (en) * 1997-02-14 1999-06-22 Hewlett-Packard Company Dynamic trace driven object code optimizer
US6038398A (en) * 1997-05-29 2000-03-14 Hewlett-Packard Co. Method and apparatus for improving performance of a program using a loop interchange, loop distribution, loop interchange sequence
US6078745A (en) * 1997-03-29 2000-06-20 Siemens Ag Method and apparatus for size optimization of storage units
US6226790B1 (en) 1997-02-28 2001-05-01 Silicon Graphics, Inc. Method for selecting optimal parameters for compiling source code
US6253373B1 (en) * 1997-10-07 2001-06-26 Hewlett-Packard Company Tracking loop entry and exit points in a compiler
US6279152B1 (en) * 1996-10-18 2001-08-21 Fujitsu Limited Apparatus and method for high-speed memory access
US6286080B1 (en) * 1999-02-16 2001-09-04 International Business Machines Corporation Advanced read cache emulation
US6289505B1 (en) * 1997-11-18 2001-09-11 Sun Microsystems, Inc. Method, apparatus and computer programmed product for binary re-optimization using a high level language compiler
US20010044930A1 (en) * 2000-05-16 2001-11-22 Hitachi, Ltd. Loop optimization method and a compiler
US20030061444A1 (en) * 2001-09-14 2003-03-27 Seagate Technology Llc Method and system for cache management algorithm selection
US6567976B1 (en) * 1997-03-20 2003-05-20 Silicon Graphics, Inc. Method for unrolling two-deep loops with convex bounds and imperfectly nested code, and for unrolling arbitrarily deep nests with constant bounds and imperfectly nested code
US20030115579A1 (en) * 2001-12-18 2003-06-19 International Business Machines Corporation Optimizing source code for iterative execution
US20030126591A1 (en) * 2001-12-21 2003-07-03 Youfeng Wu Stride-profile guided prefetching for irregular code
US20030217356A1 (en) * 2002-01-10 2003-11-20 Leonid Baraz Register allocation for program execution analysis
US6748558B1 (en) 2000-05-10 2004-06-08 Motorola, Inc. Performance monitor system and method suitable for use in an integrated circuit
US20040205718A1 (en) * 2000-12-11 2004-10-14 Sun Microsystems, Inc. Self-tuning object libraries
US6892173B1 (en) * 1998-03-30 2005-05-10 Hewlett-Packard Development Company, L.P. Analyzing effectiveness of a computer cache by estimating a hit rate based on applying a subset of real-time addresses to a model of the cache
US20050246571A1 (en) * 2002-02-01 2005-11-03 Helge Betzinger Method for processing instructions
US20060061492A1 (en) * 2004-09-20 2006-03-23 Fujitsu Limited System and method for identifying optimal encoding for a given trace
US20060248520A1 (en) * 2004-02-12 2006-11-02 Teruo Kawabata Program conversion device and program conversion method
US20060253656A1 (en) * 2005-05-03 2006-11-09 Donawa Christopher M Method, apparatus, and program to efficiently calculate cache prefetching patterns for loops
US20070136726A1 (en) * 2005-12-12 2007-06-14 Freeland Gregory S Tunable processor performance benchmarking
US7330930B1 (en) * 2004-03-09 2008-02-12 Adaptec, Inc. Method and apparatus for balanced disk access load distribution
US20080301717A1 (en) * 2007-05-31 2008-12-04 Microsoft Corporation Visualizing a memory footprint of an application program
US20090044176A1 (en) * 2007-08-09 2009-02-12 International Business Machine Corporation Method and Computer Program Product for Dynamically and Precisely Discovering Deliquent Memory Operations
US20090307675A1 (en) * 2008-06-04 2009-12-10 Ng John L Data dependence testing for loop fusion with code replication, array contraction, and loop interchange
US20090328021A1 (en) * 2008-06-30 2009-12-31 Ng John L Multiversioning if statement merging and loop fusion
US8060869B1 (en) * 2007-06-08 2011-11-15 Oracle America, Inc. Method and system for detecting memory problems in user programs
US20130283127A1 (en) * 2012-04-24 2013-10-24 International Business Machines Corporation Combined soft detection/soft decoding in tape drive storage channels
US20140173572A1 (en) * 2005-12-15 2014-06-19 International Business Machines Corporation Constraint derivation in context following for use with object code insertion
US20150212804A1 (en) * 2014-01-29 2015-07-30 Fujitsu Limited Loop distribution detection program and loop distribution detection method
US20160062868A1 (en) * 2014-08-27 2016-03-03 Ca, Inc. Automated instrumentation of applications
US20170024194A1 (en) * 2015-07-22 2017-01-26 Oracle International Corporation Optimization techniques for high-level graph language compilers
US20180074798A1 (en) * 2016-09-13 2018-03-15 Canon Kabushiki Kaisha Visualisation for guided algorithm design to create hardware friendly algorithms
US9971570B2 (en) 2015-12-15 2018-05-15 Oracle International Corporation Automated generation of memory consumption aware code
US10585945B2 (en) 2017-08-01 2020-03-10 Oracle International Corporation Methods of graph-type specialization and optimization in graph algorithm DSL compilation
US10614126B2 (en) 2015-05-21 2020-04-07 Oracle International Corporation Textual query editor for graph databases that performs semantic analysis using extracted information
US20230067853A1 (en) * 2021-08-19 2023-03-02 International Business Machines Corporation Analysis for modeling data cache utilization

Citations (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4991088A (en) * 1988-11-30 1991-02-05 Vlsi Technology, Inc. Method for optimizing utilization of a cache memory
US5193190A (en) * 1989-06-26 1993-03-09 International Business Machines Corporation Partitioning optimizations in an optimizing compiler
US5212794A (en) * 1990-06-01 1993-05-18 Hewlett-Packard Company Method for optimizing computer code to provide more efficient execution on computers having cache memories
US5303377A (en) * 1990-03-27 1994-04-12 North American Philips Corporation Method for compiling computer instructions for increasing instruction cache efficiency
US5452457A (en) * 1993-01-29 1995-09-19 International Business Machines Corporation Program construct and methods/systems for optimizing assembled code for execution
US5457799A (en) * 1994-03-01 1995-10-10 Digital Equipment Corporation Optimizer for program loops
US5579520A (en) * 1994-05-13 1996-11-26 Borland International, Inc. System and methods for optimizing compiled code according to code object participation in program activities
US5581762A (en) * 1993-05-18 1996-12-03 Fujitsu Limited Compiling apparatus having a function to analyze overlaps of memory addresses of two or more data expressions and a compiling method

Patent Citations (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4991088A (en) * 1988-11-30 1991-02-05 Vlsi Technology, Inc. Method for optimizing utilization of a cache memory
US5193190A (en) * 1989-06-26 1993-03-09 International Business Machines Corporation Partitioning optimizations in an optimizing compiler
US5303377A (en) * 1990-03-27 1994-04-12 North American Philips Corporation Method for compiling computer instructions for increasing instruction cache efficiency
US5212794A (en) * 1990-06-01 1993-05-18 Hewlett-Packard Company Method for optimizing computer code to provide more efficient execution on computers having cache memories
US5452457A (en) * 1993-01-29 1995-09-19 International Business Machines Corporation Program construct and methods/systems for optimizing assembled code for execution
US5530964A (en) * 1993-01-29 1996-06-25 International Business Machines Corporation Optimizing assembled code for execution using execution statistics collection, without inserting instructions in the code and reorganizing the code based on the statistics collected
US5581762A (en) * 1993-05-18 1996-12-03 Fujitsu Limited Compiling apparatus having a function to analyze overlaps of memory addresses of two or more data expressions and a compiling method
US5457799A (en) * 1994-03-01 1995-10-10 Digital Equipment Corporation Optimizer for program loops
US5579520A (en) * 1994-05-13 1996-11-26 Borland International, Inc. System and methods for optimizing compiled code according to code object participation in program activities

Cited By (56)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6279152B1 (en) * 1996-10-18 2001-08-21 Fujitsu Limited Apparatus and method for high-speed memory access
US5915114A (en) * 1997-02-14 1999-06-22 Hewlett-Packard Company Dynamic trace driven object code optimizer
US6226790B1 (en) 1997-02-28 2001-05-01 Silicon Graphics, Inc. Method for selecting optimal parameters for compiling source code
US6567976B1 (en) * 1997-03-20 2003-05-20 Silicon Graphics, Inc. Method for unrolling two-deep loops with convex bounds and imperfectly nested code, and for unrolling arbitrarily deep nests with constant bounds and imperfectly nested code
US6078745A (en) * 1997-03-29 2000-06-20 Siemens Ag Method and apparatus for size optimization of storage units
US6038398A (en) * 1997-05-29 2000-03-14 Hewlett-Packard Co. Method and apparatus for improving performance of a program using a loop interchange, loop distribution, loop interchange sequence
US6253373B1 (en) * 1997-10-07 2001-06-26 Hewlett-Packard Company Tracking loop entry and exit points in a compiler
US6289505B1 (en) * 1997-11-18 2001-09-11 Sun Microsystems, Inc. Method, apparatus and computer programmed product for binary re-optimization using a high level language compiler
US6892173B1 (en) * 1998-03-30 2005-05-10 Hewlett-Packard Development Company, L.P. Analyzing effectiveness of a computer cache by estimating a hit rate based on applying a subset of real-time addresses to a model of the cache
US6286080B1 (en) * 1999-02-16 2001-09-04 International Business Machines Corporation Advanced read cache emulation
US6748558B1 (en) 2000-05-10 2004-06-08 Motorola, Inc. Performance monitor system and method suitable for use in an integrated circuit
US20010044930A1 (en) * 2000-05-16 2001-11-22 Hitachi, Ltd. Loop optimization method and a compiler
US20040205718A1 (en) * 2000-12-11 2004-10-14 Sun Microsystems, Inc. Self-tuning object libraries
US6883066B2 (en) * 2001-09-14 2005-04-19 Seagate Technology Llc Method and system for cache management algorithm selection
US20030061444A1 (en) * 2001-09-14 2003-03-27 Seagate Technology Llc Method and system for cache management algorithm selection
US7340733B2 (en) * 2001-12-18 2008-03-04 International Business Machines Corporation Optimizing source code for iterative execution
US20080028381A1 (en) * 2001-12-18 2008-01-31 International Business Machines Corporation Optimizing source code for iterative execution
US20030115579A1 (en) * 2001-12-18 2003-06-19 International Business Machines Corporation Optimizing source code for iterative execution
US20030126591A1 (en) * 2001-12-21 2003-07-03 Youfeng Wu Stride-profile guided prefetching for irregular code
US20030217356A1 (en) * 2002-01-10 2003-11-20 Leonid Baraz Register allocation for program execution analysis
US20100049949A1 (en) * 2002-02-01 2010-02-25 Helge Betzinger Parallel program execution of command blocks using fixed backjump addresses
US20050246571A1 (en) * 2002-02-01 2005-11-03 Helge Betzinger Method for processing instructions
US20060248520A1 (en) * 2004-02-12 2006-11-02 Teruo Kawabata Program conversion device and program conversion method
US7330930B1 (en) * 2004-03-09 2008-02-12 Adaptec, Inc. Method and apparatus for balanced disk access load distribution
US20060061492A1 (en) * 2004-09-20 2006-03-23 Fujitsu Limited System and method for identifying optimal encoding for a given trace
US7236107B2 (en) 2004-09-20 2007-06-26 Fujitsu Limited System and method for identifying optimal encoding for a given trace
US20080301375A1 (en) * 2005-05-03 2008-12-04 International Business Machines Corporation Method, Apparatus, and Program to Efficiently Calculate Cache Prefetching Patterns for Loops
US7421540B2 (en) 2005-05-03 2008-09-02 International Business Machines Corporation Method, apparatus, and program to efficiently calculate cache prefetching patterns for loops
US20060253656A1 (en) * 2005-05-03 2006-11-09 Donawa Christopher M Method, apparatus, and program to efficiently calculate cache prefetching patterns for loops
US7761667B2 (en) 2005-05-03 2010-07-20 International Business Machines Corporation Method, apparatus, and program to efficiently calculate cache prefetching patterns for loops
US20070136726A1 (en) * 2005-12-12 2007-06-14 Freeland Gregory S Tunable processor performance benchmarking
US20140173572A1 (en) * 2005-12-15 2014-06-19 International Business Machines Corporation Constraint derivation in context following for use with object code insertion
US9274929B2 (en) * 2005-12-15 2016-03-01 International Business Machines Corporation Constraint derivation in context following for use with object code insertion
US20080301717A1 (en) * 2007-05-31 2008-12-04 Microsoft Corporation Visualizing a memory footprint of an application program
US8060869B1 (en) * 2007-06-08 2011-11-15 Oracle America, Inc. Method and system for detecting memory problems in user programs
US20090044176A1 (en) * 2007-08-09 2009-02-12 International Business Machine Corporation Method and Computer Program Product for Dynamically and Precisely Discovering Deliquent Memory Operations
US8122439B2 (en) * 2007-08-09 2012-02-21 International Business Machines Corporation Method and computer program product for dynamically and precisely discovering deliquent memory operations
US20090307675A1 (en) * 2008-06-04 2009-12-10 Ng John L Data dependence testing for loop fusion with code replication, array contraction, and loop interchange
US8677338B2 (en) * 2008-06-04 2014-03-18 Intel Corporation Data dependence testing for loop fusion with code replication, array contraction, and loop interchange
US8516468B2 (en) 2008-06-30 2013-08-20 Intel Corporation Multiversioning if statement merging and loop fusion
US20090328021A1 (en) * 2008-06-30 2009-12-31 Ng John L Multiversioning if statement merging and loop fusion
US20130283127A1 (en) * 2012-04-24 2013-10-24 International Business Machines Corporation Combined soft detection/soft decoding in tape drive storage channels
US9318148B2 (en) 2012-04-24 2016-04-19 Globalfoundries Inc. Combined soft detection/soft decoding in tape drive storage channels
US9202518B2 (en) * 2012-04-24 2015-12-01 Globalfoundries Inc. Combined soft detection/soft decoding in tape drive storage channels
US20150212804A1 (en) * 2014-01-29 2015-07-30 Fujitsu Limited Loop distribution detection program and loop distribution detection method
US9182960B2 (en) * 2014-01-29 2015-11-10 Fujitsu Limited Loop distribution detection program and loop distribution detection method
US20160062868A1 (en) * 2014-08-27 2016-03-03 Ca, Inc. Automated instrumentation of applications
US9594662B2 (en) * 2014-08-27 2017-03-14 Ca, Inc. Automated instrumentation of applications
US10614126B2 (en) 2015-05-21 2020-04-07 Oracle International Corporation Textual query editor for graph databases that performs semantic analysis using extracted information
US20170024194A1 (en) * 2015-07-22 2017-01-26 Oracle International Corporation Optimization techniques for high-level graph language compilers
US10127025B2 (en) * 2015-07-22 2018-11-13 Oracle International Corporation Optimization techniques for high-level graph language compilers
US9971570B2 (en) 2015-12-15 2018-05-15 Oracle International Corporation Automated generation of memory consumption aware code
US20180074798A1 (en) * 2016-09-13 2018-03-15 Canon Kabushiki Kaisha Visualisation for guided algorithm design to create hardware friendly algorithms
US10585945B2 (en) 2017-08-01 2020-03-10 Oracle International Corporation Methods of graph-type specialization and optimization in graph algorithm DSL compilation
US20230067853A1 (en) * 2021-08-19 2023-03-02 International Business Machines Corporation Analysis for modeling data cache utilization
US11630654B2 (en) * 2021-08-19 2023-04-18 International Business Machines Corporation Analysis for modeling data cache utilization

Similar Documents

Publication Publication Date Title
US5805863A (en) Memory pattern analysis tool for use in optimizing computer program code
Huynh et al. Scope-aware data cache analysis for WCET estimation
US6311324B1 (en) Software profiler which has the ability to display performance data on a computer screen
US5960198A (en) Software profiler with runtime control to enable and disable instrumented executable
JP4823075B2 (en) Automatic generation system for optimized code
Lim et al. An accurate worst case timing analysis for RISC processors
White et al. Timing analysis for data caches and set-associative caches
US9798528B2 (en) Software solution for cooperative memory-side and processor-side data prefetching
Mueller Static cache simulation and its applications
US8180964B1 (en) Optimization of cache configuration for application design
JP4934267B2 (en) Compiler device
US8533698B2 (en) Optimizing execution of kernels
US6721943B2 (en) Compile-time memory coalescing for dynamic arrays
Mock et al. Calpa: A tool for automating selective dynamic compilation
White et al. Timing analysis for data and wrap-around fill caches
JPH09330233A (en) Optimum object code generating method
US8843920B2 (en) Systems and methods for deferring software implementation decisions until load time
US8886887B2 (en) Uniform external and internal interfaces for delinquent memory operations to facilitate cache optimization
US6360360B1 (en) Object-oriented compiler mechanism for automatically selecting among multiple implementations of objects
Mueller et al. Fast instruction cache analysis via static cache simulation
Wang et al. CGPredict: Embedded GPU performance estimation from single-threaded applications
Lee et al. Timed compiled-code simulation of embedded software for performance analysis of SOC design
US20040199907A1 (en) Compiler and method for optimizing object codes for hierarchical memories
Wolf et al. Associative caches in formal software timing analysis
Whitham et al. Investigating average versus worst-case timing behavior of data caches and data scratchpads

Legal Events

Date Code Title Description
FEPP Fee payment procedure

Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY

FPAY Fee payment

Year of fee payment: 4

REMI Maintenance fee reminder mailed
FPAY Fee payment

Year of fee payment: 8

REMI Maintenance fee reminder mailed
LAPS Lapse for failure to pay maintenance fees
STCH Information on status: patent discontinuation

Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362

FP Lapsed due to failure to pay maintenance fee

Effective date: 20100908