PMDK C++ bindings  1.7
This is the C++ bindings documentation for PMDK's libpmemobj.
Functions
make_persistent_array_atomic.hpp File Reference

Atomic persistent_ptr allocation functions for arrays. More...

#include <libpmemobj++/allocation_flag.hpp>
#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++/detail/variadic.hpp>
#include <libpmemobj/atomic_base.h>

Go to the source code of this file.

Functions

template<typename T >
void pmem::obj::make_persistent_atomic (pool_base &pool, typename detail::pp_if_array< T >::type &ptr, std::size_t N, allocation_flag_atomic flag=allocation_flag_atomic::none())
 Atomically allocate an array of objects. More...
 
template<typename T >
void pmem::obj::make_persistent_atomic (pool_base &pool, typename detail::pp_if_size_array< T >::type &ptr, allocation_flag_atomic flag=allocation_flag_atomic::none())
 Atomically allocate an array of objects. More...
 
template<typename T >
void pmem::obj::delete_persistent_atomic (typename detail::pp_if_array< T >::type &ptr, std::size_t)
 Atomically deallocate an array of objects. More...
 
template<typename T >
void pmem::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 pmem::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.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::run(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);
});
}

Function Documentation

◆ delete_persistent_atomic() [1/2]

template<typename T >
void pmem::obj::delete_persistent_atomic ( typename detail::pp_if_array< T >::type &  ptr,
std::size_t   
)

Atomically deallocate an array of objects.

There is no way to atomically destroy an object. Any object specific cleanup must be performed elsewhere. Do NOT use this inside transactions, as it might lead to undefined behavior in the presence of transaction aborts.

param[in,out] ptr the persistent_ptr whose pointee is to be deallocated.

◆ delete_persistent_atomic() [2/2]

template<typename T >
void pmem::obj::delete_persistent_atomic ( typename detail::pp_if_size_array< T >::type &  ptr)

Atomically deallocate an array of objects.

There is no way to atomically destroy an object. Any object specific cleanup must be performed elsewhere. Do NOT use this inside transactions, as it might lead to undefined behavior in the presence of transaction aborts.

param[in,out] ptr the persistent_ptr whose pointee is to be deallocated.

◆ make_persistent_atomic() [1/2]

template<typename T >
void pmem::obj::make_persistent_atomic ( pool_base pool,
typename detail::pp_if_array< T >::type &  ptr,
std::size_t  N,
allocation_flag_atomic  flag = allocation_flag_atomic::none() 
)

Atomically allocate an array of objects.

This function can be used to atomically allocate an array of objects. Cannot be used for simple objects. Do NOT use this inside transactions, as it might lead to undefined behavior in the presence of transaction aborts.

Parameters
[in,out]poolthe pool from which the object will be allocated.
[in,out]ptrthe persistent pointer to which the allocation will take place.
[in]Nthe number of array elements.
[in]flagaffects behaviour of allocator
Exceptions
std::bad_allocon allocation failure.

◆ make_persistent_atomic() [2/2]

template<typename T >
void pmem::obj::make_persistent_atomic ( pool_base pool,
typename detail::pp_if_size_array< T >::type &  ptr,
allocation_flag_atomic  flag = allocation_flag_atomic::none() 
)

Atomically allocate an array of objects.

This function can be used to atomically allocate an array of objects. Cannot be used for simple objects. Do NOT use this inside transactions, as it might lead to undefined behavior in the presence of transaction aborts.

Parameters
[in,out]poolthe pool from which the object will be allocated.
[in,out]ptrthe persistent pointer to which the allocation will take place.
[in]flagaffects behaviour of allocator
Exceptions
std::bad_allocon allocation failure.
pmem::obj::pool::create
static pool< T > create(const std::string &path, const std::string &layout, std::size_t size=PMEMOBJ_MIN_POOL, mode_t mode=DEFAULT_MODE)
Creates a new transactional object store pool.
Definition: pool.hpp:641
make_persistent_array_atomic.hpp
Atomic persistent_ptr allocation functions for arrays.
pmem::obj::p
Resides on pmem class.
Definition: p.hpp:64
pool.hpp
C++ pmemobj pool.
pmem::obj::transaction::run
static void run(pool_base &pool, std::function< void()> tx, Locks &... locks)
Execute a closure-like transaction and lock locks.
Definition: transaction.hpp:398
transaction.hpp
C++ pmemobj transactions.
pmem::obj::persistent_ptr
Persistent pointer class.
Definition: persistent_ptr.hpp:132
p.hpp
Resides on pmem property template.
persistent_ptr.hpp
Persistent smart pointer.