Abstract:
A method of data reshaping for multidimensional dynamic array objects in the presence of multiple object instantiations. The method includes collecting all alias information using interprocedural point escape analysis, and collecting all shape information using interprocedural shape analysis. The method progresses with selecting the candidate dynamic objects based on alias and shape analysis, and determining the types of data reshaping for the candidate dynamic objects. The method further includes creating objects for selected dynamic objects with multiple object instantiations. The method proceeds by updating the memory allocation operations for the selected dynamic objects and inserting statements to initialize object descriptors. The method further includes creating the copy of the object descriptors for selected dynamic object assignments. The method concludes by replacing the object references by array-indexed references for selected dynamic objects using object descriptors.

Description:
TRADEMARKS 
       [0001]    IBM® is a registered trademark of International Business Machines Corporation, Armonk, N.Y. U.S.A. Other names used herein may be registered trademarks, trademarks or product names of International Business Machines Corporation or other companies. 
       BACKGROUND 
       [0002]    1. Field of Invention 
         [0003]    This invention relates in general to data caches, and more particularly, to data structure reordering. 
         [0004]    2. Description of Background 
         [0005]    Data cache efficiency is a major performance bottleneck in modern computer systems. Extensive research effort has been dedicated to the improvement of data cache utilization on data layout transformation, typically array padding and array data structure reordering are utilized to exploit data reuse. These optimizations are particularly effective in the domain of scientific computing in which programs operate extensively on arrays. 
         [0006]    Nowadays, many applications also make extensive use of pointers to store data using low-level programming languages that support pointers, such as C and C++. The pointer-intensive programs are a difficult challenge for modern computer architectures and memory hierarchies. Typical pointer-based heap allocated data tends to have less regular access pattern with much worse reference locality than an array. An effective way to overcome this drawback is to allocate data in a manner to increase the programs&#39; reference locality. 
         [0007]    The recent work provides a practical, safe, and automatic data reshaping and data merging framework that reorganizes dynamic arrays of objects to improve data locality. Two major approaches have been described for reorganizing these data structures: Arithmetic-based reshaping relies on a mathematical formula to map object components from their original location to their remapped location. Pointer-based reshaping introduces pointers inside the original data structure to indicate where some components have been relocated. 
         [0008]    It has been shown that arithmetic-based reshaping always performs better than the pointer-based reshaping, as it requires no additional components to be introduced and maintained inside the structure. Yet, so far arithmetic-based reshaping has been restricted to single-instantiation cases to avoid unsafe code transformations. The single-instantiation restriction says that there must be a single allocation point for a particular object type, and that this point must be executed no more than once at run time so that the base address of the object is a constant at runtime. However, many programs operate on data structures that are typically not allocated monolithically into a dynamic object. Even in cases where there is effectively a single instantiation at runtime, it may be difficult or even impossible for a compiler to statically prove that the call site will only be executed no more than once. The challenge to handle individually allocated objects imposes the difficult task upon a user to analyze all the dynamically placed objects involved in a data structure at compile time and to do a safe code transformation. 
         [0009]    Thus, there is a need for a method that provides a novel and efficient method for dynamically allocated data reshaping with multiple object instantiations. 
       SUMMARY OF THE INVENTION 
       [0010]    The shortcomings of the prior art are overcome and additional advantages are provided through the provision of a method of data reshaping for multidimensional dynamic array objects in the presence of multiple object instantiations. The method includes collecting all alias information using interprocedural pointer escape analysis. The method progresses with collecting all shape information using interprocedural shape analysis. The method further includes selecting the candidate dynamic objects based on alias and shape analysis, and determining the types of data reshaping for the candidate dynamic objects. Subsequently, the method proceeds by creating objects for selected dynamic objects with multiple object instantiations. Afterwards, the method progresses by updating the memory allocation operations for the selected dynamic objects, and inserting statements to initialize object descriptors. The method further includes creating the copy of the objects for selected dynamic object assignments. The method concludes with replacing the object references by array-indexed references for selected dynamic objects using object descriptors. 
         [0011]    Additional features and advantages are realized through the techniques of the present invention. Other embodiments and aspects of the invention are described in detail herein and are considered a part of the claimed invention. For a better understanding of the invention with advantages and features, refer to the description and to the drawings. 
       Technical Effects 
       [0012]    As a result of the summarized invention, technically we have achieved a solution for a method of data reshaping for multidimensional dynamic array objects in the presence of multiple object instantiations. 
     
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0013]    The subject regarded as the invention is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The foregoing and other objects, features, and advantages of the invention are apparent from the following detailed description taken in conjunction with the accompanying drawings in which: 
           [0014]      FIG. 1  illustrates one example of a method of data reshaping for multidimensional dynamic array objects in the presence of multiple object instantiations; 
           [0015]      FIG. 2  illustrates one example of computer software code that is amenable to improvement by data reshaping with multiple object instantiations; 
           [0016]      FIG. 3  illustrates one example of the computer software code shown in  FIG. 2 , following an optimization of data reshaping; and 
           [0017]      FIG. 4  illustrates one example of code transformation movement for the method disclosed in  FIG. 1 . 
       
    
    
       [0018]    The detailed description explains an exemplary embodiment of the invention, together with advantages and features, by way of example with reference to the drawings. 
       DETAILED DESCRIPTION OF THE INVENTION 
       [0019]    A safe and efficient data reshaping method is disclosed to reorganize multidimensional dynamic array objects with multiple object instantiations to improve data locality, in order to improve the performance in the execution of the compiled code. 
         [0020]    An intermediate representation of computer code is generated and used including a call graph, a control flow graph, and a data flow graph. The compiler system carries out two-pass traversal of the call graph in the intermediate representation of the code being compiled. This two-pass analysis avoids redundant computation by performing incremental update of reference marking with a minimal number of computations per procedure. 
         [0021]    Alias and shape analysis is used to efficiently identify data reshaping opportunities for multiple instantiated objects. An object descriptor is created for dynamic objects for safe code transformation for data reshaping. 
         [0022]    Referring to  FIG. 1 , a method of data reshaping for multidimensional dynamic array objects in the presence of multiple object instantiations, is shown. The method commences at step  100 , in which the alias information is collected using interprocedural pointer escape analysis. Subsequently, at step  110 , the shape information is collected using interprocedural shape analysis. 
         [0023]    At step  120 , the candidate dynamic objects based on alias and shape analysis are selected. Furthermore, the type of data reshaping for the candidate dynamic objects are determined. Afterwards, at step  130 , objects are created for selected dynamic objects with multiple object instantiations. 
         [0024]    At step  140 , the memory allocation operations for the selected dynamic objects are updated. This update includes the insertion of a statement to initialize the object descriptors. The copy of the object descriptors is created for selected dynamic object assignments at step  150 . In conclusion at step  160 , the object references are replaced by array-indexed references for selected dynamic objects using object descriptors. 
         [0025]    The system&#39;s method traverses each node in the call graph in the intermediate representation of the code being compiled in reverse depth-first order (top-down). If the intermediate representation for a procedure is not available, then the procedure is identified as an undefined procedure, for example, assembler code being linked to the compiled code, otherwise the procedure is a defined procedure. For each defined procedure reached in the top-down traversal of the call graph, the system collects the alias information and shape information with interprocedural pointer alias analysis and shape analysis. The interprocedural pointer analysis can be flow sensitive or flow insensitive. It collects the alias information of data objects that may reside in the same memory location. Whenever a pointer assignment (including passing pointer as parameter, function returning pointer) is met in the analysis, the alias sets represented by the right-hand side pointer and by the left-hand side pointer are merged. The alias information is refined during traversal of the call-graph, and is finalized at the end of the traversal. 
         [0026]    The interprocedural data shape analysis is field sensitive in order to reshape compatible data. It tracks the types of aggregate fields, allocation sites, and the access patterns of the data objects. Two aggregated data types are compatible if they have the same number of fields with each corresponding field having the same length and offset. Two arrays are compatible if both their element types are compatible and they have the same dimensions with each corresponding dimension having the same stride. Two pointers are compatible if they point to the compatible data. Whenever an incompatibility is found in an alias set, it is not considered for data reshaping. 
         [0027]    When the entire intermediate representation of the code to be compiled has been traversed, the system analyses the information to select the candidate for data reshaping on the type-safe analysis. For each alias set, the system will analyze its access pattern, its allocation information and its points-to set to decide the candidacy of the pointer. A dynamic pointer is considered as a candidate if (i) the access pattern for each leveled dynamic pointer is consistent, and (ii) the shape of all of its points-to fields is compatible in the whole program. 
         [0028]    Referring to  FIG. 2 , where an illustration of C-style computer software code that may be optimized in compilation by the interprocedural compilation method is shown. In the example of  FIG. 2 , variables p and q are global pointers to type struct XY. Variables P and Q are global pointers to pointer to type float. All these pointers are dynamic pointers. The function init is called twice and thus the pointers p and P are instantiated twice at runtime. Because of the equivalence between array and pointer notation, the array notation is used in the source code to access individual elements of the array. 
         [0029]    In the example of  FIG. 2 , the present method is used in an optimizing compiler to determine whether data reshaping is safe to be carried out based on the alias analysis and shape analysis. Both p and q are candidates for data splitting. Both P and Q are candidates for data merging. 
         [0030]    Referring to  FIG. 3 , the resulting code after optimization is shown, this code may be further optimized if desired by a user. 
         [0031]    The system is implemented in a link-phase portion of an optimizing compiler that generates an intermediate representation of the code, which includes a call graph. The call graph is a directed multi-grain in which the nodes represent procedures in the code being compiled, and the edges represent call points. In this application, the term procedure refers to functions and other programming language subroutines. 
         [0032]    The method may also make use of a control flow graph and a data flow graph. The data structures of a control flow graph and a data flow graph, and their uses in an intermediate representation of code in an optimizing compiler are well understood in the compiler literature. 
         [0033]    Referring to  FIG. 2  again, pointers p and q are in the same alias set, and can be candidates for data splitting with multiple object instantiation. The collected information for p and q includes: Aliases (p, q): access (array type, dimension  1 , stride  4 ), pointers-to (p[].x length  4 , offset  0 ; q[].y length  4 , offset  4 ), allocation (call graph edge  1 ). The pointers P and Q are in another alias set, and can be candidates for memory allocation merging with multiple object instantiation. The collected information for P and Q includes: Aliases (P, Q): access (array type, dimension  1 , stride  4 ), points-to (P[], Q[]), allocation (call graph edge  2 ), and Aliases (P[], Q[]): access (array type, dimension  1 , stride  4 ), points-to (P[][], Q[][]), allocation (call graph edge  3 ). 
         [0034]    The system creates an object descriptor for each dynamic pointer set after the set is determined to be a candidate for data reshaping with multiple object instantiation. The object descriptor is to record information regarding the data reshaping transformation for each object instantiation. The object descriptor is introduced per object instantiation to record the information regarding the data reshaping transformation. The content of the object descriptor depends on the type of the data reshaping. For a data splitting candidate, a data partition plan determines how the fields in the original data should be reorganized into clusters of new data. Once the partition strategy is determined, an object descriptor is created, which may contain:
       (1) The base address allocated for the dynamic pointer.   (2) The current address for the dynamic pointer. This may be omitted if there is no pointer copy with displacement in the whole program and thus the current address is always the same as the base address.   (3) The cluster base address for each new cluster.       
 
         [0038]    When an object is split, the object descriptor may contain the base address allocated for the dynamic object and the cluster base address for each new cluster. Furthermore, the object descriptor may contain the current address for the dynamic object if it is not the same as the object descriptor base address during its lifetime. 
         [0039]    For memory allocation merging candidate, the object descriptor may contain:
       (1) The base address allocated for the level- 0  dynamic pointer.   (2) The current address for the level- 0  dynamic pointer. This may be omitted if there is no pointer copy with displacement in the whole program and thus the current address is always the same as the base address.   (3) The strides for each leveled dynamic object expect level- 0  base.       
 
         [0043]    When an object memory allocation is merged, the object descriptor may contain the base address allocated for the level  0  dynamic object and the strides for each leveled dynamic object except level  0  base. Furthermore, the object descriptor may contain the current address for the level  0  dynamic pointer provided it is not the same as its base address during its lifetime. 
         [0044]    Regarding the example illustrated in  FIG. 2 , the object descriptor for pointers p and q contains (base, base_x, base_y) with maximum data splitting, and the object descriptor for pointers P and Q contains (base, stride_ 1 ) with memory allocation merging. In the example, the object descriptors have no field of current addresses since there is no pointer assignment with displacement. 
         [0045]    Once all pointer information is examined and the data reshaping object descriptors are created, the system&#39;s method modifies the intermediate representation of the code being compiled. This step is well-suited for inclusion in a backward pass in an interprocedural optimizer in a compiler, in which the system&#39;s method traverses the call graph in the depth-first order (bottom-up). 
         [0046]    For memory allocation of a candidate dynamic pointer, the code transformation depends on the type of data reshaping. For data splitting, the allocation is replaced by an allocation with the total size of the reshaped data plus the size of the new descriptor and possible padding. For memory allocation merging, if the dynamic pointer is of type base, the allocation is replaced by an allocation with the total size of combined memory allocations with this base plus the size of the new descriptor and possible padding (the leveled memory allocation is simple removed). The padding could be added for alignment or another purpose, for example, to reduce the cache miss. The system uses the first chuck of bytes for the object, and the remaining bytes for the reshaped data, as shown in  FIG. 4 . In the memory allocation sites, statements are inserted to initialize the objects. 
         [0047]    The copy of the object descriptor needs to be created when there is a pointer assignment with displacement, or a function returns a pointer with displacement, or a pointer with a displacement is passed as parameter since the current address may change for candidate pointers. Statements to create copies of the object descriptors are inserted when the current address may change. 
         [0048]    For load operation of a candidate dynamic pointer, the code is transformed to an address computation using the objects. The stride is updated as necessary. 
         [0049]    For reference of a field of a splitting candidate dynamic pointer, the code is transformed to an array indexed form using the cluster base address of the object descriptor. The stride is updated as necessary. 
         [0050]    For dereference of a highest level of a merging candidate dynamic pointer, the code is transformed to an array indexed form using the stride of the object descriptor. 
         [0051]    Referring to the example illustrated in  FIG. 2 , and the resulting code after data splitting and memory allocation merging shown in  FIG. 3 . After data reshaping is performed, other interprocedural or intraprocedural optimization techniques may be applied to further improve the performance in the execution of the compiled code. 
         [0052]    While the preferred embodiment to the invention has been described, it will be understood that those skilled in the art, both now and in the future, may make various improvements and enhancements which fall within the scope of the claims which follow. These claims should be construed to maintain the proper protection for the invention first described.