资讯详情

第9天：内存管理

9.1、整理文件

在指定的功能文件中写下各种函数功能，便于管理。 整理文件

9.2.检查内存容量

做内存管理，一定要知道有多少内存。

方法：将指定数据写入内存，立即取出，检查内容是否与写入内容相同。如果内存正常，读取的内容与写入的内容相同，表明内存有效。如果写入的内存异常（地址不存在或其他原因），则读取的内容将混乱，因此确定内存无效。

在486开始的CPU都有高速缓存机制，写入读出都在缓存中，内存无法测量，所以如果检查内存，CPU高速缓存在486以上时关闭。

#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是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或以下，即使是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; }

AC是EFLAGS的第18位，如果是386CPU，就没有这个标志位，一直是0。 

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) { 
         /* 一次增加4KB */
		p = (unsigned int *) (i + 0xffc); /*只检查最后四位 */
		old = *p;			/* 记住修改前的值 */
		*p = pat0;			/* 写入pat0 */
		*p ^= 0xffffffff;	/* 取反 */
		if (*p != pat1) { 
        	/* 检查取反结果是否等于pat1；不等于就结束检查 */
not_memory:
			*p = old;
			break;
		}
		*p ^= 0xffffffff;	/* 如果等于pat1，再取反 */
		if (*p != pat0) { 
        	/* 检查结果是否等于第一次写入的值；不等于就结束检查 */
			goto not_memory;
		}
		*p = old;			/* 恢复原来的值 */
	}
	return i;
}

HariMain

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 - 0x400000B。 前0x400000之前在asmhead.nas中已经使用过了。

检查结果一直都是3072MB。但是虚拟机并没有分配这多内存，这锅C编译器背，因为C编译器的优秀，它把很多认为“不必要的”程序给省略了，“提高”运行效率。 memtest_sub函数就被优化成：

unsigned int memtest_sub(unsigned int start, unsigned int end)
{ 
        
	unsigned int i;
	for (i = start; i <= end; i += 0x1000) { 
        }
	return i;
}

完全没有检查到内存，就是做了一个循环。

所以还是采用汇编来写吧：

// 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

这就对了。

9.3、内存管理

例：管理128MB内存

9.3.1、方案一：4KB单位管理

以4KB为一个单位进行管理。 128MB / 4KB = 32768 1、创建32768 Byte大小的数组，如果数组值为1，代表内存正在使用。0为未分配内存。

char a[32768];
for(i=0; i<1024; i++){ 
        //4MB正在使用
	a[i] = 1;
}
for(i=1024; i<32768; i++){ 
        //剩下未分配
	a[i] = 0;
}

如果需要分配100KB内存空间，只需要找到25个连续的0：

j = 0;
allocate:
	for(i=0; i<25; i++){ 
        
		if(a[j+i] != 0){ 
        
			j++;
			if(j<32768-25){ 
        
				goto allocate;
			}else{ 
        
				// 没有空间的了，不做分配了
			}
		}
	}

// 如果找到100KB的连续空间，就把数组置为1
for(i=0; i<25; i++){ 
        
	a[j+i] = 1;
}
// addr = j * 0x1000 处就是分配内存的开始地址

如果内存用完要释放：

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

以上是举例100KB，所以25都是写死的，实际25应该按分配大小进行计算。

9.3.2、 方案二：列表管理方法：

列表管理方法： 标记，从addr地址开始，有size大小的空间空闲。

struct FREEINFO { 
        	/* 标记 */
	unsigned int addr, size;
};

struct MEMMAN { 
        		/* 内存管理 */
	int frees;
	struct FREEINFO free[1000];
};

struct MEMMAN meman;
meman.frees = 1; // 1块空闲内存区间
meman.free[0].addr = 0x00400000; // 从0x00400000开始0x07c00000大小（124M）
meman.free[0].size = 0x07c00000;

如果分配100KB空间：

for(i = 0; i < meman.frees; i++){ 
        
	if(meman.free[i].size >= 100 *1024){ 
        
		// 有100KB空间可以分配
		"meman.free[i].addr 往后100KB可以使用"
		addr = meman.free[i].addr;
	}
}
"没有空间可以分配"

分配完成后，管理信息中需要删除这段空间：

for(i = 0; i < meman.frees; i++){ 
        
	if(meman.free[i].size >= 100 *1024){ 
        
		// 有100KB空间可以分配
		"meman.free[i].addr 往后100KB可以使用"
		addr = meman.free[i].addr;
		meman.free[i].addr += 100 * 1024; // 管理信息中删除这段内存
		meman.free[i].size -= 100 * 1024;
	}
}
"没有空间可以分配"

最后： 分配内存后，如果size = 0了，就要frees - 1，并且结构体数组前移。

释放内存后，如果不能和之前的内存合并，就要再加一条记录，同时frees + 1；如果能够合并，直接合并就好。

9.3.3、优化方案二

刚刚只设置了1000条记录，但是，如果内存太散，可能会耗光记录，那就增加一些管理记录：

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; /* 没有可用空间 */
}

释放内存：

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：


#define MEMMAN_ADDR 0x003c0000

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);

标签： tr35jbe0330电阻

锐单商城拥有海量元器件数据手册、 IC替代型号，打造 电子元器件IC百科大全！

锐单商城 - 一站式电子元器件采购平台