From 3b72c0c75723c3278b86c973142c9e76227a047a Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Thu, 31 Mar 2022 17:00:47 +0200 Subject: [PATCH 1/8] Add task handling benchmark --- test/benchmarks.cc | 74 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/test/benchmarks.cc b/test/benchmarks.cc index e9c159b2e..0d22e2fdc 100644 --- a/test/benchmarks.cc +++ b/test/benchmarks.cc @@ -57,6 +57,80 @@ TEMPLATE_TEST_CASE_SIG("benchmark intrusive graph dependency handling with N nod }; } +TEST_CASE("benchmark task handling", "[benchmark][task]") { + using namespace std::chrono_literals; + std::unique_ptr tm; + + constexpr int N = 10000; + constexpr int report_interval = 10; + + std::atomic highest_tid = 0; + std::atomic highest_tid_to_delete = 0; + + auto initialization_lambda = [&] { + highest_tid = 0; + tm = std::make_unique(1, nullptr, nullptr); + // we use this trick to force horizon creation without introducing dependency overhead in this microbenchmark + tm->set_horizon_step(0); + }; + + auto task_creation_lambda = [&](bool with_sync = false) { + for(int i = 0; i < N; ++i) { + // create simplest possible host task + highest_tid = tm->submit_command_group([](handler& cgh) { cgh.host_task(on_master_node, [] {}); }); + // start notifying once we've built some tasks + if(i % report_interval == 0 && i / report_interval > 1) { + while(with_sync && highest_tid_to_delete.load() < highest_tid.load()) + ; // need to potentially wait for task lookup thread to catch up + // every other generated task is always a horizon (step size 0) + tm->notify_horizon_reached(highest_tid + 1); + } + } + }; + + SECTION("without access thread") { + highest_tid_to_delete = N * 2; // set sufficiently high to just run through + BENCHMARK("generating and deleting tasks") { + initialization_lambda(); + task_creation_lambda(); + }; + } + + SECTION("with access thread") { + constexpr auto delay_per_call = 20us; + auto last_call = std::chrono::steady_clock::now(); + std::atomic run_lookups = false; + std::atomic run_thread = true; + + std::thread task_lookup([&] { + while(run_thread.load()) { + while(run_lookups.load()) { + auto htid = highest_tid.load(); + while((run_lookups.load() && htid > 0 && htid <= highest_tid_to_delete.load()) // + || std::chrono::steady_clock::now() - last_call < delay_per_call) + htid = highest_tid.load(); // wait until we are synchronized, and across the minimum delay interval + tm->get_task(htid); + highest_tid_to_delete = htid; + } + highest_tid_to_delete = 0; + } + }); + + BENCHMARK("generating and deleting tasks with access thread") { + initialization_lambda(); + highest_tid_to_delete = 0; + run_lookups = true; + task_creation_lambda(true); + run_lookups = false; + while(highest_tid_to_delete.load() != 0) + ; // wait for task lookup thread to finish + }; + + run_thread = false; + task_lookup.join(); + } +} + struct task_manager_benchmark_context { const size_t num_nodes = 1; From 35738b791915737d97d7704abdd54287476a1aba Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Fri, 1 Apr 2022 02:51:19 +0200 Subject: [PATCH 2/8] Replace task map with a simple ringbuffer --- include/print_graph.h | 4 +- include/task_manager.h | 23 ++++------- include/task_ring_buffer.h | 85 ++++++++++++++++++++++++++++++++++++++ src/print_graph.cc | 6 +-- src/task_manager.cc | 78 ++++++++++++---------------------- test/test_utils.h | 2 +- 6 files changed, 125 insertions(+), 73 deletions(-) create mode 100644 include/task_ring_buffer.h diff --git a/include/print_graph.h b/include/print_graph.h index 04f6c6ae8..ff37a6892 100644 --- a/include/print_graph.h +++ b/include/print_graph.h @@ -2,9 +2,9 @@ #include #include -#include #include "task.h" +#include "task_ring_buffer.h" namespace celerity { namespace detail { @@ -12,7 +12,7 @@ namespace detail { class command_graph; class task_manager; - std::string print_task_graph(const std::unordered_map>& tdag); + std::string print_task_graph(const task_ring_buffer& tdag); std::string print_command_graph(const command_graph& cdag, const task_manager& tm); } // namespace detail diff --git a/include/task_manager.h b/include/task_manager.h index 4de6be4b4..c5ed32a73 100644 --- a/include/task_manager.h +++ b/include/task_manager.h @@ -11,6 +11,7 @@ #include "host_queue.h" #include "region_map.h" #include "task.h" +#include "task_ring_buffer.h" #include "types.h" namespace celerity { @@ -66,7 +67,7 @@ namespace detail { task_id tid; { std::lock_guard lock(task_mutex); - tid = get_new_tid(); + tid = task_buffer.reserve_new_tid(); prepass_handler cgh(tid, std::make_unique>(cgf), num_collective_nodes); cgf(cgh); @@ -75,7 +76,7 @@ namespace detail { compute_dependencies(tid); if(queue) queue->require_collective_group(task_ref.get_collective_group_id()); - prune_tasks_before_latest_epoch_reached(); + task_buffer.delete_up_to(latest_epoch_reached.get()); } invoke_callbacks(tid); if(need_new_horizon()) { generate_horizon_task(); } @@ -127,7 +128,7 @@ namespace detail { /** * @brief Shuts down the task_manager, freeing all stored tasks. */ - void shutdown() { task_map.clear(); } + void shutdown() { task_buffer.clear(); } void set_horizon_step(const int step) { assert(step >= 0); @@ -154,12 +155,12 @@ namespace detail { * Returns the number of tasks created during the lifetime of the task_manager, * including tasks that have already been deleted. */ - task_id get_total_task_count() const { return next_task_id; } + int get_total_task_count() const { return task_buffer.get_total_task_count(); } /** * Returns the number of tasks currently being managed by the task_manager. */ - task_id get_current_task_count() const { return task_map.size(); } + int get_current_task_count() const { return task_buffer.get_current_task_count(); } private: const size_t num_collective_nodes; @@ -168,7 +169,7 @@ namespace detail { reduction_manager* reduction_mngr; task_id next_task_id = 1; - std::unordered_map> task_map; + task_ring_buffer task_buffer; // The active epoch is used as the last writer for host-initialized buffers. // This is useful so we can correctly generate anti-dependencies onto tasks that read host-initialized buffers. @@ -184,7 +185,7 @@ namespace detail { // Stores which host object was last affected by which task. std::unordered_map host_object_last_effects; - // For simplicity we use a single mutex to control access to all task-related (i.e. the task graph, task_map, ...) data structures. + // For simplicity we use a single mutex to control access to all task-related (i.e. the task graph, ...) data structures. mutable std::mutex task_mutex; std::vector task_callbacks; @@ -207,14 +208,9 @@ namespace detail { // The last epoch task that has been processed by the executor. Behind a monitor to allow awaiting this change from the main thread. epoch_monitor latest_epoch_reached{initial_epoch_task}; - // The last epoch that was used in task pruning after being reached. This allows skipping the pruning step if no new epoch was completed since. - task_id last_pruned_before{initial_epoch_task}; - // Set of tasks with no dependents std::unordered_set execution_front; - inline task_id get_new_tid() { return next_task_id++; } - task& register_task_internal(std::unique_ptr task); void invoke_callbacks(task_id tid); @@ -233,9 +229,6 @@ namespace detail { task_id generate_horizon_task(); - // Needs to be called while task map accesses are safe (ie. mutex is locked) - void prune_tasks_before_latest_epoch_reached(); - void compute_dependencies(task_id tid); }; diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h new file mode 100644 index 000000000..6e8fb69e1 --- /dev/null +++ b/include/task_ring_buffer.h @@ -0,0 +1,85 @@ +#pragma once + +#include +#include + +#include "task.h" +#include "types.h" + +namespace celerity::detail { + +constexpr unsigned long task_ringbuffer_size = 1024; + +template +class task_ring_buffer { + public: + size_t get_total_task_count() const { return next_task_id; } + size_t get_current_task_count() const { return next_task_id - number_of_deleted_tasks; } + + bool has_task(task_id tid) const { + // the nullptr check is necessary if the executor is waiting for a task to be available when its ID has been reserved + // but it has not been emplaced yet; This is safe since deletion always resets the unique_ptrs strictly prior + // to new reservations being possible + return tid >= number_of_deleted_tasks && tid < next_task_id && data[tid % N].get() != nullptr; + } + + task* find_task(task_id tid) const { return has_task(tid) ? data[tid % N].get() : nullptr; } + + task* get_task(task_id tid) const { + assert(has_task(tid)); + return data[tid % N].get(); + } + + task_id reserve_new_tid() { + wait_for_available_slot(); + auto ret = next_task_id; + next_task_id++; + return ret; + } + + // task_id must have been reserved previously + void emplace(task_id tid, std::unique_ptr task) { + data[tid % N] = std::move(task); // + } + + // may only be called by one thread + void delete_up_to(task_id target_tid) { + for(task_id tid = number_of_deleted_tasks.load(); tid < target_tid; ++tid) { + data[tid % N].reset(); + } + number_of_deleted_tasks += target_tid - number_of_deleted_tasks.load(); + } + + void clear() { + for(auto&& d : data) { + d.reset(); + } + } + + class task_buffer_iterator { + unsigned long id; + const task_ring_buffer& buffer; + + public: + task_buffer_iterator(unsigned long id, const task_ring_buffer& buffer) : id(id), buffer(buffer) {} + task* operator*() { return buffer.get_task(id); } + void operator++() { id++; } + bool operator<(task_buffer_iterator other) { return id < other.id; } + bool operator!=(task_buffer_iterator other) { return &buffer != &other.buffer || id != other.id; } + }; + + task_buffer_iterator begin() const { return task_buffer_iterator(number_of_deleted_tasks, *this); } + task_buffer_iterator end() const { return task_buffer_iterator(next_task_id, *this); } + + private: + task_id next_task_id = 0; + std::atomic number_of_deleted_tasks = 0; + std::array, N> data; + + void wait_for_available_slot() const { + while(next_task_id - number_of_deleted_tasks >= N) + ; // busy wait until we have available slots + } +}; + +} // namespace celerity::detail diff --git a/src/print_graph.cc b/src/print_graph.cc index dda556f17..8786117ed 100644 --- a/src/print_graph.cc +++ b/src/print_graph.cc @@ -36,13 +36,11 @@ namespace detail { } } - std::string print_task_graph(const std::unordered_map>& tdag) { + std::string print_task_graph(const task_ring_buffer& tdag) { std::ostringstream ss; ss << "digraph G { label=\"Task Graph\" "; - for(auto& it : tdag) { - const auto tsk = it.second.get(); - + for(auto tsk : tdag) { std::unordered_map props; props["label"] = "\"" + get_task_label(tsk) + "\""; diff --git a/src/task_manager.cc b/src/task_manager.cc index 58157c5f8..e9e7fea55 100644 --- a/src/task_manager.cc +++ b/src/task_manager.cc @@ -9,7 +9,9 @@ namespace detail { task_manager::task_manager(size_t num_collective_nodes, host_queue* queue, reduction_manager* reduction_mgr) : num_collective_nodes(num_collective_nodes), queue(queue), reduction_mngr(reduction_mgr) { // We manually generate the initial epoch task, which we treat as if it has been reached immediately. - task_map.emplace(initial_epoch_task, task::make_epoch(initial_epoch_task, epoch_action::none)); + auto reserved_tid = task_buffer.reserve_new_tid(); + assert(initial_epoch_task == reserved_tid); + task_buffer.emplace(initial_epoch_task, task::make_epoch(initial_epoch_task, epoch_action::none)); } void task_manager::add_buffer(buffer_id bid, const cl::sycl::range<3>& range, bool host_initialized) { @@ -18,28 +20,17 @@ namespace detail { if(host_initialized) { buffers_last_writers.at(bid).update_region(subrange_to_grid_box(subrange<3>({}, range)), epoch_for_new_tasks); } } - // Note that we assume tasks are not modified after their initial creation, which is why - // we don't need to worry about thread-safety after returning the task pointer. - const task* task_manager::find_task(const task_id tid) const { - const std::lock_guard lock{task_mutex}; - if(const auto it = task_map.find(tid); it != task_map.end()) { - return it->second.get(); - } else { - return nullptr; - } - } + const task* task_manager::find_task(task_id tid) const { return task_buffer.find_task(tid); } - bool task_manager::has_task(const task_id tid) const { return find_task(tid) != nullptr; } + bool task_manager::has_task(task_id tid) const { return task_buffer.has_task(tid); } - const task* task_manager::get_task(const task_id tid) const { - const auto tsk = find_task(tid); - assert(tsk != nullptr); - return tsk; - } + // Note that we assume tasks are not modified after their initial creation, which is why + // we don't need to worry about thread-safety after returning the task pointer. + const task* task_manager::get_task(task_id tid) const { return task_buffer.get_task(tid); } std::optional task_manager::print_graph(size_t max_nodes) const { std::lock_guard lock(task_mutex); - if(task_map.size() <= max_nodes) { return detail::print_task_graph(task_map); } + if(task_buffer.get_current_task_count() <= max_nodes) { return detail::print_task_graph(task_buffer); } return std::nullopt; } @@ -47,13 +38,14 @@ namespace detail { // This method is called from the executor thread, but does not lock task_mutex to avoid lock-step execution with the main thread. // latest_horizon_reached does not need synchronization (see definition), all other accesses are implicitly synchronized. - assert(get_task(horizon_tid)->get_type() == task_type::HORIZON); + assert(task_buffer.get_task(horizon_tid)->get_type() == task_type::HORIZON); assert(!latest_horizon_reached || *latest_horizon_reached < horizon_tid); assert(latest_epoch_reached.get() < horizon_tid); if(latest_horizon_reached) { latest_epoch_reached.set(*latest_horizon_reached); // The next call to submit_command_group() will prune all tasks before the epoch reached } + latest_horizon_reached = horizon_tid; } @@ -84,7 +76,7 @@ namespace detail { void task_manager::compute_dependencies(task_id tid) { using namespace cl::sycl::access; - const auto& tsk = task_map[tid]; + task* tsk = task_buffer.get_task(tid); const auto& access_map = tsk->get_buffer_access_map(); auto buffers = access_map.get_accessed_buffers(); @@ -112,7 +104,7 @@ namespace detail { // Determine reader dependencies if(std::any_of(modes.cbegin(), modes.cend(), detail::access::mode_traits::is_consumer) || (reduction.has_value() && reduction->initialize_from_buffer)) { - auto read_requirements = get_requirements(tsk.get(), bid, {detail::access::consumer_modes.cbegin(), detail::access::consumer_modes.cend()}); + auto read_requirements = get_requirements(tsk, bid, {detail::access::consumer_modes.cbegin(), detail::access::consumer_modes.cend()}); if(reduction.has_value()) { read_requirements = GridRegion<3>::merge(read_requirements, GridRegion<3>{{1, 1, 1}}); } const auto last_writers = buffers_last_writers.at(bid).get_region_values(read_requirements); @@ -121,27 +113,27 @@ namespace detail { // A valid use case (i.e., not reading garbage) for this is when the buffer has been initialized using a host pointer. if(p.second == std::nullopt) continue; const task_id last_writer = *p.second; - assert(task_map.count(last_writer) == 1); - add_dependency(tsk.get(), task_map[last_writer].get(), dependency_kind::TRUE_DEP, dependency_origin::dataflow); + assert(task_buffer.has_task(last_writer)); + add_dependency(tsk, task_buffer.get_task(last_writer), dependency_kind::TRUE_DEP, dependency_origin::dataflow); } } // Update last writers and determine anti-dependencies if(std::any_of(modes.cbegin(), modes.cend(), detail::access::mode_traits::is_producer) || reduction.has_value()) { - auto write_requirements = get_requirements(tsk.get(), bid, {detail::access::producer_modes.cbegin(), detail::access::producer_modes.cend()}); + auto write_requirements = get_requirements(tsk, bid, {detail::access::producer_modes.cbegin(), detail::access::producer_modes.cend()}); if(reduction.has_value()) { write_requirements = GridRegion<3>::merge(write_requirements, GridRegion<3>{{1, 1, 1}}); } if(write_requirements.empty()) continue; const auto last_writers = buffers_last_writers.at(bid).get_region_values(write_requirements); for(auto& p : last_writers) { if(p.second == std::nullopt) continue; - assert(task_map.count(*p.second) == 1); - auto& last_writer = *task_map[*p.second]; + assert(task_buffer.has_task(*p.second)); + task* last_writer = task_buffer.get_task(*p.second); // Determine anti-dependencies by looking at all the dependents of the last writing task bool has_anti_dependents = false; - for(auto dependent : last_writer.get_dependents()) { + for(auto dependent : last_writer->get_dependents()) { if(dependent.node->get_id() == tid) { // This can happen // - if a task writes to two or more buffers with the same last writer @@ -152,7 +144,7 @@ namespace detail { get_requirements(dependent.node, bid, {detail::access::consumer_modes.cbegin(), detail::access::consumer_modes.cend()}); // Only add an anti-dependency if we are really writing over the region read by this task if(!GridRegion<3>::intersect(write_requirements, dependent_read_requirements).empty()) { - add_dependency(tsk.get(), dependent.node, dependency_kind::ANTI_DEP, dependency_origin::dataflow); + add_dependency(tsk, dependent.node, dependency_kind::ANTI_DEP, dependency_origin::dataflow); has_anti_dependents = true; } } @@ -163,7 +155,7 @@ namespace detail { // While it might not always make total sense to have anti-dependencies between (pure) producers without an // intermediate consumer, we at least have a defined behavior, and the thus enforced ordering of tasks // likely reflects what the user expects. - add_dependency(tsk.get(), &last_writer, dependency_kind::ANTI_DEP, dependency_origin::dataflow); + add_dependency(tsk, last_writer, dependency_kind::ANTI_DEP, dependency_origin::dataflow); } } @@ -174,14 +166,14 @@ namespace detail { for(const auto& side_effect : tsk->get_side_effect_map()) { const auto [hoid, order] = side_effect; if(const auto last_effect = host_object_last_effects.find(hoid); last_effect != host_object_last_effects.end()) { - add_dependency(tsk.get(), task_map.at(last_effect->second).get(), dependency_kind::TRUE_DEP, dependency_origin::dataflow); + add_dependency(tsk, task_buffer.get_task(last_effect->second), dependency_kind::TRUE_DEP, dependency_origin::dataflow); } host_object_last_effects.insert_or_assign(hoid, tid); } if(auto cgid = tsk->get_collective_group_id(); cgid != 0) { if(auto prev = last_collective_tasks.find(cgid); prev != last_collective_tasks.end()) { - add_dependency(tsk.get(), task_map.at(prev->second).get(), dependency_kind::TRUE_DEP, dependency_origin::collective_group_serialization); + add_dependency(tsk, task_buffer.get_task(prev->second), dependency_kind::TRUE_DEP, dependency_origin::collective_group_serialization); last_collective_tasks.erase(prev); } last_collective_tasks.emplace(cgid, tid); @@ -190,14 +182,14 @@ namespace detail { // Tasks without any other true-dependency must depend on the last epoch to ensure they cannot be re-ordered before the epoch if(const auto deps = tsk->get_dependencies(); std::none_of(deps.begin(), deps.end(), [](const task::dependency d) { return d.kind == dependency_kind::TRUE_DEP; })) { - add_dependency(tsk.get(), task_map.at(epoch_for_new_tasks).get(), dependency_kind::TRUE_DEP, dependency_origin::last_epoch); + add_dependency(tsk, task_buffer.get_task(epoch_for_new_tasks), dependency_kind::TRUE_DEP, dependency_origin::last_epoch); } } task& task_manager::register_task_internal(std::unique_ptr task) { auto& task_ref = *task; assert(task != nullptr); - task_map.emplace(task->get_id(), std::move(task)); + task_buffer.emplace(task->get_id(), std::move(task)); execution_front.insert(&task_ref); return task_ref; } @@ -246,10 +238,9 @@ namespace detail { task_id task_manager::generate_horizon_task() { // we are probably overzealous in locking here - task_id tid; + task_id tid = task_buffer.reserve_new_tid(); { std::lock_guard lock(task_mutex); - tid = get_new_tid(); current_horizon_critical_path_length = max_pseudo_critical_path_length; const auto previous_horizon = current_horizon; current_horizon = reduce_execution_front(task::make_horizon_task(tid)); @@ -263,10 +254,9 @@ namespace detail { task_id task_manager::generate_epoch_task(epoch_action action) { // we are probably overzealous in locking here - task_id tid; + task_id tid = task_buffer.reserve_new_tid(); { std::lock_guard lock(task_mutex); - tid = get_new_tid(); const auto new_epoch = reduce_execution_front(task::make_epoch(tid, action)); compute_dependencies(new_epoch); set_epoch_for_new_tasks(new_epoch); @@ -279,19 +269,5 @@ namespace detail { return tid; } - void task_manager::prune_tasks_before_latest_epoch_reached() { - const auto prune_before = latest_epoch_reached.get(); - if(prune_before > last_pruned_before) { - for(auto iter = task_map.begin(); iter != task_map.end();) { - if(iter->first < prune_before) { - iter = task_map.erase(iter); - } else { - ++iter; - } - } - } - last_pruned_before = prune_before; - } - } // namespace detail } // namespace celerity diff --git a/test/test_utils.h b/test/test_utils.h index 6e7a70fad..e8ee1ef16 100644 --- a/test/test_utils.h +++ b/test/test_utils.h @@ -45,7 +45,7 @@ namespace detail { static int get_num_horizons(task_manager& tm) { int horizon_counter = 0; - for(auto& [_, task_ptr] : tm.task_map) { + for(auto task_ptr : tm.task_buffer) { if(task_ptr->get_type() == task_type::HORIZON) { horizon_counter++; } } return horizon_counter; From c5d78e8cb3b5a32b9a60a505332f0bdd10407f5e Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Fri, 1 Apr 2022 12:19:11 +0200 Subject: [PATCH 3/8] More elegant and correct task_ring_buffer::has_task implementation --- include/task_ring_buffer.h | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h index 6e8fb69e1..cc172a337 100644 --- a/include/task_ring_buffer.h +++ b/include/task_ring_buffer.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include "task.h" @@ -13,14 +14,11 @@ constexpr unsigned long task_ringbuffer_size = 1024; template class task_ring_buffer { public: - size_t get_total_task_count() const { return next_task_id; } - size_t get_current_task_count() const { return next_task_id - number_of_deleted_tasks; } + size_t get_total_task_count() const { return next_active_tid.load(); } + size_t get_current_task_count() const { return next_active_tid.load() - number_of_deleted_tasks; } bool has_task(task_id tid) const { - // the nullptr check is necessary if the executor is waiting for a task to be available when its ID has been reserved - // but it has not been emplaced yet; This is safe since deletion always resets the unique_ptrs strictly prior - // to new reservations being possible - return tid >= number_of_deleted_tasks && tid < next_task_id && data[tid % N].get() != nullptr; + return tid >= number_of_deleted_tasks && tid < next_active_tid.load(); // } task* find_task(task_id tid) const { return has_task(tid) ? data[tid % N].get() : nullptr; } @@ -39,7 +37,10 @@ class task_ring_buffer { // task_id must have been reserved previously void emplace(task_id tid, std::unique_ptr task) { - data[tid % N] = std::move(task); // + task_id expected_tid = tid; + bool successfully_updated = next_active_tid.compare_exchange_strong(expected_tid, next_active_tid.load() + 1); + assert(successfully_updated); // this is the only allowed (and extant) pattern + data[tid % N] = std::move(task); } // may only be called by one thread @@ -72,7 +73,11 @@ class task_ring_buffer { task_buffer_iterator end() const { return task_buffer_iterator(next_task_id, *this); } private: + // the id of the next task that will be reserved task_id next_task_id = 0; + // the next task id that will actually be emplaced + std::atomic next_active_tid = task_id(0); + // the number of deleted tasks (which is implicitly the start of the active range of the ringbuffer) std::atomic number_of_deleted_tasks = 0; std::array, N> data; From 162f990700a8035d392d3346fce537a0e3742e68 Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Tue, 17 May 2022 10:38:45 +0200 Subject: [PATCH 4/8] Allow revoking reserved tids, add exception handler to do so --- include/task_manager.h | 8 ++++++-- include/task_ring_buffer.h | 5 +++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/include/task_manager.h b/include/task_manager.h index c5ed32a73..096968d37 100644 --- a/include/task_manager.h +++ b/include/task_manager.h @@ -70,8 +70,12 @@ namespace detail { tid = task_buffer.reserve_new_tid(); prepass_handler cgh(tid, std::make_unique>(cgf), num_collective_nodes); - cgf(cgh); - + try { + cgf(cgh); + } catch(...) { + task_buffer.revoke_reservation(tid); + throw; + } task& task_ref = register_task_internal(std::move(cgh).into_task()); compute_dependencies(tid); diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h index cc172a337..ad53b28e1 100644 --- a/include/task_ring_buffer.h +++ b/include/task_ring_buffer.h @@ -35,6 +35,11 @@ class task_ring_buffer { return ret; } + void revoke_reservation(task_id tid) { + assert(tid == next_task_id - 1); // this is the only allowed (and extant) pattern + next_task_id--; + } + // task_id must have been reserved previously void emplace(task_id tid, std::unique_ptr task) { task_id expected_tid = tid; From 02e8a0b4792d96dee9c0490b0a2706b669d47f56 Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Tue, 17 May 2022 16:21:32 +0200 Subject: [PATCH 5/8] Use RAII for task buffer reservation slot management --- include/print_graph.h | 2 +- include/task_manager.h | 22 ++++++------- include/task_ring_buffer.h | 63 ++++++++++++++++++++++++++++---------- src/print_graph.cc | 2 +- src/task_manager.cc | 25 ++++++++------- 5 files changed, 72 insertions(+), 42 deletions(-) diff --git a/include/print_graph.h b/include/print_graph.h index ff37a6892..4023e2224 100644 --- a/include/print_graph.h +++ b/include/print_graph.h @@ -12,7 +12,7 @@ namespace detail { class command_graph; class task_manager; - std::string print_task_graph(const task_ring_buffer& tdag); + std::string print_task_graph(const task_ring_buffer& tdag); std::string print_command_graph(const command_graph& cdag, const task_manager& tm); } // namespace detail diff --git a/include/task_manager.h b/include/task_manager.h index 096968d37..e6111f39d 100644 --- a/include/task_manager.h +++ b/include/task_manager.h @@ -67,16 +67,12 @@ namespace detail { task_id tid; { std::lock_guard lock(task_mutex); - tid = task_buffer.reserve_new_tid(); + auto reservation = task_buffer.reserve_task_entry(); + tid = reservation.get_tid(); prepass_handler cgh(tid, std::make_unique>(cgf), num_collective_nodes); - try { - cgf(cgh); - } catch(...) { - task_buffer.revoke_reservation(tid); - throw; - } - task& task_ref = register_task_internal(std::move(cgh).into_task()); + cgf(cgh); + task& task_ref = register_task_internal(reservation, std::move(cgh).into_task()); compute_dependencies(tid); if(queue) queue->require_collective_group(task_ref.get_collective_group_id()); @@ -159,12 +155,12 @@ namespace detail { * Returns the number of tasks created during the lifetime of the task_manager, * including tasks that have already been deleted. */ - int get_total_task_count() const { return task_buffer.get_total_task_count(); } + size_t get_total_task_count() const { return task_buffer.get_total_task_count(); } /** * Returns the number of tasks currently being managed by the task_manager. */ - int get_current_task_count() const { return task_buffer.get_current_task_count(); } + size_t get_current_task_count() const { return task_buffer.get_current_task_count(); } private: const size_t num_collective_nodes; @@ -173,7 +169,7 @@ namespace detail { reduction_manager* reduction_mngr; task_id next_task_id = 1; - task_ring_buffer task_buffer; + task_ring_buffer task_buffer; // The active epoch is used as the last writer for host-initialized buffers. // This is useful so we can correctly generate anti-dependencies onto tasks that read host-initialized buffers. @@ -215,7 +211,7 @@ namespace detail { // Set of tasks with no dependents std::unordered_set execution_front; - task& register_task_internal(std::unique_ptr task); + task& register_task_internal(task_ring_buffer::reservation& reserve, std::unique_ptr task); void invoke_callbacks(task_id tid); @@ -225,7 +221,7 @@ namespace detail { int get_max_pseudo_critical_path_length() const { return max_pseudo_critical_path_length; } - task_id reduce_execution_front(std::unique_ptr new_front); + task_id reduce_execution_front(task_ring_buffer::reservation& reserve, std::unique_ptr new_front); void set_epoch_for_new_tasks(task_id epoch); diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h index ad53b28e1..e673a4807 100644 --- a/include/task_ring_buffer.h +++ b/include/task_ring_buffer.h @@ -4,6 +4,7 @@ #include #include +#include "log.h" #include "task.h" #include "types.h" @@ -11,9 +12,38 @@ namespace celerity::detail { constexpr unsigned long task_ringbuffer_size = 1024; -template class task_ring_buffer { public: + // This is an RAII type for ensuring correct handling of task id reservations + // in the presence of exceptions (i.e. revoking the reservation on stack unwinding) + class reservation { + friend class task_ring_buffer; + + public: + reservation(task_id tid, task_ring_buffer& buffer) : tid(tid), buffer(buffer) {} + ~reservation() { + if(!consumed) { + CELERITY_WARN("Consumed reservation for tid {} in destructor", tid); + buffer.revoke_reservation(*this); + } + } + reservation(const reservation&) = delete; // non copyable + reservation& operator=(const reservation&) = delete; // non assignable + reservation(reservation&&) = default; // movable + + task_id get_tid() const { return tid; } + + private: + void consume() { + assert(consumed == false); + consumed = true; + } + + bool consumed = false; + task_id tid; + task_ring_buffer& buffer; + }; + size_t get_total_task_count() const { return next_active_tid.load(); } size_t get_current_task_count() const { return next_active_tid.load() - number_of_deleted_tasks; } @@ -21,37 +51,38 @@ class task_ring_buffer { return tid >= number_of_deleted_tasks && tid < next_active_tid.load(); // } - task* find_task(task_id tid) const { return has_task(tid) ? data[tid % N].get() : nullptr; } + task* find_task(task_id tid) const { return has_task(tid) ? data[tid % task_ringbuffer_size].get() : nullptr; } task* get_task(task_id tid) const { assert(has_task(tid)); - return data[tid % N].get(); + return data[tid % task_ringbuffer_size].get(); } - task_id reserve_new_tid() { + reservation reserve_task_entry() { wait_for_available_slot(); - auto ret = next_task_id; + reservation ret(next_task_id, *this); next_task_id++; return ret; } - void revoke_reservation(task_id tid) { - assert(tid == next_task_id - 1); // this is the only allowed (and extant) pattern + void revoke_reservation(reservation& reserve) { + reserve.consume(); + assert(reserve.tid == next_task_id - 1); // this is the only allowed (and extant) pattern next_task_id--; } - // task_id must have been reserved previously - void emplace(task_id tid, std::unique_ptr task) { - task_id expected_tid = tid; - bool successfully_updated = next_active_tid.compare_exchange_strong(expected_tid, next_active_tid.load() + 1); + void put(reservation& reserve, std::unique_ptr task) { + reserve.consume(); + task_id expected_tid = reserve.tid; + [[maybe_unused]] bool successfully_updated = next_active_tid.compare_exchange_strong(expected_tid, next_active_tid.load() + 1); assert(successfully_updated); // this is the only allowed (and extant) pattern - data[tid % N] = std::move(task); + data[reserve.tid % task_ringbuffer_size] = std::move(task); } // may only be called by one thread void delete_up_to(task_id target_tid) { for(task_id tid = number_of_deleted_tasks.load(); tid < target_tid; ++tid) { - data[tid % N].reset(); + data[tid % task_ringbuffer_size].reset(); } number_of_deleted_tasks += target_tid - number_of_deleted_tasks.load(); } @@ -84,11 +115,11 @@ class task_ring_buffer { std::atomic next_active_tid = task_id(0); // the number of deleted tasks (which is implicitly the start of the active range of the ringbuffer) std::atomic number_of_deleted_tasks = 0; - std::array, N> data; + std::array, task_ringbuffer_size> data; void wait_for_available_slot() const { - while(next_task_id - number_of_deleted_tasks >= N) - ; // busy wait until we have available slots + while(next_task_id - number_of_deleted_tasks >= task_ringbuffer_size) + std::this_thread::yield(); // busy wait until we have available slots } }; diff --git a/src/print_graph.cc b/src/print_graph.cc index 8786117ed..259d5ffc2 100644 --- a/src/print_graph.cc +++ b/src/print_graph.cc @@ -36,7 +36,7 @@ namespace detail { } } - std::string print_task_graph(const task_ring_buffer& tdag) { + std::string print_task_graph(const task_ring_buffer& tdag) { std::ostringstream ss; ss << "digraph G { label=\"Task Graph\" "; diff --git a/src/task_manager.cc b/src/task_manager.cc index e9e7fea55..0a719c7e3 100644 --- a/src/task_manager.cc +++ b/src/task_manager.cc @@ -9,9 +9,8 @@ namespace detail { task_manager::task_manager(size_t num_collective_nodes, host_queue* queue, reduction_manager* reduction_mgr) : num_collective_nodes(num_collective_nodes), queue(queue), reduction_mngr(reduction_mgr) { // We manually generate the initial epoch task, which we treat as if it has been reached immediately. - auto reserved_tid = task_buffer.reserve_new_tid(); - assert(initial_epoch_task == reserved_tid); - task_buffer.emplace(initial_epoch_task, task::make_epoch(initial_epoch_task, epoch_action::none)); + auto reserve = task_buffer.reserve_task_entry(); + task_buffer.put(reserve, task::make_epoch(initial_epoch_task, epoch_action::none)); } void task_manager::add_buffer(buffer_id bid, const cl::sycl::range<3>& range, bool host_initialized) { @@ -186,10 +185,10 @@ namespace detail { } } - task& task_manager::register_task_internal(std::unique_ptr task) { + task& task_manager::register_task_internal(task_ring_buffer::reservation& reserve, std::unique_ptr task) { auto& task_ref = *task; assert(task != nullptr); - task_buffer.emplace(task->get_id(), std::move(task)); + task_buffer.put(reserve, std::move(task)); execution_front.insert(&task_ref); return task_ref; } @@ -208,14 +207,14 @@ namespace detail { max_pseudo_critical_path_length = std::max(max_pseudo_critical_path_length, depender->get_pseudo_critical_path_length()); } - task_id task_manager::reduce_execution_front(std::unique_ptr new_front) { + task_id task_manager::reduce_execution_front(task_ring_buffer::reservation& reserve, std::unique_ptr new_front) { // add dependencies from a copy of the front to this task const auto current_front = execution_front; for(task* front_task : current_front) { add_dependency(new_front.get(), front_task, dependency_kind::TRUE_DEP, dependency_origin::execution_front); } assert(execution_front.empty()); - return register_task_internal(std::move(new_front)).get_id(); + return register_task_internal(reserve, std::move(new_front)).get_id(); } void task_manager::set_epoch_for_new_tasks(const task_id epoch) { @@ -238,12 +237,14 @@ namespace detail { task_id task_manager::generate_horizon_task() { // we are probably overzealous in locking here - task_id tid = task_buffer.reserve_new_tid(); + task_id tid; { + auto reserve = task_buffer.reserve_task_entry(); + tid = reserve.get_tid(); std::lock_guard lock(task_mutex); current_horizon_critical_path_length = max_pseudo_critical_path_length; const auto previous_horizon = current_horizon; - current_horizon = reduce_execution_front(task::make_horizon_task(tid)); + current_horizon = reduce_execution_front(reserve, task::make_horizon_task(tid)); if(previous_horizon) { set_epoch_for_new_tasks(*previous_horizon); } } @@ -254,10 +255,12 @@ namespace detail { task_id task_manager::generate_epoch_task(epoch_action action) { // we are probably overzealous in locking here - task_id tid = task_buffer.reserve_new_tid(); + task_id tid; { + auto reserve = task_buffer.reserve_task_entry(); + tid = reserve.get_tid(); std::lock_guard lock(task_mutex); - const auto new_epoch = reduce_execution_front(task::make_epoch(tid, action)); + const auto new_epoch = reduce_execution_front(reserve, task::make_epoch(tid, action)); compute_dependencies(new_epoch); set_epoch_for_new_tasks(new_epoch); current_horizon = std::nullopt; // this horizon is now behind the epoch_for_new_tasks, so it will never become an epoch itself From 99c51058399cc3d1136b070a1310b98405682128 Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Thu, 19 May 2022 13:34:58 +0200 Subject: [PATCH 6/8] Update benchmark results for post-ringbuffer --- ci/perf/gpuc2_bench.csv | 170 +++++++++++++++++------------------ ci/perf/gpuc2_bench.md | 176 +++++++++++++++++++------------------ include/task_ring_buffer.h | 1 + 3 files changed, 176 insertions(+), 171 deletions(-) diff --git a/ci/perf/gpuc2_bench.csv b/ci/perf/gpuc2_bench.csv index e0a288de0..2d56fa89d 100644 --- a/ci/perf/gpuc2_bench.csv +++ b/ci/perf/gpuc2_bench.csv @@ -1,85 +1,87 @@ test case,benchmark name,samples,iterations,estimated,mean,low mean,high mean,std dev,low std dev,high std dev,raw -benchmark intrusive graph dependency handling with N nodes - 1,creating nodes,100,5513,2205200,4.7789,4.7478,4.8095,0.1568,0.1415,0.1824,"4.8611,4.9191,4.9300,4.9374,4.9519,4.5048,4.5576,4.6465,4.6847,4.7593,4.7901,4.8538,4.8738,4.9320,4.9427,4.9501,4.5084,4.5612,4.6503,4.6884,4.7629,4.7938,4.8574,4.8756,4.9336,4.9465,4.9519,4.5102,4.5630,4.6501,4.6902,4.7666,4.7938,4.8591,4.8774,4.9338,4.9465,4.9499,4.5121,4.5629,4.6519,4.9501,4.7393,4.7700,4.8373,4.8592,4.9173,4.9320,4.9519,4.4976,4.5521,4.6410,4.6811,4.7557,4.7847,4.8502,4.8719,4.9282,4.9410,4.9501,4.5066,4.9501,4.6102,4.6521,4.7301,4.7629,4.8300,4.8518,4.9120,4.9245,4.9519,4.4939,4.5467,4.6374,4.6757,4.7520,4.7829,4.8484,4.8699,4.9245,4.9392,4.9501,4.5048,5.2699,4.5812,4.6229,4.7174,4.7373,4.8065,4.8320,4.8919,4.9100,4.9554,4.4758,4.5340,4.6247,4.6666,4.7446,4.7736,4.8393" -benchmark intrusive graph dependency handling with N nodes - 1,creating and adding dependencies,100,1005,2412000,24.2233,24.2127,24.2387,0.0638,0.0479,0.1092,"24.1642,24.1731,24.6318,24.2338,24.1532,24.1930,24.1632,24.1532,24.1731,24.2428,24.2338,24.1532,24.1831,24.1532,24.1532,24.2627,24.2736,24.2527,24.1532,24.1632,24.2826,24.1731,24.2637,24.2726,24.2726,24.1532,24.1940,24.1632,24.2726,24.1831,24.2627,24.2139,24.2428,24.2328,24.2229,24.2637,24.1731,24.2627,24.3025,24.2736,24.2328,24.1532,24.2030,24.2627,24.1532,24.1831,24.2328,24.2527,24.1831,24.2836,24.1532,24.2527,24.2229,24.1532,24.2229,24.2726,24.2726,24.1930,24.1532,24.1731,24.1940,24.3025,24.2726,24.2736,24.3025,24.1930,24.2527,24.2139,24.2229,24.2428,24.1930,24.1632,24.2736,24.2030,24.1532,24.1831,24.1831,24.3134,24.2726,24.1632,24.2726,24.2030,24.1841,24.1731,24.2726,24.3025,24.2637,24.2428,24.2030,24.2826,24.1532,24.2726,24.2925,24.2627,24.2438,24.1532,24.1930,24.1930,24.2826,24.1532" -benchmark intrusive graph dependency handling with N nodes - 1,adding and removing dependencies,100,1187,2374000,20.5361,20.5338,20.5393,0.0137,0.0106,0.0226,"20.5257,20.5510,20.6192,20.5257,20.5510,20.5350,20.5510,20.5257,20.5518,20.5257,20.5257,20.5510,20.5265,20.5425,20.5257,20.5257,20.5518,20.5257,20.5425,20.5265,20.5510,20.5257,20.5257,20.5434,20.5257,20.5425,20.5257,20.5434,20.5257,20.5257,20.5518,20.5257,20.5425,20.5257,20.5265,20.5510,20.5257,20.5510,20.5257,20.5425,20.5257,20.5257,20.5510,20.5257,20.5510,20.5265,20.5425,20.5257,20.5257,20.5518,20.5257,20.5425,20.5257,20.5257,20.5425,20.5257,20.5518,20.5257,20.5510,20.5257,20.5265,20.5425,20.5257,20.5425,20.5257,20.5425,20.5257,20.5350,20.5510,20.5257,20.5510,20.5265,20.5257,20.5510,20.5341,20.5510,20.5257,20.5510,20.5265,20.5257,20.5425,20.5257,20.5434,20.5257,20.5425,20.5257,20.5257,20.5425,20.5257,20.5434,20.5257,20.5257,20.5510,20.5265,20.5510,20.5257,20.5510,20.5257,20.5257,20.5425" -benchmark intrusive graph dependency handling with N nodes - 1,checking for dependencies,100,10075,2015000,2.4238,2.4194,2.4432,0.0406,0.0053,0.0962,"2.4143,2.4262,2.4153,2.4262,2.4144,2.4262,2.4153,2.4153,2.4253,2.4153,2.4252,2.4143,2.4262,2.4153,2.4252,2.4154,2.4153,2.4252,2.4153,2.4253,2.4153,2.4252,2.4154,2.4262,2.4153,2.4143,2.4253,2.4153,2.4252,2.4153,2.4252,2.4153,2.4262,2.4154,2.4153,2.4252,2.4143,2.8240,2.4154,2.4431,2.4153,2.4252,2.4143,2.4153,2.4253,2.4153,2.4252,2.4153,2.4263,2.4153,2.4252,2.4154,2.4153,2.4252,2.4153,2.4263,2.4143,2.4252,2.4153,2.4262,2.4153,2.4153,2.4253,2.4153,2.4252,2.4153,2.4253,2.4153,2.4252,2.4154,2.4143,2.4252,2.4143,2.4253,2.4143,2.4252,2.4143,2.4262,2.4143,2.4252,2.4144,2.4153,2.4252,2.4153,2.4253,2.4143,2.4252,2.4154,2.4153,2.4262,2.4143,2.4253,2.4153,2.4143,2.4252,2.4153,2.4252,2.4153,2.4253,2.4153" -benchmark intrusive graph dependency handling with N nodes - 10,creating nodes,100,604,2416000,30.4345,30.4327,30.4391,0.0139,0.0070,0.0289,"30.4354,30.4189,30.5513,30.4520,30.4354,30.4354,30.4354,30.4354,30.4354,30.4189,30.4338,30.4503,30.4354,30.4354,30.4354,30.4354,30.4354,30.4189,30.4354,30.4354,30.4354,30.4354,30.4338,30.4338,30.4354,30.4354,30.4189,30.4354,30.4189,30.4189,30.4354,30.4354,30.4354,30.4354,30.4172,30.4354,30.4189,30.4354,30.4354,30.4354,30.4354,30.4354,30.4189,30.4354,30.4354,30.4338,30.4338,30.4189,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354,30.4189,30.4354,30.4354,30.4338,30.4338,30.4189,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354,30.4338,30.4354,30.4189,30.4354,30.4354,30.4354,30.4520,30.4354,30.4354,30.4354,30.4189,30.4338,30.4338,30.4354,30.4520,30.4354,30.4354,30.4189,30.4354,30.4354,30.4354,30.4354,30.4520,30.4338,30.4172,30.4354,30.4354,30.4354,30.4354,30.4354,30.4354" -benchmark intrusive graph dependency handling with N nodes - 10,creating and adding dependencies,100,87,2453400,287.7179,287.2355,289.4683,4.2031,1.1281,9.7114,"285.3448,286.0345,291.7931,287.6552,288.5632,287.6552,288.3333,287.1954,287.9885,288.4598,286.0345,287.3103,287.7586,288.4598,287.1839,288.8046,287.5287,287.8851,288.4598,287.7586,288.4598,287.2989,288.3448,287.5287,287.7701,287.1839,287.5402,288.5632,287.6552,288.6897,287.4138,288.0000,286.6092,287.7586,288.5632,287.4253,288.6782,287.5402,327.8391,287.6437,287.6552,288.4483,287.6437,288.3448,287.2989,288.9195,285.8046,288.1149,287.9885,287.8851,288.5632,287.5402,288.4483,287.5287,287.9885,288.4483,287.8851,288.5632,286.7356,288.4483,286.0460,287.8736,288.4598,287.7586,288.5747,287.7586,288.6782,287.5402,287.6437,288.4598,287.6437,288.2299,287.6437,287.6552,285.1149,286.0345,285.4598,285.3563,286.3793,285.8046,286.3793,285.1149,286.1609,286.2644,285.3448,286.1494,285.3448,286.7356,286.3793,286.0345,285.3448,285.3563,286.2644,285.6897,286.2644,285.3448,286.0460,285.1149,285.3448,286.0345" -benchmark intrusive graph dependency handling with N nodes - 10,adding and removing dependencies,100,99,2455200,245.9928,244.9843,250.7780,9.6927,0.5642,23.0928,"243.9798,245.7980,342.2525,242.8586,245.2929,245.1919,245.8081,245.1919,245.7980,245.1919,245.7980,245.1919,245.7980,245.1919,245.7980,245.1919,245.1919,246.0000,245.1919,244.7879,244.7879,244.9899,244.4848,245.3939,244.2828,245.5960,243.9798,245.2929,244.5859,245.1919,245.8081,245.2929,245.0909,244.5859,245.2929,244.3838,245.8990,245.1919,245.7980,243.7778,245.1919,244.7879,244.9899,244.9899,244.6869,245.0909,244.3838,245.7980,245.1919,245.8081,243.7677,245.1919,244.6768,244.9899,244.7879,244.7879,245.0909,244.4848,245.3939,244.1818,245.7980,245.2929,245.1919,244.3838,245.0909,245.7980,245.1919,244.9899,244.5859,245.3939,244.2828,245.4949,243.9798,245.7980,245.1919,245.2929,244.6869,244.8889,244.8889,244.6869,245.1919,244.3838,245.4949,244.0808,245.6970,243.8788,245.2929,245.7980,245.1919,244.8889,244.6869,245.1919,244.5859,245.1919,244.2828,245.4949,244.0808,245.6970,244.0808,245.6970" -benchmark intrusive graph dependency handling with N nodes - 10,checking for dependencies,100,779,2414900,30.6439,30.5766,30.7445,0.4146,0.3131,0.5641,"30.5430,30.4275,32.6662,30.5558,30.4403,30.5687,30.6714,30.6714,30.7869,30.6727,30.6842,30.6855,30.5430,30.6714,30.4275,30.5430,30.4403,30.5700,30.4403,31.6483,30.5558,30.4275,30.5430,30.4403,30.4403,30.7484,30.4275,31.8549,30.4403,30.5430,30.4390,30.4403,30.5302,30.4403,30.5430,30.4275,30.4403,30.5558,30.4403,30.5430,30.4403,30.4403,30.5558,31.6483,30.5430,30.4403,30.4660,30.5045,30.4275,31.3530,30.4403,30.5430,30.4275,30.4403,30.7112,30.4275,30.6072,30.4403,30.4403,31.7394,30.4275,30.5558,30.4403,30.4275,30.5430,30.4275,30.5430,31.6367,30.5430,30.4275,30.4403,30.5443,30.4403,30.5302,30.4403,31.6367,30.7612,30.4275,30.5430,30.4275,30.5302,30.4403,30.4403,31.8947,30.4403,30.5430,30.4403,30.4275,30.5430,30.4403,30.5430,31.6367,30.4275,30.5430,30.4403,30.5302,30.4403,30.5430,30.4275,31.6367" -benchmark intrusive graph dependency handling with N nodes - 100,creating nodes,100,55,2453000,442.8580,442.2520,445.1245,5.3698,1.1723,12.5307,"442.2545,442.8000,442.2545,444.2545,442.0727,440.2545,444.2727,440.8000,443.5273,441.5273,442.4364,442.2727,440.2364,443.8909,442.2545,444.0727,442.4545,443.8909,440.2545,440.2545,442.2545,441.3455,444.2545,442.2545,442.2545,442.4364,440.4364,442.4364,441.1636,444.0909,440.4364,442.0727,442.9818,441.5273,444.4545,442.4364,442.2545,442.0727,441.8909,443.9091,441.5273,442.0727,440.4364,442.2545,444.0727,441.1636,443.3636,441.7091,442.6182,442.2545,440.4364,442.2545,441.5273,444.4545,442.0727,440.2545,442.2545,494.9091,443.8909,442.2545,445.0000,440.6182,442.4364,442.4364,441.7091,444.2727,441.5273,442.4364,440.4364,442.2545,442.9818,441.5273,444.4545,442.4364,444.0727,440.2545,442.0727,442.8000,441.3455,444.2545,442.2545,442.2727,442.0727,441.7091,443.1636,440.9818,443.8909,442.2545,440.4364,443.3455,442.2545,443.7091,442.2727,442.2545,443.8909,442.2545,444.2727,441.5273,442.4364,440.4364" -benchmark intrusive graph dependency handling with N nodes - 100,creating and adding dependencies,100,6,2897400,4813.6750,4811.4050,4816.5100,12.9383,10.4009,19.4233,"4800.3333,4817.0000,4883.8333,4785.5000,4793.6667,4828.8333,4798.8333,4812.1667,4805.3333,4818.8333,4805.5000,4828.8333,4800.5000,4820.3333,4803.8333,4822.1667,4800.5000,4815.3333,4802.0000,4825.5000,4820.5000,4825.5000,4808.8333,4825.5000,4810.3333,4823.6667,4810.5000,4817.1667,4790.5000,4827.1667,4815.3333,4822.1667,4810.5000,4812.1667,4797.0000,4835.5000,4815.3333,4800.5000,4812.1667,4817.1667,4807.0000,4817.1667,4800.5000,4813.8333,4790.3333,4818.8333,4805.5000,4823.8333,4802.0000,4823.8333,4795.5000,4818.8333,4813.8333,4825.5000,4807.0000,4810.5000,4805.5000,4823.8333,4800.3333,4828.8333,4813.8333,4827.1667,4815.5000,4815.5000,4807.1667,4813.6667,4810.5000,4828.8333,4803.8333,4812.1667,4813.6667,4844.0000,4813.6667,4825.5000,4808.8333,4820.5000,4803.8333,4825.5000,4828.8333,4833.8333,4812.0000,4823.8333,4817.1667,4812.1667,4808.8333,4817.0000,4807.0000,4830.5000,4812.1667,4812.1667,4802.0000,4815.5000,4800.5000,4808.8333,4792.0000,4803.8333,4805.5000,4808.6667,4803.8333,4808.8333" -benchmark intrusive graph dependency handling with N nodes - 100,adding and removing dependencies,100,6,2892600,4886.8617,4874.6383,4906.3000,76.9833,56.5842,129.8395,"4818.6667,4862.3333,5029.1667,5012.5000,5010.8333,5037.6667,5002.5000,4960.6667,4980.8333,4975.8333,5005.8333,4967.3333,5378.1667,5029.3333,4974.0000,4969.1667,4997.5000,4974.0000,4980.8333,5022.5000,4970.8333,4935.6667,4867.1667,4847.3333,4837.1667,4848.8333,4832.1667,4940.6667,4875.6667,4882.1667,4858.8333,4877.1667,4838.8333,4825.5000,4815.5000,4912.3333,4835.5000,4909.0000,4865.5000,4885.6667,4867.1667,4837.1667,4855.5000,4848.8333,4843.8333,4853.8333,4850.5000,4852.3333,4845.5000,4850.5000,4880.6667,4855.5000,4817.1667,4900.5000,4864.0000,4865.5000,4840.5000,4823.8333,4835.5000,4890.6667,4842.1667,4865.5000,4877.1667,4873.8333,4845.5000,4873.8333,4815.5000,4850.5000,4840.5000,4847.1667,4840.5000,4905.5000,4883.8333,4895.6667,4842.1667,4850.5000,4815.5000,4838.8333,4827.1667,4843.8333,4837.1667,4859.0000,4810.3333,4870.6667,4860.5000,4835.5000,4865.6667,4880.5000,4833.8333,4833.8333,4817.1667,4902.3333,4840.5000,4827.1667,4865.5000,4900.6667,4867.3333,4860.5000,4862.1667,4850.5000" -benchmark intrusive graph dependency handling with N nodes - 100,checking for dependencies,100,13,2576600,2007.1215,2002.8262,2022.6169,37.5222,9.4532,86.6790,"2010.6154,2014.4615,1983.6154,1998.2308,1991.3077,1994.4615,2000.5385,1995.9231,1992.0769,1980.5385,1982.8462,1970.5385,1977.4615,1969.6923,1970.5385,2366.6154,1971.3077,2012.8462,2012.0769,2019.8462,2009.0769,2016.6923,2014.4615,2019.8462,2012.1538,2015.1538,2004.4615,2002.8462,2009.8462,2002.8462,2009.0769,2004.3846,2009.8462,2003.6154,2009.0769,2003.6154,2002.9231,2009.7692,2002.9231,2009.7692,2003.6923,2009.0000,2003.6923,2009.0000,1999.8462,2002.0769,1999.7692,1997.5385,2009.7692,2002.9231,2009.0000,2002.9231,2011.3077,2003.6923,2009.0000,2004.4615,2002.0769,2009.0769,2002.0769,2014.4615,2010.5385,2016.6923,2011.3846,2014.4615,2002.8462,2009.0769,2002.0769,1999.0000,2006.7692,1999.0000,2006.0000,1999.0000,2005.1538,1999.8462,2003.6154,1999.0000,1997.4615,2005.1538,1997.5385,2004.3846,1997.4615,2004.4615,1998.2308,2004.3846,1999.7692,1998.2308,2010.6154,2004.3846,2011.3846,2004.3846,2009.0769,2003.6154,2009.8462,2005.1538,2009.0769,2011.3846,2009.7692,2013.6923,2009.0000,2015.9231" -generating large task graphs,soup topology,100,1,1531843100,15269494.6800,15166113.9000,15317941.1000,342973.3932,174405.0090,564919.3594,"15344847.0000,15333906.0000,15309079.0000,13893588.0000,15281577.0000,15307897.0000,15288631.0000,15263963.0000,15266839.0000,15283310.0000,15363101.0000,15343995.0000,15265376.0000,15316033.0000,15259435.0000,15350567.0000,15271267.0000,15387277.0000,15312416.0000,15340208.0000,15316543.0000,15329960.0000,15331401.0000,15306825.0000,15416002.0000,15326181.0000,15396615.0000,15347742.0000,15215412.0000,15325560.0000,15439797.0000,15339607.0000,15401254.0000,15318276.0000,15296125.0000,15389441.0000,15338185.0000,15443553.0000,15323155.0000,15379332.0000,15347511.0000,15329637.0000,15302847.0000,15328366.0000,15267390.0000,15403368.0000,15345438.0000,15301915.0000,15482528.0000,15327143.0000,15313277.0000,15462299.0000,15293049.0000,15365826.0000,15387237.0000,15284292.0000,15305011.0000,15322405.0000,15293429.0000,15262852.0000,15315201.0000,15263153.0000,15352651.0000,15348795.0000,15288029.0000,15396004.0000,14460051.0000,13082613.0000,13327276.0000,15344075.0000,15239217.0000,15279964.0000,15307276.0000,15359995.0000,15298900.0000,15365135.0000,15387427.0000,15359094.0000,15332002.0000,15352160.0000,15343545.0000,15406043.0000,15396234.0000,15400582.0000,15357752.0000,15273892.0000,15300443.0000,15317044.0000,15310963.0000,15264254.0000,15332654.0000,15409139.0000,15394791.0000,15378260.0000,15381937.0000,15402175.0000,15275886.0000,15367510.0000,15314389.0000,15372859.0000" -generating large task graphs,chain topology,100,1,6469500,67493.3100,67396.7100,67818.1200,805.9293,159.7087,1787.2452,"67436.0000,67235.0000,70170.0000,67445.0000,67777.0000,67496.0000,67656.0000,67416.0000,67606.0000,67336.0000,67656.0000,67245.0000,67476.0000,67456.0000,67546.0000,67165.0000,67395.0000,67146.0000,67345.0000,67426.0000,67496.0000,67315.0000,67505.0000,67345.0000,67496.0000,67326.0000,67466.0000,67365.0000,67636.0000,67215.0000,67486.0000,67295.0000,67316.0000,67316.0000,67536.0000,67455.0000,67406.0000,67456.0000,67606.0000,67286.0000,67275.0000,67396.0000,67215.0000,67146.0000,67516.0000,67445.0000,67485.0000,67266.0000,67396.0000,67315.0000,67787.0000,67426.0000,67405.0000,67055.0000,67306.0000,67326.0000,74879.0000,67155.0000,67245.0000,67186.0000,67455.0000,67165.0000,67365.0000,67215.0000,67436.0000,67265.0000,67386.0000,67105.0000,67516.0000,67256.0000,67245.0000,67356.0000,67345.0000,67196.0000,67596.0000,67225.0000,67597.0000,67315.0000,67426.0000,67265.0000,67677.0000,67235.0000,67456.0000,67225.0000,67636.0000,67496.0000,67636.0000,67275.0000,67466.0000,67276.0000,67456.0000,67465.0000,67545.0000,67425.0000,67506.0000,67426.0000,67436.0000,67185.0000,67516.0000,67286.0000" -generating large task graphs,expanding tree topology,100,1,13832000,138276.9200,138107.0300,138626.3100,1191.5908,699.1095,2101.2521,"137990.0000,138179.0000,142879.0000,138651.0000,138821.0000,138420.0000,141726.0000,138680.0000,138160.0000,137649.0000,137779.0000,138240.0000,137929.0000,138320.0000,138501.0000,138370.0000,137318.0000,138120.0000,138170.0000,137839.0000,137538.0000,138501.0000,137759.0000,138230.0000,137598.0000,138671.0000,138150.0000,137659.0000,138119.0000,137949.0000,138120.0000,138249.0000,137839.0000,138320.0000,137909.0000,146746.0000,138541.0000,137919.0000,137929.0000,137739.0000,137649.0000,138090.0000,138109.0000,137578.0000,137839.0000,138230.0000,137789.0000,137960.0000,137959.0000,138220.0000,138370.0000,138390.0000,137719.0000,137649.0000,138020.0000,137739.0000,137829.0000,137769.0000,137849.0000,138320.0000,137639.0000,138480.0000,138210.0000,141536.0000,138030.0000,137679.0000,137528.0000,137960.0000,137759.0000,137669.0000,137729.0000,137598.0000,138491.0000,137498.0000,137729.0000,137929.0000,137919.0000,138220.0000,138049.0000,138240.0000,138781.0000,138200.0000,137719.0000,138200.0000,137568.0000,138199.0000,138120.0000,138410.0000,137268.0000,138551.0000,138500.0000,137749.0000,141416.0000,138701.0000,137909.0000,138169.0000,137699.0000,137889.0000,138520.0000,137929.0000" -generating large task graphs,contracting tree topology,100,1,17375500,178547.9900,178306.0700,179009.0600,1647.3569,1024.7082,2680.5883,"178255.0000,178005.0000,183686.0000,183686.0000,179598.0000,179097.0000,178375.0000,178607.0000,178566.0000,178596.0000,178506.0000,178596.0000,178035.0000,178256.0000,178276.0000,177704.0000,178416.0000,178587.0000,177905.0000,177945.0000,178175.0000,178425.0000,178325.0000,178156.0000,177574.0000,178296.0000,189156.0000,178085.0000,177865.0000,178115.0000,178677.0000,178826.0000,177754.0000,177975.0000,178075.0000,178306.0000,178195.0000,178236.0000,178296.0000,178396.0000,178185.0000,178166.0000,178065.0000,178216.0000,178025.0000,178095.0000,178375.0000,178105.0000,182604.0000,177985.0000,177785.0000,177905.0000,178045.0000,178066.0000,178105.0000,178316.0000,178075.0000,178146.0000,178105.0000,178045.0000,177894.0000,178896.0000,178005.0000,178075.0000,178436.0000,178146.0000,178255.0000,178086.0000,178185.0000,178767.0000,178145.0000,182373.0000,177955.0000,178406.0000,177815.0000,177845.0000,178196.0000,178205.0000,177785.0000,178025.0000,177795.0000,177454.0000,178226.0000,177655.0000,177594.0000,177955.0000,177625.0000,177744.0000,177684.0000,178015.0000,177865.0000,178486.0000,177965.0000,185639.0000,178496.0000,178245.0000,178576.0000,178325.0000,177535.0000,178406.0000" -generating large task graphs,wave_sim topology,100,1,66040300,660209.7000,659317.9500,661760.9100,5835.0377,3851.4092,10592.4036,"658595.0000,660188.0000,701377.0000,648346.0000,650429.0000,648547.0000,650560.0000,660529.0000,653566.0000,654778.0000,656431.0000,656972.0000,659497.0000,663193.0000,657573.0000,657663.0000,659096.0000,658705.0000,659708.0000,663975.0000,659357.0000,659838.0000,659557.0000,658665.0000,660229.0000,669395.0000,658394.0000,659857.0000,659177.0000,660488.0000,659527.0000,666390.0000,657363.0000,659907.0000,657863.0000,659878.0000,657523.0000,669255.0000,660018.0000,659778.0000,658755.0000,659377.0000,657423.0000,665919.0000,659067.0000,659326.0000,658946.0000,660660.0000,659336.0000,659718.0000,663134.0000,658485.0000,656281.0000,658515.0000,657363.0000,660980.0000,669105.0000,659547.0000,656151.0000,660168.0000,657423.0000,658986.0000,662814.0000,659567.0000,658034.0000,658175.0000,659487.0000,658916.0000,663113.0000,670327.0000,655439.0000,674215.0000,656492.0000,669225.0000,661661.0000,657213.0000,658856.0000,659687.0000,658355.0000,659968.0000,663294.0000,658996.0000,658986.0000,658756.0000,658435.0000,659637.0000,665950.0000,661450.0000,658265.0000,659778.0000,657323.0000,659897.0000,662563.0000,670769.0000,655138.0000,659427.0000,659427.0000,660449.0000,662743.0000,661291.0000" -generating large task graphs,jacobi topology,100,1,21514900,215136.9300,214850.6500,215633.6900,1882.0380,1227.5634,2734.0494,"215406.0000,214875.0000,220446.0000,215095.0000,220576.0000,215096.0000,215135.0000,215086.0000,214644.0000,215426.0000,215356.0000,215186.0000,214925.0000,214915.0000,215055.0000,215306.0000,214485.0000,214784.0000,214605.0000,214715.0000,215155.0000,214785.0000,218131.0000,214915.0000,214425.0000,214193.0000,214585.0000,214424.0000,214614.0000,214043.0000,214364.0000,214103.0000,214293.0000,214794.0000,214274.0000,214194.0000,214594.0000,214475.0000,214233.0000,214233.0000,214475.0000,224673.0000,214895.0000,214965.0000,215006.0000,214774.0000,214724.0000,214925.0000,214164.0000,214655.0000,214534.0000,214374.0000,214214.0000,214614.0000,214645.0000,214324.0000,214514.0000,214525.0000,214294.0000,220345.0000,214574.0000,214774.0000,214024.0000,214765.0000,214714.0000,214745.0000,214294.0000,214735.0000,214724.0000,214966.0000,214995.0000,214945.0000,214574.0000,214664.0000,215096.0000,215145.0000,215025.0000,214715.0000,224624.0000,214514.0000,214715.0000,214604.0000,214144.0000,214183.0000,214464.0000,214594.0000,214124.0000,214444.0000,214234.0000,214304.0000,214534.0000,214304.0000,214104.0000,214885.0000,213973.0000,214214.0000,215075.0000,221909.0000,215315.0000,215375.0000" -generating large command graphs for N nodes - 1,soup topology,100,1,2668175200,26437291.0200,26266152.7600,26534338.7400,638673.0791,411509.2821,944474.8030,"26678349.0000,25692311.0000,26652821.0000,26571768.0000,26525630.0000,26530599.0000,26502075.0000,26603838.0000,26622493.0000,26487739.0000,26522243.0000,26866816.0000,26678168.0000,26731640.0000,26773429.0000,26702224.0000,24692379.0000,23960653.0000,26782065.0000,26542862.0000,26607325.0000,26547632.0000,26525279.0000,26726290.0000,26538424.0000,26524087.0000,26499059.0000,26516553.0000,26542703.0000,26529888.0000,26679332.0000,26706493.0000,26738253.0000,26800440.0000,26830086.0000,26691875.0000,26668801.0000,26623425.0000,26606082.0000,26534307.0000,26601484.0000,26594851.0000,26579081.0000,26617403.0000,26660155.0000,26565396.0000,23231932.0000,24727845.0000,26605462.0000,26573320.0000,26749103.0000,26525460.0000,26559344.0000,26635798.0000,25851323.0000,25196974.0000,26531200.0000,26503879.0000,26538104.0000,26636781.0000,26537713.0000,26626782.0000,26558071.0000,26482970.0000,26703717.0000,26545698.0000,26495654.0000,26613546.0000,26593258.0000,26607234.0000,26516323.0000,26554144.0000,26580405.0000,26579021.0000,26503578.0000,26652189.0000,26618045.0000,26453443.0000,26606964.0000,26679101.0000,26589421.0000,26640798.0000,26510261.0000,26664824.0000,26605862.0000,26577218.0000,26638454.0000,26785372.0000,26511343.0000,26860154.0000,26725699.0000,26797705.0000,23058866.0000,25452628.0000,26709949.0000,26623194.0000,26567469.0000,26626521.0000,26608437.0000,26625740.0000" -generating large command graphs for N nodes - 1,chain topology,100,1,27255200,273322.4500,272948.8700,273942.9800,2424.4333,1630.8733,3497.6197,"272604.0000,273506.0000,284476.0000,273586.0000,274107.0000,273226.0000,278966.0000,273867.0000,272845.0000,272975.0000,272905.0000,272805.0000,272394.0000,273135.0000,272414.0000,272044.0000,271823.0000,272965.0000,272283.0000,272955.0000,282372.0000,274377.0000,273005.0000,273405.0000,272104.0000,272875.0000,272815.0000,272885.0000,273175.0000,273556.0000,272765.0000,272354.0000,271953.0000,272454.0000,272284.0000,276512.0000,273135.0000,273426.0000,272044.0000,273576.0000,272594.0000,272494.0000,273275.0000,271813.0000,272594.0000,271361.0000,271832.0000,272194.0000,272174.0000,273105.0000,280740.0000,273276.0000,271933.0000,272654.0000,272714.0000,272084.0000,272724.0000,273096.0000,273015.0000,272504.0000,272775.0000,273406.0000,273546.0000,273366.0000,279768.0000,272004.0000,272364.0000,271802.0000,273105.0000,272945.0000,272795.0000,272544.0000,271382.0000,272534.0000,272074.0000,272494.0000,271683.0000,271732.0000,271602.0000,285920.0000,273175.0000,271903.0000,273616.0000,272444.0000,273095.0000,272725.0000,272334.0000,272744.0000,272394.0000,272855.0000,272514.0000,272734.0000,272745.0000,271642.0000,276953.0000,272524.0000,272484.0000,272444.0000,273015.0000,272935.0000" -generating large command graphs for N nodes - 1,expanding tree topology,100,1,43962700,438959.8600,438475.0000,439696.1900,3007.3326,2170.2411,4081.4630,"435553.0000,436395.0000,448918.0000,438819.0000,438860.0000,438458.0000,440452.0000,438349.0000,439350.0000,439440.0000,439230.0000,444710.0000,439932.0000,440632.0000,438599.0000,439150.0000,439019.0000,438409.0000,438669.0000,438007.0000,451714.0000,438478.0000,439731.0000,438799.0000,438329.0000,438408.0000,438468.0000,438097.0000,436475.0000,441644.0000,436975.0000,438028.0000,438859.0000,437717.0000,437878.0000,438769.0000,438087.0000,437095.0000,442677.0000,437847.0000,437948.0000,438278.0000,438027.0000,436755.0000,438699.0000,438899.0000,437707.0000,448057.0000,438809.0000,437256.0000,437006.0000,437506.0000,437135.0000,438488.0000,438198.0000,438689.0000,442356.0000,440622.0000,439220.0000,438268.0000,438639.0000,438018.0000,439099.0000,437446.0000,436926.0000,437827.0000,451633.0000,438098.0000,437537.0000,436905.0000,437948.0000,437296.0000,437517.0000,437456.0000,437928.0000,444790.0000,437998.0000,438068.0000,437126.0000,437186.0000,438178.0000,438047.0000,438619.0000,436866.0000,442486.0000,437406.0000,438248.0000,438288.0000,436756.0000,437076.0000,436725.0000,437456.0000,438329.0000,450471.0000,436575.0000,437516.0000,437367.0000,436745.0000,437978.0000,436464.0000" -generating large command graphs for N nodes - 1,contracting tree topology,100,1,48511000,484555.6500,483995.5400,485343.5300,3360.2582,2540.3370,4350.0806,"496428.0000,483964.0000,489795.0000,485498.0000,485768.0000,484796.0000,483975.0000,484586.0000,483353.0000,488273.0000,483965.0000,482662.0000,483564.0000,483704.0000,483113.0000,483534.0000,483443.0000,493182.0000,483684.0000,482592.0000,483974.0000,483012.0000,483334.0000,483864.0000,483755.0000,483343.0000,491499.0000,481921.0000,481951.0000,482361.0000,482953.0000,481590.0000,482652.0000,480759.0000,488643.0000,482281.0000,482782.0000,482261.0000,481059.0000,483053.0000,482131.0000,481751.0000,494624.0000,483173.0000,483133.0000,483844.0000,482973.0000,483173.0000,483855.0000,483123.0000,491779.0000,483143.0000,484055.0000,483354.0000,484996.0000,484516.0000,484496.0000,482832.0000,483404.0000,487972.0000,483003.0000,483444.0000,484906.0000,482362.0000,483984.0000,484365.0000,483534.0000,495586.0000,484485.0000,483053.0000,482592.0000,483754.0000,483194.0000,483844.0000,482492.0000,498392.0000,484325.0000,482071.0000,484165.0000,483003.0000,484085.0000,482221.0000,483283.0000,494494.0000,484816.0000,483854.0000,483253.0000,484174.0000,483303.0000,483854.0000,485288.0000,484455.0000,490407.0000,483554.0000,483634.0000,483594.0000,482902.0000,482752.0000,483995.0000,481840.0000" -generating large command graphs for N nodes - 1,wave_sim topology,100,1,214805200,2152806.8700,2151474.1400,2154940.4000,8464.2155,5979.9725,14562.3129,"2148657.0000,2154037.0000,2208109.0000,2143337.0000,2158847.0000,2144659.0000,2154227.0000,2143748.0000,2154538.0000,2162423.0000,2150901.0000,2158335.0000,2145020.0000,2157844.0000,2148477.0000,2161211.0000,2148767.0000,2153206.0000,2148727.0000,2161051.0000,2145551.0000,2155400.0000,2145411.0000,2152194.0000,2161111.0000,2147535.0000,2155079.0000,2145762.0000,2152314.0000,2144219.0000,2159998.0000,2149289.0000,2152414.0000,2157163.0000,2157744.0000,2146943.0000,2180587.0000,2150000.0000,2143657.0000,2159437.0000,2150010.0000,2155800.0000,2152014.0000,2153807.0000,2147615.0000,2159648.0000,2145571.0000,2155370.0000,2147194.0000,2162282.0000,2150260.0000,2141643.0000,2146823.0000,2148317.0000,2159689.0000,2154227.0000,2150240.0000,2148947.0000,2159608.0000,2144860.0000,2150170.0000,2143517.0000,2158455.0000,2153727.0000,2144339.0000,2152174.0000,2149809.0000,2162353.0000,2148347.0000,2156632.0000,2149919.0000,2153696.0000,2148086.0000,2163445.0000,2145110.0000,2155079.0000,2157995.0000,2146153.0000,2153496.0000,2146673.0000,2156893.0000,2146553.0000,2164447.0000,2148958.0000,2154688.0000,2147374.0000,2153236.0000,2145321.0000,2160409.0000,2153687.0000,2146583.0000,2153527.0000,2144910.0000,2161000.0000,2146974.0000,2148607.0000,2142947.0000,2151833.0000,2151773.0000,2159938.0000" -generating large command graphs for N nodes - 1,jacobi topology,100,1,71740500,752055.4500,741119.1800,761925.1800,52843.3559,48914.8227,55095.3380,"691177.0000,681880.0000,807558.0000,793851.0000,793090.0000,793952.0000,790986.0000,788772.0000,790776.0000,790184.0000,801787.0000,791447.0000,790826.0000,791346.0000,792219.0000,798400.0000,790545.0000,791126.0000,789403.0000,788922.0000,802558.0000,790064.0000,788742.0000,789142.0000,790334.0000,796577.0000,789363.0000,790335.0000,789874.0000,789693.0000,802878.0000,789123.0000,788361.0000,790665.0000,789744.0000,798340.0000,792779.0000,788651.0000,791417.0000,790094.0000,803008.0000,788051.0000,789533.0000,788511.0000,788401.0000,795384.0000,790545.0000,789373.0000,788421.0000,789653.0000,796266.0000,790556.0000,790455.0000,789463.0000,789243.0000,800544.0000,789914.0000,789122.0000,788821.0000,787168.0000,794944.0000,789273.0000,788772.0000,788130.0000,789073.0000,771369.0000,680737.0000,678854.0000,679966.0000,679865.0000,680176.0000,694704.0000,680868.0000,680627.0000,679996.0000,678342.0000,678894.0000,684074.0000,679465.0000,678593.0000,678843.0000,680717.0000,679334.0000,688322.0000,680096.0000,679876.0000,680517.0000,681699.0000,680677.0000,691047.0000,682530.0000,681960.0000,681038.0000,680907.0000,691728.0000,681208.0000,680627.0000,679354.0000,679255.0000,679675.0000" -generating large command graphs for N nodes - 4,soup topology,100,1,6181797100,62767239.3000,62457661.0500,62983464.9800,1303867.2730,999306.4460,1660379.9335,"63530747.0000,62878723.0000,63326099.0000,61424638.0000,61533054.0000,63305651.0000,63603364.0000,59263466.0000,58110102.0000,60751924.0000,61387027.0000,62553457.0000,58051150.0000,60448471.0000,63301092.0000,62633848.0000,63537940.0000,63008778.0000,63176547.0000,63155787.0000,63278690.0000,63143665.0000,60588125.0000,63195212.0000,63431058.0000,63237943.0000,60017504.0000,63414667.0000,62424062.0000,62947623.0000,63143373.0000,63099199.0000,63188969.0000,63208276.0000,63216172.0000,63556175.0000,63620027.0000,63258261.0000,63092707.0000,63184882.0000,63291744.0000,63291874.0000,59954765.0000,63365904.0000,63186275.0000,63233995.0000,63320669.0000,63511601.0000,63588296.0000,63206994.0000,63608996.0000,63211543.0000,63346437.0000,63355886.0000,63180514.0000,63607572.0000,63198477.0000,63583196.0000,61641119.0000,63432652.0000,58473240.0000,63546407.0000,63102045.0000,63264674.0000,63361887.0000,63724725.0000,63387156.0000,63442139.0000,63237612.0000,62676480.0000,63119007.0000,63195012.0000,63263681.0000,63380463.0000,63596693.0000,63651536.0000,63327242.0000,63094751.0000,63304208.0000,63361867.0000,63403075.0000,63232863.0000,63433903.0000,63485812.0000,63347079.0000,61502306.0000,59704481.0000,63135910.0000,63469692.0000,63465584.0000,58149737.0000,63594828.0000,63379731.0000,63401672.0000,63104640.0000,63178590.0000,63159235.0000,63278579.0000,63148192.0000,63290232.0000" -generating large command graphs for N nodes - 4,chain topology,100,1,338368600,3392210.2800,3390235.0200,3394236.4800,10207.4953,9159.8803,12085.0248,"3399486.0000,3400357.0000,3403073.0000,3380219.0000,3386652.0000,3386080.0000,3378637.0000,3377484.0000,3393845.0000,3387604.0000,3384928.0000,3388756.0000,3376903.0000,3373396.0000,3376513.0000,3387333.0000,3382443.0000,3390920.0000,3425996.0000,3382985.0000,3378015.0000,3390459.0000,3379448.0000,3384788.0000,3380650.0000,3384468.0000,3372685.0000,3377865.0000,3387904.0000,3379448.0000,3380570.0000,3381923.0000,3385579.0000,3378166.0000,3372905.0000,3383024.0000,3381752.0000,3391660.0000,3380039.0000,3372905.0000,3382815.0000,3376071.0000,3385950.0000,3398544.0000,3398524.0000,3402972.0000,3387654.0000,3397312.0000,3399205.0000,3393164.0000,3397342.0000,3409855.0000,3389667.0000,3398434.0000,3391360.0000,3405728.0000,3396350.0000,3405026.0000,3394086.0000,3398865.0000,3404104.0000,3393023.0000,3401911.0000,3395147.0000,3402260.0000,3393604.0000,3384277.0000,3388815.0000,3404425.0000,3398023.0000,3399475.0000,3390198.0000,3398253.0000,3399305.0000,3395288.0000,3401890.0000,3395779.0000,3400027.0000,3403744.0000,3388165.0000,3409144.0000,3397812.0000,3400217.0000,3407000.0000,3409485.0000,3405878.0000,3388104.0000,3398645.0000,3394787.0000,3395708.0000,3394706.0000,3397092.0000,3386902.0000,3394115.0000,3398433.0000,3400397.0000,3402482.0000,3405577.0000,3405247.0000,3394797.0000" -generating large command graphs for N nodes - 4,expanding tree topology,100,1,955265800,9547281.3500,9495074.6200,9573668.2100,182676.0470,107326.0793,283321.9664,"9607742.0000,9593745.0000,9547298.0000,9531187.0000,9553380.0000,9533712.0000,9548520.0000,9549773.0000,9542709.0000,9527210.0000,9541607.0000,9521969.0000,9573357.0000,9530386.0000,9556335.0000,9557187.0000,9555283.0000,9561324.0000,9548210.0000,9557157.0000,9550684.0000,9548220.0000,9565433.0000,9547137.0000,9549271.0000,9549422.0000,9560653.0000,9665842.0000,9591241.0000,9598435.0000,9593796.0000,9552999.0000,9557577.0000,9558128.0000,9545024.0000,9570211.0000,9573277.0000,9554091.0000,9580341.0000,9567696.0000,9578326.0000,9565162.0000,9565463.0000,9573598.0000,9553811.0000,9569680.0000,9568427.0000,9546937.0000,9579990.0000,9556185.0000,9553720.0000,9551957.0000,9559381.0000,9549653.0000,9716278.0000,9561926.0000,9549402.0000,9533031.0000,9572476.0000,9544462.0000,9569029.0000,9583065.0000,9584177.0000,9604626.0000,9594167.0000,9583206.0000,9585741.0000,9595760.0000,9601030.0000,9605759.0000,9553269.0000,9565523.0000,9564581.0000,9567275.0000,9567095.0000,8591969.0000,8575017.0000,8586338.0000,9029938.0000,9627790.0000,9610408.0000,9659521.0000,9604827.0000,9602111.0000,9601180.0000,9641075.0000,9651705.0000,9614415.0000,9701580.0000,9651154.0000,9664831.0000,9697772.0000,9654781.0000,9651856.0000,9648891.0000,9660803.0000,9630606.0000,9621779.0000,9639943.0000,9616108.0000" -generating large command graphs for N nodes - 4,contracting tree topology,100,1,381831400,3818494.1600,3816637.3000,3820805.2500,10494.9404,8647.4759,14567.5947,"3816105.0000,3818489.0000,3834680.0000,3819782.0000,3819741.0000,3832325.0000,3815915.0000,3829259.0000,3815754.0000,3825993.0000,3831845.0000,3830753.0000,3823498.0000,3817918.0000,3808741.0000,3816085.0000,3818569.0000,3812789.0000,3840811.0000,3811045.0000,3815073.0000,3815183.0000,3828398.0000,3822467.0000,3821675.0000,3813399.0000,3816646.0000,3819020.0000,3808440.0000,3822326.0000,3823278.0000,3816686.0000,3826645.0000,3822567.0000,3817808.0000,3826795.0000,3814823.0000,3825142.0000,3814541.0000,3842715.0000,3820192.0000,3827446.0000,3816716.0000,3833898.0000,3808560.0000,3820613.0000,3833277.0000,3869195.0000,3814933.0000,3821786.0000,3801166.0000,3821866.0000,3817167.0000,3810584.0000,3837976.0000,3847324.0000,3821515.0000,3812348.0000,3818649.0000,3815854.0000,3808490.0000,3806878.0000,3802579.0000,3818880.0000,3808140.0000,3819181.0000,3813239.0000,3824681.0000,3824230.0000,3809321.0000,3807328.0000,3818289.0000,3804042.0000,3824901.0000,3801517.0000,3821124.0000,3811757.0000,3814732.0000,3807829.0000,3825192.0000,3804662.0000,3811736.0000,3807058.0000,3814331.0000,3806646.0000,3813499.0000,3807408.0000,3805735.0000,3808611.0000,3813590.0000,3802749.0000,3828828.0000,3814251.0000,3815343.0000,3812107.0000,3830201.0000,3815444.0000,3818519.0000,3810013.0000,3811566.0000" -generating large command graphs for N nodes - 4,wave_sim topology,100,1,1542105900,15387665.4800,15343930.5100,15400282.4500,108692.3531,28806.2087,249873.4924,"15363532.0000,15349416.0000,15441590.0000,15433404.0000,15403568.0000,15371838.0000,15393138.0000,15433545.0000,15401995.0000,15409721.0000,15396014.0000,15389041.0000,15386846.0000,15417114.0000,15384733.0000,15378971.0000,15385785.0000,15384161.0000,15386316.0000,15404490.0000,15398258.0000,15388239.0000,15391686.0000,15395823.0000,15464603.0000,15448243.0000,15409760.0000,15405121.0000,15405181.0000,14354541.0000,15435108.0000,15430970.0000,15431241.0000,15403598.0000,15374663.0000,15386145.0000,15401855.0000,15387518.0000,15373311.0000,15394942.0000,15390654.0000,15494170.0000,15408277.0000,15409940.0000,15443444.0000,15580303.0000,15432653.0000,15404179.0000,15368261.0000,15401644.0000,15377910.0000,15382689.0000,15412946.0000,15410922.0000,15422544.0000,15402626.0000,15363062.0000,15398829.0000,15376547.0000,15380104.0000,15371387.0000,15381066.0000,15380093.0000,15384902.0000,15386275.0000,15391155.0000,15421812.0000,15396525.0000,15384783.0000,15410411.0000,15408077.0000,15402205.0000,15388610.0000,15377749.0000,15376106.0000,15391756.0000,15417524.0000,15403999.0000,15397106.0000,15371959.0000,15395983.0000,15368291.0000,15372920.0000,15350097.0000,15359745.0000,15368342.0000,15379622.0000,15394180.0000,15360386.0000,15504409.0000,15370525.0000,15406153.0000,15383181.0000,15396334.0000,15364975.0000,15377238.0000,15403918.0000,15376887.0000,15384031.0000,15348103.0000" -generating large command graphs for N nodes - 4,jacobi topology,100,1,521570100,5280570.0400,5233343.6000,5312972.8400,198357.6607,147525.0738,252123.6722,"4675602.0000,4913153.0000,4665694.0000,4652859.0000,4669400.0000,5314723.0000,5362353.0000,5353396.0000,5363666.0000,5338848.0000,5342776.0000,5342846.0000,5341844.0000,5343777.0000,5360390.0000,5339239.0000,5347344.0000,5352063.0000,5337386.0000,5324832.0000,5350480.0000,5342846.0000,5333909.0000,5343647.0000,5340261.0000,5353165.0000,5348978.0000,5337285.0000,5345170.0000,5339069.0000,5343727.0000,5330753.0000,5347264.0000,5343217.0000,5340612.0000,5406627.0000,5334931.0000,5344669.0000,5349568.0000,5339680.0000,5356181.0000,5350230.0000,5341814.0000,5354237.0000,5336263.0000,5348888.0000,5345932.0000,5343326.0000,5339469.0000,5346854.0000,5337125.0000,5338929.0000,5387831.0000,5346363.0000,5337095.0000,5354749.0000,5349048.0000,5334139.0000,5505725.0000,5342545.0000,5332487.0000,5349408.0000,5333569.0000,5349168.0000,5341263.0000,5341944.0000,5333688.0000,5345461.0000,5336935.0000,5312479.0000,5349418.0000,5341073.0000,5344339.0000,5347916.0000,5334440.0000,5335231.0000,5349007.0000,5340983.0000,5341163.0000,5342826.0000,5341173.0000,5348577.0000,5345982.0000,5349037.0000,5332706.0000,5359757.0000,5349127.0000,5349618.0000,5353896.0000,5356571.0000,5339690.0000,5360379.0000,5357363.0000,5349799.0000,5249960.0000,4676855.0000,4678778.0000,4663960.0000,4659061.0000,4677125.0000" -generating large command graphs for N nodes - 16,soup topology,100,1,21816995200,216401055.7100,215993451.6100,216686472.4800,1730272.2305,1348760.3632,2323932.4461,"217337633.0000,217164787.0000,217570134.0000,216997919.0000,216859127.0000,208175963.0000,212952269.0000,216962502.0000,217123388.0000,217046782.0000,216808461.0000,216966259.0000,216964587.0000,215451291.0000,214216684.0000,217193471.0000,216923458.0000,217138086.0000,217310131.0000,216799094.0000,216793603.0000,217115624.0000,217445988.0000,212886695.0000,216508212.0000,217188200.0000,216959778.0000,216332129.0000,217843001.0000,216686380.0000,217089404.0000,215863361.0000,217708527.0000,212212478.0000,216809342.0000,217037305.0000,217389681.0000,216881740.0000,217193379.0000,216602141.0000,217272571.0000,217075887.0000,212219652.0000,217000675.0000,216787692.0000,217263212.0000,218076393.0000,216489167.0000,216621167.0000,218275540.0000,211412412.0000,212560768.0000,217365777.0000,217213828.0000,216700748.0000,216352758.0000,218136356.0000,216679708.0000,217176138.0000,216957834.0000,214111944.0000,215479926.0000,216726536.0000,217533474.0000,217024070.0000,216868385.0000,217119390.0000,217201796.0000,215905912.0000,217515201.0000,212106326.0000,217404450.0000,216870740.0000,216873234.0000,217189403.0000,216941173.0000,217113689.0000,218281251.0000,216631145.0000,212238788.0000,216539523.0000,216752194.0000,217128748.0000,216590599.0000,217330158.0000,216843719.0000,217782776.0000,216163340.0000,211884417.0000,217274814.0000,216786881.0000,212894700.0000,217136101.0000,217194643.0000,216826566.0000,217151251.0000,217067702.0000,216543108.0000,217363353.0000,217566868.0000" -generating large command graphs for N nodes - 16,chain topology,100,1,40463208700,400160036.2500,398431195.2700,401538796.5100,7873983.2823,6516755.7162,9459814.3047,"404877080.0000,397277098.0000,400480985.0000,404615374.0000,405173882.0000,405873828.0000,405228966.0000,399163029.0000,405278821.0000,406267583.0000,405491573.0000,400772788.0000,398901835.0000,406342955.0000,405446768.0000,409169930.0000,406081911.0000,402868826.0000,404805676.0000,406297870.0000,404922346.0000,403117819.0000,392659874.0000,382054520.0000,381341109.0000,388415457.0000,375066707.0000,384954943.0000,390043620.0000,378973086.0000,386878165.0000,381890780.0000,394586182.0000,405855562.0000,405660463.0000,405325490.0000,404617729.0000,403052655.0000,403950315.0000,400587927.0000,405837510.0000,404418531.0000,399826435.0000,405449665.0000,405087609.0000,403491687.0000,404943746.0000,400234167.0000,407145346.0000,405948288.0000,404615344.0000,399605778.0000,399949359.0000,404953855.0000,405586665.0000,405219117.0000,405324848.0000,401889753.0000,406343887.0000,404682622.0000,405308928.0000,400226564.0000,400031253.0000,405662799.0000,405818643.0000,405892774.0000,399964707.0000,400766115.0000,405150738.0000,406042938.0000,405444184.0000,400076269.0000,391874677.0000,381422755.0000,404819079.0000,405435588.0000,405501833.0000,404195590.0000,394520999.0000,405338553.0000,404106771.0000,398562992.0000,399496380.0000,405023737.0000,405187738.0000,405005804.0000,405446829.0000,398839357.0000,391822177.0000,405842038.0000,397408887.0000,382369428.0000,376110063.0000,383186094.0000,392328687.0000,395420642.0000,395448465.0000,401693450.0000,399707641.0000,404575720.0000" -generating large command graphs for N nodes - 16,expanding tree topology,100,1,67876242300,671729393.3600,669927210.4300,673014666.6100,7713639.7399,5975839.7343,10098882.9632,"676736605.0000,667497478.0000,675717565.0000,673835070.0000,677181126.0000,671562778.0000,671595800.0000,675256362.0000,674069855.0000,670239771.0000,676473827.0000,669325381.0000,659929998.0000,651738536.0000,651353276.0000,661206545.0000,672619007.0000,668844590.0000,665823429.0000,677248444.0000,675412768.0000,676648147.0000,675220224.0000,677513827.0000,673496038.0000,676778053.0000,677540367.0000,672428647.0000,677362500.0000,673279498.0000,674938851.0000,674992963.0000,673073038.0000,667462001.0000,675288653.0000,675602437.0000,676421408.0000,676952844.0000,675311808.0000,674725397.0000,678229411.0000,675766538.0000,674505170.0000,676488816.0000,679905857.0000,671733801.0000,677040831.0000,676981950.0000,674661636.0000,675161211.0000,670757483.0000,673085731.0000,676220407.0000,674690612.0000,675033900.0000,678130996.0000,676986098.0000,673754418.0000,676144073.0000,676531647.0000,672186098.0000,678858744.0000,676289579.0000,676055726.0000,676214787.0000,671334285.0000,679042692.0000,674140519.0000,673383245.0000,660328513.0000,637998998.0000,645462140.0000,659843614.0000,651781448.0000,647524576.0000,652238644.0000,676193336.0000,668967273.0000,672449997.0000,673601939.0000,672451451.0000,668095952.0000,677853181.0000,671421700.0000,668322802.0000,675478574.0000,668394307.0000,667205867.0000,672859223.0000,671807551.0000,665410718.0000,675557202.0000,674778587.0000,666704869.0000,677695191.0000,673175732.0000,674863578.0000,676063872.0000,673981819.0000,676405509.0000" -generating large command graphs for N nodes - 16,contracting tree topology,100,1,13342621200,133138311.2000,132734175.7400,133420743.8000,1708816.2353,1287548.4986,2156772.8114,"127855029.0000,130627239.0000,133775972.0000,133520718.0000,133314208.0000,133632179.0000,127761843.0000,133647038.0000,133395431.0000,134284614.0000,128191357.0000,128193851.0000,134143348.0000,133908112.0000,133721950.0000,133367228.0000,133566446.0000,133659150.0000,133877745.0000,133660063.0000,133707122.0000,133566805.0000,132831724.0000,134312418.0000,133622582.0000,133708494.0000,130278419.0000,133581985.0000,133588236.0000,133484530.0000,133396924.0000,133820817.0000,133733411.0000,134078245.0000,134118800.0000,133878346.0000,133629805.0000,133626699.0000,133327682.0000,133703756.0000,133709396.0000,127416679.0000,133580081.0000,133947066.0000,133560243.0000,133581513.0000,134136024.0000,133860050.0000,134299935.0000,133492856.0000,133662577.0000,133598606.0000,132303823.0000,133331330.0000,133549583.0000,133627040.0000,127613441.0000,134425943.0000,133701882.0000,134631142.0000,133760924.0000,133781782.0000,133471145.0000,133475713.0000,134332916.0000,133784507.0000,134052165.0000,133401873.0000,133392445.0000,133705007.0000,133531969.0000,129981205.0000,133632099.0000,133568399.0000,133651435.0000,133576805.0000,133591853.0000,133590481.0000,134291889.0000,133444022.0000,134257454.0000,133682956.0000,132012182.0000,133640846.0000,133529014.0000,134024282.0000,128052503.0000,133471997.0000,133615508.0000,133679950.0000,133388348.0000,134630240.0000,134557533.0000,134372240.0000,133909936.0000,134233178.0000,127725474.0000,133845915.0000,133460213.0000,133593186.0000" -generating large command graphs for N nodes - 16,wave_sim topology,100,1,13185901300,131448888.2200,131164384.2800,131630351.9700,1143781.7901,808122.8274,1549172.9594,"132037779.0000,132463247.0000,132018624.0000,132184297.0000,131608578.0000,131520351.0000,131571999.0000,130555373.0000,132005028.0000,131679833.0000,131500744.0000,127889625.0000,131387208.0000,131957549.0000,132111510.0000,132223543.0000,132307952.0000,131854563.0000,131481617.0000,131965693.0000,131771095.0000,132187013.0000,131655546.0000,132589956.0000,132063159.0000,131778249.0000,131754314.0000,126789351.0000,131742722.0000,131605402.0000,131395995.0000,131749645.0000,131549365.0000,131633876.0000,131795642.0000,132122301.0000,132121529.0000,130770670.0000,132164811.0000,131639206.0000,131651799.0000,131480164.0000,129902516.0000,131475355.0000,131490023.0000,131377620.0000,131450920.0000,131800741.0000,131428376.0000,132040576.0000,131516584.0000,131530470.0000,131498348.0000,131703447.0000,132116249.0000,131771897.0000,131787085.0000,126608808.0000,131533575.0000,131604980.0000,131644165.0000,131400193.0000,131749193.0000,131726901.0000,131462370.0000,132159931.0000,131602436.0000,131559124.0000,130348120.0000,131567099.0000,132634110.0000,131501194.0000,129205568.0000,131621902.0000,131427415.0000,131924586.0000,132098416.0000,132352276.0000,131853110.0000,131707966.0000,131431211.0000,131977446.0000,127241568.0000,131982345.0000,132135325.0000,131835087.0000,126920300.0000,131535269.0000,129225505.0000,131553753.0000,131456009.0000,131386747.0000,132312490.0000,132480018.0000,131990700.0000,131987155.0000,132238090.0000,131819668.0000,130760532.0000,132099036.0000" -generating large command graphs for N nodes - 16,jacobi topology,100,1,12778767400,124329836.7500,123564027.5200,124914506.7500,3400391.7718,2788266.3079,4316485.3607,"117587776.0000,126721543.0000,125922680.0000,126291398.0000,126786897.0000,125935394.0000,126060080.0000,126333909.0000,126455199.0000,126156523.0000,126183073.0000,126279334.0000,126592138.0000,126236504.0000,121797889.0000,126367603.0000,126351271.0000,126339079.0000,126373123.0000,126232316.0000,126667201.0000,126321464.0000,126316256.0000,126305105.0000,126212248.0000,125052061.0000,126218049.0000,126430262.0000,126498962.0000,122706239.0000,126494593.0000,126273304.0000,126568824.0000,126355250.0000,126262574.0000,126446822.0000,126381620.0000,126240021.0000,126285197.0000,126460168.0000,126181069.0000,126261791.0000,126229852.0000,126412848.0000,126754015.0000,120811020.0000,126187360.0000,126435361.0000,126344469.0000,126465148.0000,126337235.0000,126627925.0000,126410694.0000,126254729.0000,126261852.0000,126463525.0000,125210050.0000,126423037.0000,126344549.0000,126509672.0000,126439759.0000,121105817.0000,120459394.0000,122998673.0000,126230924.0000,126503089.0000,126070470.0000,126373724.0000,126666038.0000,126675807.0000,126410264.0000,121006870.0000,126519601.0000,126272854.0000,126381128.0000,122743380.0000,124983641.0000,122163271.0000,121412439.0000,121802728.0000,124519843.0000,116662984.0000,122988314.0000,121979443.0000,121149161.0000,122050237.0000,116151596.0000,121150443.0000,123957158.0000,115528005.0000,120604227.0000,115669173.0000,121318812.0000,116903941.0000,122162299.0000,118647121.0000,110358597.0000,121512569.0000,113894132.0000,120129599.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,soup topology,100,1,2671787000,26437800.9300,26243677.3700,26565798.3800,793222.3975,586956.3853,1057833.6688,"26700622.0000,26709658.0000,26738523.0000,26653643.0000,26868349.0000,26680834.0000,26630860.0000,26688498.0000,26661478.0000,26786183.0000,25441047.0000,26823875.0000,26881585.0000,26892615.0000,26930146.0000,24531855.0000,25338832.0000,26882586.0000,26777588.0000,26720188.0000,26736288.0000,26669572.0000,26719628.0000,26624829.0000,25802651.0000,26527844.0000,26865694.0000,26680823.0000,26759112.0000,26733074.0000,26671276.0000,26767568.0000,26716632.0000,26698458.0000,26655466.0000,26708146.0000,26678239.0000,26510210.0000,22873083.0000,25303426.0000,26739274.0000,26651629.0000,26762178.0000,26737211.0000,26672769.0000,26660926.0000,26768361.0000,26692757.0000,26648172.0000,26772748.0000,26698287.0000,26677498.0000,26712595.0000,26706432.0000,26733373.0000,26629076.0000,26930727.0000,26729896.0000,26748453.0000,26780983.0000,26707424.0000,26782587.0000,26698537.0000,26717524.0000,26797735.0000,26797144.0000,26605982.0000,24849176.0000,26107919.0000,26739546.0000,25252670.0000,23684630.0000,26724296.0000,26680764.0000,24281020.0000,23736298.0000,26680062.0000,26724647.0000,26680494.0000,26711632.0000,26749504.0000,26795622.0000,26718345.0000,26706172.0000,26698648.0000,26765033.0000,26772448.0000,26769913.0000,26736329.0000,26698507.0000,26607746.0000,24162776.0000,23934884.0000,26642793.0000,26747570.0000,26932801.0000,26669292.0000,26738603.0000,26726251.0000,26752440.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,chain topology,100,1,27494000,276946.3800,275185.3100,284954.3900,16375.4159,1866.5802,38816.3358,"275170.0000,284587.0000,282864.0000,276492.0000,274638.0000,275049.0000,275881.0000,275540.0000,275400.0000,272704.0000,273226.0000,273586.0000,273637.0000,273486.0000,272935.0000,280259.0000,275460.0000,274698.0000,274528.0000,274508.0000,274057.0000,274739.0000,275820.0000,275330.0000,274989.0000,274337.0000,274457.0000,274148.0000,275079.0000,438498.0000,276692.0000,274017.0000,274438.0000,274107.0000,275159.0000,274939.0000,276091.0000,274929.0000,274698.0000,274518.0000,274969.0000,275360.0000,274247.0000,279757.0000,274437.0000,275310.0000,274598.0000,275119.0000,275460.0000,273797.0000,274037.0000,274448.0000,274959.0000,275870.0000,274487.0000,275009.0000,275290.0000,274267.0000,287672.0000,276982.0000,274979.0000,275360.0000,275780.0000,275670.0000,274337.0000,274568.0000,274729.0000,274367.0000,274758.0000,275039.0000,275330.0000,274848.0000,280129.0000,274929.0000,273987.0000,274888.0000,274207.0000,274939.0000,274337.0000,274558.0000,274918.0000,274888.0000,274819.0000,274217.0000,275840.0000,274698.0000,274407.0000,279327.0000,274918.0000,275400.0000,275319.0000,274317.0000,274638.0000,274728.0000,275560.0000,274478.0000,274768.0000,275179.0000,275169.0000,273546.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,44345400,443654.5900,442933.4900,445242.1700,5164.1602,2921.7631,10014.1081,"441925.0000,452465.0000,458867.0000,445011.0000,443828.0000,443698.0000,442957.0000,443859.0000,441153.0000,442176.0000,441664.0000,456572.0000,442697.0000,443818.0000,442916.0000,442886.0000,442627.0000,443177.0000,443258.0000,442756.0000,451392.0000,442906.0000,442126.0000,442546.0000,442526.0000,441645.0000,442456.0000,442326.0000,443818.0000,453087.0000,442335.0000,442626.0000,441835.0000,441274.0000,441253.0000,443909.0000,441474.0000,442647.0000,446353.0000,441074.0000,441734.0000,441465.0000,441634.0000,441655.0000,441594.0000,441484.0000,440913.0000,447255.0000,441464.0000,442596.0000,440312.0000,440973.0000,440933.0000,441294.0000,441804.0000,441203.0000,452766.0000,443398.0000,443738.0000,441855.0000,442316.0000,442807.0000,442456.0000,441774.0000,441955.0000,446654.0000,441574.0000,442286.0000,442917.0000,441494.0000,441624.0000,441524.0000,441364.0000,441514.0000,452365.0000,442656.0000,442405.0000,442486.0000,442536.0000,442346.0000,442756.0000,442126.0000,442185.0000,483594.0000,443478.0000,442456.0000,442717.0000,443458.0000,443017.0000,442166.0000,441935.0000,441975.0000,447596.0000,441033.0000,442085.0000,442356.0000,441204.0000,441654.0000,441604.0000,441023.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,48788300,488971.5700,488453.6700,489724.9700,3156.1896,2349.5938,4133.2921,"488393.0000,486650.0000,499554.0000,488824.0000,487912.0000,502250.0000,488613.0000,488233.0000,488163.0000,486950.0000,486560.0000,486719.0000,486699.0000,493954.0000,487341.0000,487441.0000,487211.0000,489485.0000,487892.0000,488643.0000,487291.0000,500175.0000,488864.0000,488803.0000,488454.0000,487792.0000,487321.0000,488623.0000,487170.0000,495086.0000,487932.0000,487782.0000,488534.0000,489134.0000,488072.0000,487641.0000,487311.0000,499474.0000,487271.0000,487201.0000,487231.0000,488523.0000,487071.0000,487631.0000,488173.0000,495306.0000,488544.0000,488533.0000,486870.0000,488193.0000,487772.0000,486870.0000,488162.0000,488423.0000,493973.0000,488453.0000,488092.0000,488263.0000,487040.0000,487081.0000,488533.0000,487582.0000,498943.0000,488152.0000,488644.0000,489285.0000,487912.0000,487551.0000,487451.0000,487491.0000,493893.0000,487973.0000,486950.0000,487531.0000,488352.0000,487781.0000,487822.0000,487562.0000,491929.0000,487481.0000,487501.0000,488403.0000,488063.0000,486770.0000,488583.0000,488143.0000,496508.0000,487041.0000,488313.0000,488042.0000,488694.0000,488102.0000,488073.0000,487591.0000,486570.0000,492050.0000,488092.0000,488975.0000,487551.0000,487652.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,213714300,2163658.5400,2161486.5200,2168936.7100,16132.9985,8319.9940,32140.2295,"2155951.0000,2163095.0000,2205384.0000,2170709.0000,2164257.0000,2158456.0000,2170107.0000,2154738.0000,2160730.0000,2152154.0000,2158947.0000,2155660.0000,2173715.0000,2158215.0000,2162754.0000,2151933.0000,2159768.0000,2170369.0000,2155470.0000,2163184.0000,2152384.0000,2163015.0000,2154468.0000,2174175.0000,2154679.0000,2168234.0000,2157644.0000,2168986.0000,2157865.0000,2165128.0000,2167553.0000,2157073.0000,2161652.0000,2159738.0000,2163746.0000,2293150.0000,2163915.0000,2156431.0000,2161512.0000,2153266.0000,2177341.0000,2159478.0000,2159387.0000,2165348.0000,2159698.0000,2174516.0000,2158947.0000,2164978.0000,2155320.0000,2164838.0000,2160459.0000,2170308.0000,2158074.0000,2162984.0000,2175147.0000,2160149.0000,2164948.0000,2155510.0000,2172482.0000,2157434.0000,2161031.0000,2154738.0000,2159717.0000,2153957.0000,2166100.0000,2162503.0000,2155791.0000,2167292.0000,2152494.0000,2157384.0000,2152233.0000,2157403.0000,2157284.0000,2167402.0000,2155530.0000,2163184.0000,2157344.0000,2167923.0000,2161421.0000,2156903.0000,2162002.0000,2156532.0000,2167523.0000,2157033.0000,2158997.0000,2158435.0000,2169636.0000,2157835.0000,2159457.0000,2156141.0000,2168405.0000,2166511.0000,2152294.0000,2163846.0000,2155540.0000,2169968.0000,2159057.0000,2161441.0000,2157043.0000,2222968.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,jacobi topology,100,1,79644800,797764.3700,796883.3100,799179.9200,5595.9990,4063.9419,9209.5464,"794963.0000,795675.0000,804302.0000,797708.0000,804140.0000,798119.0000,798420.0000,797509.0000,797809.0000,809060.0000,796406.0000,795935.0000,795084.0000,793851.0000,803841.0000,795474.0000,794343.0000,794543.0000,796015.0000,808780.0000,797348.0000,797408.0000,795524.0000,795926.0000,803189.0000,796186.0000,796967.0000,795244.0000,795083.0000,812066.0000,796607.0000,796847.0000,797799.0000,794563.0000,802528.0000,794723.0000,796377.0000,796196.0000,795715.0000,809381.0000,795264.0000,793661.0000,793601.0000,793220.0000,803791.0000,795765.0000,796336.0000,795805.0000,794774.0000,800524.0000,795565.0000,795254.0000,794042.0000,794663.0000,832895.0000,795355.0000,796426.0000,794903.0000,793019.0000,801666.0000,795655.0000,793731.0000,796246.0000,796707.0000,805183.0000,795104.0000,795565.0000,794863.0000,793832.0000,810603.0000,797428.0000,796076.0000,796877.0000,795044.0000,801827.0000,793721.0000,793731.0000,795184.0000,792249.0000,808279.0000,794653.0000,795865.0000,793922.0000,796366.0000,800664.0000,796236.0000,794794.0000,795665.0000,795003.0000,801797.0000,795635.0000,794493.0000,795695.0000,794192.0000,809431.0000,795224.0000,795414.0000,794363.0000,792980.0000,801957.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,soup topology,100,1,2979750800,30091567.8700,29841316.0900,30409798.1500,1429369.1169,1148460.6393,1741787.4654,"30376102.0000,29499672.0000,27783992.0000,30911596.0000,30001382.0000,32728777.0000,29435801.0000,29331183.0000,28920717.0000,29218740.0000,29494772.0000,28397785.0000,29022098.0000,29762430.0000,29420803.0000,28279832.0000,29536241.0000,28793094.0000,29438356.0000,28383949.0000,28072379.0000,28192486.0000,31116263.0000,30022483.0000,29802184.0000,30297693.0000,29635199.0000,29384755.0000,28903835.0000,30534862.0000,34263673.0000,29883168.0000,34426763.0000,30446025.0000,30410045.0000,30257277.0000,30535754.0000,29928174.0000,30942876.0000,30040386.0000,30673214.0000,29868851.0000,30118344.0000,29691246.0000,29735358.0000,30358538.0000,34000736.0000,28921448.0000,30167817.0000,29650789.0000,30030167.0000,29337365.0000,30614764.0000,30130406.0000,30837425.0000,34181668.0000,30517810.0000,29523438.0000,30699244.0000,29345931.0000,29205365.0000,32562953.0000,29303621.0000,28753138.0000,28488848.0000,29095246.0000,33074461.0000,29670606.0000,29336914.0000,28200932.0000,30174710.0000,30509985.0000,30023875.0000,29876686.0000,29961987.0000,30246536.0000,30160684.0000,30186383.0000,30601679.0000,34145450.0000,29919477.0000,29178133.0000,29665918.0000,28772345.0000,28384570.0000,29322797.0000,29056262.0000,28449223.0000,30097113.0000,30145676.0000,29484413.0000,34097498.0000,30610256.0000,29064608.0000,30637367.0000,29571558.0000,29669463.0000,34139590.0000,30682402.0000,30389898.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,chain topology,100,1,73345500,675788.3200,654306.5300,693606.6200,99562.6860,86349.4352,110295.6718,"727816.0000,741131.0000,436415.0000,508251.0000,503521.0000,494634.0000,502490.0000,501057.0000,508632.0000,501798.0000,500827.0000,502490.0000,500906.0000,502048.0000,500285.0000,499264.0000,510545.0000,501368.0000,504673.0000,501057.0000,499804.0000,501879.0000,498272.0000,501949.0000,510675.0000,502941.0000,650229.0000,733226.0000,737144.0000,751651.0000,735501.0000,733146.0000,728297.0000,728678.0000,729660.0000,733086.0000,742123.0000,731103.0000,736984.0000,728858.0000,736543.0000,742624.0000,728808.0000,731363.0000,734609.0000,738246.0000,736333.0000,732575.0000,728457.0000,729239.0000,729028.0000,725972.0000,737965.0000,730200.0000,725371.0000,726503.0000,727716.0000,739809.0000,727396.0000,728728.0000,726313.0000,728809.0000,739919.0000,743416.0000,728858.0000,729119.0000,727115.0000,735060.0000,728467.0000,728387.0000,729660.0000,733327.0000,726855.0000,733998.0000,738696.0000,727475.0000,726544.0000,733818.0000,731754.0000,736372.0000,728317.0000,731744.0000,737926.0000,735992.0000,728207.0000,740050.0000,730391.0000,728057.0000,725402.0000,725692.0000,743967.0000,727636.0000,728918.0000,736392.0000,728738.0000,728788.0000,744859.0000,733948.0000,728868.0000,729079.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,expanding tree topology,100,1,96290800,931762.9200,909704.7500,947039.6600,93163.7006,69948.4822,116092.0239,"960156.0000,959966.0000,630863.0000,663915.0000,714882.0000,660479.0000,657183.0000,655189.0000,656882.0000,657323.0000,667853.0000,662733.0000,725983.0000,952011.0000,957291.0000,975826.0000,975505.0000,961549.0000,961318.0000,975475.0000,967350.0000,963152.0000,958433.0000,980946.0000,962872.0000,959876.0000,961770.0000,967610.0000,958403.0000,956820.0000,960227.0000,974904.0000,964534.0000,958914.0000,961940.0000,959916.0000,970426.0000,962170.0000,962370.0000,963663.0000,980755.0000,959865.0000,955126.0000,958543.0000,970917.0000,962120.0000,959485.0000,959054.0000,971648.0000,959095.0000,963382.0000,956739.0000,970546.0000,961449.0000,966979.0000,963643.0000,971227.0000,968692.0000,962451.0000,960057.0000,976377.0000,966679.0000,961139.0000,957862.0000,960096.0000,978731.0000,964915.0000,960818.0000,959706.0000,975525.0000,960346.0000,959194.0000,961979.0000,971117.0000,961980.0000,963212.0000,963652.0000,978060.0000,963723.0000,959865.0000,962911.0000,972209.0000,958924.0000,961559.0000,958844.0000,977890.0000,962942.0000,960988.0000,960197.0000,966438.0000,975565.0000,961448.0000,964875.0000,958794.0000,971368.0000,961018.0000,960087.0000,960086.0000,966389.0000,958333.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,contracting tree topology,100,1,105126000,1009019.8700,983599.7700,1027587.8600,108839.7878,84484.5382,131947.7811,"1048774.0000,1067220.0000,793741.0000,713379.0000,721124.0000,719471.0000,715473.0000,723899.0000,719621.0000,719681.0000,719731.0000,710573.0000,717668.0000,733948.0000,767812.0000,1039146.0000,1048443.0000,1069203.0000,1051068.0000,1047151.0000,1044526.0000,1064083.0000,1051689.0000,1039496.0000,1047461.0000,1051559.0000,1045047.0000,1042592.0000,1060766.0000,1049185.0000,1051339.0000,1044567.0000,1062550.0000,1047332.0000,1044677.0000,1041711.0000,1062039.0000,1043844.0000,1049485.0000,1051068.0000,1061779.0000,1044176.0000,1052932.0000,1039666.0000,1065626.0000,1039537.0000,1046039.0000,1056820.0000,1045748.0000,1044526.0000,1045268.0000,1055607.0000,1043384.0000,1070084.0000,1044325.0000,1055307.0000,1053644.0000,1050057.0000,1049365.0000,1065226.0000,1045227.0000,1049956.0000,1048384.0000,1054325.0000,1055447.0000,1046400.0000,1067299.0000,1047832.0000,1044135.0000,1038805.0000,1059114.0000,1042192.0000,1047952.0000,1049786.0000,1054525.0000,1040429.0000,1042903.0000,1045859.0000,1065837.0000,1050117.0000,1048073.0000,1046270.0000,1063913.0000,1041110.0000,1048995.0000,1048193.0000,1064002.0000,1051469.0000,1055227.0000,1047231.0000,1046239.0000,1045869.0000,1048814.0000,1056789.0000,1054995.0000,1054154.0000,1054616.0000,1063492.0000,1050498.0000,1044256.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,wave_sim topology,100,1,534722200,5305904.9300,5221351.5900,5341713.5000,284866.2531,161399.9829,455449.2570,"5355961.0000,5354979.0000,3646513.0000,3682161.0000,3740060.0000,5365919.0000,5345070.0000,5366891.0000,5330332.0000,5346844.0000,5359347.0000,5332817.0000,5364347.0000,5347124.0000,5351693.0000,5365790.0000,5341353.0000,5350701.0000,5383864.0000,5349118.0000,5358646.0000,5357573.0000,5348576.0000,5362843.0000,5350039.0000,5352424.0000,5353135.0000,5334550.0000,5348577.0000,5348828.0000,5365539.0000,5358716.0000,5340271.0000,5355870.0000,5336714.0000,5349388.0000,5358636.0000,5348036.0000,5364557.0000,5366822.0000,5368815.0000,5350310.0000,5355460.0000,5348917.0000,5355850.0000,5351502.0000,5355911.0000,5332497.0000,5474064.0000,5360709.0000,5377391.0000,5360600.0000,5377442.0000,5334380.0000,5355931.0000,5328890.0000,5338629.0000,5350490.0000,5351853.0000,5353176.0000,5364347.0000,5341744.0000,5358095.0000,5349288.0000,5343326.0000,5344088.0000,5350441.0000,5345150.0000,5348226.0000,5344729.0000,5338678.0000,5336073.0000,5356723.0000,5353246.0000,5368424.0000,5345661.0000,5360890.0000,5357563.0000,5358345.0000,5347756.0000,5368254.0000,5343347.0000,5406006.0000,5379225.0000,5383072.0000,5395345.0000,5364217.0000,5348376.0000,5348857.0000,5360690.0000,5359858.0000,5363254.0000,5366530.0000,5352734.0000,5352404.0000,5348928.0000,5364066.0000,5343417.0000,5361160.0000,5344519.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,jacobi topology,100,1,168512700,1644774.0900,1610157.0900,1666612.0200,138384.5800,95251.4775,184024.2099,"1679659.0000,1693565.0000,1151799.0000,1149265.0000,1149334.0000,1161527.0000,1152912.0000,1151499.0000,1153242.0000,1389720.0000,1689428.0000,1690008.0000,1679759.0000,1689207.0000,1680892.0000,1676473.0000,1695148.0000,1670021.0000,1688506.0000,1678717.0000,1685189.0000,1686943.0000,1674399.0000,1696401.0000,1682124.0000,1685470.0000,1679389.0000,1673738.0000,1699847.0000,1685180.0000,1705878.0000,1676693.0000,1690810.0000,1683876.0000,1682484.0000,1720046.0000,1684799.0000,1696531.0000,1676433.0000,1677755.0000,1703213.0000,1675941.0000,1695408.0000,1684888.0000,1700388.0000,1678978.0000,1672666.0000,1683396.0000,1672355.0000,1668497.0000,1674609.0000,1687083.0000,1679398.0000,1683366.0000,1694167.0000,1683326.0000,1692173.0000,1670211.0000,1672365.0000,1688185.0000,1675090.0000,1694466.0000,1673958.0000,1686943.0000,1681593.0000,1684338.0000,1689938.0000,1679829.0000,1689848.0000,1674669.0000,1690981.0000,1685680.0000,1681852.0000,1686762.0000,1675330.0000,1697593.0000,1682804.0000,1681202.0000,1684298.0000,1675290.0000,1685259.0000,1680740.0000,1689638.0000,1680280.0000,1682725.0000,1693495.0000,1682494.0000,1681963.0000,1685329.0000,1696240.0000,1683617.0000,1687153.0000,1696000.0000,1681092.0000,1694277.0000,1681673.0000,1684999.0000,1691241.0000,1686161.0000,1685290.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,2823099600,28586865.6100,28366194.6900,28730099.6200,892616.8617,636219.8248,1172864.4029,"28946464.0000,28935123.0000,28920856.0000,28875780.0000,29063345.0000,28791922.0000,25261237.0000,28293327.0000,28893995.0000,28916337.0000,28845323.0000,28082680.0000,25544883.0000,28936466.0000,29078234.0000,25277707.0000,28262179.0000,28941926.0000,28929362.0000,28880630.0000,28875881.0000,28907411.0000,28813673.0000,28814795.0000,28827669.0000,28879147.0000,28962606.0000,28909284.0000,28915716.0000,28810346.0000,28860141.0000,28892703.0000,28910096.0000,28886731.0000,28827499.0000,28887002.0000,28906098.0000,28899085.0000,25257328.0000,27552535.0000,29038489.0000,28882804.0000,25441207.0000,28000002.0000,28865591.0000,27474827.0000,26119241.0000,28894547.0000,28936365.0000,29043769.0000,29057986.0000,28773397.0000,28872174.0000,28915035.0000,28976692.0000,28921487.0000,28898634.0000,28828272.0000,28879247.0000,28807521.0000,28938569.0000,25918320.0000,27008125.0000,28833079.0000,28843709.0000,28913061.0000,28935002.0000,28865031.0000,28881942.0000,28814545.0000,28792282.0000,28853438.0000,28893264.0000,28918382.0000,28799426.0000,28954560.0000,28966151.0000,28878516.0000,28846545.0000,28855011.0000,28878425.0000,28887713.0000,28826758.0000,28911739.0000,29013041.0000,28870530.0000,28955611.0000,28927710.0000,29001419.0000,28906168.0000,28862014.0000,28900206.0000,28909525.0000,28882583.0000,28955261.0000,28851454.0000,28891140.0000,28841036.0000,28909083.0000,28895378.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,56325100,551161.9300,547438.2700,554971.6200,19141.3119,18466.2811,21276.2789,"569857.0000,569948.0000,578003.0000,569186.0000,569166.0000,568465.0000,569006.0000,568534.0000,597861.0000,533238.0000,533137.0000,533208.0000,532316.0000,532526.0000,532366.0000,532086.0000,539460.0000,532927.0000,531314.0000,531594.0000,533018.0000,532266.0000,531915.0000,534741.0000,533448.0000,532817.0000,532837.0000,532536.0000,532677.0000,533298.0000,532717.0000,535062.0000,532296.0000,532286.0000,532316.0000,532006.0000,531875.0000,532166.0000,544108.0000,532496.0000,532577.0000,532426.0000,532456.0000,532436.0000,532627.0000,532606.0000,533288.0000,532587.0000,532597.0000,532416.0000,533579.0000,531755.0000,532617.0000,541403.0000,532236.0000,531815.0000,532016.0000,531535.0000,532326.0000,533037.0000,531435.0000,572512.0000,569066.0000,569196.0000,569276.0000,569858.0000,569125.0000,568554.0000,574647.0000,569957.0000,569347.0000,568805.0000,569336.0000,569016.0000,569727.0000,575478.0000,569677.0000,569456.0000,569337.0000,569256.0000,567733.0000,569096.0000,574676.0000,569646.0000,568625.0000,570669.0000,568916.0000,568394.0000,570639.0000,574877.0000,569647.0000,569637.0000,569256.0000,568845.0000,569126.0000,569517.0000,576911.0000,569166.0000,569196.0000,569146.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,75190700,751267.6600,750512.5900,752420.7300,4706.3566,3520.6218,7070.6907,"750710.0000,750269.0000,760549.0000,749227.0000,749136.0000,748735.0000,763353.0000,749217.0000,748616.0000,748325.0000,748135.0000,777841.0000,751250.0000,749768.0000,747203.0000,748776.0000,748856.0000,750549.0000,748485.0000,748986.0000,747694.0000,747724.0000,760949.0000,746892.0000,748786.0000,750088.0000,750079.0000,756070.0000,749607.0000,748866.0000,749998.0000,749758.0000,747915.0000,762882.0000,749156.0000,749277.0000,749347.0000,749808.0000,756470.0000,749898.0000,749457.0000,749217.0000,748626.0000,755098.0000,750770.0000,750509.0000,749438.0000,748696.0000,749026.0000,754698.0000,750118.0000,749818.0000,749428.0000,749247.0000,749407.0000,748405.0000,749146.0000,749678.0000,750039.0000,763133.0000,749688.0000,749588.0000,748505.0000,748085.0000,750489.0000,757151.0000,750689.0000,748937.0000,749367.0000,749147.0000,763864.0000,749909.0000,750599.0000,750900.0000,750429.0000,758133.0000,750930.0000,748776.0000,749177.0000,749607.0000,749447.0000,752934.0000,749287.0000,750439.0000,750039.0000,749668.0000,763844.0000,749949.0000,749577.0000,749347.0000,749657.0000,756170.0000,750769.0000,749858.0000,750449.0000,750038.0000,748386.0000,759466.0000,750760.0000,749508.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,78470000,797120.1700,796557.6300,797879.8700,3301.7433,2593.0170,4109.4430,"808379.0000,796457.0000,805333.0000,797388.0000,794713.0000,799472.0000,794442.0000,795284.0000,794523.0000,795375.0000,798279.0000,795504.0000,793210.0000,796236.0000,796397.0000,801385.0000,796696.0000,796487.0000,795595.0000,795825.0000,800364.0000,795775.0000,793641.0000,795985.0000,794352.0000,808379.0000,797057.0000,796586.0000,795344.0000,796356.0000,799111.0000,797559.0000,795955.0000,795074.0000,794964.0000,797859.0000,797197.0000,795704.0000,794182.0000,795705.0000,807537.0000,796487.0000,795364.0000,796426.0000,795926.0000,797939.0000,794473.0000,796336.0000,796346.0000,797148.0000,807447.0000,796326.0000,795825.0000,795324.0000,795344.0000,796336.0000,795926.0000,795023.0000,794784.0000,794743.0000,800414.0000,797117.0000,795765.0000,795715.0000,796095.0000,802148.0000,796085.0000,796236.0000,795174.0000,795214.0000,800935.0000,795635.0000,793922.0000,796997.0000,796156.0000,804432.0000,795915.0000,795535.0000,794222.0000,795304.0000,801576.0000,796736.0000,794914.0000,796226.0000,795545.0000,803048.0000,795885.0000,795444.0000,795465.0000,795815.0000,806265.0000,795795.0000,795054.0000,796537.0000,794392.0000,804181.0000,795395.0000,796596.0000,795405.0000,797538.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,420319600,4203483.2700,4202517.8400,4204560.4100,5197.4565,4553.6458,6411.0246,"4195353.0000,4200693.0000,4213457.0000,4201224.0000,4195373.0000,4202707.0000,4200663.0000,4204320.0000,4198349.0000,4199731.0000,4196185.0000,4201154.0000,4205472.0000,4200893.0000,4197197.0000,4194631.0000,4201324.0000,4205562.0000,4197878.0000,4209230.0000,4202376.0000,4199932.0000,4209870.0000,4203227.0000,4203558.0000,4199140.0000,4212195.0000,4210271.0000,4207536.0000,4211975.0000,4200863.0000,4215251.0000,4199431.0000,4202767.0000,4208177.0000,4201384.0000,4205872.0000,4202105.0000,4203859.0000,4201574.0000,4207095.0000,4202055.0000,4210752.0000,4205162.0000,4200533.0000,4210712.0000,4209750.0000,4202507.0000,4202346.0000,4210942.0000,4203117.0000,4204070.0000,4211263.0000,4200914.0000,4209019.0000,4201905.0000,4199029.0000,4202947.0000,4197537.0000,4211103.0000,4199941.0000,4201895.0000,4206424.0000,4199401.0000,4204550.0000,4201665.0000,4223166.0000,4212826.0000,4198118.0000,4210422.0000,4200973.0000,4203509.0000,4203218.0000,4194200.0000,4203828.0000,4198589.0000,4203919.0000,4195173.0000,4204410.0000,4197918.0000,4200933.0000,4197237.0000,4196685.0000,4199180.0000,4205652.0000,4198689.0000,4208669.0000,4202426.0000,4212196.0000,4202917.0000,4207496.0000,4208628.0000,4209710.0000,4198558.0000,4205181.0000,4201034.0000,4200463.0000,4204660.0000,4198469.0000,4199882.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,130922900,1284853.5300,1275175.9600,1292742.9600,44328.0874,37653.7224,49852.6397,"1305420.0000,1305671.0000,1207645.0000,1205612.0000,1197115.0000,1195742.0000,1199620.0000,1196825.0000,1197736.0000,1196644.0000,1205341.0000,1198007.0000,1195943.0000,1200772.0000,1196404.0000,1197075.0000,1209959.0000,1197015.0000,1195532.0000,1195703.0000,1207274.0000,1196614.0000,1197416.0000,1270324.0000,1306602.0000,1305661.0000,1307845.0000,1306001.0000,1304669.0000,1310580.0000,1305280.0000,1307855.0000,1314978.0000,1306573.0000,1304678.0000,1307595.0000,1305831.0000,1305520.0000,1309598.0000,1304930.0000,1304308.0000,1316140.0000,1303667.0000,1306442.0000,1312012.0000,1302485.0000,1304088.0000,1310229.0000,1303166.0000,1307264.0000,1305801.0000,1315729.0000,1303096.0000,1306673.0000,1310960.0000,1302875.0000,1304168.0000,1315399.0000,1307424.0000,1306562.0000,1314738.0000,1306282.0000,1306923.0000,1309769.0000,1305570.0000,1303817.0000,1317564.0000,1307614.0000,1305350.0000,1307524.0000,1307184.0000,1306943.0000,1311211.0000,1308286.0000,1307554.0000,1311913.0000,1307053.0000,1306803.0000,1318525.0000,1308727.0000,1309057.0000,1312443.0000,1305640.0000,1304058.0000,1314788.0000,1303927.0000,1305260.0000,1309468.0000,1307705.0000,1303847.0000,1316541.0000,1307554.0000,1306973.0000,1307303.0000,1307363.0000,1305850.0000,1314327.0000,1308746.0000,1307885.0000,1313175.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,2054614600,20593415.4600,20581215.5100,20608161.0800,68013.2777,55714.1380,93678.7720,"20569260.0000,20602404.0000,20479922.0000,20526569.0000,20580221.0000,20591213.0000,20526990.0000,20558731.0000,20523594.0000,20646627.0000,20498657.0000,20630657.0000,20546869.0000,20598736.0000,20518253.0000,20590230.0000,20568509.0000,20577887.0000,20587655.0000,20595120.0000,20568909.0000,20655874.0000,20563449.0000,20615928.0000,20573718.0000,20537610.0000,20628373.0000,20639944.0000,20537099.0000,20542730.0000,20596111.0000,20652158.0000,20576364.0000,20579621.0000,20746636.0000,20620478.0000,20495951.0000,20605609.0000,20574991.0000,20711441.0000,20758048.0000,20756164.0000,20534254.0000,20580101.0000,20598916.0000,20596001.0000,20596543.0000,20550635.0000,20615588.0000,20594178.0000,20649753.0000,20591913.0000,20639072.0000,20601443.0000,20572777.0000,20501752.0000,20594307.0000,20536799.0000,20557067.0000,20661305.0000,20573209.0000,20706029.0000,20486112.0000,20563749.0000,20536388.0000,20581884.0000,20632781.0000,20644053.0000,20429486.0000,20550655.0000,20709776.0000,20613935.0000,20624896.0000,20549213.0000,20607694.0000,20560734.0000,20459532.0000,20623333.0000,20615488.0000,20565403.0000,20601120.0000,20722591.0000,20918742.0000,20570072.0000,20596021.0000,20596401.0000,20596312.0000,20585121.0000,20676975.0000,20555154.0000,20628342.0000,20580853.0000,20596211.0000,20648370.0000,20604628.0000,20507063.0000,20601241.0000,20651045.0000,20497985.0000,20545235.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,44209000,442285.4400,441403.1000,443964.9300,5995.1307,3805.0979,11469.0553,"443508.0000,450161.0000,487180.0000,447525.0000,443538.0000,438479.0000,436895.0000,441213.0000,437607.0000,437346.0000,443057.0000,442686.0000,443599.0000,441324.0000,436835.0000,442216.0000,437326.0000,437978.0000,441975.0000,436555.0000,437547.0000,452104.0000,439020.0000,443989.0000,443718.0000,441514.0000,442566.0000,436545.0000,437496.0000,437307.0000,447645.0000,436875.0000,436645.0000,436665.0000,442316.0000,436976.0000,442937.0000,443358.0000,441764.0000,445151.0000,443748.0000,442707.0000,442456.0000,436765.0000,437276.0000,437376.0000,437076.0000,443528.0000,442596.0000,443057.0000,437777.0000,442296.0000,443508.0000,442596.0000,442827.0000,442486.0000,442767.0000,448688.0000,442726.0000,445621.0000,438017.0000,437186.0000,436615.0000,443238.0000,443498.0000,443217.0000,451763.0000,442857.0000,438188.0000,438218.0000,437246.0000,443729.0000,444249.0000,438499.0000,444570.0000,447646.0000,449199.0000,443858.0000,445852.0000,443728.0000,445471.0000,437547.0000,443107.0000,449590.0000,450932.0000,443388.0000,445041.0000,443909.0000,437226.0000,443027.0000,437367.0000,436985.0000,437607.0000,450041.0000,442005.0000,437146.0000,443528.0000,438920.0000,443698.0000,443618.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,71837100,717836.1400,716437.9700,719210.1900,7072.4773,6301.3702,8103.1754,"724440.0000,721504.0000,736563.0000,722987.0000,709020.0000,712448.0000,713539.0000,712518.0000,731283.0000,712828.0000,725753.0000,719350.0000,712488.0000,709381.0000,721515.0000,712738.0000,717757.0000,721956.0000,722977.0000,728548.0000,720653.0000,720733.0000,707869.0000,711706.0000,717707.0000,709752.0000,710264.0000,716244.0000,723959.0000,724409.0000,733036.0000,724741.0000,719971.0000,720202.0000,712838.0000,705464.0000,719511.0000,706365.0000,723257.0000,708881.0000,712948.0000,712407.0000,726754.0000,705384.0000,723929.0000,706185.0000,713670.0000,722306.0000,710884.0000,711516.0000,713750.0000,710203.0000,712447.0000,705043.0000,723678.0000,716294.0000,701437.0000,719010.0000,724410.0000,706315.0000,722566.0000,718759.0000,722917.0000,708520.0000,722847.0000,722526.0000,723688.0000,708169.0000,701686.0000,723327.0000,725281.0000,724741.0000,724280.0000,720192.0000,725332.0000,731413.0000,718579.0000,718779.0000,712878.0000,720392.0000,714792.0000,725502.0000,719270.0000,724039.0000,726374.0000,718208.0000,715593.0000,722657.0000,722426.0000,717257.0000,707849.0000,716394.0000,717967.0000,717758.0000,716605.0000,720563.0000,712948.0000,722206.0000,722827.0000,719782.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,77309900,773797.5600,772956.8500,775106.6000,5261.2977,3783.9327,8616.3577,"770978.0000,780807.0000,806585.0000,792459.0000,774926.0000,773864.0000,773793.0000,773233.0000,780626.0000,776539.0000,774305.0000,771268.0000,772991.0000,784944.0000,776759.0000,766609.0000,772602.0000,768243.0000,777410.0000,774415.0000,772331.0000,770918.0000,773252.0000,771929.0000,777761.0000,772601.0000,770537.0000,770989.0000,771829.0000,778913.0000,768924.0000,772100.0000,767762.0000,774985.0000,781538.0000,771429.0000,771940.0000,771108.0000,775186.0000,782470.0000,773392.0000,774975.0000,772602.0000,767050.0000,772711.0000,772972.0000,775276.0000,768673.0000,769776.0000,777090.0000,773663.0000,773803.0000,774575.0000,773393.0000,766800.0000,780196.0000,773783.0000,772771.0000,772431.0000,771319.0000,775908.0000,770116.0000,771008.0000,775216.0000,771158.0000,770448.0000,771519.0000,768123.0000,773733.0000,772611.0000,777811.0000,773753.0000,771810.0000,772210.0000,773673.0000,780676.0000,772961.0000,772941.0000,774174.0000,773402.0000,778382.0000,768864.0000,772371.0000,767732.0000,768724.0000,768764.0000,780256.0000,769065.0000,773142.0000,772391.0000,772330.0000,771699.0000,772992.0000,766991.0000,772942.0000,776599.0000,779945.0000,772932.0000,773102.0000,768173.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,322276900,3228113.9800,3225417.7700,3233076.9700,18058.3378,11442.5141,33834.9605,"3236707.0000,3207993.0000,3252447.0000,3227831.0000,3223282.0000,3220326.0000,3210578.0000,3221579.0000,3220607.0000,3211600.0000,3216920.0000,3212722.0000,3229213.0000,3222932.0000,3218743.0000,3234914.0000,3225967.0000,3282544.0000,3219796.0000,3237439.0000,3219325.0000,3218002.0000,3237629.0000,3224845.0000,3232129.0000,3223553.0000,3239474.0000,3238010.0000,3225907.0000,3360171.0000,3223844.0000,3225877.0000,3216539.0000,3227991.0000,3225356.0000,3227059.0000,3225937.0000,3214175.0000,3219485.0000,3239202.0000,3211990.0000,3200319.0000,3199407.0000,3228672.0000,3224655.0000,3223052.0000,3223352.0000,3210839.0000,3215517.0000,3220858.0000,3213594.0000,3242618.0000,3227780.0000,3252408.0000,3225776.0000,3231307.0000,3239022.0000,3219435.0000,3232329.0000,3244032.0000,3217491.0000,3227550.0000,3222982.0000,3221078.0000,3215748.0000,3232930.0000,3238221.0000,3232580.0000,3209876.0000,3217371.0000,3234213.0000,3232148.0000,3239974.0000,3215838.0000,3222620.0000,3243972.0000,3245254.0000,3226869.0000,3217110.0000,3235135.0000,3218132.0000,3235485.0000,3238460.0000,3244362.0000,3242198.0000,3238861.0000,3236457.0000,3239432.0000,3222240.0000,3221087.0000,3224504.0000,3226568.0000,3210026.0000,3233261.0000,3205158.0000,3240043.0000,3240134.0000,3226909.0000,3222571.0000,3210938.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,119329400,1195272.8500,1193895.0800,1196662.4200,7067.5854,6116.8671,8515.9664,"1204549.0000,1188719.0000,1214989.0000,1218917.0000,1199409.0000,1197687.0000,1202004.0000,1190162.0000,1197025.0000,1182788.0000,1202074.0000,1192146.0000,1200632.0000,1198027.0000,1202726.0000,1193368.0000,1201393.0000,1186345.0000,1195312.0000,1196173.0000,1200833.0000,1191645.0000,1192386.0000,1190632.0000,1201643.0000,1187217.0000,1203938.0000,1191555.0000,1185533.0000,1195021.0000,1199049.0000,1196544.0000,1191304.0000,1191915.0000,1199590.0000,1193899.0000,1190352.0000,1193388.0000,1190853.0000,1196534.0000,1193348.0000,1187677.0000,1180063.0000,1204248.0000,1193528.0000,1191334.0000,1181195.0000,1195482.0000,1195542.0000,1203447.0000,1201554.0000,1197445.0000,1178239.0000,1194400.0000,1183339.0000,1190503.0000,1195743.0000,1194750.0000,1199209.0000,1185824.0000,1202124.0000,1192597.0000,1192867.0000,1194771.0000,1200892.0000,1192105.0000,1193639.0000,1194540.0000,1198137.0000,1207344.0000,1196855.0000,1202726.0000,1200171.0000,1204829.0000,1191564.0000,1185463.0000,1191795.0000,1185763.0000,1195111.0000,1182167.0000,1200131.0000,1195231.0000,1195702.0000,1204409.0000,1204028.0000,1198317.0000,1202936.0000,1194180.0000,1192576.0000,1190061.0000,1199750.0000,1193578.0000,1182448.0000,1206102.0000,1199951.0000,1195091.0000,1194901.0000,1194590.0000,1201232.0000,1181465.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,soup topology,100,1,6382793700,63781528.3700,63619800.7000,63879486.9100,629281.3743,431884.2227,969388.2668,"63741546.0000,63742579.0000,61441621.0000,61649665.0000,63691272.0000,63950402.0000,63974207.0000,64040432.0000,63822981.0000,64047235.0000,64006318.0000,64139890.0000,61756818.0000,63736949.0000,64003141.0000,63756215.0000,63657587.0000,64504171.0000,64090206.0000,64718848.0000,64568402.0000,63837589.0000,63854530.0000,62365111.0000,63957766.0000,63888444.0000,63996891.0000,64019353.0000,63844502.0000,63628262.0000,63866584.0000,63691632.0000,63872906.0000,63766032.0000,63851846.0000,64344277.0000,63943730.0000,63849450.0000,63829432.0000,63745384.0000,63780610.0000,63922039.0000,63969297.0000,63784338.0000,64258324.0000,64043619.0000,64033008.0000,63804446.0000,63935664.0000,64099945.0000,64280156.0000,64126135.0000,64238819.0000,64314291.0000,62664127.0000,60037041.0000,64073796.0000,63888936.0000,63751466.0000,63787163.0000,64361551.0000,64080869.0000,64027408.0000,64408750.0000,63933570.0000,63879018.0000,63992060.0000,64013672.0000,63913622.0000,63774390.0000,63875189.0000,63935926.0000,63946384.0000,64034302.0000,63821888.0000,62693914.0000,63696931.0000,63761915.0000,63802382.0000,64260930.0000,63940714.0000,63833119.0000,63818061.0000,63956363.0000,63818142.0000,63426720.0000,63060727.0000,63652247.0000,63749171.0000,63812791.0000,63936966.0000,63649904.0000,63898403.0000,63797172.0000,63856103.0000,63903924.0000,64090257.0000,63767276.0000,63929162.0000,64053518.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,chain topology,100,1,348762000,3447839.4900,3417495.1300,3468869.9000,127320.1146,94147.1779,159906.6768,"3491980.0000,3502500.0000,3561482.0000,3492663.0000,3483895.0000,3485458.0000,3503493.0000,3501479.0000,3488805.0000,3494035.0000,3497852.0000,3489827.0000,3480469.0000,3488795.0000,3498754.0000,3495839.0000,3501619.0000,3492612.0000,3491691.0000,3502130.0000,3471152.0000,3480910.0000,3493053.0000,3488875.0000,3487172.0000,3486771.0000,3479296.0000,3476601.0000,3470720.0000,3491621.0000,3479537.0000,3483695.0000,3494435.0000,3493043.0000,3494897.0000,3490318.0000,3488104.0000,3482994.0000,3650882.0000,3482372.0000,3492341.0000,3482443.0000,3477273.0000,3493954.0000,3484768.0000,3485999.0000,3492301.0000,3506980.0000,3487422.0000,3489126.0000,3484036.0000,3472123.0000,3487944.0000,3493694.0000,3478465.0000,3490168.0000,3501709.0000,3483174.0000,3484286.0000,3480339.0000,3485349.0000,3495638.0000,3488124.0000,3477613.0000,3492952.0000,3412290.0000,3063409.0000,3071996.0000,3063439.0000,3079119.0000,3076464.0000,3061045.0000,3081503.0000,3078728.0000,3071124.0000,3067147.0000,3429482.0000,3490539.0000,3486270.0000,3499435.0000,3495367.0000,3493824.0000,3484858.0000,3490929.0000,3490999.0000,3497592.0000,3496058.0000,3484727.0000,3489206.0000,3486961.0000,3472154.0000,3482443.0000,3489877.0000,3476662.0000,3483505.0000,3494065.0000,3483365.0000,3489326.0000,3477002.0000,3492992.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,970845600,9701693.9600,9673435.7800,9711287.8000,76899.9338,26059.9849,166107.4091,"9704025.0000,9674458.0000,9706569.0000,9706189.0000,9711659.0000,9731336.0000,9716438.0000,9708713.0000,9730004.0000,9677785.0000,9697973.0000,9726577.0000,9682624.0000,9717811.0000,9691601.0000,9701681.0000,9699406.0000,9686461.0000,9713212.0000,9694978.0000,9740083.0000,9731978.0000,9751885.0000,9683126.0000,9717340.0000,9697231.0000,9694937.0000,9708534.0000,9695478.0000,9720155.0000,9716077.0000,9742658.0000,9745543.0000,9730245.0000,9752907.0000,9028676.0000,9416460.0000,9720456.0000,9731287.0000,9706089.0000,9735584.0000,9687643.0000,9730275.0000,9711579.0000,9744462.0000,9712010.0000,9726026.0000,9715377.0000,9698975.0000,9690479.0000,9729433.0000,9714084.0000,9712240.0000,9745573.0000,9716789.0000,9688766.0000,9708534.0000,9692753.0000,9714475.0000,9730665.0000,9707662.0000,9717230.0000,9699286.0000,9732609.0000,9712130.0000,9696311.0000,9717070.0000,9689788.0000,9682093.0000,9731978.0000,9715537.0000,9700829.0000,9834171.0000,9702141.0000,9717550.0000,9723091.0000,9709064.0000,9702302.0000,9706750.0000,9724464.0000,9685841.0000,9710206.0000,9707721.0000,9752336.0000,9694577.0000,9710747.0000,9700658.0000,9708854.0000,9679238.0000,9714485.0000,9690840.0000,9713212.0000,9699987.0000,9695930.0000,9685821.0000,9672135.0000,9708533.0000,9707622.0000,9682905.0000,9709325.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,389506300,3897731.1100,3895714.5700,3903700.3300,16227.0835,6848.9668,35420.8985,"3886398.0000,3888872.0000,3896006.0000,3890525.0000,3890605.0000,3914571.0000,3888512.0000,3900534.0000,3907277.0000,3896918.0000,3889544.0000,3898952.0000,3899783.0000,3896878.0000,3897319.0000,3894804.0000,3888341.0000,3895365.0000,3887290.0000,3905704.0000,3891738.0000,3904251.0000,3886879.0000,3900425.0000,3905093.0000,3897619.0000,3908088.0000,3896747.0000,3904723.0000,3886698.0000,3897890.0000,3895074.0000,3894553.0000,3902639.0000,3901226.0000,3900374.0000,3893101.0000,3895205.0000,3911385.0000,3896758.0000,3895886.0000,3896938.0000,3898160.0000,3899452.0000,3886267.0000,3891256.0000,3895334.0000,3895905.0000,3890826.0000,3881068.0000,3901917.0000,3880507.0000,3892940.0000,3890675.0000,3884113.0000,3903941.0000,3891196.0000,3893021.0000,3892529.0000,3905183.0000,3885847.0000,3887550.0000,3892099.0000,4042974.0000,3907417.0000,3892178.0000,3904172.0000,3896768.0000,3902047.0000,3903450.0000,3901486.0000,3902879.0000,3893792.0000,3892460.0000,3903550.0000,3893331.0000,3896156.0000,3912056.0000,3901165.0000,3908840.0000,3896046.0000,3903681.0000,3899102.0000,3890335.0000,3900855.0000,3889674.0000,3892760.0000,3903029.0000,3892229.0000,3908089.0000,3890095.0000,3889724.0000,3901728.0000,3889203.0000,3881749.0000,3897929.0000,3892991.0000,3894022.0000,3885136.0000,3902739.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,1562867200,15680699.0100,15591908.8600,15718985.9200,280825.9371,120516.8003,479075.8476,"15738863.0000,15791362.0000,15735777.0000,15730537.0000,15729816.0000,15766766.0000,15708576.0000,15321182.0000,13887096.0000,13906563.0000,15715509.0000,15736378.0000,15721150.0000,15728844.0000,15737410.0000,15694489.0000,15715248.0000,15721941.0000,15738863.0000,15719718.0000,15729766.0000,15725938.0000,15711561.0000,15700540.0000,15710619.0000,15737561.0000,15753711.0000,15726931.0000,15719877.0000,15734935.0000,15734174.0000,15732601.0000,15754633.0000,15747509.0000,15760143.0000,15733673.0000,15723083.0000,15760163.0000,15749203.0000,15742359.0000,15749904.0000,15726830.0000,15703797.0000,15725508.0000,15716341.0000,15719567.0000,15743662.0000,15711992.0000,15744354.0000,15851696.0000,15726038.0000,15702043.0000,15701973.0000,15687857.0000,15714166.0000,15739654.0000,15713424.0000,15733402.0000,15721150.0000,15726940.0000,15715628.0000,15699007.0000,15719076.0000,15672467.0000,15683378.0000,15705480.0000,15708916.0000,15699067.0000,15752179.0000,15747399.0000,15717884.0000,15735457.0000,15739504.0000,15891603.0000,15742399.0000,15723474.0000,15720147.0000,15689019.0000,15701392.0000,15702866.0000,15737831.0000,15734174.0000,15722261.0000,15730317.0000,15728444.0000,15714396.0000,15744573.0000,15750405.0000,15747089.0000,15752489.0000,14655702.0000,15797644.0000,15772486.0000,15762548.0000,15743171.0000,15760894.0000,15778569.0000,15717582.0000,15732871.0000,15724747.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,jacobi topology,100,1,536615600,5447799.7200,5445284.6200,5454450.6700,19432.4397,9345.9243,41148.9195,"5448105.0000,5447163.0000,5447434.0000,5437606.0000,5456591.0000,5434360.0000,5429840.0000,5474845.0000,5443957.0000,5436113.0000,5452544.0000,5449979.0000,5435982.0000,5444238.0000,5431093.0000,5444499.0000,5439449.0000,5442925.0000,5443276.0000,5436864.0000,5433819.0000,5457473.0000,5444849.0000,5440771.0000,5458485.0000,5430813.0000,5434049.0000,5463234.0000,5455429.0000,5451822.0000,5451772.0000,5439148.0000,5460028.0000,5451372.0000,5456281.0000,5464526.0000,5441463.0000,5448807.0000,5461611.0000,5447604.0000,5464827.0000,5443977.0000,5445681.0000,5457262.0000,5448566.0000,5443648.0000,5457483.0000,5452954.0000,5449297.0000,5478834.0000,5445380.0000,5446823.0000,5436994.0000,5442465.0000,5614911.0000,5452724.0000,5442885.0000,5455569.0000,5447313.0000,5454737.0000,5447313.0000,5453947.0000,5452283.0000,5435081.0000,5442174.0000,5453766.0000,5450360.0000,5438557.0000,5438598.0000,5427416.0000,5432336.0000,5431264.0000,5431934.0000,5441753.0000,5441453.0000,5452223.0000,5448757.0000,5442354.0000,5438457.0000,5457283.0000,5438327.0000,5449358.0000,5451592.0000,5448676.0000,5448797.0000,5448997.0000,5430422.0000,5449598.0000,5434059.0000,5453035.0000,5457313.0000,5436493.0000,5448266.0000,5432586.0000,5435692.0000,5428278.0000,5446392.0000,5448766.0000,5445751.0000,5437716.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,soup topology,100,1,6874210300,67072582.0700,66551484.9200,67508750.0500,2418759.3693,2105586.8315,2871189.7628,"69119200.0000,64883519.0000,61394102.0000,62970436.0000,68538922.0000,67170660.0000,67289897.0000,67639097.0000,68155125.0000,69004523.0000,65213244.0000,69607504.0000,63377136.0000,68659810.0000,64043038.0000,68113896.0000,68289810.0000,63599657.0000,68585059.0000,68297144.0000,69661478.0000,67836180.0000,68761663.0000,63489038.0000,66925146.0000,65907117.0000,65822468.0000,68315678.0000,68905115.0000,69123458.0000,68523483.0000,64049089.0000,68919964.0000,68159172.0000,67098264.0000,62251485.0000,58670805.0000,68139615.0000,68154213.0000,68816798.0000,68543871.0000,69201345.0000,69318067.0000,68403365.0000,68913201.0000,68877352.0000,68510698.0000,69221855.0000,69598769.0000,69235882.0000,69055799.0000,68533972.0000,68307583.0000,67933215.0000,69489531.0000,64708558.0000,63231139.0000,68687764.0000,68976289.0000,69398119.0000,62431606.0000,62089599.0000,66999576.0000,68172368.0000,66918472.0000,63925866.0000,67557182.0000,68211111.0000,68712910.0000,68048393.0000,63507293.0000,69374544.0000,68230106.0000,68240046.0000,69033778.0000,67529851.0000,68563858.0000,69248195.0000,62787159.0000,69987656.0000,69195805.0000,63823763.0000,67840539.0000,67824760.0000,67457824.0000,67525463.0000,67902065.0000,67675547.0000,61577378.0000,68104258.0000,68444883.0000,63645024.0000,63324807.0000,63495121.0000,66332052.0000,63934533.0000,67951058.0000,64793489.0000,68810365.0000,68401522.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,chain topology,100,1,369332600,3561542.6700,3529663.4500,3625593.8300,221258.4372,107372.2332,369843.4372,"3422088.0000,3662163.0000,3356424.0000,3222992.0000,4836237.0000,5005377.0000,3388335.0000,3441705.0000,3587562.0000,3671120.0000,3523551.0000,3385780.0000,3537157.0000,3389927.0000,3492882.0000,3690658.0000,3607730.0000,3474318.0000,3654118.0000,3612208.0000,3558517.0000,3566191.0000,3376072.0000,3614984.0000,3398434.0000,3597441.0000,3511918.0000,3538168.0000,3396971.0000,3594635.0000,3481020.0000,3462595.0000,3608812.0000,3647896.0000,3485369.0000,3525033.0000,3654358.0000,3637427.0000,3535784.0000,3393584.0000,3489947.0000,3562534.0000,3505286.0000,3565139.0000,3515154.0000,3571161.0000,3690877.0000,3734500.0000,3383034.0000,3466152.0000,3726174.0000,3463977.0000,3583113.0000,3644670.0000,3618831.0000,3414123.0000,3712258.0000,3689705.0000,3526767.0000,3645041.0000,3410828.0000,3550091.0000,3550732.0000,3593894.0000,3372946.0000,3763154.0000,3630343.0000,3399706.0000,3672343.0000,3446725.0000,3582152.0000,3652274.0000,3661241.0000,3543058.0000,3573415.0000,3646303.0000,3615475.0000,3393344.0000,3642807.0000,3394616.0000,3396299.0000,3579376.0000,3376462.0000,3515215.0000,3446875.0000,3418402.0000,3494726.0000,3398825.0000,3586901.0000,3587762.0000,3527699.0000,3527037.0000,3435233.0000,3489316.0000,3460552.0000,3554289.0000,3641113.0000,3536725.0000,3398063.0000,3631966.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,expanding tree topology,100,1,662103900,6566341.7100,6541201.8000,6591454.6400,128969.0139,115662.3090,146857.3498,"6625575.0000,6648438.0000,6339073.0000,6406660.0000,6422610.0000,6434884.0000,6598684.0000,6343240.0000,6611048.0000,6536456.0000,6592763.0000,6346987.0000,6675820.0000,6506650.0000,6479979.0000,6522229.0000,6503183.0000,6372906.0000,6588655.0000,6466063.0000,6534943.0000,6388215.0000,6389017.0000,6464409.0000,6513372.0000,6609645.0000,6588044.0000,6497081.0000,6591951.0000,6612180.0000,6509004.0000,6620115.0000,6649030.0000,6471273.0000,6402442.0000,6577424.0000,6573226.0000,6660882.0000,6542748.0000,6584658.0000,6580840.0000,6453369.0000,6548038.0000,6493806.0000,6605086.0000,6368408.0000,6650021.0000,6671853.0000,6682424.0000,6654319.0000,6667885.0000,6672865.0000,6633019.0000,6623912.0000,6690077.0000,6507030.0000,6390950.0000,6463849.0000,6448380.0000,6215980.0000,6349482.0000,6554090.0000,6460693.0000,6346937.0000,6530645.0000,6480901.0000,6358339.0000,6536576.0000,6480291.0000,6594426.0000,6433751.0000,6464540.0000,6435064.0000,6440465.0000,6759990.0000,6845101.0000,6745783.0000,6583255.0000,6791289.0000,6740954.0000,6739440.0000,6740763.0000,6618662.0000,6739170.0000,6586380.0000,6686390.0000,6724142.0000,6799124.0000,6806899.0000,6663287.0000,6688624.0000,6704905.0000,6569860.0000,6721867.0000,6714643.0000,6552998.0000,6676572.0000,6812138.0000,6706277.0000,6625785.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,contracting tree topology,100,1,397939300,3932030.0000,3912971.7000,3949181.1100,92138.3135,81061.5885,106061.2618,"3780026.0000,3845219.0000,3982460.0000,3872301.0000,3900785.0000,3885867.0000,3870247.0000,3836053.0000,3966109.0000,3994302.0000,3953676.0000,3992790.0000,3948425.0000,4044687.0000,4013649.0000,4002117.0000,3989573.0000,4004231.0000,4006846.0000,3986818.0000,4004501.0000,4006636.0000,3987409.0000,4008610.0000,4001997.0000,3994933.0000,3999402.0000,4003871.0000,3996997.0000,4009621.0000,3988972.0000,3999562.0000,4043456.0000,3838938.0000,3954026.0000,3960909.0000,3984313.0000,3961059.0000,3937525.0000,3685247.0000,3965347.0000,3860178.0000,3864296.0000,3735633.0000,3744920.0000,3777691.0000,3779054.0000,3866070.0000,3880346.0000,3811145.0000,3819000.0000,3850961.0000,3841183.0000,3685587.0000,3876358.0000,3916695.0000,3910694.0000,3884735.0000,3894723.0000,3883833.0000,3955849.0000,3997178.0000,3985215.0000,3897038.0000,3833998.0000,3805595.0000,3736935.0000,3841062.0000,3768684.0000,3794994.0000,4021513.0000,3968773.0000,3991386.0000,4111504.0000,3979133.0000,3970607.0000,3990485.0000,3967322.0000,4038516.0000,3987740.0000,3959807.0000,4101185.0000,3979214.0000,3927956.0000,4091265.0000,3992899.0000,3957282.0000,3986567.0000,3966450.0000,4050258.0000,3979304.0000,3973553.0000,4042504.0000,3980516.0000,3972070.0000,4048324.0000,3980717.0000,3862993.0000,3856501.0000,3757494.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,wave_sim topology,100,1,1586401700,15852900.4100,15835276.1000,15889330.6500,122607.9125,74019.6363,240575.9751,"15867897.0000,15819265.0000,16803799.0000,15790491.0000,15878438.0000,15804647.0000,15757488.0000,15817622.0000,15843881.0000,15978506.0000,15839253.0000,15803686.0000,15739244.0000,15906640.0000,15805138.0000,16015337.0000,15933522.0000,15785221.0000,15751427.0000,15774651.0000,15783218.0000,15834574.0000,15750214.0000,15767457.0000,15841036.0000,15795811.0000,15760123.0000,15858059.0000,15752530.0000,15749413.0000,15852007.0000,15695100.0000,15781534.0000,15774290.0000,15840936.0000,15810027.0000,15736078.0000,15759892.0000,15827801.0000,15893666.0000,15861014.0000,15858339.0000,15844172.0000,15776885.0000,15819356.0000,15737450.0000,15760074.0000,15759993.0000,15871214.0000,16050182.0000,16061193.0000,15841437.0000,15883697.0000,15979660.0000,15878708.0000,15919966.0000,15811310.0000,15853570.0000,15919415.0000,15901711.0000,15943831.0000,15779610.0000,15780672.0000,15856616.0000,15966224.0000,15932379.0000,15873438.0000,15765203.0000,15766816.0000,15913464.0000,15864180.0000,15869891.0000,15959671.0000,15852308.0000,15871564.0000,15752709.0000,15765794.0000,15793517.0000,15940334.0000,15793145.0000,15867967.0000,15859341.0000,15946305.0000,15715859.0000,15809798.0000,15850124.0000,15915849.0000,15889979.0000,15766876.0000,15751677.0000,15854302.0000,15998224.0000,15866966.0000,15757919.0000,15799989.0000,15974059.0000,15952668.0000,15885130.0000,15885832.0000,15930546.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,jacobi topology,100,1,548029400,5455888.5100,5421494.5500,5495393.4800,187943.1631,160434.4859,222842.1130,"5284376.0000,5389835.0000,5473764.0000,5358456.0000,5457574.0000,5450630.0000,5367062.0000,5405254.0000,5376149.0000,5422967.0000,5299534.0000,5504812.0000,5383693.0000,5523418.0000,5649316.0000,5495735.0000,5122599.0000,5393011.0000,5399072.0000,5522656.0000,5433367.0000,5286910.0000,5429990.0000,5287300.0000,5277892.0000,5261512.0000,5420723.0000,5272363.0000,5263266.0000,5335342.0000,5161433.0000,5398311.0000,5441703.0000,5493972.0000,5273374.0000,5423339.0000,5311156.0000,5510804.0000,5173606.0000,5507848.0000,5434370.0000,5327336.0000,5312408.0000,5477170.0000,5370989.0000,5430552.0000,5652883.0000,5248367.0000,5491537.0000,5446803.0000,5439439.0000,5294134.0000,5763764.0000,5741992.0000,5768202.0000,5235603.0000,5830399.0000,5874723.0000,5989681.0000,5726983.0000,6033765.0000,5278985.0000,5949334.0000,5842472.0000,5767079.0000,5602447.0000,5873511.0000,5544478.0000,5450560.0000,5502559.0000,5336313.0000,5109794.0000,5342606.0000,5554938.0000,5591717.0000,5365971.0000,5437355.0000,5467963.0000,5409603.0000,5493551.0000,5364698.0000,5549427.0000,5655218.0000,5578271.0000,5365378.0000,5262123.0000,5502909.0000,5634558.0000,5518488.0000,5703890.0000,5367743.0000,5274828.0000,5266180.0000,5441933.0000,5175149.0000,5449688.0000,5391528.0000,5323349.0000,5283143.0000,5423890.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,6322494500,63261209.5600,62771779.4500,63719780.2400,2414669.5412,2182121.3471,2706636.0819,"65790457.0000,66116003.0000,66117326.0000,66001866.0000,65961591.0000,66094702.0000,60253561.0000,66085925.0000,65859237.0000,66012617.0000,66075477.0000,65931424.0000,65852795.0000,66222144.0000,64891926.0000,63300150.0000,59374888.0000,58102608.0000,58680553.0000,63066548.0000,62235434.0000,63555393.0000,64265248.0000,65834770.0000,63868367.0000,64783369.0000,63405811.0000,63822339.0000,61765785.0000,65840992.0000,60973846.0000,65404816.0000,61500292.0000,61774651.0000,60373078.0000,57385439.0000,62496409.0000,64056022.0000,65897819.0000,65812329.0000,64709630.0000,63792924.0000,63213316.0000,58909487.0000,62352967.0000,64287160.0000,63773547.0000,60238494.0000,62382322.0000,60295401.0000,66019460.0000,65819462.0000,65995064.0000,65949959.0000,60571183.0000,65957794.0000,65941222.0000,65788143.0000,60297654.0000,61607386.0000,63288148.0000,65247729.0000,62662162.0000,60226901.0000,61323087.0000,63712742.0000,61437553.0000,66399621.0000,62311258.0000,63055267.0000,63736958.0000,66247703.0000,66114550.0000,66131624.0000,61105093.0000,62725112.0000,59703629.0000,60565703.0000,63500069.0000,62022562.0000,62262746.0000,62472714.0000,62293584.0000,61162443.0000,59912735.0000,62260332.0000,59662652.0000,66173733.0000,62658626.0000,64759084.0000,57511759.0000,58799417.0000,60715066.0000,60395400.0000,64308681.0000,64628596.0000,63388187.0000,63716919.0000,62639801.0000,66134428.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,372410000,3742213.2900,3712482.3800,3762979.7700,124966.9512,92067.0975,156552.1696,"3776230.0000,3780688.0000,3700045.0000,3356304.0000,3355633.0000,3762704.0000,3790125.0000,3791939.0000,3783303.0000,3780588.0000,3790506.0000,3779425.0000,3786960.0000,3777662.0000,3782191.0000,3787260.0000,3783513.0000,3788723.0000,3778443.0000,3790626.0000,3777081.0000,3782601.0000,3766681.0000,3778042.0000,3774265.0000,3787851.0000,3781820.0000,3787020.0000,3779946.0000,3776380.0000,3786539.0000,3783824.0000,3788252.0000,3783022.0000,3787991.0000,3784535.0000,3786489.0000,3787280.0000,3784625.0000,3796677.0000,3780617.0000,3783653.0000,3780387.0000,3779515.0000,3774296.0000,3795405.0000,3780737.0000,3782911.0000,3787982.0000,3792390.0000,3796437.0000,3786268.0000,3794373.0000,3792479.0000,3781389.0000,3785717.0000,3794394.0000,3783302.0000,3781920.0000,3776860.0000,3784946.0000,3785166.0000,3796869.0000,3781699.0000,3792009.0000,3779015.0000,3784385.0000,3779575.0000,3777372.0000,3790646.0000,3632597.0000,3354801.0000,3360171.0000,3359690.0000,3382944.0000,3371011.0000,3375861.0000,3384407.0000,3420686.0000,3801697.0000,3794734.0000,3807989.0000,3805505.0000,3803110.0000,3808891.0000,3800144.0000,3789735.0000,3783423.0000,3789715.0000,3779846.0000,3787060.0000,3780718.0000,3799954.0000,3791728.0000,3782841.0000,3792419.0000,3791548.0000,3779896.0000,3789444.0000,3772261.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,982171300,9980812.7000,9924801.8200,10009123.1100,195088.4451,111873.8472,301710.3197,"10007880.0000,10040422.0000,10023830.0000,10009664.0000,10015324.0000,9993925.0000,10007169.0000,9964758.0000,10006538.0000,10003762.0000,10004844.0000,9999815.0000,9996228.0000,9991259.0000,10018591.0000,10021015.0000,10020314.0000,10003452.0000,10023690.0000,9993713.0000,10025905.0000,9982321.0000,10018620.0000,9998523.0000,10009453.0000,9988604.0000,10000516.0000,9992551.0000,9994564.0000,10002029.0000,10017609.0000,10006818.0000,9990978.0000,9980719.0000,10015084.0000,10057925.0000,10063175.0000,10053526.0000,10044750.0000,10048898.0000,10027938.0000,10000176.0000,9984646.0000,9990508.0000,9994936.0000,10031555.0000,10045061.0000,10049739.0000,10039440.0000,10043868.0000,10033398.0000,10070588.0000,9399808.0000,8933576.0000,8935149.0000,8971227.0000,10014504.0000,10037015.0000,9993323.0000,10025053.0000,10016847.0000,10020424.0000,9996589.0000,10031806.0000,10004463.0000,10162833.0000,10007089.0000,10023600.0000,10242625.0000,10025053.0000,10011426.0000,10015654.0000,9987772.0000,10012489.0000,10007489.0000,9993634.0000,9997099.0000,10013200.0000,10048798.0000,9996889.0000,10006047.0000,10020054.0000,9971512.0000,10028389.0000,10013430.0000,10036193.0000,9996969.0000,10017719.0000,10001969.0000,10016336.0000,10014843.0000,10002109.0000,10024742.0000,10059538.0000,10073395.0000,10031625.0000,10050721.0000,10045882.0000,9993503.0000,10000246.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,419649100,4192414.2400,4190976.6400,4193960.1700,7583.4402,6696.7990,8720.2494,"4184713.0000,4180705.0000,4211805.0000,4183590.0000,4194020.0000,4204460.0000,4196465.0000,4187918.0000,4205852.0000,4206895.0000,4193750.0000,4192087.0000,4193369.0000,4196365.0000,4184423.0000,4190323.0000,4195243.0000,4203598.0000,4208838.0000,4209039.0000,4187077.0000,4202467.0000,4200953.0000,4195843.0000,4185744.0000,4191756.0000,4198228.0000,4189692.0000,4186346.0000,4199701.0000,4201334.0000,4182670.0000,4203007.0000,4212536.0000,4186456.0000,4201835.0000,4198730.0000,4193689.0000,4187568.0000,4194661.0000,4195683.0000,4198249.0000,4191616.0000,4199510.0000,4182598.0000,4184111.0000,4192528.0000,4184482.0000,4186737.0000,4176838.0000,4206644.0000,4194170.0000,4199761.0000,4190553.0000,4186225.0000,4199732.0000,4187187.0000,4199271.0000,4184211.0000,4188700.0000,4179373.0000,4188700.0000,4194621.0000,4193148.0000,4189632.0000,4192677.0000,4190844.0000,4198900.0000,4185764.0000,4188730.0000,4184001.0000,4183210.0000,4189201.0000,4189061.0000,4182719.0000,4190965.0000,4178471.0000,4187859.0000,4187919.0000,4185344.0000,4200643.0000,4189472.0000,4184542.0000,4197718.0000,4184903.0000,4184362.0000,4194692.0000,4193750.0000,4191165.0000,4186616.0000,4182578.0000,4197187.0000,4191276.0000,4188760.0000,4196695.0000,4187979.0000,4193700.0000,4191856.0000,4194471.0000,4195363.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,1772912100,17663033.1000,17575186.6600,17698166.9700,254139.8734,41940.9922,462581.9830,"17696510.0000,17658799.0000,17737418.0000,16014576.0000,15805379.0000,17462487.0000,17729423.0000,17732228.0000,17717821.0000,17703934.0000,17712200.0000,17664931.0000,17673737.0000,17676101.0000,17685289.0000,17689997.0000,17709925.0000,17708683.0000,17689918.0000,17672435.0000,17685970.0000,17689006.0000,17669829.0000,17704496.0000,17667104.0000,17666333.0000,17697141.0000,17714645.0000,17684577.0000,17684578.0000,17698614.0000,17704065.0000,17702282.0000,17689617.0000,17689466.0000,17693865.0000,17697422.0000,17789917.0000,17699266.0000,17858838.0000,17648780.0000,17671623.0000,17688425.0000,17700238.0000,17710136.0000,17680560.0000,17720326.0000,17708804.0000,17694146.0000,17687333.0000,17692372.0000,17691341.0000,17697622.0000,17724314.0000,17686682.0000,17665962.0000,17693314.0000,17693825.0000,17674939.0000,17679538.0000,17685420.0000,17673537.0000,17678947.0000,17692342.0000,17685109.0000,17687643.0000,17697592.0000,17701129.0000,17689167.0000,17690339.0000,17706399.0000,17691240.0000,17720837.0000,17679698.0000,17708714.0000,17682234.0000,17685609.0000,17684647.0000,17693113.0000,17721959.0000,17719574.0000,17735444.0000,17718483.0000,17734121.0000,17748589.0000,17676783.0000,17693274.0000,17703223.0000,17691841.0000,17682555.0000,17711148.0000,17689106.0000,17692893.0000,17826847.0000,17694226.0000,17669990.0000,17701350.0000,17846635.0000,17709505.0000,17762946.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,591668800,5906193.3900,5876630.7800,5915796.5200,77887.1319,27702.2415,169574.5281,"5950947.0000,5945587.0000,5930669.0000,5899871.0000,5919568.0000,6080192.0000,5935368.0000,5901955.0000,5911262.0000,5895573.0000,5915911.0000,5901113.0000,5920830.0000,5908046.0000,5926091.0000,5903317.0000,5911744.0000,5891845.0000,5911293.0000,5904620.0000,5911634.0000,5907355.0000,5924668.0000,5927834.0000,5892226.0000,5923786.0000,5913156.0000,5931321.0000,5911673.0000,5933635.0000,5915300.0000,5926641.0000,5912605.0000,5932333.0000,5905621.0000,5917414.0000,5901153.0000,5931571.0000,5914879.0000,5924808.0000,5913346.0000,5928134.0000,5921042.0000,5934807.0000,5916131.0000,5922643.0000,5904669.0000,5910090.0000,5912755.0000,5902846.0000,5910009.0000,5913336.0000,5907856.0000,5905321.0000,5911783.0000,5908277.0000,5913176.0000,5908828.0000,5915380.0000,5898478.0000,5917524.0000,5912565.0000,5926371.0000,5921232.0000,5922433.0000,5904088.0000,5926091.0000,5917504.0000,5908177.0000,5925148.0000,5906353.0000,5922543.0000,5915139.0000,5921642.0000,5913647.0000,5922043.0000,5906504.0000,5912965.0000,5903678.0000,5914329.0000,5905621.0000,5910902.0000,5919087.0000,5911603.0000,5901805.0000,5915700.0000,5926721.0000,5919047.0000,5901834.0000,5908297.0000,5894591.0000,5908547.0000,5895923.0000,5911603.0000,5675786.0000,5209333.0000,5779453.0000,5937742.0000,5947160.0000,5934286.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,4264205700,42983281.4900,42766521.1200,43179152.8300,1049425.7053,874345.6540,1267754.1608,"43104976.0000,42840847.0000,41318904.0000,42826520.0000,43572672.0000,43668284.0000,43306469.0000,42881924.0000,42843512.0000,42886814.0000,40456861.0000,43208502.0000,42606463.0000,43391008.0000,43421297.0000,40587980.0000,43048440.0000,43816805.0000,43424011.0000,43096541.0000,43392592.0000,43697038.0000,43064440.0000,43703481.0000,44224366.0000,42834233.0000,43466973.0000,42624757.0000,42881744.0000,44081487.0000,46406098.0000,43257475.0000,40556391.0000,40412237.0000,43010268.0000,43366693.0000,42985891.0000,43318120.0000,43275800.0000,43302931.0000,42970342.0000,43284446.0000,43224613.0000,42980221.0000,40342144.0000,41361535.0000,40698279.0000,42931718.0000,43892998.0000,43818408.0000,43187563.0000,41036941.0000,43661040.0000,42946496.0000,43837895.0000,41526107.0000,44364752.0000,45221785.0000,43208995.0000,43244010.0000,42760825.0000,43075011.0000,43072675.0000,42964871.0000,44432070.0000,42889628.0000,42678940.0000,44072069.0000,40495695.0000,41223273.0000,43540402.0000,43648055.0000,42842330.0000,43144161.0000,42922020.0000,43725783.0000,43249951.0000,43013393.0000,41328363.0000,43231957.0000,43275900.0000,42728243.0000,43246354.0000,43260601.0000,42914797.0000,40585876.0000,41367577.0000,43299195.0000,43485568.0000,42580383.0000,43639179.0000,43426145.0000,43024635.0000,42763330.0000,43225334.0000,43282072.0000,44153643.0000,45020173.0000,43144081.0000,43681458.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,350532200,3499634.5900,3471335.3600,3540198.7300,170414.2351,123849.6331,258019.6651,"3406870.0000,3344792.0000,3685888.0000,4455576.0000,4206725.0000,3711877.0000,3687552.0000,3651092.0000,3714803.0000,3739490.0000,3670228.0000,3621846.0000,3636655.0000,3710905.0000,3648688.0000,3667443.0000,3642025.0000,3655520.0000,3635492.0000,3552616.0000,3561142.0000,3406259.0000,3497001.0000,3346796.0000,3576341.0000,3602851.0000,3342248.0000,3549740.0000,3346274.0000,3344361.0000,3351976.0000,3350433.0000,3587803.0000,3353899.0000,3344392.0000,3346145.0000,3346876.0000,3332759.0000,3598993.0000,3565200.0000,3346886.0000,3440654.0000,3464058.0000,3558627.0000,3466242.0000,3334583.0000,3595978.0000,3579978.0000,3363167.0000,3501840.0000,3395127.0000,3339562.0000,3340945.0000,3551333.0000,3560901.0000,3357086.0000,3642656.0000,3385840.0000,3425595.0000,3511558.0000,3561442.0000,3572294.0000,3629391.0000,3545272.0000,3566331.0000,3550331.0000,3426888.0000,3490708.0000,3525123.0000,3550271.0000,3351795.0000,3414454.0000,3532507.0000,3386651.0000,3334633.0000,3339553.0000,3338330.0000,3515105.0000,3481100.0000,3449280.0000,3495457.0000,3389457.0000,3478786.0000,3461674.0000,3487212.0000,3418101.0000,3349030.0000,3340123.0000,3347758.0000,3343620.0000,3579948.0000,3588503.0000,3354360.0000,3559258.0000,3337107.0000,3338000.0000,3342728.0000,3342559.0000,3556083.0000,3332048.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,661452000,6443730.1800,6417623.6900,6468739.1100,130707.3201,116675.4556,147861.9775,"6411620.0000,6580761.0000,6646244.0000,6468748.0000,6562065.0000,6525115.0000,6681131.0000,6593083.0000,6453159.0000,6480090.0000,6520526.0000,6487183.0000,6499356.0000,6501030.0000,6503934.0000,6506669.0000,6479639.0000,6303045.0000,6591039.0000,6463347.0000,6672684.0000,6283718.0000,6548619.0000,6606269.0000,6391532.0000,6575230.0000,6392383.0000,6528130.0000,6545183.0000,6527349.0000,6417241.0000,6434974.0000,6422190.0000,6268839.0000,6324425.0000,6529504.0000,6501691.0000,6603263.0000,6641104.0000,6552758.0000,6529864.0000,6469469.0000,6472345.0000,6389518.0000,6364460.0000,6353179.0000,6197033.0000,6150125.0000,6355724.0000,6488917.0000,6137801.0000,6419956.0000,6218995.0000,6375120.0000,6192916.0000,6342610.0000,6256305.0000,6442890.0000,6515406.0000,6232341.0000,6171695.0000,6498484.0000,6297364.0000,6503253.0000,6382645.0000,6402532.0000,6624724.0000,6294027.0000,6559671.0000,6453399.0000,6579538.0000,6469720.0000,6379589.0000,6448751.0000,6548951.0000,6389207.0000,6577314.0000,6325667.0000,6294017.0000,6257087.0000,6258039.0000,6534854.0000,6660731.0000,6295890.0000,6586881.0000,6483245.0000,6247559.0000,6418212.0000,6275943.0000,6577975.0000,6474589.0000,6547276.0000,6287655.0000,6421158.0000,6509635.0000,6236548.0000,6727378.0000,6527329.0000,6425606.0000,6489036.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,375734000,3867554.4400,3841883.4700,3890524.1700,124376.0281,109317.0478,140837.2358,"3919170.0000,4004371.0000,3970958.0000,3601899.0000,3869877.0000,3858515.0000,3862263.0000,3876219.0000,3803711.0000,3926834.0000,3945570.0000,4016424.0000,3985476.0000,4001676.0000,3999512.0000,3999241.0000,3999322.0000,4009100.0000,3992178.0000,3994542.0000,4011945.0000,3989193.0000,3996687.0000,4007467.0000,3941122.0000,3777201.0000,3604885.0000,4005804.0000,3709373.0000,3649910.0000,3746934.0000,3628920.0000,3600216.0000,3603372.0000,3796798.0000,3810074.0000,3608642.0000,3905404.0000,3820694.0000,3897790.0000,3934198.0000,3914662.0000,3979784.0000,4017175.0000,3979865.0000,4006255.0000,3881428.0000,3829149.0000,3753196.0000,3693232.0000,3642286.0000,3815984.0000,3821034.0000,3815804.0000,3830011.0000,3606788.0000,3611807.0000,3606287.0000,3856241.0000,3870918.0000,3907227.0000,3858184.0000,3829179.0000,3986397.0000,3883933.0000,3914120.0000,3995254.0000,4006496.0000,3975566.0000,4011364.0000,3994472.0000,3885526.0000,3827326.0000,3722507.0000,3606177.0000,3779165.0000,3875036.0000,3911275.0000,3886989.0000,3912528.0000,3792540.0000,3775338.0000,3924951.0000,3905744.0000,3859427.0000,3860108.0000,3808992.0000,3823509.0000,4033216.0000,3936683.0000,4032003.0000,3825202.0000,3769737.0000,3814341.0000,3876289.0000,3862633.0000,3944618.0000,3919631.0000,3962963.0000,4043405.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,1557299200,15591913.8600,15583852.3700,15600637.3200,42787.9899,37632.3081,51514.8784,"15581074.0000,15549395.0000,15665394.0000,15619367.0000,15580292.0000,15683848.0000,15686604.0000,15563091.0000,15595962.0000,15586233.0000,15557439.0000,15655716.0000,15616291.0000,15595742.0000,15542922.0000,15637412.0000,15565745.0000,15646298.0000,15597636.0000,15593708.0000,15566076.0000,15578279.0000,15530609.0000,15566097.0000,15622803.0000,15535177.0000,15630046.0000,15628654.0000,15624747.0000,15565685.0000,15615230.0000,15630228.0000,15583498.0000,15511763.0000,15657178.0000,15672708.0000,15545447.0000,15636419.0000,15515351.0000,15588628.0000,15621560.0000,15566987.0000,15639725.0000,15607874.0000,15634475.0000,15644695.0000,15594420.0000,15743713.0000,15564563.0000,15592215.0000,15596233.0000,15547932.0000,15549655.0000,15582787.0000,15646149.0000,15575984.0000,15552239.0000,15592897.0000,15558061.0000,15610229.0000,15537121.0000,15544676.0000,15566167.0000,15526581.0000,15581585.0000,15587937.0000,15554694.0000,15546128.0000,15545166.0000,15525138.0000,15668130.0000,15555255.0000,15581706.0000,15530378.0000,15568020.0000,15590552.0000,15534867.0000,15577177.0000,15665113.0000,15586154.0000,15590582.0000,15614126.0000,15540006.0000,15591093.0000,15628604.0000,15637041.0000,15577778.0000,15638703.0000,15609468.0000,15561667.0000,15572478.0000,15569412.0000,15590011.0000,15591164.0000,15549344.0000,15629365.0000,15561988.0000,15606522.0000,15602896.0000,15609408.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,541139500,5624613.6800,5579684.4400,5682548.2600,258469.1673,196201.9963,367324.8208,"5375307.0000,5210005.0000,6904724.0000,6750722.0000,5597317.0000,5521624.0000,5719099.0000,5559436.0000,5471359.0000,5743344.0000,5868131.0000,5402809.0000,5590334.0000,5733406.0000,5599483.0000,5635360.0000,5635089.0000,5718296.0000,5533486.0000,5908737.0000,5627836.0000,5512638.0000,5527916.0000,5668543.0000,5489734.0000,5873570.0000,5399363.0000,5713367.0000,5687508.0000,5798229.0000,5803117.0000,5711524.0000,5938303.0000,5603300.0000,5757992.0000,5274747.0000,5836261.0000,5746431.0000,5741931.0000,5676007.0000,5681196.0000,5913406.0000,5748204.0000,5657692.0000,5595995.0000,5886585.0000,5853483.0000,5485516.0000,5477030.0000,5778932.0000,5830189.0000,5743354.0000,5913116.0000,5537815.0000,5741090.0000,5551401.0000,5941810.0000,5511416.0000,5838424.0000,5550930.0000,5250030.0000,5633496.0000,5845458.0000,5689933.0000,5842873.0000,5371110.0000,5535361.0000,5730460.0000,5630280.0000,5384906.0000,5487971.0000,5747622.0000,5699761.0000,5686386.0000,5793730.0000,5693530.0000,5802266.0000,5604812.0000,5542554.0000,5773182.0000,5735279.0000,5536813.0000,5416215.0000,5338779.0000,5457904.0000,5208912.0000,5372733.0000,5497980.0000,5342675.0000,5306467.0000,5554276.0000,5421545.0000,5279475.0000,5203191.0000,5285878.0000,5144551.0000,5423058.0000,5410274.0000,5234140.0000,5441533.0000" +benchmark intrusive graph dependency handling with N nodes - 1,creating nodes,100,5849,2339600,4.8935,4.8688,4.9202,0.1306,0.0941,0.2035,"4.9347,4.9501,4.4720,4.8800,4.9501,4.8901,4.8764,4.9037,4.8884,4.9123,4.8988,4.9226,4.9073,4.9313,4.9157,4.9364,4.9193,4.9415,4.9243,4.9449,4.9296,4.9586,4.9296,4.9501,4.9330,4.9535,4.9345,4.9552,4.9362,4.9552,4.9381,4.9569,4.9398,4.9569,4.9398,4.9552,4.4705,4.5047,4.5680,4.5851,4.6399,4.6504,4.7017,4.7051,4.7497,4.9501,4.7702,4.7685,4.8061,4.8012,4.8352,4.8268,4.8593,4.9501,4.8678,4.8593,4.8849,4.8730,4.9022,4.9501,4.9037,4.8918,4.9174,4.9501,4.9193,4.9055,4.9296,4.9108,4.9345,4.9176,4.9398,4.9226,4.9448,4.9261,4.9484,4.9296,4.9518,4.9313,4.9535,4.9345,4.9550,4.9362,4.9569,4.9381,4.9586,4.9398,4.9569,4.9398,5.6575,4.9518,4.8918,4.8781,4.9056,4.9501,4.9089,4.8971,4.9191,4.9037,4.9296,4.9123" +benchmark intrusive graph dependency handling with N nodes - 1,creating and adding dependencies,100,1049,2412700,23.2914,23.2330,23.5558,0.5409,0.0707,1.2812,"23.3213,23.3413,23.5033,23.2164,23.1783,23.1792,23.2259,23.1783,23.3794,23.2736,23.3403,23.3213,23.2164,23.1783,23.2164,23.1783,23.1878,23.4461,23.2069,23.4175,23.2450,23.2069,23.1888,23.3308,23.3213,23.2164,23.1783,23.2355,23.4175,23.1783,23.2164,23.1792,23.2164,23.1878,23.3508,23.3117,23.2164,23.1783,23.2736,23.3880,23.2269,23.1783,23.1878,23.2164,23.1888,23.2069,23.1878,23.2164,23.1888,23.2164,23.1878,23.2355,23.4080,23.1878,23.2164,23.1792,23.3975,23.2555,28.6225,23.1878,23.2164,23.1878,23.2078,23.1878,23.1783,23.4080,23.2736,23.2259,23.1783,23.2173,23.1878,23.1783,23.2164,23.1792,23.2164,23.1878,23.3117,23.3403,23.2164,23.1878,23.2069,23.1783,23.1878,23.2164,23.1792,23.3785,23.2745,23.2164,23.1878,23.2164,23.1783,23.2164,23.1878,23.1783,23.2164,23.1792,23.2164,23.1783,23.2259,23.1792" +benchmark intrusive graph dependency handling with N nodes - 1,adding and removing dependencies,100,1516,2425600,16.1097,16.0666,16.2811,0.4201,0.0123,1.0021,"16.0778,16.0587,16.1115,16.0580,16.0515,16.0778,16.0587,16.0844,16.0580,16.0851,16.0580,16.0580,16.0778,16.0587,16.0778,16.0580,16.0580,16.0851,16.0580,16.0844,16.0580,16.0844,16.0580,16.0515,16.0785,16.0580,16.0778,16.0580,16.0719,16.0580,16.0580,16.0778,16.0515,16.0844,16.0580,16.0521,16.0844,16.0580,16.0844,16.0587,16.0778,16.0580,16.0580,16.0778,16.0580,16.0712,16.0587,16.0515,16.0844,16.0580,16.0851,16.0580,16.0844,16.0580,16.0580,16.0844,16.0580,16.0851,16.0515,20.2876,16.0580,16.0580,16.0844,16.0580,16.0785,16.0580,16.0778,16.0580,16.0521,16.0910,16.0580,16.0785,16.0580,16.0844,16.0580,16.0587,16.0844,16.0580,16.0712,16.0587,16.0580,16.0844,16.0580,16.0778,16.0580,16.0844,16.0587,16.0580,16.0844,16.0580,16.0785,16.0580,16.0778,16.0580,16.0515,16.0844,16.0580,16.0785,16.0580,16.0580" +benchmark intrusive graph dependency handling with N nodes - 1,checking for dependencies,100,19949,1994900,1.2287,1.2255,1.2411,0.0297,0.0037,0.0705,"1.2233,1.2213,1.2309,1.2248,1.2224,1.2318,1.2224,1.2298,1.2229,1.2293,1.2229,1.2223,1.2299,1.2223,1.2298,1.2228,1.2218,1.2319,1.2223,1.2309,1.2223,1.2299,1.2223,1.2218,1.2304,1.2228,1.2309,1.5222,1.2303,1.2229,1.2213,1.2303,1.2223,1.2298,1.2229,1.2293,1.2234,1.2213,1.2299,1.2223,1.2293,1.2228,1.2288,1.2229,1.2223,1.2304,1.2223,1.2299,1.2238,1.2218,1.2309,1.2223,1.2299,1.2223,1.2294,1.2233,1.2213,1.2299,1.2223,1.2299,1.2228,1.2294,1.2233,1.2219,1.2298,1.2228,1.2293,1.2228,1.2289,1.2233,1.2224,1.2293,1.2229,1.2308,1.2229,1.2213,1.2303,1.2223,1.2298,1.2229,1.2288,1.2234,1.2213,1.2304,1.2223,1.2299,1.2228,1.2293,1.2234,1.2223,1.2299,1.2223,1.2299,1.2228,1.2218,1.2309,1.2218,1.2299,1.2228,1.2294" +benchmark intrusive graph dependency handling with N nodes - 10,creating nodes,100,647,2393900,39.7659,39.6992,39.9438,0.5185,0.2406,1.1134,"39.9799,39.8408,39.8099,39.1283,39.9490,39.2365,39.4235,39.8563,39.9799,39.8563,39.9799,39.8099,39.8408,39.7481,39.2056,39.5920,39.4699,39.7790,39.8408,39.8717,39.6074,39.8547,39.5471,39.2674,39.4235,39.8563,39.9799,39.6244,39.3601,39.8408,39.8563,39.5611,39.4853,39.9799,39.8563,39.8099,39.8408,39.9799,39.8408,39.8563,39.9799,44.2859,39.9799,39.3756,39.6244,39.5611,39.3756,39.5456,39.1283,39.9490,39.8563,39.9799,39.7017,39.2674,39.3756,39.9799,39.8408,39.8563,39.9799,39.8547,39.4853,39.5471,39.9799,39.7635,39.3447,39.1592,39.8408,39.9799,39.8563,39.8099,39.1128,39.5471,39.8563,39.9490,39.6244,39.8408,39.9799,39.8408,39.9799,39.7172,39.5301,39.6399,39.2519,39.6244,39.8563,39.9799,39.8408,39.5317,39.7311,39.9799,39.8393,39.9490,39.1437,39.8408,39.9799,39.8563,39.9799,39.8408,39.9954,39.8563" +benchmark intrusive graph dependency handling with N nodes - 10,creating and adding dependencies,100,93,2455200,266.8518,266.2994,269.0646,5.1662,0.5538,12.2632,"265.8602,266.7204,269.5269,267.3656,266.2903,267.3656,266.3978,267.2581,266.3978,265.8602,266.7204,265.7527,266.6129,265.7527,267.0430,266.1828,266.2903,266.9355,265.9677,267.3656,265.9677,265.5376,267.0430,265.6452,266.7204,265.8602,266.5054,266.0645,265.4194,267.0538,265.9570,266.8280,265.7527,266.3978,265.4301,265.4194,266.3871,265.8495,266.6129,265.5269,266.6129,266.0753,265.5269,266.3978,265.4194,266.6129,317.8925,267.2581,265.9677,266.9355,266.0753,265.5376,266.5054,265.8602,266.7204,265.8602,266.8280,266.1828,265.9677,266.7204,265.8602,266.9462,266.1828,266.5054,266.0753,265.9677,266.6129,265.8602,266.9355,265.9677,266.8280,265.7527,265.6452,266.5054,265.7527,266.8280,265.9677,266.8280,266.0753,265.9677,267.0430,266.0753,266.8280,266.0645,266.9355,266.2903,265.9677,267.0430,265.9677,266.7204,266.0753,266.6129,265.9677,265.8602,266.8280,265.6452,266.7204,265.9677,265.6452,267.2581" +benchmark intrusive graph dependency handling with N nodes - 10,adding and removing dependencies,100,118,2442600,207.4397,206.8692,209.6582,5.3246,0.6049,12.6300,"207.2373,207.3220,208.0932,207.0678,206.9068,206.3051,207.5847,205.7966,207.4068,206.5593,206.8983,207.0678,206.0508,208.0000,205.7966,207.2458,206.8983,206.6441,207.4153,206.0508,207.5000,206.3051,207.0678,207.1610,206.4746,207.6695,205.5424,207.4915,206.6441,206.8983,207.1525,206.0508,207.9153,205.6271,207.2458,206.8983,206.6441,207.3305,205.8814,207.4068,206.1356,207.0678,206.8136,206.3051,207.6610,205.5424,207.5000,206.6441,206.9068,207.3220,206.2203,207.8390,205.7966,207.3220,206.8136,206.7288,207.4153,205.8814,207.4915,206.3983,207.1525,206.9831,206.4831,207.4915,205.8814,207.5000,260.0508,207.5000,206.8983,206.8983,207.4068,206.1356,207.4153,206.3051,207.1525,207.0763,206.8136,207.9237,206.2203,207.6610,206.7288,206.9831,207.2458,206.6441,207.9237,206.0508,207.4068,206.9068,206.8983,207.4153,206.2203,208.1695,206.0508,207.2373,207.0763,206.7288,207.6610,206.2203,207.6610,206.7373" +benchmark intrusive graph dependency handling with N nodes - 10,checking for dependencies,100,1116,2343600,21.7916,21.7274,22.0306,0.5706,0.1153,1.3318,"21.2572,21.3378,21.8495,21.7419,21.8136,21.7330,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8047,21.7330,21.8145,21.7330,21.8047,21.7330,21.7330,21.8136,21.7330,21.8145,21.7330,21.8047,21.7330,21.7330,21.8136,21.7330,21.8145,21.7330,21.7330,21.8136,21.7330,21.8047,21.7330,21.8145,21.7330,21.7330,21.8047,21.7330,21.8136,21.7330,21.7428,21.8136,21.7330,21.8136,21.7330,21.8136,21.7419,21.7419,21.8136,21.7330,21.8047,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.8136,21.7419,21.7419,21.8145,21.7330,21.8047,21.7330,21.8136,21.7330,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.9489,21.7330,21.8047,21.7330,21.7330,21.8145,21.7419,21.8047,21.7330,21.8136,21.7330,27.3262,21.2482,21.2482,21.4373,21.2572,21.3289" +benchmark intrusive graph dependency handling with N nodes - 100,creating nodes,100,62,2461400,413.5294,413.3132,414.0171,1.5700,0.8985,3.1886,"412.5323,414.3065,426.2581,412.8387,412.3710,414.7903,413.1613,414.1452,412.5323,414.4677,412.5161,414.6290,412.5323,412.3548,414.3065,412.5161,414.7742,412.8548,414.3065,412.8387,414.4677,413.5000,413.3387,414.2903,412.5323,414.1452,412.3548,414.6290,412.5323,414.6129,413.1613,414.4677,412.5323,414.4516,412.3710,414.1452,412.5161,414.7903,413.3387,413.1613,414.4677,412.5323,414.1452,412.3548,415.1129,412.5323,413.9677,412.5323,412.3710,414.2903,412.3710,413.9839,412.3548,414.4677,412.3710,414.2903,412.3710,412.5323,414.1290,412.3710,414.4677,413.1613,414.4677,412.3710,414.3065,412.6774,412.3710,414.4516,412.5161,414.3065,412.5161,414.3065,412.3710,413.1613,413.6452,412.3710,414.1290,412.3548,414.4677,412.5161,414.4516,413.0161,412.8548,414.4516,412.3710,414.4677,412.5161,414.4677,412.6935,414.2903,412.6774,412.6935,414.1290,412.5161,414.1452,412.5161,414.6290,412.5323,414.3065,412.3548" +benchmark intrusive graph dependency handling with N nodes - 100,creating and adding dependencies,100,6,2561400,4335.4233,4325.8233,4358.8350,72.1486,37.7052,149.8860,"4323.0000,4301.1667,4408.0000,4311.1667,4324.5000,4306.1667,4338.0000,4291.1667,4324.5000,4306.1667,4287.8333,4321.1667,4296.1667,4321.1667,4296.1667,4343.0000,4304.5000,4326.1667,4296.1667,4302.8333,4321.1667,4301.0000,4327.8333,4294.5000,4322.8333,4291.1667,4317.8333,4296.1667,4287.8333,4322.8333,4289.5000,4306.1667,4292.8333,4302.8333,4294.5000,4314.5000,4306.1667,4302.8333,4302.8333,4292.6667,4329.6667,4296.1667,4319.5000,4940.6667,4401.3333,4374.6667,4401.3333,4383.0000,4409.8333,4379.5000,4384.5000,4396.3333,4372.8333,4394.6667,4376.1667,4411.5000,4379.6667,4408.0000,4379.6667,4398.0000,4369.6667,4361.1667,4389.6667,4378.0000,4396.3333,4378.0000,4406.3333,4372.8333,4408.1667,4372.8333,4329.6667,4304.5000,4289.5000,4321.1667,4291.1667,4321.1667,4294.5000,4324.5000,4292.8333,4314.5000,4299.5000,4301.1667,4323.0000,4304.5000,4326.1667,4294.5000,4309.5000,4297.8333,4316.1667,4297.8333,4291.1667,4306.1667,4294.5000,4321.1667,4284.5000,4311.1667,4279.5000,4316.1667,4297.8333,4299.5000" +benchmark intrusive graph dependency handling with N nodes - 100,adding and removing dependencies,100,6,2568600,3751.2950,3738.5117,3811.4733,121.6344,8.9928,289.5968,"3735.1667,3743.5000,3791.8333,3751.8333,3728.3333,3728.5000,3735.0000,3740.1667,3730.0000,3726.6667,3730.1667,3736.6667,3733.5000,3731.6667,3733.5000,3736.6667,3731.8333,3733.3333,3730.0000,3735.1667,3733.3333,3731.8333,3730.0000,3733.5000,3735.0000,3735.1667,3735.0000,3730.0000,3731.8333,3735.0000,3733.5000,3735.0000,3733.5000,3731.6667,3735.1667,3733.3333,3735.1667,3736.8333,3733.3333,3733.5000,3733.3333,3730.1667,3733.3333,3736.8333,3731.6667,3740.0000,3736.8333,3731.6667,3733.5000,3735.0000,3730.1667,3735.0000,3736.6667,3735.1667,3736.6667,3730.1667,3736.6667,3738.5000,3736.8333,3736.6667,3733.5000,3735.0000,3735.1667,3733.3333,3733.3333,3736.8333,3731.6667,3736.8333,3736.6667,3736.8333,3733.3333,3738.3333,3731.8333,3736.6667,4957.5000,3733.3333,3743.5000,3745.1667,3741.6667,3741.8333,3745.1667,3753.3333,3748.5000,3755.1667,3753.5000,3758.3333,3748.5000,3751.8333,3750.1667,3760.0000,3756.6667,3758.5000,3753.5000,3755.1667,3753.3333,3760.0000,3746.8333,3751.8333,3751.8333,3755.0000" +benchmark intrusive graph dependency handling with N nodes - 100,checking for dependencies,100,14,2583000,1844.1350,1839.3550,1863.0057,45.0878,4.0997,107.2223,"1834.7857,1840.5000,1857.6429,1841.9286,1847.6429,1834.0714,1842.6429,1850.5000,1841.2143,1840.5000,1840.5000,1844.7857,1839.0714,1841.9286,1834.7857,1839.0714,1839.0714,1837.6429,1839.7143,1835.4286,1842.6429,1837.6429,1841.9286,1841.2143,1840.5000,1846.9286,1838.3571,1846.2143,1839.0714,1845.5000,1837.6429,1846.2143,1838.3571,1838.3571,1843.3571,1838.3571,1844.7857,1837.6429,1841.2143,1839.7857,1844.0714,1836.8571,1840.4286,1843.3571,1840.5000,1840.5000,1836.2143,1842.6429,1835.5000,1841.9286,1841.2143,1834.7857,1841.2143,1836.8571,1844.7857,1837.5714,1838.3571,1836.9286,1839.7857,1839.0714,1832.6429,1840.5000,1836.9286,1844.7857,1837.5714,1846.2143,1836.8571,1844.7857,1836.8571,1832.6429,1843.3571,1836.9286,1846.2143,1841.2143,2290.6429,1835.5000,1844.7857,1839.7857,1840.5000,1834.0000,1831.2143,1838.3571,1833.3571,1836.9286,1836.8571,1844.7857,1831.2143,1838.3571,1835.5000,1834.0714,1840.5000,1835.4286,1843.3571,1832.6429,1838.3571,1834.7857,1837.6429,1831.8571,1834.7857,1839.0714" +benchmark task handling > without access thread,generating and deleting tasks,100,1,477525400,4920304.4400,4852579.2500,4965170.9000,276404.0339,200472.8706,359103.7784,"5010974.0000,5004531.0000,5123988.0000,4922696.0000,5187888.0000,4954908.0000,5171438.0000,4931434.0000,4961279.0000,4946281.0000,5048555.0000,5026664.0000,4946562.0000,5039728.0000,4929990.0000,5007647.0000,5061129.0000,4899012.0000,4924079.0000,4937344.0000,5090995.0000,5004462.0000,5038105.0000,4949608.0000,4964976.0000,5084443.0000,5017567.0000,4943236.0000,5063433.0000,4968723.0000,4998670.0000,4903540.0000,5065388.0000,4970988.0000,5019439.0000,5024719.0000,5077199.0000,5167209.0000,5000073.0000,5087048.0000,4132389.0000,4053199.0000,3992063.0000,3903415.0000,3952118.0000,3992674.0000,4034503.0000,4052938.0000,4855899.0000,4936633.0000,5005353.0000,4908159.0000,4934328.0000,4832064.0000,4919911.0000,5101476.0000,5102027.0000,4983040.0000,4945048.0000,5084463.0000,4967562.0000,5021694.0000,4896376.0000,4954096.0000,4910263.0000,5065507.0000,4972552.0000,5030360.0000,5079273.0000,5114861.0000,4890305.0000,4976830.0000,4928357.0000,4950850.0000,5022275.0000,5045669.0000,4922938.0000,4989383.0000,4979614.0000,5011605.0000,4932375.0000,5009131.0000,5105373.0000,4922726.0000,4939198.0000,5033967.0000,4937084.0000,4999603.0000,5014410.0000,5019300.0000,4962642.0000,4966249.0000,5016134.0000,4950930.0000,5067230.0000,5004612.0000,4961530.0000,5065378.0000,5102547.0000,5092007.0000" +benchmark task handling > with access thread,generating and deleting tasks with access thread,100,1,1015935100,9986252.7600,9872792.6400,10070732.4500,494531.8116,383546.1367,616836.7304,"10688402.0000,10038651.0000,10462454.0000,10136988.0000,9843622.0000,10158588.0000,10051876.0000,10311689.0000,10496870.0000,9835486.0000,10211649.0000,10238290.0000,10392341.0000,10291511.0000,9843341.0000,10820132.0000,9714346.0000,10171363.0000,9937209.0000,9896722.0000,10035796.0000,9835546.0000,10020126.0000,10272395.0000,10002372.0000,9968328.0000,10086552.0000,10469137.0000,9929624.0000,9930366.0000,9887835.0000,9755745.0000,9841929.0000,10012351.0000,9867968.0000,10257596.0000,10320715.0000,10069480.0000,10395687.0000,10148800.0000,10410105.0000,10241886.0000,10414383.0000,10144883.0000,9221041.0000,8477793.0000,8337859.0000,8428089.0000,9518375.0000,9955003.0000,9932079.0000,9927270.0000,9934564.0000,10326737.0000,10060603.0000,10108283.0000,10103844.0000,10153399.0000,9849573.0000,8550661.0000,8711847.0000,10041927.0000,9989117.0000,10401860.0000,10023492.0000,10042218.0000,9941487.0000,10174699.0000,10302531.0000,9977034.0000,10245303.0000,10335264.0000,10301158.0000,10200367.0000,10207341.0000,10160712.0000,9843000.0000,9962378.0000,10293964.0000,10212711.0000,10397962.0000,10330414.0000,9997153.0000,9827621.0000,9819416.0000,9655445.0000,10321207.0000,10049822.0000,8518100.0000,8663636.0000,8458266.0000,10068268.0000,10280239.0000,10246084.0000,10170932.0000,10369348.0000,10452285.0000,10530583.0000,10262486.0000,10091291.0000" +generating large task graphs,soup topology,100,1,1529231000,15701911.7800,15565403.9200,15794011.7900,564494.2171,413863.9573,720229.4940,"15818434.0000,15861024.0000,15923403.0000,15910879.0000,15869581.0000,15918063.0000,15932880.0000,15890671.0000,15869520.0000,15920969.0000,15896982.0000,15723394.0000,13844122.0000,15595010.0000,15977785.0000,15951436.0000,15924916.0000,15934683.0000,15942900.0000,15916859.0000,15888476.0000,14234021.0000,15167360.0000,14047037.0000,15384472.0000,15941056.0000,15924846.0000,15897864.0000,15904537.0000,15884328.0000,15897915.0000,15962667.0000,15923383.0000,15857378.0000,15895018.0000,15933382.0000,15908674.0000,15918724.0000,15882554.0000,15933211.0000,15863298.0000,15896422.0000,15909686.0000,15537551.0000,13725216.0000,13957938.0000,15909697.0000,15935606.0000,15915417.0000,15905440.0000,15926578.0000,15905790.0000,15882596.0000,15868618.0000,15914727.0000,15895961.0000,15885511.0000,15925045.0000,15993546.0000,13920467.0000,13803456.0000,13934122.0000,15900389.0000,15958729.0000,15918213.0000,15999847.0000,15921670.0000,15856426.0000,15908535.0000,15919735.0000,15912643.0000,15898365.0000,14191972.0000,15123326.0000,15830136.0000,15958870.0000,15922671.0000,15898996.0000,15906421.0000,15907182.0000,15871094.0000,15892103.0000,15911349.0000,15888106.0000,15879108.0000,15934214.0000,15889187.0000,15892575.0000,15899818.0000,15937790.0000,15886883.0000,15833432.0000,15887785.0000,15941197.0000,15848491.0000,15900569.0000,15848760.0000,15920898.0000,15877796.0000,15892795.0000" +generating large task graphs,chain topology,100,1,6785600,68177.3500,67957.9000,68704.8900,1652.4222,730.9429,2850.0432,"67917.0000,67926.0000,76984.0000,68117.0000,68017.0000,67937.0000,68037.0000,68097.0000,68027.0000,68117.0000,68137.0000,67847.0000,68358.0000,67886.0000,67986.0000,67847.0000,68007.0000,67877.0000,67957.0000,67706.0000,68218.0000,67816.0000,67997.0000,67747.0000,67886.0000,68108.0000,68117.0000,67907.0000,68077.0000,67836.0000,67967.0000,67937.0000,68107.0000,67827.0000,68097.0000,67827.0000,67967.0000,68157.0000,67897.0000,79919.0000,68478.0000,67887.0000,68127.0000,67877.0000,67907.0000,67726.0000,68127.0000,67877.0000,67997.0000,68147.0000,68097.0000,67857.0000,67967.0000,67796.0000,68097.0000,67866.0000,68228.0000,67856.0000,67906.0000,67737.0000,67937.0000,67766.0000,67967.0000,67767.0000,67966.0000,67546.0000,68097.0000,67576.0000,67726.0000,67737.0000,67686.0000,67626.0000,67666.0000,67516.0000,68047.0000,67486.0000,67827.0000,67566.0000,67836.0000,67627.0000,67896.0000,67707.0000,67676.0000,67596.0000,68128.0000,67866.0000,68057.0000,67607.0000,67756.0000,67687.0000,67886.0000,67767.0000,68037.0000,67606.0000,68047.0000,67616.0000,67917.0000,67657.0000,74980.0000,67526.0000" +generating large task graphs,expanding tree topology,100,1,14083900,127204.2000,126853.2000,128044.7100,2592.7744,905.6171,4564.7714,"126487.0000,126017.0000,132740.0000,127580.0000,126688.0000,127289.0000,126949.0000,127329.0000,126478.0000,126277.0000,126829.0000,126367.0000,126868.0000,126678.0000,126618.0000,126518.0000,126859.0000,127149.0000,126377.0000,126298.0000,126908.0000,126428.0000,126598.0000,127159.0000,126057.0000,126378.0000,126297.0000,126688.0000,126869.0000,126968.0000,144602.0000,126417.0000,126548.0000,126849.0000,126117.0000,127399.0000,126578.0000,126699.0000,126778.0000,126718.0000,127089.0000,127229.0000,126498.0000,126298.0000,126688.0000,126858.0000,126278.0000,126427.0000,127450.0000,125746.0000,126618.0000,126959.0000,126267.0000,126798.0000,126838.0000,127440.0000,127299.0000,126218.0000,126888.0000,126678.0000,126999.0000,130926.0000,126979.0000,127249.0000,127320.0000,126427.0000,126809.0000,127339.0000,126909.0000,126898.0000,127119.0000,127009.0000,127039.0000,127019.0000,126578.0000,126668.0000,127199.0000,126237.0000,126739.0000,126588.0000,127179.0000,126037.0000,127580.0000,126537.0000,127419.0000,126448.0000,126878.0000,126759.0000,126317.0000,126798.0000,126738.0000,126387.0000,125957.0000,144252.0000,127279.0000,126638.0000,126498.0000,126908.0000,127008.0000,126739.0000" +generating large task graphs,contracting tree topology,100,1,17992400,181789.4500,181576.9100,182176.0100,1412.5586,899.9837,2199.2888,"181852.0000,181492.0000,185078.0000,181192.0000,183215.0000,181562.0000,180971.0000,186421.0000,181492.0000,181191.0000,181523.0000,181642.0000,181211.0000,181062.0000,181612.0000,181191.0000,181402.0000,181623.0000,181652.0000,181332.0000,181973.0000,181562.0000,181863.0000,181402.0000,181722.0000,181332.0000,181652.0000,181452.0000,181973.0000,185510.0000,182143.0000,181372.0000,181472.0000,180971.0000,181442.0000,181262.0000,181392.0000,181582.0000,180911.0000,181221.0000,181593.0000,180910.0000,181041.0000,181442.0000,181472.0000,180961.0000,181281.0000,180991.0000,181632.0000,180821.0000,180219.0000,188406.0000,180921.0000,181451.0000,182403.0000,181302.0000,181883.0000,181402.0000,181572.0000,181171.0000,181643.0000,181562.0000,181492.0000,181542.0000,181222.0000,181101.0000,181783.0000,181522.0000,180921.0000,181301.0000,181522.0000,181261.0000,181803.0000,185409.0000,181733.0000,181382.0000,181752.0000,181102.0000,181612.0000,181512.0000,182093.0000,181082.0000,181492.0000,181592.0000,181512.0000,181232.0000,181712.0000,181192.0000,181772.0000,181452.0000,181442.0000,181362.0000,181722.0000,180940.0000,181161.0000,190299.0000,182113.0000,181722.0000,182384.0000,181693.0000" +generating large task graphs,wave_sim topology,100,1,64928300,653178.8100,652530.8200,654526.3100,4574.4307,2721.0821,8863.8937,"652083.0000,651874.0000,654729.0000,651382.0000,653597.0000,652545.0000,659067.0000,652825.0000,652815.0000,651683.0000,651733.0000,651543.0000,658816.0000,650631.0000,652574.0000,654048.0000,651763.0000,651262.0000,662454.0000,651252.0000,652905.0000,654649.0000,653176.0000,652254.0000,658255.0000,652395.0000,653466.0000,653156.0000,652705.0000,651883.0000,653266.0000,688303.0000,652164.0000,652324.0000,651813.0000,650802.0000,652665.0000,661571.0000,652315.0000,651232.0000,652184.0000,652184.0000,651793.0000,655741.0000,651953.0000,651723.0000,652194.0000,652335.0000,652765.0000,659087.0000,650811.0000,653026.0000,650571.0000,650281.0000,650320.0000,656122.0000,651182.0000,650451.0000,649929.0000,648958.0000,650791.0000,656842.0000,651784.0000,650100.0000,650691.0000,650060.0000,649208.0000,659989.0000,649980.0000,649468.0000,650311.0000,648627.0000,650411.0000,655229.0000,650801.0000,649849.0000,650140.0000,650671.0000,653226.0000,651382.0000,655731.0000,652304.0000,653356.0000,653166.0000,652705.0000,650881.0000,664236.0000,651894.0000,652604.0000,651662.0000,651723.0000,652464.0000,659348.0000,651262.0000,652935.0000,651633.0000,652335.0000,652103.0000,658797.0000,653597.0000" +generating large task graphs,jacobi topology,100,1,22071200,221065.2300,220836.2300,221487.2100,1539.4516,948.1287,2401.1975,"220365.0000,220486.0000,222480.0000,221167.0000,225686.0000,220796.0000,221077.0000,221007.0000,221017.0000,220677.0000,220676.0000,220876.0000,220926.0000,220837.0000,220927.0000,220926.0000,220446.0000,220186.0000,220115.0000,220085.0000,220165.0000,221338.0000,230134.0000,220797.0000,221427.0000,220486.0000,220707.0000,221087.0000,221147.0000,220877.0000,221307.0000,221147.0000,220697.0000,220996.0000,220636.0000,220906.0000,220996.0000,220787.0000,220516.0000,221157.0000,224313.0000,220546.0000,221077.0000,220967.0000,220336.0000,220656.0000,219915.0000,220776.0000,221228.0000,220456.0000,220135.0000,220225.0000,220496.0000,220346.0000,220556.0000,220556.0000,220065.0000,220045.0000,225365.0000,220205.0000,220806.0000,220345.0000,220216.0000,220325.0000,220566.0000,220506.0000,221147.0000,220515.0000,220836.0000,220997.0000,220957.0000,220967.0000,221017.0000,221177.0000,221107.0000,220796.0000,229172.0000,220566.0000,220867.0000,220987.0000,220536.0000,220466.0000,220135.0000,220917.0000,220927.0000,220546.0000,220456.0000,220506.0000,220275.0000,220546.0000,220366.0000,220736.0000,220345.0000,220807.0000,224674.0000,220385.0000,220986.0000,220787.0000,221007.0000,220916.0000" +generating large command graphs for N nodes - 1,soup topology,100,1,2730586900,27651883.3800,27467491.9700,27786690.5000,799614.8705,624191.3124,989418.6674,"25777565.0000,27991442.0000,27989928.0000,27872527.0000,27399349.0000,25675603.0000,28135163.0000,27945986.0000,27995319.0000,27926508.0000,27886102.0000,25260116.0000,26274448.0000,27249976.0000,27952428.0000,27826669.0000,28025255.0000,28041606.0000,27899828.0000,26970767.0000,25057622.0000,27847428.0000,26415585.0000,24893140.0000,27880852.0000,28046847.0000,27971925.0000,27909515.0000,27830737.0000,27855694.0000,28075771.0000,28040004.0000,27957487.0000,27916840.0000,27944852.0000,27877546.0000,27875482.0000,28046916.0000,27913002.0000,27704587.0000,27914896.0000,27974609.0000,27863339.0000,28138821.0000,28165891.0000,27424768.0000,26129102.0000,28161272.0000,27993706.0000,27999857.0000,28176141.0000,28045643.0000,28060442.0000,28199847.0000,28159028.0000,28204315.0000,28090689.0000,28152477.0000,28196259.0000,28008214.0000,27953009.0000,27998584.0000,28128682.0000,28075691.0000,28185959.0000,28009135.0000,28160242.0000,25359363.0000,27660695.0000,27974179.0000,28104916.0000,27872106.0000,27767667.0000,27741697.0000,27543192.0000,27998404.0000,27929723.0000,27848851.0000,28017591.0000,28030564.0000,27940705.0000,28012091.0000,27950283.0000,28049722.0000,25507034.0000,28070000.0000,28008274.0000,28002041.0000,27854391.0000,27890610.0000,25482346.0000,28027899.0000,26002452.0000,26059851.0000,27957296.0000,27954722.0000,27865593.0000,27977304.0000,28008604.0000,27989137.0000" +generating large command graphs for N nodes - 1,chain topology,100,1,27522200,278151.7800,277808.8600,278677.1900,2135.7631,1503.9491,2982.6969,"277404.0000,287402.0000,284017.0000,279017.0000,278315.0000,278466.0000,278536.0000,279017.0000,278506.0000,278937.0000,278085.0000,278496.0000,277824.0000,278396.0000,277825.0000,283024.0000,278436.0000,278676.0000,277584.0000,279157.0000,278816.0000,278336.0000,278245.0000,278947.0000,278075.0000,277855.0000,278275.0000,277473.0000,277163.0000,281441.0000,277474.0000,277164.0000,276562.0000,277223.0000,277063.0000,278025.0000,276382.0000,277073.0000,277013.0000,277584.0000,276773.0000,277624.0000,276592.0000,286060.0000,277203.0000,278596.0000,277084.0000,276993.0000,277023.0000,277043.0000,276793.0000,277744.0000,277644.0000,277002.0000,276542.0000,277133.0000,277384.0000,278506.0000,282133.0000,277293.0000,277204.0000,277293.0000,276401.0000,278465.0000,277364.0000,277704.0000,277093.0000,277774.0000,277164.0000,277704.0000,276813.0000,277664.0000,288375.0000,278526.0000,277093.0000,277474.0000,277204.0000,277304.0000,277434.0000,276582.0000,277264.0000,276692.0000,276763.0000,277173.0000,276342.0000,277234.0000,276612.0000,284738.0000,277494.0000,277805.0000,276121.0000,277354.0000,277414.0000,277965.0000,277464.0000,277353.0000,278306.0000,278255.0000,277474.0000,278246.0000" +generating large command graphs for N nodes - 1,expanding tree topology,100,1,44648800,446435.6300,445853.8100,447448.2200,3834.3567,2588.8374,6230.7904,"445893.0000,444851.0000,470860.0000,447716.0000,446564.0000,445782.0000,446173.0000,446214.0000,459439.0000,444711.0000,445482.0000,445783.0000,444841.0000,445502.0000,445802.0000,444600.0000,445653.0000,452195.0000,445532.0000,444611.0000,444841.0000,444621.0000,445883.0000,444571.0000,446063.0000,445352.0000,450802.0000,444891.0000,446635.0000,445131.0000,444912.0000,445282.0000,445642.0000,444982.0000,444430.0000,459519.0000,446164.0000,445252.0000,445833.0000,444881.0000,445572.0000,444710.0000,443238.0000,444249.0000,452846.0000,445212.0000,445853.0000,445823.0000,445833.0000,445362.0000,445462.0000,445483.0000,445442.0000,451203.0000,444801.0000,444791.0000,445372.0000,444790.0000,444530.0000,445462.0000,445533.0000,444240.0000,456553.0000,444992.0000,444851.0000,444771.0000,444931.0000,444771.0000,445693.0000,444470.0000,444219.0000,450622.0000,446484.0000,444540.0000,445753.0000,446294.0000,446434.0000,444952.0000,446424.0000,445121.0000,451233.0000,444801.0000,445442.0000,445162.0000,445362.0000,444731.0000,444551.0000,444580.0000,444100.0000,455572.0000,445592.0000,445954.0000,444370.0000,444541.0000,444049.0000,444801.0000,445662.0000,445072.0000,451193.0000,445222.0000" +generating large command graphs for N nodes - 1,contracting tree topology,100,1,49329700,493044.9500,492531.9000,493749.3800,3039.2906,2350.9561,3930.6385,"490988.0000,491830.0000,497471.0000,492331.0000,492451.0000,500817.0000,491679.0000,492210.0000,492821.0000,491128.0000,491509.0000,491710.0000,491910.0000,498122.0000,491048.0000,491830.0000,490838.0000,490698.0000,491830.0000,490748.0000,492150.0000,502050.0000,494966.0000,493293.0000,494656.0000,494044.0000,492601.0000,492852.0000,491730.0000,492571.0000,498432.0000,494055.0000,492561.0000,494315.0000,492872.0000,493864.0000,493313.0000,493684.0000,498854.0000,493202.0000,491569.0000,491750.0000,492462.0000,493052.0000,492532.0000,492882.0000,504344.0000,493944.0000,493493.0000,492892.0000,493854.0000,493663.0000,493373.0000,491319.0000,497811.0000,491669.0000,491559.0000,491460.0000,491980.0000,491750.0000,493253.0000,492001.0000,504464.0000,492151.0000,490638.0000,492251.0000,491139.0000,490577.0000,489355.0000,489586.0000,495207.0000,491499.0000,490558.0000,491229.0000,490167.0000,489055.0000,489396.0000,489646.0000,496539.0000,491510.0000,491419.0000,490368.0000,490868.0000,490538.0000,492281.0000,492381.0000,504494.0000,492402.0000,492030.0000,492041.0000,492591.0000,490918.0000,492702.0000,492341.0000,498563.0000,491750.0000,492211.0000,492251.0000,492472.0000,492261.0000" +generating large command graphs for N nodes - 1,wave_sim topology,100,1,221465400,2228973.0800,2219224.0900,2231689.3000,23571.5999,6212.1525,54491.8263,"2212721.0000,2003555.0000,2235324.0000,2226487.0000,2226677.0000,2237869.0000,2233020.0000,2220656.0000,2231196.0000,2223591.0000,2225726.0000,2220907.0000,2239472.0000,2227068.0000,2232810.0000,2227941.0000,2229132.0000,2236336.0000,2224503.0000,2232548.0000,2222099.0000,2236816.0000,2221248.0000,2226227.0000,2237438.0000,2227860.0000,2237919.0000,2229933.0000,2241195.0000,2230996.0000,2243419.0000,2238430.0000,2236827.0000,2255242.0000,2238289.0000,2232228.0000,2225275.0000,2229463.0000,2227269.0000,2235334.0000,2232067.0000,2224864.0000,2234152.0000,2227709.0000,2241897.0000,2225275.0000,2235013.0000,2230736.0000,2236245.0000,2234221.0000,2224623.0000,2227730.0000,2226357.0000,2236587.0000,2223080.0000,2234302.0000,2222079.0000,2234803.0000,2233029.0000,2226727.0000,2231678.0000,2221097.0000,2237839.0000,2225686.0000,2231958.0000,2220736.0000,2238931.0000,2231958.0000,2225275.0000,2239111.0000,2223111.0000,2225566.0000,2222900.0000,2236466.0000,2224924.0000,2233490.0000,2234793.0000,2226196.0000,2237918.0000,2233189.0000,2233640.0000,2231727.0000,2239231.0000,2235575.0000,2230886.0000,2239472.0000,2223021.0000,2235585.0000,2228741.0000,2240173.0000,2228661.0000,2237077.0000,2235995.0000,2228170.0000,2238651.0000,2226868.0000,2235664.0000,2226216.0000,2239282.0000,2227309.0000" +generating large command graphs for N nodes - 1,jacobi topology,100,1,82542800,835088.7500,834374.4300,835924.2400,3966.5539,3407.2090,4617.2472,"833046.0000,832195.0000,840340.0000,843477.0000,832596.0000,835271.0000,834589.0000,829630.0000,838767.0000,831874.0000,829761.0000,835982.0000,830762.0000,844448.0000,834560.0000,832986.0000,829941.0000,831304.0000,838827.0000,834449.0000,832686.0000,833047.0000,841903.0000,832465.0000,831784.0000,833086.0000,832646.0000,842745.0000,830281.0000,830893.0000,834560.0000,830892.0000,840060.0000,835261.0000,832115.0000,830061.0000,831012.0000,843506.0000,835331.0000,835572.0000,832756.0000,833708.0000,842074.0000,833708.0000,833808.0000,833007.0000,843216.0000,834460.0000,833788.0000,834279.0000,834700.0000,843907.0000,834400.0000,834399.0000,834499.0000,833116.0000,842073.0000,835811.0000,834409.0000,836433.0000,836093.0000,842384.0000,835412.0000,834910.0000,834420.0000,833498.0000,844458.0000,834389.0000,832185.0000,834529.0000,836964.0000,832655.0000,832435.0000,831815.0000,831523.0000,838406.0000,833868.0000,834089.0000,833587.0000,833537.0000,847124.0000,836763.0000,834008.0000,833087.0000,835892.0000,839589.0000,836363.0000,831443.0000,829420.0000,832917.0000,841723.0000,830071.0000,830572.0000,836413.0000,838598.0000,832385.0000,832656.0000,832406.0000,832926.0000,840100.0000" +generating large command graphs for N nodes - 4,soup topology,100,1,6590492800,65577388.0900,65298067.3500,65753717.6700,1119938.0813,782242.9666,1527617.6770,"65821638.0000,65858448.0000,65950513.0000,65403987.0000,61466526.0000,65945563.0000,66201538.0000,65801540.0000,65770662.0000,60721864.0000,65940574.0000,63336690.0000,65747928.0000,65893704.0000,65946264.0000,66064197.0000,66037166.0000,66119462.0000,66098653.0000,66136204.0000,65928480.0000,66031886.0000,65972444.0000,65721008.0000,64932373.0000,62119824.0000,65950974.0000,65832148.0000,65627340.0000,66005727.0000,65884628.0000,65924714.0000,60720241.0000,62839627.0000,64908517.0000,66416185.0000,65958878.0000,66133960.0000,65971782.0000,65653720.0000,66138168.0000,65765732.0000,65877825.0000,65863417.0000,65825034.0000,66393371.0000,66074227.0000,65812120.0000,66033159.0000,66105456.0000,66055662.0000,66235252.0000,65349062.0000,65813943.0000,65778225.0000,65736246.0000,65991039.0000,65797994.0000,65727720.0000,65939662.0000,65911058.0000,65935333.0000,65955903.0000,65258691.0000,65899155.0000,65899335.0000,65886712.0000,66276530.0000,66036295.0000,65537760.0000,65757216.0000,65785901.0000,63510989.0000,64174707.0000,65832458.0000,66202319.0000,65760211.0000,65847636.0000,66011007.0000,65966593.0000,66104124.0000,65957335.0000,66106688.0000,66094575.0000,66057194.0000,65824082.0000,65896991.0000,66058417.0000,65833701.0000,66061192.0000,66096949.0000,66137417.0000,65951795.0000,65910987.0000,61611470.0000,65991550.0000,65856083.0000,65919604.0000,65955983.0000,65755972.0000" +generating large command graphs for N nodes - 4,chain topology,100,1,349841700,3504745.2200,3502985.2700,3507122.2100,10336.7890,7931.8991,14040.8684,"3503397.0000,3496173.0000,3546829.0000,3506042.0000,3491905.0000,3490573.0000,3524897.0000,3505461.0000,3502144.0000,3500972.0000,3497135.0000,3503777.0000,3509048.0000,3498918.0000,3499158.0000,3490673.0000,3495131.0000,3512715.0000,3501563.0000,3492706.0000,3495993.0000,3493228.0000,3506483.0000,3501093.0000,3503517.0000,3501604.0000,3491534.0000,3524727.0000,3500211.0000,3494240.0000,3493498.0000,3510640.0000,3502105.0000,3508146.0000,3506924.0000,3503928.0000,3497455.0000,3492656.0000,3500341.0000,3501313.0000,3504359.0000,3500261.0000,3506563.0000,3501303.0000,3504599.0000,3495471.0000,3500712.0000,3500381.0000,3504870.0000,3510420.0000,3508407.0000,3509979.0000,3518616.0000,3497366.0000,3505671.0000,3504248.0000,3519939.0000,3510109.0000,3551267.0000,3542591.0000,3512013.0000,3504780.0000,3515139.0000,3505380.0000,3514609.0000,3495532.0000,3515690.0000,3508347.0000,3507114.0000,3499099.0000,3509699.0000,3504870.0000,3508276.0000,3507164.0000,3501874.0000,3496253.0000,3512735.0000,3500262.0000,3494750.0000,3508456.0000,3512143.0000,3503026.0000,3504619.0000,3507725.0000,3505301.0000,3501814.0000,3491975.0000,3513055.0000,3501563.0000,3497225.0000,3502355.0000,3500832.0000,3501163.0000,3492476.0000,3492346.0000,3509057.0000,3502705.0000,3514859.0000,3502245.0000,3500011.0000" +generating large command graphs for N nodes - 4,expanding tree topology,100,1,977889000,9744932.1300,9692186.5600,9772594.3800,185372.4380,103549.9084,283543.4408,"9774341.0000,9773077.0000,9781293.0000,9787885.0000,9786063.0000,9767958.0000,9799498.0000,9786183.0000,9781704.0000,9766255.0000,9771164.0000,9777156.0000,9045449.0000,8746432.0000,8753436.0000,8844949.0000,9804728.0000,9815359.0000,9810969.0000,9809406.0000,9788457.0000,9769271.0000,9786864.0000,9770172.0000,9783438.0000,9779239.0000,9782836.0000,9782064.0000,9784469.0000,9780141.0000,9784150.0000,9779891.0000,9760333.0000,9791312.0000,9781434.0000,9805920.0000,9778848.0000,9772837.0000,9770924.0000,9776694.0000,9782004.0000,9778217.0000,9789639.0000,9766295.0000,9767057.0000,9754473.0000,9778128.0000,9769420.0000,9781884.0000,9770844.0000,9769491.0000,9778177.0000,9794338.0000,9794748.0000,9795520.0000,9792915.0000,9770723.0000,9776885.0000,9789389.0000,9780823.0000,9781454.0000,9780472.0000,9804016.0000,9799007.0000,9772647.0000,9765193.0000,9771505.0000,9759893.0000,9837730.0000,9814596.0000,9757558.0000,9783928.0000,9767166.0000,9812131.0000,9755134.0000,9773238.0000,9790079.0000,9770021.0000,9812883.0000,9768279.0000,9770893.0000,9783266.0000,9797243.0000,9793256.0000,9784589.0000,9779861.0000,9778267.0000,9792184.0000,9796242.0000,9789349.0000,9768018.0000,9786023.0000,9799167.0000,9775382.0000,9774340.0000,9776313.0000,9811109.0000,9753550.0000,9785211.0000,9748451.0000" +generating large command graphs for N nodes - 4,contracting tree topology,100,1,384494400,3908198.7900,3906694.8400,3909908.0000,8144.5437,6843.6924,10172.5172,"3912272.0000,3907783.0000,3926418.0000,3903415.0000,3911139.0000,3920177.0000,3899127.0000,3905259.0000,3911080.0000,3934173.0000,3914536.0000,3907312.0000,3907383.0000,3905379.0000,3894869.0000,3915027.0000,3911340.0000,3914957.0000,3897934.0000,3909847.0000,3907693.0000,3922682.0000,3908134.0000,3919485.0000,3910037.0000,3910779.0000,3916911.0000,3909316.0000,3908795.0000,3909937.0000,3911530.0000,3910348.0000,3907052.0000,3895470.0000,3895109.0000,3912653.0000,3902954.0000,3913594.0000,3906069.0000,3902733.0000,3905179.0000,3905809.0000,3920146.0000,3926679.0000,3918483.0000,3901742.0000,3904998.0000,3911490.0000,3909286.0000,3920778.0000,3939173.0000,3907573.0000,3905219.0000,3897504.0000,3916490.0000,3907623.0000,3906781.0000,3920627.0000,3904938.0000,3912122.0000,3900649.0000,3903344.0000,3903214.0000,3900570.0000,3913404.0000,3910088.0000,3907182.0000,3907102.0000,3901602.0000,3913294.0000,3910618.0000,3899307.0000,3910037.0000,3902653.0000,3906170.0000,3906560.0000,3898946.0000,3909176.0000,3900750.0000,3903876.0000,3911250.0000,3895490.0000,3889108.0000,3902063.0000,3897754.0000,3911030.0000,3902363.0000,3907513.0000,3906350.0000,3901451.0000,3909066.0000,3910558.0000,3892644.0000,3910148.0000,3911110.0000,3896432.0000,3911901.0000,3907733.0000,3906000.0000,3898025.0000" +generating large command graphs for N nodes - 4,wave_sim topology,100,1,1588339200,15832766.4800,15757082.9200,15865716.0100,240437.1519,120007.0972,434642.7955,"15862427.0000,15887554.0000,15875030.0000,15860634.0000,15862266.0000,15904055.0000,15868779.0000,15857488.0000,15869420.0000,15883126.0000,15853190.0000,15860232.0000,15883787.0000,15882595.0000,15886713.0000,15889709.0000,15930525.0000,15882034.0000,15875301.0000,15909105.0000,15894888.0000,15884919.0000,15890319.0000,15875833.0000,15865192.0000,15893556.0000,15869871.0000,15889318.0000,15861545.0000,15886693.0000,15931959.0000,15905949.0000,15881343.0000,15895599.0000,15873598.0000,15877375.0000,15878718.0000,15340558.0000,14065261.0000,14690887.0000,15963288.0000,15909296.0000,15852258.0000,15891762.0000,15888717.0000,15892744.0000,15868177.0000,15846056.0000,15878969.0000,15883487.0000,15866805.0000,15903304.0000,15869540.0000,15862096.0000,15880481.0000,15900419.0000,15812091.0000,15860103.0000,15851306.0000,15882434.0000,15874349.0000,15885631.0000,15874540.0000,15855814.0000,15897944.0000,15901521.0000,15870251.0000,15915728.0000,15873668.0000,15879118.0000,15901381.0000,15888195.0000,15883346.0000,15867427.0000,15790931.0000,14902869.0000,15862246.0000,15876723.0000,15885430.0000,15888977.0000,15882395.0000,15902463.0000,15884680.0000,15869530.0000,15841407.0000,15864962.0000,15880531.0000,15875632.0000,15872967.0000,15884038.0000,15833232.0000,15845144.0000,15852578.0000,15872486.0000,15866545.0000,15902843.0000,15891071.0000,15855293.0000,15844703.0000,15877375.0000" +generating large command graphs for N nodes - 4,jacobi topology,100,1,549922200,5447579.9700,5400098.3900,5482046.3500,205399.5164,160253.3866,249092.2283,"5170716.0000,5540948.0000,5564392.0000,5539535.0000,5518154.0000,5537220.0000,5576315.0000,5547180.0000,5517694.0000,5523014.0000,5543232.0000,5512985.0000,5065036.0000,4879625.0000,4877821.0000,4876498.0000,4872220.0000,5413035.0000,5518005.0000,5526932.0000,5533915.0000,5525619.0000,5539314.0000,5520328.0000,5197266.0000,4908990.0000,5505992.0000,5526390.0000,5546037.0000,5527363.0000,5528875.0000,5546088.0000,5520329.0000,5545096.0000,5585452.0000,5535377.0000,5545747.0000,5545998.0000,5530809.0000,5535428.0000,5528755.0000,5536750.0000,5561737.0000,5533914.0000,5536861.0000,5522002.0000,5512414.0000,5524597.0000,5513126.0000,5525378.0000,5518616.0000,5522062.0000,5530247.0000,5523085.0000,5534115.0000,5526330.0000,5516010.0000,5530849.0000,5522594.0000,5536850.0000,5551007.0000,5525780.0000,5536870.0000,5519447.0000,5520168.0000,5530398.0000,5521601.0000,5517594.0000,5532221.0000,5513466.0000,5527001.0000,5504740.0000,5519127.0000,5524747.0000,5515620.0000,5526862.0000,5518756.0000,5539455.0000,5517444.0000,5535938.0000,5526420.0000,5522383.0000,5517895.0000,5528113.0000,5530418.0000,5529767.0000,5530358.0000,5516361.0000,5536430.0000,5515239.0000,5524016.0000,5536128.0000,5532882.0000,5534536.0000,4946802.0000,4904972.0000,4898691.0000,4889704.0000,4910483.0000,4900895.0000" +generating large command graphs for N nodes - 16,soup topology,100,1,22341337900,223837319.4600,223529433.1400,224059751.2700,1331417.8420,1043582.7009,1642282.6050,"224434007.0000,219083488.0000,221202267.0000,223520760.0000,223448052.0000,224489837.0000,224498724.0000,223659674.0000,223511614.0000,223979651.0000,221025351.0000,223886022.0000,223949151.0000,223551459.0000,220544620.0000,224477553.0000,224547106.0000,224552044.0000,224476300.0000,224470991.0000,223992695.0000,224595767.0000,224174108.0000,221639045.0000,224191561.0000,223915568.0000,220148949.0000,224800705.0000,224088105.0000,224437847.0000,224800044.0000,224313923.0000,224165701.0000,224223322.0000,224623509.0000,224254630.0000,224574596.0000,224443839.0000,223637010.0000,223914094.0000,224770797.0000,223645003.0000,224476801.0000,220649498.0000,224587030.0000,224926863.0000,224249249.0000,220849136.0000,223875801.0000,221565253.0000,223990478.0000,224297131.0000,224254899.0000,224574395.0000,224604612.0000,224239070.0000,224925540.0000,224158517.0000,224115474.0000,224017310.0000,223910847.0000,221052170.0000,224181280.0000,224322287.0000,224819268.0000,224577540.0000,224522716.0000,224339931.0000,224327656.0000,224524761.0000,224220894.0000,224695103.0000,223808543.0000,224808798.0000,224684043.0000,224520612.0000,224181990.0000,224389735.0000,224449316.0000,219935574.0000,224879663.0000,224142065.0000,224315052.0000,224673451.0000,225279600.0000,224584643.0000,224635610.0000,223983453.0000,219725215.0000,224277340.0000,224422896.0000,224192249.0000,224292099.0000,224596395.0000,224825979.0000,224484552.0000,224175367.0000,220032857.0000,224387629.0000,224536221.0000" +generating large command graphs for N nodes - 16,chain topology,100,1,43552853000,438905484.0900,438218015.2600,439448138.0600,3118030.6465,2564728.5599,3915794.0883,"441010740.0000,440254617.0000,440292546.0000,440627610.0000,440655422.0000,440461335.0000,435413729.0000,439549717.0000,439955326.0000,436522289.0000,441056962.0000,440450413.0000,440668736.0000,440176294.0000,434836133.0000,434388266.0000,439888627.0000,439530990.0000,438576630.0000,441180555.0000,439900850.0000,440339641.0000,440538488.0000,439969991.0000,433869200.0000,441919575.0000,433805830.0000,441988585.0000,432288484.0000,438655649.0000,433683006.0000,436971758.0000,440598490.0000,438916302.0000,440015025.0000,435199439.0000,440558594.0000,439604316.0000,440667750.0000,441126268.0000,430402378.0000,434957960.0000,438113660.0000,437076204.0000,440755495.0000,440614368.0000,441550962.0000,440681946.0000,441077985.0000,432697265.0000,441417348.0000,440355647.0000,438739354.0000,440765574.0000,440213036.0000,440698386.0000,440236831.0000,440338674.0000,432294631.0000,440014819.0000,440597024.0000,440012725.0000,440127222.0000,440971612.0000,440753819.0000,440483417.0000,441082572.0000,426542249.0000,433975956.0000,440930803.0000,436254011.0000,441237083.0000,441037456.0000,440581301.0000,439953591.0000,439777958.0000,432052819.0000,440673906.0000,440379607.0000,438751543.0000,441428616.0000,441433855.0000,441486976.0000,440275780.0000,440513129.0000,436781319.0000,442654868.0000,441701060.0000,439901941.0000,440676769.0000,440523338.0000,440078144.0000,440344549.0000,440273394.0000,437511431.0000,435190202.0000,428632395.0000,434687279.0000,440297890.0000,440862099.0000" +generating large command graphs for N nodes - 16,expanding tree topology,100,1,71917759100,717760331.1400,716858586.9700,718582342.6800,4365997.0781,3846653.6139,5132937.1918,"718619832.0000,716085651.0000,722004094.0000,719027332.0000,720798950.0000,720869522.0000,720377600.0000,722300293.0000,718389021.0000,721927956.0000,722054356.0000,721002061.0000,718715107.0000,716707834.0000,717323940.0000,721893659.0000,719742522.0000,721159026.0000,718277756.0000,713742623.0000,725017807.0000,720835451.0000,722588553.0000,723949481.0000,721328545.0000,715528503.0000,721730005.0000,721700889.0000,723008225.0000,718161311.0000,712812175.0000,720493519.0000,721762584.0000,720952729.0000,721031458.0000,720930255.0000,717027280.0000,724798013.0000,720507142.0000,724512642.0000,720224717.0000,715382261.0000,712045186.0000,721522955.0000,715502578.0000,724481141.0000,713703658.0000,715727352.0000,719441860.0000,720677431.0000,717369622.0000,715236681.0000,719501892.0000,709417533.0000,715724373.0000,723071265.0000,722294322.0000,714476058.0000,716438695.0000,711300238.0000,715712739.0000,713898311.0000,709488314.0000,721410674.0000,718756115.0000,719368244.0000,713777099.0000,722228332.0000,722500458.0000,718456265.0000,711400014.0000,721536020.0000,721195294.0000,715589270.0000,704484478.0000,717669421.0000,704949368.0000,716275880.0000,720239951.0000,711156789.0000,715054063.0000,715452508.0000,712258376.0000,715822038.0000,715155985.0000,715855170.0000,714129901.0000,717076162.0000,711023524.0000,715797719.0000,719462653.0000,717349960.0000,715108652.0000,711862782.0000,724759659.0000,715864023.0000,709941670.0000,708560523.0000,720179730.0000,711989460.0000" +generating large command graphs for N nodes - 16,contracting tree topology,100,1,14032628700,139656299.5800,139283337.0600,139886817.0300,1470612.2497,1035566.7647,2064082.6505,"140443535.0000,139933930.0000,140077994.0000,140008472.0000,138792559.0000,141068041.0000,139988144.0000,140676788.0000,140235893.0000,139787103.0000,139888766.0000,140081892.0000,140670497.0000,139806370.0000,140041074.0000,139949762.0000,139758168.0000,139846977.0000,139816068.0000,139966302.0000,140128430.0000,140176922.0000,140104805.0000,139946635.0000,139828320.0000,132154550.0000,140806545.0000,139726548.0000,140027869.0000,139888004.0000,134484676.0000,139930624.0000,140168456.0000,134589113.0000,140107800.0000,140099195.0000,140281910.0000,140363956.0000,140127658.0000,140092621.0000,140431363.0000,140430422.0000,139900077.0000,139988674.0000,139910987.0000,140037838.0000,139829052.0000,140459165.0000,139845122.0000,139892753.0000,139832318.0000,140151804.0000,140293903.0000,135001705.0000,136056464.0000,140511044.0000,139759099.0000,134686938.0000,140191228.0000,140134500.0000,140390837.0000,136395165.0000,138807366.0000,139959359.0000,139881562.0000,140015876.0000,140455539.0000,140602317.0000,140425301.0000,140907505.0000,140133118.0000,139961112.0000,139887312.0000,139912469.0000,140407156.0000,140118581.0000,140117568.0000,139863847.0000,139991609.0000,140039450.0000,139920284.0000,140036395.0000,136467652.0000,140081490.0000,140744276.0000,140090327.0000,139976410.0000,140050661.0000,140093823.0000,140025914.0000,138696185.0000,139825895.0000,139919723.0000,139922178.0000,140242144.0000,139982302.0000,139764940.0000,139789787.0000,140621934.0000,139887161.0000" +generating large command graphs for N nodes - 16,wave_sim topology,100,1,13661736700,136091353.7200,135735072.4300,136307005.7100,1382756.0165,937846.4000,1933841.1917,"136568591.0000,136669734.0000,136472551.0000,136563614.0000,136530791.0000,136370397.0000,132016126.0000,134498270.0000,136498650.0000,136555158.0000,136682720.0000,136760757.0000,136607187.0000,136594111.0000,135127042.0000,136492870.0000,136544357.0000,136377000.0000,136396927.0000,136519911.0000,136512567.0000,136518969.0000,136461380.0000,136459617.0000,136459787.0000,136517786.0000,136554115.0000,136718997.0000,136474875.0000,136464716.0000,136568773.0000,136386077.0000,136399012.0000,136424409.0000,136221786.0000,131644252.0000,129569000.0000,136648224.0000,136402348.0000,131755162.0000,136411966.0000,136567571.0000,136547964.0000,134601906.0000,133924563.0000,136349047.0000,136610362.0000,136655848.0000,136586978.0000,136438566.0000,136424910.0000,136450920.0000,136519700.0000,136597638.0000,136476338.0000,136300013.0000,136310844.0000,136805381.0000,136614980.0000,136850286.0000,136644086.0000,136639707.0000,136543615.0000,136473612.0000,136645027.0000,131170153.0000,135034916.0000,136570706.0000,136569675.0000,136571457.0000,136547963.0000,136564615.0000,136694341.0000,135438391.0000,136739035.0000,136572599.0000,136668261.0000,136559254.0000,136438515.0000,136352634.0000,136525380.0000,136407828.0000,136470306.0000,136561980.0000,136593109.0000,136424299.0000,136528706.0000,136525600.0000,136454575.0000,136441100.0000,136658291.0000,136677238.0000,136588029.0000,136536471.0000,136432815.0000,129815135.0000,136521443.0000,136517245.0000,136459044.0000,136503819.0000" +generating large command graphs for N nodes - 16,jacobi topology,100,1,13098933200,130839766.5700,130571317.7400,131223504.3600,1608945.3038,981346.9185,2894170.3940,"130697647.0000,131080321.0000,130974683.0000,130687598.0000,130999249.0000,130946268.0000,131010499.0000,131164963.0000,130765015.0000,130873139.0000,131171836.0000,130595945.0000,130824587.0000,130942712.0000,130835629.0000,130863552.0000,130999640.0000,130890413.0000,131303826.0000,125935453.0000,127218876.0000,130908747.0000,131198757.0000,125678267.0000,131158059.0000,131175282.0000,131045356.0000,131095942.0000,125627319.0000,131061357.0000,131048181.0000,131072969.0000,130932302.0000,131058561.0000,131120948.0000,131334433.0000,131309867.0000,131346897.0000,130786235.0000,131151427.0000,130817764.0000,131040326.0000,131189950.0000,130948162.0000,131037802.0000,131064361.0000,131001081.0000,131213064.0000,130804720.0000,131080442.0000,131170603.0000,127244665.0000,131150385.0000,131348971.0000,131145576.0000,130934335.0000,131009919.0000,131193887.0000,129192665.0000,131185731.0000,131261205.0000,130914568.0000,131058821.0000,131092064.0000,131223062.0000,131014908.0000,131081614.0000,131020960.0000,131432598.0000,131720274.0000,131050536.0000,131280992.0000,131167087.0000,131284238.0000,131040747.0000,130926650.0000,130881244.0000,131001052.0000,130982998.0000,131130777.0000,130601373.0000,127511841.0000,131033353.0000,131160263.0000,131054443.0000,131386853.0000,131489707.0000,130994139.0000,142311172.0000,129811467.0000,130678250.0000,130882877.0000,131115619.0000,130591214.0000,131052078.0000,130364365.0000,130002790.0000,131221640.0000,131065523.0000,130414129.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,soup topology,100,1,2814285800,27995963.4100,27872730.2000,28051003.8500,398272.9303,179872.5308,683619.5638,"28064374.0000,27941051.0000,28030551.0000,28065176.0000,28092138.0000,27922647.0000,28026263.0000,28166618.0000,28345437.0000,27965727.0000,28149706.0000,28124548.0000,28119819.0000,28076899.0000,28070697.0000,28025091.0000,28072119.0000,27957051.0000,28006035.0000,25233421.0000,25792811.0000,28120251.0000,27990856.0000,28035290.0000,28046431.0000,28139768.0000,28015863.0000,28199741.0000,28043516.0000,28139577.0000,27967041.0000,28055198.0000,28149897.0000,28075726.0000,28119891.0000,28051210.0000,28051441.0000,28129949.0000,27973803.0000,28118327.0000,28128637.0000,28008179.0000,28119068.0000,28003580.0000,28022767.0000,28198068.0000,28036893.0000,27990996.0000,28081928.0000,28145629.0000,28067832.0000,27937424.0000,28071599.0000,28011004.0000,28149316.0000,27869946.0000,28043185.0000,28131853.0000,27405356.0000,27907308.0000,28107727.0000,28037855.0000,28170586.0000,28014400.0000,28050929.0000,27955859.0000,27970697.0000,28056480.0000,28162431.0000,28035991.0000,28009281.0000,28177239.0000,28118818.0000,28117896.0000,28085365.0000,28050990.0000,28057873.0000,27977981.0000,28052803.0000,28063152.0000,28103009.0000,28213387.0000,28248885.0000,28113178.0000,27944237.0000,28058053.0000,28004963.0000,28039898.0000,28152111.0000,27982339.0000,26604719.0000,27999913.0000,28090414.0000,28130239.0000,28021414.0000,28123366.0000,28140078.0000,28105984.0000,28171418.0000,28071860.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,chain topology,100,1,27878500,279709.4000,279241.6900,280377.0100,2836.2489,2138.9697,3688.9868,"277564.0000,278866.0000,288375.0000,279848.0000,281061.0000,280460.0000,285038.0000,279738.0000,279527.0000,279668.0000,278616.0000,279677.0000,279257.0000,279728.0000,279949.0000,279648.0000,280289.0000,280019.0000,279287.0000,278987.0000,287994.0000,279889.0000,279347.0000,278565.0000,278836.0000,277875.0000,279468.0000,278495.0000,277954.0000,278697.0000,278796.0000,277814.0000,278115.0000,277513.0000,278315.0000,282273.0000,277815.0000,277985.0000,278365.0000,277493.0000,277994.0000,278716.0000,277914.0000,278175.0000,277554.0000,277323.0000,277764.0000,277855.0000,277594.0000,289096.0000,277464.0000,278225.0000,279026.0000,277554.0000,278055.0000,277214.0000,278696.0000,277013.0000,278656.0000,278075.0000,279077.0000,278807.0000,281832.0000,290749.0000,287303.0000,284797.0000,283595.0000,282934.0000,278837.0000,279788.0000,278707.0000,279768.0000,278205.0000,278326.0000,278155.0000,278566.0000,279167.0000,290870.0000,278846.0000,279708.0000,280068.0000,278837.0000,279798.0000,279057.0000,278346.0000,278155.0000,279478.0000,279537.0000,279878.0000,279478.0000,278616.0000,278435.0000,285599.0000,278946.0000,278996.0000,277955.0000,278937.0000,278556.0000,278616.0000,278446.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,44716700,447262.8400,446898.9800,447814.6200,2243.4921,1640.2110,3009.1090,"447216.0000,447075.0000,454480.0000,447075.0000,446915.0000,453658.0000,447215.0000,447596.0000,447065.0000,445092.0000,448267.0000,445452.0000,446344.0000,445412.0000,451774.0000,447276.0000,446103.0000,446634.0000,445943.0000,444871.0000,446054.0000,446744.0000,446955.0000,456293.0000,446785.0000,446073.0000,446695.0000,445963.0000,446474.0000,446464.0000,446033.0000,446153.0000,451083.0000,447126.0000,447045.0000,445953.0000,447065.0000,447365.0000,446064.0000,446394.0000,447536.0000,450331.0000,447445.0000,446935.0000,447035.0000,447436.0000,446665.0000,447376.0000,447275.0000,446434.0000,456653.0000,446334.0000,446845.0000,446885.0000,447616.0000,447226.0000,446995.0000,446464.0000,447887.0000,449991.0000,447285.0000,445522.0000,446364.0000,446915.0000,447065.0000,447246.0000,446614.0000,445723.0000,450041.0000,446113.0000,446434.0000,445171.0000,446343.0000,446594.0000,445823.0000,445753.0000,446364.0000,456162.0000,446293.0000,446164.0000,445502.0000,446384.0000,446765.0000,446314.0000,445923.0000,450492.0000,446434.0000,445292.0000,446193.0000,446103.0000,446744.0000,446213.0000,446184.0000,445702.0000,449970.0000,446495.0000,446895.0000,446364.0000,445993.0000,446725.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,49594200,497440.2000,495673.5500,504674.6000,16166.7389,2388.9369,38176.7338,"494625.0000,494144.0000,504033.0000,496428.0000,495707.0000,495497.0000,495026.0000,497511.0000,494735.0000,503923.0000,494555.0000,493954.0000,495317.0000,495607.0000,494997.0000,494495.0000,495287.0000,500887.0000,496138.0000,493794.0000,495677.0000,495588.0000,495456.0000,494705.0000,494595.0000,505656.0000,494565.0000,493854.0000,495858.0000,495046.0000,495838.0000,494976.0000,494715.0000,499715.0000,494616.0000,494565.0000,493954.0000,494344.0000,494966.0000,494635.0000,495046.0000,499705.0000,496318.0000,494906.0000,494976.0000,493744.0000,493794.0000,495356.0000,493082.0000,505376.0000,494324.0000,495316.0000,493824.0000,495387.0000,493914.0000,493704.0000,492601.0000,500837.0000,493964.0000,494926.0000,494144.0000,494465.0000,494726.0000,494856.0000,495276.0000,656222.0000,494956.0000,494796.0000,494455.0000,495127.0000,494495.0000,496028.0000,493924.0000,499745.0000,496720.0000,495577.0000,496178.0000,495257.0000,496599.0000,494796.0000,495146.0000,500617.0000,494305.0000,495186.0000,494285.0000,494725.0000,495076.0000,495346.0000,494434.0000,505385.0000,495196.0000,494766.0000,495597.0000,495357.0000,495407.0000,496098.0000,495397.0000,499665.0000,496078.0000,496528.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,222556300,2226367.1800,2224263.0000,2232897.1300,17202.1917,6670.2869,38181.6073,"2223872.0000,2225826.0000,2246574.0000,2226647.0000,2237789.0000,2221076.0000,2230344.0000,2220205.0000,2229803.0000,2220916.0000,2231346.0000,2220456.0000,2222890.0000,2230534.0000,2224583.0000,2230705.0000,2222690.0000,2234272.0000,2224393.0000,2230655.0000,2224433.0000,2229723.0000,2240233.0000,2222108.0000,2229843.0000,2221106.0000,2231717.0000,2220566.0000,2231476.0000,2219894.0000,2235534.0000,2233910.0000,2221677.0000,2235114.0000,2224623.0000,2229743.0000,2211077.0000,2249760.0000,2214223.0000,2235042.0000,2224022.0000,2218101.0000,2228802.0000,2220085.0000,2234171.0000,2224744.0000,2229633.0000,2221217.0000,2232608.0000,2236696.0000,2214584.0000,2231766.0000,2218912.0000,2225415.0000,2216638.0000,2225595.0000,2223932.0000,2226357.0000,2223952.0000,2218312.0000,2228260.0000,2215155.0000,2226106.0000,2218701.0000,2227118.0000,2213262.0000,2224854.0000,2228200.0000,2218883.0000,2227108.0000,2217150.0000,2224643.0000,2217860.0000,2225575.0000,2213853.0000,2221167.0000,2227779.0000,2219334.0000,2222410.0000,2224212.0000,2382662.0000,2213633.0000,2229533.0000,2223772.0000,2214985.0000,2222700.0000,2218141.0000,2217320.0000,2220436.0000,2222930.0000,2218953.0000,2233610.0000,2221768.0000,2220796.0000,2226186.0000,2216849.0000,2220656.0000,2213973.0000,2225605.0000,2217660.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,jacobi topology,100,1,83595300,835391.6000,834734.2000,836193.3600,3702.1574,3087.8784,4400.5155,"837916.0000,833247.0000,842365.0000,832455.0000,840040.0000,833147.0000,832255.0000,833637.0000,833037.0000,837886.0000,833598.0000,832796.0000,833267.0000,834910.0000,845019.0000,834950.0000,836663.0000,834359.0000,833418.0000,837825.0000,833157.0000,833838.0000,832666.0000,844969.0000,834268.0000,835090.0000,834560.0000,832335.0000,843226.0000,834971.0000,831543.0000,832254.0000,832074.0000,845450.0000,835240.0000,835261.0000,834389.0000,834079.0000,841653.0000,834550.0000,835591.0000,835922.0000,831283.0000,843116.0000,832766.0000,830191.0000,833027.0000,836924.0000,833788.0000,834719.0000,833377.0000,831804.0000,845089.0000,835721.0000,838477.0000,835471.0000,835401.0000,839389.0000,834359.0000,833227.0000,832866.0000,834910.0000,841092.0000,834620.0000,833838.0000,833077.0000,844137.0000,833528.0000,833898.0000,833618.0000,836102.0000,838898.0000,833027.0000,830622.0000,833858.0000,833718.0000,837325.0000,834560.0000,833537.0000,835251.0000,834890.0000,846723.0000,835481.0000,834189.0000,835842.0000,835361.0000,838216.0000,832897.0000,831904.0000,831363.0000,838407.0000,834219.0000,832896.0000,830863.0000,830592.0000,842995.0000,831694.0000,832175.0000,834960.0000,833006.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,soup topology,100,1,2272782000,24165362.8300,23636387.9400,24619670.7200,2485140.7707,2095830.3079,2972319.2956,"21789075.0000,25852414.0000,25845110.0000,24785682.0000,25472353.0000,26109672.0000,25006531.0000,19605898.0000,18682617.0000,22660145.0000,24126103.0000,25939869.0000,24563762.0000,24893206.0000,22287008.0000,17746134.0000,18278513.0000,23766351.0000,25954387.0000,25250974.0000,26261990.0000,25566341.0000,26345798.0000,26496905.0000,25171273.0000,25730392.0000,25649298.0000,24707374.0000,25759447.0000,26181117.0000,23068187.0000,24690953.0000,25599083.0000,26189913.0000,23078226.0000,24133827.0000,25617930.0000,23067146.0000,24050368.0000,25144342.0000,25972361.0000,24707133.0000,25212090.0000,22744644.0000,23382604.0000,25370982.0000,23040285.0000,24495622.0000,25405818.0000,25718480.0000,25170431.0000,25195038.0000,26017146.0000,25674375.0000,25312200.0000,25843417.0000,18833113.0000,26850424.0000,25426857.0000,26224037.0000,30440276.0000,23833969.0000,25267315.0000,25705385.0000,25724581.0000,26233416.0000,18818786.0000,23325014.0000,24327344.0000,24927221.0000,26945926.0000,23928198.0000,19310247.0000,22010464.0000,21737005.0000,25367254.0000,25399696.0000,24206445.0000,25652404.0000,26883146.0000,26588608.0000,30278790.0000,24964491.0000,22389121.0000,24395372.0000,25074780.0000,26020372.0000,24788368.0000,22350298.0000,18691264.0000,23318071.0000,22273763.0000,19932667.0000,22819807.0000,21310508.0000,22825247.0000,23384076.0000,18634927.0000,16303460.0000,22425430.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,chain topology,100,1,100470200,805665.5700,796853.6900,815097.6800,46484.1637,39812.6418,56551.0049,"786088.0000,783472.0000,643949.0000,837435.0000,784714.0000,843677.0000,871129.0000,778073.0000,757573.0000,872161.0000,896627.0000,874746.0000,821345.0000,821014.0000,748547.0000,821214.0000,769205.0000,882770.0000,904863.0000,907257.0000,900935.0000,882491.0000,900254.0000,937164.0000,854467.0000,878413.0000,849769.0000,849698.0000,921905.0000,841062.0000,839689.0000,812107.0000,871038.0000,754167.0000,785155.0000,842264.0000,842094.0000,812969.0000,839118.0000,785076.0000,784885.0000,842655.0000,780958.0000,813360.0000,812809.0000,847063.0000,778373.0000,810815.0000,783382.0000,785847.0000,786328.0000,813800.0000,780267.0000,811566.0000,815182.0000,780106.0000,785266.0000,783302.0000,785446.0000,781038.0000,779365.0000,789905.0000,784143.0000,780517.0000,758195.0000,780567.0000,758294.0000,781990.0000,779194.0000,787781.0000,779956.0000,786899.0000,781339.0000,810785.0000,756140.0000,783332.0000,783903.0000,783903.0000,783332.0000,784344.0000,814251.0000,781059.0000,757093.0000,755420.0000,781228.0000,724561.0000,753816.0000,756081.0000,811535.0000,815563.0000,781859.0000,754347.0000,782651.0000,786388.0000,811295.0000,782831.0000,787500.0000,782211.0000,780337.0000,784505.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,expanding tree topology,100,1,78810800,727347.3300,714076.4300,744644.2500,76785.6450,62358.0325,93260.9836,"665679.0000,723038.0000,1003459.0000,907848.0000,913730.0000,909902.0000,914540.0000,914811.0000,877371.0000,856641.0000,908970.0000,941673.0000,851812.0000,796517.0000,771800.0000,766510.0000,692120.0000,664517.0000,726104.0000,664387.0000,724030.0000,691539.0000,695806.0000,688031.0000,664687.0000,691728.0000,666311.0000,691479.0000,664757.0000,665258.0000,664897.0000,691999.0000,665950.0000,722207.0000,666230.0000,722797.0000,665629.0000,722568.0000,666000.0000,693693.0000,689805.0000,691499.0000,665028.0000,691408.0000,692019.0000,687381.0000,870858.0000,870427.0000,871019.0000,871319.0000,739890.0000,666050.0000,691458.0000,691889.0000,679666.0000,701236.0000,702209.0000,700725.0000,701407.0000,701177.0000,701808.0000,715845.0000,711206.0000,701988.0000,701256.0000,701817.0000,701246.0000,701687.0000,725874.0000,701127.0000,702399.0000,700766.0000,701878.0000,725343.0000,701217.0000,701979.0000,701327.0000,702028.0000,709502.0000,716646.0000,702359.0000,700475.0000,702239.0000,701087.0000,699684.0000,723509.0000,691629.0000,691769.0000,691949.0000,691629.0000,692010.0000,691528.0000,692000.0000,691659.0000,691909.0000,692150.0000,691899.0000,664037.0000,666431.0000,664347.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,contracting tree topology,100,1,93320500,914252.2700,860921.5200,973547.5300,285106.3005,248960.8417,335407.6774,"928477.0000,929068.0000,946832.0000,1258253.0000,1038165.0000,1010724.0000,1037323.0000,931814.0000,958364.0000,1010883.0000,1064325.0000,983442.0000,859426.0000,851200.0000,825331.0000,1066339.0000,851692.0000,851301.0000,852143.0000,886798.0000,1474652.0000,1452311.0000,1499499.0000,1500431.0000,1451198.0000,1371336.0000,1277448.0000,1097017.0000,698431.0000,654869.0000,657944.0000,649819.0000,656472.0000,650370.0000,664226.0000,650220.0000,656151.0000,659388.0000,654538.0000,627416.0000,526856.0000,540472.0000,538638.0000,540492.0000,530123.0000,543167.0000,529502.0000,536945.0000,543117.0000,531595.0000,532627.0000,528890.0000,542005.0000,721705.0000,808570.0000,862182.0000,853776.0000,857302.0000,849528.0000,860709.0000,865157.0000,852403.0000,852964.0000,856581.0000,863584.0000,782490.0000,579947.0000,580869.0000,609393.0000,628970.0000,726154.0000,851190.0000,851160.0000,851752.0000,851551.0000,904592.0000,1014080.0000,1143325.0000,1145048.0000,1277368.0000,1170406.0000,1144046.0000,1198239.0000,1170847.0000,1170245.0000,1243855.0000,1247622.0000,1132494.0000,1190394.0000,1452159.0000,1770943.0000,1771505.0000,1073512.0000,928888.0000,986437.0000,957171.0000,958784.0000,957141.0000,958594.0000,929530.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,wave_sim topology,100,1,424673000,4373288.1700,4242476.3500,4528684.3300,726948.7388,631161.7937,819526.3633,"3501472.0000,3493687.0000,4320805.0000,4150632.0000,4923426.0000,4756401.0000,3854983.0000,3688918.0000,3745365.0000,3773498.0000,3716981.0000,3715508.0000,3716801.0000,3774911.0000,3717081.0000,3773087.0000,3717752.0000,3772576.0000,3747920.0000,3743031.0000,3761856.0000,3900999.0000,3717673.0000,3688136.0000,3748041.0000,3773188.0000,4857331.0000,3930455.0000,4007472.0000,3949722.0000,4036346.0000,4034153.0000,4006459.0000,3948980.0000,4035905.0000,3860994.0000,4035654.0000,4121598.0000,4007993.0000,4064540.0000,4008283.0000,3944713.0000,4094868.0000,4005237.0000,4009515.0000,4034853.0000,4036627.0000,4034863.0000,4068327.0000,4089918.0000,4038360.0000,4004756.0000,3950303.0000,4003855.0000,4066413.0000,4006069.0000,3919675.0000,4035485.0000,4066332.0000,3976903.0000,4005869.0000,4094938.0000,4062486.0000,4008914.0000,4035425.0000,4006168.0000,3920145.0000,4006199.0000,4066213.0000,4290166.0000,5086165.0000,5080334.0000,5102186.0000,5084262.0000,5079323.0000,5081837.0000,5961785.0000,5892844.0000,5864850.0000,5923662.0000,5861625.0000,5923332.0000,5921268.0000,5895990.0000,5923282.0000,5920977.0000,5865542.0000,5682334.0000,5319968.0000,5376827.0000,5221021.0000,5503997.0000,5421952.0000,5528544.0000,4840030.0000,4231375.0000,4174577.0000,4237086.0000,4256023.0000,4081611.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,jacobi topology,100,1,158145100,1560733.7300,1536123.1100,1590498.1600,137739.8814,115203.3656,165197.1751,"1568279.0000,1567147.0000,1957136.0000,1799318.0000,1538533.0000,1741708.0000,1974700.0000,1972065.0000,1945705.0000,1857378.0000,1829224.0000,1815828.0000,1567358.0000,1566616.0000,1567589.0000,1568110.0000,1568671.0000,1567498.0000,1566396.0000,1568571.0000,1567738.0000,1538793.0000,1567758.0000,1683057.0000,1626781.0000,1625719.0000,1568520.0000,1683027.0000,1595340.0000,1540216.0000,1538143.0000,1567258.0000,1539265.0000,1567198.0000,1568851.0000,1683649.0000,1626640.0000,1566576.0000,1655034.0000,1566887.0000,1568199.0000,1516751.0000,1410791.0000,1436410.0000,1463331.0000,1410882.0000,1438063.0000,1436089.0000,1411262.0000,1434666.0000,1412224.0000,1436841.0000,1463832.0000,1410611.0000,1461377.0000,1462610.0000,1437342.0000,1487546.0000,1767447.0000,1716641.0000,1717683.0000,1717262.0000,1912081.0000,1408878.0000,1410791.0000,1437491.0000,1410510.0000,1409769.0000,1438233.0000,1409339.0000,1410791.0000,1436339.0000,1410761.0000,1437031.0000,1410661.0000,1437151.0000,1436811.0000,1437492.0000,1409669.0000,1436450.0000,1411873.0000,1409239.0000,1528785.0000,1567468.0000,1567037.0000,1567919.0000,1568269.0000,1537291.0000,1568330.0000,1567097.0000,1568380.0000,1567579.0000,1568380.0000,1566917.0000,1568299.0000,1538443.0000,1568079.0000,1596002.0000,1568560.0000,1567038.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,2931779400,30161093.2300,29984591.1700,30250575.5700,615581.8476,363612.1031,961024.7692,"30255717.0000,30354103.0000,30247261.0000,30340167.0000,30299209.0000,30343654.0000,30254935.0000,30321903.0000,30274262.0000,30390592.0000,30336419.0000,30392797.0000,30268441.0000,30191415.0000,30266978.0000,30220249.0000,30219377.0000,30302856.0000,30387727.0000,30294951.0000,30206113.0000,30281897.0000,30352921.0000,28298479.0000,27530954.0000,30275414.0000,30268622.0000,30335147.0000,30282438.0000,30297466.0000,30310260.0000,30338354.0000,30481585.0000,30262530.0000,30324697.0000,30289931.0000,30402626.0000,30295612.0000,30239767.0000,30339225.0000,30169624.0000,30228716.0000,30258833.0000,30335318.0000,30283820.0000,30372308.0000,30280844.0000,30195523.0000,30327223.0000,30267078.0000,30045298.0000,29498532.0000,30384611.0000,30356658.0000,30335237.0000,30336189.0000,29207009.0000,26966855.0000,30225159.0000,30314739.0000,30275364.0000,30319638.0000,30494099.0000,30429436.0000,30263902.0000,30285183.0000,30314047.0000,30406462.0000,30284472.0000,30224226.0000,30314027.0000,30367399.0000,30388618.0000,30220711.0000,30265825.0000,30206624.0000,30300722.0000,30475543.0000,30427753.0000,30288469.0000,30250597.0000,30268141.0000,30377587.0000,30402595.0000,30263612.0000,30290362.0000,30318615.0000,30311352.0000,30296184.0000,29585166.0000,26539686.0000,30250287.0000,30413536.0000,30411031.0000,30040650.0000,30426280.0000,30336059.0000,30370464.0000,30309860.0000,30328114.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,57642000,576424.4000,575986.4900,577005.1700,2552.3690,2018.8921,3196.2253,"576400.0000,575278.0000,584686.0000,580338.0000,575398.0000,574676.0000,574737.0000,576109.0000,575188.0000,574247.0000,580808.0000,574116.0000,574818.0000,574717.0000,573955.0000,574317.0000,574466.0000,584105.0000,575068.0000,576521.0000,576400.0000,575148.0000,575950.0000,574917.0000,580297.0000,576060.0000,575809.0000,575018.0000,576600.0000,576851.0000,576330.0000,584796.0000,576581.0000,574146.0000,576520.0000,577292.0000,576360.0000,576009.0000,576480.0000,577392.0000,578193.0000,576451.0000,576390.0000,575609.0000,576069.0000,582401.0000,577753.0000,575980.0000,574978.0000,575588.0000,576450.0000,576531.0000,577121.0000,574246.0000,574907.0000,576591.0000,574036.0000,574025.0000,576099.0000,580528.0000,574316.0000,573505.0000,575258.0000,573985.0000,574015.0000,574347.0000,583714.0000,577352.0000,575238.0000,575028.0000,576841.0000,575668.0000,574446.0000,577943.0000,575809.0000,576570.0000,574086.0000,574587.0000,575639.0000,575739.0000,579686.0000,574636.0000,573043.0000,575739.0000,574868.0000,573344.0000,585638.0000,577412.0000,577433.0000,577161.0000,576581.0000,574707.0000,575619.0000,581921.0000,577222.0000,575108.0000,575618.0000,575198.0000,576480.0000,576090.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,75345100,754749.3400,754128.3500,755610.4800,3734.5510,2938.3474,4776.2306,"751913.0000,752884.0000,762183.0000,754257.0000,754498.0000,752795.0000,754417.0000,753897.0000,753717.0000,763655.0000,753486.0000,753846.0000,754368.0000,753485.0000,763033.0000,755309.0000,754227.0000,754297.0000,754077.0000,753967.0000,757153.0000,753145.0000,753406.0000,753976.0000,754007.0000,768665.0000,754888.0000,754026.0000,754016.0000,754497.0000,762333.0000,754047.0000,754267.0000,753065.0000,754338.0000,754337.0000,769677.0000,753726.0000,754077.0000,754378.0000,754197.0000,762022.0000,751923.0000,752874.0000,753475.0000,753386.0000,760168.0000,752574.0000,753756.0000,752174.0000,752263.0000,764688.0000,755509.0000,753556.0000,753466.0000,753025.0000,753566.0000,753776.0000,752875.0000,752634.0000,752644.0000,752955.0000,764557.0000,753616.0000,753185.0000,752754.0000,752684.0000,761050.0000,752764.0000,752364.0000,752354.0000,751993.0000,752694.0000,753966.0000,752504.0000,753155.0000,753977.0000,752394.0000,763114.0000,753215.0000,752424.0000,751733.0000,751431.0000,754387.0000,751662.0000,751872.0000,753266.0000,751852.0000,753456.0000,761852.0000,753546.0000,752274.0000,752414.0000,752033.0000,758876.0000,752564.0000,752334.0000,751913.0000,751952.0000,756912.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,80014600,799208.1800,796927.5600,800268.0800,7599.1349,3059.4281,13328.5072,"798020.0000,798050.0000,755089.0000,745771.0000,812577.0000,799533.0000,798411.0000,799203.0000,802478.0000,799012.0000,799854.0000,798381.0000,798361.0000,801356.0000,800726.0000,799493.0000,798962.0000,798801.0000,807088.0000,801897.0000,798642.0000,798842.0000,799122.0000,803491.0000,801076.0000,799232.0000,799142.0000,799072.0000,808741.0000,801096.0000,798891.0000,799482.0000,799053.0000,803620.0000,799413.0000,799163.0000,799553.0000,799242.0000,802288.0000,799733.0000,799213.0000,798852.0000,797469.0000,806957.0000,799704.0000,797258.0000,797869.0000,798882.0000,803050.0000,800294.0000,797349.0000,797059.0000,797870.0000,806546.0000,800294.0000,798821.0000,798672.0000,798952.0000,803881.0000,798521.0000,799584.0000,797309.0000,798581.0000,807739.0000,799944.0000,798881.0000,799162.0000,798972.0000,803891.0000,798391.0000,798060.0000,798602.0000,798801.0000,808100.0000,800094.0000,798050.0000,798521.0000,797940.0000,802148.0000,798522.0000,799392.0000,799252.0000,798992.0000,808951.0000,798921.0000,799283.0000,799413.0000,798781.0000,799373.0000,799623.0000,797790.0000,799533.0000,800194.0000,808359.0000,800405.0000,798361.0000,798661.0000,797970.0000,798652.0000,798150.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,428157800,4249079.4100,4229986.9800,4263481.2200,84746.9417,67490.4316,100346.9781,"4287342.0000,4280839.0000,4296980.0000,4290267.0000,4280259.0000,4279226.0000,4281361.0000,4280468.0000,4285619.0000,4280319.0000,4286289.0000,4278325.0000,4281451.0000,4279006.0000,4283605.0000,4275970.0000,4290117.0000,4280508.0000,4287442.0000,4026948.0000,4042678.0000,4043229.0000,4040975.0000,4040855.0000,4034092.0000,4050283.0000,4164629.0000,4290378.0000,4291930.0000,4292200.0000,4287452.0000,4294205.0000,4285458.0000,4294214.0000,4286801.0000,4283735.0000,4285317.0000,4288554.0000,4294396.0000,4290127.0000,4284326.0000,4289966.0000,4286900.0000,4285669.0000,4290488.0000,4288724.0000,4284175.0000,4288765.0000,4278605.0000,4289736.0000,4281520.0000,4288064.0000,4280759.0000,4290718.0000,4276973.0000,4283484.0000,4282563.0000,4281170.0000,4282643.0000,4289797.0000,4279967.0000,4287753.0000,4282012.0000,4293774.0000,4290728.0000,4295738.0000,4287422.0000,4301298.0000,4193815.0000,4059270.0000,4046495.0000,4038710.0000,4050523.0000,4044732.0000,4049821.0000,4049951.0000,4190308.0000,4285098.0000,4295698.0000,4292361.0000,4282232.0000,4284226.0000,4299314.0000,4291900.0000,4280599.0000,4280980.0000,4279217.0000,4276661.0000,4282924.0000,4295297.0000,4285558.0000,4284737.0000,4281301.0000,4286039.0000,4274798.0000,4285478.0000,4289306.0000,4277883.0000,4288784.0000,4286339.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,133824900,1346997.4500,1346371.8000,1347733.1400,3463.8435,2966.5264,4013.5692,"1346730.0000,1344666.0000,1352601.0000,1344535.0000,1354384.0000,1343223.0000,1344566.0000,1346129.0000,1346609.0000,1342612.0000,1349866.0000,1343914.0000,1343043.0000,1354756.0000,1345998.0000,1345317.0000,1350307.0000,1346970.0000,1343724.0000,1350416.0000,1347532.0000,1346579.0000,1352431.0000,1344967.0000,1346179.0000,1354134.0000,1345588.0000,1344516.0000,1351398.0000,1345187.0000,1345097.0000,1348994.0000,1344626.0000,1343013.0000,1349045.0000,1344826.0000,1344536.0000,1350517.0000,1343995.0000,1347241.0000,1348002.0000,1345738.0000,1350247.0000,1346018.0000,1343273.0000,1346158.0000,1346239.0000,1345898.0000,1351499.0000,1345949.0000,1344475.0000,1347722.0000,1345568.0000,1346359.0000,1354354.0000,1344927.0000,1346459.0000,1355957.0000,1347391.0000,1343584.0000,1354264.0000,1343835.0000,1342672.0000,1347161.0000,1343694.0000,1345487.0000,1345848.0000,1344585.0000,1348113.0000,1352240.0000,1346089.0000,1344957.0000,1356809.0000,1345077.0000,1344576.0000,1342341.0000,1344766.0000,1342732.0000,1344395.0000,1343644.0000,1343985.0000,1352491.0000,1343394.0000,1345818.0000,1345979.0000,1346419.0000,1346489.0000,1354995.0000,1347191.0000,1346259.0000,1350527.0000,1345487.0000,1343163.0000,1349666.0000,1347852.0000,1345268.0000,1355236.0000,1345036.0000,1346609.0000,1348012.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,2715524600,24211126.2300,23678171.8700,24769494.3400,2770300.9386,2529170.6144,3080093.6745,"30272789.0000,25982771.0000,28995709.0000,25166705.0000,27408922.0000,20532784.0000,20833333.0000,20346701.0000,21524653.0000,26914886.0000,23494025.0000,24162341.0000,23053059.0000,26210101.0000,22808195.0000,23593443.0000,20223607.0000,22476967.0000,22863010.0000,22535779.0000,24737221.0000,21340595.0000,22372990.0000,28865552.0000,22578419.0000,22628254.0000,24524417.0000,28522042.0000,22633724.0000,22191808.0000,21695086.0000,22706061.0000,23302723.0000,22169795.0000,21415446.0000,20383802.0000,22339798.0000,22166399.0000,22941197.0000,28193950.0000,24825888.0000,26392105.0000,20373241.0000,20446560.0000,20918444.0000,22374142.0000,23209746.0000,29926653.0000,23592060.0000,23489275.0000,25594084.0000,27978761.0000,27951451.0000,26704959.0000,27750108.0000,27632607.0000,28008098.0000,23338390.0000,27187042.0000,27841972.0000,27776078.0000,27930521.0000,27477832.0000,27667382.0000,27899812.0000,27793160.0000,24394481.0000,23621606.0000,21726976.0000,20208220.0000,22888978.0000,22621822.0000,21782692.0000,22767056.0000,22435278.0000,25411317.0000,17923669.0000,21992519.0000,22455546.0000,25587642.0000,20187980.0000,21235536.0000,25709522.0000,26071598.0000,26311222.0000,26611882.0000,26769350.0000,25909652.0000,25255101.0000,28516892.0000,20516593.0000,20457271.0000,22511924.0000,22393529.0000,22819245.0000,26963739.0000,24312705.0000,26071929.0000,26888566.0000,20591155.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,151836100,1294620.8800,1267616.4400,1320505.7400,135008.9323,123971.6967,147767.1192,"1307445.0000,1238845.0000,1448332.0000,1336210.0000,1536720.0000,1277168.0000,1333565.0000,1337222.0000,1333485.0000,1216794.0000,1283290.0000,1074805.0000,1190404.0000,1073812.0000,1073462.0000,1073923.0000,1073873.0000,1188831.0000,1075857.0000,1072760.0000,1074163.0000,1042183.0000,1049427.0000,1103739.0000,1105102.0000,1070316.0000,1250638.0000,1190143.0000,1249806.0000,1303999.0000,1308096.0000,1219789.0000,1217986.0000,1306944.0000,1247311.0000,1163894.0000,1158073.0000,1129789.0000,1218126.0000,1250387.0000,1306784.0000,1160688.0000,1217485.0000,1221353.0000,1216213.0000,1222495.0000,1249245.0000,1158754.0000,1190975.0000,1073652.0000,1281826.0000,1158974.0000,1247942.0000,1218547.0000,1242833.0000,1164365.0000,1223016.0000,1302316.0000,1160898.0000,1163583.0000,1394791.0000,1450487.0000,1452992.0000,1450176.0000,1451338.0000,1453031.0000,1390232.0000,1457791.0000,1447711.0000,1448022.0000,1395172.0000,1453733.0000,1452481.0000,1451669.0000,1449484.0000,1391825.0000,1455546.0000,1450697.0000,1452220.0000,1390933.0000,1449424.0000,1391765.0000,1453533.0000,1395051.0000,1451959.0000,1422904.0000,1421321.0000,1453432.0000,1453963.0000,1443764.0000,1450376.0000,1450697.0000,1457189.0000,1418005.0000,1451809.0000,1422253.0000,1365837.0000,1307907.0000,1304891.0000,1367019.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,161853700,1706681.0600,1659158.7800,1750797.8700,232875.0202,213930.9159,261824.9209,"1564482.0000,1556157.0000,1893236.0000,1861816.0000,1915377.0000,1863779.0000,1912743.0000,1912231.0000,1834193.0000,1915838.0000,1918453.0000,1918644.0000,1911079.0000,1946537.0000,1912221.0000,1923072.0000,1912863.0000,1912392.0000,1917542.0000,1914936.0000,1914947.0000,1891112.0000,1914506.0000,1918803.0000,1912832.0000,1827190.0000,1923293.0000,1939182.0000,1912231.0000,1920788.0000,1884249.0000,1916780.0000,1916159.0000,1916149.0000,1887705.0000,1914585.0000,1916770.0000,1915779.0000,1883918.0000,1915086.0000,1917982.0000,1918944.0000,1912151.0000,1890470.0000,1916099.0000,1917972.0000,1913875.0000,1886603.0000,1911740.0000,1917792.0000,1913483.0000,1924444.0000,1912872.0000,1914205.0000,1916069.0000,1865693.0000,1378530.0000,1330269.0000,1521892.0000,1301845.0000,1385523.0000,1250747.0000,1381766.0000,1380063.0000,1464152.0000,1251690.0000,1462359.0000,1360095.0000,1566707.0000,1333305.0000,1435388.0000,1333445.0000,1250978.0000,1329217.0000,1496734.0000,1064886.0000,1599568.0000,1564833.0000,1575252.0000,1570494.0000,1537011.0000,1504890.0000,1509218.0000,1546228.0000,1530568.0000,1515349.0000,1534926.0000,1535136.0000,1568430.0000,1601072.0000,1504428.0000,1567758.0000,1571616.0000,1503588.0000,1601202.0000,1535878.0000,1599649.0000,1563310.0000,1566386.0000,1571676.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,173721000,1716872.9200,1697757.1000,1736702.7100,99743.9201,88336.4625,115476.0331,"1825868.0000,1697374.0000,1880190.0000,1650906.0000,1779891.0000,1682116.0000,1755073.0000,1567418.0000,1574552.0000,1545146.0000,1595621.0000,1568319.0000,1595280.0000,1542841.0000,1708004.0000,1720007.0000,1568621.0000,1634135.0000,1712223.0000,1593808.0000,1751156.0000,1696212.0000,1648571.0000,1691893.0000,1657889.0000,1728343.0000,1672037.0000,1684380.0000,1650575.0000,1642299.0000,1706622.0000,1680252.0000,1780883.0000,1649674.0000,1596984.0000,1596413.0000,1650595.0000,1652189.0000,1666726.0000,1712212.0000,1625248.0000,1652690.0000,1685031.0000,1713294.0000,1654382.0000,1626109.0000,1624737.0000,1716110.0000,1709297.0000,1785993.0000,1838582.0000,1767738.0000,2008484.0000,1951246.0000,1751787.0000,1827761.0000,1736899.0000,1767747.0000,1667117.0000,1594029.0000,1707543.0000,1708405.0000,1513726.0000,1514378.0000,1516141.0000,1787405.0000,1654994.0000,1714567.0000,1681535.0000,1625078.0000,1656247.0000,1717292.0000,1685571.0000,1681023.0000,1738782.0000,1745565.0000,1737860.0000,1776615.0000,1829375.0000,1862638.0000,1823844.0000,1787596.0000,1782335.0000,1763219.0000,1785722.0000,1785581.0000,1786303.0000,1779430.0000,1773218.0000,1798827.0000,1796913.0000,1801231.0000,1858560.0000,1796482.0000,1865723.0000,1902042.0000,1880361.0000,1891953.0000,1881834.0000,1873799.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,724786300,9468295.9100,9187326.5600,9751689.8200,1436924.1739,1228809.0638,1679419.9068,"9390371.0000,9370893.0000,7642389.0000,10895122.0000,8358897.0000,6382160.0000,9331309.0000,9332210.0000,10588542.0000,7895097.0000,11173941.0000,12225783.0000,12314301.0000,12664315.0000,11346056.0000,11370793.0000,12219151.0000,12283934.0000,12217477.0000,8870326.0000,7366897.0000,7335457.0000,7317403.0000,6879924.0000,5806851.0000,6441694.0000,6604642.0000,5790721.0000,7458600.0000,8918016.0000,9399458.0000,9393618.0000,9414506.0000,9424676.0000,9378268.0000,9406061.0000,9385542.0000,9453892.0000,9389149.0000,8757341.0000,8646901.0000,8650970.0000,9149114.0000,9399118.0000,9386283.0000,9403906.0000,8883721.0000,8661279.0000,9359593.0000,9388818.0000,9442219.0000,9398586.0000,9408144.0000,9433532.0000,9416771.0000,9399387.0000,9373850.0000,9386303.0000,9373038.0000,9377346.0000,9388999.0000,9395871.0000,9389850.0000,9309838.0000,8952652.0000,9398305.0000,9387506.0000,9409086.0000,9403025.0000,9408686.0000,9472656.0000,9365433.0000,9417412.0000,9400821.0000,9406572.0000,9184932.0000,9012865.0000,9097295.0000,9243432.0000,9339154.0000,9066106.0000,7581163.0000,11606139.0000,11385231.0000,11526909.0000,11727368.0000,11188108.0000,12274506.0000,12285326.0000,12220083.0000,11928540.0000,9411802.0000,8830921.0000,9232222.0000,9085323.0000,9404127.0000,9412513.0000,9371515.0000,9417804.0000,9354833.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,276609400,2400342.9400,2298464.0200,2499755.1800,514241.6589,460318.1127,573873.9472,"3220861.0000,3164123.0000,3102226.0000,2955167.0000,3118877.0000,3057311.0000,2571421.0000,2438229.0000,2583233.0000,2475238.0000,2465660.0000,2468646.0000,2582861.0000,2520814.0000,2529250.0000,2467303.0000,2582491.0000,2528308.0000,2611546.0000,2466882.0000,2522508.0000,2587029.0000,2497671.0000,2605295.0000,2498322.0000,2526155.0000,2629701.0000,2809711.0000,2796777.0000,2711696.0000,2743396.0000,2718939.0000,2617097.0000,1902783.0000,1902373.0000,1896401.0000,1883066.0000,1901802.0000,1890390.0000,2065462.0000,2125515.0000,1982584.0000,1978567.0000,2036477.0000,2086562.0000,2589395.0000,2572503.0000,2851792.0000,2903931.0000,2749678.0000,2882549.0000,2618399.0000,2702869.0000,2747274.0000,2341154.0000,2234923.0000,2335323.0000,2367284.0000,2379797.0000,2429781.0000,2443257.0000,2307791.0000,2309454.0000,2298282.0000,2354610.0000,2235724.0000,2223591.0000,2280319.0000,1522423.0000,1475795.0000,1562909.0000,1487526.0000,1495352.0000,1456157.0000,1501443.0000,1545396.0000,1545255.0000,1474562.0000,1543442.0000,1501604.0000,1724856.0000,1585232.0000,1590953.0000,1729275.0000,1630136.0000,2308342.0000,2631414.0000,2638617.0000,2685466.0000,2700836.0000,3490251.0000,3006064.0000,3009992.0000,3191054.0000,3194070.0000,3193489.0000,3164494.0000,3167801.0000,3103429.0000,3190253.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,soup topology,100,1,6379204300,66020014.6700,65770373.4700,66144616.5100,865893.1460,487142.7481,1385311.6130,"66075558.0000,66316063.0000,66083061.0000,66042385.0000,66220502.0000,66139991.0000,65954468.0000,66070849.0000,66229509.0000,66086990.0000,66269706.0000,60975083.0000,66306024.0000,66039219.0000,66093201.0000,66205825.0000,66138306.0000,66037074.0000,62839956.0000,65322230.0000,66083803.0000,66251772.0000,66131113.0000,66065158.0000,66132244.0000,66542493.0000,66016225.0000,65904985.0000,66244788.0000,66102039.0000,66233787.0000,66575245.0000,66092940.0000,66112328.0000,66305373.0000,66366219.0000,66116415.0000,66036804.0000,66094735.0000,66150219.0000,66170578.0000,66279303.0000,66240811.0000,66218007.0000,66055019.0000,66081488.0000,66286477.0000,66154087.0000,66524077.0000,66128208.0000,66420010.0000,66130812.0000,66066039.0000,66251962.0000,66281569.0000,65986509.0000,66263424.0000,66665956.0000,60945637.0000,66110294.0000,66123388.0000,66107107.0000,66121716.0000,65967713.0000,66469214.0000,66135932.0000,64927973.0000,63482844.0000,66144659.0000,66268793.0000,66169064.0000,66289414.0000,66486135.0000,66071160.0000,66020173.0000,66438615.0000,66281368.0000,66387308.0000,66644666.0000,66351661.0000,66352311.0000,66281738.0000,66019311.0000,66325591.0000,66240981.0000,66433646.0000,66206706.0000,66494271.0000,66237063.0000,66245881.0000,66173583.0000,66316083.0000,66212869.0000,66059036.0000,66108430.0000,66139478.0000,66332906.0000,66370106.0000,66167992.0000,66129630.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,chain topology,100,1,352508800,3499779.1500,3474778.9600,3515036.5700,96334.5389,59627.1941,132861.7332,"3104861.0000,3125460.0000,3559372.0000,3520389.0000,3520348.0000,3520910.0000,3525128.0000,3531319.0000,3531830.0000,3515188.0000,3511021.0000,3522473.0000,3529426.0000,3523685.0000,3535737.0000,3525728.0000,3525128.0000,3530959.0000,3528815.0000,3524336.0000,3533243.0000,3520699.0000,3518815.0000,3525619.0000,3515570.0000,3525358.0000,3522062.0000,3514166.0000,3519096.0000,3523054.0000,3510850.0000,3510028.0000,3517252.0000,3510239.0000,3530527.0000,3508887.0000,3520709.0000,3518505.0000,3525268.0000,3533102.0000,3529175.0000,3532833.0000,3534305.0000,3526901.0000,3507444.0000,3520007.0000,3519457.0000,3524707.0000,3523284.0000,3525618.0000,3528905.0000,3512213.0000,3513266.0000,3537140.0000,3520018.0000,3521541.0000,3530217.0000,3519727.0000,3529486.0000,3531560.0000,3519587.0000,3524486.0000,3544895.0000,3524687.0000,3521110.0000,3533985.0000,3522201.0000,3522863.0000,3524817.0000,3512303.0000,3526871.0000,3528023.0000,3533032.0000,3530398.0000,3519557.0000,3517453.0000,3527402.0000,3519606.0000,3519857.0000,3520509.0000,3564712.0000,3524927.0000,3530428.0000,3519647.0000,3514377.0000,3525669.0000,3528454.0000,3518866.0000,3521611.0000,3517463.0000,3518244.0000,3519115.0000,3522713.0000,3521701.0000,3512182.0000,3525137.0000,3182038.0000,3118186.0000,3100594.0000,3095243.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,982543300,9849989.2300,9845525.0400,9854238.9500,22113.0408,18416.6758,27198.0233,"9853208.0000,9854721.0000,9850853.0000,9848248.0000,9851865.0000,9865972.0000,9857065.0000,9870972.0000,9866072.0000,9857968.0000,9850352.0000,9860692.0000,9837719.0000,9807962.0000,9836306.0000,9819203.0000,9857055.0000,9798894.0000,9834182.0000,9870600.0000,9851595.0000,9847987.0000,9868527.0000,9840323.0000,9874859.0000,9845683.0000,9848670.0000,9830815.0000,9783166.0000,9835674.0000,9855713.0000,9796830.0000,9863887.0000,9834814.0000,9838660.0000,9848790.0000,9839973.0000,9846946.0000,9848198.0000,9853669.0000,9836526.0000,9861324.0000,9845813.0000,9857917.0000,9841826.0000,9846215.0000,9841315.0000,9821478.0000,9800699.0000,9799756.0000,9850023.0000,9846074.0000,9882253.0000,9855773.0000,9864039.0000,9850452.0000,9855413.0000,9848599.0000,9859841.0000,9858988.0000,9869028.0000,9831066.0000,9842918.0000,9870240.0000,9850502.0000,9905347.0000,9877212.0000,9890869.0000,9852536.0000,9863067.0000,9863116.0000,9863818.0000,9854399.0000,9831017.0000,9851023.0000,9796852.0000,9804535.0000,9866282.0000,9854120.0000,9869749.0000,9854391.0000,9848038.0000,9844432.0000,9824793.0000,9925725.0000,9871493.0000,9877003.0000,9873587.0000,9867966.0000,9858257.0000,9857365.0000,9850093.0000,9860832.0000,9861444.0000,9859009.0000,9858358.0000,9846195.0000,9863237.0000,9848308.0000,9811689.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,394034500,3939575.4200,3937887.9500,3941041.8100,8010.9569,6698.1566,9903.1448,"3941497.0000,3915697.0000,3938441.0000,3939622.0000,3947648.0000,3940134.0000,3938069.0000,3932960.0000,3942558.0000,3935986.0000,3932981.0000,3940294.0000,3947869.0000,3937569.0000,3942237.0000,3933731.0000,3940405.0000,3933792.0000,3944712.0000,3943590.0000,3937909.0000,3952858.0000,3933932.0000,3940465.0000,3945003.0000,3935936.0000,3946075.0000,3941927.0000,3939673.0000,3937980.0000,3930495.0000,3951806.0000,3939123.0000,3948359.0000,3930185.0000,3929053.0000,3942498.0000,3930475.0000,3922811.0000,3940063.0000,3939232.0000,3951435.0000,3938752.0000,3947818.0000,3932619.0000,3949682.0000,3945865.0000,3940244.0000,3940444.0000,3945554.0000,3935826.0000,3958128.0000,3945003.0000,3946366.0000,3947438.0000,3954922.0000,3939993.0000,3944242.0000,3941667.0000,3939563.0000,3943901.0000,3940775.0000,3943310.0000,3945845.0000,3943921.0000,3939954.0000,3936757.0000,3938039.0000,3935796.0000,3952567.0000,3943360.0000,3940835.0000,3936557.0000,3931737.0000,3928883.0000,3942658.0000,3934553.0000,3930385.0000,3944622.0000,3939944.0000,3943921.0000,3941276.0000,3929765.0000,3945544.0000,3937208.0000,3946566.0000,3947488.0000,3934953.0000,3946786.0000,3941717.0000,3943590.0000,3939523.0000,3917030.0000,3910467.0000,3917802.0000,3948820.0000,3933481.0000,3938401.0000,3940044.0000,3927550.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,1623882200,15832562.1400,15729871.5200,15896996.1300,406166.0903,277976.3303,551218.0863,"14151492.0000,14660356.0000,15985307.0000,15962914.0000,15987942.0000,15935362.0000,16012278.0000,15954248.0000,15964398.0000,15952514.0000,15935533.0000,15969237.0000,14492799.0000,14116586.0000,15079281.0000,15979346.0000,15964236.0000,15955019.0000,15923760.0000,15965460.0000,15951422.0000,15976210.0000,15979557.0000,15993151.0000,15969458.0000,15928479.0000,15945362.0000,15946022.0000,15956593.0000,15966622.0000,15940231.0000,15958697.0000,15943919.0000,15958136.0000,15929751.0000,15935212.0000,15934731.0000,15943588.0000,15950190.0000,15931625.0000,15943739.0000,15939930.0000,15965470.0000,15950050.0000,15942175.0000,15929631.0000,15933850.0000,15965850.0000,15923038.0000,15945281.0000,15926305.0000,15929912.0000,15945822.0000,15927458.0000,15916707.0000,15952193.0000,15937756.0000,15945672.0000,15963856.0000,15945621.0000,15920474.0000,15920985.0000,15928258.0000,15981479.0000,15967674.0000,15969568.0000,15953185.0000,15936865.0000,15942416.0000,14436562.0000,14201287.0000,15234515.0000,16002439.0000,15993933.0000,15997189.0000,15985929.0000,15973614.0000,15985948.0000,15978063.0000,15945622.0000,15999172.0000,15947755.0000,15952525.0000,15951963.0000,15947446.0000,15955290.0000,15972243.0000,15942585.0000,15937386.0000,15937266.0000,15944719.0000,15952154.0000,15968615.0000,15979637.0000,15944178.0000,15947495.0000,15961272.0000,15949128.0000,15955421.0000,15036619.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,jacobi topology,100,1,556047900,5552896.9300,5551302.5300,5554583.4400,8340.2115,7331.9907,9919.8490,"5571505.0000,5554914.0000,5580933.0000,5552459.0000,5542280.0000,5555956.0000,5541798.0000,5556286.0000,5551507.0000,5549463.0000,5556806.0000,5544183.0000,5566476.0000,5554512.0000,5551376.0000,5562748.0000,5544584.0000,5560514.0000,5549062.0000,5557077.0000,5565633.0000,5553591.0000,5538813.0000,5555304.0000,5554242.0000,5555856.0000,5539835.0000,5547799.0000,5547128.0000,5559091.0000,5558610.0000,5559713.0000,5540526.0000,5563380.0000,5559602.0000,5554372.0000,5552399.0000,5548411.0000,5548701.0000,5547639.0000,5545877.0000,5557930.0000,5554061.0000,5558550.0000,5550044.0000,5548783.0000,5563740.0000,5548011.0000,5551276.0000,5542130.0000,5549173.0000,5561906.0000,5546727.0000,5557838.0000,5534996.0000,5544834.0000,5549042.0000,5550105.0000,5545516.0000,5572256.0000,5553972.0000,5559462.0000,5545947.0000,5550514.0000,5560944.0000,5550084.0000,5561206.0000,5553190.0000,5541758.0000,5565493.0000,5543082.0000,5567758.0000,5551247.0000,5553560.0000,5558851.0000,5555835.0000,5544814.0000,5561926.0000,5554072.0000,5563650.0000,5549382.0000,5550434.0000,5569381.0000,5556597.0000,5563600.0000,5543562.0000,5543402.0000,5544775.0000,5538712.0000,5543221.0000,5557659.0000,5543061.0000,5552098.0000,5544904.0000,5550545.0000,5552690.0000,5555955.0000,5555614.0000,5550194.0000,5538663.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,soup topology,100,1,5154808700,54940307.7500,54204083.5200,55658691.9100,3719537.3719,3285080.8687,4303581.4694,"55205612.0000,59091023.0000,53124628.0000,57800848.0000,58500975.0000,53500510.0000,52549869.0000,53753389.0000,53083500.0000,54173235.0000,48221788.0000,56275087.0000,53974077.0000,59804275.0000,51895819.0000,60469706.0000,58144298.0000,57319497.0000,54005617.0000,48791908.0000,53505008.0000,60480606.0000,52558715.0000,55423453.0000,60416014.0000,59726226.0000,60017629.0000,57166687.0000,56242886.0000,57084521.0000,56900473.0000,51004590.0000,51996540.0000,58049830.0000,59528412.0000,55653820.0000,52236255.0000,52897869.0000,53560685.0000,52543347.0000,50888341.0000,55036290.0000,54804652.0000,52870005.0000,48304565.0000,54062394.0000,55519045.0000,61671753.0000,60060229.0000,60905241.0000,57465613.0000,54813357.0000,52148959.0000,51764220.0000,54878050.0000,54902547.0000,53144486.0000,45666657.0000,53353952.0000,55243754.0000,54017349.0000,58957720.0000,60292260.0000,54976746.0000,56286088.0000,61992400.0000,61344392.0000,53459333.0000,62447302.0000,44269820.0000,57411680.0000,55805758.0000,53706000.0000,49705129.0000,48009336.0000,57979707.0000,56628516.0000,55081125.0000,57474160.0000,50894361.0000,55304488.0000,52960076.0000,57372035.0000,49285523.0000,54522868.0000,50942202.0000,60819067.0000,53224807.0000,55401351.0000,61169171.0000,55222603.0000,52411667.0000,49852658.0000,52525653.0000,50223140.0000,54998007.0000,53946796.0000,52681958.0000,56978250.0000,49265936.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,chain topology,100,1,514933700,4925400.0800,4878696.8900,5045991.0800,359385.8897,177093.3327,755701.8276,"4709151.0000,4742154.0000,7985669.0000,5250076.0000,5085334.0000,4699613.0000,5027804.0000,4722556.0000,4816123.0000,4743316.0000,4813338.0000,4732314.0000,4698340.0000,4915932.0000,4842764.0000,4743206.0000,4995333.0000,4971738.0000,4930630.0000,4967110.0000,4864786.0000,4888581.0000,4840028.0000,4756711.0000,4904962.0000,4880356.0000,4971678.0000,4793230.0000,4882028.0000,5202696.0000,4746181.0000,4954756.0000,4805012.0000,4906094.0000,4694032.0000,4890494.0000,5204660.0000,4929378.0000,4836812.0000,4702759.0000,4922956.0000,4907808.0000,4769175.0000,4876288.0000,4841591.0000,4887169.0000,5253984.0000,4758805.0000,5359713.0000,4857442.0000,5077539.0000,4832034.0000,5174703.0000,4789924.0000,4829268.0000,4716434.0000,4964855.0000,4889483.0000,5108548.0000,4697078.0000,4710312.0000,4865678.0000,4733357.0000,4918417.0000,4852663.0000,4741853.0000,4725371.0000,4866308.0000,4962852.0000,5376535.0000,4828166.0000,5242682.0000,5295743.0000,4857161.0000,4729058.0000,4706255.0000,4912025.0000,4757753.0000,4825803.0000,4869325.0000,4862672.0000,4799281.0000,4795925.0000,4628809.0000,5069613.0000,4724800.0000,5293919.0000,4685106.0000,5130159.0000,4723519.0000,5146319.0000,4725893.0000,5528103.0000,5376636.0000,4858043.0000,4955327.0000,4678873.0000,4726353.0000,4720392.0000,4770417.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,expanding tree topology,100,1,858136300,8673340.2100,8604332.6000,8857862.5600,536414.0893,258155.7535,1139698.9912,"8324060.0000,8517517.0000,13292996.0000,8883701.0000,8806074.0000,8776919.0000,8527085.0000,8801264.0000,8649819.0000,8682500.0000,8333368.0000,8464877.0000,8560408.0000,8601646.0000,8760488.0000,8682599.0000,8595194.0000,8417387.0000,8533357.0000,8561029.0000,9246379.0000,9196884.0000,8689553.0000,8857742.0000,9104659.0000,9008076.0000,9066718.0000,9058652.0000,8850548.0000,8495135.0000,8687800.0000,8424421.0000,8555159.0000,8326635.0000,9029065.0000,8617587.0000,8952781.0000,8649918.0000,8642525.0000,8825551.0000,8526374.0000,8584403.0000,8281520.0000,8327908.0000,8303031.0000,8626604.0000,8666058.0000,8708418.0000,8824238.0000,8510984.0000,8377131.0000,9354584.0000,8465047.0000,8690575.0000,8946079.0000,8818557.0000,8836060.0000,8856690.0000,8591877.0000,8626163.0000,8677290.0000,8431875.0000,8510954.0000,9062540.0000,9113446.0000,8921702.0000,8827996.0000,8997305.0000,8321936.0000,8046686.0000,8512256.0000,8145762.0000,8347104.0000,9086005.0000,8471740.0000,8865326.0000,8406357.0000,8918196.0000,8763644.0000,8583351.0000,8337165.0000,8490175.0000,8503732.0000,8417147.0000,8655267.0000,8513109.0000,8291448.0000,8438256.0000,8344459.0000,7838721.0000,8267443.0000,8267674.0000,8273725.0000,8676768.0000,8453937.0000,8593441.0000,8526223.0000,8491858.0000,8387431.0000,8574194.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,contracting tree topology,100,1,582436600,4646449.5000,4561075.4600,4828447.0400,604379.5708,263428.7767,1034367.8290,"4320735.0000,4260140.0000,8526644.0000,5289942.0000,4699173.0000,4821454.0000,4554959.0000,4615343.0000,4489825.0000,4697168.0000,4925221.0000,4977319.0000,4842533.0000,4603481.0000,4630171.0000,4526905.0000,4710043.0000,4726093.0000,4688261.0000,4449018.0000,4719149.0000,4618068.0000,4577081.0000,4776258.0000,4732795.0000,4587810.0000,4703790.0000,4409824.0000,4608330.0000,4738005.0000,4849105.0000,4737645.0000,4414102.0000,4643187.0000,4531495.0000,4439881.0000,4595666.0000,4909040.0000,4686087.0000,4623268.0000,4586328.0000,4646431.0000,4555389.0000,4615753.0000,4384986.0000,4818408.0000,4586309.0000,4677962.0000,4529330.0000,4289756.0000,4201599.0000,4260451.0000,4276772.0000,4337697.0000,4409263.0000,4644408.0000,4586398.0000,4616746.0000,4674647.0000,4500235.0000,4558566.0000,4530733.0000,4410505.0000,4589213.0000,4527637.0000,4237868.0000,4283304.0000,4266442.0000,4280638.0000,4274347.0000,4343729.0000,4320074.0000,4965626.0000,4585456.0000,4527667.0000,4761540.0000,4851140.0000,4819370.0000,4556291.0000,5787043.0000,8441833.0000,5081176.0000,4702558.0000,4205887.0000,4190988.0000,4128009.0000,4216878.0000,4241695.0000,4076352.0000,4157836.0000,4663364.0000,4617216.0000,4761970.0000,4497880.0000,4761611.0000,4413992.0000,4622016.0000,4466651.0000,4217509.0000,4248458.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,wave_sim topology,100,1,1812416500,19443608.6600,19099350.7000,19876351.0800,1961803.0221,1641396.5947,2493331.7923,"21660340.0000,21978833.0000,22942900.0000,19211890.0000,18795021.0000,18535680.0000,19100469.0000,19084650.0000,26010212.0000,18578711.0000,18179143.0000,18230872.0000,17981639.0000,18135921.0000,18009222.0000,18258955.0000,18587056.0000,18347723.0000,18145790.0000,17314966.0000,19730583.0000,20954181.0000,19106550.0000,21815333.0000,23573374.0000,19136176.0000,19240414.0000,19189889.0000,18909287.0000,18867308.0000,18424469.0000,17453819.0000,18777798.0000,18327685.0000,18199782.0000,21314044.0000,20838683.0000,18651649.0000,23651662.0000,19159792.0000,20615039.0000,20628334.0000,23745660.0000,18568461.0000,17424033.0000,23017772.0000,18001537.0000,21842525.0000,19124424.0000,18995310.0000,18949714.0000,21323621.0000,21551524.0000,17461083.0000,18130071.0000,22867527.0000,16871736.0000,18398288.0000,19040125.0000,17647647.0000,17356414.0000,18790462.0000,18049388.0000,17372354.0000,17775980.0000,18224239.0000,18315031.0000,18299432.0000,17730283.0000,18239949.0000,16993948.0000,17159471.0000,17693644.0000,18508607.0000,19452256.0000,20152653.0000,18898176.0000,17375371.0000,17518222.0000,18572318.0000,20408507.0000,20831099.0000,19260222.0000,27398362.0000,19998992.0000,19073508.0000,18453883.0000,17326278.0000,17198405.0000,22071218.0000,20045460.0000,19743918.0000,21621155.0000,22302777.0000,18987114.0000,21548948.0000,19044452.0000,21885947.0000,18820749.0000,19244772.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,jacobi topology,100,1,709279500,6719872.4200,6585085.8400,6944292.5100,870753.0891,586254.1916,1265206.7154,"6571119.0000,6681648.0000,10963040.0000,6374446.0000,6363996.0000,6493692.0000,6445350.0000,6512078.0000,6456572.0000,6387681.0000,6617587.0000,6288854.0000,6702689.0000,6361601.0000,6703239.0000,6391449.0000,6597079.0000,6463144.0000,6618168.0000,6294294.0000,6361862.0000,6008563.0000,6392731.0000,6000738.0000,6139842.0000,6426415.0000,5962306.0000,6227137.0000,6176491.0000,6258185.0000,6336183.0000,11052060.0000,7228384.0000,8948613.0000,7586774.0000,7019057.0000,7376675.0000,6252164.0000,6874955.0000,8321485.0000,7606340.0000,6785405.0000,6608350.0000,6994360.0000,6353065.0000,6583272.0000,6166272.0000,6658305.0000,6993099.0000,6342395.0000,6731653.0000,6566831.0000,6295316.0000,6618097.0000,6283694.0000,6800303.0000,6326435.0000,6711355.0000,6352785.0000,6763122.0000,6365649.0000,6444780.0000,6848304.0000,6098594.0000,6701766.0000,6427507.0000,6875466.0000,6463034.0000,6666690.0000,6365499.0000,6611546.0000,6796897.0000,6481960.0000,7641277.0000,10313581.0000,6331695.0000,6068406.0000,6284967.0000,6406808.0000,6675216.0000,6189506.0000,6772560.0000,6489865.0000,6365289.0000,6542485.0000,6219623.0000,6443036.0000,6762592.0000,6535162.0000,8922163.0000,5981241.0000,6347545.0000,5964961.0000,6570989.0000,6153457.0000,6735861.0000,6525693.0000,6530683.0000,6598069.0000,6688020.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,6830895000,68424802.0800,68179607.7600,68538113.4500,806483.1744,355279.6118,1398300.4348,"68488929.0000,68766395.0000,68159024.0000,68796632.0000,68096606.0000,68708275.0000,68182599.0000,68872055.0000,67310226.0000,63977341.0000,68747199.0000,68789960.0000,68168011.0000,68287868.0000,68879700.0000,68980130.0000,68800571.0000,68922621.0000,69032750.0000,68158634.0000,68335929.0000,68783498.0000,68169404.0000,67653947.0000,68741939.0000,68732080.0000,68839384.0000,68682165.0000,68119329.0000,68930676.0000,68912542.0000,68869350.0000,68818023.0000,68264455.0000,68842109.0000,68170426.0000,68757769.0000,68762828.0000,68396144.0000,68274262.0000,68287017.0000,68395702.0000,68664102.0000,68645546.0000,68094191.0000,68247531.0000,68813885.0000,68407104.0000,69037940.0000,69070902.0000,68342863.0000,68636870.0000,68532011.0000,68780743.0000,68190413.0000,68051831.0000,68205692.0000,68139667.0000,68369944.0000,68133616.0000,68953750.0000,68883827.0000,69161564.0000,68668549.0000,68619587.0000,68408346.0000,68420350.0000,68811260.0000,68199150.0000,68687776.0000,68523695.0000,68959180.0000,68182779.0000,68277268.0000,68881382.0000,68209149.0000,68968227.0000,68671194.0000,68349696.0000,69040935.0000,68248424.0000,67558306.0000,62743653.0000,68544124.0000,68172490.0000,68300623.0000,68159054.0000,68233335.0000,68854932.0000,68837931.0000,68570314.0000,68270435.0000,68243384.0000,68389231.0000,68563901.0000,68783077.0000,68683848.0000,68473089.0000,68858019.0000,68885019.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,371953600,3787358.0300,3756256.5500,3807608.3600,126316.1297,89512.6213,161017.7915,"3822410.0000,3814887.0000,3862266.0000,3827670.0000,3849562.0000,3833652.0000,3846726.0000,3828261.0000,3835145.0000,3896020.0000,3843111.0000,3833011.0000,3844673.0000,3827951.0000,3842579.0000,3829604.0000,3837960.0000,3830776.0000,3828061.0000,3836948.0000,3831257.0000,3816490.0000,3824905.0000,3821719.0000,3820417.0000,3824755.0000,3829444.0000,3833482.0000,3824154.0000,3830516.0000,3829765.0000,3823944.0000,3830125.0000,3814114.0000,3827951.0000,3819595.0000,3831548.0000,3821820.0000,3817641.0000,3820346.0000,3822932.0000,3825176.0000,3834734.0000,3835074.0000,3836306.0000,3819865.0000,3822260.0000,3816229.0000,3830626.0000,3829796.0000,3834022.0000,3823662.0000,3829293.0000,3828933.0000,3828703.0000,3837459.0000,3822651.0000,3831929.0000,3827761.0000,3829163.0000,3825006.0000,3826609.0000,3826558.0000,3832650.0000,3832449.0000,3824956.0000,3823653.0000,3818543.0000,3824466.0000,3834052.0000,3383309.0000,3398477.0000,3381695.0000,3389941.0000,3380663.0000,3384691.0000,3384901.0000,3403808.0000,3408656.0000,3662518.0000,3832490.0000,3825146.0000,3838862.0000,3815527.0000,3835074.0000,3823062.0000,3823994.0000,3816990.0000,3824695.0000,3810919.0000,3821880.0000,3810217.0000,3811960.0000,3823373.0000,3824374.0000,3826980.0000,3833511.0000,3813954.0000,3820538.0000,3822821.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,1013758300,10093770.9000,10039097.8700,10119273.2000,182216.0722,108859.9096,285698.9267,"10168646.0000,10117167.0000,10205355.0000,10157705.0000,10154248.0000,10113170.0000,10150722.0000,10158265.0000,10177102.0000,10111897.0000,10124162.0000,10101548.0000,10172001.0000,10097390.0000,10118071.0000,10138047.0000,10107409.0000,10089896.0000,10108442.0000,10133037.0000,10096399.0000,10101288.0000,10136104.0000,10128699.0000,10155550.0000,10135163.0000,10103261.0000,10137987.0000,10103181.0000,10157544.0000,10099093.0000,10122287.0000,10084797.0000,10122017.0000,10099784.0000,10110855.0000,10099595.0000,10108210.0000,10117899.0000,10132977.0000,10109895.0000,10090557.0000,10093273.0000,10101728.0000,10133199.0000,10179625.0000,10105024.0000,10161212.0000,10111457.0000,10118911.0000,10202239.0000,10088074.0000,10142846.0000,10174927.0000,10141905.0000,10145522.0000,10147285.0000,10157664.0000,10105956.0000,10110144.0000,10115445.0000,10101217.0000,9895798.0000,9084260.0000,9087697.0000,9089170.0000,9887914.0000,10126375.0000,10115765.0000,10105846.0000,10172714.0000,10146674.0000,10151783.0000,10104303.0000,10105776.0000,10152454.0000,10162794.0000,10160721.0000,10145101.0000,10157364.0000,10167623.0000,10113792.0000,10159978.0000,10140000.0000,10097249.0000,10173755.0000,10153437.0000,10121115.0000,10117949.0000,10121517.0000,10092481.0000,10111958.0000,10097540.0000,10098143.0000,10149218.0000,10157143.0000,10106628.0000,10112600.0000,10171831.0000,10165549.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,424588700,4245059.6300,4243465.4500,4246466.1300,7687.2157,6596.4617,9545.0747,"4246294.0000,4254881.0000,4249229.0000,4242888.0000,4225925.0000,4229512.0000,4237387.0000,4243219.0000,4251744.0000,4239311.0000,4238599.0000,4243649.0000,4248969.0000,4251634.0000,4247426.0000,4246975.0000,4248438.0000,4251414.0000,4249951.0000,4241234.0000,4228160.0000,4246885.0000,4240583.0000,4238639.0000,4240653.0000,4245893.0000,4238128.0000,4247746.0000,4239782.0000,4247856.0000,4260119.0000,4238809.0000,4239812.0000,4253688.0000,4231646.0000,4251725.0000,4242055.0000,4250201.0000,4257996.0000,4249470.0000,4236635.0000,4243910.0000,4238308.0000,4239070.0000,4243679.0000,4244310.0000,4250412.0000,4245212.0000,4246384.0000,4258717.0000,4240002.0000,4235954.0000,4232708.0000,4215445.0000,4228290.0000,4246925.0000,4249499.0000,4241404.0000,4246084.0000,4242025.0000,4254339.0000,4243899.0000,4238689.0000,4248769.0000,4256273.0000,4248107.0000,4251874.0000,4235453.0000,4246083.0000,4240783.0000,4247346.0000,4248288.0000,4254810.0000,4244721.0000,4262083.0000,4243900.0000,4251764.0000,4247766.0000,4256833.0000,4254760.0000,4254019.0000,4249259.0000,4255943.0000,4241405.0000,4247546.0000,4252556.0000,4236735.0000,4254990.0000,4243037.0000,4248387.0000,4243128.0000,4242517.0000,4241866.0000,4251183.0000,4239732.0000,4243839.0000,4248758.0000,4241073.0000,4242717.0000,4247235.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,1803884200,17979225.9900,17915856.4900,18012437.7800,225042.2098,119992.8479,412664.2632,"18028958.0000,18031544.0000,18134198.0000,18010905.0000,17996337.0000,17988783.0000,18008780.0000,18008050.0000,18071459.0000,17981259.0000,17987730.0000,17980056.0000,18002589.0000,18001367.0000,18016596.0000,17985797.0000,18004002.0000,17997539.0000,18009152.0000,17984404.0000,17984044.0000,17989674.0000,18024059.0000,18029681.0000,18048656.0000,18010925.0000,18018589.0000,18001948.0000,18013019.0000,18010453.0000,17972973.0000,18054627.0000,18001497.0000,17997820.0000,18005525.0000,17995655.0000,17950099.0000,17986689.0000,18019230.0000,18007028.0000,18004021.0000,18008812.0000,17982450.0000,17968675.0000,18006066.0000,18002508.0000,18015564.0000,18008590.0000,17989264.0000,17980065.0000,17968544.0000,17980827.0000,17984504.0000,17979966.0000,18004823.0000,17976951.0000,17980146.0000,17983323.0000,18006917.0000,17993852.0000,17982080.0000,18013800.0000,17996929.0000,18005204.0000,18007548.0000,17992339.0000,17986969.0000,17995957.0000,17985736.0000,17948967.0000,17994584.0000,18015934.0000,17991577.0000,17990586.0000,18008190.0000,18003209.0000,17982741.0000,18030652.0000,17990857.0000,18023718.0000,18047374.0000,17978904.0000,17994093.0000,17969116.0000,18033848.0000,17994975.0000,18006416.0000,17705666.0000,18955575.0000,17304636.0000,16300755.0000,17182906.0000,18045691.0000,18061069.0000,18045730.0000,18036233.0000,18040040.0000,18031183.0000,18030903.0000,18032345.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,607530800,6028284.5000,5991033.4500,6051205.9400,143159.2002,88083.9110,198281.7121,"6066453.0000,6055872.0000,6075300.0000,6055281.0000,6056333.0000,6070841.0000,6065922.0000,6069188.0000,6073936.0000,6080298.0000,6060422.0000,6060230.0000,6054090.0000,6067595.0000,6052296.0000,6068266.0000,6059920.0000,6063818.0000,6052336.0000,6071662.0000,6050142.0000,6063398.0000,6061703.0000,6061413.0000,6054971.0000,6048038.0000,6061914.0000,6045192.0000,6063007.0000,6062064.0000,6052015.0000,6056173.0000,6068076.0000,6047897.0000,6053949.0000,6059069.0000,6072745.0000,6067875.0000,6069419.0000,6066703.0000,6074127.0000,6055301.0000,6056464.0000,6050603.0000,6057766.0000,6055622.0000,6065410.0000,6062575.0000,6070370.0000,6068887.0000,6077184.0000,6059179.0000,6075059.0000,6061082.0000,6073055.0000,6049190.0000,6070721.0000,6045614.0000,6055181.0000,6066312.0000,6066151.0000,6069708.0000,6065000.0000,6063808.0000,6050833.0000,6070140.0000,6063357.0000,6065631.0000,6050272.0000,6071763.0000,6062405.0000,6063837.0000,6062105.0000,6055772.0000,6062325.0000,6074648.0000,6061172.0000,6082042.0000,6070901.0000,6076512.0000,6062325.0000,6070170.0000,6062545.0000,6069428.0000,6095147.0000,6078305.0000,6076152.0000,6085579.0000,6074848.0000,6081791.0000,6071252.0000,6054660.0000,6060131.0000,5437962.0000,5440106.0000,5449344.0000,5439104.0000,5437500.0000,5587845.0000,6070350.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,6203781200,55457495.1900,54775692.6200,56211792.8200,3652289.0474,3145352.0645,4318251.0684,"56622995.0000,48199966.0000,51630466.0000,54964112.0000,55901068.0000,55736056.0000,47902362.0000,52746370.0000,51444714.0000,55086083.0000,55604706.0000,50848965.0000,56600904.0000,54738555.0000,60059076.0000,61560621.0000,61639922.0000,51422572.0000,51718192.0000,55259792.0000,54248827.0000,56842542.0000,58964492.0000,48818447.0000,53282606.0000,57383807.0000,53644392.0000,57915193.0000,54431283.0000,48847873.0000,54462121.0000,54336813.0000,54222798.0000,57348861.0000,59028524.0000,65791407.0000,49182888.0000,54174105.0000,54633225.0000,60446620.0000,54110956.0000,54032017.0000,51700188.0000,54418117.0000,58470446.0000,55425897.0000,56799970.0000,54656309.0000,51906719.0000,55181265.0000,52894792.0000,52321595.0000,54197199.0000,53278909.0000,56211145.0000,52500955.0000,60816982.0000,54879692.0000,65844929.0000,54798969.0000,55714013.0000,61124806.0000,51597493.0000,53210950.0000,53965650.0000,54300415.0000,53496371.0000,54637804.0000,54084195.0000,52858533.0000,56307338.0000,59083327.0000,55519725.0000,53270623.0000,53694837.0000,59186914.0000,58933985.0000,55411640.0000,52807165.0000,50929708.0000,54734808.0000,60243736.0000,58137966.0000,54437174.0000,61312481.0000,53573868.0000,51789717.0000,53230097.0000,59879716.0000,53415308.0000,53224476.0000,56157894.0000,55414044.0000,61571662.0000,60837371.0000,60013510.0000,61405527.0000,54600152.0000,53251777.0000,66241371.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,647310000,6336548.0500,6200762.9200,6476732.1200,698011.4034,633984.4687,775829.4540,"5212044.0000,5344535.0000,7027193.0000,6320544.0000,5936928.0000,6041815.0000,7466525.0000,6649006.0000,5806760.0000,5561676.0000,7015310.0000,6570187.0000,5620918.0000,6099857.0000,6610654.0000,7030879.0000,5546467.0000,5628312.0000,6558284.0000,6696817.0000,5697273.0000,7130739.0000,6650670.0000,6573664.0000,7519986.0000,5845824.0000,6724219.0000,6671319.0000,5779189.0000,5502965.0000,6222588.0000,7367097.0000,5863338.0000,6171882.0000,6794512.0000,6403110.0000,5056529.0000,6457614.0000,6215304.0000,5595089.0000,5428935.0000,6366981.0000,7019268.0000,5213225.0000,7368900.0000,6225043.0000,5420339.0000,5459994.0000,6699162.0000,6596167.0000,6112089.0000,6240733.0000,7023325.0000,6259458.0000,5765422.0000,5385893.0000,5334235.0000,5410781.0000,6504093.0000,7866604.0000,6587750.0000,5547139.0000,5403256.0000,7328213.0000,6689022.0000,6212109.0000,6983311.0000,6460700.0000,7900147.0000,5998704.0000,5648701.0000,5612843.0000,7136440.0000,7400911.0000,6306057.0000,7147852.0000,5390772.0000,7240217.0000,6419181.0000,5585150.0000,5723512.0000,7220880.0000,6303512.0000,5633502.0000,6328770.0000,7628893.0000,6265480.0000,5409358.0000,5845775.0000,6916674.0000,6784293.0000,6755978.0000,7168811.0000,5534224.0000,7360314.0000,6448486.0000,6006379.0000,7365454.0000,7335297.0000,5932469.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,944526800,9545757.7000,9428823.6200,9789512.5700,828545.1773,417136.1126,1450950.0407,"9183990.0000,9072899.0000,15378166.0000,13795658.0000,9530207.0000,9204749.0000,9606059.0000,9371565.0000,9625717.0000,9241098.0000,9152941.0000,9167768.0000,8562071.0000,8425642.0000,8664986.0000,9222322.0000,9337270.0000,9297495.0000,9009649.0000,9206141.0000,9480521.0000,9599316.0000,9493716.0000,9411010.0000,9239374.0000,9271926.0000,9694386.0000,9672004.0000,9602934.0000,9628933.0000,9230488.0000,9408284.0000,9628782.0000,9280031.0000,9102305.0000,9206282.0000,9563470.0000,9372277.0000,9637499.0000,9696331.0000,9805988.0000,9133223.0000,9101894.0000,9296913.0000,9174662.0000,9354373.0000,9545735.0000,9976050.0000,9628392.0000,9495660.0000,9559571.0000,9613433.0000,9304759.0000,9195031.0000,9396242.0000,9391713.0000,9458299.0000,9942406.0000,9883485.0000,9665181.0000,9255555.0000,9157419.0000,9387245.0000,9411120.0000,11441176.0000,10378793.0000,9078770.0000,9204529.0000,9484659.0000,9494287.0000,9866432.0000,9835925.0000,9164021.0000,9192886.0000,9976351.0000,9794416.0000,9529674.0000,9200541.0000,9287886.0000,9290431.0000,9912120.0000,9511230.0000,9628581.0000,9301302.0000,9742859.0000,9536007.0000,9300221.0000,9486803.0000,9318845.0000,9226149.0000,10817244.0000,8800603.0000,8767871.0000,9534524.0000,9934131.0000,9612512.0000,9952155.0000,9187696.0000,9344383.0000,9029146.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,549935000,6523877.3900,6379466.0400,6673606.3800,752577.1051,676401.6151,842194.2556,"6334200.0000,6536964.0000,7584810.0000,5264684.0000,4780907.0000,5322523.0000,6076853.0000,6868142.0000,6245742.0000,7520447.0000,6111157.0000,6055301.0000,5863118.0000,7598506.0000,6351131.0000,5973577.0000,5993174.0000,5887293.0000,7474460.0000,6899811.0000,5973677.0000,6306387.0000,7709376.0000,6581218.0000,6627916.0000,7158602.0000,6009554.0000,6181550.0000,7275233.0000,7122804.0000,6189746.0000,5973476.0000,7863087.0000,6639658.0000,6949025.0000,7431970.0000,6110215.0000,7583567.0000,6357945.0000,6063206.0000,6121747.0000,6470498.0000,7705619.0000,6620833.0000,5658881.0000,5460705.0000,7170344.0000,5939412.0000,5287306.0000,5431129.0000,6310344.0000,6841962.0000,5377999.0000,6406236.0000,6069207.0000,5440406.0000,6530341.0000,7795408.0000,6134441.0000,6070740.0000,6152415.0000,7789116.0000,6736032.0000,7385151.0000,7038114.0000,6673132.0000,7937207.0000,6088714.0000,5749873.0000,6458355.0000,7679388.0000,6305906.0000,8053127.0000,7917179.0000,6209924.0000,6426785.0000,7547198.0000,6278094.0000,6137117.0000,7562387.0000,6247806.0000,5578849.0000,5863969.0000,6371901.0000,7254313.0000,6483292.0000,5876672.0000,7205260.0000,6552834.0000,5790990.0000,6246804.0000,7746426.0000,6519090.0000,6953053.0000,7504638.0000,6023471.0000,7536077.0000,6079647.0000,5282908.0000,5449955.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,3013304500,29784677.7200,29382839.9100,30240396.1600,2178207.2030,1848556.0016,2675201.3300,"32144364.0000,32062929.0000,26402724.0000,30258742.0000,31529779.0000,30025610.0000,29874052.0000,28905478.0000,28760753.0000,26543031.0000,27062446.0000,27144621.0000,29144480.0000,30086404.0000,28645685.0000,32101773.0000,30094650.0000,29999049.0000,29488862.0000,28392957.0000,29871467.0000,29833756.0000,30227372.0000,26070836.0000,28513124.0000,29258506.0000,30513405.0000,32050306.0000,30329966.0000,37382098.0000,29438597.0000,30984738.0000,30061778.0000,30881582.0000,31448254.0000,30453861.0000,29987036.0000,31400694.0000,28862526.0000,28261036.0000,32007385.0000,29437966.0000,28209458.0000,28125660.0000,27849095.0000,27972190.0000,27882839.0000,29664876.0000,33870275.0000,30100301.0000,29962020.0000,32497523.0000,35028530.0000,33739126.0000,29181050.0000,27417357.0000,29608269.0000,30449323.0000,31919929.0000,37237996.0000,26245887.0000,27295776.0000,25894783.0000,26095082.0000,28000953.0000,27469016.0000,28462737.0000,28464552.0000,30976380.0000,29843273.0000,29981156.0000,30248311.0000,27906655.0000,29004665.0000,33865264.0000,26109651.0000,27591788.0000,28125059.0000,27329972.0000,31184876.0000,30384360.0000,31689041.0000,30805217.0000,29199363.0000,29429900.0000,27263186.0000,28883094.0000,30220618.0000,33103953.0000,29378443.0000,29801926.0000,27236815.0000,27392430.0000,30380032.0000,29707296.0000,30262950.0000,31899881.0000,32736646.0000,32141258.0000,29795032.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,1129651400,11175543.7100,10959415.5200,11387631.7100,1091582.4343,992174.5520,1216229.6478,"10299322.0000,12652152.0000,13603704.0000,11055797.0000,12168935.0000,11500409.0000,11845111.0000,12023088.0000,9975469.0000,10606515.0000,11363680.0000,9657978.0000,12047405.0000,11744451.0000,9637900.0000,11823912.0000,12632834.0000,9100612.0000,11257268.0000,11658619.0000,12714960.0000,11934501.0000,9369541.0000,9093458.0000,12400264.0000,10686808.0000,13072898.0000,10351261.0000,11992671.0000,12056181.0000,9789166.0000,9956223.0000,11512392.0000,10197580.0000,9838299.0000,11576934.0000,12249909.0000,10052165.0000,12789581.0000,11572996.0000,9986851.0000,12595703.0000,11089209.0000,10461861.0000,12895472.0000,12132356.0000,11126660.0000,11966232.0000,10158356.0000,11569510.0000,12756910.0000,9993053.0000,10641581.0000,11820114.0000,11195461.0000,12118389.0000,9351116.0000,12016026.0000,9980208.0000,11489979.0000,10127958.0000,11656093.0000,10332667.0000,12788018.0000,11176234.0000,10084866.0000,11398566.0000,10220814.0000,11466094.0000,10515623.0000,12246843.0000,9811719.0000,10962139.0000,11762225.0000,11749230.0000,11210690.0000,12534438.0000,10581297.0000,12299593.0000,12271690.0000,9922699.0000,10343927.0000,10746760.0000,9882904.0000,8979262.0000,12213290.0000,11541346.0000,9668808.0000,11839381.0000,10251482.0000,11639251.0000,10106597.0000,10783811.0000,11298627.0000,8916733.0000,11446978.0000,12523227.0000,10062554.0000,12971576.0000,12010365.0000" diff --git a/ci/perf/gpuc2_bench.md b/ci/perf/gpuc2_bench.md index 07f166a8e..259428cb4 100644 --- a/ci/perf/gpuc2_bench.md +++ b/ci/perf/gpuc2_bench.md @@ -2,94 +2,96 @@ | Metadata | | | :------- | :------------------- | -| Created | 2022-05-12T16:50:07Z | +| Created | 2022-05-19T09:23:57Z | -| Test case | Benchmark name | Min | Mean | Std dev | -| :------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------- | -------------: | -------------: | -----------: | -| benchmark intrusive graph dependency handling with N nodes - 1 | creating nodes | 4.48 | 4.78 | 0.16 | -| benchmark intrusive graph dependency handling with N nodes - 1 | creating and adding dependencies | 24.15 | 24.22 | 0.06 | -| benchmark intrusive graph dependency handling with N nodes - 1 | adding and removing dependencies | 20.53 | 20.54 | 0.01 | -| benchmark intrusive graph dependency handling with N nodes - 1 | checking for dependencies | 2.41 | 2.42 | 0.04 | -| benchmark intrusive graph dependency handling with N nodes - 10 | creating nodes | 30.42 | 30.43 | 0.01 | -| benchmark intrusive graph dependency handling with N nodes - 10 | creating and adding dependencies | 285.11 | 287.72 | 4.20 | -| benchmark intrusive graph dependency handling with N nodes - 10 | adding and removing dependencies | 242.86 | 245.99 | 9.69 | -| benchmark intrusive graph dependency handling with N nodes - 10 | checking for dependencies | 30.43 | 30.64 | 0.41 | -| benchmark intrusive graph dependency handling with N nodes - 100 | creating nodes | 440.24 | 442.86 | 5.37 | -| benchmark intrusive graph dependency handling with N nodes - 100 | creating and adding dependencies | 4'785.50 | 4'813.67 | 12.94 | -| benchmark intrusive graph dependency handling with N nodes - 100 | adding and removing dependencies | 4'810.33 | 4'886.86 | 76.98 | -| benchmark intrusive graph dependency handling with N nodes - 100 | checking for dependencies | 1'969.69 | 2'007.12 | 37.52 | -| generating large task graphs | soup topology | 13'082'613.00 | 15'269'494.68 | 342'973.39 | -| generating large task graphs | chain topology | 67'055.00 | 67'493.31 | 805.93 | -| generating large task graphs | expanding tree topology | 137'268.00 | 138'276.92 | 1'191.59 | -| generating large task graphs | contracting tree topology | 177'454.00 | 178'547.99 | 1'647.36 | -| generating large task graphs | wave\_sim topology | 648'346.00 | 660'209.70 | 5'835.04 | -| generating large task graphs | jacobi topology | 213'973.00 | 215'136.93 | 1'882.04 | -| generating large command graphs for N nodes - 1 | soup topology | 23'058'866.00 | 26'437'291.02 | 638'673.08 | -| generating large command graphs for N nodes - 1 | chain topology | 271'361.00 | 273'322.45 | 2'424.43 | -| generating large command graphs for N nodes - 1 | expanding tree topology | 435'553.00 | 438'959.86 | 3'007.33 | -| generating large command graphs for N nodes - 1 | contracting tree topology | 480'759.00 | 484'555.65 | 3'360.26 | -| generating large command graphs for N nodes - 1 | wave\_sim topology | 2'141'643.00 | 2'152'806.87 | 8'464.22 | -| generating large command graphs for N nodes - 1 | jacobi topology | 678'342.00 | 752'055.45 | 52'843.36 | -| generating large command graphs for N nodes - 4 | soup topology | 58'051'150.00 | 62'767'239.30 | 1'303'867.27 | -| generating large command graphs for N nodes - 4 | chain topology | 3'372'685.00 | 3'392'210.28 | 10'207.50 | -| generating large command graphs for N nodes - 4 | expanding tree topology | 8'575'017.00 | 9'547'281.35 | 182'676.05 | -| generating large command graphs for N nodes - 4 | contracting tree topology | 3'801'166.00 | 3'818'494.16 | 10'494.94 | -| generating large command graphs for N nodes - 4 | wave\_sim topology | 14'354'541.00 | 15'387'665.48 | 108'692.35 | -| generating large command graphs for N nodes - 4 | jacobi topology | 4'652'859.00 | 5'280'570.04 | 198'357.66 | -| generating large command graphs for N nodes - 16 | soup topology | 208'175'963.00 | 216'401'055.71 | 1'730'272.23 | -| generating large command graphs for N nodes - 16 | chain topology | 375'066'707.00 | 400'160'036.25 | 7'873'983.28 | -| generating large command graphs for N nodes - 16 | expanding tree topology | 637'998'998.00 | 671'729'393.36 | 7'713'639.74 | -| generating large command graphs for N nodes - 16 | contracting tree topology | 127'416'679.00 | 133'138'311.20 | 1'708'816.24 | -| generating large command graphs for N nodes - 16 | wave\_sim topology | 126'608'808.00 | 131'448'888.22 | 1'143'781.79 | -| generating large command graphs for N nodes - 16 | jacobi topology | 110'358'597.00 | 124'329'836.75 | 3'400'391.77 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | soup topology | 22'873'083.00 | 26'437'800.93 | 793'222.40 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | chain topology | 272'704.00 | 276'946.38 | 16'375.42 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | expanding tree topology | 440'312.00 | 443'654.59 | 5'164.16 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | contracting tree topology | 486'560.00 | 488'971.57 | 3'156.19 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | wave\_sim topology | 2'151'933.00 | 2'163'658.54 | 16'132.00 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | jacobi topology | 792'249.00 | 797'764.37 | 5'595.00 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | soup topology | 27'783'992.00 | 30'091'567.87 | 1'429'369.12 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | chain topology | 436'415.00 | 675'788.32 | 99'562.69 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | expanding tree topology | 630'863.00 | 931'762.92 | 93'163.70 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | contracting tree topology | 710'573.00 | 1'009'019.87 | 108'839.79 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | wave\_sim topology | 3'646'513.00 | 5'305'904.93 | 284'866.25 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | jacobi topology | 1'149'265.00 | 1'644'774.09 | 138'384.58 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 25'257'328.00 | 28'586'865.61 | 892'616.86 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 531'314.00 | 551'161.93 | 19'141.31 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 746'892.00 | 751'267.66 | 4'706.36 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 793'210.00 | 797'120.17 | 3'301.74 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 4'194'200.00 | 4'203'483.27 | 5'197.46 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 1'195'532.00 | 1'284'853.53 | 44'328.09 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | soup topology | 20'429'486.00 | 20'593'415.46 | 68'013.28 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | chain topology | 436'545.00 | 442'285.44 | 5'995.13 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 701'437.00 | 717'836.14 | 7'072.48 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 766'609.00 | 773'797.56 | 5'261.30 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 3'199'407.00 | 3'228'113.98 | 18'058.34 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 1'178'239.00 | 1'195'272.85 | 7'067.59 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | soup topology | 60'037'041.00 | 63'781'528.37 | 629'281.37 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | chain topology | 3'061'045.00 | 3'447'839.49 | 127'320.11 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | expanding tree topology | 9'028'676.00 | 9'701'693.96 | 76'899.93 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | contracting tree topology | 3'880'507.00 | 3'897'731.11 | 16'227.08 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | wave\_sim topology | 13'887'096.00 | 15'680'699.01 | 280'825.94 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | jacobi topology | 5'427'416.00 | 5'447'799.72 | 19'432.44 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | soup topology | 58'670'805.00 | 67'072'582.07 | 2'418'759.37 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | chain topology | 3'222'992.00 | 3'561'542.67 | 221'258.44 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | expanding tree topology | 6'215'980.00 | 6'566'341.71 | 128'969.01 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | contracting tree topology | 3'685'247.00 | 3'932'030.00 | 92'138.31 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | wave\_sim topology | 15'695'100.00 | 15'852'900.41 | 122'607.91 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | jacobi topology | 5'109'794.00 | 5'455'888.51 | 187'943.16 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 57'385'439.00 | 63'261'209.56 | 2'414'669.54 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 3'354'801.00 | 3'742'213.29 | 124'966.95 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 8'933'576.00 | 9'980'812.70 | 195'088.45 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 4'176'838.00 | 4'192'414.24 | 7'583.44 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 15'805'379.00 | 17'663'033.10 | 254'139.87 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 5'209'333.00 | 5'906'193.39 | 77'887.13 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | soup topology | 40'342'144.00 | 42'983'281.49 | 1'049'425.71 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | chain topology | 3'332'048.00 | 3'499'634.59 | 170'414.24 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 6'137'801.00 | 6'443'730.18 | 130'707.32 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 3'600'216.00 | 3'867'554.44 | 124'376.03 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 15'511'763.00 | 15'591'913.86 | 42'787.99 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 5'144'551.00 | 5'624'613.68 | 258'469.17 | +| Test case | Benchmark name | Min | Mean | Std dev | +| :------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------- | -------------: | -------------: | -----------: | +| benchmark intrusive graph dependency handling with N nodes - 1 | creating nodes | 4.47 | 4.89 | 0.13 | +| benchmark intrusive graph dependency handling with N nodes - 1 | creating and adding dependencies | 23.18 | 23.29 | 0.54 | +| benchmark intrusive graph dependency handling with N nodes - 1 | adding and removing dependencies | 16.05 | 16.11 | 0.42 | +| benchmark intrusive graph dependency handling with N nodes - 1 | checking for dependencies | 1.22 | 1.23 | 0.03 | +| benchmark intrusive graph dependency handling with N nodes - 10 | creating nodes | 39.11 | 39.77 | 0.52 | +| benchmark intrusive graph dependency handling with N nodes - 10 | creating and adding dependencies | 265.42 | 266.85 | 5.17 | +| benchmark intrusive graph dependency handling with N nodes - 10 | adding and removing dependencies | 205.54 | 207.44 | 5.32 | +| benchmark intrusive graph dependency handling with N nodes - 10 | checking for dependencies | 21.25 | 21.79 | 0.57 | +| benchmark intrusive graph dependency handling with N nodes - 100 | creating nodes | 412.35 | 413.53 | 1.57 | +| benchmark intrusive graph dependency handling with N nodes - 100 | creating and adding dependencies | 4'279.50 | 4'335.42 | 72.15 | +| benchmark intrusive graph dependency handling with N nodes - 100 | adding and removing dependencies | 3'726.67 | 3'751.30 | 121.63 | +| benchmark intrusive graph dependency handling with N nodes - 100 | checking for dependencies | 1'831.21 | 1'844.13 | 45.09 | +| benchmark task handling > without access thread | generating and deleting tasks | 3'903'415.00 | 4'920'304.44 | 276'404.03 | +| benchmark task handling > with access thread | generating and deleting tasks with access thread | 8'337'859.00 | 9'986'252.76 | 494'531.81 | +| generating large task graphs | soup topology | 13'725'216.00 | 15'701'911.78 | 564'494.22 | +| generating large task graphs | chain topology | 67'486.00 | 68'177.35 | 1'652.42 | +| generating large task graphs | expanding tree topology | 125'746.00 | 127'204.20 | 2'592.77 | +| generating large task graphs | contracting tree topology | 180'219.00 | 181'789.45 | 1'412.56 | +| generating large task graphs | wave\_sim topology | 648'627.00 | 653'178.81 | 4'574.43 | +| generating large task graphs | jacobi topology | 219'915.00 | 221'065.23 | 1'539.45 | +| generating large command graphs for N nodes - 1 | soup topology | 24'893'140.00 | 27'651'883.38 | 799'614.87 | +| generating large command graphs for N nodes - 1 | chain topology | 276'121.00 | 278'151.78 | 2'135.76 | +| generating large command graphs for N nodes - 1 | expanding tree topology | 443'238.00 | 446'435.63 | 3'834.36 | +| generating large command graphs for N nodes - 1 | contracting tree topology | 489'055.00 | 493'044.95 | 3'039.29 | +| generating large command graphs for N nodes - 1 | wave\_sim topology | 2'003'555.00 | 2'228'973.08 | 23'571.60 | +| generating large command graphs for N nodes - 1 | jacobi topology | 829'420.00 | 835'088.75 | 3'966.55 | +| generating large command graphs for N nodes - 4 | soup topology | 60'720'241.00 | 65'577'388.09 | 1'119'938.08 | +| generating large command graphs for N nodes - 4 | chain topology | 3'490'573.00 | 3'504'745.22 | 10'336.79 | +| generating large command graphs for N nodes - 4 | expanding tree topology | 8'746'432.00 | 9'744'932.13 | 185'372.44 | +| generating large command graphs for N nodes - 4 | contracting tree topology | 3'889'108.00 | 3'908'198.79 | 8'144.54 | +| generating large command graphs for N nodes - 4 | wave\_sim topology | 14'065'261.00 | 15'832'766.48 | 240'437.15 | +| generating large command graphs for N nodes - 4 | jacobi topology | 4'872'220.00 | 5'447'579.97 | 205'399.52 | +| generating large command graphs for N nodes - 16 | soup topology | 219'083'488.00 | 223'837'319.46 | 1'331'417.84 | +| generating large command graphs for N nodes - 16 | chain topology | 426'542'249.00 | 438'905'484.09 | 3'118'030.65 | +| generating large command graphs for N nodes - 16 | expanding tree topology | 704'484'478.00 | 717'760'331.14 | 4'365'997.08 | +| generating large command graphs for N nodes - 16 | contracting tree topology | 132'154'550.00 | 139'656'299.58 | 1'470'612.25 | +| generating large command graphs for N nodes - 16 | wave\_sim topology | 129'569'000.00 | 136'091'353.72 | 1'382'756.02 | +| generating large command graphs for N nodes - 16 | jacobi topology | 125'627'319.00 | 130'839'766.57 | 1'608'945.30 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | soup topology | 25'233'421.00 | 27'995'963.41 | 398'272.93 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | chain topology | 277'013.00 | 279'709.40 | 2'836.25 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | expanding tree topology | 444'871.00 | 447'262.84 | 2'243.49 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | contracting tree topology | 492'601.00 | 497'440.20 | 16'166.74 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | wave\_sim topology | 2'211'077.00 | 2'226'367.18 | 17'202.19 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | jacobi topology | 830'191.00 | 835'391.60 | 3'702.16 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | soup topology | 16'303'460.00 | 24'165'362.83 | 2'485'140.77 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | chain topology | 643'949.00 | 805'665.57 | 46'484.16 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | expanding tree topology | 664'037.00 | 727'347.33 | 76'785.64 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | contracting tree topology | 526'856.00 | 914'252.27 | 285'106.30 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | wave\_sim topology | 3'493'687.00 | 4'373'288.17 | 726'948.74 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | jacobi topology | 1'408'878.00 | 1'560'733.73 | 137'739.88 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 26'539'686.00 | 30'161'093.23 | 615'581.85 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 573'043.00 | 576'424.40 | 2'552.37 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 751'431.00 | 754'749.34 | 3'734.55 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 745'771.00 | 799'208.18 | 7'599.13 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 4'026'948.00 | 4'249'079.41 | 84'746.94 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 1'342'341.00 | 1'346'997.45 | 3'463.84 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | soup topology | 17'923'669.00 | 24'211'126.23 | 2'770'300.94 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | chain topology | 1'042'183.00 | 1'294'620.88 | 135'008.93 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 1'064'886.00 | 1'706'681.06 | 232'875.02 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 1'513'726.00 | 1'716'872.92 | 99'743.92 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 5'790'721.00 | 9'468'295.91 | 1'436'924.17 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 1'456'157.00 | 2'400'342.94 | 514'241.66 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | soup topology | 60'945'637.00 | 66'020'014.67 | 865'893.15 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | chain topology | 3'095'243.00 | 3'499'779.15 | 96'334.54 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | expanding tree topology | 9'783'166.00 | 9'849'989.23 | 22'113.04 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | contracting tree topology | 3'910'467.00 | 3'939'575.42 | 8'010.96 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | wave\_sim topology | 14'116'586.00 | 15'832'562.14 | 406'166.09 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | jacobi topology | 5'534'996.00 | 5'552'896.93 | 8'340.21 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | soup topology | 44'269'820.00 | 54'940'307.75 | 3'719'537.37 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | chain topology | 4'628'809.00 | 4'925'400.08 | 359'385.89 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | expanding tree topology | 7'838'721.00 | 8'673'340.21 | 536'414.09 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | contracting tree topology | 4'076'352.00 | 4'646'449.50 | 604'379.57 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | wave\_sim topology | 16'871'736.00 | 19'443'608.66 | 1'961'803.02 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | jacobi topology | 5'962'306.00 | 6'719'872.42 | 870'753.09 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 62'743'653.00 | 68'424'802.08 | 806'483.17 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 3'380'663.00 | 3'787'358.03 | 126'316.13 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 9'084'260.00 | 10'093'770.90 | 182'216.07 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 4'215'445.00 | 4'245'059.63 | 7'687.22 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 16'300'755.00 | 17'979'225.99 | 225'042.21 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 5'437'500.00 | 6'028'284.50 | 143'159.20 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | soup topology | 47'902'362.00 | 55'457'495.19 | 3'652'289.05 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | chain topology | 5'056'529.00 | 6'336'548.05 | 698'011.40 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 8'425'642.00 | 9'545'757.70 | 828'545.18 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 4'780'907.00 | 6'523'877.39 | 752'577.11 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 25'894'783.00 | 29'784'677.72 | 2'178'207.20 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 8'916'733.00 | 11'175'543.71 | 1'091'582.43 | All numbers are in nanoseconds. diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h index e673a4807..4fbd01eb8 100644 --- a/include/task_ring_buffer.h +++ b/include/task_ring_buffer.h @@ -3,6 +3,7 @@ #include #include #include +#include #include "log.h" #include "task.h" From dac161d0f1828bff030a889caac77faa6e314cf4 Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Fri, 17 Jun 2022 14:40:35 +0200 Subject: [PATCH 7/8] task_ring_buffer improvements Based on reviews & discussion: * now uses epoch monitor * tracks in-flight horizons/epochs to be able to report deadlock scenarios * unit tests * document how member functions may be called * explicit memory semantics on atomics --- ci/perf/gpuc2_bench.csv | 172 ++++++++++++++++---------------- ci/perf/gpuc2_bench.md | 174 ++++++++++++++++----------------- include/runtime.h | 4 +- include/task_manager.h | 23 +++-- include/task_ring_buffer.h | 55 +++++++---- src/runtime.cc | 4 +- src/task_manager.cc | 56 +++++++---- test/CMakeLists.txt | 1 + test/task_ring_buffer_tests.cc | 53 ++++++++++ test/test_utils.h | 6 ++ 10 files changed, 324 insertions(+), 224 deletions(-) create mode 100644 test/task_ring_buffer_tests.cc diff --git a/ci/perf/gpuc2_bench.csv b/ci/perf/gpuc2_bench.csv index 2d56fa89d..2cf662623 100644 --- a/ci/perf/gpuc2_bench.csv +++ b/ci/perf/gpuc2_bench.csv @@ -1,87 +1,87 @@ test case,benchmark name,samples,iterations,estimated,mean,low mean,high mean,std dev,low std dev,high std dev,raw -benchmark intrusive graph dependency handling with N nodes - 1,creating nodes,100,5849,2339600,4.8935,4.8688,4.9202,0.1306,0.0941,0.2035,"4.9347,4.9501,4.4720,4.8800,4.9501,4.8901,4.8764,4.9037,4.8884,4.9123,4.8988,4.9226,4.9073,4.9313,4.9157,4.9364,4.9193,4.9415,4.9243,4.9449,4.9296,4.9586,4.9296,4.9501,4.9330,4.9535,4.9345,4.9552,4.9362,4.9552,4.9381,4.9569,4.9398,4.9569,4.9398,4.9552,4.4705,4.5047,4.5680,4.5851,4.6399,4.6504,4.7017,4.7051,4.7497,4.9501,4.7702,4.7685,4.8061,4.8012,4.8352,4.8268,4.8593,4.9501,4.8678,4.8593,4.8849,4.8730,4.9022,4.9501,4.9037,4.8918,4.9174,4.9501,4.9193,4.9055,4.9296,4.9108,4.9345,4.9176,4.9398,4.9226,4.9448,4.9261,4.9484,4.9296,4.9518,4.9313,4.9535,4.9345,4.9550,4.9362,4.9569,4.9381,4.9586,4.9398,4.9569,4.9398,5.6575,4.9518,4.8918,4.8781,4.9056,4.9501,4.9089,4.8971,4.9191,4.9037,4.9296,4.9123" -benchmark intrusive graph dependency handling with N nodes - 1,creating and adding dependencies,100,1049,2412700,23.2914,23.2330,23.5558,0.5409,0.0707,1.2812,"23.3213,23.3413,23.5033,23.2164,23.1783,23.1792,23.2259,23.1783,23.3794,23.2736,23.3403,23.3213,23.2164,23.1783,23.2164,23.1783,23.1878,23.4461,23.2069,23.4175,23.2450,23.2069,23.1888,23.3308,23.3213,23.2164,23.1783,23.2355,23.4175,23.1783,23.2164,23.1792,23.2164,23.1878,23.3508,23.3117,23.2164,23.1783,23.2736,23.3880,23.2269,23.1783,23.1878,23.2164,23.1888,23.2069,23.1878,23.2164,23.1888,23.2164,23.1878,23.2355,23.4080,23.1878,23.2164,23.1792,23.3975,23.2555,28.6225,23.1878,23.2164,23.1878,23.2078,23.1878,23.1783,23.4080,23.2736,23.2259,23.1783,23.2173,23.1878,23.1783,23.2164,23.1792,23.2164,23.1878,23.3117,23.3403,23.2164,23.1878,23.2069,23.1783,23.1878,23.2164,23.1792,23.3785,23.2745,23.2164,23.1878,23.2164,23.1783,23.2164,23.1878,23.1783,23.2164,23.1792,23.2164,23.1783,23.2259,23.1792" -benchmark intrusive graph dependency handling with N nodes - 1,adding and removing dependencies,100,1516,2425600,16.1097,16.0666,16.2811,0.4201,0.0123,1.0021,"16.0778,16.0587,16.1115,16.0580,16.0515,16.0778,16.0587,16.0844,16.0580,16.0851,16.0580,16.0580,16.0778,16.0587,16.0778,16.0580,16.0580,16.0851,16.0580,16.0844,16.0580,16.0844,16.0580,16.0515,16.0785,16.0580,16.0778,16.0580,16.0719,16.0580,16.0580,16.0778,16.0515,16.0844,16.0580,16.0521,16.0844,16.0580,16.0844,16.0587,16.0778,16.0580,16.0580,16.0778,16.0580,16.0712,16.0587,16.0515,16.0844,16.0580,16.0851,16.0580,16.0844,16.0580,16.0580,16.0844,16.0580,16.0851,16.0515,20.2876,16.0580,16.0580,16.0844,16.0580,16.0785,16.0580,16.0778,16.0580,16.0521,16.0910,16.0580,16.0785,16.0580,16.0844,16.0580,16.0587,16.0844,16.0580,16.0712,16.0587,16.0580,16.0844,16.0580,16.0778,16.0580,16.0844,16.0587,16.0580,16.0844,16.0580,16.0785,16.0580,16.0778,16.0580,16.0515,16.0844,16.0580,16.0785,16.0580,16.0580" -benchmark intrusive graph dependency handling with N nodes - 1,checking for dependencies,100,19949,1994900,1.2287,1.2255,1.2411,0.0297,0.0037,0.0705,"1.2233,1.2213,1.2309,1.2248,1.2224,1.2318,1.2224,1.2298,1.2229,1.2293,1.2229,1.2223,1.2299,1.2223,1.2298,1.2228,1.2218,1.2319,1.2223,1.2309,1.2223,1.2299,1.2223,1.2218,1.2304,1.2228,1.2309,1.5222,1.2303,1.2229,1.2213,1.2303,1.2223,1.2298,1.2229,1.2293,1.2234,1.2213,1.2299,1.2223,1.2293,1.2228,1.2288,1.2229,1.2223,1.2304,1.2223,1.2299,1.2238,1.2218,1.2309,1.2223,1.2299,1.2223,1.2294,1.2233,1.2213,1.2299,1.2223,1.2299,1.2228,1.2294,1.2233,1.2219,1.2298,1.2228,1.2293,1.2228,1.2289,1.2233,1.2224,1.2293,1.2229,1.2308,1.2229,1.2213,1.2303,1.2223,1.2298,1.2229,1.2288,1.2234,1.2213,1.2304,1.2223,1.2299,1.2228,1.2293,1.2234,1.2223,1.2299,1.2223,1.2299,1.2228,1.2218,1.2309,1.2218,1.2299,1.2228,1.2294" -benchmark intrusive graph dependency handling with N nodes - 10,creating nodes,100,647,2393900,39.7659,39.6992,39.9438,0.5185,0.2406,1.1134,"39.9799,39.8408,39.8099,39.1283,39.9490,39.2365,39.4235,39.8563,39.9799,39.8563,39.9799,39.8099,39.8408,39.7481,39.2056,39.5920,39.4699,39.7790,39.8408,39.8717,39.6074,39.8547,39.5471,39.2674,39.4235,39.8563,39.9799,39.6244,39.3601,39.8408,39.8563,39.5611,39.4853,39.9799,39.8563,39.8099,39.8408,39.9799,39.8408,39.8563,39.9799,44.2859,39.9799,39.3756,39.6244,39.5611,39.3756,39.5456,39.1283,39.9490,39.8563,39.9799,39.7017,39.2674,39.3756,39.9799,39.8408,39.8563,39.9799,39.8547,39.4853,39.5471,39.9799,39.7635,39.3447,39.1592,39.8408,39.9799,39.8563,39.8099,39.1128,39.5471,39.8563,39.9490,39.6244,39.8408,39.9799,39.8408,39.9799,39.7172,39.5301,39.6399,39.2519,39.6244,39.8563,39.9799,39.8408,39.5317,39.7311,39.9799,39.8393,39.9490,39.1437,39.8408,39.9799,39.8563,39.9799,39.8408,39.9954,39.8563" -benchmark intrusive graph dependency handling with N nodes - 10,creating and adding dependencies,100,93,2455200,266.8518,266.2994,269.0646,5.1662,0.5538,12.2632,"265.8602,266.7204,269.5269,267.3656,266.2903,267.3656,266.3978,267.2581,266.3978,265.8602,266.7204,265.7527,266.6129,265.7527,267.0430,266.1828,266.2903,266.9355,265.9677,267.3656,265.9677,265.5376,267.0430,265.6452,266.7204,265.8602,266.5054,266.0645,265.4194,267.0538,265.9570,266.8280,265.7527,266.3978,265.4301,265.4194,266.3871,265.8495,266.6129,265.5269,266.6129,266.0753,265.5269,266.3978,265.4194,266.6129,317.8925,267.2581,265.9677,266.9355,266.0753,265.5376,266.5054,265.8602,266.7204,265.8602,266.8280,266.1828,265.9677,266.7204,265.8602,266.9462,266.1828,266.5054,266.0753,265.9677,266.6129,265.8602,266.9355,265.9677,266.8280,265.7527,265.6452,266.5054,265.7527,266.8280,265.9677,266.8280,266.0753,265.9677,267.0430,266.0753,266.8280,266.0645,266.9355,266.2903,265.9677,267.0430,265.9677,266.7204,266.0753,266.6129,265.9677,265.8602,266.8280,265.6452,266.7204,265.9677,265.6452,267.2581" -benchmark intrusive graph dependency handling with N nodes - 10,adding and removing dependencies,100,118,2442600,207.4397,206.8692,209.6582,5.3246,0.6049,12.6300,"207.2373,207.3220,208.0932,207.0678,206.9068,206.3051,207.5847,205.7966,207.4068,206.5593,206.8983,207.0678,206.0508,208.0000,205.7966,207.2458,206.8983,206.6441,207.4153,206.0508,207.5000,206.3051,207.0678,207.1610,206.4746,207.6695,205.5424,207.4915,206.6441,206.8983,207.1525,206.0508,207.9153,205.6271,207.2458,206.8983,206.6441,207.3305,205.8814,207.4068,206.1356,207.0678,206.8136,206.3051,207.6610,205.5424,207.5000,206.6441,206.9068,207.3220,206.2203,207.8390,205.7966,207.3220,206.8136,206.7288,207.4153,205.8814,207.4915,206.3983,207.1525,206.9831,206.4831,207.4915,205.8814,207.5000,260.0508,207.5000,206.8983,206.8983,207.4068,206.1356,207.4153,206.3051,207.1525,207.0763,206.8136,207.9237,206.2203,207.6610,206.7288,206.9831,207.2458,206.6441,207.9237,206.0508,207.4068,206.9068,206.8983,207.4153,206.2203,208.1695,206.0508,207.2373,207.0763,206.7288,207.6610,206.2203,207.6610,206.7373" -benchmark intrusive graph dependency handling with N nodes - 10,checking for dependencies,100,1116,2343600,21.7916,21.7274,22.0306,0.5706,0.1153,1.3318,"21.2572,21.3378,21.8495,21.7419,21.8136,21.7330,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8047,21.7330,21.8145,21.7330,21.8047,21.7330,21.7330,21.8136,21.7330,21.8145,21.7330,21.8047,21.7330,21.7330,21.8136,21.7330,21.8145,21.7330,21.7330,21.8136,21.7330,21.8047,21.7330,21.8145,21.7330,21.7330,21.8047,21.7330,21.8136,21.7330,21.7428,21.8136,21.7330,21.8136,21.7330,21.8136,21.7419,21.7419,21.8136,21.7330,21.8047,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.8136,21.7419,21.7419,21.8145,21.7330,21.8047,21.7330,21.8136,21.7330,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.8056,21.7330,21.8136,21.7330,21.7330,21.8136,21.7330,21.9489,21.7330,21.8047,21.7330,21.7330,21.8145,21.7419,21.8047,21.7330,21.8136,21.7330,27.3262,21.2482,21.2482,21.4373,21.2572,21.3289" -benchmark intrusive graph dependency handling with N nodes - 100,creating nodes,100,62,2461400,413.5294,413.3132,414.0171,1.5700,0.8985,3.1886,"412.5323,414.3065,426.2581,412.8387,412.3710,414.7903,413.1613,414.1452,412.5323,414.4677,412.5161,414.6290,412.5323,412.3548,414.3065,412.5161,414.7742,412.8548,414.3065,412.8387,414.4677,413.5000,413.3387,414.2903,412.5323,414.1452,412.3548,414.6290,412.5323,414.6129,413.1613,414.4677,412.5323,414.4516,412.3710,414.1452,412.5161,414.7903,413.3387,413.1613,414.4677,412.5323,414.1452,412.3548,415.1129,412.5323,413.9677,412.5323,412.3710,414.2903,412.3710,413.9839,412.3548,414.4677,412.3710,414.2903,412.3710,412.5323,414.1290,412.3710,414.4677,413.1613,414.4677,412.3710,414.3065,412.6774,412.3710,414.4516,412.5161,414.3065,412.5161,414.3065,412.3710,413.1613,413.6452,412.3710,414.1290,412.3548,414.4677,412.5161,414.4516,413.0161,412.8548,414.4516,412.3710,414.4677,412.5161,414.4677,412.6935,414.2903,412.6774,412.6935,414.1290,412.5161,414.1452,412.5161,414.6290,412.5323,414.3065,412.3548" -benchmark intrusive graph dependency handling with N nodes - 100,creating and adding dependencies,100,6,2561400,4335.4233,4325.8233,4358.8350,72.1486,37.7052,149.8860,"4323.0000,4301.1667,4408.0000,4311.1667,4324.5000,4306.1667,4338.0000,4291.1667,4324.5000,4306.1667,4287.8333,4321.1667,4296.1667,4321.1667,4296.1667,4343.0000,4304.5000,4326.1667,4296.1667,4302.8333,4321.1667,4301.0000,4327.8333,4294.5000,4322.8333,4291.1667,4317.8333,4296.1667,4287.8333,4322.8333,4289.5000,4306.1667,4292.8333,4302.8333,4294.5000,4314.5000,4306.1667,4302.8333,4302.8333,4292.6667,4329.6667,4296.1667,4319.5000,4940.6667,4401.3333,4374.6667,4401.3333,4383.0000,4409.8333,4379.5000,4384.5000,4396.3333,4372.8333,4394.6667,4376.1667,4411.5000,4379.6667,4408.0000,4379.6667,4398.0000,4369.6667,4361.1667,4389.6667,4378.0000,4396.3333,4378.0000,4406.3333,4372.8333,4408.1667,4372.8333,4329.6667,4304.5000,4289.5000,4321.1667,4291.1667,4321.1667,4294.5000,4324.5000,4292.8333,4314.5000,4299.5000,4301.1667,4323.0000,4304.5000,4326.1667,4294.5000,4309.5000,4297.8333,4316.1667,4297.8333,4291.1667,4306.1667,4294.5000,4321.1667,4284.5000,4311.1667,4279.5000,4316.1667,4297.8333,4299.5000" -benchmark intrusive graph dependency handling with N nodes - 100,adding and removing dependencies,100,6,2568600,3751.2950,3738.5117,3811.4733,121.6344,8.9928,289.5968,"3735.1667,3743.5000,3791.8333,3751.8333,3728.3333,3728.5000,3735.0000,3740.1667,3730.0000,3726.6667,3730.1667,3736.6667,3733.5000,3731.6667,3733.5000,3736.6667,3731.8333,3733.3333,3730.0000,3735.1667,3733.3333,3731.8333,3730.0000,3733.5000,3735.0000,3735.1667,3735.0000,3730.0000,3731.8333,3735.0000,3733.5000,3735.0000,3733.5000,3731.6667,3735.1667,3733.3333,3735.1667,3736.8333,3733.3333,3733.5000,3733.3333,3730.1667,3733.3333,3736.8333,3731.6667,3740.0000,3736.8333,3731.6667,3733.5000,3735.0000,3730.1667,3735.0000,3736.6667,3735.1667,3736.6667,3730.1667,3736.6667,3738.5000,3736.8333,3736.6667,3733.5000,3735.0000,3735.1667,3733.3333,3733.3333,3736.8333,3731.6667,3736.8333,3736.6667,3736.8333,3733.3333,3738.3333,3731.8333,3736.6667,4957.5000,3733.3333,3743.5000,3745.1667,3741.6667,3741.8333,3745.1667,3753.3333,3748.5000,3755.1667,3753.5000,3758.3333,3748.5000,3751.8333,3750.1667,3760.0000,3756.6667,3758.5000,3753.5000,3755.1667,3753.3333,3760.0000,3746.8333,3751.8333,3751.8333,3755.0000" -benchmark intrusive graph dependency handling with N nodes - 100,checking for dependencies,100,14,2583000,1844.1350,1839.3550,1863.0057,45.0878,4.0997,107.2223,"1834.7857,1840.5000,1857.6429,1841.9286,1847.6429,1834.0714,1842.6429,1850.5000,1841.2143,1840.5000,1840.5000,1844.7857,1839.0714,1841.9286,1834.7857,1839.0714,1839.0714,1837.6429,1839.7143,1835.4286,1842.6429,1837.6429,1841.9286,1841.2143,1840.5000,1846.9286,1838.3571,1846.2143,1839.0714,1845.5000,1837.6429,1846.2143,1838.3571,1838.3571,1843.3571,1838.3571,1844.7857,1837.6429,1841.2143,1839.7857,1844.0714,1836.8571,1840.4286,1843.3571,1840.5000,1840.5000,1836.2143,1842.6429,1835.5000,1841.9286,1841.2143,1834.7857,1841.2143,1836.8571,1844.7857,1837.5714,1838.3571,1836.9286,1839.7857,1839.0714,1832.6429,1840.5000,1836.9286,1844.7857,1837.5714,1846.2143,1836.8571,1844.7857,1836.8571,1832.6429,1843.3571,1836.9286,1846.2143,1841.2143,2290.6429,1835.5000,1844.7857,1839.7857,1840.5000,1834.0000,1831.2143,1838.3571,1833.3571,1836.9286,1836.8571,1844.7857,1831.2143,1838.3571,1835.5000,1834.0714,1840.5000,1835.4286,1843.3571,1832.6429,1838.3571,1834.7857,1837.6429,1831.8571,1834.7857,1839.0714" -benchmark task handling > without access thread,generating and deleting tasks,100,1,477525400,4920304.4400,4852579.2500,4965170.9000,276404.0339,200472.8706,359103.7784,"5010974.0000,5004531.0000,5123988.0000,4922696.0000,5187888.0000,4954908.0000,5171438.0000,4931434.0000,4961279.0000,4946281.0000,5048555.0000,5026664.0000,4946562.0000,5039728.0000,4929990.0000,5007647.0000,5061129.0000,4899012.0000,4924079.0000,4937344.0000,5090995.0000,5004462.0000,5038105.0000,4949608.0000,4964976.0000,5084443.0000,5017567.0000,4943236.0000,5063433.0000,4968723.0000,4998670.0000,4903540.0000,5065388.0000,4970988.0000,5019439.0000,5024719.0000,5077199.0000,5167209.0000,5000073.0000,5087048.0000,4132389.0000,4053199.0000,3992063.0000,3903415.0000,3952118.0000,3992674.0000,4034503.0000,4052938.0000,4855899.0000,4936633.0000,5005353.0000,4908159.0000,4934328.0000,4832064.0000,4919911.0000,5101476.0000,5102027.0000,4983040.0000,4945048.0000,5084463.0000,4967562.0000,5021694.0000,4896376.0000,4954096.0000,4910263.0000,5065507.0000,4972552.0000,5030360.0000,5079273.0000,5114861.0000,4890305.0000,4976830.0000,4928357.0000,4950850.0000,5022275.0000,5045669.0000,4922938.0000,4989383.0000,4979614.0000,5011605.0000,4932375.0000,5009131.0000,5105373.0000,4922726.0000,4939198.0000,5033967.0000,4937084.0000,4999603.0000,5014410.0000,5019300.0000,4962642.0000,4966249.0000,5016134.0000,4950930.0000,5067230.0000,5004612.0000,4961530.0000,5065378.0000,5102547.0000,5092007.0000" -benchmark task handling > with access thread,generating and deleting tasks with access thread,100,1,1015935100,9986252.7600,9872792.6400,10070732.4500,494531.8116,383546.1367,616836.7304,"10688402.0000,10038651.0000,10462454.0000,10136988.0000,9843622.0000,10158588.0000,10051876.0000,10311689.0000,10496870.0000,9835486.0000,10211649.0000,10238290.0000,10392341.0000,10291511.0000,9843341.0000,10820132.0000,9714346.0000,10171363.0000,9937209.0000,9896722.0000,10035796.0000,9835546.0000,10020126.0000,10272395.0000,10002372.0000,9968328.0000,10086552.0000,10469137.0000,9929624.0000,9930366.0000,9887835.0000,9755745.0000,9841929.0000,10012351.0000,9867968.0000,10257596.0000,10320715.0000,10069480.0000,10395687.0000,10148800.0000,10410105.0000,10241886.0000,10414383.0000,10144883.0000,9221041.0000,8477793.0000,8337859.0000,8428089.0000,9518375.0000,9955003.0000,9932079.0000,9927270.0000,9934564.0000,10326737.0000,10060603.0000,10108283.0000,10103844.0000,10153399.0000,9849573.0000,8550661.0000,8711847.0000,10041927.0000,9989117.0000,10401860.0000,10023492.0000,10042218.0000,9941487.0000,10174699.0000,10302531.0000,9977034.0000,10245303.0000,10335264.0000,10301158.0000,10200367.0000,10207341.0000,10160712.0000,9843000.0000,9962378.0000,10293964.0000,10212711.0000,10397962.0000,10330414.0000,9997153.0000,9827621.0000,9819416.0000,9655445.0000,10321207.0000,10049822.0000,8518100.0000,8663636.0000,8458266.0000,10068268.0000,10280239.0000,10246084.0000,10170932.0000,10369348.0000,10452285.0000,10530583.0000,10262486.0000,10091291.0000" -generating large task graphs,soup topology,100,1,1529231000,15701911.7800,15565403.9200,15794011.7900,564494.2171,413863.9573,720229.4940,"15818434.0000,15861024.0000,15923403.0000,15910879.0000,15869581.0000,15918063.0000,15932880.0000,15890671.0000,15869520.0000,15920969.0000,15896982.0000,15723394.0000,13844122.0000,15595010.0000,15977785.0000,15951436.0000,15924916.0000,15934683.0000,15942900.0000,15916859.0000,15888476.0000,14234021.0000,15167360.0000,14047037.0000,15384472.0000,15941056.0000,15924846.0000,15897864.0000,15904537.0000,15884328.0000,15897915.0000,15962667.0000,15923383.0000,15857378.0000,15895018.0000,15933382.0000,15908674.0000,15918724.0000,15882554.0000,15933211.0000,15863298.0000,15896422.0000,15909686.0000,15537551.0000,13725216.0000,13957938.0000,15909697.0000,15935606.0000,15915417.0000,15905440.0000,15926578.0000,15905790.0000,15882596.0000,15868618.0000,15914727.0000,15895961.0000,15885511.0000,15925045.0000,15993546.0000,13920467.0000,13803456.0000,13934122.0000,15900389.0000,15958729.0000,15918213.0000,15999847.0000,15921670.0000,15856426.0000,15908535.0000,15919735.0000,15912643.0000,15898365.0000,14191972.0000,15123326.0000,15830136.0000,15958870.0000,15922671.0000,15898996.0000,15906421.0000,15907182.0000,15871094.0000,15892103.0000,15911349.0000,15888106.0000,15879108.0000,15934214.0000,15889187.0000,15892575.0000,15899818.0000,15937790.0000,15886883.0000,15833432.0000,15887785.0000,15941197.0000,15848491.0000,15900569.0000,15848760.0000,15920898.0000,15877796.0000,15892795.0000" -generating large task graphs,chain topology,100,1,6785600,68177.3500,67957.9000,68704.8900,1652.4222,730.9429,2850.0432,"67917.0000,67926.0000,76984.0000,68117.0000,68017.0000,67937.0000,68037.0000,68097.0000,68027.0000,68117.0000,68137.0000,67847.0000,68358.0000,67886.0000,67986.0000,67847.0000,68007.0000,67877.0000,67957.0000,67706.0000,68218.0000,67816.0000,67997.0000,67747.0000,67886.0000,68108.0000,68117.0000,67907.0000,68077.0000,67836.0000,67967.0000,67937.0000,68107.0000,67827.0000,68097.0000,67827.0000,67967.0000,68157.0000,67897.0000,79919.0000,68478.0000,67887.0000,68127.0000,67877.0000,67907.0000,67726.0000,68127.0000,67877.0000,67997.0000,68147.0000,68097.0000,67857.0000,67967.0000,67796.0000,68097.0000,67866.0000,68228.0000,67856.0000,67906.0000,67737.0000,67937.0000,67766.0000,67967.0000,67767.0000,67966.0000,67546.0000,68097.0000,67576.0000,67726.0000,67737.0000,67686.0000,67626.0000,67666.0000,67516.0000,68047.0000,67486.0000,67827.0000,67566.0000,67836.0000,67627.0000,67896.0000,67707.0000,67676.0000,67596.0000,68128.0000,67866.0000,68057.0000,67607.0000,67756.0000,67687.0000,67886.0000,67767.0000,68037.0000,67606.0000,68047.0000,67616.0000,67917.0000,67657.0000,74980.0000,67526.0000" -generating large task graphs,expanding tree topology,100,1,14083900,127204.2000,126853.2000,128044.7100,2592.7744,905.6171,4564.7714,"126487.0000,126017.0000,132740.0000,127580.0000,126688.0000,127289.0000,126949.0000,127329.0000,126478.0000,126277.0000,126829.0000,126367.0000,126868.0000,126678.0000,126618.0000,126518.0000,126859.0000,127149.0000,126377.0000,126298.0000,126908.0000,126428.0000,126598.0000,127159.0000,126057.0000,126378.0000,126297.0000,126688.0000,126869.0000,126968.0000,144602.0000,126417.0000,126548.0000,126849.0000,126117.0000,127399.0000,126578.0000,126699.0000,126778.0000,126718.0000,127089.0000,127229.0000,126498.0000,126298.0000,126688.0000,126858.0000,126278.0000,126427.0000,127450.0000,125746.0000,126618.0000,126959.0000,126267.0000,126798.0000,126838.0000,127440.0000,127299.0000,126218.0000,126888.0000,126678.0000,126999.0000,130926.0000,126979.0000,127249.0000,127320.0000,126427.0000,126809.0000,127339.0000,126909.0000,126898.0000,127119.0000,127009.0000,127039.0000,127019.0000,126578.0000,126668.0000,127199.0000,126237.0000,126739.0000,126588.0000,127179.0000,126037.0000,127580.0000,126537.0000,127419.0000,126448.0000,126878.0000,126759.0000,126317.0000,126798.0000,126738.0000,126387.0000,125957.0000,144252.0000,127279.0000,126638.0000,126498.0000,126908.0000,127008.0000,126739.0000" -generating large task graphs,contracting tree topology,100,1,17992400,181789.4500,181576.9100,182176.0100,1412.5586,899.9837,2199.2888,"181852.0000,181492.0000,185078.0000,181192.0000,183215.0000,181562.0000,180971.0000,186421.0000,181492.0000,181191.0000,181523.0000,181642.0000,181211.0000,181062.0000,181612.0000,181191.0000,181402.0000,181623.0000,181652.0000,181332.0000,181973.0000,181562.0000,181863.0000,181402.0000,181722.0000,181332.0000,181652.0000,181452.0000,181973.0000,185510.0000,182143.0000,181372.0000,181472.0000,180971.0000,181442.0000,181262.0000,181392.0000,181582.0000,180911.0000,181221.0000,181593.0000,180910.0000,181041.0000,181442.0000,181472.0000,180961.0000,181281.0000,180991.0000,181632.0000,180821.0000,180219.0000,188406.0000,180921.0000,181451.0000,182403.0000,181302.0000,181883.0000,181402.0000,181572.0000,181171.0000,181643.0000,181562.0000,181492.0000,181542.0000,181222.0000,181101.0000,181783.0000,181522.0000,180921.0000,181301.0000,181522.0000,181261.0000,181803.0000,185409.0000,181733.0000,181382.0000,181752.0000,181102.0000,181612.0000,181512.0000,182093.0000,181082.0000,181492.0000,181592.0000,181512.0000,181232.0000,181712.0000,181192.0000,181772.0000,181452.0000,181442.0000,181362.0000,181722.0000,180940.0000,181161.0000,190299.0000,182113.0000,181722.0000,182384.0000,181693.0000" -generating large task graphs,wave_sim topology,100,1,64928300,653178.8100,652530.8200,654526.3100,4574.4307,2721.0821,8863.8937,"652083.0000,651874.0000,654729.0000,651382.0000,653597.0000,652545.0000,659067.0000,652825.0000,652815.0000,651683.0000,651733.0000,651543.0000,658816.0000,650631.0000,652574.0000,654048.0000,651763.0000,651262.0000,662454.0000,651252.0000,652905.0000,654649.0000,653176.0000,652254.0000,658255.0000,652395.0000,653466.0000,653156.0000,652705.0000,651883.0000,653266.0000,688303.0000,652164.0000,652324.0000,651813.0000,650802.0000,652665.0000,661571.0000,652315.0000,651232.0000,652184.0000,652184.0000,651793.0000,655741.0000,651953.0000,651723.0000,652194.0000,652335.0000,652765.0000,659087.0000,650811.0000,653026.0000,650571.0000,650281.0000,650320.0000,656122.0000,651182.0000,650451.0000,649929.0000,648958.0000,650791.0000,656842.0000,651784.0000,650100.0000,650691.0000,650060.0000,649208.0000,659989.0000,649980.0000,649468.0000,650311.0000,648627.0000,650411.0000,655229.0000,650801.0000,649849.0000,650140.0000,650671.0000,653226.0000,651382.0000,655731.0000,652304.0000,653356.0000,653166.0000,652705.0000,650881.0000,664236.0000,651894.0000,652604.0000,651662.0000,651723.0000,652464.0000,659348.0000,651262.0000,652935.0000,651633.0000,652335.0000,652103.0000,658797.0000,653597.0000" -generating large task graphs,jacobi topology,100,1,22071200,221065.2300,220836.2300,221487.2100,1539.4516,948.1287,2401.1975,"220365.0000,220486.0000,222480.0000,221167.0000,225686.0000,220796.0000,221077.0000,221007.0000,221017.0000,220677.0000,220676.0000,220876.0000,220926.0000,220837.0000,220927.0000,220926.0000,220446.0000,220186.0000,220115.0000,220085.0000,220165.0000,221338.0000,230134.0000,220797.0000,221427.0000,220486.0000,220707.0000,221087.0000,221147.0000,220877.0000,221307.0000,221147.0000,220697.0000,220996.0000,220636.0000,220906.0000,220996.0000,220787.0000,220516.0000,221157.0000,224313.0000,220546.0000,221077.0000,220967.0000,220336.0000,220656.0000,219915.0000,220776.0000,221228.0000,220456.0000,220135.0000,220225.0000,220496.0000,220346.0000,220556.0000,220556.0000,220065.0000,220045.0000,225365.0000,220205.0000,220806.0000,220345.0000,220216.0000,220325.0000,220566.0000,220506.0000,221147.0000,220515.0000,220836.0000,220997.0000,220957.0000,220967.0000,221017.0000,221177.0000,221107.0000,220796.0000,229172.0000,220566.0000,220867.0000,220987.0000,220536.0000,220466.0000,220135.0000,220917.0000,220927.0000,220546.0000,220456.0000,220506.0000,220275.0000,220546.0000,220366.0000,220736.0000,220345.0000,220807.0000,224674.0000,220385.0000,220986.0000,220787.0000,221007.0000,220916.0000" -generating large command graphs for N nodes - 1,soup topology,100,1,2730586900,27651883.3800,27467491.9700,27786690.5000,799614.8705,624191.3124,989418.6674,"25777565.0000,27991442.0000,27989928.0000,27872527.0000,27399349.0000,25675603.0000,28135163.0000,27945986.0000,27995319.0000,27926508.0000,27886102.0000,25260116.0000,26274448.0000,27249976.0000,27952428.0000,27826669.0000,28025255.0000,28041606.0000,27899828.0000,26970767.0000,25057622.0000,27847428.0000,26415585.0000,24893140.0000,27880852.0000,28046847.0000,27971925.0000,27909515.0000,27830737.0000,27855694.0000,28075771.0000,28040004.0000,27957487.0000,27916840.0000,27944852.0000,27877546.0000,27875482.0000,28046916.0000,27913002.0000,27704587.0000,27914896.0000,27974609.0000,27863339.0000,28138821.0000,28165891.0000,27424768.0000,26129102.0000,28161272.0000,27993706.0000,27999857.0000,28176141.0000,28045643.0000,28060442.0000,28199847.0000,28159028.0000,28204315.0000,28090689.0000,28152477.0000,28196259.0000,28008214.0000,27953009.0000,27998584.0000,28128682.0000,28075691.0000,28185959.0000,28009135.0000,28160242.0000,25359363.0000,27660695.0000,27974179.0000,28104916.0000,27872106.0000,27767667.0000,27741697.0000,27543192.0000,27998404.0000,27929723.0000,27848851.0000,28017591.0000,28030564.0000,27940705.0000,28012091.0000,27950283.0000,28049722.0000,25507034.0000,28070000.0000,28008274.0000,28002041.0000,27854391.0000,27890610.0000,25482346.0000,28027899.0000,26002452.0000,26059851.0000,27957296.0000,27954722.0000,27865593.0000,27977304.0000,28008604.0000,27989137.0000" -generating large command graphs for N nodes - 1,chain topology,100,1,27522200,278151.7800,277808.8600,278677.1900,2135.7631,1503.9491,2982.6969,"277404.0000,287402.0000,284017.0000,279017.0000,278315.0000,278466.0000,278536.0000,279017.0000,278506.0000,278937.0000,278085.0000,278496.0000,277824.0000,278396.0000,277825.0000,283024.0000,278436.0000,278676.0000,277584.0000,279157.0000,278816.0000,278336.0000,278245.0000,278947.0000,278075.0000,277855.0000,278275.0000,277473.0000,277163.0000,281441.0000,277474.0000,277164.0000,276562.0000,277223.0000,277063.0000,278025.0000,276382.0000,277073.0000,277013.0000,277584.0000,276773.0000,277624.0000,276592.0000,286060.0000,277203.0000,278596.0000,277084.0000,276993.0000,277023.0000,277043.0000,276793.0000,277744.0000,277644.0000,277002.0000,276542.0000,277133.0000,277384.0000,278506.0000,282133.0000,277293.0000,277204.0000,277293.0000,276401.0000,278465.0000,277364.0000,277704.0000,277093.0000,277774.0000,277164.0000,277704.0000,276813.0000,277664.0000,288375.0000,278526.0000,277093.0000,277474.0000,277204.0000,277304.0000,277434.0000,276582.0000,277264.0000,276692.0000,276763.0000,277173.0000,276342.0000,277234.0000,276612.0000,284738.0000,277494.0000,277805.0000,276121.0000,277354.0000,277414.0000,277965.0000,277464.0000,277353.0000,278306.0000,278255.0000,277474.0000,278246.0000" -generating large command graphs for N nodes - 1,expanding tree topology,100,1,44648800,446435.6300,445853.8100,447448.2200,3834.3567,2588.8374,6230.7904,"445893.0000,444851.0000,470860.0000,447716.0000,446564.0000,445782.0000,446173.0000,446214.0000,459439.0000,444711.0000,445482.0000,445783.0000,444841.0000,445502.0000,445802.0000,444600.0000,445653.0000,452195.0000,445532.0000,444611.0000,444841.0000,444621.0000,445883.0000,444571.0000,446063.0000,445352.0000,450802.0000,444891.0000,446635.0000,445131.0000,444912.0000,445282.0000,445642.0000,444982.0000,444430.0000,459519.0000,446164.0000,445252.0000,445833.0000,444881.0000,445572.0000,444710.0000,443238.0000,444249.0000,452846.0000,445212.0000,445853.0000,445823.0000,445833.0000,445362.0000,445462.0000,445483.0000,445442.0000,451203.0000,444801.0000,444791.0000,445372.0000,444790.0000,444530.0000,445462.0000,445533.0000,444240.0000,456553.0000,444992.0000,444851.0000,444771.0000,444931.0000,444771.0000,445693.0000,444470.0000,444219.0000,450622.0000,446484.0000,444540.0000,445753.0000,446294.0000,446434.0000,444952.0000,446424.0000,445121.0000,451233.0000,444801.0000,445442.0000,445162.0000,445362.0000,444731.0000,444551.0000,444580.0000,444100.0000,455572.0000,445592.0000,445954.0000,444370.0000,444541.0000,444049.0000,444801.0000,445662.0000,445072.0000,451193.0000,445222.0000" -generating large command graphs for N nodes - 1,contracting tree topology,100,1,49329700,493044.9500,492531.9000,493749.3800,3039.2906,2350.9561,3930.6385,"490988.0000,491830.0000,497471.0000,492331.0000,492451.0000,500817.0000,491679.0000,492210.0000,492821.0000,491128.0000,491509.0000,491710.0000,491910.0000,498122.0000,491048.0000,491830.0000,490838.0000,490698.0000,491830.0000,490748.0000,492150.0000,502050.0000,494966.0000,493293.0000,494656.0000,494044.0000,492601.0000,492852.0000,491730.0000,492571.0000,498432.0000,494055.0000,492561.0000,494315.0000,492872.0000,493864.0000,493313.0000,493684.0000,498854.0000,493202.0000,491569.0000,491750.0000,492462.0000,493052.0000,492532.0000,492882.0000,504344.0000,493944.0000,493493.0000,492892.0000,493854.0000,493663.0000,493373.0000,491319.0000,497811.0000,491669.0000,491559.0000,491460.0000,491980.0000,491750.0000,493253.0000,492001.0000,504464.0000,492151.0000,490638.0000,492251.0000,491139.0000,490577.0000,489355.0000,489586.0000,495207.0000,491499.0000,490558.0000,491229.0000,490167.0000,489055.0000,489396.0000,489646.0000,496539.0000,491510.0000,491419.0000,490368.0000,490868.0000,490538.0000,492281.0000,492381.0000,504494.0000,492402.0000,492030.0000,492041.0000,492591.0000,490918.0000,492702.0000,492341.0000,498563.0000,491750.0000,492211.0000,492251.0000,492472.0000,492261.0000" -generating large command graphs for N nodes - 1,wave_sim topology,100,1,221465400,2228973.0800,2219224.0900,2231689.3000,23571.5999,6212.1525,54491.8263,"2212721.0000,2003555.0000,2235324.0000,2226487.0000,2226677.0000,2237869.0000,2233020.0000,2220656.0000,2231196.0000,2223591.0000,2225726.0000,2220907.0000,2239472.0000,2227068.0000,2232810.0000,2227941.0000,2229132.0000,2236336.0000,2224503.0000,2232548.0000,2222099.0000,2236816.0000,2221248.0000,2226227.0000,2237438.0000,2227860.0000,2237919.0000,2229933.0000,2241195.0000,2230996.0000,2243419.0000,2238430.0000,2236827.0000,2255242.0000,2238289.0000,2232228.0000,2225275.0000,2229463.0000,2227269.0000,2235334.0000,2232067.0000,2224864.0000,2234152.0000,2227709.0000,2241897.0000,2225275.0000,2235013.0000,2230736.0000,2236245.0000,2234221.0000,2224623.0000,2227730.0000,2226357.0000,2236587.0000,2223080.0000,2234302.0000,2222079.0000,2234803.0000,2233029.0000,2226727.0000,2231678.0000,2221097.0000,2237839.0000,2225686.0000,2231958.0000,2220736.0000,2238931.0000,2231958.0000,2225275.0000,2239111.0000,2223111.0000,2225566.0000,2222900.0000,2236466.0000,2224924.0000,2233490.0000,2234793.0000,2226196.0000,2237918.0000,2233189.0000,2233640.0000,2231727.0000,2239231.0000,2235575.0000,2230886.0000,2239472.0000,2223021.0000,2235585.0000,2228741.0000,2240173.0000,2228661.0000,2237077.0000,2235995.0000,2228170.0000,2238651.0000,2226868.0000,2235664.0000,2226216.0000,2239282.0000,2227309.0000" -generating large command graphs for N nodes - 1,jacobi topology,100,1,82542800,835088.7500,834374.4300,835924.2400,3966.5539,3407.2090,4617.2472,"833046.0000,832195.0000,840340.0000,843477.0000,832596.0000,835271.0000,834589.0000,829630.0000,838767.0000,831874.0000,829761.0000,835982.0000,830762.0000,844448.0000,834560.0000,832986.0000,829941.0000,831304.0000,838827.0000,834449.0000,832686.0000,833047.0000,841903.0000,832465.0000,831784.0000,833086.0000,832646.0000,842745.0000,830281.0000,830893.0000,834560.0000,830892.0000,840060.0000,835261.0000,832115.0000,830061.0000,831012.0000,843506.0000,835331.0000,835572.0000,832756.0000,833708.0000,842074.0000,833708.0000,833808.0000,833007.0000,843216.0000,834460.0000,833788.0000,834279.0000,834700.0000,843907.0000,834400.0000,834399.0000,834499.0000,833116.0000,842073.0000,835811.0000,834409.0000,836433.0000,836093.0000,842384.0000,835412.0000,834910.0000,834420.0000,833498.0000,844458.0000,834389.0000,832185.0000,834529.0000,836964.0000,832655.0000,832435.0000,831815.0000,831523.0000,838406.0000,833868.0000,834089.0000,833587.0000,833537.0000,847124.0000,836763.0000,834008.0000,833087.0000,835892.0000,839589.0000,836363.0000,831443.0000,829420.0000,832917.0000,841723.0000,830071.0000,830572.0000,836413.0000,838598.0000,832385.0000,832656.0000,832406.0000,832926.0000,840100.0000" -generating large command graphs for N nodes - 4,soup topology,100,1,6590492800,65577388.0900,65298067.3500,65753717.6700,1119938.0813,782242.9666,1527617.6770,"65821638.0000,65858448.0000,65950513.0000,65403987.0000,61466526.0000,65945563.0000,66201538.0000,65801540.0000,65770662.0000,60721864.0000,65940574.0000,63336690.0000,65747928.0000,65893704.0000,65946264.0000,66064197.0000,66037166.0000,66119462.0000,66098653.0000,66136204.0000,65928480.0000,66031886.0000,65972444.0000,65721008.0000,64932373.0000,62119824.0000,65950974.0000,65832148.0000,65627340.0000,66005727.0000,65884628.0000,65924714.0000,60720241.0000,62839627.0000,64908517.0000,66416185.0000,65958878.0000,66133960.0000,65971782.0000,65653720.0000,66138168.0000,65765732.0000,65877825.0000,65863417.0000,65825034.0000,66393371.0000,66074227.0000,65812120.0000,66033159.0000,66105456.0000,66055662.0000,66235252.0000,65349062.0000,65813943.0000,65778225.0000,65736246.0000,65991039.0000,65797994.0000,65727720.0000,65939662.0000,65911058.0000,65935333.0000,65955903.0000,65258691.0000,65899155.0000,65899335.0000,65886712.0000,66276530.0000,66036295.0000,65537760.0000,65757216.0000,65785901.0000,63510989.0000,64174707.0000,65832458.0000,66202319.0000,65760211.0000,65847636.0000,66011007.0000,65966593.0000,66104124.0000,65957335.0000,66106688.0000,66094575.0000,66057194.0000,65824082.0000,65896991.0000,66058417.0000,65833701.0000,66061192.0000,66096949.0000,66137417.0000,65951795.0000,65910987.0000,61611470.0000,65991550.0000,65856083.0000,65919604.0000,65955983.0000,65755972.0000" -generating large command graphs for N nodes - 4,chain topology,100,1,349841700,3504745.2200,3502985.2700,3507122.2100,10336.7890,7931.8991,14040.8684,"3503397.0000,3496173.0000,3546829.0000,3506042.0000,3491905.0000,3490573.0000,3524897.0000,3505461.0000,3502144.0000,3500972.0000,3497135.0000,3503777.0000,3509048.0000,3498918.0000,3499158.0000,3490673.0000,3495131.0000,3512715.0000,3501563.0000,3492706.0000,3495993.0000,3493228.0000,3506483.0000,3501093.0000,3503517.0000,3501604.0000,3491534.0000,3524727.0000,3500211.0000,3494240.0000,3493498.0000,3510640.0000,3502105.0000,3508146.0000,3506924.0000,3503928.0000,3497455.0000,3492656.0000,3500341.0000,3501313.0000,3504359.0000,3500261.0000,3506563.0000,3501303.0000,3504599.0000,3495471.0000,3500712.0000,3500381.0000,3504870.0000,3510420.0000,3508407.0000,3509979.0000,3518616.0000,3497366.0000,3505671.0000,3504248.0000,3519939.0000,3510109.0000,3551267.0000,3542591.0000,3512013.0000,3504780.0000,3515139.0000,3505380.0000,3514609.0000,3495532.0000,3515690.0000,3508347.0000,3507114.0000,3499099.0000,3509699.0000,3504870.0000,3508276.0000,3507164.0000,3501874.0000,3496253.0000,3512735.0000,3500262.0000,3494750.0000,3508456.0000,3512143.0000,3503026.0000,3504619.0000,3507725.0000,3505301.0000,3501814.0000,3491975.0000,3513055.0000,3501563.0000,3497225.0000,3502355.0000,3500832.0000,3501163.0000,3492476.0000,3492346.0000,3509057.0000,3502705.0000,3514859.0000,3502245.0000,3500011.0000" -generating large command graphs for N nodes - 4,expanding tree topology,100,1,977889000,9744932.1300,9692186.5600,9772594.3800,185372.4380,103549.9084,283543.4408,"9774341.0000,9773077.0000,9781293.0000,9787885.0000,9786063.0000,9767958.0000,9799498.0000,9786183.0000,9781704.0000,9766255.0000,9771164.0000,9777156.0000,9045449.0000,8746432.0000,8753436.0000,8844949.0000,9804728.0000,9815359.0000,9810969.0000,9809406.0000,9788457.0000,9769271.0000,9786864.0000,9770172.0000,9783438.0000,9779239.0000,9782836.0000,9782064.0000,9784469.0000,9780141.0000,9784150.0000,9779891.0000,9760333.0000,9791312.0000,9781434.0000,9805920.0000,9778848.0000,9772837.0000,9770924.0000,9776694.0000,9782004.0000,9778217.0000,9789639.0000,9766295.0000,9767057.0000,9754473.0000,9778128.0000,9769420.0000,9781884.0000,9770844.0000,9769491.0000,9778177.0000,9794338.0000,9794748.0000,9795520.0000,9792915.0000,9770723.0000,9776885.0000,9789389.0000,9780823.0000,9781454.0000,9780472.0000,9804016.0000,9799007.0000,9772647.0000,9765193.0000,9771505.0000,9759893.0000,9837730.0000,9814596.0000,9757558.0000,9783928.0000,9767166.0000,9812131.0000,9755134.0000,9773238.0000,9790079.0000,9770021.0000,9812883.0000,9768279.0000,9770893.0000,9783266.0000,9797243.0000,9793256.0000,9784589.0000,9779861.0000,9778267.0000,9792184.0000,9796242.0000,9789349.0000,9768018.0000,9786023.0000,9799167.0000,9775382.0000,9774340.0000,9776313.0000,9811109.0000,9753550.0000,9785211.0000,9748451.0000" -generating large command graphs for N nodes - 4,contracting tree topology,100,1,384494400,3908198.7900,3906694.8400,3909908.0000,8144.5437,6843.6924,10172.5172,"3912272.0000,3907783.0000,3926418.0000,3903415.0000,3911139.0000,3920177.0000,3899127.0000,3905259.0000,3911080.0000,3934173.0000,3914536.0000,3907312.0000,3907383.0000,3905379.0000,3894869.0000,3915027.0000,3911340.0000,3914957.0000,3897934.0000,3909847.0000,3907693.0000,3922682.0000,3908134.0000,3919485.0000,3910037.0000,3910779.0000,3916911.0000,3909316.0000,3908795.0000,3909937.0000,3911530.0000,3910348.0000,3907052.0000,3895470.0000,3895109.0000,3912653.0000,3902954.0000,3913594.0000,3906069.0000,3902733.0000,3905179.0000,3905809.0000,3920146.0000,3926679.0000,3918483.0000,3901742.0000,3904998.0000,3911490.0000,3909286.0000,3920778.0000,3939173.0000,3907573.0000,3905219.0000,3897504.0000,3916490.0000,3907623.0000,3906781.0000,3920627.0000,3904938.0000,3912122.0000,3900649.0000,3903344.0000,3903214.0000,3900570.0000,3913404.0000,3910088.0000,3907182.0000,3907102.0000,3901602.0000,3913294.0000,3910618.0000,3899307.0000,3910037.0000,3902653.0000,3906170.0000,3906560.0000,3898946.0000,3909176.0000,3900750.0000,3903876.0000,3911250.0000,3895490.0000,3889108.0000,3902063.0000,3897754.0000,3911030.0000,3902363.0000,3907513.0000,3906350.0000,3901451.0000,3909066.0000,3910558.0000,3892644.0000,3910148.0000,3911110.0000,3896432.0000,3911901.0000,3907733.0000,3906000.0000,3898025.0000" -generating large command graphs for N nodes - 4,wave_sim topology,100,1,1588339200,15832766.4800,15757082.9200,15865716.0100,240437.1519,120007.0972,434642.7955,"15862427.0000,15887554.0000,15875030.0000,15860634.0000,15862266.0000,15904055.0000,15868779.0000,15857488.0000,15869420.0000,15883126.0000,15853190.0000,15860232.0000,15883787.0000,15882595.0000,15886713.0000,15889709.0000,15930525.0000,15882034.0000,15875301.0000,15909105.0000,15894888.0000,15884919.0000,15890319.0000,15875833.0000,15865192.0000,15893556.0000,15869871.0000,15889318.0000,15861545.0000,15886693.0000,15931959.0000,15905949.0000,15881343.0000,15895599.0000,15873598.0000,15877375.0000,15878718.0000,15340558.0000,14065261.0000,14690887.0000,15963288.0000,15909296.0000,15852258.0000,15891762.0000,15888717.0000,15892744.0000,15868177.0000,15846056.0000,15878969.0000,15883487.0000,15866805.0000,15903304.0000,15869540.0000,15862096.0000,15880481.0000,15900419.0000,15812091.0000,15860103.0000,15851306.0000,15882434.0000,15874349.0000,15885631.0000,15874540.0000,15855814.0000,15897944.0000,15901521.0000,15870251.0000,15915728.0000,15873668.0000,15879118.0000,15901381.0000,15888195.0000,15883346.0000,15867427.0000,15790931.0000,14902869.0000,15862246.0000,15876723.0000,15885430.0000,15888977.0000,15882395.0000,15902463.0000,15884680.0000,15869530.0000,15841407.0000,15864962.0000,15880531.0000,15875632.0000,15872967.0000,15884038.0000,15833232.0000,15845144.0000,15852578.0000,15872486.0000,15866545.0000,15902843.0000,15891071.0000,15855293.0000,15844703.0000,15877375.0000" -generating large command graphs for N nodes - 4,jacobi topology,100,1,549922200,5447579.9700,5400098.3900,5482046.3500,205399.5164,160253.3866,249092.2283,"5170716.0000,5540948.0000,5564392.0000,5539535.0000,5518154.0000,5537220.0000,5576315.0000,5547180.0000,5517694.0000,5523014.0000,5543232.0000,5512985.0000,5065036.0000,4879625.0000,4877821.0000,4876498.0000,4872220.0000,5413035.0000,5518005.0000,5526932.0000,5533915.0000,5525619.0000,5539314.0000,5520328.0000,5197266.0000,4908990.0000,5505992.0000,5526390.0000,5546037.0000,5527363.0000,5528875.0000,5546088.0000,5520329.0000,5545096.0000,5585452.0000,5535377.0000,5545747.0000,5545998.0000,5530809.0000,5535428.0000,5528755.0000,5536750.0000,5561737.0000,5533914.0000,5536861.0000,5522002.0000,5512414.0000,5524597.0000,5513126.0000,5525378.0000,5518616.0000,5522062.0000,5530247.0000,5523085.0000,5534115.0000,5526330.0000,5516010.0000,5530849.0000,5522594.0000,5536850.0000,5551007.0000,5525780.0000,5536870.0000,5519447.0000,5520168.0000,5530398.0000,5521601.0000,5517594.0000,5532221.0000,5513466.0000,5527001.0000,5504740.0000,5519127.0000,5524747.0000,5515620.0000,5526862.0000,5518756.0000,5539455.0000,5517444.0000,5535938.0000,5526420.0000,5522383.0000,5517895.0000,5528113.0000,5530418.0000,5529767.0000,5530358.0000,5516361.0000,5536430.0000,5515239.0000,5524016.0000,5536128.0000,5532882.0000,5534536.0000,4946802.0000,4904972.0000,4898691.0000,4889704.0000,4910483.0000,4900895.0000" -generating large command graphs for N nodes - 16,soup topology,100,1,22341337900,223837319.4600,223529433.1400,224059751.2700,1331417.8420,1043582.7009,1642282.6050,"224434007.0000,219083488.0000,221202267.0000,223520760.0000,223448052.0000,224489837.0000,224498724.0000,223659674.0000,223511614.0000,223979651.0000,221025351.0000,223886022.0000,223949151.0000,223551459.0000,220544620.0000,224477553.0000,224547106.0000,224552044.0000,224476300.0000,224470991.0000,223992695.0000,224595767.0000,224174108.0000,221639045.0000,224191561.0000,223915568.0000,220148949.0000,224800705.0000,224088105.0000,224437847.0000,224800044.0000,224313923.0000,224165701.0000,224223322.0000,224623509.0000,224254630.0000,224574596.0000,224443839.0000,223637010.0000,223914094.0000,224770797.0000,223645003.0000,224476801.0000,220649498.0000,224587030.0000,224926863.0000,224249249.0000,220849136.0000,223875801.0000,221565253.0000,223990478.0000,224297131.0000,224254899.0000,224574395.0000,224604612.0000,224239070.0000,224925540.0000,224158517.0000,224115474.0000,224017310.0000,223910847.0000,221052170.0000,224181280.0000,224322287.0000,224819268.0000,224577540.0000,224522716.0000,224339931.0000,224327656.0000,224524761.0000,224220894.0000,224695103.0000,223808543.0000,224808798.0000,224684043.0000,224520612.0000,224181990.0000,224389735.0000,224449316.0000,219935574.0000,224879663.0000,224142065.0000,224315052.0000,224673451.0000,225279600.0000,224584643.0000,224635610.0000,223983453.0000,219725215.0000,224277340.0000,224422896.0000,224192249.0000,224292099.0000,224596395.0000,224825979.0000,224484552.0000,224175367.0000,220032857.0000,224387629.0000,224536221.0000" -generating large command graphs for N nodes - 16,chain topology,100,1,43552853000,438905484.0900,438218015.2600,439448138.0600,3118030.6465,2564728.5599,3915794.0883,"441010740.0000,440254617.0000,440292546.0000,440627610.0000,440655422.0000,440461335.0000,435413729.0000,439549717.0000,439955326.0000,436522289.0000,441056962.0000,440450413.0000,440668736.0000,440176294.0000,434836133.0000,434388266.0000,439888627.0000,439530990.0000,438576630.0000,441180555.0000,439900850.0000,440339641.0000,440538488.0000,439969991.0000,433869200.0000,441919575.0000,433805830.0000,441988585.0000,432288484.0000,438655649.0000,433683006.0000,436971758.0000,440598490.0000,438916302.0000,440015025.0000,435199439.0000,440558594.0000,439604316.0000,440667750.0000,441126268.0000,430402378.0000,434957960.0000,438113660.0000,437076204.0000,440755495.0000,440614368.0000,441550962.0000,440681946.0000,441077985.0000,432697265.0000,441417348.0000,440355647.0000,438739354.0000,440765574.0000,440213036.0000,440698386.0000,440236831.0000,440338674.0000,432294631.0000,440014819.0000,440597024.0000,440012725.0000,440127222.0000,440971612.0000,440753819.0000,440483417.0000,441082572.0000,426542249.0000,433975956.0000,440930803.0000,436254011.0000,441237083.0000,441037456.0000,440581301.0000,439953591.0000,439777958.0000,432052819.0000,440673906.0000,440379607.0000,438751543.0000,441428616.0000,441433855.0000,441486976.0000,440275780.0000,440513129.0000,436781319.0000,442654868.0000,441701060.0000,439901941.0000,440676769.0000,440523338.0000,440078144.0000,440344549.0000,440273394.0000,437511431.0000,435190202.0000,428632395.0000,434687279.0000,440297890.0000,440862099.0000" -generating large command graphs for N nodes - 16,expanding tree topology,100,1,71917759100,717760331.1400,716858586.9700,718582342.6800,4365997.0781,3846653.6139,5132937.1918,"718619832.0000,716085651.0000,722004094.0000,719027332.0000,720798950.0000,720869522.0000,720377600.0000,722300293.0000,718389021.0000,721927956.0000,722054356.0000,721002061.0000,718715107.0000,716707834.0000,717323940.0000,721893659.0000,719742522.0000,721159026.0000,718277756.0000,713742623.0000,725017807.0000,720835451.0000,722588553.0000,723949481.0000,721328545.0000,715528503.0000,721730005.0000,721700889.0000,723008225.0000,718161311.0000,712812175.0000,720493519.0000,721762584.0000,720952729.0000,721031458.0000,720930255.0000,717027280.0000,724798013.0000,720507142.0000,724512642.0000,720224717.0000,715382261.0000,712045186.0000,721522955.0000,715502578.0000,724481141.0000,713703658.0000,715727352.0000,719441860.0000,720677431.0000,717369622.0000,715236681.0000,719501892.0000,709417533.0000,715724373.0000,723071265.0000,722294322.0000,714476058.0000,716438695.0000,711300238.0000,715712739.0000,713898311.0000,709488314.0000,721410674.0000,718756115.0000,719368244.0000,713777099.0000,722228332.0000,722500458.0000,718456265.0000,711400014.0000,721536020.0000,721195294.0000,715589270.0000,704484478.0000,717669421.0000,704949368.0000,716275880.0000,720239951.0000,711156789.0000,715054063.0000,715452508.0000,712258376.0000,715822038.0000,715155985.0000,715855170.0000,714129901.0000,717076162.0000,711023524.0000,715797719.0000,719462653.0000,717349960.0000,715108652.0000,711862782.0000,724759659.0000,715864023.0000,709941670.0000,708560523.0000,720179730.0000,711989460.0000" -generating large command graphs for N nodes - 16,contracting tree topology,100,1,14032628700,139656299.5800,139283337.0600,139886817.0300,1470612.2497,1035566.7647,2064082.6505,"140443535.0000,139933930.0000,140077994.0000,140008472.0000,138792559.0000,141068041.0000,139988144.0000,140676788.0000,140235893.0000,139787103.0000,139888766.0000,140081892.0000,140670497.0000,139806370.0000,140041074.0000,139949762.0000,139758168.0000,139846977.0000,139816068.0000,139966302.0000,140128430.0000,140176922.0000,140104805.0000,139946635.0000,139828320.0000,132154550.0000,140806545.0000,139726548.0000,140027869.0000,139888004.0000,134484676.0000,139930624.0000,140168456.0000,134589113.0000,140107800.0000,140099195.0000,140281910.0000,140363956.0000,140127658.0000,140092621.0000,140431363.0000,140430422.0000,139900077.0000,139988674.0000,139910987.0000,140037838.0000,139829052.0000,140459165.0000,139845122.0000,139892753.0000,139832318.0000,140151804.0000,140293903.0000,135001705.0000,136056464.0000,140511044.0000,139759099.0000,134686938.0000,140191228.0000,140134500.0000,140390837.0000,136395165.0000,138807366.0000,139959359.0000,139881562.0000,140015876.0000,140455539.0000,140602317.0000,140425301.0000,140907505.0000,140133118.0000,139961112.0000,139887312.0000,139912469.0000,140407156.0000,140118581.0000,140117568.0000,139863847.0000,139991609.0000,140039450.0000,139920284.0000,140036395.0000,136467652.0000,140081490.0000,140744276.0000,140090327.0000,139976410.0000,140050661.0000,140093823.0000,140025914.0000,138696185.0000,139825895.0000,139919723.0000,139922178.0000,140242144.0000,139982302.0000,139764940.0000,139789787.0000,140621934.0000,139887161.0000" -generating large command graphs for N nodes - 16,wave_sim topology,100,1,13661736700,136091353.7200,135735072.4300,136307005.7100,1382756.0165,937846.4000,1933841.1917,"136568591.0000,136669734.0000,136472551.0000,136563614.0000,136530791.0000,136370397.0000,132016126.0000,134498270.0000,136498650.0000,136555158.0000,136682720.0000,136760757.0000,136607187.0000,136594111.0000,135127042.0000,136492870.0000,136544357.0000,136377000.0000,136396927.0000,136519911.0000,136512567.0000,136518969.0000,136461380.0000,136459617.0000,136459787.0000,136517786.0000,136554115.0000,136718997.0000,136474875.0000,136464716.0000,136568773.0000,136386077.0000,136399012.0000,136424409.0000,136221786.0000,131644252.0000,129569000.0000,136648224.0000,136402348.0000,131755162.0000,136411966.0000,136567571.0000,136547964.0000,134601906.0000,133924563.0000,136349047.0000,136610362.0000,136655848.0000,136586978.0000,136438566.0000,136424910.0000,136450920.0000,136519700.0000,136597638.0000,136476338.0000,136300013.0000,136310844.0000,136805381.0000,136614980.0000,136850286.0000,136644086.0000,136639707.0000,136543615.0000,136473612.0000,136645027.0000,131170153.0000,135034916.0000,136570706.0000,136569675.0000,136571457.0000,136547963.0000,136564615.0000,136694341.0000,135438391.0000,136739035.0000,136572599.0000,136668261.0000,136559254.0000,136438515.0000,136352634.0000,136525380.0000,136407828.0000,136470306.0000,136561980.0000,136593109.0000,136424299.0000,136528706.0000,136525600.0000,136454575.0000,136441100.0000,136658291.0000,136677238.0000,136588029.0000,136536471.0000,136432815.0000,129815135.0000,136521443.0000,136517245.0000,136459044.0000,136503819.0000" -generating large command graphs for N nodes - 16,jacobi topology,100,1,13098933200,130839766.5700,130571317.7400,131223504.3600,1608945.3038,981346.9185,2894170.3940,"130697647.0000,131080321.0000,130974683.0000,130687598.0000,130999249.0000,130946268.0000,131010499.0000,131164963.0000,130765015.0000,130873139.0000,131171836.0000,130595945.0000,130824587.0000,130942712.0000,130835629.0000,130863552.0000,130999640.0000,130890413.0000,131303826.0000,125935453.0000,127218876.0000,130908747.0000,131198757.0000,125678267.0000,131158059.0000,131175282.0000,131045356.0000,131095942.0000,125627319.0000,131061357.0000,131048181.0000,131072969.0000,130932302.0000,131058561.0000,131120948.0000,131334433.0000,131309867.0000,131346897.0000,130786235.0000,131151427.0000,130817764.0000,131040326.0000,131189950.0000,130948162.0000,131037802.0000,131064361.0000,131001081.0000,131213064.0000,130804720.0000,131080442.0000,131170603.0000,127244665.0000,131150385.0000,131348971.0000,131145576.0000,130934335.0000,131009919.0000,131193887.0000,129192665.0000,131185731.0000,131261205.0000,130914568.0000,131058821.0000,131092064.0000,131223062.0000,131014908.0000,131081614.0000,131020960.0000,131432598.0000,131720274.0000,131050536.0000,131280992.0000,131167087.0000,131284238.0000,131040747.0000,130926650.0000,130881244.0000,131001052.0000,130982998.0000,131130777.0000,130601373.0000,127511841.0000,131033353.0000,131160263.0000,131054443.0000,131386853.0000,131489707.0000,130994139.0000,142311172.0000,129811467.0000,130678250.0000,130882877.0000,131115619.0000,130591214.0000,131052078.0000,130364365.0000,130002790.0000,131221640.0000,131065523.0000,130414129.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,soup topology,100,1,2814285800,27995963.4100,27872730.2000,28051003.8500,398272.9303,179872.5308,683619.5638,"28064374.0000,27941051.0000,28030551.0000,28065176.0000,28092138.0000,27922647.0000,28026263.0000,28166618.0000,28345437.0000,27965727.0000,28149706.0000,28124548.0000,28119819.0000,28076899.0000,28070697.0000,28025091.0000,28072119.0000,27957051.0000,28006035.0000,25233421.0000,25792811.0000,28120251.0000,27990856.0000,28035290.0000,28046431.0000,28139768.0000,28015863.0000,28199741.0000,28043516.0000,28139577.0000,27967041.0000,28055198.0000,28149897.0000,28075726.0000,28119891.0000,28051210.0000,28051441.0000,28129949.0000,27973803.0000,28118327.0000,28128637.0000,28008179.0000,28119068.0000,28003580.0000,28022767.0000,28198068.0000,28036893.0000,27990996.0000,28081928.0000,28145629.0000,28067832.0000,27937424.0000,28071599.0000,28011004.0000,28149316.0000,27869946.0000,28043185.0000,28131853.0000,27405356.0000,27907308.0000,28107727.0000,28037855.0000,28170586.0000,28014400.0000,28050929.0000,27955859.0000,27970697.0000,28056480.0000,28162431.0000,28035991.0000,28009281.0000,28177239.0000,28118818.0000,28117896.0000,28085365.0000,28050990.0000,28057873.0000,27977981.0000,28052803.0000,28063152.0000,28103009.0000,28213387.0000,28248885.0000,28113178.0000,27944237.0000,28058053.0000,28004963.0000,28039898.0000,28152111.0000,27982339.0000,26604719.0000,27999913.0000,28090414.0000,28130239.0000,28021414.0000,28123366.0000,28140078.0000,28105984.0000,28171418.0000,28071860.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,chain topology,100,1,27878500,279709.4000,279241.6900,280377.0100,2836.2489,2138.9697,3688.9868,"277564.0000,278866.0000,288375.0000,279848.0000,281061.0000,280460.0000,285038.0000,279738.0000,279527.0000,279668.0000,278616.0000,279677.0000,279257.0000,279728.0000,279949.0000,279648.0000,280289.0000,280019.0000,279287.0000,278987.0000,287994.0000,279889.0000,279347.0000,278565.0000,278836.0000,277875.0000,279468.0000,278495.0000,277954.0000,278697.0000,278796.0000,277814.0000,278115.0000,277513.0000,278315.0000,282273.0000,277815.0000,277985.0000,278365.0000,277493.0000,277994.0000,278716.0000,277914.0000,278175.0000,277554.0000,277323.0000,277764.0000,277855.0000,277594.0000,289096.0000,277464.0000,278225.0000,279026.0000,277554.0000,278055.0000,277214.0000,278696.0000,277013.0000,278656.0000,278075.0000,279077.0000,278807.0000,281832.0000,290749.0000,287303.0000,284797.0000,283595.0000,282934.0000,278837.0000,279788.0000,278707.0000,279768.0000,278205.0000,278326.0000,278155.0000,278566.0000,279167.0000,290870.0000,278846.0000,279708.0000,280068.0000,278837.0000,279798.0000,279057.0000,278346.0000,278155.0000,279478.0000,279537.0000,279878.0000,279478.0000,278616.0000,278435.0000,285599.0000,278946.0000,278996.0000,277955.0000,278937.0000,278556.0000,278616.0000,278446.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,44716700,447262.8400,446898.9800,447814.6200,2243.4921,1640.2110,3009.1090,"447216.0000,447075.0000,454480.0000,447075.0000,446915.0000,453658.0000,447215.0000,447596.0000,447065.0000,445092.0000,448267.0000,445452.0000,446344.0000,445412.0000,451774.0000,447276.0000,446103.0000,446634.0000,445943.0000,444871.0000,446054.0000,446744.0000,446955.0000,456293.0000,446785.0000,446073.0000,446695.0000,445963.0000,446474.0000,446464.0000,446033.0000,446153.0000,451083.0000,447126.0000,447045.0000,445953.0000,447065.0000,447365.0000,446064.0000,446394.0000,447536.0000,450331.0000,447445.0000,446935.0000,447035.0000,447436.0000,446665.0000,447376.0000,447275.0000,446434.0000,456653.0000,446334.0000,446845.0000,446885.0000,447616.0000,447226.0000,446995.0000,446464.0000,447887.0000,449991.0000,447285.0000,445522.0000,446364.0000,446915.0000,447065.0000,447246.0000,446614.0000,445723.0000,450041.0000,446113.0000,446434.0000,445171.0000,446343.0000,446594.0000,445823.0000,445753.0000,446364.0000,456162.0000,446293.0000,446164.0000,445502.0000,446384.0000,446765.0000,446314.0000,445923.0000,450492.0000,446434.0000,445292.0000,446193.0000,446103.0000,446744.0000,446213.0000,446184.0000,445702.0000,449970.0000,446495.0000,446895.0000,446364.0000,445993.0000,446725.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,49594200,497440.2000,495673.5500,504674.6000,16166.7389,2388.9369,38176.7338,"494625.0000,494144.0000,504033.0000,496428.0000,495707.0000,495497.0000,495026.0000,497511.0000,494735.0000,503923.0000,494555.0000,493954.0000,495317.0000,495607.0000,494997.0000,494495.0000,495287.0000,500887.0000,496138.0000,493794.0000,495677.0000,495588.0000,495456.0000,494705.0000,494595.0000,505656.0000,494565.0000,493854.0000,495858.0000,495046.0000,495838.0000,494976.0000,494715.0000,499715.0000,494616.0000,494565.0000,493954.0000,494344.0000,494966.0000,494635.0000,495046.0000,499705.0000,496318.0000,494906.0000,494976.0000,493744.0000,493794.0000,495356.0000,493082.0000,505376.0000,494324.0000,495316.0000,493824.0000,495387.0000,493914.0000,493704.0000,492601.0000,500837.0000,493964.0000,494926.0000,494144.0000,494465.0000,494726.0000,494856.0000,495276.0000,656222.0000,494956.0000,494796.0000,494455.0000,495127.0000,494495.0000,496028.0000,493924.0000,499745.0000,496720.0000,495577.0000,496178.0000,495257.0000,496599.0000,494796.0000,495146.0000,500617.0000,494305.0000,495186.0000,494285.0000,494725.0000,495076.0000,495346.0000,494434.0000,505385.0000,495196.0000,494766.0000,495597.0000,495357.0000,495407.0000,496098.0000,495397.0000,499665.0000,496078.0000,496528.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,222556300,2226367.1800,2224263.0000,2232897.1300,17202.1917,6670.2869,38181.6073,"2223872.0000,2225826.0000,2246574.0000,2226647.0000,2237789.0000,2221076.0000,2230344.0000,2220205.0000,2229803.0000,2220916.0000,2231346.0000,2220456.0000,2222890.0000,2230534.0000,2224583.0000,2230705.0000,2222690.0000,2234272.0000,2224393.0000,2230655.0000,2224433.0000,2229723.0000,2240233.0000,2222108.0000,2229843.0000,2221106.0000,2231717.0000,2220566.0000,2231476.0000,2219894.0000,2235534.0000,2233910.0000,2221677.0000,2235114.0000,2224623.0000,2229743.0000,2211077.0000,2249760.0000,2214223.0000,2235042.0000,2224022.0000,2218101.0000,2228802.0000,2220085.0000,2234171.0000,2224744.0000,2229633.0000,2221217.0000,2232608.0000,2236696.0000,2214584.0000,2231766.0000,2218912.0000,2225415.0000,2216638.0000,2225595.0000,2223932.0000,2226357.0000,2223952.0000,2218312.0000,2228260.0000,2215155.0000,2226106.0000,2218701.0000,2227118.0000,2213262.0000,2224854.0000,2228200.0000,2218883.0000,2227108.0000,2217150.0000,2224643.0000,2217860.0000,2225575.0000,2213853.0000,2221167.0000,2227779.0000,2219334.0000,2222410.0000,2224212.0000,2382662.0000,2213633.0000,2229533.0000,2223772.0000,2214985.0000,2222700.0000,2218141.0000,2217320.0000,2220436.0000,2222930.0000,2218953.0000,2233610.0000,2221768.0000,2220796.0000,2226186.0000,2216849.0000,2220656.0000,2213973.0000,2225605.0000,2217660.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,jacobi topology,100,1,83595300,835391.6000,834734.2000,836193.3600,3702.1574,3087.8784,4400.5155,"837916.0000,833247.0000,842365.0000,832455.0000,840040.0000,833147.0000,832255.0000,833637.0000,833037.0000,837886.0000,833598.0000,832796.0000,833267.0000,834910.0000,845019.0000,834950.0000,836663.0000,834359.0000,833418.0000,837825.0000,833157.0000,833838.0000,832666.0000,844969.0000,834268.0000,835090.0000,834560.0000,832335.0000,843226.0000,834971.0000,831543.0000,832254.0000,832074.0000,845450.0000,835240.0000,835261.0000,834389.0000,834079.0000,841653.0000,834550.0000,835591.0000,835922.0000,831283.0000,843116.0000,832766.0000,830191.0000,833027.0000,836924.0000,833788.0000,834719.0000,833377.0000,831804.0000,845089.0000,835721.0000,838477.0000,835471.0000,835401.0000,839389.0000,834359.0000,833227.0000,832866.0000,834910.0000,841092.0000,834620.0000,833838.0000,833077.0000,844137.0000,833528.0000,833898.0000,833618.0000,836102.0000,838898.0000,833027.0000,830622.0000,833858.0000,833718.0000,837325.0000,834560.0000,833537.0000,835251.0000,834890.0000,846723.0000,835481.0000,834189.0000,835842.0000,835361.0000,838216.0000,832897.0000,831904.0000,831363.0000,838407.0000,834219.0000,832896.0000,830863.0000,830592.0000,842995.0000,831694.0000,832175.0000,834960.0000,833006.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,soup topology,100,1,2272782000,24165362.8300,23636387.9400,24619670.7200,2485140.7707,2095830.3079,2972319.2956,"21789075.0000,25852414.0000,25845110.0000,24785682.0000,25472353.0000,26109672.0000,25006531.0000,19605898.0000,18682617.0000,22660145.0000,24126103.0000,25939869.0000,24563762.0000,24893206.0000,22287008.0000,17746134.0000,18278513.0000,23766351.0000,25954387.0000,25250974.0000,26261990.0000,25566341.0000,26345798.0000,26496905.0000,25171273.0000,25730392.0000,25649298.0000,24707374.0000,25759447.0000,26181117.0000,23068187.0000,24690953.0000,25599083.0000,26189913.0000,23078226.0000,24133827.0000,25617930.0000,23067146.0000,24050368.0000,25144342.0000,25972361.0000,24707133.0000,25212090.0000,22744644.0000,23382604.0000,25370982.0000,23040285.0000,24495622.0000,25405818.0000,25718480.0000,25170431.0000,25195038.0000,26017146.0000,25674375.0000,25312200.0000,25843417.0000,18833113.0000,26850424.0000,25426857.0000,26224037.0000,30440276.0000,23833969.0000,25267315.0000,25705385.0000,25724581.0000,26233416.0000,18818786.0000,23325014.0000,24327344.0000,24927221.0000,26945926.0000,23928198.0000,19310247.0000,22010464.0000,21737005.0000,25367254.0000,25399696.0000,24206445.0000,25652404.0000,26883146.0000,26588608.0000,30278790.0000,24964491.0000,22389121.0000,24395372.0000,25074780.0000,26020372.0000,24788368.0000,22350298.0000,18691264.0000,23318071.0000,22273763.0000,19932667.0000,22819807.0000,21310508.0000,22825247.0000,23384076.0000,18634927.0000,16303460.0000,22425430.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,chain topology,100,1,100470200,805665.5700,796853.6900,815097.6800,46484.1637,39812.6418,56551.0049,"786088.0000,783472.0000,643949.0000,837435.0000,784714.0000,843677.0000,871129.0000,778073.0000,757573.0000,872161.0000,896627.0000,874746.0000,821345.0000,821014.0000,748547.0000,821214.0000,769205.0000,882770.0000,904863.0000,907257.0000,900935.0000,882491.0000,900254.0000,937164.0000,854467.0000,878413.0000,849769.0000,849698.0000,921905.0000,841062.0000,839689.0000,812107.0000,871038.0000,754167.0000,785155.0000,842264.0000,842094.0000,812969.0000,839118.0000,785076.0000,784885.0000,842655.0000,780958.0000,813360.0000,812809.0000,847063.0000,778373.0000,810815.0000,783382.0000,785847.0000,786328.0000,813800.0000,780267.0000,811566.0000,815182.0000,780106.0000,785266.0000,783302.0000,785446.0000,781038.0000,779365.0000,789905.0000,784143.0000,780517.0000,758195.0000,780567.0000,758294.0000,781990.0000,779194.0000,787781.0000,779956.0000,786899.0000,781339.0000,810785.0000,756140.0000,783332.0000,783903.0000,783903.0000,783332.0000,784344.0000,814251.0000,781059.0000,757093.0000,755420.0000,781228.0000,724561.0000,753816.0000,756081.0000,811535.0000,815563.0000,781859.0000,754347.0000,782651.0000,786388.0000,811295.0000,782831.0000,787500.0000,782211.0000,780337.0000,784505.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,expanding tree topology,100,1,78810800,727347.3300,714076.4300,744644.2500,76785.6450,62358.0325,93260.9836,"665679.0000,723038.0000,1003459.0000,907848.0000,913730.0000,909902.0000,914540.0000,914811.0000,877371.0000,856641.0000,908970.0000,941673.0000,851812.0000,796517.0000,771800.0000,766510.0000,692120.0000,664517.0000,726104.0000,664387.0000,724030.0000,691539.0000,695806.0000,688031.0000,664687.0000,691728.0000,666311.0000,691479.0000,664757.0000,665258.0000,664897.0000,691999.0000,665950.0000,722207.0000,666230.0000,722797.0000,665629.0000,722568.0000,666000.0000,693693.0000,689805.0000,691499.0000,665028.0000,691408.0000,692019.0000,687381.0000,870858.0000,870427.0000,871019.0000,871319.0000,739890.0000,666050.0000,691458.0000,691889.0000,679666.0000,701236.0000,702209.0000,700725.0000,701407.0000,701177.0000,701808.0000,715845.0000,711206.0000,701988.0000,701256.0000,701817.0000,701246.0000,701687.0000,725874.0000,701127.0000,702399.0000,700766.0000,701878.0000,725343.0000,701217.0000,701979.0000,701327.0000,702028.0000,709502.0000,716646.0000,702359.0000,700475.0000,702239.0000,701087.0000,699684.0000,723509.0000,691629.0000,691769.0000,691949.0000,691629.0000,692010.0000,691528.0000,692000.0000,691659.0000,691909.0000,692150.0000,691899.0000,664037.0000,666431.0000,664347.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,contracting tree topology,100,1,93320500,914252.2700,860921.5200,973547.5300,285106.3005,248960.8417,335407.6774,"928477.0000,929068.0000,946832.0000,1258253.0000,1038165.0000,1010724.0000,1037323.0000,931814.0000,958364.0000,1010883.0000,1064325.0000,983442.0000,859426.0000,851200.0000,825331.0000,1066339.0000,851692.0000,851301.0000,852143.0000,886798.0000,1474652.0000,1452311.0000,1499499.0000,1500431.0000,1451198.0000,1371336.0000,1277448.0000,1097017.0000,698431.0000,654869.0000,657944.0000,649819.0000,656472.0000,650370.0000,664226.0000,650220.0000,656151.0000,659388.0000,654538.0000,627416.0000,526856.0000,540472.0000,538638.0000,540492.0000,530123.0000,543167.0000,529502.0000,536945.0000,543117.0000,531595.0000,532627.0000,528890.0000,542005.0000,721705.0000,808570.0000,862182.0000,853776.0000,857302.0000,849528.0000,860709.0000,865157.0000,852403.0000,852964.0000,856581.0000,863584.0000,782490.0000,579947.0000,580869.0000,609393.0000,628970.0000,726154.0000,851190.0000,851160.0000,851752.0000,851551.0000,904592.0000,1014080.0000,1143325.0000,1145048.0000,1277368.0000,1170406.0000,1144046.0000,1198239.0000,1170847.0000,1170245.0000,1243855.0000,1247622.0000,1132494.0000,1190394.0000,1452159.0000,1770943.0000,1771505.0000,1073512.0000,928888.0000,986437.0000,957171.0000,958784.0000,957141.0000,958594.0000,929530.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,wave_sim topology,100,1,424673000,4373288.1700,4242476.3500,4528684.3300,726948.7388,631161.7937,819526.3633,"3501472.0000,3493687.0000,4320805.0000,4150632.0000,4923426.0000,4756401.0000,3854983.0000,3688918.0000,3745365.0000,3773498.0000,3716981.0000,3715508.0000,3716801.0000,3774911.0000,3717081.0000,3773087.0000,3717752.0000,3772576.0000,3747920.0000,3743031.0000,3761856.0000,3900999.0000,3717673.0000,3688136.0000,3748041.0000,3773188.0000,4857331.0000,3930455.0000,4007472.0000,3949722.0000,4036346.0000,4034153.0000,4006459.0000,3948980.0000,4035905.0000,3860994.0000,4035654.0000,4121598.0000,4007993.0000,4064540.0000,4008283.0000,3944713.0000,4094868.0000,4005237.0000,4009515.0000,4034853.0000,4036627.0000,4034863.0000,4068327.0000,4089918.0000,4038360.0000,4004756.0000,3950303.0000,4003855.0000,4066413.0000,4006069.0000,3919675.0000,4035485.0000,4066332.0000,3976903.0000,4005869.0000,4094938.0000,4062486.0000,4008914.0000,4035425.0000,4006168.0000,3920145.0000,4006199.0000,4066213.0000,4290166.0000,5086165.0000,5080334.0000,5102186.0000,5084262.0000,5079323.0000,5081837.0000,5961785.0000,5892844.0000,5864850.0000,5923662.0000,5861625.0000,5923332.0000,5921268.0000,5895990.0000,5923282.0000,5920977.0000,5865542.0000,5682334.0000,5319968.0000,5376827.0000,5221021.0000,5503997.0000,5421952.0000,5528544.0000,4840030.0000,4231375.0000,4174577.0000,4237086.0000,4256023.0000,4081611.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,jacobi topology,100,1,158145100,1560733.7300,1536123.1100,1590498.1600,137739.8814,115203.3656,165197.1751,"1568279.0000,1567147.0000,1957136.0000,1799318.0000,1538533.0000,1741708.0000,1974700.0000,1972065.0000,1945705.0000,1857378.0000,1829224.0000,1815828.0000,1567358.0000,1566616.0000,1567589.0000,1568110.0000,1568671.0000,1567498.0000,1566396.0000,1568571.0000,1567738.0000,1538793.0000,1567758.0000,1683057.0000,1626781.0000,1625719.0000,1568520.0000,1683027.0000,1595340.0000,1540216.0000,1538143.0000,1567258.0000,1539265.0000,1567198.0000,1568851.0000,1683649.0000,1626640.0000,1566576.0000,1655034.0000,1566887.0000,1568199.0000,1516751.0000,1410791.0000,1436410.0000,1463331.0000,1410882.0000,1438063.0000,1436089.0000,1411262.0000,1434666.0000,1412224.0000,1436841.0000,1463832.0000,1410611.0000,1461377.0000,1462610.0000,1437342.0000,1487546.0000,1767447.0000,1716641.0000,1717683.0000,1717262.0000,1912081.0000,1408878.0000,1410791.0000,1437491.0000,1410510.0000,1409769.0000,1438233.0000,1409339.0000,1410791.0000,1436339.0000,1410761.0000,1437031.0000,1410661.0000,1437151.0000,1436811.0000,1437492.0000,1409669.0000,1436450.0000,1411873.0000,1409239.0000,1528785.0000,1567468.0000,1567037.0000,1567919.0000,1568269.0000,1537291.0000,1568330.0000,1567097.0000,1568380.0000,1567579.0000,1568380.0000,1566917.0000,1568299.0000,1538443.0000,1568079.0000,1596002.0000,1568560.0000,1567038.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,2931779400,30161093.2300,29984591.1700,30250575.5700,615581.8476,363612.1031,961024.7692,"30255717.0000,30354103.0000,30247261.0000,30340167.0000,30299209.0000,30343654.0000,30254935.0000,30321903.0000,30274262.0000,30390592.0000,30336419.0000,30392797.0000,30268441.0000,30191415.0000,30266978.0000,30220249.0000,30219377.0000,30302856.0000,30387727.0000,30294951.0000,30206113.0000,30281897.0000,30352921.0000,28298479.0000,27530954.0000,30275414.0000,30268622.0000,30335147.0000,30282438.0000,30297466.0000,30310260.0000,30338354.0000,30481585.0000,30262530.0000,30324697.0000,30289931.0000,30402626.0000,30295612.0000,30239767.0000,30339225.0000,30169624.0000,30228716.0000,30258833.0000,30335318.0000,30283820.0000,30372308.0000,30280844.0000,30195523.0000,30327223.0000,30267078.0000,30045298.0000,29498532.0000,30384611.0000,30356658.0000,30335237.0000,30336189.0000,29207009.0000,26966855.0000,30225159.0000,30314739.0000,30275364.0000,30319638.0000,30494099.0000,30429436.0000,30263902.0000,30285183.0000,30314047.0000,30406462.0000,30284472.0000,30224226.0000,30314027.0000,30367399.0000,30388618.0000,30220711.0000,30265825.0000,30206624.0000,30300722.0000,30475543.0000,30427753.0000,30288469.0000,30250597.0000,30268141.0000,30377587.0000,30402595.0000,30263612.0000,30290362.0000,30318615.0000,30311352.0000,30296184.0000,29585166.0000,26539686.0000,30250287.0000,30413536.0000,30411031.0000,30040650.0000,30426280.0000,30336059.0000,30370464.0000,30309860.0000,30328114.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,57642000,576424.4000,575986.4900,577005.1700,2552.3690,2018.8921,3196.2253,"576400.0000,575278.0000,584686.0000,580338.0000,575398.0000,574676.0000,574737.0000,576109.0000,575188.0000,574247.0000,580808.0000,574116.0000,574818.0000,574717.0000,573955.0000,574317.0000,574466.0000,584105.0000,575068.0000,576521.0000,576400.0000,575148.0000,575950.0000,574917.0000,580297.0000,576060.0000,575809.0000,575018.0000,576600.0000,576851.0000,576330.0000,584796.0000,576581.0000,574146.0000,576520.0000,577292.0000,576360.0000,576009.0000,576480.0000,577392.0000,578193.0000,576451.0000,576390.0000,575609.0000,576069.0000,582401.0000,577753.0000,575980.0000,574978.0000,575588.0000,576450.0000,576531.0000,577121.0000,574246.0000,574907.0000,576591.0000,574036.0000,574025.0000,576099.0000,580528.0000,574316.0000,573505.0000,575258.0000,573985.0000,574015.0000,574347.0000,583714.0000,577352.0000,575238.0000,575028.0000,576841.0000,575668.0000,574446.0000,577943.0000,575809.0000,576570.0000,574086.0000,574587.0000,575639.0000,575739.0000,579686.0000,574636.0000,573043.0000,575739.0000,574868.0000,573344.0000,585638.0000,577412.0000,577433.0000,577161.0000,576581.0000,574707.0000,575619.0000,581921.0000,577222.0000,575108.0000,575618.0000,575198.0000,576480.0000,576090.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,75345100,754749.3400,754128.3500,755610.4800,3734.5510,2938.3474,4776.2306,"751913.0000,752884.0000,762183.0000,754257.0000,754498.0000,752795.0000,754417.0000,753897.0000,753717.0000,763655.0000,753486.0000,753846.0000,754368.0000,753485.0000,763033.0000,755309.0000,754227.0000,754297.0000,754077.0000,753967.0000,757153.0000,753145.0000,753406.0000,753976.0000,754007.0000,768665.0000,754888.0000,754026.0000,754016.0000,754497.0000,762333.0000,754047.0000,754267.0000,753065.0000,754338.0000,754337.0000,769677.0000,753726.0000,754077.0000,754378.0000,754197.0000,762022.0000,751923.0000,752874.0000,753475.0000,753386.0000,760168.0000,752574.0000,753756.0000,752174.0000,752263.0000,764688.0000,755509.0000,753556.0000,753466.0000,753025.0000,753566.0000,753776.0000,752875.0000,752634.0000,752644.0000,752955.0000,764557.0000,753616.0000,753185.0000,752754.0000,752684.0000,761050.0000,752764.0000,752364.0000,752354.0000,751993.0000,752694.0000,753966.0000,752504.0000,753155.0000,753977.0000,752394.0000,763114.0000,753215.0000,752424.0000,751733.0000,751431.0000,754387.0000,751662.0000,751872.0000,753266.0000,751852.0000,753456.0000,761852.0000,753546.0000,752274.0000,752414.0000,752033.0000,758876.0000,752564.0000,752334.0000,751913.0000,751952.0000,756912.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,80014600,799208.1800,796927.5600,800268.0800,7599.1349,3059.4281,13328.5072,"798020.0000,798050.0000,755089.0000,745771.0000,812577.0000,799533.0000,798411.0000,799203.0000,802478.0000,799012.0000,799854.0000,798381.0000,798361.0000,801356.0000,800726.0000,799493.0000,798962.0000,798801.0000,807088.0000,801897.0000,798642.0000,798842.0000,799122.0000,803491.0000,801076.0000,799232.0000,799142.0000,799072.0000,808741.0000,801096.0000,798891.0000,799482.0000,799053.0000,803620.0000,799413.0000,799163.0000,799553.0000,799242.0000,802288.0000,799733.0000,799213.0000,798852.0000,797469.0000,806957.0000,799704.0000,797258.0000,797869.0000,798882.0000,803050.0000,800294.0000,797349.0000,797059.0000,797870.0000,806546.0000,800294.0000,798821.0000,798672.0000,798952.0000,803881.0000,798521.0000,799584.0000,797309.0000,798581.0000,807739.0000,799944.0000,798881.0000,799162.0000,798972.0000,803891.0000,798391.0000,798060.0000,798602.0000,798801.0000,808100.0000,800094.0000,798050.0000,798521.0000,797940.0000,802148.0000,798522.0000,799392.0000,799252.0000,798992.0000,808951.0000,798921.0000,799283.0000,799413.0000,798781.0000,799373.0000,799623.0000,797790.0000,799533.0000,800194.0000,808359.0000,800405.0000,798361.0000,798661.0000,797970.0000,798652.0000,798150.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,428157800,4249079.4100,4229986.9800,4263481.2200,84746.9417,67490.4316,100346.9781,"4287342.0000,4280839.0000,4296980.0000,4290267.0000,4280259.0000,4279226.0000,4281361.0000,4280468.0000,4285619.0000,4280319.0000,4286289.0000,4278325.0000,4281451.0000,4279006.0000,4283605.0000,4275970.0000,4290117.0000,4280508.0000,4287442.0000,4026948.0000,4042678.0000,4043229.0000,4040975.0000,4040855.0000,4034092.0000,4050283.0000,4164629.0000,4290378.0000,4291930.0000,4292200.0000,4287452.0000,4294205.0000,4285458.0000,4294214.0000,4286801.0000,4283735.0000,4285317.0000,4288554.0000,4294396.0000,4290127.0000,4284326.0000,4289966.0000,4286900.0000,4285669.0000,4290488.0000,4288724.0000,4284175.0000,4288765.0000,4278605.0000,4289736.0000,4281520.0000,4288064.0000,4280759.0000,4290718.0000,4276973.0000,4283484.0000,4282563.0000,4281170.0000,4282643.0000,4289797.0000,4279967.0000,4287753.0000,4282012.0000,4293774.0000,4290728.0000,4295738.0000,4287422.0000,4301298.0000,4193815.0000,4059270.0000,4046495.0000,4038710.0000,4050523.0000,4044732.0000,4049821.0000,4049951.0000,4190308.0000,4285098.0000,4295698.0000,4292361.0000,4282232.0000,4284226.0000,4299314.0000,4291900.0000,4280599.0000,4280980.0000,4279217.0000,4276661.0000,4282924.0000,4295297.0000,4285558.0000,4284737.0000,4281301.0000,4286039.0000,4274798.0000,4285478.0000,4289306.0000,4277883.0000,4288784.0000,4286339.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,133824900,1346997.4500,1346371.8000,1347733.1400,3463.8435,2966.5264,4013.5692,"1346730.0000,1344666.0000,1352601.0000,1344535.0000,1354384.0000,1343223.0000,1344566.0000,1346129.0000,1346609.0000,1342612.0000,1349866.0000,1343914.0000,1343043.0000,1354756.0000,1345998.0000,1345317.0000,1350307.0000,1346970.0000,1343724.0000,1350416.0000,1347532.0000,1346579.0000,1352431.0000,1344967.0000,1346179.0000,1354134.0000,1345588.0000,1344516.0000,1351398.0000,1345187.0000,1345097.0000,1348994.0000,1344626.0000,1343013.0000,1349045.0000,1344826.0000,1344536.0000,1350517.0000,1343995.0000,1347241.0000,1348002.0000,1345738.0000,1350247.0000,1346018.0000,1343273.0000,1346158.0000,1346239.0000,1345898.0000,1351499.0000,1345949.0000,1344475.0000,1347722.0000,1345568.0000,1346359.0000,1354354.0000,1344927.0000,1346459.0000,1355957.0000,1347391.0000,1343584.0000,1354264.0000,1343835.0000,1342672.0000,1347161.0000,1343694.0000,1345487.0000,1345848.0000,1344585.0000,1348113.0000,1352240.0000,1346089.0000,1344957.0000,1356809.0000,1345077.0000,1344576.0000,1342341.0000,1344766.0000,1342732.0000,1344395.0000,1343644.0000,1343985.0000,1352491.0000,1343394.0000,1345818.0000,1345979.0000,1346419.0000,1346489.0000,1354995.0000,1347191.0000,1346259.0000,1350527.0000,1345487.0000,1343163.0000,1349666.0000,1347852.0000,1345268.0000,1355236.0000,1345036.0000,1346609.0000,1348012.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,2715524600,24211126.2300,23678171.8700,24769494.3400,2770300.9386,2529170.6144,3080093.6745,"30272789.0000,25982771.0000,28995709.0000,25166705.0000,27408922.0000,20532784.0000,20833333.0000,20346701.0000,21524653.0000,26914886.0000,23494025.0000,24162341.0000,23053059.0000,26210101.0000,22808195.0000,23593443.0000,20223607.0000,22476967.0000,22863010.0000,22535779.0000,24737221.0000,21340595.0000,22372990.0000,28865552.0000,22578419.0000,22628254.0000,24524417.0000,28522042.0000,22633724.0000,22191808.0000,21695086.0000,22706061.0000,23302723.0000,22169795.0000,21415446.0000,20383802.0000,22339798.0000,22166399.0000,22941197.0000,28193950.0000,24825888.0000,26392105.0000,20373241.0000,20446560.0000,20918444.0000,22374142.0000,23209746.0000,29926653.0000,23592060.0000,23489275.0000,25594084.0000,27978761.0000,27951451.0000,26704959.0000,27750108.0000,27632607.0000,28008098.0000,23338390.0000,27187042.0000,27841972.0000,27776078.0000,27930521.0000,27477832.0000,27667382.0000,27899812.0000,27793160.0000,24394481.0000,23621606.0000,21726976.0000,20208220.0000,22888978.0000,22621822.0000,21782692.0000,22767056.0000,22435278.0000,25411317.0000,17923669.0000,21992519.0000,22455546.0000,25587642.0000,20187980.0000,21235536.0000,25709522.0000,26071598.0000,26311222.0000,26611882.0000,26769350.0000,25909652.0000,25255101.0000,28516892.0000,20516593.0000,20457271.0000,22511924.0000,22393529.0000,22819245.0000,26963739.0000,24312705.0000,26071929.0000,26888566.0000,20591155.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,151836100,1294620.8800,1267616.4400,1320505.7400,135008.9323,123971.6967,147767.1192,"1307445.0000,1238845.0000,1448332.0000,1336210.0000,1536720.0000,1277168.0000,1333565.0000,1337222.0000,1333485.0000,1216794.0000,1283290.0000,1074805.0000,1190404.0000,1073812.0000,1073462.0000,1073923.0000,1073873.0000,1188831.0000,1075857.0000,1072760.0000,1074163.0000,1042183.0000,1049427.0000,1103739.0000,1105102.0000,1070316.0000,1250638.0000,1190143.0000,1249806.0000,1303999.0000,1308096.0000,1219789.0000,1217986.0000,1306944.0000,1247311.0000,1163894.0000,1158073.0000,1129789.0000,1218126.0000,1250387.0000,1306784.0000,1160688.0000,1217485.0000,1221353.0000,1216213.0000,1222495.0000,1249245.0000,1158754.0000,1190975.0000,1073652.0000,1281826.0000,1158974.0000,1247942.0000,1218547.0000,1242833.0000,1164365.0000,1223016.0000,1302316.0000,1160898.0000,1163583.0000,1394791.0000,1450487.0000,1452992.0000,1450176.0000,1451338.0000,1453031.0000,1390232.0000,1457791.0000,1447711.0000,1448022.0000,1395172.0000,1453733.0000,1452481.0000,1451669.0000,1449484.0000,1391825.0000,1455546.0000,1450697.0000,1452220.0000,1390933.0000,1449424.0000,1391765.0000,1453533.0000,1395051.0000,1451959.0000,1422904.0000,1421321.0000,1453432.0000,1453963.0000,1443764.0000,1450376.0000,1450697.0000,1457189.0000,1418005.0000,1451809.0000,1422253.0000,1365837.0000,1307907.0000,1304891.0000,1367019.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,161853700,1706681.0600,1659158.7800,1750797.8700,232875.0202,213930.9159,261824.9209,"1564482.0000,1556157.0000,1893236.0000,1861816.0000,1915377.0000,1863779.0000,1912743.0000,1912231.0000,1834193.0000,1915838.0000,1918453.0000,1918644.0000,1911079.0000,1946537.0000,1912221.0000,1923072.0000,1912863.0000,1912392.0000,1917542.0000,1914936.0000,1914947.0000,1891112.0000,1914506.0000,1918803.0000,1912832.0000,1827190.0000,1923293.0000,1939182.0000,1912231.0000,1920788.0000,1884249.0000,1916780.0000,1916159.0000,1916149.0000,1887705.0000,1914585.0000,1916770.0000,1915779.0000,1883918.0000,1915086.0000,1917982.0000,1918944.0000,1912151.0000,1890470.0000,1916099.0000,1917972.0000,1913875.0000,1886603.0000,1911740.0000,1917792.0000,1913483.0000,1924444.0000,1912872.0000,1914205.0000,1916069.0000,1865693.0000,1378530.0000,1330269.0000,1521892.0000,1301845.0000,1385523.0000,1250747.0000,1381766.0000,1380063.0000,1464152.0000,1251690.0000,1462359.0000,1360095.0000,1566707.0000,1333305.0000,1435388.0000,1333445.0000,1250978.0000,1329217.0000,1496734.0000,1064886.0000,1599568.0000,1564833.0000,1575252.0000,1570494.0000,1537011.0000,1504890.0000,1509218.0000,1546228.0000,1530568.0000,1515349.0000,1534926.0000,1535136.0000,1568430.0000,1601072.0000,1504428.0000,1567758.0000,1571616.0000,1503588.0000,1601202.0000,1535878.0000,1599649.0000,1563310.0000,1566386.0000,1571676.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,173721000,1716872.9200,1697757.1000,1736702.7100,99743.9201,88336.4625,115476.0331,"1825868.0000,1697374.0000,1880190.0000,1650906.0000,1779891.0000,1682116.0000,1755073.0000,1567418.0000,1574552.0000,1545146.0000,1595621.0000,1568319.0000,1595280.0000,1542841.0000,1708004.0000,1720007.0000,1568621.0000,1634135.0000,1712223.0000,1593808.0000,1751156.0000,1696212.0000,1648571.0000,1691893.0000,1657889.0000,1728343.0000,1672037.0000,1684380.0000,1650575.0000,1642299.0000,1706622.0000,1680252.0000,1780883.0000,1649674.0000,1596984.0000,1596413.0000,1650595.0000,1652189.0000,1666726.0000,1712212.0000,1625248.0000,1652690.0000,1685031.0000,1713294.0000,1654382.0000,1626109.0000,1624737.0000,1716110.0000,1709297.0000,1785993.0000,1838582.0000,1767738.0000,2008484.0000,1951246.0000,1751787.0000,1827761.0000,1736899.0000,1767747.0000,1667117.0000,1594029.0000,1707543.0000,1708405.0000,1513726.0000,1514378.0000,1516141.0000,1787405.0000,1654994.0000,1714567.0000,1681535.0000,1625078.0000,1656247.0000,1717292.0000,1685571.0000,1681023.0000,1738782.0000,1745565.0000,1737860.0000,1776615.0000,1829375.0000,1862638.0000,1823844.0000,1787596.0000,1782335.0000,1763219.0000,1785722.0000,1785581.0000,1786303.0000,1779430.0000,1773218.0000,1798827.0000,1796913.0000,1801231.0000,1858560.0000,1796482.0000,1865723.0000,1902042.0000,1880361.0000,1891953.0000,1881834.0000,1873799.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,724786300,9468295.9100,9187326.5600,9751689.8200,1436924.1739,1228809.0638,1679419.9068,"9390371.0000,9370893.0000,7642389.0000,10895122.0000,8358897.0000,6382160.0000,9331309.0000,9332210.0000,10588542.0000,7895097.0000,11173941.0000,12225783.0000,12314301.0000,12664315.0000,11346056.0000,11370793.0000,12219151.0000,12283934.0000,12217477.0000,8870326.0000,7366897.0000,7335457.0000,7317403.0000,6879924.0000,5806851.0000,6441694.0000,6604642.0000,5790721.0000,7458600.0000,8918016.0000,9399458.0000,9393618.0000,9414506.0000,9424676.0000,9378268.0000,9406061.0000,9385542.0000,9453892.0000,9389149.0000,8757341.0000,8646901.0000,8650970.0000,9149114.0000,9399118.0000,9386283.0000,9403906.0000,8883721.0000,8661279.0000,9359593.0000,9388818.0000,9442219.0000,9398586.0000,9408144.0000,9433532.0000,9416771.0000,9399387.0000,9373850.0000,9386303.0000,9373038.0000,9377346.0000,9388999.0000,9395871.0000,9389850.0000,9309838.0000,8952652.0000,9398305.0000,9387506.0000,9409086.0000,9403025.0000,9408686.0000,9472656.0000,9365433.0000,9417412.0000,9400821.0000,9406572.0000,9184932.0000,9012865.0000,9097295.0000,9243432.0000,9339154.0000,9066106.0000,7581163.0000,11606139.0000,11385231.0000,11526909.0000,11727368.0000,11188108.0000,12274506.0000,12285326.0000,12220083.0000,11928540.0000,9411802.0000,8830921.0000,9232222.0000,9085323.0000,9404127.0000,9412513.0000,9371515.0000,9417804.0000,9354833.0000" -building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,276609400,2400342.9400,2298464.0200,2499755.1800,514241.6589,460318.1127,573873.9472,"3220861.0000,3164123.0000,3102226.0000,2955167.0000,3118877.0000,3057311.0000,2571421.0000,2438229.0000,2583233.0000,2475238.0000,2465660.0000,2468646.0000,2582861.0000,2520814.0000,2529250.0000,2467303.0000,2582491.0000,2528308.0000,2611546.0000,2466882.0000,2522508.0000,2587029.0000,2497671.0000,2605295.0000,2498322.0000,2526155.0000,2629701.0000,2809711.0000,2796777.0000,2711696.0000,2743396.0000,2718939.0000,2617097.0000,1902783.0000,1902373.0000,1896401.0000,1883066.0000,1901802.0000,1890390.0000,2065462.0000,2125515.0000,1982584.0000,1978567.0000,2036477.0000,2086562.0000,2589395.0000,2572503.0000,2851792.0000,2903931.0000,2749678.0000,2882549.0000,2618399.0000,2702869.0000,2747274.0000,2341154.0000,2234923.0000,2335323.0000,2367284.0000,2379797.0000,2429781.0000,2443257.0000,2307791.0000,2309454.0000,2298282.0000,2354610.0000,2235724.0000,2223591.0000,2280319.0000,1522423.0000,1475795.0000,1562909.0000,1487526.0000,1495352.0000,1456157.0000,1501443.0000,1545396.0000,1545255.0000,1474562.0000,1543442.0000,1501604.0000,1724856.0000,1585232.0000,1590953.0000,1729275.0000,1630136.0000,2308342.0000,2631414.0000,2638617.0000,2685466.0000,2700836.0000,3490251.0000,3006064.0000,3009992.0000,3191054.0000,3194070.0000,3193489.0000,3164494.0000,3167801.0000,3103429.0000,3190253.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,soup topology,100,1,6379204300,66020014.6700,65770373.4700,66144616.5100,865893.1460,487142.7481,1385311.6130,"66075558.0000,66316063.0000,66083061.0000,66042385.0000,66220502.0000,66139991.0000,65954468.0000,66070849.0000,66229509.0000,66086990.0000,66269706.0000,60975083.0000,66306024.0000,66039219.0000,66093201.0000,66205825.0000,66138306.0000,66037074.0000,62839956.0000,65322230.0000,66083803.0000,66251772.0000,66131113.0000,66065158.0000,66132244.0000,66542493.0000,66016225.0000,65904985.0000,66244788.0000,66102039.0000,66233787.0000,66575245.0000,66092940.0000,66112328.0000,66305373.0000,66366219.0000,66116415.0000,66036804.0000,66094735.0000,66150219.0000,66170578.0000,66279303.0000,66240811.0000,66218007.0000,66055019.0000,66081488.0000,66286477.0000,66154087.0000,66524077.0000,66128208.0000,66420010.0000,66130812.0000,66066039.0000,66251962.0000,66281569.0000,65986509.0000,66263424.0000,66665956.0000,60945637.0000,66110294.0000,66123388.0000,66107107.0000,66121716.0000,65967713.0000,66469214.0000,66135932.0000,64927973.0000,63482844.0000,66144659.0000,66268793.0000,66169064.0000,66289414.0000,66486135.0000,66071160.0000,66020173.0000,66438615.0000,66281368.0000,66387308.0000,66644666.0000,66351661.0000,66352311.0000,66281738.0000,66019311.0000,66325591.0000,66240981.0000,66433646.0000,66206706.0000,66494271.0000,66237063.0000,66245881.0000,66173583.0000,66316083.0000,66212869.0000,66059036.0000,66108430.0000,66139478.0000,66332906.0000,66370106.0000,66167992.0000,66129630.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,chain topology,100,1,352508800,3499779.1500,3474778.9600,3515036.5700,96334.5389,59627.1941,132861.7332,"3104861.0000,3125460.0000,3559372.0000,3520389.0000,3520348.0000,3520910.0000,3525128.0000,3531319.0000,3531830.0000,3515188.0000,3511021.0000,3522473.0000,3529426.0000,3523685.0000,3535737.0000,3525728.0000,3525128.0000,3530959.0000,3528815.0000,3524336.0000,3533243.0000,3520699.0000,3518815.0000,3525619.0000,3515570.0000,3525358.0000,3522062.0000,3514166.0000,3519096.0000,3523054.0000,3510850.0000,3510028.0000,3517252.0000,3510239.0000,3530527.0000,3508887.0000,3520709.0000,3518505.0000,3525268.0000,3533102.0000,3529175.0000,3532833.0000,3534305.0000,3526901.0000,3507444.0000,3520007.0000,3519457.0000,3524707.0000,3523284.0000,3525618.0000,3528905.0000,3512213.0000,3513266.0000,3537140.0000,3520018.0000,3521541.0000,3530217.0000,3519727.0000,3529486.0000,3531560.0000,3519587.0000,3524486.0000,3544895.0000,3524687.0000,3521110.0000,3533985.0000,3522201.0000,3522863.0000,3524817.0000,3512303.0000,3526871.0000,3528023.0000,3533032.0000,3530398.0000,3519557.0000,3517453.0000,3527402.0000,3519606.0000,3519857.0000,3520509.0000,3564712.0000,3524927.0000,3530428.0000,3519647.0000,3514377.0000,3525669.0000,3528454.0000,3518866.0000,3521611.0000,3517463.0000,3518244.0000,3519115.0000,3522713.0000,3521701.0000,3512182.0000,3525137.0000,3182038.0000,3118186.0000,3100594.0000,3095243.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,982543300,9849989.2300,9845525.0400,9854238.9500,22113.0408,18416.6758,27198.0233,"9853208.0000,9854721.0000,9850853.0000,9848248.0000,9851865.0000,9865972.0000,9857065.0000,9870972.0000,9866072.0000,9857968.0000,9850352.0000,9860692.0000,9837719.0000,9807962.0000,9836306.0000,9819203.0000,9857055.0000,9798894.0000,9834182.0000,9870600.0000,9851595.0000,9847987.0000,9868527.0000,9840323.0000,9874859.0000,9845683.0000,9848670.0000,9830815.0000,9783166.0000,9835674.0000,9855713.0000,9796830.0000,9863887.0000,9834814.0000,9838660.0000,9848790.0000,9839973.0000,9846946.0000,9848198.0000,9853669.0000,9836526.0000,9861324.0000,9845813.0000,9857917.0000,9841826.0000,9846215.0000,9841315.0000,9821478.0000,9800699.0000,9799756.0000,9850023.0000,9846074.0000,9882253.0000,9855773.0000,9864039.0000,9850452.0000,9855413.0000,9848599.0000,9859841.0000,9858988.0000,9869028.0000,9831066.0000,9842918.0000,9870240.0000,9850502.0000,9905347.0000,9877212.0000,9890869.0000,9852536.0000,9863067.0000,9863116.0000,9863818.0000,9854399.0000,9831017.0000,9851023.0000,9796852.0000,9804535.0000,9866282.0000,9854120.0000,9869749.0000,9854391.0000,9848038.0000,9844432.0000,9824793.0000,9925725.0000,9871493.0000,9877003.0000,9873587.0000,9867966.0000,9858257.0000,9857365.0000,9850093.0000,9860832.0000,9861444.0000,9859009.0000,9858358.0000,9846195.0000,9863237.0000,9848308.0000,9811689.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,394034500,3939575.4200,3937887.9500,3941041.8100,8010.9569,6698.1566,9903.1448,"3941497.0000,3915697.0000,3938441.0000,3939622.0000,3947648.0000,3940134.0000,3938069.0000,3932960.0000,3942558.0000,3935986.0000,3932981.0000,3940294.0000,3947869.0000,3937569.0000,3942237.0000,3933731.0000,3940405.0000,3933792.0000,3944712.0000,3943590.0000,3937909.0000,3952858.0000,3933932.0000,3940465.0000,3945003.0000,3935936.0000,3946075.0000,3941927.0000,3939673.0000,3937980.0000,3930495.0000,3951806.0000,3939123.0000,3948359.0000,3930185.0000,3929053.0000,3942498.0000,3930475.0000,3922811.0000,3940063.0000,3939232.0000,3951435.0000,3938752.0000,3947818.0000,3932619.0000,3949682.0000,3945865.0000,3940244.0000,3940444.0000,3945554.0000,3935826.0000,3958128.0000,3945003.0000,3946366.0000,3947438.0000,3954922.0000,3939993.0000,3944242.0000,3941667.0000,3939563.0000,3943901.0000,3940775.0000,3943310.0000,3945845.0000,3943921.0000,3939954.0000,3936757.0000,3938039.0000,3935796.0000,3952567.0000,3943360.0000,3940835.0000,3936557.0000,3931737.0000,3928883.0000,3942658.0000,3934553.0000,3930385.0000,3944622.0000,3939944.0000,3943921.0000,3941276.0000,3929765.0000,3945544.0000,3937208.0000,3946566.0000,3947488.0000,3934953.0000,3946786.0000,3941717.0000,3943590.0000,3939523.0000,3917030.0000,3910467.0000,3917802.0000,3948820.0000,3933481.0000,3938401.0000,3940044.0000,3927550.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,1623882200,15832562.1400,15729871.5200,15896996.1300,406166.0903,277976.3303,551218.0863,"14151492.0000,14660356.0000,15985307.0000,15962914.0000,15987942.0000,15935362.0000,16012278.0000,15954248.0000,15964398.0000,15952514.0000,15935533.0000,15969237.0000,14492799.0000,14116586.0000,15079281.0000,15979346.0000,15964236.0000,15955019.0000,15923760.0000,15965460.0000,15951422.0000,15976210.0000,15979557.0000,15993151.0000,15969458.0000,15928479.0000,15945362.0000,15946022.0000,15956593.0000,15966622.0000,15940231.0000,15958697.0000,15943919.0000,15958136.0000,15929751.0000,15935212.0000,15934731.0000,15943588.0000,15950190.0000,15931625.0000,15943739.0000,15939930.0000,15965470.0000,15950050.0000,15942175.0000,15929631.0000,15933850.0000,15965850.0000,15923038.0000,15945281.0000,15926305.0000,15929912.0000,15945822.0000,15927458.0000,15916707.0000,15952193.0000,15937756.0000,15945672.0000,15963856.0000,15945621.0000,15920474.0000,15920985.0000,15928258.0000,15981479.0000,15967674.0000,15969568.0000,15953185.0000,15936865.0000,15942416.0000,14436562.0000,14201287.0000,15234515.0000,16002439.0000,15993933.0000,15997189.0000,15985929.0000,15973614.0000,15985948.0000,15978063.0000,15945622.0000,15999172.0000,15947755.0000,15952525.0000,15951963.0000,15947446.0000,15955290.0000,15972243.0000,15942585.0000,15937386.0000,15937266.0000,15944719.0000,15952154.0000,15968615.0000,15979637.0000,15944178.0000,15947495.0000,15961272.0000,15949128.0000,15955421.0000,15036619.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,jacobi topology,100,1,556047900,5552896.9300,5551302.5300,5554583.4400,8340.2115,7331.9907,9919.8490,"5571505.0000,5554914.0000,5580933.0000,5552459.0000,5542280.0000,5555956.0000,5541798.0000,5556286.0000,5551507.0000,5549463.0000,5556806.0000,5544183.0000,5566476.0000,5554512.0000,5551376.0000,5562748.0000,5544584.0000,5560514.0000,5549062.0000,5557077.0000,5565633.0000,5553591.0000,5538813.0000,5555304.0000,5554242.0000,5555856.0000,5539835.0000,5547799.0000,5547128.0000,5559091.0000,5558610.0000,5559713.0000,5540526.0000,5563380.0000,5559602.0000,5554372.0000,5552399.0000,5548411.0000,5548701.0000,5547639.0000,5545877.0000,5557930.0000,5554061.0000,5558550.0000,5550044.0000,5548783.0000,5563740.0000,5548011.0000,5551276.0000,5542130.0000,5549173.0000,5561906.0000,5546727.0000,5557838.0000,5534996.0000,5544834.0000,5549042.0000,5550105.0000,5545516.0000,5572256.0000,5553972.0000,5559462.0000,5545947.0000,5550514.0000,5560944.0000,5550084.0000,5561206.0000,5553190.0000,5541758.0000,5565493.0000,5543082.0000,5567758.0000,5551247.0000,5553560.0000,5558851.0000,5555835.0000,5544814.0000,5561926.0000,5554072.0000,5563650.0000,5549382.0000,5550434.0000,5569381.0000,5556597.0000,5563600.0000,5543562.0000,5543402.0000,5544775.0000,5538712.0000,5543221.0000,5557659.0000,5543061.0000,5552098.0000,5544904.0000,5550545.0000,5552690.0000,5555955.0000,5555614.0000,5550194.0000,5538663.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,soup topology,100,1,5154808700,54940307.7500,54204083.5200,55658691.9100,3719537.3719,3285080.8687,4303581.4694,"55205612.0000,59091023.0000,53124628.0000,57800848.0000,58500975.0000,53500510.0000,52549869.0000,53753389.0000,53083500.0000,54173235.0000,48221788.0000,56275087.0000,53974077.0000,59804275.0000,51895819.0000,60469706.0000,58144298.0000,57319497.0000,54005617.0000,48791908.0000,53505008.0000,60480606.0000,52558715.0000,55423453.0000,60416014.0000,59726226.0000,60017629.0000,57166687.0000,56242886.0000,57084521.0000,56900473.0000,51004590.0000,51996540.0000,58049830.0000,59528412.0000,55653820.0000,52236255.0000,52897869.0000,53560685.0000,52543347.0000,50888341.0000,55036290.0000,54804652.0000,52870005.0000,48304565.0000,54062394.0000,55519045.0000,61671753.0000,60060229.0000,60905241.0000,57465613.0000,54813357.0000,52148959.0000,51764220.0000,54878050.0000,54902547.0000,53144486.0000,45666657.0000,53353952.0000,55243754.0000,54017349.0000,58957720.0000,60292260.0000,54976746.0000,56286088.0000,61992400.0000,61344392.0000,53459333.0000,62447302.0000,44269820.0000,57411680.0000,55805758.0000,53706000.0000,49705129.0000,48009336.0000,57979707.0000,56628516.0000,55081125.0000,57474160.0000,50894361.0000,55304488.0000,52960076.0000,57372035.0000,49285523.0000,54522868.0000,50942202.0000,60819067.0000,53224807.0000,55401351.0000,61169171.0000,55222603.0000,52411667.0000,49852658.0000,52525653.0000,50223140.0000,54998007.0000,53946796.0000,52681958.0000,56978250.0000,49265936.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,chain topology,100,1,514933700,4925400.0800,4878696.8900,5045991.0800,359385.8897,177093.3327,755701.8276,"4709151.0000,4742154.0000,7985669.0000,5250076.0000,5085334.0000,4699613.0000,5027804.0000,4722556.0000,4816123.0000,4743316.0000,4813338.0000,4732314.0000,4698340.0000,4915932.0000,4842764.0000,4743206.0000,4995333.0000,4971738.0000,4930630.0000,4967110.0000,4864786.0000,4888581.0000,4840028.0000,4756711.0000,4904962.0000,4880356.0000,4971678.0000,4793230.0000,4882028.0000,5202696.0000,4746181.0000,4954756.0000,4805012.0000,4906094.0000,4694032.0000,4890494.0000,5204660.0000,4929378.0000,4836812.0000,4702759.0000,4922956.0000,4907808.0000,4769175.0000,4876288.0000,4841591.0000,4887169.0000,5253984.0000,4758805.0000,5359713.0000,4857442.0000,5077539.0000,4832034.0000,5174703.0000,4789924.0000,4829268.0000,4716434.0000,4964855.0000,4889483.0000,5108548.0000,4697078.0000,4710312.0000,4865678.0000,4733357.0000,4918417.0000,4852663.0000,4741853.0000,4725371.0000,4866308.0000,4962852.0000,5376535.0000,4828166.0000,5242682.0000,5295743.0000,4857161.0000,4729058.0000,4706255.0000,4912025.0000,4757753.0000,4825803.0000,4869325.0000,4862672.0000,4799281.0000,4795925.0000,4628809.0000,5069613.0000,4724800.0000,5293919.0000,4685106.0000,5130159.0000,4723519.0000,5146319.0000,4725893.0000,5528103.0000,5376636.0000,4858043.0000,4955327.0000,4678873.0000,4726353.0000,4720392.0000,4770417.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,expanding tree topology,100,1,858136300,8673340.2100,8604332.6000,8857862.5600,536414.0893,258155.7535,1139698.9912,"8324060.0000,8517517.0000,13292996.0000,8883701.0000,8806074.0000,8776919.0000,8527085.0000,8801264.0000,8649819.0000,8682500.0000,8333368.0000,8464877.0000,8560408.0000,8601646.0000,8760488.0000,8682599.0000,8595194.0000,8417387.0000,8533357.0000,8561029.0000,9246379.0000,9196884.0000,8689553.0000,8857742.0000,9104659.0000,9008076.0000,9066718.0000,9058652.0000,8850548.0000,8495135.0000,8687800.0000,8424421.0000,8555159.0000,8326635.0000,9029065.0000,8617587.0000,8952781.0000,8649918.0000,8642525.0000,8825551.0000,8526374.0000,8584403.0000,8281520.0000,8327908.0000,8303031.0000,8626604.0000,8666058.0000,8708418.0000,8824238.0000,8510984.0000,8377131.0000,9354584.0000,8465047.0000,8690575.0000,8946079.0000,8818557.0000,8836060.0000,8856690.0000,8591877.0000,8626163.0000,8677290.0000,8431875.0000,8510954.0000,9062540.0000,9113446.0000,8921702.0000,8827996.0000,8997305.0000,8321936.0000,8046686.0000,8512256.0000,8145762.0000,8347104.0000,9086005.0000,8471740.0000,8865326.0000,8406357.0000,8918196.0000,8763644.0000,8583351.0000,8337165.0000,8490175.0000,8503732.0000,8417147.0000,8655267.0000,8513109.0000,8291448.0000,8438256.0000,8344459.0000,7838721.0000,8267443.0000,8267674.0000,8273725.0000,8676768.0000,8453937.0000,8593441.0000,8526223.0000,8491858.0000,8387431.0000,8574194.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,contracting tree topology,100,1,582436600,4646449.5000,4561075.4600,4828447.0400,604379.5708,263428.7767,1034367.8290,"4320735.0000,4260140.0000,8526644.0000,5289942.0000,4699173.0000,4821454.0000,4554959.0000,4615343.0000,4489825.0000,4697168.0000,4925221.0000,4977319.0000,4842533.0000,4603481.0000,4630171.0000,4526905.0000,4710043.0000,4726093.0000,4688261.0000,4449018.0000,4719149.0000,4618068.0000,4577081.0000,4776258.0000,4732795.0000,4587810.0000,4703790.0000,4409824.0000,4608330.0000,4738005.0000,4849105.0000,4737645.0000,4414102.0000,4643187.0000,4531495.0000,4439881.0000,4595666.0000,4909040.0000,4686087.0000,4623268.0000,4586328.0000,4646431.0000,4555389.0000,4615753.0000,4384986.0000,4818408.0000,4586309.0000,4677962.0000,4529330.0000,4289756.0000,4201599.0000,4260451.0000,4276772.0000,4337697.0000,4409263.0000,4644408.0000,4586398.0000,4616746.0000,4674647.0000,4500235.0000,4558566.0000,4530733.0000,4410505.0000,4589213.0000,4527637.0000,4237868.0000,4283304.0000,4266442.0000,4280638.0000,4274347.0000,4343729.0000,4320074.0000,4965626.0000,4585456.0000,4527667.0000,4761540.0000,4851140.0000,4819370.0000,4556291.0000,5787043.0000,8441833.0000,5081176.0000,4702558.0000,4205887.0000,4190988.0000,4128009.0000,4216878.0000,4241695.0000,4076352.0000,4157836.0000,4663364.0000,4617216.0000,4761970.0000,4497880.0000,4761611.0000,4413992.0000,4622016.0000,4466651.0000,4217509.0000,4248458.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,wave_sim topology,100,1,1812416500,19443608.6600,19099350.7000,19876351.0800,1961803.0221,1641396.5947,2493331.7923,"21660340.0000,21978833.0000,22942900.0000,19211890.0000,18795021.0000,18535680.0000,19100469.0000,19084650.0000,26010212.0000,18578711.0000,18179143.0000,18230872.0000,17981639.0000,18135921.0000,18009222.0000,18258955.0000,18587056.0000,18347723.0000,18145790.0000,17314966.0000,19730583.0000,20954181.0000,19106550.0000,21815333.0000,23573374.0000,19136176.0000,19240414.0000,19189889.0000,18909287.0000,18867308.0000,18424469.0000,17453819.0000,18777798.0000,18327685.0000,18199782.0000,21314044.0000,20838683.0000,18651649.0000,23651662.0000,19159792.0000,20615039.0000,20628334.0000,23745660.0000,18568461.0000,17424033.0000,23017772.0000,18001537.0000,21842525.0000,19124424.0000,18995310.0000,18949714.0000,21323621.0000,21551524.0000,17461083.0000,18130071.0000,22867527.0000,16871736.0000,18398288.0000,19040125.0000,17647647.0000,17356414.0000,18790462.0000,18049388.0000,17372354.0000,17775980.0000,18224239.0000,18315031.0000,18299432.0000,17730283.0000,18239949.0000,16993948.0000,17159471.0000,17693644.0000,18508607.0000,19452256.0000,20152653.0000,18898176.0000,17375371.0000,17518222.0000,18572318.0000,20408507.0000,20831099.0000,19260222.0000,27398362.0000,19998992.0000,19073508.0000,18453883.0000,17326278.0000,17198405.0000,22071218.0000,20045460.0000,19743918.0000,21621155.0000,22302777.0000,18987114.0000,21548948.0000,19044452.0000,21885947.0000,18820749.0000,19244772.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,jacobi topology,100,1,709279500,6719872.4200,6585085.8400,6944292.5100,870753.0891,586254.1916,1265206.7154,"6571119.0000,6681648.0000,10963040.0000,6374446.0000,6363996.0000,6493692.0000,6445350.0000,6512078.0000,6456572.0000,6387681.0000,6617587.0000,6288854.0000,6702689.0000,6361601.0000,6703239.0000,6391449.0000,6597079.0000,6463144.0000,6618168.0000,6294294.0000,6361862.0000,6008563.0000,6392731.0000,6000738.0000,6139842.0000,6426415.0000,5962306.0000,6227137.0000,6176491.0000,6258185.0000,6336183.0000,11052060.0000,7228384.0000,8948613.0000,7586774.0000,7019057.0000,7376675.0000,6252164.0000,6874955.0000,8321485.0000,7606340.0000,6785405.0000,6608350.0000,6994360.0000,6353065.0000,6583272.0000,6166272.0000,6658305.0000,6993099.0000,6342395.0000,6731653.0000,6566831.0000,6295316.0000,6618097.0000,6283694.0000,6800303.0000,6326435.0000,6711355.0000,6352785.0000,6763122.0000,6365649.0000,6444780.0000,6848304.0000,6098594.0000,6701766.0000,6427507.0000,6875466.0000,6463034.0000,6666690.0000,6365499.0000,6611546.0000,6796897.0000,6481960.0000,7641277.0000,10313581.0000,6331695.0000,6068406.0000,6284967.0000,6406808.0000,6675216.0000,6189506.0000,6772560.0000,6489865.0000,6365289.0000,6542485.0000,6219623.0000,6443036.0000,6762592.0000,6535162.0000,8922163.0000,5981241.0000,6347545.0000,5964961.0000,6570989.0000,6153457.0000,6735861.0000,6525693.0000,6530683.0000,6598069.0000,6688020.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,6830895000,68424802.0800,68179607.7600,68538113.4500,806483.1744,355279.6118,1398300.4348,"68488929.0000,68766395.0000,68159024.0000,68796632.0000,68096606.0000,68708275.0000,68182599.0000,68872055.0000,67310226.0000,63977341.0000,68747199.0000,68789960.0000,68168011.0000,68287868.0000,68879700.0000,68980130.0000,68800571.0000,68922621.0000,69032750.0000,68158634.0000,68335929.0000,68783498.0000,68169404.0000,67653947.0000,68741939.0000,68732080.0000,68839384.0000,68682165.0000,68119329.0000,68930676.0000,68912542.0000,68869350.0000,68818023.0000,68264455.0000,68842109.0000,68170426.0000,68757769.0000,68762828.0000,68396144.0000,68274262.0000,68287017.0000,68395702.0000,68664102.0000,68645546.0000,68094191.0000,68247531.0000,68813885.0000,68407104.0000,69037940.0000,69070902.0000,68342863.0000,68636870.0000,68532011.0000,68780743.0000,68190413.0000,68051831.0000,68205692.0000,68139667.0000,68369944.0000,68133616.0000,68953750.0000,68883827.0000,69161564.0000,68668549.0000,68619587.0000,68408346.0000,68420350.0000,68811260.0000,68199150.0000,68687776.0000,68523695.0000,68959180.0000,68182779.0000,68277268.0000,68881382.0000,68209149.0000,68968227.0000,68671194.0000,68349696.0000,69040935.0000,68248424.0000,67558306.0000,62743653.0000,68544124.0000,68172490.0000,68300623.0000,68159054.0000,68233335.0000,68854932.0000,68837931.0000,68570314.0000,68270435.0000,68243384.0000,68389231.0000,68563901.0000,68783077.0000,68683848.0000,68473089.0000,68858019.0000,68885019.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,371953600,3787358.0300,3756256.5500,3807608.3600,126316.1297,89512.6213,161017.7915,"3822410.0000,3814887.0000,3862266.0000,3827670.0000,3849562.0000,3833652.0000,3846726.0000,3828261.0000,3835145.0000,3896020.0000,3843111.0000,3833011.0000,3844673.0000,3827951.0000,3842579.0000,3829604.0000,3837960.0000,3830776.0000,3828061.0000,3836948.0000,3831257.0000,3816490.0000,3824905.0000,3821719.0000,3820417.0000,3824755.0000,3829444.0000,3833482.0000,3824154.0000,3830516.0000,3829765.0000,3823944.0000,3830125.0000,3814114.0000,3827951.0000,3819595.0000,3831548.0000,3821820.0000,3817641.0000,3820346.0000,3822932.0000,3825176.0000,3834734.0000,3835074.0000,3836306.0000,3819865.0000,3822260.0000,3816229.0000,3830626.0000,3829796.0000,3834022.0000,3823662.0000,3829293.0000,3828933.0000,3828703.0000,3837459.0000,3822651.0000,3831929.0000,3827761.0000,3829163.0000,3825006.0000,3826609.0000,3826558.0000,3832650.0000,3832449.0000,3824956.0000,3823653.0000,3818543.0000,3824466.0000,3834052.0000,3383309.0000,3398477.0000,3381695.0000,3389941.0000,3380663.0000,3384691.0000,3384901.0000,3403808.0000,3408656.0000,3662518.0000,3832490.0000,3825146.0000,3838862.0000,3815527.0000,3835074.0000,3823062.0000,3823994.0000,3816990.0000,3824695.0000,3810919.0000,3821880.0000,3810217.0000,3811960.0000,3823373.0000,3824374.0000,3826980.0000,3833511.0000,3813954.0000,3820538.0000,3822821.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,1013758300,10093770.9000,10039097.8700,10119273.2000,182216.0722,108859.9096,285698.9267,"10168646.0000,10117167.0000,10205355.0000,10157705.0000,10154248.0000,10113170.0000,10150722.0000,10158265.0000,10177102.0000,10111897.0000,10124162.0000,10101548.0000,10172001.0000,10097390.0000,10118071.0000,10138047.0000,10107409.0000,10089896.0000,10108442.0000,10133037.0000,10096399.0000,10101288.0000,10136104.0000,10128699.0000,10155550.0000,10135163.0000,10103261.0000,10137987.0000,10103181.0000,10157544.0000,10099093.0000,10122287.0000,10084797.0000,10122017.0000,10099784.0000,10110855.0000,10099595.0000,10108210.0000,10117899.0000,10132977.0000,10109895.0000,10090557.0000,10093273.0000,10101728.0000,10133199.0000,10179625.0000,10105024.0000,10161212.0000,10111457.0000,10118911.0000,10202239.0000,10088074.0000,10142846.0000,10174927.0000,10141905.0000,10145522.0000,10147285.0000,10157664.0000,10105956.0000,10110144.0000,10115445.0000,10101217.0000,9895798.0000,9084260.0000,9087697.0000,9089170.0000,9887914.0000,10126375.0000,10115765.0000,10105846.0000,10172714.0000,10146674.0000,10151783.0000,10104303.0000,10105776.0000,10152454.0000,10162794.0000,10160721.0000,10145101.0000,10157364.0000,10167623.0000,10113792.0000,10159978.0000,10140000.0000,10097249.0000,10173755.0000,10153437.0000,10121115.0000,10117949.0000,10121517.0000,10092481.0000,10111958.0000,10097540.0000,10098143.0000,10149218.0000,10157143.0000,10106628.0000,10112600.0000,10171831.0000,10165549.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,424588700,4245059.6300,4243465.4500,4246466.1300,7687.2157,6596.4617,9545.0747,"4246294.0000,4254881.0000,4249229.0000,4242888.0000,4225925.0000,4229512.0000,4237387.0000,4243219.0000,4251744.0000,4239311.0000,4238599.0000,4243649.0000,4248969.0000,4251634.0000,4247426.0000,4246975.0000,4248438.0000,4251414.0000,4249951.0000,4241234.0000,4228160.0000,4246885.0000,4240583.0000,4238639.0000,4240653.0000,4245893.0000,4238128.0000,4247746.0000,4239782.0000,4247856.0000,4260119.0000,4238809.0000,4239812.0000,4253688.0000,4231646.0000,4251725.0000,4242055.0000,4250201.0000,4257996.0000,4249470.0000,4236635.0000,4243910.0000,4238308.0000,4239070.0000,4243679.0000,4244310.0000,4250412.0000,4245212.0000,4246384.0000,4258717.0000,4240002.0000,4235954.0000,4232708.0000,4215445.0000,4228290.0000,4246925.0000,4249499.0000,4241404.0000,4246084.0000,4242025.0000,4254339.0000,4243899.0000,4238689.0000,4248769.0000,4256273.0000,4248107.0000,4251874.0000,4235453.0000,4246083.0000,4240783.0000,4247346.0000,4248288.0000,4254810.0000,4244721.0000,4262083.0000,4243900.0000,4251764.0000,4247766.0000,4256833.0000,4254760.0000,4254019.0000,4249259.0000,4255943.0000,4241405.0000,4247546.0000,4252556.0000,4236735.0000,4254990.0000,4243037.0000,4248387.0000,4243128.0000,4242517.0000,4241866.0000,4251183.0000,4239732.0000,4243839.0000,4248758.0000,4241073.0000,4242717.0000,4247235.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,1803884200,17979225.9900,17915856.4900,18012437.7800,225042.2098,119992.8479,412664.2632,"18028958.0000,18031544.0000,18134198.0000,18010905.0000,17996337.0000,17988783.0000,18008780.0000,18008050.0000,18071459.0000,17981259.0000,17987730.0000,17980056.0000,18002589.0000,18001367.0000,18016596.0000,17985797.0000,18004002.0000,17997539.0000,18009152.0000,17984404.0000,17984044.0000,17989674.0000,18024059.0000,18029681.0000,18048656.0000,18010925.0000,18018589.0000,18001948.0000,18013019.0000,18010453.0000,17972973.0000,18054627.0000,18001497.0000,17997820.0000,18005525.0000,17995655.0000,17950099.0000,17986689.0000,18019230.0000,18007028.0000,18004021.0000,18008812.0000,17982450.0000,17968675.0000,18006066.0000,18002508.0000,18015564.0000,18008590.0000,17989264.0000,17980065.0000,17968544.0000,17980827.0000,17984504.0000,17979966.0000,18004823.0000,17976951.0000,17980146.0000,17983323.0000,18006917.0000,17993852.0000,17982080.0000,18013800.0000,17996929.0000,18005204.0000,18007548.0000,17992339.0000,17986969.0000,17995957.0000,17985736.0000,17948967.0000,17994584.0000,18015934.0000,17991577.0000,17990586.0000,18008190.0000,18003209.0000,17982741.0000,18030652.0000,17990857.0000,18023718.0000,18047374.0000,17978904.0000,17994093.0000,17969116.0000,18033848.0000,17994975.0000,18006416.0000,17705666.0000,18955575.0000,17304636.0000,16300755.0000,17182906.0000,18045691.0000,18061069.0000,18045730.0000,18036233.0000,18040040.0000,18031183.0000,18030903.0000,18032345.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,607530800,6028284.5000,5991033.4500,6051205.9400,143159.2002,88083.9110,198281.7121,"6066453.0000,6055872.0000,6075300.0000,6055281.0000,6056333.0000,6070841.0000,6065922.0000,6069188.0000,6073936.0000,6080298.0000,6060422.0000,6060230.0000,6054090.0000,6067595.0000,6052296.0000,6068266.0000,6059920.0000,6063818.0000,6052336.0000,6071662.0000,6050142.0000,6063398.0000,6061703.0000,6061413.0000,6054971.0000,6048038.0000,6061914.0000,6045192.0000,6063007.0000,6062064.0000,6052015.0000,6056173.0000,6068076.0000,6047897.0000,6053949.0000,6059069.0000,6072745.0000,6067875.0000,6069419.0000,6066703.0000,6074127.0000,6055301.0000,6056464.0000,6050603.0000,6057766.0000,6055622.0000,6065410.0000,6062575.0000,6070370.0000,6068887.0000,6077184.0000,6059179.0000,6075059.0000,6061082.0000,6073055.0000,6049190.0000,6070721.0000,6045614.0000,6055181.0000,6066312.0000,6066151.0000,6069708.0000,6065000.0000,6063808.0000,6050833.0000,6070140.0000,6063357.0000,6065631.0000,6050272.0000,6071763.0000,6062405.0000,6063837.0000,6062105.0000,6055772.0000,6062325.0000,6074648.0000,6061172.0000,6082042.0000,6070901.0000,6076512.0000,6062325.0000,6070170.0000,6062545.0000,6069428.0000,6095147.0000,6078305.0000,6076152.0000,6085579.0000,6074848.0000,6081791.0000,6071252.0000,6054660.0000,6060131.0000,5437962.0000,5440106.0000,5449344.0000,5439104.0000,5437500.0000,5587845.0000,6070350.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,6203781200,55457495.1900,54775692.6200,56211792.8200,3652289.0474,3145352.0645,4318251.0684,"56622995.0000,48199966.0000,51630466.0000,54964112.0000,55901068.0000,55736056.0000,47902362.0000,52746370.0000,51444714.0000,55086083.0000,55604706.0000,50848965.0000,56600904.0000,54738555.0000,60059076.0000,61560621.0000,61639922.0000,51422572.0000,51718192.0000,55259792.0000,54248827.0000,56842542.0000,58964492.0000,48818447.0000,53282606.0000,57383807.0000,53644392.0000,57915193.0000,54431283.0000,48847873.0000,54462121.0000,54336813.0000,54222798.0000,57348861.0000,59028524.0000,65791407.0000,49182888.0000,54174105.0000,54633225.0000,60446620.0000,54110956.0000,54032017.0000,51700188.0000,54418117.0000,58470446.0000,55425897.0000,56799970.0000,54656309.0000,51906719.0000,55181265.0000,52894792.0000,52321595.0000,54197199.0000,53278909.0000,56211145.0000,52500955.0000,60816982.0000,54879692.0000,65844929.0000,54798969.0000,55714013.0000,61124806.0000,51597493.0000,53210950.0000,53965650.0000,54300415.0000,53496371.0000,54637804.0000,54084195.0000,52858533.0000,56307338.0000,59083327.0000,55519725.0000,53270623.0000,53694837.0000,59186914.0000,58933985.0000,55411640.0000,52807165.0000,50929708.0000,54734808.0000,60243736.0000,58137966.0000,54437174.0000,61312481.0000,53573868.0000,51789717.0000,53230097.0000,59879716.0000,53415308.0000,53224476.0000,56157894.0000,55414044.0000,61571662.0000,60837371.0000,60013510.0000,61405527.0000,54600152.0000,53251777.0000,66241371.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,647310000,6336548.0500,6200762.9200,6476732.1200,698011.4034,633984.4687,775829.4540,"5212044.0000,5344535.0000,7027193.0000,6320544.0000,5936928.0000,6041815.0000,7466525.0000,6649006.0000,5806760.0000,5561676.0000,7015310.0000,6570187.0000,5620918.0000,6099857.0000,6610654.0000,7030879.0000,5546467.0000,5628312.0000,6558284.0000,6696817.0000,5697273.0000,7130739.0000,6650670.0000,6573664.0000,7519986.0000,5845824.0000,6724219.0000,6671319.0000,5779189.0000,5502965.0000,6222588.0000,7367097.0000,5863338.0000,6171882.0000,6794512.0000,6403110.0000,5056529.0000,6457614.0000,6215304.0000,5595089.0000,5428935.0000,6366981.0000,7019268.0000,5213225.0000,7368900.0000,6225043.0000,5420339.0000,5459994.0000,6699162.0000,6596167.0000,6112089.0000,6240733.0000,7023325.0000,6259458.0000,5765422.0000,5385893.0000,5334235.0000,5410781.0000,6504093.0000,7866604.0000,6587750.0000,5547139.0000,5403256.0000,7328213.0000,6689022.0000,6212109.0000,6983311.0000,6460700.0000,7900147.0000,5998704.0000,5648701.0000,5612843.0000,7136440.0000,7400911.0000,6306057.0000,7147852.0000,5390772.0000,7240217.0000,6419181.0000,5585150.0000,5723512.0000,7220880.0000,6303512.0000,5633502.0000,6328770.0000,7628893.0000,6265480.0000,5409358.0000,5845775.0000,6916674.0000,6784293.0000,6755978.0000,7168811.0000,5534224.0000,7360314.0000,6448486.0000,6006379.0000,7365454.0000,7335297.0000,5932469.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,944526800,9545757.7000,9428823.6200,9789512.5700,828545.1773,417136.1126,1450950.0407,"9183990.0000,9072899.0000,15378166.0000,13795658.0000,9530207.0000,9204749.0000,9606059.0000,9371565.0000,9625717.0000,9241098.0000,9152941.0000,9167768.0000,8562071.0000,8425642.0000,8664986.0000,9222322.0000,9337270.0000,9297495.0000,9009649.0000,9206141.0000,9480521.0000,9599316.0000,9493716.0000,9411010.0000,9239374.0000,9271926.0000,9694386.0000,9672004.0000,9602934.0000,9628933.0000,9230488.0000,9408284.0000,9628782.0000,9280031.0000,9102305.0000,9206282.0000,9563470.0000,9372277.0000,9637499.0000,9696331.0000,9805988.0000,9133223.0000,9101894.0000,9296913.0000,9174662.0000,9354373.0000,9545735.0000,9976050.0000,9628392.0000,9495660.0000,9559571.0000,9613433.0000,9304759.0000,9195031.0000,9396242.0000,9391713.0000,9458299.0000,9942406.0000,9883485.0000,9665181.0000,9255555.0000,9157419.0000,9387245.0000,9411120.0000,11441176.0000,10378793.0000,9078770.0000,9204529.0000,9484659.0000,9494287.0000,9866432.0000,9835925.0000,9164021.0000,9192886.0000,9976351.0000,9794416.0000,9529674.0000,9200541.0000,9287886.0000,9290431.0000,9912120.0000,9511230.0000,9628581.0000,9301302.0000,9742859.0000,9536007.0000,9300221.0000,9486803.0000,9318845.0000,9226149.0000,10817244.0000,8800603.0000,8767871.0000,9534524.0000,9934131.0000,9612512.0000,9952155.0000,9187696.0000,9344383.0000,9029146.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,549935000,6523877.3900,6379466.0400,6673606.3800,752577.1051,676401.6151,842194.2556,"6334200.0000,6536964.0000,7584810.0000,5264684.0000,4780907.0000,5322523.0000,6076853.0000,6868142.0000,6245742.0000,7520447.0000,6111157.0000,6055301.0000,5863118.0000,7598506.0000,6351131.0000,5973577.0000,5993174.0000,5887293.0000,7474460.0000,6899811.0000,5973677.0000,6306387.0000,7709376.0000,6581218.0000,6627916.0000,7158602.0000,6009554.0000,6181550.0000,7275233.0000,7122804.0000,6189746.0000,5973476.0000,7863087.0000,6639658.0000,6949025.0000,7431970.0000,6110215.0000,7583567.0000,6357945.0000,6063206.0000,6121747.0000,6470498.0000,7705619.0000,6620833.0000,5658881.0000,5460705.0000,7170344.0000,5939412.0000,5287306.0000,5431129.0000,6310344.0000,6841962.0000,5377999.0000,6406236.0000,6069207.0000,5440406.0000,6530341.0000,7795408.0000,6134441.0000,6070740.0000,6152415.0000,7789116.0000,6736032.0000,7385151.0000,7038114.0000,6673132.0000,7937207.0000,6088714.0000,5749873.0000,6458355.0000,7679388.0000,6305906.0000,8053127.0000,7917179.0000,6209924.0000,6426785.0000,7547198.0000,6278094.0000,6137117.0000,7562387.0000,6247806.0000,5578849.0000,5863969.0000,6371901.0000,7254313.0000,6483292.0000,5876672.0000,7205260.0000,6552834.0000,5790990.0000,6246804.0000,7746426.0000,6519090.0000,6953053.0000,7504638.0000,6023471.0000,7536077.0000,6079647.0000,5282908.0000,5449955.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,3013304500,29784677.7200,29382839.9100,30240396.1600,2178207.2030,1848556.0016,2675201.3300,"32144364.0000,32062929.0000,26402724.0000,30258742.0000,31529779.0000,30025610.0000,29874052.0000,28905478.0000,28760753.0000,26543031.0000,27062446.0000,27144621.0000,29144480.0000,30086404.0000,28645685.0000,32101773.0000,30094650.0000,29999049.0000,29488862.0000,28392957.0000,29871467.0000,29833756.0000,30227372.0000,26070836.0000,28513124.0000,29258506.0000,30513405.0000,32050306.0000,30329966.0000,37382098.0000,29438597.0000,30984738.0000,30061778.0000,30881582.0000,31448254.0000,30453861.0000,29987036.0000,31400694.0000,28862526.0000,28261036.0000,32007385.0000,29437966.0000,28209458.0000,28125660.0000,27849095.0000,27972190.0000,27882839.0000,29664876.0000,33870275.0000,30100301.0000,29962020.0000,32497523.0000,35028530.0000,33739126.0000,29181050.0000,27417357.0000,29608269.0000,30449323.0000,31919929.0000,37237996.0000,26245887.0000,27295776.0000,25894783.0000,26095082.0000,28000953.0000,27469016.0000,28462737.0000,28464552.0000,30976380.0000,29843273.0000,29981156.0000,30248311.0000,27906655.0000,29004665.0000,33865264.0000,26109651.0000,27591788.0000,28125059.0000,27329972.0000,31184876.0000,30384360.0000,31689041.0000,30805217.0000,29199363.0000,29429900.0000,27263186.0000,28883094.0000,30220618.0000,33103953.0000,29378443.0000,29801926.0000,27236815.0000,27392430.0000,30380032.0000,29707296.0000,30262950.0000,31899881.0000,32736646.0000,32141258.0000,29795032.0000" -building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,1129651400,11175543.7100,10959415.5200,11387631.7100,1091582.4343,992174.5520,1216229.6478,"10299322.0000,12652152.0000,13603704.0000,11055797.0000,12168935.0000,11500409.0000,11845111.0000,12023088.0000,9975469.0000,10606515.0000,11363680.0000,9657978.0000,12047405.0000,11744451.0000,9637900.0000,11823912.0000,12632834.0000,9100612.0000,11257268.0000,11658619.0000,12714960.0000,11934501.0000,9369541.0000,9093458.0000,12400264.0000,10686808.0000,13072898.0000,10351261.0000,11992671.0000,12056181.0000,9789166.0000,9956223.0000,11512392.0000,10197580.0000,9838299.0000,11576934.0000,12249909.0000,10052165.0000,12789581.0000,11572996.0000,9986851.0000,12595703.0000,11089209.0000,10461861.0000,12895472.0000,12132356.0000,11126660.0000,11966232.0000,10158356.0000,11569510.0000,12756910.0000,9993053.0000,10641581.0000,11820114.0000,11195461.0000,12118389.0000,9351116.0000,12016026.0000,9980208.0000,11489979.0000,10127958.0000,11656093.0000,10332667.0000,12788018.0000,11176234.0000,10084866.0000,11398566.0000,10220814.0000,11466094.0000,10515623.0000,12246843.0000,9811719.0000,10962139.0000,11762225.0000,11749230.0000,11210690.0000,12534438.0000,10581297.0000,12299593.0000,12271690.0000,9922699.0000,10343927.0000,10746760.0000,9882904.0000,8979262.0000,12213290.0000,11541346.0000,9668808.0000,11839381.0000,10251482.0000,11639251.0000,10106597.0000,10783811.0000,11298627.0000,8916733.0000,11446978.0000,12523227.0000,10062554.0000,12971576.0000,12010365.0000" +benchmark intrusive graph dependency handling with N nodes - 1,creating nodes,100,5586,2234400,8.7024,8.6969,8.7242,0.0530,0.0023,0.1265,"8.6967,8.6914,8.6951,8.6985,8.6967,8.6985,8.7003,8.6985,8.6914,8.6985,8.6985,8.6967,8.6985,8.6985,8.6914,8.6985,8.6985,8.6987,8.6985,8.6967,8.6950,8.6950,8.7003,8.6985,8.6967,8.6985,8.6985,8.6932,8.6985,8.6985,8.6967,8.6987,8.6985,8.6914,8.6985,8.6967,8.6985,8.6985,8.6985,8.6914,8.6967,8.6967,8.6967,8.6967,8.6985,8.6914,9.2295,8.6985,8.6967,8.6969,8.6967,8.6985,8.6914,8.6985,8.6985,8.6967,8.7003,8.7003,8.6932,8.6967,8.6967,8.6967,8.6985,8.6985,8.6914,8.6985,8.6985,8.6985,8.6985,8.6985,8.6914,8.6967,8.6987,8.6985,8.6967,8.6967,8.6914,8.6985,8.6985,8.6985,8.6985,8.6967,8.6932,8.6985,8.6985,8.6985,8.6967,8.6987,8.6985,8.6932,8.6985,8.6967,8.6985,8.6985,8.6985,8.6932,8.6985,8.6967,8.6985,8.6967" +benchmark intrusive graph dependency handling with N nodes - 1,creating and adding dependencies,100,1046,2405800,27.7235,27.6734,27.9255,0.4537,0.0806,1.0668,"27.5363,27.5746,27.6797,27.6606,27.6702,27.6702,27.6797,27.6597,27.7945,27.7753,27.6702,27.5927,27.6788,27.7753,27.8040,27.7084,27.5641,27.6597,27.7954,27.7753,27.6702,27.5927,32.1616,27.5268,27.7180,27.7658,27.7945,27.5363,27.6511,27.5268,27.7180,27.7753,27.8040,27.7753,27.6415,27.6128,27.6415,27.5258,27.7275,27.7753,27.6319,27.5363,27.7180,27.6128,27.6319,27.5354,27.5650,27.6893,27.8040,27.6989,27.7180,27.6893,27.7084,27.7753,27.8050,27.7753,27.7945,27.6893,27.5650,27.6989,27.8040,27.7658,27.6415,27.6893,27.6415,27.5354,27.5650,27.6893,27.6606,27.6893,27.8040,27.6989,27.5650,27.6128,27.6405,27.5268,27.6319,27.6893,27.6415,27.6128,27.6405,27.5354,27.7084,27.6989,27.5554,27.6797,27.7945,27.6224,27.7084,27.7753,27.7275,27.6033,27.7084,27.7658,27.6606,27.6893,27.8040,27.7753,27.6989,27.7849" +benchmark intrusive graph dependency handling with N nodes - 1,adding and removing dependencies,100,1516,2425600,16.1106,16.0696,16.2730,0.3855,0.0386,0.9154,"16.0778,16.1642,16.2230,16.0251,15.9591,16.0119,15.9789,16.0317,16.0778,16.0383,16.0119,15.9782,16.0515,15.9525,16.0383,16.0580,16.1774,16.0778,16.0251,16.0851,16.1570,16.0712,16.0587,16.0778,16.0580,16.0844,16.0653,16.0844,16.0580,16.0778,16.0587,16.0778,16.0580,16.0778,16.0521,16.0580,16.0844,16.0646,16.0851,16.1504,16.0778,16.1247,16.0778,15.9789,16.0778,16.0587,16.0778,16.0580,16.0844,16.0646,16.0844,16.0580,16.0580,16.0851,16.1636,16.0785,16.0580,16.0844,16.0580,16.0785,19.9241,16.0910,16.0580,16.0851,16.0580,16.0778,16.0580,16.0587,16.0778,16.0778,16.0778,16.0646,16.0844,16.0580,16.0851,16.0449,16.0910,16.0580,16.0785,16.0910,16.0778,16.0580,16.0785,16.0580,16.0778,16.1642,16.0646,16.0712,16.1840,16.0844,16.0580,16.0719,16.1306,16.0778,16.0580,16.0844,16.0844,16.0646,16.0653,16.0580" +benchmark intrusive graph dependency handling with N nodes - 1,checking for dependencies,100,19795,1979500,1.2278,1.2253,1.2378,0.0232,0.0036,0.0546,"1.2298,1.2222,1.2303,1.2227,1.2288,1.2232,1.2222,1.2304,1.2222,1.2293,1.2232,1.2217,1.2308,1.2222,1.2298,1.2227,1.2293,1.2232,1.2212,1.2298,1.2222,1.2294,1.2232,1.2293,1.2227,1.2217,1.2298,1.2222,1.2293,1.2232,1.2217,1.2298,1.2222,1.2298,1.2227,1.2293,1.2227,1.2217,1.2298,1.2227,1.2294,1.2232,1.2217,1.2303,1.2222,1.2293,1.2227,1.2293,1.2232,1.2217,1.2303,1.2227,1.2298,1.2232,1.2217,1.2303,1.2222,1.2299,1.2227,1.2298,1.2232,1.2212,1.2303,1.2222,1.2298,1.2237,1.2293,1.2227,1.2222,1.2303,1.4556,1.2298,1.2227,1.2288,1.2232,1.2222,1.2304,1.2227,1.2293,1.2232,1.2217,1.2298,1.2222,1.2293,1.2227,1.2288,1.2227,1.2217,1.2298,1.2222,1.2293,1.2227,1.2217,1.2303,1.2222,1.2299,1.2222,1.2293,1.2232,1.2217" +benchmark intrusive graph dependency handling with N nodes - 10,creating nodes,100,642,2375400,39.4050,39.3780,39.4318,0.1377,0.1212,0.1577,"39.5109,39.3863,39.3536,39.2913,39.3707,39.3707,39.5125,39.3707,39.5109,39.4642,39.3240,39.3707,39.3707,39.5109,39.1682,39.4174,39.3707,39.4953,39.3707,39.5109,39.3551,39.3707,39.3240,39.4486,39.4953,39.2150,39.5576,39.1371,39.1371,39.7134,39.5265,39.4174,39.3707,39.4330,39.1838,39.4953,39.1215,39.5732,39.4486,39.3707,39.6044,39.4486,39.3240,39.3707,39.3707,39.7150,39.4953,39.2617,39.2461,39.5109,39.4174,39.2773,39.3707,39.3863,39.5109,39.3707,39.5109,39.3707,39.4953,39.3707,39.3551,39.5109,39.3707,39.6526,39.2445,39.5748,39.1667,39.4174,39.4330,39.3692,39.6667,39.2617,39.4953,39.3707,39.5421,39.1215,39.3707,39.7134,39.3084,39.6355,39.2305,39.4486,39.1838,39.1215,39.4953,39.3707,39.5109,39.3707,39.4953,39.3084,39.2928,39.3707,39.6044,39.6526,39.2913,39.5125,39.3707,39.5732,39.1682,39.3692" +benchmark intrusive graph dependency handling with N nodes - 10,creating and adding dependencies,100,92,2428800,270.8875,270.2549,273.3613,5.8519,0.7809,13.8558,"270.7065,271.4674,273.5435,271.1522,270.2717,270.1630,270.9239,269.9457,270.8261,269.9457,270.9239,269.9457,270.0652,270.5978,270.0543,270.8152,269.9457,271.0435,269.9457,270.7065,270.0543,270.0652,270.7065,269.9457,270.7065,269.9457,270.9348,270.0543,269.9457,270.7065,270.0543,270.7065,269.0761,270.1630,269.2935,269.1848,270.3804,269.4022,270.0543,269.1848,270.2717,269.5109,269.1848,270.1630,269.1848,270.0543,269.1848,270.1630,269.0761,269.2935,270.0543,269.0761,269.9457,269.0761,270.0543,269.0761,269.0761,270.1630,269.5109,270.2717,269.0652,269.2935,269.5109,269.0761,270.0543,269.2935,270.2717,269.1848,269.2935,270.2717,269.4022,270.1739,328.5326,271.5761,270.7174,271.4674,270.5978,270.7174,271.6848,270.7065,271.5870,270.8152,271.5870,270.7065,270.7065,271.5870,270.7065,271.5761,270.7174,271.6848,270.7065,270.6087,271.4674,270.5978,271.5870,270.7065,271.6848,270.7065,270.7065,271.4674" +benchmark intrusive graph dependency handling with N nodes - 10,adding and removing dependencies,100,120,2424000,208.8143,208.2562,211.4736,5.3475,0.3344,12.7319,"208.7083,207.8750,209.8833,208.9667,208.4583,208.2917,208.9583,208.5500,208.8750,208.3833,208.7083,208.3833,208.6250,208.8833,208.2917,208.8833,208.4583,208.9667,208.3750,208.3000,208.8750,208.5417,208.9667,208.6250,208.8000,208.3750,208.8833,207.9583,208.0500,208.2917,207.8750,208.3833,207.8750,208.4667,207.7917,207.9583,208.3750,207.9583,208.4667,207.8750,208.3000,207.8750,208.0417,208.3000,207.9583,208.4667,207.9583,208.3833,207.8750,207.9583,208.3000,207.9583,208.3000,207.8750,208.3750,207.8833,207.9583,208.3000,207.9583,208.2917,207.9667,208.4583,207.8000,207.9583,208.4667,207.9583,208.2917,207.8833,208.3750,207.8833,207.9583,208.3750,207.9667,208.3750,207.9667,208.3750,207.8750,208.3750,207.8750,207.9667,208.3750,207.9667,208.5417,207.8750,261.9000,207.8750,208.2917,208.2083,207.9667,208.5417,208.0500,208.5417,208.1333,208.4583,207.8750,208.1333,208.4583,207.9667,208.4583,208.1333" +benchmark intrusive graph dependency handling with N nodes - 10,checking for dependencies,100,957,2392500,26.4029,26.3484,26.6063,0.4924,0.0439,1.1603,"31.2268,25.6050,26.4744,26.3281,26.4117,26.3281,26.4117,26.3271,26.3281,26.4117,26.3177,26.4117,26.3177,26.4117,26.3281,26.4013,26.3375,26.3166,26.4117,26.3281,26.4013,26.3281,26.4117,26.3281,26.3386,26.4013,26.3166,26.4117,26.3281,26.4013,26.3281,26.3281,26.4013,26.3281,26.4013,26.3166,26.4107,26.3281,26.4013,26.3281,26.3281,26.4013,26.3281,26.4117,26.3177,26.4107,26.3271,26.3281,26.4222,26.3177,26.4117,26.3177,26.4117,26.3281,26.4013,26.3271,26.3281,26.4013,26.3281,26.4117,26.3177,26.4117,26.3177,26.3166,26.4107,26.3271,26.4013,26.3281,26.4117,26.3281,26.3177,26.4117,26.3281,26.4013,26.3166,26.4117,26.3281,26.4013,26.3281,26.3281,26.4013,26.3177,26.4117,26.3271,26.4002,26.3271,26.3281,26.4013,26.3281,26.4117,26.3281,26.4013,26.3166,26.3271,26.4117,26.3177,26.4117,26.3281,26.4013,26.3177" +benchmark intrusive graph dependency handling with N nodes - 100,creating nodes,100,59,2466200,431.1924,430.4486,434.0841,6.7535,1.1528,15.8954,"430.6102,429.7627,431.4576,428.4068,431.8136,429.7627,430.9492,429.0847,430.7797,429.5932,432.8136,429.5932,430.7797,431.6271,429.0847,431.2881,429.0847,430.7966,429.0847,428.2373,430.7797,429.0847,431.4576,430.1017,432.3220,429.9322,432.6441,430.9661,429.2542,430.9492,429.2542,430.6102,429.0847,431.1356,430.6102,429.0847,431.4576,429.9322,432.1356,430.6102,431.9831,430.7797,432.6441,429.0847,430.6271,431.2881,429.0847,432.1356,430.2881,431.4576,429.0847,428.9153,432.6441,430.7797,431.6271,429.0847,432.1525,429.7627,432.1356,429.0847,430.6102,431.8136,429.2542,431.2881,429.7627,432.3220,430.7797,431.2881,430.9661,429.7627,432.1356,429.7627,431.4746,429.0847,431.2881,430.6102,429.0847,430.7966,429.0847,431.2881,430.7797,431.8136,429.0847,497.3390,430.4576,430.4407,433.3220,430.7966,431.9661,429.0847,430.9492,429.2542,430.9661,428.4068,428.4068,431.2881,429.0847,431.4576,429.9322,431.2881" +benchmark intrusive graph dependency handling with N nodes - 100,creating and adding dependencies,100,6,2556600,4288.8617,4284.6133,4294.0383,23.8647,19.3716,35.8207,"4257.6667,4274.5000,4416.3333,4282.8333,4296.1667,4301.1667,4289.5000,4274.3333,4229.3333,4307.8333,4279.3333,4269.5000,4306.1667,4282.8333,4304.5000,4266.0000,4324.6667,4256.0000,4294.5000,4252.6667,4282.6667,4287.8333,4281.1667,4302.8333,4279.5000,4287.6667,4297.8333,4299.5000,4289.5000,4274.5000,4329.5000,4276.1667,4319.5000,4259.5000,4311.1667,4274.3333,4306.1667,4294.5000,4321.3333,4317.8333,4287.8333,4322.8333,4292.8333,4294.5000,4272.6667,4309.5000,4286.1667,4286.1667,4294.5000,4264.5000,4299.3333,4281.0000,4311.1667,4271.1667,4319.5000,4267.8333,4279.5000,4306.1667,4272.6667,4314.5000,4271.1667,4302.8333,4269.5000,4304.5000,4284.3333,4257.6667,4307.8333,4262.8333,4317.8333,4264.3333,4304.5000,4292.8333,4294.5000,4279.5000,4252.6667,4304.5000,4256.1667,4297.8333,4262.6667,4309.5000,4292.6667,4321.3333,4257.6667,4272.8333,4294.5000,4262.6667,4286.1667,4277.8333,4299.5000,4282.6667,4304.3333,4284.3333,4257.8333,4331.1667,4276.1667,4284.5000,4259.3333,4291.1667,4282.8333,4276.0000" +benchmark intrusive graph dependency handling with N nodes - 100,adding and removing dependencies,100,6,2626200,4536.9850,4527.5583,4577.9667,86.4934,13.2834,204.1836,"4540.0000,4560.0000,4548.1667,4526.6667,4503.1667,4540.0000,4504.8333,4521.6667,4508.1667,4498.1667,4526.6667,4514.8333,4528.3333,4511.5000,4525.0000,4509.8333,4533.3333,4511.5000,4541.6667,4521.5000,4548.1667,4513.3333,4528.1667,4513.3333,4533.1667,4513.3333,4514.8333,4525.0000,4516.5000,4543.3333,4504.8333,4530.0000,4511.5000,4516.6667,4511.5000,4533.3333,4508.1667,4526.5000,4504.8333,4521.5000,4513.3333,4518.1667,4535.0000,4518.1667,5386.6667,4514.8333,4541.6667,4521.5000,4533.3333,4514.8333,4546.6667,4528.3333,4549.8333,4519.8333,4541.6667,4519.8333,4540.0000,4534.8333,4539.8333,4516.6667,4523.1667,4540.0000,4523.1667,4545.0000,4526.6667,4543.1667,4523.3333,4546.6667,4524.8333,4548.3333,4525.0000,4549.8333,4543.3333,4548.3333,4526.5000,4544.8333,4523.3333,4519.8333,4536.6667,4521.5000,4553.3333,4526.6667,4533.1667,4520.0000,4540.0000,4529.8333,4541.6667,4521.5000,4533.3333,4528.3333,4538.1667,4520.0000,4518.1667,4545.0000,4519.8333,4551.5000,4528.3333,4550.0000,4529.8333,4558.3333" +benchmark intrusive graph dependency handling with N nodes - 100,checking for dependencies,100,15,2479500,1688.7027,1680.5887,1702.8827,53.0913,36.1699,99.8235,"1654.3333,1648.3333,1681.7333,1718.4667,1733.1333,1724.4667,1727.8667,1717.8000,1725.8000,1721.8000,1721.1333,1728.4667,1722.4667,1723.1333,1719.1333,1728.4667,1717.1333,1717.8000,1717.8000,1714.4667,1725.1333,1716.4667,1722.4667,1716.4667,1723.1333,1715.1333,1723.1333,1718.4667,1717.8000,1723.1333,1716.4667,1725.8000,1713.7333,1720.4000,1716.4000,1725.8000,1722.4667,1723.1333,1726.4667,1721.1333,1725.8000,1721.8000,1725.8000,1719.8000,1731.8000,1725.8667,1717.7333,1726.4667,1719.8000,1761.2000,2072.4667,1654.3333,1644.3333,1668.3333,1648.3333,1645.0000,1649.6667,1647.6667,1654.3333,1647.6667,1655.0000,1648.3333,1645.6667,1653.0000,1647.0000,1653.6667,1647.0000,1655.0000,1649.0000,1647.0000,1655.6667,1647.6667,1656.3333,1648.3333,1653.0000,1647.6667,1646.3333,1658.3333,1645.6667,1653.0000,1646.3333,1651.6667,1645.6667,1645.6667,1651.0000,1646.3333,1653.6667,1646.3333,1651.6667,1645.6667,1646.3333,1655.0000,1645.0000,1653.0000,1644.9333,1653.0000,1646.2667,1646.3333,1653.0000,1645.6667" +benchmark task handling > without access thread,generating and deleting tasks,100,1,514692800,4809722.3300,4720042.3800,4885924.1500,420215.9176,362760.8030,469089.2140,"5014896.0000,4978587.0000,5076292.0000,4990059.0000,4981974.0000,5090630.0000,5152367.0000,5173227.0000,4954733.0000,5173648.0000,5064009.0000,5136427.0000,5119235.0000,5109276.0000,4984468.0000,4810058.0000,4025633.0000,4087099.0000,4111907.0000,4002319.0000,3974225.0000,4053205.0000,4101477.0000,4873038.0000,4928392.0000,5014196.0000,4925958.0000,4987295.0000,4933162.0000,5170381.0000,5167456.0000,5240604.0000,5014306.0000,4922371.0000,5066725.0000,5054382.0000,5004287.0000,4968889.0000,5125316.0000,5104066.0000,5069480.0000,5158238.0000,5087564.0000,5053239.0000,4972596.0000,4267070.0000,4093691.0000,4743362.0000,5063529.0000,5005209.0000,4685403.0000,4007228.0000,3973714.0000,3992841.0000,4167943.0000,4097890.0000,4089784.0000,3893723.0000,4658061.0000,5144121.0000,4929816.0000,5060222.0000,5043081.0000,5150654.0000,4949112.0000,5038882.0000,5120747.0000,4980582.0000,5101530.0000,5065371.0000,5095920.0000,5157607.0000,5135956.0000,5063178.0000,4964420.0000,4973077.0000,4996122.0000,4940205.0000,4969731.0000,5101200.0000,5081913.0000,5106481.0000,5063498.0000,5080401.0000,4950185.0000,4928453.0000,5055464.0000,5126217.0000,5019305.0000,5141908.0000,5041116.0000,4734045.0000,3936444.0000,3938398.0000,4146021.0000,4054258.0000,3937496.0000,4102839.0000,4634496.0000,5164621.0000" +benchmark task handling > with access thread,generating and deleting tasks with access thread,100,1,1087987100,10977564.5700,10839740.3500,11077308.9300,595870.4386,458516.3368,738684.6126,"11179042.0000,11275735.0000,11151220.0000,11129468.0000,11637471.0000,11280855.0000,11205933.0000,11217174.0000,11270766.0000,10822727.0000,9264707.0000,9346260.0000,9330201.0000,10712428.0000,11150879.0000,11132103.0000,11248514.0000,11275915.0000,11151881.0000,11475483.0000,11132985.0000,11505330.0000,11277749.0000,11439596.0000,11286195.0000,11286055.0000,11195233.0000,11332353.0000,11277258.0000,11145409.0000,11101765.0000,11086317.0000,11549394.0000,11162822.0000,11251198.0000,11243074.0000,11135630.0000,11131643.0000,11141410.0000,11124169.0000,11183320.0000,11134578.0000,11140348.0000,11120602.0000,11157571.0000,11122436.0000,11139497.0000,10351425.0000,11264454.0000,11150178.0000,11197136.0000,11238415.0000,11173982.0000,11189352.0000,11161098.0000,11127234.0000,11163934.0000,11170396.0000,11189372.0000,11242592.0000,11240599.0000,11266517.0000,10542657.0000,10061886.0000,9256490.0000,11635497.0000,11216894.0000,11271127.0000,11102657.0000,11239766.0000,11149537.0000,11207526.0000,11112697.0000,11198799.0000,11147383.0000,11164614.0000,11253725.0000,11174884.0000,11143715.0000,11127064.0000,11298649.0000,11216342.0000,9904458.0000,9109913.0000,9368693.0000,10542076.0000,11214850.0000,11118718.0000,11115883.0000,11257170.0000,11285835.0000,11122705.0000,11139808.0000,10946091.0000,9235231.0000,9150881.0000,9164486.0000,10958976.0000,11163883.0000,11245508.0000" +generating large task graphs,soup topology,100,1,1553521500,15499589.0800,15405895.6300,15549517.2600,336762.5834,203964.1309,527873.6196,"15592141.0000,15575299.0000,15581360.0000,15793994.0000,15552606.0000,15592582.0000,15523471.0000,15602801.0000,15636955.0000,15627177.0000,15618020.0000,15589606.0000,15544000.0000,15602280.0000,15646555.0000,15635543.0000,15625203.0000,15508773.0000,15579327.0000,15476702.0000,15514454.0000,15552086.0000,15578505.0000,15557746.0000,15641534.0000,15549731.0000,15556554.0000,15558116.0000,15509305.0000,15591369.0000,15631064.0000,15573376.0000,14827663.0000,14636791.0000,15596328.0000,15523993.0000,15533690.0000,15613521.0000,15549430.0000,15574798.0000,15537207.0000,15575209.0000,15596630.0000,15543128.0000,15572895.0000,15588373.0000,15626616.0000,15553267.0000,15595807.0000,15567374.0000,15556253.0000,15545292.0000,14867028.0000,13593746.0000,15019917.0000,15559690.0000,15658497.0000,15596459.0000,15638298.0000,15560571.0000,15609935.0000,15563046.0000,15533580.0000,15608212.0000,15506248.0000,15587793.0000,15497632.0000,15598964.0000,15565030.0000,16011325.0000,15554780.0000,15593163.0000,15574697.0000,15602441.0000,15543088.0000,15553568.0000,15549110.0000,15572463.0000,15585338.0000,15528741.0000,15489196.0000,15539121.0000,15606117.0000,15568325.0000,15638499.0000,15575911.0000,15592892.0000,15594355.0000,14371259.0000,13604677.0000,15405267.0000,15572203.0000,15563818.0000,15655361.0000,15521958.0000,15582192.0000,15585429.0000,15558066.0000,15633279.0000,15635123.0000" +generating large task graphs,chain topology,100,1,6928600,69061.7500,68982.1700,69198.1200,519.0501,335.6500,789.2568,"69340.0000,69119.0000,71133.0000,68728.0000,68888.0000,68699.0000,68828.0000,68358.0000,69049.0000,68648.0000,68838.0000,68568.0000,71824.0000,68779.0000,68898.0000,68689.0000,69068.0000,68668.0000,68938.0000,68929.0000,69029.0000,68638.0000,68959.0000,68928.0000,69029.0000,68678.0000,68769.0000,68648.0000,68919.0000,68828.0000,68798.0000,68728.0000,68938.0000,68648.0000,68818.0000,68688.0000,68819.0000,68518.0000,68738.0000,68578.0000,68909.0000,68798.0000,68838.0000,68648.0000,68758.0000,68688.0000,69119.0000,68668.0000,68909.0000,68398.0000,68878.0000,69139.0000,69179.0000,69018.0000,69260.0000,68938.0000,69049.0000,69069.0000,69019.0000,68859.0000,69008.0000,68689.0000,69650.0000,69089.0000,69169.0000,68898.0000,69109.0000,68939.0000,69239.0000,69059.0000,71834.0000,69079.0000,69420.0000,68969.0000,69289.0000,69069.0000,69279.0000,69310.0000,69429.0000,69009.0000,69179.0000,69260.0000,69600.0000,69159.0000,69359.0000,69199.0000,69360.0000,69229.0000,69420.0000,68948.0000,69079.0000,69199.0000,69369.0000,69189.0000,69219.0000,69159.0000,69399.0000,68979.0000,69550.0000,68958.0000" +generating large task graphs,expanding tree topology,100,1,14142300,141607.0000,141436.5800,141935.4200,1166.0696,663.8824,1874.9881,"141326.0000,141336.0000,145604.0000,141927.0000,141987.0000,141496.0000,141366.0000,141406.0000,141616.0000,141527.0000,141616.0000,141446.0000,141336.0000,141396.0000,141376.0000,141095.0000,141296.0000,141526.0000,141767.0000,141135.0000,141446.0000,141216.0000,141355.0000,141325.0000,141406.0000,141506.0000,146756.0000,142798.0000,141687.0000,142287.0000,142067.0000,141136.0000,141586.0000,141677.0000,141716.0000,141366.0000,141847.0000,141486.0000,141686.0000,141156.0000,142027.0000,142057.0000,141166.0000,141165.0000,141366.0000,141446.0000,141266.0000,141235.0000,141296.0000,141316.0000,141276.0000,141105.0000,141366.0000,141456.0000,149000.0000,141346.0000,141336.0000,141105.0000,141236.0000,141606.0000,141627.0000,141235.0000,141156.0000,141386.0000,140804.0000,141215.0000,141296.0000,140995.0000,141186.0000,141085.0000,141686.0000,140805.0000,141206.0000,141326.0000,141055.0000,141596.0000,141486.0000,141516.0000,140875.0000,140935.0000,141056.0000,141436.0000,141526.0000,146516.0000,141426.0000,141375.0000,141115.0000,141556.0000,141156.0000,141045.0000,140995.0000,141396.0000,141446.0000,141125.0000,141306.0000,141196.0000,140855.0000,140905.0000,141696.0000,140845.0000" +generating large task graphs,contracting tree topology,100,1,17925900,181704.3100,181506.9200,182035.3000,1276.4888,847.6035,2005.3359,"180740.0000,180550.0000,186050.0000,182082.0000,181722.0000,181973.0000,181932.0000,181592.0000,181833.0000,181812.0000,181953.0000,181742.0000,182123.0000,181572.0000,182022.0000,181501.0000,182023.0000,181642.0000,187213.0000,181622.0000,181522.0000,181312.0000,181562.0000,181692.0000,181722.0000,181692.0000,182013.0000,181883.0000,181792.0000,181883.0000,182213.0000,181943.0000,181792.0000,182133.0000,182354.0000,181972.0000,182053.0000,181723.0000,181892.0000,181943.0000,189447.0000,182554.0000,182243.0000,181772.0000,181832.0000,182143.0000,181101.0000,181993.0000,182233.0000,182254.0000,181902.0000,181753.0000,181872.0000,181923.0000,181762.0000,181772.0000,181993.0000,181672.0000,182183.0000,181672.0000,182404.0000,181903.0000,184948.0000,181041.0000,180991.0000,181302.0000,181111.0000,180730.0000,180781.0000,180670.0000,180801.0000,180800.0000,181352.0000,180891.0000,181351.0000,181051.0000,181001.0000,180681.0000,180730.0000,180630.0000,180160.0000,180850.0000,181212.0000,180470.0000,184026.0000,180880.0000,180280.0000,180750.0000,180671.0000,181401.0000,180400.0000,180400.0000,180670.0000,180931.0000,180480.0000,180841.0000,181041.0000,180981.0000,181041.0000,180911.0000" +generating large task graphs,wave_sim topology,100,1,64605400,652725.7300,652320.1000,653268.1000,2382.6554,1899.2972,2933.6344,"650210.0000,650530.0000,657363.0000,652975.0000,652114.0000,652203.0000,652604.0000,654939.0000,652244.0000,651882.0000,651442.0000,652363.0000,651863.0000,655981.0000,652143.0000,652514.0000,651853.0000,652193.0000,651322.0000,660619.0000,653496.0000,651492.0000,650941.0000,650490.0000,652143.0000,657373.0000,651492.0000,652284.0000,650650.0000,651211.0000,651252.0000,656722.0000,652604.0000,652153.0000,651863.0000,651933.0000,652124.0000,659898.0000,652263.0000,653947.0000,653366.0000,652273.0000,652514.0000,658135.0000,652885.0000,652724.0000,652364.0000,651552.0000,652214.0000,651632.0000,660770.0000,651923.0000,652333.0000,651592.0000,652323.0000,652043.0000,655359.0000,652594.0000,651742.0000,651783.0000,651632.0000,651493.0000,657633.0000,651503.0000,651622.0000,651192.0000,651482.0000,651872.0000,659667.0000,652264.0000,650971.0000,651582.0000,651613.0000,651351.0000,656191.0000,652013.0000,650911.0000,651231.0000,651012.0000,650800.0000,654739.0000,651371.0000,651331.0000,652053.0000,651993.0000,652173.0000,658786.0000,651502.0000,651552.0000,650861.0000,651862.0000,651031.0000,650891.0000,653175.0000,650761.0000,650811.0000,651622.0000,650610.0000,650890.0000,658715.0000" +generating large task graphs,jacobi topology,100,1,22575500,222358.7200,222041.9700,222907.4200,2073.6864,1362.7722,2964.9309,"221608.0000,221578.0000,228220.0000,222319.0000,222139.0000,222059.0000,222830.0000,231847.0000,222228.0000,222329.0000,222599.0000,221829.0000,222259.0000,221658.0000,221668.0000,222008.0000,221989.0000,221718.0000,221948.0000,222059.0000,221668.0000,221327.0000,221618.0000,220776.0000,222259.0000,227259.0000,221608.0000,221087.0000,221888.0000,221598.0000,222139.0000,221688.0000,221838.0000,221878.0000,221698.0000,221337.0000,221427.0000,221258.0000,221076.0000,221498.0000,221919.0000,221086.0000,221879.0000,227379.0000,222068.0000,221658.0000,221929.0000,221658.0000,221918.0000,221317.0000,221327.0000,221828.0000,222269.0000,222179.0000,222019.0000,221758.0000,222590.0000,221998.0000,221859.0000,221878.0000,222840.0000,232479.0000,221708.0000,221688.0000,221888.0000,221748.0000,221969.0000,222008.0000,221718.0000,221667.0000,221457.0000,221538.0000,221868.0000,221488.0000,221728.0000,221447.0000,221789.0000,221457.0000,222800.0000,227800.0000,222099.0000,221638.0000,222379.0000,221678.0000,222389.0000,221919.0000,221848.0000,222580.0000,222299.0000,221508.0000,221828.0000,221618.0000,221858.0000,221197.0000,222009.0000,221227.0000,222239.0000,231447.0000,221718.0000,220976.0000" +generating large command graphs for N nodes - 1,soup topology,100,1,2726715900,27207829.6100,27068730.5600,27309607.6000,601428.4956,384014.1894,908074.7226,"27207792.0000,27287071.0000,27231437.0000,27239783.0000,27294977.0000,27306449.0000,27245052.0000,25647646.0000,29793760.0000,29087523.0000,27228531.0000,27242247.0000,27256444.0000,27366323.0000,27337868.0000,27385759.0000,27273046.0000,27247839.0000,25183166.0000,24668593.0000,27258338.0000,27225135.0000,27322008.0000,27331667.0000,27302141.0000,27236657.0000,27195007.0000,27290388.0000,27306529.0000,27263678.0000,27284707.0000,27292663.0000,27118052.0000,23827400.0000,26432172.0000,27214876.0000,27249912.0000,27288285.0000,27238881.0000,27326447.0000,27193355.0000,27355552.0000,27270982.0000,27308543.0000,27350473.0000,27224032.0000,27257877.0000,27292793.0000,27236627.0000,27316117.0000,27342117.0000,27283606.0000,27363958.0000,27214113.0000,27413311.0000,27386180.0000,27368075.0000,27226748.0000,27263318.0000,27291962.0000,27310746.0000,27264931.0000,27263167.0000,27278106.0000,27330554.0000,27156666.0000,27153700.0000,27221458.0000,27279988.0000,26722362.0000,27195148.0000,27287903.0000,27246987.0000,27271353.0000,27306860.0000,27315496.0000,27264249.0000,27332749.0000,27298684.0000,27283384.0000,27308914.0000,27194577.0000,27282563.0000,27267836.0000,27173848.0000,27202292.0000,27270580.0000,27239743.0000,27239713.0000,27222811.0000,27303012.0000,27340053.0000,27282354.0000,27335673.0000,27300477.0000,27338590.0000,27271683.0000,27296610.0000,27281582.0000,27349571.0000" +generating large command graphs for N nodes - 1,chain topology,100,1,28102500,281686.2700,281346.0600,282251.0800,2195.4936,1489.3050,3263.4614,"280510.0000,280399.0000,286100.0000,280400.0000,280569.0000,285098.0000,281231.0000,280790.0000,282253.0000,280259.0000,281892.0000,281101.0000,281120.0000,280970.0000,280890.0000,281141.0000,281461.0000,282303.0000,280730.0000,286531.0000,282002.0000,281131.0000,281000.0000,281231.0000,280419.0000,280950.0000,280629.0000,281271.0000,281281.0000,280720.0000,280780.0000,280840.0000,281411.0000,280670.0000,291540.0000,280710.0000,281511.0000,280309.0000,280960.0000,280850.0000,281742.0000,280439.0000,280880.0000,280940.0000,280600.0000,280549.0000,279707.0000,280880.0000,288755.0000,281932.0000,281180.0000,281050.0000,281020.0000,280309.0000,280679.0000,281721.0000,280550.0000,280880.0000,281501.0000,281191.0000,281071.0000,280078.0000,293875.0000,281612.0000,281361.0000,280700.0000,280469.0000,281431.0000,281121.0000,281722.0000,280930.0000,281201.0000,281271.0000,281561.0000,281201.0000,281010.0000,288163.0000,281621.0000,280870.0000,281161.0000,282563.0000,281722.0000,281712.0000,282483.0000,281792.0000,282223.0000,282253.0000,282463.0000,280820.0000,280660.0000,286891.0000,281221.0000,281551.0000,280940.0000,281912.0000,281100.0000,280729.0000,280148.0000,280389.0000,280158.0000" +generating large command graphs for N nodes - 1,expanding tree topology,100,1,44934100,449639.7800,449025.8900,450330.6200,3316.8720,2776.1483,4030.6912,"450211.0000,450562.0000,456222.0000,449009.0000,449269.0000,449379.0000,449350.0000,448758.0000,450622.0000,450030.0000,460691.0000,450191.0000,451153.0000,451643.0000,451012.0000,450271.0000,449650.0000,450622.0000,450742.0000,454699.0000,450652.0000,450051.0000,451232.0000,449409.0000,449249.0000,449500.0000,450371.0000,449810.0000,454149.0000,449660.0000,450331.0000,449429.0000,450011.0000,449269.0000,451614.0000,451052.0000,458998.0000,452956.0000,448197.0000,447165.0000,449379.0000,450121.0000,449840.0000,449971.0000,450461.0000,453307.0000,451443.0000,448688.0000,449730.0000,449981.0000,450000.0000,446985.0000,444230.0000,443859.0000,455821.0000,450632.0000,447516.0000,444740.0000,444469.0000,445321.0000,445492.0000,444420.0000,445282.0000,450461.0000,444130.0000,444680.0000,444851.0000,445913.0000,445412.0000,444690.0000,445663.0000,443829.0000,459097.0000,450801.0000,448968.0000,450001.0000,450722.0000,449339.0000,450441.0000,450021.0000,450251.0000,455190.0000,448357.0000,446644.0000,447466.0000,446904.0000,448418.0000,447455.0000,446244.0000,446904.0000,459248.0000,447977.0000,448367.0000,450461.0000,450441.0000,449740.0000,448928.0000,450431.0000,451424.0000,455230.0000" +generating large command graphs for N nodes - 1,contracting tree topology,100,1,48815200,493651.4200,492885.0200,494606.3900,4341.3067,3520.0897,5427.8479,"492821.0000,487932.0000,504303.0000,489766.0000,488533.0000,491278.0000,488784.0000,489365.0000,489395.0000,489104.0000,500957.0000,496369.0000,494174.0000,494615.0000,494735.0000,493332.0000,495115.0000,494414.0000,498112.0000,494234.0000,493894.0000,495025.0000,494474.0000,494856.0000,494895.0000,493432.0000,506818.0000,496929.0000,493964.0000,489345.0000,490597.0000,489957.0000,489254.0000,489535.0000,488884.0000,495146.0000,488704.0000,489315.0000,489165.0000,488373.0000,489295.0000,488283.0000,488644.0000,496168.0000,488403.0000,488393.0000,489124.0000,488514.0000,488633.0000,487512.0000,488283.0000,508371.0000,495908.0000,495657.0000,494124.0000,494264.0000,493784.0000,493903.0000,494755.0000,502520.0000,493372.0000,494265.0000,494775.0000,493683.0000,493814.0000,493041.0000,493052.0000,500426.0000,491909.0000,493733.0000,494895.0000,493182.0000,494334.0000,492231.0000,492811.0000,509232.0000,494635.0000,493733.0000,495176.0000,492681.0000,494034.0000,493092.0000,494284.0000,499504.0000,494094.0000,493153.0000,493112.0000,492371.0000,493472.0000,492490.0000,493773.0000,506918.0000,494084.0000,493814.0000,495747.0000,493934.0000,492982.0000,492701.0000,492581.0000,499584.0000" +generating large command graphs for N nodes - 1,wave_sim topology,100,1,220916600,2207590.2200,2203525.1000,2211850.5800,21295.8661,19625.5936,23263.9214,"2193803.0000,2182712.0000,2250651.0000,2229361.0000,2245992.0000,2219973.0000,2195988.0000,2188323.0000,2196890.0000,2197540.0000,2225834.0000,2233468.0000,2226435.0000,2232216.0000,2223800.0000,2243267.0000,2228840.0000,2232426.0000,2238378.0000,2223609.0000,2207499.0000,2191679.0000,2196238.0000,2190046.0000,2233619.0000,2233178.0000,2202550.0000,2214823.0000,2236124.0000,2248637.0000,2196418.0000,2203772.0000,2187833.0000,2179907.0000,2189976.0000,2232206.0000,2236424.0000,2230523.0000,2234320.0000,2222508.0000,2241985.0000,2209943.0000,2190717.0000,2182091.0000,2186078.0000,2184907.0000,2203242.0000,2188563.0000,2183404.0000,2192311.0000,2185988.0000,2215565.0000,2191459.0000,2192030.0000,2187582.0000,2192250.0000,2202349.0000,2227047.0000,2175388.0000,2177001.0000,2181890.0000,2176090.0000,2188693.0000,2173414.0000,2176560.0000,2171822.0000,2216988.0000,2224792.0000,2209243.0000,2224051.0000,2191719.0000,2199794.0000,2185337.0000,2224752.0000,2227898.0000,2232266.0000,2240923.0000,2224762.0000,2237626.0000,2228970.0000,2241955.0000,2210976.0000,2194004.0000,2189395.0000,2196438.0000,2203481.0000,2207921.0000,2196839.0000,2190707.0000,2192040.0000,2187492.0000,2202139.0000,2184807.0000,2194064.0000,2189665.0000,2195346.0000,2203822.0000,2228709.0000,2235162.0000,2188784.0000" +generating large command graphs for N nodes - 1,jacobi topology,100,1,82618100,831167.6200,829428.0800,832795.2300,8547.6367,7640.6259,9512.7222,"841202.0000,833727.0000,840069.0000,838496.0000,836592.0000,833126.0000,831883.0000,835100.0000,844378.0000,837054.0000,835991.0000,835231.0000,834027.0000,843606.0000,836853.0000,834008.0000,834980.0000,833406.0000,844448.0000,834579.0000,833647.0000,834269.0000,834168.0000,836242.0000,833076.0000,835541.0000,834769.0000,844537.0000,833196.0000,834458.0000,833757.0000,831864.0000,837284.0000,835641.0000,835270.0000,833137.0000,832755.0000,848055.0000,835009.0000,835200.0000,835240.0000,831273.0000,825742.0000,818408.0000,817166.0000,818058.0000,818398.0000,823979.0000,817387.0000,819139.0000,817947.0000,818268.0000,845429.0000,836001.0000,834939.0000,835670.0000,840710.0000,833827.0000,834889.0000,833727.0000,834468.0000,848115.0000,836192.0000,827165.0000,817076.0000,820652.0000,824370.0000,819080.0000,819961.0000,814711.0000,817646.0000,823979.0000,817367.0000,820091.0000,818629.0000,818028.0000,839568.0000,835130.0000,833467.0000,832414.0000,837865.0000,833657.0000,834388.0000,835221.0000,831873.0000,836722.0000,833697.0000,835440.0000,834819.0000,832565.0000,845900.0000,836362.0000,835691.0000,820041.0000,816855.0000,822817.0000,816795.0000,817707.0000,816595.0000,816815.0000" +generating large command graphs for N nodes - 4,soup topology,100,1,6539497400,65211801.8800,64912349.1900,65377360.0400,1104780.1842,706125.3904,1711032.9091,"64890557.0000,65917091.0000,65299401.0000,66220415.0000,65407115.0000,65439667.0000,65924074.0000,65691474.0000,65574843.0000,65309831.0000,63765135.0000,65301675.0000,65355878.0000,65668981.0000,65329358.0000,65792956.0000,60434626.0000,65607715.0000,65006215.0000,65578168.0000,65350557.0000,65584211.0000,65915898.0000,65972305.0000,66111440.0000,65833362.0000,64909272.0000,65278631.0000,65197378.0000,65570725.0000,65404750.0000,64295159.0000,65281588.0000,65349876.0000,65790982.0000,65416552.0000,65832751.0000,65674130.0000,65319288.0000,60345116.0000,66075130.0000,65250708.0000,65622402.0000,65505872.0000,65256890.0000,65550236.0000,65168062.0000,58610131.0000,65370867.0000,65363332.0000,66054351.0000,65613055.0000,65482288.0000,65875202.0000,65542070.0000,65439116.0000,65417865.0000,65496404.0000,65542491.0000,65431261.0000,65119611.0000,65316894.0000,64405588.0000,65858841.0000,65454715.0000,65527412.0000,65554804.0000,65538023.0000,65569382.0000,65909436.0000,65452862.0000,63265879.0000,65668541.0000,65837801.0000,65393319.0000,65773960.0000,65582187.0000,63496095.0000,63845107.0000,65295403.0000,65461738.0000,65368472.0000,65401284.0000,65347883.0000,65938551.0000,65491114.0000,65319769.0000,65950214.0000,65492968.0000,65482007.0000,65564994.0000,65446149.0000,65233576.0000,65419098.0000,65497336.0000,65490072.0000,65058575.0000,63820490.0000,63445399.0000,65467760.0000" +generating large command graphs for N nodes - 4,chain topology,100,1,342979900,3429528.4900,3426510.6000,3433522.4200,17697.6443,13977.7108,22289.4252,"3431087.0000,3424415.0000,3443280.0000,3418323.0000,3430957.0000,3424574.0000,3428422.0000,3413153.0000,3415728.0000,3485941.0000,3464380.0000,3416389.0000,3430165.0000,3415988.0000,3430286.0000,3412672.0000,3417772.0000,3417561.0000,3420918.0000,3420407.0000,3436748.0000,3415577.0000,3415358.0000,3484317.0000,3420687.0000,3460984.0000,3444312.0000,3413674.0000,3427680.0000,3423202.0000,3417440.0000,3422901.0000,3434423.0000,3421289.0000,3431918.0000,3419214.0000,3407001.0000,3417130.0000,3427370.0000,3427740.0000,3432259.0000,3425366.0000,3427169.0000,3409296.0000,3427490.0000,3411690.0000,3462667.0000,3492603.0000,3463608.0000,3424083.0000,3417882.0000,3423813.0000,3477435.0000,3426859.0000,3463819.0000,3421178.0000,3434042.0000,3417551.0000,3423633.0000,3429724.0000,3434342.0000,3424985.0000,3422561.0000,3433852.0000,3417000.0000,3423643.0000,3428562.0000,3424574.0000,3415466.0000,3432489.0000,3422410.0000,3415678.0000,3433151.0000,3418343.0000,3431908.0000,3423673.0000,3419055.0000,3440124.0000,3425627.0000,3425355.0000,3436628.0000,3421729.0000,3439854.0000,3421008.0000,3421429.0000,3412221.0000,3493134.0000,3451977.0000,3435756.0000,3419505.0000,3415187.0000,3435876.0000,3407992.0000,3422932.0000,3443500.0000,3427430.0000,3432870.0000,3425667.0000,3421889.0000,3409917.0000" +generating large command graphs for N nodes - 4,expanding tree topology,100,1,951629300,9506820.9100,9436908.7700,9555014.7600,292984.3751,218891.1517,367184.7043,"9585273.0000,9610351.0000,9613807.0000,9637703.0000,9594181.0000,9655747.0000,9605762.0000,9588709.0000,9134230.0000,8607471.0000,8622601.0000,8642517.0000,9442433.0000,9614148.0000,9611012.0000,9606394.0000,9620971.0000,9678090.0000,9592767.0000,9597397.0000,9626352.0000,9611924.0000,9616883.0000,9609969.0000,9607756.0000,9650567.0000,9599801.0000,9610250.0000,9604631.0000,9599880.0000,9610161.0000,9613116.0000,9625880.0000,9630609.0000,9619238.0000,9640048.0000,9612083.0000,9616382.0000,9593208.0000,9618356.0000,9627873.0000,9623226.0000,9625029.0000,9600713.0000,9609540.0000,9616312.0000,9611634.0000,9641469.0000,9614650.0000,9540017.0000,8616749.0000,8610798.0000,8614865.0000,9321303.0000,9658341.0000,9609089.0000,9626882.0000,9622334.0000,9631982.0000,9606624.0000,9605571.0000,9639467.0000,9614298.0000,9594902.0000,9611053.0000,9595753.0000,9595533.0000,9612605.0000,9614920.0000,9577788.0000,9602777.0000,9581115.0000,9592678.0000,9590213.0000,9603869.0000,9603318.0000,9633023.0000,9601234.0000,9604880.0000,9611073.0000,9604329.0000,9602235.0000,8830454.0000,8615958.0000,8590850.0000,8744340.0000,9630449.0000,9591145.0000,9598759.0000,9616342.0000,9601003.0000,9605321.0000,9663922.0000,9632974.0000,9610952.0000,9577850.0000,9612074.0000,9620150.0000,9642892.0000,9595934.0000" +generating large command graphs for N nodes - 4,contracting tree topology,100,1,403975900,3814408.5300,3784673.8400,3831461.2800,111748.1223,72504.4357,157960.8040,"3847616.0000,3845912.0000,3880589.0000,3852495.0000,3842567.0000,4009463.0000,3858235.0000,3845272.0000,3846364.0000,3834431.0000,3834691.0000,3851182.0000,3836204.0000,3844260.0000,3835523.0000,3822919.0000,3847064.0000,3839711.0000,3840482.0000,3824632.0000,3828660.0000,3839851.0000,3833579.0000,3839681.0000,3826516.0000,3822629.0000,3838298.0000,3834581.0000,3830443.0000,3846614.0000,3855541.0000,3829682.0000,3819413.0000,3845451.0000,3835634.0000,3863886.0000,3827788.0000,3831806.0000,3834440.0000,3827257.0000,3838409.0000,3828079.0000,3878254.0000,3833659.0000,3839801.0000,3832547.0000,3850111.0000,3361085.0000,3361615.0000,3317913.0000,3350043.0000,3336909.0000,3623351.0000,3828640.0000,3830704.0000,3839019.0000,3826586.0000,3861953.0000,3847065.0000,3829642.0000,3847516.0000,3856343.0000,3839921.0000,3836946.0000,3828660.0000,3838108.0000,3823500.0000,3849849.0000,3830484.0000,3852856.0000,3821406.0000,3868556.0000,3831886.0000,3838418.0000,3838669.0000,3829591.0000,3822328.0000,3839270.0000,3833128.0000,3817208.0000,3862524.0000,3833449.0000,3829712.0000,3854088.0000,3849509.0000,3851343.0000,3852746.0000,3840663.0000,3844059.0000,3836424.0000,3828199.0000,3827788.0000,3835824.0000,3863566.0000,3833899.0000,3829441.0000,3837196.0000,3857234.0000,3827779.0000,3834020.0000" +generating large command graphs for N nodes - 4,wave_sim topology,100,1,1543441400,15527801.5900,15488803.4800,15541087.8300,106883.1469,44074.1733,234265.6400,"15523761.0000,15588745.0000,15506258.0000,15508433.0000,15529572.0000,15492472.0000,15496128.0000,15521337.0000,15474348.0000,15598122.0000,15540734.0000,15493004.0000,15633359.0000,15574828.0000,15551454.0000,15565029.0000,15519312.0000,15531776.0000,15512190.0000,15520845.0000,15526496.0000,15563607.0000,15533671.0000,15551945.0000,15541164.0000,15515195.0000,15526587.0000,15496400.0000,15537397.0000,15535915.0000,15644470.0000,15551414.0000,15510647.0000,15537979.0000,15573526.0000,15525324.0000,15527298.0000,15521809.0000,15537868.0000,15489647.0000,15473376.0000,15503363.0000,15542687.0000,15512049.0000,15538379.0000,15519013.0000,15527829.0000,15502651.0000,15582483.0000,15516097.0000,15536506.0000,15508202.0000,15511038.0000,15529562.0000,15504284.0000,15565781.0000,15575691.0000,15606768.0000,15495939.0000,15525294.0000,15464260.0000,15508312.0000,15491230.0000,15509054.0000,15498704.0000,15522870.0000,15544972.0000,15700817.0000,15521527.0000,15572393.0000,15528020.0000,15549992.0000,15511969.0000,15601659.0000,15586730.0000,15584517.0000,15378346.0000,14572309.0000,15532017.0000,15524162.0000,15607150.0000,15581510.0000,15612890.0000,15526496.0000,15513302.0000,15519383.0000,15497913.0000,15544982.0000,15480860.0000,15528230.0000,15475670.0000,15561102.0000,15536274.0000,15497120.0000,15516789.0000,15526767.0000,15679236.0000,15561583.0000,15681219.0000,15620765.0000" +generating large command graphs for N nodes - 4,jacobi topology,100,1,540435900,5412009.5900,5404122.0600,5421769.3500,44603.4982,37591.9920,54964.0542,"5414233.0000,5439451.0000,5364309.0000,5423301.0000,5369077.0000,5451463.0000,5503412.0000,5386100.0000,5430604.0000,5374878.0000,5579646.0000,5432538.0000,5399545.0000,5373185.0000,5377133.0000,5405045.0000,5375569.0000,5384506.0000,5522569.0000,5444451.0000,5374677.0000,5398333.0000,5419664.0000,5397231.0000,5376000.0000,5437487.0000,5387383.0000,5395818.0000,5373014.0000,5402842.0000,5435113.0000,5372404.0000,5449599.0000,5366643.0000,5494525.0000,5480629.0000,5407180.0000,5381912.0000,5420075.0000,5470850.0000,5391059.0000,5397773.0000,5369799.0000,5387362.0000,5402640.0000,5374427.0000,5524402.0000,5490748.0000,5379627.0000,5403554.0000,5451694.0000,5394956.0000,5378114.0000,5364799.0000,5365161.0000,5472093.0000,5434852.0000,5375299.0000,5405987.0000,5400546.0000,5393183.0000,5395338.0000,5451925.0000,5374707.0000,5442607.0000,5417840.0000,5469228.0000,5373155.0000,5381090.0000,5413962.0000,5379517.0000,5383525.0000,5537016.0000,5376522.0000,5521557.0000,5406618.0000,5442377.0000,5398914.0000,5378525.0000,5399154.0000,5395527.0000,5375249.0000,5490728.0000,5386701.0000,5418872.0000,5362685.0000,5377423.0000,5364469.0000,5422509.0000,5375610.0000,5468445.0000,5425114.0000,5422810.0000,5373205.0000,5412389.0000,5366873.0000,5387001.0000,5373746.0000,5424583.0000,5382974.0000" +generating large command graphs for N nodes - 16,soup topology,100,1,22387977900,223193282.4300,222596979.4600,223593149.0500,2452923.3397,1678339.0892,4041667.9665,"223308504.0000,232703749.0000,223624191.0000,224136142.0000,223520355.0000,223513552.0000,223770230.0000,223557105.0000,218627899.0000,223465020.0000,223883974.0000,223134505.0000,224006656.0000,224546088.0000,223831285.0000,223567584.0000,221434424.0000,223590327.0000,223409205.0000,219804086.0000,224244317.0000,223797381.0000,224076669.0000,221826347.0000,223156577.0000,222231143.0000,207602155.0000,218327851.0000,224028778.0000,219207808.0000,223530113.0000,223663737.0000,223878152.0000,224628213.0000,224784580.0000,223068911.0000,224304962.0000,223506459.0000,223833639.0000,223608312.0000,224347903.0000,223793764.0000,224143365.0000,223899423.0000,218631686.0000,223652976.0000,223375841.0000,223241067.0000,223900035.0000,224581675.0000,223455042.0000,223466894.0000,223448830.0000,223831274.0000,224332124.0000,223905966.0000,223156716.0000,224048557.0000,224578519.0000,223524803.0000,224248003.0000,223644972.0000,219050709.0000,224084122.0000,224212156.0000,224463391.0000,223634902.0000,224461337.0000,224059647.0000,224115994.0000,216181815.0000,223932817.0000,221279530.0000,224213859.0000,218491100.0000,223821626.0000,223865870.0000,223677663.0000,224146882.0000,224264033.0000,222218579.0000,223978233.0000,224586796.0000,224738202.0000,223531236.0000,225629079.0000,223674898.0000,223545233.0000,219037284.0000,223456244.0000,223650422.0000,223747115.0000,223569468.0000,223983423.0000,223770009.0000,223536807.0000,224629536.0000,222285596.0000,221623503.0000,224228707.0000" +generating large command graphs for N nodes - 16,chain topology,100,1,43031073600,432110010.3600,431437092.5900,432717969.4300,3270868.7459,2890024.1366,3784186.9093,"425359957.0000,435454577.0000,429167549.0000,427144307.0000,425241563.0000,422595111.0000,427027525.0000,423430563.0000,426180822.0000,429996369.0000,430441743.0000,430621804.0000,428202401.0000,429540646.0000,429359783.0000,439718354.0000,430024322.0000,429903673.0000,434361948.0000,434616250.0000,435800793.0000,432954993.0000,434191856.0000,434633481.0000,432631750.0000,433460400.0000,429433673.0000,434906579.0000,434240408.0000,428718909.0000,432871064.0000,430528527.0000,433736784.0000,433240754.0000,428754888.0000,429873135.0000,434663549.0000,434507703.0000,435083835.0000,434548672.0000,434698064.0000,433753885.0000,434068061.0000,428613941.0000,428632024.0000,435063186.0000,435311226.0000,434054364.0000,434486884.0000,433583173.0000,434738210.0000,433715854.0000,434302906.0000,428949326.0000,429257269.0000,434016493.0000,434014289.0000,428264058.0000,427700981.0000,434041621.0000,434587864.0000,432716831.0000,428966168.0000,428903178.0000,434919213.0000,434103508.0000,434847206.0000,433543276.0000,434070376.0000,434915205.0000,434081937.0000,432352110.0000,428216938.0000,434533403.0000,432412896.0000,435924347.0000,435469124.0000,433288274.0000,434883827.0000,433696536.0000,428816193.0000,429094841.0000,429239895.0000,434613254.0000,426203625.0000,429193177.0000,435060601.0000,435008011.0000,434591893.0000,433581809.0000,429033024.0000,434164232.0000,434346489.0000,435589281.0000,435081039.0000,434413214.0000,434929813.0000,434198438.0000,433821603.0000,425151552.0000" +generating large command graphs for N nodes - 16,expanding tree topology,100,1,70215314900,702699377.0800,702002960.1100,703303516.5500,3311691.3934,2878225.8875,3835182.4288,"705344460.0000,700923296.0000,705466111.0000,704637593.0000,700239231.0000,706074735.0000,704455217.0000,699397507.0000,707312770.0000,704264807.0000,702072865.0000,705218924.0000,704949864.0000,704468111.0000,703288748.0000,704587448.0000,705211499.0000,705600136.0000,706446007.0000,704315552.0000,706976353.0000,696282717.0000,702342094.0000,702152646.0000,698650873.0000,699969009.0000,703113565.0000,700429462.0000,700208623.0000,702482110.0000,707920410.0000,700946291.0000,698633890.0000,703280933.0000,706795940.0000,700635312.0000,703669979.0000,705546043.0000,694080857.0000,701070305.0000,706065155.0000,694648381.0000,701986461.0000,704478471.0000,700612158.0000,704726631.0000,704498739.0000,707144931.0000,702073855.0000,698209057.0000,704474854.0000,702494833.0000,702604501.0000,701550856.0000,705322900.0000,697743705.0000,698561412.0000,705702038.0000,700136206.0000,704127014.0000,704611603.0000,704787606.0000,706616049.0000,705527778.0000,705935810.0000,707043658.0000,703542758.0000,705172696.0000,705961921.0000,705878742.0000,703643940.0000,704585573.0000,696993694.0000,703864417.0000,706763719.0000,695422628.0000,698628089.0000,704346070.0000,700072144.0000,699890199.0000,704950584.0000,704996091.0000,701594418.0000,701964950.0000,704708615.0000,702531012.0000,703837616.0000,705834138.0000,703508453.0000,703298324.0000,696712090.0000,704356499.0000,693820943.0000,700234031.0000,704623455.0000,694918112.0000,694819665.0000,702674783.0000,704449595.0000,700190789.0000" +generating large command graphs for N nodes - 16,contracting tree topology,100,1,13889843600,138428564.6000,137996316.3000,138755231.1600,1899956.7912,1539919.0608,2333100.3877,"138933049.0000,138831828.0000,139248747.0000,139524709.0000,139073084.0000,139752602.0000,138952746.0000,138970950.0000,138445225.0000,138826227.0000,139132267.0000,138913201.0000,140123994.0000,139082542.0000,139273063.0000,138987091.0000,139203091.0000,139416635.0000,139518028.0000,139033359.0000,138724363.0000,133995928.0000,139066201.0000,139810792.0000,139174646.0000,139051693.0000,138698945.0000,138689488.0000,139039391.0000,139380035.0000,139296197.0000,139410593.0000,138811628.0000,139363865.0000,133834071.0000,139016698.0000,139374465.0000,139605262.0000,134382349.0000,140023325.0000,139705923.0000,135836864.0000,137310746.0000,139448255.0000,139460218.0000,139063636.0000,139145240.0000,139932392.0000,139258696.0000,134002831.0000,134598209.0000,139346101.0000,138817971.0000,139680064.0000,138848940.0000,138567757.0000,134120343.0000,138996879.0000,138993874.0000,139131845.0000,139114312.0000,139510963.0000,139588270.0000,134563743.0000,139155781.0000,140140466.0000,139315133.0000,139141904.0000,138770060.0000,139156091.0000,134163585.0000,139319231.0000,138996720.0000,140062027.0000,139166762.0000,138802983.0000,139040603.0000,138984517.0000,134234570.0000,134348546.0000,140011281.0000,134087180.0000,137642554.0000,131218457.0000,137246534.0000,135380229.0000,139270939.0000,139339149.0000,133504858.0000,139030083.0000,139478882.0000,139937502.0000,140582593.0000,138955141.0000,138601111.0000,140140977.0000,139359596.0000,139531994.0000,139105255.0000,138596721.0000" +generating large command graphs for N nodes - 16,wave_sim topology,100,1,13432604500,133825598.1300,133568250.7900,133974576.3800,981360.6993,635137.3358,1393069.7681,"133955792.0000,134156622.0000,133387295.0000,130373156.0000,134397028.0000,134008121.0000,134112438.0000,134940177.0000,134263615.0000,133769769.0000,134391737.0000,133753769.0000,134195476.0000,133813442.0000,134110855.0000,134287220.0000,133771121.0000,129573752.0000,133671082.0000,133968806.0000,133256096.0000,130120847.0000,134067363.0000,133878605.0000,134008190.0000,133959288.0000,134143357.0000,133891891.0000,133603725.0000,133864709.0000,134067503.0000,134078414.0000,132982137.0000,134443005.0000,134246532.0000,134012619.0000,133941054.0000,134098712.0000,133949159.0000,134034721.0000,134109293.0000,133999234.0000,134029962.0000,134268313.0000,134326184.0000,134003572.0000,134042316.0000,133909594.0000,134309031.0000,134108702.0000,134510983.0000,134132366.0000,134105886.0000,134039290.0000,134137095.0000,133924863.0000,134257723.0000,134020504.0000,134046163.0000,133875770.0000,133986210.0000,134404572.0000,129167622.0000,134066462.0000,134050170.0000,134098361.0000,133906879.0000,133847065.0000,134028429.0000,133884707.0000,134085427.0000,134541030.0000,134234671.0000,134541070.0000,134079756.0000,134001748.0000,134015565.0000,133853097.0000,134052094.0000,134130152.0000,133918170.0000,129487859.0000,134006107.0000,134323999.0000,134533115.0000,133851875.0000,133838991.0000,134100475.0000,134081609.0000,133901179.0000,134108882.0000,134202509.0000,132923997.0000,134177422.0000,134463874.0000,134181870.0000,133897662.0000,133885168.0000,134037236.0000,133956683.0000" +generating large command graphs for N nodes - 16,jacobi topology,100,1,12864888100,128612549.4500,128298957.8000,128799203.9700,1210894.0416,806658.6214,1686834.3720,"128815986.0000,128669719.0000,128497724.0000,129093091.0000,128375713.0000,123565662.0000,128877863.0000,128731336.0000,129111647.0000,128878084.0000,128979136.0000,128464110.0000,128465533.0000,128920474.0000,129009363.0000,129171730.0000,129614921.0000,128986499.0000,123237099.0000,128939500.0000,128878304.0000,128653658.0000,128670841.0000,129067853.0000,129114031.0000,129208380.0000,129074576.0000,128909404.0000,129137485.0000,129271529.0000,128941594.0000,129452382.0000,128827469.0000,128931755.0000,128839050.0000,129275948.0000,129256661.0000,129430160.0000,129001078.0000,128907750.0000,128403936.0000,129244969.0000,128751003.0000,129120773.0000,129035243.0000,128840062.0000,128736917.0000,128821917.0000,128724232.0000,123597493.0000,129458293.0000,128774337.0000,129111816.0000,129006697.0000,128754531.0000,129075197.0000,129095555.0000,129256711.0000,128896569.0000,128822879.0000,128466455.0000,128910626.0000,128855211.0000,128881751.0000,128647497.0000,128865470.0000,129004303.0000,128857374.0000,129420841.0000,128879366.0000,129014893.0000,128818822.0000,128834142.0000,128576573.0000,129055189.0000,129136724.0000,129259206.0000,129167282.0000,128548330.0000,129036965.0000,123568336.0000,128661493.0000,128888374.0000,128910947.0000,129245310.0000,129051793.0000,128805406.0000,128910656.0000,128342119.0000,129427805.0000,128765771.0000,128984475.0000,128420838.0000,128735714.0000,127674544.0000,125010048.0000,128962264.0000,129067573.0000,127489584.0000,125310647.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,soup topology,100,1,2751614200,27559385.8000,27532917.4300,27569882.9000,80392.9848,39568.7557,170037.2688,"27542987.0000,27546874.0000,27581309.0000,27595445.0000,27552184.0000,27594214.0000,27552365.0000,27521305.0000,27558266.0000,27594424.0000,27523119.0000,27571139.0000,27643727.0000,27596458.0000,27630542.0000,27653426.0000,27542906.0000,27598091.0000,26872236.0000,27548538.0000,27562944.0000,27592230.0000,27586088.0000,27559619.0000,27591569.0000,27621396.0000,27509122.0000,27568426.0000,27572763.0000,27517619.0000,27583464.0000,27509724.0000,27561662.0000,27595756.0000,27583544.0000,27583754.0000,27582021.0000,27498272.0000,27621817.0000,27531715.0000,27649118.0000,27583042.0000,27555791.0000,27537566.0000,27489846.0000,27444971.0000,27545722.0000,27491860.0000,27504764.0000,27497731.0000,27613240.0000,27508903.0000,27569386.0000,27562705.0000,27559418.0000,27542266.0000,27520023.0000,27512730.0000,27532437.0000,27544670.0000,27592350.0000,27603180.0000,27638628.0000,27558236.0000,27613450.0000,27648065.0000,27608662.0000,27552955.0000,27607530.0000,27590667.0000,27595877.0000,27563245.0000,27622608.0000,27527988.0000,27593282.0000,27554829.0000,27528409.0000,27575940.0000,27562112.0000,27596508.0000,27578214.0000,27565520.0000,27617728.0000,27611958.0000,27588543.0000,27590958.0000,27560620.0000,27564007.0000,27490297.0000,27539830.0000,27552515.0000,27588903.0000,27582001.0000,27532195.0000,27550321.0000,27612137.0000,27552184.0000,27614362.0000,27526376.0000,27466141.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,chain topology,100,1,28329800,284061.6300,283665.0800,284703.0500,2511.8122,1771.4221,3622.0674,"283035.0000,283344.0000,289576.0000,283375.0000,283205.0000,284276.0000,284728.0000,283845.0000,282523.0000,284116.0000,284918.0000,287883.0000,282684.0000,283695.0000,284107.0000,283715.0000,283455.0000,282353.0000,282173.0000,282844.0000,282703.0000,283415.0000,283315.0000,283175.0000,284577.0000,293404.0000,283164.0000,283235.0000,282483.0000,280911.0000,281932.0000,280850.0000,281211.0000,282262.0000,283875.0000,283225.0000,283265.0000,284156.0000,282774.0000,282874.0000,289917.0000,282764.0000,283876.0000,283234.0000,283615.0000,282543.0000,283165.0000,283294.0000,282423.0000,283324.0000,284197.0000,283375.0000,282523.0000,282804.0000,293975.0000,284006.0000,282974.0000,283866.0000,283445.0000,282704.0000,283425.0000,283535.0000,283866.0000,282523.0000,282954.0000,284257.0000,285118.0000,284698.0000,289927.0000,282623.0000,282283.0000,283595.0000,283374.0000,284978.0000,283716.0000,283745.0000,284197.0000,283004.0000,284136.0000,283786.0000,284607.0000,284437.0000,297481.0000,284336.0000,285088.0000,284628.0000,283234.0000,284347.0000,283635.0000,283795.0000,284978.0000,283866.0000,282774.0000,281952.0000,283525.0000,283135.0000,290638.0000,284107.0000,283525.0000,283655.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,44956200,449069.7400,448376.6400,449893.8100,3838.9771,3257.8687,4643.2876,"444219.0000,456523.0000,457364.0000,458306.0000,453577.0000,450912.0000,451804.0000,450562.0000,450732.0000,451122.0000,450581.0000,451403.0000,455821.0000,449680.0000,451594.0000,451593.0000,450291.0000,450051.0000,449179.0000,450241.0000,450181.0000,462103.0000,446093.0000,446223.0000,445772.0000,445653.0000,445963.0000,446644.0000,446373.0000,445912.0000,452345.0000,445492.0000,447406.0000,444630.0000,446494.0000,446053.0000,446474.0000,446443.0000,446404.0000,449860.0000,445101.0000,445401.0000,446023.0000,445902.0000,447045.0000,445392.0000,446674.0000,446304.0000,458897.0000,451604.0000,450321.0000,452145.0000,451463.0000,451644.0000,447686.0000,446253.0000,445282.0000,452986.0000,448668.0000,446384.0000,444981.0000,446434.0000,446754.0000,445702.0000,445782.0000,446524.0000,452475.0000,446724.0000,445772.0000,446174.0000,444750.0000,443819.0000,444711.0000,444810.0000,445893.0000,460781.0000,451343.0000,451103.0000,452094.0000,451714.0000,451683.0000,450601.0000,448868.0000,450672.0000,459008.0000,450722.0000,450902.0000,451123.0000,450381.0000,451153.0000,449720.0000,450591.0000,451444.0000,446984.0000,445972.0000,445652.0000,446213.0000,446224.0000,446493.0000,444980.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,49779100,495187.3700,494519.9700,496014.1700,3751.5086,3079.5909,4704.3550,"497711.0000,497240.0000,503682.0000,497290.0000,496318.0000,497731.0000,498182.0000,498142.0000,508812.0000,497570.0000,492291.0000,493273.0000,492731.0000,493192.0000,493022.0000,492831.0000,499264.0000,494455.0000,494204.0000,493563.0000,493763.0000,493583.0000,494485.0000,492651.0000,508341.0000,496859.0000,496579.0000,496709.0000,496429.0000,496548.0000,497951.0000,496178.0000,503912.0000,497049.0000,497881.0000,497239.0000,496348.0000,496388.0000,496539.0000,491579.0000,496409.0000,491108.0000,491569.0000,492872.0000,491469.0000,492401.0000,492060.0000,492672.0000,506958.0000,495868.0000,496759.0000,492020.0000,492581.0000,492631.0000,492310.0000,493152.0000,499204.0000,493663.0000,492842.0000,493062.0000,492711.0000,494295.0000,492070.0000,492761.0000,497200.0000,491559.0000,491539.0000,490316.0000,491549.0000,491439.0000,491669.0000,491670.0000,504393.0000,496810.0000,491529.0000,491930.0000,493072.0000,492411.0000,492320.0000,491589.0000,496498.0000,492941.0000,492510.0000,491889.0000,491749.0000,489876.0000,490728.0000,492571.0000,499384.0000,497771.0000,495577.0000,495206.0000,496468.0000,496558.0000,496058.0000,496538.0000,497239.0000,501839.0000,498913.0000,495467.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,224745800,2244337.3400,2241491.0000,2246608.9900,12859.1365,10340.1068,15929.7977,"2249969.0000,2255450.0000,2258465.0000,2253757.0000,2245852.0000,2263836.0000,2247566.0000,2217698.0000,2204283.0000,2245952.0000,2245601.0000,2254899.0000,2249709.0000,2244850.0000,2257565.0000,2241123.0000,2244760.0000,2241163.0000,2256693.0000,2240412.0000,2202640.0000,2210334.0000,2206448.0000,2229020.0000,2239130.0000,2247234.0000,2227717.0000,2251012.0000,2248927.0000,2241553.0000,2248567.0000,2239380.0000,2249699.0000,2236224.0000,2248427.0000,2236825.0000,2252154.0000,2258646.0000,2242346.0000,2248817.0000,2243467.0000,2250271.0000,2237055.0000,2250742.0000,2255079.0000,2241854.0000,2252394.0000,2242365.0000,2257935.0000,2239260.0000,2250220.0000,2242325.0000,2272232.0000,2258185.0000,2242295.0000,2246644.0000,2244139.0000,2256512.0000,2238909.0000,2250431.0000,2245912.0000,2242324.0000,2253746.0000,2246303.0000,2249670.0000,2240301.0000,2258186.0000,2243047.0000,2249379.0000,2240802.0000,2243377.0000,2253797.0000,2241013.0000,2253968.0000,2243838.0000,2260901.0000,2247605.0000,2246784.0000,2256131.0000,2243267.0000,2264478.0000,2249138.0000,2248307.0000,2242586.0000,2255610.0000,2252614.0000,2244599.0000,2253396.0000,2236204.0000,2255210.0000,2229451.0000,2204093.0000,2206017.0000,2232567.0000,2239409.0000,2231404.0000,2234961.0000,2245842.0000,2248456.0000,2242024.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation,jacobi topology,100,1,85332500,852012.1500,851292.3400,852991.8800,4278.9703,3406.4224,6124.1695,"851451.0000,849477.0000,856801.0000,850700.0000,849627.0000,859406.0000,846792.0000,847624.0000,852312.0000,849738.0000,857412.0000,851581.0000,853635.0000,852032.0000,859235.0000,852844.0000,850930.0000,851401.0000,851921.0000,874173.0000,852673.0000,852042.0000,851260.0000,847954.0000,858935.0000,851160.0000,850860.0000,848385.0000,854326.0000,848265.0000,849327.0000,849888.0000,851220.0000,863513.0000,849287.0000,849337.0000,851291.0000,849217.0000,855648.0000,849036.0000,850840.0000,850088.0000,861660.0000,851290.0000,850579.0000,849246.0000,848986.0000,855849.0000,845209.0000,848635.0000,849738.0000,849467.0000,860628.0000,847534.0000,848715.0000,848254.0000,849797.0000,855659.0000,848506.0000,848906.0000,850339.0000,861560.0000,849637.0000,848035.0000,850138.0000,848806.0000,855870.0000,850088.0000,849617.0000,849216.0000,849127.0000,853975.0000,849737.0000,850379.0000,848555.0000,859586.0000,852814.0000,850539.0000,849758.0000,851781.0000,857311.0000,849727.0000,851241.0000,851651.0000,852293.0000,856250.0000,850479.0000,850329.0000,851200.0000,861991.0000,850970.0000,851261.0000,850849.0000,851782.0000,855739.0000,847934.0000,852072.0000,851762.0000,850088.0000,854427.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,soup topology,100,1,2568155800,24180555.1200,23681514.4300,24600593.5700,2329883.7694,2023565.0307,2697897.1873,"24390276.0000,25173579.0000,26577167.0000,24018512.0000,20481943.0000,26015293.0000,24971445.0000,24791736.0000,21554214.0000,20254632.0000,21431882.0000,22553295.0000,27011320.0000,25204838.0000,26306785.0000,26686545.0000,25017493.0000,25186494.0000,24406376.0000,25821265.0000,25568156.0000,22630382.0000,24750047.0000,23866072.0000,20798802.0000,18683206.0000,26392418.0000,25919481.0000,27589776.0000,26782385.0000,18285192.0000,17345752.0000,18744563.0000,22615674.0000,22848526.0000,20615696.0000,25358780.0000,26188862.0000,24692027.0000,25449892.0000,26103801.0000,24734227.0000,25387775.0000,25521358.0000,25954678.0000,25182976.0000,22006520.0000,24452563.0000,22994932.0000,25073529.0000,25989425.0000,24598290.0000,24240340.0000,19133459.0000,26377039.0000,25740953.0000,21619267.0000,25822468.0000,25944379.0000,24979591.0000,22107071.0000,20111351.0000,21456218.0000,25559900.0000,25123083.0000,25872493.0000,26606593.0000,21715760.0000,24003723.0000,25549131.0000,26606242.0000,25573777.0000,26056851.0000,26543744.0000,27122810.0000,24719228.0000,24020255.0000,26916059.0000,26269194.0000,25699966.0000,26385894.0000,26360928.0000,23754271.0000,23580250.0000,24950096.0000,22231787.0000,24076039.0000,25441997.0000,24500664.0000,24703739.0000,22215185.0000,24201067.0000,25544281.0000,26754824.0000,25201182.0000,25042811.0000,19247544.0000,19700252.0000,20387634.0000,21303269.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,chain topology,100,1,84146500,1099782.4200,1036208.4000,1167668.7000,336206.0653,315260.3358,355152.7604,"843616.0000,870056.0000,746692.0000,957572.0000,922195.0000,1143915.0000,1276926.0000,1096324.0000,1143163.0000,1168581.0000,1389890.0000,1511841.0000,1542669.0000,1543612.0000,1572877.0000,1514757.0000,1546928.0000,1486294.0000,1514757.0000,1520799.0000,1438383.0000,1543392.0000,1594549.0000,1598746.0000,1596171.0000,1463009.0000,1170355.0000,890846.0000,757072.0000,1010892.0000,932715.0000,868774.0000,841913.0000,754016.0000,871789.0000,929479.0000,1310249.0000,1485211.0000,1387325.0000,1490341.0000,1596272.0000,1547609.0000,1404638.0000,1569881.0000,1572737.0000,1512704.0000,1599789.0000,1595490.0000,1649783.0000,1435668.0000,1439715.0000,1543742.0000,1462268.0000,1542720.0000,1467557.0000,1567447.0000,1496733.0000,1103258.0000,817847.0000,783512.0000,869404.0000,958203.0000,754037.0000,809942.0000,788982.0000,695626.0000,811926.0000,870126.0000,783763.0000,784514.0000,785566.0000,784203.0000,781579.0000,726023.0000,755789.0000,784293.0000,902387.0000,783051.0000,895905.0000,787059.0000,784384.0000,779584.0000,784183.0000,785496.0000,811495.0000,753836.0000,818078.0000,869235.0000,811966.0000,812798.0000,843085.0000,721084.0000,759968.0000,724691.0000,814411.0000,756100.0000,870206.0000,752904.0000,811515.0000,842784.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,expanding tree topology,100,1,124920700,1232532.5200,1213465.0100,1258126.9700,111928.7784,87353.6332,158951.1774,"1104160.0000,1221111.0000,1024529.0000,1188078.0000,1188539.0000,1401052.0000,1308186.0000,1301052.0000,1422382.0000,1272678.0000,1197116.0000,1160527.0000,1125420.0000,1136540.0000,1192647.0000,1100232.0000,1164824.0000,1191615.0000,1249194.0000,1157580.0000,1253502.0000,1331119.0000,1225098.0000,1272448.0000,1309498.0000,1248002.0000,1364422.0000,1332872.0000,1309298.0000,1276025.0000,1219598.0000,1246589.0000,1163462.0000,1164724.0000,1422983.0000,1657447.0000,1799657.0000,1105603.0000,1214810.0000,1280113.0000,1192477.0000,1392195.0000,1249846.0000,1272668.0000,1134016.0000,1251379.0000,1187377.0000,1217604.0000,1160856.0000,1222494.0000,1159064.0000,1159594.0000,1251218.0000,1223255.0000,1305531.0000,1165455.0000,1098409.0000,1128175.0000,1100663.0000,1253051.0000,1219818.0000,1191364.0000,1163311.0000,1188078.0000,1134687.0000,1100883.0000,1284160.0000,1277227.0000,1334867.0000,1338203.0000,1306052.0000,1272247.0000,1249094.0000,1221531.0000,1339205.0000,1308767.0000,1246900.0000,1274241.0000,1218295.0000,1310621.0000,1246459.0000,1512252.0000,1397715.0000,1191194.0000,1132734.0000,1225359.0000,1154665.0000,1104130.0000,1165967.0000,1158863.0000,1191795.0000,1161678.0000,1158913.0000,1131992.0000,1131982.0000,1252550.0000,1101945.0000,1159183.0000,1135850.0000,1128416.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,contracting tree topology,100,1,138984900,1351947.5500,1334678.7000,1374557.8200,100814.9332,80851.9009,129340.8642,"1511591.0000,1511891.0000,1468930.0000,1479130.0000,1545765.0000,1558570.0000,1542860.0000,1543641.0000,1679649.0000,1705017.0000,1758539.0000,1226531.0000,1386735.0000,1327071.0000,1277778.0000,1279983.0000,1337210.0000,1248613.0000,1245537.0000,1282226.0000,1243854.0000,1217043.0000,1251268.0000,1278269.0000,1332853.0000,1306272.0000,1335147.0000,1278470.0000,1336359.0000,1246519.0000,1305781.0000,1250547.0000,1309138.0000,1276727.0000,1273380.0000,1251969.0000,1302004.0000,1310541.0000,1305811.0000,1303367.0000,1305280.0000,1249695.0000,1306833.0000,1306433.0000,1359222.0000,1279291.0000,1306333.0000,1342040.0000,1268831.0000,1309558.0000,1247951.0000,1246038.0000,1249605.0000,1336068.0000,1306322.0000,1304889.0000,1277908.0000,1247852.0000,1309549.0000,1393237.0000,1334336.0000,1336329.0000,1335267.0000,1397515.0000,1274132.0000,1453852.0000,1329466.0000,1284972.0000,1450636.0000,1332672.0000,1335989.0000,1367848.0000,1363100.0000,1332933.0000,1367027.0000,1364873.0000,1331530.0000,1306543.0000,1423675.0000,1369292.0000,1330828.0000,1393988.0000,1307624.0000,1363611.0000,1333143.0000,1333965.0000,1368500.0000,1330879.0000,1338604.0000,1334265.0000,1338654.0000,1389730.0000,1392996.0000,1396383.0000,1394779.0000,1364031.0000,1361326.0000,1394489.0000,1598737.0000,1450715.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,wave_sim topology,100,1,635012700,6591218.1200,6387129.1600,6862192.8800,1189268.7292,947913.1513,1472206.4450,"7565929.0000,5175200.0000,5496659.0000,6176897.0000,5770619.0000,5695075.0000,5983421.0000,6417574.0000,6383639.0000,6447740.0000,6334477.0000,6477778.0000,6434845.0000,6608926.0000,6506762.0000,6548311.0000,6449885.0000,6478238.0000,6474532.0000,6471947.0000,6502123.0000,6468620.0000,6476896.0000,6503836.0000,6459784.0000,6463310.0000,6469942.0000,6471696.0000,6483429.0000,6537510.0000,6522032.0000,7172764.0000,10087735.0000,5542146.0000,5780637.0000,5462475.0000,5918198.0000,5784274.0000,5744819.0000,5810774.0000,5782551.0000,5833357.0000,5820653.0000,5824680.0000,5652754.0000,5698171.0000,5516457.0000,5906996.0000,6097527.0000,6412154.0000,6381364.0000,6371888.0000,6354655.0000,6412163.0000,6285543.0000,6046441.0000,6195002.0000,6021613.0000,6248744.0000,6433994.0000,6391945.0000,6479190.0000,6464993.0000,6448392.0000,6506843.0000,6446418.0000,6476696.0000,6879067.0000,6944561.0000,10368126.0000,10678283.0000,5467033.0000,5692590.0000,5768343.0000,5532036.0000,5570128.0000,7827313.0000,9782537.0000,4949973.0000,6816870.0000,6774429.0000,6712963.0000,10483976.0000,8048683.0000,8102806.0000,5884293.0000,5664927.0000,5469778.0000,5456143.0000,5780106.0000,5623539.0000,5736534.0000,5668484.0000,7131546.0000,8984055.0000,8632147.0000,8271435.0000,8904103.0000,9455859.0000,8986508.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread,jacobi topology,100,1,255709100,2571332.2200,2537415.5400,2612266.1900,187986.2938,158162.5381,221472.7310,"3026651.0000,3008356.0000,2397780.0000,2325794.0000,2468644.0000,2396356.0000,2293532.0000,2326235.0000,2436914.0000,2409101.0000,2439108.0000,2443366.0000,2402729.0000,2440991.0000,2404502.0000,2442735.0000,2436213.0000,2413580.0000,2434459.0000,2413328.0000,2433086.0000,2412317.0000,2441834.0000,2437776.0000,2416385.0000,2431333.0000,2469256.0000,2469636.0000,2461611.0000,2360509.0000,2410233.0000,2429109.0000,2443737.0000,2402489.0000,2413770.0000,2447524.0000,2403520.0000,2471980.0000,2465017.0000,2496156.0000,2463835.0000,2438126.0000,2410704.0000,2416094.0000,2373374.0000,2415574.0000,2404613.0000,2761027.0000,2706554.0000,2579604.0000,2670355.0000,2611103.0000,2552403.0000,2728636.0000,2644587.0000,2934006.0000,2849035.0000,2639757.0000,2548435.0000,2590465.0000,2522256.0000,2644497.0000,2702727.0000,2606976.0000,2696074.0000,2613849.0000,2646221.0000,2561811.0000,2487560.0000,2649076.0000,2551010.0000,2581768.0000,2554255.0000,2584564.0000,2588371.0000,2697728.0000,2549808.0000,2527987.0000,2674354.0000,2610162.0000,2643264.0000,2612036.0000,2619459.0000,2577871.0000,2667901.0000,2644647.0000,2672389.0000,2583041.0000,2466019.0000,2612998.0000,2555899.0000,2526133.0000,2804651.0000,3056617.0000,3016892.0000,3078749.0000,2988398.0000,3072588.0000,2991314.0000,3075363.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,2858516700,29500978.5300,29339932.1800,29539199.4000,344509.1771,45670.4286,807505.1540,"29664486.0000,29614911.0000,29536212.0000,29542113.0000,29640631.0000,29495054.0000,29532545.0000,29498771.0000,29498150.0000,29538466.0000,29512266.0000,29566470.0000,29549207.0000,29553244.0000,29516966.0000,29532795.0000,29528278.0000,29546862.0000,29540180.0000,29559436.0000,29472862.0000,29513529.0000,29577871.0000,29415233.0000,29491798.0000,29561571.0000,29491397.0000,29529028.0000,29503480.0000,29546081.0000,29506566.0000,29601956.0000,29462552.0000,29570116.0000,29551059.0000,29560518.0000,29534479.0000,29509652.0000,29519891.0000,29551170.0000,29613659.0000,29585465.0000,29560889.0000,29597027.0000,29596627.0000,29493221.0000,29560738.0000,29521274.0000,29528638.0000,29517026.0000,29500094.0000,29514851.0000,29548045.0000,29545780.0000,29575586.0000,29510523.0000,29580656.0000,29572251.0000,28938981.0000,26150941.0000,29518809.0000,29587549.0000,29560498.0000,29540850.0000,29587589.0000,29505654.0000,29521474.0000,29566529.0000,29489524.0000,29507798.0000,29586888.0000,29611154.0000,29593170.0000,29495325.0000,29515613.0000,29501637.0000,29475467.0000,29531563.0000,29510714.0000,29594302.0000,29468835.0000,29550569.0000,29567411.0000,29618538.0000,29591006.0000,29530521.0000,29498120.0000,29490575.0000,29539830.0000,29510062.0000,29480928.0000,29543476.0000,29566360.0000,29500865.0000,29616654.0000,29561039.0000,29562692.0000,29563845.0000,29542874.0000,29541422.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,57648100,572743.4600,570260.5900,574607.1600,10841.9639,8528.8132,13077.8409,"546904.0000,544389.0000,582762.0000,574526.0000,575288.0000,576259.0000,573946.0000,576229.0000,574937.0000,572813.0000,575568.0000,577061.0000,581329.0000,575317.0000,575258.0000,576610.0000,577573.0000,576229.0000,575078.0000,586408.0000,575659.0000,575548.0000,576911.0000,577402.0000,576360.0000,574777.0000,577351.0000,577512.0000,576270.0000,574496.0000,575929.0000,575769.0000,574957.0000,578765.0000,574005.0000,575708.0000,575468.0000,575719.0000,575939.0000,576369.0000,588182.0000,576069.0000,577151.0000,577402.0000,575869.0000,574636.0000,576750.0000,581930.0000,575488.0000,575678.0000,575689.0000,575688.0000,576190.0000,575117.0000,582301.0000,575207.0000,575468.0000,575729.0000,576209.0000,574997.0000,575819.0000,584815.0000,576040.0000,576259.0000,575749.0000,574967.0000,576550.0000,576600.0000,582040.0000,577442.0000,574666.0000,574466.0000,575638.0000,575999.0000,586629.0000,576661.0000,575869.0000,574566.0000,574737.0000,576009.0000,575338.0000,583653.0000,575177.0000,576029.0000,577683.0000,577121.0000,576440.0000,575869.0000,573464.0000,543167.0000,545271.0000,545391.0000,544640.0000,544520.0000,544810.0000,544579.0000,560209.0000,543437.0000,544770.0000,544109.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,75329600,754992.0400,754264.2700,755866.0600,4028.0903,3341.1359,4895.9133,"757653.0000,754688.0000,761761.0000,764927.0000,753315.0000,753425.0000,753565.0000,753284.0000,754406.0000,760518.0000,753636.0000,753525.0000,752794.0000,754327.0000,758585.0000,753275.0000,753846.0000,753736.0000,753205.0000,754447.0000,753786.0000,752594.0000,753896.0000,752012.0000,759597.0000,755960.0000,754147.0000,755639.0000,755078.0000,753745.0000,767051.0000,755519.0000,754788.0000,754086.0000,755048.0000,758444.0000,755780.0000,755419.0000,755108.0000,754687.0000,766099.0000,755740.0000,754457.0000,754758.0000,752824.0000,754658.0000,757943.0000,748425.0000,749377.0000,747213.0000,747704.0000,760940.0000,752112.0000,752964.0000,754116.0000,754157.0000,760138.0000,753856.0000,754497.0000,754577.0000,754948.0000,755319.0000,761711.0000,755699.0000,755358.0000,755930.0000,755699.0000,768003.0000,755659.0000,756311.0000,754256.0000,754406.0000,759597.0000,755279.0000,754858.0000,754858.0000,755539.0000,760499.0000,756120.0000,755109.0000,754757.0000,755068.0000,754808.0000,762502.0000,751472.0000,750159.0000,748806.0000,751582.0000,756962.0000,751081.0000,750359.0000,749798.0000,750089.0000,749367.0000,750169.0000,750360.0000,750970.0000,749618.0000,751041.0000,767221.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,80084300,800417.7300,799783.9600,801602.8400,4268.8934,2778.7895,7455.2700,"800475.0000,798971.0000,804892.0000,799301.0000,804401.0000,799312.0000,800634.0000,800244.0000,800665.0000,805764.0000,800465.0000,799492.0000,799573.0000,799001.0000,810223.0000,800505.0000,799713.0000,798841.0000,800124.0000,801506.0000,800464.0000,799463.0000,799242.0000,798991.0000,805543.0000,799332.0000,798491.0000,798230.0000,798691.0000,830401.0000,797679.0000,798350.0000,799002.0000,797969.0000,811465.0000,798831.0000,799512.0000,796827.0000,798671.0000,799703.0000,798290.0000,799102.0000,799993.0000,799663.0000,804452.0000,799743.0000,798270.0000,799352.0000,797910.0000,799863.0000,798701.0000,798921.0000,797489.0000,798871.0000,803119.0000,800054.0000,798300.0000,798571.0000,799102.0000,807948.0000,798892.0000,799001.0000,797779.0000,798771.0000,800143.0000,798480.0000,799543.0000,796146.0000,798551.0000,810823.0000,797097.0000,798010.0000,799352.0000,798871.0000,803610.0000,798921.0000,798601.0000,797649.0000,798290.0000,805163.0000,798140.0000,798872.0000,798550.0000,799052.0000,810433.0000,799102.0000,797228.0000,799743.0000,799032.0000,800314.0000,799092.0000,799011.0000,798891.0000,798320.0000,807658.0000,799623.0000,800193.0000,798952.0000,798781.0000,798420.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,422445000,4286679.0600,4284558.1800,4288326.4400,9473.3357,7349.0534,12752.2891,"4284904.0000,4288080.0000,4299311.0000,4287889.0000,4290324.0000,4286577.0000,4291777.0000,4285776.0000,4272782.0000,4287258.0000,4290745.0000,4287840.0000,4289924.0000,4287729.0000,4291106.0000,4281979.0000,4287419.0000,4293460.0000,4292067.0000,4284423.0000,4284684.0000,4292759.0000,4284523.0000,4294362.0000,4284473.0000,4291287.0000,4287708.0000,4296876.0000,4287900.0000,4284203.0000,4286046.0000,4286116.0000,4286858.0000,4283943.0000,4295875.0000,4282108.0000,4283561.0000,4282910.0000,4287088.0000,4284072.0000,4287499.0000,4296016.0000,4287980.0000,4278913.0000,4289783.0000,4281197.0000,4279384.0000,4280626.0000,4278762.0000,4279774.0000,4285385.0000,4281829.0000,4285795.0000,4284814.0000,4305814.0000,4305133.0000,4289162.0000,4245950.0000,4264636.0000,4285506.0000,4278342.0000,4297748.0000,4288290.0000,4291607.0000,4283010.0000,4286717.0000,4292588.0000,4286918.0000,4293721.0000,4300503.0000,4285695.0000,4282609.0000,4296746.0000,4281919.0000,4288862.0000,4296846.0000,4290094.0000,4287289.0000,4290244.0000,4286728.0000,4300744.0000,4287930.0000,4296707.0000,4292358.0000,4298961.0000,4288541.0000,4281047.0000,4297207.0000,4273352.0000,4247303.0000,4275516.0000,4275115.0000,4300713.0000,4288921.0000,4296876.0000,4283401.0000,4281247.0000,4290805.0000,4255128.0000,4286878.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,135461600,1347019.1000,1340348.1800,1351250.7100,26704.5633,18406.8968,36121.9602,"1354414.0000,1357269.0000,1364112.0000,1283599.0000,1241690.0000,1242782.0000,1243553.0000,1244295.0000,1243844.0000,1287697.0000,1340236.0000,1342971.0000,1356107.0000,1352941.0000,1355766.0000,1362349.0000,1358211.0000,1357409.0000,1362609.0000,1356508.0000,1355856.0000,1359323.0000,1355054.0000,1355325.0000,1363621.0000,1358271.0000,1357059.0000,1363530.0000,1340747.0000,1339666.0000,1347390.0000,1340518.0000,1342220.0000,1345436.0000,1338793.0000,1335928.0000,1357980.0000,1355325.0000,1340898.0000,1334777.0000,1335137.0000,1332151.0000,1360445.0000,1352841.0000,1355666.0000,1357669.0000,1355455.0000,1356918.0000,1363670.0000,1354544.0000,1355626.0000,1365013.0000,1354815.0000,1354403.0000,1361076.0000,1352389.0000,1364533.0000,1358591.0000,1356156.0000,1359783.0000,1338594.0000,1338984.0000,1352039.0000,1355696.0000,1357720.0000,1360234.0000,1355425.0000,1356297.0000,1358571.0000,1352500.0000,1353432.0000,1366937.0000,1354574.0000,1354003.0000,1359142.0000,1353912.0000,1355385.0000,1360224.0000,1353552.0000,1355797.0000,1360455.0000,1352610.0000,1355085.0000,1358651.0000,1356538.0000,1354985.0000,1358471.0000,1355335.0000,1336289.0000,1358200.0000,1354884.0000,1354484.0000,1359844.0000,1353952.0000,1354835.0000,1363120.0000,1355095.0000,1356367.0000,1352710.0000,1354022.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,2270129500,24730255.7400,24241949.2900,25255299.0200,2592825.5112,2307991.3743,3081111.4318,"23332553.0000,27045234.0000,27208734.0000,23700489.0000,20972832.0000,24962329.0000,19020605.0000,20754249.0000,27678103.0000,27127559.0000,25534824.0000,22327077.0000,22828547.0000,23626599.0000,22890064.0000,22575378.0000,21988586.0000,24913467.0000,22338860.0000,22255132.0000,26991862.0000,27643087.0000,27671710.0000,27952994.0000,23068522.0000,22046104.0000,20761001.0000,22105789.0000,22989012.0000,23068982.0000,22028943.0000,23445867.0000,26259526.0000,29346933.0000,26353314.0000,23116291.0000,25691991.0000,26389011.0000,27104105.0000,23776232.0000,28121893.0000,26934315.0000,26914186.0000,30604275.0000,22953484.0000,33263472.0000,26373020.0000,26197679.0000,24092702.0000,23087447.0000,23552729.0000,24442525.0000,25325576.0000,23817270.0000,26712494.0000,22166042.0000,24387871.0000,23027595.0000,22264489.0000,22094156.0000,22269457.0000,22405896.0000,24539428.0000,21865884.0000,22039001.0000,22257446.0000,21580794.0000,22074309.0000,21055319.0000,25870238.0000,26118850.0000,23069544.0000,22320525.0000,21560434.0000,31623125.0000,27084227.0000,26964852.0000,27317349.0000,27384176.0000,27295477.0000,27615144.0000,23864550.0000,23917469.0000,24671588.0000,25232971.0000,22652613.0000,21838111.0000,25343642.0000,28500379.0000,27327369.0000,26857248.0000,26325090.0000,26929234.0000,23249965.0000,27005189.0000,27186882.0000,26590713.0000,21246672.0000,26636570.0000,26112127.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,133434400,1478179.9900,1439757.0000,1518683.9200,201333.8947,178207.9205,225490.4336,"1223195.0000,1769349.0000,1521580.0000,1507503.0000,1278559.0000,1594709.0000,1421240.0000,1451788.0000,1189481.0000,1198749.0000,1214538.0000,1482566.0000,1829002.0000,1801881.0000,1824854.0000,1828030.0000,1775561.0000,1824454.0000,1774109.0000,1830385.0000,1826548.0000,1773037.0000,1799838.0000,1828602.0000,1829183.0000,1827129.0000,1831768.0000,1772395.0000,1770091.0000,1825926.0000,1661444.0000,1826958.0000,1770201.0000,1771353.0000,1166197.0000,1310460.0000,1303988.0000,1218566.0000,1367258.0000,1449954.0000,1454162.0000,1449634.0000,1452649.0000,1451477.0000,1447279.0000,1453200.0000,1455625.0000,1449834.0000,1453932.0000,1184171.0000,1108347.0000,1452449.0000,1453431.0000,1451087.0000,1451207.0000,1448702.0000,1453201.0000,1452519.0000,1449203.0000,1449343.0000,1438683.0000,1397115.0000,1418475.0000,1453942.0000,1452850.0000,1451147.0000,1222263.0000,1424245.0000,1420779.0000,1449904.0000,1337321.0000,1424256.0000,1391343.0000,1449123.0000,1455816.0000,1449073.0000,1449524.0000,1454794.0000,1451167.0000,1449453.0000,1453902.0000,1448602.0000,1455024.0000,1447169.0000,1455224.0000,1450325.0000,1420569.0000,1453031.0000,1370084.0000,1359543.0000,1333414.0000,1367588.0000,1281365.0000,1298358.0000,1336951.0000,1192858.0000,1105001.0000,1165456.0000,1094511.0000,1193870.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,166403400,1668805.7000,1639881.5700,1699973.9500,153544.9173,141587.1235,165594.8242,"1831918.0000,1855913.0000,1891781.0000,1915526.0000,1918753.0000,1913863.0000,1882995.0000,1911479.0000,1838641.0000,1915817.0000,1859880.0000,1916198.0000,1915606.0000,1882944.0000,1892923.0000,1857336.0000,1917229.0000,1913813.0000,1918833.0000,1943269.0000,1541047.0000,1541278.0000,1508144.0000,1512052.0000,1480072.0000,1508525.0000,1479851.0000,1512333.0000,1541147.0000,1480072.0000,1479831.0000,1512994.0000,1476635.0000,1510369.0000,1510709.0000,1510609.0000,1627030.0000,1742859.0000,1764380.0000,1718813.0000,1743430.0000,1471806.0000,1463770.0000,1462177.0000,1513625.0000,1569471.0000,1535386.0000,1507954.0000,1509307.0000,1544563.0000,1682314.0000,1597293.0000,1621579.0000,1567808.0000,1540807.0000,1653369.0000,1568870.0000,1625717.0000,1598285.0000,1626419.0000,1566916.0000,1569471.0000,1649382.0000,1539024.0000,1627651.0000,1594408.0000,1599517.0000,1564371.0000,1566415.0000,1660954.0000,1827600.0000,1799917.0000,1740184.0000,1804456.0000,1849752.0000,1801360.0000,1672616.0000,1597634.0000,1682074.0000,1650594.0000,1574801.0000,1564401.0000,1604116.0000,1569631.0000,1512203.0000,1506412.0000,1509698.0000,1514567.0000,1567697.0000,1539274.0000,1594177.0000,1598325.0000,1831076.0000,1829333.0000,1827119.0000,1744883.0000,1856815.0000,1864169.0000,1849451.0000,1800709.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,170121700,1700208.0500,1679782.3500,1721298.7800,105883.9343,96884.2633,116996.4876,"1656265.0000,1653751.0000,1770461.0000,1858949.0000,1797943.0000,1768969.0000,1802542.0000,1479731.0000,1480983.0000,1574070.0000,1654582.0000,1622842.0000,1742699.0000,1738701.0000,1600179.0000,1685210.0000,1649231.0000,1604638.0000,1646877.0000,1595981.0000,1656064.0000,1596743.0000,1742779.0000,1654953.0000,1590841.0000,1745264.0000,1655533.0000,1653470.0000,1654642.0000,1653901.0000,1599348.0000,1594047.0000,1667066.0000,1697754.0000,1601471.0000,1621790.0000,1595190.0000,1654301.0000,1627230.0000,1596311.0000,1623843.0000,1769369.0000,1831918.0000,1856855.0000,1860983.0000,1824994.0000,1800829.0000,1855693.0000,1798404.0000,1862516.0000,1833942.0000,1823882.0000,1797974.0000,1825957.0000,1745324.0000,1913923.0000,1771353.0000,1857927.0000,1888415.0000,1885049.0000,1737769.0000,1865291.0000,1857085.0000,1826187.0000,1742128.0000,1830055.0000,1859490.0000,1827289.0000,1829704.0000,1824985.0000,1800037.0000,1773356.0000,1826668.0000,1542970.0000,1622872.0000,1627881.0000,1534034.0000,1549292.0000,1562638.0000,1651296.0000,1598356.0000,1599838.0000,1653289.0000,1741656.0000,1539564.0000,1654863.0000,1594177.0000,1654251.0000,1655804.0000,1655634.0000,1595851.0000,1652478.0000,1596823.0000,1656315.0000,1652788.0000,1656486.0000,1597343.0000,1653240.0000,1596152.0000,1652418.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,1134338800,9176514.3600,8901776.8400,9456608.3100,1415209.3538,1243563.0754,1626002.2462,"10174930.0000,10019426.0000,9656138.0000,8104799.0000,8522871.0000,10434141.0000,7811915.0000,7570798.0000,8778035.0000,9199984.0000,7807826.0000,10244383.0000,7682780.0000,7361492.0000,11605750.0000,12148538.0000,11406042.0000,10375930.0000,9979591.0000,10246716.0000,8656604.0000,8575631.0000,8255345.0000,7952721.0000,8276074.0000,8068520.0000,8778415.0000,8651555.0000,8452087.0000,8506069.0000,8475421.0000,8886270.0000,8780779.0000,8237270.0000,9987144.0000,10875738.0000,10570899.0000,10450092.0000,10930091.0000,9074396.0000,8696000.0000,8584288.0000,8389328.0000,10154061.0000,9627522.0000,6892012.0000,6449473.0000,9671928.0000,10403392.0000,11456198.0000,11752247.0000,11090224.0000,11894819.0000,10570469.0000,7639398.0000,9140069.0000,9113550.0000,5587601.0000,8309427.0000,8118345.0000,6929242.0000,6932690.0000,7252024.0000,7700795.0000,7564967.0000,6029808.0000,7795634.0000,8191995.0000,8006933.0000,7732484.0000,9605151.0000,9065259.0000,8465742.0000,9001328.0000,8432660.0000,8316621.0000,9378241.0000,9407687.0000,9384903.0000,9422916.0000,9325321.0000,9411224.0000,9383441.0000,9397388.0000,9360627.0000,9400884.0000,9410853.0000,9403941.0000,9404791.0000,9707355.0000,9997263.0000,9463954.0000,10566942.0000,12263927.0000,11708215.0000,10743056.0000,12322558.0000,12296179.0000,9109171.0000,7243709.0000" +building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,316607000,3163099.6000,3134469.9200,3188904.8700,137316.0115,51569.2603,248097.9957,"3165003.0000,3166075.0000,3133974.0000,3142420.0000,3205890.0000,3188758.0000,3184509.0000,3227040.0000,3164873.0000,3164532.0000,3166625.0000,3162328.0000,3170273.0000,3161616.0000,3163199.0000,3165544.0000,3160073.0000,3166826.0000,3172888.0000,3127261.0000,3163891.0000,3168870.0000,3162247.0000,3168240.0000,3157699.0000,3164121.0000,3164032.0000,2945086.0000,2233909.0000,2826522.0000,3116851.0000,4066330.0000,3138272.0000,3160445.0000,3107804.0000,3130176.0000,3227241.0000,3162227.0000,3108616.0000,3162638.0000,3192124.0000,3192986.0000,3166826.0000,3191663.0000,3165153.0000,3166856.0000,3158761.0000,3164021.0000,3167297.0000,3163160.0000,3170443.0000,3168369.0000,3164131.0000,3153962.0000,3167348.0000,3161807.0000,3170133.0000,3157428.0000,3165835.0000,3194969.0000,3197986.0000,3184349.0000,3198106.0000,3140686.0000,3191573.0000,3191734.0000,3199088.0000,3186764.0000,3195470.0000,3191773.0000,3194599.0000,3190882.0000,3193417.0000,3198005.0000,3135357.0000,3159672.0000,3167768.0000,3187716.0000,3170333.0000,3163701.0000,3199177.0000,3165754.0000,3156346.0000,3163771.0000,3165875.0000,3195421.0000,3158239.0000,3162077.0000,3194750.0000,3170073.0000,3164753.0000,3158451.0000,3164201.0000,3167648.0000,3166195.0000,3156497.0000,3166566.0000,3167437.0000,3166044.0000,3163510.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,soup topology,100,1,6295292300,65464242.8500,65131364.8300,65766087.0800,1614192.6466,1262784.6354,2183266.6725,"65921218.0000,63065570.0000,66189096.0000,66129683.0000,63489102.0000,66350461.0000,65804788.0000,65990679.0000,66070431.0000,61320123.0000,65798076.0000,66140954.0000,66325946.0000,66093765.0000,65990900.0000,66237809.0000,66293874.0000,66200618.0000,66184026.0000,66135545.0000,66202010.0000,66033621.0000,66065743.0000,66044181.0000,66254951.0000,66065852.0000,65873337.0000,65299201.0000,66184376.0000,61484345.0000,66196539.0000,66055763.0000,66195217.0000,72785420.0000,63779111.0000,66068147.0000,66078006.0000,66071703.0000,66080130.0000,65942679.0000,66138770.0000,66156604.0000,66339080.0000,59793752.0000,66244100.0000,66194186.0000,65485613.0000,61617447.0000,66171963.0000,66041166.0000,65963028.0000,65921850.0000,66067926.0000,66082123.0000,65965273.0000,63311014.0000,65607784.0000,66208412.0000,65148656.0000,63422495.0000,66074259.0000,66162705.0000,66209194.0000,65887674.0000,62517763.0000,64523390.0000,63435301.0000,64174029.0000,66239302.0000,66051064.0000,65961034.0000,66059931.0000,66104004.0000,66111108.0000,60517473.0000,66059120.0000,66120054.0000,65269715.0000,62035227.0000,66097302.0000,65910308.0000,66163818.0000,65991712.0000,66119133.0000,65968939.0000,65967616.0000,66044182.0000,66187121.0000,66084978.0000,63711883.0000,64210308.0000,64059933.0000,66196821.0000,66041476.0000,65657168.0000,61514833.0000,66180269.0000,66060332.0000,64204968.0000,66164600.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,chain topology,100,1,340156800,3451136.5300,3447521.7900,3455601.9900,20370.8452,16901.6648,24453.8481,"3435585.0000,3447778.0000,3510076.0000,3503875.0000,3430416.0000,3430926.0000,3446436.0000,3432650.0000,3428763.0000,3469640.0000,3440294.0000,3467725.0000,3438140.0000,3471233.0000,3458138.0000,3433391.0000,3439894.0000,3452387.0000,3435164.0000,3435415.0000,3446376.0000,3434684.0000,3445093.0000,3439202.0000,3439472.0000,3440444.0000,3445405.0000,3434112.0000,3460342.0000,3431107.0000,3431327.0000,3509816.0000,3457598.0000,3448600.0000,3448048.0000,3439412.0000,3437078.0000,3433922.0000,3451725.0000,3439994.0000,3448169.0000,3442689.0000,3441777.0000,3452427.0000,3502131.0000,3433482.0000,3432750.0000,3450254.0000,3433551.0000,3447708.0000,3440515.0000,3425496.0000,3486702.0000,3444201.0000,3444862.0000,3444993.0000,3448029.0000,3468838.0000,3509796.0000,3438541.0000,3456935.0000,3449061.0000,3453209.0000,3451346.0000,3449061.0000,3445934.0000,3443581.0000,3493876.0000,3426829.0000,3440986.0000,3483216.0000,3487553.0000,3442248.0000,3437309.0000,3483396.0000,3434262.0000,3476974.0000,3442649.0000,3445244.0000,3456215.0000,3440866.0000,3441576.0000,3447759.0000,3457587.0000,3455022.0000,3458458.0000,3445894.0000,3442568.0000,3435936.0000,3460312.0000,3442859.0000,3479088.0000,3448820.0000,3510648.0000,3461384.0000,3444041.0000,3432029.0000,3431678.0000,3485900.0000,3432750.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,expanding tree topology,100,1,949736300,9545945.6900,9477574.3200,9597784.4400,301166.9771,222166.8760,388514.4591,"9609419.0000,9650096.0000,9621602.0000,9641751.0000,9638484.0000,9621472.0000,9631822.0000,9657480.0000,9676836.0000,9627504.0000,9618777.0000,9656959.0000,9632994.0000,9652010.0000,9647230.0000,9627563.0000,9650537.0000,9504150.0000,8617200.0000,8627329.0000,8728730.0000,9624268.0000,9646219.0000,9663782.0000,9607305.0000,9636561.0000,9663542.0000,9653913.0000,9689911.0000,8644210.0000,8894395.0000,9642742.0000,9638254.0000,9647832.0000,9617154.0000,9612335.0000,9641841.0000,9627413.0000,9652341.0000,9616532.0000,9632023.0000,9635398.0000,9598469.0000,9596013.0000,9630609.0000,9628385.0000,9652211.0000,9624297.0000,9612556.0000,9607916.0000,9642822.0000,9192610.0000,8599817.0000,8623612.0000,8629845.0000,10642746.0000,8607932.0000,9420782.0000,9640859.0000,9613878.0000,9623916.0000,9615691.0000,9638294.0000,9626822.0000,9607145.0000,9641009.0000,9627412.0000,9631681.0000,9636651.0000,9622023.0000,9614869.0000,9623296.0000,9641229.0000,9619859.0000,9641419.0000,9608939.0000,9613466.0000,9613928.0000,9624698.0000,9604529.0000,9635188.0000,9625870.0000,9614860.0000,9637523.0000,9634396.0000,9619989.0000,9604641.0000,9643353.0000,9634818.0000,9621973.0000,9632263.0000,9629336.0000,9623897.0000,9625208.0000,9635669.0000,9619237.0000,9616362.0000,9624206.0000,9615170.0000,9630459.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,contracting tree topology,100,1,387200600,3840354.1800,3802104.7800,3867831.8700,163984.8925,126607.5699,200788.3684,"3908912.0000,3883604.0000,3911487.0000,3889065.0000,3892129.0000,3886509.0000,3876812.0000,3899504.0000,3849991.0000,3357978.0000,3400970.0000,3453169.0000,3388356.0000,3601640.0000,3918430.0000,3900816.0000,3927548.0000,3920274.0000,3916015.0000,3924672.0000,3839330.0000,3403806.0000,3379970.0000,3863446.0000,3886109.0000,3882181.0000,3953497.0000,3903422.0000,3891258.0000,3875639.0000,3903772.0000,3884385.0000,3876560.0000,3924120.0000,3928779.0000,3912639.0000,3883153.0000,3876119.0000,3916406.0000,3902589.0000,3875869.0000,3907820.0000,3898491.0000,3908010.0000,3935863.0000,3931435.0000,3881210.0000,3878324.0000,3897770.0000,3904234.0000,3889215.0000,3883704.0000,3876861.0000,3880919.0000,3376504.0000,3355634.0000,3399578.0000,3709103.0000,3947425.0000,3903392.0000,3895897.0000,3894786.0000,3888513.0000,3885688.0000,3921446.0000,3960860.0000,3925924.0000,3747175.0000,3445875.0000,3360684.0000,3890027.0000,3885387.0000,3941824.0000,3887091.0000,3900847.0000,3895196.0000,3951562.0000,3892801.0000,3884697.0000,3949188.0000,3949910.0000,3953186.0000,3939720.0000,3948888.0000,3942696.0000,3916987.0000,3945080.0000,3900666.0000,3893032.0000,3941774.0000,3893092.0000,3884987.0000,3886529.0000,3883033.0000,3904664.0000,3876250.0000,3874627.0000,3875439.0000,3879827.0000,3903141.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,wave_sim topology,100,1,1564898400,15459748.6800,15353284.6800,15528366.2800,430047.9156,307319.2402,570322.7857,"15308173.0000,15665260.0000,15601088.0000,15604104.0000,15601849.0000,15602421.0000,15624382.0000,15584938.0000,15583564.0000,15623350.0000,15567975.0000,15624703.0000,15600486.0000,15565601.0000,15632287.0000,15640452.0000,15624442.0000,15694424.0000,15637817.0000,15600747.0000,15627779.0000,15610866.0000,14831149.0000,13747567.0000,14513407.0000,15658957.0000,14265107.0000,15079440.0000,15630483.0000,15592782.0000,15618851.0000,15576813.0000,15594345.0000,15564278.0000,15573967.0000,15538309.0000,15565951.0000,15575690.0000,15583716.0000,15603783.0000,15601799.0000,15598563.0000,15586210.0000,15587071.0000,15573165.0000,15626807.0000,15640613.0000,15670729.0000,14390184.0000,13809725.0000,15009678.0000,15649580.0000,15616697.0000,15642185.0000,15589817.0000,15613291.0000,15619594.0000,15592641.0000,15621516.0000,15620625.0000,15612990.0000,15612940.0000,15619754.0000,15590237.0000,15569508.0000,15639460.0000,15595447.0000,15583765.0000,15607309.0000,15621958.0000,15590258.0000,15614062.0000,15604645.0000,15571772.0000,15571642.0000,15609042.0000,15613932.0000,15610084.0000,15589425.0000,15600898.0000,15592071.0000,15581821.0000,15588815.0000,15587923.0000,15581851.0000,15594405.0000,15582783.0000,14211435.0000,13736738.0000,15090571.0000,15655591.0000,15633289.0000,15617398.0000,15626796.0000,15634261.0000,15633459.0000,15670740.0000,15626656.0000,15636735.0000,14060609.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation,jacobi topology,100,1,525386000,5414204.5300,5374890.5600,5437591.3800,151818.1210,99850.4141,212874.4450,"5454940.0000,5445032.0000,5166383.0000,5449610.0000,5459469.0000,5449530.0000,5456594.0000,5447747.0000,5453837.0000,5454369.0000,5455341.0000,5463857.0000,5449009.0000,5461243.0000,5451444.0000,5452295.0000,5464418.0000,5473466.0000,5472123.0000,5474126.0000,5480169.0000,5438959.0000,5454529.0000,5442227.0000,5452736.0000,5460691.0000,5469438.0000,5464428.0000,5463726.0000,5451263.0000,5446204.0000,5458146.0000,5440252.0000,5460071.0000,5438890.0000,5442396.0000,5445092.0000,5456684.0000,5454709.0000,5473456.0000,5473315.0000,5472825.0000,5480418.0000,5461913.0000,5467754.0000,5455550.0000,5461132.0000,5468045.0000,5458196.0000,5445762.0000,5467945.0000,5447797.0000,5463125.0000,5463366.0000,5464568.0000,5510816.0000,5279839.0000,4772738.0000,4804088.0000,4767728.0000,4812774.0000,4766917.0000,5147297.0000,5480258.0000,5482462.0000,5464429.0000,5449199.0000,5440052.0000,5431887.0000,5455551.0000,5437407.0000,5438470.0000,5465720.0000,5440733.0000,5461302.0000,5442928.0000,5446725.0000,5437918.0000,5462354.0000,5440191.0000,5460350.0000,5440674.0000,5441054.0000,5459789.0000,5441395.0000,5453979.0000,5438468.0000,5442587.0000,5457114.0000,5451043.0000,5447536.0000,5457836.0000,5446615.0000,5447616.0000,5451895.0000,5451213.0000,5440983.0000,5448759.0000,5443228.0000,5457926.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,soup topology,100,1,5617547800,55516257.8300,54795772.9200,56210028.9500,3608988.6786,3154094.7661,4182627.6285,"48795712.0000,59673875.0000,51656280.0000,54670177.0000,53842671.0000,58113820.0000,55768929.0000,55297626.0000,50890499.0000,59600376.0000,58126574.0000,59650131.0000,57244404.0000,62246057.0000,57910916.0000,58340330.0000,56770126.0000,52216521.0000,56270329.0000,56936932.0000,56626894.0000,48037976.0000,51931622.0000,52652316.0000,55146861.0000,54221879.0000,59946691.0000,56788209.0000,45408165.0000,54837745.0000,53293229.0000,53270346.0000,56929488.0000,54287463.0000,56619420.0000,49517348.0000,50611029.0000,48044759.0000,61616133.0000,58168805.0000,52599126.0000,57525276.0000,60492246.0000,57377275.0000,58350098.0000,54437647.0000,55720337.0000,48814717.0000,55325640.0000,60628785.0000,53493549.0000,55103398.0000,54771790.0000,55172078.0000,53518756.0000,54845180.0000,54494786.0000,54763965.0000,56081771.0000,55374623.0000,54144883.0000,54694845.0000,52154172.0000,54298023.0000,57228574.0000,60825266.0000,61180057.0000,55103839.0000,57048913.0000,51780124.0000,52577485.0000,62121321.0000,53966284.0000,56674654.0000,59272145.0000,47720434.0000,47638279.0000,58765504.0000,53709869.0000,57310008.0000,52705978.0000,60741708.0000,56800924.0000,56581348.0000,54538578.0000,56408731.0000,56558304.0000,52579448.0000,58297378.0000,55843099.0000,54116640.0000,53459064.0000,56668943.0000,51124121.0000,54195319.0000,61589825.0000,60160016.0000,62620737.0000,63442974.0000,54108263.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,chain topology,100,1,475452900,4877410.7800,4810045.6300,4990557.2300,436837.4057,297300.0018,680458.0729,"5024305.0000,4854814.0000,7499453.0000,5759087.0000,4659613.0000,4529226.0000,4696844.0000,4959552.0000,4817672.0000,5171533.0000,6293569.0000,6222514.0000,4609037.0000,4686014.0000,4841328.0000,4960753.0000,4470105.0000,4446250.0000,4343596.0000,4305643.0000,4415882.0000,4872638.0000,4525290.0000,4864060.0000,4721351.0000,4706293.0000,5067818.0000,4622172.0000,5189647.0000,5005148.0000,5022712.0000,4719667.0000,4780343.0000,4771226.0000,4693428.0000,4793958.0000,4644656.0000,4635959.0000,5052007.0000,4802143.0000,5359128.0000,4620029.0000,4758962.0000,4584441.0000,4845817.0000,4607255.0000,4607746.0000,4630829.0000,4647401.0000,4609890.0000,4929805.0000,4873800.0000,4807083.0000,4838163.0000,4761767.0000,4852980.0000,4964772.0000,4774561.0000,4772597.0000,4655827.0000,4757719.0000,4739805.0000,4744414.0000,4596564.0000,4655356.0000,4770494.0000,4669512.0000,4941768.0000,4879901.0000,4883027.0000,4966866.0000,4964311.0000,4927151.0000,4859462.0000,4806532.0000,4832692.0000,4866025.0000,4618445.0000,4680123.0000,4922011.0000,5199977.0000,5628689.0000,6634194.0000,4837020.0000,4873558.0000,4795731.0000,4827702.0000,4832301.0000,4677197.0000,4758912.0000,4601424.0000,4770133.0000,4827992.0000,4702245.0000,4679672.0000,4794629.0000,4735798.0000,4728194.0000,5202643.0000,4990730.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,expanding tree topology,100,1,842262300,8534561.1200,8472433.7100,8622017.4000,372105.3147,271257.6308,617232.4887,"8434262.0000,8446637.0000,10892400.0000,8273719.0000,8471353.0000,8354583.0000,8446526.0000,8907780.0000,8991559.0000,9293181.0000,8934992.0000,8704566.0000,8661744.0000,8623612.0000,8603703.0000,8496521.0000,8415006.0000,8435676.0000,8391872.0000,8571554.0000,8412122.0000,8516289.0000,8533712.0000,8245316.0000,8642829.0000,8355643.0000,8416640.0000,8455002.0000,8518974.0000,9027877.0000,8771272.0000,8935423.0000,8288518.0000,8554721.0000,8373909.0000,8655512.0000,8254442.0000,8489337.0000,8336067.0000,8278789.0000,9150460.0000,8260655.0000,8400659.0000,8601381.0000,8342238.0000,8414447.0000,8894014.0000,8313495.0000,8408033.0000,8607431.0000,8724853.0000,8342509.0000,8462496.0000,8830013.0000,9055741.0000,8481542.0000,9178974.0000,9008220.0000,8500669.0000,8551214.0000,8368550.0000,8811137.0000,8855742.0000,8808371.0000,8388077.0000,8607461.0000,8472035.0000,8489027.0000,8456937.0000,8481894.0000,8573687.0000,8448630.0000,8404326.0000,8206011.0000,7794451.0000,8713172.0000,8656494.0000,8466275.0000,8354111.0000,8339103.0000,8654951.0000,8485570.0000,8974626.0000,8889526.0000,8213886.0000,7624249.0000,7663233.0000,8184670.0000,8145977.0000,8504796.0000,8600819.0000,8607882.0000,8443852.0000,8310378.0000,8435236.0000,8283528.0000,8610957.0000,8049194.0000,8045938.0000,8088669.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,contracting tree topology,100,1,590697400,5894647.3900,5789770.0100,6015636.0600,572388.7645,505048.8083,646875.2250,"5653385.0000,5355392.0000,6924304.0000,6078181.0000,5562624.0000,6041351.0000,6901190.0000,6262149.0000,5187374.0000,5553738.0000,7159738.0000,7129051.0000,5550952.0000,6677255.0000,6586874.0000,5497842.0000,5554429.0000,6693616.0000,7313691.0000,5541053.0000,5534421.0000,5297421.0000,5568345.0000,5836032.0000,5511898.0000,5352937.0000,5464799.0000,5378726.0000,5429121.0000,5921593.0000,5907147.0000,5664678.0000,6523474.0000,6598126.0000,5471451.0000,5372153.0000,5680999.0000,5136407.0000,5564306.0000,5781158.0000,5344792.0000,6860442.0000,6269994.0000,5507470.0000,6013167.0000,5276923.0000,5419613.0000,5478064.0000,5750911.0000,5927746.0000,6944692.0000,6610568.0000,5692701.0000,5336526.0000,6343032.0000,6490000.0000,6010593.0000,5332187.0000,6585922.0000,6916969.0000,5582723.0000,5503022.0000,5896176.0000,6136681.0000,5600095.0000,5308513.0000,5359649.0000,5366623.0000,5584696.0000,5484125.0000,5387973.0000,5392842.0000,5910774.0000,5361212.0000,5480529.0000,5421397.0000,5863914.0000,5375971.0000,5925291.0000,6801700.0000,6946736.0000,5630753.0000,5425143.0000,6827490.0000,6521270.0000,5645942.0000,5601018.0000,6487155.0000,6839222.0000,5680077.0000,5396851.0000,5481801.0000,5486661.0000,7371721.0000,6576514.0000,5517278.0000,5663015.0000,5844788.0000,5580327.0000,5865378.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,wave_sim topology,100,1,2607735200,26593067.6000,26308381.5400,26899842.8700,1508383.1700,1269771.8016,1874115.4784,"26206164.0000,28331270.0000,30116311.0000,25366624.0000,23229617.0000,23686282.0000,24035673.0000,24635269.0000,24549066.0000,23851935.0000,23740745.0000,23509537.0000,24178484.0000,24539828.0000,23498006.0000,25073008.0000,24438667.0000,24796855.0000,25098967.0000,28459083.0000,27388633.0000,26778249.0000,26420520.0000,25734061.0000,25761293.0000,27516466.0000,26962398.0000,26303107.0000,26010946.0000,26429868.0000,26617725.0000,24561169.0000,27349910.0000,26806242.0000,26611783.0000,26211274.0000,26505070.0000,28053214.0000,25823660.0000,26550107.0000,28104841.0000,29348247.0000,28223064.0000,27036848.0000,26390613.0000,28231672.0000,27115847.0000,31744464.0000,26551700.0000,26984218.0000,28429777.0000,28190694.0000,26903365.0000,26229649.0000,26504189.0000,26763550.0000,26016114.0000,27912387.0000,27517308.0000,31861416.0000,27304596.0000,27684294.0000,25491973.0000,27044192.0000,27712438.0000,27914020.0000,26511403.0000,26312466.0000,27255672.0000,27481711.0000,27131357.0000,26936889.0000,26869471.0000,26149397.0000,26024179.0000,26596455.0000,27703370.0000,26401896.0000,26564543.0000,26628465.0000,26355827.0000,27187684.0000,26769912.0000,25789977.0000,26244788.0000,26173372.0000,25187786.0000,26008901.0000,29245151.0000,26125602.0000,26626010.0000,27325895.0000,27916975.0000,27295277.0000,26616091.0000,27411167.0000,26223739.0000,26288551.0000,25950209.0000,27048010.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread,jacobi topology,100,1,1004384100,9783209.2300,9588387.4300,9974580.6500,984925.4765,887075.5846,1104860.6557,"10320375.0000,11600770.0000,11972515.0000,10169240.0000,10025657.0000,10128954.0000,9809106.0000,11196776.0000,9798047.0000,10110969.0000,8772434.0000,8875348.0000,7817616.0000,7647273.0000,8682173.0000,8730455.0000,9773700.0000,10231738.0000,10723669.0000,9639095.0000,8996377.0000,9738614.0000,10558357.0000,10145684.0000,9710801.0000,9113019.0000,11312996.0000,8335826.0000,8179601.0000,8445554.0000,9007860.0000,9032406.0000,9651730.0000,10110287.0000,10459820.0000,8622870.0000,9041184.0000,9354687.0000,10282784.0000,9149358.0000,10237499.0000,9839054.0000,10721725.0000,8869659.0000,8906829.0000,10227980.0000,10623350.0000,11464623.0000,9885692.0000,10359260.0000,10817808.0000,9181699.0000,9069076.0000,9074776.0000,9616192.0000,10670107.0000,10276914.0000,10318652.0000,11070887.0000,8831265.0000,8569840.0000,8375922.0000,10058089.0000,9830127.0000,9136173.0000,10528940.0000,9005786.0000,9134650.0000,11153093.0000,8950511.0000,9930136.0000,10729641.0000,11219198.0000,9013400.0000,10532767.0000,7788460.0000,7848493.0000,8156928.0000,8449121.0000,9156862.0000,9987184.0000,10707149.0000,11312535.0000,9305344.0000,10848666.0000,9993977.0000,10065263.0000,11259855.0000,8996258.0000,10560230.0000,10644510.0000,11274031.0000,8794666.0000,10918499.0000,8835373.0000,9537072.0000,10222871.0000,11084032.0000,11579611.0000,9486888.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,soup topology,100,1,6537296200,67191056.9300,66788248.4500,67513074.0800,1825907.6172,1530715.3723,2116419.4496,"68214292.0000,68031565.0000,66633387.0000,68135152.0000,67863216.0000,68078303.0000,63598248.0000,67951814.0000,68270317.0000,67878124.0000,68164849.0000,68167292.0000,68595252.0000,68214511.0000,68227216.0000,68357363.0000,67880489.0000,68129391.0000,68154709.0000,67795558.0000,63646730.0000,62713462.0000,68272702.0000,68191770.0000,67618773.0000,64955449.0000,68085618.0000,66067264.0000,67307483.0000,68324901.0000,68120214.0000,68141884.0000,63783409.0000,68150131.0000,64745170.0000,67925213.0000,62644542.0000,63898507.0000,68186449.0000,67916437.0000,68590804.0000,68268794.0000,67986520.0000,68129742.0000,63027537.0000,67743691.0000,64476031.0000,65053906.0000,68248106.0000,68330932.0000,68279866.0000,62661635.0000,67915996.0000,68161872.0000,68266731.0000,67917148.0000,68319220.0000,63048056.0000,68171790.0000,68068254.0000,68014533.0000,68324169.0000,62384139.0000,68540149.0000,68228198.0000,68508288.0000,64757835.0000,68040392.0000,63654966.0000,68181189.0000,62321560.0000,67926266.0000,68050481.0000,68197159.0000,68093152.0000,68608598.0000,68597989.0000,68658423.0000,68058877.0000,68199744.0000,68670005.0000,68494001.0000,68002701.0000,68295155.0000,68394433.0000,66573624.0000,68251632.0000,68311716.0000,66958413.0000,66865797.0000,68331834.0000,68448866.0000,64393555.0000,68221114.0000,64267937.0000,66634509.0000,64511479.0000,68097099.0000,68046233.0000,68285696.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,chain topology,100,1,363098000,3699713.0400,3667306.5800,3722942.2000,138353.1220,105786.5597,170325.4108,"3739501.0000,3750161.0000,3750481.0000,3735774.0000,3747556.0000,3734793.0000,3739070.0000,3753878.0000,3727538.0000,3740643.0000,3732187.0000,3767513.0000,3733990.0000,3734832.0000,3751984.0000,3744701.0000,3739581.0000,3726887.0000,3740543.0000,3743369.0000,3775229.0000,3737177.0000,3789465.0000,3519124.0000,3310158.0000,3301562.0000,3391652.0000,3733279.0000,3786300.0000,3749941.0000,3806298.0000,3747597.0000,3742306.0000,3757815.0000,3739170.0000,3753558.0000,3745743.0000,3757755.0000,3748768.0000,3760020.0000,3772143.0000,3746965.0000,3740002.0000,3734101.0000,3746554.0000,3741234.0000,3730694.0000,3758818.0000,3748909.0000,3739972.0000,3782523.0000,3744490.0000,3774416.0000,3756493.0000,3736986.0000,3751353.0000,3737016.0000,3738199.0000,3296262.0000,3306601.0000,3294358.0000,3333562.0000,3302814.0000,3320347.0000,3344563.0000,3296922.0000,3584897.0000,3778004.0000,3735795.0000,3773656.0000,3756032.0000,3769829.0000,3778284.0000,3756002.0000,3739370.0000,3752435.0000,3814823.0000,3798002.0000,3743448.0000,3763055.0000,3737006.0000,3740503.0000,3749730.0000,3745332.0000,3757354.0000,3741705.0000,3746003.0000,3763376.0000,3754079.0000,3754610.0000,3739561.0000,3744039.0000,3746033.0000,3764839.0000,3744310.0000,3740253.0000,3767203.0000,3743849.0000,3746304.0000,3737387.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,expanding tree topology,100,1,976517400,9811516.0300,9740158.9300,9860849.1700,298400.0482,224679.8557,373938.4099,"9938513.0000,9907624.0000,9970002.0000,9941177.0000,9912484.0000,9903716.0000,9897926.0000,9904137.0000,9935848.0000,9904959.0000,9934034.0000,9919597.0000,9913304.0000,9896063.0000,9919336.0000,9920779.0000,9908104.0000,9917894.0000,9899969.0000,8891820.0000,8915925.0000,8909123.0000,9298711.0000,9906331.0000,9904879.0000,9894880.0000,9940477.0000,9952789.0000,9927552.0000,9931088.0000,9939384.0000,9935316.0000,9942790.0000,9920107.0000,9923694.0000,9918134.0000,9919135.0000,9919056.0000,9949062.0000,9933733.0000,9830698.0000,8956964.0000,8923980.0000,8909403.0000,9641089.0000,9910861.0000,9913535.0000,9969351.0000,9733354.0000,9270087.0000,9940416.0000,9926509.0000,9919247.0000,9923483.0000,9915930.0000,9923574.0000,9924566.0000,9934004.0000,9938122.0000,9912092.0000,9967447.0000,9919707.0000,9918855.0000,9927611.0000,9927010.0000,9917764.0000,9918354.0000,9917753.0000,9921450.0000,9926681.0000,9941888.0000,9950114.0000,9921510.0000,9916069.0000,9921891.0000,9920458.0000,9934836.0000,9920748.0000,9943742.0000,9925898.0000,9925839.0000,9902454.0000,9922882.0000,9915148.0000,9926890.0000,9928584.0000,9932841.0000,9933804.0000,9932771.0000,9948922.0000,9747129.0000,8921567.0000,8900055.0000,8932477.0000,9674803.0000,9921500.0000,9934555.0000,9926540.0000,9909658.0000,9916681.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,contracting tree topology,100,1,407583700,4168930.6200,4150370.9200,4176238.4900,52894.5279,8642.1170,96094.9514,"4170368.0000,4174805.0000,4205223.0000,4169446.0000,4176599.0000,4165167.0000,4178322.0000,4175647.0000,4185816.0000,4173853.0000,4173562.0000,4173763.0000,4177781.0000,4177591.0000,4185315.0000,4166208.0000,4169726.0000,4185356.0000,4184615.0000,4174183.0000,4175206.0000,4183502.0000,4176348.0000,4170858.0000,4190975.0000,4175598.0000,3823280.0000,3784546.0000,4182149.0000,4180437.0000,4179284.0000,4173574.0000,4180927.0000,4161219.0000,4203279.0000,4170418.0000,4158324.0000,4174054.0000,4161961.0000,4169645.0000,4179053.0000,4163182.0000,4183512.0000,4172171.0000,4169425.0000,4188631.0000,4175256.0000,4163885.0000,4179605.0000,4168925.0000,4185916.0000,4163003.0000,4175457.0000,4177881.0000,4173363.0000,4178552.0000,4168894.0000,4179926.0000,4189072.0000,4175837.0000,4191076.0000,4174886.0000,4172391.0000,4181367.0000,4175577.0000,4177892.0000,4180366.0000,4181668.0000,4198331.0000,4181468.0000,4173113.0000,4169686.0000,4185255.0000,4185506.0000,4175657.0000,4171209.0000,4168343.0000,4174786.0000,4175397.0000,4181028.0000,4173723.0000,4168704.0000,4175667.0000,4169726.0000,4186156.0000,4174906.0000,4173223.0000,4171029.0000,4172090.0000,4190094.0000,4176319.0000,4190155.0000,4165518.0000,4178662.0000,4171239.0000,4167502.0000,4184644.0000,4164366.0000,4170066.0000,4163795.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,wave_sim topology,100,1,1767851200,17665254.9600,17576740.8200,17710334.4100,310611.9032,176222.6503,491278.6448,"17716805.0000,17725963.0000,17790825.0000,17770888.0000,17699523.0000,17699612.0000,17751540.0000,17692930.0000,17814861.0000,17766008.0000,17755629.0000,17764205.0000,17775837.0000,17744107.0000,17726885.0000,17743986.0000,17709641.0000,17737054.0000,17705594.0000,17765327.0000,17782239.0000,17729739.0000,17806455.0000,16972535.0000,15885566.0000,16712163.0000,17803359.0000,17780857.0000,17761800.0000,17817236.0000,17712376.0000,17731153.0000,16546629.0000,15861380.0000,17534299.0000,17733817.0000,17700494.0000,17764405.0000,17732715.0000,17735871.0000,17746041.0000,17755518.0000,17709341.0000,17792819.0000,17703149.0000,17679785.0000,17723487.0000,17688381.0000,17720803.0000,17756841.0000,17700795.0000,17762382.0000,17709631.0000,17711526.0000,17724369.0000,17696367.0000,17783812.0000,17742624.0000,17702568.0000,17746551.0000,17745780.0000,17674406.0000,17685495.0000,17770939.0000,17758634.0000,17715373.0000,17746922.0000,17780546.0000,17702638.0000,17701666.0000,17691987.0000,17720652.0000,17785525.0000,17749036.0000,17748195.0000,17717637.0000,17772030.0000,17735470.0000,17751231.0000,17795354.0000,17655589.0000,17734579.0000,17689975.0000,17724890.0000,17724330.0000,17706726.0000,17734338.0000,17711885.0000,17680316.0000,17792829.0000,17708950.0000,17649046.0000,17685986.0000,17690957.0000,17719430.0000,17691277.0000,17776799.0000,17714751.0000,17750409.0000,17713820.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task,jacobi topology,100,1,598479200,5933871.7800,5882107.1600,5970790.4200,221153.1188,167843.4908,275055.1623,"6007868.0000,6041701.0000,6088190.0000,6094461.0000,6009891.0000,6008279.0000,5979664.0000,6010973.0000,5999812.0000,6012957.0000,5998460.0000,5980185.0000,5999291.0000,6001015.0000,5820383.0000,5310115.0000,5313002.0000,5302271.0000,5300517.0000,5315445.0000,5605926.0000,6018628.0000,5991526.0000,6020812.0000,5997999.0000,6014870.0000,6002498.0000,6001375.0000,6030801.0000,6000253.0000,5980836.0000,5994762.0000,5990836.0000,6000293.0000,6039787.0000,6034078.0000,6038295.0000,5994732.0000,6046161.0000,6052582.0000,6003920.0000,5983772.0000,6053074.0000,6021994.0000,6003279.0000,5997969.0000,5993179.0000,6000664.0000,5994322.0000,5991646.0000,6032935.0000,6020972.0000,5988050.0000,6031402.0000,5984083.0000,6118186.0000,6047222.0000,5996987.0000,6070976.0000,6159946.0000,5982089.0000,6010521.0000,6078541.0000,6034849.0000,6008559.0000,6002167.0000,5983692.0000,6035690.0000,6022315.0000,6004041.0000,5999391.0000,5994532.0000,6004892.0000,5990554.0000,5995494.0000,6040219.0000,5985395.0000,6026633.0000,5922066.0000,5291390.0000,5276071.0000,5290118.0000,5295358.0000,5283184.0000,5700445.0000,5993090.0000,6051410.0000,6012877.0000,5982810.0000,6040578.0000,6014390.0000,5998379.0000,6032825.0000,5989643.0000,6006726.0000,6037253.0000,5979754.0000,6073842.0000,5974765.0000,5994522.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,soup topology,100,1,5743274700,55775812.4300,55017989.8200,56555344.3400,3926479.9082,3476469.5584,4460766.2512,"51252254.0000,48802634.0000,53061521.0000,61186029.0000,54803190.0000,60862928.0000,55066829.0000,54382934.0000,57060826.0000,61257255.0000,63830398.0000,56478773.0000,60959962.0000,52327641.0000,56398802.0000,56459847.0000,54953765.0000,57591751.0000,53115664.0000,53948310.0000,54402982.0000,55146040.0000,57072849.0000,57045517.0000,53501724.0000,50196314.0000,51699531.0000,47593093.0000,53265658.0000,50814314.0000,56292621.0000,54131357.0000,56953583.0000,61674205.0000,59076083.0000,57004198.0000,61697008.0000,56234601.0000,64467564.0000,53731830.0000,54809832.0000,60730968.0000,55392486.0000,59014677.0000,56290286.0000,55406081.0000,58801032.0000,52489026.0000,47237810.0000,61690645.0000,61989742.0000,52975558.0000,53690703.0000,55306523.0000,56202200.0000,55932318.0000,60660193.0000,54210728.0000,59060463.0000,49983581.0000,54912076.0000,58681476.0000,58450439.0000,56148308.0000,54566091.0000,51914678.0000,64250574.0000,53459675.0000,55560074.0000,53775644.0000,57191373.0000,56058217.0000,54043551.0000,59503843.0000,53111816.0000,57840372.0000,61827305.0000,50072219.0000,63183854.0000,63641690.0000,54437677.0000,53579171.0000,58992114.0000,55335789.0000,55682154.0000,57470312.0000,58403339.0000,56445960.0000,59217151.0000,54705244.0000,50705198.0000,52088527.0000,60580693.0000,51583942.0000,47411380.0000,51135594.0000,49666571.0000,52052450.0000,53297779.0000,48919686.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,chain topology,100,1,591247900,6262078.2200,6104367.2400,6437781.6100,849344.9744,749301.1001,977757.6904,"5392512.0000,7055702.0000,8287025.0000,5726834.0000,5621256.0000,5768464.0000,5713079.0000,6551798.0000,6296845.0000,5853554.0000,7240312.0000,5990945.0000,5847875.0000,5741333.0000,6104992.0000,6189321.0000,5129945.0000,7123451.0000,6101214.0000,5641714.0000,4962348.0000,5284066.0000,6605290.0000,8468277.0000,8556034.0000,8144024.0000,5380478.0000,6198910.0000,6858538.0000,5772812.0000,7565388.0000,6533282.0000,6102337.0000,5708211.0000,7084156.0000,6349154.0000,5820793.0000,5583373.0000,6473430.0000,6584410.0000,5424713.0000,5685487.0000,6769610.0000,6302706.0000,5730833.0000,7214794.0000,6264613.0000,5489866.0000,5330625.0000,6718062.0000,6701832.0000,6186596.0000,7584524.0000,6728062.0000,7032347.0000,6284201.0000,5305477.0000,5663926.0000,7720511.0000,6354925.0000,5619081.0000,5677902.0000,6649092.0000,6424336.0000,5840831.0000,7696125.0000,6202967.0000,5768935.0000,5614833.0000,6882443.0000,6729194.0000,5379467.0000,5541563.0000,6833822.0000,6335498.0000,5421636.0000,5147267.0000,5395408.0000,5313933.0000,5147108.0000,5256014.0000,5146676.0000,5325775.0000,5316989.0000,5155784.0000,5682751.0000,5747876.0000,6938310.0000,6507904.0000,5461933.0000,7201608.0000,7228549.0000,6150117.0000,7198633.0000,5343278.0000,6905027.0000,7084215.0000,6887294.0000,7994209.0000,8146247.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,expanding tree topology,100,1,949080100,9420657.0500,9326451.0200,9610937.8000,657961.1903,309928.3007,1116412.0676,"9735207.0000,9484773.0000,13198948.0000,9702736.0000,8721177.0000,8787572.0000,8812038.0000,8760712.0000,9131294.0000,9487108.0000,9393409.0000,9549405.0000,9378552.0000,9366980.0000,10109657.0000,9021716.0000,9243005.0000,9183722.0000,9146332.0000,9242013.0000,9362812.0000,9236943.0000,9501164.0000,9748091.0000,9381638.0000,9192098.0000,9674774.0000,9299952.0000,9650207.0000,9435359.0000,9083353.0000,9498188.0000,9287119.0000,9397878.0000,9704460.0000,9284333.0000,8702832.0000,8783294.0000,9015875.0000,9728124.0000,9751808.0000,9274084.0000,9821971.0000,9156220.0000,9412726.0000,9546571.0000,9405052.0000,9762008.0000,9069797.0000,9084405.0000,9104503.0000,9051472.0000,9170137.0000,9350168.0000,8631566.0000,13790518.0000,8836525.0000,8791871.0000,8964588.0000,9268854.0000,9497487.0000,9787256.0000,9225321.0000,9740697.0000,9523387.0000,9090746.0000,9156341.0000,9623907.0000,9516693.0000,9249257.0000,9030554.0000,9101566.0000,9695793.0000,9731310.0000,9399753.0000,9385665.0000,9486958.0000,9227155.0000,9512867.0000,9030443.0000,9467912.0000,9250609.0000,9747200.0000,9796584.0000,9229730.0000,9022978.0000,9225021.0000,9410734.0000,9914136.0000,9774001.0000,9401315.0000,9173675.0000,9136012.0000,9212417.0000,9164606.0000,9074666.0000,9311885.0000,9512326.0000,9865844.0000,9691204.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,contracting tree topology,100,1,638401200,6411874.3400,6272426.0400,6567840.1300,754478.0825,673158.6543,917501.5142,"6299990.0000,5991587.0000,9159748.0000,5865979.0000,6923321.0000,6991440.0000,6007185.0000,5907527.0000,7454768.0000,6731057.0000,5937214.0000,6045018.0000,7827845.0000,6405611.0000,6967355.0000,7080769.0000,5981879.0000,6094982.0000,7088244.0000,7105486.0000,5843386.0000,5875608.0000,7307859.0000,6287838.0000,5864616.0000,5846752.0000,7563835.0000,6894427.0000,6043464.0000,5323462.0000,5954737.0000,6207075.0000,6068883.0000,6146710.0000,7816783.0000,6719686.0000,5848536.0000,5727717.0000,7564236.0000,6555694.0000,7053819.0000,7107100.0000,6125340.0000,6329446.0000,7637124.0000,6551056.0000,6036993.0000,5678313.0000,5315926.0000,5294236.0000,5388685.0000,5511447.0000,5320015.0000,5419403.0000,5776419.0000,6046851.0000,5841563.0000,7581959.0000,6177199.0000,6032744.0000,5943986.0000,5521195.0000,7351182.0000,7167654.0000,5686429.0000,5975095.0000,7146614.0000,6769891.0000,6607533.0000,7738556.0000,5936843.0000,7334981.0000,6285162.0000,6106525.0000,6130729.0000,7722916.0000,6731698.0000,6405911.0000,7381290.0000,6070766.0000,7465128.0000,6228646.0000,5887990.0000,5459409.0000,5303754.0000,5529430.0000,6074343.0000,7359668.0000,6342521.0000,5829660.0000,5916795.0000,7286820.0000,6907511.0000,7115154.0000,7431264.0000,5942564.0000,5382663.0000,5928016.0000,6707793.0000,5519402.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,wave_sim topology,100,1,2983032600,29246847.4100,28772927.7900,29675007.0300,2300323.8459,1965653.8151,2807285.5452,"25959307.0000,29011849.0000,29246103.0000,32842043.0000,31447352.0000,31120433.0000,29058488.0000,29361602.0000,33792253.0000,29148568.0000,31874932.0000,29342374.0000,33113708.0000,29371099.0000,30495188.0000,23675652.0000,28974177.0000,26658291.0000,23531879.0000,26757660.0000,24594581.0000,25513232.0000,26786063.0000,26996111.0000,25751543.0000,25186704.0000,26744605.0000,25927656.0000,28145718.0000,28124999.0000,30195370.0000,31083764.0000,31815709.0000,30200730.0000,29901895.0000,32290508.0000,30505278.0000,32177715.0000,29879182.0000,30529904.0000,27721134.0000,21065818.0000,27776219.0000,28044637.0000,31762559.0000,29118091.0000,29571810.0000,30572064.0000,29505955.0000,27770788.0000,28828171.0000,29152134.0000,27475579.0000,32087323.0000,29109604.0000,29575648.0000,30714573.0000,30840322.0000,31438937.0000,29725079.0000,27534721.0000,29917174.0000,30365773.0000,30815463.0000,31695501.0000,30163010.0000,30313023.0000,31478190.0000,30370142.0000,30352148.0000,31479832.0000,29384054.0000,30085763.0000,29476008.0000,29477041.0000,27408814.0000,31797836.0000,30145487.0000,29961396.0000,30318874.0000,30928059.0000,30085882.0000,29493221.0000,29045162.0000,29599111.0000,27947673.0000,29738205.0000,28644352.0000,29866738.0000,29871717.0000,31782277.0000,30548960.0000,29985984.0000,35557146.0000,25405468.0000,27389807.0000,27516596.0000,27847285.0000,24985822.0000,26914356.0000" +building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task,jacobi topology,100,1,1071129700,10903128.9300,10655959.8300,11158339.6900,1281574.0659,1158082.7889,1433154.0898,"13455143.0000,9749284.0000,12462633.0000,12431154.0000,12566080.0000,12273785.0000,11915568.0000,8933619.0000,8643981.0000,8812469.0000,9987906.0000,12810172.0000,11609157.0000,11044817.0000,12944066.0000,10480379.0000,12511175.0000,10250774.0000,11501542.0000,11224358.0000,10870027.0000,8829062.0000,8214627.0000,10381391.0000,12712026.0000,10581811.0000,12174508.0000,11933591.0000,10883572.0000,12618479.0000,12432055.0000,12394184.0000,12049872.0000,8831996.0000,10721325.0000,10229474.0000,8879145.0000,10249903.0000,10354350.0000,9597426.0000,10094828.0000,9577820.0000,9623164.0000,9554475.0000,9925768.0000,9847400.0000,9451079.0000,10300948.0000,11066139.0000,10019235.0000,10372214.0000,10288334.0000,9789932.0000,9190115.0000,9055279.0000,10023523.0000,9779351.0000,13695799.0000,10689094.0000,11714827.0000,11554494.0000,11552139.0000,8774869.0000,11589179.0000,9609960.0000,10901497.0000,11133435.0000,10334262.0000,13700097.0000,12232106.0000,10899954.0000,12588361.0000,9919206.0000,9784992.0000,10987610.0000,11193070.0000,11983876.0000,10758416.0000,12543036.0000,10077986.0000,13049094.0000,11563731.0000,9999678.0000,11773408.0000,12489585.0000,10379888.0000,11859131.0000,10001451.0000,9157323.0000,11494209.0000,10119575.0000,9972087.0000,11693326.0000,11718634.0000,12191070.0000,11013758.0000,13054064.0000,9973970.0000,10794684.0000,11289472.0000" diff --git a/ci/perf/gpuc2_bench.md b/ci/perf/gpuc2_bench.md index 259428cb4..8c307fe0c 100644 --- a/ci/perf/gpuc2_bench.md +++ b/ci/perf/gpuc2_bench.md @@ -2,96 +2,96 @@ | Metadata | | | :------- | :------------------- | -| Created | 2022-05-19T09:23:57Z | +| Created | 2022-06-17T10:51:25Z | | Test case | Benchmark name | Min | Mean | Std dev | | :------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------- | -------------: | -------------: | -----------: | -| benchmark intrusive graph dependency handling with N nodes - 1 | creating nodes | 4.47 | 4.89 | 0.13 | -| benchmark intrusive graph dependency handling with N nodes - 1 | creating and adding dependencies | 23.18 | 23.29 | 0.54 | -| benchmark intrusive graph dependency handling with N nodes - 1 | adding and removing dependencies | 16.05 | 16.11 | 0.42 | -| benchmark intrusive graph dependency handling with N nodes - 1 | checking for dependencies | 1.22 | 1.23 | 0.03 | -| benchmark intrusive graph dependency handling with N nodes - 10 | creating nodes | 39.11 | 39.77 | 0.52 | -| benchmark intrusive graph dependency handling with N nodes - 10 | creating and adding dependencies | 265.42 | 266.85 | 5.17 | -| benchmark intrusive graph dependency handling with N nodes - 10 | adding and removing dependencies | 205.54 | 207.44 | 5.32 | -| benchmark intrusive graph dependency handling with N nodes - 10 | checking for dependencies | 21.25 | 21.79 | 0.57 | -| benchmark intrusive graph dependency handling with N nodes - 100 | creating nodes | 412.35 | 413.53 | 1.57 | -| benchmark intrusive graph dependency handling with N nodes - 100 | creating and adding dependencies | 4'279.50 | 4'335.42 | 72.15 | -| benchmark intrusive graph dependency handling with N nodes - 100 | adding and removing dependencies | 3'726.67 | 3'751.30 | 121.63 | -| benchmark intrusive graph dependency handling with N nodes - 100 | checking for dependencies | 1'831.21 | 1'844.13 | 45.09 | -| benchmark task handling > without access thread | generating and deleting tasks | 3'903'415.00 | 4'920'304.44 | 276'404.03 | -| benchmark task handling > with access thread | generating and deleting tasks with access thread | 8'337'859.00 | 9'986'252.76 | 494'531.81 | -| generating large task graphs | soup topology | 13'725'216.00 | 15'701'911.78 | 564'494.22 | -| generating large task graphs | chain topology | 67'486.00 | 68'177.35 | 1'652.42 | -| generating large task graphs | expanding tree topology | 125'746.00 | 127'204.20 | 2'592.77 | -| generating large task graphs | contracting tree topology | 180'219.00 | 181'789.45 | 1'412.56 | -| generating large task graphs | wave\_sim topology | 648'627.00 | 653'178.81 | 4'574.43 | -| generating large task graphs | jacobi topology | 219'915.00 | 221'065.23 | 1'539.45 | -| generating large command graphs for N nodes - 1 | soup topology | 24'893'140.00 | 27'651'883.38 | 799'614.87 | -| generating large command graphs for N nodes - 1 | chain topology | 276'121.00 | 278'151.78 | 2'135.76 | -| generating large command graphs for N nodes - 1 | expanding tree topology | 443'238.00 | 446'435.63 | 3'834.36 | -| generating large command graphs for N nodes - 1 | contracting tree topology | 489'055.00 | 493'044.95 | 3'039.29 | -| generating large command graphs for N nodes - 1 | wave\_sim topology | 2'003'555.00 | 2'228'973.08 | 23'571.60 | -| generating large command graphs for N nodes - 1 | jacobi topology | 829'420.00 | 835'088.75 | 3'966.55 | -| generating large command graphs for N nodes - 4 | soup topology | 60'720'241.00 | 65'577'388.09 | 1'119'938.08 | -| generating large command graphs for N nodes - 4 | chain topology | 3'490'573.00 | 3'504'745.22 | 10'336.79 | -| generating large command graphs for N nodes - 4 | expanding tree topology | 8'746'432.00 | 9'744'932.13 | 185'372.44 | -| generating large command graphs for N nodes - 4 | contracting tree topology | 3'889'108.00 | 3'908'198.79 | 8'144.54 | -| generating large command graphs for N nodes - 4 | wave\_sim topology | 14'065'261.00 | 15'832'766.48 | 240'437.15 | -| generating large command graphs for N nodes - 4 | jacobi topology | 4'872'220.00 | 5'447'579.97 | 205'399.52 | -| generating large command graphs for N nodes - 16 | soup topology | 219'083'488.00 | 223'837'319.46 | 1'331'417.84 | -| generating large command graphs for N nodes - 16 | chain topology | 426'542'249.00 | 438'905'484.09 | 3'118'030.65 | -| generating large command graphs for N nodes - 16 | expanding tree topology | 704'484'478.00 | 717'760'331.14 | 4'365'997.08 | -| generating large command graphs for N nodes - 16 | contracting tree topology | 132'154'550.00 | 139'656'299.58 | 1'470'612.25 | -| generating large command graphs for N nodes - 16 | wave\_sim topology | 129'569'000.00 | 136'091'353.72 | 1'382'756.02 | -| generating large command graphs for N nodes - 16 | jacobi topology | 125'627'319.00 | 130'839'766.57 | 1'608'945.30 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | soup topology | 25'233'421.00 | 27'995'963.41 | 398'272.93 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | chain topology | 277'013.00 | 279'709.40 | 2'836.25 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | expanding tree topology | 444'871.00 | 447'262.84 | 2'243.49 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | contracting tree topology | 492'601.00 | 497'440.20 | 16'166.74 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | wave\_sim topology | 2'211'077.00 | 2'226'367.18 | 17'202.19 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | jacobi topology | 830'191.00 | 835'391.60 | 3'702.16 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | soup topology | 16'303'460.00 | 24'165'362.83 | 2'485'140.77 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | chain topology | 643'949.00 | 805'665.57 | 46'484.16 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | expanding tree topology | 664'037.00 | 727'347.33 | 76'785.64 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | contracting tree topology | 526'856.00 | 914'252.27 | 285'106.30 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | wave\_sim topology | 3'493'687.00 | 4'373'288.17 | 726'948.74 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | jacobi topology | 1'408'878.00 | 1'560'733.73 | 137'739.88 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 26'539'686.00 | 30'161'093.23 | 615'581.85 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 573'043.00 | 576'424.40 | 2'552.37 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 751'431.00 | 754'749.34 | 3'734.55 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 745'771.00 | 799'208.18 | 7'599.13 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 4'026'948.00 | 4'249'079.41 | 84'746.94 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 1'342'341.00 | 1'346'997.45 | 3'463.84 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | soup topology | 17'923'669.00 | 24'211'126.23 | 2'770'300.94 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | chain topology | 1'042'183.00 | 1'294'620.88 | 135'008.93 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 1'064'886.00 | 1'706'681.06 | 232'875.02 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 1'513'726.00 | 1'716'872.92 | 99'743.92 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 5'790'721.00 | 9'468'295.91 | 1'436'924.17 | -| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 1'456'157.00 | 2'400'342.94 | 514'241.66 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | soup topology | 60'945'637.00 | 66'020'014.67 | 865'893.15 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | chain topology | 3'095'243.00 | 3'499'779.15 | 96'334.54 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | expanding tree topology | 9'783'166.00 | 9'849'989.23 | 22'113.04 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | contracting tree topology | 3'910'467.00 | 3'939'575.42 | 8'010.96 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | wave\_sim topology | 14'116'586.00 | 15'832'562.14 | 406'166.09 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | jacobi topology | 5'534'996.00 | 5'552'896.93 | 8'340.21 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | soup topology | 44'269'820.00 | 54'940'307.75 | 3'719'537.37 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | chain topology | 4'628'809.00 | 4'925'400.08 | 359'385.89 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | expanding tree topology | 7'838'721.00 | 8'673'340.21 | 536'414.09 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | contracting tree topology | 4'076'352.00 | 4'646'449.50 | 604'379.57 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | wave\_sim topology | 16'871'736.00 | 19'443'608.66 | 1'961'803.02 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | jacobi topology | 5'962'306.00 | 6'719'872.42 | 870'753.09 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 62'743'653.00 | 68'424'802.08 | 806'483.17 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 3'380'663.00 | 3'787'358.03 | 126'316.13 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 9'084'260.00 | 10'093'770.90 | 182'216.07 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 4'215'445.00 | 4'245'059.63 | 7'687.22 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 16'300'755.00 | 17'979'225.99 | 225'042.21 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 5'437'500.00 | 6'028'284.50 | 143'159.20 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | soup topology | 47'902'362.00 | 55'457'495.19 | 3'652'289.05 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | chain topology | 5'056'529.00 | 6'336'548.05 | 698'011.40 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 8'425'642.00 | 9'545'757.70 | 828'545.18 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 4'780'907.00 | 6'523'877.39 | 752'577.11 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 25'894'783.00 | 29'784'677.72 | 2'178'207.20 | -| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 8'916'733.00 | 11'175'543.71 | 1'091'582.43 | +| benchmark intrusive graph dependency handling with N nodes - 1 | creating nodes | 8.69 | 8.70 | 0.05 | +| benchmark intrusive graph dependency handling with N nodes - 1 | creating and adding dependencies | 27.53 | 27.72 | 0.45 | +| benchmark intrusive graph dependency handling with N nodes - 1 | adding and removing dependencies | 15.95 | 16.11 | 0.39 | +| benchmark intrusive graph dependency handling with N nodes - 1 | checking for dependencies | 1.22 | 1.23 | 0.02 | +| benchmark intrusive graph dependency handling with N nodes - 10 | creating nodes | 39.12 | 39.40 | 0.14 | +| benchmark intrusive graph dependency handling with N nodes - 10 | creating and adding dependencies | 269.07 | 270.89 | 5.85 | +| benchmark intrusive graph dependency handling with N nodes - 10 | adding and removing dependencies | 207.79 | 208.81 | 5.35 | +| benchmark intrusive graph dependency handling with N nodes - 10 | checking for dependencies | 25.61 | 26.40 | 0.49 | +| benchmark intrusive graph dependency handling with N nodes - 100 | creating nodes | 428.24 | 431.19 | 6.75 | +| benchmark intrusive graph dependency handling with N nodes - 100 | creating and adding dependencies | 4'229.33 | 4'288.86 | 23.86 | +| benchmark intrusive graph dependency handling with N nodes - 100 | adding and removing dependencies | 4'498.17 | 4'536.98 | 86.49 | +| benchmark intrusive graph dependency handling with N nodes - 100 | checking for dependencies | 1'644.33 | 1'688.70 | 53.09 | +| benchmark task handling > without access thread | generating and deleting tasks | 3'893'723.00 | 4'809'722.33 | 420'215.92 | +| benchmark task handling > with access thread | generating and deleting tasks with access thread | 9'109'913.00 | 10'977'564.57 | 595'870.44 | +| generating large task graphs | soup topology | 13'593'746.00 | 15'499'589.08 | 336'762.58 | +| generating large task graphs | chain topology | 68'358.00 | 69'061.75 | 519.05 | +| generating large task graphs | expanding tree topology | 140'804.00 | 141'607.00 | 1'166.07 | +| generating large task graphs | contracting tree topology | 180'160.00 | 181'704.31 | 1'276.49 | +| generating large task graphs | wave\_sim topology | 650'210.00 | 652'725.73 | 2'382.66 | +| generating large task graphs | jacobi topology | 220'776.00 | 222'358.72 | 2'073.69 | +| generating large command graphs for N nodes - 1 | soup topology | 23'827'400.00 | 27'207'829.61 | 601'428.50 | +| generating large command graphs for N nodes - 1 | chain topology | 279'707.00 | 281'686.27 | 2'195.49 | +| generating large command graphs for N nodes - 1 | expanding tree topology | 443'829.00 | 449'639.78 | 3'316.87 | +| generating large command graphs for N nodes - 1 | contracting tree topology | 487'512.00 | 493'651.42 | 4'341.31 | +| generating large command graphs for N nodes - 1 | wave\_sim topology | 2'171'822.00 | 2'207'590.22 | 21'295.87 | +| generating large command graphs for N nodes - 1 | jacobi topology | 814'711.00 | 831'167.62 | 8'547.64 | +| generating large command graphs for N nodes - 4 | soup topology | 58'610'131.00 | 65'211'801.88 | 1'104'780.18 | +| generating large command graphs for N nodes - 4 | chain topology | 3'407'001.00 | 3'429'528.49 | 17'697.64 | +| generating large command graphs for N nodes - 4 | expanding tree topology | 8'590'850.00 | 9'506'820.91 | 292'984.38 | +| generating large command graphs for N nodes - 4 | contracting tree topology | 3'317'913.00 | 3'814'408.53 | 111'748.12 | +| generating large command graphs for N nodes - 4 | wave\_sim topology | 14'572'309.00 | 15'527'801.59 | 106'883.15 | +| generating large command graphs for N nodes - 4 | jacobi topology | 5'362'685.00 | 5'412'009.59 | 44'603.50 | +| generating large command graphs for N nodes - 16 | soup topology | 207'602'155.00 | 223'193'282.43 | 2'452'923.34 | +| generating large command graphs for N nodes - 16 | chain topology | 422'595'111.00 | 432'110'010.36 | 3'270'868.75 | +| generating large command graphs for N nodes - 16 | expanding tree topology | 693'820'943.00 | 702'699'377.08 | 3'311'691.39 | +| generating large command graphs for N nodes - 16 | contracting tree topology | 131'218'457.00 | 138'428'564.60 | 1'899'956.79 | +| generating large command graphs for N nodes - 16 | wave\_sim topology | 129'167'622.00 | 133'825'598.13 | 981'360.70 | +| generating large command graphs for N nodes - 16 | jacobi topology | 123'237'099.00 | 128'612'549.45 | 1'210'894.04 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | soup topology | 26'872'236.00 | 27'559'385.80 | 80'392.98 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | chain topology | 280'850.00 | 284'061.63 | 2'511.81 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | expanding tree topology | 443'819.00 | 449'069.74 | 3'838.98 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | contracting tree topology | 489'876.00 | 495'187.37 | 3'751.51 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | wave\_sim topology | 2'202'640.00 | 2'244'337.34 | 12'859.14 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: single-threaded immediate graph generation | jacobi topology | 845'209.00 | 852'012.15 | 4'278.97 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | soup topology | 17'345'752.00 | 24'180'555.12 | 2'329'883.77 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | chain topology | 695'626.00 | 1'099'782.42 | 336'206.07 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | expanding tree topology | 1'024'529.00 | 1'232'532.52 | 111'928.78 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | contracting tree topology | 1'217'043.00 | 1'351'947.55 | 100'814.93 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | wave\_sim topology | 4'949'973.00 | 6'591'218.12 | 1'189'268.73 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > immediate submission to a scheduler thread | jacobi topology | 2'293'532.00 | 2'571'332.22 | 187'986.29 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 26'150'941.00 | 29'500'978.53 | 344'509.18 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 543'167.00 | 572'743.46 | 10'841.96 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 747'213.00 | 754'992.04 | 4'028.09 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 796'146.00 | 800'417.73 | 4'268.89 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 4'245'950.00 | 4'286'679.06 | 9'473.34 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 1'241'690.00 | 1'347'019.10 | 26'704.56 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | soup topology | 19'020'605.00 | 24'730'255.74 | 2'592'825.51 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | chain topology | 1'094'511.00 | 1'478'179.99 | 201'333.89 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 1'462'177.00 | 1'668'805.70 | 153'544.92 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 1'479'731.00 | 1'700'208.05 | 105'883.93 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 5'587'601.00 | 9'176'514.36 | 1'415'209.35 | +| building command graphs in a dedicated scheduler thread for N nodes - 1 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 2'233'909.00 | 3'163'099.60 | 137'316.01 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | soup topology | 59'793'752.00 | 65'464'242.85 | 1'614'192.65 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | chain topology | 3'425'496.00 | 3'451'136.53 | 20'370.85 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | expanding tree topology | 8'599'817.00 | 9'545'945.69 | 301'166.98 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | contracting tree topology | 3'355'634.00 | 3'840'354.18 | 163'984.89 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | wave\_sim topology | 13'736'738.00 | 15'459'748.68 | 430'047.92 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: single-threaded immediate graph generation | jacobi topology | 4'766'917.00 | 5'414'204.53 | 151'818.12 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | soup topology | 45'408'165.00 | 55'516'257.83 | 3'608'988.68 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | chain topology | 4'305'643.00 | 4'877'410.78 | 436'837.41 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | expanding tree topology | 7'624'249.00 | 8'534'561.12 | 372'105.31 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | contracting tree topology | 5'136'407.00 | 5'894'647.39 | 572'388.76 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | wave\_sim topology | 23'229'617.00 | 26'593'067.60 | 1'508'383.17 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > immediate submission to a scheduler thread | jacobi topology | 7'647'273.00 | 9'783'209.23 | 984'925.48 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | soup topology | 62'321'560.00 | 67'191'056.93 | 1'825'907.62 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | chain topology | 3'294'358.00 | 3'699'713.04 | 138'353.12 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | expanding tree topology | 8'891'820.00 | 9'811'516.03 | 298'400.05 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | contracting tree topology | 3'784'546.00 | 4'168'930.62 | 52'894.53 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | wave\_sim topology | 15'861'380.00 | 17'665'254.96 | 310'611.90 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > reference: throttled single-threaded graph generation at 10 us per task | jacobi topology | 5'276'071.00 | 5'933'871.78 | 221'153.12 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | soup topology | 47'237'810.00 | 55'775'812.43 | 3'926'479.91 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | chain topology | 4'962'348.00 | 6'262'078.22 | 849'344.97 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | expanding tree topology | 8'631'566.00 | 9'420'657.05 | 657'961.19 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | contracting tree topology | 5'294'236.00 | 6'411'874.34 | 754'478.08 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | wave\_sim topology | 21'065'818.00 | 29'246'847.41 | 2'300'323.85 | +| building command graphs in a dedicated scheduler thread for N nodes - 4 > throttled submission to a scheduler thread at 10 us per task | jacobi topology | 8'214'627.00 | 10'903'128.93 | 1'281'574.07 | All numbers are in nanoseconds. diff --git a/include/runtime.h b/include/runtime.h index 95e00ecc9..a20bd296f 100644 --- a/include/runtime.h +++ b/include/runtime.h @@ -55,9 +55,9 @@ namespace detail { */ void startup(); - void shutdown() noexcept; + void shutdown(); - void sync() noexcept; + void sync(); bool is_master_node() const { return local_nid == 0; } diff --git a/include/task_manager.h b/include/task_manager.h index e6111f39d..0f894466b 100644 --- a/include/task_manager.h +++ b/include/task_manager.h @@ -31,9 +31,10 @@ namespace detail { return this_epoch; } - void await(const task_id epoch) const { + task_id await(const task_id min_tid_reached) const { std::unique_lock lock{mutex}; - epoch_changed.wait(lock, [=] { return this_epoch >= epoch; }); + epoch_changed.wait(lock, [=] { return this_epoch >= min_tid_reached; }); + return this_epoch; } void set(const task_id epoch) { @@ -67,15 +68,18 @@ namespace detail { task_id tid; { std::lock_guard lock(task_mutex); - auto reservation = task_buffer.reserve_task_entry(); + auto reservation = task_buffer.reserve_task_entry(await_free_task_slot_callback()); tid = reservation.get_tid(); prepass_handler cgh(tid, std::make_unique>(cgf), num_collective_nodes); cgf(cgh); - task& task_ref = register_task_internal(reservation, std::move(cgh).into_task()); + task& task_ref = register_task_internal(std::move(reservation), std::move(cgh).into_task()); compute_dependencies(tid); if(queue) queue->require_collective_group(task_ref.get_collective_group_id()); + + // the following deletion is intentionally redundant with the one happening when waiting for free task slots + // we want to free tasks earlier than just when running out of slots task_buffer.delete_up_to(latest_epoch_reached.get()); } invoke_callbacks(tid); @@ -168,7 +172,6 @@ namespace detail { reduction_manager* reduction_mngr; - task_id next_task_id = 1; task_ring_buffer task_buffer; // The active epoch is used as the last writer for host-initialized buffers. @@ -205,13 +208,16 @@ namespace detail { // Only accessed in task_manager::notify_*, which are always called from the executor thread - no locking needed. std::optional latest_horizon_reached; + // The number of horizons and epochs in flight, used to detect stalling scenarios with very broad task graphs + std::atomic number_of_in_flight_horizons_and_epochs = 0; + // The last epoch task that has been processed by the executor. Behind a monitor to allow awaiting this change from the main thread. epoch_monitor latest_epoch_reached{initial_epoch_task}; // Set of tasks with no dependents std::unordered_set execution_front; - task& register_task_internal(task_ring_buffer::reservation& reserve, std::unique_ptr task); + task& register_task_internal(task_ring_buffer::reservation&& reserve, std::unique_ptr task); void invoke_callbacks(task_id tid); @@ -221,7 +227,7 @@ namespace detail { int get_max_pseudo_critical_path_length() const { return max_pseudo_critical_path_length; } - task_id reduce_execution_front(task_ring_buffer::reservation& reserve, std::unique_ptr new_front); + task_id reduce_execution_front(task_ring_buffer::reservation&& reserve, std::unique_ptr new_front); void set_epoch_for_new_tasks(task_id epoch); @@ -230,6 +236,9 @@ namespace detail { task_id generate_horizon_task(); void compute_dependencies(task_id tid); + + // Returns a callback which blocks until any epoch task has executed, freeing new task slots + task_ring_buffer::wait_callback await_free_task_slot_callback(); }; } // namespace detail diff --git a/include/task_ring_buffer.h b/include/task_ring_buffer.h index 4fbd01eb8..f3afdf21c 100644 --- a/include/task_ring_buffer.h +++ b/include/task_ring_buffer.h @@ -3,7 +3,6 @@ #include #include #include -#include #include "log.h" #include "task.h" @@ -14,6 +13,8 @@ namespace celerity::detail { constexpr unsigned long task_ringbuffer_size = 1024; class task_ring_buffer { + friend struct task_ring_buffer_testspy; + public: // This is an RAII type for ensuring correct handling of task id reservations // in the presence of exceptions (i.e. revoking the reservation on stack unwinding) @@ -25,7 +26,7 @@ class task_ring_buffer { ~reservation() { if(!consumed) { CELERITY_WARN("Consumed reservation for tid {} in destructor", tid); - buffer.revoke_reservation(*this); + buffer.revoke_reservation(std::move(*this)); } } reservation(const reservation&) = delete; // non copyable @@ -45,13 +46,13 @@ class task_ring_buffer { task_ring_buffer& buffer; }; - size_t get_total_task_count() const { return next_active_tid.load(); } - size_t get_current_task_count() const { return next_active_tid.load() - number_of_deleted_tasks; } - bool has_task(task_id tid) const { - return tid >= number_of_deleted_tasks && tid < next_active_tid.load(); // + return tid >= number_of_deleted_tasks.load(std::memory_order_relaxed) // best effort, only reliable from application thread + && tid < next_active_tid.load(std::memory_order_acquire); // synchronizes access to data with put(...) } + size_t get_total_task_count() const { return next_active_tid.load(std::memory_order_relaxed); } + task* find_task(task_id tid) const { return has_task(tid) ? data[tid % task_ringbuffer_size].get() : nullptr; } task* get_task(task_id tid) const { @@ -59,39 +60,48 @@ class task_ring_buffer { return data[tid % task_ringbuffer_size].get(); } - reservation reserve_task_entry() { - wait_for_available_slot(); + // all member functions beyond this point may *only* be called by the main application thread + + size_t get_current_task_count() const { // + return next_active_tid.load(std::memory_order_relaxed) - number_of_deleted_tasks.load(std::memory_order_relaxed); + } + + // the task id passed to the wait callback identifies the lowest in-use TID that the ring buffer is aware of + using wait_callback = std::function; + + reservation reserve_task_entry(const wait_callback& wc) { + wait_for_available_slot(wc); reservation ret(next_task_id, *this); next_task_id++; return ret; } - void revoke_reservation(reservation& reserve) { + void revoke_reservation(reservation&& reserve) { reserve.consume(); assert(reserve.tid == next_task_id - 1); // this is the only allowed (and extant) pattern next_task_id--; } - void put(reservation& reserve, std::unique_ptr task) { + void put(reservation&& reserve, std::unique_ptr task) { reserve.consume(); - task_id expected_tid = reserve.tid; - [[maybe_unused]] bool successfully_updated = next_active_tid.compare_exchange_strong(expected_tid, next_active_tid.load() + 1); - assert(successfully_updated); // this is the only allowed (and extant) pattern + assert(next_active_tid.load(std::memory_order_relaxed) == reserve.tid); data[reserve.tid % task_ringbuffer_size] = std::move(task); + next_active_tid.store(reserve.tid + 1, std::memory_order_release); } - // may only be called by one thread void delete_up_to(task_id target_tid) { - for(task_id tid = number_of_deleted_tasks.load(); tid < target_tid; ++tid) { + assert(target_tid >= number_of_deleted_tasks.load(std::memory_order_relaxed)); + for(task_id tid = number_of_deleted_tasks.load(std::memory_order_relaxed); tid < target_tid; ++tid) { data[tid % task_ringbuffer_size].reset(); } - number_of_deleted_tasks += target_tid - number_of_deleted_tasks.load(); + number_of_deleted_tasks.store(target_tid, std::memory_order_relaxed); } void clear() { for(auto&& d : data) { d.reset(); } + number_of_deleted_tasks.store(next_task_id, std::memory_order_relaxed); } class task_buffer_iterator { @@ -106,7 +116,9 @@ class task_ring_buffer { bool operator!=(task_buffer_iterator other) { return &buffer != &other.buffer || id != other.id; } }; - task_buffer_iterator begin() const { return task_buffer_iterator(number_of_deleted_tasks, *this); } + task_buffer_iterator begin() const { // + return task_buffer_iterator(number_of_deleted_tasks.load(std::memory_order_relaxed), *this); + } task_buffer_iterator end() const { return task_buffer_iterator(next_task_id, *this); } private: @@ -115,12 +127,13 @@ class task_ring_buffer { // the next task id that will actually be emplaced std::atomic next_active_tid = task_id(0); // the number of deleted tasks (which is implicitly the start of the active range of the ringbuffer) - std::atomic number_of_deleted_tasks = 0; + std::atomic number_of_deleted_tasks = 0; std::array, task_ringbuffer_size> data; - void wait_for_available_slot() const { - while(next_task_id - number_of_deleted_tasks >= task_ringbuffer_size) - std::this_thread::yield(); // busy wait until we have available slots + void wait_for_available_slot(const wait_callback& wc) const { + if(next_task_id - number_of_deleted_tasks.load(std::memory_order_relaxed) >= task_ringbuffer_size) { + wc(static_cast(number_of_deleted_tasks.load(std::memory_order_relaxed))); + } } }; diff --git a/src/runtime.cc b/src/runtime.cc index b3dac4ec5..9fa1b57f4 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -185,7 +185,7 @@ namespace detail { set_thread_name(get_current_thread_handle(), "cy-main"); } - void runtime::shutdown() noexcept { + void runtime::shutdown() { assert(is_active); is_shutting_down = true; @@ -229,7 +229,7 @@ namespace detail { maybe_destroy_runtime(); } - void runtime::sync() noexcept { + void runtime::sync() { const auto epoch = task_mngr->generate_epoch_task(epoch_action::barrier); task_mngr->await_epoch(epoch); } diff --git a/src/task_manager.cc b/src/task_manager.cc index 0a719c7e3..08bb743d1 100644 --- a/src/task_manager.cc +++ b/src/task_manager.cc @@ -9,8 +9,8 @@ namespace detail { task_manager::task_manager(size_t num_collective_nodes, host_queue* queue, reduction_manager* reduction_mgr) : num_collective_nodes(num_collective_nodes), queue(queue), reduction_mngr(reduction_mgr) { // We manually generate the initial epoch task, which we treat as if it has been reached immediately. - auto reserve = task_buffer.reserve_task_entry(); - task_buffer.put(reserve, task::make_epoch(initial_epoch_task, epoch_action::none)); + auto reserve = task_buffer.reserve_task_entry(await_free_task_slot_callback()); + task_buffer.put(std::move(reserve), task::make_epoch(initial_epoch_task, epoch_action::none)); } void task_manager::add_buffer(buffer_id bid, const cl::sycl::range<3>& range, bool host_initialized) { @@ -34,16 +34,14 @@ namespace detail { } void task_manager::notify_horizon_reached(task_id horizon_tid) { - // This method is called from the executor thread, but does not lock task_mutex to avoid lock-step execution with the main thread. - // latest_horizon_reached does not need synchronization (see definition), all other accesses are implicitly synchronized. - assert(task_buffer.get_task(horizon_tid)->get_type() == task_type::HORIZON); assert(!latest_horizon_reached || *latest_horizon_reached < horizon_tid); assert(latest_epoch_reached.get() < horizon_tid); - if(latest_horizon_reached) { - latest_epoch_reached.set(*latest_horizon_reached); // The next call to submit_command_group() will prune all tasks before the epoch reached - } + assert(number_of_in_flight_horizons_and_epochs.load() > 0); + number_of_in_flight_horizons_and_epochs--; + + if(latest_horizon_reached) { latest_epoch_reached.set(*latest_horizon_reached); } latest_horizon_reached = horizon_tid; } @@ -56,7 +54,10 @@ namespace detail { assert(!latest_horizon_reached || *latest_horizon_reached < epoch_tid); assert(latest_epoch_reached.get() < epoch_tid); - latest_epoch_reached.set(epoch_tid); // The next call to submit_command_group() will prune all tasks before the last epoch reached + assert(number_of_in_flight_horizons_and_epochs.load() > 0); + number_of_in_flight_horizons_and_epochs--; + + latest_epoch_reached.set(epoch_tid); latest_horizon_reached = std::nullopt; // Any non-applied horizon is now behind the epoch and will therefore never become an epoch itself } @@ -112,7 +113,6 @@ namespace detail { // A valid use case (i.e., not reading garbage) for this is when the buffer has been initialized using a host pointer. if(p.second == std::nullopt) continue; const task_id last_writer = *p.second; - assert(task_buffer.has_task(last_writer)); add_dependency(tsk, task_buffer.get_task(last_writer), dependency_kind::TRUE_DEP, dependency_origin::dataflow); } } @@ -126,7 +126,6 @@ namespace detail { const auto last_writers = buffers_last_writers.at(bid).get_region_values(write_requirements); for(auto& p : last_writers) { if(p.second == std::nullopt) continue; - assert(task_buffer.has_task(*p.second)); task* last_writer = task_buffer.get_task(*p.second); // Determine anti-dependencies by looking at all the dependents of the last writing task @@ -185,10 +184,15 @@ namespace detail { } } - task& task_manager::register_task_internal(task_ring_buffer::reservation& reserve, std::unique_ptr task) { + task& task_manager::register_task_internal(task_ring_buffer::reservation&& reserve, std::unique_ptr task) { auto& task_ref = *task; assert(task != nullptr); - task_buffer.put(reserve, std::move(task)); + + if(task_ref.get_type() == task_type::EPOCH || task_ref.get_type() == task_type::HORIZON) { + number_of_in_flight_horizons_and_epochs++; // + } + + task_buffer.put(std::move(reserve), std::move(task)); execution_front.insert(&task_ref); return task_ref; } @@ -207,14 +211,14 @@ namespace detail { max_pseudo_critical_path_length = std::max(max_pseudo_critical_path_length, depender->get_pseudo_critical_path_length()); } - task_id task_manager::reduce_execution_front(task_ring_buffer::reservation& reserve, std::unique_ptr new_front) { + task_id task_manager::reduce_execution_front(task_ring_buffer::reservation&& reserve, std::unique_ptr new_front) { // add dependencies from a copy of the front to this task const auto current_front = execution_front; for(task* front_task : current_front) { add_dependency(new_front.get(), front_task, dependency_kind::TRUE_DEP, dependency_origin::execution_front); } assert(execution_front.empty()); - return register_task_internal(reserve, std::move(new_front)).get_id(); + return register_task_internal(std::move(reserve), std::move(new_front)).get_id(); } void task_manager::set_epoch_for_new_tasks(const task_id epoch) { @@ -239,12 +243,12 @@ namespace detail { // we are probably overzealous in locking here task_id tid; { - auto reserve = task_buffer.reserve_task_entry(); + auto reserve = task_buffer.reserve_task_entry(await_free_task_slot_callback()); tid = reserve.get_tid(); std::lock_guard lock(task_mutex); current_horizon_critical_path_length = max_pseudo_critical_path_length; const auto previous_horizon = current_horizon; - current_horizon = reduce_execution_front(reserve, task::make_horizon_task(tid)); + current_horizon = reduce_execution_front(std::move(reserve), task::make_horizon_task(tid)); if(previous_horizon) { set_epoch_for_new_tasks(*previous_horizon); } } @@ -257,10 +261,10 @@ namespace detail { // we are probably overzealous in locking here task_id tid; { - auto reserve = task_buffer.reserve_task_entry(); + auto reserve = task_buffer.reserve_task_entry(await_free_task_slot_callback()); tid = reserve.get_tid(); std::lock_guard lock(task_mutex); - const auto new_epoch = reduce_execution_front(reserve, task::make_epoch(tid, action)); + const auto new_epoch = reduce_execution_front(std::move(reserve), task::make_epoch(tid, action)); compute_dependencies(new_epoch); set_epoch_for_new_tasks(new_epoch); current_horizon = std::nullopt; // this horizon is now behind the epoch_for_new_tasks, so it will never become an epoch itself @@ -272,5 +276,19 @@ namespace detail { return tid; } + task_ring_buffer::wait_callback task_manager::await_free_task_slot_callback() { + return [&](task_id previous_free_tid) { + if(number_of_in_flight_horizons_and_epochs == 0) { + // verify that the epoch didn't get reached between the invocation of the callback and the in flight check + if(latest_epoch_reached.get() < previous_free_tid + 1) { + throw std::runtime_error("Exhausted task slots with no horizons or epochs in flight." + "\nLikely due to generating a very large number of tasks with no dependencies."); + } + } + task_id reached_epoch = latest_epoch_reached.await(previous_free_tid + 1); + task_buffer.delete_up_to(reached_epoch); + }; + } + } // namespace detail } // namespace celerity diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a577b503b..beffea305 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -37,6 +37,7 @@ set(TEST_TARGETS runtime_deprecation_tests sycl_tests task_graph_tests + task_ring_buffer_tests device_selection_tests ) diff --git a/test/task_ring_buffer_tests.cc b/test/task_ring_buffer_tests.cc new file mode 100644 index 000000000..bb5b22db7 --- /dev/null +++ b/test/task_ring_buffer_tests.cc @@ -0,0 +1,53 @@ +#include "task_ring_buffer.h" + +#include +#include + +#include + +#include "test_utils.h" + +namespace celerity::detail { + +TEST_CASE_METHOD(test_utils::runtime_fixture, "freeing task ring buffer capacity via horizons continues execution in runtime", "[task_ring_buffer]") { + using namespace std::chrono_literals; + celerity::distr_queue q; + + std::atomic reached_ringbuffer_capacity = false; + + auto observer = std::thread([&] { + while(runtime::get_instance().get_task_manager().get_total_task_count() < task_ringbuffer_size) + ; + reached_ringbuffer_capacity = true; + }); + + celerity::buffer dependency{1}; + + for(size_t i = 0; i < task_ringbuffer_size + 10; ++i) { + q.submit(celerity::allow_by_ref, [=, &reached_ringbuffer_capacity](celerity::handler& cgh) { + celerity::accessor acc{dependency, cgh, celerity::access::all{}, celerity::read_write_host_task}; + cgh.host_task(celerity::on_master_node, [=, &reached_ringbuffer_capacity] { + while(!reached_ringbuffer_capacity.load()) + ; + }); + }); + } + + observer.join(); +} + +TEST_CASE_METHOD(test_utils::runtime_fixture, "deadlock in task ring buffer due to slot exhaustion is reported", "[task_ring_buffer]") { + celerity::distr_queue q; + CHECK_THROWS_WITH( + [&] { + for(size_t i = 0; i < task_ringbuffer_size + 1; ++i) { + q.submit([=](celerity::handler& cgh) { cgh.host_task(celerity::on_master_node, [=] {}); }); + } + }(), + Catch::Matchers::ContainsSubstring("Exhausted task slots")); + + // we need to create a slot for the epoch task required for the runtime shutdown to succeed + task_manager_testspy::create_task_slot(runtime::get_instance().get_task_manager()); +} + +} // namespace celerity::detail \ No newline at end of file diff --git a/test/test_utils.h b/test/test_utils.h index e8ee1ef16..3dcc0b456 100644 --- a/test/test_utils.h +++ b/test/test_utils.h @@ -40,6 +40,10 @@ namespace celerity { namespace detail { + struct task_ring_buffer_testspy { + static void create_task_slot(task_ring_buffer& trb) { trb.number_of_deleted_tasks += 1; } + }; + struct task_manager_testspy { static std::optional get_current_horizon(task_manager& tm) { return tm.current_horizon; } @@ -56,6 +60,8 @@ namespace detail { static int get_max_pseudo_critical_path_length(task_manager& tm) { return tm.get_max_pseudo_critical_path_length(); } static auto get_execution_front(task_manager& tm) { return tm.get_execution_front(); } + + static void create_task_slot(task_manager& tm) { task_ring_buffer_testspy::create_task_slot(tm.task_buffer); } }; inline bool has_dependency(const task_manager& tm, task_id dependent, task_id dependency, dependency_kind kind = dependency_kind::TRUE_DEP) { From 72ad57cf05d908404433b6866070f74b92b3a856 Mon Sep 17 00:00:00 2001 From: Peter Thoman Date: Mon, 18 Jul 2022 11:23:01 +0200 Subject: [PATCH 8/8] Replace latest epoch tracking with on-demand lookup --- include/task_manager.h | 10 ++++++---- src/task_manager.cc | 30 ++++++++++++++++++------------ test/task_ring_buffer_tests.cc | 3 ++- 3 files changed, 26 insertions(+), 17 deletions(-) diff --git a/include/task_manager.h b/include/task_manager.h index 0f894466b..33c2ee0c8 100644 --- a/include/task_manager.h +++ b/include/task_manager.h @@ -79,7 +79,8 @@ namespace detail { if(queue) queue->require_collective_group(task_ref.get_collective_group_id()); // the following deletion is intentionally redundant with the one happening when waiting for free task slots - // we want to free tasks earlier than just when running out of slots + // we want to free tasks earlier than just when running out of slots, + // so that we can potentially reclaim additional resources such as buffers earlier task_buffer.delete_up_to(latest_epoch_reached.get()); } invoke_callbacks(tid); @@ -208,9 +209,6 @@ namespace detail { // Only accessed in task_manager::notify_*, which are always called from the executor thread - no locking needed. std::optional latest_horizon_reached; - // The number of horizons and epochs in flight, used to detect stalling scenarios with very broad task graphs - std::atomic number_of_in_flight_horizons_and_epochs = 0; - // The last epoch task that has been processed by the executor. Behind a monitor to allow awaiting this change from the main thread. epoch_monitor latest_epoch_reached{initial_epoch_task}; @@ -237,6 +235,10 @@ namespace detail { void compute_dependencies(task_id tid); + // Finds the first in-flight epoch, or returns the currently reached one if there are none in-flight + // Used in await_free_task_slot_callback to check for hangs + task_id get_first_in_flight_epoch() const; + // Returns a callback which blocks until any epoch task has executed, freeing new task slots task_ring_buffer::wait_callback await_free_task_slot_callback(); }; diff --git a/src/task_manager.cc b/src/task_manager.cc index 08bb743d1..7bcb1de86 100644 --- a/src/task_manager.cc +++ b/src/task_manager.cc @@ -38,9 +38,6 @@ namespace detail { assert(!latest_horizon_reached || *latest_horizon_reached < horizon_tid); assert(latest_epoch_reached.get() < horizon_tid); - assert(number_of_in_flight_horizons_and_epochs.load() > 0); - number_of_in_flight_horizons_and_epochs--; - if(latest_horizon_reached) { latest_epoch_reached.set(*latest_horizon_reached); } latest_horizon_reached = horizon_tid; @@ -54,9 +51,6 @@ namespace detail { assert(!latest_horizon_reached || *latest_horizon_reached < epoch_tid); assert(latest_epoch_reached.get() < epoch_tid); - assert(number_of_in_flight_horizons_and_epochs.load() > 0); - number_of_in_flight_horizons_and_epochs--; - latest_epoch_reached.set(epoch_tid); latest_horizon_reached = std::nullopt; // Any non-applied horizon is now behind the epoch and will therefore never become an epoch itself } @@ -187,11 +181,6 @@ namespace detail { task& task_manager::register_task_internal(task_ring_buffer::reservation&& reserve, std::unique_ptr task) { auto& task_ref = *task; assert(task != nullptr); - - if(task_ref.get_type() == task_type::EPOCH || task_ref.get_type() == task_type::HORIZON) { - number_of_in_flight_horizons_and_epochs++; // - } - task_buffer.put(std::move(reserve), std::move(task)); execution_front.insert(&task_ref); return task_ref; @@ -276,9 +265,26 @@ namespace detail { return tid; } + task_id task_manager::get_first_in_flight_epoch() const { + task_id current_horizon = 0; + task_id latest_epoch = latest_epoch_reached.get(); + // we need either one epoch or two horizons that have yet to be executed + // so that it is possible for task slots to be freed in the future + for(const auto& tsk : task_buffer) { + if(tsk->get_id() <= latest_epoch) continue; + if(tsk->get_type() == task_type::EPOCH) { + return tsk->get_id(); + } else if(tsk->get_type() == task_type::HORIZON) { + if(current_horizon) return current_horizon; + current_horizon = tsk->get_id(); + } + } + return latest_epoch; + } + task_ring_buffer::wait_callback task_manager::await_free_task_slot_callback() { return [&](task_id previous_free_tid) { - if(number_of_in_flight_horizons_and_epochs == 0) { + if(get_first_in_flight_epoch() == latest_epoch_reached.get()) { // verify that the epoch didn't get reached between the invocation of the callback and the in flight check if(latest_epoch_reached.get() < previous_free_tid + 1) { throw std::runtime_error("Exhausted task slots with no horizons or epochs in flight." diff --git a/test/task_ring_buffer_tests.cc b/test/task_ring_buffer_tests.cc index bb5b22db7..6ed569090 100644 --- a/test/task_ring_buffer_tests.cc +++ b/test/task_ring_buffer_tests.cc @@ -28,7 +28,8 @@ TEST_CASE_METHOD(test_utils::runtime_fixture, "freeing task ring buffer capacity celerity::accessor acc{dependency, cgh, celerity::access::all{}, celerity::read_write_host_task}; cgh.host_task(celerity::on_master_node, [=, &reached_ringbuffer_capacity] { while(!reached_ringbuffer_capacity.load()) - ; + ; // we wait in all tasks so that we can make sure to fill the ring buffer completely + // and therefore test that execution re-starts correctly once an epoch is reached }); }); }