std::array<std::uint32_t, std::mt19937::state_size> seed_bits{};

std::random_device real_random{};

std::generate(seed_bits.begin(), seed_bits.end(), std::ref(real_random));

std::seed_seq wrapped_seed_bits(seed_bits.begin(), seed_bits.end());

return std::mt19937(wrapped_seed_bits);

Fill_in_vector(std::vector<int>& v, int length)

: v_{v}, length_{length} {}

void operator()() {

auto rng = init_mersenne_twister();

std::uniform_int_distribution<int> percentile_die(1, 100);

//the taskflow is used only once, so we can mess up with length_ value

while (length_ > 0) {

--length_;

v_.push_back( percentile_die(rng) );

}

}

std::vector<int>& v_;

int length_;

Pick_up_max(std::vector<int>& in1, std::vector<int>& in2, std::vector<int>& out)

: in1_{in1}, in2_{in2}, out_{out} {}

void operator()() {

for (std::vector<int>::size_type i{}, e = in1_.size(); i < e; ++i) {

in1_[i] = std::max(in1_[i], in2_[i]);

}

// the taskflow is executed once, so we avoid one allocation

out_.swap(in1_);

}

std::vector<int>& in1_;

std::vector<int>& in2_;

std::vector<int>& out_;

Print(std::vector<int> const& v)

: v_{v} {}

void operator()() {

bool first{ true };

for (auto i : v_) {

if (!first) {

std::cout << ", ";

}

std::cout << i;

first = false;

}

std::cout << "\n";

}

std::vector<int> const& v_;

// Set up the memory for the arcs

std::vector<int> in1{}, in2{}, out{};

// Prepare the functors for taskflow

tf::Taskflow tf;

auto [

fill_in_vector1,

fill_in_vector2,

pick_up_max,

print

] = tf.emplace(

Fill_in_vector(in1, 20),

Fill_in_vector(in2, 20),

Pick_up_max(in1, in2, out),

Print(out)

);

// Set up the dependencies

fill_in_vector1.precede(pick_up_max);

fill_in_vector2.precede(pick_up_max);

pick_up_max.precede(print);

// Execution

tf.wait_for_all();

return 0;