Support Backend Specific Verifiers (#3469)

Summary:
Adds support for backend-specific verifiers to Glow.
I removed the asserts in the backend specific code when executing Nodes with components that depend on the backend for validity and added verifiers to take their place.
There are two backend-specific verifiers: one that works on `Function` and one that takes in `IRFunction` - this allows verification at different stages of the Glow pipeline.
I also added two error types: one that indicates a verification error at initial IR generation (`COMPILE_UNSUPPORTED_IR_AFTER_GENERATE`) and one that indicates the faulty code appeared after IR optimizations (`COMPILE_UNSUPPORTED_IR_AFTER_OPTIMIZE`).
I also refactored the code, such that Graph Optimizer does not check that all nodes are supported directly, that should not be its job, it calls the verifier instead. The base method for the `Function` verifier does said check.

Fixes #3450
Pull Request resolved: #3469

Test Plan: `ninja test`

Differential Revision: D17128493

Pulled By: shajrawi

fbshipit-source-id: d917bca05cf343f2395346fda48e54194fe41dc6

Author: shajrawi

docs/Backends.md

@@ -65,6 +65,14 @@ Additionally, there are virtual functions that backends can override:
     [below](#backend-specific-nodes-and-instructions-transformations) for more
     information.
 
+- `virtual bool verify(const Function &F) const;`
+
+  - Verifies that `Function &F` conforms to the backend-dependent graph constraints.
+
+- `virtual bool verify(const IRFunction &IR) const;`
+
+  - Verifies that `IRFunction &IR` conforms to the backend-specific constraints.
+
 - `virtual bool shouldLower(const Node *N) const;`
 
   - Allow the backend to prevent lowering for some `Node *N`. For example, if a

include/glow/Backend/Backend.h

@@ -98,6 +98,29 @@ class Backend {
   /// \returns whether the provided \p NI is supported by the backend.
   virtual bool isOpSupported(const NodeInfo &NI) const = 0;
 
+  /// \returns whether all nodes inside \p F are supported.
+  bool checkAllNodesSupported(const Function &F) const;
+
+  /// \returns whether the provided \p F conforms to the backend-dependent graph
+  /// constraints. Giving the backend an opportunity to check that everything
+  /// conforms to its specific restrictions by overriding this function. It is
+  /// highly recommended for backends to make their backend specific
+  /// verifications a super-set of target independent Function::verify() by
+  /// calling it in their overridden implementation. It is not a strict
+  /// requirement, of course, in case they diverge / the backend has a good
+  /// reason not to call Function::verify().
+  virtual bool verify(const Function &F) const;
+
+  /// \returns whether the provided \p IR conforms to the backend-dependent
+  /// graph constraints. Giving the backend an opportunity to check that
+  /// everything conforms to its specific restrictions by overriding this
+  /// function. It is highly recommended for backends to make their backend
+  /// specific verifications a super-set of target independent
+  /// IRFunction::verify() by calling it in their overridden implementation. It
+  /// is not a strict requirement, of course, in case they diverge / the backend
+  /// has a good reason not to call IRFunction::verify().
+  virtual bool verify(const IRFunction &IR) const;
+
   /// \returns true if the supplied Node \N should be lowered. By default, all
   /// Nodes are candidates for lowering.
   virtual bool shouldLower(const Node *N) const { return true; }

include/glow/Backend/BackendUtils.h

@@ -149,6 +149,28 @@ class RuntimeBundle {
 };
 } // namespace runtime
 
+/// Generates a struct named has_\p METHOD_NAME that looks for a method called
+/// \p METHOD_NAME inside of ClassName with return type ReturnType.
+#define CLASS_CONTAINS_METHOD(METHOD_NAME)                                     \
+  template <typename ClassName, typename ReturnType>                           \
+  struct has_##METHOD_NAME {                                                   \
+  private:                                                                     \
+    template <typename T>                                                      \
+    static constexpr auto check(T *) ->                                        \
+        typename std::is_same<decltype(std::declval<T>().METHOD_NAME()),       \
+                              ReturnType>::type;                               \
+    template <typename> static constexpr std::false_type check(...);           \
+    typedef decltype(check<ClassName>(0)) type;                                \
+                                                                               \
+  public:                                                                      \
+    static constexpr bool value = type::value;                                 \
+  };
+
+/// Use template meta-programming to check if typename ClassName contains
+/// getFusedActivation() method. Below generates a struct named
+/// has_getFusedActivation that looks for said method.
+CLASS_CONTAINS_METHOD(getFusedActivation)
+
 /// If \p PH is an output placeholder in the Function \p F,
 /// \returns true.
 /// This is determined by checking if the PH has a user which uses the PH as an
@@ -173,6 +195,34 @@ bool isOutput(const Placeholder *PH, const IRFunction &F);
 /// by the current function.
 bool isInput(const Placeholder *PH, const IRFunction &F);
 
+/// If \p N does not have fused activation \returns true.
+template <typename T,
+          std::enable_if_t<!has_getFusedActivation<T, FusedActivation>::value,
+                           int> = 0>
+bool checkNoFusion(const T &N) {
+  (void)N;
+  return true;
+}
+
+/// If \p N does not have fused activation \returns true.
+template <typename T,
+          std::enable_if_t<has_getFusedActivation<T, FusedActivation>::value,
+                           int> = 0>
+bool checkNoFusion(const T &N) {
+  if (N.getFusedActivation() != FusedActivation::NONE) {
+    report("Glow backend does not support fused Activations for: " +
+           std::string(N.getKindName()));
+    return false;
+  }
+  return true;
+}
+
+/// If \p N does not have fused activation \returns true.
+bool checkNoFusionForNode(const Node &N);
+
+/// If \p I does not have fused activation \returns true.
+bool checkNoFusionForInstr(const Instruction &I);
+
 /// Contains information for placeholder during allocation.
 struct PlaceholderInputOutputInfo {
   /// The placeholder address.

include/glow/Optimizer/GraphOptimizer/PassManager.h

@@ -16,6 +16,8 @@
 #ifndef GLOW_OPTIMIZER_GRAPHOPTIMIZER_PASSMANAGER_H
 #define GLOW_OPTIMIZER_GRAPHOPTIMIZER_PASSMANAGER_H
 
+#include "glow/Backend/Backend.h"
+
 #include "glow/Optimizer/GraphOptimizer/CompilationContext.h"
 #include "glow/Optimizer/GraphOptimizer/FunctionPass.h"
 #include "glow/Optimizer/GraphOptimizer/FunctionPasses.h"
@@ -34,6 +36,9 @@ class FunctionPassManager : public Named {
   /// The pipeline of passes to run.
   FunctionPassPipeline pipeline_;
 
+  /// The Backend we have for backend-specific verification.
+  const Backend *backend_;
+
   /// The index of the current pass being executed in the pipeline.
   size_t passIdx_ = 0;
 
@@ -55,8 +60,9 @@ class FunctionPassManager : public Named {
                const CompilationContext &cctx);
 
 public:
-  FunctionPassManager(llvm::StringRef name, FunctionPassPipeline pipeline)
-      : Named(name), pipeline_(pipeline), passIdx_(0) {}
+  FunctionPassManager(llvm::StringRef name, FunctionPassPipeline pipeline,
+                      const Backend *backend = nullptr)
+      : Named(name), pipeline_(pipeline), backend_(backend), passIdx_(0) {}
   ~FunctionPassManager() = default;
 
   /// Run the FunctionPassPipeline given the \ref pipeline_ and

include/glow/Support/Error.h

@@ -89,6 +89,10 @@ class GlowErr final : public llvm::ErrorInfo<GlowErr> {
     MODEL_WRITER_INVALID_FILENAME,
     // Model writer cannot serialize graph to the file.
     MODEL_WRITER_SERIALIZATION_ERROR,
+    // Compilation error; IR unsupported after generation.
+    COMPILE_UNSUPPORTED_IR_AFTER_GENERATE,
+    // Compilation error; IR unsupported after optimization.
+    COMPILE_UNSUPPORTED_IR_AFTER_OPTIMIZE,
   };
 
   /// GlowErr is not convertable to std::error_code. This is included for
@@ -164,6 +168,10 @@ class GlowErr final : public llvm::ErrorInfo<GlowErr> {
       return "MODEL_WRITER_INVALID_FILENAME";
     case ErrorCode::MODEL_WRITER_SERIALIZATION_ERROR:
       return "MODEL_WRITER_SERIALIZATION_ERROR";
+    case ErrorCode::COMPILE_UNSUPPORTED_IR_AFTER_GENERATE:
+      return "COMPILE_UNSUPPORTED_IR_AFTER_GENERATE";
+    case ErrorCode::COMPILE_UNSUPPORTED_IR_AFTER_OPTIMIZE:
+      return "COMPILE_UNSUPPORTED_IR_AFTER_OPTIMIZE";
     };
 
     llvm_unreachable("unsupported ErrorCode");

lib/Backend/Backend.cpp

@@ -157,6 +157,28 @@ void Backend::autoInstrument(TraceInfo &traceInfo, IRFunction *IR) const {
   IR->pushInstr(new TraceEventInst("end_trace", backingWeight, index));
 }
 
+bool Backend::checkAllNodesSupported(const Function &F) const {
+  bool allSupported = true;
+  for (const Node &N : F.getNodes()) {
+    if (!isOpSupported(N)) {
+      allSupported = false;
+      report("Unsupported node found while compiling Function " +
+             F.getName().str() + " for backend " + getBackendName() + ": " +
+             N.getDebugDesc());
+    }
+  }
+  return allSupported;
+}
+
+bool Backend::verify(const Function &F) const {
+  return F.verify() && checkAllNodesSupported(F);
+}
+
+bool Backend::verify(const IRFunction &IR) const {
+  (void)IR;
+  return true;
+}
+
 FunctionPassPipeline Backend::getOptimizationPipeline() const {
   return createDefaultGraphOptimizationPassPipeline();
 };

lib/Backend/BackendUtils.cpp

@@ -349,6 +349,45 @@ bool isInput(const Placeholder *PH,
   return false;
 }
 
+/// If \p N does not have fused activation \returns true.
+bool checkNoFusionForNode(const Node &N) {
+#define DEF_NODE(CLASS, NAME)                                                  \
+  case Kinded::Kind::CLASS##Kind: {                                            \
+    const CLASS *CI = llvm::cast<CLASS>(&N);                                   \
+    return checkNoFusion(*CI);                                                 \
+    break;                                                                     \
+  }
+  switch (N.getKind()) {
+#include "glow/AutoGenNodes.def"
+  default:
+    llvm_unreachable("Invalid node.");
+  }
+  return true;
+}
+
+/// If \p I does not have fused activation \returns true.
+bool checkNoFusionForInstr(const Instruction &I) {
+#define DEF_VALUE(CLASS, NAME)
+#define DEF_INSTR(CLASS, NAME)                                                 \
+  case Kinded::Kind::CLASS##Kind: {                                            \
+    const CLASS *CI = llvm::cast<CLASS>(&I);                                   \
+    return checkNoFusion(*CI);                                                 \
+    break;                                                                     \
+  }
+#define DEF_BACKEND_SPECIFIC_INSTR(CLASS, NAME)                                \
+  case Kinded::Kind::CLASS##Kind: {                                            \
+    const CLASS *CI = llvm::cast<CLASS>(&I);                                   \
+    return checkNoFusion(*CI);                                                 \
+    break;                                                                     \
+  }
+  switch (I.getKind()) {
+#include "glow/AutoGenInstr.def"
+  default:
+    llvm_unreachable("Invalid instruction.");
+  }
+  return true;
+}
+
 template <typename FUN, typename ARR>
 ContiguousPlaceholders getContiguousPlaceHolder(const ARR &holders,
                                                 const FUN &F) {

lib/Backends/Interpreter/Interpreter.cpp

@@ -22,6 +22,7 @@
 #include "glow/Graph/Graph.h"
 #include "glow/Graph/Nodes.h"
 #include "glow/IR/IR.h"
+#include "glow/IR/Instrs.h"
 #include "glow/Optimizer/IROptimizer/IROptimizer.h"
 
 using namespace glow;
@@ -467,6 +468,114 @@ bool Interpreter::isOpSupported(const NodeInfo &NI) const {
   }
 }
 
+/// Use template meta-programming to check if typename ClassName contains
+/// has_getLayout() method. Below generates a struct named has_getLayout that
+/// looks for said method.
+CLASS_CONTAINS_METHOD(getLayout)
+
+template <typename T, std::enable_if_t<
+                          !has_getLayout<T, ConvolutionLayout>::value, int> = 0>
+static bool checkLayout(const T &I) {
+  (void)I;
+  return true;
+}
+
+template <typename T,
+          std::enable_if_t<has_getLayout<T, ConvolutionLayout>::value, int> = 0>
+static bool checkLayout(const T &I) {
+  if (I.getLayout() != NHWC) {
+    report("Glow Interpreter supports only NHWC");
+    return false;
+  }
+  return true;
+}
+
+static bool checkLayoutForNode(const Node &N) {
+#define DEF_NODE(CLASS, NAME)                                                  \
+  case Kinded::Kind::CLASS##Kind: {                                            \
+    const CLASS *CI = llvm::cast<CLASS>(&N);                                   \
+    return checkLayout(*CI);                                                   \
+    break;                                                                     \
+  }
+  switch (N.getKind()) {
+#include "glow/AutoGenNodes.def"
+  default:
+    llvm_unreachable("Invalid instruction.");
+  }
+  return true;
+}
+
+bool Interpreter::verify(const Function &F) const {
+  if (!F.verify()) {
+    return false;
+  }
+  if (!checkAllNodesSupported(F)) {
+    return false;
+  }
+  for (const Node &N : F.getNodes()) {
+    if (!checkLayoutForNode(N)) {
+      return false;
+    }
+    if (!checkNoFusionForNode(N)) {
+      return false;
+    }
+    switch (N.getKind()) {
+    case Kinded::Kind::ChannelwiseQuantizedConvolutionNodeKind: {
+      auto *CQCI = llvm::cast<ChannelwiseQuantizedConvolutionNode>(&N);
+      if (!CQCI->getGroupwise()) {
+        report("Glow Interpreter does not support Non-groupwise variant");
+        return false;
+      }
+      continue;
+    }
+    default:
+      continue;
+    }
+  }
+  return true;
+}
+
+static bool checkLayoutForInstr(const Instruction &I) {
+#define DEF_VALUE(CLASS, NAME)
+#define DEF_INSTR(CLASS, NAME)                                                 \
+  case Kinded::Kind::CLASS##Kind: {                                            \
+    const CLASS *CI = llvm::cast<CLASS>(&I);                                   \
+    return checkLayout(*CI);                                                   \
+    break;                                                                     \
+  }
+#define DEF_BACKEND_SPECIFIC_INSTR(CLASS, NAME)
+  switch (I.getKind()) {
+#include "glow/AutoGenInstr.def"
+  default:
+    llvm_unreachable("Invalid instruction.");
+  }
+  return true;
+}
+
+bool Interpreter::verify(const IRFunction &IR) const {
+  for (const auto &I : IR.getInstrs()) {
+    if (!checkNoFusionForInstr(I)) {
+      return false;
+    }
+    if (!checkLayoutForInstr(I)) {
+      return false;
+    }
+    switch (I.getKind()) {
+    case Kinded::Kind::ChannelwiseQuantizedConvolutionInstKind: {
+      auto *CQCI = llvm::cast<ChannelwiseQuantizedConvolutionInst>(&I);
+      if (!CQCI->getGroupwise()) {
+        report("Glow Interpreter does not support Non-groupwise variant");
+        return false;
+      }
+      continue;
+    }
+    default:
+      continue;
+    }
+  }
+  return true;
+}
+
 bool Interpreter::shouldLower(const Node *N) const {
   switch (N->getKind()) {
   case Kinded::Kind::ConvolutionNodeKind:

lib/Backends/Interpreter/Interpreter.h

@@ -49,6 +49,9 @@ class Interpreter final : public BackendUsingGlowIR {
 
   bool isOpSupported(const NodeInfo &NI) const override;
 
+  bool verify(const Function &F) const override;
+  bool verify(const IRFunction &IR) const override;
+
   bool shouldLower(const Node *N) const override;
 
   /// @}