Threading.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_THREADING
#define SC_EXPORT_LIBRARY_THREADING 0
#endif
#define SC_THREADING_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_THREADING)
 
#include "../Common/AlignedStorage.h"
#include "../Common/Assert.h"
#include "../Common/Function.h"
#include "../Common/PlatformMacrosType.h"
#include "../Common/PrimitiveDefinitions.h"
#include "../Common/Result.h"
#include "Internal/Optional.h" // UniqueOptional
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(ThreadingAssert, SC_THREADING_EXPORT);
 
#define SC_THREADING_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::ThreadingAssert, e)
#define SC_THREADING_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::ThreadingAssert, e)
#define SC_THREADING_TRUST_RESULT(expression) SC_THREADING_ASSERT_RELEASE(expression)
 
 
 
struct SC_THREADING_EXPORT 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_THREADING_EXPORT 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_THREADING_EXPORT 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_THREADING_EXPORT 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_THREADING_EXPORT 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_THREADING_EXPORT EventObject
{
    bool autoReset = true;
 
    void wait();
 
    void signal();
 
  private:
    bool  isSignaled = false;
    Mutex mutex;
 
    ConditionVariable cond;
};
 
struct SC_THREADING_EXPORT Semaphore
{
    Semaphore(int initialCount = 0);
 
    void acquire();
 
    void release();
 
  private:
    int   count;
    Mutex mutex;
 
    ConditionVariable condition;
};
 
} // namespace SC