dot_printer.h

Go to the documentation of this file.

// 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 <fstream>
#include <filesystem>
#include <iostream>
#include <cmath>
#include <utility>
#include <set>
 
#include "printer.h"
#include "options/color_scheme.h"
#include "options/color_picker.h"
#include "options/debug_options.h"
#include "options/structure_options.h"
#include "../../core/abstractions/base/node/graph_node_abstraction.h"
#include "../../core/abstractions/base/node/task_node_abstraction.h"
#include "../../core/abstractions/base/any_groupable_abstraction.h"
 
namespace hh {
 
class DotPrinter : public Printer {
 private:
  class Edge {
   private:
    std::string id_{}; 
 
    std::string type_{}; 
 
    std::string extraLabel_{}; 
 
    std::set<std::string>
        arrivals_{}, 
    exits_{}; 
 
    bool declarationPrinted_ = false; 
 
    core::abstraction::GraphNodeAbstraction *
        belongingGraph_ = nullptr; 
 
   public:
    explicit Edge(std::string id, std::string type, core::abstraction::GraphNodeAbstraction *const belongingGraph)
        : id_(std::move(id)), type_(std::move(type)), belongingGraph_(belongingGraph) {}
 
    virtual ~Edge() = default;
 
    [[nodiscard]] std::string const &id() const { return id_; }
 
    [[nodiscard]] std::string const &extraLabel() const { return extraLabel_; }
 
    [[nodiscard]] core::abstraction::GraphNodeAbstraction *belongingGraph() const { return belongingGraph_; }
 
    void addExtraLabel(std::string extraLabel) { extraLabel_ = std::move(extraLabel); }
 
    void addArrival(std::string arrival) { arrivals_.insert(std::move(arrival)); }
 
    void addExit(std::string exit) { exits_.insert(std::move(exit)); }
 
    void printDeclaration(std::ostream &os) {
      if (!declarationPrinted_) {
        declarationPrinted_ = true;
        os << "\"" << id_ << "\"" << "[label=\"" << type_ << "\\n" << extraLabel_ << "\", shape=rect];\n";
      }
    }
 
    void printEdges(std::ostream &os) const {
      for (auto &arrival : arrivals_) {
        os << "\"" << arrival << "\" -> \"" << id_ << "\"[penwidth=1, dir=none];\n";
      }
      for (auto &exit : exits_) {
        os << "\"" << id_ << "\" -> \"" << exit << "\"[penwidth=1];\n";
      }
    }
 
    bool operator==(Edge const &rhs) const { return id_ == rhs.id_ && type_ == rhs.type_; }
  };
 
  std::ofstream outputFile_ = {}; 
  ColorScheme colorScheme_ = {}; 
  StructureOptions structureOptions_ = {}; 
  DebugOptions debugOptions_ = {}; 
  std::unique_ptr<ColorPicker> colorPicker_ = nullptr; 
 
  std::chrono::nanoseconds
      graphTotalExecution_ = std::chrono::nanoseconds::max(), 
  minExecutionDurationInAllGraphs_ =
  std::chrono::nanoseconds::max(), 
  maxExecutionDurationInAllGraphs_ =
  std::chrono::nanoseconds::min(), 
  rangeExecutionDurationInAllGraphs_ =
  std::chrono::nanoseconds::min(),  
  minWaitDurationInAllGraphs_ =
  std::chrono::nanoseconds::max(),  
  maxWaitDurationInAllGraphs_ =
  std::chrono::nanoseconds::min(),  
  rangeWaitDurationInAllGraphs_ =
  std::chrono::nanoseconds::min();  
 
  std::unique_ptr<std::vector<Edge>> edges_ = nullptr; 
 
 public:
  DotPrinter(std::filesystem::path const &dotFilePath,
             ColorScheme colorScheme,
             StructureOptions structureOptions,
             DebugOptions debugOptions,
             core::abstraction::GraphNodeAbstraction const *graph,
             std::unique_ptr<ColorPicker> colorPicker,
             bool verbose)
      : colorScheme_(colorScheme),
        structureOptions_(structureOptions),
        debugOptions_(debugOptions),
        colorPicker_(std::move(colorPicker)),
        edges_(std::make_unique<std::vector<Edge>>()) {
    assert(graph != nullptr);
 
    testPath(dotFilePath, verbose);
 
    if (colorPicker_ == nullptr) {
      throw (
          std::runtime_error("A dot printer should be constructed with a valid ColorPicker (colorPicker != nullptr)")
      );
    }
 
    auto minMaxExecTime = graph->minMaxExecutionDuration();
    auto minMaxWaitTime = graph->minMaxWaitDuration();
 
    minExecutionDurationInAllGraphs_ = minMaxExecTime.first;
    maxExecutionDurationInAllGraphs_ = minMaxExecTime.second;
 
    minWaitDurationInAllGraphs_ = minMaxWaitTime.first;
    maxWaitDurationInAllGraphs_ = minMaxWaitTime.second;
 
    // Compute range
    rangeExecutionDurationInAllGraphs_ =
        maxExecutionDurationInAllGraphs_ == minExecutionDurationInAllGraphs_ ?
        std::chrono::nanoseconds(1) :
        maxExecutionDurationInAllGraphs_ - minExecutionDurationInAllGraphs_;
 
    rangeWaitDurationInAllGraphs_ =
        maxWaitDurationInAllGraphs_ == minWaitDurationInAllGraphs_ ?
        std::chrono::nanoseconds(1) :
        maxWaitDurationInAllGraphs_ - minWaitDurationInAllGraphs_;
 
    graphTotalExecution_ =
        graph->executionDuration() == std::chrono::nanoseconds::zero() ?
        std::chrono::system_clock::now() - graph->startExecutionTimeStamp() : graph->executionDuration();
  }
 
  ~DotPrinter() override { outputFile_.close(); }
 
  void printGraphHeader(core::abstraction::GraphNodeAbstraction const *graph) override {
    // If the graph is the outer graph, i.e. the main graph
    if (!graph->isRegistered()) {
      outputFile_
          << "digraph " << graph->id()
          << " {\nlabel=\"" << graph->name();
      if (debugOptions_ == DebugOptions::ALL) { outputFile_ << " " << graph->id(); }
 
      outputFile_ << "\\nExecution duration:" << durationPrinter(this->graphTotalExecution_)
                  << "\\nCreation duration:" << durationPrinter(graph->graphConstructionDuration())
                  << "\"; fontsize=25; penwidth=5; labelloc=top; labeljust=left; \n";
 
      // If the graph is an inner graph, i.e. a graph of the outer graph
    } else {
      outputFile_ << "subgraph cluster" << graph->id() << " {\nlabel=\"" << graph->name();
      if (debugOptions_ == DebugOptions::ALL) {
        outputFile_ << " " << graph->id();
      }
      outputFile_
          << "\"; fontsize=25; penwidth=5; fillcolor=\""
          << colorFormatConvertor(graph->printOptions().background())
          << "\";\n";
    }
    outputFile_.flush();
  }
 
  void printGraphFooter(core::abstraction::GraphNodeAbstraction const *graph) override {
 
    // Print all edge declarations that has not already been printed
    for (auto &edge : *edges_) {
      if (edge.belongingGraph() == graph) {
        edge.printDeclaration(outputFile_);
      }
    }
 
    // If the graph is the outer graph
    if (!graph->isRegistered()) {
      // Print all the stored edges
 
      for (auto const &edge : *(this->edges_)) { edge.printEdges(outputFile_); }
    }
    // Close the dot subgraph
    outputFile_ << "}\n";
    outputFile_.flush();
  }
 
  void printNodeInformation(core::abstraction::NodeAbstraction const *node) override {
    // If the node is not a graph
    if (auto task = dynamic_cast<core::abstraction::TaskNodeAbstraction const *>(node)) {
      //If all group node to be printed
      if (this->structureOptions_ == StructureOptions::ALL || this->structureOptions_ == StructureOptions::THREADING) {
        // Get and print the node information
        outputFile_ << getTaskInformation(task);
        // If only one node per group need to be printed with gathered information
      } else {
        if (auto copyableNode = dynamic_cast<core::abstraction::AnyGroupableAbstraction const *>(task)) {
          // If the node is the group main node
          if (copyableNode == copyableNode->groupRepresentative()) {
            // Get and print the node information
            outputFile_ << getTaskInformation(task);
          }
        } else {
          // Case for printing state manager while not printing all nodes
          outputFile_ << getTaskInformation(task);
        }
      }
    }
    outputFile_.flush();
  }
 
  void printEdge(core::abstraction::NodeAbstraction const *from, core::abstraction::NodeAbstraction const *to,
                 std::string const &edgeType,
                 size_t const &queueSize, size_t const &maxQueueSize) override {
 
    std::ostringstream oss;
    std::string idToFind, label;
 
    for (auto &source : from->ids()) {
      for (auto &dest : to->ids()) {
        auto edge = getOrCreateEdge(dest.second, edgeType, to->belongingGraph());
 
        if (edge->extraLabel().empty()) {
          if (this->structureOptions_ == StructureOptions::QUEUE || this->structureOptions_ == StructureOptions::ALL) {
            oss << "QS=" << queueSize << "\\nMQS=" << maxQueueSize;
            edge->addExtraLabel(oss.str());
            oss.str("");
          }
        }
        edge->addArrival(source.first);
        edge->addExit(dest.first);
 
        if (this->structureOptions_ == StructureOptions::THREADING ||
            this->structureOptions_ == StructureOptions::ALL) {
          if (auto copyableSender = dynamic_cast<core::abstraction::AnyGroupableAbstraction const *>(from)) {
            for (auto groupMember : *copyableSender->group()) { edge->addArrival(groupMember->nodeId()); }
          }
        }
      }
    }
  }
 
  void printGroup(core::abstraction::NodeAbstraction *representative,
                  std::vector<core::abstraction::NodeAbstraction *> const &group) override {
    bool const printAllGroupMembers =
        this->structureOptions_ == StructureOptions::THREADING || this->structureOptions_ == StructureOptions::ALL;
 
    auto copyableRepr = dynamic_cast<core::abstraction::AnyGroupableAbstraction *>(representative);
    auto printRepr = dynamic_cast<core::abstraction::PrintableAbstraction *>(representative);
    if (copyableRepr == nullptr || printRepr == nullptr) {
      std::ostringstream oss;
      oss << "Internal error in: " << __FUNCTION__
          << " a group of node should be created with node that derives from AnyGroupableAbstraction and PrintableAbstraction";
      throw std::runtime_error(oss.str());
    }
 
    // Print header
    // If all group node to be printed
    if (printAllGroupMembers) {
      // Create a dot subgraph for the task group
      outputFile_ << "subgraph cluster" << representative->id()
                  << " {\nlabel=\"\"; penwidth=3; style=filled; fillcolor=\"#ebf0fa\"; color=\"#4e78cf\";\n";
 
    }
 
    printRepr->visit(this);
 
    if (printAllGroupMembers) {
      for (auto groupMember : group) {
        if(auto printGroupMember = dynamic_cast<core::abstraction::PrintableAbstraction *>(groupMember)){
          printGroupMember->visit(this);
        }else {
          std::ostringstream oss;
          oss << "Internal error in: " << __FUNCTION__
              << " a group of node should be created with nodes that derive from AnyGroupableAbstraction and PrintableAbstraction";
          throw std::runtime_error(oss.str());
        }
      }
    }
 
    if (printAllGroupMembers) {
      outputFile_ << "}\n";
    }
 
    outputFile_.flush();
  }
 
  void printSource(core::abstraction::NodeAbstraction const *source) override {
    outputFile_ << source->id() << " [label=\"" << source->name();
    if (debugOptions_ == DebugOptions::ALL) {
      outputFile_ << " " << source->id() << " \\(Graph:" << source->belongingGraph()->id() << "\\)";
    }
    outputFile_ << "\", shape=invhouse];\n";
    outputFile_.flush();
  }
 
  void printSink(core::abstraction::NodeAbstraction const *sink) override {
    outputFile_ << sink->id() << " [label=\"" << sink->name();
    if (debugOptions_ == DebugOptions::ALL) {
      outputFile_ << " " << sink->id() << " \\(Graph:" << sink->belongingGraph()->id() << "\\)";
    }
    outputFile_ << "\", shape=point];\n";
    outputFile_.flush();
  }
 
  void printExecutionPipelineHeader(core::abstraction::ExecutionPipelineNodeAbstraction const *ep,
                                    core::abstraction::NodeAbstraction const *switchNode) override {
    //Print the dot subgraph header
    outputFile_ << "subgraph cluster" << ep->id() << " {\nlabel=\"" << ep->name();
    if (debugOptions_ == DebugOptions::ALL) { outputFile_ << " " << ep->id() << " / " << switchNode->id(); }
    // Print a "triangle" node to represent the execution pipeline switch
    outputFile_ << "\"; penwidth=1; style=dotted; style=filled; fillcolor=\""
                << colorFormatConvertor(ep->printOptions().background())
                << "\";\n "
                << switchNode->id() << "[label=\"\", shape=triangle];\n";
    outputFile_.flush();
  }
 
  void printExecutionPipelineFooter() override {
    outputFile_ << "}\n";
    outputFile_.flush();
  }
 
 private:
  std::vector<Edge>::iterator getOrCreateEdge(
      std::string const &id, std::string const &type,
      hh::core::abstraction::GraphNodeAbstraction *belongingGraph) {
    std::ostringstream ossId;
    ossId << "edge" << id << type;
    Edge temp(ossId.str(), type, belongingGraph);
    auto it = std::find(this->edges_->begin(), this->edges_->end(), temp);
    if (it != this->edges_->end()) { return it; }
    else { return this->edges_->insert(this->edges_->end(), temp); }
  }
 
  std::string getTaskInformation(core::abstraction::TaskNodeAbstraction const *task) {
    std::stringstream ss;
 
    auto copyableTask = dynamic_cast<core::abstraction::AnyGroupableAbstraction const *>(task);
    auto slotTask = dynamic_cast<core::abstraction::SlotAbstraction const *>(task);
 
    bool printAllNodes =
        this->structureOptions_ == StructureOptions::THREADING || this->structureOptions_ == StructureOptions::ALL;
 
    // Print the name
    ss << task->id() << " [label=\"" << task->name();
    // Print the id (address) in case of debug
    if (debugOptions_ == DebugOptions::ALL) {
      ss << " " << task->id() << " \\(" << task->belongingGraph()->id() << "\\)";
    }
 
    // If the group has to be presented as a single dot node
    if (!printAllNodes) {
      if (copyableTask && copyableTask->isInGroup()) {
        ss << " x " << copyableTask->numberThreads();
      }
    }
    // If debug information printed
    if (debugOptions_ == DebugOptions::ALL) {
      if (slotTask) {
        // Print number of active input connection
        ss << "\\nActive inputs connection: " << slotTask->connectedNotifiers().size();
      }
      // If all nodes in a group need to be printed
      if (printAllNodes) {
        ss << "\\nThread Active?: " << std::boolalpha << task->isActive();
        // If all nodes in a group should NOT be printed
      } else {
        if (copyableTask) {
          ss << "\\nActive threads: " << copyableTask->numberActiveThreadInGroup();
        }
      }
    }
    // If all nodes in a group need to be printed OR is state manager
    if (printAllNodes || !copyableTask) {
      ss << "\\nNumber Elements Received: " << task->numberReceivedElements();
      ss << "\\nWait Duration: " << durationPrinter(task->waitDuration());
      ss << "\\nDequeue + Execution Duration: " << durationPrinter(task->executionDuration());
      ss << "\\nExecution Duration Per Element: " << durationPrinter(task->perElementExecutionDuration());
      if (task->hasMemoryManagerAttached()) {
        ss << "\\nMemory manager (" << task->memoryManager()->managedType() << "): "
           << task->memoryManager()->currentSize() << "/" << task->memoryManager()->capacity();
        ss << "\\nMemory Wait Duration: " << durationPrinter(task->memoryWaitDuration());
      }
      // If all nodes in a group should NOT be printed
    } else {
      //Get the time in the groups
      if (copyableTask) {
        // Print the number of element received per task
        ss << "\\nNumber of Elements Received Per Task: ";
        if (copyableTask->numberThreads() > 1) {
          auto minmaxElements = copyableTask->minmaxNumberElementsReceivedGroup();
          auto meanSDNumberElements = copyableTask->meanSDNumberElementsReceivedGroup();
          ss << "\\n"
             << "  Min: " << minmaxElements.first << "\\n"
             << "  Avg: " << std::setw(3) << meanSDNumberElements.first
             << " +- " << std::setw(3) << meanSDNumberElements.second
             << "\\n"
             << "  Max: " << std::setw(3) << minmaxElements.second << "\\n";
        } else {
          ss << task->numberReceivedElements() << "\\n";
        }
        // Print the wait time
        ss << "Wait Time: ";
        if (copyableTask->numberThreads() > 1) {
          auto minmaxWait = copyableTask->minmaxWaitDurationGroup();
          auto meanSDWait = copyableTask->meanSDWaitDurationGroup();
          ss << "\\n"
             << "  Min: " << durationPrinter(minmaxWait.first) << "\\n"
             << "  Avg: " << durationPrinter(meanSDWait.first) << " +- "
             << durationPrinter(meanSDWait.second) << "\\n"
             << "  Max: " << durationPrinter(minmaxWait.second) << "\\n";
        } else {
          ss << durationPrinter(task->waitDuration()) << "\\n";
        }
        // Print the execution time
        ss << "Dequeue + Execution Time: ";
        if (copyableTask->numberThreads() > 1) {
          auto minmaxExec = copyableTask->minmaxExecutionDurationGroup();
          auto meanSDExec = copyableTask->meanSDExecutionDurationGroup();
          ss << "\\n"
             << "  Min: " << durationPrinter(minmaxExec.first) << "\\n"
             << "  Avg: " << durationPrinter(meanSDExec.first) << " +- "
             << durationPrinter(meanSDExec.second) << "\\n"
             << "  Max: " << durationPrinter(minmaxExec.second) << "\\n";
        } else {
          ss << durationPrinter(task->executionDuration()) << "\\n";
        }
 
        // Print the execution time per Element
        ss << "Execution Time Per Element: ";
        if (copyableTask->numberThreads() > 1) {
          auto minmaxExecPerElement = copyableTask->minmaxExecTimePerElementGroup();
          auto meanSDExecPerElement = copyableTask->meanSDExecTimePerElementGroup();
          ss << "\\n"
             << "  Min: " << durationPrinter(minmaxExecPerElement.first) << "\\n"
             << "  Avg: " << durationPrinter(meanSDExecPerElement.first) << " +- "
             << durationPrinter(meanSDExecPerElement.second) << "\\n"
             << "  Max: " << durationPrinter(minmaxExecPerElement.second) << "\\n";
        } else {
          ss << durationPrinter(task->perElementExecutionDuration()) << "\\n";
        }
 
        // Print the memory wait time
        if (task->hasMemoryManagerAttached()) {
          ss << "Memory manager (" << task->memoryManager()->managedType() << "): "
             << task->memoryManager()->currentSize() << "/" << task->memoryManager()->capacity();
          ss << "\\nMemory Wait Time: ";
          if (copyableTask->numberThreads() == 1) {
            ss << durationPrinter(task->memoryWaitDuration()) << "\\n";
          } else {
            auto minmaxWaitMemory = copyableTask->minmaxMemoryWaitTimeGroup();
            auto meanSDWaitMemory = copyableTask->meanSDMemoryWaitTimePerElementGroup();
            ss << "\\n"
               << "  Min: " << durationPrinter(minmaxWaitMemory.first) << "\\n"
               << "  Avg: " << durationPrinter(meanSDWaitMemory.first) << " +-"
               << durationPrinter(meanSDWaitMemory.second) << "\\n"
               << "  Max: " << durationPrinter(minmaxWaitMemory.second) << "\\n";
          }
        }
      }
    }
    // If extra information has been defined by the user, print it
    auto extraInfo = task->extraPrintingInformation();
    if (!extraInfo.empty()) { ss << "\\n" << extraInfo; }
 
    ss << "\"";
    ss << ",shape=rect";
    // Change the color of the rect depending on the user choice
    switch (this->colorScheme_) {
      case ColorScheme::EXECUTION:ss << ",color=" << this->getExecRGB(task->executionDuration()) << ", penwidth=3";
        break;
      case ColorScheme::WAIT:ss << ",color=" << this->getWaitRGB(task->waitDuration()) << ", penwidth=3";
        break;
      default:break;
    }
 
    ss << R"(, style=filled, fillcolor=")"
       << colorFormatConvertor(task->printOptions().background())
       << R"(", fontcolor=")"
       << colorFormatConvertor(task->printOptions().font())
       << "\"];\n";
    return ss.str();
  }
 
  void testPath(std::filesystem::path const &dotFilePath, bool verbose) {
    auto directoryPath = dotFilePath.parent_path();
    std::ostringstream oss;
    if (!dotFilePath.has_filename()) {
      oss << "The path: " << dotFilePath << " does not represent a file.";
      throw (std::runtime_error(oss.str()));
    }
    if (!std::filesystem::exists(directoryPath)) {
      oss << "The file " << dotFilePath.filename() << " can not be store in " << directoryPath
          << " because the directory does not  exist.";
      throw (std::runtime_error(oss.str()));
    }
    if (!std::filesystem::exists(directoryPath)) {
      oss << "The file " << dotFilePath.filename() << " can not be store in " << directoryPath
          << " because the directory does not  exist.";
      throw (std::runtime_error(oss.str()));
    }
    if (verbose) {
      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);
  }
 
  std::string getExecRGB(std::chrono::nanoseconds const &ns) {
    return colorPicker_
        ->getRGBFromRange(ns, this->minExecutionDurationInAllGraphs_, this->rangeExecutionDurationInAllGraphs_);
  }
 
  std::string getWaitRGB(std::chrono::nanoseconds const &ns) {
    return colorPicker_->getRGBFromRange(ns, this->minWaitDurationInAllGraphs_, this->rangeWaitDurationInAllGraphs_);
  }
 
  static std::string durationPrinter(std::chrono::nanoseconds const &ns) {
    std::ostringstream oss;
 
    // Cast with precision loss
    auto s = std::chrono::duration_cast<std::chrono::seconds>(ns);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(ns);
    auto us = std::chrono::duration_cast<std::chrono::microseconds>(ns);
 
    if (s > std::chrono::seconds::zero()) {
      oss << s.count() << "." << std::setfill('0') << std::setw(3) << (ms - s).count() << "s";
    } else if (ms > std::chrono::milliseconds::zero()) {
      oss << ms.count() << "." << std::setfill('0') << std::setw(3) << (us - ms).count() << "ms";
    } else if (us > std::chrono::microseconds::zero()) {
      oss << us.count() << "." << std::setfill('0') << std::setw(3) << (ns - us).count() << "us";
    } else {
      oss << std::setw(3) << ns.count() << "ns";
    }
    return oss.str();
  }
 
  static std::string colorFormatConvertor(hh::tool::PrintOptions::Color const &color) {
    std::ostringstream ss;
    ss << "#"
       << std::setw(2) << std::setfill('0') << std::hex << (int) color.r_
       << std::setw(2) << std::setfill('0') << std::hex << (int) color.g_
       << std::setw(2) << std::setfill('0') << std::hex << (int) color.b_
       << std::setw(2) << std::setfill('0') << std::hex << (int) color.a_;
 
    return ss.str();
  }
};
 
}
 
#endif //HEDGEHOG_DOT_PRINTER_H