void test_custom_factory()
{
std::vector<char> buffer;
{
std::shared_ptr<B> struct_a(new B(1981, false));
hpx::serialization::output_archive oarchive(buffer);
oarchive << struct_a;
}
{
std::shared_ptr<B> struct_b;
hpx::serialization::input_archive iarchive(buffer);
iarchive >> struct_b;
HPX_TEST_EQ(struct_b->b, 1981);
}
}
int hpx_main()
{
// List of currently available resources
hpx::lcos::channel<locality_id_t> free_resources(hpx::find_here());
std::size_t os_thread_count = hpx::get_os_thread_count();
// At the beginning all threads on all localities are free
for (locality_id_t id : hpx::find_all_localities())
{
for (std::size_t i = 0; i != os_thread_count; ++i)
{
free_resources.set(id);
++count;
}
}
for (int i = 0; i < 1000; ++i)
{
// Ask for resources
hpx::shared_future<locality_id_t> target = free_resources.get();
// Do some work, once we have acquired resources
hpx::shared_future<int> result = target.then(
[](hpx::shared_future<locality_id_t> t)
-> hpx::shared_future<int>
{
--count;
return hpx::make_ready_future(0);
});
// Free resources
result.then(
[free_resources, target](hpx::shared_future<int>) mutable
{
++count;
free_resources.set(target.get());
});
result.get();
}
std::size_t remaining_count = free_resources.close(true);
HPX_TEST_EQ(remaining_count, count.load());
return hpx::finalize();
}
int main()
{
std::vector<char> vector;
{
hpx::serialization::output_archive archive{vector};
boost::shared_ptr<A<int> > b = boost::make_shared<B<int> >(-4);
boost::shared_ptr<A<char> > c = boost::make_shared<B<char> >(44);
boost::shared_ptr<A<double> > d = boost::make_shared<B<double> >(99);
boost::shared_ptr<A<float> > e = boost::make_shared<C<short, float> >(222);
archive << b << c << d << e;
}
{
hpx::serialization::input_archive archive{vector};
boost::shared_ptr<A<int> > b;
boost::shared_ptr<A<char> > c;
boost::shared_ptr<A<double> > d;
boost::shared_ptr<A<float> > e;
archive >> b;
archive >> c;
archive >> d;
archive >> e;
HPX_TEST_EQ(b->a, -5);
HPX_TEST_EQ(boost::static_pointer_cast<B<int> >(b)->b, -4);
HPX_TEST_EQ(c->a, 43);
HPX_TEST_EQ(boost::static_pointer_cast<B<char> >(c)->b, 44);
HPX_TEST_EQ(d->a, 98);
HPX_TEST_EQ(boost::static_pointer_cast<B<double> >(d)->b, 99);
HPX_TEST_EQ(e->a, 221);
HPX_TEST_EQ((boost::static_pointer_cast<C<short, float> >(e)->b), 222);
HPX_TEST_EQ((boost::static_pointer_cast<C<short, float> >(e)->c), 223);
}
}
int hpx_main(int argc, char* argv[])
{
std::size_t num_threads = hpx::resource::get_num_threads("default");
hpx::threads::thread_pool_base& tp =
hpx::resource::get_thread_pool("default");
auto used_pu_mask = tp.get_used_processing_units();
HPX_TEST_EQ(hpx::threads::count(used_pu_mask), num_threads);
for (std::size_t t = 0; t < num_threads; ++t)
{
auto thread_mask = hpx::resource::get_partitioner().get_pu_mask(t);
HPX_TEST(hpx::threads::bit_or(used_pu_mask, thread_mask));
}
return hpx::finalize();
}
void test_count_if_async(ExPolicy p, IteratorTag)
{
typedef std::vector<int>::iterator base_iterator;
typedef std::vector<int>::difference_type diff_type;
typedef test::test_iterator<base_iterator, IteratorTag> iterator;
std::vector<int> c(10007);
std::iota(boost::begin(c), boost::begin(c) + 50, 0);
std::iota(boost::begin(c) + 50, boost::end(c), std::rand() + 50);
hpx::future<diff_type> f =
hpx::parallel::count_if(p,
iterator(boost::begin(c)), iterator(boost::end(c)),
smaller_than_50());
HPX_TEST_EQ(f.get(), 50);
}
bool test_migrate_component_to_storage(hpx::id_type const& source,
hpx::id_type const& target, hpx::components::component_storage storage,
hpx::id_type::management_type t)
{
hpx::id_type oldid;
{
// create component on given locality
test_client t1(source);
HPX_TEST_NEQ(hpx::naming::invalid_id, t1.get_id());
// the new object should live on the source locality
HPX_TEST_EQ(t1.call(), source);
// remember the original id for later resurrection
oldid = hpx::id_type(t1.get_id().get_gid(), t);
try {
// migrate of t1 to the target storage
test_client t2(hpx::components::migrate_to_storage(t1, storage));
HPX_TEST_EQ(hpx::naming::invalid_id, t2.get_id());
}
catch (hpx::exception const&) {
return false;
}
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(1));
// make sure all local references go out of scope if t == unmanaged
}
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(1));
{
test_client t1(hpx::components::migrate_from_storage<test_server>(
oldid, target));
// the id of the newly resurrected object should be the same as the old id
HPX_TEST_EQ(oldid, t1.get_id());
// the new object should now live on the target locality
HPX_TEST_EQ(t1.call(), target);
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(0));
}
return true;
}
void test_uninitialized_copy_exception_async(ExPolicy p, IteratorTag)
{
typedef std::vector<test::count_instances>::iterator base_iterator;
typedef test::decorated_iterator<base_iterator, IteratorTag>
decorated_iterator;
std::vector<test::count_instances> c(10007);
std::vector<test::count_instances> d(c.size());
std::iota(boost::begin(c), boost::end(c), std::rand());
boost::atomic<std::size_t> throw_after(std::rand() % c.size()); //-V104
test::count_instances::instance_count.store(0);
bool caught_exception = false;
bool returned_from_algorithm = false;
try {
hpx::future<base_iterator> f =
hpx::parallel::uninitialized_copy(p,
decorated_iterator(
boost::begin(c),
[&throw_after]()
{
if (throw_after-- == 0)
throw std::runtime_error("test");
}),
decorated_iterator(boost::end(c)),
boost::begin(d));
returned_from_algorithm = true;
f.get();
HPX_TEST(false);
}
catch (hpx::exception_list const& e) {
caught_exception = true;
test::test_num_exceptions<ExPolicy, IteratorTag>::call(p, e);
}
catch (...) {
HPX_TEST(false);
}
HPX_TEST(caught_exception);
HPX_TEST(returned_from_algorithm);
HPX_TEST_EQ(test::count_instances::instance_count.load(), std::size_t(0));
}
void test_make_shared_future()
{
// test make_future<T>(shared_future<T>)
{
hpx::shared_future<int> f1 = hpx::make_ready_future(42);
hpx::shared_future<int> f2 = hpx::make_future<int>(f1);
HPX_TEST_EQ(42, f1.get());
HPX_TEST_EQ(42, f2.get());
}
// test make_future<T>(shared_future<U>) where is_convertible<U, T>
{
hpx::shared_future<int> f1 = hpx::make_ready_future(42);
hpx::shared_future<double> f2 = hpx::make_future<double>(f1);
HPX_TEST_EQ(42, f1.get());
HPX_TEST_EQ(42.0, f2.get());
}
// test make_future<void>(shared_future<U>)
{
hpx::shared_future<int> f1 = hpx::make_ready_future(42);
hpx::shared_future<void> f2 = hpx::make_future<void>(f1);
HPX_TEST_EQ(42, f1.get());
}
// test make_future<void>(shared_future<void>)
{
hpx::shared_future<void> f1 = hpx::make_ready_future();
hpx::shared_future<void> f2 = hpx::make_future<void>(f1);
}
// test make_future<T>(shared_future<U>) with given T conv(U)
{
hpx::shared_future<int> f1 = hpx::make_ready_future(42);
hpx::shared_future<std::string> f2 =
hpx::make_future<std::string>(
f1,
[](int value) -> std::string
{
return std::to_string(value);
});
HPX_TEST_EQ(42, f1.get());
HPX_TEST_EQ(std::string("42"), f2.get());
}
}
// this test must be run with 4 threads
int main(int argc, char* argv[])
{
std::vector<std::string> cfg = {
"hpx.os_threads=" + std::to_string(max_threads)
};
// create the resource partitioner
hpx::resource::partitioner rp(argc, argv, std::move(cfg));
// before adding pools - set the default pool name to "pool-0"
rp.set_default_pool_name("pool-0");
// create N pools
for (int i=0; i<max_threads; i++) {
std::string pool_name = "pool-"+std::to_string(i);
rp.create_thread_pool(pool_name,
hpx::resource::scheduling_policy::local_priority_fifo);
}
// add one PU to each pool
int thread_count = 0;
for (const hpx::resource::numa_domain& d : rp.numa_domains())
{
for (const hpx::resource::core& c : d.cores())
{
for (const hpx::resource::pu& p : c.pus())
{
if (thread_count < max_threads)
{
std::string pool_name = "pool-" + std::to_string(thread_count);
std::cout << "Added pu " << thread_count
<< " to " << pool_name << "\n";
rp.add_resource(p, pool_name);
thread_count++;
}
}
}
}
// now run the test
HPX_TEST_EQ(hpx::init(), 0);
return hpx::util::report_errors();
}
int hpx_main()
{
hpx::id_type here = hpx::find_here();
hpx::id_type there = here;
if (hpx::get_num_localities_sync() > 1)
{
std::vector<hpx::id_type> localities = hpx::find_remote_localities();
there = localities[0];
}
{
increment_action inc;
hpx::apply_colocated(inc, there, here, 1);
}
{
hpx::unique_future<hpx::id_type> inc_f =
hpx::components::new_<increment_server>(there);
hpx::id_type where = inc_f.get();
increment_action inc;
hpx::apply_colocated(inc, where, here, 1);
}
{
hpx::unique_future<hpx::id_type> inc_f =
hpx::components::new_<increment_server>(there);
hpx::id_type where = inc_f.get();
hpx::apply_colocated<increment_action>(where, here, 1);
}
// finalize will synchronize will all pending operations
int result = hpx::finalize();
hpx::util::spinlock::scoped_lock l(result_mutex);
result_cv.wait_for(result_mutex, boost::chrono::seconds(1),
hpx::util::bind(std::equal_to<boost::int32_t>(), boost::ref(final_result), 3));
HPX_TEST_EQ(final_result, 3);
return result;
}
void test_remote_async_cb(hpx::id_type const& target)
{
typedef hpx::components::client<decrement_server> decrement_client;
{
decrement_client dec_f =
hpx::components::new_<decrement_client>(target);
call_action call;
callback_called.store(0);
hpx::future<std::int32_t> f1 = hpx::async_cb(call, dec_f, &cb, 42);
HPX_TEST_EQ(f1.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<std::int32_t> f2 =
hpx::async_cb(hpx::launch::all, call, dec_f, &cb, 42);
HPX_TEST_EQ(f2.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
}
{
decrement_client dec_f =
hpx::components::new_<decrement_client>(target);
hpx::id_type dec = dec_f.get_id();
callback_called.store(0);
hpx::future<std::int32_t> f1 =
hpx::async_cb<call_action>(dec_f, &cb, 42);
HPX_TEST_EQ(f1.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<std::int32_t> f2 =
hpx::async_cb<call_action>(hpx::launch::all, dec_f, &cb, 42);
HPX_TEST_EQ(f2.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
}
}
int main()
{
///////////////////////////////////////////////////////////////////////////
{ // Client to A, instance of C
clientA obj(hpx::components::new_<C>(hpx::find_here()));
HPX_TEST_EQ(obj.test0(), "C");
}
HPX_TEST(a_ctor); HPX_TEST(a_dtor);
HPX_TEST(b_ctor); HPX_TEST(b_dtor);
HPX_TEST(c_ctor); HPX_TEST(c_dtor);
reset_globals();
///////////////////////////////////////////////////////////////////////////
{ // Client to B, instance of C
clientB obj(hpx::components::new_<C>(hpx::find_here()));
HPX_TEST_EQ(obj.test0(), "C");
HPX_TEST_EQ(obj.test1(), "C");
}
HPX_TEST(a_ctor); HPX_TEST(a_dtor);
HPX_TEST(b_ctor); HPX_TEST(b_dtor);
HPX_TEST(c_ctor); HPX_TEST(c_dtor);
reset_globals();
///////////////////////////////////////////////////////////////////////////
{ // Client to C, instance of C
clientC obj(hpx::components::new_<C>(hpx::find_here()));
HPX_TEST_EQ(obj.test0(), "C");
HPX_TEST_EQ(obj.test1(), "C");
HPX_TEST_EQ(obj.test2(), "C");
}
HPX_TEST(a_ctor); HPX_TEST(a_dtor);
HPX_TEST(b_ctor); HPX_TEST(b_dtor);
HPX_TEST(c_ctor); HPX_TEST(c_dtor);
reset_globals();
return 0;
}
void test_leak()
{
{
hpx::shared_future<test> f;
{
hpx::lcos::promise<test> p;
f = p.get_future();
hpx::apply_c<call_action>(p.get_id(), hpx::find_here());
}
test t = f.get();
}
hpx::agas::garbage_collect();
hpx::this_thread::yield();
hpx::agas::garbage_collect();
hpx::this_thread::yield();
HPX_TEST_EQ(test::count, 0);
}
void force_recursion_test2()
{
std::vector<hpx::lcos::local::promise<void> > promises;
promises.reserve(NUM_FUTURES);
std::vector<hpx::shared_future<void> > futures;
futures.reserve(NUM_FUTURES);
for (std::size_t i = 0; i != NUM_FUTURES; ++i)
{
promises.push_back(hpx::lcos::local::promise<void>());
futures.push_back(promises[i].get_future());
}
boost::atomic<std::size_t> executed_continuations(0);
make_ready_continue(0, promises, futures, executed_continuations);
hpx::wait_all(futures);
HPX_TEST_EQ(executed_continuations.load(), NUM_FUTURES);
}
void test_count_if(ExPolicy policy, IteratorTag)
{
static_assert(
hpx::parallel::is_execution_policy<ExPolicy>::value,
"hpx::parallel::is_execution_policy<ExPolicy>::value");
typedef std::vector<int>::iterator base_iterator;
typedef std::vector<int>::difference_type diff_type;
typedef test::test_iterator<base_iterator, IteratorTag> iterator;
std::vector<int> c(100007);
std::iota(boost::begin(c), boost::begin(c) + 50, 0);
std::iota(boost::begin(c) + 50, boost::end(c), std::rand() + 50);
diff_type num_items = hpx::parallel::count_if(policy,
iterator(boost::begin(c)), iterator(boost::end(c)),
smaller_than_50());
HPX_TEST_EQ(num_items, 50u);
}
int hpx_main()
{
std::vector<double> large(64);
auto zip_it_begin = hpx::util::make_zip_iterator(large.begin());
auto zip_it_end = hpx::util::make_zip_iterator(large.end());
hpx::parallel::for_each(
hpx::parallel::execution::datapar, zip_it_begin, zip_it_end,
[](auto& t) -> void
{
hpx::util::get<0>(t) = 10.0;
});
HPX_TEST_EQ(
std::count(large.begin(), large.end(), 10.0),
std::ptrdiff_t(large.size()));
return hpx::finalize(); // Handles HPX shutdown
}
int hpx_main()
{
locality_id = hpx::get_locality_id();
hpx::id_type here = hpx::find_here();
hpx::id_type there = here;
if (hpx::get_num_localities_sync() > 1)
{
std::vector<hpx::id_type> localities = hpx::find_remote_localities();
there = localities[0];
}
{
increment_action inc;
hpx::apply(inc, hpx::colocated(there), here, 1);
}
{
hpx::future<hpx::id_type> inc_f =
hpx::components::new_<increment_server>(there);
hpx::id_type where = inc_f.get();
increment_action inc;
hpx::apply(inc, hpx::colocated(where), here, 1);
}
{
hpx::future<hpx::id_type> inc_f =
hpx::components::new_<increment_server>(there);
hpx::id_type where = inc_f.get();
hpx::apply<increment_action>(hpx::colocated(where), here, 1);
}
// register function which will verify final result
hpx::register_shutdown_function(on_shutdown);
HPX_TEST_EQ(hpx::finalize(), 0);
return 0;
}
// dereference element to the right of current
void test_right_element_full()
{
// demonstrate use of 'previous' and 'next' transformers
std::vector<int> values(10);
std::iota(boost::begin(values), boost::end(values), 0);
auto transformer = test::make_next_transformer(
boost::end(values)-1, &values.front());
std::ostringstream str;
std::for_each(
hpx::util::make_transform_iterator(boost::begin(values), transformer),
hpx::util::make_transform_iterator(boost::end(values), transformer),
[&str](int d)
{
str << d << " ";
});
HPX_TEST_EQ(str.str(), std::string("1 2 3 4 5 6 7 8 9 0 "));
}
void test_uninitialized_copy_exception(ExPolicy policy, IteratorTag)
{
BOOST_STATIC_ASSERT(hpx::parallel::is_execution_policy<ExPolicy>::value);
typedef std::vector<test::count_instances>::iterator base_iterator;
typedef test::decorated_iterator<base_iterator, IteratorTag>
decorated_iterator;
std::vector<test::count_instances> c(10007);
std::vector<test::count_instances> d(c.size());
std::iota(boost::begin(c), boost::end(c), std::rand());
boost::atomic<std::size_t> throw_after(std::rand() % c.size()); //-V104
test::count_instances::instance_count.store(0);
bool caught_exception = false;
try {
hpx::parallel::uninitialized_copy(policy,
decorated_iterator(
boost::begin(c),
[&throw_after]()
{
if (throw_after-- == 0)
throw std::runtime_error("test");
}),
decorated_iterator(boost::end(c)),
boost::begin(d));
HPX_TEST(false);
}
catch (hpx::exception_list const& e) {
caught_exception = true;
test::test_num_exceptions<ExPolicy, IteratorTag>::call(policy, e);
}
catch (...) {
HPX_TEST(false);
}
HPX_TEST(caught_exception);
HPX_TEST_EQ(test::count_instances::instance_count.load(), std::size_t(0));
}
int hpx_main()
{
std::vector<hpx::id_type> const localities =
hpx::find_all_localities(foo::get_component_type());
std::vector<hpx::future<hpx::id_type> > components;
for (int i = 0; i != NUM_INSTANCES; ++i)
{
for (std::size_t j = 0; j != localities.size(); ++j)
{
components.push_back(hpx::new_<foo>(localities[j]));
}
}
hpx::wait_all(components);
for (std::size_t j = 0; j != localities.size(); ++j)
{
HPX_TEST_EQ(NUM_INSTANCES, get_count_action()(localities[j]));
}
return hpx::finalize();
}
int hpx_main(boost::program_options::variables_map& vm)
{
typedef hpx::future<void> wait_for_worker;
std::vector<wait_for_worker> futures;
// get locations and start workers
std::string expected;
std::vector<hpx::id_type> localities = hpx::find_all_localities();
for (hpx::id_type const& l : localities)
{
futures.push_back(hpx::async(worker_action(), l));
expected += "hello!\n";
}
hpx::register_shutdown_function(hpx::util::bind(&on_shutdown, expected));
hpx::wait_all(futures);
HPX_TEST_EQ(hpx::finalize(), 0);
return 0;
}
static void cl_test(hpx::opencl::device cldevice)
{
hpx::opencl::buffer buffer = cldevice.create_buffer(CL_MEM_READ_WRITE,
DATASIZE,
initdata);
// test if buffer initialization worked
size_t buffer_size = buffer.size().get();
HPX_TEST_EQ(buffer_size, DATASIZE);
// read and compare
TEST_CL_BUFFER(buffer, initdata);
// create program
hpx::opencl::program prog = cldevice.create_program_with_source(
square_src);
// build program
prog.build();
// create kernel
hpx::opencl::kernel square_kernel = prog.create_kernel("square");
// set kernel arg
square_kernel.set_arg(0, buffer);
// create work_size
hpx::opencl::work_size<1> dim;
dim[0].offset = 3;
dim[0].size = 5;
// run kernel
square_kernel.enqueue(dim).get().await();
// test if kernel executed successfully
TEST_CL_BUFFER(buffer, refdata1);
}
void test(hpx::id_type dest, char* send_buffer, std::size_t size)
{
typedef Buffer buffer_type;
buffer_type recv_buffer;
std::vector<hpx::future<buffer_type> > recv_buffers;
recv_buffers.reserve(10);
Action act;
for(std::size_t j = 0; j != 10; ++j)
{
recv_buffers.push_back(hpx::async(act, dest,
buffer_type(send_buffer, size, buffer_type::reference)));
}
hpx::wait_all(recv_buffers);
for (hpx::future<buffer_type>& f : recv_buffers)
{
buffer_type b = f.get();
HPX_TEST_EQ(b.size(), size);
HPX_TEST(0 == memcmp(b.data(), send_buffer, size));
}
}
bool test_copy_component_here(hpx::id_type id)
{
// create component on given locality
test_client t1;
t1.create(id);
HPX_TEST_NEQ(hpx::naming::invalid_id, t1.get_gid());
try {
// create a copy of t1 here
test_client t2(hpx::components::copy<test_server>(t1.get_gid(), hpx::find_here()));
HPX_TEST_NEQ(hpx::naming::invalid_id, t2.get_gid());
// the new object should life here
HPX_TEST_EQ(t2.call(), hpx::find_here());
return true;
}
catch (hpx::exception const&) {
HPX_TEST(false);
}
return false;
}
int hpx_main()
{
boost::uint32_t num_localities = hpx::get_num_localities(hpx::launch::sync);
// count_down_and_wait
{
hpx::lcos::latch l = create_latch(num_localities, 0);
HPX_TEST(!l.is_ready());
// Wait for all localities to reach this point.
l.count_down_and_wait();
HPX_TEST(l.is_ready());
}
// count_down/wait
{
hpx::lcos::latch l = create_latch(num_localities, 1);
HPX_TEST(!l.is_ready());
// Wait for all localities to reach this point.
if (hpx::get_locality_id() == 0)
{
l.count_down_and_wait();
HPX_TEST(l.is_ready());
}
else
{
l.count_down(1);
l.wait();
HPX_TEST(l.is_ready());
}
}
HPX_TEST_EQ(hpx::finalize(), 0);
return 0;
}
bool test_migrate_component_from_storage(hpx::id_type const& source,
hpx::components::component_storage storage)
{
hpx::id_type oldid;
{
// create component on given locality
test_client t1(source);
HPX_TEST_NEQ(hpx::naming::invalid_id, t1.get_id());
// the new object should live on the source locality
HPX_TEST_EQ(t1.call(), source);
// remember the original id for later action invocation
oldid = t1.get_id();
try {
// migrate of t1 to the target storage
test_client t2(hpx::components::migrate_to_storage(t1, storage));
HPX_TEST_EQ(hpx::naming::invalid_id, t2.get_id());
}
catch (hpx::exception const&) {
return false;
}
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(1));
}
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(1));
// The object is stored in the storage now, apply an action which should
// transparently bring it back.
{
test_client t1;
t1.reset(oldid);
// transparently resurrect object on the original source locality
HPX_TEST_EQ(t1.call(), source);
HPX_TEST_EQ(storage.size(hpx::launch::sync), std::size_t(0));
}
return true;
}
int main(int argc, char* argv[])
{
HPX_TEST_EQ(hpx::init(argc, argv), 0);
return hpx::util::report_errors();
}
void worker2_ref(tuple_base_type const&t)
{
HPX_TEST_EQ(hpx::util::get<0>(t), 42);
HPX_TEST_EQ(hpx::util::get<1>(t), 3.14);
HPX_TEST_EQ(hpx::util::get<2>(t), "test");
}
void worker1(tuple_type t)
{
HPX_TEST_EQ(hpx::util::get<0>(t), 42);
HPX_TEST_EQ(hpx::util::get<1>(t), 3.14);
HPX_TEST_EQ(hpx::util::get<2>(t), "test");
}
void test_remote_async_cb_colocated(test_client const& target)
{
{
increment_action inc;
callback_called.store(0);
hpx::future<boost::int32_t> f1 =
hpx::async_cb(inc, hpx::colocated(target), &cb, 42);
HPX_TEST_EQ(f1.get(), 43);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<boost::int32_t> f2 =
hpx::async_cb(hpx::launch::all, inc, hpx::colocated(target), &cb, 42);
HPX_TEST_EQ(f2.get(), 43);
HPX_TEST_EQ(callback_called.load(), 1);
}
{
increment_with_future_action inc;
hpx::promise<boost::int32_t> p;
hpx::shared_future<boost::int32_t> f = p.get_future();
callback_called.store(0);
hpx::future<boost::int32_t> f1 =
hpx::async_cb(inc, hpx::colocated(target), &cb, f);
hpx::future<boost::int32_t> f2 =
hpx::async_cb(hpx::launch::all, inc, hpx::colocated(target), &cb, f);
p.set_value(42);
HPX_TEST_EQ(f1.get(), 43);
HPX_TEST_EQ(f2.get(), 43);
HPX_TEST_EQ(callback_called.load(), 2);
}
{
callback_called.store(0);
hpx::future<boost::int32_t> f1 =
hpx::async_cb<increment_action>(hpx::colocated(target), &cb, 42);
HPX_TEST_EQ(f1.get(), 43);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<boost::int32_t> f2 = hpx::async_cb<increment_action>(
hpx::launch::all, hpx::colocated(target), &cb, 42);
HPX_TEST_EQ(f2.get(), 43);
HPX_TEST_EQ(callback_called.load(), 1);
}
{
hpx::future<hpx::id_type> dec_f =
hpx::components::new_<decrement_server>(hpx::colocated(target));
hpx::id_type dec = dec_f.get();
call_action call;
callback_called.store(0);
hpx::future<boost::int32_t> f1 = hpx::async_cb(call, dec, &cb, 42);
HPX_TEST_EQ(f1.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<boost::int32_t> f2 =
hpx::async_cb(hpx::launch::all, call, dec, &cb, 42);
HPX_TEST_EQ(f2.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
}
{
hpx::future<hpx::id_type> dec_f =
hpx::components::new_<decrement_server>(hpx::colocated(target));
hpx::id_type dec = dec_f.get();
callback_called.store(0);
hpx::future<boost::int32_t> f1 =
hpx::async_cb<call_action>(dec, &cb, 42);
HPX_TEST_EQ(f1.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
callback_called.store(0);
hpx::future<boost::int32_t> f2 =
hpx::async_cb<call_action>(hpx::launch::all, dec, &cb, 42);
HPX_TEST_EQ(f2.get(), 41);
HPX_TEST_EQ(callback_called.load(), 1);
}
{
increment_with_future_action inc;
hpx::shared_future<boost::int32_t> f =
hpx::async(hpx::launch::deferred, hpx::util::bind(&increment, 42));
callback_called.store(0);
hpx::future<boost::int32_t> f1 = hpx::async_cb(
inc, hpx::colocated(target), &cb, f);
hpx::future<boost::int32_t> f2 = hpx::async_cb(
hpx::launch::all, inc, hpx::colocated(target), &cb, f);
HPX_TEST_EQ(f1.get(), 44);
HPX_TEST_EQ(f2.get(), 44);
HPX_TEST_EQ(callback_called.load(), 2);
}
}
