400行代码实现本地Key-Value缓存(二)
V &value, K &recyKey, V &recyValue, bool &recycled)
{
AutoLock autoLock(m_MutexLock);
recycled = false;
if(Exist(key)) return LruSet(key, value);
else return LruAdd(key, value, recyKey, recyValue, recycled);
}
void Clear()
{
AutoLock autoLock(m_MutexLock);
m_HeadAddr->m_FreeBase = 0;
m_HeadAddr->m_RecycleHead = 0;
m_HeadAddr->m_UsedCount = 0;
for(uint32_t i = 0; i < m_HeadAddr->m_TableLen; ++i)
{
(m_ArrayAddr+i)->m_Head = m_InvalidId;
(m_ArrayAddr+i)->m_Tail = m_InvalidId;
}
}
int GetRowKeys(vector &keys, uint32_t index)
{
AutoLock autoLock(m_MutexLock);
if(index >= m_HeadAddr->m_TableLen) return -1;
keys.clear();
keys.reserve(16);
int count = 0;
Array *tmpArray = m_ArrayAddr + index;
uint32_t nodeId = tmpArray->m_Head;
while(nodeId != m_InvalidId)
{
Entry *tmpNode = m_EntryAddr + nodeId;
keys.push_back(tmpNode->m_Key);
nodeId = tmpNode->m_Next;
++count;
}
return count;
}
void *Padding(uint32_t size)
{
AutoLock autoLock(m_MutexLock);
if(size > m_HeadSize - sizeof(TableHead)) return NULL;
else return m_HeadAddr->m_Padding;
}
private:
static const uint32_t m_InvalidId = 0xffffffff;
static const uint32_t m_HeadSize = 1024;
struct TableHead
{
uint32_t m_TableLen;
uint32_t m_NodeTotal;
uint32_t m_FreeBase;
uint32_t m_RecycleHead;
uint32_t m_UsedCount;
char m_TableName[256];
uint32_t m_Padding[0];
};
struct Array
{
uint32_t m_Head;
uint32_t m_Tail;
};
struct Entry
{
V m_Value;
K m_Key;
uint32_t m_Code;
uint32_t m_Next;
uint32_t m_Prev;
};
size_t m_MemSize;
uint8_t *m_MemAddr;
TableHead *m_HeadAddr;
Array *m_ArrayAddr;
Entry *m_EntryAddr;
ThreadMutex m_MutexLock;
bool MoveToHead(K &key);
uint32_t GetIdByKey(K &key);
void AddNodeToHead(uint32_t index, uint32_t nodeId);
bool MoveNodeToHead(uint32_t index, uint32_t nodeId);
bool RecycleNode(uint32_t index, uint32_t nodeId);
uint32_t GetTailNodeId(uint32_t index);
uint32_t GetFreeNode();
DISABLE_COPY_AND_ASSIGN(HashTable);
};
template
HashTable::HashTable(const char *tablename, uint32_t tableLen, uint32_t nodeTotal)
{
AbortAssert(tablename != NULL);
m_MemSize = m_HeadSize + tableLen*sizeof(Array) + nodeTotal*sizeof(Entry);
m_MemAddr = (uint8_t*)MemFile::Realloc(tablename, m_MemSize);
AbortAssert(m_MemAddr != NULL);
m_HeadAddr = (TableHead*)(m_MemAddr);
m_ArrayAddr = (Array*)(m_MemAddr + m_HeadSize);
m_EntryAddr = (Entry*)(m_MemAddr + m_HeadSize + tableLen*sizeof(Array));
m_HeadAddr->m_TableLen = tableLen;
m_HeadAddr->m_NodeTotal = nodeTotal;
strncpy(m_HeadAddr->m_TableName, tablename, sizeof(m_HeadAddr->m_TableName));
if(m_HeadAddr->m_UsedCount == 0)//if first use init array to invalid id
{
for(uint32_t i = 0; i < tableLen; ++i)
{
(m_ArrayAddr+i)->m_Head = m_InvalidId;
(m_ArrayAddr+i)->m_Tail = m_InvalidId;
}
m_HeadAddr->m_FreeBase = 0;
m_HeadAddr->m_RecycleHead = 0;
}
}
template
HashTable::~HashTable()
{
MemFile::Release(m_MemAddr, m_MemSize);
}
template
bool HashTable::MoveToHead(K &key)
{
uint32_t nodeId = GetIdByKey(key);
uint32_t index = key.HashCode() % m_HeadAddr->m_TableLen;
return MoveNodeToHead(index, nodeId);
}
template
uint32_t HashTable::GetIdByKey(K &key)
{
uint32_t has