any_groupable_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_ANY_COPYABLE_ABSTRACTION_H
#define HEDGEHOG_ANY_COPYABLE_ABSTRACTION_H
 
#include <cstddef>
#include <numeric>
#include <cmath>
#include <algorithm>
 
#include "node/task_node_abstraction.h"
 
namespace hh {
namespace core {
namespace abstraction {
 
class AnyGroupableAbstraction {
 private:
  size_t const numberThreads_ = 0; 
  AnyGroupableAbstraction *groupRepresentative_ = nullptr; 
  std::shared_ptr<std::set<AnyGroupableAbstraction *>> group_ = nullptr; 
 
 public:
  explicit AnyGroupableAbstraction(size_t const numberThreads) :
      numberThreads_(numberThreads),
      groupRepresentative_(this),
      group_(std::make_shared<std::set<AnyGroupableAbstraction *>>()) {
    group_->insert(this);
  }
 
  virtual ~AnyGroupableAbstraction() = default;
 
  [[nodiscard]] size_t numberThreads() const { return numberThreads_; }
 
  [[nodiscard]] bool isInGroup() const { return numberThreads_ != 1; }
 
  [[nodiscard]] std::string nodeId() const {
    if (auto thisAsNode = dynamic_cast<NodeAbstraction const *>(this)) {
      return thisAsNode->id();
    } else {
      throw std::runtime_error("A group representative should be a NodeAbstraction.");
    };
  }
 
  [[nodiscard]] std::shared_ptr<std::set<AnyGroupableAbstraction *>> const &group() const {
    return group_;
  }
 
  [[nodiscard]] std::shared_ptr<std::set<NodeAbstraction *>> groupAsNodes() const {
    auto ret = std::make_shared<std::set<NodeAbstraction *>>();
    for (auto copyable : *group_) {
      if (auto node = dynamic_cast<NodeAbstraction *>(copyable)) { ret->insert(node); }
    }
    return ret;
  }
 
  [[nodiscard]] AnyGroupableAbstraction *groupRepresentative() const { return groupRepresentative_; }
 
  [[nodiscard]] std::string groupRepresentativeId() const {
    if (auto representativeAsNode = dynamic_cast<NodeAbstraction const *>(groupRepresentative_)) {
      return representativeAsNode->id();
    } else {
      throw std::runtime_error("A group representative should be a NodeAbstraction.");
    };
  }
 
  void groupRepresentative(AnyGroupableAbstraction *groupRepresentative) { groupRepresentative_ = groupRepresentative; }
 
  void group(std::shared_ptr<std::set<AnyGroupableAbstraction *>> const &group) { group_ = group; }
 
  [[nodiscard]] size_t numberActiveThreadInGroup() const {
    size_t count = 0;
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      count = (size_t) std::count_if(
          this->group_->cbegin(), this->group_->cend(),
          [](auto nodeInGroup) {
            if (auto taskGroup = dynamic_cast<TaskNodeAbstraction const *>(nodeInGroup)) {
              return taskGroup->isActive();
            } else {
              throw std::runtime_error("All the nodes in a group should be of the same type: the representative is a "
                                       "TaskNodeAbstraction, but not the nodes in its group.");
            }
          }
      );
    };
 
    return count;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minmaxWaitDurationGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minMax =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
 
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      auto minMaxElem = std::minmax_element(
          this->group_->cbegin(), this->group_->cend(),
          [](auto lhs, auto rhs) {
            auto lhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(lhs);
            auto rhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(rhs);
            if (lhsAsTask && rhsAsTask) {
              return lhsAsTask->waitDuration() < rhsAsTask->waitDuration();
            } else {
              throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                       " type TaskNodeAbstraction but not the nodes in its group.");
            }
          }
      );
 
      auto minTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.first);
      auto maxTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.second);
      if (minTask && maxTask) {
        minMax = {minTask->waitDuration(), maxTask->waitDuration()};
      } else {
        throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                 " type TaskNodeAbstraction but not the nodes in its group.");
      }
    }
 
    return minMax;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSDWaitDurationGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSD =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      std::chrono::nanoseconds
          sum = std::chrono::nanoseconds::zero(),
          mean = std::chrono::nanoseconds::zero();
      double
          sd = 0;
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          sum += task->waitDuration();
        } else {
          throw std::runtime_error("All nodes in a group should be of the same type, the representative derives from "
                                   "TaskNodeAbstraction but not the group members.");
        }
      }
      mean = sum / (this->group_->size());
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          auto diff = (double) (task->waitDuration().count() - mean.count());
          sd += diff * diff;
        } else {
          throw std::runtime_error("All nodes in a group should be of the same type, the representative derives from "
                                   "TaskNodeAbstraction but not the group members.");
        }
      }
      meanSD = {
          mean,
          std::chrono::nanoseconds((int64_t) std::sqrt(sd / (double) this->group_->size()))};
    }
    return meanSD;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minmaxExecutionDurationGroup() const {
    auto groupAsNode = this->groupAsNodes();
    auto minMaxElem = std::minmax_element(
        groupAsNode->cbegin(), groupAsNode->cend(),
        [](auto lhs, auto rhs) {
          return lhs->executionDuration() < rhs->executionDuration();
        }
    );
    return {(*minMaxElem.first)->executionDuration(),
            (*minMaxElem.second)->executionDuration()};
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSDExecutionDurationGroup() const {
    auto groupAsNode = groupAsNodes();
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSD =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
 
    std::chrono::nanoseconds
        sum = std::chrono::nanoseconds::zero(),
        mean = std::chrono::nanoseconds::zero();
    double
        sd = 0;
 
    for (auto taskInGroup : *groupAsNode) {
      sum += taskInGroup->executionDuration();
    }
    mean = sum / (groupAsNode->size());
 
    for (auto taskInGroup : *groupAsNode) {
      sd += (double) (taskInGroup->executionDuration().count() - mean.count()) *
          (double) (taskInGroup->executionDuration().count() - mean.count());
    }
 
    meanSD = {mean, std::chrono::nanoseconds((int64_t) std::sqrt(sd / (double) groupAsNode->size()))};
 
    return meanSD;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minmaxExecTimePerElementGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minMax =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
 
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      auto minMaxElem = std::minmax_element(
          this->group_->cbegin(), this->group_->cend(),
          [](auto lhs, auto rhs) {
            auto lhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(lhs);
            auto rhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(rhs);
            if (lhsAsTask && rhsAsTask) {
              return lhsAsTask->perElementExecutionDuration() < rhsAsTask->perElementExecutionDuration();
            } else {
              throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                       " type TaskNodeAbstraction but not the group members.");
            }
          }
      );
 
      auto minTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.first);
      auto maxTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.second);
      if (minTask && maxTask) {
        minMax = {minTask->perElementExecutionDuration(), maxTask->perElementExecutionDuration()};
      } else {
        throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                 " type TaskNodeAbstraction but not the group members.");
      }
    }
    return minMax;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSDExecTimePerElementGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSD =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      std::chrono::nanoseconds
          sum = std::chrono::nanoseconds::zero(),
          mean = std::chrono::nanoseconds::zero();
      double
          sd = 0;
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          sum += task->perElementExecutionDuration();
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the group members.");
        }
      }
      mean = sum / (this->group_->size());
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          auto diff = (double) (task->perElementExecutionDuration().count() - mean.count());
          sd += diff * diff;
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the group members.");
        }
      }
      meanSD = {mean, std::chrono::nanoseconds((int64_t) std::sqrt(sd / (double) this->group_->size()))};
    }
    return meanSD;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minmaxMemoryWaitTimeGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> minMax =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      auto minMaxElem = std::minmax_element(
          this->group_->cbegin(), this->group_->cend(),
          [](auto lhs, auto rhs) {
            auto lhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(lhs);
            auto rhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(rhs);
            if (lhsAsTask && rhsAsTask) {
              return lhsAsTask->memoryWaitDuration() < rhsAsTask->memoryWaitDuration();
            } else {
              throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                       " type TaskNodeAbstraction but not the nodes in the group.");
            }
          }
      );
      auto minTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.first);
      auto maxTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.second);
      if (minTask && maxTask) {
        minMax = {minTask->memoryWaitDuration(), maxTask->memoryWaitDuration()};
      } else {
        throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                 " type TaskNodeAbstraction but not the nodes in the group.");
      }
    }
    return minMax;
  }
 
  [[nodiscard]] std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSDMemoryWaitTimePerElementGroup() const {
    std::pair<std::chrono::nanoseconds, std::chrono::nanoseconds> meanSD =
        {std::chrono::nanoseconds::zero(), std::chrono::nanoseconds::zero()};
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      std::chrono::nanoseconds
          sum = std::chrono::nanoseconds::zero(),
          mean = std::chrono::nanoseconds::zero();
      double
          sd = 0;
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          sum += task->memoryWaitDuration();
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the group members.");
        }
      }
      mean = sum / (this->group_->size());
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          auto diff = (double) (task->memoryWaitDuration().count() - mean.count());
          sd += diff * diff;
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the group members.");
        }
      }
      meanSD = {mean, std::chrono::nanoseconds((int64_t) std::sqrt(sd / (double) this->group_->size()))};
    }
    return meanSD;
  }
 
  [[nodiscard]] std::pair<size_t, size_t> minmaxNumberElementsReceivedGroup() const {
    std::pair<size_t, size_t> minMax = {0, 0};
 
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      auto minMaxElem = std::minmax_element(
          this->group_->cbegin(), this->group_->cend(),
          [](auto lhs, auto rhs) {
            auto lhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(lhs);
            auto rhsAsTask = dynamic_cast<TaskNodeAbstraction const *>(rhs);
            if (lhsAsTask && rhsAsTask) {
              return lhsAsTask->numberReceivedElements() < rhsAsTask->numberReceivedElements();
            } else {
              throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                       " type TaskNodeAbstraction but not the nodes in the group.");
            }
          }
      );
      auto minTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.first);
      auto maxTask = dynamic_cast<TaskNodeAbstraction *>(*minMaxElem.second);
      if (minTask && maxTask) {
        minMax = {minTask->numberReceivedElements(), maxTask->numberReceivedElements()};
      } else {
        throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                 " type TaskNodeAbstraction but not the nodes in the group.");
      }
    }
 
    return minMax;
  }
 
  [[nodiscard]] std::pair<double, double> meanSDNumberElementsReceivedGroup() const {
    std::pair<double, double> meanSD = {0, 0};
    if (dynamic_cast<TaskNodeAbstraction const *>(this)) {
      size_t sum = 0;
      double mean = 0, sd = 0;
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          sum += task->numberReceivedElements();
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the nodes in the group.");
        }
      }
      mean = (double) sum / (double) (this->group_->size());
 
      for (auto taskInGroup : *this->group_) {
        auto task = dynamic_cast<TaskNodeAbstraction *>(taskInGroup);
        if (task) {
          auto diff = (double) task->numberReceivedElements() - mean;
          sd += diff * diff;
        } else {
          throw std::runtime_error("All the nodes in a group should be of the same type, the representative is of"
                                   " type TaskNodeAbstraction but not the nodes in the group.");
        }
      }
 
      meanSD = {mean, std::sqrt(sd / (double) this->group_->size())};
    }
    return meanSD;
  }
 
  virtual void createGroup(std::map<NodeAbstraction *, std::vector<NodeAbstraction *>> &) = 0;
};
}
}
}
#endif //HEDGEHOG_ANY_COPYABLE_ABSTRACTION_H