cuddl::device_blacklist Class Reference

Reusable, move-only device lookup. More...

Public Member Functions
	device_blacklist (kmer_blacklist source, size_t buckets, cuda::stream_ref stream)
	device_blacklist (device_blacklist const &)=delete
device_blacklist &	operator= (device_blacklist const &)=delete
	device_blacklist (device_blacklist &&) noexcept=default
device_blacklist &	operator= (device_blacklist &&) noexcept=default
kmer_blacklist const &	source () const noexcept
cuda::std::optional< detail::blacklist_view >	view () const noexcept
Result< void >	validate (uint32_t k, size_t buckets, cuda::stream_ref stream) const

Detailed Description

Reusable, move-only device lookup.

Construction synchronizes the upload stream. Keep this owner and its allocation stream alive until every consuming kernel completes.

Definition at line 201 of file blacklist.cuh.

Constructor & Destructor Documentation

device_blacklist() [1/3]

cuddl::device_blacklist::device_blacklist ( kmer_blacklist  source, size_t  buckets, cuda::stream_ref  stream  )

inline

Definition at line 203 of file blacklist.cuh.

        : source_(std::move(source)), buckets_(buckets), device_(stream.device().get()) {
        if (buckets < 2048 || buckets > 8192 || !std::has_single_bit(buckets)) {
            throw std::invalid_argument("invalid blacklist bucket count");
        }
 
        if (source_.keys().empty()) return;
 
        std::vector<uint32_t> offsets(buckets + 1, 0);
        std::vector<uint64_t> fingerprints(buckets, 0);
 
        for (auto key : source_.keys()) {
            auto const hash = detail::hash_kmer(key);
            auto const bucket = hash & (buckets - 1);
            ++offsets[bucket + 1];
            fingerprints[bucket] |= uint64_t{1} << detail::blacklist_view::fingerprint(hash);
        }
 
        for (size_t b = 1; b <= buckets; ++b) {
            offsets[b] += offsets[b - 1];
        }
 
        auto cursor = offsets;
        std::vector<uint64_t> keys(source_.keys().size());
        for (auto key : source_.keys()) {
            keys[cursor[detail::hash_kmer(key) & (buckets - 1)]++] = key;
        }
        // 32 to 64 map bits per key hold false positives to 1.5-3% at any list size.
        auto const presence_bits =
            std::max(10U, static_cast<uint32_t>(std::bit_width(keys.size())) + 5U);
        std::vector<uint32_t> presence((size_t{1} << presence_bits) / 32);
        for (auto key : keys) {
            auto const slot = detail::blacklist_view::presence_slot(key, presence_bits);
            presence[slot / 32] |= uint32_t{1} << (slot % 32);
        }
        presence_bits_ = presence_bits;
 
        keys_.emplace(cuda::make_device_buffer<uint64_t>(stream, stream.device(), keys));
        offsets_.emplace(cuda::make_device_buffer<uint32_t>(stream, stream.device(), offsets));
        presence_.emplace(cuda::make_device_buffer<uint32_t>(stream, stream.device(), presence));
        fingerprints_.emplace(
            cuda::make_device_buffer<uint64_t>(stream, stream.device(), fingerprints)
        );
        stream.sync();
    }

device_blacklist() [2/3]

cuddl::device_blacklist::device_blacklist ( device_blacklist const &  )

delete

device_blacklist() [3/3]

cuddl::device_blacklist::device_blacklist ( device_blacklist &&  )

defaultnoexcept

Member Function Documentation

operator=() [1/2]

device_blacklist & cuddl::device_blacklist::operator= ( device_blacklist &&  )

defaultnoexcept

operator=() [2/2]

device_blacklist & cuddl::device_blacklist::operator= ( device_blacklist const &  )

delete

source()

kmer_blacklist const & cuddl::device_blacklist::source ( ) const

inlinenoexcept

Definition at line 253 of file blacklist.cuh.

                                                                {
        return source_;
    }

validate()

Result< void > cuddl::device_blacklist::validate ( uint32_t  k, size_t  buckets, cuda::stream_ref  stream  ) const

inline

Definition at line 266 of file blacklist.cuh.

                                                                                                 {
        if ((!source_.keys().empty() && source_.kmer_length() != k) || buckets != buckets_ ||
            stream.device().get() != device_) {
            return Err(
                Error::invalid_argument("blacklist construction configuration or device mismatch")
            );
        }
        return Ok();
    }

Here is the call graph for this function:

view()

cuda::std::optional< detail::blacklist_view > cuddl::device_blacklist::view ( ) const

inlinenoexcept

Definition at line 256 of file blacklist.cuh.

                                                                              {
        if (!keys_) return cuda::std::nullopt;
        return detail::blacklist_view{
            keys_->data(),
            offsets_->data(),
            presence_->data(),
            fingerprints_->data(),
            presence_bits_
        };
    }

---

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

• blacklist.cuh