operation.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
 
#ifndef CORE_OPERATION_OPERATION_H_
#define CORE_OPERATION_OPERATION_H_
 
#include <cstdint>
#include <functional>
#include <set>
#include <string>
#include <vector>
 
#include "core/functor.h"
#include "core/util/log.h"
 
namespace bdm {
 
class Agent;
 
enum OpComputeTarget { kCpu, kCuda, kOpenCl };
 
inline std::string OpComputeTargetString(OpComputeTarget t) {
  switch (t) {
    case OpComputeTarget::kCpu:
      return "kCpu";
    case OpComputeTarget::kCuda:
      return "kCuda";
    case OpComputeTarget::kOpenCl:
      return "kOpenCl";
    default:
      return "Invalid";
  }
}
 
struct OperationImpl {
  virtual ~OperationImpl() = default;
 
  virtual void SetUp() {}
 
  virtual void TearDown() {}
 
  virtual void operator()(Agent *agent) = 0;
 
  virtual void operator()() = 0;
 
  virtual OperationImpl *Clone() = 0;
 
  bool IsGpuOperation() const { return target_ == kCuda || target_ == kOpenCl; }
 
  virtual bool IsStandalone() = 0;
 
  OpComputeTarget target_ = kCpu;
};
 
struct AgentOperationImpl : public OperationImpl {
  void operator()() override {
    Log::Fatal("AgentOperationImpl",
               "AgentOperationImpl do not support this function operator");
  }
 
  bool IsStandalone() override { return false; }
};
 
struct StandaloneOperationImpl : public OperationImpl {
  void operator()(Agent *agent) override {
    Log::Fatal("StandaloneOperationImpl",
               "StandaloneOperationImpl do not support this function operator");
  }
 
  bool IsStandalone() override { return true; }
};
 
struct Operation {
  explicit Operation(const std::string &name);
 
  Operation(const std::string &name, uint32_t frequency);
 
  ~Operation();
 
  Operation *Clone();
 
  void operator()(Agent *agent);
 
  void operator()();
 
  void AddOperationImpl(OpComputeTarget target, OperationImpl *impl);
 
  template <typename T>
  T *GetImplementation() {
    T *implementation = nullptr;
    // Go over the available implementations and return the requested one
    for (auto *imp : implementations_) {
      if (dynamic_cast<T *>(imp)) {
        implementation = dynamic_cast<T *>(imp);
      }
    }
    return implementation;
  }
 
  bool IsComputeTargetSupported(OpComputeTarget target);
 
  void SelectComputeTarget(OpComputeTarget target);
 
  bool IsStandalone() {
    return implementations_[active_target_]->IsStandalone();
  }
 
  void SetUp();
 
  void TearDown();
 
  bool IsExcluded(Functor<bool, Agent *> *filter) {
    if (filter == nullptr) {
      return false;
    }
    return exclude_filters_.find(filter) != exclude_filters_.end();
  }
 
  void SetExcludeFilters(
      const std::set<Functor<bool, Agent *> *> &exclude_filters) {
    exclude_filters_ = exclude_filters;
  }
 
  size_t frequency_ = 1;
  std::string name_;
  OpComputeTarget active_target_ = kCpu;
  std::vector<OperationImpl *> implementations_;
 
  std::set<Functor<bool, Agent *> *> exclude_filters_;
};
 
}  // namespace bdm
 
#endif  // CORE_OPERATION_OPERATION_H_