9 内存管理
2020.10.22-2020.10.23
今天的主要学习了内存管理的必要性和如何进行内存管理。
1. 整理源文件
文档:harib06a
暂时先把鼠标的问题放一边,今天干点别的。
bootpack.c现在已经182行了,看着不舒服,我们要稍微整理一下。将程序整理如下:
函 数 名 | 移 动 前 | 移 动 后 |
---|---|---|
wait_KBC_sendready | bootpack.c | keyboard.c |
init_keyboard | bootpack.c | keyboard.c |
enable_mouse | bootpack.c | mouse.c |
mouse_decode | bootpack.c | mouse.c |
inthandler21 | init.c | keyboard.c |
inthandler2c | init.c | mouse.c |
做的事情很简单,就是把函数放到不同的地方而已,但是如果不知道哪个函数写在什么地方可就麻烦了。所以在bootpack.h里还要加上函数声明,在Makefile的"OBJS_BOOTPACK="那里,要将keyboard.obj和mouse.obj也补进去。
OBJS_BOOTPACK = bootpack.obj naskfunc.obj hankaku.obj graphic.obj dsctbl.obj int.obj fifo.obj keyboard.obj mouse.obj
整理完后,bootpack.c就减到了86行,看起来清爽多了。
2. 内存容量检查
文档:harib06b
在进行内存管理之前,我们要首先搞清楚内存究竟有多大,范围是哪里。
在最初启动时,BIOS肯定要检查内存容量,所以我们其实问一下BIOS就能知道内存容量有多大。但是,BIOS版本不同,BIOS的调用方法也不相同,所以我们选择自己去检查内存。
下面来介绍做法。
首先,让486以后的CPU的Cache功能无效。
Cache(高速缓存):它是位于CPU与内存间的一种容量较小但速度很高的存储器。CPU的速度远高于内存,当CPU直接从内存中存取数据时要等待一定时间周期,而Cache则可以保存CPU刚用过或循环使用的一部分数据,如果CPU需要再次使用该部分数据时可从Cache中直接调用,这样就避免了重复存取数据,减少了CPU的等待时间,因而提高了系统的效率。使用Cache提高系统性能依据是程序的局部性原理。
程序的局部性原理:观察机器语言的流程会发现,8成以上的时间耗费在循环上。这意味着那个地方的内存要一遍又一遍读进来。就算是变量,也有会像"for(int i = 0; i < 100; i++) { }"这样的程序使得i所在的内存地址,一次又一次被写入。
内存检查时,往内存随便写入一个值,然后读取出来检查与写入的值是否相同。如果CPU里缓存还在运作,我们写入和读出的就不是内存而是缓存,所以我们在内存检查时要先将缓存设为OFF。具体来说,我们还得先检查CPU是不是在486以上(486以后才加入了缓存),如果是,就将缓存设为OFF。因此我们创建了以下函数memtest:
//本次的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;
}
最初对EFLAGS进行的处理是检查CPU是486以上还是386。如果是486以上,EFLAGS寄存器的第18位应该是所谓的AC标志位。如果CPU是386,那么就没有这个标志位,18位一直是0。我们有意识地把1写入到这一位,然后再读出EFLAGS的值,继而检查AC标志位是否仍为1。如果是386,即使设定AC=1,AC的值还会自动回到0。最后,将AC标志位重置为0。
将AC标志位重置为0时,用到了AND运算,那里出现了一个运算符“”,它是取反运算符,就是将所有的位都反转的意思。所以,EFLAGS_AC_BIT与0xfffbffff一样。
为了禁止缓存,还需要对CR0寄存器的29和30位置1,使用到的函数load_cr0和store_cr0与之前的情况不一样,不能用C语言来写只能用汇编语言来写,存在naskfunc.nas里。
//本次的naskfunc.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
memtest_sub函数,是内存检查处理的实现部分。
//最开始的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) { /* 检查值是否恢复 */
goto not_memory;
}
*p = old; /* 恢复为修改前的值 */
}
return i;
}
这个程序所做的是:调查从start地址到end地址的范围内,能够使用的内存的末尾地址。要做的事情很简单。首先如果p不是指针,就不能指定地址去读取内存,所以先执行“p=i;”。紧接着使用这个p,将原值保存下来(变量old)。接着试写0xaa55aa55,在内存里反转该值,检查结果是否正确。如果正确,就再次反转它,检查一下是否能回复到初始值。最后,使用old变量,将内存的值恢复回去。……如果在某个环节没能恢复成预想的值,那么就在那个环节终止调查,并报告终止时的地址。有些机型即便不进行这种检查也不会有问题。但有些机型因为芯片组和主板电路等原因,如果不做这种检查就会直接读出写入的数据,所以要反转一下。
关于反转,我们用XOR运算来实现,其运算符是“^”。
i的值每次增加4是因为每次要检查4个字节。之所以把变量命名为pat0、pat1是因为这些变量表示测试时所用的几种形式。
上述这个程序执行起来特别慢,所以又做了点修改:
//本次的bootpack.c节选
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; /* 先记住修改前的值 */
改变的内容只是for 语句中i 的增值部分以及p的赋值部分。每次只增加4,就要检查全部内存,速度太慢了,所以改成了每次增加0x1000,相当于4KB,这样一来速度就提高了1000倍。p的赋值计算式也变了,这是因为,如果不进行任何改变仍写作“p=i;”的话,程序就会只检查4KB最开头的4个字节。所以要改为“p=i + 0xffc;”,让它只检查末尾的4个字节。
毕竟在系统启动时内存已经被仔细检查过了,所以像这次这样,目的只是确认容量的话,做到如此程度就足够了。甚至可以说每次检查1MB都没什么问题。
下面来改造HariMain函数,添加的程序如下:
//本次的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范围的内存。0x00400000号以前的内存已经被使用了(参考内存分布图),没有内存,程序根本运行不到这里,所以我们没做内存检查。如果以byte或KB为单位来显示结果不容易看明白,所以我们以MB为单位。
也不知道能不能正常运行。如果在QEMU上运行,根据模拟器的设定,内存应该为32MB。运行“make run”。
内存容量怎么不是32MB,而是3072MB?这不就是3GB吗?为什么会失败呢?明明已经将缓冲OFF掉了。
编译器太过优秀导致BUG
文档:harib06c
程序本身肯定是没有错误的。经过多方调查,终于搞清楚了原因。如果我们不用“make run”,而是用“make -r bootpack.nas”来运行的话,就可以确认bootpack.c被编译成了什么样的机器语言。用文本编辑器看一看生成的bootpack.nas会发现,最下边有memtest_sub的编译结果。我们将编译结果列在下面:
;harib06b中,memtest_sub的编译结果
_memtest_sub:
PUSH EBP ; C编译器的固定语句
MOV EBP,ESP
MOV EDX,DWORD [12+EBP] ; EDX = end;
MOV EAX,DWORD [8+EBP] ; EAX = start; /* EAX是i */
CMP EAX,EDX ; if (EAX > EDX) goto L30;
JA L30
L36:
L34:
ADD EAX,4096 ; EAX += 0x1000;
CMP EAX,EDX ; if (EAX <= EDX) goto L36;
JBE L36
L30:
POP EBP ; 接收前文中PUSH的EBP
RET ; return;
对比回memtest_sub的内容发现少了for语句中间的处理指令。
//harib06b中,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 += 0x1000) {
p = (unsigned int *) (i + 0xffc);
old = *p; /* 先记住修改前的值 */
*p = pat0; /* 试写 */
*p ^= 0xffffffff; /* 反转 */
if (*p != pat1) { /* 检查反转结果 */
not_memory:
*p = old;
break;
}
*p ^= 0xffffffff; /* 再次反转 */
if (*p != pat0) { /* 检查值是否恢复 */
goto not_memory;
}
*p = old; /* 恢复为修改前的值 */
}
return i;
}
**怪不得显示结果是3GB,那到底为为什么会这样呢?**问题就出在编译器太过优秀。
编译器在编译时,应该是按下面思路考虑问题的。
-
首先将内存的内容保存到old里,然后写入pat0的值,再反转,最后跟pat1进行比较。这不是肯定相等的吗?if语句不成立,得不到执
行,所以把它删掉。怎么?下面还要反转吗?这家伙好像就喜欢反转。这次是不是要比较*p和pat0呀?这不是也肯定相等吗?这些处
理不是多余么?为了提高速度,将这部分也删掉吧。这样一来,程序就变成了//编译器脑中所想的(1) 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; /* 先记住修改前的值*/ *p = pat0; /* 试写 */ *p ^= 0xffffffff; /* 反转 */ *p ^= 0xffffffff; /* 再次反转 */ *p = old; /* 恢复为修改前的值 */ } return i; }
-
反转了两次会变回之前的状态,所以这些处理也可以不要嘛。因此程序就变成了这样:
//编译器脑中所想的(2) 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; /* 先记住修改前的值 */ *p = pat0; /* 试写 */ *p = old; /* 恢复为修改前的值 */ } return i; }
-
还有,“*p = pat0;”本来就没有意义嘛。反正要将old的值赋给 *p。因此程序就变成了:
//编译器脑中所想的(3) 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; /* 先记住修改前的值 */ *p = old; /* 恢复为修改前的值 */ } return i; }
-
这程序是什么嘛?结果,*p里面不是没写进任何内容吗?这有什么意义?
//编译器脑中所想的(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); } return i; }
-
这里的地址变量p,虽然计算了地址,却一次也没有用到。这么说来,old、pat0、pat1也都是用不到的变量。全部都舍弃掉吧。
//编译器脑中所想的(5) unsigned int memtest_sub(unsigned int start, unsigned int end) { unsigned int i; for (i = start; i <= end; i += 0x1000) { } return i; }
根据以上编译器的思路,我们可以看出,它进行了最优化处理。但其实这个工作本来是不需要的。用于应用程序的C编译器,根本想不到会对没有内存的地方进行读写。
如果更改编译选项,是可以停止最优化处理的。可是在其他地方,我们还是需要如此考虑周密的最优化处理的,所以不想更改编译选项。那怎样来解决这个问题呢?想来想去,还是觉得很麻烦,于是决定memtest_sub也用汇编来写算了。
这次C编译器只是好心干了坏事,但意外的是,它居然会考虑得如此周到、缜密来进行最优化处理……这个编译器真是聪明啊!顺便说一句,这种事偶尔还会有的,所以能够看见中途结果很有用。而且懂汇编语言很重要。
汇编语言写的程序如下:
;本次的naskfunc.nas节选
_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
试运行一下
结果正确!
3. 挑战内存管理
文档:harib06d
一直提到内存管理这个词,到底什么是内存管理呢?为什么要进行内存管理呢?
比如说,假设内存大小是128MB,应用程序A暂时需要100KB,画面控制需要1.2MB……,像这样,操作系统在工作中,有时需要分配一定大小的内存,用完以后又不再需要,这种事会频繁发生。为了应付这些需求,必须恰当管理好哪些内存可以使用(哪些内存空闲),哪些内存不可以使用(正在使用),这就是内存管理。如果不进行管理,系统会变得一塌糊涂,要么不知道哪里可用,要么多个应用程序使用同一地址的内存。
内存管理的基础,一是内存分配,一是内存释放。“现在要启动应用程序B了,需要84KB内存,哪儿空着呢?”如果问内存管理程序这么一个问题,内存管理程序就会给出一个能够自由使用的84KB的内存地址,这就是内存分配。另一方面,“内存使用完了,现在把内存归还给内存管理程序”,这一过程就是内存的释放过程。
先假设有128MB的内存吧。也就是说,有0x08000000个字节。另外我们假设以0x1000个字节(4KB)为单位进行管理。大家会如何管理呢?答案有很多,我们从简单的方法开始介绍。
0x08000000/0x1000 = 0x08000 = 32768,所以首先我们来创建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;
again:
for (i = 0; i < 25; i++) {
if (a[j + i] != 0) {
j++;
if (j < 32768 - 25) goto again;
//"没有可用内存了";
}
}
//从a[j]到a[j + 24]为止,标记连续为0;
如果找到了标记连续为0的地方,暂时将这些地方标记为“正在使用”,然后从j的值计算出对应的地址。这次是以0x1000字节为管理单位的,所以将j放大0x1000倍就行了。
for (i = 0; i < 25; i++) {
a[j + i] = 1;
}
//从j*0x1000 开始的100KB空间得到分配;
如果要释放这部分内存空间,可以像下面这样做。比如,如果遇到这种情况:“刚才取得的从0x00123000开始的100KB,已经不用了,现在归还。谢谢你呀。”那该怎么办呢?用地址值除以0x1000,计算出j就可以了。
j = 0x00123000 / 0x1000;
for (i = 0; i < 25; i++) {
a[j + i] = 0;
}
很简单吧。以后再有需要内存的时候,这个地方又可以再次被使用了。
上面这个方法虽然很好懂,但是有一点问题。如果内存是128MB,管理表只需要32768字节(32KB);如果内存最大是3GB,管理表是多大呢?0xc0000000 / 0x1000 = 0xc0000 = 786432,也就是说光管理表就需要768KB。当然,虽说768KB不小,但从3GB看来,只不过是0.02%。
事实上,0.02%的比例是与容量没有关系的。用32KB管理128MB时,比例也是0.02%。如果容量是个问题,这个管理表可以不用char来构成,而是使用位(bit)来构成。归根到底,储存的只有0和1,用不了一个字节,一位就够了。这样做,程序会变得复杂些,但是管理表的大小可缩减到原来的1/8。如果是3GB内存,只需要96KB就可以管理整个内存了。这个比例只有0.003%。
我们后面还会讲到,这虽然不是最好的方法,但Windows的软盘管理方法,与这个方法很接近(1.44MB的容量,以512字节为单位分块管理)。
除了这个管理方法之外,还有一种列表管理的方法,是把类似于“从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里。memman是笔者起的名字,代表memory manager。比如,如果需要100KB的空间,只要查看memman中free的状况,从中找到100MB以上的可用空间就行了。
for (i = 0; i < memman.frees; i++) {
if (memman.free[i].size >= 100 * 1024) {
//"找到可用空间!";
//"从地址memman.free[i].addr开始的100KB空间,可以使用哦!";
}
} //"没有可用空间";
如果找到了可用内存空间,就将这一段信息从“可用内存空间管理表”中删除。这相当于给这一段内存贴上了“正在使用”的标签。
memman.free[i].addr += 100 * 1024; /* 可用地址向后推进了100KB */
memman.free[i].size -= 100 * 1024; /* 减去100KB */
如果size变成了0,那么这一段可用信息就不再需要了,将这条信息删除,frees减去1就可以了。
释放内存时,增加一条可用信息,frees加1。而且,还要调查一下这段新释放出来的内存,与相邻的可用空间能不能连到一起。如果能连到一起,就把它们归纳为一条。
能够归纳为一条的例子:
free[0]:地址0x00400000号开始,0x00019000字节可用
free[1]:地址0x00419000号开始,0x07be7000字节可用
可以归纳为
free[0]:地址0x00400000号开始,0x07c00000字节可用
如果不将它们归纳为一条,以后系统要求“请给我提供0x07bf0000字节的内存”时,本来有这么多的可用空间,但以先前的查找程序却会找不到。
上述新方法的优点,首先就是占用内存少。memman是8×1000 + 4 =8004,还不到8KB。与上一种方法的32KB相比,差得可不少。而且,这里的1000是个很充裕的数字。可用空间不可能如此零碎分散(当然,这与内存的使用方法有关)。所以,这个数字或许能降到100。这样的话,只要804字节就能管理128MB的内存了。
如果用这种新方法,就算是管理3GB的内存,也只需要8KB左右就够了。当然,可用内存可能更零碎些,为了安全起见,也可以设定10000条可用区域管理信息。即使这样也只有80KB。
这样新方法,还有其他优点,那就是大块内存的分配和释放都非常迅速。比如我们考虑分配10MB内存的情形。如果按前一种方法,就要写入2560个“内存正在使用”的标记“1”,而释放内存时,要写入2560个“0”。这些都需要花费很长的时间。
另一方面,这种新方法在分配内存时,只要加法运算和减法运算各执行一次就结束了。不管是10MB也好,100MB也好,还是40KB,任何情况都一样。释放内存的时候虽然没那么快,但是与写入2560个“0”相比,速度快得可以用“一瞬间”来形容。
事情总是有两面性的占用内存少,分配和释放内存速度快,现在看起来全是优点,但是实际上也有缺点,首先是管理程序变复杂了。特别是将可用信息归纳到一起的处理,变得相当复杂。
还有一个缺点是,当可用空间被搞得零零散散,怎么都归纳不到一块儿时,会将1000条可用空间管理信息全部用完。虽然可以认为这几乎不会发生,但也不能保证绝对不能发生。这种情况下,要么做一个更大的MEMMAN,要么就只能割舍掉小块内存。被割舍掉的这部分内存,虽然实际上空着,但是却被误认为正在使用,而再也不能使用。
为了解决这一问题,实际上操作系统想尽了各种办法。有一种办法是,暂时先割舍掉,当memman有空余时,再对使用中的内存进行检查,将割舍掉的那部分内容再捡回来。还有一种方法是,如果可用内存太零碎了,就自动切换到之前那种管理方法。那么,我们的“纸娃娃系统”(haribote OS)会采用什么办法呢?笔者经过斟酌,采用了这样一种做法,即“割舍掉的东西,只要以后还能找回来,就暂时不去管它。”。如果我们陷在这个问题上不能自拔,花上好几天时间,大家就会厌烦的。笔者还是希望大家能开开心心心地开发“纸娃娃系统”。而且万一出了问题,到时候我们再回过头来重新修正内存管理程序也可以。
根据这种思路,笔者首先创建了以下程序。
//本次的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,只有1000组的话,可能不够。所以,我们创建了4000组,留出不少余量。这样一来,管理空间大约是32KB。其中还有变量 maxfrees、lostsize、losts等,这些变量与管理本身没有关系,不用在意它们。如果特别想了解的话,可以看看函数memman_init的注释,里面有介绍。
函数memman_init对memman进行了初始化,设定为空。主要工作,是将frees设为0,而其他的都是附属性设定。这里的init,是initialize(初始化)的缩写。
函数memman_total用来计算可用内存的合计大小并返回。笔者觉得有这个功能应该很方便,所以就创建了这么一个函数。原理很简单,不用解释大家也会明白。total这个英文单词,是“合计”的意思。最后的memman_alloc函数,功能是分配指定大小的内存。除了free[i].size变为0时的处理以外的部分,在前面已经说过了。alloc是英文allocate(分配)的缩写。在编程中,需要分配内存空间时,常常会使用allocate这个词。
memman_alloc函数中free[i].size等于0的处理,与FIFO缓冲区的处理方法很相似,要进行移位处理。
man->free[i] = man->free[i+1]; 这种方法被称为结构体赋值,其使用方法如上所示,可以写成简单的形式。
释放内存函数,也就是往memman里追加可用内存信息的函数,稍微有点复杂。
//本次的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; /* 失败 */
}
程序太长了,用文字来描述不易于理解,所以笔者在程序里加了注释。如果理解了以前讲解的原理,现在只要细细读一读程序,大家肯定能看懂。另外,我们前面已经说过,如果可用信息表满了,就按照舍去之后带来损失最小的原则进行割舍。但是在这个程序里,我们并没有对损失程度进行比较,而是舍去了刚刚进来的可用信息,这只是为了图个方便。
最后,将这个程序应用于HariMain,结果就变成了下面这样。
写着“(中略)”的部分,笔者没做修改。
//本次的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(0x00300000号地址以后,今后的程序即使有所增加,预计也不
会到达0x003c0000,所以我们使用这一数值),然后计算内存总量memtotal,将现在不用的内存以0x1000个字节为单位注册到memman
里。最后,显示出合计可用内存容量。在QEMU上执行时,有时会注册成632KB和28MB。632+28672=29304,所以屏幕上会显示出29304KB。
那好,运行一下“make run”看看。哦,运行正常。
### 按0x1000B分配内存
文档:harib07a
bootpack.c已经有254行了,整理一下分出一部分到memory.c中去,bootpack.c剩下95行。
如今的memman_alloc和memman_free以1B为单位进行内存管理,在反复进行内存分配和内存释放之后,内存中就会出现许多外部碎片,即很多不连续的小段未使用空间,慢慢把man->frees消耗完。(内存分配太小会产生外部碎片,分配太大又容易产生外部碎片。)
因此我们决定按0x1000B (4KB) 固定大小分配内存和释放内存,把指定的内存大小按0x1000B为单位round up(向上舍入)。
//本次的*memory.c节选
unsigned int memman_alloc_4k(struct MEMMAN *man, unsigned int size)
{
unsigned int a;
size = (size + 0xfff) & 0xfffff000;
a = memman_alloc(man, size);
return a;
}
int memman_free_4k(struct MEMMAN *man, unsigned int addr, unsigned int size)
{
int i;
size = (size + 0xfff) & 0xfffff000;
i = memman_free(man, addr, size);
return i;
}
round up:
以0x1000为单位对0x12345678进行round up结果为0x12346000,用程序表达这个过程
i = (i & 0xfffff000) + 0x1000;
上述这个例子看起来不错,但其实是错的。当 i = 0x12345000,程序运行结果为0x12346000,显然不对。
所以进行改进,先判断最后几位是否为全0,全0就什么都不做。
if = (i & 0xfff != 0) {
i = (i & 0xfffff000) + 0x1000;
}
再改进一下:
i = (i + 0xfff) & 0xfffff000;
实际上,这是加上0xfff后round down(向下舍入)。
其实加上0xfff就是为了判断进位,如果最后三位不是0就会向前进位,再round down之后round up就成了。
拿十进制数举例,183加99后再round down就是200,而100加99后再round down就是100。
我们这次的memman_alloc和memman_free函数就使用了这种小技巧。
明天见!