Remove custom memory manager

core/src/fxcrt/mem_int.h

-// Copyright 2014 PDFium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
- 
-// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
-
-#ifndef _FXM_MEM_INT_H_
-#define _FXM_MEM_INT_H_
-struct FX_DefAllocator {
-    IFX_Allocator                       m_Allocator;
-    struct CFX_MemoryMgr*       m_pFoxitMgr;
-};
-struct CFX_MemoryMgr {
-public:
-    FXMEM_SystemMgr*    m_pSystemMgr;
-    FX_DefAllocator             m_DefAllocator;
-    FX_LPVOID                   m_pExternalMemory;
-    FX_BOOL                             m_bReleaseMgr;
-    void                        Init(FXMEM_SystemMgr* pSystemMgr);
-    void*                       Alloc(size_t size, int flags);
-    void*                       AllocDebug(size_t size, int flags, FX_LPCSTR file, int line);
-    void*                       Realloc(void* p, size_t size, int flags);
-    void*                       ReallocDebug(void* p, size_t size, int flags, FX_LPCSTR file, int line);
-    void                        Free(void* p, int flags);
-    void                        PurgeMgr();
-};
-extern CFX_MemoryMgr* g_pDefFoxitMgr;
-#define FIXEDMEM_PAGE_EXTRASPACE                sizeof(size_t)
-#define FIXEDMEM_BLOCKNUM(bs)                   (8 * (FX_FIXEDMEM_PAGESIZE - FIXEDMEM_PAGE_EXTRASPACE) / (8 * bs + 1))
-#define FIXEDMEM_8BYTES_BLOCKNUM                FIXEDMEM_BLOCKNUM(8)
-#define FIXEDMEM_16BYTES_BLOCKNUM               FIXEDMEM_BLOCKNUM(16)
-#define FIXEDMEM_32BYTES_BLOCKNUM               FIXEDMEM_BLOCKNUM(32)
-extern const FX_BYTE ZeroLeadPos[256];
-extern const FX_BYTE OneLeadPos[256];
-template <size_t blockNum, size_t blockSize>
-class CFXMEM_FixedPage
-{
-public:
-    void                Initialize()
-    {
-        m_nAvailCount = blockNum;
-        FXSYS_memset32(m_BusyMap, 0, (blockNum + 7) / 8);
-    }
-    FX_BOOL             HasFreeBlock() const
-    {
-        return (FX_BOOL)m_nAvailCount;
-    }
-    FX_LPVOID   Alloc(size_t size)
-    {
-        FXSYS_assert(m_nAvailCount);
-        FX_LPDWORD pFind = (FX_LPDWORD)m_BusyMap;
-        size_t i = 0;
-        while (i < (blockNum + 7) / 8 / 4 && pFind[i] == 0xFFFFFFFF) {
-            i ++;
-        }
-        i *= 4;
-        while (m_BusyMap[i] == 0xFF) {
-            i ++;
-        }
-        size_t pos = ZeroLeadPos[m_BusyMap[i]];
-        m_BusyMap[i] |= 1 << (7 - pos);
-        m_nAvailCount --;
-        return (FX_LPBYTE)(this + 1) + (i * 8 + pos) * blockSize;
-    }
-    void                Free(FX_LPVOID p)
-    {
-        FXSYS_assert(p > (FX_LPVOID)this && p < (FX_LPVOID)((FX_LPBYTE)this + FX_FIXEDMEM_PAGESIZE));
-        size_t pos = ((FX_LPBYTE)p - (FX_LPBYTE)(this + 1)) / blockSize;
-        m_BusyMap[pos / 8] &= ~(1 << (7 - (pos % 8)));
-        m_nAvailCount ++;
-    }
-    volatile size_t     m_nAvailCount;
-    FX_BYTE                     m_BusyMap[(blockNum + 7) / 8];
-};
-typedef CFXMEM_FixedPage<FIXEDMEM_8BYTES_BLOCKNUM, 8>   CFXMEM_8BytesPage;
-typedef CFXMEM_FixedPage<FIXEDMEM_16BYTES_BLOCKNUM, 16> CFXMEM_16BytesPage;
-typedef CFXMEM_FixedPage<FIXEDMEM_32BYTES_BLOCKNUM, 32> CFXMEM_32BytesPage;
-template <size_t blockNum, size_t blockSize>
-class CFXMEM_FixedPages
-{
-public:
-    typedef CFXMEM_FixedPage<blockNum, blockSize> T;
-    FX_LPBYTE           m_pStartPage;
-    FX_LPBYTE           m_pLimitPos;
-    FX_LPBYTE           m_pCurPage;
-    volatile size_t     m_nAvailBlocks;
-    void                Initialize(FX_LPBYTE pStart, size_t pages)
-    {
-        m_pStartPage = m_pCurPage = pStart;
-        m_nAvailBlocks = pages * blockNum;
-        for (size_t n = 0; n < pages; n ++) {
-            ((T*)pStart)->Initialize();
-            pStart += FX_FIXEDMEM_PAGESIZE;
-        }
-        m_pLimitPos = pStart;
-    }
-    FX_BOOL             IsEmpty() const
-    {
-        return m_nAvailBlocks == (m_pLimitPos - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * blockNum;
-    }
-    FX_BOOL             HasFreeBlock() const
-    {
-        return (FX_BOOL)m_nAvailBlocks;
-    }
-    FX_LPVOID   Alloc(size_t size)
-    {
-        FXSYS_assert(m_nAvailBlocks);
-        do {
-            if (((T*)m_pCurPage)->HasFreeBlock()) {
-                m_nAvailBlocks --;
-                return ((T*)m_pCurPage)->Alloc(size);
-            }
-            m_pCurPage += FX_FIXEDMEM_PAGESIZE;
-            if (m_pCurPage == m_pLimitPos) {
-                m_pCurPage = m_pStartPage;
-            }
-        } while (TRUE);
-        return NULL;
-    }
-    void                Free(FX_LPVOID p)
-    {
-        FXSYS_assert(p > (FX_LPVOID)m_pStartPage && p < (FX_LPVOID)m_pLimitPos);
-        ((T*)(m_pStartPage + ((FX_LPBYTE)p - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * FX_FIXEDMEM_PAGESIZE))->Free(p);
-        m_nAvailBlocks ++;
-    }
-};
-typedef CFXMEM_FixedPages<FIXEDMEM_8BYTES_BLOCKNUM, 8>          CFXMEM_8BytesPages;
-typedef CFXMEM_FixedPages<FIXEDMEM_16BYTES_BLOCKNUM, 16>        CFXMEM_16BytesPages;
-typedef CFXMEM_FixedPages<FIXEDMEM_32BYTES_BLOCKNUM, 32>        CFXMEM_32BytesPages;
-class CFXMEM_Block
-{
-public:
-    size_t                      m_nBlockSize;
-    CFXMEM_Block*       m_pNextBlock;
-};
-class CFXMEM_Page
-{
-public:
-    size_t                      m_nAvailSize;
-    CFXMEM_Block*       m_pLimitPos;
-    CFXMEM_Block        m_AvailHead;
-    void                Initialize(size_t size);
-    FX_BOOL             IsEmpty() const
-    {
-        return m_AvailHead.m_pNextBlock && m_AvailHead.m_nBlockSize == m_AvailHead.m_pNextBlock->m_nBlockSize;
-    }
-    FX_LPVOID   Alloc(size_t size);
-    FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
-    void                Free(FX_LPVOID p);
-protected:
-    FX_LPVOID   Alloc(CFXMEM_Block* pPrevBlock, CFXMEM_Block* pNextBlock, size_t size, size_t oldsize);
-};
-class CFXMEM_Pages
-{
-public:
-    CFXMEM_Page*        m_pStartPage;
-    CFXMEM_Page*        m_pLimitPos;
-    CFXMEM_Page*        m_pCurPage;
-    size_t                      m_nPageSize;
-    void                Initialize(FX_LPBYTE pStart, size_t pageSize, size_t pages);
-    FX_BOOL             IsEmpty() const;
-    FX_LPVOID   Alloc(size_t size);
-    FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
-    void                Free(FX_LPVOID p);
-};
-class CFXMEM_Pool
-{
-public:
-    CFXMEM_Pool*                        m_pPrevPool;
-    CFXMEM_Pool*                        m_pNextPool;
-    CFXMEM_8BytesPages          m_8BytesPages;
-    CFXMEM_16BytesPages         m_16BytesPages;
-    CFXMEM_32BytesPages         m_32BytesPages;
-    CFXMEM_Pages                        m_MidPages;
-    FX_BOOL                                     m_bAlone;
-    FX_DWORD                            m_dwReserved[3];
-    FX_LPVOID                           m_pLimitPos;
-    CFXMEM_Page*                        m_pLargePage;
-    void                Initialize(const FX_MEMCONFIG* pMemConfig, size_t size, size_t pageNum8Bytes, size_t pageNum16Bytes, size_t pageNum32Bytes, size_t pageNumMid);
-    FX_BOOL             IsEmpty() const;
-    size_t              GetSize(FX_LPVOID p) const;
-    FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
-    void                Free(FX_LPVOID p);
-};
-class CFXMEM_FixedMgr
-{
-public:
-    void                        Initialize(size_t size);
-    FX_LPVOID           Alloc(size_t size);
-    FX_LPVOID           Realloc(FX_LPVOID p, size_t newSize);
-    void                        Free(FX_LPVOID p);
-    void                        FreeAll();
-    void                        Purge();
-    CFXMEM_Pool*        GetFirstPool()
-    {
-        return &m_FirstPool;
-    }
-    size_t                      GetSize(FX_LPVOID p) const;
-    FXMEM_SystemMgr             m_SystemMgr;
-    FXMEM_SystemMgr2*   m_pExtender;
-    FX_LPVOID                   m_pReserved;
-    FX_MEMCONFIG                m_MemConfig;
-protected:
-    FX_LPVOID           Alloc16(CFXMEM_Pool **pp32Pool = NULL, size_t size = 0);
-    FX_LPVOID           Alloc32(size_t size);
-    FX_LPVOID           AllocSmall(size_t size);
-    FX_LPVOID           AllocMid(size_t size);
-    FX_LPVOID           AllocLarge(size_t size);
-    FX_LPVOID           ReallocSmall(CFXMEM_Pool* pPool, FX_LPVOID p, size_t oldSize, size_t newSize);
-    void                        FreePool(CFXMEM_Pool* pPool);
-    CFXMEM_Pool         m_FirstPool;
-};
-#define FIXEDMEM_PROXYSIZE_0    (1024 * 1024 * 8)
-#define FIXEDMEM_PROXYSIZE_1    (1024 * 1024 * 16)
-#define FIXEDMEM_PROXYSIZE_2    (1024 * 1024 * 32)
-#define FIXEDMEM_PROXYSIZE_3    (1024 * 1024 * 64)
-#define FIXEDMEM_PROXYSIZE_4    (1024 * 1024 * 128)
-#define FIXEDMEM_PROXYSIZE_5    (1024 * 1024 * 256)
-const FX_MEMCONFIG*     FixedMgr_GetConfig(size_t nSize);
-class CFixedMgr_Proxy
-{
-public:
-    FXMEM_FoxitMgr*     Initialize(FX_LPVOID pBuffer, size_t nSize, FX_BOOL bExtensible);
-    static FX_BOOL      Common_More(FXMEM_SystemMgr2* pMgr, size_t alloc_size, void** new_memory, size_t* new_size);
-    static void         Common_Free(FXMEM_SystemMgr2* pMgr, void* memory);
-    FXMEM_SystemMgr2    m_SystemMgr;
-    CFXMEM_Page*                m_pFixedPage;
-    FX_LPVOID                   m_pBuffer;
-    size_t                              m_nSize;
-    FX_BOOL                             m_bExtensible;
-};
-#endif