fixed benchmark compilation error

Author: twhuang-utah

benchmarks/binary_tree/omp.cpp

@@ -4,7 +4,7 @@
 // binary_tree_omp
 void binary_tree_omp(size_t num_layers, unsigned num_threads) {
 
-  std::atomic<size_t> counter = 0;
+  std::atomic<size_t> counter {0};
 
   size_t N = 1 << num_layers;
   size_t *D = new size_t [N]; 

benchmarks/mnist/dnn.hpp

@@ -186,12 +186,15 @@ struct MNIST {
 
   void add_layer(size_t in_degree, size_t out_degree, Activation act) {
     acts.emplace_back(act);
-    Ys.emplace_back().resize(batch_size, out_degree);
+    Ys.emplace_back();
+    Ys.back().resize(batch_size, out_degree);
     Ws.push_back(Eigen::MatrixXf::Random(in_degree, out_degree));
     Bs.push_back(Eigen::MatrixXf::Random(1, out_degree));
 
-    dW.emplace_back().resize(in_degree, out_degree);
-    dB.emplace_back().resize(1, out_degree);
+    dW.emplace_back();
+    dW.back().resize(in_degree, out_degree);
+    dB.emplace_back();
+    dB.back().resize(1, out_degree);
   }
 
   void forward(size_t layer, const Eigen::MatrixXf& mat) {

benchmarks/mnist/taskflow.cpp

@@ -23,9 +23,10 @@ void run_taskflow(MNIST& D, unsigned num_threads) {
 
   for(auto e=0u; e<D.epoch; e++) {
     for(auto i=0u; i<iter_num; i++) {
-      auto& f_task = forward_tasks.emplace_back(taskflow.emplace(
+      forward_tasks.emplace_back(taskflow.emplace(
         [&, i=i, e=e%num_par_shf]() { forward_task(D, i, e, mats, vecs); }
       ));
+      auto& f_task = forward_tasks.back();
 
       if(i != 0 || (i == 0 && e != 0)) {
         auto sz = update_tasks.size();
@@ -36,14 +37,16 @@ void run_taskflow(MNIST& D, unsigned num_threads) {
 
       for(int j=D.acts.size()-1; j>=0; j--) {
         // backward propagation
-        auto& b_task = backward_tasks.emplace_back(taskflow.emplace(
+        backward_tasks.emplace_back(taskflow.emplace(
           [&, i=j, e=e%num_par_shf] () { backward_task(D, i, e, mats); }
         ));
+        auto& b_task = backward_tasks.back();
 
         // update weight 
-        auto& u_task = update_tasks.emplace_back(
+        update_tasks.emplace_back(
           taskflow.emplace([&, i=j] () {D.update(i);})
         );
+        auto& u_task = update_tasks.back();
 
         if(j + 1u == D.acts.size()) {
           f_task.precede(b_task);
@@ -58,13 +61,14 @@ void run_taskflow(MNIST& D, unsigned num_threads) {
 
     if(e == 0) {
       // No need to shuffle in first epoch
-      shuffle_tasks.emplace_back(taskflow.emplace([](){}))
-                   .precede(forward_tasks[forward_tasks.size()-iter_num]);           
+      shuffle_tasks.emplace_back(taskflow.emplace([](){}));
+      shuffle_tasks.back().precede(forward_tasks[forward_tasks.size()-iter_num]);           
     }
     else {
-      auto& t = shuffle_tasks.emplace_back(taskflow.emplace(
+      shuffle_tasks.emplace_back(taskflow.emplace(
         [&, e=e%num_par_shf]() { D.shuffle(mats[e], vecs[e], D.images.rows());}
       ));
+      auto& t = shuffle_tasks.back();
       t.precede(forward_tasks[forward_tasks.size()-iter_num]);
 
       // This shuffle task starts after belows finish

benchmarks/mnist/tbb.cpp

@@ -28,14 +28,15 @@ void run_tbb(MNIST& D, unsigned num_threads) {
 
   for(auto e=0u; e<D.epoch; e++) {
     for(auto i=0u; i<iter_num; i++) {
-      auto& f_task = forward_tasks.emplace_back(
+      forward_tasks.emplace_back(
         std::make_unique<continue_node<continue_msg>>(
           G, 
           [&, i=i, e=e%num_par_shf](const continue_msg&) {
             forward_task(D, i, e, mats, vecs);
           }
         ) 
       );
+      auto& f_task = forward_tasks.back();
 
       if(i != 0 || (i == 0 && e != 0)) {
         auto sz = update_tasks.size();
@@ -47,24 +48,26 @@ void run_tbb(MNIST& D, unsigned num_threads) {
       for(int j=D.acts.size()-1; j>=0; j--) {
 
         // backward propagation
-        auto& b_task = backward_tasks.emplace_back(
+        backward_tasks.emplace_back(
           std::make_unique<continue_node<continue_msg>>(
             G, 
             [&, i=j, e=e%num_par_shf] (const continue_msg&) {
               backward_task(D, i, e, mats);
             }
           )
         );
+        auto& b_task = backward_tasks.back();
 
         // update weight 
-        auto& u_task = update_tasks.emplace_back(
+        update_tasks.emplace_back(
           std::make_unique<continue_node<continue_msg>>(
             G, 
             [&, i=j] (const continue_msg&) {
               D.update(i);
             }
           )
         );
+        auto& u_task = update_tasks.back();
 
         if(j + 1u == D.acts.size()) {
           make_edge(*f_task, *b_task);
@@ -85,14 +88,15 @@ void run_tbb(MNIST& D, unsigned num_threads) {
       make_edge(*shuffle_tasks.back(), *forward_tasks[forward_tasks.size()-iter_num]);
     }
     else {
-      auto& t = shuffle_tasks.emplace_back(
+      shuffle_tasks.emplace_back(
         std::make_unique<continue_node<continue_msg>>(
           G, 
           [&, e=e%num_par_shf](const continue_msg&) {
             D.shuffle(mats[e], vecs[e], D.images.rows());
           }
         )
       );
+      auto& t = shuffle_tasks.back();
       make_edge(*t, *forward_tasks[forward_tasks.size()-iter_num]);
 
       // This shuffle task starts after belows finish