Placeholder: add the graph creators and a simple unit test that checks that we can construct the graph.

This commit is the first few steps in the implementation of the
Placeholder node. The plan is discussed in #1334. Placeholder are
unbound variables where the content of the tensor is provided by the
execution engine or the AOT compiler at runtime.

This commit introduces Storage as a superclass for Variable (bound) and
Placeholder (unbound). This PR also adds a simple unit test that checks
that we can create new Placeholder nodes. This PR does not implement any
of the infrastructure that's required to do anything useful with
Placeholder variables, such as loading content into them, deleting them,
pretty dotty-printer, etc.

Next steps (not necessarily in any specific order):

1. Teach the execution engine to bind tensors to the Placeholder nodes.

2. Verify that dotty printing, dump() and debugging work well.

3. Cleanup the APIs that are related to Variable and Placeholder and
make them consistent.

4. Change (some of) the unit tests to use the new Placeholder API.

5. Make sure that our optimizations are correct when placeholder are
used.

Author: nadavrot

include/glow/Graph/Graph.h

@@ -38,8 +38,8 @@ using NodesList = llvm::iplist<glow::Node>;
 using NodesPtrList = std::list<glow::Node *>;
 /// List of Functions.
 using FunctionList = std::list<Function *>;
-/// List of Variables.
 using VariablesList = std::list<Variable *>;
+using PlaceholderList = std::list<Placeholder *>;
 using UnsignedArrayRef = llvm::ArrayRef<size_t>;
 
 class Module final {
@@ -53,6 +53,8 @@ class Module final {
   llvm::StringSet<> uniqueVariableNames_{};
   /// A list of variables that the Module owns.
   VariablesList vars_;
+  /// A list of placeholder nodes that the Module owns.
+  PlaceholderList placeholders_;
   /// Deterministic PRNG used to initialize weights in this module.
   PseudoRNG PRNG_;
 
@@ -67,11 +69,10 @@ class Module final {
                                     llvm::StringSet<> &stringTable);
 
   /// Inserts the variable \p V to the list of variables.
-  Variable *addVar(Variable *V) {
-    V->setName(uniqueName(V->getName(), uniqueVariableNames_));
-    vars_.push_back(V);
-    return V;
-  }
+  Variable *addVar(Variable *V);
+
+  /// Inserts the placeholder node \p ph to the list of variables.
+  Placeholder *addPlaceholder(Placeholder *ph);
 
   /// Return a pointer to a uniqued type \p T.
   TypeRef uniqueType(const Type &T);
@@ -117,9 +118,19 @@ class Module final {
 
   const VariablesList &getVars() const { return vars_; }
 
+  /// \returns the list of placeholders that the Module owns.
+  PlaceholderList &getPlaceholders() { return placeholders_; }
+
+  const PlaceholderList &getPlaceholders() const { return placeholders_; }
+
   /// @name High-level Variable builders.
   ///@{
 
+  Placeholder *createPlaceholder(ElemKind T, llvm::ArrayRef<size_t> dims,
+                                 llvm::StringRef name);
+
+  Placeholder *createPlaceholder(TypeRef T, llvm::StringRef name);
+
   Variable *createVariable(TypeRef T, llvm::StringRef name,
                            VisibilityKind visibility = VisibilityKind::Private,
                            bool isTrainable = true);

include/glow/Graph/Nodes.h

@@ -34,6 +34,7 @@ class Storage : public Node {
 public:
   Storage(Kinded::Kind k, llvm::StringRef name) : Node(k, name) {}
 
+  /// \return the single output value of the node.
   NodeValue getOutput() { return getNthResult(0); }
 
   /// Declare the standard Node methods.

lib/Graph/Graph.cpp

@@ -54,10 +54,17 @@ Function *Module::createFunction(llvm::StringRef name) {
 Module::~Module() {
   eraseFunctions();
 
-  for (auto it = vars_.begin(), e = vars_.end(); it != e;) {
-    auto cur = it++;
-    eraseVariable(*cur);
+  for (auto it = vars_.begin(), e = vars_.end(); it != e; it++) {
+    Variable *v = *it;
+    delete v;
+  }
+  for (auto it = placeholders_.begin(), e = placeholders_.end(); it != e;
+       it++) {
+    Placeholder *p = *it;
+    delete p;
   }
+  vars_.clear();
+  placeholders_.clear();
 }
 
 void Module::verify() const {
@@ -325,6 +332,17 @@ static ShapeVector getNewShapeWithoutAxis(llvm::ArrayRef<size_t> dims,
 //                       Node builders
 //===----------------------------------------------------------------------===//
 
+Placeholder *Module::createPlaceholder(TypeRef T, llvm::StringRef name) {
+  auto FT = uniqueType(*T);
+  return addPlaceholder(new Placeholder(name, FT));
+}
+
+Placeholder *Module::createPlaceholder(ElemKind T, llvm::ArrayRef<size_t> dims,
+                                       llvm::StringRef name) {
+  auto FT = uniqueType(T, dims);
+  return createPlaceholder(FT, name);
+}
+
 Variable *Module::createVariable(TypeRef T, llvm::StringRef name,
                                  VisibilityKind visibility, bool isTrainable) {
   auto FT = uniqueType(*T);
@@ -389,6 +407,18 @@ llvm::StringRef Module::uniqueName(llvm::StringRef name,
   llvm_unreachable("Unable to find a unique a name.");
 }
 
+Variable *Module::addVar(Variable *V) {
+  V->setName(uniqueName(V->getName(), uniqueVariableNames_));
+  vars_.push_back(V);
+  return V;
+}
+
+Placeholder *Module::addPlaceholder(Placeholder *ph) {
+  ph->setName(uniqueName(ph->getName(), uniqueVariableNames_));
+  placeholders_.push_back(ph);
+  return ph;
+}
+
 ConvolutionNode *Function::createConv(llvm::StringRef name, NodeValue input,
                                       size_t depth,
                                       llvm::ArrayRef<unsigned_t> kernels,

tests/unittests/graphTest.cpp

@@ -886,3 +886,16 @@ TEST(Graph, PostOrderTest) {
   EXPECT_EQ(order[12], ret2->getOutput());
   EXPECT_EQ(order[13], ret2);
 }
+
+TEST(Graph, placeholder) {
+  Module MD;
+  Function *F = MD.createFunction("F");
+  IRFunction M(F);
+  Node *K = MD.createPlaceholder(ElemKind::FloatTy, {4, 320, 200, 3}, "input");
+  Node *S = MD.createPlaceholder(ElemKind::Int64ITy, {4, 1}, "select");
+
+  K = F->createFullyConnected("FC", K, 10); 
+  K = F->createRELU("Relu", K);
+  K = F->createSoftMax("SoftMax", K, S);
+  F->createSave("Save", K);
+}