cache_line.h

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>

struct alignas(64) CacheLine {
  std::array<std::byte, 64> data;
};

class AlignedStorage {
 private:
  std::vector<CacheLine> data_;
 
 public:
  AlignedStorage() = default;
  AlignedStorage(size_t bits) : data_((bits + 511) / 512) {}

  void resize(size_t bits) { data_.resize((bits + 511) / 512); }
  std::span<CacheLine> AsLines() { return data_; }
  std::span<const CacheLine> AsConstLines() const { return data_; }

  std::span<uint64_t> As64BitInts() {
    return std::span<uint64_t>(reinterpret_cast<uint64_t*>(data_.data()),
                               data_.size() * 8);
  }

  std::span<const uint64_t> AsConst64BitInts() const {
    return std::span<const uint64_t>(
        reinterpret_cast<const uint64_t*>(data_.data()), data_.size() * 8);
  }

  std::span<std::byte> AsBytes() {
    return std::span<std::byte>(reinterpret_cast<std::byte*>(data_.data()),
                                data_.size() * 64);
  }

  std::span<const std::byte> AsConstBytes() const {
    return std::span<const std::byte>(
        reinterpret_cast<const std::byte*>(data_.data()), data_.size() * 64);
  }

  std::span<std::uint16_t> As16BitInts() {
    return std::span<std::uint16_t>(
        reinterpret_cast<std::uint16_t*>(data_.data()), data_.size() * 32);
  }

  std::span<const std::uint16_t> AsConst16BitInts() const {
    return std::span<const std::uint16_t>(
        reinterpret_cast<const std::uint16_t*>(data_.data()),
        data_.size() * 32);
  }
};