Patent Publication Number: US-2021173740-A1

Title: Erasure recovery in a distributed storage system

Description:
FIELD OF THE INVENTION 
     The invention lies in the general field of data storage systems and the management of failures in these systems. More particularly, the invention relates to methods and devices for coding and decoding data that make it possible to optimize the data read/write operations and to optimize the volume of data to be transferred, necessary for the repairing of a storage system following a failure. 
     STATE OF THE ART 
     In recent years, the volume of digital data has increased considerably, because of the use of applications such as social networks, email, file sharing, and video sharing. Thus, companies that offer online services have to manage data volumes of several tens of petabytes (1 PB=10 15  bytes). These quantities of data, which continue to increase exponentially year on year, need to be stored reliably. 
     Distributed storage systems (DSS) are widely used these days to provide open-ended and reliable storage solutions. These architectures, as illustrated in  FIG. 1 , comprise multiple storage nodes ( 110 ,  112 ,  114 ) in which data are stored in a distributed fashion. A storage node can be composed of one ( 112 ) or of a plurality of storage devices ( 110 ,  114 ). Each storage device of a node which comprises several thereof is itself designated as a storage node. Generally, the storage devices are storage discs. A controller ( 102 ) makes it possible to manage communications from/to the nodes, including the disc read/write operations based on requests received from a computer ( 106 ) coupled to the communication network ( 104 ). 
     Now, it is not uncommon for discs, devices or storage nodes to fail, and it is commonplace, for thousands of nodes, for several tens of failures on average to be reported per day. A distributed storage system has to ensure the protection of the data in the case where one or several nodes or storage devices or discs fail. 
     In order to ensure the reliability and the availability of the data, the standard implementations incorporate solutions based on the redundancy of the data in order to be able to retrieve the data lost in the event of failure. 
     There are several methods, listed hereinbelow, that make it possible to add reliability to a storage system: 
     Replication is one of the methods most widely used. It consists in replicating one and the same data block over several storage nodes. Generally, one and the same data block is stored in n different nodes, which makes it possible to tolerate n−1 failures. In practice, each data block is stored in three different nodes making it possible to tolerate two failures. Even though replication offers a good tolerance to failures, it has the disadvantage of posting a storage overhead, which can be assessed at 200% in replications with 3 nodes. 
     Erasure Code. This approach is based on the use of the well-known Reed-Solomon (RS) codes. Each data file is broken down into k data blocks to which are added r parity function blocks generating k+r data blocks, and the term code RS(k,r) is used. The k+r data blocks are stored in k+r different nodes, in which k nodes store the k original blocks and r parity nodes store the r parity function blocks. A code RS(k,r) has two basic properties: any data block k out of the k+r blocks is sufficient to regenerate the original datum, and r failures, whatever they may be, can be tolerated. In practice, with a code RS(10,4), each data file is broken down into 10 blocks, and 4 parity function blocks are generated, making it possible to tolerate up to four failures. The RS codes offer a better storage efficiency compared to replication, the storage overhead being assessed at 40% for a code RS(10,4). 
     In a data storage system, in case of failure, reconstructing the data entails reading the data stored in the redundancy nodes, then transferring them in the network from these nodes supplying data, also called “providers”, into a new storage node, also called “newcomer”. Even if, in the event of failure of a single node, there is need for only a single provider in the case of replication, k providers are required in the case of a code RS(k,r), then involving the transfer over the network of the data from the k providers. The repair of a single failure can thus entail reading and transmitting hundreds of terabytes (TB). Also, the cost of the repair in terms of bandwidth and of reads/writes can be significant. 
     Some solutions listed hereinbelow address reducing the bandwidth required during the repair phase, or “bandwidth repair”. 
     Regenerating codes are one example. The main idea as described in the article “Network coding for distributed storage systems”, Alexandros G Dimakis, P Brighten Godfrey, Yunnan Wu, Martin J Wainwright, and Kannan Ramchandran, IEEE Transactions on Information Theory, 56(9): 4539-4551, 2010, is that each node generates a linear combination of data from the data blocks which are available to it. The quantity of data to be transferred from each provider node is then lower than that stored in each node, which reduces the bandwidth required for the repair. However, with a regenerating code, the information retrieved in the new node is a linear combination of the transferred data, and it can then not necessarily be equal to the data block lost. 
     Exact regenerating codes are proposed for retrieving exactly the same lost data block. The main idea as described in the article “Optimal exact-regenerating codes for distributed storage at the MSR and MBR points via a product-matrix construction”, Rashmi, Korlakai Vinayak, Nihar B. Shah, and P. Vijay Kumar, IEEE Transactions on Information Theory 57(8): 5227-5239, 2011, consists in eliminating the unwanted data blocks by using the concept of interference alignment. Even though the exact regenerating codes make it possible to considerably reduce the bandwidth for the repair, the cost of the disc inputs/outputs (“I/O overhead”) is not optimized. Indeed, to repair a single failure, an exact regenerating code requires all the data stored in all the nodes to be read. 
     Solutions are proposed for reducing both the repair bandwidth and the cost of the disc inputs/outputs. 
     For example, with the hierarchical codes as presented in the article “Hierarchical codes: How to make erasure codes attractive for peer-to-peer storage systems”, Alessandro Duminuco and Ernst Biersack, P2P′08, 8th IEEE International Conference on Peer-to-Peer Computing, pages 89-98, the main idea consists in hi-erarchically creating specific parity functions from smaller codes than the original code. A hierarchical code (k,r) needs └k/r−1┘ (integer part of k/r−1) to k data blocks read and downloaded to repair a single failure. However, the hierarchical code does not maintain all the properties of a conventional RS code. Indeed, a hierarchical code (k,r) cannot tolerate any r failures. It therefore proves less reliable with equal redundancy. 
     The hitchhiker code is a code which makes it possible to maintain the same properties as an RS code and to offer a failure repair that is less costly in terms of bandwidth and of disc inputs/outputs. The main idea as described in “A hitchhikers guide to fast and efficient data reconstruction in erasure-coded data centers”, KV Rashmi, Nihar B Shah, Dikang Gu, Hairong Kuang, Dhruba Borthakur, and Kannan Ramchandran, ACM SIGCOMM Computer Communication Review, 44(4):331-342, 2015, consists in reducing the number of data blocks needed to repair a single failure. The hitchhiker approach considers two RS subcodes having the same configuration (k,r). Specific parity functions which depend on the second code and on the first code are created in the second RS subcode. These interleaved parity functions make it possible to reduce the quantity of data read and transferred to repair a data block. A hitchhiker code (10,4) makes it possible to reduce by 30% to 35% the cost of the repair bandwidth and of the disc inputs/outputs. 
     The following references propose data coding methods for reducing the bandwidth: 
     Cheng Huang et al.: “Erasure Coding in Windows Azure Storage”, USENIX, 11 Apr. 2013 (2013-04-11), pages 1-12, XP061013941. This LRC (k, l, r) method is based on the generation of local parity functions stored in storage nodes; however, the LRC codes introduce a storage overhead due to the additional storage of the local parity functions. 
     Cheng Huang et al.: “Pyramid Codes: Flexible Schemes to Trade Spaces for Access Efficiency in Reliable Data Storage systems”, Proc. Sixth IEEE International Symposium on Network Computing and Applications 2007, IEEE, 1 Jul. 2007 (2007-01-07), pages 79-86, XP031119281, ISBN: 978-0-7695-2922-6. This method presents an alternative to the LRC method. However, the pyramid codes, like the LRC codes, introduce a storage overhead compared to a conventional erasure code and to the Babylon code. 
     These approaches do not allow for the same storage efficiency as a conventional erasure code, contrary to the hitchhiker codes, to the regenerating codes and to the hierarchical codes, which make it possible to reduce the bandwidth while maintaining the same storage efficiency as a conventional erasure code. 
     Contrary to the methods described previously based on the definition of a new erasure code, the solution proposed in the patent application US 2016/211869 A1 by Blaum Mario et al. proposes a dynamic storage system incorporating several erasure codes, capable of switching between different codes as a function of the objective. The system decides either to reduce the repair bandwidth, or to reduce the storage overhead as a function of the popularity of the file. The system supports in particular the two codes: LRC (cited previously) and “Product Code” (PC). 
     It emerges that there is a need for a data coding/decoding solution for reconstructing data lost or damaged in the event of a failure of one or more data storage elements, which is enhanced in terms of repair bandwidth cost and of disc input/output cost, while maintaining the same storage efficiency as the conventional erasure codes. 
     Moreover, with the advent of SSD (Solid State Drive) discs, the storage elements are increasingly faster, and each disc can generate several tens of Gigabits per second in read mode. The bit rate of the interfaces linking the storage elements is then particularly critical and becomes a bottleneck in the storage systems. Reducing the flows to be exchanged in the event of reconstruction is therefore particularly important. There is thus the need for a solution that makes it possible to optimize the quantity of data to be transferred when repairing a storage system, following a failure. 
     The present invention addresses the abovementioned various needs. 
     SUMMARY OF THE INVENTION 
     The present invention aims to mitigate the limitations of the known techniques by proposing methods and devices for coding and decoding data that make it possible to optimize the quantity of data transferred, as well as the read/write operations needed for the repair of a storage system, following a failure. 
     Advantageously, the present invention makes it possible to reduce both the repair bandwidth and the disc input/output costs while maintaining properties of storage efficiency and of reliability in which all the failures r out of k+r are tolerated. 
     One object of the present invention relates to a data coding method. In particular, it proposes a method for coding (k, r) data comprising steps consisting in:
         dividing an initial datum a into k data blocks a i ;   grouping the k data blocks into r−1 subsets S j  of data blocks;   generating, for each subset S j , a linear function g j (a) defined as a linear combination of the data blocks assigned to said subset S j , and   generating r parity functions comprising a primary parity function f 0 (a) as a linear combination of the k data blocks a i , and r−1 secondary parity functions, each secondary parity function f j (a) being defined as the sum of the primary parity function f 0 (a) and of a linear function g j (a).       

     Solutions are proposed for reducing both the repair bandwidth and the disc input/output cost. 
     For example, with the hierarchical codes as presented in the article “Hierarchical codes: How to make erasure codes attractive for peer-to-peer storage systems”, Alessandro Duminuco and Ernst Biersack, P2P′08, 8th IEEE International Conference on Peer-to-Peer Computing, pages 89-98, the main idea consists in hierarchically creating specific parity functions from smaller codes than the original code. A hierarchical code (k,r) needs └k/r−1┘ (integer part of k/r−1) to k data blocks read and downloaded to repair a single failure. However, the hierarchical code does not maintain all the properties of a conventional RS code. Indeed, a hierarchical code (k,r) cannot tolerate any r failures. It therefore proves less reliable with equal redundancy. 
     The hitchhiker code is a code which makes it possible to maintain the same properties as an RS code and to offer a failure repair that is less costly in terms of bandwidth and of disc inputs/outputs. The main idea as described in “A hitchhikers guide to fast and efficient data reconstruction in erasure-coded data centers”, KV Rashmi, Nihar B Shah, Dikang Gu, Hairong Kuang, Dhruba Borthakur, and Kannan Ramchandran, ACM SIGCOMM Computer Communication Review, 44(4):331-342, 2015, consists in reducing the number of data blocks needed to repair a single failure. The hitchhiker approach considers two RS subcodes having the same configuration (k,r). Specific parity functions which depend on the second code and on the first code are created in the second RS subcode. These interleaved parity functions make it possible to reduce the quantity of data read and transferred to repair a data block. A hitchhiker code (10,4) makes it possible to reduce by 30% to 35% the cost of the repair bandwidth and of the disc inputs/outputs. 
     The following references propose data coding methods for reducing the bandwidth: 
     Cheng Huang et al.: “Erasure Coding in Windows Azure Storage”, USENIX, 11 Apr. 2013 (2013-04-11), pages 1-12, XP061013941. This LRC (k, l, r) method is based on the generation of local parity functions stored in storage nodes; however, the LRC codes introduce a storage overhead due to the additional storage of the local parity functions. 
     Cheng Huang et al.: “Pyramid Codes: Flexible Schemes to Trade Spaces for Access Efficiency in Reliable Data Storage systems”, Proc. Sixth IEEE International Symposium on Network Computing and Applications 2007, IEEE, 1 Jul. 2007 (2007-01-07), pages 79-86, XP031119281, ISBN: 978-0-7695-2922-6. This method presents an alternative to the LRC method. However, the pyramid codes, like the LRC codes, introduce a storage overhead compared to a conventional erasure code and to the Babylon code. 
     These approaches do not allow for the same storage efficiency as a conventional erasure code, contrary to the hitchhiker codes, to the regenerating codes and to the hierarchical codes, which make it possible to reduce the bandwidth while maintaining the same storage efficiency as a conventional erasure code. 
     Contrary to the methods described previously based on the definition of a new erasure code, the solution proposed in the patent application US 2016/211869 A1 by Blaum Mario et al. proposes a dynamic storage system incorporating several erasure codes, capable of switching between different codes as a function of the objective. The system decides either to reduce the repair bandwidth, or to reduce the storage overhead as a function of the popularity of the file. The system supports in particular the two codes: LRC (cited previously) and “Product Code” (PC). 
     It emerges that there is a need for a data coding/decoding solution for reconstructing data lost or damaged in the event of a failure of one or more data storage elements, which is enhanced in terms of repair bandwidth costs and of disc input/output cost, while maintaining the same storage efficiency as the conventional erasure codes. 
     According to alternative or combined embodiments of the coding method:
         the step of generating r parity functions consists in generating r encoding vectors comprising:   a primary encoding vector C 0  composed of k primary encoding coefficients c 0,1  to c 0,k ; and   r−1 secondary encoding vectors C j  (1&lt;=j&lt;=r−1), each secondary encoding vector being composed of k secondary encoding coefficients c j,1  to c j,k ;   each primary encoding coefficient c 0,i  corresponds to a non-zero random number, and a secondary encoding coefficient c j,i  corresponds to a non-zero or zero random number depending on whether the data block a i  belongs to or does not belong to the subset S j ;   the step of generating a linear function g j (a) consists in generating a linear combination of the k data blocks (a 1 , . . . , a k ) and of the secondary encoding vector C j ;   k=10 and r=4.       

     The data coding method of the present invention is particularly suited for distributing data over storage devices for the purpose of reconstructing data lost following a failure of a storage device. Also claimed is a method for storing k+r data comprising at least one step consisting in storing, in k systematic storage devices N i , i∈{1, . . . , k}, k data blocks a i , and in storing, in r parity storage devices N i , i∈{k+1, k+r}, r parity functions, the r parity functions being obtained according to the data coding method claimed. 
     The invention covers also a data coding device comprising means for implementing the steps of the data coding method as claimed. 
     Another object of the present invention relates to a method for reconstructing or duplicating the content of a device which stores data coded according to the coding method claimed. In particular, a method is claimed for reconstructing the content of a storage device out of a plurality of storage devices storing k data blocks as in k systematic storage devices N i , i∈{1, . . . , k}, and r parity functions f j (a) in r parity storage devices N i , i∈{k+1, . . . , k+r}, said k data blocks and r parity functions being obtained according to the data cooling method claimed, the reconstruction method comprising at least steps consisting in:
         determining whether the storage device for which to reconstruct the content is a systematic or parity storage device;   if said device is a systematic storage device N i , i∈{1, . . . , k}:
           determining to which subset of data S j  the data block of said device belongs;   retrieving the primary and secondary parity functions stored in the parity storage devices k+1 and k+1+j;   computing the linear function g j (a) associated with the subset S j ;   retrieving the data blocks of the subset S j  except for the block a i ; and   reconstructing the content of said systematic storage device N i , i∈{1, . . . , k};   
           if said device is a parity storage device N i , i∈{k+1, . . . , k+r}, determining the index i identifying said storage device;
           if the index i is equal to k+1:
               retrieving the secondary parity function f 0 (a) stored in the parity storage device of index i=k+2 and the data blocks a i  of the subset S i−k+1 ;   computing the linear function g 1 (a) associated with the subset S 1  and decoding the primary parity function f 0 (a); and   reconstructing the content of said parity device of index i=k+1;   
               if the index i is greater than k+1:
               retrieving the primary parity function f 0 (a) stored in the parity storage device of index i=k+1 and the data blocks a i  of the subset S i−k+1;      computing the linear function g i−k+1 (a) associated with the subset S i−k+1  and decoding the secondary parity function f i−k+1 (a); and   reconstructing the content of said parity device of index i&gt;k+1.   
               
               

     The content reconstruction method is particularly suited to the reconstruction of content for data lost following a failure of a storage device. 
     According to alternative or combined embodiments of the reconstruction method:
         the steps of retrieving the parity functions consist in transferring the data from the corresponding storage devices to a data collecting device;   the step of computing the linear function g j (a), associated with the subset S j  for the reconstruction of a systematic node i such that i∈{1, . . . , k}, consists in subtracting the primary parity function stored in the storage device N k+1  from the secondary parity function stored in the storage device N k+1+j ;   the step of computing the linear function g 1 (a), associated with the subset S 1  for the reconstruction of a parity node i such that i=k+1, consists in generating a linear combination from the data blocks of the subset S 1  and from the encoding vector C 1 ;   the step of computing the linear function g j (a), associated with the subset S j  for the reconstruction of a parity node i such that i∈{k+2, . . . , k+r}, consists in generating a linear combination from the data blocks of the subset S j  and from the encoding vector C j ; the step of reconstructing the content of said systematic storage device consists in decoding the data block a i  from the linear function g j (a);   the step of reconstructing the content of said parity storage device i such that i=k+1 consists in decoding the secondary parity function of said parity device of index i=k+1 from the computed linear function g 1 (a);   the step of reconstructing the content of said parity storage device i such that i&gt;k+1 consists in decoding the secondary parity function of said parity device of index i&gt;k+1 from the computed linear function g i−k+1 (a).       

     The invention also covers a device for reconstructing the content of a storage device out of a plurality of devices storing k data blocks as in k systematic storage devices N i , i∈{1, . . . , k}, and r parity functions f j (a) in r parity storage devices N i , i∈{k+1, . . . , k+r}, said k data blocks and r parity functions being obtained according to the coding method claimed, the device comprising means for implementing the steps of the claimed method for reconstructing the content of a storage device. 
     The present invention can be incorporated in hardware and/or software elements such as an integrated circuit of ASIC or FPGA type. 
     The invention relates also to a computer program which comprises coding instructions making it possible to perform the steps of the coding method claimed and/or comprising code instructions making it possible to perform the steps of the content reconstruction method claimed, when said program is run on a computer. 
     The invention can be available on a storage medium that can be read by a processor on which is stored a program comprising code instructions for executing the coding method and/or the content reconstruction method as claimed. 
     One advantageous use of the content reconstruction method claimed is in a distributed storage system which comprises a plurality of data storage nodes capable of storing data coded according to the coding method claimed. 
     Another advantageous use of the content reconstruction method claimed is in a local storage system which comprises data storage discs capable of storing data coded according to the coding method claimed. 
    
    
     
       DESCRIPTION OF THE FIGURES 
       Different aspects and advantages of the invention will emerge with the support of the description of a preferred but nonlimiting implementation of the invention, with reference to the figures below: 
         FIG. 1  illustrates a distributed system environment that makes it possible to implement the invention in an embodiment; 
         FIG. 2  shows a representation of the storage of the data in an embodiment of the invention; 
         FIG. 3  illustrates the steps of the coding method of the invention in an embodiment; 
         FIG. 4  illustrates the generation of a primary encoding vector, according to the principles of the invention; 
         FIG. 5  illustrates the generation of a secondary encoding vector, according to the principles of the invention; 
         FIG. 6  illustrates the generation of a primary parity function and of a secondary parity function, according to the principles of the invention; 
         FIGS. 7 a  to 7 c    illustrate the steps of reconstruction of systematic and parity nodes according to the principles of the invention; 
         FIG. 8  is a table comparing the performance levels of different codes. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Throughout the rest of the description, the expression ‘storage node’ is used in the generic sense and denotes a storage entity, whether it be a single disc or a group of storage devices forming a node. The embodiments of the invention described apply to any variant of a distributed storage system illustrated in  FIG. 1 , which is only an example of an environment that makes it possible to implement the invention. Thus, this example is not limiting and the principles described can be applied for any other environment incorporating a storage system, distributed or not, such as cloud systems, data centres, distributed file systems, whether based on files or on objects. The invention can also be applied to non-distributed storage systems such as “disk arrays”. Moreover, a storage node which stores data derived from the initial datum is designated “systematic node” and a storage node which stores a parity function is designated “parity node”. 
     To facilitate the understanding of the principles of the invention, the coding method is first of all described on a particular example of a code (k=10, r=4), then is generalized for any code (k, r). 
     Description of the coding method on the example of a code (10, 4): 
       FIG. 2  illustrates a representation of the storage of data by application of the coding method of the invention, based on the example of a code k=10 and r=4. Hereinafter in the description, the coding steps of the present invention can be designated by the expression “Babylon code” or “Babylon coding”. An initial datum a is divided into k=10 pieces ( 200 ) or data blocks (a 1 , . . . , a 10 ), denoted a i , i∈{1, . . . , 10}, to which are added r=4 parity blocks or parity functions f 0 , f 1 , f 2  and f 3 , which are linear combinations of the data (a 1 , . . . , a 10 ) and hereinbelow denoted f 0 (a), f 1 (a), f 2 (a), f 3 (a) or f 0 (a) and f j (a), j∈{1, 2, 3}. The parity function f 0 (a) is designated as primary parity function, and the parity functions f j (a) are designated as secondary parity functions. The primary and secondary parity functions are generated according to the Babylon coding ( 202 ) of the invention and stored on storage nodes ( 204 ). 
     The systematic data blocks a 1  to a 10  are stored on 10 corresponding systematic storage nodes ( 206 ), denoted (N 1  to N 10 ), and the primary f 0 (a) and secondary f 1 (a), f 2 (a), f 3 (a) parity functions are stored on 4 corresponding parity storage nodes ( 208 ), denoted N 11  to N 14 . 
       FIG. 3  illustrates the steps of the coding method ( 300 ) of the invention in an embodiment of a code (k=10, r=4). In a first step ( 302 ), the method makes it possible to divide an initial datum a into 10 data blocks (a 1 , . . . , a 10 ), then, in a next step ( 304 ), to create 3 data subsets (S 1 , S 2 , S 3 ). Each data subset comprises different data blocks out of the 10 blocks created. In one embodiment, two subsets (S 1 , S 2 ) are each composed of 3 data blocks and the third subset (S 3 ) is composed of 4 data blocks. The first subset S 1  is composed of the first three blocks (a 1 , a 2 , a 3 ) obtained from the initial datum, the second subset S 2  is composed of the next three blocks (a 4 , a 5 , a 6 ), and the last subset S 3  is composed of the last four remaining blocks (a 7 , a 8 , a 9 , a 10 ). 
     In a next step ( 306 ), the method makes it possible to generate 4 encoding vectors of length (k=10), corresponding to the 4 parity nodes. The encoding vectors denoted C 0  to C 4  correspond to a primary encoding vector C 0  and 3 secondary encoding vectors C 1 , C 2 , C 3 . 
       FIGS. 4 and 5  detail the steps of generation of the encoding vectors according to the principles of the invention. 
       FIG. 4  illustrates the generation of the primary encoding vector C 0  ( 400 ) in an embodiment. The primary encoding vector C 0  is composed of 10 primary encoding coefficients c 0,1  to c 0,10  in which each primary encoding coefficient c 0,1  ( 402 - i ) corresponds to a non-zero random number ( 404 - i ). 
       FIG. 5  illustrates the generation of the secondary encoding vectors C j  (1&lt;=j&lt;=3) in an embodiment ( 500 ). Each secondary encoding vector C j  is composed of 10 secondary encoding coefficients c j,1  to c j,10 . 
     To generate a vector C j , the method checks ( 504 - i ), for each block a i , whether the block a i  belongs to the subset S j . If such is the case (yes branch), the method makes it possible to associate with the coefficients c j,i  non-zero random numbers ( 506 - i ). If the blocks as do not belong to the subset S j  (no branch), the method makes it possible to associate with the coefficients c j,i  zero random numbers ( 508 - i ). 
     For example, to generate the encoding vector C 1 , the method checks, for each data block a 1 , a 2 , . . . a 10 , whether it belongs to the subset S 1 . Since the data blocks a 1 , a 2 , a 3  belong to the subset S 1 , the method therefore generates non-zero random numbers for the coefficients c 1,1  and c 1,3 . Since the data blocks a 4 , . . . , a 10  do not belong to S 1 , the method generates zero random numbers associated with the coefficients c 1,4  . . . c 1,10 . 
     Thus, for the subset S 1 , the method makes it possible to generate an encoding vector C 1  equal to c 1,1 , c 1,2 , c 1,3 , 0, 0, 0, 0, 0, 0, 0) in which c 1,1 , c 1,2  and c 1,3  are non-zero random numbers. 
     For the subset S 2 , the method makes it possible to generate an encoding vector C 2  equal to (0, 0, 0, c 2,4 , c 2,5 , c 2,6 , 0, 0, 0, 0) in which c 2,4 , c 2,5  and c 2,6  are non-zero random numbers. 
     For the subset S 3 , the method makes it possible to generate an encoding vector C 3  equal to (0, 0, 0, 0, 0, 0, c 3,7 , c 3,8 , c 3,9 , c 3,10 ) in which c 3,7 , c 3,8 , c 3,9  and c 3,10  are non-zero random numbers. 
     Returning to  FIG. 3 , after the step of generation of the encoding vectors, the method makes it possible to generate ( 308 ) 4 parity functions as linear combinations of the data blocks (a 1 , . . . , a 10 ) comprising a primary parity function f 0 (a) and 3 secondary parity functions f 1 (a), f 2 (a) and f 3 (a). 
       FIG. 6  details the generation of the primary parity function f 0 (a), and the secondary parity functions f j (a) j∈{1, 2, 3} according to the principles of the invention. The primary parity function ( 602 ) is a linear combination of the 10 data blocks (a 1 , . . . a 10 ) and is stored in the parity node N 11 . Each data block as has an associated encoding coefficient c 0,i  of the primary encoding vector C 0  ( 400 ). The primary parity function f 0 (a) can be written according to the following equation: 
         f   0 ( a )= c   0,1   *a   1   +C   0,2   *a   2   +C   0,3   *a   3   +C   0,4   *a   4   +C   0,5   *a   5   +C   0,6   *a   6   +C   0,7   *a   7   +C   0,8   *a   8   +C   0,9   *a   9   +c   0,10   *a   10    
     in which the coefficients c 0,1 , c 0,2 , . . . , c 0,10  are non-zero random numbers. 
     As illustrated in  FIG. 6 , to generate the 3 secondary parity functions f j (a) (1&lt;=j&lt;=3) ( 604 ), the method first generates 3 linear functions g j (a) (1&lt;=j&lt;=3) ( 606 ). Each linear function g j (a) is a linear combination of the 10 data blocks (a 1 , . . . , a 10 ) and of the encoding vectors C j  (1&lt;=j&lt;=3) ( 500 ). 
     The linear function g 1 (a) is obtained by linear combination of the 10 data blocks (a 1 , . . . , a 10 ) and of the encoding vector C 1 , and it can then be written: 
         g   1 ( a )= c   1,1   *a   1   +c   1,2   *a   2   +c   1,3   *a   3 . 
     The linear function g 2 (a) is obtained by linear combination of the 10 data blocks (a 1 , . . . , a 10 ) and of the encoding vector C 2 , and it can then be written: 
         g   2 ( a )= c   2,4   *a   4   +c   2,5   *a   5   +c   2,6   *a   6 . 
     Similarly, the linear function g 3 (a) is obtained by linear combination of the 10 data blocks (a 1 , . . . , a 10 ) and of the encoding vector C 3  and can be written: 
         g   3 ( a )= c   3,7   *a   7   +c   3,8   *a   8   +c   3,9   *a   9   +c   3,10   *a   10 . 
     Once the functions g j (a) (1&lt;=j&lt;=3) are generated, the method makes it possible to create the secondary parity functions f 1 (a), f 2 (a) and f 3 (a). The secondary parity function f 1 (a) is obtained by the sum of the primary parity function f 0 (a) and of the linear function g 1 (a). It can be represented as follows: 
         f   1 ( a )= f   0 ( a )+ g   1 ( a ) 
     Similarly, the secondary parity function f 2 (a) is obtained by the sum of the primary parity function f 0 (a) and of the linear function g 2 (a). It can be represented as follows: 
         f   2 ( a )= f   0 ( a )+ g   2 ( a ) 
     Likewise, the secondary parity function f 3 (a) is obtained by the sum of the primary parity function f 0 (a) and of the linear function g 3 (a). It can be represented as follows: 
         f   3 ( a )= f   0 ( a )+ g   3 ( a ) 
     The secondary parity functions f 1 (a), f 2 (a), f 3 (a) are stored respectively in the parity nodes N 12 , N 13  and N 14  ( 208 ). 
     Advantageously, the linear functions g 1 (a), g 2 (a), g 3 (a) and the primary parity function f 0 (a) are generated so as to be linearly independent of one another. Moreover, the sum of any two of these functions is also linearly independent of the other functions. Finally, advantageously, since all the data blocks are linearly independent, the Babylon code maintains the same properties as an RS code. 
       FIGS. 7 a  to 7 c    illustrate the steps of detecting failures and of reconstructing the content of systematic nodes and of parity nodes according to the principles of the invention. 
     As illustrated in  FIG. 7 a   , the method is initiated ( 702 ) when information relating to the detection of a failure in the storage system is available indicating the number of failures ( 704 ). For the cases where the number of failures is greater than or equal to five, the repair method may not be operative and the system is considered to be defective ( 706 ). For the cases where the number of failures lies between two and four failures, the two, three or four nodes that have failed can be reconstructed according to the known repair methods ( 708 ), of erasure code or Reed Solomon type. 
     The method claimed according to the Babylon code works for the cases where a single storage node in a local or distributed storage system has failed. The repair steps will make it possible to retrieve, in the other storage nodes, the lost data which were contained in the failed node and to reconstruct a new storage node with the same data. After a failure is detected, the method determines the nature of the node which has failed ( 710 ), namely whether it is a systematic node or a parity node. 
     In order to facilitate the understanding of the principles of the invention and without limitation, the reconstruction method is first of all described on a particular example of a code (k=10, r=4), then is generalized for any code (k, r). 
     Description of the decoding method of the invention on the example of a storage system with a code (10, 4): 
     If the failure relates to a systematic node N i , i∈{1, . . . , 10}, that is to say a node storing data blocks a i , the reconstruction ( 712 ) is done according to the steps of the method described in  FIG. 7   b.    
     If the failure relates to a parity node N i , i∈{11, . . . , 14}, that is to say a node storing parity functions, the reconstruction ( 714 ) is done according to the steps of the method described in  FIG. 7   c.    
       FIG. 7 b    illustrates the steps of reconstruction of a systematic node according to the present invention. 
     To illustrate the method, it is assumed that the block a 1  located in the node N 1  is lost, and that it must be reconstructed. In a first step ( 716 ), the method makes it possible to determine the subset of data S j , j∈[1,2,3], to which the datum as of the node N i  that has failed belongs. In the example, the data block a 1  belongs to the subset S 1 , which contains the data (a 1 , a 2 , a 3 ). In a next step ( 718 ), the method makes it possible to retrieve the data of the primary parity function f 0 (a) which are stored in the node N 11  and to retrieve the data of the secondary parity function f 1 (a) corresponding to the index of the identified subset S 1 , which are stored in the node N 12 . The expression “retrieve the data” is used to denote operations of transferring of the data from a storage node to a data collecting device. The data collecting device can be incorporated in a general storage system controller, where the node reconstruction method can be implemented. The retrieval of the data also includes the operations of reading/writing from/into memory elements of the storage nodes and of the data collecting device. 
     After the data collection step, the method makes it possible ( 720 ), from the retrieved data, to compute the linear function g 1 (a) associated with the subset of data S 1 . In one embodiment, the linear function g j (a) is obtained by subtraction of the primary parity function f 0 (a) located in the node N 11  from the secondary parity function f 1 (a) located in the node N 12 . 
     In a next step ( 722 ), the method makes it possible to load the data blocks (a 2 , a 3 ) of the subset S 1 , except for the block a 1  which is lost. By subtracting these data from the linear function g 1 (a), the datum a 1  is retrieved and the primary storage node N 1  for the lost data block a 1  is reconstructed ( 724 ). 
     The reconstruction of the node for a 1  needs to use only 4 data blocks {a 2 , a 3 , f 0 (a), f 1 (a)}, unlike a conventional RS code which would have required 10 blocks, i.e. a saving of 60%. Similarly, the reconstruction of a systematic node for any data block a i  for i∈{1, 2, 3}, requires only 4 blocks, by using the data blocks having the index i∈{1, 2, 3}\{i}, that is to say except for the data block of index i corresponding to the node N i  that has failed, and by using the data blocks of the primary parity f 0 (a) and secondary parity f 1 (a) functions. 
     The reconstruction of a systematic node for any data block a i  for i∈{4, 5, 6} requires 4 blocks, by using the data blocks having the index i∈{4, 5, 6}\{i} and by using the data blocks of the primary parity f 0 (a) and secondary parity f 2 (a) functions. 
     The reconstruction of a systematic node for any data block a i  for i∈{7, 8, 9, 10} requires 5 blocks, by using the data blocks having the index i∈{7, 8, 9, 10}\{i} and by using the data blocks of the primary parity f 0 (a) and secondary parity f 3 (a) functions. 
       FIG. 7 c    illustrates the steps of reconstruction of a parity node according to the present invention. 
     The nodes N i , i∈[11,14] contain the primary f 0 (a) and secondary f 1 (a), f 2 (a), f 3 (a) parity functions. The method first of all determines ( 726 ) whether the node to be repaired is N 11  which contains the primary parity function f 0 (a). If yes, the method makes it possible to transfer ( 728 ) the data f 1 (a) and those of the subset S 1  containing a 1 , a 2  and a 3  from the nodes N 12 , N 1 , N 2  and N 3 . In a next step ( 730 ), the method makes it possible to generate the linear function g 1 (a) using the data a 1 , a 2  and a 3 , then to decode the primary parity function f 0 (a) by subtracting the linear function g 1 (a) from the parity function f 1 (a). The method then makes it possible to reconstruct the node N 11 . 
     Like the nodes i, i∈{1, . . . , 10}, the repair of N 11  requires only 4 data blocks (f 1 (a), a 1 , a 2  and a 3 ). 
     Returning to the step ( 726 ), if the node to be repaired is a parity node N i  such that i∈[12,14], the method makes it possible to load ( 734 ) the data of the node N 11  which contains the parity function f 0 (a), and load the data of the subsets S i−11 . In a next step ( 736 ), the method makes it possible to generate the linear function g i−11 (a) using the data of the subsets and to decode the parity function f i−11 (a) by effecting the sum of the primary parity function f 0 (a) and of the linear function g i−11 (a). The method then makes it possible to reconstruct ( 738 ) the node N i , i∈[12,14]. 
     Thus, for the reconstruction of the node N 12  containing the secondary parity function f 1 (a), the method makes it possible to load the parity function f 0 (a) of the node N 11  and the data of the subset S 1  (a 1  from the node N 1 , a 2  from the node N 2  and a 3  from the node N 3 ). In a first stage, the parity function g 1 (a) is generated using the data a 1 , a 2  and a 3  of the subset S 1 . Next, the secondary parity function f 1 (a) is decoded by effecting the sum of f 0 (a) and g 1 (a) and the node N 12  is reconstructed. 
     Likewise, for the reconstruction of the node N 13  containing the secondary parity function f 2 (a), the method makes it possible to load the data of the node N 11  which contains the parity function f 0 (a) and the data of the subset S 2 . In a first stage, the parity function g 2 (a) is generated using the data a 4 , a 5  and a 6  of the subset S 2 . Next, the secondary parity function f 2 (a) is decoded by effecting the sum of f 0 (a) and g 2 (a) and the node N 13  is reconstructed. 
     Finally, for the reconstruction of the node N 14  containing the secondary parity function f 3 (a), the method makes it possible to load the parity function f 0 (a) contained in the node N 11  and the data of the subset S 3 . In a first stage, the parity function g 3 (a) is generated using the data a 7 , a 8 , a 9 , and a 10  of the subset S 3 . Next, the secondary parity function f 3 (a) is decoded by effecting the sum of f 0 (a) and g 3 (a) and the node N 14  is reconstructed. 
     It should be noted that the repair of the nodes N 12  and N 13  requires only the transfer of 4 data blocks, respectively {f 0 (a), a 1 , a 2  and a 3 } and {f 0 (a), a 4 , a 5  and a 6 }, and that the repair of the node N 14  requires the transfer of 5 data blocks {f 0 (a), a 7 , a 8 , a 9 , a 10 }. 
     Thus, advantageously, the claimed reconstruction method requires only 4 or 5 data blocks for the reconstruction of any node i∈{1, . . . , 14}. It makes it possible to reduce the bandwidth and the inputs/outputs by 50% to 60% compared to an RS code. 
     The general principle of the coding method of the invention is now described for any code (k, r): 
     Starting from a datum a as input of size M, the general principle of the invention consists in dividing the datum into k data blocks (a 1 , . . . , a k ), each block having a size M/k. Each data block as stored in the node N i  is of fixed size m=M/k. 
     The following notations are suitable for the description below:
         └X┘ expresses the integer part of X; and   ┌X┐ expresses the excess integer part of X.       

     The Babylon coding method begins with a step of division of the k data blocks (a 1 , . . . , a k ) into (r−1) subsets (S 1 , S 2 , . . . , S r−1 ), denoted S j , 1≤j≤r−1. If k is a multiple of r−1, the subsets have one and the same size k/r−1. If k is not a multiple of r−1, each of the r−1−q first subsets is composed of t f  data blocks, and the following q subsets contain t c  data blocks with: 
         t   f   =└k/r− 1┘,
 
         t   c   =┌k/r− 1┐,  q=k  mod( r− 1)
 
     The first subset S 1  is composed of data blocks belonging to (a 1 , . . . , a tf ). The j th  subset S j  is composed of data blocks belonging to (a (j−1)tf+1 , . . . , a jtf ), for (1≤j≤r−1). 
     The second step of the method consists in generating r encoding vectors comprising a primary encoding vector C 0  and r−1 secondary encoding vectors C j  (1&lt;=j&lt;=r−1). 
     The primary encoding vector C 0  is composed of k encoding coefficients c 0,1  to c 0,k  in which each primary encoding coefficient c 0,i  corresponds to a non-zero random number. 
     A secondary encoding vector C j  is composed of k encoding coefficients c j,1  to c j,k . To generate a secondary encoding vector C j , the method checks, for each block a i , whether the block a i  belongs to the subset S j . If such is the case, then the method makes it possible to associate non-zero random numbers with the coefficients c j,i , and if the block as does not belong to the subset S j , then the method makes it possible to associate zero random numbers with the coefficients c j,i . 
     The structure of the encoding vectors C 0  to C r−1  is represented hereinbelow: 
     
       
         
           
             
               c 
               0 
             
             = 
             
               [ 
               
                 
                   c 
                   
                     0 
                     , 
                     1 
                   
                 
                 , 
                 
                   c 
                   
                     0 
                     , 
                     2 
                   
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   c 
                   
                     0 
                     , 
                     k 
                   
                 
               
               ] 
             
           
         
       
       
         
           
             
               c 
               1 
             
             = 
             
               [ 
               
                 
                   c 
                   
                     1 
                     , 
                     1 
                   
                 
                 , 
                 
                   c 
                   
                     1 
                     , 
                     2 
                   
                 
                 , 
                 
                   c 
                   
                     1 
                     , 
                     tf 
                   
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
               
               ] 
             
           
         
       
       
         
           
             
               c 
               2 
             
             = 
             
               [ 
               
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
                 , 
                 
                   c 
                   
                     2 
                     , 
                     
                       tf 
                       + 
                       1 
                     
                   
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   
                     c 
                     
                       2 
                       , 
                       
                         2 
                          
                         tf 
                       
                     
                   
                    
                   0 
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
               
               ] 
             
           
         
       
       
         
           … 
         
       
       
         
           
             
               c 
               
                 r 
                 - 
                 q 
               
             
             = 
             
               [ 
               
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
                 , 
                 
                   c 
                   
                     
                       r 
                       - 
                       q 
                     
                     , 
                     
                       ( 
                       
                         r 
                         - 
                         q 
                         - 
                         1 
                       
                       ) 
                     
                     , 
                     
                       tf 
                       + 
                       1 
                     
                   
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   c 
                   
                     
                       r 
                       - 
                       q 
                     
                     , 
                     
                       
                         ( 
                         
                           r 
                           - 
                           q 
                         
                         ) 
                       
                        
                       t 
                        
                       c 
                     
                   
                 
                 , 
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
               
               ] 
             
           
         
       
       
         
           
             
               c 
               
                 r 
                 - 
                 q 
                 + 
                 1 
               
             
             = 
             
               [ 
               
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
                 , 
                 
                   c 
                   
                     
                       r 
                       - 
                       q 
                       + 
                       1 
                     
                     , 
                     
                       ( 
                       
                         r 
                         - 
                         q 
                       
                       ) 
                     
                     , 
                     
                       tc 
                       + 
                       1 
                     
                   
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   c 
                   
                     
                       r 
                       - 
                       q 
                       + 
                       1 
                     
                     , 
                     
                       ( 
                       
                         r 
                         - 
                         q 
                       
                       ) 
                     
                     , 
                     tc 
                   
                 
                 , 
                 0 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 0 
               
               ] 
             
           
         
       
       
         
           … 
         
       
       
         
           
             
               c 
               
                 r 
                 - 
                 1 
               
             
             = 
             
               
                 [ 
                 
                   0 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   0 
                   , 
                   
                     c 
                     
                       
                         r 
                         - 
                         1 
                       
                       , 
                       
                         rtc 
                         + 
                         1 
                       
                     
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     c 
                     
                       
                         r 
                         - 
                         1 
                       
                       , 
                       k 
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     After the step of generation of the encoding vectors, the method makes it possible to generate r parity functions, linear combinations of the data (a 1 , . . . , a k ) and composed of a primary parity function f 0 (a) and of r−1 secondary parity functions f 1 (a), . . . , f r−1 (a). 
     The primary parity function is a linear combination of the k data blocks (a 1 , . . . , a k ) and is stored in the parity node of index k+1, N k+1 . Each data block a i  has an associated encoding coefficient c 0,i  of the primary encoding vector C 0 . The primary parity function f 0 (a) can be written according to the following equation: 
         f   0 ( a )= c   0,1   *a   1   +c   0,2   *a   2   + . . . +c   0,k   *a   k    
     in which the coefficients c 0,1 , c 0,2 , . . . , c 0,k  are non-zero random numbers. 
     To generate the r−1 secondary parity functions f j (a) (1&lt;=j&lt;=r−1), the method makes it possible to generate first of all r−1 linear functions g j (a) (1&lt;=j&lt;=r−1). Each linear function g j (a) is a linear combination of the k data blocks (a 1 , . . . , a k ) and of the encoding vectors C j  (1&lt;=j&lt;=r−1). Once the linear functions g j (a) (1&lt;=j&lt;=r−1) are generated, the method makes it possible to create the secondary parity functions f 1 (a), f 2 (a), . . . f r−1 (a) such that a secondary parity function f j (a), 1≤j≤r−1, is obtained by adding the primary parity function f 0 (a) to a linear function g j (a): 
         f   j ( a )= f   0 ( a )+ g   j ( a ) 
     The data blocks and the parity functions generated according to the coding of the invention are stored in storage nodes of a local or distributed storage system. The k data blocks (a 1 , . . . , a k ) are stored in k systematic nodes N i , i∈{1, . . . k} and each of the r parity blocks obtained by a parity function is stored in a parity node N i , i∈{k+1, . . . , k+r}, as illustrated in the table below: 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                 Node 1 
                 a 1   
               
               
                   
                 . 
                 . 
               
               
                   
                 . 
                 . 
               
               
                   
                 Node k 
                 a k   
               
               
                   
                 Node k + 1 
                 f o (a) 
               
               
                   
                 Node k + 2 
                 f o (a) + g 1 (a) 
               
               
                   
                 . 
                 . 
               
               
                   
                 . 
                 . 
               
               
                   
                 Node k + r 
                 f o (a) + g r−1 (a) 
               
               
                   
                   
               
            
           
         
       
     
     Advantageously, the linear functions g j (a), 1≤j≤r−1 and the primary parity function f 0 (a) are generated so as to be linearly independent of one another. Moreover, the sum of any two of these functions is also linearly independent of the other functions. Finally, advantageously, all the data blocks being linearly independent, the Babylon code maintains the same properties as an RS code. 
     The general principle of the reconstruction method of the invention is now described for any code (k, r). The reconstruction method is initiated when information relating to the detection of a failure in the storage system is available. The method can be initiated to duplicate the content of a node. The reconstruction method in the case of a failure works for the cases in which a single storage node in a local or distributed storage system has failed. The repair steps will make it possible to retrieve, in the other storage nodes, the lost data which were contained in the node that has failed and to reconstruct a new storage node with the same data. 
     When a failure is detected, the method determines the nature of the node which has failed, namely whether it is a systematic node or a parity node. 
     If the failure relates to a systematic node N i , i∈{1, . . . , k}, that is to say a node storing data blocks a i , the reconstruction is done according to the case 1 described hereinbelow. 
     If the failure relates to a parity node N i , i∈{k+1, . . . , k+r}, that is to say a node storing parity functions, the reconstruction is done according to the case 2 described hereinbelow. 
     Case 1: Reconstruction of the Nodes N i , i∈{1, . . . k} 
     Considering a repair of the datum as stored in a node N i  such that (1≤i≤k) with a i ∈S j  and (1≤j&lt;r), the method makes it possible, initially, to transfer the data contained in the nodes of index k+1, N (k+1)  and of index k+1+j, N (k+1+j) . Next, the datum f 0 (a), stored in the node of index k+1, N (k+1) , is subtracted from the datum f j (a) stored in the node of index k+1+j, N (k+1+j)  to recover the linear function g j (a) associated with the subset S j . The method then makes it possible to transfer the data of the subset S j \{a i } (that is to say, except for the data block a i ). The use of the linear function g j (a) makes it possible to decode the lost datum a i . The number of data blocks needed to reconstruct as is therefore (t f +1) if i belongs to the (r−1−q) first subsets. If i belongs to the q last subsets, the total number of data blocks required is (t c +1). 
     Case 2: Reconstruction of the Nodes N i , i∈{k+1, . . . , k+r} 
     As in the preceding case, for the reconstruction of the node N i  such that k+1&lt;i≤k+r, the method makes it possible to transfer the datum f 0 (a) stored in the node of index k+1, N (k+1) , and the data located in the subset S i−k+1 . The linear function g i−k+1 (a) is obtained from the data of the subset S i−k+1 . Next, the decoding is performed by using the primary function f 0 (a) and the linear function g i−k+1 (a) to retrieve the secondary function f i−k+1 (a) (in effect, f i=k+1 (a)=f 0 (a)+g i−k+1 (a)). It should be noted that if (i−k+1) belongs to the (r−1−q) first blocks, the repair requires (t r +1) data blocks. If (i−k+1)∈{r−q, . . . , r−1}, then the repair requires (t c +1) blocks. 
     For the particular case of the node of index k+1, N k+1  containing the primary parity function f 0 (a), the method makes it possible to transfer the first subset S 1  to generate the linear function g 1 (a). The method then makes it possible to transfer the data from the node of index k+2, N k+2  containing the secondary parity function f 1 (a). By subtracting the linear function g 1 (a) from the secondary parity function f 1 (a), the primary parity function f 0 (a) is decoded (in effect, f 0 (a)=f 1 (a)−g 1 (a)). The datum of the node of index k+1, N k+1  containing the primary parity function f 0 (a), is retrieved by using (t f +1) data blocks. 
     Generally, the average value of the data transferred and read for the reconstruction/repair, whatever the type of node, is given by the following equation: 
     
       
         
           
             γ 
             = 
             
               
                 1 
                 
                   ( 
                   
                     k 
                     + 
                     r 
                   
                   ) 
                 
               
                
               
                 [ 
                 
                   
                     ( 
                     
                       
                         ( 
                         
                           
                             
                               ( 
                               
                                 r 
                                 - 
                                 1 
                                 - 
                                 q 
                               
                               ) 
                             
                             × 
                             
                               t 
                               j 
                             
                           
                           + 
                           
                             ( 
                             
                               r 
                               - 
                               q 
                             
                             ) 
                           
                         
                         ) 
                       
                       × 
                       
                         ( 
                         
                           
                             t 
                             j 
                           
                           + 
                           1 
                         
                         ) 
                       
                     
                     ) 
                   
                   + 
                   
                     ( 
                     
                       
                         q 
                          
                         
                           ( 
                           
                             
                               L 
                               c 
                             
                             + 
                             1 
                           
                           ) 
                         
                       
                       2 
                     
                     ) 
                   
                 
                 ] 
               
             
           
         
       
     
     It should be noted that the description takes for the example a value of r&gt;=3. For a value r=1, the Babylon code acts as a conventional RS code. For a value r=2, the data are divided into two subsets S 1  and S 2 , in which S 1  is composed of the t s  first blocks and S 2  contains the k−t s  last blocks, in which t s =└k/┘. 
     Advantageously, the method of the invention makes it possible to not use all the nodes in the reconstruction process. Moreover, the nodes contributing to the reconstruction do not have to perform computations, but they simply have to transfer their content to a data collector where the decoding operations will be performed. The data collector can be the new storage node replacing the failed node. 
     Still advantageously, by virtue of the Babylon coding method, the reconstruction time is reduced compared to the methods based on matrices in which all of the data blocks of the k nodes are necessary for the reconstruction. 
       FIG. 8  is a comparative table of the performance levels comparing the results of different known codes with those obtained by the Babylon code of the present invention. In the table ( 800 ), the first column lists the compared codes: RS; regenerators; exact regenerators; hierarchical; hitchhiker; and Babylon. 
     For all the codes, a file of the same size of M bytes coded using a (k=10, r=4) configuration was considered. 
     The evaluation was done for each code for one and the same storage efficiency (71%) column ( 804 ) on different parameters: the average bandwidth required for the repair ( 806 ), the disc inputs/outputs ( 808 ) and the tolerance to failures ( 810 ). The bandwidth and the disc inputs/outputs are expressed as a percentage relative to the size M of the original file. The percentages in the table are computed by taking account of the repair of the systematic nodes and of the parity nodes. 
     The results are as follows:
         For an RS code, the repair of a single failure requires M bytes to be read and transferred. This is equivalent to 100% of the original size of the file.       

     For the same storage efficiency, the bandwidth required by the regenerator codes and the exact regenerator codes are computed. The bandwidth used for the repair of a failure is on average equal to 32.5%. However, the disc inputs/outputs are not optimized. To repair a single failure, the regenerator codes require all the data stored in the nodes to be read before they are transferred. 
     The hierarchical code optimizes both the bandwidth and the disc inputs/outputs. The quantity of the data read and transferred in the network is equal to 33.57%. However, the hierarchical code does not maintain the same tolerance to failures as the RS codes. In effect, it is not possible to tolerate any 4 failures by using the hierarchical code. 
     The hitchhiker code makes it possible to both optimize the bandwidth and the disc inputs/outputs while maintaining the same tolerance to failures as the RS code. In this case, the quantity of the data read and transferred is equal to 76.42%. 
     The Babylon code requires on average 43.57% of the size of the original file to repair a single failure in terms of bandwidth and of disc inputs/outputs. It also makes it possible to tolerate any 4 failures out of the 14 nodes. 
     The present invention can be implemented from hardware and/or software elements. It can be available as a computer program product on a computer-readable medium. The medium can be electronic, magnetic, optical or electro-magnetic. In one embodiment, the method is implemented by computer. A computer program product is described, said computer program comprising code instructions making it possible to perform one or more of the steps of the method, when said program is run on a computer. In one embodiment, the device for implementing the invention comprises a computer-readable storage medium (RAM, ROM, flash memory or another memory technology, for example disc medium or another non-transient computer-readable storage medium) coded with a computer program (that is to say several executable instructions) which, when it is run on one or more processors, performs the functions of the embodiments described previously. As an example of hardware architecture suitable for implementing the invention, a device can comprise a communication bus to which are linked a central processing unit or microprocessor (CPU, acronym for Central Processing Unit), which processor can be “multi-core” or “many-core”; a read-only memory (ROM) that can comprise the programs necessary for the implementation of the invention; a random access memory or cache memory (RAM) comprising registers suitable for saving variables and parameters created and modified during the execution of the abovementioned programs; and a communication or I/O (input/output) interface, suitable for transmitting and receiving data. In the case where the invention is installed on a reprogrammable computation machine (for example an FPGA circuit), the corresponding program (that is to say the sequence of instructions) can be stored in or on a removable storage medium (for example an SD card, or a mass storage such as a hard disc, e.g. an SSD) or non-removable, volatile or non-volatile storage medium, this storage medium being partially or totally readable by a computer or a processor. The computer-readable medium can be transportable or communicable or mobile or transmissible (i.e. by a 2G, 3G, 4G, Wifi, BLE, fibre optic or other telecommunication network). The reference to a computer program which, when it is run, performs any one of the functions described previously, is not limited to an application program running on a single host computer. On the contrary, the terms computer program and software are used here in a general sense to refer to any type of computer code (for example, application software, firmware, microcode, or any other form of computer instruction, such as web services or SOA or via programming interfaces API) which can be used to program one or more processors to implement aspects of the techniques described here. The computer means or resources can in particular be distributed (“cloud computing”), possibly with or according to pair-to-pair and/or virtualization technologies. The software code can be executed on any appropriate processor (for example, a microprocessor) or processor core or a set of processors, whether they are provided in a single computation device or distributed between several computation devices (possibly accessible in the environment of the device). Securing technologies (crypto-processors, authentication, encryption, chip card, etc) can be used.