173 lines
8.9 KiB
C++
173 lines
8.9 KiB
C++
#pragma once
|
|
|
|
#include "Scaleform/L/List.h"
|
|
#include "Scaleform/L/Lock.h"
|
|
|
|
namespace Scaleform
|
|
{
|
|
class StatBag;
|
|
class SysAllocPaged;
|
|
class AllocInfo;
|
|
|
|
namespace Heap
|
|
{
|
|
class MemVisitor;
|
|
class SegVisitor;
|
|
}
|
|
|
|
class __declspec(novtable) MemoryHeap :
|
|
public ListNode<MemoryHeap> // 08
|
|
{
|
|
public:
|
|
using ChildListType = List<MemoryHeap>;
|
|
|
|
enum class HeapFlags
|
|
{
|
|
kThreadUnsafe = 0x1,
|
|
kFastTinyBlocks = 0x2,
|
|
kFixedGranularity = 0x4,
|
|
kRoot = 0x8,
|
|
kNoDebugInfo = 0x10,
|
|
kUserDebug = 0x1000
|
|
};
|
|
|
|
enum class RootHeapParameters
|
|
{
|
|
kMinAlign = 0x10,
|
|
kGranularity = 0x4000,
|
|
kReserve = 0x4000,
|
|
kThreshold = 0x40000,
|
|
kLimit = 0x0
|
|
};
|
|
|
|
class HeapDesc
|
|
{
|
|
public:
|
|
// members
|
|
std::uint32_t flags{ 0 }; // 00
|
|
std::size_t minAlign{ 16 }; // 08
|
|
std::size_t granularity{ 8 * 1024 }; // 10
|
|
std::size_t reserve{ 8 * 1024 }; // 18
|
|
std::size_t threshold{ static_cast<std::size_t>(-1) }; // 20
|
|
std::size_t limit{ 0 }; // 28
|
|
std::size_t heapID{ 0 }; // 30
|
|
std::size_t arena{ 0 }; // 38
|
|
};
|
|
static_assert(sizeof(HeapDesc) == 0x40);
|
|
|
|
class HeapInfo
|
|
{
|
|
public:
|
|
// members
|
|
HeapDesc desc; // 00
|
|
MemoryHeap* parent; // 40
|
|
char* name; // 48
|
|
};
|
|
static_assert(sizeof(HeapInfo) == 0x50);
|
|
|
|
class __declspec(novtable) HeapVisitor
|
|
{
|
|
public:
|
|
virtual ~HeapVisitor() = default; // 00
|
|
|
|
// add
|
|
virtual void Visit(MemoryHeap* a_parentHeap, MemoryHeap* a_childHeap) = 0; // 01
|
|
};
|
|
static_assert(sizeof(HeapVisitor) == 0x8);
|
|
|
|
class __declspec(novtable) LimitHandler
|
|
{
|
|
public:
|
|
virtual ~LimitHandler() = default; // 00
|
|
|
|
// add
|
|
virtual bool OnExceedLimit(MemoryHeap* a_heap, std::size_t a_overLimit) = 0; // 01
|
|
virtual void OnFreeSegment(MemoryHeap* a_heap, std::size_t a_freeingSize) = 0; // 02
|
|
};
|
|
static_assert(sizeof(LimitHandler) == 0x8);
|
|
|
|
class __declspec(novtable) HeapTracer
|
|
{
|
|
public:
|
|
virtual ~HeapTracer() = default; // 00
|
|
|
|
// add
|
|
virtual void OnCreateHeap(const MemoryHeap* a_heap) = 0; // 01
|
|
virtual void OnDestroyHeap(const MemoryHeap* a_heap) = 0; // 02
|
|
virtual void OnAlloc(const MemoryHeap* a_heap, std::size_t a_size, std::size_t a_align, std::uint32_t a_sid, const void* a_ptr) = 0; // 03
|
|
virtual void OnRealloc(const MemoryHeap* a_heap, const void* a_oldPtr, std::size_t a_newSize, const void* a_newPtr) = 0; // 04
|
|
virtual void OnFree(const MemoryHeap* a_heap, const void* a_ptr) = 0; // 05
|
|
};
|
|
static_assert(sizeof(HeapTracer) == 0x8);
|
|
|
|
class RootStats
|
|
{
|
|
public:
|
|
// members
|
|
std::size_t sysMemFootprint; // 00
|
|
std::size_t sysMemUsedSpace; // 08
|
|
std::size_t pageMapFootprint; // 10
|
|
std::size_t pageMapUsedSpace; // 18
|
|
std::size_t bookkeepingFootprint; // 20
|
|
std::size_t bookkeepingUsedSpace; // 28
|
|
std::size_t debugInfoFootprint; // 30
|
|
std::size_t debugInfoUsedSpace; // 38
|
|
std::size_t userDebugFootprint; // 40
|
|
std::size_t userDebugUsedSpace; // 48
|
|
};
|
|
static_assert(sizeof(RootStats) == 0x50);
|
|
|
|
virtual ~MemoryHeap() = default; // 00
|
|
|
|
// add
|
|
virtual void CreateArena(std::size_t a_arena, SysAllocPaged* a_sysAlloc) = 0; // 01
|
|
virtual void DestroyArena(std::size_t a_arena) = 0; // 02
|
|
virtual bool ArenaIsEmpty(std::size_t a_arena) = 0; // 03
|
|
virtual MemoryHeap* CreateHeap(const char* a_name, const HeapDesc& a_desc) = 0; // 04
|
|
virtual void SetLimitHandler(LimitHandler* a_handler) = 0; // 05
|
|
virtual void SetLimit(std::size_t a_newLimit) = 0; // 06
|
|
virtual void AddRef() = 0; // 07
|
|
virtual void Release() = 0; // 08
|
|
virtual void* Alloc(std::size_t a_size, const AllocInfo* a_info = nullptr) = 0; // 09
|
|
virtual void* Alloc(std::size_t a_size, std::size_t a_align, const AllocInfo* a_info = nullptr) = 0; // 0A
|
|
virtual void* Realloc(void* a_oldPtr, std::size_t a_newSize) = 0; // 0B
|
|
virtual void Free(void* a_ptr) = 0; // 0C
|
|
virtual void* AllocAutoHeap(const void* a_thisPtr, std::size_t a_size, const AllocInfo* a_info = nullptr) = 0; // 0D
|
|
virtual void* AllocAutoHeap(const void* a_thisPtr, std::size_t a_size, std::size_t a_align, const AllocInfo* a_info = nullptr) = 0; // 0E
|
|
virtual MemoryHeap* GetAllocHeap(const void* a_thisPtr) = 0; // 0F
|
|
virtual std::size_t GetUsableSize(const void* a_ptr) = 0; // 10
|
|
virtual void* AllocSysDirect(std::size_t a_size) = 0; // 11
|
|
virtual void FreeSysDirect(void* a_ptr, std::size_t a_size) = 0; // 12
|
|
virtual bool GetStats(StatBag* a_bag) = 0; // 13
|
|
virtual std::size_t GetFootprint() const = 0; // 14
|
|
virtual std::size_t GetTotalFootprint() const = 0; // 15
|
|
virtual std::size_t GetUsedSpace() const = 0; // 16
|
|
virtual std::size_t GetTotalUsedSpace() const = 0; // 17
|
|
virtual void GetRootStats(RootStats* a_stats) = 0; // 18
|
|
virtual void VisitMem(Heap::MemVisitor* a_visitor, std::uint32_t a_flags) = 0; // 19
|
|
virtual void VisitRootSegments(Heap::SegVisitor* a_visitor) = 0; // 1A
|
|
virtual void VisitHeapSegments(Heap::SegVisitor* a_visitor) const = 0; // 1B
|
|
virtual void SetTracer(HeapTracer* a_tracer) = 0; // 1C
|
|
virtual void DestroyItself() = 0; // 1D
|
|
virtual void UltimateCheck() = 0; // 1E
|
|
virtual void ReleaseCachedMem() = 0; // 1F
|
|
virtual bool DumpMemoryLeaks() = 0; // 20
|
|
virtual void CheckIntegrity() const = 0; // 21
|
|
virtual void GetUserDebugStats(RootStats* a_stats) const = 0; // 22
|
|
|
|
void AssignToCurrentThread() { ownerThreadID = REX::W32::GetCurrentThreadId(); }
|
|
|
|
// members
|
|
std::size_t selfSize; // 18
|
|
volatile std::uint32_t refCount; // 20
|
|
std::size_t ownerThreadID; // 28
|
|
void* autoRelease; // 30
|
|
HeapInfo info; // 38
|
|
ChildListType childHeaps; // 88
|
|
mutable Lock heapLock; // 98
|
|
bool useLocks; // C0
|
|
bool trackDebugInfo; // C1
|
|
};
|
|
static_assert(sizeof(MemoryHeap) == 0xC8);
|
|
}
|