ReadRepacker.h

Go to the documentation of this file.

#include <vector>

#include "Utilities/StorageFactory/interface/IOPosBuffer.h"
#include "FWCore/Utilities/interface/propagate_const.h"

class ReadRepacker {
public:
  // Returns the number of input buffers it was able to pack into the IO operation.
  int pack(long long int *pos,   // An array of file offsets to read.
           int *len,             // An array of lengths to read.
           int nbuf,             // Size of the pos and len array.
           char *buf,            // Temporary buffer to hold I/O result.
           IOSize buffer_size);  // Size of the temporary buffer.

  void unpack(
      char *buf);  // Buffer to unpack the I/O results into.  Not the temporayr buffer and result buffer may overlap.

  std::vector<IOPosBuffer> &iov() { return m_iov; }  // Returns the IO vector, optimized for storage.

  IOSize bufferUsed() const { return m_buffer_used; }  // Returns the total amount of space in the temp buffer used.
  IOSize extraBytes() const {
    return m_extra_bytes;
  }  // Returns the number of extra bytes to be issued to the I/O system
     // Note that (buffer_used - extra_bytes) should equal the number of "real" bytes serviced.
  IOSize realBytesProcessed() const {
    return m_buffer_used - m_extra_bytes;
  }  // Return the number of bytes of the input request that would be processed by the IO vector

  // Two reads distanced by less than READ_COALESCE_SIZE will turn into one
  // large read.
  static const IOSize TEMPORARY_BUFFER_SIZE = 256 * 1024;

  // A read larger than BIG_READ_SIZE will not be coalesced.
  static const IOSize READ_COALESCE_SIZE = 32 * 1024;

  // The size of the temporary holding buffer for read-coalescing.
  static const IOSize BIG_READ_SIZE = 256 * 1024;

private:
  int packInternal(long long int *pos,
                   int *len,
                   int nbuf,
                   char *buf,
                   IOSize buffer_size);  // Heart of the implementation of Pack; because we pack up to 2 buffers,
                                         // its easier to break the method into two.

  void reset(unsigned int nbuf);  // Reset all the internal counters and arrays.  Resize arrays to be about nbuf long.

  std::vector<int> m_idx_to_iopb;  // Mapping from idx in the input array to the iopb in the IO vector
  std::vector<int>
      m_idx_to_iopb_offset;        // Mapping from idx in the input array to the data offset in the results of the iopb.
  std::vector<IOPosBuffer> m_iov;  // Vector of IO for the storage system to perform.
  edm::propagate_const<int *> m_len;  // Pointed to the array of read sizes.
  IOSize m_buffer_used;               // Bytes in the temporary buffer used.
  IOSize m_extra_bytes;               // Number of bytes read from storage that will be discarded.
  std::vector<char> m_spare_buffer;  // The spare buffer; allocated if we cannot fit the I/O results into the ROOT buffer.
};