管理内存本质是库管（仓库管理）

整理源文件

整理bootpack.c

新建：keyboard.c和mouse.c

• wait_KBC_sendready = 从bootpack.c 移动到 keyboard.c
• nit_keyboard = 从bootpack.c 移动到 keyboard.c
• enable_mouse = 从bootpack.c 移动到mouse.c
• mouse_decode = 从bootpack.c 移动到mouse.c
• inthandler21 = 从init.c 移动到 keyboard.c
• nthandler2c = 从init.c 移动到 mouse.c

更新：bootpack.h
增加了keyborad.c和mouse.c声明

...代码省略

/* keyboard.c */
void inthandler21(int *esp);
void wait_KBC_sendready(void);
void init_keyboard(void);
extern struct FIFO8 keyfifo;
#define PORT_KEYDAT		0x0060
#define PORT_KEYCMD		0x0064

/* mouse.c */
struct MOUSE_DEC {
	unsigned char buf[3], phase;
	int x, y, btn;
};
void inthandler2c(int *esp);
void enable_mouse(struct MOUSE_DEC *mdec);
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat);
extern struct FIFO8 mousefifo;

更新：Makfile

补入了keyboard.obj mouse.obj

OBJS_BOOTPACK = bootpack.obj naskfunc.obj hankaku.obj graphic.obj dsctbl.obj \
		int.obj fifo.obj keyboard.obj mouse.obj

......代码省略

检查内存容量

• 内存多大？
• 内存范围？

往内存里写入数据时，如果先写入内存的话，在等待写入完成的期间，CPU处于空闲状态，这样就会影响速度。所以，先更新高速缓存，缓存控制电路配合内存的速度，然后再慢慢发送内存写入命令。

观察机器语言的流程会发现，9成以上的时间耗费在循环上。所谓循环，是指程序在同一个地方来回打转。所以，那个地方的内存要一遍又一遍读进来。从第2圈循环开始，那个地方的内存信息已经保存到缓存里了，就不需要执行费时的读取内存操作了，机器语言的执行速度因而得以大幅提高。

更新：bootpack.c

#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;
    /* 确认CPU是386还是486以上的 */
    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) { /* 如果是386，即使设定AC=1，AC的值还会自动回到
    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;
}

这段程序的作用：

1. 确认CPU类型386，486
2. 根据CPU类型设定参数
3. 禁止缓存（内存检查时）
4. 允许缓存

更新：naskfunc.nas

为了禁止缓存，需要对CR0寄存器进行操作，由于无法使用C语言编写，所以写道nas

_load_cr0: ; int load_cr0(void);
        MOV EAX,CR0
        RET
_store_cr0: ; void store_cr0(int cr0);
        MOV EAX,[ESP+4]
        MOV CR0,EAX
        RET

更新：naskfunc.nas

关于memtest_sub这个功能在c语言中有问题，所以用汇编语言编写，这个错误纠正过程大家看看书，这里就不细写了。

_memtest_sub: ; unsigned int memtest_sub(unsigned int start, unsigned int end)
        PUSH EDI ; （由于还要使用EBX, ESI, EDI）
        PUSH ESI
        PUSH EBX
        MOV ESI,0xaa55aa55 ; pat0 = 0xaa55aa55;
        MOV EDI,0x55aa55aa ; pat1 = 0x55aa55aa;
        MOV EAX,[ESP+12+4] ; i = start;
mts_loop:
        MOV EBX,EAX
        ADD EBX,0xffc ; p = i + 0xffc;
        MOV EDX,[EBX] ; old = *p;
        MOV [EBX],ESI ; *p = pat0;
        XOR DWORD [EBX],0xffffffff ; *p ^= 0xffffffff;
        CMP EDI,[EBX] ; if (*p != pat1) goto fin;
        JNE mts_fin
        XOR DWORD [EBX],0xffffffff ; *p ^= 0xffffffff;
        CMP ESI,[EBX] ; if (*p != pat0) goto fin;
        JNE mts_fin
        MOV [EBX],EDX ; *p = old;
        ADD EAX,0x1000 ; i += 0x1000;
        CMP EAX,[ESP+12+8] ; if (i <= end) goto mts_loop;
        JBE mts_loop
        POP EBX
        POP ESI
        POP EDI
        RET
mts_fin:
        MOV [EBX],EDX ; *p = old;
        POP EBX
        POP ESI
        POP EDI
        RET

这段代码作用：实现内存检查

1. 调查从start地址到end地址的范围内，能够使用的内存的末尾地址
2. 首先如果p不是指针，就不能指定 地址去读取内存，所以先执行“p=i;”.
3. 紧接着使用这个p，将原值保存下来（变量old）
4. 接着试写0xaa55aa55，在内存里反转该值，检查结果是否正确
5. 如果正确，就再次反转它，检查一下是否能恢复到初始值。
6. 最后，使用old变量，将内存的值恢复回去。
7. …如果在某个环节没能 恢复成预想的值，那么就在那个环节终止调查，并报告终止时的地址。

反转 = 用XOR运算来实现，其运算符是“^”。
“*p^ = 0xffffffff;”是“*p = *p^0xffffffff;”的省略形式。

更新：bootpack.c

i = memtest(0x00400000, 0xbfffffff) / (1024 * 1024);
sprintf(s, "memory %dMB", i);
putfonts8_asc(binfo->vram, binfo->scrnx, 0, 32, COL8_FFFFFF, s);

对0x00400000～0xbfffffff范围的内存进行检查。这 个程序最大可以识别3GB范围的内存。

测试：打开cmd，输入make run

文件夹09_day\harib06c

挑战内存管理

内存管理的意义？

• 内存分配：启动程序，分配空闲内存地址
• 内存释放：程序关闭，归还内存地址，以便再次分配

比如说，假设内存128MB，程序A需要100KB，画面控制需要1.2MB。像这样，需要分配一定大小的内存。为了应付这些需求，必须管理好哪些内存空闲，哪些内存正在使用，这就是内存管理。否则会变得一团糟。

内存管理方法1：

• 假设有128MB的内存（即有0x08000000个字节）。
• 假设以0x1000个字节（4KB）为单位进行管理。
• 0x08000000/0x1000 = 0x08000 = 创建32768字节区域。
• 写入0标记位空闲，写入1标记为正在使用

char a[32768];
for (i = 0; i < 1024; i++) {
		a[i] = 1; 													/* 一直到4MB为止，标记为正在使用 */
}
for (i = 1024; i < 32768; i++) {
		a[i] = 0;													 /* 剩下的全部标记为空 */
}

• 假设需要使用100kb空间
• 从a中找出连续25个标记为0的地址

j = 0;
再来一次:
for (i = 0; i < 25; i++) {
        if (a[j + i] != 0) {
                j++;
                if (j < 32768 - 25) goto 再来一次;
                "没有可用内存了";
         }
}
"从a[j]到a[j + 24]为止，标记连续为0";

• 假设找到连续25个标记为0的地址
• 暂时标记为1（正在使用）
• 然后从j值计算出对应地址
• 以0x1000字节为管理单位

for (i = 0; i < 25; i++) {
				a[j + i] = 1;
}
"从 j * 0x1000 开始的100KB空间得到分配";

• 假设要释放这部分内存空间（从0x00123000开始的100kb）
• 用0x00123000除以0x1000计算出j

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

一些bug

• 如果内存是128MB，管理表只需要32768字节（32KB）；
• 如果内存最大是3GB，0xc0000000 / 0x1000 = 0xc0000 = 786432（768KB）

如果容量是个问题，这个管理表可以不用char来构成， 而是使用位（bit）来构成。归根到底，储存的只有0和1.这样做，程序会变得复杂些，但是管理表的大小可缩减到原来的1/8。

如果是3GB内存，只需要96KB就可以管理整个内存了

内存管理方法2：

列表管理法：把类似于“从xxx 号地址开始的yyy字节的空间是空着的”这种信息都列在表里

struct FREEINFO { /* 可用状况 */
				unsigned int addr, size;
};
struct MEMMAN { /* 内存管理 */
        int frees;
        struct FREEINFO free[1000];
};
struct MEMMAN memman;
        memman.frees = 1; /* 可用状况list中只有1件 */
        memman.free[0].addr = 0x00400000; /* 从0x00400000号地址开始，有124MB可用 */
        memman.free[0].size = 0x07c00000;

之所以有1000个free，是考虑到即使可用内存部分不连续，我们也能写入到这1000个free里

• 假设需要100kb空间
• 只需查看memman中free状态
• 从中找出到100KB以上可用空间即可

for (i = 0; i < memman.frees; i++) {
      if (memman.free[i].size >= 100 * 1024) {
      "找到可用空间！";
      "从地址memman.free[i].addr开始的100KB空间，可以使用哦！";
      }
}

• 如果找到可用内存空间
• 将这段信息从“可用内存空间管理表”中删除，相当于“正在使用”
• 如果size变成了0，将这条信息删掉 除，frees减去1就可以了。

memman.free[i].addr += 100 * 1024; /* 可用地址向后推进了100KB */
memman.free[i].size -= 100 * 1024; /* 减去100KB */

• 释放内存，增加一条可用信息，frees加1
• 调查这段新释放的内存与相邻可用空间能否连到一起
• 如果能连到一起，归纳为一条
• 如果不归纳为一条，系统索要内存空间时，找不到释放的可用空间

free[0]:地址0x00400000号开始，0x00019000字节可用
free[1]:地址0x00419000号开始，0x07be7000字节可用

可以归纳为
free[0]:地址0x00400000号开始，0x07c00000字节可用

第二种内存管理方法特点：

1. 首先占用内存少。804字节管理128MB的内存。
2. 管理3GB的内存，只需8KB，为了安全起见，设定10000 条可用区域管理信息，即使这样也只有80KB。
3. 大块内存的分配和释放都非常迅速
4. 缺点是管理程序变复杂
5. 可用空间零散，要么提高空间上限，要么放弃小块内存。

作者采用的内存管理方法：

• 割舍掉的东西，只要以后还能找回 来，就暂时不去管它

更新：bootpack.c

#define MEMMAN_FREES 4090 /* 大约是32KB*/

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->free[i + 1]; /* 代入结构体 */
                                  }
                        }
                        return a;
                }
        }
        return 0; /* 没有可用空间 */
}

• struct MEMMAN，创建了4000组，这样一来，管理空间大约是32KB
• memman_init对memman进行了初始化，将frees设为0
• memman_total用来计算可用内存的合计大小并返回
• memman_alloc功能是分配指定大小的内存

man->free[i].addr = man->free[i+1].addr;
man->free[i].size = man->free[i+1].size;

我们在这里将其归纳为了：
man->free[i] = man->free[i+1];

释放内存功能

更新：bootpack.c

int memman_free(struct MEMMAN *man, unsigned int addr, unsigned int size)/* 释放 */
{
        int i, j;
        /* 为便于归纳内存，将free[]按照addr的顺序排列 */
        /* 所以，先决定应该放在哪里 */
        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) {
        /* 前面有可用内存 */
                if (man->free[i - 1].addr + man->free[i - 1].size == addr) {
                        /* 可以与前面的可用内存归纳到一起 */
                        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]变成0后归纳到前面去 */
                                        man->frees--;
                                        for (; i < man->frees; i++) {
                                       				 man->free[i] = man->free[i + 1]; /* 结构体赋值 */
                                        }
                                }
                        }
                        return 0; /* 成功完成 */
                }
        }
        /* 不能与前面的可用空间归纳到一起 */
        if (i < man->frees) {
                /* 后面还有 */
                if (addr + size == man->free[i].addr) {
                        /* 可以与后面的内容归纳到一起 */
                        man->free[i].addr = addr;
                        man->free[i].size += size;
                        return 0; /* 成功完成 */
                }
        }
        /* 既不能与前面归纳到一起，也不能与后面归纳到一起 */
        if (man->frees < MEMMAN_FREES) {
                /* free[i]之后的，向后移动，腾出一点可用空间 */
                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; /* 更新最大值 */
                }
                man->free[i].addr = addr;
                man->free[i].size = size;
                return 0; /* 成功完成 */
        }
        /* 不能往后移动 */
        man->losts++;
        man->lostsize += size;
        return -1; /* 失败 */
}

程序的解释在注释中

功能写好了要在bootpack.c中使用

#define MEMMAN_ADDR 0x003c0000
void HariMain(void)
{
        （中略）
        unsigned int memtotal;
        struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
        （中略）
        memtotal = memtest(0x00400000, 0xbfffffff);
        memman_init(memman);
        memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff */
        memman_free(memman, 0x00400000, memtotal - 0x00400000);
        （中略）
        sprintf(s, "memory %dMB free : %dKB",
        memtotal / (1024 * 1024), memman_total(memman) / 1024);
        putfonts8_asc(binfo->vram, binfo->scrnx, 0, 32, COL8_FFFFFF, s);

......代码省略

• memman需要32KB，决定使用自0x003c0000开始的 32KB
• 然后计算内存总量 memtotal，
• 将现在不用的内存以0x1000个字节为单位注册到memman 里。
• 最后，显示出合计可用内存容量。
• 在QEMU上执行时，有时会注册 成632KB和28MB。632+28672=29304，所以屏幕上会显示出29304KB。

测试：打开cmd，输入make run

管理内存是个头疼的事

今天就到这里