static union block_hdr *new_block(int minsz, int exact) {
union block_hdr **lastptr = &block_freelist;
union block_hdr *blok = block_freelist;
if (!exact) {
minsz = 1 + ((minsz - 1) / BLOCK_MINFREE);
minsz *= BLOCK_MINFREE;
}
/* Check if we have anything of the requested size on our free list first...
*/
while (blok) {
if (minsz <= blok->h.endp - blok->h.first_avail) {
*lastptr = blok->h.next;
blok->h.next = NULL;
stat_freehit++;
return blok;
} else {
lastptr = &blok->h.next;
blok = blok->h.next;
}
}
/* Nope...damn. Have to malloc() a new one. */
stat_malloc++;
return malloc_block(minsz);
}
void *malloc(size_t size)
{
t_block *b;
b = malloc_block(size);
return (BDATA(b));
}
static union block_hdr *new_block(int min_size)
{
union block_hdr **lastptr = &block_freelist;
union block_hdr *blok = block_freelist;
/* First, see if we have anything of the required size
* on the free list...
*/
while (blok != NULL) {
if (min_size + BLOCK_MINFREE <= blok->h.endp - blok->h.first_avail) {
*lastptr = blok->h.next;
blok->h.next = NULL;
debug_verify_filled(blok->h.first_avail, blok->h.endp,
"Ouch! Someone trounced a block on the free list!\n");
return blok;
}
else {
lastptr = &blok->h.next;
blok = blok->h.next;
}
}
/* Nope. */
min_size += BLOCK_MINFREE;
blok = malloc_block((min_size > BLOCK_MINALLOC) ? min_size : BLOCK_MINALLOC);
return blok;
}
void* seg_pool::malloc_one()
{
pool_block* ba=get_free_block();
if(!ba){
malloc_block();
ba=get_free_block();
if(!ba)
return NULL;
}
void* p=ba->malloc_one();
if(ba->full()){
ba->erase_from_list();
reg_full_block(ba);
}
return p;
}
void *vogl_tracked_malloc(const char *pFile_line, size_t size, size_t *pActual_size)
{
size = (size + sizeof(uint32) - 1U) & ~(sizeof(uint32) - 1U);
if (!size)
size = sizeof(uint32);
if (size > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE)
{
vogl_mem_error("vogl_malloc: size too big", pFile_line);
return NULL;
}
uint8 *p_new = (uint8 *)malloc_block(size, pFile_line);
VOGL_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (VOGL_MIN_ALLOC_ALIGNMENT - 1)) == 0);
if (!p_new)
{
vogl_mem_error("vogl_malloc: out of memory", pFile_line);
return NULL;
}
if (pActual_size)
{
*pActual_size = msize_block(p_new, pFile_line);
if ((size) && (*pActual_size >= static_cast<uint64_t>(size) * 16U))
{
// I've seen this happen with glibc's absolutely terrible debug heap crap, best to let the caller know that shit is going to die
fprintf(stderr, "%s: malloc_usable_size may be misbehaving! Requested %zu bytes, but the usable size is reported as %zu bytes.\n", __FUNCTION__, size, *pActual_size);
}
}
#if VOGL_RAND_FILL_ALLLOCATED_MEMORY
random_fill(p_new, size);
#endif
return p_new;
}
