mirror of
https://github.com/justinian/jsix.git
synced 2025-12-10 00:14:32 -08:00
117 lines
2.7 KiB
C++
117 lines
2.7 KiB
C++
#include "kutil/memory.h"
|
|
#include "assert.h"
|
|
#include "log.h"
|
|
#include "memory.h"
|
|
#include "memory_pages.h"
|
|
|
|
memory_manager g_kernel_memory_manager;
|
|
|
|
struct memory_manager::alloc_header
|
|
{
|
|
uint64_t size;
|
|
uint64_t reserved;
|
|
uint8_t data[0];
|
|
} __attribute__ ((packed));
|
|
|
|
struct memory_manager::free_header
|
|
{
|
|
free_header *next;
|
|
uint64_t size;
|
|
} __attribute__ ((packed));
|
|
|
|
memory_manager::memory_manager() :
|
|
m_start(nullptr),
|
|
m_length(0)
|
|
{
|
|
kutil::memset(m_free, 0, sizeof(m_free));
|
|
}
|
|
|
|
memory_manager::memory_manager(void *start) :
|
|
m_start(start),
|
|
m_length(0)
|
|
{
|
|
kutil::memset(m_free, 0, sizeof(m_free));
|
|
grow_memory();
|
|
}
|
|
|
|
void *
|
|
memory_manager::allocate(size_t length)
|
|
{
|
|
size_t total = length + sizeof(alloc_header);
|
|
unsigned size = min_size;
|
|
while (total > (1 << size)) size++;
|
|
kassert(size < max_size, "Tried to allocate a block bigger than max_size");
|
|
log::debug(logs::memory, "Allocating %d bytes, which is size %d", total, size);
|
|
|
|
alloc_header *header = reinterpret_cast<alloc_header *>(pop_free(size));
|
|
header->size = size;
|
|
|
|
log::debug(logs::memory, " Returning %d bytes at %lx", length, &header->data);
|
|
return &header->data;
|
|
}
|
|
|
|
void
|
|
memory_manager::free(void *p)
|
|
{
|
|
// In this simple version, we don't care about freed pointers
|
|
}
|
|
|
|
void
|
|
memory_manager::grow_memory()
|
|
{
|
|
size_t length = (1 << max_size);
|
|
|
|
free_header *block = reinterpret_cast<free_header *>(
|
|
reinterpret_cast<uint64_t>(m_start) + m_length);
|
|
|
|
g_page_manager.map_pages(
|
|
reinterpret_cast<page_manager::addr_t>(block),
|
|
length / page_manager::page_size);
|
|
|
|
block->size = max_size;
|
|
block->next = get_free(max_size);
|
|
get_free(max_size) = block;
|
|
m_length += length;
|
|
|
|
log::debug(logs::memory, "Allocated new block at %lx: size %d next %lx",
|
|
block, block->size, block->next);
|
|
}
|
|
|
|
void
|
|
memory_manager::ensure_block(unsigned size)
|
|
{
|
|
free_header *header = get_free(size);
|
|
if (header != nullptr) return;
|
|
else if (size == max_size) {
|
|
grow_memory();
|
|
return;
|
|
}
|
|
|
|
free_header *bigger = pop_free(size + 1);
|
|
|
|
uint64_t new_size = bigger->size - 1;
|
|
free_header *next = reinterpret_cast<free_header *>(
|
|
reinterpret_cast<uint64_t>(bigger) + (1 << new_size));
|
|
|
|
next->next = bigger->next;
|
|
next->size = new_size;
|
|
|
|
bigger->next = next;
|
|
bigger->size = new_size;
|
|
log::debug(logs::memory, "ensure_block[%2d] split blocks:", size);
|
|
log::debug(logs::memory, " %lx: size %d next %lx", bigger, bigger->size, bigger->next);
|
|
log::debug(logs::memory, " %lx: size %d next %lx", next, next->size, next->next);
|
|
|
|
get_free(size) = bigger;
|
|
}
|
|
|
|
memory_manager::free_header *
|
|
memory_manager::pop_free(unsigned size)
|
|
{
|
|
ensure_block(size);
|
|
free_header *block = get_free(size);
|
|
get_free(size) = block->next;
|
|
block->next = nullptr;
|
|
return block;
|
|
}
|