diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4be5e3b5c8..3a7bb88230 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -99,6 +99,7 @@ option(TEST_SEGMENT_VECTOR_VECTOR_EXPSIZE "enable testing of pmem::obj::segment_
 option(TEST_SEGMENT_VECTOR_VECTOR_FIXEDSIZE "enable testing of pmem::obj::segment_vector with vector as segment_vector_type and fixed_size_policy" ON)
 option(TEST_ENUMERABLE_THREAD_SPECIFIC "enable testing of pmem::obj::enumerable_thread_specific" ON)
 option(TEST_CONCURRENT_MAP "enable testing of pmem::obj::experimental::concurrent_map (depends on TEST_STRING)" ON)
+option(TEST_SWMR_MAP "enable testing of pmem::obj::experimental::swmr_map (depends on TEST_STRING)" ON)
 option(TEST_SELF_RELATIVE_POINTER "enable testing of pmem::obj::experimental::self_relative_ptr" ON)
 option(TEST_RADIX_TREE "enable testing of pmem::obj::experimental::radix_tree" ON)
 option(TEST_MPSC_QUEUE "enable testing of pmem::obj::experimental::mpsc_queue" ON)
diff --git a/benchmarks/self_relative_pointer/assignment.cpp b/benchmarks/self_relative_pointer/assignment.cpp
index a9e752523e..de83990f46 100644
--- a/benchmarks/self_relative_pointer/assignment.cpp
+++ b/benchmarks/self_relative_pointer/assignment.cpp
@@ -37,7 +37,8 @@ using size_type = std::ptrdiff_t;
 template <typename U>
 using persistent_ptr = pmem::obj::persistent_ptr<U>;
 template <typename U>
-using self_relative_ptr = pmem::obj::experimental::self_relative_ptr<U>;
+using self_relative_ptr =
+	pmem::obj::experimental::self_relative_ptr<U, std::false_type>;
 template <typename U>
 using vector = pmem::obj::vector<U>;
 
@@ -81,6 +82,28 @@ benchmark_assignment(pointer<pointer<value_type>[]> &array,
 	}
 }
 
+template <template <typename U, typename PersistentAware> class pointer>
+void
+benchmark_swap(
+	pointer<pointer<value_type, std::false_type>[], std::false_type> &array,
+	pointer<value_type, std::false_type> value)
+{
+	for (size_type i = 0; i < ARR_SIZE; i++) {
+		swap(array[i], value);
+	}
+}
+
+template <template <typename U, typename PersistentAware> class pointer>
+void
+benchmark_assignment(
+	pointer<pointer<value_type, std::false_type>[], std::false_type> &array,
+	pointer<value_type, std::false_type> value)
+{
+	for (size_type i = 0; i < ARR_SIZE; i++) {
+		array[i] = value;
+	}
+}
+
 int
 main(int argc, char *argv[])
 {
diff --git a/benchmarks/self_relative_pointer/get.cpp b/benchmarks/self_relative_pointer/get.cpp
index ee10fa846b..7edcbff9f4 100644
--- a/benchmarks/self_relative_pointer/get.cpp
+++ b/benchmarks/self_relative_pointer/get.cpp
@@ -82,7 +82,8 @@ main(int argc, char *argv[])
 		root->pptr = prepare_array(pop, ARR_SIZE);
 
 		pmem::obj::persistent_ptr<value_type> pptr = root->pptr;
-		pmem::obj::experimental::self_relative_ptr<value_type>
+		pmem::obj::experimental::self_relative_ptr<value_type,
+							   std::false_type>
 			offset_ptr = root->pptr;
 		int *vptr = root->pptr.get();
 
diff --git a/include/libpmemobj++/container/detail/concurrent_skip_list_impl.hpp b/include/libpmemobj++/container/detail/concurrent_skip_list_impl.hpp
index 958a48f40e..b15cbdc38d 100644
--- a/include/libpmemobj++/container/detail/concurrent_skip_list_impl.hpp
+++ b/include/libpmemobj++/container/detail/concurrent_skip_list_impl.hpp
@@ -120,7 +120,8 @@ allocator_swap(MyAlloc &, OtherAlloc &, std::false_type)
 { /* NO SWAP */
 }
 
-template <typename Value, typename Mutex = pmem::obj::mutex,
+template <typename Value, typename UsePersistentAwarePtr,
+	  typename Mutex = pmem::obj::mutex,
 	  typename LockType = std::unique_lock<Mutex>>
 class skip_list_node {
 public:
@@ -131,7 +132,8 @@ class skip_list_node {
 	using pointer = value_type *;
 	using const_pointer = const value_type *;
 	using node_pointer =
-		obj::experimental::self_relative_ptr<skip_list_node>;
+		obj::experimental::self_relative_ptr<skip_list_node,
+						     UsePersistentAwarePtr>;
 	using atomic_node_pointer = std::atomic<node_pointer>;
 	using mutex_type = Mutex;
 	using lock_type = LockType;
@@ -210,6 +212,18 @@ class skip_list_node {
 		return get_next(level).load(std::memory_order_acquire);
 	}
 
+	template <typename U = void,
+		  typename = typename std::enable_if<
+			  std::is_same<UsePersistentAwarePtr,
+				       std::true_type>::value,
+			  U>::type>
+	node_pointer
+	next(size_type level)
+	{
+		assert(level < height());
+		return get_next(level).persist_load(std::memory_order_acquire);
+	}
+
 	/**
 	 * Can`t be called concurrently
 	 * Should be called inside a transaction
@@ -233,6 +247,18 @@ class skip_list_node {
 		pop.persist(&node, sizeof(node));
 	}
 
+	void
+	set_next(size_type level, node_pointer next)
+	{
+		assert(level < height());
+		auto &node = get_next(level);
+		node.store(node_pointer{next.get(), true},
+			   std::memory_order_release);
+		/* instead of persist it immediately, mark it dirty,
+		 * and rely on consequent get_next operation to flush.
+		 */
+	}
+
 	void
 	set_nexts(const node_pointer *new_nexts, size_type h)
 	{
@@ -240,7 +266,8 @@ class skip_list_node {
 		auto *nexts = get_nexts();
 
 		for (size_type i = 0; i < h; i++) {
-			nexts[i].store(new_nexts[i], std::memory_order_relaxed);
+			nexts[i].store(node_pointer{new_nexts[i].get(), true},
+				       std::memory_order_relaxed);
 		}
 	}
 
@@ -497,8 +524,11 @@ class concurrent_skip_list {
 	using const_reference = const value_type &;
 	using pointer = typename allocator_traits_type::pointer;
 	using const_pointer = typename allocator_traits_type::const_pointer;
+	using use_persistent_aware_ptr =
+		typename traits_type::use_persistent_aware_ptr;
 
-	using list_node_type = skip_list_node<value_type>;
+	using list_node_type =
+		skip_list_node<value_type, use_persistent_aware_ptr>;
 
 	using iterator = skip_list_iterator<list_node_type, false>;
 	using const_iterator = skip_list_iterator<list_node_type, true>;
@@ -514,7 +544,8 @@ class concurrent_skip_list {
 	using node_ptr = list_node_type *;
 	using const_node_ptr = const list_node_type *;
 	using persistent_node_ptr =
-		obj::experimental::self_relative_ptr<list_node_type>;
+		obj::experimental::self_relative_ptr<list_node_type,
+						     use_persistent_aware_ptr>;
 
 	using prev_array_type = std::array<node_ptr, MAX_LEVEL>;
 	using next_array_type = std::array<persistent_node_ptr, MAX_LEVEL>;
@@ -2306,6 +2337,33 @@ class concurrent_skip_list {
 			      sizeof(decltype(size_diff)) -
 			      sizeof(decltype(insert_stage))];
 	};
+
+	class swmr_tls_data : public obj::segment_vector<tls_entry_type> {
+	public:
+		using base_type = obj::segment_vector<tls_entry_type>;
+		swmr_tls_data()
+		{
+		}
+		~swmr_tls_data() = default;
+		tls_entry_type &
+		local()
+		{
+			if (this->size() == 0) {
+				this->resize(1);
+			}
+			return this->front();
+		}
+
+	private:
+		obj::pool_base
+		get_pool() const noexcept
+		{
+			auto pop = pmemobj_pool_by_ptr(this);
+			assert(pop != nullptr);
+			return obj::pool_base(pop);
+		}
+	};
+
 	static_assert(sizeof(tls_entry_type) == 64,
 		      "The size of tls_entry_type should be 64 bytes.");
 
@@ -2430,14 +2488,12 @@ class concurrent_skip_list {
 		assert(level < prev->height());
 		persistent_node_ptr next = prev->next(level);
 		pointer_type curr = next.get();
-
 		while (curr && cmp(get_key(curr), key)) {
 			prev = curr;
 			assert(level < prev->height());
 			next = prev->next(level);
 			curr = next.get();
 		}
-
 		return next;
 	}
 
@@ -2645,7 +2701,6 @@ class concurrent_skip_list {
 
 		do {
 			find_insert_pos(prev_nodes, next_nodes, key);
-
 			node_ptr next = next_nodes[0].get();
 			if (next && !allow_multimapping &&
 			    !_compare(key, get_key(next))) {
@@ -2753,9 +2808,11 @@ class concurrent_skip_list {
 		return true;
 	}
 
-	bool
-	try_lock_nodes(size_type height, prev_array_type &prevs,
-		       const next_array_type &nexts, lock_array &locks)
+	template <typename Is_SWMR>
+	typename std::enable_if<std::is_same<Is_SWMR, std::false_type>::value,
+				bool>::type
+	try_lock_nodes_impl(size_type height, prev_array_type &prevs,
+			    const next_array_type &nexts, lock_array &locks)
 	{
 		assert(check_prev_array(prevs, height));
 
@@ -2775,6 +2832,23 @@ class concurrent_skip_list {
 		return true;
 	}
 
+	template <typename Is_SWMR>
+	typename std::enable_if<std::is_same<Is_SWMR, std::true_type>::value,
+				bool>::type
+	try_lock_nodes_impl(size_type height, prev_array_type &prevs,
+			    const next_array_type &nexts, lock_array &locks)
+	{
+		return true;
+	}
+
+	bool
+	try_lock_nodes(size_type height, prev_array_type &prevs,
+		       const next_array_type &nexts, lock_array &locks)
+	{
+		return try_lock_nodes_impl<use_persistent_aware_ptr>(
+			height, prevs, nexts, locks);
+	}
+
 	/**
 	 * Returns an iterator pointing to the first element from the list for
 	 * which cmp(element, key) is false.
@@ -3075,11 +3149,9 @@ class concurrent_skip_list {
 	{
 		assert(pmemobj_tx_stage() == TX_STAGE_WORK);
 		size_type sz = calc_node_size(height);
-
 		persistent_node_ptr n =
 			node_allocator_traits::allocate(_node_allocator, sz)
 				.raw();
-
 		assert(n != nullptr);
 
 		node_allocator_traits::construct(_node_allocator, n.get(),
@@ -3243,7 +3315,12 @@ class concurrent_skip_list {
 	random_level_generator_type _rnd_generator;
 	persistent_node_ptr dummy_head;
 
-	enumerable_thread_specific<tls_entry_type> tls_data;
+	using tls_data_storage = typename std::conditional<
+		std::is_same<use_persistent_aware_ptr, std::true_type>::value,
+		swmr_tls_data,
+		enumerable_thread_specific<tls_entry_type>>::type;
+
+	tls_data_storage tls_data;
 
 	std::atomic<size_type> _size;
 
@@ -3257,7 +3334,7 @@ class concurrent_skip_list {
 
 template <typename Key, typename Value, typename KeyCompare,
 	  typename RND_GENERATOR, typename Allocator, bool AllowMultimapping,
-	  size_t MAX_LEVEL>
+	  size_t MAX_LEVEL, typename UsePersistentAwarePtr = std::false_type>
 class map_traits {
 public:
 	static constexpr size_t max_level = MAX_LEVEL;
@@ -3269,6 +3346,7 @@ class map_traits {
 	using reference = value_type &;
 	using const_reference = const value_type &;
 	using allocator_type = Allocator;
+	using use_persistent_aware_ptr = UsePersistentAwarePtr;
 
 	/**
 	 * pmem::detail::concurrent_skip_list allows multimapping. If this flag
diff --git a/include/libpmemobj++/detail/self_relative_ptr_base_impl.hpp b/include/libpmemobj++/detail/self_relative_ptr_base_impl.hpp
index a6f3e9c751..14645b033c 100644
--- a/include/libpmemobj++/detail/self_relative_ptr_base_impl.hpp
+++ b/include/libpmemobj++/detail/self_relative_ptr_base_impl.hpp
@@ -44,7 +44,8 @@ class self_relative_ptr_base_impl {
 	using byte_type = uint8_t;
 	using byte_ptr_type = byte_type *;
 	using const_byte_ptr_type = const byte_type *;
-
+	static constexpr difference_type dirty_flag = ~(1L << 1);
+	static constexpr difference_type dirty_mask = dirty_flag & (1 << 1 | 1);
 	/*
 	 * Constructors
 	 */
@@ -190,6 +191,30 @@ class self_relative_ptr_base_impl {
 	{
 		return offset == nullptr_offset;
 	}
+	/**
+	 * check if offset is dirty
+	 */
+	static inline bool
+	is_dirty(difference_type other_offset)
+	{
+		return ((other_offset != nullptr_offset) &&
+			(other_offset & dirty_mask) ==
+				(dirty_flag & dirty_mask));
+	}
+	bool
+	is_dirty()
+	{
+		return (!is_null() &&
+			(difference_type(offset) & dirty_mask) ==
+				(dirty_flag & dirty_mask));
+	}
+	void
+	set_dirty_flag(bool dirty)
+	{
+		intptr_t dirty_mask = dirty == true;
+		--dirty_mask;
+		offset &= (dirty_mask | dirty_flag);
+	}
 
 protected:
 	/**
@@ -222,8 +247,12 @@ class self_relative_ptr_base_impl {
 		*/
 		uintptr_t mask = other_offset == nullptr_offset;
 		--mask;
+		intptr_t mask_dirty = is_dirty(other_offset) == true;
+		--mask_dirty;
+		/* clear the dirty_flag if it's set to get the correct ptr. */
 		uintptr_t ptr = static_cast<uintptr_t>(
-			reinterpret_cast<intptr_t>(this) + other_offset + 1);
+			reinterpret_cast<intptr_t>(this) +
+			(other_offset | ~(dirty_flag | mask_dirty)) + 1);
 		ptr &= mask;
 		return reinterpret_cast<void *>(ptr);
 	}
diff --git a/include/libpmemobj++/detail/tagged_ptr.hpp b/include/libpmemobj++/detail/tagged_ptr.hpp
index b4c27f3d1e..c0861fddf6 100644
--- a/include/libpmemobj++/detail/tagged_ptr.hpp
+++ b/include/libpmemobj++/detail/tagged_ptr.hpp
@@ -169,12 +169,13 @@ struct tagged_ptr_impl {
 	PointerType ptr;
 
 	friend struct std::atomic<tagged_ptr_impl<
-		P1, P2, obj::experimental::self_relative_ptr<void>>>;
+		P1, P2,
+		obj::experimental::self_relative_ptr<void, std::false_type>>>;
 };
 
 template <typename P1, typename P2>
-using tagged_ptr =
-	tagged_ptr_impl<P1, P2, obj::experimental::self_relative_ptr<void>>;
+using tagged_ptr = tagged_ptr_impl<
+	P1, P2, obj::experimental::self_relative_ptr<void, std::false_type>>;
 
 } /* namespace detail */
 } /* namespace pmem */
@@ -187,7 +188,8 @@ struct atomic<pmem::detail::tagged_ptr<P1, P2>> {
 private:
 	using ptr_type = pmem::detail::tagged_ptr_impl<
 		P1, P2,
-		atomic<pmem::obj::experimental::self_relative_ptr<void>>>;
+		atomic<pmem::obj::experimental::self_relative_ptr<
+			void, std::false_type>>>;
 	using value_type = pmem::detail::tagged_ptr<P1, P2>;
 
 public:
diff --git a/include/libpmemobj++/experimental/atomic_self_relative_ptr.hpp b/include/libpmemobj++/experimental/atomic_self_relative_ptr.hpp
index 57412cf6bd..f6bf357760 100644
--- a/include/libpmemobj++/experimental/atomic_self_relative_ptr.hpp
+++ b/include/libpmemobj++/experimental/atomic_self_relative_ptr.hpp
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: BSD-3-Clause
-/* Copyright 2020-2021, Intel Corporation */
+/* Copyright 2021, 4Paradigm Inc. */
 
 /**
  * @file
@@ -24,8 +24,12 @@ namespace std
  * Doesn't automatically add itself to the transaction.
  * The user is responsible for persisting the data.
  */
+
+template <typename T, typename PersistentAware>
+struct atomic<pmem::obj::experimental::self_relative_ptr<T, PersistentAware>>;
+
 template <typename T>
-struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
+struct atomic<pmem::obj::experimental::self_relative_ptr<T, false_type>> {
 private:
 	using ptr_type = pmem::detail::self_relative_ptr_base_impl<
 		std::atomic<std::ptrdiff_t>>;
@@ -34,7 +38,8 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 
 public:
 	using this_type = atomic;
-	using value_type = pmem::obj::experimental::self_relative_ptr<T>;
+	using value_type =
+		pmem::obj::experimental::self_relative_ptr<T, false_type>;
 	using difference_type = typename value_type::difference_type;
 
 	/*
@@ -87,7 +92,6 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 			accessor::pointer_to_offset(ptr, expected.get());
 		auto desired_offset =
 			accessor::pointer_to_offset(ptr, desired.get());
-
 		bool result = accessor::get_offset(ptr).compare_exchange_weak(
 			expected_offset, desired_offset, success, failure);
 		if (!result) {
@@ -110,7 +114,6 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 			accessor::pointer_to_offset(ptr, expected.get());
 		auto desired_offset =
 			accessor::pointer_to_offset(ptr, desired.get());
-
 		bool result = accessor::get_offset(ptr).compare_exchange_weak(
 			expected_offset, desired_offset, order);
 		if (!result) {
@@ -133,7 +136,6 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 			accessor::pointer_to_offset(ptr, expected.get());
 		auto desired_offset =
 			accessor::pointer_to_offset(ptr, desired.get());
-
 		bool result = accessor::get_offset(ptr).compare_exchange_strong(
 			expected_offset, desired_offset, success, failure);
 		if (!result) {
@@ -156,7 +158,6 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 			accessor::pointer_to_offset(ptr, expected.get());
 		auto desired_offset =
 			accessor::pointer_to_offset(ptr, desired.get());
-
 		bool result = accessor::get_offset(ptr).compare_exchange_strong(
 			expected_offset, desired_offset, order);
 		if (!result) {
@@ -273,6 +274,351 @@ struct atomic<pmem::obj::experimental::self_relative_ptr<T>> {
 		}
 	}
 
+	pmem::obj::pool_base
+	get_pool_base() const
+	{
+		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
+		return pmem::obj::pool_base(pop);
+	}
+
+private:
+	ptr_type ptr;
+};
+
+template <typename T>
+struct atomic<pmem::obj::experimental::self_relative_ptr<T, true_type>> {
+private:
+	using ptr_type = pmem::detail::self_relative_ptr_base_impl<
+		std::atomic<std::ptrdiff_t>>;
+	using accessor = pmem::detail::self_relative_accessor<
+		std::atomic<std::ptrdiff_t>>;
+
+public:
+	using this_type = atomic;
+	using value_type =
+		pmem::obj::experimental::self_relative_ptr<T, true_type>;
+	using difference_type = typename value_type::difference_type;
+
+	/*
+	 * Constructors
+	 */
+
+	constexpr atomic() noexcept = default;
+	atomic(value_type value) : ptr()
+	{
+		store(value);
+	}
+	atomic(const atomic &) = delete;
+
+	void
+	store(value_type desired,
+	      std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto offset = accessor::pointer_to_offset(ptr, desired.get());
+		LIBPMEMOBJ_CPP_ANNOTATE_HAPPENS_BEFORE(order, &ptr);
+		intptr_t dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		offset &= (dirty_mask | ptr_type::dirty_flag);
+		accessor::get_offset(ptr).store(offset, order);
+	}
+
+	value_type
+	load(std::memory_order order = std::memory_order_seq_cst) const noexcept
+	{
+		auto offset = accessor::get_offset(ptr).load(order);
+		LIBPMEMOBJ_CPP_ANNOTATE_HAPPENS_AFTER(order, &ptr);
+		if (ptr_type::is_dirty(offset)) {
+			auto &target = accessor::get_offset(ptr);
+			get_pool_base().persist(&target, sizeof(target));
+		}
+		auto pointer = accessor::offset_to_pointer<T>(offset, ptr);
+		return value_type{pointer, ptr_type::is_dirty(offset)};
+	}
+
+	value_type
+	persist_load(
+		std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto offset = accessor::get_offset(ptr).load(order);
+		LIBPMEMOBJ_CPP_ANNOTATE_HAPPENS_AFTER(order, &ptr);
+		intptr_t dirty_mask;
+		if ((dirty_mask = (ptr_type::is_dirty(offset) == true)) > 0) {
+			auto &target = accessor::get_offset(ptr);
+			get_pool_base().persist(&target, sizeof(target));
+		}
+		auto desired = offset;
+		while (true) {
+			--dirty_mask;
+			desired = offset | ~(ptr_type::dirty_flag | dirty_mask);
+			if (accessor::get_offset(ptr).compare_exchange_weak(
+				    offset, desired) ||
+			    !ptr_type::is_dirty(offset)) {
+				break;
+			}
+			auto &target = accessor::get_offset(ptr);
+			get_pool_base().persist(&target, sizeof(target));
+			dirty_mask = ptr_type::is_dirty(offset) == true;
+		}
+		auto pointer = accessor::offset_to_pointer<T>(offset, ptr);
+		return value_type{pointer, ptr_type::is_dirty(offset)};
+	}
+	value_type
+	exchange(value_type desired,
+		 std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto new_offset =
+			accessor::pointer_to_offset(ptr, desired.get());
+		intptr_t dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		new_offset &= (dirty_mask | ptr_type::dirty_flag);
+		auto old_offset =
+			accessor::get_offset(ptr).exchange(new_offset, order);
+		return value_type{
+			accessor::offset_to_pointer<T>(old_offset, ptr),
+			ptr_type::is_dirty(old_offset)};
+	}
+
+	bool
+	compare_exchange_weak(value_type &expected, value_type desired,
+			      std::memory_order success,
+			      std::memory_order failure) noexcept
+	{
+		auto expected_offset =
+			accessor::pointer_to_offset(ptr, expected.get());
+		auto desired_offset =
+			accessor::pointer_to_offset(ptr, desired.get());
+		intptr_t dirty_mask = expected.is_dirty();
+		--dirty_mask;
+		expected_offset &= (dirty_mask | ptr_type::dirty_flag);
+		dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		desired_offset &= (dirty_mask | ptr_type::dirty_flag);
+		bool result = accessor::get_offset(ptr).compare_exchange_weak(
+			expected_offset, desired_offset, success, failure);
+		if (!result) {
+			try {
+				expected = accessor::offset_to_pointer<T>(
+					expected_offset, ptr);
+				expected.set_dirty_flag(
+					ptr_type::is_dirty(expected_offset));
+			} catch (...) {
+				std::terminate();
+			}
+		}
+		return result;
+	}
+
+	bool
+	compare_exchange_weak(
+		value_type &expected, value_type desired,
+		std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto expected_offset =
+			accessor::pointer_to_offset(ptr, expected.get());
+		auto desired_offset =
+			accessor::pointer_to_offset(ptr, desired.get());
+		intptr_t dirty_mask = expected.is_dirty();
+		--dirty_mask;
+		expected_offset &= (dirty_mask | ptr_type::dirty_flag);
+		dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		desired_offset &= (dirty_mask | ptr_type::dirty_flag);
+		bool result = accessor::get_offset(ptr).compare_exchange_weak(
+			expected_offset, desired_offset, order);
+		if (!result) {
+			try {
+				expected = accessor::offset_to_pointer<T>(
+					expected_offset, ptr);
+				expected.set_dirty_flag(
+					ptr_type::is_dirty(expected_offset));
+			} catch (...) {
+				std::terminate();
+			}
+		}
+		return result;
+	}
+
+	bool
+	compare_exchange_strong(value_type &expected, value_type desired,
+				std::memory_order success,
+				std::memory_order failure) noexcept
+	{
+		auto expected_offset =
+			accessor::pointer_to_offset(ptr, expected.get());
+		auto desired_offset =
+			accessor::pointer_to_offset(ptr, desired.get());
+		intptr_t dirty_mask = expected.is_dirty();
+		--dirty_mask;
+		expected_offset &= (dirty_mask | ptr_type::dirty_flag);
+		dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		desired_offset &= (dirty_mask | ptr_type::dirty_flag);
+		bool result = accessor::get_offset(ptr).compare_exchange_strong(
+			expected_offset, desired_offset, success, failure);
+		if (!result) {
+			try {
+				expected = accessor::offset_to_pointer<T>(
+					expected_offset, ptr);
+				expected.set_dirty_flag(
+					ptr_type::is_dirty(expected_offset));
+			} catch (...) {
+				std::terminate();
+			}
+		}
+		return result;
+	}
+
+	bool
+	compare_exchange_strong(
+		value_type &expected, value_type desired,
+		std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto expected_offset =
+			accessor::pointer_to_offset(ptr, expected.get());
+		auto desired_offset =
+			accessor::pointer_to_offset(ptr, desired.get());
+		intptr_t dirty_mask = expected.is_dirty();
+		--dirty_mask;
+		expected_offset &= (dirty_mask | ptr_type::dirty_flag);
+		dirty_mask = desired.is_dirty();
+		--dirty_mask;
+		desired_offset &= (dirty_mask | ptr_type::dirty_flag);
+		bool result = accessor::get_offset(ptr).compare_exchange_strong(
+			expected_offset, desired_offset, order);
+		if (!result) {
+			try {
+				expected = accessor::offset_to_pointer<T>(
+					expected_offset, ptr);
+				expected.set_dirty_flag(
+					ptr_type::is_dirty(expected_offset));
+			} catch (...) {
+				std::terminate();
+			}
+		}
+		return result;
+	}
+
+	value_type
+	fetch_add(difference_type val,
+		  std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto offset = accessor::get_offset(ptr).fetch_add(
+			val * static_cast<difference_type>(sizeof(T)), order);
+		return value_type{accessor::offset_to_pointer<T>(offset, ptr),
+				  true};
+	}
+
+	value_type
+	fetch_sub(difference_type val,
+		  std::memory_order order = std::memory_order_seq_cst) noexcept
+	{
+		auto offset = accessor::get_offset(ptr).fetch_sub(
+			val * static_cast<difference_type>(sizeof(T)), order);
+		return value_type{accessor::offset_to_pointer<T>(offset, ptr),
+				  true};
+	}
+
+	bool
+	is_lock_free() const noexcept
+	{
+		return accessor::get_offset(ptr).is_lock_free();
+	}
+
+	/*
+	 * Operators
+	 */
+
+	operator value_type() const noexcept
+	{
+		return load();
+	}
+
+	atomic &operator=(const atomic &) = delete;
+	atomic &operator=(const atomic &) volatile = delete;
+
+	value_type
+	operator=(value_type desired) noexcept
+	{
+		store(desired);
+		return desired;
+	}
+
+	value_type
+	operator&=(difference_type flag) noexcept
+	{
+		auto old_offset = accessor::get_offset(ptr).load();
+		auto new_offset = (old_offset & flag);
+		accessor::get_offset(ptr).exchange(new_offset);
+		return load();
+	}
+
+	value_type
+	operator++() noexcept
+	{
+		try {
+			return this->fetch_add(1) + 1;
+		} catch (...) {
+			/* This should never happen during normal program
+			 * execution */
+			std::terminate();
+		}
+	}
+
+	value_type
+	operator++(int) noexcept
+	{
+		return this->fetch_add(1);
+	}
+
+	value_type
+	operator--() noexcept
+	{
+		try {
+			return this->fetch_sub(1) - 1;
+		} catch (...) {
+			/* This should never happen during normal program
+			 * execution */
+			std::terminate();
+		}
+	}
+
+	value_type
+	operator--(int) noexcept
+	{
+		return this->fetch_sub(1);
+	}
+
+	value_type
+	operator+=(difference_type diff) noexcept
+	{
+		try {
+			return this->fetch_add(diff) + diff;
+		} catch (...) {
+			/* This should never happen during normal program
+			 * execution */
+			std::terminate();
+		}
+	}
+
+	value_type
+	operator-=(difference_type diff) noexcept
+	{
+		try {
+			return this->fetch_sub(diff) - diff;
+		} catch (...) {
+			/* This should never happen during normal program
+			 * execution */
+			std::terminate();
+		}
+	}
+
+	pmem::obj::pool_base
+	get_pool_base() const
+	{
+		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
+		return pmem::obj::pool_base(pop);
+	}
+
 private:
 	ptr_type ptr;
 };
@@ -291,9 +637,11 @@ namespace detail
  *
  * Use in a single-threaded environment only.
  */
-template <typename T>
-struct can_do_snapshot<std::atomic<obj::experimental::self_relative_ptr<T>>> {
-	using snapshot_type = obj::experimental::self_relative_ptr<T>;
+template <typename T, typename PersistentAware>
+struct can_do_snapshot<
+	std::atomic<obj::experimental::self_relative_ptr<T, PersistentAware>>> {
+	using snapshot_type =
+		obj::experimental::self_relative_ptr<T, PersistentAware>;
 	static constexpr bool value = sizeof(std::atomic<snapshot_type>) ==
 		sizeof(typename snapshot_type::offset_type);
 	static_assert(value,
diff --git a/include/libpmemobj++/experimental/concurrent_map.hpp b/include/libpmemobj++/experimental/concurrent_map.hpp
index ed8542994a..1f480007da 100644
--- a/include/libpmemobj++/experimental/concurrent_map.hpp
+++ b/include/libpmemobj++/experimental/concurrent_map.hpp
@@ -57,10 +57,11 @@ template <typename Key, typename Value, typename Comp = std::less<Key>,
 class concurrent_map
     : public detail::concurrent_skip_list<detail::map_traits<
 	      Key, Value, Comp, detail::default_random_generator, Allocator,
-	      false, 64>> {
-	using traits_type = detail::map_traits<Key, Value, Comp,
-					       detail::default_random_generator,
-					       Allocator, false, 64>;
+	      false, 64, std::false_type>> {
+	using traits_type =
+		detail::map_traits<Key, Value, Comp,
+				   detail::default_random_generator, Allocator,
+				   false, 64, std::false_type>;
 	using base_type = pmem::detail::concurrent_skip_list<traits_type>;
 
 public:
diff --git a/include/libpmemobj++/experimental/self_relative_ptr.hpp b/include/libpmemobj++/experimental/self_relative_ptr.hpp
index 8fde7867f7..134553da20 100644
--- a/include/libpmemobj++/experimental/self_relative_ptr.hpp
+++ b/include/libpmemobj++/experimental/self_relative_ptr.hpp
@@ -21,11 +21,11 @@ namespace obj
 namespace experimental
 {
 
-template <typename T>
+template <typename T, typename PersistentAware>
 class self_relative_ptr;
 
-template <>
-class self_relative_ptr<void> : public self_relative_ptr_base {
+template <typename PersistentAware>
+class self_relative_ptr<void, PersistentAware> : public self_relative_ptr_base {
 public:
 	using base_type = self_relative_ptr_base;
 	using this_type = self_relative_ptr;
@@ -37,12 +37,21 @@ class self_relative_ptr<void> : public self_relative_ptr_base {
 	    : self_relative_ptr_base()
 	{
 	}
+	constexpr self_relative_ptr(std::nullptr_t, bool dirty) noexcept
+	    : self_relative_ptr_base()
+	{
+	}
 
 	self_relative_ptr(element_type *ptr) noexcept
 	    : self_relative_ptr_base(self_offset(ptr))
 	{
 	}
 
+	self_relative_ptr(element_type *ptr, bool dirty) noexcept
+	    : self_relative_ptr_base(self_offset(ptr, dirty))
+	{
+	}
+
 	inline element_type *
 	get() const noexcept
 	{
@@ -56,6 +65,14 @@ class self_relative_ptr<void> : public self_relative_ptr_base {
 	{
 		return base_type::pointer_to_offset(static_cast<void *>(ptr));
 	}
+	difference_type
+	self_offset(element_type *ptr, bool dirty) const noexcept
+	{
+		intptr_t dirty_mask = dirty == true;
+		--dirty_mask;
+		return (base_type::pointer_to_offset(static_cast<void *>(ptr)) &
+			(dirty_mask | dirty_flag));
+	}
 };
 
 /**
@@ -78,7 +95,7 @@ class self_relative_ptr<void> : public self_relative_ptr_base {
  * @includedoc shared/self_relative_pointer_implementation.txt
  * @ingroup primitives
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 class self_relative_ptr : public self_relative_ptr_base {
 public:
 	using base_type = self_relative_ptr_base;
@@ -126,6 +143,11 @@ class self_relative_ptr : public self_relative_ptr_base {
 	{
 	}
 
+	constexpr self_relative_ptr(std::nullptr_t, bool dirty) noexcept
+	    : self_relative_ptr_base()
+	{
+	}
+
 	/**
 	 * Volatile pointer constructor.
 	 *
@@ -136,6 +158,11 @@ class self_relative_ptr : public self_relative_ptr_base {
 	{
 	}
 
+	self_relative_ptr(element_type *ptr, bool dirty) noexcept
+	    : self_relative_ptr_base(self_offset(ptr, dirty))
+	{
+	}
+
 	/**
 	 * Constructor from persistent_ptr<T>
 	 */
@@ -144,6 +171,11 @@ class self_relative_ptr : public self_relative_ptr_base {
 	{
 	}
 
+	self_relative_ptr(persistent_ptr<T> ptr, bool dirty) noexcept
+	    : self_relative_ptr_base(self_offset(ptr.get(), dirty))
+	{
+	}
+
 	/**
 	 * PMEMoid constructor.
 	 *
@@ -157,6 +189,12 @@ class self_relative_ptr : public self_relative_ptr_base {
 	{
 	}
 
+	self_relative_ptr(PMEMoid oid, bool dirty) noexcept
+	    : self_relative_ptr_base(self_offset(
+		      static_cast<element_type *>(pmemobj_direct(oid)), dirty))
+	{
+	}
+
 	/**
 	 * Copy constructor
 	 */
@@ -178,7 +216,8 @@ class self_relative_ptr : public self_relative_ptr_base {
 				typename std::remove_cv<U>::type>::value &&
 				!std::is_void<U>::value,
 			decltype(static_cast<T *>(std::declval<U *>()))>::type>
-	self_relative_ptr(self_relative_ptr<U> const &r) noexcept
+	self_relative_ptr(
+		self_relative_ptr<U, PersistentAware> const &r) noexcept
 	    : self_relative_ptr_base(self_offset(static_cast<T *>(r.get())))
 	{
 	}
@@ -295,8 +334,8 @@ class self_relative_ptr : public self_relative_ptr_base {
 	template <typename Y,
 		  typename = typename std::enable_if<
 			  std::is_convertible<Y *, T *>::value>::type>
-	self_relative_ptr<T> &
-	operator=(self_relative_ptr<Y> const &r)
+	self_relative_ptr<T, PersistentAware> &
+	operator=(self_relative_ptr<Y, PersistentAware> const &r)
 	{
 		this_type(r).swap(*this);
 		return *this;
@@ -318,7 +357,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Prefix increment operator.
 	 */
-	inline self_relative_ptr<T> &
+	inline self_relative_ptr<T, PersistentAware> &
 	operator++()
 	{
 		detail::conditional_add_to_tx(this);
@@ -330,7 +369,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Postfix increment operator.
 	 */
-	inline self_relative_ptr<T>
+	inline self_relative_ptr<T, PersistentAware>
 	operator++(int)
 	{
 		auto copy = *this;
@@ -342,7 +381,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Prefix decrement operator.
 	 */
-	inline self_relative_ptr<T> &
+	inline self_relative_ptr<T, PersistentAware> &
 	operator--()
 	{
 		detail::conditional_add_to_tx(this);
@@ -354,7 +393,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Postfix decrement operator.
 	 */
-	inline self_relative_ptr<T>
+	inline self_relative_ptr<T, PersistentAware>
 	operator--(int)
 	{
 		auto copy = *this;
@@ -366,7 +405,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Addition assignment operator.
 	 */
-	inline self_relative_ptr<T> &
+	inline self_relative_ptr<T, PersistentAware> &
 	operator+=(std::ptrdiff_t s)
 	{
 		detail::conditional_add_to_tx(this);
@@ -377,7 +416,7 @@ class self_relative_ptr : public self_relative_ptr_base {
 	/**
 	 * Subtraction assignment operator.
 	 */
-	inline self_relative_ptr<T> &
+	inline self_relative_ptr<T, PersistentAware> &
 	operator-=(std::ptrdiff_t s)
 	{
 		detail::conditional_add_to_tx(this);
@@ -402,6 +441,14 @@ class self_relative_ptr : public self_relative_ptr_base {
 	{
 		return base_type::pointer_to_offset(static_cast<void *>(ptr));
 	}
+	difference_type
+	self_offset(element_type *ptr, bool dirty) const noexcept
+	{
+		intptr_t dirty_mask = dirty == true;
+		--dirty_mask;
+		return (base_type::pointer_to_offset(static_cast<void *>(ptr)) &
+			(dirty_mask | dirty_flag));
+	}
 };
 
 /**
@@ -412,9 +459,10 @@ class self_relative_ptr : public self_relative_ptr_base {
  *
  * @relates self_relative_ptr
  */
-template <class T>
+template <class T, typename PersistentAware>
 inline void
-swap(self_relative_ptr<T> &a, self_relative_ptr<T> &b)
+swap(self_relative_ptr<T, PersistentAware> &a,
+     self_relative_ptr<T, PersistentAware> &b)
 {
 	a.swap(b);
 }
@@ -423,10 +471,10 @@ swap(self_relative_ptr<T> &a, self_relative_ptr<T> &b)
  * Equality operator.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator==(self_relative_ptr<T> const &lhs,
-	   self_relative_ptr<Y> const &rhs) noexcept
+operator==(self_relative_ptr<T, PersistentAware> const &lhs,
+	   self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return lhs.to_byte_pointer() == rhs.to_byte_pointer();
 }
@@ -435,10 +483,10 @@ operator==(self_relative_ptr<T> const &lhs,
  * Inequality operator.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator!=(self_relative_ptr<T> const &lhs,
-	   self_relative_ptr<Y> const &rhs) noexcept
+operator!=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return !(lhs == rhs);
 }
@@ -447,9 +495,10 @@ operator!=(self_relative_ptr<T> const &lhs,
  * Equality operator with nullptr.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator==(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator==(self_relative_ptr<T, PersistentAware> const &lhs,
+	   std::nullptr_t) noexcept
 {
 	return !bool(lhs);
 }
@@ -458,9 +507,10 @@ operator==(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
  * Equality operator with nullptr.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator==(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
+operator==(std::nullptr_t,
+	   self_relative_ptr<T, PersistentAware> const &lhs) noexcept
 {
 	return !bool(lhs);
 }
@@ -469,9 +519,10 @@ operator==(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
  * Inequality operator with nullptr.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator!=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator!=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   std::nullptr_t) noexcept
 {
 	return bool(lhs);
 }
@@ -480,9 +531,10 @@ operator!=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
  * Inequality operator with nullptr.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator!=(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
+operator!=(std::nullptr_t,
+	   self_relative_ptr<T, PersistentAware> const &lhs) noexcept
 {
 	return bool(lhs);
 }
@@ -494,10 +546,10 @@ operator!=(std::nullptr_t, self_relative_ptr<T> const &lhs) noexcept
  * offset) of rhs. Returns false otherwise.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator<(self_relative_ptr<T> const &lhs,
-	  self_relative_ptr<Y> const &rhs) noexcept
+operator<(self_relative_ptr<T, PersistentAware> const &lhs,
+	  self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return lhs.to_byte_pointer() < rhs.to_byte_pointer();
 }
@@ -508,10 +560,10 @@ operator<(self_relative_ptr<T> const &lhs,
  * See less than operator for comparison rules.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator<=(self_relative_ptr<T> const &lhs,
-	   self_relative_ptr<Y> const &rhs) noexcept
+operator<=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return !(rhs < lhs);
 }
@@ -522,10 +574,10 @@ operator<=(self_relative_ptr<T> const &lhs,
  * See less than operator for comparison rules.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator>(self_relative_ptr<T> const &lhs,
-	  self_relative_ptr<Y> const &rhs) noexcept
+operator>(self_relative_ptr<T, PersistentAware> const &lhs,
+	  self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return (rhs < lhs);
 }
@@ -536,10 +588,10 @@ operator>(self_relative_ptr<T> const &lhs,
  * See less than operator for comparison rules.
  * @relates self_relative_ptr
  */
-template <typename T, typename Y>
+template <typename T, typename Y, typename PersistentAware>
 inline bool
-operator>=(self_relative_ptr<T> const &lhs,
-	   self_relative_ptr<Y> const &rhs) noexcept
+operator>=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   self_relative_ptr<Y, PersistentAware> const &rhs) noexcept
 {
 	return !(lhs < rhs);
 }
@@ -550,33 +602,36 @@ operator>=(self_relative_ptr<T> const &lhs,
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator<(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator<(self_relative_ptr<T, PersistentAware> const &lhs,
+	  std::nullptr_t) noexcept
 {
-	return std::less<typename self_relative_ptr<T>::element_type *>()(
-		lhs.get(), nullptr);
+	return std::less<typename self_relative_ptr<
+		T, PersistentAware>::element_type *>()(lhs.get(), nullptr);
 }
 
 /**
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator<(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
+operator<(std::nullptr_t,
+	  self_relative_ptr<T, PersistentAware> const &rhs) noexcept
 {
-	return std::less<typename self_relative_ptr<T>::element_type *>()(
-		nullptr, rhs.get());
+	return std::less<typename self_relative_ptr<
+		T, PersistentAware>::element_type *>()(nullptr, rhs.get());
 }
 
 /**
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator<=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator<=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   std::nullptr_t) noexcept
 {
 	return !(nullptr < lhs);
 }
@@ -585,9 +640,10 @@ operator<=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator<=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
+operator<=(std::nullptr_t,
+	   self_relative_ptr<T, PersistentAware> const &rhs) noexcept
 {
 	return !(rhs < nullptr);
 }
@@ -596,9 +652,10 @@ operator<=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator>(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator>(self_relative_ptr<T, PersistentAware> const &lhs,
+	  std::nullptr_t) noexcept
 {
 	return nullptr < lhs;
 }
@@ -607,9 +664,10 @@ operator>(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator>(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
+operator>(std::nullptr_t,
+	  self_relative_ptr<T, PersistentAware> const &rhs) noexcept
 {
 	return rhs < nullptr;
 }
@@ -618,9 +676,10 @@ operator>(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator>=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
+operator>=(self_relative_ptr<T, PersistentAware> const &lhs,
+	   std::nullptr_t) noexcept
 {
 	return !(lhs < nullptr);
 }
@@ -629,9 +688,10 @@ operator>=(self_relative_ptr<T> const &lhs, std::nullptr_t) noexcept
  * Compare a self_relative_ptr with a null pointer.
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 inline bool
-operator>=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
+operator>=(std::nullptr_t,
+	   self_relative_ptr<T, PersistentAware> const &rhs) noexcept
 {
 	return !(nullptr < rhs);
 }
@@ -640,11 +700,11 @@ operator>=(std::nullptr_t, self_relative_ptr<T> const &rhs) noexcept
  * Addition operator for self-relative pointers.
  * @relates self_relative_ptr
  */
-template <typename T>
-inline self_relative_ptr<T>
-operator+(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
+template <typename T, typename PersistentAware>
+inline self_relative_ptr<T, PersistentAware>
+operator+(self_relative_ptr<T, PersistentAware> const &lhs, std::ptrdiff_t s)
 {
-	self_relative_ptr<T> ptr = lhs;
+	self_relative_ptr<T, PersistentAware> ptr = lhs;
 	ptr += s;
 	return ptr;
 }
@@ -653,11 +713,11 @@ operator+(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
  * Subtraction operator for self-relative pointers.
  * @relates self_relative_ptr
  */
-template <typename T>
-inline self_relative_ptr<T>
-operator-(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
+template <typename T, typename PersistentAware>
+inline self_relative_ptr<T, PersistentAware>
+operator-(self_relative_ptr<T, PersistentAware> const &lhs, std::ptrdiff_t s)
 {
-	self_relative_ptr<T> ptr = lhs;
+	self_relative_ptr<T, PersistentAware> ptr = lhs;
 	ptr -= s;
 	return ptr;
 }
@@ -673,9 +733,11 @@ operator-(self_relative_ptr<T> const &lhs, std::ptrdiff_t s)
 template <typename T, typename Y,
 	  typename = typename std::enable_if<
 		  std::is_same<typename std::remove_cv<T>::type,
-			       typename std::remove_cv<Y>::type>::value>>
+			       typename std::remove_cv<Y>::type>::value>,
+	  typename PersistentAware>
 inline ptrdiff_t
-operator-(self_relative_ptr<T> const &lhs, self_relative_ptr<Y> const &rhs)
+operator-(self_relative_ptr<T, PersistentAware> const &lhs,
+	  self_relative_ptr<Y, PersistentAware> const &rhs)
 {
 	return self_relative_ptr_base::distance_between(rhs, lhs) /
 		static_cast<ptrdiff_t>(sizeof(T));
@@ -685,9 +747,9 @@ operator-(self_relative_ptr<T> const &lhs, self_relative_ptr<Y> const &rhs)
  * Ostream operator
  * @relates self_relative_ptr
  */
-template <typename T>
+template <typename T, typename PersistentAware>
 std::ostream &
-operator<<(std::ostream &os, self_relative_ptr<T> const &ptr)
+operator<<(std::ostream &os, self_relative_ptr<T, PersistentAware> const &ptr)
 {
 	os << ptr.to_void_pointer();
 	return os;
diff --git a/include/libpmemobj++/experimental/swmr_map.hpp b/include/libpmemobj++/experimental/swmr_map.hpp
new file mode 100644
index 0000000000..d3bf0c5bdc
--- /dev/null
+++ b/include/libpmemobj++/experimental/swmr_map.hpp
@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+#ifndef PMEMOBJ_SWMR_MAP_HPP
+#define PMEMOBJ_SWMR_MAP_HPP
+
+#include <libpmemobj++/allocator.hpp>
+#include <libpmemobj++/container/detail/concurrent_skip_list_impl.hpp>
+#include <libpmemobj++/detail/pair.hpp>
+
+namespace pmem
+{
+namespace obj
+{
+namespace experimental
+{
+/**
+ *
+ */
+template <typename Key, typename Value, typename Comp = std::less<Key>,
+	  typename Allocator =
+		  pmem::obj::allocator<detail::pair<const Key, Value>>>
+class swmr_map : public detail::concurrent_skip_list<detail::map_traits<
+			 Key, Value, Comp, detail::default_random_generator,
+			 Allocator, false, 64, std::true_type>> {
+	using traits_type =
+		detail::map_traits<Key, Value, Comp,
+				   detail::default_random_generator, Allocator,
+				   false, 64, std::true_type>;
+	using base_type = pmem::detail::concurrent_skip_list<traits_type>;
+
+public:
+	using key_type = typename base_type::key_type;
+	using mapped_type = typename base_type::mapped_type;
+	using value_type = typename base_type::value_type;
+	using size_type = typename base_type::size_type;
+	using difference_type = typename base_type::difference_type;
+	using key_compare = Comp;
+	using allocator_type = Allocator;
+	using reference = typename base_type::reference;
+	using const_reference = typename base_type::const_reference;
+	using pointer = typename base_type::pointer;
+	using const_pointer = typename base_type::const_pointer;
+	using iterator = typename base_type::iterator;
+	using const_iterator = typename base_type::const_iterator;
+
+	/**
+	 * Default constructor.
+	 */
+	swmr_map() = default;
+
+	/**
+	 * Copy constructor.
+	 */
+	swmr_map(const swmr_map &table) : base_type(table)
+	{
+	}
+
+	/**
+	 * Move constructor.
+	 */
+	swmr_map(swmr_map &&table) : base_type(std::move(table))
+	{
+	}
+
+	/**
+	 * Construct the empty map
+	 */
+	explicit swmr_map(const key_compare &comp,
+			  const allocator_type &alloc = allocator_type())
+	    : base_type(comp, alloc)
+	{
+	}
+
+	/**
+	 * Constructs the map with the contents of the range [first, last).
+	 */
+	template <class InputIt>
+	swmr_map(InputIt first, InputIt last, const key_compare &comp = Comp(),
+		 const allocator_type &alloc = allocator_type())
+	    : base_type(first, last, comp, alloc)
+	{
+	}
+
+	/**
+	 * Constructs the map with initializer list
+	 */
+	swmr_map(std::initializer_list<value_type> ilist)
+	    : base_type(ilist.begin(), ilist.end())
+	{
+	}
+
+	/**
+	 * Assignment operator
+	 */
+	swmr_map &
+	operator=(const swmr_map &other)
+	{
+		return static_cast<swmr_map &>(base_type::operator=(other));
+	}
+
+	/**
+	 * Move-assignment operator
+	 */
+	swmr_map &
+	operator=(swmr_map &&other)
+	{
+		return static_cast<swmr_map &>(
+			base_type::operator=(std::move(other)));
+	}
+
+	/**
+	 *
+	 */
+	swmr_map &
+	operator=(std::initializer_list<value_type> ilist)
+	{
+		return static_cast<swmr_map &>(base_type::operator=(ilist));
+	}
+};
+
+/** Non-member swap */
+template <typename Key, typename Value, typename Comp, typename Allocator>
+void
+swap(swmr_map<Key, Value, Comp, Allocator> &lhs,
+     swmr_map<Key, Value, Comp, Allocator> &rhs)
+{
+	lhs.swap(rhs);
+}
+
+} /* namespace experimental */
+} /* namespace obj */
+} /* namespace pmem */
+#endif /* PMEMOBJ_SWMR_MAP_HPP */
diff --git a/tests/ptr/pa_self_relative_ptr.cpp b/tests/ptr/pa_self_relative_ptr.cpp
new file mode 100644
index 0000000000..eb917de410
--- /dev/null
+++ b/tests/ptr/pa_self_relative_ptr.cpp
@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * obj_cpp_ptr.c -- cpp bindings test
+ *
+ */
+
+#include "ptr.hpp"
+#include "unittest.hpp"
+
+#include <libpmemobj++/experimental/self_relative_ptr.hpp>
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/make_persistent_array_atomic.hpp>
+#include <libpmemobj++/make_persistent_atomic.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/pool.hpp>
+#include <libpmemobj++/transaction.hpp>
+
+#include <sstream>
+
+#define LAYOUT "cpp"
+
+template <typename T>
+using pa_self_relative_ptr =
+	nvobj::experimental::self_relative_ptr<T, std::true_type>;
+using self_relative_ptr_base = nvobj::experimental::self_relative_ptr_base;
+
+namespace
+{
+
+using root = templated_root<pa_self_relative_ptr, self_relative_ptr_base>;
+
+/*
+ * test_offset -- test offset calculation within a hierarchy
+ */
+void
+test_offset(nvobj::pool<root> &pop)
+{
+	struct A {
+		uint64_t a;
+	};
+
+	struct B {
+		uint64_t b;
+	};
+
+	struct C : public A, public B {
+		uint64_t c;
+	};
+
+	try {
+		nvobj::transaction::run(pop, [] {
+			auto distance =
+				self_relative_ptr_base::distance_between;
+
+			pa_self_relative_ptr<C> cptr =
+				nvobj::make_persistent<C>();
+			pa_self_relative_ptr<B> bptr = cptr;
+			UT_ASSERT(distance(cptr, bptr) > 0);
+			UT_ASSERT(static_cast<std::size_t>(
+					  distance(cptr, bptr)) == sizeof(A));
+
+			pa_self_relative_ptr<B> bptr2;
+			bptr2 = cptr;
+			UT_ASSERT(distance(cptr, bptr2) > 0);
+			UT_ASSERT(static_cast<std::size_t>(
+					  distance(cptr, bptr2)) == sizeof(A));
+
+			pa_self_relative_ptr<B> bptr3 =
+				static_cast<pa_self_relative_ptr<B>>(cptr);
+			UT_ASSERT(distance(cptr, bptr3) > 0);
+			UT_ASSERT(static_cast<std::size_t>(
+					  distance(cptr, bptr3)) == sizeof(A));
+
+			nvobj::delete_persistent<C>(cptr);
+		});
+	} catch (...) {
+		UT_ASSERT(0);
+	}
+}
+
+void
+test_base_ptr_casting(nvobj::pool<root> &pop)
+{
+	auto r = pop.root();
+
+	try {
+		nvobj::transaction::run(pop, [&] {
+			r->arr[0] = pa_self_relative_ptr<foo>{
+				nvobj::make_persistent<foo>()};
+			r->arr[1] = pa_self_relative_ptr<int>{
+				nvobj::make_persistent<int>(TEST_INT)};
+			r->arr[2] = nullptr;
+
+			UT_ASSERTne(r->arr[0].to_void_pointer(), nullptr);
+			UT_ASSERTeq(*static_cast<int *>(
+					    r->arr[1].to_void_pointer()),
+				    TEST_INT);
+			UT_ASSERTeq(r->arr[2].to_void_pointer(), nullptr);
+
+			pa_self_relative_ptr<foo> tmp0 =
+				static_cast<foo *>(r->arr[0].to_void_pointer());
+			pa_self_relative_ptr<int> tmp1 =
+				static_cast<int *>(r->arr[1].to_void_pointer());
+			pa_self_relative_ptr<foo> tmp2 =
+				static_cast<foo *>(r->arr[2].to_void_pointer());
+			nvobj::delete_persistent<foo>(tmp0);
+			nvobj::delete_persistent<int>(tmp1);
+			nvobj::delete_persistent<foo>(tmp2);
+		});
+	} catch (...) {
+		UT_ASSERT(0);
+	}
+}
+
+void
+test_base_ptr_assignment()
+{
+	int tmp;
+
+	self_relative_ptr_base ptr1 = &tmp;
+	self_relative_ptr_base ptr2 = nullptr;
+
+	ptr1 = ptr2;
+
+	UT_ASSERT(ptr1.to_void_pointer() == nullptr);
+	UT_ASSERT(ptr2.to_void_pointer() == nullptr);
+}
+
+} /* namespace */
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc != 2)
+		UT_FATAL("usage: %s file-name", argv[0]);
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(path, LAYOUT, PMEMOBJ_MIN_POOL,
+						S_IWUSR | S_IRUSR);
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	test_root_pointers<pa_self_relative_ptr, self_relative_ptr_base>(
+		*pop.root());
+	test_ptr_operators_null<pa_self_relative_ptr>();
+	test_ptr_transactional(pop);
+	test_ptr_array(pop);
+	test_offset(pop);
+	test_base_ptr_casting(pop);
+	test_base_ptr_assignment();
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/ptr/pa_self_relative_ptr_arith.cpp b/tests/ptr/pa_self_relative_ptr_arith.cpp
new file mode 100644
index 0000000000..69a6ac9f76
--- /dev/null
+++ b/tests/ptr/pa_self_relative_ptr_arith.cpp
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+#include "ptr_arith.hpp"
+
+#include <libpmemobj++/experimental/self_relative_ptr.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+
+template <typename T>
+using pa_self_relative_ptr =
+	nvobj::experimental::self_relative_ptr<T, std::true_type>;
+
+#define LAYOUT "cpp"
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc != 2)
+		UT_FATAL("usage: %s file-name", argv[0]);
+
+	const char *path = argv[1];
+
+	nvobj::pool_base pop;
+
+	try {
+		pop = nvobj::pool_base::create(path, LAYOUT, PMEMOBJ_MIN_POOL,
+					       S_IWUSR | S_IRUSR);
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	test_arith<pa_self_relative_ptr>(pop);
+	test_relational<pa_self_relative_ptr>(pop);
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/ptr/pa_self_relative_ptr_atomic.hpp b/tests/ptr/pa_self_relative_ptr_atomic.hpp
new file mode 100644
index 0000000000..7c80ebbc55
--- /dev/null
+++ b/tests/ptr/pa_self_relative_ptr_atomic.hpp
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+#include "thread_helpers.hpp"
+#include "unittest.hpp"
+
+#include <libpmemobj++/experimental/atomic_self_relative_ptr.hpp>
+#include <libpmemobj++/experimental/self_relative_ptr.hpp>
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+constexpr size_t CONCURRENCY = 20;
+constexpr size_t MEAN_CONCURRENCY = CONCURRENCY * 2;
+constexpr size_t HIGH_CONCURRENCY = CONCURRENCY * 5;
+
+template <typename T>
+using pa_self_relative_ptr =
+	pmem::obj::experimental::self_relative_ptr<T, std::true_type>;
+using self_relative_ptr_base = pmem::obj::experimental::self_relative_ptr_base;
+
+template <typename T, bool need_volatile>
+using atomic_type = typename std::conditional<
+	need_volatile,
+	typename std::add_volatile<std::atomic<pa_self_relative_ptr<T>>>::type,
+	std::atomic<pa_self_relative_ptr<T>>>::type;
+
+template <bool volatile_atomic>
+void
+test_fetch()
+{
+	constexpr size_t count_iterations = 300;
+	constexpr size_t arr_size = CONCURRENCY * count_iterations;
+	std::vector<int> vptr(arr_size, 0);
+
+	atomic_type<int, volatile_atomic> ptr{vptr.data()};
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = ptr.fetch_add(1);
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() + arr_size == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 1);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = ptr.fetch_sub(1) - 1;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 2);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = ptr++;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() + arr_size == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 3);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = --ptr;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 4);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = ++ptr - 1;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() + arr_size == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 5);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = ptr-- - 1;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 6);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = (ptr += 1) - 1;
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() + arr_size == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 7);
+	}
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		for (size_t i = 0; i < count_iterations; ++i) {
+			auto element = (ptr -= 1);
+			*element += 1;
+		}
+	});
+
+	UT_ASSERT(vptr.data() == ptr.load().get());
+	for (auto element : vptr) {
+		UT_ASSERTeq(element, 8);
+	}
+}
+
+template <bool volatile_atomic>
+void
+test_exchange()
+{
+	pa_self_relative_ptr<int> first = reinterpret_cast<int *>(uintptr_t{0});
+	pa_self_relative_ptr<int> second =
+		reinterpret_cast<int *>(~uintptr_t{0});
+
+	atomic_type<int, volatile_atomic> ptr;
+
+	UT_ASSERT(ptr.load(std::memory_order_acquire).is_null());
+
+	ptr.store(first, std::memory_order_release);
+
+	UT_ASSERT(ptr.load() == first);
+
+	auto before_ptr = ptr.exchange(second, std::memory_order_acq_rel);
+
+	UT_ASSERT(ptr.load(std::memory_order_acquire) == second);
+
+	parallel_exec(MEAN_CONCURRENCY, [&](size_t i) {
+		for (size_t j = 0; j < 1000000; j++) {
+			auto before = ptr.exchange(i % 2 == 0 ? first : second,
+						   std::memory_order_acq_rel);
+			UT_ASSERT(before == first || before == second);
+		}
+	});
+
+	auto last_ptr = ptr.load();
+	UT_ASSERT(last_ptr == first || last_ptr == second);
+}
+
+template <bool volatile_atomic>
+void
+test_compare_exchange()
+{
+	int *first = reinterpret_cast<int *>(uintptr_t{0});
+	int *second = reinterpret_cast<int *>(~uintptr_t{0});
+	atomic_type<int, volatile_atomic> atomic_ptr{first};
+	std::atomic<size_t> exchanged(0);
+
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		// tst_val != atomic_ptr  ==>  tst_val is modified
+		// tst_val == atomic_ptr  ==>  atomic_ptr is modified
+
+		pa_self_relative_ptr<int> tst_val{first}, new_val{second};
+		if (atomic_ptr.compare_exchange_strong(tst_val, new_val)) {
+			++exchanged;
+		} else {
+			UT_ASSERT(tst_val == new_val);
+		}
+	});
+
+	UT_ASSERTeq(exchanged.load(), 1);
+	UT_ASSERT(atomic_ptr.load().get() == second);
+
+	atomic_ptr = first;
+	parallel_exec(CONCURRENCY, [&](size_t) {
+		// tst_val != atomic_ptr  ==>  tst_val is modified
+		// tst_val == atomic_ptr  ==>  atomic_ptr is modified
+
+		pa_self_relative_ptr<int> tst_val{first}, new_val{second};
+		if (atomic_ptr.compare_exchange_strong(
+			    tst_val, new_val, std::memory_order_acquire,
+			    std::memory_order_relaxed)) {
+			++exchanged;
+		} else {
+			UT_ASSERT(tst_val == new_val);
+		}
+	});
+
+	UT_ASSERTeq(exchanged.load(), 2);
+	UT_ASSERT(atomic_ptr.load().get() == second);
+}
+
+/**
+ * Small lock free stack for tests
+ */
+template <bool volatile_atomic, std::memory_order... weak_args>
+class test_stack {
+public:
+	struct node;
+
+	using value_type = size_t;
+	using node_ptr_type = pa_self_relative_ptr<node>;
+
+	struct node {
+		size_t value;
+		node_ptr_type next;
+	};
+
+	void
+	push(const value_type &data)
+	{
+		node_ptr_type new_node = new node{data, nullptr};
+
+		auto next_node = head.load(std::memory_order_acquire);
+
+		while (!head.compare_exchange_weak(next_node, new_node,
+						   weak_args...))
+			; // empty
+		new_node->next = next_node;
+	}
+
+	std::vector<value_type>
+	get_all()
+	{
+		auto current_node = head.load();
+		std::vector<value_type> values;
+		while (current_node != nullptr) {
+			values.push_back(current_node->value);
+			current_node = current_node->next;
+		}
+		return values;
+	}
+
+	~test_stack()
+	{
+		auto current_node = head.load();
+		while (current_node != nullptr) {
+			auto prev_node = current_node.get();
+			current_node = current_node->next;
+			delete prev_node;
+		}
+	}
+
+private:
+	atomic_type<node, volatile_atomic> head;
+};
+
+template <bool volatile_atomic, std::memory_order... weak_args>
+void
+test_stack_based_on_atomic()
+{
+	test_stack<volatile_atomic, weak_args...> stack;
+	constexpr size_t count_iterations = 1000;
+	parallel_exec(HIGH_CONCURRENCY, [&](size_t i) {
+		for (size_t j = 0; j < count_iterations; j++) {
+			stack.push(j + (i * count_iterations));
+		}
+	});
+	auto all = stack.get_all();
+	std::sort(all.begin(), all.end());
+	for (size_t i = 0; i < HIGH_CONCURRENCY * count_iterations; i++) {
+		UT_ASSERTeq(all[i], i);
+	}
+}
+
+template <bool volatile_atomic>
+void
+test_the_stack()
+{
+	test_stack_based_on_atomic<volatile_atomic, std::memory_order_acquire,
+				   std::memory_order_relaxed>();
+	test_stack_based_on_atomic<volatile_atomic,
+				   std::memory_order_seq_cst>();
+}
+
+template <bool volatile_atomic>
+void
+test_is_lock_free()
+{
+	atomic_type<int, volatile_atomic> a;
+	((void)(a.is_lock_free()));
+	((void)(std::atomic_is_lock_free(&a)));
+}
+
+template <bool volatile_atomic>
+void
+test(int argc, char *argv[])
+{
+	test_fetch<volatile_atomic>();
+	test_exchange<volatile_atomic>();
+	test_compare_exchange<volatile_atomic>();
+	test_the_stack<volatile_atomic>();
+	test_is_lock_free<volatile_atomic>();
+}
diff --git a/tests/ptr/pa_self_relative_ptr_atomic_pmem.cpp b/tests/ptr/pa_self_relative_ptr_atomic_pmem.cpp
new file mode 100644
index 0000000000..152618b3ab
--- /dev/null
+++ b/tests/ptr/pa_self_relative_ptr_atomic_pmem.cpp
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+#include "thread_helpers.hpp"
+#include "unittest.hpp"
+
+#include <libpmemobj++/experimental/atomic_self_relative_ptr.hpp>
+#include <libpmemobj++/experimental/self_relative_ptr.hpp>
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/make_persistent_array_atomic.hpp>
+#include <libpmemobj++/make_persistent_atomic.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+#include <libpmemobj++/persistent_ptr_base.hpp>
+#include <libpmemobj++/pool.hpp>
+#include <libpmemobj++/transaction.hpp>
+
+#define LAYOUT "cpp"
+
+namespace nvobj = pmem::obj;
+
+template <typename T>
+using pa_self_relative_ptr =
+	pmem::obj::experimental::self_relative_ptr<T, std::true_type>;
+template <typename T>
+using atomic_ptr = std::atomic<pa_self_relative_ptr<T>>;
+
+constexpr int ARR_SIZE = 10000;
+
+struct root {
+	atomic_ptr<nvobj::p<int>[ARR_SIZE]> parr;
+	atomic_ptr<int> ptr;
+};
+
+namespace
+{
+
+void
+test_ptr_transactional(nvobj::pool<root> &pop)
+{
+	auto r = pop.root();
+	try {
+		nvobj::transaction::run(pop, [&] {
+			UT_ASSERT(r->ptr.load() == nullptr);
+			nvobj::transaction::snapshot<atomic_ptr<int>>(&r->ptr);
+			r->ptr = nvobj::make_persistent<int>();
+		});
+	} catch (...) {
+		UT_ASSERT(0);
+	}
+
+	UT_ASSERT(r->ptr.load() != nullptr);
+
+	try {
+		nvobj::transaction::run(pop, [&] {
+			nvobj::delete_persistent<int>(r->ptr.load());
+			nvobj::transaction::snapshot<atomic_ptr<int>>(&r->ptr);
+			r->ptr.store(nullptr);
+		});
+	} catch (...) {
+		UT_ASSERT(0);
+	}
+
+	UT_ASSERT(r->ptr.load() == nullptr);
+}
+
+} /* namespace */
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc != 2)
+		UT_FATAL("usage: %s file-name", argv[0]);
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(path, LAYOUT, PMEMOBJ_MIN_POOL,
+						S_IWUSR | S_IRUSR);
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	test_ptr_transactional(pop);
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/ptr/ptr.hpp b/tests/ptr/ptr.hpp
index a2d1d0eba6..3d18363c75 100644
--- a/tests/ptr/ptr.hpp
+++ b/tests/ptr/ptr.hpp
@@ -18,6 +18,20 @@
 namespace nvobj = pmem::obj;
 namespace nvobjexp = nvobj::experimental;
 
+template <template <typename U, typename PersistentAware> class pointer>
+void
+assert_if_oid_is_null(pointer<int, std::true_type> &f)
+{
+	UT_ASSERT(OID_IS_NULL(f.raw()));
+}
+
+template <template <typename U, typename PersistentAware> class pointer>
+void
+assert_if_oid_is_null(pointer<int, std::false_type> &f)
+{
+	UT_ASSERT(OID_IS_NULL(f.raw()));
+}
+
 template <template <typename U> class pointer>
 void
 assert_if_oid_is_null(pointer<int> &f)
@@ -25,9 +39,13 @@ assert_if_oid_is_null(pointer<int> &f)
 	UT_ASSERT(OID_IS_NULL(f.raw()));
 }
 
-template <>
 void
-assert_if_oid_is_null(nvobjexp::self_relative_ptr<int> &f)
+assert_if_oid_is_null(nvobjexp::self_relative_ptr<int, std::true_type> &f)
+{
+}
+
+void
+assert_if_oid_is_null(nvobjexp::self_relative_ptr<int, std::false_type> &f)
 {
 }
 
@@ -35,6 +53,28 @@ assert_if_oid_is_null(nvobjexp::self_relative_ptr<int> &f)
  * test_null_ptr -- verifies if the pointer correctly behaves like a
  * nullptr-value
  */
+template <template <typename U, typename PersistentAware> class pointer>
+void
+test_null_ptr(pointer<int, std::true_type> &f)
+{
+	assert_if_oid_is_null(f);
+	UT_ASSERT((bool)f == false);
+	UT_ASSERT(!f);
+	UT_ASSERTeq(f.get(), nullptr);
+	UT_ASSERT(f == nullptr);
+}
+
+template <template <typename U, typename PersistentAware> class pointer>
+void
+test_null_ptr(pointer<int, std::false_type> &f)
+{
+	assert_if_oid_is_null(f);
+	UT_ASSERT((bool)f == false);
+	UT_ASSERT(!f);
+	UT_ASSERTeq(f.get(), nullptr);
+	UT_ASSERT(f == nullptr);
+}
+
 template <template <typename U> class pointer>
 void
 test_null_ptr(pointer<int> &f)
@@ -102,7 +142,7 @@ struct nested {
 template <template <typename U> class pointer, class pointer_base>
 struct templated_root {
 	pointer<foo> pfoo;
-	pointer<nvobj::p<int>[(long unsigned) TEST_ARR_SIZE]> parr;
+	pointer<nvobj::p<int>[(long unsigned)TEST_ARR_SIZE]> parr;
 	pointer_base arr[3];
 
 	/* This variable is unused, but it's here to check if the persistent_ptr
diff --git a/tests/ptr/self_relative_ptr.cpp b/tests/ptr/self_relative_ptr.cpp
index 43b16e1750..838c26d9d0 100644
--- a/tests/ptr/self_relative_ptr.cpp
+++ b/tests/ptr/self_relative_ptr.cpp
@@ -22,7 +22,8 @@
 #define LAYOUT "cpp"
 
 template <typename T>
-using self_relative_ptr = nvobj::experimental::self_relative_ptr<T>;
+using self_relative_ptr =
+	nvobj::experimental::self_relative_ptr<T, std::false_type>;
 using self_relative_ptr_base = nvobj::experimental::self_relative_ptr_base;
 
 namespace
diff --git a/tests/ptr/self_relative_ptr_arith.cpp b/tests/ptr/self_relative_ptr_arith.cpp
index a643cdd863..ee1e2d0c36 100644
--- a/tests/ptr/self_relative_ptr_arith.cpp
+++ b/tests/ptr/self_relative_ptr_arith.cpp
@@ -6,6 +6,11 @@
 #include <libpmemobj++/experimental/self_relative_ptr.hpp>
 #include <libpmemobj++/persistent_ptr.hpp>
 
+template <typename T>
+using self_relative_ptr =
+	nvobj::experimental::self_relative_ptr<T, std::false_type>;
+using self_relative_ptr_base = nvobj::experimental::self_relative_ptr_base;
+
 #define LAYOUT "cpp"
 
 static void
@@ -25,8 +30,8 @@ test(int argc, char *argv[])
 		UT_FATAL("!pool::create: %s %s", pe.what(), path);
 	}
 
-	test_arith<nvobjexp::self_relative_ptr>(pop);
-	test_relational<nvobjexp::self_relative_ptr>(pop);
+	test_arith<self_relative_ptr>(pop);
+	test_relational<self_relative_ptr>(pop);
 
 	pop.close();
 }
diff --git a/tests/ptr/self_relative_ptr_atomic.hpp b/tests/ptr/self_relative_ptr_atomic.hpp
index ab6f892f73..ceeb413a85 100644
--- a/tests/ptr/self_relative_ptr_atomic.hpp
+++ b/tests/ptr/self_relative_ptr_atomic.hpp
@@ -20,8 +20,9 @@ using pmem::obj::experimental::self_relative_ptr;
 template <typename T, bool need_volatile>
 using atomic_type = typename std::conditional<
 	need_volatile,
-	typename std::add_volatile<std::atomic<self_relative_ptr<T>>>::type,
-	std::atomic<self_relative_ptr<T>>>::type;
+	typename std::add_volatile<
+		std::atomic<self_relative_ptr<T, std::false_type>>>::type,
+	std::atomic<self_relative_ptr<T, std::false_type>>>::type;
 
 template <bool volatile_atomic>
 void
@@ -134,8 +135,10 @@ template <bool volatile_atomic>
 void
 test_exchange()
 {
-	self_relative_ptr<int> first = reinterpret_cast<int *>(uintptr_t{0});
-	self_relative_ptr<int> second = reinterpret_cast<int *>(~uintptr_t{0});
+	self_relative_ptr<int, std::false_type> first =
+		reinterpret_cast<int *>(uintptr_t{0});
+	self_relative_ptr<int, std::false_type> second =
+		reinterpret_cast<int *>(~uintptr_t{0});
 
 	atomic_type<int, volatile_atomic> ptr;
 
@@ -174,7 +177,8 @@ test_compare_exchange()
 		// tst_val != atomic_ptr  ==>  tst_val is modified
 		// tst_val == atomic_ptr  ==>  atomic_ptr is modified
 
-		self_relative_ptr<int> tst_val{first}, new_val{second};
+		self_relative_ptr<int, std::false_type> tst_val{first},
+			new_val{second};
 		if (atomic_ptr.compare_exchange_strong(tst_val, new_val)) {
 			++exchanged;
 		} else {
@@ -190,7 +194,8 @@ test_compare_exchange()
 		// tst_val != atomic_ptr  ==>  tst_val is modified
 		// tst_val == atomic_ptr  ==>  atomic_ptr is modified
 
-		self_relative_ptr<int> tst_val{first}, new_val{second};
+		self_relative_ptr<int, std::false_type> tst_val{first},
+			new_val{second};
 		if (atomic_ptr.compare_exchange_strong(
 			    tst_val, new_val, std::memory_order_acquire,
 			    std::memory_order_relaxed)) {
@@ -213,7 +218,7 @@ class test_stack {
 	struct node;
 
 	using value_type = size_t;
-	using node_ptr_type = self_relative_ptr<node>;
+	using node_ptr_type = self_relative_ptr<node, std::false_type>;
 
 	struct node {
 		size_t value;
diff --git a/tests/ptr/self_relative_ptr_atomic_pmem.cpp b/tests/ptr/self_relative_ptr_atomic_pmem.cpp
index a0bd221081..016e9c458d 100644
--- a/tests/ptr/self_relative_ptr_atomic_pmem.cpp
+++ b/tests/ptr/self_relative_ptr_atomic_pmem.cpp
@@ -20,7 +20,8 @@
 namespace nvobj = pmem::obj;
 
 template <typename T>
-using self_relative_ptr = pmem::obj::experimental::self_relative_ptr<T>;
+using self_relative_ptr =
+	pmem::obj::experimental::self_relative_ptr<T, std::false_type>;
 template <typename T>
 using atomic_ptr = std::atomic<self_relative_ptr<T>>;
 
diff --git a/tests/swmr_map/pmreorder.conf b/tests/swmr_map/pmreorder.conf
new file mode 100644
index 0000000000..3d6748e9cf
--- /dev/null
+++ b/tests/swmr_map/pmreorder.conf
@@ -0,0 +1,6 @@
+{
+	"pmemobj_open" : "NoReorderNoCheck",
+	"pmemobj_close" : "NoReorderNoCheck",
+	"pmemobj_alloc" : "NoReorderNoCheck",
+	"pmemobj_xalloc" : "NoReorderNoCheck"
+}
diff --git a/tests/swmr_map/swmr_map.cpp b/tests/swmr_map/swmr_map.cpp
new file mode 100644
index 0000000000..46223e6cfd
--- /dev/null
+++ b/tests/swmr_map/swmr_map.cpp
@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * swmr_map.cpp -- pmem::obj::experimental::swmr_map test
+ *
+ */
+
+#include "thread_helpers.hpp"
+#include "unittest.hpp"
+
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+#include <libpmemobj++/pool.hpp>
+
+#include <iterator>
+#include <thread>
+#include <vector>
+
+#include <libpmemobj++/container/string.hpp>
+#include <libpmemobj++/experimental/swmr_map.hpp>
+
+#define LAYOUT "swmr_map"
+
+namespace nvobj = pmem::obj;
+
+namespace
+{
+
+struct hetero_less {
+	using is_transparent = void;
+	template <typename T1, typename T2>
+	bool
+	operator()(const T1 &lhs, const T2 &rhs) const
+	{
+		return lhs < rhs;
+	}
+};
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int>>
+	persistent_map_type_int;
+
+typedef nvobj::experimental::swmr_map<nvobj::string, nvobj::string, hetero_less>
+	persistent_map_type_string;
+
+struct root {
+	nvobj::persistent_ptr<persistent_map_type_int> cons1;
+	nvobj::persistent_ptr<persistent_map_type_string> cons2;
+};
+
+std::string
+gen_key(persistent_map_type_string &, int i)
+{
+	return std::to_string(i);
+}
+
+int
+gen_key(persistent_map_type_int &, int i)
+{
+	return i;
+}
+
+template <typename MapType>
+void
+check_sorted(MapType *map)
+{
+	using value_type = typename MapType::value_type;
+	UT_ASSERT(std::is_sorted(
+		map->begin(), map->end(),
+		[](const value_type &lhs, const value_type &rhs) {
+			return lhs.first < rhs.first;
+		}));
+}
+
+/*
+ * emplace_and_lookup_test -- (internal) test emplace and lookup operations
+ */
+template <typename MapType>
+void
+emplace_and_lookup_test(nvobj::pool<root> &pop, MapType *map)
+{
+	const size_t NUMBER_ITEMS_INSERT = 50;
+
+	// Adding more concurrency will increase DRD test time
+	const size_t concurrency = 4;
+
+	size_t TOTAL_ITEMS = NUMBER_ITEMS_INSERT * (concurrency - 1);
+
+	UT_ASSERT(map != nullptr);
+
+	map->runtime_initialize();
+
+	parallel_exec(1, [&](size_t thread_id) {
+		int begin = 0;
+		int end = begin + int(TOTAL_ITEMS);
+		for (int i = begin; i < end; ++i) {
+			auto ret = map->emplace(gen_key(*map, i),
+						gen_key(*map, i));
+			UT_ASSERT(ret.second == true);
+
+			UT_ASSERT(map->count(gen_key(*map, i)) == 1);
+
+			typename MapType::iterator it =
+				map->find(gen_key(*map, i));
+			UT_ASSERT(it != map->end());
+			UT_ASSERT(it->first == gen_key(*map, i));
+			UT_ASSERT(it->second == gen_key(*map, i));
+		}
+		for (int i = begin; i < end; ++i) {
+			typename MapType::const_iterator it =
+				map->find(gen_key(*map, i));
+			UT_ASSERT(it != map->end());
+			UT_ASSERT(it->first == gen_key(*map, i));
+			UT_ASSERT(it->second == gen_key(*map, i));
+		}
+	});
+
+	parallel_exec(concurrency, [&](size_t thread_id) {
+		if (thread_id == 0) {
+			int begin = int(TOTAL_ITEMS);
+			int end = 2 * int(TOTAL_ITEMS);
+			for (int i = begin; i < end; ++i) {
+				auto ret = map->emplace(gen_key(*map, i),
+							gen_key(*map, i));
+				UT_ASSERT(ret.second == true);
+
+				UT_ASSERT(map->count(gen_key(*map, i)) == 1);
+			}
+		} else {
+			int begin = (thread_id - 1) * NUMBER_ITEMS_INSERT;
+			int end = begin + int(NUMBER_ITEMS_INSERT);
+			for (int i = begin; i < end; ++i) {
+				typename MapType::iterator it =
+					map->find(gen_key(*map, i));
+				UT_ASSERT(it != map->end());
+				UT_ASSERT(it->first == gen_key(*map, i));
+				UT_ASSERT(it->second == gen_key(*map, i));
+			}
+
+			for (int i = begin; i < end; ++i) {
+				typename MapType::const_iterator it =
+					map->find(gen_key(*map, i));
+				UT_ASSERT(it != map->end());
+				UT_ASSERT(it->first == gen_key(*map, i));
+				UT_ASSERT(it->second == gen_key(*map, i));
+			}
+		}
+	});
+
+	check_sorted(map);
+
+	UT_ASSERT(map->size() == 2 * TOTAL_ITEMS);
+
+	UT_ASSERT(std::distance(map->begin(), map->end()) ==
+		  2 * int(TOTAL_ITEMS));
+
+	check_sorted(map);
+
+	map->runtime_initialize();
+
+	UT_ASSERT(map->size() == 2 * TOTAL_ITEMS);
+
+	map->runtime_initialize();
+
+	UT_ASSERT(map->size() == 2 * TOTAL_ITEMS);
+
+	map->clear();
+
+	UT_ASSERT(map->size() == 0);
+
+	UT_ASSERT(std::distance(map->begin(), map->end()) == 0);
+}
+/*
+ * emplace_and_lookup_duplicates_test -- (internal) test emplace and lookup
+ * operations with duplicates
+ */
+template <typename MapType>
+void
+emplace_and_lookup_duplicates_test(nvobj::pool<root> &pop, MapType *map)
+{
+	const size_t NUMBER_ITEMS_INSERT = 50;
+
+	// Adding more concurrency will increase DRD test time
+	const size_t concurrency = 1;
+
+	UT_ASSERT(map != nullptr);
+
+	map->runtime_initialize();
+
+	std::vector<std::thread> threads;
+	threads.reserve(concurrency * 2);
+
+	for (size_t i = 0; i < concurrency; ++i) {
+		threads.emplace_back([&]() {
+			for (int i = 0;
+			     i < static_cast<int>(NUMBER_ITEMS_INSERT); ++i) {
+				map->emplace(gen_key(*map, i),
+					     gen_key(*map, i));
+			}
+		});
+	}
+
+	for (size_t i = 0; i < concurrency; ++i) {
+		threads.emplace_back([&]() {
+			for (int i = 0;
+			     i < static_cast<int>(NUMBER_ITEMS_INSERT); ++i) {
+				auto it = map->find(gen_key(*map, i));
+
+				if (it != map->end()) {
+					UT_ASSERT(it->first ==
+						  gen_key(*map, i));
+					UT_ASSERT(it->second ==
+						  gen_key(*map, i));
+				}
+			}
+		});
+	}
+
+	for (auto &t : threads) {
+		t.join();
+	}
+
+	check_sorted(map);
+
+	for (auto &e : *map) {
+		UT_ASSERT(e.first == e.second);
+	}
+
+	UT_ASSERT(map->size() == NUMBER_ITEMS_INSERT);
+
+	UT_ASSERT(std::distance(map->begin(), map->end()) ==
+		  static_cast<int>(NUMBER_ITEMS_INSERT));
+
+	check_sorted(map);
+}
+}
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc < 2) {
+		UT_FATAL("usage: %s file-name", argv[0]);
+	}
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(
+			path, LAYOUT, PMEMOBJ_MIN_POOL * 20, S_IWUSR | S_IRUSR);
+		nvobj::transaction::run(pop, [&] {
+			pop.root()->cons1 = nvobj::make_persistent<
+				persistent_map_type_int>();
+			pop.root()->cons2 = nvobj::make_persistent<
+				persistent_map_type_string>();
+		});
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	emplace_and_lookup_test(pop, pop.root()->cons1.get());
+	emplace_and_lookup_duplicates_test(pop, pop.root()->cons1.get());
+
+	emplace_and_lookup_test(pop, pop.root()->cons2.get());
+	emplace_and_lookup_duplicates_test(pop, pop.root()->cons2.get());
+
+	nvobj::transaction::run(pop, [&] {
+		nvobj::delete_persistent<persistent_map_type_int>(
+			pop.root()->cons1);
+		nvobj::delete_persistent<persistent_map_type_string>(
+			pop.root()->cons2);
+	});
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/swmr_map/swmr_map_insert_reopen.cpp b/tests/swmr_map/swmr_map_insert_reopen.cpp
new file mode 100644
index 0000000000..a690881b49
--- /dev/null
+++ b/tests/swmr_map/swmr_map_insert_reopen.cpp
@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * swmr_map_insert_reopen.cpp -- pmem::obj::experimental::swmr_map
+ * test
+ *
+ */
+
+#include "unittest.hpp"
+#include <libpmemobj++/experimental/swmr_map.hpp>
+
+template <typename MapType>
+void
+check_size(MapType *map, size_t expected_size)
+{
+	UT_ASSERT(map->size() == expected_size);
+	UT_ASSERT(std::distance(map->begin(), map->end()) ==
+		  int(expected_size));
+}
+
+namespace nvobj = pmem::obj;
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int>>
+	persistent_map_type;
+
+struct root {
+	nvobj::persistent_ptr<persistent_map_type> cons;
+};
+
+static const std::string LAYOUT = "swmr_map";
+
+/*
+ * insert_reopen_test -- (internal) test insert operations and verify
+ * consistency after reopen
+ * pmem::obj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+insert_reopen_test(nvobj::pool<root> &pop, std::string path,
+		   size_t concurrency = 4)
+{
+
+	using value_type = persistent_map_type::value_type;
+	PRINT_TEST_PARAMS;
+
+	size_t thread_items = 50;
+	const size_t expected_size = thread_items * concurrency;
+
+	{
+		auto map = pop.root()->cons;
+
+		UT_ASSERT(map != nullptr);
+
+		map->runtime_initialize();
+
+		parallel_exec(concurrency, [&](size_t thread_id) {
+			int begin = thread_id * thread_items;
+			int end = begin + int(thread_items);
+			for (int i = begin; i < end; ++i) {
+				map->insert(value_type(i, i));
+			}
+		});
+
+		check_size(map.get(), expected_size);
+
+		map->insert(value_type(expected_size + 1, 1));
+		map->unsafe_erase(expected_size + 1);
+
+		pop.close();
+	}
+
+	{
+		pop = nvobj::pool<root>::open(path, LAYOUT);
+
+		auto map = pop.root()->cons;
+
+		UT_ASSERT(map != nullptr);
+
+		map->runtime_initialize();
+
+		check_size(map.get(), expected_size);
+
+		parallel_exec(concurrency, [&](size_t thread_id) {
+			int begin = thread_id * thread_items;
+			int end = begin + int(thread_items);
+			for (int i = begin; i < end; ++i) {
+				map->insert(
+					value_type(i + int(expected_size), i));
+			}
+		});
+
+		check_size(map.get(), expected_size * 2);
+	}
+}
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc < 2) {
+		UT_FATAL("usage: %s file-name", argv[0]);
+	}
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(
+			path, LAYOUT, PMEMOBJ_MIN_POOL * 20, S_IWUSR | S_IRUSR);
+		pmem::obj::transaction::run(pop, [&] {
+			pop.root()->cons =
+				nvobj::make_persistent<persistent_map_type>();
+		});
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	size_t concurrency = 1;
+	if (On_drd)
+		concurrency = 1;
+	std::cout << "Running tests for " << concurrency << " threads"
+		  << std::endl;
+
+	insert_reopen_test(pop, path, concurrency);
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/swmr_map/swmr_map_pmreorder_simple.cpp b/tests/swmr_map/swmr_map_pmreorder_simple.cpp
new file mode 100644
index 0000000000..f33134102b
--- /dev/null
+++ b/tests/swmr_map/swmr_map_pmreorder_simple.cpp
@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * swmr_map_reorder_simple.cpp -- pmem::obj::experimental::swmr_map
+ * test
+ *
+ */
+
+#include "helper_algorithm.hpp"
+#include "unittest.hpp"
+
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+#include <libpmemobj++/pool.hpp>
+
+#include <future>
+#include <iostream>
+
+#include <libpmemobj++/experimental/swmr_map.hpp>
+
+#define LAYOUT "persistent_swmr_map"
+
+namespace nvobj = pmem::obj;
+
+namespace
+{
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int>>
+	persistent_map_type;
+
+typedef persistent_map_type::value_type value_type;
+
+struct root {
+	nvobj::persistent_ptr<persistent_map_type> cons;
+};
+
+static constexpr int elements[] = {2, 257, 513, 1, 123, 713};
+
+static constexpr int len_elements =
+	static_cast<int>(sizeof(elements) / sizeof(elements[0]));
+
+/*
+ * check_exist -- (internal) check existence of an element
+ */
+void
+check_exist(nvobj::persistent_ptr<persistent_map_type> &map, int element)
+{
+	auto it = map->find(element);
+	UT_ASSERTeq(it != map->end(), true);
+
+	UT_ASSERTeq(it->first, element);
+	UT_ASSERTeq(it->second, element);
+}
+
+/*
+ * test_init -- (internal) init test
+ * pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+test_init(nvobj::pool<root> &pop)
+{
+	auto persistent_map = pop.root()->cons;
+	persistent_map->runtime_initialize();
+
+	for (int i = 0; i < len_elements / 2; i++) {
+		persistent_map->insert(value_type(elements[i], elements[i]));
+		check_exist(persistent_map, elements[i]);
+	}
+}
+
+/*
+ * test_map -- (internal) test
+ * pmem::obj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+test_insert(nvobj::pool<root> &pop)
+{
+	auto persistent_map = pop.root()->cons;
+
+	persistent_map->runtime_initialize();
+
+	for (int i = len_elements / 2; i < len_elements; i++) {
+		persistent_map->insert(value_type(elements[i], elements[i]));
+		check_exist(persistent_map, elements[i]);
+	}
+}
+
+void
+check_consistency(nvobj::pool<root> &pop)
+{
+	auto persistent_map = pop.root()->cons;
+	persistent_map->runtime_initialize();
+
+	auto size = static_cast<typename persistent_map_type::difference_type>(
+		persistent_map->size());
+
+	UT_ASSERTeq(
+		std::distance(persistent_map->begin(), persistent_map->end()),
+		size);
+
+	UT_ASSERT(size <= len_elements);
+
+	for (int i = 0; i < size; i++) {
+		UT_ASSERTeq(persistent_map->count(elements[i]), 1);
+		check_exist(persistent_map, elements[i]);
+	}
+
+	for (int i = size;
+	     i < static_cast<int>(sizeof(elements) / sizeof(elements[0]));
+	     i++) {
+		UT_ASSERTeq(persistent_map->count(elements[i]), 0);
+	}
+
+	auto value_comp = [](const value_type &lhs, const value_type &rhs) {
+		return lhs.first < rhs.first;
+	};
+	std::is_sorted(persistent_map->begin(), persistent_map->end(),
+		       value_comp);
+
+	is_strictly_increased(persistent_map->begin(), persistent_map->end(),
+			      value_comp);
+}
+}
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc != 3 || strchr("coi", argv[1][0]) == nullptr)
+		UT_FATAL("usage: %s <c|o|i> file-name", argv[0]);
+
+	const char *path = argv[2];
+
+	nvobj::pool<root> pop;
+
+	try {
+		if (argv[1][0] == 'o') {
+			pop = nvobj::pool<root>::open(path, LAYOUT);
+
+			check_consistency(pop);
+		} else if (argv[1][0] == 'c') {
+			pop = nvobj::pool<root>::create(path, LAYOUT,
+							PMEMOBJ_MIN_POOL * 20,
+							S_IWUSR | S_IRUSR);
+
+			pmem::obj::transaction::run(pop, [&] {
+				pop.root()->cons = nvobj::make_persistent<
+					persistent_map_type>();
+			});
+
+			test_init(pop);
+		} else if (argv[1][0] == 'i') {
+			pop = nvobj::pool<root>::open(path, LAYOUT);
+
+			test_insert(pop);
+		}
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/swmr_map/swmr_map_singlethread.cpp b/tests/swmr_map/swmr_map_singlethread.cpp
new file mode 100644
index 0000000000..bd94acc035
--- /dev/null
+++ b/tests/swmr_map/swmr_map_singlethread.cpp
@@ -0,0 +1,701 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * swmr_map_singlethread.cpp -- pmem::obj::experimental::swmr_map
+ * basic tests
+ *
+ */
+
+#include "unittest.hpp"
+
+#include <libpmemobj++/container/string.hpp>
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+#include <libpmemobj++/pool.hpp>
+
+#include <iterator>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <libpmemobj++/experimental/swmr_map.hpp>
+
+#define LAYOUT "swmr_map"
+
+namespace nvobj = pmem::obj;
+
+namespace
+{
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int>>
+	persistent_map_type;
+
+typedef persistent_map_type::value_type value_type;
+
+struct move_element {
+	move_element(int val) noexcept : val(val)
+	{
+	}
+
+	move_element(const move_element &) = delete;
+
+	move_element &operator=(const move_element &) = delete;
+
+	move_element(move_element &&e) noexcept : val(e.val)
+	{
+		e.val = 0;
+	}
+
+	move_element &
+	operator=(move_element &&e)
+	{
+		val = e.val;
+		e.val = 0;
+		return *this;
+	}
+
+	nvobj::p<int> val;
+};
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, move_element>
+	persistent_map_move_type;
+
+typedef persistent_map_move_type::value_type value_move_type;
+
+struct hetero_less {
+	using is_transparent = void;
+	template <typename T1, typename T2>
+	bool
+	operator()(const T1 &lhs, const T2 &rhs) const
+	{
+		return lhs < rhs;
+	}
+};
+
+inline std::string
+gen_hetero(int v)
+{
+	return std::to_string(v);
+}
+
+typedef nvobj::experimental::swmr_map<pmem::obj::string, pmem::obj::string,
+				      hetero_less>
+	persistent_map_string_type;
+
+struct root {
+	nvobj::persistent_ptr<persistent_map_type> map1;
+	nvobj::persistent_ptr<persistent_map_type> map2;
+
+	nvobj::persistent_ptr<persistent_map_move_type> map_move;
+
+	nvobj::persistent_ptr<persistent_map_string_type> map_string;
+};
+
+void
+verify_elements(persistent_map_type &map, size_t elements)
+{
+	UT_ASSERT(map.size() == elements);
+
+	for (int i = 0; i < static_cast<int>(elements); i++) {
+		UT_ASSERT(map.count(i) == 1);
+	}
+}
+
+/**
+ * Wrapper around PMDK allocator
+ * @throw std::bad_alloc on allocation failure.
+ */
+template <typename T, typename U, typename... Args>
+void
+tx_alloc_wrapper(nvobj::pool_base &pop, nvobj::persistent_ptr<U> &ptr,
+		 Args &&... args)
+{
+	try {
+		nvobj::transaction::manual tx(pop);
+		ptr = nvobj::make_persistent<T>(std::forward<Args>(args)...);
+		nvobj::transaction::commit();
+	} catch (...) {
+		throw std::bad_alloc();
+	}
+}
+
+/*
+ * swap_test -- (internal) test swap method
+ * pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+swap_test(nvobj::pool<root> &pop)
+{
+	auto &map1 = pop.root()->map1;
+	auto &map2 = pop.root()->map2;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map1);
+	tx_alloc_wrapper<persistent_map_type>(pop, map2);
+
+	for (int i = 0; i < 50; i++) {
+		auto ret = map1->insert(value_type(i, i));
+		UT_ASSERT(ret.second == true);
+	}
+
+	for (int i = 0; i < 300; i++) {
+		auto ret = map2->insert(value_type(i, i));
+		UT_ASSERT(ret.second == true);
+	}
+
+	map1->swap(*map2);
+	verify_elements(*map1, 300);
+	verify_elements(*map2, 50);
+
+	pmem::detail::destroy<persistent_map_type>(*map1);
+	pmem::detail::destroy<persistent_map_type>(*map2);
+}
+
+/*
+ * access_test -- (internal) test access methods
+ * pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+access_test(nvobj::pool<root> &pop)
+{
+	auto &map1 = pop.root()->map1;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map1);
+
+	for (int i = 0; i < 100; i++) {
+		auto ret = map1->insert(value_type(i, i));
+		UT_ASSERT(ret.second == true);
+	}
+
+	UT_ASSERT(map1->begin() ==
+		  const_cast<const persistent_map_type *>(map1.get())->begin());
+	UT_ASSERT(map1->end() ==
+		  const_cast<const persistent_map_type *>(map1.get())->end());
+
+	int i = 0;
+	auto it = map1->begin();
+	auto const_it =
+		const_cast<const persistent_map_type *>(map1.get())->begin();
+	while (it != map1->end()) {
+		UT_ASSERT(it->first == const_it->first);
+		UT_ASSERT(it->second == const_it->second);
+
+		i++;
+		it++;
+		const_it++;
+	}
+
+	UT_ASSERT(static_cast<size_t>(i) == map1->size());
+
+	pmem::detail::destroy<persistent_map_type>(*map1);
+}
+
+/*
+ * insert_test -- (internal) test insert methods
+ * pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+insert_test(nvobj::pool<root> &pop)
+{
+	auto &map1 = pop.root()->map1;
+	auto &map_move = pop.root()->map_move;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map1);
+
+	{
+		auto ret = map1->insert(value_type(1, 1));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 1);
+		UT_ASSERTeq(ret.first->second, 1);
+	}
+
+	{
+		auto ret = map1->insert(value_type(2, 2));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 2);
+		UT_ASSERTeq(ret.first->second, 2);
+	}
+
+	tx_alloc_wrapper<persistent_map_move_type>(pop, map_move);
+
+	{
+		value_move_type e(3, 3);
+
+		auto ret = map_move->insert(std::move(e));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 3);
+		UT_ASSERTeq(ret.first->second.val, 3);
+	}
+
+	{
+		value_move_type e(4, 4);
+
+		auto ret = map_move->insert(std::move(e));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 4);
+		UT_ASSERTeq(ret.first->second.val, 4);
+	}
+
+	{
+		value_move_type e(5, 5);
+
+		auto ret = map_move->insert(std::move(e));
+		UT_ASSERTeq(ret.second, true);
+
+		using const_iterator =
+			typename persistent_map_move_type::const_iterator;
+		const_iterator it = map_move->find(5);
+
+		UT_ASSERT(it != map_move->end());
+
+		UT_ASSERTeq(it->first, 5);
+		UT_ASSERTeq(it->second.val, 5);
+	}
+
+	{
+		value_move_type e(6, 6);
+
+		auto ret = map_move->insert(std::move(e));
+		UT_ASSERTeq(ret.second, true);
+
+		using iterator = typename persistent_map_move_type::iterator;
+		iterator it = map_move->find(6);
+
+		UT_ASSERT(it != map_move->end());
+
+		UT_ASSERTeq(it->first, 6);
+		UT_ASSERTeq(it->second.val, 6);
+	}
+
+	{
+		std::vector<value_type> v = {value_type(11, 11),
+					     value_type(12, 12),
+					     value_type(13, 13)};
+
+		map1->insert(v.begin(), v.end());
+
+		for (auto &e : v)
+			UT_ASSERTeq(map1->count(e.first), 1);
+	}
+
+	{
+		map1->insert(std::initializer_list<value_type>{
+			value_type(21, 21), value_type(22, 22)});
+
+		UT_ASSERTeq(map1->count(21), 1);
+		UT_ASSERTeq(map1->count(22), 1);
+	}
+
+	pmem::detail::destroy<persistent_map_type>(*map1);
+	pmem::detail::destroy<persistent_map_move_type>(*map_move);
+}
+
+/*
+ * emplace_test -- (internal) test emplace method
+ */
+void
+emplace_test(nvobj::pool<root> &pop)
+{
+	auto &map = pop.root()->map1;
+	auto &map_move = pop.root()->map_move;
+	auto &map_string = pop.root()->map_string;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map);
+
+	{
+		auto ret = map->emplace(value_type(1, 1));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 1);
+		UT_ASSERTeq(ret.first->second, 1);
+	}
+
+	{
+		auto ret = map->emplace(value_type(1, 2));
+		UT_ASSERTeq(ret.second, false);
+		UT_ASSERTeq(ret.first->first, 1);
+		UT_ASSERTeq(ret.first->second, 1);
+	}
+
+	{
+		auto ret = map->emplace(2, 2);
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 2);
+		UT_ASSERTeq(ret.first->second, 2);
+	}
+
+	{
+		auto ret = map->emplace(2, 3);
+		UT_ASSERTeq(ret.second, false);
+		UT_ASSERTeq(ret.first->first, 2);
+		UT_ASSERTeq(ret.first->second, 2);
+	}
+
+	tx_alloc_wrapper<persistent_map_move_type>(pop, map_move);
+
+	{
+		value_move_type e(3, 3);
+
+		auto ret = map_move->emplace(std::move(e));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 3);
+		UT_ASSERTeq(ret.first->second.val, 3);
+	}
+
+	{
+		move_element m(4);
+		auto ret = map_move->emplace(4, std::move(m));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERTeq(ret.first->first, 4);
+		UT_ASSERTeq(ret.first->second.val, 4);
+		UT_ASSERTeq(m.val, 0); // m was moved
+	}
+
+	{
+		move_element m(5);
+		auto ret = map_move->try_emplace(4, std::move(m));
+		UT_ASSERTeq(ret.second, false);
+		UT_ASSERTeq(ret.first->first, 4);
+		UT_ASSERTeq(ret.first->second.val, 4);
+		UT_ASSERTeq(m.val, 5); // m was not moved
+	}
+
+	tx_alloc_wrapper<persistent_map_string_type>(pop, map_string);
+	{
+		std::string str("foo");
+		auto ret = map_string->emplace(str, str);
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERT(ret.first->first == str);
+		UT_ASSERT(ret.first->second == str);
+	}
+
+	{
+		auto ret = map_string->emplace("bar", "bar");
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERT(ret.first->first == "bar");
+		UT_ASSERT(ret.first->second == "bar");
+	}
+
+	{
+		std::string str("foo\0bar", 7);
+		auto ret = map_string->emplace(
+			std::piecewise_construct,
+			std::forward_as_tuple(str.c_str(), str.size()),
+			std::forward_as_tuple(str.c_str(), str.size()));
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERT(ret.first->first == str);
+		UT_ASSERT(ret.first->second == str);
+	}
+
+	{
+		std::string str("bar\0foo", 7);
+		auto ret =
+			map_string->try_emplace(str, str.c_str(), str.size());
+		UT_ASSERTeq(ret.second, true);
+		UT_ASSERT(ret.first->first == str);
+		UT_ASSERT(ret.first->second == str);
+
+		ret = map_string->try_emplace(str, "new_value");
+		UT_ASSERTeq(ret.second, false);
+		UT_ASSERT(ret.first->first == str);
+		UT_ASSERT(ret.first->second == str);
+	}
+
+	pmem::detail::destroy<persistent_map_type>(*map);
+	pmem::detail::destroy<persistent_map_move_type>(*map_move);
+	pmem::detail::destroy<persistent_map_string_type>(*map_string);
+}
+
+template <bool is_const, typename MapType>
+void
+bound_helper(nvobj::persistent_ptr<MapType> &m)
+{
+	using iterator =
+		typename std::conditional<is_const,
+					  typename MapType::const_iterator,
+					  typename MapType::iterator>::type;
+
+	using map_ptr_type =
+		typename std::conditional<is_const, const MapType *,
+					  MapType *>::type;
+	map_ptr_type map = m.get();
+
+	for (int i = 0; i < 298; ++i) {
+		iterator lb_it = map->lower_bound(i);
+		iterator ub_it = map->upper_bound(i);
+		UT_ASSERT(lb_it != map->end());
+		UT_ASSERT(ub_it != map->end());
+
+		std::pair<iterator, iterator> range = map->equal_range(i);
+
+		if (i % 2 == 0) {
+			UT_ASSERT(lb_it != ub_it);
+			UT_ASSERTeq(lb_it->first, i);
+			UT_ASSERTeq(lb_it->second, i);
+			UT_ASSERTeq(ub_it->first, i + 2);
+			UT_ASSERTeq(ub_it->second, i + 2);
+
+			UT_ASSERTeq(std::distance(range.first, range.second),
+				    1);
+			UT_ASSERTeq(range.first->first, i);
+			UT_ASSERTeq(range.first->second, i);
+			UT_ASSERTeq(range.second->first, i + 2);
+			UT_ASSERTeq(range.second->second, i + 2);
+		} else {
+			UT_ASSERT(lb_it == ub_it);
+			UT_ASSERTeq(lb_it->first, i + 1);
+			UT_ASSERTeq(lb_it->second, i + 1);
+			UT_ASSERTeq(ub_it->first, i + 1);
+			UT_ASSERTeq(ub_it->second, i + 1);
+
+			UT_ASSERTeq(std::distance(range.first, range.second),
+				    0);
+			UT_ASSERTeq(range.first->first, i + 1);
+			UT_ASSERTeq(range.first->second, i + 1);
+			UT_ASSERTeq(range.second->first, i + 1);
+			UT_ASSERTeq(range.second->second, i + 1);
+		}
+	}
+
+	iterator lb_it = map->lower_bound(298);
+	UT_ASSERT(lb_it != map->end());
+	UT_ASSERTeq(lb_it->first, 298);
+	UT_ASSERTeq(lb_it->second, 298);
+
+	iterator ub_it = map->upper_bound(298);
+	UT_ASSERT(ub_it == map->end());
+
+	lb_it = map->lower_bound(300);
+	UT_ASSERT(lb_it == map->end());
+
+	ub_it = map->upper_bound(300);
+	UT_ASSERT(ub_it == map->end());
+
+	lb_it = map->lower_bound(-1);
+	UT_ASSERT(lb_it == map->begin());
+	UT_ASSERTeq(lb_it->first, 0);
+	UT_ASSERTeq(lb_it->second, 0);
+
+	ub_it = map->upper_bound(-1);
+	UT_ASSERT(ub_it == map->begin());
+	UT_ASSERTeq(ub_it->first, 0);
+	UT_ASSERTeq(ub_it->second, 0);
+
+	std::pair<iterator, iterator> range = map->equal_range(-1);
+	UT_ASSERTeq(std::distance(range.first, range.second), 0);
+	UT_ASSERT(range.first == range.second);
+	UT_ASSERT(range.first == map->begin());
+
+	range = map->equal_range(298);
+	UT_ASSERTeq(std::distance(range.first, range.second), 1);
+	UT_ASSERT(range.first != map->end());
+	UT_ASSERT(range.second == map->end());
+	UT_ASSERTeq(range.first->first, 298);
+	UT_ASSERTeq(range.first->second, 298);
+
+	range = map->equal_range(300);
+	UT_ASSERTeq(std::distance(range.first, range.second), 0);
+	UT_ASSERT(range.first == map->end());
+	UT_ASSERT(range.second == map->end());
+}
+
+/*
+ * bound_test -- (internal) test upper_bound, lower_bound and equal_range
+ * methods pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+bound_test(nvobj::pool<root> &pop)
+{
+	auto &map1 = pop.root()->map1;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map1);
+
+	for (int i = 0; i < 300; i += 2) {
+		auto ret = map1->insert(value_type(i, i));
+		UT_ASSERT(ret.second == true);
+	}
+
+	bound_helper<true>(map1);
+	bound_helper<false>(map1);
+
+	pmem::detail::destroy<persistent_map_type>(*map1);
+}
+
+/*
+ * erase_test -- (internal) test erase methods
+ * pmem::obj::swmr_map<nvobj::p<int>, nvobj::p<int> >
+ */
+void
+erase_test(nvobj::pool<root> &pop)
+{
+	auto &map1 = pop.root()->map1;
+
+	tx_alloc_wrapper<persistent_map_type>(pop, map1);
+
+	for (int i = 0; i < 300; ++i) {
+		auto ret = map1->insert(value_type(i, i));
+		UT_ASSERT(ret.second == true);
+	}
+
+	auto last = map1->find(150);
+	UT_ASSERT(last != map1->end());
+
+	auto ret = map1->unsafe_erase(map1->begin(), last);
+
+	UT_ASSERT(map1->begin() == ret);
+	UT_ASSERTeq(150, std::distance(map1->begin(), map1->end()));
+
+	for (int i = 0; i < 150; ++i) {
+		UT_ASSERT(map1->contains(i) == false);
+	}
+
+	for (int i = 150; i < 300; ++i) {
+		UT_ASSERT(map1->contains(i));
+	}
+
+	UT_ASSERTeq(map1->unsafe_erase(150), size_t(1));
+	UT_ASSERT(map1->find(150) == map1->end());
+
+	persistent_map_type::const_iterator const_it = map1->find(151);
+	UT_ASSERT(const_it != map1->end());
+	persistent_map_type::iterator it = map1->unsafe_erase(const_it);
+	UT_ASSERT(map1->contains(151) == false);
+	UT_ASSERT(it != map1->end());
+	UT_ASSERTeq(it->first, 152);
+	UT_ASSERTeq(it->second, 152);
+	it = map1->unsafe_erase(it);
+	UT_ASSERT(map1->contains(152) == false);
+	UT_ASSERT(it != map1->end());
+	UT_ASSERTeq(it->first, 153);
+	UT_ASSERTeq(it->second, 153);
+
+	pmem::detail::destroy<persistent_map_type>(*map1);
+}
+
+template <bool is_const, typename MapType>
+void
+hetero_helper(nvobj::persistent_ptr<MapType> &m)
+{
+	using iterator =
+		typename std::conditional<is_const,
+					  typename MapType::const_iterator,
+					  typename MapType::iterator>::type;
+
+	using map_ptr_type =
+		typename std::conditional<is_const, const MapType *,
+					  MapType *>::type;
+
+	using value_type = typename MapType::value_type;
+
+	map_ptr_type map = m.get();
+
+	UT_ASSERT(std::is_sorted(
+		map->begin(), map->end(),
+		[](const value_type &lhs, const value_type &rhs) {
+			return lhs.first < rhs.first;
+		}));
+
+	for (int i = 0; i < 100; ++i) {
+		UT_ASSERT(map->contains(gen_hetero(i)));
+	}
+
+	for (int i = 0; i < 100; ++i) {
+		iterator it = map->find(gen_hetero(i));
+
+		UT_ASSERT(it != map->end());
+		UT_ASSERT(it->first == gen_hetero(i));
+		UT_ASSERT(it->second == gen_hetero(i));
+	}
+
+	for (int i = 0; i < 99; ++i) {
+		iterator lb_it = map->lower_bound(gen_hetero(i));
+		iterator ub_it = map->upper_bound(gen_hetero(i));
+		UT_ASSERT(lb_it != map->end());
+		UT_ASSERT(ub_it != map->end());
+		UT_ASSERT(lb_it != ub_it);
+		UT_ASSERT(lb_it->first == gen_hetero(i));
+		UT_ASSERT(lb_it->second == gen_hetero(i));
+
+		// make sure that ub_it points to the next after lb_it
+		UT_ASSERTeq(std::distance(lb_it, ub_it), 1);
+
+		UT_ASSERT(ub_it->first == ub_it->second);
+
+		std::pair<iterator, iterator> range =
+			map->equal_range(gen_hetero(i));
+		UT_ASSERTeq(std::distance(range.first, range.second), 1);
+		UT_ASSERT(range.first->first == gen_hetero(i));
+		UT_ASSERT(range.first->second == gen_hetero(i));
+		UT_ASSERT(range.second->first == range.second->second);
+	}
+}
+
+/*
+ * hetero_test -- (internal) test heterogeneous contains/count/find/erase
+ * methods pmem::obj::swmr_map<pmem::obj::string, pmem::obj::string,
+ * std::less<void> >
+ */
+void
+hetero_test(nvobj::pool<root> &pop)
+{
+	auto &map = pop.root()->map_string;
+
+	tx_alloc_wrapper<persistent_map_string_type>(pop, map);
+
+	for (int i = 0; i < 100; ++i) {
+		map->emplace(gen_hetero(i), gen_hetero(i));
+	}
+
+	hetero_helper<true>(map);
+	hetero_helper<false>(map);
+
+	for (int i = 0; i < 100; ++i) {
+		UT_ASSERTeq(map->unsafe_erase(gen_hetero(i)), 1);
+	}
+
+	for (int i = 0; i < 100; ++i) {
+		UT_ASSERTeq(map->count(gen_hetero(i)), 0);
+	}
+
+	for (int i = 0; i < 100; ++i) {
+		UT_ASSERT(map->contains(gen_hetero(i)) == false);
+	}
+
+	pmem::detail::destroy<persistent_map_string_type>(*map);
+}
+}
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc < 2) {
+		UT_FATAL("usage: %s file-name", argv[0]);
+	}
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(
+			path, LAYOUT, PMEMOBJ_MIN_POOL * 20, S_IWUSR | S_IRUSR);
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	access_test(pop);
+	swap_test(pop);
+	insert_test(pop);
+	emplace_test(pop);
+	bound_test(pop);
+	erase_test(pop);
+	hetero_test(pop);
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}
diff --git a/tests/swmr_map/swmr_map_tx.cpp b/tests/swmr_map/swmr_map_tx.cpp
new file mode 100644
index 0000000000..f553016a94
--- /dev/null
+++ b/tests/swmr_map/swmr_map_tx.cpp
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/* Copyright 2021, 4Paradigm Inc. */
+
+/*
+ * concurrent_hash_map_tx.cpp -- pmem::obj::experimental::swmr_map test
+ *
+ */
+
+#include "unittest.hpp"
+
+#include <libpmemobj++/make_persistent.hpp>
+#include <libpmemobj++/p.hpp>
+#include <libpmemobj++/persistent_ptr.hpp>
+#include <libpmemobj++/pool.hpp>
+
+#include <array>
+#include <iterator>
+#include <thread>
+#include <vector>
+
+#include <libpmemobj++/experimental/swmr_map.hpp>
+
+#define LAYOUT "swmr_map"
+
+namespace nvobj = pmem::obj;
+
+typedef nvobj::experimental::swmr_map<nvobj::p<int>, nvobj::p<int>>
+	persistent_map_type;
+
+struct root {
+	nvobj::persistent_ptr<persistent_map_type> map;
+	nvobj::persistent_ptr<persistent_map_type> map2;
+};
+
+/*
+ * It verifies that f() throws transaction_scope_error exception.
+ */
+void
+assert_tx_exception(std::function<void(void)> f)
+{
+	bool exception_thrown = false;
+	try {
+		f();
+		UT_ASSERT(0);
+	} catch (pmem::transaction_scope_error &) {
+		exception_thrown = true;
+	} catch (std::exception &e) {
+		UT_FATALexc(e);
+	}
+
+	UT_ASSERT(exception_thrown);
+}
+
+void
+test_tx_exception(nvobj::pool<root> &pop)
+{
+	pmem::obj::transaction::run(pop, [&] {
+		pop.root()->map = nvobj::make_persistent<persistent_map_type>();
+	});
+
+	using value_type = typename persistent_map_type::value_type;
+	using key_type = typename persistent_map_type::key_type;
+
+	auto map = pop.root()->map;
+
+	map->runtime_initialize();
+
+	pmem::obj::transaction::run(pop, [&] {
+		value_type v(0, 0);
+		assert_tx_exception([&] { (void)map->insert(v); });
+
+		assert_tx_exception(
+			[&] { (void)map->insert(std::pair<int, int>(0, 0)); });
+
+		assert_tx_exception(
+			[&] { (void)map->insert(value_type(0, 0)); });
+
+		assert_tx_exception([&] {
+			(void)map->insert(map->end(), value_type(0, 0));
+		});
+
+		assert_tx_exception([&] {
+			(void)map->insert(map->end(),
+					  std::pair<int, int>(0, 0));
+		});
+
+		std::array<persistent_map_type::value_type, 2> arr{
+			persistent_map_type::value_type{0, 0},
+			persistent_map_type::value_type{1, 1}};
+
+		assert_tx_exception(
+			[&] { (void)map->insert(arr.begin(), arr.end()); });
+
+		assert_tx_exception([&] {
+			(void)map->insert(
+				{persistent_map_type::value_type{0, 0},
+				 persistent_map_type::value_type{1, 1}});
+		});
+
+		assert_tx_exception([&] { (void)map->emplace(0, 0); });
+
+		assert_tx_exception(
+			[&] { (void)map->emplace_hint(map->end(), 0, 0); });
+
+		key_type k(0);
+		assert_tx_exception([&] { (void)map->try_emplace(k, 0); });
+
+		assert_tx_exception(
+			[&] { (void)map->try_emplace(key_type(0), 0); });
+
+		assert_tx_exception([&] { (void)map->try_emplace(0, 0); });
+
+		assert_tx_exception([&] { (void)map->unsafe_erase(0); });
+
+		assert_tx_exception(
+			[&] { (void)map->unsafe_erase(map->begin()); });
+
+		assert_tx_exception([&] {
+			(void)map->unsafe_erase(map->begin(), map->end());
+		});
+	});
+
+	pmem::obj::transaction::run(pop, [&] {
+		pmem::obj::delete_persistent<persistent_map_type>(map);
+	});
+}
+
+void
+verify_elements(nvobj::pool<root> &pop, int number_of_inserts)
+{
+	auto map = pop.root()->map;
+	auto map2 = pop.root()->map2;
+
+	for (int i = 0; i < number_of_inserts; i++) {
+		auto it = map->find(i);
+		auto it2 = map2->find(i);
+
+		UT_ASSERT(it->second == i);
+		UT_ASSERT(it2->second == i + 1);
+	}
+}
+
+static void
+test(int argc, char *argv[])
+{
+	if (argc < 2) {
+		UT_FATAL("usage: %s file-name", argv[0]);
+	}
+
+	const char *path = argv[1];
+
+	nvobj::pool<root> pop;
+
+	try {
+		pop = nvobj::pool<root>::create(
+			path, LAYOUT, PMEMOBJ_MIN_POOL * 20, S_IWUSR | S_IRUSR);
+	} catch (pmem::pool_error &pe) {
+		UT_FATAL("!pool::create: %s %s", pe.what(), path);
+	}
+
+	test_tx_exception(pop);
+
+	pop.close();
+}
+
+int
+main(int argc, char *argv[])
+{
+	return run_test([&] { test(argc, argv); });
+}