ct_task.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 VECTIONEER.
 */
 
#ifndef CONTAINER_CT_TASK_H
#define CONTAINER_CT_TASK_H
 
#include "cmdline_task.h"
#include "ct_tasksched.h"
#include "ct_time.h"
#include "ps_parameter.h"
#include "utl_realtime.h"
#include <atomic>
#include <cstdint>
#include <pthread.h>
#include <string>
#include <vector>
 
namespace mcx::container {
 
class Module;
 
 
class Task {
public:
  Task(const char* name, parameter_server::Parameter* parent);
 
  virtual ~Task();
 
  Task() = delete;
 
  Task(Task& orig) = delete;
 
  Task& operator=(Task& orig) = delete;
 
  void setName(const char* name);
 
  const char* getName() const;
 
  bool running() const;
 
  void setStackSize(uint64_t size_bytes);
 
  uint64_t getStackSize() const;
 
  void add(Module* module);
 
  void add(const std::vector<Module*>& modules);
 
  void configure();
 
  void start(uint64_t cycle_time_micro_s, TaskSched task_sched, const std::vector<uint32_t>& cpu_affinity_list = {},
             uint32_t priority = 0);
 
  void start(cmd_line::Task);
 
  void stop();
 
  void setCycleTimeMicroS(uint64_t cycle_time_micro_s);
 
  uint64_t getCycleMicroS() const;
 
  double getCycleTimeS() const;
 
  uint64_t getNrOfCycles() const;
 
  bool setSchedPolicy(uint32_t policy);
 
  uint32_t getSchedPolicy() const;
 
  bool setSchedPriority(int priority);
 
  int getSchedPriority() const;
 
  bool setCpuAffinity(const std::vector<uint32_t>& cpu_affinity_list);
 
  const std::vector<uint32_t>& getCpuAffinity() const;
 
private:
  struct ModuleInfo {
    Module* module;
  };
 
  struct TimeStatistics {
    uint64_t actual;
    uint64_t max;
  };
 
  enum class State {
    OFF = 0,
    READY = 1,
    ON = 2,
  };
 
  timespec prepare(pthread_attr_t& gattr);
 
  void* run();
 
  static void* runHelper(void* context);
 
  struct timespec syncToIdealTime(struct timespec t_ideal);
 
  static inline void fillCycleTime(TimeStatistics* cycle_time, uint64_t time, uint64_t cycle);
 
  const char* policyToStr(uint32_t policy) const;
 
  std::atomic<State> state_{State::OFF};
  std::atomic<bool> is_running_{false};
  std::string task_name_{"Undefined"};
 
  struct timespec desired_cycle_time_ {};
  TimeStatistics actual_cycle_time_{};
 
  int32_t reset_absolute_max_time_micro_s_{};
  uint64_t absolute_max_time_micro_s_{};
  uint64_t desired_cycle_time_micro_s_{1000};
  std::atomic<uint64_t> nr_of_cycles_{};
  TimeStatistics utilization_percent_{};
 
  double secaligned_{0.1};
  int32_t startop_[2]{};
 
  std::vector<uint32_t> cpu_affinity_list_{};
  sched_param sched_priority_{};
  pthread_t task_thread_id_{};
  uint32_t sched_policy_{};
 
  uint64_t stack_size_{};
 
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif
  utils::PageFaults page_faults_{};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
 
  std::vector<ModuleInfo> modules_;
  parameter_server::Parameter local_branch_;
};
 
inline void Task::fillCycleTime(TimeStatistics* cycle_time, uint64_t time, uint64_t cycle) {
  cycle_time->actual = time;
  if (cycle == 0) {
    cycle_time->max = cycle_time->actual;
  } else {
    cycle_time->max = cycle_time->actual > cycle_time->max ? cycle_time->actual : cycle_time->max;
  }
}
 
} // namespace mcx::container
 
#endif // CONTAINER_CT_TASK_H