#include <dali/internal/common/fixed-size-memory-pool.h>
// INTERNAL HEADERS
+#include <dali/devel-api/threading/mutex.h>
#include <dali/public-api/common/dali-common.h>
namespace Dali
* @brief Constructor
*/
Impl( SizeType fixedSize, SizeType initialCapacity, SizeType maximumBlockCapacity )
- : mFixedSize( fixedSize ),
+ : mMutex(),
+ mFixedSize( fixedSize ),
mMemoryBlocks( initialCapacity * mFixedSize ),
mMaximumBlockCapacity( maximumBlockCapacity ),
mCurrentBlock( &mMemoryBlocks ),
mCurrentBlockSize = 0;
}
+ Mutex mMutex; ///< Mutex for thread-safe allocation and deallocation
+
SizeType mFixedSize; ///< The size of each allocation in bytes
Block mMemoryBlocks; ///< Linked list of allocated memory blocks
void* FixedSizeMemoryPool::Allocate()
{
+ Mutex::ScopedLock( mImpl->mMutex );
+
// First, recycle deleted objects
if( mImpl->mDeletedObjects )
{
void FixedSizeMemoryPool::Free( void* memory )
{
+ Mutex::ScopedLock( mImpl->mMutex );
+
// Add memory to head of deleted objects list. Store next address in the same memory space as the old object.
*( reinterpret_cast< void** >( memory ) ) = mImpl->mDeletedObjects;
mImpl->mDeletedObjects = memory;
}
+void* FixedSizeMemoryPool::AllocateThreadSafe()
+{
+ Mutex::ScopedLock( mImpl->mMutex );
+ return Allocate();
+}
+
+void FixedSizeMemoryPool::FreeThreadSafe( void* memory )
+{
+ Mutex::ScopedLock( mImpl->mMutex );
+ Free( memory );
+}
+
+
} // namespace Internal
} // namespace Dali
void* Allocate();
/**
+ * @brief Thread-safe version of Allocate()
+ *
+ * @return Return the newly allocated memory
+ */
+ void* AllocateThreadSafe();
+
+ /**
* @brief Delete a block of memory for the allocation that has been allocated by this memory pool
*
* @param memory The memory to be deleted. Must have been allocated by this memory pool
*/
void Free( void* memory );
+ /**
+ * @brief Thread-safe version of Free()
+ *
+ * @param memory The memory to be deleted. Must have been allocated by this memory pool
+ */
+ void FreeThreadSafe( void* memory );
+
private:
// Undefined
}
/**
+ * @brief Thread-safe version of Allocate()
+ *
+ * @return Return the allocated object
+ */
+ T* AllocateThreadSafe()
+ {
+ return new ( mPool->AllocateThreadSafe() ) T();
+ }
+
+ /**
* @brief Allocate a block of memory from the memory pool of the appropriate size to
* store an object of type T. This is usually so the memory can be used in a
* placement new for an object of type T with a constructor that takes multiple
}
/**
+ * @brief Thread-safe version of AllocateRaw()
+ *
+ * @return Return the allocated memory block
+ */
+ void* AllocateRawThreadSafe()
+ {
+ return mPool->AllocateThreadSafe();
+ }
+
+ /**
* @brief Return the object to the memory pool
*
* @param object Pointer to the object to delete
}
/**
+ * @brief Thread-safe version of Free()
+ *
+ * @param object Pointer to the object to delete
+ */
+ void FreeThreadSafe( T* object )
+ {
+ object->~T();
+
+ mPool->FreeThreadSafe( object );
+ }
+
+ /**
* @brief Reset the memory pool, unloading all block memory previously allocated
*/
void ResetMemoryPool()
EventThreadServices& eventThreadServices = GetEventThreadServices();
SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- mSceneObject = new SceneGraph::Material();
+ mSceneObject = SceneGraph::Material::New();
AddMessage( updateManager, updateManager.GetMaterialOwner(), *mSceneObject );
eventThreadServices.RegisterObject( this );
EventThreadServices& eventThreadServices = GetEventThreadServices();
SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- mSceneObject = new SceneGraph::Renderer();
+ mSceneObject = SceneGraph::Renderer::New();
AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
eventThreadServices.RegisterObject( this );
#include <dali/internal/render/common/render-item.h>
// INTERNAL INCLUDES
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/render/renderers/render-renderer.h>
+namespace
+{
+//Memory pool used to allocate new RenderItems. Memory used by this pool will be released when shutting down DALi
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::RenderItem> gRenderItemPool;
+}
namespace Dali
{
namespace SceneGraph
{
+RenderItem* RenderItem::New()
+{
+ return new ( gRenderItemPool.AllocateRaw() ) RenderItem();
+}
+
RenderItem::RenderItem()
: mModelViewMatrix( false ),
mRenderer( NULL ),
{
}
+void RenderItem::operator delete( void* ptr )
+{
+ gRenderItemPool.Free( static_cast<RenderItem*>( ptr ) );
+}
+
void RenderItem::Reset()
{
mRenderer = NULL;
public:
/**
- * Create a new render-item.
+ * Construct a new RenderItem
*/
- RenderItem();
+ static RenderItem* New();
/**
* Non-virtual destructor; RenderItem is not suitable as a base class.
~RenderItem();
/**
+ * Overriden delete operator.
+ * Deletes the RenderItem from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* Reset the render-item.
*/
void Reset();
private:
+ /**
+ * Private constructor. See RenderItem::New
+ */
+ RenderItem();
+
// RenderItems should not be copied as they are heavy
RenderItem( const RenderItem& item );
RenderItem& operator = ( const RenderItem& item );
// check if we have enough items, we can only be one behind at worst
if( mItems.Count() <= mNextFree )
{
- mItems.PushBack( new RenderItem ); // Push a new empty render item
+ mItems.PushBack( RenderItem::New() ); // Push a new empty render item
}
// get the item mNextFree points to and increase by one
RenderItem& item = *mItems[ mNextFree++ ];
#include <cmath> // fmod
// INTERNAL INCLUDES
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/render/common/performance-monitor.h>
+namespace //Unnamed namespace
+{
+//Memory pool used to allocate new animations. Memory used by this pool will be released when shutting down DALi
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Animation> gAnimationMemoryPool;
+}
+
namespace Dali
{
namespace SceneGraph
{
+Animation* Animation::New( float durationSeconds, float speedFactor, const Vector2& playRange, bool isLooping, EndAction endAction, EndAction disconnectAction )
+{
+ return new ( gAnimationMemoryPool.AllocateRawThreadSafe() ) Animation( durationSeconds, speedFactor, playRange, isLooping, endAction, disconnectAction );
+}
Animation::Animation( float durationSeconds, float speedFactor, const Vector2& playRange, bool isLooping, Dali::Animation::EndAction endAction, Dali::Animation::EndAction disconnectAction )
: mDurationSeconds(durationSeconds),
{
}
+void Animation::operator delete( void* ptr )
+{
+ gAnimationMemoryPool.FreeThreadSafe( static_cast<Animation*>( ptr ) );
+}
+
void Animation::SetDuration(float durationSeconds)
{
mDurationSeconds = durationSeconds;
* @param[in] disconnectAction The action to perform when the property owner of an animator is disconnected.
* @return A new Animation
*/
- static Animation* New( float durationSeconds, float speedFactor, const Vector2& playRange, bool isLooping, EndAction endAction, EndAction disconnectAction )
- {
- return new Animation( durationSeconds, speedFactor, playRange, isLooping, endAction, disconnectAction );
- }
+ static Animation* New( float durationSeconds, float speedFactor, const Vector2& playRange, bool isLooping, EndAction endAction, EndAction disconnectAction );
/**
* Virtual destructor
virtual ~Animation();
/**
+ * Overriden delete operator
+ * Deletes the animation from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* Set the duration of an animation.
* @pre durationSeconds must be greater than zero.
* @param[in] durationSeconds The duration in seconds.
#include <dali/internal/update/nodes/node.h>
// INTERNAL INCLUDES
+#include <dali/internal/common/internal-constants.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/update/node-attachments/node-attachment.h>
#include <dali/internal/update/common/discard-queue.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
-#include <dali/internal/common/internal-constants.h>
+
+namespace //Unnamed namespace
+{
+//Memory pool used to allocate new nodes. Memory used by this pool will be released when shutting down DALi
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Node> gNodeMemoryPool;
+}
namespace Dali
{
Node* Node::New()
{
- return new Node();
+ return new ( gNodeMemoryPool.AllocateRawThreadSafe() ) Node();
}
Node::Node()
{
}
+void Node::operator delete( void* ptr )
+{
+ gNodeMemoryPool.FreeThreadSafe( static_cast<Node*>( ptr ) );
+}
+
void Node::OnDestroy()
{
// Node attachments should be notified about the disconnection.
virtual ~Node();
/**
+ * Overriden delete operator
+ * Deletes the node from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* When a Node is marked "active" it has been disconnected, but its properties have been modified.
* @note An inactive Node will be skipped during the UpdateManager ResetProperties stage.
* @param[in] isActive True if the Node is active.
#include <dali/internal/update/resources/texture-metadata.h>
#include <dali/internal/update/resources/resource-manager.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
+
+namespace //Unnamed namespace
+{
+//Memory pool used to allocate new materials. Memory used by this pool will be released when shutting down DALi
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Material> gMaterialMemoryPool;
+}
namespace Dali
{
namespace SceneGraph
{
+Material* Material::New()
+{
+ return new ( gMaterialMemoryPool.AllocateRawThreadSafe() ) Material();
+}
+
Material::Material()
: mShader( NULL ),
mBlendColor( NULL ),
mConnectionObservers.Destroy( *this );
}
+void Material::operator delete( void* ptr )
+{
+ gMaterialMemoryPool.FreeThreadSafe( static_cast<Material*>( ptr ) );
+}
+
void Material::Prepare( const ResourceManager& resourceManager )
{
if( mMaterialChanged )
};
/**
- * Constructor
+ * Construct a new Material.
*/
- Material();
+ static Material* New();
/**
* Destructor
virtual ~Material();
/**
+ * Overriden delete operator
+ * Deletes the material from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* Prepare material, check texture loading status, opacity etc
* @param resourceManager for checking texture details and loading status
*/
*/
virtual void ConnectedUniformMapChanged();
+private:
+
+ /**
+ * Protected constructor; See also Material::New()
+ */
+ Material();
+
private: // Data
Shader* mShader;
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/common/internal-constants.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
namespace // unnamed namespace
const unsigned int COPY_UNIFORM_MAP = 1;
const unsigned int REGENERATE_UNIFORM_MAP = 2;
+//Memory pool used to allocate new renderers. Memory used by this pool will be released when shutting down DALi
+Dali::Internal::MemoryPoolObjectAllocator<Dali::Internal::SceneGraph::Renderer> gRendererMemoryPool;
+
void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, const Dali::Internal::SceneGraph::UniformMap& uniformMap )
{
// Iterate thru uniformMap.
namespace SceneGraph
{
+Renderer* Renderer::New()
+{
+ return new ( gRendererMemoryPool.AllocateRawThreadSafe() ) Renderer();
+}
+
Renderer::Renderer()
:mSceneController(0),
mRenderer(NULL),
}
}
+void Renderer::operator delete( void* ptr )
+{
+ gRendererMemoryPool.FreeThreadSafe( static_cast<Renderer*>( ptr ) );
+}
+
+
void Renderer::PrepareRender( BufferIndex updateBufferIndex )
{
mResourcesReady = false;
};
/**
- * Default constructor
+ * Construct a new Renderer
*/
- Renderer();
+ static Renderer* New();
/**
* Destructor
virtual ~Renderer();
/**
+ * Overriden delete operator
+ * Deletes the renderer from its global memory pool
+ */
+ void operator delete( void* ptr );
+
+ /**
* Set the material for the renderer
* @param[in] bufferIndex The current frame's buffer index
* @param[in] material The material this renderer will use
private:
/**
+ * Protected constructor; See also Renderer::New()
+ */
+ Renderer();
+
+ /**
* Helper function to create a new render data provider
* @return the new (initialized) data provider
*/
projects / platform / core / uifw / dali-core.git / commitdiff