S3FC project page

S3FC home page

---

               

---

s3_periodic_notifier.cc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_periodic_notifier.h>
#include <s3fc/s3_exception.h>

#include <sstream>
#include <algorithm>
// WIN32 compatibility [rfanner]
#ifdef _WIN32
// Define NOMINMAX to prevent the definition of min and max macros in windef.h
#define NOMINMAX
#include <wtypes.h>
#include <winbase.h>
#endif

s3_periodic_notifier::event_loop* s3_periodic_notifier::ev_loop = 0;
s3_mutex s3_periodic_notifier::ev_loop_lock;

//
s3_periodic_notifier::event_loop::event_loop()
{
   // start myself
   start();
}

//
s3_periodic_notifier::event_loop::~event_loop()
{
   request_terminate();
   wait_on_exit();
   // deletion can now safely continue....
}

//
void s3_periodic_notifier::event_loop::add_client(s3_periodic_notifier* n_id)
{
   state_lock.lock();
   // test precondition - violation is internal error
   if ( is_client(n_id) )
   {
      state_lock.unlock();
      // client already here
      std::stringstream str;
      str << "Client [" << n_id << "] already in list";
      throw s3_generic_exception("s3_periodic_notifier::event_loop::"
             "add_client()", str.str());
   }
   // add to list with zero period
   client_list[n_id] = 0;
   state_lock.unlock();
}

//
void s3_periodic_notifier::event_loop::remove_client(s3_periodic_notifier* n_id)
{
   state_lock.lock();
   // test precondition - violation is internal error
   if ( ! is_client(n_id) )
   {
      state_lock.unlock();
      // client already here
      std::stringstream str;
      str << "Client [" << n_id << "] not in list";
      throw s3_generic_exception("s3_periodic_notifier::event_loop::"
             "remove_client()", str.str());
   }
   // remove from list
   client_list.erase(n_id);
   state_lock.unlock();
}

//
void s3_periodic_notifier::event_loop::set_period(s3_periodic_notifier* n_id,
                    const period_t& n_period)
{
   state_lock.lock();
   // test precondition - violation is internal error
   if ( ! is_client(n_id) )
   {
      state_lock.unlock();
      // client already here
      std::stringstream str;
      str << "Client [" << n_id << "] not in list";
      throw s3_generic_exception("s3_periodic_notifier::event_loop::"
             "set_period()", str.str());
   }
   // set the period
   client_list[n_id] = n_period;
   state_lock.unlock();
}

//
bool s3_periodic_notifier::event_loop::clients() const
{
   bool c;
   state_lock.lock();
   c = ( client_list.size() > 0 ) ;
   state_lock.unlock();
   return c;
}


//
bool s3_periodic_notifier::event_loop::is_client(s3_periodic_notifier* n_id)
{
   return (client_list.count(n_id) != 0);
}

//
void s3_periodic_notifier::event_loop::main_loop()
{
   // BIG NOTE: The slot_size_ms number may NEVER exceed 1000, i.e. a
   // maximum slot size of 1 second is enforced. This is due to the way
   // in which the timing calculations is performed in here. This again
   // is due to the non-linear representation of POSIX time (sec,nsec pair).
   // If this needs to be changed the part that calculates delta_ms would 
   // require some attention.

   // size of a timing interval (in milliseconds as we humans like ms)
   const int interval_size_ms = 100;
   // also in nanoseconds (as POSIX prefers ns)
   const int interval_size_ns = 1000000 * interval_size_ms;

   // interval counter - count the number of slot_size_ms intervals
   // each interval is aligned to the absolute system time base, as
   // reported by clock_gettime(CLOCK_REALTIME, ...).
   unsigned long interval_cnt = 0;
   // time until the start of the next interval timeslot,
   // aligned to system time
   long delta_ns;
#ifdef _WIN32
   // For Windows implementation [rfanner].
   // As the POSIX real-time functions clock_gettime and nanosleep
   // are not readily available in Windows, we use the GetTickCount
   // and Sleep functions supplied by Windows. Alternately, if the 
   // time precision turns out to be too low, one could turn to the
   // high precision time functions QueryPerformanceCounter and 
   // QueryPerformanceFrequency.

   // The output and input of GetTickCount and Sleep are of the type
   // DWORD, which is a 32-bit unsigned integer.
   // the time in milliseconds to sleep
   DWORD msecs_to_sleep = 0;
#else
   // For Linux implementation [rfanner].
   // need this for clock_gettime and nanosleep. these are POSIX 1003.1c-1995
   timespec ts;
#endif

   while(true)
   {
      if (test_terminate()) break;
#ifdef _WIN32
      // For Windows implementation [rfanner].
      // Determine when the next time interval must commence
      DWORD current_time = GetTickCount();
      // align with clock, and find the remaining milliseconds until the
      // next interval
      // Note that it does not matter if wrap-around of GetTickCount has 
      // occured, as the modulus provides a relative measure.
      msecs_to_sleep = interval_size_ms - (current_time % interval_size_ms);
      // sleep for the specified interval.
      Sleep(msecs_to_sleep);      
#else
      // get the time according to the RTC
      clock_gettime(CLOCK_REALTIME, &ts);
      // align our intervals with the RTC - calculate the remaining number
      // of nanoseconds until the start of the next interval
      delta_ns = interval_size_ns - (ts.tv_nsec % ( interval_size_ns ));

      // sleep for delta_ns
      ts.tv_sec = 0;
      ts.tv_nsec = delta_ns;
      nanosleep(&ts, 0);
#endif
      // increment interval counter
      interval_cnt++;
      
      // notify
      state_lock.lock();
      for (list_t::iterator ptr = client_list.begin();
      ptr != client_list.end();
      ptr++) 
      {
    // this client period
    period_t cp_ms = ptr->second;
    if ( cp_ms > 0 ) // zero period ignored
    {
       if ((cp_ms/interval_size_ms) == 0) // period too small - 
          // use minimum and verify every interval
       {
          ptr->first->notify();
       }
       // modulo safe as we checked for zero denominator
       else  if ((interval_cnt % (cp_ms/interval_size_ms)) == 0)
       {
          ptr->first->notify();
       }
    }
      }
      state_lock.unlock();
   }
}

//
s3_periodic_notifier::s3_periodic_notifier(period_t n_period_ms) :
   period_ms(n_period_ms),
   enabled(false)
{
   ev_loop_lock.lock();
   if ( ev_loop == 0 )
   {
      ev_loop = new event_loop();
   }
   ev_loop->add_client(this);
   ev_loop->set_period(this, n_period_ms);
   ev_loop_lock.unlock();
}


//
s3_periodic_notifier::~s3_periodic_notifier()
{
   ev_loop_lock.lock();
   ev_loop->remove_client(this);
   // if i am the last one to leave take ev_loop with me
   if  (! ev_loop->clients())
   {
      delete ev_loop;
      ev_loop = 0;
   }
   ev_loop_lock.unlock();
}

//
void s3_periodic_notifier::enable()
{
   state_lock.lock();
   enabled = true;
   state_lock.unlock();
}

//
void s3_periodic_notifier::disable()
{
   state_lock.lock();
   enabled = false;
   state_lock.unlock();
}

//
void s3_periodic_notifier::set_period(period_t n_period_ms)
{
   state_lock.lock();
   period_ms = n_period_ms;
   ev_loop->set_period(this, n_period_ms);
   state_lock.unlock();
}

//
void s3_periodic_notifier::subscribe(s3_semaphore& sem)
{
   state_lock.lock();

   // check precondition (sem already subscribed) and throw if violation
   if ( is_subscribed(sem) )
   {
      state_lock.unlock();
      // alreay in list
      std::stringstream str;
      str << "Semaphore at [" << &sem << "] already subscribed";
      throw s3_generic_exception("s3_periodic_notifier::subscribe()",
             str.str());
   }
   notification_list.push_back(&sem);
   state_lock.unlock();
}

//
void s3_periodic_notifier::unsubscribe(s3_semaphore& sem)
{
   state_lock.lock();

   // check precondition (sem already subscribed) and throw if violation
   if ( ! is_subscribed(sem) )
   {
      state_lock.unlock();
      // not in list
      std::stringstream str;
      str << "Semaphore at [" << &sem << "] not subscribed";
      throw s3_generic_exception("s3_periodic_notifier::unsubscribe()",
             str.str());
   }
   notification_list.erase(std::find(notification_list.begin(), 
                 notification_list.end(), 
                 &sem));
   state_lock.unlock();
}

//
void s3_periodic_notifier::notify()
{
   state_lock.lock();
   // do nothing if we're not currently enabled
   if ( enabled )
   {
      for (std::list<s3_semaphore*>::iterator ptr = notification_list.begin();
      ptr != notification_list.end();
      ptr++)
      {
    (*ptr)->post();
      }
   }
   state_lock.unlock();
}

//
bool s3_periodic_notifier::is_subscribed(s3_semaphore& sem){
   return ( std::find(notification_list.begin(), 
            notification_list.end(), 
            &sem) != notification_list.end() );
}

---

Send comments to: s3fc@stonethree.com