3e3d25a7ec2d9285542fa857888ece7b9356ccfb
[pdfium.git] / core / src / fxcrt / mem_int.h
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4  
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #ifndef _FXM_MEM_INT_H_
8 #define _FXM_MEM_INT_H_
9 struct FX_DefAllocator {
10     IFX_Allocator                       m_Allocator;
11     struct CFX_MemoryMgr*       m_pFoxitMgr;
12 };
13 struct CFX_MemoryMgr {
14 public:
15     FXMEM_SystemMgr*    m_pSystemMgr;
16     FX_DefAllocator             m_DefAllocator;
17     FX_LPVOID                   m_pExternalMemory;
18     FX_BOOL                             m_bReleaseMgr;
19     void                        Init(FXMEM_SystemMgr* pSystemMgr);
20     void*                       Alloc(size_t size, int flags);
21     void*                       AllocDebug(size_t size, int flags, FX_LPCSTR file, int line);
22     void*                       Realloc(void* p, size_t size, int flags);
23     void*                       ReallocDebug(void* p, size_t size, int flags, FX_LPCSTR file, int line);
24     void                        Free(void* p, int flags);
25     void                        PurgeMgr();
26 };
27 extern CFX_MemoryMgr* g_pDefFoxitMgr;
28 #define FIXEDMEM_PAGE_EXTRASPACE                sizeof(size_t)
29 #define FIXEDMEM_BLOCKNUM(bs)                   (8 * (FX_FIXEDMEM_PAGESIZE - FIXEDMEM_PAGE_EXTRASPACE) / (8 * bs + 1))
30 #define FIXEDMEM_8BYTES_BLOCKNUM                FIXEDMEM_BLOCKNUM(8)
31 #define FIXEDMEM_16BYTES_BLOCKNUM               FIXEDMEM_BLOCKNUM(16)
32 #define FIXEDMEM_32BYTES_BLOCKNUM               FIXEDMEM_BLOCKNUM(32)
33 extern const FX_BYTE ZeroLeadPos[256];
34 extern const FX_BYTE OneLeadPos[256];
35 template <size_t blockNum, size_t blockSize>
36 class CFXMEM_FixedPage
37 {
38 public:
39     void                Initialize()
40     {
41         m_nAvailCount = blockNum;
42         FXSYS_memset32(m_BusyMap, 0, (blockNum + 7) / 8);
43     }
44     FX_BOOL             HasFreeBlock() const
45     {
46         return (FX_BOOL)m_nAvailCount;
47     }
48     FX_LPVOID   Alloc(size_t size)
49     {
50         FXSYS_assert(m_nAvailCount);
51         FX_LPDWORD pFind = (FX_LPDWORD)m_BusyMap;
52         size_t i = 0;
53         while (i < (blockNum + 7) / 8 / 4 && pFind[i] == 0xFFFFFFFF) {
54             i ++;
55         }
56         i *= 4;
57         while (m_BusyMap[i] == 0xFF) {
58             i ++;
59         }
60         size_t pos = ZeroLeadPos[m_BusyMap[i]];
61         m_BusyMap[i] |= 1 << (7 - pos);
62         m_nAvailCount --;
63         return (FX_LPBYTE)(this + 1) + (i * 8 + pos) * blockSize;
64     }
65     void                Free(FX_LPVOID p)
66     {
67         FXSYS_assert(p > (FX_LPVOID)this && p < (FX_LPVOID)((FX_LPBYTE)this + FX_FIXEDMEM_PAGESIZE));
68         size_t pos = ((FX_LPBYTE)p - (FX_LPBYTE)(this + 1)) / blockSize;
69         m_BusyMap[pos / 8] &= ~(1 << (7 - (pos % 8)));
70         m_nAvailCount ++;
71     }
72     volatile size_t     m_nAvailCount;
73     FX_BYTE                     m_BusyMap[(blockNum + 7) / 8];
74 };
75 typedef CFXMEM_FixedPage<FIXEDMEM_8BYTES_BLOCKNUM, 8>   CFXMEM_8BytesPage;
76 typedef CFXMEM_FixedPage<FIXEDMEM_16BYTES_BLOCKNUM, 16> CFXMEM_16BytesPage;
77 typedef CFXMEM_FixedPage<FIXEDMEM_32BYTES_BLOCKNUM, 32> CFXMEM_32BytesPage;
78 template <size_t blockNum, size_t blockSize>
79 class CFXMEM_FixedPages
80 {
81 public:
82     typedef CFXMEM_FixedPage<blockNum, blockSize> T;
83     FX_LPBYTE           m_pStartPage;
84     FX_LPBYTE           m_pLimitPos;
85     FX_LPBYTE           m_pCurPage;
86     volatile size_t     m_nAvailBlocks;
87     void                Initialize(FX_LPBYTE pStart, size_t pages)
88     {
89         m_pStartPage = m_pCurPage = pStart;
90         m_nAvailBlocks = pages * blockNum;
91         for (size_t n = 0; n < pages; n ++) {
92             ((T*)pStart)->Initialize();
93             pStart += FX_FIXEDMEM_PAGESIZE;
94         }
95         m_pLimitPos = pStart;
96     }
97     FX_BOOL             IsEmpty() const
98     {
99         return m_nAvailBlocks == (m_pLimitPos - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * blockNum;
100     }
101     FX_BOOL             HasFreeBlock() const
102     {
103         return (FX_BOOL)m_nAvailBlocks;
104     }
105     FX_LPVOID   Alloc(size_t size)
106     {
107         FXSYS_assert(m_nAvailBlocks);
108         do {
109             if (((T*)m_pCurPage)->HasFreeBlock()) {
110                 m_nAvailBlocks --;
111                 return ((T*)m_pCurPage)->Alloc(size);
112             }
113             m_pCurPage += FX_FIXEDMEM_PAGESIZE;
114             if (m_pCurPage == m_pLimitPos) {
115                 m_pCurPage = m_pStartPage;
116             }
117         } while (TRUE);
118         return NULL;
119     }
120     void                Free(FX_LPVOID p)
121     {
122         FXSYS_assert(p > (FX_LPVOID)m_pStartPage && p < (FX_LPVOID)m_pLimitPos);
123         ((T*)(m_pStartPage + ((FX_LPBYTE)p - m_pStartPage) / FX_FIXEDMEM_PAGESIZE * FX_FIXEDMEM_PAGESIZE))->Free(p);
124         m_nAvailBlocks ++;
125     }
126 };
127 typedef CFXMEM_FixedPages<FIXEDMEM_8BYTES_BLOCKNUM, 8>          CFXMEM_8BytesPages;
128 typedef CFXMEM_FixedPages<FIXEDMEM_16BYTES_BLOCKNUM, 16>        CFXMEM_16BytesPages;
129 typedef CFXMEM_FixedPages<FIXEDMEM_32BYTES_BLOCKNUM, 32>        CFXMEM_32BytesPages;
130 class CFXMEM_Block
131 {
132 public:
133     size_t                      m_nBlockSize;
134     CFXMEM_Block*       m_pNextBlock;
135 };
136 class CFXMEM_Page
137 {
138 public:
139     size_t                      m_nAvailSize;
140     CFXMEM_Block*       m_pLimitPos;
141     CFXMEM_Block        m_AvailHead;
142     void                Initialize(size_t size);
143     FX_BOOL             IsEmpty() const
144     {
145         return m_AvailHead.m_pNextBlock && m_AvailHead.m_nBlockSize == m_AvailHead.m_pNextBlock->m_nBlockSize;
146     }
147     FX_LPVOID   Alloc(size_t size);
148     FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
149     void                Free(FX_LPVOID p);
150 protected:
151     FX_LPVOID   Alloc(CFXMEM_Block* pPrevBlock, CFXMEM_Block* pNextBlock, size_t size, size_t oldsize);
152 };
153 class CFXMEM_Pages
154 {
155 public:
156     CFXMEM_Page*        m_pStartPage;
157     CFXMEM_Page*        m_pLimitPos;
158     CFXMEM_Page*        m_pCurPage;
159     size_t                      m_nPageSize;
160     void                Initialize(FX_LPBYTE pStart, size_t pageSize, size_t pages);
161     FX_BOOL             IsEmpty() const;
162     FX_LPVOID   Alloc(size_t size);
163     FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
164     void                Free(FX_LPVOID p);
165 };
166 class CFXMEM_Pool
167 {
168 public:
169     CFXMEM_Pool*                        m_pPrevPool;
170     CFXMEM_Pool*                        m_pNextPool;
171     CFXMEM_8BytesPages          m_8BytesPages;
172     CFXMEM_16BytesPages         m_16BytesPages;
173     CFXMEM_32BytesPages         m_32BytesPages;
174     CFXMEM_Pages                        m_MidPages;
175     FX_BOOL                                     m_bAlone;
176     FX_DWORD                            m_dwReserved[3];
177     FX_LPVOID                           m_pLimitPos;
178     CFXMEM_Page*                        m_pLargePage;
179     void                Initialize(const FX_MEMCONFIG* pMemConfig, size_t size, size_t pageNum8Bytes, size_t pageNum16Bytes, size_t pageNum32Bytes, size_t pageNumMid);
180     FX_BOOL             IsEmpty() const;
181     size_t              GetSize(FX_LPVOID p) const;
182     FX_LPVOID   Realloc(FX_LPVOID p, size_t oldSize, size_t newSize);
183     void                Free(FX_LPVOID p);
184 };
185 class CFXMEM_FixedMgr
186 {
187 public:
188     void                        Initialize(size_t size);
189     FX_LPVOID           Alloc(size_t size);
190     FX_LPVOID           Realloc(FX_LPVOID p, size_t newSize);
191     void                        Free(FX_LPVOID p);
192     void                        FreeAll();
193     void                        Purge();
194     CFXMEM_Pool*        GetFirstPool()
195     {
196         return &m_FirstPool;
197     }
198     size_t                      GetSize(FX_LPVOID p) const;
199     FXMEM_SystemMgr             m_SystemMgr;
200     FXMEM_SystemMgr2*   m_pExtender;
201     FX_LPVOID                   m_pReserved;
202     FX_MEMCONFIG                m_MemConfig;
203 protected:
204     FX_LPVOID           Alloc16(CFXMEM_Pool **pp32Pool = NULL, size_t size = 0);
205     FX_LPVOID           Alloc32(size_t size);
206     FX_LPVOID           AllocSmall(size_t size);
207     FX_LPVOID           AllocMid(size_t size);
208     FX_LPVOID           AllocLarge(size_t size);
209     FX_LPVOID           ReallocSmall(CFXMEM_Pool* pPool, FX_LPVOID p, size_t oldSize, size_t newSize);
210     void                        FreePool(CFXMEM_Pool* pPool);
211     CFXMEM_Pool         m_FirstPool;
212 };
213 #define FIXEDMEM_PROXYSIZE_0    (1024 * 1024 * 8)
214 #define FIXEDMEM_PROXYSIZE_1    (1024 * 1024 * 16)
215 #define FIXEDMEM_PROXYSIZE_2    (1024 * 1024 * 32)
216 #define FIXEDMEM_PROXYSIZE_3    (1024 * 1024 * 64)
217 #define FIXEDMEM_PROXYSIZE_4    (1024 * 1024 * 128)
218 #define FIXEDMEM_PROXYSIZE_5    (1024 * 1024 * 256)
219 const FX_MEMCONFIG*     FixedMgr_GetConfig(size_t nSize);
220 class CFixedMgr_Proxy
221 {
222 public:
223     FXMEM_FoxitMgr*     Initialize(FX_LPVOID pBuffer, size_t nSize, FX_BOOL bExtensible);
224     static FX_BOOL      Common_More(FXMEM_SystemMgr2* pMgr, size_t alloc_size, void** new_memory, size_t* new_size);
225     static void         Common_Free(FXMEM_SystemMgr2* pMgr, void* memory);
226     FXMEM_SystemMgr2    m_SystemMgr;
227     CFXMEM_Page*                m_pFixedPage;
228     FX_LPVOID                   m_pBuffer;
229     size_t                              m_nSize;
230     FX_BOOL                             m_bExtensible;
231 };
232 #endif