Abstract: A method of linking a plurality of object code modules to form an executable program, each object code module having section data, a set of relocation instructions and one or more symbols, each symbol having a plurality of attributes associated therewith, wherein the relocation instructions include a data retrieval instruction having a symbol field identifying a symbol and an attribute field identifying a symbol attribute associated with the identified symbol to be retrieved, the method including reading at least one relocation instruction from the set of relocation instructions and where the relocation instruction is a data retrieval instruction, determining the symbol identified by the symbol field and retrieving one of the plurality of symbol attributes associated with the symbol in dependence on the contents of the symbol attributes field of the instruction.

Abstract: Less data to transmit from a server to a virtual machine on a client is achieved by transmitting only those methods of classes that the executed application actually requires. This is accomplished by taking the classes of the targeted application and statically determining which methods of these classes, as well as of the library classes, can actually be used by the application. A method usage map of usable methods for each class is saved in a file. When the request to download is received from the client, the server consults this map and selectively transmits only those methods that are in it. This saves download time and memory space in the virtual machine and speeds up execution.

Abstract: In an ASP server farm, requests to use an application are directed to a particular executing instance of the application (or an appropriate component thereof) that is identified as being the least loaded of the available such instances of the application or its component. The number of such instances is dynamically increased or decreased in response to the number of requests for the application or components thereof. Requests may be directed (in accordance with the first aspect) or the instances adjusted (in accordance with a second aspect) on a per client-basis, in which instances of the application and/or components thereof are reserved for the use of a user or a particular group of users. Operation in this manner facilitates compliance with service agreements with respective users or groups of users.

Abstract: A method and system for providing “just-in-time” dynamic loading and unloading of libraries. Library code is loaded into memory just prior to the actual execution of a routine in that library and is unloaded from memory after the execution of the library routine is completed. According to the present invention, a library structure having a library loader and a library implementation module. The library loader provides the same entry points as the library itself and contains code to drive the loading and unloading of the library implementation module which actually contains the code to implement the library call. At the beginning of the execution of an application or other software module, the library loaders for libraries needed by that application or other software module, are loaded into memory and unloaded upon completion of that application or other software module.

Abstract: A method for program verification comprises receiving a program unit, determining data types used by the program unit, creating a first mapping for the data types and using the first mapping to represent type information in verification information for the program unit. The verification information comprises the data type of entries on an operand stack or in a register file during simulated execution of the program unit.

Abstract: A method and system for providing an executable module having an address space for storing program data that is to reside in a read-only storage medium and an address space for storing program data that is to reside in a random access memory is herein described. The executable module represents Java classes that are structured for dynamic class loading. A static class loader is used to modify the class structure to accommodate static loading. The static class loader also identifies methods that contain unresolved symbolic references and data that varies during the execution of the module. These methods and data are identified in order to place them in the address space that resides in the random access memory. The static loader is beneficial in a distributed computing environment having a client computer that has little or no secondary storage thereby requiring applications to run entirely in random access memory.

Abstract: The invention provides a method and system for managing memory for software modules in a computer processing environment. According to a first aspect of the invention, a method includes allocating memory for a first software module. The method also includes loading the first software module into the allocated memory. The first software module includes processor executable instructions for loading a second software module into memory. The method further includes registering the first software module for service and loading the second software module. According to a second aspect of the invention, a method is provided for releasing memory allocated according to the first aspect of the invention. Systems and articles of manufacture for managing memory for software modules are also described.

Abstract: One embodiment of the present invention provides a system that determines class dependencies of a class. The system operates by: receiving a representation of the class; creating a model of the class from the representation; analyzing the model to detect references to supporting classes; and creating a list of all dependent classes. For each supporting class found, the system recursively determines the dependencies of that class and adds them to the list. In a variation on this embodiment, the system identifies classes that an object depends on by: receiving a representation of an object; parsing the object to identify any classes on which the object depends; and analyzing and documenting the class dependencies of the object and all dependent classes.

Abstract: A mutability mechanism is provided for parsing an object at loading time. The mutability mechanism inserts a property into the object that indicates whether or not the object is immutable. The mutability mechanism looks at the code for the object and determines whether any other objects can modify the object. If the object cannot be modified after it is created, then the new property is set to indicate that the object is immutable; otherwise, the property is set to indicate that the object is mutable. This property can be inspected at runtime when a call is made to a program object. If an object passed as an argument is marked mutable, a clone of this object must be passed to the callee. However, if an object passed as an argument is marked immutable, a simple reference to the object may be passed as an argument to the callee.

Abstract: In a cluster of computing nodes having shared access to one or more volumes of data storage using a parallel file system, a method for managing the data storage includes selecting a first one of the nodes to serve as a session manager node, and selecting a second one of the nodes to serve as a session node for a data management application. A session of the data management application is created on the session node by sending a message from the session node to the session manager node, causing the session manager node to distribute information regarding the session among the nodes in the cluster. Responsive to the information distributed by the session manager node, events are received at the session node from the nodes in the cluster for processing by the data management application.

Abstract: A method for linking compiled pattern data and loading the data into tester hardware includes the steps of generating a composite object that includes a shared resource, determining a local shared resource specific to a test instrument that is associated with the shared resource in the composite object, assigning a local reconciled value or address to the local shared resource, and loading the local shared resource into the test instrument.

Abstract: Method and apparatus for extending functionality of a first set of classes and methods in an application hosted by a computing arrangement. A mapping is established that maps original class names in the first set to corresponding substitute class names of classes in a second set. The classes in the second set change the functionality of the classes in the first set. In response to loading a class file of a class in the first set, the original class names are replaced with corresponding substitute class names in the class file. Classes referenced by the substitute class names are then instantiated in lieu of classes referenced by the original class names.

Abstract: Method and apparatus for processing java server pages (JSPs) which reduces the delays resulting from a first time invocation of a JSP. One embodiment provides a method for processing JSPs for a java virtual machine (JVM), comprising: selecting one or more JSP files to be processed for the JVM; translating the JSP files to java source code files; inserting quick exit codes to java source code files; compiling java source code files to servlet class files; and loading servlet class files into the JVM.

Abstract: Methods and computer readable media for a software tool capable of subdividing programs into autonomous modules, where the modules enable a feature of the program, are provided. One exemplary method includes a computer implemented method for identifying modules of an executable program. The method begins with initiating the executable program. Then, the executable program is monitored as it is running. The monitoring of the executable program further includes, identifying interrelated classes for each of the modules where each of the modules correspond to a feature functionality of the executable program. Also included in the monitoring is generating a data structure for each module as the executable program is running. Here, the data structure defines the classes for each feature functionality.

Abstract: A system and method for EJB classloading. By changing the EJB classloading scheme so that the EJB impl class is loaded in a child ClassLoader, the system allows the old EJB impl class to be replaced with a new one without disturbing the rest of the deployment. The key to doing this is to remove all direct references to the EJB impl class from classes loaded in the parent ClassLoaders. Removing this dependency allows the old EJB impl class to be replaced at any time with a new impl class.

Abstract: A custom class loader configured to dynamically locate and load classes in a virtual machine in accordance with an associated dependency specification. The custom class loader can include class loading logic configured to specifically and dynamically locate, define and load a class specified by name. The custom class loader also can include a list of peer class loaders arranged in a peer-to-peer fashion in accordance with the associated dependency specification in the virtual machine. In this regard, list generation logic can be included which can generate the list when the specified class has been replaced. Finally, the custom class loader can include deference logic configured to defer the location, definition and loading of the specified class to the peer class loaders in the list.

Abstract: A smaller footprint is loaded into the virtual machine by loading only those methods of library classes that the executed application actually requires. This is accomplished by taking the classes of the targeted application and statically determining which methods of these classes, as well as of the library classes, can actually be used by the application. A generated method usage map of usable methods for each class are saved in a file. At runtime, the virtual machine consults this file and selectively loads into memory only those classes listed in the file. This saves memory space in the virtual machine and speeds execution.

Abstract: Method and apparatus for switching between multiple implementations of a routine. A plurality of implementations of a routine are compiled into respective object code modules. In one embodiment, each implementation of the routine is adapted for a particular hardware configuration. The different object code modules are associated with respective sets of hardware characteristics and with the name of the routine. When the application program and library are loaded into memory of the computer system, a references to the routine are resolved using the sets of hardware characteristics and the hardware configuration of the system.

Abstract: An apparatus and method provide a cache for analyzed program information when no class file can be identified. When loading a class, if there is an identifiable class file for the class, the class file is checked to determine if analyzed program information is attached. If so, the analyzed program information can be directly used without the overhead of analyzing the program information again. If there is no identifiable class file for the class, a cache is checked to see if there is an entry in the cache corresponding to the class. If there is no entry in the cache corresponding to the class, the program information is analyzed and saved in a cache entry for future use. If there is an entry in the cache corresponding to the class, the analyzed program information is retrieved and used, thereby saving the time required to repeatedly analyze the program information.

Abstract: A process and system for externalizing classloader information to non-application modules such as tool modules that do not reside within the same Application server virtual machine such as a J2EE AppServer JVM. Tools that read and display classloader information typically need to co-reside within the AppServer because of the virtual machine security mechanisms that prevent classes outside the virtual machine itself to introspect the classloaders. This presents a problem for tooling vendors because most server owners do not want anything other than their applications running within the AppServer virtual machine. The invention allows tooling vendors to create a classloader tool that is external to the AppServer virtual machine, and which is running in a completely separate virtual machine, thus having minimal overhead on production systems, but which allows classloading through standard or open (e.g. non-proprietary) interfaces.

Abstract: One embodiment of the present invention provides a system that initializes system classes for a virtual machine during build time for the virtual machine, so that portions of the system classes can be stored in Read Only Memory (ROM). During virtual machine build time, the system loads system classes for the virtual machine. Next, the system identifies which of the system classes can be initialized at build time and then initializes the identified system classes. The system then stores portions of the system classes in a ROM image, so that the portions of the system classes can be accessed from the ROM image during subsequent run-time execution of the virtual machine. In this way, this embodiment of the present invention reduces the amount of time required to initialize system classes during run-time execution of the virtual machine.

Abstract: Embodiments of a system and method for providing class dependency graph-based class loading and reloading may be used to segregate namespaces in a graph-centric way, and may provide a set of normalized topologies that may be used to efficiently support hot-swapping of programmatic logic such as classes, applets, and beans, among other applications. Embodiments may provide a domain-independent, flexible and robust namespace segregation technique that is based on the dependency between the various classes and not on details like the roles the classes play. The problem of segregating namespaces is formulated as a graph theory problem, and a solution is sought through graph techniques. The graph may be normalized by identifying and grouping interdependent classes and non-interdependent classes in separate groups. A directed dependency relationship of the groups may be determined using the relationships between the member classes of the groups.

Abstract: Improved techniques for representation of objects in a Java™ programming environment are disclosed. The techniques are highly suitable for representation of Java™ objects inside virtual machines, especially those that operate with limited resources (e.g., embedded systems). A cluster of Java™ object representations is disclosed. Each of the Java™ object representations provide a reference to a Java™ object and a reference to the class associated with the Java™ object. Accordingly, a two-tier representation is provided which allows efficient implementation of applications which need to access information regarding both Java™ objects and classes. As a result, quick access to information regarding Java™ objects can be achieved.

Abstract: A program generation apparatus for generating light-weight class files for each terminal apparatus by linking class files. The program generation apparatus includes: a storage unit for prestoring the class files for each terminal apparatus, where each class defines (a) dependent variables unique to each terminal apparatus and (b) non-dependent variables common to all the terminal apparatuses, each variable is identified by a variable name, and each class file includes a variable name for each variable; an assignment unit for assigning an offset number to each variable defined in the class files so that the same offset numbers are assigned to non-dependent variables having the same variable names; and a generation unit for generating the light-weight class files for each terminal apparatus by replacing each variable name in each class file with an offset number assigned by the assignment unit.

Abstract: Improved techniques for loading class files into virtual computing machines are disclosed. These techniques provide a mechanism that will generally improve the efficiency of virtual machines by selectively loading information into a virtual machine. As will be appreciated, this allows a better use of the resources of the virtual machine. This is especially effective in virtual machines that operate with limited memory resources (e.g., embedded systems). In one embodiment, class files suitable for loading into a virtual machine are initially loaded into a memory portion (e.g., heap memory). Then, information that is needed to be loaded into the virtual machine is selected. Finally, only the selected information is loaded into the virtual machine.

Abstract: A method for calling a software method in a called CORBA application by a caller software method in a caller CORBA application in a process of a computer system is disclosed. The caller software method calls a software method in a CORBA stub sending a parameter which is created using a classloader of the caller application. The CORBA stub software method calls a software method in a dynamic proxy sending the parameter. The dynamic proxy software method calls an ORB sending the parameter. The ORB serializes the parameter and returns it to the dynamic proxy software method. The dynamic proxy software method calls the ORB sending the serialized parameter. The ORB deserializes the serialized parameter using a classloader of the called application and returns it to the dynamic proxy software method. The dynamic proxy software method calls the called software method sending the deserialized parameter.

Abstract: Improved frameworks for loading and execution of portable, platform independent programming instructions within a virtual machine are described. The improved frameworks provides a mechanism that will generally improve the runtime performance of virtual machines by eliminating the need to always traverse a constant pool at runtime to execute a Java™ instruction. In addition, specific data structures that are suitable for use within a virtual machine and methods for creating such data structures are described. Accordingly, an enhanced Java™ bytecode representation having a pair of Java™ bytecode streams is disclosed. The enhanced Java™ bytecode has a Java™ code stream suitable for storing various Java™ commands as bytecodes within a code stream. A Java™ data stream of the enhanced Java™ bytecode representation is used to store the data parameters associated with the Java™ commands in the code stream. Actual parameter values, or references to actual parameter values can be provided in the data stream.

Abstract: A method of operating a computer system includes providing a first version of a program in memory and verifying the program prior to program execution. Program verification includes indicating a verification error when a first version of a first program unit implementation is not internally consistent, indicating a verification error when the first version of the first program unit implementation is inconsistent with the version of the program unit API definition file associated with the first version of the first program unit implementation, receiving a second version of the first program unit implementation and a second version of the first program unit implementation is binary compatible with the first version of the first program unit implementation by comparing the first version of the first program unit API definition file and the second version of the first program unit API definition unit.

Abstract: Improved frameworks for loading and execution of portable, platform independent programming instructions within a virtual machine are disclosed. The improved frameworks provide a mechanism that will generally improve the runtime performance of virtual machines by eliminating the need to always traverse a constant pool at runtime to execute a Java instruction. In effect, the described system contemplates doing some extra work during the loading of a class into a virtual machine by obtaining the information from the constant pool during loading and representing that information in a form that can be used more efficiently at runtime. Accordingly, methods for creating data structures suitable for use by a virtual machine to execute load constant commands, as well as methods for execution of Java load constant instructions are disclosed.

Abstract: A method of operating a computer involving data structures in a set of data structures. As unloaded data structures are needed during runtime, a data structure is received from a first memory. The data structure includes one or more sets of instructions and one or more constants. Instructions from the data structure are stored in a first portion of a second memory, which comprises RAM. Constants from the data structure are stored in a second portion of the second memory if only if the respective constant has not been stored in the second portion of the second memory. Indexes in instructions that reference the constants are modified to correspond to the respective locations of the constants in the second portion of the second memory, and at least some instructions from the data structure are read and executed from the RAM.

Abstract: A method and corresponding apparatus for localization of a JAVA® application using a reflection API and a custom class loader use specifics of JAVA® language to provide localization of certain data elements, i.e., variables, of the application during class loading. The method and corresponding apparatus for localization reduce complexity of the JAVA® application by eliminating the function code dedicated to localization. In addition, the method and apparatus for localization increase productivity of engineers who write language-independent code, and reduce memory consumption of classes that use localized strings. Since all localization is accomplished when the class is loaded and since the code that uses localization is independent of the code performing localization, the method and apparatus for localization ensure better performance of the application and afford better code reusability.

Abstract: A system and method is provided for facilitating and implementing an efficient mechanism for performing an interface dispatch. The system and method retrieves source code and performs a pre-execution or preparation stage prior to execution of the source code. During the pre-execution stage memory is allocated for class types, class method tables are formed and interface virtual tables are formed. A block of memory is also allocated for an interface map in the form of a vector having a plurality of slots. The system and method packs the interface map with references to the interface virtual table locations utilizing a comb-vector technique.

Abstract: A method is provided that enables native code, dynamically compiled from platform-independent code by one task of a multitasking virtual machine, to be used by other tasks. The system interprets the platform-independent code of a method for a threshold number of interpretations, and then produces class initialization dependent (CID) native code. The runtime of the system guarantees that a task uses CID code of a method only when all of the classes of an initialized set associated with the CID code have been initialized by the task, and otherwise, interprets the platform-independent code of the method. This allows the compiler to avoid generating class initialization barriers for classes from the initialized set. After a threshold number of failures to execute the CID code of a method, task re-entrant code is generated to replace the interpretation of its platform-independent code.

Abstract: A modified JAVA(™) execution environment is described. The modified environment supports multiple JAVA(™) applications on a single JAVA(™) virtual machine (JVM). This modified environment provides significant memory and performance improvements when running multiple applications on a single computer system. Notably, no changes are needed to the source code of an application to take advantage of the modified environment. Further, embodiments of the invention may support shared access to base classes through the use of overlays. Additionally, system resource permissions can be enforced based upon the user permissions associated with a running application. Notably, embodiments of the invention allow multiple applications to share the abstract window toolkit (AWT) on a per display basis. Since only a single garbage collection routine is necessary, applications see improved performance relative to running in different JVMs. Further, the shared base classes eliminate significant memory overhead.

Abstract: According to the preferred embodiments, an object oriented mechanism and method allow creating system level Java code that is protected, and therefore cannot be accessed or extended by unauthorized users or programs. Several new tests are performed during loading, linking, and initialization of a class that assure that the class is as the operating system expects. In addition, one or more runtime tests may be performed to prevent programs from getting into the Java system level code via a runtime “back door.” By providing additional tests when classes are loaded and when certain types of methods and functions are invoked at runtime, the Java system level code is protected from unauthorized access and use.

Abstract: A system and method for providing dynamic class reloading using a modular, pluggable and maintainable class loader is described. Each application in an application server (or alternatively in any implementation) may include a dynamic class loader module. The class loader module may include a hierarchical stack of class loaders. Each module in the application may be associated with its own class loader. Each class loader may be responsible for loading one or more classes. When a class is changed, the changed class may be detected by the class loader module. Any notification for a class change may come to the class loader controller so that the concerned class loader can be replaced. The class loaders for all classes that depend on the changed class may also be replaced. The replaced class loaders may then reload the affected classes.

Abstract: An existing neutral operating system (OS) signal is utilized to notify a virtual machine (VM) about a change to its execution parameters. The signal is predefined to indicate that an execution parameter should be changed, and upon receipt, the VM may look up a file in a predefined location, the file containing the new command line parameters. The VM may then modify its parameters to match the file, and continue with its execution, thus providing a mechanism for altering VM execution parameters at runtime.

Abstract: A system, comprising a receiving module to receive a request to load a component, a stack to record the request and a loader to fulfill the request, wherein when the request has been fulfilled the request is removed from the stack and when the loading of the component is unsuccessful, contents of the stack are made available to a user to indicate the unsuccessfully loaded component.

Abstract: The present invention provides a visual linker. The visual linker includes a link server that implements linking instructions for sections to a memory. The visual linker also includes a graphical user interface that receives said instructions and displays said sections within said memory. The visual linker also includes an application programming interface that receives said instructions and reports the results of said linking instruction and said sections within said memory. The visual linker also includes an incomplete link comprising sections not allocated to said memory. The visual linker also includes a link recipe comprising said instructions implemented by said link server.

Abstract: Methods and apparatus for managing execution of an application according to an application lifecycle. The application lifecycle is managed by an application manager through a set of commands that enable the application manager to cause the application to enter one of a plurality of states. In addition, the application can communicate with the application manager to indicate that the application cannot change its state as the application manager has requested or to request that the application manager change the state of the application to a particular state.

Abstract: A hash table dispatch mechanism for interface Methods. The mechanism reduces dispatch times during the execution of an object-oriented language program. An interface hash table having a pointer as an index for either a specific location in a corresponding dispatch table or an interface Method of the program is created for a dispatch table. The interface hash table has an address and a plurality of slots having a hash value related to an interface Method. The mechanism includes a recovery Method for resolving conflicts when two or more slots in the interface hash table contain clashing values.

Abstract: A computer system includes multiple class loaders for loading program class files into the system. A constraint checking mechanism is provided wherein a first class file loaded by a first class loader makes a symbolic reference to a second class file loaded by a second class loader, the symbolic reference including a descriptor of a third class file. The constraint mechanism requires that the first and second class files agree on the identity of the third class file and stores a list of constraints as a set of asymmetric relationships between class loaders. Each stored constraint, for a class loader which loaded a class file that contains a symbolic reference to another class file, includes a first parameter denoting the class loader which loaded the class file to which the symbolic references is made; and a second parameter denoting a class file which is identified by a descriptor in said symbolic reference.

Abstract: Disclosed is a system and method for enabling dynamic class reloading in the application server environment. Users may specify class versionability by specifying a list of explicitly versionable classes; and the application server(s) may execute a background task which operates periodically to check modified versionable classes, and cause the classes to be reloaded. Administrators may specify a set of class files to be treated as a “bundle”. When the bundle is deployed, a deployer manager may obtain a lock, e.g. a semaphore, referred to as the “dirtyClassListLock”. Once this lock is obtained, the deployer manager may copy all the class files in the bundle from a deployment environment to their appropriate runtime locations. After the runtime locations have been updated, the deployer manager may release the dirtyClassListLock. According to this method, the background task that checks for and reloads modified classes may also have to obtain the dirtyClassListLock in order to run.

Abstract: System and method for dynamic loading of remote classes. Using embodiments, remote classes may be loaded dynamically by a default class loader without the use of separate, custom class loaders. The remote class loader mechanism may locate on remote systems classes needed by code executing on the local system but not locally stored, and which therefore cannot be located and loaded by the default class loader. After locating the classes, the remote class loader mechanism may obtain copies of the classes and save them to a location indicated by the class path of the default class loader. The default class loader can then locate and load the classes from the location indicated by the class path.

Abstract: A method and apparatus for managing a run-time environment is provided for improving performance and scalability of networked computer systems. In one example of the invention, a method starts by loading a class file, the class file specifying a class that includes a static class variable and a static initializer to initialize the static class variable. The static initializer is then invoked to initialize the static class variable. The class and the initialized static class variable are then saved in a second class file. The second class file is then loaded into a shared memory, the second class file including the class and the initialized static class variable.

Abstract: Disclosed is a method for executing a remote method. Each argument of the remote method is wrapped when the argument is a remote object (e.g. the argument's declared class implements a remote marker interface). However, each argument of the remote method is copied when an argument is not a remote object. The remote method is invoked using the wrapped or copied argument(s) (e.g. the wrapped or copied arguments are passed to the invoked method). A result of the invoked remote method is then wrapped (e.g., prior to being passed to the process that is receiving the result) when the result is a remote object (e.g., the result's declared class does not implement the remote marker interface). In contrast, the result of the remote method is copied (e.g., the copy is then passed to the process that is receiving the result) when the result is are remote object.

Abstract: A computer system, a computer product and a method 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 of version information prior to execution. In one embodiment, JAVA® programming language methods are processed within the context a modified framework.

Abstract: An interpreter serves for a programming language. It first receives information specifying names and the like of multiple applications written in the programming language. Then, the interpreter generates individual application areas corresponding to the applications for storing data required for execution of the applications. It also generates a task for each of the applications and executes the application in the task. If the interpreter detects a new class in required classes during execution of the individual applications, it loads bytecodes for the new class in a shared area. Also, if the new class has a class variable, the interpreter allocates a class variable area for the class variable which corresponds to the application. Furthermore, to access a class variable during execution of an application, the interpreter accesses a class variable area for the class variable in the individual application area corresponding to the application.

Abstract: A system for shortening the class loading process in a Java program according to the present invention includes a class loader unit for loading Java program class files from an auxiliary memory, performing linking and initialization processes and generating runtime data; a first memory unit for maintaining the runtime data generated by the class loader unit in an accessible state; a second memory unit for storing the runtime data, which have been loaded into the first memory unit in an accessible state, in the form of images; a runtime data search unit for loading the runtime data, which have been stored in the second memory unit in the form of images, into the first memory unit upon the request of the class loader unit; and an execution unit for executing the runtime data that have been loaded into the first memory unit in an accessible state.

Abstract: A system and method are provided in which relevant byte codes that are frequently used upon execution of a Java program are compiled to corresponding native codes and the resultant native codes are stored so that the native codes for the relevant byte codes are retrieved and executed upon future execution of the Java program, thereby shortening the time required for generating the native codes by compiling the byte codes.