rttask.h

#pragma once
 
#ifndef RTTASK_H
#define RTTASK_H
 
#include <atomic>         // for std::atomic
#include <cstdint>        // for int32_t, int64_t
#include <cstddef>        // for size_t
#include <cstdio>         // for std::snprintf
#include <cstring>        // for std::memset
#include <limits>         // for std::numeric_limits
#include <stdexcept>      // for std::invalid_argument
 
#if defined(WIN32)
#undef max
#endif // defined(WIN32)
 
#if !defined(RSI_INTERNAL)
#include "rsi.h"
#endif // defined(RSI_INTERNAL)
 
#define RSI_GLOBAL(type, name) \
  static_assert(sizeof(std::atomic<type>) == sizeof(type), "Expected size of "#type" to be equal to std::atomic<"#type">."); \
  alignas(uint64_t) std::atomic<type> name
 
#define REGISTER_GLOBAL(name) \
  { #name, offsetof(GlobalData, name), sizeof(GlobalData::name), RSIDataTypeGet<decltype(GlobalData::name.load())>::type }
 
namespace RSI
{
namespace RapidCode
{
namespace RealTimeTasks
{
  // Forward declaration of User's custom-defined structure of global data.
  struct GlobalData;
  
  class RTTaskImplementation;
  class RTTaskManagerImplementation;
 
 
  inline constexpr int32_t RTTaskManagerCountMaximum = 8;
  inline constexpr int32_t RTTaskCountMaximum = 64;
  inline constexpr char RTTaskManagerExecutableName[] = "rttaskmanager";
 
 
  enum class RTTaskState : int32_t
  {
    Dead            = 0, 
    Disabled        = 1, 
    Waiting         = 2, 
    Running         = 3, 
  };
 
  enum class RTTaskManagerState : int32_t
  {
    Dead = 0,    
    Running = 1, 
    Stopped = 2, 
  };
 
  enum class PlatformType : int32_t
  {
    Native    = 0, 
    INtime    = 1, 
    Linux     = 2, 
    Windows   = 3, 
  };
 
  enum class TaskPriority : int32_t
  {
    NonRealTime = 0,  
    Lowest,           
    Low,              
    MediumLow,        
    Medium,           
    MediumHigh,       
    High,             
    Highest           
  };
 
 
 
  // Function pointer type for real-time task functions.
  using TaskFunction = int32_t(*)(GlobalData*, char*, const uint32_t);
 
  struct RTTaskCreationParameters
  {
    static constexpr int32_t DirectoryLengthMaximum = 256;
 
    static constexpr int32_t NameLengthMaximum = 64;
 
    static constexpr const char* const LibraryNameDefault = "RTTaskFunctions";
    
    static constexpr TaskPriority PriorityDefault = TaskPriority::Medium;
 
    static constexpr int32_t RepeatForever = -1;
    
    static constexpr int32_t RepeatNone = 0;
 
    static constexpr int32_t PeriodDefault = 1;
    
    static constexpr int32_t PhaseDefault = 0;
 
    static constexpr bool EnableTimingDefault = false;
 
    char FunctionName[NameLengthMaximum] = {0};
    
    char LibraryName[NameLengthMaximum] = "RTTaskFunctions";
    
    char LibraryDirectory[DirectoryLengthMaximum] = {0};
    
    char UserLabel[NameLengthMaximum] = {0};
 
    TaskPriority Priority = PriorityDefault;
    
    int32_t Repeats = RepeatNone;
 
    int32_t Period = PeriodDefault;
 
    int32_t Phase = PhaseDefault;
 
    bool EnableTiming = EnableTimingDefault;
 
    // Default constructor.
    RTTaskCreationParameters() = default;
    
    RTTaskCreationParameters(const char* const argFunctionName, const char* const argLibraryName = nullptr, const char* const argLibraryDirectory = nullptr)
      : Priority(PriorityDefault)
      , Repeats(RepeatNone)
      , Period(PeriodDefault)
      , Phase(PhaseDefault)
      , EnableTiming(EnableTimingDefault)
    {
      if (argFunctionName == nullptr)
      {
        throw std::invalid_argument("Task function name must not be null.");
      }
      std::snprintf(FunctionName, NameLengthMaximum, "%s", argFunctionName);
 
      if (argLibraryName != nullptr)
      {
        std::snprintf(LibraryName, NameLengthMaximum, "%s", argLibraryName);
      }
      else
      {
        std::snprintf(LibraryName, NameLengthMaximum, "%s", LibraryNameDefault);
      }
      
      if (argLibraryDirectory != nullptr)
      {
        std::snprintf(LibraryDirectory, DirectoryLengthMaximum, "%s", argLibraryDirectory);
      }
      else
      {
        std::memset(LibraryDirectory, 0, DirectoryLengthMaximum);
      }
    }
  };
 
  struct RTTaskInfo
  {
    RTTaskCreationParameters CreationParameters;
  };
 
  struct RTTaskStatus
  {
    RTTaskState State = RTTaskState::Dead;
    
    int64_t ExecutionCount = InvalidExecutionCount;
    
    uint64_t ExecutionTimeMax = InvalidExecutionTime;
    
    uint64_t ExecutionTimeMin = std::numeric_limits<uint64_t>::max();
    
    double ExecutionTimeMean = InvalidExecutionTime;
    
    uint64_t ExecutionTimeLast = InvalidExecutionTime;
 
    uint64_t StartTimeDeltaLast = InvalidExecutionTime;
 
    uint64_t StartTimeDeltaMax = InvalidExecutionTime;
 
    double StartTimeDeltaMean = InvalidExecutionTime;
 
    RTTaskStatus() = default;
    
    static constexpr int64_t InvalidExecutionCount = -1;
    
    static constexpr uint64_t InvalidExecutionTime = 0;
 
    static constexpr uint64_t ErrorMessageSizeMaximum = 512;
    char ErrorMessage[ErrorMessageSizeMaximum] = {};
  };
 
  struct RTTaskManagerStatus
  {
    RTTaskManagerState State;
    
    uint64_t TaskSubmissionCount;
    
    int64_t CycleCount;
    
    uint64_t CycleTimeMax;
    
    uint64_t CycleTimeMin;
    
    double CycleTimeMean;
    
    uint64_t CycleTimeLast;
 
    uint64_t StartTimeDeltaLast = 0;
 
    uint64_t StartTimeDeltaMax = 0;
 
    double StartTimeDeltaMean = 0;
  };
 
  struct RTTaskManagerCreationParameters
  {
    static constexpr int32_t DirectoryLengthMaximum = 256;
    
    static constexpr int32_t NameLengthMaximum = 64;
 
    char RTTaskDirectory[DirectoryLengthMaximum] = {0};
    
    PlatformType Platform = PlatformType::Native;
    
    char NodeName[NameLengthMaximum] = {0};
    
    int32_t CpuCore = -1;
    
    char UserLabel[NameLengthMaximum] = {0};
 
    bool NoRmp = false;
  };
 
  struct RTTaskManagerInfo
  {
    RTTaskManagerCreationParameters CreationParameters;
    
    int32_t Id;
  };
 
  typedef int32_t (*GlobalMemberOffsetGetter)(const char* const name);
  typedef int32_t (*GlobalNamesGetter)(const char* names[], int32_t capacity);
  typedef int32_t (*GlobalMemberTypeGetter)(const char* const name);
 
  inline constexpr int32_t GlobalMaxSize = 2048;
 
#if !defined(RSI_INTERNAL)
#if !defined(__INTIME__)
 
  class RSI_API RapidCodeBehavior : public virtual RapidCodeObject
  {
  public:
    const char* const VersionGet() override;
    int32_t MpiVersionMajor() override;
    int32_t MpiVersionMinor() override;
    int32_t MpiVersionRelease() override;
    int32_t RSIVersionMajor() override;
    int32_t RSIVersionMinor() override;
    int32_t RSIVersionMicro() override;
    int32_t RSIVersionPatch() override;
    int32_t NumberGet() override;
    int32_t ErrorLogCountGet() override;
    const RsiError* const ErrorLogGet() override;
    void ErrorLogClear() override;
    void ThrowExceptions(bool state) override;
    const char* const RsiErrorMessageGet(RSIErrorMessage msg) override;
    const char* const ErrorMessageGet(RSIErrorMessage msg) override;
    bool WarningMsgCheck(RSIErrorMessage msg) override;
    void Trace(bool state) override;
    void TraceMaskOnSet(RSITrace maskOn) override;
    bool TraceMaskOnGet(RSITrace maskOn) override;
    void TraceMaskOffSet(RSITrace maskOff) override;
    void TraceMaskClear() override;
    void TraceFileSet(const char* const fileName) override;
    void TraceFileClose() override;
    void TraceInjectMessage(RSITrace traceLevel, const char* const message) override;
 
    virtual ~RapidCodeBehavior();
    RapidCodeBehavior(const RapidCodeBehavior&);
    RapidCodeBehavior& operator=(const RapidCodeBehavior&);
    RapidCodeBehavior(RapidCodeBehavior&&);
    RapidCodeBehavior& operator=(RapidCodeBehavior&&);
 
    class Implementation;
  protected:
    Implementation* rapidCodeBehavior = nullptr;
    RapidCodeBehavior(Implementation*);
  };
 
 
  class RSI_API RTTask : public virtual RapidCodeBehavior
  {
  public:
 
    void Stop();
    
    void TimingReset();
 
 
    RTTaskStatus StatusGet();
 
    int64_t ExecutionCountAbsoluteWait(int64_t count = ExecutionCountDefault, int32_t timeoutMs = ExecutionCountWaitTimeoutMillisecondsDefault);
    
    int64_t ExecutionCountRelativeWait(int64_t count = ExecutionCountDefault, int32_t timeoutMs = ExecutionCountWaitTimeoutMillisecondsDefault);
 
 
    int32_t IdGet();
    
    RTTaskInfo InfoGet();
 
 
    static constexpr int64_t ExecutionCountWaitFailure = -1;
    static constexpr int64_t ExecutionCountDefault = 1;
    static constexpr int32_t ExecutionCountWaitTimeoutMillisecondsDefault = 250;
 
    ~RTTask();
    RTTask(const RTTask&);
    RTTask& operator=(const RTTask&);
    RTTask(RTTask&&);
    RTTask& operator=(RTTask&&);
 
  protected:
    RTTaskImplementation* pImpl = nullptr;
    RTTask(RTTaskImplementation*, RapidCodeBehavior::Implementation*);
    friend class RTTaskBuilder;
  }; // end class RTTask
 
  class RSI_API RTTaskManager : public virtual RapidCodeBehavior
  {
  public:
        
    static RapidVector<RTTaskManager> Discover();
 
    static RTTaskManager Get(const int32_t managerId);
    
    static RTTaskManager Create(const RTTaskManagerCreationParameters& parameters);
 
 
    virtual RapidVector<const char*> GlobalNamesGet(const char* const libraryName = nullptr, const char* const libraryDirectory = nullptr);
    
    virtual RSI::RapidCode::FirmwareValue GlobalValueGet(int32_t offset);
    
    virtual RSI::RapidCode::FirmwareValue GlobalValueGet(const char* const name, const char* const libraryName = nullptr, const char* const libraryDirectory = nullptr);
 
    virtual void GlobalValueSet(const RSI::RapidCode::FirmwareValue& value, const char* const name, const char* const libraryName = nullptr, const char* const libraryDirectory = nullptr);
 
    virtual RSI::RapidCode::RSIDataType GlobalTypeGet(const char* const name, const char* const libraryName = nullptr, const char* const libraryDirectory = nullptr);
    
 
 
    virtual RTTask TaskSubmit(const RTTaskCreationParameters& parameters);
    
    virtual RTTask TaskSubmit(const char* const functionName, const char* const libraryName = RTTaskCreationParameters::LibraryNameDefault, const char* const libraryDirectory = nullptr);
    
    virtual void Shutdown();
 
 
 
    virtual RapidVector<RTTask> TasksGet();
 
    virtual RTTaskManagerStatus StatusGet();
 
 
 
    virtual RTTaskManagerInfo InfoGet();
 
    virtual int32_t IdGet();
 
    virtual void TaskRemove(const int32_t taskId);
 
    virtual ~RTTaskManager();
 
    RTTaskManager(const RTTaskManager&);
    RTTaskManager& operator=(const RTTaskManager&);
    RTTaskManager(RTTaskManager&&);
    RTTaskManager& operator=(RTTaskManager&&);
 
    class Storage;
  protected:
    RTTaskManagerImplementation* pImpl = nullptr;
    Storage* storage = nullptr;
    RTTaskManager(RTTaskManagerImplementation*, Storage* storage, RapidCodeBehavior::Implementation*);
    friend class RTTaskManagerBuilder;
    // friend RTTaskManager MakeRTTaskManager(RTTaskManagerImplementation*, RapidCodeBehavior::Implementation*);
    // friend RTTaskManager MakeRTTaskManager(RTTaskManagerImplementation*);
  }; // end class RTTaskManager
 
#endif // !defined(__INTIME__)
  
  template <int32_t Capacity>
  class GlobalMetadataMap {
  public:
    struct Metadata
    {
      const char* key;
      
      int32_t offset;
      
      int32_t size;
  
      // const std::type_info* type;
      RSI::RapidCode::RSIDataType type;
    };
    
    constexpr GlobalMetadataMap() : data(), tail(0) {}
    
    constexpr GlobalMetadataMap(std::initializer_list<Metadata> initData)
    {
      for (const auto& item : initData)
      {
        data[tail++] = item;
      }
    }
  
    constexpr int32_t Size() const { return tail; }
  
    constexpr Metadata operator[](int32_t index) const { return data[index]; }
    
    constexpr Metadata operator[](const char* key) const
    {
      for (int32_t index = 0; index < tail; ++index)
      {
        auto& metadata = data[index];
        if (std::strcmp(metadata.key, key)==0)
        {
          return metadata;
        }
      }
      constexpr char errorMessageFormat[] = "Key '%s' not found in GlobalMetadata.";
      constexpr int32_t bufferSize = 256;
      char buffer[bufferSize] = {0};
      std::snprintf(buffer, bufferSize, errorMessageFormat, key);
      throw std::out_of_range(buffer);
    }
  
  private:
    Metadata data[Capacity]{};
    int32_t tail = 0;
  };
 
#if !defined(SWIG)
  // Primary template for parsing the type of a global variable.
  template<typename Type, typename = void>
  struct RSIDataTypeGet { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeINVALID; };
  template<typename Type>
  struct RSIDataTypeGet<Type, typename std::enable_if<std::is_integral<Type>::value && std::is_signed<Type>::value , void>::type>
  { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeINT64; };
  template<typename Type>
  struct RSIDataTypeGet<Type, typename std::enable_if<std::is_integral<Type>::value && std::is_unsigned<Type>::value , void>::type>
  { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeUINT64; };
  template<typename Type>
  struct RSIDataTypeGet<Type, typename std::enable_if<std::is_floating_point<Type>::value, void>::type>
  { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeDOUBLE; };
  template<>
  struct RSIDataTypeGet<int16_t> { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeINT16; };
  template<>
  struct RSIDataTypeGet<uint16_t> { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeUINT16; };
  template<>
  struct RSIDataTypeGet<int32_t> { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeINT32; };
  template<>
  struct RSIDataTypeGet<uint32_t> { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeUINT32; };
  template<>
  struct RSIDataTypeGet<float> { static constexpr RSI::RapidCode::RSIDataType type = RSIDataType::RSIDataTypeFLOAT; };
#endif // !defined(SWIG)
 
#endif // !defined(RSI_INTERNAL)
 
 
} // end namespace RealTimeTasks
} // end namespace RapidCode
} // end namespace RSI
 
#endif // !defined(RTTASK_H)