vos/source/timer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: timer.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <osl/time.h>
  32
  33 #include <vos/timer.hxx>
  34 #include <vos/diagnose.hxx>
  35 #include <vos/ref.hxx>
  36 #include <vos/thread.hxx>
  37 #include <vos/conditn.hxx>
  38
  39
  40 /////////////////////////////////////////////////////////////////////////////
  41 //
  42 // Timer manager
  43 //
  44
  45 class OTimerManagerCleanup;
  46
  47 class NAMESPACE_VOS(OTimerManager) : public NAMESPACE_VOS(OThread)
  48 {
  49
  50 public:
  51
  52     ///
  53       OTimerManager();
  54
  55     ///
  56       ~OTimerManager();
  57
  58       /// register timer
  59     sal_Bool SAL_CALL registerTimer(NAMESPACE_VOS(OTimer)* pTimer);
  60
  61       /// unregister timer
  62     sal_Bool SAL_CALL unregisterTimer(NAMESPACE_VOS(OTimer)* pTimer);
  63
  64       /// lookup timer
  65     sal_Bool SAL_CALL lookupTimer(const NAMESPACE_VOS(OTimer)* pTimer);
  66
  67     /// retrieves the "Singleton" TimerManager Instance
  68     static OTimerManager* SAL_CALL getTimerManager();
  69
  70
  71 protected:
  72
  73      /// worker-function of thread
  74       virtual void SAL_CALL run();
  75
  76     // Checking and triggering of a timer event
  77     void SAL_CALL checkForTimeout();
  78
  79     // cleanup Method
  80     virtual void SAL_CALL onTerminated();
  81
  82       // sorted-queue data
  83       NAMESPACE_VOS(OTimer)*            m_pHead;
  84     // List Protection
  85     NAMESPACE_VOS(OMutex)               m_Lock;
  86     // Signal the insertion of a timer
  87     NAMESPACE_VOS(OCondition)   m_notEmpty;
  88
  89     // Synchronize access to OTimerManager
  90     static NAMESPACE_VOS(OMutex) m_Access;
  91
  92     // "Singleton Pattern"
  93     static NAMESPACE_VOS(OTimerManager)* m_pManager;
  94
  95     friend class OTimerManagerCleanup;
  96
  97 };
  98
  99 using namespace vos;
 100
 101 /////////////////////////////////////////////////////////////////////////////
 102 //
 103 // Timer class
 104 //
 105
 106 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OTimer, vos),
 107                         VOS_NAMESPACE(OTimer, vos),
 108                         VOS_NAMESPACE(OObject, vos), 0);
 109
 110 OTimer::OTimer()
 111 {
 112     m_TimeOut     = 0;
 113     m_Expired     = 0;
 114     m_RepeatDelta = 0;
 115       m_pNext       = 0;
 116 }
 117
 118 OTimer::OTimer(const TTimeValue& Time)
 119 {
 120     m_TimeOut     = Time;
 121     m_RepeatDelta = 0;
 122     m_Expired     = 0;
 123       m_pNext       = 0;
 124
 125     m_TimeOut.normalize();
 126 }
 127
 128 OTimer::OTimer(const TTimeValue& Time, const TTimeValue& Repeat)
 129 {
 130     m_TimeOut     = Time;
 131     m_RepeatDelta = Repeat;
 132     m_Expired     = 0;
 133       m_pNext       = 0;
 134
 135     m_TimeOut.normalize();
 136     m_RepeatDelta.normalize();
 137 }
 138
 139 OTimer::~OTimer()
 140 {
 141     stop();
 142 }
 143
 144 void OTimer::start()
 145 {
 146     if (! isTicking())
 147     {
 148         if (! m_TimeOut.isEmpty())
 149             setRemainingTime(m_TimeOut);
 150
 151         OTimerManager *pManager = OTimerManager::getTimerManager();
 152
 153         VOS_ASSERT(pManager);
 154
 155         if ( pManager != 0 )
 156         {
 157             pManager->registerTimer(this);
 158         }
 159     }
 160 }
 161
 162 void OTimer::stop()
 163 {
 164     OTimerManager *pManager = OTimerManager::getTimerManager();
 165
 166     VOS_ASSERT(pManager);
 167
 168     if ( pManager != 0 )
 169     {
 170         pManager->unregisterTimer(this);
 171     }
 172 }
 173
 174 sal_Bool OTimer::isTicking() const
 175 {
 176     OTimerManager *pManager = OTimerManager::getTimerManager();
 177
 178     VOS_ASSERT(pManager);
 179
 180     if (pManager)
 181         return pManager->lookupTimer(this);
 182     else
 183         return sal_False;
 184
 185 }
 186
 187 sal_Bool OTimer::isExpired() const
 188 {
 189     TTimeValue Now;
 190
 191     osl_getSystemTime(&Now);
 192
 193     return !(Now < m_Expired);
 194 }
 195
 196 sal_Bool OTimer::expiresBefore(const OTimer* pTimer) const
 197 {
 198     VOS_ASSERT(pTimer);
 199
 200     if ( pTimer != 0 )
 201     {
 202         return m_Expired < pTimer->m_Expired;
 203     }
 204     else
 205     {
 206         return sal_False;
 207     }
 208 }
 209
 210 void OTimer::setAbsoluteTime(const TTimeValue& Time)
 211 {
 212     m_TimeOut     = 0;
 213     m_Expired     = Time;
 214     m_RepeatDelta = 0;
 215
 216     m_Expired.normalize();
 217 }
 218
 219 void OTimer::setRemainingTime(const TTimeValue& Remaining)
 220 {
 221     osl_getSystemTime(&m_Expired);
 222
 223     m_Expired.addTime(Remaining);
 224 }
 225
 226 void OTimer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
 227 {
 228     osl_getSystemTime(&m_Expired);
 229
 230     m_Expired.addTime(Remaining);
 231
 232     m_RepeatDelta = Repeat;
 233 }
 234
 235 void OTimer::addTime(const TTimeValue& Delta)
 236 {
 237     m_Expired.addTime(Delta);
 238 }
 239
 240 TTimeValue OTimer::getRemainingTime() const
 241 {
 242     TTimeValue Now;
 243
 244     osl_getSystemTime(&Now);
 245
 246     sal_Int32 secs = m_Expired.Seconds - Now.Seconds;
 247
 248     if (secs < 0)
 249         return TTimeValue(0, 0);
 250
 251     sal_Int32 nsecs = m_Expired.Nanosec - Now.Nanosec;
 252
 253     if (nsecs < 0)
 254     {
 255         if (secs > 0)
 256         {
 257             secs  -= 1;
 258             nsecs += 1000000000;
 259         }
 260         else
 261             return TTimeValue(0, 0);
 262     }
 263
 264     return TTimeValue(secs, nsecs);
 265 }
 266
 267
 268 /////////////////////////////////////////////////////////////////////////////
 269 //
 270 // Timer manager
 271 //
 272
 273 OMutex NAMESPACE_VOS(OTimerManager)::m_Access;
 274 OTimerManager* NAMESPACE_VOS(OTimerManager)::m_pManager=0;
 275
 276 OTimerManager::OTimerManager()
 277 {
 278     OGuard Guard(&m_Access);
 279
 280     VOS_ASSERT(m_pManager == 0);
 281
 282     m_pManager = this;
 283
 284     m_pHead= 0;
 285
 286     m_notEmpty.reset();
 287
 288     // start thread
 289     create();
 290 }
 291
 292 OTimerManager::~OTimerManager()
 293 {
 294     OGuard Guard(&m_Access);
 295
 296     if ( m_pManager == this )
 297         m_pManager = 0;
 298 }
 299
 300 void OTimerManager::onTerminated()
 301 {
 302     delete this; // mfe: AAARRRGGGHHH!!!
 303 }
 304
 305 OTimerManager* OTimerManager::getTimerManager()
 306 {
 307     OGuard Guard(&m_Access);
 308
 309     if (! m_pManager)
 310         new OTimerManager;
 311
 312     return (m_pManager);
 313 }
 314
 315 sal_Bool OTimerManager::registerTimer(OTimer* pTimer)
 316 {
 317     VOS_ASSERT(pTimer);
 318
 319     if ( pTimer == 0 )
 320     {
 321         return sal_False;
 322     }
 323
 324     OGuard Guard(&m_Lock);
 325
 326     // try to find one with equal or lower remaining time.
 327     OTimer** ppIter = &m_pHead;
 328
 329     while (*ppIter)
 330     {
 331         if (pTimer->expiresBefore(*ppIter))
 332         {
 333             // next element has higher remaining time,
 334             // => insert new timer before
 335             break;
 336         }
 337         ppIter= &((*ppIter)->m_pNext);
 338     }
 339
 340     // next element has higher remaining time,
 341     // => insert new timer before
 342     pTimer->m_pNext= *ppIter;
 343     *ppIter = pTimer;
 344
 345
 346     if (pTimer == m_pHead)
 347     {
 348         // it was inserted as new head
 349         // signal it to TimerManager Thread
 350         m_notEmpty.set();
 351     }
 352
 353     return sal_True;
 354 }
 355
 356 sal_Bool OTimerManager::unregisterTimer(OTimer* pTimer)
 357 {
 358     VOS_ASSERT(pTimer);
 359
 360     if ( pTimer == 0 )
 361     {
 362         return sal_False;
 363     }
 364
 365     // lock access
 366     OGuard Guard(&m_Lock);
 367
 368     OTimer** ppIter = &m_pHead;
 369
 370     while (*ppIter)
 371     {
 372         if (pTimer == (*ppIter))
 373         {
 374             // remove timer from list
 375             *ppIter = (*ppIter)->m_pNext;
 376             return sal_True;
 377         }
 378         ppIter= &((*ppIter)->m_pNext);
 379     }
 380
 381     return sal_False;
 382 }
 383
 384 sal_Bool OTimerManager::lookupTimer(const OTimer* pTimer)
 385 {
 386     VOS_ASSERT(pTimer);
 387
 388     if ( pTimer == 0 )
 389     {
 390         return sal_False;
 391     }
 392
 393     // lock access
 394     OGuard Guard(&m_Lock);
 395
 396     // check the list
 397     for (OTimer* pIter = m_pHead; pIter != 0; pIter= pIter->m_pNext)
 398     {
 399         if (pIter == pTimer)
 400         {
 401             return sal_True;
 402         }
 403     }
 404
 405     return sal_False;
 406 }
 407
 408 void OTimerManager::checkForTimeout()
 409 {
 410
 411     m_Lock.acquire();
 412
 413     if ( m_pHead == 0 )
 414     {
 415         m_Lock.release();
 416         return;
 417     }
 418
 419     OTimer* pTimer = m_pHead;
 420
 421     if (pTimer->isExpired())
 422     {
 423         // remove expired timer
 424         m_pHead = pTimer->m_pNext;
 425
 426         pTimer->acquire();
 427
 428         m_Lock.release();
 429
 430         pTimer->onShot();
 431
 432         // restart timer if specified
 433         if ( ! pTimer->m_RepeatDelta.isEmpty() )
 434         {
 435             TTimeValue Now;
 436
 437             osl_getSystemTime(&Now);
 438
 439             Now.Seconds += pTimer->m_RepeatDelta.Seconds;
 440             Now.Nanosec += pTimer->m_RepeatDelta.Nanosec;
 441
 442             pTimer->m_Expired = Now;
 443
 444             registerTimer(pTimer);
 445         }
 446         pTimer->release();
 447     }
 448     else
 449     {
 450         m_Lock.release();
 451     }
 452
 453
 454     return;
 455 }
 456
 457 void OTimerManager::run()
 458 {
 459     setPriority(TPriority_BelowNormal);
 460
 461     while (schedule())
 462     {
 463         TTimeValue              delay;
 464         TTimeValue*             pDelay=0;
 465
 466
 467         m_Lock.acquire();
 468
 469         if (m_pHead != 0)
 470         {
 471             delay = m_pHead->getRemainingTime();
 472             pDelay=&delay;
 473         }
 474         else
 475         {
 476             pDelay=0;
 477         }
 478
 479
 480         m_notEmpty.reset();
 481
 482         m_Lock.release();
 483
 484
 485         m_notEmpty.wait(pDelay);
 486
 487         checkForTimeout();
 488       }
 489
 490 }
 491
 492
 493 /////////////////////////////////////////////////////////////////////////////
 494 //
 495 // Timer manager cleanup
 496 //
 497
 498 // jbu:
 499 // The timer manager cleanup has been removed (no thread is killed anymore).
 500 // So the thread leaks.
 501 // This will result in a GPF in case the vos-library gets unloaded before
 502 // process termination.
 503 // -> TODO : rewrite this file, so that the timerManager thread gets destroyed,
 504 //           when there are no timers anymore !