Polyhedral model and method for distributing data using computational operations

Abstract

A method of distributing data and parity between different data storage media using computational operations based on a polyhedral model. Devices, systems, and methods divide data into data stripe units, where the number of data stripe units is equal to the number of vertices of the polyhedron, and respective ones of the plurality of data stripe units correspond to respective ones of the plurality of vertices of the polyhedron; constructing a plurality of parity checks, where the number of parity checks is equal to the number of faces of the polyhedron, and a respective parity of the plurality of parity checks corresponds to a respective parity of the plurality of parity checks of the polyhedron, wherein a respective parity of the plurality of parity is constructed by computationally operating data stripe units corresponding to vertices respectively associated with a face of the polyhedron corresponding to the respective parity; and distributing the subset of data stripe units and the parity subset to the subset of storage media.

Description

[0001] Cross-reference to related applications

[0002] This application claims priority to Indian Patent Application No. 202311056017, filed on August 21, 2023, which is incorporated herein by reference in its entirety as fully set forth herein. Technical Field

[0003] This disclosure relates to erasure-decoded data storage, specifically to storing data via a graph-based erasure coding model for encoding and decoding the data, and to redundantly distributing the data across different data storage media. Background Technology

[0004] Erasure decoding takes the original data and encodes it so that when the data is retrieved, a subset of the data can be used to reconstruct the original data information. Erasure decoding is a data protection scheme that segments data, uses redundancy to extend and encode these segments, and stores them across multiple locations. Even if multiple disks fail, erasure decoding can prevent data loss.

[0005] Another method for protecting data is RAID (Redundant Array of Independent Disks), which stores data in multiple locations so that if one or more disks fail, copies of the data are stored on the other disks. RAID levels exist that provide fault tolerance for up to two disks. Even nested RAID levels can ensure reconfigurability for up to two disks based on the fault tolerance of the branch corresponding to the primary RAID level. As disks become larger and rebuild times increase, dual-disk failure limitations become a significant constraint on RAID implementations. RAID implementations offer high performance levels due to the parallelism available when using multiple media to store data. However, if the number of parity checks added does not increase accordingly, the probability of failure for the entire volume also increases with the number of storage media (e.g., memory disks). Storage media include, but are not limited to, hard disk drives, solid-state drives, tape drives, and optical drives.

[0006] A volume, logical drive, RAID volume, or erasure-decoded volume is a logical abstraction of a group of physical disks. A logical volume presents a certain amount of storage space to the host for data storage. This storage space is physically composed of the storage space provided by its constituent physical disks. Due to the additional redundancy introduced for fault tolerance, the capacity of a volume is typically less than the sum of the capacities of its constituent physical disks. Host data written to a volume means that the host has written data bytes starting from the logical block address of the space provided by the volume. Actual data may reside / span one or more physical disks and physical block addresses.

[0007] Erasure decoding schemes exist that offer higher fault tolerance but are computationally very intensive, thus impacting input / output (I / O) performance. Erasure decoding is suitable for data storage, allowing data to be reconstructed. Algorithms used for erasure decoding (such as Reed-Solomon) have very high computational complexity, involving Galois field matrix multiplication. This results in significant performance overhead on the erased volume.

[0008] Storage disks are prone to failure, so resilience mechanisms provide data protection in the event of disk failure. RAID levels offer fault tolerance of up to two disks per volume. RAID 5 offers one level of fault tolerance, while RAID 6 offers two. Volume rebuilds can be performed quickly to mitigate the risk of total volume failure. Erasure coding offers even higher fault tolerance but is computationally intensive and has lower performance.

[0009] Data is stored on disks (a type of storage medium) connected to the storage controller. This data is at risk of failure due to disk failure. To ensure data fault tolerance, redundancy of data written across disks needs to be introduced. Existing RAID levels 0, 1, 5, 6, 1E, 10, 50, and 60 exist (10, 50, and 60 are nested RAID levels) and different erasure decoding schemes, which provide different methods for creating redundancy and storing data. RAID levels exist that provide fault tolerance for two disks while offering higher I / O performance compared to erasure-decoded volumes. Erasure decoding schemes exist that offer high fault tolerance but are computationally intensive compared to RAID volumes, thus impacting I / O performance.

[0010] Extensive research exists in erasure decoding, primarily employing polynomial coding in the Galois domain. Most industrial implementations utilize computationally intensive Reed-Solomon codes and locally repairable codes to achieve full data recoverability. To repair a degraded volume with faulty physical disks, the remaining physical disks, containing the data and additional redundant data (parity), are read. If all disks participate in redundancy calculations and subsequent repair, this method is called global repair involving global parity, because the entire set of disks participates in forming the parity check. If only a subset of disks participates in redundancy calculations and subsequent repair, the code is called locally repairable, because parity is local to the subset of disks.

[0011] It needs to have tolerance for more than two disk failures while still providing high I / O performance. Summary of the Invention

[0012] Various aspects provide a graph-based erasure coding model based on polyhedra, which uses bitwise XOR operations to encode and decode data, and redundantly distributes data and parity checks across different data storage media.

[0013] A method is provided that comprises: dividing a data stripe into a plurality of data stripe units, wherein the number of data stripe units is equal to the number of vertices of a polyhedron, and a corresponding data stripe unit in the data stripe unit corresponds to a corresponding vertex of the polyhedron; constructing a plurality of parity checks, wherein the number of parity checks is equal to the number of faces of the polyhedron, and a corresponding parity check in the plurality of parity checks corresponds to a face of the polyhedron, wherein the corresponding parity check in the plurality of parity checks is constructed by computational operations on the data stripe unit corresponding to the vertex of the face associated with the corresponding parity check of the polyhedron; and distributing subsets of data stripe units and subsets of parity checks to subsets of storage medium.

[0014] According to one aspect, the method described in the preceding paragraph is provided, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron.

[0015] According to one aspect, a method based on one of the preceding two paragraphs is provided, wherein the computational operation is XOR.

[0016] According to one aspect, a method based on one of the preceding three paragraphs is provided, wherein the computational operation is an arithmetic, comparison, or logical operation.

[0017] According to one aspect, a method according to one of the preceding four paragraphs is provided, wherein distributing a subset of data stripe cells and a subset of parity to a subset of storage medium includes distribution according to a rotational distribution pattern.

[0018] According to one aspect, a method according to one of the preceding five paragraphs is provided, the method comprising reconstructing a data stripe cell corresponding to a vertex by performing an XOR operation on a parity check corresponding to a face associated with a vertex of the polyhedron and on a data stripe cell corresponding to the remaining vertices of the face associated with the parity check of the polyhedron.

[0019] According to one aspect, a method according to one of the preceding six paragraphs is provided, the method comprising reconstructing a face of a data stripe cell corresponding to a vertex by performing an XOR on the parity check corresponding to the face associated with the vertex of the polyhedron.

[0020] According to one aspect, a method according to one of the preceding seven paragraphs is provided, the method comprising edge reconstruction of data stripe cells corresponding to vertices of a polyhedron, wherein the vertex is associated with a first joining edge of the polyhedron, the first joining edge being associated with a neighboring face of the polyhedron, and the first joining edge being associated with a first disjoint vertex opposite to the vertex, wherein the vertex is associated with a second joining edge of the polyhedron, the second joining edge being associated with the neighboring face of the polyhedron, and the second joining edge being associated with a second disjoint vertex opposite to the vertex, wherein the edge reconstruction is performed by determining the edge by performing an XOR operation on the parity checksum corresponding to the first neighboring face and the data stripe cell corresponding to the vertex associated with the first neighboring face, rather than the vertex associated with the first disjoint edge. The calculation of a first non-intersecting edge, wherein the first non-intersecting edge is an edge of the polyhedron associated with the neighboring face and the first adjacent face, and one of the two vertices of the first non-intersecting edge is the first non-intersecting vertex; the calculation of a second non-intersecting edge, wherein the second non-intersecting edge is an edge of the polyhedron associated with the neighboring face and the second adjacent face, and one of the two vertices of the second non-intersecting edge is the second non-intersecting vertex; and the calculation of the first non-intersecting edge, the calculation of the second non-intersecting edge, and the calculation of the parity corresponding to the neighboring face, wherein the data stripe cell corresponding to the vertex is determined by XORing the calculation of the first non-intersecting edge, the calculation of the second non-intersecting edge, and the parity corresponding to the neighboring face.

[0021] According to one aspect, a method is provided based on one of the preceding eight paragraphs, which includes nesting polyhedral volumes with different levels of RAID or erasure-decoded volumes.

[0022] According to one aspect, an apparatus is provided, the apparatus comprising: a plurality of storage media; an erasure decoding controller, the erasure decoding controller comprising: a processor; a memory storing computer-readable instructions, which, when executed by the processor, cause the processor to: divide a data stripe into a plurality of data stripe units, wherein the number of data stripe units is equal to the number of vertices of a polyhedron, and each data stripe unit corresponds to a vertex of the polyhedron; construct a plurality of parity checks, wherein the number of parity checks is equal to the number of faces of the polyhedron, and a corresponding parity check in the plurality of parity checks corresponds to a face of the polyhedron, wherein a corresponding parity check in the plurality of parity checks is constructed by computational operations on the data stripe unit corresponding to the vertex of the face of the polyhedron corresponding to the corresponding parity check; and distribute subsets of data stripe units and subsets of parity checks to subsets of storage media.

[0023] According to one aspect, an apparatus as described in the preceding paragraph is provided, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron.

[0024] According to one aspect, an apparatus as described in one of the preceding two paragraphs is provided, wherein the computational operation is XOR.

[0025] According to one aspect, an apparatus is provided as described in one of the preceding three paragraphs, wherein the computational operation is an arithmetic, comparison, or logical operation.

[0026] According to one aspect, an apparatus is provided as described in one of the preceding four paragraphs, wherein distributing a subset of data stripe cells and a subset of parity cells to a subset of storage medium comprises distributing them according to a rotational distribution pattern.

[0027] According to one aspect, an apparatus is provided as described in one of the preceding five paragraphs, wherein the plurality of storage media includes media selected from hard disks, solid-state drives, pen drives, Blu-ray discs, SD cards, CD drives, DVD drives, random access memory, memory cards, non-volatile memory modules, floppy disks, disk arrays, paper storage, optical disc drives, and magnetic tapes.

[0028] According to one aspect, an apparatus is provided according to one of the preceding six paragraphs, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: reconstruct the data stripe cell corresponding to the vertex by performing an XOR operation on the parity check corresponding to the face associated with the vertex of the polyhedron and the data stripe cell corresponding to the remaining vertices of the face associated with the parity check of the polyhedron.

[0029] According to one aspect, an apparatus is provided according to one of the preceding seven paragraphs, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: reconstruct the face of the data stripe cell corresponding to the vertex by performing an XOR operation on the parity check corresponding to the face of the vertex associated with the polyhedron.

[0030] According to one aspect, an apparatus is provided according to one of the preceding eight paragraphs, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: reconstruct edges of data stripe cells corresponding to vertices of a polyhedron, wherein the vertex is associated with a first joining edge of the polyhedron, the first joining edge being associated with a neighboring face of the polyhedron, and the first joining edge being associated with a first non-intersecting vertex opposite to the vertex, wherein the vertex is associated with a second joining edge of the polyhedron, the second joining edge being associated with the neighboring face of the polyhedron, and the second joining edge being associated with a second non-intersecting vertex opposite to the vertex, wherein the edge reconstruction is performed by: relative to the parity sum corresponding to the first neighboring face and the vertex associated with the first neighboring face, rather than the vertex associated with the first non-intersecting edge. The first non-intersecting edge is calculated by XORing the corresponding data stripe unit, wherein the first non-intersecting edge is the edge of the polyhedron associated with the neighboring face and the first adjacent face, and one of the two vertices of the first non-intersecting edge is the first non-intersecting vertex; the second non-intersecting edge is calculated by XORing the parity check corresponding to the second adjacent face and the data stripe unit corresponding to the vertex associated with the second adjacent face instead of the vertex associated with the second non-intersecting edge, wherein the second non-intersecting edge is the edge of the polyhedron associated with the neighboring face and the second adjacent face, and one of the two vertices of the second non-intersecting edge is the second non-intersecting vertex; and the data stripe unit corresponding to the vertex is determined by XORing the calculation of the first non-intersecting edge, the calculation of the second non-intersecting edge and the parity check corresponding to the neighboring face.

[0031] According to one aspect, an apparatus is provided as described in one of the preceding nine paragraphs, the apparatus comprising nesting polyhedral volumes with different levels of RAID or erasure-decoded volumes.

[0032] One aspect provides a system comprising: a data storage network including: a plurality of storage nodes; a gateway erasure decoding accelerator including: a processor; and a memory storing computer-readable instructions that, when executed by the processor, cause the processor to: divide a data stripe into a plurality of data stripe units, wherein the number of data stripe units is equal to the number of vertices of a polyhedron, and a corresponding data stripe in the data stripe unit corresponds to a vertex of the polyhedron; construct a plurality of parity checks, wherein the number of parity checks is equal to the number of faces of the polyhedron, and a corresponding parity check in the plurality of parity checks corresponds to a face of the polyhedron, wherein a corresponding parity check is constructed by computational operations on the data stripe unit corresponding to the vertex of the face associated with each parity check of the polyhedron; and distribute subsets of data stripe units and subsets of parity checks to subsets of storage nodes in the plurality of storage nodes.

[0033] According to one aspect, a system is provided as described in the preceding paragraph, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron, wherein the computational operation is an XOR, wherein the computational operation is an arithmetic, comparison, or logical operation, and wherein distributing subsets of data stripe cells and parity subsets to subsets of storage nodes includes distribution according to a rotational distribution pattern.

[0034] According to one aspect, a system is provided as described in one of the preceding two paragraphs, wherein the plurality of storage nodes includes nodes selected from hard disks, solid-state drives, pen drives, Blu-ray discs, SD cards, CD drives, DVD drives, memory cards, non-volatile memory modules, floppy disks, disk arrays, paper storage, optical disc drives, and magnetic tapes.

[0035] According to one aspect, a system is provided according to one of the preceding three paragraphs, wherein the memory stores computer-readable instructions that, when executed by the processor, cause the processor to: reconstruct data stripe units corresponding to the vertices of the polyhedron through a reconstruction process selected from face reconstruction, vertex reconstruction, and edge reconstruction. Attached Figure Description

[0036] The accompanying figure illustrates an example of a polyhedral-based graph-based erasure coding model that uses bitwise XOR operations to encode and decode data and redundantly distributes data and parity checks across different data storage media.

[0037] Figure 1 A block diagram of a storage system with erasure decoding controller and nodes is shown.

[0038] Figure 2A block diagram of a storage system with a gateway node and multiple storage nodes is shown. The gateway node has an erasure coding accelerator, and the gateway node and storage nodes are connected via a network.

[0039] Figure 3A A tetrahedral erasure code model with four input data streams and four parity checks is shown.

[0040] Figure 3B Instructions were shown Figure 3A The model describes how to generate four parity tables by XORing the data input stream.

[0041] Figure 3C It shows Figure 3A The tetrahedral parity check calculation of the tetrahedral code model shown.

[0042] Figure 3D It shows Figure 3A The model shown is a tetrahedral volume, i.e., eight-drive data and a rotational parity distribution.

[0043] Figure 3E It shows that it is based on Figure 3A The model is a tetrahedral roll, in which three drivers have failed.

[0044] Figure 3F It shows Figure 3E The tetrahedral volume of the driver identified in the middle is the data reconstruction of the three-fault driver.

[0045] Figure 4A A cube code model with eight input data streams and six parity checks is shown.

[0046] Figure 4B It shows Figure 4A The corresponding parity check name and value are indicated in the code.

[0047] Figure 4C It shows Figure 4A Parity check calculation for the cube code model shown.

[0048] Figure 4D It shows Figure 4A The model consists of a cube volume, i.e., fourteen-drive data and a rotational parity distribution.

[0049] Figure 4E It shows the basis Figure 4A The model is a cube volume in which three drives have failed.

[0050] Figure 4F The refactoring data for the faulty driver is shown: Figure 4E The drives identified in the text are drive 1, drive 5, and drive 9.

[0051] Figure 5A A dodecahedral code model with twenty input data streams and twelve parity checks is shown.

[0052] Figure 5B It shows Figure 5A The name and value of the corresponding parity check.

[0053] Figure 5C It shows Figure 5A The dodecahedral parity check calculation of the dodecahedral code model shown.

[0054] Figure 5D It shows Figure 5A The model's dodecahedral volume, i.e., the 32-driver data and rotation parity distribution.

[0055] Figure 5E It shows the basis Figure 5A The model is a dodecahedral roll, in which five drivers have failed.

[0056] Figure 5F The refactoring data for the faulty driver is shown: Figure 5E The drivers identified in the text are Driver 4, Driver 5, Driver 6, Driver 7, and Driver 8.

[0057] Figure 6 A flowchart of the write workflow is shown.

[0058] Figures 7A to 7C A flowchart of the tetrahedral reconstruction / reading workflow is shown, in which data stripe cells are reconstructed for reading, and data and parity stripe cells are reconstructed for reconstruction.

[0059] Figures 8A to 8C A flowchart of the cube's reconstruction / reading workflow is shown, in which data stripe cells are reconstructed for reading, and data and parity stripe cells are reconstructed for reconstruction.

[0060] Figures 9A to 9D A flowchart of the reconstruction / reading workflow of a dodecahedron is shown, in which data stripe cells are reconstructed for reading, and data and parity stripe cells are reconstructed for reconstruction.

[0061] Figure 10 The characteristics of various parameters are shown: RAID 5 volume, RAID 6 volume, tetrahedral volume, cube volume, and dodecahedral volume.

[0062] Figure 11 A graph showing the read computational overhead in XOR is presented, where the number of XOR operations is plotted against the number of disk failures.

[0063] Figure 12 Performance estimates (X times a single drive) for various parameters are shown.

[0064] Figure 13 Heterogeneous nesting is shown.

[0065] Figure 14 Uniform nesting is shown.

[0066] Figure 15 This illustrates a nested approach with polyhedrons as the secondary coding level and RAID1 as the primary coding level.

[0067] Reference numerals for any illustrated element appearing in multiple different figures have the same meaning in all figures, and any reference or discussion of any illustrated element in the context of any particular figure also applies to every other figure (if any) in which the same illustrated element is shown. Detailed Implementation

[0068] According to various aspects of the present invention, a polyhedron-based graph-based erasure coding model is provided, which uses computational operations to encode and decode data and redundantly distributes data and parity checks across different data storage media. The model can be based on polyhedra, including regular polyhedra. Regular polyhedra are a subset of polyhedrons, distinguished primarily by the fact that all faces, edges, and corners are symmetrical. Symmetry provides equal fault tolerance regardless of whether the combination of storage medium cells fails.

[0069] Non-regular polyhedra can provide asymmetric fault tolerance based on combinations of storage medium cell failures. A polyhedron can have face asymmetry, where the generated parity check can have varying amounts of redundancy embedded within it (based on the number of vertices on that face). This can affect the volume's fault tolerance because the faces have different levels of added redundancy. Considering all combinations of missing faces and vertices, the volume's fault tolerance can be determined by the minimum possible fault tolerance.

[0070] Various aspects offer tolerances starting at three for cubes, three for tetrahedrons, and four for dodecahedrons.

[0071] Nesting levels are provided for various aspects. Polyhedral volumes can be used as primary or secondary levels in nested encoding formats. Figure 13 Heterogeneous nesting is shown. Figure 14 Uniform nesting is shown. Figure 15This illustrates nesting with polyhedrons as secondary coding levels and RAID 1 as the primary coding level. The primary coding level indicates the coding level that directly uses a single storage medium as the storage source. Non-primary coding levels are coding levels that use other coded volumes as storage sources. Each such primary coded volume is called a branch forming a non-primary volume. Polyhedron volumes can be configured for heterogeneous or uniform nesting. Nesting is heterogeneous if all participants at a given coding level are of different coding types. Nesting is uniform if all participants at a given coding level are of the same coding type. Polyhedron volumes can be nested with volumes of different RAID levels or erasure-decoded volumes. The fault tolerance of the entire nested volume is given by the minimum fault tolerance of each individual branch. They can also be used in nested levels to provide better fault tolerance per branch. Nested levels indicate the fault tolerance applied in more than one layer. Using RAID as an example, RAID 10, RAID 50, RAID 60, RAID 11, RAID 51, and RAID 61 are nested RAID levels. For example, RAID 50 is a nested RAID level, where RAID 5 is the primary RAID level and RAID 0 indicates a secondary RAID level. There can be three disks, forming one branch of a volume implementing RAID 5 (the primary RAID level). Additional layers of RAID 0 can be applied over multiple branches of RAID 5. Therefore, the benefits of two RAID levels can be seen in nested RAID levels.

[0072] This paper presents a method for introducing redundancy and storing data across multiple storage media to provide better fault tolerance and higher performance. The data stripe to be stored is divided into multiple smaller data stripe units, and the corresponding stripe units are stored in different storage media (such as disks). These data stripe units can represent vertices of a polyhedron. To introduce data redundancy, multiple parity checks can be computed and stored. The computed parity checks can represent the corresponding faces of the polyhedron. To compute a given parity check, all data stripe units representing the vertices of that face of the polyhedron are encoded using a symmetric parity encoding and decoding method; in one example, this symmetric parity encoding and decoding method is bitwise XOR. The number of parity checks generated can be given by the number of faces of the polyhedron. The data stripe units of a given stripe unit and the generated parity checks can be distributed across different storage media. For example, a tetrahedron consists of four vertices and four faces, and therefore four parity checks are computed using three data vertices of the corresponding parity checks. For up to three disk failures, the remaining data stripe units and parity checks can be used to reconstruct the entire tetrahedron. To reconstruct a given parity check face P of a tetrahedron, adjacent faces, coincident edges, or constituent vertices of the tetrahedron are sufficient. This method uses bitwise XOR operations for encoding and decoding, which is computationally simple, associative, and provides fast performance. The tetrahedron has a tolerance of three, the cube has a tolerance of three, and the dodecahedron has a tolerance of five.

[0073] A polyhedron is a geometric shape and can be mathematically represented as a function of vertices and faces (V, F), where V represents the set of vertices and F represents the set of faces. A volume is a logical construct of physical storage media grouped together to exhibit a pattern of data distribution and redundancy. For example, if three physical storage media exist using a distribution pattern as outlined by RAID 5, the logical construct providing combined redundancy is called a RAID 5 volume. In the case of a polyhedron providing a distribution pattern, the logical construct using physical storage media to implement the polyhedron code is called a polyhedral volume.

[0074] A fault-tolerant volume is represented by a polyhedron (V, F) consisting of a data set (V) and a parity set (F), such that the total number of storage disks in the volume is given by |V| + |F|. |V| is a mathematical notation indicating the count of elements in the vertex set (V). |F| is a mathematical notation indicating the count of elements in the parity set (F). In the absence of disk failures in the volume, (V) data stripe units can be read from individual storage disks (media) without any computational overhead for reconstruction. If the corresponding face of the polyhedron F has M vertices, then for up to |M| ± 1 (M-1 to M+1) storage disk (media) failures, missing data stripe units can be reconstructed using a bitwise XOR operation based on the specific polyhedron. This is used both for data reading and for rebuilding the volume when the failed storage disk (media) has been replaced. The storage overhead is given by (|V| + |F|) / |F|.

[0075] A polyhedron can be identified by a code (N, K, D), where N represents the total number of individual storage media units (e.g., disks or drives), K represents the number of data vertices, and D represents the fault tolerance of individual storage media units. For a tetrahedron, the code is (8, 4, 3), which has eight individual storage media units (e.g., disks or drives), four data vertices, and tolerates up to three individual storage media unit failures. A total of eight (8) disks are needed to distribute the data modeled as a tetrahedron, which is the sum of the vertices (4) and faces (4) of a tetrahedron representing four data and four parity stripe units. For a "cube"-based erasure code, the code is (14, 8, 3), which has fourteen individual storage media units (e.g., disks or drives), eight data vertices, and tolerates up to three individual storage media unit failures. A total of fourteen (14) disks are needed to distribute the data modeled as a cube, which is the sum of the vertices (8) and faces (6) of a cube representing eight data and six parity stripe units. For a dodecahedron, the code is (32, 20, 5), which contains thirty-two individual storage medium cells (e.g., disks or drives), twenty data vertices, and is tolerant of failures of up to five individual storage medium cells. A total of thirty-two (32) disks are needed to distribute the data modeled as a dodecahedron, which is the sum of the vertices (20) and faces (12) of the dodecahedron representing twenty data and twelve parity stripe cells. Data and parity can be stored in the storage medium according to any storage mode. Two example distribution modes of data and parity across different media include: (1) interleaving media with both data and parity in a rotating manner; and (2) storing parity in a dedicated medium and storing data on different sets of dedicated media.

[0076] The degree of fault tolerance, given by the number of vertices on the face of a polyhedron, can be greater than two. For example, in a tetrahedron, the degree of fault tolerance can be three. Using a tetrahedron as an example, data can be reconstructed after one, two, and three random media failures.

[0077] The aspects provide graph-based erasure codes modeled on a polyhedron using XOR (binary exclusive OR) operations. The aspects can provide a fault tolerance level greater than two (2). The aspects can offer high performance and low computational overhead for high I / O performance. The aspects can provide the option to delay the start of volume rebuild after multiple disk failures. In contrast to RAID, where a RAID volume is typically degraded due to a single drive failure and a suitable replacement for the failed disk is found, the storage controller automatically triggers volume rebuild. Using polyhedron codes, polyhedron volume rebuild can be programmed on the storage controller to initiate automatically only after it has crossed a threshold number of failed disks, which can be less than or equal to the total fault tolerance provided by the polyhedron. Rebuild may be delayed because a degraded polyhedron volume may not see an immediate performance degradation, but rather a gradual performance degradation proportional to the number of disk failures.

[0078] Local repairability can be provided in various ways to reduce overhead during reconstruction. There are two widely used methods for repairing volumes by reconstructing data on the missing disks: global repair and local repair. In global repair, all other surviving disks are read to reconstruct the missing data. This is similar to parity calculation techniques that use all data disks to generate parity (example RAID 5). The advantage of local repair is that fewer disks are read to reconstruct a given missing data segment compared to reading all disks in a global repair scenario. This reduces the amount of data movement used for reconstruction and frees up disk bandwidth for host I / O. As a result, host I / O performance will be better while the volume is being rebuilt, and the reconstruction will be faster because less data movement is involved in the reconstruction.

[0079] The feasibility of implementation can be achieved by utilizing the XOR operation available in existing hardware RAID auxiliary engines. Other computational operations (e.g., arithmetic operations such as +, -, ...) can also be used. Comparison (<, >, =, but not limited to) or logic (AND, OR, XOR, but not limited to) operations can be used with existing hardware RAID auxiliary engines.

[0080] As indicated above, polyhedral codes are a type of erasure coding model that establishes relationships between different subsets of stored data by creating redundancy based on those subsets. A polyhedron is a geometric figure represented by (V, F). Polyhedral codes (N, K, D) are a family of graph erasure codes based on the geometric concept of a polyhedron (V, F), where N = |V| + |F|, K = |V|, and D = |M| ± 1, where |M| indicates the number of vertices in a given face of the polyhedron. Polyhedral codes are correlated in encoding / decoding by using XOR instead of polynomial equations in the Galois domain to compute parity, thus significantly reducing computational overhead. Parity calculated across different disk distributions and data can be efficiently utilized using a rotating distributed parity mechanism similar to RAID5 to take advantage of all underlying disks.

[0081] One aspect provides a family of polyhedra for erasure coding. Another aspect provides an algorithm for encoding / decoding and reconstructing data that makes up a disk. The aspects also provide a graph-based system erasure coding model and algorithm for polyhedral-based encoding / decoding and reconstruction. The other aspect provides a computationally efficient method for parity checking calculation of erasure codes. Specific implementations of polyhedral codes with methods for distributing data and parity checking exist. According to one aspect, a distribution model for sets of data stripe units and their corresponding parity checks is provided. Fixed array geometries of 8, 14, and 32 disks with volumes exhibiting storage overheads of 2x, 1.75x, and 1.6x respectively can indicate that polyhedral codes are being used. Furthermore, if a fixed data pattern is written to the volume, the appearance of the XOR value of the subset of data that makes up the disk can be a clear indication of polyhedral codes in use.

[0082] This method and algorithm can be used by a storage controller that provides fault tolerance for the underlying disks connected to it. It can also be used by a storage accelerator that aggregates and accelerates input / output (I / O) to storage devices connected to the system. Furthermore, it can be used by distributed network storage products that provide fault protection for storage nodes. The method and algorithm can be implemented in the I / O path to encode, distribute, and read data according to a polyhedral code for decoding and reconstruction.

[0083] Figure 1 A block diagram of a storage system 100 with a polyhedral erasure decoding controller 100 and a storage disk 120 is shown. In this case, the corresponding storage medium is the storage disk 120, which may include any number (N) of storage disks 120. All or a subset of the disks 120 may be included in an erasure-decoded volume 122.

[0084] Figure 2 A block diagram of a storage system 200 with a gateway node 214 is shown, the gateway node having a polyhedral erasure coding accelerator 212 and a plurality of storage nodes 220 providing several bytes of data storage, wherein the gateway node 214 and the storage nodes 220 are connected via a network 202.

[0085] Figure 3A A tetrahedral code model with four input data streams is shown, where the corresponding data streams represent data stripe units: data 1, data 2, data 3, and data 4, i.e., the data stripe is divided into 4 data stripe units. This model is based on a "regular tetrahedral" erasure code. Specifically, the erasure code is an (8, 4, 3) code, where eight storage medium units are used, four data vertices are used, and the resulting four parity-checking vertices are represented by the vertices, and it can tolerate up to three individual storage medium unit failures. The method utilizing the tetrahedral code model is based on... Figure 3B The parity check shown generates four parity checks: Parity 1, Parity 2, Parity 3, and Parity 4. Specifically, Parity 1 is calculated based on data 1, data 2, and data 3, for example, data 1 XOR data 2 XOR data 3; Parity 2 is calculated based on data 2, data 3, and data 4, for example, data 2 XOR data 3 XOR data 4; Parity 3 is calculated based on data 3, data 4, and data 1, for example, data 3 XOR data 4 XOR data 1; and Parity 4 is calculated based on data 4, data 1, and data 2, for example, data 4 XOR data 1 and data 2. Specific implementations include rotated parity and fixed parity distribution. Once the polyhedral model is constructed, the order of vertex and parity distribution across the various storage disks is determined. In the case of rotated parity, a parity shift factor is used to determine the rotation offset, distributing the parity across the storage disks in a rotated manner.

[0086] Figure 3B It shows Figure 3A The tetrahedral parity check calculation of the tetrahedral code model shown. Figure 3A The data layout is shown geometrically on a regular tetrahedron, and visually represented as the data and parity corresponding to the 3D entity, where each vertex is associated with and labeled with a data <identifier>. Each face represents the parity check using the parity <identifier>. Figure 3B It shows Figure 3AThe table shown represents the information corresponding to a complete data strip and indicates the parity calculation. The relationship between a given parity <identifier> and three data <identifiers> is indicated in the table. The corresponding face of the tetrahedron has three vertices, which are associated with the corresponding face of the tetrahedron corresponding to the parity check. These three vertices participate in the XOR operation to generate the parity check, and the "circle +" indicates a bitwise XOR operation. Figure 3B In the diagram, each line indicates the various data elements involved in calculating parity. Four lines combined represent a complete polyhedron. A complete stripe of a data volume represents a complete polyhedron. Figure 3B This shows a complete data stripe and parity check corresponding to a tetrahedron. Figure 3C It shows Figure 3B The information in the data (tetrahedron 1) and the data and parity check corresponding to the additional seven tetrahedrons representing the total eight tetrahedrons of the data volume. Figure 3D In this context, eight complete data stripes and parity checks are distributed across eight storage drives, representing the entire data volume.

[0087] Figure 3D This diagram illustrates the data and rotational parity distribution of an 8-drive tetrahedral volume. Corresponding cells represent the corresponding data stripe cells that make up the storage medium. Corresponding rows represent the corresponding data stripes on the tetrahedral volume. Four rows correspond to a complete tetrahedron. The parity shift factor between stripes is equal to 1. The parity shift factor indicates which stripes are to be used as consecutive data stripes. Figure 3D The number of disks used to store parity in a rotational manner, representing the offset between each row (on the disk). For example, consider... Figure 3D The first two rows of the table. The first row, or stripe 1, contains: data 1, data 2, data 3, data 4, parity 1, parity 2, parity 3, and parity 4. The second row, or stripe 2, contains: parity 8, data 5, data 6, data 7, data 8, parity 5, parity 6, and parity 7. In the first row or stripe 1, the first data element is stored in column 1 (store drive 1), and the first parity element (parity 1) is stored in column 5 (store drive 5). In the second row or stripe 2, a parity shift factor of 1 is applied, as it applies to each subsequent row. Therefore, the first data element of stripe 2 is stored in column 2 (store drive 2), and the first parity element of stripe 2 is stored in column 6 (store drive 6). Essentially, between two stripes or rows, the positions of the various elements are shifted to the right by one offset (parity shift factor = 1), while the order of the stripe cells (the individual cells in the table) within the row remains constant.

[0088] exist Figure 3DIn the case of the rotated parity distribution shown, the parity is distributed across different columns (storage disks). Within a given column (storage disk), both data stripes / parity are stored for different data stripes / parity.

[0089] Under the condition of a fixed parity distribution (not shown), Figure 3D There will be columns (storage disks) that store only data or parity data, and not both. Storage disks 1, 2, 3, and 4 will be used to store data stripe units, and storage disks 5, 6, 7, and 8 will be used to store parity stripe units. The same operation will be repeated in each row indicating consecutive stripes.

[0090] Figure 3E It shows Figure 3D In this example, three drives have failed. In this example, drive 1, drive 2... and drive 3 A malfunction has occurred, including " This indicates that the storage drive has failed.

[0091] Figure 3F It shows how to refactor Figure 3E The data of the failed drive. In this example, X'-X is reconstructed before being used with pipelined operations. When multiple failed storage disks exist, as in this example case, multiple data / parity stripe units are missing and need to be reconstructed. The order in which stripe unit reconstruction begins is determined based on the elements involved in the reconstruction. If a reconstruction participant is also missing, the missing participant can be reconstructed first. X' is the reconstruction of X and indicates that X should be reconstructed before X can be used as a participant in another reconstruction operation. Figure 3F Example of storage drive 1 2 and 3 Refactoring that has already failed.

[0092] Figure 4A A polyhedral model with a cube example is shown, which has eight input data streams, i.e., data stripes have been divided into eight data stripe units and six parity checks associated with the cube model. The model is based on erasure coding of a "cube". Specifically, the model is a (14, 8, 3) code, where fourteen storage medium units will be used, eight vertices represent the data, the resulting six parity check representation faces, and it is tolerant of up to three individual storage medium unit failures. Figure 4B It shows Figure 4AThe corresponding parity check name and value are identified in the code. Specifically, parity check 1 is calculated based on data 1, data 2, data 3, and data 4, for example, data 1 XOR data 2 XOR data 3 XOR data 4; parity check 2 is calculated based on data 2, data 6, data 7, and data 3, for example, data 2 XOR data 6 XOR data 7 XOR data 3; parity check 3 is calculated based on data 3, data 4, data 8, and data 7, for example, data 3 XOR data 4 XOR data 8 XOR data 7; parity check 4 is calculated based on data 5, data 6, data 2, and data 1, for example, data 5 XOR data 6 XOR data 2 XOR data 1; parity check 5 is calculated based on data 5, data 6, data 7, and data 8, for example, data 5 XOR data 6 XOR data 7 XOR data 8; and parity check 6 is calculated based on data 4, data 1, data 5, and data 8, for example, data 4 XOR data 1 XOR data 5 XOR data 8. The specific implementation includes rotating parity check and fixed parity check distribution.

[0093] Figure 4C It shows Figure 4A The parity check calculation for the cube code model shown is as follows. Each face of the tetrahedron has four vertices, which are associated with the corresponding parity check face of the cube. These four vertices participate in the XOR operation to generate the parity check, and the "circle +" indicates the bitwise XOR operation. Figure 4B The parity check is shown for a data stripe. Figure 4C The diagram shows the same data stripe used for a total of four binary XOR parity calculation stripes, plus three additional data stripes. Each stripe has six parity values ​​and eight data values, thus the four stripes constitute twenty-four parity values. Figure 4C Described in Figure 4D , Figure 4E and Figure 4F The parity calculations for all parity checks seen in the image. Figure 4C Four sets of data are shown, corresponding to parity checks 1 to 6, 7 to 12, 13 to 18, and 19 to 24 for four cubic polyhedra.

[0094] Figure 4D The cube volume, i.e., 14 drives, is shown with its data and rotational parity distribution. The corresponding cell represents the corresponding data stripe cell that makes up the storage medium. The corresponding row represents the corresponding data stripe on the cube volume. The parity shift factor between stripes is equal to one (1).

[0095] Figure 4E The diagram shows a cube volume, i.e., a 3-drive failure, where drive 1... 5 drives and driver 9 A malfunction has occurred.

[0096] Figure 4F It shows how to refactor Figure 4E The data of the failed drive. When multiple failed storage disks exist, as in this example case, multiple data / parity stripe cells are missing and need to be reconstructed. The order in which stripe cell reconstruction begins is determined based on the elements involved in the reconstruction. If a reconstruction participant is also missing, the missing participant can be reconstructed first. X' is the reconstruction of X and indicates that X should be reconstructed before X can be used as a participant in another reconstruction operation. Figure 4F Example of storage drive 1 5 and 9 Reconstruction of a failed system. Here, parity 12, data 12, and data 16 are missing and need to be reconstructed. Data 12 and data 16 can be reconstructed first because all reconstructing participants in their reconstruction process exist in the non-failed storage drive. The reconstructed data 12 and data 16 are indicated by single quotes as data 12' and data 16'. However, data 12 and data 16 are participants in the reconstruction of parity 12, so data 12 and data 16 need to be reconstructed first before attempting to reconstruct parity 12. Therefore, after data 12 and data 16 have been reconstructed, parity 12 can be reconstructed in the second iteration, indicated by parity 12".

[0097] Parity check 12" = data 12' ⊕ data 9 ⊕ data 13 ⊕ data 16'

[0098] Data 12' = Parity Check 7 ⊕ Data 9 ⊕ Data 10 ⊕ Data 11

[0099] Data 16' = Parity check 11 ⊕ Data 13 ⊕ Data 14 ⊕ Data 15

[0100] Figure 5A A dodecahedral code model with twenty input data streams is shown, i.e., the data stripes are divided into 20 data stripe units. This model is based on erasure coding of a "regular dodecahedron". Specifically, the model is a (32, 20, 5) code, where 32 storage medium units and 20 data vertices are used, with 12 parity-checking vertices resulting from the resulting data, and it is tolerant of up to five individual storage medium unit failures. Figure 5BThis demonstrates how to calculate 12 parity checks. Specifically, parity check 1 is calculated based on data 1, data 2, data 3, data 4, and data 5, for example, data 1 XOR data 2 XOR data 3 XOR data 4 XOR data 4; parity check 2 is calculated based on data 1, data 6, data 7, data 8, and data 2, for example, data 1 XOR data 6 XOR data 7 XOR data 8 XOR data 2; parity check 3 is calculated based on data 2, data 8, data 9, data 10, and data 3, for example, data 2 XOR data 8 XOR data 9 XOR data 10 XOR data 3; parity check 4 is calculated based on data 3, data 10, data 11, data 12, and data 4, for example, data 3 XOR data 10 XOR data 11 XOR data 12 XOR data 4; and parity check 5 is calculated based on data 4, data 12, data 13, data 14, and data 5, for example, data 4 XOR data 12 XOR data 13 XOR data 14. XOR data 5; Calculate parity 6 based on data 5, data 14, data 15, data 6, and data 1, for example, data 5 XOR data 14 XOR data 15 XOR data 6 XOR data 1; Calculate parity 7 based on data 6, data 7, data 16, data 20, and data 15, for example, data 6 XOR data 7 XOR data 16 XOR data 20 XOR data 15; Calculate parity 8 based on data 7, data 8, data 9, data 17, and data 16, for example, data 7 XOR data 8 XOR data 9 XOR data 17 XOR data 16; Calculate parity 9 based on data 9, data 10, data 11, data 18, and data 17, for example, data 9 XOR data 10 XOR data 11 XOR data 18 XOR data 17; Calculate parity 10 based on data 11, data 12, data 13, data 19, and data 18, for example, data 11 XOR data 12 XOR data 13 XOR data 19 XOR data 18; calculate parity 11 based on data 13, data 14, data 15, data 20, and data 19, for example, data 13 XOR data 14 XOR data 15 XOR data 20 XOR data 19; and calculate parity 12 based on data 16, data 17, data 18, data 19, and data 20, for example, data 16 XOR data 17 XOR data 18 XOR data 19 XOR data 20. Specific implementations include rotated parity distributions and fixed parity distributions.

[0101] Figure 5C It shows Figure 5AThe parity check calculation for the dodecahedral code model is shown. Each face of the dodecahedron has five vertices, which are associated with the corresponding parity check face of the dodecahedron. These five vertices participate in the XOR operation to generate the parity check, and the "circle +" indicates the bitwise XOR operation. Figure 5B The parity check is shown for a data stripe. Figure 5C The diagram shows the data stripe and the second data stripe used for a total of two binary XOR parity calculation stripes. Each stripe contains twenty data bits and twelve parity bits, resulting in a data volume of twenty-four parity bits. The "circled +" character indicates the binary XOR operation. Figure 5C Described in Figure 5D , Figure 5E and Figure 5F The calculation of all parity checks seen in the image.

[0102] Figure 5D The dodecahedral volume, i.e., 32-drive data and rotational parity distribution, is shown. The corresponding cell represents the corresponding data stripe cell that makes up the storage medium. The corresponding row represents the corresponding data stripe on the dodecahedral volume. The parity shift factor between stripes is equal to one (1).

[0103] Figure 5E It shows Figure 5D The example shows that five drives have failed. In this example, drives 4, 5, 6, 7, and 8 have failed.

[0104] Figure 5F It shows how to refactor Figure 5E Data from the faulty driver.

[0105] Figure 6A flowchart of the write workflow is shown. Data is transferred from the host 602 to the controller memory. The data stripes of the host data are divided 604 into data stripe units in a deterministic order, such as ascending order. The number of data stripe units is the number of vertices of the selected polyhedron. For example, if the selected polyhedron is a tetrahedron, the number of data stripe units is four. Then, parity checks are constructed 606, where all data stripe units representing the vertices of the corresponding face of the polyhedron are used to compute a given parity. In one example, the data stripe units of the vertices are bitwise XORed to compute the corresponding parity. The number of parity checks to be constructed is equal to the number of faces of the polyhedron. For example, if the selected polyhedron is a tetrahedron, the number of parity checks is four. Then it is determined whether all parity checks have been computed 608. If not, 610 is selected corresponding to the face of the polyhedron to be computed next. 612 is determined corresponding to the vertices of the selected face. The 614 parity checks are computed using a symmetric parity coding method, for example, by performing a computation operation on all selected data stripe units. The computation operation can be a bitwise XOR. Once it is determined that all 608 parities have been computed, the encoding of the 616 polyhedron (including encoding the data and computing the parities) is completed by iterating through boxes 608, 610, 612, and 612 multiple times to complete the various missing segments of the polyhedron, where each parity check is computed once per iteration. This is the exit condition for the encoding loop, which generates parities to enable the reconstruction of any missing entities (missing data and parities). The data stripe units and the computed parities are distributed 618 to different storage media forming the volume; one example distribution pattern is a rotated parity distribution pattern. Rotated parity distribution allows the use of drives during read workloads. In the case of dedicated parity, dedicated data disks can be used for read workloads, which may result in lower performance.

[0106] If data 1, data 2, data 3, and data 4 are missing (see...) Figures 3A to 3F Then, an example of face-based reconstruction of a given data stripe DS on a tetrahedral volume T can be performed as follows:

[0107] 1. V = (data1, data2, data3, data4)

[0108] F = (parity check 1, parity check 2, parity check 3, parity check 4)

[0109] MV = (data1, data2, data3, data4),

[0110] MF=().

[0111] 2. Next missing data strip cell = Data 1. Faces associated with Data 1 = (Parity 1, Parity 3, Parity 4)

[0112] 3. Data 1 = Parity 1 XOR Parity 3 XOR Parity 4

[0113] 4. MV = (data2, data3, data4)

[0114] 5. Next missing data strip cell = data 2. Faces associated with data 2 = (parity 4, parity 1, parity 2)

[0115] 6. Data 2 = Parity 4 XOR Parity 2 XOR Parity 1

[0116] 7.MV = (data 3, data 4)

[0117] 8. The next missing data strip cell = data 3. The face associated with data 3 = (parity 1, parity 2, parity 3).

[0118] 9. Data 3 = Parity 1 XOR Parity 2 XOR Parity 3

[0119] 10.MV = (Data 4)

[0120] 11. Next missing data strip cell = data 4. Faces associated with data 4 = (parity check 2, parity check 3, parity check 4)

[0121] 12. Data 4 = Parity2 XOR Parity3 XOR Parity4

[0122] 13.MV=(). All data stripe units have been reconstructed.

[0123] Figures 7A to 7CA flowchart illustrating the tetrahedral reconstruction / reading workflow is shown, where data stripe cells are reconstructed for reading, and where data and parity stripe cells are reconstructed for reconstruction. 702 identifies the data stripe DS(V,F) on the tetrahedral volume T to be read, where V is the set of vertices (v1,v2,v3,v4) representing the tetrahedron of the data stripe cell, and F is the set of faces (f1,f2,f3,f4) representing the tetrahedron of the parity stripe cell. 704 Reads the data stripe cells given by V=(v1,v2,v3,v4) and faces F=(f1,f2,f3,f4) from the constituent storage medium of the tetrahedral volume T. 706 Then determines whether any constituent storage medium in the constituent storage medium of volume T has failed. If no, meaning no component of the storage medium has failed, then 728 data stripe cells are read and concatenated in a deterministic order, such as ascending, of the data stripe cell distribution to form the requested data stripe DS. If yes, then 708 is determined to be the set of missing vertices MV belonging to V and the set of missing faces MF belonging to F, corresponding to the stripe cells stored on the failed / missing storage medium. Then it is determined whether the cardinality of 710 MV plus the cardinality of MF is greater than the fault tolerance level three (3). If yes, the data cannot be reconstructed, and the process ends. If no, then it is determined whether the cardinality of 712 MV is equal to zero. If yes, meaning the cardinality of MV is equal to zero, then 728 data stripe cells are read and concatenated in ascending order of the data stripe cell distribution to form the requested data stripe DS. If no, then face-based reconstruction of the missing vertices is performed. To reconstruct the missing vertices, it is determined whether the cardinality of 714 MV is equal to three, i.e., the number of vertices associated with the face. If not, perform vertex-based reconstruction, and if yes, determine 716 the next missing data stripe unit represented by the missing vertex v belonging to MV, such that all faces associated with v are not missing and belong to the set given by F minus MF (F-MF). This condition is to select vertices with associated faces that still exist. F indicates the set of all faces of the tetrahedron, and MF indicates all missing faces. F minus MF (F-MF) indicates the set of faces that exist (not missing). If all faces exist, then MF is an empty set. When the previous and current vertices are available for reconstruction. Reconstruct 718 the data stripe unit represented by v by XORing the three parity stripe units represented by the faces associated with vertex v. Remove vertex v from MV 720, and again determine whether the cardinality of MV is equal to zero. If vertex-based reconstruction is to be performed, determine 722 the parity stripe unit represented by face f in F minus MF (F-MF), such that only one missing associated vertex v belongs to MV in the set of vertices associated with f.The data stripe cell represented by v is reconstructed by XORing the parity stripe cell represented by f and the data stripe cells represented by other vertices of the MV that are not associated with f. The data stripe cell represented by v is removed from the MV, and the cardinality of the MV is determined again, 712. If so, the data stripe cells represented by v1, v2, v3, and v4, read from the constituent storage medium in ascending order of the data stripe cell distribution, are concatenated, 728, to form the requested data stripe DS. Then, it is determined, 730, whether parity reconstruction should be performed. If not, the requested data in the data stripe DS is transferred, 740, to the data requester; and if so, parity reconstruction is performed. For parity reconstruction, it is determined, 732, whether the cardinality of the MF is equal to zero, which suggests how many missing faces to reconstruct. If so, the requested data in the data stripe DS is transferred, 740, to the data requester. If not, then determine 734, the next missing parity stripe cell represented by the missing face f belonging to MF. Reconstruct 736, the parity stripe cell represented by f, by performing an XOR operation on the three data stripe cells represented by the vertices of V associated with f. Remove 738, the parity stripe cell represented by f, from MF.

[0124] Reconstruction can be iterative, and for a given reconstruction iteration with missing vertices, there may be multiple options for reconstructing using different sets of faces and vertices. The presence (non-missing) of the corresponding faces and vertices for a given combination can be a constraint on choosing the combination to use for reconstruction. Operationally, if the inputs for the combination exist, XOR may take the same amount of time regardless of the combination. If there is more than one missing entity in the face / vertices combination, the data may be unrecoverable because XORing a portion of the data set will not produce the original data. For each reconstruction iteration within the tolerance limit, there exists at least one combination where all input (vertices and / or faces) sets exist, and only the data to be reconstructed is missing. For combinations of missing drivers up to the tolerance limit, there exists at least one combination to recover the missing data.

[0125] If data stripe units (data 3, data 4, and data 5) are missing (see...) Figures 4A to 4F Then, an example of vertex-based reconstruction of a given data stripe DS on a cube volume C can be performed as follows:

[0126] 1. V = (data1, data2, data3, data4, data5, data6, data7, data8)

[0127] F = (parity check 1, parity check 2, parity check 3, parity check 4, parity check 5, parity check 6)

[0128] MV = (data 3, data 4, data 5),

[0129] MF=()

[0130] 2. The next missing data stripe cell = data 3. The parity stripe cell with only one missing data cell, f = parity 2.

[0131] 3. Data 3 = Parity 2 XOR Data 2 XOR Data 6 XOR Data 7

[0132] 4.MV = (data 4, data 5)

[0133] 5. Next missing data stripe cell = data 4. Parity stripe cell f with only one missing data cell = parity 1

[0134] 6. Data 4 = Parity 1 XOR Data 1 XOR Data 2 XOR Data 3

[0135] 7.MV = (Data 5)

[0136] 8. Next missing data stripe cell = data 5. Parity stripe cell with only one missing data f = parity 4

[0137] 9. Data 5 = Parity 4 XOR Data 6 XOR Data 2 XOR Data 1

[0138] 10.MV=(). All data stripe units have been reconstructed.

[0139] Figures 8A to 8CA flowchart illustrating the cube's reconstruction / reading workflow is shown, where data stripe cells are reconstructed for reading, and where data and parity stripe cells are reconstructed for reconstruction. At 802, the data stripe DS(V,F) on the cube volume C to be read is identified, where V is the set of vertices (v1,v2,v3,v4,v5,v6,v7,v8) representing the data stripe cells of the cube, and F is the set of faces (f1,f2,f3,f4,f5,f6) representing the parity stripe cells of the cube. 804 The data stripe cells given by V and the faces given by F are read from the constituent storage medium of cube volume C. Then, it is determined whether any constituent storage medium in volume T has failed. If no, meaning that no component storage medium has failed, the data stripe units represented by v1, v2, v3, v4, v5, v6, v7, v8, read from the component storage medium in ascending order of data stripe unit distribution are concatenated 820 to form the requested data stripe DS, and if yes, it is determined that 808 belongs to the set of missing vertices MV of V and the set of missing faces MF of F, which correspond to the stripe units stored on the failed / missing storage medium. Then it is determined whether the cardinality of 810 MV plus the cardinality of MF is greater than the fault tolerance level three (3). If yes, the data cannot be reconstructed and the process ends. If no, it is determined whether the cardinality of 812 MV is equal to zero. If yes, it means that the cardinality of MV is zero, and the data stripe units represented by v1, v2, v3, v4, v5, v6, v7, v8 read from the constituent storage medium in ascending order of data stripe unit distribution are concatenated 820 to form the requested data stripe DS, and if no, vertex-based reconstruction is performed. To reconstruct missing vertices, 814 parity stripe units represented by faces f in F minus MF are determined such that only one missing associated vertex v belongs to MV in the set of vertices to which f is associated. When there is a set of missing vertices or faces that need to be reconstructed, there may be more than one combination to reconstruct the data because there may be embedded redundancy of a given vertex in three faces. In a polyhedral code, there will be at least one combination in which a face and its corresponding vertex exist. The parity stripe units represented by faces f in F minus MF are determined by filtering incomplete combinations according to the following rules: (1) the vertex v to be reconstructed is associated with an existing face f; and (2) there are other vertices associated with face f. The 816 data stripe cells represented by v are reconstructed by XORing the parity stripe cells represented by f and the data stripe cells represented by other vertices of the MV that are not associated with f. The 818 data stripe cells represented by v are removed from the MV, and the cardinality of the 712 MV is determined again to be zero.If so, the data stripe cells represented by v1, v2, v3, v4, v5, v6, v7, v8, read from the constituent storage medium in ascending order of data stripe cell distribution are concatenated 820 to form the requested data stripe DS. Then, it is determined 822 whether parity reconstruction should be performed, depending on whether data is missing. If not, the requested data in the data stripe DS is transmitted 832 to the data requester, and if so, parity reconstruction is performed. For parity reconstruction, it is determined 824 whether the cardinality of MF is equal to zero, where MF indicates the set of missing faces, and if the cardinality of MF is equal to zero, there are no missing parities to be reconstructed. If so, the requested data in the data stripe DS is transmitted 832 to the data requester. If not, the next missing parity stripe cell represented by the missing face f belonging to MF is determined 826. The parity stripe cell represented by f is reconstructed 828 by XORing the four data stripe cells represented by the vertices of V associated with f. Remove 830 parity stripe cells denoted by f from MF.

[0140] If data stripe units (data 1, data 2, data 3, data 4, data 5, and data 6) are missing (see [link to documentation]). Figures 5A to 5F Then, an example of edge-based reconstruction of a given data strip DS on a dodecahedral volume D can be performed as follows:

[0141] 1. V = (data1, data2, ..., data19, data20)

[0142] F = (parity check 1, parity check 2, ..., parity check 11, parity check 12)

[0143] MV = (data1, data2, data3, data4, data5, data6)

[0144] MF=()

[0145] 2. Next missing data stripe cell = data 6. Parity stripe cell f with only one missing data cell = parity 7.

[0146] 3. Data 6 = Parity 7 XOR data 7 XOR data 16 XOR data 20 XOR data 15

[0147] 4. MV = (data1, data2, data3, data4, data5)

[0148] 5. There is no parity stripe unit with only one missing data point. Switch to edge-based reconstruction.

[0149] 6. The face with the highest missing vertex, f = parity 1.

[0150] Vertices associated with f = (data1, data2, data3, data4, data5)

[0151] Edges associated with f = ((data1, data2), (data2, data3), (data3, data4), (data4, data5), (data5, data1))

[0152] The adjacent faces of f = (parity 2, parity 3, parity 4, parity 5, parity 6)

[0153] 7. The next missing data strip cell v = data 1

[0154] 8. Non-intersecting edges between vertices, where v = ((data2, data3), (data4, data5)).

[0155] 9. Edge 1 = (Data 2, Data 3)

[0156] 10. The adjacent faces of f associated with edge 1 = parity check 3

[0157] 11. Edge 1 calculation = Parity check 3 XOR data 8 XOR data 9 XOR data 10

[0158] 12. Edge 2 = (Data 4, Data 5)

[0159] 13. The adjacent faces of f connected to edge 2 = parity check 5

[0160] 14. Edge 2 calculation = parity check 5 XOR data 12 XOR data 13 XOR data 14

[0161] 15. Data 1 = Parity Check 1 XOR edge 1 XOR edge 2

[0162] 16.MV = (data2, data3, data4, data5)

[0163] 17. The next missing data stripe cell = data2. The parity stripe cell f with only one missing data cell = parity2. Vertex-based reconstruction is possible.

[0164] 18. Data2 = Parity2 XOR Data1 XOR Data6 XOR Data7 XOR Data8

[0165] 19.MV = (data3, data4, data5)

[0166] 20. Next missing data stripe cell = data 3. Parity stripe cell f = parity 3 with only one missing data.

[0167] 21. Data 3 = Parity 3 XOR Data 2 XOR Data 8 XOR Data 9 XOR Data 10

[0168] 22.MV = (data 4, data 5)

[0169] 23. Next missing data stripe cell = data 4. Parity stripe cell f = parity 4 with only one missing data.

[0170] 24. Data 4 = Parity 4 XOR Data 3 XOR Data 10 XOR Data 11 XOR Data 12

[0171] 25.MV = (Data 5)

[0172] 26. Next missing data stripe cell = data 5. Parity stripe cell f with only one missing data cell = parity 5

[0173] 27. Data 5 = Parity 5 XOR Data 4 XOR Data 12 XOR Data 13 XOR Data 14

[0174] 28.MV=(). All data stripe units have been reconstructed.

[0175] A joining edge is a polyhedron edge associated with two faces of a polyhedron, and associated with two vertices at opposite ends of the edge, wherein the edge joins at the vertex of interest and does not intersect at the other vertex of no interest. A non-intersecting edge is a polyhedron edge associated with two faces of a polyhedron, one face being identical to one face of the face associated with the joining edge, and the other face being an adjacent face, wherein one of the two vertices of the edge is a non-intersecting vertex of no interest.

[0176] Figures 9A to 9DA flowchart illustrating the reconstruction / reading workflow of a dodecahedron is shown, in which data stripe cells are reconstructed for reading, and data and parity stripe cells are reconstructed for reconstruction. 902 identifies the data stripe DS(V,F) on the dodecahedron volume D to be read, where V is the set of vertices (v1 to v20) of the dodecahedron representing the data stripe cell, and F is the set of faces (f1 to f12) of the dodecahedron representing the parity stripe cell. 904 Reads the data stripe cell given by V and the face given by F from the constituent storage medium of the dodecahedron volume D. Then, 906 determines whether any constituent storage medium in the constituent storage medium of volume D has failed. If no, it means that no component storage medium has failed. Data stripe units represented by v1, v2, ..., v19, v20, read from the component storage medium in ascending order of data stripe unit distribution are concatenated 934 to form the requested data stripe DS. If yes, it is determined that 908 is the set of missing vertices MV belonging to V and the set of missing faces MF belonging to F, corresponding to the stripe units stored on the failed / missing storage medium. Then it is determined whether 910 the cardinality of MV plus the cardinality of MF is greater than the fault tolerance level five (5). If yes, the data cannot be reconstructed, and the process ends. If no, it is determined whether 912 the cardinality of MV is equal to zero. If no, vertex-based reconstruction is performed. If yes, it means that the cardinality of MV is equal to zero. Then, data stripe units represented by v1, v2, ..., v19, v20, read from the component storage medium in ascending order of data stripe unit distribution are concatenated 934 to form the requested data stripe DS. If no, the vertex basis is reconstructed. 914 is determined by subtracting the face f in MF from F, such that only one missing associated vertex v in the set of vertices associated with f belongs to MV. When there is a set of missing vertices or faces that need to be reconstructed, there may be more than one combination to reconstruct the data because there may be embedded redundancy of a given vertex in three faces. In the polyhedral code, there will be at least one combination in which a face and its corresponding vertex exist. 814 is determined by filtering incomplete combinations by subtracting the face f in MF from F, following the rules that: (1) the vertex v to be reconstructed is associated with an existing face f; and (2) there are other vertices associated with face f. Next, it is determined whether face f is found in 916. If not, edge-based reconstruction is performed, and if yes, it means that face f is found, and the data stripe unit represented by v in 918 is reconstructed by XORing the parity stripe unit represented by f and the data stripe unit represented by other vertices in MV that do not belong to f. The data stripe unit represented by v in 920 is removed from MV. To reconfirm whether the base of 912 MV is equal to zero.For edge-based reconstruction, determine 922 the parity stripe unit represented by face f in F minus MF (F-MF) such that there exists the maximum number of associated vertices belonging to MV in the set of vertices to which f is associated. The face sharing an edge with f is the adjacent face AF belonging to F minus MF. Determine 924 the next missing data stripe unit represented by the missing vertex v belonging to MV such that f is associated with v. Determine 926 the two (2) non-intersecting edges (e1, e2) of face f such that vertex v is non-intersecting with the vertices associated with e1 and with the vertices associated with e2. Construct 928 each of the non-intersecting edge parity stripe units in the non-intersecting edge parity stripe unit e belonging to (e1, e2) by XORing the parity stripe unit represented by face ef belonging to AF (which shares an associated edge e with face f) and the data stripe unit represented by the vertices associated with face ef (excluding the vertices of edge e). The data stripe cell represented by v is reconstructed by XORing the parity stripe cell represented by face f and the parity stripe cell represented by edges e1 and e2. The reconstructed data stripe cell represented by v is removed from MV 932. After concatenating the data stripe cells represented by v1, v2, ..., v19, v20 read from the constituent storage medium in ascending order of data stripe cell distribution 934 to form the requested data stripe DS, it is determined 936 whether parity reconstruction should be performed. If not, the requested data in data stripe DS is transferred 946 to the data requester, and if yes, parity reconstruction is performed. For parity reconstruction, it is determined 938 whether the cardinality of MF is equal to zero. If yes, the requested data in data stripe DS is transferred 946 to the data requester. If not, the next missing parity stripe cell represented by the missing face f belonging to MF is determined 940. The parity stripe cell represented by f is reconstructed by XORing the five data stripe cells represented by the vertices of V that belong to f and are associated with it. The parity stripe cell represented by f is removed from MF.

[0177] Figure 10 The characteristics of various parameters are shown: RAID 5 volume, RAID 6 volume, tetrahedral volume, cube volume, and dodecahedral volume. The probability of failure has an annualized failure rate (AFR) of 1.37 for the disks. AFR is the relationship between the mean time between failures (MTBF) and the number of hours the multiple devices operate per year. Figure 10The failure probability row in the value indicates a range of values, which represents the probability of volume failure. The value range depends on the number of disks, ranging from a minimum supported number to up to thirty-two disks. Based on a number of disks ranging from four to thirty-two, the value range for RAID 6 is 2.74 to 21.92. Based on a number of disks ranging from three to thirty-two, the value range for RAID 5 is 4.11 to 43.84. The number of Galois domain multiplications per data stripe represents a polynomial time complexity that varies based on the number of data disks.

[0178] According to one example, the characteristics of a tetrahedron (8, 4, 3) include: eight disks; fault tolerance of up to four storage units; storage overhead equal to twice that of the standard; failure probability equal to 3.65, where the disk AFR equals 1.37; write computational overhead equal to eight XORs; read computational overhead is zero for an optimal volume with (0) degradation, low degradation with two XORs (1), medium degradation with four XORs (2), and high degradation with six XORs (3); rebuild computational overhead with low degradation with two XORs plus one stripe unit write (1), medium degradation with four XORs plus two stripe unit write (2), and high degradation with six XORs plus three stripe unit write (3); and the number of Galois field multiplications is zero.

[0179] Figure 11 A graph showing the read computational overhead in XOR is presented. The number of XOR operations is plotted relative to the number of disk failures.

[0180] Figure 12 Performance estimates (X times a single drive) for different fault-tolerant volumes with various I / O types running on different types of storage disks are shown.

[0181] Graphical erasure decoding, which uses computational operations such as bitwise XOR (binary exclusive OR) for encoding and decoding data, to model polyhedra can be used to provide fault recovery for storage controllers, storage accelerators, software RAID, software erasure coding, and distributed storage networks. Graphics are a broader category where polyhedra are subsets of three-dimensional solids. Polyhedra can be regular polyhedra, such as tetrahedrons, cubes, and dodecahedrons. Polyhedra can also be irregular polyhedra, such as pyramids based on squares and pyramids based on rectangles. Polyhedra can be used to establish relationships between subsets of data and, due to their symmetry properties, can also be used for encryption.

[0182] Storage media can include: disk arrays, paper storage, hard disks, solid-state drives, non-volatile memory modules, pen drives, Blu-ray discs, SD cards, CD drives, DVD drives, memory cards, floppy disks, disk arrays, paper storage, optical disc drives, zip drives, and magnetic tape. A hard disk is a circular disk with a spindle, which has a half-inch spindle made of aluminum and non-magnetic material, mounted on a circular stack of magnetic material with a diameter of 10nm to 20nm. Solid-state drives are used to store and retrieve information in a computer, and they are similar to hard disk drives, except that they have no moving parts. Pen drives are portable hard disk drives also known as USB flash drives, thumb drives, and jump drives. Blu-ray discs are optical media storage devices used for high-definition (HD) video and other high-quality audio. Secure digital cards (SD cards) contain many chips for permanent data and information storage and are portable storage devices primarily used in mobile phones and digital cameras. Compact optical discs (CDs) are portable auxiliary storage devices that are circular and made of polycarbonate plastic. Digital video discs (DVDs) are optical media that store optical data and have a shape similar to CDs, but with a larger storage capacity. Floppy disks, also known as floppy disks, are made of a plastic disc plate with a flexible outer layer of iron oxide. They have a plastic cover called a sheath. In the center of the sheath, there is a point from which the sheath rotates.

[0183] Figure 13 Heterogeneous nesting is shown. There are twenty-two storage media. At the primary coding level, eight drives (1 to 8) are included in the first branch of a tetrahedral primary volume, and fourteen drives (9 to 22) are included in the second branch of a cubic primary volume. At the secondary coding level, the twenty-two drives are heterogeneously nested in a polyhedral plus RAID 0 volume.

[0184] Figure 14 Uniform nesting is shown. There are twenty-four storage media. At the primary coding level, eight drives (1 to 8) are included in the first branch of the tetrahedral primary volume, eight drives (9 to 16) are included in the second branch of the tetrahedral primary volume, and eight drives (17 to 24) are included in the third branch of the tetrahedral primary volume. At the secondary coding level, the twenty-four drives are uniformly nested in the tetrahedral plus-0 volume.

[0185] Figure 15This diagram illustrates a nested configuration with a polyhedron as the secondary coding level and RAID 1 as the primary coding level. Sixteen storage media are present. At the primary coding level, two drives (1-2), two drives (3-4), two drives (5-6), two drives (7-8), two drives (9-10), two drives (11-12), two drives (13-14), and two drives (15-16) are included in the RAID 1 primary volume. At the secondary coding level, the sixteen drives are heterogeneously nested within a RAID+tetrahedron volume.

[0186] Although examples have been described above, other variations and examples may be made in accordance with this disclosure without departing from the substance and scope of these disclosed examples.

Claims

1. A method comprising: dividing a data stripe into a plurality of data stripe units, wherein a number of the data stripe units is equal to a number of vertices of a polyhedron and a respective data stripe unit of the data stripe units corresponds to a respective vertex of the polyhedron; constructing a plurality of parity checks, wherein a number of the parity checks is equal to a number of faces of the polyhedron and a respective parity check of the plurality of parity checks corresponds to a face of the polyhedron, wherein the respective parity check of the plurality of parity checks is constructed by a computational operation on the data stripe units corresponding to vertices of the face of the polyhedron corresponding to the respective parity check; and distributing a subset of data stripe units and a subset of parity checks to a subset of storage media.

2. The method of claim 1, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron.

3. The method of any one of claims 1 to 2, wherein the computational operation is XOR.

4. The method of any one of claims 1 to 3, wherein the computational operation is an arithmetic, comparison, or logical operation.

5. The method of any one of claims 1 to 4, wherein distributing a subset of data stripe units and a subset of parity checks to a subset of storage media comprises distributing according to a rotational distribution pattern.

6. The method of any one of claims 1 to 5, comprising vertex reconstruction of a data stripe unit corresponding to a vertex of the polyhedron by XORing a parity check corresponding to a face associated with the vertex of the polyhedron and data stripe units corresponding to remaining vertices of the face respectively associated with the polyhedron corresponding to the face of the parity check.

7. The method of any one of claims 1 to 6, comprising face reconstruction of a data stripe unit corresponding to a vertex of the polyhedron by XORing the parity check corresponding to a face associated with the vertex of the polyhedron.

8. The method of any one of claims 1 to 7, comprising edge reconstruction of a data stripe unit corresponding to a vertex of the polyhedron, wherein the vertex is associated with a first incident edge of the polyhedron, the first incident edge is associated with a neighboring face of the polyhedron, and the first incident edge is associated with a first disjoint vertex opposite the vertex, wherein the vertex is associated with a second incident edge of the polyhedron, the second incident edge is associated with the neighboring face of the polyhedron, and the second incident edge is associated with a second disjoint vertex opposite the vertex, wherein edge reconstruction is by: determining a first disjoint edge computation by XORing a parity check corresponding to a first adjacent face and a data stripe unit corresponding to a vertex associated with the first adjacent face but not the vertex associated with a first disjoint edge, wherein the first disjoint edge is an edge of the polyhedron associated with the neighboring face and the first adjacent face and one of two vertices of the first disjoint edge is the first disjoint vertex; and determining a second disjoint edge computation by XORing the parity check corresponding to the first adjacent face and a data stripe unit corresponding to a vertex associated with the second adjacent face but not the vertex associated with the second disjoint edge, wherein the second disjoint edge is an edge of the polyhedron associated with the neighboring face and the second adjacent face and one of two vertices of the second disjoint edge is the second disjoint vertex. determining a second disjoint edge calculation by XORing a parity check corresponding to a second adjacent face and a data stripe unit corresponding to a vertex associated with the second adjacent face other than the vertex associated with the second disjoint edge, wherein the second disjoint edge is an edge of the polyhedron associated with the adjacent face and the second adjacent face, and one of the two vertices of the second disjoint edge is the second disjoint vertex; and determining the data stripe unit corresponding to the vertex by XORing the first disjoint edge calculation, the second disjoint edge calculation, and the parity check corresponding to the adjacent face.

9. The method of any one of claims 1 to 8, comprising nesting a polyhedral volume with a different level of RAID or erasure coded volume.

10. An apparatus comprising: a plurality of storage media; an erasure coding controller comprising: a processor; a memory storing computer readable instructions that, when executed by the processor, cause the processor to: divide a data stripe into a plurality of data stripe units, wherein a number of the data stripe units is equal to a number of vertices of a polyhedron, and a respective one of the data stripe units corresponds to a respective one of the vertices of the polyhedron; construct a plurality of parity checks, wherein a number of the parity checks is equal to a number of faces of the polyhedron, and a respective one of the plurality of parity checks corresponds to a respective one of a plurality of faces of the polyhedron, wherein a respective one of the parity checks is constructed by a computational operation on the data stripe units corresponding to vertices of a face of the polyhedron corresponding to the respective one of the parity checks; and distribute a subset of data stripe units and a subset of parity checks to a subset of storage media.

11. The apparatus of claim 10, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron.

12. The apparatus of any one of claims 10 to 11, wherein the computational operation is an XOR.

13. The apparatus of any one of claims 10 to 12, wherein the computational operation is an arithmetic, comparison, or logical operation.

14. The apparatus of any one of claims 10 to 13, wherein distributing a subset of data stripe units and a subset of parity checks to a subset of storage media comprises distributing according to a rotational distribution pattern.

15. The apparatus of any one of claims 10 to 14, wherein the plurality of storage media comprises a medium selected from a hard disk, a solid state drive, a pen drive, a Blu-ray disc, an SD card, a CD drive, a DVD drive, a random access memory, a memory card, a non-volatile memory module, a floppy disk, a disk pack, a paper storage, an optical disc drive, and a magnetic tape.

16. The device of any of claims 10-15, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: perform vertex reconstruction on a data stripe unit corresponding to a vertex of the polyhedron by XORing a parity check corresponding to a face associated with the vertex of the polyhedron with a data stripe unit corresponding to a vertex associated with a remaining face of the polyhedron corresponding to the parity check.

17. The device of any of claims 10-16, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: perform face reconstruction on a data stripe unit corresponding to a vertex of the polyhedron by XORing the parity check corresponding to a face associated with the vertex of the polyhedron.

18. The device of any of claims 10-17, the memory storing computer-readable instructions that, when executed by the processor, cause the processor to: perform edge reconstruction on a data stripe unit corresponding to a vertex of the polyhedron, wherein the vertex is associated with a first incident edge of the polyhedron, the first incident edge is associated with a neighboring face of the polyhedron, and the first incident edge is associated with a first disjoint vertex opposite the vertex, wherein the vertex is associated with a second incident edge of the polyhedron, the second incident edge is associated with the neighboring face of the polyhedron, and the second incident edge is associated with a second disjoint vertex opposite the vertex, wherein edge reconstruction is performed by: determining a first disjoint edge calculation by XORing a parity check corresponding to a first neighboring face with a data stripe unit corresponding to a vertex associated with the first neighboring face but not the vertex associated with a first disjoint edge, wherein the first disjoint edge is an edge of the polyhedron associated with the neighboring face and the first neighboring face, and one of the two vertices of the first disjoint edge is the first disjoint vertex; determining a second disjoint edge calculation by XORing a parity check corresponding to a second neighboring face with a data stripe unit corresponding to a vertex associated with the second neighboring face but not the vertex associated with a second disjoint edge, wherein the second disjoint edge is an edge of the polyhedron associated with the neighboring face and the second neighboring face, and one of the two vertices of the second disjoint edge is the second disjoint vertex; and determining the data stripe unit corresponding to the vertex by XORing the first disjoint edge calculation, the second disjoint edge calculation, and the parity check corresponding to the neighboring face.

19. The device of any of claims 10-18, the device comprising nesting polyhedral volumes with different levels of RAID or erasure coded volumes.

20. A system, the system comprising: a data storage network, the data storage network comprising: a plurality of storage nodes; A gateway erasure coding accelerator, the gateway erasure coding accelerator comprising: a processor; a memory storing computer readable instructions that, when executed by the processor, cause the processor to: divide a data stripe into a plurality of data stripe units, wherein a number of the data stripe units is equal to a number of vertices of a polyhedron and a respective data stripe unit of the plurality of data stripe units corresponds to a respective vertex of the plurality of vertices of the polyhedron; construct a plurality of parity checks, wherein a number of the parity checks is equal to a number of faces of the polyhedron and a respective parity check of the plurality of parity checks corresponds to a respective face of a plurality of faces of the polyhedron, wherein the respective parity check of the plurality of parity checks is constructed by a computational operation on the data stripe units corresponding to vertices of a face of the polyhedron corresponding to the respective parity check of the parity checks; and distribute a subset of data stripe units and a subset of parity checks to a subset of storage nodes of the plurality of storage nodes.

21. The system of claim 20, wherein the polyhedron is a tetrahedron, a cube, or a dodecahedron, wherein the computational operation is XOR, wherein the computational operation is an arithmetic, comparison, or logical operation, and wherein distributing a subset of data stripe units and a subset of parity checks to a subset of storage nodes comprises distributing according to a rotational distribution pattern.

22. The system of any one of claims 20-21, wherein the plurality of storage nodes comprises nodes selected from a hard disk, a solid state drive, a pen drive, a Blu-ray disc, an SD card, a CD drive, a DVD drive, a memory card, a non-volatile memory module, a floppy disk, a disk pack, a paper storage, an optical disc drive, and a magnetic tape.

23. The system of any one of claims 20-22, the memory storing computer readable instructions that, when executed by the processor, cause the processor to reconstruct data stripe units corresponding to vertices of the polyhedron by a reconstruction process selected from a face reconstruction, a vertex reconstruction, and an edge reconstruction.

Images