mirror of https://gitee.com/bigwinds/arangodb
556 lines
21 KiB
C++
556 lines
21 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief associative array implementation
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
|
|
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler
|
|
/// @author Martin Schoenert
|
|
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
|
|
/// @author Copyright 2006-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef ARANGODB_HASH_INDEX_HASH__ARRAY_H
|
|
#define ARANGODB_HASH_INDEX_HASH__ARRAY_H 1
|
|
|
|
#include "Basics/Common.h"
|
|
#include "Basics/JsonHelper.h"
|
|
#include "Basics/logging.h"
|
|
|
|
namespace triagens {
|
|
namespace basics {
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- UNIQUE ASSOCIATIVE POINTERS
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief associative array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <class Key, class Element>
|
|
class AssocUnique {
|
|
|
|
public:
|
|
|
|
typedef std::function<uint64_t(Key const*)> HashKeyFuncType;
|
|
typedef std::function<uint64_t(Element const*)> HashElementFuncType;
|
|
typedef std::function<bool(Key const*, Element const*)>
|
|
IsEqualKeyElementFuncType;
|
|
typedef std::function<bool(Element const*, Element const*)>
|
|
IsEqualElementElementFuncType;
|
|
|
|
typedef std::function<void(Element*)> CallbackElementFuncType;
|
|
|
|
private:
|
|
struct Bucket {
|
|
|
|
uint64_t _nrAlloc; // the size of the table
|
|
uint64_t _nrUsed; // the number of used entries
|
|
|
|
Element** _table; // the table itself, aligned to a cache line boundary
|
|
};
|
|
|
|
std::vector<Bucket> _buckets;
|
|
size_t _bucketsMask;
|
|
|
|
HashKeyFuncType const _hashKey;
|
|
HashElementFuncType const _hashElement;
|
|
IsEqualKeyElementFuncType const _isEqualKeyElement;
|
|
IsEqualElementElementFuncType const _isEqualElementElement;
|
|
|
|
std::function<std::string()> _contextCallback;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public:
|
|
AssocUnique (HashKeyFuncType hashKey,
|
|
HashElementFuncType hashElement,
|
|
IsEqualKeyElementFuncType isEqualKeyElement,
|
|
IsEqualElementElementFuncType isEqualElementElement,
|
|
size_t numberBuckets = 1,
|
|
std::function<std::string()> contextCallback = [] () -> std::string { return ""; }) :
|
|
_hashKey(hashKey),
|
|
_hashElement(hashElement),
|
|
_isEqualKeyElement(isEqualKeyElement),
|
|
_isEqualElementElement(isEqualElementElement),
|
|
_contextCallback(contextCallback) {
|
|
|
|
// Make the number of buckets a power of two:
|
|
size_t ex = 0;
|
|
size_t nr = 1;
|
|
numberBuckets >>= 1;
|
|
while (numberBuckets > 0) {
|
|
ex += 1;
|
|
numberBuckets >>= 1;
|
|
nr <<= 1;
|
|
}
|
|
numberBuckets = nr;
|
|
_bucketsMask = nr - 1;
|
|
|
|
try {
|
|
for (size_t j = 0; j < numberBuckets; j++) {
|
|
_buckets.emplace_back();
|
|
Bucket& b = _buckets.back();
|
|
b._nrAlloc = initialSize();
|
|
b._table = nullptr;
|
|
|
|
// may fail...
|
|
b._table = new Element* [b._nrAlloc];
|
|
|
|
for (uint64_t i = 0; i < b._nrAlloc; i++) {
|
|
b._table[i] = nullptr;
|
|
}
|
|
}
|
|
}
|
|
catch (...) {
|
|
for (auto& b : _buckets) {
|
|
delete [] b._table;
|
|
b._table = nullptr;
|
|
b._nrAlloc = 0;
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief destructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
~AssocUnique () {
|
|
for (auto& b : _buckets) {
|
|
delete [] b._table;
|
|
b._table = nullptr;
|
|
b._nrAlloc = 0;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adhere to the rule of five
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
AssocUnique (AssocUnique const&) = delete; // copy constructor
|
|
AssocUnique (AssocUnique&&) = delete; // move constructor
|
|
AssocUnique& operator= (AssocUnique const&) = delete; // op =
|
|
AssocUnique& operator= (AssocUnique&&) = delete; // op =
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initial preallocation size of the hash table when the table is
|
|
/// first created
|
|
/// setting this to a high value will waste memory but reduce the number of
|
|
/// reallocations/repositionings necessary when the table grows
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private:
|
|
|
|
static uint64_t initialSize () {
|
|
return 251;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resizes the array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void resizeInternal (Bucket& b,
|
|
uint64_t targetSize,
|
|
bool allowShrink) {
|
|
|
|
if (b._nrAlloc >= targetSize && ! allowShrink) {
|
|
return;
|
|
}
|
|
|
|
// only log performance infos for indexes with more than this number of entries
|
|
static uint64_t const NotificationSizeThreshold = 131072;
|
|
|
|
double start = TRI_microtime();
|
|
if (targetSize > NotificationSizeThreshold) {
|
|
LOG_ACTION("index-resize %s, target size: %llu",
|
|
_contextCallback().c_str(),
|
|
(unsigned long long) targetSize);
|
|
}
|
|
|
|
Element** oldTable = b._table;
|
|
uint64_t oldAlloc = b._nrAlloc;
|
|
|
|
TRI_ASSERT(targetSize > 0);
|
|
|
|
// This might throw, is catched outside
|
|
b._table = new Element* [targetSize];
|
|
|
|
for (uint64_t i = 0; i < targetSize; i++) {
|
|
b._table[i] = nullptr;
|
|
}
|
|
|
|
b._nrAlloc = targetSize;
|
|
|
|
if (b._nrUsed > 0) {
|
|
uint64_t const n = b._nrAlloc;
|
|
|
|
for (uint64_t j = 0; j < oldAlloc; j++) {
|
|
Element* element = oldTable[j];
|
|
|
|
if (element != nullptr) {
|
|
uint64_t i, k;
|
|
i = k = _hashElement(element) % n;
|
|
|
|
for (; i < n && b._table[i] != nullptr; ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr; ++i);
|
|
}
|
|
|
|
b._table[i] = element;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] oldTable;
|
|
|
|
LOG_TIMER((TRI_microtime() - start),
|
|
"index-resize %s, target size: %llu",
|
|
_contextCallback().c_str(),
|
|
(unsigned long long) targetSize);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief check a resize of the hash array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool checkResize (Bucket& b) {
|
|
if (2 * b._nrAlloc < 3 * b._nrUsed) {
|
|
try {
|
|
resizeInternal(b, 2 * b._nrAlloc + 1, false);
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
public:
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the hash array's memory usage
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
size_t memoryUsage () {
|
|
size_t sum = 0;
|
|
for (auto& b : _buckets) {
|
|
sum += (size_t) (b._nrAlloc * sizeof(Element*));
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the number of elements in the hash
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
size_t size () {
|
|
size_t sum = 0;
|
|
for (auto& b : _buckets) {
|
|
sum += static_cast<size_t>(b._nrUsed);
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief resizes the hash table
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int resize (size_t size) {
|
|
for (auto& b : _buckets) {
|
|
try {
|
|
resizeInternal(b,
|
|
(uint64_t) (3 * size / 2 + 1) / _buckets.size(),
|
|
false);
|
|
}
|
|
catch (...) {
|
|
return TRI_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
return TRI_ERROR_NO_ERROR;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Appends information about statistics in the given json.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void appendToJson (TRI_memory_zone_t* zone, triagens::basics::Json& json) {
|
|
triagens::basics::Json bkts(zone, triagens::basics::Json::Array);
|
|
for (auto& b : _buckets) {
|
|
triagens::basics::Json bucketInfo(zone, triagens::basics::Json::Object);
|
|
bucketInfo("nrAlloc", triagens::basics::Json(static_cast<double>(b._nrAlloc)));
|
|
bucketInfo("nrUsed", triagens::basics::Json(static_cast<double>(b._nrUsed)));
|
|
bkts.add(bucketInfo);
|
|
}
|
|
json("buckets", bkts);
|
|
json("nrBuckets", triagens::basics::Json(static_cast<double>(_buckets.size())));
|
|
json("totalUsed", triagens::basics::Json(static_cast<double>(size())));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief finds an element equal to the given element.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Element* find (Element* element) const {
|
|
uint64_t i = _hashElement(element);
|
|
Bucket const& b = _buckets[i & _bucketsMask];
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
i = i % n;
|
|
uint64_t k = i;
|
|
|
|
for (; i < n && b._table[i] != nullptr &&
|
|
! _isEqualElementElement(element, b._table[i]); ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr &&
|
|
! _isEqualElementElement(element, b._table[i]); ++i);
|
|
}
|
|
|
|
// ...........................................................................
|
|
// return whatever we found, this is nullptr if the thing was not found
|
|
// and otherwise a valid pointer
|
|
// ...........................................................................
|
|
|
|
return b._table[i];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief finds an element given a key, returns NULL if not found
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Element* findByKey (Key* key) const {
|
|
uint64_t i = _hashKey(key);
|
|
Bucket const& b = _buckets[i & _bucketsMask];
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
i = i % n;
|
|
uint64_t k = i;
|
|
|
|
for (; i < n && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
}
|
|
|
|
// ...........................................................................
|
|
// return whatever we found, this is nullptr if the thing was not found
|
|
// and otherwise a valid pointer
|
|
// ...........................................................................
|
|
|
|
return b._table[i];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief adds an key/element to the array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int insert (Key const* key,
|
|
Element* element,
|
|
bool isRollback) {
|
|
// ...........................................................................
|
|
// we are adding and the table is more than half full, extend it
|
|
// ...........................................................................
|
|
|
|
uint64_t i = _hashKey(key);
|
|
Bucket& b = _buckets[i & _bucketsMask];
|
|
|
|
if (! checkResize(b)) {
|
|
return TRI_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
i = i % n;
|
|
uint64_t k = i;
|
|
|
|
for (; i < n && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
}
|
|
|
|
Element* arrayElement = b._table[i];
|
|
|
|
// ...........................................................................
|
|
// if we found an element, return
|
|
// ...........................................................................
|
|
|
|
if (arrayElement != nullptr) {
|
|
return TRI_ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED;
|
|
}
|
|
|
|
b._table[i] = static_cast<Element*>(element);
|
|
TRI_ASSERT(b._table[i] != nullptr);
|
|
b._nrUsed++;
|
|
|
|
return TRI_ERROR_NO_ERROR;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief helper to heal a hole where we deleted something
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void healHole (Bucket& b, uint64_t i) {
|
|
|
|
// ...........................................................................
|
|
// remove item - destroy any internal memory associated with the
|
|
// element structure
|
|
// ...........................................................................
|
|
|
|
b._table[i] = nullptr;
|
|
b._nrUsed--;
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
|
|
// ...........................................................................
|
|
// and now check the following places for items to move closer together
|
|
// so that there are no gaps in the array
|
|
// ...........................................................................
|
|
|
|
uint64_t k = TRI_IncModU64(i, n);
|
|
|
|
while (b._table[k] != nullptr) {
|
|
uint64_t j = _hashElement(b._table[k]) % n;
|
|
|
|
if ((i < k && ! (i < j && j <= k)) || (k < i && ! (i < j || j <= k))) {
|
|
b._table[i] = b._table[k];
|
|
b._table[k] = nullptr;
|
|
i = k;
|
|
}
|
|
|
|
k = TRI_IncModU64(k, n);
|
|
}
|
|
|
|
if (b._nrUsed == 0) {
|
|
resizeInternal(b, initialSize(), true);
|
|
}
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element from the array based on its key,
|
|
/// returns nullptr if the element
|
|
/// was not found and the old value, if it was successfully removed
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Element* removeByKey (Key const* key) {
|
|
uint64_t i = _hashKey(key);
|
|
Bucket& b = _buckets[i & _bucketsMask];
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
i = i % n;
|
|
uint64_t k = i;
|
|
|
|
for (; i < n && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr &&
|
|
! _isEqualKeyElement(key, b._table[i]); ++i);
|
|
}
|
|
|
|
Element* old = b._table[i];
|
|
|
|
// ...........................................................................
|
|
// if we did not find such an item return nullptr
|
|
// ...........................................................................
|
|
|
|
if (old == nullptr) {
|
|
healHole(b, i);
|
|
}
|
|
return old;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removes an element from the array, returns nullptr if the element
|
|
/// was not found and the old value, if it was successfully removed
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Element* remove (Element const* element) {
|
|
uint64_t i = _hashElement(element);
|
|
Bucket& b = _buckets[i & _bucketsMask];
|
|
|
|
uint64_t const n = b._nrAlloc;
|
|
i = i % n;
|
|
uint64_t k = i;
|
|
|
|
for (; i < n && b._table[i] != nullptr &&
|
|
! _isEqualElementElement(element, b._table[i]); ++i);
|
|
if (i == n) {
|
|
for (i = 0; i < k && b._table[i] != nullptr &&
|
|
! _isEqualElementElement(element, b._table[i]); ++i);
|
|
}
|
|
|
|
Element* old = b._table[i];
|
|
|
|
// ...........................................................................
|
|
// if we did not find such an item return nullptr
|
|
// ...........................................................................
|
|
|
|
if (old != nullptr) {
|
|
healHole(b, i);
|
|
}
|
|
|
|
return old;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief a method to iterate over all elements in the hash
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void invokeOnAllElements (CallbackElementFuncType callback) {
|
|
for (auto& b : _buckets) {
|
|
if (b._table != nullptr) {
|
|
for (size_t i = 0; i < b._nrAlloc; ++i) {
|
|
if (b._table[i] != nullptr) {
|
|
callback(b._table[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
} // namespace basics
|
|
} // namespace triagens
|
|
|
|
#endif
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
|
|
// End:
|