JPH0844570A - System and method for program execution - Google Patents

Abstract

PURPOSE:To shorten the time required for the start of program execution or the program execution time by reducing the frequency in access to an external storage device and saving the labor or time of address resolution processing at the time of loading the program from the external storage device to a main memory. CONSTITUTION:A program execution control part 11 presented by an operating system preliminarily reads plural load modules 31 constituting the program from an external storage device 3 into a load image generation area 21 in a main memory 2 and performs the address resolution processing of functions and variables, which are referred to among load modules, and writes the result in the load image generation area 21. The load image of the program generated on the load image generation area 21 in this manner is preserved in a load image storage area 32 of the external storage device 3. When the program is executed hereafter, the program execution control part 11 reads the load image preserved in the external storage device 3 into the main memory 2 and starts execution of the program.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program execution system for executing a program composed of a plurality of load modules.

[0002]

2. Description of the Related Art When a computer system executes a program, it is necessary to load a program module stored in an external storage device into a main memory that can be directly accessed by a processor before executing the program. The program is
It is composed of one or a plurality of load modules, which must be sequentially loaded into the main memory. Here, loading means reading the program into the memory area of the process that executes the program.

Conventionally, when a program is composed of a plurality of load modules, the program is executed by the following procedure. First, load the load module that is first started in the program. This module holds the load module information needed by the program and then uses this information to load the remaining load modules. Once all the required load modules have been loaded, the process of resolving the addresses of functions and variables that are mutually referenced between the load modules is performed.

However, if all the load modules are read from the external storage device, the access to the external storage device increases, so that it takes time to load. Also,
If function and variable address resolution processing is performed after loading the load module, it takes time from loading to program execution.

On the other hand, there is conventionally known a text sharing system in which the number of accesses to an external storage device is reduced and the data can be loaded at high speed. In this text sharing method, when multiple programs use the same load module, the text part (operation instruction part) of the contents of the load module that has been read once is shared by the processes, and The number of readings from the storage device is reduced.

Further, conventionally, there is a runtime address resolution method that shortens the time from loading to program execution by minimizing the address resolution processing. In this execution address resolution method, after loading the load module, only the address resolution processing of variables is performed, and the address resolution processing of functions is performed as needed during program execution, so that the time from loading to program execution is reduced. To shorten it.

[0007]

In the above-mentioned text sharing method, the program does not perform update processing on the text portion but only refers to it. Therefore, an external storage device for the text portion is used. The number of accesses to can be reduced. However, in the contents of the load module, the data part that the program updates, that is, the part that has numerical values and character strings used when the program runs cannot be shared between processes like this. . As a result, even when the text sharing method is used, access to the external storage device occurs for each load module in order to read the data part.

In the run-time address resolution method, the time from loading to execution of the program is shortened, but since the address resolution processing is performed after the program has resolved the execution, the program execution time becomes long.

As described above, the conventional program execution method has a problem that it takes time to load the external storage device because the external storage device is accessed a number of times proportional to the number of load modules. In addition, since the address resolution processing is performed after the load module is loaded, there is a problem that the time until the program is executed and the time for executing the program become long.

An object of the present invention is to solve the conventional problems as described above, reduce the number of accesses to an external storage device at the time of program loading, and execute address resolution processing before the program loading to execute the program. An object of the present invention is to provide a program execution system capable of reducing the time required to execute the program and the execution time of the program.

[0011]

In order to achieve the above object, the program execution system of the present invention is configured to load into a memory of a plurality of load modules constituting a program,
Load image creating means for creating a load image necessary for program execution on the memory by performing address resolution processing of the functions and variables mutually referenced between the load modules, and a load created on the memory A load image saving means for saving the image in a non-volatile storage device; and a load image reading means for reading the load image saved in the storage device into a memory when the program is executed. To do.

[0012]

According to the present invention, the load of a plurality of load modules and the address resolution processing of the functions and variables that are mutually referenced between the load modules are performed in advance before the program is executed, and the resulting load on the memory is executed. Save the image in non-volatile storage. When executing the program thereafter, instead of loading the load module, the saved load image is read into the memory.

As a result, it is possible to reduce the number of accesses to the external storage device when executing the program. In addition, address resolution processing is not required when executing a program or during program execution. As a result, it is possible to shorten the time until the program is executed and the program execution time.

[0014]

Embodiments of the present invention will now be described in detail with reference to the drawings.

FIG. 1 is an overall configuration diagram of a computer system showing an embodiment of the present invention.

As shown in FIG. 1, a system is constituted by a processor 1, a memory 3 that provides a main memory of the processor, and a non-volatile external storage device 3 that stores programs.

The outline of the operation performed when the program is executed is as follows.

Before executing the program, the processor 1 reads the load module of the program from the external storage device 3 and loads it into the memory 2 as a preparatory operation. When all the load modules have been loaded, the processor 1 performs address resolution processing of functions and variables that are mutually referenced among the load modules. Next, the processor 1 stores in the external storage device 3 the information created on the memory 2 by the above preparatory operation.

After that, when executing the program, the processor 1 reads the above information stored in the external storage device 3 into the memory 2 to reduce the number of accesses to the external storage device 3 and to eliminate the address resolution processing. And

The details will be described below.

FIG. 2 is a functional block diagram of a portion for controlling program execution in this embodiment.

In FIG. 2, the program execution control unit 11
Performs one of the operations outlined above and is a function provided in the operating system of the processor 1. By the function of the program execution control unit 11, a load image creation area 21 into which a load module is read in the preparatory operation, a process area 22 used when the program is executed, and the like are secured in the memory 2.
In the external storage device 3, a plurality of load modules 31 forming a program are stored in advance, and the function of the program execution control unit 11 secures a load image storage area 32 in which a load image is stored.

FIG. 3 shows the program execution control unit 11 of FIG.
Shows the flow of operations for creating a load image of a program prior to execution of the program.

The program execution control unit 11 first reads the load module to be activated first among the load modules 31 into the load image creation area 21 of the memory 2 (S1). Next, from the read load module, a list of file names of all load modules required for the program is taken out (S2). Then, according to this list, the remaining load modules are read into the load image creation area 21 (S4).

If all the load modules of the program have been read (S3), then the address resolution processing of the functions and variables mutually referenced between the load modules is performed (S5), and the result is the load image of the memory 2. Write in the creation area 21. In this way, all the information (load image) necessary for executing the program is created in the load image creating area 21, and then the load image in the load image creating area 21 is loaded into the external storage device 3. The data is stored in the storage area 32 (S6).

When there are a plurality of programs, if the capacity of the external storage device 3 permits,
It is desirable to create the load image in advance as described above and store it in the load image creating area 32 of the external storage device 3.

FIG. 4 shows a flow of operations when the program execution control unit 11 executes a program.

Upon receiving the program execution request, the program execution control unit 11 retrieves the load image corresponding to the program from the load image storage area 32 in the external storage device 3 (S11), and retrieves it from the process area 22.
Read in (S12).

As described above, in this embodiment, the load of a plurality of load modules and the address resolution processing of the functions and variables mutually referenced between the load modules are performed in advance before executing the program, and the result is obtained. The information stored in the memory is stored in the external storage device. When the program is executed, the load module is not loaded, but the saved information is read into the memory to reduce the number of accesses to the external storage device when the program is executed and to execute the program. Address resolution processing during program execution is unnecessary. As a result, it is possible to shorten the time until the program is executed and the program execution time.

Although the present invention has been specifically described based on the embodiments, it is needless to say that the present invention is not limited to the above embodiments and various modifications can be made without departing from the spirit of the invention. Yes.

[0031]

As described above, according to the present invention,
The number of accesses to the external storage device when executing the program can be reduced, and the address resolution processing when executing the program or during execution of the program becomes unnecessary, and the time until the program is executed and the program execution time can be reduced. It can be shortened.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a computer system to which a program execution method of the present invention is applied.

FIG. 2 is a functional block diagram of a program execution control unit showing an embodiment of the present invention.

FIG. 3 is an operation flowchart performed by a program execution control unit of the present invention before executing a program.

FIG. 4 is a flowchart of an operation performed by a program execution control unit of the present invention when executing a program.

[Explanation of symbols]

 1 Processor 2 Memory 3 External Storage Device 11 Program Execution Control Unit 21 Load Image Creation Area 22 Process Area 31 Load Module 32 Load Image Storage Area

Claims (2)

[Claims] 1. A program execution system for executing a program composed of a plurality of load modules, comprising: loading into a memory of a load module which constitutes the program; and address resolution processing of a function and a variable which are mutually referenced between the load modules. By performing a load image creating means for creating a load image required for executing the program on the memory, and a load image created on the memory by the load image creating means to a non-volatile storage device. A program execution system comprising: a load image storage unit that stores the load image; and a load image reading unit that loads the load image in the storage device onto the memory when the program is executed. 2. A program execution method for executing a program composed of a plurality of load modules, comprising: loading into a memory of a load module that constitutes the program; and address resolution processing of a function and a variable which are mutually referenced between the load modules. By executing the load image creating process for creating the load image necessary for executing the program on the memory, and the load image created on the memory by the load image creating process to a non-volatile storage device. A program execution system comprising: a load image saving process for saving; and a load image reading means for reading a load image in the storage device onto the memory when executing the program.