// 2018/08/28 - contributed by Glen Fraser

//

// Simple example showing use of the C++14-compatible threadpool

// implementation. The threadpool (alone) may be used when you have

// no inter-task dependencies to express, and when you require

// C++14 for a project.

//

// NOTE: if you are using a fully C++17-compliant compiler, you should

// be including <taskflow/taskflow.hpp> rather than this file!

//

// Compile with VS2017 using:

// cl /std:c++14 /W4 /EHsc /O2 /Ipath-to-taskflow threadpool_cxx14.cpp

// Compile with clang (including Apple LLVM version 9.0.0) using:

// clang++ -std=c++14 -Wall -O3 -Ipath-to-taskflow threadpool_cxx14.cpp -o threadpool_cxx14

// (for gcc, replace clang++ with g++)

#include <taskflow/threadpool/threadpool_cxx14.hpp>

#include <iostream>

#include <random>

// The "noinline" directive is used to prevent the compiler from

// optimizing out the entire calculation, ensuring it actually does

// its (fake) work when we want it to (for testing), at runtime.

#ifdef _WIN32

__declspec(noinline)

#else

__attribute__((noinline))

#endif // _WIN32

int64_t compute(int64_t x, int64_t i, int64_t r)

{

return x + i + r;

}

int main()

{

auto numThreads = std::max(1u, std::thread::hardware_concurrency());

tf::Threadpool tp(numThreads);

std::default_random_engine gen(17);

std::uniform_int_distribution<int64_t> d{ 0, 10000 };

std::vector<std::future<int64_t>> intFutures;

std::vector<std::future<void>> voidFutures;

auto start = std::chrono::steady_clock::now();

for (auto i = 0; i < 2000; ++i) {

auto r = d(gen);

auto future = tp.async(

[i, r]() {

int64_t sum = 0;

for (int64_t x = 0; x < 10000000; ++x) {

sum += compute(x, i, r);

}

return sum;

});

intFutures.push_back(std::move(future));

voidFutures.push_back(tp.async([]() {

// Simulate a very small task that returns no value.

std::this_thread::sleep_for(std::chrono::microseconds(5));

}));

}

std::cout << "Scheduled " << intFutures.size() + voidFutures.size() << " tasks...\n";

// Wait for them all to finish (get the results)

int64_t sum = 0;

for (auto& f : intFutures) {

sum += f.get();

}

for (auto& f : voidFutures) {

f.get();

}

auto end = std::chrono::steady_clock::now();

std::cout << "...ran in "

<< std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()

<< " milliseconds\n";

std::cout << "Remaining scheduled tasks: " << tp.num_tasks()

<< "\tWorker threads: " << tp.num_workers() << '\n';

std::cout << intFutures.size() << " int futures summed to: " << sum << '\n';

std::cout << "(also ran " << voidFutures.size() << " void futures)\n";

std::cout << "\n";

// You may also use Threadpool::wait_for_all() to synchronize -- it

// will return when all scheduled tasks have completed (even tasks

// scheduled "silently" without a future).

auto const numSilentTasks = 10;

std::mutex printMutex;

for (auto i = 0; i < numSilentTasks; ++i) {

tp.silent_async([=, &printMutex]() {

// Simulate a small task

std::this_thread::sleep_for(std::chrono::microseconds(5) * (numSilentTasks - i));

std::lock_guard<std::mutex> lock(printMutex);

std::cout << "Silent task " << i << " returning\n";

});

}

tp.wait_for_all();

{

std::lock_guard<std::mutex> lock(printMutex);

std::cout << "Main thread: all scheduled tasks are done\n";

}

return 0;

}