Outputs.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/api.h>
 
#include <tvm/internal/enums.h>
 
#include <type_traits>
 
namespace tvm
{
 
namespace graph
{
 
class CallGraph;
 
namespace abstract
{
 
class TVM_DLLAPI Outputs
{
public:
  friend class tvm::graph::CallGraph;
 
  virtual ~Outputs() = default;
 
  enum class Output_
  {
  };
  struct Output
  {};
 
  static constexpr unsigned int OutputSize = 0;
 
  using OutputParent = Outputs;
 
  using OutputBase = Outputs;
 
  static constexpr auto OutputBaseName = "Outputs";
 
  static constexpr const char * OutputName(Output_) { return "INVALID"; }
 
  template<typename EnumT>
  bool isOutputEnabled(EnumT e) const
  {
    // FIXME is there a way to check that the enum has the good type here ?
    int i = static_cast<int>(e);
    return isOutputEnabled(i);
  }
 
  bool isOutputEnabled(int i) const { return isOutputStaticallyEnabled(i) && isOutputCustomEnabled(i); }
 
  virtual bool isOutputStaticallyEnabled(int) const { return true; }
 
  virtual bool isOutputCustomEnabled(int) const { return true; }
 
  template<typename EnumT>
  static constexpr bool OutputStaticallyEnabled(EnumT)
  { return true; }
 
protected:
  bool is_node_ = false;
};
 
#define SET_OUTPUTS(SelfT, ...) PP_ID(EXTEND_ENUM(Output, SelfT, __VA_ARGS__))
 
#define DISABLE_OUTPUTS(...) PP_ID(DISABLE_SIGNALS(Output, __VA_ARGS__))
 
#define CLEAR_DISABLED_OUTPUTS() PP_ID(CLEAR_DISABLED_SIGNALS(Output))
 
template<typename T, typename EnumT>
constexpr bool is_valid_output(EnumT v)
{
  static_assert(std::is_base_of<Outputs, T>::value,
                "Cannot test output validity for a type that is not derived of Outputs");
  static_assert(std::is_enum<EnumT>::value, "Cannot test output validity for a value that is not an enumeration");
  return std::is_same<typename T::Output_, EnumT>::value
         || ((!std::is_same<typename T::OutputParent, typename T::OutputBase>::value)
             && is_valid_output<typename T::OutputParent>(v));
}
 
template<typename T, typename EnumT, typename... Args>
constexpr bool is_valid_output(EnumT v, Args... args)
{ return is_valid_output<T>(v) && is_valid_output<T>(args...); }
 
} // namespace abstract
 
} // namespace graph
 
} // namespace tvm