workingmemory.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/base/memory.h"
#include "gwnavruntime/kernel/SF_Debug.h"
#include "gwnavruntime/kernel/SF_RefCount.h"

namespace Kaim
{

typedef KyUInt32 BufferIndex;
static const BufferIndex BufferIndex_Invalid = KyUInt32MAXVAL;

// 13 is enough given our current usage of queries but we should create buffers on demand instead
// of having hardcoded limites like that
static const BufferIndex BufferIndex_Count = 13;

class AStarTraversalContext;
class PathRefinerContext;
class PathClamperContext;
class NavDataChangeIndexInGrid;
class SpatializedPointCollectorContext;
class ChannelArrayComputer;
class DynamicNavMeshContext;
class QueryDynamicOutput;

class WorkingMemory
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_WorldFwk)
    KY_CLASS_WITHOUT_COPY(WorkingMemory)

public:
    struct MyLimitHandler : public MemoryHeap::LimitHandler
    {
        virtual ~MyLimitHandler() {}
        virtual bool OnExceedLimit(MemoryHeap* /*heap*/, UPInt /*overLimit*/) { return false; };
        virtual void OnFreeSegment(MemoryHeap* /*heap*/, UPInt /*freeingSize*/) { };
    };

    struct WorkingBuffer
    {
        WorkingBuffer() : m_memory(nullptr), m_memorySize(0), m_inUse(false) {}

        void* m_memory;
        KyUInt32 m_memorySize;
        bool m_inUse;
    };

    // \param memoryLimitSize           specifies the local heap memory allocation limit
    // \param granularityOfBufferResize specifies how the buffer size increase if more memory is needed
    WorkingMemory(KyUInt32 memoryLimitSize = 4 * 1024 * 1024 /* 4 Mb */, KyUInt32 granularityOfBufferResize = 5 * 1024/* 5 Kb */);
    ~WorkingMemory();

    void Init(KyUInt32 memoryLimitSize, KyUInt32 granularityOfBufferResize);
    void InitMemoryHeap(KyUInt32 memoryLimitSize);

    void SetNewLimit(KyUInt32 memoryLimitSize);

    void* AllocBiggerBuffer(BufferIndex bufferIdx, KyUInt32 newMinByteSize = 0);

    void ReleaseAllMemoryBuffer();
    void ReleaseUnusedMemoryBuffer();
    void ReleaseMemory(void* memory) { KY_HEAP_FREE(m_memoryHeap, memory); }

    void InitBuffersToNull();

    BufferIndex TakeUsageOfFirstUnusedBufferIdx();
    void ReleaseBuffer(BufferIndex bufferIdx);

    void* GetBuffer(BufferIndex bufferIdx) const;
    KyUInt32 GetBufferSize(BufferIndex bufferIdx) const;

    KyUInt32 GetTotalAllocatedSize() const;

    // Used by astarQuery
    AStarTraversalContext*            GetOrCreateAStarTraversalContext();
    PathRefinerContext*               GetOrCreatePathRefinerContext();
    PathClamperContext*               GetOrCreatePathClamperContext();
    NavDataChangeIndexInGrid*         GetOrCreateNavDataChangeIndexInGrid();
    ChannelArrayComputer*             GetOrCreateChannelArrayComputer();
    DynamicNavMeshContext*            GetOrCreateDynamicNavMeshContext();
    SpatializedPointCollectorContext* GetOrCreateSpatializedPointCollectorContext();

private:
    void CreateAllPathfinderContexts();
    void  CreateChannelArrayComputer();
    void CreateDynamicNavMeshContext();
    void CreateSpatializedPointCollectorContext();

public:
    MemoryHeap* m_memoryHeap;
    MyLimitHandler m_myLimitHandler;
    KyUInt32 m_granularityOfBufferResize;
    WorkingBuffer m_workingBuffer[BufferIndex_Count];

public:
    AStarTraversalContext* m_astarContext;
    PathRefinerContext* m_refinerContext;
    PathClamperContext* m_clamperContext;
    NavDataChangeIndexInGrid* m_navDataChangeIndexInGrid;
    ChannelArrayComputer* m_channelArrayComputer;

    SpatializedPointCollectorContext* m_collectorContext;

    DynamicNavMeshContext* m_dynamicNavMeshContext;

    Ptr<QueryDynamicOutput> m_queryDynamicOutput; // Do not use the workingMemory but can be used by all queries
};

KY_INLINE void WorkingMemory::ReleaseBuffer(BufferIndex bufferIdx)
{
    KY_ASSERT(bufferIdx < BufferIndex_Count);
    m_workingBuffer[bufferIdx].m_inUse = false;
}
KY_INLINE void* WorkingMemory::GetBuffer(BufferIndex bufferIdx) const
{
    KY_ASSERT(bufferIdx < BufferIndex_Count);
    return m_workingBuffer[bufferIdx].m_memory;
}

KY_INLINE KyUInt32 WorkingMemory::GetBufferSize(BufferIndex bufferIdx) const
{
    KY_ASSERT(bufferIdx < BufferIndex_Count);
    return m_workingBuffer[bufferIdx].m_memorySize;
}


KY_INLINE AStarTraversalContext*    WorkingMemory::GetOrCreateAStarTraversalContext()
{
    if (m_astarContext == nullptr)
        CreateAllPathfinderContexts();
    return m_astarContext;
}
KY_INLINE PathRefinerContext*       WorkingMemory::GetOrCreatePathRefinerContext()
{
    if (m_refinerContext == nullptr)
        CreateAllPathfinderContexts();
    return m_refinerContext;
}
KY_INLINE PathClamperContext*       WorkingMemory::GetOrCreatePathClamperContext()
{
    if (m_clamperContext == nullptr)
        CreateAllPathfinderContexts();
    return m_clamperContext;
}
KY_INLINE NavDataChangeIndexInGrid* WorkingMemory::GetOrCreateNavDataChangeIndexInGrid()
{
    if (m_navDataChangeIndexInGrid == nullptr)
        CreateAllPathfinderContexts();
    return m_navDataChangeIndexInGrid;
}
KY_INLINE ChannelArrayComputer*     WorkingMemory::GetOrCreateChannelArrayComputer()
{
    if (m_channelArrayComputer == nullptr)
        CreateChannelArrayComputer();
    return m_channelArrayComputer;
}
KY_INLINE DynamicNavMeshContext*    WorkingMemory::GetOrCreateDynamicNavMeshContext()
{
    if (m_dynamicNavMeshContext == nullptr)
        CreateDynamicNavMeshContext();
    return m_dynamicNavMeshContext;
}
KY_INLINE SpatializedPointCollectorContext* WorkingMemory::GetOrCreateSpatializedPointCollectorContext()
{
    if (m_collectorContext == nullptr)
        CreateSpatializedPointCollectorContext();
    return m_collectorContext;
}

}