Teensy 3.1 - Any way to show CPU speed on my OLED?

class ExponentialFilter
{
  public:
    // the constructor takes one argument: the alpha value
    ExponentialFilter(double alpha)
      : alpha_(alpha),
      beta_(1 - alpha_)
    { }
    // feed a value into the filter and update the filtered value
    void feed(double sample)
    {
      value_ = alpha_*sample + beta_*value_;
    }
    // get filtered value
    double get() const
    {
      return value_;
    }
    // additional function-like access
    double operator()() const
    {
      return get();
    }
  private:
    const double alpha_;
    const double beta_;
    double value_;
};

class AbstractModule
{
  public:
    AbstractModule()
    {
      // add to list of modules
      prepend(this);
    }

    /** do whatever is necessary to update this module
      \return true if the module had work to do, false if the module remained idle
     **/
    virtual bool update() = 0;

    /** Update all modules **/
    static bool updateAll()
    {
      static ExponentialFilter filter(0.01); // smothen the cpu usage value
      static uint32_t idleTime = 0; // used to measure idle time

      bool busy = false; // this is true if *any* module was busy in the loop

      auto p = modules_();
      elapsedMicros loopTime; // how long did we need to ask / execute all modules

      // loop through modules and ask / execute
      while(p != nullptr)
      {
        if (p->update())
        {
          busy = true;
        }
        p = p->next();
      }
      if (busy) // some module was busy, to regard the loop time as busy time
      {
        uint32_t busyTime_ = loopTime;
        double cpuUsage = (double)busyTime_/(busyTime_ + idleTime);
        idleTime = 0;
        filter.feed(cpuUsage);
        Serial.printf("cpu usage: %5.3f\r", filter.get());
      }
      else // no module was busy, add loop time to idle time
      {
        idleTime += loopTime;
      }

      return busy;
    }

  protected:
    virtual ~AbstractModule() {}

  private:
    /** prepend a module to the list of registered modules **/
    static void prepend(AbstractModule* module)
    {
      module->next_ = modules_();
      modules_() = module;
    }

    /** Don't allow copy construction **/
    AbstractModule(const AbstractModule& other);

    /** Don't allow copy assignment **/
    AbstractModule& operator=(const AbstractModule& other);

    /** get pointer to list of modules **/
    static AbstractModule*& modules_()
    {
      static AbstractModule* p = nullptr;
      return p;
    }

    /** get next module in list **/
    AbstractModule* next() {return next_;}

    /** pointer to next module (intrusive linked list) **/
    AbstractModule* next_;

};

template <uint8_t pin>
class Blink: public AbstractModule
{
  public:
    Blink(uint16_t period)
      : period_(period)
    {
      pinMode(pin, OUTPUT);
    }
    bool update() override
    {
      if (timer_ < period_)
      {
        return false;
      }
      timer_ -= period_;
      digitalWriteFast(pin, !digitalReadFast(pin));
//      delay(50); // <-- uncomment to turn this into a CPU hog
      return true;
    }
  private:
    elapsedMillis timer_;
    uint16_t period_;
};

void setup()
{
  static Blink<LED_BUILTIN> ledBlinker(200);
  static Blink<10> otherBlinker(300);
}
void loop()
{
  AbstractModule::updateAll();
}