LCOV - code coverage report
Current view: top level - salhelper/source - timer.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 158 0.0 %
Date: 2014-04-14 Functions: 0 25 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/diagnose.h>
      22             : #include <salhelper/simplereferenceobject.hxx>
      23             : #include <osl/thread.hxx>
      24             : #include <osl/conditn.hxx>
      25             : #include <osl/mutex.hxx>
      26             : #include <rtl/instance.hxx>
      27             : 
      28             : using namespace salhelper;
      29             : 
      30             : class salhelper::TimerManager : public osl::Thread
      31             : {
      32             : 
      33             : public:
      34             : 
      35             : 
      36             :     TimerManager();
      37             : 
      38             : 
      39             :     virtual ~TimerManager();
      40             : 
      41             :     /// register timer
      42             :     bool SAL_CALL registerTimer(salhelper::Timer* pTimer);
      43             : 
      44             :     /// unregister timer
      45             :     bool SAL_CALL unregisterTimer(salhelper::Timer* pTimer);
      46             : 
      47             :     /// lookup timer
      48             :     bool SAL_CALL lookupTimer(const salhelper::Timer* pTimer);
      49             : 
      50             :     /// retrieves the "Singleton" TimerManager Instance
      51             :     static TimerManager* SAL_CALL getTimerManager();
      52             : 
      53             : 
      54             : protected:
      55             : 
      56             :     /// worker-function of thread
      57             :     virtual void SAL_CALL run() SAL_OVERRIDE;
      58             : 
      59             :     // Checking and triggering of a timer event
      60             :     void SAL_CALL checkForTimeout();
      61             : 
      62             :     // cleanup Method
      63             :     virtual void SAL_CALL onTerminated() SAL_OVERRIDE;
      64             : 
      65             :     // sorted-queue data
      66             :     salhelper::Timer*       m_pHead;
      67             :     // List Protection
      68             :     osl::Mutex                  m_Lock;
      69             :     // Signal the insertion of a timer
      70             :     osl::Condition              m_notEmpty;
      71             : 
      72             :     // "Singleton Pattern"
      73             :     static salhelper::TimerManager* m_pManager;
      74             : 
      75             : };
      76             : 
      77             : 
      78             : 
      79             : // Timer class
      80             : 
      81             : 
      82           0 : Timer::Timer()
      83             :     : m_aTimeOut( 0 ),
      84             :       m_aExpired( 0 ),
      85             :       m_aRepeatDelta( 0 ),
      86           0 :       m_pNext( NULL )
      87             : {
      88           0 : }
      89             : 
      90           0 : Timer::Timer( const TTimeValue& Time )
      91             :     : m_aTimeOut( Time ),
      92             :       m_aExpired( 0 ),
      93             :       m_aRepeatDelta( 0 ),
      94           0 :       m_pNext( NULL )
      95             : {
      96           0 : }
      97             : 
      98           0 : Timer::Timer( const TTimeValue& Time, const TTimeValue& Repeat )
      99             :     : m_aTimeOut( Time ),
     100             :       m_aExpired( 0 ),
     101             :       m_aRepeatDelta( Repeat ),
     102           0 :       m_pNext( NULL )
     103             : {
     104           0 : }
     105             : 
     106           0 : Timer::~Timer()
     107             : {
     108           0 :     stop();
     109           0 : }
     110             : 
     111           0 : void Timer::start()
     112             : {
     113           0 :     if (! isTicking())
     114             :     {
     115           0 :         if (! m_aTimeOut.isEmpty())
     116           0 :             setRemainingTime(m_aTimeOut);
     117             : 
     118           0 :         TimerManager *pManager = TimerManager::getTimerManager();
     119             : 
     120             :         OSL_ASSERT(pManager);
     121             : 
     122           0 :         if ( pManager != 0 )
     123             :         {
     124           0 :             pManager->registerTimer(this);
     125             :         }
     126             :     }
     127           0 : }
     128             : 
     129           0 : void Timer::stop()
     130             : {
     131           0 :     TimerManager *pManager = TimerManager::getTimerManager();
     132             : 
     133             :     OSL_ASSERT(pManager);
     134             : 
     135           0 :     if ( pManager != 0 )
     136             :     {
     137           0 :         pManager->unregisterTimer(this);
     138             :     }
     139           0 : }
     140             : 
     141           0 : sal_Bool Timer::isTicking() const
     142             : {
     143           0 :     TimerManager *pManager = TimerManager::getTimerManager();
     144             : 
     145             :     OSL_ASSERT(pManager);
     146             : 
     147           0 :     if (pManager)
     148           0 :         return pManager->lookupTimer(this);
     149             :     else
     150           0 :         return sal_False;
     151             : 
     152             : }
     153             : 
     154           0 : sal_Bool Timer::isExpired() const
     155             : {
     156           0 :     TTimeValue Now;
     157             : 
     158           0 :     osl_getSystemTime(&Now);
     159             : 
     160           0 :     return !(Now < m_aExpired);
     161             : }
     162             : 
     163           0 : sal_Bool Timer::expiresBefore(const Timer* pTimer) const
     164             : {
     165             :     OSL_ASSERT(pTimer);
     166             : 
     167           0 :     if ( pTimer != 0 )
     168             :     {
     169           0 :         return m_aExpired < pTimer->m_aExpired;
     170             :     }
     171             :     else
     172             :     {
     173           0 :         return sal_False;
     174             :     }
     175             : }
     176             : 
     177           0 : void Timer::setAbsoluteTime(const TTimeValue& Time)
     178             : {
     179           0 :     m_aTimeOut     = 0;
     180           0 :     m_aExpired     = Time;
     181           0 :     m_aRepeatDelta = 0;
     182             : 
     183           0 :     m_aExpired.normalize();
     184           0 : }
     185             : 
     186           0 : void Timer::setRemainingTime(const TTimeValue& Remaining)
     187             : {
     188           0 :     osl_getSystemTime(&m_aExpired);
     189             : 
     190           0 :     m_aExpired.addTime(Remaining);
     191           0 : }
     192             : 
     193           0 : void Timer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
     194             : {
     195           0 :     osl_getSystemTime(&m_aExpired);
     196             : 
     197           0 :     m_aExpired.addTime(Remaining);
     198             : 
     199           0 :     m_aRepeatDelta = Repeat;
     200           0 : }
     201             : 
     202           0 : void Timer::addTime(const TTimeValue& Delta)
     203             : {
     204           0 :     m_aExpired.addTime(Delta);
     205           0 : }
     206             : 
     207           0 : TTimeValue Timer::getRemainingTime() const
     208             : {
     209           0 :     TTimeValue Now;
     210             : 
     211           0 :     osl_getSystemTime(&Now);
     212             : 
     213           0 :     sal_Int32 secs = m_aExpired.Seconds - Now.Seconds;
     214             : 
     215           0 :     if (secs < 0)
     216           0 :         return TTimeValue(0, 0);
     217             : 
     218           0 :     sal_Int32 nsecs = m_aExpired.Nanosec - Now.Nanosec;
     219             : 
     220           0 :     if (nsecs < 0)
     221             :     {
     222           0 :         if (secs > 0)
     223             :         {
     224           0 :             secs  -= 1;
     225           0 :             nsecs += 1000000000L;
     226             :         }
     227             :         else
     228           0 :             return TTimeValue(0, 0);
     229             :     }
     230             : 
     231           0 :     return TTimeValue(secs, nsecs);
     232             : }
     233             : 
     234             : 
     235             : 
     236             : 
     237             : // Timer manager
     238             : 
     239             : namespace
     240             : {
     241             :     // Synchronize access to TimerManager
     242             :     struct theTimerManagerMutex : public rtl::Static< osl::Mutex, theTimerManagerMutex> {};
     243             : }
     244             : 
     245             : TimerManager* salhelper::TimerManager::m_pManager = NULL;
     246             : 
     247           0 : TimerManager::TimerManager()
     248             : {
     249           0 :     osl::MutexGuard Guard(theTimerManagerMutex::get());
     250             : 
     251             :     OSL_ASSERT(m_pManager == 0);
     252             : 
     253           0 :     m_pManager = this;
     254             : 
     255           0 :     m_pHead= 0;
     256             : 
     257           0 :     m_notEmpty.reset();
     258             : 
     259             :     // start thread
     260           0 :     create();
     261           0 : }
     262             : 
     263           0 : TimerManager::~TimerManager()
     264             : {
     265           0 :     osl::MutexGuard Guard(theTimerManagerMutex::get());
     266             : 
     267           0 :     if ( m_pManager == this )
     268           0 :         m_pManager = 0;
     269           0 : }
     270             : 
     271           0 : void TimerManager::onTerminated()
     272             : {
     273           0 :     delete this; // mfe: AAARRRGGGHHH!!!
     274           0 : }
     275             : 
     276           0 : TimerManager* TimerManager::getTimerManager()
     277             : {
     278           0 :     osl::MutexGuard Guard(theTimerManagerMutex::get());
     279             : 
     280           0 :     if (! m_pManager)
     281           0 :         new TimerManager;
     282             : 
     283           0 :     return m_pManager;
     284             : }
     285             : 
     286           0 : bool TimerManager::registerTimer(Timer* pTimer)
     287             : {
     288             :     OSL_ASSERT(pTimer);
     289             : 
     290           0 :     if ( pTimer == 0 )
     291             :     {
     292           0 :         return false;
     293             :     }
     294             : 
     295           0 :     osl::MutexGuard Guard(m_Lock);
     296             : 
     297             :     // try to find one with equal or lower remaining time.
     298           0 :     Timer** ppIter = &m_pHead;
     299             : 
     300           0 :     while (*ppIter)
     301             :     {
     302           0 :         if (pTimer->expiresBefore(*ppIter))
     303             :         {
     304             :             // next element has higher remaining time,
     305             :             // => insert new timer before
     306           0 :             break;
     307             :         }
     308           0 :         ppIter= &((*ppIter)->m_pNext);
     309             :     }
     310             : 
     311             :     // next element has higher remaining time,
     312             :     // => insert new timer before
     313           0 :     pTimer->m_pNext= *ppIter;
     314           0 :     *ppIter = pTimer;
     315             : 
     316             : 
     317           0 :     if (pTimer == m_pHead)
     318             :     {
     319             :         // it was inserted as new head
     320             :         // signal it to TimerManager Thread
     321           0 :         m_notEmpty.set();
     322             :     }
     323             : 
     324           0 :     return true;
     325             : }
     326             : 
     327           0 : bool TimerManager::unregisterTimer(Timer* pTimer)
     328             : {
     329             :     OSL_ASSERT(pTimer);
     330             : 
     331           0 :     if ( pTimer == 0 )
     332             :     {
     333           0 :         return false;
     334             :     }
     335             : 
     336             :     // lock access
     337           0 :     osl::MutexGuard Guard(m_Lock);
     338             : 
     339           0 :     Timer** ppIter = &m_pHead;
     340             : 
     341           0 :     while (*ppIter)
     342             :     {
     343           0 :         if (pTimer == (*ppIter))
     344             :         {
     345             :             // remove timer from list
     346           0 :             *ppIter = (*ppIter)->m_pNext;
     347           0 :             return true;
     348             :         }
     349           0 :         ppIter= &((*ppIter)->m_pNext);
     350             :     }
     351             : 
     352           0 :     return false;
     353             : }
     354             : 
     355           0 : bool TimerManager::lookupTimer(const Timer* pTimer)
     356             : {
     357             :     OSL_ASSERT(pTimer);
     358             : 
     359           0 :     if ( pTimer == 0 )
     360             :     {
     361           0 :         return false;
     362             :     }
     363             : 
     364             :     // lock access
     365           0 :     osl::MutexGuard Guard(m_Lock);
     366             : 
     367             :     // check the list
     368           0 :     for (Timer* pIter = m_pHead; pIter != 0; pIter= pIter->m_pNext)
     369             :     {
     370           0 :         if (pIter == pTimer)
     371             :         {
     372           0 :             return true;
     373             :         }
     374             :     }
     375             : 
     376           0 :     return false;
     377             : }
     378             : 
     379           0 : void TimerManager::checkForTimeout()
     380             : {
     381             : 
     382           0 :     m_Lock.acquire();
     383             : 
     384           0 :     if ( m_pHead == 0 )
     385             :     {
     386           0 :         m_Lock.release();
     387           0 :         return;
     388             :     }
     389             : 
     390           0 :     Timer* pTimer = m_pHead;
     391             : 
     392           0 :     if (pTimer->isExpired())
     393             :     {
     394             :         // remove expired timer
     395           0 :         m_pHead = pTimer->m_pNext;
     396             : 
     397           0 :         pTimer->acquire();
     398             : 
     399           0 :         m_Lock.release();
     400             : 
     401           0 :         pTimer->onShot();
     402             : 
     403             :         // restart timer if specified
     404           0 :         if ( ! pTimer->m_aRepeatDelta.isEmpty() )
     405             :         {
     406           0 :             TTimeValue Now;
     407             : 
     408           0 :             osl_getSystemTime(&Now);
     409             : 
     410           0 :             Now.Seconds += pTimer->m_aRepeatDelta.Seconds;
     411           0 :             Now.Nanosec += pTimer->m_aRepeatDelta.Nanosec;
     412             : 
     413           0 :             pTimer->m_aExpired = Now;
     414             : 
     415           0 :             registerTimer(pTimer);
     416             :         }
     417           0 :         pTimer->release();
     418             :     }
     419             :     else
     420             :     {
     421           0 :         m_Lock.release();
     422             :     }
     423             : 
     424             : 
     425           0 :     return;
     426             : }
     427             : 
     428           0 : void TimerManager::run()
     429             : {
     430           0 :     setPriority( osl_Thread_PriorityBelowNormal );
     431             : 
     432           0 :     while (schedule())
     433             :     {
     434           0 :         TTimeValue      delay;
     435           0 :         TTimeValue*     pDelay=0;
     436             : 
     437             : 
     438           0 :         m_Lock.acquire();
     439             : 
     440           0 :         if (m_pHead != 0)
     441             :         {
     442           0 :             delay = m_pHead->getRemainingTime();
     443           0 :             pDelay=&delay;
     444             :         }
     445             :         else
     446             :         {
     447           0 :             pDelay=0;
     448             :         }
     449             : 
     450             : 
     451           0 :         m_notEmpty.reset();
     452             : 
     453           0 :         m_Lock.release();
     454             : 
     455             : 
     456           0 :         m_notEmpty.wait(pDelay);
     457             : 
     458           0 :         checkForTimeout();
     459             :     }
     460             : 
     461           0 : }
     462             : 
     463             : 
     464             : 
     465             : 
     466             : // Timer manager cleanup
     467             : 
     468             : 
     469             : // jbu:
     470             : // The timer manager cleanup has been removed (no thread is killed anymore).
     471             : // So the thread leaks.
     472             : // This will result in a GPF in case the salhelper-library gets unloaded before
     473             : // process termination.
     474             : // -> TODO : rewrite this file, so that the timerManager thread gets destroyed,
     475             : //           when there are no timers anymore !
     476             : 
     477             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10