[Speed]change Scope string hashed variable index to number hashed

.pre-commit-config.yaml

@@ -1,16 +1,16 @@
 repos:
 -   repo: https://github.com/Lucas-C/pre-commit-hooks.git
-    sha: v1.0.1
+    rev: v1.1.5
     hooks:
     -   id: remove-crlf
         files: (?!.*third_party)^.*$ | (?!.*book)^.*$
 -   repo: https://github.com/PaddlePaddle/mirrors-yapf.git
-    sha: 0d79c0c469bab64f7229c9aca2b1186ef47f0e37
+    rev: v0.16.2
     hooks:
     -   id: yapf
         files: (.*\.(py|bzl)|BUILD|.*\.BUILD|WORKSPACE)$
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    sha: 5bf6c09bfa1297d3692cadd621ef95f1284e33c0
+    rev: v1.2.3
     hooks:
     -   id: check-added-large-files
     -   id: check-merge-conflict
@@ -35,7 +35,7 @@ repos:
         language: system
         files: \.(c|cc|cxx|cpp|cu|h|hpp|hxx)$
 -   repo: https://github.com/PaddlePaddle/pre-commit-golang
-    sha: 8337620115c25ff8333f1b1a493bd031049bd7c0
+    rev: v0.2
     hooks:
     -   id: go-fmt
         types:

paddle/fluid/framework/CMakeLists.txt

@@ -33,7 +33,7 @@ cc_test(variable_test SRCS variable_test.cc)
 cc_library(threadpool SRCS threadpool.cc DEPS enforce)
 cc_test(threadpool_test SRCS threadpool_test.cc DEPS threadpool)
 
-cc_library(scope SRCS scope.cc DEPS glog threadpool)
+cc_library(scope SRCS scope.cc DEPS glog threadpool profiler)
 cc_test(scope_test SRCS scope_test.cc DEPS scope)
 
 cc_library(data_device_transform SRCS data_device_transform.cc DEPS tensor)

paddle/fluid/framework/details/var_handle.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/fluid/framework/details/var_handle.h"
+#include "paddle/fluid/framework/variable.h"
 
 namespace paddle {
 namespace framework {
@@ -27,6 +28,11 @@ std::string VarHandle::DebugString() const {
 }
 
 std::string DummyVarHandle::DebugString() const { return "dummy"; }
+
+// VarUUID::VarUUID(const std::strign& name) : name(name) {
+//   unique_id = UUIDGenerator::Instance()(name);
+// }
+
 }  // namespace details
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/framework/details/var_handle.h

@@ -15,6 +15,7 @@
 #pragma once
 #include <sstream>
 #include <string>
+#include <unordered_map>
 #include <unordered_set>
 #include <utility>
 
@@ -73,6 +74,49 @@ struct DummyVarHandle : public VarHandleBase {
   std::string DebugString() const override;
 };
 
+/// variable unique_id generator, threadsafe singleton.
+class UUIDGenerator {
+ public:
+  UUIDGenerator() {}
+  int operator()(const std::string& name) { return hasher(name); }
+  static UUIDGenerator& Instance() {
+    static UUIDGenerator g;
+    return g;
+  }
+
+ private:
+  std::hash<std::string> hasher;
+  DISABLE_COPY_AND_ASSIGN(UUIDGenerator);
+};
+
+// a runtime unique variable identity.
+struct VarUUID {
+  explicit VarUUID(const std::string& name) : name(name) {
+    unique_id = UUIDGenerator::Instance()(name);
+  }
+  VarUUID(const std::string& name, int id) : name(name), unique_id(id) {}
+  bool operator==(const VarUUID& rhs) const {
+    return unique_id == rhs.unique_id;
+  }
+  bool operator!=(const VarUUID& rhs) const {
+    return unique_id != rhs.unique_id;
+  }
+  std::string name;
+  int unique_id; /*default -1 if uninitialized*/
+};
+
+struct VarUUIDHash {
+  size_t operator()(const VarUUID& id) const { return id.unique_id; }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const VarUUID& var) {
+  os << var.name;
+  if (VLOG_IS_ON(5)) {
+    os << "[" << var.unique_id << "]";
+  }
+  return os;
+}
+
 }  // namespace details
 }  // namespace framework
 }  // namespace paddle

paddle/fluid/framework/operator.cc

@@ -15,6 +15,7 @@ limitations under the License. */
 #include <glog/logging.h>
 
 #include <algorithm>
+#include <string>
 
 #include "paddle/fluid/framework/data_transform.h"
 #include "paddle/fluid/framework/executor.h"
@@ -46,7 +47,7 @@ proto::VarType::Type GetDataTypeOfVar(const Variable* var) {
   }
 }
 
-static DDim GetDims(const Scope& scope, const std::string& name,
+static DDim GetDims(const Scope& scope, const VarUUID& name,
                     bool get_actual_dim = false) {
   Variable* var = scope.FindVar(name);
   if (var == nullptr) {
@@ -66,7 +67,7 @@ static DDim GetDims(const Scope& scope, const std::string& name,
   }
 }
 
-static LoD GetLoD(const Scope& scope, const std::string& name) {
+static LoD GetLoD(const Scope& scope, const VarUUID& name) {
   Variable* var = scope.FindVar(name);
   auto default_lod = LoD({{}});
 
@@ -93,31 +94,31 @@ void OperatorBase::Run(const Scope& scope, const platform::Place& place) {
   RunImpl(scope, place);
 }
 
-std::string OperatorBase::Input(const std::string& name) const {
+VarUUID OperatorBase::Input(const std::string& name) const {
   auto& ins = Inputs(name);
   PADDLE_ENFORCE_LE(ins.size(), 1UL,
                     "Operator %s's input %s should contain only one variable.",
                     type_, name);
-  return ins.empty() ? kEmptyVarName : ins[0];
+  return ins.empty() ? VarUUID(kEmptyVarName) : ins[0];
 }
 
-const std::vector<std::string>& OperatorBase::Inputs(
+const std::vector<VarUUID>& OperatorBase::Inputs(
     const std::string& name) const {
   auto it = inputs_.find(name);
   PADDLE_ENFORCE(it != inputs_.end(), "Operator %s does not have the input %s.",
                  type_, name);
   return it->second;
 }
 
-std::string OperatorBase::Output(const std::string& name) const {
+VarUUID OperatorBase::Output(const std::string& name) const {
   auto& outs = Outputs(name);
   PADDLE_ENFORCE_LE(outs.size(), 1UL,
                     "Operator %s's output %s should contain only one variable.",
                     type_, name);
-  return outs.empty() ? kEmptyVarName : outs[0];
+  return outs.empty() ? VarUUID(kEmptyVarName) : outs[0];
 }
 
-const std::vector<std::string>& OperatorBase::Outputs(
+const std::vector<VarUUID>& OperatorBase::Outputs(
     const std::string& name) const {
   auto it = outputs_.find(name);
   PADDLE_ENFORCE(it != outputs_.end(),
@@ -180,17 +181,17 @@ OperatorBase::OperatorBase(const std::string& type,
   CheckAllInputOutputSet();
 }
 
-std::vector<std::string> OperatorBase::InputVars() const {
-  std::vector<std::string> ret_val;
+std::vector<VarUUID> OperatorBase::InputVars() const {
+  std::vector<VarUUID> ret_val;
   for (auto& o : inputs_) {
     ret_val.reserve(ret_val.size() + o.second.size());
     ret_val.insert(ret_val.end(), o.second.begin(), o.second.end());
   }
   return ret_val;
 }
 
-std::vector<std::string> OperatorBase::OutputVars(bool has_intermediate) const {
-  std::vector<std::string> ret_val;
+std::vector<VarUUID> OperatorBase::OutputVars(bool has_intermediate) const {
+  std::vector<VarUUID> ret_val;
   if (has_intermediate) {
     // push all outputs into ret_val
     for (auto& o : outputs_) {
@@ -233,11 +234,13 @@ void OperatorBase::CheckAllInputOutputSet() const {
 void OperatorBase::GenerateTemporaryNames() {
   static std::atomic<size_t> gUniqId(0UL);
   for (auto& output : outputs_) {
-    for (auto& output_name : output.second) {
-      if (output_name == kTempVarName) {
+    for (auto& output_id : output.second) {
+      if (output_id.name == kTempVarName) {
+        std::string output_name = "";
         output_name += type_;
         output_name += "@";
         output_name += std::to_string(gUniqId.fetch_add(1));
+        output_id = VarUUID(output_name);
       }
     }
   }
@@ -283,7 +286,7 @@ const std::vector<const Tensor*> ExecutionContext::MultiInput<Tensor>(
   std::vector<const Tensor*> res;
   res.reserve(names.size());
   std::transform(names.begin(), names.end(), std::back_inserter(res),
-                 [&](const std::string& sub_name) {
+                 [&](const VarUUID& sub_name) {
                    auto var = scope_.FindVar(sub_name);
                    return var == nullptr ? nullptr : GetTensorFromVar(var);
                  });
@@ -303,7 +306,7 @@ std::vector<Tensor*> ExecutionContext::MultiOutput<Tensor>(
   std::vector<Tensor*> res;
   res.reserve(names.size());
   std::transform(names.begin(), names.end(), std::back_inserter(res),
-                 [&](const std::string& sub_name) {
+                 [&](const VarUUID& sub_name) {
                    auto var = scope_.FindVar(sub_name);
                    return var == nullptr ? nullptr
                                          : GetMutableTensorFromVar(var);
@@ -340,7 +343,7 @@ class RuntimeInferShapeContext : public InferShapeContext {
     PADDLE_ENFORCE_EQ(length, 1UL,
                       "Input %s should not have more than one inputs", name);
     auto ipt = ins[0];
-    auto* var = ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
+    auto* var = ipt == VarUUID(kEmptyVarName) ? nullptr : scope_.FindVar(ipt);
     return var != nullptr;
   }
 
@@ -353,7 +356,7 @@ class RuntimeInferShapeContext : public InferShapeContext {
     PADDLE_ENFORCE_EQ(length, 1UL,
                       "Output %s should not have more than one inputs", name);
     auto ipt = outs[0];
-    auto* var = ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
+    auto* var = ipt == VarUUID(kEmptyVarName) ? nullptr : scope_.FindVar(ipt);
     return var != nullptr;
   }
 
@@ -385,13 +388,11 @@ class RuntimeInferShapeContext : public InferShapeContext {
 
   AttrReader Attrs() const override { return AttrReader(op_.Attrs()); }
 
-  const std::vector<std::string>& Inputs(
-      const std::string& name) const override {
+  const std::vector<VarUUID>& Inputs(const std::string& name) const override {
     return op_.Inputs(name);
   }
 
-  const std::vector<std::string>& Outputs(
-      const std::string& name) const override {
+  const std::vector<VarUUID>& Outputs(const std::string& name) const override {
     return op_.Outputs(name);
   }
 

paddle/fluid/framework/operator.h

@@ -106,19 +106,19 @@ class OperatorBase {
   const VariableNameMap& Outputs() const { return outputs_; }
 
   //! Get a input with argument's name described in `op_proto`
-  std::string Input(const std::string& name) const;
+  VarUUID Input(const std::string& name) const;
   //! Get a input which has multiple variables.
-  const std::vector<std::string>& Inputs(const std::string& name) const;
-  //! Get all inputs variable names
-  std::vector<std::string> InputVars() const;
+  const std::vector<VarUUID>& Inputs(const std::string& name) const;
+
+  std::vector<VarUUID> InputVars() const;
 
   //! Get a output with argument's name described in `op_proto`
-  std::string Output(const std::string& name) const;
+  VarUUID Output(const std::string& name) const;
   //! Get an output which has multiple variables.
   //! TODO add a vector_view to prevent memory copy.
-  const std::vector<std::string>& Outputs(const std::string& name) const;
-  //! Get all outputs variable names
-  virtual std::vector<std::string> OutputVars(bool has_intermediate) const;
+  const std::vector<VarUUID>& Outputs(const std::string& name) const;
+
+  virtual std::vector<VarUUID> OutputVars(bool has_intermediate) const;
 
   // Return a new operator instance, which is as same as this.
   // Use unique_ptr to prevent caller forget to delete this pointer.
@@ -200,12 +200,12 @@ class ExecutionContext {
 
   const Variable* InputVar(const std::string& name) const {
     auto ipt = op_.Input(name);
-    return ipt == kEmptyVarName ? nullptr : scope_.FindVar(ipt);
+    return ipt == VarUUID(kEmptyVarName) ? nullptr : scope_.FindVar(ipt);
   }
 
   Variable* OutputVar(const std::string& name) const {
     auto opt = op_.Output(name);
-    return opt == kEmptyVarName ? nullptr : scope_.FindVar(opt);
+    return opt == VarUUID(kEmptyVarName) ? nullptr : scope_.FindVar(opt);
   }
 
   const std::vector<const Variable*> MultiInputVar(
@@ -214,9 +214,10 @@ class ExecutionContext {
     std::vector<const Variable*> res;
     res.reserve(names.size());
     std::transform(names.begin(), names.end(), std::back_inserter(res),
-                   [this](const std::string& name) {
-                     return name == kEmptyVarName ? nullptr
-                                                  : scope_.FindVar(name);
+                   [this](const VarUUID& name) {
+                     return name == VarUUID(kEmptyVarName)
+                                ? nullptr
+                                : scope_.FindVar(name);
                    });
     return res;
   }
@@ -226,9 +227,10 @@ class ExecutionContext {
     std::vector<Variable*> res;
     res.reserve(names.size());
     std::transform(names.begin(), names.end(), std::back_inserter(res),
-                   [this](const std::string& name) {
-                     return name == kEmptyVarName ? nullptr
-                                                  : scope_.FindVar(name);
+                   [this](const VarUUID& name) {
+                     return name == VarUUID(kEmptyVarName)
+                                ? nullptr
+                                : scope_.FindVar(name);
                    });
     return res;
   }
@@ -251,7 +253,7 @@ class ExecutionContext {
     std::vector<const T*> res;
     res.reserve(names.size());
     std::transform(names.begin(), names.end(), std::back_inserter(res),
-                   [&](const std::string& sub_name) {
+                   [&](const VarUUID& sub_name) {
                      auto var = scope_.FindVar(sub_name);
                      return var == nullptr ? nullptr : &var->Get<T>();
                    });
@@ -264,7 +266,7 @@ class ExecutionContext {
     std::vector<T*> res;
     res.reserve(names.size());
     std::transform(names.begin(), names.end(), std::back_inserter(res),
-                   [&](const std::string& sub_name) {
+                   [&](const VarUUID& sub_name) {
                      auto var = scope_.FindVar(sub_name);
                      return var == nullptr ? nullptr : var->GetMutable<T>();
                    });
@@ -291,12 +293,12 @@ class ExecutionContext {
 #endif
 
   //! Get actual name vector for this input.
-  const std::vector<std::string>& Inputs(const std::string& name) const {
+  const std::vector<VarUUID>& Inputs(const std::string& name) const {
     return op_.Inputs(name);
   }
 
   //! Get actual name vector for this output.
-  const std::vector<std::string>& Outputs(const std::string& name) const {
+  const std::vector<VarUUID>& Outputs(const std::string& name) const {
     return op_.Outputs(name);
   }