Skip to content
This repository was archived by the owner on Mar 22, 2023. It is now read-only.

Commit 9a64acf

Browse files
author
Pawel Karczewski
committed
Remove nvobj term from examples
This is cosmetic change, made mostly to simplify copy-pasting from documentation.
1 parent a953b16 commit 9a64acf

File tree

2 files changed

+64
-69
lines changed

2 files changed

+64
-69
lines changed

‎examples/map_cli/ctree_map_persistent.hpp‎

Lines changed: 45 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
// SPDX-License-Identifier: BSD-3-Clause
2-
/* Copyright 2016-2018, Intel Corporation */
2+
/* Copyright 2016-2021, Intel Corporation */
33

44
#ifndef LIBPMEMOBJ_CPP_EXAMPLES_CTREE_MAP_PERSISTENT_HPP
55
#define LIBPMEMOBJ_CPP_EXAMPLES_CTREE_MAP_PERSISTENT_HPP
@@ -19,8 +19,6 @@
1919

2020
#define BIT_IS_SET(n, i) (!!((n) & (1ULL << (i))))
2121

22-
namespace nvobj = pmem::obj;
23-
2422
namespace examples
2523
{
2624

@@ -38,7 +36,7 @@ class ctree_map_p {
3836
typedef K key_type;
3937

4038
/** Convenience typedef for the value type. */
41-
typedef nvobj::persistent_ptr<T> value_type;
39+
typedef pmem::obj::persistent_ptr<T> value_type;
4240

4341
/** Convenience typedef for the callback function. */
4442
typedef std::function<int(key_type, value_type, void *)> callback;
@@ -48,10 +46,10 @@ class ctree_map_p {
4846
*/
4947
ctree_map_p()
5048
{
51-
auto pop = nvobj::pool_by_vptr(this);
49+
auto pop = pmem::obj::pool_by_vptr(this);
5250

53-
nvobj::transaction::run(pop, [&] {
54-
this->root = nvobj::make_persistent<entry>();
51+
pmem::obj::transaction::run(pop, [&] {
52+
this->root = pmem::obj::make_persistent<entry>();
5553
});
5654
}
5755

@@ -79,10 +77,11 @@ class ctree_map_p {
7977
}
8078

8179
entry e(key, value);
82-
auto pop = nvobj::pool_by_vptr(this);
83-
nvobj::transaction::run(pop, [&] {
80+
auto pop = pmem::obj::pool_by_vptr(this);
81+
pmem::obj::transaction::run(pop, [&] {
8482
if (dest_entry->key == 0 || dest_entry->key == key) {
85-
nvobj::delete_persistent<T>(dest_entry->value);
83+
pmem::obj::delete_persistent<T>(
84+
dest_entry->value);
8685
*dest_entry = e;
8786
} else {
8887
insert_leaf(
@@ -109,9 +108,10 @@ class ctree_map_p {
109108
int
110109
insert_new(key_type key, const Args &... args)
111110
{
112-
auto pop = nvobj::pool_by_vptr(this);
113-
nvobj::transaction::run(pop, [&] {
114-
return insert(key, nvobj::make_persistent<T>(args...));
111+
auto pop = pmem::obj::pool_by_vptr(this);
112+
pmem::obj::transaction::run(pop, [&] {
113+
return insert(key,
114+
pmem::obj::make_persistent<T>(args...));
115115
});
116116

117117
return -1;
@@ -129,16 +129,16 @@ class ctree_map_p {
129129
value_type
130130
remove(key_type key)
131131
{
132-
nvobj::persistent_ptr<entry> parent = nullptr;
132+
pmem::obj::persistent_ptr<entry> parent = nullptr;
133133
auto leaf = get_leaf(key, &parent);
134134

135135
if (leaf == nullptr)
136136
return nullptr;
137137

138138
auto ret = leaf->value;
139139

140-
auto pop = nvobj::pool_by_vptr(this);
141-
nvobj::transaction::run(pop, [&] {
140+
auto pop = pmem::obj::pool_by_vptr(this);
141+
pmem::obj::transaction::run(pop, [&] {
142142
if (parent == nullptr) {
143143
leaf->key = 0;
144144
leaf->value = nullptr;
@@ -149,9 +149,11 @@ class ctree_map_p {
149149
->key == leaf->key]);
150150

151151
/* cleanup entries and the unnecessary node */
152-
nvobj::delete_persistent<entry>(n->entries[0]);
153-
nvobj::delete_persistent<entry>(n->entries[1]);
154-
nvobj::delete_persistent<node>(n);
152+
pmem::obj::delete_persistent<entry>(
153+
n->entries[0]);
154+
pmem::obj::delete_persistent<entry>(
155+
n->entries[1]);
156+
pmem::obj::delete_persistent<node>(n);
155157
}
156158
});
157159

@@ -168,9 +170,10 @@ class ctree_map_p {
168170
int
169171
remove_free(key_type key)
170172
{
171-
auto pop = nvobj::pool_by_vptr(this);
172-
nvobj::transaction::run(
173-
pop, [&] { nvobj::delete_persistent<T>(remove(key)); });
173+
auto pop = pmem::obj::pool_by_vptr(this);
174+
pmem::obj::transaction::run(pop, [&] {
175+
pmem::obj::delete_persistent<T>(remove(key));
176+
});
174177
return 0;
175178
}
176179

@@ -180,16 +183,16 @@ class ctree_map_p {
180183
int
181184
clear()
182185
{
183-
auto pop = nvobj::pool_by_vptr(this);
184-
nvobj::transaction::run(pop, [&] {
186+
auto pop = pmem::obj::pool_by_vptr(this);
187+
pmem::obj::transaction::run(pop, [&] {
185188
if (this->root->inode) {
186189
this->root->inode->clear();
187-
nvobj::delete_persistent<node>(
190+
pmem::obj::delete_persistent<node>(
188191
this->root->inode);
189192
this->root->inode = nullptr;
190193
}
191194

192-
nvobj::delete_persistent<T>(this->root->value);
195+
pmem::obj::delete_persistent<T>(this->root->value);
193196
this->root->value = nullptr;
194197
this->root->key = 0;
195198
});
@@ -286,19 +289,19 @@ class ctree_map_p {
286289
{
287290
}
288291

289-
nvobj::p<key_type> key;
290-
nvobj::persistent_ptr<node> inode;
292+
pmem::obj::p<key_type> key;
293+
pmem::obj::persistent_ptr<node> inode;
291294
value_type value;
292295

293296
void
294297
clear()
295298
{
296299
if (inode) {
297300
inode->clear();
298-
nvobj::delete_persistent<node>(inode);
301+
pmem::obj::delete_persistent<node>(inode);
299302
inode = nullptr;
300303
}
301-
nvobj::delete_persistent<T>(value);
304+
pmem::obj::delete_persistent<T>(value);
302305
value = nullptr;
303306
}
304307
};
@@ -313,20 +316,20 @@ class ctree_map_p {
313316
entries[1] = nullptr;
314317
}
315318

316-
nvobj::p<int> diff; /* most significant differing bit */
317-
nvobj::persistent_ptr<entry> entries[2];
319+
pmem::obj::p<int> diff; /* most significant differing bit */
320+
pmem::obj::persistent_ptr<entry> entries[2];
318321

319322
void
320323
clear()
321324
{
322325
if (entries[0]) {
323326
entries[0]->clear();
324-
nvobj::delete_persistent<entry>(entries[0]);
327+
pmem::obj::delete_persistent<entry>(entries[0]);
325328
entries[0] = nullptr;
326329
}
327330
if (entries[1]) {
328331
entries[1]->clear();
329-
nvobj::delete_persistent<entry>(entries[1]);
332+
pmem::obj::delete_persistent<entry>(entries[1]);
330333
entries[1] = nullptr;
331334
}
332335
}
@@ -347,11 +350,11 @@ class ctree_map_p {
347350
void
348351
insert_leaf(const entry *e, int diff)
349352
{
350-
auto new_node = nvobj::make_persistent<node>();
353+
auto new_node = pmem::obj::make_persistent<node>();
351354
new_node->diff = diff;
352355

353356
int d = BIT_IS_SET(e->key, new_node->diff);
354-
new_node->entries[d] = nvobj::make_persistent<entry>(*e);
357+
new_node->entries[d] = pmem::obj::make_persistent<entry>(*e);
355358

356359
auto dest_entry = root;
357360
while (dest_entry->inode != nullptr) {
@@ -363,7 +366,7 @@ class ctree_map_p {
363366
}
364367

365368
new_node->entries[!d] =
366-
nvobj::make_persistent<entry>(*dest_entry);
369+
pmem::obj::make_persistent<entry>(*dest_entry);
367370
dest_entry->key = 0;
368371
dest_entry->inode = new_node;
369372
dest_entry->value = nullptr;
@@ -372,11 +375,11 @@ class ctree_map_p {
372375
/*
373376
* Fetch leaf from the tree.
374377
*/
375-
nvobj::persistent_ptr<entry>
376-
get_leaf(key_type key, nvobj::persistent_ptr<entry> *parent)
378+
pmem::obj::persistent_ptr<entry>
379+
get_leaf(key_type key, pmem::obj::persistent_ptr<entry> *parent)
377380
{
378381
auto n = root;
379-
nvobj::persistent_ptr<entry> p = nullptr;
382+
pmem::obj::persistent_ptr<entry> p = nullptr;
380383

381384
while (n->inode != nullptr) {
382385
p = n;
@@ -397,7 +400,7 @@ class ctree_map_p {
397400
* Recursive foreach on nodes.
398401
*/
399402
int
400-
foreach_node(const nvobj::persistent_ptr<entry> e, callback clb,
403+
foreach_node(const pmem::obj::persistent_ptr<entry> e, callback clb,
401404
void *arg)
402405
{
403406
int ret = 0;
@@ -414,7 +417,7 @@ class ctree_map_p {
414417
}
415418

416419
/* Tree root */
417-
nvobj::persistent_ptr<entry> root;
420+
pmem::obj::persistent_ptr<entry> root;
418421
};
419422

420423
} /* namespace examples */

‎examples/mutex/mutex.cpp‎

Lines changed: 19 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
// SPDX-License-Identifier: BSD-3-Clause
2-
/* Copyright 2016-2020, Intel Corporation */
2+
/* Copyright 2016-2021, Intel Corporation */
33

44
/*
55
* mutex.cpp -- C++ documentation snippets.
@@ -12,25 +12,23 @@
1212
#include <libpmemobj++/pool.hpp>
1313
#include <mutex>
1414

15-
namespace nvobj = pmem::obj;
16-
1715
void
1816
unique_guard_example()
1917
{
2018
/* pool root structure */
2119
struct root {
22-
nvobj::mutex pmutex;
20+
pmem::obj::mutex pmutex;
2321
};
2422

2523
/* create a pmemobj pool */
26-
auto pop = nvobj::pool<root>::create("poolfile", "layout",
27-
PMEMOBJ_MIN_POOL);
24+
auto pop = pmem::obj::pool<root>::create("poolfile", "layout",
25+
PMEMOBJ_MIN_POOL);
2826
auto proot = pop.root();
2927

3028
/* typical usage schemes */
31-
std::lock_guard<nvobj::mutex> guard(proot->pmutex);
29+
std::lock_guard<pmem::obj::mutex> guard(proot->pmutex);
3230

33-
std::unique_lock<nvobj::mutex> other_guard(proot->pmutex);
31+
std::unique_lock<pmem::obj::mutex> other_guard(proot->pmutex);
3432
}
3533
//! [unique_guard_example]
3634

@@ -40,25 +38,23 @@ unique_guard_example()
4038
#include <libpmemobj++/shared_mutex.hpp>
4139
#include <mutex>
4240

43-
namespace nvobj = pmem::obj;
44-
4541
void
4642
shared_mutex_example()
4743
{
4844
/* pool root structure */
4945
struct root {
50-
nvobj::shared_mutex pmutex;
46+
pmem::obj::shared_mutex pmutex;
5147
};
5248

5349
/* create a pmemobj pool */
54-
auto pop = nvobj::pool<root>::create("poolfile", "layout",
55-
PMEMOBJ_MIN_POOL);
50+
auto pop = pmem::obj::pool<root>::create("poolfile", "layout",
51+
PMEMOBJ_MIN_POOL);
5652
auto proot = pop.root();
5753

5854
/* typical usage schemes */
5955
proot->pmutex.lock_shared();
6056

61-
std::unique_lock<nvobj::shared_mutex> guard(proot->pmutex);
57+
std::unique_lock<pmem::obj::shared_mutex> guard(proot->pmutex);
6258
}
6359
//! [shared_mutex_example]
6460

@@ -68,19 +64,17 @@ shared_mutex_example()
6864
#include <libpmemobj++/pool.hpp>
6965
#include <libpmemobj++/timed_mutex.hpp>
7066

71-
namespace nvobj = pmem::obj;
72-
7367
void
7468
timed_mutex_example()
7569
{
7670
/* pool root structure */
7771
struct root {
78-
nvobj::timed_mutex pmutex;
72+
pmem::obj::timed_mutex pmutex;
7973
};
8074

8175
/* create a pmemobj pool */
82-
auto pop = nvobj::pool<root>::create("poolfile", "layout",
83-
PMEMOBJ_MIN_POOL);
76+
auto pop = pmem::obj::pool<root>::create("poolfile", "layout",
77+
PMEMOBJ_MIN_POOL);
8478
auto proot = pop.root();
8579

8680
const auto timeout = std::chrono::milliseconds(100);
@@ -101,27 +95,25 @@ timed_mutex_example()
10195
#include <mutex>
10296
#include <thread>
10397

104-
namespace nvobj = pmem::obj;
105-
10698
void
10799
cond_var_example()
108100
{
109101
/* pool root structure */
110102
struct root {
111-
nvobj::mutex pmutex;
112-
nvobj::condition_variable cond;
103+
pmem::obj::mutex pmutex;
104+
pmem::obj::condition_variable cond;
113105
int counter;
114106
};
115107

116108
/* create a pmemobj pool */
117-
auto pop = nvobj::pool<root>::create("poolfile", "layout",
118-
PMEMOBJ_MIN_POOL);
109+
auto pop = pmem::obj::pool<root>::create("poolfile", "layout",
110+
PMEMOBJ_MIN_POOL);
119111

120112
auto proot = pop.root();
121113

122114
/* run worker to bump up the counter */
123115
std::thread worker([&] {
124-
std::unique_lock<nvobj::mutex> lock(proot->pmutex);
116+
std::unique_lock<pmem::obj::mutex> lock(proot->pmutex);
125117
while (proot->counter < 1000)
126118
++proot->counter;
127119
/* unlock before notifying to avoid blocking on waiting thread
@@ -131,7 +123,7 @@ cond_var_example()
131123
proot->cond.notify_one();
132124
});
133125

134-
std::unique_lock<nvobj::mutex> lock(proot->pmutex);
126+
std::unique_lock<pmem::obj::mutex> lock(proot->pmutex);
135127
/* wait on condition variable */
136128
proot->cond.wait(lock, [&] { return proot->counter >= 1000; });
137129

0 commit comments

Comments
 (0)