malloc_2.cpp

#include <unistd.h>
#include <cstring>

struct MetaData {
    size_t size;         
    bool is_free;         
    MetaData* next;       
    MetaData* prev;       
};
class Allocator {
private:
    MetaData* head;
    Allocator() : head(nullptr) {}
public:
    Allocator& operator=(const Allocator&) = delete;
     Allocator(const Allocator&) = delete;
    void* smalloc(size_t size) {
        if (size == 0 || size > 100000000){
            return nullptr;
        }
        MetaData* curr = head;
        MetaData* last = nullptr;
        while (curr) {
            if (curr->is_free && curr->size >= size) {
                curr->is_free = false;
                return (char*)curr + sizeof(MetaData);
            }
            last = curr;
            curr = curr->next;
        }
        void* brk = sbrk(size + sizeof(MetaData));
        if (brk == (void*)-1){                                
            return nullptr;
        }
        MetaData* meta = (MetaData*)brk;
        meta->size = size;
        meta->is_free = false;
        meta->next = nullptr;
        meta->prev = last;
        if (last){
            last->next = meta;
        }
        else{
            head = meta;
        }
        return (char*)meta + sizeof(MetaData);
    }
    static Allocator& get() {
        static Allocator instance;
        return instance;
    }
    void* scalloc(size_t num, size_t size) {
        if (num == 0 || size == 0){
            return nullptr;
        }
        size_t total = num * size;
        void* p = smalloc(total);
        if (p){
            std::memset(p, 0, total);
        }
        return p;
    }

    void sfree(void* p) {
        if (!p){
            return;
        }
        MetaData* meta = (MetaData*)((char*)p - sizeof(MetaData));
        if (!meta->is_free){
            meta->is_free = true;
        }
    }
    void* srealloc(void* oldp, size_t size) {
        if (size == 0 || size > 100000000){
            return nullptr;
        }
        if (!oldp){
            return smalloc(size);
        }
        MetaData* meta = (MetaData*)((char*)oldp - sizeof(MetaData));
        if (meta->size >= size){
            return oldp;
        }
        void* newp = smalloc(size);
        if (!newp){
            return nullptr;
        }
        std::memmove(newp, oldp, meta->size);
        sfree(oldp);
        return newp;
    }
    size_t free_bytes() const {
        size_t sum = 0;
        MetaData* curr = head;
        while (curr) {
            if (curr->is_free)
                sum += curr->size;
            curr = curr->next;
        }
        return sum;
    }
    size_t meta_size() const {
        return sizeof(MetaData);
    }
    size_t free_blocks() const {
        size_t count = 0;
        MetaData* curr = head;
        while (curr) {
            if (curr->is_free)
                count++;
            curr = curr->next;
        }
        return count;
    }

    
  size_t allocated_bytes() const {
        size_t sum = 0;
        MetaData* curr = head;
        while (curr) {
            sum += curr->size;
            curr = curr->next;
        }
        return sum;
    }
    size_t allocated_blocks() const {
        size_t count = 0;
        MetaData* curr = head;
        while (curr) {
            count++;
            curr = curr->next;
        }
        return count;
    }
    size_t meta_bytes() const {
        return allocated_blocks() * sizeof(MetaData);
    }
};

void* smalloc(size_t size) {
    return Allocator::get().smalloc(size);
}
void* scalloc(size_t num, size_t size) {
    return Allocator::get().scalloc(num, size);
}
void sfree(void* p) {
    Allocator::get().sfree(p);
}
void* srealloc(void* p, size_t size) {
    return Allocator::get().srealloc(p, size);}
size_t _num_free_blocks() {
    return Allocator::get().free_blocks();}
size_t _num_free_bytes() {
    return Allocator::get().free_bytes();}
size_t _num_allocated_blocks() {
    return Allocator::get().allocated_blocks();}
size_t _num_allocated_bytes() {
    return Allocator::get().allocated_bytes();}
size_t _num_meta_data_bytes() {
    return Allocator::get().meta_bytes();}
size_t _size_meta_data() {
    return Allocator::get().meta_size();}