《深入理解计算机系统》自学历程（一）模拟高速缓存逻辑（下）

经过三次重写，和合计30多个小时的开发，终于把这个简单的逻辑做完了。（自己太笨）

因为刚刚接触C，写的代码实现方式肯定有不对的地方，逻辑上可能也有疏漏，如果有看官发现问题还望及时给予指正，谢谢。

一、整体概括：

1.1目标：

维护一个单独的缓存空间，该空间是低一级存储的缓存。缓存的大小比低级存储的大小要小很多，通过一个逻辑将底层存储的数据抽到缓存中的一个位置。

1.2 实现思路：

　　通过阅读《深入理解计算机系统》一书，了解低级存储与缓存之间关联规则是基于存储地址的，通过一个地址映射的规则，将低级存储的地址映射到缓存的制定位置。

　　1.2.1 存储：

　　　　存储是由一个个位构成的，每个位都有一个对应的地址，地址的大小取决于计算机的字长。

　　1.2.2 低级存储：

　　　　在这次的设计中低级存储只是一个抽象概念，实际上就是内存中的一块空间，只不过我通过映射值将低级存储的地址改为从F000开始的地址。

　　1.2.3 缓存：

　　　　缓存是比低级存储小得多的集合，因为存储越大寻址的时间越长，所以需要一个小的缓存来存储处理器近期使用到的数据。

　　　　这次设计中的缓存也只是一个抽象概念，也是内存的一块空间，也是通过映射值将缓存的地址改为A000开始的地址。

　　如何将低级存储的地址映射到缓存——缓存模型：

　　　　缓存模型主要分——组、行、缓存单元

　　　　1.2.3.1 组

　　　　　　在逻辑上没有体现，知识对地址进行切割并划分了一个范围，是在映射逻辑上有关，在实际内存中不会存储。

　　　　1.2.3.2 行

　　　　　　也是一个逻辑体现，主要是为了更好的提升缓存的寻址效率而设置的思想。

　　　　1.2.3.3 缓存单元：

　　　　　　实际存储数据的对象，其中包含了标识、是否加载、以及字节块。

　　　　　　　　标识：标识是地址的一部分根据规则截取出来的，通过地址另一部分找到对应的组以后就会对其中的行进行遍历，根据标识找到对应的行。

　　　　　　　　是否加载：用来标识该缓存是否已经加载数据。

　　　　　　　　字节块：用来存储缓存数据。（大小可设置）

　　   　1.2.3.4 总结

　　　　　　通过上述的几个对象，我们将缓存组织成了一个三层的结构，第一层是组、第二层是行、第三层是存储单元。一个缓存可以有S个组，可以有E个行，每行只能有一个缓存单元。

　　1.2.4 全相连高速缓存、组相连高速缓存、直接映射高速缓存

　　　　全相连高速缓存就是缓存中只有一个组，有E个行的方式实现。

　　　　组相连高速缓存就是一个缓存中有S个组，E个行的实现方式。

　　　　直接映射高速缓存就是一个缓存中有S个组，1个行和1个缓存单元的实现方式。

　　 1.2.5 缓存各项指标的设置：

　　　　组数、行数、缓存数据块的大小的设置直接影响缓存的效率但也要根据实际情况，大小对不同的情况有不同的策略。

二、具体实现：

　　2.1 公共常量：

　　　　计算机字长：MemAddrLength

　　2.2 几个核心对象：

　　　　2.2.1 硬件控制器：HWController

　　　　　　属性：

　　　　　　　　存储空间大小

　　　　　　1）写方法（Write）：传入一个虚拟硬件地址（自己映射的，从F000开始）和一个长度。映射后写入数据到内存。

　　　　　　2）读方法（Read）：传入一个虚拟硬件地址和一个长度。映射后从内存读出数据，并写到一个新的内存空间并返回该指针。

　　　　2.2.2 缓存控制器：CacheController

　　　　　　1）缓存单元查询器（CacheFinder）：

　　　　　　2）读方法（Read）：传入一个硬件虚拟地址和长度，在缓存中查找对应的单元，如果找不到从硬件中读取数据写到缓存，并将数据写到内存新的空间中、返回该指针。

　　　　　　3）写方法（Write）：传入一个硬件虚拟地址和长度，将数据写入到硬件中再写到缓存里（实际上缓存会有多种策略、直写/不直写等等）。

　　　　　　4）取下一个（Next）：将传入缓存单元指针移动到相邻的下一个缓存单元，如果超出缓存范围则返回0x00。

　　2.3 执行结果概述

　　返回四大部分：

　　1）总体介绍部分，会将地址空间、缓存的S、E、B、t几个主要参数值显示出来。

　　

　　2）内存查看部分，会将初始化后虚拟硬件存储和缓存存储的值都写出来。

3）缓存大小显示

4）缓存读值测试

下面的集合是所有缓存单元的参数和右侧缓存单元字节块中的数据。

上面的集合是根据指令从缓存中读取出来的数据内容。

通过这两个集合可以验证读取数据是否正确。

 剩下没解决的问题：

在写缓存的时候，如果该组所有缓存单元都已经初始化了，就需要通过一个科学的方式选择一个块覆盖或驱逐，目前是用随机数，不太合理。

抽象不够，没有悟透和语言不熟导致很多复用问题比较多，有问题望指出。后续有时间我会继续完善。

说不定有BUG，如果有客观指正。

三、代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>

/*
 * 基本设定初始化
 */
const unsigned int _memSize = 1024; //内存大小（字节）
const unsigned int _memAddrLength = 16;//地址长度
const unsigned int _cacheSize = 256;//缓存大小

/*
 * 硬件控制器
 */
typedef struct HWController{
    unsigned long _memStartAddr; //start addr 0XF0
    unsigned char* _memAddr;
    unsigned long _memOffset;

    unsigned char* (*Read)(unsigned long memOffset, unsigned long addr, unsigned long length);
    unsigned char (*Write)(unsigned long memOffset, unsigned long addr, unsigned char *data, unsigned long length);
};

/*
 * 缓存控制器：
 *      1）缓存单元集合指针 CacheUnitArrayPtr
 *      2）缓存查询函数 CacheFinder
 *      3）缓存读函数 Read
 *      4）缓存写函数 Write
 */
typedef struct CacheController {
    unsigned int _s;
    unsigned long _sMask;
    unsigned int _S;
    unsigned int _E;
    unsigned int _b;
    unsigned long _bMask;
    unsigned int _B;
    unsigned int _t;
    unsigned long _tMask;
    unsigned int _C;

    unsigned long _unitCount;
    unsigned long _unitSize;

    unsigned long _cacheSize;
    unsigned long _cacheStartAddr;
    unsigned char* _cacheMemAddr;
    unsigned long _cacheOffset;
    struct CacheUnit* CacheUnitArrayPtr;

    struct CacheUnit* (*Next)(struct CacheController *ctrl,struct CacheUnit *unit);
    struct CacheUnit* (*CacheFinder)(struct CacheController *ctrl,unsigned long Addr);
    unsigned char* (*Read)(struct CacheController *ctrl,struct HWController *hwctrl,unsigned long addr, unsigned long length);
    unsigned char (*Write)(struct CacheController *ctrl,struct HWController *hwctrl,unsigned long addr, unsigned char *data, unsigned long length);
};

/*
 * 缓存单元
 *      1）数据块集合指针 BlockArrayPtr;
 *      2）t标志位 tCode;
 *      3）热标识位 hot;
 */
typedef struct CacheUnit {
    unsigned char* BlockArrayPtr;
    unsigned long tCode;
    unsigned char Hot;
};

//HWController
unsigned char _hwWrite(unsigned long memOffset, unsigned long addr, unsigned char *data, unsigned long length){
    unsigned char* ptr = (unsigned char*)(memOffset + addr);
    while(length--){
        *ptr = *data;
        ptr++;
        data++;
    }
    return 1;
}
unsigned char* _hwRead(unsigned long memOffset, unsigned long addr, unsigned long length){
    unsigned char *ptr = (unsigned char*)(memOffset + addr);
    unsigned char *retPtr = malloc(length);
    unsigned char *loopPtr = retPtr;
    while(length--){
        *loopPtr = *ptr;
        ptr++;
        loopPtr++;
    }

    return retPtr;
}
struct HWController* GetHWCtroller(){
    struct HWController *ctrl = malloc(sizeof(struct HWController));
    void *rPtr = malloc(_memSize);//get ptr point to Memory Space.
    (*ctrl)._memStartAddr = 0xF000;
    (*ctrl)._memOffset = (unsigned long) (rPtr - (*ctrl)._memStartAddr);
    (*ctrl)._memAddr = rPtr;
    (*ctrl).Write = _hwWrite;
    (*ctrl).Read = _hwRead;

    unsigned char *ptr = rPtr;
    int i = 0;
    while( i < _memSize ){
        *ptr = i + 1000;
        ptr++;
        i++;
    }

    printf("==>Memory:
 startAddr:%X,offset:%X",(unsigned int)(*ctrl)._memStartAddr,(unsigned int)((*ctrl)._memOffset ));

    return ctrl;
}

//CacheController
struct CacheUnit* _next(struct CacheController *ctrl,struct CacheUnit *unit){
   unit = (struct CacheUnit *)((unsigned long)unit + ctrl->_unitSize);
   return unit >= (ctrl->_cacheSize + ctrl->_cacheMemAddr) ? 0x00 : unit;
}
struct CacheUnit* _cacheFinder(struct CacheController *ctrl,unsigned long addr){
    unsigned long _tBit = (addr&(*ctrl)._tMask)>>((*ctrl)._b+(*ctrl)._s);
    unsigned long _sBit = (addr&(*ctrl)._sMask)>>((*ctrl)._b);
    unsigned long _bBit = (addr&(*ctrl)._bMask);

//    printf("

====>Find Addr:%X 
 tMask:%X,tVal:%X 	 sMask:%X,sVal:%X 	 bMask:%X,bVal:%X",addr,(*ctrl)._tMask,_tBit,(*ctrl)._sMask,_sBit,(*ctrl)._bMask,_bBit);

    struct CacheUnit* _unit = (struct CacheUnit*)((*ctrl)._cacheStartAddr + ctrl->_cacheOffset + _sBit * ((*ctrl)._E * ctrl->_unitSize));
    int e = (*ctrl)._E;
    while ( e-- )
    {
        if((*_unit).tCode == _tBit){
            return _unit;
        }
        _unit = (struct CacheUnit *)(((unsigned long)_unit)+ ctrl->_unitSize);
    }
    return 0;
}
unsigned char* _cacheRead(struct CacheController *ctrl,struct HWController *hwctrl,unsigned long addr, unsigned long length){
    struct CacheUnit *unit = ctrl->CacheFinder(ctrl,addr);
    //todo: 找时间把Loader抽象出来或者其他方式优化复用。
    if(!unit || !(*unit).Hot){
        unsigned char *read = hwctrl->Read(hwctrl->_memOffset,addr,length);
        ctrl->Write(ctrl,hwctrl,addr,read,length);
        unit = ctrl->CacheFinder(ctrl,addr);
        if(!unit || !(*unit).Hot){
            printf("
ERROR::can not load cache by %X !!!! 
" ,(unsigned int)addr);
            exit(0);
        }
    }
    unsigned char *memPtr = malloc(length);
    unsigned char *memLoopPtr = memPtr;
    unsigned char *blockPtr = (*unit).BlockArrayPtr + (ctrl->_bMask & addr);
    unsigned long i = 0;
    while(i < length){
        *memLoopPtr = *blockPtr;
        memLoopPtr++;
        blockPtr++;
        if(blockPtr >= (*unit).BlockArrayPtr + (*ctrl)._B){
            unit = ctrl->CacheFinder(ctrl,addr + i + 1);
            if(!unit || !(*unit).Hot){
                    printf("
ERROR::can not load cache by %X !!!! 
" ,(unsigned int)(addr + i));
                    exit(0);
            }
            blockPtr = unit->BlockArrayPtr;
        }
        i++;
    }
    return memPtr;
}
unsigned char _cacheWrite(struct CacheController *ctrl,struct HWController *hwctrl,unsigned long addr, unsigned char *data, unsigned long length){
    //写入底层内存先。
    hwctrl->Write(hwctrl->_memOffset,addr,data,length);
    //写入缓存
    unsigned char *ptr = data;
    unsigned long i = 0;

    while(i<length){
        struct CacheUnit *unit = ctrl->CacheFinder(ctrl,addr + i);
        if(!unit||!unit->Hot)
        {
            unsigned long startAddr = (unsigned long)(ctrl->_cacheMemAddr + (((ctrl->_sMask & (addr + i)) >> ((*ctrl)._b)) * ctrl->_E) * ctrl->_unitSize) ;
            unsigned long endAddr = (unsigned long)(ctrl->_cacheMemAddr + (((ctrl->_sMask & (addr + i)) >> ((*ctrl)._b)) * ctrl->_E)) + ctrl->_E * ctrl->_unitSize;
            unit = (struct CacheUnit *)startAddr;
            int hit = 0;
            while(unit){
                if(!unit->Hot)
                {
                    hit=1;
                    break;
                }
                unit = ctrl->Next(ctrl,unit);
                if((unsigned long)unit >= endAddr){
                    break;
                }
            }
            if(!hit)
            {
                printf("

nhit!!!
");
               int rm = rand() % ( ctrl->_E );
               unit = startAddr + rm * ctrl->_unitSize;
            }
            unit->tCode = ((addr + i) & ctrl->_tMask) >> ((*ctrl)._b+(*ctrl)._s);
            unit->Hot = 1;
        }
        unsigned char *blockPtr = unit->BlockArrayPtr + ((addr+i)&ctrl->_bMask);
        *blockPtr = *ptr;
        ptr++;
        i++;
    }
}
struct CacheController* GetCacheController(unsigned int _memAddrLength, unsigned int cacheSize, unsigned int blockSize,unsigned int E){
    struct CacheController *cache = malloc(sizeof(struct CacheController));
    (*cache)._b = (unsigned int)log2(blockSize);
    (*cache)._B = blockSize;
    (*cache)._bMask = (unsigned long) pow(2,(*cache)._b) - 1;

    (*cache)._E = E;

    (*cache)._S = cacheSize / (*cache)._B / (*cache)._E;
    (*cache)._s = (unsigned int)log2((*cache)._S);
    (*cache)._sMask = (unsigned long) pow(2,((*cache)._b + (*cache)._s)) - (*cache)._bMask - 1;

    (*cache)._C = (*cache)._B * (*cache)._E * (*cache)._S;

    (*cache)._t = _memAddrLength - (*cache)._s - (*cache)._b;
    (*cache)._tMask = (unsigned long) pow(2,_memAddrLength) - (*cache)._bMask - (*cache)._sMask - 1;

    (*cache)._unitCount = (*cache)._E * (*cache)._S;
    (*cache)._unitSize = sizeof(struct CacheUnit) + (*cache)._B;

    (*cache)._cacheSize = (*cache)._unitSize * (*cache)._unitCount;
    //apply mem
    (*cache)._cacheMemAddr = malloc((*cache)._cacheSize);
    (*cache)._cacheStartAddr = 0xA000;
    (*cache)._cacheOffset = (unsigned long)((*cache)._cacheMemAddr - cache->_cacheStartAddr);

    unsigned long counter = (*cache)._unitCount;
    struct CacheUnit *unit = (struct CacheUnit*)(*cache)._cacheMemAddr;

    while(counter){
        (*unit).Hot = 0x00;
        (*unit).tCode = counter;
        (*unit).BlockArrayPtr = (unsigned char *)(((unsigned long)unit) + sizeof(struct CacheUnit));
        int x;
        for(x = 0;x < cache->_B ; x++){
            *(unit->BlockArrayPtr + x) = (unsigned char)x;
        }
        unit = (struct CacheUnit*)((*unit).BlockArrayPtr + (*cache)._B);
        counter--;
    }
    (*cache).Next = _next;
    (*cache).CacheFinder = _cacheFinder;
    (*cache).Read = _cacheRead;
    (*cache).Write = _cacheWrite;

    printf("
==>CacheSize:
 MemAddrLength = %d. C = %d, 
S = %d, E = %d, B = %d; 
 s = %d, b = %d, t = %d",_memAddrLength,(*cache)._C,(*cache)._S,(*cache)._E,(*cache)._B,(*cache)._s,(*cache)._b,(*cache)._t);
    printf("
cacheAddr:%X,cacheStartAddr:%X, cacheOffset:%X, cacheSize:%d",(unsigned int)(*cache)._cacheMemAddr,(unsigned int)(*cache)._cacheStartAddr,(unsigned int)(*cache)._cacheOffset,(unsigned int) (*cache)._cacheSize);
    printf("
bMask:%x,sMask:%x,tMask:%x",(unsigned int)(*cache)._bMask,(unsigned int)(*cache)._sMask,(unsigned int)(*cache)._tMask);

    return cache;
}

//utility
void PrintMem(char* title, unsigned long addr, unsigned long length,int split){
    printf("

=====> title::%s::  Printing Mem %X,Length:%d  <=======
",title,(unsigned int)addr,(unsigned int)length);
    unsigned char *ptr = (unsigned char *)addr;

    int i = 0;
    while(i < length){
        if( i % 16 == 0){
            printf("
%d	%X	",i,(unsigned int)ptr);
        }
        else if( i > 0 && i % 4 == 0){
            printf("	");
        }
        printf("	%X",*ptr);
        ptr++;
        i++;
    }
}
void PrintCache(char* title, struct CacheController* ctrl){
    printf("

=====> title::%s::  Printing Mem %X,Length:%d  <=======
",title,(unsigned int)(ctrl->_cacheStartAddr + ctrl->_cacheOffset),(unsigned int)ctrl->_unitCount);

    struct CacheUnit *unit = ( struct CacheUnit *)(ctrl->_cacheStartAddr + ctrl->_cacheOffset);
    unsigned char *blockPtr = unit->BlockArrayPtr;
    int i = 0;
    int j = 0;
    while(i < ctrl->_unitCount){
        printf("
--Unit%d[[tCode:%d,BlockPtr:%X,Hot:%d]] Blocks:	",i+1,(unsigned int)unit->tCode,(unsigned int)unit->BlockArrayPtr,(unsigned int)unit->Hot);
        j = 0;
        while(j < ctrl->_B){
            printf("	%X",(unsigned int)*blockPtr);
            blockPtr++;
            j++;
        }
        unit = (struct CacheUnit *)(((unsigned long)unit) + sizeof(struct CacheUnit) + ctrl->_B);
        blockPtr = unit->BlockArrayPtr;
        i++;
    }
}
int main() {
    printf("Hello, World!
");
    struct HWController hwCtrl = *GetHWCtroller();
    struct CacheController cacheCtrl = *GetCacheController(_memAddrLength,_cacheSize,32,2);

//HW Unit Test
    //    PrintMem("",(unsigned long)hwCtrl._memAddr,16,0);
    //    unsigned char temp = 0xAA;
    //    unsigned char *data = &temp;
    //    hwCtrl.Write(hwCtrl._memOffset,0XF002,data,1);
    //    PrintMem(" HWMEM 0~16 ",(unsigned long)hwCtrl._memAddr,16,0);
    //    unsigned char *retData = hwCtrl.Read(hwCtrl._memOffset,0XF002,1);
    //    PrintMem(" HWMEM 0XF002 ",(unsigned long)retData,1,0);
    //    unsigned char *retData = hwCtrl.Read(hwCtrl._memOffset,0XF002,1);
    PrintMem(" HWMEM ALL ",(unsigned long)hwCtrl._memAddr,_memSize,0);


    //Cache Unit Test
    PrintMem(" CACHE ALL ",(unsigned long)cacheCtrl._cacheMemAddr,cacheCtrl._cacheSize,0);


    //struct test
    struct CacheUnit cu = {
            0x00,
            0x00,
            0x00
    };
    printf("
 ============>> CacheUnitTypeSize %d 
",sizeof(struct CacheUnit));
    printf("
 ============>> CacheUnitSize %d 
",sizeof(cu));
    printf("
 ============>> CacheUnitSize.Hot %d 
",sizeof(cu.Hot));
    printf("
 ============>> CacheUnitSize.tCode %d 
",sizeof(cu.tCode));
    printf("
 ============>> CacheUnitSize ptr %d 
",sizeof(cu.BlockArrayPtr));

    //ReadCacheTest
    PrintMem("",cacheCtrl.Read(&cacheCtrl,&hwCtrl,0XF038,16),16,0);
    PrintCache("",&cacheCtrl);
    return 0;
}