OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgreMemoryAllocatorConfig.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 
29 #ifndef __MemoryAllocatorConfig_H__
30 #define __MemoryAllocatorConfig_H__
31 
33 #include "OgreHeaderPrefix.h"
34 
115 
120 
125 
128 
131 
141 namespace Ogre
142 {
160  {
177 
178 
179  // sentinel value, do not use
181  };
185 }
186 
188 #include "OgreMemorySTLAllocator.h"
189 
190 #if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NEDPOOLING
191 
192 # include "OgreMemoryNedPooling.h"
193 namespace Ogre
194 {
195  // configure default allocators based on the options above
196  // notice how we're not using the memory categories here but still roughing them out
197  // in your allocators you might choose to create different policies per category
198 
199  // configurable category, for general malloc
200  // notice how we ignore the category here, you could specialise
201  template <MemoryCategory Cat> class CategorisedAllocPolicy : public NedPoolingPolicy{};
202  template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public NedPoolingAlignedPolicy<align>{};
203 }
204 
205 #elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NED
206 
207 # include "OgreMemoryNedAlloc.h"
208 namespace Ogre
209 {
210  // configure default allocators based on the options above
211  // notice how we're not using the memory categories here but still roughing them out
212  // in your allocators you might choose to create different policies per category
213 
214  // configurable category, for general malloc
215  // notice how we ignore the category here, you could specialise
216  template <MemoryCategory Cat> class CategorisedAllocPolicy : public NedAllocPolicy{};
217  template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public NedAlignedAllocPolicy<align>{};
218 }
219 
220 #elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_STD
221 
222 # include "OgreMemoryStdAlloc.h"
223 namespace Ogre
224 {
225  // configure default allocators based on the options above
226  // notice how we're not using the memory categories here but still roughing them out
227  // in your allocators you might choose to create different policies per category
228 
229  // configurable category, for general malloc
230  // notice how we ignore the category here
231  template <MemoryCategory Cat> class CategorisedAllocPolicy : public StdAllocPolicy{};
232  template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public StdAlignedAllocPolicy<align>{};
233 
234  // if you wanted to specialise the allocation per category, here's how it might work:
235  // template <> class CategorisedAllocPolicy<MEMCATEGORY_SCENE_OBJECTS> : public YourSceneObjectAllocPolicy{};
236  // template <size_t align> class CategorisedAlignAllocPolicy<MEMCATEGORY_SCENE_OBJECTS, align> : public YourSceneObjectAllocPolicy<align>{};
237 
238 
239 }
240 
241 #elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_TRACK
242 
243 # include "OgreMemoryTrackAlloc.h"
244 namespace Ogre
245 {
246  // configure default allocators based on the options above
247  // notice how we're not using the memory categories here but still roughing them out
248  // in your allocators you might choose to create different policies per category
249 
250  // configurable category, for general malloc
251  // notice how we ignore the category here, you could specialise
252  template <MemoryCategory Cat> class CategorisedAllocPolicy : public TrackAllocPolicy{};
253  template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public TrackAlignedAllocPolicy<align>{};
254 }
255 
256 #else
257 
258 // your allocators here?
259 
260 #endif
261 
262 namespace Ogre
263 {
264  // Useful shortcuts
273 
275 
276  // Now define all the base classes for each allocation
285 
287 
288 
289  // Per-class allocators defined here
290  // NOTE: small, non-virtual classes should not subclass an allocator
291  // the virtual function table could double their size and make them less efficient
292  // use primitive or STL allocators / deallocators for those
341 
342  // Containers (by-value only)
343  // Will be of the form:
344  // typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc;
345  // for use in vector<T, TAlloc>::type
346 
347 
348 
349 }
350 
351 // Util functions
352 namespace Ogre
353 {
365  template<typename T>
366  T* constructN(T* basePtr, size_t count)
367  {
368  for (size_t i = 0; i < count; ++i)
369  {
370  new ((void*)(basePtr+i)) T();
371  }
372  return basePtr;
373  }
377 }
378 // define macros
379 
387 #if OGRE_DEBUG_MODE
388 
390 # define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
391 # define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
393 # define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
395 
397 # define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
398 # define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
400 # define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
402 # define OGRE_DELETE_ARRAY_T(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
404 
405 // aligned allocation
407 # define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
408 # define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
410 # define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
412 # define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
414 # define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)
416 # define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
418 
420 # define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
421 # define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
423 # define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
425 # define OGRE_DELETE_ARRAY_T_SIMD(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
427 # define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
429 # define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
431 # define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
433 # define OGRE_DELETE_ARRAY_T_ALIGN(ptr, T, count, category, align) if(ptr){for (size_t _b = 0; _b < count; ++_b) { (ptr)[_b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
435 
436 // new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
437 // Also hooks up the file/line/function params
438 // Can only be used with classes that derive from AllocatedObject since customised new/delete needed
439 # define OGRE_NEW new (__FILE__, __LINE__, __FUNCTION__)
440 # define OGRE_DELETE delete
441 
442 
443 #else // !OGRE_DEBUG_MODE
444 
446 # define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
447 # define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
449 # define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
451 
453 # define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
454 # define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
456 # define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
458 # define OGRE_DELETE_ARRAY_T(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
460 
461 // aligned allocation
463 # define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
464 # define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
466 # define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
468 # define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))
470 # define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr)
472 # define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr)
474 
476 # define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
477 # define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
479 # define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
481 # define OGRE_DELETE_ARRAY_T_SIMD(ptr, T, count, category) if(ptr){for (size_t b = 0; b < count; ++b) { (ptr)[b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
483 # define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
485 # define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count)
487 # define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
489 # define OGRE_DELETE_ARRAY_T_ALIGN(ptr, T, count, category, align) if(ptr){for (size_t _b = 0; _b < count; ++_b) { (ptr)[_b].~T();} ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
491 
492 // new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
493 # define OGRE_NEW new
494 # define OGRE_DELETE delete
495 
496 #endif // OGRE_DEBUG_MODE
497 
498 
499 namespace Ogre
500 {
505  template<typename T>
506  void deletePtr(T* ptr)
507  {
508  OGRE_DELETE ptr;
509  }
510 }
511 
516 #include "OgreHeaderSuffix.h"
517 
518 #endif
GeneralAllocatedObject DynLibAlloc
ScriptingAllocatedObject AbstractNodeAlloc
ScriptingAllocatedObject ScriptTranslatorAlloc
GeneralAllocatedObject LogAlloc
SceneCtlAllocatedObject ShadowDataAlloc
GeneralAllocatedObject FileSystemLayerAlloc
ResourceAllocatedObject ResourceAlloc
AnimationAllocatedObject AnimableAlloc
GeneralAllocatedObject UtilityAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > GeometryAllocPolicy
GeometryAllocatedObject ProgMeshAlloc
AllocatedObject< SceneObjAllocPolicy > SceneObjAllocatedObject
RenderSysAllocatedObject ViewportAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_OBJECTS > SceneObjAllocPolicy
Animation data like tracks, bone matrices.
AllocatedObject< AnimationAllocPolicy > AnimationAllocatedObject
SceneObjAllocatedObject SubEntityAlloc
SceneCtlAllocatedObject LodAlloc
ResourceAllocatedObject TechniqueAlloc
ResourceAllocatedObject CompositorInstAlloc
SceneObjAllocatedObject OverlayAlloc
GeneralAllocatedObject PluginAlloc
GeneralAllocatedObject ConfigAlloc
ResourceAllocatedObject TextureUnitStateAlloc
RenderSysAllocatedObject RenderSysAlloc
GeneralAllocatedObject ProfilerAlloc
ResourceAllocatedObject PassAlloc
MemoryCategory
A set of categories that indicate the purpose of a chunk of memory being allocated.
RenderSysAllocatedObject GpuParamsAlloc
AllocatedObject< SceneCtlAlignPolicy > SceneCtlAlignedObject
GeneralAllocatedObject CodecAlloc
GeometryAllocatedObject BatchedGeometryAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GENERAL > GeneralAllocPolicy
CategorisedAlignAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > SceneCtlAlignPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > SceneCtlAllocPolicy
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RESOURCE > ResourceAllocPolicy
SceneObjAllocatedObject MovableAlloc
An allocation policy for use with AllocatedObject and STLAllocator.
T * constructN(T *basePtr, size_t count)
Utility function for constructing an array of objects with placement new, without using new[] (which ...
GeneralAllocatedObject TimerAlloc
AllocatedObject< ResourceAllocPolicy > ResourceAllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
ScriptingAllocatedObject ScriptCompilerAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_ANIMATION > AnimationAllocPolicy
GeneralAllocatedObject RootAlloc
GeometryAllocatedObject VertexDataAlloc
SceneCtlAllocatedObject NodeAlloc
#define OGRE_DELETE
ResourceAllocatedObject SubMeshAlloc
AllocatedObject< GeneralAllocPolicy > GeneralAllocatedObject
GeneralAllocatedObject SerializerAlloc
GeometryAllocatedObject IndexDataAlloc
GeometryAllocatedObject DebugGeomAlloc
AnimationAllocatedObject AnimationAlloc
AllocatedObject< GeometryAllocPolicy > GeometryAllocatedObject
RenderSysAllocatedObject BufferAlloc
SceneCtlAllocatedObject SceneMgtAlloc
Geometry held in main memory.
AllocatedObject< SceneCtlAllocPolicy > SceneCtlAllocatedObject
GeneralAllocatedObject StreamAlloc
GeometryAllocatedObject PatchAlloc
SceneCtlAllocatedObject RenderQueueAlloc
GeneralAllocatedObject ImageAlloc
SceneCtlAlignedObject SceneMgtAlignedAlloc
GeometryAllocatedObject EdgeDataAlloc
An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given bo...
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCRIPTING > ScriptingAllocPolicy
void deletePtr(T *ptr)
Function which invokes OGRE_DELETE on a given pointer.
SceneObjAllocatedObject FXAlloc
GeneralAllocatedObject FactoryAlloc
AllocatedObject< RenderSysAllocPolicy > RenderSysAllocatedObject
AllocatedObject< ScriptingAllocPolicy > ScriptingAllocatedObject
GeneralAllocatedObject ArchiveAlloc
GeneralAllocatedObject ControllerAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RENDERSYS > RenderSysAllocPolicy