static struct utspace_split_node *_new_node(allocman_t *alloc) {
int error;
struct utspace_split_node *node;
node = (struct utspace_split_node*) allocman_mspace_alloc(alloc, sizeof(*node), &error);
if (error) {
return NULL;
}
error = allocman_cspace_alloc(alloc, &node->ut);
if (error) {
allocman_mspace_free(alloc, node, sizeof(*node));
return NULL;
}
return node;
}
static struct utspace_split_node *_new_node(allocman_t *alloc) {
int error;
struct utspace_split_node *node;
node = (struct utspace_split_node*) allocman_mspace_alloc(alloc, sizeof(*node), &error);
if (error) {
ZF_LOGV("Failed to allocate node of size %zu", sizeof(*node));
return NULL;
}
error = allocman_cspace_alloc(alloc, &node->ut);
if (error) {
allocman_mspace_free(alloc, node, sizeof(*node));
ZF_LOGV("Failed to allocate slot");
return NULL;
}
return node;
}
static int _refill_watermark(allocman_t *alloc)
{
int found_empty_pool;
int did_allocation;
uint32_t i;
if (alloc->refilling_watermark || !alloc->used_watermark) {
return 0;
}
alloc->refilling_watermark = 1;
/* Run in a loop refilling our resources. We need a loop as refilling
one resource may require another watermark resource to be used. It is up
to the allocators to prove that this process results in a consistent
increase in the watermark pool, and hence will terminate. Need to be
very careful with re-entry in this loop, as our watermark resources
may change anytime we perform an allocation. We try and allocate evenly
across all the resources types since typically we are only refilling
a single object from each resource anyway, so the performance will be
the same, and if we aren't we are boot strapping and I'm not convinced
that all allocations orders are equivalent in this case */
int limit = 0;
do {
found_empty_pool = 0;
did_allocation = 0;
while (alloc->num_freed_slots > 0) {
cspacepath_t slot = alloc->freed_slots[--alloc->num_freed_slots];
allocman_cspace_free(alloc, &slot);
/* a free is like an allocation in that we have made some progress */
did_allocation = 1;
}
while (alloc->num_freed_mspace_chunks > 0) {
struct allocman_freed_mspace_chunk chunk = alloc->freed_mspace_chunks[--alloc->num_freed_mspace_chunks];
allocman_mspace_free(alloc, chunk.ptr, chunk.size);
did_allocation = 1;
}
while (alloc->num_freed_utspace_chunks > 0) {
struct allocman_freed_utspace_chunk chunk = alloc->freed_utspace_chunks[--alloc->num_freed_utspace_chunks];
allocman_utspace_free(alloc, chunk.cookie, chunk.size_bits);
did_allocation = 1;
}
if (alloc->num_cspace_slots < alloc->desired_cspace_slots) {
int error;
found_empty_pool = 1;
cspacepath_t slot;
error = _allocman_cspace_alloc(alloc, &slot, 0);
if (!error) {
alloc->cspace_slots[alloc->num_cspace_slots++] = slot;
did_allocation = 1;
}
}
for (i = 0; i < alloc->num_utspace_chunks; i++) {
if (alloc->utspace_chunk_count[i] < alloc->utspace_chunk[i].count) {
cspacepath_t slot;
uint32_t cookie;
int error;
/* First grab a slot */
found_empty_pool = 1;
error = allocman_cspace_alloc(alloc, &slot);
if (!error) {
/* Now try to allocate */
cookie = _allocman_utspace_alloc(alloc, alloc->utspace_chunk[i].size_bits, alloc->utspace_chunk[i].type, &slot, &error, 0);
if (!error) {
alloc->utspace_chunks[i][alloc->utspace_chunk_count[i]].cookie = cookie;
alloc->utspace_chunks[i][alloc->utspace_chunk_count[i]].slot = slot;
alloc->utspace_chunk_count[i]++;
did_allocation = 1;
} else {
/* Give the slot back */
allocman_cspace_free(alloc, &slot);
}
}
}
}
for (i = 0 ; i < alloc->num_mspace_chunks; i++) {
if (alloc->mspace_chunk_count[i] < alloc->mspace_chunk[i].count) {
void *result;
int error;
found_empty_pool = 1;
result = _allocman_mspace_alloc(alloc, alloc->mspace_chunk[i].size, &error, 0);
if (!error) {
alloc->mspace_chunks[i][alloc->mspace_chunk_count[i]++] = result;
did_allocation = 1;
}
}
}
limit++;
} while (found_empty_pool && did_allocation && limit < 4);
alloc->refilling_watermark = 0;
if (!found_empty_pool) {
alloc->used_watermark = 0;
}
return found_empty_pool;
}
