快捷搜索：  汽车  科技
当前位置： 爱玩科技 > 科技 > 正文

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）

威哥 461

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）更新：bootpack.c观察机器语言的流程会发现，9成以上的时间耗费在循环上。所谓循环，是指程序在同一个地方来回打转。所以，那个地方的内存要一遍又一遍读进来。从第2圈循环开始，那个地方的内存信息已经保存到缓存里了，就不需要执行费时的读取内存操作了，机器语言的执行速度因而得以大幅提高。...代码省略 /* 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] pha

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(1)

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

整理源文件

整理bootpack.c

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(2)

新建：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

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(3)

更新：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;

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(4)

更新：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 ......代码省略

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(5)

检查内存容量
  • 内存多大？
  • 内存范围？

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

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

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(6)

更新：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. 允许缓存

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(7)

更新：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

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(8)

更新：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;”的省略形式。

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(9)

更新：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

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(10)

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(11)

挑战内存管理

内存管理的意义？

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

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

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(12)

内存管理方法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就可以管理整个内存了

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(13)

内存管理方法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. 可用空间零散，要么提高空间上限，要么放弃小块内存。

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(14)

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

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

更新：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。

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(15)

测试：打开cmd，输入make run

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(16)

管理内存是个头疼的事

今天就到这里

常见的几种内存管理机制（内存管理30天自制操作系统学习笔记）(17)

网站首页

返回栏目

猜您喜欢：

相关文章