task_node_abstraction.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_TASK_NODE_ABSTRACTION_H
#define HEDGEHOG_TASK_NODE_ABSTRACTION_H
 
#include <ostream>
#include "node_abstraction.h"
#include "../../../../api/memory_manager/manager/abstract_memory_manager.h"
#include "../../../../tools/nvtx_profiler.h"
#include "../printable_abstraction.h"
 
namespace hh {
namespace core {
namespace abstraction {
 
class TaskNodeAbstraction : public NodeAbstraction, public PrintableAbstraction {
 private:
  size_t numberReceivedElements_ = 0; 
  bool
      isActive_ = false, 
  isInitialized_ = false; 
 
  std::chrono::nanoseconds
      perElementExecutionDuration_ = std::chrono::nanoseconds::zero(), 
  waitDuration_ = std::chrono::nanoseconds::zero(), 
  memoryWaitDuration_ = std::chrono::nanoseconds::zero(); 
 
  std::shared_ptr<NvtxProfiler>
      nvtxProfiler_ = nullptr; 
 
  behavior::Node *
      node_ = nullptr; 
 
 public:
  explicit TaskNodeAbstraction(std::string const &name, behavior::Node *node) : NodeAbstraction(name), node_(node) {
    nvtxProfiler_ = std::make_shared<NvtxProfiler>(name);
  }
 
  ~TaskNodeAbstraction() override = default;
 
  [[nodiscard]] bool isActive() const { return isActive_; }
 
  [[nodiscard]] bool isInitialized() const {
    return isInitialized_;
  }
 
  [[nodiscard]] size_t numberReceivedElements() const { return numberReceivedElements_; }
 
  [[nodiscard]] std::chrono::nanoseconds const &waitDuration() const { return waitDuration_; }
 
  [[nodiscard]] std::chrono::nanoseconds const &memoryWaitDuration() const { return memoryWaitDuration_; }
 
  [[nodiscard]] std::shared_ptr<NvtxProfiler> const &nvtxProfiler() const { return nvtxProfiler_; }
 
  [[nodiscard]] std::chrono::nanoseconds perElementExecutionDuration() const {
    return
        this->numberReceivedElements() == 0 ?
        std::chrono::nanoseconds::zero() :
        (std::chrono::nanoseconds) (perElementExecutionDuration_ / this->numberReceivedElements());
  }
 
  void isActive(bool isActive) { isActive_ = isActive; }
 
  void incrementNumberReceivedElements() { ++this->numberReceivedElements_; }
 
  void incrementWaitDuration(std::chrono::nanoseconds const &wait) { this->waitDuration_ += wait; }
 
  void incrementMemoryWaitDuration(std::chrono::nanoseconds const &wait) { this->memoryWaitDuration_ += wait; }
 
  void incrementPerElementExecutionDuration(std::chrono::nanoseconds const &exec) {
    this->perElementExecutionDuration_ += exec;
  }
 
  virtual void preRun() = 0;
 
  virtual void run() = 0;
 
  virtual void postRun() = 0;
 
  [[nodiscard]] virtual std::string extraPrintingInformation() const = 0;
 
  [[nodiscard]] virtual bool hasMemoryManagerAttached() const = 0;
 
  [[nodiscard]] virtual std::shared_ptr<AbstractMemoryManager> memoryManager() const = 0;
 
  [[nodiscard]] behavior::Node *node() const override { return node_; }
 
 protected:
  void setInitialized() { isInitialized_ = true; }
};
}
}
}
#endif //HEDGEHOG_TASK_NODE_ABSTRACTION_H