|Publication number||US6038398 A|
|Application number||US 08/972,623|
|Publication date||Mar 14, 2000|
|Filing date||Nov 18, 1997|
|Priority date||May 29, 1997|
|Publication number||08972623, 972623, US 6038398 A, US 6038398A, US-A-6038398, US6038398 A, US6038398A|
|Original Assignee||Hewlett-Packard Co.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (7), Non-Patent Citations (16), Referenced by (50), Classifications (4), Legal Events (8)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This patent application claims priority from Provisional Patent Application Serial No. 60/047,868, filed May 29, 1997.
This invention relates to compiler programs and, more particularly, to a compiler program which includes an optimizing procedure which, through use of loop interchanges and loop distributions, improves a sequence of memory addressing actions of an application program being compiled.
Loop interchange is a program transformation that re-orders loop inclusions or "nests". A loop interchange is illustrated by the following example:
______________________________________ Before After______________________________________a) DO I = 0,9 DO J = 0,9b) DO J = 0,9 => DO I = 0,9c) A(I,J) = 0 A(I,J) = 0 Example 1______________________________________
To paraphrase the above steps in the "before" code: step a) indicates that the value of I should be calculated for each of the values stored in an I×J memory matrix at I positions 0-9; step b) indicates that the value of J should be calculated, for every value of I, for each of the values stored in the I×J memory matrix at J positions 0-9; and step c) indicates that A(I,J) should be initialized to zero at the start. One skilled in the art will realize that an interchange of the loops of Example 1 may help performance, since the memory accesses will become more sequential.
This can be understood by reference to FIG. 1, wherein a 10×10 memory matrix is schematically illustrated. If the above-noted Before code listing is executed, the following I,J addresses are accessed in sequence: 0,0; 0,1; 0,2; 0,3 . . . Note that this addressing requires memory positions 0, 10, 20, 30, etc to be sequentially accessed, requiring multi-memory position increment for each address action.
By performing a loop interchange between the I loop and the J loop to reach the "After" code listing in Example 1, the resulting JxI addressing accesses memory positions 0-30 . . . in sequence, thus achieving a single step or "stride one" incrementing of address positions (i.e., a more efficient and faster executing procedure).
A loop interchange requires perfect loop nests, that is, no code is present within the body of the outer loop other than one or more inner loop(s). A set of loops which comprise other than a perfect loop nest is referred to as an imperfect loop nest. One strategy for interchanging imperfect loop nests is first to apply an "enabling" transformation, such as loop distribution, which takes an outer loop that surrounds multiple components, and converts the outer loop into multiple loops around each individual component. For example:
______________________________________Before After______________________________________DO I = 0,9 DO I = 0,9X(I) = 3 => X(I) = 3DO J = 0,9 END DOA(I,J) = 0 DO I = 0,9END DO DO J = 0,9END DO A(I,J) = 0 Example 2______________________________________
The loop distribution illustrated in the "After" code of Example 2 splits the DO I outer loop into two loops and allows isolation of the imperfection (i.e., X(I)=3). Thereafter, the second loop nest can be interchanged, as shown in Example 1. Further examples of both loop interchange and loop distribution can be found in Zima and Chapman, Supercompilers for Parallel and Vector Computers, ACM Press, 1991.
The practical difficulties of such program manipulations are: (i) neither a loop interchange nor a loop distribution are always legal, and (ii) loop distribution, by itself, may be a detrimental transformation, as it raises loop overhead, and more importantly, may lower memory reuse. Accordingly, an algorithm is needed that achieves the distribution-enabled interchanges as above, only when legal, and avoids detrimental distributions when no subsequent interchange is enabled.
For simple cases, such manipulations have been achieved, essentially by speculatively distributing loops; seeing if profitable loop interchanges result; and if not, abandoning the distribution and restoring the original code. See: McKinley et al., "Improving Data Locality with Loop Transformations", ACM Transactions on Programming Languages and Systems, July 1996, Vol. 18, Num. 4.
To summarize, the prior art recognizes that loop interchanges, standing alone may improve program performance by improving a sequence of memory accesses. Further, it is known that by starting with a loop distribution, that a subsequent loop interchange may be enabled which will improve program execution. However, to Applicant's knowledge, it has not been realized that where a potential loop distribution is illegal, that an enabling loop interchange may open a route for further program code improvements.
A compiler optimizing procedure improves a sequence of memory addressing actions of a program, wherein the program includes a plurality of do loops. The procedure includes the steps of: performing an interchange of do loops, within a set of nested loops, to move at least one loop of the set to a position of an outer loop, wherein the one loop manifests a condition which prevents application of a distribution action thereto; attempting distribution of a next outermost loops so as to isolate a code segment in the program from remaining interior loops of the set of nested loops; and if the distribution is performed, determining for each remaining interior loop if an interchange with another interior loop will improve an efficiency of execution of the program and if yes, performing the loop interchange.
FIG. 1 is a schematic illustration of a 10×10 memory matrix that is useful in describing the actions of the prior art.
FIG. 2 is a block diagram of a computer system that is adapted to perform the invention hereof.
FIG. 3 is a logical flow diagram illustrating the procedure of the invention.
Referring to FIG. 2, a computer 10 includes an input/output module 12 for receiving a program to be compiled and a central processing unit (CPU) 14 for performing compile actions on the program. The received program is stored on a disk drive 18, prior to and after being subjected to the compile action of a compiler procedure 20 which is stored in memory 22.
Compiler procedure 20 includes a code optimizer procedure 24 which further comprises a set of subprocedures that are utilized to perform the optimizing actions. Those subprocedures include a loop interchange procedure 26, a loop distribution procedure 28, a legality procedure 30 (for determining if either a loop interchange or loop distribution is "legal" or "illegal"), and a "profitability" procedure (for determining whether a program manipulation results in improved performance or is detrimental to performance).
While it is to be hereafter assumed that the procedures and subprocedures for performing the method of the invention have already been loaded into memory 22, the controlling programs and subroutines may be present on a memory disk 34, or other memory media, which is loaded directly into CPU 14 to control the action thereof to perform the invention.
Turning to FIG. 3, the procedures employed by the invention to improve the execution of a program will be described. It is initially to be understood that profitability procedure 32, when executed, determines if the execution time of a revised code sequence is improved over a previous non-revised version. If it turns out that the execution sequence of revised code is less efficient, then profitability procedure 32 indicates such fact. More precisely, the result of an optimization action may be to be worsen a sequence of memory addressing actions and thus degrade program performance. In such case, the optimization action is counter-productive and is reversed.
Legality procedure 30 determines if a code transformation will result in an identical calculated result as the pre-transformed code. More specifically, it determines if required data dependencies are maintained in the transformed code. If not, the code transformation is termed "illegal".
As shown in FIG. 3, code optimizer 24 initially determines if a perfect loop nest is present in the program listing, i.e., there is no code in the body of an outer loop other than an inner loop or loops (decision box 50). If it is determined that the loop nest is perfect, then it is next determined whether a loop interchange is both legal and profitable (decision box 52). If the answer is yes, a loop interchange is performed (box 54) and the procedure is at an end. If the interchange is found to be either illegal or not profitable, the procedure is at an end.
Assume now that the loop nest is found to be imperfect (decision box 50). In such case, it is next determined whether a distribution of the loops within the loop nest will improve program performance (i.e., the program performance is more "profitable") (decision box 56). If a distribution action results in the less efficient program operation, the procedure is at an end. By contrast, if it is determined that a distribution action will render a more efficient program performance, then it is next determined whether the distribution action is legal (decision box 58).
For example, a distribution will often be found illegal if data dependencies are violated by the distribution action. Such a case may occur where a data dependency resides in an inner loop of a loop nest, making a loop interchange illegal. Nevertheless, if such an inner loop can be moved so as to become an outer loop and thereby isolate the data dependency to the outer loop, a subsequent interchange of further inner loops may be enabled.
Returning to decision box 58, if it is found that the distribution action is legal, then the procedure moves to box 60 wherein a distribution action is performed, followed by a loop interchange. If, however, the distribution action is found to be illegal (decision box 58), then the procedure moves to decision box 62 wherein it is determined if at least two loops are present in the outer perfect nest of loops. If no, an interchange cannot be performed and the procedure is at an end. Otherwise, an interchange of loops is performed (box 64) which may remove the data dependency to an outer loop (so as to enable a subsequent distribution action).
Thereafter, a second outermost loop is found (box 66) and the procedure recycles to decision box 50. If the second outermost loop (and further loops) are found not to constitute a perfect nest of loops, then the procedure moves to decision boxes 56 and 58 to determine if a distribution will be both profitable and legal. If yes, then the distribution action is performed, enabling a subsequent interchange which is then performed. Accordingly, the initial interchange (box 64) enables a distribution action which, in turn, enables a subsequent interchange action to improve code performance.
The key to achieving the transformation illustrated in FIG. 3 above, is choosing a legal loop interchange that enables a legal distribution that, in turn, enables a profitable and legal interchange. The code listing which implements the above-described procedure is as follows:
______________________________________Loop.sub.-- Transform (loop) :if (loop is perfect nest) thenif (interchange is legal and profitable) theninterchange (loop)elseno interchange is attemptedendifelseif (profitable to distribute) thenif (legal to distribute) then Distribute.sub.-- And.sub.-- Interchange(loop)elseAttempt.sub.-- Distribution.sub.-- 2(loop)endifendifend______________________________________
The statement "Attempt-- Distribution-- 2 (loop)" refers to the extra step of trying an enabling distribution and interchange along the lines described above in box 60. For a loop nest to be worth interchanging to enable distribution, its dependencies, which constrain legal transformations, must have a particular form. In the dependence distance vector notation, for instance, distance vectors with zero in the first row are preferred, with some positive number in inner rows, so that the interchanged loop will carry the dependency in the resulting outer loop, making an inner distribution legal. If this condition obtains, the interchange can be executed, with the optimizing procedure applied recursively to the resulting inner loop nests.
In a two-deep nest, there is only one possible interchange. In deeper nests, there may be more legal interchanges which yield inner loops of the appropriate form, all of which may be worth trying. The dependency condition mentioned above helps minimize the number of transformations attempted.
Given the recursion and potential backtracking of the invention, the procedure needs a way of backing out of tentative or speculative transformations. This can be done by reversing the transformation. It may be more efficient to execute the transformations on an auxiliary data structure, which can be simply abandoned if the transformation is found unprofitable, or used as a template to modify the fundamental representation if the transformation is ultimately accepted.
The following is a further detailed example of an application of the invention to a test program sequence. The benchmark code 093. nasa 7/CHOLKSY contains this loop:
______________________________________DO I = 0, NRHSDO K = 0, NDO L = 0, NMATB(I,L,K) = B(I,L,K) * A(L,0,K)END DODO JJ = 1, MIN (M, N-K)DO L = 0, NMAT B(I,L,K+JJ) = B(I,L,K+JJ)-A(L,-JJ,K+JJ)*B(I,L,K)END DOEND DOEND DODO K = N, 0, -1DO L = 0, NMATB(I,L,K) = B(I,L,K) * A(L,0,K)END DODO JJ = 1, MIN (M, K)DO L = 0, NMAT B(I,L,K-JJ) = B(I,L,K-JJ)-A(L,-JJ,K)*B(I,L,K)END DOEND DOEND DOEND DO______________________________________
The desired end-result is to interchange the I loop to innermost, to achieve "stride-one" memory accesses. This requires first distributing the I loop, which is obviously legal. This leaves two nests, each of which looks like:
______________________________________DO I = 0, NRHSDO K = 0, NDO L = 0, NMATB(I,L,K) = B(I,L,K) * A(L,0,K)END DODO JJ = 1, MIN (M, N-K)DO L = 0, NMAT B(I,L,K+JJ) = B(I,L,K+JJ)-A(L,-JJ,K+JJ)*B(I,L,K)END DOEND DOEND DOEND DO______________________________________
Now there is a double-nest at the top-level. The goal is to get I innermost in the deepest (second) nest. Unfortunately, it is illegal to distribute the I-K loop nest over the L and JJ-L nests. However, if the I-K loop nest is first interchanged, the resulting I loop can be distributed over the two inner loops. This results in:
______________________________________DO K = 0, NDO I = 0, NRHSDO L = 0, NMATB(I,L,K) = B(I,L,K) * A(L,0,K)END DOEND DODO I = 0, NRHSDO JJ = 1, MIN (M, N-K)DO L = 0, NMAT B(I,L,K+JJ) = B(I,L,K+JJ)-A(L,-JJ,K+JJ)*B(I,L,K)END DOEND DOEND DOEND DO______________________________________
Now it is legal and profitable to exchange the I loop innermost. Accordingly, the above described loop distribution and loop interchange procedure can apply sequences of distribution and interchange in order to perform a profitable and legal interchange. Further, the procedure avoids doing enabling, and possibly detrimental transformations, unless a profitable transformation results.
It should be understood that the foregoing description is only illustrative of the invention. Various alternatives and modifications can be devised by those skilled in the art without departing from the invention. Accordingly, the present invention is intended to embrace all such alternatives, modifications and variances which fall within the scope of the appended claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4833606 *||Oct 7, 1987||May 23, 1989||Hitachi, Ltd.||Compiling method for vectorizing multiple do-loops in source program|
|US5151991 *||Oct 18, 1988||Sep 29, 1992||Hitachi, Ltd.||Parallelization compile method and system|
|US5230053 *||Feb 5, 1991||Jul 20, 1993||Matsushita Electric Industrial Co., Ltd.||Processor scheduling method for iterative loops|
|US5303377 *||Mar 27, 1990||Apr 12, 1994||North American Philips Corporation||Method for compiling computer instructions for increasing instruction cache efficiency|
|US5457799 *||Mar 1, 1994||Oct 10, 1995||Digital Equipment Corporation||Optimizer for program loops|
|US5802375 *||Nov 23, 1994||Sep 1, 1998||Cray Research, Inc.||Outer loop vectorization|
|US5805863 *||Dec 27, 1995||Sep 8, 1998||Intel Corporation||Memory pattern analysis tool for use in optimizing computer program code|
|1||*||ACM Transactions on Programming Languages and Systems, vol. 18, No. 4, Jul. 1996, pp. 424 453, K. S. McKinley et al., Improving Data Locality with Loop Transformations .|
|2||ACM Transactions on Programming Languages and Systems, vol. 18, No. 4, Jul. 1996, pp. 424-453, K. S. McKinley et al., "Improving Data Locality with Loop Transformations".|
|3||Bacon, D.; Graham, S.; Sharp, O.; "Compiler Transformations for High Performance Computing"; ACM Computing Surveys; vol. 26, No. 4, pp. 345-420 Dec. 1994.|
|4||*||Bacon, D.; Graham, S.; Sharp, O.; Compiler Transformations for High Performance Computing ; ACM Computing Surveys; vol. 26, No. 4, pp. 345 420 Dec. 1994.|
|5||Hsieh, B.; "Loop Distribution with Mulitple Exits"; Proceedings of the 1992 Conference on Supercomputing; pp. 204-213, 1992.|
|6||*||Hsieh, B.; Loop Distribution with Mulitple Exits ; Proceedings of the 1992 Conference on Supercomputing; pp. 204 213, 1992.|
|7||Kelly, W.; Pugh, W.; "A Unifying Framework for Iteration Reordering Transformations"; IEEE First International Conference on Algorithms and Architectures for Parallel Processing; vol. 1, pp. 153-162 Apr. 1995.|
|8||*||Kelly, W.; Pugh, W.; A Unifying Framework for Iteration Reordering Transformations ; IEEE First International Conference on Algorithms and Architectures for Parallel Processing; vol. 1, pp. 153 162 Apr. 1995.|
|9||Pyo, C.; Lee, K.; Han, H.; Lee, G.; "Reference Distance as a Metric for Data Locality"; High Performance Computing on the Information Superhighway, 1997; pp. 151-156 May 1997.|
|10||*||Pyo, C.; Lee, K.; Han, H.; Lee, G.; Reference Distance as a Metric for Data Locality ; High Performance Computing on the Information Superhighway, 1997; pp. 151 156 May 1997.|
|11||Sarkar, V.; Gao, G.; "Optimization of Array by Collective Loop Transformations"; Proceedings of the 1991 International Conference on Supercomputing; pp. 194-205, 1991.|
|12||*||Sarkar, V.; Gao, G.; Optimization of Array by Collective Loop Transformations ; Proceedings of the 1991 International Conference on Supercomputing; pp. 194 205, 1991.|
|13||Sass, R.; Mutka, M.; "Enabling Unimodular Transformations"; Proceedings of the Conference on Supercomputing '94; pp. 753-762 Nov. 1994.|
|14||*||Sass, R.; Mutka, M.; Enabling Unimodular Transformations ; Proceedings of the Conference on Supercomputing 94; pp. 753 762 Nov. 1994.|
|15||Wolf, M.; Maydan, D.; Chen, D.; "Combining Loop Transformations Considering Caches and Scheduling"; Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture; pp. 274-286 Dec. 1996.|
|16||*||Wolf, M.; Maydan, D.; Chen, D.; Combining Loop Transformations Considering Caches and Scheduling ; Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture; pp. 274 286 Dec. 1996.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US6223337 *||Dec 12, 1997||Apr 24, 2001||Hewlett-Packard Company||Random test generation for compiler optimization|
|US7086038||Oct 7, 2002||Aug 1, 2006||Hewlett-Packard Development Company, L.P.||System and method for creating systolic solvers|
|US7131119 *||May 30, 2001||Oct 31, 2006||International Business Machines Corporation||Code optimization|
|US7318223 *||Aug 26, 2004||Jan 8, 2008||International Business Machines Corporation||Method and apparatus for a generic language interface to apply loop optimization transformations|
|US7574704||Oct 21, 2004||Aug 11, 2009||International Business Machines Corporation||System and method for frequency based loop reorganization|
|US7890940 *||Jan 11, 2008||Feb 15, 2011||International Business Machines Corporation||Compilation and runtime information generation and optimization|
|US8056065||Sep 26, 2007||Nov 8, 2011||International Business Machines Corporation||Stable transitions in the presence of conditionals for an advanced dual-representation polyhedral loop transformation framework|
|US8060870 *||Sep 26, 2007||Nov 15, 2011||International Business Machines Corporation||System and method for advanced polyhedral loop transformations of source code in a compiler|
|US8087010||Sep 26, 2007||Dec 27, 2011||International Business Machines Corporation||Selective code generation optimization for an advanced dual-representation polyhedral loop transformation framework|
|US8087011||Sep 26, 2007||Dec 27, 2011||International Business Machines Corporation||Domain stretching for an advanced dual-representation polyhedral loop transformation framework|
|US8429636 *||Jun 30, 2011||Apr 23, 2013||Oracle America, Inc.||Handling dependency conditions between machine instructions|
|US8453134 *||Jun 4, 2008||May 28, 2013||Intel Corporation||Improving data locality and parallelism by code replication|
|US8572590||Sep 16, 2009||Oct 29, 2013||Reservoir Labs, Inc.||Methods and apparatus for joint parallelism and locality optimization in source code compilation|
|US8589901 *||Dec 22, 2010||Nov 19, 2013||Edmund P. Pfleger||Speculative region-level loop optimizations|
|US8661422||Feb 4, 2009||Feb 25, 2014||Reservoir Labs, Inc.||Methods and apparatus for local memory compaction|
|US8677338 *||Jun 4, 2008||Mar 18, 2014||Intel Corporation||Data dependence testing for loop fusion with code replication, array contraction, and loop interchange|
|US8688619||Mar 8, 2010||Apr 1, 2014||Reservoir Labs||Systems, methods and apparatus for distributed decision processing|
|US8793675||Dec 24, 2010||Jul 29, 2014||Intel Corporation||Loop parallelization based on loop splitting or index array|
|US8892483||May 31, 2011||Nov 18, 2014||Reservoir Labs, Inc.||Systems and methods for planning a solution to a dynamically changing problem|
|US8914601||Oct 18, 2011||Dec 16, 2014||Reservoir Labs, Inc.||Systems and methods for a fast interconnect table|
|US8930926||Apr 16, 2010||Jan 6, 2015||Reservoir Labs, Inc.||System, methods and apparatus for program optimization for multi-threaded processor architectures|
|US9134976||Dec 13, 2011||Sep 15, 2015||Reservoir Labs, Inc.||Cross-format analysis of software systems|
|US9185020||Apr 29, 2010||Nov 10, 2015||Reservoir Labs, Inc.||System, apparatus and methods to implement high-speed network analyzers|
|US9361079 *||Jan 30, 2012||Jun 7, 2016||Nvidia Corporation||Method for compiling a parallel thread execution program for general execution|
|US9489180||Nov 16, 2012||Nov 8, 2016||Reservoir Labs, Inc.||Methods and apparatus for joint scheduling and layout optimization to enable multi-level vectorization|
|US9613163||Nov 12, 2015||Apr 4, 2017||Significs And Elements, Llc||Efficient packet forwarding using cyber-security aware policies|
|US9684865||Jun 5, 2013||Jun 20, 2017||Significs And Elements, Llc||System and method for configuration of an ensemble solver|
|US9798588||Apr 25, 2013||Oct 24, 2017||Significs And Elements, Llc||Efficient packet forwarding using cyber-security aware policies|
|US20010044930 *||Jan 18, 2001||Nov 22, 2001||Hitachi, Ltd.||Loop optimization method and a compiler|
|US20030079209 *||May 30, 2001||Apr 24, 2003||International Business Machines Corporation||Code optimization|
|US20040068718 *||Oct 7, 2002||Apr 8, 2004||Cronquist Darren C.||System and method for creating systolic solvers|
|US20060048121 *||Aug 26, 2004||Mar 2, 2006||International Business Machines Corporation||Method and apparatus for a generic language interface to apply loop optimization transformations|
|US20060101441 *||Oct 21, 2004||May 11, 2006||International Business Machines Corporation||System and method for frequency based loop reorganization|
|US20060248520 *||Feb 4, 2005||Nov 2, 2006||Teruo Kawabata||Program conversion device and program conversion method|
|US20080162909 *||Jan 11, 2008||Jul 3, 2008||International Business Machines Corporation||Compilation and runtime information generation and optimization|
|US20090083722 *||Sep 26, 2007||Mar 26, 2009||Eichenberger Alexandre E||System and Method for Stable Transitions in the Presence of Conditionals for an Advanced Dual-Representation Polyhedral Loop Transformation Framework|
|US20090083724 *||Sep 26, 2007||Mar 26, 2009||Eichenberger Alexandre E||System and Method for Advanced Polyhedral Loop Transformations of Source Code in a Compiler|
|US20090307673 *||Sep 26, 2007||Dec 10, 2009||Eichenberger Alexandre E||System and Method for Domain Stretching for an Advanced Dual-Representation Polyhedral Loop Transformation Framework|
|US20090307674 *||Jun 4, 2008||Dec 10, 2009||Ng John L||Improving data locality and parallelism by code replication and array contraction|
|US20090307675 *||Jun 4, 2008||Dec 10, 2009||Ng John L||Data dependence testing for loop fusion with code replication, array contraction, and loop interchange|
|US20100070956 *||Sep 16, 2009||Mar 18, 2010||Reservoir Labs, Inc||Methods and apparatus for joint parallelism and locality optimization in source code compilation|
|US20100218196 *||Apr 16, 2010||Aug 26, 2010||Reservoir Labs, Inc.||System, methods and apparatus for program optimization for multi-threaded processor architectures|
|US20100281160 *||Apr 29, 2010||Nov 4, 2010||Reservoir Labs, Inc.||System, apparatus and methods to implement high-speed network analyzers|
|US20110258415 *||Jun 30, 2011||Oct 20, 2011||Sun Microsystems, Inc.||Apparatus and method for handling dependency conditions|
|US20120167068 *||Dec 22, 2010||Jun 28, 2012||Jin Lin||Speculative region-level loop optimizations|
|US20130198494 *||Jan 30, 2012||Aug 1, 2013||Vinod Grover||Method for compiling a parallel thread execution program for general execution|
|WO2004034274A2 *||Oct 3, 2003||Apr 22, 2004||Hewlett-Packard Development Company L.P.||System and method for creating systolic solvers|
|WO2004034274A3 *||Oct 3, 2003||Nov 3, 2005||Hewlett Packard Development Co||System and method for creating systolic solvers|
|WO2010033622A2 *||Sep 16, 2009||Mar 25, 2010||Reservoir Labs, Inc.||Methods and apparatus for joint parallelism and locality optimization in source code compilation|
|WO2010033622A3 *||Sep 16, 2009||Jun 3, 2010||Reservoir Labs, Inc.||Methods and apparatus for joint parallelism and locality optimization in source code compilation|
|May 26, 1998||AS||Assignment|
Owner name: HEWLETT-PACKARD COMPANY, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:SCHOOLER, RICHARD;REEL/FRAME:009220/0881
Effective date: 19971111
|Jan 16, 2001||AS||Assignment|
Owner name: HEWLETT-PACKARD COMPANY, COLORADO
Free format text: MERGER;ASSIGNOR:HEWLETT-PACKARD COMPANY;REEL/FRAME:011523/0469
Effective date: 19980520
|Sep 15, 2003||FPAY||Fee payment|
Year of fee payment: 4
|Sep 14, 2007||FPAY||Fee payment|
Year of fee payment: 8
|Sep 22, 2011||AS||Assignment|
Owner name: HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P., TEXAS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:HEWLETT-PACKARD COMPANY;REEL/FRAME:026945/0699
Effective date: 20030131
|Oct 24, 2011||REMI||Maintenance fee reminder mailed|
|Mar 14, 2012||LAPS||Lapse for failure to pay maintenance fees|
|May 1, 2012||FP||Expired due to failure to pay maintenance fee|
Effective date: 20120314