transaction.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
/* Copyright 2016-2021, Intel Corporation */
 
#ifndef LIBPMEMOBJ_CPP_TRANSACTION_HPP
#define LIBPMEMOBJ_CPP_TRANSACTION_HPP
 
#include <array>
#include <functional>
#include <string>
#include <vector>
 
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/pexceptions.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj/tx_base.h>
 
#ifndef LIBPMEMOBJ_CPP_FLAT_TX_USE_FAILURE_RETURN
#define LIBPMEMOBJ_CPP_FLAT_TX_USE_FAILURE_RETURN true
#endif
 
namespace pmem
{
 
namespace detail
{
template <typename T>
struct can_do_snapshot {
    static constexpr bool value = LIBPMEMOBJ_CPP_IS_TRIVIALLY_COPYABLE(T);
};
 
template <bool is_flat>
class transaction_base {
public:
    class manual {
    public:
        template <typename... L>
        manual(obj::pool_base &pop, L &... locks)
        {
            int ret = 0;
 
            nested = pmemobj_tx_stage() == TX_STAGE_WORK;
 
            if (nested) {
                ret = pmemobj_tx_begin(pop.handle(), nullptr,
                               TX_PARAM_NONE);
            } else if (pmemobj_tx_stage() == TX_STAGE_NONE) {
                ret = pmemobj_tx_begin(
                    pop.handle(), nullptr, TX_PARAM_CB,
                    transaction_base::c_callback, nullptr,
                    TX_PARAM_NONE);
            } else {
                throw pmem::transaction_scope_error(
                    "Cannot start transaction in stage different than WORK or NONE");
            }
 
            if (ret != 0)
                throw pmem::transaction_error(
                    "failed to start transaction")
                    .with_pmemobj_errormsg();
 
            auto err = add_lock(locks...);
 
            if (err) {
                pmemobj_tx_abort(EINVAL);
                (void)pmemobj_tx_end();
                throw pmem::transaction_error(
                    "failed to add lock")
                    .with_pmemobj_errormsg();
            }
 
            set_failure_behavior();
        }
 
        ~manual() noexcept
        {
            /* normal exit or with an active exception */
            if (pmemobj_tx_stage() == TX_STAGE_WORK) {
                if (is_flat && nested)
                    pmemobj_tx_commit();
                else
                    pmemobj_tx_abort(ECANCELED);
            }
 
            (void)pmemobj_tx_end();
        }
 
        manual(const manual &p) = delete;
 
        manual(const manual &&p) = delete;
 
        manual &operator=(const manual &p) = delete;
 
        manual &operator=(manual &&p) = delete;
 
    private:
        template <bool cnd = is_flat
                  &&LIBPMEMOBJ_CPP_FLAT_TX_USE_FAILURE_RETURN>
        typename std::enable_if<cnd>::type
        set_failure_behavior()
        {
            pmemobj_tx_set_failure_behavior(POBJ_TX_FAILURE_RETURN);
        }
 
        template <bool cnd = is_flat
                  &&LIBPMEMOBJ_CPP_FLAT_TX_USE_FAILURE_RETURN>
        typename std::enable_if<!cnd>::type
        set_failure_behavior()
        {
        }
 
        bool nested = false;
    };
 
/*
 * XXX The Microsoft compiler does not follow the ISO SD-6: SG10 Feature
 * Test Recommendations. "|| _MSC_VER >= 1900" is a workaround.
 */
#if __cpp_lib_uncaught_exceptions || _MSC_VER >= 1900
    class automatic {
    public:
        template <typename... L>
        automatic(obj::pool_base &pop, L &... locks)
            : tx_worker(pop, locks...)
        {
        }
 
        ~automatic() noexcept(false)
        {
            /* active exception, abort handled by tx_worker */
            if (exceptions.new_uncaught_exception())
                return;
 
            /* transaction ended normally */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_commit();
            /* transaction aborted, throw an exception */
            else if (pmemobj_tx_stage() == TX_STAGE_ONABORT ||
                 (pmemobj_tx_stage() == TX_STAGE_FINALLY &&
                  pmemobj_tx_errno() != 0))
                throw pmem::transaction_error(
                    "Transaction aborted");
        }
 
        automatic(const automatic &p) = delete;
 
        automatic(const automatic &&p) = delete;
 
        automatic &operator=(const automatic &p) = delete;
 
        automatic &operator=(automatic &&p) = delete;
 
    private:
        class uncaught_exception_counter {
        public:
            uncaught_exception_counter()
                : count(std::uncaught_exceptions())
            {
            }
 
            bool
            new_uncaught_exception()
            {
                return std::uncaught_exceptions() > this->count;
            }
 
        private:
            int count;
        } exceptions;
 
        manual tx_worker;
    };
#endif /* __cpp_lib_uncaught_exceptions */
 
    /*
     * Deleted default constructor.
     */
    transaction_base() = delete;
 
    ~transaction_base() noexcept = delete;
 
    static void
    abort(int err)
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_error("wrong stage for abort");
 
        pmemobj_tx_abort(err);
        throw pmem::manual_tx_abort("explicit abort " +
                        std::to_string(err));
    }
 
    static void
    commit()
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_error("wrong stage for commit");
 
        pmemobj_tx_commit();
    }
 
    static int
    error() noexcept
    {
        return pmemobj_tx_errno();
    }
 
    POBJ_CPP_DEPRECATED static int
    get_last_tx_error() noexcept
    {
        return error();
    }
 
    template <typename... Locks>
    static void
    run(obj::pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        manual worker(pool, locks...);
 
        tx();
 
        auto stage = pmemobj_tx_stage();
 
        if (stage == TX_STAGE_WORK) {
            pmemobj_tx_commit();
        } else if (stage == TX_STAGE_ONABORT) {
            throw pmem::transaction_error("transaction aborted");
        } else if (stage == TX_STAGE_NONE) {
            throw pmem::transaction_error(
                "transaction ended prematurely");
        }
    }
 
    template <typename... Locks>
    POBJ_CPP_DEPRECATED static void
    exec_tx(obj::pool_base &pool, std::function<void()> tx,
        Locks &... locks)
    {
        run(pool, tx, locks...);
    }
 
    template <typename T,
          typename std::enable_if<detail::can_do_snapshot<T>::value,
                      T>::type * = nullptr>
    static void
    snapshot(const T *addr, size_t num = 1)
    {
        if (TX_STAGE_WORK != pmemobj_tx_stage())
            throw pmem::transaction_error(
                "wrong stage for taking a snapshot.");
 
        if (pmemobj_tx_add_range_direct(addr, sizeof(*addr) * num)) {
            if (errno == ENOMEM)
                throw pmem::transaction_out_of_memory(
                    "Could not take a snapshot of given memory range.")
                    .with_pmemobj_errormsg();
            else
                throw pmem::transaction_error(
                    "Could not take a snapshot of given memory range.")
                    .with_pmemobj_errormsg();
        }
    }
 
    enum class stage {
        work = TX_STAGE_WORK,         
        oncommit = TX_STAGE_ONCOMMIT, 
        onabort = TX_STAGE_ONABORT, 
        finally = TX_STAGE_FINALLY, 
    };
 
    static void
    register_callback(stage stg, std::function<void()> cb)
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw pmem::transaction_scope_error(
                "register_callback must be called during a transaction");
 
        get_tx_data()->callbacks[static_cast<size_t>(stg)].push_back(
            cb);
    }
 
private:
    template <typename L, typename... Locks>
    static int
    add_lock(L &lock, Locks &... locks) noexcept
    {
        auto err =
            pmemobj_tx_lock(lock.lock_type(), lock.native_handle());
 
        if (err)
            return err;
 
        return add_lock(locks...);
    }
 
    static inline int
    add_lock() noexcept
    {
        return 0;
    }
 
    using callbacks_list_type = std::vector<std::function<void()>>;
    using callbacks_map_type =
        std::array<callbacks_list_type, MAX_TX_STAGE>;
 
    static void
    c_callback(PMEMobjpool *pop, enum pobj_tx_stage obj_stage, void *arg)
    {
        /*
         * We cannot do anything when in TX_STAGE_NONE because
         * pmemobj_tx_get_user_data() can only be called when there is
         * an active transaction.
         */
        if (obj_stage == TX_STAGE_NONE)
            return;
 
        auto *data = static_cast<tx_data *>(pmemobj_tx_get_user_data());
        if (data == nullptr)
            return;
 
        for (auto &cb : data->callbacks[obj_stage])
            cb();
 
        /*
         * Callback for TX_STAGE_FINALLY is called as the last one so we
         * can free tx_data here
         */
        if (obj_stage == TX_STAGE_FINALLY) {
            delete data;
            pmemobj_tx_set_user_data(NULL);
        }
    }
 
    struct tx_data {
        callbacks_map_type callbacks;
    };
 
    static tx_data *
    get_tx_data()
    {
        auto *data = static_cast<tx_data *>(pmemobj_tx_get_user_data());
        if (data == nullptr) {
            data = new tx_data;
            pmemobj_tx_set_user_data(data);
        }
 
        return data;
    }
};
 
} /* namespace detail */
 
namespace obj
{
 
class basic_transaction : public detail::transaction_base<false> {
public:
    using manual = typename detail::transaction_base<false>::manual;
 
/*
 * XXX The Microsoft compiler does not follow the ISO SD-6: SG10 Feature
 * Test Recommendations. "|| _MSC_VER >= 1900" is a workaround.
 */
#if __cpp_lib_uncaught_exceptions || _MSC_VER >= 1900
    using automatic = typename detail::transaction_base<false>::automatic;
#endif /* __cpp_lib_uncaught_exceptions */
    template <typename... Locks>
    static void
    run(obj::pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        detail::transaction_base<false>::run(pool, tx, locks...);
    }
 
    /*
     * Deleted default constructor.
     */
    basic_transaction() = delete;
 
    ~basic_transaction() noexcept = delete;
};
 
class flat_transaction : public detail::transaction_base<true> {
public:
    using manual = typename detail::transaction_base<true>::manual;
 
/*
 * XXX The Microsoft compiler does not follow the ISO SD-6: SG10 Feature
 * Test Recommendations. "|| _MSC_VER >= 1900" is a workaround.
 */
#if __cpp_lib_uncaught_exceptions || _MSC_VER >= 1900
    using automatic = typename detail::transaction_base<true>::automatic;
#endif /* __cpp_lib_uncaught_exceptions */
    template <typename... Locks>
    static void
    run(obj::pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        detail::transaction_base<true>::run(pool, tx, locks...);
    }
 
    /*
     * Deleted default constructor.
     */
    flat_transaction() = delete;
 
    ~flat_transaction() noexcept = delete;
};
 
#ifdef LIBPMEMOBJ_CPP_USE_FLAT_TRANSACTION
using transaction = flat_transaction;
#else
using transaction = basic_transaction;
#endif
 
} /* namespace obj */
 
} /* namespace pmem */
 
#endif /* LIBPMEMOBJ_CPP_TRANSACTION_HPP */