Move optimizeFunction into the base Backend.

include/glow/Backends/Backend.h

@@ -82,6 +82,9 @@ class Backend {
   /// \returns true if the Backend wants the buffer sharing optimization
   /// performed.
   virtual bool shouldShareBuffers() const { return true; }
+
+  /// Optimize the Function \p F given compilation mode \p mode.
+  void optimizeFunction(CompilationMode mode, Function *F);
 };
 
 /// Create a backend of kind \p kind.

include/glow/ExecutionEngine/ExecutionEngine.h

@@ -43,9 +43,6 @@ class ExecutionEngine final {
   /// A glow function compiled for this ExecutionEngine's backend.
   std::unique_ptr<CompiledFunction> function_;
 
-  /// Optimize the Function \p F given compilation mode \p mode.
-  void optimizeFunction(CompilationMode mode, Function *F);
-
 public:
   ExecutionEngine(BackendKind backendKind = BackendKind::Interpreter);
 

lib/Backends/Backend.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "glow/Backends/Backend.h"
+#include "glow/Graph/Graph.h"
+#include "glow/Optimizer/Optimizer.h"
+
+using namespace glow;
+
+void Backend::optimizeFunction(CompilationMode mode, Function *F) {
+  // Verify the function pre-optimization/lowering.
+  assert(F->verify() && "Function must be valid");
+
+  // Optimize the graph.
+  ::glow::optimize(F, mode);
+
+  // Allow the backend to transform the graph prior to lowering.
+  if (transformPreLowering(F, mode)) {
+    // Optimize the graph again after the backend transformation.
+    // In particular, DCE is very likely to be useful.
+    ::glow::optimize(F, mode);
+  }
+
+  // Lower the graph into a sequence of low-level linear algebra operations.
+  ::glow::lower(F, *this);
+
+  // Optimize the graph again.
+  ::glow::optimize(F, mode);
+
+  // Allow the backend to transform the graph after lowering.
+  if (transformPostLowering(F, mode)) {
+    // Optimize the graph again after the backend transformation.
+    // In particular, DCE is very likely to be useful.
+    ::glow::optimize(F, mode);
+  }
+}

lib/Backends/CMakeLists.txt

@@ -1,4 +1,6 @@
-add_library(Backends Backends.cpp)
+add_library(Backends
+              Backend.cpp
+              Backends.cpp)
 
 add_library(BackendUtils BackendUtils.cpp)
 

lib/ExecutionEngine/ExecutionEngine.cpp

@@ -121,42 +121,14 @@ void glow::runBatch(ExecutionEngine &EE, Context &ctx, size_t iterations,
   }
 }
 
-void ExecutionEngine::optimizeFunction(CompilationMode mode, Function *F) {
-  // Verify the function pre-optimization/lowering.
-  assert(F->verify() && "Function must be valid");
-
-  // Optimize the graph.
-  ::glow::optimize(F, mode);
-
-  // Allow the backend to transform the graph prior to lowering.
-  if (backend_->transformPreLowering(F, mode)) {
-    // Optimize the graph again after the backend transformation.
-    // In particular, DCE is very likely to be useful.
-    ::glow::optimize(F, mode);
-  }
-
-  // Lower the graph into a sequence of low-level linear algebra operations.
-  ::glow::lower(F, *backend_);
-
-  // Optimize the graph again.
-  ::glow::optimize(F, mode);
-
-  // Allow the backend to transform the graph after lowering.
-  if (backend_->transformPostLowering(F, mode)) {
-    // Optimize the graph again after the backend transformation.
-    // In particular, DCE is very likely to be useful.
-    ::glow::optimize(F, mode);
-  }
-}
-
 void ExecutionEngine::compile(CompilationMode mode, Function *F) {
-  optimizeFunction(mode, F);
+  backend_->optimizeFunction(mode, F);
   function_ = backend_->compile(F);
 }
 
 void ExecutionEngine::save(CompilationMode mode, Function *F,
                            llvm::StringRef outputDir,
                            llvm::StringRef networkName) {
-  optimizeFunction(mode, F);
+  backend_->optimizeFunction(mode, F);
   backend_->save(F, outputDir, networkName);
 }

tests/unittests/CPUDeviceManagerTest.cpp

@@ -41,42 +41,13 @@ std::unique_ptr<Module> makeBasicModule(std::string functionName = "main") {
   return module;
 }
 
-// TODO: This really should be a helper function somewhere
-void optimizeFunction(Backend *backend, CompilationMode mode, Function *F) {
-  // Verify the function pre-optimization/lowering.
-  assert(F->verify() && "Function must be valid");
-
-  // Optimize the graph.
-  ::glow::optimize(F, mode);
-
-  // Allow the backend to transform the graph prior to lowering.
-  if (backend->transformPreLowering(F, mode)) {
-    // Optimize the graph again after the backend transformation.
-    // In particular, DCE is very likely to be useful.
-    ::glow::optimize(F, mode);
-  }
-
-  // Lower the graph into a sequence of low-level linear algebra operations.
-  ::glow::lower(F, *backend);
-
-  // Optimize the graph again.
-  ::glow::optimize(F, mode);
-
-  // Allow the backend to transform the graph after lowering.
-  if (backend->transformPostLowering(F, mode)) {
-    // Optimize the graph again after the backend transformation.
-    // In particular, DCE is very likely to be useful.
-    ::glow::optimize(F, mode);
-  }
-}
-
 FunctionMapTy
 compileFunctions(Module *module,
                  std::vector<std::unique_ptr<CompiledFunction>> &backing) {
   FunctionMapTy results;
   auto *backend = createBackend(BackendKind::CPU);
   for (auto *F : module->getFunctions()) {
-    optimizeFunction(backend, CompilationMode::Infer, F);
+    backend->optimizeFunction(CompilationMode::Infer, F);
     auto f = backend->compile(F);
     backing.push_back(std::move(f));
     results.emplace(F->getName(), backing.back().get());