JPS63121929A - Stack processing system - Google Patents

Abstract

PURPOSE:To evade abnormal termination of a program due to a lack of capacity of a stack memory by reserving local variables used in a program in a fixed place of the program and saving values of local variables on a stack memory at the time of calling a subprogram and restoring them at the time of return to a main program. CONSTITUTION:A stack management part 12 stores values of prescribed variables in a variable save area 15 on a stack memory 14 and stores return information 16 on the stack memory 14 and transfers the control to a subprogram 13 thereafter. When execution of the subprogram 13 is completed, the stack management part 12 takes out return information 16 from the stack memory 14 and uses values saved in the variable value save area 15 to restore values of variables in a variable area 11 of a main program 10 to states before call of the subprogram 13 and transfers the control to the main program 10 thereafter.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to a program language processing method and a program execution method for a computer system, and in particular to an efficient stack memory used when recursively calling subprograms. This invention relates to a stack processing method suitable for use.

[Conventional technology]

The conventional recursive calling method for subprograms is
rth), translated by Katayama, "Algorithm Child Data Structure - Program", Japan Combita Association, pp. 37Ili - 381
Pages, “Basic Methods of Computers” by Ishii, Kyoritsu Publishing, pp. 27-2
As described on page 9, this is done by allocating local variables used within the subprogram on the stack memory. Therefore, it is necessary to make this stack @ area resident on a high-speed main storage device until the execution of the subprogram is completed. This will be explained with reference to FIG.

When the main program 21 shown in FIG. 3 starts, first the variable area (
is secured on the stack memory 30 (step 22),
When the main program 21 is executed, the variable area (1) on the stack memory 30 is referred to.

When calling the subprogram 24 from the main program 21, return information necessary for returning from the subprogram 24 to the main program 21 is stored on the stack memory 50, and then the subprogram 24 is jumped.

At the beginning of the called subprogram 24, similarly to the main program 21, a variable area (2) for storing local variables used in the subprogram 24 is secured on the stack memory 30 (step 25). And subprogram 2
4, the variable area (2) on the stack memory 30 is
), while the variable area (1) is also directly referenced for variables in the variable area (1) passed as arguments from the main program 21. When the execution of the program 24 ends, the variable area (2) on the stack memory 50 is released in step 26, and the variable area (2) on the stack memory 50 is released in step 27.
Return to the main program 21 using the return information above 0. At the end of execution of the main program 21, the variable area on the stack memory 30 is released in step 23.

[Problem that the invention seeks to solve]

In the conventional method described above, in order to enable direct reference to the variable area for the main program 21 from the subprogram 24, this stack area is made resident on the main memory,
Always available for reference.

In an actual program, a subprogram may call another subprogram or itself recursively. If you call yourself recursively in this way, that is, if you call subprogram 24 or subprogram 24, the second time it is called, a separate variable area will be allocated on the stack memory again. . If such subprogram calls are made multiple times, the stack memory will be reduced to several tens of digits.
0 requires a byte to several megabytes or more,
A problem occurs in which the program terminates abnormally due to insufficient stack space.

SUMMARY OF THE INVENTION An object of the present invention is to provide a stack processing method that makes effective use of a stack memory provided in a main storage device and avoids abnormal termination of a program due to insufficient capacity of the stack memory.

[Means for solving problems]

The above purpose is not to dynamically allocate the local variables used within the program on the stack memory, but to allocate them in a fixed location within the program, and when calling the subprogram, the local variable values are stored on the stack memory. This is accomplished by saving the value and restoring its value when returning to the main program.

[Effect]

The values saved on the stack memory are not referenced until control is returned to the main program.

As the axis program calls further subprograms and the nesting of calls becomes deeper, a large amount of stack memory is required. However, in this case, the values stored at the beginning of the stack memory do not need to remain resident in the main memory until all subsequently stored values are retrieved, so the values stored at the beginning of the stack memory do not need to remain resident in the main memory, so Even if it is stored in the auxiliary storage device, there is little effect on execution efficiency. Also,
In recent years, access to main memory has been localized, and virtual memory has been adopted, since only the fixedly allocated variable area is referenced without referring to the data in a large amount of stack memory. In computers, the probability of ゝ- shift fold decreases.

〔Example〕

An embodiment of the present invention will be described below with reference to FIGS. 1 and 2.

FIG. 1 is an explanatory diagram of a stack processing method according to an embodiment of the present invention. The stack memory 14 shown in FIG. 1 is a first-in, last-out type memory provided on a main storage device (not shown) of a computer system.

That is, when information is taken out from the stack memory 14, it is taken out in order from the last stored information among the stored information. In this embodiment, main program 1
0 is provided with a variable area 11 for fixedly securing local variables newly used in the main program 1°, and a similar variable area 17 is also provided in the subprogram 13. In this way, variable areas 11 and 17 are set to program 1.
Instead of providing it in 0, 1'5, it may be provided in another location specified by the system.

When the subprogram 13 is called from the main program 10.

The stack management unit 12 stores the value of a predetermined variable in the variable save area 15 on the stack memory 30, further stores return information 16 on the stack memory 14, and then transfers control to the subprogram 16. When executing the subprogram 13, refer to the variable area 17 reserved for the subprogram 15,
In addition, variables passed as arguments from the main program 10 are not stored in the stack memory 14, but in the variable area 11 within the main program 10, and further, if the main program is called from another program, the variables for that main program are stored. Refer to variable area directly. When the execution of the subprogram 13 is completed, the stack management unit 12 takes out the return information 16 from the stack memory 14, saves it to the variable value save area 15, and uses the value to save the variables in the variable area 11 of the main program 10. The value is restored to the state before calling the subprogram 13, and then control is transferred to the main program 10.

As described above, according to this embodiment, the stack memory 14 is not referenced while the subprogram 13 is being executed, so there is no need to make the stack memory 14 resident in the main memory. In addition, the variable area referenced during execution of programs 10 and 13 is the predetermined area 1.
Since there are only 1 and 17, references to the main storage device are localized, and in a computer system that employs a virtual storage method, the probability of page faults is reduced and processing efficiency can be improved. Furthermore, since the information stored in the stack memory 14 is retrieved in order from the information input last, the data input earlier can be stored in an auxiliary storage device such as a disk file.

FIG. 2 is a flowchart showing a procedure for avoiding stack memory overflow by using an auxiliary storage device. As described above, the stack management unit 12 saves the local variable values in the variable area in the main program 10 onto the stack memory 14.
), it is checked whether there is enough free space on the stack memory 14 to save the above value (step 1).

- If it is determined that there is sufficient space in step 2A, jump to step 4 and save the variable value to the stack memory 14Il.
? : Evacuate. If it is determined in step 2 that there is not enough free space, proceed to step 3 and use the stack memory 14.
The oldest information is written out to the disk file in order to free up space in the stack memory 14, and then the process proceeds to step 4.

When returning to the main program 10, as shown in FIG. 2(b), it is checked whether there is saved data in the stack memory 14 in the main storage device (step 5) o If this saved data exists If it is determined in step 6, the process jumps to step 8 and the variable value is restored from the stack memory 14 to the program 10. If it is determined that the saved data is not in the stack memory 14, the corresponding saved data has been written to the disk file, so the saved data is read from the disk file to the stack memory 14 in step 7, and then Proceed to step 8.

In this way, it becomes possible to use a large-capacity auxiliary storage device such as the above-mentioned disk, and the stack memory becomes over 70-
It is possible to avoid abnormal termination caused by program execution, and to reduce the main memory capacity required for program execution.

〔Effect of the invention〕

According to the present invention, the stack memory used for dynamically allocating a storage area for variables and storing information for returning from a subprogram to the main program can be fixed without referring to the area in the stack. Since a program can be executed by referencing only the variable area, it is possible to localize access to the main memory, which has the effect of reducing the probability of page faults in virtual memory type computers. Furthermore, it becomes possible to use a large-capacity auxiliary storage device as part of the stack, which has the effect of reducing the main storage capacity t that must be allocated to the stack required for program execution. In addition, an abnormal termination due to stack overflow 70- occurs and K<<, which eliminates the need for program developers and users to consider the stack capacity.

[Brief explanation of the drawing]

Fig. 1 is an explanatory diagram of a stack processing method according to an embodiment of the present invention, Fig. 2 (α) t (b) is a 70-chart when using an auxiliary storage device, and Fig. 3 is a conventional stack processing FIG. 2 is an explanatory diagram of the method. 10...Main program, 11, 17...Variable area, 12...Stack management section, 13...Subprogram, 14...Stack memory. 7・'-~ Patent Attorney Katsutoshi Ogawa No. 1 Figure 2 (O-) (b) Figure 3

Claims (1)

[Claims] 1. In a computer system that includes a stack memory in the main storage for recursive calling of a program, a variable area is provided in a location other than the stack memory within the program, and when calling a subprogram, the main program is A stack processing method characterized in that local variable values and return information to the main program are stored in the stack memory, and data in the stack memory is not referenced while the subprogram is being executed. 2. The data stored in the stack memory is moved from the oldest data to an auxiliary storage device when there is no more space in the stack memory, and is returned from the auxiliary storage device to the stack memory as necessary. A stack processing method according to claim 1.