fiber_exec.hpp

Go to the documentation of this file.

 
#ifndef LELY_EV_FIBER_EXEC_HPP_
#define LELY_EV_FIBER_EXEC_HPP_
 
#include <lely/ev/exec.hpp>
#include <lely/ev/fiber_exec.h>
#include <lely/ev/future.hpp>
#include <lely/util/fiber.hpp>
 
#include <mutex>
#include <utility>
 
namespace lely {
namespace ev {
 
using FiberFlag = util::FiberFlag;

class FiberThread {
 public:
  FiberThread(FiberFlag flags = static_cast<FiberFlag>(0),
              ::std::size_t stack_size = 0, ::std::size_t max_unused = 0) {
    if (ev_fiber_thrd_init(static_cast<int>(flags), stack_size, max_unused) ==
        -1)
      util::throw_errc("FiberThread");
  }

  FiberThread(FiberFlag flags, ::std::size_t stack_size,
              ::std::size_t max_unused, bool& already) {
    int result =
        ev_fiber_thrd_init(static_cast<int>(flags), stack_size, max_unused);
    if (result == -1) util::throw_errc("FiberThread");
    already = result != 0;
  }
 
  FiberThread(const FiberThread&) = delete;
  FiberThread(FiberThread&&) = delete;
 
  FiberThread& operator=(const FiberThread&) = delete;
  FiberThread& operator=(FiberThread&&) = delete;

  ~FiberThread() { ev_fiber_thrd_fini(); }
};

class FiberExecutor : public Executor {
 public:
  explicit FiberExecutor(Executor inner_exec)
      : Executor(ev_fiber_exec_create(inner_exec)) {
    if (!exec_) ::lely::util::throw_errc("FiberExecutor");
  }
 
  FiberExecutor(const FiberExecutor&) = delete;
 
  FiberExecutor(FiberExecutor&& other) noexcept : Executor(other) {
    other.exec_ = nullptr;
  }
 
  FiberExecutor& operator=(const FiberExecutor&) = delete;
 
  FiberExecutor&
  operator=(FiberExecutor&& other) noexcept {
    using ::std::swap;
    swap(exec_, other.exec_);
    return *this;
  }

  ~FiberExecutor() { ev_fiber_exec_destroy(exec_); }

  Executor
  get_inner_executor() const noexcept {
    return Executor(ev_fiber_exec_get_inner_exec(*this));
  }
};

template <class T, class E>
inline void
fiber_await(Future<T, E> f) noexcept {
  ev_fiber_await(f);
}

inline void
fiber_yield() noexcept {
  ev_fiber_await(nullptr);
}
 
namespace detail {
 
inline void
throw_fiber_error(const char* what_arg, int ev) {
  switch (ev) {
    case ev_fiber_success:
      break;
    case ev_fiber_error:
      util::throw_errc(what_arg);
    case ev_fiber_timedout:
      throw ::std::system_error(::std::make_error_code(::std::errc::timed_out),
                                what_arg);
    case ev_fiber_busy:
      throw ::std::system_error(
          ::std::make_error_code(::std::errc::resource_unavailable_try_again),
          what_arg);
    case ev_fiber_nomem:
      throw ::std::system_error(
          ::std::make_error_code(::std::errc::not_enough_memory), what_arg);
  }
}

class FiberMutexBase {
 public:
  FiberMutexBase() = default;
 
  FiberMutexBase(const FiberMutexBase&) = delete;
  FiberMutexBase(FiberMutexBase&& other) = delete;
 
  FiberMutexBase& operator=(const FiberMutexBase&) = delete;
  FiberMutexBase& operator=(FiberMutexBase&& other) = delete;
 
  ~FiberMutexBase() { ev_fiber_mtx_destroy(*this); }
 
  operator ev_fiber_mtx_t*() noexcept { return &mtx_; }

  void
  lock() {
    int ev = ev_fiber_mtx_lock(*this);
    if (ev != ev_fiber_success) detail::throw_fiber_error("lock", ev);
  }

  bool
  try_lock() {
    int ev = ev_fiber_mtx_trylock(*this);
    switch (ev) {
      case ev_fiber_success:
        return true;
      case ev_fiber_busy:
        return false;
      default:
        detail::throw_fiber_error("try_lock", ev);
        return false;
    }
  }

  void
  unlock() {
    int ev = ev_fiber_mtx_unlock(*this);
    if (ev != ev_fiber_success) detail::throw_fiber_error("unlock", ev);
  }
 
 private:
  ev_fiber_mtx_t mtx_{nullptr};
};
 
}  // namespace detail

class FiberMutex : public detail::FiberMutexBase {
 public:
  FiberMutex() {
    int ev = ev_fiber_mtx_init(*this, ev_fiber_mtx_plain);
    if (ev != ev_fiber_success) detail::throw_fiber_error("FiberMutex", ev);
  }
};

class FiberRecursiveMutex : public detail::FiberMutexBase {
 public:
  FiberRecursiveMutex() {
    int ev = ev_fiber_mtx_init(*this, ev_fiber_mtx_recursive);
    if (ev != ev_fiber_success)
      detail::throw_fiber_error("FiberRecursiveMutex", ev);
  }
};

class FiberConditionVariable {
 public:
  FiberConditionVariable() {
    if (ev_fiber_cnd_init(*this) != ev_fiber_success)
      ::lely::util::throw_errc("FiberConditionVariable");
  }
 
  FiberConditionVariable(const FiberConditionVariable&) = delete;
  FiberConditionVariable(FiberConditionVariable&& other) = delete;
 
  FiberConditionVariable& operator=(const FiberConditionVariable&) = delete;
  FiberConditionVariable& operator=(FiberConditionVariable&& other) = delete;
 
  ~FiberConditionVariable() { ev_fiber_cnd_destroy(*this); }
 
  operator ev_fiber_cnd_t*() noexcept { return &cond_; }

  void
  notify_one() noexcept {
    ev_fiber_cnd_signal(*this);
  }

  void
  notify_all() noexcept {
    ev_fiber_cnd_broadcast(*this);
  }

  void
  wait(std::unique_lock<FiberMutex>& lock) {
    int ev = ev_fiber_cnd_wait(*this, *lock.mutex());
    if (ev != ev_fiber_success) detail::throw_fiber_error("wait", ev);
  }

  template <class Predicate>
  void
  wait(std::unique_lock<FiberMutex>& lock, Predicate pred) {
    while (!pred()) wait(lock);
  }
 
 private:
  ev_fiber_cnd_t cond_{nullptr};
};
 
}  // namespace ev
}  // namespace lely
 
#endif  // !LELY_EV_FIBER_EXEC_HPP_