【操作系统】第三章:内存管理

第三章:内存管理


一、内存管理

1.内存管理内容
(1)地址转换:

image-20220924075118384

Point1:程序装入

绝对装入:在编译时如果知道程序将放入到内存中的哪个位置,编译程序将产生绝对地址的目标代码。装入程序按照装入模块中的地址,将程序的数据装入内存。

image-20220924072557250

可重定位装入(静态重定位):根据内存的目前情况将装入模块装入到内存的适当位置(装入时对地址进行重定位),地址变换是在装入时一次完成的。

image-20220924073124235

动态运行时装入(动态重定位):装入程序把装入模块装入内存后,并不会立即把逻辑地址转换为物理地址,而是把地址转换推迟到程序真正要执行时才进行(装入内存后所有的地址依然是逻辑地址),这种方式需要一个重定位寄存器的支持。

image-20220924074040911

动态重定位优点:

  1. 允许程序在内存中发生移动。
  2. 可将程序分配到不连续的存储区中
  3. 在程序运行前只需装入部分代码即可投入运行
  4. 在程序运行期间,可根据需要动态申请分配内存空间
  5. 便于程序段的共享
  6. 可向用户提供一个比存储空间大得多的地址空间
Point2:程序链接

静态链接:在程序运行之前,先将各目标模块所需的库函数连接成一个完整的可执行文件(装入模块),之后不再拆开。

image-20220924084723863

装入时动态链接:将各目标模块装入内存时,边装入边链接的方式。

image-20220924084939171

运行时动态链接:在程序执行中需要该目标模块时才对其进行链接,这种方式便于修改和更新,便于实现对目标模块的共享。

image-20220924085235225

(2)内存保护:

上下限寄存器:在CPU中设置一对上下限寄存器,存放进程的上、下限地址。进程的指令要访问某个地址时,CPU检查是否越界。

image-20220924110023534

重定位寄存器:采用重定位寄存器(基地址寄存器)和界地址寄存器(限长寄存器)进行越界检查。重定位寄存器中存放的是进程的起始物理地址,界地址寄存器中存放的是进程的最大逻辑地址。

image-20220924110702272

(3)内存空间的扩充:
Point1:覆盖技术

覆盖技术:将程序分为多个段,常用段常驻内存不常用段在需要时调入内存,以解决程序大小超过物理内存总和的问题。

  • 常用段:放在内存的固定区中,调入后就不再调出(除非运行结束)
  • 非常用段:放在覆盖区,需要用到时调入内存,用不到时调出内存。

image-20220924112306127

Point2:交换技术

交换技术:内存空间紧张时,系统将内存中的某些进程暂时换出外存(进程的PCB保留在仍然内存中),把内存中某些已具备运行条件的进程换入内存(进程在内存与磁盘间动态调度)

image-20220924114542054

问题1:在外存的什么位置保存被换出的进程?

在具有交换功能的操作系统中,通常把磁盘分为文件区与对换区两部分。

  • 文件区:主要用于存放文件,追求存储空间的利用率(采用离散分配方式)
  • 对换区:主要用于存储被换出的进程,追求换入换出速度(采用连续分配方式)

问题2:什么时候进行进程交换?

交换通常在进程运行且内存吃紧的情况下发生,而当系统符合降低时就暂停。

例如:在发现许多进程运行时经常发生缺页,就说明内存紧张此时可以换出一些内存,而当缺页率下降时就可以暂停换出。

问题3:应该交换出哪些进程?

可优先换出阻塞的进程、优先换出优先级更低的进程、为了防止优先级低的进程饥饿,还会考虑进程在内存中驻留的时间问题。

【补充】覆盖与交换的区别

  1. 覆盖是在同一个程序或进程中进行的
  2. 交换是在不同的进程(或作业)之间进行的
(4)内存空间的分配与回收:

image-20220927072929670

2.连续分配管理方式
(1)单一连续分配:

在单一连续分配方式中,内存被分为系统区与用户区

  • 系统区:通常位于内存的低地址部分,用于存放操作系统相关数据。
  • 用户区:用于存放用户进程相关数据。
  • 内存中只能有一道用户程序,用户程序独占整个用户区空间。

image-20220924122030205

(2)固定分区分配:

将整个用户空间划分为固定大小分区,每个分区中装入一道作业,为支持多道程序系统在内存中装入多道程序(且互不干扰)。

image-20220924123215280

(3)动态分区分配:

不预先划分内存分区,而是在进程装入内存时根据进程的大小动态的建立分区,并使分区的大小正好适合进程的需要,因此系统分区的大小和数量是可变的。

问题1:操作系统用什么数据结构记录内存的使用情况?

答:空闲分区表、空闲分区链

image-20220924123916602

问题2:当有多个空闲分区满足需求时,应该选择哪个分区进行分配?

答:需要按照动态分区分配算法从空闲分区表或空闲分区链中选出一个分区分配该改作业,包含4中动态分区分配算法。

问题3:如何进行分区的分配与回收?

答:回收之后如果发现有一些空闲分区是相邻的,则需要对空闲分区进行合并。

注:关于内部与外部碎片

  1. 内部碎片:分配给某进程的内存区域中,有些部分没有用上
  2. 外部碎片:内存中的某些空闲分区由于太小而难以利用上。

image-20220924125341539

(4)动态分区分配算法:

首次适应算法First Fit

  • 算法思想:每次都从低地址开始查找,找到第1个能够满足大小的空闲分区。

  • 算法实现:空闲分区以地址递增的次序进行排列,每次分配内存时顺序查找空闲分区链or空闲分区表,找到大小能够满足要求的第1个空闲分区。

image-20220925105956412

最佳适应算法Best Fit

  • 算法思想:由于动态分区分配是一种连续分配方式,为各进程分配的空间必须是连续的一整片区域。因此为了保证大进程到来时能有连续的大片空间,可以尽可能多的留下大片的空闲区域,即优先使用更小的空闲区域
  • 算法实现:空闲分区按容量递增次序链接,分配内存时顺序查找空闲分区链or空闲分区表,找到大小满足要求的第1个空闲分区。

image-20220925111230304

BestFit缺点:每次都选取最小的分区进行分配,会留下越来越多很小的难以利用的内存块(外部碎片)。

最坏适应算法Worst Fit

  • 算法思想:为解决BestFit算法的问题,可以在每次分配时优先使用最大的连续空闲区,这样分配后剩余的空闲区就不会太小。
  • 算法实现:空闲分区按照容量递减次序进行链接,每次分配内存时顺序查找空闲分区链or空闲分区表,找到大小满足要求的第1个空闲分区。

image-20220925111719745

邻接适应算法NextFit

  • 算法思想:首次适应算法每次都从链头开始查找,这可能会导致低地址部分出现很多小的空闲分区,而每次分配查找时都要经过这些分区,因此也增加了查找的开销。如果每次都从上次查找结束的位置开始检索就能解决这个问题
  • 算法实现:空闲分区以地址递增的顺序排列(可排成循环链表便于检索),每次分配内存时从上次查找结束的位置开始查找空闲分区or空闲链表,找到大小能够满足要求的第1个空闲分区。

注:邻接适应与首次适应算法与最佳/最坏算法相比,在空闲内存分区发生变化后,无需对整个链表进行重新排列(节省开销)。

首次适应算法每次都从头查找检索低地址的小分区,其更有可能把高地址部分的大空闲分区保留下来(最佳适应算法优点)

邻接适应算法无论高低地址部分的空闲分区都被相同概论的使用,导致大分区被划分为小分区、无大分区可用(最坏适应算法的缺点)

image-20220925115313809

注:综合来看四种算法中反而首次适应算法的空闲内存分区分配策略是最好的。

3.基本分页存储管理
(1)基本分页存储

内存空间分为大小相等的分区,每个分区就是一个页框/页帧/内存块/物理块/物理页面Page Frame,每个页框有一个页框号从0开始。

进程的逻辑地址空间也分为与页框大小相等的部分,每个部分称为一个页/页面Page,每个页面有一个页号从0开始。

操作系统以页框为单位为各进程分配内存空间,进程的页面与内存的页框有映射关系(每个页面不必连续存放)

image-20220927074257712

操作系统为每个进程建立一张页表(1个进程对应1张页表),以获取页面在内存中存放的位置(页框位置)

image-20220927074736519

★问题1:每个页表项占多少字节?

image-20220927075326885

★问题2:如何实现逻辑地址到物理地址的转换?

虽然进程的各个页面是离散存放的,但是页面内部是连续存放的,如果要访问逻辑地址A则:

  1. 确定逻辑地址A对应的页号P
  2. 确定逻辑地址A的页内偏移量W
  3. 找到P号页面在内存中的起始地址(通过查询页表)
  4. 逻辑地址A对应的物理地址 = P号页面在内存中的起始地址 + 页内偏移量W

问题3:如何确定一个逻辑地址对应的页号P 和 页内偏移量W?

image-20220927084820388

问题4:页面大小为2的整数次幂,为地址转换带来的好处?

  • 页号与页内偏移量的计算:如果页面大小为2kB,用二进制数表示逻辑地址则末尾k位即为页内偏移量,其余部分即为页号。

image-20220927091711672

  • 物理地址的计算:根据逻辑地址得到页号,根据页号在页表中找到页面存放的内存块号,将二进制表示的内存块号页内偏移量拼接起来,就可以得到最终的物理地址。

image-20220927091736737

  • 分页存储管理的逻辑地址结构如下:

image-20220927092320624

(2)基本地址变换机构

基本地址变换机构可以借助进程的页表将逻辑地址转换为物理地址。

通常会在系统中设置一个页表寄存器PTR,存放页表在内存中的起始地址F和页表长度M,

进程执行时页表始址F和页表长度M存在PCB中,当进程被调度时操作系统内核会将这两个参数放到页表寄存器中。

image-20220927101937966

设页面大小为L,将逻辑地址A转换到物理地址E的过程如下

  1. 计算页号与页内偏移量:根据逻辑地址A,划分得到页号P和页内偏移量W(如果是十进制需要手算P=A/L、W=A%L)
  2. 页号合法性检查:比较页号P与页表长度M,若P≥M则产生越界中断(特判P=M也会发生中断!)
  3. 计算页表项地址以获取内存块号:页表项地址=页表起始地址F+页号P*页表项长度,取出该页表项内容b即为内存块号
  4. 计算物理地址E:E=b*L+W
  5. 用得到的物理地址E去访问内存

image-20220927102338985

注:在分页存储管理系统,只要确定了每个页面的大小逻辑地址结构就确定了(页式管理中地址是一维的)

实际应用中通常使一个页框恰好能够放入整数个页表项

image-20220927103755569

(3)具有快表的地址变换机构

具有快表的地址变换机构是对基本地址变换结构的改进

TLB联想寄存器,translation lookaside buffer是一种访问速度比内存快很多的高速缓存(非内存),用于存放最近访问页表项的副本。

TLB联想寄存器可以加速地址变换的速度,因此内存中的页表项常被称为慢表。

引入快表后地址的变换过程

image-20220927112540176

  1. CPU给出逻辑地址由硬件计算出页号、页内偏移量,将页号与块表中的所有页号进行比较。
  2. 如果找到匹配的页号,则直接从中取出该页对应的内存块号,再将内存块号与页内偏移量拼接成物理地址后访问对应的内存单元。
  3. 如果没有找到匹配的页号,则需要访问内存中的页表找到对应的页表项,得到页面存放的内存块号,再将内存块号与页内偏移量拼接成物理地址后访问对应的内存单元。(在找到页表项后应同时将其存入快表以便后续使用,若快表已满需按照一定的算法对旧的页表项进行替换)

image-20220927113438428

注:TLB和普通Cache的区别—TLB中只有页表项的副本,而普通Cache中可能会有其他的各种数据的副本

(4)两级页表

单级页表中存在需要改进的问题:

问题1:根据页号查询页表的方法,要求所有的页表项都连续存放(需要占用很多个连续的页框)

可将长长的页表进行分组,使每个内存块刚好可以放入一个分组,再将各分组离散的放到各个内存块中。另外要为离散分配的页表再建立一张页表,称为页目录表/外层页表/顶层页表。

image-20220928120425294

image-20220928120435825

两级页表实现逻辑地址转换:

  1. 按照地址结构将逻辑地址拆分成三个部分
  2. 从PCB中读出页目录表的起始地址,再根据一级页号查询页目录表,找到下一级页表在内存中的存放位置。
  3. 根据二级页号查表,找到最终想要访问的内存块号
  4. 结合页内偏移量得到物理地址

问题2:进程在一段时间内只需访问某几个特定的页面就可正常工作,没有必要让整个页表都常驻内存中

可以在需要访问页面时才将页面调入内存(虚拟存储技术),可以在页表项中添加一个标志位用于表示该页面是否已调入内存。如果想要访问的页面不再内存中,则产生缺页中断(内中断)然后将目标页面从外存中调入内存。

问题3:若采用多级页表机制,则各级页表的大小不能超过一个页面

image-20220928124821393

注:两级页表的分表使得访问内存的次数变多,具体访问次数为n级页面访问内存的次数为n+1次

4.基本分段存储管理
(1)基本分页存储

将进程的地址空间,按照程序自身的逻辑关系(程序可读性更高)划分为若干个段,每个段都有一个段名(每段从0开始编址)。

以段为单位进行内存的分配,每个段在内存中占据者连续的空间,但各段之间可以不相邻。

image-20220928130149729

为了能够从物理内存中找到各个逻辑段的存放地址,为此需要为各进程建立一张段映射表(段表)

image-20220928132445118

(2)基本地址变换机构

基本分段存储管理地址转换的过程

image-20220928140929488

(3)分段存储与分页存储对比:

image-20220928134830805

5.段页式管理

image-20220928135239068

综合分段分页管理的优点,提出了段页式内存管理

(1)段页式管理方式:

image-20220928135607785

image-20220928135727689

(2)段表页表:

image-20220928140004786

(3)地址转换:

image-20220928140822412

二、虚拟内存管理

1.虚拟内存

操作系统将内存中暂时用不到的信息换出外存,从而实现内存的虚拟扩充就是虚拟内存技术,虚拟内存的三个特征:

  • 多次性:无需在作业运行时一次性全部装入内存,而是允许被分成多次调入内存。
  • 对换性:在作业运行时无序一直常驻内存,而是允许在作业运行过程中将作业换入、换出。
  • 虚拟性:从逻辑上扩充了内存的容量,使用户看到的内存远大于实际的容量。

注:虚拟内存的实现需要建立在离散分配的内存管理方式基础之上。

2.请求分页管理方式

与传统的基本分页管理方式不同,在程序执行过程中

若所访问的信息不在内存时,由操作系统负责将所需信息从外存调入内存,然后继续执行程序(请求调页/段)。

若内存空间不够时,由操作系统负责将内存中暂时用不到的信息换出到外存(页面/段置换)。

(1)页表机制:

image-20220929190608230

(2)缺页中断机构:

在请求分页系统中,每当要访问的页面不在内存时便产生一个缺页中断,然后由操作系统的缺页中断处理程序处理中断。此时缺页的进程阻塞,放入阻塞队列。在调页完成后再将其唤醒,放回就绪队列。

  • 如果内存有空闲块则为进程分配一个空闲块,将所缺页面装入该块,并修该页表中相应的页表项。
  • 如果内存中没有空闲块,则由页面置换算法选择一个页面淘汰。若该页面在内存期间被修改过,则要将其写回外存未修改的页面不用写回外存。
(3)地址变换机构:

请求分页存储管理与基本分页存储管理的主要区别:

  1. 请求调页(查到页表项时进行判断)
  2. 页面置换(需要调入页面,但没有空闲内存块时进行)
  3. 需要修改请求页表中新增的表项

image-20220929212124794

(4)页面置换算法:

页面换入/换出需要磁盘IO,会有较大的开销,因此好的页面置换算法应该追求更少的缺页率。

OPT最佳置换算法,Optimal:每次选择淘汰的页面是以后永不使用or在最长时间内不被访问的页面,可以保证最低的缺页率。

image-20220929215149579

注:最佳置换算法可以保证最低的缺页率,但实际上操作系统无法提前预判页面访问序列,因此OPT置换算法是无法实现的。

FIFO先进先出置换算法:每次淘汰的页面是最早进入内存的页面。

将调入内存的页面根据调入先后顺序排成队列,换出页面时选择队头页面,队列的最大长度取决于系统为进程分配的内存块数量。

image-20220929215313654

image-20220929215346399

注:FIFO会产生Belady异常,与进程实际运行时的规律不适应(先进入的页面也有可能是最进程被访问的)因此算法性能较差。

LRU最近最久未置换算法,least recently used:每次淘汰的页面是最近最久未使用的页面,

在每个页面页表项的访问字段中,记录页面自上次被访问以来所经历的时间t,需要淘汰页面时选择现有页面中t值最大的即可。

image-20220929220320078

注:LRU算法的实现需要专门的硬件支持,虽然算法性能好(最接近OPT)但是实现困哪、开销较大。

CLOCK时钟置换算法:最近未用算法NRU,Not Recently Used

为每个页面设置一个访问位,将内存中的页面都通过链接指针链接成一个循环队列。

image-20220929221219764

改进型的时钟置换算法

简单的时钟置换算法仅考虑了页面是否被访问过,

如果被淘汰的页面没有被修改过,则无需执行IO操作写回外存,只有被淘汰的页面被修改过时才需要写回外存。

因此除了考虑一个页面的访问、还应考虑是否被修改过,在其他条件都相同时应该优先淘汰没有被修改过的页面。

image-20220929222745608

(5)页面分配置换策略:

驻留集:请求分页存储管理中给进程分配的物理块/页框的集合。如果驻留集太小会导致缺页频繁,系统要花大量的时间来处理缺页,实际用于进程推进的时间很少。如果驻留集太大又会导致多道程序并发度下降,资源利用率降低。

页面分配策略:

  • 固定分配:驻留集大小不变,操作系统为每个进程分配一组固定数目的物理块,在进程运行期间不再改变。
  • 可变分配:驻留集大小可变,先为每个进程分配一定数目的物理块,在进程运行期间可根据情况适当做增加与减少。

页面置换策略:

  • 局部置换:发生缺页时只能选进程自己的物理块进行置换。
  • 全局置换:可以将操作系统保留的空闲物理块分配给缺页进程,也可以将别的进程持有的物理块置换到外存,在分配给缺页进程。

image-20220930115120463

固定分配局部置换策略

  1. 系统为每个进程分配一定数量的物理块,在运行期间都不改变。
  2. 若进程在运行中发生缺页,则只能从该进程在内存中的页面中换出一页,然后再调入需要的页面。
  3. 缺点:很难在刚开始就确定应该为每个进程分配多少个物理块才算合理。

可变分配局部置换策略

  1. 刚开始系统为每个进程分配一定数量的物理块,操作系统会保持一个空闲物理块队列,
  2. 当某进程发生缺页时,从空闲物理块中取出一块分配给该进程。若已无空闲物理块则可选择一个未锁定的页面换出外存,再将该物理块分配给缺页的进程。
  3. 采用这种策略时,只要某进程发生缺页都将获得新的物理块,仅当空闲物理块用完时,系统才选择一个未锁定的页面调出。被选择调出的页面可能是系统中的任何一个进程的页,因此这个被选中的进程拥有的物理块会减少,缺页率会增加。

可变分配全局置换策略

  1. 刚开始会为每个进程分配一定数量的物理块,当某进程发生缺页时,只允许从该进程自己的物理块中选出一个进行换出外存。
  2. 如果进程在运行中频繁地缺页,系统会为该进程多分配几个物理块,直至该进程缺页率趋势当程度。
  3. 如果进程在运行中缺页率特别低,则可适当减少分配给该进程的物理块。
  • 可变分配全局置换:只要缺页就给分配新物理块。
  • 可变分配局部置换:要根据发生缺页的频率来动态地增加或减少进程的物理块。

何时调入页面

  • 预调页策略:预测不久之后可能访问到的页面,将预先调入内存。该策略主要用于进程的首次调入,由程序员指出先调入的部分。
  • 请求调页策略:进程在运行期间发现缺页时才将所缺页面调入内存。该策略调入的页面一定会被访问到,但IO开销比较大。

何处调入页面

  • 系统拥有足够的对换区空间时

    页面的调入调出都是在内存与对换区之间进行的,从而保证页面的调入调出速度,

    在进程运行前需要将进程相关的数据从文件区复制到对换区。

  • 系统缺少足够的对换区空间时

    对于不会被修改的数据都直接从文件区调入,由于文件不会被修改因此换出时不必写回磁盘,下次需要时再从文件区调入即可。

    对于可能会被修改的部分,换出时需要写回磁盘对换区,下次需要时再从对换区调入。

  • UNIX方式:

    运行之前进程有关的数据全部放在文件区,故未使用过的页面都可从文件区调入。

    若被使用过的页面需要换出,则写回对换区,下次需要时从对换区调入。

image-20220930124929826

(6)抖动和工作集:
  • 抖动:刚换出的页面马上又要换入内存,刚换入的页面马上又要换出内存,这种频繁的页面调度行为称为抖动/颠簸。产生抖动的主要原因是进程频繁访问的页面数量高于可用的物理块数量(分配给进程的物理块不够)
  • 工作集:在某段时间间隔里,进程实际访问页面的集合。
  • 驻留集:请求分页存储管理中给进程分配的物理块/页框的集合

注:驻留集的大小一般不能小于工作集的大小,否则进程运行过程中将发生频繁的缺页。

image-20220930130711259

  • 10
    点赞
  • 64
    收藏
    觉得还不错? 一键收藏
  • 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 联系。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值