PeerStreamer

#include "timer.h"

#include <signal.h>

#include <iostream>

#include <queue>

#include <functional>

struct TimerLess {

  bool operator()(Timer *& left, Timer *& right) const

  {

    // a Timer has less priority if it's expiry time is bigger

    struct timeval a = left->getExpiry();

    struct timeval b = right->getExpiry();

    return timercmp(&a, &b, >); 

  }

};

typedef std::priority_queue<Timer *, std::vector<Timer *>, struct TimerLess> TimerQueue; 

static TimerQueue timerQueue;

static struct timeval earliestTime;

static void maskTimer()

{

  sigset_t set;

  sigemptyset(&set);

  sigaddset(&set, SIGALRM);

  sigprocmask(SIG_BLOCK, &set, NULL);

}

static void unmaskTimer()

{

  sigset_t set;

  sigemptyset(&set);

  sigaddset(&set, SIGALRM);

  sigprocmask(SIG_UNBLOCK, &set, NULL);

}

void calcInterval(const struct timeval &future, struct timeval &interval)

{

  struct timeval now;

  gettimeofday(&now, 0);

  interval.tv_sec = future.tv_sec - now.tv_sec;

  interval.tv_usec = future.tv_usec - now.tv_usec;

  if (interval.tv_usec < 0) {

    interval.tv_usec += 1000000;

    interval.tv_sec--;

  }

}

static void fireTimers()

{

  struct timeval now;

  gettimeofday(&now, 0);

  while (!timerQueue.empty()) {

    Timer *top = timerQueue.top();

    struct timeval expiry = top->getExpiry();

    if (timercmp(&now, &expiry, >=)) {

      timerQueue.pop();

      top->fire();

    }

    else

      break;

  }

}

static void setTimer()

{

  // Must be called with an timer in the timerQueue

  Timer *top = timerQueue.top();

  struct timeval expiry = top->getExpiry();

  struct timeval interval;

  calcInterval(expiry, interval);

  if (interval.tv_sec < 0) {

    interval.tv_sec = 0;

    fireTimers();

    return;

  }

  earliestTime = expiry;

  // Single shot timer

  struct itimerval it;

  it.it_interval.tv_sec = 0;

  it.it_interval.tv_usec = 0;

  it.it_value = interval;

  std::cout << "Setting up itimer\n";

  setitimer(ITIMER_REAL, &it, 0);

}

static void handleAlarmSig(int sig)

{

  std::cout << "Got alarm signal\n";

  // Alarm signal is masked already

  fireTimers();

  if (!timerQueue.empty())

    setTimer();

}

static struct SetupSignalHandler {

  SetupSignalHandler()

  {

    std::cout << "Setting up signal handler\n";

    struct sigaction act;

    act.sa_handler = handleAlarmSig;

    sigemptyset(&act.sa_mask);

    sigaddset(&act.sa_mask, SIGALRM);

    act.sa_flags = 0;

    sigaction(SIGALRM, &act, 0);

  }

} setupSignalHandler;

void Timer::start()

{

  // Calculate expiry time

  gettimeofday(&expiry, 0);

  expiry.tv_usec += delayMs * 1000;

  expiry.tv_sec += expiry.tv_usec % 1000000;

  expiry.tv_usec %= 1000000;

  // Add the timer to the queue

  maskTimer();

  timerQueue.push(this);

  setTimer();

  unmaskTimer();

}

void Timer::fire()

{

  callback(arg);

}

void Timer::stop()

{

  maskTimer();

  TimerQueue copy = timerQueue;

  while (!timerQueue.empty())

    timerQueue.pop();

  while (!copy.empty()) {

    Timer *top = copy.top();

    copy.pop();

    if (top != this)

      timerQueue.push(top);

  }

  unmaskTimer();

}