--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali/integration-api/debug.h>
+#include <dali/integration-api/trace.h>
+
+#include <chrono>
+#include <iostream>
+#include <list>
+#include <thread>
+
+// INTERNAL INCLUDES
+#include "shared/utility.h"
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+using namespace std;
+
+// TODO : borderline, blur type need to solve partial update issue.
+// Until that issue exist, just block it.
+#define ALLOW_BORDER_AND_BLUR 0
+
+namespace
+{
+enum class ControlTestType
+{
+ // clang-format off
+ COLOR = 0, ///< Test with simple color
+ IMAGE, ///< Test with simple image
+ TEXT, ///< Test with simple text label
+ ROUNDED_COLOR, ///< Test with rounded color
+#if ALLOW_BORDER_AND_BLUR
+ BORDER_COLOR, ///< Test with borderline color
+ ROUNDED_BORDER_COLOR, ///< Test with rounded borderline color
+ BLUR_COLOR, ///< Test with blur color
+ ROUNDED_BLUR_COLOR, ///< Test with blur color
+#endif
+ TYPE_MAX,
+ // clang-format on
+};
+
+const char* TestTypeString(ControlTestType type)
+{
+ // clang-format off
+ switch(type)
+ {
+ case ControlTestType::COLOR: return "COLOR";
+ case ControlTestType::IMAGE: return "IMAGE";
+ case ControlTestType::TEXT: return "TEXT";
+ case ControlTestType::ROUNDED_COLOR: return "ROUNDED COLOR";
+#if ALLOW_BORDER_AND_BLUR
+ case ControlTestType::BORDER_COLOR: return "BORDER COLOR";
+ case ControlTestType::ROUNDED_BORDER_COLOR:return "ROUNDED BORDER COLOR";
+ case ControlTestType::BLUR_COLOR: return "BLUR COLOR";
+ case ControlTestType::ROUNDED_BLUR_COLOR: return "ROUNDED BLUR COLOR";
+#endif
+ default: return "UNKNOWN";
+ }
+ // clang-format on
+}
+
+// NOTE : Due to the image load is bottleneck on target, we just use single small image.
+const char* IMAGE_PATH[] = {
+ DEMO_IMAGE_DIR "gallery-small-1.jpg",
+};
+
+constexpr uint32_t NUM_IMAGES = sizeof(IMAGE_PATH) / sizeof(char*);
+
+constexpr uint32_t ROWS_COUNT(40);
+constexpr uint32_t COLUMNS_COUNT(40);
+constexpr uint32_t TOTAL_COLUMNS_COUNT(80);
+constexpr uint32_t DURATION_PER_COLUMNS(50); // miliseconds.
+// Increase animation time cause OnTick time can be delayed.
+constexpr uint32_t DURATION_OF_ANIMATION(DURATION_PER_COLUMNS*(COLUMNS_COUNT * 4 / 3)); // miliseconds.
+
+// We should render same type of views in some timing.
+static_assert(COLUMNS_COUNT * 2 <= TOTAL_COLUMNS_COUNT);
+
+constexpr float VIEW_MARGIN_RATE = 0.1f;
+
+// copy from dali-adaptor time-service.cpp
+void GetNanoseconds(uint64_t& timeInNanoseconds)
+{
+ // Get the time of a monotonic clock since its epoch.
+ auto epoch = std::chrono::steady_clock::now().time_since_epoch();
+
+ auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(epoch);
+
+ timeInNanoseconds = static_cast<uint64_t>(duration.count());
+}
+
+Control CreateColor()
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+ bgView.SetBackgroundColor(Color::YELLOW);
+ return bgView;
+}
+
+Control CreateImage(uint32_t& imageCount)
+{
+ Control bgView = ImageView::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, IMAGE_PATH[imageCount++ % NUM_IMAGES]);
+ return bgView;
+}
+
+Control CreateTextLabel()
+{
+ Control bgView = TextLabel::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS, "Hello, World!");
+ return bgView;
+}
+
+Control CreateRoundedColor()
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+
+ Property::Map map;
+ map[Visual::Property::TYPE] = Visual::COLOR;
+ map[ColorVisual::Property::MIX_COLOR] = Color::YELLOW;
+ map[DevelVisual::Property::CORNER_RADIUS] = 0.5f;
+ map[DevelVisual::Property::CORNER_RADIUS_POLICY] = Visual::Transform::Policy::RELATIVE;
+
+ bgView[Control::Property::BACKGROUND] = map;
+
+ return bgView;
+}
+
+#if ALLOW_BORDER_AND_BLUR
+Control CreateBorderColor(const float& requiredBorderlineWidth)
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+
+ Property::Map map;
+ map[Visual::Property::TYPE] = Visual::COLOR;
+ map[ColorVisual::Property::MIX_COLOR] = Color::YELLOW;
+ map[DevelVisual::Property::BORDERLINE_WIDTH] = requiredBorderlineWidth;
+ map[DevelVisual::Property::BORDERLINE_COLOR] = Color::RED;
+
+ bgView[Control::Property::BACKGROUND] = map;
+
+ return bgView;
+}
+
+Control CreateRoundedBorderColor(const float& requiredBorderlineWidth)
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+
+ Property::Map map;
+ map[Visual::Property::TYPE] = Visual::COLOR;
+ map[ColorVisual::Property::MIX_COLOR] = Color::YELLOW;
+ map[DevelVisual::Property::CORNER_RADIUS] = 0.5f;
+ map[DevelVisual::Property::CORNER_RADIUS_POLICY] = Visual::Transform::Policy::RELATIVE;
+ map[DevelVisual::Property::BORDERLINE_WIDTH] = requiredBorderlineWidth;
+ map[DevelVisual::Property::BORDERLINE_COLOR] = Color::RED;
+
+ bgView[Control::Property::BACKGROUND] = map;
+
+ return bgView;
+}
+
+Control CreateBlurColor(const float& requiredBlurRadius)
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+
+ Property::Map map;
+ map[Visual::Property::TYPE] = Visual::COLOR;
+ map[ColorVisual::Property::MIX_COLOR] = Color::YELLOW;
+ map[DevelColorVisual::Property::BLUR_RADIUS] = requiredBlurRadius;
+
+ bgView[Control::Property::BACKGROUND] = map;
+
+ return bgView;
+}
+
+Control CreateRoundedBlurColor(const float& requiredBlurRadius)
+{
+ Control bgView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+
+ Property::Map map;
+ map[Visual::Property::TYPE] = Visual::COLOR;
+ map[ColorVisual::Property::MIX_COLOR] = Color::YELLOW;
+ map[DevelVisual::Property::CORNER_RADIUS] = 0.5f;
+ map[DevelVisual::Property::CORNER_RADIUS_POLICY] = Visual::Transform::Policy::RELATIVE;
+ map[DevelColorVisual::Property::BLUR_RADIUS] = requiredBlurRadius;
+
+ bgView[Control::Property::BACKGROUND] = map;
+
+ return bgView;
+}
+#endif
+
+/**
+ * @brief Statistic container that we can get average / sum / min/ max.
+ *
+ * @tparam T Type of data. T should define add, compare, div-by-int, numeric_limits<T>::min and max
+ */
+template<typename T>
+struct Statistic
+{
+ static constexpr double trimRate = 0.34;
+
+ std::vector<T> v;
+ int vcnt;
+ T vsum;
+ T vmax;
+ T vmin;
+ Statistic()
+ {
+ Clear();
+ }
+
+ void Clear()
+ {
+ v.clear();
+ vcnt = 0;
+ vsum = 0;
+ vmax = std::numeric_limits<T>::min();
+ vmin = std::numeric_limits<T>::max();
+ }
+
+ void Add(T x)
+ {
+ v.emplace_back(x);
+ vsum += x;
+ vcnt++;
+ vmax = std::max(vmax, x);
+ vmin = std::min(vmin, x);
+ }
+
+ double GetAverage()
+ {
+ if(vcnt == 0) return 0.0;
+ return static_cast<double>(vsum) / vcnt;
+ }
+
+ double GetTrimedAverage()
+ {
+ if(vcnt == 0) return 0.0;
+ std::sort(v.begin(), v.end());
+ T trimVsum = 0;
+ int removedCnt = static_cast<int>(vcnt * trimRate * 0.5); // floor
+ int trimVcnt = vcnt - removedCnt * 2;
+ if(trimVcnt == 0)
+ {
+ trimVcnt += 2;
+ removedCnt--;
+ }
+ for(int i = removedCnt; i < vcnt - removedCnt; i++)
+ {
+ trimVsum += v[i];
+ }
+
+ return static_cast<double>(trimVsum) / trimVcnt;
+ }
+};
+
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERF_VIEW_CREATION_SAMPLE, true);
+
+} // namespace
+
+/**
+ * Test application to compare performance between various type of Views creation time & manually created Renderers
+ */
+class PerfViewCreation : public ConnectionTracker
+{
+public:
+ PerfViewCreation(Application& application)
+ : mApplication(application),
+ mRowsCount(ROWS_COUNT),
+ mColumnsCount(COLUMNS_COUNT),
+ mTotalColumnsCount(TOTAL_COLUMNS_COUNT),
+ mDurationPerColumns(DURATION_PER_COLUMNS),
+ mDurationOfAnimation(DURATION_OF_ANIMATION),
+ mTestType(ControlTestType::COLOR)
+ {
+ // Connect to the Application's Init signal
+ mApplication.InitSignal().Connect(this, &PerfViewCreation::Create);
+ }
+
+ ~PerfViewCreation() = default;
+
+ // The Init signal is received once (only) during the Application lifetime
+ void Create(Application& application)
+ {
+ GetNanoseconds(mAppStartTime);
+
+ // Get a handle to the window
+ mWindow = application.GetWindow();
+ mWindow.SetBackgroundColor(Color::WHITE);
+ mWindowSize = mWindow.GetSize();
+
+ mWindow.GetRootLayer().SetProperty(Layer::Property::DEPTH_TEST, false);
+
+ mSize = Vector3(mWindowSize.x / mColumnsCount, mWindowSize.y / mRowsCount, 0.0f);
+
+ Timer timer = Timer::New(mDurationPerColumns);
+ timer.TickSignal().Connect(this, &PerfViewCreation::OnTick);
+ mTimerList.push_back(timer);
+
+ mCreationStatistic.Clear();
+
+ mCreateCount = 0;
+ mDeleteCount = 0;
+ mImageCount = 0;
+
+ timer.Start();
+
+ // Respond to key events
+ mWindow.KeyEventSignal().Connect(this, &PerfViewCreation::OnKeyEvent);
+ }
+
+ bool OnTick()
+ {
+ CreateColumnView();
+ if(mCreateCount < mColumnsCount)
+ {
+ // Start next phase.
+ Timer timer = Timer::New(mDurationPerColumns);
+ timer.TickSignal().Connect(this, &PerfViewCreation::OnTick);
+ mTimerList.push_back(timer);
+
+ timer.Start();
+ }
+ return false;
+ }
+ void CreateColumnView()
+ {
+ uint64_t startTime;
+ uint64_t endTime;
+
+ GetNanoseconds(startTime);
+ DALI_TRACE_BEGIN(gTraceFilter, "DALI_SAMPLE_PERF_VIEW_CREATION");
+
+ Control columnView = Control::New(Control::ControlBehaviour::DISABLE_STYLE_CHANGE_SIGNALS);
+ columnView.SetBackgroundColor(Color::BLUE);
+ columnView[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+ columnView[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ columnView[Actor::Property::SIZE] = Vector2(mSize.x, (float)mWindowSize.y);
+ columnView[Actor::Property::POSITION] = Vector2(mSize.x * (mCreateCount % mColumnsCount), -(float)mWindowSize.y);
+ for(uint32_t i = 0; i < mRowsCount; ++i)
+ {
+ Control bgView;
+ switch(mTestType)
+ {
+ case ControlTestType::COLOR:
+ default:
+ {
+ bgView = CreateColor();
+ break;
+ }
+ case ControlTestType::IMAGE:
+ {
+ bgView = CreateImage(mImageCount);
+ break;
+ }
+ case ControlTestType::TEXT:
+ {
+ bgView = CreateTextLabel();
+ break;
+ }
+ case ControlTestType::ROUNDED_COLOR:
+ {
+ bgView = CreateRoundedColor();
+ break;
+ }
+#if ALLOW_BORDER_AND_BLUR
+ case ControlTestType::BORDER_COLOR:
+ {
+ bgView = CreateBorderColor(std::min(mSize.x, mSize.y) * VIEW_MARGIN_RATE);
+ break;
+ }
+ case ControlTestType::ROUNDED_BORDER_COLOR:
+ {
+ bgView = CreateRoundedBorderColor(std::min(mSize.x, mSize.y) * VIEW_MARGIN_RATE);
+ break;
+ }
+ case ControlTestType::BLUR_COLOR:
+ {
+ bgView = CreateBlurColor(std::min(mSize.x, mSize.y) * VIEW_MARGIN_RATE * 0.5f);
+ break;
+ }
+ case ControlTestType::ROUNDED_BLUR_COLOR:
+ {
+ bgView = CreateRoundedBlurColor(std::min(mSize.x, mSize.y) * VIEW_MARGIN_RATE * 0.5f);
+ break;
+ }
+#endif
+ }
+
+ bgView[Actor::Property::PARENT_ORIGIN] = ParentOrigin::TOP_LEFT;
+ bgView[Actor::Property::ANCHOR_POINT] = AnchorPoint::TOP_LEFT;
+ bgView[Actor::Property::SIZE] = Vector2(mSize.x * (1.0f - VIEW_MARGIN_RATE), mSize.y * (1.0f - VIEW_MARGIN_RATE));
+ bgView[Actor::Property::POSITION] = Vector2(mSize.x * VIEW_MARGIN_RATE * 0.5f, mSize.y * VIEW_MARGIN_RATE * 0.5f + mSize.y * i);
+ columnView.Add(bgView);
+ }
+
+ mWindow.GetRootLayer().Add(columnView);
+ mCreatingControlList.push_back(columnView);
+
+ // Add appearing animation
+ Animation appearingAnimation = Animation::New(mDurationOfAnimation * 0.001f);
+ appearingAnimation.AnimateTo(Property(columnView, Actor::Property::POSITION_Y), 0.0f);
+ appearingAnimation.FinishedSignal().Connect(this, &PerfViewCreation::OnAppearAnimationFinished);
+ appearingAnimation.Play();
+
+ mCreatingAnimationList.push_back(appearingAnimation);
+
+ GetNanoseconds(endTime);
+
+ DALI_TRACE_END(gTraceFilter, "DALI_SAMPLE_PERF_VIEW_CREATION");
+
+ // Append duration of creation time.
+ mCreationStatistic.Add((endTime - startTime) / 1000000.0);
+
+ mCreateCount++;
+
+ if(mCreateCount % mTotalColumnsCount == 0)
+ {
+ DALI_LOG_ERROR("Average of creation %d DALI(%s) : %.6lf ms\n", mRowsCount, TestTypeString(mTestType), mCreationStatistic.GetTrimedAverage());
+ mCreationStatistic.Clear();
+ mTestType = static_cast<ControlTestType>((static_cast<int>(mTestType) + 1) % static_cast<int>(ControlTestType::TYPE_MAX));
+ }
+ }
+
+ bool OnTouch(Actor actor, const TouchEvent& touch)
+ {
+ // quit the application
+ mApplication.Quit();
+ return true;
+ }
+
+ void OnKeyEvent(const KeyEvent& event)
+ {
+ if(event.GetState() == KeyEvent::DOWN)
+ {
+ if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK))
+ {
+ mApplication.Quit();
+ }
+ }
+ }
+
+ void OnAppearAnimationFinished(Animation& animation)
+ {
+ // We can assume that front of mControlList must be disappearing.
+ auto currentControl = mCreatingControlList.front();
+ mCreatingControlList.pop_front();
+
+ // Dereference timer safety
+ if(mTimerList.empty())
+ {
+ mTimerList.pop_front();
+ }
+
+ // Dereference animation safety
+ mCreatingAnimationList.pop_back();
+
+ mRemovingControlList.push_back(currentControl);
+
+ if(mCreateCount < mTotalColumnsCount * (static_cast<int>(ControlTestType::TYPE_MAX)))
+ {
+ CreateColumnView();
+ }
+
+ // Add disappearing animation
+ Animation disappearingAnimation = Animation::New(mDurationOfAnimation * 0.001f);
+ disappearingAnimation.AnimateTo(Property(currentControl, Actor::Property::POSITION_Y), (float)mWindowSize.y);
+ disappearingAnimation.FinishedSignal().Connect(this, &PerfViewCreation::OnDisappearAnimationFinished);
+ disappearingAnimation.Play();
+
+ mRemovingAnimationList.push_back(disappearingAnimation);
+ }
+ void OnDisappearAnimationFinished(Animation& animation)
+ {
+ // We can assume that front of mControlList must be deleted.
+ mRemovingControlList.front().Unparent();
+ mRemovingControlList.pop_front();
+
+ // Dereference animation safety
+ mRemovingAnimationList.pop_back();
+
+ mDeleteCount++;
+
+ // If all controls are deleted, quit this application. byebye~
+ if(mDeleteCount == mTotalColumnsCount * (static_cast<int>(ControlTestType::TYPE_MAX)))
+ {
+ GetNanoseconds(mAppEndTime);
+
+ DALI_LOG_ERROR("Duration of all app running time : %.6lf ms\n", (mAppEndTime - mAppStartTime) / 1000000.0);
+ mApplication.Quit();
+ }
+ }
+
+private:
+ Application& mApplication;
+ Window mWindow;
+ Vector2 mWindowSize;
+
+ std::list<Control> mCreatingControlList;
+ std::list<Control> mRemovingControlList;
+ std::list<Animation> mCreatingAnimationList;
+ std::list<Animation> mRemovingAnimationList;
+ std::list<Timer> mTimerList;
+
+ Vector3 mSize;
+
+ const uint32_t mRowsCount;
+ const uint32_t mColumnsCount;
+ const uint32_t mTotalColumnsCount;
+
+ const uint32_t mDurationPerColumns;
+ const uint32_t mDurationOfAnimation;
+
+ ControlTestType mTestType;
+
+ uint32_t mCreateCount = 0;
+ uint32_t mDeleteCount = 0;
+ uint32_t mImageCount = 0;
+
+ uint64_t mAppStartTime = 0;
+ uint64_t mAppEndTime = 0;
+
+ Statistic<double> mCreationStatistic;
+};
+
+int DALI_EXPORT_API main(int argc, char** argv)
+{
+ Application application = Application::New(&argc, &argv);
+
+ PerfViewCreation test(application);
+ application.MainLoop();
+
+ return 0;
+}
projects / platform / core / uifw / dali-demo.git / commitdiff