Data processing: software development – installation – and managem – Software program development tool – Linking
Reexamination Certificate
2000-09-29
2004-10-26
Ingberg, Todd (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Linking
Reexamination Certificate
active
06810519
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The invention is generally related to computers and computer software. More specifically, the invention is generally related to improving the execution of software compiled as a plurality of software modules.
2. Background of the Related Art
The most efficient code for a computer program can be generated when all components, including referenced subroutines, are known and are included in the software compilation process. This allows the compiler for the computer program to perform several optimizations that are well-known to the compiler arts, including but not limited to: (a) using the tightest possible call protocol between “caller” and “callee” software modules; (b) inlining of the callee software module into the caller software module; and (c) global analysis. The caller software module is a module or procedure that calls or invokes another software module, subroutine or object. The callee software module is the software module, subroutine or object called or invoked.
Using the tightest possible call protocol between “caller” and “callee” software modules comprises using a direct vs indirect call if the relative address of the callee software module is known (since it is a part of the same compilation unit). Other optimizations such as coordinated register assignment are also possible.
Inlining of the callee software module into the caller software module comprises a step beyond tight binding, where the code of the callee software module is actually copied into the instruction stream of the caller software module. This allows the code of the callee to be customized for the particular case at hand, by, for example, propagating literal parameter values into the body of the callee.
Global analysis comprises the analysis of the data flow beyond the boundaries of a single subroutine, thereby enabling such things as eliminating stores to unreferenced data fields, optimizing into registers data that is only referenced in a localized fashion, and the like.
Even when all the referenced subroutines and other such components of a software program to be compiled are not known at compile time, most of the optimizations that are possible with “complete knowledge” are still possible to a lesser extent with “incomplete knowledge.” Thus, there is still an advantage to including in the compilation process those subroutines and other components that can be identified and included.
Unfortunately, in the “incomplete knowledge” case, there are several additional problems that can arise. For example, when the runtime environment of the program to be compiled will consist of several separately compiled pieces or modules, it may be discovered that the same subroutine (or other software component) was included in more than one separately compiled piece or module. This would not be a problem for purely procedural subroutines, but when the subroutines have static storage of one form or another (including the static data structures associated with C++ or JAVA® programming language classes) then errors will result unless a single static storage image is somehow shared between all copies.
When referenced subroutines or other components are included in a compilation unit, it may be discovered at execution time that different versions of those subroutines or components were in different compilation units that comprise the runtime environment of the program. If this is the case, even if a single static storage image is shared between copies errors may result since the expected static storage layout may not be identical between all copies.
Even when separately compiled copies of the same subroutine or other component are compatible and when the problem of addressing a common static storage view is addressed, there may be other static data associated with a subroutine or component that is compiler-generated and hence which cannot be validly shared between copies. Separate copies of such data must be maintained.
It also should be noted that even when all referenced subroutines and other components are known and accessible at compile time, there may be practical reasons why they cannot all be processed within a single compilation operation. For instance, there may be limits to the size of a compiled object that can be created, requiring that the complete computer program be broken into several separate compiled objects.
Binding by copying to avoid references between separate compilation or load units has been done in several contexts, such as in “overlayed” applications to avoid overlay “thrashing.” Binding is also performed done to some degree in current dynamic link library (DLL) based implementations as well, in order to permit the advantages of tight binding. However, these designs either require that the copied subroutines be purely functional or require that static storage be manually controlled so that it will be accessible and equivalently viewed from all versions of a given subroutine.
SUMMARY OF THE INVENTION
This invention addresses these and other problems associated with the prior art by providing a computer system, a computer product, a method and a framework in which static storage within an environment comprising a plurality of compilation modules is managed such that compiled cloned copies of called externally resolved (with respect to a compilation unit) items are preferentially executed in favor of the corresponding externally resolved item based on a favorable comparison of version information prior to execution. The cloned copies are compiled in a manner providing internal resolution (with respect to the compilation unit) by, for example, in-line coding. In one embodiment, JAVA® programming language methods are processed within the context of a modified framework.
Specifically, according to an embodiment of the invention, a method for compiling, in one of a plurality of compilation units, a subroutine having associated with it calls to items having addresses resolved external to the one compilation unit, the method comprising the steps of: copying each of the external resolution items into the one compilation unit to form respective internal resolution items, and compiling the subroutine using the external resolution items and the respective internal resolution items, each of the items having associated with it a respective version indicium for identifying inter-compilation unit version conflicts during execution of the compiled subroutine, wherein corresponding compiled external resolution items are executed in the case of inter-compilation version conflicts.
REFERENCES:
patent: 5805899 (1998-09-01), Evans et al.
patent: 5966702 (1999-10-01), Fresko et al.
patent: 6298478 (2001-10-01), Nally et al.
James Noble, et al., “Object Ownership for Dynamic Alias Protection,” 1999, IEEE Computer Society Press, Proceedings of Technology of Object-Oriented Languages and Systems (TOOLS 32) Melbourne, pp 176-187.
Ingberg Todd
International Business Machines - Corporation
Kiss Eric B.
Moser Patterson & Sheridan LLP
LandOfFree
Achieving tight binding for dynamically loaded software... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Achieving tight binding for dynamically loaded software..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Achieving tight binding for dynamically loaded software... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3276848