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 EventObject;
} // 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();
 
    [[nodiscard]] Result start(Function<void(Thread&)>&& func);
 
    void setThreadName(const native_char_t* name);
 
    [[nodiscard]] Result join();
 
    [[nodiscard]] 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::EventObject
{
    bool autoReset = true;
 
    void wait();
 
    void signal();
 
  private:
    bool  isSignaled = false;
    Mutex mutex;
 
    ConditionVariable cond;
};