// 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 |