BVB Source Codes

CRYENGINE Show ControllerDefragHeap.h Source code

Return Download CRYENGINE: download ControllerDefragHeap.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #pragma once
  4.  
  5. class IControllerRelocatableChain;
  6.  
  7. class CControllerDefragHdl
  8. {
  9. public:
  10.         CControllerDefragHdl()
  11.                 : m_hdlAndFlags(0)
  12.         {
  13.         }
  14.  
  15.         explicit CControllerDefragHdl(void* pFixed)
  16.                 : m_hdlAndFlags((UINT_PTR)pFixed)
  17.         {
  18.         }
  19.  
  20.         explicit CControllerDefragHdl(IDefragAllocator::Hdl hdl)
  21.                 : m_hdlAndFlags((hdl << 1) | IsHandleMask)
  22.         {
  23.         }
  24.  
  25.         bool                  IsFixed() const { return (m_hdlAndFlags & IsHandleMask) == 0; }
  26.         IDefragAllocator::Hdl AsHdl() const   { return (IDefragAllocator::Hdl)(m_hdlAndFlags >> 1); }
  27.         void*                 AsFixed() const { return (void*)m_hdlAndFlags; }
  28.  
  29.         bool                  IsValid() const { return m_hdlAndFlags != 0; }
  30.  
  31.         friend bool           operator==(CControllerDefragHdl a, CControllerDefragHdl b)
  32.         {
  33.                 return a.m_hdlAndFlags == b.m_hdlAndFlags;
  34.         }
  35.  
  36.         friend bool operator!=(CControllerDefragHdl a, CControllerDefragHdl b)
  37.         {
  38.                 return a.m_hdlAndFlags != b.m_hdlAndFlags;
  39.         }
  40.  
  41. private:
  42.         enum
  43.         {
  44.                 IsHandleMask = 0x1
  45.         };
  46.  
  47. private:
  48.         UINT_PTR m_hdlAndFlags;
  49. };
  50.  
  51. class CControllerDefragHeap : private IDefragAllocatorPolicy
  52. {
  53. public:
  54.         struct Stats
  55.         {
  56.                 IDefragAllocatorStats defragStats;
  57.                 size_t                bytesInFixedAllocs;
  58.         };
  59.  
  60. public:
  61.         CControllerDefragHeap();
  62.         ~CControllerDefragHeap();
  63.  
  64.         void                 Init(size_t capacity);
  65.         bool                 IsInitialised() const { return m_pAddressRange != NULL; }
  66.  
  67.         Stats                GetStats();
  68.  
  69.         void                 Update();
  70.  
  71.         CControllerDefragHdl AllocPinned(size_t sz, IControllerRelocatableChain* pContext);
  72.         void                 Free(CControllerDefragHdl hdl);
  73.  
  74.         void                 ChangeContext(CControllerDefragHdl hdl, IControllerRelocatableChain* pContext)
  75.         {
  76.                 if (!hdl.IsFixed())
  77.                         m_pAllocator->ChangeContext(hdl.AsHdl(), pContext);
  78.         }
  79.  
  80.         size_t UsableSize(CControllerDefragHdl hdl);
  81.  
  82.         void*  WeakPin(CControllerDefragHdl hdl)
  83.         {
  84.                 if (!hdl.IsFixed())
  85.                         return m_pBaseAddress + m_pAllocator->WeakPin(hdl.AsHdl());
  86.                 else
  87.                         return hdl.AsFixed();
  88.         }
  89.  
  90.         void* Pin(CControllerDefragHdl hdl)
  91.         {
  92.                 if (!hdl.IsFixed())
  93.                         return m_pBaseAddress + m_pAllocator->Pin(hdl.AsHdl());
  94.                 else
  95.                         return hdl.AsFixed();
  96.         }
  97.  
  98.         void Unpin(CControllerDefragHdl hdl)
  99.         {
  100.                 if (!hdl.IsFixed())
  101.                         m_pAllocator->Unpin(hdl.AsHdl());
  102.         }
  103.  
  104. private:
  105.         union FixedHdr
  106.         {
  107.                 char pad[16];
  108.                 struct
  109.                 {
  110.                         uint32 size;
  111.                         bool   bFromGPH;
  112.                 };
  113.         };
  114.  
  115.         struct Copy
  116.         {
  117.                 Copy()
  118.                 {
  119.                         memset(this, 0, sizeof(*this));
  120.                 }
  121.  
  122.                 Copy(void* pContext, UINT_PTR dstOffset, UINT_PTR srcOffset, UINT_PTR size, IDefragAllocatorCopyNotification* pNotification)
  123.                         : inUse(true)
  124.                         , pContext(pContext)
  125.                         , dstOffset(dstOffset)
  126.                         , srcOffset(srcOffset)
  127.                         , size(size)
  128.                         , pNotification(pNotification)
  129.                         , jobState(-1)
  130.                         , relocateFrameId(0)
  131.                         , cancelled(false)
  132.                         , relocated(false)
  133.                 {
  134.                 }
  135.  
  136.                 bool                              inUse;
  137.  
  138.                 void*                             pContext;
  139.                 UINT_PTR                          dstOffset;
  140.                 UINT_PTR                          srcOffset;
  141.                 UINT_PTR                          size;
  142.                 IDefragAllocatorCopyNotification* pNotification;
  143.  
  144.                 volatile int                      jobState;
  145.                 uint32                            relocateFrameId;
  146.                 bool                              cancelled;
  147.                 bool                              relocated;
  148.         };
  149.  
  150.         enum
  151.         {
  152.                 CompletionLatencyFrames     = 2,
  153.                 MaxInFlightCopies           = 32,
  154.                 MaxScheduledCopiesPerUpdate = 4,
  155.                 MaxScheduledBytesPerUpdate  = 128 * 1024,
  156.                 MinJobCopySize              = 4096,
  157.                 MinFixedAllocSize           = 384 * 1024,
  158.                 MinAlignment                = 16,
  159.                 MaxAllocs                   = 4 * 1024,
  160.                 AllowGPHFallback            = 1,
  161.         };
  162.  
  163. private:
  164.         virtual uint32 BeginCopy(void* pContext, UINT_PTR dstOffset, UINT_PTR srcOffset, UINT_PTR size, IDefragAllocatorCopyNotification* pNotification);
  165.         virtual void   Relocate(uint32 userMoveId, void* pContext, UINT_PTR newOffset, UINT_PTR oldOffset, UINT_PTR size);
  166.         virtual void   CancelCopy(uint32 userMoveId, void* pContext, bool bSync);
  167.  
  168.         virtual void   SyncCopy(void* pContext, UINT_PTR dstOffset, UINT_PTR srcOffset, UINT_PTR size);
  169.  
  170. private:
  171.         CControllerDefragHeap(const CControllerDefragHeap&);
  172.         CControllerDefragHeap& operator=(const CControllerDefragHeap&);
  173.  
  174. private:
  175.         bool  IncreaseRange(UINT_PTR offs, UINT_PTR sz);
  176.         void  DecreaseRange(UINT_PTR offs, UINT_PTR sz);
  177.         void  DecreaseRange_Locked(UINT_PTR offs, UINT_PTR sz);
  178.  
  179.         void* FixedAlloc(size_t sz, bool bFromGPH);
  180.         void  FixedFree(void* p);
  181.  
  182.         void  UpdateInflight(int frameId);
  183.  
  184. private:
  185.         IMemoryAddressRange*           m_pAddressRange;
  186.         IDefragAllocator*              m_pAllocator;
  187.  
  188.         char*                          m_pBaseAddress;
  189.         uint32                         m_nPageSize;
  190.         uint32                         m_nLogPageSize;
  191.  
  192.         CryCriticalSectionNonRecursive m_pagesLock;
  193.         std::vector<int>               m_numAllocsPerPage;
  194.  
  195.         volatile int                   m_nBytesInFixedAllocs;
  196.  
  197.         Copy                           m_copiesInFlight[MaxInFlightCopies];
  198.         size_t                         m_numAvailableCopiesInFlight;
  199.         size_t                         m_bytesInFlight;
  200.         int                            m_tickId;
  201.         uint32                         m_nLastCopyIdx;
  202.  
  203.         CryCriticalSectionNonRecursive m_queuedCancelLock;
  204.         int                            m_numQueuedCancels;
  205.         uint32                         m_queuedCancels[MaxInFlightCopies];
  206. };
  207.  
downloadControllerDefragHeap.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top