Abstract:
A method, computer program product and apparatus for indicating program modifications affecting program performance in an Integrated Development Environment (IDE). The modifications that a developer makes to a program is detected and the code location where these modifications occur is determined. The previous profiling data of the program is acquired. The effect of the modifications on the program performance according to the previous profiling data and the code location where the modifications occur is evaluated. The evaluation results may then be provided to the developer. As a result of the above process, the developer can be aware of the performance problem while he/she is editing the source code so as to make corrections without waiting after the profiling phase, thus greatly shortening the development period.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application claims priority under 35 U.S.C. §119(a) from Chinese Patent Application No. 201010117730.1, filed on Feb. 26, 2010, the contents of which are incorporated herein by reference. 
       TECHNICAL FIELD 
       [0002]    The present invention relates to the field of computers, particularly to the Integrated Development Environment (IDE), and more particularly, to indicating to developers the effect of program modifications on program performance in an IDE. 
       BACKGROUND 
       [0003]    Software development is usually carried out in an IDE. The traditional software development cycle includes editing source code, building, testing and profiling. Performance problems, such as performance bottlenecks, may be discovered by profiling. To address the discovered performance problems, a developer edits the source code, builds, tests and profiles the program over again.  FIG. 1  illustrates a schematic structure diagram of an IDE  100 . Referring to  FIG. 1 , as shown, IDE  100  includes an editing module  101 , a building module  102 , a testing module  103 , a profiling module  104  and a graphic user interface  105 , where the developer may edit, build, test and profile the program with the above modules, and during this process, generate and store building results  106 , testing results  107  and profiling data  108 . 
         [0004]      FIG. 2  illustrates a traditional software development cycle. Referring to  FIG. 2 , the traditional software development cycle includes editing  201 , building  202 , testing  203  and profiling  204  which sequentially form a complete cycle. Performance bottlenecks may be found during the profiling phase and editing may be entered again, so that the next cycle begins. 
         [0005]    In the above performance problem solving manner, the performance problems introduced in the editing phase will be discovered in the profiling phase and solved by editing the source code in the next cycle. The problem with this solving process is that it is long, since testing and profiling will generally run for a period of time. Furthermore, this process may result in the performance regression problem, i.e., new performance problems may be introduced when the developer is modifying the source code, and the developer is usually unaware of the performance problems caused by his/her modifications. This is because programs are usually complicated, and it is difficult for the developer to evaluate the overall performance effect of the code modifications. In addition, in a collaborative development, a developer only knows about the modules for which he/she is responsible, and has no idea about the modules for which other developers are responsible; more importantly, development is usually separated from testing and profiling. Even though some IDEs comprise an integrated profiler, the developer still needs to wait for a period of time to get the profiling results, then to check the positions where performance bottlenecks and performance regressions are generated, and to try to solve the problems. Such a process for solving performance problems is obviously inefficient. 
       BRIEF SUMMARY 
       [0006]    In one embodiment of the present invention, a method for indicating program modifications affecting program performance in an Integrated Development Environment comprises detecting modifications that a developer makes to a program. The method further comprises determining a code location where the modifications are made. Additionally, the method comprises acquiring previous profiling data of the program. Furthermore, the method comprises evaluating an effect of the modifications on program performance according to the previous profiling data and the code location where the modifications are made. In addition, the method comprises providing results of the evaluation to the developer. 
         [0007]    Other forms of the embodiment of the method described above are in a computer program product. 
         [0008]    The foregoing has outlined rather generally the features and technical advantages of one or more embodiments of the present invention in order that the detailed description of the present invention that follows may be better understood. Additional features and advantages of the present invention will be described hereinafter which may form the subject of the claims of the present invention. 
     
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
         [0009]    A better understanding of the present invention can be obtained when the following detailed description is considered in conjunction with the following drawings, in which: 
           [0010]      FIG. 1  is a schematic structure diagram of an Integrated Development Environment (IDE); 
           [0011]      FIG. 2  illustrates a traditional software development cycle; 
           [0012]      FIG. 3  is a flowchart of a method for indicating program modifications affecting program performance in an IDE according to an embodiment of the present invention; 
           [0013]      FIG. 4  is a flowchart of the sub-steps of evaluating the effect of modifications on program performance according to previous profiling data and the code location where the modifications occur according to an embodiment of the present invention; 
           [0014]      FIG. 5  is a flowchart of the sub-steps of evaluating the variation of the performance relevant index (i.e., variation of the number of machine instructions) of the function where the modification is located, caused by the modified code according to an embodiment of the present invention; 
           [0015]      FIG. 6  is a flowchart of the sub-steps of evaluating the variation of the performance relevant index (i.e., variation of the number of machine instruction clock cycles) of the function where the modification is located, caused by the modified code according to another embodiment of the present invention; 
           [0016]      FIG. 7  depicts an embodiment of a hardware configuration of a computer system which is representative of a hardware environment for practicing the present invention; and 
           [0017]      FIG. 8  illustrates the software components used for indicating program modifications affecting program performance in an IDE according to an embodiment of the present invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0018]    The present invention comprises a method, computer program product and apparatus for analyzing previous profiling data of a program, and for indicating to developers the performance loss that may be caused by their modifications while they are modifying the program. 
         [0019]    The embodiments of the present invention will now be described with reference to the accompanying drawings. In the following description, numerous details are described to enable the present invention to be fully understood. However, it is obvious to those skilled in the art that the realization of the present invention can be without some of these details. In addition, it should be appreciated that the present invention is not limited to the described specific embodiments. In contrast, it is contemplated to implement the present invention by using any combination of the following features and elements, no matter whether they involve different embodiments or not. Therefore, the following aspects, features, embodiments and advantages are illustrative, rather than elements or limitations of the appended claims, unless explicitly stated otherwise in the claims. 
         [0020]    Now referring to  FIG. 3 ,  FIG. 3  illustrates a method  300  for indicating program modifications affecting program performance in an Integrated Development Environment (IDE) according to an embodiment of the present invention. 
         [0021]    Referring to  FIG. 3 , in step  301 , the modifications that the developer makes to the program in an IDE is detected. 
         [0022]    In step  302 , the code locations where the modifications occur are determined. According to an embodiment of the present invention, step  302  includes determining the function where the modified code is located. In one embodiment, step  302  assumes that all the modifications to the program are performed inside existing functions of the program. As for changes outside the existing functions (e.g., adding a new function outside the existing functions), there are callings of the newly added function being added in some existing function, and thus this step will determine the function calling the newly added function, and will not determine the newly added function itself. In programming languages, such as the C programming language, a macro may be defined, and the macro may be invoked by a function. Modifying an existing macro or adding a new macro will also result in performance variation of the function calling the macro. Therefore, determining the function in which the modified code is located also includes determining all the functions invoking a modified macro or a newly added macro. 
         [0023]    It should be noted that the term “function” used herein refers to any relatively independent code segment that accomplishes a specific function in the program, including subroutines, methods, procedures, sub-programs, etc. in different programming languages. 
         [0024]    In step  303 , the previous profiling data of the program is obtained. Profiling data is generated during the profiling phase of the program, and it includes various performance data and performance relevant data in a number of previous program executions, such as performance indexes (e.g., a statistic value of the number of processor clock cycles consumed by the functions during a number of program runnings), performance relevant indexes (e.g., the amount of machine instructions or the amount of machine instruction clock cycles consumed by the functions), and the invocation frequencies of the functions in a number of previous program runnings. The following table illustrates an exemplary structure of the profiling data: 
         [0000]                    TABLE 1               Exemplary structure of the profiling data                                                                  
where the Function ID is the identification of a function in the program; performance relevant index refers to the performance relevant factors of the function itself (e.g., the number of static machine instructions, the number of machine instruction clock cycles of the function); performance index 1 . . . performance index n are the actual performance indexes profiled for the corresponding function in a number of previous runnings, such as the total number or average number of the consumed processor clock cycles; and the invocation frequency is the frequency or percentage that the function is invoked during the previous runnings
 
         [0025]    The above profiling data may be generated directly by the profiling process, or may be extracted from the data generated in the profiling process. 
         [0026]    In step  304 , the effect of the modifications on the program performance is evaluated according to the previous profiling data and the code location where the modifications occur. According to an embodiment of the present invention, step  304  includes evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the previous profiling data, and evaluating the effect of the modifications on the program performance according to the expected variation of the performance index of the function. Therein, evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the previous profiling data includes: evaluating the variation, which is caused by the modifications, of the performance relevant index of the function in which the modifications are located; and evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the variation of the performance relevant index. And therein, evaluating the effect of the modifications on the program performance according to the expected variation of the performance index of the function includes: evaluating the effect of the modifications on the program performance according to the ratio of the expected variation of the performance index of the function to the sum of the performance indexes of all the functions of the program, as well as the frequency that the function is invoked during the program running 
         [0027]    In step  305 , the evaluation results are provided to the developer. 
         [0028]      FIG. 4  is a flowchart of the sub-steps of step  304  for evaluating the effect of the modifications on the program performance according to the previous profiling data and the code location where the modifications occur according to an embodiment of the present invention. 
         [0029]    Referring to  FIG. 4 , in conjunction with  FIG. 3 , in step  401 , the performance index, PerformanceIndex, and performance relevant index, PerformanceRelevantIndex, of the function are obtained from the profiling data according to the function ID of the function in which the modifications are located as determined in step  302 . The performance index, PerformanceIndex, may be a statistic value of the number of processor clock cycles consumed by the function in a number of previous program runnings, such as the sum of the number of processor clock cycles or the average value in each running The performance relevant index may be either the number of machine instructions consumed by the function, or the number of machine instruction clock cycles consumed by the function. 
         [0030]    In step  402 , the variation amount of the performance relevant index, PerformanceRelevantIndex_Add, of the function caused by the modified code is evaluated. 
         [0031]    In step  403 , the following equation (EQ1) is calculated: 
         [0000]    
       
         
           
             
               
                 
                   p 
                   = 
                   
                     
                       PerformanceIndex 
                       × 
                       PerformanceRelevantIndex_Add 
                     
                     PerformanceRelevantIndex 
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                      
                     
                         
                     
                      
                     1 
                   
                   ) 
                 
               
             
           
         
       
     
         [0032]    where PerformanceIndex and PerformanceRelevantIndex are the performance index and performance relevant index of the function in which the modifications are located that are obtained in step  401 , respectively. p denotes the expected variation of the performance index of the function in which the modifications are located, caused by the modifications, as evaluated according to the variation of the performance relevant index of the function in which the modifications are located, caused by the modifications. 
         [0033]    In step  404 , the variable α is calculated using the following equation (EQ2): 
         [0000]    
       
         
           
             
               
                 
                   α 
                   = 
                   
                     
                       p 
                       × 
                       β 
                     
                     
                       
                           
                       
                        
                       
                         
                           
                             
                               the 
                                
                               
                                   
                               
                                
                               sum 
                                
                               
                                   
                               
                                
                               of 
                                
                               
                                   
                               
                                
                               PerformanceIndex 
                             
                           
                         
                         
                           
                             
                               of 
                                
                               
                                   
                               
                                
                               all 
                                
                               
                                   
                               
                                
                               the 
                                
                               
                                   
                               
                                
                               functions 
                                
                               
                                   
                               
                                
                               in 
                                
                               
                                 
                                     
                                 
                                  
                                 
                                     
                                 
                               
                                
                               the 
                                
                               
                                   
                               
                                
                               program 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                      
                     
                         
                     
                      
                     2 
                   
                   ) 
                 
               
             
           
         
       
     
         [0034]    where p is the expected variation of the performance index in which the modifications are located, as evaluated in step  403 ; β is the invocation frequency of the function as obtained from the profiling data of the program (e.g., the percentage that the function is invoked in a number of program runnings); α denotes the effect of the modifications on the program&#39;s overall performance, and it is evaluated according to the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located and in consideration of the ratio of the expected variation of the performance index of the function in the sum of performance indexes of all the functions in the program and the invocation frequency of the function. 
         [0035]    According to an embodiment of the present invention, in step  305 , the value α, as calculated in step  404 , may be presented to the developer, to indicate to him/her the effect of the modifications on the program performance. According to another embodiment of the present invention, the value a may also first be compared with a pre-defined threshold, and when the value α is larger than the threshold, it is indicated to the developer that his/her modifications may greatly affect the program performance. It should be noted that the above steps are performed in the phase that the developer is editing the code in an IDE so that the performance influence probably caused by the editing actions of the developer can be timely indicated. As a result, the developer may carry out performance optimization in time, thus reducing performance regression and enhancing the development efficiency. 
         [0036]    According to an embodiment of the present invention, the performance relevant index is the number of machine instructions consumed by the function, and the variation amount of the performance relevant index, PerformanceRelevantIndex_Add, is the variation amount of the machine instructions of the function, named as FIA (Function_Instruction_Add) caused by the code modifications. 
         [0037]      FIG. 5  is a flowchart of the sub-steps of step  402  for evaluating the variation amount of the performance relevant index of the function caused by the modified code according to an embodiment of the present invention. 
         [0038]    Referring to  FIG. 5 , in step  501 , the modified code in the function is detected line by line. For the case that a modified or newly added macro is invoked by a function in programming languages, such as C, the code of the modified or newly added macro will be viewed as the code of the function itself, and will be detected line by line. 
         [0039]    In step  502 , a determination is made as to whether the modified code introduces a new function invocation. 
         [0040]    If the modified code does not introduce a new function invocation, then, in step  503 , the number of machine instructions of this line of code, LineInstruction, is calculated. As known in the art, the number of machine instructions of a code line may be obtained by compiling the modified program code and then calculating from the compiled binary code. 
         [0041]    In step  504 , the equation FIA=FIA+LineInstruction is calculated, assuming that the initial value of FIA is 0. Upon executing step  504 , the modified code in the function is detected line by line in step  501 . If the modifications are not simply adding new code lines, but modifying old code lines into new code lines, then the number of machine instructions of the old code lines should be further subtracted from the above expression. 
         [0042]    If, however, the modified code introduces a new function invocation, then in step  505 , the number of machine instructions introduced by the new function, FunInstruction, is calculated. As known in the art, the number of machine instructions introduced by the new function may be obtained by compiling the modified program code and from the compiled binary code, or may be obtained by accumulating the number of machine instructions of all the instruction lines contained in the new function. For the case where the newly introduced function invocation is an I/O function invocation, since the I/O functions with the same number of instructions may consume substantially different processor clock cycles, it is preferable to use another embodiment illustrated in  FIG. 6  and described below to evaluate the variation amount of the performance relevant index of the function caused by the modified code. 
         [0043]    In step  506 , the equation FIA=FIA+FunInstruction is calculated. Upon executing step  506 , the modified code in the function is detected line by line in step  501 . If the modifications are not simply adding a new function invocation, but replacing an old function invocation by a new function invocation, then the number of machine instructions of the old function may be further subtracted from the above expression. 
         [0044]    In one embodiment, the above process is performed iteratively, until all the modified code lines in the function have been processed, so as to obtain the final machine instruction variation amount FIA of the function caused by the code modification. 
         [0045]    According to another embodiment of the present invention, the performance relevant index is the number of machine instruction clock cycles consumed by the function, and the variation amount of the performance relevant index, PerformanceRelevantIndex_Add, is the variation amount of machine instruction clock cycles FCA (Function_Cycle_Add) of the function caused by the code modifications.  FIG. 6  is a flowchart of the sub-steps of step  402  for evaluating the variation amount of the performance relevant index (i.e., the variation amount of machine instruction clock cycles) of the function caused by the modified code according to an embodiment of the present invention. 
         [0046]    Referring to  FIG. 6 , in step  601 , the modified code in the function is detected line by line. For the case that a modified or newly added macro is invoked by a function in a programming language, such as C, the code in the modified or newly added macro will be viewed as the code of the function itself, and is detected line by line. 
         [0047]    In step  602 , a determination is made as to whether the modified code introduces a new function invocation. 
         [0048]    If the modified code does not introduce a new function invocation, then, in step  603 , the number of machine instruction clock cycles, LineCycle, of this line of code is calculated. As known in the art, the number of machine instruction clock cycles of a code line may be calculated by the number of machine instructions of the code line and the clock cycles occupied by each machine instruction. 
         [0049]    In step  604 , the equation FCA=FCA+LineCycle is calculated, assuming that the initial value of FCA is 0. Upon executing step  604 , the modified code in the function is detected line by line in step  601 . If the modifications are not only simply adding new code lines, but modifying old code lines into new code lines, then the number of machine instruction clock cycles of the old code lines should be further subtracted from the above expression. 
         [0050]    If, however, the modified code introduces a new function invocation, then in step  605 , the number of machine instruction clock cycles, FunCycle, introduced by the new function is calculated. As known in the art, the number of machine instruction clock cycles introduced by the new function may be obtained by accumulating the number of machine instruction clock cycles of all the instruction lines contained in the new function. For the case where the newly introduced function invocation is an I/O function invocation, since the number of processor clock cycles consumed by I/O functions with the same number of machine instructions may differ greatly, and since I/O functions are usually included in third-party library functions, the number of clock cycles consumed by the I/O functions needs to be recorded in the third-party library functions (which is evaluated by the third-party). Thus, when the I/O function is introduced for the first time due to program modifications, the number of clock cycles may be obtained from the third-party library function as the number of machine instruction clock cycles introduced by this new I/O function. In future profiling, performance data of the I/O function (i.e., the number of clock cycles) may be further collected to replace the number of clock cycles provided by the third party for evaluating the variation amount of the performance relevant index. 
         [0051]    In step  606 , the equation FCA=FCA+FunCycle is calculated. Upon executing step  606 , the modified code in the function is detected line by line in step  601 . If the modifications are not simply adding a new function invocation, but modifying an old function invocation into a new function invocation, then the number of machine instruction clock cycles of the old function should be further subtracted from the above expression. 
         [0052]    In one embodiment, the above process is performed iteratively, until all the modified code lines in the function are processed, so as to obtain the final machine instruction variation amount FCA of the function caused by the code modifications. 
         [0053]    Above is described a method for indicating program modifications affecting program performance in an IDE according to the embodiments of the present invention. It should be pointed out that the above description and illustration are exemplary. In other embodiments of the present invention, the method may have more, less or different steps, and the details of the respective steps and the order among the steps may be different from that is illustrated and described. For example, according to one embodiment of the present invention, in step  304 , the invocation frequency of the function in which modifications are located may further be determined; and if the invocation frequency is too small, e.g., smaller than 0.1, then it may be determined that the modifications to this function will not cause significant effect on the program performance, so that the evaluation for this function may be omitted. For further example, while the above description uses the number of processor clock cycles as the performance index of the function, and uses the number of machine instructions and the number of machine instruction clock cycles as the performance relevant index of the function; this is exemplary; and in some other embodiments of the present invention, other performance indexes and performance relevant indexes may be used. Furthermore, the above described method for calculating the performance relevant index of the function and the formula in steps  403  and  404  are exemplary as well, and they may have other variations in other embodiments of the present invention. 
         [0054]      FIG. 7  depicts an embodiment of a hardware configuration of a computer system  700  which is representative of a hardware environment for practicing the present invention. Referring to  FIG. 7 , computer system  700  has a processor  701  coupled to various other components by system bus  702 . An operating system  703  may run on processor  701  and provide control and coordinate the functions of the various components of  FIG. 7 . An application  704  in accordance with the principles of the present invention may run in conjunction with operating system  703  and provide calls to operating system  703  where the calls implement the various functions or services to be performed by application  704 . Application  704  may include, for example, an application for indicating to developers the effect of program modifications on program performance in an IDE as discussed above. 
         [0055]    Referring again to  FIG. 7 , read-only memory (“ROM”)  705  may be coupled to system bus  702  and include a basic input/output system (“BIOS”) that controls certain basic functions of computer device  700 . Random access memory (“RAM”)  706  and disk adapter  707  may also be coupled to system bus  702 . It should be noted that software components including operating system  703  and application  704  may be loaded into RAM  706 , which may be computer system&#39;s  700  main memory for execution. Disk adapter  707  may be an integrated drive electronics (“IDE”) adapter that communicates with a disk unit  708 , e.g., disk drive. 
         [0056]    Computer system  700  may further include a communications adapter  709  coupled to bus  702 . Communications adapter  709  may interconnect bus  702  with an outside network (not shown) thereby allowing computer system  700  to communicate with other similar devices. 
         [0057]    I/O devices may also be connected to computer system  700  via a user interface adapter  710  and a display adapter  711 . Keyboard  712 , mouse  713  and speaker  714  may all be interconnected to bus  702  through user interface adapter  710 . Data may be inputted to computer system  700  through any of these devices. A display monitor  715  may be connected to system bus  702  by display adapter  711 . In this manner, a user is capable of inputting to computer system  700  through keyboard  712  or mouse  713  and receiving output from computer system  700  via display  715  or speaker  714 . 
         [0058]    As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon. 
         [0059]    Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. 
         [0060]    A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus or device. 
         [0061]    Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing. 
         [0062]    Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the C programming language or similar programming languages. The program code may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). 
         [0063]    Aspects of the present invention are described above with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the present invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to product a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the function/acts specified in the flowchart and/or block diagram block or blocks. 
         [0064]    These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks. 
         [0065]    The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the function/acts specified in the flowchart and/or block diagram block or blocks. 
         [0066]      FIG. 8  illustrates the software components used for indicating program modifications affecting program performance in an IDE according to an embodiment of the present invention. In one embodiment, these software components are the components or modules of the program for indicating program modifications affecting program performance in an IDE, where the program may reside in application  704  ( FIG. 7 ). 
         [0067]    Now referring to  FIG. 8 , the software modules include a modification detecting module  801  for detecting modifications to a program made by the developer in an IDE; a position determining module  802  for determining the code location where the modifications are made; a profiling data acquiring module  803  for acquiring previous profiling data; a performance influence evaluating module  804  for evaluating the influence or effect of the modifications on the program performance according to the previous profiling data and the code location where modifications are made; and an indicating module  805  for indicating the evaluation results to the developer. 
         [0068]    According to an embodiment of the present invention, determining the code location where the modifications occur comprises determining the function in which the modifications are located, and the previous profiling data comprises the performance index of the function in the program in the previous program running. 
         [0069]    According to an embodiment of the present invention, the performance influence evaluating module  804  is used for: evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the previous profiling data, and evaluating the effect of the modifications on the program performance according to the expected variation of the performance index of the function. 
         [0070]    According to an embodiment of the present invention, evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the previous profiling data comprises: evaluating the variation, which is caused by the modifications, of the performance relevant index of the function in which the modifications are located; and evaluating the expected variation, which is caused by the modifications, of the performance index of the function in which the modifications are located according to the variation of the performance relevant index. 
         [0071]    According to an embodiment of the present invention, evaluating the effect of the modifications on the program performance according to the expected variation of the performance index of the function comprises: evaluating the effect of the modifications on the program performance according to the ratio of the expected variation of the performance index of the function to the sum of the performance indexes of all functions of the program and the invocation frequency of the function in the program running 
         [0072]    According to an embodiment of the present invention, the performance index is a statistic value of the processor clock cycles consumed by the function in previous program running 
         [0073]    According to an embodiment of the present invention, the performance relevant index is the number of machine instructions of the function. According to another embodiment of the present invention, the performance relevant index is the number of machine instruction clock cycles of the function. 
         [0074]    Above is described the apparatus for indicating program modifications affecting program performance in an IDE according to the embodiments of the present invention. It should be pointed out that the above description and illustration are exemplary. In other embodiments of the present invention, the apparatus may have more, less or different modules, and the relationships, such as connection and inclusion relationships, among the modules may be different from that is described. The modules discussed above may be inside an IDE as a module of the IDE, or may be a standalone module outside the IDE and work together with IDE. 
         [0075]    The following describes the working process of the method of the present invention by way of an example using the following exemplary program: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                 1 
                 #include &lt;stdio.h&gt; 
               
               
                 2 
                 extern int 
               
               
                 3 
                 init_args(int argc, char *argv[ ]) 
               
               
                 4 
                 { 
               
               
                 5 
                 //initiate the args 
               
               
                 6 
                 } 
               
               
                 7 
                   
               
               
                 8 
                 extern int 
               
               
                 9 
                 search_entry(int *list, int id) 
               
               
                 10 
                 { 
               
               
                 11 
                 //find the ID in the list 
               
               
                 12 
                 } 
               
               
                 13 
                   
               
               
                 14 
                 extern int 
               
               
                 15 
                 main(int argc, char *argv[ ]) 
               
               
                 16 
                 { 
               
               
                 17 
                  int data[100] = {0}; 
               
               
                 18 
                  int ret, id = −1; 
               
               
                 19 
                   
               
               
                 20 
                  id = init_args(argc, argv); 
               
               
                 21 
                   
               
               
                 22 
                  ret = search_entry(data, id); 
               
               
                 23 
                   
               
               
                 24 
                  cleaup( ); 
               
               
                 25 
                 } 
               
               
                   
               
             
          
         
       
     
         [0076]    Assuming the processor clock cycles is selected as the performance index for profiling, and the number of machine instructions is selected as the performance relevant index, the profiling data are shown in the following table: 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                 TABLE 2 
               
               
                   
                   
               
               
                   
                   
                 Number of Machine 
                 Processor 
               
               
                   
                 Function ID 
                 Instructions 
                 Clock Cycles 
               
               
                   
                   
               
             
             
               
                   
                 Main 
                 200 
                 2400 
               
               
                   
                 init_args 
                 500 
                 4000 
               
               
                   
                 search_entry 
                 900 
                 6700 
               
               
                   
                   
               
             
          
         
       
     
         [0077]    It is assumed that the developer modifies the above example program as follows: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                 1 
                 #include &lt;stdio.h&gt; 
               
               
                 2 
                   
               
               
                 3 
                 extern int 
               
               
                 4 
                 init_args(int argc, char *argv[ ]) 
               
               
                 5 
                 { 
               
               
                 6 
                 //initiate the args 
               
               
                 7 
                 } 
               
               
                 8 
                   
               
               
                 9 
                 extern int 
               
               
                 10 
                 search_entry(int *list, int id) 
               
               
                 11 
                 { 
               
               
                 12 
                 //find the ID in the list 
               
               
                 13 
                 } 
               
               
                 14 
                   
               
               
                 15 
                 extern int 
               
               
                 16 
                 sort_data(char *list) 
               
               
                 17 
                 { 
               
               
                 18 
                  //sort the list 
               
               
                 19 
                 } 
               
               
                 20 
                   
               
               
                 21 
                 extern int 
               
               
                 22 
                 main(int argc, char *argv[ ]) 
               
               
                 23 
                 { 
               
               
                 24 
                  int data[100] = {0}; 
               
               
                 25 
                  int ret, id = −1; 
               
               
                 26 
                   
               
               
                 27 
                  id = init_args(argc, argv); 
               
               
                 28 
                   
               
               
                 29 
                  printf(“Will sort the list first...\n”); 
               
               
                 30 
                  ret = sort_data(data); 
               
               
                 31 
                   
               
               
                 32 
                  ret = search_entry(data, id); 
               
               
                 33 
                   
               
               
                 34 
                  if (ret &gt; 0) 
               
               
                 35 
                   printf(“succeed to find the ID!\n”); 
               
               
                 36 
                 } 
               
               
                   
               
             
          
         
       
     
         [0078]    In the above modified program, lines 15-19 are a newly added function, sort_data ( ), and lines 29-30 are the newly added code. According to the process illustrated in  FIGS. 3 ,  4  and  5  and described above, it is detected in step  301  that the developer has modified the program, and in step  302  it is determined that the location in which code is modified is the function “main”; in step  303 , the previous profiling data of the program is acquired (i.e., Table 2). Next, in step  401 , the number of machine instructions (i.e., PerformanceRelevantIndex) of the main function acquired from Table 2 is 200 and the number of processor clock cycles (i.e., PerformanceIndex) is 2400. In step  503 , it is calculated that the newly added code at line 29 has 8 machine instructions, while in step  504 , it is calculated that the new function sort_data( ) invoked at line 30 has 420 instructions. Thus, in step  402 , the variation amount of the performance relevant index (i.e., the variation amount of the machine instructions) of the main function, PerformanceRelevantIndex_Add, is obtained (equals 8+420=428 machine instructions). Since function main ( ) is the entry point of the program, the percentage that it is invoked is β=100%, i.e., function main ( ) will always be invoked. Thus, in step  403 , the following is calculated. 
         [0000]    
       
         
           
             
               
                 
                   p 
                   = 
                     
                    
                   
                     
                       PerformanceIndex 
                       × 
                       PerformanceRelevantIndex_Add 
                     
                     PerformanceRelevantIndex 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       2400 
                       × 
                       428 
                     
                     200 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   5136 
                 
               
             
           
         
       
     
         [0079]    This means that the newly added 428 machine instructions in main ( ) will consume 5136 processor clock cycles. Then, in step  404 , the following is calculated. 
         [0000]    
       
         
           
             
               
                 
                   α 
                   = 
                     
                    
                   
                     
                       p 
                       × 
                       β 
                     
                     
                       
                           
                       
                        
                       
                         
                           
                             
                               the 
                                
                               
                                   
                               
                                
                               sum 
                                
                               
                                   
                               
                                
                               of 
                                
                               
                                   
                               
                                
                               PerformanceIndex 
                             
                           
                         
                         
                           
                             
                               of 
                                
                               
                                   
                               
                                
                               all 
                                
                               
                                   
                               
                                
                               the 
                                
                               
                                   
                               
                                
                               functions 
                                
                               
                                   
                               
                                
                               in 
                                
                               
                                 
                                     
                                 
                                  
                                 
                                     
                                 
                               
                                
                               the 
                                
                               
                                   
                               
                                
                               program 
                             
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         5136 
                         × 
                         100 
                          
                         % 
                       
                       
                         2400 
                         + 
                         4000 
                         + 
                         6700 
                       
                     
                     ≈ 
                     
                       39 
                        
                       % 
                     
                   
                 
               
             
           
         
       
     
         [0080]    That is, the newly added code will result in a performance loss of 39% of the original program. Assuming the predetermined threshold is 10%, since 39%&gt;10%, it is indicated to the developer. 
         [0081]    Although the present invention has been illustrated and described with reference to the preferred embodiments, those skilled in the art will understand that various changes both in form and details may be made thereto without departing from the spirit and scope of the present invention.