From 8b5539756bffb9a9f059ac178da8c03bdd1fe8e8 Mon Sep 17 00:00:00 2001 From: Christian Mazakas Date: Fri, 24 Mar 2023 14:35:01 -0700 Subject: [PATCH] Partially implement insert_or_assign() --- .../boost/unordered/concurrent_flat_map.hpp | 14 +++ test/cfoa/insert_tests.cpp | 109 ++++++++++++++++-- 2 files changed, 111 insertions(+), 12 deletions(-) diff --git a/include/boost/unordered/concurrent_flat_map.hpp b/include/boost/unordered/concurrent_flat_map.hpp index 34963c84..6f5c9ff3 100644 --- a/include/boost/unordered/concurrent_flat_map.hpp +++ b/include/boost/unordered/concurrent_flat_map.hpp @@ -149,6 +149,20 @@ namespace boost { return table_.visit_all(std::move(f)); } + template bool insert_or_assign(key_type const& k, M&& obj) + { + return table_.try_emplace_or_visit( + k, [&](value_type& m) { m.second = std::forward(obj); }, + std::forward(obj)); + } + + template bool insert_or_assign(key_type&& k, M&& obj) + { + return table_.try_emplace_or_visit( + std::move(k), [&](value_type& m) { m.second = std::forward(obj); }, + std::forward(obj)); + } + /// Hash Policy /// void rehash(size_type n) { table_.rehash(n); } diff --git a/test/cfoa/insert_tests.cpp b/test/cfoa/insert_tests.cpp index 631c8877..96ac926d 100644 --- a/test/cfoa/insert_tests.cpp +++ b/test/cfoa/insert_tests.cpp @@ -32,7 +32,7 @@ struct raii int x_ = -1; raii() { ++default_constructor; } - explicit raii(int const x) : x_{x} { ++default_constructor; } + raii(int const x) : x_{x} { ++default_constructor; } raii(raii const& rhs) : x_{rhs.x_} { ++copy_constructor; } raii(raii&& rhs) noexcept : x_{rhs.x_} { @@ -147,24 +147,22 @@ namespace { template std::vector > split( - std::vector& vec, std::size_t const nt /* num threads*/) + boost::span s, std::size_t const nt /* num threads*/) { std::vector > subslices; subslices.reserve(nt); - boost::span s(vec); - - auto a = vec.size() / nt; + auto a = s.size() / nt; auto b = a; - if (vec.size() % nt != 0) { + if (s.size() % nt != 0) { ++b; } auto num_a = nt; auto num_b = std::size_t{0}; - if (nt * b > vec.size()) { - num_a = nt * b - vec.size(); + if (nt * b > s.size()) { + num_a = nt * b - s.size(); num_b = nt - num_a; } @@ -187,7 +185,7 @@ namespace { template void thread_runner(std::vector& values, F f) { std::vector threads; - auto subslices = split(values, num_threads); + auto subslices = split(values, num_threads); for (std::size_t i = 0; i < num_threads; ++i) { threads.emplace_back([&f, &subslices, i] { @@ -215,6 +213,8 @@ namespace { } }); BOOST_TEST_EQ(num_inserts, x.size()); + BOOST_TEST_EQ(raii::copy_assignment, 0); + BOOST_TEST_EQ(raii::move_assignment, 0); } } lvalue_inserter; @@ -251,6 +251,9 @@ namespace { } else { BOOST_TEST_EQ(raii::copy_constructor, 0); } + + BOOST_TEST_EQ(raii::copy_assignment, 0); + BOOST_TEST_EQ(raii::move_assignment, 0); } } rvalue_inserter; @@ -281,9 +284,79 @@ namespace { { thread_runner( values, [&x](boost::span s) { x.insert(s.begin(), s.end()); }); + + BOOST_TEST_EQ(raii::copy_assignment, 0); + BOOST_TEST_EQ(raii::move_assignment, 0); } } iterator_range_inserter; + struct lvalue_insert_or_assign_copy_assign_type + { + template void operator()(std::vector& values, X& x) + { + thread_runner(values, [&x](boost::span s) { + for (auto& r : s) { + x.insert_or_assign(r.first, r.second); + } + }); + + BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size()); + // don't check move construction count here because of rehashing + BOOST_TEST_GT(raii::move_constructor, 0); + BOOST_TEST_EQ(raii::copy_assignment, values.size() - x.size()); + BOOST_TEST_EQ(raii::move_assignment, 0); + } + } lvalue_insert_or_assign_copy_assign; + + struct lvalue_insert_or_assign_move_assign_type + { + template void operator()(std::vector& values, X& x) + { + thread_runner(values, [&x](boost::span s) { + for (auto& r : s) { + x.insert_or_assign(r.first, std::move(r.second)); + } + }); + + BOOST_TEST_EQ(raii::copy_constructor, x.size()); + BOOST_TEST_GT(raii::move_constructor, x.size()); // rehashing + BOOST_TEST_EQ(raii::copy_assignment, 0); + BOOST_TEST_EQ(raii::move_assignment, values.size() - x.size()); + } + } lvalue_insert_or_assign_move_assign; + + struct rvalue_insert_or_assign_copy_assign_type + { + template void operator()(std::vector& values, X& x) + { + thread_runner(values, [&x](boost::span s) { + for (auto& r : s) { + x.insert_or_assign(std::move(r.first), r.second); + } + }); + + BOOST_TEST_EQ(raii::copy_constructor, x.size()); + BOOST_TEST_GT(raii::move_constructor, x.size()); // rehashing + BOOST_TEST_EQ(raii::copy_assignment, values.size() - x.size()); + BOOST_TEST_EQ(raii::move_assignment, 0); + } + } rvalue_insert_or_assign_copy_assign; + + struct rvalue_insert_or_assign_move_assign_type + { + template void operator()(std::vector& values, X& x) + { + thread_runner(values, [&x](boost::span s) { + for (auto& r : s) { + x.insert_or_assign(std::move(r.first), std::move(r.second)); + } + }); + + BOOST_TEST_EQ(raii::copy_assignment, 0); + BOOST_TEST_EQ(raii::move_assignment, values.size() - x.size()); + } + } rvalue_insert_or_assign_move_assign; + template void insert(X*, G gen, F inserter, test::random_generator rg) { @@ -316,9 +389,6 @@ namespace { BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor + raii::move_constructor, raii::destructor); - - BOOST_TEST_EQ(raii::copy_assignment, 0); - BOOST_TEST_EQ(raii::move_assignment, 0); } template void insert_initializer_list(X*) @@ -403,6 +473,21 @@ UNORDERED_TEST( ((lvalue_inserter)(rvalue_inserter)(iterator_range_inserter) (norehash_lvalue_inserter)(norehash_rvalue_inserter)) ((default_generator)(sequential)(limited_range))) + +UNORDERED_TEST( + insert, + ((map)) + ((value_type_generator)) + ((lvalue_insert_or_assign_copy_assign)(lvalue_insert_or_assign_move_assign)) + ((default_generator)(sequential)(limited_range))) + +UNORDERED_TEST( + insert, + ((map)) + ((init_type_generator)) + ((lvalue_insert_or_assign_copy_assign)(lvalue_insert_or_assign_move_assign) + (rvalue_insert_or_assign_copy_assign)(rvalue_insert_or_assign_move_assign)) + ((default_generator)(sequential)(limited_range))) // clang-format on RUN_TESTS()