系统编程与操作系统

第一部分  系统编程                  
 第1章  语言处理程序                  
 1.1  引言                  
 1.2  语言处理工作                  
 1.2.1  程序生成                  
 1.2.2  程序执行                  
 1.3  语言处理的基础                  
 1.3.1  简易的编译程序                  
 1.4  语言规格基本说明                  
 1.4.1  程序设计语言的语法                  
 练习1.4                  
 1.4.2  约束和约束时刻                  
 1.5  语言处理程序开发工具                  
 1.5.1  LEX                  
 1.5.2  YACC                  
 参考文献                  
 第2章  语言处理程序的数据结构                  
 2.1  查找型数据结构                  
 2.1.1  表的组织                  
 2.1.2  链表和树型结构组织形式                  
 练习2.1                  
 2.2  分配型数据结构                  
 2.2.1  栈                  
 2.2.2  堆                  
 参考文献                  
 第3章  扫描与分析                  
 3.1  扫描                  
 练习3.1                  
 3.2  分析                  
 3.2.1  自顶向下的分析                  
 练习3.2.1                  
 3.2.2  自底向上的分析                  
 练习3.2                  
 参考文献                  
 第4章  汇编程序                  
 4.1  汇编程序要素                  
 4.1.1  汇编语言语句                  
 4.1.2  汇编程序的优点                  
 4.2  简单的汇编模式                  
 4.3  汇编程序的遍扫描结构                  
 4.4  两遍扫描汇编程序的设计                  
 4.4.1  高级的汇编指示语句                  
 练习4.4.1                  
 4.4.2  汇编程序的第1遍扫描                  
 4.4.3  中间代码形式                  
 4.4.4  祈使语句的中间代码                  
 4.4.5  说明语句与汇编程序指示语句的处理                  
 练习4.4                  
 4.4.6  汇编程序的第2遍扫描                  
 4.4.7  列表和错误信息报告                  
 练习4.4.7                  
 4.4.8  有关组织结构的一些话题                  
 练习4.4.8                  
 4.5  用于IBM PC机的单遍扫描汇编程序                  
 4.5.1  Intel 8088微处理器的体系结构                  
 4.5.2  Intel 8088的指令                  
 4.5.3  Intel 8088汇编语言                  
 4.5.4  单遍扫描汇编程序的问题                  
 4.5.5  汇编程序设计                  
 参考文献                  
 第5章  宏与宏处理程序                  
 5.1  宏定义与宏调用                  
 5.2  宏扩展                  
 5.3  嵌套的宏调用语句                  
 5.4  高级宏设施                  
 5.4.1  条件扩展                  
 5.4.2  用于扩展时循环的其他设施                  
 5.4.3  语义扩展                  
 练习5.4                  
 5.5  宏预处理程序的设计                  
 5.5.1  设计概述                  
 5.5.2  数据结构                  
 5.5.3  宏定义的处理                  
 5.5.4  宏扩展                  
 5.5.5  嵌套的宏调用                  
 练习5.5                  
 5.5.6  宏-汇编程序的设计                  
 练习5.5                  
 参考文献                  
 第6章  编译程序和解释程序                  
 6.1  组成编译的各个方面                  
 6.2  内存分配                  
 6.2.1  静态和动态内存分配                  
 6.2.2  体结构语言的内存分配                  
 6.2.3  数组的分配与访问                  
 练习6.2                  
 6.3  表达式编译                  
 6.3.1  一个用于表达式的代码生成器                  
 练习6.3.1                  
 6.3.2  表达式的中间代码                  
 练习6.3.2                  
 6.4  对控制结构的编译                  
 练习6.4                  
 6.5  代码优化                  
 6.5.1  优化变换                  
 6.5.2  局部优化                  
 6.5.3  全局优化                  
 练习6.5                  
 6.6  解释程序                  
 6.6.1  解释程序纵观                  
 6.6.2  一个小(型)解释程序                  
 6.6.3  解释程序与不纯解释程序                  
 练习6.6                  
 参考文献                  
                   
 第7章  连接程序                  
 7.1  重定位和连接的概念                  
 7.1.1  程序的重定位                  
 7.1.2  连接                  
 7.1.3  目标模块                  
 7.2  连接程序的设计                  
 7.2.1  段寻址的重定位和连接需求                  
 7.2.2  重定位算法                  
 7.2.3  连接需求                  
 练习7.2                  
 7.3  自(身)重定位程序                  
 练习7.3                  
 7.4  一个适用于MS DOS的连接程序                  
 练习7.4                  
 7.5  覆盖块的连接                  
 练习7.5                  
 7.6  装入程序                  
 练习7.6                  
 参考文献                  
 第8章  软件工具                  
 8.1  程序开发软件工具                  
 8.1.1  程序设计和编码                  
 8.1.2  程序输入和编辑                  
 8.1.3  程序测试与调试                  
 8.1.4  提高程序性能                  
 8.1.5  程序文档编制                  
 8.1.6  设计软件工具                  
 8.2  编辑器                  
 8.2.1  屏幕编辑器                  
 8.2.2  文字处理器                  
 8.2.3  结构编辑器                  
 8.2.4  设计编辑器                  
 8.3  调试监视程序                  
 8.4  编程环境                  
 练习8.4                  
 8.5  用户界面                  
 8.5.1  命令对话                  
 8.5.2  数据的呈现                  
 8.5.3  联机帮助                  
 8.5.4  用户界面的结构                  
 8.5.5  用户界面管理系统                  
 练习8.5                  
 参考文献                  
 第二部分  操作系统                  
 第9章  操作系统功能的演化                  
 9.1  操作系统的功能                  
 9.1.1  资源分配及相关功能                  
 9.1.2  用户接口相关功能                  
 9.2  操作系统功能演化                  
 9.3  批处理系统                  
 9.3.1  用户服务                  
 9.3.2  批监控程序的功能                  
 9.3.3  支持批处理的特殊特征                  
 练习9.3                  
 9.4  多道程序系统                  
 9.4.1  多道程序管理的结构支持                  
 9.4.2  用户服务                  
 9.4.3  多道程序管理程序的功能                  
 练习9.4                  
 9.5  分时系统                  
 9.5.1  调度                  
 9.5.2  存储器管理                  
 练习9.5                  
 9.6  实时操作系统                  
 练习9.6                  
 9.7  操作系统结构                  
 参考文献                  
 第10章  进程                  
 10.1  进程定义                  
 练习10.1                  
 10.2  进程控制                  
 10.2.1  进程创立                  
 10.2.2  进程状态                  
 10.2.3  与进程相关的事件                  
 10.2.4  进程控制块                  
 10.2.5  进程调度                  
 10.2.6  进程终止                  
 10.2.7  总结                  
 10.3  进程交互                  
 10.3.1  同步控制                  
 10.3.2  数据访问同步                  
 10.3.3  进程间通信                  
 练习10.3                  
 10.4  实现进程交互                  
 10.4.1  Fork-Join                  
 10.4.2  Parbegin-Parend                  
 10.4.3  Unix中的进程                  
 10.5  线程                  
 练习10.5                  
 参考文献                  
 第11章  调度                  
 11.1  调度策略                  
 11.1.1  非抢占调度                  
 练习11.1.1                  
 11.1.2  抢占调度                  
 练习11.1.2                  
 11.2  作业调度                  
 11.3  进程调度                  
 11.3.1  事件监视                  
 11.3.2  进程调度机构                  
 11.3.3  多道程序设计中的进程调度                  
 11.3.4  分时系统中的进程调度                  
 11.3.5  多级调度                  
 练习11.3                  
 11.4  Unix中的进程管理                  
 练习11.4                  
 11.5  多处理器操作系统中的调度                  
 11.5.1  主-从配置                  
 11.5.2  对称多处理器                  
 练习11.5                  
 参考文献                  
 第12章  死锁                  
 12.1  定义                  
 12.2  建立资源状态模型                  
 12.2.1  资源请求和分配图及等待图中的路径                  
 12.2.2  死锁的条件                  
 12.3  处理死锁                  
 12.4  检测和解决死锁                  
 12.4.1  死锁检测算法                  
 12.4.2  死锁解决                  
 12.5  避免死锁                  
 12.5.1  所有的请求在一起提出                  
 12.5.2  资源分级                  
 12.5.3  银行家算法                  
 12.6  死锁处理的混合方式                  
 练习12.6                  
 参考文献                  
 第13章  进程同步                  
 13.1  实现控制同步                  
 练习13.1                  
 13.2  临界区                  
 13.2.1  临界段实现的特性                  
 13.2.2  实现临界段的历史                  
 13.2.3  用临界段实现进程同步                  
 13.2.4  临界段的算法实现                  
 练习13.2                  
 13.3  经典的进程同步问题                  
 13.3.1  有限长度缓冲区的生产者消费者问题                  
 13.3.2  读者和写者                  
 13.3.3  哲学家进餐                  
 13.4  进程同步语言特征的演化                  
 13.5  信号量                  
 13.5.1  实现信号量                  
 13.5.2  使用信号量的生产者消费者                  
 13.5.3  使用信号量的读者和写者                  
 练习13.5                  
 13.6  临界区                  
 13.7  条件临界区                  
 练习13.7                  
 13.8  管程                  
 13.8.1  抽象                  
 13.8.2  封装                  
 13.8.3  管程特性                  
 13.8.4  磁盘调度器：实例分析                  
 练习13.8                  
 13.9  Ada中的并行程序设计                  
 13.9.1  Ada中的任务                  
 13.9.2  Ada中的实时程序设计                  
 练习13.9                  
 参考文献                  
 第14章  进程间通信                  
 14.1  进程间消息                  
 14.2  关于实现的问题                  
 14.2.1  命名                  
 14.2.2  消息传送协议                  
 14.2.3  进程间消息的缓冲                  
 14.2.4  进程间消息的传送                  
 练习14.2                  
 14.3  邮箱                  
 14.3.1  一个邮箱的实现                  
 14.3.2  使用邮箱的好处                  
 练习14.3                  
 14.4  UNIX环境下的进程间消息                  
 练习14.4                  
 14.5  MACH中的进程间消息                  
 练习14.5                  
 参考文献                  
 第15章  存储器管理                  
 15.1  内存分配的基础知识                  
 15.1.1  内存重用                  
 15.1.2  内存分配模型                  
 15.2  连续内存分配                  
 15.2.1  内存保护                  
 15.2.2  程序重定位                  
 15.2.3  内存碎片                  
 15.2.4  程序初始装入                  
 练习15.2                  
 15.3  不连续内存分配                  
 15.4  虚拟内存页式管理                  
 15.4.1  页. 页块和地址转换                  
 15.4.2  请求分页式存储管理                  
 15.4.3  分页硬件                  
 练习15.4                  
 15.4.4  分页软件                  
 15.4.5  页面淘汰                  
 15.4.6  控制程序的内存分配                  
 15.4.7  页共享                  
 练习15.4                  
 15.4.8  Ｕnix内存管理                  
 15.5  虚拟内存段式管理                  
 15.5.1  组织多段程序                  
 15.5.2  管理物理内存                  
 15.5.3  保护和共享                  
 15.5.4  段页式                  
 15.5.5  实例研究                  
 练习15.5                  
 参考文献                  
 第16章  IO组织和IO编程                  
 16.1  IO组织                  
 16.2  IO设备                  
 练习16.2                  
 16.3  物理输入输出控制系统(PIOCS)                  
 16.3.1  PIOCS的功能                  
 16.3.2  PIOCS的数据结构                  
 16.3.3  PIOCS功能的实现                  
 16.3.4  设备驱动程序                  
 练习16.3                  
 16.4  基本文件组织                  
 16.4.1  顺序文件组织                  
 16.4.2  直接文件组织                  
 16.4.3  索引顺序文件组织                  
 练习16.4                  
 16.5  高级IO程序设计                  
 16.5.1  记录的缓冲                  
 16.5.2  记录块                  
 练习16.5                  
 16.6  逻辑IOCS                  
 16.6.1  LIOCS函数                  
 16.6.2  LIOCS模块                  
 16.6.3  LIOCS数据结构                  
 16.6.4  LIOCS功能的实现                  
 练习16.6                  
 16.7  处理UNIX中的文件                  
 练习16.7                  
 参考文献                  
 第17章  文件系统                  
 17.1  目录结构                  
 练习17.1                  
 17.2  文件保护                  
 17.3  分配磁盘空间                  
 17.4  实现文件访问                  
 17.4.1  打开文件时FS的活动                  
 17.4.2  文件操作时的FCB的活动                  
 17.4.3  FS在文件关闭时的活动                  
 练习17.4                  
 17.5  文件共享                  
 17.6  文件系统的可靠性                  
 17.6.1  FS完整性的丢失                  
 17.6.2  FS可靠性技术                  
 练习17.6                  
 17.7  UNIX文件系统                  
 练习17.7                  
 参考文献                  
 第18章  保护和安全                  
 18.1  数据加密                  
 18.1.1  对于加密系统的攻击                  
 18.1.2  加密技术                  
 18.2  保护和安全机制                  
 18.2.1  保护机制                  
 18.2.2  安全机制                  
 18.3  用户文件保护                  
 18.3.1  加密用户文件中的数据                  
 18.3.2  用户文件的访问控制                  
 18.3.3  用户的权限表(C-list)                  
 18.4  权限                  
 18.4.1  基于权限的计算机系统                  
 18.4.2  对象的共享和保护                  
 18.4.3  软件权限                  
 参考文献                  
 第19章  分布式操作系统                  
 19.1  定义和例子                  
 19.1.1  分布式系统模型                  
 19.1.2  分布式操作系统的例子                  
 19.2  分布式操作系统的设计问题                  
 练习19.2                  
 19.3  网络连接问题                  
 19.3.1  网络拓扑结构                  
 19.3.2  通信                  
 19.3.3  交换策略                  
 19.3.4  路由                  
 19.4  通信协议                  
 19.4.1  阻塞协议                  
 19.4.2  非阻塞协议                  
 19.4.3  远程过程调用                  
 练习19.4                  
 19.5  系统状态和事件前趋                  
 19.5.1  系统状态                  
 19.5.2  事件前趋                  
 19.5.3  产生有用的时间戳                  
 练习19.5                  
 19.6  资源分配                  
 19.7  分布式控制算法                  
 19.7.1  理解分布式控制算法                  
 19.7.2  分布式互斥算法                  
 练习19.7                  
 19.7.3  分布式死锁处理                  
 练习19.7                  
 19.8  文件系统                  
 19.8.1  文件系统的透明性                  
 19.8.2  分布式文件系统的设计                  
 练习19.8                  
 19.9  可靠性                  
 19.9.1  可靠性技术的分级体系                  
 19.9.2  数据恢复                  
 19.9.3  故障的容错                  
 19.9.4  弹性恢复技术                  
 练习19.9                  
 19.10  安全                  
 19.10.1  解决消息安全威胁问题                  
 19.10.2  密钥分配                  
 19.10.3  解决消息回放攻击                  
 19.10.4  Kerberos                  
 练习19.10                  
 参考文献