600 lines
23 KiB
C++
600 lines
23 KiB
C++
#include "levelgraph.hpp"
|
|
#include <taskflow/taskflow.hpp>
|
|
#include <taskflow/algorithm/pipeline.hpp>
|
|
//#include "matrix_calculation.hpp"
|
|
|
|
struct Input {
|
|
size_t lev;
|
|
size_t len;
|
|
std::vector<int>& mybuffer;
|
|
LevelGraph& graph;
|
|
|
|
void operator()(tf::Pipeflow& pf) {
|
|
if (len == 0 && lev == graph.level()) {
|
|
pf.stop();
|
|
}
|
|
else {
|
|
mybuffer[pf.line()] = graph.node_at(lev, len).uid();
|
|
int val = work(mybuffer[pf.line()]);
|
|
graph.node_at(lev, len).set_value(val);
|
|
|
|
if(len == graph.length()-1){
|
|
++lev;
|
|
len = 0;
|
|
}
|
|
else {
|
|
++len;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
struct Filter {
|
|
std::vector<int>& mybuffer;
|
|
LevelGraph& graph;
|
|
|
|
void operator()(tf::Pipeflow& pf) {
|
|
|
|
int uid = mybuffer[pf.line()];
|
|
int val = work(uid);
|
|
size_t level = graph.level();
|
|
size_t length = graph.length();
|
|
|
|
graph.node_at(uid/level, uid%length).set_value(val);
|
|
}
|
|
};
|
|
|
|
struct FilterFinal {
|
|
std::vector<int>& mybuffer;
|
|
LevelGraph& graph;
|
|
|
|
void operator()(tf::Pipeflow& pf){
|
|
int uid = mybuffer[pf.line()];
|
|
int val = work(uid);
|
|
|
|
int lev = uid/graph.level();
|
|
int len = uid%graph.length();
|
|
|
|
if (lev != 0) {
|
|
int value_prev_level = 0;
|
|
|
|
for (auto& in_edge : graph.node_at(lev, len)._in_edges) {
|
|
value_prev_level += graph.node_at(lev-1, in_edge.first).get_value();
|
|
}
|
|
graph.node_at(lev, len).set_value(val + value_prev_level);
|
|
}
|
|
else {
|
|
graph.node_at(lev, len).set_value(val);
|
|
}
|
|
}
|
|
};
|
|
|
|
// graph_pipeline_taskflow_1_pipe
|
|
std::chrono::microseconds graph_pipeline_taskflow_1_pipe(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}} // 1st pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_2_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_2_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 2nd pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_3_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_3_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 3rd pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_4_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_4_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 4th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_5_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_5_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 5th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_6_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_6_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 6th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_7_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_7_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 7th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_8_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_8_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
//std::ofstream outputfile;
|
|
//outputfile.open("./tf_result.txt", std::ofstream::app);
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 8th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
//for(auto r:result) {
|
|
// outputfile << r << '\n';
|
|
//}
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_9_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_9_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 9th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_10_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_10_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 10th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
|
|
// graph_pipeline_taskflow_11_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_11_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 11th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_12_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_12_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 11th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 12th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_13_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_13_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 11th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 12th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 13th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_14_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_14_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 11th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 12th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 13th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 14th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_15_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_15_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 11th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 12th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 13th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 14th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 15th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
// graph_pipeline_taskflow_16_pipes
|
|
std::chrono::microseconds graph_pipeline_taskflow_16_pipes(
|
|
LevelGraph& graph, unsigned num_lines, unsigned num_threads) {
|
|
|
|
tf::Taskflow taskflow;
|
|
tf::Executor executor(num_threads);
|
|
|
|
std::vector<int> mybuffer(num_lines);
|
|
|
|
//std::ofstream outputfile;
|
|
//outputfile.open("./tf_16_pipes.txt", std::ofstream::app);
|
|
|
|
auto beg = std::chrono::high_resolution_clock::now();
|
|
tf::Pipeline pl(num_lines,
|
|
tf::Pipe{tf::PipeType::SERIAL, Input{0, 0, mybuffer, graph}}, // 1st pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 2nd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 3rd pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 4th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 5th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 6th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 7th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 8th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 9th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 10th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 11th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 12th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 13th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 14th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, Filter{mybuffer, graph}}, // 15th pipe
|
|
tf::Pipe{tf::PipeType::SERIAL, FilterFinal{mybuffer, graph}} // 16th pipe
|
|
);
|
|
|
|
taskflow.composed_of(pl);
|
|
executor.run(taskflow).wait();
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
//outputfile.close();
|
|
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(end - beg);
|
|
}
|
|
|
|
std::chrono::microseconds measure_time_taskflow(
|
|
LevelGraph& graph, size_t pipes, unsigned num_lines, unsigned num_threads) {
|
|
|
|
std::chrono::microseconds elapsed;
|
|
|
|
switch(pipes) {
|
|
case 1:
|
|
elapsed = graph_pipeline_taskflow_1_pipe(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 2:
|
|
elapsed = graph_pipeline_taskflow_2_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 3:
|
|
elapsed = graph_pipeline_taskflow_3_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 4:
|
|
elapsed = graph_pipeline_taskflow_4_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 5:
|
|
elapsed = graph_pipeline_taskflow_5_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 6:
|
|
elapsed = graph_pipeline_taskflow_6_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 7:
|
|
elapsed = graph_pipeline_taskflow_7_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 8:
|
|
elapsed = graph_pipeline_taskflow_8_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 9:
|
|
elapsed = graph_pipeline_taskflow_9_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 10:
|
|
elapsed = graph_pipeline_taskflow_10_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 11:
|
|
elapsed = graph_pipeline_taskflow_11_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 12:
|
|
elapsed = graph_pipeline_taskflow_12_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 13:
|
|
elapsed = graph_pipeline_taskflow_13_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 14:
|
|
elapsed = graph_pipeline_taskflow_14_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 15:
|
|
elapsed = graph_pipeline_taskflow_15_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
case 16:
|
|
elapsed = graph_pipeline_taskflow_16_pipes(graph, num_lines, num_threads);
|
|
break;
|
|
|
|
default:
|
|
throw std::runtime_error("can support only up to 16 pipes");
|
|
break;
|
|
}
|
|
return elapsed;
|
|
}
|
|
|