Merge pull request #942 from igchor/stable_1.11_radix_fix

Fix radix_tree::try_emplace

Author: lukaszstolarczuk

include/libpmemobj++/experimental/radix_tree.hpp

@@ -411,46 +411,46 @@ struct radix_tree<Key, Value, BytesView>::leaf {
 	const Key &key() const;
 	const Value &value() const;
 
-private:
-	friend class radix_tree<Key, Value, BytesView>;
-
-	leaf() = default;
-
-	template <typename... Args>
-	static persistent_ptr<leaf> make(tagged_node_ptr parent,
-					 Args &&... args);
-
-	static persistent_ptr<leaf> make_internal();
+	static persistent_ptr<leaf> make(tagged_node_ptr parent);
 
 	template <typename... Args1, typename... Args2>
 	static persistent_ptr<leaf>
-	make_internal(std::piecewise_construct_t pc,
-		      std::tuple<Args1...> first_args,
-		      std::tuple<Args2...> second_args);
-
-	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(K &&k, V &&v);
+	make(tagged_node_ptr parent, std::piecewise_construct_t pc,
+	     std::tuple<Args1...> first_args, std::tuple<Args2...> second_args);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const K &k, const V &v);
-
+	static persistent_ptr<leaf> make(tagged_node_ptr parent, K &&k, V &&v);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent, const Key &k,
+					 const Value &v);
+	template <typename K, typename... Args>
+	static persistent_ptr<leaf> make_key_args(tagged_node_ptr parent, K &&k,
+						  Args &&... args);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(detail::pair<K, V> &&p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 detail::pair<K, V> &&p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const detail::pair<K, V> &p);
-
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const detail::pair<K, V> &p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(std::pair<K, V> &&p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 std::pair<K, V> &&p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const std::pair<K, V> &p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const std::pair<K, V> &p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const leaf &other);
+
+private:
+	friend class radix_tree<Key, Value, BytesView>;
+
+	leaf() = default;
 
 	template <typename... Args1, typename... Args2, size_t... I1,
 		  size_t... I2>
-	static persistent_ptr<leaf> make_internal(
-		std::piecewise_construct_t, std::tuple<Args1...> &first_args,
-		std::tuple<Args2...> &second_args,
-		detail::index_sequence<I1...>, detail::index_sequence<I2...>);
-
-	static persistent_ptr<leaf> make_internal(const leaf &other);
+	static persistent_ptr<leaf>
+	make(tagged_node_ptr parent, std::piecewise_construct_t,
+	     std::tuple<Args1...> &first_args,
+	     std::tuple<Args2...> &second_args, detail::index_sequence<I1...>,
+	     detail::index_sequence<I2...>);
 
 	tagged_node_ptr parent = nullptr;
 };
@@ -1294,7 +1294,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(const key_type &k,
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, k, std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, k,
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -1489,8 +1490,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(key_type &&k, Args &&... args)
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, std::move(k),
-				  std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, std::move(k),
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -1536,8 +1537,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(K &&k, Args &&... args) ->
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, std::forward<K>(k),
-				  std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, std::forward<K>(k),
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -2799,8 +2800,8 @@ radix_tree<Key, Value, BytesView>::radix_tree_iterator<IsConst>::assign_val(
 		auto old_leaf = leaf_;
 
 		transaction::run(pop, [&] {
-			*slot = leaf::make(old_leaf->parent, old_leaf->key(),
-					   rhs);
+			*slot = leaf::make_key_args(old_leaf->parent,
+						    old_leaf->key(), rhs);
 			delete_persistent<typename radix_tree::leaf>(old_leaf);
 		});
 
@@ -2973,18 +2974,6 @@ radix_tree<Key, Value, BytesView>::find_leaf(
 	std::abort();
 }
 
-template <typename Key, typename Value, typename BytesView>
-template <typename... Args>
-persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
-					      Args &&... args)
-{
-	auto ptr = make_internal(std::forward<Args>(args)...);
-	ptr->parent = parent;
-
-	return ptr;
-}
-
 template <typename Key, typename Value, typename BytesView>
 Key &
 radix_tree<Key, Value, BytesView>::leaf::key()
@@ -3030,94 +3019,111 @@ radix_tree<Key, Value, BytesView>::leaf::~leaf()
 
 template <typename Key, typename Value, typename BytesView>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal()
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent)
 {
 	auto t = std::make_tuple();
-	return make_internal(std::piecewise_construct, t, t,
-			     typename detail::make_index_sequence<>::type{},
-			     typename detail::make_index_sequence<>::type{});
+	return make(parent, std::piecewise_construct, t, t,
+		    typename detail::make_index_sequence<>::type{},
+		    typename detail::make_index_sequence<>::type{});
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename... Args1, typename... Args2>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	std::piecewise_construct_t pc, std::tuple<Args1...> first_args,
-	std::tuple<Args2...> second_args)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::piecewise_construct_t pc,
+					      std::tuple<Args1...> first_args,
+					      std::tuple<Args2...> second_args)
 {
-	return make_internal(
-		pc, first_args, second_args,
-		typename detail::make_index_sequence<Args1...>::type{},
-		typename detail::make_index_sequence<Args2...>::type{});
+	return make(parent, pc, first_args, second_args,
+		    typename detail::make_index_sequence<Args1...>::type{},
+		    typename detail::make_index_sequence<Args2...>::type{});
 }
 
 template <typename Key, typename Value, typename BytesView>
-template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(K &&k, V &&v)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const Key &k, const Value &v)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::forward<K>(k)),
-			     std::forward_as_tuple(std::forward<V>(v)));
+	return make(parent, std::piecewise_construct, std::forward_as_tuple(k),
+		    std::forward_as_tuple(v));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const K &k, const V &v)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent, K &&k,
+					      V &&v)
+{
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(k)),
+		    std::forward_as_tuple(std::forward<V>(v)));
+}
+
+template <typename Key, typename Value, typename BytesView>
+template <typename K, typename... Args>
+persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
+radix_tree<Key, Value, BytesView>::leaf::make_key_args(tagged_node_ptr parent,
+						       K &&k, Args &&... args)
 {
-	return make_internal(std::piecewise_construct, std::forward_as_tuple(k),
-			     std::forward_as_tuple(v));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(k)),
+		    std::forward_as_tuple(std::forward<Args>(args)...));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(detail::pair<K, V> &&p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      detail::pair<K, V> &&p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::forward<K>(p.first)),
-			     std::forward_as_tuple(std::forward<V>(p.second)));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(p.first)),
+		    std::forward_as_tuple(std::forward<V>(p.second)));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	const detail::pair<K, V> &p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const detail::pair<K, V> &p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(p.first),
-			     std::forward_as_tuple(p.second));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(p.first),
+		    std::forward_as_tuple(p.second));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(std::pair<K, V> &&p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::pair<K, V> &&p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::forward<K>(p.first)),
-			     std::forward_as_tuple(std::forward<V>(p.second)));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(p.first)),
+		    std::forward_as_tuple(std::forward<V>(p.second)));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const std::pair<K, V> &p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const std::pair<K, V> &p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(p.first),
-			     std::forward_as_tuple(p.second));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(p.first),
+		    std::forward_as_tuple(p.second));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename... Args1, typename... Args2, size_t... I1, size_t... I2>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	std::piecewise_construct_t, std::tuple<Args1...> &first_args,
-	std::tuple<Args2...> &second_args, detail::index_sequence<I1...>,
-	detail::index_sequence<I2...>)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::piecewise_construct_t,
+					      std::tuple<Args1...> &first_args,
+					      std::tuple<Args2...> &second_args,
+					      detail::index_sequence<I1...>,
+					      detail::index_sequence<I2...>)
 {
 	standard_alloc_policy<void> a;
 	auto key_size = total_sizeof<Key>::value(std::get<I1>(first_args)...);
@@ -3134,14 +3140,17 @@ radix_tree<Key, Value, BytesView>::leaf::make_internal(
 	new (key_dst) Key(std::forward<Args1>(std::get<I1>(first_args))...);
 	new (val_dst) Value(std::forward<Args2>(std::get<I2>(second_args))...);
 
+	ptr->parent = parent;
+
 	return ptr;
 }
 
 template <typename Key, typename Value, typename BytesView>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const leaf &other)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const leaf &other)
 {
-	return make_internal(other.key(), other.value());
+	return make(parent, other.key(), other.value());
 }
 
 /**

tests/external/libcxx/map/map.modifiers/try.emplace.pass.cpp

@@ -28,6 +28,7 @@
 //  C++17
 
 #include "../is_transparent.h"
+#include "helper_classes.hpp"
 #include "map_wrapper.hpp"
 #include "unittest.hpp"
 
@@ -46,13 +47,16 @@ using container4 =
 	container_t<nvobj::string, Moveable, TRANSPARENT_COMPARE_STRING>;
 using container5 =
 	container_t<MoveableWrapper, MoveableWrapper, TRANSPARENT_COMPARE>;
+using container6 =
+	container_t<int, default_constructible_only, TRANSPARENT_COMPARE>;
 
 struct root {
 	nvobj::persistent_ptr<container> s;
 	nvobj::persistent_ptr<container2> s2;
 	nvobj::persistent_ptr<container3> s3;
 	nvobj::persistent_ptr<container4> s4;
 	nvobj::persistent_ptr<container5> s5;
+	nvobj::persistent_ptr<container6> s6;
 };
 
 int
@@ -318,6 +322,35 @@ run(pmem::obj::pool<root> &pop)
 		pmem::obj::transaction::run(
 			pop, [&] { nvobj::delete_persistent<M>(robj->s5); });
 	}
+	{
+		typedef container6 M;
+		typedef std::pair<M::iterator, bool> R;
+		pmem::obj::transaction::run(
+			pop, [&] { robj->s6 = nvobj::make_persistent<M>(); });
+		auto &m = *robj->s6;
+		R r;
+		for (int i = 0; i < 20; i += 2)
+			m.emplace(std::piecewise_construct,
+				  std::forward_as_tuple(i),
+				  std::forward_as_tuple());
+		UT_ASSERT(m.size() == 10);
+		UT_ASSERT(default_constructible_only::count == 10);
+
+		r = m.try_emplace(2);
+		UT_ASSERT(m.size() == 10);
+		UT_ASSERT(!r.second); // was not inserted
+		UT_ASSERT(default_constructible_only::count == 10);
+		UT_ASSERT(r.first->MAP_KEY == 2); // key
+
+		r = m.try_emplace(3);
+		UT_ASSERT(m.size() == 11);
+		UT_ASSERT(r.second);		  // was inserted
+		UT_ASSERT(r.first->MAP_KEY == 3); // key
+		UT_ASSERT(default_constructible_only::count == 11);
+		pmem::obj::transaction::run(
+			pop, [&] { nvobj::delete_persistent<M>(robj->s6); });
+	}
+
 	return 0;
 }