[WIP] Lazy Skip List Set

[Rextuz]

Implementation of SkipListSet based on fine-grained locks. The algorithm is based on the imlementation from the paper [2007] Herlihy, Lev, Luchangco, Shavit A Provably Correct Scalable Concurrent Skip List.

Contributors:
Max Kanushin,
Oleg Kurishev,
Efim Cherepanov.

[Rextuz]

Code in Java

import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;

public class LazySkipListSet {

    public static final int max_height = 4;
    private static int randomSeed = new Random().nextInt() | 0x0100;

    private Node lSentinel = new Node(Integer.MIN_VALUE, max_height);
    private Node rSentinel = new Node(Integer.MAX_VALUE, max_height);

    public LazySkipListSet() {
        for (int layer = 0; layer < max_height; layer++)
            lSentinel.nexts[layer] = rSentinel;
    }

    private int findNode(int v, Node preds[], Node succs[]) {
        int lFound = -1;
        Node pred = lSentinel;

        for (int layer = max_height - 1; layer >= 0; layer--) {
            Node curr = pred.nexts[layer];

            while (v > curr.key) {
                pred = curr;
                curr = pred.nexts[layer];
            }

            if (lFound == -1 && v == curr.key)
                lFound = layer;

            preds[layer] = pred;
            succs[layer] = curr;
        }

        return lFound;
    }

    private int _randomLevel() {
        int x = randomSeed;
        x ^= x << 13;
        x ^= x >>> 17;
        randomSeed = x ^= x << 5;
        if ((x & 0x8001) != 0) // test highest and lowest bits
            return 0;
        int level = 1;
        while (((x >>>= 1) & 1) != 0) ++level;
        return level;
    }

    public int randomLevel() {
        // FIXME
        int level = _randomLevel();

        if (level == max_height - 1) {
            int a = new Random().nextInt(2);
            if (a == 0)
                return max_height - 2;
        }

        if (level >= max_height)
            return max_height - 1;

        return level;
    }

    public boolean add(int v) {
        int topLayer = randomLevel();
        Node preds[] = new Node[max_height];
        Node succs[] = new Node[max_height];

        while (true) {
            int lFound = findNode(v, preds, succs);

            if (lFound != -1) {
                Node nodeFound = succs[lFound];
                if (!nodeFound.marked) {
                    while (!nodeFound.fullyLinked) {
                    }
                    return false;
                }
                continue;
            }

            int highestLocked = -1;
            try {
                Node pred, succ, prevPred = null;
                boolean valid = true;

                for (int layer = 0; valid && (layer <= topLayer); layer++) {
                    pred = preds[layer];
                    succ = succs[layer];

                    if (pred != prevPred) {
                        pred.lock.lock();
                        highestLocked = layer;
                        prevPred = pred;
                    }

                    valid = !pred.marked && !succ.marked && pred.nexts[layer] == succ;
                }

                if (!valid)
                    continue;

                Node newNode = new Node(v, topLayer);
                for (int layer = 0; layer <= topLayer; layer++) {
                    newNode.nexts[layer] = succs[layer];
                    preds[layer].nexts[layer] = newNode;
                }

                newNode.fullyLinked = true;
                return true;
            } finally {
                unlock(preds, highestLocked);
            }
        }
    }

    private void unlock(Node preds[], int highestLocked) {
        for (int layer = 0; layer <= highestLocked; layer++)
            if (preds[layer].lock.isHeldByCurrentThread())
                preds[layer].lock.unlock();
    }

    public boolean remove(int v) {
        Node nodeToDelete = null;
        boolean isMarked = false;
        int topLayer = -1;
        Node preds[] = new Node[max_height];
        Node succs[] = new Node[max_height];

        while (true) {
            int lFound = findNode(v, preds, succs);

            if (isMarked || (lFound != -1 && okToDelete(succs[lFound], lFound))) {
                if (!isMarked) {
                    nodeToDelete = succs[lFound];
                    topLayer = nodeToDelete.topLayer;
                    nodeToDelete.lock.lock();

                    if (nodeToDelete.marked) {
                        nodeToDelete.lock.unlock();
                        return false;
                    }

                    nodeToDelete.marked = true;
                    isMarked = true;
                }

                int highestLocked = -1;
                try {
                    Node pred, succ, prevPred = null;
                    boolean valid = true;

                    for (int layer = 0; valid && (layer <= topLayer); layer++) {
                        pred = preds[layer];
                        succ = succs[layer];

                        if (pred != prevPred) {
                            pred.lock.lock();
                            highestLocked = layer;
                            prevPred = pred;
                        }

                        valid = !pred.marked && pred.nexts[layer] == succ;
                    }

                    if (!valid)
                        continue;

                    for (int layer = topLayer; layer >= 0; layer--)
                        preds[layer].nexts[layer] = nodeToDelete.nexts[layer];

                    nodeToDelete.lock.unlock();
                    return true;
                } finally {
                    unlock(preds, highestLocked);
                }
            } else
                return false;
        }
    }

    private boolean okToDelete(Node candidate, int lFound) {
        return (candidate.fullyLinked && candidate.topLayer == lFound && !candidate.marked);
    }

    public boolean contains(int v) {
        Node preds[] = new Node[max_height];
        Node succs[] = new Node[max_height];
        int lFound = findNode(v, preds, succs);

        return (lFound != -1 && succs[lFound].fullyLinked && !succs[lFound].marked);
    }

    public boolean isEmpty() {
        Node succ = lSentinel.nexts[0];

        while (true) {
            if (lSentinel.nexts[0] == rSentinel)
                return true;

            if (succ.marked)
                succ = lSentinel.nexts[0];
            else
                return false;
        }
    }

    class Node {
        int key;
        int topLayer;
        Node nexts[];
        volatile boolean marked;
        volatile boolean fullyLinked; // false
        ReentrantLock lock = new ReentrantLock();

        Node(int v, int topLayer) {
            this.key = v;
            this.topLayer = topLayer;

            nexts = new Node[topLayer + 1];
        }
    }
}

[Rextuz]

Добрый день, возникли проблемы с запуском тестов для нашего контейнера.

Ссылка на юнит-тесты: Rextuz#1
Ссылка на стресс-тесты: Rextuz#2
В обоих случаях происходит ошибка сборки, когда в конструктор std::hash передается нестандартный тип данных:

In file included from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_find/../set_type_lazy_skip_list.h:36:0,
                 from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_find/set_insdelfind_lazy_skip.cpp:32:
/home/rextuz/Documents/git/libcds/cds/container/lazy_skip_list_set_dhp.h: In instantiation of ‘bool cds::container::LazySkipListSet<GC, T, Traits>::insert(cds::container::LazySkipListSet<GC, T, Traits>::value_type) [with GC = cds::gc::DHP; T = set::set_type_base<long unsigned int, long unsigned int>::key_val; Traits = set::set_type<set::tag_SkipListSet, long unsigned int, long unsigned int>::traits_LazySkipListSet_turbo32; cds::container::LazySkipListSet<GC, T, Traits>::value_type = set::set_type_base<long unsigned int, long unsigned int>::key_val]’:
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_find/set_insdelfind.h:154:21:   required from ‘void set::Set_InsDelFind::do_test(Set&) [with Set = set::SkipListSet<cds::gc::DHP, set::set_type_base<long unsigned int, long unsigned int>::key_val, set::set_type<set::tag_SkipListSet, long unsigned int, long unsigned int>::traits_LazySkipListSet_turbo32>]’
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_find/set_insdelfind.h:214:13:   required from ‘void set::Set_InsDelFind::run_test() [with Set = set::SkipListSet<cds::gc::DHP, set::set_type_base<long unsigned int, long unsigned int>::key_val, set::set_type<set::tag_SkipListSet, long unsigned int, long unsigned int>::traits_LazySkipListSet_turbo32>]’
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_find/set_insdelfind_lazy_skip.cpp:36:5:   required from here
/home/rextuz/Documents/git/libcds/cds/container/lazy_skip_list_set_dhp.h:50:51: error: use of deleted function ‘std::hash<set::set_type_base<long unsigned int, long unsigned int>::key_val>::hash()’
             key_type key = std::hash<value_type>{}(v);

Как стоит бороться с такой ситуацией?

В одном из стресс-тестов при сборке по каким-то причинам происходит вызов конструктора node с параметрами K const& k, T const& v, который у нас не реализован (и не должен быть?). Почему подобное может происходить?

                 from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/../set_type_lazy_skip_list.h:36,
                 from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/set_insdel_string_lazy_skip.cpp:32:
/home/rextuz/Documents/git/libcds/cds/container/details/lazy_skip_list_set_base.h: In instantiation of ‘cds::container::lazy_skip_list_set::node<GC, T, Lock>::node() [with GC = cds::gc::DHP; T = set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val; Lock = std::recursive_mutex]’:
/home/rextuz/Documents/git/libcds/cds/details/allocator.h:153:35:   required from ‘cds::details::Allocator<T, Alloc>::value_type* cds::details::Allocator<T, Alloc>::Construct(void*, const S& ...) [with S = {}; T = cds::container::lazy_skip_list_set::node<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, std::recursive_mutex>; Alloc = std::allocator<int>; cds::details::Allocator<T, Alloc>::value_type = cds::container::lazy_skip_list_set::node<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, std::recursive_mutex>]’
/home/rextuz/Documents/git/libcds/cds/details/allocator.h:73:33:   required from ‘cds::details::Allocator<T, Alloc>::value_type* cds::details::Allocator<T, Alloc>::New(const S& ...) [with S = {}; T = cds::container::lazy_skip_list_set::node<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, std::recursive_mutex>; Alloc = std::allocator<int>; cds::details::Allocator<T, Alloc>::value_type = cds::container::lazy_skip_list_set::node<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, std::recursive_mutex>]’
/home/rextuz/Documents/git/libcds/cds/container/details/lazy_skip_list_set_base.h:120:26:   required from ‘static cds::container::lazy_skip_list_set::node<GC, T, Lock>* cds::container::lazy_skip_list_set::node<GC, T, Lock>::allocate_node(cds::container::lazy_skip_list_set::node<GC, T, Lock>::key_type) [with GC = cds::gc::DHP; T = set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val; Lock = std::recursive_mutex; cds::container::lazy_skip_list_set::node<GC, T, Lock>::node_ptr = cds::container::lazy_skip_list_set::node<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, std::recursive_mutex>*; cds::container::lazy_skip_list_set::node<GC, T, Lock>::key_type = long unsigned int]’
/home/rextuz/Documents/git/libcds/cds/container/details/lazy_skip_list_set_base.h:144:50:   required from ‘static cds::container::lazy_skip_list_set::node<GC, T, Lock>* cds::container::lazy_skip_list_set::node<GC, T, Lock>::min_key() [with GC = cds::gc::DHP; T = set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val; Lock = std::recursive_mutex]’
/home/rextuz/Documents/git/libcds/cds/container/lazy_skip_list_set_dhp.h:38:40:   required from ‘cds::container::LazySkipListSet<GC, T, Traits>::LazySkipListSet() [with GC = cds::gc::DHP; T = set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val; Traits = set::set_type<set::tag_SkipListSet, std::__cxx11::basic_string<char>, long unsigned int>::traits_LazySkipListSet_turbo32]’
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/../set_type_lazy_skip_list.h:50:9:   required from ‘set::SkipListSet<GC, T, Traits>::SkipListSet(const Config&) [with Config = set::Set_InsDel_string; GC = cds::gc::DHP; T = set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val; Traits = set::set_type<set::tag_SkipListSet, std::__cxx11::basic_string<char>, long unsigned int>::traits_LazySkipListSet_turbo32]’
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/set_insdel_string.h:484:17:   required from ‘void set::Set_InsDel_string::run_test() [with Set = set::SkipListSet<cds::gc::DHP, set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val, set::set_type<set::tag_SkipListSet, std::__cxx11::basic_string<char>, long unsigned int>::traits_LazySkipListSet_turbo32>]’
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/set_insdel_string_lazy_skip.cpp:36:5:   required from here
/home/rextuz/Documents/git/libcds/cds/container/details/lazy_skip_list_set_base.h:52:55: error: no matching function for call to ‘set::set_type_base<std::__cxx11::basic_string<char>, long unsigned int>::key_val::key_val()’
             node() : _marked(false), fullyLinked(false) {
                                                       ^
In file included from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/set_insdel_string.h:31:0,
                 from /home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/set_insdel_string_lazy_skip.cpp:31:
/home/rextuz/Documents/git/libcds/test/stress/set/insdel_string/../set_type.h:190:13: note: candidate: template<class K, class T> set::set_type_base<Key, Value>::key_val::key_val(const K&, const T&)
             key_val( K const& k, T const& v ): key(k), val(v) {}```