0030329: Move BRepMesh_IncAllocator to NCollection package
[occt.git] / src / NCollection / NCollection_IncAllocator.cxx
1 // Created on: 2002-04-12
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2002-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <NCollection_IncAllocator.hxx>
17 #include <NCollection_DataMap.hxx>
18 #include <NCollection_Map.hxx>
19 #include <Standard_Mutex.hxx>
20 #include <Standard_OutOfMemory.hxx>
21 #include <stdio.h>
22 #include <fstream>
23 #include <iomanip>
24
25
26 IMPLEMENT_STANDARD_RTTIEXT(NCollection_IncAllocator,NCollection_BaseAllocator)
27
28 namespace
29 {
30
31   inline size_t IMEM_SIZE (const size_t theSize)
32   {
33     return (theSize - 1) / sizeof(NCollection_IncAllocator::aligned_t) + 1;
34   }
35
36   inline size_t IMEM_ALIGN (const void* theAddress)
37   {
38     return sizeof(NCollection_IncAllocator::aligned_t) * IMEM_SIZE (size_t(theAddress));
39   }
40
41   #define IMEM_FREE(p_bl) (size_t(p_bl->p_end_block - p_bl->p_free_space))
42
43 #ifdef OCCT_DEBUG
44   // auxiliary dummy function used to get a place where break point can be set
45   inline void place_for_breakpoint() {}
46 #endif
47 }
48
49 #define MaxLookup 16
50
51 static Standard_Boolean IS_DEBUG = Standard_False;
52
53 //=======================================================================
54 /**
55  * Static data map (address -> AllocatorID)
56  */
57 //=======================================================================
58 static NCollection_DataMap<Standard_Address, Standard_Size>& StorageIDMap()
59 {
60   static NCollection_DataMap<Standard_Address, Standard_Size> TheMap;
61   return TheMap;
62 }
63
64 //=======================================================================
65 /**
66  * Static map (AllocatorID)
67  */
68 //=======================================================================
69 static NCollection_Map<Standard_Size>& StorageIDSet()
70 {
71   static NCollection_Map<Standard_Size> TheMap;
72   return TheMap;
73 }
74
75 //=======================================================================
76 //function : IncAllocator_SetDebugFlag
77 //purpose  : Turn on/off debugging of memory allocation
78 //=======================================================================
79
80 Standard_EXPORT void IncAllocator_SetDebugFlag(const Standard_Boolean theDebug)
81 {
82   IS_DEBUG = theDebug;
83 }
84
85 #ifdef OCCT_DEBUG
86
87 //=======================================================================
88 /**
89  * Static value of the current allocation ID. It provides unique
90  * numbering of allocators.
91  */
92 //=======================================================================
93 static Standard_Size CurrentID = 0;
94 static Standard_Size CATCH_ID = 0;
95
96 //=======================================================================
97 //function : Debug_Create
98 //purpose  : Store the allocator address in the internal maps
99 //=======================================================================
100
101 static void Debug_Create(Standard_Address theAlloc)
102 {
103   static Standard_Mutex aMutex;
104   aMutex.Lock();
105   StorageIDMap().Bind(theAlloc, ++CurrentID);
106   StorageIDSet().Add(CurrentID);
107   if (CurrentID == CATCH_ID)
108     place_for_breakpoint();
109   aMutex.Unlock();
110 }
111
112 //=======================================================================
113 //function : Debug_Destroy
114 //purpose  : Forget the allocator address from the internal maps
115 //=======================================================================
116
117 static void Debug_Destroy(Standard_Address theAlloc)
118 {
119   static Standard_Mutex aMutex;
120   aMutex.Lock();
121   if (StorageIDMap().IsBound(theAlloc))
122   {
123     Standard_Size anID = StorageIDMap()(theAlloc);
124     StorageIDSet().Remove(anID);
125     StorageIDMap().UnBind(theAlloc);
126   }
127   aMutex.Unlock();
128 }
129
130 #endif /* OCCT_DEBUG */
131
132 //=======================================================================
133 //function : IncAllocator_PrintAlive
134 //purpose  : Outputs the alive numbers to the file inc_alive.d
135 //=======================================================================
136
137 Standard_EXPORT void IncAllocator_PrintAlive()
138 {
139   if (StorageIDSet().IsEmpty())
140   {
141     return;
142   }
143
144   std::ofstream aFileOut ("inc_alive.d", std::ios_base::trunc | std::ios_base::out);
145   if (!aFileOut.is_open())
146   {
147     std::cout << "failure writing file inc_alive.d" << std::endl;
148     return;
149   }
150   aFileOut.imbue (std::locale ("C"));
151   aFileOut << std::fixed << std::setprecision(1);
152
153   aFileOut << "Alive IncAllocators (number, size in Kb)\n";
154   Standard_Size    aTotSize = 0;
155   Standard_Integer nbAlloc  = 0;
156   for (NCollection_DataMap<Standard_Address, Standard_Size>::Iterator itMap (StorageIDMap());
157        itMap.More(); itMap.Next())
158   {
159     const NCollection_IncAllocator* anAlloc = static_cast<NCollection_IncAllocator*>(itMap.Key());
160     Standard_Size anID  = itMap.Value();
161     Standard_Size aSize = anAlloc->GetMemSize();
162     aTotSize += aSize;
163     nbAlloc++;
164     aFileOut << std::setw(20) << anID << ' '
165              << std::setw(20) << (double(aSize) / 1024.0)
166              << '\n';
167   }
168   aFileOut << "Total:\n"
169            << std::setw(20) << nbAlloc << ' '
170            << std::setw(20) << (double(aTotSize) / 1024.0)
171            << '\n';
172   aFileOut.close();
173 }
174
175 //=======================================================================
176 //function : NCollection_IncAllocator()
177 //purpose  : Constructor
178 //=======================================================================
179
180 NCollection_IncAllocator::NCollection_IncAllocator (size_t theBlockSize)
181 : myMutex (NULL)
182 {
183 #ifdef ALLOC_TRACK_USAGE
184   printf ("\n..NCollection_IncAllocator: Created (%x)\n",this);
185 #endif
186 #ifdef OCCT_DEBUG
187   if (IS_DEBUG)
188     Debug_Create(this);
189 #endif
190   const size_t aDefault = DefaultBlockSize;
191   const size_t aSize = IMEM_SIZE(sizeof(IBlock)) +
192       IMEM_SIZE((theBlockSize > 2*sizeof(IBlock)) ? theBlockSize : aDefault);
193   IBlock * const aBlock = (IBlock *) malloc (aSize * sizeof(aligned_t));
194   myFirstBlock = aBlock;
195   mySize = aSize - IMEM_SIZE(sizeof(IBlock));
196   myMemSize = aSize * sizeof(aligned_t);
197   if (aBlock == NULL)
198     throw Standard_OutOfMemory("NCollection_IncAllocator: out of memory");
199   aBlock -> p_free_space = (aligned_t *) IMEM_ALIGN (&aBlock[1]);
200   aBlock -> p_end_block  = ((aligned_t *) aBlock) + aSize;
201   aBlock -> p_next       = NULL;
202 }
203
204 //=======================================================================
205 //function : ~NCollection_IncAllocator
206 //purpose  : Destructor
207 //=======================================================================
208
209 NCollection_IncAllocator::~NCollection_IncAllocator ()
210 {
211   delete myMutex;
212 #ifdef OCCT_DEBUG
213   if (IS_DEBUG)
214     Debug_Destroy(this);
215 #endif
216   Clean();
217   free (myFirstBlock);
218 }
219
220 //=======================================================================
221 //function : SetThreadSafe
222 //purpose  :
223 //=======================================================================
224 void NCollection_IncAllocator::SetThreadSafe (bool theIsThreadSafe)
225 {
226   if (myMutex == NULL
227    && theIsThreadSafe)
228   {
229     myMutex = new Standard_Mutex();
230   }
231   else if (!theIsThreadSafe)
232   {
233     delete myMutex;
234     myMutex = NULL;
235   }
236 }
237
238 //=======================================================================
239 //function : Allocate
240 //purpose  : allocate a memory
241 //remark   : returns NULL if allocation fails
242 //=======================================================================
243
244 void * NCollection_IncAllocator::Allocate (const size_t aSize)
245 {
246   aligned_t * aResult = NULL;
247   const size_t cSize = aSize ? IMEM_SIZE(aSize) : 0;
248
249   Standard_Mutex::Sentry aLock (myMutex);
250   if (cSize > mySize) {
251     /* If the requested size exceeds normal allocation size, allocate
252        a separate block and place it as the head of the list              */
253     aResult = (aligned_t *) allocateNewBlock (cSize+1);
254     if (aResult)
255       myFirstBlock -> p_free_space = myFirstBlock -> p_end_block;
256     else
257       throw Standard_OutOfMemory("NCollection_IncAllocator: out of memory");
258   } else
259     if (cSize <= IMEM_FREE(myFirstBlock)) {
260       /* If the requested size fits into the free space in the 1st block  */
261       aResult = myFirstBlock -> allocateInBlock (cSize);
262     } else {
263       /* Search for a block in the list with enough free space            */
264       int aMaxLookup = MaxLookup;   /* limit the number of blocks to query */
265       IBlock * aCurrentBlock = myFirstBlock -> p_next;
266       while (aCurrentBlock && aMaxLookup--) {
267         if (cSize <= IMEM_FREE(aCurrentBlock)) {
268           aResult = aCurrentBlock -> allocateInBlock (cSize);
269           break;
270         }
271         aCurrentBlock = aCurrentBlock -> p_next;
272       }
273       if (aResult == NULL) {
274         /* There is no available block with enough free space. Create a new
275            one and place it in the head of the list                       */
276         aResult = (aligned_t *) allocateNewBlock (mySize);
277         if (aResult)
278           myFirstBlock -> p_free_space = aResult + cSize;
279         else
280         {
281           const size_t aDefault = IMEM_SIZE(DefaultBlockSize);
282           if (cSize > aDefault)
283               throw Standard_OutOfMemory("NCollection_IncAllocator: out of memory");
284           else
285           {            
286             aResult = (aligned_t *) allocateNewBlock (aDefault);
287             if (aResult)
288               myFirstBlock -> p_free_space = aResult + cSize;
289             else
290               throw Standard_OutOfMemory("NCollection_IncAllocator: out of memory");
291           }
292         }
293       }
294     }
295   return aResult;
296 }
297
298 //=======================================================================
299 //function : Reallocate
300 //purpose  : 
301 //=======================================================================
302
303 void * NCollection_IncAllocator::Reallocate (void         * theAddress,
304                                              const size_t oldSize,
305                                              const size_t newSize)
306 {
307 // Check that the dummy parameters are OK
308   if (theAddress == NULL || oldSize == 0)
309     return Allocate (newSize);
310
311   const size_t cOldSize = IMEM_SIZE(oldSize);
312   const size_t cNewSize = newSize ? IMEM_SIZE(newSize) : 0;
313   aligned_t * anAddress = (aligned_t *) theAddress;
314
315   Standard_Mutex::Sentry aLock (myMutex);
316 // We check only the LAST allocation to do the real extension/contraction
317   if (anAddress + cOldSize == myFirstBlock -> p_free_space) {
318     myFirstBlock -> p_free_space = anAddress;
319 // If the new size fits into the memory block => OK
320 // This also includes any case of contraction
321     if (cNewSize <= IMEM_FREE(myFirstBlock)) {
322       myFirstBlock -> p_free_space += cNewSize;
323       return anAddress;
324     }
325   }
326 // In case of contraction of non-terminating allocation, do nothing
327   else if (cOldSize >= cNewSize)
328     return anAddress;
329 // Extension of non-terminated allocation if there is enough room in the
330 // current memory block 
331   if (cNewSize <= IMEM_FREE(myFirstBlock)) {
332     aligned_t * aResult = myFirstBlock -> allocateInBlock (cNewSize);
333     if (aResult)
334       for (unsigned i = 0; i < cOldSize; i++)
335         aResult[i] = anAddress[i];
336     return aResult;
337   }
338
339 // This is either of the cases:
340 //   - extension of non-terminating allocation, or
341 //   - extension of terminating allocation when the new size is too big
342 // In both cases create a new memory block, allocate memory and copy there
343 // the reallocated memory.
344   size_t cMaxSize = mySize > cNewSize ? mySize : cNewSize;
345   aligned_t * aResult = (aligned_t *) allocateNewBlock (cMaxSize);
346   if (aResult) {
347     myFirstBlock -> p_free_space = aResult + cNewSize;
348     for (unsigned i = 0; i < cOldSize; i++)
349       aResult[i] = anAddress[i];
350   }
351   else
352   {
353     throw Standard_OutOfMemory("NCollection_IncAllocator: out of memory");
354   }
355   return aResult;
356 }
357
358 //=======================================================================
359 //function : Free
360 //purpose  : 
361 //=======================================================================
362
363 void NCollection_IncAllocator::Free (void *)
364 {}
365
366 //=======================================================================
367 //function : Clean
368 //purpose  : 
369 //=======================================================================
370
371 void NCollection_IncAllocator::Clean ()
372 {
373 #ifdef ALLOC_TRACK_USAGE
374   printf ("\n..NCollection_IncAllocator: Memory size to clean:%8.1f kB (%x)\n",
375            double(GetMemSize())/1024, this);
376 #endif
377   IBlock * aBlock = myFirstBlock;
378   if (aBlock) {
379     aBlock -> p_free_space = (aligned_t *) &aBlock[1];
380     aBlock = aBlock -> p_next;
381     while (aBlock) {
382       IBlock * aNext = aBlock -> p_next;
383       free (aBlock);
384       aBlock = aNext;
385     }
386     myFirstBlock -> p_next = NULL;
387   }
388   myMemSize = 0;
389 }
390
391 //=======================================================================
392 //function : Reset
393 //purpose  : 
394 //=======================================================================
395
396 void NCollection_IncAllocator::Reset (const Standard_Boolean doReleaseMem)
397 {
398   Standard_Mutex::Sentry aLock (myMutex);
399   if (doReleaseMem)
400     Clean();
401   else {
402     Standard_Integer aBlockCount(0);
403     IBlock * aBlock = myFirstBlock;
404     while (aBlock)
405       if (aBlockCount++ < MaxLookup) {
406         aBlock -> p_free_space = (aligned_t *) &aBlock[1];
407         if (aBlockCount < MaxLookup)
408           aBlock = aBlock -> p_next;
409         else {
410           IBlock * aNext = aBlock -> p_next;
411           aBlock -> p_next = NULL;
412           aBlock = aNext;
413         }
414       } else {
415         IBlock * aNext = aBlock -> p_next;
416         myMemSize -= (aBlock -> p_end_block - (aligned_t *) aBlock) * sizeof (aligned_t);
417         free (aBlock);
418         aBlock = aNext;
419       }
420   }
421 }
422
423 //=======================================================================
424 //function : GetMemSize
425 //purpose  : diagnostic utility
426 //=======================================================================
427
428 size_t NCollection_IncAllocator::GetMemSize () const
429 {
430 //   size_t aResult = 0;
431 //   IBlock * aBlock = myFirstBlock;
432 //   while (aBlock) {
433 //     aResult += (aBlock -> p_end_block - (aligned_t *) aBlock);
434 //     aBlock = aBlock -> p_next;
435 //   }
436 //   return aResult * sizeof (aligned_t);
437   return myMemSize;
438 }
439
440 //=======================================================================
441 //function : allocateNewBlock
442 //purpose  : 
443 //=======================================================================
444
445 void * NCollection_IncAllocator::allocateNewBlock (const size_t cSize)
446 {
447   aligned_t * aResult = 0L;
448   const size_t aSz = cSize + IMEM_SIZE(sizeof(IBlock));
449   IBlock * aBlock = (IBlock *) malloc (aSz * sizeof(aligned_t));
450   if (aBlock) {
451     aBlock -> p_end_block  = ((aligned_t *)aBlock) + aSz;
452     aBlock -> p_next = myFirstBlock;
453     myFirstBlock = aBlock;
454     aResult = (aligned_t *) IMEM_ALIGN(&aBlock[1]);
455     myMemSize += aSz * sizeof(aligned_t);
456   }
457   return aResult;
458 }