ThreadSchedule/threadschedule_8hpp_source.html

#pragma once


#include "chaos.hpp"

#include "concepts.hpp"

#include "error_handler.hpp"

#include "futures.hpp"

#include "generator.hpp"

#include "profiles.hpp"

#include "pthread_wrapper.hpp"

#include "scheduled_pool.hpp"

#include "scheduler_policy.hpp"

#include "task.hpp"

#include "thread_pool.hpp"

#include "thread_pool_with_errors.hpp"

#include "thread_registry.hpp"

#include "thread_wrapper.hpp"

#include "topology.hpp"


namespace threadschedule

{


namespace ts = threadschedule;


// Re-export main types for convenience

#ifndef _WIN32

using ts::PThreadWrapper;

#endif

using ts::affinity_for_node;

using ts::apply_profile;

using ts::ChaosConfig;

using ts::ChaosController;

using ts::CpuTopology;

using ts::distribute_affinities_by_numa;

using ts::ErrorCallback;

using ts::ErrorHandler;

using ts::FastThreadPool;

using ts::FastThreadPoolWithErrors;

using ts::FutureWithErrorHandler;

using ts::GlobalHighPerformancePool;

using ts::GlobalPool;

using ts::GlobalThreadPool;

using ts::HighPerformancePool;

using ts::HighPerformancePoolWithErrors;

using ts::JThreadWrapper;

using ts::LightweightPool;

using ts::LightweightPoolT;

using ts::JThreadWrapperView;

using ts::read_topology;

using ts::ScheduledFastThreadPool;

using ts::ScheduledHighPerformancePool;

using ts::ScheduledLightweightPool;

using ts::ScheduledTaskHandle;

using ts::ScheduledThreadPool;

using ts::ScheduledThreadPoolT;

using ts::SchedulingPolicy;

using ts::ShutdownPolicy;

using ts::TaskError;

using ts::ThreadAffinity;

using ts::ThreadByNameView;

using ts::ThreadPool;

using ts::ThreadPoolBase;

using ts::ThreadPoolWithErrors;

using ts::PollingWait;

using ts::PoolWithErrors;

using ts::TaskEndCallback;

using ts::TaskStartCallback;

using ts::ThreadPriority;

using ts::ThreadProfile;

using ts::ThreadWrapper;

using ts::ThreadWrapperView;


// Build-mode introspection

using ts::BuildMode;

using ts::build_mode;

using ts::build_mode_string;


// Future combinators

using ts::when_all;

using ts::when_all_settled;

using ts::when_any;


// Coroutine primitives (C++20)

#if defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L

using ts::executor_base;

using ts::generator;

using ts::pool_executor;

using ts::run_on;

using ts::schedule_on;

using ts::sync_wait;

using ts::task;

#endif


} // namespace threadschedule

chaos.hpp
Test/chaos features to perturb scheduling at runtime.

threadschedule::ChaosController
RAII controller that periodically perturbs scheduling attributes of registered threads for chaos/fuzz...
Definition chaos.hpp:86

threadschedule::ErrorHandler
Central registry and dispatcher for task-error callbacks.
Definition error_handler.hpp:143

threadschedule::FutureWithErrorHandler
A move-only future wrapper that supports an error callback.
Definition error_handler.hpp:330

threadschedule::GlobalPool
Singleton accessor for a process-wide pool instance.
Definition thread_pool.hpp:2151

threadschedule::HighPerformancePool
High-performance thread pool optimized for high-frequency task submission.
Definition thread_pool.hpp:545

threadschedule::LightweightPoolT
Ultra-lightweight fire-and-forget thread pool.
Definition thread_pool.hpp:1847

threadschedule::PThreadWrapper
RAII wrapper around POSIX threads with a modern C++ interface.
Definition pthread_wrapper.hpp:55

threadschedule::PoolWithErrors
Thread pool wrapper that combines any pool type with an ErrorHandler.
Definition thread_pool_with_errors.hpp:33

threadschedule::ScheduledTaskHandle
Copyable handle for a cancellable scheduled task.
Definition scheduled_pool.hpp:34

threadschedule::ScheduledThreadPoolT
Thread pool augmented with delayed and periodic task scheduling.
Definition scheduled_pool.hpp:138

threadschedule::ThreadAffinity
Manages a set of CPU indices to which a thread may be bound.
Definition scheduler_policy.hpp:214

threadschedule::ThreadByNameView
Looks up an OS thread by its name via /proc and provides scheduling control.
Definition thread_wrapper.hpp:669

threadschedule::ThreadPoolBase
Single-queue thread pool parameterized by its idle-wait strategy.
Definition thread_pool.hpp:1267

threadschedule::ThreadPriority
Value-semantic wrapper for a thread scheduling priority.
Definition scheduler_policy.hpp:114

threadschedule::ThreadWrapperView
Non-owning view over an externally managed std::thread.
Definition thread_wrapper.hpp:441

threadschedule::ThreadWrapper
Owning wrapper around std::thread with RAII join-on-destroy semantics.
Definition thread_wrapper.hpp:353

concepts.hpp
C++20 concepts, type traits, and SFINAE helpers for the threading library.

error_handler.hpp
Error handling primitives: TaskError, ErrorHandler, and ErrorHandledTask.

futures.hpp
Combinators for std::future: when_all, when_any, when_all_settled.

generator.hpp
Lazy multi-value coroutine (generator<T>).

threadschedule
Definition chaos.hpp:23

threadschedule::SchedulingPolicy
SchedulingPolicy
Enumeration of available thread scheduling policies.
Definition scheduler_policy.hpp:62

threadschedule::FastThreadPoolWithErrors
PoolWithErrors< FastThreadPool > FastThreadPoolWithErrors
FastThreadPool with integrated error handling.
Definition thread_pool_with_errors.hpp:193

threadschedule::ShutdownPolicy
ShutdownPolicy
Controls how a pool handles pending tasks during shutdown.
Definition thread_pool.hpp:459

threadschedule::ThreadPool
ThreadPoolBase< IndefiniteWait > ThreadPool
General-purpose thread pool with indefinite blocking wait.
Definition thread_pool.hpp:1760

threadschedule::apply_profile
auto apply_profile(ThreadLike &t, ThreadProfile const &p) -> expected< void, std::error_code >
Apply a profile to a thread wrapper or view.
Definition profiles.hpp:160

threadschedule::BuildMode
BuildMode
Indicates whether the library was compiled in header-only or runtime (shared library) mode.
Definition thread_registry.hpp:736

threadschedule::affinity_for_node
auto affinity_for_node(int node_index, int thread_index, int threads_per_node=1) -> ThreadAffinity
Build a ThreadAffinity for the given NUMA node.
Definition topology.hpp:151

threadschedule::distribute_affinities_by_numa
auto distribute_affinities_by_numa(size_t num_threads) -> std::vector< ThreadAffinity >
Distribute thread affinities across NUMA nodes in round-robin order.
Definition topology.hpp:182

threadschedule::GlobalThreadPool
GlobalPool< ThreadPool > GlobalThreadPool
Singleton accessor for the process-wide ThreadPool instance.
Definition thread_pool.hpp:2259

threadschedule::JThreadWrapperView
ThreadWrapperView JThreadWrapperView
Definition thread_wrapper.hpp:632

threadschedule::ScheduledThreadPool
ScheduledThreadPoolT< ThreadPool > ScheduledThreadPool
ScheduledThreadPoolT using the default ThreadPool backend.
Definition scheduled_pool.hpp:390

threadschedule::FastThreadPool
ThreadPoolBase< PollingWait<> > FastThreadPool
Thread pool with 10 ms polling wait for lower wake-up latency.
Definition thread_pool.hpp:1771

threadschedule::ThreadPoolWithErrors
PoolWithErrors< ThreadPool > ThreadPoolWithErrors
ThreadPool with integrated error handling.
Definition thread_pool_with_errors.hpp:196

threadschedule::GlobalHighPerformancePool
GlobalPool< HighPerformancePool > GlobalHighPerformancePool
Singleton accessor for the process-wide HighPerformancePool instance.
Definition thread_pool.hpp:2265

threadschedule::ScheduledFastThreadPool
ScheduledThreadPoolT< FastThreadPool > ScheduledFastThreadPool
ScheduledThreadPoolT using FastThreadPool as backend.
Definition scheduled_pool.hpp:394

threadschedule::HighPerformancePoolWithErrors
PoolWithErrors< HighPerformancePool > HighPerformancePoolWithErrors
HighPerformancePool with integrated error handling.
Definition thread_pool_with_errors.hpp:190

threadschedule::ScheduledLightweightPool
ScheduledThreadPoolT< LightweightPool > ScheduledLightweightPool
ScheduledThreadPoolT using LightweightPool as backend (minimal overhead).
Definition scheduled_pool.hpp:396

threadschedule::TaskEndCallback
std::function< void(std::chrono::steady_clock::time_point, std::thread::id, std::chrono::microseconds elapsed)> TaskEndCallback
Callback invoked when a pool worker finishes executing a task.
Definition thread_pool.hpp:323

threadschedule::build_mode_string
auto build_mode_string() -> char const *
Returns a human-readable C string describing the active build mode.
Definition thread_registry.hpp:766

threadschedule::when_all
auto when_all(std::vector< std::future< T > > &futures) -> std::vector< T >
Block until all futures complete, returning results in submission order.
Definition futures.hpp:34

threadschedule::ErrorCallback
std::function< void(TaskError const  &)> ErrorCallback
Signature for error-handling callbacks registered with ErrorHandler.
Definition error_handler.hpp:116

threadschedule::TaskStartCallback
std::function< void(std::chrono::steady_clock::time_point, std::thread::id)> TaskStartCallback
Work-stealing deque for per-thread task queues in a thread pool.
Definition thread_pool.hpp:320

threadschedule::ScheduledHighPerformancePool
ScheduledThreadPoolT< HighPerformancePool > ScheduledHighPerformancePool
ScheduledThreadPoolT using HighPerformancePool as backend.
Definition scheduled_pool.hpp:392

threadschedule::when_all_settled
auto when_all_settled(std::vector< std::future< T > > &futures) -> std::vector< expected< T, std::exception_ptr > >
Block until all futures complete, returning an expected per slot.
Definition futures.hpp:95

threadschedule::when_any
auto when_any(std::vector< std::future< T > > &futures) -> std::pair< size_t, T >
Block until the first future becomes ready.
Definition futures.hpp:154

threadschedule::JThreadWrapper
ThreadWrapper JThreadWrapper
Owning wrapper around std::jthread with cooperative cancellation (C++20).
Definition thread_wrapper.hpp:631

threadschedule::read_topology
auto read_topology() -> CpuTopology
Discover basic topology. Linux: reads /sys for NUMA nodes. Windows: single node, sequential CPU indic...
Definition topology.hpp:53

threadschedule::build_mode
auto build_mode() -> BuildMode
Returns the build mode detected at compile time (header-only variant).
Definition thread_registry.hpp:756

threadschedule::LightweightPool
LightweightPoolT<> LightweightPool
Default lightweight pool with 64-byte task slots (56 bytes usable).
Definition thread_pool.hpp:2116

profiles.hpp
High-level thread configuration profiles and helpers.

pthread_wrapper.hpp
RAII wrapper around POSIX threads (Linux only).

scheduled_pool.hpp
Delayed and periodic task scheduling on top of any pool type.

scheduler_policy.hpp
Scheduling policies, thread priority, and CPU affinity types.

threadschedule::ChaosConfig
Plain value type holding runtime chaos-testing parameters.
Definition chaos.hpp:34

threadschedule::CpuTopology
Snapshot of basic CPU/NUMA topology.
Definition topology.hpp:39

threadschedule::PollingWait
Wait policy that polls with a configurable timeout.
Definition thread_pool.hpp:1201

threadschedule::TaskError
Holds diagnostic information captured from a failed task.
Definition error_handler.hpp:33

threadschedule::ThreadProfile
Declarative profile bundling scheduling intent for a thread.
Definition profiles.hpp:57

task.hpp
Coroutine task, sync_wait, and pool helpers schedule_on / run_on.

thread_pool.hpp
Thread pools: HighPerformancePool, ThreadPoolBase, LightweightPoolT, and GlobalPool.

thread_pool_with_errors.hpp
PoolWithErrors wrapper that combines any pool with an ErrorHandler.

thread_registry.hpp
Process-wide thread registry, control blocks, and composite registry.

thread_wrapper.hpp
Enhanced thread wrappers: ThreadWrapper, JThreadWrapper, and non-owning views.

topology.hpp
Hardware topology helpers (CPU count, NUMA nodes) and affinity builders.