[Placeholder] Remove the ability to differentiate variables.

This commit removes the ability to differentiate variables. From this
point we can only differentiate placeholders. It looks like we've
reached this point because all of the tests are passing.

Author: nadavrot

include/glow/Graph/Graph.h

@@ -677,7 +677,8 @@ class Function final : public Named {
 
 struct TrainingConfig;
 
-using VariableGradientsList = std::list<std::pair<Storage *, Storage *>>;
+using VariableGradientsList =
+    std::list<std::pair<Placeholder *, Placeholder *>>;
 
 /// Create a new Function that 'trains' the input Function. We differentiate the
 /// nodes and insert code to update the weights based on the \p config

lib/Graph/Grad.cpp

@@ -228,36 +228,36 @@ Function *glow::differentiate(Function *F, const TrainingConfig &conf,
   } // End of the for-each instr loop.
 
   for (auto N : nodes) {
-    // Iterate only through Variables/Placeholders used by the Function.
-    // These are inserted during the post-order walk.
-    Storage *V = llvm::dyn_cast<Storage>(N);
-    if (!V)
+    // Iterate only through Placeholders used by the Function. These are
+    // inserted during the post-order walk.
+    Placeholder *PH = llvm::dyn_cast<Placeholder>(N);
+    if (!PH)
       continue;
 
     // In this special differentiation mode we record the last gradient value
     // without performing the SGD update. This mode is used by the unit tests.
     if (varGrads) {
-      if (map.hasGradient(V)) {
-        std::string nodeName = "_grad_" + V->getName().str();
+      if (map.hasGradient(PH)) {
+        std::string nodeName = "_grad_" + PH->getName().str();
         // Save the gradient and return the destination variable.
-        auto *saveNode = G->createSavePH(nodeName, map.getGradient(V));
-        auto *GradV = llvm::dyn_cast<Storage>(saveNode->getPlaceholder());
-        varGrads->push_back({V, GradV});
+        auto *saveNode = G->createSavePH(nodeName, map.getGradient(PH));
+        Placeholder *GradV = saveNode->getPlaceholder();
+        varGrads->push_back({PH, GradV});
       }
       continue;
     }
 
     // Don't update nodes that are not marked as trainable.
-    if (!V->isTraining()) {
+    if (!PH->isTraining()) {
       continue;
     }
 
-    auto X = new SGDNode(V->getName(), map.getGradient(V), V, conf.L1Decay,
+    auto X = new SGDNode(PH->getName(), map.getGradient(PH), PH, conf.L1Decay,
                          conf.L2Decay, conf.learningRate, conf.momentum,
                          conf.batchSize);
     toAppend.push_back(X);
     // Now update the weight with the value computed by SGD.
-    auto *save = new SaveNode(V->getName().str() + ".saveGrad", {X, 0}, V);
+    auto *save = new SaveNode(PH->getName().str() + ".saveGrad", {X, 0}, PH);
     toAppend.push_back(save);
   }
 

tests/unittests/gradCheckTest.cpp

@@ -58,15 +58,15 @@ float gradDiff(float G1, float G2) {
 Placeholder *getGrad(const VariableGradientsList &grads, Placeholder *V) {
   for (auto &p : grads) {
     if (p.first == V) {
-      return cast<Placeholder>(p.second);
+      return p.second;
     }
   }
   return nullptr;
 }
 
 void allocateGrads(Context &ctx, const VariableGradientsList &grads) {
   for (auto &p : grads) {
-    auto grad = cast<Placeholder>(p.second);
+    auto grad = p.second;
     ctx.allocate(grad);
   }
 }