JPH04340147A - Computer system - Google Patents

Abstract

PURPOSE:To prevent the generation of a useless idle area by binding segments at the time of loading a virtual storage, and when the number of physical segments necessary for loading is small, loading the physical segments to a virtual storage space. CONSTITUTION:A BIND statement 1-3 is a statement for binding logical segments to be inputted to a loader 1-4. A load module 1-1 is inputted to a loader 1-4 and includes the segment information 1-2 of respective logical segments included in it. Logical segments are loaded from the loader to the virtual storage space 1-9. A segment binding table 1-7 is updated by a segment registering means 1-5 and referred to by a bind loading means 1-6. A segment location table 1-8 is updated by the means 1-6 and stores the addresses of logical segments loaded to the space 1-9.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION The present invention is used for loading virtual memory in a computer system that protects virtual memory space using a segment method.

The present invention relates to a computer system that binds segments when loading a virtual memory space and can load a virtual memory space even if the number of physical segments required for loading is small.

0003

2. Description of the Related Art A virtual memory load of a computer system that protects virtual memory space using a conventional segment method will be described with reference to FIG. Hereinafter, in order to distinguish the segments in the load module and the segments in the virtual storage space, they will be referred to as logical segments and physical segments, respectively.

[0004] 10-1 and 10-3 are load modules containing logical segments to be loaded into virtual storage space. 10-2 is segment information created by a compiler or linked editing program for each logical segment, and includes storage protection attributes (writable, readable, executable, etc.) of the logical segment and size information of the logical segment. There is. 10-4 is a virtual storage space, which is divided into a finite number of fixed-length physical segments. These physical segments are numbered in a one-to-one correspondence with numbers, and these numbers are called segment numbers.

When a logical segment is loaded into a virtual storage space, one physical segment is allocated to one load segment and loaded into it. Since the size of the logical segment is less than or equal to the size of the physical segment,
The unloaded portion of the logical segment of the physical segment becomes free space. Therefore, when loading the logical segments of load module (1) 10-1 and load module (2) 10-3, the virtual storage space 10-4
physical segment.

Since there are a finite number of physical segments, if there are many logical segments to be loaded, it may become impossible to load all the logical segments into the virtual storage space. In this case, logical segments are bound using the bind function of a binder or linked editing program to reduce the number of logical segments for each load module. and,
Even with this method, if all logical segments could not be loaded into the virtual storage space, the program could not be executed.

[0007]

[Problems to be Solved by the Invention] In the conventional method, loading a small logical segment creates wasted free space in the physical segment, and when there are many logical segments to load, a large number of physical segments are required. As a result, the specifications of the number of physical segments are compressed, and in order to bind logical segments to reduce the number of logical segments, it is necessary to recreate the load module using the binder or the binding function of the linked editing program. First, the bind function of binders and linked editing programs can only bind logical segments in load module units, so there is a limit to the number of logical segments that can be reduced by binding among the logical segments to be loaded. There was a problem that the number of physical segments was reduced.

The present invention solves these problems by making it possible to load a plurality of logical segments into one physical segment, and even if the number of physical segments required for loading is small, it is possible to load into a virtual storage space. The purpose is to provide a computer system that can

[0009]

[Means for Solving the Problems] The present invention provides a segment binding method for storing bound segment names in a computer system that inputs segment information from a plurality of load modules and protects a virtual storage space using a segment method. Create a table and a segment location table that stores the locations of segments, enter a statement to bind the segments,
A segment registration means that acquires the segment name of the segment to be bound from the statement, registers and updates the segment name in the segment binding table, and binds the segment specified by the statement and loads it into the virtual storage space. The present invention is characterized by comprising a loader including bind load means for registering, referencing, and updating the load information in the segment location table.

0010

[Operation] Registers the logical segment in the load module to be bound in the segment binding table, binds the logical segment registered in the table to the logical segment already loaded in the physical segment in the virtual storage space, and then The address at which the logical segment will be loaded from now on is registered in the table, and the logical segment is loaded into the virtual storage space.

[0011] As a result, even if a small logical segment is loaded, unnecessary free space is not created in the physical segment, and even if there are many logical segments to be loaded, the number of physical segments required for loading is small, and the physical The specifications of the number of segments are less likely to be compressed. Also,
When binding logical segments to reduce the number of logical segments, there is no need to recreate the load module using the bind function of the binder or linked editing program, and it is possible to bind logical segments across multiple load modules. Binding can increase the number of physical segments required for loading.

0012

Embodiments Next, embodiments of the present invention will be explained based on the drawings. FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention.

In the embodiment of the present invention, segment information 1-2 is input from a plurality of load modules 1-1, and the bound segment name is input to a computer system that protects the virtual storage space 1-9 using the segment method. A segment bind table 1-7 that stores segment locations and a segment location table 1-8 that stores segment locations are provided, input a statement to bind a segment, obtain the segment name of the segment to be bound from that statement, and Segment registration means 1-5 registers and updates segment names in segment binding table 1-7, and virtual storage space 1 binds segments specified by statements.
-9, and a bind load means 1-6 for registering, referencing, and updating the load information in the segment location table 1-8.

BIND statements 1-3 are loader 1
This is a statement that binds the logical segment input to loader 1-4.
contains segment information 1-2 for each logical segment contained therein. Virtual storage space 1-
9, a logical segment is loaded by the loader. The segment binding table 1-7 is updated by the segment registration means 1-5, and the segment binding table 1-7 is updated by the segment registration means 1-5.
referenced by

The segment location table 1-8 is updated by the bind load means 1-6 and stores the address of the logical segment loaded into the virtual storage space 1-9.

FIG. 2 is a diagram illustrating the BIND statement in the embodiment of the present invention.

"//BIND" indicates a request to bind and load a logical segment, and describes the name of the logical segment to be bound as the segment name. “//B
IND” and the segment name are separated by “Δ” (blank). Between the segment names is “,”.
(comma) and separated from the next statement by “;”.

Next, the segment binding table will be explained. FIG. 5 is a diagram showing the structure of the segment binding table in the embodiment of the present invention.

The segment binding table 1-7 is created and updated by the segment registration means 1-5, and the binding table directory 5-1 and the binding table 5-7 are created and updated by the segment registration means 1-5.
2. Consists of segment information table 5-3.

Each entry in the bind table directory 5-1 is created for each logical segment specified by the BIND statement 1-3 shown in FIG. 1, and the segment name 5-4 of the logical segment specified by the BIND statement 1-3 is and a pointer 5-5 to the corresponding binding table of that logical segment.

The bind table 5-2 is created for each BIND statement 1-3, and each entry is created for each logical segment, and contains a segment name 5-6 and a pointer to the segment information table corresponding to the logical segment that has it. It consists of 5-7. At the time of loading, load segments having segment names stored in the segment binding table 1-7 are bound to each other.

Next, the processing of the segment registration means 1-5 will be explained. FIG. 6 is a diagram showing an example of creating a segment binding table in the embodiment of the present invention, and FIG. 7 is a flowchart showing the flow of processing by the segment registration means in the embodiment of the present invention. Here, in the case of this embodiment, it is assumed that the condition for logical segments to be bindable is that the attributes of the logical segments match.

BIND statement 6 in loader 1-4
Assume that a BIND statement 6-1 including -2 and 6-3 and a load module are input. Loader 1-4
detects the BIND statement and activates the segment registration means 1-5. Assume that the BIND statement 6-2 is first detected. At this time, the segment registration means 1-5 is activated, and the BIND statement 6-2
Segment attributes are obtained from the segment information table of all logical segments having the segment names described therein (step 7-1).

Next, in order to check whether the specified load segment can be bound, it is checked whether the attributes match (step 7-2).

[0025] If they do not match, binding cannot be performed, so invalidate this BIND statement 6-2 and
Error processing is performed (step 7-8), and the processing is terminated. If all logical segment attributes match,
Bind table directories are created and expanded by the number of logical segments to be registered (step 7-3). Thereafter, the segment name written in the BIND statement 6-2 is set in the segment name storage area (step 7-4). Segments A, B, which are logical segments,
If the segment names of C are “A”, “B”, and “C”,
Segment names 5-4 shown in FIG. 5 are registered as A, B, and C.

Next, an area for creating a bind table corresponding to the BIND statement being processed is secured (step 7-5). Then, the address of the created bind table is set in the storage area of the pointer to the corresponding bind table in the logical segment of the bind table directory (step 7-6). In this case, the address of the bind table 1 is set as shown at 6-5 in FIG. Next, the segment name of each logical segment corresponding to this bind table and the address of the segment information table are set in the created bind table (step 7-7), and the process ends. In this case, the results are as shown in 6-6 and 6-7 shown in FIG.

When the loader detects the BIND statement 6-3, this means is activated again and the same process is repeated. In this case, when all BIND statements are processed, a segment bind table as shown in FIG. 6 is created.

Next, the segment location table will be explained. FIG. 3 is a diagram showing the structure of the segment location table in the embodiment of the present invention. Segment location table 1-8 is virtual storage space 1-8.
Segment name 3-1 of logical segment loaded into 9
, the area where the segment number 3-2 of the physical segment loaded with the logical segment is stored, and the offset from the beginning of the physical segment loaded with the logical segment to the beginning of the loaded logical segment ( (byte unit) 3-3 is stored,
An area in which segment information 3-4 is stored, and the contents of the segment information table described above are stored therein.

Next, the bind load means 1-6 will be explained with reference to FIGS. 4, 6, 8 and 9. Figure 4
is a diagram showing an example of creating a segment location table in the embodiment of the present invention, FIG. 8 is a flowchart showing the flow of processing of the bind load means in the embodiment of the present invention, and FIG. 9 is a diagram showing the virtual storage space after segment loading in the embodiment of the present invention. FIG.

Assume that a BIND statement 6-1 and load modules 9-1 and 9-2 are input to the loader 1-4, and a logical segment is loaded into the virtual storage space 9-3. 9-4 in FIG. 9 is segment information allocated to each physical segment.

In this case, a segment binding table as shown in FIG. 6 is created. Assume that a load request for segment F (hereinafter referred to as F; the same applies to segments A, . . . ), which is a logical segment, arrives first (step 8-1). At this time, it is checked whether the segment name "F" of F is registered in the bind table directory (step 8-2). If "F" is not registered, a new segment number and physical segment are assigned (step 8-7), and the segment location table is updated (step 8-8).

First, the segment name "F", then the segment number (#3 shown in FIG. 9 in this case), the offset from the beginning (0 in this case), and segment information are set, and then the segment number 4 shown in FIG. -1. Segment information can be obtained from the segment information table. Then, as shown at 9-5 in FIG. 9, F is loaded from the beginning of the physical segment "#3" (step 8-9), and the process ends.

Next, assume that a load request for A has arrived (step 8-1). It is checked whether the segment name "A" of A is registered in the bind table directory (step 8-2). In this case, since it is registered as shown in 6-4 of FIG. 6, the bind table (1) corresponding to A is obtained from 6-5 (step 8-3).

Next, it is checked whether the segment name of the logical segment whose segment name is stored in the bind table (1) is stored in the segment location table 1-8 (step 8-4). Assuming that nothing but F has been loaded into virtual storage space 1-9, the corresponding segment name has not been found, so a new segment number (in this case #0) and physical segment are assigned (step 8-7). . Then, the segment location table 1-8 is updated as shown in 4-2 in FIG. 4 (step 8-8), and A is loaded as shown in 9-6 in FIG. 9 (step 8-9).

Next, suppose that a load request for B comes (step 8-1). At this time, it is checked whether the segment name "B" of B is registered in the bind table directory (step 8-2). If it is registered as shown in 6-4 in FIG. 6, the bind table (1) corresponding to B is obtained from 6-5 in the same figure (step 8-3).

Next, it is checked whether the segment name of the logical segment whose segment name is stored in the bind table (1) is stored in the segment location table 1-8 (step 8-4). In this case, if the segment name "A" is found, the offset from the beginning of the physical segment of A (in this case, 0 as shown in Figure 4) and the segment size in the segment information (in this case, 300 as shown in Figure 4) ) are obtained from the segment location table 1-8, and by adding them, the offset to immediately after A is determined (step 8-5).

[0037] After that, if B is loaded after A,
Check whether B can fit into the loaded physical segment of A (step 8-6). This can be checked by adding the size of B to the offset obtained earlier and checking whether it is larger or smaller than the physical segment size. If it is large, B cannot fit in it, but if it is small, it can fit in it and can be loaded into that physical segment. In this case, if it is assumed that B can fit, the segment location table 1-8 is updated (step 8-8). The loaded segment number of B is "#0", which is the same as that of A, and the offset from the beginning of the physical segment is set to "300", which is the offset immediately after A obtained in step 8-5. Then, as shown at 9-7 in FIG. 9, B is loaded (step 8-9), and the process ends.

Next, suppose that a load request for C comes. At this time, the same processing as B is performed, but if C cannot fit into the loaded physical segments of A and B (step 8-6), a new segment number (#1 in this case) and physical Assign segments (step 8-7)
, updates the segment location table 1-8 (step 8-8), and loads C as shown at 9-8 in FIG. 9 (step 8-9).

When all logical segment load requests are processed as described above, the segment location table will become as shown in FIG. 4, and the virtual storage space will become as shown in FIG. 9.

[0040]

[Effects of the Invention] As explained above, according to the present invention, even if a small logical segment is loaded, unnecessary free space is not created in a physical segment, and even if there are a large number of logical segments to be loaded, it is necessary for loading. When binding logical segments to reduce the number of logical segments, it is possible to reduce the number of logical segments by using the binding function of a binder or linked editing program. There is no need to recreate the load module; for example, when dynamically linking, logical segments can be bound across multiple load modules, and binding can increase the number of physical segments required for loading. There is.

[Brief explanation of the drawing]

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

FIG. 2 is a diagram illustrating a BIND statement in the embodiment of the present invention.

FIG. 3 is a diagram showing the configuration of a segment location table in the embodiment of the present invention.

FIG. 4 is a diagram showing an example of creating a segment location table in the embodiment of the present invention.

FIG. 5 is a diagram showing the configuration of a segment binding table in the embodiment of the present invention.

FIG. 6 is a diagram showing an example of creating a segment binding table in the embodiment of the present invention.

FIG. 7 is a flowchart showing the processing flow of the segment registration means in the embodiment of the present invention.

FIG. 8 is a flowchart showing the processing flow of the bind load means in the embodiment of the present invention.

FIG. 9 is a diagram showing the layout of virtual storage space after segment loading in the embodiment of this invention.

FIG. 10 is a diagram showing a layout when segments are loaded into a virtual storage space in a conventional example.

[Explanation of symbols]

1-1 Load module 1-2 Segment information 1-3 BIND statement 1-4 Loader 1-5 Segment registration means 1-6 Bind load means 1-7 Segment bind table 1-8 Segment location table 1-9 Virtual storage space

Claims (1)

[Claims] Claim 1: In a computer system that inputs segment information from a plurality of load modules and protects virtual storage space using a segment method, there is provided a segment binding table that stores bound segment names and stores the location of the segments. segment registration means for inputting a statement for binding a segment, acquiring a segment name of a segment to be bound from the statement, and registering and updating the segment name in the segment binding table; The present invention is characterized by comprising a loader including a bind load means for binding and loading a segment specified by a statement into the virtual storage space, and registering, referencing, and updating the load information in the segment location table. A computer system that