操作系统---内存

目录

程序运行的机制

程序的运行方法---指令识别

逻辑地址和实际地址

写程序到程序运行

装入的三种方式,地址转换

链接的三种方式

 内存管理

 内存保护

设置上、下限寄存器

设置重定位寄存器和界地址寄存器

内存空间的分配与回收

连续分配方式

1、单一连续分配方式

2、固定分区分配

3、动态分区分配

 操作系统如何选择空闲区来给进程分配空间---动态分区分配算法

1、首次适应算法

2、最佳适应算法

3、最坏适应算法

4、邻近适应算法(循环首次适应算法)

 5、内部碎片和外部碎片的概念

4、基本分页存储管理

页表

基本地址变化机制

具有块表的基本地址变化机制

两级页表

5、基本分段存储管理

6、段页式存储管理

  内存扩充

1、覆盖技术

2、交换技术

3、虚拟内存技术

 虚拟内存

 请求分页管理方式

页面置换算法

最佳置换算法(OPT)

先进先出置换算法(FCFO)

最近最久未使用置换算法(LRU)

时钟置换算法(CLOCK)

改进后的时钟置换算法(CLOCK)

页面分配策略

驻留集

 调入页面的时机

从何处调入页面

页面抖动(颠簸)

工作集


内存:是存放数据的硬件,所有程序运行时都是要加载进入内存,程序在内存中才可以被CPU处理

内存有一个,但是程序不一定只有一个,多个程序的数据存储在一块内存中,如何确定这个程序的数据在内存的哪里存放呢?

存储单元:类似于酒店的房间,我们可以给内存划分成一个个的房间,这些房间就是存储单元

内存地址:为了方便管理,酒店房间会有编号,相应的,内存的存储单元也可以有编号,这个编号就是地址

每一个地址对应一个存储单元

程序运行的机制

程序的运行方法---指令识别

逻辑地址和实际地址

编译时期,程序数据的实际存放地址是未知的,我们知道的只会是逻辑地址

例如,逻辑上x的存放地址是0,但是实际存放中0的位置被占有了,那么x就要后移到1,地址1就是实际地址,0就是逻辑地址

写程序到程序运行

编译: 程序员写好的代码文件会经过编译,形成机器可以识别的二进制语言,这些二进制语言打包在目标文件里(c语言是.o文件,java就是.class文件),这些目标文件有自己独立的逻辑地址

链接:链接就是将编译后形成的一组目标文件和其所需的库函数等资源打包到一起,形成一个完整的装入模块,这个装入模块有自己独立的逻辑地址

装入:装入就是将链接形成的装入模块放入内存(逻辑地址到物理地址的转化)

装入的三种方式,地址转换

1、绝对装入

在装入之前,就已经知道程序要在内存中存放的绝对地址

 但是,绝对装入只有在单道程序环境下使用,因为这时内存只会有一个程序,从而可以知道内存可以装入代码的起始地址,才可以知道其实际地址

2、静态重定位

装入时就会实现逻辑地址到物理地址的转化,装入模块会根据内存的实际情况,自动调整装入位置

 静态重定位会让内存给作业分配全部空间,如果空间不够,就不能装入作业

作业在装入之后,地址空间就不会改变了

3、动态重定位(现代操作系统)

只有程序运行时,才会将逻辑地址转化为物理地址

需要一个重定位寄存器实现

 允许作业在内存中移动 (作业的重定位寄存器的值更改,那么作业的物理地址也会改变)

链接的三种方式

1、静态链接

将目标文件和所需的库函数连接称为一个完整的装入模块(形成一个完整的逻辑地址)之后不再拆开,装入程序将装入模块放入内存

2、装入时动态链接

将目标文件和所需的库函数一边装入内存,一边进行连接

 3、运行时动态链接

程序运行时需要哪一个目标文件,就选择这个目标文件放入内存并链接

 内存管理

操作系统肯定要管理内存,那么操作系统需要完成哪些工作呢?

1、操作系统负责内存的分配与回收:程序想要运行,就需要加载进入内存,那么操作系统如何知道给这个程序分配哪一块的空间呢?程序运行结束,要如何释放程序所占用的内存空间呢?

2、操作系统需要提供技术来从逻辑上扩充内存空间:一个游戏,内存可能有20G,电脑才有4G的内存,这个游戏要运行,肯定要加载进入内存,但是20G的大小是如何放入4G内存的呢?这就要涉及到虚拟技术

3、操作系统要实现逻辑地址到物理地址的转换:三种装入方式

4、操作系统要实现内存保护:操作系统要保证一个进程不会访问到别的内存空间

 内存保护

设置上、下限寄存器

1、设置上、下限寄存器存储进程物理地址的开始和结束位置(针对于物理地址的判断)

设置重定位寄存器和界地址寄存器

2、设置重定位寄存器和界地址寄存器(针对于逻辑地址的判断)

重定位寄存器:存储物理地址的起始位置;界地址寄存器:存放最大的逻辑地址

通过界地址寄存器,可以判断请求访问的逻辑地址是否越界,根据重定位寄存器可以从逻辑地址得到物理地址

内存空间的分配与回收

连续分配方式

产生连续的内存空间

1、单一连续分配方式

单一连续分配方式中,内存被分为系统区(低地址部分,存放操作系统相关数据)和用户区(高地址部分,存放用户进程数据)

内存中同一时刻只能有一道用户程序,这个程序独占用户区

优点:实现简单;可以利用覆盖技术实现扩充内存

缺点:空间浪费,只支持单道程序系统

2、固定分区分配

将内存划分为固定大小的分区,每一个分区只能装入一道作业

根据分区大小是否相等,可以分为:分区大小相等和分区大小不相等

分区大小相等:那么如果占有空间很小的进程,会占用一个分区,每个分区的大小过大,会造成内存空间的浪费(内部碎片),每个分区的大小过小,大进程又装不下

分区大小不相等:相比上一个,增加空间设置的灵活性

操作系统如何管理这些分区呢?

创建一个数据结构---分区说明表,如下所示:

3、动态分区分配

根据进程的空间要求,动态的划分内存空间

 1、操作系统如何管理这些分区呢?

 2、操作系统如何选择空闲区来给进程分配空间---动态分区分配算法

1、首次适应算法

原则:按照地址递增的顺序,找到第一个可以满足空间要求的空闲分区

实现:空闲分区表按照地址递增的顺序存储

缺点:每次都要从第一个位置开始查找,查找效率低下,产生外部碎片

2、最佳适应算法

原则:找到满足空间要求且空闲分区大小最小的空闲分区

实现:空闲分区表按照容量递增的顺序存储

 缺点:每次选择的都是最小的可以满足要求的空闲分区,产生外部碎片

3、最坏适应算法

为了解决最佳适应算法的问题而提出了最坏适应算法

原则:找到满足空间要求且空闲分区大小最大的空闲分区

实现:空闲分区表按照容量递减的顺序存储

 缺点:不断分裂大分区,导致大进程没有可以被存储的空间

4、邻近适应算法(循环首次适应算法)

为了解决首次适应算法查找速度慢的问题而提出

原则:按照地址递增的顺序,找到第一个可以满足空间要求的空闲分区

实现:空闲分区表按照地址递增的顺序存储,为了提高效率,可以从上一次查找结束之后的位置开始查找

缺点:可能分裂大分区,导致大进程没有可以被存储的空间

 内部碎片和外部碎片的概念

内部碎片:一个分区内,分配给某一个进程的空间没有用完

外部碎片:内存内,某些区间太小而无法使用

动态内存分配:没有内部碎片,但是会有外部碎片

解决办法:紧凑法:移动进程空间,腾出大的空闲空间 

3、操作系统如何分配和回收空间

将连续的空闲区合并,避免空间浪费


以上的3种方法分配的都是连续的内存空间,称之为连续分配管理方式,但是,固定区间分配会产生内部碎片,动态区间分配会产生外部碎片

那我们是不是可以在内存中给作业申请非连续空间来解决碎片问题呢?这个称之为非连续分配管理方式,或者称为离散分配方式

4、基本分页存储管理

以上的这个思想就是基本分页存储管理的实现原理:

内存划分为大小相等的分区,每一个分区称之为“页框”,每一个页框会有一个编号(页框号),编号从0开始

用户进程划分为一个个大小和页框相等的区域,每一个区域称之为:”页“,每一个页会有一个编号(页号),编号从0开始

操作系统会以页框为单位给进程分配空间,用户进程的每一个页面进入内存的每一个页框中

页框不能太大,否则会产生大的内部碎片

如何装入:实现逻辑地址到物理地址的转化?

为了计算机的方便,我们会将页面大小,设置为2的整数幂大小

使用32个二进制存储,那么前面20位(红色)部分对应的是页号,后12位(黑色)表示页内偏移量

也就是说,逻辑地址包括两部分:页号和页内偏移量;一个页面(页号固定)的大小由页内偏移量决定:一个页面包含的是n个逻辑地址,这个n=2^k(k是页内偏移量的二进制位数);一个进程的页面个数由页号决定

如果有k位表示页内偏移量(页地址数),那么系统的一个页面大小2^k

如果有M位表示页号,那么一个进程最多有页面2^M个

1、页号:逻辑地址/页面长度(80/50=1)

2、偏移量:逻辑地址%页面长度(80%50=30)

3、起始物理地址:操作系统需要提供某一种数据结构来组织存储各个页面的起始物理地址

4、物理地址=起始物理地址+偏移量

页表

起始物理地址:操作系统需要提供某一种数据结构来组织存储各个页面的起始物理地址,这个数据结构是页表

 先计算出逻辑空间对应的页号,在页表内查询到块号,这个块号对应着内存的页框号,根据页框号*内存给每个页框设置的固定长度,就可以得到起始物理地址

基本地址变化机制

基本地址变化机制借助页表,实现逻辑地址到物理地址的转化 

设置页表寄存器这一个结构,用于存储页表在内存的起始地址和页表长度,在进程没有执行时,页表在内存的起始地址和页表长度(页表有多少页)存放在PCB中,进程一旦开始调度,页表在内存的起始地址和页表长度,就会存储在页表寄存器中

1、进程没有被调度,PCB存储进程的信息,包括页表在内存的起始地址和页表长度

2、进程被调度,PCB将内存的起始地址和页表长度信息交给页表寄存器

3、根据逻辑地址计算得到页号(逻辑地址/页表内存大小)和页内偏移量(逻辑地址%页表内存大小)

4、页表寄存器根据页表长(页表数目的多少)判断是否查询越界,没有越界,那么由于每一个页表的长度是固定的且页表号是递增的,根据页表在内存的起始地址和页号可以得到逻辑地址所在页面的起始物理地址,根据页内偏移量最终得到实际的物理地址

5、给定逻辑地址就可以决定物理地址,地址是一维的

具有块表的基本地址变化机制

1、局部性原理

时间局部性:一个指令执行后,不久后被再次访问;一个数据被访问过,不久后这个数据被再次访问

空间局部性:一个程序访问过某一个存储单元,不久后,这个存储单元的附近存储单元也被访问

 由于局部性原理,极有可能一直访问的都是同一个页面,那么就会造成页表的多次不必要的查询,那么如何增加效率呢?为了解决这个问题,引入了快表机制

这就借助了高速缓冲的思想:将近期频繁使用的数据放到更高一级的存储器中

2、快表

快表,又可以称为联想寄存器,简称(TLB),是一种访问速度比内存快的高度缓冲存储器,用于存放当前访问的若干页表项,来加速地址转化的速度;与此对应,内存中页表的访问速度慢,称为慢表

 如果命中快表,可以不必对慢表进行访问,只需要计算出实际地址访问内存

 如果没命中快表,需要对慢表进行访问,同时将信息记入快表,计算出实际地址访问内存

3、两级页表

对于上面提供的单级页表这一数据结构,有两个缺点:1、单级页表要在内存中连续存储:根据页表号计算当前页表号对应的起始地址,就要求页表号是递增的,连续存储的;一旦这个页表内存申请过大,就不太容易在内存中找到连续且足够大的空间存储页表,况且这就失去了离散分配方式的意义2、单极页表的全部信息可能只需要那么几行,不需要全部存储在内存,浪费内存空间

为了解决这两个问题,提出了两级页表

如何解决问题一:参考解决进程连续分布的方法:将进程地址分页,建立页表,离散存储进程;那么可以将连续的页表分页,再次建立页表(称为页目录表或者外层页表),离散存储连续的页表

1、将连续的页表分页

 2、再次建立页表(称为页目录表或者外层页表),离散存储连续的页表

 如何解决问题二:在需要访问页面时,才将这个页面其调入内存;在页表项中增加标志位,用于标志这个页面是否进入内存

1、采用多级页表机制,每一级页表的大小不能超过一个页面

5、基本分段存储管理

进程的地址空间:根据程序的自身逻辑关系划分为多个段,每段从0开始编址

内存分配原则:根据段来分配,段之间连续分配,段和段之间离散分配

 分段系统的逻辑结构:由段号和段内偏移量构成

如果有k位表示段内偏移量,那么系统的一个段大小2^k

如果有M位表示段号,那么一个进程最多有段2^M个

段表:记录段存入内存的信息 

和页表相比,页表中每一个页的长度是系统的,一个段的长度是不一定的,需要显示记录段长

段表结构:

段表实现逻辑地址到物理地址的转化: 

 分页,分段管理的对比:

1、页是信息在物理上的存储,实现分页管理,主要就是实现离散分配,提高内存利用率。对用户不可见

2、段是信息的逻辑存储,实现分段管理,主要就是更好的服务用户,满足用户需求,一个段通常包含一个逻辑模块的信息,用户编程时要提供段名,对用户可见

 3、页的大小是固定的,由系统决定;段的大小不固定,取决于一个模块的信息,由用户编写的代码决定

4、分页管理,用户只需要给定一个地址就可以,地址是一维的;分段管理,需要用户给定地址和段名,地址是二维的

5、分页管理,产生内部碎片无外部碎片;分段管理,产生外部碎片无内部碎片

6、分页比分段更容易实现对于信息的共享和保护

6、段页式存储管理

先将用户进程分段,后分页

 逻辑地址结构由段号,页号,页内偏移量组成

段表、页表结构:

实现逻辑地址到物理地址的转化: 

 

  内存扩充

所谓的内存扩充,并不是指增加系统的物理内存,而是指在现有内存的基础上增加内存的使用率

1、覆盖技术

覆盖技术的思想:将程序分为多个段(模块),常用的段常驻内存,不常用的段就可以调出内存

内存将分为“固定区”和“覆盖区”

固定区:存放常用的段,程序运行期间内不会调出

覆盖区:存放不常用的段,程序运行期间内需要的时候调入,不需要的时候调出

缺点:程序的调用(覆盖)结构需要程序员自己声明,操作系统有了覆盖结构之后才能实现覆盖;对用户不透明,增加了用户的编程负担

2、交换技术

当系统的内存空间紧张的时候,系统可以将某些进程暂时调出内存,存入外存,也可以将外存中具备运行条件的进程换入内存(进程在内存和磁盘的交换)

处理机调度中的中级调度!!!

进程的PCB常驻内存

1、外存的哪些地方存放被换出的进程

具有对换功能的操作系统,会将外存(磁盘)分为两个区域:对换区和文件区;文件区用于存放文件,要求提高存储空间的利用率,采用离散分配方式管理文件区,对换区用于存放被内存换出的进程,主要追求换入换出的速度,采用连续分配方式;总之,对换区的I/O速度快于文件区

2、什么时候进程交换

换出一般出现于内存不足时,换入发生在内存空间充足且外存中具备运行条件的进程才可以换入

3、可以换出哪些进程

例如:优先级低的进程,阻塞的进程等

3、虚拟内存技术

 

 虚拟内存

根据局部性原理,我们可以在装入程序时,内存装入很快需要的部分,暂时不用的数据就留在外存

操作系统在程序运行期间,负责数据的换入换出,在用户看来,自己使用的内存很多,这就是虚拟内存

虚拟内存的最大容量和实际容量

虚拟内存的最大容量由计算机的地址结构决定

虚拟内存的实际容量是(内存+外存)和最大容量的最小值

使用虚拟内存之后,呈现:1、多次性:一个作业可以被分为多次调入内存2、对换性:操作系统在程序运行期间,负责数据的换入换出3、虚拟性:在用户看来,自己使用的内存很多,这就是虚拟内存

虚拟内存技术基于离散分配方式!!!

 请求分页管理方式

 在基本分页管理方式上的拓展

请求分页系统建立在基本分页系统基础之上,为了支持虚拟存储器功能而增加了请求调页功能和页面置换功能。请求分页是目前最常用的一种实现虚拟存储器的方法。

在请求分页系统中,只要求将当前需要的一部分页面装入内存,便可以启动作业运行。在作业执行过程中,当所要访问的页面不在内存时,再通过调页功能将其调入,同时还可以通过置换功能将暂时不用的页面换出到外存上,以便腾出内存空间。


为了实现请求分页,系统必须提供一定的硬件支持。除了需要一定容量的内存及外存的计算机系统,还需要有页表机制、缺页中断机构和地址变换机构。

页表结构

 缺页中断机制

当想要访问的页面不在内存时,需要请求将页面调入内存;这时会产生缺页中断,将进程加入阻塞队列,直到缺页中断程序处理完成,将页面调入内存,进程才会被唤醒,进入就绪队列

1、如果内存中有空闲位置,那么将页面加载进入内存

2、如果内存中没有空闲位置,使用页面置换,淘汰一个页面(如果这个页面的数据被修改过,那么数据要写回外存),然后将页面调入内存

缺页中断作为中断同样要经历,诸如保护CPU环境、分析中断原因、转入缺页中断处理程序、恢复CPU环境等几个步骤。但与一般的中断相比,它有以下两个明显的区别:

  • 在指令执行期间产生和处理中断信号,而非一条指令执行完后,属于内部中断。
  • 一条指令在执行期间,可能产生多次缺页中断。

地址变换机构

请求分页系统中的地址变换机构,是在分页系统地址变换机构的基础上,为实现虚拟内存,又增加了某些功能而形成的。

 在进行地址变换时,先检索快表:

  • 若找到要访问的页,便修改页表项中的访问位(写指令则还须重置修改位),然后利用页表项中给出的物理块号和页内地址形成物理地址。
  • 若未找到该页的页表项,应到内存中去查找页表,再对比页表项中的状态位P,看该页是否已调入内存,未调入则产生缺页中断,请求从外存把该页调入内存。

页面置换算法

 页面置换算法决定将哪一个页面换出外存

页面的换入换出需要磁盘I/O,好的页面算法应该减少磁盘I/O的次数

缺页率=(缺页次数)/页面访问次数

最佳置换算法(OPT)

淘汰的页面是以后不可能使用或者长时间不再使用的页面

 缺页率:9/20=0.45

系统无法知道并发情况下,进程的执行顺序,最佳置换算法无法实现!!!

先进先出置换算法(FCFO)

每次淘汰最早进入内存的页面

 缺页率:9/12=0.75

belady异常

最近最久未使用置换算法(LRU)

淘汰最近最久未使用页面

使用页表的访问字段记录从上一次访问到现在的时间

 逆向观察

  缺页率:6/20=0.3

效率好,但是实现困难

时钟置换算法(CLOCK)

使用页面的访问位,访问位为1表示最近访问过,访问位为0表示最近没有访问过

将内存的页面构造成循环队列

1、一个页面被访问,访问位就要置为1

2、需要淘汰一个页面,访问循环队列,找到访问位是0的页面换出,换入的页面的标志位是1;

 如果访问到的访问位是1,将其改为0,继续访问下一个页面

 性能和开销相对均衡

改进后的时钟置换算法(CLOCK)

之前说的时钟置换算法,只关注是不是被访问过;然而,如果被淘汰的页面没有在内存中被修改过,是不需要写回外存的

在其他条件相同时,优先淘汰没有修改过的页面

访问位为1表示最近访问过,访问位为0表示最近没有访问过

修改位是1,表示在内存中修改过,修改位是0,表示在内存中没修改过 

页面分配策略

驻留集

请求分页管理系统中,给进程分配的物理块的集合

采用了虚拟存储技术的系统,驻留集大小一般小于进程总大小

 固定分配:系统给每个进程分配固定数目的物理块,进程运行期间不会改变,也就是驻留集不变

可变分配:系统给每个进程分配一定数目的物理块,进程运行期间可以增加或者减少,也就是驻留集可变

局部置换:发生缺页,只可以选择进程自己的物理块进行置换

全局置换:发生缺页,操作系统可以将空闲的物理块分配给进程,也可以将别的进程的物理块置换到外存后分配给进程

现代操作系统通常釆用三种策略:

  1. 固定分配局部置换。它为每个进程分配一定数目的物理块,在整个运行期间都不改变。若进程在运行中发生缺页,则只能从该进程在内存中的页面中选出一页换出,然后再调入需要的页面。实现这种策略难以确定为每个进程应分配的物理块数目:太少会频繁出现缺页中断,太多又会使CPU和其他资源利用率下降。
  2. 可变分配全局置换。这是最易于实现的物理块分配和置换策略,为系统中的每个进程分配一定数目的物理块,操作系统自身也保持一个空闲物理块队列。当某进程发生缺页时,系统从空闲物理块队列中取出一个物理块分配给该进程,并将欲调入的页装入其中。
  3. 可变分配局部置换。它为每个进程分配一定数目的物理块,当某进程发生缺页时,只允许从该进程在内存的页面中选出一页换出,这样就不会影响其他进程的运行。如果进程在运行中频繁地缺页,系统再为该进程分配若干物理块,直至该进程缺页率趋于适当程度; 反之,若进程在运行中缺页率特别低,则可适当减少分配给该进程的物理块。

可变分配全局置换和可变分配局部置换的区别:

可变分配局部置换,根据缺页频率动态调整物理块数目;可变分配全局置换,只要发生缺页就会增加物理块

 调入页面的时机

为确定系统将进程运行时所缺的页面调入内存的时机,可釆取以下两种调页策略:

  1. 预调页策略。根据局部性原理(空间局部性),一次调入若干个相邻的页可能会比一次调入一个页面更高效。但如果调入的一批页面中大多数都未被访问,则又是低效的。所以就需要釆用以预测为基础的预调页策略,将预计在不久之后便会被访问的页面预先调入内存。但目前预调页的成功率仅约50%。故这种策略主要用于进程的首次调入时,由程序员指出应该先调入哪些页。
  2. 请求调页策略。进程在运行中需要访问的页面不在内存而提出请求,由系统将所需页面调入内存。由这种策略调入的页一定会被访问,且这种策略比较易于实现,故在目前的虚拟存储器中大多釆用此策略。它的缺点在于每次只调入一页,调入调出页面数多时会花费过多的I/O开销。

从何处调入页面

请求分页系统中的外存分为两部分:用于存放文件的文件区和用于存放对换页面的对换区。对换区通常是釆用连续分配方式,而文件区釆用离散分配方式,故对换区的磁盘I/O速度比文件区的更快。这样从何处调入页面有三种情况:

  1. 系统拥有足够的对换区空间:可以全部从对换区调入所需页面,以提髙调页速度。为此,在进程运行前,需将与该进程有关的文件从文件区复制到对换区。
  2. 系统缺少足够的对换区空间:凡不会被修改的文件都直接从文件区调入;而当换出这些页面时,由于它们未被修改而不必再将它们换出。但对于那些可能被修改的部分,在将它们换出时须调到对换区(读写速度快),以后需要时再从对换区调入。
  3. UNIX方式:与进程有关的文件都放在文件区,故未运行过的页面,都应从文件区调入。曾经运行过但又被换出的页面,由于是被放在对换区,因此下次调入时应从对换区调入。进程请求的共享页面若被其他进程调入内存,则无需再从对换区调入。

页面抖动(颠簸)

刚刚换出的页面马上又要换入主存,刚刚换入的页面马上就要换出主存,这种频繁的页面调度行为称为抖动,或颠簸。
页面抖动的主要原因是某个进程频繁访问的页面数目高于可用的物理块数目。

工作集

工作集是指在某段时间间隔内,进程要访问的页面集合。

驻留集是指在请求分页管理系统中给进程分配的内存块的集合

经常被使用的页面需要在工作集中,而长期不被使用的页面要从工作集中被丢弃。为了防止系统出现抖动现象,需要选择合适的工作集大小。


 

一般来说:驻留集大小>=工作集大小,否则进程在运行中会频繁发生缺页

  • 8
    点赞
  • 37
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
文将对 Linux™ 程序员可以使用的内存管理技术进行概述,虽然关注的重点是 C 语言,但同样也适用于其他语言。文中将为您提供如何管理内存的细节,然后将进一步展示如何手工管理内存,如何使用引用计数或者内存池来半手工地管理内存,以及如何使用垃圾收集自动管理内存。 为什么必须管理内存 内存管理是计算机编程最为基本的领域之一。在很多脚本语言中,您不必担心内存是如何管理的,这并不能使得内存管理的重要性有一点点降低。对实际编程来说,理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中,比如 C 和 C++,您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。 追溯到在 Apple II 上进行汇编语言编程的时代,那时内存管理还不是个大问题。您实际上在运行整个系统。系统有多少内存,您就有多少内存。您甚至不必费心思去弄明白它有多少内存,因为每一台机器的内存数量都相同。所以,如果内存需要非常固定,那么您只需要选择一个内存范围并使用它即可。 不过,即使是在这样一个简单的计算机中,您也会有问题,尤其是当您不知道程序的每个部分将需要多少内存时。如果您的空间有限,而内存需求是变化的,那么您需要一些方法来满足这些需求: 确定您是否有足够的内存来处理数据。 从可用的内存中获取一部分内存。 向可用内存池(pool)中返回部分内存,以使其可以由程序的其他部分或者其他程序使用。 实现这些需求的程序库称为 分配程序(allocators),因为它们负责分配和回收内存。程序的动态性越强,内存管理就越重要,您的内存分配程序的选择也就更重要。让我们来了解可用于内存管理的不同方法,它们的好处与不足,以及它们最适用的情形。 回页首 C 风格的内存分配程序 C 编程语言提供了两个函数来满足我们的三个需求: malloc:该函数分配给定的字节数,并返回一个指向它们的指针。如果没有足够的可用内存,那么它返回一个空指针。 free:该函数获得指向由 malloc 分配的内存片段的指针,并将其释放,以便以后的程序或操作系统使用(实际上,一些 malloc 实现只能将内存归还给程序,而无法将内存归还给操作系统)。 物理内存和虚拟内存 要理解内存在程序中是如何分配的,首先需要理解如何将内存操作系统分配给程序。计算机上的每一个进程都认为自己可以访问所有的物理内存。显然,由于同时在运行多个程序,所以每个进程不可能拥有全部内存。实际上,这些进程使用的是 虚拟内存。 只是作为一个例子,让我们假定您的程序正在访问地址为 629 的内存。不过,虚拟内存系统不需要将其存储在位置为 629 的 RAM 中。实际上,它甚至可以不在 RAM 中 —— 如果物理 RAM 已经满了,它甚至可能已经被转移到硬盘上!由于这类地址不必反映内存所在的物理位置,所以它们被称为虚拟内存操作系统维持着一个虚拟地址到物理地址的转换的表,以便计算机硬件可以正确地响应地址请求。并且,如果地址在硬盘上而不是在 RAM 中,那么操作系统将暂时停止您的进程,将其他内存转存到硬盘中,从硬盘上加载被请求的内存,然后再重新启动您的进程。这样,每个进程都获得了自己可以使用的地址空间,可以访问比您物理上安装的内存更多的内存。 在 32-位 x86 系统上,每一个进程可以访问 4 GB 内存。现在,大部分人的系统上并没有 4 GB 内存,即使您将 swap 也算上, 每个进程所使用的内存也肯定少于 4 GB。因此,当加载一个进程时,它会得到一个取决于某个称为 系统中断点(system break)的特定地址的初始内存分配。该地址之后是未被映射的内存 —— 用于在 RAM 或者硬盘中没有分配相应物理位置的内存。因此,如果一个进程运行超出了它初始分配的内存,那么它必须请求操作系统“映射进来(map in)”更多的内存。(映射是一个表示一一对应关系的数学术语 —— 当内存的虚拟地址有一个对应的物理地址来存储内存内容时,该内存将被映射。) 基于 UNIX 的系统有两个可映射到附加内存中的基本系统调用: brk: brk() 是一个非常简单的系统调用。还记得系统中断点吗?该位置是进程映射的内存边界。 brk() 只是简单地将这个位置向前或者向后移动,就可以向进程添加内存或者从进程取走内存。 mmap: mmap(),或者说是“内存映像”,类似于 brk(),但是更为灵活。首先,它可以映射任何位置的内存,而不单单只局限于进程。其次,它不仅可以将虚拟地址映射到物理的 RAM 或者 swap,它还可以将它们映射到文件和文件位置,这样,读写内存将对文件中的数据进行读写。不过,在这里,我们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所做的事情与 mmap() 相反。 如您所见, brk() 或者 mmap() 都可以用来向我们的进程添加额外的虚拟内存。在我们的例子中将使用 brk(),因为它更简单,更通用。 实现一个简单的分配程序 如果您曾经编写过很多 C 程序,那么您可能曾多次使用过 malloc() 和 free()。不过,您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码,来帮助说明管理内存时都涉及到了哪些事情。 要试着运行这些示例,需要先 复制本代码清单,并将其粘贴到一个名为 malloc.c 的文件中。接下来,我将一次一个部分地对该清单进行解释。 在大部分操作系统中,内存分配由以下两个简单的函数来处理: void *malloc(long numbytes):该函数负责分配 numbytes 大小的内存,并返回指向第一个字节的指针。 void free(void *firstbyte):如果给定一个由先前的 malloc 返回的指针,那么该函数会将分配的空间归还给进程的“空闲空间”。 malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事:将分配程序标识为已经初始化,找到系统中最后一个有效内存地址,然后建立起指向我们管理的内存的指针。这三个变量都是全局变量: 清单 1. 我们的简单分配程序的全局变量 int has_initialized = 0; void *managed_memory_start; void *last_valid_address; 如前所述,被映射的内存的边界(最后一个有效地址)常被称为系统中断点或者 当前中断点。在很多 UNIX® 系统中,为了指出当前系统中断点,必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点,然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码,它将找到当前中断点并初始化我们的变量: 清单 2. 分配程序初始化函数 /* Include the sbrk function */ #include void malloc_init() { /* grab the last valid address from the OS */ last_valid_address = sbrk(0); /* we don't have any memory to manage yet, so *just set the beginning to be last_valid_address */ managed_memory_start = last_valid_address; /* Okay, we're initialized and ready to go */ has_initialized = 1; } 现在,为了完全地管理内存,我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后,我们需要做的是诸如将它们标记为未被使用的等事情,并且,在调用 malloc 时,我们要能够定位未被使用的内存块。因此, malloc 返回的每块内存的起始处首先要有这个结构: 清单 3. 内存控制块结构定义 struct mem_control_block { int is_available; int size; }; 现在,您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构?答案是它们不必知道;在返回指针之前,我们会将其移动到这个结构之后,把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样,从调用程序的角度来看,它们所得到的全部是空闲的、开放的内存。然后,当通过 free() 将该指针传递回来时,我们只需要倒退几个内存字节就可以再次找到这个结构。 在讨论分配内存之前,我们将先讨论释放,因为它更简单。为了释放内存,我们必须要做的惟一一件事情就是,获得我们给出的指针,回退 sizeof(struct mem_control_block) 个字节,并将其标记为可用的。这里是对应的代码: 清单 4. 解除分配函数 void free(void *firstbyte) { struct mem_control_block *mcb; /* Backup from the given pointer to find the * mem_control_block */ mcb = firstbyte - sizeof(struct mem_control_block); /* Mark the block as being available */ mcb->is_available = 1; /* That's It! We're done. */ return; } 如您所见,在这个分配程序中,内存的释放使用了一个非常简单的机制,在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述: 清单 5. 主分配程序的伪代码 1. If our allocator has not been initialized, initialize it. 2. Add sizeof(struct mem_control_block) to the size requested. 3. start at managed_memory_start. 4. Are we at last_valid address? 5. If we are: A. We didn't find any existing space that was large enough -- ask the operating system for more and return that. 6. Otherwise: A. Is the current space available (check is_available from the mem_control_block)? B. If it is: i) Is it large enough (check "size" from the mem_control_block)? ii) If so: a. Mark it as unavailable b. Move past mem_control_block and return the pointer iii) Otherwise: a. Move forward "size" bytes b. Go back go step 4 C. Otherwise: i) Move forward "size" bytes ii) Go back to step 4 我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码: 清单 6. 主分配程序 void *malloc(long numbytes) { /* Holds where we are looking in memory */ void *current_location; /* This is the same as current_location, but cast to a * memory_control_block */ struct mem_control_block *current_location_mcb; /* This is the memory location we will return. It will * be set to 0 until we find something suitable */ void *memory_location; /* Initialize if we haven't already done so */ if(! has_initialized) { malloc_init(); } /* The memory we search for has to include the memory * control block, but the users of malloc don't need * to know this, so we'll just add it in for them. */ numbytes = numbytes + sizeof(struct mem_control_block); /* Set memory_location to 0 until we find a suitable * location */ memory_location = 0; /* Begin searching at the start of managed memory */ current_location = managed_memory_start; /* Keep going until we have searched all allocated space */ while(current_location != last_valid_address) { /* current_location and current_location_mcb point * to the same address. However, current_location_mcb * is of the correct type, so we can use it as a struct. * current_location is a void pointer so we can use it * to calculate addresses. */ current_location_mcb = (struct mem_control_block *)current_location; if(current_location_mcb->is_available) { if(current_location_mcb->size >= numbytes) { /* Woohoo! We've found an open, * appropriately-size location. */ /* It is no longer available */ current_location_mcb->is_available = 0; /* We own it */ memory_location = current_location; /* Leave the loop */ break; } } /* If we made it here, it's because the Current memory * block not suitable; move to the next one */ current_location = current_location + current_location_mcb->size; } /* If we still don't have a valid location, we'll * have to ask the operating system for more memory */ if(! memory_location) { /* Move the program break numbytes further */ sbrk(numbytes); /* The new memory will be where the last valid * address left off */ memory_location = last_valid_address; /* We'll move the last valid address forward * numbytes */ last_valid_address = last_valid_address + numbytes; /* We need to initialize the mem_control_block */ current_location_mcb = memory_location; current_location_mcb->is_available = 0; current_location_mcb->size = numbytes; } /* Now, no matter what (well, except for error conditions), * memory_location has the address of the memory, including * the mem_control_block */ /* Move the pointer past the mem_control_block */ memory_location = memory_location + sizeof(struct mem_control_block); /* Return the pointer */ return memory_location; } 这就是我们的内存管理器。现在,我们只需要构建它,并在程序中使用它即可。 运行下面的命令来构建 malloc 兼容的分配程序(实际上,我们忽略了 realloc() 等一些函数,不过, malloc() 和 free() 才是最主要的函数): 清单 7. 编译分配程序 gcc -shared -fpic malloc.c -o malloc.so 该程序将生成一个名为 malloc.so 的文件,它是一个包含有我们的代码的共享库。 在 UNIX 系统中,现在您可以用您的分配程序来取代系统的 malloc(),做法如下: 清单 8. 替换您的标准的 malloc LD_PRELOAD=/path/to/malloc.so export LD_PRELOAD LD_PRELOAD 环境变量使动态链接器在加载任何可执行程序之前,先加载给定的共享库的符号。它还为特定库中的符号赋予优先权。因此,从现在起,该会话中的任何应用程序都将使用我们的 malloc(),而不是只有系统的应用程序能够使用。有一些应用程序不使用 malloc(),不过它们是例外。其他使用 realloc() 等其他内存管理函数的应用程序,或者错误地假定 malloc() 内部行为的那些应用程序,很可能会崩溃。ash shell 似乎可以使用我们的新 malloc() 很好地工作。 如果您想确保 malloc() 正在被使用,那么您应该通过向函数的入口点添加 write() 调用来进行测试。 我们的内存管理器在很多方面都还存在欠缺,但它可以有效地展示内存管理需要做什么事情。它的某些缺点包括: 由于它对系统中断点(一个全局变量)进行操作,所以它不能与其他分配程序或者 mmap 一起使用。 当分配内存时,在最坏的情形下,它将不得不遍历 全部进程内存;其中可能包括位于硬盘上的很多内存,这意味着操作系统将不得不花时间去向硬盘移入数据和从硬盘中移出数据。 没有很好的内存不足处理方案( malloc 只假定内存分配是成功的)。 它没有实现很多其他的内存函数,比如 realloc()。 由于 sbrk() 可能会交回比我们请求的更多的内存,所以在堆(heap)的末端会遗漏一些内存。 虽然 is_available 标记只包含一位信息,但它要使用完整的 4-字节 的字。 分配程序不是线程安全的。 分配程序不能将空闲空间拼合为更大的内存块。 分配程序的过于简单的匹配算法会导致产生很多潜在的内存碎片。 我确信还有很多其他问题。这就是为什么它只是一个例子! 其他 malloc 实现 malloc() 的实现有很多,这些实现各有优点与缺点。在设计一个分配程序时,要面临许多需要折衷的选择,其中包括: 分配的速度。 回收的速度。 有线程的环境的行为。 内存将要被用光时的行为。 局部缓存。 簿记(Bookkeeping)内存开销。 虚拟内存环境中的行为。 小的或者大的对象。 实时保证。 每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中,分配非常慢,而回收非常快。另外,由于它在使用虚拟内存系统方面较差,所以它最适于处理大的对象。 还有其他许多分配程序可以使用。其中包括: Doug Lea Malloc:Doug Lea Malloc 实际上是完整的一组分配程序,其中包括 Doug Lea 的原始分配程序,GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构,但是它加入了索引,这使得搜索速度更快,并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存,以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本,支持多线程。在本文后面的 参考资料部分中,有一篇描述 Doug Lea 的 Malloc 实现的文章。 BSD Malloc:BSD Malloc 是随 4.2 BSD 发行的实现,包含在 FreeBSD 之中,这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类,这些对象的大小为 2 的若干次幂减去某一常数。所以,如果您请求给定大小的一个对象,它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现,但是可能会浪费内存。在 参考资料部分中,有一篇描述该实现的文章。 Hoard:编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此,它的构造以锁的使用为中心,从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在 参考资料部分中,有一篇描述该实现的文章。 众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求,那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过,如果不熟悉分配程序的设计,那么定制分配程序通常会带来比它们解决的问题更多的问题。要获得关于该主题的适当的介绍,请参阅 Donald Knuth 撰写的 The Art of Computer Programming Volume 1: Fundamental Algorithms 中的第 2.5 节“Dynamic Storage Allocation”(请参阅 参考资料中的链接)。它有点过时,因为它没有考虑虚拟内存环境,不过大部分算法都是基于前面给出的函数。 在 C++ 中,通过重载 operator new(),您可以以每个类或者每个模板为单位实现自己的分配程序。在 Andrei Alexandrescu 撰写的 Modern C++ Design 的第 4 章(“Small Object Allocation”)中,描述了一个小对象分配程序(请参阅 参考资料中的链接)。 基于 malloc() 的内存管理的缺点 不只是我们的内存管理器有缺点,基于 malloc() 的内存管理器仍然也有很多缺点,不管您使用的是哪个分配程序。对于那些需要保持长期存储的程序使用 malloc() 来管理内存可能会非常令人失望。如果您有大量的不固定的内存引用,经常难以知道它们何时被释放。生存期局限于当前函数的内存非常容易管理,但是对于生存期超出该范围的内存来说,管理内存则困难得多。而且,关于内存管理是由进行调用的程序还是由被调用的函数来负责这一问题,很多 API 都不是很明确。 因为管理内存的问题,很多程序倾向于使用它们自己的内存管理规则。C++ 的异常处理使得这项任务更成问题。有时好像致力于管理内存分配和清理的代码比实际完成计算任务的代码还要多!因此,我们将研究内存管理的其他选择。 回页首 半自动内存管理策略 引用计数 引用计数是一种 半自动(semi-automated)的内存管理技术,这表示它需要一些编程支持,但是它不需要您确切知道某一对象何时不再被使用。引用计数机制为您完成内存管理任务。 在引用计数中,所有共享的数据结构都有一个域来包含当前活动“引用”结构的次数。当向一个程序传递一个指向某个数据结构指针时,该程序会将引用计数增加 1。实质上,您是在告诉数据结构,它正在被存储在多少个位置上。然后,当您的进程完成对它的使用后,该程序就会将引用计数减少 1。结束这个动作之后,它还会检查计数是否已经减到零。如果是,那么它将释放内存。 这样做的好处是,您不必追踪程序中某个给定的数据结构可能会遵循的每一条路径。每次对其局部的引用,都将导致计数的适当增加或减少。这样可以防止在使用数据结构时释放该结构。不过,当您使用某个采用引用计数的数据结构时,您必须记得运行引用计数函数。另外,内置函数和第三方的库不会知道或者可以使用您的引用计数机制。引用计数也难以处理发生循环引用的数据结构。 要实现引用计数,您只需要两个函数 —— 一个增加引用计数,一个减少引用计数并当计数减少到零时释放内存。 一个示例引用计数函数集可能看起来如下所示: 清单 9. 基本的引用计数函数 /* Structure Definitions*/ /* Base structure that holds a refcount */ struct refcountedstruct { int refcount; } /* All refcounted structures must mirror struct * refcountedstruct for their first variables */ /* Refcount maintenance functions */ /* Increase reference count */ void REF(void *data) { struct refcountedstruct *rstruct; rstruct = (struct refcountedstruct *) data; rstruct->refcount++; } /* Decrease reference count */ void UNREF(void *data) { struct refcountedstruct *rstruct; rstruct = (struct refcountedstruct *) data; rstruct->refcount--; /* Free the structure if there are no more users */ if(rstruct->refcount == 0) { free(rstruct); } } REF 和 UNREF 可能会更复杂,这取决于您想要做的事情。例如,您可能想要为多线程程序增加锁,那么您可能想扩展 refcountedstruct,使它同样包含一个指向某个在释放内存之前要调用的函数的指针(类似于面向对象语言中的析构函数 —— 如果您的结构中包含这些指针,那么这是 必需的)。 当使用 REF 和 UNREF 时,您需要遵守这些指针的分配规则: UNREF 分配前左端指针(left-hand-side pointer)指向的值。 REF 分配后左端指针(left-hand-side pointer)指向的值。 在传递使用引用计数的结构的函数中,函数需要遵循以下这些规则: 在函数的起始处 REF 每一个指针。 在函数的结束处 UNREF 第一个指针。 以下是一个使用引用计数的生动的代码示例: 清单 10. 使用引用计数的示例 /* EXAMPLES OF USAGE */ /* Data type to be refcounted */ struct mydata { int refcount; /* same as refcountedstruct */ int datafield1; /* Fields specific to this struct */ int datafield2; /* other declarations would go here as appropriate */ }; /* Use the functions in code */ void dosomething(struct mydata *data) { REF(data); /* Process data */ /* when we are through */ UNREF(data); } struct mydata *globalvar1; /* Note that in this one, we don't decrease the * refcount since we are maintaining the reference * past the end of the function call through the * global variable */ void storesomething(struct mydata *data) { REF(data); /* passed as a parameter */ globalvar1 = data; REF(data); /* ref because of Assignment */ UNREF(data); /* Function finished */ } 由于引用计数是如此简单,大部分程序员都自已去实现它,而不是使用库。不过,它们依赖于 malloc 和 free 等低层的分配程序来实际地分配和释放它们的内存。 在 Perl 等高级语言中,进行内存管理时使用引用计数非常广泛。在这些语言中,引用计数由语言自动地处理,所以您根本不必担心它,除非要编写扩展模块。由于所有内容都必须进行引用计数,所以这会对速度产生一些影响,但它极大地提高了编程的安全性和方便性。以下是引用计数的益处: 实现简单。 易于使用。 由于引用是数据结构的一部分,所以它有一个好的缓存位置。 不过,它也有其不足之处: 要求您永远不要忘记调用引用计数函数。 无法释放作为循环数据结构的一部分的结构。 减缓几乎每一个指针的分配。 尽管所使用的对象采用了引用计数,但是当使用异常处理(比如 try 或 setjmp()/ longjmp())时,您必须采取其他方法。 需要额外的内存来处理引用。 引用计数占用了结构中的第一个位置,在大部分机器中最快可以访问到的就是这个位置。 在多线程环境中更慢也更难以使用。 C++ 可以通过使用 智能指针(smart pointers)来容忍程序员所犯的一些错误,智能指针可以为您处理引用计数等指针处理细节。不过,如果不得不使用任何先前的不能处理智能指针的代码(比如对 C 库的联接),实际上,使用它们的后果通实比不使用它们更为困难和复杂。因此,它通常只是有益于纯 C++ 项目。如果您想使用智能指针,那么您实在应该去阅读 Alexandrescu 撰写的 Modern C++ Design 一书中的“Smart Pointers”那一章。 内存内存池是另一种半自动内存管理方法。内存池帮助某些程序进行自动内存管理,这些程序会经历一些特定的阶段,而且每个阶段中都有分配给进程的特定阶段的内存。例如,很多网络服务器进程都会分配很多针对每个连接的内存 —— 内存的最大生存期限为当前连接的存在期。Apache 使用了池式内存(pooled memory),将其连接拆分为各个阶段,每个阶段都有自己的内存池。在结束每个阶段时,会一次释放所有内存。 在池式内存管理中,每次内存分配都会指定内存池,从中分配内存。每个内存池都有不同的生存期限。在 Apache 中,有一个持续时间为服务器存在期的内存池,还有一个持续时间为连接的存在期的内存池,以及一个持续时间为请求的存在期的池,另外还有其他一些内存池。因此,如果我的一系列函数不会生成比连接持续时间更长的数据,那么我就可以完全从连接池中分配内存,并知道在连接结束时,这些内存会被自动释放。另外,有一些实现允许注册 清除函数(cleanup functions),在清除内存池之前,恰好可以调用它,来完成在内存被清理前需要完成的其他所有任务(类似于面向对象中的析构函数)。 要在自己的程序中使用池,您既可以使用 GNU libc 的 obstack 实现,也可以使用 Apache 的 Apache Portable Runtime。GNU obstack 的好处在于,基于 GNU 的 Linux 发行版本中默认会包括它们。Apache Portable Runtime 的好处在于它有很多其他工具,可以处理编写多平台服务器软件所有方面的事情。要深入了解 GNU obstack 和 Apache 的池式内存实现,请参阅 参考资料部分中指向这些实现的文档的链接。 下面的假想代码列表展示了如何使用 obstack: 清单 11. obstack 的示例代码 #include #include /* Example code listing for using obstacks */ /* Used for obstack macros (xmalloc is a malloc function that exits if memory is exhausted */ #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free /* Pools */ /* Only permanent allocations should go in this pool */ struct obstack *global_pool; /* This pool is for per-connection data */ struct obstack *connection_pool; /* This pool is for per-request data */ struct obstack *request_pool; void allocation_failed() { exit(1); } int main() { /* Initialize Pools */ global_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(global_pool); connection_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(connection_pool); request_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(request_pool); /* Set the error handling function */ obstack_alloc_failed_handler = &allocation_failed; /* Server main loop */ while(1) { wait_for_connection(); /* We are in a connection */ while(more_requests_available()) { /* Handle request */ handle_request(); /* Free all of the memory allocated * in the request pool */ obstack_free(request_pool, NULL); } /* We're finished with the connection, time * to free that pool */ obstack_free(connection_pool, NULL); } } int handle_request() { /* Be sure that all object allocations are allocated * from the request pool */ int bytes_i_need = 400; void *data1 = obstack_alloc(request_pool, bytes_i_need); /* Do stuff to process the request */ /* return */ return 0; } 基本上,在操作的每一个主要阶段结束之后,这个阶段的 obstack 会被释放。不过,要注意的是,如果一个过程需要分配持续时间比当前阶段更长的内存,那么它也可以使用更长期限的 obstack,比如连接或者全局内存。传递给 obstack_free() 的 NULL 指出它应该释放 obstack 的全部内容。可以用其他的值,但是它们通常不怎么实用。 使用池式内存分配的益处如下所示: 应用程序可以简单地管理内存内存分配和回收更快,因为每次都是在一个池中完成的。分配可以在 O(1) 时间内完成,释放内存池所需时间也差不多(实际上是 O(n) 时间,不过在大部分情况下会除以一个大的因数,使其变成 O(1))。 可以预先分配错误处理池(Error-handling pools),以便程序在常规内存被耗尽时仍可以恢复。 有非常易于使用的标准实现。 池式内存的缺点是: 内存池只适用于操作可以分阶段的程序。 内存池通常不能与第三方库很好地合作。 如果程序的结构发生变化,则不得不修改内存池,这可能会导致内存管理系统的重新设计。 您必须记住需要从哪个池进行分配。另外,如果在这里出错,就很难捕获该内存池。 回页首 垃圾收集 垃圾收集(Garbage collection)是全自动地检测并移除不再使用的数据对象。垃圾收集器通常会在当可用内存减少到少于一个具体的阈值时运行。通常,它们以程序所知的可用的一组“基本”数据 —— 栈数据、全局变量、寄存器 —— 作为出发点。然后它们尝试去追踪通过这些数据连接到每一块数据。收集器找到的都是有用的数据;它没有找到的就是垃圾,可以被销毁并重新使用这些无用的数据。为了有效地管理内存,很多类型的垃圾收集器都需要知道数据结构内部指针的规划,所以,为了正确运行垃圾收集器,它们必须是语言本身的一部分。 收集器的类型 复制(copying): 这些收集器将内存存储器分为两部分,只允许数据驻留在其中一部分上。它们定时地从“基本”的元素开始将数据从一部分复制到另一部分。内存新近被占用的部分现在成为活动的,另一部分上的所有内容都认为是垃圾。另外,当进行这项复制操作时,所有指针都必须被更新为指向每个内存条目的新位置。因此,为使用这种垃圾收集方法,垃圾收集器必须与编程语言集成在一起。 标记并清理(Mark and sweep):每一块数据都被加上一个标签。不定期的,所有标签都被设置为 0,收集器从“基本”的元素开始遍历数据。当它遇到内存时,就将标签标记为 1。最后没有被标记为 1 的所有内容都认为是垃圾,以后分配内存时会重新使用它们。 增量的(Incremental):增量垃圾收集器不需要遍历全部数据对象。因为在收集期间的突然等待,也因为与访问所有当前数据相关的缓存问题(所有内容都不得不被页入(page-in)),遍历所有内存会引发问题。增量收集器避免了这些问题。 保守的(Conservative):保守的垃圾收集器在管理内存时不需要知道与数据结构相关的任何信息。它们只查看所有数据类型,并假定它们 可以全部都是指针。所以,如果一个字节序列可以是一个指向一块被分配的内存的指针,那么收集器就将其标记为正在被引用。有时没有被引用的内存会被收集,这样会引发问题,例如,如果一个整数域中包含一个值,该值是已分配内存的地址。不过,这种情况极少发生,而且它只会浪费少量内存。保守的收集器的优势是,它们可以与任何编程语言相集成。 Hans Boehm 的保守垃圾收集器是可用的最流行的垃圾收集器之一,因为它是免费的,而且既是保守的又是增量的,可以使用 --enable-redirect-malloc 选项来构建它,并且可以将它用作系统分配程序的简易替代者(drop-in replacement)(用 malloc/ free 代替它自己的 API)。实际上,如果这样做,您就可以使用与我们在示例分配程序中所使用的相同的 LD_PRELOAD 技巧,在系统上的几乎任何程序中启用垃圾收集。如果您怀疑某个程序正在泄漏内存,那么您可以使用这个垃圾收集器来控制进程。在早期,当 Mozilla 严重地泄漏内存时,很多人在其中使用了这项技术。这种垃圾收集器既可以在 Windows® 下运行,也可以在 UNIX 下运行。 垃圾收集的一些优点: 您永远不必担心内存的双重释放或者对象的生命周期。 使用某些收集器,您可以使用与常规分配相同的 API。 其缺点包括: 使用大部分收集器时,您都无法干涉何时释放内存。 在多数情况下,垃圾收集比其他形式的内存管理更慢。 垃圾收集错误引发的缺陷难于调试。 如果您忘记将不再使用的指针设置为 null,那么仍然会有内存泄漏。 回页首 结束语 一切都需要折衷:性能、易用、易于实现、支持线程的能力等,这里只列出了其中的一些。为了满足项目的要求,有很多内存管理模式可以供您使用。每种模式都有大量的实现,各有其优缺点。对很多项目来说,使用编程环境默认的技术就足够了,不过,当您的项目有特殊的需要时,了解可用的选择将会有帮助。下表对比了本文中涉及的内存管理策略。 表 1. 内存分配策略的对比 策略 分配速度 回收速度 局部缓存 易用性 通用性 实时可用 SMP 线程友好 定制分配程序 取决于实现 取决于实现 取决于实现 很难 无 取决于实现 取决于实现 简单分配程序 内存使用少时较快 很快 差 容易 高 否 否 GNU malloc 中 快 中 容易 高 否 中 Hoard 中 中 中 容易 高 否 是 引用计数 N/A N/A 非常好 中 中 是(取决于 malloc 实现) 取决于实现 池 中 非常快 极好 中 中 是(取决于 malloc 实现) 取决于实现 垃圾收集 中(进行收集时慢) 中 差 中 中 否 几乎不 增量垃圾收集 中 中 中 中 中 否 几乎不 增量保守垃圾收集 中 中 中 容易 高 否 几乎不 参考资料 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 Web 上的文档 GNU C Library 手册的 obstacks 部分 提供了 obstacks 编程接口。 Apache Portable Runtime 文档 描述了它们的池式分配程序的接口。 基本的分配程序 Doug Lea 的 Malloc 是最流行的内存分配程序之一。 BSD Malloc 用于大部分基于 BSD 的系统中。 ptmalloc 起源于 Doug Lea 的 malloc,用于 GLIBC 之中。 Hoard 是一个为多线程应用程序优化的 malloc 实现。 GNU Memory-Mapped Malloc(GDB 的组成部分) 是一个基于 mmap() 的 malloc 实现。 池式分配程序 GNU Obstacks(GNU Libc 的组成部分)是安装最多的池式分配程序,因为在每一个基于 glibc 的系统中都有它。 Apache 的池式分配程序(Apache Portable Runtime 中) 是应用最为广泛的池式分配程序。 Squid 有其自己的池式分配程序。 NetBSD 也有其自己的池式分配程序。 talloc 是一个池式分配程序,是 Samba 的组成部分。 智能指针和定制分配程序 Loki C++ Library 有很多为 C++ 实现的通用模式,包括智能指针和一个定制的小对象分配程序。 垃圾收集器 Hahns Boehm Conservative Garbage Collector 是最流行的开源垃圾收集器,它可以用于常规的 C/C++ 程序。 关于现代操作系统中的虚拟内存的文章 Marshall Kirk McKusick 和 Michael J. Karels 合著的 A New Virtual Memory Implementation for Berkeley UNIX 讨论了 BSD 的 VM 系统。 Mel Gorman's Linux VM Documentation 讨论了 Linux VM 系统。 关于 malloc 的文章 Poul-Henning Kamp 撰写的 Malloc in Modern Virtual Memory Environments 讨论的是 malloc 以及它如何与 BSD 虚拟内存交互。 Berger、McKinley、Blumofe 和 Wilson 合著的 Hoard -- a Scalable Memory Allocator for Multithreaded Environments 讨论了 Hoard 分配程序的实现。 Marshall Kirk McKusick 和 Michael J. Karels 合著的 Design of a General Purpose Memory Allocator for the 4.3BSD UNIX Kernel 讨论了内核级的分配程序。 Doug Lea 撰写的 A Memory Allocator 给出了一个关于设计和实现分配程序的概述,其中包括设计选择与折衷。 Emery D. Berger 撰写的 Memory Management for High-Performance Applications 讨论的是定制内存管理以及它如何影响高性能应用程序。 关于定制分配程序的文章 Doug Lea 撰写的 Some Storage Management Techniques for Container Classes 描述的是为 C++ 类编写定制分配程序。 Berger、Zorn 和 McKinley 合著的 Composing High-Performance Memory Allocators 讨论了如何编写定制分配程序来加快具体工作的速度。 Berger、Zorn 和 McKinley 合著的 Reconsidering Custom Memory Allocation 再次提及了定制分配的主题,看是否真正值得为其费心。 关于垃圾收集的文章 Paul R. Wilson 撰写的 Uniprocessor Garbage Collection Techniques 给出了垃圾收集的一个基本概述。 Benjamin Zorn 撰写的 The Measured Cost of Garbage Collection 给出了关于垃圾收集和性能的硬数据(hard data)。 Hans-Juergen Boehm 撰写的 Memory Allocation Myths and Half-Truths 给出了关于垃圾收集的神话(myths)。 Hans-Juergen Boehm 撰写的 Space Efficient Conservative Garbage Collection 是一篇描述他的用于 C/C++ 的垃圾收集器的文章。 Web 上的通用参考资料 内存管理参考 中有很多关于内存管理参考资料和技术文章的链接。 关于内存管理和内存层级的 OOPS Group Papers 是非常好的一组关于此主题的技术文章。 C++ 中的内存管理讨论的是为 C++ 编写定制的分配程序。 Programming Alternatives: Memory Management 讨论了程序员进行内存管理时的一些选择。 垃圾收集 FAQ 讨论了关于垃圾收集您需要了解的所有内容。 Richard Jones 的 Garbage Collection Bibliography 有指向任何您想要的关于垃圾收集的文章的链接。 书籍 Michael Daconta 撰写的 C++ Pointers and Dynamic Memory Management 介绍了关于内存管理的很多技术。 Frantisek Franek 撰写的 Memory as a Programming Concept in C and C++ 讨论了有效使用内存的技术与工具,并给出了在计算机编程中应当引起注意的内存相关错误的角色。 Richard Jones 和 Rafael Lins 合著的 Garbage Collection: Algorithms for Automatic Dynamic Memory Management 描述了当前使用的最常见的垃圾收集算法。 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.5 节“Dynamic Storage Allocation”中,描述了实现基本的分配程序的一些技术。 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.3.5 节“Lists and Garbage Collection”中,讨论了用于列表的垃圾收集算法。 Andrei Alexandrescu 撰写的 Modern C++ Design 第 4 章“Small Object Allocation”描述了一个比 C++ 标准分配程序效率高得多的一个高速小对象分配程序。 Andrei Alexandrescu 撰写的 Modern C++ Design 第 7 章“Smart Pointers”描述了在 C++ 中智能指针的实现。 Jonathan 撰写的 Programming from the Ground Up 第 8 章“Intermediate Memory Topics”中有本文使用的简单分配程序的一个汇编语言版本。 来自 developerWorks 自我管理数据缓冲区内存 (developerWorks,2004 年 1 月)略述了一个用于管理内存的自管理的抽象数据缓存器的伪 C (pseudo-C)实现。 A framework for the user defined malloc replacement feature (developerWorks,2002 年 2 月)展示了如何利用 AIX 中的一个工具,使用自己设计的内存子系统取代原有的内存子系统。 掌握 Linux 调试技术 (developerWorks,2002 年 8 月)描述了可以使用调试方法的 4 种不同情形:段错误、内存溢出、内存泄漏和挂起。 在 处理 Java 程序中的内存漏洞 (developerWorks,2001 年 2 月)中,了解导致 Java 内存泄漏的原因,以及何时需要考虑它们。 在 developerWorks Linux 专区中,可以找到更多为 Linux 开发人员准备的参考资料。 从 developerWorks 的 Speed-start your Linux app 专区中,可以下载运行于 Linux 之上的 IBM 中间件产品的免费测试版本,其中包括 WebSphere® Studio Application Developer、WebSphere Application Server、DB2® Universal Database、Tivoli® Access Manager 和 Tivoli Directory Server,查找 how-to 文章和技术支持。 通过参与 developerWorks blogs 加入到 developerWorks 社区。 可以在 Developer Bookstore Linux 专栏中定购 打折出售的 Linux 书籍。 关于作者 Jonathan Bartlett 是 Programming from the Ground Up 一书的作者,这本书介绍的是 Linux 汇编语言编程。Jonathan Bartlett 是 New Media Worx 的总开发师,负责为客户开发 Web、视频、kiosk 和桌面应用程序。您可以通过 johnnyb@eskimo.com 与 Jonathan 联系。
操作系统中,C语言的请求调页存储管理方式是指通过C语言的系统调用来实现页面调度的过程。该过程主要包含三个步骤:页面置换、页面分配、页面回收。页面置换是指当内存中的页框被用完时,需要将其中的一些页帧替换出去,以便腾出空间给新的页面使用。页面分配是指在需要新的页面时,从主存中分配一个或多个空闲页面,在操作系统中建立该页面对应的页表项,并将该页面的物理地址与逻辑地址映射起来。页面回收是指当页面不再被使用时,需要将其从主存中回收,并更新对应的页表项。 在C语言中实现请求调页存储管理方式,需要使用一些系统调用函数,比如mmap、munmap等。其中,mmap函数用于请求操作系统为应用程序分配指定大小的虚拟地址空间,并将这个区域映射到实际物理内存上。而munmap函数则用于释放已经映射的虚拟地址空间,并将其对应的物理内存页帧标记为空闲状态。 对于操作系统的调页机制而言,C语言是非常重要的一种实现方式。通过使用C语言的系统调用,在应用程序层面上就可以控制操作系统页面调度的过程,并实现更加高效和灵活的页面管理方法。同时,C语言还可以与各种硬件设备进行有效的数据交换,从而进一步优化页面置换、分配和回收的速度和效率。因此,C语言请求调页存储管理方式在操作系统开发中是非常常见的一种实现方式。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值