[Placeholder] Allow executing Placeholders in the execution engine.

Implement the logic for executing Placeholders in the execution engine.
This commit changes the backend interface and adds the ability to pass
Placeholder variables in addition to Variables. This change breaks the
out-of-tree backends.

This is the first step in adding support for placeholder variables in
the execution engine. The commit adds support to the interpreter but not
to the OpenCL and CPU backends.

Author: nadavrot

include/glow/Backends/Backend.h

@@ -39,9 +39,12 @@ class Backend {
   /// Dtor.
   virtual ~Backend() = default;
 
-  /// Generate code for input function \param IR.
+  /// Generate code for input function \param IR. \p placeholders is a list of
+  /// Placeholders that are mapped to the concrete input tensor for the
+  /// specific function.
   virtual std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const = 0;
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const = 0;
 
   /// Save the bundle for \p IR for a later standalone execution
   /// in \p outputDir. Make \p networkName the function name for

include/glow/Backends/CompiledFunction.h

@@ -16,8 +16,16 @@
 #ifndef GLOW_BACKENDS_COMPILEDFUNCTION_H
 #define GLOW_BACKENDS_COMPILEDFUNCTION_H
 
+#include <unordered_map>
+
 namespace glow {
 
+class Placeholder;
+class Tensor;
+
+/// Maps placeholders to the tensors that back them.
+using PlaceholderMap = std::unordered_map<Placeholder *, Tensor *>;
+
 /// Interface for executing a compiled function.
 class CompiledFunction {
 public:

include/glow/ExecutionEngine/ExecutionEngine.h

@@ -67,7 +67,11 @@ class ExecutionEngine final {
 
   /// Optimize the graph, generate IR, optimize IR and compile it for a
   /// specific target. This method should be invoked before the run method.
-  void compile(CompilationMode mode, Function *F);
+  /// The placeholder variables in \p placeholders are mapped to the concrete
+  /// tensor values in the compiled instance of the function.
+  void compile(CompilationMode mode, Function *F,
+               llvm::ArrayRef<Placeholder *> placeholders = {},
+               llvm::ArrayRef<Tensor *> inputs = {});
 
   /// Save a bundle for a standalone execution. This method takes care of
   /// everything when preparing the bundle for saving. There is no need to

lib/Backends/CPU/CPUBackend.cpp

@@ -123,7 +123,8 @@ CPUBackend::createIRGen(IRFunction *IR,
 }
 
 std::unique_ptr<CompiledFunction>
-CPUBackend::compile(std::unique_ptr<IRFunction> IR) const {
+CPUBackend::compile(std::unique_ptr<IRFunction> IR,
+                    const PlaceholderMap &placeholders) const {
   AllocationsInfo allocationsInfo;
   std::unique_ptr<LLVMIRGen> irgen = createIRGen(IR.get(), allocationsInfo);
   irgen->initTargetMachine(target.empty() ? "" : target.getValue(),

lib/Backends/CPU/CPUBackend.h

@@ -43,7 +43,8 @@ class CPUBackend : public Backend {
   ~CPUBackend() override = default;
 
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override;
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override;
 
   void save(std::unique_ptr<IRFunction> IR, llvm::StringRef outputDir,
             llvm::StringRef networkName) const override;

lib/Backends/Interpreter/Interpreter.cpp

@@ -24,8 +24,9 @@
 using namespace glow;
 
 std::unique_ptr<CompiledFunction>
-Interpreter::compile(std::unique_ptr<IRFunction> IR) const {
-  return llvm::make_unique<InterpreterFunction>(std::move(IR));
+Interpreter::compile(std::unique_ptr<IRFunction> IR,
+                     const PlaceholderMap &placeholders) const {
+  return llvm::make_unique<InterpreterFunction>(std::move(IR), placeholders);
 }
 
 bool Interpreter::isOpSupported(Kinded::Kind opKind, ElemKind elementTy) const {

lib/Backends/Interpreter/Interpreter.h

@@ -35,7 +35,8 @@ class Interpreter final : public Backend {
   ~Interpreter() override = default;
 
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override;
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override;
 
   bool isOpSupported(Kinded::Kind opKind, ElemKind elementTy) const override;
 

lib/Backends/Interpreter/InterpreterFunction.cpp

@@ -24,17 +24,22 @@
 
 using namespace glow;
 
-InterpreterFunction::InterpreterFunction(std::unique_ptr<IRFunction> F)
+InterpreterFunction::InterpreterFunction(std::unique_ptr<IRFunction> F,
+                                         const PlaceholderMap &placeholders)
     : F_(std::move(F)) {
+
+  // Register the concrete tensors that back the placeholder tensors.
+  for (auto &ph : placeholders) {
+    auto *w = F_->getWeightForNode(ph.first);
+    assert(!externalTensors_.count(w) && "The tensor is already registered");
+    externalTensors_[w] = ph.second;
+  }
+
   for (auto &v : F_->getGraph()->getParent()->getVars()) {
     auto *w = F_->getWeightForNode(v);
     assert(!externalTensors_.count(w) && "The tensor is already registered");
     externalTensors_[w] = &v->getPayload();
   }
-
-  for (auto *W : F_->getWeights()) {
-    getOrCreateTensor(W);
-  }
 }
 
 InterpreterFunction::~InterpreterFunction() {

lib/Backends/Interpreter/InterpreterFunction.h

@@ -48,7 +48,8 @@ class InterpreterFunction final : public CompiledFunction {
   std::unordered_map<const Value *, Tensor *> externalTensors_;
 
 public:
-  InterpreterFunction(std::unique_ptr<IRFunction> F);
+  InterpreterFunction(std::unique_ptr<IRFunction> F,
+                      const PlaceholderMap &placeholders);
 
   /// \name CompiledFunction interface
   ///@{

lib/Backends/OpenCL/OpenCL.cpp

@@ -1571,6 +1571,7 @@ cl_mem OpenCLFunction::allocDeviceBuffer(uint64_t size) {
 void OpenCLFunction::freeDeviceBuffer(cl_mem buf) { clReleaseMemObject(buf); }
 
 std::unique_ptr<CompiledFunction>
-OCLBackend::compile(std::unique_ptr<IRFunction> IR) const {
+OCLBackend::compile(std::unique_ptr<IRFunction> IR,
+                    const PlaceholderMap &placeholders) const {
   return llvm::make_unique<OpenCLFunction>(std::move(IR));
 }

lib/Backends/OpenCL/OpenCL.h

@@ -171,7 +171,8 @@ class OCLBackend final : public Backend {
   ~OCLBackend() override = default;
 
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override;
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override;
 
   bool transformPostLowering(Function *F, CompilationMode mode) const override;
 

lib/ExecutionEngine/ExecutionEngine.cpp

@@ -169,8 +169,19 @@ std::unique_ptr<IRFunction> ExecutionEngine::generateIR(CompilationMode mode,
   return IR;
 }
 
-void ExecutionEngine::compile(CompilationMode mode, Function *F) {
-  function_ = backend_->compile(generateIR(mode, F));
+void ExecutionEngine::compile(CompilationMode mode, Function *F,
+                              llvm::ArrayRef<Placeholder *> placeholders,
+                              llvm::ArrayRef<Tensor *> inputs) {
+  PlaceholderMap pmap;
+  assert(placeholders.size() == inputs.size() &&
+         "Invalid number of placeholders");
+
+  for (size_t i = 0, e = placeholders.size(); i < e; i++) {
+    pmap[placeholders[i]] = inputs[i];
+  }
+
+  auto IR = generateIR(mode, F);
+  function_ = backend_->compile(std::move(IR), pmap);
 }
 
 void ExecutionEngine::save(CompilationMode mode, Function *F,

tests/unittests/BackendCorrectnessTest.cpp

@@ -239,8 +239,9 @@ class MockCPUBackend : public Backend {
 public:
   MockCPUBackend() { backend_.reset(createBackend(BackendKind::CPU)); }
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override {
-    return backend_->compile(std::move(IR));
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override {
+    return backend_->compile(std::move(IR), placeholders);
   }
   bool isOpSupported(Kinded::Kind opKind, ElemKind elementTy) const override {
     return true;
@@ -304,7 +305,8 @@ TEST_P(CPUOnly, dataParallelStackingTest) {
   }
 
   MockCPUBackend backend;
-  backend.compile(std::move(M))->execute();
+  PlaceholderMap empty;
+  backend.compile(std::move(M), empty)->execute();
   auto H = var->getHandle();
   EXPECT_EQ(H.at(0), 3);
   EXPECT_EQ(H.at(1), 4);

tests/unittests/BackendTest.cpp

@@ -145,7 +145,8 @@ TEST_P(BackendTest, debugPrint) {
   IRBuilder(IR.get()).createDebugPrintInst("print", *IR->getWeights().begin());
 
   std::unique_ptr<Backend> backend(createBackend(GetParam()));
-  auto function = backend->compile(std::move(IR));
+  PlaceholderMap empty;
+  auto function = backend->compile(std::move(IR), empty);
   function->execute();
 }
 
@@ -176,6 +177,21 @@ TEST_P(BackendTest, decoupleCodegenFromGraph) {
   EXPECT_NEAR(HX.at({2}), 9, 1E-5);
 }
 
+/// Check that we can pass information to the execution engine using Placeholder
+/// variables and read it back using Save nodes (in variables).
+TEST(Placeholder, simplePlaceholderValue) {
+  Tensor data{99.0, 35.0, 2.0, 3.0};
+  ExecutionEngine EE{BackendKind::Interpreter};
+  auto &mod = EE.getModule();
+  Function *F = mod.createFunction("main");
+  auto *input = mod.createPlaceholder(ElemKind::FloatTy, {4}, "input");
+  SaveNode *S = F->createSave("ret", input);
+  EE.compile(CompilationMode::Infer, F, {input}, {&data});
+  EE.run();
+  auto &res = S->getVariable()->getPayload();
+  EXPECT_TRUE(res.isEqual(data));
+}
+
 INSTANTIATE_TEST_CASE_P(Interpreter, BackendTest,
                         ::testing::Values(BackendKind::Interpreter));
 

tests/unittests/BackendTestUtils.h

@@ -26,7 +26,8 @@ class MockBackend : public Backend {
     void execute() override {}
   };
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override {
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override {
     return llvm::make_unique<MockFunction>();
   }
   bool isOpSupported(Kinded::Kind opKind, ElemKind elementTy) const override {

tests/unittests/quantizationTest.cpp

@@ -615,8 +615,9 @@ class MockQuantBackend : public Backend {
     backend_.reset(createBackend(BackendKind::Interpreter));
   }
   std::unique_ptr<CompiledFunction>
-  compile(std::unique_ptr<IRFunction> IR) const override {
-    return backend_->compile(std::move(IR));
+  compile(std::unique_ptr<IRFunction> IR,
+          const PlaceholderMap &placeholders) const override {
+    return backend_->compile(std::move(IR), placeholders);
   }
   bool isOpSupported(Kinded::Kind opKind, ElemKind elementTy) const override {
     if (opKind == Kinded::Kind::SoftMaxNodeKind ||