2020-02-03 07:00:36 +03:00
|
|
|
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
|
2019-06-23 05:21:30 +03:00
|
|
|
// Use of this source code is governed by an MIT license
|
|
|
|
// that can be found in the LICENSE file.
|
2019-06-22 21:20:28 +03:00
|
|
|
module builtin
|
|
|
|
|
2020-07-18 14:49:00 +03:00
|
|
|
//import hash.wyhash as hash
|
|
|
|
import hash
|
2020-04-08 01:02:15 +03:00
|
|
|
|
2020-03-19 08:52:34 +03:00
|
|
|
/*
|
2020-05-17 14:51:18 +03:00
|
|
|
This is a highly optimized hashmap implementation. It has several traits that
|
2020-04-12 15:10:06 +03:00
|
|
|
in combination makes it very fast and memory efficient. Here is a short expl-
|
|
|
|
anation of each trait. After reading this you should have a basic understand-
|
|
|
|
ing of how it functions:
|
|
|
|
|
|
|
|
1. Hash-function: Wyhash. Wyhash is the fastest hash-function for short keys
|
|
|
|
passing SMHasher, so it was an obvious choice.
|
|
|
|
|
|
|
|
2. Open addressing: Robin Hood Hashing. With this method, a hash-collision is
|
|
|
|
resolved by probing. As opposed to linear probing, Robin Hood hashing has a
|
|
|
|
simple but clever twist: As new keys are inserted, old keys are shifted arou-
|
|
|
|
nd in a way such that all keys stay reasonably close to the slot they origin-
|
|
|
|
ally hash to. A new key may displace a key already inserted if its probe cou-
|
2020-05-17 14:51:18 +03:00
|
|
|
nt is larger than that of the key at the current position.
|
2020-04-12 15:10:06 +03:00
|
|
|
|
|
|
|
3. Memory layout: key-value pairs are stored in a `DenseArray`. This is a dy-
|
|
|
|
namic array with a very low volume of unused memory, at the cost of more rea-
|
|
|
|
llocations when inserting elements. It also preserves the order of the key-v-
|
|
|
|
alues. This array is named `key_values`. Instead of probing a new key-value,
|
|
|
|
this map probes two 32-bit numbers collectively. The first number has its 8
|
|
|
|
most significant bits reserved for the probe-count and the remaining 24 bits
|
|
|
|
are cached bits from the hash which are utilized for faster re-hashing. This
|
|
|
|
number is often referred to as `meta`. The other 32-bit number is the index
|
|
|
|
at which the key-value was pushed to in `key_values`. Both of these numbers
|
|
|
|
are stored in a sparse array `metas`. The `meta`s and `kv_index`s are stored
|
|
|
|
at even and odd indices, respectively:
|
|
|
|
|
|
|
|
metas = [meta, kv_index, 0, 0, meta, kv_index, 0, 0, meta, kv_index, ...]
|
|
|
|
key_values = [kv, kv, kv, ...]
|
|
|
|
|
|
|
|
4. The size of metas is a power of two. This enables the use of bitwise AND
|
2020-05-26 18:59:52 +03:00
|
|
|
to convert the 64-bit hash to a bucket/index that doesn't overflow metas. If
|
2020-04-12 15:10:06 +03:00
|
|
|
the size is power of two you can use "hash & (SIZE - 1)" instead of "hash %
|
|
|
|
SIZE". Modulo is extremely expensive so using '&' is a big performance impro-
|
|
|
|
vement. The general concern with this approach is that you only make use of
|
|
|
|
the lower bits of the hash which can cause more collisions. This is solved by
|
|
|
|
using a well-dispersed hash-function.
|
|
|
|
|
|
|
|
5. The hashmap keeps track of the highest probe_count. The trick is to alloc-
|
|
|
|
ate `extra_metas` > max(probe_count), so you never have to do any bounds-che-
|
2020-05-17 14:51:18 +03:00
|
|
|
cking since the extra meta memory ensures that a meta will never go beyond
|
2020-03-21 15:55:07 +03:00
|
|
|
the last index.
|
2020-03-19 08:52:34 +03:00
|
|
|
|
2020-04-12 15:10:06 +03:00
|
|
|
6. Cached rehashing. When the `load_factor` of the map exceeds the `max_load_
|
|
|
|
factor` the size of metas is doubled and all the key-values are "rehashed" to
|
|
|
|
find the index for their meta's in the new array. Instead of rehashing compl-
|
|
|
|
etely, it simply uses the cached-hashbits stored in the meta, resulting in
|
|
|
|
much faster rehashing.
|
2020-03-19 08:52:34 +03:00
|
|
|
*/
|
|
|
|
|
2020-01-24 22:13:59 +03:00
|
|
|
const (
|
2020-05-26 18:59:52 +03:00
|
|
|
// Number of bits from the hash stored for each entry
|
2020-05-09 13:42:01 +03:00
|
|
|
hashbits = 24
|
2020-03-21 15:55:07 +03:00
|
|
|
// Number of bits from the hash stored for rehashing
|
2020-04-05 23:09:52 +03:00
|
|
|
max_cached_hashbits = 16
|
2020-02-20 22:04:06 +03:00
|
|
|
// Initial log-number of buckets in the hashtable
|
2020-05-09 13:42:01 +03:00
|
|
|
init_log_capicity = 5
|
2020-02-20 22:04:06 +03:00
|
|
|
// Initial number of buckets in the hashtable
|
2020-05-09 13:42:01 +03:00
|
|
|
init_capicity = 1 << init_log_capicity
|
2020-06-21 17:51:02 +03:00
|
|
|
// Maximum load-factor (len / capacity)
|
2020-05-09 13:42:01 +03:00
|
|
|
max_load_factor = 0.8
|
2020-03-21 15:55:07 +03:00
|
|
|
// Initial highest even index in metas
|
2020-05-09 13:42:01 +03:00
|
|
|
init_cap = init_capicity - 2
|
2020-03-19 08:52:34 +03:00
|
|
|
// Used for incrementing `extra_metas` when max
|
|
|
|
// probe count is too high, to avoid overflow
|
2020-05-09 13:42:01 +03:00
|
|
|
extra_metas_inc = 4
|
2020-02-20 22:04:06 +03:00
|
|
|
// Bitmask to select all the hashbits
|
2020-05-09 13:42:01 +03:00
|
|
|
hash_mask = u32(0x00FFFFFF)
|
2020-02-20 22:04:06 +03:00
|
|
|
// Used for incrementing the probe-count
|
2020-05-09 13:42:01 +03:00
|
|
|
probe_inc = u32(0x01000000)
|
2020-01-24 22:13:59 +03:00
|
|
|
)
|
|
|
|
|
2020-05-17 14:51:18 +03:00
|
|
|
// This function is intended to be fast when
|
2020-04-12 15:10:06 +03:00
|
|
|
// the strings are very likely to be equal
|
|
|
|
// TODO: add branch prediction hints
|
|
|
|
[inline]
|
2020-10-15 13:32:28 +03:00
|
|
|
fn fast_string_eq(a string, b string) bool {
|
2020-04-12 15:10:06 +03:00
|
|
|
if a.len != b.len {
|
|
|
|
return false
|
|
|
|
}
|
2020-07-20 20:06:41 +03:00
|
|
|
unsafe {
|
|
|
|
return C.memcmp(a.str, b.str, b.len) == 0
|
|
|
|
}
|
2020-04-12 15:10:06 +03:00
|
|
|
}
|
|
|
|
|
2020-03-12 14:19:13 +03:00
|
|
|
// Dynamic array with very low growth factor
|
|
|
|
struct DenseArray {
|
2020-05-04 15:56:19 +03:00
|
|
|
value_bytes int
|
2020-03-12 14:19:13 +03:00
|
|
|
mut:
|
2020-06-21 17:51:02 +03:00
|
|
|
cap u32
|
|
|
|
len u32
|
|
|
|
deletes u32
|
|
|
|
keys &string
|
|
|
|
values byteptr
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
[inline]
|
2020-08-09 12:22:11 +03:00
|
|
|
[unsafe]
|
2020-05-04 15:56:19 +03:00
|
|
|
fn new_dense_array(value_bytes int) DenseArray {
|
2020-09-14 16:20:54 +03:00
|
|
|
s8size := int(8 * sizeof(string))
|
2020-05-04 15:56:19 +03:00
|
|
|
return DenseArray{
|
|
|
|
value_bytes: value_bytes
|
|
|
|
cap: 8
|
2020-06-21 17:51:02 +03:00
|
|
|
len: 0
|
2020-05-04 15:56:19 +03:00
|
|
|
deletes: 0
|
2020-09-14 16:20:54 +03:00
|
|
|
keys: &string(malloc(s8size))
|
2020-05-04 15:56:19 +03:00
|
|
|
values: malloc(8 * value_bytes)
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-03 22:12:53 +03:00
|
|
|
[inline]
|
|
|
|
fn (d &DenseArray) key(i int) voidptr {
|
|
|
|
return unsafe {voidptr(d.keys + i)}
|
|
|
|
}
|
|
|
|
|
|
|
|
// for cgen
|
|
|
|
[inline]
|
|
|
|
fn (d &DenseArray) value(i int) voidptr {
|
|
|
|
return unsafe {voidptr(d.values + i * d.value_bytes)}
|
|
|
|
}
|
|
|
|
|
|
|
|
[inline]
|
|
|
|
fn (d &DenseArray) has_index(i int) bool {
|
|
|
|
pkey := unsafe {d.keys + i}
|
|
|
|
return pkey.str != 0
|
|
|
|
}
|
|
|
|
|
2020-03-19 08:52:34 +03:00
|
|
|
// Push element to array and return index
|
2020-04-12 15:10:06 +03:00
|
|
|
// The growth-factor is roughly 1.125 `(x + (x >> 3))`
|
2020-03-19 08:52:34 +03:00
|
|
|
[inline]
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut d DenseArray) push(key string, value voidptr) u32 {
|
2020-06-21 17:51:02 +03:00
|
|
|
if d.cap == d.len {
|
2020-05-04 15:56:19 +03:00
|
|
|
d.cap += d.cap >> 3
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
2020-12-02 16:35:11 +03:00
|
|
|
x := v_realloc(byteptr(d.keys), int(sizeof(string) * d.cap))
|
2020-07-25 19:20:47 +03:00
|
|
|
d.keys = &string(x)
|
2020-12-02 16:35:11 +03:00
|
|
|
d.values = v_realloc(byteptr(d.values), d.value_bytes * int(d.cap))
|
2020-07-15 22:56:50 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
push_index := d.len
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
2020-07-15 22:56:50 +03:00
|
|
|
d.keys[push_index] = key
|
2020-07-03 19:10:10 +03:00
|
|
|
C.memcpy(d.values + push_index * u32(d.value_bytes), value, d.value_bytes)
|
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
d.len++
|
2020-03-19 08:52:34 +03:00
|
|
|
return push_index
|
|
|
|
}
|
|
|
|
|
2020-04-22 05:00:38 +03:00
|
|
|
fn (d DenseArray) get(i int) voidptr {
|
|
|
|
$if !no_bounds_checking? {
|
2020-06-21 17:51:02 +03:00
|
|
|
if i < 0 || i >= int(d.len) {
|
|
|
|
panic('DenseArray.get: index out of range (i == $i, d.len == $d.len)')
|
2020-04-22 05:00:38 +03:00
|
|
|
}
|
|
|
|
}
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
return byteptr(d.keys) + i * int(sizeof(string))
|
|
|
|
}
|
2020-04-22 05:00:38 +03:00
|
|
|
}
|
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// Move all zeros to the end of the array and resize array
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut d DenseArray) zeros_to_end() {
|
2020-05-04 15:56:19 +03:00
|
|
|
mut tmp_value := malloc(d.value_bytes)
|
2020-03-19 08:52:34 +03:00
|
|
|
mut count := u32(0)
|
2020-11-06 17:26:59 +03:00
|
|
|
for i in 0 .. int(d.len) {
|
2020-07-15 22:56:50 +03:00
|
|
|
if unsafe {d.keys[i]}.str != 0 {
|
2020-05-04 15:56:19 +03:00
|
|
|
// swap keys
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
tmp_key := d.keys[count]
|
|
|
|
d.keys[count] = d.keys[i]
|
|
|
|
d.keys[i] = tmp_key
|
|
|
|
}
|
2020-05-04 15:56:19 +03:00
|
|
|
// swap values (TODO: optimize)
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
C.memcpy(tmp_value, d.values + count * u32(d.value_bytes), d.value_bytes)
|
|
|
|
C.memcpy(d.values + count * u32(d.value_bytes), d.values + i * d.value_bytes, d.value_bytes)
|
|
|
|
C.memcpy(d.values + i * d.value_bytes, tmp_value, d.value_bytes)
|
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
count++
|
|
|
|
}
|
|
|
|
}
|
2020-05-04 15:56:19 +03:00
|
|
|
free(tmp_value)
|
2020-03-21 15:55:07 +03:00
|
|
|
d.deletes = 0
|
2020-06-21 17:51:02 +03:00
|
|
|
d.len = count
|
2020-04-30 10:32:29 +03:00
|
|
|
d.cap = if count < 8 { u32(8) } else { count }
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
2020-12-02 16:35:11 +03:00
|
|
|
x := v_realloc(byteptr(d.keys), int(sizeof(string) * d.cap))
|
2020-07-25 19:20:47 +03:00
|
|
|
d.keys = &string(x)
|
2020-12-02 16:35:11 +03:00
|
|
|
d.values = v_realloc(byteptr(d.values), d.value_bytes * int(d.cap))
|
2020-07-15 22:56:50 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
pub struct map {
|
2020-06-25 00:31:19 +03:00
|
|
|
// Number of bytes of a value
|
2020-05-09 13:42:01 +03:00
|
|
|
value_bytes int
|
2020-03-19 08:52:34 +03:00
|
|
|
mut:
|
2020-06-25 00:31:19 +03:00
|
|
|
// Highest even index in the hashtable
|
2020-05-09 13:42:01 +03:00
|
|
|
cap u32
|
2020-03-19 08:52:34 +03:00
|
|
|
// Number of cached hashbits left for rehasing
|
2020-05-09 13:42:01 +03:00
|
|
|
cached_hashbits byte
|
2020-03-19 08:52:34 +03:00
|
|
|
// Used for right-shifting out used hashbits
|
2020-05-09 13:42:01 +03:00
|
|
|
shift byte
|
2020-03-21 15:55:07 +03:00
|
|
|
// Array storing key-values (ordered)
|
2020-05-09 13:42:01 +03:00
|
|
|
key_values DenseArray
|
2020-03-21 15:55:07 +03:00
|
|
|
// Pointer to meta-data:
|
2020-06-25 00:31:19 +03:00
|
|
|
// - Odd indices store kv_index.
|
|
|
|
// - Even indices store probe_count and hashbits.
|
2020-05-09 13:42:01 +03:00
|
|
|
metas &u32
|
2020-03-19 08:52:34 +03:00
|
|
|
// Extra metas that allows for no ranging when incrementing
|
|
|
|
// index in the hashmap
|
2020-05-09 13:42:01 +03:00
|
|
|
extra_metas u32
|
2020-03-19 08:52:34 +03:00
|
|
|
pub mut:
|
2020-04-12 15:10:06 +03:00
|
|
|
// Number of key-values currently in the hashmap
|
2020-06-21 17:51:02 +03:00
|
|
|
len int
|
2020-03-12 14:19:13 +03:00
|
|
|
}
|
|
|
|
|
2020-04-12 15:10:06 +03:00
|
|
|
fn new_map_1(value_bytes int) map {
|
2020-09-14 16:20:54 +03:00
|
|
|
metasize := int(sizeof(u32) * (init_capicity + extra_metas_inc))
|
2020-02-20 22:04:06 +03:00
|
|
|
return map{
|
2020-01-24 22:13:59 +03:00
|
|
|
value_bytes: value_bytes
|
2020-03-19 08:52:34 +03:00
|
|
|
cap: init_cap
|
2020-04-05 23:09:52 +03:00
|
|
|
cached_hashbits: max_cached_hashbits
|
2020-03-19 08:52:34 +03:00
|
|
|
shift: init_log_capicity
|
2020-05-04 15:56:19 +03:00
|
|
|
key_values: new_dense_array(value_bytes)
|
2020-09-14 16:20:54 +03:00
|
|
|
metas: &u32(vcalloc(metasize))
|
2020-03-19 08:52:34 +03:00
|
|
|
extra_metas: extra_metas_inc
|
2020-06-21 17:51:02 +03:00
|
|
|
len: 0
|
2019-06-22 21:20:28 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-15 13:32:28 +03:00
|
|
|
fn new_map_init(n int, value_bytes int, keys &string, values voidptr) map {
|
2020-04-12 15:10:06 +03:00
|
|
|
mut out := new_map_1(value_bytes)
|
2020-01-24 22:13:59 +03:00
|
|
|
for i in 0 .. n {
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
out.set(keys[i], byteptr(values) + i * value_bytes)
|
|
|
|
}
|
2019-08-03 10:44:08 +03:00
|
|
|
}
|
2020-01-24 22:13:59 +03:00
|
|
|
return out
|
2019-08-29 01:52:32 +03:00
|
|
|
}
|
2019-08-03 10:44:08 +03:00
|
|
|
|
2020-03-19 08:52:34 +03:00
|
|
|
[inline]
|
2020-04-27 14:27:33 +03:00
|
|
|
fn (m &map) key_to_index(key string) (u32,u32) {
|
2020-07-18 12:14:03 +03:00
|
|
|
hash := hash.wyhash_c(key.str, u64(key.len), 0)
|
2020-03-19 08:52:34 +03:00
|
|
|
index := hash & m.cap
|
2020-05-09 13:42:01 +03:00
|
|
|
meta := ((hash >> m.shift) & hash_mask) | probe_inc
|
2020-04-05 23:09:52 +03:00
|
|
|
return u32(index),u32(meta)
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
[inline]
|
2020-04-27 14:27:33 +03:00
|
|
|
fn (m &map) meta_less(_index u32, _metas u32) (u32,u32) {
|
2020-04-05 23:09:52 +03:00
|
|
|
mut index := _index
|
|
|
|
mut meta := _metas
|
2020-07-15 22:56:50 +03:00
|
|
|
for meta < unsafe {m.metas[index]} {
|
2020-03-19 08:52:34 +03:00
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2020-02-20 22:04:06 +03:00
|
|
|
}
|
2020-03-21 15:55:07 +03:00
|
|
|
return index,meta
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
[inline]
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut m map) meta_greater(_index u32, _metas u32, kvi u32) {
|
2020-04-05 23:09:52 +03:00
|
|
|
mut meta := _metas
|
|
|
|
mut index := _index
|
2020-03-19 08:52:34 +03:00
|
|
|
mut kv_index := kvi
|
2020-07-15 22:56:50 +03:00
|
|
|
for unsafe {m.metas[index]} != 0 {
|
|
|
|
if meta > unsafe {m.metas[index]} {
|
|
|
|
unsafe {
|
|
|
|
tmp_meta := m.metas[index]
|
|
|
|
m.metas[index] = meta
|
|
|
|
meta = tmp_meta
|
|
|
|
}
|
|
|
|
tmp_index := unsafe {m.metas[index + 1]}
|
|
|
|
unsafe {
|
|
|
|
m.metas[index + 1] = kv_index
|
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
kv_index = tmp_index
|
2020-01-24 22:13:59 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2020-02-20 22:04:06 +03:00
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
m.metas[index] = meta
|
|
|
|
m.metas[index + 1] = kv_index
|
|
|
|
}
|
2020-05-09 13:42:01 +03:00
|
|
|
probe_count := (meta >> hashbits) - 1
|
2020-05-26 18:59:52 +03:00
|
|
|
m.ensure_extra_metas(probe_count)
|
|
|
|
}
|
|
|
|
|
|
|
|
[inline]
|
|
|
|
fn (mut m map) ensure_extra_metas(probe_count u32) {
|
2020-05-09 13:42:01 +03:00
|
|
|
if (probe_count << 1) == m.extra_metas {
|
2020-03-19 08:52:34 +03:00
|
|
|
m.extra_metas += extra_metas_inc
|
|
|
|
mem_size := (m.cap + 2 + m.extra_metas)
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
2020-12-02 16:35:11 +03:00
|
|
|
x := v_realloc(byteptr(m.metas), int(sizeof(u32) * mem_size))
|
2020-07-25 19:20:47 +03:00
|
|
|
m.metas = &u32(x)
|
2020-12-02 16:35:11 +03:00
|
|
|
C.memset(m.metas + mem_size - extra_metas_inc, 0, int(sizeof(u32) * extra_metas_inc))
|
2020-07-03 19:10:10 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
// Should almost never happen
|
|
|
|
if probe_count == 252 {
|
2020-03-21 15:55:07 +03:00
|
|
|
panic('Probe overflow')
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
2020-03-19 09:05:20 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
|
2020-06-27 14:58:07 +03:00
|
|
|
// Insert new element to the map. The element is inserted if its key is
|
2020-06-25 00:31:19 +03:00
|
|
|
// not equivalent to the key of any other element already in the container.
|
|
|
|
// If the key already exists, its value is changed to the value of the new element.
|
2020-05-26 18:59:52 +03:00
|
|
|
fn (mut m map) set(k string, value voidptr) {
|
|
|
|
key := k.clone()
|
2020-06-21 17:51:02 +03:00
|
|
|
load_factor := f32(m.len << 1) / f32(m.cap)
|
2020-03-21 15:55:07 +03:00
|
|
|
if load_factor > max_load_factor {
|
2020-03-19 08:52:34 +03:00
|
|
|
m.expand()
|
2020-02-20 22:30:34 +03:00
|
|
|
}
|
2020-03-21 15:55:07 +03:00
|
|
|
mut index,mut meta := m.key_to_index(key)
|
2020-04-05 23:09:52 +03:00
|
|
|
index,meta = m.meta_less(index, meta)
|
2020-03-19 08:52:34 +03:00
|
|
|
// While we might have a match
|
2020-07-15 22:56:50 +03:00
|
|
|
for meta == unsafe {m.metas[index]} {
|
|
|
|
kv_index := unsafe {m.metas[index + 1]}
|
|
|
|
if fast_string_eq(key, unsafe {m.key_values.keys[kv_index]}) {
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
C.memcpy(m.key_values.values + kv_index * u32(m.value_bytes), value, m.value_bytes)
|
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
return
|
2020-02-20 19:58:13 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2019-12-30 22:01:24 +03:00
|
|
|
}
|
2020-05-04 15:56:19 +03:00
|
|
|
kv_index := m.key_values.push(key, value)
|
2020-04-05 23:09:52 +03:00
|
|
|
m.meta_greater(index, meta, kv_index)
|
2020-06-21 17:51:02 +03:00
|
|
|
m.len++
|
2020-02-20 19:58:13 +03:00
|
|
|
}
|
|
|
|
|
2020-03-19 08:52:34 +03:00
|
|
|
// Doubles the size of the hashmap
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut m map) expand() {
|
2020-03-19 08:52:34 +03:00
|
|
|
old_cap := m.cap
|
2020-05-09 13:42:01 +03:00
|
|
|
m.cap = ((m.cap + 2) << 1) - 2
|
2020-03-19 08:52:34 +03:00
|
|
|
// Check if any hashbits are left
|
2020-04-05 23:09:52 +03:00
|
|
|
if m.cached_hashbits == 0 {
|
|
|
|
m.shift += max_cached_hashbits
|
|
|
|
m.cached_hashbits = max_cached_hashbits
|
2020-03-21 15:55:07 +03:00
|
|
|
m.rehash()
|
2019-06-22 21:20:28 +03:00
|
|
|
}
|
2020-02-20 22:04:06 +03:00
|
|
|
else {
|
2020-03-19 08:52:34 +03:00
|
|
|
m.cached_rehash(old_cap)
|
2020-05-04 15:56:19 +03:00
|
|
|
m.cached_hashbits--
|
2019-08-29 01:52:32 +03:00
|
|
|
}
|
2020-02-20 19:58:13 +03:00
|
|
|
}
|
|
|
|
|
2020-06-27 14:58:07 +03:00
|
|
|
// A rehash is the reconstruction of the hash table:
|
|
|
|
// All the elements in the container are rearranged according
|
|
|
|
// to their hash value into the newly sized key-value container.
|
2020-06-25 00:31:19 +03:00
|
|
|
// Rehashes are performed when the load_factor is going to surpass
|
|
|
|
// the max_load_factor in an operation.
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut m map) rehash() {
|
2020-03-19 08:52:34 +03:00
|
|
|
meta_bytes := sizeof(u32) * (m.cap + 2 + m.extra_metas)
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
2020-12-02 16:35:11 +03:00
|
|
|
x := v_realloc(byteptr(m.metas), int(meta_bytes))
|
2020-07-25 19:20:47 +03:00
|
|
|
m.metas = &u32(x)
|
2020-07-15 22:56:50 +03:00
|
|
|
C.memset(m.metas, 0, meta_bytes)
|
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
for i := u32(0); i < m.key_values.len; i++ {
|
2020-07-15 22:56:50 +03:00
|
|
|
if unsafe {m.key_values.keys[i]}.str == 0 {
|
2020-03-19 08:52:34 +03:00
|
|
|
continue
|
2020-03-16 15:01:31 +03:00
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
mut index,mut meta := m.key_to_index(unsafe {m.key_values.keys[i]})
|
2020-04-05 23:09:52 +03:00
|
|
|
index,meta = m.meta_less(index, meta)
|
|
|
|
m.meta_greater(index, meta, i)
|
2020-03-16 15:01:31 +03:00
|
|
|
}
|
2019-08-29 01:52:32 +03:00
|
|
|
}
|
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// This method works like rehash. However, instead of rehashing the
|
2020-06-27 14:58:07 +03:00
|
|
|
// key completely, it uses the bits cached in `metas`.
|
2020-05-17 14:51:18 +03:00
|
|
|
fn (mut m map) cached_rehash(old_cap u32) {
|
2020-04-05 23:09:52 +03:00
|
|
|
old_metas := m.metas
|
2020-09-14 16:20:54 +03:00
|
|
|
metasize := int(sizeof(u32) * (m.cap + 2 + m.extra_metas))
|
|
|
|
m.metas = &u32(vcalloc(metasize))
|
2020-03-19 08:52:34 +03:00
|
|
|
old_extra_metas := m.extra_metas
|
2020-03-21 15:55:07 +03:00
|
|
|
for i := u32(0); i <= old_cap + old_extra_metas; i += 2 {
|
2020-07-15 22:56:50 +03:00
|
|
|
if unsafe {old_metas[i]} == 0 {
|
2020-03-19 08:52:34 +03:00
|
|
|
continue
|
2020-03-16 15:01:31 +03:00
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
old_meta := unsafe {old_metas[i]}
|
2020-05-09 13:42:01 +03:00
|
|
|
old_probe_count := ((old_meta >> hashbits) - 1) << 1
|
|
|
|
old_index := (i - old_probe_count) & (m.cap >> 1)
|
|
|
|
mut index := (old_index | (old_meta << m.shift)) & m.cap
|
2020-03-19 08:52:34 +03:00
|
|
|
mut meta := (old_meta & hash_mask) | probe_inc
|
2020-04-05 23:09:52 +03:00
|
|
|
index,meta = m.meta_less(index, meta)
|
2020-07-15 22:56:50 +03:00
|
|
|
kv_index := unsafe {old_metas[i + 1]}
|
2020-04-05 23:09:52 +03:00
|
|
|
m.meta_greater(index, meta, kv_index)
|
2019-10-30 20:19:59 +03:00
|
|
|
}
|
2020-02-20 22:04:06 +03:00
|
|
|
unsafe{
|
2020-04-05 23:09:52 +03:00
|
|
|
free(old_metas)
|
2020-01-24 22:13:59 +03:00
|
|
|
}
|
2019-12-30 22:01:24 +03:00
|
|
|
}
|
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// This method is used for assignment operators. If the argument-key
|
|
|
|
// does not exist in the map, it's added to the map along with the zero/dafault value.
|
2020-06-27 14:58:07 +03:00
|
|
|
// If the key exists, its respective value is returned.
|
2020-06-25 00:31:19 +03:00
|
|
|
fn (mut m map) get_and_set(key string, zero voidptr) voidptr {
|
2020-06-24 21:41:26 +03:00
|
|
|
for {
|
|
|
|
mut index,mut meta := m.key_to_index(key)
|
|
|
|
for {
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta == unsafe {m.metas[index]} {
|
|
|
|
kv_index := unsafe {m.metas[index + 1]}
|
|
|
|
if fast_string_eq(key, unsafe {m.key_values.keys[kv_index]}) {
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
return voidptr(m.key_values.values + kv_index * u32(m.value_bytes))
|
|
|
|
}
|
2020-06-24 21:41:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta > unsafe {m.metas[index]} { break }
|
2020-06-24 21:41:26 +03:00
|
|
|
}
|
2020-06-27 14:58:07 +03:00
|
|
|
// Key not found, insert key with zero-value
|
2020-06-24 21:41:26 +03:00
|
|
|
m.set(key, zero)
|
|
|
|
}
|
2020-12-02 16:35:11 +03:00
|
|
|
assert false
|
|
|
|
return voidptr(0)
|
2020-06-24 21:41:26 +03:00
|
|
|
}
|
2020-06-25 00:31:19 +03:00
|
|
|
|
2020-06-27 14:58:07 +03:00
|
|
|
// If `key` matches the key of an element in the container,
|
2020-06-25 00:31:19 +03:00
|
|
|
// the method returns a reference to its mapped value.
|
|
|
|
// If not, a zero/default value is returned.
|
|
|
|
fn (m map) get(key string, zero voidptr) voidptr {
|
|
|
|
mut index,mut meta := m.key_to_index(key)
|
|
|
|
for {
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta == unsafe {m.metas[index]} {
|
|
|
|
kv_index := unsafe {m.metas[index + 1]}
|
|
|
|
if fast_string_eq(key, unsafe {m.key_values.keys[kv_index]}) {
|
2020-07-03 19:10:10 +03:00
|
|
|
unsafe {
|
|
|
|
return voidptr(m.key_values.values + kv_index * u32(m.value_bytes))
|
|
|
|
}
|
2020-06-25 00:31:19 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta > unsafe {m.metas[index]} { break }
|
2020-06-25 00:31:19 +03:00
|
|
|
}
|
|
|
|
return zero
|
|
|
|
}
|
2020-06-24 21:41:26 +03:00
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// Checks whether a particular key exists in the map.
|
2020-02-20 22:04:06 +03:00
|
|
|
fn (m map) exists(key string) bool {
|
2020-03-21 15:55:07 +03:00
|
|
|
mut index,mut meta := m.key_to_index(key)
|
2020-05-09 13:42:01 +03:00
|
|
|
for {
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta == unsafe {m.metas[index]} {
|
|
|
|
kv_index := unsafe {m.metas[index + 1]}
|
|
|
|
if fast_string_eq(key, unsafe {m.key_values.keys[kv_index]}) {
|
2020-05-09 13:42:01 +03:00
|
|
|
return true
|
|
|
|
}
|
2020-02-20 19:58:13 +03:00
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
2020-07-15 22:56:50 +03:00
|
|
|
if meta > unsafe {m.metas[index]} { break }
|
2020-02-20 19:58:13 +03:00
|
|
|
}
|
2020-02-20 22:04:06 +03:00
|
|
|
return false
|
2019-12-30 08:57:56 +03:00
|
|
|
}
|
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// Removes the mapping of a particular key from the map.
|
2020-05-17 14:51:18 +03:00
|
|
|
pub fn (mut m map) delete(key string) {
|
2020-03-21 15:55:07 +03:00
|
|
|
mut index,mut meta := m.key_to_index(key)
|
2020-04-05 23:09:52 +03:00
|
|
|
index,meta = m.meta_less(index, meta)
|
2020-03-19 08:52:34 +03:00
|
|
|
// Perform backwards shifting
|
2020-07-15 22:56:50 +03:00
|
|
|
for meta == unsafe {m.metas[index]} {
|
|
|
|
kv_index := unsafe {m.metas[index + 1]}
|
|
|
|
if fast_string_eq(key, unsafe {m.key_values.keys[kv_index]}) {
|
|
|
|
for (unsafe {m.metas[index + 2]} >> hashbits) > 1 {
|
|
|
|
unsafe {
|
|
|
|
m.metas[index] = m.metas[index + 2] - probe_inc
|
|
|
|
m.metas[index + 1] = m.metas[index + 3]
|
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
index += 2
|
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
m.len--
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
m.metas[index] = 0
|
|
|
|
}
|
2020-03-19 08:52:34 +03:00
|
|
|
m.key_values.deletes++
|
2020-05-26 18:59:52 +03:00
|
|
|
// Mark key as deleted
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
m.key_values.keys[kv_index].free()
|
|
|
|
C.memset(&m.key_values.keys[kv_index], 0, sizeof(string))
|
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
if m.key_values.len <= 32 {
|
2020-03-21 15:55:07 +03:00
|
|
|
return
|
|
|
|
}
|
2020-04-05 23:09:52 +03:00
|
|
|
// Clean up key_values if too many have been deleted
|
2020-06-21 17:51:02 +03:00
|
|
|
if m.key_values.deletes >= (m.key_values.len >> 1) {
|
2020-03-19 08:52:34 +03:00
|
|
|
m.key_values.zeros_to_end()
|
|
|
|
m.rehash()
|
2020-04-05 23:09:52 +03:00
|
|
|
m.key_values.deletes = 0
|
2020-03-19 08:52:34 +03:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
index += 2
|
|
|
|
meta += probe_inc
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 00:31:19 +03:00
|
|
|
// Returns all keys in the map.
|
2020-04-12 15:10:06 +03:00
|
|
|
// TODO: add optimization in case of no deletes
|
2020-01-24 22:13:59 +03:00
|
|
|
pub fn (m &map) keys() []string {
|
2020-06-27 18:00:27 +03:00
|
|
|
mut keys := []string{ len:m.len }
|
2020-02-20 22:04:06 +03:00
|
|
|
mut j := 0
|
2020-06-21 17:51:02 +03:00
|
|
|
for i := u32(0); i < m.key_values.len; i++ {
|
2020-07-15 22:56:50 +03:00
|
|
|
if unsafe {m.key_values.keys[i]}.str == 0 {
|
2020-03-19 08:52:34 +03:00
|
|
|
continue
|
2020-02-20 22:04:06 +03:00
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
keys[j] = unsafe {m.key_values.keys[i]}.clone()
|
2020-03-19 08:52:34 +03:00
|
|
|
j++
|
2020-02-20 22:04:06 +03:00
|
|
|
}
|
2020-01-24 22:13:59 +03:00
|
|
|
return keys
|
2019-12-30 22:01:24 +03:00
|
|
|
}
|
|
|
|
|
2020-08-09 12:22:11 +03:00
|
|
|
[unsafe]
|
2020-05-26 02:52:06 +03:00
|
|
|
pub fn (d DenseArray) clone() DenseArray {
|
2020-09-14 16:20:54 +03:00
|
|
|
ksize := int(d.cap * sizeof(string))
|
|
|
|
vsize := int(d.cap * u32(d.value_bytes))
|
2020-05-26 02:52:06 +03:00
|
|
|
res := DenseArray {
|
|
|
|
value_bytes: d.value_bytes
|
|
|
|
cap: d.cap
|
2020-09-14 16:20:54 +03:00
|
|
|
len: d.len
|
2020-05-26 02:52:06 +03:00
|
|
|
deletes: d.deletes
|
2020-09-14 16:20:54 +03:00
|
|
|
keys: unsafe {&string(malloc(ksize))}
|
|
|
|
values: unsafe {byteptr(malloc(vsize))}
|
2020-07-20 20:06:41 +03:00
|
|
|
}
|
|
|
|
unsafe {
|
2020-09-14 16:20:54 +03:00
|
|
|
C.memcpy(res.keys, d.keys, ksize)
|
|
|
|
C.memcpy(res.values, d.values, vsize)
|
2020-05-26 02:52:06 +03:00
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
2020-08-09 12:22:11 +03:00
|
|
|
[unsafe]
|
2020-05-26 02:52:06 +03:00
|
|
|
pub fn (m map) clone() map {
|
2020-09-14 16:20:54 +03:00
|
|
|
metasize := int(sizeof(u32) * (m.cap + 2 + m.extra_metas))
|
2020-05-26 02:52:06 +03:00
|
|
|
res := map{
|
|
|
|
value_bytes: m.value_bytes
|
|
|
|
cap: m.cap
|
|
|
|
cached_hashbits: m.cached_hashbits
|
|
|
|
shift: m.shift
|
2020-07-17 20:14:12 +03:00
|
|
|
key_values: unsafe {m.key_values.clone()}
|
2020-09-14 16:20:54 +03:00
|
|
|
metas: &u32(malloc(metasize))
|
2020-05-26 02:52:06 +03:00
|
|
|
extra_metas: m.extra_metas
|
2020-06-21 17:51:02 +03:00
|
|
|
len: m.len
|
2020-05-26 02:52:06 +03:00
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
2020-09-14 16:20:54 +03:00
|
|
|
C.memcpy(res.metas, m.metas, metasize)
|
2020-07-15 22:56:50 +03:00
|
|
|
}
|
2020-05-26 02:52:06 +03:00
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
2020-08-09 12:22:11 +03:00
|
|
|
[unsafe]
|
2020-05-06 19:03:44 +03:00
|
|
|
pub fn (m &map) free() {
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
free(m.metas)
|
|
|
|
}
|
2020-06-21 17:51:02 +03:00
|
|
|
for i := u32(0); i < m.key_values.len; i++ {
|
2020-07-15 22:56:50 +03:00
|
|
|
if unsafe {m.key_values.keys[i]}.str == 0 {
|
2020-04-06 00:31:53 +03:00
|
|
|
continue
|
|
|
|
}
|
2020-07-15 22:56:50 +03:00
|
|
|
unsafe {
|
|
|
|
m.key_values.keys[i].free()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
unsafe {
|
|
|
|
free(m.key_values.keys)
|
|
|
|
free(m.key_values.values)
|
2020-01-24 22:13:59 +03:00
|
|
|
}
|
2019-07-23 23:57:06 +03:00
|
|
|
}
|
|
|
|
|
2020-08-14 22:01:43 +03:00
|
|
|
/*
|
2019-06-27 14:14:59 +03:00
|
|
|
pub fn (m map_string) str() string {
|
2020-06-21 17:51:02 +03:00
|
|
|
if m.len == 0 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return '{}'
|
|
|
|
}
|
2019-08-05 06:54:16 +03:00
|
|
|
mut sb := strings.new_builder(50)
|
2019-08-29 01:52:32 +03:00
|
|
|
sb.writeln('{')
|
2020-03-21 15:55:07 +03:00
|
|
|
for key, val in m {
|
2019-08-29 01:52:32 +03:00
|
|
|
sb.writeln(' "$key" => "$val"')
|
2019-08-05 05:34:12 +03:00
|
|
|
}
|
2019-08-29 01:52:32 +03:00
|
|
|
sb.writeln('}')
|
|
|
|
return sb.str()
|
2020-03-19 09:05:20 +03:00
|
|
|
}
|
2020-08-14 22:01:43 +03:00
|
|
|
*/
|