modified benchmark

Cong Hao · Cong Hao · commit 61c650db8907 · 2018-12-12T15:52:05.000-06:00
diff --git a/benchmark/graph_traversal/levelgraph.hpp b/benchmark/graph_traversal/levelgraph.hpp
@@ -203,9 +203,9 @@ class LevelGraph {
 
 };
 
-std::chrono::microseconds measure_time_taskflow(LevelGraph&);
-std::chrono::microseconds measure_time_omp(LevelGraph&);
-std::chrono::microseconds measure_time_tbb(LevelGraph&);
+std::chrono::microseconds measure_time_taskflow(LevelGraph&, unsigned);
+std::chrono::microseconds measure_time_omp(LevelGraph&, unsigned);
+std::chrono::microseconds measure_time_tbb(LevelGraph&, unsigned);
 
 
 
diff --git a/benchmark/graph_traversal/main.cpp b/benchmark/graph_traversal/main.cpp
@@ -1,30 +1,36 @@
 #include "levelgraph.hpp"
 
-int main() {
+int main(int argc, char* argv[]) {
+
+  unsigned num_threads = std::thread::hardware_concurrency();
+
+  if(argc > 1) {
+    num_threads = std::atoi(argv[1]);
+  }
 
   double omp_time {0.0};
   double tbb_time {0.0};
   double tf_time  {0.0};
   int rounds {5};
- 
+  
   std::cout << std::setw(12) << "|V|+|E|"
             << std::setw(12) << "OpenMP"
             << std::setw(12) << "TBB"
             << std::setw(12) << "Taskflow"
             << std::endl;
 
-  for(int i=1; i<=401; i += 4) {
+  for(int i=1; i<=401; i += 10) {
 
     LevelGraph graph(i, i);
     
     for(int j=0; j<rounds; ++j) {
-      omp_time += measure_time_omp(graph).count();
+      omp_time += measure_time_omp(graph, num_threads).count();
       graph.clear_graph();
 
-      tbb_time += measure_time_tbb(graph).count();
+      tbb_time += measure_time_tbb(graph, num_threads).count();
       graph.clear_graph();
 
-      tf_time  += measure_time_taskflow(graph).count();
+      tf_time  += measure_time_taskflow(graph, num_threads).count();
       graph.clear_graph();
     }
 
diff --git a/benchmark/graph_traversal/omp.cpp b/benchmark/graph_traversal/omp.cpp
@@ -4,9 +4,9 @@
 
 #include "levelgraph.hpp"
 
-void traverse_regular_graph_omp(LevelGraph& graph){
+void traverse_regular_graph_omp(LevelGraph& graph, unsigned num_threads){
 
-  omp_set_num_threads(std::thread::hardware_concurrency());
+  omp_set_num_threads(num_threads);
   
   #pragma omp parallel
   {
@@ -262,9 +262,9 @@ void traverse_regular_graph_omp(LevelGraph& graph){
   }  
 }
 
-std::chrono::microseconds measure_time_omp(LevelGraph& graph){
+std::chrono::microseconds measure_time_omp(LevelGraph& graph, unsigned num_threads){
   auto beg = std::chrono::high_resolution_clock::now();
-  traverse_regular_graph_omp(graph);
+  traverse_regular_graph_omp(graph, num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
 }
diff --git a/benchmark/graph_traversal/taskflow.cpp b/benchmark/graph_traversal/taskflow.cpp
@@ -6,7 +6,7 @@
 
 struct TF {
   
-  TF(LevelGraph& graph) {
+  TF(LevelGraph& graph, unsigned num_threads) : tf {num_threads} {
 
     tasks.resize(graph.level()); 
     for(size_t i=0; i<tasks.size(); ++i) {
@@ -38,14 +38,14 @@ struct TF {
 
 };
 
-void traverse_level_graph_taskflow(LevelGraph& graph){
-  TF tf(graph);
+void traverse_level_graph_taskflow(LevelGraph& graph, unsigned num_threads){
+  TF tf(graph, num_threads);
   tf.run();
 }
 
-std::chrono::microseconds measure_time_taskflow(LevelGraph& graph){
+std::chrono::microseconds measure_time_taskflow(LevelGraph& graph, unsigned num_threads){
   auto beg = std::chrono::high_resolution_clock::now();
-  traverse_level_graph_taskflow(graph);
+  traverse_level_graph_taskflow(graph, num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
 }
diff --git a/benchmark/graph_traversal/tbb.cpp b/benchmark/graph_traversal/tbb.cpp
@@ -11,9 +11,9 @@ using namespace tbb::flow;
 
 struct TBB {
   
-  TBB(LevelGraph& graph) {
+  TBB(LevelGraph& graph, unsigned num_threads) {
 
-    tbb::task_scheduler_init init(std::thread::hardware_concurrency());
+    tbb::task_scheduler_init init(num_threads);
 
     tasks.resize(graph.level()); 
     for(size_t i=0; i<tasks.size(); ++i) {
@@ -60,14 +60,14 @@ struct TBB {
   std::unique_ptr<continue_node<continue_msg>> source;
 };
 
-void traverse_regular_graph_tbb(LevelGraph& graph){
-  TBB tbb(graph);
+void traverse_regular_graph_tbb(LevelGraph& graph, unsigned num_threads){
+  TBB tbb(graph, num_threads);
   tbb.run();
 }
 
-std::chrono::microseconds measure_time_tbb(LevelGraph& graph){
+std::chrono::microseconds measure_time_tbb(LevelGraph& graph, unsigned num_threads){
   auto beg = std::chrono::high_resolution_clock::now();
-  traverse_regular_graph_tbb(graph);
+  traverse_regular_graph_tbb(graph, num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
 }
diff --git a/benchmark/wavefront/main.cpp b/benchmark/wavefront/main.cpp
@@ -1,6 +1,12 @@
 #include "matrix.hpp"
 
-int main() {
+int main(int argc, char* argv[]) {
+
+  unsigned num_threads = std::thread::hardware_concurrency();
+
+  if(argc > 1) {
+    num_threads = std::atoi(argv[1]);
+  }
 
   double omp_time {0.0};
   double tbb_time {0.0};
@@ -23,9 +29,9 @@ int main() {
     init_matrix();
 
     for(int j=0; j<rounds; ++j) {
-      omp_time += measure_time_omp().count();
-      tbb_time += measure_time_tbb().count();
-      tf_time  += measure_time_taskflow().count();
+      omp_time += measure_time_omp(num_threads).count();
+      tbb_time += measure_time_tbb(num_threads).count();
+      tf_time  += measure_time_taskflow(num_threads).count();
     }
 
     destroy_matrix();
diff --git a/benchmark/wavefront/matrix.hpp b/benchmark/wavefront/matrix.hpp
@@ -17,8 +17,8 @@ inline double **matrix {nullptr};
 
 // nominal operations
 inline double calc(double v0, double v1) {
-  return (v0 == v1) ? std::pow(v0/v1, 4.0f) : std::max(v0,v1);
-  //return std::max(v0, v1);
+  //return (v0 == v1) ? std::pow(v0/v1, 4.0f) : std::max(v0,v1);
+  return std::max(v0, v1);
 }
 
 // initialize the matrix
@@ -56,8 +56,8 @@ inline void block_computation(int i, int j){
 }
 
 
-std::chrono::microseconds measure_time_taskflow();
-std::chrono::microseconds measure_time_omp();
-std::chrono::microseconds measure_time_tbb();
+std::chrono::microseconds measure_time_taskflow(unsigned);
+std::chrono::microseconds measure_time_omp(unsigned);
+std::chrono::microseconds measure_time_tbb(unsigned);
 
 
diff --git a/benchmark/wavefront/omp.cpp b/benchmark/wavefront/omp.cpp
@@ -5,7 +5,7 @@
 int **D {nullptr};
 
 // wavefront computation
-void wavefront_omp() {
+void wavefront_omp(unsigned num_threads) {
   
   // set up the dependency matrix
   D = new int *[MB];
@@ -16,7 +16,7 @@ void wavefront_omp() {
     }
   }
   
-  omp_set_num_threads(std::thread::hardware_concurrency());
+  omp_set_num_threads(num_threads);
 
   #pragma omp parallel
   {
@@ -73,9 +73,9 @@ void wavefront_omp() {
   delete [] D;
 }
 
-std::chrono::microseconds measure_time_omp() {
+std::chrono::microseconds measure_time_omp(unsigned num_threads) {
   auto beg = std::chrono::high_resolution_clock::now();
-  wavefront_omp();
+  wavefront_omp(num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg);
 }
diff --git a/benchmark/wavefront/taskflow.cpp b/benchmark/wavefront/taskflow.cpp
@@ -2,9 +2,9 @@
 #include <taskflow/taskflow.hpp> 
 
 // wavefront computing
-void wavefront_taskflow() {
+void wavefront_taskflow(unsigned num_threads) {
 
-  tf::Taskflow tf;
+  tf::Taskflow tf{num_threads};
 
   std::vector<std::vector<tf::Task>> node(MB);
 
@@ -22,17 +22,18 @@ void wavefront_taskflow() {
           block_computation(i, j);
         }
       );
-      if(j+1 < NB) node[i][j].precede(node[i][j+1]);
+
       if(i+1 < MB) node[i][j].precede(node[i+1][j]);
+      if(j+1 < NB) node[i][j].precede(node[i][j+1]);
     }
   }
 
   tf.wait_for_all();
 }
 
-std::chrono::microseconds measure_time_taskflow() {
+std::chrono::microseconds measure_time_taskflow(unsigned num_threads) {
   auto beg = std::chrono::high_resolution_clock::now();
-  wavefront_taskflow();
+  wavefront_taskflow(num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg);
 }
diff --git a/benchmark/wavefront/tbb.cpp b/benchmark/wavefront/tbb.cpp
@@ -3,12 +3,12 @@
 #include <tbb/flow_graph.h>
 
 // the wavefront computation
-void wavefront_tbb() {
+void wavefront_tbb(unsigned num_threads) {
 
   using namespace tbb;
   using namespace tbb::flow;
   
-  tbb::task_scheduler_init init(std::thread::hardware_concurrency());
+  tbb::task_scheduler_init init(num_threads);
     
   continue_node<continue_msg> ***node = new continue_node<continue_msg> **[MB];
 
@@ -42,9 +42,9 @@ void wavefront_tbb() {
   }
 }
 
-std::chrono::microseconds measure_time_tbb() {
+std::chrono::microseconds measure_time_tbb(unsigned num_threads) {
   auto beg = std::chrono::high_resolution_clock::now();
-  wavefront_tbb();
+  wavefront_tbb(num_threads);
   auto end = std::chrono::high_resolution_clock::now();
   return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg);
 }
diff --git a/example/threadpool.cpp b/example/threadpool.cpp
@@ -337,7 +337,7 @@ auto batch_insertions() {
 
 // Function: main
 int main(int argc, char* argv[]) {
-  
+
   std::cout << std::setw(WIDTH) << "workload"
             << std::setw(WIDTH) << "simple"
             << std::setw(WIDTH) << "pro"

Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,9 @@`
`4`	`4`
`5`	`5`	`#include "levelgraph.hpp"`
`6`	`6`
`7`		`-void traverse_regular_graph_omp(LevelGraph& graph){`
	`7`	`+void traverse_regular_graph_omp(LevelGraph& graph, unsigned num_threads){`
`8`	`8`
`9`		`- omp_set_num_threads(std::thread::hardware_concurrency());`
	`9`	`+ omp_set_num_threads(num_threads);`
`10`	`10`
`11`	`11`	`#pragma omp parallel`
`12`	`12`	`{`
`@@ -262,9 +262,9 @@ void traverse_regular_graph_omp(LevelGraph& graph){`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`-std::chrono::microseconds measure_time_omp(LevelGraph& graph){`
	`265`	`+std::chrono::microseconds measure_time_omp(LevelGraph& graph, unsigned num_threads){`
`266`	`266`	`auto beg = std::chrono::high_resolution_clock::now();`
`267`		`- traverse_regular_graph_omp(graph);`
	`267`	`+ traverse_regular_graph_omp(graph, num_threads);`
`268`	`268`	`auto end = std::chrono::high_resolution_clock::now();`
`269`	`269`	`return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);`
`270`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`int **D {nullptr};`
`6`	`6`
`7`	`7`	`// wavefront computation`
`8`		`-void wavefront_omp() {`
	`8`	`+void wavefront_omp(unsigned num_threads) {`
`9`	`9`
`10`	`10`	`// set up the dependency matrix`
`11`	`11`	`D = new int *[MB];`
`@@ -16,7 +16,7 @@ void wavefront_omp() {`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`
`19`		`- omp_set_num_threads(std::thread::hardware_concurrency());`
	`19`	`+ omp_set_num_threads(num_threads);`
`20`	`20`
`21`	`21`	`#pragma omp parallel`
`22`	`22`	`{`
`@@ -73,9 +73,9 @@ void wavefront_omp() {`
`73`	`73`	`delete [] D;`
`74`	`74`	`}`
`75`	`75`
`76`		`-std::chrono::microseconds measure_time_omp() {`
	`76`	`+std::chrono::microseconds measure_time_omp(unsigned num_threads) {`
`77`	`77`	`auto beg = std::chrono::high_resolution_clock::now();`
`78`		`- wavefront_omp();`
	`78`	`+ wavefront_omp(num_threads);`
`79`	`79`	`auto end = std::chrono::high_resolution_clock::now();`
`80`	`80`	`return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg);`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,9 @@`
`2`	`2`	`#include <taskflow/taskflow.hpp>`
`3`	`3`
`4`	`4`	`// wavefront computing`
`5`		`-void wavefront_taskflow() {`
	`5`	`+void wavefront_taskflow(unsigned num_threads) {`
`6`	`6`
`7`		`- tf::Taskflow tf;`
	`7`	`+ tf::Taskflow tf{num_threads};`
`8`	`8`
`9`	`9`	`std::vector<std::vector<tf::Task>> node(MB);`
`10`	`10`
`@@ -22,17 +22,18 @@ void wavefront_taskflow() {`
`22`	`22`	`block_computation(i, j);`
`23`	`23`	`}`
`24`	`24`	`);`
`25`		`- if(j+1 < NB) node[i][j].precede(node[i][j+1]);`
	`25`	`+`
`26`	`26`	`if(i+1 < MB) node[i][j].precede(node[i+1][j]);`
	`27`	`+ if(j+1 < NB) node[i][j].precede(node[i][j+1]);`
`27`	`28`	`}`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`tf.wait_for_all();`
`31`	`32`	`}`
`32`	`33`
`33`		`-std::chrono::microseconds measure_time_taskflow() {`
	`34`	`+std::chrono::microseconds measure_time_taskflow(unsigned num_threads) {`
`34`	`35`	`auto beg = std::chrono::high_resolution_clock::now();`
`35`		`- wavefront_taskflow();`
	`36`	`+ wavefront_taskflow(num_threads);`
`36`	`37`	`auto end = std::chrono::high_resolution_clock::now();`
`37`	`38`	`return std::chrono::duration_cast<std::chrono::milliseconds>(end - beg);`
`38`	`39`	`}`