int hpx_main(variables_map& vm) { int test; std::string inputFile; inputFile = vm["input"].as<std::string>(); { id_type prefix = get_applier().get_runtime_support_gid(); bhcontroller dat; dat.create(prefix); test = dat.construct(inputFile); if(test == 0){ dat.run_simulation(); } dat.free(); // std::cout << (boost::format("total error : %1%\n" // "average error : %2%\n") // % r % (r / size)); } finalize(); std::cout<<"OH YEAH!\n"; return 0; }
int hpx_main(variables_map& vm) { { boost::uint64_t n = vm["n-value"].as<boost::uint64_t>(); const id_type prefix = get_applier().get_runtime_support_gid(); high_resolution_timer t; jacobsthal_future f(prefix, prefix, n); bigint r = f.get(); double elapsed = t.elapsed(); std::cout << ( boost::format("jacobsthal(%1%) == %2%\n" "elapsed time == %3%\n") % n % r % elapsed); } finalize(); return 0; }
int hpx_main( variables_map& vm ) { if (vm.count("no-header")) header = false; { if (0 == tasks) throw std::invalid_argument("count of 0 tasks specified\n"); // Start the clock. high_resolution_timer t; for (boost::uint64_t i = 0; i < tasks; ++i) register_work(HPX_STD_BIND(&invoke_worker, delay)); // Reschedule hpx_main until all other hpx-threads have finished. We // should be resumed after most of the null px-threads have been // executed. If we haven't, we just reschedule ourselves again. do { suspend(); } while (get_thread_count(hpx::threads::thread_priority_normal) > 1); print_results(get_os_thread_count(), t.elapsed()); } return finalize(); }
int hpx_main(variables_map& vm) { { boost::uint64_t m = vm["m-value"].as<boost::uint64_t>() , n = vm["n-value"].as<boost::uint64_t>(); const id_type prefix = get_applier().get_runtime_support_gid(); high_resolution_timer t; ackermann_peter_future f(prefix, prefix, m, n); boost::uint64_t r = f.get(); double elapsed = t.elapsed(); std::cout << ( boost::format("ackermann_peter(%1%, %2%) == %3%\n" "elapsed time == %4%\n") % m % n % r % elapsed); } finalize(); return 0; }
int hpx_main(variables_map& vm) { boost::uint64_t const futures = vm["futures"].as<boost::uint64_t>(); boost::uint64_t const grain_size = vm["grain-size"].as<boost::uint64_t>(); { thread_id_type thread_id = register_thread_nullary( boost::bind(&test_dummy_thread, futures)); HPX_TEST(thread_id != hpx::threads::invalid_thread_id); // Flood the queues with suspension operations before the rescheduling // attempt. unique_future<void> before = async(&tree_boot, futures, grain_size, thread_id); set_thread_state(thread_id, pending, wait_signaled); // Flood the queues with suspension operations after the rescheduling // attempt. unique_future<void> after = async(&tree_boot, futures, grain_size, thread_id); before.get(); after.get(); set_thread_state(thread_id, pending, wait_terminate); } finalize(); return 0; }
int hpx_main(variables_map& vm) { unsigned int size(0), allocblock(0), blocksize(0); size = vm["size"].as<unsigned int>(); allocblock = vm["allocblock"].as<unsigned int>(); blocksize = vm["blocksize"].as<unsigned int>(); { id_type prefix = get_applier().get_runtime_support_gid(); smphplmatrex dat; dat.create(prefix); dat.construct(size, allocblock, blocksize); double r = dat.LUsolve(); dat.free(); std::cout << (boost::format("total error : %1%\n" "average error : %2%\n") % r % (r / size)); } finalize(); return 0; }
int hpx_main(variables_map& vm) { std::size_t pxthreads = 0; if (vm.count("pxthreads")) pxthreads = vm["pxthreads"].as<std::size_t>(); std::size_t iterations = 0; if (vm.count("iterations")) iterations = vm["iterations"].as<std::size_t>(); std::size_t suspend_duration = 0; if (vm.count("suspend-duration")) suspend_duration = vm["suspend-duration"].as<std::size_t>(); { barrier b(pxthreads + 1); // Create the hpx-threads. for (std::size_t i = 0; i < pxthreads; ++i) register_work(boost::bind (&suspend_test, boost::ref(b), iterations, suspend_duration)); b.wait(); // Wait for all hpx-threads to enter the barrier. } // Initiate shutdown of the runtime system. return finalize(); }
int hpx_main(variables_map& vm) { boost::uint64_t const futures = vm["futures"].as<boost::uint64_t>(); boost::uint64_t const grain_size = vm["grain-size"].as<boost::uint64_t>(); { id_type const prefix = find_here(); thread_id_type thread_id = register_thread_nullary (boost::bind(&test_dummy_thread, futures)); boost::uint64_t thread = boost::uint64_t(thread_id); // Flood the queues with suspension operations before the rescheduling // attempt. future<void> before = async<tree_boot_action>(prefix, futures, grain_size, prefix, thread); set_thread_state(thread_id, pending, wait_signaled); // Flood the queues with suspension operations after the rescheduling // attempt. future<void> after = async<tree_boot_action>(prefix, futures, grain_size, prefix, thread); before.get(); after.get(); set_thread_state(thread_id, pending, wait_terminate); } finalize(); return 0; }
int hpx_main(variables_map& vm) { std::size_t pxthreads = 0; if (vm.count("pxthreads")) pxthreads = vm["pxthreads"].as<std::size_t>(); std::size_t iterations = 0; if (vm.count("iterations")) iterations = vm["iterations"].as<std::size_t>(); for (std::size_t i = 0; i < iterations; ++i) { // create a barrier waiting on 'count' threads barrier b(pxthreads + 1); boost::atomic<std::size_t> c(0); // create the threads which will wait on the barrier for (std::size_t i = 0; i < pxthreads; ++i) register_work(hpx::util::bind (&local_barrier_test, std::ref(b), std::ref(c))); b.wait(); // wait for all threads to enter the barrier HPX_TEST_EQ(pxthreads, c); } // initiate shutdown of the runtime system finalize(); return 0; }
int hpx_main( variables_map& vm ) { if (vm.count("no-header")) header = false; std::size_t num_os_threads = hpx::get_os_thread_count(); int num_executors = vm["executors"].as<int>(); if (num_executors <= 0) throw std::invalid_argument("number of executors to use must be larger than 0"); if (std::size_t(num_executors) > num_os_threads) throw std::invalid_argument("number of executors to use must be \ smaller than number of OS threads"); std::size_t num_cores_per_executor = vm["cores"].as<int>(); if ((num_executors - 1) * num_cores_per_executor > num_os_threads) throw std::invalid_argument("number of cores per executor should not \ cause oversubscription"); if (0 == tasks) throw std::invalid_argument("count of 0 tasks specified\n"); // Start the clock. high_resolution_timer t; // create the executor instances using hpx::threads::executors::local_priority_queue_executor; { std::vector<local_priority_queue_executor> executors; for (std::size_t i = 0; i != std::size_t(num_executors); ++i) { // make sure we don't oversubscribe the cores, the last executor will // be bound to the remaining number of cores if ((i + 1) * num_cores_per_executor > num_os_threads) { HPX_ASSERT(i == std::size_t(num_executors) - 1); num_cores_per_executor = num_os_threads - i * num_cores_per_executor; } executors.push_back(local_priority_queue_executor(num_cores_per_executor)); } t.restart(); // schedule normal threads for (boost::uint64_t i = 0; i < tasks; ++i) executors[i % num_executors].add( hpx::util::bind(&worker_timed, delay * 1000)); // destructors of executors will wait for all tasks to finish executing } print_results(num_os_threads, t.elapsed()); return finalize(); }
int hpx_main(variables_map& vm) { here = find_here(); pi = boost::math::constants::pi<double>(); // dt = vm["dt-value"].as<double>(); // dx = vm["dx-value"].as<double>(); // c = vm["c-value"].as<double>(); nx = vm["nx-value"].as<boost::uint64_t>(); nt = vm["nt-value"].as<boost::uint64_t>(); c = 1.0; dt = 1.0/(nt-1); dx = 1.0/(nx-1); alpha_squared = (c*dt/dx)*(c*dt/dx); // check that alpha_squared satisfies the stability condition if (0.25 < alpha_squared) { cout << (("alpha^2 = (c*dt/dx)^2 should be less than 0.25 for stability!\n")) << flush; } u = std::vector<std::vector<data> >(nt, std::vector<data>(nx)); cout << (boost::format("dt = %1%\n") % dt) << flush; cout << (boost::format("dx = %1%\n") % dx) << flush; cout << (boost::format("alpha^2 = %1%\n") % alpha_squared) << flush; { // Keep track of the time required to execute. high_resolution_timer t; std::vector<future<double> > futures; for (boost::uint64_t i=0;i<nx;i++) futures.push_back(async<wave_action>(here,nt-1,i)); // open file for output std::ofstream outfile; outfile.open ("output.dat"); wait(futures, [&](std::size_t i, double n) { double x_here = i*dx; outfile << (boost::format("%1% %2%\n") % x_here % n) << flush; }); outfile.close(); char const* fmt = "elapsed time: %1% [s]\n"; std::cout << (boost::format(fmt) % t.elapsed()); } finalize(); return 0; }
int hpx_main(variables_map&) { test_void_actions(); test_void_direct_actions(); test_object_actions(); test_object_direct_actions(); finalize(); return hpx::util::report_errors(); }
int hpx_main( variables_map& vm ) { { simple_mobile_object a(hpx::find_here()); simple_mobile_object b(hpx::find_here()); id_type a_id = a.get_id(); gid_type a_gid = get_stripped_gid(a_id.get_gid()); boost::uint64_t b_lva = b.get_lva(); // Resolve a_gid. address addr = hpx::agas::resolve(a_id).get(); /////////////////////////////////////////////////////////////////////// HPX_TEST_EQ(addr.address_, a.get_lva()); HPX_SANITY_EQ(hpx::agas::resolve(a_id).get().address_, a.get_lva()); /////////////////////////////////////////////////////////////////////// // Change a's GID to point to b. // Rebind the GID. boost::uint64_t a_lva = addr.address_; addr.address_ = b_lva; HPX_TEST(get_agas_client().bind_local(a_gid, addr)); // Update our AGAS cache. get_agas_client().update_cache_entry(a_gid, addr); /////////////////////////////////////////////////////////////////////// HPX_TEST_EQ(b_lva, a.get_lva()); HPX_SANITY_EQ(hpx::agas::resolve(a_id).get().address_, a.get_lva()); /////////////////////////////////////////////////////////////////////// // Now we restore the original bindings to prevent a double free. // Rebind the GID. addr.address_ = a_lva; HPX_TEST(get_agas_client().bind_local(a_gid, addr)); // Update our AGAS cache. get_agas_client().update_cache_entry(a_gid, addr); /////////////////////////////////////////////////////////////////////// HPX_TEST_EQ(hpx::agas::resolve(a_id).get().address_, a_lva); HPX_SANITY_EQ(hpx::agas::resolve(a_id).get().address_, a.get_lva()); } finalize(); return report_errors(); }
int hpx_main( variables_map& ) { { const boost::format fmter("%1% %|40t|%2%\n"); cout << HPX_SIZEOF(hpx::naming::gid_type) << HPX_SIZEOF(hpx::naming::id_type) << HPX_SIZEOF(hpx::naming::address) << flush; } finalize(); return 0; }
int hpx_main(variables_map & vm) { { std::size_t nx = vm["nx"].as<std::size_t>(); std::size_t ny = vm["ny"].as<std::size_t>(); std::size_t max_iterations = vm["max_iterations"].as<std::size_t>(); std::size_t line_block = vm["line_block"].as<std::size_t>(); jacobi::grid u(nx, ny, 1.0); jacobi::solver solver(u, nx, line_block); solver.run(max_iterations); } return finalize(); }
int hpx_main(variables_map& vm) { { std::cout << "commands: localities, help, quit\n"; while (true) { std::cout << "> "; std::string arg; std::getline(std::cin, arg); if (arg.empty()) continue; else if (0 == std::string("quit").find(arg)) break; else if (0 == std::string("localities").find(arg)) { std::vector<id_type> localities = hpx::find_all_localities(); for (id_type const& locality_ : localities) { address addr = hpx::agas::resolve(locality_).get(); std::cout << ( boost::format(" [%1%] %2%\n") % get_locality_id_from_gid(locality_.get_gid()) % addr.locality_); } continue; } else if (0 != std::string("help").find(arg)) std::cout << ( boost::format("error: unknown command '%1%'\n") % arg); std::cout << "commands: localities, help, quit\n"; } } finalize(); return 0; }
int hpx_main(variables_map& vm) { std::size_t pxthreads = 0; if (vm.count("pxthreads")) pxthreads = vm["pxthreads"].as<std::size_t>(); std::size_t iterations = 0; if (vm.count("iterations")) iterations = vm["iterations"].as<std::size_t>(); for (std::size_t i = 0; i < iterations; ++i) { event e; boost::atomic<std::size_t> c(0); std::vector<hpx::future<void> > futs; futs.reserve(pxthreads); // Create the threads which will wait on the event for (std::size_t i = 0; i < pxthreads; ++i) { futs.push_back( hpx::async(&local_event_test, boost::ref(e), boost::ref(c)) ); } // Release all the threads. e.set(); // Wait for all the our threads to finish executing. hpx::wait_all(futs); HPX_TEST_EQ(pxthreads, c); // Make sure that waiting on a set event works. e.wait(); } // Initiate shutdown of the runtime system. return finalize(); }
int hpx_main( variables_map& vm ) { { num_iterations = vm["delay-iterations"].as<boost::uint64_t>(); const boost::uint64_t count = vm["futures"].as<boost::uint64_t>(); if (HPX_UNLIKELY(0 == count)) throw std::logic_error("error: count of 0 futures specified\n"); measure_action_futures(count, vm.count("csv") != 0); measure_function_futures(count, vm.count("csv") != 0); } finalize(); return 0; }
int hpx_main(variables_map& vm) { boost::uint64_t const futures = vm["futures"].as<boost::uint64_t>(); boost::uint64_t const grain_size = vm["grain-size"].as<boost::uint64_t>(); { id_type const prefix = find_here(); thread_id_type thread = register_thread_nullary (hpx::util::bind(&test_dummy_thread, futures)); tree_boot(futures, grain_size, prefix, reinterpret_cast<boost::uint64_t>(thread.get())); set_thread_state(thread, pending, wait_terminate); } finalize(); return 0; }
int hpx_main( variables_map& vm ) { { cout << std::string(80, '#') << "\n" << "simple component test\n" << std::string(80, '#') << "\n" << flush; hpx_test_main<simple_refcnt_monitor>(vm); cout << std::string(80, '#') << "\n" << "managed component test\n" << std::string(80, '#') << "\n" << flush; hpx_test_main<managed_refcnt_monitor>(vm); } finalize(); return report_errors(); }
int hpx_main( variables_map& ) { { # define HPX_SIZEOF(type) \ hpx::util::format("{1:-40} {2}\n", \ HPX_PP_STRINGIZE(type), sizeof(type)) \ /**/ cout << HPX_SIZEOF(hpx::naming::gid_type) << HPX_SIZEOF(hpx::naming::id_type) << HPX_SIZEOF(hpx::naming::address) << HPX_SIZEOF(hpx::threads::thread_data) << flush; # undef HPX_SIZEOF } finalize(); return 0; }
int hpx_main(variables_map& vm) { std::size_t num_threads = 1; if (vm.count("threads")) num_threads = vm["threads"].as<std::size_t>(); std::size_t pxthreads = 0; if (vm.count("pxthreads")) pxthreads = vm["pxthreads"].as<std::size_t>(); std::size_t iterations = 0; if (vm.count("iterations")) iterations = vm["iterations"].as<std::size_t>(); for (std::size_t i = 0; i < iterations; ++i) { id_type prefix = get_applier().get_runtime_support_gid(); // create a barrier waiting on 'count' threads barrier b; b.create_one(prefix, pxthreads + 1); boost::atomic<std::size_t> c(0); for (std::size_t j = 0; j < pxthreads; ++j) register_work(boost::bind (&barrier_test, b.get_gid(), boost::ref(c), pxthreads)); b.wait(); // wait for all threads to enter the barrier HPX_TEST_EQ(pxthreads, c.load()); } // initiate shutdown of the runtime system finalize(); return 0; }
int hpx_main( variables_map& vm ) { for (hpx::id_type const& l : hpx::find_all_localities()) { cout << std::string(80, '#') << "\n" << "simple component test: " << l << "\n" << std::string(80, '#') << "\n" << flush; hpx_test_main<simple_object>(vm, l); cout << std::string(80, '#') << "\n" << "managed component test: " << l << "\n" << std::string(80, '#') << "\n" << flush; hpx_test_main<managed_object>(vm, l); } finalize(); return report_errors(); }
int hpx_main( variables_map& vm ) { if (vm.count("no-header")) header = false; { if (0 == tasks) throw std::invalid_argument("count of 0 tasks specified\n"); if (0 == feeders || feeders > get_os_thread_count()) throw std::invalid_argument("number of feeders must be between 1 and OS-thread-count\n"); // Start the clock. thread_aware_timer t; if (0 == vm.count("no-stack")) { for (boost::uint64_t i = 0; i != feeders; ++i) register_work(HPX_STD_BIND(&create_tasks, tasks/feeders)); } else { for (boost::uint64_t i = 0; i != feeders; ++i) register_work(HPX_STD_BIND(&create_stackless_tasks, tasks/feeders)); } // Reschedule hpx_main until all other hpx-threads have finished. We // should be resumed after most of the null HPX-threads have been // executed. If we haven't, we just reschedule ourselves again. do { suspend(); } while (get_thread_count(hpx::threads::thread_priority_normal) > 1); print_results(get_os_thread_count(), t.elapsed()); } return finalize(); }
int hpx_main(variables_map& vm) { typedef basic_any<hpx::util::portable_binary_iarchive, hpx::util::portable_binary_oarchive> any_type; { std::vector<char> buffer; small_object const f(17); HPX_TEST_LTE(sizeof(small_object), sizeof(void*)); any_type any(f); out(buffer, any); any_type any_in; in(buffer, any_in); HPX_TEST(!any_in.empty()); HPX_TEST_EQ(any, any_in); } { std::vector<char> buffer; big_object const f(5, 12); HPX_TEST_LT(sizeof(void*), sizeof(big_object)); any_type any(f); out(buffer, any); any_type any_in; in(buffer, any_in); HPX_TEST(!any_in.empty()); HPX_TEST_EQ(any, any_in); } return finalize(); }
int hpx_main(variables_map& vm) { std::size_t elements = 0; if (vm.count("elements")) elements = vm["elements"].as<std::size_t>(); // get list of all known localities std::vector<id_type> prefixes = hpx::find_remote_localities(); id_type prefix; // execute the qsort() function on any of the remote localities if (!prefixes.empty()) prefix = prefixes[0]; // execute the qsort() function locally else prefix = hpx::find_here(); { // create a (remote) memory block memory_block mb; mb.create<int, uint8_t>(prefix, elements); access_memory_block<int> data(mb.get()); // randomly fill the vector std::generate(data.get_ptr(), data.get_ptr() + elements, std::rand); std::cout << "serial quicksort" << std::endl; high_resolution_timer t; quicksort_serial<int>::call(data.get_ptr(), 0, elements); double elapsed = t.elapsed(); std::cout << " elapsed=" << elapsed << "\n" << " count=" << quicksort_serial<int>::sort_count << "\n"; // int* it = data.get_ptr(); // int* end = data.get_ptr() + elements; // for (; it < end; ++it) // std::cout << *it << "\n"; std::generate(data.get_ptr(), data.get_ptr() + elements, std::rand); std::cout << "parallel quicksort" << std::endl; t.restart(); future<void> n = async<quicksort_parallel<int>::action_type>( prefix, prefix, mb.get_gid(), 0, elements); ::hpx::lcos::wait(n); elapsed = t.elapsed(); std::cout << " elapsed=" << elapsed << "\n" << " count=" << quicksort_parallel<int>::sort_count << "\n"; // it = data.get_ptr(); // end = data.get_ptr() + elements; // for (; it < end; ++it) // std::cout << *it << "\n"; mb.free(); } // initiate shutdown of the runtime systems on all localities finalize(1.0); return 0; }
int hpx_main( variables_map& vm ) { if (vm.count("no-header")) header = false; /////////////////////////////////////////////////////////////////////////// // Initialize the PRNG seed. if (!seed) seed = boost::uint64_t(std::time(0)); { /////////////////////////////////////////////////////////////////////// // Validate command-line arguments. if (0 == tasks) throw std::invalid_argument("count of 0 tasks specified\n"); if (min_delay > max_delay) throw std::invalid_argument("minimum delay cannot be larger than " "maximum delay\n"); if (min_delay > total_delay) throw std::invalid_argument("minimum delay cannot be larger than" "total delay\n"); if (max_delay > total_delay) throw std::invalid_argument("maximum delay cannot be larger than " "total delay\n"); if ((min_delay * tasks) > total_delay) throw std::invalid_argument("minimum delay is too small for the " "specified total delay and number of " "tasks\n"); if ((max_delay * tasks) < total_delay) throw std::invalid_argument("maximum delay is too small for the " "specified total delay and number of " "tasks\n"); /////////////////////////////////////////////////////////////////////// // Randomly generate a description of the heterogeneous workload. std::vector<boost::uint64_t> payloads; payloads.reserve(tasks); // For random numbers, we use a 64-bit specialization of Boost.Random's // mersenne twister engine (good uniform distribution up to 311 // dimensions, cycle length 2 ^ 19937 - 1) boost::random::mt19937_64 prng(seed); boost::uint64_t current_sum = 0; for (boost::uint64_t i = 0; i < tasks; ++i) { // Credit to Spencer Ruport for putting this algorithm on // stackoverflow. boost::uint64_t const low_calc = (total_delay - current_sum) - (max_delay * (tasks - 1 - i)); bool const negative = (total_delay - current_sum) < (max_delay * (tasks - 1 - i)); boost::uint64_t const low = (negative || (low_calc < min_delay)) ? min_delay : low_calc; boost::uint64_t const high_calc = (total_delay - current_sum) - (min_delay * (tasks - 1 - i)); boost::uint64_t const high = (high_calc > max_delay) ? max_delay : high_calc; // Our range is [low, high]. boost::random::uniform_int_distribution<boost::uint64_t> dist(low, high); boost::uint64_t const payload = dist(prng); if (payload < min_delay) throw std::logic_error("task delay is below minimum"); if (payload > max_delay) throw std::logic_error("task delay is above maximum"); current_sum += payload; payloads.push_back(payload); } // Randomly shuffle the entire sequence to deal with drift. boost::function<boost::uint64_t(boost::uint64_t)> shuffler_f = boost::bind(&shuffler, boost::ref(prng), _1); std::random_shuffle(payloads.begin(), payloads.end() , shuffler_f); /////////////////////////////////////////////////////////////////////// // Validate the payloads. if (payloads.size() != tasks) throw std::logic_error("incorrect number of tasks generated"); boost::uint64_t const payloads_sum = std::accumulate(payloads.begin(), payloads.end(), 0ULL); if (payloads_sum != total_delay) throw std::logic_error("incorrect total delay generated"); /////////////////////////////////////////////////////////////////////// // Start the clock. high_resolution_timer t; /////////////////////////////////////////////////////////////////////// // Queue the tasks in a serial loop. for (boost::uint64_t i = 0; i < tasks; ++i) register_work(HPX_STD_BIND(&invoke_worker, payloads[i])); /////////////////////////////////////////////////////////////////////// // Wait for the work to finish. do { // Reschedule hpx_main until all other px-threads have finished. We // should be resumed after most of the null px-threads have been // executed. If we haven't, we just reschedule ourselves again. suspend(); } while (get_thread_count(hpx::threads::thread_priority_normal) > 1); /////////////////////////////////////////////////////////////////////// // Print the results. print_results(get_os_thread_count(), t.elapsed()); } finalize(); return 0; }
int hpx_main(variables_map& vm) { { { if (sizeof(small_object) <= sizeof(void*)) std::cout << "object is small\n"; else std::cout << "object is large\n"; small_object const f(17); function<boost::uint64_t(boost::uint64_t const&)> f0(f); function<boost::uint64_t(boost::uint64_t const&)> f1(f0); function<boost::uint64_t(boost::uint64_t const&)> f2; f2 = f0; f0(7); f1(9); f2(11); } { if (sizeof(big_object) <= sizeof(void*)) std::cout << "object is small\n"; else std::cout << "object is large\n"; big_object const f(5, 12); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&)> f0(f); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&)> f1(f0); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&)> f2; f2 = f0; f0(0, 1); f1(1, 0); f2(1, 1); } } // non serializable version { { if (sizeof(small_object) <= sizeof(void*)) std::cout << "object is small\n"; else std::cout << "object is large\n"; small_object const f(17); function<boost::uint64_t(boost::uint64_t const&), void, void> f0(f); function<boost::uint64_t(boost::uint64_t const&), void, void> f1(f0); function<boost::uint64_t(boost::uint64_t const&), void, void> f2; f2 = f0; f0(2); f1(4); f2(6); } { if (sizeof(big_object) <= sizeof(void*)) std::cout << "object is small\n"; else std::cout << "object is large\n"; big_object const f(5, 12); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&), void, void> f0(f); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&), void, void> f1(f0); function<boost::uint64_t(boost::uint64_t const&, boost::uint64_t const&), void, void> f2; f2 = f0; f0(3, 4); f1(5, 6); f2(7, 8); } } finalize(); return 0; }
int hpx_main( variables_map& vm ) { { if (vm.count("no-header")) header = false; if (vm.count("csv-header")) csv_header = true; if (0 == tasks) throw std::invalid_argument("count of 0 tasks specified\n"); if (suspended_tasks > tasks) throw std::invalid_argument( "suspended tasks must be smaller than tasks\n"); std::uint64_t const os_thread_count = get_os_thread_count(); /////////////////////////////////////////////////////////////////////// stage_worker_function stage_worker; if ("static-balanced-stackbased" == distribution) stage_worker = &stage_worker_static_balanced_stackbased; else if ("static-imbalanced" == distribution) stage_worker = &stage_worker_static_imbalanced; else if ("round-robin" == distribution) stage_worker = &stage_worker_round_robin; else throw std::invalid_argument( "invalid distribution type specified (valid options are " "\"static-balanced\", \"static-imbalanced\" or \"round-robin\")" ); /////////////////////////////////////////////////////////////////////// std::uint64_t tasks_per_feeder = 0; //std::uint64_t total_tasks = 0; std::uint64_t suspended_tasks_per_feeder = 0; std::uint64_t total_suspended_tasks = 0; if ("strong" == scaling) { if (tasks % os_thread_count) throw std::invalid_argument( "tasks must be cleanly divisable by OS-thread count\n"); if (suspended_tasks % os_thread_count) throw std::invalid_argument( "suspended tasks must be cleanly divisable by OS-thread " "count\n"); tasks_per_feeder = tasks / os_thread_count; //total_tasks = tasks; suspended_tasks_per_feeder = suspended_tasks / os_thread_count; total_suspended_tasks = suspended_tasks; } else if ("weak" == scaling) { tasks_per_feeder = tasks; //total_tasks = tasks * os_thread_count; suspended_tasks_per_feeder = suspended_tasks; total_suspended_tasks = suspended_tasks * os_thread_count; } else throw std::invalid_argument( "invalid scaling type specified (valid options are \"strong\" " "or \"weak\")"); /////////////////////////////////////////////////////////////////////// if (suspended_tasks != 0) { std::uint64_t gcd = boost::math::gcd(tasks_per_feeder , suspended_tasks_per_feeder); suspend_step = suspended_tasks_per_feeder / gcd; // We check earlier to make sure that there are never more // suspended tasks than tasks requested. no_suspend_step = (tasks_per_feeder / gcd) - suspend_step; } /////////////////////////////////////////////////////////////////////// std::vector<std::string> counter_shortnames; std::vector<std::string> counters; if (vm.count("counter")) { std::vector<std::string> raw_counters = vm["counter"].as<std::vector<std::string> >(); for (std::uint64_t i = 0; i < raw_counters.size(); ++i) { std::vector<std::string> entry; boost::algorithm::split(entry, raw_counters[i], boost::algorithm::is_any_of(","), boost::algorithm::token_compress_on); HPX_ASSERT(entry.size() == 2); counter_shortnames.push_back(entry[0]); counters.push_back(entry[1]); } } std::shared_ptr<hpx::util::activate_counters> ac; if (!counters.empty()) ac.reset(new hpx::util::activate_counters(counters)); /////////////////////////////////////////////////////////////////////// // Start the clock. high_resolution_timer t; if (ac) ac->reset_counters(); // This needs to stay here; we may have suspended as recently as the // performance counter reset (which is called just before the staging // function). std::uint64_t const num_thread = hpx::get_worker_thread_num(); for (std::uint64_t i = 0; i < os_thread_count; ++i) { if (num_thread == i) continue; register_work(hpx::util::bind(&stage_workers , i , tasks_per_feeder , stage_worker ) , "stage_workers" , hpx::threads::pending , hpx::threads::thread_priority_normal , i ); } stage_workers(num_thread, tasks_per_feeder, stage_worker); double warmup_estimate = t.elapsed(); // Schedule a low-priority thread; when it is executed, it checks to // make sure all the tasks (which are normal priority) have been // executed, and then it hpx::lcos::local::barrier finished(2); register_work(hpx::util::bind(&wait_for_tasks , std::ref(finished) , total_suspended_tasks ) , "wait_for_tasks", hpx::threads::pending , hpx::threads::thread_priority_low); finished.wait(); // Stop the clock double time_elapsed = t.elapsed(); print_results(os_thread_count, time_elapsed, warmup_estimate , counter_shortnames, ac); } if (suspended_tasks != 0) // Force termination of all suspended tasks. hpx::get_runtime().get_thread_manager().abort_all_suspended_threads(); return finalize(); }
int hpx_main(variables_map& vm) { bool do_logging = false; if (vm.count("verbose")) do_logging = true; std::size_t timesteps = 0; if (vm.count("timesteps")) timesteps = vm["timesteps"].as<std::size_t>(); std::size_t grain_size = 3; if (vm.count("grain-size")) grain_size = vm["grain-size"].as<std::size_t>(); std::size_t allowedl = 0; if (vm.count("refinement")) allowedl = vm["refinement"].as<std::size_t>(); std::size_t nx0 = 0; if (vm.count("dimensions")) nx0 = vm["dimensions"].as<std::size_t>(); parameter par; // default pars par->allowedl = allowedl; par->loglevel = 2; par->output = 1.0; par->output_stdout = 1; par->lambda = 0.15; par->nt0 = timesteps; par->minx0 = -15.0; par->maxx0 = 15.0; par->ethreshold = 0.005; par->R0 = 8.0; par->amp = 0.1; par->amp_dot = 0.1; par->delta = 1.0; par->gw = 5; par->eps = 0.0; par->output_level = 0; par->granularity = grain_size; for (std::size_t i = 0; i < HPX_SMP_AMR3D_MAX_LEVELS; i++) par->refine_level[i] = 1.5; id_type rt_id = get_applier().get_runtime_support_gid(); section root; hpx::components::stubs::runtime_support::get_config(rt_id, root); if (root.has_section("smp_amr3d")) { section pars = *(root.get_section("smp_amr3d")); appconfig_option<double>("lambda", pars, par->lambda); appconfig_option<std::size_t>("refinement", pars, par->allowedl); appconfig_option<std::size_t>("loglevel", pars, par->loglevel); appconfig_option<double>("output", pars, par->output); appconfig_option<std::size_t>("output_stdout", pars, par->output_stdout); appconfig_option<std::size_t>("output_level", pars, par->output_level); appconfig_option<std::size_t>("dimensions", pars, nx0); appconfig_option<std::size_t>("timesteps", pars, par->nt0); appconfig_option<double>("maxx0", pars, par->maxx0); appconfig_option<double>("minx0", pars, par->minx0); appconfig_option<double>("ethreshold", pars, par->ethreshold); appconfig_option<double>("R0", pars, par->R0); appconfig_option<double>("delta", pars, par->delta); appconfig_option<double>("amp", pars, par->amp); appconfig_option<double>("amp_dot", pars, par->amp_dot); appconfig_option<std::size_t>("ghostwidth", pars, par->gw); appconfig_option<double>("eps", pars, par->eps); appconfig_option<std::size_t>("grain_size", pars, par->granularity); for (std::size_t i = 0; i < par->allowedl; i++) { std::string ref_level = "refine_level_" + lexical_cast<std::string>(i); appconfig_option<double>(ref_level, pars, par->refine_level[i]); } } // derived parameters if ((nx0 % par->granularity) != 0) { std::string msg = boost::str(boost::format( "dimensions (%1%) must be cleanly divisible by the grain-size " "(%2%)") % nx0 % par->granularity); HPX_THROW_IN_CURRENT_FUNC(bad_parameter, msg); } // the number of timesteps each px thread can take independent of // communication par->time_granularity = par->granularity / 3; // set up refinement centered around the middle of the grid par->nx[0] = nx0 / par->granularity; for (std::size_t i = 1; i < (par->allowedl + 1); ++i) { par->nx[i] = std::size_t(par->refine_level[i - 1] * par->nx[i - 1]); if ((par->nx[i] % 2) == 0) par->nx[i] += 1; if (par->nx[i] > (2 * par->nx[i - 1] - 5)) par->nx[i] = 2 * par->nx[i - 1] - 5; } // for each row, record what the lowest level on the row is std::size_t num_rows = 1 << par->allowedl; // account for prolongation and restriction (which is done every other step) if (par->allowedl > 0) num_rows += (1 << par->allowedl) / 2; num_rows *= 2; // we take two timesteps in the mesh par->num_rows = num_rows; int ii = -1; for (std::size_t i = 0; i < num_rows; ++i) { if (((i + 5) % 3) != 0 || (par->allowedl == 0)) ii++; int level = -1; for (std::size_t j = par->allowedl; j>=0; --j) { if ((ii % (1 << j)) == 0) { level = par->allowedl - j; par->level_row.push_back(level); break; } } } par->dx0 = (par->maxx0 - par->minx0) / (nx0 - 1); par->dt0 = par->lambda * par->dx0; par->min.resize(par->allowedl + 1); par->max.resize(par->allowedl + 1); par->min[0] = par->minx0; par->max[0] = par->maxx0; for (std::size_t i = par->allowedl; i > 0; --i) { par->min[i] = 0.5 * (par->maxx0 - par->minx0) + par->minx0 - (par->nx[i] - 1) / 2 * par->dx0 / (1 << i) * par->granularity; par->max[i] = par->min[i] + ((par->nx[i] - 1) * par->granularity + par->granularity - 1) * par->dx0 / (1 << i); } par->rowsize.resize(par->allowedl + 1); for (int i = 0; i <= par->allowedl; ++i) { par->rowsize[i] = 0; for (int j = par->allowedl; j >= i; --j) par->rowsize[i] += par->nx[j] * par->nx[j] * par->nx[j]; } // get component types needed below component_type function_type = get_component_type<stencil>(); component_type logging_type = get_component_type<logging>(); { id_type here = get_applier().get_runtime_support_gid(); high_resolution_timer t; // we are in spherical symmetry, r=0 is the smallest radial domain point unigrid_mesh um; um.create(here); boost::shared_ptr<std::vector<id_type> > result_data = um.init_execute(function_type, par->rowsize[0], par->nt0, par->loglevel ? logging_type : component_invalid, par); std::cout << "Elapsed time: " << t.elapsed() << " [s]" << std::endl; for (std::size_t i = 0; i < result_data->size(); ++i) hpx::components::stubs::memory_block::free((*result_data)[i]); } // unigrid_mesh needs to go out of scope before shutdown // initiate shutdown of the runtime systems on all localities finalize(); return 0; }