sync.hpp

#pragma once
 
#include "../topic.hpp"
 
namespace LibXR
{
struct Topic::SyncBlock : public SuberBlock
{
  enum WaitState : uint32_t
  {
    WAIT_IDLE = 0,    
    WAITING = 1,      
    WAIT_CLAIMED = 2  
  };
 
  void* buff_addr;  
  void (*copy_payload)(
      void* dst,
      void* payload_addr);  
  MicrosecondTimestamp
      timestamp;  
  std::atomic<uint32_t> wait_state =
      WAIT_IDLE;  
  Semaphore sem;  
};
 
template <typename Data>
class Topic::SyncSubscriber
{
 public:
  SyncSubscriber(const char* name, Data& data, Domain* domain = nullptr)
      : SyncSubscriber(Topic(WaitTopic(name, UINT32_MAX, domain)), data)
  {
  }
 
  SyncSubscriber(Topic topic, Data& data)
  {
    Topic::CheckSubscriberType<Data>(topic);
 
    block_ = new LockFreeList::Node<SyncBlock>;
    block_->data_.type = SuberType::SYNC;
    block_->data_.timestamp = MicrosecondTimestamp();
    block_->data_.wait_state.store(SyncBlock::WAIT_IDLE, std::memory_order_relaxed);
    block_->data_.buff_addr = &data;
    block_->data_.copy_payload = &Topic::CopyPayload<Data>;
    topic.block_->data_.subers.Add(*block_);
  }
 
  SyncSubscriber(const SyncSubscriber& other) = delete;
 
  SyncSubscriber& operator=(const SyncSubscriber& other) = delete;
 
  SyncSubscriber(SyncSubscriber&& other) noexcept : block_(other.block_)
  {
    other.block_ = nullptr;
  }
 
  SyncSubscriber& operator=(SyncSubscriber&& other) noexcept
  {
    if (this != &other)
    {
      block_ = other.block_;
      other.block_ = nullptr;
    }
    return *this;
  }
 
  ErrorCode Wait(uint32_t timeout = UINT32_MAX)
  {
    ASSERT(block_ != nullptr);
 
    auto& data = block_->data_;
    uint32_t expected = SyncBlock::WAIT_IDLE;
    if (!data.wait_state.compare_exchange_strong(expected, SyncBlock::WAITING,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_acquire))
    {
      return ErrorCode::BUSY;
    }
 
    auto wait_ans = data.sem.Wait(timeout);
    if (wait_ans == ErrorCode::OK)
    {
      data.wait_state.store(SyncBlock::WAIT_IDLE, std::memory_order_release);
      return ErrorCode::OK;
    }
 
    expected = SyncBlock::WAITING;
    if (data.wait_state.compare_exchange_strong(expected, SyncBlock::WAIT_IDLE,
                                                std::memory_order_acq_rel,
                                                std::memory_order_acquire))
    {
      return wait_ans;
    }
 
    DEV_ASSERT(data.wait_state.load(std::memory_order_acquire) ==
               SyncBlock::WAIT_CLAIMED);
 
    ErrorCode finish_wait_ans;
    do
    {
      finish_wait_ans = data.sem.Wait(UINT32_MAX);
    } while (finish_wait_ans == ErrorCode::TIMEOUT);
    REQUIRE(finish_wait_ans == ErrorCode::OK);
    data.wait_state.store(SyncBlock::WAIT_IDLE, std::memory_order_release);
    return ErrorCode::OK;
  }
 
  MicrosecondTimestamp GetTimestamp() const { return block_->data_.timestamp; }
 
  LockFreeList::Node<SyncBlock>* block_ =
      nullptr;  
};
}  // namespace LibXR