Rename memory_manager to heap_manager

src/kernel/page_manager.cpp

@@ -1,13 +1,13 @@
 #include <algorithm>
 
 #include "kutil/assert.h"
-#include "kutil/memory_manager.h"
+#include "kutil/heap_manager.h"
 #include "console.h"
 #include "log.h"
 #include "page_manager.h"
 
 page_manager g_page_manager;
-kutil::memory_manager g_kernel_memory_manager;
+kutil::heap_manager g_kernel_heap_manager;
 
 
 static uintptr_t
@@ -161,10 +161,10 @@ page_manager::init(
 		}
 	}
 
-	new (&g_kernel_memory_manager) kutil::memory_manager(
+	new (&g_kernel_heap_manager) kutil::heap_manager(
 			reinterpret_cast<void *>(end),
 			mm_grow_callback);
-	kutil::setup::set_heap(&g_kernel_memory_manager);
+	kutil::setup::set_heap(&g_kernel_heap_manager);
 
 	m_kernel_pml4 = get_pml4();
 }

src/libraries/kutil/heap_manager.cpp

@@ -1,12 +1,12 @@
 #include <stdint.h>
 #include "kutil/assert.h"
 #include "kutil/memory.h"
-#include "kutil/memory_manager.h"
+#include "kutil/heap_manager.h"
 
 namespace kutil {
 
 
-struct memory_manager::mem_header
+struct heap_manager::mem_header
 {
 	mem_header(mem_header *prev, mem_header *next, uint8_t size) :
 		m_prev(prev), m_next(next)
@@ -67,7 +67,7 @@ private:
 };
 
 
-memory_manager::memory_manager() :
+heap_manager::heap_manager() :
 	m_start(nullptr),
 	m_length(0),
 	m_grow(nullptr)
@@ -75,7 +75,7 @@ memory_manager::memory_manager() :
 	kutil::memset(m_free, 0, sizeof(m_free));
 }
 
-memory_manager::memory_manager(void *start, grow_callback grow_cb) :
+heap_manager::heap_manager(void *start, grow_callback grow_cb) :
 	m_start(start),
 	m_length(0),
 	m_grow(grow_cb)
@@ -85,7 +85,7 @@ memory_manager::memory_manager(void *start, grow_callback grow_cb) :
 }
 
 void *
-memory_manager::allocate(size_t length)
+heap_manager::allocate(size_t length)
 {
 	size_t total = length + sizeof(mem_header);
 	unsigned size = min_size;
@@ -98,7 +98,7 @@ memory_manager::allocate(size_t length)
 }
 
 void
-memory_manager::free(void *p)
+heap_manager::free(void *p)
 {
 	mem_header *header = reinterpret_cast<mem_header *>(p);
 	header -= 1; // p points after the header
@@ -120,7 +120,7 @@ memory_manager::free(void *p)
 }
 
 void
-memory_manager::grow_memory()
+heap_manager::grow_memory()
 {
 	size_t length = (1 << max_size);
 
@@ -136,7 +136,7 @@ memory_manager::grow_memory()
 }
 
 void
-memory_manager::ensure_block(unsigned size)
+heap_manager::ensure_block(unsigned size)
 {
 	if (get_free(size) != nullptr) return;
 	else if (size == max_size) {
@@ -154,8 +154,8 @@ memory_manager::ensure_block(unsigned size)
 	get_free(size) = orig;
 }
 
-memory_manager::mem_header *
-memory_manager::pop_free(unsigned size)
+heap_manager::mem_header *
+heap_manager::pop_free(unsigned size)
 {
 	ensure_block(size);
 	mem_header *block = get_free(size);

src/libraries/kutil/include/kutil/heap_manager.h

@@ -1,5 +1,5 @@
 #pragma once
-/// \file memory_manager.h
+/// \file heap_manager.h
 /// A buddy allocator and related definitions.
 
 #include <stddef.h>
@@ -7,19 +7,19 @@
 namespace kutil {
 
 
-/// Manager for allocation of virtual memory.
-class memory_manager
+/// Manager for allocation of heap memory.
+class heap_manager
 {
 public:
 	using grow_callback = void (*)(void *start, size_t length);
 
 	/// Default constructor. Creates an invalid manager.
-	memory_manager();
+	heap_manager();
 
 	/// Constructor.
 	/// \arg start    Pointer to the start of the heap to be managed
 	/// \arg grow_cb  Function pointer to grow the heap size
-	memory_manager(void *start, grow_callback grow_cb);
+	heap_manager(void *start, grow_callback grow_cb);
 
 	/// Allocate memory from the area managed.
 	/// \arg length  The amount of memory to allocate, in bytes
@@ -63,7 +63,7 @@ protected:
 
 	grow_callback m_grow;
 
-	memory_manager(const memory_manager &) = delete;
+	heap_manager(const heap_manager &) = delete;
 };
 
 } // namespace kutil

src/libraries/kutil/include/kutil/memory.h

@@ -68,13 +68,13 @@ inline T* mask_pointer(T *p, uintptr_t mask)
 uint8_t checksum(const void *p, size_t len, size_t off = 0);
 
 
-class memory_manager;
+class heap_manager;
 
 namespace setup {
 
 /// Set the heap that malloc() / free() will use.
 /// \arg mm  The heap manager for the heap to use.
-void set_heap(memory_manager *mm);
+void set_heap(heap_manager *mm);
 
 } // namespace kutil::setup
 } // namespace kutil

src/libraries/kutil/memory.cpp

@@ -1,5 +1,5 @@
 #include "kutil/memory.h"
-#include "kutil/memory_manager.h"
+#include "kutil/heap_manager.h"
 
 namespace std {
 	enum class __attribute__ ((__type_visibility("default"))) align_val_t : size_t { };
@@ -17,10 +17,10 @@ namespace kutil {
 
 namespace setup {
 
-static memory_manager *heap_memory_manager;
+static heap_manager *heap_memory_manager;
 
 void
-set_heap(memory_manager *mm)
+set_heap(heap_manager *mm)
 {
 	setup::heap_memory_manager = mm;
 }

src/tests/heap_manager.cpp

@@ -6,7 +6,7 @@
 #include <stdint.h>
 
 #include "kutil/memory.h"
-#include "kutil/memory_manager.h"
+#include "kutil/heap_manager.h"
 #include "catch.hpp"
 
 using namespace kutil;
@@ -35,7 +35,7 @@ TEST_CASE( "Buddy blocks tests", "[memory buddy]" )
 
 	memory = aligned_alloc(max_block, 4 * max_block);
 
-	memory_manager mm(memory, grow_callback);
+	heap_manager mm(memory, grow_callback);
 
 	// The ctor should have allocated an initial block
 	CHECK( total_alloc_size == max_block );