utils.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <format>
#include <functional>
#include <iostream>
#include <limits>
#include <stack>
#include <stdexcept>
#include <string_view>
#include <system_error>
#include <utility>
 
#if defined(__has_feature)
#if __has_feature(thread_sanitizer)
#include <sanitizer/tsan_interface.h>
#define tsan_acquire(addr) __tsan_acquire(addr)
#define tsan_release(addr) __tsan_release(addr)
#else
#define tsan_acquire(addr) static_cast<void>(0)
#define tsan_release(addr) static_cast<void>(0)
#endif
#else
#define tsan_acquire(addr) static_cast<void>(0)
#define tsan_release(addr) static_cast<void>(0)
#endif
 
namespace condy {
 
class [[nodiscard]] Defer {
public:
    template <typename Func>
    Defer(Func &&func) : func_(std::forward<Func>(func)) {}
    ~Defer() { func_(); }
 
    Defer(const Defer &) = delete;
    Defer &operator=(const Defer &) = delete;
    Defer(Defer &&) = delete;
    Defer &operator=(Defer &&) = delete;
 
private:
    std::function<void()> func_;
};

template <typename Func> Defer defer(Func &&func) {
    return Defer(std::forward<Func>(func));
}
 
template <typename BaseMutex> class MaybeMutex : public BaseMutex {
public:
    using Base = BaseMutex;
    using Base::Base;
 
    void lock() noexcept {
        if (use_mutex_) {
            Base::lock();
        }
    }
 
    void unlock() noexcept {
        if (use_mutex_) {
            Base::unlock();
        }
    }
 
    bool try_lock() noexcept {
        if (use_mutex_) {
            return Base::try_lock();
        }
        return true;
    }
 
    void set_use_mutex(bool use_mutex) noexcept { use_mutex_ = use_mutex; }
 
private:
    bool use_mutex_ = false;
};
 
[[noreturn]] inline void panic_on(std::string_view msg) noexcept {
    std::cerr << std::format("Panic: {}\n", msg);
#ifndef CRASH_TEST
    std::terminate();
#else
    // Ctest cannot handle SIGABRT, so we use exit here
    std::exit(EXIT_FAILURE);
#endif
}
 
template <typename T> class RawStorage {
public:
    template <typename... Args> void construct(Args &&...args) {
        new (&storage_) T(std::forward<Args>(args)...);
    }
 
    T &get() { return *reinterpret_cast<T *>(&storage_); }
 
    const T &get() const { return *reinterpret_cast<const T *>(&storage_); }
 
    void destroy() { get().~T(); }
 
private:
    alignas(T) unsigned char storage_[sizeof(T)];
};
 
template <typename T, size_t N> class SmallArray {
public:
    SmallArray(size_t capacity) : capacity_(capacity) {
        if (!is_small_()) {
            large_ = new T[capacity];
        }
    }
 
    ~SmallArray() {
        if (!is_small_()) {
            delete[] large_;
        }
    }
 
    T &operator[](size_t index) {
        return is_small_() ? small_[index] : large_[index];
    }
 
    const T &operator[](size_t index) const {
        return is_small_() ? small_[index] : large_[index];
    }
 
    size_t capacity() const { return capacity_; }
 
private:
    bool is_small_() const { return capacity_ <= N; }
 
private:
    size_t capacity_;
    union {
        T small_[N];
        T *large_;
    };
};
 
inline auto make_system_error(std::string_view msg, int ec) {
    return std::system_error(ec, std::generic_category(), std::string(msg));
}
 
template <typename M, typename T> constexpr ptrdiff_t offset_of(M T::*member) {
    constexpr T *dummy = nullptr;
    return reinterpret_cast<ptrdiff_t>(&(dummy->*member));
}
 
template <typename M, typename T> T *container_of(M T::*member, M *ptr) {
    auto offset = offset_of(member);
    // NOLINTNEXTLINE(performance-no-int-to-ptr)
    return reinterpret_cast<T *>(reinterpret_cast<intptr_t>(ptr) - offset);
}
 
template <typename T, T From = 0, T To = std::numeric_limits<T>::max()>
class IdPool {
public:
    static_assert(From < To, "Invalid ID range");
 
    T allocate() {
        if (!recycled_ids_.empty()) {
            T id = recycled_ids_.top();
            recycled_ids_.pop();
            return id;
        }
        if (next_id_ < To) {
            return next_id_++;
        }
        throw std::runtime_error("ID pool exhausted");
    }
 
    void recycle(T id) {
        assert(From <= id && id < next_id_ && id < To);
        recycled_ids_.push(id);
    }
 
    void reset() {
        next_id_ = From;
        while (!recycled_ids_.empty()) {
            recycled_ids_.pop();
        }
    }
 
private:
    T next_id_ = From;
    std::stack<T> recycled_ids_;
};
 
class AtomicMutex {
public:
    void lock() noexcept {
        bool expected = false;
        while (!lock_.compare_exchange_weak(expected, true,
                                            std::memory_order_acquire,
                                            std::memory_order_relaxed)) {
            expected = false;
            lock_.wait(true, std::memory_order_relaxed);
        }
    }
 
    void unlock() noexcept {
        lock_.store(false, std::memory_order_release);
        lock_.notify_one();
    }
 
private:
    std::atomic_bool lock_ = false;
};
 
} // namespace condy