Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/bmaggregator_8h_source.html below:

NCBI C++ ToolKit: include/util/bitset/bmaggregator.h Source File

<

BV>

<

Opt = bm::agg_run_options<> >

bvector_type::optmode opt = bvector_type::opt_compress)

<

TPipe>

<

BII>

<

BII>

src_sub_size);

* is_result_full,

init_clear =

);

,

j);

,

j);

* src_idx,

,

j);

,

j,

arena& ar);

(p) arena();

(p) arg_groups();

<

Agg,

It>

pipeline_size = 0;

(It it =

; it !=

; ++it, ++pipeline_size)

(It it =

; it !=

; ++it, ++w)

op_st = agg.get_operation_status();

(op_st != Agg::operation_status::op_done)

op_st = agg.run_step(

, j);

pipeline_size -= (op_st == Agg::operation_status::op_done);

(pipeline_size <= 0)

<

BV>

<

BV>

<

BV>

<

BV>

ar_->reset_all_blocks();

operation_ = top_block_size_ = 0;

operation_status_ = operation_status::op_undefined;

count_ = 0; bcache_ptr_ = 0; gap_cache_cnt_ = 0;

<

BV>

range_gap_blk_[0] = 0;

is_single_bit_ =

;

<

BV>

range_from_ = from; range_to_ = to;

bvector_type::block_idx_type

(nb_from == nb_to)

gap_init_range_block<gap_word_t>(

range_gap_blk_[0] = 0;

<

BV>

<

BV>

ag_.add(bv, agr_group);

<

BV>

(bv_target, ag_.arg_bv0.data(), ag_.arg_bv0.size());

<

BV>

combine_and_sub(bv_target,

ag_.arg_bv0.data(), ag_.arg_bv0.size(),

<

BV>

combine_and_sub(bv_target,

ag_.arg_bv0.data(), ag_.arg_bv0.size(),

ag_.arg_bv1.data(), ag_.arg_bv1.size(),

<

BV>

combine_and_sub(bv_target,

ag_.arg_bv0.data(), ag_.arg_bv0.size(),

ag_.arg_bv1.data(), ag_.arg_bv1.size(),

<

BV>

<

BII>

combine_and_sub(bi,

ag_.arg_bv0.data(), ag_.arg_bv0.size(),

ag_.arg_bv1.data(), ag_.arg_bv1.size());

<

BV>

find_first_and_sub(idx,

ag_.arg_bv0.data(), ag_.arg_bv0.size(),

ag_.arg_bv1.data(), ag_.arg_bv1.size());

<

BV>

ar_->reset_all_blocks();

combine_shift_right_and(bv_target, ag_.arg_bv0.data(), ag_.arg_bv0.size(),

<

BV>

ar_->reset_or_blocks();

top_blocks = resize_target(bv_target, bv_src, src_size);

(

= 0;

< top_blocks; ++

)

set_array_max =

find_effective_sub_block_size(

, bv_src, src_size,

);

(

j = 0; j < set_array_max; ++j)

<

BV>

ar_->reset_and_blocks();

top_blocks = resize_target(bv_target, bv_src, src_size);

(

= 0;

< top_blocks; ++

)

set_array_max =

find_effective_sub_block_size(

, bv_src, src_size,

);

(

j = 0; j < set_array_max; ++j)

<

BV>

global_found =

;

(!bv_src_and || !src_and_size)

top_blocks = resize_target(bv_target, bv_src_and, src_and_size);

top_blocks2 = resize_target(bv_target, bv_src_sub, src_sub_size,

);

(top_blocks2 > top_blocks)

top_blocks = top_blocks2;

(

= 0;

< top_blocks; ++

)

set_array_max =

find_effective_sub_block_size(

, bv_src_and, src_and_size,

bv_src_sub, src_sub_size);

(

j = 0; j < set_array_max; ++j)

bv_src_and, src_and_size,

bv_src_sub, src_sub_size,

&is_res_full, !any);

bman_target.check_alloc_top_subblock(

);

bman_target.validate_top_full(

);

found = digest;

bman_target.opt_copy_bit_block(

, j, tb_ar_->tb1,

bvector_type::opt_compress, tb_ar_->tb_opt);

global_found |= found;

global_found;

<

BV>

<

BII>

global_found =

;

(!bv_src_and || !src_and_size)

top_blocks = 0;

(

= 0;

< src_and_size; ++

)

arg_top_blocks = bv->get_blocks_manager().top_block_size();

(arg_top_blocks > top_blocks)

top_blocks = arg_top_blocks;

(

= 0;

< src_sub_size; ++

)

arg_top_blocks = bv->get_blocks_manager().top_block_size();

(arg_top_blocks > top_blocks)

top_blocks = arg_top_blocks;

(

= 0;

< top_blocks; ++

)

set_array_max =

find_effective_sub_block_size(

, bv_src_and, src_and_size,

bv_src_sub, src_sub_size);

(

j = 0; j < set_array_max; ++j)

bv_src_and, src_and_size,

bv_src_sub, src_sub_size,

&is_res_full,

);

found = digest;

global_found |= found;

global_found;

<

BV>

<

TPipe>

pipe_size = pipe_args.

();

bcache_ptr_ = &pipe.get_bcache();

top_blocks = pipe.get_top_blocks();

(pipe.bv_or_target_)

pipe.bv_or_target_->get_blocks_manager().reserve_top_blocks(top_blocks);

i_from(0), j_from(0), i_to(0), j_to(0);

bvector_type::block_idx_type nb;

batch_size = pipe.get_options().batch_size;

batch_size = pipe.compute_run_batch();

(

batch_from(0), batch_to(0); batch_from < pipe_size;

batch_from = batch_to)

batch_to = batch_from + batch_size;

(batch_to > pipe_size)

batch_to = pipe_size;

(

= i_from;

< top_blocks; ++

)

constexpr(TPipe::options_type::is_masks())

(; j < sub_size; ++j)

p = batch_from;

(; p < batch_to; ++p)

constexpr (TPipe::options_type::is_compute_counts())

(pipe.count_res_vect_[p] >= pipe.search_count_limit_)

bv_src_and, src_and_size,

bv_src_sub, src_sub_size,

(digest || is_res_full)

(pipe.bv_or_target_)

pipe.bv_or_target_->get_blocks_manager();

bman.check_alloc_top_subblock(

);

pipe.bv_or_target_->combine_operation_block_or(

, j, blk, arg_blk);

constexpr (!TPipe::options_type::is_make_results())

constexpr (TPipe::options_type::is_compute_counts())

pipe.count_res_vect_[p]+=

pipe.get_bv_res_vector();

bv_targets_vect[p] = bv_target;

bvector_type::blocks_manager_type& bman =

bv_target->get_blocks_manager();

bman.reserve_top_blocks(top_blocks);

bv_target->get_blocks_manager();

bman.check_alloc_top_subblock(

);

bman.set_block_ptr(

, j,

bman.validate_top_full(

);

constexpr (TPipe::options_type::is_compute_counts())

constexpr (TPipe::options_type::is_compute_counts())

pipe.count_res_vect_[p] +=

bman.opt_copy_bit_block(

, j, tb_ar_->tb1,

bvector_type::opt_compress, tb_ar_->tb_opt);

(pipe.bv_or_target_ && p == pipe_size)

pipe.bv_or_target_->get_blocks_manager();

(

* blk = bman.get_block_ptr(

, j))

bman.optimize_block(

, j, blk,

tb_ar_->tb_opt, bvector_type::opt_compress, 0);

<

BV>

top_blocks = max_top_blocks(bv_src_and, src_and_size);

top_blocks2 = max_top_blocks(bv_src_sub, src_sub_size);

(top_blocks2 > top_blocks)

top_blocks = top_blocks2;

(nblock_from == nblock_to)

= top_from;

bv_src_and, src_and_size,

bv_src_sub, src_sub_size,

block_bit_idx = 0;

(top_to < top_blocks)

top_blocks = top_to+1;

(

= top_from;

< top_blocks; ++

)

set_array_max = find_effective_sub_block_size(

, bv_src_and, src_and_size,

);

set_array_max2 =

find_effective_sub_block_size(

, bv_src_sub, src_sub_size,

);

(set_array_max2 < set_array_max)

set_array_max = set_array_max2;

(; j < set_array_max; ++j)

bv_src_and, src_and_size,

bv_src_sub, src_sub_size,

&is_res_full,

);

block_bit_idx = 0;

<

BV>

max_size = 1;

(

k = 0; k < src_size; ++k)

bvector_type::blocks_manager_type& bman_arg =

bv->get_blocks_manager();

*

* blk_blk_arg = bman_arg.get_topblock(

);

(top_null_as_zero)

<

BV>

set_array_max = find_effective_sub_block_size(

, bv_src1, src_size1,

);

(set_array_max && src_size2)

set_array_max2 =

find_effective_sub_block_size(

, bv_src2, src_size2,

);

(set_array_max2 > set_array_max)

set_array_max = set_array_max2;

set_array_max;

<

BV>

bvector_type::blocks_manager_type& bman_target =

bv_target.get_blocks_manager();

ar_->reset_or_blocks();

* blk = sort_input_blocks_or(

bv_src, src_size,

, j);

bman_target.check_alloc_top_subblock(

);

bman_target.set_block_ptr(

, j, blk);

bman_target.validate_top_full(

);

arg_blk_count = ar_->v_arg_or_blk.size();

arg_blk_gap_count = ar_->v_arg_or_blk_gap.size();

(arg_blk_count || arg_blk_gap_count)

all_one = process_bit_blocks_or(bman_target,

, j, *ar_);

(arg_blk_gap_count)

process_gap_blocks_or(*ar_);

bman_target.opt_copy_bit_block(

, j, tb_ar_->tb1,

opt_mode_, tb_ar_->tb_opt);

<

BV>

src_and_size)

* blk = sort_input_blocks_and(

bv_src, src_and_size,

, j);

arg_blk_and_count = ar_->v_arg_and_blk.size();

arg_blk_and_gap_count = ar_->v_arg_and_blk_gap.size();

(arg_blk_and_count || arg_blk_and_gap_count)

(!arg_blk_and_gap_count && (arg_blk_and_count == 1))

bman_target.check_alloc_top_subblock(

);

bman_target.set_block_ptr(

, j, blk);

bman_target.validate_top_full(

);

digest = process_bit_blocks_and(*ar_, ~0ull,

);

(arg_blk_and_gap_count)

digest = process_gap_blocks_and(*ar_, digest);

bman_target.opt_copy_bit_block(

, j, tb_ar_->tb1,

opt_mode_, tb_ar_->tb_opt);

<

BV>

,

j,

* is_result_full,

find_all)

is_single_bit_ =

;

*is_result_full = 0;

* blk = sort_input_blocks_and(

bv_src_and, src_and_size,

, j);

arg_blk_and_count = ar_->v_arg_and_blk.size();

arg_blk_and_gap_count = ar_->v_arg_and_blk_gap.size();

(!(arg_blk_and_count | arg_blk_and_gap_count))

ar_->reset_or_blocks();

blk = sort_input_blocks_or(

bv_src_sub, src_sub_size,

, j);

(!arg_blk_and_gap_count && (arg_blk_and_count == 1))

*is_result_full = 1;

digest = process_bit_blocks_and(*ar_, ~0ull, find_all);

digest = process_bit_blocks_sub(*ar_, digest);

arg_blk_gap_count = ar_->v_arg_and_blk_gap.size();

(

k = 0; k < arg_blk_gap_count; ++k)

arg_blk_gap_count = ar_->v_arg_or_blk_gap.size();

(

k = 0; k < arg_blk_gap_count; ++k)

digest = process_gap_blocks_and(*ar_, digest);

digest = process_gap_blocks_sub(*ar_, digest);

is_single_bit_ =

;

<

BV>

(

k = 0; k < arg_blk_gap_count; ++k)

<

BV>

(

k = 0; (k < arg_blk_gap_count) && digest; ++k)

(++k; k < arg_blk_gap_count; ++k)

<

BV>

(

k = 0; k < arg_blk_gap_count; ++k)

(

k = 0; digest && (k < arg_blk_gap_count); ++k)

(++k; k < arg_blk_gap_count; ++k)

<

BV>

(

= 0;

< arg_blk_gap_count &&

; ++

)

<

BV>

(

= 0;

< arg_blk_gap_count; ++

)

<

BV>

,

j,

unroll_factor,

, len_unr;

= arg_blk_count - k;

len_unr =

- (

% unroll_factor);

( ;k < len_unr; k+=unroll_factor)

= arg_blk_count - k;

len_unr =

- (

% unroll_factor);

( ;k < len_unr; k+=unroll_factor)

(; k < arg_blk_count; ++k)

<

BV>

(range_set_ && (nb_from == nb_to))

(arg_blk_count > 1)

args[k], args[k+1], digest);

(arg_blk_count)

unroll_factor = 4;

(; k + unroll_factor < arg_blk_count; k += unroll_factor)

args[k], args[k+1], args[k+2], args[k+3],

(; k + unroll_factor < arg_blk_count; k += unroll_factor)

args[k+2][nword] & args[k+3][nword];

(; k + 2 < arg_blk_count; k += 2)

(; k < arg_blk_count; ++k)

acc &= args[k][nword];

(; k + 2 < arg_blk_count; k += 2)

0:

digest;

&single_bit_idx_, digest);

(is_single_bit_) { ++k;

sbit_check; }

(; k < arg_blk_count; ++k)

0:

digest;

&single_bit_idx_, digest);

{ ++k;

sbit_check; }

<

BV>

unroll_factor = 4;

(; k + unroll_factor < arg_blk_count; k += unroll_factor)

args[k], args[k+1],args[k+2], args[k+3],

&single_bit_idx_, digest);

=

nword =

(; k + unroll_factor < arg_blk_count; k += unroll_factor)

acc = args[k][nword] | args[k+1][nword] |

args[k+2][nword] | args[k+3][nword];

(; k < arg_blk_count; ++k)

acc |= args[k][nword];

(; k + 2 < arg_blk_count; k += 2)

0:

digest;

&single_bit_idx_, digest);

(is_single_bit_) { ++k;

sbit_check; }

(; k < arg_blk_count; ++k)

0:

digest;

{ ++k;

sbit_check; }

<

BV>

bvector_type::blocks_manager_type& bman_target = bv_target.get_blocks_manager();

(bman_target.is_init())

bman_target.deinit_tree();

top_blocks = bman_target.top_block_size();

need_realloc =

;

(

= 0;

< src_size; ++

)

bvector_type::blocks_manager_type& bman_arg =

bv->get_blocks_manager();

arg_top_blocks = bman_arg.top_block_size();

(arg_top_blocks > top_blocks)

need_realloc =

;

top_blocks = arg_top_blocks;

(arg_size >

)

bman_target.reserve_top_blocks(top_blocks);

(!bman_target.is_init())

bman_target.init_tree();

(

> bv_target.size())

bv_target.resize(

);

<

BV>

top_blocks = 1;

(

= 0;

< src_size; ++

)

bvector_type::blocks_manager_type& bman_arg =

bv->get_blocks_manager();

arg_top_blocks = bman_arg.top_block_size();

(arg_top_blocks > top_blocks)

top_blocks = arg_top_blocks;

<

BV>

,

j)

bit_arr = ar_->v_arg_or_blk.resize_no_copy(src_size);

gap_arr = ar_->v_arg_or_blk_gap.resize_no_copy(src_size);

bc(0), gc(0);

(

k = 0; k < src_size; ++k)

bv_src[k]->get_blocks_manager().get_block_ptr(

, j);

bit_arr[bc++] = arg_blk;

ar_->v_arg_or_blk.resize_no_check(bc);

ar_->v_arg_or_blk_gap.resize_no_check(gc);

<

BV>

,

j)

ar_->v_arg_tmp_blk.resize_no_copy(src_size);

blocks_arr = ar_->v_arg_tmp_blk.data();

(

k = 0; k < src_size; ++k)

bv_src[k]->get_blocks_manager().get_block_ptr(

, j);

has_full_blk =

;

bit_arr = ar_->v_arg_and_blk.resize_no_copy(src_size + 1);

gap_arr = ar_->v_arg_and_blk_gap.resize_no_copy(src_size + 1);

bc(0), gc(0);

(

k = 0; k < src_size; ++k)

gap_arr[gc++] = gap_blk;

has_full_blk =

;

bit_arr[bc++] = arg_blk;

(range_gap_blk_[0])

gap_arr[gc++] = range_gap_blk_;

ar_->v_arg_and_blk_gap.resize_no_check(gc);

(has_full_blk && (!bc && !gc))

ar_->v_arg_and_blk.resize_no_check(bc);

<

BV>

* src_idx,

,

j)

bv_idx = src_idx[k];

= bcache_ptr_->cnt_vect_[bv_idx];

* bit_blk = bcache_ptr_->blk_vect_[bv_idx];

bcache_ptr_->blk_vect_[bv_idx] = bit_blk;

bcache_ptr_->blk_ij_vect_[bv_idx] = pair_ij;

<

BV>

(

= 1;

< src_size; ++

)

bv_target.bit_or(*bv);

<

BV>

(

= 1;

< src_size; ++

)

bv_target.bit_and(*bv);

<

BV>

src_and_size,

src_sub_size)

combine_and_horizontal(bv_target, bv_src_and, src_and_size);

(

= 0;

< src_sub_size; ++

)

<

BV>

top_block_size_ = resize_target(bv_target, bv_src, src_size);

ar_->carry_overs.resize(src_size);

(

= 0;

< src_size; ++

)

ar_->carry_overs[

] = 0;

<

BV>

prepare_shift_right_and(bv_target, bv_src_and, src_and_size);

(

> top_block_size_)

(!any_carry_overs(ar_->carry_overs.data(), src_and_size))

combine_shift_right_and(

, j, bv_target, bv_src_and, src_and_size);

(count_);

bv_target.any();

<

BV>

* blk = temp_blk_ ? temp_blk_ : tb_ar_->tb1;

* carry_overs = ar_->carry_overs.data();

blk_zero =

;

* arg_blk = bman_arg.get_block(

, j);

(

k = 1; k < src_size; ++k)

carry_over = carry_overs[k];

(!digest && !carry_over)

blk_zero = !blk_zero;

* arg_blk = get_arg_block(bv_src, k,

, j);

carry_overs[k] = (

char)

process_shift_right_and(blk, arg_blk, digest, carry_over);

(carry_overs[k] == 0 || carry_overs[k] == 1);

bman_target.opt_copy_bit_block(

, j, blk, opt_mode_, tb_ar_->tb_opt);

<

BV>

(carry_over == 1 || carry_over == 0);

blk[0] = carry_over;

blk[0] = carry_over & arg_blk[0];

<

BV>

bv_src[k]->get_blocks_manager().get_block(

, j);

<

BV>

acc = carry_overs[0];

(

= 1;

< co_size; ++

)

acc |= carry_overs[

];

<

BV>

temp_blk_ = temp_block;

BM_NOT_DEFINED:

BM_SHIFT_R_AND:

prepare_shift_right_and(*bv_target, ag_.arg_bv0.data(), ag_.arg_bv0.size());

operation_status_ = operation_status::op_prepared;

<

BV>

(operation_status_ == operation_status::op_prepared

|| operation_status_ == operation_status::op_in_progress);

BM_NOT_DEFINED:

BM_SHIFT_R_AND:

(

> top_block_size_)

(!this->any_carry_overs(ar_->carry_overs.data(), ag_.arg_bv0.size()))

operation_status_ = operation_status::op_done;

operation_status_;

this->combine_shift_right_and(

, j, *bv_target_,

ag_.arg_bv0.data(), ag_.arg_bv0.size());

operation_status_ = operation_status::op_in_progress;

operation_status_;

<

BV>

<

Opt>

sz = arg_vect_.size();

(

= 0;

< sz; ++

)

free_arg_group(

[

]);

sz = bv_res_vect_.size();

(

= 0;

< sz; ++

)

sz = bcache_.blk_vect_.size();

** blk_arr = bcache_.blk_vect_.data();

(

= 0;

< sz; ++

)

<

BV>

<

Opt>

constexpr (Opt::is_make_results())

sz = arg_vect_.size();

bv_res_vect_.resize(sz);

(

= 0;

< sz; ++

)

constexpr (Opt::is_compute_counts())

sz = arg_vect_.size();

count_res_vect_.resize(sz);

* cnt_arr = count_res_vect_.data();

::memset(cnt_arr, 0, sz *

(cnt_arr[0]));

pipe_size = pipe_args.

();

(

p = 0; p < pipe_size; ++p)

complete_arg_group(ag);

top_blocks1 = max_top_blocks(bv_src_and, src_and_size);

(top_blocks1 > top_blocks_)

top_blocks_ = top_blocks1;

top_blocks2 = max_top_blocks(bv_src_sub, src_sub_size);

(top_blocks2 > top_blocks_)

top_blocks_ = top_blocks2;

is_complete_ =

;

(bcache_.bv_inp_vect_.size() == bcache_.cnt_vect_.size());

(bcache_.bv_inp_vect_.size() == bcache_.blk_vect_.size());

(bcache_.bv_inp_vect_.size() == bcache_.blk_ij_vect_.size());

<

BV>

<

Opt>

<

BV>

<

Opt>

(

k = 0; k <

; ++k)

found(

);

bv_idx(0);

** bv_arr = bcache_.bv_inp_vect_.data();

((

**)bv_arr, bcache_.bv_inp_vect_.size(),

bcache_.cnt_vect_[bv_idx]++;

bv_idx = bcache_.bv_inp_vect_.size();

bcache_.bv_inp_vect_.push_back(bv);

bcache_.cnt_vect_.push_back(0);

bcache_.blk_vect_.push_back(0);

<

BV>

<

Opt>

arg_vect_.push_back(arg);

<

BV>

<

Opt>

cache_size = 256 * 1024;

bv_struct_overhead = (64 * 8);

cached_vect = float(cache_size) / float(block_size + bv_struct_overhead);

bv_count = unique_vectors();

args_total = arg_vect_.size();

((bv_count < cached_vect) || (args_total < 2))

avg_vect_per_group = total_vect_ / args_total;

reuse_coeff = 0.7f;

f_batch_size =

(1+reuse_coeff)*(

(avg_vect_per_group) / float(cached_vect) + 0.99f);

batch_size = size_t(f_batch_size);

<

BV>

ncbi::TMaskedQueryRegions mask

#define BM_DECLARE_TEMP_BLOCK(x)

#define BM_ASSERT_THROW(x, xerrcode)

#define FULL_BLOCK_FAKE_ADDR

#define FULL_BLOCK_REAL_ADDR

Bit manipulation primitives (internal)

Pipeline vector for running a group of aggregation operations on a family of vectors.

const bv_vector_type & get_all_input_vect() const noexcept

bool is_complete_

ready to run state flag

size_t compute_run_batch() const noexcept

Function looks at the pipeline to apply euristics to suggest optimal run_batch parameter.

run_options & options() noexcept

Set pipeline run options.

void complete_arg_sub_group(index_vector_type &idx_vect, const bvector_type_const_ptr *bv_src, size_t size)

size_t total_vect_

total number of vector mentions in all groups

const count_vector_type & get_all_input_cnt_vect() const noexcept

bv_count_vector_type & get_bv_count_vector() noexcept

Return results vector count used for pipeline execution.

const run_options & get_options() const noexcept

Get pipeline run options.

bool is_complete() const noexcept

return true if pipeline is ready for execution (complete)

void set_search_count_limit(size_type limit) noexcept

Set search limit for results.

void set_or_target(bvector_type *bv_or) noexcept

Attach OR (aggregator vector).

void complete_arg_group(arg_groups *ag)

size_type size() const noexcept

Return size() of pileine.

bvector_type * bv_or_target_

OR target bit-bector ptr.

unsigned top_blocks_

top-level structure size, max of all bvectors

const arg_vector_type & get_args_vector() const noexcept

Return argument vector used for pipeline execution.

bv_count_vector_type count_res_vect_

results (counts)

arg_groups * add()

Add new arguments group.

size_type search_count_limit_

search limit by count

pipeline(const pipeline &)=delete

pipeline & operator=(const pipeline &)=delete

pipeline_bcache & get_bcache() noexcept

void complete()

Prepare pipeline for the execution (resize and init internal structures) Once complete,...

pipeline_bcache bcache_

blocks cache structure

arg_vector_type arg_vect_

input arg. groups

run_options options_

execution parameters

unsigned get_top_blocks() const noexcept

Return number of top blocks after complete.

bvect_vector_type bv_res_vect_

results (bit-vector ptrs)

size_t unique_vectors() const noexcept

Return number of unique vectors in the pipeline (after complete())

bvect_vector_type & get_bv_res_vector() noexcept

Return results vector used for pipeline execution.

Algorithms for fast aggregation of a group of bit-vectors.

BV::block_idx_type block_idx_type

void combine_or(unsigned i, unsigned j, bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

bm::word_t * cache_gap_block(const bm::word_t *arg_blk, const size_t *src_idx, size_t k, unsigned i, unsigned j)

bvector_type * check_create_target()

unsigned top_block_size_

operation top block (i) size

bool compute_count_

compute search result count

bool test_gap_blocks_sub(size_t block_count, unsigned bit_idx)

arg_groups * arg_groups_type_ptr

digest_type process_bit_blocks_sub(const arena &ar, digest_type digest)

pipeline_bcache * bcache_ptr_

bm::heap_vector< bm::pair< unsigned, unsigned >, allocator_type, true > block_ij_vector_type

void combine_and(unsigned i, unsigned j, bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

void combine_or(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

Aggregate group of vectors using logical OR.

int operation_

operation code (default: not defined)

static const bm::word_t * get_arg_block(const bvector_type_const_ptr *bv_src, unsigned k, unsigned i, unsigned j) noexcept

allocator_pool_type pool_

pool for operations with cyclic mem.use

arg_groups ag_

aggregator argument groups

bm::word_t * temp_blk_

external temp block ptr

bm::word_t * sort_input_blocks_and(const bvector_type_const_ptr *bv_src, size_t src_size, unsigned i, unsigned j)

bm::heap_vector< bvector_type *, allocator_type, true > bvect_vector_type

bm::heap_vector< bvector_type_const_ptr, allocator_type, true > bv_vector_type

void combine_shift_right_and(bvector_type &bv_target)

Aggregate added group of vectors using SHIFT-RIGHT and logical AND Operation does NOT perform an expl...

bvector_type * bv_target_

target bit-vector

bm::heap_vector< size_type, allocator_type, true > bv_count_vector_type

static unsigned process_shift_right_and(bm::word_t *blk, const bm::word_t *arg_blk, digest_type &digest, unsigned carry_over) noexcept

BV::allocator_type allocator_type

bool is_single_bit_

single bit flag

bm::gap_word_t range_gap_blk_[5]

temp GAP range block

static void free_arg_group(arg_groups *arg)

operation_status run_step(unsigned i, unsigned j)

Run a step of current arrgegation operation.

static bool any_carry_overs(const unsigned char *carry_overs, size_t co_size) noexcept

void combine_and_sub(TPipe &pipe)

Run AND-SUB: AND (groups1) AND NOT ( OR(group0)) for a pipeline.

void stage(bm::word_t *temp_block)

Prepare operation, create internal resources, analyse dependencies.

bool combine_and_sub(bvector_type &bv_target)

Aggregate added group of vectors using fused logical AND-SUB Operation does NOT perform an explicit r...

bm::heap_vector< size_t, allocator_type, true > index_vector_type

void reset()

Reset aggregate groups, forget all attached vectors.

void set_operation(int op_code) noexcept

Set operation code for the aggregator.

bvector_type::blocks_manager_type blocks_manager_type

arena * ar_

data arena ptr

digest_type combine_and_sub(unsigned i, unsigned j, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, const bvector_type_const_ptr *bv_src_sub, size_t src_sub_size, int *is_result_full, bool find_all)

void combine_or(bvector_type &bv_target)

Aggregate added group of vectors using logical OR Operation does NOT perform an explicit reset of arg...

bm::heap_vector< unsigned, allocator_type, true > count_vector_type

digest_type process_bit_blocks_and(const arena &ar, digest_type digest, bool find_all)

bool combine_and_sub(bvector_type &bv_target, bool any)

Aggregate added group of vectors using fused logical AND-SUB Operation does NOT perform an explicit r...

void combine_and(bvector_type &bv_target)

Aggregate added group of vectors using logical AND Operation does NOT perform an explicit reset of ar...

digest_type process_gap_blocks_sub(const arena &ar, digest_type digest)

bm::heap_vector< const bm::word_t *, allocator_type, true > block_ptr_vector_type

size_type range_from_

search from

bool combine_shift_right_and(bvector_type &bv_target, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, bool any)

Fusion aggregate group of vectors using SHIFT right with AND.

static arg_groups * construct_arg_group()

const bvector_type * bvector_type_const_ptr

const bvector_type * get_target() const noexcept

static unsigned find_effective_sub_block_size(unsigned i, const bvector_type_const_ptr *bv_src1, size_t src_size1, const bvector_type_const_ptr *bv_src2, size_t src_size2) noexcept

int get_operation() const noexcept

Get current operation code.

bool find_first_and_sub(size_type &idx)

Aggregate added group of vectors using fused logical AND-SUB, find the first match.

bm::id64_t get_cache_gap_hits() const noexcept

size_t add(const bvector_type *bv, unsigned agr_group=0)

Attach source bit-vector to a argument group (0 or 1).

bool combine_shift_right_and(unsigned i, unsigned j, bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

void reset_range_hint() noexcept

Reset range hint to false.

operation

Codes for aggregation operations which can be pipelined for efficient execution.

bm::word_t * sort_input_blocks_or(const bvector_type_const_ptr *bv_src, size_t src_size, unsigned i, unsigned j)

bm::heap_vector< unsigned char, allocator_type, true > uchar_vector_type

bm::word_t * get_temp_block() noexcept

bool combine_and_sub(BII bi, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, const bvector_type_const_ptr *bv_src_sub, size_t src_sub_size)

void combine_and_horizontal(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

Horizontal AND aggregation (potentially slower) method.

bm::heap_vector< bm::word_t *, allocator_type, true > blockptr_vector_type

digest_type process_gap_blocks_and(const arena &ar, digest_type digest)

static unsigned find_effective_sub_block_size(unsigned i, const bvector_type_const_ptr *bv_src, size_t src_size, bool top_null_as_zero) noexcept

bool test_gap_blocks_and(size_t block_count, unsigned bit_idx)

void set_optimization(typename bvector_type::optmode opt=bvector_type::opt_compress) noexcept

set on-the-fly bit-block compression By default aggregator does not try to optimize result,...

bool range_set_

pipeline blocks cache ptr

size_type range_to_

search to

bool combine_and_sub_bi(BII bi)

Aggregate added group of vectors using fused logical AND-SUB.

bool find_first_and_sub(size_type &idx, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, const bvector_type_const_ptr *bv_src_sub, size_t src_sub_size)

void prepare_shift_right_and(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

void process_gap_blocks_or(const arena &ar)

void set_compute_count(bool count_mode) noexcept

tb_arena * tb_ar_

data arena ptr (heap allocated)

static unsigned resize_target(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size, bool init_clear=true)

size_type count_

search result count

bvector_type::allocator_type::allocator_pool_type allocator_pool_type

static arena * construct_arena()

bm::heap_vector< arg_groups_type_ptr, allocator_type, true > arg_vector_type

static unsigned max_top_blocks(const bvector_type_const_ptr *bv_src, size_t src_size) noexcept

bool combine_and_sub(bvector_type &bv_target, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, const bvector_type_const_ptr *bv_src_sub, size_t src_sub_size, bool any)

Fusion aggregate group of vectors using logical AND MINUS another set.

bm::heap_vector< const bm::gap_word_t *, allocator_type, true > gap_block_ptr_vector_type

void combine_or_horizontal(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

Horizontal OR aggregation (potentially slower) method.

operation_status operation_status_

static void free_arena(arena *ar) noexcept

void combine_and_sub_horizontal(bvector_type &bv_target, const bvector_type_const_ptr *bv_src_and, size_t src_and_size, const bvector_type_const_ptr *bv_src_sub, size_t src_sub_size)

Horizontal AND-SUB aggregation (potentially slower) method.

bm::id64_t gap_cache_cnt_

void combine_and(bvector_type &bv_target, const bvector_type_const_ptr *bv_src, size_t src_size)

Aggregate group of vectors using logical AND.

bool set_range_hint(size_type from, size_type to) noexcept

Set search hint for the range, where results needs to be searched (experimental for internal use).

bvector_type::optmode opt_mode_

perform search result optimization

operation_status get_operation_status() const

bool process_bit_blocks_or(blocks_manager_type &bman_target, unsigned i, unsigned j, const arena &ar)

value_type * data() const noexcept

void resize(size_type new_size)

vector resize

size_type size() const noexcept

void reset() noexcept

Quick resize to zero.

void push_back(const value_type &v)

push new element to the back of the vector

static vector< string > arr

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

bm::id_t bit_block_count(const bm::word_t *block) noexcept

Bitcount for bit block.

bool bit_find_first(const bm::word_t *block, unsigned *pos) noexcept

BIT block find the first set bit.

bm::id64_t bit_block_and_3way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND

bm::id64_t digest_mask(unsigned from, unsigned to) noexcept

Compute digest mask for [from..to] positions.

unsigned word_bitcount64(bm::id64_t x) noexcept

int for_each_bit_blk(const bm::word_t *block, SIZE_TYPE offset, Func &bit_functor)

for-each visitor, calls a visitor functor for each 1 bit group

bool bit_block_or(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock OR operation. Function does not analyse availability of source and destination blocks.

bm::id64_t bit_block_and(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock AND operation. Function does not analyse availability of source and destination blocks...

void block_init_digest0(bm::word_t *const block, bm::id64_t digest) noexcept

Init block with 000111000 pattren based on digest.

bool bit_block_or_3way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2) noexcept

3 way (target | source1 | source2) bitblock OR operation. Function does not analyse availability of s...

bool is_bits_one(const bm::wordop_t *start) noexcept

Returns "true" if all bits in the block are 1.

bool bit_is_all_zero(const bm::word_t *start) noexcept

Returns "true" if all bits in the block are 0.

void bit_block_set(bm::word_t *dst, bm::word_t value) noexcept

Bitblock memset operation.

bool bit_block_or_5way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, const bm::word_t *src3, const bm::word_t *src4) noexcept

5 way (target, source1, source2) bitblock OR operation. Function does not analyse availability of sou...

void bit_block_copy(bm::word_t *dst, const bm::word_t *src) noexcept

Bitblock copy operation.

bm::id64_t bit_block_and_2way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND

bool bit_block_shift_r1_and_unr(bm::word_t *block, bm::word_t co_flag, const bm::word_t *mask_block, bm::id64_t *digest) noexcept

Right bit-shift bitblock by 1 bit (reference) + AND.

bm::id64_t bit_block_sub_3way(bm::word_t *dst, const bm::word_t *src0, const bm::word_t *src1, bm::id64_t digest) noexcept

digest based bit-block SUB 3-way

bool bit_find_first_if_1(const bm::word_t *block, unsigned *first, bm::id64_t digest) noexcept

BIT block find the first set bit if only 1 bit is set.

bm::id64_t bit_block_sub_5way(bm::word_t *dst, const bm::word_t *src0, const bm::word_t *src1, const bm::word_t *src2, const bm::word_t *src3, bm::id64_t digest) noexcept

digest based bit-block SUB 5-way

bm::id64_t bit_block_init_and_2way(bm::word_t *dst, const bm::word_t *src1, const bm::word_t *src2, bm::id64_t digest) noexcept

digest based bit-block AND (0 elements of digest will be zeroed)

bm::id64_t calc_block_digest0(const bm::word_t *const block) noexcept

Compute digest for 64 non-zero areas.

bm::id64_t bit_block_and_5way(bm::word_t *dst, const bm::word_t *src0, const bm::word_t *src1, const bm::word_t *src2, const bm::word_t *src3, bm::id64_t digest) noexcept

digest based bit-block AND 5-way

bm::id64_t bit_block_sub(bm::word_t *dst, const bm::word_t *src) noexcept

Plain bitblock SUB (AND NOT) operation. Function does not analyse availability of source and destinat...

@ READWRITE

mutable (read-write object)

@ BM_GAP

GAP compression is ON.

void gap_add_to_bitset(unsigned *dest, const T *pcurr, unsigned len) noexcept

Adds(OR) GAP block to bitblock.

unsigned gap_test_unr(const T *buf, const unsigned pos) noexcept

Tests if bit = pos is true. Analog of bm::gap_test with SIMD unrolling.

void gap_convert_to_bitset(unsigned *dest, const T *buf, unsigned len=0) noexcept

GAP block to bitblock conversion.

void gap_and_to_bitset(unsigned *dest, const T *pcurr) noexcept

ANDs GAP block to bitblock.

void gap_sub_to_bitset(unsigned *dest, const T *pcurr) noexcept

SUB (AND NOT) GAP block to bitblock.

bm::agg_run_options< agg_disable_result_bvectors, agg_disable_counts > agg_opt_disable_bvects_and_counts

Pre-defined aggregator options to disable both intermediate results and counts.

void combine_and(BV &bv, It first, It last)

AND Combine bitvector and the iterable sequence.

const bool agg_disable_search_masks

const bool agg_produce_result_bvectors

bm::agg_run_options< agg_disable_result_bvectors, agg_compute_counts > agg_opt_only_counts

Pre-defined aggregator options for counts-only (results dropped) operation.

void combine_or(BV &bv, It first, It last)

OR Combine bitvector and the iterable sequence.

void aggregator_pipeline_execute(It first, It last)

Experimental method ro run multiple aggregators in sync.

const bool agg_disable_counts

bm::agg_run_options< agg_produce_result_bvectors, agg_compute_counts > agg_opt_bvect_and_counts

Pre-defined aggregator options for results plus counts operation.

const bool agg_disable_result_bvectors

const bool agg_compute_counts

const unsigned set_array_mask

const unsigned set_block_mask

void aligned_free(void *ptr) BMNOEXCEPT

Aligned free.

const unsigned set_sub_array_size

void get_block_coord(BI_TYPE nb, unsigned &i, unsigned &j) noexcept

Recalc linear bvector block index into 2D matrix coordinates.

bm::id_t block_to_global_index(unsigned i, unsigned j, unsigned block_idx) noexcept

calculate bvector<> global bit-index from block-local coords

void * aligned_new_malloc(size_t size)

Aligned malloc (unlike classic malloc it throws bad_alloc exception)

bool find_ptr(const void *const *p_arr, size_t arr_size, const void *ptr, size_t *idx) noexcept

Scan search for pointer value in unordered array.

const unsigned set_word_shift

const unsigned set_block_size

unsigned long long int id64_t

const unsigned set_array_shift

unsigned short gap_word_t

const unsigned gap_max_bits

const unsigned set_top_array_size

const unsigned set_block_shift

const unsigned set_word_mask

const unsigned bits_in_block

const struct ncbi::grid::netcache::search::fields::SIZE size

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

Aggregation options to control execution Default settings are to support only result bit-vector filte...

static constexpr bool is_make_results() noexcept

make result(target) vectors (aggregation search results) (Default: true) when false is used - means w...

static constexpr bool is_compute_counts() noexcept

Compute counts for the target vectors, when set to true, population count is computed for each result...

static constexpr bool is_masks() noexcept

Support for masking operations (Default: false)

Temporary operations vectors.

gap_block_ptr_vector_type v_arg_and_blk_gap

source GAP blocks list (AND)

block_ptr_vector_type v_arg_and_blk

source blocks list (AND)

block_ptr_vector_type v_arg_or_blk

source blocks list (OR)

gap_block_ptr_vector_type v_arg_or_blk_gap

source GAP blocks list (OR)

block_ptr_vector_type v_arg_tmp_blk

source blocks list

uchar_vector_type carry_overs

shift carry over flags

size_t add(const bvector_type *bv, unsigned agr_group)

Add bit-vector pointer to its aggregation group.

bv_vector_type arg_bv0

arg group 0

bv_vector_type arg_bv1

arg group 1

void reset()

Reset argument groups to zero.

index_vector_type arg_idx0

indexes of vectors for arg group 0

index_vector_type arg_idx1

Block cache for pipeline execution.

blockptr_vector_type blk_vect_

cached block ptrs for bv_inp_vect_

count_vector_type cnt_vect_

usage count for bv_inp (all groups)

bv_vector_type bv_inp_vect_

all input vectors from all groups

block_ij_vector_type blk_ij_vect_

current block coords

Aggregation options for runtime control.

size_t batch_size

Batch size sets number of argument groups processed at a time Default: 0 means this parameter will be...

Alllocated blocka of scratch memory.

bm::bit_block_t tb_opt

temp block for results optimization

functor-adaptor for back-inserter

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4