From 85404d4cb987f25dd897af2a035f5ec6b8e73c49 Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Sat, 24 Mar 2018 22:54:43 +0800
Subject: [PATCH 01/27] update cpp reader doc

---
 doc/fluid/design/concepts/cpp_data_feeding.md | 35 +++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/doc/fluid/design/concepts/cpp_data_feeding.md b/doc/fluid/design/concepts/cpp_data_feeding.md
index 8607b40ccb..6ed3f604dc 100644
--- a/doc/fluid/design/concepts/cpp_data_feeding.md
+++ b/doc/fluid/design/concepts/cpp_data_feeding.md
@@ -113,7 +113,7 @@ To solve this problem, we introduce `ReaderHolder` as a wrapper. It acts as an e
 
 To create and invoke readers, some new ops are introduced:
 
-### CreateReaderOp
+### Operators That Creates Readers
 
 Each reader has its creation op. File readers' creation ops have no input and yield the created file reader as its output. Decorated readers' creation ops take the underlying readers as inputs and then yield new decorated readers.
 
@@ -153,13 +153,17 @@ double_buffer_reader = create_double_buffer_op(batch_reader)
 The forwarding ops of the corresponding `main_program` would be like this:
 
 ```
-while_op {
+not_completed = true
+pass_count = 0
+while_op(not_completed) {
     has_next = has_next_op(double_buffer_reader)
     if_else_op(has_next) {
         batch_data = read_op(double_buffer_reader)
         ... (subsequent training ops)
     } else {
         reset_op(double_buffer_reader)
+        increase_op(pass_count)
+        not_completed = less_than_op(pass_count, reqiured_pass_num)
     }
 }
 ```
@@ -169,3 +173,30 @@ Two important considerations for these programs are as follows:
 1. The multiple\_reader is the batch\_reader's underlying reader, and the batch\_reader is the double\_buffer\_reader's underlying reader. `read_op`, `has_next_op` and other reader related ops will only invoke the top-most reader. In this case, it's the double\_buffer\_reader.
 
 2. All readers exist in both `startup_program` and `main_program`. And they are persistable.
+
+### Simplify Configuration by MultiPassReader
+
+The  Program configuration mentioned above is somehow complicated. Users need to be very similar to concepts of Program and Block to prevent making mistakes in their code. To make the usage of C++ readers more friendly to beginning users, we introduce `MultiPassReader`.
+
+`MultiPassReader` is a decorated reader. A multi-pass reader is used to continuously yield data for several pass training. It takes the number of passes to run as one of its attributes('pass_num') and maintains a counter to record how many passes it has completed. Each time its underlying reader reaches the EOF, the multi-pass reader checks whether it has completed the training of given number of pass. If not, the underlying reader will be re-initialized and starts a new pass automatically. Before completing the whole training, the return of MultiPassReader's `HasNext()` will always be `true`.
+
+With `MultiPassReader`, the startup program would be like this:
+
+```
+multiple_reader = open_files_op(...)
+batch_reader = create_batch_reader_op(multiple_reader)
+double_buffer_reader = create_double_buffer_op(batch_reader)
+multi_pass_reader = create_multi_pass_reader_op(double_buffer_reader)
+... (other initializers)
+```
+
+The forwarding part of the corresponding `main_program` would be like this:
+
+```
+not_completed = true
+while_op(not_completed) {
+    batch_data = read_op(multi_pass_reader)
+    ... (subsequent training ops)
+    not_completed = has_next_op(multi_pass_reader)
+}
+```

From dd532e2086bc2e05e02b65d4459d2f12de46793a Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Sat, 24 Mar 2018 22:59:53 +0800
Subject: [PATCH 02/27] refine MultiPassReader's doc string

---
 .../fluid/operators/reader/create_multi_pass_reader_op.cc   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/paddle/fluid/operators/reader/create_multi_pass_reader_op.cc b/paddle/fluid/operators/reader/create_multi_pass_reader_op.cc
index 4d4e9fb909..47d9989bc8 100644
--- a/paddle/fluid/operators/reader/create_multi_pass_reader_op.cc
+++ b/paddle/fluid/operators/reader/create_multi_pass_reader_op.cc
@@ -81,10 +81,10 @@ class CreateMultiPassReaderOpMaker : public DecoratedReaderMakerBase {
 
       This operator creates a multi-pass reader. A multi-pass reader 
       is used to yield data for several pass training continuously. 
-      It takes the the number of pass to run as one of its attributes
+      It takes the number of passes to run as one of its attributes
       ('pass_num'), and maintains a pass counter to record how many 
-      passes it has completed. When the underlying reader reach the EOF, 
-      the multi-pass reader checks whether it has completed training 
+      passes it has completed. When the underlying reader reaches the 
+      EOF, the multi-pass reader checks whether it has completed training 
       of the given number of pass. If not, the underlying reader will 
       be re-initialized and starts a new pass automatically.
     )DOC");

From efd7ee8521986e7789ea88ec0e9a2c7ff5c83ca9 Mon Sep 17 00:00:00 2001
From: m3ngyang <yangm3ng@gmail.com>
Date: Sun, 25 Mar 2018 19:35:20 +0800
Subject: [PATCH 03/27] translate Cluster Training and Prediction

---
 doc/v2/faq/cluster/index_en.rst | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/doc/v2/faq/cluster/index_en.rst b/doc/v2/faq/cluster/index_en.rst
index 855b7e8e53..7cbcaeefcb 100644
--- a/doc/v2/faq/cluster/index_en.rst
+++ b/doc/v2/faq/cluster/index_en.rst
@@ -2,4 +2,15 @@
 Cluster Training and Prediction
 ###############################
 
-TBD
+.. contents::
+
+1. Network connection errors in the log during muliti-node cluster training
+------------------------------------------------
+The errors in the log belong to network connection during mulilti-node cluster training, for example, :code:`Connection reset by peer`.
+This kind of error is usually caused by the abnormal exit of the training process in some node, and the others cannot connect with this node any longer. Steps to troubleshoot the problem as follows:
+
+* Find the first error in the :code:`train.log`, :code:`server.log`, check whether other fault casued the problem, such as FPE, lacking of memory or disk.
+
+* If network connection gave rise to the first error in the log, this may be caused by the port conflict of the non-exclusive execution. Connect with the operator to check if the current MPI cluster supports jobs submitted with parameter :code:`resource=full`. If so, change the port of job.
+
+* If the currnet MPI cluster does not support exclusive pattern, ask the operator to replace or update the current cluster.

From ce84af638bc6204c30272f3163e7f7b3026bcfec Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Mon, 26 Mar 2018 10:48:54 +0800
Subject: [PATCH 04/27] update

---
 doc/fluid/design/concepts/cpp_data_feeding.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/fluid/design/concepts/cpp_data_feeding.md b/doc/fluid/design/concepts/cpp_data_feeding.md
index 6ed3f604dc..9c44dec4b9 100644
--- a/doc/fluid/design/concepts/cpp_data_feeding.md
+++ b/doc/fluid/design/concepts/cpp_data_feeding.md
@@ -185,8 +185,8 @@ With `MultiPassReader`, the startup program would be like this:
 ```
 multiple_reader = open_files_op(...)
 batch_reader = create_batch_reader_op(multiple_reader)
-double_buffer_reader = create_double_buffer_op(batch_reader)
-multi_pass_reader = create_multi_pass_reader_op(double_buffer_reader)
+multi_pass_reader = create_multi_pass_reader_op(batch_reader)
+double_buffer_reader = create_double_buffer_op(multi_pass_reader)
 ... (other initializers)
 ```
 
@@ -195,8 +195,8 @@ The forwarding part of the corresponding `main_program` would be like this:
 ```
 not_completed = true
 while_op(not_completed) {
-    batch_data = read_op(multi_pass_reader)
+    batch_data = read_op(double_buffer_reader)
     ... (subsequent training ops)
-    not_completed = has_next_op(multi_pass_reader)
+    not_completed = has_next_op(double_buffer_reader)
 }
 ```

From ccfec1bcb15dbfbba9b0ce0087d79eb9206dce48 Mon Sep 17 00:00:00 2001
From: Luo Tao <luotao02@baidu.com>
Date: Mon, 26 Mar 2018 21:19:11 +0800
Subject: [PATCH 05/27] remove vars when remove ops

---
 paddle/fluid/framework/block_desc.cc          | 34 ++++++++++++++++---
 .../tests/unittests/test_protobuf_descs.py    | 27 +++++++++++++++
 2 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/paddle/fluid/framework/block_desc.cc b/paddle/fluid/framework/block_desc.cc
index 3693bc25d8..4faf9dcf37 100644
--- a/paddle/fluid/framework/block_desc.cc
+++ b/paddle/fluid/framework/block_desc.cc
@@ -148,14 +148,40 @@ void BlockDesc::RemoveOp(size_t s, size_t e) {
     return;
   }
   need_update_ = true;
+  std::vector<std::string> vars1;  // input vars from delete ops
   for (auto it = ops_.begin() + s; it != ops_.begin() + e; it++) {
-    auto names = (*it)->InputArgumentNames();
-    for (auto n : names) {
-      // TODO(typhoonzero): delete vars if no other op use it.
-      VLOG(3) << "deleting var " << n;
+    // delete all output vars
+    auto out_names = (*it)->OutputArgumentNames();
+    for (auto n : out_names) {
+      vars_.erase(vars_.find(n));
     }
+    // collect all input vars from remove ops
+    auto in_names = (*it)->InputArgumentNames();
+    vars1.insert(vars1.end(), in_names.begin(), in_names.end());
   }
   ops_.erase(ops_.begin() + s, ops_.begin() + e);
+
+  // collect input and output vars from remain ops
+  std::vector<std::string> vars2;
+  for (auto it = ops_.begin(); it != ops_.end(); it++) {
+    auto in_names = (*it)->InputArgumentNames();
+    auto out_names = (*it)->OutputArgumentNames();
+    vars2.insert(vars2.end(), in_names.begin(), in_names.end());
+    vars2.insert(vars2.end(), out_names.begin(), out_names.end());
+  }
+
+  // delete input vars if no other op use it.
+  std::vector<std::string> del_vars;
+  std::sort(vars1.begin(), vars1.end());
+  std::unique(vars1.begin(), vars1.end());
+  std::sort(vars2.begin(), vars2.end());
+  std::unique(vars2.begin(), vars2.end());
+  // del_vars = vars1 -  vars1 ^ vars2
+  std::set_difference(vars1.begin(), vars1.end(), vars2.begin(), vars2.end(),
+                      std::inserter(del_vars, del_vars.end()));
+  for (auto it = del_vars.begin(); it != del_vars.end(); it++) {
+    vars_.erase(vars_.find(*it));
+  }
 }
 
 std::vector<OpDesc *> BlockDesc::AllOps() const {
diff --git a/python/paddle/fluid/tests/unittests/test_protobuf_descs.py b/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
index 309ea2b9b7..871cb76fff 100644
--- a/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
+++ b/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
@@ -186,6 +186,33 @@ class TestBlockDesc(unittest.TestCase):
             all_ops.append(block.op(idx))
         self.assertEqual(all_ops, [op0, op1, op2])
 
+    def test_remove_op(self):
+        prog = core.ProgramDesc()
+        self.assertIsNotNone(prog)
+        block = prog.block(0)
+        self.assertIsNotNone(block)
+        op1 = block.append_op()
+        op2 = block.append_op()
+        var1 = block.var("var1")
+        var2 = block.var("var2")
+        var3 = block.var("var3")
+        var4 = block.var("var4")
+        op1.set_input("X", ["var1", "var2"])
+        op1.set_output("Y", ["var3"])
+        op2.set_input("X", ["var1"])
+        op2.set_output("Y", ["var4"])
+
+        # remove op1, its input var2 and output var3 will be removed at the same time,
+        # but its input var1 will not be removed since var1 is also an input for op2.
+        block.remove_op(0, 1)
+
+        all_ops = []
+        for idx in xrange(0, block.op_size()):
+            all_ops.append(block.op(idx))
+        self.assertEqual(all_ops, [op2])
+        all_vars = block.all_vars()
+        self.assertEqual(set(all_vars), {var1, var4})
+
 
 if __name__ == '__main__':
     unittest.main()

From f4925755dbf6c5470a6f0436b80acbdd32cf74b1 Mon Sep 17 00:00:00 2001
From: Xi Chen <putcncx@gmail.com>
Date: Mon, 26 Mar 2018 16:10:16 -0700
Subject: [PATCH 06/27] fix submit_local's paddle pip name issue

---
 paddle/scripts/submit_local.sh.in | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/paddle/scripts/submit_local.sh.in b/paddle/scripts/submit_local.sh.in
index 80fa0c72af..1283de9d95 100755
--- a/paddle/scripts/submit_local.sh.in
+++ b/paddle/scripts/submit_local.sh.in
@@ -153,9 +153,15 @@ if [ $? -ne 0 ]; then
     exit 1
 fi
 
-INSTALLED_VERSION=`pip freeze 2>/dev/null | grep '^paddle' | sed 's/.*==//g'`
+if [ "@WITH_GPU@" == "ON" ]; then
+    PADDLE_NAME="paddlepaddle-gpu"
+else 
+    PADDLE_NAME="paddlepaddle"
+fi
+
+INSTALLED_VERSION=`pip freeze 2>/dev/null | grep "^${PADDLE_NAME}==" | sed 's/.*==//g'`
 
-if [ -z ${INSTALLED_VERSION} ]; then
+if [ -z "${INSTALLED_VERSION}" ]; then
    INSTALLED_VERSION="0.0.0"  # not installed
 fi
 cat <<EOF | python -

From 68c199432b67049e39be585979c0af35c9f06c10 Mon Sep 17 00:00:00 2001
From: m3ngyang <yangm3ng@gmail.com>
Date: Tue, 27 Mar 2018 12:31:02 +0800
Subject: [PATCH 07/27] fix typo

---
 doc/v2/faq/cluster/index_en.rst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/v2/faq/cluster/index_en.rst b/doc/v2/faq/cluster/index_en.rst
index 7cbcaeefcb..fa942a0962 100644
--- a/doc/v2/faq/cluster/index_en.rst
+++ b/doc/v2/faq/cluster/index_en.rst
@@ -4,13 +4,13 @@ Cluster Training and Prediction
 
 .. contents::
 
-1. Network connection errors in the log during muliti-node cluster training
+1. Network connection errors in the log during multi-node cluster training
 ------------------------------------------------
-The errors in the log belong to network connection during mulilti-node cluster training, for example, :code:`Connection reset by peer`.
-This kind of error is usually caused by the abnormal exit of the training process in some node, and the others cannot connect with this node any longer. Steps to troubleshoot the problem as follows:
+There are maybe some errors in the log belonging to network connection problem during multi-node cluster training, for example, :code:`Connection reset by peer`.
+This kind of error is usually caused by the abnormal exit of a training process in some node, and the other nodes cannot connect with this node any longer. Steps to troubleshoot the problem are as follows:
 
 * Find the first error in the :code:`train.log`, :code:`server.log`, check whether other fault casued the problem, such as FPE, lacking of memory or disk.
 
-* If network connection gave rise to the first error in the log, this may be caused by the port conflict of the non-exclusive execution. Connect with the operator to check if the current MPI cluster supports jobs submitted with parameter :code:`resource=full`. If so, change the port of job.
+* If the first error in server.log says "Address already used", this may be caused by the port conflict of the non-exclusive execution. Connect the sys-admin to check if the current MPI cluster supports jobs submitted with parameter :code:`resource=full`. If the current MPI cluster does not support this parameter, change the server port and try agian.
 
-* If the currnet MPI cluster does not support exclusive pattern, ask the operator to replace or update the current cluster.
+* If the current MPI cluster does not support exclusive pattern which allows a process to occupy the whole node, ask the administrator to replace or update the this cluster.

From 25317bd312124cb3f26a2248c04215591d4e8446 Mon Sep 17 00:00:00 2001
From: qingqing01 <dangqingqing@baidu.com>
Date: Tue, 27 Mar 2018 16:32:31 +0800
Subject: [PATCH 08/27] Make the first device share data with the global scope
 in parallel_do_op. (#9398)

---
 paddle/fluid/operators/parallel_do_op.cc | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/paddle/fluid/operators/parallel_do_op.cc b/paddle/fluid/operators/parallel_do_op.cc
index 4001b9a130..b28c16b13f 100644
--- a/paddle/fluid/operators/parallel_do_op.cc
+++ b/paddle/fluid/operators/parallel_do_op.cc
@@ -144,7 +144,12 @@ class ParallelDoOp : public framework::OperatorBase {
       PADDLE_ENFORCE(scope.FindVar(param)->IsType<LoDTensor>(),
                      "Only support parameter type as LoDTensor");
       auto &src = scope.FindVar(param)->Get<LoDTensor>();
-      for (size_t i = 0; i < sub_scopes.size(); ++i) {
+
+      auto *sub_scope0 = sub_scopes[0];
+      auto *dst0 = sub_scope0->Var(param)->GetMutable<LoDTensor>();
+      dst0->ShareDataWith(src);
+
+      for (size_t i = 1; i < sub_scopes.size(); ++i) {
         auto &place = places[i];
         auto *sub_scope = sub_scopes[i];
         auto *dst = sub_scope->Var(param)->GetMutable<LoDTensor>();

From 7f4012247e09aec9c9d912a806bdf6b5dfabe97a Mon Sep 17 00:00:00 2001
From: Luo Tao <luotao02@baidu.com>
Date: Tue, 27 Mar 2018 18:55:32 +0800
Subject: [PATCH 09/27] adjust remove rule for variables

---
 paddle/fluid/framework/block_desc.cc          | 73 +++++++++++--------
 paddle/fluid/framework/block_desc.h           |  5 ++
 .../tests/unittests/test_protobuf_descs.py    |  9 ++-
 3 files changed, 52 insertions(+), 35 deletions(-)

diff --git a/paddle/fluid/framework/block_desc.cc b/paddle/fluid/framework/block_desc.cc
index 4faf9dcf37..fbe08349c3 100644
--- a/paddle/fluid/framework/block_desc.cc
+++ b/paddle/fluid/framework/block_desc.cc
@@ -147,40 +147,51 @@ void BlockDesc::RemoveOp(size_t s, size_t e) {
   if (ops_.begin() + s == ops_.end() || ops_.begin() + e == ops_.end()) {
     return;
   }
+  auto get_vars = [](std::deque<std::unique_ptr<OpDesc>>::iterator &op,
+                     std::vector<std::string> &v) {
+    auto in_names = (*op)->InputArgumentNames();
+    v.insert(v.end(), in_names.begin(), in_names.end());
+    auto out_names = (*op)->OutputArgumentNames();
+    v.insert(v.end(), out_names.begin(), out_names.end());
+    std::sort(v.begin(), v.end());
+    auto last = std::unique(v.begin(), v.end());
+    v.erase(last, v.end());
+  };
   need_update_ = true;
-  std::vector<std::string> vars1;  // input vars from delete ops
-  for (auto it = ops_.begin() + s; it != ops_.begin() + e; it++) {
-    // delete all output vars
-    auto out_names = (*it)->OutputArgumentNames();
-    for (auto n : out_names) {
-      vars_.erase(vars_.find(n));
+
+  for (size_t i = s; i < e; i++) {
+    // since remove op one by one, every time remove the first op.
+    auto op = ops_.begin() + s;
+
+    // collect input and output variables from current delete op
+    std::vector<std::string> cur_vars;
+    get_vars(op, cur_vars);
+
+    // remove current op
+    ops_.erase(ops_.begin() + s);
+
+    // collect input and output variables from other ops
+    std::vector<std::string> other_vars;
+    for (auto it = ops_.begin(); it != ops_.end(); it++) {
+      get_vars(it, other_vars);
     }
-    // collect all input vars from remove ops
-    auto in_names = (*it)->InputArgumentNames();
-    vars1.insert(vars1.end(), in_names.begin(), in_names.end());
-  }
-  ops_.erase(ops_.begin() + s, ops_.begin() + e);
-
-  // collect input and output vars from remain ops
-  std::vector<std::string> vars2;
-  for (auto it = ops_.begin(); it != ops_.end(); it++) {
-    auto in_names = (*it)->InputArgumentNames();
-    auto out_names = (*it)->OutputArgumentNames();
-    vars2.insert(vars2.end(), in_names.begin(), in_names.end());
-    vars2.insert(vars2.end(), out_names.begin(), out_names.end());
-  }
 
-  // delete input vars if no other op use it.
-  std::vector<std::string> del_vars;
-  std::sort(vars1.begin(), vars1.end());
-  std::unique(vars1.begin(), vars1.end());
-  std::sort(vars2.begin(), vars2.end());
-  std::unique(vars2.begin(), vars2.end());
-  // del_vars = vars1 -  vars1 ^ vars2
-  std::set_difference(vars1.begin(), vars1.end(), vars2.begin(), vars2.end(),
-                      std::inserter(del_vars, del_vars.end()));
-  for (auto it = del_vars.begin(); it != del_vars.end(); it++) {
-    vars_.erase(vars_.find(*it));
+    // variables should be deleted
+    std::vector<std::string> delete_vars;
+    // delete_vars = cur_vars -  cur_vars ^ other_input_vars
+    std::set_difference(cur_vars.begin(), cur_vars.end(), other_vars.begin(),
+                        other_vars.end(),
+                        std::inserter(delete_vars, delete_vars.end()));
+    // remove variables
+    for (size_t i = 0; i < delete_vars.size(); i++) {
+      auto name = delete_vars[i];
+      auto it = vars_.find(name);
+      PADDLE_ENFORCE(it != vars_.end(),
+                     "%s is not in variable list, it should not be deleted",
+                     name);
+      vars_.erase(it);
+      VLOG(3) << "deleting variable " << name;
+    }
   }
 }
 
diff --git a/paddle/fluid/framework/block_desc.h b/paddle/fluid/framework/block_desc.h
index 185f018ac1..468423e0e8 100644
--- a/paddle/fluid/framework/block_desc.h
+++ b/paddle/fluid/framework/block_desc.h
@@ -89,6 +89,11 @@ class BlockDesc {
 
   OpDesc *InsertOp(size_t index);
 
+  /*
+   * Remove Op and its input/output variables.
+   * Note that for either input or ouput variable, if it is also an input or
+   * output variable of other ops, we should remain it.
+   */
   void RemoveOp(size_t s, size_t e);
 
   std::vector<OpDesc *> AllOps() const;
diff --git a/python/paddle/fluid/tests/unittests/test_protobuf_descs.py b/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
index 871cb76fff..da85786d0c 100644
--- a/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
+++ b/python/paddle/fluid/tests/unittests/test_protobuf_descs.py
@@ -197,13 +197,14 @@ class TestBlockDesc(unittest.TestCase):
         var2 = block.var("var2")
         var3 = block.var("var3")
         var4 = block.var("var4")
+        var5 = block.var("var5")
         op1.set_input("X", ["var1", "var2"])
-        op1.set_output("Y", ["var3"])
+        op1.set_output("Y", ["var3", "var4"])
         op2.set_input("X", ["var1"])
-        op2.set_output("Y", ["var4"])
+        op2.set_output("Y", ["var4", "var5"])
 
         # remove op1, its input var2 and output var3 will be removed at the same time,
-        # but its input var1 will not be removed since var1 is also an input for op2.
+        # but its input var1 and output var4 will not be removed since they are used for op2.
         block.remove_op(0, 1)
 
         all_ops = []
@@ -211,7 +212,7 @@ class TestBlockDesc(unittest.TestCase):
             all_ops.append(block.op(idx))
         self.assertEqual(all_ops, [op2])
         all_vars = block.all_vars()
-        self.assertEqual(set(all_vars), {var1, var4})
+        self.assertEqual(set(all_vars), {var1, var4, var5})
 
 
 if __name__ == '__main__':

From 587781153eb21ad69e571d012002dd97b93d9a88 Mon Sep 17 00:00:00 2001
From: typhoonzero <typhoonzero1986@gmail.com>
Date: Tue, 27 Mar 2018 20:41:21 +0800
Subject: [PATCH 10/27] fix slr deser

---
 paddle/fluid/operators/detail/variable_response.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/paddle/fluid/operators/detail/variable_response.cc b/paddle/fluid/operators/detail/variable_response.cc
index 12e8eb0b4d..d0f103c455 100644
--- a/paddle/fluid/operators/detail/variable_response.cc
+++ b/paddle/fluid/operators/detail/variable_response.cc
@@ -153,6 +153,7 @@ bool VariableResponse::CopySelectRowsData(
     const platform::DeviceContext& ctx, int length) {
   auto var = scope_->FindVar(meta_.varname());
   auto* slr = var->GetMutable<framework::SelectedRows>();
+  slr->mutable_rows()->resize(length / 8);
   int64_t* rows_data = slr->mutable_rows()->data();
 
   // copy rows CPU data, GPU data will be copied lazily.

From 094d5096899344206892cc2f82b85bfe2bae2bac Mon Sep 17 00:00:00 2001
From: typhoonzero <typhoonzero1986@gmail.com>
Date: Tue, 27 Mar 2018 20:41:33 +0800
Subject: [PATCH 11/27] fix slr deser

---
 paddle/fluid/operators/detail/variable_response.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/fluid/operators/detail/variable_response.cc b/paddle/fluid/operators/detail/variable_response.cc
index d0f103c455..3787b139a5 100644
--- a/paddle/fluid/operators/detail/variable_response.cc
+++ b/paddle/fluid/operators/detail/variable_response.cc
@@ -153,7 +153,7 @@ bool VariableResponse::CopySelectRowsData(
     const platform::DeviceContext& ctx, int length) {
   auto var = scope_->FindVar(meta_.varname());
   auto* slr = var->GetMutable<framework::SelectedRows>();
-  slr->mutable_rows()->resize(length / 8);
+  slr->mutable_rows()->resize(length / 8);  // int64
   int64_t* rows_data = slr->mutable_rows()->data();
 
   // copy rows CPU data, GPU data will be copied lazily.

From cc1c6afbbf6df880b2954b61cf1afdc9c368597d Mon Sep 17 00:00:00 2001
From: "yi.wu" <yi.wu@baifendian.com>
Date: Tue, 27 Mar 2018 23:17:30 +0800
Subject: [PATCH 12/27] fix slr serde

---
 .../operators/detail/variable_response.cc     | 23 ++++++++++++++-----
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/paddle/fluid/operators/detail/variable_response.cc b/paddle/fluid/operators/detail/variable_response.cc
index 3787b139a5..bdda570343 100644
--- a/paddle/fluid/operators/detail/variable_response.cc
+++ b/paddle/fluid/operators/detail/variable_response.cc
@@ -48,6 +48,8 @@ bool ReadRaw(::google::protobuf::io::CodedInputStream* input,
              void* dest, int size) {
   const void* data = NULL;
   int size_to_write = 0;
+  int length = size;
+  int total_written = 0;
 
   if (platform::is_gpu_place(place)) {
 #ifdef PADDLE_WITH_CUDA
@@ -56,16 +58,21 @@ bool ReadRaw(::google::protobuf::io::CodedInputStream* input,
     platform::CPUPlace cpu;
 
     char* p = reinterpret_cast<char*>(dest);
-    while (size > 0) {
+    while (total_written < length) {
       if (!input->GetDirectBufferPointer(&data, &size_to_write)) {
         return false;
       }
-
+      // NOTE: if raw buffer is large and have two neighbor fields of raw
+      // buffers GetDirectBufferPointer can get all of them, use length to
+      // truncate it.
+      if (total_written + size_to_write > length) {
+        size_to_write = length - total_written;
+      }
       memory::Copy(boost::get<platform::CUDAPlace>(place),
                    reinterpret_cast<void*>(p), cpu, data, size_to_write,
                    gpu_dev_ctx.stream());
       p += size_to_write;
-      size -= size_to_write;
+      total_written += size_to_write;
 
       input->Skip(size_to_write);
     }
@@ -77,16 +84,21 @@ bool ReadRaw(::google::protobuf::io::CodedInputStream* input,
   }
 
   char* p = reinterpret_cast<char*>(dest);
-  while (size > 0) {
+  while (total_written < length) {
     if (!input->GetDirectBufferPointer(&data, &size_to_write)) {
       return false;
     }
+    // NOTE: if raw buffer is large and have two neighbor fields of raw buffers
+    // GetDirectBufferPointer can get all of them, use length to truncate it.
+    if (total_written + size_to_write > length) {
+      size_to_write = length - total_written;
+    }
     // TODO(gongwb): can we avoid copy?
     platform::CPUPlace cpu;
     memory::Copy(cpu, reinterpret_cast<void*>(p), cpu, data, size_to_write);
 
     p += size_to_write;
-    size -= size_to_write;
+    total_written += size_to_write;
 
     input->Skip(size_to_write);
   }
@@ -234,7 +246,6 @@ int VariableResponse::Parse(Source* source) {
       if (tag != 0) {
         return -1;
       }
-
       return 0;
     }
 

From 0e7413938a109285e41f3a55650c6a338279c355 Mon Sep 17 00:00:00 2001
From: Xi Chen <putcncx@gmail.com>
Date: Tue, 27 Mar 2018 14:32:42 -0700
Subject: [PATCH 13/27] added missing *.pb.h *.pb.cc generation to fix
 distribute build issue

---
 cmake/generic.cmake | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cmake/generic.cmake b/cmake/generic.cmake
index c749c97f13..c0808ac06c 100644
--- a/cmake/generic.cmake
+++ b/cmake/generic.cmake
@@ -597,6 +597,9 @@ function(grpc_library TARGET_NAME)
           COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
           ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}" -I "${PROTO_PATH}"
           --plugin=protoc-gen-grpc="${GRPC_CPP_PLUGIN}" "${ABS_PROTO}"
+          COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+          ARGS --cpp_out "${CMAKE_CURRENT_BINARY_DIR}" -I "${PROTO_PATH}"
+          "${ABS_PROTO}"
           DEPENDS "${ABS_PROTO}" ${PROTOBUF_PROTOC_EXECUTABLE} extern_grpc)
 
   # FIXME(typhoonzero): grpc generated code do not generate virtual-dtor, mark it

From 54a8c04fab9310ef78f0b000ae411fd7ae706ee7 Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Tue, 27 Mar 2018 22:09:43 +0000
Subject: [PATCH 14/27] add inplace attr to bn

---
 python/paddle/fluid/layers/nn.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py
index 2db4e5d27d..0332556f62 100644
--- a/python/paddle/fluid/layers/nn.py
+++ b/python/paddle/fluid/layers/nn.py
@@ -1483,6 +1483,7 @@ def batch_norm(input,
                param_attr=None,
                bias_attr=None,
                data_layout='NCHW',
+               in_place=False,
                name=None,
                moving_mean_name=None,
                moving_variance_name=None):
@@ -1538,7 +1539,7 @@ def batch_norm(input,
     saved_mean = helper.create_tmp_variable(dtype=dtype, stop_gradient=True)
     saved_variance = helper.create_tmp_variable(dtype=dtype, stop_gradient=True)
 
-    batch_norm_out = helper.create_tmp_variable(dtype)
+    batch_norm_out = input if in_place else helper.create_tmp_variable(dtype)
 
     helper.append_op(
         type="batch_norm",

From f34f2d40267ce7334af6092242c7eef83e3f33aa Mon Sep 17 00:00:00 2001
From: Yang Yang <yangyang62@baidu.com>
Date: Tue, 27 Mar 2018 22:10:32 +0000
Subject: [PATCH 15/27] make bn inplace in img_conv_group by default

---
 python/paddle/fluid/nets.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/paddle/fluid/nets.py b/python/paddle/fluid/nets.py
index 3b2e1a3073..bbedf6fde0 100644
--- a/python/paddle/fluid/nets.py
+++ b/python/paddle/fluid/nets.py
@@ -98,7 +98,7 @@ def img_conv_group(input,
             use_mkldnn=use_mkldnn)
 
         if conv_with_batchnorm[i]:
-            tmp = layers.batch_norm(input=tmp, act=conv_act)
+            tmp = layers.batch_norm(input=tmp, act=conv_act, in_place=True)
             drop_rate = conv_batchnorm_drop_rate[i]
             if abs(drop_rate) > 1e-5:
                 tmp = layers.dropout(x=tmp, dropout_prob=drop_rate)

From d4f49355309f257f33ce08c4d680c712ee5cf2a0 Mon Sep 17 00:00:00 2001
From: Xi Chen <putcncx@gmail.com>
Date: Tue, 27 Mar 2018 18:56:04 -0700
Subject: [PATCH 16/27] test removal of redundant line

---
 cmake/generic.cmake | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cmake/generic.cmake b/cmake/generic.cmake
index c0808ac06c..981da16a45 100644
--- a/cmake/generic.cmake
+++ b/cmake/generic.cmake
@@ -587,7 +587,6 @@ function(grpc_library TARGET_NAME)
   get_filename_component(PROTO_WE ${grpc_library_PROTO} NAME_WE)
   get_filename_component(PROTO_PATH ${ABS_PROTO} PATH)
 
-  protobuf_generate_cpp(grpc_proto_srcs grpc_proto_hdrs "${ABS_PROTO}")
   set(grpc_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.cc")
   set(grpc_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.h")
   cc_library("${TARGET_NAME}_proto" SRCS "${grpc_proto_srcs}")

From 06aaea8a64c59467d45f2cf2e4eea3d0e91d946a Mon Sep 17 00:00:00 2001
From: Xi Chen <putcncx@gmail.com>
Date: Tue, 27 Mar 2018 19:10:04 -0700
Subject: [PATCH 17/27] Revert "test removal of redundant line"

This reverts commit d4f49355309f257f33ce08c4d680c712ee5cf2a0.
---
 cmake/generic.cmake | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cmake/generic.cmake b/cmake/generic.cmake
index 981da16a45..c0808ac06c 100644
--- a/cmake/generic.cmake
+++ b/cmake/generic.cmake
@@ -587,6 +587,7 @@ function(grpc_library TARGET_NAME)
   get_filename_component(PROTO_WE ${grpc_library_PROTO} NAME_WE)
   get_filename_component(PROTO_PATH ${ABS_PROTO} PATH)
 
+  protobuf_generate_cpp(grpc_proto_srcs grpc_proto_hdrs "${ABS_PROTO}")
   set(grpc_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.cc")
   set(grpc_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.h")
   cc_library("${TARGET_NAME}_proto" SRCS "${grpc_proto_srcs}")

From 1daa96579cd5df393b8f848c72ea9974a8d25b62 Mon Sep 17 00:00:00 2001
From: Xi Chen <putcncx@gmail.com>
Date: Tue, 27 Mar 2018 20:14:34 -0700
Subject: [PATCH 18/27] adding comments for this fix

---
 cmake/generic.cmake | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cmake/generic.cmake b/cmake/generic.cmake
index c0808ac06c..3fe750f47e 100644
--- a/cmake/generic.cmake
+++ b/cmake/generic.cmake
@@ -587,6 +587,9 @@ function(grpc_library TARGET_NAME)
   get_filename_component(PROTO_WE ${grpc_library_PROTO} NAME_WE)
   get_filename_component(PROTO_PATH ${ABS_PROTO} PATH)
 
+  #FIXME(putcn): the follwoing line is supposed to generate *.pb.h and cc, but
+  # somehow it didn't. line 602 to 604 is to patching this. Leaving this here 
+  # for now to enable dist CI.
   protobuf_generate_cpp(grpc_proto_srcs grpc_proto_hdrs "${ABS_PROTO}")
   set(grpc_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.cc")
   set(grpc_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/${PROTO_WE}.grpc.pb.h")

From 9a9d67dac28c362b6b2e86ffeec7c68fa1704d01 Mon Sep 17 00:00:00 2001
From: typhoonzero <typhoonzero1986@gmail.com>
Date: Wed, 28 Mar 2018 16:47:06 +0800
Subject: [PATCH 19/27] fix dist train selected rows height missing

---
 paddle/fluid/operators/detail/send_recv.proto      |  8 ++++----
 paddle/fluid/operators/detail/sendrecvop_utils.cc  |  1 +
 paddle/fluid/operators/detail/test_serde.cc        |  2 ++
 paddle/fluid/operators/detail/variable_response.cc | 11 +++++++++++
 4 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/paddle/fluid/operators/detail/send_recv.proto b/paddle/fluid/operators/detail/send_recv.proto
index 598aaa4c51..2d33f026e4 100644
--- a/paddle/fluid/operators/detail/send_recv.proto
+++ b/paddle/fluid/operators/detail/send_recv.proto
@@ -59,12 +59,12 @@ message VariableMessage {
   // lod details:
   int64 lod_level = 5;
   repeated LodData lod = 6;
+  // selected_rows height, aka. original dim0
+  int64 slr_height = 7;
   // tensor data
-  bytes serialized = 7;
+  bytes serialized = 8;
   // selected_rows data
-  bytes rows = 8;
+  bytes rows = 9;
 }
 
 message VoidMessage {}
-
-message TestMessage { int64 test_1 = 1; }
diff --git a/paddle/fluid/operators/detail/sendrecvop_utils.cc b/paddle/fluid/operators/detail/sendrecvop_utils.cc
index d7bbf79c50..f318f8ac28 100644
--- a/paddle/fluid/operators/detail/sendrecvop_utils.cc
+++ b/paddle/fluid/operators/detail/sendrecvop_utils.cc
@@ -108,6 +108,7 @@ void SerializeToByteBuffer(const std::string& name, framework::Variable* var,
         e.WriteUint64(VarMsg::kDimsFieldNumber, dim);
       }
       e.WriteUint64(VarMsg::kLodLevelFieldNumber, 0);
+      e.WriteUint64(VarMsg::kSlrHeightFieldNumber, slr->height());
       auto* tensor = slr->mutable_value();
       if (platform::is_gpu_place(ctx.GetPlace())) {
 #ifdef PADDLE_WITH_CUDA
diff --git a/paddle/fluid/operators/detail/test_serde.cc b/paddle/fluid/operators/detail/test_serde.cc
index e646c894d1..e9e2dc84ad 100644
--- a/paddle/fluid/operators/detail/test_serde.cc
+++ b/paddle/fluid/operators/detail/test_serde.cc
@@ -40,6 +40,7 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   // serialize var to ByteBuffer
   framework::Variable var;
   auto* slr = var.GetMutable<framework::SelectedRows>();
+  slr->set_height(1000);
   auto* tensor = slr->mutable_value();
   auto* rows = slr->mutable_rows();
   tensor->Resize(framework::make_ddim({2, 10}));
@@ -106,6 +107,7 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   }
   EXPECT_EQ(rows_data2[0], 3);
   EXPECT_EQ(rows_data2[1], 10);
+  EXPECT_EQ(slr2->height(), 1000);
 }
 
 void RunTestLodTensor(platform::Place place, int from_type = 0) {
diff --git a/paddle/fluid/operators/detail/variable_response.cc b/paddle/fluid/operators/detail/variable_response.cc
index bdda570343..862fd26b54 100644
--- a/paddle/fluid/operators/detail/variable_response.cc
+++ b/paddle/fluid/operators/detail/variable_response.cc
@@ -68,6 +68,8 @@ bool ReadRaw(::google::protobuf::io::CodedInputStream* input,
       if (total_written + size_to_write > length) {
         size_to_write = length - total_written;
       }
+      VLOG(3) << "copy raw " << size_to_write
+              << " bytes, written: " << total_written << ", length: " << length;
       memory::Copy(boost::get<platform::CUDAPlace>(place),
                    reinterpret_cast<void*>(p), cpu, data, size_to_write,
                    gpu_dev_ctx.stream());
@@ -147,6 +149,7 @@ bool VariableResponse::CopySelectRowsTensorData(
     const platform::DeviceContext& ctx, framework::DDim& dims, int length) {
   auto var = scope_->FindVar(meta_.varname());
   auto* slr = var->GetMutable<framework::SelectedRows>();
+  slr->set_height(meta_.slr_height());
   auto* tensor = slr->mutable_value();
   tensor->Resize(dims);
   void* tensor_data = tensor->mutable_data(
@@ -348,6 +351,14 @@ int VariableResponse::Parse(Source* source) {
         }
         break;
       }
+      case sendrecv::VariableMessage::kSlrHeightFieldNumber: {
+        uint64_t v = 0;
+        if ((wt != WIRETYPE_VARINT) || !input.ReadVarint64(&v)) {
+          return tag;
+        }
+        meta_.set_slr_height(static_cast<int64_t>(v));
+        break;
+      }
       case sendrecv::VariableMessage::kSerializedFieldNumber: {
         PADDLE_ENFORCE((meta_.type() == sendrecv::SELECTED_ROWS ||
                         meta_.type() == sendrecv::LOD_TENSOR) &&

From 2e577379ca8fc67dbb4fc436297cf7ae826b3fa7 Mon Sep 17 00:00:00 2001
From: chengduoZH <zhaochengduo@163.com>
Date: Wed, 28 Mar 2018 16:52:20 +0800
Subject: [PATCH 20/27] add cos

---
 paddle/fluid/operators/activation_op.cc       | 18 +++++++
 paddle/fluid/operators/activation_op.h        | 49 +++++++++++++++++++
 paddle/function/EigenGemm.cpp                 |  1 +
 python/paddle/fluid/layers/ops.py             |  1 +
 .../tests/unittests/test_activation_op.py     | 15 ++++++
 5 files changed, 84 insertions(+)

diff --git a/paddle/fluid/operators/activation_op.cc b/paddle/fluid/operators/activation_op.cc
index 979115eee0..7f4b23c526 100644
--- a/paddle/fluid/operators/activation_op.cc
+++ b/paddle/fluid/operators/activation_op.cc
@@ -260,6 +260,21 @@ $out = floor(x)$
   }
 };
 
+class CosOpMaker : public framework::OpProtoAndCheckerMaker {
+ public:
+  CosOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : framework::OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "Input of Floor operator");
+    AddOutput("Out", "Output of Floor operator");
+    AddComment(R"DOC(
+Floor Activation Operator.
+
+$out = cos(x)$
+
+)DOC");
+  }
+};
+
 class RoundOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
   RoundOpMaker(OpProto *proto, OpAttrChecker *op_checker)
@@ -561,6 +576,9 @@ REGISTER_OP(ceil, ops::ActivationOp, ops::CeilOpMaker, ceil_grad,
 REGISTER_OP(floor, ops::ActivationOp, ops::FloorOpMaker, floor_grad,
             ops::ActivationOpGrad);
 
+REGISTER_OP(cos, ops::ActivationOp, ops::CosOpMaker, cos_grad,
+            ops::ActivationOpGrad);
+
 REGISTER_OP(round, ops::ActivationOp, ops::RoundOpMaker, round_grad,
             ops::ActivationOpGrad);
 
diff --git a/paddle/fluid/operators/activation_op.h b/paddle/fluid/operators/activation_op.h
index 4c575b4a7b..3bd3f0bb94 100644
--- a/paddle/fluid/operators/activation_op.h
+++ b/paddle/fluid/operators/activation_op.h
@@ -331,6 +331,54 @@ struct FloorFunctor : public BaseActivationFunctor<T> {
   }
 };
 
+template <typename T>
+struct Sine {
+  HOSTDEVICE T operator()(const T& val) const { return sin(val); }
+};
+
+template <typename T>
+struct Cosine {
+  HOSTDEVICE T operator()(const T& val) const { return cos(val); }
+};
+
+// cosine'(x) = -sin(x)
+template <typename T>
+struct CosGradFunctor : public BaseActivationFunctor<T> {
+  template <typename Device, typename X, typename Out, typename dOut,
+            typename dX>
+  void operator()(Device d, X x, Out out, dOut dout, dX dx) const {
+    dx.device(d) = -dout * x.unaryExpr(Sine<T>());
+  }
+};
+
+// cosine(x) = cos(x)
+template <typename T>
+struct CosFunctor : public BaseActivationFunctor<T> {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.unaryExpr(Cosine<T>());
+  }
+};
+
+// sine'(x) = cos(x)
+template <typename T>
+struct SinGradFunctor : public BaseActivationFunctor<T> {
+  template <typename Device, typename X, typename Out, typename dOut,
+            typename dX>
+  void operator()(Device d, X x, Out out, dOut dout, dX dx) const {
+    dx.device(d) = dout * x.unaryExpr(Cosine<T>());
+  }
+};
+
+// sine(x) = sin(x)
+template <typename T>
+struct SinFunctor : public BaseActivationFunctor<T> {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.unaryExpr(Sine<T>());
+  }
+};
+
 // round(x) = [x]
 template <typename T>
 struct RoundFunctor : public BaseActivationFunctor<T> {
@@ -782,6 +830,7 @@ struct SwishGradFunctor : public BaseActivationFunctor<T> {
   __macro(abs, AbsFunctor, AbsGradFunctor);                          \
   __macro(ceil, CeilFunctor, ZeroGradFunctor);                       \
   __macro(floor, FloorFunctor, ZeroGradFunctor);                     \
+  __macro(cos, CosFunctor, CosGradFunctor);                          \
   __macro(round, RoundFunctor, ZeroGradFunctor);                     \
   __macro(reciprocal, ReciprocalFunctor, ReciprocalGradFunctor);     \
   __macro(log, LogFunctor, LogGradFunctor);                          \
diff --git a/paddle/function/EigenGemm.cpp b/paddle/function/EigenGemm.cpp
index bac4659e62..4c81ebdd31 100644
--- a/paddle/function/EigenGemm.cpp
+++ b/paddle/function/EigenGemm.cpp
@@ -63,6 +63,7 @@ struct EigenBlasGemm {
     const EigenMatrix a(const_cast<T*>(A), sizeA);
     const EigenMatrix b(const_cast<T*>(B), sizeB);
     EigenMatrix c(C, sizeC);
+    Eigen::Tensor<T, 2, Eigen::RowMajor, int> ss;
 
     typedef typename Eigen::Tensor<T, 2>::DimensionPair DimPair;
     Eigen::array<DimPair, 1> dims;
diff --git a/python/paddle/fluid/layers/ops.py b/python/paddle/fluid/layers/ops.py
index f5c6b47d24..ee8de219ee 100644
--- a/python/paddle/fluid/layers/ops.py
+++ b/python/paddle/fluid/layers/ops.py
@@ -25,6 +25,7 @@ __activations__ = [
     'abs',
     'ceil',
     'floor',
+    'cos',
     'round',
     'reciprocal',
     'log',
diff --git a/python/paddle/fluid/tests/unittests/test_activation_op.py b/python/paddle/fluid/tests/unittests/test_activation_op.py
index 4a2b35322d..b78fb8a319 100644
--- a/python/paddle/fluid/tests/unittests/test_activation_op.py
+++ b/python/paddle/fluid/tests/unittests/test_activation_op.py
@@ -14,6 +14,7 @@
 
 import unittest
 import numpy as np
+import math
 import paddle.fluid.core as core
 from op_test import OpTest
 from scipy.special import expit
@@ -196,6 +197,20 @@ class TestFloor(OpTest):
         self.check_grad(['X'], 'Out', max_relative_error=0.007)
 
 
+class TestCos(OpTest):
+    def setUp(self):
+        self.op_type = "cos"
+        x = np.random.uniform(-1, 1, [4, 4]).astype("float32")
+        self.inputs = {'X': x}
+        self.outputs = {'Out': math.cos(self.inputs['X'])}
+
+    def test_check_output(self):
+        self.check_output()
+
+    def test_check_grad(self):
+        self.check_grad(['X'], 'Out', max_relative_error=0.007)
+
+
 class TestRound(OpTest):
     def setUp(self):
         self.op_type = "round"

From ce16400daedfa8f793d20d44081db7f417af693a Mon Sep 17 00:00:00 2001
From: "Yang Yang(Tony)" <yangyang62@baidu.com>
Date: Wed, 28 Mar 2018 21:15:12 -0700
Subject: [PATCH 21/27] make append activation in place by default (#9417)

---
 python/paddle/fluid/layer_helper.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/python/paddle/fluid/layer_helper.py b/python/paddle/fluid/layer_helper.py
index d771837fc5..4341e06596 100644
--- a/python/paddle/fluid/layer_helper.py
+++ b/python/paddle/fluid/layer_helper.py
@@ -398,7 +398,6 @@ class LayerHelper(object):
             return input_var
         if isinstance(act, basestring):
             act = {'type': act}
-        tmp = self.create_tmp_variable(dtype=input_var.dtype)
 
         if 'use_mkldnn' in self.kwargs:
             act['use_mkldnn'] = self.kwargs.get('use_mkldnn')
@@ -408,9 +407,9 @@ class LayerHelper(object):
         self.append_op(
             type=act_type,
             inputs={"X": [input_var]},
-            outputs={"Out": [tmp]},
+            outputs={"Out": [input_var]},
             attrs=act)
-        return tmp
+        return input_var
 
     def _get_default_initializer(self, dtype):
         if dtype is None or dtype_is_floating(dtype) is True:

From bdda08d9f2846cd4a5cb407e993be0bc03a674a5 Mon Sep 17 00:00:00 2001
From: chengduoZH <zhaochengduo@163.com>
Date: Wed, 28 Mar 2018 23:13:38 +0800
Subject: [PATCH 22/27] add sin

---
 paddle/fluid/framework/CMakeLists.txt         |  2 +-
 paddle/fluid/operators/activation_op.cc       | 24 ++++++++++++++++---
 paddle/fluid/operators/activation_op.h        |  1 +
 paddle/function/EigenGemm.cpp                 |  1 -
 python/paddle/fluid/layers/ops.py             |  1 +
 .../tests/unittests/test_activation_op.py     | 17 +++++++++++--
 6 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/paddle/fluid/framework/CMakeLists.txt b/paddle/fluid/framework/CMakeLists.txt
index a4ea74a6d2..8c8def6bf4 100644
--- a/paddle/fluid/framework/CMakeLists.txt
+++ b/paddle/fluid/framework/CMakeLists.txt
@@ -100,7 +100,7 @@ cc_test(init_test SRCS init_test.cc DEPS init)
 cc_test(op_kernel_type_test SRCS op_kernel_type_test.cc DEPS place device_context framework_proto)
 cc_test(cow_ptr_tests SRCS details/cow_ptr_test.cc)
       
-cc_test(channel_test SRCS channel_test.cc)
+# cc_test(channel_test SRCS channel_test.cc)
 cc_test(tuple_test SRCS tuple_test.cc )
 cc_test(concurrency_test SRCS concurrency_test.cc DEPS go_op channel_close_op channel_create_op
         channel_send_op channel_recv_op sum_op select_op elementwise_add_op compare_op
diff --git a/paddle/fluid/operators/activation_op.cc b/paddle/fluid/operators/activation_op.cc
index 7f4b23c526..a6d9ce0f04 100644
--- a/paddle/fluid/operators/activation_op.cc
+++ b/paddle/fluid/operators/activation_op.cc
@@ -264,10 +264,10 @@ class CosOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
   CosOpMaker(OpProto *proto, OpAttrChecker *op_checker)
       : framework::OpProtoAndCheckerMaker(proto, op_checker) {
-    AddInput("X", "Input of Floor operator");
-    AddOutput("Out", "Output of Floor operator");
+    AddInput("X", "Input of Cosine operator");
+    AddOutput("Out", "Output of Cosine operator");
     AddComment(R"DOC(
-Floor Activation Operator.
+Cosine Activation Operator.
 
 $out = cos(x)$
 
@@ -275,6 +275,21 @@ $out = cos(x)$
   }
 };
 
+class SinOpMaker : public framework::OpProtoAndCheckerMaker {
+ public:
+  SinOpMaker(OpProto *proto, OpAttrChecker *op_checker)
+      : framework::OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "Input of Sine operator");
+    AddOutput("Out", "Output of Sine operator");
+    AddComment(R"DOC(
+Sine Activation Operator.
+
+$out = sin(x)$
+
+)DOC");
+  }
+};
+
 class RoundOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
   RoundOpMaker(OpProto *proto, OpAttrChecker *op_checker)
@@ -579,6 +594,9 @@ REGISTER_OP(floor, ops::ActivationOp, ops::FloorOpMaker, floor_grad,
 REGISTER_OP(cos, ops::ActivationOp, ops::CosOpMaker, cos_grad,
             ops::ActivationOpGrad);
 
+REGISTER_OP(sin, ops::ActivationOp, ops::SinOpMaker, sin_grad,
+            ops::ActivationOpGrad);
+
 REGISTER_OP(round, ops::ActivationOp, ops::RoundOpMaker, round_grad,
             ops::ActivationOpGrad);
 
diff --git a/paddle/fluid/operators/activation_op.h b/paddle/fluid/operators/activation_op.h
index 3bd3f0bb94..7fbe4efc04 100644
--- a/paddle/fluid/operators/activation_op.h
+++ b/paddle/fluid/operators/activation_op.h
@@ -831,6 +831,7 @@ struct SwishGradFunctor : public BaseActivationFunctor<T> {
   __macro(ceil, CeilFunctor, ZeroGradFunctor);                       \
   __macro(floor, FloorFunctor, ZeroGradFunctor);                     \
   __macro(cos, CosFunctor, CosGradFunctor);                          \
+  __macro(sin, SinFunctor, SinGradFunctor);                          \
   __macro(round, RoundFunctor, ZeroGradFunctor);                     \
   __macro(reciprocal, ReciprocalFunctor, ReciprocalGradFunctor);     \
   __macro(log, LogFunctor, LogGradFunctor);                          \
diff --git a/paddle/function/EigenGemm.cpp b/paddle/function/EigenGemm.cpp
index 4c81ebdd31..bac4659e62 100644
--- a/paddle/function/EigenGemm.cpp
+++ b/paddle/function/EigenGemm.cpp
@@ -63,7 +63,6 @@ struct EigenBlasGemm {
     const EigenMatrix a(const_cast<T*>(A), sizeA);
     const EigenMatrix b(const_cast<T*>(B), sizeB);
     EigenMatrix c(C, sizeC);
-    Eigen::Tensor<T, 2, Eigen::RowMajor, int> ss;
 
     typedef typename Eigen::Tensor<T, 2>::DimensionPair DimPair;
     Eigen::array<DimPair, 1> dims;
diff --git a/python/paddle/fluid/layers/ops.py b/python/paddle/fluid/layers/ops.py
index ee8de219ee..0e5987ee59 100644
--- a/python/paddle/fluid/layers/ops.py
+++ b/python/paddle/fluid/layers/ops.py
@@ -26,6 +26,7 @@ __activations__ = [
     'ceil',
     'floor',
     'cos',
+    'sin',
     'round',
     'reciprocal',
     'log',
diff --git a/python/paddle/fluid/tests/unittests/test_activation_op.py b/python/paddle/fluid/tests/unittests/test_activation_op.py
index b78fb8a319..fb162f8b73 100644
--- a/python/paddle/fluid/tests/unittests/test_activation_op.py
+++ b/python/paddle/fluid/tests/unittests/test_activation_op.py
@@ -14,7 +14,6 @@
 
 import unittest
 import numpy as np
-import math
 import paddle.fluid.core as core
 from op_test import OpTest
 from scipy.special import expit
@@ -202,7 +201,21 @@ class TestCos(OpTest):
         self.op_type = "cos"
         x = np.random.uniform(-1, 1, [4, 4]).astype("float32")
         self.inputs = {'X': x}
-        self.outputs = {'Out': math.cos(self.inputs['X'])}
+        self.outputs = {'Out': np.cos(self.inputs['X'])}
+
+    def test_check_output(self):
+        self.check_output()
+
+    def test_check_grad(self):
+        self.check_grad(['X'], 'Out', max_relative_error=0.007)
+
+
+class TestSin(OpTest):
+    def setUp(self):
+        self.op_type = "sin"
+        x = np.random.uniform(-1, 1, [4, 4]).astype("float32")
+        self.inputs = {'X': x}
+        self.outputs = {'Out': np.sin(self.inputs['X'])}
 
     def test_check_output(self):
         self.check_output()

From 450be963feb74b591bb232cd2b05aac9b01b23b4 Mon Sep 17 00:00:00 2001
From: typhoonzero <typhoonzero1986@gmail.com>
Date: Thu, 29 Mar 2018 14:34:45 +0800
Subject: [PATCH 23/27] fix sparse errors

---
 paddle/fluid/operators/detail/grpc_client.cc  |  1 -
 .../operators/detail/sendrecvop_utils.cc      |  2 +-
 .../fluid/operators/detail/sendrecvop_utils.h |  7 +++++++
 paddle/fluid/operators/detail/test_serde.cc   | 19 +++++++++++--------
 .../operators/detail/variable_response.cc     |  9 ++++++---
 paddle/fluid/operators/listen_and_serv_op.cc  |  2 ++
 paddle/fluid/operators/send_op.cc             |  4 ++--
 7 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/paddle/fluid/operators/detail/grpc_client.cc b/paddle/fluid/operators/detail/grpc_client.cc
index e73bbe7537..03b789f326 100644
--- a/paddle/fluid/operators/detail/grpc_client.cc
+++ b/paddle/fluid/operators/detail/grpc_client.cc
@@ -204,7 +204,6 @@ std::shared_ptr<grpc::Channel> RPCClient::GetChannel(const std::string& ep) {
   }
 
   grpc::ChannelArguments args;
-  args.SetInt("grpc.testing.fixed_reconnect_backoff_ms", 5000);
   args.SetCompressionAlgorithm(GRPC_COMPRESS_NONE);
   args.SetMaxSendMessageSize(std::numeric_limits<int>::max());
   args.SetMaxReceiveMessageSize(std::numeric_limits<int>::max());
diff --git a/paddle/fluid/operators/detail/sendrecvop_utils.cc b/paddle/fluid/operators/detail/sendrecvop_utils.cc
index f318f8ac28..7e3f015dab 100644
--- a/paddle/fluid/operators/detail/sendrecvop_utils.cc
+++ b/paddle/fluid/operators/detail/sendrecvop_utils.cc
@@ -155,7 +155,7 @@ void SerializeToByteBuffer(const std::string& name, framework::Variable* var,
     ProtoEncodeHelper e2((char*)buf, 128);
     // NOTE: rows is of type int64_t
     size_t rows_memory_size =
-        slr->rows().capacity() * framework::SizeOfType(typeid(int64_t));
+        slr->rows().size() * framework::SizeOfType(typeid(int64_t));
     e2.WriteVarlengthBeginning(VarMsg::kRowsFieldNumber, rows_memory_size);
     slices[2] = ::grpc::Slice(e2.size());
     memcpy(const_cast<uint8_t*>(slices[2].begin()), e2.data(), e2.size());
diff --git a/paddle/fluid/operators/detail/sendrecvop_utils.h b/paddle/fluid/operators/detail/sendrecvop_utils.h
index 3b87562703..b3b2b8469c 100644
--- a/paddle/fluid/operators/detail/sendrecvop_utils.h
+++ b/paddle/fluid/operators/detail/sendrecvop_utils.h
@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #pragma once
+#include <sys/time.h>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -35,6 +36,12 @@ namespace detail {
 #define BATCH_BARRIER_MESSAGE "BATCH_BARRIER@RECV"
 #define FETCH_BARRIER_MESSAGE "FETCH_BARRIER@RECV"
 
+static int64_t GetTimestamp() {
+  struct timeval tp;
+  gettimeofday(&tp, NULL);
+  return tp.tv_sec * 1000 + tp.tv_usec / 1000;
+}
+
 typedef void (*DestroyCallback)(void*);
 
 void SerializeToByteBuffer(const std::string& name, framework::Variable* var,
diff --git a/paddle/fluid/operators/detail/test_serde.cc b/paddle/fluid/operators/detail/test_serde.cc
index e9e2dc84ad..ea1670e56f 100644
--- a/paddle/fluid/operators/detail/test_serde.cc
+++ b/paddle/fluid/operators/detail/test_serde.cc
@@ -43,12 +43,11 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   slr->set_height(1000);
   auto* tensor = slr->mutable_value();
   auto* rows = slr->mutable_rows();
-  tensor->Resize(framework::make_ddim({2, 10}));
+  tensor->Resize(framework::make_ddim({564, 128}));
   tensor->mutable_data<float>(place);
-  int tensor_numel = 2 * 10;
+  int tensor_numel = 564 * 128;
   math::set_constant(ctx, tensor, 32.7);
-  rows->push_back(3);
-  rows->push_back(10);
+  for (int i = 0; i < 564; ++i) rows->push_back(i);
 
   ::grpc::ByteBuffer msg;
   operators::detail::SerializeToByteBuffer("myvar", &var, ctx, &msg);
@@ -65,6 +64,7 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   sendrecv::VariableMessage varmsg;
   EXPECT_TRUE(varmsg.ParseFromString(tmp));
 
+  // deserialize bytebuffer
   EXPECT_EQ(varmsg.varname(), "myvar");
   EXPECT_EQ(varmsg.type(), 1);
 
@@ -75,8 +75,10 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   for (int i = 0; i < tensor_numel; ++i) {
     EXPECT_FLOAT_EQ(tensor_data[i], 32.7);
   }
-  EXPECT_EQ(rows_data[0], 3);
-  EXPECT_EQ(rows_data[1], 10);
+  for (int i = 0; i < 564; ++i) {
+    EXPECT_EQ(rows_data[i], i);
+  }
+
   // deserialize zero-copy
   // framework::Variable var2;
   // operators::detail::DeserializeFromByteBuffer(msg, ctx, &var2);
@@ -105,8 +107,9 @@ void RunSerdeTestSelectedRows(platform::Place place) {
   for (int i = 0; i < tensor_numel; ++i) {
     EXPECT_FLOAT_EQ(tensor_data2[i], 32.7);
   }
-  EXPECT_EQ(rows_data2[0], 3);
-  EXPECT_EQ(rows_data2[1], 10);
+  for (int i = 0; i < rows2->size(); ++i) {
+    EXPECT_EQ(rows_data2[i], i);
+  }
   EXPECT_EQ(slr2->height(), 1000);
 }
 
diff --git a/paddle/fluid/operators/detail/variable_response.cc b/paddle/fluid/operators/detail/variable_response.cc
index 862fd26b54..f59c9b50bb 100644
--- a/paddle/fluid/operators/detail/variable_response.cc
+++ b/paddle/fluid/operators/detail/variable_response.cc
@@ -68,8 +68,6 @@ bool ReadRaw(::google::protobuf::io::CodedInputStream* input,
       if (total_written + size_to_write > length) {
         size_to_write = length - total_written;
       }
-      VLOG(3) << "copy raw " << size_to_write
-              << " bytes, written: " << total_written << ", length: " << length;
       memory::Copy(boost::get<platform::CUDAPlace>(place),
                    reinterpret_cast<void*>(p), cpu, data, size_to_write,
                    gpu_dev_ctx.stream());
@@ -152,6 +150,10 @@ bool VariableResponse::CopySelectRowsTensorData(
   slr->set_height(meta_.slr_height());
   auto* tensor = slr->mutable_value();
   tensor->Resize(dims);
+  PADDLE_ENFORCE_EQ(
+      tensor->numel(),
+      length / framework::SizeOfType(
+                   paddle::operators::detail::ToTypeIndex(meta_.data_type())));
   void* tensor_data = tensor->mutable_data(
       ctx.GetPlace(),
       paddle::operators::detail::ToTypeIndex(meta_.data_type()));
@@ -168,7 +170,8 @@ bool VariableResponse::CopySelectRowsData(
     const platform::DeviceContext& ctx, int length) {
   auto var = scope_->FindVar(meta_.varname());
   auto* slr = var->GetMutable<framework::SelectedRows>();
-  slr->mutable_rows()->resize(length / 8);  // int64
+  slr->mutable_rows()->resize(length /
+                              framework::SizeOfType(typeid(int64_t)));  // int64
   int64_t* rows_data = slr->mutable_rows()->data();
 
   // copy rows CPU data, GPU data will be copied lazily.
diff --git a/paddle/fluid/operators/listen_and_serv_op.cc b/paddle/fluid/operators/listen_and_serv_op.cc
index 08b83375dd..9796fabdb6 100644
--- a/paddle/fluid/operators/listen_and_serv_op.cc
+++ b/paddle/fluid/operators/listen_and_serv_op.cc
@@ -141,6 +141,7 @@ class ListenAndServOp : public framework::OperatorBase {
       // and this will still work.
 
       std::vector<std::future<void>> fs;
+      double ts = detail::GetTimestamp();
       // block0 contains only listen_and_serv op, start run from block1.
       for (int blkid = 1; blkid < num_blocks - 1; ++blkid) {
         fs.push_back(
@@ -162,6 +163,7 @@ class ListenAndServOp : public framework::OperatorBase {
           LOG(ERROR) << "run sub program error " << e.what();
         }
       }
+      VLOG(2) << "run all blocks spent (ms) " << detail::GetTimestamp() - ts;
 
       // Reset the received sparse variables, the sum operator would not
       // sum the input sparse variables which rows is empty at the next
diff --git a/paddle/fluid/operators/send_op.cc b/paddle/fluid/operators/send_op.cc
index fdf3c06ef0..0752bd1bbd 100644
--- a/paddle/fluid/operators/send_op.cc
+++ b/paddle/fluid/operators/send_op.cc
@@ -72,7 +72,7 @@ class SendOp : public framework::OperatorBase {
 
     for (size_t i = 0; i < ins.size(); i++) {
       if (NeedSend(scope, ins[i])) {
-        VLOG(2) << "sending " << ins[i] << " to " << epmap[i];
+        VLOG(3) << "sending " << ins[i] << " to " << epmap[i];
         rpc_client->AsyncSendVariable(epmap[i], ctx, scope, ins[i]);
       } else {
         VLOG(3) << "don't send no-initialied variable: " << ins[i];
@@ -81,7 +81,7 @@ class SendOp : public framework::OperatorBase {
     PADDLE_ENFORCE(rpc_client->Wait());
 
     for (auto& ep : endpoints) {
-      VLOG(2) << "batch barrier, ep: " << ep;
+      VLOG(3) << "batch barrier, ep: " << ep;
       rpc_client->AsyncSendBatchBarrier(ep);
     }
     PADDLE_ENFORCE(rpc_client->Wait());

From f5da16e51b05ac88a9402f256cee0a101c58116d Mon Sep 17 00:00:00 2001
From: Abhinav Arora <abhinavarora28@gmail.com>
Date: Wed, 28 Mar 2018 23:57:17 -0700
Subject: [PATCH 24/27] Disabling channel test to debug issue (#9491)

---
 paddle/fluid/framework/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/fluid/framework/CMakeLists.txt b/paddle/fluid/framework/CMakeLists.txt
index a4ea74a6d2..8c8def6bf4 100644
--- a/paddle/fluid/framework/CMakeLists.txt
+++ b/paddle/fluid/framework/CMakeLists.txt
@@ -100,7 +100,7 @@ cc_test(init_test SRCS init_test.cc DEPS init)
 cc_test(op_kernel_type_test SRCS op_kernel_type_test.cc DEPS place device_context framework_proto)
 cc_test(cow_ptr_tests SRCS details/cow_ptr_test.cc)
       
-cc_test(channel_test SRCS channel_test.cc)
+# cc_test(channel_test SRCS channel_test.cc)
 cc_test(tuple_test SRCS tuple_test.cc )
 cc_test(concurrency_test SRCS concurrency_test.cc DEPS go_op channel_close_op channel_create_op
         channel_send_op channel_recv_op sum_op select_op elementwise_add_op compare_op

From 241f3c988f87978d05a8b2f516509490b01b5ef5 Mon Sep 17 00:00:00 2001
From: Thuan Nguyen <cs2be@yahoo.com>
Date: Thu, 29 Mar 2018 00:04:10 -0700
Subject: [PATCH 25/27] Add channel design document (#9463)

* Add channel design document

* Update channel send/recv state diagram
---
 doc/fluid/design/concurrent/channel.md        | 139 ++++++++++++++++++
 .../design/concurrent/images/channel_recv.png | Bin 0 -> 136646 bytes
 .../design/concurrent/images/channel_send.png | Bin 0 -> 85643 bytes
 3 files changed, 139 insertions(+)
 create mode 100644 doc/fluid/design/concurrent/channel.md
 create mode 100644 doc/fluid/design/concurrent/images/channel_recv.png
 create mode 100644 doc/fluid/design/concurrent/images/channel_send.png

diff --git a/doc/fluid/design/concurrent/channel.md b/doc/fluid/design/concurrent/channel.md
new file mode 100644
index 0000000000..a00a3325e7
--- /dev/null
+++ b/doc/fluid/design/concurrent/channel.md
@@ -0,0 +1,139 @@
+# Channel Design
+
+## Introduction
+
+A Channel is a data structure that allows for synchronous interprocess 
+communication via message passing.  It is a fundemental component of CSP
+(communicating sequential processes), and allows for users to pass data
+between threads without having to worry about synchronization.
+
+## How to use it
+
+Paddle offers python APIs to open and close channels, along with sending
+and receiving data to/from a channel.
+
+### Create a channel
+
+Creates a new channel that takes in variables of a specific dtype.
+
+- **fluid.make_channel(dtype, capacity=0)**
+  - **dtype**: The data type of variables being sent/received through channel
+  - **capacity**: The capacity of the channel.  A capacity of 0 represents 
+    an unbuffered channel.  Capacity > 0 represents a buffered channel
+
+```
+ch = fluid.make_channel(dtype=core.VarDesc.VarType.LOD_TENSOR, 10)
+```
+
+### Close a channel
+
+Closes a channel.  Any pending senders and receivers will be awoken during
+this time.  Receivers can still receive from a closed channel, but senders
+are not allowed to send any additional data to the channel (Paddle will
+raise an exception if users try to send to a closed channel.)
+
+- **fluid.channel_close(channel)**
+
+```
+fluid.channel_close(ch)
+```
+
+### Send data to a channel
+
+Sends a variable to a channel.  Currently, variables of dtype `LoDTensor`, 
+`LoDRankTable`, `LoDTensorArray`, `SelectedRows`, `ReaderHolder`, and 
+`ChannelHolder` are supported.
+
+By default, the data of the Variable is moved from the sender to the receiver,
+however the user can optionally copy the data before performing the send.
+
+- **channel_send(channel, variable, is_copy=False)**
+  - **channel**: The channel to send the variable to
+  - **variable**: The variable to send to the channel
+  - **is_copy**: If set to True, channel_send will perform a variable assign
+  to copy the source variable to a new variable to be sent.
+  
+```
+ch = fluid.make_channel(dtype=core.VarDesc.VarType.LOD_TENSOR)
+var = fill_constant(shape=[1],dtype=core.VarDesc.VarType.INT32, value=100)
+fluid.channel_send(ch, var, True)
+```
+
+### Receive data from a channel
+
+Receives a variable from a channel.  The data of the variable is moved to the
+receiving variable.
+
+- **channel_recv(channel, return_variable)**
+  - **channel**: The channel to receive the variable from
+  - **return_variable**: The destination variable used to store the data of the
+  variable received from the channel
+  
+```
+ch = fluid.make_channel(dtype=core.VarDesc.VarType.LOD_TENSOR)
+var = fill_constant(shape=[1],dtype=core.VarDesc.VarType.INT32, value=-1)
+fluid.channel_recv(ch, var)
+```
+
+## How it Works
+
+Channels provides a simple interface for different threads to share data.
+To support the synchronization requirements, channels utilizes a series of
+internal queues, locks, and conditional variables.
+
+### QueueMessage
+
+QueueMessage encapsulates the state of the channel send/receive operation to be
+put in the **sendq/recvq**.  It contains a condition variable used to lock the 
+thread (when there are no available sends/receives).  In addition, it contains
+a callback function to notify a thread when the QueueMessage is being 
+processed by the channel.
+
+### Queues
+
+- **buff_**: This queue holds the data buffer in a buffered channel.  The
+capacity is set to the capacity of the channel.  This data buffer is not
+used in an unbuffered channel.
+
+- **sendq**: This queue holds the QueueMessage of any pending senders of a
+channel.  When a thread performs a channel_send operation on the channel, the
+channel_send operation will put a new QueueMessage on the sendq and block the
+current thread under two conditions:
+  1. The channel is buffered and is full
+  2. The channel is unbuffered and does not have a receiver
+
+- **recvq**:  This queue holds the QueueMessage of any pending receivers of a
+channel.  When a thread performs a channel_recv operation on the channel, the
+channel_recv operation will put a new QueueMessage on the recvq and block the
+current thread under two conditions:
+  1. The channel is buffered and there is no data on the buff_
+  2. The channel is unbuffered and does not have a sender
+  
+### State diagram
+
+#### Channel Send
+
+<p align="center">
+<img src="./images/channel_send.png"/><br/>
+</p>
+  
+#### Channel Receive
+
+<p align="center">
+<img src="./images/channel_recv.png"/><br/>
+</p>
+  
+## Limitations and Considerations
+
+### Variable Copy
+
+In golang, variables in channels are copied from the sender to the receiver.
+In Paddle, the data from our variables are **moved** from sender to receiver.
+As a result, these variables should not be used after they are sent.  We
+provide a flag in channel_send method to allow users to copy the variable to
+be sent before it is sent.  
+
+Please note that this is acheived by adding an **assign** operator and creating
+a temporary variable that is sent in place of the original variable.  Please
+note that **assign** operator has limited support for only certain variables 
+datatypes.
diff --git a/doc/fluid/design/concurrent/images/channel_recv.png b/doc/fluid/design/concurrent/images/channel_recv.png
new file mode 100644
index 0000000000000000000000000000000000000000..c06cd15ae7b8a8c94d5742f6675e389081fcf789
GIT binary patch
literal 136646
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
Ms>+m0z5V+C0GBe^(EtDd

literal 0
HcmV?d00001

diff --git a/doc/fluid/design/concurrent/images/channel_send.png b/doc/fluid/design/concurrent/images/channel_send.png
new file mode 100644
index 0000000000000000000000000000000000000000..006ebb4a5a4bcd32c97847e9fb7729a740255f7c
GIT binary patch
literal 85643
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%0A1yekB{qizn<~L
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
WWK+fYxv;^2kGQamQ2AHAfd2#1QGn(E

literal 0
HcmV?d00001


From c4886584047122b5b358021a6c21977c259142d0 Mon Sep 17 00:00:00 2001
From: fengjiayi <fengjiayi@baidu.com>
Date: Thu, 29 Mar 2018 15:34:36 +0800
Subject: [PATCH 26/27] follow comments

---
 doc/fluid/design/concepts/cpp_data_feeding.md | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/doc/fluid/design/concepts/cpp_data_feeding.md b/doc/fluid/design/concepts/cpp_data_feeding.md
index 9c44dec4b9..aabc1ba75a 100644
--- a/doc/fluid/design/concepts/cpp_data_feeding.md
+++ b/doc/fluid/design/concepts/cpp_data_feeding.md
@@ -113,7 +113,7 @@ To solve this problem, we introduce `ReaderHolder` as a wrapper. It acts as an e
 
 To create and invoke readers, some new ops are introduced:
 
-### Operators That Creates Readers
+### Operators That Create Readers
 
 Each reader has its creation op. File readers' creation ops have no input and yield the created file reader as its output. Decorated readers' creation ops take the underlying readers as inputs and then yield new decorated readers.
 
@@ -168,17 +168,19 @@ while_op(not_completed) {
 }
 ```
 
-Two important considerations for these programs are as follows:
+A few important considerations for these programs are as follows:
 
-1. The multiple\_reader is the batch\_reader's underlying reader, and the batch\_reader is the double\_buffer\_reader's underlying reader. `read_op`, `has_next_op` and other reader related ops will only invoke the top-most reader. In this case, it's the double\_buffer\_reader.
+1. `not_completed`, `pass_count` and other variables shown above are all Fluid Variables.
 
-2. All readers exist in both `startup_program` and `main_program`. And they are persistable.
+2. The multiple\_reader is the batch\_reader's underlying reader, and the batch\_reader is the double\_buffer\_reader's underlying reader. `read_op`, `has_next_op` and other reader related ops will only invoke the top-most reader. In this case, it's the double\_buffer\_reader.
+
+3. All readers exist in both `startup_program` and `main_program`. And they are persistable.
 
 ### Simplify Configuration by MultiPassReader
 
-The  Program configuration mentioned above is somehow complicated. Users need to be very similar to concepts of Program and Block to prevent making mistakes in their code. To make the usage of C++ readers more friendly to beginning users, we introduce `MultiPassReader`.
+The Program configuration mentioned above is complicated. Users need to be very familiar to concepts of Program and Block to prevent making mistakes in their code. To make the usage of C++ readers more friendly to new users, we introduce `MultiPassReader`.
 
-`MultiPassReader` is a decorated reader. A multi-pass reader is used to continuously yield data for several pass training. It takes the number of passes to run as one of its attributes('pass_num') and maintains a counter to record how many passes it has completed. Each time its underlying reader reaches the EOF, the multi-pass reader checks whether it has completed the training of given number of pass. If not, the underlying reader will be re-initialized and starts a new pass automatically. Before completing the whole training, the return of MultiPassReader's `HasNext()` will always be `true`.
+`MultiPassReader` is a decorated reader. A multi-pass reader is used to continuously yield data for several training passes. It takes the number of passes to run as one of its attributes('pass_num') and maintains a counter to record how many passes it has completed. Each time its underlying reader reaches the EOF, the multi-pass reader checks whether it has completed the training of given number of pass. If not, the underlying reader will be re-initialized and starts a new pass automatically. Before completing the whole training, the return of MultiPassReader's `HasNext()` will always be `true`.
 
 With `MultiPassReader`, the startup program would be like this:
 

From 8425c2c859b22f263e213d4fed454890b598948c Mon Sep 17 00:00:00 2001
From: dzhwinter <dongzhihong01@baidu.com>
Date: Thu, 29 Mar 2018 16:34:33 +0800
Subject: [PATCH 27/27] Speed/sequence op1 (#9217)

* "add functors"

* "remove old code"

* "fix"

* "fix ci"

* "add details"

* "fix ci"

* "fix ci"

* "fix ci"

* "fix ci"

* "remove unused code"
---
 .../fluid/operators/math/sequence_pooling.cc  | 112 ++++-
 .../fluid/operators/math/sequence_pooling.cu  | 381 ++++++++++++++----
 .../fluid/operators/math/sequence_pooling.h   |  20 +-
 paddle/fluid/operators/sequence_pool_op.h     | 102 +----
 .../fluid/tests/unittests/test_seq_pool.py    | 110 ++---
 5 files changed, 484 insertions(+), 241 deletions(-)

diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc
index f7a6f2bdf4..5ae42ab973 100644
--- a/paddle/fluid/operators/math/sequence_pooling.cc
+++ b/paddle/fluid/operators/math/sequence_pooling.cc
@@ -19,8 +19,17 @@ namespace paddle {
 namespace operators {
 namespace math {
 
+using Tensor = framework::Tensor;
+using LoDTensor = framework::LoDTensor;
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+using EigenVector = framework::EigenVector<T, MajorType, IndexType>;
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+using EigenMatrix = framework::EigenMatrix<T, MajorType, IndexType>;
+
 template <typename T>
-class MaxSeqPoolFunctor<platform::CPUDeviceContext, T> {
+class MaxSeqPoolFunctor {
  public:
   void operator()(const platform::CPUDeviceContext& context,
                   const framework::LoDTensor& input, framework::Tensor* output,
@@ -60,7 +69,7 @@ class MaxSeqPoolFunctor<platform::CPUDeviceContext, T> {
 };
 
 template <typename T>
-class MaxSeqPoolGradFunctor<platform::CPUDeviceContext, T> {
+class MaxSeqPoolGradFunctor {
  public:
   void operator()(const platform::CPUDeviceContext& context,
                   const framework::Tensor& out_grad,
@@ -93,10 +102,101 @@ class MaxSeqPoolGradFunctor<platform::CPUDeviceContext, T> {
   }
 };
 
-template class MaxSeqPoolFunctor<platform::CPUDeviceContext, float>;
-template class MaxSeqPoolFunctor<platform::CPUDeviceContext, double>;
-template class MaxSeqPoolGradFunctor<platform::CPUDeviceContext, float>;
-template class MaxSeqPoolGradFunctor<platform::CPUDeviceContext, double>;
+template <typename T>
+class SequencePoolFunctor<platform::CPUDeviceContext, T> {
+ public:
+  /* max pool has index output */
+  void operator()(const platform::CPUDeviceContext& context,
+                  const std::string pooltype, const framework::LoDTensor& input,
+                  framework::Tensor* output,
+                  framework::Tensor* index = nullptr) {
+    if (pooltype == "MAX") {
+      math::MaxSeqPoolFunctor<T> max_pool;
+      max_pool(context, input, output, index);
+      return;
+    }
+    auto lod = input.lod()[0];
+    auto& place = *context.eigen_device();
+    for (int i = 0; i < static_cast<int>(lod.size()) - 1; ++i) {
+      Tensor in_t =
+          input.Slice(static_cast<int>(lod[i]), static_cast<int>(lod[i + 1]));
+      Tensor out_t = output->Slice(i, i + 1);
+      int64_t h = static_cast<int64_t>(lod[i + 1] - lod[i]);
+      int64_t w = input.numel() / input.dims()[0];
+      auto in_e = EigenMatrix<T>::From(in_t, framework::make_ddim({h, w}));
+      auto out_e = EigenVector<T>::Flatten(out_t);
+      if (pooltype == "AVERAGE") {
+        out_e.device(place) = in_e.mean(Eigen::array<int, 1>({{0}}));
+      } else if (pooltype == "SUM") {
+        out_e.device(place) = in_e.sum(Eigen::array<int, 1>({{0}}));
+      } else if (pooltype == "SQRT") {
+        out_e.device(place) = in_e.sum(Eigen::array<int, 1>({{0}})) /
+                              std::sqrt(static_cast<T>(h));
+      } else if (pooltype == "LAST") {
+        out_e.device(place) = in_e.chip(h - 1, 0);
+      } else if (pooltype == "FIRST") {
+        out_e.device(place) = in_e.chip(0, 0);
+      } else {
+        PADDLE_THROW("unsupported pooling pooltype");
+      }
+    }
+  }
+};
+
+template <typename T>
+class SequencePoolGradFunctor<platform::CPUDeviceContext, T> {
+ public:
+  void operator()(const platform::CPUDeviceContext& context,
+                  const std::string pooltype, const framework::Tensor& out_grad,
+                  framework::LoDTensor* in_grad,
+                  /* max pool has index */
+                  const framework::Tensor* index = nullptr) {
+    if (pooltype == "MAX") {
+      math::MaxSeqPoolGradFunctor<T> max_pool_grad;
+      max_pool_grad(context, out_grad, *index, in_grad);
+      return;
+    }
+
+    if (pooltype == "LAST" || pooltype == "FIRST") {
+      // set X@Grad be zero at first when pooltype is LAST/FIRST
+      math::SetConstant<platform::CPUDeviceContext, T> functor;
+      functor(context, in_grad, 0);
+    }
+    auto lod = in_grad->lod()[0];
+    auto& place = *context.eigen_device();
+    for (int i = 0; i < static_cast<int>(lod.size()) - 1; ++i) {
+      auto in_g_t = in_grad->Slice(static_cast<int>(lod[i]),
+                                   static_cast<int>(lod[i + 1]));
+      auto out_g_t = out_grad.Slice(i, i + 1);
+      int64_t h = static_cast<int64_t>(lod[i + 1] - lod[i]);
+      int64_t w = in_grad->numel() / in_grad->dims()[0];
+      auto in_g_e = EigenMatrix<T>::From(in_g_t, {h, w});
+      auto out_g_e = EigenMatrix<T>::From(out_g_t, {1, w});
+      auto out_g_e_v = EigenVector<T>::Flatten(out_g_t);
+      Eigen::DSizes<int, 2> bcast(h, 1);
+
+      if (pooltype == "AVERAGE") {
+        in_g_e.device(place) = (out_g_e / static_cast<T>(h)).broadcast(bcast);
+      } else if (pooltype == "SUM") {
+        in_g_e.device(place) = (out_g_e).broadcast(bcast);
+      } else if (pooltype == "SQRT") {
+        in_g_e.device(place) =
+            (out_g_e / std::sqrt(static_cast<T>(h))).broadcast(bcast);
+      } else if (pooltype == "LAST") {
+        in_g_e.chip(h - 1, 0).device(place) = out_g_e_v;
+      } else if (pooltype == "FIRST") {
+        in_g_e.chip(0, 0).device(place) = out_g_e_v;
+      } else {
+        PADDLE_THROW("unsupported pooling pooltype");
+      }
+    }
+  }
+};
+
+template class SequencePoolFunctor<platform::CPUDeviceContext, float>;
+template class SequencePoolFunctor<platform::CPUDeviceContext, double>;
+template class SequencePoolGradFunctor<platform::CPUDeviceContext, float>;
+template class SequencePoolGradFunctor<platform::CPUDeviceContext, double>;
 
 }  // namespace math
 }  // namespace operators
diff --git a/paddle/fluid/operators/math/sequence_pooling.cu b/paddle/fluid/operators/math/sequence_pooling.cu
index d61407c020..1935364da3 100644
--- a/paddle/fluid/operators/math/sequence_pooling.cu
+++ b/paddle/fluid/operators/math/sequence_pooling.cu
@@ -14,6 +14,7 @@ limitations under the License. */
 
 #include "paddle/fluid/operators/math/math_function.h"
 #include "paddle/fluid/operators/math/sequence_pooling.h"
+#include "paddle/fluid/platform/cuda_helper.h"
 
 namespace paddle {
 namespace operators {
@@ -22,113 +23,331 @@ namespace math {
 #define FLT_MAX __FLT_MAX__
 
 template <typename T>
-__global__ void KeMaxSequencePool(const T* input, const size_t* starts,
-                                  T* output, int* index, int64_t num_seq,
-                                  int64_t dim) {
-  int dim_idx = threadIdx.x;
-  int seq_id = blockIdx.x;
-  if (seq_id >= num_seq) return;
-  size_t start = starts[seq_id];
-  size_t end = starts[seq_id + 1];
-
-  for (int64_t i = dim_idx; i < dim; i += blockDim.x) {
-    T max_val = static_cast<T>(-FLT_MAX);
-    int max_id = -1;
-    for (size_t step_id = start; step_id < end; step_id++) {
-      if (max_val < input[step_id * dim + i]) {
-        max_val = input[step_id * dim + i];
-        max_id = step_id;
+struct MaxPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      T max_val = static_cast<T>(-FLT_MAX);
+      int max_index = -1;
+      for (int i = start; i < end; ++i) {
+        if (max_val < input[item_dim * i + tid]) {
+          max_val = input[item_dim * i + tid];
+          max_index = i;
+        }
       }
+      output[tid] = max_val;
+      index[tid] = max_index;
     }
-    output[seq_id * dim + i] = max_val;
-    index[seq_id * dim + i] = max_id;
   }
-}
+};
 
 template <typename T>
-class MaxSeqPoolFunctor<platform::CUDADeviceContext, T> {
- public:
-  void operator()(const platform::CUDADeviceContext& context,
-                  const framework::LoDTensor& input, framework::Tensor* output,
-                  framework::Tensor* index) {
-    auto in_dims = input.dims();
-    auto out_dims = output->dims();
-    auto idx_dims = index->dims();
-    PADDLE_ENFORCE_GT(in_dims.size(), static_cast<int64_t>(1));
-    PADDLE_ENFORCE_GT(out_dims.size(), 1);
-    for (int64_t i = 1; i < in_dims.size(); ++i) {
-      PADDLE_ENFORCE_EQ(in_dims[i], out_dims[i]);
+struct AvgPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      T val = static_cast<T>(0);
+      for (int i = start; i < end; ++i) {
+        val += input[item_dim * i + tid];
+      }
+      // end, start is lod, so end - start != 0
+      output[tid] = val / static_cast<T>(end - start);
     }
-    PADDLE_ENFORCE_EQ(idx_dims, out_dims);
+  }
+};
 
-    auto starts = input.lod()[0];
-    const T* in_data = input.data<T>();
-    T* out_data = output->data<T>();
-    int* max_index = index->data<int>();
+template <typename T>
+struct SumPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      T val = static_cast<T>(0);
+      for (int i = start; i < end; ++i) {
+        val += input[item_dim * i + tid];
+      }
+      output[tid] = val;
+    }
+  }
+};
 
-    int64_t num_seq = out_dims[0];
-    int64_t dim = output->numel() / num_seq;
+template <typename T>
+struct SqrtPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      T val = static_cast<T>(0);
+      for (int i = start; i < end; ++i) {
+        val += input[item_dim * i + tid];
+      }
+      // end, start is lod, so end - start != 0
+      output[tid] = val / sqrt(end - start);
+    }
+  }
+};
 
-    dim3 threads(256, 1);
-    dim3 grid(num_seq, 1);
-    auto stream = context.stream();
-    KeMaxSequencePool<T><<<grid, threads, 0, stream>>>(
-        in_data, starts.CUDAData(context.GetPlace()), out_data, max_index,
-        num_seq, dim);
+template <typename T>
+struct LastPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      output[tid] = input[item_dim * (end - 1) + tid];
+    }
   }
 };
 
 template <typename T>
-__global__ void KeMaxSequencePoolGrad(const T* out_grad, const int* max_index,
-                                      T* in_grad, int64_t num_seq,
-                                      int64_t dim) {
-  int idx = threadIdx.x + blockIdx.x * blockDim.x;
-  int col_idx = idx % dim;
-  if (idx < num_seq * dim) {
-    int step_id = max_index[idx];
-    in_grad[step_id * dim + col_idx] = out_grad[idx];
+struct FirstPoolFunctor {
+  HOSTDEVICE void operator()(const T* input, const size_t start,
+                             const size_t end, const size_t item_dim, T* output,
+                             int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      output[tid] = input[item_dim * start + tid];
+    }
   }
+};
+
+template <typename T, typename Range_OP>
+__global__ void sequence_pool_kernel(Range_OP op, const T* input,
+                                     const size_t* lod, const size_t lod_size,
+                                     const size_t item_dim, T* output,
+                                     int* index) {
+  int bid = blockIdx.x;
+  if (bid >= lod_size - 1) return;
+  size_t start = lod[bid];
+  size_t end = lod[bid + 1];
+  int* index_offset = nullptr;
+  if (index != nullptr) {
+    index_offset = &index[bid * item_dim];
+  }
+  op(input, start, end, item_dim, &output[bid * item_dim], index_offset);
 }
 
 template <typename T>
-class MaxSeqPoolGradFunctor<platform::CUDADeviceContext, T> {
+class SequencePoolFunctor<platform::CUDADeviceContext, T> {
  public:
   void operator()(const platform::CUDADeviceContext& context,
-                  const framework::Tensor& out_grad,
-                  const framework::Tensor& index,
-                  framework::LoDTensor* in_grad) {
-    auto og_dims = out_grad.dims();
-    auto idx_dims = index.dims();
-    auto ig_dims = in_grad->dims();
-    PADDLE_ENFORCE_GT(og_dims.size(), static_cast<int64_t>(1));
-    PADDLE_ENFORCE_GT(ig_dims.size(), static_cast<int64_t>(1));
-    for (int64_t i = 1; i < og_dims.size(); ++i) {
-      PADDLE_ENFORCE_EQ(og_dims[i], ig_dims[i]);
+                  const std::string pooltype, const framework::LoDTensor& input,
+                  framework::Tensor* output,
+                  framework::Tensor* index = nullptr) {
+    auto lod = input.lod()[0];
+    const size_t item_dim = output->numel() / output->dims()[0];
+    dim3 threads(1024, 1);
+    dim3 grid(lod.size(), 1);
+    if (pooltype == "MAX") {
+      sequence_pool_kernel<
+          T, MaxPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          MaxPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), index->data<int>());
+    } else if (pooltype == "AVERAGE") {
+      sequence_pool_kernel<
+          T, AvgPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          AvgPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "SUM") {
+      sequence_pool_kernel<
+          T, SumPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          SumPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "SQRT") {
+      sequence_pool_kernel<
+          T, SqrtPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          SqrtPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "LAST") {
+      sequence_pool_kernel<
+          T, LastPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          LastPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "FIRST") {
+      sequence_pool_kernel<
+          T, FirstPoolFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          FirstPoolFunctor<T>(), input.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          output->mutable_data<T>(context.GetPlace()), nullptr);
+    } else {
+      PADDLE_THROW("unsupported pooling pooltype");
     }
-    PADDLE_ENFORCE_EQ(idx_dims, og_dims);
+  }
+};
 
-    const T* og_data = out_grad.data<T>();
-    const int* max_index = index.data<int>();
-    T* ig_data = in_grad->data<T>();
+template <typename T>
+struct MaxPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        if (i == index[tid]) {
+          in_grad[item_dim * i + tid] = out_grad[tid];
+        } else {
+          in_grad[item_dim * i + tid] = static_cast<T>(0);
+        }
+      }
+    }
+  }
+};
 
-    SetConstant<platform::CUDADeviceContext, T> set_zero;
-    set_zero(context, in_grad, static_cast<T>(0.0));
-    int64_t num_seq = og_dims[0];
-    int64_t dim = out_grad.numel() / num_seq;
+template <typename T>
+struct AvgPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        in_grad[item_dim * i + tid] = out_grad[tid] / (end - start);
+      }
+    }
+  }
+};
 
-    unsigned int blocks = (num_seq * dim + 128 - 1) / 128;
-    dim3 threads(128, 1);
-    dim3 grid(blocks, 1);
-    auto stream = context.stream();
-    KeMaxSequencePoolGrad<T><<<grid, threads, 0, stream>>>(
-        og_data, max_index, ig_data, num_seq, dim);
+template <typename T>
+struct SumPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        in_grad[item_dim * i + tid] = out_grad[tid];
+      }
+    }
+  }
+};
+
+template <typename T>
+struct SqrtPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        in_grad[item_dim * i + tid] =
+            out_grad[tid] / (sqrt(static_cast<T>(end - start)));
+      }
+    }
+  }
+};
+
+template <typename T>
+struct LastPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        if (i == end - 1) {
+          in_grad[item_dim * i + tid] = out_grad[tid];
+        } else {
+          in_grad[item_dim * i + tid] = static_cast<T>(0);
+        }
+      }
+    }
+  }
+};
+
+template <typename T>
+struct FirstPoolGradFunctor {
+  HOSTDEVICE void operator()(const T* out_grad, const size_t start,
+                             const size_t end, const size_t item_dim,
+                             T* in_grad, const int* index) {
+    for (int tid = threadIdx.x; tid < item_dim; tid += blockDim.x) {
+      for (int i = start; i < end; ++i) {
+        if (i == start) {
+          in_grad[item_dim * i + tid] = out_grad[tid];
+        } else {
+          in_grad[item_dim * i + tid] = static_cast<T>(0);
+        }
+      }
+    }
+  }
+};
+
+template <typename T, typename Range_OP>
+__global__ void sequence_pool_grad_kernel(Range_OP op, const T* out_grad,
+                                          const size_t* lod,
+                                          const size_t lod_size,
+                                          const size_t item_dim, T* in_grad,
+                                          const int* index) {
+  int bid = blockIdx.x;
+  if (bid >= lod_size - 1) return;
+  size_t start = lod[bid];
+  size_t end = lod[bid + 1];
+  const int* index_offset = nullptr;
+  if (index != nullptr) {
+    index_offset = &index[bid * item_dim];
+  }
+  op(&out_grad[bid * item_dim], start, end, item_dim, in_grad, index_offset);
+}
+
+template <typename T>
+class SequencePoolGradFunctor<platform::CUDADeviceContext, T> {
+ public:
+  void operator()(const platform::CUDADeviceContext& context,
+                  const std::string pooltype, const framework::Tensor& out_grad,
+                  framework::LoDTensor* in_grad,
+                  /* max pool has index */
+                  const framework::Tensor* index = nullptr) {
+    auto lod = in_grad->lod()[0];
+    const size_t item_dim = in_grad->numel() / in_grad->dims()[0];
+    dim3 threads(1024, 1);
+    dim3 grid(lod.size(), 1);
+    if (pooltype == "MAX") {
+      sequence_pool_grad_kernel<
+          T, MaxPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          MaxPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), index->data<int>());
+    } else if (pooltype == "AVERAGE") {
+      sequence_pool_grad_kernel<
+          T, AvgPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          AvgPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "SUM") {
+      sequence_pool_grad_kernel<
+          T, SumPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          SumPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "SQRT") {
+      sequence_pool_grad_kernel<
+          T, SqrtPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          SqrtPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "LAST") {
+      sequence_pool_grad_kernel<
+          T, LastPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          LastPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), nullptr);
+    } else if (pooltype == "FIRST") {
+      sequence_pool_grad_kernel<
+          T, FirstPoolGradFunctor<T>><<<grid, threads, 0, context.stream()>>>(
+          FirstPoolGradFunctor<T>(), out_grad.data<T>(),
+          lod.CUDAData(context.GetPlace()), lod.size(), item_dim,
+          in_grad->mutable_data<T>(context.GetPlace()), nullptr);
+
+    } else {
+      PADDLE_THROW("unsupported pooling pooltype");
+    }
   }
 };
 
-template class MaxSeqPoolFunctor<platform::CUDADeviceContext, float>;
-template class MaxSeqPoolFunctor<platform::CUDADeviceContext, double>;
-template class MaxSeqPoolGradFunctor<platform::CUDADeviceContext, float>;
-template class MaxSeqPoolGradFunctor<platform::CUDADeviceContext, double>;
+// sequence pooling
+template class SequencePoolFunctor<platform::CUDADeviceContext, float>;
+template class SequencePoolFunctor<platform::CUDADeviceContext, double>;
+template class SequencePoolGradFunctor<platform::CUDADeviceContext, float>;
+template class SequencePoolGradFunctor<platform::CUDADeviceContext, double>;
 
 }  // namespace math
 }  // namespace operators
diff --git a/paddle/fluid/operators/math/sequence_pooling.h b/paddle/fluid/operators/math/sequence_pooling.h
index ecb76884f6..38e7802229 100644
--- a/paddle/fluid/operators/math/sequence_pooling.h
+++ b/paddle/fluid/operators/math/sequence_pooling.h
@@ -21,23 +21,23 @@ namespace paddle {
 namespace operators {
 namespace math {
 
-#define FLT_MAX __FLT_MAX__
-
 template <typename DeviceContext, typename T>
-class MaxSeqPoolFunctor {
+class SequencePoolFunctor {
  public:
-  void operator()(const DeviceContext& context,
+  /* max pool has index output */
+  void operator()(const DeviceContext& context, const std::string pooltype,
                   const framework::LoDTensor& input, framework::Tensor* output,
-                  framework::Tensor* index);
+                  framework::Tensor* index = nullptr);
 };
 
-template <typename DeviceContext, class T>
-class MaxSeqPoolGradFunctor {
+template <typename DeviceContext, typename T>
+class SequencePoolGradFunctor {
  public:
-  void operator()(const DeviceContext& context,
+  void operator()(const DeviceContext& context, const std::string pooltype,
                   const framework::Tensor& out_grad,
-                  const framework::Tensor& index,
-                  framework::LoDTensor* in_grad);
+                  framework::LoDTensor* in_grad,
+                  /* max pool has index */
+                  const framework::Tensor* index = nullptr);
 };
 
 }  // namespace math
diff --git a/paddle/fluid/operators/sequence_pool_op.h b/paddle/fluid/operators/sequence_pool_op.h
index 8706ff14aa..c58d677c92 100644
--- a/paddle/fluid/operators/sequence_pool_op.h
+++ b/paddle/fluid/operators/sequence_pool_op.h
@@ -23,12 +23,6 @@ namespace operators {
 
 using Tensor = framework::Tensor;
 using LoDTensor = framework::LoDTensor;
-template <typename T, int MajorType = Eigen::RowMajor,
-          typename IndexType = Eigen::DenseIndex>
-using EigenVector = framework::EigenVector<T, MajorType, IndexType>;
-template <typename T, int MajorType = Eigen::RowMajor,
-          typename IndexType = Eigen::DenseIndex>
-using EigenMatrix = framework::EigenMatrix<T, MajorType, IndexType>;
 
 template <typename DeviceContext, typename T>
 class SequencePoolKernel : public framework::OpKernel<T> {
@@ -37,11 +31,13 @@ class SequencePoolKernel : public framework::OpKernel<T> {
     auto* in = context.Input<LoDTensor>("X");
     auto* out = context.Output<Tensor>("Out");
     std::string pooltype = context.Attr<std::string>("pooltype");
+    Tensor* index = nullptr;
+    if (pooltype == "MAX") {
+      index = context.Output<Tensor>("MaxIndex");
+    }
 
     auto dims = in->dims();
     auto lod = in->lod();
-    int64_t w = in->numel() / dims[0];
-
     // InferShape by lod
     PADDLE_ENFORCE_EQ(lod.size(), 1UL, "Only support one level sequence now.");
     PADDLE_ENFORCE_GE(
@@ -50,45 +46,14 @@ class SequencePoolKernel : public framework::OpKernel<T> {
         "The first dimension of Input(X) must be large than batch size.");
     dims[0] = lod[0].size() - 1;
     out->Resize({dims});
-
-    auto lod_level_0 = lod[0];
-
     out->mutable_data<T>(context.GetPlace());
-    auto& dev_ctx = context.template device_context<DeviceContext>();
     if (pooltype == "MAX") {
-      math::MaxSeqPoolFunctor<DeviceContext, T> max_pool;
-      auto* index = context.Output<Tensor>("MaxIndex");
       index->Resize({dims});
       index->mutable_data<int>(context.GetPlace());
-      max_pool(dev_ctx, *in, out, index);
-      return;
-    }
-
-    auto& place =
-        *context.template device_context<DeviceContext>().eigen_device();
-    for (int i = 0; i < static_cast<int>(lod_level_0.size()) - 1; ++i) {
-      Tensor in_t = in->Slice(static_cast<int>(lod_level_0[i]),
-                              static_cast<int>(lod_level_0[i + 1]));
-      Tensor out_t = out->Slice(i, i + 1);
-      int64_t h = static_cast<int64_t>(lod_level_0[i + 1] - lod_level_0[i]);
-      auto in_e = EigenMatrix<T>::From(in_t, framework::make_ddim({h, w}));
-      auto out_e = EigenVector<T>::Flatten(out_t);
-
-      if (pooltype == "AVERAGE") {
-        out_e.device(place) = in_e.mean(Eigen::array<int, 1>({{0}}));
-      } else if (pooltype == "SUM") {
-        out_e.device(place) = in_e.sum(Eigen::array<int, 1>({{0}}));
-      } else if (pooltype == "SQRT") {
-        out_e.device(place) = in_e.sum(Eigen::array<int, 1>({{0}})) /
-                              std::sqrt(static_cast<T>(h));
-      } else if (pooltype == "LAST") {
-        out_e.device(place) = in_e.chip(h - 1, 0);
-      } else if (pooltype == "FIRST") {
-        out_e.device(place) = in_e.chip(0, 0);
-      } else {
-        PADDLE_THROW("unsupported pooling pooltype");
-      }
     }
+    math::SequencePoolFunctor<DeviceContext, T> pool;
+    pool(context.template device_context<DeviceContext>(), pooltype, *in, out,
+         index);
   }
 };
 
@@ -96,58 +61,17 @@ template <typename DeviceContext, typename T>
 class SequencePoolGradKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& context) const override {
-    auto* in = context.Input<LoDTensor>("X");
     auto* out_g = context.Input<Tensor>(framework::GradVarName("Out"));
     auto* in_g = context.Output<LoDTensor>(framework::GradVarName("X"));
     std::string pooltype = context.Attr<std::string>("pooltype");
-
-    auto dims = in->dims();
-    auto lod = in->lod()[0];
-    int64_t w = in->numel() / dims[0];
-
-    in_g->mutable_data<T>(context.GetPlace());
-    auto& dev_ctx = context.template device_context<DeviceContext>();
-
+    const Tensor* index = nullptr;
     if (pooltype == "MAX") {
-      math::MaxSeqPoolGradFunctor<DeviceContext, T> max_pool_grad;
-      auto* index = context.Input<Tensor>("MaxIndex");
-      max_pool_grad(dev_ctx, *out_g, *index, in_g);
-      return;
-    }
-
-    if (pooltype == "LAST" || pooltype == "FIRST") {
-      // set X@Grad be zero at first when pooltype is LAST/FIRST
-      math::SetConstant<DeviceContext, T> functor;
-      functor(dev_ctx, in_g, 0);
-    }
-    auto& place =
-        *context.template device_context<DeviceContext>().eigen_device();
-
-    for (int i = 0; i < static_cast<int>(lod.size()) - 1; ++i) {
-      auto in_g_t =
-          in_g->Slice(static_cast<int>(lod[i]), static_cast<int>(lod[i + 1]));
-      auto out_g_t = out_g->Slice(i, i + 1);
-      int64_t h = static_cast<int64_t>(lod[i + 1] - lod[i]);
-      auto in_g_e = EigenMatrix<T>::From(in_g_t, {h, w});
-      auto out_g_e = EigenMatrix<T>::From(out_g_t, {1, w});
-      auto out_g_e_v = EigenVector<T>::Flatten(out_g_t);
-      Eigen::DSizes<int, 2> bcast(h, 1);
-
-      if (pooltype == "AVERAGE") {
-        in_g_e.device(place) = (out_g_e / static_cast<T>(h)).broadcast(bcast);
-      } else if (pooltype == "SUM") {
-        in_g_e.device(place) = (out_g_e).broadcast(bcast);
-      } else if (pooltype == "SQRT") {
-        in_g_e.device(place) =
-            (out_g_e / std::sqrt(static_cast<T>(h))).broadcast(bcast);
-      } else if (pooltype == "LAST") {
-        in_g_e.chip(h - 1, 0).device(place) = out_g_e_v;
-      } else if (pooltype == "FIRST") {
-        in_g_e.chip(0, 0).device(place) = out_g_e_v;
-      } else {
-        PADDLE_THROW("unsupported pooling pooltype");
-      }
+      index = context.Input<Tensor>("MaxIndex");
     }
+    in_g->mutable_data<T>(context.GetPlace());
+    math::SequencePoolGradFunctor<DeviceContext, T> pool;
+    pool(context.template device_context<DeviceContext>(), pooltype, *out_g,
+         in_g, index);
   }
 };
 
diff --git a/python/paddle/fluid/tests/unittests/test_seq_pool.py b/python/paddle/fluid/tests/unittests/test_seq_pool.py
index 0488475721..2e48ef0e88 100644
--- a/python/paddle/fluid/tests/unittests/test_seq_pool.py
+++ b/python/paddle/fluid/tests/unittests/test_seq_pool.py
@@ -49,6 +49,61 @@ class TestSeqAvgPool(OpTest):
         self.check_grad(["X"], "Out")
 
 
+class TestSeqSumPool(TestSeqAvgPool):
+    def compute(self, x, lod, out):
+        self.attrs = {'pooltype': "SUM"}
+        for i in range(4):
+            sub_x = x[lod[0][i]:lod[0][i + 1], :]
+            out[i] = sub_x.sum(axis=0)
+
+
+class TestSeqMaxPool(TestSeqAvgPool):
+    def set_data(self):
+        self.op_type = 'sequence_pool'
+        x = np.random.uniform(0.1, 1, [13, 23]).astype('float32')
+        lod = [[0, 4, 5, 8, 13]]
+        for i in range(4):
+            l = lod[0][i + 1] - lod[0][i]
+            x[lod[0][i] + np.random.randint(l), :] += 2.0
+
+        self.inputs = {'X': (x, lod)}
+
+        out = np.zeros((4, 23)).astype('float32')
+        self.outputs = {'Out': out}
+        return x, lod, out
+
+    def compute(self, x, lod, out):
+        self.attrs = {'pooltype': "MAX"}
+        for i in range(4):
+            sub_x = x[lod[0][i]:lod[0][i + 1], :]
+            out[i] = np.amax(sub_x, axis=0)
+
+
+class TestSeqSqrtPool(TestSeqAvgPool):
+    def compute(self, x, lod, out):
+        self.attrs = {'pooltype': "SQRT"}
+        for i in range(4):
+            sub_x = x[lod[0][i]:lod[0][i + 1], :]
+            len = lod[0][i + 1] - lod[0][i]
+            out[i] = sub_x.sum(axis=0) / np.sqrt(len)
+
+
+class TestSeqLastPool(TestSeqAvgPool):
+    def compute(self, x, lod, out):
+        self.attrs = {'pooltype': "LAST"}
+        for i in range(4):
+            sub_x = x[lod[0][i]:lod[0][i + 1], :]
+            out[i] = sub_x[-1, :]
+
+
+class TestSeqFirstPool(TestSeqAvgPool):
+    def compute(self, x, lod, out):
+        self.attrs = {'pooltype': "FIRST"}
+        for i in range(4):
+            sub_x = x[lod[0][i]:lod[0][i + 1], :]
+            out[i] = sub_x[0, :]
+
+
 class TestSeqAvgPool2D(TestSeqAvgPool):
     def set_data(self):
         self.op_type = 'sequence_pool'
@@ -68,14 +123,6 @@ class TestSeqAvgPool2D(TestSeqAvgPool):
             out[i] = np.reshape(sub_x.mean(axis=0), (3, 17))
 
 
-class TestSeqSumPool(TestSeqAvgPool):
-    def compute(self, x, lod, out):
-        self.attrs = {'pooltype': "SUM"}
-        for i in range(4):
-            sub_x = x[lod[0][i]:lod[0][i + 1], :]
-            out[i] = sub_x.sum(axis=0)
-
-
 class TestSeqSumPool2D(TestSeqAvgPool2D):
     def compute(self, x, lod, out):
         self.attrs = {'pooltype': "SUM"}
@@ -84,15 +131,6 @@ class TestSeqSumPool2D(TestSeqAvgPool2D):
             out[i] = np.reshape(sub_x.sum(axis=0), (3, 17))
 
 
-class TestSeqSqrtPool(TestSeqAvgPool):
-    def compute(self, x, lod, out):
-        self.attrs = {'pooltype': "SQRT"}
-        for i in range(4):
-            sub_x = x[lod[0][i]:lod[0][i + 1], :]
-            len = lod[0][i + 1] - lod[0][i]
-            out[i] = sub_x.sum(axis=0) / np.sqrt(len)
-
-
 class TestSeqSqrtPool2D(TestSeqAvgPool2D):
     def compute(self, x, lod, out):
         self.attrs = {'pooltype': "SQRT"}
@@ -108,28 +146,6 @@ class TestSeqSqrtPool2D(TestSeqAvgPool2D):
         self.check_grad(["X"], "Out", max_relative_error=0.06)
 
 
-class TestSeqMaxPool(TestSeqAvgPool):
-    def set_data(self):
-        self.op_type = 'sequence_pool'
-        x = np.random.uniform(0.1, 1, [13, 23]).astype('float32')
-        lod = [[0, 4, 5, 8, 13]]
-        for i in range(4):
-            l = lod[0][i + 1] - lod[0][i]
-            x[lod[0][i] + np.random.randint(l), :] += 2.0
-
-        self.inputs = {'X': (x, lod)}
-
-        out = np.zeros((4, 23)).astype('float32')
-        self.outputs = {'Out': out}
-        return x, lod, out
-
-    def compute(self, x, lod, out):
-        self.attrs = {'pooltype': "MAX"}
-        for i in range(4):
-            sub_x = x[lod[0][i]:lod[0][i + 1], :]
-            out[i] = np.amax(sub_x, axis=0)
-
-
 class TestSeqMaxPool2D(TestSeqAvgPool2D):
     def set_data(self):
         self.op_type = 'sequence_pool'
@@ -151,14 +167,6 @@ class TestSeqMaxPool2D(TestSeqAvgPool2D):
             out[i] = np.reshape(np.amax(sub_x, axis=0), (3, 11))
 
 
-class TestSeqLastPool(TestSeqAvgPool):
-    def compute(self, x, lod, out):
-        self.attrs = {'pooltype': "LAST"}
-        for i in range(4):
-            sub_x = x[lod[0][i]:lod[0][i + 1], :]
-            out[i] = sub_x[-1, :]
-
-
 class TestSeqLastPool2D(TestSeqAvgPool2D):
     def compute(self, x, lod, out):
         self.attrs = {'pooltype': "LAST"}
@@ -167,14 +175,6 @@ class TestSeqLastPool2D(TestSeqAvgPool2D):
             out[i] = np.reshape(sub_x[-1, :], (3, 17))
 
 
-class TestSeqFirstPool(TestSeqAvgPool):
-    def compute(self, x, lod, out):
-        self.attrs = {'pooltype': "FIRST"}
-        for i in range(4):
-            sub_x = x[lod[0][i]:lod[0][i + 1], :]
-            out[i] = sub_x[0, :]
-
-
 class TestSeqFirstPool2D(TestSeqAvgPool2D):
     def compute(self, x, lod, out):
         self.attrs = {'pooltype': "FIRST"}