RetroSearch Browse

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

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

NCBI C++ ToolKit: src/connect/ncbi_heapmgr.c Source File

120 #define NCBI_USE_ERRCODE_X Connect_HeapMgr 123 #if defined(NCBI_OS_MSWIN) && defined(_WIN64) 125 # pragma warning (disable : 4311) 131 #define abs(a) ((a) < 0 ? (a) : -(a)) 134 # if NCBI_PLATFORM_BITS == 64 136 # define HEAP_PACKED __attribute__((packed)) 137 # elif defined(_CRAYC) 140 # error "Don't know how to pack on this 64-bit platform" 175 #define _HEAP_ALIGN_EX(a, b) ((((unsigned long)(a) + ((b) - 1)) / (b)) * (b)) 176 #define _HEAP_ALIGN_2(a, b) (( (unsigned long)(a) + ((b) - 1)) \ 177 & (unsigned long)(~((b) - 1))) 178 #define _HEAP_SIZESHIFT 4 179 #define HEAP_BLOCKS(s) ((s) >> _HEAP_SIZESHIFT) 180 #define HEAP_EXTENT(b) ((b) << _HEAP_SIZESHIFT) 181 #define HEAP_ALIGN(a) _HEAP_ALIGN_2(a, HEAP_EXTENT(1)) 182 #define HEAP_MASK (~(HEAP_EXTENT(1) - 1)) 183 #define HEAP_PREV_BIT 8 184 #define HEAP_NEXT_BIT 4 187 #define HEAP_SIZE(s) ((s) & (unsigned long) HEAP_MASK) 188 #define HEAP_FLAG(s) ((s) & (unsigned long)(~HEAP_MASK)) 189 #define HEAP_NEXT(b) ((SHEAP_HeapBlock*) \ 190 ((char*)(b) + (b)->head.size)) 191 #define HEAP_PREV(b) ((SHEAP_HeapBlock*) \ 192 ((char*)(b) - HEAP_SIZE((b)->head.flag))) 193 #define HEAP_INDEX(b, base) ((TNCBI_Size)((b) - (base))) 194 #define HEAP_ISLAST(b) ((b)->head.flag & HEAP_LAST) 195 #define HEAP_ISUSED(b) ((b)->head.flag & HEAP_USED) 197 #define HEAP_CHECK(heap) \ 198 assert(!heap->base == !heap->size); \ 199 assert(heap->used <= heap->size); \ 200 assert(heap->free <= heap->size); \ 201 assert(heap->last <= heap->size); \ 202 assert(heap->used == heap->size || heap->free < heap->size) 204 #if ~HEAP_MASK != (HEAP_PREV_BIT | HEAP_NEXT_BIT | HEAP_LAST | HEAP_USED) \ 205 || HEAP_BLOCKS(~HEAP_MASK) != 0 206 # error "HEAP_MASK is invalid!" 226 static int

x_Parity(

unsigned int

v)

231

v = (v & 0x11111111U) * 0x11111111U;

232 return

(v >> 28) & 1;

238 return

(0x6996 >> v) & 1;

271 if

(!base != !

)

275

(

"Heap Create: Storage too small:" 276 " provided %u, required %u+"

,

289 heap

->auxarg =

->resize ? auxarg : 0;

297

(

"Heap Create: Unaligned base (0x%08lX)"

,

321

(

"Heap Attach: Unaligned base (0x%08lX)"

, (

long

) base));

328 heap

->serial = serial;

331

(

"Heap Attach: Heap size truncation (%u->%u)" 332 " can result in missing data"

,

343 if

(base && (!maxsize || maxsize >

sizeof

(

))) {

351

(

"Heap Attach: Heap corrupt @%u (0x%08X, %u)"

,

353 b

->head.flag,

b

->head.size));

357 size

+=

b

->head.size;

362

(

"Heap Attach: Runaway heap @%u (0x%08X, %u)" 363 " size=%u vs. maxsize=%u"

,

365 b

->head.flag,

b

->head.size,

408 if

(!hint && need < (e->

.

>> 1)) {

412 if

(b < heap->base ||

->base +

->size <=

b

) {

419 if

(need <= b->

.size) {

428 f

=

b

->head.size < need ? 0 :

b

;

429 for

(

b

=

->base +

b

->prevfree; ;

b

=

->base +

b

->prevfree) {

431 if

(b < heap->base ||

->base +

->size <=

b

) {

438 if

(

b

== e ||

b

->head.size < need)

447 char

_id[32],

[80];

449

sprintf(

,

" (0x%08X, %u)"

,

b

->head.flag,

b

->head.size);

453

(

"Heap Find%s: Heap corrupt @%u/%u%s"

,

469 f

->prevfree =

;

470 f

->nextfree =

;

477 if

(

b

->head.size <

f

->head.size) {

480 f

->nextfree =

b

->nextfree;

482 heap

->base[

b

->nextfree].prevfree =

;

483 b

->nextfree =

;

492 f

->prevfree =

b

->prevfree;

493 heap

->base[

b

->prevfree].nextfree =

;

494 b

->prevfree =

;

499 #if defined(_DEBUG) && !defined(NDEBUG) 500 # define s_HEAP_Unlink(b) { b->prevfree = b->nextfree = ~((TNCBI_Size) 0); } 502 # define s_HEAP_Unlink(b) 519 unsigned int last

= 0;

529 assert

(!need ||

b

->head.size < need);

531 free

+=

b

->head.size;

534 assert

(

f

!= p && (u || (!

n

&& !need)));

537 heap

->base[

b

->prevfree].nextfree =

b

->nextfree;

538 heap

->base[

b

->nextfree].prevfree =

b

->prevfree;

540 heap

->free =

b

->prevfree;

545 heap

->base[

f

->prevfree].nextfree =

f

->nextfree;

546 heap

->base[

f

->nextfree].prevfree =

f

->prevfree;

547

}

else if

(

->free !=

f

->prevfree) {

548 heap

->base[

f

->prevfree].nextfree =

f

->nextfree;

549 heap

->base[

f

->nextfree].prevfree =

f

->prevfree;

550 heap

->free =

f

->prevfree;

552 assert

(

f

->prevfree ==

f

->nextfree);

564 f

->head.flag =

;

565 f

->head.size =

;

572 if

(need && need <=

)

588 f

->head.flag = (p ? p->head.size : 0) |

;

614 f

->head.size -=

;

617 b

->head.size =

;

622 b

->head.size =

;

624 f

->head.flag =

b

->head.flag;

625 f

->head.size = save -

;

636

memset((

char

*)

b

+ need, 0,

);

670 n

=

->base +

f

->nextfree;

673 assert

(

f

->prevfree ==

f

->nextfree);

677 n

->prevfree =

f

->prevfree;

678 heap

->base[

f

->prevfree].nextfree =

f

->nextfree;

680 heap

->free =

f

->prevfree;

704

(

"Heap Alloc%s: Unaligned base (0x%08lX)"

,

709

dsize = hsize - dsize;

710

memset(base +

->size, 0, dsize);

711 f

= base +

->last;

715 f

->head.size = hsize;

725 f

= base +

->size;

727 f

->head.size = dsize;

731 if

(

f

!= base +

->free) {

734

}

else if

(

->free !=

f

->prevfree) {

737 heap

->free =

f

->prevfree;

739 assert

(

f

->prevfree ==

f

->nextfree);

742 f

->head.size += dsize;

768 assert

((!p ||

->base <= p) && n <= heap->base +

->size);

771 b

->head.flag =

;

775 b

->head.size +=

n

->head.size;

782 if

(

->free ==

n

->prevfree) {

784 assert

(

n

->prevfree ==

n

->nextfree);

786 b

->prevfree =

->free;

787 b

->nextfree =

->free;

790 heap

->free =

n

->prevfree;

792 heap

->base[

n

->nextfree].prevfree =

n

->prevfree;

793 heap

->base[

n

->prevfree].nextfree =

n

->nextfree;

804 if

(p ==

->base +

->free) {

847

(

"Heap Free%s: Heap corrupt @%u/%u (0x%08X, %u)"

,

849 heap

->size,

b

->head.flag,

b

->head.size));

855

(

"Heap Free%s: Freeing free block @%u"

,

910 if

(!p || p < heap->base || e <= p)

915

(

"Heap Free%s: Lame hint%s for block @%u"

,

922

(

"Heap Free%s: Freeing free block @%u"

,

942 if

(!

->chunk) {

958 if

(!

b

||

b

->head.size <

->chunk) {

961

}

else if

(!(

=

b

->head.size %

->chunk)) {

970 if

(

->resize) {

979

(

"Heap Trim%s: Unaligned base (0x%08lX)"

,

997 b

->head.size =

;

1006

(

"Heap Trim%s: Heap not trimmable"

,

(_id,

)));

1023 if

(p < heap->base || e <= p

1034 if

(e <=

b

||

b

<= p

1038 if

(

b

!= e || (

b

&& !p)) {

1043

(

"Heap Walk%s: No last block @%u"

,

(_id,

),

1050

(

n

< e || (

->chunk

&& b < heap->base +

->last))) {

1051 if

(

->chunk

) {

1054

?

"expected"

:

"invalid"

,

->last);

1064 if

(

->chunk

) {

1069 for

(

i

= 0;

i

<

->size; ++

i

) {

1083 if

(

self

|| (c <=

b

&&

b

<= s)){

1084 if

(

|| s <

n

) {

1099 if

(s ==

->base +

->free)

1115 if

(

->size <=

b

->prevfree ||

1116 heap

->size <=

b

->nextfree

1120

}

else if

(

b

->prevfree !=

b

->nextfree ||

1121 b

!=

->base +

b

->nextfree) {

1122 for

(

i

= 0;

i

<

->size; ++

i

) {

1124 b

=

->base +

b

->nextfree;

1126 heap

->size <=

b

->nextfree ||

1127

s !=

->base +

b

->prevfree) {

1135 b

=

->base +

b

->nextfree;

1137 if

(!c || !

b

||

b

!= c) {

1139

sprintf(

,

" @%u/%u (%u, <-%u, %u->)"

,

1146 b

&& c ?

"broken"

:

"corrupt"

,

));

1155 for

(

i

= 0; c < e &&

i

<

->size; ++

i

) {

1160

(

"Heap Walk%s: Used block @%u within" 1169 if

(c ==

->base +

->free)

1189

(

"Heap Walk%s: Adjacent free blocks" 1269 char

* base = (

char

*)

+

sizeof

(*

);

1283 copy

->serial = serial;

1297 if

(

->refcnt) {

1301 return heap

->refcnt;

1310 if

(

->refcnt && --

->refcnt)

1311 return heap

->refcnt;

1312

memset(

, 0,

sizeof

(*

));

1325 if

(!

->chunk && !

->refcnt) {

1327

(

"Heap Destroy%s: Heap read-only"

,

(_id,

)));

1328

}

else if

(

->resize

)

1370 size

+=

b

->head.size;

1371 b

=

->base +

b

->prevfree;

1373 #if defined(_DEBUG) && !defined(NDEBUG) 1377

alt_size +=

b

->head.size;

1378 b

=

->base +

b

->nextfree;

1396 return heap

->serial;

static int heap[2 *(256+1+29)+1]

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

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

SHEAP_Block * HEAP_Next(const HEAP heap, const SHEAP_Block *ptr)

void * HEAP_Base(const HEAP heap)

void HEAP_Options(ESwitch fast, ESwitch unused)

SHEAP_Block * HEAP_Alloc(HEAP heap, TNCBI_Size size, int tail)

HEAP HEAP_Copy(const HEAP heap, size_t extra, int serial)

SHEAP_Block * HEAP_Walk(const HEAP heap, const SHEAP_Block *ptr)

HEAP HEAP_Create(void *base, TNCBI_Size size, TNCBI_Size chunk, FHEAP_Resize resize, void *auxarg)

unsigned int HEAP_Destroy(HEAP heap)

void HEAP_Free(HEAP heap, SHEAP_Block *ptr)

int HEAP_Serial(const HEAP heap)

HEAP HEAP_AttachFast(const void *base, TNCBI_Size size, int serial)

HEAP HEAP_Attach(const void *base, TNCBI_Size maxsize, int serial)

void *(* FHEAP_Resize)(void *old_base, TNCBI_Size new_size, void *auxarg)

void HEAP_FreeFast(HEAP heap, SHEAP_Block *ptr, const SHEAP_Block *prev)

unsigned int HEAP_AddRef(HEAP heap)

TNCBI_Size HEAP_Idle(const HEAP heap)

HEAP HEAP_Trim(HEAP heap)

unsigned int HEAP_Detach(HEAP heap)

TNCBI_Size HEAP_Size(const HEAP heap)

TNCBI_Size HEAP_Used(const HEAP heap)

enum ENcbiSwitch ESwitch

Aux.

unsigned int TNCBI_Size

Fixed-size analogs of size_t and time_t (mainly for IPC)

unsigned int

A callback function used to compare two keys in a database.

static const CS_INT unused

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

void resize(vector< SMethodDef > &container)

static SHEAP_HeapBlock * s_HEAP_Collect(HEAP heap, TNCBI_Size need)

static SHEAP_HeapBlock * x_HEAP_Walk(const HEAP heap, const SHEAP_Block *ptr)

static SHEAP_HeapBlock * s_HEAP_Walk(const HEAP heap, const SHEAP_Block *ptr)

static SHEAP_Block * s_HEAP_Take(HEAP heap, SHEAP_HeapBlock *b, SHEAP_HeapBlock *n, TNCBI_Size size, TNCBI_Size need, int tail)

#define _HEAP_ALIGN_2(a, b)

#define _HEAP_ALIGN_EX(a, b)

#define HEAP_INDEX(b, base)

static SHEAP_HeapBlock * s_HEAP_Find(HEAP heap, TNCBI_Size need, SHEAP_HeapBlock *hint)

static void s_HEAP_Free(HEAP heap, SHEAP_HeapBlock *p, SHEAP_HeapBlock *b, SHEAP_HeapBlock *n)

static const char * s_HEAP_Id(char *buf, HEAP h)

static void s_HEAP_Link(HEAP heap, SHEAP_HeapBlock *f, SHEAP_HeapBlock *hint)

#define CORE_LOGF_X(subcode, level, fmt_args)

#define CORE_LOG_X(subcode, level, message)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

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

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

voidp calloc(uInt items, uInt size)

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