System and method for lazy loading of shared libraries

• US 5,708,811 A
• Filed: 02/21/1995
• Issued: 01/13/1998
• Est. Priority Date: 02/26/1993
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Padgett, Donald Robert, Giangarra, Paul Placido, Arendt, James Wendell, Phelan, James Michael, Manikundalam, Ravindranath Kasinath
• Primary Examiner(s): TOPLU, LUCIEN
• Application Number:
  US08/391,300
• Time in Patent Office: 1,057 Days
• Field of Search: 395/700, 395/425, 395/712, 395/685, 395/413, 395/710, 364/280.4, 364/246.3
• US Class Current: 717/163
• CPC Class Codes: G06F 12/10 Address translation
• CPC Class Codes: G06F 2212/1016 Performance improvement
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

Lazy loading of executable library objects reduces operating system overhead and memory commitment requirements by postponing object loading until object references are expected. Initial task loading allocates only the main executable and library objects referenced by that executable. Secondary referenced objects are not allocated. Object references cause page faults for allocated but not loaded pages. Page fault handling causes loading and fixup of executable objects. Page fault handling also determines the next level of object references and allocates memory for the next object level. Shared memory systems allow sharing of executable objects until explicitly referenced. Once referenced, memory fault causes copying and fixup to referencing task memory area.

Claims

1. A method for loading an executable program into memory from permanent storage, the method comprising the steps of:

a) receiving a request for the executable program, wherein the executable program includes a main executable file and first level object libraries;

b) loading initial executable code of the main executable file into the memory;

c) fetching an executable header of the main executable file from the permanent storage, wherein the executable header includes identity of the first level object libraries;

d) obtaining a virtual memory entry for each object identified in the first level of object libraries;

e) loading an object identified in one of the first level object libraries when the object is referenced;

f) determining identity of the second level object library from the object;

g) determining when an object identified in the second level object library is needed for execution; and

h) when the object identified in the second level object library is needed, loading the object identified in the second level object library into the memory.

2. The method of claim 1, wherein step (h) further comprises:

prior to loading the object identified in the second level object library, obtaining a virtual memory entry for the object identified in the second level object library.

3. The method of claim 1, wherein step (d) further comprises obtaining the virtual memory entry by:

creating a list of objects identified in the first level object library;

determining, for each object in the list of objects, whether a module table entry exists;

when the module table entry does not exist, creating the module table entry; and

when the module table entry exists, registering the module table entry with a virtual memory.

4. The method of claim 1, wherein step (e) further comprises loading the object identified in one of the first level object libraries by:

loading a page of the object into a user virtual memory space; and

when the page is referenced, loading the page into the memory.

5. The method of claim 4 further comprises loading the page by:

determining that the page is stored in the user virtual memory space;

generating a page fault; and

retrieving the page from the permanent storage in response to the page fault.

6. An apparatus for loading an executable program into memory from permanent storage, the apparatus comprising:

tasking block;

loading block; and

virtual memory block;

wherein, when a user space requests an executable program;

the tasking block creates a task, registers the task with the virtual memory block, and causes the loader block to initiate memory loading of the executable program;

the loader block accesses a main executable file and objects identified in first level object libraries based on a executable file header, loads initial executable code of the main executable file into user memory, and, for each object identified in one of the first level of libraries, provides a module table entry which is registered with the virtual memory block;

the virtual memory block stores a virtual representation of the objects identified in the first level object libraries and a virtual representation of data of the main executable file;

wherein, when the user space is executing the executable program;

the tasking block detects when one of the objects identified in the first level object libraries is referenced by the initial executable code, generates a load command and determines a second level object library from the one of the objects identified in the first level object libraries;

the virtual memory block, in response to the load command, determines whether the one of the objects identified in the first level object libraries is currently in the user memory, and when the one of the objects identified in the first level object libraries is not in the user memory, generates a page fault, and provides a virtual representation of objects identified in the second level object library;

the loader block, in response to the page fault, accesses the one of the objects identified in the first level object libraries to load into the user memory.

7. The apparatus of claim 6, wherein, when the user space requests a second executable program, the task block generates a second task and registers the second task with the virtual memory block;

and wherein, when the user space is executing the second executable program and such execution references an object, the virtual memory determines whether the object already has a virtual representation from the execution of the executable program, and when the object does have the virtual representation, reusing the virtual representation for the execution of the second executable program.