sync.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <memory>
#include <utility>
#include <vector>
 
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex::platform {

class REX_API Fence {
 public:
  Fence();
 
  Fence(const Fence&) = delete;
  Fence& operator=(const Fence&) = delete;
 
  ~Fence();

  void Signal();

  void Wait();
 
 private:
  struct Impl;
  std::unique_ptr<Impl> impl_;
};
 
enum class WaitResult : u8 {
  kSuccess,      
  kUserCallback, 
  kTimeout,      
  kAbandoned,    
  kFailed,
};

class WaitHandle {
 public:
  virtual ~WaitHandle() = default;

  virtual void* GetNativeHandle() const = 0;
 
 protected:
  WaitHandle() = default;
};

REX_API WaitResult Wait(WaitHandle* wait_handle, bool is_alertable,
                        std::chrono::milliseconds timeout = std::chrono::milliseconds::max());

REX_API WaitResult SignalAndWait(
    WaitHandle* wait_handle_to_signal, WaitHandle* wait_handle_to_wait_on, bool is_alertable,
    std::chrono::milliseconds timeout = std::chrono::milliseconds::max());

REX_API std::pair<WaitResult, size_t> WaitMultiple(
    WaitHandle* wait_handles[], size_t wait_handle_count, bool wait_all, bool is_alertable,
    std::chrono::milliseconds timeout = std::chrono::milliseconds::max());

inline WaitResult WaitAll(WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable,
                          std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) {
  return WaitMultiple(wait_handles, wait_handle_count, true, is_alertable, timeout).first;
}

inline WaitResult WaitAll(std::vector<WaitHandle*> wait_handles, bool is_alertable,
                          std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) {
  return WaitAll(wait_handles.data(), wait_handles.size(), is_alertable, timeout);
}

inline std::pair<WaitResult, size_t> WaitAny(
    WaitHandle* wait_handles[], size_t wait_handle_count, bool is_alertable,
    std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) {
  return WaitMultiple(wait_handles, wait_handle_count, false, is_alertable, timeout);
}

inline std::pair<WaitResult, size_t> WaitAny(
    std::vector<WaitHandle*> wait_handles, bool is_alertable,
    std::chrono::milliseconds timeout = std::chrono::milliseconds::max()) {
  return WaitAny(wait_handles.data(), wait_handles.size(), is_alertable, timeout);
}

class REX_API Event : public WaitHandle {
 public:
  static std::unique_ptr<Event> CreateManualResetEvent(bool initial_state);

  static std::unique_ptr<Event> CreateAutoResetEvent(bool initial_state);

  virtual void Set() = 0;
 
  virtual void Reset() = 0;

  virtual void Pulse() = 0;
};

class REX_API Semaphore : public WaitHandle {
 public:
  static std::unique_ptr<Semaphore> Create(int initial_count, int maximum_count);

  virtual bool Release(int release_count, int* out_previous_count) = 0;
};

class REX_API Mutant : public WaitHandle {
 public:
  static std::unique_ptr<Mutant> Create(bool initial_owner);

  virtual bool Release() = 0;
};
 
}  // namespace rex::platform