缓冲技术之五：缓冲池的LRU管理策略C++实现

/*
LRU事实上属于一类被称为内存置换算法（FIFO、LRU、LFU）：都是指在有限的容量下，设计一个如何管理和更新数据项的策略
本程序是实现LRU-1算法，但是和常见的LRU算法不同，一般常规的LRU算法是直接用一个LRU双向链表队列实现管理，这种双向链
表会导致查找元素的时间复杂度位O(n)，故而我的程序是在LRU双向链表的基础上附加一个map关联容器用以加速索引过程，将
查找元素的操作的时间复杂度降低为O(logN)
*/
#include <iostream>
#include <map> //map并非hash-table
#include <algorithm>
#include <assert.h>
#include <windows.h>
//这类STL文件均没有.h后缀
using namespace std;

#define BUFFER_BLOCK_SIZE 512
typedef struct __buffer_head
{
__buffer_head* prev; //指向前一个缓冲块
__buffer_head* next; //指向后一个缓冲块的__buffer_head
int   block_number;//用来标示该buffer缓冲块的全局索引号
char* buffer_content;//指向数据缓存区的指针
}buffer_head;

class LRUBufferList
{
private:
int LRUBufferList_Size_MAX; //LRU队列上限
int LRUBufferList_Size; //LRU队列当前存储量
buffer_head* LRUBufferList_First; //LRU链首
buffer_head* LRUBufferList_End; //LRU链尾
map<int, buffer_head*> quickIndex; //除了LRU管理队列外，还要配备一个额外的快速索引结构，这里采用STL提供的map

public:
LRUBufferList(int capacity)
{
LRUBufferList_Size_MAX = capacity;
LRUBufferList_First = LRUBufferList_End = NULL;
LRUBufferList_Size = 0;
}

~LRUBufferList()
{
map<int, buffer_head*>::iterator iter;
//清理所有的缓存块空间，释放内存
for (iter = quickIndex.begin(); iter != quickIndex.end(); iter++ )
{
if (iter->second->buffer_content) //如果该缓冲块被分配了空间，则删除该空间
delete iter->second->buffer_content;

delete iter->second; //删除该缓冲块的buffer_head头部结构
}
quickIndex.erase(quickIndex.begin(), quickIndex.end()); //擦除map快速索引结构
LRUBufferList_First = LRUBufferList_End = NULL; //置LRU队列的管理指针为空
}

//给定Block的缓冲块号，返回指定缓冲块头部指针
buffer_head* get(int param_number)
{
//先在map快速索引结构中定位该block块
map<int, buffer_head*>::iterator iter = quickIndex.find( param_number );

if ( iter == quickIndex.end() )
return NULL;
else
{
//在map中找到了该缓冲块的头部指针,则意味着该缓冲块应该在LRU被提到链首
moveToHead(iter->second);
return iter->second;
}
}

//将指定的block缓冲块号中的内容替换成content指定的内容，如果LRU队列中不存在该block，则新建该block并将其加入到LRU队列中
buffer_head* rewrite(int param_number, char* content)
{
//如果该批次要修改的内容的有效数据内容超过511，即不能用单个缓冲块装载完，则说明是前面调度出现了问题，当然这种调度
//应该是根据具体要缓冲的内容大小而分配适当块数的缓冲块，但至于如何切割内容，显然不是由LRU队列实现的。
if ( strlen(content) > BUFFER_BLOCK_SIZE-1  )
exit(-1);

map<int, buffer_head*>::iterator iter = quickIndex.find( param_number );

if (iter == quickIndex.end() )
{
buffer_head* newBuffer = getFreeBuffer(param_number);
strcpy(newBuffer->buffer_content, content);

//新缓冲块创建成功，下面可以执行将该新Block加入到LRU队列中
addToHead(newBuffer);
return newBuffer;
}

else //意味着LRU缓冲队列中原先便有了该缓冲块，故而需要调换该缓冲块的原先内容
{
strcpy(iter->second->buffer_content, content);
moveToHead(iter->second);
return iter->second;
}
}

buffer_head* getFreeBuffer(int param_number)
{
if (LRUBufferList_Size < LRUBufferList_Size_MAX) //在内存中创建一个新的缓冲块
{
buffer_head newBuffer;
newBuffer.prev = newBuffer.next = NULL;
newBuffer.block_number = param_number;
newBuffer.buffer_content = new char[BUFFER_BLOCK_SIZE]; //给新创建的block缓冲块分配512固定字节空间
//在快速索引结构中也添加索引
quickIndex[param_number] = &newBuffer;

return &newBuffer;
}
else if (LRUBufferList_Size == LRUBufferList_Size_MAX)
{
//从LRU末尾淘汰一个对象，将其空间腾空给新的数据使用
LRUBufferList_Size--; //这里先给LRU队列中有效数据数量减1，在addToHead()操作中将加回来，逻辑更清楚
buffer_head* temp = LRUBufferList_End;
LRUBufferList_End->prev->next = NULL;
LRUBufferList_End = LRUBufferList_End->prev;

temp->prev = temp->next = NULL;
//将淘汰掉的LRU末尾缓冲块快速索引信息从map中删除掉
quickIndex.erase( temp->block_number );
temp->block_number = param_number;
//在快速索引结构中修改索引
quickIndex[param_number] = temp;
return temp;
}
}

void addToHead( buffer_head* target )
{

if (LRUBufferList_Size == 0)
{
LRUBufferList_First = LRUBufferList_End = target;
}
else
{
target->next = LRUBufferList_First;
LRUBufferList_First->prev = target;
LRUBufferList_First = target;
}

LRUBufferList_Size++;
}

void moveToHead( buffer_head* target )
{
//如果LRU队列中只有当前target一个对象，则显然不需要再调整
if (LRUBufferList_Size == 1)
return;
//如果当前对象本身就是LRU队列的链首，则也无需调整
if (target == LRUBufferList_First)
return;
//调整target的邻居缓冲块的信息
if (target->prev)
target->prev->next = target->next;
if (target->next) //如果目标缓冲块的后续还有缓冲块
target->next->prev = target->prev;
else //如果目标缓冲块的后续没有缓冲块，则意味着target本身就是链尾，这时移动target会牵涉到LRU队列链尾信息的变动
{
if (target->prev)
LRUBufferList_End = target->prev;
else //如果target前向也没有缓冲块，则意味着LRU队列只有target一个
{
assert( LRUBufferList_Size == 1);
LRUBufferList_End = target;
}
}

//调整目标缓冲块头部的前后缓冲块邻居信息
target->prev = NULL;
target->next = LRUBufferList_First;
LRUBufferList_First->prev = target;
//调整LRU队列链首信息
LRUBufferList_First = target;
}

char* strcpy(char *dest, const char* src)
{
char* ret = dest;
while(*src)
*dest++ = *src++;
*dest = '\0';//手动在字符串末尾加入\0结束符
return ret;
}

unsigned strlen(const char* str)
{
int cnt = 0;
if (!str)
return 0;
for (; *str != '\0'; ++str)
++cnt;
return cnt;
}

};