JPH0359727A - Saving/restoring system in microprocessor - Google Patents

Abstract

PURPOSE:To remove the overhead of a microprocessor by restoring only an internal register in which an updating flag is set up at the time of ending interruption processing. CONSTITUTION:When the execution of an interrupted program is ended,the restoration of internal registers is started. Since the data of respective registers Rdn-1 to Rd3, Rsm to Rs1 are sequentially stored in a stack, the data area read out by push-up based upon an instruction from a stack pointer. When the updating flag of the internal register to be restored is '0' like the Rs3 at the time of referring it, only the value of the stack pointer is updated without reading out data from the stack because rewriting is not executed at the time of executing the interrupted program to access the succeeding data Rs2. Consequently, the overhead of the microprocessor can be removed.

Description

[Detailed Description of the Invention] [Summary] The device includes a plurality of internal registers that each store information such as state information and data, and saves the information stored in these internal registers to a stack when an interrupt occurs. Regarding the saving and restoring method for microprocessors, the purpose of this method is to restore only the registers and state information actually used during the execution of the interrupted program, thereby eliminating the overhead of the microprocessor. An update flag is provided for each to indicate that rewriting has been performed, and this update flag is also stored in the stack corresponding to each internal register, and when an interrupt occurs, it is stored in the status register. After saving the information stored in the data register specified by the program and the corresponding update flags to the stack, the update flags of these internal registers are reset, and when the interrupt processing is finished, the update flags are reset. The configuration is configured so that only the internal registers that are set are restored.

[Industrial application field]

It has multiple internal registers that each store information such as state information and data, and when an interrupt occurs, the information stored in these internal registers is saved to the address indicated by the stack pointer on the stack. Regarding microprocessors.

[Conventional technology]

If an interrupt from a high-priority process, exception handling, or subroutine call occurs while the processor is executing a process, the process is interrupted and the processor state information and instructions and data stored in internal registers are (In this specification, instructions, data, etc. are simply referred to as data) are saved to a save memory such as a stack.

In order to perform this saving process quickly and easily, as for the data stored in internal registers as described above, only the data stored in the internal registers used when executing the relevant interrupt process are saved. That's what I do.

When this interrupt processing is completed, the saved data is restored from the saved memory such as the stack to the original internal register, and the status information is restored by executing a return instruction, and the processing is restarted.

FIG. 4 is a flowchart of such a conventional save/restore method. When an interrupt occurs during the execution of program A, state information such as the program counter, status register, or internal flag of the node/ware is saved in step B1. is saved to the save memory.

In the next step B2, the contents of the register designated for use by the interrupted program B are saved to the save memory, and then in step B3, the interrupted program B is processed.

When the processing of program B is completed, the contents of the registers saved in step B2 are restored to the original registers in step B4, and the status information saved in step B1 is transferred to the step B1 by executing a return instruction in step B5. After restoring at B6, processing of the program interrupted by the interrupt is resumed.

If another interrupt by program C occurs during the execution of program B in step B3, this program B
interrupting the processing of and executing the program C by processing steps C1 to C6 similar to steps B1 to B6 above,
After that, the program returns to block B3 and resumes processing of program B.

[Problem to be solved by the invention]

However, the internal registers specified for use by the interrupting program include all internal registers that may be used when this program is executed, so depending on the contents of the interrupt processing, Not all internal registers are necessarily used for processing, and internal registers that are not used retain their contents before the interrupt.

However, in the above-mentioned conventional technology, the overhead of the microprocessor is incurred because the internal registers that maintain the contents before the interrupt are also restored.

An object of the present invention is to eliminate microprocessor overhead by restoring only the registers and state information actually used during execution of the interrupted program.

[Means to solve the problem]

A plurality of internal registers RS+, ---Rs□, Rd+, each storing information such as status information and data.
In a microprocessor equipped with Rd, , and configured to save the information stored in these internal registers to the address indicated by the stack pointer SP of stack B when an interrupt occurs, the internal register Rs , Rd is provided with an update flag f indicating that rewriting has been performed, and the stack B is configured so that this update flag can be stored correspondingly in each internal register, and when an interrupt occurs, the state is When a specified interrupt occurs in the internal registers that store information and the interrupting program, the status information and the corresponding update flags are saved to the stack, and then the update flags of these internal registers are reset. When the interrupt processing is finished, the stack address is sequentially indicated by the stack pointer, and for internal registers whose update flags are set, the internal registers are restored using the information read from the stack and the update flags, and the update flags are used to restore the internal registers. Therefore, for this internal register, only the value of the stack pointer is updated without reading from the stack.

did.

[For production]

FIG. 1 is a diagram illustrating the principle of the present invention, in which a microprocessor has a status register that stores status information indicating its status, and data that stores data such as instructions and numerical values. Register R
d l, Rd 2. It is provided with an internal register including Rdh, and each of these internal registers Rs and Rd is provided with an update flag f indicating that rewriting has been performed.

When the processor receives an interrupt from a process with a higher priority than this process, an exception process, a subroutine call, etc. while executing a process, internal registers Rsl and RS2゜Rs that store state information, and this interrupt An internal register, for example, Rd, that stores data specified by the program.

The data stored in Rd I, . In FIG. 1, registers to be saved are indicated by hatching upward to the right.

This saving can be done, for example, using internal registers RSI, Rs
2゜RS, , Rds, ---Rd+, -1 are pushed down onto the stack in the order of
,,,,,, Rd31 R5l11+”””””R
The respective data are stocked in the order of S21 Rs l .

When this save is completed, all internal registers Rs, Rd
The update flag of is reset to "0", for example.

After that, the interrupted program is executed, but the update flags of the internal registers Rs and Rd that were rewritten during this process are set to 1'', for example, and the flags of the internal registers that were not rewritten are set to `` The update flags of each internal register in FIG. 1 are maintained at 0'' by the execution of this interrupted program. is shown as having been rewritten.

When the execution power of the interrupted program reaches 4%, the internal registers are restored. That is, the stack includes internal registers Rdh-,, Rd31, RS11 from above.
Each data is stored in the order of RS21 RSl, so it is read by pushing up according to the stack pointer.At this time, the update flag of the internal register to be restored is referred to and this data is stored. For example, if the update flag is 0'' like in R83, no rewriting is performed when the interrupted program is executed, so there is no need to restore it, and therefore only the value of the stack pointer is read without reading from the stack. is updated to access the next data RS2.

In Figure 1, the downward-sloping hunting in the internal register that was restored because it was rewritten when the interrupted program was executed and the update flag was set to "1" is replaced by the above-mentioned upward-rightward hatching. The internal registers RS, , Rs3 . For R3II + Rd n-1, only this upward-sloping hatching is applied, indicating that no restoration is performed.

As described above, in the present invention, since restoration is not performed to internal registers that have not been rewritten, the overhead of the microprocessor can be eliminated.

〔Example〕

FIG. 2 shows an embodiment of the present invention, and the operation of this embodiment will be explained according to the flowchart in FIG. Note that, for convenience of explanation, flowchart F in FIG. 3 is shown for a case corresponding to one interrupt.

As shown in FIG. 2, the microprocessor of this embodiment includes internal registers including a status register S for storing status information from an arithmetic/control circuit C and a data register R for storing data such as instructions and numerical values used for processing; It is equipped with a stack pointer SP indicating the latest storage address of the save stack B for saving the information stored in these internal registers S and H, and as described above, the information stored in the internal registers S and R is A save stack B for saving information stored in the microprocessor is connected to the data bus DB of this microprocessor. Note that the above internal register S,
R and stack B are written/written by arithmetic/control unit C.
Needless to say, this is something that will be published one after another.

For convenience of explanation, the address of the stack above is the latest storage address, that is, in FIG. 2, the address at the top of stack B is assumed to be 1 and increases downward by 1, and this address is used as the subscript of "B" The codes of the internal registers saved are added in parentheses.

In FIG. 3, processing X of step
is executed, and in step ■, the end of this process is identified, and if it is not finished, it is determined in step ■ whether or not there is an interrupt request, and if there is no interrupt, the process returns to step ■ and processing X is continued. , When there is an interrupt request for processing Z, the saving operation of internal registers S and R is started from step (3).

This saving operation is performed by saving the data in the status register S while shuffling down the stack B in step ■, and in the following step ■, the data in the status register S is saved by
Similarly, the data stored in the data registers R2 to Rfi-1 in the range of is saved to the stack B. Therefore, in this stack B, as shown in parentheses in FIG.
．． A~Bs0, and the upper address Bd,...~B
1, data R5 to Rfi-1 are stored together with the flag f, respectively.

In the next step (2), the flags of all the internal registers that have been saved are reset to 0°', for example, and the execution of the interrupted process Z is started in the next step (2).

Note that the second data register, which is not used for this process Z,
In the illustrated example, there is no need to save RRn.

If an internal register is written while executing this process Z, the update flag of the internal register is set to “1”.
The execution state is determined in step (3), and when the process is completed, the process moves to the next step Q and subsequent steps to restore the internal registers.

In step @, the value of the stack pointer SP is transferred to the stack B
Set to 1, which is the latest storage address of
Refers to the update flag of the internal register corresponding to the data stored in the stack specified by this value, Rh-1 in the illustrated example, and sets this update flag to "1" in step ○.
Determine whether or not.

As shown in FIG. 2, if the update flag of this internal register R9-1 is "P1", the process moves from step ○ to step 0, and in step 2, data is read from B on the stack and this data is used to fill the internal register Rh. -1 is restored, and then the process moves to step 0. If the update flag of this internal register is "0", the data in this internal register has not been rewritten by the execution of process Z, and it is necessary to restore it. Since there is no one, we move directly from step 0 to step 0 and add 1 to the value of the stack pointer.

In the next step 0, in order to identify whether or not the value of this stack pointer is within the data storage area Bd, it is compared with the stack address d□A where the first saved data is stored, and the value of the stack pointer is The value p is this d□8
If the stack pointer value p is larger than dmai, the restoration of data registers R1 to R is completed and the state is stored in the state information register S. Since it will enter area Bs, it moves to the next step [phase] and waits for the return command to arrive.

When this return instruction arrives, in step 0, the value of the stack pointer is set to the minimum address Sm1 of the state information storage area.
n, and perform the same processing as steps 0 to ■ until step ■ to obtain stack addresses B5m1h to Bsma.
The register that was rewritten in process Z in the status information register is restored using the status information stored in +<, and when this is completed, the status returns to the state before the interrupt was generated, so return to step 1 and process. Resume execution of X.

〔Effect of the invention〕

According to the present invention, there is no need to perform restoration processing for internal registers that were not rewritten during the execution of the interrupted processing, so a special effect is achieved in that the overhead of the microprocessor associated with this processing can be eliminated. achieved.

[Brief explanation of drawings]

Fig. 1 is a block diagram showing the principle of the present invention, Fig. 2 is a block diagram showing an embodiment of the invention, Fig. 3 is a flowchart for explaining the operation of the embodiment of Fig. 2, and Fig. 4 is a block diagram showing the embodiment of the invention. 2 is a flowchart of a conventional save/restore method.

Claims (1)

[Claims] A plurality of internal registers (Rs_l, ......R
s_m, Rd_1, ......Rd_n), and when an interrupt occurs, the information stored in these internal registers is indicated by the stack pointer (SP) of the stack (B). In a microprocessor that saves data to an address, an update flag (f) is provided to each of the internal registers (Rs, Rd) to indicate that rewriting has been performed, and the stack (B) also uses this update flag for each of the internal registers (Rs, Rd). It is configured so that it can be stored in correspondence with internal registers, and when an interrupt occurs, the information stored in the internal register storing the state information and the internal register specified by the interrupting program is stored. After saving the corresponding update flags to the stack, the update flags of these internal registers are reset, and when the interrupt processing is finished, the stack address is sequentially indicated by the stack pointer, and the update flags are set. For internal registers, this internal register is restored using the information read from the stack and the update flag, and for internal registers for which the update flag is not set, only the value of the stack pointer is updated without reading from the stack. This is an evacuation/restoration method characterized by: