transaction.hpp

Go to the documentation of this file.

/*
 * Copyright 2016, Intel Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 *     * Neither the name of the copyright holder nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef LIBPMEMOBJ_TRANSACTION_HPP
#define LIBPMEMOBJ_TRANSACTION_HPP

#include <functional>
#include <string>

#include "libpmemobj++/detail/pexceptions.hpp"
#include "libpmemobj++/pool.hpp"
#include "libpmemobj/tx_base.h"

namespace nvml
{

namespace obj
{

class transaction {
public:
    class manual {
    public:
        template <typename... L>
        manual(obj::pool_base &pop, L &... locks)
        {
            if (pmemobj_tx_begin(pop.get_handle(), NULL,
                         TX_LOCK_NONE) != 0)
                throw transaction_error(
                    "failed to start transaction");

            auto err = add_lock(locks...);

            if (err) {
                pmemobj_tx_abort(EINVAL);
                throw transaction_error("failed to"
                            " add lock");
            }
        }

        ~manual() noexcept
        {
            /* normal exit or with an active exception */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_abort(ECANCELED);

            pmemobj_tx_end();
        }

        manual(const manual &p) = delete;

        manual(const manual &&p) = delete;

        manual &operator=(const manual &p) = delete;

        manual &operator=(manual &&p) = delete;
    };

/*
 * 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)
        {
            if (pmemobj_tx_begin(pop.get_handle(), NULL,
                         TX_LOCK_NONE) != 0)
                throw transaction_error(
                    "failed to start transaction");

            auto err = add_lock(locks...);

            if (err) {
                pmemobj_tx_abort(EINVAL);
                throw transaction_error("failed to add"
                            " lock");
            }
        }

        ~automatic() noexcept
        {
            /* manual abort or commit end transaction */
            if (pmemobj_tx_stage() != TX_STAGE_WORK) {
                pmemobj_tx_end();
                return;
            }

            if (this->exceptions.new_uncaught_exception())
                /* exit with an active exception */
                pmemobj_tx_abort(ECANCELED);
            else
                /* normal exit commit tx */
                pmemobj_tx_commit();

            pmemobj_tx_end();
        }

        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;
    };
#endif /* __cpp_lib_uncaught_exceptions */

    /*
     * Deleted default constructor.
     */
    transaction() = delete;

    ~transaction() noexcept = delete;

    static void
    abort(int err)
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw transaction_error("wrong stage for"
                        " abort");

        pmemobj_tx_abort(err);
        throw manual_tx_abort("explicit abort " + std::to_string(err));
    }

    static void
    commit()
    {
        if (pmemobj_tx_stage() != TX_STAGE_WORK)
            throw transaction_error("wrong stage for"
                        " commit");

        pmemobj_tx_commit();
    }

    static int
    get_last_tx_error() noexcept
    {
        return pmemobj_tx_errno();
    }

    template <typename... Locks>
    static void
    exec_tx(pool_base &pool, std::function<void()> tx, Locks &... locks)
    {
        if (pmemobj_tx_begin(pool.get_handle(), NULL, TX_LOCK_NONE) !=
            0)
            throw transaction_error("failed to start transaction");

        auto err = add_lock(locks...);

        if (err) {
            pmemobj_tx_abort(err);
            pmemobj_tx_end();
            throw transaction_error("failed to add a lock to the"
                        " transaction");
        }

        try {
            tx();
        } catch (manual_tx_abort &) {
            pmemobj_tx_end();
            throw;
        } catch (...) {
            /* first exception caught */
            if (pmemobj_tx_stage() == TX_STAGE_WORK)
                pmemobj_tx_abort(ECANCELED);

            /* waterfall tx_end for outer tx */
            pmemobj_tx_end();
            throw;
        }

        auto stage = pmemobj_tx_stage();

        if (stage == TX_STAGE_WORK) {
            pmemobj_tx_commit();
        } else if (stage == TX_STAGE_ONABORT) {
            pmemobj_tx_end();
            throw transaction_error("transaction aborted");
        } else if (stage == TX_STAGE_NONE) {
            throw transaction_error("transaction ended"
                        "prematurely");
        }

        pmemobj_tx_end();
    }

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;
    }
};

} /* namespace obj */

} /* namespace nvml */

#endif /* LIBPMEMOBJ_TRANSACTION_HPP */