OgreMemoryAllocatorConfig.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2008 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 
00024 You may alternatively use this source under the terms of a specific version of
00025 the OGRE Unrestricted License provided you have obtained such a license from
00026 Torus Knot Software Ltd
00027 ---------------------------------------------------------------------------
00028 */
00029 
00030 #ifndef __MemoryAllocatorConfig_H__
00031 #define __MemoryAllocatorConfig_H__
00032 
00033 #include "OgrePrerequisites.h"
00034 
00109 
00114 
00119 
00122 
00125 
00133 namespace Ogre
00134 {
00144     enum MemoryCategory
00145     {
00147         MEMCATEGORY_GENERAL = 0,
00149         MEMCATEGORY_GEOMETRY = 1, 
00151         MEMCATEGORY_ANIMATION = 2, 
00153         MEMCATEGORY_SCENE_CONTROL = 3,
00155         MEMCATEGORY_SCENE_OBJECTS = 4,
00157         MEMCATEGORY_RESOURCE = 5,
00159         MEMCATEGORY_SCRIPTING = 6,
00161         MEMCATEGORY_RENDERSYS = 7,
00162 
00163         
00164         // sentinel value, do not use 
00165         MEMCATEGORY_COUNT = 8
00166     };
00167 }
00168 
00169 #include "OgreMemoryAllocatedObject.h"
00170 #include "OgreMemorySTLAllocator.h"
00171 
00172 #if OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_NED
00173 
00174 #  include "OgreMemoryNedAlloc.h"
00175 namespace Ogre
00176 {
00177     // configure default allocators based on the options above
00178     // notice how we're not using the memory categories here but still roughing them out
00179     // in your allocators you might choose to create different policies per category
00180 
00181     // configurable category, for general malloc
00182     // notice how we ignore the category here, you could specialise
00183     template <MemoryCategory Cat> class CategorisedAllocPolicy : public NedAllocPolicy{};
00184     template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public NedAlignedAllocPolicy<align>{};
00185 }
00186 
00187 #elif OGRE_MEMORY_ALLOCATOR == OGRE_MEMORY_ALLOCATOR_STD
00188 
00189 #  include "OgreMemoryStdAlloc.h"
00190 namespace Ogre
00191 {
00192     // configure default allocators based on the options above
00193     // notice how we're not using the memory categories here but still roughing them out
00194     // in your allocators you might choose to create different policies per category
00195 
00196     // configurable category, for general malloc
00197     // notice how we ignore the category here
00198     template <MemoryCategory Cat> class CategorisedAllocPolicy : public StdAllocPolicy{};
00199     template <MemoryCategory Cat, size_t align = 0> class CategorisedAlignAllocPolicy : public StdAlignedAllocPolicy<align>{};
00200 
00201     // if you wanted to specialise the allocation per category, here's how it might work:
00202     // template <> class CategorisedAllocPolicy<MEMCATEGORY_SCENE_OBJECTS> : public YourSceneObjectAllocPolicy{};
00203     // template <size_t align> class CategorisedAlignAllocPolicy<MEMCATEGORY_SCENE_OBJECTS, align> : public YourSceneObjectAllocPolicy<align>{};
00204     
00205     
00206 }
00207 
00208 #else
00209     
00210 // your allocators here?
00211 
00212 #endif
00213 
00214 namespace Ogre
00215 {
00216     // Useful shortcuts
00217     typedef CategorisedAllocPolicy<MEMCATEGORY_GENERAL> GeneralAllocPolicy;
00218     typedef CategorisedAllocPolicy<MEMCATEGORY_GEOMETRY> GeometryAllocPolicy;
00219     typedef CategorisedAllocPolicy<MEMCATEGORY_ANIMATION> AnimationAllocPolicy;
00220     typedef CategorisedAllocPolicy<MEMCATEGORY_SCENE_CONTROL> SceneCtlAllocPolicy;
00221     typedef CategorisedAllocPolicy<MEMCATEGORY_SCENE_OBJECTS> SceneObjAllocPolicy;
00222     typedef CategorisedAllocPolicy<MEMCATEGORY_RESOURCE> ResourceAllocPolicy;
00223     typedef CategorisedAllocPolicy<MEMCATEGORY_SCRIPTING> ScriptingAllocPolicy;
00224     typedef CategorisedAllocPolicy<MEMCATEGORY_RENDERSYS> RenderSysAllocPolicy;
00225 
00226     // Now define all the base classes for each allocation
00227     typedef AllocatedObject<GeneralAllocPolicy> GeneralAllocatedObject;
00228     typedef AllocatedObject<GeometryAllocPolicy> GeometryAllocatedObject;
00229     typedef AllocatedObject<AnimationAllocPolicy> AnimationAllocatedObject;
00230     typedef AllocatedObject<SceneCtlAllocPolicy> SceneCtlAllocatedObject;
00231     typedef AllocatedObject<SceneObjAllocPolicy> SceneObjAllocatedObject;
00232     typedef AllocatedObject<ResourceAllocPolicy> ResourceAllocatedObject;
00233     typedef AllocatedObject<ScriptingAllocPolicy> ScriptingAllocatedObject;
00234     typedef AllocatedObject<RenderSysAllocPolicy> RenderSysAllocatedObject;
00235 
00236 
00237     // Per-class allocators defined here
00238     // NOTE: small, non-virtual classes should not subclass an allocator
00239     // the virtual function table could double their size and make them less efficient
00240     // use primitive or STL allocators / deallocators for those
00241     typedef ScriptingAllocatedObject    AbstractNodeAlloc;
00242     typedef AnimationAllocatedObject    AnimableAlloc;
00243     typedef AnimationAllocatedObject    AnimationAlloc;
00244     typedef GeneralAllocatedObject      ArchiveAlloc;
00245     typedef GeometryAllocatedObject     BatchedGeometryAlloc;
00246     typedef RenderSysAllocatedObject    BufferAlloc;
00247     typedef GeneralAllocatedObject      CodecAlloc;
00248     typedef ResourceAllocatedObject     CompositorInstAlloc;
00249     typedef GeneralAllocatedObject      ConfigAlloc;
00250     typedef GeneralAllocatedObject      ControllerAlloc;
00251     typedef GeometryAllocatedObject     DebugGeomAlloc;
00252     typedef GeneralAllocatedObject      DynLibAlloc;
00253     typedef GeometryAllocatedObject     EdgeDataAlloc;
00254     typedef GeneralAllocatedObject      FactoryAlloc;
00255     typedef SceneObjAllocatedObject     FXAlloc;
00256     typedef GeneralAllocatedObject      ImageAlloc;
00257     typedef GeometryAllocatedObject     IndexDataAlloc;
00258     typedef GeneralAllocatedObject      LogAlloc;
00259     typedef SceneObjAllocatedObject     MovableAlloc;
00260     typedef SceneCtlAllocatedObject     NodeAlloc;
00261     typedef SceneObjAllocatedObject     OverlayAlloc;
00262     typedef RenderSysAllocatedObject    GpuParamsAlloc;
00263     typedef ResourceAllocatedObject     PassAlloc;
00264     typedef GeometryAllocatedObject     PatchAlloc;
00265     typedef GeneralAllocatedObject      PluginAlloc;
00266     typedef GeneralAllocatedObject      ProfilerAlloc;
00267     typedef GeometryAllocatedObject     ProgMeshAlloc;
00268     typedef SceneCtlAllocatedObject     RenderQueueAlloc;
00269     typedef RenderSysAllocatedObject    RenderSysAlloc;
00270     typedef GeneralAllocatedObject      RootAlloc;
00271     typedef ResourceAllocatedObject     ResourceAlloc;
00272     typedef GeneralAllocatedObject      SerializerAlloc;
00273     typedef SceneCtlAllocatedObject     SceneMgtAlloc;
00274     typedef ScriptingAllocatedObject    ScriptCompilerAlloc;
00275     typedef ScriptingAllocatedObject    ScriptTranslatorAlloc;
00276     typedef SceneCtlAllocatedObject     ShadowDataAlloc;
00277     typedef GeneralAllocatedObject      StreamAlloc;
00278     typedef SceneObjAllocatedObject     SubEntityAlloc;
00279     typedef ResourceAllocatedObject     SubMeshAlloc;
00280     typedef ResourceAllocatedObject     TechniqueAlloc;
00281     typedef GeneralAllocatedObject      TimerAlloc;
00282     typedef ResourceAllocatedObject     TextureUnitStateAlloc;
00283     typedef GeneralAllocatedObject      UtilityAlloc;
00284     typedef GeometryAllocatedObject     VertexDataAlloc;
00285     typedef RenderSysAllocatedObject    ViewportAlloc;
00286 
00287     // Containers (by-value only)
00288     // Will  be of the form:
00289     // typedef STLAllocator<T, DefaultAllocPolicy, Category> TAlloc;
00290     // for use in std::vector<T, TAlloc> 
00291     
00292 
00293 
00294 }
00295 
00296 // Util functions
00297 namespace Ogre
00298 {
00303     template<typename T>
00304     T* constructN(T* basePtr, size_t count)
00305     {
00306         for (size_t i = 0; i < count; ++i)
00307         {
00308             new ((void*)(basePtr+i)) T();
00309         }
00310         return basePtr;
00311     }
00312 }
00313 // define macros 
00314 
00315 #if OGRE_DEBUG_MODE
00316 
00318 #   define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
00320 #   define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
00322 #   define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
00323 
00325 #   define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
00327 #   define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__)), count) 
00329 #   define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
00331 #   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);}
00332 
00333 // aligned allocation
00335 #   define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
00337 #   define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes, __FILE__, __LINE__, __FUNCTION__)
00339 #   define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
00341 #   define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count), __FILE__, __LINE__, __FUNCTION__))
00343 #   define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr)
00345 #   define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr)
00346 
00348 #   define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
00350 #   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) 
00352 #   define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes(ptr);}
00354 #   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);}
00356 #   define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T), __FILE__, __LINE__, __FUNCTION__)) T
00358 #   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) 
00360 #   define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes(ptr);}
00362 #   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);}
00363 
00364 // new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
00365 // Also hooks up the file/line/function params
00366 // Can only be used with classes that derive from AllocatedObject since customised new/delete needed
00367 #   define OGRE_NEW new (__FILE__, __LINE__, __FUNCTION__)
00368 #   define OGRE_DELETE delete
00369 
00370 
00371 #else // !OGRE_DEBUG_MODE
00372 
00374 #   define OGRE_MALLOC(bytes, category) ::Ogre::CategorisedAllocPolicy<category>::allocateBytes(bytes)
00376 #   define OGRE_ALLOC_T(T, count, category) static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
00378 #   define OGRE_FREE(ptr, category) ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr)
00379 
00381 #   define OGRE_NEW_T(T, category) new (::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T))) T
00383 #   define OGRE_NEW_ARRAY_T(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count) 
00385 #   define OGRE_DELETE_T(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAllocPolicy<category>::deallocateBytes((void*)ptr);}
00387 #   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);}
00388 
00389 // aligned allocation
00391 #   define OGRE_MALLOC_SIMD(bytes, category) ::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(bytes)
00393 #   define OGRE_MALLOC_ALIGN(bytes, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(bytes)
00395 #   define OGRE_ALLOC_T_SIMD(T, count, category) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count)))
00397 #   define OGRE_ALLOC_T_ALIGN(T, count, category, align) static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count)))
00399 #   define OGRE_FREE_SIMD(ptr, category) ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr)
00401 #   define OGRE_FREE_ALIGN(ptr, category, align) ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr)
00402 
00404 #   define OGRE_NEW_T_SIMD(T, category) new (::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T))) T
00406 #   define OGRE_NEW_ARRAY_T_SIMD(T, count, category) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category>::allocateBytes(sizeof(T)*(count))), count) 
00408 #   define OGRE_DELETE_T_SIMD(ptr, T, category) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category>::deallocateBytes((void*)ptr);}
00410 #   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);}
00412 #   define OGRE_NEW_T_ALIGN(T, category, align) new (::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T))) T
00414 #   define OGRE_NEW_ARRAY_T_ALIGN(T, count, category, align) ::Ogre::constructN(static_cast<T*>(::Ogre::CategorisedAlignAllocPolicy<category, align>::allocateBytes(sizeof(T)*(count))), count) 
00416 #   define OGRE_DELETE_T_ALIGN(ptr, T, category, align) if(ptr){(ptr)->~T(); ::Ogre::CategorisedAlignAllocPolicy<category, align>::deallocateBytes((void*)ptr);}
00418 #   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);}
00419 
00420 // new / delete for classes deriving from AllocatedObject (alignment determined by per-class policy)
00421 #   define OGRE_NEW new 
00422 #   define OGRE_DELETE delete
00423 
00424 #endif // OGRE_DEBUG_MODE
00425 
00426 
00427 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:24 2009