| ▼Nkcenon | |
| ►Nthread | Core threading foundation of the thread system library |
| ►Nadapters | |
| Ccommon_executor_factory | Factory for creating IExecutor adapters from thread_pool instances |
| Cthread_pool_executor_adapter | Adapter exposing thread_pool through common::interfaces::IExecutor |
| ►Nconcepts | |
| Ccallable_return_type | Type trait to extract return type from a callable |
| Ccallable_return_type< F, std::enable_if_t< std::is_invocable_v< F > > > | |
| Chas_get_method | SFINAE helper to detect if a type has a get() method |
| Chas_get_method< T, std::void_t< decltype(std::declval< T >().get())> > | |
| Chas_wait_method | SFINAE helper to detect if a type has a wait() method |
| Chas_wait_method< T, std::void_t< decltype(std::declval< T >().wait())> > | |
| Cis_duration | Type trait to detect if a type is a std::chrono::duration |
| Cis_duration< std::chrono::duration< Rep, Period > > | |
| Cis_future_like | Type trait to detect future-like types (has get() and wait() methods) |
| Cis_nothrow_callable | Helper to check if a callable is noexcept |
| Cis_valid_job_type | SFINAE helper for JobType validation |
| Cis_valid_job_type< T, std::enable_if_t< JobType< T > > > | |
| ►Ndetail | |
| ►Ccallable_eraser | Type eraser for heterogeneous callable storage |
| Cvtable_t | |
| Ccompile_string | Compile-time string for template error messages |
| ►Cconcurrent_queue | Thread-safe MPMC queue with blocking wait support (Internal implementation) |
| Cnode | |
| Cconditional_feature | Template for conditional compilation based on feature flags |
| Cconstexpr_string | Constexpr string utilities for compile-time job naming |
| Cfunction_traits | Type trait for function signature analysis |
| Cfunction_traits< R(*)(Args...) noexcept > | |
| Cfunction_traits< R(*)(Args...)> | |
| Cfunction_traits< R(C::*)(Args...) const > | |
| Cfunction_traits< R(C::*)(Args...)> | |
| Cfuture_value_type | Helper to get the value type from a future |
| Cglobal_reclamation_manager | Global manager for orphaned nodes from terminated threads |
| Chas_bound_policy_tag | Detect if type has bound_policy_tag |
| Chas_bound_policy_tag< T, std::void_t< typename T::policy_tag > > | |
| Chas_bound_policy_type | Detect if type has bound_policy_type member |
| Chas_bound_policy_type< T, std::void_t< typename T::bound_policy_type > > | |
| Chas_do_work_method | SFINAE helper to detect if a type has a do_work method |
| Chas_do_work_method< T, std::void_t< decltype(std::declval< T >().do_work())> > | |
| Chas_get_method | SFINAE helper to detect if a type has a specific member |
| Chas_get_method< T, std::void_t< decltype(std::declval< T >().get())> > | |
| Chas_overflow_policy_tag | Detect if type has overflow_policy_tag |
| Chas_overflow_policy_tag< T, std::void_t< typename T::policy_tag > > | |
| Chas_overflow_policy_type | Detect if type has overflow_policy_type member |
| Chas_overflow_policy_type< T, std::void_t< typename T::overflow_policy_type > > | |
| Chas_priority_method | SFINAE helper to detect if a type has a specific member function |
| Chas_priority_method< T, std::void_t< decltype(std::declval< T >().priority())> > | |
| Chas_sync_policy_tag | Detect if type has sync_policy_tag |
| Chas_sync_policy_tag< T, std::void_t< typename T::policy_tag > > | |
| Chas_sync_policy_type | Detect if type has sync_policy_type member |
| Chas_sync_policy_type< T, std::void_t< typename T::sync_policy_type > > | |
| Chazard_pointer_registry | Global hazard pointer registry Manages all thread-local hazard lists |
| Cis_compatible_job | Compile-time job validation |
| Cis_compatible_job< Job, ExpectedJobType > | |
| Cis_policy_queue_impl | Primary template: not a policy_queue |
| Cis_policy_queue_impl< policy_queue< SyncPolicy, BoundPolicy, OverflowPolicy > > | Specialization for policy_queue template |
| ►Cjob_eraser | Type erasure helper for heterogeneous job storage |
| Cvtable_t | |
| Cjob_type_extractor | Template to extract job type from job classes |
| Cjob_type_extractor< T > | |
| Cjob_type_list | Variadic template helper for job type lists |
| Cjob_type_traits | Type traits for job types |
| Cjob_validator | Compile-time job validation with detailed error messages |
| ►Clockfree_job_queue | Lock-free Multi-Producer Multi-Consumer (MPMC) job queue (Internal implementation) |
| Cnode | Internal queue node structure |
| Cnode_pool | Lock-free node freelist (Treiber stack) for node recycling |
| Cpriority_comparator | Priority comparison helper with custom comparison functions |
| Cretire_node | Retire node for pending deletion |
| Cthread_hazard_list | Thread-local hazard pointer list Each thread maintains a small array of hazard pointers |
| Cthread_impl | Thread implementation abstraction that handles differences between std::jthread and std::thread |
| Cvalidate_thread_count | Compile-time validation for thread pool configuration |
| ►Ndiagnostics | |
| Cbottleneck_report | Analysis report of bottlenecks in the thread pool |
| Ccomponent_health | Health status of a single component |
| Cdiagnostics_config | Configuration options for thread pool diagnostics |
| Cexecution_event_listener | Interface for receiving job execution events |
| Chealth_status | Comprehensive health status of the thread pool |
| Chealth_thresholds | Configurable thresholds for health status determination |
| Cjob_execution_event | Event data for job execution tracing |
| Cjob_info | Information about a job in the thread pool |
| Cthread_info | Information about a worker thread in the pool |
| Cthread_pool_diagnostics | Comprehensive diagnostics API for thread pool monitoring |
| ►Njobs | |
| Cjob_interface | Interface for executable job objects |
| ►Nlockfree | |
| Ccircular_array | Dynamic circular array for work-stealing deque |
| Cwork_stealing_deque | Lock-free work-stealing deque based on Chase-Lev algorithm |
| ►Nmetrics | |
| CBackendRegistry | Backend registry for managing multiple export formats |
| CBaseSnapshot | Base snapshot structure containing common metric values |
| CEnhancedSnapshot | Enhanced snapshot with latency percentiles and throughput |
| CEnhancedThreadPoolMetrics | Enhanced thread pool metrics with histograms and percentiles |
| CJsonBackend | JSON format backend |
| CLatencyHistogram | HDR-style histogram for latency distribution with logarithmic buckets |
| CLoggingBackend | Logging backend for debugging and diagnostics |
| Cmetrics_service | Centralized metrics service for thread pool metrics management |
| CMetricsBackend | Abstract interface for metrics export backends |
| CMetricsBase | Abstract base class for thread pool metrics |
| CPrometheusBackend | Prometheus/OpenMetrics format backend |
| ►CSlidingWindowCounter | Sliding window counter for throughput measurement |
| CBucket | Time bucket structure |
| ►CThreadPoolMetrics | Lightweight metrics container shared between thread_pool and workers |
| CSnapshot | Snapshot structure containing all metric values |
| CWorkerMetrics | Per-worker metrics for detailed analysis |
| ►Nplatform | |
| Csystem_info | System information structure |
| ►Npolicies | |
| Cadaptive_sync_policy | Adaptive synchronization policy that can switch modes |
| Cbound_policy_tag | Tag type for bound policy identification |
| Cbounded_policy | Policy that limits queue size to a maximum |
| Cdynamic_bounded_policy | Policy with dynamically adjustable size limit |
| ►Clockfree_sync_policy | Lock-free synchronization policy using Michael-Scott algorithm |
| Cnode | |
| Cmutex_sync_policy | Synchronization policy using mutex and condition variable |
| Coverflow_block_policy | Policy that blocks until space is available |
| Coverflow_drop_newest_policy | Policy that rejects new item when queue is full (same as reject) |
| Coverflow_drop_oldest_policy | Policy that drops the oldest item when queue is full |
| Coverflow_policy_tag | Tag type for overflow policy identification |
| Coverflow_reject_policy | Policy that rejects new items when queue is full |
| Coverflow_timeout_policy | Policy that blocks for a limited time when queue is full |
| Csync_policy_tag | Tag type for sync policy identification |
| Cunbounded_policy | Policy that allows unlimited queue size |
| ►Nsync | |
| Catomic_flag_wrapper | Enhanced atomic flag with additional operations |
| Ccondition_variable_wrapper | Enhanced condition variable wrapper with timeout and predicate support |
| Cscoped_lock_guard | RAII-based scoped lock guard with timeout support |
| Cshared_mutex_wrapper | Shared mutex wrapper with reader-writer lock semantics |
| ►Nutils | |
| Cenum_formatter | A generic formatter for enum types, using a user-provided converter functor |
| Cformatter | Provides convenience methods for string formatting using C++20 <format> |
| ►Cadaptive_job_queue | Adaptive queue that switches between mutex and lock-free modes |
| Caccuracy_guard | RAII guard that temporarily switches to accuracy mode |
| Cstats | Statistics about mode switching |
| Caged_priority | Priority with aging support |
| Caging_stats | Statistics about priority aging behavior |
| Caging_typed_job_queue_t | A typed job queue with priority aging support, based on policy_queue |
| Caging_typed_job_t | A typed job with priority aging support |
| Catomic_shared_ptr | |
| Catomic_wait_helper | Helper class to add wait/notify functionality to std::atomic |
| Catomic_with_wait | RAII wrapper to add wait/notify to atomic variables |
| Cautoscaler | Manages automatic scaling of thread pool workers based on load metrics |
| ►Cautoscaling_policy | Configuration for autoscaling behavior |
| Cscale_down_config | Configuration for scale-down triggers |
| Cscale_up_config | Configuration for scale-up triggers |
| Cautoscaling_pool_policy | Pool policy that implements automatic scaling for dynamic worker management |
| Cautoscaling_stats | Statistics for autoscaling operations |
| Cbackoff_calculator | Calculates backoff delays for work-stealing operations |
| Cbackpressure_config | Configuration for backpressure mechanisms |
| Cbackpressure_job_queue | A job queue with comprehensive backpressure mechanisms |
| Cbackpressure_stats | Thread-safe statistics for backpressure operations |
| Cbackpressure_stats_snapshot | Snapshot of backpressure statistics (copyable) |
| Cbarrier | C++17-compatible barrier implementation |
| Ccallback_job | A specialized job class that encapsulates user-defined callbacks |
| Ccallback_typed_job_t | Callback-based typed job template |
| Ccancellable_future | A future wrapper that supports cancellation |
| Ccancellable_future< void > | Specialization for void return type |
| Ccancellation_callback_guard | RAII guard for automatic callback unregistration |
| ►Ccancellation_context | Thread-local cancellation context for implicit token propagation |
| Cguard | RAII guard for push/pop operations |
| Ccancellation_reason | Holds information about why a cancellation occurred |
| Ccancellation_scope | Structured cancellation scope with check points |
| ►Ccancellation_token | Provides a mechanism for cooperative cancellation of operations |
| Ctoken_state | |
| Ccircuit_breaker_policy | Pool policy that implements circuit breaker pattern for failure protection |
| Cconfig_builder | Builder for thread_system_config |
| Cconfig_changed_event | Configuration changed event |
| Cconfiguration_manager | Configuration manager for unified system configuration |
| Ccrash_context | Crash context information |
| ►Ccrash_handler | Thread-safe crash handler for the entire thread system |
| Ccallback_entry | |
| Ccleanup_entry | |
| Ccrash_stats | Get crash statistics |
| Cdag_config | Configuration options for the DAG scheduler |
| Cdag_job | A job with dependency support for DAG-based scheduling |
| Cdag_job_builder | Fluent builder for creating dag_job instances |
| Cdag_job_info | Information about a job in the DAG |
| Cdag_scheduler | DAG-based job scheduler with dependency management |
| Cdag_stats | Statistics about DAG execution |
| Cdefault_error_handler | Default error handler implementation |
| ►Cenhanced_cancellation_token | Advanced cancellation token with timeout, deadline, and reason support |
| Cstate | |
| Cenhanced_work_stealing_config | Configuration for enhanced work-stealing with NUMA awareness |
| Cerror | Represents an error in the thread system |
| Cerror_handler | Error handler interface |
| Cevent_base | Event base class for type safety |
| ►Cevent_bus | Event Bus for publish-subscribe pattern |
| Csubscription | Subscription handle for managing subscriptions |
| Cfuture_job | A job that wraps a callable and provides a future for its result |
| Chas_blocking_overflow | Compile-time detection of blocking overflow policy |
| Chas_blocking_overflow< T, std::enable_if_t< policy_queue_traits< T >::is_policy_queue > > | |
| Chazard_pointer | Single hazard pointer that protects one object from reclamation Uses RAII pattern - automatically releases protection on destruction |
| ►Chazard_pointer_domain | Domain managing hazard pointers and retirement for a specific type |
| Cstats | Get statistics |
| Cthread_retire_list | |
| Cis_bounded_queue | Compile-time detection of bounded queue |
| Cis_bounded_queue< T, std::enable_if_t< policy_queue_traits< T >::is_policy_queue > > | |
| Cis_lockfree_queue | Compile-time detection of lock-free capability |
| Cis_lockfree_queue< T, std::enable_if_t< policy_queue_traits< T >::is_policy_queue > > | |
| Cjob | Represents a unit of work (task) to be executed, typically by a job queue |
| ►Cjob_builder | Fluent builder for creating and configuring jobs with composition |
| Cbuilt_job | Internal job implementation created by the builder |
| Cjob_components | Internal structure holding composed behaviors for a job |
| Cjob_info | Information about a job for starvation callback |
| ►Cjob_queue | A thread-safe job queue for managing and dispatching work items |
| Cmemory_stats | Get memory footprint statistics for the queue |
| Cjob_queue_adapter | Adapter for job_queue to pool_queue_adapter_interface |
| Clatch | C++17-compatible latch implementation |
| Clifecycle_controller | Centralized thread lifecycle state and synchronization management |
| Cmodule_version | Version information for thread_system module |
| Cnuma_node | Information about a single NUMA node |
| Cnuma_thread_pool | A NUMA-aware thread pool optimized for Non-Uniform Memory Access architectures |
| Cnuma_topology | NUMA (Non-Uniform Memory Access) topology information |
| Cnuma_work_stealer | NUMA-aware work stealer with enhanced victim selection policies |
| Coperation_cancelled_exception | Exception thrown when an operation is cancelled |
| Cperformance_alert_event | Performance alert event |
| Cpolicy_queue | Policy-based queue template |
| Cpolicy_queue_adapter | Adapter for policy_queue to pool_queue_adapter_interface |
| Cpolicy_queue_traits | Extract policy types from a policy_queue |
| Cpolicy_queue_traits< T, std::enable_if_t< detail::has_sync_policy_type< T >::value &&detail::has_bound_policy_type< T >::value &&detail::has_overflow_policy_type< T >::value > > | |
| Cpool_future | A future that can be scheduled on a thread pool |
| Cpool_policy | Base interface for thread pool policies |
| Cpool_promise | A promise that can schedule work on a thread pool |
| Cpool_promise< void > | Specialization for void type |
| Cpool_queue_adapter_interface | Abstract interface for queue adapters used by thread_pool |
| Cpriority_aging_config | Configuration for priority aging behavior |
| Cprotected_job | A job wrapper that integrates circuit breaker protection |
| Cqueue_capabilities | Runtime-queryable queue capabilities descriptor |
| Cqueue_capabilities_interface | Mixin interface for queue capability introspection |
| ►Cqueue_factory | Factory for creating queue instances |
| Crequirements | Queue selection requirements |
| Cqueue_type_selector | Compile-time queue type selector |
| Cresult | A template class representing either a value or an error |
| Cresult< void > | Specialization of result for void |
| Cresult_void | Wrapper for void result |
| Cretry_policy | Encapsulates retry behavior configuration for jobs |
| Csafe_hazard_guard | |
| Csafe_hazard_pointer_domain | Global Hazard Pointer Domain Manager |
| Csafe_hazard_pointer_record | Thread-local hazard pointer record with explicit memory ordering |
| Cscaling_decision | Scaling decision result |
| Cscaling_metrics_sample | Metrics sample for autoscaling decisions |
| Cscheduler_interface | Scheduler interface for queuing and retrieving jobs |
| Cscoped_crash_callback | RAII helper for automatic crash callback registration |
| Cscoped_service | RAII helper for scoped service registration |
| ►Cservice_container | Modern service container for dependency injection |
| Cservice_entry | |
| Cservice_registry | Lightweight service registry for dependency lookup |
| Csteal_backoff_config | Configuration for backoff behavior |
| Csubmit_options | Options for submitting jobs to the thread pool |
| Csystem_shutdown_event | System shutdown event |
| Csystem_startup_event | System startup event |
| Cthread_base | A foundational class for implementing custom worker threads |
| Cthread_context | Context object that provides access to optional services |
| Cthread_context_builder | Builder for thread_context with fluent interface |
| Cthread_error_category | Std::error_category implementation for thread_system errors |
| Cthread_logger | Structured logger for thread system |
| Cthread_pool | A thread pool for concurrent execution of jobs using multiple worker threads |
| Cthread_pool_builder | Fluent builder for creating and configuring thread pools |
| Cthread_pool_crash_safety | Thread pool crash safety extensions |
| ►Cthread_system_config | Unified configuration for thread_system |
| Cpool_config | Configuration for thread pool behavior |
| Cresilience_config | Configuration for resilience features |
| Cscaling_config | Configuration for dynamic scaling features |
| Cthread_worker | A specialized worker thread that processes jobs from a job_queue |
| Ctoken_bucket | Lock-free token bucket rate limiter for controlling throughput |
| Ctyped_job_factory_interface | Factory interface for creating typed jobs |
| Ctyped_job_interface | Typed job interface template |
| Ctyped_job_t | Typed job template |
| Ctyped_safe_hazard_domain | Typed hazard pointer domain |
| Ctyped_thread_pool_builder | Typed thread pool builder template |
| Ctyped_thread_pool_t | Typed thread pool template |
| Ctyped_thread_worker_t | Typed thread worker template |
| Cvalidation_result | Configuration validation result |
| Cwork_affinity_tracker | Tracks cooperation patterns between workers for locality-aware stealing |
| Cwork_stealing_pool_policy | Pool policy that implements work-stealing behavior for load balancing |
| Cwork_stealing_stats | Statistics for work-stealing operations |
| Cwork_stealing_stats_snapshot | Non-atomic snapshot of work-stealing statistics |
| Cworker_policy | Worker behavior policy configuration |
| ▼Nstd | STL namespace |
| Cformatter< kcenon::thread::job_queue > | |
| Cformatter< kcenon::thread::job_queue, wchar_t > | |
| Cformatter< kcenon::thread::job_types > | Specialization of std::formatter for job_types using narrow strings |
| Cformatter< kcenon::thread::job_types, wchar_t > | Specialization of std::formatter for job_types using wide strings |
| Cformatter< kcenon::thread::thread_conditions > | Specialization of std::formatter for kcenon::thread::thread_conditions |
| Cformatter< kcenon::thread::thread_conditions, wchar_t > | Specialization of std::formatter for wide-character kcenon::thread::thread_conditions |
| Cformatter< kcenon::thread::thread_pool > | Specialization of std::formatter for kcenon::thread::thread_pool |
| Cformatter< kcenon::thread::thread_pool, wchar_t > | Specialization of std::formatter for wide-character kcenon::thread::thread_pool |
| Cformatter< kcenon::thread::thread_worker > | Specialization of std::formatter for kcenon::thread::thread_worker |
| Cformatter< kcenon::thread::thread_worker, wchar_t > | Specialization of std::formatter for wide-character kcenon::thread::thread_worker |
| Cformatter< kcenon::thread::typed_thread_pool_t< job_type > > | Specialization of std::formatter for typed_thread_pool_t<job_type> |
| Cformatter< kcenon::thread::typed_thread_pool_t< job_type >, wchar_t > | Specialization of std::formatter for wide-character typed_thread_pool_t<job_type> |
| Cformatter< kcenon::thread::typed_thread_worker_t< job_type > > | Specialization of std::formatter for typed_thread_worker_t<job_type> |
| Cformatter< kcenon::thread::typed_thread_worker_t< job_type >, wchar_t > | Specialization of std::formatter for wide-character typed_thread_worker_t<job_type> |
| Cformatter< test_priority > | Specialization of std::formatter for test_priority. Enables formatting of test_priority enum values as strings using C++20 std::format |
| Cformatter< test_priority, wchar_t > | Specialization of std::formatter for wide-character test_priority. Allows test_priority enum values to be formatted as wide strings using C++20 std::format |
| Cis_error_code_enum< kcenon::thread::error_code > | Specialization to enable implicit conversion of thread_system::error_code to std::error_code |
| ▼Nutility_module | |
| Cconvert_string | Provides utilities for string encoding conversion, Base64 encoding/decoding, and substring operations like splitting or replacing |
| Cenum_formatter | A generic formatter for enum types, using a user-provided converter functor |
| Cformatter | Provides convenience methods for string formatting using C++20 <format> |
| Cspan | A fallback span implementation for C++17 and earlier compilers |
| Ccancellable_long_job | A job that performs a long-running task with periodic cancellation checks |
| Cconsole_logger | Simple console logger implementation using common_system ILogger |
| Cconsole_monitoring | Simple monitoring implementation using common::interfaces::IMonitor |
| Ccritical_resource | |
| Cdemo_service | |
| CLockFreeStack | |
| Cmock_logger | Mock logger implementation for demonstration |
| ▼Cmock_monitoring | Mock monitoring implementation for demonstration |
| Cmonitoring_stats | |
| Cnon_cancellable_job | A job that DOES NOT check for cancellation (anti-pattern) |
| Csample_monitoring | |
| CSmartJobProcessor | Smart job processor that adapts to queue capabilities |
| CTestData | |
| CTestNode | |
1.12.0