AbstractNode.h

Go to the documentation of this file.

/*
 * Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM
 */
 
#pragma once
 
#include <tvm/api.h>
 
#include <tvm/graph/internal/Inputs.h>
 
#include <cassert>
#include <functional>
#include <vector>
 
namespace tvm
{
 
namespace graph
{
 
class CallGraph;
 
namespace abstract
{
template<typename T>
class Node;
}
 
namespace internal
{
 
class AbstractNode : public Inputs, public abstract::Outputs
{
public:
  template<typename T>
  friend class tvm::graph::abstract::Node;
 
  friend class tvm::graph::CallGraph;
 
  enum class Update_
  {
  };
  struct Update
  {};
 
  static constexpr unsigned int UpdateSize = 0;
 
  using UpdateParent = AbstractNode;
 
  using UpdateBase = AbstractNode;
 
  static constexpr auto UpdateBaseName = "AbstractNode";
 
  static constexpr const char * UpdateName(Update_) { return "INVALID"; }
 
  template<typename EnumT>
  bool isUpdateEnabled(EnumT e) const
  {
    int i = static_cast<int>(e);
    return isUpdateStaticallyEnabled(i) && isUpdateCustomEnabled(i);
  }
 
  virtual bool isUpdateStaticallyEnabled(int) const { return true; }
 
  virtual bool isUpdateCustomEnabled(int) const { return true; }
 
  template<typename EnumT>
  static constexpr bool UpdateStaticallyEnabled(EnumT)
  { return true; }
 
  virtual ~AbstractNode() = default;
 
  inline void update(int i)
  {
    assert(updates_.count(i));
    updates_[i](*this);
  }
 
protected:
  std::map<int, std::function<void(AbstractNode &)>> updates_;
 
  std::map<int, std::vector<int>> outputDependencies_;
  std::map<int, std::vector<int>> internalDependencies_;
  using input_dependency_t = std::map<Outputs *, std::set<int>>;
  std::map<int, input_dependency_t> inputDependencies_;
  std::map<int, std::pair<Outputs *, int>> directDependencies_;
 
private:
  AbstractNode() { is_node_ = true; }
};
 
#define SET_UPDATES(SelfT, ...) PP_ID(EXTEND_ENUM(Update, SelfT, __VA_ARGS__))
 
#define DISABLE_UPDATES(...) PP_ID(DISABLE_SIGNALS(Update, __VA_ARGS__))
 
#define CLEAR_DISABLED_UPDATES() PP_ID(CLEAR_DISABLED_SIGNALS(Update))
 
template<typename T, typename EnumT>
constexpr bool is_valid_update(EnumT v)
{
  static_assert(std::is_base_of<AbstractNode, T>::value,
                "Cannot test update validity for a type that is not derived of Updates");
  static_assert(std::is_enum<EnumT>::value, "Cannot test update validity for a value that is not an enumeration");
  return std::is_same<typename T::Update_, EnumT>::value
         || ((!std::is_same<typename T::UpdateParent, typename T::UpdateBase>::value)
             && is_valid_update<typename T::UpdateParent>(v));
}
 
template<typename T, typename EnumT, typename... Args>
constexpr bool is_valid_update(EnumT v, Args... args)
{ return is_valid_update<T>(v) && is_valid_update<T>(args...); }
 
} // namespace internal
 
} // namespace graph
 
} // namespace tvm