Block.hpp

Go to the documentation of this file.

 
#pragma once
#include <sys/mman.h>
 
#include <algorithm>
#include <cstddef>
#include <fstream>
 
#include "RBTreeDriver.hpp"
 
#define REQUEST_MEMORY_VIA_MMAP(size) \
    mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)
 
#define RELEASE_MEMORY_VIA_MUNMAP(ptr, size) munmap(ptr, size)
 
namespace hh::halloc {
struct MemoryNode {
    MemoryNode* left;    
    MemoryNode* right;   
    MemoryNode* parent;  
 
    std::size_t value;
 
    MemoryNode* next;  
    MemoryNode* prev;  
};
 
#define MEMORY_NODE_SIZE sizeof(MemoryNode)
 
class Block {
    std::size_t size;                  
    MemoryNode* head;                  
    RBTreeDriver<MemoryNode> rb_tree;  
    std::size_t get_actual_value(std::size_t value) const;
 
    void mark_as_used(std::size_t& value) const;
 
    void mark_as_free(std::size_t& value) const;
 
    bool is_free(const std::size_t& value) const;
 
    void shrink_then_align(MemoryNode* node, std::size_t bytes);
 
    void coalesce_nodes(MemoryNode* node);
 
public:
    Block();
 
    explicit Block(std::size_t bytes);
 
    Block(Block&& other);
 
    Block& operator=(Block&& other);
 
    MemoryNode* best_fit(std::size_t bytes);
 
    ~Block();
 
    std::size_t get_size() const { return size; }
 
    void* get_head() const { return head; }
 
    void* allocate(std::size_t bytes, MemoryNode* node);
 
    void deallocate(void* ptr, std::size_t bytes);
 
    void log_block_state(std::ofstream& logfile) const {
        ;
        logfile << "Block State:\n";
        logfile << "Address: " << this << "\n";
        logfile << "Total Size: " << size << " bytes\n";
 
        auto current = head;
        std::size_t free_space = 0;
        std::size_t actual_used_space = 0;
        std::size_t num_free_nodes = 0;
        std::size_t num_used_nodes = 0;
        std::size_t headers_used_space = 0;
 
        std::size_t i = 0;
        while (current) {
            logfile << "---------------- Node " << ++i << " ----------------\n";
            std::size_t node_size = get_actual_value(current->value);
            headers_used_space += MEMORY_NODE_SIZE;
            logfile << "Node Address: " << current << " | Size: " << node_size << " bytes"
                    << " | Status: " << (is_free(current->value) ? "Free" : "Used") << "\n";
            if (is_free(current->value)) {
                free_space += node_size;
                num_free_nodes++;
            } else {
                actual_used_space += node_size;
                num_used_nodes++;
            }
            current = current->next;
        }
 
        logfile << "-------------------------------------------------------\n";
        logfile << "Free Space: " << free_space << " bytes\n";
        logfile << "Actual Used Space: " << actual_used_space << " bytes\n";
        logfile << "Headers Used Space: " << headers_used_space << " bytes\n";
        logfile << "Number of Free Nodes: " << num_free_nodes << "\n";
        logfile << "Number of Used Nodes: " << num_used_nodes << "\n";
    }
};
}  // namespace hh::halloc