salhelper/source/timer.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 #include <salhelper/timer.hxx>
  20
  21 #include <osl/thread.hxx>
  22
  23 #include <condition_variable>
  24 #include <mutex>
  25
  26 using namespace salhelper;
  27
  28 class salhelper::TimerManager final : public osl::Thread
  29 {
  30 public:
  31     TimerManager();
  32
  33     ~TimerManager();
  34
  35     /// register timer
  36     void registerTimer(salhelper::Timer* pTimer);
  37
  38     /// unregister timer
  39     void unregisterTimer(salhelper::Timer const * pTimer);
  40
  41     /// lookup timer
  42     bool lookupTimer(const salhelper::Timer* pTimer);
  43
  44 protected:
  45     /// worker-function of thread
  46     virtual void SAL_CALL run() override;
  47
  48     /// Checking and triggering of a timer event
  49     void checkForTimeout();
  50
  51     /// sorted-queue data
  52     salhelper::Timer*       m_pHead;
  53     bool m_terminate;
  54     /// List Protection
  55     std::mutex                  m_Lock;
  56     /// Signal the insertion of a timer
  57     std::condition_variable     m_notEmpty;
  58
  59     /// "Singleton Pattern"
  60     //static salhelper::TimerManager* m_pManager;
  61
  62 };
  63
  64 namespace
  65 {
  66     salhelper::TimerManager& getTimerManager()
  67     {
  68         static salhelper::TimerManager aManager;
  69         return aManager;
  70     }
  71 }
  72
  73
  74 Timer::Timer()
  75     : m_aTimeOut(0),
  76       m_aExpired(0),
  77       m_aRepeatDelta(0),
  78       m_pNext(nullptr)
  79 {
  80 }
  81
  82 Timer::Timer(const TTimeValue& rTime)
  83     : m_aTimeOut(rTime),
  84       m_aExpired(0),
  85       m_aRepeatDelta(0),
  86       m_pNext(nullptr)
  87 {
  88 }
  89
  90 Timer::Timer(const TTimeValue& rTime, const TTimeValue& Repeat)
  91     : m_aTimeOut(rTime),
  92       m_aExpired(0),
  93       m_aRepeatDelta(Repeat),
  94       m_pNext(nullptr)
  95 {
  96 }
  97
  98 Timer::~Timer()
  99 {
 100     stop();
 101 }
 102
 103 void Timer::start()
 104 {
 105     if (!isTicking())
 106     {
 107         if (!m_aTimeOut.isEmpty())
 108             setRemainingTime(m_aTimeOut);
 109
 110         getTimerManager().registerTimer(this);
 111     }
 112 }
 113
 114 void Timer::stop()
 115 {
 116     getTimerManager().unregisterTimer(this);
 117 }
 118
 119 sal_Bool Timer::isTicking() const
 120 {
 121     return getTimerManager().lookupTimer(this);
 122 }
 123
 124 sal_Bool Timer::isExpired() const
 125 {
 126     TTimeValue Now;
 127
 128     osl_getSystemTime(&Now);
 129
 130     return !(Now < m_aExpired);
 131 }
 132
 133 sal_Bool Timer::expiresBefore(const Timer* pTimer) const
 134 {
 135     if (pTimer)
 136         return m_aExpired < pTimer->m_aExpired;
 137     else
 138         return false;
 139 }
 140
 141 void Timer::setAbsoluteTime(const TTimeValue& Time)
 142 {
 143     m_aTimeOut = 0;
 144     m_aExpired = Time;
 145     m_aRepeatDelta = 0;
 146
 147     m_aExpired.normalize();
 148 }
 149
 150 void Timer::setRemainingTime(const TTimeValue& Remaining)
 151 {
 152     osl_getSystemTime(&m_aExpired);
 153
 154     m_aExpired.addTime(Remaining);
 155 }
 156
 157 void Timer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
 158 {
 159     osl_getSystemTime(&m_aExpired);
 160
 161     m_aExpired.addTime(Remaining);
 162
 163     m_aRepeatDelta = Repeat;
 164 }
 165
 166 void Timer::addTime(const TTimeValue& Delta)
 167 {
 168     m_aExpired.addTime(Delta);
 169 }
 170
 171 TTimeValue Timer::getRemainingTime() const
 172 {
 173     TTimeValue Now;
 174
 175     osl_getSystemTime(&Now);
 176
 177     sal_Int32 secs = m_aExpired.Seconds - Now.Seconds;
 178
 179     if (secs < 0)
 180         return TTimeValue(0, 0);
 181
 182     sal_Int32 nsecs = m_aExpired.Nanosec - Now.Nanosec;
 183
 184     if (nsecs < 0)
 185     {
 186         if (secs > 0)
 187         {
 188             secs  -= 1;
 189             nsecs += 1000000000;
 190         }
 191         else
 192             return TTimeValue(0, 0);
 193     }
 194
 195     return TTimeValue(secs, nsecs);
 196 }
 197
 198 /** The timer manager cleanup has been removed (no thread is killed anymore),
 199     so the thread leaks.
 200
 201     This will result in a GPF in case the salhelper-library gets unloaded before
 202     process termination.
 203
 204     @TODO : rewrite this file, so that the timerManager thread gets destroyed,
 205             when there are no timers anymore !
 206 **/
 207
 208 TimerManager::TimerManager() :
 209     m_pHead(nullptr), m_terminate(false)
 210 {
 211     // start thread
 212     create();
 213 }
 214
 215 TimerManager::~TimerManager() {
 216     {
 217         std::scoped_lock g(m_Lock);
 218         m_terminate = true;
 219     }
 220     m_notEmpty.notify_all();
 221     join();
 222 }
 223
 224 void TimerManager::registerTimer(Timer* pTimer)
 225 {
 226     if (!pTimer)
 227         return;
 228
 229     bool notify = false;
 230     {
 231         std::lock_guard Guard(m_Lock);
 232
 233         // try to find one with equal or lower remaining time.
 234         Timer** ppIter = &m_pHead;
 235
 236         while (*ppIter)
 237         {
 238             if (pTimer->expiresBefore(*ppIter))
 239             {
 240                 // next element has higher remaining time,
 241                 // => insert new timer before
 242                 break;
 243             }
 244             ppIter= &((*ppIter)->m_pNext);
 245         }
 246
 247         // next element has higher remaining time,
 248         // => insert new timer before
 249         pTimer->m_pNext= *ppIter;
 250         *ppIter = pTimer;
 251
 252
 253         if (pTimer == m_pHead)
 254         {
 255             notify = true;
 256         }
 257     }
 258
 259     if (notify) {
 260         // it was inserted as new head
 261         // signal it to TimerManager Thread
 262         m_notEmpty.notify_all();
 263     }
 264 }
 265
 266 void TimerManager::unregisterTimer(Timer const * pTimer)
 267 {
 268     if (!pTimer)
 269         return;
 270
 271     // lock access
 272     std::lock_guard Guard(m_Lock);
 273
 274     Timer** ppIter = &m_pHead;
 275
 276     while (*ppIter)
 277     {
 278         if (pTimer == (*ppIter))
 279         {
 280             // remove timer from list
 281             *ppIter = (*ppIter)->m_pNext;
 282             return;
 283         }
 284         ppIter= &((*ppIter)->m_pNext);
 285     }
 286 }
 287
 288 bool TimerManager::lookupTimer(const Timer* pTimer)
 289 {
 290     if (!pTimer)
 291         return false;
 292
 293     // lock access
 294     std::lock_guard Guard(m_Lock);
 295
 296     // check the list
 297     for (Timer* pIter = m_pHead; pIter != nullptr; pIter= pIter->m_pNext)
 298     {
 299         if (pIter == pTimer)
 300             return true;
 301     }
 302
 303     return false;
 304 }
 305
 306 void TimerManager::checkForTimeout()
 307 {
 308     std::unique_lock aLock (m_Lock);
 309
 310     if (!m_pHead)
 311     {
 312         return;
 313     }
 314
 315     Timer* pTimer = m_pHead;
 316
 317     if (!pTimer->isExpired())
 318         return;
 319
 320     // remove expired timer
 321     m_pHead = pTimer->m_pNext;
 322
 323     pTimer->acquire();
 324
 325     aLock.unlock();
 326
 327     pTimer->onShot();
 328
 329     // restart timer if specified
 330     if (!pTimer->m_aRepeatDelta.isEmpty())
 331     {
 332         TTimeValue Now;
 333
 334         osl_getSystemTime(&Now);
 335
 336         Now.Seconds += pTimer->m_aRepeatDelta.Seconds;
 337         Now.Nanosec += pTimer->m_aRepeatDelta.Nanosec;
 338
 339         pTimer->m_aExpired = Now;
 340
 341         registerTimer(pTimer);
 342     }
 343     pTimer->release();
 344 }
 345
 346 void TimerManager::run()
 347 {
 348     osl_setThreadName("salhelper::TimerManager");
 349
 350     setPriority( osl_Thread_PriorityBelowNormal );
 351
 352     while (schedule())
 353     {
 354         {
 355             std::unique_lock a_Guard(m_Lock);
 356
 357             if (m_pHead != nullptr)
 358             {
 359                 TTimeValue delay = m_pHead->getRemainingTime();
 360                 m_notEmpty.wait_for(
 361                     a_Guard,
 362                     std::chrono::nanoseconds(
 363                         sal_Int64(delay.Seconds) * 1'000'000'000 + delay.Nanosec),
 364                     [this] { return m_terminate; });
 365             }
 366             else
 367             {
 368                 m_notEmpty.wait(a_Guard, [this] { return m_terminate || m_pHead != nullptr; });
 369             }
 370
 371             if (m_terminate) {
 372                 break;
 373             }
 374         }
 375
 376         checkForTimeout();
 377     }
 378
 379 }
 380
 381 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */