/*
* palloc_reservation_create -- creates a volatile reservation of a
* memory block.
*
* The first step in the allocation of a new block is reserving it in
* the transient heap - which is represented by the bucket abstraction.
*
* To provide optimal scaling for multi-threaded applications and reduce
* fragmentation the appropriate bucket is chosen depending on the
* current thread context and to which allocation class the requested
* size falls into.
*
* Once the bucket is selected, just enough memory is reserved for the
* requested size. The underlying block allocation algorithm
* (best-fit, next-fit, ...) varies depending on the bucket container.
*/
static int
palloc_reservation_create(struct palloc_heap *heap, size_t size,
palloc_constr constructor, void *arg,
uint64_t extra_field, uint16_t object_flags, uint16_t class_id,
struct pobj_action_internal *out)
{
int err = 0;
struct memory_block *new_block = &out->m;
ASSERT(class_id < UINT8_MAX);
struct alloc_class *c = class_id == 0 ?
heap_get_best_class(heap, size) :
alloc_class_by_id(heap_alloc_classes(heap),
(uint8_t)class_id);
if (c == NULL) {
ERR("no allocation class for size %lu bytes", size);
errno = EINVAL;
return -1;
}
/*
* The caller provided size in bytes, but buckets operate in
* 'size indexes' which are multiples of the block size in the
* bucket.
*
* For example, to allocate 500 bytes from a bucket that
* provides 256 byte blocks two memory 'units' are required.
*/
ssize_t size_idx = alloc_class_calc_size_idx(c, size);
if (size_idx < 0) {
ERR("allocation class not suitable for size %lu bytes",
size);
errno = EINVAL;
return -1;
}
ASSERT(size_idx <= UINT32_MAX);
new_block->size_idx = (uint32_t)size_idx;
struct bucket *b = heap_bucket_acquire(heap, c);
err = heap_get_bestfit_block(heap, b, new_block);
if (err != 0)
goto out;
if (alloc_prep_block(heap, new_block, constructor, arg,
extra_field, object_flags, &out->offset) != 0) {
/*
* Constructor returned non-zero value which means
* the memory block reservation has to be rolled back.
*/
if (new_block->type == MEMORY_BLOCK_HUGE) {
bucket_insert_block(b, new_block);
}
err = ECANCELED;
goto out;
}
/*
* Each as of yet unfulfilled reservation needs to be tracked in the
* runtime state.
* The memory block cannot be put back into the global state unless
* there are no active reservations.
*/
if ((out->resvp = bucket_current_resvp(b)) != NULL)
util_fetch_and_add64(out->resvp, 1);
out->lock = new_block->m_ops->get_lock(new_block);
out->new_state = MEMBLOCK_ALLOCATED;
out:
heap_bucket_release(heap, b);
if (err == 0)
return 0;
errno = err;
return -1;
}
/*
* mock_open_pool -- (internal) simulate pool opening
*/
static void
mock_open_pool(PMEMobjpool *pop)
{
util_fetch_and_add64(&pop->run_id, 2);
}
