dot_printer.h

// NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
// software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
// derivative works of the software or any portion of the software, and you may copy and distribute such modifications
// or works. Modified works should carry a notice stating that you changed the software and should note the date and
// nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
// source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
// WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
// CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
// THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
// are solely responsible for determining the appropriateness of using and distributing the software and you assume
// all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
// with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of 
// operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
// damage to property. The software developed by NIST employees is not subject to copyright protection within the
// United States.


#ifndef HEDGEHOG_DOT_PRINTER_H
#define HEDGEHOG_DOT_PRINTER_H

#include <filesystem>
#include <fstream>
#include <string>
#include <vector>
#include <iostream>
#include <iomanip>
#include <iterator>

#include "abstract_printer.h"
#include "../../core/io/base/receiver/core_slot.h"

namespace hh {
enum class ColorScheme {
  NONE, 
  EXECUTION, 
  WAIT 
};

enum class StructureOptions {
  NONE, 
  ALLTHREADING, 
  QUEUE, 
  ALL 
};

enum class DebugOptions {
  NONE, 
  DEBUG 
};

class DotPrinter : public AbstractPrinter {
 private:
  std::vector<std::string> edges_ = {}; 
  std::ofstream outputFile_ = {}; 

  ColorScheme colorScheme_ = {}; 
  StructureOptions structureOptions_ = {}; 
  DebugOptions debugOptions_ = {}; 

  uint64_t
      maxExecutionTime_ = {},         
      minExecutionTime_ = {},         
      rangeExecutionTime_ = {},       
      maxWaitTime_ = {},              
      minWaitTime_ = {},              
      rangeWaitTime_ = {},            
      graphExecutionDuration_ = {};   

 public:
  explicit DotPrinter(std::filesystem::path const &dotFilePath,
                      ColorScheme colorScheme, StructureOptions structureOptions, DebugOptions debugOptions,
                      core::CoreNode *graph)
      : AbstractPrinter(), edges_({}),
        colorScheme_(colorScheme), structureOptions_(structureOptions), debugOptions_(debugOptions) {
    assert(graph != nullptr);
    auto directoryPath = dotFilePath.parent_path();
    if (dotFilePath.has_filename()) {
      if (std::filesystem::exists(directoryPath)) {
        if (std::filesystem::exists(dotFilePath)) {
          std::cout
              << "The file " << dotFilePath.filename() << " will be overwritten." << std::endl;
        } else {
          std::cout
              << "The file " << dotFilePath.filename() << " will be created." << std::endl;
        }
        outputFile_ = std::ofstream(dotFilePath);

      } else {
        std::ostringstream oss;
        oss << "The file " << dotFilePath.filename() << " can not be store in " << directoryPath
            << " because the directory does not  exist.";
        HLOG_SELF(0, oss.str())
        throw (std::runtime_error(oss.str()));
      }
    } else {
      std::ostringstream oss;
      oss << "The path: " << dotFilePath << " does not represent a file.";
      HLOG_SELF(0, oss.str())
      throw (std::runtime_error(oss.str()));
    }
    minExecutionTime_ = graph->minExecutionTime().count();
    maxExecutionTime_ = graph->maxExecutionTime().count();
    minWaitTime_ = graph->minWaitTime().count();
    maxWaitTime_ = graph->maxWaitTime().count();
    // Compute range
    rangeExecutionTime_ = ((maxExecutionTime_ - minExecutionTime_) == 0 ? 1 : maxExecutionTime_ - minExecutionTime_);
    rangeWaitTime_ = ((maxWaitTime_ - minWaitTime_) == 0 ? 1 : maxWaitTime_ - minWaitTime_);
    graphExecutionDuration_ =
        graph->executionDuration().count() == 0 ?
        std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::high_resolution_clock::now() - graph->startExecutionTimeStamp()).count()
                                                : graph->executionDuration().count();
  }

  ~DotPrinter() override { outputFile_.close(); }

  void printNodeInformation(core::CoreNode *node) final {
    // If the node is not a graph
    if (node->type() != core::NodeType::Graph) {
      //If all cluster node to be printed
      if (this->structureOptions_ == StructureOptions::ALL
          || this->structureOptions_ == StructureOptions::ALLTHREADING) {
        // Get and print the node information
        outputFile_ << getNodeInformation(node);
        // If only one node per cluster need to be printed with gathered information
      } else {
        // If the node is the cluster main node
        if (node->id() == node->coreClusterNode()->id()) {
          // Get and print the node information
          outputFile_ << getNodeInformation(node);
        }
      }
    }
    outputFile_.flush();
  }

  void printGraphHeader(core::CoreNode const *node) final {
    // If the graph is the outer graph, i.e. the main graph
    if (!node->isInside()) {
      outputFile_
          << "digraph " << node->id()
          << " {\nlabel=\"" << node->name();
      if (debugOptions_ == DebugOptions::DEBUG) {
        outputFile_ << " " << node->id();
      }
      outputFile_ << "\\nExecution time:" << this->durationPrinter(this->graphExecutionDuration_)
                  << "\\nCreation time:" << this->durationPrinter(node->creationDuration().count())
                  << "\"; fontsize=25; penwidth=5; ranksep=0; labelloc=top; labeljust=left; \n";
      // If the graph is an inner graph, i.e. a node of the outer graph
    } else {
      outputFile_ << "subgraph cluster" << node->id() << " {\nlabel=\"" << node->name();
      if (debugOptions_ == DebugOptions::DEBUG) {
        outputFile_ << " " << node->id();
      }
      outputFile_ << "\"; fontsize=25; penwidth=5; fillcolor=white;\n";
    }
    outputFile_.flush();
  }

  void printClusterHeader(core::CoreNode const *clusterNode) final {
    //If all cluster node to be printed
    if (this->structureOptions_ == StructureOptions::ALLTHREADING || this->structureOptions_ == StructureOptions::ALL) {
      // Create a dot subgraph for the task cluster
      outputFile_ << "subgraph cluster" << clusterNode->id()
                  << " {\nlabel=\"\"; penwidth=3; style=filled; fillcolor=\"#4e78cf63\"; color=\"#4e78cf\";\n";
      // Add an "egg" node to represent the entry point of cluster
      outputFile_ << "box" << clusterNode->id() << "[label=\"\", shape=egg];\n";
      outputFile_.flush();
    }
  }

  void printClusterFooter() final {
    //If all cluster node to be printed
    if (this->structureOptions_ == StructureOptions::ALLTHREADING || this->structureOptions_ == StructureOptions::ALL) {
      // Close the subgraph
      outputFile_ << "}\n";
      outputFile_.flush();
    }
  }

  void printGraphFooter(core::CoreNode const *graph) final {
    // If the graph is the outer graph
    if (!graph->isInside()) {
      // Print all the stored edges
      std::copy(edges_.begin(), edges_.end(), std::ostream_iterator<std::string>(outputFile_, "\n"));
    }
    // Close the dot subgraph
    outputFile_ << "}\n";
    outputFile_.flush();
  }

  void printClusterEdge(core::CoreNode const *clusterNode) final {
    //If all cluster node to be printed
    if (this->structureOptions_ == StructureOptions::ALLTHREADING || this->structureOptions_ == StructureOptions::ALL) {
      // Print an edge from the cluster "egg" node to the task
      std::ostringstream ss;
      ss << "box" << clusterNode->coreClusterNode()->id() << " -> " << clusterNode->id();
      edges_.push_back(ss.str());
    }
  }

  void printExecutionPipelineHeader(core::CoreNode *epNode, core::CoreNode *switchNode) override {
    //Print the dot subgraph header
    outputFile_ << "subgraph cluster" << epNode->id() << " {\nlabel=\"" << epNode->name();
    if (debugOptions_ == DebugOptions::DEBUG) { outputFile_ << " " << epNode->id() << " / " << switchNode->id(); }
    // Print a "triangle" node to represent the execution pipeline switch
    outputFile_ << "\"; penwidth=1; style=dotted; style=filled; fillcolor=gray80;\n "
                << switchNode->id() << "[label=\"\", shape=triangle];\n";
    outputFile_.flush();
  }

  void printExecutionPipelineFooter() override {
    outputFile_ << "}\n";
    outputFile_.flush();
  }

  void printEdgeSwitchGraphs(core::CoreNode *to,
                             std::string const &idSwitch,
                             std::string_view const &edgeType,
                             size_t const &queueSize,
                             size_t const &maxQueueSize,
                             bool isMemoryManaged) override {
    std::ostringstream
        oss;

    std::string
        idDest,
        headLabel,
        penWidth = ",penwidth=1",
        queueStr;



    // If the queue information need to be printed
    if (this->structureOptions_ == StructureOptions::QUEUE || this->structureOptions_ == StructureOptions::ALL) {
      oss << " QS:" << queueSize << " MQS:" << maxQueueSize;
      queueStr = oss.str();
      oss.str("");
    }

    // Change the width of the edge if the data is memory managed
    if (isMemoryManaged) { penWidth = ",penwidth=3"; }

    // If all nodes in a cluster need to be printed
    if (this->structureOptions_ == StructureOptions::ALLTHREADING || this->structureOptions_ == StructureOptions::ALL) {
      // If the node is part of a cluster
      if (to->isInCluster()) {
        // Loop over all input node of the current node
        // (could be simply itself or, all input nodes in the case of graph)
        for (auto &dest: to->ids()) {
          // Create cluster id (dest.first is the input node, dest.second is the reference to the cluster main node)
          idDest = "box" + dest.second;
          // Create the edge
          oss << idSwitch << " -> " << idDest << "[label=\"" << edgeType << queueStr << "\""
              << penWidth << "];";
        }
        // If the node is not part of a cluster
      } else {
        // Crete the edge
        oss << idSwitch << " -> " << to->id() << "[label=\"" << edgeType << queueStr << "\"" << penWidth << "];";
      }
      // If all nodes should not be printed but node is the main cluster node
    } else if (to->id() == to->coreClusterNode()->id()) {
      // Create the edge
      oss << idSwitch << " -> " << to->id() << "[label=\"" << edgeType << queueStr << "\"" << penWidth << "];";
    }
    edges_.push_back(oss.str());
  }

  void printEdge(core::CoreNode const *from, core::CoreNode const *to, std::string_view const &edgeType,
                 size_t const &queueSize, size_t const &maxQueueSize,
                 bool isMemoryManaged) final {
    std::ostringstream
        oss;

    std::string
        headLabel,
        tailLabel,
        idDest,
        queueStr,
        penWidth = ",penwidth=1";

    // Change the width of the edge if the data is memory managed
    if (isMemoryManaged) { penWidth = ",penwidth=3"; }

    // If the queue information need to be printed, add queue information
    if (this->structureOptions_ == StructureOptions::QUEUE || this->structureOptions_ == StructureOptions::ALL) {
      oss << " QS:" << queueSize << " MQS:" << maxQueueSize;
      queueStr = oss.str();
      oss.str("");
    }

    // If all nodes in a cluster need to be printed
    if (this->structureOptions_ == StructureOptions::ALLTHREADING || this->structureOptions_ == StructureOptions::ALL) {
      // If the source node is in a cluster
      if (from->isInCluster()) {
        // Loop over all source node of the current node
        // (could be simply itself or, all input nodes in the case of graph)
        for (auto &source: from->ids()) {
          headLabel = ",ltail=cluster" + source.second;
          // If the destination node is in a cluster
          if (to->isInCluster()) {
            // Loop over all destination node of the current node
            // (could be simply itself or, all input nodes in the case of graph)
            for (auto &dest : to->ids()) {
              tailLabel = ",lhead=cluster" + dest.second;
              idDest = "box" + dest.second;
              oss << source.first << " -> " << idDest << "[label=\"" << edgeType << queueStr << "\"" << headLabel
                  << tailLabel << penWidth << "];";
            }
            // If the destination node is NOT in a cluster
          } else {
            oss << source.first << " -> " << to->id() << "[label=\"" << edgeType << queueStr << "\"" << headLabel
                << penWidth
                << "];";
          }
        }
        // If the source node is NOT in a cluster
      } else {
        // If the destination node is in a cluster
        if (to->isInCluster()) {
          // Loop over all destination node of the current node
          // (could be simply itself or, all input nodes in the case of graph)
          for (auto &dest : to->ids()) {
            tailLabel = ",lhead=cluster" + dest.second;
            idDest = "box" + dest.second;
            oss << from->id() << " -> " << idDest << "[label=\"" << edgeType << queueStr << "\"" << headLabel
                << tailLabel << penWidth << "];";
          }
          // If the destination node is NOT in a cluster
        } else {
          oss << from->id() << " -> " << to->id() << "[label=\"" << edgeType << queueStr << "\"" << headLabel
              << penWidth
              << "];";
        }
      }
      edges_.push_back(oss.str());
      // If all nodes should NOT be printed and, from and to are the main nodes of their cluster
    } else if (from->id() == from->coreClusterNode()->id() && to->id() == to->coreClusterNode()->id()) {
      oss << from->id() << " -> " << to->id() << "[label=\"" << edgeType << queueStr << "\"" << penWidth << "];";
      edges_.push_back(oss.str());
    }
  }

 private:
  std::string getNodeInformation(core::CoreNode *node) {
    std::stringstream ss;

    // Print the name
    ss << node->id() << " [label=\"" << node->name();
    // Print the id (adress) in case of debug
    if (debugOptions_ == DebugOptions::DEBUG) {
      ss << " " << node->id() << " \\(" << node->threadId() << ", " << node->graphId() << "\\)";
    }

    switch (node->type()) {
      // Set a specific shape for the source
      case core::NodeType::Source:ss << "\", shape=doublecircle";
        break;
        // Set a specific shape for the sink
      case core::NodeType::Sink:ss << "\",shape=point";
        break;
        // For the execution task
      case core::NodeType::Task:
        // If the cluster has to be presented as a single dot node
        if (!(this->structureOptions_ == StructureOptions::ALLTHREADING
            || this->structureOptions_ == StructureOptions::ALL)) {
          if(node->isInCluster()){
            ss << " x " << node->numberThreads();
          }
        }
        // If debug information printed
        if (debugOptions_ == DebugOptions::DEBUG) {
          // Print number of active input connection
          ss << "\\nActive input connection: " << dynamic_cast<core::CoreSlot *>(node)->numberInputNodes();
          // If all nodes in a cluster need to be printed
          if (this->structureOptions_ == StructureOptions::ALLTHREADING
              || this->structureOptions_ == StructureOptions::ALL) {
            ss << "\\nThread Active?: " << std::boolalpha << dynamic_cast<core::CoreSlot *>(node)->isActive();
            // If all nodes in a cluster should NOT be printed
          } else {
            ss << "\\nActive threads: " << dynamic_cast<core::CoreSlot *>(node)->numberActiveThreadInCluster();
          }
        }
        // If all nodes in a cluster need to be printed
        if (this->structureOptions_ == StructureOptions::ALLTHREADING
            || this->structureOptions_ == StructureOptions::ALL) {
          ss << "\\nWait Time: " << this->durationPrinter(node->waitTime().count());
          ss << "\\nExecution Time: " << this->durationPrinter(node->executionTime().count());
          ss << "\\nMemory Wait Time: " << this->durationPrinter(node->memoryWaitTime().count());
          // If all nodes in a cluster should NOT be printed
        } else {
          //Get the time in the clusters
          auto minmaxWait = node->minmaxWaitTimeCluster();
          auto minmaxExec = node->minmaxExecTimeCluster();
          auto minmaxMemoryWait = node->minmaxMemoryWaitTimeCluster();
          // Print the wait time
          ss << "\\nWait Time: ";
          if (node->numberThreads() > 1) {
            ss << "\\n"
                << "  Min: " << this->durationPrinter(minmaxWait.first) << "\\n"
                << "  Avg: " << this->durationPrinter(node->meanWaitTimeCluster().count()) << " +- "
                << this->durationPrinter(node->stdvWaitTimeCluster()) << "\\n"
                << "  Max: " << this->durationPrinter(minmaxWait.second) << "\\n\\n";
          } else {
            ss << this->durationPrinter(node->meanWaitTimeCluster().count()) << "\\n";
          }
          // Print the execution time
          ss << "Execution Time: ";
          if (node->numberThreads() > 1) {
            ss << "\\n"
                << "  Min: " << this->durationPrinter(minmaxExec.first) << "\\n"
                << "  Avg: " << this->durationPrinter(node->meanExecTimeCluster().count()) << " +- "
                << this->durationPrinter(node->stdvExecTimeCluster()) << "\\n"
                << "  Max: " << this->durationPrinter(minmaxExec.second) << "\\n\\n";
          } else {
            ss << this->durationPrinter(node->meanExecTimeCluster().count()) << "\\n";
          }

          // Print the memory wait time
          if (node->meanMemoryWaitTimeCluster().count() > 0) {
            ss << "Memory Wait Time: ";
            if (node->numberThreads() > 1) {
              ss << "\\n"
                  << "  Min: " << this->durationPrinter(minmaxMemoryWait.first) << "\\n"
                  << "  Avg: " << this->durationPrinter(node->meanMemoryWaitTimeCluster().count()) << " +-"
                  << this->durationPrinter(node->stdvMemoryWaitTimeCluster()) << "\\n"
                  << "  Max: " << this->durationPrinter(minmaxMemoryWait.second) << "\\n\\n";
            } else {
              ss << this->durationPrinter(node->meanMemoryWaitTimeCluster().count()) << "\\n";
            }
          }
        }
        // If extra information has been defined by the user, print it
        if (!node->extraPrintingInformation().empty()) {
          ss << "\\n" << node->extraPrintingInformation();
        }
        ss << "\"";
        ss << ",shape=circle";
        // Change the color of the circle depending on the user choice
        switch (this->colorScheme_) {
          case ColorScheme::EXECUTION:ss << ",color=" << this->getExecRGB(node->executionTime().count()) << ", penwidth=3";
            break;
          case ColorScheme::WAIT:ss << ",color=" << this->getWaitRGB(node->waitTime().count()) << ", penwidth=3";
            break;
          default:break;
        }

        if (node->isCudaRelated()) { ss << R"(, style=filled, fillcolor="#76b900", fontcolor="#8946ff")"; }
        break;
        // Print state manager
      case core::NodeType::StateManager:
        if (debugOptions_ == DebugOptions::DEBUG) {
          ss << "\\nActive input connection: " << dynamic_cast<core::CoreSlot *>(node)->numberInputNodes();
          ss << "\\nActive threads: " << dynamic_cast<core::CoreSlot *>(node)->numberActiveThreadInCluster();
        }
        ss << "\\nWait Time: " << this->durationPrinter(node->waitTime().count());
        ss << "\\nExecution Time: " << this->durationPrinter(node->executionTime().count());
        ss << "\"";
        ss << ",shape=diamond";
        // Change the color of the circle depending on the user choice
        switch (this->colorScheme_) {
          case ColorScheme::EXECUTION:ss << ",color=" << this->getExecRGB(node->executionTime().count()) << ", penwidth=3";
            break;
          case ColorScheme::WAIT:ss << ",color=" << this->getWaitRGB(node->waitTime().count()) << ", penwidth=3";
            break;
          default:break;
        }
        break;
      default:break;
    }
    ss << "];\n";

    return ss.str();
  }

  std::string getRGBFromRange(uint64_t const &val, uint64_t const &min, uint64_t const &range) {

    uint64_t posRedToBlue = (std::abs((int64_t) val - (int64_t) min)) * 255 / range;
    posRedToBlue = posRedToBlue > 255 ? 255 : posRedToBlue;
    std::stringstream ss;
    ss << "\"#"
       << std::setfill('0') << std::setw(2) << std::hex << posRedToBlue
       << "00"
       << std::setfill('0') << std::setw(2) << std::hex << 255 - posRedToBlue
       << "\"";

    HLOG(0, "PRINT RGB RANGE " << val << " " << min << " " << range << " " << posRedToBlue)
    return ss.str();
  }

  std::string getExecRGB(uint64_t val) {
    return getRGBFromRange(val, this->minExecutionTime_, this->rangeExecutionTime_);
  }

  std::string getWaitRGB(uint64_t val) {
    return getRGBFromRange(val, this->minWaitTime_, this->rangeWaitTime_);
  }

  std::string durationPrinter(uint64_t duration) {
    std::ostringstream oss;
    uint64_t
        s = (duration % 1000000000) / 1000000,
        mS = (duration % 1000000) / 1000,
        uS = (duration % 1000);

    if (s > 0) {
      oss << s << "." << std::setfill('0') << std::setw(3) << mS << "s";
    } else if (mS > 0) {
      oss << mS << "." << std::setfill('0') << std::setw(3) << uS << "ms";
    } else {
      oss << duration << "us";
    }
    return oss.str();
  }
};
}
#endif //HEDGEHOG_DOT_PRINTER_H