periodic_task.h

/* Copyright 2018 Boon Thau Loo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef BM_BM_SIM_PERIODIC_TASK_H_
#define BM_BM_SIM_PERIODIC_TASK_H_
 
#include <string>
#include <vector>
#include <thread>
#include <atomic>
#include <queue>
#include <chrono>
#include <functional>
#include <condition_variable>
#include <mutex>
 
namespace bm {
 
class PeriodicTask {
 public:
  // Friend so that PeriodicTaskList can call execute()
  friend class PeriodicTaskList;
 
  PeriodicTask(const std::string &name,
               std::function<void()> fn,
               std::chrono::milliseconds interval);
  ~PeriodicTask();
 
  // Deleting copy-constructor and copy-assignment
  PeriodicTask(const PeriodicTask&) = delete;
  PeriodicTask& operator= (const PeriodicTask&) = delete;
  // Deleting move constructor and move assignment
  PeriodicTask(PeriodicTask&&) = delete;
  PeriodicTask& operator= (PeriodicTask&&) = delete;
 
  const std::string name;
  const std::chrono::milliseconds interval;
 
 private:
  void execute();
 
  void reset_next();
  void cancel();
 
  const std::function<void()> fn;
  std::chrono::system_clock::time_point next;
};
 
class PeriodicTaskList {
 public:
  static PeriodicTaskList &get_instance();
 
  // Returns true if task was successfully registered
  bool register_task(PeriodicTask *task);
  bool unregister_task(PeriodicTask *task);
 
  void start();
  void join();
 
 private:
  class PeriodCompare {
   public:
    bool
    operator() (const PeriodicTask *lhs, const PeriodicTask *rhs) {
      return lhs->next > rhs->next;
    }
  };
  using TaskQueue = std::priority_queue<PeriodicTask*,
                                        std::vector<PeriodicTask*>,
                                        PeriodCompare>;
 
  PeriodicTaskList() = default;
  ~PeriodicTaskList();
 
  void loop();
 
  // The queue of PeriodicTasks, ordered by next execution time
  TaskQueue task_queue;
 
  std::thread periodic_thread;
  bool running;
  mutable std::mutex queue_mutex;
  mutable std::condition_variable cv;
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_PERIODIC_TASK_H_