kcenon::logger::async::batch_processing_jthread_worker Class Reference

Worker thread for batch processing with jthread compatibility. More...

Collaboration diagram for kcenon::logger::async::batch_processing_jthread_worker:

Public Types
using	process_callback = std::function<void()>

Public Member Functions
	batch_processing_jthread_worker (process_callback callback, std::mutex &notify_mutex, std::condition_variable &notify_cv)
	~batch_processing_jthread_worker ()
void	start ()
void	stop ()
bool	is_running () const noexcept

Private Attributes
process_callback	callback_
std::mutex &	notify_mutex_
std::condition_variable &	notify_cv_
compat_jthread	thread_
std::atomic< bool >	running_ {false}
std::shared_ptr< simple_stop_source >	stop_source_

Detailed Description

Worker thread for batch processing with jthread compatibility.

Uses std::jthread with std::stop_token for cooperative cancellation where available, falls back to std::thread with manual stop mechanism for environments without jthread support (e.g., libc++).

Definition at line 33 of file batch_processor.cpp.

Member Typedef Documentation

process_callback

using kcenon::logger::async::batch_processing_jthread_worker::process_callback = std::function<void()>

Definition at line 35 of file batch_processor.cpp.

Constructor & Destructor Documentation

batch_processing_jthread_worker()

kcenon::logger::async::batch_processing_jthread_worker::batch_processing_jthread_worker ( process_callback callback, std::mutex & notify_mutex, std::condition_variable & notify_cv )

inlineexplicit

Definition at line 37 of file batch_processor.cpp.

        : callback_(std::move(callback))
        , notify_mutex_(notify_mutex)
        , notify_cv_(notify_cv)
#if !LOGGER_HAS_JTHREAD
        , stop_source_(std::make_shared<simple_stop_source>())
#endif
    {}

~batch_processing_jthread_worker()

kcenon::logger::async::batch_processing_jthread_worker::~batch_processing_jthread_worker ( )

inline

Definition at line 48 of file batch_processor.cpp.

                                       {
        stop();
    }

References stop().

Here is the call graph for this function:

Member Function Documentation

is_running()

bool kcenon::logger::async::batch_processing_jthread_worker::is_running ( ) const

inlinenodiscardnoexcept

Definition at line 104 of file batch_processor.cpp.

                                                   {
        return running_.load(std::memory_order_acquire);
    }

References running_.

start()

void kcenon::logger::async::batch_processing_jthread_worker::start ( )

inline

Definition at line 52 of file batch_processor.cpp.

                 {
        if (running_.exchange(true, std::memory_order_acq_rel)) {
            return;  // Already started
        }
 
#if LOGGER_HAS_JTHREAD
        auto callback = callback_;
        auto& cv = notify_cv_;
        auto& mtx = notify_mutex_;
        thread_ = compat_jthread([callback, &cv, &mtx](std::stop_token stop_token) {
            while (!stop_token.stop_requested()) {
                if (callback) {
                    callback();
                }
                // Wait for notification or timeout instead of polling
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait_for(lock, std::chrono::milliseconds(10),
                            [&stop_token]{ return stop_token.stop_requested(); });
            }
        });
#else
        // Reset stop source for new start
        stop_source_->reset();
 
        auto callback = callback_;
        auto stop = stop_source_;
        auto& cv = notify_cv_;
        auto& mtx = notify_mutex_;
        thread_ = compat_jthread([callback, stop, &cv, &mtx](simple_stop_source& /*unused*/) {
            while (!stop->stop_requested()) {
                if (callback) {
                    callback();
                }
                // Wait for notification or timeout instead of polling
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait_for(lock, std::chrono::milliseconds(10),
                            [&stop]{ return stop->stop_requested(); });
            }
        });
#endif
    }

References callback_, notify_cv_, notify_mutex_, running_, stop(), stop_source_, and thread_.

Here is the call graph for this function:

stop()

void kcenon::logger::async::batch_processing_jthread_worker::stop ( )

inline

Definition at line 94 of file batch_processor.cpp.

                {
        if (!running_.exchange(false, std::memory_order_acq_rel)) {
            return;  // Already stopped
        }
 
        // Request stop and join thread
        thread_.request_stop();
        thread_.join();
    }

References kcenon::logger::async::compat_jthread::join(), kcenon::logger::async::compat_jthread::request_stop(), running_, and thread_.

Referenced by start(), and ~batch_processing_jthread_worker().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

callback_

process_callback kcenon::logger::async::batch_processing_jthread_worker::callback_

private

Definition at line 109 of file batch_processor.cpp.

Referenced by start().

notify_cv_

std::condition_variable& kcenon::logger::async::batch_processing_jthread_worker::notify_cv_

private

Definition at line 111 of file batch_processor.cpp.

Referenced by start().

notify_mutex_

std::mutex& kcenon::logger::async::batch_processing_jthread_worker::notify_mutex_

private

Definition at line 110 of file batch_processor.cpp.

Referenced by start().

running_

std::atomic<bool> kcenon::logger::async::batch_processing_jthread_worker::running_ {false}

private

Definition at line 113 of file batch_processor.cpp.

{false};

Referenced by is_running(), start(), and stop().

stop_source_

std::shared_ptr<simple_stop_source> kcenon::logger::async::batch_processing_jthread_worker::stop_source_

private

Definition at line 115 of file batch_processor.cpp.

Referenced by start().

thread_

compat_jthread kcenon::logger::async::batch_processing_jthread_worker::thread_

private

Definition at line 112 of file batch_processor.cpp.

Referenced by start(), and stop().

---

The documentation for this class was generated from the following file:

• src/impl/async/batch_processor.cpp