diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,13 @@ All notable changes to this project (as seen by library users) will be documented in this file. The CHANGELOG is available on [Github](https://github.com/luc-tielen/souffle-haskell.git/CHANGELOG.md). +## [2.1.0] - 2021-01-03 + +- souffle-haskell now supports Souffle version 2.0.2. +- Fix GHC 8.10 specific warnings and compile error. +- Support Semigroup and Monoid instances for composing Souffle actions in + other ways. + ## [2.0.1] - 2020-09-05 ## Fixed diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License -Copyright (c) 2019 Luc Tielen +Copyright (c) 2020 Luc Tielen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -149,7 +149,7 @@ it can be linked with other languages (including Haskell!). For an example, take a look at the configuration for the -[test suite](https://github.com/luc-tielen/souffle-haskell/blob/master/package.yaml#L68-L80) of this project. +[test suite](https://github.com/luc-tielen/souffle-haskell/blob/master/package.yaml#L118-L133) of this project. If you run into C++ compilation issues when using stack, this might be because the `-std=c++17` flag is not being used correctly when compiling souffle-haskell. @@ -229,6 +229,7 @@ Setup your environment by entering the following command: ```bash +$ cachix use luctielen # Optional (improves setup time *significantly*) $ nix-shell ``` diff --git a/cbits/souffle/BTree.h b/cbits/souffle/BTree.h deleted file mode 100644 --- a/cbits/souffle/BTree.h +++ /dev/null @@ -1,2334 +0,0 @@ -/* - * Souffle - A Datalog Compiler - * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved - * Licensed under the Universal Permissive License v 1.0 as shown at: - * - https://opensource.org/licenses/UPL - * - /licenses/SOUFFLE-UPL.txt - */ - -/************************************************************************ - * - * @file BTree.h - * - * An implementation of a generic B-tree data structure including - * interfaces for utilizing instances as set or multiset containers. - * - ***********************************************************************/ - -#pragma once - -#include "utility/CacheUtil.h" -#include "utility/ContainerUtil.h" -#include "utility/ParallelUtil.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace souffle { - -namespace detail { - -// ---------- comparators -------------- - -/** - * A generic comparator implementation as it is used by - * a b-tree based on types that can be less-than and - * equality comparable. - */ -template -struct comparator { - /** - * Compares the values of a and b and returns - * -1 if ab and 0 otherwise - */ - int operator()(const T& a, const T& b) const { - return (a > b) - (a < b); - } - bool less(const T& a, const T& b) const { - return a < b; - } - bool equal(const T& a, const T& b) const { - return a == b; - } -}; - -// ---------- search strategies -------------- - -/** - * A common base class for search strategies in b-trees. - */ -struct search_strategy {}; - -/** - * A linear search strategy for looking up keys in b-tree nodes. - */ -struct linear_search : public search_strategy { - /** - * Required user-defined default constructor. - */ - linear_search() = default; - - /** - * Obtains an iterator referencing an element equivalent to the - * given key in the given range. If no such element is present, - * a reference to the first element not less than the given key - * is returned. - */ - template - inline Iter operator()(const Key& k, Iter a, Iter b, Comp& comp) const { - return lower_bound(k, a, b, comp); - } - - /** - * Obtains a reference to the first element in the given range that - * is not less than the given key. - */ - template - inline Iter lower_bound(const Key& k, Iter a, Iter b, Comp& comp) const { - auto c = a; - while (c < b) { - auto r = comp(*c, k); - if (r >= 0) { - return c; - } - ++c; - } - return b; - } - - /** - * Obtains a reference to the first element in the given range that - * such that the given key is less than the referenced element. - */ - template - inline Iter upper_bound(const Key& k, Iter a, Iter b, Comp& comp) const { - auto c = a; - while (c < b) { - if (comp(*c, k) > 0) { - return c; - } - ++c; - } - return b; - } -}; - -/** - * A binary search strategy for looking up keys in b-tree nodes. - */ -struct binary_search : public search_strategy { - /** - * Required user-defined default constructor. - */ - binary_search() = default; - - /** - * Obtains an iterator pointing to some element within the given - * range that is equal to the given key, if available. If multiple - * elements are equal to the given key, an undefined instance will - * be obtained (no guaranteed lower or upper boundary). If no such - * element is present, a reference to the first element not less than - * the given key will be returned. - */ - template - Iter operator()(const Key& k, Iter a, Iter b, Comp& comp) const { - Iter c; - auto count = b - a; - while (count > 0) { - auto step = count >> 1; - c = a + step; - auto r = comp(*c, k); - if (r == 0) { - return c; - } - if (r < 0) { - a = ++c; - count -= step + 1; - } else { - count = step; - } - } - return a; - } - - /** - * Obtains a reference to the first element in the given range that - * is not less than the given key. - */ - template - Iter lower_bound(const Key& k, Iter a, Iter b, Comp& comp) const { - Iter c; - auto count = b - a; - while (count > 0) { - auto step = count >> 1; - c = a + step; - if (comp(*c, k) < 0) { - a = ++c; - count -= step + 1; - } else { - count = step; - } - } - return a; - } - - /** - * Obtains a reference to the first element in the given range that - * such that the given key is less than the referenced element. - */ - template - Iter upper_bound(const Key& k, Iter a, Iter b, Comp& comp) const { - Iter c; - auto count = b - a; - while (count > 0) { - auto step = count >> 1; - c = a + step; - if (comp(k, *c) >= 0) { - a = ++c; - count -= step + 1; - } else { - count = step; - } - } - return a; - } -}; - -// ---------- search strategies selection -------------- - -/** - * A template-meta class to select search strategies for b-trees - * depending on the key type. - */ -template -struct strategy_selection { - using type = S; -}; - -struct linear : public strategy_selection {}; -struct binary : public strategy_selection {}; - -// by default every key utilizes binary search -template -struct default_strategy : public binary {}; - -template <> -struct default_strategy : public linear {}; - -template -struct default_strategy> : public linear {}; - -/** - * The default non-updater - */ -template -struct updater { - void update(T& /* old_t */, const T& /* new_t */) {} -}; - -/** - * The actual implementation of a b-tree data structure. - * - * @tparam Key .. the element type to be stored in this tree - * @tparam Comparator .. a class defining an order on the stored elements - * @tparam Allocator .. utilized for allocating memory for required nodes - * @tparam blockSize .. determines the number of bytes/block utilized by leaf nodes - * @tparam SearchStrategy .. enables switching between linear, binary or any other search strategy - * @tparam isSet .. true = set, false = multiset - */ -template > -class btree { -public: - class iterator; - using const_iterator = iterator; - - using key_type = Key; - using element_type = Key; - using chunk = range; - -protected: - /* ------------- static utilities ----------------- */ - - const static SearchStrategy search; - - /* ---------- comparison utilities ---------------- */ - - mutable Comparator comp; - - bool less(const Key& a, const Key& b) const { - return comp.less(a, b); - } - - bool equal(const Key& a, const Key& b) const { - return comp.equal(a, b); - } - - mutable WeakComparator weak_comp; - - bool weak_less(const Key& a, const Key& b) const { - return weak_comp.less(a, b); - } - - bool weak_equal(const Key& a, const Key& b) const { - return weak_comp.equal(a, b); - } - - /* -------------- updater utilities ------------- */ - - mutable Updater upd; - void update(Key& old_k, const Key& new_k) { - upd.update(old_k, new_k); - } - - /* -------------- the node type ----------------- */ - - using size_type = std::size_t; - using field_index_type = uint8_t; - using lock_type = OptimisticReadWriteLock; - - struct node; - - /** - * The base type of all node types containing essential - * book-keeping information. - */ - struct base { -#ifdef IS_PARALLEL - - // the parent node - node* volatile parent; - - // a lock for synchronizing parallel operations on this node - lock_type lock; - - // the number of keys in this node - volatile size_type numElements; - - // the position in the parent node - volatile field_index_type position; -#else - // the parent node - node* parent; - - // the number of keys in this node - size_type numElements; - - // the position in the parent node - field_index_type position; -#endif - - // a flag indicating whether this is a inner node or not - const bool inner; - - /** - * A simple constructor for nodes - */ - base(bool inner) : parent(nullptr), numElements(0), position(0), inner(inner) {} - - bool isLeaf() const { - return !inner; - } - - bool isInner() const { - return inner; - } - - node* getParent() const { - return parent; - } - - field_index_type getPositionInParent() const { - return position; - } - - size_type getNumElements() const { - return numElements; - } - }; - - struct inner_node; - - /** - * The actual, generic node implementation covering the operations - * for both, inner and leaf nodes. - */ - struct node : public base { - /** - * The number of keys/node desired by the user. - */ - static constexpr size_t desiredNumKeys = - ((blockSize > sizeof(base)) ? blockSize - sizeof(base) : 0) / sizeof(Key); - - /** - * The actual number of keys/node corrected by functional requirements. - */ - static constexpr size_t maxKeys = (desiredNumKeys > 3) ? desiredNumKeys : 3; - - // the keys stored in this node - Key keys[maxKeys]; - - // a simple constructor - node(bool inner) : base(inner) {} - - /** - * A deep-copy operation creating a clone of this node. - */ - node* clone() const { - // create a clone of this node - node* res = (this->isInner()) ? static_cast(new inner_node()) - : static_cast(new leaf_node()); - - // copy basic fields - res->position = this->position; - res->numElements = this->numElements; - - for (size_type i = 0; i < this->numElements; ++i) { - res->keys[i] = this->keys[i]; - } - - // if this is a leaf we are done - if (this->isLeaf()) { - return res; - } - - // copy child nodes recursively - auto* ires = (inner_node*)res; - for (size_type i = 0; i <= this->numElements; ++i) { - ires->children[i] = this->getChild(i)->clone(); - ires->children[i]->parent = res; - } - - // that's it - return res; - } - - /** - * A utility function providing a reference to this node as - * an inner node. - */ - inner_node& asInnerNode() { - assert(this->inner && "Invalid cast!"); - return *static_cast(this); - } - - /** - * A utility function providing a reference to this node as - * a const inner node. - */ - const inner_node& asInnerNode() const { - assert(this->inner && "Invalid cast!"); - return *static_cast(this); - } - - /** - * Computes the number of nested levels of the tree rooted - * by this node. - */ - size_type getDepth() const { - if (this->isLeaf()) { - return 1; - } - return getChild(0)->getDepth() + 1; - } - - /** - * Counts the number of nodes contained in the sub-tree rooted - * by this node. - */ - size_type countNodes() const { - if (this->isLeaf()) { - return 1; - } - size_type sum = 1; - for (unsigned i = 0; i <= this->numElements; ++i) { - sum += getChild(i)->countNodes(); - } - return sum; - } - - /** - * Counts the number of entries contained in the sub-tree rooted - * by this node. - */ - size_type countEntries() const { - if (this->isLeaf()) { - return this->numElements; - } - size_type sum = this->numElements; - for (unsigned i = 0; i <= this->numElements; ++i) { - sum += getChild(i)->countEntries(); - } - return sum; - } - - /** - * Determines the amount of memory used by the sub-tree rooted - * by this node. - */ - size_type getMemoryUsage() const { - if (this->isLeaf()) { - return sizeof(leaf_node); - } - size_type res = sizeof(inner_node); - for (unsigned i = 0; i <= this->numElements; ++i) { - res += getChild(i)->getMemoryUsage(); - } - return res; - } - - /** - * Obtains a pointer to the array of child-pointers - * of this node -- if it is an inner node. - */ - node** getChildren() { - return asInnerNode().children; - } - - /** - * Obtains a pointer to the array of const child-pointers - * of this node -- if it is an inner node. - */ - node* const* getChildren() const { - return asInnerNode().children; - } - - /** - * Obtains a reference to the child of the given index. - */ - node* getChild(size_type s) const { - return asInnerNode().children[s]; - } - - /** - * Checks whether this node is empty -- can happen due to biased insertion. - */ - bool isEmpty() const { - return this->numElements == 0; - } - - /** - * Checks whether this node is full. - */ - bool isFull() const { - return this->numElements == maxKeys; - } - - /** - * Obtains the point at which full nodes should be split. - * Conventional b-trees always split in half. However, in cases - * where in-order insertions are frequent, a split assigning - * larger portions to the right fragment provide higher performance - * and a better node-filling rate. - */ - int getSplitPoint(int /*unused*/) { - return std::min(3 * maxKeys / 4, maxKeys - 2); - } - - /** - * Splits this node. - * - * @param root .. a pointer to the root-pointer of the enclosing b-tree - * (might have to be updated if the root-node needs to be split) - * @param idx .. the position of the insert causing the split - */ -#ifdef IS_PARALLEL - void split(node** root, lock_type& root_lock, int idx, std::vector& locked_nodes) { - assert(this->lock.is_write_locked()); - assert(!this->parent || this->parent->lock.is_write_locked()); - assert((this->parent != nullptr) || root_lock.is_write_locked()); - assert(this->isLeaf() || souffle::contains(locked_nodes, this)); - assert(!this->parent || souffle::contains(locked_nodes, const_cast(this->parent))); -#else - void split(node** root, lock_type& root_lock, int idx) { -#endif - assert(this->numElements == maxKeys); - - // get middle element - int split_point = getSplitPoint(idx); - - // create a new sibling node - node* sibling = (this->inner) ? static_cast(new inner_node()) - : static_cast(new leaf_node()); - -#ifdef IS_PARALLEL - // lock sibling - sibling->lock.start_write(); - locked_nodes.push_back(sibling); -#endif - - // move data over to the new node - for (unsigned i = split_point + 1, j = 0; i < maxKeys; ++i, ++j) { - sibling->keys[j] = keys[i]; - } - - // move child pointers - if (this->inner) { - // move pointers to sibling - auto* other = static_cast(sibling); - for (unsigned i = split_point + 1, j = 0; i <= maxKeys; ++i, ++j) { - other->children[j] = getChildren()[i]; - other->children[j]->parent = other; - other->children[j]->position = j; - } - } - - // update number of elements - this->numElements = split_point; - sibling->numElements = maxKeys - split_point - 1; - - // update parent -#ifdef IS_PARALLEL - grow_parent(root, root_lock, sibling, locked_nodes); -#else - grow_parent(root, root_lock, sibling); -#endif - } - - /** - * Moves keys from this node to one of its siblings or splits - * this node to make some space for the insertion of an element at - * position idx. - * - * Returns the number of elements moved to the left side, 0 in case - * of a split. The number of moved elements will be <= the given idx. - * - * @param root .. the root node of the b-tree being part of - * @param idx .. the position of the insert triggering this operation - */ - // TODO: remove root_lock ... no longer needed -#ifdef IS_PARALLEL - int rebalance_or_split(node** root, lock_type& root_lock, int idx, std::vector& locked_nodes) { - assert(this->lock.is_write_locked()); - assert(!this->parent || this->parent->lock.is_write_locked()); - assert((this->parent != nullptr) || root_lock.is_write_locked()); - assert(this->isLeaf() || souffle::contains(locked_nodes, this)); - assert(!this->parent || souffle::contains(locked_nodes, const_cast(this->parent))); -#else - int rebalance_or_split(node** root, lock_type& root_lock, int idx) { -#endif - - // this node is full ... and needs some space - assert(this->numElements == maxKeys); - - // get snap-shot of parent - auto parent = this->parent; - auto pos = this->position; - - // Option A) re-balance data - if (parent && pos > 0) { - node* left = parent->getChild(pos - 1); - -#ifdef IS_PARALLEL - // lock access to left sibling - if (!left->lock.try_start_write()) { - // left node is currently updated => skip balancing and split - split(root, root_lock, idx, locked_nodes); - return 0; - } -#endif - - // compute number of elements to be movable to left - // space available in left vs. insertion index - size_type num = std::min(maxKeys - left->numElements, idx); - - // if there are elements to move .. - if (num > 0) { - Key* splitter = &(parent->keys[this->position - 1]); - - // .. move keys to left node - left->keys[left->numElements] = *splitter; - for (size_type i = 0; i < num - 1; ++i) { - left->keys[left->numElements + 1 + i] = keys[i]; - } - *splitter = keys[num - 1]; - - // shift keys in this node to the left - for (size_type i = 0; i < this->numElements - num; ++i) { - keys[i] = keys[i + num]; - } - - // .. and children if necessary - if (this->isInner()) { - auto* ileft = static_cast(left); - auto* iright = static_cast(this); - - // move children - for (size_type i = 0; i < num; ++i) { - ileft->children[left->numElements + i + 1] = iright->children[i]; - } - - // update moved children - for (size_type i = 0; i < num; ++i) { - iright->children[i]->parent = ileft; - iright->children[i]->position = left->numElements + i + 1; - } - - // shift child-pointer to the left - for (size_type i = 0; i < this->numElements - num + 1; ++i) { - iright->children[i] = iright->children[i + num]; - } - - // update position of children - for (size_type i = 0; i < this->numElements - num + 1; ++i) { - iright->children[i]->position = i; - } - } - - // update node sizes - left->numElements += num; - this->numElements -= num; - -#ifdef IS_PARALLEL - left->lock.end_write(); -#endif - - // done - return num; - } - -#ifdef IS_PARALLEL - left->lock.abort_write(); -#endif - } - - // Option B) split node -#ifdef IS_PARALLEL - split(root, root_lock, idx, locked_nodes); -#else - split(root, root_lock, idx); -#endif - return 0; // = no re-balancing - } - - private: - /** - * Inserts a new sibling into the parent of this node utilizing - * the last key of this node as a separation key. (for internal - * use only) - * - * @param root .. a pointer to the root-pointer of the containing tree - * @param sibling .. the new right-sibling to be add to the parent node - */ -#ifdef IS_PARALLEL - void grow_parent(node** root, lock_type& root_lock, node* sibling, std::vector& locked_nodes) { - assert(this->lock.is_write_locked()); - assert(!this->parent || this->parent->lock.is_write_locked()); - assert((this->parent != nullptr) || root_lock.is_write_locked()); - assert(this->isLeaf() || souffle::contains(locked_nodes, this)); - assert(!this->parent || souffle::contains(locked_nodes, const_cast(this->parent))); -#else - void grow_parent(node** root, lock_type& root_lock, node* sibling) { -#endif - - if (this->parent == nullptr) { - assert(*root == this); - - // create a new root node - auto* new_root = new inner_node(); - new_root->numElements = 1; - new_root->keys[0] = keys[this->numElements]; - - new_root->children[0] = this; - new_root->children[1] = sibling; - - // link this and the sibling node to new root - this->parent = new_root; - sibling->parent = new_root; - sibling->position = 1; - - // switch root node - *root = new_root; - - } else { - // insert new element in parent element - auto parent = this->parent; - auto pos = this->position; - -#ifdef IS_PARALLEL - parent->insert_inner( - root, root_lock, pos, this, keys[this->numElements], sibling, locked_nodes); -#else - parent->insert_inner(root, root_lock, pos, this, keys[this->numElements], sibling); -#endif - } - } - - /** - * Inserts a new element into an inner node (for internal use only). - * - * @param root .. a pointer to the root-pointer of the containing tree - * @param pos .. the position to insert the new key - * @param key .. the key to insert - * @param newNode .. the new right-child of the inserted key - */ -#ifdef IS_PARALLEL - void insert_inner(node** root, lock_type& root_lock, unsigned pos, node* predecessor, const Key& key, - node* newNode, std::vector& locked_nodes) { - assert(this->lock.is_write_locked()); - assert(souffle::contains(locked_nodes, this)); -#else - void insert_inner(node** root, lock_type& root_lock, unsigned pos, node* predecessor, const Key& key, - node* newNode) { -#endif - - // check capacity - if (this->numElements >= maxKeys) { -#ifdef IS_PARALLEL - assert(!this->parent || this->parent->lock.is_write_locked()); - assert((this->parent) || root_lock.is_write_locked()); - assert(!this->parent || souffle::contains(locked_nodes, const_cast(this->parent))); -#endif - - // split this node -#ifdef IS_PARALLEL - pos -= rebalance_or_split(root, root_lock, pos, locked_nodes); -#else - pos -= rebalance_or_split(root, root_lock, pos); -#endif - - // complete insertion within new sibling if necessary - if (pos > this->numElements) { - // correct position - pos = pos - this->numElements - 1; - - // get new sibling - auto other = this->parent->getChild(this->position + 1); - -#ifdef IS_PARALLEL - // make sure other side is write locked - assert(other->lock.is_write_locked()); - assert(souffle::contains(locked_nodes, other)); - - // search for new position (since other may have been altered in the meanwhile) - size_type i = 0; - for (; i <= other->numElements; ++i) { - if (other->getChild(i) == predecessor) { - break; - } - } - - pos = (i > other->numElements) ? 0 : i; - other->insert_inner(root, root_lock, pos, predecessor, key, newNode, locked_nodes); -#else - other->insert_inner(root, root_lock, pos, predecessor, key, newNode); -#endif - return; - } - } - - // move bigger keys one forward - for (int i = this->numElements - 1; i >= (int)pos; --i) { - keys[i + 1] = keys[i]; - getChildren()[i + 2] = getChildren()[i + 1]; - ++getChildren()[i + 2]->position; - } - - // ensure proper position - assert(getChild(pos) == predecessor); - - // insert new element - keys[pos] = key; - getChildren()[pos + 1] = newNode; - newNode->parent = this; - newNode->position = pos + 1; - ++this->numElements; - } - - public: - /** - * Prints a textual representation of this tree to the given output stream. - * This feature is mainly intended for debugging and tuning purposes. - * - * @see btree::printTree - */ - void printTree(std::ostream& out, const std::string& prefix) const { - // print the header - out << prefix << "@" << this << "[" << ((int)(this->position)) << "] - " - << (this->inner ? "i" : "") << "node : " << this->numElements << "/" << maxKeys << " ["; - - // print the keys - for (unsigned i = 0; i < this->numElements; i++) { - out << keys[i]; - if (i != this->numElements - 1) { - out << ","; - } - } - out << "]"; - - // print references to children - if (this->inner) { - out << " - ["; - for (unsigned i = 0; i <= this->numElements; i++) { - out << getChildren()[i]; - if (i != this->numElements) { - out << ","; - } - } - out << "]"; - } - -#ifdef IS_PARALLEL - // print the lock state - if (this->lock.is_write_locked()) { - std::cout << " locked"; - } -#endif - - out << "\n"; - - // print the children recursively - if (this->inner) { - for (unsigned i = 0; i < this->numElements + 1; ++i) { - static_cast(this)->children[i]->printTree(out, prefix + " "); - } - } - } - - /** - * A function decomposing the sub-tree rooted by this node into approximately equally - * sized chunks. To minimize computational overhead, no strict load balance nor limit - * on the number of actual chunks is given. - * - * @see btree::getChunks() - * - * @param res .. the list of chunks to be extended - * @param num .. the number of chunks to be produced - * @param begin .. the iterator to start the first chunk with - * @param end .. the iterator to end the last chunk with - * @return the handed in list of chunks extended by generated chunks - */ - std::vector& collectChunks( - std::vector& res, size_type num, const iterator& begin, const iterator& end) const { - assert(num > 0); - - // special case: this node is empty - if (isEmpty()) { - if (begin != end) { - res.push_back(chunk(begin, end)); - } - return res; - } - - // special case: a single chunk is requested - if (num == 1) { - res.push_back(chunk(begin, end)); - return res; - } - - // cut-off - if (this->isLeaf() || num < (this->numElements + 1)) { - auto step = this->numElements / num; - if (step == 0) { - step = 1; - } - - size_type i = 0; - - // the first chunk starts at the begin - res.push_back(chunk(begin, iterator(this, step - 1))); - - // split up the main part - for (i = step - 1; i < this->numElements - step; i += step) { - res.push_back(chunk(iterator(this, i), iterator(this, i + step))); - } - - // the last chunk runs to the end - res.push_back(chunk(iterator(this, i), end)); - - // done - return res; - } - - // else: collect chunks of sub-set elements - - auto part = num / (this->numElements + 1); - assert(part > 0); - getChild(0)->collectChunks(res, part, begin, iterator(this, 0)); - for (size_type i = 1; i < this->numElements; i++) { - getChild(i)->collectChunks(res, part, iterator(this, i - 1), iterator(this, i)); - } - getChild(this->numElements) - ->collectChunks(res, num - (part * this->numElements), - iterator(this, this->numElements - 1), end); - - // done - return res; - } - - /** - * A function to verify the consistency of this node. - * - * @param root ... a reference to the root of the enclosing tree. - * @return true if valid, false otherwise - */ - template - bool check(Comp& comp, const node* root) const { - bool valid = true; - - // check fill-state - if (this->numElements > maxKeys) { - std::cout << "Node with " << this->numElements << "/" << maxKeys << " encountered!\n"; - valid = false; - } - - // check root state - if (root == this) { - if (this->parent != nullptr) { - std::cout << "Root not properly linked!\n"; - valid = false; - } - } else { - // check parent relation - if (!this->parent) { - std::cout << "Invalid null-parent!\n"; - valid = false; - } else { - if (this->parent->getChildren()[this->position] != this) { - std::cout << "Parent reference invalid!\n"; - std::cout << " Node: " << this << "\n"; - std::cout << " Parent: " << this->parent << "\n"; - std::cout << " Position: " << ((int)this->position) << "\n"; - valid = false; - } - - // check parent key - if (valid && this->position != 0 && - !(comp(this->parent->keys[this->position - 1], keys[0]) < ((isSet) ? 0 : 1))) { - std::cout << "Left parent key not lower bound!\n"; - std::cout << " Node: " << this << "\n"; - std::cout << " Parent: " << this->parent << "\n"; - std::cout << " Position: " << ((int)this->position) << "\n"; - std::cout << " Key: " << (this->parent->keys[this->position]) << "\n"; - std::cout << " Lower: " << (keys[0]) << "\n"; - valid = false; - } - - // check parent key - if (valid && this->position != this->parent->numElements && - !(comp(keys[this->numElements - 1], this->parent->keys[this->position]) < - ((isSet) ? 0 : 1))) { - std::cout << "Right parent key not lower bound!\n"; - std::cout << " Node: " << this << "\n"; - std::cout << " Parent: " << this->parent << "\n"; - std::cout << " Position: " << ((int)this->position) << "\n"; - std::cout << " Key: " << (this->parent->keys[this->position]) << "\n"; - std::cout << " Upper: " << (keys[0]) << "\n"; - valid = false; - } - } - } - - // check element order - if (this->numElements > 0) { - for (unsigned i = 0; i < this->numElements - 1; i++) { - if (valid && !(comp(keys[i], keys[i + 1]) < ((isSet) ? 0 : 1))) { - std::cout << "Element order invalid!\n"; - std::cout << " @" << this << " key " << i << " is " << keys[i] << " vs " - << keys[i + 1] << "\n"; - valid = false; - } - } - } - - // check state of sub-nodes - if (this->inner) { - for (unsigned i = 0; i <= this->numElements; i++) { - valid &= getChildren()[i]->check(comp, root); - } - } - - return valid; - } - }; // namespace detail - - /** - * The data type representing inner nodes of the b-tree. It extends - * the generic implementation of a node by the storage locations - * of child pointers. - */ - struct inner_node : public node { - // references to child nodes owned by this node - node* children[node::maxKeys + 1]; - - // a simple default constructor initializing member fields - inner_node() : node(true) {} - - // clear up child nodes recursively - ~inner_node() { - for (unsigned i = 0; i <= this->numElements; ++i) { - if (children[i] != nullptr) { - if (children[i]->isLeaf()) { - delete static_cast(children[i]); - } else { - delete static_cast(children[i]); - } - } - } - } - }; - - /** - * The data type representing leaf nodes of the b-tree. It does not - * add any capabilities to the generic node type. - */ - struct leaf_node : public node { - // a simple default constructor initializing member fields - leaf_node() : node(false) {} - }; - - // ------------------- iterators ------------------------ - -public: - /** - * The iterator type to be utilized for scanning through btree instances. - */ - class iterator : public std::iterator { - // a pointer to the node currently referred to - node const* cur; - - // the index of the element currently addressed within the referenced node - field_index_type pos = 0; - - public: - // default constructor -- creating an end-iterator - iterator() : cur(nullptr) {} - - // creates an iterator referencing a specific element within a given node - iterator(node const* cur, field_index_type pos) : cur(cur), pos(pos) {} - - // a copy constructor - iterator(const iterator& other) : cur(other.cur), pos(other.pos) {} - - // an assignment operator - iterator& operator=(const iterator& other) { - cur = other.cur; - pos = other.pos; - return *this; - } - - // the equality operator as required by the iterator concept - bool operator==(const iterator& other) const { - return cur == other.cur && pos == other.pos; - } - - // the not-equality operator as required by the iterator concept - bool operator!=(const iterator& other) const { - return !(*this == other); - } - - // the deref operator as required by the iterator concept - const Key& operator*() const { - return cur->keys[pos]; - } - - // the increment operator as required by the iterator concept - iterator& operator++() { - // the quick mode -- if in a leaf and there are elements left - if (cur->isLeaf() && ++pos < cur->getNumElements()) { - return *this; - } - - // otherwise it is a bit more tricky - - // A) currently in an inner node => go to the left-most child - if (cur->isInner()) { - cur = cur->getChildren()[pos + 1]; - while (!cur->isLeaf()) { - cur = cur->getChildren()[0]; - } - pos = 0; - - // nodes may be empty due to biased insertion - if (!cur->isEmpty()) { - return *this; - } - } - - // B) we are at the right-most element of a leaf => go to next inner node - assert(cur->isLeaf()); - assert(pos == cur->getNumElements()); - - while (cur != nullptr && pos == cur->getNumElements()) { - pos = cur->getPositionInParent(); - cur = cur->getParent(); - } - return *this; - } - - // prints a textual representation of this iterator to the given stream (mainly for debugging) - void print(std::ostream& out = std::cout) const { - out << cur << "[" << (int)pos << "]"; - } - }; - - /** - * A collection of operation hints speeding up some of the involved operations - * by exploiting temporal locality. - */ - template - struct btree_operation_hints { - using node_cache = LRUCache; - - // the node where the last insertion terminated - node_cache last_insert; - - // the node where the last find-operation terminated - node_cache last_find_end; - - // the node where the last lower-bound operation terminated - node_cache last_lower_bound_end; - - // the node where the last upper-bound operation terminated - node_cache last_upper_bound_end; - - // default constructor - btree_operation_hints() = default; - - // resets all hints (to be triggered e.g. when deleting nodes) - void clear() { - last_insert.clear(nullptr); - last_find_end.clear(nullptr); - last_lower_bound_end.clear(nullptr); - last_upper_bound_end.clear(nullptr); - } - }; - - using operation_hints = btree_operation_hints<1>; - -protected: -#ifdef IS_PARALLEL - // a pointer to the root node of this tree - node* volatile root; - - // a lock to synchronize update operations on the root pointer - lock_type root_lock; -#else - // a pointer to the root node of this tree - node* root; - - // required to not duplicate too much code - lock_type root_lock; -#endif - - // a pointer to the left-most node of this tree (initial note for iteration) - leaf_node* leftmost; - - /* -------------- operator hint statistics ----------------- */ - - // an aggregation of statistical values of the hint utilization - struct hint_statistics { - // the counter for insertion operations - CacheAccessCounter inserts; - - // the counter for contains operations - CacheAccessCounter contains; - - // the counter for lower_bound operations - CacheAccessCounter lower_bound; - - // the counter for upper_bound operations - CacheAccessCounter upper_bound; - }; - - // the hint statistic of this b-tree instance - mutable hint_statistics hint_stats; - -public: - // the maximum number of keys stored per node - static constexpr size_t max_keys_per_node = node::maxKeys; - - // -- ctors / dtors -- - - // the default constructor creating an empty tree - btree(Comparator comp = Comparator(), WeakComparator weak_comp = WeakComparator()) - : comp(std::move(comp)), weak_comp(std::move(weak_comp)), root(nullptr), leftmost(nullptr) {} - - // a constructor creating a tree from the given iterator range - template - btree(const Iter& a, const Iter& b) : root(nullptr), leftmost(nullptr) { - insert(a, b); - } - - // a move constructor - btree(btree&& other) - : comp(other.comp), weak_comp(other.weak_comp), root(other.root), leftmost(other.leftmost) { - other.root = nullptr; - other.leftmost = nullptr; - } - - // a copy constructor - btree(const btree& set) : comp(set.comp), weak_comp(set.weak_comp), root(nullptr), leftmost(nullptr) { - // use assignment operator for a deep copy - *this = set; - } - -protected: - /** - * An internal constructor enabling the specific creation of a tree - * based on internal parameters. - */ - btree(size_type /* size */, node* root, leaf_node* leftmost) : root(root), leftmost(leftmost) {} - -public: - // the destructor freeing all contained nodes - ~btree() { - clear(); - } - - // -- mutators and observers -- - - // emptiness check - bool empty() const { - return root == nullptr; - } - - // determines the number of elements in this tree - size_type size() const { - return (root) ? root->countEntries() : 0; - } - - /** - * Inserts the given key into this tree. - */ - bool insert(const Key& k) { - operation_hints hints; - return insert(k, hints); - } - - /** - * Inserts the given key into this tree. - */ - bool insert(const Key& k, operation_hints& hints) { -#ifdef IS_PARALLEL - - // special handling for inserting first element - while (root == nullptr) { - // try obtaining root-lock - if (!root_lock.try_start_write()) { - // somebody else was faster => re-check - continue; - } - - // check loop condition again - if (root != nullptr) { - // somebody else was faster => normal insert - root_lock.end_write(); - break; - } - - // create new node - leftmost = new leaf_node(); - leftmost->numElements = 1; - leftmost->keys[0] = k; - root = leftmost; - - // operation complete => we can release the root lock - root_lock.end_write(); - - hints.last_insert.access(leftmost); - - return true; - } - - // insert using iterative implementation - - node* cur = nullptr; - - // test last insert hints - lock_type::Lease cur_lease; - - auto checkHint = [&](node* last_insert) { - // ignore null pointer - if (!last_insert) return false; - // get a read lease on indicated node - auto hint_lease = last_insert->lock.start_read(); - // check whether it covers the key - if (!weak_covers(last_insert, k)) return false; - // and if there was no concurrent modification - if (!last_insert->lock.validate(hint_lease)) return false; - // use hinted location - cur = last_insert; - // and keep lease - cur_lease = hint_lease; - // we found a hit - return true; - }; - - if (hints.last_insert.any(checkHint)) { - // register this as a hit - hint_stats.inserts.addHit(); - } else { - // register this as a miss - hint_stats.inserts.addMiss(); - } - - // if there is no valid hint .. - if (!cur) { - do { - // get root - access lock - auto root_lease = root_lock.start_read(); - - // start with root - cur = root; - - // get lease of the next node to be accessed - cur_lease = cur->lock.start_read(); - - // check validity of root pointer - if (root_lock.end_read(root_lease)) { - break; - } - - } while (true); - } - - while (true) { - // handle inner nodes - if (cur->inner) { - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.lower_bound(k, a, b, weak_comp); - auto idx = pos - a; - - // early exit for sets - if (isSet && pos != b && weak_equal(*pos, k)) { - // validate results - if (!cur->lock.validate(cur_lease)) { - // start over again - return insert(k, hints); - } - - // update provenance information - if (typeid(Comparator) != typeid(WeakComparator) && less(k, *pos)) { - if (!cur->lock.try_upgrade_to_write(cur_lease)) { - // start again - return insert(k, hints); - } - update(*pos, k); - cur->lock.end_write(); - return true; - } - - // we found the element => no check of lock necessary - return false; - } - - // get next pointer - auto next = cur->getChild(idx); - - // get lease on next level - auto next_lease = next->lock.start_read(); - - // check whether there was a write - if (!cur->lock.end_read(cur_lease)) { - // start over - return insert(k, hints); - } - - // go to next - cur = next; - - // move on lease - cur_lease = next_lease; - - continue; - } - - // the rest is for leaf nodes - assert(!cur->inner); - - // -- insert node in leaf node -- - - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.upper_bound(k, a, b, weak_comp); - auto idx = pos - a; - - // early exit for sets - if (isSet && pos != a && weak_equal(*(pos - 1), k)) { - // validate result - if (!cur->lock.validate(cur_lease)) { - // start over again - return insert(k, hints); - } - - // update provenance information - if (typeid(Comparator) != typeid(WeakComparator) && less(k, *(pos - 1))) { - if (!cur->lock.try_upgrade_to_write(cur_lease)) { - // start again - return insert(k, hints); - } - update(*(pos - 1), k); - cur->lock.end_write(); - return true; - } - - // we found the element => done - return false; - } - - // upgrade to write-permission - if (!cur->lock.try_upgrade_to_write(cur_lease)) { - // something has changed => restart - hints.last_insert.access(cur); - return insert(k, hints); - } - - if (cur->numElements >= node::maxKeys) { - // -- lock parents -- - auto priv = cur; - auto parent = priv->parent; - std::vector parents; - do { - if (parent) { - parent->lock.start_write(); - while (true) { - // check whether parent is correct - if (parent == priv->parent) { - break; - } - // switch parent - parent->lock.abort_write(); - parent = priv->parent; - parent->lock.start_write(); - } - } else { - // lock root lock => since cur is root - root_lock.start_write(); - } - - // record locked node - parents.push_back(parent); - - // stop at "sphere of influence" - if (!parent || !parent->isFull()) { - break; - } - - // go one step higher - priv = parent; - parent = parent->parent; - - } while (true); - - // split this node - auto old_root = root; - idx -= cur->rebalance_or_split(const_cast(&root), root_lock, idx, parents); - - // release parent lock - for (auto it = parents.rbegin(); it != parents.rend(); ++it) { - auto parent = *it; - - // release this lock - if (parent) { - parent->lock.end_write(); - } else { - if (old_root != root) { - root_lock.end_write(); - } else { - root_lock.abort_write(); - } - } - } - - // insert element in right fragment - if (((size_type)idx) > cur->numElements) { - // release current lock - cur->lock.end_write(); - - // insert in sibling - return insert(k, hints); - } - } - - // ok - no split necessary - assert(cur->numElements < node::maxKeys && "Split required!"); - - // move keys - for (int j = cur->numElements; j > idx; --j) { - cur->keys[j] = cur->keys[j - 1]; - } - - // insert new element - cur->keys[idx] = k; - cur->numElements++; - - // release lock on current node - cur->lock.end_write(); - - // remember last insertion position - hints.last_insert.access(cur); - return true; - } - -#else - // special handling for inserting first element - if (empty()) { - // create new node - leftmost = new leaf_node(); - leftmost->numElements = 1; - leftmost->keys[0] = k; - root = leftmost; - - hints.last_insert.access(leftmost); - - return true; - } - - // insert using iterative implementation - node* cur = root; - - auto checkHints = [&](node* last_insert) { - if (!last_insert) return false; - if (!weak_covers(last_insert, k)) return false; - cur = last_insert; - return true; - }; - - // test last insert - if (hints.last_insert.any(checkHints)) { - hint_stats.inserts.addHit(); - } else { - hint_stats.inserts.addMiss(); - } - - while (true) { - // handle inner nodes - if (cur->inner) { - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.lower_bound(k, a, b, weak_comp); - auto idx = pos - a; - - // early exit for sets - if (isSet && pos != b && weak_equal(*pos, k)) { - // update provenance information - if (typeid(Comparator) != typeid(WeakComparator) && less(k, *pos)) { - update(*pos, k); - return true; - } - - return false; - } - - cur = cur->getChild(idx); - continue; - } - - // the rest is for leaf nodes - assert(!cur->inner); - - // -- insert node in leaf node -- - - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.upper_bound(k, a, b, weak_comp); - auto idx = pos - a; - - // early exit for sets - if (isSet && pos != a && weak_equal(*(pos - 1), k)) { - // update provenance information - if (typeid(Comparator) != typeid(WeakComparator) && less(k, *(pos - 1))) { - update(*(pos - 1), k); - return true; - } - - return false; - } - - if (cur->numElements >= node::maxKeys) { - // split this node - idx -= cur->rebalance_or_split(&root, root_lock, idx); - - // insert element in right fragment - if (((size_type)idx) > cur->numElements) { - idx -= cur->numElements + 1; - cur = cur->parent->getChild(cur->position + 1); - } - } - - // ok - no split necessary - assert(cur->numElements < node::maxKeys && "Split required!"); - - // move keys - for (int j = cur->numElements; j > idx; --j) { - cur->keys[j] = cur->keys[j - 1]; - } - - // insert new element - cur->keys[idx] = k; - cur->numElements++; - - // remember last insertion position - hints.last_insert.access(cur); - - return true; - } -#endif - } - - /** - * Inserts the given range of elements into this tree. - */ - template - void insert(const Iter& a, const Iter& b) { - // TODO: improve this beyond a naive insert - operation_hints hints; - // a naive insert so far .. seems to work fine - for (auto it = a; it != b; ++it) { - // use insert with hint - insert(*it, hints); - } - } - - // Obtains an iterator referencing the first element of the tree. - iterator begin() const { - return iterator(leftmost, 0); - } - - // Obtains an iterator referencing the position after the last element of the tree. - iterator end() const { - return iterator(); - } - - /** - * Partitions the full range of this set into up to a given number of chunks. - * The chunks will cover approximately the same number of elements. Also, the - * number of chunks will only approximate the desired number of chunks. - * - * @param num .. the number of chunks requested - * @return a list of chunks partitioning this tree - */ - std::vector partition(size_type num) const { - return getChunks(num); - } - - std::vector getChunks(size_type num) const { - std::vector res; - if (empty()) { - return res; - } - return root->collectChunks(res, num, begin(), end()); - } - - /** - * Determines whether the given element is a member of this tree. - */ - bool contains(const Key& k) const { - operation_hints hints; - return contains(k, hints); - } - - /** - * Determines whether the given element is a member of this tree. - */ - bool contains(const Key& k, operation_hints& hints) const { - return find(k, hints) != end(); - } - - /** - * Locates the given key within this tree and returns an iterator - * referencing its position. If not found, an end-iterator will be returned. - */ - iterator find(const Key& k) const { - operation_hints hints; - return find(k, hints); - } - - /** - * Locates the given key within this tree and returns an iterator - * referencing its position. If not found, an end-iterator will be returned. - */ - iterator find(const Key& k, operation_hints& hints) const { - if (empty()) { - return end(); - } - - node* cur = root; - - auto checkHints = [&](node* last_find_end) { - if (!last_find_end) return false; - if (!covers(last_find_end, k)) return false; - cur = last_find_end; - return true; - }; - - // test last location searched (temporal locality) - if (hints.last_find_end.any(checkHints)) { - // register it as a hit - hint_stats.contains.addHit(); - } else { - // register it as a miss - hint_stats.contains.addMiss(); - } - - // an iterative implementation (since 2/7 faster than recursive) - - while (true) { - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search(k, a, b, comp); - - if (pos < b && equal(*pos, k)) { - hints.last_find_end.access(cur); - return iterator(cur, pos - a); - } - - if (!cur->inner) { - hints.last_find_end.access(cur); - return end(); - } - - // continue search in child node - cur = cur->getChild(pos - a); - } - } - - /** - * Obtains a lower boundary for the given key -- hence an iterator referencing - * the smallest value that is not less the given key. If there is no such element, - * an end-iterator will be returned. - */ - iterator lower_bound(const Key& k) const { - operation_hints hints; - return lower_bound(k, hints); - } - - /** - * Obtains a lower boundary for the given key -- hence an iterator referencing - * the smallest value that is not less the given key. If there is no such element, - * an end-iterator will be returned. - */ - iterator lower_bound(const Key& k, operation_hints& hints) const { - if (empty()) { - return end(); - } - - node* cur = root; - - auto checkHints = [&](node* last_lower_bound_end) { - if (!last_lower_bound_end) return false; - if (!covers(last_lower_bound_end, k)) return false; - cur = last_lower_bound_end; - return true; - }; - - // test last searched node - if (hints.last_lower_bound_end.any(checkHints)) { - hint_stats.lower_bound.addHit(); - } else { - hint_stats.lower_bound.addMiss(); - } - - iterator res = end(); - while (true) { - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.lower_bound(k, a, b, comp); - auto idx = pos - a; - - if (!cur->inner) { - hints.last_lower_bound_end.access(cur); - return (pos != b) ? iterator(cur, idx) : res; - } - - if (isSet && pos != b && equal(*pos, k)) { - return iterator(cur, idx); - } - - if (pos != b) { - res = iterator(cur, idx); - } - - cur = cur->getChild(idx); - } - } - - /** - * Obtains an upper boundary for the given key -- hence an iterator referencing - * the first element that the given key is less than the referenced value. If - * there is no such element, an end-iterator will be returned. - */ - iterator upper_bound(const Key& k) const { - operation_hints hints; - return upper_bound(k, hints); - } - - /** - * Obtains an upper boundary for the given key -- hence an iterator referencing - * the first element that the given key is less than the referenced value. If - * there is no such element, an end-iterator will be returned. - */ - iterator upper_bound(const Key& k, operation_hints& hints) const { - if (empty()) { - return end(); - } - - node* cur = root; - - auto checkHints = [&](node* last_upper_bound_end) { - if (!last_upper_bound_end) return false; - if (!coversUpperBound(last_upper_bound_end, k)) return false; - cur = last_upper_bound_end; - return true; - }; - - // test last search node - if (hints.last_upper_bound_end.any(checkHints)) { - hint_stats.upper_bound.addHit(); - } else { - hint_stats.upper_bound.addMiss(); - } - - iterator res = end(); - while (true) { - auto a = &(cur->keys[0]); - auto b = &(cur->keys[cur->numElements]); - - auto pos = search.upper_bound(k, a, b, comp); - auto idx = pos - a; - - if (!cur->inner) { - hints.last_upper_bound_end.access(cur); - return (pos != b) ? iterator(cur, idx) : res; - } - - if (pos != b) { - res = iterator(cur, idx); - } - - cur = cur->getChild(idx); - } - } - - /** - * Clears this tree. - */ - void clear() { - if (root != nullptr) { - if (root->isLeaf()) { - delete static_cast(root); - } else { - delete static_cast(root); - } - } - root = nullptr; - leftmost = nullptr; - } - - /** - * Swaps the content of this tree with the given tree. This - * is a much more efficient operation than creating a copy and - * realizing the swap utilizing assignment operations. - */ - void swap(btree& other) { - // swap the content - std::swap(root, other.root); - std::swap(leftmost, other.leftmost); - } - - // Implementation of the assignment operation for trees. - btree& operator=(const btree& other) { - // check identity - if (this == &other) { - return *this; - } - - // create a deep-copy of the content of the other tree - // shortcut for empty sets - if (other.empty()) { - return *this; - } - - // clone content (deep copy) - root = other.root->clone(); - - // update leftmost reference - auto tmp = root; - while (!tmp->isLeaf()) { - tmp = tmp->getChild(0); - } - leftmost = static_cast(tmp); - - // done - return *this; - } - - // Implementation of an equality operation for trees. - bool operator==(const btree& other) const { - // check identity - if (this == &other) { - return true; - } - - // check size - if (size() != other.size()) { - return false; - } - if (size() < other.size()) { - return other == *this; - } - - // check content - for (const auto& key : other) { - if (!contains(key)) { - return false; - } - } - return true; - } - - // Implementation of an inequality operation for trees. - bool operator!=(const btree& other) const { - return !(*this == other); - } - - // -- for debugging -- - - // Determines the number of levels contained in this tree. - size_type getDepth() const { - return (empty()) ? 0 : root->getDepth(); - } - - // Determines the number of nodes contained in this tree. - size_type getNumNodes() const { - return (empty()) ? 0 : root->countNodes(); - } - - // Determines the amount of memory used by this data structure - size_type getMemoryUsage() const { - return sizeof(*this) + (empty() ? 0 : root->getMemoryUsage()); - } - - /* - * Prints a textual representation of this tree to the given - * output stream (mostly for debugging and tuning). - */ - void printTree(std::ostream& out = std::cout) const { - out << "B-Tree with " << size() << " elements:\n"; - if (empty()) { - out << " - empty - \n"; - } else { - root->printTree(out, ""); - } - } - - /** - * Prints a textual summary of statistical properties of this - * tree to the given output stream (for debugging and tuning). - */ - void printStats(std::ostream& out = std::cout) const { - auto nodes = getNumNodes(); - out << " ---------------------------------\n"; - out << " Elements: " << size() << "\n"; - out << " Depth: " << (empty() ? 0 : root->getDepth()) << "\n"; - out << " Nodes: " << nodes << "\n"; - out << " ---------------------------------\n"; - out << " Size of inner node: " << sizeof(inner_node) << "\n"; - out << " Size of leaf node: " << sizeof(leaf_node) << "\n"; - out << " Size of Key: " << sizeof(Key) << "\n"; - out << " max keys / node: " << node::maxKeys << "\n"; - out << " avg keys / node: " << (size() / (double)nodes) << "\n"; - out << " avg filling rate: " << ((size() / (double)nodes) / node::maxKeys) << "\n"; - out << " ---------------------------------\n"; - out << " insert-hint (hits/misses/total): " << hint_stats.inserts.getHits() << "/" - << hint_stats.inserts.getMisses() << "/" << hint_stats.inserts.getAccesses() << "\n"; - out << " contains-hint(hits/misses/total):" << hint_stats.contains.getHits() << "/" - << hint_stats.contains.getMisses() << "/" << hint_stats.contains.getAccesses() << "\n"; - out << " lower-bound-hint (hits/misses/total):" << hint_stats.lower_bound.getHits() << "/" - << hint_stats.lower_bound.getMisses() << "/" << hint_stats.lower_bound.getAccesses() << "\n"; - out << " upper-bound-hint (hits/misses/total):" << hint_stats.upper_bound.getHits() << "/" - << hint_stats.upper_bound.getMisses() << "/" << hint_stats.upper_bound.getAccesses() << "\n"; - out << " ---------------------------------\n"; - } - - /** - * Checks the consistency of this tree. - */ - bool check() { - auto ok = empty() || root->check(comp, root); - if (!ok) { - printTree(); - } - return ok; - } - - /** - * A static member enabling the bulk-load of ordered data into an empty - * tree. This function is much more efficient in creating a index over - * an ordered set of elements than an iterative insertion of values. - * - * @tparam Iter .. the type of iterator specifying the range - * it must be a random-access iterator - */ - template - static typename std::enable_if::iterator_category, - std::random_access_iterator_tag>::value, - R>::type - load(const Iter& a, const Iter& b) { - // quick exit - empty range - if (a == b) { - return R(); - } - - // resolve tree recursively - auto root = buildSubTree(a, b - 1); - - // find leftmost node - node* leftmost = root; - while (!leftmost->isLeaf()) { - leftmost = leftmost->getChild(0); - } - - // build result - return R(b - a, root, static_cast(leftmost)); - } - -protected: - /** - * Determines whether the range covered by the given node is also - * covering the given key value. - */ - bool covers(const node* node, const Key& k) const { - if (isSet) { - // in sets we can include the ends as covered elements - return !node->isEmpty() && !less(k, node->keys[0]) && !less(node->keys[node->numElements - 1], k); - } - // in multi-sets the ends may not be completely covered - return !node->isEmpty() && less(node->keys[0], k) && less(k, node->keys[node->numElements - 1]); - } - - /** - * Determines whether the range covered by the given node is also - * covering the given key value. - */ - bool weak_covers(const node* node, const Key& k) const { - if (isSet) { - // in sets we can include the ends as covered elements - return !node->isEmpty() && !weak_less(k, node->keys[0]) && - !weak_less(node->keys[node->numElements - 1], k); - } - // in multi-sets the ends may not be completely covered - return !node->isEmpty() && weak_less(node->keys[0], k) && - weak_less(k, node->keys[node->numElements - 1]); - } - -private: - /** - * Determines whether the range covered by this node covers - * the upper bound of the given key. - */ - bool coversUpperBound(const node* node, const Key& k) const { - // ignore edges - return !node->isEmpty() && !less(k, node->keys[0]) && less(k, node->keys[node->numElements - 1]); - } - - // Utility function for the load operation above. - template - static node* buildSubTree(const Iter& a, const Iter& b) { - const int N = node::maxKeys; - - // divide range in N+1 sub-ranges - int length = (b - a) + 1; - - // terminal case: length is less then maxKeys - if (length <= N) { - // create a leaf node - node* res = new leaf_node(); - res->numElements = length; - - for (int i = 0; i < length; ++i) { - res->keys[i] = a[i]; - } - - return res; - } - - // recursive case - compute step size - int numKeys = N; - int step = ((length - numKeys) / (numKeys + 1)); - - while (numKeys > 1 && (step < N / 2)) { - numKeys--; - step = ((length - numKeys) / (numKeys + 1)); - } - - // create inner node - node* res = new inner_node(); - res->numElements = numKeys; - - Iter c = a; - for (int i = 0; i < numKeys; i++) { - // get dividing key - res->keys[i] = c[step]; - - // get sub-tree - auto child = buildSubTree(c, c + (step - 1)); - child->parent = res; - child->position = i; - res->getChildren()[i] = child; - - c = c + (step + 1); - } - - // and the remaining part - auto child = buildSubTree(c, b); - child->parent = res; - child->position = numKeys; - res->getChildren()[numKeys] = child; - - // done - return res; - } -}; // namespace souffle - -// Instantiation of static member search. -template -const SearchStrategy - btree::search; - -} // end namespace detail - -/** - * A b-tree based set implementation. - * - * @tparam Key .. the element type to be stored in this set - * @tparam Comparator .. a class defining an order on the stored elements - * @tparam Allocator .. utilized for allocating memory for required nodes - * @tparam blockSize .. determines the number of bytes/block utilized by leaf nodes - * @tparam SearchStrategy .. enables switching between linear, binary or any other search strategy - */ -template , - typename Allocator = std::allocator, // is ignored so far - unsigned blockSize = 256, - typename SearchStrategy = typename souffle::detail::default_strategy::type, - typename WeakComparator = Comparator, typename Updater = souffle::detail::updater> -class btree_set : public souffle::detail::btree { - using super = souffle::detail::btree; - - friend class souffle::detail::btree; - -public: - /** - * A default constructor creating an empty set. - */ - btree_set(const Comparator& comp = Comparator(), const WeakComparator& weak_comp = WeakComparator()) - : super(comp, weak_comp) {} - - /** - * A constructor creating a set based on the given range. - */ - template - btree_set(const Iter& a, const Iter& b) { - this->insert(a, b); - } - - // A copy constructor. - btree_set(const btree_set& other) : super(other) {} - - // A move constructor. - btree_set(btree_set&& other) : super(std::move(other)) {} - -private: - // A constructor required by the bulk-load facility. - template - btree_set(s size, n* root, l* leftmost) : super(size, root, leftmost) {} - -public: - // Support for the assignment operator. - btree_set& operator=(const btree_set& other) { - super::operator=(other); - return *this; - } - - // Support for the bulk-load operator. - template - static btree_set load(const Iter& a, const Iter& b) { - return super::template load(a, b); - } -}; - -/** - * A b-tree based multi-set implementation. - * - * @tparam Key .. the element type to be stored in this set - * @tparam Comparator .. a class defining an order on the stored elements - * @tparam Allocator .. utilized for allocating memory for required nodes - * @tparam blockSize .. determines the number of bytes/block utilized by leaf nodes - * @tparam SearchStrategy .. enables switching between linear, binary or any other search strategy - */ -template , - typename Allocator = std::allocator, // is ignored so far - unsigned blockSize = 256, - typename SearchStrategy = typename souffle::detail::default_strategy::type, - typename WeakComparator = Comparator, typename Updater = souffle::detail::updater> -class btree_multiset : public souffle::detail::btree { - using super = souffle::detail::btree; - - friend class souffle::detail::btree; - -public: - /** - * A default constructor creating an empty set. - */ - btree_multiset(const Comparator& comp = Comparator(), const WeakComparator& weak_comp = WeakComparator()) - : super(comp, weak_comp) {} - - /** - * A constructor creating a set based on the given range. - */ - template - btree_multiset(const Iter& a, const Iter& b) { - this->insert(a, b); - } - - // A copy constructor. - btree_multiset(const btree_multiset& other) : super(other) {} - - // A move constructor. - btree_multiset(btree_multiset&& other) : super(std::move(other)) {} - -private: - // A constructor required by the bulk-load facility. - template - btree_multiset(s size, n* root, l* leftmost) : super(size, root, leftmost) {} - -public: - // Support for the assignment operator. - btree_multiset& operator=(const btree_multiset& other) { - super::operator=(other); - return *this; - } - - // Support for the bulk-load operator. - template - static btree_multiset load(const Iter& a, const Iter& b) { - return super::template load(a, b); - } -}; - -} // end of namespace souffle diff --git a/cbits/souffle/Brie.h b/cbits/souffle/Brie.h deleted file mode 100644 --- a/cbits/souffle/Brie.h +++ /dev/null @@ -1,3166 +0,0 @@ -/* - * Souffle - A Datalog Compiler - * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved - * Licensed under the Universal Permissive License v 1.0 as shown at: - * - https://opensource.org/licenses/UPL - * - /licenses/SOUFFLE-UPL.txt - */ - -/************************************************************************ - * - * @file Brie.h - * - * This header file contains the implementation for a generic, fixed - * length integer trie. - * - * Tries trie is utilized to store n-ary tuples of integers. Each level - * is implemented via a sparse array (also covered by this header file), - * referencing the following nested level. The leaf level is realized - * by a sparse bit-map to minimize the memory footprint. - * - * Multiple insert operations can be be conducted concurrently on trie - * structures. So can read-only operations. However, inserts and read - * operations may not be conducted at the same time. - * - ***********************************************************************/ - -#pragma once - -#include "CompiledTuple.h" -#include "RamTypes.h" -#include "utility/CacheUtil.h" -#include "utility/ContainerUtil.h" -#include "utility/StreamUtil.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef _WIN32 -/** - * When compiling for windows, redefine the gcc builtins which are used to - * their equivalents on the windows platform. - */ -#define __sync_synchronize MemoryBarrier -#define __sync_bool_compare_and_swap(ptr, oldval, newval) \ - (InterlockedCompareExchangePointer((void* volatile*)ptr, (void*)newval, (void*)oldval) == (void*)oldval) -#endif // _WIN32 - -namespace souffle { - -namespace detail { - -/** - * A templated functor to obtain default values for - * unspecified elements of sparse array instances. - */ -template -struct default_factory { - T operator()() const { - return T(); // just use the default constructor - } -}; - -/** - * A functor representing the identity function. - */ -template -struct identity { - T operator()(T v) const { - return v; - } -}; - -/** - * A operation to be utilized by the sparse map when merging - * elements associated to different values. - */ -template -struct default_merge { - /** - * Merges two values a and b when merging spase maps. - */ - T operator()(T a, T b) const { - default_factory def; - // if a is the default => us b, else stick to a - return (a != def()) ? a : b; - } -}; - -} // end namespace detail - -/** - * A sparse array simulates an array associating to every element - * of uint32_t an element of a generic type T. Any non-defined element - * will be default-initialized utilizing the detail::default_factory - * functor. - * - * Internally the array is organized as a balanced tree. The leaf - * level of the tree corresponds to the elements of the represented - * array. Inner nodes utilize individual bits of the indices to reference - * sub-trees. For efficiency reasons, only the minimal sub-tree required - * to cover all non-null / non-default values stored in the array is - * maintained. Furthermore, several levels of nodes are aggreated in a - * B-tree like fashion to inprove cache utilization and reduce the number - * of steps required for lookup and insert operations. - * - * @tparam T the type of the stored elements - * @tparam BITS the number of bits consumed per node-level - * e.g. if it is set to 3, the resulting tree will be of a degree of - * 2^3=8, and thus 8 child-pointers will be stored in each inner node - * and as many values will be stored in each leaf node. - * @tparam merge_op the functor to be utilized when merging the content of two - * instances of this type. - * @tparam copy_op a functor to be applied to each stored value when copying an - * instance of this array. For instance, this is utilized by the - * trie implementation to create a clone of each sub-tree instead - * of preserving the original pointer. - */ -template , - typename copy_op = detail::identity> -class SparseArray { - using key_type = uint64_t; - - // some internal constants - static constexpr int BIT_PER_STEP = BITS; - static constexpr int NUM_CELLS = 1 << BIT_PER_STEP; - static constexpr key_type INDEX_MASK = NUM_CELLS - 1; - -public: - // the type utilized for indexing contained elements - using index_type = key_type; - - // the type of value stored in this array - using value_type = T; - - // the atomic view on stored values - using atomic_value_type = std::atomic; - -private: - struct Node; - - /** - * The value stored in a single cell of a inner - * or leaf node. - */ - union Cell { - // an atomic view on the pointer referencing a nested level - std::atomic aptr; - - // a pointer to the nested level (unsynchronized operations) - Node* ptr; - - // an atomic view on the value stored in this cell (leaf node) - atomic_value_type avalue; - - // the value stored in this cell (unsynchronized access, leaf node) - value_type value; - }; - - /** - * The node type of the internally maintained tree. - */ - struct Node { - // a pointer to the parent node (for efficient iteration) - const Node* parent; - // the pointers to the child nodes (inner nodes) or the stored values (leaf nodes) - Cell cell[NUM_CELLS]; - }; - - /** - * A struct describing all the information required by the container - * class to manage the wrapped up tree. - */ - struct RootInfo { - // the root node of the tree - Node* root; - // the number of levels of the tree - uint32_t levels; - // the absolute offset of the theoretical first element in the tree - index_type offset; - - // the first leaf node in the tree - Node* first; - // the absolute offset of the first element in the first leaf node - index_type firstOffset; - }; - - union { - RootInfo unsynced; // for sequential operations - volatile RootInfo synced; // for synchronized operations - }; - -public: - /** - * A default constructor creating an empty sparse array. - */ - SparseArray() : unsynced(RootInfo{nullptr, 0, 0, nullptr, std::numeric_limits::max()}) {} - - /** - * A copy constructor for sparse arrays. It creates a deep - * copy of the data structure maintained by the handed in - * array instance. - */ - SparseArray(const SparseArray& other) - : unsynced(RootInfo{clone(other.unsynced.root, other.unsynced.levels), other.unsynced.levels, - other.unsynced.offset, nullptr, other.unsynced.firstOffset}) { - if (unsynced.root) { - unsynced.root->parent = nullptr; - unsynced.first = findFirst(unsynced.root, unsynced.levels); - } - } - - /** - * A r-value based copy constructor for sparse arrays. It - * takes over ownership of the structure maintained by the - * handed in array. - */ - SparseArray(SparseArray&& other) - : unsynced(RootInfo{other.unsynced.root, other.unsynced.levels, other.unsynced.offset, - other.unsynced.first, other.unsynced.firstOffset}) { - other.unsynced.root = nullptr; - other.unsynced.levels = 0; - other.unsynced.first = nullptr; - } - - /** - * A destructor for sparse arrays clearing up the internally - * maintained data structure. - */ - ~SparseArray() { - clean(); - } - - /** - * An assignment creating a deep copy of the handed in - * array structure (utilizing the copy functor provided - * as a template parameter). - */ - SparseArray& operator=(const SparseArray& other) { - if (this == &other) return *this; - - // clean this one - clean(); - - // copy content - unsynced.levels = other.unsynced.levels; - unsynced.root = clone(other.unsynced.root, unsynced.levels); - if (unsynced.root) { - unsynced.root->parent = nullptr; - } - unsynced.offset = other.unsynced.offset; - unsynced.first = (unsynced.root) ? findFirst(unsynced.root, unsynced.levels) : nullptr; - unsynced.firstOffset = other.unsynced.firstOffset; - - // done - return *this; - } - - /** - * An assignment operation taking over ownership - * from a r-value reference to a sparse array. - */ - SparseArray& operator=(SparseArray&& other) { - // clean this one - clean(); - - // harvest content - unsynced.root = other.unsynced.root; - unsynced.levels = other.unsynced.levels; - unsynced.offset = other.unsynced.offset; - unsynced.first = other.unsynced.first; - unsynced.firstOffset = other.unsynced.firstOffset; - - // reset other - other.unsynced.root = nullptr; - other.unsynced.levels = 0; - other.unsynced.first = nullptr; - - // done - return *this; - } - - /** - * Tests whether this sparse array is empty, thus it only - * contains default-values, or not. - */ - bool empty() const { - return unsynced.root == nullptr; - } - - /** - * Computes the number of non-empty elements within this - * sparse array. - */ - std::size_t size() const { - // quick one for the empty map - if (empty()) return 0; - - // count elements -- since maintaining is making inserts more expensive - std::size_t res = 0; - for (auto it = begin(); it != end(); ++it) { - ++res; - } - return res; - } - -private: - /** - * Computes the memory usage of the given sub-tree. - */ - static std::size_t getMemoryUsage(const Node* node, int level) { - // support null-nodes - if (!node) return 0; - - // add size of current node - std::size_t res = sizeof(Node); - - // sum up memory usage of child nodes - if (level > 0) { - for (int i = 0; i < NUM_CELLS; i++) { - res += getMemoryUsage(node->cell[i].ptr, level - 1); - } - } - - // done - return res; - } - -public: - /** - * Computes the total memory usage of this data structure. - */ - std::size_t getMemoryUsage() const { - // the memory of the wrapper class - std::size_t res = sizeof(*this); - - // add nodes - if (unsynced.root) { - res += getMemoryUsage(unsynced.root, unsynced.levels); - } - - // done - return res; - } - - /** - * Resets the content of this array to default values for each contained - * element. - */ - void clear() { - clean(); - unsynced.root = nullptr; - unsynced.levels = 0; - unsynced.first = nullptr; - unsynced.firstOffset = std::numeric_limits::max(); - } - - /** - * A struct to be utilized as a local, temporal context by client code - * to speed up the execution of various operations (optional parameter). - */ - struct op_context { - index_type lastIndex{0}; - Node* lastNode{nullptr}; - op_context() = default; - }; - -private: - // --------------------------------------------------------------------- - // Optimistic Locking of Root-Level Infos - // --------------------------------------------------------------------- - - /** - * A struct to cover a snapshot of the root node state. - */ - struct RootInfoSnapshot { - // the current pointer to a root node - Node* root; - // the current number of levels - uint32_t levels; - // the current offset of the first theoretical element - index_type offset; - // a version number for the optimistic locking - uintptr_t version; - }; - - /** - * Obtains the current version of the root. - */ - uint64_t getRootVersion() const { - // here it is assumed that the load of a 64-bit word is atomic - return (uint64_t)synced.root; - } - - /** - * Obtains a snapshot of the current root information. - */ - RootInfoSnapshot getRootInfo() const { - RootInfoSnapshot res{}; - do { - // first take the mod counter - do { - // if res.mod % 2 == 1 .. there is an update in progress - res.version = getRootVersion(); - } while (res.version % 2); - - // then the rest - res.root = synced.root; - res.levels = synced.levels; - res.offset = synced.offset; - - // check consistency of obtained data (optimistic locking) - } while (res.version != getRootVersion()); - - // got a consistent snapshot - return res; - } - - /** - * Updates the current root information based on the handed in modified - * snapshot instance if the version number of the snapshot still corresponds - * to the current version. Otherwise a concurrent update took place and the - * operation is aborted. - * - * @param info the updated information to be assigned to the active root-info data - * @return true if successfully updated, false if aborted - */ - bool tryUpdateRootInfo(const RootInfoSnapshot& info) { - // check mod counter - uintptr_t version = info.version; - - // update root to invalid pointer (ending with 1) - if (!__sync_bool_compare_and_swap(&synced.root, (Node*)version, (Node*)(version + 1))) { - return false; - } - - // conduct update - synced.levels = info.levels; - synced.offset = info.offset; - - // update root (and thus the version to enable future retrievals) - __sync_synchronize(); - synced.root = info.root; - - // done - return true; - } - - /** - * A struct summarizing the state of the first node reference. - */ - struct FirstInfoSnapshot { - // the pointer to the first node - Node* node; - // the offset of the first node - index_type offset; - // the version number of the first node (for the optimistic locking) - uintptr_t version; - }; - - /** - * Obtains the current version number of the first node information. - */ - uint64_t getFirstVersion() const { - // here it is assumed that the load of a 64-bit word is atomic - return (uint64_t)synced.first; - } - - /** - * Obtains a snapshot of the current first-node information. - */ - FirstInfoSnapshot getFirstInfo() const { - FirstInfoSnapshot res{}; - do { - // first take the version - do { - res.version = getFirstVersion(); - } while (res.version % 2); - - // collect the values - res.node = synced.first; - res.offset = synced.firstOffset; - - } while (res.version != getFirstVersion()); - - // we got a consistent snapshot - return res; - } - - /** - * Updates the information stored regarding the first node in a - * concurrent setting utilizing a optimistic locking approach. - * This is identical to the approach utilized for the root info. - */ - bool tryUpdateFirstInfo(const FirstInfoSnapshot& info) { - // check mod counter - uintptr_t version = info.version; - - // temporary update first pointer to point to uneven value (lock-out) - if (!__sync_bool_compare_and_swap(&synced.first, (Node*)version, (Node*)(version + 1))) { - return false; - } - - // conduct update - synced.firstOffset = info.offset; - - // update node pointer (and thus the version number) - __sync_synchronize(); - synced.first = info.node; // must be last (and atomic) - - // done - return true; - } - -public: - /** - * Obtains a mutable reference to the value addressed by the given index. - * - * @param i the index of the element to be addressed - * @return a mutable reference to the corresponding element - */ - value_type& get(index_type i) { - op_context ctxt; - return get(i, ctxt); - } - - /** - * Obtains a mutable reference to the value addressed by the given index. - * - * @param i the index of the element to be addressed - * @param ctxt a operation context to exploit state-less temporal locality - * @return a mutable reference to the corresponding element - */ - value_type& get(index_type i, op_context& ctxt) { - return getLeaf(i, ctxt).value; - } - - /** - * Obtains a mutable reference to the atomic value addressed by the given index. - * - * @param i the index of the element to be addressed - * @return a mutable reference to the corresponding element - */ - atomic_value_type& getAtomic(index_type i) { - op_context ctxt; - return getAtomic(i, ctxt); - } - - /** - * Obtains a mutable reference to the atomic value addressed by the given index. - * - * @param i the index of the element to be addressed - * @param ctxt a operation context to exploit state-less temporal locality - * @return a mutable reference to the corresponding element - */ - atomic_value_type& getAtomic(index_type i, op_context& ctxt) { - return getLeaf(i, ctxt).avalue; - } - -private: - /** - * An internal function capable of navigating to a given leaf node entry. - * If the cell does not exist yet it will be created as a side-effect. - * - * @param i the index of the requested cell - * @param ctxt a operation context to exploit state-less temporal locality - * @return a reference to the requested cell - */ - inline Cell& getLeaf(index_type i, op_context& ctxt) { - // check context - if (ctxt.lastNode && (ctxt.lastIndex == (i & ~INDEX_MASK))) { - // return reference to referenced - return ctxt.lastNode->cell[i & INDEX_MASK]; - } - - // get snapshot of root - auto info = getRootInfo(); - - // check for emptiness - if (info.root == nullptr) { - // build new root node - info.root = newNode(); - - // initialize the new node - info.root->parent = nullptr; - info.offset = i & ~(INDEX_MASK); - - // try updating root information atomically - if (tryUpdateRootInfo(info)) { - // success -- finish get call - - // update first - auto firstInfo = getFirstInfo(); - while (info.offset < firstInfo.offset) { - firstInfo.node = info.root; - firstInfo.offset = info.offset; - if (!tryUpdateFirstInfo(firstInfo)) { - // there was some concurrent update => check again - firstInfo = getFirstInfo(); - } - } - - // return reference to proper cell - return info.root->cell[i & INDEX_MASK]; - } - - // somebody else was faster => use standard insertion procedure - delete info.root; - - // retrieve new root info - info = getRootInfo(); - - // make sure there is a root - assert(info.root); - } - - // for all other inserts - // - check boundary - // - navigate to node - // - insert value - - // check boundaries - while (!inBoundaries(i, info.levels, info.offset)) { - // boundaries need to be expanded by growing upwards - raiseLevel(info); // try raising level unless someone else did already - // update root info - info = getRootInfo(); - } - - // navigate to node - Node* node = info.root; - unsigned level = info.levels; - while (level != 0) { - // get X coordinate - auto x = getIndex(i, level); - - // decrease level counter - --level; - - // check next node - std::atomic& aNext = node->cell[x].aptr; - Node* next = aNext; - if (!next) { - // create new sub-tree - Node* newNext = newNode(); - newNext->parent = node; - - // try to update next - if (!aNext.compare_exchange_strong(next, newNext)) { - // some other thread was faster => use updated next - delete newNext; - } else { - // the locally created next is the new next - next = newNext; - - // update first - if (level == 0) { - // compute offset of this node - auto off = i & ~INDEX_MASK; - - // fast over-approximation of whether a update is necessary - if (off < unsynced.firstOffset) { - // update first reference if this one is the smallest - auto first_info = getFirstInfo(); - while (off < first_info.offset) { - first_info.node = next; - first_info.offset = off; - if (!tryUpdateFirstInfo(first_info)) { - // there was some concurrent update => check again - first_info = getFirstInfo(); - } - } - } - } - } - - // now next should be defined - assert(next); - } - - // continue one level below - node = next; - } - - // update context - ctxt.lastIndex = (i & ~INDEX_MASK); - ctxt.lastNode = node; - - // return reference to cell - return node->cell[i & INDEX_MASK]; - } - -public: - /** - * Updates the value stored in cell i by the given value. - */ - void update(index_type i, const value_type& val) { - op_context ctxt; - update(i, val, ctxt); - } - - /** - * Updates the value stored in cell i by the given value. A operation - * context can be provided for exploiting temporal locality. - */ - void update(index_type i, const value_type& val, op_context& ctxt) { - get(i, ctxt) = val; - } - - /** - * Obtains the value associated to index i -- which might be - * the default value of the covered type if the value hasn't been - * defined previously. - */ - value_type operator[](index_type i) const { - return lookup(i); - } - - /** - * Obtains the value associated to index i -- which might be - * the default value of the covered type if the value hasn't been - * defined previously. - */ - value_type lookup(index_type i) const { - op_context ctxt; - return lookup(i, ctxt); - } - - /** - * Obtains the value associated to index i -- which might be - * the default value of the covered type if the value hasn't been - * defined previously. A operation context can be provided for - * exploiting temporal locality. - */ - value_type lookup(index_type i, op_context& ctxt) const { - // check whether it is empty - if (!unsynced.root) return souffle::detail::default_factory()(); - - // check boundaries - if (!inBoundaries(i)) return souffle::detail::default_factory()(); - - // check context - if (ctxt.lastNode && ctxt.lastIndex == (i & ~INDEX_MASK)) { - return ctxt.lastNode->cell[i & INDEX_MASK].value; - } - - // navigate to value - Node* node = unsynced.root; - unsigned level = unsynced.levels; - while (level != 0) { - // get X coordinate - auto x = getIndex(i, level); - - // decrease level counter - --level; - - // check next node - Node* next = node->cell[x].ptr; - - // check next step - if (!next) return souffle::detail::default_factory()(); - - // continue one level below - node = next; - } - - // remember context - ctxt.lastIndex = (i & ~INDEX_MASK); - ctxt.lastNode = node; - - // return reference to cell - return node->cell[i & INDEX_MASK].value; - } - -private: - /** - * A static operation utilized internally for merging sub-trees recursively. - * - * @param parent the parent node of the current merge operation - * @param trg a reference to the pointer the cloned node should be stored to - * @param src the node to be cloned - * @param levels the height of the cloned node - */ - static void merge(const Node* parent, Node*& trg, const Node* src, int levels) { - // if other side is null => done - if (src == nullptr) { - return; - } - - // if the trg sub-tree is empty, clone the corresponding branch - if (trg == nullptr) { - trg = clone(src, levels); - if (trg != nullptr) { - trg->parent = parent; - } - return; // done - } - - // otherwise merge recursively - - // the leaf-node step - if (levels == 0) { - merge_op merg; - for (int i = 0; i < NUM_CELLS; ++i) { - trg->cell[i].value = merg(trg->cell[i].value, src->cell[i].value); - } - return; - } - - // the recursive step - for (int i = 0; i < NUM_CELLS; ++i) { - merge(trg, trg->cell[i].ptr, src->cell[i].ptr, levels - 1); - } - } - -public: - /** - * Adds all the values stored in the given array to this array. - */ - void addAll(const SparseArray& other) { - // skip if other is empty - if (other.empty()) { - return; - } - - // special case: emptiness - if (empty()) { - // use assignment operator - *this = other; - return; - } - - // adjust levels - while (unsynced.levels < other.unsynced.levels || !inBoundaries(other.unsynced.offset)) { - raiseLevel(); - } - - // navigate to root node equivalent of the other node in this tree - auto level = unsynced.levels; - Node** node = &unsynced.root; - while (level > other.unsynced.levels) { - // get X coordinate - auto x = getIndex(other.unsynced.offset, level); - - // decrease level counter - --level; - - // check next node - Node*& next = (*node)->cell[x].ptr; - if (!next) { - // create new sub-tree - next = newNode(); - next->parent = *node; - } - - // continue one level below - node = &next; - } - - // merge sub-branches from here - merge((*node)->parent, *node, other.unsynced.root, level); - - // update first - if (unsynced.firstOffset > other.unsynced.firstOffset) { - unsynced.first = findFirst(*node, level); - unsynced.firstOffset = other.unsynced.firstOffset; - } - } - - // --------------------------------------------------------------------- - // Iterator - // --------------------------------------------------------------------- - - /** - * The iterator type to be utilized to iterate over the non-default elements of this array. - */ - class iterator { - using pair_type = std::pair; - - // a pointer to the leaf node currently processed or null (end) - const Node* node; - - // the value currently pointed to - pair_type value; - - public: - // default constructor -- creating an end-iterator - iterator() : node(nullptr) {} - - iterator(const Node* node, pair_type value) : node(node), value(std::move(value)) {} - - iterator(const Node* first, index_type firstOffset) : node(first), value(firstOffset, 0) { - // if the start is the end => we are done - if (!first) return; - - // load the value - if (first->cell[0].value == value_type()) { - ++(*this); // walk to first element - } else { - value.second = first->cell[0].value; - } - } - - // a copy constructor - iterator(const iterator& other) = default; - - // an assignment operator - iterator& operator=(const iterator& other) = default; - - // the equality operator as required by the iterator concept - bool operator==(const iterator& other) const { - // only equivalent if pointing to the end - return (node == nullptr && other.node == nullptr) || - (node == other.node && value.first == other.value.first); - } - - // the not-equality operator as required by the iterator concept - bool operator!=(const iterator& other) const { - return !(*this == other); - } - - // the deref operator as required by the iterator concept - const pair_type& operator*() const { - return value; - } - - // support for the pointer operator - const pair_type* operator->() const { - return &value; - } - - // the increment operator as required by the iterator concept - iterator& operator++() { - // get current offset - index_type x = value.first & INDEX_MASK; - - // go to next non-empty value in current node - do { - x++; - } while (x < NUM_CELLS && node->cell[x].value == value_type()); - - // check whether one has been found - if (x < NUM_CELLS) { - // update value and be done - value.first = (value.first & ~INDEX_MASK) | x; - value.second = node->cell[x].value; - return *this; // done - } - - // go to parent - node = node->parent; - int level = 1; - - // get current index on this level - x = getIndex(value.first, level); - x++; - - while (level > 0 && node) { - // search for next child - while (x < NUM_CELLS) { - if (node->cell[x].ptr != nullptr) { - break; - } - x++; - } - - // pick next step - if (x < NUM_CELLS) { - // going down - node = node->cell[x].ptr; - value.first &= getLevelMask(level + 1); - value.first |= x << (BIT_PER_STEP * level); - level--; - x = 0; - } else { - // going up - node = node->parent; - level++; - - // get current index on this level - x = getIndex(value.first, level); - x++; // go one step further - } - } - - // check whether it is the end of range - if (node == nullptr) { - return *this; - } - - // search the first value in this node - x = 0; - while (node->cell[x].value == value_type()) { - x++; - } - - // update value - value.first |= x; - value.second = node->cell[x].value; - - // done - return *this; - } - - // True if this iterator is passed the last element. - bool isEnd() const { - return node == nullptr; - } - - // enables this iterator core to be printed (for debugging) - void print(std::ostream& out) const { - out << "SparseArrayIter(" << node << " @ " << value << ")"; - } - - friend std::ostream& operator<<(std::ostream& out, const iterator& iter) { - iter.print(out); - return out; - } - }; - - /** - * Obtains an iterator referencing the first non-default element or end in - * case there are no such elements. - */ - iterator begin() const { - return iterator(unsynced.first, unsynced.firstOffset); - } - - /** - * An iterator referencing the position after the last non-default element. - */ - iterator end() const { - return iterator(); - } - - /** - * An operation to obtain an iterator referencing an element addressed by the - * given index. If the corresponding element is a non-default value, a corresponding - * iterator will be returned. Otherwise end() will be returned. - */ - iterator find(index_type i) const { - op_context ctxt; - return find(i, ctxt); - } - - /** - * An operation to obtain an iterator referencing an element addressed by the - * given index. If the corresponding element is a non-default value, a corresponding - * iterator will be returned. Otherwise end() will be returned. A operation context - * can be provided for exploiting temporal locality. - */ - iterator find(index_type i, op_context& ctxt) const { - // check whether it is empty - if (!unsynced.root) return end(); - - // check boundaries - if (!inBoundaries(i)) return end(); - - // check context - if (ctxt.lastNode && ctxt.lastIndex == (i & ~INDEX_MASK)) { - Node* node = ctxt.lastNode; - - // check whether there is a proper entry - value_type value = node->cell[i & INDEX_MASK].value; - if (value == value_type{}) { - return end(); - } - // return iterator pointing to value - return iterator(node, std::make_pair(i, value)); - } - - // navigate to value - Node* node = unsynced.root; - unsigned level = unsynced.levels; - while (level != 0) { - // get X coordinate - auto x = getIndex(i, level); - - // decrease level counter - --level; - - // check next node - Node* next = node->cell[x].ptr; - - // check next step - if (!next) return end(); - - // continue one level below - node = next; - } - - // register in context - ctxt.lastNode = node; - ctxt.lastIndex = (i & ~INDEX_MASK); - - // check whether there is a proper entry - value_type value = node->cell[i & INDEX_MASK].value; - if (value == value_type{}) { - return end(); - } - - // return iterator pointing to cell - return iterator(node, std::make_pair(i, value)); - } - - /** - * An operation obtaining the smallest non-default element such that it's index is >= - * the given index. - */ - iterator lowerBound(index_type i) const { - op_context ctxt; - return lowerBound(i, ctxt); - } - - /** - * An operation obtaining the smallest non-default element such that it's index is >= - * the given index. A operation context can be provided for exploiting temporal locality. - */ - iterator lowerBound(index_type i, op_context&) const { - // check whether it is empty - if (!unsynced.root) return end(); - - // check boundaries - if (!inBoundaries(i)) { - // if it is on the lower end, return minimum result - if (i < unsynced.offset) { - const auto& value = unsynced.first->cell[0].value; - auto res = iterator(unsynced.first, std::make_pair(unsynced.offset, value)); - if (value == value_type()) { - ++res; - } - return res; - } - // otherwise it is on the high end, return end iterator - return end(); - } - - // navigate to value - Node* node = unsynced.root; - unsigned level = unsynced.levels; - while (true) { - // get X coordinate - auto x = getIndex(i, level); - - // check next node - Node* next = node->cell[x].ptr; - - // check next step - if (!next) { - if (x == NUM_CELLS - 1) { - ++level; - node = const_cast(node->parent); - if (!node) return end(); - } - - // continue search - i = i & getLevelMask(level); - - // find next higher value - i += 1ull << (BITS * level); - - } else { - if (level == 0) { - // found boundary - return iterator(node, std::make_pair(i, node->cell[x].value)); - } - - // decrease level counter - --level; - - // continue one level below - node = next; - } - } - } - - /** - * An operation obtaining the smallest non-default element such that it's index is greater - * the given index. - */ - iterator upperBound(index_type i) const { - op_context ctxt; - return upperBound(i, ctxt); - } - - /** - * An operation obtaining the smallest non-default element such that it's index is greater - * the given index. A operation context can be provided for exploiting temporal locality. - */ - iterator upperBound(index_type i, op_context& ctxt) const { - if (i == std::numeric_limits::max()) { - return end(); - } - return lowerBound(i + 1, ctxt); - } - -private: - /** - * An internal debug utility printing the internal structure of this sparse array to the given output - * stream. - */ - void dump(bool detailed, std::ostream& out, const Node& node, int level, index_type offset, - int indent = 0) const { - auto x = getIndex(offset, level + 1); - out << times("\t", indent) << x << ": Node " << &node << " on level " << level - << " parent: " << node.parent << " -- range: " << offset << " - " - << (offset + ~getLevelMask(level + 1)) << "\n"; - - if (level == 0) { - for (int i = 0; i < NUM_CELLS; i++) { - if (detailed || node.cell[i].value != value_type()) { - out << times("\t", indent + 1) << i << ": [" << (offset + i) << "] " << node.cell[i].value - << "\n"; - } - } - } else { - for (int i = 0; i < NUM_CELLS; i++) { - if (node.cell[i].ptr) { - dump(detailed, out, *node.cell[i].ptr, level - 1, - offset + (i * (index_type(1) << (level * BIT_PER_STEP))), indent + 1); - } else if (detailed) { - auto low = offset + (i * (1 << (level * BIT_PER_STEP))); - auto hig = low + ~getLevelMask(level); - out << times("\t", indent + 1) << i << ": empty range " << low << " - " << hig << "\n"; - } - } - } - out << "\n"; - } - -public: - /** - * A debug utility printing the internal structure of this sparse array to the given output stream. - */ - void dump(bool detail = false, std::ostream& out = std::cout) const { - if (!unsynced.root) { - out << " - empty - \n"; - return; - } - out << "root: " << unsynced.root << "\n"; - out << "offset: " << unsynced.offset << "\n"; - out << "first: " << unsynced.first << "\n"; - out << "fist offset: " << unsynced.firstOffset << "\n"; - dump(detail, out, *unsynced.root, unsynced.levels, unsynced.offset); - } - -private: - // -------------------------------------------------------------------------- - // Utilities - // -------------------------------------------------------------------------- - - /** - * Creates new nodes and initializes them with 0. - */ - static Node* newNode() { - auto* res = new Node(); - std::memset(res->cell, 0, sizeof(Cell) * NUM_CELLS); - return res; - } - - /** - * Destroys a node and all its sub-nodes recursively. - */ - static void freeNodes(Node* node, int level) { - if (!node) return; - if (level != 0) { - for (int i = 0; i < NUM_CELLS; i++) { - freeNodes(node->cell[i].ptr, level - 1); - } - } - delete node; - } - - /** - * Conducts a cleanup of the internal tree structure. - */ - void clean() { - freeNodes(unsynced.root, unsynced.levels); - unsynced.root = nullptr; - unsynced.levels = 0; - } - - /** - * Clones the given node and all its sub-nodes. - */ - static Node* clone(const Node* node, int level) { - // support null-pointers - if (node == nullptr) { - return nullptr; - } - - // create a clone - auto* res = new Node(); - - // handle leaf level - if (level == 0) { - copy_op copy; - for (int i = 0; i < NUM_CELLS; i++) { - res->cell[i].value = copy(node->cell[i].value); - } - return res; - } - - // for inner nodes clone each child - for (int i = 0; i < NUM_CELLS; i++) { - auto cur = clone(node->cell[i].ptr, level - 1); - if (cur != nullptr) { - cur->parent = res; - } - res->cell[i].ptr = cur; - } - - // done - return res; - } - - /** - * Obtains the left-most leaf-node of the tree rooted by the given node - * with the given level. - */ - static Node* findFirst(Node* node, int level) { - while (level > 0) { - bool found = false; - for (int i = 0; i < NUM_CELLS; i++) { - Node* cur = node->cell[i].ptr; - if (cur) { - node = cur; - --level; - found = true; - break; - } - } - assert(found && "No first node!"); - } - - return node; - } - - /** - * Raises the level of this tree by one level. It does so by introducing - * a new root node and inserting the current root node as a child node. - */ - void raiseLevel() { - // something went wrong when we pass that line - assert(unsynced.levels < (sizeof(index_type) * 8 / BITS) + 1); - - // create new root - Node* node = newNode(); - node->parent = nullptr; - - // insert existing root as child - auto x = getIndex(unsynced.offset, unsynced.levels + 1); - node->cell[x].ptr = unsynced.root; - - // swap the root - unsynced.root->parent = node; - - // update root - unsynced.root = node; - ++unsynced.levels; - - // update offset be removing additional bits - unsynced.offset &= getLevelMask(unsynced.levels + 1); - } - - /** - * Attempts to raise the height of this tree based on the given root node - * information and updates the root-info snapshot correspondingly. - */ - void raiseLevel(RootInfoSnapshot& info) { - // something went wrong when we pass that line - assert(info.levels < (sizeof(index_type) * 8 / BITS) + 1); - - // create new root - Node* newRoot = newNode(); - newRoot->parent = nullptr; - - // insert existing root as child - auto x = getIndex(info.offset, info.levels + 1); - newRoot->cell[x].ptr = info.root; - - // exchange the root in the info struct - auto oldRoot = info.root; - info.root = newRoot; - - // update level counter - ++info.levels; - - // update offset - info.offset &= getLevelMask(info.levels + 1); - - // try exchanging root info - if (tryUpdateRootInfo(info)) { - // success => final step, update parent of old root - oldRoot->parent = info.root; - } else { - // throw away temporary new node - delete newRoot; - } - } - - /** - * Tests whether the given index is covered by the boundaries defined - * by the hight and offset of the internally maintained tree. - */ - bool inBoundaries(index_type a) const { - return inBoundaries(a, unsynced.levels, unsynced.offset); - } - - /** - * Tests whether the given index is within the boundaries defined by the - * given tree hight and offset. - */ - static bool inBoundaries(index_type a, uint32_t levels, index_type offset) { - auto mask = getLevelMask(levels + 1); - return (a & mask) == offset; - } - - /** - * Obtains the index within the arrays of cells of a given index on a given - * level of the internally maintained tree. - */ - static index_type getIndex(RamDomain a, unsigned level) { - return (a & (INDEX_MASK << (level * BIT_PER_STEP))) >> (level * BIT_PER_STEP); - } - - /** - * Computes the bit-mask to be applicable to obtain the offset of a node on a - * given tree level. - */ - static index_type getLevelMask(unsigned level) { - if (level > (sizeof(index_type) * 8 / BITS)) return 0; - return (~(index_type(0)) << (level * BIT_PER_STEP)); - } -}; - -/** - * A sparse bit-map is a bit map virtually assigning a bit value to every value if the - * uint32_t domain. However, only 1-bits are stored utilizing a nested sparse array - * structure. - * - * @tparam BITS similar to the BITS parameter of the sparse array type - */ -template -class SparseBitMap { - // the element type stored in the nested sparse array - using value_t = uint64_t; - - // define the bit-level merge operation - struct merge_op { - value_t operator()(value_t a, value_t b) const { - return a | b; // merging bit masks => bitwise or operation - } - }; - - // the type of the internal data store - using data_store_t = SparseArray; - using atomic_value_t = typename data_store_t::atomic_value_type; - - // some constants for manipulating stored values - static constexpr short BITS_PER_ENTRY = sizeof(value_t) * 8; - static constexpr short LEAF_INDEX_WIDTH = static_cast(__builtin_ctz(BITS_PER_ENTRY)); - static constexpr uint64_t LEAF_INDEX_MASK = BITS_PER_ENTRY - 1; - -public: - // the type to address individual entries - using index_type = typename data_store_t::index_type; - -private: - // it utilizes a sparse map to store its data - data_store_t store; - -public: - // a simple default constructor - SparseBitMap() = default; - - // a default copy constructor - SparseBitMap(const SparseBitMap&) = default; - - // a default r-value copy constructor - SparseBitMap(SparseBitMap&&) = default; - - // a default assignment operator - SparseBitMap& operator=(const SparseBitMap&) = default; - - // a default r-value assignment operator - SparseBitMap& operator=(SparseBitMap&&) = default; - - // checks whether this bit-map is empty -- thus it does not have any 1-entries - bool empty() const { - return store.empty(); - } - - // the type utilized for recording context information for exploiting temporal locality - using op_context = typename data_store_t::op_context; - - /** - * Sets the bit addressed by i to 1. - */ - bool set(index_type i) { - op_context ctxt; - return set(i, ctxt); - } - - /** - * Sets the bit addressed by i to 1. A context for exploiting temporal locality - * can be provided. - */ - bool set(index_type i, op_context& ctxt) { - atomic_value_t& val = store.getAtomic(i >> LEAF_INDEX_WIDTH, ctxt); - value_t bit = (1ull << (i & LEAF_INDEX_MASK)); - -#ifdef __GNUC__ -#if __GNUC__ >= 7 - // In GCC >= 7 the usage of fetch_or causes a bug that needs further investigation - // For now, this two-instruction based implementation provides a fix that does - // not sacrifice too much performance. - - while (true) { - auto order = std::memory_order::memory_order_relaxed; - - // load current value - value_t old = val.load(order); - - // if bit is already set => we are done - if (old & bit) return false; - - // set the bit, if failed, repeat - if (!val.compare_exchange_strong(old, old | bit, order, order)) continue; - - // it worked, new bit added - return true; - } - -#endif -#endif - - value_t old = val.fetch_or(bit, std::memory_order::memory_order_relaxed); - return (old & bit) == 0u; - } - - /** - * Determines the whether the bit addressed by i is set or not. - */ - bool test(index_type i) const { - op_context ctxt; - return test(i, ctxt); - } - - /** - * Determines the whether the bit addressed by i is set or not. A context for - * exploiting temporal locality can be provided. - */ - bool test(index_type i, op_context& ctxt) const { - value_t bit = (1ull << (i & LEAF_INDEX_MASK)); - return store.lookup(i >> LEAF_INDEX_WIDTH, ctxt) & bit; - } - - /** - * Determines the whether the bit addressed by i is set or not. - */ - bool operator[](index_type i) const { - return test(i); - } - - /** - * Resets all contained bits to 0. - */ - void clear() { - store.clear(); - } - - /** - * Determines the number of bits set. - */ - std::size_t size() const { - // this is computed on demand to keep the set operation simple. - std::size_t res = 0; - for (const auto& cur : store) { - res += __builtin_popcountll(cur.second); - } - return res; - } - - /** - * Computes the total memory usage of this data structure. - */ - std::size_t getMemoryUsage() const { - // compute the total memory usage - return sizeof(*this) - sizeof(data_store_t) + store.getMemoryUsage(); - } - - /** - * Sets all bits set in other to 1 within this bit map. - */ - void addAll(const SparseBitMap& other) { - // nothing to do if it is a self-assignment - if (this == &other) return; - - // merge the sparse store - store.addAll(other.store); - } - - // --------------------------------------------------------------------- - // Iterator - // --------------------------------------------------------------------- - - /** - * An iterator iterating over all indices set to 1. - */ - class iterator : public std::iterator { - using nested_iterator = typename data_store_t::iterator; - - // the iterator through the underlying sparse data structure - nested_iterator iter; - - // the currently consumed mask - uint64_t mask = 0; - - // the value currently pointed to - index_type value{}; - - public: - // default constructor -- creating an end-iterator - iterator() = default; - - iterator(const nested_iterator& iter) - : iter(iter), mask(toMask(iter->second)), value(iter->first << LEAF_INDEX_WIDTH) { - moveToNextInMask(); - } - - iterator(const nested_iterator& iter, uint64_t m, index_type value) - : iter(iter), mask(m), value(value) {} - - // a copy constructor - iterator(const iterator& other) = default; - - // an assignment operator - iterator& operator=(const iterator& other) = default; - - // the equality operator as required by the iterator concept - bool operator==(const iterator& other) const { - // only equivalent if pointing to the end - return iter == other.iter && mask == other.mask; - } - - // the not-equality operator as required by the iterator concept - bool operator!=(const iterator& other) const { - return !(*this == other); - } - - // the deref operator as required by the iterator concept - const index_type& operator*() const { - return value; - } - - // support for the pointer operator - const index_type* operator->() const { - return &value; - } - - // the increment operator as required by the iterator concept - iterator& operator++() { - // progress in current mask - if (moveToNextInMask()) return *this; - - // go to next entry - ++iter; - - // update value - if (!iter.isEnd()) { - value = iter->first << LEAF_INDEX_WIDTH; - mask = toMask(iter->second); - moveToNextInMask(); - } - - // done - return *this; - } - - bool isEnd() const { - return iter.isEnd(); - } - - void print(std::ostream& out) const { - out << "SparseBitMapIter(" << iter << " -> " << std::bitset<64>(mask) << " @ " << value << ")"; - } - - // enables this iterator core to be printed (for debugging) - friend std::ostream& operator<<(std::ostream& out, const iterator& iter) { - iter.print(out); - return out; - } - - static uint64_t toMask(const value_t& value) { - static_assert(sizeof(value_t) == sizeof(uint64_t), "Fixed for 64-bit compiler."); - return reinterpret_cast(value); - } - - private: - bool moveToNextInMask() { - // check if there is something left - if (mask == 0) return false; - - // get position of leading 1 - auto pos = __builtin_ctzll(mask); - - // consume this bit - mask &= ~(1llu << pos); - - // update value - value &= ~LEAF_INDEX_MASK; - value |= pos; - - // done - return true; - } - }; - - /** - * Obtains an iterator pointing to the first index set to 1. If there - * is no such bit, end() will be returned. - */ - iterator begin() const { - auto it = store.begin(); - if (it.isEnd()) return end(); - return iterator(it); - } - - /** - * Returns an iterator referencing the position after the last set bit. - */ - iterator end() const { - return iterator(); - } - - /** - * Obtains an iterator referencing the position i if the corresponding - * bit is set, end() otherwise. - */ - iterator find(index_type i) const { - op_context ctxt; - return find(i, ctxt); - } - - /** - * Obtains an iterator referencing the position i if the corresponding - * bit is set, end() otherwise. An operation context can be provided - * to exploit temporal locality. - */ - iterator find(index_type i, op_context& ctxt) const { - // check prefix part - auto it = store.find(i >> LEAF_INDEX_WIDTH, ctxt); - if (it.isEnd()) return end(); - - // check bit-set part - uint64_t mask = iterator::toMask(it->second); - if (!(mask & (1llu << (i & LEAF_INDEX_MASK)))) return end(); - - // OK, it is there => create iterator - mask &= ((1ull << (i & LEAF_INDEX_MASK)) - 1); // remove all bits before pos i - return iterator(it, mask, i); - } - - /** - * Locates an iterator to the first element in this sparse bit map not less - * than the given index. - */ - iterator lower_bound(index_type i) const { - auto it = store.lowerBound(i >> LEAF_INDEX_WIDTH); - if (it.isEnd()) return end(); - - // check bit-set part - uint64_t mask = iterator::toMask(it->second); - - // if there is no bit remaining in this mask, check next mask. - if (!(mask & ((~uint64_t(0)) << (i & LEAF_INDEX_MASK)))) { - index_type next = ((i >> LEAF_INDEX_WIDTH) + 1) << LEAF_INDEX_WIDTH; - if (next < i) return end(); - return lower_bound(next); - } - - // there are bits left, use least significant bit of those - if (it->first == i >> LEAF_INDEX_WIDTH) { - mask &= ((~uint64_t(0)) << (i & LEAF_INDEX_MASK)); // remove all bits before pos i - } - - // compute value represented by least significant bit - index_type pos = __builtin_ctzll(mask); - - // remove this bit as well - mask = mask & ~(1ull << pos); - - // construct value of this located bit - index_type val = (it->first << LEAF_INDEX_WIDTH) | pos; - return iterator(it, mask, val); - } - - /** - * Locates an iterator to the first element in this sparse bit map than is greater - * than the given index. - */ - iterator upper_bound(index_type i) const { - if (i == std::numeric_limits::max()) { - return end(); - } - return lower_bound(i + 1); - } - - /** - * A debugging utility printing the internal structure of this map to the - * given output stream. - */ - void dump(bool detail = false, std::ostream& out = std::cout) const { - store.dump(detail, out); - } - - /** - * Provides write-protected access to the internal store for running - * analysis on the data structure. - */ - const data_store_t& getStore() const { - return store; - } -}; - -// --------------------------------------------------------------------- -// TRIE -// --------------------------------------------------------------------- - -namespace detail { - -/** - * A base class for the Trie implementation allowing various - * specializations of the Trie template to inherit common functionality. - * - * @tparam Dim the number of dimensions / arity of the stored tuples - * @tparam Derived the type derived from this base class - */ -template -class TrieBase { -public: - /** - * The type of the stored entries / tuples. - */ - using entry_type = typename souffle::Tuple; - - // -- operation wrappers -- - - /** - * A generic function enabling the insertion of tuple values in a user-friendly way. - */ - template - bool insert(Values... values) { - return static_cast(*this).insert(entry_type{{RamDomain(values)...}}); - } - - /** - * A generic function enabling the convenient conduction of a membership check. - */ - template - bool contains(Values... values) const { - return static_cast(*this).contains(entry_type{{RamDomain(values)...}}); - } - - // --------------------------------------------------------------------- - // Iterator - // --------------------------------------------------------------------- - - /** - * An iterator over the stored entries. - * - * Iterators for tries consist of a top-level iterator maintaining the - * master copy of a materialized tuple and a recursively nested iterator - * core -- one for each nested trie level. - */ - template