/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
DALI_TEST_CHECK(application.GetCore().GetObjectRegistry());
END_TEST;
}
+
+int UtcDaliCoreCheckMemoryPool(void)
+{
+ TestApplication application;
+
+ // Calling LogMemoryPools should check capacity across the board.
+ application.GetCore().LogMemoryPools();
+
+ tet_result(TET_PASS);
+ END_TEST;
+}
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return ObjectRegistry(&mImpl->GetObjectRegistry());
}
+void Core::LogMemoryPools() const
+{
+ mImpl->LogMemoryPools();
+}
+
Core::Core()
: mImpl(nullptr)
{
#define DALI_INTEGRATION_CORE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
ObjectRegistry GetObjectRegistry() const;
+ /**
+ * Log core's memory pool's capacities
+ */
+ void LogMemoryPools() const;
+
private:
/**
* Private constructor; see also Core::New()
mUpdateManager->SetShaderSaver(*mShaderFactory);
GetImplementation(Dali::TypeRegistry::Get()).CallInitFunctions();
+
+ DALI_LOG_RELEASE_INFO("Node size: %lu\n", sizeof(Dali::Internal::SceneGraph::Node));
+ DALI_LOG_RELEASE_INFO("Renderer size: %lu\n", sizeof(Dali::Internal::SceneGraph::Renderer));
+ DALI_LOG_RELEASE_INFO("RenderItem size: %lu\n", sizeof(Dali::Internal::SceneGraph::RenderItem));
}
Core::~Core()
return *(mObjectRegistry.Get());
}
+void Core::LogMemoryPools() const
+{
+ uint32_t animationPoolCapacity = SceneGraph::Animation::GetMemoryPoolCapacity();
+ uint32_t renderItemPoolCapacity = SceneGraph::RenderItem::GetMemoryPoolCapacity();
+ uint32_t relayoutItemPoolCapacity = mRelayoutController->GetMemoryPoolCapacity();
+ uint32_t rendererPoolCapacity = SceneGraph::Renderer::GetMemoryPoolCapacity();
+ uint32_t textureSetPoolCapacity = SceneGraph::TextureSet::GetMemoryPoolCapacity();
+ uint32_t renderTaskPoolCapacity = SceneGraph::RenderTaskList::GetMemoryPoolCapacity();
+ uint32_t nodePoolCapacity = SceneGraph::Node::GetMemoryPoolCapacity();
+
+ DALI_LOG_RELEASE_INFO(
+ "\nMemory Pool capacities:\n"
+ " Animations: %lu\n"
+ " RenderItems: %lu\n"
+ " RelayoutItems: %lu\n"
+ " Renderers: %lu\n"
+ " TextureSets: %lu\n"
+ " RenderTasks: %lu\n"
+ " Nodes: %lu\n",
+ animationPoolCapacity,
+ renderItemPoolCapacity,
+ relayoutItemPoolCapacity,
+ rendererPoolCapacity,
+ textureSetPoolCapacity,
+ renderTaskPoolCapacity,
+ nodePoolCapacity);
+
+ uint32_t updateQCapacity = mUpdateManager->GetUpdateMessageQueueCapacity();
+ uint32_t renderQCapacity = mUpdateManager->GetRenderMessageQueueCapacity();
+
+ DALI_LOG_RELEASE_INFO(
+ "\nMessage Queue capacities:\n"
+ " UpdateQueue: %lu\n"
+ " RenderQueue: %lu\n",
+ updateQCapacity,
+ renderQCapacity);
+
+ size_t renderInstructionCapacity = mUpdateManager->GetRenderInstructionCapacity();
+ DALI_LOG_RELEASE_INFO("\nRenderInstruction capacity: %lu\n", renderInstructionCapacity);
+}
+
EventThreadServices& Core::GetEventThreadServices()
{
return *this;
*/
ObjectRegistry& GetObjectRegistry() const;
+ /**
+ * Log the capacity of DALi memory pools
+ */
+ void LogMemoryPools() const;
+
public: // Implementation of EventThreadServices
/**
* @copydoc EventThreadServices::RegisterObject
}
}
+uint32_t FixedSizeMemoryPool::GetCapacity() const
+{
+ // Ignores deleted objects list, just returns currently allocated size
+ uint32_t totalAllocation = 0;
+#ifdef DEBUG_ENABLED
+ Mutex::ScopedLock lock(mImpl->mMutex);
+ Impl::Block* block = &mImpl->mMemoryBlocks;
+ while(block)
+ {
+ totalAllocation += block->mBlockSize;
+ block = block->nextBlock;
+ }
+#endif
+ return totalAllocation;
+}
+
} // namespace Internal
} // namespace Dali
#define DALI_INTERNAL_FIXED_SIZE_MEMORY_POOL_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
void FreeThreadSafe(void* memory);
+ /**
+ * Get the current capacity of the memory pool
+ *
+ * @note in release mode, this returns 0, as the block size isn't defined.
+ */
+ uint32_t GetCapacity() const;
+
private:
// Undefined
FixedSizeMemoryPool(const FixedSizeMemoryPool& fixedSizeMemoryPool);
#define DALI_INTERNAL_MEMORY_POOL_OBJECT_ALLOCATOR_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
mPool = new FixedSizeMemoryPool(TypeSizeWithAlignment<T>::size);
}
+ /**
+ * @brief Get the capacity of the memory pool
+ */
+ uint32_t GetCapacity() const
+ {
+ return mPool->GetCapacity();
+ }
+
private:
// Undefined
MemoryPoolObjectAllocator(const MemoryPoolObjectAllocator& memoryPoolObjectAllocator);
// CLASS HEADER
#include <dali/internal/event/images/pixel-data-impl.h>
+#include <dali/integration-api/debug.h>
+
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gPixelDataLogFilter = Debug::Filter::New(Debug::NoLogging, false, "DALI_LOG_PIXEL_DATA_SIZE");
+#endif
+
namespace Dali
{
namespace Internal
{
+#if defined(DEBUG_ENABLED)
+// Only track data allocation if debug is enabled
+uint32_t PixelData::gPixelDataAllocationTotal{0};
+#endif
+
PixelData::PixelData(uint8_t* buffer,
uint32_t bufferSize,
uint32_t width,
mPixelFormat(pixelFormat),
mReleaseFunction(releaseFunction)
{
+ DALI_LOG_INFO(gPixelDataLogFilter, Debug::Concise, "Allocated PixelData of size %u\n", bufferSize);
+#if defined(DEBUG_ENABLED)
+ gPixelDataAllocationTotal += mBufferSize;
+#endif
}
PixelData::~PixelData()
{
delete[] mBuffer;
}
+#if defined(DEBUG_ENABLED)
+ gPixelDataAllocationTotal -= mBufferSize;
+#endif
}
}
// INTERNAL INCLUDES
#include <dali/devel-api/images/pixel-data-devel.h>
+#include <dali/integration-api/debug.h>
#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/object/base-object.h>
*/
uint32_t GetStride() const;
+ /**
+ * Class method to get the total currently allocated size of pixel buffers
+ */
+ static uint32_t GetTotalAllocatedSize()
+ {
+#if defined(DEBUG_ENABLED)
+ return gPixelDataAllocationTotal;
+#else
+ return 0;
+#endif
+ }
+
private:
/*
* Undefined copy constructor.
uint32_t mStride; ///< Buffer stride in pixels, 0 means the buffer is tightly packed
Pixel::Format mPixelFormat; ///< Pixel format
Dali::PixelData::ReleaseFunction mReleaseFunction; ///< Function for releasing memory
+
+#if defined(DEBUG_ENABLED)
+ static uint32_t gPixelDataAllocationTotal;
+#endif
};
} // namespace Internal
}
}
+uint32_t RelayoutController::GetMemoryPoolCapacity()
+{
+ return mRelayoutInfoAllocator.GetCapacity();
+}
+
} // namespace Internal
} // namespace Dali
#define DALI_INTERNAL_RELAYOUT_CONTROLLER_IMPL_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
void SetProcessingCoreEvents(bool processingEvents);
+ /**
+ * Get the capacity of the memory pool containing relayout info
+ * (It Should be regularly purged!)
+ */
+ uint32_t GetMemoryPoolCapacity();
+
public: // CALLBACKS
/**
* @brief Callback raised after the application creates the scene
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
mInstructions.push_back(renderInstruction);
}
+std::size_t RenderInstructionContainer::GetCapacity() const
+{
+ std::size_t capacity{0};
+ for(auto& el : mInstructions)
+ {
+ capacity += el->GetCapacity();
+ }
+ capacity += mInstructions.size() * sizeof(RenderInstruction*);
+ return capacity;
+}
+
} // namespace SceneGraph
} // namespace Internal
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_CONTAINER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/buffer-index.h>
#include <dali/public-api/common/vector-wrapper.h>
+#include <cstddef>
namespace Dali
{
*/
void PushBack(BufferIndex index, RenderInstruction* renderInstruction);
+ /**
+ * Get the total memory used by all the render instructions
+ */
+ std::size_t GetCapacity() const;
+
private:
std::vector<RenderInstruction*> mInstructions;
};
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
}
+std::size_t RenderInstruction::GetCapacity()
+{
+ std::size_t capacity{0u};
+ RenderListContainer::Iterator iter = mRenderLists.Begin();
+ RenderListContainer::ConstIterator end = mRenderLists.End();
+ for(; iter != end; ++iter)
+ {
+ capacity += ((*iter)->GetCachedItemCount() * (sizeof(RenderItem) + sizeof(RenderItem*)));
+ capacity += sizeof(RenderList);
+ }
+ capacity += sizeof(RenderInstruction);
+ return capacity;
+}
+
} // namespace SceneGraph
} // namespace Internal
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return mCamera;
}
+ /**
+ * Get the total memory usage of the render instruction
+ */
+ std::size_t GetCapacity();
+
public: // Data
Render::RenderTracker* mRenderTracker; ///< Pointer to an optional tracker object (not owned)
gRenderItemPool.Free(static_cast<RenderItem*>(ptr));
}
+uint32_t RenderItem::GetMemoryPoolCapacity()
+{
+ return gRenderItemPool.GetCapacity();
+}
+
} // namespace SceneGraph
} // namespace Internal
bool mIsOpaque : 1;
bool mIsUpdated : 1;
+ /**
+ * Get the capacity of the global pool.
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
private:
/**
* Private constructor. See RenderItem::New
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void RenderQueue::ProcessMessages(BufferIndex bufferIndex)
{
+ std::size_t capacity = container0->GetCapacity() + container1->GetCapacity();
+ mCapacity = capacity; // write is atomic.
+
MessageBuffer* container = GetCurrentContainer(bufferIndex);
for(MessageBuffer::Iterator iter = container->Begin(); iter.IsValid(); iter.Next())
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_QUEUE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/common/message-buffer.h>
+#include <atomic>
+#include <cstddef>
namespace Dali
{
*/
void ProcessMessages(BufferIndex bufferIndex);
+ /**
+ * Return the current capacity total of both buffers.
+ */
+ std::size_t GetCapacity() const
+ {
+ return mCapacity;
+ }
+
private:
/**
* Helper to retrieve the current container.
private:
MessageBuffer* container0; ///< Messages are queued here when the update buffer index == 0
MessageBuffer* container1; ///< Messages are queued here when the update buffer index == 1
+
+ std::atomic<std::size_t> mCapacity{0u}; // Current total capacity of both buffers.
};
} // namespace SceneGraph
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
}
+uint32_t Animation::GetMemoryPoolCapacity()
+{
+ return gAnimationMemoryPool.GetCapacity();
+}
+
} // namespace SceneGraph
} // namespace Internal
#define DALI_INTERNAL_SCENE_GRAPH_ANIMATION_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
void Update(BufferIndex bufferIndex, float elapsedSeconds, bool& looped, bool& finished, bool& progressReached);
+ static uint32_t GetMemoryPoolCapacity();
+
protected:
/**
* Protected constructor. See New()
void SortSiblingNodesRecursively(Node& node)
{
NodeContainer& container = node.GetChildren();
- std::sort(container.Begin(), container.End(), [](Node* a, Node* b) { return a->GetDepthIndex() < b->GetDepthIndex(); });
+ std::sort(container.Begin(), container.End(), [](Node* a, Node* b)
+ { return a->GetDepthIndex() < b->GetDepthIndex(); });
// Descend tree and sort as well
for(auto&& iter : container)
{
}
- ~SceneInfo() = default; ///< Default non-virtual destructor
- SceneInfo(SceneInfo&& rhs) = default; ///< Move constructor
- SceneInfo& operator=(SceneInfo&& rhs) = default; ///< Move assignment operator
- SceneInfo& operator=(const SceneInfo& rhs) = delete; ///< Assignment operator
- SceneInfo(const SceneInfo& rhs) = delete; ///< Copy constructor
+ ~SceneInfo() = default; ///< Default non-virtual destructor
+ SceneInfo(SceneInfo&& rhs) = default; ///< Move constructor
+ SceneInfo& operator=(SceneInfo&& rhs) = default; ///< Move assignment operator
+ SceneInfo& operator=(const SceneInfo& rhs) = delete; ///< Assignment operator
+ SceneInfo(const SceneInfo& rhs) = delete; ///< Copy constructor
Layer* root{nullptr}; ///< Root node (root is a layer). The layer is not stored in the node memory pool.
OwnerPointer<RenderTaskList> taskList; ///< Scene graph render task list
OwnerPointer<FrameCallbackProcessor> frameCallbackProcessor; ///< Owned FrameCallbackProcessor, only created if required.
- float keepRenderingSeconds; ///< Set via Dali::Stage::KeepRendering
- NodePropertyFlags nodeDirtyFlags; ///< cumulative node dirty flags from previous frame
- uint32_t frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
-
- DevelStage::Rendering renderingBehavior; ///< Set via DevelStage::SetRenderingBehavior
+ std::atomic<std::size_t> renderInstructionCapacity{0u};
+ float keepRenderingSeconds; ///< Set via Dali::Stage::KeepRendering
+ NodePropertyFlags nodeDirtyFlags; ///< cumulative node dirty flags from previous frame
+ uint32_t frameCounter; ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
+ DevelStage::Rendering renderingBehavior; ///< Set via DevelStage::SetRenderingBehavior
bool animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
bool previousUpdateScene; ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
Layer* rootLayer = layer.Release();
- DALI_ASSERT_DEBUG(std::find_if(mImpl->scenes.begin(), mImpl->scenes.end(), [rootLayer](Impl::SceneInfoPtr& scene) {
- return scene && scene->root == rootLayer;
- }) == mImpl->scenes.end() &&
+ DALI_ASSERT_DEBUG(std::find_if(mImpl->scenes.begin(), mImpl->scenes.end(), [rootLayer](Impl::SceneInfoPtr& scene)
+ { return scene && scene->root == rootLayer; }) == mImpl->scenes.end() &&
"Root Node already installed");
rootLayer->CreateTransform(&mImpl->transformManager);
return mImpl->messageQueue.ReserveMessageSlot(size, updateScene);
}
+std::size_t UpdateManager::GetUpdateMessageQueueCapacity() const
+{
+ return mImpl->messageQueue.GetCapacity();
+}
+
+std::size_t UpdateManager::GetRenderMessageQueueCapacity() const
+{
+ return mImpl->renderQueue.GetCapacity();
+}
+
+std::size_t UpdateManager::GetRenderInstructionCapacity() const
+{
+ return mImpl->renderInstructionCapacity;
+}
+
void UpdateManager::EventProcessingStarted()
{
mImpl->messageQueue.EventProcessingStarted();
void UpdateManager::ConstrainCustomObjects(BufferIndex bufferIndex)
{
- //Constrain custom objects (in construction order)
+ // Constrain custom objects (in construction order)
for(auto&& object : mImpl->customObjects)
{
ConstrainPropertyOwner(*object, bufferIndex);
{
for(auto&& renderer : mImpl->renderers)
{
- //Apply constraints
+ // Apply constraints
ConstrainPropertyOwner(*renderer, bufferIndex);
mImpl->renderingRequired = renderer->PrepareRender(bufferIndex) || mImpl->renderingRequired;
{
const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
- //Clear nodes/resources which were previously discarded
+ // Clear nodes/resources which were previously discarded
mImpl->discardQueue.Clear(bufferIndex);
bool isAnimationRunning = IsAnimationRunning();
- //Process Touches & Gestures
+ // Process Touches & Gestures
const bool gestureUpdated = ProcessGestures(bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds);
bool updateScene = // The scene-graph requires an update if..
// values if the scene was updated in the previous frame.
if(updateScene || mImpl->previousUpdateScene)
{
- //Reset properties from the previous update
+ // Reset properties from the previous update
ResetProperties(bufferIndex);
mImpl->transformManager.ResetToBaseValue();
}
// be set again
updateScene |= mImpl->messageQueue.ProcessMessages(bufferIndex);
- //Forward compiled shader programs to event thread for saving
+ // Forward compiled shader programs to event thread for saving
ForwardCompiledShadersToEventThread();
// Although the scene-graph may not require an update, we still need to synchronize double-buffered
// We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
if(updateScene || mImpl->previousUpdateScene)
{
- //Animate
+ // Animate
bool animationActive = Animate(bufferIndex, elapsedSeconds);
- //Constraint custom objects
+ // Constraint custom objects
ConstrainCustomObjects(bufferIndex);
- //Clear the lists of renderers from the previous update
+ // Clear the lists of renderers from the previous update
for(auto&& scene : mImpl->scenes)
{
if(scene)
mImpl->frameCallbackProcessor->Update(bufferIndex, elapsedSeconds);
}
- //Update node hierarchy, apply constraints,
+ // Update node hierarchy, apply constraints,
UpdateNodes(bufferIndex);
- //Apply constraints to RenderTasks, shaders
+ // Apply constraints to RenderTasks, shaders
ConstrainRenderTasks(bufferIndex);
ConstrainShaders(bufferIndex);
- //Update renderers and apply constraints
+ // Update renderers and apply constraints
UpdateRenderers(bufferIndex);
- //Update the transformations of all the nodes
+ // Update the transformations of all the nodes
if(mImpl->transformManager.Update())
{
mImpl->nodeDirtyFlags |= NodePropertyFlags::TRANSFORM;
}
- //Initialise layer renderable reuse
+ // Initialise layer renderable reuse
UpdateLayers(bufferIndex);
- //Process Property Notifications
+ // Process Property Notifications
ProcessPropertyNotifications(bufferIndex);
- //Update cameras
+ // Update cameras
for(auto&& cameraIterator : mImpl->cameras)
{
cameraIterator->Update(bufferIndex);
}
- //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
- //reset the update buffer index and make sure there is enough room in the instruction container
+ // Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
+ // reset the update buffer index and make sure there is enough room in the instruction container
if(mImpl->renderersAdded)
{
// Calculate how many render tasks we have in total
}
std::size_t numberOfRenderInstructions = 0;
+ mImpl->renderInstructionCapacity = 0u;
for(auto&& scene : mImpl->scenes)
{
if(scene && scene->root && scene->taskList && scene->scene)
renderToFboEnabled,
isRenderingToFbo);
+ mImpl->renderInstructionCapacity += scene->scene->GetRenderInstructions().GetCapacity();
scene->scene->SetSkipRendering(false);
}
else
#include <dali/internal/update/rendering/scene-graph-renderer.h> // for OwnerPointer< Renderer >
#include <dali/internal/update/rendering/scene-graph-texture-set.h> // for OwnerPointer< TextureSet >
+// EXTERNAL INCLUDES
+#include <cstddef>
+
namespace Dali
{
class FrameCallbackInterface;
*/
void RemoveFrameCallback(FrameCallbackInterface* frameCallback);
+ /**
+ * Get the update message queue capacity (mutex locked)
+ */
+ std::size_t GetUpdateMessageQueueCapacity() const;
+
+ /**
+ * Get the render message queue capacity
+ */
+ std::size_t GetRenderMessageQueueCapacity() const;
+
+ /**
+ * Get the render instruction capacity
+ */
+ std::size_t GetRenderInstructionCapacity() const;
+
private:
// Undefined
UpdateManager(const UpdateManager&);
}
}
+uint32_t Node::GetMemoryPoolCapacity()
+{
+ return gNodeMemoryPool.GetCapacity();
+}
+
} // namespace SceneGraph
} // namespace Internal
}
/**
+ * @brief Get the total capacity of the memory pools
+ * @return The capacity of the memory pools
+ *
+ * @note This is different to the node count.
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
+ /**
* @brief Returns partial rendering data associated with the node.
* @return The partial rendering data
*/
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return mImpl->sceneUpdate;
}
+std::size_t MessageQueue::GetCapacity() const
+{
+ MessageQueueMutex::ScopedLock lock(mImpl->queueMutex);
+
+ uint32_t capacity = 0u;
+ MessageBufferIter endIter = mImpl->freeQueue.end();
+ for(MessageBufferIter iter = mImpl->freeQueue.begin(); iter != endIter; ++iter)
+ {
+ capacity += (*iter)->GetCapacity();
+ }
+ endIter = mImpl->processQueue.end();
+ for(MessageBufferIter iter = mImpl->processQueue.begin(); iter != endIter; ++iter)
+ {
+ capacity += (*iter)->GetCapacity();
+ }
+ if(mImpl->currentMessageBuffer != nullptr)
+ {
+ capacity += mImpl->currentMessageBuffer->GetCapacity();
+ }
+ return capacity;
+}
+
} // namespace Update
} // namespace Internal
#define DALI_INTERNAL_UPDATE_MESSAGE_QUEUE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/update/common/scene-graph-buffers.h>
+// EXTERNAL INCLUDES
+#include <cstddef>
+
namespace Dali
{
namespace Integration
*/
bool IsSceneUpdateRequired() const;
+ /**
+ * Query for the capacity of the current message queue
+ */
+ std::size_t GetCapacity() const;
+
private:
/**
* Helper to call Process and destructor on each queued message
private:
// Not copyable:
- MessageQueue() = delete;
- MessageQueue(const MessageQueue& rhs) = delete;
+ MessageQueue() = delete;
+ MessageQueue(const MessageQueue& rhs) = delete;
MessageQueue& operator=(const MessageQueue& rhs) = delete;
private:
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return mNotificationObject;
}
+uint32_t RenderTaskList::GetMemoryPoolCapacity()
+{
+ return gRenderTaskListMemoryPool.GetCapacity();
+}
+
} // namespace SceneGraph
} // namespace Internal
#define DALI_INTERNAL_SCENE_GRAPH_RENDER_TASK_LIST_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
CompleteNotificationInterface* GetCompleteNotificationInterface();
+ /**
+ * Get the capacity of the memory pools
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
protected:
/**
* Protected constructor. See New()
SetUpdated(false);
}
+uint32_t Renderer::GetMemoryPoolCapacity()
+{
+ return gRendererMemoryPool.GetCapacity();
+}
+
void Renderer::UniformMappingsChanged(const UniformMap& mappings)
{
// The mappings are either from PropertyOwner base class, or the Shader
*/
void ResetDirtyFlag();
+ /**
+ * Get the capacity of the memory pools
+ * @return the capacity of the memory pools
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
public: // UniformMap::Observer
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
return mHasAlpha;
}
+uint32_t TextureSet::GetMemoryPoolCapacity()
+{
+ return gTextureSetMemoryPool.GetCapacity();
+}
+
} // namespace SceneGraph
} // namespace Internal
#define DALI_INTERNAL_SCENE_GRAPH_TEXTURE_SET_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return mSamplers;
}
+ /**
+ * Get the capacity of the memory pools
+ * @return the capacity of the memory pools
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
private:
/**
* Protected constructor; See also TextureSet::New()
return GetImplementation(*this).GetStride();
}
+uint32_t PixelData::GetTotalAllocatedSize()
+{
+ return Internal::PixelData::GetTotalAllocatedSize();
+}
+
} // namespace Dali
*/
uint32_t GetStride() const;
+ /**
+ * Class method to get the total currently allocated size of pixel buffers
+ */
+ static uint32_t GetTotalAllocatedSize();
+
public:
/**
* @brief The constructor.
/**
* @}
*/
-} //namespace Dali
+} // namespace Dali
#endif // DALI_PIXEL_DATA_H
projects / platform / core / uifw / dali-core.git / commitdiff