Patent Publication Number: US-8533565-B2

Title: Cache controller and cache controlling method

Description:
CROSS-REFERENCE TO RELATED APPLICATION(S) 
     This application is a continuation of PCT international application Ser. No. PCT/JP2007/062464 filed on Jun. 20, 2007 which designates the United States, the entire contents of which are incorporated herein by reference. 
    
    
     FIELD 
     The embodiments discussed herein are directed to a cache controller, a cache controlling method, and a cache controlling program that perform a write operation to store data received from a execution unit, and generate an ECC for the store data. 
     BACKGROUND 
     Conventionally, a data cache memory (DATA-RAM) protects data by appending an Error-Check-and-Correction (ECC) byte to an 8-byte data. An ECC is stored in an ECC cache memory (ECC-RAM) that is separate from DATA-RAM, and dedicatedly provided for ECCs. The ECC-RAM is updated when a register or a write operation is performed to the cache memory. 
     A common method of generating an ECC will now be explained with reference to  FIG. 17 . As depicted  FIG. 17 , to write data into a cache memory, an instruction processor issues a store instruction to a memory processor. Upon receiving the instruction, the memory processor checks if the cache line to be stored is in the cache memory, and at the same time, reads the data in the cache line to be stored from the cache memory and checks the data for an error. At this time, store data issued from an execution unit and alike is written in a store buffer (STB). 
     When the instruction processor issues a store permission subsequently, the memory processor writes the data taken out from the store buffer into a write buffer (WB), and further writes the data taken out from the write buffer into the DATA-RAM. At the same time as writing the data, the memory processor generates an ECC based on 8-byte fetched data read from the DATA-RAM, using bytes-not-to-be-stored included therein (ECC generation 1). In addition, the memory processor generates an ECC based on data in the bytes-to-be-stored included in the 8-byte store data (ECC generation 2). The memory processor then merges these two ECCs to generate an ECC corresponding to the updated store data, and stores the generated ECC in the ECC-RAM. 
     However, a 1-bit error might be different in each of these scenarios, that is, in the data read from the DATA-RAM upon checking for an error when the retrieval access is made to the cache memory in response to the store request; and in the data read therefrom upon generating the ECC after the storing is permitted, and the cache memory is accessed for the write. In other words, if no error is detected at the error check performed upon the data retrieval, but an error is found in the data read upon execution of the write, the ECC corresponding to the data after the write cannot be generated properly. Furthermore, the ECC remaining at this point is one corresponding to the data before the write, and the data before the write has been already lost. Therefore, it is impossible to correct the faulty bit, further making it impossible to correct the 1-bit error upon reading the data before executing the write. The reason why such an uncorrectable error occurs is that, because the data is read from the DATA-RAM twice, the result of each of the reads might be different. 
     In response to such an issue, a disclosed technique executes an error check and an ECC generation based on a single read (see  FIG. 18 ). In other words, the disclosed memory processor does not use the data read from DATA-RAM upon executing the write. More specifically, an ECC is generated based on the data stored previously, and the ECC is appended to the store data written in the STB, to generate new store data (see Japanese Laid-open Patent Publication No. 01-185753, Japanese Laid-open Patent Publication No. 03-108041, Japanese Laid-open Patent Publication No. 10-232789, and Japanese National Publication of International Patent Publication No. 2004-514184, for example). 
     However, these conventional techniques have a problem that, when data of equal to or less than 8 bytes are stored in the same address consecutively, Store-Store-Interlock (SSI) may occur, resulting in performance deterioration. More specifically, because a memory processor with such a structure maintains data-not-to-be-stored as an ECC, if the next store instruction executes a write in the same area as the preceding store instruction, the memory processor has to wait for the preceding storing to complete before generating an ECC. Therefore, the memory processor results in detecting SSI for store data other than 8-byte full-store data, thus fails to execute the next storing. 
     SUMMARY 
     According to an aspect of an embodiment of the invention, a cache memory controller includes a data detecting unit that detects a write address in the cache memory into which the store data is stored, an area-to-be-stored of the store data that is to be stored and an area-not-to-be-stored that is not to be stored, when the store data is transmitted from an execution unit; a data determining unit that determines whether data-to-be-stored that is already written is present in the write address detected by the data detecting unit; an existing data-not-to-be-stored obtaining unit that obtains, from the data written in the write address, data detected by the data detecting unit and written in the area-not-to-be-stored, as existing data-not-to-be-stored, when the data determining unit determines that the data-to-be-stored is present in the write address; a store data writing unit that merges the existing data-not-to-be-stored obtained by the existing data-not-to-be-stored obtaining unit with the data-to-be-stored in the area-to-be-stored detected by the data detecting unit to generate new store data, and writes the new store data into the write address detected by the data detecting unit; and an ECC generating unit that generates an ECC for the new store data written by the store data writing unit into the cache memory, from the new store data generated by the store data writing unit. 
     The object and advantages of the invention will be realized and attained by means of the elements and combinations particularly pointed out in the claims. 
     It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory and are not restrictive of the invention, as claimed. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG. 1  is a schematic of a system structure depicting an entire structure of a cache memory controller according to a first embodiment of the present invention; 
         FIG. 2  is a block diagram of a structure of a cache memory controlling unit according to the first embodiment; 
         FIG. 3  is a schematic of an example of a structure of information stored in an STB; 
         FIG. 4  is a schematic of an example of a structure of information stored in a WB; 
         FIG. 5  is a schematic of an example of a structure of information stored in an FCDR; 
         FIG. 6  is a flowchart of a process performed by the cache memory controlling unit according to the first embodiment; 
         FIG. 7  is a schematic of movement of data in an IU-REQ process; 
         FIG. 8  is a schematic of movement of data in a WB-GO process; 
         FIG. 9  is a schematic of movement of data in an ST1-REQ process; 
         FIG. 10  is a schematic of movement of data in an ST2-REQ process; 
         FIG. 11  is a flowchart of the IU-REQ process; 
         FIG. 12  is a flowchart of the WB-GO process; 
         FIG. 13  is a flowchart of the ST1-REQ process; 
         FIG. 14  is a flowchart of the ST2-REQ process; 
         FIG. 15  is a schematic of examples of store data merger; 
         FIG. 16  is a schematic of an example of an order of data priority in a data merger; 
         FIG. 17  is a schematic for explaining a conventional technology; and 
         FIG. 18  is another schematic for explaining a conventional technology. 
     
    
    
     DESCRIPTION OF EMBODIMENTS 
     Preferred embodiments of the present invention will be explained with reference to accompanying drawings. The present invention is not limited to the embodiment described below. 
     The explanations will be given in order of the overview and characteristics of a cache controlling unit according to the embodiments, and the structure of and processes performed by the cache controlling unit. Various variations of the embodiments will be explained last. 
     [a] First Embodiment 
     Overview and Characteristic of Cache Memory Controller 
     To begin with, an overview and a characteristic of a cache memory controller according to an embodiment of the present invention will be explained with reference to  FIG. 1 .  FIG. 1  is a schematic of a system structure depicting an entire structure of the cache memory controller according to a first embodiment of the present invention. 
     As depicted in  FIG. 1 , this cache memory controller is connected to an execution unit and an instruction processing unit to realize a central processing unit (CPU or MPU). The central processing unit is connected to a memory controlling unit that reads or writes data from or to a main memory. The instruction processing unit connected to a cache memory controlling unit transmits a store instruction appended with store-related information such as a store address, a store data width, and aligning information to the cache memory controlling unit. The execution unit transmits 8-byte store data to the cache memory controlling unit. 
     The cache memory controlling unit includes: a plurality of store buffers (STB) that stores therein 8-byte store data transmitted by the execution unit; a plurality of write buffers (WB) that temporarily maintains the store data to be stored (to be written) in a DATA-RAM; the DATA-RAM that is a cache memory that stores therein 8-byte store data; a plurality of fetch data registers (FCDR) that maintains data output from the DATA-RAM; and an ECC-RAM that stores therein an ECC corresponding to 8-byte store data to be stored in the DATA-RAM. 
     Using such a structure, the cache memory controlling unit generally writes store data received from the execution unit onto the cache memory, as well as generating an ECC for the store data. Especially, a main characteristic of the cache memory controlling unit is in its capability of preventing SSI from occurring even when equal to or less than 8-byte data is stored consecutively to the same address, and of generating a correct ECC. 
     To explain this main characteristic more specifically, upon receiving store data from the execution unit, the cache memory controlling unit detects therein an address into which the store data is stored; an area-to-be-stored; and an area-not-to-be-stored that is not to be stored, from the store data (See Step ( 1 ) in  FIG. 1 ). To use a specific example, let us assume that the execution unit transmits 8-byte store data having 6-byte data that is to be maintained (to be stored) in the DATA-RAM, and 2-byte data that is not to be maintained (not to be stored). In this scenario, the cache memory controlling unit detects, for example, an “address A” that is an address of the DATA-RAM in which the store data is to be stored; “6 bytes” that is an area-to-be-stored that is to be stored in the store data; and “2 bytes” that is an area-not-to-be-stored that is not to be stored. In addition, the cache memory controlling unit maintains the store data in the STB, and outputs the store data to the WB. 
     The cache memory controlling unit then determines if any other data written in the detected address of the cache memory is present (see Step ( 2 ) in  FIG. 1 ). To explain more specifically with reference to the example, the cache memory controlling unit refers to the detected address “address A” in the DATA-RAM, and determines if other data is already written in the address (retrieves the cache). 
     If it is determined that other data is present in the address of the cache memory, the cache memory controlling unit obtains the data from the area-not-to-be-stored detected earlier in the data that is stored in the address, as existing data-not-to-be-stored (see Step ( 3 ) in  FIG. 1 ). To explain more specifically with reference to the example, if it is determined that other data is present in the address “address A” of the DATA-RAM, that is, if a cache hit occurs, the cache memory controlling unit stores data in the detected “2-byte” area-not-to-be-stored, out of the data stored in the address, as existing data-not-to-be-stored (in this example, 2-byte data) in the FCDR. Alternatively, the FCDR may store the entire “8 bytes” including the “2 bytes”, instead of only the “2 bytes” in the area-not-to-be-stored. 
     The cache memory controlling unit then generates new data-to-be-stored by merging the obtained existing data-not-to-be-stored with the data-to-be-stored detected earlier in the area-to-be-stored, and writes the data in the detected address in the cache memory (see Step ( 4 ) in  FIG. 1 ). To explain more specifically with reference to the example, the cache memory controlling unit reads and stores the “2-byte” existing data-not-to-be-stored, obtained and maintained in the FCDR, into the WB; at the same time, the cache memory controlling unit generates new “8-byte” store data by merging this existing data-not-to-be-stored with the “6-byte” data-to-be-stored, and stores the generated new store data in the WB. The cache memory controlling unit then reads the new “8-byte” store data from the WB, and writes the data in the detected address in the DATA-RAM, the address A. 
     The cache memory controlling unit generates an ECC for the new store data written in the cache memory, based on the generated new store data (see step ( 5 ) in  FIG. 1 ). To explain more specifically with reference to the example, the cache memory controlling unit generates a 1-byte ECC for the new store data written in the DATA-RAM from the “8-byte” new store data generated and maintained in the WB, and stores the ECC in the ECC-RAM. 
     In this manner, before executing the store, the cache memory controlling unit according to the first embodiment brings the data from the area-not-to-be-stored (the data in the area not overwritten by the store data) and maintains the data itself in the WB, instead of the ECC generated from the data stored previously in the DATA-RAM; and merges the data-to-be-stored with the data in the area-not-to-be-stored to generate new store data and an ECC. As a result, as mentioned above as the main characteristic, the main characteristic of the cache memory is in that SSI can be prevented from occurring even when equal to or less than 8-byte data is consecutively stored to the same address, and that a correct ECC can be generated. 
     Structure of Cache Memory Controller 
     A structure of the cache memory controlling unit depicted in  FIG. 1  will now be explained with reference to  FIG. 2 .  FIG. 2  is a block diagram of the structure of the cache memory controlling unit according to the first embodiment. As depicted in  FIG. 2 , a cache memory controlling unit  10  includes a DATA-RAM  11 , an ECC-RAM  12 , a data maintaining unit  13 , and a processing unit  20 . 
     The DATA-RAM  11  is a cache memory storing therein a plurality of pieces of data in a unit of 8 bytes. More specifically, the DATA-RAM  11  is caused to store data output from the execution unit by way of the instruction processing unit, or to serve the data for reads by the instruction processing unit. 
     The ECC-RAM  11  is a memory for storing therein ECC data generated by an ECC generating unit  25  that is to be described later. More specifically, the ECC-RAM  12  stores therein 1-byte ECC data generated by the ECC generating unit  25  correspondingly to each piece of data stored in the DATA-RAM  11 . 
     The data maintaining unit  13  is a buffer that temporarily stores therein the store data received from the execution unit to enable the processing unit  20  to be described later to perform various processes thereto. In a close relationship with the embodiment, the data maintaining unit  13  includes an STB  14 , a WB  15 , and an FCDR  16 . 
     The STB  14  is a buffer that temporarily stores therein the store data received from the execution unit. To explain with a specific example, when the execution unit transmits store data and the instruction processing unit outputs store-related information such as a store address, a store data width, and aligning information together with a store instruction, the STB  14  stores therein data-to-be-stored (store byte mark (STBM)) and a store address (ADRS), each detected (generated) and stored by a data detecting unit  21  to be described later, as depicted in  FIG. 3 . The STBM indicates which bytes of store data are to be stored, and the store address indicates where in the DATA-RAM the data is to be stored.  FIG. 3  is a schematic of an example of a structure of the information stored in the STB. 
     When the data-area-to-be-stored, the area-not-to-be-stored, and the store address are detected before storing the store data taken out from the STB  14  in the DATA-RAM  11 , the WB  15  maintains the store data output from the STB  14 . For example, as depicted in  FIG. 4 , in the same manner as in the STB  14 , the WB  15  maintains the data-to-be-stored (store byte mark (STBM)) and a store address (ADRS), associated with each of EVEN and ODD, as depicted in  FIG. 4 .  FIG. 4  is a schematic of an example of a structure of the information stored in the WB. 
     The FCDR  16  is a buffer that temporarily stores therein the data written in and output from the area-not-to-be-stored in the DATA-RAM  11 , as existing data-not-to-be-stored. More specifically, the FCDR  16  stores therein data read by an existing data-not-to-be-stored obtaining unit  23  from the address in the DATA-RAM  11  where existing data-not-to-be-stored, written in an area-not-to-be-stored that is not to be stored, from the store data detected by the data detecting unit  21 , is stored. For example, the FCDR  16  maintains existing data-not-to-be-stored, read from the DATA-RAM  11 , in an 8-byte area as depicted in  FIG. 5 .  FIG. 5  is a schematic of an example of a structure of information stored in the FCDR. 
     The processing unit  20  is a processing unit that executes various processes. Especially in a close relationship with the embodiment, the processing unit  20  includes the data detecting unit  21 , a data determining unit  22 , the existing data-not-to-be-stored obtaining unit  23 , a store data writing unit  24 , and the ECC generating unit  25 . 
     Upon receiving store data from the execution unit, the data detecting unit  21  detects therein the address in the cache memory into which the store data is stored; the area-to-be-stored where the store data is to be stored; and the area-not-to-be-stored that is not to be stored, from the store data. More specifically, upon receiving an 8-byte store data from the execution unit, the data detecting unit  21  stores the data-to-be-stored (store byte mark (STBM)) and a store address (ADRS) detected from the store data in the STB  14 . The data detecting unit  21  also detects an area-not-to-be-stored that is not to be stored from the store data, and transmits the store data to the WB  15 . For example, the data detecting unit  21  causes the STB  14  to maintain STBM that is the area to be stored (6 bytes), and the store address (ADRS=address A) detected in the store data received from the execution unit. At the same time, the data detecting unit  21  detects the area-not-to-be-stored that is not to be stored (2 bytes), and transmits the store data to the WB  15 . 
     The data determining unit  22  determines if any other data written in the address in the cache memory detected by the data detecting unit  21  is present. To explain with a specific example, the data determining unit  22  refers to the address “ADRS” in the DATA-RAM  11 , the address detected and stored in the STB  14  by the data detecting unit  21 , and determines if other data is already written therein. The result of the determination is notified to the existing data-not-to-be-stored obtaining unit  23  to be described later. 
     If the data determining unit  22  determines that other data written in the address of the cache memory is present, the existing data-not-to-be-stored obtaining unit  23  obtains the data written in the area-not-to-be-stored, detected by the data detecting unit  21 , out of the data written in the address, as existing data-not-to-be-stored. To explain more specifically with reference to the example, when the existing data-not-to-be-stored obtaining unit  23  is notified from the data determining unit  22  that other data is present in the address “ADRS (e.g., address A)” in the DATA-RAM  11 , that is, if a cache hit occurs, the existing data-not-to-be-stored obtaining unit  23  obtains the data written in the detected area-not-to-be-stored (2 bytes), out of the data written in the address, and stores the data in the FCDR  16  as existing data-not-to-be-stored (in this example, the 2-byte data). 
     The store data writing unit  24  merges the existing data-not-to-be-stored obtained by the existing data-not-to-be-stored obtaining unit  23  with the data-to-be-stored in the area-to-be-stored detected by the data detecting unit  21  to generate new store data. The store data writing unit  24  then writes the new store data into the address in the cache memory detected by the data detecting unit  21 . To explain more specifically with reference to the example, the store data writing unit  24  merges the “2-byte” existing data-not-to-be-stored stored in the FCDR  16  with the “6-byte” data-to-be-stored in the area-to-be-stored and stored in the WB  15 , in the WB  15  (e.g., processes these pieces of data with an EOR circuit) to generate new “8-byte” store data. The store data writing unit  24  then stores the new store data in the WB  15 . The store data writing unit  24  then reads the new “8-byte” store data from the WB  15 , and writes the data into the detected address “ADRD (e.g., address A)” in the DATA-RAM  11 . 
     The ECC generating unit  25  generates an ECC for the new store data written in the cache memory by the store data writing unit  24 , from the new store data generated by the store data writing unit  24 . To explain more specifically with reference to the example, the ECC generating unit  25  reads the new “8-byte” store data generated by the store data writing unit  24  and stored in the WB  15 , generates a 1-byte ECC for the new store data written in the DATA-RAM, and stores the ECC to the ECC-RAM  12 . 
     Process Performed by Cache Memory Controlling Unit 
     A process performed by the cache memory controlling unit will now be explained with reference to  FIG. 6 .  FIG. 6  is a flowchart of the process performed by the cache memory controlling unit according to the first embodiment. 
     As depicted in  FIG. 6 , if store data is received from the execution unit (YES at Step S 601 ), the data detecting unit  21  included in the cache memory controlling unit  10  stores the data-to-be-stored (store byte mark (STBM)) and the store address(ADRS) into the STB  14 , detects the area-not-to-be-stored that is not to be stored, from the store data, and transmits the store data to the WB  15  (Step S 602 ). 
     The data determining unit  22  then refers to the address “ADRS” in the DATA-RAM  11 , such an address detected by the data detecting unit  21  and maintained in the STB  14 , and determines if any other data is already written therein. In other words, the data determining unit  22  retrieves the cache (Step S 603 ). 
     If any other data is already written therein (a cache hit occurs) (YES at Step S 604 ), the existing data-not-to-be-stored obtaining unit  23  obtains the data written in the area-not-to-be-stored, out of the data written in the address, from the DATA-RAM  11  as existing data-not-to-be-stored, and stores the obtained existing data-not-to-be-stored in the FCDR  16  (Step S 605 ). 
     The store data writing unit  24  then reads the existing data-not-to-be-stored stored in the FCDR  16  into the WB  15 , merges the data with the data-to-be-stored, which is in the area to be stored maintained in the WB  15 , in the WB  15  to generate new store data, and writes the new store data to the detected address in the DATA-RAM  11  (Step S 606 ). 
     The ECC generating unit  25  generates an ECC for the new store data that is written in the DATA-RAM  11  by the store data writing unit  24 , from the new store data generated by the store data writing unit  24 . The ECC generating unit  25  then stores the ECC in the ECC-RAM  12  (Step S 607 ). 
     On the contrary, referring back to Step S 604 , if no data-to-be-stored is written (a cache miss occurs) (NO at Step S 604 ), the data that is the store data to be written is registered (Step S 608 ), and the cache is retrieved again (Step S 603 ). 
     Effects of First Embodiment 
     As described above, according to the first embodiment, upon receiving store data from an execution unit, the cache memory controller detects a write address in the cache memory where the store data is to be stored, a store area that is to be stored, and an area-not-to-be-stored that is not to be stored, from the store data; determines if any data-to-be-stored stored previously in the detected write address is present; obtains the data written in the detected area-not-to-be-stored, out of the data written in the write address, as existing data-not-to-be-stored, if it is determined that the data-to be-stored is stored in the write address; merges the obtained existing data-not-to-be-stored with the data-to-be-stored in the detected area-to-be-stored to generate new store data, and writes the new store data to the detected write address; and generates an ECC for the new store data written in the cache memory, based on the generated new store data. Therefore, it is possible to prevent SSI from occurring even when equal to or less than 8-byte data is stored consecutively to the same address, and to generate a correct ECC. 
     More specifically, the cache memory controller generates new store data, as well as an ECC, using the data itself stored in the DATA-RAM, instead of an ECC generated based on the data stored previously. Therefore, the cache memory controller can perform the process without waiting for an ECC to be generated for preceding data. As a result, it is possible to prevent SSI from occurring even when equal to or less than 8-byte data is stored consecutively to the same address, and to generate a correct ECC. Moreover, a 1-bit error can be completely remedied in the RAM. 
     [b] Second Embodiment 
     The cache memory controller according to the first embodiment described above brings the data stored in the area-not-to-be-stored in the DATA-RAM to the FCDR or the WB before executing the store, and merges the store data with the data contained in the area-not-to-be-stored to generate new store data and an ECC; however, the present embodiment is not limited thereto. When the preceding data is stored in the same address, the cache memory controller can also generate new store data and an ECC taking the area-to-be-stored of the preceding store data into consideration in advance. 
     Therefore, in a second embodiment of the present invention, explanations will be given in detail how data is moved among the STB, the WB, and the FCDR that are the buffers on which store data is processed, and the DATA-RAM and the ECC-RAM in which store data and ECCs are stored, with reference to  FIGS. 7 to 14 . Furthermore, according to the second embodiment, in a situation where the preceding data is stored in the same address, the cache memory controller generates new store data and an ECC taking the area-to-be-stored of the preceding store data into consideration in advance. 
     Movement of Data in Each Process
         Store Request Issued from Execution Unit/Instruction Processing Unit   To begin with, an Instruction Unit-Request (IU-REQ) process that is executed upon receiving a store request from the execution unit/the instruction processing unit will be explained with reference to  FIG. 7 .  FIG. 7  is a schematic of movement of data in the IU-REQ process.       

     As depicted in  FIG. 7 , the instruction processing unit transmits (issues) a store instruction that is accompanied by store-related store information such as a store address, a store data width, and aligning information to the cache memory controlling unit. Upon receiving the issued store instruction, the cache memory controlling unit generates STBM from the information, and stores the information into the STB together with the ADRS. 
     The cache memory controlling unit then inputs the store instruction to a pipeline, and checks if the cache line to be stored is in the cache memory (DATA-RAM). The cache memory controlling unit reads the data from the 8-byte data cache memory using the store address, and checks the data for an error. If a cache hit occurs, the cache memory controlling unit sets the read data in the area-to-be-stored to the FCDR. If a cache miss occurs, the cache memory controlling unit requests the data from the main memory. 
     Writing from STB into WB 
     A Write-Buffer-GO (WB-GO) process in which store data is written from the STB into the WB will now be explained with reference to  FIG. 8 .  FIG. 8  is a schematic of movement of data in the WB-GO process. 
     As depicted in  FIG. 8 , when the cache memory controlling unit receives a store permission from the instruction processing unit, and if the STB that is to be processed has the highest priority and there is an space in the WB, the cache memory controlling unit issues a WB-GO (write request). In response, the cache memory controlling unit reads the data in the area-to-be-stored from the STB, and data in the area-not-to-be-stored from the FCDR, respectively, and updates the WB with the data. The cache memory controlling unit determines the area-to-be-stored based on the STB-STBM. 
     In addition, the cache memory controlling unit performs an address match between a WB-GO-ADRS of the current store data-to-be-stored (STB-ADRS that is to be processed by WB-GO) and the ST2-ADRS (address in the ST2-REQ) of the preceding store data that is the store data transmitted from the execution unit prior to the current store data. If the ST2-REQ is at the same timing as the WB-GO, the cache memory controlling unit refers to the ST2-STBM, merges the ST2-DATA additionally, and writes the data into the WB. In other words, if a match occurs between the DATA-RAM address in which the preceding store data is to be stored and the DATA-RAM address into which the current store data is to be stored, the cache memory controlling unit obtains the data-to-be-stored of the preceding data from the WB, and merges the current data-to-be-stored and the existing data-not-to-be-stored obtained from the FCDR with the data-to-be-stored of the preceding store data, and writes the data into the WB. 
     Retrieving Cache Memory 
     A Store1-Request (ST1-REQ) process performed when a cache miss occurs in  FIG. 7  will now be explained with reference to  FIG. 9 .  FIG. 9  is a schematic of movement of data in the ST1-REQ process. 
     As depicted in  FIG. 9 , when the area-to-be-stored is not in the DATA-RAM although the store data has been stored in the WB, the cache memory controlling unit initiates the ST1-REQ from the WB. In response, the cache memory controlling unit retrieves the cache memory using the WB-ADRS. If a cache hit occurs and no error is present in the DATA-RAM, the cache memory controlling unit writes only the data in the area-not-to-be-stored into the WB using the WB-STBM. If a cache miss occurs, the cache memory controlling unit requests the data from the main memory. 
     Writing into Cache Memory 
     A Store2-Request (ST2-REQ) performed upon writing store data from the WB to the cache memory and upon generating an ECC will now be explained with reference to  FIG. 10 .  FIG. 10  is a schematic of movement of data in the ST2-REQ process. 
     As depicted in  FIG. 10 , if the area-to-be-stored is present in the cache memory, the cache memory controlling unit initiates the ST2-REQ from the WB. Upon initiating the ST2-REQ, the cache memory controlling unit takes out the store data from the WB requested by the ST2-REQ, and updates the DATA-RAM with the data. The cache memory controlling unit then generates a 1-byte ECC corresponding to 8-byte data based on this data, and writes the ECC to the ECC-RAM. 
     If the addresses of the ST2-ADRS and the STB-ADRS (an address in each store buffer) match, then the cache memory controlling unit reflects the data onto the target FCDR. At this time, the cache memory controlling unit updates only the area-to-be-stored using the ST2-STBM. Furthermore, if the addresses of the ST2-ADRS and another WB-ADRS (a WB address excluding the one onto which the ST2 is executed) match, the cache memory controlling unit reflects the store data onto the target WB. In this situation as well, the cache memory controlling unit updates only the area-to-be-stored using the ST2-STBM. 
     Moreover, when ST2-REQ is generated consecutively, the cache memory controlling unit cannot reflect the prior store data onto the WB to which the next storing is executed. Therefore, if the ST2-ADRS that is an address of a store preceding by 1τ makes a match with the ST2-ADR before generation of an ECC, the store data is merged with the data preceding by 1τ. 
     Performing Each Process 
     A process flow of each of the processes “store request issued from the execution unit/instruction processing unit (IU-REQ)”, “writing from the STB to the WB (WB-GO)”, “retrieving cache memory (ST1-REQ)”, and “writing into cache memory (ST2-REQ)” will now be explained with reference to  FIGS. 11 to 14 . “LID” mentioned in a flowchart of each of these processes suggests that an area-to-be-stored is exclusively servicing in the cache memory, and the “LID” is updated when a cache hit occurs, and stored in the STB and the WB. 
     IU-REQ Process 
     To begin with, the IU-REQ, depicted in  FIG. 7 , will be explained with reference to  FIG. 11 .  FIG. 11  is a flowchart of the IU-REQ process. 
     As depicted in  FIG. 11 , if the instruction processing unit transmits (issues) a store instruction (YES at Step S 1101 ), the cache memory controlling unit determines if the data-to-be-stored is stored in the DATA-RAM (retrieves the cache) (Step S 1102 ). 
     If no cache hit occurs (YES at Step S 1102 ), the cache memory controlling unit updates the “LID” to “1” (Step S 1103 ), generates STBM from the received store data, and stores the STBM into the STB together with the ADRS (Step S 1104 ). At the same time, the cache memory controlling unit reads the data-to-be-stored making a cache hit from the DATA-RAM, and stores the data into the FCDR (Step S 1105 ). 
     On the contrary, if no cache hit occurs (NO at Step S 1102 ), the cache memory controlling unit updates the “LID” to “0”, generates STBM from the received store data, and stores the STBM into the STB together with the ADRS (Step S 1106 ). 
     WB-GO Process 
     The WB-GO process depicted in  FIG. 8  will now be explained with reference to  FIG. 12 .  FIG. 12  is a flowchart of the WB-GO process. 
     As depicted in  FIG. 12 , upon receiving a store permission from the instruction processing unit (YES at Step S 1201 ), the cache memory controlling unit issues a WB-GO request, and executes the WB-GO process (Step S 1202 ). 
     In response, the cache memory controlling unit merges the following data, that is: the data-to-be-stored, in the area-to-be-stored, obtained from the STB; the existing data-not-to-be-stored that is the data in the area-not-to-be-stored and obtained from the FCDR; the data-to-be-stored obtained from another WB when the address in the WB-GO and the address in the ST2 (the data-to-be-stored in the preceding store data) match; and the data-to-be-stored obtained from the same WB when the address in the WB-GO and the address in the same WB (the data-to-be-stored in the preceding store data) match (Step S 1203  to Step S 1208 ). The cache memory controlling unit then stores the merged data in the WB (Step S 1209 ). 
     ST1-REQ Process Flow 
     The ST1-REQ process depicted in  FIG. 9  will now be explained with reference to  FIG. 13 .  FIG. 13  is a flowchart of the ST1-REQ process. 
     As depicted in  FIG. 13 , if a cache miss occurs (YES at Step S 1301 ), the cache memory controlling unit checks the status of the WB (Step S 1302 ). 
     If the LID in the WB is set to “0” (YES at Step S 1303 ), the cache memory controlling unit initiates an ST1-REQ (Step S 1304 ). 
     The cache memory controlling unit retrieves the cache again for the store data received from the execution unit (Step S 1305 ). If a cache hit occurs (YES at Step S 1305 ), the cache memory controlling unit updates the LID to “1”, reads the data-to-be-stored that made the cache hit from the DATA-RAM, and stores the data in the WB (Step S 1306 ). 
     On the contrary, if a cache hit does not occur (NO at Step S 1305 ), the cache memory controlling unit requests the received store data to the main memory (Step S 1308 ), writes the data into the DATA-RAM (Step S 1309 ), and performs Step S 1302  and the steps thereafter. 
     Referring back to Step S 1303 , if the LID in the WB is not “0” (NO at Step S 1303 ), the cache memory controlling unit initiates an ST2-REQ (Step S 1307 ). 
     ST2-REQ Process Flow 
     The ST2-REQ process depicted in  FIG. 10  will now be explained with reference to  FIG. 14 .  FIG. 14  is a flowchart of the ST2-REQ process. 
     As depicted in  FIG. 14 , the cache memory controlling unit checks the status of the WB (Step S 1401 ), and if the LID is “1” (YES at Step S 1402 ), the ST2-REQ is initiated (Step S 1403 ). 
     In response, the cache memory controlling unit stores the store data from the WB into the DATA-RAM (Step S 1404 ). At the same time, if the address in the WB-GO makes a match with the address in the ST2 (YES at Step S 1405 ), the cache memory controlling unit stores the data in the area-to-be-stored into another WB (Step S 1406 ). In addition, if the address in the STB makes a match with the address in the ST2 (YES at Step S 1407 ), the cache memory controlling unit stores the data in the area-to-be-stored into the FCDR (Step S 1408 ). If the address in another WB makes a match with the address in the ST2 (YES at Step S 1409 ), the cache memory controlling unit stores the data in the area-to-be-stored in that WB (Step S 1410 ). If the address in the ST2 preceding by 1τ makes a match with the address in the ST2 (YES at Step S 1411 ), the cache memory controlling unit merges the data preceding by 1τ into the current store data (Step S 1412 ), generates an ECC based on the merged data, and stores the ECC in the ECC-RAM (Step S 1413 ). 
     Referring back to Step S 1402 , if the LID is not “1” (NO Step S 1402 ), a calculator initiates the ST1-REQ (Step S 1414 ). 
     Effects of Second Embodiment 
     As described above, according to the second embodiment, if it is determined that the data-to-be-stored is not present in the write address in the cache memory, the cache memory controlling unit registers the data-to-be-stored, and then detects any data-already-stored stored in the detected address of the cache memory; if the cache memory controlling unit detects the data-already-stored stored in the detected address of the cache memory, the cache memory controlling unit merges new store data with the data-already-stored to further generate new store data, and writes the new store data in the write address detected by the data detecting unit; and the cache memory controlling unit generates an ECC for the new store data that is written in the cache memory based on the generated new store data. Therefore, even when a cache miss occurs, a correct ECC can be generated. 
     Furthermore, according to the second embodiment, when the execution unit transmits store data, the cache memory controlling unit detects a write address in the cache memory into which preceding data, transmitted from the execution unit prior to the store data, is stored, and a preceding area-to-be-stored that is to be stored from the preceding store data; the cache memory controlling unit further determines if the write address of the detected store data makes a match with the write address of the preceding store data; if it is determined that the write address of the store data makes a match with the write address of the preceding store data, the cache memory controlling unit merges the existing data-not-to-be-stored and the data-to-be-stored with the preceding data-to-be-stored in the detected preceding area-to-be-stored to generate new store data, writes the new store data into the write address in the cache memory, and generates an ECC for the new store data written into the cache memory based on the generated new store data. Therefore, the cache memory controlling unit can generate new store data and an ECC taking preceding store data into consideration. As a result, SSI can be prevented from occurring more reliably even when equal to or less than 8-byte data is stored consecutively to the same address, and a correct ECC can be generated more surely. 
     [c] Third Embodiment 
     The second embodiment explained the scenario where current store data is merged with, for example, preceding store data, or store data stored in the WB into which the current store data is to be stored to generate new store data. In this embodiment, it will be explained which data is to be prioritized in a merger operation. 
     To begin with, it will be explained under what circumstances store data are merged with reference to  FIG. 15 .  FIG. 15  is a schematic of an example of a merger of store data. “WB 0 ” and “WB 1 ” depicted in  FIG. 15  indicate that these are physically different write buffers. 
     For example, the cache memory controlling unit merges the data-to-be-stored in the store data transmitted from the execution unit with existing data-not-to-be-stored that is the data stored in the DATA-RAM corresponding to the area-not-to-be-stored (see ( 1 ) in  FIG. 15 ). 
     In addition, if the write address of the store data currently transmitted from the execution unit makes a match with the write address of preceding store data stored in the WB prior to the store data that is currently received, the cache memory controlling unit merges the data-to-be-stored of the store data transmitted from the execution unit with existing data-not-to-be-stored that is the data stored in the DATA-RAM corresponding to the area-not-to-be-stored and the data-to-be-stored in the preceding store data (see ( 2 ) in  FIG. 15 ). 
     Moreover, if the write address of store data stored in the WB 0  makes a match with the write address of store data stored in the WB 1 , the cache memory controlling unit merges the data-to-be-stored in the store data stored in the WB 0  with the data-to-be-stored in the store data stored in the WB 1  (see ( 3 ) in  FIG. 15 ). 
     Furthermore, if the write address of the store data currently transmitted from the execution unit makes a match with the write address of store data stored in the WB 0  in which the store data currently transmitted from the execution unit is to be stored, the cache memory controlling unit merges data-to-be-stored in the store data transmitted from the execution unit with the existing data-not-to-be-stored that is the data stored in the DATA-RAM corresponding to the area-not-to-be-stored, and the data-to-be-stored in the store data stored in the WB 0 , and stores the merged data in the WB 1  (see ( 4 ) in  FIG. 15 ). 
     Furthermore, upon merging the existing data-not-to-be-stored that is the data stored in the DATA-RAM corresponding to the area-not-to-be-stored with the data-to-be-stored in the store data stored in the WB 0  to store the merged data in the WB 1  at ( 4 ) in  FIG. 15 , if the write address of the newly generated store data makes a match with the write address of the store data stored in the WB 1  into which the newly generated store data is to be stored, the cache memory controlling unit merges the data-to-be-stored in the newly generated store data with the data-to-be-stored stored in the WB 1  to store the new store data in the WB 1  (see ( 5 ) in  FIG. 15 ). 
     It will now be explained which store data is to be prioritized upon merging the data in the scenarios depicted in ( 1 ) to ( 5 ) in  FIG. 15 , with reference to  FIG. 16 .  FIG. 16  is a schematic of an example of an order of data priority in a data merger. 
     As depicted in ( 1 ) in  FIG. 16 , as an order of data priority in a merger operation, store data to be stored in the “STB-DATA (WB-GO)” is most prioritized, and data to be stored in “WB-DATA”, “ST2-DATA (ST2-REQ)”, and “FCDR-DATA (WB-GO)” are prioritized in descending order. When this priority is applied to each of the examples depicted in  FIG. 15 , store data depicted in ( 2 ) in  FIG. 16  will be generated. 
     [d] Fourth Embodiment 
     Up to this point, the embodiments of the present invention have been explained; however, these embodiments may also be realized by various different implementations other than those described above. Therefore, other embodiments of the present invention will now be explained, under the classification of (1) Selecting Data to Be Merged, and (2) System Structure, etc. 
     (1) Selecting Data to be Merged 
     In the second embodiment, as an example, it has been explained that the data transmitted by the execution unit is merged with all of the data, including data stored in the DATA-RAM, data found in a retrieval performed after a cache miss, and preceding data; however, the present invention is not limited thereto, and the data to be merged may be selected in any way, e.g., only some of these pieces of data may be merged. 
     (2) System Structure, Etc. 
     The whole or a part of the processing described in the embodiments to be automatically executed (e.g., outputting store data from the execution unit) may be manually executed. Moreover, the processing procedure, the control procedure, the specific names, information containing various kinds of data and parameters (for example, those depicted in  FIGS. 3 to 5 ), described herein or in the drawings, may be changed in any way except where specified otherwise. 
     Furthermore, each of the elements provided in each of the apparatus depicted in the drawings only represents conceptualized functions thereof, and does not necessary have to be structured physically as depicted in the drawings. In other words, a specific distributive or integrative structure of each of the apparatus is not limited to that depicted in the drawings, and whole or any part of thereof may be distributed or integrated functionally or physically in any unit depending on various types of loads or usage (for example, the data detecting unit and the data determining unit may be integrated). 
     According to an embodiment, it is possible to prevent SSI from occurring even when equal to or less than 8-byte data is stored consecutively to the same address, as well as generating a correct ECC. 
     Furthermore, according to an embodiment, a correct ECC can be generated even when a cache miss occurs. 
     Furthermore, according to an embodiment, the cache memory controlling unit can generate new store data and an ECC taking preceding store data into consideration. As a result, SSI can be prevented from occurring more reliably even when equal to or less than 8-byte data is stored consecutively to the same address, and a correct ECC can be generated more surely. 
     All examples and conditional language recited herein are intended for pedagogical purposes to aid the reader in understanding the invention and the concepts contributed by the inventor to furthering the art, and are to be construed as being without limitation to such specifically recited examples and conditions, nor does the organization of such examples in the specification relate to a showing of the superiority and inferiority of the invention. Although the embodiments of the present inventions have been described in detail, it should be understood that the various changes, substitutions, and alterations could be made hereto without departing from the spirit and scope of the invention.