SF_SysAlloc.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/kernel/SF_Types.h"

namespace Kaim {

// ***** SysAllocBase

// SysAllocBase is a base class for SysAlloc.
// This class is used to provide link-independent initialization for
// different memory heap engines in System class and has no public APIs.
class SysAllocBase
{
    friend class System;
protected:
    virtual ~SysAllocBase() { }

    // Initializes heap system, creating and initializing GlobalHeap.
    virtual bool initHeapEngine(const void* heapDesc) { KY_UNUSED(heapDesc); return false; }
    // Shuts down heap system, clearing out global heap.
    virtual void shutdownHeapEngine() { }
};


//------------------------------------------------------------------------
// ***** SysAlloc

// SysAlloc defines a memory allocation interface that developers can override
// to to provide memory for GFx; an instance of this class is typically created on
// application startup and passed into System or Intrnl::System constructor.
//
// SysAlloc is more memory efficient when delegating to malloc/dlmalloc based implementation,
// as it doesn't require large alignment and will return more memory blocks
// to the application once content is unloaded.
//
// Users implementing this interface must provide three functions: Alloc, Free,
// and Realloc. Implementations of these functions must honor the requested alignment.
// Although arbitrary alignment requests are possible, requested alignment will
// typically be small, such as 16 bytes or less.
//
// SysAlloc links to the MemoryHeapMH implementation, which groups small
// allocations into 4K-sized blocks belonging to the heap. Allocations larger
// then 512 bytes will delegated directly to SysAlloc and released immediately
// once no longer used, making more memory available to the application.

class SysAlloc : public SysAllocBase
{
public:
    SysAlloc() {}
    virtual ~SysAlloc() {}

    virtual void* Alloc(UPInt size, UPInt align) = 0;
    virtual void  Free(void* ptr, UPInt size, UPInt align) = 0;
    virtual void* Realloc(void* oldPtr, UPInt oldSize, UPInt newSize, UPInt align) = 0;

protected:
    // Implementation of SysAllocBase based on MemoryHeapMH.
    virtual bool initHeapEngine(const void* heapDesc);
    virtual void shutdownHeapEngine();
};


//------------------------------------------------------------------------
// ***** SysAllocBase_SingletonSupport

// SysAllocBase_SingletonSupport is a SysAllocBase class wrapper that implements
// the InitSystemSingleton static function, used to create a global singleton
// used for the GFxSystem default argument initialization.
//
// End users implementing custom SysAlloc/Paged interface don't need to make use of this base
// class; they can just create an instance of their own class on stack and pass it to System.

template<class A, class B>
class SysAllocBase_SingletonSupport : public B
{
    struct SysAllocContainer
    {
        UPInt Data[(sizeof(A) + sizeof(UPInt)-1) / sizeof(UPInt)];
        bool  Initialized;
        SysAllocContainer() : Initialized(0) { }
    };

    SysAllocContainer* pContainer;

public:
    SysAllocBase_SingletonSupport() : pContainer(0) { }

    static  B*  InitSystemSingleton()
    {
        static SysAllocContainer Container;
        KY_ASSERT(Container.Initialized == false);

    #undef new

        SysAllocBase_SingletonSupport<A,B> *presult = ::new((void*)Container.Data) A;

    // Redefine operator 'new' if necessary.
    #if defined(KY_DEFINE_NEW)
    #define new KY_DEFINE_NEW
    #endif

        presult->pContainer = &Container;
        Container.Initialized = true;
        return presult;
    }

protected:
    virtual void shutdownHeapEngine()
    {
        B::shutdownHeapEngine();
        if (pContainer)
        {
            pContainer->Initialized = false;
            ((B*)this)->~B();
            pContainer = 0;
        }
    }
};

}