make_persistent_atomic.hpp File Reference

Persistent_ptr atomic allocation functions for objects. More...

#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++/pool.hpp>
#include <libpmemobj/atomic_base.h>
#include <tuple>

Go to the source code of this file.

Functions
template<typename T , typename... Args>
void	pmem::obj::make_persistent_atomic (pool_base &pool, typename detail::pp_if_not_array< T >::type &ptr, Args &&... args)
	Atomically allocate and construct an object. More...
template<typename T >
void	pmem::obj::delete_persistent_atomic (typename detail::pp_if_not_array< T >::type &ptr) noexcept
	Atomically deallocate an object. More...

Detailed Description

Persistent_ptr atomic allocation functions for objects.

The typical usage examples would be:

#include <fcntl.h>
#include <libpmemobj++/make_persistent_atomic.hpp>
#include <libpmemobj++/p.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>
 
using namespace pmem::obj;
 
void
make_persistent_atomic_example()
{
 
    struct compound_type {
 
        compound_type(int val, double dval)
            : some_variable(val), some_other_variable(dval)
        {
        }
 
        void
        set_some_variable(int val)
        {
            some_variable = val;
        }
 
        p<int> some_variable;
        p<double> some_other_variable;
    };
 
    // pool root structure
    struct root {
        persistent_ptr<compound_type> comp; //
    };
 
    // create a pmemobj pool
    auto pop = pool<root>::create("poolfile", "layout", PMEMOBJ_MIN_POOL);
    auto proot = pop.root();
 
    // typical usage schemes
 
    // atomic allocation and construction with arguments passing
    make_persistent_atomic<compound_type>(pop, proot->comp, 1, 2.0);
 
    // atomic object deallocation, ~compound_type() is not called
    delete_persistent<compound_type>(proot->comp);
 
    // error prone cases
    transaction::run(pop, [&] {
        // possible invalid state in case of transaction abort
        make_persistent_atomic<compound_type>(pop, proot->comp, 1, 1.3);
        delete_persistent_atomic<compound_type>(proot->comp);
    });
}

Function Documentation

delete_persistent_atomic()

template<typename T >

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

noexcept

Atomically deallocate an object.

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()

template<typename T , typename... Args>

void pmem::obj::make_persistent_atomic	(	pool_base &	pool,
		typename detail::pp_if_not_array< T >::type &	ptr,
		Args &&...	args
	)

Atomically allocate and construct an object.

Constructor parameters are passed through variadic parameters. Do NOT use this inside transactions, as it might lead to undefined behavior in the presence of transaction aborts.

Parameters

[in,out]	pool	the pool from which the object will be allocated.
[in,out]	ptr	the persistent pointer to which the allocation will take place.
[in]	args	variadic function parameter containing all parameters passed to the objects constructor.

Exceptions

std::bad_alloc

on allocation failure.