Background writer pumping snapshots onto a dedicated thread. More...

#include <ca-checkpoint.H>

Collaboration diagram for Aleph::CA::Async_Checkpoint_Writer< Engine >:

Classes
struct	Task

Public Types
enum class	Queue_Policy { Block , Drop_Oldest }
	Behaviour when the internal queue is full. More...

Public Member Functions
	Async_Checkpoint_Writer (const std::size_t capacity=8, const Queue_Policy policy=Queue_Policy::Block)
	Construct the writer and spawn its worker thread.

	Async_Checkpoint_Writer (const Async_Checkpoint_Writer &)=delete

Async_Checkpoint_Writer &	operator= (const Async_Checkpoint_Writer &)=delete

	~Async_Checkpoint_Writer () noexcept
	Destructor: drains the queue and joins the worker.

void	submit (Engine &engine, std::filesystem::path path, Checkpoint_Options options={})
	Synchronously capture the engine state and enqueue a write.

void	flush ()
	Block until the queue is drained.

std::size_t	pending () const
	Snapshot of pending queue depth (informational).

void	set_before_write_hook (std::function< void()> hook)
	Install a hook called by the worker just before each write.

std::size_t	total_written () const noexcept
	Total number of files successfully written by the worker.

std::size_t	total_dropped () const noexcept
	Total number of pending tasks discarded due to `Drop_Oldest`.

std::size_t	capacity () const noexcept
	Configured queue capacity.

Queue_Policy	policy () const noexcept
	Configured back-pressure policy.

Private Member Functions
void	worker_loop () noexcept

Private Attributes
std::mutex	mu_

std::condition_variable	not_empty_

std::condition_variable	not_full_

std::condition_variable	drained_

std::deque< Task >	queue_

std::size_t	capacity_

Queue_Policy	policy_

bool	stop_ = false

bool	in_flight_ = false

std::optional< std::string >	worker_error_

std::atomic< std::size_t >	total_written_ {0}

std::atomic< std::size_t >	total_dropped_ {0}

std::function< void()>	before_write_hook_

std::thread	worker_

Detailed Description

template<typename Engine>
class Aleph::CA::Async_Checkpoint_Writer< Engine >

Background writer pumping snapshots onto a dedicated thread.

Decouples engine.step() from disk I/O: submit() synchronously copies the current frame into an internal task buffer (a fast memcpy) and returns immediately; a worker thread later runs optional DEFLATE compression and the atomic-rename write.

Queue policy:

Block — submit() blocks until queue depth < capacity.
Drop_Oldest — when the queue is full, the oldest pending task is discarded and the new one enqueued.

The destructor blocks on flush() so no snapshot is silently lost when the writer goes out of scope.

Thread safety: submit() and flush() are safe to call from a single producer thread (typically the engine thread). The writer is not designed for multi-producer use — wrap it in your own synchronisation if multiple engines share the same writer.

Template Parameters

Engine engine type satisfying Checkpointable_Engine.

Definition at line 1289 of file ca-checkpoint.H.

[in]	capacity	maximum number of pending tasks. Must be `>= 1`.
[in]	policy	what to do when `capacity` is reached.

[in]	engine	engine to snapshot.
[in]	path	destination path.
[in]	options	compression / dir-fsync knobs.

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Queue_Policy

Constructor & Destructor Documentation

◆ Async_Checkpoint_Writer() [1/2]

◆ Async_Checkpoint_Writer() [2/2]

◆ ~Async_Checkpoint_Writer()

Member Function Documentation

◆ capacity()

◆ flush()

◆ operator=()

◆ pending()

◆ policy()

◆ set_before_write_hook()

◆ submit()

◆ total_dropped()

◆ total_written()

◆ worker_loop()

Member Data Documentation

◆ before_write_hook_

◆ capacity_

◆ drained_

◆ in_flight_

◆ mu_

◆ not_empty_

◆ not_full_

◆ policy_

◆ queue_

◆ stop_

◆ total_dropped_

◆ total_written_

◆ worker_

◆ worker_error_