CA2102883A1 - System and method for lazy loading of shared libraries - Google Patents
System and method for lazy loading of shared librariesInfo
- Publication number
- CA2102883A1 CA2102883A1 CA002102883A CA2102883A CA2102883A1 CA 2102883 A1 CA2102883 A1 CA 2102883A1 CA 002102883 A CA002102883 A CA 002102883A CA 2102883 A CA2102883 A CA 2102883A CA 2102883 A1 CA2102883 A1 CA 2102883A1
- Authority
- CA
- Canada
- Prior art keywords
- executable
- loading
- memory
- referenced
- routines
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
- 238000000034 method Methods 0.000 title claims abstract description 19
- 238000004590 computer program Methods 0.000 claims description 8
- 230000004044 response Effects 0.000 claims description 4
- 238000001514 detection method Methods 0.000 claims 4
- 230000006870 function Effects 0.000 description 9
- 230000008569 process Effects 0.000 description 8
- 238000012545 processing Methods 0.000 description 6
- 238000013459 approach Methods 0.000 description 5
- 238000010586 diagram Methods 0.000 description 3
- 230000010365 information processing Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 230000008676 import Effects 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- WLNBMPZUVDTASE-HXIISURNSA-N (2r,3r,4s,5r)-2-amino-3,4,5,6-tetrahydroxyhexanal;sulfuric acid Chemical compound [O-]S([O-])(=O)=O.O=C[C@H]([NH3+])[C@@H](O)[C@H](O)[C@H](O)CO.O=C[C@H]([NH3+])[C@@H](O)[C@H](O)[C@H](O)CO WLNBMPZUVDTASE-HXIISURNSA-N 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000003111 delayed effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000011156 evaluation Methods 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 238000013507 mapping Methods 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/54—Link editing before load time
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/10—Address translation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/10—Providing a specific technical effect
- G06F2212/1016—Performance improvement
Abstract
Abstract of the Disclosure System and Method for Lazy Loading of Shared Libraries 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.
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.
Description
'~102~
System and Method for Lazy Loading of Shared Libraries 1. Field of the Invention The present invention relates to information processing systems and more particularly to operating systems. Still more particularly, this invention relates to systems for controlling the loading of executable tasks by an operating system.
System and Method for Lazy Loading of Shared Libraries 1. Field of the Invention The present invention relates to information processing systems and more particularly to operating systems. Still more particularly, this invention relates to systems for controlling the loading of executable tasks by an operating system.
2. Background and Related Art Computer operating systems control the operation of computer system components. Among the responsibilities of the operating system is loading other programs for execution. The other programs are typically application programs, but also may include operating system components. Loading programs involves finding the requested program on the program storage media, typically a hard disk file, and then bringing the program into memory and making it ready to be executed by the processor. Programs are stored in program storage in executable form that results from compilation or assembly of program source code. The executable form has a specified format known to the loader that contains information necessary for processing that executable code. One of the processing steps the loader performs is address relocation. Addresses in the executable file are expressed relative to a beginning address. This beginning address or starting offset is not determined until the program is loaded into memory. Address relocation modifies the relative addresses so that they point to actual addressabie locations in the system. Once the addresses have been fixed, the program is ready to execute.
Computer programs have become increasingly complex as system user requirements have expanded and as the capabilities of systems have increased. The increased capacity of microcomputer systems such as the I~M~ PS/2~ computer system is one example. Increased processor capacity and function has allowed complex word processing, spread sheet, database, and other business and scientific applications to be developed.
Complex applications, however, result in increasingly larger .
?,~ 8~3 executable files.
The generation of large executable files whenever a portion of an application or system changed increases the cost and time required to create or revise an application or system. One solution to this problem has been to divide applications or systems into segments that are dynamically loadable. Linking (address resolution) of these segments is deferred until execution time. Each segment is de~ined to contain a specific portion of code and is written to respond to well defined interfaces. Programs in other segments that access a particular segment object need not be changed or recompiled as long as that interface is constant. This provides greater flexibility in the development and maintenance of operating systems and application programs.
The dynamic linking concept has been implemented in the IBM
OS/2~ operating system product OS/2 dynamic link libraries (or DLLs) are dynamically linked to provide defined functions to an operating system or application program. The interfaces to the DLLs are specified library interfaces. A program using a dynamic link library will contain a library interface call to that program. The compiler will track each of these external library calls and will include them in a section of the executable file. In the current system, when the OS/2 loader loads an executable program (typically stored as a file with a .EXE suffix) it scans the file to find all dynamic link library references. Each library function referenced is in turn dynamically loaded. The loader will check each of these libraries to determine whether they, in turn call other library functions. This checking and loading process continues recursively until all dynamic link references are resolved.
The current OS/2 operating system assigns memory addresses and user memory space to each of the libraries referenced by a task. Commonly used DLLs frequently reference other DLLs that in turn reference still other DLLs. As a result long chains of DLLs are allocated and mapped into each task. Many of ?J~28~3 these DLLs are specified to handle error or other exception conditions and are used only infrequently. This means that the large loaded memory is unnecessary most of the time. The large memory allocation also increases the overhead on the system since the memory manager must sift through this large allocated memory when determining which areas to replace in a paging system.
An additional problem exists in microkernel systems such as th~ Mach operating system developed by Carnegie Mellon University. The Mach microkernel allocates kernel port identifiers for interprocess communications. The Mach kernel assigns a kernel port identifier to each DLL or more efficiently to each DLL object. The assignment of unreferenced ports interferes with efficient port resolution.
Dynamic subroutine loading schemes have been previously proposed, but each has suffered from disadvantages. The IBM
Technical Disclosure Bulletin, May, 1986, pp. 5535-5537 contained an article entitled "Transparent Dynamic Subroutine Loader." The proposed technique required a special purpose dynamic loader to be linked with the main routine. The loader maintained tables of subroutine references and loaded subroutines as they were called. This approach was not integral to the operating system and did not support sharing between tasks. The tracking and loading applied only to the particular task. The requirement to link the dynamic loader program into the main program also limits transparency.
A slightly different approach was suggested in "Execution Time Loading Using Self Modifying Stubs", IBM Technical Disclosure Bulletin, January, 1987, p. 3521. This approach required subroutine stubs to be added to each main program. When the subroutine was first referenced the library copy was loaded and the stub modified to branch to the loaded library copy.
This approach has the disadvantage of requiring special coding techniques and execution time modifications to program flow.
Finally, "Dynamic Link Library Mechanism in DOS Environment", ,: . . ~ . , - , . ~
2~3 IBM Technical Dlsclosure Bulletin, November, 1991, pp. 209-210 proposed a "terminate and stay resident" (TSR) routine in the DOS environment to manage a list of library routines. The routine responds to a "soft interrupt" generated by a special binding call inserted in the main routine. When the interrupt is received, the TSR routine checks a table to determine if the function has been previously loaded, and if not, it is loaded and the table updated. Control is then passed to the function. This approach has the disadvantage of requiring a special interrupt routine to manage the dynamic libraries. A
requirement to insert special interrupt calls in the main program also limits general application.
The technical problem presented i.s to provide a mechanism for dynamically loading executable library objects only when such objects are required for execution. Solution of the problem should be transparent to the application developer and to the executing program, i.e., it should appear no different than if the library functions were linked into the main program.
Summary of the Invention The present invention is directed to a system for dynamically loading library objects only when they are required for execution. The system includes means for delaying the loading of unreferenced objects until a reference is made. The present invention incorporates this feature as part of system loader and execution processing and requires no change to the main executable program.
The present invention includes a system for manaying allocation of memory to executable programs having means for receiving a request to load a primary executable program into memory, means for determining secondary executable programs referenced by the primary executable program, means for allocating memory slots to the secondary executable programs without loading the programs into memory; means for detecting references to one of the allocated but unloaded slots, the means for detecting generating a detect signal when a r~ference is detected; and means for loading the executable .
~2~3 program allocated the slo-t: into memory in response to the detect signal.
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of a preferred embodiment of the invention, as illustrated in the accompanying drawing wherein like reference numbers represent like parts of the invention.
Brief Description of the Drawing Figure 1 is a block diagram illustrating an information processing system useable with the present invention.
Figure 2 is a diagram of the structure and interrelationships of executable objects.
Figure 3 is a block diagram showing the components of the preferred embodiment of the present invention.
Figure 4 is a flow chart illustrating the process steps of the present invention.
Detailed Description The present invention is used in conjunction with an information processing system. An example of such a system is shown in Figure 1 at 100. The system has a processing unit or CPU 102 interconnected by a system bus 103 to various system components. These components include, but are not limited to, hard disk storage 104, random access memory 106, network interface 108, input,/output interface 110. The input/output interface coordinates input from a keyboard 114, pointing device 116, and controls output to a display 112. Additional permanent storage devices such as a diskette drive, a tape drive or a CD-ROM drive could be attached to such a system.
The in~ormation processing system on which the current system operates is preferably an IBM PS/2 computer system. The system and method disclosed are not limited to such a system, however, and are operable on other microcomputer systems, workstation systems such as the IBM RISC System/6000 workstation, or mainframe systems such as the IBM ES/9000 computer system.
The preferred embodiment of the present invention is implemented in a system tha-t supports dynamic link libraries (DLLs). These libraries have the property that each object in the library is relocatable at load time, i.e., it can be assigned any address by the loader.
Each executable module is stored in permanent storage (for example, on the hard disk) in a specified format. In the preferred embodiment, the main executable file and all dynamic link libraries are stored according to the "LX - Linear Executable Module" format. Storage formats could differ between the main executable and the dynamic link libraries or even within the dynamic link libraries as long as all formats are recognizable by the loader.
The executable module is shown, for example, at 202 in Figure 2. The main executable is the program first called to perform a function either by the operating system or directly by the user. An example of user invocation is the entry of the program name by the user at the operating system command prompt. E.g., entering MYPROGM would cause loading and execution of MYPROGM.E~E.
The executable module header contains numerous pieces of information required to load and execute the program. These include the module name, the version level, CPU or operating system dependencies, size of the module, fixup information needed to relocate addresses, and import module references to DLL modules to be imported at execution.
The main executable program references dynamic link libraries through the import module list. DLL references can occur because of explicit program invocations inserted by the system developer or can be inserted by the compiler during compilation. As shown in Figure 2, module 202 contains references to objects in DLLs 204 and 2Q6. Module 204 contains references to modules 208, 210, and 212, while module 206 contains references to modules 212 and 214.
Each dynamic link library (DLL) is divided into a number of objects containing text, shared data, and instance data.
28~3 AT9-g3-025 7 Executable objects can contain several routines or only one, depending upon the options selected when the objects were created. Each object is relocatable at load time, i.e., it can be assigned any address at load time. Each object is further divided into pages corresponding to the size of pages used in the vixtual memory manager of the computer system. Each page has an associated "fixup stream" that identifies and encodes the addresses that must be modified when the module is loaded.
These modifications are divided into local fixups where local addresses are offset by the starti.ng address of the object and external fixups where the addresses are offset based on the addresses of other objects or other dynamic link libraries.
The preferred embodiment of the present invention is implemented using a Mach microkernel based system having an OS/2 operating system personality. The major functional components of this system are shown in Figure 3. The User 302 is a program running in user space. It may be an application or system utility program. The OS/2 Server 304 contains the operating system features of OS/2 providing an OS/2 user interface and generating the necessary microkernel service requests to microkernel 306. File server 308 manages the disk files or other persistent storage media.
OS/2 Server 304 contains three components of concern to the present invention. Tasking 310 establishes execution tasks for executing requested operations. Loader 312 performs the functions of requesting executable modules from the file server 308, fixing up the executable modules, and loading them into memory. Memory Manager 314 manages memory resources using microkernel memory management facilities. The microkernel has a virtual memory system 316. The virtual memory system manages the assignment of VM pages to memory objects and detects memory page faults. Page faults are caused by a task requesting a memory page that has been allocated to the task but is not currently in memory. Handling the fault requires paging out of unused or not recently used pages and paging in of the requested page.
21~'3~'~
AT~-93-025 8 The operation of the lazy loading process of the present invention will be described with reference to Figure 4 in conjunction with Fig-ure 3. The process begins with a user space request for executable program initialization 402. This causes Tasking 310 to create a task for execution and to register the task with the virtual memory system 316. Tasking next causes loader 312 to initiate 404 memory loading of the .EXE file. The loader accesses the .EXE file through the file server 308.
The loader begins loading the initial executable code 406. The loader fetches the .EXE header and builds a Module Table Entry (MTE) for the module. The module table entry is registered with VM 316. The loader creates a list of DLLs referenced by the .EXE file. For each .DLL object the loader determines whether an MTE exists for that DLL object, and if not, it accesses the DLL using the file server, loads and builds an MTE for the DLL objeGt. The MTE is registered with VM.
Execution of the task then begins 408. The loading process maps each page of data associated with the .EXE and referenced .DLLs into the user virtual memory space, but the physical page is not loaded until referenced. A reference to a virtual memory page that is not loaded causes a page fault 410. An external pager is provided to handle memory object page faults. This pager causes the requested page to be loaded into user memory. Once a page has been loaded, the default microkernel pager handles subsequent loading or unloading.
A page fault 410 causes microkernel VM 316 to determine the object name, page and MTE 412. For valid pages, the external pager directs 416 the loader to fixup and load 4~8 the page.
The fixup process detects any additional external objects, i.e., other DLL objects and determines whether that object has been allocated memory 420. If not, a memory slot of the appropriate size is requested 422 and the page mapped into the user address space 424.
The preferred embodiment is implemented in a shared memory ~2~83 system where tasks can share certain memory regions. When another user task references a page already assigned to one user 414 the kernel gives t:hat second user task a copy of the page from the kernel cache avoiding the need for the loader to fixup the page. This sharing avoids the overhead of reading and fixing up that page again for the second user. When the second user references an object on the shared page, a memory protection fault is generated. Objects from the shared page were not loaded into the user space because no fixup was dona, only copying of the fixed page. The server handles the fault by mapping the object into the second user's address space 430 and restarting the user task.
The ~bove process results in delayed or lazy evaluation of the library object requirements. The loader postpones loading any library object until it is likely to be used. All DLLs objects references in the .EXE file are initially loaded because the initial execution can include any of those objects. As each DLL object is referenced, the next level of DLL objects referenced by that object is processed. ~:
The present invention has the advantage of limiting memory allocation and loading to that required by referenced objects.
This also limits the number of Mach ports and memory pages that must be assigned thereby reducing overall system overhead.
The preferred embodiment has been shown in conjunction with the Mach microkernel. It will be appreciated, however, by those skilled in the art, that the lazy loading process is not limiied to this type of operating system. The process described herein may be adapted to other operating systems, and particularly to those supporting virtual memory management.
It will be understood from the foregoing description that various modifications and changes may be made in the preferred embodiment of the present invention without departing from its true spirit. It is intended that this description is for ~ ~2~8~
purposes of illustration only and should not be construed in a limiting sense. The scope of this invention should be limited only by the language of -the followiny claims.
Computer programs have become increasingly complex as system user requirements have expanded and as the capabilities of systems have increased. The increased capacity of microcomputer systems such as the I~M~ PS/2~ computer system is one example. Increased processor capacity and function has allowed complex word processing, spread sheet, database, and other business and scientific applications to be developed.
Complex applications, however, result in increasingly larger .
?,~ 8~3 executable files.
The generation of large executable files whenever a portion of an application or system changed increases the cost and time required to create or revise an application or system. One solution to this problem has been to divide applications or systems into segments that are dynamically loadable. Linking (address resolution) of these segments is deferred until execution time. Each segment is de~ined to contain a specific portion of code and is written to respond to well defined interfaces. Programs in other segments that access a particular segment object need not be changed or recompiled as long as that interface is constant. This provides greater flexibility in the development and maintenance of operating systems and application programs.
The dynamic linking concept has been implemented in the IBM
OS/2~ operating system product OS/2 dynamic link libraries (or DLLs) are dynamically linked to provide defined functions to an operating system or application program. The interfaces to the DLLs are specified library interfaces. A program using a dynamic link library will contain a library interface call to that program. The compiler will track each of these external library calls and will include them in a section of the executable file. In the current system, when the OS/2 loader loads an executable program (typically stored as a file with a .EXE suffix) it scans the file to find all dynamic link library references. Each library function referenced is in turn dynamically loaded. The loader will check each of these libraries to determine whether they, in turn call other library functions. This checking and loading process continues recursively until all dynamic link references are resolved.
The current OS/2 operating system assigns memory addresses and user memory space to each of the libraries referenced by a task. Commonly used DLLs frequently reference other DLLs that in turn reference still other DLLs. As a result long chains of DLLs are allocated and mapped into each task. Many of ?J~28~3 these DLLs are specified to handle error or other exception conditions and are used only infrequently. This means that the large loaded memory is unnecessary most of the time. The large memory allocation also increases the overhead on the system since the memory manager must sift through this large allocated memory when determining which areas to replace in a paging system.
An additional problem exists in microkernel systems such as th~ Mach operating system developed by Carnegie Mellon University. The Mach microkernel allocates kernel port identifiers for interprocess communications. The Mach kernel assigns a kernel port identifier to each DLL or more efficiently to each DLL object. The assignment of unreferenced ports interferes with efficient port resolution.
Dynamic subroutine loading schemes have been previously proposed, but each has suffered from disadvantages. The IBM
Technical Disclosure Bulletin, May, 1986, pp. 5535-5537 contained an article entitled "Transparent Dynamic Subroutine Loader." The proposed technique required a special purpose dynamic loader to be linked with the main routine. The loader maintained tables of subroutine references and loaded subroutines as they were called. This approach was not integral to the operating system and did not support sharing between tasks. The tracking and loading applied only to the particular task. The requirement to link the dynamic loader program into the main program also limits transparency.
A slightly different approach was suggested in "Execution Time Loading Using Self Modifying Stubs", IBM Technical Disclosure Bulletin, January, 1987, p. 3521. This approach required subroutine stubs to be added to each main program. When the subroutine was first referenced the library copy was loaded and the stub modified to branch to the loaded library copy.
This approach has the disadvantage of requiring special coding techniques and execution time modifications to program flow.
Finally, "Dynamic Link Library Mechanism in DOS Environment", ,: . . ~ . , - , . ~
2~3 IBM Technical Dlsclosure Bulletin, November, 1991, pp. 209-210 proposed a "terminate and stay resident" (TSR) routine in the DOS environment to manage a list of library routines. The routine responds to a "soft interrupt" generated by a special binding call inserted in the main routine. When the interrupt is received, the TSR routine checks a table to determine if the function has been previously loaded, and if not, it is loaded and the table updated. Control is then passed to the function. This approach has the disadvantage of requiring a special interrupt routine to manage the dynamic libraries. A
requirement to insert special interrupt calls in the main program also limits general application.
The technical problem presented i.s to provide a mechanism for dynamically loading executable library objects only when such objects are required for execution. Solution of the problem should be transparent to the application developer and to the executing program, i.e., it should appear no different than if the library functions were linked into the main program.
Summary of the Invention The present invention is directed to a system for dynamically loading library objects only when they are required for execution. The system includes means for delaying the loading of unreferenced objects until a reference is made. The present invention incorporates this feature as part of system loader and execution processing and requires no change to the main executable program.
The present invention includes a system for manaying allocation of memory to executable programs having means for receiving a request to load a primary executable program into memory, means for determining secondary executable programs referenced by the primary executable program, means for allocating memory slots to the secondary executable programs without loading the programs into memory; means for detecting references to one of the allocated but unloaded slots, the means for detecting generating a detect signal when a r~ference is detected; and means for loading the executable .
~2~3 program allocated the slo-t: into memory in response to the detect signal.
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of a preferred embodiment of the invention, as illustrated in the accompanying drawing wherein like reference numbers represent like parts of the invention.
Brief Description of the Drawing Figure 1 is a block diagram illustrating an information processing system useable with the present invention.
Figure 2 is a diagram of the structure and interrelationships of executable objects.
Figure 3 is a block diagram showing the components of the preferred embodiment of the present invention.
Figure 4 is a flow chart illustrating the process steps of the present invention.
Detailed Description The present invention is used in conjunction with an information processing system. An example of such a system is shown in Figure 1 at 100. The system has a processing unit or CPU 102 interconnected by a system bus 103 to various system components. These components include, but are not limited to, hard disk storage 104, random access memory 106, network interface 108, input,/output interface 110. The input/output interface coordinates input from a keyboard 114, pointing device 116, and controls output to a display 112. Additional permanent storage devices such as a diskette drive, a tape drive or a CD-ROM drive could be attached to such a system.
The in~ormation processing system on which the current system operates is preferably an IBM PS/2 computer system. The system and method disclosed are not limited to such a system, however, and are operable on other microcomputer systems, workstation systems such as the IBM RISC System/6000 workstation, or mainframe systems such as the IBM ES/9000 computer system.
The preferred embodiment of the present invention is implemented in a system tha-t supports dynamic link libraries (DLLs). These libraries have the property that each object in the library is relocatable at load time, i.e., it can be assigned any address by the loader.
Each executable module is stored in permanent storage (for example, on the hard disk) in a specified format. In the preferred embodiment, the main executable file and all dynamic link libraries are stored according to the "LX - Linear Executable Module" format. Storage formats could differ between the main executable and the dynamic link libraries or even within the dynamic link libraries as long as all formats are recognizable by the loader.
The executable module is shown, for example, at 202 in Figure 2. The main executable is the program first called to perform a function either by the operating system or directly by the user. An example of user invocation is the entry of the program name by the user at the operating system command prompt. E.g., entering MYPROGM would cause loading and execution of MYPROGM.E~E.
The executable module header contains numerous pieces of information required to load and execute the program. These include the module name, the version level, CPU or operating system dependencies, size of the module, fixup information needed to relocate addresses, and import module references to DLL modules to be imported at execution.
The main executable program references dynamic link libraries through the import module list. DLL references can occur because of explicit program invocations inserted by the system developer or can be inserted by the compiler during compilation. As shown in Figure 2, module 202 contains references to objects in DLLs 204 and 2Q6. Module 204 contains references to modules 208, 210, and 212, while module 206 contains references to modules 212 and 214.
Each dynamic link library (DLL) is divided into a number of objects containing text, shared data, and instance data.
28~3 AT9-g3-025 7 Executable objects can contain several routines or only one, depending upon the options selected when the objects were created. Each object is relocatable at load time, i.e., it can be assigned any address at load time. Each object is further divided into pages corresponding to the size of pages used in the vixtual memory manager of the computer system. Each page has an associated "fixup stream" that identifies and encodes the addresses that must be modified when the module is loaded.
These modifications are divided into local fixups where local addresses are offset by the starti.ng address of the object and external fixups where the addresses are offset based on the addresses of other objects or other dynamic link libraries.
The preferred embodiment of the present invention is implemented using a Mach microkernel based system having an OS/2 operating system personality. The major functional components of this system are shown in Figure 3. The User 302 is a program running in user space. It may be an application or system utility program. The OS/2 Server 304 contains the operating system features of OS/2 providing an OS/2 user interface and generating the necessary microkernel service requests to microkernel 306. File server 308 manages the disk files or other persistent storage media.
OS/2 Server 304 contains three components of concern to the present invention. Tasking 310 establishes execution tasks for executing requested operations. Loader 312 performs the functions of requesting executable modules from the file server 308, fixing up the executable modules, and loading them into memory. Memory Manager 314 manages memory resources using microkernel memory management facilities. The microkernel has a virtual memory system 316. The virtual memory system manages the assignment of VM pages to memory objects and detects memory page faults. Page faults are caused by a task requesting a memory page that has been allocated to the task but is not currently in memory. Handling the fault requires paging out of unused or not recently used pages and paging in of the requested page.
21~'3~'~
AT~-93-025 8 The operation of the lazy loading process of the present invention will be described with reference to Figure 4 in conjunction with Fig-ure 3. The process begins with a user space request for executable program initialization 402. This causes Tasking 310 to create a task for execution and to register the task with the virtual memory system 316. Tasking next causes loader 312 to initiate 404 memory loading of the .EXE file. The loader accesses the .EXE file through the file server 308.
The loader begins loading the initial executable code 406. The loader fetches the .EXE header and builds a Module Table Entry (MTE) for the module. The module table entry is registered with VM 316. The loader creates a list of DLLs referenced by the .EXE file. For each .DLL object the loader determines whether an MTE exists for that DLL object, and if not, it accesses the DLL using the file server, loads and builds an MTE for the DLL objeGt. The MTE is registered with VM.
Execution of the task then begins 408. The loading process maps each page of data associated with the .EXE and referenced .DLLs into the user virtual memory space, but the physical page is not loaded until referenced. A reference to a virtual memory page that is not loaded causes a page fault 410. An external pager is provided to handle memory object page faults. This pager causes the requested page to be loaded into user memory. Once a page has been loaded, the default microkernel pager handles subsequent loading or unloading.
A page fault 410 causes microkernel VM 316 to determine the object name, page and MTE 412. For valid pages, the external pager directs 416 the loader to fixup and load 4~8 the page.
The fixup process detects any additional external objects, i.e., other DLL objects and determines whether that object has been allocated memory 420. If not, a memory slot of the appropriate size is requested 422 and the page mapped into the user address space 424.
The preferred embodiment is implemented in a shared memory ~2~83 system where tasks can share certain memory regions. When another user task references a page already assigned to one user 414 the kernel gives t:hat second user task a copy of the page from the kernel cache avoiding the need for the loader to fixup the page. This sharing avoids the overhead of reading and fixing up that page again for the second user. When the second user references an object on the shared page, a memory protection fault is generated. Objects from the shared page were not loaded into the user space because no fixup was dona, only copying of the fixed page. The server handles the fault by mapping the object into the second user's address space 430 and restarting the user task.
The ~bove process results in delayed or lazy evaluation of the library object requirements. The loader postpones loading any library object until it is likely to be used. All DLLs objects references in the .EXE file are initially loaded because the initial execution can include any of those objects. As each DLL object is referenced, the next level of DLL objects referenced by that object is processed. ~:
The present invention has the advantage of limiting memory allocation and loading to that required by referenced objects.
This also limits the number of Mach ports and memory pages that must be assigned thereby reducing overall system overhead.
The preferred embodiment has been shown in conjunction with the Mach microkernel. It will be appreciated, however, by those skilled in the art, that the lazy loading process is not limiied to this type of operating system. The process described herein may be adapted to other operating systems, and particularly to those supporting virtual memory management.
It will be understood from the foregoing description that various modifications and changes may be made in the preferred embodiment of the present invention without departing from its true spirit. It is intended that this description is for ~ ~2~8~
purposes of illustration only and should not be construed in a limiting sense. The scope of this invention should be limited only by the language of -the followiny claims.
Claims (14)
1. A system for managing allocation of memory to executable programs, the system comprising:
means for receiving a request to load a primary executable program into memory;
means for determining secondary executable programs referenced by said primary executable program;
means for allocating memory slots to said secondary executable programs without loading said programs into memory;
means for detecting references to one of said allocated but unloaded slots, said means for detecting generating a detect signal when a reference is detected; and means for loading the executable program allocated said slot into memory in response to said detect signal.
means for receiving a request to load a primary executable program into memory;
means for determining secondary executable programs referenced by said primary executable program;
means for allocating memory slots to said secondary executable programs without loading said programs into memory;
means for detecting references to one of said allocated but unloaded slots, said means for detecting generating a detect signal when a reference is detected; and means for loading the executable program allocated said slot into memory in response to said detect signal.
2. The system of claim 1 wherein said means for loading the executable program comprises:
means for copying said executable program from a storage device;
means for relocating address references in said executable program;
means for determining executable programs referenced by said executable program; and means for allocating memory slot to said referenced executable programs without loading said programs into memory.
means for copying said executable program from a storage device;
means for relocating address references in said executable program;
means for determining executable programs referenced by said executable program; and means for allocating memory slot to said referenced executable programs without loading said programs into memory.
3. The system of claim 2, wherein said means for detecting is a page fault detection system.
4. The system of claim 1, wherein said means for loading is an external pager.
5. The system of claim 3 wherein said means for loading is an external pager.
6. A method for dynamically loading executable routines comprising the steps of:
receiving a request to load a main executable routine into memory;
creating a list of all routines referenced by said main executable routine;
allocating memory locations to said routines without loading said routines;
detecting a reference to one of said allocated memory locations and generating a detection signal; and loading said routine into said allocated memory location in response to said detection signal.
receiving a request to load a main executable routine into memory;
creating a list of all routines referenced by said main executable routine;
allocating memory locations to said routines without loading said routines;
detecting a reference to one of said allocated memory locations and generating a detection signal; and loading said routine into said allocated memory location in response to said detection signal.
7. The method of claim 6 wherein said loading step includes the steps of:
copying said routine from a storage device;
relocating address references in said routine;
creating a list of routines referenced by said loaded routine; and allocating memory locations to said referenced routines without loading said routines into memory.
copying said routine from a storage device;
relocating address references in said routine;
creating a list of routines referenced by said loaded routine; and allocating memory locations to said referenced routines without loading said routines into memory.
8. The method of claim 6, wherein said detecting step includes detecting a memory page fault reference.
9. The method of claim 6, wherein said loading step includes passing control to an external pager to perform said loading steps.
10. A computer program product having a computer readable medium having computer program logic recorded thereon for dynamically loading executable routines into memory, said computer program product comprising: means for receiving a request to load a primary executable routine into memory;
means for determining secondary executable routines referenced by said primary executable program;
means for allocating memory slots to said secondary executable routines without loading said programs into memory;
means for detecting references to one of said allocated but unloaded slots, said means for detecting generating a detect signal when a reference is detected; and means for loading said the executable routine allocated said slot into memory in response to said detect signal.
means for determining secondary executable routines referenced by said primary executable program;
means for allocating memory slots to said secondary executable routines without loading said programs into memory;
means for detecting references to one of said allocated but unloaded slots, said means for detecting generating a detect signal when a reference is detected; and means for loading said the executable routine allocated said slot into memory in response to said detect signal.
11. The computer program of claim 10 wherein said means for loading the executable routine comprises:
means for copying said executable routine from a storage device;
means for relocating address references in said executable routine;
means for determining executable routines referenced by said executable routine; and means for allocating memory slot to said referenced executable routines without loading said routines into memory.
means for copying said executable routine from a storage device;
means for relocating address references in said executable routine;
means for determining executable routines referenced by said executable routine; and means for allocating memory slot to said referenced executable routines without loading said routines into memory.
12. The computer program of claim 11, wherein said means for detecting is a page fault detection system.
13. The computer program of claim 10, wherein said means for loading is an external pager.
14. The computer program of claim 12, wherein said means for loading is an external pager.
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US2364393A | 1993-02-26 | 1993-02-26 | |
| US23,643 | 1993-02-26 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CA2102883A1 true CA2102883A1 (en) | 1994-08-27 |
Family
ID=21816373
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002102883A Abandoned CA2102883A1 (en) | 1993-02-26 | 1993-11-10 | System and method for lazy loading of shared libraries |
Country Status (7)
| Country | Link |
|---|---|
| US (1) | US5708811A (en) |
| EP (1) | EP0613084A1 (en) |
| JP (1) | JP3314378B2 (en) |
| KR (1) | KR0152461B1 (en) |
| CN (1) | CN1042862C (en) |
| BR (1) | BR9400603A (en) |
| CA (1) | CA2102883A1 (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US11200070B2 (en) | 2018-08-03 | 2021-12-14 | International Business Machines Corporation | Dynamic-link library usage based on memory size |
Families Citing this family (117)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5379432A (en) * | 1993-07-19 | 1995-01-03 | Taligent, Inc. | Object-oriented interface for a procedural operating system |
| US7188352B2 (en) | 1995-07-11 | 2007-03-06 | Touchtunes Music Corporation | Intelligent digital audiovisual playback system |
| US8661477B2 (en) * | 1994-10-12 | 2014-02-25 | Touchtunes Music Corporation | System for distributing and selecting audio and video information and method implemented by said system |
| US7424731B1 (en) | 1994-10-12 | 2008-09-09 | Touchtunes Music Corporation | Home digital audiovisual information recording and playback system |
| EP0786121B1 (en) | 1994-10-12 | 2000-01-12 | Touchtunes Music Corporation | Intelligent digital audiovisual playback system |
| US6466992B2 (en) * | 1994-12-07 | 2002-10-15 | Next Computer, Inc. | Method for providing stand-in objects |
| FR2753868A1 (en) | 1996-09-25 | 1998-03-27 | Technical Maintenance Corp | METHOD FOR SELECTING A RECORDING ON AN AUDIOVISUAL DIGITAL REPRODUCTION SYSTEM AND SYSTEM FOR IMPLEMENTING THE METHOD |
| US5960204A (en) * | 1996-10-28 | 1999-09-28 | J.D. Edwards World Source Company | System and method for installing applications on a computer on an as needed basis |
| US6363436B1 (en) * | 1997-01-27 | 2002-03-26 | International Business Machines Corporation | Method and system for loading libraries into embedded systems |
| US5878263A (en) * | 1997-03-05 | 1999-03-02 | International Business Machines Corporation | Internal chaining technique for fixup records |
| US6385567B1 (en) * | 1997-07-31 | 2002-05-07 | Microsoft Corporation | Program-module substitution in a program loader for multiple-platform emulation |
| JPH1185526A (en) * | 1997-09-12 | 1999-03-30 | Hitachi Ltd | Program loading method |
| FR2769165B1 (en) * | 1997-09-26 | 2002-11-29 | Technical Maintenance Corp | WIRELESS SYSTEM WITH DIGITAL TRANSMISSION FOR SPEAKERS |
| US6292843B1 (en) * | 1998-01-16 | 2001-09-18 | International Business Machines Corporation | Quick loading of run time dynamic link library for OS/2 |
| US6185733B1 (en) * | 1998-01-20 | 2001-02-06 | International Business Machines Corporation | Method and apparatus for remote object code inclusion |
| US6074432A (en) * | 1998-03-19 | 2000-06-13 | Xilinx, Inc. | Method for generating a software class compatible with two or more interpreters |
| US6158047A (en) * | 1998-07-08 | 2000-12-05 | Hewlett-Packard Company | Client/server system for fast, user transparent and memory efficient computer language translation |
| FR2781582B1 (en) | 1998-07-21 | 2001-01-12 | Technical Maintenance Corp | SYSTEM FOR DOWNLOADING OBJECTS OR FILES FOR SOFTWARE UPDATE |
| FR2781580B1 (en) | 1998-07-22 | 2000-09-22 | Technical Maintenance Corp | SOUND CONTROL CIRCUIT FOR INTELLIGENT DIGITAL AUDIOVISUAL REPRODUCTION SYSTEM |
| US8028318B2 (en) | 1999-07-21 | 2011-09-27 | Touchtunes Music Corporation | Remote control unit for activating and deactivating means for payment and for displaying payment status |
| FR2781591B1 (en) | 1998-07-22 | 2000-09-22 | Technical Maintenance Corp | AUDIOVISUAL REPRODUCTION SYSTEM |
| GB2340266B (en) * | 1998-07-31 | 2003-03-12 | Sony Uk Ltd | Data processing |
| US6430569B1 (en) * | 1998-08-14 | 2002-08-06 | Sun Microsystems, Inc. | Methods and apparatus for type safe, lazy, user-defined class loading |
| US8434099B2 (en) * | 1998-09-09 | 2013-04-30 | Microsoft Corporation | Efficient linking and loading for late binding and platform retargeting |
| US7409694B2 (en) * | 1998-09-09 | 2008-08-05 | Microsoft Corporation | Highly componentized system architecture with loadable virtual memory manager |
| US6486897B1 (en) * | 1998-09-29 | 2002-11-26 | Apple Computer, Inc. | Multi-repository display system using separate presentation, adaptation and access layers |
| US6314566B1 (en) * | 1998-09-29 | 2001-11-06 | Apple Computer, Inc. | Method and apparatus for “Just-in-Time” dynamic loading and unloading of computer software libraries |
| US8726330B2 (en) | 1999-02-22 | 2014-05-13 | Touchtunes Music Corporation | Intelligent digital audiovisual playback system |
| US6308184B1 (en) * | 1999-04-09 | 2001-10-23 | Hewlett-Packard Company | Delayed unloading of a dynamically loadable file |
| US6601114B1 (en) * | 1999-05-27 | 2003-07-29 | Sun Microsystems, Inc. | Fully lazy linking with module-by-module verification |
| US6618769B1 (en) * | 1999-05-27 | 2003-09-09 | Sun Microsystems, Inc. | Module-by-module verification |
| US6763397B1 (en) | 1999-05-27 | 2004-07-13 | Sun Microsystems, Inc. | Fully lazy linking |
| AU2004200283B2 (en) * | 1999-05-27 | 2006-11-02 | Sun Microsystems, Inc. | Module-by-module verification |
| US6766521B1 (en) * | 1999-05-27 | 2004-07-20 | Sun Microsystems, Inc. | Dataflow algorithm for symbolic computation of lowest upper bound type |
| US7539973B2 (en) * | 1999-06-01 | 2009-05-26 | Bruce Hodge | Object type-declaration prefix syntax |
| US6634019B1 (en) | 1999-07-16 | 2003-10-14 | Lamarck, Inc. | Toggling software characteristics in a fault tolerant and combinatorial software environment system, method and medium |
| FR2796482B1 (en) | 1999-07-16 | 2002-09-06 | Touchtunes Music Corp | REMOTE MANAGEMENT SYSTEM FOR AT LEAST ONE AUDIOVISUAL INFORMATION REPRODUCING DEVICE |
| US6973560B1 (en) | 1999-07-16 | 2005-12-06 | Lamarck, Inc. | Fault tolerant and combinatorial software environment system, method and medium |
| US6609246B1 (en) * | 1999-12-07 | 2003-08-19 | Bull Hn Information Systems Inc. | Integrated development environment for high speed transaction processing WWW applications on heterogeneous computer systems |
| FR2805377B1 (en) | 2000-02-23 | 2003-09-12 | Touchtunes Music Corp | EARLY ORDERING PROCESS FOR A SELECTION, DIGITAL SYSTEM AND JUKE-BOX FOR IMPLEMENTING THE METHOD |
| FR2805060B1 (en) | 2000-02-16 | 2005-04-08 | Touchtunes Music Corp | METHOD FOR RECEIVING FILES DURING DOWNLOAD |
| FR2805072B1 (en) | 2000-02-16 | 2002-04-05 | Touchtunes Music Corp | METHOD FOR ADJUSTING THE SOUND VOLUME OF A DIGITAL SOUND RECORDING |
| FR2808906B1 (en) | 2000-05-10 | 2005-02-11 | Touchtunes Music Corp | DEVICE AND METHOD FOR REMOTELY MANAGING A NETWORK OF AUDIOVISUAL INFORMATION REPRODUCTION SYSTEMS |
| FR2811175B1 (en) * | 2000-06-29 | 2002-12-27 | Touchtunes Music Corp | AUDIOVISUAL INFORMATION DISTRIBUTION METHOD AND AUDIOVISUAL INFORMATION DISTRIBUTION SYSTEM |
| FR2811114B1 (en) | 2000-06-29 | 2002-12-27 | Touchtunes Music Corp | DEVICE AND METHOD FOR COMMUNICATION BETWEEN A SYSTEM FOR REPRODUCING AUDIOVISUAL INFORMATION AND AN ELECTRONIC ENTERTAINMENT MACHINE |
| US6498937B1 (en) | 2000-07-14 | 2002-12-24 | Trw Inc. | Asymmetric bandwidth wireless communication techniques |
| EP1303802B1 (en) * | 2000-07-25 | 2013-01-16 | Rovi Solutions Corporation | System and method of verifying the authenticity of dynamically connectable executable images |
| FR2814085B1 (en) | 2000-09-15 | 2005-02-11 | Touchtunes Music Corp | ENTERTAINMENT METHOD BASED ON MULTIPLE CHOICE COMPETITION GAMES |
| FR2820221B1 (en) * | 2001-02-01 | 2004-08-20 | Cimai Technology | METHOD AND SYSTEM FOR MANAGING EXECUTABLES WITH SHARED LIBRARIES |
| US6960291B2 (en) * | 2001-06-19 | 2005-11-01 | Exxonmobil Research And Engineering Company | Naphtha desulfurization method |
| DE10130115A1 (en) * | 2001-06-20 | 2003-01-02 | Oliver H Wesling | Method for accelerated, secure, individualized, need-related and automatic downloading and installation of application software or data to mobile or fixed computers by replacement of blank data spaces with virtual markers |
| DE50104035D1 (en) * | 2001-12-10 | 2004-11-11 | Aladdin Knowledge Systems Gmbh | Procedure for executing a program on a computer |
| US7533101B2 (en) * | 2002-03-04 | 2009-05-12 | Microsoft Corporation | Extensible loader |
| US7346780B2 (en) | 2002-04-03 | 2008-03-18 | Microsoft Corporation | Integrity ordainment and ascertainment of computer-executable instructions |
| US7228426B2 (en) * | 2002-04-03 | 2007-06-05 | Microsoft Corporation | Integrity ordainment and ascertainment of computer-executable instructions with consideration for execution context |
| US7117507B2 (en) * | 2002-06-03 | 2006-10-03 | Sumisho Computer Systems Corporation | Software atomization |
| US20030226929A1 (en) * | 2002-06-06 | 2003-12-11 | Robert Knizner | Holding device for spare string trimmer line spools with slotted inner cavities |
| US7281017B2 (en) * | 2002-06-21 | 2007-10-09 | Sumisho Computer Systems Corporation | Views for software atomization |
| US7165075B2 (en) * | 2002-07-20 | 2007-01-16 | Microsoft Corporation | Object graph faulting and trimming in an object-relational database system |
| US11029823B2 (en) | 2002-09-16 | 2021-06-08 | Touchtunes Music Corporation | Jukebox with customizable avatar |
| US8584175B2 (en) | 2002-09-16 | 2013-11-12 | Touchtunes Music Corporation | Digital downloading jukebox system with user-tailored music management, communications, and other tools |
| US7822687B2 (en) * | 2002-09-16 | 2010-10-26 | Francois Brillon | Jukebox with customizable avatar |
| US10373420B2 (en) | 2002-09-16 | 2019-08-06 | Touchtunes Music Corporation | Digital downloading jukebox with enhanced communication features |
| US8151304B2 (en) * | 2002-09-16 | 2012-04-03 | Touchtunes Music Corporation | Digital downloading jukebox system with user-tailored music management, communications, and other tools |
| US9646339B2 (en) | 2002-09-16 | 2017-05-09 | Touchtunes Music Corporation | Digital downloading jukebox system with central and local music servers |
| US8332895B2 (en) | 2002-09-16 | 2012-12-11 | Touchtunes Music Corporation | Digital downloading jukebox system with user-tailored music management, communications, and other tools |
| US8103589B2 (en) | 2002-09-16 | 2012-01-24 | Touchtunes Music Corporation | Digital downloading jukebox system with central and local music servers |
| US8090943B1 (en) * | 2003-04-28 | 2012-01-03 | Teradata Us, Inc. | Preventing unauthorized access of routines in a library |
| KR100617698B1 (en) * | 2004-06-07 | 2006-08-28 | 삼성전자주식회사 | Binary file creating apparatus and method for storing functional data, and a computer readable storage medium storing the method |
| US8117607B2 (en) * | 2004-08-18 | 2012-02-14 | International Business Machines Corporation | Administration of kernel extensions |
| US8196098B2 (en) | 2006-01-03 | 2012-06-05 | International Business Machines Corporation | System and method for executing temporary processing agents |
| US8171482B1 (en) | 2006-05-09 | 2012-05-01 | Vmware, Inc. | Application environment specifications for provisioning application specific runtime environments using subsets of resources required for execution |
| KR100790053B1 (en) * | 2006-06-05 | 2008-01-02 | 주식회사 대우일렉트로닉스 | Apparatus and Method for Processing Bundle for Master Device |
| CN101187899B (en) * | 2006-11-17 | 2010-05-12 | 中兴通讯股份有限公司 | Embedded type system storage space optimization method |
| US20080163185A1 (en) * | 2006-12-29 | 2008-07-03 | Rto Software, Inc. | Delay-load optimizer |
| US9171419B2 (en) | 2007-01-17 | 2015-10-27 | Touchtunes Music Corporation | Coin operated entertainment system |
| US9330529B2 (en) * | 2007-01-17 | 2016-05-03 | Touchtunes Music Corporation | Game terminal configured for interaction with jukebox device systems including same, and/or associated methods |
| KR100866627B1 (en) * | 2007-01-29 | 2008-11-03 | 삼성전자주식회사 | Method for page preload using control flow and system thereof |
| US9953481B2 (en) * | 2007-03-26 | 2018-04-24 | Touchtunes Music Corporation | Jukebox with associated video server |
| US8707283B2 (en) * | 2007-03-29 | 2014-04-22 | Microsoft Corporation | Parallel DLL tree initialization |
| US7900217B2 (en) * | 2007-03-29 | 2011-03-01 | Microsoft Corporation | Dynamic DLL cycle resolution |
| US8219987B1 (en) | 2007-08-24 | 2012-07-10 | Vmware, Inc. | Optimized virtual machine specification for provisioning application specific runtime environment |
| US8001083B1 (en) | 2007-05-09 | 2011-08-16 | Vmware, Inc. | Repository including version management |
| US9015180B1 (en) | 2007-05-09 | 2015-04-21 | Vmware, Inc. | Repository including file identification |
| US8577937B1 (en) | 2007-05-09 | 2013-11-05 | Vmware, Inc. | Repository including exclusion list |
| US7971047B1 (en) | 2007-09-10 | 2011-06-28 | Vmware, Inc. | Operating system environment and installation |
| US8347263B1 (en) | 2007-05-09 | 2013-01-01 | Vmware, Inc. | Repository including installation metadata for executable applications |
| US11262996B2 (en) | 2007-05-09 | 2022-03-01 | Vmware, Inc. | Repository including exclusion list |
| US10290006B2 (en) * | 2008-08-15 | 2019-05-14 | Touchtunes Music Corporation | Digital signage and gaming services to comply with federal and state alcohol and beverage laws and regulations |
| US8332887B2 (en) | 2008-01-10 | 2012-12-11 | Touchtunes Music Corporation | System and/or methods for distributing advertisements from a central advertisement network to a peripheral device via a local advertisement server |
| GB2456019A (en) * | 2007-12-31 | 2009-07-01 | Symbian Software Ltd | Loading dynamic link libraries in response to an event |
| GB2461499A (en) * | 2008-05-30 | 2010-01-06 | Symbian Software Ltd | Loading software stored in two areas into RAM, the software in a first area is loaded whole and from a second it is demand paged loaded. |
| GB2460462A (en) * | 2008-05-30 | 2009-12-02 | Symbian Software Ltd | Method for loading software components into RAM by modifying the software part to be loaded based on the memory location to be used. |
| US8849435B2 (en) | 2008-07-09 | 2014-09-30 | Touchtunes Music Corporation | Digital downloading jukebox with revenue-enhancing features |
| CN101645019A (en) * | 2008-08-04 | 2010-02-10 | 优诺威讯国际有限公司 | Virtual operating system creation method |
| US8370932B2 (en) * | 2008-09-23 | 2013-02-05 | Webroot Inc. | Method and apparatus for detecting malware in network traffic |
| CN101727345B (en) * | 2008-10-29 | 2013-09-04 | 国际商业机器公司 | Method and system for controlling loading state of dynamic link library DLL |
| US10564804B2 (en) | 2009-03-18 | 2020-02-18 | Touchtunes Music Corporation | Digital jukebox device with improved user interfaces, and associated methods |
| US10719149B2 (en) | 2009-03-18 | 2020-07-21 | Touchtunes Music Corporation | Digital jukebox device with improved user interfaces, and associated methods |
| US9292166B2 (en) | 2009-03-18 | 2016-03-22 | Touchtunes Music Corporation | Digital jukebox device with improved karaoke-related user interfaces, and associated methods |
| CN102449658A (en) | 2009-03-18 | 2012-05-09 | 踏途音乐公司 | Entertainment server and associated social networking services |
| US8171141B1 (en) | 2009-04-02 | 2012-05-01 | Vmware, Inc. | Provisioning system including stack manager |
| JP5338452B2 (en) * | 2009-04-24 | 2013-11-13 | 日本電気株式会社 | Memory management system, memory management method and program |
| KR101446403B1 (en) | 2010-01-26 | 2014-11-04 | 터치튠즈 뮤직 코포레이션 | Digital jukebox device with improved user interfaces, and associated methods |
| US8793809B2 (en) * | 2011-04-25 | 2014-07-29 | Apple Inc. | Unified tracking data management |
| GB2522772B (en) | 2011-09-18 | 2016-01-13 | Touchtunes Music Corp | Digital jukebox device with karaoke and/or photo booth features, and associated methods |
| US11151224B2 (en) | 2012-01-09 | 2021-10-19 | Touchtunes Music Corporation | Systems and/or methods for monitoring audio inputs to jukebox devices |
| CN103414838B (en) | 2013-06-20 | 2015-12-23 | 威海华菱光电股份有限公司 | Image-scanning device and control method thereof |
| US9921717B2 (en) | 2013-11-07 | 2018-03-20 | Touchtunes Music Corporation | Techniques for generating electronic menu graphical user interface layouts for use in connection with electronic devices |
| JP6777545B2 (en) | 2014-03-25 | 2020-10-28 | タッチチューンズ ミュージック コーポレイションＴｏｕｃｈｔｕｎｅｓ Ｍｕｓｉｃ Ｃｏｒｐｏｒａｔｉｏｎ | Digital jukebox devices with an improved user interface and related methods |
| US9348625B2 (en) | 2014-05-23 | 2016-05-24 | Google Inc. | Application access to native and bundled libraries |
| US10528735B2 (en) * | 2014-11-17 | 2020-01-07 | Morphisec Information Security 2014 Ltd. | Malicious code protection for computer systems based on process modification |
| US10754796B2 (en) * | 2018-08-29 | 2020-08-25 | Red Hat, Inc. | Efficient user space driver isolation by CPU page table switching |
| US10983926B2 (en) | 2018-08-29 | 2021-04-20 | Red Hat, Inc. | Efficient userspace driver isolation for virtual machines |
| US11662987B2 (en) * | 2021-08-06 | 2023-05-30 | International Business Machines Corporation | Logically splitting object code into modules with lazy loading of content |
| US20230305883A1 (en) * | 2022-03-22 | 2023-09-28 | Nvidia Corporation | Application programming interface to perform selective loading |
| US20230305890A1 (en) * | 2022-03-22 | 2023-09-28 | Nvidia Corporation | Application programming interface to identify location of program portions |
Family Cites Families (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JPS60252973A (en) * | 1984-05-30 | 1985-12-13 | Fujitsu Ltd | Dynamic loading control system |
| US5291601A (en) * | 1989-06-01 | 1994-03-01 | Hewlett-Packard Company | Shared libraries implemented with linking program loader |
| US5247678A (en) * | 1989-10-12 | 1993-09-21 | Texas Instruments Incorporated | Load time linker for software used with a multiprocessor system |
| JPH0418638A (en) * | 1990-05-11 | 1992-01-22 | Fujitsu Ltd | Static memory allocation processing method |
| US5241623A (en) * | 1990-09-27 | 1993-08-31 | General Electric Company | Method and system for delineation of structure and linkages between knowledge base modules |
| US5291593A (en) * | 1990-10-24 | 1994-03-01 | International Business Machines Corp. | System for persistent and delayed allocation object reference in an object oriented environment |
| US5247681A (en) * | 1990-12-18 | 1993-09-21 | International Business Machines Corporation | Dynamic link libraries system and method |
| IL97894A0 (en) * | 1991-04-17 | 1992-06-21 | Ibm | Multi-processor computer system |
| GB2261753B (en) * | 1991-11-19 | 1995-07-12 | Intel Corp | Multi-mode microprocessor with electrical pin for selective re-initialization of processor state |
| US5359721A (en) * | 1991-12-18 | 1994-10-25 | Sun Microsystems, Inc. | Non-supervisor mode cross address space dynamic linking |
| US5303392A (en) * | 1992-02-27 | 1994-04-12 | Sun Microsystems, Inc. | Accessing current symbol definitions in a dynamically configurable operating system |
-
1993
- 1993-11-10 CA CA002102883A patent/CA2102883A1/en not_active Abandoned
-
1994
- 1994-01-24 JP JP00572894A patent/JP3314378B2/en not_active Expired - Fee Related
- 1994-02-10 EP EP94300983A patent/EP0613084A1/en not_active Withdrawn
- 1994-02-17 BR BR9400603A patent/BR9400603A/en active Search and Examination
- 1994-02-24 KR KR1019940003597A patent/KR0152461B1/en not_active IP Right Cessation
- 1994-02-24 CN CN94102158A patent/CN1042862C/en not_active Expired - Fee Related
-
1995
- 1995-02-21 US US08/391,300 patent/US5708811A/en not_active Expired - Fee Related
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US11200070B2 (en) | 2018-08-03 | 2021-12-14 | International Business Machines Corporation | Dynamic-link library usage based on memory size |
Also Published As
| Publication number | Publication date |
|---|---|
| KR940020238A (en) | 1994-09-15 |
| JP3314378B2 (en) | 2002-08-12 |
| BR9400603A (en) | 1994-09-27 |
| CN1042862C (en) | 1999-04-07 |
| EP0613084A1 (en) | 1994-08-31 |
| JPH06250924A (en) | 1994-09-09 |
| CN1101142A (en) | 1995-04-05 |
| US5708811A (en) | 1998-01-13 |
| KR0152461B1 (en) | 1998-10-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US5708811A (en) | System and method for lazy loading of shared libraries | |
| US7380276B2 (en) | Processor extensions and software verification to support type-safe language environments running with untrusted code | |
| US7490216B1 (en) | Methods for accessing multiple page tables in a computer system | |
| US6321323B1 (en) | System and method for executing platform-independent code on a co-processor | |
| US11210239B2 (en) | Protection key management and prefixing in virtual address space legacy emulation system | |
| US5634058A (en) | Dynamically configurable kernel | |
| US5375241A (en) | Method and system for dynamic-link library | |
| US8015557B2 (en) | Methods and apparatus to support mixed-mode execution within a single instruction set architecture process of a virtual machine | |
| US5539899A (en) | System and method for handling a segmented program in a memory for a multitasking data processing system utilizing paged virtual storage | |
| US7162626B2 (en) | Use of common language infrastructure for sharing drivers and executable content across execution environments | |
| US7260815B1 (en) | Method and apparatus for managing registers in a binary translator | |
| JP4668166B2 (en) | Method and apparatus for guest to access memory converted device | |
| US4970639A (en) | Virtual machine architecture independent program loader | |
| US7558724B2 (en) | Operation region describing a virtual device | |
| US5826090A (en) | Loadable hardware support | |
| US20020046305A1 (en) | Method for effective binary translation between different instruction sets using emulated supervisor flag and multiple page tables | |
| US6324688B1 (en) | Method and apparatus for optimizing execution of Java programs | |
| WO2008009176A1 (en) | Heap organization for a multitasking virtual machine | |
| US7213098B2 (en) | Computer system and method providing a memory buffer for use with native and platform-independent software code | |
| US6772259B2 (en) | Interrupt handlers used in different modes of operations | |
| Darlet | Runtime Loader-Linker Technologies |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| FZDE | Discontinued |