|
|
|
|
@ -4,10 +4,12 @@ |
|
|
|
|
** Implementation is heavily inspired by Lua's ltable.c. |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
#include "upb/table.int.h" |
|
|
|
|
|
|
|
|
|
#include <string.h> |
|
|
|
|
|
|
|
|
|
#include "third_party/wyhash/wyhash.h" |
|
|
|
|
#include "upb/table.int.h" |
|
|
|
|
|
|
|
|
|
/* Must be last. */ |
|
|
|
|
#include "upb/port_def.inc" |
|
|
|
|
|
|
|
|
|
#define UPB_MAXARRSIZE 16 /* 64k. */ |
|
|
|
|
@ -87,11 +89,7 @@ static upb_tabent *mutable_entries(upb_table *t) { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static bool isfull(upb_table *t) { |
|
|
|
|
if (upb_table_size(t) == 0) { |
|
|
|
|
return true; |
|
|
|
|
} else { |
|
|
|
|
return ((double)(t->count + 1) / upb_table_size(t)) > MAX_LOAD; |
|
|
|
|
} |
|
|
|
|
return t->count == t->max_count; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static bool init(upb_table *t, uint8_t size_lg2, upb_alloc *a) { |
|
|
|
|
@ -100,6 +98,7 @@ static bool init(upb_table *t, uint8_t size_lg2, upb_alloc *a) { |
|
|
|
|
t->count = 0; |
|
|
|
|
t->size_lg2 = size_lg2; |
|
|
|
|
t->mask = upb_table_size(t) ? upb_table_size(t) - 1 : 0; |
|
|
|
|
t->max_count = upb_table_size(t) * MAX_LOAD; |
|
|
|
|
bytes = upb_table_size(t) * sizeof(upb_tabent); |
|
|
|
|
if (bytes > 0) { |
|
|
|
|
t->entries = upb_malloc(a, bytes); |
|
|
|
|
@ -115,9 +114,17 @@ static void uninit(upb_table *t, upb_alloc *a) { |
|
|
|
|
upb_free(a, mutable_entries(t)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_tabent *emptyent(upb_table *t) { |
|
|
|
|
upb_tabent *e = mutable_entries(t) + upb_table_size(t); |
|
|
|
|
while (1) { if (upb_tabent_isempty(--e)) return e; UPB_ASSERT(e > t->entries); } |
|
|
|
|
static upb_tabent *emptyent(upb_table *t, upb_tabent *e) { |
|
|
|
|
upb_tabent *begin = mutable_entries(t); |
|
|
|
|
upb_tabent *end = begin + upb_table_size(t); |
|
|
|
|
for (e = e + 1; e < end; e++) { |
|
|
|
|
if (upb_tabent_isempty(e)) return e; |
|
|
|
|
} |
|
|
|
|
for (e = begin; e < end; e++) { |
|
|
|
|
if (upb_tabent_isempty(e)) return e; |
|
|
|
|
} |
|
|
|
|
UPB_ASSERT(false); |
|
|
|
|
return NULL; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_tabent *getentry_mutable(upb_table *t, uint32_t hash) { |
|
|
|
|
@ -173,7 +180,7 @@ static void insert(upb_table *t, lookupkey_t key, upb_tabkey tabkey, |
|
|
|
|
our_e->next = NULL; |
|
|
|
|
} else { |
|
|
|
|
/* Collision. */ |
|
|
|
|
upb_tabent *new_e = emptyent(t); |
|
|
|
|
upb_tabent *new_e = emptyent(t, mainpos_e); |
|
|
|
|
/* Head of collider's chain. */ |
|
|
|
|
upb_tabent *chain = getentry_mutable(t, hashfunc(mainpos_e->key)); |
|
|
|
|
if (chain == mainpos_e) { |
|
|
|
|
@ -268,10 +275,14 @@ static upb_tabkey strcopy(lookupkey_t k2, upb_alloc *a) { |
|
|
|
|
return (uintptr_t)str; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static uint32_t table_hash(const char *p, size_t n) { |
|
|
|
|
return wyhash(p, n, 0, _wyp); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static uint32_t strhash(upb_tabkey key) { |
|
|
|
|
uint32_t len; |
|
|
|
|
char *str = upb_tabstr(key, &len); |
|
|
|
|
return upb_murmur_hash2(str, len, 0); |
|
|
|
|
return table_hash(str, len); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static bool streql(upb_tabkey k1, lookupkey_t k2) { |
|
|
|
|
@ -280,9 +291,15 @@ static bool streql(upb_tabkey k1, lookupkey_t k2) { |
|
|
|
|
return len == k2.str.len && (len == 0 || memcmp(str, k2.str.str, len) == 0); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool upb_strtable_init2(upb_strtable *t, upb_ctype_t ctype, upb_alloc *a) { |
|
|
|
|
bool upb_strtable_init2(upb_strtable *t, upb_ctype_t ctype, |
|
|
|
|
size_t expected_size, upb_alloc *a) { |
|
|
|
|
UPB_UNUSED(ctype); /* TODO(haberman): rm */ |
|
|
|
|
return init(&t->t, 2, a); |
|
|
|
|
size_t need_entries = (expected_size + 1) / MAX_LOAD; |
|
|
|
|
int size_lg2 = 2; |
|
|
|
|
while (1 << size_lg2 < need_entries) { |
|
|
|
|
size_lg2++; |
|
|
|
|
} |
|
|
|
|
return init(&t->t, size_lg2, a); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void upb_strtable_clear(upb_strtable *t) { |
|
|
|
|
@ -333,20 +350,20 @@ bool upb_strtable_insert3(upb_strtable *t, const char *k, size_t len, |
|
|
|
|
tabkey = strcopy(key, a); |
|
|
|
|
if (tabkey == 0) return false; |
|
|
|
|
|
|
|
|
|
hash = upb_murmur_hash2(key.str.str, key.str.len, 0); |
|
|
|
|
hash = table_hash(key.str.str, key.str.len); |
|
|
|
|
insert(&t->t, key, tabkey, v, hash, &strhash, &streql); |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool upb_strtable_lookup2(const upb_strtable *t, const char *key, size_t len, |
|
|
|
|
upb_value *v) { |
|
|
|
|
uint32_t hash = upb_murmur_hash2(key, len, 0); |
|
|
|
|
uint32_t hash = table_hash(key, len); |
|
|
|
|
return lookup(&t->t, strkey2(key, len), v, hash, &streql); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool upb_strtable_remove3(upb_strtable *t, const char *key, size_t len, |
|
|
|
|
upb_value *val, upb_alloc *alloc) { |
|
|
|
|
uint32_t hash = upb_murmur_hash2(key, len, 0); |
|
|
|
|
uint32_t hash = table_hash(key, len); |
|
|
|
|
upb_tabkey tabkey; |
|
|
|
|
if (rm(&t->t, strkey2(key, len), val, &tabkey, hash, &streql)) { |
|
|
|
|
if (alloc) { |
|
|
|
|
@ -699,182 +716,3 @@ bool upb_inttable_iter_isequal(const upb_inttable_iter *i1, |
|
|
|
|
return i1->t == i2->t && i1->index == i2->index && |
|
|
|
|
i1->array_part == i2->array_part; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#if defined(UPB_UNALIGNED_READS_OK) || defined(__s390x__) |
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
|
|
|
* MurmurHash2, by Austin Appleby (released as public domain). |
|
|
|
|
* Reformatted and C99-ified by Joshua Haberman. |
|
|
|
|
* Note - This code makes a few assumptions about how your machine behaves - |
|
|
|
|
* 1. We can read a 4-byte value from any address without crashing |
|
|
|
|
* 2. sizeof(int) == 4 (in upb this limitation is removed by using uint32_t |
|
|
|
|
* And it has a few limitations - |
|
|
|
|
* 1. It will not work incrementally. |
|
|
|
|
* 2. It will not produce the same results on little-endian and big-endian |
|
|
|
|
* machines. */ |
|
|
|
|
uint32_t upb_murmur_hash2(const void *key, size_t len, uint32_t seed) { |
|
|
|
|
/* 'm' and 'r' are mixing constants generated offline.
|
|
|
|
|
* They're not really 'magic', they just happen to work well. */ |
|
|
|
|
const uint32_t m = 0x5bd1e995; |
|
|
|
|
const int32_t r = 24; |
|
|
|
|
|
|
|
|
|
/* Initialize the hash to a 'random' value */ |
|
|
|
|
uint32_t h = seed ^ len; |
|
|
|
|
|
|
|
|
|
/* Mix 4 bytes at a time into the hash */ |
|
|
|
|
const uint8_t * data = (const uint8_t *)key; |
|
|
|
|
while(len >= 4) { |
|
|
|
|
uint32_t k; |
|
|
|
|
memcpy(&k, data, sizeof(k)); |
|
|
|
|
|
|
|
|
|
k *= m; |
|
|
|
|
k ^= k >> r; |
|
|
|
|
k *= m; |
|
|
|
|
|
|
|
|
|
h *= m; |
|
|
|
|
h ^= k; |
|
|
|
|
|
|
|
|
|
data += 4; |
|
|
|
|
len -= 4; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Handle the last few bytes of the input array */ |
|
|
|
|
switch(len) { |
|
|
|
|
case 3: h ^= data[2] << 16; |
|
|
|
|
case 2: h ^= data[1] << 8; |
|
|
|
|
case 1: h ^= data[0]; h *= m; |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
/* Do a few final mixes of the hash to ensure the last few
|
|
|
|
|
* bytes are well-incorporated. */ |
|
|
|
|
h ^= h >> 13; |
|
|
|
|
h *= m; |
|
|
|
|
h ^= h >> 15; |
|
|
|
|
|
|
|
|
|
return h; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#else /* !UPB_UNALIGNED_READS_OK */ |
|
|
|
|
|
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
|
|
|
* MurmurHashAligned2, by Austin Appleby |
|
|
|
|
* Same algorithm as MurmurHash2, but only does aligned reads - should be safer |
|
|
|
|
* on certain platforms. |
|
|
|
|
* Performance will be lower than MurmurHash2 */ |
|
|
|
|
|
|
|
|
|
#define MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; } |
|
|
|
|
|
|
|
|
|
uint32_t upb_murmur_hash2(const void * key, size_t len, uint32_t seed) { |
|
|
|
|
const uint32_t m = 0x5bd1e995; |
|
|
|
|
const int32_t r = 24; |
|
|
|
|
const uint8_t * data = (const uint8_t *)key; |
|
|
|
|
uint32_t h = (uint32_t)(seed ^ len); |
|
|
|
|
uint8_t align = (uintptr_t)data & 3; |
|
|
|
|
|
|
|
|
|
if(align && (len >= 4)) { |
|
|
|
|
/* Pre-load the temp registers */ |
|
|
|
|
uint32_t t = 0, d = 0; |
|
|
|
|
int32_t sl; |
|
|
|
|
int32_t sr; |
|
|
|
|
|
|
|
|
|
switch(align) { |
|
|
|
|
case 1: t |= data[2] << 16; /* fallthrough */ |
|
|
|
|
case 2: t |= data[1] << 8; /* fallthrough */ |
|
|
|
|
case 3: t |= data[0]; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
t <<= (8 * align); |
|
|
|
|
|
|
|
|
|
data += 4-align; |
|
|
|
|
len -= 4-align; |
|
|
|
|
|
|
|
|
|
sl = 8 * (4-align); |
|
|
|
|
sr = 8 * align; |
|
|
|
|
|
|
|
|
|
/* Mix */ |
|
|
|
|
|
|
|
|
|
while(len >= 4) { |
|
|
|
|
uint32_t k; |
|
|
|
|
|
|
|
|
|
d = *(uint32_t *)data; |
|
|
|
|
t = (t >> sr) | (d << sl); |
|
|
|
|
|
|
|
|
|
k = t; |
|
|
|
|
|
|
|
|
|
MIX(h,k,m); |
|
|
|
|
|
|
|
|
|
t = d; |
|
|
|
|
|
|
|
|
|
data += 4; |
|
|
|
|
len -= 4; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* Handle leftover data in temp registers */ |
|
|
|
|
|
|
|
|
|
d = 0; |
|
|
|
|
|
|
|
|
|
if(len >= align) { |
|
|
|
|
uint32_t k; |
|
|
|
|
|
|
|
|
|
switch(align) { |
|
|
|
|
case 3: d |= data[2] << 16; /* fallthrough */ |
|
|
|
|
case 2: d |= data[1] << 8; /* fallthrough */ |
|
|
|
|
case 1: d |= data[0]; /* fallthrough */ |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
k = (t >> sr) | (d << sl); |
|
|
|
|
MIX(h,k,m); |
|
|
|
|
|
|
|
|
|
data += align; |
|
|
|
|
len -= align; |
|
|
|
|
|
|
|
|
|
/* ----------
|
|
|
|
|
* Handle tail bytes */ |
|
|
|
|
|
|
|
|
|
switch(len) { |
|
|
|
|
case 3: h ^= data[2] << 16; /* fallthrough */ |
|
|
|
|
case 2: h ^= data[1] << 8; /* fallthrough */ |
|
|
|
|
case 1: h ^= data[0]; h *= m; /* fallthrough */ |
|
|
|
|
}; |
|
|
|
|
} else { |
|
|
|
|
switch(len) { |
|
|
|
|
case 3: d |= data[2] << 16; /* fallthrough */ |
|
|
|
|
case 2: d |= data[1] << 8; /* fallthrough */ |
|
|
|
|
case 1: d |= data[0]; /* fallthrough */ |
|
|
|
|
case 0: h ^= (t >> sr) | (d << sl); h *= m; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
h ^= h >> 13; |
|
|
|
|
h *= m; |
|
|
|
|
h ^= h >> 15; |
|
|
|
|
|
|
|
|
|
return h; |
|
|
|
|
} else { |
|
|
|
|
while(len >= 4) { |
|
|
|
|
uint32_t k = *(uint32_t *)data; |
|
|
|
|
|
|
|
|
|
MIX(h,k,m); |
|
|
|
|
|
|
|
|
|
data += 4; |
|
|
|
|
len -= 4; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ----------
|
|
|
|
|
* Handle tail bytes */ |
|
|
|
|
|
|
|
|
|
switch(len) { |
|
|
|
|
case 3: h ^= data[2] << 16; /* fallthrough */ |
|
|
|
|
case 2: h ^= data[1] << 8; /* fallthrough */ |
|
|
|
|
case 1: h ^= data[0]; h *= m; |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
h ^= h >> 13; |
|
|
|
|
h *= m; |
|
|
|
|
h ^= h >> 15; |
|
|
|
|
|
|
|
|
|
return h; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
#undef MIX |
|
|
|
|
|
|
|
|
|
#endif /* UPB_UNALIGNED_READS_OK */ |
|
|
|
|
|
Joshua Haberman
4 years ago