chunk_detector.h

Go to the documentation of this file.

#ifndef CVMFS_INGESTION_CHUNK_DETECTOR_H_
#define CVMFS_INGESTION_CHUNK_DETECTOR_H_

#include <gtest/gtest_prod.h>
#include <stdint.h>

#include <cstdlib>

#include <algorithm>

class BlockItem;

class ChunkDetector {
 public:
  ChunkDetector() : last_cut_(0), offset_(0) {}
  virtual ~ChunkDetector() { }
  uint64_t FindNextCutMark(BlockItem *block);

  virtual bool MightFindChunks(uint64_t size) const = 0;

 protected:
  virtual uint64_t DoFindNextCutMark(BlockItem *block) = 0;

  virtual uint64_t DoCut(uint64_t offset) {
    last_cut_ = offset;
    return offset;
  }

  virtual uint64_t NoCut(uint64_t /* offset */) { return 0; }

  uint64_t last_cut() const { return last_cut_; }
  uint64_t offset() const { return offset_; }

 private:
  uint64_t last_cut_;
  uint64_t offset_;
};


class StaticOffsetDetector : public ChunkDetector {
 public:
  explicit StaticOffsetDetector(uint64_t s) : chunk_size_(s) { }
  bool MightFindChunks(uint64_t size) const { return size > chunk_size_; }

 protected:
  virtual uint64_t DoFindNextCutMark(BlockItem *buffer);

 private:
  const uint64_t chunk_size_;
};


class Xor32Detector : public ChunkDetector {
  FRIEND_TEST(T_ChunkDetectors, Xor32);

 public:
  Xor32Detector(const uint64_t minimal_chunk_size,
                const uint64_t average_chunk_size,
                const uint64_t maximal_chunk_size);

  bool MightFindChunks(const uint64_t size) const {
    return size > minimal_chunk_size_;
  }

 protected:
  virtual uint64_t DoFindNextCutMark(BlockItem *buffer);

  virtual uint64_t DoCut(const uint64_t offset) {
    xor32_     = 0;
    xor32_ptr_ = offset;
    return ChunkDetector::DoCut(offset);
  }

  virtual uint64_t NoCut(const uint64_t offset) {
    xor32_ptr_ = offset;
    return ChunkDetector::NoCut(offset);
  }

  inline void xor32(const unsigned char byte) {
    xor32_ = (xor32_ << 1) ^ byte;
  }

  inline bool CheckThreshold() {
    return abs(static_cast<int32_t>(xor32_) - kMagicNumber) < threshold_;
  }

 private:
  // xor32 only depends on a window of the last 32 bytes in the data stream
  static const unsigned kXor32Window = 32;
  static const int32_t kMagicNumber;

  const uint64_t minimal_chunk_size_;
  const uint64_t average_chunk_size_;
  const uint64_t maximal_chunk_size_;
  const int32_t threshold_;

  uint64_t xor32_ptr_;
  uint32_t xor32_;
};

#endif  // CVMFS_INGESTION_CHUNK_DETECTOR_H_