mirrors/yosys
3
0
Fork 0
mirror of https://github.com/YosysHQ/yosys synced 2025-04-06 17:44:09 +00:00
Code Activity

new hashlib::pool<> (derived from new dict)

Browse source
This commit is contained in:
Clifford Wolf 2014-12-31 04:19:04 +01:00
parent c4bd6cb9d3
commit 429ccb62a1
1 changed files with 158 additions and 228 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

386
kernel/hashlib.h
View file

@ -289,13 +289,13 @@ class dict
public: public:
class iterator class iterator
{ {
friend dict<K, T, OPS>; friend dict;
protected: protected:
dict<K, T, OPS> *ptr; dict *ptr;
int index; int index;
public: public:
iterator() { } iterator() { }
iterator(dict<K, T, OPS> *ptr, int index) : ptr(ptr), index(index) { } iterator(dict *ptr, int index) : ptr(ptr), index(index) { }
iterator operator++() { index--; return *this; } iterator operator++() { index--; return *this; }
bool operator==(const iterator &other) const { return index == other.index; } bool operator==(const iterator &other) const { return index == other.index; }
bool operator!=(const iterator &other) const { return index != other.index; } bool operator!=(const iterator &other) const { return index != other.index; }
@ -307,13 +307,13 @@ public:
class const_iterator class const_iterator
{ {
friend dict<K, T, OPS>; friend dict;
protected: protected:
const dict<K, T, OPS> *ptr; const dict *ptr;
int index; int index;
public: public:
const_iterator() { } const_iterator() { }
const_iterator(const dict<K, T, OPS> *ptr, int index) : ptr(ptr), index(index) { } const_iterator(const dict *ptr, int index) : ptr(ptr), index(index) { }
const_iterator operator++() { index--; return *this; } const_iterator operator++() { index--; return *this; }
bool operator==(const const_iterator &other) const { return index == other.index; } bool operator==(const const_iterator &other) const { return index == other.index; }
bool operator!=(const const_iterator &other) const { return index != other.index; } bool operator!=(const const_iterator &other) const { return index != other.index; }
@ -325,24 +325,24 @@ public:
{ {
} }
dict(const dict<K, T, OPS> &other) dict(const dict &other)
{ {
entries = other.entries; entries = other.entries;
do_rehash(); do_rehash();
} }
dict(dict<K, T, OPS> &&other) dict(dict &&other)
{ {
swap(other); swap(other);
} }
dict<K, T, OPS> &operator=(const dict<K, T, OPS> &other) { dict &operator=(const dict &other) {
entries = other.entries; entries = other.entries;
do_rehash(); do_rehash();
return *this; return *this;
} }
dict<K, T, OPS> &operator=(dict<K, T, OPS> &&other) { dict &operator=(dict &&other) {
clear(); clear();
swap(other); swap(other);
return *this; return *this;
@ -443,13 +443,13 @@ public:
return entries[i].udata.second; return entries[i].udata.second;
} }
void swap(dict<K, T, OPS> &other) void swap(dict &other)
{ {
hashtable.swap(other.hashtable); hashtable.swap(other.hashtable);
entries.swap(other.entries); entries.swap(other.entries);
} }
bool operator==(const dict<K, T, OPS> &other) const { bool operator==(const dict &other) const {
if (size() != other.size()) if (size() != other.size())
return false; return false;
for (auto &it : entries) { for (auto &it : entries) {
@ -460,7 +460,7 @@ public:
return true; return true;
} }
bool operator!=(const dict<K, T, OPS> &other) const { bool operator!=(const dict &other) const {
return !(*this == other); return !(*this == other);
} }
@ -475,54 +475,38 @@ public:
const_iterator end() const { return const_iterator(nullptr, -1); } const_iterator end() const { return const_iterator(nullptr, -1); }
}; };
// ********************************************************************************
// ********************************************************************************
// ********************************************************************************
// ********************************************************************************
// ********************************************************************************
template<typename K, typename OPS = hash_ops<K>> template<typename K, typename OPS = hash_ops<K>>
class pool class pool
{ {
struct entry_t struct entry_t
{ {
int link; K udata;
K key; int next;
entry_t() : link(-1) { } entry_t() { }
entry_t(const K &key) : link(1), key(key) { } entry_t(const K &udata, int next) : udata(udata), next(next) { }
bool is_free() const { return link < 0; }
int get_next() const { return (link > 0 ? link : -link) - 2; }
bool get_last() const { return get_next() == -1; }
void set_next_used(int next) { link = next + 2; }
void set_next_free(int next) { link = -(next + 2); }
}; };
std::vector<int> hashtable; std::vector<int> hashtable;
std::vector<entry_t> entries; std::vector<entry_t> entries;
int free_list, counter, begin_n;
int begin_seek_count;
OPS ops; OPS ops;
void init() #if 0
{ static inline void do_assert(bool cond) {
free_list = -1; if (!cond) throw std::runtime_error("pool<> assert failed.");
counter = 0;
begin_n = -1;
begin_seek_count = 0;
} }
#else
static inline void do_assert(bool) { }
#endif
void init_from(const pool<K, OPS> &other) int do_hash(const K &key) const
{
hashtable.clear();
entries.clear();
counter = other.size();
begin_n = counter - 1;
entries.reserve(counter);
for (auto &it : other)
entries.push_back(entry_t(it));
rehash();
}
int mkhash(const K &key) const
{ {
unsigned int hash = 0; unsigned int hash = 0;
if (!hashtable.empty()) if (!hashtable.empty())
@ -530,190 +514,152 @@ class pool
return hash; return hash;
} }
void upd_begin_n(bool do_refree = true) void do_rehash()
{ {
if (begin_n < -1) {
begin_n = -(begin_n+2);
while (begin_n >= 0 && entries[begin_n].is_free()) { begin_seek_count++; begin_n--; }
if (do_refree && begin_seek_count > int(entries.size() / 2)) refree();
}
}
void refree()
{
free_list = -1;
begin_n = -1;
int last_free = -1;
for (int i = 0; i < int(entries.size()); i++)
if (entries[i].is_free()) {
if (last_free != -1)
entries[last_free].set_next_free(i);
else
free_list = i;
last_free = i;
} else
begin_n = i;
if (last_free != -1)
entries[last_free].set_next_free(-1);
begin_seek_count = 0;
}
void rehash()
{
upd_begin_n(false);
entries.resize(begin_n + 1);
free_list = -1;
begin_n = -1;
hashtable.clear(); hashtable.clear();
hashtable.resize(hashtable_size(entries.size() * hashtable_size_factor), -1); hashtable.resize(hashtable_size(entries.size() * hashtable_size_factor), -1);
int last_free = -1; for (int i = 0; i < int(entries.size()); i++) {
for (int i = 0; i < int(entries.size()); i++) do_assert(-1 <= entries[i].next && entries[i].next < int(entries.size()));
if (entries[i].is_free()) { int hash = do_hash(entries[i].udata);
if (last_free != -1) entries[i].next = hashtable[hash];
entries[last_free].set_next_free(i); hashtable[hash] = i;
else
free_list = i;
last_free = i;
} else {
int hash = mkhash(entries[i].key);
entries[i].set_next_used(hashtable[hash]);
hashtable[hash] = i;
begin_n = i;
}
if (last_free != -1)
entries[last_free].set_next_free(-1);
begin_seek_count = 0;
}
int do_erase(const K &key, int hash)
{
int last_index = -1;
int index = hashtable.empty() ? -1 : hashtable[hash];
while (1) {
if (index < 0)
return 0;
if (ops.cmp(entries[index].key, key)) {
if (last_index < 0)
hashtable[hash] = entries[index].get_next();
else
entries[last_index].set_next_used(entries[index].get_next());
entries[index].key = K();
entries[index].set_next_free(free_list);
free_list = index;
if (--counter == 0)
clear();
else if (index == begin_n)
begin_n = -(begin_n+2);
return 1;
}
last_index = index;
index = entries[index].get_next();
} }
} }
int lookup_index(const K &key, int hash) const int do_erase(int index, int hash)
{ {
int index = hashtable.empty() ? -1 : hashtable[hash]; do_assert(index < int(entries.size()));
while (1) { if (hashtable.empty() || index < 0)
if (index < 0) return 0;
return -1;
if (ops.cmp(entries[index].key, key))
return index;
index = entries[index].get_next();
}
}
int insert_at(const K &key, int hash) int k = hashtable[hash];
{ if (k == index) {
if (free_list < 0) hashtable[hash] = entries[index].next;
} else {
while (entries[k].next != index) {
k = entries[k].next;
do_assert(0 <= k && k < int(entries.size()));
}
entries[k].next = entries[index].next;
}
int back_idx = entries.size()-1;
if (index != back_idx)
{ {
free_list = entries.size(); int back_hash = do_hash(entries[back_idx].udata);
entries.push_back(entry_t());
if (entries.size() * hashtable_size_trigger > hashtable.size()) { k = hashtable[back_hash];
int i = free_list; if (k == back_idx) {
entries[i].key = key; hashtable[back_hash] = index;
entries[i].set_next_used(0); } else {
begin_n = i; while (entries[k].next != back_idx) {
counter++; k = entries[k].next;
rehash(); do_assert(0 <= k && k < int(entries.size()));
return i; }
entries[k].next = index;
} }
entries[index] = std::move(entries[back_idx]);
} }
int i = free_list; entries.pop_back();
free_list = entries[i].get_next();
entries[i].key = key; if (entries.empty())
entries[i].set_next_used(hashtable[hash]); hashtable.clear();
hashtable[hash] = i;
if ((begin_n < -1 && -(begin_n+2) <= i) || (begin_n >= -1 && begin_n <= i)) return 1;
begin_n = i; }
counter++;
return i; int do_lookup(const K &key, int &hash) const
{
if (hashtable.empty())
return -1;
if (entries.size() * hashtable_size_trigger > hashtable.size()) {
((pool*)this)->do_rehash();
hash = do_hash(key);
}
int index = hashtable[hash];
while (index >= 0 && !ops.cmp(entries[index].udata, key)) {
index = entries[index].next;
do_assert(-1 <= index && index < int(entries.size()));
}
return index;
}
int do_insert(const K &value, int &hash)
{
if (hashtable.empty()) {
entries.push_back(entry_t(value, -1));
do_rehash();
hash = do_hash(value);
} else {
entries.push_back(entry_t(value, hashtable[hash]));
hashtable[hash] = entries.size() - 1;
}
return entries.size() - 1;
} }
public: public:
class iterator class iterator
{ {
pool<K, OPS> *ptr; friend pool;
protected:
pool *ptr;
int index; int index;
public: public:
iterator() { } iterator() { }
iterator(pool<K, OPS> *ptr, int index) : ptr(ptr), index(index) { } iterator(pool *ptr, int index) : ptr(ptr), index(index) { }
iterator operator++() { do index--; while (index >= 0 && ptr->entries[index].is_free()); return *this; } iterator operator++() { index--; return *this; }
bool operator==(const iterator &other) const { return index == other.index; } bool operator==(const iterator &other) const { return index == other.index; }
bool operator!=(const iterator &other) const { return index != other.index; } bool operator!=(const iterator &other) const { return index != other.index; }
K &operator*() { return ptr->entries[index].key; } const K &operator*() const { return ptr->entries[index].udata; }
K *operator->() { return &ptr->entries[index].key; } const K *operator->() const { return &ptr->entries[index].udata; }
const K &operator*() const { return ptr->entries[index].key; }
const K *operator->() const { return &ptr->entries[index].key; }
}; };
class const_iterator class const_iterator
{ {
const pool<K, OPS> *ptr; friend pool;
protected:
const pool *ptr;
int index; int index;
public: public:
const_iterator() { } const_iterator() { }
const_iterator(const pool<K, OPS> *ptr, int index) : ptr(ptr), index(index) { } const_iterator(const pool *ptr, int index) : ptr(ptr), index(index) { }
const_iterator operator++() { do index--; while (index >= 0 && ptr->entries[index].is_free()); return *this; } const_iterator operator++() { index--; return *this; }
bool operator==(const const_iterator &other) const { return index == other.index; } bool operator==(const const_iterator &other) const { return index == other.index; }
bool operator!=(const const_iterator &other) const { return index != other.index; } bool operator!=(const const_iterator &other) const { return index != other.index; }
const K &operator*() const { return ptr->entries[index].key; } const K &operator*() const { return ptr->entries[index].udata; }
const K *operator->() const { return &ptr->entries[index].key; } const K *operator->() const { return &ptr->entries[index].udata; }
}; };
pool() pool()
{ {
init();
} }
pool(const pool<K, OPS> &other) pool(const pool &other)
{ {
init_from(other); entries = other.entries;
do_rehash();
} }
pool(pool<K, OPS> &&other) pool(pool &&other)
{ {
init();
swap(other); swap(other);
} }
pool<K, OPS> &operator=(const pool<K, OPS> &other) { pool &operator=(const pool &other) {
if (this != &other) entries = other.entries;
init_from(other); do_rehash();
return *this; return *this;
} }
pool<K, OPS> &operator=(pool<K, OPS> &&other) { pool &operator=(pool &&other) {
clear(); clear();
swap(other); swap(other);
return *this; return *this;
@ -721,7 +667,6 @@ public:
pool(const std::initializer_list<K> &list) pool(const std::initializer_list<K> &list)
{ {
init();
for (auto &it : list) for (auto &it : list)
insert(it); insert(it);
} }
@ -729,7 +674,6 @@ public:
template<class InputIterator> template<class InputIterator>
pool(InputIterator first, InputIterator last) pool(InputIterator first, InputIterator last)
{ {
init();
insert(first, last); insert(first, last);
} }
@ -740,40 +684,41 @@ public:
insert(*first); insert(*first);
} }
std::pair<iterator, bool> insert(const K &key) std::pair<iterator, bool> insert(const K &value)
{ {
int hash = mkhash(key); int hash = do_hash(value);
int i = lookup_index(key, hash); int i = do_lookup(value, hash);
if (i >= 0) if (i >= 0)
return std::pair<iterator, bool>(iterator(this, i), false); return std::pair<iterator, bool>(iterator(this, i), false);
i = insert_at(key, hash); i = do_insert(value, hash);
return std::pair<iterator, bool>(iterator(this, i), true); return std::pair<iterator, bool>(iterator(this, i), true);
} }
int erase(const K &key) int erase(const K &key)
{ {
int hash = mkhash(key); int hash = do_hash(key);
return do_erase(key, hash); int index = do_lookup(key, hash);
return do_erase(index, hash);
} }
iterator erase(iterator it) iterator erase(iterator it)
{ {
int hash = mkhash(*it); int hash = do_hash(it->first);
do_erase(*it, hash); do_erase(it.index, hash);
return ++it; return ++it;
} }
int count(const K &key) const int count(const K &key) const
{ {
int hash = mkhash(key); int hash = do_hash(key);
int i = lookup_index(key, hash); int i = do_lookup(key, hash);
return i < 0 ? 0 : 1; return i < 0 ? 0 : 1;
} }
iterator find(const K &key) iterator find(const K &key)
{ {
int hash = mkhash(key); int hash = do_hash(key);
int i = lookup_index(key, hash); int i = do_lookup(key, hash);
if (i < 0) if (i < 0)
return end(); return end();
return iterator(this, i); return iterator(this, i);
@ -781,62 +726,47 @@ public:
const_iterator find(const K &key) const const_iterator find(const K &key) const
{ {
int hash = mkhash(key); int hash = do_hash(key);
int i = lookup_index(key, hash); int i = do_lookup(key, hash);
if (i < 0) if (i < 0)
return end(); return end();
return const_iterator(this, i); return const_iterator(this, i);
} }
bool operator[](const K &key) const bool operator[](const K &key)
{ {
int hash = mkhash(key); int hash = do_hash(key);
int i = lookup_index(key, hash); int i = do_lookup(key, hash);
return i >= 0; return i >= 0;
} }
void swap(pool<K, OPS> &other) void swap(pool &other)
{ {
hashtable.swap(other.hashtable); hashtable.swap(other.hashtable);
entries.swap(other.entries); entries.swap(other.entries);
std::swap(free_list, other.free_list);
std::swap(counter, other.counter);
std::swap(begin_n, other.begin_n);
std::swap(begin_seek_count, other.begin_seek_count);
} }
bool operator==(const pool<K, OPS> &other) const { bool operator==(const pool &other) const {
if (counter != other.counter) if (size() != other.size())
return false; return false;
if (counter == 0) for (auto &it : entries)
return true; if (!other.count(it.udata))
if (entries.size() < other.entries.size()) return false;
for (auto &it : *this) {
auto oit = other.find(it.first);
if (oit == other.end() || oit->second != it.second)
return false;
}
else
for (auto &oit : other) {
auto it = find(oit.first);
if (it == end() || it->second != oit.second)
return false;
}
return true; return true;
} }
bool operator!=(const pool<K, OPS> &other) const { bool operator!=(const pool &other) const {
return !(*this == other); return !(*this == other);
} }
size_t size() const { return counter; } size_t size() const { return entries.size(); }
bool empty() const { return counter == 0; } bool empty() const { return entries.empty(); }
void clear() { hashtable.clear(); entries.clear(); init(); } void clear() { hashtable.clear(); entries.clear(); }
iterator begin() { upd_begin_n(); return iterator(this, begin_n); } iterator begin() { return iterator(this, int(entries.size())-1); }
iterator end() { return iterator(nullptr, -1); } iterator end() { return iterator(nullptr, -1); }
const_iterator begin() const { ((pool*)this)->upd_begin_n(); return const_iterator(this, begin_n); } const_iterator begin() const { return const_iterator(this, int(entries.size())-1); }
const_iterator end() const { return const_iterator(nullptr, -1); } const_iterator end() const { return const_iterator(nullptr, -1); }
}; };