vcl/source/app/scheduler.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svdata.hxx>
  21 #include <tools/time.hxx>
  22 #include <vcl/scheduler.hxx>
  23 #include <saltimer.hxx>
  24 #include <salinst.hxx>
  25
  26 namespace {
  27 const sal_uInt64 MaximumTimeoutMs = 1000 * 60; // 1 minute
  28 }
  29
  30 void ImplSchedulerData::Invoke()
  31 {
  32     DBG_TESTSOLARMUTEX();
  33
  34     assert(!mbInScheduler);
  35     if (mbDelete || mbInScheduler )
  36         return;
  37
  38     // prepare Scheduler Object for deletion after handling
  39     mpTask->SetDeletionFlags();
  40
  41     // tdf#92036 Reset the period to avoid re-firing immediately.
  42     mpTask->mpSchedulerData->mnUpdateTime = tools::Time::GetSystemTicks();
  43
  44     // invoke it
  45     mbInScheduler = true;
  46     mpTask->Invoke();
  47     mbInScheduler = false;
  48 }
  49
  50 void Scheduler::ImplDeInitScheduler()
  51 {
  52     ImplSVData*     pSVData = ImplGetSVData();
  53     ImplSchedulerData*  pSchedulerData = pSVData->mpFirstSchedulerData;
  54     if (pSVData->mpSalTimer)
  55     {
  56         pSVData->mpSalTimer->Stop();
  57     }
  58
  59     if ( pSchedulerData )
  60     {
  61         do
  62         {
  63             ImplSchedulerData* pTempSchedulerData = pSchedulerData;
  64             if ( pSchedulerData->mpTask )
  65             {
  66                 pSchedulerData->mpTask->mbActive = false;
  67                 pSchedulerData->mpTask->mpSchedulerData = nullptr;
  68             }
  69             pSchedulerData = pSchedulerData->mpNext;
  70             delete pTempSchedulerData;
  71         }
  72         while ( pSchedulerData );
  73
  74         pSVData->mpFirstSchedulerData = nullptr;
  75         pSVData->mnTimerPeriod = 0;
  76     }
  77
  78     delete pSVData->mpSalTimer;
  79     pSVData->mpSalTimer = nullptr;
  80 }
  81
  82 /**
  83  * Start a new timer if we need to for nMS duration.
  84  *
  85  * if this is longer than the existing duration we're
  86  * waiting for, do nothing - unless bForce - which means
  87  * to reset the minimum period; used by the scheduled itself.
  88  */
  89 void Scheduler::ImplStartTimer(sal_uInt64 nMS, bool bForce)
  90 {
  91     ImplSVData* pSVData = ImplGetSVData();
  92     if (pSVData->mbDeInit)
  93     {
  94         // do not start new timers during shutdown - if that happens after
  95         // ImplSalStopTimer() on WNT the timer queue is restarted and never ends
  96         return;
  97     }
  98
  99     DBG_TESTSOLARMUTEX();
 100
 101     if (!pSVData->mpSalTimer)
 102     {
 103         pSVData->mnTimerPeriod = MaximumTimeoutMs;
 104         pSVData->mpSalTimer = pSVData->mpDefInst->CreateSalTimer();
 105         pSVData->mpSalTimer->SetCallback(Scheduler::CallbackTaskScheduling);
 106     }
 107
 108     if ( !nMS )
 109         nMS = 1;
 110
 111     // Only if smaller timeout, to avoid skipping.
 112     if (bForce || nMS < pSVData->mnTimerPeriod)
 113     {
 114         pSVData->mnTimerPeriod = nMS;
 115         pSVData->mpSalTimer->Start(nMS);
 116     }
 117 }
 118
 119 void Scheduler::CallbackTaskScheduling( bool bIdle )
 120 {
 121     // this function is for the saltimer callback
 122     Scheduler::ProcessTaskScheduling( bIdle );
 123 }
 124
 125 bool Scheduler::ProcessTaskScheduling( bool bIdle )
 126 {
 127     ImplSVData        *pSVData = ImplGetSVData();
 128     if ( pSVData->mbDeInit )
 129         return false;
 130     ImplSchedulerData *pMostUrgent = nullptr;
 131     sal_uInt64         nTime = tools::Time::GetSystemTicks();
 132
 133     DBG_TESTSOLARMUTEX();
 134
 135     for ( ImplSchedulerData *pSchedulerData = pSVData->mpFirstSchedulerData;
 136           pSchedulerData; pSchedulerData = pSchedulerData->mpNext )
 137     {
 138         if ( !pSchedulerData->mpTask || pSchedulerData->mbDelete || pSchedulerData->mbInScheduler ||
 139              !pSchedulerData->mpTask->ReadyForSchedule( bIdle, nTime ) ||
 140              !pSchedulerData->mpTask->IsActive())
 141             continue;
 142         if (!pMostUrgent)
 143             pMostUrgent = pSchedulerData;
 144         else
 145         {
 146             // Find the highest priority.
 147             // If the priority of the current task is higher (numerical value is lower) than
 148             // the priority of the most urgent, the current task gets the new most urgent.
 149             if ( pSchedulerData->mpTask->GetPriority() < pMostUrgent->mpTask->GetPriority() )
 150                 pMostUrgent = pSchedulerData;
 151         }
 152     }
 153
 154     if ( pMostUrgent )
 155     {
 156         SAL_INFO("vcl.schedule", "Invoke task " << pMostUrgent->GetDebugName());
 157
 158         pMostUrgent->mnUpdateTime = nTime;
 159         pMostUrgent->Invoke();
 160         return true;
 161     }
 162     else
 163         return false;
 164 }
 165
 166 static bool g_bDeterministicMode = false;
 167
 168 void Scheduler::SetDeterministicMode(bool bDeterministic)
 169 {
 170     g_bDeterministicMode = bDeterministic;
 171 }
 172
 173 bool Scheduler::GetDeterministicMode()
 174 {
 175     return g_bDeterministicMode;
 176 }
 177
 178 sal_uInt64 Scheduler::CalculateMinimumTimeout( bool &bHasActiveIdles )
 179 {
 180     ImplSchedulerData* pSchedulerData = nullptr;
 181     ImplSchedulerData* pPrevSchedulerData = nullptr;
 182     ImplSVData*        pSVData = ImplGetSVData();
 183     sal_uInt64         nTime = tools::Time::GetSystemTicks();
 184     sal_uInt64         nMinPeriod = MaximumTimeoutMs;
 185
 186     DBG_TESTSOLARMUTEX();
 187
 188     SAL_INFO("vcl.schedule", "Calculating minimum timeout:");
 189     pSchedulerData = pSVData->mpFirstSchedulerData;
 190     while ( pSchedulerData )
 191     {
 192         ImplSchedulerData *pNext = pSchedulerData->mpNext;
 193
 194         // Should Task be released from scheduling?
 195         if ( !pSchedulerData->mbInScheduler &&
 196               pSchedulerData->mbDelete )
 197         {
 198             if ( pPrevSchedulerData )
 199                 pPrevSchedulerData->mpNext = pSchedulerData->mpNext;
 200             else
 201                 pSVData->mpFirstSchedulerData = pSchedulerData->mpNext;
 202             if ( pSchedulerData->mpTask )
 203                 pSchedulerData->mpTask->mpSchedulerData = nullptr;
 204             pNext = pSchedulerData->mpNext;
 205             delete pSchedulerData;
 206         }
 207         else
 208         {
 209             if (!pSchedulerData->mbInScheduler)
 210             {
 211                 if ( !pSchedulerData->mpTask->IsIdle() )
 212                 {
 213                     sal_uInt64 nOldMinPeriod = nMinPeriod;
 214                     nMinPeriod = pSchedulerData->mpTask->UpdateMinPeriod(
 215                                                            nOldMinPeriod, nTime );
 216                     SAL_INFO("vcl.schedule", "Have active timer '" <<
 217                              pSchedulerData->GetDebugName() <<
 218                              "' update min period from " << nOldMinPeriod <<
 219                              " to " << nMinPeriod);
 220                     assert( nMinPeriod <= nOldMinPeriod );
 221                     if ( nMinPeriod > nOldMinPeriod )
 222                     {
 223                         nMinPeriod = nOldMinPeriod;
 224                         SAL_WARN("vcl.schedule",
 225                              "New update min period > old period - using old");
 226                     }
 227                 }
 228                 else
 229                 {
 230                     SAL_INFO("vcl.schedule", "Have active idle '" <<
 231                              pSchedulerData->GetDebugName() << "'");
 232                     bHasActiveIdles = true;
 233                 }
 234             }
 235             pPrevSchedulerData = pSchedulerData;
 236         }
 237         pSchedulerData = pNext;
 238     }
 239
 240     // delete clock if no more timers available,
 241     if ( !pSVData->mpFirstSchedulerData )
 242     {
 243         if ( pSVData->mpSalTimer )
 244             pSVData->mpSalTimer->Stop();
 245         nMinPeriod = MaximumTimeoutMs;
 246         pSVData->mnTimerPeriod = nMinPeriod;
 247         SAL_INFO("vcl.schedule", "Unusual - no more timers available - stop timer");
 248     }
 249     else
 250     {
 251         Scheduler::ImplStartTimer(nMinPeriod, true);
 252         SAL_INFO("vcl.schedule", "Calculated minimum timeout as " << nMinPeriod << " and " <<
 253                  (bHasActiveIdles ? "has active idles" : "no idles"));
 254     }
 255
 256     return nMinPeriod;
 257 }
 258
 259 const char *ImplSchedulerData::GetDebugName() const
 260 {
 261     return mpTask && mpTask->GetDebugName() ?
 262         mpTask->GetDebugName() : "unknown";
 263 }
 264
 265 void Task::StartTimer( sal_uInt64 nMS )
 266 {
 267     Scheduler::ImplStartTimer( nMS, false );
 268 }
 269
 270 void Task::SetDeletionFlags()
 271 {
 272     mpSchedulerData->mbDelete = true;
 273     mbActive = false;
 274 }
 275
 276 void Task::Start()
 277 {
 278     ImplSVData *const pSVData = ImplGetSVData();
 279     if (pSVData->mbDeInit)
 280     {
 281         return;
 282     }
 283
 284     DBG_TESTSOLARMUTEX();
 285
 286     // Mark timer active
 287     mbActive = true;
 288
 289     if ( !mpSchedulerData )
 290     {
 291         // insert Task
 292         mpSchedulerData                = new ImplSchedulerData;
 293         mpSchedulerData->mpTask        = this;
 294         mpSchedulerData->mbInScheduler = false;
 295
 296         // insert last due to SFX!
 297         ImplSchedulerData* pPrev = nullptr;
 298         ImplSchedulerData* pData = pSVData->mpFirstSchedulerData;
 299         while ( pData )
 300         {
 301             pPrev = pData;
 302             pData = pData->mpNext;
 303         }
 304         mpSchedulerData->mpNext = nullptr;
 305         if ( pPrev )
 306             pPrev->mpNext = mpSchedulerData;
 307         else
 308             pSVData->mpFirstSchedulerData = mpSchedulerData;
 309     }
 310     mpSchedulerData->mbDelete      = false;
 311     mpSchedulerData->mnUpdateTime  = tools::Time::GetSystemTicks();
 312 }
 313
 314 void Task::Stop()
 315 {
 316     mbActive = false;
 317
 318     if ( mpSchedulerData )
 319         mpSchedulerData->mbDelete = true;
 320 }
 321
 322 Task& Task::operator=( const Task& rTask )
 323 {
 324     if ( IsActive() )
 325         Stop();
 326
 327     mbActive = false;
 328     mePriority = rTask.mePriority;
 329
 330     if ( rTask.IsActive() )
 331         Start();
 332
 333     return *this;
 334 }
 335
 336 Task::Task( const sal_Char *pDebugName )
 337     : mpSchedulerData( nullptr )
 338     , mpDebugName( pDebugName )
 339     , mePriority( TaskPriority::HIGH )
 340     , mbActive( false )
 341 {
 342 }
 343
 344 Task::Task( const Task& rTask )
 345     : mpSchedulerData( nullptr )
 346     , mpDebugName( rTask.mpDebugName )
 347     , mePriority( rTask.mePriority )
 348     , mbActive( false )
 349 {
 350     if ( rTask.IsActive() )
 351         Start();
 352 }
 353
 354 Task::~Task()
 355 {
 356     if ( mpSchedulerData )
 357     {
 358         mpSchedulerData->mbDelete = true;
 359         mpSchedulerData->mpTask = nullptr;
 360     }
 361 }
 362
 363 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */