Apparatus and method for demand loading a dynamic link library

Abstract

An apparatus and method for demand loading a dynamic link library (DLL) is disclosed. The method includes generating a demand load library for demand loading the DLL and replacing the reference library of the DLL with the demand load library.

Claims

What is claimed is:

1. A method, implemented in an information handling system having an operating system, for demand loading a dynamic link library (DLL) having a reference library for resolving references to the DLL, said method comprising the steps of:

finding entry points into the DLL;

generating a demand load library including program code for performing the following steps for each entry point:

determining whether an address corresponding to the entry point has been called before;

if the address corresponding to the entry point has not been called before, then calling a demand loading initialization routine; and

jumping to the address corresponding to the entry point; and

replacing the reference library of the DLL with the demand load library.

2. The method, as recited in claim 1, wherein said step of calling a demand loading initialization routine includes the step of calling APIs from the operating system.

3. The method, as recited in claim 2, wherein said step of calling APIs includes the step of calling a load API for loading the DLL if the entry point has not been called before.

4. The method, as recited in claim 3, wherein said step of calling a load API further includes the step of inputting the name of the entry point to the load API.

5. The method, as recited in claim 4, wherein said step of calling APIs further includes the step of calling an address API for returning an address corresponding to the entry point.

6. The method, as recited in claim 5, further including the steps of:

obtaining a name and an ordinal for each entry point; and

passing the name and ordinal to the demand loading initialization routine.

7. The method, as recited in claim 6, wherein said step of calling an address API further includes the step of inputting the ordinal for the entry point to the address API.

8. The method, as recited in claim 1, wherein the step of generating program code further includes the step of generating assembly language program code and assembling the assembly language program code into object code.

9. The method, as recited in claim 8, further comprising the step of packaging the code generated into the demand load library.

10. The method, as recited in claim 9, further comprising the step of linking the object code of the demand load library with object code corresponding to an application program to thereby replace the reference library of the DLL with the demand load library.

11. The method, as recited in claim 1, further comprising the step of calling, by an application program, a particular entry point to export a corresponding function from the DLL.

12. The method, as recited in claim 11, further comprising the step of executing the function to generate a result.

13. The method, as recited in claim 12, further comprising the step of returning the result directly to the application program.

14. The method, as recited in claim 1, wherein the step of generating a demand load library comprises generating program code for performing a demand loading initialization routine.

15. The method, as recited in claim 1, wherein the step of generating a demand load library comprises generating program code for calling APIs from the operating system.

16. The method, as recited in claim 1, further comprising the step of packaging the code generated in the demand load library.

17. The method, as recited in claim 16, further comprising the step of linking the object code of the demand load library with object code corresponding to an application program to thereby replace the reference library of the DLL with the demand load library.

18. A method, implemented in an information handling system having an operating system, for generating a demand load library for demand loading a DLL, said method comprising the steps of:

finding entry points into the DLL; and

generating program code for performing the following steps for each entry point:

determining whether an address corresponding to the entry point has been called before;

if the address corresponding to the entry point has not been called before, then calling a demand loading initialization routine; and

jumping to the address corresponding to the entry point.

19. The method, as recited in claim 18, wherein said step of calling a demand loading initialization routine includes the step of calling APIs from the operating system.

20. The method, as recited in claim 19, wherein said step of calling APIs further includes the step of calling a load API for loading the DLL.

21. The method, as recited in claim 20, wherein said step of calling a load API further includes the step of inputting the name of the entry point to the load API.

22. The method, as recited in claim 21, wherein said step of calling APIs further includes the step of calling an address API for returning an address corresponding to the entry point.

23. The method, as recited in claim 22, further including the steps of:

obtaining a name and an ordinal for each entry point; and

passing the name and the ordinal to the demand loading initialization routine.

24. The method, as recited in claim 23, wherein said step of calling an address API further includes the step of inputting the ordinal for the entry point to the address API.

25. The method, as recited in claim 18, wherein the step of generating program code further includes the steps of generating assembly language program code and assembling the assembly language program code into object code.

26. The method, as recited in claim 25, comprising the step of packaging the code generated into the demand load library.

27. The method, as recited in claim 25, further comprising the step of linking the object code of the demand load library with object code corresponding to an application program to thereby replace a reference library of the DLL with the demand load library.

28. The method, as recited in claim 18, wherein said step of finding includes the step of finding entry points corresponding to instruction exports.

29. The method, as recited in claim 28, wherein said step of finding further includes the step of separating entry points corresponding to instruction exports from data exports.

30. The method, as recited in claim 29, wherein said step of finding further includes the step of repacking the DLL into a first DLL containing entry points corresponding to instruction exports and a second DLL containing entry points corresponding to data exports.

31. A computer program product comprising:

a program storage device readable by a computer system tangibly embodying a program of instructions executable by said computer system to generate a demand load library for demand loading a DLL, said program of instructions implementing the following method:

finding entry points into the DLL; and

generating program code for performing the following steps for each entry point:

determining whether an address corresponding to the entry point has been called before;

if the address corresponding to the entry point has not been called before, then calling a demand loading initialization routine; and

jumping to the address corresponding to the entry point.

32. The computer program product, as recited in claim 31, wherein said step of calling a demand loading initialization routine includes the step of calling APIs from the operating system.

33. The computer program product, as recited in claim 32, wherein said step of calling APIs further includes the step of calling a load API for loading the DLL.

34. The computer program product, as recited in claim 33, wherein said step of calling a load API further includes the step of inputting the name of the entry point to the load API.

35. The computer program product, as recited in claim 32, wherein said steps of calling APIs further includes the step of calling an address API for returning an address corresponding to the entry point.

36. The computer program product, as recited in claim 35, wherein the method further including the steps of:

obtaining a name and an ordinal for each entry point; and

passing the name and the ordinal to the demand loading initialization routine.

37. The computer program product, as recited in claim 36, wherein said step of calling an address API further includes the step of inputting the ordinal for the entry point to the address API.

38. The computer program product, as recited in claim 31, wherein the step of generating program code further includes the steps of generating assembly language program code and assembling the assembly language program code into object code.

39. The computer program product, as recited in claim 38, comprising the step of packaging the code generated into the demand load library.

40. The computer program product, as recited in claim 39, further comprising the step of linking the object code of the demand load library with object code corresponding to an application program to thereby replace a reference library of the DLL with the demand load library.

41. The computer program product, as recited in claim 31, wherein said step of finding includes the step of finding entry points corresponding to instruction exports.

42. The computer program product, as recited in claim 41, wherein said step of finding further includes the step of separating entry points corresponding to instruction exports from data exports.

43. The computer program product, as recited in claim 42, wherein said step of finding further includes the step of repacking the DLL into a first DLL containing entry points corresponding to instruction exports and a second DLL containing entry points corresponding to data exports.

44. An information handling system comprising;

at least one processor;

memory operably associated with said processor;

an application program stored in said memory, said program including a dynamic link library (DLL); and

a demand load library stored in said memory for demand loading the DLL, the demand load library including:

means for determining whether an address corresponding to an entry point has been called before;

a demand loading initialization routine; and

means for returning an address corresponding to said entry point for calling said entry point to export a corresponding function from the DLL, wherein the demand loading initialization routine loads the DLL if the entry point has not been called before.

45. The information handling system, as recited in claim 44, further including:

means for executing a function from said DLL to generate a result; and

means for returning the result directly to the application program.

46. A computer program product in a computer readable medium, comprising:

a dynamic link library (DLL); and

a demand load library for demand loading said DLL, the demand load library including:

means for determining whether an address corresponding to an entry point has been called before;

a demand loading initialization routine; and

means for returning an address corresponding to the entry point for calling the entry point to export a corresponding function from the DLL, wherein the demand loading initialization routine loads the DLL if the entry point has not been called before.

Description

FIELD OF THE INVENTION

The present invention relates in general to information handling systems and more particularly to an apparatus and method for demand loading dynamic link libraries (DLLs) utilized in computer programs.

BACKGROUND OF THE INVENTION

A computer application program usually includes a number of separate routines. Typically, the routines include a main program and several subsidiary routines referred to as objects, modules, or resources. Execution of the application program begins with the main program with calls being made to the subsidiary routines. In order to operate as a complete program, prior to execution these routines are linked together using a linker such as 386 link. The linker copies each of the routines into an executable file for the application program. The linker also provides each of the routines with information identifying the locations of other routines so that the routines can access each other. The executable file can then be loaded into the memory of a computer such that the application program can be executed by the computer according to the instructions in the routines.

A dynamic link library (DLL) is an executable module or routine containing services that application programs can call to perform useful tasks, e.g., directory searches, login commands, searching functions, character string manipulations, etc. DLLs exist primarily to provide services to application programs. These libraries play an important role in operating systems such as Windows and OS/2, which use them to make their services and resources available to application programs.

DLLs are similar to run-time libraries. The main difference between DLLs and run-time libraries is that DLLs are linked with the application program at run time, that is, when the computer is executing the application program, not when the application program files are linked with the linker. Linking a library with an application program at run time is referred to as dynamic linking; linking a library with an application program by using the linker is referred to as static linking. The discussion below focuses on the OS/2 operating system, but those of ordinary skill in the art will understand that the following discussion applies equally to other operating systems, such as Windows, which utilize DLLs.

In order to access a DLL at run time, the application program must be able to obtain information indicating where to find the DLL. One method provided by operating systems utilizing DLLs is to use an import library, or reference library, which contains information regarding where to locate the DLL at run time. During linking, the linker uses statically linked reference libraries to resolve references to external services. As noted above, when an application program desires a service from a static link library, the linker copies the code for that service into the application program's executable file. When the application program desires a service run from a DLL, however, the linker does not copy any code from the DLL. Instead, the linker searches all defined import or reference libraries to find one that contains the necessary information regarding location of the DLL. The linker copies the necessary information from the reference or import library to create a dynamic link between the executing application program and the DLL.

When a process loads under the OS/2 operating system, all DLLs that the process references, either directly or indirectly, are also loaded. DLLs referencing other DLLs form a reference tree, the entire set of which gets loaded before the first instruction of the main program is executed. A typical DLL is only partially loaded. The remainder of the DLL is loaded on its first reference. The minimum DLL load requires some initialization in the operating system and the execution of the DLL's initialization routine. Any code or data referenced by the initialization routine, including the initialization routine itself, is loaded. For some DLLs, the dynamic link load time is quite expensive in terms of time, particularly if the DLL is very large or the DLL's initialization routine is very long.

Referring to FIG. 1, the several steps described above are depicted. The source program or application code 50, in a high level language such as C language, and DLL function prototypes 55 are processed by a compiler 60, producing an object code module 65. The object code module 65 is statically linked by a linker 70 to a DLL reference library 75 which resolves external references to the DLL to produce a load module 80 containing the application's executable file ready for loading and running in a computer.

The problem with load time initialization as described above is that frequently a process does not call the DLLs that it references. Therefore, the DLLs which are referenced but not called are unnecessarily loaded. When the load time of the unnecessary DLLs is a large percentage of the total execution time, the performance of the process degrades significantly.

There is a method utilized in the OS/2 operating system to prevent the unnecessary loading of DLLs. The method is called demand loading and is implemented using a well-known documented set of OS/2 operating system APIs (Application Program Interfaces). Demand loading is the process of delaying the load of a DLL until it is actually called. If a DLL is demand loaded but never demanded or called, it is effectively not loaded, and the cost of loading it is saved.

It will be appreciated that demand loading is utilized in other operating systems and creates problems similar to those encountered with the OS/2's demand loading technique.

The problem with the OS/2's demand loading technique is that it is difficult to use, particularly if a program has initially been written without it. It requires the programmer to replace a call to a target dynamic link with a load check, a couple of OS/2 demand loading APIs, and error recovery should the OS/2 APIs fail. The following C-like code illustrates this difficulty:

    ______________________________________
    BEFORE (with no demand loading):
     x( )  /* call function X( );*/
    AFTER (with OS/2's default demand loading):
     static funcptr x;
     if (x=0)
             /* if entry point address has not loaded */
     {
     if(/DLL.sub.-- to.sub.-- load.sub.-- is.sub.-- not.sub.-- loaded)
                       /* if DLL has not been loaded */
     {
      rc = DosLoadModule (DLL.sub.-- to.sub.-- Load);
                          /* load the DLL */
      if (rc)
      {
      Do.sub.-- error.sub.-- recovery( );
      }
      DLL.sub.-- to.sub.-- load.sub.-- is.sub.-- not.sub.-- loaded = FALSE;
     }
     /*obtain the address of entry point x( ) */
     rc = DosQueryProcAddr (entry point identifier - either a name or
      ordinal number);
     if (rc)
     {
     Do.sub.-- error.sub.-- recovery( );
     }
    *x( ); /* call function x indirectly */
    ______________________________________

    ______________________________________
    if (entry.sub.-- point.sub.-- address == 0)
    call demload.sub.-- initialization(entry.sub.-- point.sub.-- address,
    name, ordinal)
    }
    goto entry.sub.-- point.sub.-- address
    ______________________________________

• Inventors
  Pekowski, Raymond Paul; Rousse, Curt James;
• Assignee
  International Business Machines Corporation (Armonk, NY)
• Published
  Dec-14-1999
• Current US Classes:
  717/163
• Application #
  742103
• International Classes
  G06F 009/44
• Field of Search
  395/685 395/710 395/701 709/305 709/685
• Examiner
  Oberley; Alvin E.
• Agent
  LaBaw; Jeffrey S., Judson; David H.
• US Patent References:
  5247678
  5247681
  5291601
  5339430
  5369766
  5369770
  5375241
  5450586
  5475840
  5734904
  5812848