cpp-taskflow/benchmarks/thread_pool/thread_pool.cpp at master · ezhangle/cpp-taskflow · GitHub

History

82 lines (74 loc) · 1.84 KB

Raw

#include <taskflow/taskflow.hpp>

#include "ThreadPool.hpp"

ThreadPool* ThreadPool::singleton = nullptr;

std::mutex ThreadPool::singleton_mutex;

tf::Executor executor;

class ChronoTimer {

public:

ChronoTimer(void) {

}

void start(void){

startTime = std::chrono::high_resolution_clock::now();

}

void finish(std::string msg){

auto finish = std::chrono::high_resolution_clock::now();

std::chrono::duration<double> elapsed = finish - startTime;

printf("%s : %f ms\n",msg.c_str(), elapsed.count() * 1000);

}

private:

std::chrono::high_resolution_clock::time_point startTime;

};

float benchFunc(uint64_t loopLen){

float acc = 0;

for (uint64_t k = 0; k < loopLen; ++k)

acc += k;

return acc;

}

void bench(uint32_t iter){

printf("Benchmark with %d iterations\n",iter);

const uint64_t num_blocks = 1000;

const uint64_t loopLen = 100;

ChronoTimer timer;

ThreadPool *pool = ThreadPool::get();

timer.start();

for (uint64_t it = 0; it < iter; ++it) {

tf::Taskflow taskflow;

tf::Task node[num_blocks];

for (uint64_t i = 0; i < num_blocks; i++)

node[i] = taskflow.placeholder();

for (uint64_t i = 0; i < num_blocks; i++) {

node[i].work([=]() {

benchFunc(loopLen);

});

}

executor.run(taskflow).wait();

}

timer.finish("taskflow: time in ms: ");

timer.start();

for (uint64_t it = 0; it < iter; ++it) {

std::vector<std::future<int>> results;

for (uint64_t i = 0; i < num_blocks; i++) {

results.emplace_back(pool->enqueue([=]() {

benchFunc(loopLen);

return 0;

}));

}

for(auto& result : results)

{

result.get();

}

timer.finish("threadpool: time in ms: ");

}

int main() {