libpmemobj-cpp/benchmarks/self_relative_pointer/get.cpp at d561afdd16d1a8ce176a71e0b77c8e7f3c8c9097 · pmem/libpmemobj-cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2020, Intel Corporation */

/*
 * get.cpp -- this simple benchmark is used to measure time of getting and
 * changing a specified number of elements from a persistent array using
 * self_relative_ptr and persistent_ptr
 */

#include <cassert>
#include <iostream>

#include <libpmemobj++/experimental/self_relative_ptr.hpp>
#include <libpmemobj++/make_persistent.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>

#include "../measure.hpp"

#ifndef _WIN32

#include <unistd.h>
#define CREATE_MODE_RW (S_IWUSR | S_IRUSR)

#else

#include <windows.h>
#define CREATE_MODE_RW (S_IWRITE | S_IREAD)

#endif

static const std::string LAYOUT = "get";

using value_type = int[];

constexpr int ARR_SIZE = 10000000;

struct root {
	pmem::obj::persistent_ptr<value_type> pptr;
};

pmem::obj::persistent_ptr<value_type>
prepare_array(pmem::obj::pool_base &pop, int arr_size)
{
	pmem::obj::persistent_ptr<value_type> parr;

	pmem::obj::transaction::run(pop, [&] {
		parr = pmem::obj::make_persistent<value_type>(
			static_cast<std::size_t>(arr_size));
	});

	for (int i = 0; i < arr_size; ++i) {
		parr[i] = i;
	}

	return parr;
}

int
main(int argc, char *argv[])
{
	using pool = pmem::obj::pool<root>;
	pool pop;

	if (argc != 2) {
		std::cerr << "usage: " << argv[0] << " file-name" << std::endl;
		return 1;
	}

	const char *path = argv[1];

	try {
		try {
			pop = pool::create(path, LAYOUT, PMEMOBJ_MIN_POOL * 20,
					   CREATE_MODE_RW);
		} catch (const pmem::pool_error &pe) {
			pop = pool::open(path, LAYOUT);
		}

		auto root = pop.root();
		root->pptr = prepare_array(pop, ARR_SIZE);

		pmem::obj::persistent_ptr<value_type> pptr = root->pptr;
		pmem::obj::experimental::self_relative_ptr<value_type,
							   std::false_type>
			offset_ptr = root->pptr;
		int *vptr = root->pptr.get();

		std::cout << "Run time volatile ptr "
			  << measure<std::chrono::milliseconds>([&] {
				     for (int i = 0; i < ARR_SIZE; i++) {
					     vptr[i] += 1;
				     }
			     })
			  << "ms" << std::endl;

		std::cout << "Run time self-relative ptr "
			  << measure<std::chrono::milliseconds>([&] {
				     for (int i = 0; i < ARR_SIZE; i++) {
					     offset_ptr[i] += 1;
				     }
			     })
			  << "ms" << std::endl;

		std::cout << "Run time persistent ptr "
			  << measure<std::chrono::milliseconds>([&] {
				     for (int i = 0; i < ARR_SIZE; i++) {
					     pptr[i] += 1;
				     }
			     })
			  << "ms" << std::endl;

		pmem::obj::transaction::run(pop, [&] {
			pmem::obj::delete_persistent<value_type>(
				pop.root()->pptr, ARR_SIZE);
		});

		pop.close();
	} catch (const pmem::pool_error &pe) {
		std::cerr << "!pool::create: " << pe.what() << " " << path
			  << std::endl;
		return 1;
	} catch (const std::logic_error &e) {
		std::cerr << "!pool::close: " << e.what() << std::endl;
		return 1;
	} catch (const std::exception &e) {
		std::cerr << "!exception: " << e.what() << std::endl;
		try {
			pmem::obj::transaction::run(pop, [&] {
				pmem::obj::delete_persistent<value_type>(
					pop.root()->pptr, ARR_SIZE);
			});

			pop.close();
		} catch (const pmem::transaction_error &e) {
			std::cerr << "!transaction::run: " << e.what()
				  << std::endl;
		} catch (const std::logic_error &e) {
			std::cerr << "!pool::close: " << e.what() << std::endl;
		}
		return 1;
	}
	return 0;
}