SystemClockCoroutine.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_SYSTEM_CLOCK_COROUTINE_H
#define ACE_TIME_SYSTEM_CLOCK_COROUTINE_H
 
// activate only if <AceRoutine.h> is included before this header
#ifdef ACE_ROUTINE_VERSION
 
#include <stdint.h>
#include <AceCommon.h> // TimingStats
#include <AceRoutine.h>
#include "SystemClock.h"
 
class SystemClockCoroutineTest;
class SystemClockCoroutineTest_runCoroutine;
 
namespace ace_time {
namespace clock {
 
template <typename T_SCCI, typename T_CRCI>
class SystemClockCoroutineTemplate :
    public SystemClockTemplate<T_SCCI>,
    public ace_routine::CoroutineTemplate<T_CRCI, uint16_t> {
 
  public:
    explicit SystemClockCoroutineTemplate(
        Clock* referenceClock /* nullable */,
        Clock* backupClock /* nullable */,
        uint16_t syncPeriodSeconds = 3600,
        uint16_t initialSyncPeriodSeconds = 5,
        uint16_t requestTimeoutMillis = 1000,
        ace_common::TimingStats* timingStats = nullptr):
      SystemClockTemplate<T_SCCI>(referenceClock, backupClock),
      ace_routine::CoroutineTemplate<T_CRCI, uint16_t>(),
      mSyncPeriodSeconds(syncPeriodSeconds),
      mRequestTimeoutMillis(requestTimeoutMillis),
      mTimingStats(timingStats),
      mCurrentSyncPeriodSeconds(initialSyncPeriodSeconds) {}
 
    int runCoroutine() override {
      this->keepAlive();
      if (this->getReferenceClock() == nullptr) return 0;
 
      uint32_t nowMillis = this->clockMillis();
 
      COROUTINE_LOOP() {
        // Send request
        this->getReferenceClock()->sendRequest();
        mRequestStartMillis = this->coroutineMillis();
        mRequestStatus = kStatusSent;
        this->setPrevSyncAttemptMillis(nowMillis);
        this->setNextSyncAttemptMillis(
            nowMillis + mCurrentSyncPeriodSeconds * (uint32_t) 1000);
 
        // Wait for request until mRequestTimeoutMillis.
        while (true) {
          if (this->getReferenceClock()->isResponseReady()) {
            mRequestStatus = kStatusOk;
            break;
          }
 
          {
            // Local variable waitMillis must be scoped with {} so that the
            // goto in COROUTINE_LOOP() skips past it. This seems to be
            // a problem only in clang++; g++ seems to be fine without it.
            uint16_t waitMillis =
                (uint16_t) this->coroutineMillis() - mRequestStartMillis;
            if (waitMillis >= mRequestTimeoutMillis) {
              mRequestStatus = kStatusTimedOut;
              this->setSyncStatusCode(this->kSyncStatusTimedOut);
              break;
            }
          }
 
          COROUTINE_YIELD();
        }
 
        // Process the response
        if (mRequestStatus == kStatusOk) {
          acetime_t nowSeconds = this->getReferenceClock()->readResponse();
          if (mTimingStats != nullptr) {
            uint16_t elapsedMillis =
                (uint16_t) this->coroutineMillis() - mRequestStartMillis;
            mTimingStats->update(elapsedMillis);
          }
 
          if (nowSeconds == this->kInvalidSeconds) {
            this->setSyncStatusCode(this->kSyncStatusError);
            // Clobber the mRequestStatus to trigger the exponential backoff
            mRequestStatus = kStatusUnknown;
          } else {
            this->syncNow(nowSeconds);
            mCurrentSyncPeriodSeconds = mSyncPeriodSeconds;
            this->setSyncStatusCode(this->kSyncStatusOk);
          }
        }
 
        // Wait for mCurrentSyncPeriodSeconds
        this->setNextSyncAttemptMillis(
            nowMillis + mCurrentSyncPeriodSeconds * (uint32_t) 1000);
        for (mWaitCount = 0;
            mWaitCount < mCurrentSyncPeriodSeconds;
            mWaitCount++
        ) {
          COROUTINE_DELAY(1000);
        }
 
        // Determine the retry delay time based on success or failure. If
        // failure, retry with exponential backoff, until the delay becomes
        // mSyncPeriodSeconds.
        if (mRequestStatus != kStatusOk) {
          if (mCurrentSyncPeriodSeconds >= mSyncPeriodSeconds / 2) {
            mCurrentSyncPeriodSeconds = mSyncPeriodSeconds;
          } else {
            mCurrentSyncPeriodSeconds *= 2;
          }
        }
      }
    }
 
    uint8_t getRequestStatus() const { return mRequestStatus; }
 
  protected:
    SystemClockCoroutineTemplate() {}
 
  private:
    friend class ::SystemClockCoroutineTest;
    friend class ::SystemClockCoroutineTest_runCoroutine;
 
    static const uint8_t kStatusUnknown = 0;
 
    static const uint8_t kStatusSent = 1;
 
    static const uint8_t kStatusOk = 2;
 
    static const uint8_t kStatusTimedOut = 3;
 
    // disable copy constructor and assignment operator
    SystemClockCoroutineTemplate(const SystemClockCoroutineTemplate&) = delete;
    SystemClockCoroutineTemplate& operator=(
        const SystemClockCoroutineTemplate&) = delete;
 
    uint16_t const mSyncPeriodSeconds = 3600;
    uint16_t const mRequestTimeoutMillis = 1000;
    ace_common::TimingStats* const mTimingStats = nullptr;
 
    uint16_t mRequestStartMillis; // lower 16-bit of millis()
    uint16_t mCurrentSyncPeriodSeconds = 5;
    uint16_t mWaitCount;
    uint8_t mRequestStatus = kStatusUnknown;
};
 
using SystemClockCoroutine = SystemClockCoroutineTemplate<
    hw::ClockInterface, ace_routine::ClockInterface
>;
 
}
}
 
#endif
 
#endif