static void
mm_lock_print_stat(const struct mm_thread *thread,
const struct mm_lock_stat_set *stat_set,
const struct mm_lock_stat *stat)
{
const char *name = mm_thread_getname(thread);
if (stat_set->moreinfo != NULL)
mm_verbose("lock %s (%s), %s, locked %llu, failed %llu",
stat_set->location, stat_set->moreinfo, name,
stat->lock_count, stat->fail_count);
else
mm_verbose("lock %s, %s, locked %llu, failed %llu",
stat_set->location, name,
stat->lock_count, stat->fail_count);
}
static void
mm_pool_prepare_low(struct mm_pool *pool,
const char *pool_name,
const struct mm_arena *arena,
uint32_t item_size)
{
ASSERT(item_size < 0x200);
if (item_size < sizeof(struct mm_slink))
item_size = sizeof(struct mm_slink);
mm_verbose("make the '%s' memory pool with element size %u",
pool_name, item_size);
pool->item_last = 0;
pool->item_size = item_size;
pool->block_capacity = MM_POOL_BLOCK_SIZE / item_size;
pool->block_array_used = 0;
pool->block_array_size = 0;
pool->arena = arena;
pool->block_array = NULL;
pool->block_cur_ptr = NULL;
pool->block_end_ptr = NULL;
mm_stack_prepare(&pool->free_list);
pool->pool_name = mm_global_strdup(pool_name);
}
static void
mm_pool_grow(struct mm_pool *pool)
{
ENTER();
// Check for 32-bit integer overflow.
uint32_t total_capacity = pool->block_capacity * pool->block_array_used;
if (unlikely(total_capacity > (total_capacity + pool->block_capacity)))
mm_fatal(0, "the '%s' memory pool overflow", pool->pool_name);
// If needed grow the block container array.
if (pool->block_array_used == pool->block_array_size) {
if (pool->block_array_size)
pool->block_array_size *= 2;
else
pool->block_array_size = 4;
pool->block_array = mm_arena_realloc(
pool->arena,
pool->block_array,
pool->block_array_size * sizeof(char *));
}
// Allocate a new memory block.
char *block = mm_arena_alloc(pool->arena, MM_POOL_BLOCK_SIZE);
pool->block_array[pool->block_array_used] = block;
pool->block_array_used++;
pool->block_cur_ptr = block;
pool->block_end_ptr = block + pool->block_capacity * pool->item_size;
mm_verbose("grow the '%s' memory pool to %u elements, occupy %lu bytes",
pool->pool_name,
pool->block_capacity * pool->block_array_used,
(unsigned long) MM_POOL_BLOCK_SIZE * pool->block_array_used);
LEAVE();
}
