LibDmem.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "LibDmem.hpp"
#include <stdint.h>
#include <string.h>

LibDmem::LibDmem(void* buffer, size_t size) {
    mBeginning = (SEGMENT*) buffer;
    SEGMENT* last = (SEGMENT*) (((uint8_t*) buffer) + size - SIZE_OF_CTRL);

    mBeginning->prev = 0;
    mBeginning->next = last;
    mBeginning->size = 0;

    last->prev = mBeginning;
    last->next = 0;
    last->size = 0;

    mFree = (uint8_t*) last - (uint8_t*) mBeginning - SIZE_OF_CTRL;
    mTotalSize = mFree;
    mBlockCount = 0;
}

LibDmem::~LibDmem() {

}

void* LibDmem::alloc(size_t size) {
    SEGMENT * prev = 0;
    size = ALIGN_TO_SIZE(size, 4);
    size_t requiredSize = size + SIZE_OF_CTRL;
    size_t smallestGap = SIZE_MAX;

    for (SEGMENT* iterator = mBeginning; iterator->next; iterator = iterator->next) {
        size_t currentGap = (uint8_t*) iterator->next - (uint8_t*) iterator - iterator->size - SIZE_OF_CTRL;

        if (currentGap == requiredSize) {
            prev = iterator;
            break;
        }
        if (currentGap >= requiredSize) {
            if (currentGap < smallestGap) {
                prev = iterator;
                smallestGap = currentGap;
            }
        }
    }

    if (!prev) {
        return 0;
    }

    SEGMENT* seg = (SEGMENT*) (((uint8_t*) prev) + prev->size + SIZE_OF_CTRL);

    seg->prev = prev;
    seg->next = prev->next;
    seg->size = size;
    seg->next->prev = seg;
    prev->next = seg;
    mBlockCount++;
    mFree -= requiredSize;

    return ((uint8_t*) seg) + SIZE_OF_CTRL;
}

void LibDmem::free(void* p) {
    LIB_ASSERT((p != 0)&&(p > mBeginning) && (p < (((uint8_t*)mBeginning)+mTotalSize)));

    SEGMENT* seg = (SEGMENT*) (((uint8_t*) p) - SIZE_OF_CTRL);

    seg->prev->next = seg->next;
    seg->next->prev = seg->prev;

    mBlockCount--;
    mFree += seg->size + SIZE_OF_CTRL;
    if (mFree > mTotalSize) {
        __asm volatile("nop\n");
    }
}

void* LibDmem::resize(void* p, size_t size) {
    LIB_ASSERT((p != 0)&&(p > mBeginning) && (p < (((uint8_t*)mBeginning)+mTotalSize)));

    if (size == 0) {
        free(p);
        return 0;
    }
    if (p == 0) {
        return alloc(size);
    }

    size = ALIGN_TO_SIZE(size, 4);
    SEGMENT* seg = (SEGMENT*) (((uint8_t*) p) - SIZE_OF_CTRL);

    size_t available = (uint8_t*) seg->next - (uint8_t*) seg - SIZE_OF_CTRL;
    if (size <= available) {
        mFree += seg->size - size;
        seg->size = size;
        return p;
    }

    //Try to allocate a new segment
    void* newSeg = alloc(size);
    if (!newSeg) {
        free(p);
        return 0;
    }
    memcpy(newSeg, p, seg->size);
    free(p);
    return newSeg;
}

void* LibDmem::resizeLeft(void* p, size_t left) {
    LIB_ASSERT((p != 0)&&(p > mBeginning) && (p < (((uint8_t*)mBeginning)+mTotalSize)));
    LIB_ASSERT((left%4)==0);

    SEGMENT* oldSeg = (SEGMENT*) (((uint8_t*) p) - SIZE_OF_CTRL);

    if (left > oldSeg->size) {
        return 0;
    }

    SEGMENT* newSeg = (SEGMENT*) (((uint8_t*) oldSeg) + left);

    SEGMENT* prev = oldSeg->prev;
    SEGMENT* next = oldSeg->next;
    size_t size = oldSeg->size - left;

    newSeg->prev = prev;
    newSeg->next = next;
    newSeg->size = size;

    if (prev) {
        prev->next = newSeg;
    }
    if (next) {
        next->prev = newSeg;
    }

    mFree += left;
    return ((uint8_t*) newSeg) + SIZE_OF_CTRL;
}

size_t LibDmem::getTotalMemory() {
    return mTotalSize;
}

size_t LibDmem::getFreeMemory() {
    return mFree;
}

unsigned int LibDmem::getBlockCount() {
    return mBlockCount;
}