移动操作系统内核分析——Linux系统启动过程

实验一 Linux系统启动过程

  1. 编译带有调试信息的Linux内核。

1.    编译带有调试信息的Linux内核。
打开Shell终端,在Linux内核源码根目录里执行下列操作:
1)    清除以前的编译结果及配置信息:执行make mrproper
2)    以预定义的通用配置defconfig配置内核:执行make defconfig
3)    修改通用配置以满足内核调试需求:执行make menuconfig 或 make gconfig
▪    选中Kernel hacking / Compile-time checks and compiler options / Compile the kernel with debug info配置项及其子配置项:
•    Provide GDB scripts for kernel debugging
▪    去掉Processor type and features / Build a relocatable kernel / Randomize the address of the kernel image (KASLR)配置项。
4)    编译内核:执行make
编译结果说明:
▪    可启动内核镜像文件:arch/x86_64/boot/bzImage
▪    内核可执行文件(带调试信息):vmlinux

 

 

实验一:编译带有调试信息的Linux内核

 (1)、下载linux,我放在 /home/hws/linux 目录下

 

                                                  

(2)、首先清除以前编译结果及配置信息,在终端执行make mrproper,然后以通用配置defconfig配置内核,执行make defconfig 命令。

(3)、执行 make menuconfig命令来满足内核调试需求

                               

 

Ⅰ、勾选Provide GDB scripts for kernel debugging配置项

                                           

 

Ⅱ、去掉Processor type and features / Build a relocatable kernel / Randomize the address of the kernel image (KASLR)配置项。       

                                         

 

(4)、编译内核,执行make -j4 命令

                                                

(在初次写的时候,由于码字快了,没有加 -j4,等了一会儿时间,-j 参数是指定了可并行执行的作业数,通常设为计算机CPU数目的两倍以提高编译速度。)

(5)、编译结果:有一个内核可执行文件vmlinux,可用于调试,如图所示;还有一个是内核镜像文件bzImage,用于启动和运行 Linux 系统

                                      

 

 

实验二:构建小型Linux系统

(1)、下载busybox的源码,我存放的目录在/home/hws/busybox下面

 

                             

                                              

(2)、以动态链接方式(使用defconfig的默认配置选项)编译Busybox,

         Ⅰ、在Busybox 源码根目录下执行:make defconfig

                                    
         Ⅱ、在Busybox 源码根目录下执行:make install,编译好的 Busybox在 _install目录下,如图所示。

                             

(3)用 Busybox 制作根文件系统

                Ⅰ、创建 100M 磁盘镜像 rootfs.img

               

                   在磁盘镜像中创建 ext4 根文件系统

                    

                   挂载刚刚创建的根文件系统

                

               

Ⅱ、创建文件夹

             

            

            

           在根文件系统上安装busybox,busybox的_install的位置是/home/hws/busybox/_install

           

          

          

Ⅲ、创建系统配置文件 /etc/inittab,做这一步的时候,要先进行sudo bash操作,才能进行创建系统配置文件 /etc/inittab 的步骤。

       

Ⅳ、创建系统设置脚本 /etc/init.d/rcS

Ⅴ、创建系统配置文件 /etc/inittab

Ⅵ、卸载根文件系统 执行 sudo umount rootfs 命令,取消挂载rootfs,如果没有挂载,则相当于两台计算机同时挂载了同一个文件系统rootfs,写操作时可能会破坏rootfs文件系统。

     

(4)、将根文件系统挂载到Linux虚拟机上面

    

    

(5)、如果之前系统启动失败。这是因为以动态链接方式编译的Busybox可执行文件依赖于libc等多个动态链接库,而这些库没有被包含在根文件系统中,导致init程序加载失败,有两种方案可以解决,

方案一:

用ldd命令查看busybox可执行文件所依赖的库:
都能在Ubuntu主机的/lib/x86_64-linux-gnu和/lib64目录中找到。在根文件系统上创建/lib及/lib64这两个目录,
将主机上的libm.so.6、libresolv.so.2、libc.so.6库文件拷贝到根文件系统的/lib目录下;
将ld-linux-x86-64.so.2库文件拷贝到根文件系统的/lib64目录下。

方案二:

以静态链接方式编译Busybox:
(1)    在busybox源码根目录下执行make menuconfig修改配置文件,
勾选Settings / Build static binary (no shared libs)配置项,用新编译出来的busybox可执行文件替换根文件系统中的/bin/busybox文件。

 

现用方案一将Busybox依赖的动态链接库放入根文件系统中。

 

 

 

实验三:通过调试内核了解Linux系统的启动过程。

一、用qemu创建Linux虚拟机,并进入调试模式

二、用gdb调试虚拟机上运行的Linux内核程序

三、使用gdb调试命令,设置、查看、删除断点

                       

四、激活源码浏览窗口。

  Ⅰ、查看激活源码浏览窗口

                                   

Ⅱ、查看函数调用栈

Ⅲ、查看源码、显示当前执行的源码、显示当前执行的源文件信息

Ⅳ、gdb 调试命令- 单步执行等

Ⅵ、内核启动过程中各阶段入口函数的执行顺序、相互调用关系及调用时机:

  1)、在此之前内核一直是stop状态,如果按“c”则继续执行,系统开始启动,并启动到start_kernel函数的位置停在断点处,如下图所示:

                                              

 2)、查看一下start_kernel函数,里面实现了内核核心数据结构的初始化

                                      

 3)、start_kernel一直翻阅下去,可以看到arch_call_rest_init()这个函数,可见,这个start_kernel最终是调用了arch_call_rest_init()进入了外设的初始化阶段。

4)、在上面找到了这个arch_call_rest_init()函数之后,继而调用了rest_init()函数,于是在rest_init处设置断点

                   

5)、可以看出,在左边的调试窗口已经有数据显示出来

查看一下rest_init函数的代码,发现里面是创建了第一个内核线程kernel_init。也就是用0号进程创建1号进程,这个进程的执行函数就是kernel_init()

                              

6)、接下来,在kernel_init设置断点

              

7)、“c”则继续执行,系统开始启动

8)、然后我们找到这个kernel_init()函数,看其函数内容,发现里面通过调用run_init_process来运行init用户程序

                

如果ramdisk_execute_command不为0,就执行该命令成为init User Process;如果execute_command不为0,就执行该命令成为init User Process;如果上述都不成立,就依序执行如下指令

run_init_process(/sbin/init);run_init_process(/etc/init);

run_init_process(/bin/init);run_init_process(/bin/sh);

也就是说会按照顺序从/sbin/init, /etc/init, /bin/init/bin/sh依序执行第一个 init User Process.

如果都找不到可以执行的 init Process,就会进入Kernel Panic.如上图所示的panic(No init found. Try passing init= option to kernel. ”“See Linux Documentation/init.txt for guidance.);

9)、然后我们查看一下run_init_process,并设置断点。

10)、“c”则继续执行,左侧调试窗口也开始启动

run_init_procrss()处断点调试,run_init_process 就是通过 execve()来运行 init 程序。最后,init用户程序将执行后续的操作系统环境初始化设置工作。

 总结

实验一,把这个linux内核编译出来,比较容易,只要把修改通用配置以满足内核调试需求就可以了,编译速度提高的话,后面就加上-j4就可以了。

实验二,创建小型的Linux系统上面,主要是配置根文件系统,最后的话,要卸载根文件系统,如果不卸载的话,rootfs.img类似于用作qemu虚拟机的虚拟磁盘,一块磁盘不能被两台计算机同时使用,否则,当这两台计算机都有写磁盘操作的时候,会引起冲突,将彼此数据覆盖,造成磁盘里的文件系统损坏。运行到最后可能会遇到启动不了的问题,我是通过方案一的方法将Busybox依赖的动态链接库放入根文件系统中来解决的。

实验三,了解Linux系统的启动该过程,是三个实验中我耗费时间最长的一个模块,通过两个终端来了解了Linux系统启动过程的几个主要阶段。首先是内核初始化阶段,设置断点,按”C”键继续执行后,发现了start_kernel,进行了核心数据结构初始化,从start_kernel开始执行,它中间实现了内核的一系列的初始化动作,而且这函数最后面还包含了arch_call_rest_init(),来进入外设初始化阶段。继续运行后调用了rest_init来创建了第一个内核线程kernel_init完成外初始化,点开kernel_init()函数,看其函数内容,发现里面通过调用run_init_process来运行init用户程序,内核线程kernel_init转化为系统中第一个用户进程——init进程,最后init用户程序将执行后续的操作系统环境初始化设置工作。

 

隐形的稻草人,加油鸭~~~

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
对考试很有帮助的.......... 《计算机操作系统》期末复习指导 第一章 计算机操作系统概述 1、操作系统的概念 操作系统(Operating System,OS),是一种软件,属于系统软件; 1、科普的观点 操作系统是计算机系统的管理和控制中心,它依照设计者制定的各种调度策略组织和管理计算机系统资源,使之能高效地运行。 2、功能的观点 操作系统是一个计算机资源管理系统,它负责计算机系统的全部资源的分配、控制、调度和回收。 3、用户的观点 操作系统是计算机与用户之间的接口,用户通过这种接口使用计算机。 4、软件的观点 操作系统是程序和数据结构的集合。 5、管理的观点 操作系统是计算机硬件和软件资源的合理而协调的管理者。 6、 操作系统是一个大型的程序系统,它负责计算机的全部软、硬件资源的分配、调度工作,控制并协调并发活动,实现信息的存取和保护。它提供用户接口,使用户获得良好的工作环境。操作系统使整个计算机系统实现了高效率和高度自动化。 2、操作系统的生成和五大类型 生成:产生最适合自己工作环境的OS内核(kernel)。既方便用户,又使系统开销尽量小;生成的配置过程如UNIX中newconfig命令;DOS中config.sys文件;维护由系统管理员负责。 操作系统的五大类型是批处理操作系统、分时操作系统、实时操作系统、网络操作系统、分布式操作系统。 多道程序设计:即在系统内(内存)同时存放并运行几道相互独立的程序。 多道程序设计的基础:是将运行过程进一步细化成几个小的步骤,从而实现宏观上的并行。但从微观上看,内存中的多道程序轮流地或分时地占用处理机,交替执行。 多道程序系统 ≠ 多重处理系统 ≠ 多用户 ≠ 多终端 多道是指内存中驻留多个程序或一个程序的多个程序段,因此,多用户系统一定是采用多道技术。而多道系统不一定是多用户系统。多重处理系统一般指多CPU系统。当然,一个CPU的系统采用分时技术可以为多用户服务。多用户的关键技术是在用户之间要有保密保安措施。终端指用户使用的硬件设备,即使一个终端也可为多用户使用,例如,银行的自动取款机(ATM)。 •分时与实时 分时技术:把CPU的时间分成很短的时间片(例如,几十至几百毫秒)工作。随着时间片的时间减少,对换时间所占的比例随之增大。随着用户数目的不断增加,这种矛盾会越来越突出。 实时是指计算机对于外来信息能够以足够快的速度进行处理,并在被控对象允许的时间范围内做出快速反应。交互作用能力较差。 3、操作系统的五大功能 •作业管理:包括任务管理、界面管理、人机交互、图形界面、语音控制和虚拟现实等; •文件管理:又称为信息管理; •存储管理:实质是对存储“空间”的管理,主要指对内存的管理; •设备管理:实质是对硬件设备的管理,其中包括对输入输出设备的分配、启动、完成和回收; •进程管理:又称处理机管理,实质上是对处理机执行“时间”的管理,即如何将CPU真正合理地分配给每个任务。 4、表征操作系统的属性 主要有:响应比,并发性,信息的共享、保密与保护,可扩充性、可移植性、可读性、可“生成”性,安全可靠性,可测试性等。 第二章 用户与操作系统的接口 1、基本概念 作业(Job)是让计算机完成一件事或任务,可大可小,可多可少。 作业步(Job steps) :作业顺序执行的工作单元。 作业流(Job Stream) :作业步的控制流程。 作业类别:终端交互作业、批处理作业。 2、用户界面 三代用户界面: •第一代用户界面:操作命令和系统调用在一维空间(命令行界面); •第二代用户界面:图形界面在二维空间(图形界面); •第三代用户界面:虚拟现实在三维空间(虚拟现实的界面元素)。 3、传统的人机接口 •操作命令 联机(键盘操作命令)、脱机(作业控制语言) 用户组合自编(Shell语言):DOS Shell;UNIX ;BShell、CShell等 •系统调用(System Call) 4、作业输入输出方式 •输入输出方式:脱机、直接耦合(交互联机) •SPOOLing:联机外围同时操作,假脱机(排队转储,设备虚拟技术) 5、作业调度 •作业调度的功能: (1)采用JCB(作业控制块)表格,记录各作业状况; (2)按选定的算法,从后备作业队列中选出一部分(多道)或一个作业投入运行; (3)为被选中的作业做好运行前的准备工作。例如建立相应的执行进程和分配系统资源; (4)作业运行结束的善后处理工作。 •作业调度算法: (1)先来先服务(FCFS) 作业平均周转时间=∑(作业完成时刻i-作业提交时刻i)/n个作业 (2)最短作业优先:在作业内容参差很不均衡时有合理性 (3)“响应比”最高的优先 “响应(系数)比”:作业响应时间(等待和运行)/作业运行时间 (4)定时轮转法(按时间片):适合作业不定的情况 (5)优先数法:急事先办的原则 第三章进程及处理机管理 1、为什么要引入“进程” (1)进程调度属于低级处理机管理,即确定系统中哪个进程将获得CPU;而作业调度属于高级处理机管理,即确定系统中哪些作业将获得CPU。 (2)进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。 (3)引入进程的意义是描述多道程序设计系统中程序的动态执行过程。 2、进程的定义及特征 (1)程序和进程的区别 (2)进程的五个基本特征:动态性、并发性、独立性、制约性、结构性 3、进程调度 (1)进程的三个基本状态及转换 三个基本状态是等待、执行和就绪,在一定的条件下,进程的状态将发生转换。 (2)进程调度算法 主要有先来先服务(FCFS)、时间片轮转法、多级反馈轮转法、优先数法。 (3)进程控制块(PCB)是进程存在的唯一标志,它描述了进程的动态性。 4、进程通信 (1)进程的同步与互斥 一般来说同步反映了进程之间的协作性质,往往指有几个进程共同完成一个任务时在时间次序上的某种限制,进程相互之间各自的存在及作用,通过交换信息完成通信。如接力比赛中一组队员使用接力棒等。 进程互斥体现了进程之间对资源的竞争关系,这时进程相互之间不一定清楚其它进程情况,往往指多个任务多个进程间的通讯制约,因而使用更广泛。如打篮球时双方挣抢篮板球等。 (2)临界区 并发进程中与共享资源有关的程序段定义为临界区。进入临界区的准则是:①一次只准一个进程进入临界区;②本进程结束负责通知下一进程;③进程调度,不能阻塞。 (3)原语 原语是不可中断的过程。 •加锁/开锁(LOCK/UNLOCK)原语 优点是实现互斥简单;缺点是效率很低。 •信号量(Semaphore)及PV操作 PV操作能够实现对临界区的管理要求。它由P操作原语和V操作原语组成,对信号量进行操作,具体定义如下: P(S):①将信号量S的值减1,即S=S-1; ②如果S 0,则该进程继续执行;否则该进程置为等待状态,排入等待队列。 V(S):①将信号量S的值加1,即S=S+1; ②如果S>0,则该进程继续执行;否则释放队列中第一个等待信号量的进程。 信号量的数据结构为一个值和一个指针,指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时,表示当前可用资源的数量;当它的值小于0时,其绝对值表示等待使用该资源的进程个数。注意信号量的值仅能由PV操作来改变。 一般来说,信号量S 0时,S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源,因此S的值减1;当S<0时,表示已经没有可用资源,请求者必须等待别的进程释放该类资源,它才能运行下去。而执行一个V操作意味着释放一个单位资源,因此S的值加1;若S 0,表示有某些进程正在等待该资源,因此要唤醒一个等待状态的进程,使之运行下去。 •消息缓冲通信原语 高级通信原语,用于一组信息发送(Send)与读取(Read)。 5、死锁 (1)死锁的概念 死锁是两个或两个以上的进程中的每一个,都在等待其中另一个进程释放资源而被封锁,它们都无法向前推进,称这种现象为死锁现象。 产生死锁的原因是共享资源有限,多个进程对共享资源的竞争,而且操作不当。 (2)产生死锁的四个必要条件是资源互斥使用、保持和等待、非剥夺性、循环等待。 (3)解决死锁的方法 一般有死锁的预防,即破坏产生死锁的四个必要条件中的一个或多个,使系统绝不会进入死锁状态;死锁的避免,即在资源动态分配的过程中使用某种办法防止系统进人死锁状态;和允许系统产生死锁,然后使用检测算法及时地发现并解除它。 安全状态、安全系列、银行家算法等 第四章 存储管理 1、存储管理使用的基本概念 •逻辑地址与物理地址 在具有地址变换机构的计算机中,允许程序中编排的地址和信息实际存放在内存中的地址有所不同。前者叫逻辑(相对)地址,后者叫物理(绝对)地址。 •重定位:将逻辑地址转换为物理地址。 •虚拟存储管理 虚存是由操作系统调度,采用内外存的交换技术,各道程序在必需使用时调入内存,不用的调出内存,这样好象内存容量不受限制。 虚存的特点: (1)虚存容量不是无限的,极端情况受内存和外存可利用的总容量限制; (2)虚存容量还受计算机总线地址结构限制; (3)速度和容量的“时空”矛盾,虛存量的“扩大”是以牺牲CPU工作时间以及内外存交换时间为代价的。 •存储管理的目的及功能 目的是方便用户,提高内存资源的利用率,实现内存共享。 功能主要有内存的分配和管理、内存的扩充技术、内存保护技术 2、分区分配存储管理 分为固定分区、可变分区、可重定位分区、多重分区。 内存“扩充”技术: •交换:由操作系统做,用户不知道。 •覆盖:由用户控制,操作系统提供覆盖机制。 内存保护技术: ---保护系统工作区和用户作业区,特别是如何防止系统区被破坏。方法有存储保护键、界限寄存器 3、请求页式存储管理 (1)页式存储管理实现原理 基于程序在运行时不需要一开始都装入内存(局部性原理),更不应该把最近较长一段时间内不用的程序装入内存。 (2)页表的作用是将逻辑页号转换为物理块号。 (3)页面淘汰算法 先进先出算法(FIFO)、循环检测法、最近最少使用页面先淘汰(LRU)、最不经常使用的页面先淘汰(LFU)、最近没有使用页面先淘汰(NUR)、最优淘汰算法(OPT)等。 (4)页式存储管理的优、缺点 优点: •虛存量大,适合多道程序运行,用户不必担心内存不够的调度操作; •内存利用率高,不常用的页面尽量不留在内存; •不要求作业连续存放,有效地解决了“碎片”问题。与分区式相比,不需移动作业;与多重分区比,无零星碎片产生。 缺点: •要处理页面中断、缺页中断处理等,系统开销较大; •有可能产生“抖动”; •地址变换机构复杂,为提高速度采用硬件实现,增加了机器成本。 4、段式、段页式存储管理 段式、页式存储管理的对比。 段页式存储管理特点: •每一段分若干页,再按页式管理,页间不要求连续; •用分段方法分配管理作业,用分页方法分配管理内存; •兼有段式和页式管理的优点,系统复杂和开销增大,一般在大型机器上才使用。 第五章文件管理 1、文件管理任务与功能 任务:把存储、检索、共享和保护文件的手段,提供给操作系统本身和用户,以达到方便用户和提高资源利用率的目的。 功能: ---分配与管理外存 ---提供合适的存储方法 ---文件共享、保护,解决命名冲突 文件组织结构:文件、文件元素、文件系统 •文件系统 = 文件管理程序(文件和目录的集合)+ 它所管理的全部文件; •文件系统是用户与外存的接口; •为用户提供统一方法(以数据记录的逻辑单位),访问存储在物理介质上的信息。 2、文件分类 (1)按文件性质与用途分:系统文件、库文件、用户文件 (2)按操作保护分:只读文件、可读可写文件、可执行文件 (3)按使用情况分:临时文件、永久文件、档案文件 (4)按用户观点分:普通文件、目录文件、特殊文件 (5)按存取的物理结构分:顺序(连续)文件、链接文件、索引文件 (6)按文件的逻辑存储结构分:有结构文件、无结构文件 (7)按文件中的数据形式分:源文件、目标文件 3、文件的逻辑结构和物理结构 •文件的逻辑结构 ---从用户观点看 ---按文件名及记录号存取文件,是一维、连续的字符序列,方便存储、检索或加工 ---文件由若干个逻辑记录组成,并加以命名或编号 •文件的物理结构 又称文件的存储结构,是指文件在外存上的存储组织形式,是与存储介质的存储性能有关; 空闲空间的管理方法主要有:空闲表法、空闲(自由)链表法、成组链接法 4、文件目录 (1)文件目录分类:一级文件目录、二级文件目录、多级文件目录 (2)文件目录的管理 •目录做成文件,文件系统便于内部统一管理,目录文件在使用时调入内存; •在操作系统中,大量采用“表格”管理。 5、文件存取控制 •解决文件保护、保密和共享 •常用的文件存取控制方法有:存取控制矩阵、用户权限表、使用口令、使用密码 6、文件系统的数据结构和表示 UNIX或Linux操作系统中文件系统的主要特点 (1)操作系统文件的目录组织是一个树形结构,从根结点到叶子称为文件的全路径名,文件可以由其全路径名唯一确定; (2)文件本身是无结构的字符流; (3)把外部设备的特殊文件和普通文件以及目录文件都统一在文件这一概念上,对于一般文件的访问、共享和保护方式也可以适用于外部设备。 第六章 输入输出设备管理 1、设备管理的任务和功能 •设备管理的任务 (1)按用户需求提出的要求接入外部设备,系统按一定算法分配和管理控制,而用户不必关心设备的实际地址和控制指令; (2)尽量提高输入输出设备的利用率,例如发挥主机与外设以及外设与外设之间的真正并行工作能力。 •设备管理的功能 (1)分配设备 (2)控制和实现真正的输入输出操作 (3)对输入输出缓冲区进行管理 (4)在一些较大系统中实现虚拟设备技术 2、外部设备分类 (1)按系统和用户分:系统设备、用户设备 (2)按输入输出传送方式分(UNIX或Linux操作系统):字符型设备、块设备 (3)按资源特点分:独享设备、共享设备、虚拟设备 (4)按设备硬件物理特性分:顺序存取设备、直接存取设备 (5)按设备使用分:物理设备、逻辑设备、伪设备 •设备I/O方式:询问、通道、中断 •I/O设备分配算法:先来先服务(FCFS)、按优先级进行分配 3、设备管理技术 (1)I/O设置缓存理由 •解决信息的到达率和离去率不一致的矛盾; •缓存起中转站的作用; •使得一次输入的信息能多次使用; •在通道或控制器内设置局部寄存器作为缓冲存储器,可暂存I/O信息,以减少中断CPU的次数。这种情形可进一步推广,使得一次读入的信息可多次重复使用。 (2)虚拟设备的技术(SPOOLing) SPOOLing,即外围设备联机并行操作,它是关于慢速字符设备如何与计算机主机交换信息的一种技术,通常也叫做“假脱机技术”。是一种预输入、缓输出和转储的管理技术. SPOOLing系统的特点: •提高了I/O速度; •将独享设备改造为共享设备(典型例子是打印机的“共享”); •实现了虚拟设备功能。 4、设备处理程序编制内容 •设备驱动程序的功能 (1)将接收到的抽象要求转换为具体要求; (2)检查用户I/O请求的合法性,了解I/O设备的状态,传递有I/O关参数,设置设备的工作方式; (3)发出I/O命令,启动分配到的I/O设备,完成指定的I/O 操作; (4)及时响应由控制器或通道发来的中断请求,并根据其中断类型调用相应的中断处理程序进行处理; (5)对于设置有通道的计算机系统,驱动程序还应能够根据用户的 I/O请求,自动地构成通道程序。 •设备驱动程序的特点 (1)驱动程序主要是在请求I/O的进程与设备控制器之间的一个通信程序。 (2)驱动程序与I/O设备的特性紧密相关。 (3)驱动程序与I/O控制方式紧密相关。 (4)由于驱动程序与硬件紧密相关,因而其中的一部分程序用汇编语言书写,目前有很多驱动程序,其基本部分已经固化,放在ROM中。 •设备处理方式 (1)将抽象要求转换为具体要求 (2)检查I/O请求的合法性 (3)读出和检查设备的状态 (4)传送必要的参数 (5)方式的设置和I/O设备启动 难点分析 •如何理解操作系统在计算机系统中的地位? 操作系统是软件,而且是系统软件。它在计算机系统中的作用,大致可以从两方面体会:对内,操作系统管理计算机系统的各种资源,扩充硬件的功能;对外,操作系统提供良好的人机界面,方便用户使用计算机。它在整个计算机系统中具有承上启下的地位。 •系统调用与一般过程调用的区别。 系统调用在本质上是一种过程调用,但它是一种特殊的过程调用,它与一般过程调用的主要区别如下: (1)运行状态不同。一般的过程调用,其调用和被调用过程都是用户程序,它们都运行在同一系统状态下;而系统调用的调用过程是用户程序,它运行在用户态,其被调用过程是系统过程,运行在系统态。 (2)进入方式不同。一般过程调用可以直接通过过程调用语句将控制转移到被调用过程;而执行系统调用时,由于调用和被调用过程处于不同系统状态,必须通过访管中断进入。 (3)代码层次不同。一般过程调用中的被调用程序是用户级程序,而系统调用是操作系统中的代码程序,是系统级程序。 •下表给出作业l、2、3的提交时间和运行时间。采用先来先服务调度算法和短作业优先调度算法,试问平均周转时间各为多少?(时间单位:小时,以十进制进行计算。) 解:采用先来先服务调度策略,则调度顺序为l、2、3。  平均周转时间T=(8+11.6+12)/3=10.53 采用短作业优先调度策略,则调度顺序为l、3、2。  平均周转时间T=(8+8+12.6)/3=9.53 •试述文件管理系统设置打开文件、关闭文件命令的原因。 解:操作系统需要处理大量用户文件,而访问一个文件需要查询目录,有时甚至需要多次查询目录。由于文件目录与文件一起存放在辅存上,当存取文件时,必须先到辅存中读取文件目录信息,从中获得文件的存放地址,然后再去存取文件。这样一来,文件信息的存取将花费很多时间。如果将整个文件目录放入主存,虽然可以提高存取速度,但这需要占用大量主存空间,显然这也是不可取的。 实际上,在一段时间内使用的文件数总是有限的,因此只要将目录中当前要使用的那些文件的目录表目复制到内存中就可以了。这样既不占用太多的主存空间,又可显著提高查询文件目录的速度。为此,大多数操作系统中设置了两个文件操作:打开文件和关闭文件。 打开文件操作完成的功能是将文件的有关目录信息复制到主存活动文件表中,以建立用户和这个文件的联系。关闭文件操作的功能是用户宣布这个文件当前不再使用,系统将其在主存中的相应目录信息删去,因而也就切断了用户同这个文件的联系。 •有一个文件系统如图(a)所示,图中的框表示目录,圈表示普通文件。根目录常驻内存,目录文件组织成链接文件,不设文件控制块,普通文件组织成索引文件。目录表目指示下一级文件名及其磁盘地址(各占2个字节,共4个字节)。若下级文件是目录文件,指示其第一个磁盘块地址。若下级文件是普通文件,指示其文件控制块的磁盘地址。每个目录文件磁盘块最后4个字节供拉链使用。下级文件在上级目录文件中的次序在图中为从左至右。每个磁盘块有512字节,与普通文件的一页等长。 普通文件的文件控制块组织结构如图(b)所示,其中每个磁盘地址占2个字节,前10个地址直接指示该文件前10页的地址。第11个地址指示一级索引表地址,一级索引表中每个磁盘地址指示一个文件页地址;第12个地址指示二级索引表地址,二级索引表中每个地址指示一个一级索引表地址;第13个地址指示三级索引表地址,三级索引表中每个地址指示一个二级索引表地址。问: (1)一个普通文件最多可有多少个文件页? (2)若要读文件J中的某一页,最多启动磁盘多少次? (3)若要读文件W中的某一页,最少启动磁盘多少次? 答:(1)由题目中所给条件可知,磁盘块大小为512字节,每个磁盘地址占2个字节。因此,一个一级索引表可容纳256个磁盘地址。同样地,一个二级索引表可容纳256个一级索引表地址,一个三级索引表可容纳256个二级索引表地址。这样,一个普通文件最多可有页数为:10+256+256×256+256×256×256=16843018 (2)从图(a)中可以看出,目录文件A和目录文件D中的目录项都只有两个,因此这两个目录文件都不需要拉链。若要读文件J中的某一项,首先从内存的根目录中找到目录文件A的磁盘地址,将其读入内存(第1次访问磁盘)。然后再从目录A中找出目录文件D的磁盘地址,并将其读入内存(第2次访问磁盘)。从目录D中找出文件J的文件控制块地址,将文件J的文件控制块读入内存(第3次访问磁盘)。在最坏情况下,要访问页的磁盘地址需通过三级索引才能找到,这时要三次访问磁盘才能将三级索引表读入内存(第4、5、6次访问磁盘)。最后读入文件J中的相应页(第7次访问磁盘)。 由此可知,若要读文件J中的某一页,最多启动磁盘7次。 (3)从图(a)中可以看出,目录文件C和目录文件U中,目录项数目较多,若目录项数超过127(512/4-l=127),则目录文件的读入可能需要多次磁盘读(因目录文件组织成链接文件)。在最好情况下,所找的目录项都在目录文件的第一个磁盘块中。若要读文件W中的某一页,首先从内存的根目录中找到目录文件C的磁盘地址,将其读入内存(第1次访问磁盘)。在最好情况下,能从目录C的第一个磁盘块中找出目录文件互的磁盘地址,并将其读入内存(第2次访问磁盘)。从目录I中找出目录文件P的的磁盘地址,将其读入内存(第3次访问磁盘)。从目录P中找到目录文件U的磁盘地址,将其读入内存(第4次访问磁盘)。在最好情况下,能从目录U的第一个磁盘块中找出文件W的文件控制块地址,将文件W的文件控制块读入内存(第5次访问磁盘)。在最好情况下,要访问的页在前10页中,这时可直接得到该页的磁盘地址。最后读入文件W中的相应页(第6次访问磁盘)。 由此可知,若要读文件W中的某一页,最少启动磁盘6次。 •采用可变分区管理存储空间时,若主存中按地址顺序依次有五个空闲区,大小分别为15K、28K、10K、226K、110K。现有五个作业J1到J5,它们所需的主存空间依次是10K、15K、102K、26K、180K。问如果采用首次适应分配算法,能否把这五个作业按J1到J5的次序全部装入主存。使用哪种分配算法装入这五个作业,可使主存的利用率最高? 解:按首次适应分配算法,不能把这五个作业全部依次装入主存。这时J1、J2装入第1、2个空闲区,J3、J4装入第4、5个空闲区,J5有180K,无法装入仅有的10K空闲区。 能使主存利用率最高的是采用最佳适应分配算法。这时,这五个空闲块分别装入作业J2、J4、J1、J5、J3。 •某虚拟存储器的用户编程空间共32个页面,每页为1KB,内存为16KB。假定某时刻一用户页表中已调入内存的页面的页号和物理块号的对照表如下: 请计算逻辑地址0A5C(H)所对应的绝对地址。 解:页式存储管理的逻辑地址分为两部分:页号和页内地址。由已知条件“用户编程空间共32个页面”,可知页号部分占5位;由“每页为1KB”,1K=210,可知内页地址占10位。由“内存为16KB”,可知有16块,块号为4位。 逻辑地址0A5C(H)所对应的二进制表示形式是:000 1010 0101 1100 ,根据上面的分析,下划线部分为页内地址,编码 “000 10” 为页号,表示该逻辑地址对应的页号为2。查页表,得到物理块号是4(十进制),即物理块地址为:01 00 ,拼接块内地址10 0101 1100,得01 0010 0101 1100,即125C(H)。 •某采用页式存储管理的系统,接收了一个共7页的作业,作业执行时依次访问的页为:1、2、3、4、2、1、5、6、2、1、2、3、7。当内存块数量为4时,请分别用先进先出(FIFO)调度算法和最近最少使用(LRU)调度算法,计算作业执行过程中会产生多少次缺页中断?写出依次产生缺页中断后应淘汰的页。(所有内存开始时都是空的,凡第一次用到的页面都产生一次缺页中断。要求写出计算过程) 解:(1)采用先进先出(FIFO)调度算法,页面调度过程如下: 所以,共产生10次缺页中断,依次淘汰的页是1、2、3、4、5、6。 (2)采用最近最少使用(LRU)调度算法,页面调度过程如下: 因此,共产生8次缺页中断,依次淘汰的页是3、4、5、6。 •试述分页式存储管理系统和分段式存储管理系统的主要区别。 解:分页和分段有许多相似之处,比如两者都不要求作业连续存放。但在概念上两者完全不同,主要表现在以下几个方式: (1)页是信息的物理单位,分页是为了实现非连续分配,以便解决内存碎片问题,或者说分页是由于系统管理的需要。段是信息的逻辑单位,它含有一组意义相对完整的信息,分段的目的是为了更好地实现共享,满足用户的需要。 (2)页的大小固定,由系统确定,将逻辑地址划分为页号和页内地址是由机器硬件实现的。而段的长度却不固定,决定于用户所编写的程序,通常由编译程序在对源程序进行编译时根据信息的性质来划分。 (3)分页的作业地址空间是一维的。分段的地址空间是二维的。 •为什么说有了通道技术和中断技术才真正做到了CPU与外设的并行操作? 解:通道是负责外围设备与主存之间进行数据交换,能单独完成输入输出操作的处理机。有了通道,主存和外围设备之间的数据交换就不要CPU干预了,CPU可以做与输入输出无关的其他工作,从而使计算机系统获得了CPU与外围设备之间并行工作的能力。 I/O中断是通道和CPU协调工作的一种手段。如果没有中断技术,CPU就要不断去查询通道以及设备执行的情况,这样一来,CPU还是把大量的时间花在了查询上,不能很好地为其他进程服务。使用中断技术,CPU可以完全不管通道和设备的执行情况,因为无论操作正常结束或操作异常结束,通道都会发出中断,通知CPU来处理。 综上所述,通道技术和中断技术的出现,使得主存可以直接与外设交换数据,而CPU得以并行地工作,大大提高了CPU的使用效率。 •某分时系统的进程出现如图所示的状态变化。 试问:(1)你认为该系统采用的是何种进程调度算法? (2)把图中所示的六个状态变化的原因写出来。 解:(1)该分时系统采用的进程调度算法是时间片轮转法。 (2)①进程被选中,变成运行态;②时间片到,运行的进程排入就绪队列尾部;③运行的进程启动打印机,等待打印;④打印工作结束,等待的进程排入就绪队列尾部;⑤等待磁盘读文件工作;⑥磁盘传输信息结束,等待的进程排入就绪队列尾部。 •怎样理解操作系统的作业调度和进程调度的关系? 解:作业调度和进程调度都属于处理机调度。作业调度是处理机管理的高级形式,它的主要功能是审查系统是否能满足用户作业的资源要求以及按照一定的算法来选取作业。进程调度是处理机管理的低级形式,它的主要功能是根据一定的算法将CPU分派给就绪队列中的一个进程。 作业的状态及其转换 操作系统中作业的状态主要有:提交、后备、执行、完成,进程的状态主要有等待、就绪、执行。作业调度和进程调度的转换关系见下图。 •用PV操作实现进程间的同步与互斥应该注意什么? 解:用PV操作实现进程间的同步与互斥,应该注意以下四方面问题: (1)对每一个共享资源都要设立信号量。互斥时对一个共享资源设立一个信号量;同步时对一个共享资源可能要设立两个或多个信号量,要视由几个进程来使用该共享变量而定。 (2)互斥时信号量的初值一般为1;同步时至少有一个信号量的初值大于等于1。 (3)PV操作一定要成对调用。互斥时在临界区前后对同一信号量作PV操作;同步时则对不同的信号量作PV操作,PV操作的位置一定要正确。 (4)对互斥和同步混合问题,PV操作可能会嵌套,一般同步的PV操作在外,互斥的PV操作在内。 三、课程练习及参考解答 一、填空 1、设备I/O方式有如下三种:_________、__________和___________。 2、文件存取方式按存取次序通常分_________________、_______________,还有一类 ______________。 3、从用户观点看,UNIX系统将文件分三类:___________________、___________________和 _________________。 4、引起死锁的四个必要条件是 、________________、 和__________________。 5、进程的三个最基本状态是_____________、____________和_____________。 6、传统操作系统提供编程人员的接口称为________________。 7、三代人机界面的发展是指:______________、_________________和_______________。 8、常用的进程调度算法有_________________、_________________和___________________。 二、选择一个正确答案的序号填入括号中 1、计算机操作系统是一个( )。 A. 应用软件 B. 硬件的扩充 C. 用户软件 D.系统软件 2、操作系统程序结构的主要特点是( )。 A. 一个程序模块 B. 分层结构 C. 层次模块化结构 D. 子程序结构 3、面向用户的组织机构属于( )。 A. 虚拟结构 B. 逻辑结构 C. 实际结构 D. 物理结构 4、操作系统中应用最多的数据结构是( )。 A. 堆栈 B. 队列 C. 表格 D. 树 5、可重定位内存分区分配目的为( )。 A. 解决碎片问题 B. 便于多作业共享内存 C. 回收空白区方便 D. 摆脱用户干预 6、逻辑地址就是( )。 A. 用户地址 B. 相对地址 C. 物理地址 D.绝对地址 7、原语是( )。 A. 一条机器指令 B. 若干条机器指令组成 C. 一条特定指令 D. 中途能打断的指令 8、索引式(随机)文件组织的一个主要优点是( )。 A. 不需要链接指针 B. 用户存取方便 C.回收实现比较简单 D.能实现物理块的动态分配 9、几年前一位芬兰大学生在Internet上公开发布了以下一种免费操作系统核心( ),经过许多人的努力,该操作系统正不断完善,并被推广。 A. Windows NT B. Linux C. UNIX D. OS2 10.文件目录的主要作用是( )。 A. 按名存取 B.提高速度 C.节省空间 D.提高外存利用率 11、某进程在运行过程中需要等待从磁盘上读入数据,此时该进程的状态是( )。 A. 从就绪变为运行 B.从运行变为就绪 C. 从运行变为阻塞 D.从阻塞变为就绪 12、把逻辑地址转变为内存的物理地址的过程称作( )。 A.编译 B.连接 C.运行 D.重定位 13、进程和程序的一个本质区别是( )。 A.前者分时使用CPU, 后者独占CPU B.前者存储在内存,后者存储在外存 C.前者在一个文件中,后者在多个文件中 D.前者为动态的,后者为静态的 三、是非题,正确的在括号内划√,错的划×。 ( )1、进程间的相互制约关系体现为进程的互斥和同步。 ( )2、只有一个终端的计算机无法安装多用户操作系统。 ( )3、UNIX的最大特点是分时多用户、多任务和倒树型文件结构。 ( )4、常用的缓冲技术有双缓冲,环形缓冲和缓冲池。 ( )5、实时操作系统的响应系数最小,设备利用率最差。 ( )6、死锁是指两个或多个进程都处于互相等待状态而无法继续工作。 ( )7、具有多道功能的操作系统一定是多用户操作系统。 ( )8、一般的分时操作系统无法做实时控制用。 ( )9、多用户操作系统在单一硬件终端硬件支持下仍然可以工作。 ( )10、常用的缓冲技术是解决慢速设备与快速CPU处理之间协调工作。 四、回答题 1、试以生产者——消费者问题说明进程同步问题的实质。 2、以一台打印机为例,简述SPOOLing 技术的优点。 3、简述请求页式存储管理的优缺点。 4、虚拟存储器的基本特征是什么?虚拟存储器的容量主要受到什么限制? 5、现代操作系统与传统操作系统相比,设计中采用了哪些先进技术? 练习参考解答 一、填空 1、询问、中断、通道 2、顺序存取、直接存取、按键索引 3、普通(用户)、目录、特殊 4、互斥使用、保持和等待、非剥夺性、循环等待 5、准备(就绪)、执行、等待 6、系统调用 7、一维命令行、二维图形界面、三维虚拟现实 8、先来先服务、优先数法、轮转法 二、选择题 1、D 2、C 3、B 4、C 5、A 6、B 7、B 8、D 9、B 10、A 11、C 12、D 13、D 三、是非题 有错误的是第2、5、7题,其余均是正确的。 四、回答题 1、答:一个生产者,一个消费者和一个产品之间关系是典型的进程同步问题。设信号量S为仓库内产品,P-V操作配对进行缺一不可。生产者进程将产品放入仓库后通知消费者可用;消费者进程在得知仓库有产品时取走,然后告诉生产者可继续生产。 2、答:以一台打印机为例, SPOOLing 技术的主要优点是在多用户情况下,每一个用户使用打印机就好像自己拥有一台打印机。不会产生打印机“忙”而等待。 3、答:优点: (1)虛存量大,适合多道程序运行,用户不必担心内存不够的调度操作。动态页式管理提供了内存与外存统一管理的虚存实现方式。 (2)内存利用率高,不常用的页面尽量不留在内存。 (3)不要求作业连续存放,有效地解决了“碎片”问题。与分区式比,不需移动作业;与多重分区比,无零星碎片产生。UNIX操作系统较早采用。 缺点: (1)要处理页面中断、缺页中断处理等,系统开销较大。 (2)有可能产生“抖动”。 (3)地址变换机构复杂,为提高速度采用硬件实现,增加了机器成本。 4、答:虚存是由操作系统调度,采用内外存的交换技术,各道程序在必需使用时调入内存,不用的调出内存,这祥好像内存容量不受限制。但要注意: (1)虚存容量不是无限的,极端情况受内存、外存的可使用的总容量限制; (2)虚存容量还受计算机总线长度的地址结构限制; (3)速度和容量的“时空”矛盾,虛存量的“扩大”是以牺牲CPU工作时间以及内、外存交换时间为代价的。 5、答:现代操作系统是指网络操作系统和分布式操作系统,采用了网络地址方案、网络协议、路由技术和微内核等先进技术。
文将对 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 联系。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

隐形的稻草人HWS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值