JP2014157434A - Program generation method, program execution method, program generation device, program generation program, program execution device, and program execution program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To allow execution of a program to be quickly started.SOLUTION: An OS part 144, before execution of an execution program 120 is started, maps, onto a process space, a partial program code including a main function among program codes of an execution program 120 and a correspondence table for specifying a storage domain in an auxiliary storage device which stores remaining program codes other than the partial program code among the program codes of the execution program 120. The program execution part 141 executes the execution program 120. When the program execution part 141 executes a program code included in the remaining program codes that are not mapped onto the process space as an execution code, the OS part 144 maps the execution code onto the process space by using the corresponding table mapped onto the process space.

Description

  The present invention relates to, for example, a program generation method, a program execution method, a program generation device, a program generation program, a program execution device, and a program execution program for shortening the startup time of a program.

  Along with the rapid increase in performance and capacity of CPUs (Central Processing Units) and DRAMs (Dynamic Random Access Memory), application programs have become highly functional and are steadily growing. In particular, an application program having a graphical user interface (GUI) is written in a high-level language such as C ++, and the total number of development steps exceeds 1 million lines is not uncommon.

  However, when the program becomes large, disk I / O through a file system that requires a large processing delay as a dependency on the high-speed CPU and DRAM is required many times when the program is started. Once launched, there was no problem with its operability, but users were frustrated with the startup time of the program.

Therefore, a method of using a NAND flash memory that has remarkably higher I / O performance than a hard disk may be considered.
However, flash memory is still more expensive than hard disks. In addition, flash memory requires data erasure in 64 kilobyte blocks in CMOS (CMOS: Complementary Metal Oxide Semiconductor), and if bit data is written or erased about 100,000 times in one block, bit information is stored. It may become unusable due to deterioration of the charge film.
For this reason, when a flash memory is used instead of a hard disk, the startup time of an application is greatly shortened, but it may not always be a good choice for building a system.

  Patent Document 1 or Patent Document 2 describes that when an exception occurrence block when an access exception occurs is an execution function portion of a shared library, the execution function portion is read from a file of the shared library into a physical block.

  Japanese Patent Application Laid-Open No. 2004-228561 describes that an OS (Operating System) and a program are read out to a main storage device via a network.

  In addition, there is a common practice of delaying and loading a shared library that seems to have few opportunities for use.

JP 2010-257173 A JP-A-6-250924

  An object of the present invention is, for example, to be able to generate a program having a short time required for activation.

The program generation method of the present invention includes:
Data including a part of program code including a main function as a program code to be mapped to the virtual space before the program execution is started, and mapped to the virtual space before the execution of the program is started Including storage area information for specifying a storage area in the auxiliary storage device in which the remaining program codes excluding the part of the program codes are stored, and mapped to the virtual space before the execution of the program is started A file including the remaining program code as data not to be generated is generated as the program.

  According to the present invention, for example, it is possible to generate a program that takes a short time to start.

2 is a diagram illustrating an example of a hardware configuration of a computer system 100 according to Embodiment 1. FIG. 2 is a diagram illustrating an example of a software configuration of a computer system 100 according to Embodiment 1. FIG. FIG. 3 is a diagram illustrating a configuration example of an execution program 120 in the first embodiment. 6 is a diagram illustrating an example of a correspondence table 122 according to Embodiment 1. FIG. 3 is a diagram showing an example of a process space 130 of an execution program 120 in the first embodiment. FIG. FIG. 3 is a schematic diagram showing a page allocation method during execution of an execution program 120 in the first embodiment. FIG. 3 is a schematic diagram showing a page allocation method during execution of an execution program 120 in the first embodiment. 2 is a functional configuration diagram of a computer system 100 according to Embodiment 1. FIG. 3 is a flowchart showing a program execution process in the first embodiment. It is a figure which shows the outline | summary of the page allocation method at the time of the program execution in the past. FIG. 10 shows a process space in the fourth embodiment. It is a figure which shows the 1st execution program 120A in Embodiment 9, and the 2nd execution program 120B. It is a figure which shows 1st process space 130A and 2nd process space 130B in Embodiment 9. FIG.

Embodiment 1 FIG.
A description will be given of a mode in which a program having a short startup time is generated so that the program can be started quickly.

FIG. 1 is a diagram illustrating an example of a hardware configuration of a computer system 100 according to the first embodiment.
An example of the hardware configuration of the computer system 100 according to the first embodiment will be described with reference to FIG.

The computer system 100 includes a CPU 101, a DRAM 103, a disk controller 104, a hard disk 105, and a network controller 106.
The CPU 101 is connected to the DRAM 103, the disk controller 104, and the network controller 106 via the bus 108, and controls these hardware.
The CPU 101 includes a memory management unit (MMU 102) that mutually converts a virtual address of the virtual memory and a physical address of the physical memory (DRAM 103).
The DRAM 103 is a main storage device (also referred to as a memory, a physical memory, or a main memory) used as a storage area for executing a program.
The hard disk 105 is an auxiliary storage device for storing a program or data used in the program.
The disk controller 104 is a device that controls the hard disk 105.
The network controller 106 is a device for connecting to the network 107.

  CPU 101 is an abbreviation for Central Processing Unit, and DRAM 103 is an abbreviation for Dynamic Random Access Memory.

  However, the hardware configuration of the computer system 100 may be a configuration other than the configuration shown in FIG.

FIG. 2 is a diagram illustrating an example of a software configuration of the computer system 100 according to the first embodiment.
An example of the software configuration of the computer system 100 according to the first embodiment will be described with reference to FIG.

The computer system 100 includes an OS 111, a compiler 113, a linker 114, a program source 115, a static library source 116, a shared library source 117, and an execution program 120.
The OS 111 is an operating system that provides the functions of the computer system 100 to software such as the execution program 120.
The OS 111 includes a program loader 112 that loads the execution program 120 into the physical memory from the hard disk 105 or the network.

The program source 115 is a source code of the execution program 120.
The static library source 116 is source code of a static library (for example, a standard library).
The shared library source 117 is a source code of the shared library.

The compiler 113 is a program for compiling the program source 115, the static library source 116, and the shared library source 117.
Hereinafter, the compiled program source 115 is referred to as an “object program”.
The compiled static library source 116 is called “static library”, and the compiled shared library source 117 is called “shared library”.

  The linker 114 is a program for generating an execution program 120 by combining an object program, a static library, and a shared library.

  The execution program 120 is an execution format program executed by the CPU 101.

FIG. 3 is a diagram illustrating a configuration example of the execution program 120 in the first embodiment.
A configuration example of the execution program 120 in the first embodiment will be described with reference to FIG.

  The execution program 120 includes an entry point text 121, a correspondence table 122, program data 123, and a program text 124.

The entry point text 121 is a part of text including the main () function in the text of the execution program 120 (also referred to as program code, command statement, function, routine, or machine language).
In addition to the main () function, the entry point text 121 includes rewrite logic for rewriting the stack pointer and heap pointer, and a signal handler for handling a memory access exception.
The entry point text 121 is a. Stored in the text section.
In the conventional execution program, all the texts of the execution program 120 are. Stored in the text section.

The program data 123 is a data entity defined in the execution program 120.
For example, the program data 123 includes data defined in the entry point text 121 and data defined in the static library.

The program text 124 is an entity of the remaining text excluding the entry point text 121 in the text of the execution program 120.
For example, the program text 124 includes a static library.

  Program data 123 and program text 124 are... For storing comments. stored in the comment section.

The correspondence table 122 includes the addresses of the virtual memory (also referred to as virtual space or virtual address space), the. This is information for associating the program data 123 stored in the comment section or the storage area in which the program text 124 is stored. The address of the virtual memory is called “virtual address”.
The correspondence table 122 is a table for storing data defined in the program. Stored in the data section.
In the conventional execution program, the program data 123 is. Stored in the data section. Further, the conventional execution program does not include the correspondence table 122.

FIG. 4 is a diagram showing an example of the correspondence table 122 in the first embodiment.
The correspondence table 122 in the first embodiment will be described with reference to FIG.

The correspondence table 122 includes virtual addresses and. This is information for associating the program data 123 stored in the coment section or the storage area where the program text 124 is stored.
The correspondence table 122 associates “virtual address”, “start offset”, and “number of pages”.
The “virtual address” indicates an address for identifying the first storage area to which the program data 123 or the program text 124 is mapped in the storage area of the virtual memory.
The “start offset” is the. A page number for identifying the first page in which program data 123 or program text 124 stored in the comment section is stored is shown.
“Number of pages” indicates the number of pages in which program data 123 or program text 124 is stored.

FIG. 5 is a diagram illustrating an example of the process space 130 of the execution program 120 in the first embodiment.
The process space 130 of the execution program 120 in the first embodiment will be described with reference to FIG.

The process space 130 is a virtual space allocated for a process that executes the execution program 120.
The process space 130 includes a text area 131, a stack area 132, a heap area 133, a bss area 134, and a data area 135.
The text area 131 is a storage area to which the entry point text 121 and the program text 124 are mapped.
The stack area 132 is a storage area to which variable values of local variables in the program data 123 are mapped.
The heap area 133 is a storage area that is dynamically reserved during execution of the execution program 120.
The bss area 134 is a storage area to which variable values of global variables whose initial values are not defined in the program data 123 are mapped.
The data area 135 is a storage area to which variable values of global variables in which initial values are defined in the program data 123 are mapped. Also, the correspondence table 122 (see FIG. 4) is mapped to the data area 135.

6 and 7 are schematic diagrams showing a page allocation method at the time of execution of the execution program 120 in the first embodiment.
An overview of a page allocation method for mapping the process space 130 to the execution program 120 and allocating a physical page to the process space 130 will be described with reference to FIGS.

The process space 130 of the execution program 120 is composed of a plurality of virtual pages.
A virtual page shaded among the virtual pages constituting the process space 130 means a virtual page to which a part of the execution program 120 is mapped and a storage area (physical page) of physical memory is allocated.
The virtual pages that are not shaded among the virtual pages constituting the process space 130 mean virtual pages to which the execution program 120 is not mapped and physical pages are not allocated.

The text area 131 includes three areas “main text”, “Libc text”, and “hoge text”.
“Main text” is an area to which the entry point text 121 is mapped out of the text (program code) mapped to the text area 131.
“Libc text” is an area to which the text of the static library (part of the program text 124) is mapped among the texts mapped to the text area 131.
The “hoge text” is an area to which program text 124 (excluding a static library, for example, a shared library) is mapped among texts mapped to the text area 131.

The data area 135 includes three areas “main data”, “Libc data”, and “hoge data”.
“Main data” is an area to which data defined in the entry point text 121 among data mapped to the data area 135 is mapped. Further, the correspondence table 122 is also mapped to “main data”.
“Libc data” is an area to which data defined in the static library among data mapped to the data area 135 is mapped.
“Hoge data” is an area to which the remaining data of the data area 135 is mapped.

Before the execution of the execution program 120 is started, the program loader 112 maps the entry point text 121 to a virtual page that constitutes “main text”. The virtual storage function of the OS 111 allocates the physical page of the physical memory to the virtual page that constitutes “main text”, and loads the entry point text 121 to the allocated physical page.
In addition, the program loader 112 maps the correspondence table 122 to a virtual page constituting “main data”. Then, the virtual storage function of the OS 111 allocates a physical page of the physical memory to a virtual page constituting “main data”, and loads the correspondence table 122 to the allocated physical page.
The program loader 112 does not map text or data other than the entry point text 121 and the correspondence table 122 to the process space 130 before the execution of the execution program 120 is started (see FIG. 6).

  Text or data other than the entry point text 121 and the correspondence table 122 is mapped to the process space 130 by a memory access exception and loaded into the physical memory when the execution instruction 120 is started and an access instruction is generated ( (See FIG. 7).

FIG. 8 is a functional configuration diagram of the computer system 100 according to the first embodiment.
A functional configuration of the computer system 100 according to the first embodiment will be described with reference to FIG.

The computer system 100 (an example of a program execution device) includes a program execution unit 141, a compilation unit 142, a link unit 143 (an example of a program generation unit), and an OS unit 144 (an example of a pre-start mapping unit and an executing mapping). A signal handler unit 145, a device driver unit 146, and a program storage unit 149.
The program execution unit 141 executes the execution program 120.
The compiling unit 142 compiles the program source 115, the static library source 116, and the shared library source 117 by executing the compiler 113.
By executing the linker 114, the link unit 143 executes a compiled program source 115 (object program), a compiled static library source 116 (static library), a compiled shared library source 117 (shared library), Are combined to generate an execution program 120.
The OS unit 144 executes the OS 111. For example, the OS unit 144 executes the program loader 112 and the virtual storage function (including the paging mechanism) of the OS 111.
The signal handler unit 145 executes a signal handler defined in the main () function of the execution program 120.
The device driver unit 146 executes a device driver for controlling the disk controller 104.
The program storage unit 149 stores the program source 115, the static library source 116, the shared library source 117, the execution program 120, and the like using the hard disk 105.

FIG. 9 is a flowchart showing a program execution process in the first embodiment.
The program execution process in Embodiment 1 is demonstrated based on FIG.

  Here, it is assumed that the execution program 120 (see FIG. 3) and the correspondence table 122 (see FIG. 4) are generated by the compiling unit 142 and the link unit 143.

In S110, the OS unit 144 generates a process space 130 (see FIG. 5) for executing the execution program 120.
After S110, the process proceeds to S120.

  In S120, the OS unit 144 loads the entry point text 121 and the correspondence table 122 as follows.

The OS unit 144 executes the execution program 120. The entry point text 121 stored in the text section is mapped to a virtual page of “main text” in the text area 131 of the process space 130.
The OS unit 144 executes the execution program 120. The entry point text 121 stored in the text section is mapped to a virtual page of “main text” in the text area 131 of the process space 130.
The OS unit 144 allocates a physical page of the physical memory (DRAM 103) to a virtual page of “main text” (see FIG. 6).
Then, the OS unit 144 reads the entry point text 121 from the program storage unit 149 (hard disk 105), and writes the read entry point text 121 on the physical page. That is, the OS unit 144 loads the entry point text 121 onto the physical page.

  Further, the OS unit 144 sets a virtual address immediately after “main text” in the stack pointer for designating the stack area 132 (see (1) in FIG. 6).

  Further, the OS unit 144 sets a virtual address of the rewrite logic included in the entry point text 121 as an entry pointer for designating a program code to be executed. After the rewrite logic is executed, the main () function is executed. However, the OS unit 144 may set the virtual address of the main () function in the entry pointer, and the rewrite logic may be called from the main () function.

Similarly, the OS unit 144. The correspondence table 122 stored in the data section is mapped to a virtual page of “main data” in the data area 135 of the process space 130.
The OS unit 144 allocates a physical page to a virtual page of “main data” (see FIG. 6).
Then, the OS unit 144 loads the correspondence table 122 from the program storage unit 149 to the physical page.
Further, the OS unit 144 sets a virtual address immediately before “main data” in the heap pointer for designating the heap area 133 (see (2) in FIG. 6).
After S120, the process proceeds to S130.

  In S <b> 130, the program execution unit 141 starts execution of the execution program 120. That is, the program execution unit 141 executes the rewrite logic (or the rewrite logic called from the main () function) set in the entry pointer.

The program execution unit 141 sets the correct virtual address of the stack area 132 as the stack pointer by executing the rewrite logic, and sets the correct virtual address of the heap area 133 as the heap pointer.
That is, the program execution unit 141 updates the virtual address set in the stack pointer to the virtual address immediately after the text area 131 (see (3) in FIG. 6), and sets the virtual address set in the heap pointer to bss. The virtual address immediately before the area 134 is updated (see (4) in FIG. 6).
Thus, the existing program loader can be used as the program loader 112 of the computer system 100 without adding a rewrite logic function to the existing program loader.

After executing the rewrite logic, the program execution unit 141 executes the next program code of the rewrite logic.
After S130, the process proceeds to S140.

In S140, when an access instruction (call, jump, load, store, etc.) for accessing the program data 123 or the program text 124 to which the virtual page is not mapped is executed, the OS unit 144 signals the virtual address to be accessed. By notifying the handler unit 145, a memory access violation is generated.
Hereinafter, the program data 123 or program text 124 accessed in S140 is referred to as “access violation data”, and the virtual address of the access violation data is referred to as “access violation address”.
If a memory access violation has occurred (YES), the process proceeds to S150.
If no memory access violation occurs (NO), the process proceeds to S170.

  In S150, the signal handler unit 145 performs the following processing by executing the signal handler defined in the main () function.

The signal handler unit 145 acquires the start offset and the number of pages associated with the same virtual address as the access violation address from the correspondence table 122 (see FIG. 4).
Then, the signal handler unit 145 maps the page (access violation data) in the hard disk 105 specified by the acquired start offset and the number of pages to the virtual page specified by the access violation address, and assigns the physical page to the virtual page. Assign.

For example, when the access violation address is “0xc0077000”, the signal handler unit 145 acquires the start offset “114” and the page number “56” from the correspondence table 122.
The signal handler unit 145 maps “56” pages from the “114” -th page to the “169” -th page of the hard disk 105 to the virtual page, and allocates the physical page to the virtual page.

Hereinafter, the start offset acquired in S150 is referred to as “target start offset”, and the number of pages acquired in S150 is referred to as “target page number”.
After S150, the process proceeds to S160.

In S160, the OS unit 144 acquires the target start offset and the target page number from the signal handler unit 145.
The OS unit 144 uses the paging function of the OS 111 to specify the sector corresponding to the page specified by the target start offset and the target page number among the sectors (storage areas) of the hard disk 105.
Hereinafter, the specified sector is referred to as “target sector”, and the identifier for identifying the specified sector is referred to as “target sector number”.

  The OS unit 144 notifies the device driver unit 146 of the access violation address and the target sector number.

  The device driver unit 146 converts the access violation address into a physical address using the MMU 102 and inputs an I / O instruction including the physical address and the target sector number to the disk controller 104.

In accordance with the I / O instruction, the disk controller 104 loads the access violation data stored in the target sector of the hard disk 105 into the physical page identified by the physical address.
For example, the disk controller 104 loads access violation data by using a DMA (Direct Memory Access) function.
After S160, the process proceeds to S170.

In S170, the program execution unit 141 continues to execute the execution program 120.
After S170, the process proceeds to S171.

In S171, when the execution of the execution program 120 is completed (YES), the program execution process ends.
If execution of the execution program 120 does not end (NO), the process returns to S140.

  As described above, the computer system 100 according to the first embodiment uses only pages necessary for program execution and does not generate redundant copies. As a result, the larger the application, the faster the startup compared to the conventional example, and it is possible to suppress unnecessary memory consumption.

In the first embodiment, the form in which the execution program 120 is stored in the hard disk 105 provided in the computer system 100 has been described.
However, the execution program 120 (or a part of the execution program 120) may be stored in another storage device connected to the network 107. In this case, the computer system 100 acquires the execution program 120 (or a part of the execution program 120) from another storage device via the network 107.

FIG. 10 is a diagram showing an outline of a conventional page allocation method during program execution.
An overview of a page allocation method at the start of execution of a conventional program will be described with reference to FIG.

Conventionally, when a program is executed, a process space and an execution context are secured before the execution of the program is started.
Also, physical pages are allocated to the program text area “main text” and the static library text area “Libc text” in the process space, and the program text and the static library text are loaded.
Further, physical pages are allocated to the program data area “main data”, the static library data area “Libc data”, and the shared library data area “hoge data”, and the program, static library, and shared library Data is loaded.
Furthermore, a physical page is allocated to the text area “hoge text” of the shared library provided in a virtual space different from the process space of the program, and the text of the shared library is loaded.
In other words, conventionally, all programs, static libraries, and shared libraries are loaded into physical memory before program execution is started.

The stack area is provided immediately after the text areas “main text” and “Libc text”, the bss area is provided immediately before the data areas “main data”, “Libc data”, and “hoge data”, and the heap area is the bss area. It is provided immediately before.
The program is executed in order from the main () function specified by the entry pointer.

After running the program, if the physical memory is insufficient, the shared library is saved to the hard disk.
When the shared library saved on the hard disk is used, a load function for loading the shared library is executed, and the shared library is loaded from the hard disk to the physical memory.

Next, a file system for loading data (for example, a shared library) from the hard disk into the physical memory will be described.
The file system manages a 512-byte buffer memory corresponding to one sector of the hard disk by the function of the OS, and loads the shared library from the hard disk to the physical memory using the buffer memory of the OS.
That is, when an OS system call such as read () or write () is called to load the shared library, the file system copies the shared library to the buffer memory in units of sectors on the hard disk and buffers the shared library. Copy from memory to physical memory.

However, recent file systems use a Libc data buffer corresponding to one page of physical memory instead of using the OS buffer memory. Libc is a standard library prepared in C language.
For example, when a load function for loading a shared library is executed, the file system opens a file including the shared library among files on the hard disk with the open () function, and opens the shared library with the read () function. The shared library that has been read is copied to the data buffer for Libc.
Further, the file system copies the shared library from the data buffer for Libc to the physical memory allocated to the heap area or the text area “hoge text”.
That is, the file system loads one disk I / O (read from the hard disk) and two data copies (from the hard disk to the data buffer) for each page of the physical memory in order to load the shared library into the physical memory. Copy, copy from data buffer to physical memory).

In the first embodiment, for example, the following program generation method and program execution method have been described. The code or name of the corresponding configuration is shown in parentheses.
The program generation unit (143) includes a part of program code (121) including a main function (main () function) as a program code to be mapped to the virtual space before the execution of the program (120) is started, A storage area for specifying a storage area in the auxiliary storage device (105) in which the remaining program codes excluding the part of the program codes are stored as data to be mapped in the virtual space before the execution of the program is started A file including the information (122) and including the remaining program code (124) as data not mapped in the virtual space before the execution of the program is started is generated as the program.

Before the start mapping unit 144 starts execution of the execution program, a part of the program code of the execution program including a main function and the part of the program code of the execution program The storage area information for specifying the storage area in the auxiliary storage device in which the remaining program codes excluding the program code are stored is mapped in the virtual space.
A program execution unit (141) executes the execution program.
When the executing mapping unit (144) executes, as the execution code, the program code included in the remaining program code that is not mapped in the virtual space by the pre-start mapping unit, the pre-start mapping The execution code is mapped to the virtual space using the storage area information mapped to the virtual space by the unit.

In the first embodiment, the arrows included in the flowchart mainly indicate input / output of data and signals. The processing described based on the flowchart and the like is executed using hardware.
What is described as “˜unit” in the first embodiment may be replaced with “˜circuit”, “˜device”, “˜unit”, “˜step”, or “˜processing”. That is, what is described as “to part” may be implemented by any of firmware, software, hardware, or a combination thereof.

  In the following embodiments, the description of the computer system 100 in the first embodiment will be supplemented.

Embodiment 2. FIG.
As described in the first embodiment, the computer system 100 can manage a working set (memory area) for executing a program by using the virtual storage function of the operating system as it is.
The computer system 100 does not limit the location of the back store used as a virtual storage device. For example, the computer system 100 may use a server connected to a network such as the Internet as a virtual storage device. That is, the computer system 100 may load the execution program 120 from the server into the physical memory instead of the hard disk 105.

In the second embodiment, for example, the following computer system 100 has been described.
The computer system 100 places the library text and the page data of the data on the network as a replica of the execution program file, and acquires the page data via the network.

Embodiment 3 FIG.
As described in the first embodiment, the computer system 100 can use an existing operating system because the specification of the operating system does not matter.
That is, the linker 114 of the computer system 100 can be implemented in accordance with the implementation of the virtual storage mechanism realized by the existing CPU 101, MMU 102, and OS 111.
For example, the computer system 100 can apply a CPU 101 of Intel or AMD, an OS 111 of Microsoft or HP, a PA-RISC inverted table architecture of HP, an IBM server, or the like.

In the third embodiment, for example, the following computer system 100 has been described.
The computer system 100 changes the stack pointer and the heap pointer by executing the execution program, and secures the text placement area and data placement area of the library. Thereby, the computer system 100 does not need to change the loader function of the program of the existing system.

Embodiment 4 FIG.
In the first embodiment, the case where the computer system 100 executes the execution program 120 in one process space has been described.
However, the computer system 100 can also execute the execution program 120 in a plurality of process spaces. For example, the computer system 100 can display a plurality of windows functioning as a web browser by executing the web browser execution program 120 in a plurality of process spaces.

FIG. 11 is a diagram showing a process space in the fourth embodiment.
The computer system 100 generates a first process space when the execution of the execution program 120 is started, and executes the execution program 120 using the generated first process space.
Furthermore, the computer system 100 generates a second process when the execution program 120 is executed using the first process space, and what is the first process space using the generated second process space? The execution program 120 is executed separately.
The area “hoge text” that can be shared by the first process space and the second process space may be provided in a virtual area different from the first process space and the second process space.

In the fourth embodiment, for example, the following computer system 100 has been described.
When the computer system 100 executes two or more execution programs, the computer system 100 shares a physical memory page to which the text is assigned.

Embodiment 5 FIG.
One of the advantages of using a shared library is as follows. Even if the shared library is updated for some reason, if there is no change in the API (Application Program Interface) of the shared library, there is no need to recompile an application program that uses the updated shared library.
In the computer system 100 described in the first embodiment, it is not necessary to recompile the application program (execution program 120) in accordance with the update of the shared library excluding the API change. However, since the computer system 100 uses the updated shared library, it is necessary to newly generate an application program by executing the linker 114 anew.

In the fifth embodiment, for example, the following computer system 100 has been described.
Even if there is a change in the shared library, the computer system 100 performs only an incremental change of the library and does not require recompilation of the execution program.

Embodiment 6 FIG.
The computer system 100 described in the first embodiment pastes the application program (execution program 120) into the virtual space and enables only the pages necessary for its execution, thereby shortening the startup time of the application program and memory consumption. Is to optimize.
The computer system 100 can achieve the above effect without modifying the existing system, but the computer system 100 may be constructed by modifying the existing system.

Embodiment 7 FIG.
The computer system 100 stores a virtual address where a memory access violation has occurred during execution of the execution program 120, and stores text or data set in a virtual area identified by the stored virtual address. text section or. The execution program 120 may be reconfigured so as to be stored in the data section. Further, the computer system 100 may sort the text or data set in the stored virtual address into the address storage number.
As a result, the computer system 100 can load text or data that is likely to be used during execution of the execution program 120 into the physical memory before the execution of the execution program 120 is started. That is, the computer system 100 can suppress a memory access violation that occurs during execution of the execution program 120.

In the seventh embodiment, for example, the following computer system 100 has been described.
The computer system 100 acquires the address where the memory access violation of text and data has occurred, sorts the text and data in symbol units corresponding to the address, and relinks the program.

Embodiment 8 FIG.
The computer system 100 may generate an application program (execution program 120) using a linker provided by Microsoft Corporation and following the Microsoft PE execution file format.
The computer system 100 can be applied to all application programs that operate on the operating system “Windows (registered trademark)” of Microsoft Corporation.
For example, a developer who develops an application program that runs on "Windows (registered trademark)" creates and tests a program as usual using a development environment such as "Visual Studio (registered trademark)" of Microsoft Corporation. An application program of an appropriate quality as a product may be developed. Then, the developer creates a PE execution file format application program using a linker provided by Microsoft, and ships the created application program as a product.

In the eighth embodiment, for example, the following computer system 100 has been described.
The computer system 100 has a loader that can interpret the execution program format.

Embodiment 9 FIG.
The form of the execution program 120 different from the first embodiment will be described.
Items different from the first embodiment will be mainly described, and items omitted will be the same as those in the first embodiment.

FIG. 12 is a diagram showing the first execution program 120A and the second execution program 120B in the ninth embodiment.
As shown in FIG. 12, the link unit 143 generates a first execution program 120A composed of the entry point text 121 and the correspondence table 122, and a second execution program 120B composed of the program text 124 and the program data 123. To do.
The main () function of the entry point text 121 includes a system call (fork) for copying the process space 130 and mapping logic for mapping the program text 124 and the program data 123 to the copied process space 130. .

FIG. 13 is a diagram showing a first process space 130A and a second process space 130B in the ninth embodiment.
In FIG. 13, the OS unit 144 generates a first process space 130A for executing the first execution program 120A (see FIG. 12).
The OS unit 144 maps the entry point text 121 of the first execution program 120A to a virtual page of “main text”, and maps the correspondence table 122 to “main data”.
The OS unit 144 allocates a physical page to the virtual page of “main text” and the virtual page of “main data”, and loads the entry point text 121 and the correspondence table 122 to the allocated physical page.

The program execution unit 141 executes a main () function included in the entry point text 121 of the first process space 130A.
Thereby, the first process space 130A is copied to generate the second process space 130B, and the program text 124 and the program data 123 are mapped to the second process space 130B using the correspondence table 122.

  Thereafter, the program execution unit 141 executes the second execution program 120B mapped to the second process space 130B.

In the ninth embodiment, it has been described that the minimum execution program composed of the entry point text 121 and the correspondence table 122 and the normal execution program composed of the program text 124 and the program data 123 are generated.
Further, it has been described that the process space for executing a normal program is generated by copying the process space of the smallest execution program.

In each embodiment, for example, the following matters have been described.
Conventional operating system functions avoid services such as loading shared library text into memory and copying data to the process of use, and all libraries, including static libraries, are in the virtual address space of the executable program. Arrange and resolve the address to make one execution program.

  Prior to the main () function, the linker program adds logic for initializing the stack pointer at the text position where all text is stored and data for the library part, and logic for updating the heap pointer at the position required for BSS storage. Add

The program described by the main () function is minimal.
A linker program is an executable program. Store the text of the program in the text section; In the data section, the data of the program and the correspondence table of the text, data and BSS of the library program are stored.
The text and data of the library pointed to the correspondence table is. Store in the comment section.

The system program loader is. text section and. The data section is loaded into the secured process space.
When the system gives an execution context to the process, the execution program secures storage areas for library text, data, and BSS by the update logic of the stack pointer and heap pointer.

  By executing the program, a memory access violation exception occurs in text reference or data reference / write.

An exception handler for memory access violation is defined in the execution program.
The handler refers to the correspondence table with the address where the memory access violation occurred. The text or data in the comment section is mapped to the page containing the address. Then, when the system paging mechanism issues a DMA I / O instruction to the hard disk controller via the file system, the contents of the page portion of the execution program file are written into the page from the sector of the hard disk by DMA. .

  The execution program may map the library text of the execution program and the entire data in the process space at the timing of updating the stack pointer and the heap pointer.

  The replica of the execution program may be placed on the network.

Many shared libraries for huge applications are used only by the program on the system.
However, a plurality of the same applications may be used on the same system.
In view of this situation, the execution program takes statistical information on how many simultaneous executions of itself are performed.
When it is determined from the statistical information that two or more are often executed simultaneously, the execution program reserves the page memory of the library text as a shared memory.
Thus, the second and subsequent execution programs can share the library text memory space.

  The execution method using the shared memory area for the library can always be applied regardless of the number of processes of the execution program.

The linker program reconfigures the existing shared library into an execution program.
However, if a change occurs in the shared library to be used, the linker program is re-executed.

Each embodiment is characterized in that it is effective without changing the existing system.
However, this does not deny the change in programming paradigm due to higher performance and larger capacity of CPUs and DRAMs. It is also acceptable to implement a system program, particularly a loader that secures process space and maps the execution program during execution.

  The computer system 100 stores the address that caused the memory access violation by executing the program, and relinks the symbol including the address and the text and data modified by the symbol in the order of occurrence of the memory access violation. This enables more efficient use of the page memory.

According to each embodiment, the start-up of a huge application becomes very fast.
Further, since the application can manage the memory use by itself, the working set management can be implemented as an application function even in an application in an embedded system in which restrictions on the memory use are severe.

In each embodiment, for example, the following program generation method and program execution method have been described.
A linker that generates an executable program and a loader that loads the executable program into memory. The memory address exception that occurs when the program references library text, data, or BSS causes the program address space A part of page memory is secured and the data is loaded.
The linker places the static library and shared library required when generating the execution program in one program address space, performs address resolution only including the shared library, and stores the load address stored in the execution program and the text of the library. A correspondence table, which is a means for specifying the data, is generated as data, and an executable program is generated.

  The library text and the page data of the data are arranged on the network as a replica of the execution program file, and the page data is acquired via the network.

The execution program itself changes the stack pointer and heap area pointer to secure the text arrangement area and data arrangement area of the library.
Thereby, it is not necessary to change the loader function of the program of the existing system.

  When two or more execution programs are executed on the same system, the physical memory page to which the text is assigned is shared.

It has a correspondence table of load addresses, texts and data, and means for updating the contents.
Even if there is a change in the shared library portion, it is only an incremental change of the library, and no recompilation of other programs in the execution program is required.

  The system has a loader that can interpret the executable program format.

  The execution program acquires the address information that caused the memory access violation of the text and data by executing the program, sorts the text and data in symbol units corresponding to the address, and relinks the text and data.

  100 computer system, 101 CPU, 102 MMU 103 DRAM, 104 disk controller, 105 hard disk, 106 network controller, 107 network, 108 bus, 111 OS, 112 program loader, 113 compiler, 114 linker, 115 program source, 116 static library source 117 shared library source, 120 execution program, 121 entry point text, 122 correspondence table, 123 program data, 124 program text, 130 process space, 131 text area, 132 stack area, 133 heap area, 134 bss area, 135 data area 141 Program execution unit 142 Compile unit 143 Link , 144 OS unit, 145 signal handler unit, 146 device driver section, 149 a program storage unit.

Claims (16)

Data including a part of program code including a main function as a program code to be mapped to the virtual space before the program execution is started, and mapped to the virtual space before the execution of the program is started Including storage area information for specifying a storage area in the auxiliary storage device in which the remaining program codes excluding the part of the program codes are stored, and mapped to the virtual space before the execution of the program is started A program generation method comprising: generating a file including the remaining program code as unprocessed data as the program. Before the start mapping unit starts executing the execution program, a part of the program code of the execution program including a main function and a part of the program code of the execution program Mapping the storage area information for specifying the storage area in the auxiliary storage device in which the remaining program codes except for are stored in the virtual space,
The program execution unit executes the execution program,
When the executing mapping unit executes, as the execution code, the program code included in the remaining program code that is not mapped to the virtual space by the pre-start mapping unit, the pre-start mapping unit performs virtual A program execution method, wherein the execution code is mapped to a virtual space using the storage area information mapped to a space. A program generation unit generates, as the execution program, a program including the part of the program code as text section data to be set in a text area for setting a program code among areas constituting a virtual space for executing the program And
The pre-start mapping unit converts the partial program code included in the execution program as the text section data into the text in the virtual space before the execution of the execution program generated by the program generation unit is started. 3. The program execution method according to claim 2, wherein the program is mapped to an area. The part of the program code includes the main function and a pointer rewriting function,
The pointer rewriting function designates the first area when the remaining program code is added to the text area as a first pointer for designating a first area located next to the text area. 4. The program execution method according to claim 3, wherein the function is a function for setting an address to be executed. The program generation unit generates, as the execution program, a program including the storage area information as data section data to be set in a data area for setting data defined in the program among the areas constituting the virtual space,
The pre-start mapping unit stores the storage area information included in the execution program as the data section data in the data area of the virtual space before the execution of the execution program generated by the program generation unit is started. 5. The program execution method according to claim 4, wherein mapping is performed. The pointer rewriting function adds data defined in the execution program to the data area to a second pointer for designating the second area other than the text area, the data area, and the first area. 6. The program execution method according to claim 5, wherein the program is a function for setting an address for designating the second area. The program execution method according to claim 4, wherein the program execution unit executes the main function after executing the pointer rewriting function.   8. The program execution method according to claim 2, wherein the auxiliary storage device is a device connected to a network. When the execution program is executed by using the first virtual space and the execution program is executed by using the second virtual space by the program execution unit, the executing mapping unit At least one program included in the remaining program code in a third virtual space shared by the execution program executed using the space and the execution program executed using the second virtual space 9. The program execution method according to claim 2, wherein the code is mapped. The said program generation part includes the said execution code mapped by the said executing mapping part in the said one part program code, and produces | generates the said execution program newly, The any one of Claim 3-7 characterized by the above-mentioned. The program execution method described in 1. A part of program code including a main function as program code to be mapped to the virtual space before the execution of the program is started, and the part of the code as data to be mapped to the virtual space before the execution of the program is started Including storage area information for specifying a storage area in the auxiliary storage device in which the remaining program code excluding the program code is stored, and the remaining as data not mapped in the virtual space before the execution of the program is started A program generation apparatus comprising: a program generation unit that generates a file including the program code as the program.   A program generation program for causing a computer to function as the program generation device according to claim 11. Before execution of the execution program is started, a part of the program code of the execution program including a main function and a remaining program excluding the part of the program code of the execution program A storage area information for specifying a storage area in the auxiliary storage device in which the code is stored; and a pre-start mapping unit that maps the virtual space;
A program execution unit for executing the execution program;
When the program execution unit executes the program code included in the remaining program code that is not mapped to the virtual space by the pre-start mapping unit as the execution code, the pre-start mapping unit is mapped to the virtual space A program execution apparatus comprising: an executing mapping unit that maps the execution code to a virtual space using storage area information.   A program execution program for causing a computer to function as the program execution device according to claim 13. An entry point text that is a program code including a main function for copying the virtual space and mapping the program code of the second program to the virtual space, and an auxiliary for storing the program code of the second program A program generation method comprising: generating a first program including storage area information for specifying a storage area in a storage device. Entry point text that is a program code that includes a main function for the pre-start mapping unit to copy the virtual space and map the program code of the second program to the virtual space before the execution of the second program is started And mapping the first program to the virtual space, the storage area information for specifying the storage area in the auxiliary storage device in which the program code of the second program is stored,
By executing the main function of the first program, the program execution unit creates a second virtual space by copying the first virtual space for the first program,
The program execution unit maps the program code of the second program to the second virtual space using the storage area information,
The program execution method, wherein the program execution unit executes the program code of the second program using the second virtual space.

Images