基于哈希表实现页面置换算法

首先，在看这篇文章前，你需要了解缓存是干嘛的？

缓存

    众所周知，程序运行时，数据一般存在内存或磁盘里，而内存中的数据总是可以被更快速的获取。但是内存空间是有限的，大多数人PC的内存可能在4G~16G之间，这意味着你必须要舍弃一部分不频繁被访问的数据，把它们存在磁盘里；而把经常需要被访问的数据存在内存里，这就是缓存的基本思路。

    但对于程序（和你）而言，无法预测哪些数据是被经常访问的，所以你只能根据访问数据的历史来推测和统计哪些数据是被经常访问的，并把它存在内存里，如果内存满了就找个最不被经常访问的数据替换掉。这个统计过程和改写内存的策略通常被称为“页面置换算法”，事实上，所有可实现的缓存策略（页面置换算法）都是基于历史访问信息来实现的。科学家经过几十年的努力，发明了许许多多的页面置换算法，比如：FIFO、LFU、LRU、ARC、MQ、GD、GDSF....，它们各有所长，没有孰优孰劣。

    缺页数(率)：为了评判页面置换算法的优劣，针对访问数据的次数n，和数据未被缓存命中的次数（缺页数）p，缺页率=p/n。显然，缺页率越小，页面置换算法越优秀。

 

正事

    本文基于哈希表的内存管理结构，简单地实现线程安全的缓存算法（LFU, LRU, ARC, MQ, GD, GDSF):

　 首先看API：(cache.h)

#pragma once

#include <sys/time.h>
#ifdef __cplusplus
extern "C" {
#endif

typedef struct _cache *cache_t, _cache;
typedef struct _cache_ele cache_pair;
typedef struct _cache_ret { /// 读缓存返回结果
    long cost;        /// 代价
    const char*cache; /// 数据
}cache_ret;
/**
 * @API
 * create, delete, search, read
 */
cache_t   new_cache        (unsigned capacity, cache_ret(*model)(cache_t, const char*)); /// 新建
void      del_cache        (cache_t cache);                                              /// 删除
unsigned  cache_page_fault (cache_t cache);                                              /// 缺页数
cache_ret read_cache       (cache_t cache, const char*filename);                         /// 读缓存

/**
 * @Cache_Algorithm_Model
 * cache_ret(*)(cache_t, const char*)
 */
cache_ret LRU (cache_t cache, const char*request); /// 页面替换算法模型
cache_ret LFU (cache_t cache, const char*request);
cache_ret ARC (cache_t cache, const char*request);
cache_ret MQ  (cache_t cache, const char*request);
cache_ret GD  (cache_t cache, const char*request);
cache_ret GDSF(cache_t cache, const char*request);

#ifdef __cplusplus
}
#endif

    数据结构：

　　　　缓存：　　

struct _cache_ele {                   /// 数据单元
    char *key, *file_cache;           /// 键值、数据 
    long cost;                        /// 代价（长度）
    struct timeval pre_t;             /// 上次访问时间
    unsigned int cnt;                 /// 访问次数
    struct _cache_ele *nxt, *pre;
};

struct _cache {
    cache_pair table[HASHTABELSIZE], *first_table;      /// 哈希表，first_table根据需要生成
    cache_ret (*f)(cache_t, const char *);              /// 页面置换策略
    pthread_mutex_t mutex;                              /// 线程安全的锁
    unsigned int capacity, _cur, first_cur, page_fault; /// 容量、当前量、ft当前量、缺页数
};/// *cache_t

     缓存策略实现：

     缓存策略实际上是一个选择问题，如果缓存没有满，那么显然可以直接把新请求的数据直接读到缓存中，如果满了，则按照策略选一个数据替换掉。

     (cache.c完整代码)

#include "cache.h"
#include <zconf.h>
#include "stdlib.h"
#include <sys/mman.h>
#include "pthread.h"
#include "string.h"
#include <sys/time.h>
#include <fcntl.h>

#define RMALLOC(type,n) (type*)malloc(sizeof(type)*(n))
#define MALLOC(p,type,n) type*p = RMALLOC(type, n)
#define MAX_BUFFER_LEN 1024ll * 1024
#ifndef HASHTABLESZIE
#define HASHTABELSIZE 10005
#endif

unsigned int string_hash(const char *str) {
    unsigned int hash = 0;
    int i;
    for (i = 0; *str; i++) {
        if ((i & 1) == 0)hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
        else hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
    }
    return (hash & 0x7FFFFFFF);
}

struct _cache_ele {
    char *key, *file_cache;
    long cost;
    struct timeval pre_t;
    unsigned int cnt;
    struct _cache_ele *nxt, *pre;
};

cache_pair*new_cache_pair(){
    MALLOC(res, cache_pair, 1);
    res->key = res->file_cache = NULL;
    res->cnt = res->cost = 0;
    res->nxt = res->pre = NULL;
    return res;
}

void del_cache_pair(cache_pair *del) {
    free(del->key);
    free(del->file_cache);
    free(del);
}

struct _cache {
    cache_pair table[HASHTABELSIZE], *first_table;      /// hash table
    cache_ret (*f)(cache_t, const char *);              /// function pointer
    pthread_mutex_t mutex;
    unsigned int capacity, _cur, first_cur, page_fault;
};/// *cache_t

cache_t new_cache(unsigned capacity, cache_ret(*model)(cache_t, const char *)) {
    if (model) {
        MALLOC(ret, _cache, 1);
        pthread_mutex_init(&ret->mutex, NULL);
        ret->capacity = capacity;
        ret->page_fault = ret->first_cur = ret->_cur = 0;
        memset(ret->table, 0, sizeof(cache_pair) * HASHTABELSIZE);
        if (model == ARC)ret->first_table = RMALLOC(cache_pair, HASHTABELSIZE);
        else if(model == MQ)ret->first_table = RMALLOC(cache_pair, HASHTABELSIZE * 3);
        else ret->first_table = NULL;
        ret->f = model;
        return ret;
    }
    return NULL;
}

cache_ret read_cache(cache_t cache, const char *filename) {
    pthread_mutex_lock(&cache->mutex);
    cache_ret res = cache->f(cache, filename);
    pthread_mutex_unlock(&cache->mutex);
    return res;
}

unsigned cache_page_fault(cache_t cache){
    return cache->page_fault;
}

void del_cache(cache_t cache) {
    pthread_mutex_destroy(&cache->mutex);
    for (int i = 0; i < HASHTABELSIZE; ++i) {
        cache_pair *p = cache->table[i].nxt;
        while (p) {
            cache_pair *tmp = p;
            p = p->nxt;
            del_cache_pair(tmp);
        }
    }
    if (cache->first_table) {
        for (int i = 0; i < HASHTABELSIZE; ++i) {
            cache_pair *p = cache->first_table[i].nxt;
            while (p) {
                cache_pair *tmp = p;
                p = p->nxt;
                del_cache_pair(tmp);
            }
        }
        free(cache->first_table);
    }
    free(cache);
}

cache_pair *is_in_table(cache_pair *table, const char *request, int *ret) {
    unsigned int index = string_hash(request) % HASHTABELSIZE;
    cache_pair *src = table + index;
    if (!src->nxt) {
        *ret = 0;
        return src;
    }
    src = src->nxt;
    while (strcmp(src->key, request)) {
        cache_pair *pre = src;
        src = src->nxt;
        if (!src) { /// not in table: return pre node
            *ret = 0;
            return pre;
        }
    }
    *ret = 1;
    return src;
}

void replace_after_src(cache_pair *src, const char *request) {
    src = src->nxt;
    src->cnt = 1;
    gettimeofday(&src->pre_t, NULL);
    src->key = src->key ? (char *) realloc(src->key, strlen(request) + 1) : RMALLOC(char, strlen(request) + 1);
    strcpy(src->key, request);
    int fd = open(request, O_RDONLY);
    if (fd > 0) {
        char *fp = mmap(NULL, MAX_BUFFER_LEN, PROT_READ, MAP_SHARED, fd, 0);
        src->cost = strlen(fp) + 1;
        src->file_cache = src->file_cache ? (char *) realloc(src->file_cache, src->cost) : RMALLOC(char, src->cost);
        strcpy(src->file_cache, fp);
        munmap(fp, MAX_BUFFER_LEN);
        close(fd);
    } else {
        src->cost = -1;
        if (src->file_cache)free(src->file_cache);
        src->file_cache = NULL;
    }
}

void add_after_src(cache_pair *src, const char *request) {
    src->nxt = new_cache_pair();
    src->nxt->pre = src;
    replace_after_src(src, request);
}

void replace_copy(cache_pair *src, cache_pair *aim) {
    src = src->nxt;
    src->cnt = aim->cnt;
    gettimeofday(&src->pre_t, NULL);
    src->cost = aim->cost;
    free(src->key);
    free(src->file_cache);
    src->key = aim->key;
    src->file_cache = aim->file_cache;
    aim->pre->nxt = aim->nxt;
    free(aim);
}

void add_copy(cache_pair *src, cache_pair *aim) {
    src->nxt = new_cache_pair();
    src->nxt->pre = src;
    replace_copy(src, aim);
}

cache_pair *LRU_CHOOSE(cache_pair *table) {
    double mn = -1;
    cache_pair *res = NULL;
    for (int i = 0; i < HASHTABELSIZE; ++i)
        if (table[i].nxt) {
            cache_pair *ptr = table + i;
            while (ptr->nxt) {
                cache_pair *pre = ptr;
                ptr = ptr->nxt;
                double cur = ptr->pre_t.tv_sec * 1000.0 + ptr->pre_t.tv_usec / 1000.0;
                if (mn < 0 || cur < mn) {
                    mn = cur;
                    res = pre;
                }
            }
        }
    return res;
}

cache_pair *LFU_CHOOSE(cache_pair *table) {
    int mn = -1;
    cache_pair *res = NULL;
    for (int i = 0; i < HASHTABELSIZE; ++i)
        if (table[i].nxt) {
            cache_pair *ptr = table + i;
            while (ptr->nxt) {
                cache_pair *pre = ptr;
                ptr = ptr->nxt;
                int cur = ptr->cnt;
                if (mn < 0 || cur < mn) {
                    mn = cur;
                    res = pre;
                }
            }
        }
    return res;
}

cache_pair *GD_CHOOSE(cache_pair *table) {
    double mn = -1;
    cache_pair *res = NULL;
    for (int i = 0; i < HASHTABELSIZE; ++i)
        if (table[i].nxt) {
            cache_pair *ptr = table + i;
            while (ptr->nxt) {
                cache_pair *pre = ptr;
                ptr = ptr->nxt;
                double cur = ptr->cost + ptr->pre_t.tv_sec;
                if (mn < 0 || cur < mn) {
                    mn = cur;
                    res = pre;
                }
            }
        }
    return res;
}

cache_pair *GDSF_CHOOSE(cache_pair *table) {
    double mn = -1;
    cache_pair *res = NULL;
    for (int i = 0; i < HASHTABELSIZE; ++i)
        if (table[i].nxt) {
            cache_pair *ptr = table + i;
            while (ptr->nxt) {
                cache_pair *pre = ptr;
                ptr = ptr->nxt;
                double cur = ptr->cnt * ptr->cost + ptr->pre_t.tv_sec;
                if (mn < 0 || cur < mn) {
                    mn = cur;
                    res = pre;
                }
            }
        }
    return res;
}

cache_ret LRU(cache_t set, const char *request) {
    int flag;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) { /// real node
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else { /// pre node
        ++set->page_fault;
        if (set->_cur == set->capacity) { /// choose and replace
            src = LRU_CHOOSE(set->table);
            replace_after_src(src, request);
        } else { /// add node
            add_after_src(src, request);
            ++set->_cur;
        }
        src = src->nxt;
    }
    return (cache_ret) {src->cost, src->file_cache};
}

cache_ret LFU(cache_t set, const char *request) {
    int flag;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) {
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else {
        ++set->page_fault;
        if (set->_cur == set->capacity) {
            src = LFU_CHOOSE(set->table);
            replace_after_src(src, request);
        } else {
            add_after_src(src, request);
            ++set->_cur;
        }
        src = src->nxt;
    }
    return (cache_ret) {src->cost, src->file_cache};
}

cache_ret ARC(cache_t set, const char *request) {
    int flag;
    cache_pair *first_table = set->first_table;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) { /// in second table
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else {
        cache_pair *first_src = is_in_table(first_table, request, &flag);
        if (flag) { /// in first table
            ++first_src->cnt;
            if (set->_cur == set->capacity) { /// choose and replace
                src = LRU_CHOOSE(set->table);
                replace_copy(src, first_src); /// copy data to nxt src and delete first_src
            } else { /// add node
                add_copy(src, first_src); /// create node and replace
                ++set->_cur;
            }
            src = src->nxt;
        } else { /// not in first table
            ++set->page_fault;
            if (set->first_cur == set->capacity) {
                first_src = LRU_CHOOSE(first_table);
                replace_after_src(first_src, request);
            } else {
                add_after_src(first_src, request);
                ++set->first_cur;
            }
            src = first_src->nxt;
        }
    }
    return (cache_ret) {src->cost, src->file_cache};
}

cache_ret MQ(cache_t set, const char *request) {
    int flag;
    cache_pair *first_table = set->first_table;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) { /// in second table
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else {
        cache_pair *first_src = is_in_table(first_table, request, &flag);
        if (flag) { /// in first table
            ++first_src->cnt;
            if (set->_cur == set->capacity) { /// choose and replace
                src = LRU_CHOOSE(set->table);
                replace_copy(src, first_src); /// copy data to nxt src and delete first_src
            } else { /// add node
                add_copy(src, first_src); /// create node and replace
                ++set->_cur;
            }
            src = src->nxt;
        } else { /// not in first table
            ++set->page_fault;
            if (set->first_cur == set->capacity) {
                first_src = LRU_CHOOSE(first_table);
                replace_after_src(first_src, request);
            } else {
                add_after_src(first_src, request);
                ++set->first_cur;
            }
            src = first_src->nxt;
        }
    }
    return (cache_ret) {src->cost, src->file_cache};
}

cache_ret GD(cache_t set, const char *request) {
    int flag;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) {
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else {
        ++set->page_fault;
        if (set->_cur == set->capacity) {
            src = GD_CHOOSE(set->table);
            replace_after_src(src, request);
        } else {
            add_after_src(src, request);
            ++set->_cur;
        }
        src = src->nxt;
    }
    return (cache_ret) {src->cost, src->file_cache};
}

cache_ret GDSF(cache_t set, const char *request) {
    int flag;
    cache_pair *src = is_in_table(set->table, request, &flag);
    if (flag) {
        src->cnt++;
        gettimeofday(&src->pre_t, NULL);
    } else {
        ++set->page_fault;
        if (set->_cur == set->capacity) {
            src = GDSF_CHOOSE(set->table);
            replace_after_src(src, request);
        } else {
            add_after_src(src, request);
            ++set->_cur;
        }
        src = src->nxt;
    }
    return (cache_ret) {src->cost, src->file_cache};
}

---版权：代码遵从MIT协议开源，可以按需使用。（地址：cache.c）

---转载需标明出处，侵权必究

---作者：RhythmLian: https://github.com/Rhythmicc