Abstract:
The popularity of various application features is tracked, and applications are compiled or otherwise configured for optimization based on the use of the more popular features. More specifically, application features are mapped to corresponding sections of underlying code, and compiler directives are generated to direct a compiler to optimize the application for the performance of specific, application features, based on their popularity. This way, the application is compiled for use at an application feature level, rather than for size or speed generally. In another embodiment, the optimization is performed after compile time, by rearranging object code pages of an executable image, based on corresponding application feature popularity.

Description:
TECHNICAL FIELD 
     This invention pertains generally to optimization of computer applications, and more specifically to optimizing applications based on application feature popularity. 
     BACKGROUND 
     The current generation of compilers are capable of optimizing application binary files for either size or speed. In other words, the complier can be directed to make an executable image that is as small as possible or as fast as possible. The speed versus size of a program is a classic and well understood tradeoff in computer science. 
     Current compiler optimization, whether for speed or size, does not take into account which specific features of an application are most likely to be used when the program is run. In fact, compilers have no notion of high level application features at all. Thus, the optimizations have limited direct user benefit. Although it is somewhat useful for the application to be as small as possible, or as fast as possible overall without regard to specific feature performance, such optimizations are not calibrated to the ways in which users interact with the resulting programs when they are run in the field. 
     It would be desirable to be able to compile and otherwise configure applications in a manner without these shortcomings. 
     SUMMARY 
     The popularity of various application features is tracked, and applications are compiled or otherwise configured for optimization based on the use of the more popular features. More specifically, application features are mapped to corresponding sections of underlying code, and compiler directives are generated to direct a compiler to optimize the application for the performance of specific, application features, based on their popularity. This way, the application is compiled for use at an application feature level, rather than for size or speed generally. In another embodiment, the optimization is performed after compile time, by rearranging object code pages of an executable image, based on corresponding application feature popularity. 
     The features and advantages described in this summary and in the following detailed description are not all-inclusive, and particularly, many additional features and advantages will be apparent to one of ordinary skill in the relevant art in view of the drawings, specification, and claims hereof. Moreover, it should be noted that the language used in the specification has been principally selected for readability and instructional purposes, and may not have been selected to delineate or circumscribe the inventive subject matter, resort to the claims being necessary to determine such inventive subject matter. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram illustrating application optimization based on application feature popularity, according to some embodiments of the present invention. 
         FIG. 2  is a block diagram illustrating application optimization based on application feature popularity, according to other embodiments of the present invention. 
     
    
    
     The Figures depict embodiments of the present invention for purposes of illustration only. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles of the invention described herein. 
     DETAILED DESCRIPTION 
       FIG. 1  illustrates a system  100  for optimizing an application based on application feature popularity, according to some embodiments of the present invention. It is to be understood that although various components are illustrated in  FIG. 1  as separate entities, each illustrated component represents a collection of functionalities which can be implemented as software, hardware, firmware or any combination of these. Where a component is implemented as software, it can be implemented as a standalone program, but can also be implemented in other ways, for example as part of a larger program, as a plurality of separate programs, as a kernel loadable module, as one or more device drivers or as one or more statically or dynamically linked libraries. 
     As illustrated in  FIG. 1 , a popularity tracking component  111  dynamically determines application feature popularity. A number of application feature popularity tracking packages are available today, and the implementation mechanics of such technology in the context of the present invention will be readily apparent to one of ordinary skill in the relevant art in light of this specification. Another embodiment uses the application tracking, methodology disclosed in the pending patent application titled “Application Streaming Profiling,” having the same assignee as the present application, filed on Feb. 28, 2008 and now bearing Ser. No. 12/039,515 (“the Profiling Application”). 
     The Profiling Application is herein incorporated by reference. The use of the methodologies disclosed in the Profiling Application to dynamically determine application feature popularity will be readily apparent to one of ordinary skill in the relevant art in light of this specification and the incorporated specification of the Profiling Application. In yet other embodiments, other methodologies for determining application feature popularity are used as desired. 
     A mapping component  115  maps specific program features of an application  107  to specific sections of the underlying source code  117 . An application developer or the like provides the source code  117  for the application  107  being analyzed. The mapping component  115 , by referring to the corresponding source code  117 , can map specific program functionality back to specific sections of the source code  117 , at least approximately. In some embodiments, some or all of this mapping is entered by, for example, an application developer, who has access to both the source code  117  and the popularity data  113 . 
     It is to be understood that how much of the mapping is performed automatically by the mapping component  115 , and how much is input by, e.g., an application developer, is a variable design parameter. The implementation mechanics of performing such mapping based on the popularity data  113  and the application source code  117  are within the skill set of one of ordinary skill in the relevant art, and the usage thereof within the context of the present invention will be readily apparent to one of such a skill level in light of this specification. 
     The popularity data  113  is analyzed to produce compiler directives  119 , such that a compiler  105  can process the information. For example, the source code  117  can be marked by a developer, so as to indicate the relative popularity of corresponding features (e.g., with # or similar directives  119  that can be read by a compiler preprocessor). Such directives  119  can also be inserted into the source code  117  automatically by the mapping component  115 . 
     Compiler directives need not be placed directly into the source code  117 . In various embodiments, directives  119  can be in the form of data in a file, environment variables, configuration settings, command line options, etc. The compiler directives  119  can be as complicated as indications of exactly which source code  117  maps to which features and a ranking of the corresponding feature popularity, to something as simple as a listing of function names or other labels that pertain to more popular application features. The implementation mechanics of general compiler direction are known to those of ordinary skill in the relevant art, and the use of such techniques to direct a compiler  105  to designate specific sections of an application  107  for optimization will be readily apparent to one of such a skill level in light of this specification. 
     In any case, the compiler directives  119  are read and processed by a compiler  105  (or, e.g., a compiler  105  extension or the like) during a subsequent recompile of the application  107  (e.g., when a patch is being developed, when a new version is being created, etc.). The directives  119  inform the compiler  105  as to which sections of the source code  117  correspond to the more popular application features, and the compiler  105  compiles the application  107  for optimization of the performance of those more commonly used features. In other words, the application  107  is compiled for use at an application feature level, rather than for size or speed generally. This implies that the optimization is focused on the sections that correspond to more commonly used features, even the expense of degradation of performance for less popular features. It is to be understood that specific techniques for optimizing compilation of source code  117  are known by those of ordinary skill in the relevant art, and the use of such techniques to optimize specifically designated sections of an application  107  will be readily apparent to one of such a skill level in light of this specification. 
     As illustrated in  FIG. 2 , in another embodiment of the present invention the feature based optimization is performed by a post-compile utility  201  that organizes object code  203  corresponding to specific functionalities of the application  107 . In this embodiment, the mapping component  115  maps specific code pages  203  of an application  107  to program features based on the popularity data  113  and the source code  117 , as opposed to mapping specific sections of the underlying source code  117  to application features. The post-compile utility  201  rearranges the code pages  203  comprising the application  107  (i.e., the executable image), so as to optimize for performance of the more popular features. Typically, this embodiment would be somewhat else effective than the compiler  105  based optimization embodiment described above in conjunction with  FIG. 1 . 
     As will be understood by those familiar with the art, the invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. Likewise, the particular naming and division of the portions, modules, agents, managers, components, functions, procedures, actions, layers, features, attributes, methodologies and other aspects are not mandatory or significant, and the mechanisms that implement the invention or its features may have different names, divisions and/or formats. Furthermore, as will be apparent to one of ordinary skill in the relevant art, the portions, modules, agents, managers, components, functions, procedures, actions, layers, features, attributes, methodologies and other aspects of the invention can be implemented as software, hardware, firmware or any combination of the three. Of course, wherever a component of the present invention is implemented as software, the component can be implemented as a script, as a standalone program, as part of a larger program, as a plurality of separate scripts and/or programs, as a statically or dynamically linked library, as a kernel loadable module, as a device driver, and/or in every and any other way known now or in the future to those of skill in the art of computer programming. Additionally, the present invention is in no way limited to implementation in any specific programming language, or for any specific operating system or environment. Furthermore, it will be readily apparent to those of ordinary skill in the relevant art that where the present invention is implemented in whole or in part in software, the software components thereof can be stored on computer readable media as computer program products. Any form of computer readable medium can be used in this context, such as magnetic or optical storage media. Additionally, software portions of the present invention can be instantiated (for example as object code or executable images) within the memory of any programmable computing device. Accordingly, the disclosure of the present invention is intended to be illustrative, but not limiting, of the scope of the invention, which is set forth in the following claims.