seq_ring.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
// https://en.wikipedia.org/wiki/Seqlock
#pragma once
#include "sol3/core/stream_writer.h"
 
#include <flatbuffers/stl_emulation.h>
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <vector>
 
namespace sol3::core {
 
size_t constexpr kCacheLineSize = 64;
 
void* checkAlignedAs(void* data, size_t alignment);
 
void const* checkAlignedAs(void const* data, size_t alignment);
 
size_t checkSize(size_t size, size_t min_size);
 
std::size_t alignUp(std::size_t v, std::size_t a);
 
void atomicStoreMemcpy(void* dst, void const* src, size_t bytes);
 
void atomicLoadMemcpy(void* dst, void const* src, size_t bytes);
 
struct alignas(kCacheLineSize) SeqRingSlotHeader {
  alignas(kCacheLineSize) std::atomic<uint64_t> seq;
  uint32_t slot_type;
  uint64_t max_size;
  std::atomic<uint64_t> size;
};
 
struct alignas(kCacheLineSize) SeqRingHeader {
  alignas(kCacheLineSize) std::atomic<uint64_t> head_seq;
  std::atomic<uint64_t> head_gen;
  uint32_t slot_type;
  uint64_t slot_count;
  uint64_t slot_size;
};
 
class SeqRingSlotView {
 public:
  SeqRingSlotView() = default;
  SeqRingSlotView(SeqRingSlotHeader const* header, size_t seq);
 
  size_t copyTo(void* dest, std::chrono::steady_clock::duration time_out) const;
 
  size_t readInto(
      IStreamWriter& stream,
      std::chrono::steady_clock::duration time_out) const;
 
  size_t maxSize() const;
 
  bool dirty(std::memory_order order = std::memory_order_seq_cst) const;
 
  uint64_t seq() const;
 
  uint32_t slotType() const;
 
 private:
  size_t size() const;
 
  uint8_t const* data() const;
 
  SeqRingSlotHeader const* header_ = nullptr;
  uint64_t seq_ = 0;
};
 
class SeqRingWriter {
 public:
  static size_t minDataSize(size_t n_slots, size_t slot_size);
 
  SeqRingWriter(
      uint32_t slot_type,
      void* data,
      size_t data_size,
      size_t n_slots,
      size_t slot_size);
 
  uint64_t write(
      void const* header_data,
      size_t header_size,
      void const* payload_data,
      size_t payload_size);
 
  uint64_t head() const;
 
  flatbuffers::span<uint8_t const> slotSpan(uint64_t seq) const;
 
  size_t slotCount() const;
 
  size_t slotSize() const;
 
  uint32_t slotType() const;
 
 private:
  void* data_;
  size_t data_size_;
  SeqRingHeader* header_;
  std::vector<SeqRingSlotHeader*> slot_headers_;
};
 
class SeqRingReader {
 public:
  SeqRingReader() = default;
  SeqRingReader(void const* data, size_t data_size);
 
  uint64_t head() const;
 
  SeqRingSlotView slot(size_t seq) const;
 
  size_t slotCount() const;
  size_t slotSize() const;
 
  uint32_t slotType() const;
 
  flatbuffers::span<uint8_t const> trailerSpan() const;
 
 private:
  void const* data_ = nullptr;
  size_t data_size_ = 0;
  SeqRingHeader const* header_ = nullptr;
  std::vector<SeqRingSlotHeader const*> slot_headers_;
};
 
}  // namespace sol3::core