US20010032332A1 - Method of generating profile-optimized code - Google Patents
Method of generating profile-optimized code Download PDFInfo
- Publication number
- US20010032332A1 US20010032332A1 US09/761,152 US76115201A US2001032332A1 US 20010032332 A1 US20010032332 A1 US 20010032332A1 US 76115201 A US76115201 A US 76115201A US 2001032332 A1 US2001032332 A1 US 2001032332A1
- Authority
- US
- United States
- Prior art keywords
- solution
- compiling
- function
- options
- application program
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
- G06F8/4441—Reducing the execution time required by the program code
Definitions
- This invention relates to a method for compiling code and more particularly, to using profile data generated from sample runs compiled with different compiler options to guide the set of options to be used for each function.
- VLIW Very Long Instruction. Word
- Compiler optimization control flags generally work on a whole source module.
- the typical development scenario is to compile, run, and profile a program, then recompile modules based on the feedback provided by the profiler: compile some modules for speed, some for size.
- a program is compiled with two or more sets of compiler options, and each resulting executable is profiled.
- the results of all the profiles are used as input to a program which will analyze the profile data, and given constraints will generate a solution which will be a list of each function in the application, and the set of compiler options to use for each function in order to satisfy the given constraints.
- FIG. 1 illustrates the system according to one embodiment of the present invention
- FIG. 2 illustrates the method according to one embodiment of the present invention
- FIG. 3 illustrates linear solution generation
- FIG. 4 illustrates search tree
- FIG. 5 illustrates a chart of speed (cycle) versus size (bytes);
- FIG. 6 illustrates a zoom area expansion of part of the chart of FIG. 5;
- FIG. 7 illustrates a solution point window
- FIG. 8 illustrates an override window
- FIG. 9 illustrates extended solution point window.
- a standard compiler takes code (such as C) and compiles it, generating object code.
- a compiler may be controlled with compiler options so it generates code which will, for example, run as fast as possible or may be controlled to generate code which is as small as possible.
- the goal of this invention is to automatically choose compiler options for each function in a program to optimally balance system constraints such as size and speed. This set of options is referred to as the “solution” for the program.
- FIG. 1 there is illustrated a system 10 according to one embodiment of the present invention.
- the method performed by the system is illustrated in FIG. 2.
- Code such as C code from source 11 is compiled in compiler 13 resulting in executable code.
- the first step (Step 1 ) in the process is that the whole program is compiled several times in the compiler 13 , each time with different compiling option.
- the options may be for minimum size at all cost, for size with moderate speed cost, for speed, for aggressive speed or maximum speed at all cost.
- the option sets are chosen at control 13 a by the user using a graphical user interface 17 to optimize the different performance metrics such as maximum speed or minimum size.
- the initial steps for generating the information used by the user interface 17 is providing said application program, and an associated database for exercising said program, providing a compiler, for compiling said application program, having compiling options.
- the result of the compiling step is a set of executable objects, one for each option set.
- the resulting executable objects are represented by executable 1, executable 2, executable 3, etc. in FIG. 1 that correspond to option 1, option 2, option 3, etc.
- the executable objects may be stored in an executable database and are applied to a profiler 15 .
- the next step is to execute each version or executable object of the program produced in Step 1 , producing profile information for each version or executable.
- the user interface 17 provides a profiler 15 for extracting information related to said compiled application program from different compiling options, but using the same associated database, creating a profiler database 19 based upon said extracted information.
- the profiler 15 includes a simulator 15 a to run the executable to provide a profile of the program.
- Each “profile” contains measured performance metrics for each function in the program (such as size, power consumed, and cycles consumed.). This is represented by the profile 1, profile 2, and profile 3 in FIG.
- profile 1 corresponds to the profile of run executable 1
- profile 2 corresponds to the profile of run executable 2
- profile 3 corresponds to the profile of executable 3.
- the profiler 15 may be a standalone simulator that records run-time information.
- An application program typically comprises several different functions that are used to perform the activities an application program is to perform. Each method of building an application can result in an executable version of the program application that exhibits different results, such as, code size and processor cycle count or speed behavior. When an application is built using several different methods, each resulting version of the application can be profiled by the profiler at the function level for its results over a consistent input set, collecting compiled code size and execution cycles for the functions of the program.
- Profile data collected by running the program and recording the time spent in each function can indicate which parts of the program deserve speed versus size consideration.
- the program must remain the same in all profile runs, and the profile runs must all do the same thing on all the same data.
- the resulting set of profile information describes the effects that each method has on each profilable function; for the example discussed above, this is in terms of code size and number of cycles executed for each function of the application program. If the method changes at the function level (from function to function), the term “solution” is used to represent a specific assignment of methods to each function of the compiled program.
- a program consists of 3 functions F1, F2, and F3.
- the functions When compiled with options set 1, the functions have the respective sizes of A1, A2, and A3, and the execution times of B1, B2, and B3.
- the 3 functions When compiled with options set 2, the 3 functions have respective sizes C1, C2, and C3, and respective execution times of D1, D2, and D3.
- the compilation of this program by the system will create two profile sets, corresponding to the two options sets (options 1 and options 2).
- Profile 1 consists of the following data:
- Profile 2 consists of the following data:
- Every individual function trade-off can be considered to produce a solution. All possible permutations of trade-offs over the whole set of profile runs may be saved in memory or at least the most desirable.
- the profile data is stored in memory 19 of FIG. 1.
- Step 3 provides a solution solver 21 for generating estimated solutions from said profiler database.
- a solution engine 21 uses this profiling information to evaluate the permutations of varying methods at the function level to compute all of the useful solutions.
- a solution is “useful”, if no other solution results in a version of the application that is better optimized for a specific result, such as, for example, faster and smaller in code size than it.
- the user interface 17 creates a solution database 23 based upon solutions from said solver 21 from extracted information.
- the solver or solution engine 21 uses linear programming and heuristics to reduce the total number of permutations of option sets per function to an “efficient frontier” which is the set of potential solutions for which there are no other solutions that are better in all performance metrics, such as size and speed.
- the “efficient frontier” represents the best set of compile options for the set of functions to produce the best set of potential solutions.
- the fundamental unit in the solver 21 is the function record, which contains the time and size information for a single function in a single profile. Each profile is represented as a sequence of function records F1, F2, F3, etc. one for each function.
- the solver 21 operates on a matrix of function records, each row containing the records for one function, each column containing the records for one profile. To form a solution, the solver 21 picks one function record from each row; choosing from different columns implements the node interchange.
- the solver process has two stages. The first is generating possible solutions and the second is filtering the possible solutions.
- the process of forming the solution curve is essentially a search problem; it divides nicely into generating solution from the function matrix, and evaluating them to determine which are useful. We want to avoid brute-force generation, since the numbers are extremely large. The vast majority of these solutions will be useless. It's important both to reduce the number generated and to efficiently discard the useless ones.
- a second method is to remove from each row all function records that are themselves useless. In many instances, records will be identical (and the duplicates can be removed) or one or more will be clearly inferior (their time and size are both greater than the others). This filtering method mirrors the evaluation of solutions: only points on the lower contour of the speed/size plot are retained.
- solutions can be generated in several ways.
- the best heuristic for our purposes we call “linear approximation” (FIG. 3).
- the linear solver 21 sorts the rows of the filtered matrix and then moves a small window down the rows, only considering possibilities that involve choices within the window. In its simplest form, with two columns and a one-row window, the choices would be to take the function in column A or in the one in column B; after the choice, the choice is made on the next row, and so on. Rows above the window are left in column B, rows below it in column A. It is linear because the number of solutions generated is directly proportional to the number of rows in the matrix.
- the window is eight rows so we have 256 choices at each step; there may be more than two columns so we use each pair of columns in turn; and there are two or more sort functions so we make that many passes over the entire matrix. All these details serve to generate permutations that are likely to be useful, without generating all of them.
- the filtering process both the initial filter and the solution filter, uses a binary search tree. For the five profiles such as Option 1 for speed, Option 2 for size, Option 3 for minimum size, Option 4 for maximum speed, and Option 5 for aggressive speed.
- the two column pair choices are for example Option 1 and Option 2, Option 2 and Option 3, Option 3 and Option 4, Option 4 and Option 5; and Option 5 and Option 1.
- the results are then filtered by comparing the set of solutions in a search tree from the pairs of options.
- a binary search tree is illustrated in FIG. 4. An attempt is made to insert each candidate solution into the tree at point X; the sorted nature of the tree allows efficient determination of whether the candidate should be included, and when entries already present should be removed. At the start point X, if the solution is slower and bigger than the prior solution at point X, the candidate solution is discarded.
- point X is discarded, the two subtrees are combined (for example, by attaching point Y at the bottom leftmost point of the Z subtree), and the process is repeated at the new point X (for example, the former Z). If the solution is only faster than the prior solution at point X, it moves down to the left to point Y; if it is only smaller, it moves down to the right to point Z. In either case, the process is repeated at the new point-if slower and bigger, discard; if faster and smaller, delete and combine; if faster, move left, if slower, move right. If the solution reaches the bottom of the tree, it is attached as a new entry.
- the tree When all candidate solutions have been inserted into the tree, the tree contains all useful entries and the others have been discarded.
- the process is efficient because it is logarithmic: the typical candidate is compared against no more than log-to-base-2 of the number of entries in the tree, a number much smaller than the number of candidates.
- the user interface 17 of the present invention includes five different modules or windows. These five modules are solution space module 17 a , a Zoom window module 17 e of the solution space window, a solution point module 17 b , a solution point override module 17 c and an extended solution point module 17 d.
- Step 4 displays the “efficient frontier” solution curve graphically, and allows the user using the user interface 17 to select a solution point in one of two ways.
- the user interface 17 includes a graphical user interface and a display 18 for generating an “efficient frontier” plot or a graph window with cycles being on the vertical axis and bytes being on the horizontal axis.
- the result is a concave curve plot on the display that explicitly represents the candidate performance metric tradeoff (see FIG. 5).
- Each point on the curve represents one potential solution, which is the set of compiler options for each function in the program that can be used to generate an executable that exhibits that performance tradeoff.
- the overall performance of each useful solution may then be graphed. Useful solutions are plotted in between and will form a solution space curve.
- the solution space module receives a list of useful solutions from a solution solver 21 .
- Each solution contains a list of all profitable functions, and for each function, its resulting performance metric (such as code size and number of processor cycles) and what method of compiling the function was used to obtain those results.
- An overall performance for an application program is computed by summing up the performance of each function and then adding in any unprofiled performance. Unprofiled performance for a function may be estimated based upon the unprofiled performance of the original application executables initially profiled. The unprofiled performance of the original executables may differ slightly due to effects from alignment, for example, and in this case, the average is taken.
- the overall performance of each useful solution may then be graphed. Useful solutions are plotted in between and will form a solution space curve.
- the main window of the solution space module 17 a of the user interface 17 is the “solution space” window depicted in FIG. 5. It is presently preferred to be a 2 dimensional graph with the results for one performance metric option, such as a code size, increasing along the X axis and the results for a second performance metric, such as cycle count or speed, increasing along the Y axis.
- the upper left corner represents the smallest code size solution for an application and the lower right represents the fastest (fewest processor cycles) solution curve.
- Useful solutions are plotted in between the smallest code size and the fastest and form the solution space or efficient frontier curve.
- the user By plotting and displaying the solution space curve, the user is allowed to visualize and therefore understand what performance metric tradeoffs, such as code size and speed, are possible for that application.
- the display could display selected results in red for the results for options 1, 2, 3 etc.
- the “efficient frontier” could be in blue.
- a zoom window facility 17 e is provided to allow the user to zoom in on an area of the curve of interest. This zoom facility 17 e allows the user to see an expanded view of a series of contiguous solution points. The expanded view of a series of contiguous solution points in the curve of FIG. 5 is illustrated in FIG. 6. The zoom can be over an area of interest and the user can select the best solution point in that area.
- Step 5 is selecting the solution point by selecting any plotted point with the mouse pointer.
- the selection method 1 is for the user to browse the “efficient frontier” curve and simply select a point on the zoom facility for example through a graphical user interface and the mouse pointer.
- Selection method 2 allows the user to specify an upper bound on any performance metric such as cycle count or size and the system will choose a solution that maximizes the other performance metrics. Either selection method will visualize the exact option sets chosen for each function and provide an interactive mechanism for overriding any functions options set.
- a next step 6 is determining if an override is applied.
- the “efficient frontier” is recomputed by simply rerunning the solver (Step 3 ).
- the compilation/execution/profiling steps need not be iterated.
- the user interface 17 presents the entire graph to the user and allows the user to select the appropriate solution.
- a solution area or point may be selected by highlighting any plotted point with the cursor, using the mouse. Alternatively, the user can input a maximum cycle count or maximum code size, and the smallest or fastest, respectively, solution that meets that constraint will be chosen.
- a solution point module 30 is provided to allow for the presentation of a single solution point from the solver 21 . Once a solution point is found that meets the user's code size and speed requirements, a module is provided to view the details of the selected solution point. The window for this module displays a table with a listing of each function of the application along with columns for its performance (code size and cycles) and the method used to build it, preferably in tabular form. The “solution point” window of FIG. 7 contains this information.
- the column on the far left lists the functions. For each function, there are columns for the function's cycle count, size and method used to build the function (OptionSet and Options). Note the main function has the function set for minimum size in the example. The data within each column can be sorted. This allows the user the flexibility to see what functions have the greatest cycle count or code size.
- the solution point module also exports the necessary information to compile the application program to achieve the results similar to those of the selected solution, via a makefile, preferably on a function-by-function basis.
- a next step 6 is determining if an override is to be applied.
- the system has the added flexibility provided by allowing the user to “override” the method used to build any function.
- the user may override a function (Step 7 ) by selecting a particular method that should always be used in building the function or by giving a rule that tells the solution engine how to pick the method.
- a typical rule is to pick the method of building the function that results in the fastest version or the smallest version.
- a rule is dynamically applied each time the solution engine or solver is used and therefore can select a different method of building the function, if the profile data changes.
- the profile data is a set of inputs and conditions supplied to the application program to simulate its actual operation.
- the “efficient frontier” is recomputed by simply rerunning the solver (Step 3 ).
- the compilation/execution/profiling steps need not be iterated.
- the user interface 17 presents the entire graph to the user and allows the user to select the appropriate solution. From the original methods used to build and profile the application, the solution solver obtains data on how each method affects the performance of each function.
- a solution point override module provides the user a way to display and control what method is employed on a function-by-function basis. When a method is bound to a function via a user selection, the override window removes from the solver's data all of the methods for that function except the bound one.
- the solver always chooses that one and only one method of building that function.
- an override “rule” is applied to a function by a user, the override window does the same thing as above, but will reevaluate which method to keep each time the solver is invoked.
- the override rule is useful if the profiling training set isn't perfectly representative and it is known that a particular function either is or is not speed critical.
- the binding of a method to function is useful if the function isn't invoked during profiling and so no cycle count information is available from which to choose the best method.
- FIG. 8 illustrates an override window. On the left column is the list of functions and on the right is the rule information with selections for maximum speed, aggressive speed, speed, size and minimum size and the estimated cycles and size.
- Step 8 writes the selected solution to a persistent database 25 containing directives to the compiler 13 that control options to be applied individually to each function.
- Step 9 compiles the program using the directives database created in the previous steps. This results in an executable that is then run and profiled to collect actual performance metrics. The resultant performance metrics are presented to the user and compared to the predicted performance metrics.
- the compiler uses the build method recorded from step 5 in any subsequent builds of the program or until the user chooses another build method either by rerunning the system or deleting the database.
- the useful solutions set database generated by the solution engine are only estimations, based upon the profiling information obtained from the different versions of the application actually built. They are not actually built or profiled. Rather, it is assumed that each function will behave identically regardless of surrounding code, and “projects” the performance of a solution point based upon the performance of each function from the profile information. This assumption isn't precisely correct because of alignment padding, no operations (NOPs) between fetch packets, etc. Therefore, the solution points are estimates and can differ from the actual performance.
- the user interface 17 of the present invention preferably allows the user the ability to actually build the solution point selected and compare the actual results with results that were graphed. An “extended solution point” window Step 10 depicted in FIG. 9 will compare the actual with the estimated performance.
- the extended solution point module takes the “makefile” generated by choosing a solution point and feeds it to the compiler to actually build the solution selected.
- the profiler then profiles the resulting executable, collecting the same profile information as for the original executables. It then presents an overall view and a function level view.
- the overall performance of the built solution is computed in the same manner as described in the solution space module. This overall performance result may be textually compared to the overall performance of the point chosen in a solution space module.
- each function may be listed and along with it, both the actual (profiled) and estimated (plotted) performance of that function listed in a tabular format, along with columns that contain the difference between the actual and estimated results.
- FIG. 9 illustrates on the top left the estimates of cycles, size, unprofiled cycles, unprofiled size and the total size and cycles. The top right presents the same information for actual or profiled cycles, size, etc. On the bottom left column is the listing of the functions. The next columns to the right is presented the estimated cycles, estimated sizes, the OptionSet, the actual cycles, actual size and the error or delta for each function. Note that for the top function the size error because the actual size was larger than estimated.
- the solution is installed as the default build method for the program. Otherwise, the user iterates from step 4 .
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
A method of generating profiled optimized code using user interface (17) that allows a user to visually understand, inspect, and manipulate a compiled application program as a function of compiler options, such as, code size and speed, is provided. A program (11) is compiled in a compiler (13) with two or more compiler options such as size and speed and the resulting executables (14) are profiled (15). The results of the profiles (19) are analyed in a solver (21) for generating sets of useful solutions (23) wherein the sets have methods of compiling at the function level. The useful solutions (23) are displayed (18) at the user interface (17) to allow the user to visually understand, inspect and manipulate compiler options to select compiler options (13 a) for the program.
Description
- This application is a continuation-in-part of applications Ser. No. 09/668,794, filed Sep. 22, 1900 entitled “Method of Generating Profiled Optimized Code” of Tatge et al.; application Ser. No. 09/510,217 filed Feb. 22, 1900 entitled “User Interface For Making Compiler Tradeoffs of Ward et al.; and application Ser. No. 09/510,216 filed 2/22/00 entitled “Method of Generating Profiled Optimized Code of Bartley et al. These applications are incorporated herein by reference
- This invention relates to a method for compiling code and more particularly, to using profile data generated from sample runs compiled with different compiler options to guide the set of options to be used for each function.
- For some time, the technique of using the runtime performance of a program to guide optimizations has been discussed in the literature and occasionally implemented in production compilers. This technique is generally referred to as “profile-based optimization.” The goal is to identify those paths through a program which are executed the most frequently, and to apply more aggressive optimization techniques to those critical sections of code to make them execute faster.
- In an embedded environment, not only is speed important, but the size of the generated code is often a critical cost issue. Therefore, it is necessary to balance the concerns of speed versus space. Simply identifying the time-critical code and applying aggressive optimization to it is not enough. We must optimize part of the code to be fast, and part of the code to be small, while constraining the total program size so that it fits in the available target memory. The goal is to be able to speed optimize as much of the critical part of the program as possible without violating the size constraint.
- It is a generally observed phenomenon that a large portion of the execution time of a program is generally spent in a small portion of the actual code. This is what makes profile-based optimization effective: it allows you to predict which parts of the code are speed critical, and to selectively apply more aggressive speed or size optimization.
- Compiling for speed on a Very Long Instruction. Word (VLIW) architecture potentially leads to significant code size growth. Compiling for size on a VLIW results in significant speed degradation. If we simply compile everything for speed, the code may grow beyond what is available on the target memory. If we simply compile for space, the resulting performance is unacceptable.
- Compiler optimization control flags generally work on a whole source module. The typical development scenario is to compile, run, and profile a program, then recompile modules based on the feedback provided by the profiler: compile some modules for speed, some for size.
- In accordance with one embodiment of the present invention, a program is compiled with two or more sets of compiler options, and each resulting executable is profiled. The results of all the profiles are used as input to a program which will analyze the profile data, and given constraints will generate a solution which will be a list of each function in the application, and the set of compiler options to use for each function in order to satisfy the given constraints.
- FIG. 1 illustrates the system according to one embodiment of the present invention;
- FIG. 2 illustrates the method according to one embodiment of the present invention;
- FIG. 3 illustrates linear solution generation;
- FIG. 4 illustrates search tree;
- FIG. 5 illustrates a chart of speed (cycle) versus size (bytes);
- FIG. 6 illustrates a zoom area expansion of part of the chart of FIG. 5;
- FIG. 7 illustrates a solution point window;
- FIG. 8 illustrates an override window; and
- FIG. 9 illustrates extended solution point window.
- A standard compiler takes code (such as C) and compiles it, generating object code. A compiler may be controlled with compiler options so it generates code which will, for example, run as fast as possible or may be controlled to generate code which is as small as possible. The goal of this invention is to automatically choose compiler options for each function in a program to optimally balance system constraints such as size and speed. This set of options is referred to as the “solution” for the program.
- Referring to FIG. 1, there is illustrated a
system 10 according to one embodiment of the present invention. The method performed by the system is illustrated in FIG. 2. Code such as C code fromsource 11 is compiled incompiler 13 resulting in executable code. In accordance with the method and the system as illustrated in FIG. 1 and FIG. 2, the first step (Step 1) in the process is that the whole program is compiled several times in thecompiler 13, each time with different compiling option. For example, the options may be for minimum size at all cost, for size with moderate speed cost, for speed, for aggressive speed or maximum speed at all cost. The option sets are chosen at control 13 a by the user using agraphical user interface 17 to optimize the different performance metrics such as maximum speed or minimum size. The initial steps for generating the information used by theuser interface 17 is providing said application program, and an associated database for exercising said program, providing a compiler, for compiling said application program, having compiling options. The result of the compiling step is a set of executable objects, one for each option set. The resulting executable objects are represented byexecutable 1,executable 2,executable 3, etc. in FIG. 1 that correspond tooption 1,option 2,option 3, etc. The executable objects may be stored in an executable database and are applied to aprofiler 15. - The next step (Step2) is to execute each version or executable object of the program produced in
Step 1, producing profile information for each version or executable. Theuser interface 17 provides aprofiler 15 for extracting information related to said compiled application program from different compiling options, but using the same associated database, creating a profiler database 19 based upon said extracted information. Theprofiler 15 includes a simulator 15 a to run the executable to provide a profile of the program. Each “profile” contains measured performance metrics for each function in the program (such as size, power consumed, and cycles consumed.). This is represented by theprofile 1,profile 2, andprofile 3 in FIG. 1 whereprofile 1 corresponds to the profile ofrun executable 1,profile 2 corresponds to the profile ofrun executable 2,profile 3 corresponds to the profile ofexecutable 3. Theprofiler 15 may be a standalone simulator that records run-time information. An application program typically comprises several different functions that are used to perform the activities an application program is to perform. Each method of building an application can result in an executable version of the program application that exhibits different results, such as, code size and processor cycle count or speed behavior. When an application is built using several different methods, each resulting version of the application can be profiled by the profiler at the function level for its results over a consistent input set, collecting compiled code size and execution cycles for the functions of the program. Profile data collected by running the program and recording the time spent in each function can indicate which parts of the program deserve speed versus size consideration. The program must remain the same in all profile runs, and the profile runs must all do the same thing on all the same data. The resulting set of profile information describes the effects that each method has on each profilable function; for the example discussed above, this is in terms of code size and number of cycles executed for each function of the application program. If the method changes at the function level (from function to function), the term “solution” is used to represent a specific assignment of methods to each function of the compiled program. - As an example of profile data illustrated in the table below, a program consists of 3 functions F1, F2, and F3. When compiled with options set 1, the functions have the respective sizes of A1, A2, and A3, and the execution times of B1, B2, and B3. When compiled with options set 2, the 3 functions have respective sizes C1, C2, and C3, and respective execution times of D1, D2, and D3. The compilation of this program by the system will create two profile sets, corresponding to the two options sets (
options 1 and options 2). -
Profile 1 consists of the following data: - F1: size=A1 cycles=B1
- F2: size=A2 cycles=B2
- F3: size=A3 cycles=B3
-
Profile 2 consists of the following data: - F1: size=C1 cycles=D1
- F2: size=C2 cycles=D2
- F3: size=C3 cycles=
D3 Options 1 Options 2Size Cycles Size Cycles F1 A1 B1 C1 D1 F2 A2 B2 C2 D2 F3 A3 B3 C3 D3 - While the example has only three functions in actual practice the program may have many more functions and run many profiles. With just four functions and two profiles or options there are 16 possible combinations. An application with only 165 functions and three profiles or three options would have 10 to the power of 79 possible combinations. It is easy to see that selecting the best combination can take lots of time and effort. Applicant's present invention provides a method and system to assist in that selection.
- Every individual function trade-off can be considered to produce a solution. All possible permutations of trade-offs over the whole set of profile runs may be saved in memory or at least the most desirable. The profile data is stored in memory19 of FIG. 1.
-
Step 3, provides asolution solver 21 for generating estimated solutions from said profiler database. Asolution engine 21 uses this profiling information to evaluate the permutations of varying methods at the function level to compute all of the useful solutions. A solution is “useful”, if no other solution results in a version of the application that is better optimized for a specific result, such as, for example, faster and smaller in code size than it. Theuser interface 17 creates asolution database 23 based upon solutions from saidsolver 21 from extracted information. The solver orsolution engine 21, uses linear programming and heuristics to reduce the total number of permutations of option sets per function to an “efficient frontier” which is the set of potential solutions for which there are no other solutions that are better in all performance metrics, such as size and speed. The “efficient frontier” represents the best set of compile options for the set of functions to produce the best set of potential solutions. The fundamental unit in thesolver 21 is the function record, which contains the time and size information for a single function in a single profile. Each profile is represented as a sequence of function records F1, F2, F3, etc. one for each function. Thesolver 21 operates on a matrix of function records, each row containing the records for one function, each column containing the records for one profile. To form a solution, thesolver 21 picks one function record from each row; choosing from different columns implements the node interchange. - The solver process has two stages. The first is generating possible solutions and the second is filtering the possible solutions. The process of forming the solution curve is essentially a search problem; it divides nicely into generating solution from the function matrix, and evaluating them to determine which are useful. We want to avoid brute-force generation, since the numbers are extremely large. The vast majority of these solutions will be useless. It's important both to reduce the number generated and to efficiently discard the useless ones.
- We can reduce the space considerably by an initial filtering step. One way is to convert the function matrix into a two-column matrix where one column contains the fastest version of each function and the other contains the smallest, thus distilling the essential trade-off of time and size. This two-column matrix is most useful when considering the evaluation process as a 0-1 integer programming problem, but is less useful for producing the entire solution curve.
- A second method is to remove from each row all function records that are themselves useless. In many instances, records will be identical (and the duplicates can be removed) or one or more will be clearly inferior (their time and size are both greater than the others). This filtering method mirrors the evaluation of solutions: only points on the lower contour of the speed/size plot are retained.
- Following the initial filtering, solutions can be generated in several ways. The best heuristic for our purposes we call “linear approximation” (FIG. 3). The
linear solver 21 sorts the rows of the filtered matrix and then moves a small window down the rows, only considering possibilities that involve choices within the window. In its simplest form, with two columns and a one-row window, the choices would be to take the function in column A or in the one in column B; after the choice, the choice is made on the next row, and so on. Rows above the window are left in column B, rows below it in column A. It is linear because the number of solutions generated is directly proportional to the number of rows in the matrix. - In actual use, the window is eight rows so we have 256 choices at each step; there may be more than two columns so we use each pair of columns in turn; and there are two or more sort functions so we make that many passes over the entire matrix. All these details serve to generate permutations that are likely to be useful, without generating all of them. The permutations—the solutions—are filtered to collect a list of useful solutions, which in practice is very nearly the same as the list formed by an exhaustive approach. The filtering process, both the initial filter and the solution filter, uses a binary search tree. For the five profiles such as
Option 1 for speed,Option 2 for size,Option 3 for minimum size,Option 4 for maximum speed, andOption 5 for aggressive speed. The two column pair choices are forexample Option 1 andOption 2,Option 2 andOption 3,Option 3 andOption 4,Option 4 andOption 5; andOption 5 andOption 1. The results are then filtered by comparing the set of solutions in a search tree from the pairs of options. A binary search tree is illustrated in FIG. 4. An attempt is made to insert each candidate solution into the tree at point X; the sorted nature of the tree allows efficient determination of whether the candidate should be included, and when entries already present should be removed. At the start point X, if the solution is slower and bigger than the prior solution at point X, the candidate solution is discarded. If the solution is faster and smaller than the prior solution at point X, point X is discarded, the two subtrees are combined (for example, by attaching point Y at the bottom leftmost point of the Z subtree), and the process is repeated at the new point X (for example, the former Z). If the solution is only faster than the prior solution at point X, it moves down to the left to point Y; if it is only smaller, it moves down to the right to point Z. In either case, the process is repeated at the new point-if slower and bigger, discard; if faster and smaller, delete and combine; if faster, move left, if slower, move right. If the solution reaches the bottom of the tree, it is attached as a new entry. When all candidate solutions have been inserted into the tree, the tree contains all useful entries and the others have been discarded. The process is efficient because it is logarithmic: the typical candidate is compared against no more than log-to-base-2 of the number of entries in the tree, a number much smaller than the number of candidates. - The
user interface 17 of the present invention includes five different modules or windows. These five modules are solution space module 17 a, a Zoom window module 17 e of the solution space window, a solution point module 17 b, a solution point override module 17 c and an extended solution point module 17 d. -
Step 4 displays the “efficient frontier” solution curve graphically, and allows the user using theuser interface 17 to select a solution point in one of two ways. Theuser interface 17 includes a graphical user interface and adisplay 18 for generating an “efficient frontier” plot or a graph window with cycles being on the vertical axis and bytes being on the horizontal axis. The result is a concave curve plot on the display that explicitly represents the candidate performance metric tradeoff (see FIG. 5). Each point on the curve represents one potential solution, which is the set of compiler options for each function in the program that can be used to generate an executable that exhibits that performance tradeoff. The overall performance of each useful solution may then be graphed. Useful solutions are plotted in between and will form a solution space curve. The solution space module receives a list of useful solutions from asolution solver 21. Each solution contains a list of all profitable functions, and for each function, its resulting performance metric (such as code size and number of processor cycles) and what method of compiling the function was used to obtain those results. An overall performance for an application program is computed by summing up the performance of each function and then adding in any unprofiled performance. Unprofiled performance for a function may be estimated based upon the unprofiled performance of the original application executables initially profiled. The unprofiled performance of the original executables may differ slightly due to effects from alignment, for example, and in this case, the average is taken. The overall performance of each useful solution may then be graphed. Useful solutions are plotted in between and will form a solution space curve. - The main window of the solution space module17 a of the
user interface 17 is the “solution space” window depicted in FIG. 5. It is presently preferred to be a 2 dimensional graph with the results for one performance metric option, such as a code size, increasing along the X axis and the results for a second performance metric, such as cycle count or speed, increasing along the Y axis. Thus, for example, the upper left corner represents the smallest code size solution for an application and the lower right represents the fastest (fewest processor cycles) solution curve. Useful solutions are plotted in between the smallest code size and the fastest and form the solution space or efficient frontier curve. By plotting and displaying the solution space curve, the user is allowed to visualize and therefore understand what performance metric tradeoffs, such as code size and speed, are possible for that application. The display could display selected results in red for the results foroptions - If the solution space contains many useful solutions, the curve will not look like a series of points, but rather like a continuous blue line. A zoom window facility17 e is provided to allow the user to zoom in on an area of the curve of interest. This zoom facility 17 e allows the user to see an expanded view of a series of contiguous solution points. The expanded view of a series of contiguous solution points in the curve of FIG. 5 is illustrated in FIG. 6. The zoom can be over an area of interest and the user can select the best solution point in that area.
- Holding the mouse pointer over any solution point in the graph will display the exact code size and speed characteristics for that solution. The original versions of the application that were built to generate the profiling information may also be plotted, but in some unique representation, such as, in a different color. This helps the user understand the improvements that this process can bring to an application.
-
Step 5 is selecting the solution point by selecting any plotted point with the mouse pointer. Theselection method 1 is for the user to browse the “efficient frontier” curve and simply select a point on the zoom facility for example through a graphical user interface and the mouse pointer.Selection method 2 allows the user to specify an upper bound on any performance metric such as cycle count or size and the system will choose a solution that maximizes the other performance metrics. Either selection method will visualize the exact option sets chosen for each function and provide an interactive mechanism for overriding any functions options set. - A
next step 6 is determining if an override is applied. - If an override module is applied, the “efficient frontier” is recomputed by simply rerunning the solver (Step3). The compilation/execution/profiling steps need not be iterated. The
user interface 17 presents the entire graph to the user and allows the user to select the appropriate solution. - A solution area or point may be selected by highlighting any plotted point with the cursor, using the mouse. Alternatively, the user can input a maximum cycle count or maximum code size, and the smallest or fastest, respectively, solution that meets that constraint will be chosen. A solution point module30 is provided to allow for the presentation of a single solution point from the
solver 21. Once a solution point is found that meets the user's code size and speed requirements, a module is provided to view the details of the selected solution point. The window for this module displays a table with a listing of each function of the application along with columns for its performance (code size and cycles) and the method used to build it, preferably in tabular form. The “solution point” window of FIG. 7 contains this information. The column on the far left lists the functions. For each function, there are columns for the function's cycle count, size and method used to build the function (OptionSet and Options). Note the main function has the function set for minimum size in the example. The data within each column can be sorted. This allows the user the flexibility to see what functions have the greatest cycle count or code size. - Once a solution point is selected, the solution point module also exports the necessary information to compile the application program to achieve the results similar to those of the selected solution, via a makefile, preferably on a function-by-function basis.
- A
next step 6 is determining if an override is to be applied. The system has the added flexibility provided by allowing the user to “override” the method used to build any function. The user may override a function (Step 7) by selecting a particular method that should always be used in building the function or by giving a rule that tells the solution engine how to pick the method. A typical rule is to pick the method of building the function that results in the fastest version or the smallest version. A rule is dynamically applied each time the solution engine or solver is used and therefore can select a different method of building the function, if the profile data changes. The profile data is a set of inputs and conditions supplied to the application program to simulate its actual operation. - If an override module is applied, the “efficient frontier” is recomputed by simply rerunning the solver (Step3). The compilation/execution/profiling steps need not be iterated. The
user interface 17 presents the entire graph to the user and allows the user to select the appropriate solution. From the original methods used to build and profile the application, the solution solver obtains data on how each method affects the performance of each function. A solution point override module provides the user a way to display and control what method is employed on a function-by-function basis. When a method is bound to a function via a user selection, the override window removes from the solver's data all of the methods for that function except the bound one. Thus, the solver always chooses that one and only one method of building that function. When an override “rule” is applied to a function by a user, the override window does the same thing as above, but will reevaluate which method to keep each time the solver is invoked. - The override rule is useful if the profiling training set isn't perfectly representative and it is known that a particular function either is or is not speed critical. The binding of a method to function is useful if the function isn't invoked during profiling and so no cycle count information is available from which to choose the best method. FIG. 8 illustrates an override window. On the left column is the list of functions and on the right is the rule information with selections for maximum speed, aggressive speed, speed, size and minimum size and the estimated cycles and size.
- Step8 writes the selected solution to a
persistent database 25 containing directives to thecompiler 13 that control options to be applied individually to each function. - Step9 compiles the program using the directives database created in the previous steps. This results in an executable that is then run and profiled to collect actual performance metrics. The resultant performance metrics are presented to the user and compared to the predicted performance metrics. In step 9 the compiler uses the build method recorded from
step 5 in any subsequent builds of the program or until the user chooses another build method either by rerunning the system or deleting the database. - The useful solutions set database generated by the solution engine are only estimations, based upon the profiling information obtained from the different versions of the application actually built. They are not actually built or profiled. Rather, it is assumed that each function will behave identically regardless of surrounding code, and “projects” the performance of a solution point based upon the performance of each function from the profile information. This assumption isn't precisely correct because of alignment padding, no operations (NOPs) between fetch packets, etc. Therefore, the solution points are estimates and can differ from the actual performance. The
user interface 17 of the present invention preferably allows the user the ability to actually build the solution point selected and compare the actual results with results that were graphed. An “extended solution point”window Step 10 depicted in FIG. 9 will compare the actual with the estimated performance. - The extended solution point module takes the “makefile” generated by choosing a solution point and feeds it to the compiler to actually build the solution selected. The profiler then profiles the resulting executable, collecting the same profile information as for the original executables. It then presents an overall view and a function level view.
- The overall performance of the built solution is computed in the same manner as described in the solution space module. This overall performance result may be textually compared to the overall performance of the point chosen in a solution space module. In addition, each function may be listed and along with it, both the actual (profiled) and estimated (plotted) performance of that function listed in a tabular format, along with columns that contain the difference between the actual and estimated results.
- Optionally, it will also display a function table containing columns for actual code size, actual cycle counts, estimated code size, estimated cycle counts, delta code size (between actual and estimate) and delta cycle counts. FIG. 9 illustrates on the top left the estimates of cycles, size, unprofiled cycles, unprofiled size and the total size and cycles. The top right presents the same information for actual or profiled cycles, size, etc. On the bottom left column is the listing of the functions. The next columns to the right is presented the estimated cycles, estimated sizes, the OptionSet, the actual cycles, actual size and the error or delta for each function. Note that for the top function the size error because the actual size was larger than estimated.
- If the solution is acceptable to the user, the solution is installed as the default build method for the program. Otherwise, the user iterates from
step 4. - While this invention has been described with reference to illustrative embodiments, this description is not intended to be construed in a limiting sense. Various modifications and combinations of the illustrative embodiments, as well as other embodiments of the invention, will be apparent to persons skilled in the art upon reference to the description. It is therefore intended that the appended claims encompass any such modifications or embodiments.
Claims (23)
1. A method for compiling an application program in an optimum manner, comprising:
compiling said application with a different set of compiler options to provide two or more executables,
generating profile information from said executables, and
selecting compiler options for said application program based upon said profile information.
2. The method of , wherein said set of computer options is selected from speed, code size, and power.
claim 1
3. A method for compiling an application program in an optimum manner, comprising:
compiling said application program with a first set of compiler options to provide a first executable,
compiling said application program with a second set of compiler options to provide a second executable, generating profile information from said first and second executables, and
selecting compiler options for each function of said application program so as to optimize said application program as a function of desired profile information.
4. The method of , wherein said first set of options is for speed.
claim 3
5. The method of , wherein said second set of options is for code size.
claim 3
6. The method of , further comprising, analyzing said profile information against user supplied constraints for selecting said compiler options by function.
claim 3
7. A solution space generator, comprising:
means for reading profiler information, and
means for generating useful solutions of a solution set derived from profiler information.
8. The generation of , further comprising:
claim 7
means for providing a display of said useful solutions.
9. The generation of , further comprising:
claim 8
means for selecting one of said solutions and using said solution for subsequent compile of an application program.
10. A method for compiling an application program comprising the steps of: computing said application with a different set of compiler options to provide two or more executables; generating profile information from said executables; applying said profile information to a solver; generating sets of useful solutions from said profile information wherein the sets have methods of compiling at the function level; and selecting compiler options for said application program using said useful solutions for subsequent compiling of said application.
11. The method of wherein said selecting step includes displaying said useful solutions.
claim 10
12. The method of wherein said generating step includes generating an efficient frontier curve of optimum solution points and displaying said curve of solution points.
claim 10
13. The method of wherein said generating step includes a zoom window of a section of said curve of solution points.
claim 12
14. The method of wherein said generating step includes linear programming and heuristics to reduce the number of permutations of option sets per function.
claim 10
15. The method of wherein said generating solutions step generates possible solutions step generates possible solutions and filters the possible solutions.
claim 10
16. The method of wherein said generating solutions includes a search tree wherein each candidate is applied to a node and compared to the solution at the node and if faster in time and smaller in size replacing that candidate at the node, if neither faster nor smaller in size discarding the candidate, if faster only processing down the tree in one direction and if smaller only processing down the tree in a different direction.
claim 10
17. The method of wherein the step of selecting compiling option includes displaying a solution point on said solution point curve illustrating for each function the compiling information of size and cycles and method of compiling.
claim 10
18. The method of including means for displaying a solution point on said solution point curve and means for displaying and overriding a compiling function solution after displaying a selected solution point and thereafter redisplaying the results.
claim 10
19. The method of including the step after compiling of displaying by function the difference between the expected results and the actual results.
claim 17
20. A user interface for displaying and controlling the results of compiling an application program with a compiler having a preselected number of compiling options, comprising:
a module for displaying at least a portion of solution information as a function of said selected compiling options and for selecting at least one displayed solution, and a module for outputting, for a selected solution, compiler information to allow for said application program to be compiled in a manner consistent with said selected solution.
21. A user interface for displaying and controlling the results of compiling an application program with a compiler having a preselected number of compiling options, comprising:
a module for displaying at least a portion of information as a function of selected performance metrics and for selecting at least one displayed solution, and
a module for outputting, for a selected solution, compiler information to allow for said application program to be compiled in a manner consistent with said selected solution.
22. The user interface of , further comprising:
claim 21
a module for selecting and fixing instructions for a solver that generates said solutions information.
23. The user interface of , further comprising:
claim 22
a module for compiling said application program in a manner consistent with said selected solution and for comparing the results with said selected solution.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/761,152 US6922829B2 (en) | 1999-10-12 | 2001-01-17 | Method of generating profile-optimized code |
Applications Claiming Priority (5)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US15836399P | 1999-10-12 | 1999-10-12 | |
US51021600A | 2000-02-22 | 2000-02-22 | |
US09/510,217 US6718544B1 (en) | 2000-02-22 | 2000-02-22 | User interface for making compiler tradeoffs |
US66879400A | 2000-09-22 | 2000-09-22 | |
US09/761,152 US6922829B2 (en) | 1999-10-12 | 2001-01-17 | Method of generating profile-optimized code |
Related Parent Applications (3)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/510,217 Continuation-In-Part US6718544B1 (en) | 1999-10-12 | 2000-02-22 | User interface for making compiler tradeoffs |
US51021600A Continuation-In-Part | 1999-10-12 | 2000-02-22 | |
US66879400A Continuation-In-Part | 1999-10-12 | 2000-09-22 |
Publications (2)
Publication Number | Publication Date |
---|---|
US20010032332A1 true US20010032332A1 (en) | 2001-10-18 |
US6922829B2 US6922829B2 (en) | 2005-07-26 |
Family
ID=27496336
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/761,152 Expired - Lifetime US6922829B2 (en) | 1999-10-12 | 2001-01-17 | Method of generating profile-optimized code |
Country Status (1)
Country | Link |
---|---|
US (1) | US6922829B2 (en) |
Cited By (30)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030066060A1 (en) * | 2001-09-28 | 2003-04-03 | Ford Richard L. | Cross profile guided optimization of program execution |
US20030140334A1 (en) * | 2001-12-13 | 2003-07-24 | Granston Elana D. | Method for selective solicitation of user assistance in the performance tuning process |
WO2004061586A2 (en) * | 2002-12-17 | 2004-07-22 | Bea Systems, Inc. | Iterative code optimization using adaptive size metrics |
US20060177008A1 (en) * | 2005-02-07 | 2006-08-10 | David Forney | Extensible diagnostic tool |
US20060236310A1 (en) * | 2005-04-19 | 2006-10-19 | Domeika Max J | Methods and apparatus to iteratively compile software to meet user-defined criteria |
US20070006157A1 (en) * | 2003-10-23 | 2007-01-04 | Fujitsu Limited | Software development tool program |
US20070079294A1 (en) * | 2005-09-30 | 2007-04-05 | Robert Knight | Profiling using a user-level control mechanism |
US20070103348A1 (en) * | 2005-11-04 | 2007-05-10 | Sun Microsystems, Inc. | Threshold search failure analysis |
US20070169004A1 (en) * | 2005-11-04 | 2007-07-19 | Sun Microsystems, Inc. | Automatic failure analysis of code development options |
US20070168969A1 (en) * | 2005-11-04 | 2007-07-19 | Sun Microsystems, Inc. | Module search failure analysis |
US20070204260A1 (en) * | 2006-02-24 | 2007-08-30 | Oki Electric Industry Co., Ltd. | Program transformation system |
US20080155521A1 (en) * | 2006-12-22 | 2008-06-26 | Nokia Corporation | System, Method, Apparatus and Computer Program Product for Providing Memory Footprint Reduction |
WO2008113681A1 (en) * | 2007-03-20 | 2008-09-25 | Siemens Aktiengesellschaft | Method for the computer-aided determination of an optimization potential of a software system |
US20080244529A1 (en) * | 2003-08-06 | 2008-10-02 | International Business Machines Corporation | Profile normalization in an autonomic software system |
US20080250399A1 (en) * | 2005-12-30 | 2008-10-09 | Bo Huang | Evaluation and Selection of Programming Code |
US20090083722A1 (en) * | 2007-09-26 | 2009-03-26 | Eichenberger Alexandre E | System and Method for Stable Transitions in the Presence of Conditionals for an Advanced Dual-Representation Polyhedral Loop Transformation Framework |
US20090083724A1 (en) * | 2007-09-26 | 2009-03-26 | Eichenberger Alexandre E | System and Method for Advanced Polyhedral Loop Transformations of Source Code in a Compiler |
US20090307673A1 (en) * | 2007-09-26 | 2009-12-10 | Eichenberger Alexandre E | System and Method for Domain Stretching for an Advanced Dual-Representation Polyhedral Loop Transformation Framework |
US20090313615A1 (en) * | 2008-06-16 | 2009-12-17 | International Business Machines Corporation | Policy-based program optimization to minimize environmental impact of software execution |
US20110276945A1 (en) * | 2010-05-07 | 2011-11-10 | Salesforce.Com, Inc. | Validating Visual Components |
US8087010B2 (en) | 2007-09-26 | 2011-12-27 | International Business Machines Corporation | Selective code generation optimization for an advanced dual-representation polyhedral loop transformation framework |
US8321262B1 (en) * | 2008-06-04 | 2012-11-27 | Pros, Inc. | Method and system for generating pricing recommendations |
US20130227531A1 (en) * | 2012-02-24 | 2013-08-29 | Zynga Inc. | Methods and Systems for Modifying A Compiler to Generate A Profile of A Source Code |
US8612958B2 (en) | 2008-12-25 | 2013-12-17 | Panasonic Corporation | Program converting apparatus and program conversion method |
US8713530B2 (en) | 2010-05-13 | 2014-04-29 | Salesforce.Com, Inc. | Test framework of visual components in a multitenant database environment |
WO2014200362A1 (en) * | 2013-06-11 | 2014-12-18 | Smart Research Limited | Method and computer program for generating or manipulating source code |
US9009669B2 (en) | 2010-05-07 | 2015-04-14 | Salesforce.Com, Inc. | Visual user interface validator |
US20150227448A1 (en) * | 2014-02-13 | 2015-08-13 | Infosys Limited | Methods of software performance evaluation by run-time assembly code execution and devices thereof |
US9235390B1 (en) * | 2008-03-31 | 2016-01-12 | Symantec Corporation | Application optimization for use based on feature popularity |
US20170115972A1 (en) * | 2015-10-21 | 2017-04-27 | Lsis Co., Ltd. | Method of optimally compiling plc command |
Families Citing this family (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7172814B2 (en) | 2003-06-03 | 2007-02-06 | Bio-Tec Biologische Naturverpackungen Gmbh & Co | Fibrous sheets coated or impregnated with biodegradable polymers or polymers blends |
US20070089104A1 (en) * | 2005-10-13 | 2007-04-19 | Arie Tal | Method and system for managing heuristic properties |
US8141039B2 (en) * | 2006-04-28 | 2012-03-20 | International Business Machines Corporation | Method and system for consolidating machine readable code |
US20080034349A1 (en) * | 2006-08-04 | 2008-02-07 | Microsoft Corporation | Incremental program modification based on usage data |
US8595711B2 (en) * | 2006-11-14 | 2013-11-26 | Red Hat, Inc. | Function-level compiler processing optimization |
US7926036B2 (en) * | 2007-04-26 | 2011-04-12 | Microsoft Corporation | Technologies for code failure proneness estimation |
US20090125880A1 (en) * | 2007-11-12 | 2009-05-14 | Microsoft Corporation | Polymorphic software architecture |
US7683902B1 (en) | 2009-03-27 | 2010-03-23 | International Business Machines Corporation | Method to visualize performance data of a multi-layered state diagram |
US9792325B2 (en) * | 2013-08-25 | 2017-10-17 | Microsoft Technology Licensing, Llc | Continuous cloud-scale query optimization and processing |
JP2015069220A (en) * | 2013-09-26 | 2015-04-13 | 富士通株式会社 | Device, method, and program for generating performance evaluation program |
Citations (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5189633A (en) * | 1990-01-12 | 1993-02-23 | Bonadio Allan R | Apparatus and method for interactively manipulating mathematical equations |
US5353410A (en) * | 1992-03-18 | 1994-10-04 | International Business Machines Corporation | Method and system for deferred read in lazy-write disk cache systems |
US5535391A (en) * | 1992-06-05 | 1996-07-09 | Borland International, Inc. | System and methods for optimizing object-oriented compilations |
US5815720A (en) * | 1996-03-15 | 1998-09-29 | Institute For The Development Of Emerging Architectures, L.L.C. | Use of dynamic translation to collect and exploit run-time information in an optimizing compilation system |
US5933643A (en) * | 1997-04-17 | 1999-08-03 | Hewlett Packard Company | Profiler driven data prefetching optimization where code generation not performed for loops |
US5966538A (en) * | 1997-10-31 | 1999-10-12 | Hewlett-Packard Company | Method and apparatus for automatically determining which compiler options should be used when compiling a computer program |
US5978795A (en) * | 1997-01-14 | 1999-11-02 | Microsoft Corporation | Temporally ordered binary search method and system |
US6047277A (en) * | 1997-06-19 | 2000-04-04 | Parry; Michael H. | Self-organizing neural network for plain text categorization |
US6295641B1 (en) * | 1998-12-03 | 2001-09-25 | International Business Machines Corporation | Method and apparatus for dynamically selecting bytecodes for just in time compiling in a user's environment |
US6360360B1 (en) * | 1996-02-08 | 2002-03-19 | International Business Machines Corporation | Object-oriented compiler mechanism for automatically selecting among multiple implementations of objects |
US6427234B1 (en) * | 1998-06-11 | 2002-07-30 | University Of Washington | System and method for performing selective dynamic compilation using run-time information |
US6509898B2 (en) * | 1998-04-17 | 2003-01-21 | Xerox Corporation | Usage based methods of traversing and displaying generalized graph structures |
-
2001
- 2001-01-17 US US09/761,152 patent/US6922829B2/en not_active Expired - Lifetime
Patent Citations (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5189633A (en) * | 1990-01-12 | 1993-02-23 | Bonadio Allan R | Apparatus and method for interactively manipulating mathematical equations |
US5353410A (en) * | 1992-03-18 | 1994-10-04 | International Business Machines Corporation | Method and system for deferred read in lazy-write disk cache systems |
US5535391A (en) * | 1992-06-05 | 1996-07-09 | Borland International, Inc. | System and methods for optimizing object-oriented compilations |
US6360360B1 (en) * | 1996-02-08 | 2002-03-19 | International Business Machines Corporation | Object-oriented compiler mechanism for automatically selecting among multiple implementations of objects |
US5815720A (en) * | 1996-03-15 | 1998-09-29 | Institute For The Development Of Emerging Architectures, L.L.C. | Use of dynamic translation to collect and exploit run-time information in an optimizing compilation system |
US5978795A (en) * | 1997-01-14 | 1999-11-02 | Microsoft Corporation | Temporally ordered binary search method and system |
US5933643A (en) * | 1997-04-17 | 1999-08-03 | Hewlett Packard Company | Profiler driven data prefetching optimization where code generation not performed for loops |
US6047277A (en) * | 1997-06-19 | 2000-04-04 | Parry; Michael H. | Self-organizing neural network for plain text categorization |
US5966538A (en) * | 1997-10-31 | 1999-10-12 | Hewlett-Packard Company | Method and apparatus for automatically determining which compiler options should be used when compiling a computer program |
US6509898B2 (en) * | 1998-04-17 | 2003-01-21 | Xerox Corporation | Usage based methods of traversing and displaying generalized graph structures |
US6427234B1 (en) * | 1998-06-11 | 2002-07-30 | University Of Washington | System and method for performing selective dynamic compilation using run-time information |
US6295641B1 (en) * | 1998-12-03 | 2001-09-25 | International Business Machines Corporation | Method and apparatus for dynamically selecting bytecodes for just in time compiling in a user's environment |
Cited By (52)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030066060A1 (en) * | 2001-09-28 | 2003-04-03 | Ford Richard L. | Cross profile guided optimization of program execution |
US20030140334A1 (en) * | 2001-12-13 | 2003-07-24 | Granston Elana D. | Method for selective solicitation of user assistance in the performance tuning process |
US7237234B2 (en) * | 2001-12-13 | 2007-06-26 | Texas Instruments Incorporated | Method for selective solicitation of user assistance in the performance tuning process |
WO2004061586A2 (en) * | 2002-12-17 | 2004-07-22 | Bea Systems, Inc. | Iterative code optimization using adaptive size metrics |
WO2004061586A3 (en) * | 2002-12-17 | 2004-11-04 | Bea Systems Inc | Iterative code optimization using adaptive size metrics |
US6964042B2 (en) | 2002-12-17 | 2005-11-08 | Bea Systems, Inc. | System and method for iterative code optimization using adaptive size metrics |
US7610580B2 (en) | 2002-12-17 | 2009-10-27 | Bea Systems, Inc. | System and method for iterative code optimization using adaptive size metrics |
US20080244529A1 (en) * | 2003-08-06 | 2008-10-02 | International Business Machines Corporation | Profile normalization in an autonomic software system |
US8356291B2 (en) * | 2003-08-06 | 2013-01-15 | International Business Machines Corporation | Profile normalization in an autonomic software system |
US8621449B2 (en) | 2003-08-06 | 2013-12-31 | International Business Machines Corporation | Profile normalization in an autonomic software system |
US20080244548A1 (en) * | 2003-08-06 | 2008-10-02 | International Business Machines Corporation | Profile normalization in an autonomic software system |
US20070006157A1 (en) * | 2003-10-23 | 2007-01-04 | Fujitsu Limited | Software development tool program |
US7765535B2 (en) | 2003-10-23 | 2010-07-27 | Fujitsu Limited | Software development tool program |
US8559605B2 (en) * | 2005-02-07 | 2013-10-15 | Avaya Inc. | Extensible diagnostic tool |
US20060177008A1 (en) * | 2005-02-07 | 2006-08-10 | David Forney | Extensible diagnostic tool |
US20060236310A1 (en) * | 2005-04-19 | 2006-10-19 | Domeika Max J | Methods and apparatus to iteratively compile software to meet user-defined criteria |
US20070079294A1 (en) * | 2005-09-30 | 2007-04-05 | Robert Knight | Profiling using a user-level control mechanism |
US20070103348A1 (en) * | 2005-11-04 | 2007-05-10 | Sun Microsystems, Inc. | Threshold search failure analysis |
US20070168969A1 (en) * | 2005-11-04 | 2007-07-19 | Sun Microsystems, Inc. | Module search failure analysis |
US8136101B2 (en) | 2005-11-04 | 2012-03-13 | Oracle America, Inc. | Threshold search failure analysis |
US20070169004A1 (en) * | 2005-11-04 | 2007-07-19 | Sun Microsystems, Inc. | Automatic failure analysis of code development options |
US7797684B2 (en) * | 2005-11-04 | 2010-09-14 | Oracle America, Inc. | Automatic failure analysis of code development options |
US20080250399A1 (en) * | 2005-12-30 | 2008-10-09 | Bo Huang | Evaluation and Selection of Programming Code |
US20070204260A1 (en) * | 2006-02-24 | 2007-08-30 | Oki Electric Industry Co., Ltd. | Program transformation system |
US9378002B2 (en) * | 2006-12-22 | 2016-06-28 | Core Wireless Licensing S.A.R.L. | System, method, apparatus and computer program product for providing memory footprint reduction |
US20080155521A1 (en) * | 2006-12-22 | 2008-06-26 | Nokia Corporation | System, Method, Apparatus and Computer Program Product for Providing Memory Footprint Reduction |
US8527951B2 (en) | 2007-03-20 | 2013-09-03 | Siemens Aktiengesellschaft | Method for the computer-aided determination of an optimization potential of a soft-ware system |
WO2008113681A1 (en) * | 2007-03-20 | 2008-09-25 | Siemens Aktiengesellschaft | Method for the computer-aided determination of an optimization potential of a software system |
US8056065B2 (en) | 2007-09-26 | 2011-11-08 | International Business Machines Corporation | Stable transitions in the presence of conditionals for an advanced dual-representation polyhedral loop transformation framework |
US8087010B2 (en) | 2007-09-26 | 2011-12-27 | International Business Machines Corporation | Selective code generation optimization for an advanced dual-representation polyhedral loop transformation framework |
US8087011B2 (en) | 2007-09-26 | 2011-12-27 | International Business Machines Corporation | Domain stretching for an advanced dual-representation polyhedral loop transformation framework |
US8060870B2 (en) * | 2007-09-26 | 2011-11-15 | International Business Machines Corporation | System and method for advanced polyhedral loop transformations of source code in a compiler |
US20090083722A1 (en) * | 2007-09-26 | 2009-03-26 | Eichenberger Alexandre E | System and Method for Stable Transitions in the Presence of Conditionals for an Advanced Dual-Representation Polyhedral Loop Transformation Framework |
US20090307673A1 (en) * | 2007-09-26 | 2009-12-10 | Eichenberger Alexandre E | System and Method for Domain Stretching for an Advanced Dual-Representation Polyhedral Loop Transformation Framework |
US20090083724A1 (en) * | 2007-09-26 | 2009-03-26 | Eichenberger Alexandre E | System and Method for Advanced Polyhedral Loop Transformations of Source Code in a Compiler |
US9235390B1 (en) * | 2008-03-31 | 2016-01-12 | Symantec Corporation | Application optimization for use based on feature popularity |
US8321262B1 (en) * | 2008-06-04 | 2012-11-27 | Pros, Inc. | Method and system for generating pricing recommendations |
US8495605B2 (en) * | 2008-06-16 | 2013-07-23 | International Business Machines Corporation | Policy-based program optimization to minimize environmental impact of software execution |
US20090313615A1 (en) * | 2008-06-16 | 2009-12-17 | International Business Machines Corporation | Policy-based program optimization to minimize environmental impact of software execution |
US8612958B2 (en) | 2008-12-25 | 2013-12-17 | Panasonic Corporation | Program converting apparatus and program conversion method |
US8566792B2 (en) * | 2010-05-07 | 2013-10-22 | Salesforce, Inc. | Validating visual components |
US9009669B2 (en) | 2010-05-07 | 2015-04-14 | Salesforce.Com, Inc. | Visual user interface validator |
US9098618B2 (en) | 2010-05-07 | 2015-08-04 | Salesforce.Com, Inc. | Validating visual components |
US20110276945A1 (en) * | 2010-05-07 | 2011-11-10 | Salesforce.Com, Inc. | Validating Visual Components |
US8713530B2 (en) | 2010-05-13 | 2014-04-29 | Salesforce.Com, Inc. | Test framework of visual components in a multitenant database environment |
US8959483B2 (en) | 2010-05-13 | 2015-02-17 | Salesforce.Com, Inc. | Test framework of visual components in a multitenant database environment |
US20130227531A1 (en) * | 2012-02-24 | 2013-08-29 | Zynga Inc. | Methods and Systems for Modifying A Compiler to Generate A Profile of A Source Code |
WO2014200362A1 (en) * | 2013-06-11 | 2014-12-18 | Smart Research Limited | Method and computer program for generating or manipulating source code |
US20150227448A1 (en) * | 2014-02-13 | 2015-08-13 | Infosys Limited | Methods of software performance evaluation by run-time assembly code execution and devices thereof |
US10318400B2 (en) * | 2014-02-13 | 2019-06-11 | Infosys Limited | Methods of software performance evaluation by run-time assembly code execution and devices thereof |
US20170115972A1 (en) * | 2015-10-21 | 2017-04-27 | Lsis Co., Ltd. | Method of optimally compiling plc command |
US10445074B2 (en) * | 2015-10-21 | 2019-10-15 | Lsis Co., Ltd. | Method of optimally compiling PLC command |
Also Published As
Publication number | Publication date |
---|---|
US6922829B2 (en) | 2005-07-26 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6922829B2 (en) | Method of generating profile-optimized code | |
JP5648584B2 (en) | Method and apparatus for profiling software applications | |
US6938249B2 (en) | Compiler apparatus and method for optimizing loops in a computer program | |
Malony et al. | Traceview: A trace visualization tool | |
US6381739B1 (en) | Method and apparatus for hierarchical restructuring of computer code | |
US7168059B2 (en) | Graphical loop profile analysis | |
US7644397B2 (en) | Software performance analysis using data mining | |
US5889999A (en) | Method and apparatus for sequencing computer instruction execution in a data processing system | |
US5966538A (en) | Method and apparatus for automatically determining which compiler options should be used when compiling a computer program | |
US6523173B1 (en) | Method and apparatus for allocating registers during code compilation using different spill strategies to evaluate spill cost | |
US20070044075A1 (en) | Method for analysis of source code and display of corresponding output through a marking scheme | |
CN102236550A (en) | Software development tool | |
CN102236551A (en) | Software development tool | |
EP1788485A1 (en) | Source program analysis device and method | |
US9424014B2 (en) | Strength reduction compiler optimizations for operations with unknown strides | |
WO2008038389A1 (en) | Program performance analyzing apparatus | |
US6360360B1 (en) | Object-oriented compiler mechanism for automatically selecting among multiple implementations of objects | |
Veit Batz et al. | A first experimental evaluation of search plan driven graph pattern matching | |
US6718544B1 (en) | User interface for making compiler tradeoffs | |
CN104809067B (en) | Towards the method for generating test case and device of equality constraint | |
Eusse et al. | Pre-architectural performance estimation for ASIP design based on abstract processor models | |
US7530063B2 (en) | Method and system for code modification based on cache structure | |
EP1139218A2 (en) | Method of generating optimized code | |
JP2003271394A (en) | Device for arranging and allocating function and basic block and program for optimizing allocation | |
JPH02236638A (en) | Register allocation managing system |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: TEXAS INSTRUMENTS INCORPORATED, TEXAS Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:WARD, ALAN S.;TATGE, REID E.;HUMPHREYS, JONATHAN F.;AND OTHERS;REEL/FRAME:011774/0108;SIGNING DATES FROM 20010213 TO 20010326 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
FPAY | Fee payment |
Year of fee payment: 8 |
|
FPAY | Fee payment |
Year of fee payment: 12 |