all passes

add doc

Author: panyx0718

doc/fluid/design/ir/draft.md

@@ -71,6 +71,44 @@ is a `Graph` and its output is also a `Graph`. For example,
 a `Pass` can simply print out the `Graph`. A `Pass`
 can also fuse some `Graph`'s `Node`s.
 
+```cpp
+class Pass {
+ public:
+
+  virtual std::unique_ptr<Graph> Apply(std::unique_ptr<Graph> graph) const = 0;
+
+  // Get a reference to the attributed previously set.
+  template <typename AttrType>
+  AttrType &Get(const std::string &attr_name) const;
+
+  // Set a pointer to the attribute. Pass takes ownership of the attribute.
+  template <typename AttrType>
+  void Set(const std::string &attr_name, AttrType *attr) ;
+
+  // Set a pointer to the attribute. Pass doesn't take ownership. Caller
+  // should delete the attribute.
+  template <typename AttrType>
+  void SetNotOwned(const std::string &attr_name, AttrType *attr);
+};
+
+// In my_pass.cc
+class MyPass : public Pass {
+ public:
+  std::unique_ptr<Graph> Apply(std::unique_ptr<Graph> graph) const override {
+    // do something.
+    return graph;
+  }
+}
+REGISTER_PASS(my_pass, MyPass);
+
+
+// To use the pass.
+auto my_pass = ir::PassRegistry::Instance().Get("my_pass");
+graph = my_pass->Apply(std::move(graph));
+// Note: to force link my_pass.cc, in the code:
+USE_PASS(my_pass);
+```
+
 #### Optimize
 
 `Optimize` contains a series of `Pass` with defined order.

paddle/fluid/framework/CMakeLists.txt

@@ -99,7 +99,7 @@ else()
 endif()
 
 
-cc_library(parallel_executor SRCS parallel_executor.cc DEPS ssa_graph_builder_factory threaded_ssa_graph_executor scope_buffered_ssa_graph_executor graph graph_viz_pass)
+cc_library(parallel_executor SRCS parallel_executor.cc DEPS threaded_ssa_graph_executor scope_buffered_ssa_graph_executor graph graph_viz_pass multi_devices_graph_builder ssa_graph_printer ssa_graph_checker)
 
 cc_library(prune SRCS prune.cc DEPS framework_proto)
 cc_test(prune_test SRCS prune_test.cc DEPS op_info prune recurrent_op device_context)

paddle/fluid/framework/details/CMakeLists.txt

@@ -31,9 +31,6 @@ cc_library(fuse_vars_op_handle SRCS fuse_vars_op_handle.cc DEPS op_handle_base s
 cc_library(multi_devices_graph_builder SRCS multi_devices_graph_builder.cc DEPS ssa_graph_builder computation_op_handle
         scale_loss_grad_op_handle rpc_op_handle all_reduce_op_handle reduce_op_handle broadcast_op_handle data_balance_op_handle)
 
-
-cc_library(ssa_graph_builder_factory SRCS ssa_graph_builder_factory.cc DEPS multi_devices_graph_builder ssa_graph_printer ssa_graph_checker)
-
 cc_library(ssa_graph_executor SRCS ssa_graph_executor.cc DEPS graph framework_proto)
 cc_library(threaded_ssa_graph_executor SRCS threaded_ssa_graph_executor.cc DEPS fetch_op_handle ssa_graph_executor scope
         simple_threadpool device_context)

paddle/fluid/framework/details/multi_devices_graph_builder.cc

@@ -35,15 +35,15 @@ namespace framework {
 namespace details {
 
 void MultiDevSSAGraphBuilder::Init() const {
-  loss_var_name_ = Get<std::string>("loss_var_name");
-  places_ = Get<std::vector<platform::Place>>("places");
-  local_scopes_ = Get<std::vector<Scope *>>("local_scopes");
-  strategy_ = Get<BuildStrategy>("strategy");
+  loss_var_name_ = Get<const std::string>("loss_var_name");
+  places_ = Get<const std::vector<platform::Place>>("places");
+  local_scopes_ = Get<const std::vector<Scope *>>("local_scopes");
+  strategy_ = Get<const BuildStrategy>("strategy");
 #ifdef PADDLE_WITH_CUDA
   nccl_ctxs_ = &Get<platform::NCCLContextMap>("nccl_ctxs");
 #endif
 
-  for (auto &p : Get<std::unordered_set<std::string>>("params")) {
+  for (auto &p : Get<const std::unordered_set<std::string>>("params")) {
     grad_names_.insert(GradVarName(p));
   }
   balance_vars_.resize(places_.size(), 0);

paddle/fluid/framework/details/ssa_graph_builder_factory.cc

@@ -26,9 +26,8 @@ class SSAGraghBuilderWithChecker : public SSAGraphBuilder {
  public:
   std::unique_ptr<ir::Graph> Apply(
       std::unique_ptr<ir::Graph> graph) const override {
-    auto new_graph = Get<ir::Pass>("previous_pass").Apply(std::move(graph));
-    PADDLE_ENFORCE(IsValidGraph(new_graph.get()));
-    return new_graph;
+    PADDLE_ENFORCE(IsValidGraph(graph.get()));
+    return graph;
   }
 
   bool IsValidGraph(const ir::Graph* graph) const;

paddle/fluid/framework/details/ssa_graph_builder_factory.h

@@ -39,13 +39,11 @@ class SSAGraghBuilderWithPrinter : public SSAGraphBuilder {
  public:
   std::unique_ptr<ir::Graph> Apply(
       std::unique_ptr<ir::Graph> graph) const override {
-    auto new_graph = Get<ir::Pass>("previous_pass").Apply(std::move(graph));
-
     std::unique_ptr<std::ostream> fout(
-        new std::ofstream(Get<std::string>("debug_graphviz_path")));
+        new std::ofstream(Get<const std::string>("debug_graphviz_path")));
     PADDLE_ENFORCE(fout->good());
-    Get<GraphvizSSAGraphPrinter>("graph_printer").Print(*new_graph, *fout);
-    return new_graph;
+    Get<GraphvizSSAGraphPrinter>("graph_printer").Print(*graph, *fout);
+    return graph;
   }
 };
 

paddle/fluid/framework/details/ssa_graph_checker.h

@@ -42,13 +42,15 @@ class Pass {
 
   virtual std::unique_ptr<Graph> Apply(std::unique_ptr<Graph> graph) const = 0;
 
+  // Get a reference to the attributed previously set.
   template <typename AttrType>
   AttrType &Get(const std::string &attr_name) const {
     PADDLE_ENFORCE(attrs_.find(attr_name) != attrs_.end(),
                    "%s attr not registered for pass.", attr_name);
     return *boost::any_cast<AttrType *>(attrs_.at(attr_name));
   }
 
+  // Set a pointer to the attribute. Pass takes ownership of the attribute.
   template <typename AttrType>
   void Set(const std::string &attr_name, AttrType *attr) {
     PADDLE_ENFORCE(attrs_.count(attr_name) == 0);
@@ -59,6 +61,8 @@ class Pass {
     };
   }
 
+  // Set a pointer to the attribute. Pass doesn't take ownership. Caller
+  // should delete the attribute.
   template <typename AttrType>
   void SetNotOwned(const std::string &attr_name, AttrType *attr) {
     PADDLE_ENFORCE(attrs_.count(attr_name) == 0);
@@ -127,6 +131,7 @@ struct PassRegistrar : public Registrar {
                              __test_global_namespace_##uniq_name##__>::value, \
                 msg)
 
+// Register a new pass that can be applied on the IR.
 #define REGISTER_PASS(pass_type, pass_class)                \
   STATIC_ASSERT_PASS_GLOBAL_NAMESPACE(                      \
       __reg_pass__##pass_type,                              \

paddle/fluid/framework/details/ssa_graph_printer.h

@@ -26,7 +26,8 @@ limitations under the License. */
 #endif
 
 #include "paddle/fluid/framework/details/scope_buffered_ssa_graph_executor.h"
-#include "paddle/fluid/framework/details/ssa_graph_builder_factory.h"
+#include "paddle/fluid/framework/details/ssa_graph_checker.h"
+#include "paddle/fluid/framework/details/ssa_graph_printer.h"
 #include "paddle/fluid/framework/details/threaded_ssa_graph_executor.h"
 #include "paddle/fluid/platform/profiler.h"
 
@@ -43,16 +44,6 @@ std::unique_ptr<ir::Graph> ApplyParallelExecutorPass(
 #else
     const BuildStrategy &strategy) {
 #endif
-  details::ParallelExecutorPassManager builder_factory(
-      places, loss_var_name, param_names, local_scopes, strategy);
-  if (use_cuda) {
-#ifdef PADDLE_WITH_CUDA
-    builder_factory.SetNCCLContextMap(nccl_ctxs);
-#else
-    PADDLE_THROW("Not compiled with CUDA.");
-#endif
-  }
-
   std::unique_ptr<ir::Graph> graph(new ir::Graph(main_program));
   if (!strategy.debug_graphviz_path_.empty()) {
     auto viz_pass = ir::PassRegistry::Instance().Get("graph_viz_pass");
@@ -62,8 +53,37 @@ std::unique_ptr<ir::Graph> ApplyParallelExecutorPass(
     graph = viz_pass->Apply(std::move(graph));
   }
 
-  auto builder = builder_factory.Create();
-  graph = builder->Apply(std::move(graph));
+  auto multi_device_pass =
+      ir::PassRegistry::Instance().Get("multi_device_pass");
+  multi_device_pass->SetNotOwned<const std::vector<platform::Place>>("places",
+                                                                     &places);
+  multi_device_pass->SetNotOwned<const std::string>("loss_var_name",
+                                                    &loss_var_name);
+  multi_device_pass->SetNotOwned<const std::unordered_set<std::string>>(
+      "params", &param_names);
+  multi_device_pass->SetNotOwned<const std::vector<Scope *>>("local_scopes",
+                                                             &local_scopes);
+  multi_device_pass->SetNotOwned<const BuildStrategy>("strategy", &strategy);
+
+#ifdef PADDLE_WITH_CUDA
+  platform::NCCLContextMap *nctx = use_cuda ? nccl_ctxs : nullptr;
+  multi_device_pass->SetNotOwned<platform::NCCLContextMap>("nccl_ctxs", nctx);
+#endif
+  graph = multi_device_pass->Apply(std::move(graph));
+
+  if (!strategy.debug_graphviz_path_.empty()) {
+    auto multi_device_print_pass =
+        ir::PassRegistry::Instance().Get("multi_device_print_pass");
+    multi_device_print_pass->SetNotOwned<const std::string>(
+        "debug_graphviz_path", &strategy.debug_graphviz_path_);
+    multi_device_print_pass->Set<details::GraphvizSSAGraphPrinter>(
+        "graph_printer", new details::GraphvizSSAGraphPrinter);
+    graph = multi_device_print_pass->Apply(std::move(graph));
+  }
+
+  auto multi_device_check_pass =
+      ir::PassRegistry::Instance().Get("multi_device_check_pass");
+  graph = multi_device_check_pass->Apply(std::move(graph));
 
   if (!strategy.debug_graphviz_path_.empty()) {
     auto viz_pass = ir::PassRegistry::Instance().Get("graph_viz_pass");