From 5110c4743751145c4ae1934cd1d83bc6c55bb43f Mon Sep 17 00:00:00 2001 From: John Abd-El-Malek Date: Sat, 17 May 2014 22:33:34 -0700 Subject: Initial commit. --- core/src/fxcrt/mem_int.h | 232 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 core/src/fxcrt/mem_int.h (limited to 'core/src/fxcrt/mem_int.h') diff --git a/core/src/fxcrt/mem_int.h b/core/src/fxcrt/mem_int.h new file mode 100644 index 0000000000..da43023bb5 --- /dev/null +++ b/core/src/fxcrt/mem_int.h @@ -0,0 +1,232 @@ +// 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 +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 CFXMEM_8BytesPage; +typedef CFXMEM_FixedPage CFXMEM_16BytesPage; +typedef CFXMEM_FixedPage CFXMEM_32BytesPage; +template +class CFXMEM_FixedPages +{ +public: + typedef CFXMEM_FixedPage 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 CFXMEM_8BytesPages; +typedef CFXMEM_FixedPages CFXMEM_16BytesPages; +typedef CFXMEM_FixedPages 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 -- cgit v1.2.3