* Copyright 2008, Axel Dörfler. All Rights Reserved.
* Copyright 2007, Hugo Santos. All Rights Reserved.
*
* Distributed under the terms of the MIT License.
*/
#ifndef HASHED_OBJECT_CACHE_H
#define HASHED_OBJECT_CACHE_H
#include <util/OpenHashTable.h>
#include "ObjectCache.h"
#include "slab_private.h"
struct HashedSlab : slab {
HashedSlab* hash_next;
};
struct HashedObjectCache final : ObjectCache {
HashedObjectCache();
static HashedObjectCache* Create(const char* name, size_t object_size,
size_t alignment, size_t maximum,
size_t magazineCapacity,
size_t maxMagazineCount,
uint32 flags, void* cookie,
object_cache_constructor constructor,
object_cache_destructor destructor,
object_cache_reclaimer reclaimer);
virtual void Delete();
virtual slab* CreateSlab(uint32 flags);
virtual void ReturnSlab(slab* slab, uint32 flags);
virtual slab* ObjectSlab(void* object) const;
private:
struct Definition {
typedef HashedObjectCache ParentType;
typedef const void* KeyType;
typedef HashedSlab ValueType;
Definition(HashedObjectCache* parent)
:
parent(parent)
{
}
Definition(const Definition& definition)
:
parent(definition.parent)
{
}
size_t HashKey(const void* key) const
{
return (addr_t)::lower_boundary(key, parent->slab_size)
>> parent->lower_boundary;
}
size_t Hash(HashedSlab* value) const
{
return HashKey(value->pages);
}
bool Compare(const void* key, HashedSlab* value) const
{
return value->pages == key;
}
HashedSlab*& GetLink(HashedSlab* value) const
{
return value->hash_next;
}
HashedObjectCache* parent;
};
struct InternalAllocator {
void* Allocate(size_t size) const
{
return slab_internal_alloc(size, 0);
}
void Free(void* memory) const
{
slab_internal_free(memory, 0);
}
};
typedef BOpenHashTable<Definition, false, false,
InternalAllocator> HashTable;
friend struct Definition;
private:
void _ResizeHashTableIfNeeded(uint32 flags);
private:
HashTable hash_table;
size_t lower_boundary;
};
#endif
