Halloc.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <fstream>
#include <memory>
 
#include "BlocksContainer.hpp"
 
const int DEFAULT_BLOCK_SIZE = (128 * 1024 * 1024);  
const int DEFAULT_MAX_NUM_BLOCKS = 1;                
 
namespace hh::halloc {
template <typename T = void, int BlockSize = DEFAULT_BLOCK_SIZE,
          int MaxNumBlocks = DEFAULT_MAX_NUM_BLOCKS>
class Halloc {
    // Use shared_ptr so allocator can be copied (required by STL containers)
    std::shared_ptr<BlocksContainer<BlockSize, MaxNumBlocks>>
        blocks;  
 
public:
    // ==================== C++ Allocator Requirements ====================
 
    using value_type = T;                    
    using pointer = T*;                      
    using const_pointer = const T*;          
    using reference = T&;                    
    using const_reference = const T&;        
    using size_type = std::size_t;           
    using difference_type = std::ptrdiff_t;  
 
    template <typename U>
    struct rebind {
        using other = Halloc<U, BlockSize, MaxNumBlocks>;
    };
 
    Halloc();
 
    Halloc(const Halloc& other) : blocks(other.blocks) {}
 
    template <typename U>
    Halloc(const Halloc<U, BlockSize, MaxNumBlocks>& other) : blocks(other.blocks) {}
 
    Halloc& operator=(const Halloc& other) {
        blocks = other.blocks;
        return *this;
    }
 
    // Allow rebind copy constructor to access private members
    template <typename U, int BS, int MNB>
    friend class Halloc;
 
    T* allocate(std::size_t count);
 
    void deallocate(T* ptr, std::size_t count);
 
    bool operator==(const Halloc& other) const { return blocks == other.blocks; }
 
    bool operator!=(const Halloc& other) const { return !(*this == other); }
 
    ~Halloc();
 
    void log_container_state(const char* logfile_dir) const {
        std::ofstream logfile;
        logfile.open(logfile_dir, std::ios::app);
        logfile << "#####################################################\n";
        logfile << "Halloc Allocator State:\n";
        blocks->log_container_state(logfile);
        logfile << "#####################################################\n";
        logfile.close();
    }
};
}  // namespace hh::halloc
 
namespace hh::halloc {
template <typename T, int BlockSize, int MaxNumBlocks>
Halloc<T, BlockSize, MaxNumBlocks>::Halloc()
    : blocks(std::make_shared<BlocksContainer<BlockSize, MaxNumBlocks>>()) {
    // BlocksContainer constructor handles initialization
}
 
template <typename T, int BlockSize, int MaxNumBlocks>
T* Halloc<T, BlockSize, MaxNumBlocks>::allocate(std::size_t count) {
    return static_cast<T*>(blocks->allocate(count * sizeof(T)));
}
 
template <typename T, int BlockSize, int MaxNumBlocks>
void Halloc<T, BlockSize, MaxNumBlocks>::deallocate(T* ptr, std::size_t count) {
    blocks->deallocate(ptr, count * sizeof(T));
}
 
template <typename T, int BlockSize, int MaxNumBlocks>
Halloc<T, BlockSize, MaxNumBlocks>::~Halloc() {
    // shared_ptr handles cleanup when reference count reaches zero
}
 
}  // namespace hh::halloc