void
hash_create_mutexes(
/*================*/
hash_table_t* table, /* in: hash table */
ulint n_mutexes, /* in: number of mutexes, must be a
power of 2 */
ulint sync_level) /* in: latching order level of the
mutexes: used in the debug version */
{
ulint i;
ut_a(n_mutexes == ut_2_power_up(n_mutexes));
table->mutexes = mem_alloc(n_mutexes * sizeof(mutex_t));
for (i = 0; i < n_mutexes; i++) {
mutex_create(table->mutexes + i);
mutex_set_level(table->mutexes + i, sync_level);
}
table->n_mutexes = n_mutexes;
}
void
mem_area_free(
/*==========*/
void* ptr, /* in, own: pointer to allocated memory
buffer */
mem_pool_t* pool) /* in: memory pool */
{
mem_area_t* area;
mem_area_t* buddy;
void* new_ptr;
ulint size;
ulint n;
/* It may be that the area was really allocated from the OS with
regular malloc: check if ptr points within our memory pool */
if ((byte*)ptr < pool->buf || (byte*)ptr >= pool->buf + pool->size) {
ut_free(ptr);
return;
}
area = (mem_area_t*) (((byte*)ptr) - MEM_AREA_EXTRA_SIZE);
if (mem_area_get_free(area)) {
fprintf(stderr,
"InnoDB: Error: Freeing element to mem pool"
" free list though the\n"
"InnoDB: element is marked free!\n");
mem_analyze_corruption(area);
ut_error;
}
size = mem_area_get_size(area);
UNIV_MEM_FREE(ptr, size - MEM_AREA_EXTRA_SIZE);
if (size == 0) {
fprintf(stderr,
"InnoDB: Error: Mem area size is 0. Possibly a"
" memory overrun of the\n"
"InnoDB: previous allocated area!\n");
mem_analyze_corruption(area);
ut_error;
}
#ifdef UNIV_LIGHT_MEM_DEBUG
if (((byte*)area) + size < pool->buf + pool->size) {
ulint next_size;
next_size = mem_area_get_size(
(mem_area_t*)(((byte*)area) + size));
if (ut_2_power_up(next_size) != next_size) {
fprintf(stderr,
"InnoDB: Error: Memory area size %lu,"
" next area size %lu not a power of 2!\n"
"InnoDB: Possibly a memory overrun of"
" the buffer being freed here.\n",
(ulong) size, (ulong) next_size);
mem_analyze_corruption(area);
ut_error;
}
}
#endif
buddy = mem_area_get_buddy(area, size, pool);
n = ut_2_log(size);
mutex_enter(&(pool->mutex));
mem_n_threads_inside++;
ut_a(mem_n_threads_inside == 1);
if (buddy && mem_area_get_free(buddy)
&& (size == mem_area_get_size(buddy))) {
/* The buddy is in a free list */
if ((byte*)buddy < (byte*)area) {
new_ptr = ((byte*)buddy) + MEM_AREA_EXTRA_SIZE;
mem_area_set_size(buddy, 2 * size);
mem_area_set_free(buddy, FALSE);
} else {
new_ptr = ptr;
mem_area_set_size(area, 2 * size);
}
/* Remove the buddy from its free list and merge it to area */
UT_LIST_REMOVE(free_list, pool->free_list[n], buddy);
pool->reserved += ut_2_exp(n);
mem_n_threads_inside--;
mutex_exit(&(pool->mutex));
mem_area_free(new_ptr, pool);
return;
} else {
UT_LIST_ADD_FIRST(free_list, pool->free_list[n], area);
mem_area_set_free(area, TRUE);
ut_ad(pool->reserved >= size);
pool->reserved -= size;
}
mem_n_threads_inside--;
mutex_exit(&(pool->mutex));
ut_ad(mem_pool_validate(pool));
}
