Class RleRun

cpp/src/arrow/util/rle_encoding_internal.h:105–142

A Single Run Length Encoded run. Consist of a single value repeated multiple times. A previous version of this class also stored the value bit width to be self contain, removing it and passing it explicitly when needed proved to speed up decoding up to 10 % on some benchmarks.

/// removing it and passing it explicitly when needed proved to speed up decoding up to
/// 10 % on some benchmarks.
class RleRun {
 public:
  constexpr RleRun() noexcept = default;

  explicit RleRun(const uint8_t* data, rle_size_t values_count,
                  rle_size_t value_bit_width) noexcept
      : values_count_(values_count) {
    ARROW_DCHECK_GE(value_bit_width, 0);
    ARROW_DCHECK_GE(values_count, 0);
    std::copy(data, data + raw_data_size(value_bit_width), data_.begin());
  }

  /// The repeated value in the run in little endian form (as stored in the buffer).
  uint64_t value_little_endian() const noexcept {
    // Underlying memcpy is required to avoid undefined behavior.
    return SafeLoadAs<uint64_t>(data_.data());
  }

  /// The number of repeated values in this run.
  constexpr rle_size_t values_count() const noexcept { return values_count_; }

  /// A pointer to the repeated value raw bytes.
  constexpr const uint8_t* raw_data_ptr() const noexcept { return data_.data(); }

  /// The number of bytes used for the raw repeated value.
  constexpr rle_size_t raw_data_size(rle_size_t value_bit_width) const noexcept {
    auto out = bit_util::BytesForBits(value_bit_width);
    ARROW_DCHECK_LE(out, std::numeric_limits<rle_size_t>::max());
    return static_cast<rle_size_t>(out);
  }

 private:
  /// The repeated value raw bytes stored inside the class with enough space to store
  /// up to a 64 bit value.
  alignas(8) std::array<uint8_t, 8> data_ = {};
  /// The number of time the value is repeated.
  rle_size_t values_count_ = 0;
};

template <typename T>
class BitPackedRunDecoder;