tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored

Browse Source
This commit is contained in:
Kruno Tomola Fabro 2016-08-11 14:08:11 +01:00
parent 514cdf401b
commit fdd64dd6ed
4 changed files with 502 additions and 671 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

283
src/data_structures/map/rh_common.hpp Normal file
View File

@ -0,0 +1,283 @@
#pragma once
#include "utils/crtp.hpp"
#include "utils/option_ptr.hpp"
#include <cstring>
#include <functional>
// RobinHood base.
// Entrys are POINTERS alligned to 8B.
// Entrys must know thers key.
// D must have method K& get_key()
// K must be comparable with ==.
template <class K, class D, size_t init_size_pow2 = 2>
class RhBase
{
protected:
class Combined
{
public:
Combined() : data(0) {}
Combined(D *data, size_t off)
{
// assert((((size_t)data) & 0x7) == 0 && off < 8);
this->data = ((size_t)data) | off;
}
bool valid() const { return data != 0; }
size_t off() const { return data & 0x7; }
void decrement_off_unsafe() { data--; }
bool decrement_off()
{
if (off() > 0) {
data--;
return true;
}
return false;
}
bool increment_off()
{
if (off() < 7) {
data++;
return true;
}
return false;
}
D *ptr() const { return (D *)(data & (~(0x7))); }
bool equal(const K &key, size_t off)
{
return this->off() == off && key == ptr()->get_key();
}
friend bool operator==(const Combined &a, const Combined &b)
{
return a.off() == b.off() &&
a.ptr()->get_key() == b.ptr()->get_key();
}
friend bool operator!=(const Combined &a, const Combined &b)
{
return !(a == b);
}
private:
size_t data;
};
template <class It>
class IteratorBase : public Crtp<It>
{
protected:
IteratorBase() : map(nullptr) { advanced = index = ~((size_t)0); }
IteratorBase(const RhBase *map) : map(map)
{
index = 0;
while (index < map->capacity && !map->array[index].valid()) {
index++;
}
if (index == map->capacity) {
map = nullptr;
advanced = index = ~((size_t)0);
} else {
advanced = index;
}
}
IteratorBase(const RhBase *map, size_t start)
: map(map), index(start), advanced(0)
{
}
const RhBase *map;
size_t advanced;
size_t index;
public:
IteratorBase(const IteratorBase &) = default;
IteratorBase(IteratorBase &&) = default;
D *operator*()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
D *operator->()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
It &operator++()
{
assert(index < map->capacity && map->array[index].valid());
auto mask = map->mask();
do {
advanced++;
if (advanced >= map->capacity) {
map = nullptr;
advanced = index = ~((size_t)0);
break;
}
index = (index + 1) & mask;
} while (!map->array[index].valid());
return this->derived();
}
It &operator++(int) { return operator++(); }
friend bool operator==(const It &a, const It &b)
{
return a.index == b.index && a.map == b.map;
}
friend bool operator!=(const It &a, const It &b) { return !(a == b); }
};
public:
class ConstIterator : public IteratorBase<ConstIterator>
{
friend class RhBase;
protected:
ConstIterator(const RhBase *map) : IteratorBase<ConstIterator>(map) {}
ConstIterator(const RhBase *map, size_t index)
: IteratorBase<ConstIterator>(map, index)
{
}
public:
ConstIterator() = default;
ConstIterator(const ConstIterator &) = default;
const D *operator->()
{
return IteratorBase<ConstIterator>::operator->();
}
const D *operator*()
{
return IteratorBase<ConstIterator>::operator*();
}
};
class Iterator : public IteratorBase<Iterator>
{
friend class RhBase;
protected:
Iterator(const RhBase *map) : IteratorBase<Iterator>(map) {}
Iterator(const RhBase *map, size_t index)
: IteratorBase<Iterator>(map, index)
{
}
public:
Iterator() = default;
Iterator(const Iterator &) = default;
};
RhBase() {}
RhBase(const RhBase &other)
{
capacity = other.capacity;
count = other.count;
if (capacity > 0) {
size_t bytes = sizeof(Combined) * capacity;
array = (Combined *)malloc(bytes);
memcpy(array, other.array, bytes);
} else {
array = nullptr;
}
}
~RhBase() { this->clear(); }
Iterator begin() { return Iterator(this); }
ConstIterator begin() const { return ConstIterator(this); }
ConstIterator cbegin() const { return ConstIterator(this); }
Iterator end() { return Iterator(); }
ConstIterator end() const { return ConstIterator(); }
ConstIterator cend() const { return ConstIterator(); }
protected:
void init_array(size_t size)
{
size_t bytes = sizeof(Combined) * size;
array = (Combined *)malloc(bytes);
std::memset(array, 0, bytes);
capacity = size;
}
// True if before array has some values.
// Before array has to be released also.
bool increase_size()
{
if (capacity == 0) {
// assert(array == nullptr && count == 0);
size_t new_size = 1 << init_size_pow2;
init_array(new_size);
return false;
}
size_t new_size = capacity * 2;
init_array(new_size);
count = 0;
return true;
}
Iterator create_it(size_t index) { return Iterator(this, index); }
public:
void clear()
{
free(array);
array = nullptr;
capacity = 0;
count = 0;
}
size_t size() const { return count; }
protected:
size_t before_index(size_t now, size_t mask)
{
return (now - 1) & mask; // THIS IS VALID
}
size_t index(const K &key, size_t mask) const
{
return hash(std::hash<K>()(key)) & mask;
}
// This is rather expensive but offers good distribution.
size_t hash(size_t x) const
{
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
}
size_t mask() const { return capacity - 1; }
Combined *array = nullptr;
size_t capacity = 0;
size_t count = 0;
friend class IteratorBase<Iterator>;
friend class IteratorBase<ConstIterator>;
};

234
src/data_structures/map/rh_hashmap.hpp
View File

@ -1,3 +1,4 @@
#include "rh_common.hpp"
#include "utils/crtp.hpp"
#include "utils/option_ptr.hpp"
#include <functional>
@ -10,197 +11,33 @@
// K must be comparable with ==.
// HashMap behaves as if it isn't owner of entrys.
template <class K, class D, size_t init_size_pow2 = 2>
class RhHashMap
class RhHashMap : public RhBase<K, D, init_size_pow2>
{
private:
class Combined
{
public:
Combined() : data(0) {}
Combined(D *data, size_t off)
{
// assert(((((size_t)(data)) & 0x7) == 0) && off < 8);
this->data = ((size_t)data) | off;
}
bool valid() { return data != 0; }
size_t off() { return data & 0x7; }
void decrement_off() { data--; }
bool increment_off()
{
if (off() < 7) {
data++;
return true;
}
return false;
}
D *ptr() { return (D *)(data & (~(0x7))); }
private:
size_t data;
};
template <class It>
class IteratorBase : public Crtp<It>
{
protected:
IteratorBase() : map(nullptr) { index = ~((size_t)0); }
IteratorBase(const RhHashMap *map) : map(map)
{
index = 0;
while (index < map->capacity && !map->array[index].valid()) {
index++;
}
if (index == map->capacity) {
map = nullptr;
index = ~((size_t)0);
}
}
const RhHashMap *map;
size_t index;
public:
IteratorBase(const IteratorBase &) = default;
IteratorBase(IteratorBase &&) = default;
D *operator*()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
D *operator->()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
It &operator++()
{
assert(index < map->capacity && map->array[index].valid());
do {
index++;
if (index >= map->capacity) {
map = nullptr;
index = ~((size_t)0);
break;
}
} while (!map->array[index].valid());
return this->derived();
}
It &operator++(int) { return operator++(); }
friend bool operator==(const It &a, const It &b)
{
return a.index == b.index && a.map == b.map;
}
friend bool operator!=(const It &a, const It &b) { return !(a == b); }
};
public:
class ConstIterator : public IteratorBase<ConstIterator>
{
friend class RhHashMap;
ConstIterator(const RhHashMap *map) : IteratorBase<ConstIterator>(map)
{
}
public:
ConstIterator() = default;
ConstIterator(const ConstIterator &) = default;
const D *operator->()
{
return IteratorBase<ConstIterator>::operator->();
}
const D *operator*()
{
return IteratorBase<ConstIterator>::operator*();
}
};
class Iterator : public IteratorBase<Iterator>
{
friend class RhHashMap;
Iterator(const RhHashMap *map) : IteratorBase<Iterator>(map) {}
public:
Iterator() = default;
Iterator(const Iterator &) = default;
};
RhHashMap() {}
RhHashMap(const RhHashMap &other)
{
capacity = other.capacity;
count = other.count;
if (capacity > 0) {
size_t bytes = sizeof(Combined) * capacity;
array = (Combined *)malloc(bytes);
memcpy(array, other.array, bytes);
} else {
array = nullptr;
}
}
~RhHashMap() { this->clear(); }
Iterator begin() { return Iterator(this); }
ConstIterator begin() const { return ConstIterator(this); }
ConstIterator cbegin() const { return ConstIterator(this); }
Iterator end() { return Iterator(); }
ConstIterator end() const { return ConstIterator(); }
ConstIterator cend() const { return ConstIterator(); }
void init_array(size_t size)
{
size_t bytes = sizeof(Combined) * size;
array = (Combined *)malloc(bytes);
memset(array, 0, bytes);
capacity = size;
}
typedef RhBase<K, D, init_size_pow2> base;
using base::array;
using base::index;
using base::capacity;
using base::count;
using typename base::Combined;
void increase_size()
{
if (capacity == 0) {
// assert(array == nullptr && count == 0);
size_t new_size = 1 << init_size_pow2;
init_array(new_size);
return;
}
size_t new_size = capacity * 2;
size_t old_size = capacity;
auto a = array;
init_array(new_size);
count = 0;
for (int i = 0; i < old_size; i++) {
if (a[i].valid()) {
insert(a[i].ptr());
if (base::increase_size()) {
for (int i = 0; i < old_size; i++) {
if (a[i].valid()) {
insert(a[i].ptr());
}
}
}
free(a);
}
public:
using base::RhBase;
bool contains(const K &key) { return find(key).is_present(); }
OptionPtr<D> find(const K key)
@ -293,9 +130,10 @@ public:
auto before = now;
do {
other.decrement_off(); // This is alright even for off=0
// on found element because it
// wont be seen.
// This is alright even for off=0 on found element
// because it wont be seen.
other.decrement_off_unsafe();
array[before] = other;
before = now;
now = (now + 1) & mask;
@ -318,36 +156,4 @@ public:
}
return OptionPtr<D>();
}
void clear()
{
free(array);
array = nullptr;
capacity = 0;
count = 0;
}
size_t size() { return count; }
private:
size_t index(const K &key, size_t mask)
{
return hash(std::hash<K>()(key)) & mask;
}
size_t hash(size_t x) const
{
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
}
size_t mask() { return capacity - 1; }
Combined *array = nullptr;
size_t capacity = 0;
size_t count = 0;
friend class IteratorBase<Iterator>;
friend class IteratorBase<ConstIterator>;
};

593
src/data_structures/map/rh_hashmultimap.hpp
View File

@ -1,4 +1,6 @@
#include "rh_common.hpp"
#include "utils/crtp.hpp"
#include "utils/likely.hpp"
#include "utils/option_ptr.hpp"
#include <cstring>
#include <functional>
@ -11,236 +13,38 @@
// K must be comparable with ==.
// HashMap behaves as if it isn't owner of entrys.
template <class K, class D, size_t init_size_pow2 = 2>
class RhHashMultiMap
class RhHashMultiMap : public RhBase<K, D, init_size_pow2>
{
private:
class Combined
{
public:
Combined() : data(0) {}
Combined(D *data, size_t off)
{
assert((data & 0x7) == 0 && off < 8);
this->data = ((size_t)data) | off;
}
bool valid() { return data != 0; }
size_t off() { return data & 0x7; }
bool decrement_off()
{
if (off() > 0) {
data--;
return true;
}
return false;
}
bool increment_off()
{
if (off() < 7) {
data++;
return true;
}
return false;
}
D *ptr() { return (D *)(data & (~(0x7))); }
private:
size_t data;
};
template <class It>
class IteratorBase : public Crtp<It>
{
protected:
IteratorBase() : map(nullptr) { advanced = index = ~((size_t)0); }
IteratorBase(const RhHashMultiMap *map) : map(map)
{
index = 0;
while (index < map->capacity && !map->array[index].valid()) {
index++;
}
if (index == map->capacity) {
map = nullptr;
advanced = index = ~((size_t)0);
} else {
advanced = index;
}
}
IteratorBase(const RhHashMultiMap *map, size_t start)
: map(map), index(start), advanced(0)
{
}
const RhHashMultiMap *map;
size_t advanced;
size_t index;
public:
IteratorBase(const IteratorBase &) = default;
IteratorBase(IteratorBase &&) = default;
D *operator*()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
D *operator->()
{
assert(index < map->capacity && map->array[index].valid());
return map->array[index].ptr();
}
It &operator++()
{
assert(index < map->capacity && map->array[index].valid());
auto mask = map->mask();
do {
advanced++;
if (advanced >= map->capacity) {
map = nullptr;
advanced = index = ~((size_t)0);
break;
}
index = (index + 1) & mask;
} while (!map->array[index].valid());
return this->derived();
}
//
// // True if value is present
// bool is_present() { return map != nullptr; }
It &operator++(int) { return operator++(); }
friend bool operator==(const It &a, const It &b)
{
return a.index == b.index && a.map == b.map;
}
friend bool operator!=(const It &a, const It &b) { return !(a == b); }
};
public:
class ConstIterator : public IteratorBase<ConstIterator>
{
friend class RhHashMultiMap;
ConstIterator(const RhHashMultiMap *map)
: IteratorBase<ConstIterator>(map)
{
}
ConstIterator(const RhHashMultiMap *map, size_t index)
: IteratorBase<ConstIterator>(map, index)
{
}
public:
ConstIterator() = default;
ConstIterator(const ConstIterator &) = default;
const D *operator->()
{
return IteratorBase<ConstIterator>::operator->();
}
const D *operator*()
{
return IteratorBase<ConstIterator>::operator*();
}
};
class Iterator : public IteratorBase<Iterator>
{
friend class RhHashMultiMap;
Iterator(const RhHashMultiMap *map) : IteratorBase<Iterator>(map) {}
Iterator(const RhHashMultiMap *map, size_t index)
: IteratorBase<Iterator>(map, index)
{
}
public:
Iterator() = default;
Iterator(const Iterator &) = default;
};
RhHashMultiMap() {}
RhHashMultiMap(const RhHashMultiMap &other)
{
capacity = other.capacity;
count = other.count;
if (capacity > 0) {
size_t bytes = sizeof(Combined) * capacity;
array = (Combined *)malloc(bytes);
memcpy(array, other.array, bytes);
} else {
array = nullptr;
}
}
// RhHashMultiMap(RhHashMultiMap &&other)
// {
// capacity = other.capacity;
// count = other.count;
// array = other.array;
//
// other.array = nullptr;
// other.capacity = 0;
// other.count = 0;
// }
~RhHashMultiMap() { this->clear(); }
Iterator begin() { return Iterator(this); }
ConstIterator begin() const { return ConstIterator(this); }
ConstIterator cbegin() const { return ConstIterator(this); }
Iterator end() { return Iterator(); }
ConstIterator end() const { return ConstIterator(); }
ConstIterator cend() const { return ConstIterator(); }
void init_array(size_t size)
{
size_t bytes = sizeof(Combined) * size;
array = (Combined *)malloc(bytes);
std::memset(array, 0, bytes);
capacity = size;
}
typedef RhBase<K, D, init_size_pow2> base;
using base::array;
using base::index;
using base::capacity;
using base::count;
using typename base::Combined;
using base::before_index;
using base::create_it;
void increase_size()
{
if (capacity == 0) {
assert(array == nullptr && count == 0);
size_t new_size = 1 << init_size_pow2;
init_array(new_size);
return;
}
size_t new_size = capacity * 2;
size_t old_size = capacity;
auto a = array;
init_array(new_size);
count = 0;
for (int i = 0; i < old_size; i++) {
if (a[i].valid()) {
add(a[i].ptr());
if (base::increase_size()) {
for (int i = 0; i < old_size; i++) {
if (a[i].valid()) {
add(a[i].ptr());
}
}
}
free(a);
}
public:
using base::RhBase;
using base::end;
using typename base::ConstIterator;
using typename base::Iterator;
bool contains(const K &key) { return find(key) != end(); }
Iterator find(const K &key_in)
@ -250,30 +54,20 @@ public:
size_t mask = this->mask();
size_t now = index(key, mask);
size_t off = 0;
size_t checked = 0;
size_t border = 8 <= capacity ? 8 : capacity;
Combined other = array[now];
while (other.valid() && off < border) {
auto other_off = other.off();
if (other_off == off && key == other.ptr()->get_key()) {
return Iterator(this, now);
return create_it(now);
} else if (other_off < off) { // Other is rich
break;
} else { // Else other has equal or greater
// offset, so he is poor.
auto other_key = other.ptr()->get_key();
do {
now = (now + 1) & mask;
other = array[now];
checked++;
if (checked >= count) { // Reason is possibility of map
// full of same values.
break;
}
} while (other.valid() && other.off() == other_off &&
other.ptr()->get_key() == other_key);
} else { // Else other has equal or greater off, so he is poor.
if (UNLIKELY(skip(now, other, other_off, mask))) {
break;
}
off++;
}
}
@ -301,31 +95,24 @@ public:
Combined other = array[now];
while (off < border) {
if (other.valid()) {
auto other_off = other.off();
const size_t other_off = other.off();
bool multi = false;
if (other_off == off &&
other.ptr()->get_key() == key) { // Found the
do { // same
if (other_off == off && other.ptr()->get_key() == key) {
// Found the same
do {
now = (now + 1) & mask;
other = array[now];
if (!other.valid()) {
set(now, data, off);
return;
}
other_off = other.off();
} while (other_off == off &&
other.ptr()->get_key() == key);
} while (other.equal(key, off));
multi = true;
} else if (other_off > off ||
other_poor(other, mask, start,
now)) { // Other is poor or the same
auto other_key = other.ptr()->get_key();
do {
now = (now + 1) & mask;
other = array[now];
} while (other.valid() && other.off() == other_off &&
other.ptr()->get_key() == other_key);
now)) { // Else other has equal or
// greater off, so he is poor.
skip(now, other, other_off, mask); // TRUE IS IMPOSSIBLE
off++;
continue;
}
@ -357,136 +144,6 @@ public:
add(data);
}
private:
void set(size_t now, D *data, size_t off)
{
array[now] = Combined(data, off);
count++;
}
// True if no adjusment is needed, false otherwise.
bool is_off_adjusted(Combined &com, size_t mask, size_t start, size_t now,
bool multi)
{
if (com.off() == 0) { // Must be adjusted
return false;
}
size_t cin = index(com.ptr()->get_key(), mask);
if ((start <= now && (cin < start || cin > now)) ||
(now < start && cin < start &&
cin > now)) { // Outside [start,now] interval
return multi;
}
auto a = array[cin];
auto b = array[(cin + 1) & mask];
return (a.off() == b.off() && a.ptr()->get_key() == b.ptr()->get_key());
// Check if different key has eneterd in to
// range of other.
}
bool other_poor(Combined other, size_t mask, size_t start, size_t now)
{
auto cin = index(other.ptr()->get_key(), mask);
return (start <= now && (cin <= start || cin > now)) ||
(now < start && cin <= start &&
cin > now); // If other index is smaller then he is poorer.
}
// True if no adjusment is needed, false otherwise.
bool is_off_adjusted_rem(Combined &com, size_t mask, size_t start,
size_t bef, size_t now, bool multi)
{
if (com.off() == 0) { // Must be adjusted
return false;
}
size_t cin = index(com.ptr()->get_key(), mask);
if (cin == bef) {
return false;
}
if ((start <= now && (cin < start || cin > now)) ||
(now < start && cin < start &&
cin > now)) { // Outside [start,now] interval
return multi;
}
auto a = array[cin];
auto b = array[before_index(cin, mask)];
return b.valid() &&
(a.off() == b.off() && a.ptr()->get_key() == b.ptr()->get_key());
// Check if different key has eneterd in to
// range of other.
}
public:
// Removes element. Returns removed element if it existed. It doesn't
// specify which element from same key group will be removed.
OptionPtr<D> remove(const K &key_in)
{
if (count > 0) {
auto key = std::ref(key_in);
size_t mask = this->mask();
size_t now = index(key, mask);
size_t off = 0;
size_t checked = 0;
size_t border = 8 <= capacity ? 8 : capacity;
Combined other = array[now];
while (other.valid() && off < border) {
auto other_off = other.off();
bool multi = false;
if (other_off == off && key == other.ptr()->get_key()) {
do {
now = (now + 1) & mask;
other = array[now];
if (!other.valid()) {
break;
}
other_off = other.off();
} while (other_off == off &&
other.ptr()->get_key() == key &&
(multi = true)); // multi = true is correct
auto bef = before_index(now, mask);
auto ret = OptionPtr<D>(array[bef].ptr());
auto start_rem = bef;
while (other.valid() &&
(is_off_adjusted_rem(other, mask, start_rem, bef,
now, multi) ||
other.decrement_off())) {
array[bef] = other;
bef = now;
now = (now + 1) & mask;
other = array[now];
}
array[bef] = Combined();
count--;
return ret;
} else if (other_off < off) { // Other is rich
break;
} else { // Else other has equal or greater
// offset, so he is poor.
auto other_key = other.ptr()->get_key();
do {
now = (now + 1) & mask;
other = array[now];
checked++;
if (checked >= count) { // Reason is possibility of map
// full of same values.
break;
}
} while (other.valid() && other.off() == other_off &&
other.ptr()->get_key() == other_key);
off++;
}
}
}
return OptionPtr<D>();
}
// Removes element equal by key and value. Returns true if it existed.
bool remove(D *data)
{
@ -495,34 +152,32 @@ public:
size_t mask = this->mask();
size_t now = index(key, mask);
size_t off = 0;
size_t checked = 0;
size_t border = 8 <= capacity ? 8 : capacity;
Combined other = array[now];
while (other.valid() && off < border) {
auto other_off = other.off();
bool multi = false;
const size_t other_off = other.off();
if (other_off == off && key == other.ptr()->get_key()) {
auto founded = capacity;
size_t started = now;
bool multi = false;
do {
if (other.ptr() == data) {
founded = now;
}
now = (now + 1) & mask;
other = array[now];
if (!other.valid()) {
if (!other.valid() || UNLIKELY(started == now)) {
// Reason is possibility of map full of same values.
break;
}
other_off = other.off();
} while (other_off == off &&
other.ptr()->get_key() == key &&
(multi = true)); // multi = true is correct
} while (other.equal(key, off) && (multi = true));
// multi = true is correct
if (founded == capacity) {
return false;
}
auto bef = before_index(now, mask);
array[founded] = array[bef];
// Same as remove of key only diffrence is with founded
auto start_rem = bef;
while (other.valid() &&
@ -542,19 +197,10 @@ public:
} else if (other_off < off) { // Other is rich
break;
} else { // Else other has equal or greater
// offset, so he is poor.
auto other_key = other.ptr()->get_key();
do {
now = (now + 1) & mask;
other = array[now];
checked++;
if (checked >= count) { // Reason is possibility of map
// full of same values.
break;
}
} while (other.valid() && other.off() == other_off &&
other.ptr()->get_key() == other_key);
} else { // Else other has equal or greater off, so he is poor.
if (UNLIKELY(skip(now, other, other_off, mask))) {
break;
}
off++;
}
}
@ -562,41 +208,138 @@ public:
return false;
}
void clear()
{
free(array);
array = nullptr;
capacity = 0;
count = 0;
}
size_t size() const { return count; }
private:
size_t before_index(size_t now, size_t mask)
// Skips same key valus as other. true if whole map is full of same key
// values.
bool skip(size_t &now, Combined &other, size_t other_off, size_t mask)
{
return (now - 1) & mask; // THIS IS VALID
auto other_key = other.ptr()->get_key();
size_t start = now;
do {
now = (now + 1) & mask;
other = array[now];
if (UNLIKELY(start == now)) { // Reason is possibility of map
// full of same values.
return true;
}
} while (other.valid() && other.equal(other_key, other_off));
return false;
}
size_t index(const K &key, size_t mask) const
void set(size_t now, D *data, size_t off)
{
return hash(std::hash<K>()(key)) & mask;
array[now] = Combined(data, off);
count++;
}
size_t hash(size_t x) const
// True if no adjusment is needed, false otherwise.
bool is_off_adjusted(Combined &com, size_t mask, size_t start, size_t now,
bool multi)
{
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
if (com.off() == 0) { // Must be adjusted
return false;
}
size_t cin = index(com.ptr()->get_key(), mask);
if (outside(start, now, cin)) { // Outside [start,now] interval
return multi;
}
auto a = array[cin];
auto b = array[(cin + 1) & mask];
return a == b;
// Check if different key has eneterd in to
// range of other.
}
size_t mask() const { return capacity - 1; }
bool other_poor(Combined other, size_t mask, size_t start, size_t now)
{
// If other index is smaller then he is poorer.
return outside_left_weak(start, now,
index(other.ptr()->get_key(), mask));
}
Combined *array = nullptr;
size_t capacity = 0;
size_t count = 0;
// True if no adjusment is needed, false otherwise.
bool is_off_adjusted_rem(Combined &com, size_t mask, size_t start,
size_t bef, size_t now, bool multi)
{
if (com.off() == 0) { // Must be adjusted
return false;
}
size_t cin = index(com.ptr()->get_key(), mask);
if (cin == bef) {
return false;
}
if (outside(start, now, cin)) {
return multi;
}
auto a = array[cin];
auto b = array[before_index(cin, mask)];
return b.valid() && a == b;
// Check if different key has eneterd in to
// range of other.
}
friend class IteratorBase<Iterator>;
friend class IteratorBase<ConstIterator>;
// True if p is uutside [start,end] interval
bool outside(size_t start, size_t end, size_t p)
{
return (start <= end && (p < start || p > end)) ||
(end < start && p < start && p > end);
}
// True if p is outside <start,end] interval
bool outside_left_weak(size_t start, size_t end, size_t p)
{
return (start <= end && (p <= start || p > end)) ||
(end < start && p <= start && p > end);
}
};
// Unnecessary
// // Removes element. Returns removed element if it existed. It doesn't
// // specify which element from same key group will be removed.
// OptionPtr<D> remove(const K &key_in)
// {
//
// if (count > 0) {
// auto key = std::ref(key_in);
// size_t mask = this->mask();
// size_t now = index(key, mask);
// size_t off = 0;
// size_t checked = 0;
// size_t border = 8 <= capacity ? 8 : capacity;
// Combined other = array[now];
// while (other.valid() && off < border) {
// auto other_off = other.off();
// bool multi = false;
// if (other_off == off && key == other.ptr()->get_key()) {
// do {
// now = (now + 1) & mask;
// other = array[now];
// if (!other.valid()) {
// break;
// }
// other_off = other.off();
// } while (other_off == off &&
// other.ptr()->get_key() == key &&
// (multi = true)); // multi = true is correct
//
// auto bef = before_index(now, mask);
// auto ret = OptionPtr<D>(array[bef].ptr());
//
// move_before(now, bef, other, mask, multi);
// return ret;
//
// } else if (other_off < off) { // Other is rich
// break;
//
// } else { // Else other has equal or greater off, so he is
// poor.
// if (UNLIKELY(skip(now, other, other_off, mask))) {
// break;
// }
// off++;
// }
// }
// }
//
// return OptionPtr<D>();
// }

63
tests/unit/rh_hashmultimap.cpp
View File

@ -42,6 +42,36 @@ TEST_CASE("Robin hood hashmultimap insert/get check")
REQUIRE(*map.find(0) == ptr0);
}
TEST_CASE("Robin hood hashmultimap extreme same key valus full")
{
RhHashMultiMap<int, Data> map;
for (int i = 0; i < 128; i++) {
map.add(new Data(7));
}
REQUIRE(map.size() == 128);
REQUIRE(map.find(7) != map.end());
REQUIRE(map.find(0) == map.end());
auto ptr0 = new Data(0);
map.add(ptr0);
REQUIRE(map.find(0) != map.end());
REQUIRE(*map.find(0) == ptr0);
}
TEST_CASE("Robin hood hashmultimap extreme same key valus full with remove")
{
RhHashMultiMap<int, Data> map;
for (int i = 0; i < 127; i++) {
map.add(new Data(7));
}
auto ptr = new Data(7);
map.add(ptr);
REQUIRE(map.size() == 128);
REQUIRE(!map.remove(new Data(0)));
REQUIRE(map.remove(ptr));
}
TEST_CASE("Robin hood hasmultihmap remove functionality")
{
RhHashMultiMap<int, Data> map;
@ -51,7 +81,7 @@ TEST_CASE("Robin hood hasmultihmap remove functionality")
map.add(ptr0);
REQUIRE(map.find(0) != map.end());
REQUIRE(*map.find(0) == ptr0);
REQUIRE(map.remove(0).get() == ptr0);
REQUIRE(map.remove(ptr0));
REQUIRE(map.find(0) == map.end());
}
@ -144,37 +174,6 @@ TEST_CASE("Robin hood hashmultimap checked rand")
cross_validate(map, s_map);
}
TEST_CASE("Robin hood hashmultimap with remove checked")
{
RhHashMultiMap<int, Data> map;
std::multimap<int, Data *> s_map;
std::srand(std::time(0));
for (int i = 0; i < 162638; i++) {
int key = (std::rand() % 10000) << 3;
if ((std::rand() % 3) == 0) {
auto removed = map.remove(key);
auto it = s_map.find(key);
if (removed.is_present()) {
while (it != s_map.end() && it->second != removed.get()) {
it++;
}
REQUIRE(it != s_map.end());
s_map.erase(it);
} else {
REQUIRE(it == s_map.end());
}
} else {
auto data = new Data(key);
map.add(data);
s_map.insert(std::pair<int, Data *>(key, data));
}
}
cross_validate(map, s_map);
}
TEST_CASE("Robin hood hashmultimap with remove data checked")
{
RhHashMultiMap<int, Data> map;