thread.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <climits>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <stop_token>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
 
#include <rex/assert.h>
#include <rex/platform.h>
#include <rex/platform/process.h>
#include <rex/platform/sync.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex::platform {
 
#if REX_PLATFORM_ANDROID
REX_API void AndroidInitialize();
REX_API void AndroidShutdown();
#endif
 
REX_API u32 GetLogicalProcessorCount();

REX_API void WidenProcessAffinity();

REX_API u32 GetCallerSystemThreadID();

REX_API u32 GetCallerThreadID();

REX_API void SetCallerThreadID(u32 id);

REX_API void SetCurrentThreadName(const std::string_view name);

REX_API void SetCurrentThreadPriority(i32 priority);

REX_API void MaybeYield();

REX_API void SyncMemory();

REX_API void SleepFor(std::chrono::microseconds duration);
 
template <typename Rep, typename Period>
void SleepFor(std::chrono::duration<Rep, Period> duration) {
  SleepFor(std::chrono::duration_cast<std::chrono::microseconds>(duration));
}

REX_API std::chrono::milliseconds GetCurrentThreadCPUTime();

enum class SleepResult : u8 {
  kSuccess,
  kAlerted, 
};

REX_API SleepResult AlertableSleep(std::chrono::microseconds duration);

template <typename Rep, typename Period>
SleepResult AlertableSleep(std::chrono::duration<Rep, Period> duration) {
  return AlertableSleep(std::chrono::duration_cast<std::chrono::microseconds>(duration));
}
 
using TLSHandle = u32;
constexpr TLSHandle kInvalidTLSHandle = UINT_MAX;
 
REX_API TLSHandle AllocateTLSHandle();
 
REX_API bool FreeTLSHandle(TLSHandle handle);

REX_API uintptr_t GetTLSValue(TLSHandle handle);

REX_API bool SetTLSValue(TLSHandle handle, uintptr_t value);
 
#if REX_PLATFORM_WIN32
struct ThreadPriority {
  static const i32 kLowest = -2;
  static const i32 kBelowNormal = -1;
  static const i32 kNormal = 0;
  static const i32 kAboveNormal = 1;
  static const i32 kHighest = 2;
};
#else
struct ThreadPriority {
  static const i32 kLowest = 1;
  static const i32 kBelowNormal = 8;
  static const i32 kNormal = 16;
  static const i32 kAboveNormal = 24;
  static const i32 kHighest = 32;
};
#endif

class REX_API Thread : public WaitHandle {
 public:
  struct CreationParameters {
    size_t stack_size = 4_MiB;
    bool create_suspended = false; 
    i32 initial_priority = 0;      
  };

  static std::unique_ptr<Thread> Create(CreationParameters params,
                                        rex::MoveOnlyFunction<void()> start_routine);
  static Thread* GetCallingThread();

  static void Exit(int exit_code);
 
  virtual u32 GetSystemID() const = 0;
 
  const std::string& GetName() const { return name_; }

  virtual void SetName(std::string name) { name_ = std::move(name); }
 
  virtual i32 GetPriority() = 0;

  virtual void SetPriority(i32 new_priority) = 0;

  virtual u64 GetAffinityMask() = 0;

  virtual void SetAffinityMask(u64 new_affinity_mask) = 0;

  virtual void QueueUserCallback(rex::MoveOnlyFunction<void()> callback) = 0;

  virtual bool Resume(u32* out_previous_suspend_count = nullptr) = 0;

  virtual bool Suspend(u32* out_previous_suspend_count = nullptr) = 0;

  using RedirectFilter = bool (*)(u64 pc, void* context);

  virtual bool Redirect(RedirectFilter filter, void* context, void (*target)()) = 0;

  virtual bool SuspendIf(RedirectFilter filter, void* context) = 0;
 
 protected:
  std::string name_;
};
 
namespace detail {

REX_API void RegisterCurrentThread();

REX_API u64 GetThreadCount();
 
}  // namespace detail

template <typename F>
std::jthread Spawn(std::string_view name, F&& fn) {
  return std::jthread([thread_name = std::string(name),
                       body = std::forward<F>(fn)](const std::stop_token& token) mutable {
    detail::RegisterCurrentThread();
    PrepareThreadForCrash();
    SetCurrentThreadName(thread_name);
    body(std::move(token));
  });
}
 
}  // namespace rex::platform
 
#if REX_PLATFORM_LINUX || REX_PLATFORM_MAC
#if REX_PLATFORM_MAC && !defined(_XOPEN_SOURCE)
#define _XOPEN_SOURCE 700
#endif
#include <ucontext.h>
#include <cstdint>
#include <vector>
#endif
 
namespace rex::platform {

struct REX_API Fiber {
  static Fiber* ConvertCurrentThread();

  static Fiber* Create(size_t stack_size, void (*entry)(void*), void* arg);

  static void SwitchTo(Fiber* target);

  void Destroy();

  static Fiber* GetCurrent();
 
 private:
#if REX_PLATFORM_WIN32
  void* handle_ = nullptr;
  bool is_thread_fiber_ = false;
#elif REX_PLATFORM_LINUX || REX_PLATFORM_MAC
  ucontext_t context_{};
  std::vector<u8> stack_;
  void (*entry_)(void*) = nullptr;
  void* arg_ = nullptr;
  bool is_thread_fiber_ = false;
 
  static void Trampoline();
#endif
};
 
}  // namespace rex::platform
 
namespace rex {

struct ThreadStop {
  i32 exit_code = 0;
};
 
}  // namespace rex