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

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

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

<

Alloc>

<

TAlloc>

;

first_bit = block ? 1 : 0;

first_bit = block[0] & 1;

this->

(blockman);

.top_blocks_ = btmp;

top_block_sz = (unsigned)

* ret = (blk_blk == 0) ? 0 : blk_blk[j];

(blk_blk) ? blk_blk[j] : 0;

(blk_blk) ? blk_blk[j] : 0;

->top_blocks_root();

.free_bit_block(block);

, j, i_from, j_from, i_to, j_to;

(j = j_from; j <= j_to; ++j)

(j = 0; j <= j_to; ++j)

(

= i_from;

<= i_to; ++

)

, j, i_from, j_from, i_to, j_to;

(j = j_from; j <= j_to; ++j)

(j = 0; j <= j_to; ++j)

(

= i_from;

<= i_to; ++

)

.free_bit_block(old_block);

new_block =

.alloc_bit_block();

threshold = unsigned(this->

(

(level)) - 4u);

(res_len >= threshold)

::memcpy(tblk, tmp_buf, (res_len+1) *

(

));

new_blk =

.alloc_bit_block();

content_flag,

initial_block_type,

* actual_block_type,

allow_null_ret=

)

*actual_block_type = initial_block_type;

(block_flag == content_flag && allow_null_ret)

(initial_block_type == 0)

block =

.alloc_bit_block();

(initial_block_type == 0)

block =

.alloc_bit_block();

(level), this->

());

::memcpy(gap_blk_ptr, gap_block_src,

blk_blk[j+0] = blk_blk[j+1] = blk_blk[j+2] = blk_blk[j+3] =

;

(gap_count < threashold)

(gap_count < threashold)

(gap_count < threashold)

threashold)

gap_block = gap_block ? gap_block :

(block);

(!block && alloc)

,

j)

.free_gap_block(gap_block, this->

());

.free_bit_block(block);

cnt_sum(0), effective_blocks(0), gap_len_sum(0);

* blk = sub_stat.blocks[j] = blk_blk[j];

sub_stat.full_blocks++;

gap_len_sum += (gp[0] >> 3);

sub_stat.gap_len_sum += (gp[0] >> 3);

sub_stat.gap_blocks++;

sub_stat.bc_arr[j] = bc;

sub_stat.bit_blocks++;

sub_stat.bv_count += bc;

sub_stat.empty_blocks++; sub_stat.bc_arr[j] = 0;

(sub_stat.bit_blocks + sub_stat.gap_blocks +

sub_stat.empty_blocks +

(cnt_sum > non_sparse_cut_off

)

(effective_blocks > 1)

gap_len_sum += effective_blocks * 4;

(gap_len_sum < cnt_sum)

diff = cnt_sum - gap_len_sum;

cut_off = cnt_sum * 0.14f;

.alloc_bit_block();

.free_bit_block(block);

*ptr = (

)(((

-1) << 3) | (level << 1) | (*src & 1));

(

< top_blocks)

::memset(&new_blocks[

], 0,

(

*) * (top_blocks-

));

( ; tb_cnt; --tb_cnt)

)

(

= 0;

< top_blocks; )

(

= 0;

< top_blocks; ++

)

= top_blocks - 1;

(;

> 0; --

)

s_size =

(unsigned);

(

= 0;

< top_blocks; )

s_size += nb_full ? 1+

(

) : 0; nb_full = 0;

nb_prev =

++;

s_size += nb_empty ? 1+

(

) : 0; nb_empty = 0;

s_size += nb_full ? 1+

(

) : 0; nb_full = 0;

s_size += nb_empty ? 1+

(

) : 0; nb_empty = 0;

s_size += nb_empty ? 1+

(

) : 0; nb_empty = 0;

s_size += nb_full ? 1+

(

) : 0; nb_full = 0;

(new_level >= 0 && new_level < old_level)

gap_blk = new_gap_blk;

((block[0] & 1u))

(gap_count < threashold)

(

= 0;

< top_blocks; ++

)

stat->add_scorrection();

blocks_mem =

(*this);

blocks_mem +=

(

**) * top_size;

stat->memory_used += blocks_mem;

(

= 0;

< top_size; ++

)

*

* blk_blk = blk_root[

];

blk_blk = blk_root[

];

->gap_blocks_sz +=

;

std::bad_alloc();

BM_THROW(BM_ERR_BADALLOC);

alloc_sz =

.get_alloc_size();

alloc_sz_v = (alloc_sz + (

(

*)-1)) /

(

*);

* arena_mem_ptr = (

*) alloc.alloc_ptr(alloc_sz_v);

ar->

= arena_mem_ptr;

(

.bit_blocks_sz)

arena_mem_ptr +=

.bit_blocks_sz *

(

);

arena_mem_ptr +=

.top_block_size *

(

*);

(

.ptr_sub_blocks_sz)

arena_mem_ptr +=

.ptr_sub_blocks_sz *

(

*);

(

.gap_blocks_sz)

alloc_sz = ar->st_.get_alloc_size();

alloc_sz_v = (alloc_sz + (

(

*)-1)) /

(

*);

alloc.free_ptr(ar->a_ptr_, alloc_sz_v);

(

= 0;

< top_size; ++

)

*

* blk_blk_arg = blk_root_arg[

];

blk_blk_arg = blk_root_arg[

];

blk_root[

] = t_blk_blk;

t_blk_blk[j] = blk_p;

t_gap_block +=

;

t_blk_blk[j] = t_block;

(need_top_blocks < arg_top_blocks)

arg_top_blocks = unsigned(need_top_blocks);

i_from, j_from, i_to, j_to;

(i_to >= arg_top_blocks-1)

i_to = arg_top_blocks-1;

(

= i_from;

<= i_to; ++

)

j = (

== i_from) ? j_from : 0;

blk_root[

] = blk_blk_arg;

j = (

== i_from) ? j_from : 0;

blk = blk_blk[j]; blk_arg = blk_blk_arg[j];

blk =

.alloc_bit_block();

}

(j < j_limit);

<

BlocksManager>

.get_allocator().free_bit_block(

, 3);

(

.get_allocator().alloc_bit_block(3));

<

POOL,

PCLASS>

obj.set_allocator_pool(&pool);

->set_allocator_pool(0);

(!obj.get_allocator_pool())

->set_allocator_pool(&pool);

static void * Alloc(size_t size)

#define IS_FULL_BLOCK(addr)

#define IS_VALID_ADDR(addr)

#define BMPTR_SETBIT0(ptr)

#define BMSET_PTRGAP(ptr)

#define BMPTR_CLEARBIT0(ptr)

#define FULL_BLOCK_FAKE_ADDR

#define FULL_SUB_BLOCK_REAL_ADDR

#define FULL_BLOCK_REAL_ADDR

void assign_if_not_set(POOL &pool, PCLASS &obj) BMNOEXCEPT

check if vector has no assigned allocator and set one

PCLASS * optr_

garded object

void operator=(const alloc_pool_guard &)=delete

alloc_pool_guard(const alloc_pool_guard &)=delete

~alloc_pool_guard() BMNOEXCEPT

alloc_pool_guard() BMNOEXCEPT

alloc_pool_guard(POOL &pool, PCLASS &obj) BMNOEXCEPT

bm::word_t * get() BMNOEXCEPT

bit_block_guard & operator=(const bit_block_guard &)

bit_block_guard(const bit_block_guard &)

bit_block_guard(BlocksManager &bman, bm::word_t *blk=0) BMNOEXCEPT

void attach(bm::word_t *blk) BMNOEXCEPT

Functor detects if any bit set.

block_any_func(const blocks_manager &bm) BMNOEXCEPT

Bitcounting functor filling the block counts array.

void operator()(const bm::word_t *block, id_type idx) BMNOEXCEPT

void on_non_empty_top(unsigned) BMNOEXCEPT

id_type last_block() const BMNOEXCEPT

block_count_arr_func(const blocks_manager &bm, unsigned *arr) BMNOEXCEPT

Base class for bitcounting functors.

bm::id_t block_count(const bm::word_t *block) const BMNOEXCEPT

block_count_base(const blocks_manager &bm) BMNOEXCEPT

bit value change counting functor

block_count_change_func(const blocks_manager &bm) BMNOEXCEPT

id_type count() const BMNOEXCEPT

void operator()(const bm::word_t *block, block_idx_type idx) BMNOEXCEPT

bm::id_t prev_block_border_bit_

block_idx_type block_count(const bm::word_t *block, block_idx_type idx) BMNOEXCEPT

id_type count() const BMNOEXCEPT

void operator()(const bm::word_t *block) BMNOEXCEPT

void add_full(id_type c) BMNOEXCEPT

block_count_func(const blocks_manager &bm) BMNOEXCEPT

Fill block with all-one bits functor.

void operator()(bm::word_t *block, block_idx_type idx)

block_one_func(blocks_manager &bm) BMNOEXCEPT

Base functor class connected for "constant" functors.

void on_empty_block(block_idx_type) BMNOEXCEPT

bm_func_base_const(const blocks_manager &bman) BMNOEXCEPT

bm_func_base_const & operator=(const bm_func_base_const &) BMNOEXCEPT

bm_func_base_const(const bm_func_base_const &) BMNOEXCEPT

void on_empty_top(unsigned) BMNOEXCEPT

const blocks_manager & bm_

Base functor class (block visitor)

void on_empty_top(unsigned) BMNOEXCEPT

bm_func_base(blocks_manager &bman) BMNOEXCEPT

bm_func_base(const bm_func_base &)

bm_func_base & operator=(const bm_func_base &)

void on_empty_block(block_idx_type) BMNOEXCEPT

const gap_word_t * glevel_len_

void on_non_empty_top(unsigned)

gap_level_func(blocks_manager &bm, const gap_word_t *glevel_len) BMNOEXCEPT

void operator()(bm::word_t *block, block_idx_type idx)

bitvector blocks manager Embedded class managing bit-blocks on very low level. Includes number of fun...

unsigned top_block_size_

Size of the top level block array in blocks_ tree.

void set_glen(const gap_word_t *glevel_len) BMNOEXCEPT

void zero_block(unsigned i, unsigned j) BMNOEXCEPT

Free block, make it zero pointer in the tree.

void set_all_zero(block_idx_type nb, block_idx_type nb_to) BMNOEXCEPT

set all-Zero block pointers for [start..end]

bm::word_t *** top_blocks_

Tree of blocks.

arena * arena_

memory arena pointer

void assign_gap(unsigned i, unsigned j, const bm::gap_word_t *res, unsigned res_len, bm::word_t *blk, gap_word_t *tmp_buf)

Attach the result of a GAP logical operation.

bm::word_t * get_block_ptr(unsigned i, unsigned j) BMNOEXCEPT

Finds block in 2-level blocks array (unsinitized)

void set_block_all_set(block_idx_type nb)

bm::word_t * check_allocate_tempblock()

unsigned find_max_top_blocks() const BMNOEXCEPT

calculate max top blocks size whithout NULL-tail

bm::word_t * deoptimize_block(block_idx_type nb)

Make sure block turns into true bit-block if it is GAP or a full block.

gap_word_t glevel_len_[bm::gap_levels]

vector defines gap block lengths for different levels

void return_tempblock(bm::word_t *block) BMNOEXCEPT

void set_all_set(block_idx_type nb, block_idx_type nb_to)

set all-set block pointers for [start..end]

const bm::word_t *const * get_topblock(unsigned i) const BMNOEXCEPT

Function returns top-level block in 2-level blocks array.

id_type max_bits_

maximum addresable bits

void validate_top_full(unsigned i) BMNOEXCEPT

void shrink_top_blocks()

shrink unused top blocks array (via reallocation)

allocator_type get_allocator() const BMNOEXCEPT

Returns allocator.

blocks_manager(const gap_word_t *glevel_len, id_type max_bits, const Alloc &alloc=Alloc())

void copy_to_arena(arena *ar) const BMNOEXCEPT

Copy blocks into arena allocated memory.

void init_tree(unsigned top_size)

allocate first level of descr. of blocks

bm::word_t * alloc_bit_block(block_idx_type nb)

Create(allocate) bit block.

void destroy_arena() BMNOEXCEPT

free all arena memory

bool is_subblock_null(unsigned nsub) const BMNOEXCEPT

Returns true if second level block pointer is 0.

void move_from(blocks_manager &bm) BMNOEXCEPT

implementation of moving semantics

void set_block_all_set_ptr(unsigned i, unsigned j)

Places new block into blocks table.

static void alloc_arena(arena *ar, const bm::bv_arena_statistics &st, allocator_type &alloc)

Allocate arena (content memory) based on arena statistics.

blocks_manager(blocks_manager &&blockman) BMNOEXCEPT

bm::gap_word_t * extend_gap_block(block_idx_type nb, gap_word_t *blk)

Extends GAP block to the next level or converts it to bit block.

void assign_gap_check(unsigned i, unsigned j, const bm::gap_word_t *res, unsigned res_len, bm::word_t *blk, gap_word_t *tmp_buf)

Attach the result of a GAP logical operation but check if it is all 000.

bm::word_t ** check_alloc_top_subblock(unsigned nblk_blk)

Allocate top sub-block if not allocated.

block_idx_type find_next_nz_block(block_idx_type nb, bool deep_scan=true) const BMNOEXCEPT

Find the next non-zero block starting from nb.

bm::word_t * temp_block_

Temp block.

bm::word_t *** top_blocks_root() const BMNOEXCEPT

Returns root block in the tree.

void deinit_tree() BMNOEXCEPT

const bm::word_t * get_block(block_idx_type nb, int *no_more_blocks) const BMNOEXCEPT

Returns current capacity (bits)

unsigned top_block_size() const BMNOEXCEPT

Returns size of the top block array in the tree.

void destroy_tree() BMNOEXCEPT

destroy tree, free memory in all blocks and control structures Note: pointers are NOT assigned to zer...

void free_temp_block() BMNOEXCEPT

bm::word_t * copy_bit_block(block_idx_type nb, const bm::word_t *block_src, int is_src_gap)

Create bit block as a copy of source block (bit or gap).

size_t calc_serialization_null_full() const BMNOEXCEPT

Calculate approximate memory needed to serialize big runs of 0000s and 111s (as blocks)

void free_top_subblock(unsigned nblk_blk) BMNOEXCEPT

bm::word_t * check_allocate_block(block_idx_type nb, int initial_block_type)

Function checks if block is not yet allocated, allocates and returns.

bm::word_t ** alloc_top_subblock(unsigned i, bm::word_t *addr)

Allocate subblock and fill based on.

const bm::word_t * get_block_ptr(unsigned i, unsigned j) const BMNOEXCEPT

Finds block in 2-level blocks array (unsinitized)

bm::word_t * set_gap_block(block_idx_type nb, const gap_word_t *gap_block_src, int level)

Allocate an place new GAP block (copy of provided block)

unsigned glen(unsigned level) const BMNOEXCEPT

Returns GAP level length for specified level.

void assign_gap(block_idx_type nb, const bm::gap_word_t *res, unsigned res_len, bm::word_t *blk, gap_word_t *tmp_buf)

Attach the result of a GAP logical operation.

void clone_gap_block(unsigned i, unsigned j, const bm::gap_word_t *gap_block, unsigned len)

Clone static known block, assign to i-j position.

allocator_type alloc_

allocator

void init_tree()

allocate first level of descr. of blocks

allocator_type & get_allocator() BMNOEXCEPT

Returns reference on the allocator.

bool is_init() const BMNOEXCEPT

if tree of blocks already up

void validate_top_zero(unsigned i) BMNOEXCEPT

void swap(blocks_manager &bm) BMNOEXCEPT

Swaps content.

void opt_copy_bit_block(unsigned i, unsigned j, const bm::word_t *src_block, int opt_mode, bm::word_t *tmp_block)

Optimize and copy bit-block.

bm::word_t *** top_blocks_root() BMNOEXCEPT

void deallocate_top_subblock(unsigned nblk_blk) BMNOEXCEPT

void optimize_gap_convert_bit_block(unsigned i, unsigned j, bm::word_t *block, unsigned threashold)

const bm::word_t * get_block(unsigned i, unsigned j) const BMNOEXCEPT

Finds block in 2-level blocks array.

void copy_to_arena(const blocks_manager &bman)

calculate arena statistics, calculate and copy all blocks there

void set_block_all_set_no_check(unsigned i, unsigned j)

bm::word_t * copy_block(block_idx_type idx, const blocks_manager &bm_src)

Copy block from another vector.

void optimize_bit_block_nocheck(unsigned i, unsigned j)

Full Optimize bit-block at i-j position (no checks)

bm::word_t * convert_gap2bitset(unsigned i, unsigned j, const gap_word_t *gap_block=0, unsigned len=0)

Converts block from type gap to conventional bitset block.

bm::word_t * check_allocate_block(block_idx_type nb, unsigned content_flag, int initial_block_type, int *actual_block_type, bool allow_null_ret=true)

Function checks if block is not yet allocated, allocates it and sets to all-zero or all-one bits.

void free_ptr(bm::word_t **ptr) BMNOEXCEPT

BMFORCEINLINE void set_block_ptr(unsigned i, unsigned j, bm::word_t *block) BMNOEXCEPT

Places new block into blocks table.

void operator=(const blocks_manager &)

void copy(const blocks_manager &blockman, block_idx_type block_from=0, block_idx_type block_to=bm::set_total_blocks)

const gap_word_t * glen() const BMNOEXCEPT

Returns current GAP level vector.

unsigned compute_top_block_size(id_type bits_to_store) const BMNOEXCEPT

Compute size of the block array needed to store bits.

unsigned find_real_top_blocks() const BMNOEXCEPT

calculate top blocks which are not NULL and not FULL

void zero_gap_block_ptr(unsigned i, unsigned j) BMNOEXCEPT

Free block, make it zero pointer in the tree.

blocks_manager(const blocks_manager &blockman)

void zero_block(block_idx_type nb) BMNOEXCEPT

Free block, make it zero pointer in the tree.

void set_block_all_set(unsigned i, unsigned j)

bm::word_t * deoptimize_block_no_check(bm::word_t *block, unsigned i, unsigned j)

bm::word_t * deoptimize_block(unsigned i, unsigned j, bool alloc)

deoptimize block and return bit-block ptr can return NULL if block does not exists or allocate (if re...

bm::word_t * make_bit_block(block_idx_type nb)

Create all-zeros bit block.

bm::gap_word_t * allocate_gap_block(unsigned level, const gap_word_t *src=0, const gap_word_t *glevel_len=0)

bool is_sparse_sblock(unsigned i, unsigned sparse_cut_off, bm::bv_sub_survey &sub_stat) const BMNOEXCEPT

Bit count all blocks to determine if it is very sparse.

static void free_arena(arena *ar, allocator_type &alloc) BMNOEXCEPT

Free arena (content memory) based on arena statistics.

void optimize_bit_block(unsigned i, unsigned j, int opt_mode)

Optimize bit-block at i-j position.

bm::word_t * borrow_tempblock()

void optimize_block(unsigned i, unsigned j, bm::word_t *block, bm::word_t *temp_block, int opt_mode, bv_statistics *bv_stat)

void calc_arena_stat(bm::bv_arena_statistics *st) const BMNOEXCEPT

Calculates bitvector arena statistics.

bm::word_t * set_block(unsigned i, unsigned j, bm::word_t *block, bool gap)

Places new block into descriptors table, returns old block's address.

~blocks_manager() BMNOEXCEPT

bm::word_t ** alloc_top_subblock(unsigned nblk_blk)

unsigned reserve_top_blocks(unsigned top_blocks)

Make sure blocks manager has enough blocks capacity.

bm::word_t * set_block(block_idx_type nb, bm::word_t *block)

Places new block into descriptors table, returns old block's address.

bm::word_t * convert_gap2bitset(block_idx_type nb, const gap_word_t *gap_block=0)

Converts block from type gap to conventional bitset block.

void optimize_tree(bm::word_t *temp_block, int opt_mode, bv_statistics *bv_stat)

void set_block_ptr(block_idx_type nb, bm::word_t *block)

Places new block into blocks table.

bm::word_t * clone_gap_block(const bm::gap_word_t *gap_block, bool &gap_res)

Clone GAP block from another GAP It can mutate into a bit-block if does not fit.

void set_all_zero(bool) BMNOEXCEPT

Fills all blocks with 0.

void copy_bit_block(unsigned i, unsigned j, const bm::word_t *src_block)

Allocate and copy block.

static bm::id_t block_bitcount(const bm::word_t *block) BMNOEXCEPT

Count number of bits ON in the block.

bm::word_t * clone_assign_block(unsigned i, unsigned j, const bm::word_t *src_block, bool invert=false)

Clone block, assign to i-j position.

void reserve(id_type max_bits)

reserve capacity for specified number of bits

void stat_correction(bv_statistics *stat) noexcept

void set_block_gap_ptr(block_idx_type nb, gap_word_t *gap_blk)

Mark pointer as GAP and assign to the blocks tree.

bm::word_t * set_block(block_idx_type nb, bm::word_t *block, bool gap)

Places new block into descriptors table, returns old block's address.

Bitvector Bit-vector container with runtime compression of bits.

static vector< string > arr

bool avx2_test_all_zero_wave(const void *ptr)

check if wave of pointers is all NULL

bool sse42_test_all_zero_wave(const void *ptr) noexcept

check if wave of pointers is all NULL

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

Bitcount for bit block.

void bit_invert(T *start) noexcept

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

Bitblock copy/stream operation.

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.

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

Bitblock copy operation.

unsigned bit_block_calc_change(const bm::word_t *block) noexcept

bool gap_is_all_one(const bm::gap_word_t *buf) noexcept

Checks if GAP block is all-one.

void gap_invert(T *buf) noexcept

Inverts all bits in the GAP buffer.

void set_gap_level(T *buf, int level) noexcept

Sets GAP block capacity level.

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.

bool gap_is_all_zero(const bm::gap_word_t *buf) noexcept

Checks if GAP block is all-zero.

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

GAP block to bitblock conversion.

unsigned gap_bit_count_unr(const T *buf) noexcept

Calculates number of bits ON in GAP buffer. Loop unrolled version.

unsigned gap_capacity(const T *buf, const T *glevel_len) noexcept

Returs GAP block capacity.

T gap_level(const T *buf) noexcept

Returs GAP blocks capacity level.

int gap_calc_level(unsigned len, const T *glevel_len) noexcept

Calculates GAP block capacity level.

bm::gap_word_t gap_length(const bm::gap_word_t *buf) noexcept

Returs GAP block length.

void gap_set_all(T *buf, unsigned set_max, unsigned value) noexcept

Sets all bits to 0 or 1 (GAP)

const unsigned set_array_mask

const unsigned gap_max_level

void xor_swap(W &x, W &y) noexcept

XOR swap two variables.

bool find_not_null_ptr(const bm::word_t *const *const *arr, N start, N size, N *pos) noexcept

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.

bool check_block_zero(const bm::word_t *blk, bool deep_scan) noexcept

Checks all conditions and returns true if block consists of only 0 bits.

const unsigned set_total_blocks

void bit_block_change_bc(const bm::word_t *block, unsigned *gc, unsigned *bc) noexcept

const unsigned gap_levels

const unsigned set_block_size

unsigned bit_to_gap(gap_word_t *dest, const unsigned *block, unsigned dest_len) noexcept

Convert bit block to GAP representation.

unsigned long long int id64_t

const unsigned gap_equiv_len

const unsigned gap_max_buff_len

const unsigned set_array_shift

unsigned short gap_word_t

const unsigned gap_max_bits

const unsigned set_top_array_size

void for_each_block(T ***root, unsigned size1, F &f, BLOCK_IDX start)

bool is_aligned(T *p) noexcept

Check pointer alignment.

const unsigned bits_in_block

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

Arena allocation memory guard.

arena_guard(arena *ar, blocks_manager &bman) noexcept

Allocation arena for ReadOnly vectors.

void reset()

Set all arena fields to zero.

bm::bv_arena_statistics st_

statistics and sizes

bm::word_t ** blk_blks_

PTR sub-blocks area.

void * a_ptr_

main allocated pointer

bm::gap_word_t * gap_blocks_

GAP blocks area.

bm::word_t *** top_blocks_

top descriptor

bm::word_t * blocks_

bit-blocks area

Structure with statistical information about memory allocation for arena based vectors.

size_t bit_blocks_sz

Total size of bit blocks.

size_t gap_blocks_sz

Total size of gap blocks.

size_t ptr_sub_blocks_sz

Total size of sub-blocks ptrs.

unsigned top_block_size

size of top descriptor

void reset() noexcept

Reset statisctics.

Structure with statistical information about memory allocation footprint, serialization projection,...

void add_gap_block(unsigned capacity, unsigned length, unsigned level) noexcept

count gap block

size_t ptr_sub_blocks

Number of sub-blocks.

void add_bit_block() noexcept

cound bit block

size_t max_serialize_mem

estimated maximum memory for serialization

Basic stats on second level group of blocks.

Default GAP lengths table.

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