0024010: Voxel_DS: getting the origin point of a voxel
[occt.git] / src / Standard / Standard_MMgrOpt.cxx
CommitLineData
b311480e 1// Created on: 2005-03-15
2// Created by: Peter KURNEV
3// Copyright (c) 2005-2012 OPEN CASCADE SAS
4//
5// The content of this file is subject to the Open CASCADE Technology Public
6// License Version 6.5 (the "License"). You may not use the content of this file
7// except in compliance with the License. Please obtain a copy of the License
8// at http://www.opencascade.org and read it completely before using this file.
9//
10// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12//
13// The Original Code and all software distributed under the License is
14// distributed on an "AS IS" basis, without warranty of any kind, and the
15// Initial Developer hereby disclaims all such warranties, including without
16// limitation, any warranties of merchantability, fitness for a particular
17// purpose or non-infringement. Please see the License for the specific terms
18// and conditions governing the rights and limitations under the License.
19
7fd59977 20
21#include <Standard_MMgrOpt.hxx>
22#include <Standard_OutOfMemory.hxx>
23
7fd59977 24#ifdef HAVE_CONFIG_H
25# include <config.h>
26#endif
27
28#include <stdio.h>
29
30#ifdef HAVE_STRING_H
31# include <string.h>
32#endif
33
34#ifndef WNT
35# include <stdlib.h>
36# include <errno.h>
37#endif
38
39#ifdef WNT
40#include <windows.h>
41#else
42# ifdef HAVE_UNISTD_H
43# include <unistd.h>
44# endif
45# ifdef HAVE_SYS_MMAN_H
46# include <sys/mman.h> /* mmap() */
47# endif
48#endif
49#ifdef HAVE_MALLOC_H
50# include <malloc.h>
51#endif
52#include <stdlib.h>
53#include <sys/types.h>
54#include <sys/stat.h>
55#include <fcntl.h>
56//
57#if defined (__sun) || defined(SOLARIS)
58extern "C" int getpagesize() ;
59#endif
60
61//======================================================================
62// Assumptions
63//======================================================================
64
65// This implementation makes a number of assumptions regarding size of
66// types:
67//
68// sizeof(Standard_Size) == sizeof(Standard_Address==void*)
69//
70// On WNT, sizeof(HANDLE) is equal of multiple of sizeof(Standard_Size)
71
72//======================================================================
73// Naming conventions
74//======================================================================
75
76// For clarity of implementation, the following conventions are used
77// for naming variables:
78//
79// ...Size: size in bytes
80//
81// RoundSize, RSize etc.: size in bytes, rounded according to allocation granularity
82//
83// ...SizeN: size counted in number of items of sizeof(Standard_Size) bytes each
84//
85// ...Storage: address of the user area of the memory block (Standard_Address)
86//
87// ...Block: address of the hole memory block (header) (Standard_Size*)
88
89//======================================================================
90// Macro definitions
91//======================================================================
92
93//
94// MMAP_BASE_ADDRESS, MMAP_FLAGS
95#if defined (__hpux) || defined(HPUX)
96#define MMAP_BASE_ADDRESS 0x80000000
97#define MMAP_FLAGS (MAP_ANONYMOUS | MAP_PRIVATE | MAP_VARIABLE)
98#elif defined (__osf__) || defined(DECOSF1)
99#define MMAP_BASE_ADDRESS 0x1000000000
100#define MMAP_FLAGS (MAP_ANONYMOUS | MAP_PRIVATE | MAP_VARIABLE)
101#elif defined(_AIX)
102#define MMAP_BASE_ADDRESS 0x80000000
103#define MMAP_FLAGS (MAP_ANONYMOUS | MAP_PRIVATE | MAP_VARIABLE)
104#elif defined(__APPLE__)
105#define MMAP_BASE_ADDRESS 0x80000000
106#define MMAP_FLAGS (MAP_ANON | MAP_PRIVATE)
107#elif defined(LIN)
108#define MMAP_BASE_ADDRESS 0x20000000
109#define MMAP_FLAGS (MAP_PRIVATE)
110#elif defined(WNT)
111//static HANDLE myhMap;
112#else
113#define MMAP_BASE_ADDRESS 0x60000000
114#define MMAP_FLAGS (MAP_PRIVATE)
115#endif
116
117// Round size up to the specified page size
118#define PAGE_ALIGN(size,thePageSize) \
119 (((size) + (thePageSize) - 1) & ~((thePageSize) - 1))
120
121// Round size up to 4, 8, or 16 bytes
122// Note that 0 yields 0
123#define ROUNDUP16(size) (((size) + 0xf) & ~(Standard_Size)0xf)
124#define ROUNDUP8(size) (((size) + 0x7) & ~(Standard_Size)0x7)
125#define ROUNDUP4(size) (((size) + 0x3) & ~(Standard_Size)0x3)
126#define ROUNDDOWN8(size) ((size) & ~(Standard_Size)0x7)
127
128// The following two macros define granularity of memory allocation,
129// by rounding size to the size of the allocation cell,
130// and obtaining cell index from rounded size.
131// Note that granularity shall be not less than sizeof(Standard_Size)
132
133// Traditional implementation: granularity 16 bytes
134//#define ROUNDUP_CELL(size) ROUNDUP16(size)
135//#define INDEX_CELL(rsize) ((rsize) >> 4)
136
137// Reduced granularity: 8 bytes
138#define ROUNDUP_CELL(size) ROUNDUP8(size)
139#define ROUNDDOWN_CELL(size) ROUNDDOWN8(size)
140#define INDEX_CELL(rsize) ((rsize) >> 3)
141
142// Minimal granularity: 4 bytes (32-bit systems only)
143#ifndef _OCC64
144//#define ROUNDUP_CELL(size) ROUNDUP4(size)
145//#define INDEX_CELL(rsize) ((rsize) >> 2)
146#endif
147
148// Adaptive granularity, less for little blocks and greater for bigger ones:
149/*
150#if _OCC64
151#define ROUNDUP_CELL(size) ((size) <= 0x40 ? ROUNDUP8(size) : ROUNDUP16(size))
152#define INDEX_CELL(rsize) ((rsize) <= 0x40 ? ((rsize) >> 3) : (4 + ((rsize) >> 4)))
153#else
154#define ROUNDUP_CELL(size) ((size) <= 0x40 ? ROUNDUP4(size) : ROUNDUP8(size))
155#define INDEX_CELL(rsize) ((rsize) <= 0x40 ? ((rsize) >> 2) : (8 + ((rsize) >> 3)))
156#endif
157*/
158
159
160/* In the allocated block, first bytes are used for storing of memory manager's data.
161 (size of block). The minimal size of these data is sizeof(int).
162 The memory allocated in system usually alligned by 16 bytes.Tthe aligment of the
163 data area in the memory block is shfted on BLOCK_SHIFT*sizeof(Standard_Size)
164 bytes.
165 It is OK for WNT, SUN and Linux systems, but on SGI aligment should be 8 bytes.
166 So, BLOCK_SHIFT is formed as macro for support on other possible platforms.
167*/
168
169#if defined(IRIX) || defined(SOLARIS)
170#define BLOCK_SHIFT 2
171#else
172#define BLOCK_SHIFT 1
173#endif
174
175// Get address of user area from block address, and vice-versa
176#define GET_USER(block) (((Standard_Size*)(block)) + BLOCK_SHIFT)
177#define GET_BLOCK(storage) (((Standard_Size*)(storage))-BLOCK_SHIFT)
178
179// create static instance of out-of-memory exception to protect
180// against possible lack of memory for its raising
181static Handle(Standard_OutOfMemory) anOutOfMemError = new Standard_OutOfMemory;
182
183//=======================================================================
184//function : Standard_MMgr
185//purpose :
186//=======================================================================
187
188Standard_MMgrOpt::Standard_MMgrOpt(const Standard_Boolean aClear,
189 const Standard_Boolean aMMap,
190 const Standard_Size aCellSize,
191 const Standard_Integer aNbPages,
192 const Standard_Size aThreshold,
193 const Standard_Boolean isReentrant)
194{
195 // check basic assumption
196 if ( sizeof(Standard_Size) != sizeof(Standard_Address) )
197 {
198 cerr << "Fatal error: Open CASCADE Optimized Memory manager: this platform is not supported!" << endl;
199 exit(1);
200 }
201
202 // clear buffer fields
203 myFreeListMax = 0;
204 myFreeList = NULL;
205 myPageSize = 0;
206 myAllocList = NULL;
207 myNextAddr = NULL;
208 myEndBlock = NULL;
209
210 // initialize parameters
211 myClear = aClear;
212 myMMap = (Standard_Integer)aMMap;
213 myCellSize = aCellSize;
214 myNbPages = aNbPages;
215 myThreshold = aThreshold;
216 myReentrant = isReentrant;
217
218 // initialize
219 Initialize();
220}
221
222//=======================================================================
223//function : ~Standard_MMgrOpt
224//purpose :
225//=======================================================================
226
227Standard_MMgrOpt::~Standard_MMgrOpt()
228{
229 Purge(Standard_True);
230 free(myFreeList);
231
232 // NOTE: freeing pools may be dangerous if not all memory taken by
233 // this instance of the memory manager has been freed
234 FreePools();
235}
236
237// interface level
238
239//=======================================================================
240//function : Initialize
241//purpose :
242//=======================================================================
243
244void Standard_MMgrOpt::Initialize()
245{
246 // check number of pages in small blocks pools
247 if ( myNbPages < 100 )
248 myNbPages = 1000;
249
250 // get system-dependent page size
251#ifndef WNT
252 myPageSize = getpagesize();
253 if ( ! myPageSize )
254 myMMap = 0;
255#else
256 SYSTEM_INFO SystemInfo;
257 GetSystemInfo (&SystemInfo);
258 myPageSize = SystemInfo.dwPageSize;
259#endif
260
261 // initialize memory mapped files
262 if(myMMap) {
263#if defined (__sgi) || defined(IRIX)
264 /* Probleme de conflit en la zone des malloc et la zone des mmap sur SGI */
265 /* Ce probleme a ete identifie en IRIX 5.3 jusqu'en IRIX 6.2. Le probleme */
266 /* ne semble pas apparaitre en IRIX 6.4 */
267 /* Les malloc successifs donnent des adresses croissantes (a partir de 0x0x10000000) */
268 /* ce que l'on appelle le pointeur de BREAK */
269 /* Le premier mmap est force a l'addresse MMAP_BASE_ADDRESS (soit 0x60000000 sur SGI) */
270 /* mais les mmap suivants sont decides par le systeme (flag MAP_VARIABLE). Malheureusement */
271 /* il renvoie une addresse la plus basse possible dans la zone des malloc juste au dessus */
272 /* du BREAK soit 0x18640000 ce qui donne un espace d'allocation d'environ 140 Mo pour les */
273 /* malloc. Sur des gros modeles on peut avoir des pointes a 680 Mo en Rev6 pour une maquette */
274 /* de 2 000 000 de points. En Rev7, la meme maquette n'excedera pas 286 Mo (voir vision.for) */
275 /* Pour palier ce comportement, la solution adoptee est la suivante : */
276 /* Lorsque l'on entre dans alloc_startup (ici), on n'a pas encore fait de mmap. */
277 /* On fait alors un malloc (d'environ 700Mo) que l'on libere de suite. Cela a pour */
278 /* consequence de deplacer le BREAK tres haut. Le BREAK ne redescend jamais meme lors du free */
279 /* Le mmap donnant une adresse (environ 100 Mo au dessus du BREAK) on se retrouve alors avec */
280 /* le partage des zones de memoire suivant : */
281 /* 700 Mo pour les malloc - 500 Mo (1,2Go - 700Mo ) pour les mmap. Avec un CLD_SD_SIZE */
282 /* de 2 000 000 on atteind jamais 500 Mo de mmap, meme en chargeant des applications (qui */
283 /* utilisent la zone de mmap */
284 /* Ce partage des zones memoire pourra eventuellemt etre regle par une variable d'environnement */
285 /* CLD_HIGH_SBRK */
286 char *var;
287 Standard_Size high_sbrk;
288
289 high_sbrk = 700*1024*1024;
290 if ( (var=getenv("CLD_HIGH_SBRK")) != NULL ) {
291 high_sbrk = atoi(var);
292 }
293
294 var = (char*)malloc(high_sbrk); // 700 Mb
295 if ( var )
296 free(var);
297 else
298 perror("ERR_MEMRY_FAIL");
299#endif
300
301#if defined(IRIX) || defined(__sgi) || defined(SOLARIS) || defined(__sun) || defined(LIN) || defined(linux) || defined(__FreeBSD__)
302 if ((myMMap = open ("/dev/zero", O_RDWR)) < 0) {
303 if ((myMMap = open ("/dev/null", O_RDWR)) < 0){
304 myMMap = 0;
305 }
306 }
307 if (!myMMap)
308 perror("ERR_MMAP_FAIL");
309#else
310 myMMap = -1;
311#endif
312 }
313
314 // initialize free lists
315 myFreeListMax = INDEX_CELL(ROUNDUP_CELL(myThreshold-BLOCK_SHIFT)); // all blocks less than myThreshold are to be recycled
316 myFreeList = (Standard_Size **) calloc (myFreeListMax+1, sizeof(Standard_Size *));
317 myCellSize = ROUNDUP16(myCellSize);
318}
319
320//=======================================================================
321//function : SetMMgrOptCallBack
322//purpose : Sets a callback function to be called on each alloc/free
323//=======================================================================
324
325static Standard_MMgrOpt::TPCallBackFunc MyPCallBackFunc = NULL;
326
327Standard_EXPORT void Standard_MMgrOpt::SetCallBackFunction(TPCallBackFunc pFunc)
328{
329 MyPCallBackFunc = pFunc;
330}
331
332inline void callBack(const Standard_Boolean isAlloc,
333 const Standard_Address aStorage,
334 const Standard_Size aRoundSize,
335 const Standard_Size aSize)
336{
337 if (MyPCallBackFunc)
338 (*MyPCallBackFunc)(isAlloc, aStorage, aRoundSize, aSize);
339}
340
341//=======================================================================
342//function : Allocate
343//purpose :
344//=======================================================================
345
346Standard_Address Standard_MMgrOpt::Allocate(const Standard_Size aSize)
347{
348 Standard_Size * aStorage = NULL;
349
350 // round up size according to allocation granularity
351 // The keyword 'volatile' is only used here for GCC 64-bit compilations
352 // otherwise this method would crash in runtime in optimized build.
353 volatile Standard_Size RoundSize = ROUNDUP_CELL(aSize);
354 const Standard_Size Index = INDEX_CELL(RoundSize);
355
356 // blocks of small and medium size are recyclable
357 if ( Index <= myFreeListMax ) {
358 const Standard_Size RoundSizeN = RoundSize / sizeof(Standard_Size);
359
360 // Lock access to critical data (myFreeList and other fields) by mutex.
361 // Note that we do not lock fields that do not change during the
362 // object life (such as myThreshold), and assume that calls to functions
363 // of standard library are already protected by their implementation.
364 // The unlock is called as soon as possible, for every treatment case.
365 // We also do not use Sentry, since in case if OCC signal or exception is
366 // caused by this block we will have deadlock anyway...
367 if (myReentrant) myMutex.Lock();
368
369 // if free block of the requested size is available, return it
370 if ( myFreeList[Index] ) {
371 // the address of the next free block is stored in the header
372 // of the memory block; use it to update list pointer
373 // to point to next free block
374 Standard_Size* aBlock = myFreeList[Index];
375 myFreeList[Index] = *(Standard_Size**)aBlock;
376
377 // unlock the mutex
378 if ( myReentrant ) myMutex.Unlock();
379
380 // record size of the allocated block in the block header and
381 // shift the pointer to the beginning of the user part of block
382 aBlock[0] = RoundSize;
383 aStorage = GET_USER(aBlock);
384
385 // clear block if requested
386 if (myClear)
387 memset (aStorage, 0, RoundSize);
388 }
389 // else if block size is small allocate it in pools
390 else if ( RoundSize <= myCellSize ) {
391 // unlock the mutex for free lists
392 if ( myReentrant ) myMutex.Unlock();
393
394 // and lock the specific mutex used to protect access to small blocks pools;
395 // note that this is done by sentry class so as to ensure unlocking in case of
396 // possible exception that may be thrown from AllocMemory()
49f38e37 397 Standard_Mutex::Sentry aSentry (myReentrant ? &myMutexPools : NULL);
7fd59977 398
399 // check for availability of requested space in the current pool
400 Standard_Size *aBlock = myNextAddr;
401 if ( &aBlock[ BLOCK_SHIFT+RoundSizeN] > myEndBlock ) {
402 // otherwise, allocate new memory pool with page-aligned size
403 Standard_Size Size = myPageSize * myNbPages;
404 aBlock = AllocMemory(Size); // note that size may be aligned by this call
405
406 if (myEndBlock > myNextAddr) {
407 // put the remaining piece to the free lists
408 const Standard_Size aPSize = (myEndBlock - GET_USER(myNextAddr))
409 * sizeof(Standard_Size);
410 const Standard_Size aRPSize = ROUNDDOWN_CELL(aPSize);
411 const Standard_Size aPIndex = INDEX_CELL(aRPSize);
412 if ( aPIndex > 0 && aPIndex <= myFreeListMax ) {
413 if (myReentrant) myMutex.Lock();
414 *(Standard_Size**)myNextAddr = myFreeList[aPIndex];
415 myFreeList[aPIndex] = myNextAddr;
416 if (myReentrant) myMutex.Unlock();
417 }
418 }
419
420 // set end pointer to the end of the new pool
421 myEndBlock = aBlock + Size / sizeof(Standard_Size);
422 // record in the first bytes of the pool the address of the previous one
423 *(Standard_Size**)aBlock = myAllocList;
424 // and make new pool current (last)
425 // and get pointer to the first memory block in the pool
426 myAllocList = aBlock;
427 aBlock+=BLOCK_SHIFT;
428 }
429
430 // initialize header of the new block by its size
431 // and get the pointer to the user part of block
432 aBlock[0] = RoundSize;
433 aStorage = GET_USER(aBlock);
434
435 // and advance pool pointer to the next free piece of pool
436 myNextAddr = &aStorage[RoundSizeN];
437 }
438 // blocks of medium size are allocated directly
439 else {
440 // unlock the mutex immediately, as we do not need further to access any field
441 if ( myReentrant ) myMutex.Unlock();
442
443 // we use operator ?: instead of if() since it is faster
444 Standard_Size *aBlock = (Standard_Size*) (myClear ? calloc( RoundSizeN+BLOCK_SHIFT, sizeof(Standard_Size)) :
445 malloc((RoundSizeN+BLOCK_SHIFT) * sizeof(Standard_Size)) );
446
447 // if allocation failed, try to free some memory by purging free lists, and retry
448 if ( ! aBlock ) {
449 if ( Purge (Standard_False) )
450 aBlock = (Standard_Size*)calloc(RoundSizeN+BLOCK_SHIFT, sizeof(Standard_Size));
451 // if still not succeeded, raise exception
452 if ( ! aBlock )
453 anOutOfMemError->Reraise ("Standard_MMgrOpt::Allocate(): malloc failed");
454 }
455
456 // initialize new block header by its size
457 // and get the pointer to the user part of block
458 aBlock[0] = RoundSize;
459 aStorage = GET_USER(aBlock);
460 }
461 }
462 // blocks of big size may be allocated as memory mapped files
463 else {
464 // Compute size of the block to be allocated, including header,
465 // Note that we use rounded size, even if this block will not be stored in
466 // the free list, for consistency of calls to AllocMemory() / FreeMemory()
467 // and calculation of index in the free list
468 Standard_Size AllocSize = RoundSize + sizeof(Standard_Size);
469
470 // allocate memory
471 Standard_Size* aBlock = AllocMemory(AllocSize);
472
473 // initialize new block header by its size
474 // and get the pointer to the user part of block.
475 aBlock[0] = RoundSize;
476 aStorage = GET_USER(aBlock);
477 }
478
479 callBack(Standard_True, aStorage, RoundSize, aSize);
480
481 return aStorage;
482}
483
484//=======================================================================
485//function : Free
486//purpose :
487//=======================================================================
488
489void Standard_MMgrOpt::Free(Standard_Address& theStorage)
490{
491 // safely return if attempt to free null pointer
492 if ( ! theStorage )
493 return;
494
495 // get the pointer to the memory block header
496 Standard_Size* aBlock = GET_BLOCK(theStorage);
497
498 // and get the allocated size of the block
499 Standard_Size RoundSize = aBlock[0];
500
501 callBack(Standard_False, theStorage, RoundSize, 0);
502
503 // check whether blocks with that size are recyclable
504 const Standard_Size Index = INDEX_CELL(RoundSize);
505 if ( Index <= myFreeListMax ) {
506 // Lock access to critical data (myFreeList and other) by mutex
507 // Note that we do not lock fields that do not change during the
508 // object life (such as myThreshold), and assume that calls to functions
509 // of standard library are already protected by their implementation.
510 // We also do not use Sentry, since in case if OCC signal or exception is
511 // caused by this block we will have deadlock anyway...
512 if (myReentrant) myMutex.Lock();
513
514 // in the memory block header, record address of the next free block
515 *(Standard_Size**)aBlock = myFreeList[Index];
516 // add new block to be first in the list
517 myFreeList[Index] = aBlock;
518
519 if (myReentrant) myMutex.Unlock();
520 }
521 // otherwise, we have block of big size which shall be simply released
522 else
523 FreeMemory (aBlock, RoundSize);
524
525 theStorage = NULL;
526}
527
528//=======================================================================
529//function : Purge
530//purpose : Frees all free lists except small blocks (less than CellSize)
531//=======================================================================
532
533Standard_Integer Standard_MMgrOpt::Purge(Standard_Boolean )//isDeleted)
534{
535 // Lock access to critical data by mutex
49f38e37 536 Standard_Mutex::Sentry aSentry (myReentrant ? &myMutex : NULL);
7fd59977 537
538 // TODO: implement support for isDeleted = True
539
540 // free memory blocks contained in free lists
541 // whose sizes are greater than cellsize
542 Standard_Integer nbFreed = 0;
543 Standard_Size i = INDEX_CELL(ROUNDUP_CELL(myCellSize+BLOCK_SHIFT));
544 for (; i <= myFreeListMax; i++ ) {
545 Standard_Size * aFree = myFreeList[i];
546 while(aFree) {
547 Standard_Size * anOther = aFree;
548 aFree = * (Standard_Size **) aFree;
549 free(anOther);
550 nbFreed++;
551 }
552 myFreeList[i] = NULL;
553 }
554
555 // Lock access to critical data by mutex
49f38e37 556 Standard_Mutex::Sentry aSentry1 (myReentrant ? &myMutexPools : NULL);
7fd59977 557
558 // release memory pools containing no busy memory;
559 // for that for each pool count the summary size of blocks
560 // got from the free lists allocated from this pool
561#ifndef WNT
562 const Standard_Size PoolSize = myPageSize * myNbPages;
563#else
564 const Standard_Size PoolSize =
565 PAGE_ALIGN(myPageSize * myNbPages + sizeof(HANDLE), myPageSize) -
566 sizeof(HANDLE);
567#endif
568 const Standard_Size RPoolSize = ROUNDDOWN_CELL(PoolSize);
569 const Standard_Size PoolSizeN = RPoolSize / sizeof(Standard_Size);
570
571 // declare the table of pools;
572 // (we map free blocks onto a number of pools simultaneously)
573 static const Standard_Integer NB_POOLS_WIN = 512;
574 static Standard_Size* aPools[NB_POOLS_WIN];
575 static Standard_Size aFreeSize[NB_POOLS_WIN];
576 static Standard_Integer aFreePools[NB_POOLS_WIN];
577
578 Standard_Size * aNextPool = myAllocList;
579 Standard_Size * aPrevPool = NULL;
580 const Standard_Size nCells = INDEX_CELL(myCellSize);
581 Standard_Integer nPool = 0, nPoolFreed = 0;
582
583 while (aNextPool) {
584 // fill the table of pools
585 Standard_Integer iPool;
586 for (iPool = 0; aNextPool && iPool < NB_POOLS_WIN; iPool++) {
587 aPools[iPool] = aNextPool;
588 aFreeSize[iPool] = 0;
589 aNextPool = * (Standard_Size **) aNextPool; // get next pool
590 }
591 const Standard_Integer iLast = iPool - 1;
592 nPool += iPool;
593
594 // scan free blocks, find corresponding pools and increment
595 // counters
596 for (i = 0; i <= nCells; i++ ) {
597 Standard_Size * aFree = myFreeList[i];
598 Standard_Size aSize = BLOCK_SHIFT * sizeof(Standard_Size) +
599 ROUNDUP_CELL(1) * i;
600 while(aFree) {
601 for (iPool = 0; iPool <= iLast; iPool++) {
602 if (aFree >= aPools[iPool] && aFree < aPools[iPool] + PoolSizeN) {
603 aFreeSize[iPool] += aSize;
604 break;
605 }
606 }
607 aFree = * (Standard_Size **) aFree; // get next free block
608 }
609 }
610
611 // scan the table and make the list of free pools
612 Standard_Integer iLastFree = -1;
613 for (iPool = 0; iPool <= iLast; iPool++) {
614 aFreeSize[iPool] = ROUNDUP_CELL(aFreeSize[iPool]);
615 if (aFreeSize[iPool] == RPoolSize)
616 aFreePools[++iLastFree] = iPool;
617 }
618 if (iLastFree == -1) {
619 // no free pools found in this table
620 aPrevPool = aPools[iLast];
621 continue;
622 }
623
624 // scan free blocks again, and remove those of them
625 // that belong to free pools
626 Standard_Integer j;
627 for (i = 0; i <= nCells; i++ ) {
628 Standard_Size * aFree = myFreeList[i];
629 Standard_Size * aPrevFree = NULL;
630 while(aFree) {
631 for (j = 0; j <= iLastFree; j++) {
632 iPool = aFreePools[j];
633 if (aFree >= aPools[iPool] && aFree < aPools[iPool] + PoolSizeN)
634 break;
635 }
636 if (j <= iLastFree)
637 {
638 // remove
639 aFree = * (Standard_Size **) aFree;
640 if (aPrevFree)
641 * (Standard_Size **) aPrevFree = aFree; // link to previous
642 else
643 myFreeList[i] = aFree;
644 nbFreed++;
645 }
646 else {
647 // skip
648 aPrevFree = aFree;
649 aFree = * (Standard_Size **) aFree;
650 }
651 }
652 }
653
654 // release free pools, and reconnect remaining pools
655 // in the linked list
656 Standard_Size * aPrev = (aFreePools[0] == 0
657 ? aPrevPool
658 : aPools[aFreePools[0] - 1]);
659 for (j = 0; j <= iLastFree; j++) {
660 iPool = aFreePools[j];
661 if (j > 0) {
662 // update the pointer to the previous non-free pool
663 if (iPool - aFreePools[j - 1] > 1)
664 aPrev = aPools[iPool - 1];
665 }
666 if (j == iLastFree || aFreePools[j + 1] - iPool > 1) {
667 // get next non-free pool
668 Standard_Size * aNext =
669 (j == iLastFree && aFreePools[j] == iLast)
670 ? aNextPool
671 : aPools[iPool + 1];
672 // and connect it to the list of pools that have been processed
673 // and remain non-free
674 if (aPrev)
675 * (Standard_Size **) aPrev = aNext;
676 else
677 myAllocList = aNext;
678 }
679 FreeMemory(aPools[iPool], PoolSize);
680 }
681 // update the pointer to the previous non-free pool
682 aPrevPool = (aFreePools[iLastFree] == iLast
683 ? aPrev
684 : aPools[iLast]);
685 nPoolFreed += iLastFree + 1;
686 }
687
688 return nbFreed;
689}
690
691//=======================================================================
692//function : FreePools
693//purpose : Frees all memory pools allocated for small blocks
694//=======================================================================
695
696void Standard_MMgrOpt::FreePools()
697{
698 // Lock access to critical data by mutex
49f38e37 699 Standard_Mutex::Sentry aSentry (myReentrant ? &myMutexPools : NULL);
7fd59977 700
701 // last pool is remembered in myAllocList
702 Standard_Size * aFree = myAllocList;
703 myAllocList = 0;
704 while (aFree) {
705 Standard_Size * aBlock = aFree;
706 // next pool address is stored in first 8 bytes of each pool
707 aFree = * (Standard_Size **) aFree;
708 // free pool (note that its size is calculated rather than stored)
709 FreeMemory ( aBlock, myPageSize * myNbPages );
710 }
711}
712
713//=======================================================================
714//function : Reallocate
715//purpose :
716//=======================================================================
717
718Standard_Address Standard_MMgrOpt::Reallocate(Standard_Address& theStorage,
719 const Standard_Size theNewSize)
720{
cf9a910a 721 // if theStorage == NULL, just allocate new memory block
722 if (!theStorage)
723 {
724 return Allocate(theNewSize);
725 }
726
7fd59977 727 Standard_Size * aBlock = GET_BLOCK(theStorage);
728 Standard_Address newStorage = NULL;
729
730 // get current size of the memory block from its header
731 Standard_Size OldSize = aBlock[0];
732
733 // if new size is less than old one, just do nothing
734 if (theNewSize <= OldSize) {
735 newStorage = theStorage;
736 }
737 // otherwise, allocate new block and copy the data to it
738 else {
739 newStorage = Allocate(theNewSize);
740 memcpy (newStorage, theStorage, OldSize);
741 Free( theStorage );
742 // clear newly added part of the block
743 if ( myClear )
744 memset(((char*)newStorage) + OldSize, 0, theNewSize-OldSize);
745 }
746 theStorage = NULL;
747 return newStorage;
748}
749
750//=======================================================================
751//function : AllocMemory
752//purpose : Allocate a big block of memory using either malloc/calloc
753// or memory mapped file
754//=======================================================================
755
756Standard_Size * Standard_MMgrOpt::AllocMemory(Standard_Size &Size)
757{
758 // goto is used as efficient method for a possibility to retry allocation
759retry:
760
761 Standard_Size * aBlock = NULL;
762
763 // if MMap option is ON, allocate using memory mapped files
764 if (myMMap) {
765#ifndef WNT
766
767 // align size to page size
768 const Standard_Size AlignedSize = PAGE_ALIGN(Size, myPageSize);
769
770 // allocate memory
771 // note that on UNIX myMMap is file descriptor for /dev/null
772 aBlock = (Standard_Size * )mmap((char*)MMAP_BASE_ADDRESS, AlignedSize,
773 PROT_READ | PROT_WRITE, MMAP_FLAGS,
774 myMMap, 0);
775 if (aBlock == MAP_FAILED /* -1 */) {
776 int errcode = errno;
777 // as a last resort, try freeing some memory by calling Purge()
778 if ( Purge(Standard_False) )
779 goto retry;
780 // if nothing helps, raise exception
781 anOutOfMemError->Reraise (strerror(errcode));
782 }
783
784 // save actually allocated size into argument
785 Size = AlignedSize;
786
787#else /* WNT */
788
789 // align size to page size, taking into account additional space needed to
790 // store handle to the memory map
791 const Standard_Size AlignedSize = PAGE_ALIGN(Size+sizeof(HANDLE), myPageSize);
792
793 // allocate mapped file
794 HANDLE hMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
795 PAGE_READWRITE,
796 DWORD(AlignedSize / 0x80000000),
797 DWORD(AlignedSize % 0x80000000), NULL);
798 HANDLE * aMBlock = NULL;
799 // check for error and try allocating address space
800 if ( ! hMap || GetLastError() == ERROR_ALREADY_EXISTS ||
801 ! (aMBlock = (HANDLE*)MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0)) )
802 {
803 // close handle if allocated
804 if ( hMap )
805 CloseHandle(hMap);
806 hMap = 0;
807 // as a last resort, try freeing some memory by calling Purge() and retry
808 if ( Purge(Standard_False) )
809 goto retry;
810 // if nothing helps, make error message and raise exception
811 const int BUFSIZE=1024;
812 char message[BUFSIZE];
813 if ( FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(), 0, message, BUFSIZE-1, 0) <=0 )
814 strcpy (message, "Standard_MMgrOpt::AllocMemory() failed to mmap");
815 anOutOfMemError->Reraise (message);
816 }
817
818 // record map handle in the beginning
819 aMBlock[0] = hMap;
820
821 // and shift to the beginning of usable area
822 aBlock = (Standard_Size*)(aMBlock+1);
823
824 // save actually allocated size into argument
825 Size = AlignedSize - sizeof(HANDLE);
826#endif
827 }
828 // else just allocate by malloc or calloc
829 else {
830 aBlock = (Standard_Size *) (myClear ? calloc(Size,sizeof(char)) : malloc(Size));
831 // check the result
832 if ( ! aBlock )
833 {
834 // as a last resort, try freeing some memory by calling Purge()
835 if ( Purge(Standard_False) )
836 goto retry;
837 // if nothing helps, raise exception
838 anOutOfMemError->Reraise ("Standard_MMgrOpt::Allocate(): malloc failed");
839 }
840 }
841 // clear whole block if clearing option is set
842 if (myClear)
843 memset (aBlock, 0, Size);
844 return aBlock;
845}
846
847//=======================================================================
848//function : FreeMemory
849//purpose :
850//=======================================================================
851
852void Standard_MMgrOpt::FreeMemory (Standard_Address aBlock,
853 const Standard_Size
854#ifndef WNT
855 aSize
856#endif
857 )
858{
859 // release memory (either free or unmap)
860 if ( myMMap ) {
861#ifndef WNT
862 // align size to page size, just the same as in AllocMemory()
863 const Standard_Size AlignedSize = PAGE_ALIGN(aSize, myPageSize);
864 munmap((char*)aBlock, AlignedSize);
865#else
866 // recover handle to the memory mapping stored just before the block
867 const HANDLE * aMBlock = (const HANDLE *)aBlock;
868 HANDLE hMap = *(--aMBlock);
869 UnmapViewOfFile((LPCVOID)aMBlock);
870 CloseHandle (hMap);
871#endif
872 }
873 else
874 free(aBlock);
875}
876
877//=======================================================================
878//function : SetReentrant
879//purpose :
880//=======================================================================
881
882void Standard_MMgrOpt::SetReentrant(Standard_Boolean isReentrant)
883{
884 myReentrant = isReentrant;
885}