source: trunk/src/kernel32/os2heap.cpp@ 7358

Last change on this file since 7358 was 7358, checked in by phaller, 24 years ago

Heap acceleration
File size: 10.8 KB
Line 
1/* $Id: os2heap.cpp,v 1.30 2001-11-16 12:57:00 phaller Exp $ */
2
3/*
4 * Heap class for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
7 *
8 *
9 * NOTE: ReAlloc allocates memory using Alloc if memory pointer == NULL
10 * WINE controls depend on this, even though it apparently
11 * doesn't work like this in Windows.
12 *
13 * Project Odin Software License can be found in LICENSE.TXT
14 *
15 */
16#define INCL_DOSMEMMGR
17#define INCL_DOSSEMAPHORES
18#define INCL_DOSERRORS
19#include <os2wrap.h> //Odin32 OS/2 api wrappers
20#include <stdlib.h>
21#include <string.h>
22#include <umalloc.h>
23
24#include "win32type.h"
25#include "os2heap.h"
26#include "misc.h"
27#include "vmutex.h"
28#include "initterm.h"
29#include <odin32validate.h>
30
31#define DBG_LOCALLOG DBG_os2heap
32#include "dbglocal.h"
33
34#ifndef HEAP_NO_SERIALIZE
35 #define HEAP_NO_SERIALIZE 1
36#endif
37
38#ifndef HEAP_ZERO_MEMORY
39 #define HEAP_ZERO_MEMORY 8
40#endif
41
42VMutex heaplistmutex; //protects linked lists of heaps
43
44void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean);
45void _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size);
46
47
48//******************************************************************************
49// Fast Heap Handle Management
50//******************************************************************************
51
52HANDLE fhhm_lastHandle = 0;
53OS2Heap* fhhm_lastHeap = NULL;
54
55
56//******************************************************************************
57//******************************************************************************
58OS2Heap::OS2Heap(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize)
59{
60 OS2Heap *curheap = OS2Heap::heap;
61
62 totalAlloc = 0;
63 fInitialized = 0;
64 nrHeaps = 0;
65 heapelem = NULL;
66
67 dwInitialSize = (dwInitialSize >= 0x4000) ? dwInitialSize : 0x4000;
68
69 this->dwMaximumSize = dwMaximumSize;
70 this->dwInitialSize = dwInitialSize;
71 this->flOptions = flOptions;
72
73 heaplistmutex.enter();
74 if(curheap != NULL) {
75 while(curheap->next != NULL) {
76 curheap = curheap->next;
77 }
78 curheap->next = this;
79 }
80 else heap = this;
81 next = NULL;
82
83 heaplistmutex.leave();
84
85 APIRET rc;
86
87 rc = DosAllocMem((PPVOID)&pInitialHeapMem, dwInitialSize, PAG_READ|PAG_WRITE|PAG_COMMIT);
88 if(rc != 0) {
89 dprintf(("OS2Heap::OS2Heap: DosAllocSharedMem failed with %d", rc));
90 DebugInt3();
91 }
92 uheap = _ucreate(pInitialHeapMem, dwInitialSize, _BLOCK_CLEAN,
93 _HEAP_REGULAR, getmoreHeapMem, releaseHeapMem);
94 if(uheap == NULL) {
95 DosFreeMem(pInitialHeapMem);
96 pInitialHeapMem = NULL;
97 dprintf(("OS2Heap::OS2Heap: _ucreate failed!"));
98 DebugInt3();
99 }
100 hPrimaryHeap = (HANDLE)uheap;
101 dprintf(("KERNEL32: HeapCreate: initial size %d, max size %d (flags %X) returned %X\n", dwInitialSize, dwMaximumSize, flOptions, hPrimaryHeap));
102}
103//******************************************************************************
104//******************************************************************************
105OS2Heap::~OS2Heap()
106{
107 OS2Heap *curheap = OS2Heap::heap;
108 int i;
109
110 // invalidate handle cache
111 fhhm_lastHandle = 0;
112 fhhm_lastHeap = NULL;
113
114
115 dprintf(("dtr OS2Heap, hPrimaryHeap = %X\n", hPrimaryHeap));
116
117 heaplistmutex.enter();
118 if(heap == this) {
119 heap = next;
120 }
121 else {
122 while(curheap->next != NULL) {
123 if(curheap->next == this) {
124 curheap->next = next;
125 break;
126 }
127 curheap = curheap->next;
128 }
129 }
130 heaplistmutex.leave();
131
132 if(uheap) {
133 _uclose(uheap);
134 _udestroy(uheap, _FORCE);
135 uheap = NULL;
136 }
137 if(pInitialHeapMem) {
138 DosFreeMem(pInitialHeapMem);
139 pInitialHeapMem = NULL;
140 }
141
142 dprintf(("dtr OS2Heap, hPrimaryHeap = %X done\n", hPrimaryHeap));
143}
144//******************************************************************************
145//******************************************************************************
146LPVOID OS2Heap::Alloc(DWORD dwFlags, DWORD dwBytes)
147{
148 HEAPELEM *lpHeapObj;
149 LPVOID lpMem;
150
151// dprintf(("OS2Heap::Alloc\n"));
152 lpMem = _umalloc(uheap, dwBytes + HEAP_OVERHEAD);
153 if(lpMem == NULL) {
154 dprintf(("OS2Heap::Alloc, lpMem == NULL"));
155 return(NULL);
156 }
157 if(dwFlags & HEAP_ZERO_MEMORY) {
158 memset(lpMem, 0, dwBytes+HEAP_OVERHEAD);
159 }
160 totalAlloc += dwBytes;
161
162 //align at 8 byte boundary
163 lpHeapObj = (HEAPELEM *)(((ULONG)lpMem+7) & ~7);
164 lpHeapObj->lpMem = lpMem;
165 lpHeapObj->magic = MAGIC_NR_HEAP;
166
167 return(LPVOID)(lpHeapObj+1);
168}
169//******************************************************************************
170//******************************************************************************
171DWORD OS2Heap::Size(DWORD dwFlags, PVOID lpMem)
172{
173 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
174
175 if(lpMem == NULL) {
176 dprintf(("OS2Heap::Size lpMem == NULL\n"));
177 return -1;
178 }
179 /* verify lpMem address */
180 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
181 {
182 dprintf(("OS2Heap::Size ERROR BAD HEAP POINTER:%X\n", lpMem));
183 return -1;
184 }
185
186 if(helem->magic != MAGIC_NR_HEAP)
187 {
188 dprintf(("OS2Heap::Size ERROR BAD HEAP POINTER:%X\n", lpMem));
189 return -1;
190 }
191
192 return(_msize(helem->lpMem) - HEAP_OVERHEAD);
193}
194//******************************************************************************
195//******************************************************************************
196LPVOID OS2Heap::ReAlloc(DWORD dwFlags, LPVOID lpMem, DWORD dwBytes)
197{
198 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
199 LPVOID lpNewMem;
200 int i, oldSize;
201
202 if (dwBytes == 0) return NULL; // intercept stupid parameters
203
204 //NOTE: Allocate memory using Alloc -> WINE controls depend on this, even
205 // though it apparently doesn't work in Windows.
206 if (lpMem == 0) return Alloc(dwFlags, dwBytes);
207// if (lpMem == 0) return NULL;
208
209 if (helem->magic != MAGIC_NR_HEAP)
210 {
211 dprintf(("OS2Heap::ReAlloc ERROR BAD HEAP POINTER:%X\n", lpMem));
212 return lpMem;
213 }
214
215 oldSize = Size(0,lpMem);
216 if (oldSize >= dwBytes) {
217 dprintf(("ReAlloc with smaller size than original (%d); return old pointer", oldSize));
218 return lpMem; // if reallocation with same size don't do anything
219 }
220 lpNewMem = Alloc(dwFlags, dwBytes);
221 memcpy(lpNewMem, lpMem, dwBytes < oldSize ? dwBytes : oldSize);
222 Free(0, lpMem);
223
224 if(lpNewMem == NULL)
225 {
226 dprintf(("OS2Heap::ReAlloc, no more memory left\n"));
227 }
228
229 return(lpNewMem);
230}
231//******************************************************************************
232//******************************************************************************
233BOOL OS2Heap::Free(DWORD dwFlags, LPVOID lpMem)
234{
235 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
236
237 /* verify lpMem address */
238 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
239 {
240 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
241 return FALSE;
242 }
243
244 if(helem->magic != MAGIC_NR_HEAP)
245 {
246 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
247 return FALSE;
248 }
249
250#ifdef DEBUG1
251 int size = Size(0, lpMem);
252 dprintf(("OS2Heap::Free lpMem = %X, size %d\n", lpMem, size));
253 totalAlloc -= size;
254#endif
255
256 free(helem->lpMem);
257 return(TRUE);
258}
259//******************************************************************************
260//******************************************************************************
261DWORD OS2Heap::Compact(DWORD dwFlags)
262{
263 dprintf(("OS2Heap::Compact, %X- stub\n", dwFlags));
264 return(0);
265}
266//******************************************************************************
267//******************************************************************************
268BOOL OS2Heap::Validate(DWORD dwFlags, LPCVOID lpMem)
269{
270 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
271
272 dprintf(("OS2Heap::Validate, %X %X", dwFlags, lpMem));
273
274 if(lpMem == NULL) {
275 dprintf(("OS2Heap::Validate lpMem == NULL\n"));
276 return(FALSE);
277 }
278 /* verify lpMem address */
279 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
280 {
281 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
282 return FALSE;
283 }
284
285 if(helem->magic != MAGIC_NR_HEAP)
286 {
287 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
288 return FALSE;
289 }
290 return(TRUE);
291}
292//******************************************************************************
293//******************************************************************************
294BOOL OS2Heap::Walk(void *lpEntry)
295{
296 dprintf(("OS2Heap::Walk, %X - stub? (TRUE)\n", lpEntry));
297 return(TRUE);
298}
299//******************************************************************************
300//******************************************************************************
301OS2Heap *OS2Heap::find(HANDLE hHeap)
302{
303/* PH moved to inlineable macro ...
304 * // check against cache first
305 * if (fhhm_lastHeap)
306 * if (hHeap == fhhm_lastHandle)
307 * {
308 * return fhhm_lastHeap;
309 * }
310 *
311 */
312
313 OS2Heap *curheap = OS2Heap::heap;
314
315 //@@@PH NT programs seem to assume heap 0 is always valid?!
316 if (hHeap == 0)
317 if (curheap != NULL)
318 {
319 fhhm_lastHandle = hHeap;
320 fhhm_lastHeap = curheap;
321 return curheap;
322 }
323
324 while(curheap != NULL)
325 {
326 if(curheap->hPrimaryHeap == hHeap)
327 {
328 fhhm_lastHandle = hHeap;
329 fhhm_lastHeap = curheap;
330 return(curheap);
331 }
332 curheap = curheap->next;
333 }
334 dprintf(("Heap %X not found!\n", hHeap));
335 fhhm_lastHandle = hHeap;
336 fhhm_lastHeap = NULL;
337 return(NULL);
338}
339//******************************************************************************
340//******************************************************************************
341OS2Heap *OS2Heap::heap = NULL;
342
343//******************************************************************************
344//******************************************************************************
345void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean)
346{
347 APIRET rc;
348 PVOID newblock;
349
350 dprintf(("KERNEL32: getmoreHeapMem(%08xh, %08xh, %08xh)", pHeap, *size, *clean));
351
352 /* round the size up to a multiple of 64K */
353 //NOTE: MUST use 64kb here or else we are at risk of running out of virtual
354 // memory space. (when allocating 4kb we actually get 4kb + 60k uncommited)
355 *size = (*size / 65536) * 65536 + 65536;
356
357 rc = DosAllocMem(&newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);
358//// rc = DosAllocMem(&newblock, *size, flAllocMem|PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);
359 if(rc != 0) {
360 dprintf(("getmoreHeapMem: DosAllocMem failed with %d", rc));
361 return FALSE;
362 }
363 *clean = _BLOCK_CLEAN;
364 dprintf(("KERNEL32: getmoreHeapMem %x %d", newblock, *size));
365 return newblock;
366}
367//******************************************************************************
368//******************************************************************************
369void _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size)
370{
371 dprintf(("KERNEL32: releaseHeapMem %x %x %d", pHeap, block, size));
372 DosFreeMem(block);
373}
374//******************************************************************************
375//******************************************************************************
Note: See TracBrowser for help on using the repository browser.