alloc.h

Go to the documentation of this file.

#ifndef VIRTMEM_ALLOC_H
#define VIRTMEM_ALLOC_H

#include "base_alloc.h"
#include "config/config.h"
#include "vptr.h"

namespace virtmem {

template <typename, typename> class VPtr;

template <typename Properties, typename Derived>
class VAlloc : public BaseVAlloc
{
    LockPage smallPagesData[Properties::smallPageCount];
    LockPage mediumPagesData[Properties::mediumPageCount];
    LockPage bigPagesData[Properties::bigPageCount];
#ifdef NVALGRIND
    uint8_t smallPagePool[Properties::smallPageCount * Properties::smallPageSize] __attribute__ ((aligned (sizeof(TAlign))));
    uint8_t mediumPagePool[Properties::mediumPageCount * Properties::mediumPageSize] __attribute__ ((aligned (sizeof(TAlign))));
    uint8_t bigPagePool[Properties::bigPageCount * Properties::bigPageSize] __attribute__ ((aligned (sizeof(TAlign))));
#else
    uint8_t smallPagePool[Properties::smallPageCount * (Properties::smallPageSize + valgrindPad * 2)];
    uint8_t mediumPagePool[Properties::mediumPageCount * (Properties::mediumPageSize + valgrindPad * 2)];
    uint8_t bigPagePool[Properties::bigPageCount * (Properties::bigPageSize + valgrindPad * 2)];
#endif
    static VAlloc *instance;

protected:
    VAlloc(void)
    {
        ASSERT(!instance);
        instance = this;
#ifdef NVALGRIND
        initSmallPages(smallPagesData, &smallPagePool[0], Properties::smallPageCount, Properties::smallPageSize);
        initMediumPages(mediumPagesData, &mediumPagePool[0], Properties::mediumPageCount, Properties::mediumPageSize);
        initBigPages(bigPagesData, &bigPagePool[0], Properties::bigPageCount, Properties::bigPageSize);
#else
        initSmallPages(smallPagesData, &smallPagePool[pad], Properties::smallPageCount, Properties::smallPageSize);
        initMediumPages(mediumPagesData, &mediumPagePool[pad], Properties::mediumPageCount, Properties::mediumPageSize);
        initBigPages(bigPagesData, &bigPagePool[pad], Properties::bigPageCount, Properties::bigPageSize);
        VALGRIND_MAKE_MEM_NOACCESS(&smallPagePool[0], pad); VALGRIND_MAKE_MEM_NOACCESS(&smallPagePool[Properties::smallPageCount * Properties::smallPageSize + pad], pad);
        VALGRIND_MAKE_MEM_NOACCESS(&mediumPagePool[0], pad); VALGRIND_MAKE_MEM_NOACCESS(&mediumPagePool[Properties::mediumPageCount * Properties::mediumPageSize + pad], pad);
        VALGRIND_MAKE_MEM_NOACCESS(&bigPagePool[0], pad); VALGRIND_MAKE_MEM_NOACCESS(&bigPagePool[Properties::bigPageCount * Properties::bigPageSize + pad], pad);
#endif
    }
    ~VAlloc(void) { instance = 0; }

public:
    static VAlloc *getInstance(void) { return instance; }

    // C style malloc/free
    template <typename T> VPtr<T, Derived> alloc(VPtrSize size=sizeof(T))
    {
        virtmem::VPtr<T, Derived> ret;
        ret.setRawNum(allocRaw(size));
        return ret;
    }

    template <typename T> void free(VPtr<T, Derived> &p)
    {
        freeRaw(p.getRawNum());
        p.setRawNum(0);
    }

    // C++ style new/delete --> call constructors (by placement new) and destructors
    template <typename T> VPtr<T, Derived> newClass(VPtrSize size=sizeof(T))
    {
        virtmem::VPtr<T, Derived> ret = alloc<T>(size);
        T *ptr = static_cast<T *>(read(ret.getRawNum(), sizeof(T)));
        new (ptr) T; // UNDONE: can this be ro?
        return ret;
    }

    template <typename T> void deleteClass(VPtr<T, Derived> &p)
    {
        p->~T();
        freeRaw(p.getRawNum());
    }

    // C++ style new []/delete [] --> calls constructors and destructors
    // the size of the array (necessary for destruction) is stored at the beginning of the block.
    // A pointer offset from this is returned.
    template <typename T> VPtr<T, Derived> newArray(VPtrSize elements)
    {
        VPtrNum p = allocRaw(sizeof(T) * elements + sizeof(VPtrSize));
        write(p, &elements, sizeof(VPtrSize));
        p += sizeof(VPtrSize);
        for (VPtrSize s=0; s<elements; ++s)
            new (read(p + (s * sizeof(T)), sizeof(T))) T; // UNDONE: can this be ro?

        virtmem::VPtr<T, Derived> ret;
        ret.setRawNum(p);
        return ret;
    }
    template <typename T> void deleteArray(VPtr<T, Derived> &p)
    {
        const VPtrNum soffset = p.getRawNum() - sizeof(VPtrSize); // pointer to size offset
        VPtrSize *size = static_cast<VPtrSize *>(read(soffset, sizeof(VPtrSize)));
        for (VPtrSize s=0; s<*size; ++s)
        {
            T *ptr = static_cast<T *>(read(p.getRawNum() + (s * sizeof(T)), sizeof(T)));
            ptr->~T();
        }
        freeRaw(soffset); // soffset points at beginning of actual block
    }

    template <typename T> struct TVPtr { typedef virtmem::VPtr<T, Derived> type; };

#ifdef VIRTMEM_CPP11

    template <typename T> using VPtr = virtmem::VPtr<T, Derived>;
#endif
};

template <typename Properties, typename Derived>
VAlloc<Properties, Derived> *VAlloc<Properties, Derived>::instance = 0;

}

#endif // VIRTMEM_ALLOC_H