BlocksContainer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <limits>
#include <utility>
 
#include "Block.hpp"
 
namespace hh::halloc {
 
template <std::size_t BlockSize, int MaxNumBlocks>
class BlocksContainer {
    Block blocks[MaxNumBlocks];  
    int current_block_index;     
 
    std::pair<std::size_t, MemoryNode*> best_fit(std::size_t bytes);
 
public:
    BlocksContainer();
 
    void* allocate(std::size_t bytes);
 
    void deallocate(void* ptr, std::size_t bytes);
 
    void log_container_state(std::ofstream& logfile) const;
};
}  // namespace hh::halloc
 
namespace hh::halloc {
inline std::size_t get_actual_value(std::size_t value) {
    return value & ~(3ull << 62);
}
 
template <std::size_t BlockSize, int MaxNumBlocks>
std::pair<std::size_t, MemoryNode*> BlocksContainer<BlockSize, MaxNumBlocks>::best_fit(
    std::size_t bytes) {
    std::size_t best_block_index = std::numeric_limits<std::size_t>::max();
    std::size_t best_size = std::numeric_limits<std::size_t>::max();
    MemoryNode* best_node = nullptr;
 
    // Search all initialized blocks
    for (int i = 0; i <= current_block_index; i++) {
        MemoryNode* node = blocks[i].best_fit(bytes);
        if (node) {
            std::size_t node_size = get_actual_value(node->value);
            // Track smallest fit
            if (node_size < best_size) {
                best_node = node;
                best_size = node_size;
                best_block_index = i;
            }
        }
    }
 
    return {best_block_index, best_node};
}
 
template <std::size_t BlockSize, int MaxNumBlocks>
BlocksContainer<BlockSize, MaxNumBlocks>::BlocksContainer() {
    current_block_index = 0;
    blocks[current_block_index] = std::move(Block(BlockSize));
}
 
template <std::size_t BlockSize, int MaxNumBlocks>
void* BlocksContainer<BlockSize, MaxNumBlocks>::allocate(std::size_t bytes) {
    if (bytes < 1) {
        throw std::invalid_argument("Bytes must be positive");
    }
 
    auto [index, node] = best_fit(bytes);
 
    // No suitable node found in existing blocks
    if (index == std::numeric_limits<std::size_t>::max()) {
        // Try to create a new block
        if (current_block_index + 1 < MaxNumBlocks) {
            current_block_index++;
            blocks[current_block_index] = std::move(Block(BlockSize));
            index = current_block_index;
            node = blocks[index].best_fit(bytes);
        }
    }
 
    if (!node) {
        return REQUEST_MEMORY_VIA_MMAP(bytes);
    }
 
    // Allocate from the selected block
    return blocks[index].allocate(bytes, node);
}
 
template <std::size_t BlockSize, int MaxNumBlocks>
void BlocksContainer<BlockSize, MaxNumBlocks>::deallocate(void* ptr, std::size_t bytes) {
    // Find which block owns this pointer
    for (int i = 0; i <= current_block_index; i++) {
        // Check if ptr is within block i's address range
        void* block_start = blocks[i].get_head();
        void* block_end = (char*)block_start + BlockSize;
 
        if (block_start <= ptr && ptr < block_end) {
            blocks[i].deallocate(ptr, bytes);
            return;
        }
    }
 
    RELEASE_MEMORY_VIA_MUNMAP(ptr, bytes);
}
 
template <std::size_t BlockSize, int MaxNumBlocks>
void BlocksContainer<BlockSize, MaxNumBlocks>::log_container_state(std::ofstream& logfile) const {
    logfile << "=================================================\n";
    logfile << "BlocksContainer State:\n";
    logfile << "Total Blocks: " << (current_block_index + 1) << "\n";
    for (int i = 0; i <= current_block_index; i++) {
        logfile << "---------------- Block " << i << " ----------------\n";
        blocks[i].log_block_state(logfile);
        logfile << "---------------- End Block " << i << " ----------------\n";
    }
    logfile << "=================================================\n\n";
}
};  // namespace hh::halloc