From 4e52e284a0edd12f7d92dcc0cdf0d21202d78248 Mon Sep 17 00:00:00 2001 From: Baptiste Wicht Date: Wed, 28 Mar 2018 14:20:00 +0200 Subject: [PATCH] Distinction between total memory and buddy memory --- kernel/include/physical_allocator.hpp | 17 +++++- kernel/src/physical_allocator.cpp | 83 +++++++++++++++++++++------ 2 files changed, 80 insertions(+), 20 deletions(-) diff --git a/kernel/include/physical_allocator.hpp b/kernel/include/physical_allocator.hpp index 068767af..362ab7d7 100644 --- a/kernel/include/physical_allocator.hpp +++ b/kernel/include/physical_allocator.hpp @@ -54,17 +54,32 @@ void free(size_t address, size_t pages); /*! * \brief Return the amount of physical memory available */ +size_t total_available(); + +/*! + * \brief Return the amount of physical memory currently available + */ size_t available(); /*! * \brief Return the amount of physical memory allocated */ +size_t total_allocated(); + +/*! + * \brief Return the amount of physical memory currently allocated + */ size_t allocated(); +/*! + * \brief Return the amount of physical memory currently free + */ +size_t free(); + /*! * \brief Return the amount of physical memory free */ -size_t free(); +size_t total_free(); } //end of physical_allocator namespace diff --git a/kernel/src/physical_allocator.cpp b/kernel/src/physical_allocator.cpp index 364d1709..9edc14dc 100644 --- a/kernel/src/physical_allocator.cpp +++ b/kernel/src/physical_allocator.cpp @@ -34,17 +34,21 @@ buddy_type allocator; size_t first_physical_address; size_t last_physical_address; +bool buddy = false; +size_t buddy_managed_space = 0; +size_t buddy_allocated_memory = 0; + size_t array_size(size_t managed_space, size_t block){ return (managed_space / (block * unit) + 1) / (sizeof(uint64_t) * 8) + 1; } -uint64_t* create_array(size_t managed_space, size_t block){ +uint64_t* create_buddy_array(size_t managed_space, size_t block){ auto size = array_size(managed_space, block) * sizeof(uint64_t); auto pages = paging::pages(size); auto physical_address = current_mmap_entry_position; - allocated_memory += pages * paging::PAGE_SIZE; + buddy_allocated_memory += pages * paging::PAGE_SIZE; current_mmap_entry_position += pages * paging::PAGE_SIZE; auto virtual_address = virtual_allocator::allocate(pages); @@ -60,14 +64,26 @@ std::string sysfs_free(){ return std::to_string(physical_allocator::free()); } +std::string sysfs_total_free(){ + return std::to_string(physical_allocator::total_free()); +} + std::string sysfs_available(){ return std::to_string(physical_allocator::available()); } +std::string sysfs_total_available(){ + return std::to_string(physical_allocator::total_available()); +} + std::string sysfs_allocated(){ return std::to_string(physical_allocator::allocated()); } +std::string sysfs_total_allocated(){ + return std::to_string(physical_allocator::total_allocated()); +} + } //End of anonymous namespace void physical_allocator::early_init(){ @@ -123,24 +139,23 @@ size_t physical_allocator::early_allocate(size_t blocks){ void physical_allocator::init(){ //Make sure to start with an aligned address if((current_mmap_entry_position % paging::PAGE_SIZE) != 0){ - allocated_memory += current_mmap_entry_position % paging::PAGE_SIZE; + buddy_allocated_memory += current_mmap_entry_position % paging::PAGE_SIZE; current_mmap_entry_position = current_mmap_entry_position + current_mmap_entry_position % paging::PAGE_SIZE; } - // Compute the size of the managed space + // Compute the size of the managed space available into the + // current mmap entry auto size = current_mmap_entry->size; auto managed_space = size - (current_mmap_entry_position - current_mmap_entry->base); - logging::logf(logging::log_level::TRACE, "palloc: Managed space %m\n", size_t(managed_space)); - - auto data_bitmap_1 = create_array(managed_space, 1); - auto data_bitmap_2 = create_array(managed_space, 2); - auto data_bitmap_4 = create_array(managed_space, 4); - auto data_bitmap_8 = create_array(managed_space, 8); - auto data_bitmap_16 = create_array(managed_space, 16); - auto data_bitmap_32 = create_array(managed_space, 32); - auto data_bitmap_64 = create_array(managed_space, 64); - auto data_bitmap_128 = create_array(managed_space, 128); + auto data_bitmap_1 = create_buddy_array(managed_space, 1); + auto data_bitmap_2 = create_buddy_array(managed_space, 2); + auto data_bitmap_4 = create_buddy_array(managed_space, 4); + auto data_bitmap_8 = create_buddy_array(managed_space, 8); + auto data_bitmap_16 = create_buddy_array(managed_space, 16); + auto data_bitmap_32 = create_buddy_array(managed_space, 32); + auto data_bitmap_64 = create_buddy_array(managed_space, 64); + auto data_bitmap_128 = create_buddy_array(managed_space, 128); first_physical_address = current_mmap_entry_position; last_physical_address = current_mmap_entry->base + current_mmap_entry->size; @@ -158,6 +173,13 @@ void physical_allocator::init(){ allocator.init(); + // The available space is now dependent only on the buddy allocator + buddy = true; + buddy_managed_space = managed_space; + + logging::logf(logging::log_level::TRACE, "palloc: Buddy allocator in place\n"); + logging::logf(logging::log_level::TRACE, "palloc: Managed space %m\n", size_t(managed_space)); + //TODO The current system uses more memory than necessary, //because it also tries to index memory that is used for the //buddy system. @@ -167,8 +189,11 @@ void physical_allocator::init(){ void physical_allocator::finalize(){ sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/available"), &sysfs_available); - sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/free"), &sysfs_free); + sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/total_available"), &sysfs_total_available); sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/allocated"), &sysfs_allocated); + sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/total_allocated"), &sysfs_total_allocated); + sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/free"), &sysfs_free); + sysfs::set_dynamic_value(path("/sys"), path("/memory/physical/total_free"), &sysfs_total_free); // Publish the e820 map auto entries = e820::mmap_entry_count(); @@ -188,7 +213,7 @@ void physical_allocator::finalize(){ size_t physical_allocator::allocate(size_t blocks){ thor_assert(blocks * paging::PAGE_SIZE < free(), "Not enough physical memory"); - allocated_memory += buddy_type::level_size(blocks) * unit; + buddy_allocated_memory += buddy_type::level_size(blocks) * unit; auto phys = allocator.allocate(blocks); @@ -200,17 +225,37 @@ size_t physical_allocator::allocate(size_t blocks){ } void physical_allocator::free(size_t address, size_t blocks){ - allocated_memory -= buddy_type::level_size(blocks) * unit; + buddy_allocated_memory -= buddy_type::level_size(blocks) * unit; return allocator.free(address, blocks); } -size_t physical_allocator::available(){ +size_t physical_allocator::total_available(){ return e820::available_memory(); } +size_t physical_allocator::available(){ + if(buddy){ + return buddy_managed_space; + } else { + return total_available(); + } +} + +size_t physical_allocator::total_allocated(){ + return buddy_allocated_memory + allocated_memory; +} + size_t physical_allocator::allocated(){ - return allocated_memory; + if(buddy){ + return allocated_memory; + } else { + return buddy_allocated_memory; + } +} + +size_t physical_allocator::total_free(){ + return total_available() - total_allocated(); } size_t physical_allocator::free(){