Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

finalized index API changes

This commit is contained in:
Jan Steemann 2015-11-25 16:44:01 +01:00
parent db85c926be
commit e29bc893b7
8 changed files with 121 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
UnitTests/Basics/associative-multi-pointer-nohashcache-test.cpp
View File

@ -59,13 +59,13 @@ struct data_container_t {
data_container_t (int key, int value) : value(value), key(key) {}; data_container_t (int key, int value) : value(value), key(key) {};
}; };
static uint64_t HashKey (void const* e) { static uint64_t HashKey (void* userData, void const* e) {
int const* key = (int const*) e; int const* key = (int const*) e;
return fasthash64(key, sizeof(int), 0x12345678); return fasthash64(key, sizeof(int), 0x12345678);
} }
static uint64_t HashElement (void const* e, bool byKey) { static uint64_t HashElement (void* userData, void const* e, bool byKey) {
data_container_t const* element = (data_container_t const*) e; data_container_t const* element = (data_container_t const*) e;
if (byKey) { if (byKey) {
@ -76,21 +76,21 @@ static uint64_t HashElement (void const* e, bool byKey) {
} }
} }
static bool IsEqualKeyElement (void const* k, void const* r) { static bool IsEqualKeyElement (void* userData, void const* k, void const* r) {
int const* key = (int const*) k; int const* key = (int const*) k;
data_container_t const* element = (data_container_t const*) r; data_container_t const* element = (data_container_t const*) r;
return *key == element->key; return *key == element->key;
} }
static bool IsEqualElementElement (void const* l, void const* r) { static bool IsEqualElementElement (void* userData, void const* l, void const* r) {
data_container_t const* left = (data_container_t const*) l; data_container_t const* left = (data_container_t const*) l;
data_container_t const* right = (data_container_t const*) r; data_container_t const* right = (data_container_t const*) r;
return left->value == right->value; return left->value == right->value;
} }
static bool IsEqualElementElementByKey (void const* l, void const* r) { static bool IsEqualElementElementByKey (void* userData, void const* l, void const* r) {
data_container_t const* left = (data_container_t const*) l; data_container_t const* left = (data_container_t const*) l;
data_container_t const* right = (data_container_t const*) r; data_container_t const* right = (data_container_t const*) r;

19
UnitTests/Basics/associative-multi-pointer-test.cpp
View File

@ -59,13 +59,16 @@ struct data_container_t {
data_container_t (int key, int value) : value(value), key(key) {}; data_container_t (int key, int value) : value(value), key(key) {};
}; };
static uint64_t HashKey (void const* e) { static uint64_t HashKey (void* userData,
void const* e) {
int const* key = (int const*) e; int const* key = (int const*) e;
return fasthash64(key, sizeof(int), 0x12345678); return fasthash64(key, sizeof(int), 0x12345678);
} }
static uint64_t HashElement (void const* e, bool byKey) { static uint64_t HashElement (void* userData,
void const* e,
bool byKey) {
data_container_t const* element = (data_container_t const*) e; data_container_t const* element = (data_container_t const*) e;
if (byKey) { if (byKey) {
@ -76,21 +79,27 @@ static uint64_t HashElement (void const* e, bool byKey) {
} }
} }
static bool IsEqualKeyElement (void const* k, void const* r) { static bool IsEqualKeyElement (void* userData,
void const* k,
void const* r) {
int const* key = (int const*) k; int const* key = (int const*) k;
data_container_t const* element = (data_container_t const*) r; data_container_t const* element = (data_container_t const*) r;
return *key == element->key; return *key == element->key;
} }
static bool IsEqualElementElement (void const* l, void const* r) { static bool IsEqualElementElement (void* userData,
void const* l,
void const* r) {
data_container_t const* left = (data_container_t const*) l; data_container_t const* left = (data_container_t const*) l;
data_container_t const* right = (data_container_t const*) r; data_container_t const* right = (data_container_t const*) r;
return left->value == right->value; return left->value == right->value;
} }
static bool IsEqualElementElementByKey (void const* l, void const* r) { static bool IsEqualElementElementByKey (void* userData,
void const* l,
void const* r) {
data_container_t const* left = (data_container_t const*) l; data_container_t const* left = (data_container_t const*) l;
data_container_t const* right = (data_container_t const*) r; data_container_t const* right = (data_container_t const*) r;

34
arangod/Indexes/EdgeIndex.cpp
View File

@ -49,7 +49,8 @@ using namespace triagens::arango;
/// @brief hashes an edge key /// @brief hashes an edge key
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static uint64_t HashElementKey (void const* data) { static uint64_t HashElementKey (void* userData,
TRI_edge_header_t const* data) {
TRI_ASSERT_EXPENSIVE(data != nullptr); TRI_ASSERT_EXPENSIVE(data != nullptr);
TRI_edge_header_t const* h = static_cast<TRI_edge_header_t const*>(data); TRI_edge_header_t const* h = static_cast<TRI_edge_header_t const*>(data);
@ -65,7 +66,8 @@ static uint64_t HashElementKey (void const* data) {
/// @brief hashes an edge (_from case) /// @brief hashes an edge (_from case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static uint64_t HashElementEdgeFrom (void const* data, static uint64_t HashElementEdgeFrom (void* userData,
TRI_doc_mptr_t const* data,
bool byKey) { bool byKey) {
TRI_ASSERT_EXPENSIVE(data != nullptr); TRI_ASSERT_EXPENSIVE(data != nullptr);
@ -105,7 +107,8 @@ static uint64_t HashElementEdgeFrom (void const* data,
/// @brief hashes an edge (_to case) /// @brief hashes an edge (_to case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static uint64_t HashElementEdgeTo (void const* data, static uint64_t HashElementEdgeTo (void* userData,
TRI_doc_mptr_t const* data,
bool byKey) { bool byKey) {
TRI_ASSERT_EXPENSIVE(data != nullptr); TRI_ASSERT_EXPENSIVE(data != nullptr);
@ -145,8 +148,9 @@ static uint64_t HashElementEdgeTo (void const* data,
/// @brief checks if key and element match (_from case) /// @brief checks if key and element match (_from case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualKeyEdgeFrom (void const* left, static bool IsEqualKeyEdgeFrom (void* userData,
void const* right) { TRI_edge_header_t const* left,
TRI_doc_mptr_t const* right) {
TRI_ASSERT_EXPENSIVE(left != nullptr); TRI_ASSERT_EXPENSIVE(left != nullptr);
TRI_ASSERT_EXPENSIVE(right != nullptr); TRI_ASSERT_EXPENSIVE(right != nullptr);
@ -181,8 +185,9 @@ static bool IsEqualKeyEdgeFrom (void const* left,
/// @brief checks if key and element match (_to case) /// @brief checks if key and element match (_to case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualKeyEdgeTo (void const* left, static bool IsEqualKeyEdgeTo (void* userData,
void const* right) { TRI_edge_header_t const* left,
TRI_doc_mptr_t const* right) {
TRI_ASSERT_EXPENSIVE(left != nullptr); TRI_ASSERT_EXPENSIVE(left != nullptr);
TRI_ASSERT_EXPENSIVE(right != nullptr); TRI_ASSERT_EXPENSIVE(right != nullptr);
@ -218,8 +223,9 @@ static bool IsEqualKeyEdgeTo (void const* left,
/// @brief checks for elements are equal (_from and _to case) /// @brief checks for elements are equal (_from and _to case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualElementEdge (void const* left, static bool IsEqualElementEdge (void* userData,
void const* right) { TRI_doc_mptr_t const* left,
TRI_doc_mptr_t const* right) {
return left == right; return left == right;
} }
@ -227,8 +233,9 @@ static bool IsEqualElementEdge (void const* left,
/// @brief checks for elements are equal (_from case) /// @brief checks for elements are equal (_from case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualElementEdgeFromByKey (void const* left, static bool IsEqualElementEdgeFromByKey (void* userData,
void const* right) { TRI_doc_mptr_t const* left,
TRI_doc_mptr_t const* right) {
TRI_ASSERT_EXPENSIVE(left != nullptr); TRI_ASSERT_EXPENSIVE(left != nullptr);
TRI_ASSERT_EXPENSIVE(right != nullptr); TRI_ASSERT_EXPENSIVE(right != nullptr);
@ -281,8 +288,9 @@ static bool IsEqualElementEdgeFromByKey (void const* left,
/// @brief checks for elements are equal (_to case) /// @brief checks for elements are equal (_to case)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualElementEdgeToByKey (void const* left, static bool IsEqualElementEdgeToByKey (void* userData,
void const* right) { TRI_doc_mptr_t const* left,
TRI_doc_mptr_t const* right) {
TRI_ASSERT_EXPENSIVE(left != nullptr); TRI_ASSERT_EXPENSIVE(left != nullptr);
TRI_ASSERT_EXPENSIVE(right != nullptr); TRI_ASSERT_EXPENSIVE(right != nullptr);

14
arangod/Indexes/HashIndex.cpp
View File

@ -54,7 +54,8 @@ static void FreeElement(TRI_index_element_t* element) {
/// @brief determines if two elements are equal /// @brief determines if two elements are equal
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualElementElement (TRI_index_element_t const* left, static bool IsEqualElementElement (void* userData,
TRI_index_element_t const* left,
TRI_index_element_t const* right) { TRI_index_element_t const* right) {
return left->document() == right->document(); return left->document() == right->document();
} }
@ -63,7 +64,8 @@ static bool IsEqualElementElement (TRI_index_element_t const* left,
/// @brief given a key generates a hash integer /// @brief given a key generates a hash integer
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static uint64_t HashKey (TRI_hash_index_search_value_t const* key) { static uint64_t HashKey (void* userData,
TRI_hash_index_search_value_t const* key) {
uint64_t hash = 0x0123456789abcdef; uint64_t hash = 0x0123456789abcdef;
for (size_t j = 0; j < key->_length; ++j) { for (size_t j = 0; j < key->_length; ++j) {
@ -78,7 +80,8 @@ static uint64_t HashKey (TRI_hash_index_search_value_t const* key) {
/// @brief determines if a key corresponds to an element /// @brief determines if a key corresponds to an element
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualKeyElement (TRI_hash_index_search_value_t const* left, static bool IsEqualKeyElement (void* userData,
TRI_hash_index_search_value_t const* left,
TRI_index_element_t const* right) { TRI_index_element_t const* right) {
TRI_ASSERT_EXPENSIVE(right->document() != nullptr); TRI_ASSERT_EXPENSIVE(right->document() != nullptr);
@ -108,10 +111,11 @@ static bool IsEqualKeyElement (TRI_hash_index_search_value_t const* left,
return true; return true;
} }
static bool IsEqualKeyElementHash (TRI_hash_index_search_value_t const* left, static bool IsEqualKeyElementHash (void* userData,
TRI_hash_index_search_value_t const* left,
uint64_t const hash, // Has been computed but is not used here uint64_t const hash, // Has been computed but is not used here
TRI_index_element_t const* right) { TRI_index_element_t const* right) {
return IsEqualKeyElement(left, right); return IsEqualKeyElement(userData, left, right);
} }
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------

6
arangod/Indexes/HashIndex.h
View File

@ -268,7 +268,8 @@ namespace triagens {
: _numFields(n) { : _numFields(n) {
} }
uint64_t operator() (TRI_index_element_t const* element, uint64_t operator() (void* userData,
TRI_index_element_t const* element,
bool byKey = true) { bool byKey = true) {
uint64_t hash = 0x0123456789abcdef; uint64_t hash = 0x0123456789abcdef;
@ -306,7 +307,8 @@ namespace triagens {
: _numFields(n) { : _numFields(n) {
} }
bool operator() (TRI_index_element_t const* left, bool operator() (void* userData,
TRI_index_element_t const* left,
TRI_index_element_t const* right) { TRI_index_element_t const* right) {
TRI_ASSERT_EXPENSIVE(left->document() != nullptr); TRI_ASSERT_EXPENSIVE(left->document() != nullptr);
TRI_ASSERT_EXPENSIVE(right->document() != nullptr); TRI_ASSERT_EXPENSIVE(right->document() != nullptr);

18
arangod/Indexes/PrimaryIndex.cpp
View File

@ -44,11 +44,13 @@ using namespace triagens::arango;
// --SECTION-- private functions // --SECTION-- private functions
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
static inline uint64_t HashKey (char const* key) { static inline uint64_t HashKey (void* userData,
char const* key) {
return TRI_FnvHashString(key); return TRI_FnvHashString(key);
} }
static inline uint64_t HashElement (TRI_doc_mptr_t const* element) { static inline uint64_t HashElement (void* userData,
TRI_doc_mptr_t const* element) {
return element->_hash; return element->_hash;
} }
@ -56,7 +58,8 @@ static inline uint64_t HashElement (TRI_doc_mptr_t const* element) {
/// @brief determines if a key corresponds to an element /// @brief determines if a key corresponds to an element
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualKeyElement (char const* key, static bool IsEqualKeyElement (void* userData,
char const* key,
uint64_t const hash, uint64_t const hash,
TRI_doc_mptr_t const* element) { TRI_doc_mptr_t const* element) {
@ -68,7 +71,8 @@ static bool IsEqualKeyElement (char const* key,
/// @brief determines if two elements are equal /// @brief determines if two elements are equal
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool IsEqualElementElement (TRI_doc_mptr_t const* left, static bool IsEqualElementElement (void* userData,
TRI_doc_mptr_t const* left,
TRI_doc_mptr_t const* right) { TRI_doc_mptr_t const* right) {
return left->_hash == right->_hash return left->_hash == right->_hash
&& strcmp(TRI_EXTRACT_MARKER_KEY(left), TRI_EXTRACT_MARKER_KEY(right)) == 0; && strcmp(TRI_EXTRACT_MARKER_KEY(left), TRI_EXTRACT_MARKER_KEY(right)) == 0;
@ -317,12 +321,12 @@ int PrimaryIndex::resize (triagens::arango::Transaction* trx,
return _primaryIndex->resize(trx, targetSize); return _primaryIndex->resize(trx, targetSize);
} }
uint64_t PrimaryIndex::calculateHash (triagens::arango::Transaction*, uint64_t PrimaryIndex::calculateHash (triagens::arango::Transaction* trx,
char const* key) { char const* key) {
return HashKey(key); return HashKey(trx, key);
} }
uint64_t PrimaryIndex::calculateHash (triagens::arango::Transaction*, uint64_t PrimaryIndex::calculateHash (triagens::arango::Transaction* trx,
char const* key, char const* key,
size_t length) { size_t length) {
return TRI_FnvHashPointer(static_cast<void const*>(key), length); return TRI_FnvHashPointer(static_cast<void const*>(key), length);

59
lib/Basics/AssocMulti.h
View File

@ -145,12 +145,14 @@ namespace triagens {
public: public:
static IndexType const INVALID_INDEX = ((IndexType)0)-1; static IndexType const INVALID_INDEX = ((IndexType)0)-1;
typedef std::function<uint64_t(Key const*)> HashKeyFuncType; typedef std::function<uint64_t(UserData*, Key const*)> HashKeyFuncType;
typedef std::function<uint64_t(Element const*, bool)> HashElementFuncType; typedef std::function<uint64_t(UserData*, Element const*, bool)> HashElementFuncType;
typedef std::function<bool(Key const*, typedef std::function<bool(UserData*,
Key const*,
Element const*)> Element const*)>
IsEqualKeyElementFuncType; IsEqualKeyElementFuncType;
typedef std::function<bool(Element const*, typedef std::function<bool(UserData*,
Element const*,
Element const*)> Element const*)>
IsEqualElementElementFuncType; IsEqualElementElementFuncType;
typedef std::function<void(Element*)> typedef std::function<void(Element*)>
@ -376,7 +378,7 @@ namespace triagens {
#endif #endif
// compute the hash by the key only first // compute the hash by the key only first
uint64_t hashByKey = _hashElement(element, true); uint64_t hashByKey = _hashElement(userData, element, true);
Bucket& b = _buckets[hashByKey & _bucketsMask]; Bucket& b = _buckets[hashByKey & _bucketsMask];
auto result = doInsert(userData, element, hashByKey, b, overwrite, checkEquality); auto result = doInsert(userData, element, hashByKey, b, overwrite, checkEquality);
@ -425,7 +427,7 @@ namespace triagens {
std::unordered_map<uint64_t, DocumentsPerBucket> partitions; std::unordered_map<uint64_t, DocumentsPerBucket> partitions;
for (size_t i = lower; i < upper; ++i) { for (size_t i = lower; i < upper; ++i) {
uint64_t hashByKey = _hashElement(elements[i], true); uint64_t hashByKey = _hashElement(userData, elements[i], true);
auto bucketId = hashByKey & _bucketsMask; auto bucketId = hashByKey & _bucketsMask;
auto it = partitions.find(bucketId); auto it = partitions.find(bucketId);
@ -609,7 +611,7 @@ namespace triagens {
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(b._table[i].prev != INVALID_INDEX || (b._table[i].prev != INVALID_INDEX ||
(useHashCache && b._table[i].readHashCache() != hashByKey) || (useHashCache && b._table[i].readHashCache() != hashByKey) ||
! _isEqualElementElementByKey(element, b._table[i].ptr)) ! _isEqualElementElementByKey(userData, element, b._table[i].ptr))
) { ) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
@ -638,7 +640,7 @@ namespace triagens {
// list of which we want to make element a member. Perhaps an // list of which we want to make element a member. Perhaps an
// equal element is right here: // equal element is right here:
if (checkEquality && if (checkEquality &&
_isEqualElementElement(element, b._table[i].ptr)) { _isEqualElementElement(userData, element, b._table[i].ptr)) {
old = b._table[i].ptr; old = b._table[i].ptr;
if (overwrite) { if (overwrite) {
TRI_ASSERT(! useHashCache || TRI_ASSERT(! useHashCache ||
@ -833,7 +835,7 @@ namespace triagens {
(new std::vector<Element*>()); (new std::vector<Element*>());
// compute the hash // compute the hash
uint64_t hashByKey = _hashKey(key); uint64_t hashByKey = _hashKey(userData, key);
Bucket const& b = _buckets[hashByKey & _bucketsMask]; Bucket const& b = _buckets[hashByKey & _bucketsMask];
IndexType hashIndex = hashToIndex(hashByKey); IndexType hashIndex = hashToIndex(hashByKey);
IndexType i = hashIndex % b._nrAlloc; IndexType i = hashIndex % b._nrAlloc;
@ -847,7 +849,7 @@ namespace triagens {
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(b._table[i].prev != INVALID_INDEX || (b._table[i].prev != INVALID_INDEX ||
(useHashCache && b._table[i].readHashCache() != hashByKey) || (useHashCache && b._table[i].readHashCache() != hashByKey) ||
! _isEqualKeyElement(key, b._table[i].ptr)) ! _isEqualKeyElement(userData, key, b._table[i].ptr))
) { ) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
@ -882,7 +884,7 @@ namespace triagens {
(new std::vector<Element*>()); (new std::vector<Element*>());
// compute the hash // compute the hash
uint64_t hashByKey = _hashElement(element, true); uint64_t hashByKey = _hashElement(userData, element, true);
Bucket const& b = _buckets[hashByKey & _bucketsMask]; Bucket const& b = _buckets[hashByKey & _bucketsMask];
IndexType hashIndex = hashToIndex(hashByKey); IndexType hashIndex = hashToIndex(hashByKey);
IndexType i = hashIndex % b._nrAlloc; IndexType i = hashIndex % b._nrAlloc;
@ -896,7 +898,7 @@ namespace triagens {
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(b._table[i].prev != INVALID_INDEX || (b._table[i].prev != INVALID_INDEX ||
(useHashCache && b._table[i].readHashCache() != hashByKey) || (useHashCache && b._table[i].readHashCache() != hashByKey) ||
! _isEqualElementElementByKey(element, b._table[i].ptr)) ! _isEqualElementElementByKey(userData, element, b._table[i].ptr))
) { ) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
@ -931,7 +933,7 @@ namespace triagens {
std::unique_ptr<std::vector<Element*>> result std::unique_ptr<std::vector<Element*>> result
(new std::vector<Element*>()); (new std::vector<Element*>());
uint64_t hashByKey = _hashElement(element, true); uint64_t hashByKey = _hashElement(userData, element, true);
Bucket const& b = _buckets[hashByKey & _bucketsMask]; Bucket const& b = _buckets[hashByKey & _bucketsMask];
uint64_t hashByElm; uint64_t hashByElm;
IndexType i = findElementPlace(userData, b, element, true, hashByElm); IndexType i = findElementPlace(userData, b, element, true, hashByElm);
@ -947,7 +949,7 @@ namespace triagens {
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(b._table[i].prev != INVALID_INDEX || (b._table[i].prev != INVALID_INDEX ||
(useHashCache && b._table[i].readHashCache() != hashByKey) || (useHashCache && b._table[i].readHashCache() != hashByKey) ||
! _isEqualElementElementByKey(element, b._table[i].ptr))) { ! _isEqualElementElementByKey(userData, element, b._table[i].ptr))) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
_nrProbes++; _nrProbes++;
@ -1029,7 +1031,7 @@ namespace triagens {
if (useHashCache) { if (useHashCache) {
// We need to exchange the hashCache value by that of the key: // We need to exchange the hashCache value by that of the key:
b->_table[i].writeHashCache( b->_table[i].writeHashCache(
_hashElement(b->_table[i].ptr, true)); _hashElement(userData, b->_table[i].ptr, true));
} }
#ifdef TRI_CHECK_MULTI_POINTER_HASH #ifdef TRI_CHECK_MULTI_POINTER_HASH
check(userData, false, false); check(userData, false, false);
@ -1189,7 +1191,7 @@ namespace triagens {
hashByKey = oldTable[j].readHashCache(); hashByKey = oldTable[j].readHashCache();
} }
else { else {
hashByKey = _hashElement(oldTable[j].ptr, true); hashByKey = _hashElement(userData, oldTable[j].ptr, true);
} }
IndexType insertPosition = insertFirst(userData, b, oldTable[j].ptr, hashByKey); IndexType insertPosition = insertFirst(userData, b, oldTable[j].ptr, hashByKey);
// Now walk to the end of the list: // Now walk to the end of the list:
@ -1204,7 +1206,7 @@ namespace triagens {
hashByElm = oldTable[k].readHashCache(); hashByElm = oldTable[k].readHashCache();
} }
else { else {
hashByElm = _hashElement(oldTable[k].ptr, false); hashByElm = _hashElement(userData, oldTable[k].ptr, false);
} }
insertFurther(userData, b, oldTable[k].ptr, hashByKey, hashByElm, insertPosition); insertFurther(userData, b, oldTable[k].ptr, hashByKey, hashByElm, insertPosition);
k = oldTable[k].prev; k = oldTable[k].prev;
@ -1277,7 +1279,7 @@ namespace triagens {
IndexType hashIndex; IndexType hashIndex;
if (b._table[i].prev == INVALID_INDEX) { if (b._table[i].prev == INVALID_INDEX) {
// We are the first in a linked list. // We are the first in a linked list.
uint64_t hashByKey = _hashElement(b._table[i].ptr, true); uint64_t hashByKey = _hashElement(userData, b._table[i].ptr, true);
hashIndex = hashToIndex(hashByKey); hashIndex = hashToIndex(hashByKey);
j = hashIndex % b._nrAlloc; j = hashIndex % b._nrAlloc;
if (useHashCache && b._table[i].readHashCache() != hashByKey) { if (useHashCache && b._table[i].readHashCache() != hashByKey) {
@ -1286,7 +1288,8 @@ namespace triagens {
for (k = j; k != i; ) { for (k = j; k != i; ) {
if (b._table[k].ptr == nullptr || if (b._table[k].ptr == nullptr ||
(b._table[k].prev == INVALID_INDEX && (b._table[k].prev == INVALID_INDEX &&
_isEqualElementElementByKey(b._table[i].ptr, _isEqualElementElementByKey(userData,
b._table[i].ptr,
b._table[k].ptr))) { b._table[k].ptr))) {
ok = false; ok = false;
std::cout << "Alarm pos bykey: " << i << std::endl; std::cout << "Alarm pos bykey: " << i << std::endl;
@ -1296,7 +1299,7 @@ namespace triagens {
} }
else { else {
// We are not the first in a linked list. // We are not the first in a linked list.
uint64_t hashByElm = _hashElement(b._table[i].ptr, false); uint64_t hashByElm = _hashElement(userData, b._table[i].ptr, false);
hashIndex = hashToIndex(hashByElm); hashIndex = hashToIndex(hashByElm);
j = hashIndex % b._nrAlloc; j = hashIndex % b._nrAlloc;
if (useHashCache && b._table[i].readHashCache() != hashByElm) { if (useHashCache && b._table[i].readHashCache() != hashByElm) {
@ -1304,7 +1307,8 @@ namespace triagens {
} }
for (k = j; k != i; ) { for (k = j; k != i; ) {
if (b._table[k].ptr == nullptr || if (b._table[k].ptr == nullptr ||
_isEqualElementElement(b._table[i].ptr, _isEqualElementElement(userData,
b._table[i].ptr,
b._table[k].ptr)) { b._table[k].ptr)) {
ok = false; ok = false;
std::cout << "Alarm unique: " << k << ", " std::cout << "Alarm unique: " << k << ", "
@ -1343,14 +1347,14 @@ namespace triagens {
// pointer into the table, which is either empty or points to // pointer into the table, which is either empty or points to
// an entry that compares equal to element. // an entry that compares equal to element.
hashByElm = _hashElement(element, false); hashByElm = _hashElement(userData, element, false);
IndexType hashindex = hashToIndex(hashByElm); IndexType hashindex = hashToIndex(hashByElm);
IndexType i = hashindex % b._nrAlloc; IndexType i = hashindex % b._nrAlloc;
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(! checkEquality || (! checkEquality ||
(useHashCache && b._table[i].readHashCache() != hashByElm) || (useHashCache && b._table[i].readHashCache() != hashByElm) ||
! _isEqualElementElement(element, b._table[i].ptr))) { ! _isEqualElementElement(userData, element, b._table[i].ptr))) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
_nrProbes++; _nrProbes++;
@ -1369,7 +1373,7 @@ namespace triagens {
// This performs a complete lookup for an element. It returns a slot // This performs a complete lookup for an element. It returns a slot
// number. This slot is either empty or contains an element that // number. This slot is either empty or contains an element that
// compares equal to element. // compares equal to element.
uint64_t hashByKey = _hashElement(element, true); uint64_t hashByKey = _hashElement(userData, element, true);
Bucket const& b = _buckets[hashByKey & _bucketsMask]; Bucket const& b = _buckets[hashByKey & _bucketsMask];
buck = const_cast<Bucket*>(&b); buck = const_cast<Bucket*>(&b);
IndexType hashIndex = hashToIndex(hashByKey); IndexType hashIndex = hashToIndex(hashByKey);
@ -1380,7 +1384,7 @@ namespace triagens {
while (b._table[i].ptr != nullptr && while (b._table[i].ptr != nullptr &&
(b._table[i].prev != INVALID_INDEX || (b._table[i].prev != INVALID_INDEX ||
(useHashCache && b._table[i].readHashCache() != hashByKey) || (useHashCache && b._table[i].readHashCache() != hashByKey) ||
! _isEqualElementElementByKey(element, b._table[i].ptr))) { ! _isEqualElementElementByKey(userData, element, b._table[i].ptr))) {
i = incr(b, i); i = incr(b, i);
#ifdef TRI_INTERNAL_STATS #ifdef TRI_INTERNAL_STATS
_nrProbes++; _nrProbes++;
@ -1389,7 +1393,7 @@ namespace triagens {
if (b._table[i].ptr != nullptr) { if (b._table[i].ptr != nullptr) {
// It might be right here! // It might be right here!
if (_isEqualElementElement(element, b._table[i].ptr)) { if (_isEqualElementElement(userData, element, b._table[i].ptr)) {
return i; return i;
} }
@ -1463,7 +1467,8 @@ namespace triagens {
// Find out where this element ought to be: // Find out where this element ought to be:
// If it is the start of one of the linked lists, we need to hash // If it is the start of one of the linked lists, we need to hash
// by key, otherwise, we hash by the full identity of the element: // by key, otherwise, we hash by the full identity of the element:
uint64_t hash = _hashElement(b._table[j].ptr, uint64_t hash = _hashElement(userData,
b._table[j].ptr,
b._table[j].prev == INVALID_INDEX); b._table[j].prev == INVALID_INDEX);
IndexType hashIndex = hashToIndex(hash); IndexType hashIndex = hashToIndex(hash);
IndexType k = hashIndex % b._nrAlloc; IndexType k = hashIndex % b._nrAlloc;

50
lib/Basics/AssocUnique.h
View File

@ -87,11 +87,11 @@ namespace triagens {
public: public:
typedef std::function<uint64_t(Key const*)> HashKeyFuncType; typedef std::function<uint64_t(UserData*, Key const*)> HashKeyFuncType;
typedef std::function<uint64_t(Element const*)> HashElementFuncType; typedef std::function<uint64_t(UserData*, Element const*)> HashElementFuncType;
typedef std::function<bool(Key const*, uint64_t hash, Element const*)> typedef std::function<bool(UserData*, Key const*, uint64_t hash, Element const*)>
IsEqualKeyElementFuncType; IsEqualKeyElementFuncType;
typedef std::function<bool(Element const*, Element const*)> typedef std::function<bool(UserData*, Element const*, Element const*)>
IsEqualElementElementFuncType; IsEqualElementElementFuncType;
typedef std::function<void(Element*)> CallbackElementFuncType; typedef std::function<void(Element*)> CallbackElementFuncType;
@ -269,7 +269,7 @@ namespace triagens {
if (element != nullptr) { if (element != nullptr) {
uint64_t i, k; uint64_t i, k;
i = k = _hashElement(element) % n; i = k = _hashElement(userData, element) % n;
for (; i < n && b._table[i] != nullptr; ++i); for (; i < n && b._table[i] != nullptr; ++i);
if (i == n) { if (i == n) {
@ -350,10 +350,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualElementElementByKey(element, b._table[i]); ++i); ! _isEqualElementElementByKey(userData, element, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualElementElementByKey(element, b._table[i]); ++i); ! _isEqualElementElementByKey(userData, element, b._table[i]); ++i);
} }
Element* arrayElement = b._table[i]; Element* arrayElement = b._table[i];
@ -455,7 +455,7 @@ namespace triagens {
Element* find (UserData* userData, Element* find (UserData* userData,
Element const* element) const { Element const* element) const {
uint64_t i = _hashElement(element); uint64_t i = _hashElement(userData, element);
Bucket const& b = _buckets[i & _bucketsMask]; Bucket const& b = _buckets[i & _bucketsMask];
uint64_t const n = b._nrAlloc; uint64_t const n = b._nrAlloc;
@ -463,10 +463,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualElementElementByKey(element, b._table[i]); ++i); ! _isEqualElementElementByKey(userData, element, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualElementElementByKey(element, b._table[i]); ++i); ! _isEqualElementElementByKey(userData, element, b._table[i]); ++i);
} }
// ........................................................................... // ...........................................................................
@ -483,7 +483,7 @@ namespace triagens {
Element* findByKey (UserData* userData, Element* findByKey (UserData* userData,
Key const* key) const { Key const* key) const {
uint64_t hash = _hashKey(key); uint64_t hash = _hashKey(userData, key);
uint64_t i = hash; uint64_t i = hash;
uint64_t bucketId = i & _bucketsMask; uint64_t bucketId = i & _bucketsMask;
Bucket const& b = _buckets[bucketId]; Bucket const& b = _buckets[bucketId];
@ -493,10 +493,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
} }
// ........................................................................... // ...........................................................................
@ -517,7 +517,7 @@ namespace triagens {
Key const* key, Key const* key,
BucketPosition& position, BucketPosition& position,
uint64_t& hash) const { uint64_t& hash) const {
hash = _hashKey(key); hash = _hashKey(userData, key);
uint64_t i = hash; uint64_t i = hash;
uint64_t bucketId = i & _bucketsMask; uint64_t bucketId = i & _bucketsMask;
Bucket const& b = _buckets[bucketId]; Bucket const& b = _buckets[bucketId];
@ -527,10 +527,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
} }
// if requested, pass the position of the found element back // if requested, pass the position of the found element back
@ -552,7 +552,7 @@ namespace triagens {
int insert (UserData* userData, int insert (UserData* userData,
Element* element) { Element* element) {
uint64_t hash = _hashElement(element); uint64_t hash = _hashElement(userData, element);
Bucket& b = _buckets[hash & _bucketsMask]; Bucket& b = _buckets[hash & _bucketsMask];
if (! checkResize(userData, b, 0)) { if (! checkResize(userData, b, 0)) {
@ -622,7 +622,7 @@ namespace triagens {
std::unordered_map<uint64_t, DocumentsPerBucket> partitions; std::unordered_map<uint64_t, DocumentsPerBucket> partitions;
for (size_t i = lower; i < upper; ++i) { for (size_t i = lower; i < upper; ++i) {
uint64_t hash = _hashElement(elements[i]); uint64_t hash = _hashElement(userData, elements[i]);
auto bucketId = hash & _bucketsMask; auto bucketId = hash & _bucketsMask;
auto it = partitions.find(bucketId); auto it = partitions.find(bucketId);
@ -771,7 +771,7 @@ namespace triagens {
uint64_t k = TRI_IncModU64(i, n); uint64_t k = TRI_IncModU64(i, n);
while (b._table[k] != nullptr) { while (b._table[k] != nullptr) {
uint64_t j = _hashElement(b._table[k]) % n; uint64_t j = _hashElement(userData, b._table[k]) % n;
if ((i < k && ! (i < j && j <= k)) || (k < i && ! (i < j || j <= k))) { if ((i < k && ! (i < j && j <= k)) || (k < i && ! (i < j || j <= k))) {
b._table[i] = b._table[k]; b._table[i] = b._table[k];
@ -796,7 +796,7 @@ namespace triagens {
Element* removeByKey (UserData* userData, Element* removeByKey (UserData* userData,
Key const* key) { Key const* key) {
uint64_t hash = _hashKey(key); uint64_t hash = _hashKey(userData, key);
uint64_t i = hash; uint64_t i = hash;
Bucket& b = _buckets[i & _bucketsMask]; Bucket& b = _buckets[i & _bucketsMask];
@ -805,10 +805,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualKeyElement(key, hash, b._table[i]); ++i); ! _isEqualKeyElement(userData, key, hash, b._table[i]); ++i);
} }
Element* old = b._table[i]; Element* old = b._table[i];
@ -826,7 +826,7 @@ namespace triagens {
Element* remove (UserData* userData, Element* remove (UserData* userData,
Element const* element) { Element const* element) {
uint64_t i = _hashElement(element); uint64_t i = _hashElement(userData, element);
Bucket& b = _buckets[i & _bucketsMask]; Bucket& b = _buckets[i & _bucketsMask];
uint64_t const n = b._nrAlloc; uint64_t const n = b._nrAlloc;
@ -834,10 +834,10 @@ namespace triagens {
uint64_t k = i; uint64_t k = i;
for (; i < n && b._table[i] != nullptr && for (; i < n && b._table[i] != nullptr &&
! _isEqualElementElement(element, b._table[i]); ++i); ! _isEqualElementElement(userData, element, b._table[i]); ++i);
if (i == n) { if (i == n) {
for (i = 0; i < k && b._table[i] != nullptr && for (i = 0; i < k && b._table[i] != nullptr &&
! _isEqualElementElement(element, b._table[i]); ++i); ! _isEqualElementElement(userData, element, b._table[i]); ++i);
} }
Element* old = b._table[i]; Element* old = b._table[i];