sweep()

template<typename T >

template<typename Pred , typename Finish >
requires std::invocable<Pred, T&> && std::invocable<Finish, T&>

void MayaFlux::Memory::SweepList< T >::sweep ( Pred  ready, Finish  finish  )

inline

Non-blocking pass over every currently held item.

Atomically takes the entire chain, then for each item calls ready(item). If it returns true, calls finish(item) and frees the link. If false, the item is republished so a later sweep() or drain() will see it again.

Items pushed by other threads while this sweep is running are not part of the taken chain and are left untouched; they surface on a later sweep().

Template Parameters

Pred	Callable (T&) -> bool. True means the item is done and safe to finalize now.
Finish	Callable (T&) -> void. Invoked exactly once per item for which ready returned true, before the link is freed.

Parameters

ready	Readiness check.
finish	Finalizer, invoked once per reclaimed item.

Definition at line 138 of file SweepList.hpp.

    {
        Link* chain = m_head.exchange(nullptr, std::memory_order_acquire);
 
        Link* survivors = nullptr;
        size_t reclaimed = 0;
 
        while (chain) {
            Link* next = chain->next;
 
            if (std::invoke(ready, chain->value)) {
                std::unique_ptr<Link> owned(chain);
                std::invoke(finish, owned->value);
                ++reclaimed;
            } else {
                chain->next = survivors;
                survivors = chain;
            }
 
            chain = next;
        }
 
        if (survivors) {
            reattach(survivors);
        }
 
        m_count.fetch_sub(reclaimed, std::memory_order_relaxed);
    }

References chain, MayaFlux::Memory::SweepList< T >::m_count, MayaFlux::Memory::SweepList< T >::m_head, MayaFlux::Memory::SweepList< T >::Link::next, and MayaFlux::Memory::SweepList< T >::reattach().

Here is the call graph for this function: