#include "config.h"
#include "util/storage/slabhash.h"
struct slabhash* slabhash_create(size_t numtables, size_t start_size,
size_t maxmem, lruhash_sizefunc_t sizefunc,
lruhash_compfunc_t compfunc, lruhash_delkeyfunc_t delkeyfunc,
lruhash_deldatafunc_t deldatafunc, void* arg)
{
size_t i;
struct slabhash* sl = (struct slabhash*)calloc(1,
sizeof(struct slabhash));
if(!sl) return NULL;
sl->size = numtables;
log_assert(sl->size > 0);
sl->array = (struct lruhash**)calloc(sl->size, sizeof(struct lruhash*));
if(!sl->array) {
free(sl);
return NULL;
}
sl->mask = (uint32_t)(sl->size - 1);
if(sl->mask == 0) {
sl->shift = 0;
} else {
log_assert( (sl->size & sl->mask) == 0
);
sl->shift = 0;
while(!(sl->mask & 0x80000000)) {
sl->mask <<= 1;
sl->shift ++;
}
}
for(i=0; i<sl->size; i++) {
sl->array[i] = lruhash_create(start_size, maxmem / sl->size,
sizefunc, compfunc, delkeyfunc, deldatafunc, arg);
if(!sl->array[i]) {
slabhash_delete(sl);
return NULL;
}
}
return sl;
}
void slabhash_delete(struct slabhash* sl)
{
if(!sl)
return;
if(sl->array) {
size_t i;
for(i=0; i<sl->size; i++)
lruhash_delete(sl->array[i]);
free(sl->array);
}
free(sl);
}
void slabhash_clear(struct slabhash* sl)
{
size_t i;
if(!sl)
return;
for(i=0; i<sl->size; i++)
lruhash_clear(sl->array[i]);
}
static unsigned int
slab_idx(struct slabhash* sl, hashvalue_t hash)
{
return ((hash & sl->mask) >> sl->shift);
}
void slabhash_insert(struct slabhash* sl, hashvalue_t hash,
struct lruhash_entry* entry, void* data, void* arg)
{
lruhash_insert(sl->array[slab_idx(sl, hash)], hash, entry, data, arg);
}
struct lruhash_entry* slabhash_lookup(struct slabhash* sl,
hashvalue_t hash, void* key, int wr)
{
return lruhash_lookup(sl->array[slab_idx(sl, hash)], hash, key, wr);
}
void slabhash_remove(struct slabhash* sl, hashvalue_t hash, void* key)
{
lruhash_remove(sl->array[slab_idx(sl, hash)], hash, key);
}
void slabhash_status(struct slabhash* sl, const char* id, int extended)
{
size_t i;
char num[17];
log_info("Slabhash %s: %u tables mask=%x shift=%d",
id, (unsigned)sl->size, (unsigned)sl->mask, sl->shift);
for(i=0; i<sl->size; i++) {
snprintf(num, sizeof(num), "table %u", (unsigned)i);
lruhash_status(sl->array[i], num, extended);
}
}
size_t slabhash_get_size(struct slabhash* sl)
{
size_t i, total = 0;
for(i=0; i<sl->size; i++) {
lock_quick_lock(&sl->array[i]->lock);
total += sl->array[i]->space_max;
lock_quick_unlock(&sl->array[i]->lock);
}
return total;
}
size_t slabhash_get_mem(struct slabhash* sl)
{
size_t i, total = sizeof(*sl);
total += sizeof(struct lruhash*)*sl->size;
for(i=0; i<sl->size; i++) {
total += lruhash_get_mem(sl->array[i]);
}
return total;
}
struct lruhash* slabhash_gettable(struct slabhash* sl, hashvalue_t hash)
{
return sl->array[slab_idx(sl, hash)];
}
static void delkey(struct slabhash_testkey* k) {
lock_rw_destroy(&k->entry.lock); free(k);}
static void deldata(struct slabhash_testdata* d) {free(d);}
size_t test_slabhash_sizefunc(void* ATTR_UNUSED(key), void* ATTR_UNUSED(data))
{
return sizeof(struct slabhash_testkey) +
sizeof(struct slabhash_testdata);
}
int test_slabhash_compfunc(void* key1, void* key2)
{
struct slabhash_testkey* k1 = (struct slabhash_testkey*)key1;
struct slabhash_testkey* k2 = (struct slabhash_testkey*)key2;
if(k1->id == k2->id)
return 0;
if(k1->id > k2->id)
return 1;
return -1;
}
void test_slabhash_delkey(void* key, void* ATTR_UNUSED(arg))
{
delkey((struct slabhash_testkey*)key);
}
void test_slabhash_deldata(void* data, void* ATTR_UNUSED(arg))
{
deldata((struct slabhash_testdata*)data);
}
void slabhash_setmarkdel(struct slabhash* sl, lruhash_markdelfunc_t md)
{
size_t i;
for(i=0; i<sl->size; i++) {
lruhash_setmarkdel(sl->array[i], md);
}
}
void slabhash_traverse(struct slabhash* sh, int wr,
void (*func)(struct lruhash_entry*, void*), void* arg)
{
size_t i;
for(i=0; i<sh->size; i++)
lruhash_traverse(sh->array[i], wr, func, arg);
}
size_t count_slabhash_entries(struct slabhash* sh)
{
size_t slab, cnt = 0;
for(slab=0; slab<sh->size; slab++) {
lock_quick_lock(&sh->array[slab]->lock);
cnt += sh->array[slab]->num;
lock_quick_unlock(&sh->array[slab]->lock);
}
return cnt;
}