cuddl::detail::sequence_buffer_pool Class Reference

Public Member Functions
	sequence_buffer_pool (cuda::stream_ref stream, size_t buffers, size_t limit, bool page_locked, bool in_place)
	limit bounds one buffer; larger genomes stay on the loader's own growing buffer.
void	set_capacity (size_t buffers, size_t reserve_each=0)
	Number of buffers the pool may grow to.
size_t	buffers () const noexcept
	Buffers allocated so far. Read once the loaders have stopped.
decompression_target	acquire (size_t bytes)
	Returns reusable bytes, or a null target when the pool cannot serve.

Detailed Description

Definition at line 867 of file database_staging.cuh.

Constructor & Destructor Documentation

sequence_buffer_pool()

cuddl::detail::sequence_buffer_pool::sequence_buffer_pool ( cuda::stream_ref  stream, size_t  buffers, size_t  limit, bool  page_locked, bool  in_place  )

inline

limit bounds one buffer; larger genomes stay on the loader's own growing buffer.

in_place says kernels read leased buffers themselves. Otherwise only copies read them, and every consumer drops a lease once its copies have completed, so a slot is reusable as soon as it is released.

Definition at line 875 of file database_staging.cuh.

        : stream_(stream),
          limit_(limit),
          pinned_pool_(
              page_locked
                  ? std::optional{device_pinned_pool(stream.device(), pinned_placement::host)}
                  : std::nullopt
          ),
          in_place_(in_place) {
        slots_.reserve(buffers);
    }

Here is the call graph for this function:

Member Function Documentation

acquire()

decompression_target cuddl::detail::sequence_buffer_pool::acquire ( size_t  bytes )

inline

Returns reusable bytes, or a null target when the pool cannot serve.

Definition at line 915 of file database_staging.cuh.

                                                             {
        if (bytes == 0 || bytes > limit_) return {};
        slot* owner = nullptr;
        {
            std::lock_guard lock(mutex_);
            owner = claim();
            if (owner == nullptr) return {};
        }
        // Wait on the loader thread rather than the build loop: the slot is already reserved,
        // so this blocks only the genome that needs it. A failing wait throws out of the loader,
        // which reports it through the pool's error slot like any other load failure.
        if (in_place_) owner->consumed.sync();
        if (owner->size < bytes) {
            auto grown = size_t{1} << 16;
            while (grown < bytes) {
                grown *= 2;
            }
            owner->resize(stream_, grown, pinned_pool_);
        }
        return lease(owner);
    }

buffers()

size_t cuddl::detail::sequence_buffer_pool::buffers ( ) const

inlinenoexcept

Buffers allocated so far. Read once the loaders have stopped.

Definition at line 910 of file database_staging.cuh.

                                                  {
        return slots_.size();
    }

set_capacity()

void cuddl::detail::sequence_buffer_pool::set_capacity ( size_t  buffers, size_t  reserve_each = 0  )

inline

Number of buffers the pool may grow to.

With reserve_each, page-locks that many bytes per buffer at once and returns them to the pool, which keeps them, so loaders take their buffers from pinned memory. Each loader page-locking its own first buffer serialised them in the driver: with 64 loaders on a Xeon w9-3595X, 20,000 genomes spent 9% of their host time there and took 3.3 s, against 3.0 s with the reservation.

Definition at line 900 of file database_staging.cuh.

                                                               {
        capacity_ = std::max<size_t>(1, buffers);
        if (pinned_pool_ && reserve_each != 0 && !ablated("pinned-reservation")) {
            cuda::buffer<char, cuda::mr::host_accessible, cuda::mr::device_accessible> reserved(
                stream_, *pinned_pool_, capacity_ * reserve_each, cuda::no_init
            );
        }
    }

Here is the call graph for this function:

---

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

• database_staging.cuh