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

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

heap acceleration
File size: 10.9 KB
Line 
1/* $Id: os2heap.cpp,v 1.27 2001-10-12 03:48:06 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
52static HANDLE fhhm_lastHandle = 0;
53static OS2Heap* 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 if(lpMem == NULL) {
238 dprintf(("OS2Heap::Free lpMem == NULL\n"));
239 return(FALSE);
240 }
241 /* verify lpMem address */
242 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
243 {
244 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
245 return FALSE;
246 }
247
248 if(helem->magic != MAGIC_NR_HEAP)
249 {
250 dprintf(("OS2Heap::Free ERROR BAD HEAP POINTER:%X\n", lpMem));
251 return FALSE;
252 }
253
254#ifdef DEBUG1
255 int size = Size(0, lpMem);
256 dprintf(("OS2Heap::Free lpMem = %X, size %d\n", lpMem, size));
257 totalAlloc -= size;
258#endif
259
260 free(helem->lpMem);
261 return(TRUE);
262}
263//******************************************************************************
264//******************************************************************************
265DWORD OS2Heap::Compact(DWORD dwFlags)
266{
267 dprintf(("OS2Heap::Compact, %X- stub\n", dwFlags));
268 return(0);
269}
270//******************************************************************************
271//******************************************************************************
272BOOL OS2Heap::Validate(DWORD dwFlags, LPCVOID lpMem)
273{
274 HEAPELEM *helem = GET_HEAPOBJ(lpMem);
275
276 dprintf(("OS2Heap::Validate, %X %X", dwFlags, lpMem));
277
278 if(lpMem == NULL) {
279 dprintf(("OS2Heap::Validate lpMem == NULL\n"));
280 return(FALSE);
281 }
282 /* verify lpMem address */
283 if (lpMem >= (LPVOID)ulMaxAddr || lpMem < (LPVOID)0x10000)
284 {
285 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
286 return FALSE;
287 }
288
289 if(helem->magic != MAGIC_NR_HEAP)
290 {
291 dprintf(("OS2Heap::Validate BAD HEAP POINTER:%X\n", lpMem));
292 return FALSE;
293 }
294 return(TRUE);
295}
296//******************************************************************************
297//******************************************************************************
298BOOL OS2Heap::Walk(void *lpEntry)
299{
300 dprintf(("OS2Heap::Walk, %X - stub? (TRUE)\n", lpEntry));
301 return(TRUE);
302}
303//******************************************************************************
304//******************************************************************************
305OS2Heap *OS2Heap::find(HANDLE hHeap)
306{
307 // check against cache first
308 if (fhhm_lastHeap)
309 if (hHeap == fhhm_lastHandle)
310 return fhhm_lastHeap;
311
312 OS2Heap *curheap = OS2Heap::heap;
313
314 //@@@PH NT programs seem to assume heap 0 is always valid?!
315 if (hHeap == 0)
316 if (curheap != NULL)
317 {
318 fhhm_lastHandle = hHeap;
319 fhhm_lastHeap = curheap;
320 return curheap;
321 }
322
323 while(curheap != NULL)
324 {
325 if(curheap->hPrimaryHeap == hHeap)
326 {
327 fhhm_lastHandle = hHeap;
328 fhhm_lastHeap = curheap;
329 return(curheap);
330 }
331 curheap = curheap->next;
332 }
333 dprintf(("Heap %X not found!\n", hHeap));
334 fhhm_lastHandle = hHeap;
335 fhhm_lastHeap = NULL;
336 return(NULL);
337}
338//******************************************************************************
339//******************************************************************************
340OS2Heap *OS2Heap::heap = NULL;
341
342//******************************************************************************
343//******************************************************************************
344void * _LNK_CONV getmoreHeapMem(Heap_t pHeap, size_t *size, int *clean)
345{
346 APIRET rc;
347 PVOID newblock;
348
349 dprintf(("KERNEL32: getmoreHeapMem(%08xh, %08xh, %08xh)", pHeap, *size, *clean));
350
351 /* round the size up to a multiple of 64K */
352 //NOTE: MUST use 64kb here or else we are at risk of running out of virtual
353 // memory space. (when allocating 4kb we actually get 4kb + 60k uncommited)
354 *size = (*size / 65536) * 65536 + 65536;
355
356 rc = DosAllocMem(&newblock, *size, PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);
357//// rc = DosAllocMem(&newblock, *size, flAllocMem|PAG_READ|PAG_WRITE|PAG_COMMIT|PAG_EXECUTE);
358 if(rc != 0) {
359 dprintf(("getmoreHeapMem: DosAllocMem failed with %d", rc));
360 return FALSE;
361 }
362 *clean = _BLOCK_CLEAN;
363 dprintf(("KERNEL32: getmoreHeapMem %x %d", newblock, *size));
364 return newblock;
365}
366//******************************************************************************
367//******************************************************************************
368void _LNK_CONV releaseHeapMem(Heap_t pHeap, void *block, size_t size)
369{
370 dprintf(("KERNEL32: releaseHeapMem %x %x %d", pHeap, block, size));
371 DosFreeMem(block);
372}
373//******************************************************************************
374//******************************************************************************
Note: See TracBrowser for help on using the repository browser.