016.cpp

#include <cstdio>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/make_persistent.hpp>

const char * const poolPath = "/mnt/pmem/pool_for_016";

template <typename T>
class linkedlist {
    struct element {
        element(const T& v) : value(v){}
        pmem::obj::p<T> value;
        pmem::obj::persistent_ptr<element> next = nullptr;
    };
    pmem::obj::persistent_ptr<element> head = nullptr;
    struct iterator {
        iterator(pmem::obj::persistent_ptr<element> start) : current(start){}
        pmem::obj::persistent_ptr<element> current;
        const pmem::obj::p<T> & operator *(){return current->value;}
        iterator & operator ++(){current = current->next; return *this;}
        bool operator!=(const iterator & o) const {return o.current!=current;}
    };
public:
    linkedlist() = default;
    void add(const T & v){
        assert(pmemobj_tx_stage() == TX_STAGE_WORK);
        if(head == nullptr)
            head = pmem::obj::make_persistent<element>(v);
        else {
            auto curr = head;
            while(curr->next != nullptr)
                curr = curr->next;
            curr->next = pmem::obj::make_persistent<element>(v);
        }
    }
    iterator begin() {return iterator(head);}
    iterator end() {return iterator(nullptr);}
};

struct root {
    pmem::obj::persistent_ptr<linkedlist<int>> ll;
};

int main(int argc, char ** argv) {

    if(argc == 1) {
        remove(poolPath);
        pmem::obj::pool<root> pop = pmem::obj::pool<root>::create(poolPath, std::string(), 8*1024*1024 /*PMEMOBJ_MIN_POOL*/);
        pmem::obj::transaction::exec_tx(pop, [&] {
            pop.get_root()->ll = pmem::obj::make_persistent<linkedlist<int>>();
        });
        return 0;
    }

    pmem::obj::pool<root> pop = pmem::obj::pool<root>::open(poolPath, std::string());

    switch(argc) {
        case 2: {
            //       ./016; let i=0; while ./016 $i; do let i++; done
            int v = atoi(argv[1]);
            try {
                pmem::obj::transaction::exec_tx(pop, [&] {
                    pop.get_root()->ll->add(v);
                });
            } catch(const pmem::transaction_error & e) {
                printf("Last: %5d (err: %s)\n", v, e.what());
                return 1;
            }
            break;
        }
        //       ./016; ./016 x x
        case 3: {
            int c = 0;
            try {
                while(1) {
                    pmem::obj::transaction::exec_tx(pop, [&] {
                        pop.get_root()->ll->add(c);
                    });
                    c++;
                }
            } catch(const pmem::transaction_error & e) {
                printf("Last: %5d (err: %s)\n", c, e.what());
            }
            break;
        }
        case 4: {
            for(const auto v: *(pop.get_root()->ll))
                printf("%d, ", v.get_ro());
            printf("\n");
        }
    }
    return 0;
}