core_node.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_CORE_NODE_H
#define HEDGEHOG_CORE_NODE_H

#include <iostream>
#include <sstream>
#include <memory>
#include <map>
#include <set>
#include <chrono>
#include <cmath>
#include <vector>

#include "../../api/printer/abstract_printer.h"
#include "../../behavior/node.h"
#include "../../tools/logger.h"

namespace hh::core {

enum struct NodeType { Graph, Task, StateManager, Sink, Source, ExecutionPipeline, Switch };

#ifndef DOXYGEN_SHOULD_SKIP_THIS
class CoreSlot;
#endif //DOXYGEN_SHOULD_SKIP_THIS

class CoreNode {
 private:
  bool
      isInside_ = false, 
      hasBeenRegistered_ = false, 
      isCudaRelated_ = false, 
      isInCluster_ = false, 
      isActive_ = false; 

  int threadId_ = 0; 

  size_t numberThreads_ = 1; 

  std::string_view name_ = ""; 

  NodeType const type_; 

  CoreNode
      *belongingNode_ = nullptr, 
      *coreClusterNode_ = nullptr; 

  std::shared_ptr<std::multimap<CoreNode *, std::shared_ptr<CoreNode>>>
      insideNodes_ = nullptr; 

  std::chrono::duration<uint64_t, std::micro>
      creationDuration_ = std::chrono::duration<uint64_t, std::micro>::zero(), 
      executionDuration_ = std::chrono::duration<uint64_t, std::micro>::zero(), 
      waitDuration_ = std::chrono::duration<uint64_t, std::micro>::zero(), 
      memoryWaitDuration_ = std::chrono::duration<uint64_t, std::micro>::zero(); 

  std::chrono::time_point<std::chrono::high_resolution_clock> const
      creationTimeStamp_ = std::chrono::high_resolution_clock::now(); 

  std::chrono::time_point<std::chrono::high_resolution_clock>
      startExecutionTimeStamp_ = std::chrono::high_resolution_clock::now(); 

 public:
  CoreNode() = delete;

  CoreNode(std::string_view const &name, NodeType const type, size_t numberThreads)
      : isActive_(false), name_(name), type_(type), coreClusterNode_(this) {
    numberThreads_ = numberThreads == 0 ? 1 : numberThreads;
    HLOG_SELF(0,
              "Creating CoreNode with type: " << (int) type << ", name: " << name << " and number of Threads: "
                                              << this->numberThreads_)
    this->insideNodes_ = std::make_shared<std::multimap<CoreNode *, std::shared_ptr<CoreNode>>>();
  }

  virtual ~CoreNode() {
    HLOG_SELF(0, "Destructing CoreNode")
  }

  virtual std::shared_ptr<CoreNode> clone() = 0;  // Virtual constructor (copying)

  // Accessor

  [[nodiscard]] virtual std::string id() const {
    std::stringstream ss{};
    ss << "x" << this;
    return ss.str();
  }

  [[nodiscard]] virtual std::vector<std::pair<std::string, std::string>> ids() const {
    return {{this->id(), this->coreClusterNode()->id()}};
  }

  [[nodiscard]] std::string_view const &name() const { return name_; }

  [[nodiscard]] NodeType type() const { return type_; }

  [[nodiscard]] bool isInside() const { return isInside_; }

  [[nodiscard]] bool hasBeenRegistered() const { return hasBeenRegistered_; }

  [[nodiscard]] CoreNode *coreClusterNode() const { return coreClusterNode_; }

  [[nodiscard]] int threadId() const { return threadId_; }

  [[nodiscard]] size_t numberThreads() const { return numberThreads_; }

  [[nodiscard]] CoreNode *belongingNode() const { return belongingNode_; }

  [[nodiscard]] std::shared_ptr<std::multimap<CoreNode *,
                                              std::shared_ptr<CoreNode>>> const &insideNodes() const {
    return insideNodes_;
  }

  [[nodiscard]] std::shared_ptr<std::multimap<CoreNode *, std::shared_ptr<CoreNode>>> &insideNodes() {
    return insideNodes_;
  }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> const &executionTime() const { return executionDuration_; }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> const &waitTime() const { return waitDuration_; }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> const &memoryWaitTime() const {
    return memoryWaitDuration_;
  }

  [[nodiscard]] bool isInCluster() const { return this->isInCluster_; }

  [[nodiscard]] bool isActive() const { return isActive_; }

  [[nodiscard]] bool isCudaRelated() const { return isCudaRelated_; }

  [[nodiscard]] virtual int graphId() { return this->belongingNode()->graphId(); }

  [[nodiscard]] virtual int deviceId() { return this->belongingNode()->deviceId(); }

  [[nodiscard]] virtual std::chrono::duration<uint64_t, std::micro> maxExecutionTime() const {
    return this->executionDuration_;
  }

  [[nodiscard]] virtual std::chrono::duration<uint64_t, std::micro> minExecutionTime() const {
    return this->executionDuration_;
  }

  [[nodiscard]] virtual std::chrono::duration<uint64_t, std::micro> maxWaitTime() const { return this->waitDuration_; }

  [[nodiscard]] virtual std::chrono::duration<uint64_t, std::micro> minWaitTime() const { return this->waitDuration_; }

  [[nodiscard]] std::chrono::time_point<std::chrono::high_resolution_clock> const &creationTimeStamp() const {
    return creationTimeStamp_;
  }

  [[nodiscard]] std::chrono::time_point<std::chrono::high_resolution_clock> const &startExecutionTimeStamp() const {
    return startExecutionTimeStamp_;
  }

  [[nodiscard]] std::chrono::duration<uint64_t,
                                      std::micro> const &creationDuration() const { return creationDuration_; }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> const &executionDuration() const {
    return executionDuration_;
  }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> meanExecTimeCluster() const {
    auto ret = this->executionTime();
    if (this->isInCluster()) {
      std::chrono::duration<uint64_t, std::micro> sum = std::chrono::duration<uint64_t, std::micro>::zero();
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        sum += it->second->executionTime();
      }
      ret = sum / this->numberThreads();
    }
    return ret;
  }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> meanWaitTimeCluster() const {
    auto ret = this->waitTime();
    if (this->isInCluster()) {
      std::chrono::duration<uint64_t, std::micro> sum = std::chrono::duration<uint64_t, std::micro>::zero();
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        sum += it->second->waitTime();
      }
      ret = sum / this->numberThreads();
    }
    return ret;
  }

  [[nodiscard]] std::chrono::duration<uint64_t, std::micro> meanMemoryWaitTimeCluster() const {
    auto ret = this->memoryWaitTime();
    if (this->isInCluster()) {
      std::chrono::duration<uint64_t, std::micro> sum = std::chrono::duration<uint64_t, std::micro>::zero();
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        sum += it->second->memoryWaitTime();
      }
      ret = sum / this->numberThreads();
    }
    return ret;
  }

  [[nodiscard]] uint64_t stdvExecTimeCluster() const {
    auto ret = 0;
    if (this->isInCluster()) {
      auto mean = this->meanExecTimeCluster().count(), meanSquare = mean * mean;
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        ret += (uint64_t) std::pow(it->second->executionTime().count(), 2) - meanSquare;
      }
      ret /= this->numberThreads();
      ret = (uint64_t) std::sqrt(ret);
    }
    return ret;
  }

  [[nodiscard]] uint64_t stdvWaitTimeCluster() const {
    auto ret = 0;
    if (this->isInCluster()) {
      auto mean = this->meanWaitTimeCluster().count(), meanSquare = mean * mean;
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        ret += (uint64_t) std::pow(it->second->waitTime().count(), 2) - meanSquare;
      }
      ret /= this->numberThreads();
      ret = (uint64_t) std::sqrt(ret);
    }
    return ret;
  }

  [[nodiscard]] uint64_t stdvMemoryWaitTimeCluster() const {
    auto ret = 0;
    if (this->isInCluster()) {
      auto mean = this->meanMemoryWaitTimeCluster().count(), meanSquare = mean * mean;
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        ret += (uint64_t) std::pow(it->second->memoryWaitTime().count(), 2) - meanSquare;
      }
      ret /= this->numberThreads();
      ret = (uint64_t) std::sqrt(ret);
    }
    return ret;
  }

  [[nodiscard]] std::pair<uint64_t, uint64_t> minmaxWaitTimeCluster() const {
    uint64_t min = std::numeric_limits<uint64_t>::max();
    uint64_t max = 0;
    uint64_t val = 0;
    if (this->isInCluster()) {
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        val = it->second->waitTime().count();
        if (val < min) { min = val; }
        if (val > max) { max = val; }
      }
    } else {
      min = this->meanWaitTimeCluster().count();
      max = min;
    }
    return {min, max};
  }

  [[nodiscard]] std::pair<uint64_t, uint64_t> minmaxMemoryWaitTimeCluster() const {
    uint64_t min = std::numeric_limits<uint64_t>::max();
    uint64_t max = 0;
    uint64_t val = 0;
    if (this->isInCluster()) {
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        val = it->second->memoryWaitTime().count();
        if (val < min) { min = val; }
        if (val > max) { max = val; }
      }
    } else {
      min = this->meanMemoryWaitTimeCluster().count();
      max = min;
    }
    return {min, max};
  }

  [[nodiscard]] std::pair<uint64_t, uint64_t> minmaxExecTimeCluster() const {
    uint64_t min = std::numeric_limits<uint64_t>::max();
    uint64_t max = 0;
    uint64_t val = 0;
    if (this->isInCluster()) {
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        val = it->second->executionTime().count();
        if (val < min) { min = val; }
        if (val > max) { max = val; }
      }
    } else {
      min = this->meanExecTimeCluster().count();
      max = min;
    }

    return {min, max};
  }

  [[nodiscard]] size_t numberActiveThreadInCluster() const {
    size_t ret = 0;
    if (this->isInCluster()) {
      for (auto it = this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).first;
           it != this->belongingNode()->insideNodes()->equal_range(this->coreClusterNode()).second; ++it) {
        ret += it->second->isActive() ? 1 : 0;
      }
    } else {
      ret = this->isActive() ? 1 : 0;
    }
    return ret;
  }

  [[nodiscard]] virtual std::string extraPrintingInformation() { return node()->extraPrintingInformation(); }

  // Setter
  void startExecutionTimeStamp(
      std::chrono::time_point<std::chrono::high_resolution_clock> const &startExecutionTimeStamp) {
    startExecutionTimeStamp_ = startExecutionTimeStamp;
  }
  virtual void deviceId(int deviceId) { this->belongingNode()->deviceId(deviceId); }

  virtual void setInside() { this->isInside_ = true; }

  void setInCluster() { this->isInCluster_ = true; }

  void threadId(uint8_t threadId) { threadId_ = threadId; }

  void coreClusterNode(CoreNode *coreClusterNode) { coreClusterNode_ = coreClusterNode; }

  void name(std::string_view const &name) { name_ = name; }

  void numberThreads(size_t numberThreads) { numberThreads_ = numberThreads; }

  void belongingNode(CoreNode *belongingNode) { belongingNode_ = belongingNode; }

  void hasBeenRegistered(bool hasBeenRegistered) { hasBeenRegistered_ = hasBeenRegistered; }

  void isActive(bool isActive) { isActive_ = isActive; }

  void isCudaRelated(bool isCudaRelated) { isCudaRelated_ = isCudaRelated; }

  void isInside(bool isInside) { isInside_ = isInside; }

  void creationDuration(std::chrono::duration<uint64_t, std::micro> const &creationDuration) {
    creationDuration_ = creationDuration;
  }

  void executionDuration(std::chrono::duration<uint64_t, std::micro> const &executionDuration) {
    executionDuration_ = executionDuration;
  }

  void incrementWaitForMemoryDuration(std::chrono::duration<uint64_t, std::micro> const &memoryWait) {
    this->memoryWaitDuration_ += memoryWait;
  }

  // Virtual
  virtual void preRun() {}

  virtual void run() {}

  virtual void postRun() {}

  virtual void createCluster(std::shared_ptr<std::multimap<CoreNode *, std::shared_ptr<CoreNode>>> &) {};

  virtual void joinThreads() {}

  virtual void duplicateEdge(
      CoreNode *duplicateNode, std::map<CoreNode *, std::shared_ptr<CoreNode>> &correspondenceMap) = 0;

  virtual behavior::Node *node() = 0;

  virtual void visit(AbstractPrinter *printer) = 0;

  virtual std::set<CoreSlot *> getSlots() = 0;

  // Public method
  void removeInsideNode(CoreNode *coreNode) {
    HLOG_SELF(0, "Remove inside node " << coreNode->id() << ")")
    this->insideNodes()->erase(coreNode);
  }


  void copyInnerStructure(CoreNode *rhs) {
    this->isInside_ = rhs->isInside();
    this->belongingNode_ = rhs->belongingNode();
    this->hasBeenRegistered_ = rhs->hasBeenRegistered();
    this->isInCluster_ = rhs->isInCluster();
    this->isCudaRelated_ = rhs->isCudaRelated();
    this->numberThreads_ = rhs->numberThreads();
    this->coreClusterNode(rhs->coreClusterNode());
  }

 protected:
  void addUniqueInsideNode(const std::shared_ptr<CoreNode> &coreNode) {
    HLOG_SELF(0, "Add InsideNode " << coreNode->name() << "(" << coreNode->id() << ")")
    if (insideNodes_->find(coreNode.get()) == insideNodes_->end()) {
      coreNode->belongingNode(this);
      coreNode->hasBeenRegistered(true);
      insideNodes_->insert({coreNode.get(), coreNode});
    }
  }

  void incrementWaitDuration(std::chrono::duration<uint64_t, std::micro> const &wait) { this->waitDuration_ += wait; }

  void incrementExecutionDuration(std::chrono::duration<uint64_t, std::micro> const &exec) {
    this->executionDuration_ += exec;
  }
};

}
#endif //HEDGEHOG_CORE_NODE_H