JP6891789B2 - Arithmetic logic unit - Google Patents

Description

The present invention relates to a technical field of an arithmetic unit that executes various arithmetic processes.

As a device of this type, a device that performs floating-point arithmetic is known. In floating-point arithmetic, if a non-number (NaN: Not a Number) occurs, subsequent arithmetic may not be able to be executed normally. Therefore, for example, Patent Document 1 proposes a technique of initializing a target block to prevent a control failure when a non-number occurs in a floating-point operation.

Japanese Unexamined Patent Publication No. 2004-278843

Countermeasures when a non-number occurs include migration to fail-safe and overwriting of calculation result data. When shifting to fail-safe, normal control is stopped, so that the occurrence of abnormalities can be reliably suppressed, but there is a risk that the functions of the entire system will be significantly reduced. On the other hand, if the calculation result data is overwritten and the control is continued, if a serious defect occurs, multiple error countermeasure processing may occur and the calculation may become impossible. Therefore, it is preferable that the transition to fail-safe and the overwriting of the calculated data are selected according to the cause of the non-numerical occurrence. However, in the above-mentioned Patent Document 1, such a case is not assumed at all, and there is sufficient room for improvement.

The present invention has been made in view of the above problems, for example, and an object of the present invention is to provide an arithmetic unit capable of executing appropriate control according to the cause of occurrence of a non-number.

One aspect of the arithmetic unit according to the present invention is an arithmetic unit including a CPU having a general-purpose register, a floating-point arithmetic unit, and a fixed-point arithmetic unit, and a ROM and RAM connected to the CPU via a data bus. When the calculation result of the floating-point arithmetic unit in the arithmetic control is non-number, the calculation result is caused by any of the general-purpose register, the floating-point arithmetic unit, the data bus, the ROM, or the RAM. The specific means for specifying whether or not the number has become non-number, and (i) when the specified cause is any of the floating-point arithmetic unit, the ROM, or the RAM, the arithmetic control is performed. (Ii) If the identified cause is either the general-purpose register or the data bus, the coping means for stopping the arithmetic control and shifting to fail-safe processing is provided. Be prepared.

It is a block diagram which shows the structure of the arithmetic unit which concerns on this embodiment. It is a flowchart which shows the flow of error processing by the arithmetic unit which concerns on this embodiment. It is a flowchart which shows the flow of the top-level processing of the arithmetic processing by the arithmetic unit which concerns on this embodiment. It is a flowchart which shows the flow of the normal processing by the arithmetic unit which concerns on this embodiment. It is a table showing the non-numerical factors and the countermeasures in that case.

Hereinafter, embodiments of the arithmetic unit will be described with reference to the drawings.

<System configuration>
First, the configuration of the arithmetic unit according to the present embodiment will be described with reference to FIG. FIG. 1 is a block diagram showing a configuration of an arithmetic unit according to the present embodiment.

As shown in FIG. 1, the arithmetic unit 10 according to the present embodiment includes a CPU (Central Processing Unit) 100, a ROM (Read Only Memory) 200, a RAM (Random Access Memory) 300, and an interrupt controller 400. ing.

The CPU 100 includes a general-purpose register 110, an ALU.F (floating point arithmetic unit) 120, and an ALU (fixed point arithmetic unit) 130. The general-purpose register 110 is a storage device that temporarily stores data read from the ROM 200 and the RAM 300 via the data bus 150. The ALU.F120 and ALU130 are configured to be able to appropriately read the data stored in the general-purpose register 110 and perform arithmetic processing.

The ROM 200 is a storage device that stores data stored in advance, and is configured to be able to output data to the CPU 100 via the data bus 150. Further, the ROM 200 is configured to be able to output an instruction code to the CPU via the instruction bus 250.

The RAM 300 is a storage device capable of reading and writing data, and is configured so that data can be exchanged with the CPU 100 via the data bus 150.

The interrupt controller 400 is configured to be able to receive a non-number occurrence notification indicating that a non-number has occurred in the calculation result of the ALU.F120. Upon receiving the non-numerical occurrence notification, the interrupt controller 400 can output an instruction to the CPU 100 to start error processing. Error handling will be described in detail below.

<Error handling>
Next, error processing (that is, processing when a non-number occurs) by the arithmetic unit 10 according to the present embodiment will be described with reference to FIG. FIG. 2 is a flowchart showing a flow of error processing by the arithmetic unit according to the present embodiment.

As shown in FIG. 2, at the time of error processing, first, a check of the general-purpose register 110 (that is, a process of checking whether or not the cause of the non-number occurrence is in the general-purpose register 100) is executed (step S11). The check of the general-purpose register 110 is performed by writing a specific value other than a value (non-number, + ∞, −∞, 0, etc.) that can cause a non-number to the general-purpose register 110, reading the written value, and arbitrarily Just check if the value can be written. At this time, the value is directly described in the instruction so that the data is not read from the ROM 200.

After checking the general-purpose register 110, it is determined whether or not there is an error as a result of the check (that is, whether or not the cause of the non-number occurrence is the general-purpose register 110) (step S12). If there is no error (step S12: YES), the process proceeds to step S14. On the other hand, if there is an error (step S12: NO), "ERROR1" is input to Flag_Err, which is a value for managing the error (step S13), and the process proceeds to step S25.

Subsequently, the check of the data bus 150 (that is, the process of checking whether or not the cause of the non-number occurrence is in the data bus 150) is executed (step S14). In the check of the data bus 150, for example, after writing a specific value other than a value (non-number, + ∞, −∞, 0, etc.) that can cause non-number generation to the ROM 200, the written value is read and the read data is read. You can check if it matches the written data.

After checking the data bus 150, it is determined whether or not there is an error as a result of the check (that is, whether or not the cause of the non-number is not the data bus 150) (step S15). If there is no error (step S15: YES), the process proceeds to step S17. On the other hand, if there is an error (step S15: NO), "ERROR2" is input to Flag_Err (step S16), and the process proceeds to step S25.

Subsequently, the check of the ALU.F120 (that is, the process of checking whether or not the cause of the non-number has occurred in the ALU.F120) is executed (step S17). The ALU.F120 check is performed using, for example, a combination of data in which non-numbers are never generated by floating-point arithmetic (for example, non-numbers, other than + ∞, -∞, and 0), and the operation result is non-numerical. You can check that it is not.

After checking the ALU.F120, it is determined whether or not there was an error as a result of the check (that is, whether or not the cause of the non-number was not the ALU.F120) (step S18). If there is no error (step S18: YES), the process proceeds to step S20. On the other hand, if there is an error (step S18: NO), "ERROR3" is input to Flag_Err (step S19), and the process proceeds to step S25.

Subsequently, the data check of the ROM 200 (that is, the process of checking whether or not the cause of the non-number occurrence is in the data of the ROM 200) is executed (step S20). The data in the ROM 200 may be checked by checking that the data is not a value (for example, other than the non-number, +∞, −∞, 0) that reads the data from the ROM 200 and generates a non-number.

After checking the data of the ROM 200, it is determined whether or not there is an error as a result of the check (that is, whether or not the cause of the non-number occurrence is the data of the ROM 200) (step S21). If there is no error (step S21: YES), the process proceeds to step S24. On the other hand, if there is an error (step S22: NO), "ERROR4" is input to Flag_Err (step S22), and the address of the ROM 200 data in which there is an abnormality in Err_ADDR, which is a value indicating the address where the error occurred, is entered. Input and proceed to step S25.

In the arithmetic unit according to the present embodiment, it is any one of the general-purpose register 110, the data bus 150, the ALU.F120, the ROM 200, and the RAM 300 that can cause the non-number to be generated. Therefore, if there is no error in any of the check processes up to this point (that is, each process of step S11, step S14, step S17, and step S20), it can be determined that there is a cause for the occurrence of a non-number in the remaining RAM 300. .. Therefore, if there is no error in the process of step S20 (step S21: YES), it is determined that there is an error in the RAM 300, and "ERROR5" is input to Flag_Err (step S24). However, as in the case of checking the data of the ROM 200, the data of the RAM 300 may be actually checked to determine the presence or absence of an error.

When the part causing the non-number is found (that is, when some input is completed in Flag_Err as a result of the check process), it is determined whether or not "ERROR5" is input in Flag_Err (step S25). That is, it is determined whether or not the cause of the non-number is the data of the RAM 300. When "ERROR5" is input to Flag_Err (step S25: YES), the operation data is overwritten (step S26), and the series of processes is completed. On the other hand, when "ERROR5" is not input to Flag_Err (step S25: NO), the operation data is not overwritten (that is, step S26 is omitted), and the series of processes is terminated.

<Top level processing of arithmetic processing>
Next, the top-level processing of the arithmetic processing by the arithmetic unit 10 according to the present embodiment will be described with reference to FIG. FIG. 3 is a flowchart showing a flow of top-level processing of arithmetic processing by the arithmetic unit according to the present embodiment.

As shown in FIG. 3, in the top-level processing of the arithmetic processing, it is first determined whether or not "ERROR1" and "ERROR2" are not input to Flag_Err (step S31). That is, it is determined whether or not the cause of the non-number is neither the general-purpose register 110 nor the data bus 150.

When "ERROR1" and "ERROR2" are not input to Flag_Err (step S31: YES), normal process 1, normal process 2, ..., Normal process N are called and executed in sequence (step S32). ~ Step S34). On the other hand, when "ERROR1" or "ERROR2" is input to Flag_Err (step S31: YES), fail-safe is executed (step S35).

As described above, in the arithmetic unit 10 according to the present embodiment, when the cause of the non-number is neither the general-purpose register 110 nor the data bus 150, normal arithmetic processing is executed and the non-number is generated. If the cause is either the general-purpose register 110 or the data bus 150, fail-safe is executed (in other words, normal arithmetic processing is not executed). The fail-safe is a process for preventing a problem caused by the occurrence of a non-number in the calculation result.

<Normal processing>
Next, the normal processing by the arithmetic unit 10 according to the present embodiment (that is, each processing from step S32 to step S34 in FIG. 3) will be described with reference to FIG. FIG. 4 is a flowchart showing the flow of normal processing by the arithmetic unit according to the present embodiment.

As shown in FIG. 4, at the time of normal processing, it is first determined whether or not "ERROR4" is not input to Flag_Err (step S41). That is, it is determined whether or not the cause of the non-number is not the data of the ROM 200 (in other words, whether or not the factor of the non-number is ALU.F120 which may have been left at this point). To do.

When "ERROR4" is not input to Flag_Err (step S41: NO), the calculation process by the simple control logic is executed (step S42). That is, when it can be determined that the cause of the non-number occurrence is not the ROM 200 but the ALU.F120, the simple control logic is adopted and the normal arithmetic processing is executed. In the simple control logic, for example, a representative value of the process may be returned according to a main parameter such as a control state. More specifically, for example, the representative value table may be searched by the input data of the control state. In this case, the parameter to be handled is not floating point but integer type data so as not to use ALU.F120 with an error.

When "ERROR4" is not input to Flag_Err (step S41: YES), whether or not "ERROR3" is input to Flag_Err and the arithmetic processing uses the data of Err_ADDR. Determine (step S43). That is, it is determined whether or not the cause of the non-number occurrence is the data of the ROM 200 and the arithmetic processing is executed using the data of the address where the abnormality is found.

When "ERROR3" is input to Flag_Err and it is determined that the arithmetic processing uses the data of Err_ADDR (step S43: YES), the arithmetic processing is executed by the control logic that does not use the ROM value. (Step S44). The control logic in this case may be the same as the simple control logic described above. Further, since it can be determined that there is no more than ALU.F, floating-point arithmetic may be performed.

When "ERROR3" is not input to Flag_Err, or when it is determined that the arithmetic processing does not use the data of Err_ADDR (step S43: NO), the normal arithmetic processing (floating point arithmetic) is executed (floating point arithmetic). Step S45).

<Technical effect>
Next, the technical effect obtained by the arithmetic unit 10 according to the present embodiment will be described with reference to FIG. FIG. 5 is a table showing non-numerical factors and countermeasures in that case. In the figure, 〇 means “normal”, × means “abnormal (error)”, and − means “no check required”.

As shown in FIG. 5, in the arithmetic unit 10 according to the present embodiment, which part is the cause (non-number generation factor) of the non-number occurrence in the calculation result of ALU.F by executing the error processing. Judge whether or not, and take different measures according to the judgment result.

Specifically, if an error is found in the check of the general-purpose register 110 in (1) (that is, the process of step S11 in FIG. 2), it is determined that the non-numerical cause is a hardware failure of the general-purpose register 110. , Do not continue control (ie, normal arithmetic processing). If an error is found in the check of the data bus 150 (that is, the process of step S14 of FIG. 2) in (2), it is determined that the data bus 150 has failed, and the control is not continued in the same manner.

If an error is found in the general-purpose register 110 or the data bus 150, it becomes extremely difficult to continue the subsequent arithmetic processing. Therefore, by selecting not to continue the control (execute fail-safe), it is possible to minimize the trouble caused by the system abnormality.

If an error is found in the check of the ALU.F120 in (3) (that is, the process of step S17 in FIG. 2), it is determined that the non-number generation factor is the failure of the ALU.F120, and only the ALU130 is used. Continue control with simple logic. If an error is found in the data check of the ROM 200 in (4) (that is, the process of step S20 in FIG. 2), it is determined that the non-number generation factor is an abnormality in the data value of the ROM 200, and the abnormal data is selected. Continue control as long as you do not use it. If an error is found in the data check of the RAM 300 in (5) (optional as described above), it is determined that the non-numerical cause is an abnormality in the data value of the RAM 300, and the calculation result data is rewritten. To continue control.

When an error is found in any of the ALU.F120, ROM200, or RAM300, the arithmetic processing itself can be continuously executed by taking some measures. Therefore, as compared with the case where the control is not continued, it is possible to suppress the functional deterioration of the arithmetic unit.

<Additional notes>
Various aspects of the invention derived from the embodiments described above will be described below.

(Appendix 1)
The arithmetic unit according to Appendix 1 is an arithmetic unit including a CPU having a general-purpose register, a floating-point arithmetic unit, and a fixed-point arithmetic unit, and a ROM and a RAM connected to the CPU via a data bus. When the calculation result of the floating-point arithmetic unit in the calculation control is non-number, the calculation result is not due to any of the general-purpose register, the floating-point arithmetic unit, the data bus, the ROM, or the RAM. If the specific means for specifying whether the number has been reached and (i) the specified cause is any of the floating-point arithmetic unit, the ROM, or the RAM, the arithmetic control is continued. , (Ii) If the identified cause is either the general-purpose register or the data bus, the arithmetic control is stopped and the process shifts to fail-safe processing.

According to the arithmetic unit described in Appendix 1, different measures are taken depending on which part of the arithmetic unit is the cause of the non-numerical calculation result of the floating-point arithmetic unit. Specifically, if it is any of a floating-point arithmetic unit, ROM, or RAM, arithmetic control is continued. On the other hand, if the cause of the non-numerical calculation result of the floating-point arithmetic unit is either a general-purpose register or a data bus, the arithmetic control is stopped and the process shifts to fail-safe.

When the cause of the non-number is any of the floating-point arithmetic unit, ROM, or RAM, it is possible to continue the arithmetic control depending on the conditions without shifting to fail-safe. Specifically, the calculation control can be continued by, for example, overwriting the calculation data, not using some data, setting the simple logic, and the like. In this way, even when the calculation result is innumerable, it is possible to prevent the function as the calculation device from being significantly deteriorated by continuing the calculation control while taking simple measures.

On the other hand, when the cause of the non-number is either a general-purpose register or a data bus, it is very difficult to continue arithmetic control, so it is preferable to immediately shift to fail-safe. If the calculation control is stopped and the process shifts to fail-safe, it is possible to surely suppress the occurrence of an abnormality caused by the innumerable calculation results.

The present invention is not limited to the above-described embodiment, and can be appropriately modified within the scope of claims and within a range not contrary to the gist or idea of the invention that can be read from the entire specification. It is included in the technical scope of the present invention.

10 Arithmetic logic unit 100 CPU
110 General-purpose register 120 ALU.F
130 ALU
150 data bus 200 ROM
250 instruction bus 300 RAM
400 interrupt controller

Claims (1)

An arithmetic unit including a CPU having a general-purpose register, a floating-point arithmetic unit, and a fixed-point arithmetic unit, and a ROM and RAM connected to the CPU via a data bus.
When the calculation result of the floating-point arithmetic unit in the arithmetic control is non-number, the calculation result is not due to any of the general-purpose register, the floating-point arithmetic unit, the data bus, the ROM, or the RAM. A specific means of identifying whether the number has been reached,
(I) When the identified cause is any of the floating-point arithmetic unit, the ROM, or the RAM, the arithmetic control is continued, and (ii) the identified cause is the said. If it is either a general-purpose register or the data bus, it is provided with a coping means for stopping the arithmetic control and shifting to fail-safe processing .
The specifying means executes a process of identifying the cause of the general-purpose register or the data bus before the process of identifying the cause of the floating-point arithmetic unit, the ROM, or the RAM. An arithmetic unit characterized by

Images