sync.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt_config.hpp"
#include <cstdint>
#include <reloco/mutex.hpp>
#include <reloco/unique_lock.hpp>
 
namespace microfmt::log {
 
namespace detail {
 
struct MICROFMT_API_CLASS null_mutex {
  constexpr void lock() noexcept {}
  constexpr void unlock() noexcept {}
  [[nodiscard]] constexpr bool try_lock() noexcept { return true; }
};
 
} // namespace detail
 
inline constexpr std::uint64_t wait_forever = ~std::uint64_t{0};
 
struct null_wait_channel {
  constexpr void lock() noexcept {}
  constexpr void unlock() noexcept {}
  template <typename Pred> [[nodiscard]] constexpr bool wait_for(std::uint64_t, Pred pred) noexcept {
    return static_cast<bool>(pred());
  }
  constexpr void wake_all() noexcept {}
};
 
class condition_variable_wait_channel {
public:
  void lock() noexcept { mutex_.lock(); }
  void unlock() noexcept { mutex_.unlock(); }
 
  template <typename Pred> [[nodiscard]] bool wait_for(std::uint64_t timeout_us, Pred pred) noexcept {
    // The caller already owns mutex_; adopt it for the wait and hand it back.
    reloco::unique_lock<reloco::mutex> guard(mutex_, reloco::adopt_lock);
    bool ok = true;
    if (timeout_us == wait_forever) {
      ok = cv_.wait(guard, pred).has_value();
    } else {
      auto res = cv_.wait_for(guard, reloco::duration::from_micros(timeout_us), pred);
      ok = res.has_value() && *res;
    }
    (void)guard.release();
    return ok;
  }
 
  void wake_all() noexcept { cv_.notify_all(); }
 
private:
  reloco::mutex mutex_{};
  reloco::condition_variable cv_{};
};
 
class RELOCO_POINTER space_notifier {
public:
  using callback = void (*)(void *) noexcept;
 
  constexpr space_notifier() noexcept = default;
  constexpr space_notifier(void *ctx RELOCO_LIFETIMEBOUND, callback cb) noexcept : ctx_(ctx), cb_(cb) {}
 
  void notify() const noexcept {
    if (cb_ != nullptr) {
      cb_(ctx_);
    }
  }
 
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return cb_ != nullptr; }
 
private:
  void *ctx_{nullptr};
  callback cb_{nullptr};
};
 
} // namespace microfmt::log