Detailed description

template< typename stream_type, typename algorithm_type = DeviceThreadScheduler>
struct nvbio::aln::BatchedAlignmentScore< stream_type, algorithm_type >

Execution context for a batch of alignment jobs.

Template Parameters

stream_type	the stream of alignment jobs
algorithm_type	a Batch Scheduler specifier

This class has to provide the following interface:

stream_type
{
    typedef ... aligner_type;           // define the aligner type
    // an alignment context
    struct context_type
    {
        int32           min_score;      // the threshold score for a valid alignment
        sink_type       sink;           // alignment sink
        ...                             // private data
    };
    // a container for the strings to be aligned
    struct strings_type
    {
        pattern_type    pattern;        // the pattern to align
        qual_type       quals;          // the pattern qualities
        text_type       text;           // the text to align
        ...                             // private data
    };
    // return the aligner
    aligner_type aligner() const;
    // return the maximum pattern length
    uint32 max_pattern_length() const;
    // return the maximum text length
    uint32 max_text_length() const;
    // stream size
    uint32 size() const;
    // return the i-th pattern length
    uint32 pattern_length(const uint32 i, context_type* context) const;
    // return the i-th text length
    uint32 text_length(const uint32 i, context_type* context) const;
    // initialize the context relative to the i-th alignment;
    // return false if the alignment is to be skipped
    bool init_context(
         const uint32        i,                             // job index
         context_type*       context) const;                // output job context
    // get the context relative to the i-th alignment
    void load_strings(
         const uint32        i,                             // job index
         const uint32        pattern_begin,                 // pattern window begin
         const uint32        pattern_end                    // pattern window end
         context_type*       context,                       // job context
         strings_type*       strings) const;                // output strings
    // consume the output
    void output(const uint32 i, context_type* context);
};

While this design might seem a little convoluted it is motivated by efficiency and generality. In fact, it does:

allow the scheduler to break the alignment process into multiple stages while performing initializations only once through the stream_type::init_context() method;
allow the user to perform string caching in registers/local memory: in fact, schedulers will instantiate the strings_type class on the stack, thus guaranteeing that any user-defined private data will be placed either in registers or local memory. The stream_type::load_strings() method is then free to use such private data to implement a cache for any of the involved strings. With this design cached strings will then be allowed to just contain pointers to the caches, making sure that they can be passed by value without inadvertedly copying the caches themselves.

Definition at line 313 of file batched.h.

#include <batched.h>

Public Types
typedef stream_type::aligner_type	aligner_type

typedef checkpoint_storage_type < aligner_type >::type	cell_type

Public Methods
void	enact (stream_type stream, uint64 temp_size=0u, uint8 *temp=NULL)

Static Public Methods
static uint64	min_temp_storage (const uint32 max_pattern_len, const uint32 max_text_len, const uint32 stream_size)

static uint64	max_temp_storage (const uint32 max_pattern_len, const uint32 max_text_len, const uint32 stream_size)