操作系统内存管理

最新推荐文章于 2024-05-19 07:49:28 发布

qq_43216121

最新推荐文章于 2024-05-19 07:49:28 发布

阅读量229

点赞数 1

文章标签： linux

本文链接：https://blog.csdn.net/qq_43216121/article/details/125395898

版权

什么是高速缓冲存储器： cache memory

cpu与内存访问速度过慢，距离过远，因此引入高速缓冲存储器，它被加在了CPU上面。它的具体使用是，处理器每次访问内存，把要访问的内容和地址都放在了高速缓存里，下次访问相同地址里的内容，不需要在去内存访问了，cpu直接访问高速缓冲存储器就好。
而对于写内存而言，cpu会先更新上面的高速缓冲存储器，由高速缓冲存储器上的硬件电路对内存进行读写，就不需要cpu再去等待内存写完了。
观察机器语言流程就会发现，9成以上时间耗费在循环上。比如for循环中，地址不发生变化，而内容一直变化，如果cpu再操纵内存的话，就会非常耗费时间，所以可以在高速缓冲存储器上完成这个操作。

内存容量检查的实现

内存的检查通过给内存中指定位置写一个值，接着把这个值读出来，判断两个值是否相等。因此我们首先需要把高速缓冲存储器关掉，要不然检查的都不是内存而是缓冲里的。而386没有缓存，486及以上才会有缓存功能。

检查CPU是否含有高速缓存存储器（是386还是486及其以上）

如果是486以上的，EFLAGS寄存器的第18位是AC标志位，如果cpu是386的那么AC标志位一直是0，这里的检查思路是先获得这个寄存器的值，然后18位写为1，再获得一次，检查是否为1。

#define EFLAGS_AC_BIT       0x00040000
#define CR0_CACHE_DISABLE   0x60000000

unsigned int memtest(unsigned int start, unsigned int end)
{
    char flg486 = 0;
    unsigned int eflg, cr0, i;
    eflg = io_load_eflags();
    eflg |= EFLAGS_AC_BIT; /* AC-bit = 1 */
    io_store_eflags(eflg);
    eflg = io_load_eflags();
    if ((eflg & EFLAGS_AC_BIT) != 0) { 
        flg486 = 1;
    }
    eflg &= ~EFLAGS_AC_BIT; /* AC-bit = 0 */
    io_store_eflags(eflg);

    if (flg486 != 0) {
        cr0 = load_cr0();
        cr0 |= CR0_CACHE_DISABLE; //禁止缓存
        store_cr0(cr0);
    }

    i = memtest_sub(start, end);

    if (flg486 != 0) {
        cr0 = load_cr0();
        cr0 &= ~CR0_CACHE_DISABLE; 
        store_cr0(cr0);
    }

    return i;
}

8 io_load_eflags()这个函数会去获得EFLAGES的值
9 给eflg的第18位的AC标志位写1
10 把eflg的值再放回寄存器，如果AC标志位变成1就是486，如果18位一直为0，就是386
11 再次取出EFLAGES的值
12 判断AC标志位是否为1
13 为1的话，就是486
18 如果是486话，之前已经把18位置为0，现在要对CR0标志位的1位进行操作
24 是内存检查的实现部分
对第8行，第9行，汇编实现进行补充

_io_load_eflags：
PUSHFD表示将32位标志寄存器EFLAGS压入栈的顶部，栈向下生长了
POP EAX 将栈顶的数据复制到EAX，POP是出栈
RET 把栈顶的值，返回给这个函数被调用的地方
_io_store_eflags：
[ESP+4]是栈最后一个参数的地址，因为栈是向下生长，越来越小，所以加的话，就是往后退
MOV EAX,[ESP+4]是把栈顶的内容给EAX
PUSH是入栈，把EAX的内容压入栈
POPFD是把栈顶的值作为寄存器EFLAGS的值弹出
RET是把栈顶的值，返回给这个函数被调用的地方
以上代码的逻辑是：
先获取到EFLAGES，再对第18位置1，然后再次获取这个寄存器看置1是否成功，如果是0，则是386，如果是1，则是486再次置0。
如果我写这个代码的话，先获取一次值，看看是多少，给他置1，看置1，成功不，置1不成功话，则是386，不成功话，则是486给他恢复到0，开始后面的工作
其实书中的意思和我的意思是一样的
现在对于CPU是否含有缓存已经判断出来了，我们进行下一项

内存容量检查

内存容量检查时，要往内存里随便写一个值，然后马上读取，来检查读取的值和写入的值是否相等。如果内存连接正常，则写入的值都能够记在内存里。如果没连接上，则读出的值是乱七八糟的。
在内存检查时，看看CPU是不是在486及以上，如果是，就将缓存设为OFF，我们继续看代码：
15 将EFLAGES设为0
16 保存EFLAGES寄存器的值
18 如果是486，则禁止缓存
24 memtest_sub是进行内存检查处理的
28 在把486的缓存打开

内存容量检查memtest_sub的实现

unsigned int memtest_sub(unsigned int start, unsigned int end)
{
    unsigned int i, *p, old, pat0 = 0xaa55aa55, pat1 = 0x55aa55aa;
    for (i = start; i <= end; i += 4) {
        p = (unsigned int *)i;
        old = *p;           /* 把修改前的值记住*/
        *p = pat0;          
        *p ^= 0xffffffff;   
        if (*p != pat1) {   
not_memory:
            *p = old;
            break;
        }
        *p ^= 0xffffffff;   /* 再次反转 */
        if (*p != pat0) {   /* ���ɖ߂������H */
            goto not_memory;
        }
        *p = old;           /* ���������l�����ɖ߂� */
    }
    return i;
}

4 每次检查4字节的地址
5 p等于i的地址
6 把这个地址，修改前的值记下来
7 给这个地址赋值0xaa55aa55，
8 利用异或运算符在这里取反
9 判断取出来的值是不是0x55aa55aa，如果不是运行下面的，就说明内存的连续性有问题
11 把原来的值放回去
14 数字之前是0xaa55aa55，8行反转了一次是0x55aa55aa，14行再次反转，那么应该是0xaa55aa55
15 如果不是14行分析的值，说明碰巧第一次内存中的数据通过了筛选。
由于上述代码一次4字节的去测试，太慢了，我们进行了优化，优化后的代码如下

unsigned int memtest_sub(unsigned int start, unsigned int end)
{
    unsigned int i, *p, old, pat0 = 0xaa55aa55, pat1 = 0x55aa55aa;
    for (i = start; i <= end; i += 0x1000) {
        p = (unsigned int *) (i + 0xffc);
        old = *p;

这样子每次增加0x1000，后面3个0，是2的12次方，是4KB。
地址是以字节为单位的。
5 每次加上0xffc，c是1100，在1100，1101，1110，1111，这四个地址可以存放数据，所以只检查末尾的4字节，
为什么是4字节，因为内存的最小存储单位是字节，所以1个就是1字节。
为什么要这么粗的检查内存，因为内存在系统启动时已经被仔细检查过了，我们目前的工作是主要进行容量检查

36 i是memset的返回值，从0x00400000，检查到0xbfffffff。

除了两次1024

书里168叶讲了在内存容量检查时，多次反转，被C编译器优化掉，所以最后也被改成了汇编语言
我们反正时间多的是，在这里深入研究一下吧

这个i还不是内存的终止地址减去内存的开始地址
作者在167页的下面说，内存应该是32MB，内存为什么应该是32MB？
不知道
作者怀疑是C编译器的问题，采取的是将C语言转化为汇编语言，观察代码的运行情况

挑战内存管理

一维数组进行内存管理

管理系统的内存，哪些内存可以使用，哪些内存不能使用。如果不进行内存管理，操作系统不知道哪块内存可以用，也可能多个程序访问同一个内存空间，内存管理的基础，一是内存分配，一是内存释放。
假设有128MB的内存（128MB对应0x0800 0000，128是2的7次方，1MB对应1024KB，1KB对应1024B，所以128MB是2^7乘210乘2^10，总共是2的27次方。分析0x0800 0000，8对应1000，是2的3次方，所以这个是2的27次方）
假设以0x1000个字节为单位进行管理（这个是2的12次方，2的10次方是1KB，2的12次方是4KB）
那么用0x0800 0000/0x1000=0x08000=32678个区域。我们可以创建一个32678长度的一维数组，对数组里写1或者写0，来表示哪些区域正在使用，哪些区域是空着的

char a[32678];
for(i=0;i<1024;i++){
    a[i] = 1;//一个区域是4KB，1024个区域是4MB，也就是说定义了前4MB区域比较繁忙
}
for(i=1024;i<32678;i++){
    a[i] = 0;//后面的内存空间标记为空
}

如果此时需要100KB的空间，只需要找到25个区域标记为0的就好

j=0;
for(i=0;i<25;i++)
{
    if(a[j+i] != 0)
    {
        j++
        if(j>32678-25){
            printf("没有内存了");        
        }    
    }
}

如果找到了100KB的空间，则需要将这部分内存标记为正在使用，此时要把j返回出去，j相当于偏移地址，从j可以计算出这100KB的具体内存

for(i=0;i<25;i++)
{
    a[j+i] = 1;        
}

如果要释放这部分内存空间，比如这部分内存是0x00123000开始的100KB

j=0x00123000/0x1000;
for(i=0; i<25; i++)
{
 a[j+i]=0;   
}

以上是利用一维数组进行内存管理。
如果内存不断变大，相应的这个一维数组也不断变大，因此这个不是最好的方法

利用链表来进行内存管理

下面这个FREEINFO记载的是可用的

struct FREEINFO{
  unsigned int addr,size;  
};
struct MEMMAN{
    int free;
    struct FREEINFO free[1000];
}
struct MEMMAN memman;
memman.free=1;                    //表示可用的数量，这里表示可用的数量是1
memman.free[0].addr=0x00400000;  //从0x00400000开始，有124MB可用
memman.free[0].size=0x07c00000;

0x07c00000是多少MB，经过计算是124MB

如果要判断是否有100KB的空间，那我们是对FREEINFO中的size进行判断

for(i=0; i<memman.frees; i++)
{
    if(memman.free[i].size >= 100*1024){
        print("找到可用空间")    
    }    
}

如果这时候找到了可用内存，我们需要进行：

memman.free[i].addr += 100*1024
memman.free[i].size -= 100*1024

如果size变成了0，那么这一段信息就不需要了，在MEMMAN的free中减去1就好，表示可用的空间减少1。

如果要释放内存则操作与上述相反就好。
现在我们看这个与一维数组管理内存的优势，在一维数组中，需要申请100MB内存时，需要对1个数组25个元素置1操作，而这个申请100MB内存话，只需要进行两步加减就好了

作者要使用的内存管理方法

如果可用空间被搞的零零散散，1000条的可用空间管理被用完时，这时候要么去增加MEMMAN中free的大小，要么把一些可用的小空间进行省略
作者认为那就把小空间舍掉吧，反正以后还可以通过内存检查找回来
最终作者创建的代码为以下

#define MEMMAN_FREES        4090
struct FREEINFO {   /* ������� */
    unsigned int addr, size;
};

struct MEMMAN {     /* �������Ǘ� */
    int frees, maxfrees, lostsize, losts;
    struct FREEINFO free[MEMMAN_FREES];
};

void memman_init(struct MEMMAN *man)
{
    man->frees = 0;         /* 可用信息数目*/
    man->maxfrees = 0;      /* 用于观察可用状况：frees的最大值*/
    man->lostsize = 0;      /* 解放失败的内存大小总和 */
    man->losts = 0;         /* 释放失败次数 */
    return;
}
unsigned int memman_total(struct MEMMAN *man)
/* 报告空余内存大小的合计 */
{
    unsigned int i, t = 0;
    for (i = 0; i < man->frees; i++) {
        t += man->free[i].size;
    }
    return t;
}
unsigned int memman_alloc(struct MEMMAN *man, unsigned int size)
/* 内存分配 */
{
    unsigned int i, a;
    for (i = 0; i < man->frees; i++) {
        if (man->free[i].size >= size) {
            a = man->free[i].addr;
            man->free[i].addr += size;
            man->free[i].size -= size;
            if (man->free[i].size == 0) {
                /* free[i]如果变成了0 */
                man->frees--;
                for (; i < man->frees; i++) {[
                    man->free[i] = man->freei + 1]; /* �\���̂̑�� */
                }
            }
            return a;
        }
    }
    return 0; /* 没有可用空间 */
}

第8行说明了最大可使用的内存区域被设定到了4000
第41行相当于移位处理，一个 i 编号在中间的空闲区域被用完了，那么后面的就要往前补，在书177页下面有详细解释

int memman_free(struct MEMMAN *man, unsigned int addr, unsigned int size)
/* 释放 */
{
    int i, j;
    /* �܂Ƃ߂₷�����l����ƁAfree[]��addr���ɕ���ł���ق������� */
    /* ������܂��A�ǂ��ɓ����ׂ��������߂� */
    for (i = 0; i < man->frees; i++) {
        if (man->free[i].addr > addr) {
            break;
        }
    }
    /* free[i - 1].addr < addr < free[i].addr */
    if (i > 0) {
        /* �O������ */
        if (man->free[i - 1].addr + man->free[i - 1].size == addr) {
            /* �O�̂����̈�ɂ܂Ƃ߂��� */
            man->free[i - 1].size += size;
            if (i < man->frees) {
                /* �������� */
                if (addr + size == man->free[i].addr) {
                    /* �Ȃ�ƌ��Ƃ��܂Ƃ߂��� */
                    man->free[i - 1].size += man->free[i].size;
                    /* man->free[i]�̍폜 */
                    /* free[i]���Ȃ��Ȃ����̂őO�ւ‚߂� */
                    man->frees--;
                    for (; i < man->frees; i++) {
                        man->free[i] = man->free[i + 1]; /* �\���̂̑�� */
                    }
                }
            }
            return 0; /* �����I�� */
        }
    }
    /* �O�Ƃ͂܂Ƃ߂��Ȃ����� */
    if (i < man->frees) {
        /* ��낪���� */
        if (addr + size == man->free[i].addr) {
            /* ���Ƃ͂܂Ƃ߂��� */
            man->free[i].addr = addr;
            man->free[i].size += size;
            return 0; /* �����I�� */
        }
    }
    /* �O�ɂ����ɂ��܂Ƃ߂��Ȃ� */
    if (man->frees < MEMMAN_FREES) {
        /* free[i]�������A���ւ��炵�āA�����܂���� */
        for (j = man->frees; j > i; j--) {
            man->free[j] = man->free[j - 1];
        }
        man->frees++;
        if (man->maxfrees < man->frees) {
            man->maxfrees = man->frees; /* �ő�l���X�V */
        }
        man->free[i].addr = addr;
        man->free[i].size = size;
        return 0; /* �����I�� */
    }
    /* ���ɂ��点�Ȃ����� */
    man->losts++;
    man->lostsize += size;
    return -1; /* ���s�I�� */
}