WO2025148564A1 - Refilling data processing method and apparatus, and device, storage medium and program - Google Patents

Abstract

Provided in the present application are a refilling data processing method and apparatus, and an electronic device, a computer-readable storage medium and a computer program. The method comprises: when a memory access instruction of a processor is acquired by means of a first cache, acquiring a hit result of the memory access instruction in the first cache; if the hit result is that the memory access instruction is not hit, suspending the memory access instruction, and sending an acquisition request to a second cache by means of the first cache at the same time; and upon receiving, by means of the first cache, refilling data sent by the second cache in response to the acquisition request, determining a target data block from the first cache, releasing old data stored in the target data block, and writing the refilling data into the target data block. In the present application, after receiving refilling data, a first cache releases old data stored in a selected target data block, thereby ensuring the normal implementation of the process of reading the old data by a memory access instruction during this period.

Description

Method, device, equipment, storage medium and program for processing refill data

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims priority to the Chinese patent application filed with the China Patent Office on January 12, 2024, with application number 202410053386.6 and application name “Method, device, equipment and storage medium for processing refilled data”, the entire contents of which are incorporated by reference in this application.

Technical Field

The present application relates to the field of computer technology, and in particular to a method, device, electronic device, computer-readable storage medium and computer program for processing refill data.

Background Art

Modern processors generally have three levels of cache: L1 cache, L2 cache and L3 cache. When the processor's memory access instruction misses the L1 cache, L2 cache needs to refill the data requested by the memory access instruction into the L1 cache to ensure normal data access. Similarly, when the memory access instruction misses the L2 cache, L3 cache needs to refill the requested data into the L2 cache.

Currently, in the process of refilling data from the lower-level cache to the upper-level cache, the upper-level cache first selects a data block (data is used to represent the location where data is stored) and releases the old data in it, and then writes the refill data into the data block when the lower-level cache sends the refill data to realize data refill.

However, in the above process, it often takes a long time to send the refill data from the lower-level cache to the upper-level cache. During the waiting time for the refill data, the old data in the data block has been released, but the refill data has not yet been received, so there is no valid data in the data block, but the data block is still continuously occupied, resulting in idleness and waste of cache resources.

Summary of the invention

Embodiments of the present application provide a method, device, electronic device, computer-readable storage medium, and computer program for processing refill data to solve problems in related technologies.

In a first aspect, an embodiment of the present application provides a method for processing refill data, the method comprising:

In the case where a memory access instruction of the processor is obtained through the first cache, obtaining a hit result of the memory access instruction in the first cache;

If the hit result is a miss, the memory access instruction is suspended, and a fetch request is sent to a second cache through the first cache; the second cache is a lower-level cache of the first cache;

When the first cache receives the refill data sent by the second cache in response to the acquisition request, the target data block is determined from the first cache, the old data stored in the target data block is released, and the refill data is written into the target data block.

In a second aspect, an embodiment of the present application provides a device for processing refill data, the device comprising:

An acquisition module, configured to acquire a hit result of a memory access instruction in the first cache when a memory access instruction of the processor is acquired through the first cache;

a miss module, configured to suspend the memory access instruction if the hit result is a miss, and send a fetch request to a second cache through the first cache; the second cache is a lower-level cache of the first cache;

A write module is used to determine a target data block from the first cache, release old data stored in the target data block, and write the refill data into the target data block when receiving the refill data sent by the second cache in response to the acquisition request through the first cache.

In a third aspect, an embodiment of the present application further provides an electronic device, including a processor;

a memory for storing instructions executable by the processor;

The processor is configured to execute the instructions to implement the method of the first aspect.

In a fourth aspect, an embodiment of the present application further provides a computer-readable storage medium, which, when instructions in the computer-readable storage medium are executed by a processor of an electronic device, enables the electronic device to execute the method of the first aspect.

In a fifth aspect, an embodiment of the present application provides a computer program, comprising a computer-readable code, which, when executed on a computing processing device, causes the computing processing device to execute the method of the first aspect.

In an embodiment of the present application, when a memory access instruction misses in the first cache, the data block is not selected for release first, but the subordinate second cache is notified to obtain the refill data required for the memory access request, and when the second cache obtains the refill data and sends the refill data to the first cache, the target data block is determined from the first cache, and the old data stored in the target data block is released, and the refill data is written into the target data block. In this way, during the period before the arrival of the refill data, the data block storing the old data operates normally, is not vacant or occupied, and the old data can also be accessed normally. In addition, after the first cache receives the refill data, the present application releases the old data stored in the selected target data block, which also ensures the normal implementation of the old data reading process of the memory access instruction during this period.

The above description is only an overview of the technical solution of the present application. In order to more clearly understand the technical means of the present application, it can be implemented in accordance with the contents of the specification. In order to make the above and other purposes, features and advantages of the present application more obvious and easy to understand, the specific implementation methods of the present application are listed below.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

FIG1 is an architecture diagram of an implementation scenario provided by an embodiment of the present application;

FIG2 is a flowchart of a method for processing refill data provided by an embodiment of the present application;

FIG3 is a schematic diagram of the architecture of a first cache provided by an embodiment of the present invention;

FIG4 is a flowchart of specific steps of a method for processing refill data provided in an embodiment of the present application;

FIG5 is a schematic diagram of another architecture of a first cache provided by an embodiment of the present invention;

FIG6 is a block diagram of a device for processing refill data provided by an embodiment of the present application;

FIG7 schematically shows a block diagram of a computing processing device for executing the method according to the present application;

FIG8 schematically shows a storage unit for holding or carrying a program code for implementing the method according to the present application;

FIG. 9 is a block diagram of an electronic device provided in an embodiment of the present application.

Specific embodiments

The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.

The terms "first", "second", etc. in the specification and claims of the present application are used to distinguish similar objects, and are not used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable under appropriate circumstances, so that the embodiments of the present application can be implemented in an order other than those illustrated or described here, and the objects distinguished by "first", "second", etc. are generally a class, and the number of objects is not limited. For example, the first object can be one or more. In addition, the term "and/or" in the specification and claims is used to describe the association relationship of associated objects, indicating that three kinds of relationships can exist, for example, A and/or B can be represented: A exists alone, A and B exist at the same time, and B exists alone. The character "/" generally indicates that the front and back associated objects are a kind of "or" relationship. In the embodiment of the present application, the term "multiple" refers to two or more, and other quantifiers are similar.

Referring to Figure 1, Figure 1 is an implementation scenario architecture diagram provided by an embodiment of the present application. In order to improve execution efficiency and reduce the interaction between the processor and the memory, modern processors can integrate a multi-level cache architecture on the processor. The common architecture is the three-level cache structure of Figure 1, including: Level 1 cache L1, Level 2 cache L2 and Level 3 cache L3. Level 1 cache L1 is the cache closest to the processor, with the smallest capacity and the fastest speed; Level 2 cache L2 has a larger capacity, but is slower than Level 1 cache L1. Level 2 cache L2 is the buffer of Level 1 cache L1. The function of Level 2 cache L2 is to store data that is needed for processor processing but cannot be stored by Level 1 cache L1; Level 3 cache L3 has the largest capacity and is also the slowest level. Level 3 cache L3 and memory can be regarded as buffers of Level 2 cache L2.

When the processor is running, the processor will first go to the first-level cache L1 to find the required data according to the memory access instruction, then go to the second-level cache L2, and then go to the third-level cache L3. If the third-level cache does not find the data it needs, it will get the data from the memory. The longer the search path, the longer it takes, so if you need to get certain data very frequently, make sure that the data is in the first-level cache L1, so that the speed will be very fast. Among them, the memory access instruction is an instruction to get data from a specified address in the memory, or to store data at a specified address in the memory.

In the above process, if the memory access instruction does not hit in the first-level cache L1 (meaning that the first-level cache L1 does not store the data requested to be read by the memory access instruction), the memory access instruction will continue to be searched whether it hits in the second-level cache L2. If it hits in the second-level cache L2, the second-level cache L2 will refill the data requested to be read by the memory access instruction into the first-level cache L1; if it does not hit in the second-level cache L2, the memory access instruction will continue to be searched whether it hits in the third-level cache L3. If it hits in the third-level cache L3, the third-level cache L3 will refill the data requested to be read by the memory access instruction into the second-level cache L2, and then the second-level cache L2 will refill the data into the first-level cache L1.

However, due to the limited cache space, when a cache capacity conflict occurs (i.e., the cache space is full and insufficient to continue storing the refill data), it is necessary to select a data block in the first cache waiting for refilling to release the old data therein, thereby freeing up space to store the refill data.

The related technology is that when the first cache notifies the lower-level second cache to refill data, it selects a data block in the first cache to release the old data therein, and when the lower-level cache sends the refill data, the refill data is written into the data block to achieve data refill. This will cause the vacant data block to be continuously occupied during the waiting process for the refill data. In addition, if there is a need to access the old data during this process, it cannot be successfully accessed because the old data has been released.

In order to solve this problem, the embodiment of the present application may not select a data block for release when the memory access instruction does not hit the first cache, but instead notify the subordinate second cache to obtain the refill data required for the memory access request, wait for the second cache to obtain the refill data and send the refill data to the first cache, and then determine the target data block from the first cache, release the old data stored in the target data block, and write the refill data to the target data block. In this way, during the period before the arrival of the refill data, the data block storing the old data operates normally and is not vacant or occupied, and the old data can also be accessed normally. In addition, after the first cache receives the refill data, the present application releases the old data stored in the selected target data block and writes the refill data to the target data block, which also ensures the normal implementation of the old data reading process of the memory access instruction during this period.

FIG. 2 is a flowchart of a method for processing refill data provided by an embodiment of the present application. As shown in FIG. 2 , the method may include:

Step 101 : when a memory access instruction of a processor is obtained through a first cache, a hit result of the memory access instruction in the first cache is obtained.

In an embodiment of the present application, after the memory access instruction enters the pipeline of the first cache, it is necessary to further check whether the first cache contains the data requested to be read by the memory access instruction. The process of determining whether the data exists can be understood as determining the hit result of the memory access instruction in the first cache. The hit result includes a hit or a miss. A hit represents that the first cache contains the data requested to be read by the memory access instruction; a miss represents that the first cache does not contain the data requested to be read by the memory access instruction.

Specifically, judging the hit result of the memory access instruction in the first cache requires traversing the cache directory of the first cache, so it takes a certain amount of time, which is fixed. Referring to Figure 3, it shows a schematic diagram of the architecture of the first cache. The first cache can adopt a 5-level pipeline architecture, that is, it includes a pipeline queue with 5 sequentially arranged data bits, each data bit corresponds to a pipeline moment, and different data bits correspond to different pipeline moments. The instruction is used to enter the pipeline from the initial data bit S1 of the pipeline queue, and change the data bit with the migration of time. The embodiment of the present application can obtain the hit result of the memory access instruction in the first cache (obtain the hit result at the moment corresponding to the S3 data bit) after the memory access instruction enters the pipeline from the starting data bit (S1) of the pipeline queue, after a fixed number of data bits (for example, 2 data bits are separated). Since the hit result is obtained, and the hit result includes a hit or a miss. Therefore, the embodiment of the present application can subsequently perform corresponding instruction control operations according to the hit result.

It should be noted that the interval of a fixed number of data bits (Figure 3 shows an interval of 2 data bits) refers to the time required for the execution of the operation of waiting to determine the hit result of the memory access instruction in the first cache. Since the time length is fixed, and the data bits in the pipeline queue of the first cache represent the moment, the time length can be converted into a fixed number of data bits. Starting from the starting data bit (S1), a fixed number of data bits are spaced to represent the completion of the execution process of waiting to determine whether a hit is achieved after the memory access instruction enters the pipeline of the first cache, thereby obtaining the hit result of the memory access instruction in the first cache.

Step 102: If the hit result is a miss, the memory access instruction is suspended, and a fetch request is sent to a second cache through the first cache; the second cache is a lower-level cache of the first cache.

In an embodiment of the present application, the hit result of the memory access instruction in the first cache is a hit, indicating that the first cache has the data requested to be read by the memory access instruction. If the first cache also has a superior third cache, the first cache can refill the data requested to be read by the memory access instruction into the third cache; if the first cache does not have a superior third cache, the processor can read data directly from the first cache through the memory access instruction.

In this step, the hit result of the memory access instruction in the first cache is a miss, indicating that the first cache does not store the data requested to be read by the memory access instruction. At this time, it is necessary to check whether the second cache under the first cache has the data. If the data is stored in the second cache, let the second cache refill the data into the first cache. Therefore, when the hit result is a miss, the embodiment of the present application can suspend the memory access instruction and send a fetch request to the second cache through the first cache to request the second cache to find the refill data required by the memory access instruction and send it to the first cache. In addition, when the hit result is a miss, the embodiment of the present application does not need to immediately find the target data block in the first cache for release, so that during the period before the refill data arrives, the target data block storing the old data can operate normally and the old data can also be accessed normally. The second cache is a lower-level cache of the first cache. For example, for the three-level cache structure: first-level cache L1, second-level cache L2 and third-level cache L3, assuming that the first cache is first-level cache L1, then the second-level cache can be second-level cache L2; assuming that the first cache is second-level cache L2, then the second-level cache can be third-level cache L3.

It should be noted that, referring to FIG. 3 , when the hit result of the memory access instruction in the first cache is a miss, the memory access instruction is suspended, which means that the memory access instruction is separated from the pipeline queue of the first cache and enters an allocated miss status register (MSHR, Miss-status Handling Registers) for waiting. The miss status register is a register used to record each unfinished transaction, and the recorded information includes the invalid address, keyword information, and unfinished execution instructions. Once the second cache completes the refill of the first cache, the memory access instruction in the miss status register can be re-executed. The re-executed memory access instruction can re-enter the pipeline queue of the first cache.

Step 103: When the first cache receives the refill data sent by the second cache in response to the acquisition request, determine the target data block from the first cache, release the old data stored in the target data block, and write the refill data into the target data block.

In an embodiment of the present application, the process in which the second cache responds to the acquisition request to search and obtain the refill data and send it to the first cache usually takes a long time (it takes dozens to hundreds of data bits in the pipeline of the first cache). During the time when the first cache waits for the refill data to be sent, the embodiment of the present application does not release or occupy the data block containing the old data, thereby improving the utilization rate of the cache resources while ensuring that the old data can be accessed normally.

Furthermore, in the embodiment of the present application, the target data block is selected only when the refill data sent by the second cache is received through the first cache. If the target data block stores old data, the old data is released and the refill data is written into the target data block. In this way, during the period before the refill data arrives, the data block storing the old data in the first cache can operate normally and is not vacant or occupied, and the old data can also be accessed normally. After the first cache receives the refill data, the old data stored in the selected target data block is released, and the refill data is written into the target data block, which also ensures the normal implementation of the data reading process of the memory access instruction.

In summary, in the embodiments of the present application, when a memory access instruction does not hit in the first cache, the data block is not selected for release first, but the subordinate second cache is notified to obtain the refill data required for the memory access request, and waits for the second cache to obtain the refill data and send the refill data to the first cache, and then the target data block is determined from the first cache, and the old data stored in the target data block is released, and the refill data is written into the target data block. In this way, during the period before the arrival of the refill data, the data block storing the old data operates normally and is not vacant or occupied, and the old data can also be accessed normally. In addition, after the first cache receives the refill data, the present application releases the old data stored in the selected target data block, which also ensures the normal implementation of the old data reading process of the memory access instruction during this period.

FIG. 4 is a flowchart of specific steps of a method for processing refill data provided by an embodiment of the present application. As shown in FIG. 4 , the method may include:

Step 201: When a memory access instruction of a processor is obtained through a first cache, a hit result of the memory access instruction in the first cache is obtained.

This step may specifically refer to the above step 101, which will not be described in detail here.

Step 202: If the hit result is a miss, the memory access instruction is controlled to leave the pipeline queue and enter the missing state register for suspended waiting, and at the same time, a fetch request is sent to a second cache through the first cache; the second cache is a lower-level cache of the first cache.

In an embodiment of the present application, referring to Figure 3, the hit result of the memory access instruction in the first cache is a miss, indicating that the data requested to be read by the memory access instruction is not stored in the first cache. At this time, it is necessary to send a get request to the lower-level second cache through the first cache to check whether the lower-level second cache has the data. If the data is stored in the second cache, the second cache responds to the get request and refills the data into the first cache.

Specifically, when the hit result is a miss, the memory access instruction can be removed from the pipeline queue of the first cache and enter an allocated miss status register (MSHR) for waiting. The miss status register is a register used to record each unfinished transaction. Once the second cache completes the refill of the first cache, the memory access instruction in the miss status register can be re-executed, and the re-executed memory access instruction can re-enter the pipeline queue of the first cache.

Among them, the memory access instruction is separated from the pipeline queue of the first cache because the data requested by the memory access instruction is not stored in the first cache, which causes the memory access instruction to currently fail to realize data reading. Therefore, the memory access instruction is first separated from the pipeline queue of the first cache and enters the missing status register to wait, so as to avoid interfering with the execution of other requests of the first cache. After waiting for the lower-level second cache to send the data requested by the memory access instruction to the first cache, the data requested by the memory access instruction has been obtained by the first cache. Then, the memory access instruction in the missing status register can enter the pipeline queue of the first cache again, so as to correctly read the data in the first cache.

Step 203: When the refill data sent by the second cache in response to the acquisition request is received through the first cache, the first cache directory is read starting from the starting data bit of the pipeline queue of the first cache, and after an interval of a first number of data bits, the target data block is determined from the first cache according to the first cache directory.

In an embodiment of the present application, referring to FIG5, another schematic diagram of the architecture of the first cache is shown. FIG5 is a first cache processing process connected to FIG3. When the refill data sent by the second cache in response to the acquisition request is received through the first cache, the data requested by the memory access instruction has been obtained by the first cache, and the memory access instruction in the missing status register can enter the pipeline queue of the first cache again. Specifically, the memory access instruction can enter the pipeline from the starting data bit (S1 data bit) of the pipeline queue of the first cache, and read the first cache directory from the starting data bit (S1 data bit). The first cache directory is a data that represents the directory of data stored in the first cache. By reading the first cache directory, a target data block can be determined from the first cache to release and store the refill data.

Optionally, step 203 may specifically include sub-steps 2031-2032:

Sub-step 2031: According to the first cache directory, obtain the last access time of each data block in the first cache.

Sub-step 2032: taking the data block with the earliest last access time as the target data block.

In one implementation of an embodiment of the present application, for sub-steps 2031-2032, the first cache directory records the last access time of each data block in the first cache. The embodiment of the present application can obtain the last access time of each data block in the first cache based on the first cache directory, and use the data block with the earliest last access time as the target data block. The data block with the earliest last access time indicates that the data stored in the data block is the least active. Therefore, by using the data block with the earliest last access time as the target data block, the impact on the more active data in other data blocks can be minimized.

In another implementation of the embodiment of the present application, a data block may be randomly selected from the first cache as the target data block, and the embodiment of the present application does not specifically limit the selection strategy of the target data block.

Optionally, step 203 may further include sub-steps 2033-2034:

Sub-step 2033: When receiving, through the first cache, the refill data sent by the second cache in response to the acquisition request, detecting the storage status of the first cache.

Sub-step 2034: when it is determined that the storage status is: there is no free data block in the first cache that can store the refill data, determine a target data block from the first cache.

In an embodiment of the present application, with respect to sub-steps 2033-2034, specifically before determining the target data block in the first cache, the storage status of the first cache can be first detected. If the storage status is that there are free data blocks in the first cache that can store the refill data, the free data blocks are directly used as the target data blocks. However, when a capacity conflict occurs in the first cache (there are no free data blocks in the first cache that can store the refill data), it is necessary to determine the target data block from the first cache through the method of the above embodiment, release the old data in the target data block to make it a free data block, and write the refill data into the free target data block.

Step 204: Write the refill data into the refill buffer area of the first cache.

In an embodiment of the present application, referring to Figure 5, when the first cache just receives the refill data sent by the second cache of the lower level (the refill data has not yet been written to the target data block at this time), it is necessary to temporarily store the refill data before writing the refill data to the target data block. Therefore, an independent refill buffer area can be set up in the first cache, and the first cache can write the refill data into the refill buffer area for temporary storage.

Step 205, read the refill buffer area at the data bit after the starting data bit, and read the refill data after an interval of a second number of data bits, write the read refill data into the write buffer area of the first cache, and read the old data in the target data block.

In an embodiment of the present application, referring to Figure 5, the operation of reading and refilling the buffer area is started at the next data bit (S2 data bit) of the starting data bit (S1 data bit) of the pipeline queue of the first cache. Since it takes a fixed time for the first cache to read the refill cache area from the beginning to read the refill data (corresponding to the pipeline, it takes a time corresponding to 1 data bit), the refill data can be read at the S3 data bit after an interval of the second number of data bits (an interval of 1 data bit).

In the S3 data bit of the pipeline queue of the first cache, while the first cache reads the refill data from the refill buffer area, the first cache can also write the refill data into the write buffer area of the first cache (not shown in the figure). The write buffer area is an independent storage area established in the first cache. Its function is to determine whether to write the refill data to the target data block based on whether a read operation is performed on the target data block, and to write the refill data to the target data block when determining to write.

Furthermore, in the S3 data bit of the pipeline queue of the first cache, the first cache also synchronously starts an operation of reading old data in the target data block.

Step 206: After a third number of data bits have been left, the old data obtained by reading is stored in the second cache, thereby completing the release of the target data block.

In an embodiment of the present application, referring to Figure 5, the first cache also synchronously starts the operation of reading the old data in the target data block in the S3 data bit of the pipeline queue of the first cache. Since it takes a fixed time for the first cache to read the target data block from the beginning to read the old data therein (corresponding to the pipeline, it takes a time corresponding to 2 data bits), after an interval of the third number of data bits (an interval of 2 data bits), the old data in the target data block can be read at the S5 data bit of the pipeline queue of the first cache. At this time, the old data is read out from the target data block.

Furthermore, the S5 data bit of the pipeline queue of the first cache can also send the read old data to the second cache to complete the release of the target data block.

It should be noted that after the old data in the target data block is released, if a read instruction for the old data is subsequently received, the first cache still needs to obtain data from the second cache and refill the first cache according to steps 201 to 207 to meet the read instruction's requirement to read the old data.

Step 207: When it is detected that the operation of reading the target data block is completed, write the refill data in the write buffer area into the target data block.

In the embodiment of the present application, the function of the write buffer area is to determine whether to write the refill data into the target data block according to the judgment of the read operation performed on the target data block. Specifically, the embodiment of the present application sets a higher priority for the operation of reading the target data block, so the write buffer needs to wait until all the read operations on the target data block are completed before starting the operation of writing the refill data in the write buffer area into the target data block. That is, when the write buffer area determines that all the read operations performed on the target data block are completed, the write buffer area executes the operation of writing the refill data in the write buffer area into the target data block, thereby completing the operation of storing the refill data into the first cache storage unit.

Optionally, the method may further include:

Step 208: When the first address carried in the read request received by the first cache matches the second address of the target refill data in the write buffer area, return the target refill data as a response to the read request.

In an embodiment of the present application, during the period when the target refill data is in the write buffer area and has not yet been written into the target data block, if a read request for the target refill data is received, the target refill data in the write buffer area can be directly returned as a response to the read request. Wherein, when the first address carried by the read request received by the first cache matches the second address of the target refill data in the write buffer area, it is determined that the data requested to be read by the read request is the target refill data in the refill buffer area.

It should be noted that, in summary, the missing status register can establish two tasks. The first task is used to implement the first cache obtaining refill data from the second cache during the above embodiment; the second task is used to implement the target data block, release the target data block, write the refill data to the target data block, and continue to refill the refill data to the superior cache during the above embodiment.

Optionally, the method may further include:

Step 209: After writing the refill data into the target data block, extract the memory access instruction from the missing status register, write the refill data into the third cache, and wake up the operation of reading data from the third cache through the memory access instruction.

The third cache is an upper-level cache of the first cache; and the memory access instruction misses in the third cache.

In the embodiment of the present application, when the first cache does not have a third cache of the upper level, the memory access instruction can directly obtain the refill data from the first cache and feed it back to the processor. In the case where the first cache has a third cache of the upper level, after writing the refill data into the target data block, the first cache also needs to extract the memory access instruction from the missing status register, write the refill data into the third cache, and wake up the operation of reading data from the third cache through the memory access instruction, that is, the memory access instruction is to first access the upper cache, if the access to the upper cache does not hit, then access the data of the lower cache for data access, so when the memory access instruction does not hit in the upper third cache, after the lower second cache writes the refill data into the first cache of the current level, the first cache also needs to refill the refill data into the upper third cache, and when the third cache has no upper cache, the operation of reading data from the third cache through the memory access instruction can be awakened, and the awakened memory access instruction can directly obtain the refill data from the third cache and feed it back to the processor. Similarly, when the third cache also has a higher cache, the third cache still needs to continue to refill the refill data into the higher cache.

Optionally, step 209 may specifically include sub-steps 2091-2092:

Sub-step 2091: Control the memory access instruction to enter the pipeline queue of the first cache from the starting data bit, and at the same time generate a wake-up instruction through the first cache and send it to the third cache through the wake-up queue.

Sub-step 2092: after spacing out the second number of data bits in the pipeline queue, obtain refill data through the first cache, and issue the memory access instruction as a refill instruction from the refill queue to the third cache.

The wake-up instruction is used to wake up the operation of reading data from the third cache through the memory access instruction; and the refill instruction is used to write the refill data into the third cache for reading by the memory access instruction.

In an embodiment of the present application, the hit result is a miss, indicating that the data requested to be read by the memory access instruction is not stored in the first cache. At this time, it is necessary to check whether the data is stored in the lower-level second cache. If the data is stored in the second cache, the second cache is allowed to refill the data into the first cache for reading by the memory access instruction.

Specifically, referring to Figure 3, after waiting for the second cache to refill the first cache, the memory access instruction is controlled to re-enter the pipeline queue from the starting data bit, and at the same time, a wake-up instruction is generated through the first cache and issued by the wake-up queue to the upper third cache (the moment of entering the wake-up queue and issuing the wake-up instruction is the moment corresponding to the data bit S1); and after an interval of the second number of data bits (an interval of 2 data bits), the refill data is obtained through the first cache, and the memory access instruction is issued from the refill queue to the third cache as a refill instruction.

For example, referring to Figure 3, when the hit result is a miss, the actual sending time of the wake-up request is the moment corresponding to data bit S1. Since the refill request has to wait in the refill queue for the length of time represented by a data bit (ensuring that the refill request at the exit of the refill queue is issued in time to reduce the probability of congestion in the refill queue), the actual sending time of the refill request is the moment corresponding to data bit S4. It can be seen that the embodiment of the present application can ensure that for each refill request, a wake-up request is issued three data bits in advance.

The embodiment of the present application realizes the management of memory access instructions through the concise and clear multi-level pipeline queue architecture of the first cache. Based on the pipeline queue, it is designed to obtain the hit result of the memory access instruction and send a wake-up request at a fixed data bit, and to obtain the refill data at another fixed data bit and send the refill request through the refill queue; based on the pipeline queue architecture and the design of each processing time of the instruction in the pipeline, it can achieve accurate and stable control of the fixed advance amount of the wake-up request, ensuring the accuracy and coverage of the memory access instruction reading process. The whole process does not need to read the status of the pipeline requests at each level, and the real-time calculation of the advance issuance time based on the status of the refill queue request, so the complexity is extremely low, reducing the cost and power consumption of the circuit.

Optionally, the method may further include:

Step 210: If the hit result is a hit, read the data in the data block hit by the memory access instruction in the first cache and return it.

In an embodiment of the present application, the hit result of the memory access instruction in the first cache is a hit, indicating that the first cache has the data requested to be read by the memory access instruction. If the first cache also has a third cache of an upper level, the first cache can refill the data requested to be read by the memory access instruction into the third cache; if the first cache does not have a third cache of an upper level, the processor can read data directly from the first cache through the memory access instruction.

In summary, in the embodiments of the present application, when a memory access instruction misses in the first cache, the data block is not selected for release first, but the subordinate second cache is notified to obtain the refill data required for the memory access request, and when the second cache obtains the refill data and sends the refill data to the first cache, the target data block is determined from the first cache, and the old data stored in the target data block is released, and the refill data is written into the target data block. In this way, during the period before the arrival of the refill data, the data block storing the old data operates normally, is not vacant or occupied, and the old data can also be accessed normally. In addition, after the first cache receives the refill data, the present application releases the old data stored in the selected target data block, which also ensures the normal implementation of the old data reading process of the memory access instruction during this period.

FIG6 is a block diagram of a device for processing refill data provided by an embodiment of the present application, the device comprising:

The acquisition module 301 is used to acquire a hit result of the memory access instruction in the first cache when the memory access instruction of the processor is acquired through the first cache;

A miss module 302, configured to suspend the memory access instruction if the hit result is a miss, and send a fetch request to a second cache through the first cache; the second cache is a lower-level cache of the first cache;

The write module 303 is used to determine the target data block from the first cache, release the old data stored in the target data block, and write the refill data into the target data block when receiving the refill data sent by the second cache in response to the acquisition request through the first cache.

Optionally, the writing module 303 includes:

The determination submodule is used to read the first cache directory starting from the start data bit of the pipeline queue of the first cache, and determine the target data block from the first cache according to the first cache directory after an interval of a first number of data bits.

Optionally, the writing module 303 includes:

A first writing submodule, used for writing the refill data into a refill buffer area of the first cache;

a processing submodule, configured to read the refill buffer area at a data bit following the start data bit, and read the refill data after a second number of data bits, write the read refill data into the write buffer area of the first cache, and read old data in the target data block;

A release submodule, used for storing the read old data into the second cache after a third number of data bits have passed, thereby completing the release of the target data block;

The second writing submodule is used to write the refill data in the write buffer area into the target data block when it is detected that the operation of reading the target data block is completed.

Optionally, the device further comprises:

A return module is used to return the target refill data as a response to the read request when the first address carried by the read request received by the first cache matches the second address of the target refill data in the write buffer area.

Optionally, the determining submodule includes:

an acquiring unit, configured to acquire, according to the first cache directory, a last access time of each data block in the first cache;

The determination unit is used to take the data block with the earliest last access time as the target data block.

Optionally, the miss module 302 includes:

The suspend submodule is used to control the memory access instruction to leave the pipeline queue and enter the missing state register to suspend and wait if the hit result is a miss.

Optionally, the device further comprises:

a wake-up module, configured to extract the memory access instruction from the missing status register after writing the refill data into the target data block, write the refill data into a third cache, and wake up an operation of reading data from the third cache through the memory access instruction;

The third cache is an upper-level cache of the first cache; and the memory access instruction misses in the third cache.

Optionally, the wake-up module includes:

An entry submodule, used for controlling the memory access instruction to enter the pipeline queue of the first cache from the starting data bit, and generating a wake-up instruction through the first cache and sending it to the third cache through the wake-up queue;

a sending submodule, configured to obtain refill data through the first cache after the second number of data bits are spaced apart in the pipeline queue, and send the memory access instruction as a refill instruction from the refill queue to the third cache;

The wake-up instruction is used to wake up the operation of reading data from the third cache through the memory access instruction; and the refill instruction is used to write the refill data into the third cache for reading by the memory access instruction.

Optionally, the device further comprises:

A hit module is used to read the data in the data block hit by the memory access instruction in the first cache and return it if the hit result is a hit.

Optionally, the writing module 303 includes:

a detection submodule, configured to detect a storage status of the first cache when receiving, through the first cache, refill data sent by the second cache in response to the acquisition request;

The full-load submodule is used to determine a target data block from the first cache when it is determined that the storage status is: there is no free data block in the first cache that can store the refill data.

Optionally, the pipeline queue includes five data bits arranged in sequence.

Optionally, the first number is 1.

Optionally, the second number is 1.

Optionally, the third quantity is 2.

Optionally, the missing status register records the memory access instruction that has not been completed, the failure address of the memory access instruction that has not been completed, and the keyword information of the memory access instruction that has not been completed.

Optionally, the device further comprises:

The data release module is used to release the old data in the target data block, so that the target data block becomes a free data block.

In summary, in the embodiments of the present application, when a memory access instruction misses in the first cache, the data block is not selected for release first, but the subordinate second cache is notified to obtain the refill data required for the memory access request, and when the second cache obtains the refill data and sends the refill data to the first cache, the target data block is determined from the first cache, and the old data stored in the target data block is released, and the refill data is written into the target data block. In this way, during the period before the arrival of the refill data, the data block storing the old data operates normally, is not vacant or occupied, and the old data can also be accessed normally. In addition, after the first cache receives the refill data, the present application releases the old data stored in the selected target data block, which also ensures the normal implementation of the old data reading process of the memory access instruction during this period.

The various component embodiments of the present application can be implemented in hardware, or in software modules running on one or more processors, or in a combination thereof. It should be understood by those skilled in the art that a microprocessor or digital signal processor (DSP) can be used in practice to implement some or all functions of some or all components in the computing processing device according to the embodiment of the present application. The application can also be implemented as a device or apparatus program (e.g., computer program and computer program product) for executing part or all of the methods described herein. Such a program implementing the present application can be stored on a computer-readable medium, or can have the form of one or more signals. Such a signal can be downloaded from an Internet website, or provided on a carrier signal, or provided in any other form.

For example, FIG. 7 shows a computing processing device that can implement the method according to the present application. The computing processing device traditionally includes a processor 1010 and a computer program product or a computer-readable medium in the form of a memory 1020. The memory 1020 can be an electronic memory such as a flash memory, an EEPROM (electrically erasable programmable read-only memory), an EPROM, a hard disk, or a ROM. The memory 1020 has a storage space 1030 for a program code 1031 for executing any method step in the above method. For example, the storage space 1030 for the program code can include individual program codes 1031 for implementing the various steps in the above method respectively. These program codes can be read from or written to one or more computer program products. These computer program products include program code carriers such as hard disks, compact disks (CDs), memory cards, or floppy disks. Such computer program products are generally portable or fixed storage units as described with reference to FIG. 8. The storage unit can have storage segments, storage spaces, etc. arranged similarly to the memory 1020 in the computing processing device of FIG. 7. The program code can be compressed, for example, in an appropriate form. Typically, the storage unit includes computer readable code 1031', i.e., code that can be read by a processor such as 1010, which, when executed by a computing processing device, causes the computing processing device to perform the various steps in the method described above.

Referring to Fig. 9, it is a block diagram of a structure of an electronic device provided by an embodiment of the present invention. As shown in Fig. 9, the electronic device includes: a processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other through the communication bus; the memory is used to store executable instructions, and the executable instructions enable the processor to execute the processing method of refilling data in the above-mentioned embodiment.

The processor may be a CPU (Central Processing Unit), a general processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array) or other editable devices, transistor logic devices, hardware components or any combination thereof. The processor may also be a combination that implements a computing function, such as a combination of one or more microprocessors, a combination of a DSP and a microprocessor, etc.

The communication bus may include a path for transmitting information between the memory and the communication interface. The communication bus may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. The communication bus may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, only one line is used in FIG9 , but it does not mean that there is only one bus or one type of bus.

The memory can be ROM (Read Only Memory) or other types of static storage devices that can store static information and instructions, RAM (Random Access) or other types of dynamic storage devices that can store information and instructions, or it can be EEPROM (Electrically Erasable Programmable Read Only), CD-ROM (Compact Disa Read Only), magnetic tape, floppy disk and optical data storage device, etc.

An embodiment of the present application also provides a computer program product, including a computer program, and a method for processing refill data implemented when the computer program is executed by a processor.

References to "one embodiment," "embodiment," or "one or more embodiments" herein mean that a particular feature, structure, or characteristic described in conjunction with the embodiment is included in at least one embodiment of the present application. In addition, please note that examples of the term "in one embodiment" herein do not necessarily all refer to the same embodiment.

In the description provided herein, a large number of specific details are described. However, it is understood that the embodiments of the present application can be practiced without these specific details. In some instances, well-known methods, structures and techniques are not shown in detail so as not to obscure the understanding of this description.

In the claims, any reference signs placed between brackets shall not be construed as limiting the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The present application may be implemented by means of hardware comprising several different elements and by means of a suitably programmed computer. In a unit claim enumerating several means, several of these means may be embodied by the same item of hardware. The use of the words first, second, and third etc. does not indicate any order. These words may be interpreted as names.

The above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Those skilled in the art will readily appreciate other embodiments of the present application after considering the specification and practicing the application disclosed herein. The present application is intended to cover any variations, uses or adaptations of the present application, which follow the general principles of the present application and include common knowledge or customary techniques in the art that are not disclosed in the present application. The specification and examples are intended to be exemplary only, and the true scope and spirit of the present application are indicated by the following claims.

It should be understood that the present application is not limited to the precise structures that have been described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present application is limited only by the appended claims.

The above are only preferred embodiments of the present application and are not intended to limit the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application should be included in the protection scope of the present application.

The above is a detailed introduction to a method, device, electronic device, computer-readable storage medium and computer program for processing refilled data provided by the present application. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea; at the same time, for general technical personnel in this field, according to the idea of the present application, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present application.

Claims (20)

A method for processing refill data, wherein the method comprises: In the case where a memory access instruction of the processor is obtained through the first cache, obtaining a hit result of the memory access instruction in the first cache; If the hit result is a miss, the memory access instruction is suspended, and a fetch request is sent to a second cache through the first cache; the second cache is a lower-level cache of the first cache; When the first cache receives the refill data sent by the second cache in response to the acquisition request, the target data block is determined from the first cache, the old data stored in the target data block is released, and the refill data is written into the target data block. The method for processing refill data according to claim 1, wherein determining the target data block from the first cache comprises: The first cache directory is read starting from the start data bit of the pipeline queue of the first cache, and after an interval of a first number of data bits, the target data block is determined from the first cache according to the first cache directory. The method for processing refilled data according to claim 2, wherein the releasing of the old data stored in the target data block and the writing of the refilled data into the target data block comprises: Writing the refill data into a refill buffer area of the first cache; At a data bit following the start data bit, the refill buffer area is read, and after a second number of data bits have passed, the refill data is read and obtained, the refill data obtained by reading is written into the write buffer area of the first cache, and old data in the target data block is read; After a third number of data bits have been left, storing the read old data into the second cache, and completing the release of the target data block; When it is detected that the operation of reading the target data block is finished, the refill data in the write buffer area is written into the target data block. The method for processing refill data according to claim 3, wherein the method further comprises: When a first address carried in the read request received by the first cache matches a second address of target refill data in the write buffer area, the target refill data is returned as a response to the read request. The method for processing refill data according to claim 2, wherein determining the target data block from the first cache according to the first cache directory comprises: According to the first cache directory, obtaining the last access time of each data block in the first cache; The data block with the earliest last access time is used as the target data block. The method for processing refill data according to claim 1, wherein if the hit result is a miss, suspending the memory access instruction comprises: If the hit result is a miss, the memory access instruction is controlled to leave the pipeline queue and enter the missing state register to suspend and wait. The method for processing refill data according to claim 6, wherein the method further comprises: After writing the refill data into the target data block, extracting the memory access instruction from the missing status register, writing the refill data into the third cache, and waking up the operation of reading data from the third cache through the memory access instruction; The third cache is an upper-level cache of the first cache; and the memory access instruction misses in the third cache. The method for processing refill data according to claim 7, wherein the step of writing the refill data into a third cache and awakening the operation of reading data from the third cache through the memory access instruction comprises: Control the memory access instruction to enter the pipeline queue of the first cache from the starting data bit, and at the same time generate a wake-up instruction through the first cache and send it to the third cache through the wake-up queue; After a second number of data bits are spaced in the pipeline queue, refill data is obtained through the first cache, and the memory access instruction is issued from the refill queue to the third cache as a refill instruction; The wake-up instruction is used to wake up the operation of reading data from the third cache through the memory access instruction; and the refill instruction is used to write the refill data into the third cache for reading by the memory access instruction. The method for processing refill data according to claim 1, wherein the method further comprises: If the hit result is a hit, the data in the data block hit by the memory access instruction in the first cache is read and returned. The method for processing refill data according to claim 1, wherein, when receiving, through the first cache, the refill data sent by the second cache in response to the acquisition request, determining the target data block from the first cache comprises: When receiving, through the first cache, the refill data sent by the second cache in response to the acquisition request, detecting a storage status of the first cache; When it is determined that the storage status is that there is no free data block in the first cache that can store the refill data, a target data block is determined from the first cache. The method for processing refill data according to claim 2, wherein the pipeline queue includes five data bits arranged in sequence. The method for processing refill data according to claim 2, wherein the first number is 1. The method for processing refill data according to claim 3 or 8, wherein the second number is 1. The method for processing refill data according to claim 3, wherein the third number is 2. According to the processing method for refilling data according to claim 6, wherein the missing status register records the memory access instruction that has not been completed, the failure address of the memory access instruction that has not been completed, and the keyword information of the memory access instruction that has not been completed. The method for processing refill data according to claim 10, wherein after determining the target data block from the first cache, it further comprises: The old data in the target data block is released, so that the target data block becomes a free data block. A device for processing refill data, wherein the device comprises: An acquisition module, configured to acquire a hit result of a memory access instruction in the first cache when a memory access instruction of the processor is acquired through the first cache; a miss module, configured to suspend the memory access instruction if the hit result is a miss, and send a fetch request to a second cache through the first cache; the second cache is a lower-level cache of the first cache; A write module is used to determine a target data block from the first cache, release old data stored in the target data block, and write the refill data into the target data block when receiving the refill data sent by the second cache in response to the acquisition request through the first cache. An electronic device, comprising: a processor; a memory for storing instructions executable by the processor; The processor is configured to execute the instructions to implement the method according to any one of claims 1 to 16. A computer-readable storage medium, wherein when instructions in the computer-readable storage medium are executed by a processor of an electronic device, the electronic device is enabled to execute the method as claimed in any one of claims 1 to 16. A computer program comprises a computer readable code, which, when executed on a computing processing device, causes the computing processing device to execute the method according to any one of claims 1 to 16.