Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1999-09-28
2003-04-08
Morse, Gregory (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C717S153000, C717S148000, C717S165000, C717S156000
Reexamination Certificate
active
06546551
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention generally relates to object-oriented programming (OOP), and in particular to OOP systems supporting the C++ and Java™ programming languages.
2. Description of the Related Art
Object-oriented programming languages provide a number of features such as classes, inheritance, and virtual methods. These object-oriented features have several advantages. In particular, they enable the creation of class libraries that can be reused by many different applications, in many different contexts.
Class libraries are usually distributed separately from applications that use them. A disadvantage of this traditional distribution model is that the shipped class libraries can be very large, and hence require large amounts of space to store them, and large amounts of time to download them. In cases where an application only uses a small part of a class library's functionality, distribution of the entire library is often undesirable, because the user effectively pays a penalty for unused library features. A more detailed description of such problems is set forth in Tip et al., “Practical experience with an application extractor for java™,”
In Proceedings of the Fourteenth Annual Conference on Object
-
Oriented Programming Systems, Languages, and Applications
(OOPSLA'99) (Denver, Colo., 1999), herein incorporated by reference in its entirety.
To address this problem, application extraction tools have been designed and implemented. Such tools are discussed in Agesen et al., “Sifting out the gold: Delivering compact applications from an exploratory object-oriented programming environment,” In
Proceedings of the Ninth Annual Conference on Object
-
Oriented Programming Systems, Languages, and Applications
(OOPSLA'94) (Portland, Oreg., 1994),
ACM SIGPLAN Notices
29(10), pp. 355-370; Agesen, “Concrete Type Inference: Delivering Object-Oriented Applications,” Sun Microsystems Laboratories Technical Report SMLI TR-96-52, December 1995; Tip et al., “Practical experience with an application extractor for java™,” In
Proceedings of the Fourteenth Annual Conference on Object
-
Oriented Programming Systems, Languages, and Applications
(OOPSLA'99) (Denver, Colo., 1999);
IBM Smalltalk User's Guide,
version 3, release 0 ed., IBM Corp, 1995, Chapters 36-38; Smalltalk/V for win32 Programming, Digitalk Inc., 1993, Chapter 17; and ParcPlace Smalltalk, objectworks release 4.1 ed., 1992, Sections 16, 28; herein incorporated by reference in their entirety. Such tools can perform a static whole-program analysis of the application along with the libraries that it depends on to determine the parts of the library and the application that are used. Subsequently, program transformations and optimizations are performed that eliminate the unused functionality of the application and the library, thereby reducing both application size and download time.
Modern object-oriented programming environments such as the Java™ platform load object oriented programs dynamically, create object instances dynamically when they are needed, and link such object instances dynamically for execution. In addition, such platforms typically include a reflection mechanism by which an object-oriented program can fetch information about a class of objects, or access program components by specifying their name. For example, a program can inquire about the name of a class associated with an object reference, or the number of methods defined in a class. Dynamic loading is another example of reflection. Here, the programmer instructs the platform to load a class with a specified name, after which instances of this class can be created. For a more detailed description of the Java™ reflection mechanism, see McManis, “Take an in-depth look at the Java™ Reflection API”, http://www.javaworld.com/jw-09-1997/jw-09-indepth.html, herein incorporated by reference in its entirety. The use of reflection poses a problem for application extraction tools because a static analysis alone cannot determine which classes are instantiated using reflection, and which methods are invoked using reflection. Without this information, a safe approximation of the application's call graph cannot be constructed; and without a safe call graph, it is unclear which methods are unused so that extraction of the application is impossible.
In order to handle applications that use reflection, or applications that uses class libraries in which reflection is used, application extraction tools require additional information from the user. In current application extraction tools, this information takes the form of a list of the classes, methods, and fields in an application that are accessed using reflection. This information is then used to construct a safe approximation of the call graph, and the application can be extracted safely. The drawbacks of this approach have to do with the fact that the set of program components accessed using reflection in a class library depend on the library features used by an application. Hence, if a user wants to extract multiple applications with regard to the same library, he is faced with two options:
(1) Construct a global list of program components in the library that may be accessed anywhere in the class library using reflection. This list can safely be used for extracting any applications with respect to the library; or
(2) For a given application that is to be extracted with respect to the library, construct a list of program components in the library that are accessed using reflection in the parts of the library used by that application.
Option (1) has the advantage that only a single “configuration file” needs to be written for the library, but it has the disadvantage of being overly conservative: the extracted applications may contain parts of the library that they do not use.
Option (2) has the advantage that each application is extracted only with the parts of the library that it uses, but it has the disadvantage that a separate configuration file is required for each application.
Therefore, there is a need in the art to provide a mechanism for accurately and efficiently extracting object-oriented components of a library that are potentially used in the execution of multiple applications.
SUMMARY OF THE INVENTION
The problems presented above and the related problems of the prior art are solved by the present invention, method, and apparatus for accurately extracting library-based object-oriented applications. The present invention is capable of accurately extracting multiple applications with respect to a class library. The invention relies on a single configuration file for the library, which describes how program components in the library should be preserved under specified conditions. The invention may be used in application extraction tools, and in tools that aim at enhancing performance using whole-program optimizations.
The invention may be used as an optimization to reduce application size by eliminating unreachable methods. In the alternative, the invention may be used as a basis for optimizations that reduce execution time (e.g., by means of call devirtualization), and as a basis for tools for program understanding and debugging.
REFERENCES:
patent: 5241673 (1993-08-01), Schelvis
patent: 5794041 (1998-08-01), Law et al.
patent: 5872973 (1999-02-01), Mitchell et al.
patent: 5907843 (1999-05-01), Cleron et al.
patent: 5915252 (1999-06-01), Misheski et al.
patent: 5983020 (1999-11-01), Sweeney et al.
patent: 6093216 (2000-07-01), Adl-Tabatabai et al.
patent: 6230314 (2001-05-01), Sweeney et al.
patent: 6292933 (2001-09-01), Bahrs et al.
patent: 6401182 (2002-06-01), Sweeney
patent: 6442748 (2002-08-01), Bowman-Amuah
Title: Reflection in an Object-Oriented Concurrent Language, author: Watanabe et al, ACM, 1988.*
Title: Cost effective object space management for hardware assisted real time garbage collection, author: Nilson, ACM, 1992.*
Title: Call graph construction in Object-Oriented Languages, Grove et al, ACM, Oct., 199
Sweeney Peter Francis
Tip Frank
Das Chameli C.
F. Chau & Associates LLP
International Business Machines - Corporation
Morse Gregory
LandOfFree
Method for accurately extracting library-based... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method for accurately extracting library-based..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method for accurately extracting library-based... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3083622