XrdEc::RedundancyProvider Class Reference

#include <XrdEcRedundancyProvider.hh>

Collaboration diagram for XrdEc::RedundancyProvider:

Public Member Functions
	RedundancyProvider (const ObjCfg &objcfg)
void	compute (stripes_t &stripes)

Detailed Description

The redundancy provider class offers automatic parity computing and data recovery. Depending on configuration it will use erasure coding or replication.

Definition at line 41 of file XrdEcRedundancyProvider.hh.

Constructor & Destructor Documentation

RedundancyProvider()

XrdEc::RedundancyProvider::RedundancyProvider

(

const ObjCfg &

objcfg

)

Constructor. Stripe parameters (number of data and parity blocks) are constant per ErasureEncoding object.

Definition at line 151 of file XrdEcRedundancyProvider.cc.

                                                             :
    objcfg( objcfg ),
    encode_matrix( objcfg.nbchunks * objcfg.nbdata )
{
  // k = data
  // m = data + parity
  gf_gen_cauchy1_matrix( encode_matrix.data(), static_cast<int>( objcfg.nbchunks ), static_cast<int>( objcfg.nbdata ) );
}

Member Function Documentation

compute()

void XrdEc::RedundancyProvider::compute

(

stripes_t &

stripes

)

Compute all missing data and parity blocks in the the stripe. Stripe size has to equal nData+nParity. Blocks can be arbitrary size, but size has to be equal within a stripe. Function will throw on incorrect input.

Parameters

stripes

nData+nParity blocks, missing (empty) blocks will be computed if possible.

Definition at line 233 of file XrdEcRedundancyProvider.cc.

{
  /* throws if stripe is not recoverable */
  std::string pattern = getErrorPattern( stripes );
 
  /* nothing to do if there are no parity blocks. */
  if ( !objcfg.nbparity ) return;
 
  /* in case of a single data block use replication */
  if ( objcfg.nbdata == 1 )
    return replication( stripes );
 
  /* normal operation: erasure coding */
  CodingTable& dd = getCodingTable(pattern);
 
  unsigned char* inbuf[objcfg.nbdata];
  for( uint8_t i = 0; i < objcfg.nbdata; i++ )
    inbuf[i] = reinterpret_cast<unsigned char*>( stripes[dd.blockIndices[i]].buffer );
 
  std::vector<unsigned char> memory( dd.nErrors * objcfg.chunksize );
 
  unsigned char* outbuf[dd.nErrors];
  for (int i = 0; i < dd.nErrors; i++)
  {
    outbuf[i] = &memory[i * objcfg.chunksize];
  }
 
  ec_encode_data(
      static_cast<int>( objcfg.chunksize ), // Length of each block of data (vector) of source or destination data.
      static_cast<int>( objcfg.nbdata ),     // The number of vector sources in the generator matrix for coding.
      dd.nErrors,     // The number of output vectors to concurrently encode/decode.
      dd.table.data(), // Pointer to array of input tables
      inbuf,          // Array of pointers to source input buffers
      outbuf          // Array of pointers to coded output buffers
  );
 
  int e = 0;
  for (size_t i = 0; i < objcfg.nbchunks; i++)
  {
    if( pattern[i] )
    {
      memcpy( stripes[i].buffer, outbuf[e], objcfg.chunksize );
      e++;
    }
  }
}

Referenced by XrdEc::WrtBuff::Encode().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• XrdEcRedundancyProvider.hh
• XrdEcRedundancyProvider.cc