Slab.cpp

#include "Slab.hpp"
#include <cstdlib>
#include <cstring>
#include <iostream>

namespace slab {

Slab::Slab(size_t chunkSize) : chunkSize_(chunkSize), memory_(nullptr), freeList_(nullptr) {

    memory_ = malloc(kSlabSize);

    for (size_t i = 0; i < kSlabSize; i += chunkSize_) {
        void* chunk = ((char*)memory_) + i;
        Node* node = (Node*)chunk;  
        node->next = freeList_;
        freeList_ = node;
    }

    // std::cout << "Slab initialized with " << kSlabSize << " bytes" << std::endl;
}

Slab::~Slab() {
   
    free(memory_);
    freeList_ = nullptr;
}

void* Slab::allocate() {
   
    if (freeList_ == nullptr) return nullptr;

    Node* node = freeList_;
    freeList_ = node->next;
    return (void*)node; 
}

void Slab::deallocate(void* ptr) {
  

    auto* base = (char*)memory_;
    auto* end_of_slab = ((char*)memory_ + kSlabSize);
    auto* p = (char*)ptr;
    if(p >= base && p < end_of_slab) {
        Node* node = (Node*)ptr; 
        node->next = freeList_;
        freeList_ = node;
    }
}

bool Slab::empty() const {
    
    size_t totalChunks = kSlabSize / chunkSize_;
    
    size_t freeChunks = 0;
    Node* current = freeList_;
    while (current != nullptr) {
        freeChunks++;
        current = current->next;
    }
    
    return freeChunks == totalChunks;
}



bool Slab::contains(void* ptr) const {
  
    auto* base = (char*)memory_;
    auto* end_of_slab = ((char*)memory_ + kSlabSize);
    auto* p = (char*)ptr;
    if(p >= base && p < end_of_slab) return true;
    return false;
}

} // namespace slab