Threading.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/AlignedStorage.h"
#include "../Foundation/Function.h"
#include "../Foundation/Result.h"
#include "Internal/Optional.h" // UniqueOptional
 
namespace SC
{
struct Thread;
struct ConditionVariable;
struct Mutex;
struct RWLock;
struct Barrier;
struct EventObject;
struct Semaphore;
} // namespace SC
 
 
 
struct SC::Mutex
{
    Mutex();
    ~Mutex();
 
    // Underlying OS primitives can't be copied or moved
    Mutex(const Mutex&)            = delete;
    Mutex(Mutex&&)                 = delete;
    Mutex& operator=(const Mutex&) = delete;
    Mutex& operator=(Mutex&&)      = delete;
 
    void lock();
    void unlock();
 
  private:
    friend struct ConditionVariable;
#if SC_PLATFORM_APPLE
    static constexpr int OpaqueMutexSize      = 56 + sizeof(long);
    static constexpr int OpaqueMutexAlignment = alignof(long);
#elif SC_PLATFORM_WINDOWS
    static constexpr int OpaqueMutexSize      = 4 * sizeof(void*) + 2 * sizeof(long);
    static constexpr int OpaqueMutexAlignment = alignof(void*);
#elif SC_PLATFORM_EMSCRIPTEN
    static constexpr int OpaqueMutexSize      = sizeof(void*) * 6 + sizeof(long);
    static constexpr int OpaqueMutexAlignment = alignof(long);
#else
    static constexpr int OpaqueMutexSize      = sizeof(void*) * 6;
    static constexpr int OpaqueMutexAlignment = alignof(long);
#endif
    // Wrap native mutex as opaque array of bytes
    using OpaqueMutex = AlignedStorage<OpaqueMutexSize, OpaqueMutexAlignment>;
    OpaqueMutex mutex;
};
 
struct SC::ConditionVariable
{
    ConditionVariable();
    ~ConditionVariable();
 
    // Underlying OS primitives can't be copied or moved
    ConditionVariable(const ConditionVariable&)            = delete;
    ConditionVariable(ConditionVariable&&)                 = delete;
    ConditionVariable& operator=(const ConditionVariable&) = delete;
    ConditionVariable& operator=(ConditionVariable&&)      = delete;
 
    void wait(Mutex& mutex);
    void signal();
    void broadcast();
 
  private:
#if SC_PLATFORM_APPLE
    static constexpr int OpaqueCVSize      = 40 + sizeof(long);
    static constexpr int OpaqueCVAlignment = alignof(long);
#elif SC_PLATFORM_WINDOWS
    static constexpr int OpaqueCVSize      = sizeof(void*);
    static constexpr int OpaqueCVAlignment = alignof(void*);
#elif SC_PLATFORM_EMSCRIPTEN
    static constexpr int OpaqueCVSize      = sizeof(void*) * 12;
    static constexpr int OpaqueCVAlignment = alignof(long);
#else
    static constexpr int OpaqueCVSize      = sizeof(void*) * 6;
    static constexpr int OpaqueCVAlignment = alignof(long);
#endif
 
    //  Wrap native condition variable as opaque array of bytes
    using OpaqueConditionVariable = AlignedStorage<OpaqueCVSize, OpaqueCVAlignment>;
    OpaqueConditionVariable condition;
};
 
struct SC::Thread
{
    Thread() = default;
    ~Thread();
 
    // Cannot be copied or moved (as it would require a dynamic allocation for the type erased Function)
    Thread(Thread&&)                 = delete;
    Thread& operator=(Thread&&)      = delete;
    Thread(const Thread&)            = delete;
    Thread& operator=(const Thread&) = delete;
 
    static uint64_t CurrentThreadID();
 
    uint64_t threadID();
 
    Result start(Function<void(Thread&)>&& func);
 
    void setThreadName(const native_char_t* name);
 
    Result join();
 
    Result detach();
 
    [[nodiscard]] bool wasStarted() const;
 
    static void Sleep(uint32_t milliseconds);
 
  private:
    void setThreadNameInternal(const native_char_t* name);
    struct Internal;
    using OpaqueThread = AlignedStorage<sizeof(void*), alignof(void*)>;
    UniqueOptional<OpaqueThread> thread;
    Function<void(Thread&)>      userFunction;
};
 
struct SC::RWLock
{
    RWLock()  = default;
    ~RWLock() = default;
 
    RWLock(const RWLock&)            = delete;
    RWLock(RWLock&&)                 = delete;
    RWLock& operator=(const RWLock&) = delete;
    RWLock& operator=(RWLock&&)      = delete;
 
    void lockRead();
 
    void unlockRead();
 
    void lockWrite();
 
    void unlockWrite();
 
  private:
    Mutex mutex;
 
    ConditionVariable readersQ;
    ConditionVariable writersQ;
 
    int  activeReaders  = 0;
    int  waitingWriters = 0;
    bool writerActive   = false;
};
 
struct SC::Barrier
{
    Barrier(uint32_t count) : threadCount(count) {}
 
    void wait();
 
  private:
    const uint32_t threadCount;
 
    uint32_t waitCount  = 0;
    uint32_t generation = 0;
    Mutex    mutex;
 
    ConditionVariable condition;
};
 
struct SC::EventObject
{
    bool autoReset = true;
 
    void wait();
 
    void signal();
 
  private:
    bool  isSignaled = false;
    Mutex mutex;
 
    ConditionVariable cond;
};
 
struct SC::Semaphore
{
    Semaphore(int initialCount = 0);
 
    void acquire();
 
    void release();
 
  private:
    int   count;
    Mutex mutex;
 
    ConditionVariable condition;
};