seqlock_read()

template<std::invocable Fn>

auto MayaFlux::Memory::seqlock_read	(	const Seqlock &	lock,
		uint32_t	max_attempts,
		Fn &&	fn
	)		-> std::optional<std::invoke_result_t<Fn>>

Invoke a read functor under a Seqlock with a bounded retry count.

Retries the read up to max_attempts times if a concurrent write is detected. On each attempt the functor is called with no arguments; its return value is forwarded on success.

Returns std::nullopt if max_attempts is exhausted without a clean read. Callers in frame loops should treat nullopt as "use previous frame" rather than blocking.

The functor must be callable with no arguments and must return a value (or void — see seqlock_read_void for void functors).

Template Parameters

Fn	Callable type, must satisfy std::invocable<Fn>.

Parameters

lock	The Seqlock guarding the data region.
max_attempts	Maximum number of read attempts before giving up. 0 means unbounded (spin until clean).
fn	Functor that reads and returns the guarded data.

Returns

std::optional<return type of fn>, empty on exhaustion.

auto pixels = seqlock_read(m_layer_locks[layer], 8, [&] {
    return std::span<const uint8_t>(buf.data(), buf.size());
});
if (pixels) upload_to_gpu(*pixels);

Definition at line 237 of file SeqLock.hpp.

{
    uint32_t attempts = 0;
    while (max_attempts == 0 || attempts < max_attempts) {
        uint32_t snap = lock.read_begin();
        auto result = std::invoke(std::forward<Fn>(fn));
        if (!lock.read_retry(snap))
            return result;
        ++attempts;
    }
    return std::nullopt;
}