dali/internal/adaptor/common/combined-update-render-controller.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/adaptor/common/combined-update-render-controller.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/platform-abstraction.h>
  23 #include <dali/integration-api/shader-precompiler.h>
  24 #include <errno.h>
  25 #include <unistd.h>
  26 #include "dali/public-api/common/dali-common.h"
  27
  28 // INTERNAL INCLUDES
  29 #include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
  30 #include <dali/internal/adaptor/common/adaptor-internal-services.h>
  31 #include <dali/internal/adaptor/common/combined-update-render-controller-debug.h>
  32 #include <dali/internal/graphics/common/graphics-interface.h>
  33 #include <dali/internal/graphics/gles/egl-graphics.h>
  34 #include <dali/internal/system/common/environment-options.h>
  35 #include <dali/internal/system/common/texture-upload-manager-impl.h>
  36 #include <dali/internal/system/common/time-service.h>
  37 #include <dali/internal/thread/common/thread-settings-impl.h>
  38 #include <dali/internal/window-system/common/window-impl.h>
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 namespace Adaptor
  45 {
  46 namespace
  47 {
  48
  49 const unsigned int CREATED_THREAD_COUNT = 1u;
  50
  51 const int CONTINUOUS = -1;
  52 const int ONCE       = 1;
  53
  54 const unsigned int TRUE  = 1u;
  55 const unsigned int FALSE = 0u;
  56
  57 const unsigned int MILLISECONDS_PER_SECOND(1e+3);
  58 const float        NANOSECONDS_TO_SECOND(1e-9f);
  59 const unsigned int NANOSECONDS_PER_SECOND(1e+9);
  60 const unsigned int NANOSECONDS_PER_MILLISECOND(1e+6);
  61
  62 // The following values will get calculated at compile time
  63 const float    DEFAULT_FRAME_DURATION_IN_SECONDS(1.0f / 60.0f);
  64 const uint64_t DEFAULT_FRAME_DURATION_IN_MILLISECONDS(DEFAULT_FRAME_DURATION_IN_SECONDS* MILLISECONDS_PER_SECOND);
  65 const uint64_t DEFAULT_FRAME_DURATION_IN_NANOSECONDS(DEFAULT_FRAME_DURATION_IN_SECONDS* NANOSECONDS_PER_SECOND);
  66
  67 /**
  68  * Handles the use case when an update-request is received JUST before we process a sleep-request. If we did not have an update-request count then
  69  * there is a danger that, on the event-thread we could have:
  70  *  1) An update-request where we do nothing as Update/Render thread still running.
  71  *  2) Quickly followed by a sleep-request being handled where we pause the Update/Render Thread (even though we have an update to process).
  72  *
  73  * Using a counter means we increment the counter on an update-request, and decrement it on a sleep-request. This handles the above scenario because:
  74  *  1) MAIN THREAD:           Update Request: COUNTER = 1
  75  *  2) UPDATE/RENDER THREAD:  Do Update/Render, then no Updates required -> Sleep Trigger
  76  *  3) MAIN THREAD:           Update Request: COUNTER = 2
  77  *  4) MAIN THREAD:           Sleep Request:  COUNTER = 1 -> We do not sleep just yet
  78  *
  79  * Also ensures we preserve battery life by only doing ONE update when the above use case is not triggered.
  80  *  1) MAIN THREAD:           Update Request: COUNTER = 1
  81  *  2) UPDATE/RENDER THREAD:  Do Update/Render, then no Updates required -> Sleep Trigger
  82  *  3) MAIN THREAD:           Sleep Request:  COUNTER = 0 -> Go to sleep
  83  */
  84 const unsigned int MAXIMUM_UPDATE_REQUESTS = 2;
  85 } // unnamed namespace
  86
  87 ///////////////////////////////////////////////////////////////////////////////////////////////////
  88 // EVENT THREAD
  89 ///////////////////////////////////////////////////////////////////////////////////////////////////
  90
  91 CombinedUpdateRenderController::CombinedUpdateRenderController(AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions, ThreadMode threadMode)
  92 : mFpsTracker(environmentOptions),
  93   mUpdateStatusLogger(environmentOptions),
  94   mEventThreadSemaphore(0),
  95   mSurfaceSemaphore(0),
  96   mUpdateRenderThreadWaitCondition(),
  97   mAdaptorInterfaces(adaptorInterfaces),
  98   mPerformanceInterface(adaptorInterfaces.GetPerformanceInterface()),
  99   mCore(adaptorInterfaces.GetCore()),
 100   mEnvironmentOptions(environmentOptions),
 101   mNotificationTrigger(adaptorInterfaces.GetProcessCoreEventsTrigger()),
 102   mSleepTrigger(NULL),
 103   mPreRenderCallback(NULL),
 104   mTextureUploadManager(adaptorInterfaces.GetTextureUploadManager()),
 105   mUpdateRenderThread(NULL),
 106   mDefaultFrameDelta(0.0f),
 107   mDefaultFrameDurationMilliseconds(0u),
 108   mDefaultFrameDurationNanoseconds(0u),
 109   mDefaultHalfFrameNanoseconds(0u),
 110   mUpdateRequestCount(0u),
 111   mRunning(FALSE),
 112   mThreadId(0),
 113   mThreadMode(threadMode),
 114   mUpdateRenderRunCount(0),
 115   mDestroyUpdateRenderThread(FALSE),
 116   mUpdateRenderThreadCanSleep(FALSE),
 117   mPendingRequestUpdate(FALSE),
 118   mUseElapsedTimeAfterWait(FALSE),
 119   mNewSurface(NULL),
 120   mDeletedSurface(nullptr),
 121   mPostRendering(FALSE),
 122   mSurfaceResized(0),
 123   mForceClear(FALSE),
 124   mUploadWithoutRendering(FALSE),
 125   mFirstFrameAfterResume(FALSE)
 126 {
 127   LOG_EVENT_TRACE;
 128
 129   // Initialise frame delta/duration variables first
 130   SetRenderRefreshRate(environmentOptions.GetRenderRefreshRate());
 131
 132   // Set the thread-synchronization interface on the render-surface
 133   Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 134   if(currentSurface)
 135   {
 136     currentSurface->SetThreadSynchronization(*this);
 137   }
 138
 139   mSleepTrigger = TriggerEventFactory::CreateTriggerEvent(MakeCallback(this, &CombinedUpdateRenderController::ProcessSleepRequest), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
 140 }
 141
 142 CombinedUpdateRenderController::~CombinedUpdateRenderController()
 143 {
 144   LOG_EVENT_TRACE;
 145
 146   Stop();
 147
 148   delete mPreRenderCallback;
 149   delete mSleepTrigger;
 150 }
 151
 152 void CombinedUpdateRenderController::Initialize()
 153 {
 154   LOG_EVENT_TRACE;
 155
 156   // Ensure Update/Render Thread not already created
 157   DALI_ASSERT_ALWAYS(!mUpdateRenderThread);
 158
 159   // Create Update/Render Thread
 160   ConditionalWait::ScopedLock lock(mGraphicsInitializeWait);
 161   mUpdateRenderThread = new pthread_t();
 162   int error           = pthread_create(mUpdateRenderThread, NULL, InternalUpdateRenderThreadEntryFunc, this);
 163   DALI_ASSERT_ALWAYS(!error && "Return code from pthread_create() when creating UpdateRenderThread");
 164
 165   // The Update/Render thread will now run and initialise the graphics interface etc. and will then wait for Start to be called
 166   // When this function returns, the application initialisation on the event thread should occur
 167 }
 168
 169 void CombinedUpdateRenderController::Start()
 170 {
 171   LOG_EVENT_TRACE;
 172
 173   DALI_ASSERT_ALWAYS(!mRunning && mUpdateRenderThread);
 174
 175   // Wait until all threads created in Initialise are up and running
 176   for(unsigned int i = 0; i < CREATED_THREAD_COUNT; ++i)
 177   {
 178     mEventThreadSemaphore.Acquire();
 179   }
 180
 181   mRunning = TRUE;
 182
 183   LOG_EVENT("Startup Complete, starting Update/Render Thread");
 184
 185   RunUpdateRenderThread(CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL);
 186
 187   Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 188   if(currentSurface)
 189   {
 190     currentSurface->StartRender();
 191   }
 192
 193   DALI_LOG_RELEASE_INFO("CombinedUpdateRenderController::Start\n");
 194 }
 195
 196 void CombinedUpdateRenderController::Pause()
 197 {
 198   LOG_EVENT_TRACE;
 199
 200   mRunning = FALSE;
 201
 202   PauseUpdateRenderThread();
 203
 204   AddPerformanceMarker(PerformanceInterface::PAUSED);
 205
 206   DALI_LOG_RELEASE_INFO("CombinedUpdateRenderController::Pause\n");
 207 }
 208
 209 void CombinedUpdateRenderController::Resume()
 210 {
 211   LOG_EVENT_TRACE;
 212
 213   if(!mRunning && IsUpdateRenderThreadPaused())
 214   {
 215     LOG_EVENT("Resuming");
 216
 217     RunUpdateRenderThread(CONTINUOUS, AnimationProgression::USE_ELAPSED_TIME, UpdateMode::NORMAL);
 218
 219     AddPerformanceMarker(PerformanceInterface::RESUME);
 220
 221     mRunning               = TRUE;
 222     mForceClear            = TRUE;
 223     mFirstFrameAfterResume = TRUE;
 224
 225     DALI_LOG_RELEASE_INFO("CombinedUpdateRenderController::Resume\n");
 226   }
 227   else
 228   {
 229     DALI_LOG_RELEASE_INFO("CombinedUpdateRenderController::Resume: Already resumed [%d, %d, %d]\n", mRunning, mUpdateRenderRunCount, mUpdateRenderThreadCanSleep);
 230   }
 231 }
 232
 233 void CombinedUpdateRenderController::Stop()
 234 {
 235   LOG_EVENT_TRACE;
 236
 237   // Stop Rendering and the Update/Render Thread
 238   Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 239   if(currentSurface)
 240   {
 241     currentSurface->StopRender();
 242   }
 243
 244   StopUpdateRenderThread();
 245
 246   if(mUpdateRenderThread)
 247   {
 248     LOG_EVENT("Destroying UpdateRenderThread");
 249
 250     // wait for the thread to finish
 251     pthread_join(*mUpdateRenderThread, NULL);
 252
 253     delete mUpdateRenderThread;
 254     mUpdateRenderThread = NULL;
 255   }
 256
 257   mRunning = FALSE;
 258
 259   DALI_LOG_RELEASE_INFO("CombinedUpdateRenderController::Stop\n");
 260 }
 261
 262 void CombinedUpdateRenderController::RequestUpdate()
 263 {
 264   LOG_EVENT_TRACE;
 265
 266   // Increment the update-request count to the maximum
 267   if(mUpdateRequestCount < MAXIMUM_UPDATE_REQUESTS)
 268   {
 269     ++mUpdateRequestCount;
 270   }
 271
 272   if(mRunning && IsUpdateRenderThreadPaused())
 273   {
 274     LOG_EVENT("Processing");
 275
 276     RunUpdateRenderThread(CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL);
 277   }
 278
 279   ConditionalWait::ScopedLock updateLock(mUpdateRenderThreadWaitCondition);
 280   mPendingRequestUpdate = TRUE;
 281 }
 282
 283 void CombinedUpdateRenderController::RequestUpdateOnce(UpdateMode updateMode)
 284 {
 285   // Increment the update-request count to the maximum
 286   if(mUpdateRequestCount < MAXIMUM_UPDATE_REQUESTS)
 287   {
 288     ++mUpdateRequestCount;
 289   }
 290
 291   if(IsUpdateRenderThreadPaused() || updateMode == UpdateMode::FORCE_RENDER)
 292   {
 293     LOG_EVENT_TRACE;
 294
 295     // Run Update/Render once
 296     RunUpdateRenderThread(ONCE, AnimationProgression::NONE, updateMode);
 297   }
 298 }
 299
 300 void CombinedUpdateRenderController::ReplaceSurface(Dali::RenderSurfaceInterface* newSurface)
 301 {
 302   LOG_EVENT_TRACE;
 303
 304   if(mUpdateRenderThread)
 305   {
 306     // Set the ThreadSyncronizationInterface on the new surface
 307     newSurface->SetThreadSynchronization(*this);
 308
 309     LOG_EVENT("Starting to replace the surface, event-thread blocked");
 310
 311     // Start replacing the surface.
 312     {
 313       ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 314       mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will replace the surface now
 315       mNewSurface    = newSurface;
 316       mUpdateRenderThreadWaitCondition.Notify(lock);
 317     }
 318
 319     // Wait until the surface has been replaced
 320     mSurfaceSemaphore.Acquire();
 321
 322     LOG_EVENT("Surface replaced, event-thread continuing");
 323   }
 324 }
 325
 326 void CombinedUpdateRenderController::DeleteSurface(Dali::RenderSurfaceInterface* surface)
 327 {
 328   LOG_EVENT_TRACE;
 329
 330   if(mUpdateRenderThread)
 331   {
 332     LOG_EVENT("Starting to delete the surface, event-thread blocked");
 333
 334     // Start replacing the surface.
 335     {
 336       ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 337       mPostRendering  = FALSE; // Clear the post-rendering flag as Update/Render thread will delete the surface now
 338       mDeletedSurface = surface;
 339       mUpdateRenderThreadWaitCondition.Notify(lock);
 340     }
 341
 342     // Wait until the surface has been deleted
 343     mSurfaceSemaphore.Acquire();
 344
 345     LOG_EVENT("Surface deleted, event-thread continuing");
 346   }
 347 }
 348
 349 void CombinedUpdateRenderController::WaitForGraphicsInitialization()
 350 {
 351   ConditionalWait::ScopedLock lk(mGraphicsInitializeWait);
 352   LOG_EVENT_TRACE;
 353
 354   if(mUpdateRenderThread)
 355   {
 356     LOG_EVENT("Waiting for graphics initialisation, event-thread blocked");
 357
 358     // Wait until the graphics has been initialised
 359     mGraphicsInitializeWait.Wait(lk);
 360
 361     LOG_EVENT("graphics initialised, event-thread continuing");
 362   }
 363 }
 364
 365 void CombinedUpdateRenderController::ResizeSurface()
 366 {
 367   LOG_EVENT_TRACE;
 368
 369   LOG_EVENT("Resize the surface");
 370
 371   {
 372     ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 373     // Surface is resized and the surface resized count is increased.
 374     mSurfaceResized++;
 375     mUpdateRenderThreadWaitCondition.Notify(lock);
 376   }
 377 }
 378
 379 void CombinedUpdateRenderController::SetRenderRefreshRate(unsigned int numberOfFramesPerRender)
 380 {
 381   // Not protected by lock, but written to rarely so not worth adding a lock when reading
 382   mDefaultFrameDelta                = numberOfFramesPerRender * DEFAULT_FRAME_DURATION_IN_SECONDS;
 383   mDefaultFrameDurationMilliseconds = uint64_t(numberOfFramesPerRender) * DEFAULT_FRAME_DURATION_IN_MILLISECONDS;
 384   mDefaultFrameDurationNanoseconds  = uint64_t(numberOfFramesPerRender) * DEFAULT_FRAME_DURATION_IN_NANOSECONDS;
 385   mDefaultHalfFrameNanoseconds      = mDefaultFrameDurationNanoseconds / 2u;
 386
 387   LOG_EVENT("mDefaultFrameDelta(%.6f), mDefaultFrameDurationMilliseconds(%lld), mDefaultFrameDurationNanoseconds(%lld)", mDefaultFrameDelta, mDefaultFrameDurationMilliseconds, mDefaultFrameDurationNanoseconds);
 388 }
 389
 390 void CombinedUpdateRenderController::SetPreRenderCallback(CallbackBase* callback)
 391 {
 392   LOG_EVENT_TRACE;
 393   LOG_EVENT("Set PreRender Callback");
 394
 395   ConditionalWait::ScopedLock updateLock(mUpdateRenderThreadWaitCondition);
 396   if(mPreRenderCallback)
 397   {
 398     delete mPreRenderCallback;
 399   }
 400   mPreRenderCallback = callback;
 401 }
 402
 403 void CombinedUpdateRenderController::AddSurface(Dali::RenderSurfaceInterface* surface)
 404 {
 405   LOG_EVENT_TRACE;
 406   LOG_EVENT("Surface is added");
 407   if(mUpdateRenderThread)
 408   {
 409     // Set the ThreadSyncronizationInterface on the added surface
 410     surface->SetThreadSynchronization(*this);
 411   }
 412 }
 413
 414 int32_t CombinedUpdateRenderController::GetThreadId() const
 415 {
 416   return mThreadId;
 417 }
 418
 419 ///////////////////////////////////////////////////////////////////////////////////////////////////
 420 // EVENT THREAD
 421 ///////////////////////////////////////////////////////////////////////////////////////////////////
 422
 423 void CombinedUpdateRenderController::RunUpdateRenderThread(int numberOfCycles, AnimationProgression animationProgression, UpdateMode updateMode)
 424 {
 425   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 426
 427   switch(mThreadMode)
 428   {
 429     case ThreadMode::NORMAL:
 430     {
 431       mUpdateRenderRunCount    = numberOfCycles;
 432       mUseElapsedTimeAfterWait = (animationProgression == AnimationProgression::USE_ELAPSED_TIME);
 433       break;
 434     }
 435     case ThreadMode::RUN_IF_REQUESTED:
 436     {
 437       if(updateMode != UpdateMode::FORCE_RENDER)
 438       {
 439         // Render only if the update mode is FORCE_RENDER which means the application requests it.
 440         // We don't want to awake the update thread.
 441         return;
 442       }
 443
 444       mUpdateRenderRunCount++;         // Increase the update request count
 445       mUseElapsedTimeAfterWait = TRUE; // The elapsed time should be used. We want animations to proceed.
 446       break;
 447     }
 448   }
 449
 450   mUpdateRenderThreadCanSleep = FALSE;
 451   mUploadWithoutRendering     = (updateMode == UpdateMode::SKIP_RENDER);
 452   LOG_COUNTER_EVENT("mUpdateRenderRunCount: %d, mUseElapsedTimeAfterWait: %d", mUpdateRenderRunCount, mUseElapsedTimeAfterWait);
 453   mUpdateRenderThreadWaitCondition.Notify(lock);
 454 }
 455
 456 void CombinedUpdateRenderController::PauseUpdateRenderThread()
 457 {
 458   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 459   mUpdateRenderRunCount = 0;
 460 }
 461
 462 void CombinedUpdateRenderController::StopUpdateRenderThread()
 463 {
 464   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 465   mDestroyUpdateRenderThread = TRUE;
 466   mUpdateRenderThreadWaitCondition.Notify(lock);
 467 }
 468
 469 bool CombinedUpdateRenderController::IsUpdateRenderThreadPaused()
 470 {
 471   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 472
 473   if(mThreadMode == ThreadMode::RUN_IF_REQUESTED)
 474   {
 475     return !mRunning || mUpdateRenderThreadCanSleep;
 476   }
 477
 478   return (mUpdateRenderRunCount != CONTINUOUS) || // Report paused if NOT continuously running
 479          mUpdateRenderThreadCanSleep;             // Report paused if sleeping
 480 }
 481
 482 void CombinedUpdateRenderController::ProcessSleepRequest()
 483 {
 484   LOG_EVENT_TRACE;
 485
 486   // Decrement Update request count
 487   if(mUpdateRequestCount > 0)
 488   {
 489     --mUpdateRequestCount;
 490   }
 491
 492   // Can sleep if our update-request count is 0
 493   // Update/Render thread can choose to carry on updating if it determines more update/renders are required
 494   if(mUpdateRequestCount == 0)
 495   {
 496     LOG_EVENT("Going to sleep");
 497
 498     ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 499     mUpdateRenderThreadCanSleep = TRUE;
 500   }
 501 }
 502
 503 ///////////////////////////////////////////////////////////////////////////////////////////////////
 504 // UPDATE/RENDER THREAD
 505 ///////////////////////////////////////////////////////////////////////////////////////////////////
 506
 507 void CombinedUpdateRenderController::UpdateRenderThread()
 508 {
 509   ThreadSettings::SetThreadName("RenderThread\0");
 510   mThreadId = ThreadSettings::GetThreadId();
 511
 512   // Install a function for logging
 513   mEnvironmentOptions.InstallLogFunction();
 514
 515   // Install a function for tracing
 516   mEnvironmentOptions.InstallTraceFunction();
 517
 518   LOG_UPDATE_RENDER("THREAD CREATED");
 519
 520   // Initialize graphics
 521   GraphicsInterface& graphics = mAdaptorInterfaces.GetGraphicsInterface();
 522   graphics.Initialize();
 523
 524   Dali::DisplayConnection& displayConnection = mAdaptorInterfaces.GetDisplayConnectionInterface();
 525   displayConnection.Initialize(); //@todo Move InitializeGraphics code into graphics implementation
 526
 527   // Setup graphics controller into upload manager.
 528   GetImplementation(mTextureUploadManager).InitalizeGraphicsController(graphics.GetController());
 529
 530   NotifyGraphicsInitialised();
 531
 532   //@todo Vk swaps this around, but we need to support surfaceless context for multi-window
 533   graphics.ConfigureSurface(mAdaptorInterfaces.GetRenderSurfaceInterface());
 534
 535   // Tell core it has a context
 536   mCore.ContextCreated();
 537
 538   NotifyThreadInitialised();
 539
 540   // Initialize and create graphics resource for the shared context.
 541   WindowContainer windows;
 542   mAdaptorInterfaces.GetWindowContainerInterface(windows);
 543
 544   for(auto&& window : windows)
 545   {
 546     Dali::Integration::Scene      scene         = window->GetScene();
 547     Dali::RenderSurfaceInterface* windowSurface = window->GetSurface();
 548
 549     if(scene && windowSurface)
 550     {
 551       windowSurface->InitializeGraphics();
 552     }
 553   }
 554
 555   // Update time
 556   uint64_t lastFrameTime;
 557   TimeService::GetNanoseconds(lastFrameTime);
 558   uint64_t lastMemPoolLogTime = lastFrameTime;
 559
 560   LOG_UPDATE_RENDER("THREAD INITIALISED");
 561
 562   bool     useElapsedTime     = true;
 563   bool     updateRequired     = true;
 564   uint64_t timeToSleepUntil   = 0;
 565   int      extraFramesDropped = 0;
 566
 567   const uint64_t memPoolInterval = 1e9 * float(mEnvironmentOptions.GetMemoryPoolInterval());
 568
 569   const unsigned int renderToFboInterval = mEnvironmentOptions.GetRenderToFboInterval();
 570   const bool         renderToFboEnabled  = 0u != renderToFboInterval;
 571   unsigned int       frameCount          = 0u;
 572
 573   if(Integration::ShaderPrecompiler::Get().IsEnable())
 574   {
 575     std::vector<RawShaderData> precompiledShaderList;
 576     Integration::ShaderPrecompiler::Get().GetPrecompileShaderList(precompiledShaderList);
 577     DALI_LOG_RELEASE_INFO("ShaderPrecompiler[ENABLE], list size:%d \n",precompiledShaderList.size());
 578     for(auto precompiledShader = precompiledShaderList.begin(); precompiledShader != precompiledShaderList.end(); ++precompiledShader)
 579     {
 580       auto numberOfPrecomipledShader = precompiledShader->shaderCount;
 581       for(int i= 0; i<numberOfPrecomipledShader; ++i)
 582       {
 583         auto vertexShader   = std::string(graphics.GetController().GetGlAbstraction().GetVertexShaderPrefix() + precompiledShader->vertexPrefix[i].data() + precompiledShader->vertexShader.data());
 584         auto fragmentShader = std::string(graphics.GetController().GetGlAbstraction().GetFragmentShaderPrefix() + precompiledShader->fragmentPrefix[i].data() + precompiledShader->fragmentShader.data());
 585         mCore.PreCompileShader(vertexShader.data(), fragmentShader.data());
 586       }
 587       DALI_LOG_RELEASE_INFO("ShaderPrecompiler[ENABLE], shader count :%d \n",numberOfPrecomipledShader);
 588     }
 589   }
 590   else
 591   {
 592     DALI_LOG_RELEASE_INFO("ShaderPrecompiler[DISABLE] \n");
 593   }
 594
 595   while(UpdateRenderReady(useElapsedTime, updateRequired, timeToSleepUntil))
 596   {
 597     LOG_UPDATE_RENDER_TRACE;
 598
 599     // For thread safe
 600     bool                          uploadOnly     = mUploadWithoutRendering;
 601     unsigned int                  surfaceResized = mSurfaceResized;
 602     Dali::RenderSurfaceInterface* deletedSurface = ShouldSurfaceBeDeleted();
 603
 604     // Performance statistics are logged upon a VSYNC tick so use this point for a VSync marker
 605     AddPerformanceMarker(PerformanceInterface::VSYNC);
 606
 607     uint64_t currentFrameStartTime = 0;
 608     TimeService::GetNanoseconds(currentFrameStartTime);
 609
 610     uint64_t timeSinceLastFrame = currentFrameStartTime - lastFrameTime;
 611
 612     // Optional FPS Tracking when continuously rendering
 613     if(useElapsedTime && mFpsTracker.Enabled())
 614     {
 615       float absoluteTimeSinceLastRender = timeSinceLastFrame * NANOSECONDS_TO_SECOND;
 616       mFpsTracker.Track(absoluteTimeSinceLastRender);
 617     }
 618
 619     lastFrameTime = currentFrameStartTime; // Store frame start time
 620
 621     //////////////////////////////
 622     // REPLACE SURFACE
 623     //////////////////////////////
 624
 625     Dali::RenderSurfaceInterface* newSurface = ShouldSurfaceBeReplaced();
 626     if(DALI_UNLIKELY(newSurface))
 627     {
 628       LOG_UPDATE_RENDER_TRACE_FMT("Replacing Surface");
 629       // This is designed for replacing pixmap surfaces, but should work for window as well
 630       // we need to delete the surface and renderable (pixmap / window)
 631       // Then create a new pixmap/window and new surface
 632       // If the new surface has a different display connection, then the context will be lost
 633       mAdaptorInterfaces.GetDisplayConnectionInterface().Initialize();
 634       graphics.ActivateSurfaceContext(newSurface);
 635       // TODO: ReplaceGraphicsSurface doesn't work, InitializeGraphics()
 636       // already creates new surface window, the surface and the context.
 637       // We probably don't need ReplaceGraphicsSurface at all.
 638       // newSurface->ReplaceGraphicsSurface();
 639       SurfaceReplaced();
 640     }
 641
 642     //////////////////////////////
 643     // TextureUploadRequest (phase #1)
 644     //////////////////////////////
 645
 646     // Upload requested resources after resource context activated.
 647     graphics.ActivateResourceContext();
 648
 649     const bool textureUploaded = mTextureUploadManager.ResourceUpload();
 650
 651     // Update & Render forcely if there exist some uploaded texture.
 652     uploadOnly = textureUploaded ? false : uploadOnly;
 653
 654     const bool isRenderingToFbo = renderToFboEnabled && ((0u == frameCount) || (0u != frameCount % renderToFboInterval));
 655     ++frameCount;
 656
 657     //////////////////////////////
 658     // UPDATE
 659     //////////////////////////////
 660
 661     const uint32_t currentTime   = static_cast<uint32_t>(currentFrameStartTime / NANOSECONDS_PER_MILLISECOND);
 662     const uint32_t nextFrameTime = currentTime + static_cast<uint32_t>(mDefaultFrameDurationMilliseconds);
 663
 664     uint64_t noOfFramesSinceLastUpdate = 1;
 665     float    frameDelta                = 0.0f;
 666     if(useElapsedTime)
 667     {
 668       if(mThreadMode == ThreadMode::RUN_IF_REQUESTED)
 669       {
 670         extraFramesDropped = 0;
 671         while(timeSinceLastFrame >= mDefaultFrameDurationNanoseconds)
 672         {
 673           timeSinceLastFrame -= mDefaultFrameDurationNanoseconds;
 674           extraFramesDropped++;
 675         }
 676       }
 677
 678       // If using the elapsed time, then calculate frameDelta as a multiple of mDefaultFrameDelta
 679       noOfFramesSinceLastUpdate += extraFramesDropped;
 680
 681       frameDelta = mDefaultFrameDelta * noOfFramesSinceLastUpdate;
 682     }
 683     LOG_UPDATE_RENDER("timeSinceLastFrame(%llu) noOfFramesSinceLastUpdate(%u) frameDelta(%.6f)", timeSinceLastFrame, noOfFramesSinceLastUpdate, frameDelta);
 684
 685     Integration::UpdateStatus updateStatus;
 686
 687     AddPerformanceMarker(PerformanceInterface::UPDATE_START);
 688     TRACE_UPDATE_RENDER_BEGIN("DALI_UPDATE");
 689     mCore.Update(frameDelta,
 690                  currentTime,
 691                  nextFrameTime,
 692                  updateStatus,
 693                  renderToFboEnabled,
 694                  isRenderingToFbo,
 695                  uploadOnly);
 696     TRACE_UPDATE_RENDER_END("DALI_UPDATE");
 697     AddPerformanceMarker(PerformanceInterface::UPDATE_END);
 698
 699     unsigned int keepUpdatingStatus = updateStatus.KeepUpdating();
 700
 701     // Tell the event-thread to wake up (if asleep) and send a notification event to Core if required
 702     if(updateStatus.NeedsNotification())
 703     {
 704       mNotificationTrigger.Trigger();
 705       LOG_UPDATE_RENDER("Notification Triggered");
 706     }
 707
 708     // Optional logging of update/render status
 709     mUpdateStatusLogger.Log(keepUpdatingStatus);
 710
 711     //////////////////////////////
 712     // RENDER
 713     //////////////////////////////
 714
 715     graphics.FrameStart();
 716     mAdaptorInterfaces.GetDisplayConnectionInterface().ConsumeEvents();
 717
 718     if(mPreRenderCallback != NULL)
 719     {
 720       bool keepCallback = CallbackBase::ExecuteReturn<bool>(*mPreRenderCallback);
 721       if(!keepCallback)
 722       {
 723         delete mPreRenderCallback;
 724         mPreRenderCallback = NULL;
 725       }
 726     }
 727
 728     //////////////////////////////
 729     // TextureUploadRequest (phase #2)
 730     //////////////////////////////
 731
 732     // Upload requested resources after resource context activated.
 733     graphics.ActivateResourceContext();
 734
 735     // Since uploadOnly value used at Update side, we should not change uploadOnly value now even some textures are uploaded.
 736     mTextureUploadManager.ResourceUpload();
 737
 738     if(mFirstFrameAfterResume)
 739     {
 740       // mFirstFrameAfterResume is set to true when the thread is resumed
 741       // Let graphics know the first frame after thread initialized or resumed.
 742       graphics.SetFirstFrameAfterResume();
 743       mFirstFrameAfterResume = FALSE;
 744     }
 745
 746     Integration::RenderStatus renderStatus;
 747
 748     AddPerformanceMarker(PerformanceInterface::RENDER_START);
 749     TRACE_UPDATE_RENDER_BEGIN("DALI_RENDER");
 750
 751     // Upload shared resources
 752     TRACE_UPDATE_RENDER_BEGIN("DALI_PRE_RENDER");
 753     mCore.PreRender(renderStatus, mForceClear);
 754     TRACE_UPDATE_RENDER_END("DALI_PRE_RENDER");
 755
 756     if(!uploadOnly || surfaceResized)
 757     {
 758       // Go through each window
 759       windows.clear();
 760       mAdaptorInterfaces.GetWindowContainerInterface(windows);
 761
 762       for(auto&& window : windows)
 763       {
 764         Dali::Integration::Scene      scene         = window->GetScene();
 765         Dali::RenderSurfaceInterface* windowSurface = window->GetSurface();
 766
 767         if(scene && windowSurface)
 768         {
 769           TRACE_UPDATE_RENDER_BEGIN("DALI_RENDER_SCENE");
 770           Integration::RenderStatus windowRenderStatus;
 771
 772           const bool sceneSurfaceResized = scene.IsSurfaceRectChanged();
 773
 774           // clear previous frame damaged render items rects, buffer history is tracked on surface level
 775           mDamagedRects.clear();
 776
 777           // Collect damage rects
 778           mCore.PreRender(scene, mDamagedRects);
 779
 780           // Render off-screen frame buffers first if any
 781           mCore.RenderScene(windowRenderStatus, scene, true);
 782
 783           Rect<int> clippingRect; // Empty for fbo rendering
 784
 785           // Switch to the context of the surface, merge damaged areas for previous frames
 786           windowSurface->PreRender(sceneSurfaceResized, mDamagedRects, clippingRect); // Switch GL context
 787
 788           // Render the surface
 789           mCore.RenderScene(windowRenderStatus, scene, false, clippingRect);
 790
 791           // Buffer swapping now happens when the surface render target is presented.
 792
 793           // If surface is resized, the surface resized count is decreased.
 794           if(DALI_UNLIKELY(sceneSurfaceResized))
 795           {
 796             SurfaceResized();
 797           }
 798           TRACE_UPDATE_RENDER_END("DALI_RENDER_SCENE");
 799         }
 800       }
 801     }
 802
 803     TRACE_UPDATE_RENDER_BEGIN("DALI_POST_RENDER");
 804     if(!uploadOnly)
 805     {
 806       graphics.PostRender();
 807     }
 808
 809     mCore.PostRender();
 810     TRACE_UPDATE_RENDER_END("DALI_POST_RENDER");
 811
 812     //////////////////////////////
 813     // DELETE SURFACE
 814     //////////////////////////////
 815     if(DALI_UNLIKELY(deletedSurface))
 816     {
 817       LOG_UPDATE_RENDER_TRACE_FMT("Deleting Surface");
 818
 819       deletedSurface->DestroySurface();
 820
 821       SurfaceDeleted();
 822     }
 823
 824     TRACE_UPDATE_RENDER_END("DALI_RENDER");
 825     AddPerformanceMarker(PerformanceInterface::RENDER_END);
 826
 827     // if the memory pool interval is set and has elapsed, log the graphics memory pools
 828     if(0 < memPoolInterval && memPoolInterval < lastFrameTime - lastMemPoolLogTime)
 829     {
 830       lastMemPoolLogTime = lastFrameTime;
 831       graphics.LogMemoryPools();
 832     }
 833
 834     mForceClear = false;
 835
 836     // Trigger event thread to request Update/Render thread to sleep if update not required
 837     if((Integration::KeepUpdating::NOT_REQUESTED == keepUpdatingStatus) && !renderStatus.NeedsUpdate())
 838     {
 839       mSleepTrigger->Trigger();
 840       updateRequired = false;
 841       LOG_UPDATE_RENDER("Sleep Triggered");
 842     }
 843     else
 844     {
 845       updateRequired = true;
 846     }
 847
 848     //////////////////////////////
 849     // FRAME TIME
 850     //////////////////////////////
 851
 852     extraFramesDropped = 0;
 853
 854     if(timeToSleepUntil == 0)
 855     {
 856       // If this is the first frame after the thread is initialized or resumed, we
 857       // use the actual time the current frame starts from to calculate the time to
 858       // sleep until the next frame.
 859       timeToSleepUntil = currentFrameStartTime + mDefaultFrameDurationNanoseconds;
 860     }
 861     else
 862     {
 863       // Otherwise, always use the sleep-until time calculated in the last frame to
 864       // calculate the time to sleep until the next frame. In this way, if there is
 865       // any time gap between the current frame and the next frame, or if update or
 866       // rendering in the current frame takes too much time so that the specified
 867       // sleep-until time has already passed, it will try to keep the frames syncing
 868       // by shortening the duration of the next frame.
 869       timeToSleepUntil += mDefaultFrameDurationNanoseconds;
 870
 871       // Check the current time at the end of the frame
 872       uint64_t currentFrameEndTime = 0;
 873       TimeService::GetNanoseconds(currentFrameEndTime);
 874       while(currentFrameEndTime > timeToSleepUntil + mDefaultFrameDurationNanoseconds)
 875       {
 876         // We are more than one frame behind already, so just drop the next frames
 877         // until the sleep-until time is later than the current time so that we can
 878         // catch up.
 879         timeToSleepUntil += mDefaultFrameDurationNanoseconds;
 880         extraFramesDropped++;
 881       }
 882     }
 883
 884     // Render to FBO is intended to measure fps above 60 so sleep is not wanted.
 885     if(0u == renderToFboInterval)
 886     {
 887       // Sleep until at least the the default frame duration has elapsed. This will return immediately if the specified end-time has already passed.
 888       TimeService::SleepUntil(timeToSleepUntil);
 889     }
 890   }
 891
 892   // Inform core of context destruction
 893   mCore.ContextDestroyed();
 894
 895   windows.clear();
 896   mAdaptorInterfaces.GetWindowContainerInterface(windows);
 897
 898   // Destroy surfaces
 899   for(auto&& window : windows)
 900   {
 901     Dali::RenderSurfaceInterface* surface = window->GetSurface();
 902     surface->DestroySurface();
 903   }
 904
 905   graphics.Shutdown();
 906
 907   LOG_UPDATE_RENDER("THREAD DESTROYED");
 908
 909   // Uninstall the logging function
 910   mEnvironmentOptions.UnInstallLogFunction();
 911 }
 912
 913 bool CombinedUpdateRenderController::UpdateRenderReady(bool& useElapsedTime, bool updateRequired, uint64_t& timeToSleepUntil)
 914 {
 915   useElapsedTime = true;
 916
 917   ConditionalWait::ScopedLock updateLock(mUpdateRenderThreadWaitCondition);
 918   while((!mUpdateRenderRunCount ||                                                      // Should try to wait if event-thread has paused the Update/Render thread
 919          (mUpdateRenderThreadCanSleep && !updateRequired && !mPendingRequestUpdate)) && // Ensure we wait if we're supposed to be sleeping AND do not require another update
 920         !mDestroyUpdateRenderThread &&                                                  // Ensure we don't wait if the update-render-thread is supposed to be destroyed
 921         !mNewSurface &&                                                                 // Ensure we don't wait if we need to replace the surface
 922         !mDeletedSurface &&                                                             // Ensure we don't wait if we need to delete the surface
 923         !mSurfaceResized)                                                               // Ensure we don't wait if we need to resize the surface
 924   {
 925     LOG_UPDATE_RENDER("WAIT: mUpdateRenderRunCount:       %d", mUpdateRenderRunCount);
 926     LOG_UPDATE_RENDER("      mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate);
 927     LOG_UPDATE_RENDER("      mDestroyUpdateRenderThread:  %d", mDestroyUpdateRenderThread);
 928     LOG_UPDATE_RENDER("      mNewSurface:                 %d", mNewSurface);
 929     LOG_UPDATE_RENDER("      mDeletedSurface:             %d", mDeletedSurface);
 930     LOG_UPDATE_RENDER("      mSurfaceResized:             %d", mSurfaceResized);
 931
 932     // Reset the time when the thread is waiting, so the sleep-until time for
 933     // the first frame after resuming should be based on the actual start time
 934     // of the first frame.
 935     timeToSleepUntil = 0;
 936
 937     mUpdateRenderThreadWaitCondition.Wait(updateLock);
 938
 939     if(!mUseElapsedTimeAfterWait)
 940     {
 941       useElapsedTime = false;
 942     }
 943   }
 944
 945   LOG_COUNTER_UPDATE_RENDER("mUpdateRenderRunCount:       %d", mUpdateRenderRunCount);
 946   LOG_COUNTER_UPDATE_RENDER("mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate);
 947   LOG_COUNTER_UPDATE_RENDER("mDestroyUpdateRenderThread:  %d", mDestroyUpdateRenderThread);
 948   LOG_COUNTER_UPDATE_RENDER("mNewSurface:                 %d", mNewSurface);
 949   LOG_COUNTER_UPDATE_RENDER("mDeletedSurface:             %d", mDeletedSurface);
 950   LOG_COUNTER_UPDATE_RENDER("mSurfaceResized:             %d", mSurfaceResized);
 951
 952   mUseElapsedTimeAfterWait    = FALSE;
 953   mUpdateRenderThreadCanSleep = FALSE;
 954   mPendingRequestUpdate       = FALSE;
 955
 956   // If we've been asked to run Update/Render cycles a finite number of times then decrement so we wait after the
 957   // requested number of cycles
 958   if(mUpdateRenderRunCount > 0)
 959   {
 960     --mUpdateRenderRunCount;
 961   }
 962
 963   // Keep the update-render thread alive if this thread is NOT to be destroyed
 964   return !mDestroyUpdateRenderThread;
 965 }
 966
 967 Dali::RenderSurfaceInterface* CombinedUpdateRenderController::ShouldSurfaceBeReplaced()
 968 {
 969   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 970
 971   Dali::RenderSurfaceInterface* newSurface = mNewSurface;
 972   mNewSurface                              = NULL;
 973
 974   return newSurface;
 975 }
 976
 977 void CombinedUpdateRenderController::SurfaceReplaced()
 978 {
 979   // Just increment the semaphore
 980   mSurfaceSemaphore.Release(1);
 981 }
 982
 983 Dali::RenderSurfaceInterface* CombinedUpdateRenderController::ShouldSurfaceBeDeleted()
 984 {
 985   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
 986
 987   Dali::RenderSurfaceInterface* deletedSurface = mDeletedSurface;
 988   mDeletedSurface                              = NULL;
 989
 990   return deletedSurface;
 991 }
 992
 993 void CombinedUpdateRenderController::SurfaceDeleted()
 994 {
 995   // Just increment the semaphore
 996   mSurfaceSemaphore.Release(1);
 997 }
 998
 999 void CombinedUpdateRenderController::SurfaceResized()
1000 {
1001   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
1002   if(mSurfaceResized)
1003   {
1004     mSurfaceResized--;
1005   }
1006 }
1007
1008 ///////////////////////////////////////////////////////////////////////////////////////////////////
1009 // ALL THREADS
1010 ///////////////////////////////////////////////////////////////////////////////////////////////////
1011
1012 void CombinedUpdateRenderController::NotifyThreadInitialised()
1013 {
1014   // Just increment the semaphore
1015   mEventThreadSemaphore.Release(1);
1016 }
1017
1018 void CombinedUpdateRenderController::NotifyGraphicsInitialised()
1019 {
1020   mGraphicsInitializeWait.Notify();
1021 }
1022
1023 void CombinedUpdateRenderController::AddPerformanceMarker(PerformanceInterface::MarkerType type)
1024 {
1025   if(mPerformanceInterface)
1026   {
1027     mPerformanceInterface->AddMarker(type);
1028   }
1029 }
1030
1031 /////////////////////////////////////////////////////////////////////////////////////////////////
1032 // POST RENDERING: EVENT THREAD
1033 /////////////////////////////////////////////////////////////////////////////////////////////////
1034
1035 void CombinedUpdateRenderController::PostRenderComplete()
1036 {
1037   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
1038   mPostRendering = FALSE;
1039   mUpdateRenderThreadWaitCondition.Notify(lock);
1040 }
1041
1042 ///////////////////////////////////////////////////////////////////////////////////////////////////
1043 // POST RENDERING: RENDER THREAD
1044 ///////////////////////////////////////////////////////////////////////////////////////////////////
1045
1046 void CombinedUpdateRenderController::PostRenderStarted()
1047 {
1048   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
1049   mPostRendering = TRUE;
1050 }
1051
1052 void CombinedUpdateRenderController::PostRenderWaitForCompletion()
1053 {
1054   ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
1055   while(mPostRendering &&
1056         !mNewSurface &&     // We should NOT wait if we're replacing the surface
1057         !mDeletedSurface && // We should NOT wait if we're deleting the surface
1058         !mDestroyUpdateRenderThread)
1059   {
1060     mUpdateRenderThreadWaitCondition.Wait(lock);
1061   }
1062 }
1063
1064 } // namespace Adaptor
1065
1066 } // namespace Internal
1067
1068 } // namespace Dali