WO2024046213A1

WO2024046213A1 - Method and apparatus for caching blocks of redundant array of independent disks, and device and readable medium

Info

Publication number: WO2024046213A1
Application number: PCT/CN2023/114783
Authority: WO
Inventors: 梁欣玲; 苏涛
Original assignee: 苏州元脑智能科技有限公司
Priority date: 2022-09-01
Filing date: 2023-08-24
Publication date: 2024-03-07
Also published as: CN115129265B; CN115129265A

Abstract

Provided in the present application are a method and apparatus for caching blocks of a redundant array of independent disks, and a device and a readable storage medium. The method comprises: determining the number of blocks in each stripe in a disk array, and constructing stripe cache information structural bodies; applying for an internal memory from a fixed object pool according to the number of blocks in each stripe; in response to the disk array performing a read io process, according to an array address of the read io process, calculating a stripe serial number and a block serial number, where data to be read is located; and calculating a pointer variable of a stripe cache information structural body that corresponds to the block serial number in a cache structure corresponding to the stripe serial number, and reading the data on the basis of the pointer variable. By using the solution of the present application, the internal memory cost of disk arrays can be effectively saved on, the performance of storage systems is improved, and the competitiveness of products is improved.

Description

Independent redundant disk array block caching method, device, equipment and readable medium

This application requires priority to be submitted to the China Patent Office on September 1, 2022, with the application number 202211059821.3, and the application name is "Independent redundant disk array block caching method, device, equipment and readable medium", The entire contents of which are incorporated herein by reference.

Technical field

The present application relates to the field of computers, and more specifically to a method, device, equipment and non-volatile readable storage medium for independent redundant disk array block caching.

Background technique

Storage technology is widely used in various major areas of today's society, such as banks and major universities. With the advancement of science and technology, storage technology has also made a qualitative leap. Development is no longer limited to the efficiency of storing data, data security and reliability, etc. The focus is gradually focusing on how to save memory and use less memory to complete business need.

RAID6 (redundant array of independent disks) storage technology stores user data information into the cache structure sce (sce) corresponding to the blocks in the cache stripe information sde (storage stripe cache information structure) structure. structure that stores chunked data information). During the initialization process of Raid6, the number of blocks in a stripe is determined based on the number of disks created according to the specifications, and then the memory of the cache sce structure required for the corresponding blocks is reserved and allocated, as well as pointer variables pointing to these memories. For example: the upper limit of the number of blocks in a stripe is 16, then when creating a RAID6 with 16 disks, each sce structure is 64 bytes, then 64*16 bytes need to be allocated, as well as pointer variables pointing to these structures. : Each pointer variable is 8 bytes, that is, 8*16 bytes are allocated, and the memory required for a strip is (64+8)*16 bytes. A RAID6 redundant array consists of a large number of stripes, so the memory requirements are also very large.

Contents of the invention

In view of this, the purpose of the embodiments of this application is to propose a method, device, equipment and non-volatile readable storage medium for independent redundant disk array block caching. By using the technical solution of this application, disks can be effectively saved. Reduce the memory cost of the array, improve the performance of the storage system, and improve the competitiveness of the product.

Based on the above purpose, one aspect of the embodiment of the present application provides a method for independent redundant disk array block caching, which includes the following steps:

Determine the number of blocks in each stripe in the disk array, and construct the stripe cache information structure;

Apply memory from the fixed object pool according to the number of blocks in each stripe;

In response to the disk array performing the read IO process, the stripe number and block number where the data to be read are located is obtained based on the array address of the read IO process;

Calculate the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and read data based on the pointer variable.

According to some embodiments of the present application, determining the number of blocks in each stripe in the disk array and constructing the stripe cache information structure includes:

Determine the number x of blocks in each stripe in the disk array, where 5≤x≤16;

Construct the strip cache information structure sde struct{sce*sceExtension[i]}, where 1≤i≤4.

According to some embodiments of the present application, applying for memory from the fixed object pool according to the number of blocks in each stripe includes:

Calculate the size of the requested memory according to the formula [(x+3)/4] rounded * (8+256) and apply for memory of the corresponding size.

According to some embodiments of the present application, calculating the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and reading data based on the pointer variable includes:

Calculate the pointer variable of sceExtension[i] according to the formula Sce**psce=sceExtension+stripnum/4, where *psce is the pointer variable of sceExtension[i], and sceExtension is the first one in the array sceExtension[i] of the strip cache information structure. The address of the element, stripnum is the block number;

Calculate the block number in the strip cache information structure according to the formula stripnum&=3, where stripnum is the block number;

Calculate the pointer variable of the strip cache information structure corresponding to the block number in the cache structure corresponding to the strip number according to the formula pointer variable=*psce+stripnum.

According to some embodiments of the present application, the applied memory includes memory corresponding to the block cache and memory corresponding to the cache pointer variable.

According to some embodiments of the present application, the object pointed to by the cache pointer variable is 256 bytes of memory.

According to some embodiments of the present application, it also includes:

Determine whether the data read based on the pointer variable is a cache hit.

According to some embodiments of the present application, it also includes:

In response to a cache hit, data is read from the block corresponding to the pointer variable.

According to some embodiments of the present application, it also includes:

In response to a cache miss, the data is read from the disk and the read result is stored in the structure corresponding to the pointer variable.

Another aspect of the embodiment of the present application also provides a device for independent redundant disk array block caching. The device includes:

The construction module is configured to determine the number of blocks in each stripe in the disk array and construct a strip cache information structure;

The application module is configured to apply for memory from the fixed object pool according to the number of blocks in each stripe;

The first computing module is configured to perform a read IO process in response to the disk array, and obtain the strip number and block number where the data to be read is located based on the array address of the read IO process;

The second calculation module is configured to calculate the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and read data based on the pointer variable.

According to some embodiments of the present application, the construction module is also configured to:

According to some embodiments of the present application, the application module is also configured to:

According to some embodiments of the present application, the second computing module is further configured to:

Another aspect of the embodiments of the present application also provides a computer device, which includes:

at least one processor; and

The memory stores computer instructions that can be run on the processor. When the instructions are executed by the processor, the steps of any of the above methods are implemented.

Another aspect of the embodiment of the present application also provides a non-volatile readable storage medium. The non-volatile readable storage medium stores a computer program. When the computer program is executed by a processor, any one of the above methods is implemented. A step of.

The present application has the following beneficial technical effects: The independent redundant disk array block cache method provided by the embodiment of the present application determines the number of blocks in each stripe in the disk array and constructs a strip cache information structure. ; Apply for memory from the fixed object pool according to the number of blocks in each stripe; Perform the read io process in response to the disk array, and obtain the stripe number and partition where the data to be read is located based on the array address of the read io process. Block number; calculate the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and read the data based on the pointer variable. The technical solution can effectively save the memory cost of the disk array and improve the storage system. performance and improve product competitiveness.

Description of drawings

In order to explain the embodiments of the present application or the technical solutions in the prior art more clearly, the drawings needed to be used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings in the following description are only These are some embodiments of the present application. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without exerting creative efforts.

Figure 1 is a schematic flow chart of a method for independent redundant disk array block caching according to some embodiments of the present application;

Figure 2 is a schematic diagram of a strip cache information structure according to some embodiments of the present application;

Figure 3 is a schematic diagram of an independent redundant disk array block cache device according to some embodiments of the present application;

Figure 4 is a schematic diagram of a computer device according to some embodiments of the present application;

Figure 5 is a schematic diagram of a computer non-volatile readable storage medium according to some embodiments of the present application.

Detailed ways

In order to make the purpose, technical solutions and advantages of the present application more clear, the embodiments of the present application will be further described in detail below with reference to specific embodiments and the accompanying drawings.

Based on the above purpose, the first aspect of the embodiments of this application proposes some embodiments of a method for independent redundant disk array block caching. Figure 1 shows a schematic flow chart of the method.

As shown in Figure 1, the method may include the following steps:

S1 determines the number of blocks in each stripe in the disk array and constructs the stripe cache information structure. Determine the number x of blocks in each stripe in the disk array according to the requirements. The maximum value of x is 16 and the minimum value of x is 5. Reconstruct the strip cache information structure sde struct{sce*sceExtension[i ]}, as shown in Figure 2, where the maximum value of i in the sceExtension[i] array is 4 and the minimum value is 1. Based on the above-reconstructed strip cache information structure, you only need to allocate [(x/4) The entire +1]*8 bytes of memory are used to store pointer variables, and each stripe saves x*8-[(x+3)/4]*8 bytes of memory. For example, when creating a raid6 stripe width When it is 16, the memory saved per stripe is 16*8-4*8 bytes.

S2 applies for memory from the fixed object pool according to the number of blocks in each stripe. Based on the number of chunks The memory applied for includes the memory corresponding to the block cache and the memory corresponding to the cache pointer variable. The object pointed to by the cache pointer variable is 256 bytes of memory, and the size of each sce is 64 bytes. Then in a sceExtensions[i] array The memory allocated by a pointer variable can actually store 4 sce.

S3 responds to the disk array and performs the read IO process, and obtains the strip number and block number where the data to be read is located based on the array address of the read IO process. When the disk array performs the read IO process, the strip number and block number where the data in the normal raid is located can be calculated based on the address in the read IO process. This calculation method can be calculated using any method in the existing technology. This No further details will be given.

S4 calculates the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and reads the data based on the pointer variable. After calculating the strip number and block number where the data in the normal raid is located, you need to calculate the pointer variable of the data in the reconstructed strip cache information structure, which can be calculated according to the formula Sce**psce=sceExtension+stripnum/ 4 Calculate the pointer variable of sceExtension[i], where *psce is the pointer variable of sceExtension[i], sceExtension is the address of the first element in the array sceExtension[i] of the strip cache information structure, stripnum is the block number, and then Calculate the block number in the strip cache information structure according to the formula stripnum&=3, stripnum is the block number, and finally calculate the block number in the cache structure corresponding to the stripe number according to the formula pointer variable=*psce+stripnum The pointer variable of the corresponding strip cache information structure, where stripnum is the value calculated by the second formula. After obtaining the pointer variable of the cache structure corresponding to the block, the cache information of the block can be obtained through the pointer variable of sce. When reading the data, it is necessary to determine whether the data read based on the pointer variable is a cache hit. If the cache is hit, then Read data from the block corresponding to the pointer variable. If the cache misses, read the data from the disk and store the read result in the structure corresponding to the pointer variable.

By using the solution of this application, the memory cost of the disk array can be effectively saved, the performance of the storage system can be improved, and the competitiveness of the product can be improved.

In a preferred embodiment of the present application, determining the number of blocks in each stripe in the disk array and constructing the stripe cache information structure includes:

Construct the strip cache information structure sde struct{sce*sceExtension[i]}, where 1≤i≤4, where the optimal value of i is 4, and the object pointed to by the cache pointer variable is 256 bytes of memory, each The size of sce is 64 bytes, so the memory allocated by a pointer variable in a sceExtensions[i] array can actually store 4 sce.

In a preferred embodiment of this application, applying for memory from the fixed object pool according to the number of blocks in each stripe includes:

In a preferred embodiment of the present application, calculating the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and reading the data based on the pointer variable includes:

In a preferred embodiment of this application, the applied memory includes memory corresponding to the block cache and memory corresponding to the cache pointer variable.

In a preferred embodiment of this application, the object pointed to by the cache pointer variable is 256 bytes of memory.

In a preferred embodiment of the present application, it also includes:

Determine whether the data read based on the pointer variable is a cache hit.

In a preferred embodiment of the present application, it also includes:

It should be noted that those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing relevant hardware through computer programs. The above programs can be stored in computer-readable storage media. When the program is executed, it may include the processes of the above method embodiments. The storage media can be magnetic disks, optical disks, read-only memory (Read-Only Memory, ROM) or random access memory (Random Access Memory, RAM), etc. The foregoing computer program embodiments can achieve the same or similar effects as any of the corresponding foregoing method embodiments.

In addition, the method disclosed according to the embodiment of the present application can also be implemented as a computer program executed by a CPU, and the computer program can be stored in a computer-readable storage medium. When the computer program is executed by the CPU, the above functions defined in the method disclosed in the embodiment of the present application are performed.

Based on the above purpose, the second aspect of the embodiment of the present application proposes a device for independent redundant disk array block caching. As shown in Figure 3, the device 200 includes:

In a preferred embodiment of this application, the construction module is also configured as:

In a preferred embodiment of this application, the application module is also configured as:

In a preferred embodiment of the present application, the second computing module is further configured to:

In a preferred embodiment of the present application, a judgment module is also included, and the judgment module is configured as:

Determine whether the data read based on the pointer variable is a cache hit.

In a preferred embodiment of this application, the judgment module is also configured as:

Based on the above purpose, a third aspect of the embodiment of the present application provides a computer device. FIG. 4 shows a schematic diagram of an embodiment of a computer device provided by this application. As shown in Figure 4, the embodiment of the present application includes the following devices: at least one processor 21; and a memory 22. The memory 22 stores computer instructions 23 that can be run on the processor. When the instructions are executed by the processor, the following methods are implemented:

Determine the number of blocks in each stripe in the disk array, and construct the stripe cache information structure. Determine the number x of blocks in each stripe in the disk array according to the requirements. The maximum value of x is 16 and the minimum value of x is 5. Reconstruct the strip cache information structure sde struct{sce*sceExtension[i ]}, where the maximum value of i in the sceExtension[i] array is 4 and the minimum value is 1. Based on the above-reconstructed strip cache information structure, only [(x/4) rounding + 1]*8 needs to be allocated Bytes of memory are used to store pointer variables, and each stripe saves x*8-[(x+3)/4]*8 bytes of memory. For example, when creating a raid6 strip with a width of 16, each stripe saves x*8-[(x+3)/4]*8 bytes of memory. The memory saved by striping is 16*8-4*8 bytes.

Memory is requested from the fixed object pool according to the number of blocks in each stripe. Based on the number of chunks The memory requested includes the memory corresponding to the block cache and the memory corresponding to the cache pointer variable. Storage, the object pointed to by the cache pointer variable is 256 bytes of memory, and the size of each sce is 64 bytes, so the memory allocated by a pointer variable in the sceExtensions[i] array can actually store 4 sce.

In response to the disk array performing a read IO process, the stripe number and block number where the data to be read are located are obtained based on the array address of the read IO process. When the disk array performs the read IO process, the strip number and block number where the data in the normal raid is located can be calculated based on the address in the read IO process. This calculation method can be calculated using any method in the existing technology. This No further details will be given.

Calculate the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and read data based on the pointer variable. After calculating the strip number and block number where the data in the normal raid is located, you need to calculate the pointer variable of the data in the reconstructed strip cache information structure, which can be calculated according to the formula Sce**psce=sceExtension+stripnum/ 4 Calculate the pointer variable of sceExtension[i], where *psce is the pointer variable of sceExtension[i], sceExtension is the address of the first element in the array sceExtension[i] of the strip cache information structure, stripnum is the block number, and then Calculate the block number in the strip cache information structure according to the formula stripnum&=3, stripnum is the block number, and finally calculate the block number in the cache structure corresponding to the stripe number according to the formula pointer variable=*psce+stripnum The pointer variable of the corresponding strip cache information structure, where stripnum is the value calculated by the second formula. After obtaining the pointer variable of the cache structure corresponding to the block, the cache information of the block can be obtained through the pointer variable of sce. When reading the data, it is necessary to determine whether the data read based on the pointer variable is a cache hit. If the cache is hit, then Read data from the block corresponding to the pointer variable. If the cache misses, read the data from the disk and store the read result in the structure corresponding to the pointer variable.

In a preferred embodiment of the present application, it also includes:

Determine whether the data read based on the pointer variable is a cache hit.

In a preferred embodiment of the present application, it also includes:

Based on the above purpose, a fourth aspect of the embodiments of the present application provides a computer-readable storage medium. FIG. 5 shows a schematic diagram of an embodiment of a computer-readable storage medium provided by this application. As shown in Figure 5, the computer-readable storage medium 31 stores a computer program 32 that performs the following methods when executed by a processor:

Memory is requested from the fixed object pool according to the number of blocks in each stripe. Based on the number of chunks The memory applied for includes the memory corresponding to the block cache and the memory corresponding to the cache pointer variable. The object pointed to by the cache pointer variable is 256 bytes of memory, and the size of each sce is 64 bytes. Then in a sceExtensions[i] array The memory allocated by a pointer variable can actually store 4 sce.

In a preferred embodiment of the present application, the applied memory includes memory corresponding to the block cache and memory corresponding to the cache pointer variable.

In a preferred embodiment of the present application, it also includes:

Determine whether the data read based on the pointer variable is a cache hit.

In a preferred embodiment of the present application, it also includes:

In addition, the method disclosed according to the embodiment of the present application can also be implemented as a computer program executed by a processor, and the computer program can be stored in a computer non-volatile readable storage medium. When the computer program is executed by the processor, the above functions defined in the method disclosed in the embodiment of the present application are performed.

In addition, the above method steps and system units can also be implemented using a controller and a computer non-volatile readable storage medium for storing a computer program that enables the controller to implement the above steps or unit functions.

Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits and steps have been described generally in terms of their functionality. Whether this functionality is implemented as software or hardware depends on the specific application and the design constraints imposed on the overall system. Those skilled in the art can implement the functions in various ways for each specific application, but such implementation decisions should not be interpreted as causing a departure from the scope of the embodiments disclosed in the present application.

In one or more example designs, functionality may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functionality may be stored on or transmitted over as one or more instructions or code on a computer non-volatile readable storage medium. Computer non-volatile readable storage media includes computer storage media and communication media including any medium that facilitates transfer of a computer program from one place to another. Storage media can be any available media that can be accessed by a general purpose or special purpose computer. as By way of example and not limitation, the computer non-volatile readable storage medium may include RAM, ROM, EEPROM, CD-ROM or other optical disk storage devices, magnetic disk storage devices or other magnetic storage devices, or may be used to carry or Any other medium that stores required program code in the form of instructions or data structures and that can be accessed by a general or special purpose computer or a general or special purpose processor. Also, any connection is properly termed a computer-readable storage medium. For example, if coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave are used to deliver software from a website, server, or other remote source, the coaxial cable Cable, fiber optic cable, twisted pair, DSL or wireless technologies such as infrared, radio and microwave are included in the definition of media. As used herein, disks and optical disks include compact disks (CDs), laser disks, optical disks, digital versatile disks (DVDs), floppy disks, and Blu-ray disks, where disks typically reproduce data magnetically, while optical disks reproduce data optically using lasers. . Combinations of the above should also be included within the scope of computer non-volatile readable storage media.

The above are exemplary embodiments disclosed in the present application, but it should be noted that various changes and modifications can be made without departing from the scope of the embodiments disclosed in the present application as defined in the claims. The functions, steps and/or actions of the method claims in accordance with the disclosed embodiments described herein need not be performed in any particular order. In addition, although the elements disclosed in the embodiments of the present application may be described or claimed in individual form, they may also be understood as plural unless explicitly limited to the singular.

It will be understood that, as used herein, the singular form "a" and "an" are intended to include the plural form as well, unless the context clearly supports an exception. It will also be understood that as used herein, "and/or" is meant to include any and all possible combinations of one or more of the associated listed items.

The embodiment numbers disclosed in the above embodiments of the present application are only for description and do not represent the advantages or disadvantages of the embodiments.

Those of ordinary skill in the art can understand that all or part of the steps to implement the above embodiments can be completed by hardware, or can be completed by instructing the relevant hardware through a program. The program can be stored in a computer-readable storage medium. The above-mentioned The storage medium can be a read-only memory, a magnetic disk or an optical disk, etc.

Those of ordinary skill in the art should understand that the above discussion of any embodiments is only illustrative, and is not intended to imply that the scope of the disclosure of the embodiments of the present application (including the claims) is limited to these examples; under the ideas of the embodiments of the present application , the above embodiments or technical features in different embodiments can also be combined, and there are many other changes in different aspects of the above embodiments of the present application, which are not provided in details for the sake of simplicity. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the embodiments of the present application shall be included in the protection scope of the embodiments of the present application.

Claims

A method for independent redundant disk array block caching, which is characterized by including the following steps:

Determine the number of blocks in each stripe in the disk array, and construct the stripe cache information structure;

Apply memory from the fixed object pool according to the number of blocks in each stripe;

In response to the disk array performing the read IO process, the stripe number and block number where the data to be read are located is obtained based on the array address of the read IO process;

Calculate the pointer variable of the stripe cache information structure corresponding to the block number in the cache structure corresponding to the stripe number, and read data based on the pointer variable.
The method according to claim 1, characterized in that determining the number of blocks in each stripe in the disk array and constructing the stripe cache information structure includes:

Determine the number x of blocks in each stripe in the disk array, where 5≤x≤16;

Construct the strip cache information structure sde struct{sce*sceExtension[i]}, where 1≤i≤4.
The method according to claim 2, further comprising:

Allocate [(x/4) rounded + 1]*8 bytes of memory to store pointer variables.
The method according to claim 2 or 3, further comprising:

If the width of the created stripe is x, calculate the number of bytes saved by the stripe according to the method x*8-[(x+3)/4]*8.
The method according to claim 2 or 3, characterized in that applying for memory from the fixed object pool according to the number of blocks in each stripe includes:

Calculate the size of the requested memory according to the formula [(x+3)/4] rounded * (8+256) and apply for memory of the corresponding size.
The method according to claim 5, further comprising:

If the object pointed to by the cache pointer variable is 256 bytes of memory, and the size of each sce is 64 bytes, then the memory allocated by a pointer variable in a sceExtensions[i] array is used to store 4 sce.
The method according to claim 2, characterized in that calculating the pointer variable of the strip cache information structure corresponding to the block number in the cache structure corresponding to the strip number, and reading the data based on the pointer variable includes:

Calculate the pointer variable of sceExtension[i] according to the formula Sce**psce=sceExtension+stripnum/4, where *psce is the pointer variable of sceExtension[i], and sceExtension is the first one in the array sceExtension[i] of the strip cache information structure. The address of the element, stripnum is the block number;

Calculate the block number in the strip cache information structure according to the formula stripnum&=3, where stripnum is the block number;

Calculate the pointer variable of the strip cache information structure corresponding to the block number in the cache structure corresponding to the strip number according to the formula pointer variable=*psce+stripnum.
The method according to claim 7, characterized in that stripnum in the formula pointer variable =*psce+stripnum is the calculated value of the formula stripnum&=3.
The method according to claim 7 or 8, further comprising:

If the pointer variable of the cache structure corresponding to the block is obtained, the cache information of the block is obtained through the pointer variable of sce.
The method according to claim 5, characterized in that the applied memory includes memory corresponding to the block cache and memory corresponding to the cache pointer variable.
The method according to claim 10, characterized in that the object pointed to by the cache pointer variable is a 256-byte memory.
The method according to claim 1, further comprising:

Determine whether the data read based on the pointer variable is a cache hit.
The method of claim 12, further comprising:

In response to a cache hit, data is read from the block corresponding to the pointer variable.
The method of claim 12, further comprising:

In response to a cache miss, the data is read from the disk and the read result is stored in the structure corresponding to the pointer variable.
An independent redundant disk array block caching device, characterized in that the device includes:

A construction module configured to determine the number of blocks in each stripe in the disk array and construct a stripe cache information structure;

An application module configured to apply for memory from the fixed object pool according to the number of blocks in each stripe;

A first computing module, the first computing module is configured to perform a read IO process in response to the disk array, and obtain the strip number and block number where the data to be read is located based on the array address of the read IO process;

The second calculation module is configured to calculate the pointer variable of the strip cache information structure corresponding to the block number in the cache structure corresponding to the strip number, and read data based on the pointer variable.
The device according to claim 15, characterized in that the construction module is further configured to:

Determine the number x of blocks in each stripe in the disk array, where 5≤x≤16;

Construct the strip cache information structure sde struct{sce*sceExtension[i]}, where 1≤i≤4.
The device according to claim 16, characterized in that the application module is further configured to:

Calculate the size of the requested memory according to the formula [(x+3)/4] rounded * (8+256) and apply for memory of the corresponding size.
The device according to claim 16, wherein the second computing module is further configured to:

Calculate the pointer variable of sceExtension[i] according to the formula Sce**psce=sceExtension+stripnum/4, where *psce is the pointer variable of sceExtension[i], and sceExtension is the first one in the array sceExtension[i] of the strip cache information structure. The address of the element, stripnum is the block number;

Calculate the block number in the strip cache information structure according to the formula stripnum&=3, where stripnum is the block number;

Calculate the pointer variable of the strip cache information structure corresponding to the block number in the cache structure corresponding to the strip number according to the formula pointer variable=*psce+stripnum.
A computer device, characterized in that it includes:

at least one processor; and

A memory that stores computer instructions executable on the processor, and when executed by the processor, the instructions implement the steps of the method of any one of claims 1-14.
A non-volatile readable storage medium, the non-volatile readable storage medium stores a computer program, characterized in that when the computer program is executed by a processor, the computer program implements any one of claims 1-14 Method steps.