From 5ebd347ee0510935f8625b6e7c1234d80869d690 Mon Sep 17 00:00:00 2001 From: Maurizio Drocco Date: Wed, 5 Dec 2018 17:08:25 -0800 Subject: [PATCH 1/4] [pnnl/SHAD#144] RMA-based shad::transform --- .../shad/core/impl/modifyng_sequence_ops.h | 168 ++++++++++++++++-- include/shad/core/impl/utils.h | 11 -- test/unit_tests/core/shad_algorithm_test.cc | 1 + 3 files changed, 150 insertions(+), 30 deletions(-) diff --git a/include/shad/core/impl/modifyng_sequence_ops.h b/include/shad/core/impl/modifyng_sequence_ops.h index c8b562de..629222d8 100755 --- a/include/shad/core/impl/modifyng_sequence_ops.h +++ b/include/shad/core/impl/modifyng_sequence_ops.h @@ -26,6 +26,7 @@ #define INCLUDE_SHAD_CORE_IMPL_MODIFYING_SEQUENCE_OPS_H #include +#include #include #include #include @@ -85,12 +86,147 @@ void fill(distributed_sequential_tag&& policy, ForwardIt first, ForwardIt last, } } +namespace transform_impl { +template +struct gen_args_t { + static constexpr size_t buf_size = + (2 << 10) / sizeof(typename ForwardIt::value_type); + typename ForwardIt::value_type buf[buf_size]; + ForwardIt w_first; + size_t size; +}; + +template +ForwardIt2 block_contiguous_kernel(rt::Locality l, + ForwardIt1 first, ForwardIt1 last, + ForwardIt2 d_first, UnaryOperation op) { + using itr_traits1 = std::iterator_traits; + using itr_traits2 = distributed_iterator_traits; + using args_t = gen_args_t; + auto size = std::distance(first, last); + auto d_last = d_first; + std::advance(d_last, size); + + // local assign + if (rt::thisLocality() == l) { + auto local_d_range = itr_traits2::local_range(d_first, d_last); + auto loc_res = std::transform(first, last, local_d_range.begin(), op); + return itr_traits2::iterator_from_local(d_first, d_last, loc_res - 1) + 1; + } + + // remote assign + std::shared_ptr args_buf(new uint8_t[sizeof(args_t)], + std::default_delete()); + auto typed_args_buf = reinterpret_cast(args_buf.get()); + auto block_last = first; + rt::Handle h; + while (first != last) { + typed_args_buf->w_first = d_first; + typed_args_buf->size = + std::min(args_t::buf_size, (size_t)std::distance(first, last)); + std::advance(block_last, typed_args_buf->size); + std::transform(first, block_last, typed_args_buf->buf, op); + rt::asyncExecuteAt( + h, l, + [](rt::Handle&, const uint8_t* args_buf, const uint32_t) { + const args_t& args = *reinterpret_cast(args_buf); + using val_t = typename ForwardIt2::value_type; + ForwardIt2 w_last = args.w_first; + std::advance(w_last, args.size); + auto w_range = itr_traits2::local_range(args.w_first, w_last); + std::memcpy(w_range.begin(), args.buf, sizeof(val_t) * args.size); + }, + args_buf, sizeof(args_t)); + std::advance(first, typed_args_buf->size); + std::advance(d_first, typed_args_buf->size); + } + rt::waitForCompletion(h); + return d_last; // todo double check +} + +// distributed-sequential kernel for insert-iterators +template +void dseq_kernel(ForwardIt1 first, ForwardIt1 last, + shad::insert_iterator d_first, + shad::insert_iterator* res_ptr, UnaryOperation op) { + using itr_traits1 = distributed_iterator_traits; + auto local_range = itr_traits1::local_range(first, last); + auto begin = local_range.begin(); + auto end = local_range.end(); + *res_ptr = std::transform(begin, end, d_first, op); +} + +// distributed-sequential kernel assuming output-iterator is block-contiguous +template +void dseq_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, + ForwardIt2* res_ptr, UnaryOperation op) { + using itr_traits1 = distributed_iterator_traits; + using itr_traits2 = distributed_random_access_iterator_trait; + auto loc_range = itr_traits1::local_range(first, last); + auto loc_first = loc_range.begin(); + auto d_last = d_first; + std::advance(d_last, std::distance(loc_first, loc_range.end())); + auto dmap = itr_traits2::distribution(d_first, d_last); + auto loc_last = loc_first; + for (auto i : dmap) { + auto l = i.first; + std::advance(loc_last, i.second); + d_last = transform_impl::block_contiguous_kernel(l, loc_first, loc_last, + d_first, op); + std::advance(loc_first, i.second); + std::advance(d_first, i.second); + } + *res_ptr = d_last; +} + +// distributed-parallel kernel for insert-iterators +template +void dpar_kernel(ForwardIt1 first, ForwardIt1 last, + shad::insert_iterator d_first, + shad::insert_iterator* res_ptr, UnaryOperation op) { + using itr_traits1 = distributed_iterator_traits; + auto local_range = itr_traits1::local_range(first, last); + auto begin = local_range.begin(); + auto end = local_range.end(); + auto it = itr_traits1::iterator_from_local(first, last, begin); + *res_ptr = std::transform(begin, end, d_first, op); +} + +// distributed-parallel kernel assuming output-iterator is block-contiguous +template +void dpar_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, + ForwardIt2* res_ptr, UnaryOperation op) { + using itr_traits1 = distributed_iterator_traits; + using itr_traits2 = distributed_random_access_iterator_trait; + auto loc_range = itr_traits1::local_range(first, last); + auto loc_first = loc_range.begin(); + auto first_ = itr_traits1::iterator_from_local(first, last, loc_first); + std::advance(d_first, std::distance(first, first_)); + auto d_last = d_first; + std::advance(d_last, std::distance(loc_first, loc_range.end())); + auto dmap = itr_traits2::distribution(d_first, d_last); + + auto loc_last = loc_first; + for (auto i : dmap) { + auto l = i.first; + std::advance(loc_last, i.second); + d_last = transform_impl::block_contiguous_kernel(l, loc_first, loc_last, + d_first, op); + std::advance(loc_first, i.second); + std::advance(d_first, i.second); + } + *res_ptr = d_last; +} + +} // namespace transform_impl + template ForwardIt2 transform(distributed_parallel_tag&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 d_first, UnaryOperation unary_op) { - using itr_traits = distributed_iterator_traits; - auto localities = itr_traits::localities(first1, last1); + using itr_traits1 = distributed_iterator_traits; + using itr_traits2 = distributed_random_access_iterator_trait; + auto localities = itr_traits1::localities(first1, last1); std::vector res(localities.size(), d_first); auto res_it = res.begin(); rt::Handle h; @@ -102,16 +238,11 @@ ForwardIt2 transform(distributed_parallel_tag&& policy, ForwardIt1 first1, const std::tuple& args, ForwardIt2* res_ptr) { - auto gbegin = std::get<0>(args); - auto gend = std::get<1>(args); - auto local_range = itr_traits::local_range(gbegin, gend); - auto begin = local_range.begin(); - auto end = local_range.end(); - auto it = itr_traits::iterator_from_local(gbegin, gend, begin); - auto d_first_ = std::get<2>(args); - advance_output_iterator(d_first_, gbegin, it); + auto first = std::get<0>(args); + auto last = std::get<1>(args); + auto d_first = std::get<2>(args); auto op = std::get<3>(args); - *res_ptr = std::transform(begin, end, d_first_, op); + transform_impl::dpar_kernel(first, last, d_first, res_ptr, op); }, std::make_tuple(first1, last1, d_first, unary_op), &(*res_it)); } @@ -123,8 +254,9 @@ template ForwardIt2 transform(distributed_sequential_tag&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 d_first, UnaryOperation unary_op) { - using itr_traits = distributed_iterator_traits; - auto localities = itr_traits::localities(first1, last1); + using itr_traits1 = distributed_iterator_traits; + using itr_traits2 = distributed_random_access_iterator_trait; + auto localities = itr_traits1::localities(first1, last1); ForwardIt2 res = d_first; for (auto locality = localities.begin(), end = localities.end(); locality != end; ++locality) { @@ -133,13 +265,11 @@ ForwardIt2 transform(distributed_sequential_tag&& policy, ForwardIt1 first1, [](const std::tuple& args, ForwardIt2* res_ptr) { - auto d_first_ = std::get<2>(args); + auto first = std::get<0>(args); + auto last = std::get<1>(args); + auto d_first = std::get<2>(args); auto op = std::get<3>(args); - auto local_range = - itr_traits::local_range(std::get<0>(args), std::get<1>(args)); - auto begin = local_range.begin(); - auto end = local_range.end(); - *res_ptr = std::transform(begin, end, d_first_, op); + transform_impl::dseq_kernel(first, last, d_first, res_ptr, op); }, std::make_tuple(first1, last1, res, unary_op), &res); } diff --git a/include/shad/core/impl/utils.h b/include/shad/core/impl/utils.h index d039701c..dc8c5770 100755 --- a/include/shad/core/impl/utils.h +++ b/include/shad/core/impl/utils.h @@ -35,17 +35,6 @@ namespace shad { namespace impl { -template -void advance_output_iterator(It &it, It2 first, It2 last) { - std::advance(it, std::distance(first, last)); -} - -template -void advance_output_iterator(shad::insert_iterator, It2, It2) {} - -template -void advance_output_iterator(shad::buffered_insert_iterator, It2, It2) {} - } // namespace impl } // namespace shad diff --git a/test/unit_tests/core/shad_algorithm_test.cc b/test/unit_tests/core/shad_algorithm_test.cc index e93686b3..2d7f0563 100644 --- a/test/unit_tests/core/shad_algorithm_test.cc +++ b/test/unit_tests/core/shad_algorithm_test.cc @@ -1180,6 +1180,7 @@ TYPED_TEST(MTF, shad_find) { // search_n - todo +// transform TYPED_TEST(MTF, shad_transform) { using it_t = typeof(this->in->begin()); using shad_out_it_t = shad::insert_iterator; From c92f9a5fbe727c26877a625b8923de66ea92d152 Mon Sep 17 00:00:00 2001 From: Maurizio Drocco Date: Mon, 10 Dec 2018 16:04:29 -0800 Subject: [PATCH 2/4] [pnnl/SHAD#144] improved compile-time dispatching --- .../shad/core/impl/modifyng_sequence_ops.h | 32 +++++++++++++------ include/shad/core/iterator.h | 11 +++++++ 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/include/shad/core/impl/modifyng_sequence_ops.h b/include/shad/core/impl/modifyng_sequence_ops.h index 629222d8..913edab7 100755 --- a/include/shad/core/impl/modifyng_sequence_ops.h +++ b/include/shad/core/impl/modifyng_sequence_ops.h @@ -144,9 +144,9 @@ ForwardIt2 block_contiguous_kernel(rt::Locality l, return d_last; // todo double check } -// distributed-sequential kernel for insert-iterators +// distributed-sequential kernel for non-block-contiguous output-iterators template -void dseq_kernel(ForwardIt1 first, ForwardIt1 last, +void dseq_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, shad::insert_iterator d_first, shad::insert_iterator* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; @@ -156,9 +156,9 @@ void dseq_kernel(ForwardIt1 first, ForwardIt1 last, *res_ptr = std::transform(begin, end, d_first, op); } -// distributed-sequential kernel assuming output-iterator is block-contiguous +// distributed-sequential kernel for block-contiguous output-iterators template -void dseq_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, +void dseq_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; using itr_traits2 = distributed_random_access_iterator_trait; @@ -179,9 +179,9 @@ void dseq_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, *res_ptr = d_last; } -// distributed-parallel kernel for insert-iterators +// distributed-parallel kernel for non-block-contiguous output-iterators template -void dpar_kernel(ForwardIt1 first, ForwardIt1 last, +void dpar_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, shad::insert_iterator d_first, shad::insert_iterator* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; @@ -192,9 +192,9 @@ void dpar_kernel(ForwardIt1 first, ForwardIt1 last, *res_ptr = std::transform(begin, end, d_first, op); } -// distributed-parallel kernel assuming output-iterator is block-contiguous +// distributed-parallel kernel for block-contiguous output-iterators template -void dpar_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, +void dpar_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; using itr_traits2 = distributed_random_access_iterator_trait; @@ -205,7 +205,6 @@ void dpar_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, auto d_last = d_first; std::advance(d_last, std::distance(loc_first, loc_range.end())); auto dmap = itr_traits2::distribution(d_first, d_last); - auto loc_last = loc_first; for (auto i : dmap) { auto l = i.first; @@ -218,6 +217,21 @@ void dpar_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, *res_ptr = d_last; } +// dispatchers +template +void dseq_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, + ForwardIt2* res_ptr, UnaryOperation op) { + dseq_kernel(is_block_contiguous::value, first, last, d_first, + res_ptr, op); +} + +template +void dpar_kernel(ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, + ForwardIt2* res_ptr, UnaryOperation op) { + dpar_kernel(is_block_contiguous::value, first, last, d_first, + res_ptr, op); +} + } // namespace transform_impl template diff --git a/include/shad/core/iterator.h b/include/shad/core/iterator.h index 844793dd..8a6bcb25 100644 --- a/include/shad/core/iterator.h +++ b/include/shad/core/iterator.h @@ -150,6 +150,17 @@ class buffered_insert_iterator rt::Locality locality_; }; +// compile-time test for block-contiguous property +template +struct is_block_contiguous { + static constexpr std::true_type value{}; +}; + +template +struct is_block_contiguous> { + static constexpr std::false_type value{}; +}; + } // namespace shad #endif /* INCLUDE_SHAD_CORE_ITERATOR_H_ */ From 30fc8951a4088f1ade839c8e2a0ca96baee8e1a0 Mon Sep 17 00:00:00 2001 From: Maurizio Drocco Date: Wed, 30 Jan 2019 16:26:25 -0800 Subject: [PATCH 3/4] [pnnl/SHAD#144] fixes --- .../shad/core/impl/modifyng_sequence_ops.h | 106 +++++++++--------- include/shad/core/iterator.h | 50 +++++---- 2 files changed, 80 insertions(+), 76 deletions(-) diff --git a/include/shad/core/impl/modifyng_sequence_ops.h b/include/shad/core/impl/modifyng_sequence_ops.h index 4be21d95..177713e9 100755 --- a/include/shad/core/impl/modifyng_sequence_ops.h +++ b/include/shad/core/impl/modifyng_sequence_ops.h @@ -73,16 +73,17 @@ void fill(distributed_sequential_tag&& policy, ForwardIt first, ForwardIt last, for (auto locality = localities.begin(), end = localities.end(); locality != end; ++locality) { - rt::executeAt(locality, - [](const std::tuple& args) { - auto begin = std::get<0>(args); - auto end = std::get<1>(args); - auto value = std::get<2>(args); - - auto local_range = itr_traits::local_range(begin, end); - std::fill(local_range.begin(), local_range.end(), value); - }, - std::make_tuple(first, last, value)); + rt::executeAt( + locality, + [](const std::tuple& args) { + auto begin = std::get<0>(args); + auto end = std::get<1>(args); + auto value = std::get<2>(args); + + auto local_range = itr_traits::local_range(begin, end); + std::fill(local_range.begin(), local_range.end(), value); + }, + std::make_tuple(first, last, value)); } } @@ -97,9 +98,9 @@ struct gen_args_t { }; template -ForwardIt2 block_contiguous_kernel(rt::Locality l, - ForwardIt1 first, ForwardIt1 last, - ForwardIt2 d_first, UnaryOperation op) { +ForwardIt2 block_contiguous_kernel(rt::Locality l, ForwardIt1 first, + ForwardIt1 last, ForwardIt2 d_first, + UnaryOperation op) { using itr_traits1 = std::iterator_traits; using itr_traits2 = distributed_iterator_traits; using args_t = gen_args_t; @@ -145,10 +146,9 @@ ForwardIt2 block_contiguous_kernel(rt::Locality l, } // distributed-sequential kernel for non-block-contiguous output-iterators -template +template void dseq_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, - shad::insert_iterator d_first, - shad::insert_iterator* res_ptr, UnaryOperation op) { + ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; auto local_range = itr_traits1::local_range(first, last); auto begin = local_range.begin(); @@ -158,8 +158,8 @@ void dseq_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, // distributed-sequential kernel for block-contiguous output-iterators template -void dseq_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, - ForwardIt2* res_ptr, UnaryOperation op) { +void dseq_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, + ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; using itr_traits2 = distributed_random_access_iterator_trait; auto loc_range = itr_traits1::local_range(first, last); @@ -180,10 +180,9 @@ void dseq_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d } // distributed-parallel kernel for non-block-contiguous output-iterators -template +template void dpar_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, - shad::insert_iterator d_first, - shad::insert_iterator* res_ptr, UnaryOperation op) { + ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; auto local_range = itr_traits1::local_range(first, last); auto begin = local_range.begin(); @@ -194,8 +193,8 @@ void dpar_kernel(std::false_type, ForwardIt1 first, ForwardIt1 last, // distributed-parallel kernel for block-contiguous output-iterators template -void dpar_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, - ForwardIt2* res_ptr, UnaryOperation op) { +void dpar_kernel(std::true_type, ForwardIt1 first, ForwardIt1 last, + ForwardIt2 d_first, ForwardIt2* res_ptr, UnaryOperation op) { using itr_traits1 = distributed_iterator_traits; using itr_traits2 = distributed_random_access_iterator_trait; auto loc_range = itr_traits1::local_range(first, last); @@ -335,24 +334,24 @@ void generate(distributed_sequential_tag&& policy, ForwardIt first, for (auto locality = localities.begin(), end = localities.end(); locality != end; ++locality) { - rt::executeAt(locality, - [](const std::tuple& args) { - auto begin = std::get<0>(args); - auto end = std::get<1>(args); - auto generator = std::get<2>(args); - auto local_range = itr_traits::local_range(begin, end); - auto lbegin = local_range.begin(); - auto lend = local_range.end(); - - // call the generator to align with the offset - auto it = - itr_traits::iterator_from_local(begin, end, lbegin); - for (auto calls = std::distance(begin, it); calls; --calls) - generator(); - - std::generate(lbegin, lend, generator); - }, - std::make_tuple(first, last, generator)); + rt::executeAt( + locality, + [](const std::tuple& args) { + auto begin = std::get<0>(args); + auto end = std::get<1>(args); + auto generator = std::get<2>(args); + auto local_range = itr_traits::local_range(begin, end); + auto lbegin = local_range.begin(); + auto lend = local_range.end(); + + // call the generator to align with the offset + auto it = itr_traits::iterator_from_local(begin, end, lbegin); + for (auto calls = std::distance(begin, it); calls; --calls) + generator(); + + std::generate(lbegin, lend, generator); + }, + std::make_tuple(first, last, generator)); } } @@ -392,18 +391,19 @@ void replace(distributed_sequential_tag&& policy, ForwardIt first, for (auto locality = localities.begin(), end = localities.end(); locality != end; ++locality) { - rt::executeAt(locality, - [](const std::tuple& args) { - auto begin = std::get<0>(args); - auto end = std::get<1>(args); - auto old_value = std::get<2>(args); - auto new_value = std::get<3>(args); - - auto local_range = itr_traits::local_range(begin, end); - std::replace(local_range.begin(), local_range.end(), - old_value, new_value); - }, - std::make_tuple(first, last, old_value, new_value)); + rt::executeAt( + locality, + [](const std::tuple& args) { + auto begin = std::get<0>(args); + auto end = std::get<1>(args); + auto old_value = std::get<2>(args); + auto new_value = std::get<3>(args); + + auto local_range = itr_traits::local_range(begin, end); + std::replace(local_range.begin(), local_range.end(), old_value, + new_value); + }, + std::make_tuple(first, last, old_value, new_value)); } } diff --git a/include/shad/core/iterator.h b/include/shad/core/iterator.h index 275f3447..ef846e41 100644 --- a/include/shad/core/iterator.h +++ b/include/shad/core/iterator.h @@ -44,11 +44,12 @@ namespace shad { template class insert_iterator : public std::iterator { + protected: using Iterator = typename Container::iterator; - using value_type = typename Container::value_type; using internal_container_t = typename Container::internal_container_t; public: + using value_type = typename Container::value_type; using container_type = Container; /// @brief Constructor. @@ -79,7 +80,7 @@ class insert_iterator insert_iterator& operator++() { return *this; } insert_iterator& operator++(int) { return *this; } - private: + protected: typename internal_container_t::ObjectID global_id_; Iterator iterator_; internal_container_t* local_container_ptr_ = nullptr; @@ -97,21 +98,21 @@ class insert_iterator /// /// @tparam Container The type of the distributed container. template -class buffered_insert_iterator - : public std::iterator { - using Iterator = typename Container::iterator; - using value_type = typename Container::value_type; - using internal_container_t = typename Container::internal_container_t; +class buffered_insert_iterator : public insert_iterator { + using base_t = insert_iterator; + using Iterator = typename base_t::Iterator; + using internal_container_t = typename base_t::internal_container_t; public: - using container_type = Container; + using value_type = typename base_t::value_type; + using container_type = typename base_t::container_type; /// @brief Constructor. /// /// @param container The container into which the iterator inserts. /// @param iterator The position at which the iterator starts to insert. buffered_insert_iterator(Container& container, Iterator iterator) - : global_id_(container.global_id()) {} + : base_t(container, iterator) {} /// @brief The assignment operator. /// @@ -122,21 +123,22 @@ class buffered_insert_iterator /// /// @return A self reference. buffered_insert_iterator& operator=(const value_type& value) { - if (!local_container_ptr_ || locality_ != rt::thisLocality()) { - locality_ = rt::thisLocality(); - local_container_ptr_ = Container::from_global_id(global_id_); + if (!this->local_container_ptr_ || this->locality_ != rt::thisLocality()) { + this->locality_ = rt::thisLocality(); + this->local_container_ptr_ = Container::from_global_id(this->global_id_); rt::Handle h; handle_ = h; } - local_container_ptr_->buffered_async_insert(handle_, value); + this->local_container_ptr_->buffered_async_insert(handle_, value); return *this; } /// @brief Flushes pending insertions to the container. void flush() { - if (local_container_ptr_ != nullptr && locality_ == rt::thisLocality()) { + if (this->local_container_ptr_ != nullptr && + this->locality_ == rt::thisLocality()) { // if(!handle_.IsNull()) FIXME - local_container_ptr_->buffered_async_flush(handle_); + this->local_container_ptr_->buffered_async_flush(handle_); } } @@ -145,21 +147,23 @@ class buffered_insert_iterator buffered_insert_iterator& operator++(int) { return *this; } private: - typename internal_container_t::ObjectID global_id_; - internal_container_t* local_container_ptr_ = nullptr; - rt::Locality locality_; rt::Handle handle_; }; // compile-time test for block-contiguous property -template +template struct is_block_contiguous { - static constexpr std::true_type value{}; + static constexpr std::true_type value{}; }; -template -struct is_block_contiguous> { - static constexpr std::false_type value{}; +template +struct is_block_contiguous> { + static constexpr std::false_type value{}; +}; + +template +struct is_block_contiguous> { + static constexpr std::false_type value{}; }; } // namespace shad From 654a771ce6d065c5e513b536f02ca70a7911db01 Mon Sep 17 00:00:00 2001 From: Maurizio Drocco Date: Wed, 6 Feb 2019 16:38:37 -0800 Subject: [PATCH 4/4] [pnnl/SHAD#151] fix --- test/unit_tests/core/shad_algorithm_test.cc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/test/unit_tests/core/shad_algorithm_test.cc b/test/unit_tests/core/shad_algorithm_test.cc index 985d80a5..0b2f9c1b 100644 --- a/test/unit_tests/core/shad_algorithm_test.cc +++ b/test/unit_tests/core/shad_algorithm_test.cc @@ -424,11 +424,12 @@ TYPED_TEST(ATF, shad_generate) { shad::generate, shad_test_stl::generate_, shad_test_stl::ordered_checksum, generator); + auto cgenerator = [n = 42]() { return n; }; this->test_void_with_policy( shad::distributed_parallel_tag{}, - shad::generate, - shad_test_stl::generate_, - shad_test_stl::ordered_checksum, generator); + shad::generate, + shad_test_stl::generate_, + shad_test_stl::ordered_checksum, cgenerator); } // replace