print-rttasks-summary.cpp

#include <thread>
#include <chrono>
#include <csignal>
#include <atomic>
#include <iostream>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
#include <memory>
 
#include "helpers.h"          // import our helper functions.
#include "config.h"           // import our configuration.
#include "rsi.h"              // import our RapidCode Library.
#include "rttask.h"           // import the RTTask library
 
using namespace RSI::RapidCode; // Import the RapidCode namespace
using namespace RSI::RapidCode::RealTimeTasks; // Import the RealTimeTasks namespace
 
/* CONSTANTS - Use these to customize the output */
constexpr bool LOOP_FOREVER = false; // If false, it will only run once
constexpr int64_t LOOP_PERIOD_MS = 1000;
 
constexpr bool PRINT_DETAILED_INFO = true;
constexpr bool PRINT_TIMING_METRICS = true;
 
constexpr int32_t SEPARATOR_LENGTH = 80; // Length of the separator lines in the output
 
// setup signal handler for Ctrl+C
std::atomic<bool> stopRequested(false);
void SignalHandler(int signal)
{
  if (signal == SIGINT)
  {
    stopRequested.store(true);
  }
}
 
// helpers for converting RapidCode types to STL types
template<typename T>
std::vector<T> ConvertToSTLVector(const RapidVector<T>& src) {
  std::vector<T> dst;
  dst.reserve(src.Size());
  for (auto& p : src) dst.emplace_back(std::move(p));
  return dst;
}
 
std::vector<std::string> ConvertToSTLVector(const RapidVector<const char*>& src) {
    std::vector<std::string> dst;
    dst.reserve(src.Size());
    for (const char* p : src) {
        dst.emplace_back(std::string(p));
    }
    return dst;
}
 
// helper functions for converting RapidCode enums to strings
std::string ToString(const RTTaskState& state)
{
  switch (state)
  {
    case RTTaskState::Dead: return "Dead";
    case RTTaskState::Disabled: return "Disabled";
    case RTTaskState::Waiting: return "Waiting";
    case RTTaskState::Running: return "Running";
    default: return "Unknown State";
  }
}
 
std::string ToString(const RTTaskManagerState& state)
{
  switch (state)
  {
    case RTTaskManagerState::Dead: return "Dead";
    case RTTaskManagerState::Running: return "Running";
    case RTTaskManagerState::Stopped: return "Stopped";
    default: return "Unknown State";
  }
}
 
std::string ToString(const PlatformType& platformType)
{
  switch (platformType)
  {
    case PlatformType::Native: return "Native";
    case PlatformType::INtime: return "INtime";
    case PlatformType::Linux: return "Linux";
    case PlatformType::Windows: return "Windows";
    default: return "Unknown Platform";
  }
}
 
std::string FormatUserLabel(std::string_view userLabel, std::string_view autoGenerated = "")
{
  if (userLabel.empty() || (!autoGenerated.empty() && userLabel == autoGenerated))
    return std::string();
  return std::string(userLabel) + " ";
}
 
void AppendTaskSummary(std::ostream& os, RTTask& task)
{
  const RTTaskInfo& taskInfo = task.InfoGet();
  const RTTaskStatus& taskStatus = task.StatusGet();
  const RTTaskCreationParameters& taskParams = taskInfo.CreationParameters;
 
  // Basic task information
  std::string userLabel = FormatUserLabel(taskParams.UserLabel);
  std::string executionCount = 
    taskStatus.ExecutionCount == RTTaskStatus::InvalidExecutionCount ?
     "N/A" : std::to_string(taskStatus.ExecutionCount);
  
  os << "  Task " << userLabel
              << "(ID: " << task.IdGet() << ")"
              << " - State: " << ToString(taskStatus.State)
              << " [Execution Count: " << executionCount << "]\n";
  
  // Task creation parameters
  if (PRINT_DETAILED_INFO)
  {
    os << "    Function: " << taskParams.FunctionName << "\n";
 
    if (taskParams.LibraryName != nullptr && taskParams.LibraryName[0] != '\0')
    {
      os << "    Library: " << taskParams.LibraryName << "\n";
    }
  
    if (taskParams.LibraryDirectory != nullptr && taskParams.LibraryDirectory[0] != '\0')
    {
      os << "    Library Directory: " << taskParams.LibraryDirectory << "\n";
    }
  
    os << "    Priority: " << static_cast<int32_t>(taskParams.Priority) << "\n";
  
    auto repeatsOrForever = [](int64_t repeats) { return repeats == RTTaskCreationParameters::RepeatForever ? "Forever" : std::to_string(repeats); };
    os << "    Repeats: " << repeatsOrForever(taskParams.Repeats) << "\n";
    os << "    Period: " << taskParams.Period << " samples\n";
    os << "    Phase: " << taskParams.Phase << " samples\n";
  }
 
  // timing information
  if (PRINT_TIMING_METRICS)
  {
    if (taskParams.EnableTiming)
    {
      auto timeOrInvalid = [](uint64_t time) { return time == RTTaskStatus::InvalidExecutionTime ? "N/A" : std::to_string(time); };
      os << "    Execution Time: " << timeOrInvalid(taskStatus.ExecutionTimeLast) << " ns\n";
      os << "    Max Execution Time: " << timeOrInvalid(taskStatus.ExecutionTimeMax) << " ns\n";
      os << "    Min Execution Time: " << timeOrInvalid(taskStatus.ExecutionTimeMin) << " ns\n";
      os << "    Mean Execution Time: " << timeOrInvalid(taskStatus.ExecutionTimeMean) << " ns\n";
    }
    else
    {
      os << "    Timing: Disabled\n";
    }
  }
}
 
void AppendTaskManagerSummary(std::ostream& os, RTTaskManager& taskManager)
{
  const RTTaskManagerInfo& taskManagerInfo = taskManager.InfoGet();
  const RTTaskManagerStatus& taskManagerStatus = taskManager.StatusGet();
  const RTTaskManagerCreationParameters& taskManagerParams = taskManagerInfo.CreationParameters;
 
  os << std::string(SEPARATOR_LENGTH, '-') << "\n";
 
  // Task manager information
  std::string autoGeneratedLabel = "TaskManager_" + std::to_string(taskManager.IdGet());
  std::string managerLabel = FormatUserLabel(taskManagerParams.UserLabel, autoGeneratedLabel);
 
  os << "Task Manager " << managerLabel
                    << "(ID: " << taskManager.IdGet() << ")"
                    << " - State: " << ToString(taskManagerStatus.State)
                    << " [Cycle Count: " << taskManagerStatus.CycleCount << "]\n";
 
  // Task manager creation parameters
  if (PRINT_DETAILED_INFO)
  {
    os << "Platform: " << ToString(taskManagerParams.Platform);
    if (taskManagerParams.Platform == PlatformType::INtime)
    {
      os << " - " << taskManagerParams.NodeName;
    }
    else if (taskManagerParams.Platform == PlatformType::Linux || taskManagerParams.Platform == PlatformType::Windows)
    {
      if (taskManagerParams.CpuCore != -1)
      {
        os << " - CPU Core: " << taskManagerParams.CpuCore;
      }
    }
    os << "\n";
  
    if (taskManagerParams.RTTaskDirectory != nullptr && taskManagerParams.RTTaskDirectory[0] != '\0')
    {
      os << "RTTask Directory: " << taskManagerParams.RTTaskDirectory << "\n";
    }
  }
 
  // Task manager status information
  if (PRINT_TIMING_METRICS)
  {
    os << "Cycle Time Mean: " << taskManagerStatus.CycleTimeMean << " ns\n";
    os << "Cycle Time Last: " << taskManagerStatus.CycleTimeLast << " ns\n";
    os << "Cycle Time Max: " << taskManagerStatus.CycleTimeMax << " ns\n";
    os << "Cycle Time Min: " << taskManagerStatus.CycleTimeMin << " ns\n";
  }
 
  // Task summary information
  std::vector<RTTask> tasks = ConvertToSTLVector(taskManager.TasksGet());
 
  // Format the count of tasks
  if (taskManagerStatus.TaskSubmissionCount != 0)
  {
    os << "\nTasks submitted: " << taskManagerStatus.TaskSubmissionCount;
    if (tasks.size() != 0)
    {
      os << ", Current tasks: " << tasks.size();
    }
    os << "\n";
  }
 
  // add the info about each task to the string
  for (auto& task : tasks)
  {
    AppendTaskSummary(os, task);
  }
}
 
void AppendGlobalTagSummary(std::ostream& os, const std::shared_ptr<RTTaskManager>& taskManager)
{
  std::vector<std::string> globalTagNames = ConvertToSTLVector(taskManager->GlobalNamesGet());
 
  os << "Global Tags Count: " << globalTagNames.size() << "\n";
  for (const auto& tagName : globalTagNames)
  {
    RSI::RapidCode::FirmwareValue tag = taskManager->GlobalValueGet(tagName.c_str());
    os << "  " << tagName << ": " << tag.UInt64 << "\n";
  }
}
 
int main()
{
  // Print a start message to indicate that the sample app has started
  const std::string SAMPLE_APP_NAME = "📜 Utilities: Print Real-Time Tasks Summary";  
  Helpers::PrintHeader(SAMPLE_APP_NAME);
 
  // register the signal handler for Ctrl+C
  std::signal(SIGINT, SignalHandler);
 
  // set the exit code to an error value.
  int exitCode = -1;  
  try
  {
    /* SAMPLE APP BODY */
    std::ostringstream rtTasksSummary;
    auto nextWakeupTime = std::chrono::steady_clock::now();
    while (!stopRequested.load())
    {
      rtTasksSummary.str(""); rtTasksSummary.clear();
      rtTasksSummary << std::string(SEPARATOR_LENGTH, '-') << "\n";
  
      // Discover the task managers that are running, and convert to STL containers for easier memory management.
      std::vector<RTTaskManager> taskManagers = ConvertToSTLVector(RTTaskManager::Discover());
      rtTasksSummary << "Discovered " << taskManagers.size() << " task managers:\n";
  
      if (taskManagers.size() != 0)
      {
        // Loop through each task manager and add its information to the string
        for (auto& taskManager : taskManagers)
        {
          AppendTaskManagerSummary(rtTasksSummary, taskManager);
        }
        rtTasksSummary << std::string(SEPARATOR_LENGTH, '-') << "\n";
  
        // Add the global tags to the string
        // AppendGlobalTagSummary(rtTasksSummary, taskManagers[0]);
        // rtTasksSummary << std::string(SEPARATOR_LENGTH, '-') << "\n";
      }
      
      // Print the accumulated string
      std::cout << rtTasksSummary.str() << std::endl;
 
      if (!LOOP_FOREVER) break;
      // Sleep for the specified period before the next iteration
      nextWakeupTime += std::chrono::milliseconds(LOOP_PERIOD_MS);
      std::this_thread::sleep_until(nextWakeupTime);
    };
    
    exitCode = 0; // Set the exit code to success.
  }
  catch (const std::exception &ex)
  {
    std::cerr << ex.what() << std::endl;
    exitCode = -1;
  }
  // print a message to indicate the sample app has finished and if it was successful or not
  Helpers::PrintFooter(SAMPLE_APP_NAME, exitCode);
 
  return exitCode;
}