tests: add negative pmreorder test for atomic self relative ptr

Author: lukaszstolarczuk

tests/CMakeLists.txt

@@ -325,7 +325,9 @@ if(TEST_SELF_RELATIVE_POINTER)
 	if(PMREORDER_SUPPORTED)
 		build_test(atomic_persistent_aware_ptr_pmreorder ptr/atomic_persistent_aware_ptr_pmreorder.cpp)
 		add_test_generic(NAME atomic_persistent_aware_ptr_pmreorder CASE 0 TRACERS none
-				SCRIPT ptr/pmreorder.cmake)
+				SCRIPT ptr/atomic_pmreorder_0.cmake)
+		add_test_generic(NAME atomic_persistent_aware_ptr_pmreorder CASE 1 TRACERS none
+				SCRIPT ptr/atomic_pmreorder_1.cmake)
 	endif()
 endif()
 

tests/ptr/atomic_persistent_aware_ptr_pmreorder.cpp

@@ -19,6 +19,29 @@
 int TEST_DATA_R = 0xABBA;
 int TEST_DATA_W = 0xACDC;
 
+/* mock prepared to check negative case (simulate wrong implementation) */
+template <typename T>
+class mock_atomic_self_relative_ptr {
+public:
+	using value_type = pmem::obj::experimental::self_relative_ptr<T>;
+
+	void
+	store(value_type val)
+	{
+		ptr.store(val);
+		pmem::obj::pool_by_vptr(this).persist(&ptr, sizeof(ptr));
+	}
+
+	value_type
+	load()
+	{
+		return ptr.load();
+	}
+
+private:
+	std::atomic<pmem::obj::experimental::self_relative_ptr<T>> ptr;
+};
+
 namespace nvobj = pmem::obj;
 template <typename T>
 using self_relative_ptr = nvobj::experimental::self_relative_ptr<T>;
@@ -31,9 +54,12 @@ struct root {
 	atomic_ptr<int, std::true_type> ptr_r;
 	/* write-optimized */
 	atomic_ptr<int, std::false_type> ptr_w;
+	/* mock for negative case */
+	mock_atomic_self_relative_ptr<int> ptr_neg;
 
 	self_relative_ptr<int> read_r;
 	self_relative_ptr<int> read_w;
+	self_relative_ptr<int> read_neg;
 };
 
 void
@@ -63,6 +89,29 @@ insert_and_read(nvobj::pool<root> &pop)
 		});
 }
 
+void
+insert_and_read_mock(nvobj::pool<root> &pop)
+{
+	parallel_xexec(
+		2,
+		[&](size_t thread_id, std::function<void(void)> syncthreads) {
+			syncthreads();
+			auto r = pop.root();
+
+			if (thread_id == 0) {
+				VALGRIND_PMC_EMIT_LOG("PMREORDER_MARKER.BEGIN");
+				/* insert test data into mock atomic ptr */
+				r->ptr_neg.store(
+					reinterpret_cast<int *>(TEST_DATA_R));
+				VALGRIND_PMC_EMIT_LOG("PMREORDER_MARKER.END");
+			} else {
+				/* read test data into self relative ptr */
+				r->read_neg = r->ptr_neg.load();
+				pop.persist(r->read_neg.to_persistent_ptr());
+			}
+		});
+}
+
 void
 check_consistency(nvobj::pool<root> &pop)
 {
@@ -77,11 +126,18 @@ check_consistency(nvobj::pool<root> &pop)
 		  r->ptr_r.load().get() == r->read_r.get());
 }
 
+void
+check_consistency_mock(nvobj::pool<root> &pop)
+{
+	auto r = pop.root();
+	UT_ASSERT(r->ptr_neg.load().get() == r->read_neg.get());
+}
+
 static void
 test(int argc, char *argv[])
 {
-	if (argc != 3 || strchr("cio", argv[1][0]) == nullptr)
-		UT_FATAL("usage: %s <c|i|o> file-name", argv[0]);
+	if (argc != 3 || strchr("ciomn", argv[1][0]) == nullptr)
+		UT_FATAL("usage: %s <c|i|o|m|n> file-name", argv[0]);
 
 	const char *path = argv[2];
 
@@ -99,6 +155,7 @@ test(int argc, char *argv[])
 				pop.root()->ptr_w = nullptr;
 				pop.root()->read_r = nullptr;
 				pop.root()->read_w = nullptr;
+				pop.root()->read_neg = nullptr;
 			});
 
 		} else if (argv[1][0] == 'i') {
@@ -110,6 +167,16 @@ test(int argc, char *argv[])
 			/* re-open at the end, for consistency check */
 			pop = nvobj::pool<root>::open(path, LAYOUT);
 			check_consistency(pop);
+
+		} else if (argv[1][0] == 'm') {
+			/* mock store and load in parallel */
+			pop = nvobj::pool<root>::open(path, LAYOUT);
+			insert_and_read_mock(pop);
+
+		} else if (argv[1][0] == 'n') {
+			/* re-open at the end, for negative consistency check */
+			pop = nvobj::pool<root>::open(path, LAYOUT);
+			check_consistency_mock(pop);
 		}
 	} catch (pmem::pool_error &pe) {
 		UT_FATAL("!pool::create: %s %s", pe.what(), path);

tests/ptr/atomic_pmreorder_0.cmake

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2019-2021, Intel Corporation
+
+include(${SRC_DIR}/../helpers.cmake)
+
+setup()
+
+execute(${TEST_EXECUTABLE} c ${DIR}/testfile)
+pmreorder_create_store_log(${DIR}/testfile ${TEST_EXECUTABLE} m ${DIR}/testfile)
+# negative test, should fail, uses mock of atomic_self_relative_ptr
+pmreorder_execute(false NoReorderNoCheck "PMREORDER_MARKER=ReorderAccumulative" ${TEST_EXECUTABLE} n)
+pmreorder_execute(false NoReorderNoCheck "PMREORDER_MARKER=ReorderReverseAccumulative" ${TEST_EXECUTABLE} n)
+
+finish()