NVML C++ bindings  1.0.0
This is the C++ bindings documentation for NVML's libpmemobj.
 All Classes Files Functions Variables Typedefs Pages
Functions
make_persistent_array_atomic.hpp File Reference

Atomic persistent_ptr allocation functions for arrays. More...

#include "libpmemobj++/detail/array_traits.hpp"
#include "libpmemobj++/detail/check_persistent_ptr_array.hpp"
#include "libpmemobj++/detail/common.hpp"
#include "libpmemobj++/detail/make_atomic_impl.hpp"
#include "libpmemobj++/detail/pexceptions.hpp"
#include "libpmemobj/atomic_base.h"

Go to the source code of this file.

Functions

template<typename T >
void nvml::obj::make_persistent_atomic (pool_base &pool, typename detail::pp_if_array< T >::type &ptr, std::size_t N)
 Atomically allocate an array of objects. More...
 
template<typename T >
void nvml::obj::make_persistent_atomic (pool_base &pool, typename detail::pp_if_size_array< T >::type &ptr)
 Atomically allocate an array of objects. More...
 
template<typename T >
void nvml::obj::delete_persistent_atomic (typename detail::pp_if_array< T >::type &ptr, std::size_t N)
 Atomically deallocate an array of objects. More...
 
template<typename T >
void nvml::obj::delete_persistent_atomic (typename detail::pp_if_size_array< T >::type &ptr)
 Atomically deallocate an array of objects. More...
 

Detailed Description

Atomic persistent_ptr allocation functions for arrays.

The typical usage examples would be:

#include <fcntl.h>
using namespace nvml::obj;
void
make_persistent_array_atomic_example()
{
struct compound_type {
compound_type() : some_variable(0), some_other_variable(0)
{
}
void
set_some_variable(int val)
{
some_variable = val;
}
p<int> some_variable;
p<double> some_other_variable;
};
// pool root structure
struct root {
};
// create a pmemobj pool
auto pop = pool<root>::create("poolfile", "layout", PMEMOBJ_MIN_POOL);
auto proot = pop.get_root();
// typical usage schemes
// atomic array allocation and construction - the compound_type has to
// be default constructible
make_persistent_atomic<compound_type[]>(pop, proot->comp, 20);
make_persistent_atomic<compound_type[42]>(pop, arr);
// atomic array deallocation, no destructor being called
delete_persistent_atomic<compound_type[]>(proot->comp, 20);
delete_persistent_atomic<compound_type[42]>(arr);
// error prone cases
transaction::exec_tx(pop, [&] {
// possible invalid state in case of transaction abort
make_persistent_atomic<compound_type[]>(pop, proot->comp, 30);
delete_persistent_atomic<compound_type[]>(proot->comp, 30);
});
}