OGRE  1.9.0
OgreMemoryAllocatorConfig.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28
29#ifndef __MemoryAllocatorConfig_H__
30#define __MemoryAllocatorConfig_H__
31
33#include "OgreHeaderPrefix.h"
34
115
120
125
128
131
141namespace Ogre
142{
185}
186
189
190#if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NEDPOOLING
191
192# include "OgreMemoryNedPooling.h"
193namespace 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"
208namespace 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"
223namespace 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#else
242
243// your allocators here?
244
245#endif
246
247namespace Ogre
248{
249 // Useful shortcuts
258
259 // Now define all the base classes for each allocation
268
269
270 // Per-class allocators defined here
271 // NOTE: small, non-virtual classes should not subclass an allocator
272 // the virtual function table could double their size and make them less efficient
273 // use primitive or STL allocators / deallocators for those
321
322 // Containers (by-value only)
323 // Will be of the form:
324 // typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc;
325 // for use in vector<T, TAlloc>::type
326
327
328
329}
330
331// Util functions
332namespace Ogre
333{
345 template<typename T>
346 T* constructN(T* basePtr, size_t count)
347 {
348 for (size_t i = 0; i < count; ++i)
349 {
350 new ((void*)(basePtr+i)) T();
351 }
352 return basePtr;
353 }
357}
358// define macros
359
367#if OGRE_DEBUG_MODE
368
370# define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
372# define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
374# define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
375
377# define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
379# define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count)
381# define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
383# 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);}
384
385// aligned allocation
387# define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
389# define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
391# define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
393# define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
395# define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)
397# define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
398
400# define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
402# 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)
404# define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
406# 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);}
408# define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
410# 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)
412# define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
414# 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);}
415
416// new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
417// Also hooks up the file/line/function params
418// Can only be used with classes that derive from AllocatedObject since customised new/delete needed
419# define OGRE_NEW new (__FILE__, __LINE__, __FUNCTION__)
420# define OGRE_DELETE delete
421
422
423#else // !OGRE_DEBUG_MODE
424
426# define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
428# define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
430# define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
431
433# define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
435# define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
437# define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
439# 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);}
440
441// aligned allocation
443# define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
445# define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
447# define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
449# define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))
451# define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr)
453# define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr)
454
456# define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
458# define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count)
460# define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
462# 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);}
464# define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
466# define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count)
468# define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
470# 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);}
471
472// new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
473# define OGRE_NEW new
474# define OGRE_DELETE delete
475
476#endif // OGRE_DEBUG_MODE
477
478
479namespace Ogre
480{
485 template<typename T>
486 void deletePtr(T* ptr)
487 {
488 OGRE_DELETE ptr;
489 }
490}
491
496#include "OgreHeaderSuffix.h"
497
498#endif
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given bo...
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 ...
MemoryCategory
A set of categories that indicate the purpose of a chunk of memory being allocated.
#define OGRE_DELETE
@ MEMCATEGORY_RESOURCE
Other resources.
@ MEMCATEGORY_ANIMATION
Animation data like tracks, bone matrices.
@ MEMCATEGORY_RENDERSYS
Rendersystem structures.
@ MEMCATEGORY_SCENE_CONTROL
Nodes, control data.
@ MEMCATEGORY_GENERAL
General purpose.
@ MEMCATEGORY_SCRIPTING
Scripting.
@ MEMCATEGORY_GEOMETRY
Geometry held in main memory.
@ MEMCATEGORY_SCENE_OBJECTS
Scene object instances.
SceneCtlAllocatedObject ShadowDataAlloc
GeneralAllocatedObject DynLibAlloc
RenderSysAllocatedObject RenderSysAlloc
SceneObjAllocatedObject SubEntityAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RESOURCE > ResourceAllocPolicy
ResourceAllocatedObject TechniqueAlloc
AllocatedObject< GeometryAllocPolicy > GeometryAllocatedObject
GeneralAllocatedObject ImageAlloc
AllocatedObject< AnimationAllocPolicy > AnimationAllocatedObject
ResourceAllocatedObject TextureUnitStateAlloc
AllocatedObject< ScriptingAllocPolicy > ScriptingAllocatedObject
GeneralAllocatedObject ProfilerAlloc
ResourceAllocatedObject ResourceAlloc
ResourceAllocatedObject SubMeshAlloc
ScriptingAllocatedObject ScriptCompilerAlloc
GeometryAllocatedObject IndexDataAlloc
GeneralAllocatedObject TimerAlloc
GeneralAllocatedObject ConfigAlloc
GeneralAllocatedObject ArchiveAlloc
RenderSysAllocatedObject ViewportAlloc
AnimationAllocatedObject AnimationAlloc
GeometryAllocatedObject EdgeDataAlloc
GeometryAllocatedObject ProgMeshAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCRIPTING > ScriptingAllocPolicy
RenderSysAllocatedObject BufferAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_OBJECTS > SceneObjAllocPolicy
ScriptingAllocatedObject ScriptTranslatorAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_RENDERSYS > RenderSysAllocPolicy
AllocatedObject< RenderSysAllocPolicy > RenderSysAllocatedObject
ResourceAllocatedObject CompositorInstAlloc
SceneCtlAllocatedObject LodAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_ANIMATION > AnimationAllocPolicy
GeneralAllocatedObject CodecAlloc
GeometryAllocatedObject DebugGeomAlloc
AllocatedObject< SceneObjAllocPolicy > SceneObjAllocatedObject
SceneObjAllocatedObject MovableAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > SceneCtlAllocPolicy
GeometryAllocatedObject BatchedGeometryAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > GeometryAllocPolicy
RenderSysAllocatedObject GpuParamsAlloc
GeneralAllocatedObject FileSystemLayerAlloc
AllocatedObject< SceneCtlAllocPolicy > SceneCtlAllocatedObject
GeneralAllocatedObject RootAlloc
GeometryAllocatedObject VertexDataAlloc
GeneralAllocatedObject StreamAlloc
GeneralAllocatedObject SerializerAlloc
SceneCtlAllocatedObject RenderQueueAlloc
SceneCtlAllocatedObject SceneMgtAlloc
SceneCtlAllocatedObject NodeAlloc
GeneralAllocatedObject PluginAlloc
GeneralAllocatedObject ControllerAlloc
SceneObjAllocatedObject FXAlloc
AllocatedObject< GeneralAllocPolicy > GeneralAllocatedObject
GeneralAllocatedObject LogAlloc
CategorisedAllocPolicy< Ogre::MEMCATEGORY_GENERAL > GeneralAllocPolicy
AllocatedObject< ResourceAllocPolicy > ResourceAllocatedObject
AnimationAllocatedObject AnimableAlloc
ResourceAllocatedObject PassAlloc
ScriptingAllocatedObject AbstractNodeAlloc
GeneralAllocatedObject UtilityAlloc
GeometryAllocatedObject PatchAlloc
void deletePtr(T *ptr)
Function which invokes OGRE_DELETE on a given pointer.
GeneralAllocatedObject FactoryAlloc
SceneObjAllocatedObject OverlayAlloc