cusbf Namespace Reference

Namespaces
namespace	detail

Classes
struct	Config
	Compile-time configuration for a cusbf::filter. More...
struct	CudaError
class	DenseRecordBatchBuilder
	Accumulates parsed FASTX records into a dense RecordBatchView. More...
struct	device_span
	A span that is assumed to point to device-accessible memory. More...
struct	DnaAlphabet
	An alphabet for encoding DNA sequences, consisting of the symbols A, C, G, and T. More...
struct	DnaTripletAlphabet
	An alphabet that encodes non-overlapping DNA triplets as single symbols. More...
struct	Error
	Error payload carried in Result on failure. More...
struct	FastxDetailedQueryRecord
	Detailed per-record query results returned by Filter FASTX detail APIs. More...
struct	FastxDetailedQueryReport
	Aggregate and per-record results returned by Filter FASTX detail APIs. More...
struct	FastxInsertReport
	Summary statistics returned by Filter insert operations on FASTX and record-batch input. More...
struct	FastxParseError
struct	FastxQueryReport
	Summary statistics returned by Filter query operations on FASTX and record-batch input. More...
struct	FastxRecordView
	Per-record query payload emitted by FASTX streaming query APIs. More...
class	filter
	GPU Super Bloom filter (defined in filter.cuh). More...
struct	filter_block
	One 256-bit filter block stored as an array of Config::blockWordCount words. More...
class	filter_ref
	Non-owning device reference to sectorized filter storage. More...
struct	InvalidArgumentError
struct	IoError
struct	NormalizedRecord
	Per-record metadata inside a normalized record batch. More...
class	NormalizedRecordBatch
	Host-resident Normalized record batch ready for bulk sequence insert/query. More...
struct	ProteinAlphabet
	An alphabet for encoding protein sequences, consisting of the 20 standard amino acids plus common ambiguous and rare residue symbols: More...
struct	RecordBatchView
	Dense host-resident sequence batch plus explicit record boundaries. More...
struct	RecordQueryView
	Per-record query payload emitted by query_record_batch(). More...
struct	RecordRange
	Ordered non-overlapping byte range for one record inside a dense sequence batch. More...
struct	ResourceError
struct	Result
	Fallible API result: cuda::std::expected<T, Error> with cuSBF factories. More...
struct	Result< void >
struct	SourceLocation
	File, line, and column for a C++ call site or FASTX input position. More...

Concepts
concept	Alphabet
	Concept for alphabet-like types used to encode bytes as symbol indices.
concept	RecordQueryConsumer
	Callable invoked once per record by Filter::query_record_batch overloads that take a callback.
concept	FastxRecordConsumer
	Callable invoked once per record by Filter::query_fastx_records and related FASTX streaming query APIs.

Enumerations
enum class	ErrorCategory : uint8_t {   cuda , io , fastx_parse , invalid_argument ,   resource }
	Error category for Result failures. More...

Functions
template<typename Config >
constexpr uint64_t	dense_packed_word_count (uint64_t num_symbols)
	Returns the number of uint64_t words required for num_symbols encoded symbols.
template<typename Config >
constexpr uint64_t	dense_packed_kmer_count (uint64_t num_symbols)
	Returns the number of k-mer windows in a dense packed symbol sequence.
template<typename Config >
std::vector< uint64_t >	pack_dense_sequence (std::string_view sequence)
	Packs an ASCII sequence into dense symbolBits-wide uint64_t words.
template<typename Config >
void	pack_dense_sequence_device (const char *d_sequence, uint64_t num_symbols, uint64_t *d_words, cudaStream_t stream={})
	Packs a device-resident encoded byte sequence into dense uint64_t words.
void	require_void (const Result< void > &result)
	Aborts when a Result is unsuccessful (benchmarks and tests).
void	cuda_abort_on_error (cudaError_t error, std::source_location location=std::source_location::current())
	Terminates the process when error is not cudaSuccess (for RAII teardown only).
cuda::std::unexpected< Error >	Err (Error error)
	Failure return; converts to any Result<T> via cuda::std::unexpected.
Result< void >	Ok () noexcept
	Success return for Result<void>; same as return {}.
Result< void >	cuda_try (cudaError_t error, std::source_location location=std::source_location::current())
	Checks a CUDA runtime call and returns an error on failure.
template<typename Config >
Result< void >	normalize_record_batch_into (RecordBatchView batch, std::string &sequence_out, std::vector< NormalizedRecord > &records_out)
	Builds a normalized record batch into reusable host buffers.
template<typename Config >
Result< NormalizedRecordBatch >	normalize_record_batch (RecordBatchView batch)
	Builds a normalized record batch from a dense RecordBatchView.

Enumeration Type Documentation

ErrorCategory

enum class cusbf::ErrorCategory : uint8_t

strong

Error category for Result failures.

Enumerator
cuda
io
fastx_parse
invalid_argument
resource

Definition at line 67 of file error.hpp.

                         : uint8_t {
    cuda,
    io,
    fastx_parse,
    invalid_argument,
    resource,
};

Function Documentation

cuda_abort_on_error()

void cusbf::cuda_abort_on_error ( cudaError_t  error, std::source_location  location = std::source_location::current()  )

inline

Terminates the process when error is not cudaSuccess (for RAII teardown only).

Definition at line 187 of file error.hpp.

  {
    if (error == cudaSuccess) {
        return;
    }
    const Error err = Error::cuda(error, location);
    std::fputs(err.message().c_str(), stderr);
    std::fputc('\n', stderr);
    std::abort();
}

Here is the call graph for this function:

cuda_try()

Result< void > cusbf::cuda_try ( cudaError_t  error, std::source_location  location = std::source_location::current()  )

inline

Checks a CUDA runtime call and returns an error on failure.

Definition at line 230 of file error.hpp.

                                                                                       {
    if (error == cudaSuccess) {
        return Ok();
    }
    return Err(Error::cuda(error, location));
}

Here is the call graph for this function:

dense_packed_kmer_count()

template<typename Config >

constexpr uint64_t cusbf::dense_packed_kmer_count ( uint64_t  num_symbols )

constexpr

Returns the number of k-mer windows in a dense packed symbol sequence.

Definition at line 24 of file dense_packed.hpp.

                                                                               {
    return detail::dense_packed_kmer_count<Config>(num_symbols);
}

Here is the call graph for this function:

dense_packed_word_count()

template<typename Config >

constexpr uint64_t cusbf::dense_packed_word_count ( uint64_t  num_symbols )

constexpr

Returns the number of uint64_t words required for num_symbols encoded symbols.

Definition at line 18 of file dense_packed.hpp.

                                                                               {
    return detail::dense_packed_word_count<Config>(num_symbols);
}

Here is the call graph for this function:

Err()

cuda::std::unexpected< Error > cusbf::Err ( Error  error )

inline

Failure return; converts to any Result<T> via cuda::std::unexpected.

Definition at line 219 of file error.hpp.

                                                               {
    return cuda::std::unexpected<Error>(std::move(error));
}

Here is the caller graph for this function:

normalize_record_batch()

template<typename Config >

Result< NormalizedRecordBatch > cusbf::normalize_record_batch

(

RecordBatchView

batch

)

Builds a normalized record batch from a dense RecordBatchView.

Template Parameters

Config

Filter configuration (alphabet and k-mer sizing).

Parameters

batch

Dense input batch without embedded separators.

Returns

Owning normalized batch ready for filter::insert_record_batch or query APIs.

Definition at line 314 of file normalized_record_batch.hpp.

                                                                                          {
    return NormalizedRecordBatch::from_batch<Config>(batch);
}

normalize_record_batch_into()

template<typename Config >

Result< void > cusbf::normalize_record_batch_into	(	RecordBatchView	batch,
		std::string &	sequence_out,
		std::vector< NormalizedRecord > &	records_out
	)

Builds a normalized record batch into reusable host buffers.

Template Parameters

Config

Filter configuration (alphabet and k-mer sizing).

Parameters

batch	Dense input batch without embedded separators.
sequence_out	Output normalized sequence buffer (resized in place).
records_out	Output per-record metadata (cleared then filled).

Definition at line 289 of file normalized_record_batch.hpp.

  {
    CUSBF_TRY(detail::validateRecordBatch<Config>(batch));
 
    const uint64_t estimated_bytes = detail::estimate_normalized_batch_bytes<Config>(batch);
    sequence_out.resize(static_cast<size_t>(estimated_bytes));
    size_t sequence_out_bytes = 0;
    detail::normalize_record_batch_into_buffer<Config>(
        batch, sequence_out.data(), sequence_out_bytes, records_out
    );
    sequence_out.resize(sequence_out_bytes);
    return {};
}

Here is the call graph for this function:

Ok()

Result< void > cusbf::Ok ( )

inlinenoexcept

Success return for Result<void>; same as return {}.

Definition at line 224 of file error.hpp.

                                                {
    return Result<void>::ok();
}

Here is the call graph for this function:

Here is the caller graph for this function:

pack_dense_sequence()

template<typename Config >

std::vector< uint64_t > cusbf::pack_dense_sequence

(

std::string_view

sequence

)

Packs an ASCII sequence into dense symbolBits-wide uint64_t words.

Reads one symbol every Config::symbolWidth input bytes via Config::Alphabet. Trailing input shorter than one symbol is ignored. Invalid bytes are stored as their low Config::symbolBits (same as masking Config::Alphabet::invalidSymbol).

Definition at line 36 of file dense_packed.hpp.

                                                                               {
    const uint64_t num_symbols = sequence.size() / Config::symbolWidth;
    std::vector<uint64_t> words(dense_packed_word_count<Config>(num_symbols), 0);
    constexpr uint64_t symbols_per_word = detail::dense_packed_symbols_per_word<Config>();
    for (uint64_t symbol_index = 0; symbol_index < num_symbols; ++symbol_index) {
        const uint8_t symbol =
            Config::Alphabet::encode(sequence.data() + symbol_index * Config::symbolWidth);
        const uint64_t word_index = symbol_index / symbols_per_word;
        const auto bit_offset =
            static_cast<unsigned>((symbol_index % symbols_per_word) * Config::symbolBits);
        words[word_index] |= (static_cast<uint64_t>(symbol & Config::symbolMask) << bit_offset);
    }
    return words;
}

Here is the call graph for this function:

pack_dense_sequence_device()

template<typename Config >

void cusbf::pack_dense_sequence_device ( const char *  d_sequence, uint64_t  num_symbols, uint64_t *  d_words, cudaStream_t  stream = {}  )

inline

Packs a device-resident encoded byte sequence into dense uint64_t words.

d_sequence holds num_symbols symbols at Config::symbolWidth bytes each. d_words must hold at least dense_packed_word_count(num_symbols) words.

Definition at line 58 of file dense_packed.hpp.

                          {}
) {
    if (num_symbols == 0) {
        return;
    }
    constexpr uint64_t block_size = 256;
    const uint64_t num_words = dense_packed_word_count<Config>(num_symbols);
    const uint64_t grid_size = cuda::ceil_div(num_words, block_size);
    detail::pack_dense_sequence_kernel<Config>
        <<<grid_size, block_size, 0, stream>>>(d_sequence, num_symbols, d_words);
    CUSBF_CUDA_CALL(cudaGetLastError());
}

require_void()

void cusbf::require_void ( const Result< void > &  result )

inline

Aborts when a Result is unsuccessful (benchmarks and tests).

Definition at line 178 of file error.hpp.

                                                     {
    if (!result) {
        std::fputs(result.error().message().c_str(), stderr);
        std::fputc('\n', stderr);
        std::abort();
    }
}