extern bool coalesce_headers() {
Header* larger, *smaller;
bool merged = false;
int i;
// Only loop to 31 because loop accesses i+1
for (i = 0; i < 31; i++) {
smaller = freelist[i][0];
larger = freelist[i+1][0];
while (larger != NULL) {
while (smaller != NULL) {
// If the blocks are back to back
if (((long) larger + sizeof(Header) + get_free_size(larger)) == (long) smaller) {
assert(!larger->is_allocated && !smaller->is_allocated);
// Blocks are buddies, merge them
merge_blocks(larger, smaller);
merged = true;
}
smaller = smaller->next_header;
}
smaller = freelist[i][0];
larger = larger->next_header;
}
}
return merged;
}
size_t free_size() const
{
size_t s{0};
for (auto it = memory_blocks_.begin(); it != memory_blocks_.end(); it++) {
s += it->get_free_size();
}
return s;
}
/* This function initializes the memory allocator and makes a portion of
’_length’ bytes available. The allocator uses a ’_basic_block_size’ as
its minimal unit of allocation. The function returns the amount of
memory made available to the allocator. If an error occurred,
it returns 0.
*/
extern unsigned int init_allocator(unsigned int _basic_block_size,
unsigned int _length) {
if (_basic_block_size)
block_size = _basic_block_size;
else
block_size = default_block_size;
if (_length)
mem_size = _length;
else
mem_size = default_mem_size;
init_freelist();
allocated_space = malloc(sizeof(Header) + mem_size);
Header* header = allocated_space;
init_Header(header);
header->size = basic_logarithm(mem_size);
add_header(header);
return get_free_size(header);
}
