JPS61846A - Test method for normalness of memory contents - Google Patents

Abstract

PURPOSE:To attain a simple and quick test for the normalness of a program stored in a ROM by performing a CRC arithmetic for each module or fixed byte and reading out the CRC check data for collation with the CRC operation result. CONSTITUTION:A CRC check data producing means 16 produces the CRC check data from a program Pi which is written on a ROM15. This CRC check data is stored in a prescribed area of the ROM15 together with other additional data via a buffer register. The program Pi is read out of the ROM15 and the means 16 performs a CRC arithmetic. The produced CRC check data is latched by a buffer register 20. While the CRC check data (d) previously stored in ROM15 is read out and latched by a buffer register 19 for collation with the CRC operation result through a comparator 21. Thus the normalness of the program is decided when the coincidence is obtained from said collation. While it is decided that the program is not normal when no coincidence is obtained.

Description

TECHNICAL FIELD OF THE INVENTION The present invention relates to a method for testing the normality of memory contents that can easily test the normality of a program of a data processing system stored in a read-only memory (ROM). It is.

Conventional technology and problems In data processing systems that store programs in read-only memory (ROM), when the power is turned on, etc., there is a test to see if the program in the read-only memory is normal. The program is compared with a program stored on a magnetic tape or a magnetic drum, and if a match is found, the program is determined to be normal and execution of processing according to the program stored in the only memory is started.

In that case, the program must be read from the magnetic tape or magnetic drum, transferred to random access memory, and written, and the contents stored in the read-only memory corresponding to the written contents must be sequentially read and verified, making the verification process complicated. However, there is a drawback that it takes a long time to check the normality of the program stored in the read-only memory.

It is also possible to store programs by adding parity pits to each byte, but in that case, it is possible to detect only one bit error, but there is a drawback that multiple bit errors cannot be detected. . Therefore, the reliability of checking the program's normality was low.

OBJECTS OF THE INVENTION It is an object of the present invention to make it possible to easily and quickly test the normality of a program stored in a read-only memory.

Structure of the Invention The present invention provides a system for executing data processing according to a program, in which the program is stored by adding CRC check data to each module or a certain byte, and a read-only memory is provided. When testing a program stored in memory,
Performing a CRC operation in units of modules or in units of fixed bytes, and reading out the CRC check data,
It checks the normality of the program in module units or fixed byte units by comparing it with the CRC calculation results, and it is also possible to detect multiple bit errors, so read-only memory (R
The reliability of checking the normality of programs stored in the OM) can be improved.

Embodiment of the Invention FIG. 1 is a block diagram of main parts of a system configuration to which an embodiment of the present invention is applied, in which 1 is a processor (CPU), 2 is a read-only memory (ROM) that stores programs and test programs TP, 3 is random access memory (RAM), 4 is input/output controller (IOC')
, 5 is a common bus.

The read-only memory 2 stores programs and CRC check data. For example, CRC check data is added and stored in program module units or fixed byte units. As shown in the figure, CRC check data is generated for each program module or fixed byte unit Pi, and additional information Ci including this CRC check data is stored. A test program TP can also be stored. The additional information Ci can be, for example, only CRC check data, but as shown in the enlarged view on the right side of the additional information Ci, information about program version a, program module units, or fixed byte units can also be used. Start address b, number of bytes c,
CRC check data d can be stored.

The generating polynomial for creating CRC check data can be, for example, X"10X"+X5+1,
CRC check data is 16 bits. CRC check data is created for each program module or a certain byte unit using the generator polynomial as described above, and the module unit or certain byte unit Pi of the program is stored in the read-only memory 2. Read-only memory 2 of CRC check data
This information is stored in the area of additional information Ci.

When starting up the system by turning on the power, etc., processor 1
reads the test program TP from the read-only memory 2, and uses the test program TP to obtain the attached color information C of the program in module units or in fixed byte units Pi.
i, starts reading the module unit or fixed byte unit Pi of the program specified by the start address b, reads the number of bytes specified by the number of bytes C, and reads the module unit or byte unit of the read program. A CRC calculation is performed in units of pi, the CRC calculation result is compared with pre-stored CRC check data d, and if the comparison matches, it is determined to be normal. Note that the version a of the additional information Ci does not normally need to be read, and the starting address b and the number of bytes c of the additional information Ci
, CRC check data d are read only by the test program TP, and during normal data processing, only the module unit or byte unit Pi of the program is read out.

If there is no error bit in each module or byte of the program, the CRC operation result will be O. If there is a single bit or multiple bit error, the CRC operation result will not be 0, so it is difficult to determine whether the CRC operation result is 0 or not. The normality of the stored program can be checked. Also, if it is normal,
The CRC calculation is performed for the next module unit or a certain byte unit program. When the normality of the program stored in the read-only memory 2 is confirmed, normal data processing based on this program is executed.

FIG. 3 shows a main part of a flowchart for creating data to be written to the read-only memory 2 according to an embodiment of the present invention, and shows a program stored in an area Pi in the read-only memory 2 (hereinafter abbreviated as ROM). Input the data to the CRC check data generation means (2) to generate CRC check data (2). Then, for the entire program area,
After performing the process (2), after the program, the start address b, number of bytes C, and C of the area Pi are added as additional data C4.
RC check data d is added (2) to create write data (2) to the ROM, and this ROM data is written (2).

Note that the test program TP is stored in a predetermined area in the ROM.

FIG. 4 shows a main part of a flowchart of a method for testing a program stored in a ROM according to an embodiment of the present invention.
The test program TP reads the additional data C4 and confirms the start address and number of bytes of the program portion of the ROM data to be tested. This additional data Ci
The reading may be performed either before or after reading the program in units of modules or bytes.

Next, program data of the read program in units of modules or units of bytes is input to the CRC check data generation means, and CRC calculation is performed to generate CRC check data. This generated CRC check data and R
The CRC check data of the additional data of the OM is compared with 0. If the comparison results [phase] match, it is determined to be normal [phase]; if they do not match, it is determined to be abnormal and a fault is displayed [phase] (lamp lighting, printout, etc.).

The test program TP is shown to be stored in advance in the program area of ROM +11, but instead of being stored in ROM (1), it can be stored in random access memory (RAM) from a magnetic tape device, magnetic disk device, etc. ROM according to its test program TP.
It is also possible to test the normality of the program stored in 121 in module units or byte units Pi. The RAM and ROM (2) in FIG. 4 show an example of such a case.

FIG. 5 shows a configuration for creating the above-mentioned ROM data, and 10 shows a program Pi stored in the read-only memory 1'5 (ROM). Further, 11 is a CRC check data generation means, and 14 is a buffer register (RB3) for holding CRC check data. Further, the CRC check data generation means 11 has a configuration that performs the above-mentioned polynomial calculation, and 12.13 is a buffer register (R
Bl+RB2).

CRC check data is generated by the CRC check data generation means 11 from the program Pi written in the ROM,
The CRC check data generated via the buffer register 14 is stored in a predetermined area of the ROM 15 together with other additional data. The test program TP is also the same ROM.
The case where it is stored in is shown.

FIG. 6 shows a configuration corresponding to the flow of the test method shown in FIG. 4, in which 16 is a CRC check data generation means;
is a buffer register (RB7>) that reads and latches the CRC check data d from the ROM 15, 20 is a buffer register (RBe) that latches the result calculated by the CRC check data generation means 16, 21 is C, RC
The CRC check data generation means 16 is a comparator circuit (CMP) that performs comparison with check data, and has a configuration that performs a CRC operation using the above-mentioned polynomial.
8 is a buffer register (RB4), (RBs).

The program Pi stored in the ROM 15 is read out, a CRC operation is performed by the CRC check data generation means 16, and the generated CRC check data is latched in the buffer register 20, and the CRC check data stored in the ROM 15 in advance is d is read out, launched into the buffer register 19, and compared in the comparator circuit 21. If they match, it is determined to be normal, and if they do not match, it is determined to be abnormal.

As described in detail, the present invention stores a program by adding CRC check data to each program module or a certain byte, and provides a one-way memory 2, so that the program can be saved when the system power is turned on, when the program runs out of control, etc. When testing the normality of the program stored in the read-only memory 2, the program is read out in module units or in fixed byte units along with the CRC check data, and the program is checked in module units or fixed byte units by CRC calculation. The system checks the normality of each byte by reading the correct program from magnetic tape, etc.
Compared to the conventional example of checking the program stored in the read-only memory 2, since the program stored in the read-only memory 2 is simply read and a CRC calculation is performed, the normality of the program can be verified in a short time. It has the advantage of being able to be used. Furthermore, since the CRC check data is added and stored, unlike simply adding 9 parity bits, it is possible to detect multiple bit errors, thereby improving the reliability of the normality check.

[Brief explanation of drawings]

Fig. 1 is a block diagram of an embodiment of the present invention, Fig. 2 is an explanatory diagram of the storage contents of the read-only memory, and Figs. The main parts of the flowchart, FIG. 5 and FIG. 6, show the configuration for creating ROM data and performing a program test according to the embodiment of the present invention. 1 is a processor, 2 is a read-only memory, 3 is a random access memory, 4 is an input/output control device, 5 is a common bus, TP is a test program, Pi is a program module unit or a fixed byte unit, and C4 is additional information. . Figure 1 Figure 3 Figure 4 Figure 5

Claims (1)

[Claims] In a system that executes data processing according to a program, a read-only memory is provided in which a program is stored by adding CRC check data to each module or a certain byte of the program, and the program stored in the read-only memory is provided. At the time of testing, the normality of the program can be verified in module units or fixed byte units by performing CRC calculation on the module unit or fixed byte unit, and reading out the CRC check data and comparing it with the CRC operation result. A method for testing the normality of memory contents.