SPOOLING技术实际上是一种外围设备同时联机操作技术,又称为排队转储技术。
它在输入和输出之间增加了“输入井”和“输出井”的排队转储环节。
SPOOLing技术的特点:
(1)提高了I/O速度.从对低速I/O设备进行的I/O操作变为对输入井或输出井的操作,如同脱机操作一样,提高了I/O速度,缓和了CPU与低速I/O设备速度不匹配的矛盾.
(2)设备并没有分配给任何进程.在输入井或输出井中,分配给进程的是一存储区和建立一张I/O请求表.
(3)实现了虚拟设备功能.多个进程同时使用一独享设备,而对每一进程而言,都认为自己独占这一设备,不过,该设备是逻辑上的设备.
SPOOLing是Simultaneous Peripheral Operation On-Line （即外部设备联机并行操作）的缩写，它是关于慢速字符设备如何与计算机主机交换信息的一种技术，通常称为“假脱机技术”。
SPOOLing 系统既不同于脱机方式，也不同于直接藕合方式,SPOOLing 技术实际上是一种外围设备同时联机操作技术，又称为排队转储技术。它在输入和输出之间增加了“输入井”和“输出井”的排队转储环节，以消除用户的“联机” 等待时间。在系统输入模块收到作业输入请求信号后，输入管理模块中的读过程负责将信息从输入装置中读入输入井缓冲区。当缓冲区满时，由写过程将信息从缓冲区写到外存的输入井中，读过程和写过程反复循环，直到一个作业输入完毕。当读过程读到一个硬件结束标志之后，系统再次驱动写过程把最后一批信息写入外存输入井并调用中断处理程序结束该次输入。然后，系统为该作业建立作业控制块，从而使输入井中的作业进入作业等待队列，等待作业调度程序选中后进入内存运行。系统在管理输入井过程中可以“不断”读入输入的作业，直到输入结束或输入井满而暂停。若系统的某台台行式打印机采用了虚拟设备技术，那么若有进程要求对它打印输出时，SPOOLing系统并不是将这台打印机直接分配给进程，而是在共享设备（磁盘或磁鼓）上的输出SPOOLing存储区中为其分配一块存储空间，进程的输出数据以文件形式此。各进程的数据输出文件形成了一个输出队列，由输出POOLing系统控制这台打印机进程，依次将队列中的输出文件实际打印输出。在SPOOLing 系统中，实际上并没有为任何进程分配，而只是在输入井和输出井中，为进程分配一存储区和建立一章I/O请求表。这样，便把独占设备改造为共享设备。
宏观上，虽然是多个进程在同时使用一台独立设备，而对每一个进程而言，它们都认为自己是独占了一个设备。当然，该设备只是逻辑上的设备。SPOOLing系统实现了将独占设备变换为若干台对应的逻辑设备的功能。
SPOOLing 技术实质上是用户进程利用一共享设备的一个存储区，并不是真正占有这一设备，用户进程把要完成的任务以文件的形式存入存储区，在存储区中排队并等待 SPOOLing系统调度，只有被SPOOLing系统调度并输出，此项任务才真正完成，通过这一技术可以大大提高了共享设备的使用率，节约了硬件资源。
SPOOLing技术是在通道技术和多道程序设计基础上产生的，它由主机和相应的通道共同承担作业的输入输出工作，利用磁盘作为后援存储器，实现外围设备同时联机操作。
SPOOLing系统由专门负责I/O的常驻内存的进程以及输入井、输出井组成；它将独占设备改造为共享设备，实现了虚拟设备功能。
将一台独享打印机改造为可供多个用户共享的打印机，是应用SPOOLing技术的典型实例。具体做法是：系统对于用户的打印输出，但并不真正把打印机分配给该用户进程，而是先在输出井中申请一个空闲盘块区，并将要打印的数据送入其中；然后为用户申请并填写请求打印表，将该表挂到请求打印队列上。若打印机空闲，输出程序从请求打印队首取表，将要打印的数据从输出井传送到内存缓冲区，再进行打印，直到打印队列为空。
SPOOLing技术实现设备管理时的工作特征：
1、提高了I/O速度
2、将独占设备改造为共享设备
在SPOOLing 系统中，实际上并没有为任何进程分配，而只是在输入井和输出井中，为进程分配一存储区并建立一张I/O请求表。这样，便把独占设备改造为共享设备。
宏观上，虽然是多个进程在同时使用一台独立设备，而对每一个进程而言，它们都认为自己是独占了一个设备。当然，该设备只是逻辑上的设备。SPOOLing系统实现了将独占设备变换为若干台对应的逻辑设备的功能。
2009年12月23日星期三
2009年12月16日星期三
CISC && RISC
复杂指令计算机CISC特点.
1.指令格式不固定,指令可长可短,操作数可多可少.
2.寻址方式复杂多样，操作数可来自寄存器,也可来自存储器.
3.使用微代码,指令集可以直接在微代码记忆体(比主记忆体的速度快很多)里执行.
4.允许设计师实现CISC体系机器的向上相容.新的系统可以使用一个包含早期系统的指令超集合.
5.微程式指令的格式与高阶语言相匹配,因而编译器的设计较简单.
6.CPI>5,指令越复杂,CPI越大.
CISC的缺陷.
A.指令使用频度不均衡."80~20"的理论,80%的计算任务只需要调用20%的指令就能完成; 扩充的复杂指令往往是低频度指令.
B.大量复杂指令的控制逻辑不规整.不适于VLSI集成,微程序的使用反而制约了速度提高.
C.CISC指令的格式长短不一，需要不同的时钟周期来完成.执行较慢的指令将影响整台机器的执行效率.不利于采用先进指令级并行技术.
D.软硬功能分配．复杂指令增加硬件的复杂度，使指令执行周期大大加长，直接访存次数增多，数据重复利用率低．
精简指令集RISC
A.保留最基本的，去掉复杂、使用频度不高的指令，以减小CPI . CPUTime="IC"*CPI*CC ; IC是程序中指令数，CPI是每条指令执行所用的周期数，CC是时钟周期时间.
B.复杂指令可以通过对简单基本的指令组合而成.
C.每条指令的长度都是相同的，大部分指令可以在一个机器周期里完成.
D.采用多级指令流水线结构，处理器在同一时间内可执行多条指令.
E.采用加载，存储结构，统一存储器寻址方式，只允许load和store指令执行存储器操作，其余指令均对寄存器操作.
F.大大增加了通用寄存器的数量，ALU只与寄存器文件直接连接.
G.采用高速缓存结构，为保证指令不间断地传送给CPU运算器，CPU设置了一定大小的cache以扩展存储器的带宽,满足CPU频繁取指的需求，一般有两个独立的cache,分别存放 “指令＋数据”
1.指令格式不固定,指令可长可短,操作数可多可少.
2.寻址方式复杂多样，操作数可来自寄存器,也可来自存储器.
3.使用微代码,指令集可以直接在微代码记忆体(比主记忆体的速度快很多)里执行.
4.允许设计师实现CISC体系机器的向上相容.新的系统可以使用一个包含早期系统的指令超集合.
5.微程式指令的格式与高阶语言相匹配,因而编译器的设计较简单.
6.CPI>5,指令越复杂,CPI越大.
CISC的缺陷.
A.指令使用频度不均衡."80~20"的理论,80%的计算任务只需要调用20%的指令就能完成; 扩充的复杂指令往往是低频度指令.
B.大量复杂指令的控制逻辑不规整.不适于VLSI集成,微程序的使用反而制约了速度提高.
C.CISC指令的格式长短不一，需要不同的时钟周期来完成.执行较慢的指令将影响整台机器的执行效率.不利于采用先进指令级并行技术.
D.软硬功能分配．复杂指令增加硬件的复杂度，使指令执行周期大大加长，直接访存次数增多，数据重复利用率低．
精简指令集RISC
A.保留最基本的，去掉复杂、使用频度不高的指令，以减小CPI . CPUTime="IC"*CPI*CC ; IC是程序中指令数，CPI是每条指令执行所用的周期数，CC是时钟周期时间.
B.复杂指令可以通过对简单基本的指令组合而成.
C.每条指令的长度都是相同的，大部分指令可以在一个机器周期里完成.
D.采用多级指令流水线结构，处理器在同一时间内可执行多条指令.
E.采用加载，存储结构，统一存储器寻址方式，只允许load和store指令执行存储器操作，其余指令均对寄存器操作.
F.大大增加了通用寄存器的数量，ALU只与寄存器文件直接连接.
G.采用高速缓存结构，为保证指令不间断地传送给CPU运算器，CPU设置了一定大小的cache以扩展存储器的带宽,满足CPU频繁取指的需求，一般有两个独立的cache,分别存放 “指令＋数据”
2009年12月10日星期四
swap分区作用
当程序需要的内存比电脑上拥有的物理内存还要大的时候，不管是 Windows 也好，Linux 也好，解决办法就是把存不下的东西转移到硬盘上的“虚拟内存”中去，尽管硬盘的速度比内存慢上很多，但是至少容量要大上很多。
另外，操作系统也可以把一些很久不活动的程序转移到虚拟内存中去，留出更多的主内存给需要的程序和磁盘缓冲。
Linux 在安装的时候，一般需要划出一个分区作为 Linux 的“交换分区”，作为虚拟内存内容的保存分区。
swapon -s 这个命令，可以查看当前系统的虚拟内存的情况，这条命令需要 root 来运行。
Filename Type Size Used Priority
/dev/sda3 partition 1004052 0 -1
可以看到常常看到当前的交换分区为 /dev/sda3，第 2 栏的 Type 中显示为 partition，说明这是个交换分区，那么，还有其他的 Type 吗？
当然，其实 Linux 也可以像 Windows 一样，用交换文件来保存虚拟内存的内容，这样即使你忘记划出交换分区也不要紧，而且灵活性上会更大一些。下面我们看看如何创建交换文件。
交换文件和交换分区一样，大小是固定的，比如你想要一个 1G 的交换文件，那么首先要创建一个 1G 的空白文件，我们用 dd 这个工具来完成这个任务：
dd if=/dev/zero of=/swapfile bs=1024 count=1048576
1048576 就是 1G 用 KB 表示的大小，如果你想要其他大小的文件，更改这个数字即可。
上面的命令，会在根目录下创建 swapfile 这个文件，然后，我们需要将它格式化为交换文件的格式：
mkswap /swapfile
然后把挂载上去，就可以立刻应用这个交换文件了：
swapon /swapfile
你可以运行 swapon -s 查看一下：
Filename Type Size Used Priority
/dev/sda3 partition 1004052 0 -1
/swapfile file 1048486 0 -2
多出来了一项，Type 为 file，确实是我们创建的交换文件，系统已经在使用了。
如果你想开机的时候自动挂载这个交换文件，那么还要在 /etc/fstab 中加上下面这一句：
/swapfile none swap sw 0 0
另外，操作系统也可以把一些很久不活动的程序转移到虚拟内存中去，留出更多的主内存给需要的程序和磁盘缓冲。
Linux 在安装的时候，一般需要划出一个分区作为 Linux 的“交换分区”，作为虚拟内存内容的保存分区。
swapon -s 这个命令，可以查看当前系统的虚拟内存的情况，这条命令需要 root 来运行。
Filename Type Size Used Priority
/dev/sda3 partition 1004052 0 -1
可以看到常常看到当前的交换分区为 /dev/sda3，第 2 栏的 Type 中显示为 partition，说明这是个交换分区，那么，还有其他的 Type 吗？
当然，其实 Linux 也可以像 Windows 一样，用交换文件来保存虚拟内存的内容，这样即使你忘记划出交换分区也不要紧，而且灵活性上会更大一些。下面我们看看如何创建交换文件。
交换文件和交换分区一样，大小是固定的，比如你想要一个 1G 的交换文件，那么首先要创建一个 1G 的空白文件，我们用 dd 这个工具来完成这个任务：
dd if=/dev/zero of=/swapfile bs=1024 count=1048576
1048576 就是 1G 用 KB 表示的大小，如果你想要其他大小的文件，更改这个数字即可。
上面的命令，会在根目录下创建 swapfile 这个文件，然后，我们需要将它格式化为交换文件的格式：
mkswap /swapfile
然后把挂载上去，就可以立刻应用这个交换文件了：
swapon /swapfile
你可以运行 swapon -s 查看一下：
Filename Type Size Used Priority
/dev/sda3 partition 1004052 0 -1
/swapfile file 1048486 0 -2
多出来了一项，Type 为 file，确实是我们创建的交换文件，系统已经在使用了。
如果你想开机的时候自动挂载这个交换文件，那么还要在 /etc/fstab 中加上下面这一句：
/swapfile none swap sw 0 0
2009年11月20日星期五
load average
Linux Load Average参数
首先如何获取这个参数呢？
使用uptime就可以输出，top命令也会提供其内容。
这三个数值代表一段时间内在运行队列里阻塞的进程数。系统提供的时间片段是load average:1min,5min,15min。
什么是阻塞的进程呢？
阻塞的进程：一般在等待系统资源而不能继续运行的进程。例如：
>>CPU
>>Disk I/O
>>Network I/O
空闲的cpu 就是0 load ，要是2.5就代表过载了150%
%us %sy表示cpu总共的处理时间。如果这两个数经常是99%-100%说明你的cpu不行了。
如果%wa很高(80%) 说明cpu在等待I/O上花了很多时间，说明你的硬盘有点问题，要不是网卡有点问题，还有可能程序试图访问非法的数据。运行ps faux可以查出错误。D-表示在等待，就是你的问题所在。
如果需要继续进一步诊断，使用以下程序strace可以最终那个进程在干吗，iostat可以看硬盘吞吐量，bwmon可以看网络吞吐量～
首先如何获取这个参数呢？
使用uptime就可以输出，top命令也会提供其内容。
这三个数值代表一段时间内在运行队列里阻塞的进程数。系统提供的时间片段是load average:1min,5min,15min。
什么是阻塞的进程呢？
阻塞的进程：一般在等待系统资源而不能继续运行的进程。例如：
>>CPU
>>Disk I/O
>>Network I/O
空闲的cpu 就是0 load ，要是2.5就代表过载了150%
%us %sy表示cpu总共的处理时间。如果这两个数经常是99%-100%说明你的cpu不行了。
如果%wa很高(80%) 说明cpu在等待I/O上花了很多时间，说明你的硬盘有点问题，要不是网卡有点问题，还有可能程序试图访问非法的数据。运行ps faux可以查出错误。D-表示在等待，就是你的问题所在。
如果需要继续进一步诊断，使用以下程序strace可以最终那个进程在干吗，iostat可以看硬盘吞吐量，bwmon可以看网络吞吐量～
2009年11月13日星期五
SATA与ATA的区别
串行高级技术配件（SATA）是一项新兴的标准电子接口技术。SATA的性能有望超过前一代技术--并行ATA，因为它可以提供更高的性能，而成本却只是SCSI或光纤通道等传统存储技术的一小部分。
顾名思义，SATA只是一种串行链接接口标准，用来控制及传输服务器或存储设备到客户端应用之间的数据和信息。SATA用来把硬盘驱动器等存储设备连接到主板上，从而增强系统性能、提高效率、大幅降低开发成本。
要了解SATA的优点，就需要深入地了解并行ATA。并行ATA是基于集成驱动器电路（IDE）接口标准的一项硬驱技术，用于传输及交换计算机主板总线到磁盘存储设备间的数据。
许多低端的网络连接存储（NAS）设备之所以采用并行ATA驱动器，是因为成本效益。另外，还因为众多的高带宽应用，譬如备份与恢复、视频监控、视频处理以及使用磁盘而不是磁带的近线存储。
采用SATA的存储设备配置起来要比采用并行ATA简便得多，这归因于其较小的格式参数。SATA所用的电缆要比并行ATA更长、更细，后者采用又粗又短又容易断裂的电缆。另外，SATA采用7针数据连接器，而不是并行ATA的40针连接器。
连接到磁盘驱动器的粗电缆装配起来比较困难，还会堵住气流、导致发热，这一切都会影响硬件系统的总体性能和稳定性。SATA铺设及安装起来简单多了，紧凑性为主板和磁盘驱动器腾出了多余的空间。
SATA还采用低电压差分信号技术，这与低功耗和冷却的需求相一致。信号电压从并行ATA的5伏降低到了SATA的区区0.7伏。这不仅降低了磁盘驱动器的功耗，还缩小了开关控制器的尺寸。
这项接口技术采用了8/10位编码方法，即把8位数据字节编码成10位字符进行传输。采用串行技术以及8/10位编码法，不仅提高了总体的传输性能，还完全绕开了并行传输存在的问题。这种数据完整性很高的方案提供了必要的嵌入计时和重要的数据完整性检查功能，而这正是高速传输所需要的。
SATA 采用了点对点拓扑结构，而不是普遍应用于并行ATA或SCSI技术的基于总线的架构，所以SATA可以为每个连接设备提供全部带宽，从而提高了总体性能。据SATA工作组（Serial ATA Working Group）声称，由于进度表包括了三代增强型数据传输速率：设备的突发速率分别为150Mbps、300Mbps和600Mbps，SATA因而保证了长达10年的稳定而健康的发展期。这项新标准还向后兼容，这样串行格式转换成并行格式就更方便了，反之亦然，而且还会加快采用SATA的速度。
由于采用柔韧的细电缆、热插拔连接器、提高了数据可靠性和保障性，而且软件上完全兼容，SATA将给廉价的网络存储产品带来巨大的市场机会。许多磁盘驱动器和芯片生产商已经宣布推出支持SATA的产品，由80余家厂商组成的SATA工作组也得到了业界的广泛支持。
目前，SATA的成本比并行ATA高出15%左右，但差距正在迅速缩小。预计在不远的将来，SATA的成本将与如今的并行ATA持平。
转自：http://detail.zol.com.cn/product_param/index3366.html
顾名思义，SATA只是一种串行链接接口标准，用来控制及传输服务器或存储设备到客户端应用之间的数据和信息。SATA用来把硬盘驱动器等存储设备连接到主板上，从而增强系统性能、提高效率、大幅降低开发成本。
要了解SATA的优点，就需要深入地了解并行ATA。并行ATA是基于集成驱动器电路（IDE）接口标准的一项硬驱技术，用于传输及交换计算机主板总线到磁盘存储设备间的数据。
许多低端的网络连接存储（NAS）设备之所以采用并行ATA驱动器，是因为成本效益。另外，还因为众多的高带宽应用，譬如备份与恢复、视频监控、视频处理以及使用磁盘而不是磁带的近线存储。
采用SATA的存储设备配置起来要比采用并行ATA简便得多，这归因于其较小的格式参数。SATA所用的电缆要比并行ATA更长、更细，后者采用又粗又短又容易断裂的电缆。另外，SATA采用7针数据连接器，而不是并行ATA的40针连接器。
连接到磁盘驱动器的粗电缆装配起来比较困难，还会堵住气流、导致发热，这一切都会影响硬件系统的总体性能和稳定性。SATA铺设及安装起来简单多了，紧凑性为主板和磁盘驱动器腾出了多余的空间。
SATA还采用低电压差分信号技术，这与低功耗和冷却的需求相一致。信号电压从并行ATA的5伏降低到了SATA的区区0.7伏。这不仅降低了磁盘驱动器的功耗，还缩小了开关控制器的尺寸。
这项接口技术采用了8/10位编码方法，即把8位数据字节编码成10位字符进行传输。采用串行技术以及8/10位编码法，不仅提高了总体的传输性能，还完全绕开了并行传输存在的问题。这种数据完整性很高的方案提供了必要的嵌入计时和重要的数据完整性检查功能，而这正是高速传输所需要的。
SATA 采用了点对点拓扑结构，而不是普遍应用于并行ATA或SCSI技术的基于总线的架构，所以SATA可以为每个连接设备提供全部带宽，从而提高了总体性能。据SATA工作组（Serial ATA Working Group）声称，由于进度表包括了三代增强型数据传输速率：设备的突发速率分别为150Mbps、300Mbps和600Mbps，SATA因而保证了长达10年的稳定而健康的发展期。这项新标准还向后兼容，这样串行格式转换成并行格式就更方便了，反之亦然，而且还会加快采用SATA的速度。
由于采用柔韧的细电缆、热插拔连接器、提高了数据可靠性和保障性，而且软件上完全兼容，SATA将给廉价的网络存储产品带来巨大的市场机会。许多磁盘驱动器和芯片生产商已经宣布推出支持SATA的产品，由80余家厂商组成的SATA工作组也得到了业界的广泛支持。
目前，SATA的成本比并行ATA高出15%左右，但差距正在迅速缩小。预计在不远的将来，SATA的成本将与如今的并行ATA持平。
转自：http://detail.zol.com.cn/product_param/index3366.html
2009年11月8日星期日
Linux分区跳过sda4
/dev/sda1 /dev/sda2 /dev/sda3都是主分区，秉承“一个硬盘最多只有4个主分区，主分区不能扩建其他磁盘”的分区规则，也就是说，如果我再分一个/dev/sda4(主分区)的话，那后面的磁盘是无法创建的！
所以，就需要将原本/dev/sda4变成逻辑分区(逻辑分区是建立在扩展分区之上的，扩展分区不是实际意义上的分区)
又因为LINUX中，逻辑分区编号是5开始的，所以会出现没有/dev/sda4这个磁盘。
所以，就需要将原本/dev/sda4变成逻辑分区(逻辑分区是建立在扩展分区之上的，扩展分区不是实际意义上的分区)
又因为LINUX中，逻辑分区编号是5开始的，所以会出现没有/dev/sda4这个磁盘。
2009年11月7日星期六
Linux不需要碎片整理
2009年11月5日星期四
terms--trap,exception,system call,interrupt
From "Art of Assembly"
Trap: Denote a programmer initiated and expected transfer of control to a special handler routine.In many respects, a trap is nothing more than a specialized subroutine call. Many texts refer to traps as software interrupts.
exception: Exceptions are illegal program actions that generate an interrupt. Examples of illegal programs actions include divide by zero, attempt to access memory outside segment bounds, and so on.
system call: With a system call a user program can ask for an operating system service.System calls provide the interface between a process and the operating system.
Interrupt: Interrupts are generated by hardware devices that need attention of the operating system. For example, a clock chip may generate an interrupt every 100 msec to allow the kernel to implement time sharing. As another example, when the disk has read a block from disk, it generates an interrupt to alert the operating system that the block is ready to be retrieved.
Trap: Denote a programmer initiated and expected transfer of control to a special handler routine.In many respects, a trap is nothing more than a specialized subroutine call. Many texts refer to traps as software interrupts.
exception: Exceptions are illegal program actions that generate an interrupt. Examples of illegal programs actions include divide by zero, attempt to access memory outside segment bounds, and so on.
system call: With a system call a user program can ask for an operating system service.System calls provide the interface between a process and the operating system.
Interrupt: Interrupts are generated by hardware devices that need attention of the operating system. For example, a clock chip may generate an interrupt every 100 msec to allow the kernel to implement time sharing. As another example, when the disk has read a block from disk, it generates an interrupt to alert the operating system that the block is ready to be retrieved.
2009年11月2日星期一
看穿双核
彻底看穿双核CPU Intel与AMD多核处理器剖解
一、双核心的由来
所谓双核心处理器，简单地说就是在一块CPU基板上集成两个处理器核心，并通过并行总线将各处理器核心连接起来。双核心并不是一个新概念，而只 是CMP(Chip Multi Processors，单芯片多处理器)中最基本、最简单、最容易实现的一种类型。其实在RISC处理器领域，双核心甚至多核心都早已经实现。CMP最早 是由美国斯坦福大学提出的，其思想是在一块芯片内实现SMP(Symmetrical Multi-Processing，对称多处理)架构，且并行执行不同的进程。早在上个世纪末，惠普和IBM就已经提出双核处理器的可行性设计。IBM 在2001年就推出了基于双核心的Power4处理器，随后是Sun和惠普公司，都先后推出了基于双核架构的UltraSPARC以及PA-RISC芯片，但此时双核心处理器架构还都是在高端的RISC领域，直到前不久Intel和AMD相继推出自己的双核心处理器，双核心才真正走入了主流的X86领域。
MCM模块内封装了4个Power4芯片，共有8个CPU核心
Intel和AMD之所以推出双核心处理器，最重要的原因是原有的普通单核心处理器的频率难于提升，性能没有质的飞跃。由于频率难于提 升，Intel在发布3.8GHz的产品以后只得宣布停止4GHz的产品计划；而AMD在实际频率超过2GHz以后也无法大幅度提升，3GHz成为了 AMD无法逾越的一道坎。正是在这种情况下，为了寻找新的卖点，Intel和AMD都不约而同地祭起了双核心这面大旗。
Sun UltraSPARC IV双核处理器
二、AMD双核心处理器的简介
AMD目前的桌面平台双核心处理器代号为Toledo和Manchester，基本上可以简单看作是把两个Athlon 64所采用的
Venice核心整合在同一个处理器内部，每个核心都拥有独立的512KB或1MB二级缓存，两个核心共享Hyper Transport，从架构上来说相对于目前的Athlon 64架构并没有任何改变。
与Intel的双核心处理器不同的是，由于AMD的Athlon 64处理器内部整和了内存控制器，而且在当初Athlon 64设计时就为双核心做了考虑，但是仍然需要仲裁器来保证其缓存数据的一致性。AMD在此采用了SRQ(System Request Queue，系统请求队列)技术，在工作的时候每一个核心都将其请求放在SRQ中，当获得资源之后请求将会被送往相应的执行核心，所以其缓存数据的一致性 不需要通过北桥芯片，直接在处理器内部就可以完成。与Intel的双核心处理器相比，其优点是缓存数据延迟得以大大降低。
AMD目前的桌面平台双核心处理器是Athlon 64 X2，其型号按照PR值分为3800+至4800+等几种，同样采用0.09微米制程，Socket 939接口，支持1GHz的Hyper Transport，当然也都支持双通道DDR内存技术。
Athlon 64 X2
由于AMD双核心处理器的仲裁器是在CPU内部而不是在北桥芯片上，所以在主板芯片组的选择上要比Intel双核心处理器要宽松得多，甚至可以 说与主板芯片组无关。理论上来说，任何Socket 939的主板通过更新BIOS都可以支持Athlon 64 X2。对普通消费者而言，这样可以保护已有的投资，而不必象Intel双核心处理器那样需要同时升级主板
三、Intel双核心构架剖析
AMD的“真伪双核论”虽无法立足，但它点出的英特尔双核处理器可能出现前端总线资源争抢的问题是否真是实情呢？对此，英特尔表示：AMD并不 了解我们的产品和我们将来产品的技术走向，对自己的竞争对手及其产品妄加猜测和评论的行为是不值得赞赏的。AMD曾经指出奔腾至尊版是两个核心共享一个二 级缓存，这就是一个非常明显的错误。事实上，奔腾至尊版和奔腾D都是每个核心配有独享的一级和二级缓存，不同的是英特尔将双核争用前端总线的任务仲裁功能 放在了芯片组的北桥芯片中。
基于Smithfield衍生出的奔腾至尊版和奔腾D
图1：基于Smithfield衍生出的奔腾至尊版和奔腾D，主要区别就在于奔腾至尊版支持超线程，而奔腾D屏蔽了超线程功能。
按照“离得越近、走得越快”的集成电路设计原则，把这些功能组件集成在处理器中确实可以提高效率，减少延迟。不过，在台式机还不可能在短期内就 支持4个内核和更多内核的现实情况下，只要有高带宽的前端系统总线，就算把这些任务仲裁组件外置，对于双核处理器的台式机来说带来的延迟和性能损失也是微 乎其微的。
英特尔945和955系列芯片组目前可提供800MHz（用于目前的奔腾D）和1066MHz（用于奔腾至尊版）前端总线，如果是供一个四核处理器使用，那肯定会造成资源争抢，但对于双核来说，这个带宽已经足够了。英特尔认为目前双核系统中的主要瓶颈还是内存、I/O总线和硬盘系统，提升这些模块的速度才能使整个系统的计算平台更加均衡。
基于这种设计思路，英特尔在945和955系列芯片组中加强了对PCI-Express总线的支持，增加了对更高速DDR2内存的支持，对 SATA(串行ATA)的支持速度增加了一倍由1.5Gb/s升级3Gb/s，进一步增加了磁盘阵列RAID 5 和 RAID 10的支持。
单核奔腾4处理器
图2：单核奔腾4处理器（左）和双核奔腾D处理器（右）微架构示意图
此外，英特尔奔腾至尊版有一个独门“绝活”，那就是双核心加超线程的架构，这种架构可同时处理四个线程，这让它在多任务多线程的应用中具有明显优势。而且CMP与SMT（同时多线程，英特尔超线程就是一种SMT技术）的结合是业界公认的处理器重要发展趋势，最早推出双核处理器的IBM也是这一趋势的推动者。
奔腾至尊版的双核
英特尔之所以在奔腾至尊版和奔腾D上采用共享前端总线的双核架构，还是出于双核架构自身的紧凑设计和生产进程方面的考虑，这种架构使英特尔能够迅速推出全系列的双核处理器家族，加快双核处理器的产品化，而且它带来的成本优势也大大降低了奔腾至尊版、奔腾D与现有主流单核处理器——奔腾4系列的差价，有利于双核处理器在PC市场上的迅速普及。
四、AMD双核心架构剖析
从架构上来看，Athlon 64 X2除了多个“芯”外与目前的Athlon 64并没有任何区别。Athlon 64 X2的大多数技术特征、功能与目前市售的、基于AMD64架构的处理器是一样的，而且这些双核心处理器仍将使用1GHz HyperTransport总线与芯片组连接及支持双通道DDR内存技术。
图3：奔腾至尊版的双核+超线程架构让它具备同时四线程处理能力
实际上Toledo核心就相当于是两个San Diego核心的Athlon 64处理器的集成，至于Manchester自然就相当于两个
Venice核心了—这也就是说，双核心的Athlon 64 X2处理器均将支持SSE3指令集。
另外我们不难发现的是，AMD的台式双核心处理器的频率与其单核心产品基本上处于同一水平上—这一点与Intel非常不一样(Intel目前频率最高的桌面单核心处理器达到了3.8GHz，而其最高频率的双核心处理器只不过3.2GHz)。当然这并不难理解，因为 Athlon 64处理器，特别是采用了90nm SOI工艺的Athlon 64处理器的发热量要比Intel的高频率的Prescott核心处理器要低不少，所以自然可以采用比较高的工作频率了(当然从频率的角度来看，Athlon 64 X2也还是低于Pentium D的)。
由于Intel受发热量限制目前的双核心处理器最高只有3.2GHz，因此在性能上肯定要比AMD的 Athlon 64 X2要低一些——不过Pentium D不如Athlon64 X2的地方并不仅仅只有这方面而已。在处理器的架构上AMD也有其独到之处，下图所示就是AMD的双核心处理器的架构示意图。
AMD的双核心方案面临一个重要的问题，就是随着第二核心的出现，对内存与I/O带宽的资源将会出现争夺，如何解决好这个问题是AMD双核心处理器的性能的关键问题之一。与Pentium D不同的是，Athlon 64 X2的两个内核并不需要通过外部FSB通信这一途径。Athlon 64 X2内部整合了一个System Request Queue(SRQ)仲裁装备，每一个核心将其请求放在SRQ中，当获得资源之后请求将会被送往相应的执行核心，所有的过程都在CPU核心范围之内完成。
AMD双核心强调是真正将两个核心崁入整合在一个硅晶内核上，可以真正发挥双核心效率，不像对手的产品事实上为两个Packet的设计，会有两个核心之间传输瓶颈的问题。因此Athlon 64 X2的架构要优于Pentium D架构，尤其是在高负载的多线程/多任务的环境下，AMD的处理器将会表现出比Intel的处理器更好的性能。
此外，随着第二核心的出现，对内存与I/O带宽的资源将会出现争夺，如何解决好这个问题是AMD双核心处理器的性能的关键问题之一。AMD信引入了Crossbar控制器，这个全新的控制器结合优化的系统请求队列，可以有效的降低这个问题的危害性。
AMD处理器集成的内存控制器在进化到双核心时代表现出来的优势更加明显，低延时的内存控制器使得对CPU的缓存的依赖也大幅减少，在这样的情况下，在日后过渡到多核心的时候，需要考虑的问题更多的是基于各个核心之间的连接。我们可以看到，两个核心所采用的L2缓存也是分别独享的，也就是两个L2缓存中保存的数据是一致的。
实际的可利用容量和一个核心的L2缓存容量是相同的—这一点和Intel一样。与Intel有所不同的是，AMD方案的两个核心之间的通信是通过处理器内部的Crossbar实现的。相比之下Intel的Pentium D处理器的核心之间的通信则是需要通过芯片组的MCH来进行—这显然比AMD的方案要带来更多的延迟时间。不过AMD的架构也并非十全十美，双核心处理器仍然只支持双通道DDR400内存无疑是一个有些令人遗憾的地方—两个处理器核心自然需要更大的内存带宽。要解决这个矛盾，只能使用全新的针脚设计，DDR2或许是一个不错的选择。
Athlon 64 X2这样的设计还有一个好处，那就是如果打算支持新的双内核处理器的话，对旧平台而言唯一的要求就是升级到最新BIOS就OK了，这将大大降低平台的应用、升级成本。当然AMD沿用以前的内存控制器也是有很大的好处的，那就是双核心的Athlon 64 X2处理器可以在目前几乎所有的Socket 939主板上使用。这方面AMD有着Intel无可比拟的优势—因为以前的915/925主板并不能支持Intel的双核心处理器。
此外，与Pentium D是通过降低频率来降低功耗不同，同样采用0.0
9微米生产技术的Athlon 64 X2似乎并不需要面临这样的问题。这都得益于AMD在Athlon 64 X2处理器上所采用的“Dual Stress Liner”应变硅技术。Dual Stress Liner技术是由AMD和IBM联合开发的，据称可以将半导体晶体管的响应速度提高24％。
事实上，DSL很类似于英特尔在90nm生产技术中引入的应变硅技术。我们都知道，晶体管越微细化，运行速度就越高，但同时也会引发泄漏电流增加、开关效率降低，从而导致耗电和发热量的增加。而DSL通过向晶体管的硅层施加应力，同时实现了速度的提高与耗电量的降低。
与Intel使用的应变硅不同，来自AMD和IBM的DSL能够被用于两种类型的晶体管：NMOS和PMOS(具有n和p通道)而无需使用极难获得的硅锗层，硅锗层会增加成本，并且有可能影响芯片的产量。 DSL这种双重性，让它比英特尔的应变硅更有效—DSL可以将晶体管的响应速度提升24%，而应变硅能提供的最大改进在15-20%。
并且更重要的是，AMD和IBM 这项新技术对产量及生产成本并没有任何负面影响。由于在生产时无需使用新的生产方法，所以使用标准生产设备和材料便可迅速展开量产。另外，配合使用硅绝缘膜构造(SOI，绝缘体上硅)与应变硅，还可生产性能更高、耗电更低的晶体管。AMD工程师们表示，DSL和SOI一起结合可以让Athlon 64处理器的频率潜力有大约16％的增长。而Athlon 64 X2的初始频率与目前Athlon 64持平上也可以看到DSL技术的确很有效。
当然，AMD也将在未来转移更先进的65nm生产线上，改进他们的内存控制器来对DDR2，DDR3和FB-DIMM等高性能内存提供支持，也将开始使用更快的HyperTransport 2.0总线，及更有效的节能降耗技术。
五、双核心技术与超线程技术的区别
超线程技术已经不是什么新鲜事物了，但普通用户可能与双核心技术区分不开。例如开启了超线程技术的Pentium 4 530与Pentium D 530在操作系统中都同样被识别为两颗处理器，它们究竟是不是一样的呢？这个问题确实具有迷惑性。
其实，可以简单地把双核心技术理解为两个"物理"处理器，是一种"硬"的方式；而超线程技术只是两个"逻辑"处理器，是一种"软"的方式。
从原理上来说，超线程技术属于Intel版本的多线程技术。这种技术可以让单CPU拥有处理多线程的能力，而物理上只使用一个处理器。超线程技术为每个物理处理器设置了两个入口-AS(Architecture State，架构状态)接口，从而使操作系统等软件将其识别为两个逻辑处理器。这两个逻辑处理器像传统处理器一样，都有独立的IA-32架构，它们可以分别进入暂停、中断状态，或直接执行特殊线程，并且每个逻辑处理器都拥有APIC(Advanced Programmable Interrupt Controller，高级可编程中断控制器)。
虽然支持超线程的Pentium 4能同时执行两个线程，但不同于传统的双处理器平台或双内核处理器，超线程中的两个逻辑处理器并没有独立的执行单元、整数单元、寄存器甚至缓存等等资源。它们在运行过程中仍需要共用执行单元、缓存和系统总线接口。在执行多线程时两个逻辑处理器均是交替工作，如果两个线程都同时需要某一个资源时，其中一个要暂停并要让出资源，要待那些资源闲置时才能继续。因此，超线程技术所带来的性能提升远不能等同于两个相同时钟频率处理器带来的性能提升。可以说Intel 的超线程技术仅可以看做是对单个处理器运算资源的优化利用。
而双核心技术则是通过"硬"的物理核心实现多线程工作：每个核心拥有独立的指令集、执行单元，与超线程中所采用的模拟共享机制完全不一样。在操作系统看来，它是实实在在的双处理器，可以同时执行多项任务，能让处理器资源真正实现并行处理模式，其效率和性能提升要比超线程技术要高得多，不可同日而语。
六、双核心处理器的适用范围
目前，Windows XP专业版等操作系统支持双物理核心和四个逻辑核心，但这并不意味着所有软件对此都有优化。
事实上大量的测试已经证明，无论是Intel还是AMD的双核心处理器，相对于其各自的同频率的单核心处理器而言，对于目前的普通应用例如多媒体软件、游戏和办公软件等等都没有任何性能提升，甚至可能还稍有降低，因为这些普通应用目前都还只是单线程程序，在处理器执行指令时实际上只有一个核心在工作，而另外一个核心则处于空闲状态帮不上忙。
所以对普通用户而言，只要日常应用的程序仍然是单线程的话，双核心处理器实际上没有任何意义，反而还增大了购买成本。除非经常执行大运算量的多任务处理，例如在游戏的同时进行音视
频处理等等，这时双核心处理器才能真正发挥作用。
目前最适合双核心处理器发挥威力的平台是服务器和工作站，这是因为其经常进行多任务处理，而且日常运行的大量程序都是多线程程序，例如图形工作站所使用的Adobe Photoshop和3D MAX等都是多线程程序。一般来说，在执行多任务处理和多线程程序时，双核心处理器要比同频率的单核心处理器的性能要高大约50%-70%，甚至在某些应用下性能几乎能提升100%。
当然，随着双核心处理器的强势推出和逐渐普及，日后支持多线程的普通应用程序也会逐渐增多，对普通用户而言那时双核心处理器才会真正发挥作用。
七、双核心处理器目前所存在的问题
无论是Intel的Pentium D和Pentium EE，还是AMD的Athlon 64 X2处理器，都是简单地将两个物理内核"叠加"在一起，这必然带来晶体管数量的大幅度增加，双方都已经达到了两亿三千万个以上的晶体管；带来的直接后果就是由泄漏电流引起的功耗大幅度增加，就算是采用了节能技术其发热量也居高不下，从而导致双核心处理器相对于单核心处理器而言频率提升更加困难。
而且由于目前的制造工艺的限制，双核心处理器的良品率要比单核心处理器的低，这必然会带来成本的居高不下，所以目前的双核心处理器的价格都太贵了，距离普及还差得很远。当然，随着处理器核心架构和制造技术的发展，今后必然会解决目前所遇到的问题。
一、双核心的由来
所谓双核心处理器，简单地说就是在一块CPU基板上集成两个处理器核心，并通过并行总线将各处理器核心连接起来。双核心并不是一个新概念，而只 是CMP(Chip Multi Processors，单芯片多处理器)中最基本、最简单、最容易实现的一种类型。其实在RISC处理器领域，双核心甚至多核心都早已经实现。CMP最早 是由美国斯坦福大学提出的，其思想是在一块芯片内实现SMP(Symmetrical Multi-Processing，对称多处理)架构，且并行执行不同的进程。早在上个世纪末，惠普和IBM就已经提出双核处理器的可行性设计。IBM 在2001年就推出了基于双核心的Power4处理器，随后是Sun和惠普公司，都先后推出了基于双核架构的UltraSPARC以及PA-RISC芯片，但此时双核心处理器架构还都是在高端的RISC领域，直到前不久Intel和AMD相继推出自己的双核心处理器，双核心才真正走入了主流的X86领域。
MCM模块内封装了4个Power4芯片，共有8个CPU核心
Intel和AMD之所以推出双核心处理器，最重要的原因是原有的普通单核心处理器的频率难于提升，性能没有质的飞跃。由于频率难于提 升，Intel在发布3.8GHz的产品以后只得宣布停止4GHz的产品计划；而AMD在实际频率超过2GHz以后也无法大幅度提升，3GHz成为了 AMD无法逾越的一道坎。正是在这种情况下，为了寻找新的卖点，Intel和AMD都不约而同地祭起了双核心这面大旗。
Sun UltraSPARC IV双核处理器二、AMD双核心处理器的简介
AMD目前的桌面平台双核心处理器代号为Toledo和Manchester，基本上可以简单看作是把两个Athlon 64所采用的
Venice核心整合在同一个处理器内部，每个核心都拥有独立的512KB或1MB二级缓存，两个核心共享Hyper Transport，从架构上来说相对于目前的Athlon 64架构并没有任何改变。
与Intel的双核心处理器不同的是，由于AMD的Athlon 64处理器内部整和了内存控制器，而且在当初Athlon 64设计时就为双核心做了考虑，但是仍然需要仲裁器来保证其缓存数据的一致性。AMD在此采用了SRQ(System Request Queue，系统请求队列)技术，在工作的时候每一个核心都将其请求放在SRQ中，当获得资源之后请求将会被送往相应的执行核心，所以其缓存数据的一致性 不需要通过北桥芯片，直接在处理器内部就可以完成。与Intel的双核心处理器相比，其优点是缓存数据延迟得以大大降低。
AMD目前的桌面平台双核心处理器是Athlon 64 X2，其型号按照PR值分为3800+至4800+等几种，同样采用0.09微米制程，Socket 939接口，支持1GHz的Hyper Transport，当然也都支持双通道DDR内存技术。
Athlon 64 X2由于AMD双核心处理器的仲裁器是在CPU内部而不是在北桥芯片上，所以在主板芯片组的选择上要比Intel双核心处理器要宽松得多，甚至可以 说与主板芯片组无关。理论上来说，任何Socket 939的主板通过更新BIOS都可以支持Athlon 64 X2。对普通消费者而言，这样可以保护已有的投资，而不必象Intel双核心处理器那样需要同时升级主板
三、Intel双核心构架剖析
AMD的“真伪双核论”虽无法立足，但它点出的英特尔双核处理器可能出现前端总线资源争抢的问题是否真是实情呢？对此，英特尔表示：AMD并不 了解我们的产品和我们将来产品的技术走向，对自己的竞争对手及其产品妄加猜测和评论的行为是不值得赞赏的。AMD曾经指出奔腾至尊版是两个核心共享一个二 级缓存，这就是一个非常明显的错误。事实上，奔腾至尊版和奔腾D都是每个核心配有独享的一级和二级缓存，不同的是英特尔将双核争用前端总线的任务仲裁功能 放在了芯片组的北桥芯片中。
基于Smithfield衍生出的奔腾至尊版和奔腾D
图1：基于Smithfield衍生出的奔腾至尊版和奔腾D，主要区别就在于奔腾至尊版支持超线程，而奔腾D屏蔽了超线程功能。按照“离得越近、走得越快”的集成电路设计原则，把这些功能组件集成在处理器中确实可以提高效率，减少延迟。不过，在台式机还不可能在短期内就 支持4个内核和更多内核的现实情况下，只要有高带宽的前端系统总线，就算把这些任务仲裁组件外置，对于双核处理器的台式机来说带来的延迟和性能损失也是微 乎其微的。
英特尔945和955系列芯片组目前可提供800MHz（用于目前的奔腾D）和1066MHz（用于奔腾至尊版）前端总线，如果是供一个四核处理器使用，那肯定会造成资源争抢，但对于双核来说，这个带宽已经足够了。英特尔认为目前双核系统中的主要瓶颈还是内存、I/O总线和硬盘系统，提升这些模块的速度才能使整个系统的计算平台更加均衡。
基于这种设计思路，英特尔在945和955系列芯片组中加强了对PCI-Express总线的支持，增加了对更高速DDR2内存的支持，对 SATA(串行ATA)的支持速度增加了一倍由1.5Gb/s升级3Gb/s，进一步增加了磁盘阵列RAID 5 和 RAID 10的支持。
单核奔腾4处理器
图2：单核奔腾4处理器（左）和双核奔腾D处理器（右）微架构示意图此外，英特尔奔腾至尊版有一个独门“绝活”，那就是双核心加超线程的架构，这种架构可同时处理四个线程，这让它在多任务多线程的应用中具有明显优势。而且CMP与SMT（同时多线程，英特尔超线程就是一种SMT技术）的结合是业界公认的处理器重要发展趋势，最早推出双核处理器的IBM也是这一趋势的推动者。
奔腾至尊版的双核
英特尔之所以在奔腾至尊版和奔腾D上采用共享前端总线的双核架构，还是出于双核架构自身的紧凑设计和生产进程方面的考虑，这种架构使英特尔能够迅速推出全系列的双核处理器家族，加快双核处理器的产品化，而且它带来的成本优势也大大降低了奔腾至尊版、奔腾D与现有主流单核处理器——奔腾4系列的差价，有利于双核处理器在PC市场上的迅速普及。
四、AMD双核心架构剖析
从架构上来看，Athlon 64 X2除了多个“芯”外与目前的Athlon 64并没有任何区别。Athlon 64 X2的大多数技术特征、功能与目前市售的、基于AMD64架构的处理器是一样的，而且这些双核心处理器仍将使用1GHz HyperTransport总线与芯片组连接及支持双通道DDR内存技术。
图3：奔腾至尊版的双核+超线程架构让它具备同时四线程处理能力实际上Toledo核心就相当于是两个San Diego核心的Athlon 64处理器的集成，至于Manchester自然就相当于两个
Venice核心了—这也就是说，双核心的Athlon 64 X2处理器均将支持SSE3指令集。
另外我们不难发现的是，AMD的台式双核心处理器的频率与其单核心产品基本上处于同一水平上—这一点与Intel非常不一样(Intel目前频率最高的桌面单核心处理器达到了3.8GHz，而其最高频率的双核心处理器只不过3.2GHz)。当然这并不难理解，因为 Athlon 64处理器，特别是采用了90nm SOI工艺的Athlon 64处理器的发热量要比Intel的高频率的Prescott核心处理器要低不少，所以自然可以采用比较高的工作频率了(当然从频率的角度来看，Athlon 64 X2也还是低于Pentium D的)。
由于Intel受发热量限制目前的双核心处理器最高只有3.2GHz，因此在性能上肯定要比AMD的 Athlon 64 X2要低一些——不过Pentium D不如Athlon64 X2的地方并不仅仅只有这方面而已。在处理器的架构上AMD也有其独到之处，下图所示就是AMD的双核心处理器的架构示意图。
AMD的双核心方案面临一个重要的问题，就是随着第二核心的出现，对内存与I/O带宽的资源将会出现争夺，如何解决好这个问题是AMD双核心处理器的性能的关键问题之一。与Pentium D不同的是，Athlon 64 X2的两个内核并不需要通过外部FSB通信这一途径。Athlon 64 X2内部整合了一个System Request Queue(SRQ)仲裁装备，每一个核心将其请求放在SRQ中，当获得资源之后请求将会被送往相应的执行核心，所有的过程都在CPU核心范围之内完成。
AMD双核心强调是真正将两个核心崁入整合在一个硅晶内核上，可以真正发挥双核心效率，不像对手的产品事实上为两个Packet的设计，会有两个核心之间传输瓶颈的问题。因此Athlon 64 X2的架构要优于Pentium D架构，尤其是在高负载的多线程/多任务的环境下，AMD的处理器将会表现出比Intel的处理器更好的性能。
此外，随着第二核心的出现，对内存与I/O带宽的资源将会出现争夺，如何解决好这个问题是AMD双核心处理器的性能的关键问题之一。AMD信引入了Crossbar控制器，这个全新的控制器结合优化的系统请求队列，可以有效的降低这个问题的危害性。
AMD处理器集成的内存控制器在进化到双核心时代表现出来的优势更加明显，低延时的内存控制器使得对CPU的缓存的依赖也大幅减少，在这样的情况下，在日后过渡到多核心的时候，需要考虑的问题更多的是基于各个核心之间的连接。我们可以看到，两个核心所采用的L2缓存也是分别独享的，也就是两个L2缓存中保存的数据是一致的。
实际的可利用容量和一个核心的L2缓存容量是相同的—这一点和Intel一样。与Intel有所不同的是，AMD方案的两个核心之间的通信是通过处理器内部的Crossbar实现的。相比之下Intel的Pentium D处理器的核心之间的通信则是需要通过芯片组的MCH来进行—这显然比AMD的方案要带来更多的延迟时间。不过AMD的架构也并非十全十美，双核心处理器仍然只支持双通道DDR400内存无疑是一个有些令人遗憾的地方—两个处理器核心自然需要更大的内存带宽。要解决这个矛盾，只能使用全新的针脚设计，DDR2或许是一个不错的选择。
Athlon 64 X2这样的设计还有一个好处，那就是如果打算支持新的双内核处理器的话，对旧平台而言唯一的要求就是升级到最新BIOS就OK了，这将大大降低平台的应用、升级成本。当然AMD沿用以前的内存控制器也是有很大的好处的，那就是双核心的Athlon 64 X2处理器可以在目前几乎所有的Socket 939主板上使用。这方面AMD有着Intel无可比拟的优势—因为以前的915/925主板并不能支持Intel的双核心处理器。
此外，与Pentium D是通过降低频率来降低功耗不同，同样采用0.0
9微米生产技术的Athlon 64 X2似乎并不需要面临这样的问题。这都得益于AMD在Athlon 64 X2处理器上所采用的“Dual Stress Liner”应变硅技术。Dual Stress Liner技术是由AMD和IBM联合开发的，据称可以将半导体晶体管的响应速度提高24％。
事实上，DSL很类似于英特尔在90nm生产技术中引入的应变硅技术。我们都知道，晶体管越微细化，运行速度就越高，但同时也会引发泄漏电流增加、开关效率降低，从而导致耗电和发热量的增加。而DSL通过向晶体管的硅层施加应力，同时实现了速度的提高与耗电量的降低。
与Intel使用的应变硅不同，来自AMD和IBM的DSL能够被用于两种类型的晶体管：NMOS和PMOS(具有n和p通道)而无需使用极难获得的硅锗层，硅锗层会增加成本，并且有可能影响芯片的产量。 DSL这种双重性，让它比英特尔的应变硅更有效—DSL可以将晶体管的响应速度提升24%，而应变硅能提供的最大改进在15-20%。
并且更重要的是，AMD和IBM 这项新技术对产量及生产成本并没有任何负面影响。由于在生产时无需使用新的生产方法，所以使用标准生产设备和材料便可迅速展开量产。另外，配合使用硅绝缘膜构造(SOI，绝缘体上硅)与应变硅，还可生产性能更高、耗电更低的晶体管。AMD工程师们表示，DSL和SOI一起结合可以让Athlon 64处理器的频率潜力有大约16％的增长。而Athlon 64 X2的初始频率与目前Athlon 64持平上也可以看到DSL技术的确很有效。
当然，AMD也将在未来转移更先进的65nm生产线上，改进他们的内存控制器来对DDR2，DDR3和FB-DIMM等高性能内存提供支持，也将开始使用更快的HyperTransport 2.0总线，及更有效的节能降耗技术。
五、双核心技术与超线程技术的区别
超线程技术已经不是什么新鲜事物了，但普通用户可能与双核心技术区分不开。例如开启了超线程技术的Pentium 4 530与Pentium D 530在操作系统中都同样被识别为两颗处理器，它们究竟是不是一样的呢？这个问题确实具有迷惑性。
其实，可以简单地把双核心技术理解为两个"物理"处理器，是一种"硬"的方式；而超线程技术只是两个"逻辑"处理器，是一种"软"的方式。
从原理上来说，超线程技术属于Intel版本的多线程技术。这种技术可以让单CPU拥有处理多线程的能力，而物理上只使用一个处理器。超线程技术为每个物理处理器设置了两个入口-AS(Architecture State，架构状态)接口，从而使操作系统等软件将其识别为两个逻辑处理器。这两个逻辑处理器像传统处理器一样，都有独立的IA-32架构，它们可以分别进入暂停、中断状态，或直接执行特殊线程，并且每个逻辑处理器都拥有APIC(Advanced Programmable Interrupt Controller，高级可编程中断控制器)。
虽然支持超线程的Pentium 4能同时执行两个线程，但不同于传统的双处理器平台或双内核处理器，超线程中的两个逻辑处理器并没有独立的执行单元、整数单元、寄存器甚至缓存等等资源。它们在运行过程中仍需要共用执行单元、缓存和系统总线接口。在执行多线程时两个逻辑处理器均是交替工作，如果两个线程都同时需要某一个资源时，其中一个要暂停并要让出资源，要待那些资源闲置时才能继续。因此，超线程技术所带来的性能提升远不能等同于两个相同时钟频率处理器带来的性能提升。可以说Intel 的超线程技术仅可以看做是对单个处理器运算资源的优化利用。
而双核心技术则是通过"硬"的物理核心实现多线程工作：每个核心拥有独立的指令集、执行单元，与超线程中所采用的模拟共享机制完全不一样。在操作系统看来，它是实实在在的双处理器，可以同时执行多项任务，能让处理器资源真正实现并行处理模式，其效率和性能提升要比超线程技术要高得多，不可同日而语。
六、双核心处理器的适用范围
目前，Windows XP专业版等操作系统支持双物理核心和四个逻辑核心，但这并不意味着所有软件对此都有优化。
事实上大量的测试已经证明，无论是Intel还是AMD的双核心处理器，相对于其各自的同频率的单核心处理器而言，对于目前的普通应用例如多媒体软件、游戏和办公软件等等都没有任何性能提升，甚至可能还稍有降低，因为这些普通应用目前都还只是单线程程序，在处理器执行指令时实际上只有一个核心在工作，而另外一个核心则处于空闲状态帮不上忙。
所以对普通用户而言，只要日常应用的程序仍然是单线程的话，双核心处理器实际上没有任何意义，反而还增大了购买成本。除非经常执行大运算量的多任务处理，例如在游戏的同时进行音视
频处理等等，这时双核心处理器才能真正发挥作用。
目前最适合双核心处理器发挥威力的平台是服务器和工作站，这是因为其经常进行多任务处理，而且日常运行的大量程序都是多线程程序，例如图形工作站所使用的Adobe Photoshop和3D MAX等都是多线程程序。一般来说，在执行多任务处理和多线程程序时，双核心处理器要比同频率的单核心处理器的性能要高大约50%-70%，甚至在某些应用下性能几乎能提升100%。
当然，随着双核心处理器的强势推出和逐渐普及，日后支持多线程的普通应用程序也会逐渐增多，对普通用户而言那时双核心处理器才会真正发挥作用。
七、双核心处理器目前所存在的问题
无论是Intel的Pentium D和Pentium EE，还是AMD的Athlon 64 X2处理器，都是简单地将两个物理内核"叠加"在一起，这必然带来晶体管数量的大幅度增加，双方都已经达到了两亿三千万个以上的晶体管；带来的直接后果就是由泄漏电流引起的功耗大幅度增加，就算是采用了节能技术其发热量也居高不下，从而导致双核心处理器相对于单核心处理器而言频率提升更加困难。
而且由于目前的制造工艺的限制，双核心处理器的良品率要比单核心处理器的低，这必然会带来成本的居高不下，所以目前的双核心处理器的价格都太贵了，距离普及还差得很远。当然，随着处理器核心架构和制造技术的发展，今后必然会解决目前所遇到的问题。
2009年9月18日星期五
Virtualbox下我很愚蠢的错误
用virtualbox的共享文件夹，设置Fedora的文件夹被winXP共享。一直出现这样一个错误：
命令：net use x:\\vboxsrv\Download
发生系统错误 67
找不到网络名
我看了n遍帮助一直觉得没错。差点没疯了。
终于今天看到发现了天机了，
寒，少了个空格。
应该是：net use x: \\vboxsrv\Download
应该还是我自己没理解这句命令的含义，嗨～
命令：net use x:\\vboxsrv\Download
发生系统错误 67
找不到网络名
我看了n遍帮助一直觉得没错。差点没疯了。
终于今天看到发现了天机了，
寒，少了个空格。
应该是：net use x: \\vboxsrv\Download
应该还是我自己没理解这句命令的含义，嗨～
2009年9月17日星期四
抢占式内核
本文译者：
康华：计算机硕士，主要从事Linux操作系统内核、Linux技术标准、计算机安全、软件测试等领域的研究与开发工作，现就职于信息产业部软件与集成电路促进中心所属的MII-HP Linux软件实验室。如果需要可以联系通过kanghua151@msn.com联系他。
注明：棕色写的内容为译者注。
如果有意义不明之处请参见原文。
Kevin 将继续他的实时之旅，这次他要着重分析如何通过改造Linux内核来为应用程序带来实时性能。
在2002年的1-2月发行的嵌入Linux月刊中，我们探讨了有关实时和Linux的基础问题。而这次我将精力花在改造Linux内核来为应用程序带来实时性能这个主题上。到目前为止，工作的重心集中在提高内核响应速度——通过减少抢占响应时间缩短系统响应时间，因为我们知道抢占响应时间在Linux中耗时较长。
通过改进内核——仅仅是剔除一些标准内核的功能——并不去改变或增加内核API，应用程序就可以获得更快的响应速度。这样做优势明显，因为ISVs(独立软件开发商)不需要为不同的实时要求开发不同版本的系统。比如，DVD播放器可以在一个改进过的内核上更稳定的运行，而它不必知道该内核是经过改进的版本。
背景和历史
自2.2版本内核发布以来，内核抢占成为一个热门话题。Paul Barton-Davis 和 Benno Senoner曾给Linus
Torvalds写了一封信(该信后来追加了许多人的签名)，请求在2.4版本内核中显著降低抢占延迟时间。
他们需要Linux性能上能满足播放音频、音乐以及MIDI的要求。Senoner开发了一套基准软件（benchmarking
software）测试2.2版本内核（以及后来的2.4版本），在最坏情况下发现抢占延迟高达100毫秒(参考)。 对于音频应用程序来说，这么长的延迟时间显然是无法接受的。因为经验显示系统响应时间只有在几毫秒内才能满足音频应用程序的需要。
有两个补丁包为内核提供了相当不错的抢占响应速度提升。Ingo Molnar (来自 Red Hat) 和 Andrew Morton (来自Wollongong大学)
两人都开发了内核补丁，这些补丁为内核中长代码路径片段插入了抢占点。你可以在这里这里发现Ingo Molnar的补丁包 ，或在这里找到Andrew Morton的补丁包。
另外，Morton还提供了测量响应速度的工具，比如测量内核忽视请求时间长度等，有关详细信息在他的快速响应补丁网站上可以找到。
目前，至少有两个组织开发了抢占式内核，为内核抢占问题提供了更基础、更强大的解决途径。
在2002年1-2月ELJ上发表的系列文章的第一篇中，我列举了不少希望Linux能够支持的实时功能，它们包括多优先级、用户空间中断处理和DMA、同步机制中的优先级继承（优先级继承可用来解决优先级反转问题。当优先级反转发生时，优先级较低的任务被暂时地提高它的优先级，使得该任务能尽快执行，释放出优先级较高的任务所需要的资源）、微妙级的时钟解析度 、全面实现POSIX1003.1b规范要求的功能和调度程序的恒量耗时算法等。我们在本文中也会简要讨论它们。
要
明白这些性能改进都必须依赖给内核打补丁，但是打补丁后的内核就不再兼容其它标准内核了，比如抢占式内核需要修改自旋锁的代码，这时如果一个驱动程序的二
进制执行文件如果不采用修改过的自旋锁，那么很可能无法正常抢占。所以改造内核时一般都需要内核源代码并重新编译内核代码。值得一提的是，使用模块化的Linux驱动程序是使得源代码兼容的一个有效方法。我们不赞成仅仅发布驱动程序的已经编译的二进制文件而没有源代码，因为这样作既缺乏兼容性保障也不符合开源精神。
改进
各种各样对内核的改进能够为应用程序透明地提供众多好处。比如，提高内核的抢占性主要通过抢占式内核或是添加抢占点着两个途径。从内核角度进行改进可以使得应用程序不用做修改就能获得高的响应速度。
透明性也应该考虑是否改变对内核来说也是透明的，换句话说就是，是否采用的方法能自动跟踪内核的改变。Molnar和Morton提出的插入抢占点的方法需要测量新内核中的调度响应时间，并且在此基础上插入抢占点到合适位置。
相反，如果在SMP锁定基础上创建抢占式内核,则可以自动、无须修改地过渡到新内核。而且如果在SMP-锁定机制中实现抢占性，则当内核开发者提高SMP锁定粒度（granularity）时，也同时会自动提高抢占粒度。我们会看到SMP锁定将粒度稳步提高，因为SMP不断扩张必定需要不断提高锁定粒度。
正是由于这种新引进的SMP锁，内核抢占才自2.4版本或更新（实际在2.6才正是支持）内核后被正式实现。而早期内核缺乏SMP锁。
抢占式内核的另外一个需要强调的重要优势是它使得代码——但代码不会发觉——可被抢占，比如，驱动程序开发者不必为要使驱动程序可被抢占去编写任何特殊代码，驱动程序的代码能在必要时被抢占，除非驱动程序持有锁。所以在内核其它部分，编写优良的SMP安全（代码中不存在多处理器并发访问共享资源的危险）的驱动程序将自动受益于抢占式内核。而另一方面，非SMP安全的驱动程序可能不能和抢占式内核和谐工作。
也许有人会发觉，只要某些驱动程序没有请求锁，内核代码就可以调用它。比如我们使用MontaVista的抢占式内核做简单测试中发现，动态装载的驱动程序中read()和write()函数都可以正常被抢占，但是函数init_module()、open()和close()却不能。这意味着如果一个低优先级的进程执行操作open()或close()，那么它有可能被一个新唤醒的高优先级别进程推迟抢占时机。
实际上，开发者最好去测量响应时间，因为即使使用抢占式内核，我们也有可能找到有那些代码片段持有锁的时间超过了应用程序允许的长间。
比如MontaVista, 提供了一个抢占式内核，对那些长期持锁的代码片段插入了抢占点，同时也提供了测量工具，以便开发者可以测量它们实际应用程序和环境的抢占性。
SMP锁的目的是确保内核重入（re-entrance）安全。也就是，如果并行运行的进程需要访问内核资源，那么对这些资源访问必须安全、可靠。越精细的锁定粒度越能保证竞争进程运行的并行巡行能力越强。因为并行能力的提高需要减少堵塞（因为锁的争用），（而细粒度锁可减少阻塞机会）。
上述概念也同样适用于单处理器。对于I/O系统来说，如果将I/O设备看作一个独立的处理器，那么应用程序和I/O活动的并行运行无疑能提高系统吞吐量。提高抢占性，意味着高优先级的I/O范畴进程（I/O-bound process）会更频繁地被唤醒，从而提高了吞吐量。这样以来，虽然可能带来某些负作用，比如我们可能会需要更多的上下文切换和在内核关键路径上执行更多代码（关键路径直那些访问共享资源的代码路径，为了防止竞争条件需要上锁等操作），但是即使如此，我们仍然可以获得更大的系统吞吐量。
允许内核抢占的优势是显而易见的，标准内核迟早会引入抢占功能（目前已经具有）。抢占式内核有些实现中可以提供几微妙的响应时间，而更精确的实现则可把响应时间提高到几十分之一微秒。
环顾嵌入Linux生产商，MontaVista 和TimeSys提供了抢占式内核；REDSonic使用抢占点；LynuxWorks和红帽子使用RTLinux；Lineo
使用RTAI；OnCore通过和Linux系统调用兼容的API（和LynuxWorks利用LynuxOs一样）与在他们的抢占式微内核上。
运行一个Linux内核（可抢占的）达到实时目的。
抢占点
抢占点的核心思想是在特定点上调用调度程序去检查是否有更高优级的任务做好了运行准备，需要即刻运行。Molnar和Morton就是利用该思想，测量内核路径的执行时间，找到时间过长的路径插入调度检查点（等于打断了长路径）。你可以通过抢占补丁代码或是对比打过补丁的内核和先前未达补丁的内核，从中发现那些地方需要插入抢占点。抢占补丁看起来很象if (current ->need_resched) schedule()（这是用户空间抢占执行的典型情形）;
为了使用Andrew Morton开发的抢占点内核补丁，需要从上面给出的URL下载该补丁，同时还要从kernel.org下载恰当版本的内核源代码。然后内核打上补丁然后重新编译，详细细节可以在这里找到，但要注意这些是为2.4版本老版本内核而言的。另外还请注意你可能需要升级你的开发环境。
使用Molnar的补丁要做的事情同上。下载补丁、编译新内核，Morton开发了针对2.4多个版本的补丁。而Molnar的补丁针对一些2.2版本内核和早期的2.4版本内核。
抢占式内核
抢占式内核使得用户程序在执行系统调用期间可以被抢占，从而使新被唤醒的高优先级进程能够运行。这种抢占并非可以在内核中任意位置都能安全进行，比如在临界区中的代码就不能发生抢占。临界区是指同一时间内不可以有超过一个进程在其中执行的指令序列。在Linux内核中这些部分需要用自旋锁保护。
MontaVista
和 TimeSys采用类似的方法建立抢占式内核。他们巧妙地将自旋锁的功能加强为也能防止抢占（2.6新内核中自选锁也是这样做的）。依靠该方法，抢占只能发生在未使用自旋锁的其它部分。当一个更高优先级的进程被唤醒，调度程序就能抢占低优先级进程正在执行的系统调用，只要此刻该系统调用代码没有被自旋锁保护——加上自旋锁意味不可抢占。
另外，使用抢占式内核，打断锁（解开再锁上）使得重新调度相比采用抢占点（低响应时间）补丁要简单。因为如果内核释放了一个锁，然后又再获得它，那么当锁被释放时，就会进行抢占检查。内核中有些地方需要上锁——比如一个循环——但不需要一直持有锁，可以每进行一次循环，锁就要被释放，然后再获得。
MontaVista实现抢占主要通过一个计数器（2.6版本中称它为抢占计数，用它可以跟踪锁定嵌套数），当自旋锁被获取时，该计数就增加1。当高优先级别的进程被唤醒，调度程序会检查抢占计数——检查是否为零——判断是否此刻允许抢占（如果为0，就可以发生抢占）。依靠这个计数器，当锁嵌套调用时，抢占机制能很好的工作，但是任何持有自旋锁的临界区域都不允许抢占，即使锁用来保护的是些无关资源。
TimeSys采用一个优先级遗传互斥量（priority inheritance mutex）。利用这种机制，一个高优先级的进程可以抢占一个持有不同资源互斥量的低优先级别的进程。另外因为采用了优先级遗传，所以持有互斥量的低优先级的进程不能无限推迟等待在该互斥量上的高优先级进程。这样以来解决了所谓的优先级翻转问题（Priority Inversion Problem）。
MontaVista公司开发的抢占包可以从SourceForge kpreempt 站点获得。MontaVista公司的开源精神很值得赞赏，他们同时也提供了他们的实时调度程序与高解析度定时器，这些都可以从SourceForge的这里和这里获得。
SourceForge
的kpreempt 项目同时也含有Robert Love开发的抢占式内核的连接（请看2002年4月和5月出版的Linux杂志，其中介绍了他对内核改进的详细信息）。 另外 MontaVista的补丁也由Love维护（现在Robert Love已经归于MontaVista麾下），虽然MontaVista 也参与维护工作。最新的补丁可在此处下载。
Love最新发布的补丁现在已经可以和Ingo Molnar的恒时（耗时为衡量）调度程序补丁协同工作。Molnar的时间复杂度为O(1)的调度程序可以用于2.4版本内核，并且目前也已经植入了2.5版本的内核中了。TimeSys也将自己的抢占式内核发布在了他们的网站上。抢占式内核需要的补丁包都已经完备。要得到这些补丁，你需要将它们对比2.4.7内核代码数生成diff文件。上述的这些抢占式内核程序都遵守GPL协议。
TimeSys还为实时程序开发者提供了许多额外功能，这些功能不能无偿下载。它们包括实时调度和实时资源分配技术。这些模块填加了额外的系统调用，比如提供对新增功能的访问方法等。
如果那些朋友对这些细节感性趣，可以通过我们提供的许多线索找到想要的信息。自旋锁机制的关键信息包含在文件include/linux/spinlock.h中，MontaVista
和TimeSys都对该文件进行了修改。
有趣的是，虽然MontaVista 和TimeSys都对旧函数改了名字，但是他们仍然使用这些旧函数。以前老的自旋锁函数仍然需要。比如不允许在调度程序执行期间发生抢占内核的行为，否则会带来无穷无尽的递归调用。MontaVista使用象_raw_spin_lock和
_raw_read_lock这样的命名；TimeSys 使用象old_spin_lock 和
old_spin_lock_irq这样的命名。
可以在TimeSys发布的代码kernel/include/linux/mutex.h中发现它是利用write_lock() 和 read_lock()函数——他们实现了互斥锁——定义自旋锁的。具体实现函数do_write_lock()可以在文件kernel/kernel/mutex.c中看到，它实现了互斥锁定功能。
其它的内核实时方法
另一个能有效提高实时性的方法是提高时钟的粒度。TimeSys, MontaVista, REDSonic 和其他公司都提高了时钟解析度，比如，TimeSys 在上下文切换期间使用Pentium处理器的时间戳计数器（Stamp Counter）来确保准确地对CPU时间进行记帐，该记帐值要被诸如 getrusage()等函数用到。
许多开发者，也包含作者都认为Linux缺乏对POSIX1003的全面支持是个很重要的缺陷。幸运的是，目前已经有了解决方法，特别是，TimeSys公司已经有了一个不错的实现。
除了对POSIX的贡献外，TimeSys已经开发了一些全新的资源访问控制机制。这些新技术使得实时应用程序可以节约CPU时间或网络带宽。比如结合它们的中断线程模型、抢占式内核和其它功能，能提供高出标准内核2或3倍的响应速度。
到目前为止，Linux好象还不允许让用户空间应用程序自己注册函数处理中断，该机制称为用户空间中断处理机制，它目前已经在RIX、SGI's UNIX等系统中得到使用。
有趣的是，SGI在Linux中，利用他们的ds1286实时时钟接口，可以从用户空间通过一个实时时钟访问中断。可以在这里.找到相关信息
和用户级别中断处理相关的是用户空间和设备的DMA通讯，提供此功能的补丁可以从这里获得。
保证
显然，没有哪个实时Linux厂商愿意保证响应速度。如果提供保证的话，那么应该类似下面的声明：
使用我们的Linux内核，和所需的硬件与设备等，我们可以保证你的应用程序如果被锁在内存，具有最高优先权。。那么将能够在你实时硬件发出中断信号后的N微妙内被唤醒。如果你无法获得上述能力，我们将视其为一个bug。
但是我们从没看到过该类保证，这是为什么呢？ 我们认为有如下几种可能。
厂商的这种保证毫无意义，没有客户需要它。但我们认为许多开发者希望获得保证，事实上，硬实时本身就意味着一个保证。
厂
商没有充分测量他们的内核和环境，以至于有能力给出一个保证。这是一个小花招。因为单独测量无法给出另人满意的保证，代码必须在所有环境中被测试而且要在
最坏情况下测试。从厂商的宣称中，看起来它们似乎已经花了大量精力去测量和学习代码，但事实上，对工程师来说可能给出给定环境下的一些数据更能让人放心。
如果考虑所有需要保证的方面，Linux所涉及的方面实在是太多了。这点可能就是问题的所在。开发者希望能够改写他们的内核，他们希望能下载驱动程序并使用。这些行为都超出了厂商的控制，所以如果厂商公开声明一个保证，就有可能仅仅是针对某一个特定系统在一些选定的情况下才有效的。
也许我们会看到某些妥协的保证，例如像“在Pentium
系列的计算机上应用程序响应速度为100ms或更短”另外加上驱动程序花去的时间。驱动程序使用的时间非常重要，因为驱动程序中的中断处理代码往往在响应时间中占主要部分。
2009年8月1日星期六
ippbx我长见识了
wiki了一下，ippbx貌似支持的是xml-rpc的数据传输形式。而我感觉那个ethereal似乎只是测试用的，知道有反应了。
因此ippbx配置里面的
config_url = reg.php就表示ippbx向这个页面发送了数据。
php中正好有xml-rpc的扩展http://phpxmlrpc.sourceforge.net/
xml数据是以gobal request的形式传输过来的，因此只要获取gobal request就可以了，基本用法如下：
// this is the function exposed as "get_time()"
function return_time($method, $args) {
return date('Ymd\THis');
}
$server = xmlrpc_server_create() or die("Can't create server");
xmlrpc_server_register_method($server, 'return_time', 'get_time')
or die("Can't register method.");
$request = $GLOBALS['HTTP_RAW_POST_DATA'];
$options = array('output_type' => 'xml', 'version' => 'xmlrpc');
print xmlrpc_server_call_method($server, $request, NULL, $options)
or die("Can't call method");
xmlrpc_server_destroy($server);
就生成了xml这样，就可以进一步用php解析这一个请求了，貌似是这样的。你先试试看。
因此ippbx配置里面的
config_url = reg.php就表示ippbx向这个页面发送了数据。
php中正好有xml-rpc的扩展http://phpxmlrpc.sourceforge.net/
xml数据是以gobal request的形式传输过来的，因此只要获取gobal request就可以了，基本用法如下：
// this is the function exposed as "get_time()"
function return_time($method, $args) {
return date('Ymd\THis');
}
$server = xmlrpc_server_create() or die("Can't create server");
xmlrpc_server_register_method($server, 'return_time', 'get_time')
or die("Can't register method.");
$request = $GLOBALS['HTTP_RAW_POST_DATA'];
$options = array('output_type' => 'xml', 'version' => 'xmlrpc');
print xmlrpc_server_call_method($server, $request, NULL, $options)
or die("Can't call method");
xmlrpc_server_destroy($server);
就生成了xml这样，就可以进一步用php解析这一个请求了，貌似是这样的。你先试试看。
kernel安装
历时两个月，我亲爱的内核终于出炉了，这个可是原版的太阳炉。。。
Linux内核kernel和所有的操作系统一样提供了对计算机硬件的统一视图，是硬件一个更高的抽象层。为用户和用户空间程序提供如下特性：
1.进程
2.信号和旗语
3.虚拟内存(swapping,paging,mapping)
4.文件系统
5.基本输入输出
6.进程通信（管道和互联网）
kernel在系统启动是被载入到内存，启动里面我写了。
kernel.org 开发的kernel被称为vanilla内核。而各个版本的Linux都会有自己的kernel一般就是在vanilla kernel上面打一些补丁。一般vanilla kernel都不能很好的在其他发行版Linux上运行。不过听说debian是个例外。
安装：
1.先确定系统是否安装了必需的软件 rpmdevtools yum-utils,
su -c "yum install yum-utils rpmdevtools"
2.准备内核的编译环境
rpmdev-setuptree
3.用yum软件管理程序的可以输入命令
yumdownloader --source kernel
就可以在镜像源里面下到kernel-.src.rpm文件。
4.确定编译内核说需要的软件是否全部安装。
su -c "yum-builddep kernel-.src.rpm"
5.安装rpm包
rpm -Uvh kernel-.src.rpm
6.可以重新将rpm编译打包，但也可以直接安装二进制文件。我在rpmbuild出错了看不懂原因，就只好直接安装二进制文件了。
7.进入~/rpmbuild/BUILD/kernel-/linux-/
8.先配置make oldconfig || make defconfig || make menuconfig
8.使用root权限一口气 make && make modules && make modules_install install
9.Over,重启
P.S. 我第一遍安装成功的kernel不能用是因为配置时开启了PAE选项，所谓PAE就是Physical Address Extension，原来32位电脑只能装4 Giga的内存这个特性是扩充内存用的。intel Pentium Pro及以后的电脑除了我这个品牌Pentium M都支持PAE，这句话比较寒。。。
另外，其实如果只是开发Linux驱动，只要装个kernel-headers 和 kernel-devel包就可以了。
Linux内核kernel和所有的操作系统一样提供了对计算机硬件的统一视图，是硬件一个更高的抽象层。为用户和用户空间程序提供如下特性：
1.进程
2.信号和旗语
3.虚拟内存(swapping,paging,mapping)
4.文件系统
5.基本输入输出
6.进程通信（管道和互联网）
kernel在系统启动是被载入到内存，启动里面我写了。
kernel.org 开发的kernel被称为vanilla内核。而各个版本的Linux都会有自己的kernel一般就是在vanilla kernel上面打一些补丁。一般vanilla kernel都不能很好的在其他发行版Linux上运行。不过听说debian是个例外。
安装：
1.先确定系统是否安装了必需的软件 rpmdevtools yum-utils,
su -c "yum install yum-utils rpmdevtools"
2.准备内核的编译环境
rpmdev-setuptree
3.用yum软件管理程序的可以输入命令
yumdownloader --source kernel
就可以在镜像源里面下到kernel-
4.确定编译内核说需要的软件是否全部安装。
su -c "yum-builddep kernel-
5.安装rpm包
rpm -Uvh kernel-
6.可以重新将rpm编译打包，但也可以直接安装二进制文件。我在rpmbuild出错了看不懂原因，就只好直接安装二进制文件了。
7.进入~/rpmbuild/BUILD/kernel-
8.先配置make oldconfig || make defconfig || make menuconfig
8.使用root权限一口气 make && make modules && make modules_install install
9.Over,重启
P.S. 我第一遍安装成功的kernel不能用是因为配置时开启了PAE选项，所谓PAE就是Physical Address Extension，原来32位电脑只能装4 Giga的内存这个特性是扩充内存用的。intel Pentium Pro及以后的电脑除了我这个品牌Pentium M都支持PAE，这句话比较寒。。。
另外，其实如果只是开发Linux驱动，只要装个kernel-headers 和 kernel-devel包就可以了。
2009年7月30日星期四
vanilla内核安装卸载
从kernel.org下载下来的kernel叫做vanilla kernel，大部分Linux版本都会有自己的kernel，比如我用的fedora，社区会给他打很多补丁。因此直接想要在fedora上边装载 vanilla kernel是不行的，至少我试了几次都直接开机崩溃了，一次是kernel panic，一次是X window死了。
按我老师的说法是：
Well, Fedora can and can't use a Vanilla kernel. The Fedora kernel is a
vanilla kernel with a bunch of patches on it. If you try to use a vanilla
kernel on fedora, it may work fine -- or you may run into odd problems that
have to do with some fedora user-land applications expecting the kernel
patches to be in there. I think most distributions apply their own custom
patches to the kernel. Debian may be an exception, I am not sure.
我折腾了半天把那个vanilla kernel装上去了。开不了机，只好使用grub换到原来的内核。下面还要把vanilla kernel删掉
wget -c http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.24.tar.bz2
tar xjf linux-2.6.24.tar.bz2
cd linux-2.6.24
make defconfig
make all
su -c "make modules_install install"
这个好像只能手动删除
/usr/src/linux-2.6.29
/lib/modules/2.6.29
/boot/vmlinuz-2.6.29 or kernel-2.6.29
/boot/initrd-2.6.29
/boot/System.map-2.6.29
就算完事了。。。还得去弄那个src.rpm包。。。命苦阿。。。
按我老师的说法是：
Well, Fedora can and can't use a Vanilla kernel. The Fedora kernel is a
vanilla kernel with a bunch of patches on it. If you try to use a vanilla
kernel on fedora, it may work fine -- or you may run into odd problems that
have to do with some fedora user-land applications expecting the kernel
patches to be in there. I think most distributions apply their own custom
patches to the kernel. Debian may be an exception, I am not sure.
我折腾了半天把那个vanilla kernel装上去了。开不了机，只好使用grub换到原来的内核。下面还要把vanilla kernel删掉
wget -c http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.24.tar.bz2
tar xjf linux-2.6.24.tar.bz2
cd linux-2.6.24
make defconfig
make all
su -c "make modules_install install"
这个好像只能手动删除
/usr/src/linux-2.6.29
/lib/modules/2.6.29
/boot/vmlinuz-2.6.29 or kernel-2.6.29
/boot/initrd-2.6.29
/boot/System.map-2.6.29
就算完事了。。。还得去弄那个src.rpm包。。。命苦阿。。。
2009年7月26日星期日
Linux字体大讨论
貌似我直接问了一句没文化的问题，才知道vlgothic 為日文字型，不是中文字体。
然后一群大牛就开始了他们对Linux中文字体的讨论：
---------------------------------------------------------------------------------
最佳方案：
中文显示最清晰的 Vista 雅黑字体，英文默认使用的是开发人员评分最高的 Consolas 字体，这两种字体搭配在一起格外漂亮。另外还安装了 XP
下的 simsun（宋体和新宋体），以满足 office 软件的需求。
------------------------------------------------------------------------------------------------------------
自由字体推荐用文泉驛，普通的和等宽的都不错，个人觉得微米黑比正黑美观，但是字符集不全。宋体的话用cjkuni-uming-fonts，台湾明体比大陆宋体好看。
----------------------------------------------------------------------------------
LiHeiPro+Monaco也是一种不错的组合
图见 http://www.linuxsir.org/bbs/post1953624-3.html
http://www.linuxsir.org/bbs/post1953637-9.html
----------------------------------------------------------------------------------
如果是想偷懒的，在Fedora 11用文泉驿正黑都是一个不错的选择，比在Fedora 10又有进步了。
话说Fedora上的正黑比Ubuntu上的要好很多，在老爸上的Ubuntu，总感觉是文泉驿隶书字体..
----------------------------------------------------------------------------------
文泉驿、微软雅黑或者华文丽黑
----------------------------------------------------------------------------------
然后一群大牛就开始了他们对Linux中文字体的讨论：
---------------------------------------------------------------------------------
最佳方案：
中文显示最清晰的 Vista 雅黑字体，英文默认使用的是开发人员评分最高的 Consolas 字体，这两种字体搭配在一起格外漂亮。另外还安装了 XP
下的 simsun（宋体和新宋体），以满足 office 软件的需求。
------------------------------------------------------------------------------------------------------------
自由字体推荐用文泉驛，普通的和等宽的都不错，个人觉得微米黑比正黑美观，但是字符集不全。宋体的话用cjkuni-uming-fonts，台湾明体比大陆宋体好看。
----------------------------------------------------------------------------------
LiHeiPro+Monaco也是一种不错的组合
图见 http://www.linuxsir.org/bbs/post1953624-3.html
http://www.linuxsir.org/bbs/post1953637-9.html
----------------------------------------------------------------------------------
如果是想偷懒的，在Fedora 11用文泉驿正黑都是一个不错的选择，比在Fedora 10又有进步了。
话说Fedora上的正黑比Ubuntu上的要好很多，在老爸上的Ubuntu，总感觉是文泉驿隶书字体..
----------------------------------------------------------------------------------
文泉驿、微软雅黑或者华文丽黑
----------------------------------------------------------------------------------
2009年7月21日星期二
Linux笔记之重启关机
1.重启
Linux文件系统把内存中变化的部分存到磁盘中的次数比较少，这个设计让Linux的磁盘读取更加快速，但同时如果强关电脑也使文件系统更加容易丢掉数据。传统的UNIX&Linux系统对关机方式非常敏感，现在因为伟大的灰常鲁棒的ext3fs,ext4fs的发明变得稍微好点了:)但大家还是对她温柔一点，否则很容易导致一些隐蔽的问题。
对于一个商业化的操作系统，重启似乎是解决很多问题的最好方法，但Linux出问题你最好先动脑筋想想再说，因为Linux出的问题一般更加微妙，盲目重启一般来说都解决不了什么问题。
下面列一些你需要重启的情况：
添加了一个新硬件；已使用的硬件出了问题；启动时使用的配置文件被更该；或者死机了。
2.关机
关机或重启更上华山还是有点不一样的，关机方式花样翻新，包你满意。
1）切电源
2）使用shutdown命令
3）使用halt和reboot命令
4）使用telinit改变init运行等级
5）使用poweroff命令
一个个讨论一下，
1）最直接的方法:)容易丢失数据
2）最优雅的方式，shutdown命令可以加参数，还可以发送消息。比如shutdown -h 09:30 "Going down for scheduled maintainenance"。当shutdown命令即将发生的时候，用户无法登录主机但可以看到这条信息。shutdown可以使用参数 -P(power off) -h(halt) -r(reboot) -F(强制fsck) -f(不fsck)，一般文件系统是正常卸载的话fsck就被跳过去了。
3)halt要讲的就是-n参数，一般的halt会调用sync将内存中的内容写到磁盘里面，但是一但调用-n那就sync不再被调用，这样数据可能就会丢失。
Linux文件系统把内存中变化的部分存到磁盘中的次数比较少，这个设计让Linux的磁盘读取更加快速，但同时如果强关电脑也使文件系统更加容易丢掉数据。传统的UNIX&Linux系统对关机方式非常敏感，现在因为伟大的灰常鲁棒的ext3fs,ext4fs的发明变得稍微好点了:)但大家还是对她温柔一点，否则很容易导致一些隐蔽的问题。
对于一个商业化的操作系统，重启似乎是解决很多问题的最好方法，但Linux出问题你最好先动脑筋想想再说，因为Linux出的问题一般更加微妙，盲目重启一般来说都解决不了什么问题。
下面列一些你需要重启的情况：
添加了一个新硬件；已使用的硬件出了问题；启动时使用的配置文件被更该；或者死机了。
2.关机
关机或重启更上华山还是有点不一样的，关机方式花样翻新，包你满意。
1）切电源
2）使用shutdown命令
3）使用halt和reboot命令
4）使用telinit改变init运行等级
5）使用poweroff命令
一个个讨论一下，
1）最直接的方法:)容易丢失数据
2）最优雅的方式，shutdown命令可以加参数，还可以发送消息。比如shutdown -h 09:30 "Going down for scheduled maintainenance"。当shutdown命令即将发生的时候，用户无法登录主机但可以看到这条信息。shutdown可以使用参数 -P(power off) -h(halt) -r(reboot) -F(强制fsck) -f(不fsck)，一般文件系统是正常卸载的话fsck就被跳过去了。
3)halt要讲的就是-n参数，一般的halt会调用sync将内存中的内容写到磁盘里面，但是一但调用-n那就sync不再被调用，这样数据可能就会丢失。
Linux笔记之进程二
一、信号
信号是进程级别的中断请求。大概有30种左右，主要使用方法如下：
*可以作为进程之间的通信
*可以通过终端发送来杀死，中断，挂起进程，<Ctrl-C>&<Ctrl-Z>
*可以使用终端命令kill发送杀死进程
*当进程产生违规操作时，由内核发出。
*当子进程死亡或者IO通道上有可利用的数据。
收到信号可能会发生两种事情：1）如果收到信号的进程有处理信号的机制，就被预定的程序处理（C里面就有<signal.h>头文件处理）。2）内核代表进程做一些默认的操作。
程序可以通过忽略或者阻塞信号防止。忽略的信号就直接消失了，但是阻塞的信号会入队等候处理。不管你阻塞了多少信号，显式取消阻塞后只能调用一次信号。
＃ Name Description Default Can catch? Can block?
1 HUP Hangup Terminate Y Y
2 INT Interrupt Terminate Y Y
3 QUIT Quit Terminate Y Y
9 KILL Kill Terminate N N
a BUS Bus error Terminate Y Y
11 SEGV Segmentation error Terminate Y Y
15 TERM Software termination Terminate Y Y
a STOP Stop Stop N N
a TSTP Keyboard stop Stop Y Y
a CONT Continue after stop Ignore Y N
a WINCH Window changed Ignore Y Y
a USR1 User-defined Terminate Y Y
a USR2 User-defined Terminate Y Y
#a 根据硬件架构会不同
二、Kill指令
kill [-signal] pid
kill pid（可以被忽略获取，忽略，阻塞）
kill -KILL pid (保证杀死进程)
三、进程状态
runnable 进程正在运行
sleeping 进程正在等待资源
zombie 进程快死了
stopped 进程被挂起
四、nice&renice参数
nice表示这个进程有多少nice［-20，+19］，越nice说明进程的运行优先级越低。
五、ps进程监测
ps [aux/lax]
六、top高级进程监测
ps只能监测一个瞬间，top可以持续的监测系统。使用时按q键，可以选择监视参数。
This work is licensed under a Creative Commons Attribution 3.0 Unported License.
信号是进程级别的中断请求。大概有30种左右，主要使用方法如下：
*可以作为进程之间的通信
*可以通过终端发送来杀死，中断，挂起进程，<Ctrl-C>&<Ctrl-Z>
*可以使用终端命令kill发送杀死进程
*当进程产生违规操作时，由内核发出。
*当子进程死亡或者IO通道上有可利用的数据。
收到信号可能会发生两种事情：1）如果收到信号的进程有处理信号的机制，就被预定的程序处理（C里面就有<signal.h>头文件处理）。2）内核代表进程做一些默认的操作。
程序可以通过忽略或者阻塞信号防止。忽略的信号就直接消失了，但是阻塞的信号会入队等候处理。不管你阻塞了多少信号，显式取消阻塞后只能调用一次信号。
＃ Name Description Default Can catch? Can block?
1 HUP Hangup Terminate Y Y
2 INT Interrupt Terminate Y Y
3 QUIT Quit Terminate Y Y
9 KILL Kill Terminate N N
a BUS Bus error Terminate Y Y
11 SEGV Segmentation error Terminate Y Y
15 TERM Software termination Terminate Y Y
a STOP Stop Stop N N
a TSTP Keyboard stop Stop Y Y
a CONT Continue after stop Ignore Y N
a WINCH Window changed Ignore Y Y
a USR1 User-defined Terminate Y Y
a USR2 User-defined Terminate Y Y
#a 根据硬件架构会不同
二、Kill指令
kill [-signal] pid
kill pid（可以被忽略获取，忽略，阻塞）
kill -KILL pid (保证杀死进程)
三、进程状态
runnable 进程正在运行
sleeping 进程正在等待资源
zombie 进程快死了
stopped 进程被挂起
四、nice&renice参数
nice表示这个进程有多少nice［-20，+19］，越nice说明进程的运行优先级越低。
五、ps进程监测
ps [aux/lax]
六、top高级进程监测
ps只能监测一个瞬间，top可以持续的监测系统。使用时按q键，可以选择监视参数。
This work is licensed under a Creative Commons Attribution 3.0 Unported License.
Linux笔记之进程
1.进程
Linux进程貌似是一个相当复杂的系统，每一个进程就是一个运行的程序的抽象。通过他可以管理和监视程序使用的内存，CPU时间，输入输出资源。
一个进程包含地址空间以及一系列的内置于内核的数据结构。
地址空间就是一些被内核标记为归进程使用的内存页（pages，内存单元PC机上为４k）,里面包含进程执行的代码和库，进程的变量，进程使用的栈，以及其他进程运行时内核需要的额外信息。因为Linux是虚拟内存系统，因此这些地址到底是在物理内存中还是swap分区中并没有关系。
内核内置的数据结构每个进程的一些信息，一些比较重要的列举如下：
*进程的地址空间映射
*进程当前的状态（sleeping,stopped,runnable等）
*进程运行的优先级
*进程所使用资源的信息
*进程所打开的文件以及使用的网络端口号
*进程的信号标志（信号被阻塞记录）
*进程的所有者
一些进程共享这些属性产生了所谓的进程群（thread group），这个是Linux类似传统的UNIX系统的多进程机制。虽然这些进程共享地址空间，但是这些进程群中的进程都有自己的执行优先级和执行状态。其实很少有程序使用多进程机制来运行程序。
进程有很多参数都会影响程序的运行，比如：他所得到的处理器时间，他能读取的文件。这些参数有：PID,PPID,UID&EUID,GID&EGID
1)PID:process ID number
内核给每个进程都分配一个ID，很多命令和系统的调用都会用到。
2)PPID:parent PID
Linux系统中并不会通过系统命令产生一个新的进程，而是一个已经存在的进程通过复制自己产生。这个复制的新进程然后，改变当前的属性运行另外一个程序。这样原来的那个进程就相当于该进程的父亲，这里用PPID表示。
PPID在处理一个未知进程的时候比较有用，因为有其父必有其子么。
3)UID&EUID:real and effective user ID
UID就是创建该进程的用户的编号，更精确的说应该是其父进程的UID。EUID标识号负责标识以什么用户身份来给新创建的进程赋所有权、检查文件的存取权限和检查通过系统调用kill向进程发送软中断信号的许可权限。UID&EUID其实差不多的，用两个就是为了把进程本身和权限操作分开来。这样setuid程序就不用经常去更改权限了。
另外还有一个FSUID控制文件系统的访问权限，这个在内核外一般很少使用。
4)GID&EGID
GID用来标识一个群的进程。EGID作用和EUID差不多的。
2.进程的生命周期
一个进程通过fork的系统调用复制自己产生一个新的进程，这个新进程跟原来的进程非常相像，但是他们有不同的PID。fork有一个非常独特的性质就是他返回两个不同的值，对于子进程他将返回0，而对于父进程返回子进程的最新PID，因此通过检验两个值就可以区分那个是儿子，那个是老子。之后，子进程就会通过系统调用之其中一种exec运行新的程序。这个调用会初始化所有的数据，栈。不同形式的exec只不过在指令的参数，运行环境上有一些不同。
Linux操作系统用一种另外的和fork不同的创建的方式。就是调用clone产生一个共享内存或I/O的进程，这个多用于产生多进程程序的产生。
系统启动是第一个创建的进程就是init，这个进程负责运行所有的启动脚本，同时这个进程还负责管理进程的任务。当一个进程结束的时候，就会调用 _exit通知内核他已经死了。还会返回一个数字告诉他是怎么死的（程序退出的原因）。。。一般用0表示正常退出。在把这个进程火化之前，Linux会用 wait通知他的父母。如果不是该进程自己找死，父母会通过（exit code）知道孩子是怎么被杀死的。同样还可以知道他孩子的财产总数（用的资源：））
这个设计在wait调用正常的时运作的非常棒。但如果该进程的父母已经去世了或者其他原因wait没反应，那么就把该进程的孩子作为孤儿归init养（这不是林妹妹么）。
Linux进程貌似是一个相当复杂的系统，每一个进程就是一个运行的程序的抽象。通过他可以管理和监视程序使用的内存，CPU时间，输入输出资源。
一个进程包含地址空间以及一系列的内置于内核的数据结构。
地址空间就是一些被内核标记为归进程使用的内存页（pages，内存单元PC机上为４k）,里面包含进程执行的代码和库，进程的变量，进程使用的栈，以及其他进程运行时内核需要的额外信息。因为Linux是虚拟内存系统，因此这些地址到底是在物理内存中还是swap分区中并没有关系。
内核内置的数据结构每个进程的一些信息，一些比较重要的列举如下：
*进程的地址空间映射
*进程当前的状态（sleeping,stopped,runnable等）
*进程运行的优先级
*进程所使用资源的信息
*进程所打开的文件以及使用的网络端口号
*进程的信号标志（信号被阻塞记录）
*进程的所有者
一些进程共享这些属性产生了所谓的进程群（thread group），这个是Linux类似传统的UNIX系统的多进程机制。虽然这些进程共享地址空间，但是这些进程群中的进程都有自己的执行优先级和执行状态。其实很少有程序使用多进程机制来运行程序。
进程有很多参数都会影响程序的运行，比如：他所得到的处理器时间，他能读取的文件。这些参数有：PID,PPID,UID&EUID,GID&EGID
1)PID:process ID number
内核给每个进程都分配一个ID，很多命令和系统的调用都会用到。
2)PPID:parent PID
Linux系统中并不会通过系统命令产生一个新的进程，而是一个已经存在的进程通过复制自己产生。这个复制的新进程然后，改变当前的属性运行另外一个程序。这样原来的那个进程就相当于该进程的父亲，这里用PPID表示。
PPID在处理一个未知进程的时候比较有用，因为有其父必有其子么。
3)UID&EUID:real and effective user ID
UID就是创建该进程的用户的编号，更精确的说应该是其父进程的UID。EUID标识号负责标识以什么用户身份来给新创建的进程赋所有权、检查文件的存取权限和检查通过系统调用kill向进程发送软中断信号的许可权限。UID&EUID其实差不多的，用两个就是为了把进程本身和权限操作分开来。这样setuid程序就不用经常去更改权限了。
另外还有一个FSUID控制文件系统的访问权限，这个在内核外一般很少使用。
4)GID&EGID
GID用来标识一个群的进程。EGID作用和EUID差不多的。
2.进程的生命周期
一个进程通过fork的系统调用复制自己产生一个新的进程，这个新进程跟原来的进程非常相像，但是他们有不同的PID。fork有一个非常独特的性质就是他返回两个不同的值，对于子进程他将返回0，而对于父进程返回子进程的最新PID，因此通过检验两个值就可以区分那个是儿子，那个是老子。之后，子进程就会通过系统调用之其中一种exec运行新的程序。这个调用会初始化所有的数据，栈。不同形式的exec只不过在指令的参数，运行环境上有一些不同。
Linux操作系统用一种另外的和fork不同的创建的方式。就是调用clone产生一个共享内存或I/O的进程，这个多用于产生多进程程序的产生。
系统启动是第一个创建的进程就是init，这个进程负责运行所有的启动脚本，同时这个进程还负责管理进程的任务。当一个进程结束的时候，就会调用 _exit通知内核他已经死了。还会返回一个数字告诉他是怎么死的（程序退出的原因）。。。一般用0表示正常退出。在把这个进程火化之前，Linux会用 wait通知他的父母。如果不是该进程自己找死，父母会通过（exit code）知道孩子是怎么被杀死的。同样还可以知道他孩子的财产总数（用的资源：））
这个设计在wait调用正常的时运作的非常棒。但如果该进程的父母已经去世了或者其他原因wait没反应，那么就把该进程的孩子作为孤儿归init养（这不是林妹妹么）。
linux笔记之启动二
Linux启动以后init将执行系统启动脚本，启动脚本做一下的事：
1.设置计算机名
2.设置时区
3.使用fsck检查文件系统
4.挂载系统磁盘
5.将/tmp中老文件干掉
6.配置网络接口
7.启动守护进程和网络服务
init定义了7个运行级别（run level）：
1.Level 0 关机状态
2.Level 1 或称 S 表示单用户模式
3.Level 2-5 表示多用户级别
4.Level 6 表示重启层
一般多用户都在2，3层，第4层一般不用，第五层被X windows的启动进程使用，例如xdm。传说Linux支持10层，但7-9层并未被定义。
1.设置计算机名
2.设置时区
3.使用fsck检查文件系统
4.挂载系统磁盘
5.将/tmp中老文件干掉
6.配置网络接口
7.启动守护进程和网络服务
init定义了7个运行级别（run level）：
1.Level 0 关机状态
2.Level 1 或称 S 表示单用户模式
3.Level 2-5 表示多用户级别
4.Level 6 表示重启层
一般多用户都在2，3层，第4层一般不用，第五层被X windows的启动进程使用，例如xdm。传说Linux支持10层，但7-9层并未被定义。
2009年7月20日星期一
Linux 中文字体文泉驿
开始没注意有这么个东西，弄得课程设计上面的字大大小小的。好东西，替人宣传一下。
官方网站 http://wenq.org/
作为几千年中华文明的见证，浩瀚传统文化传承的载体，汉字是让我们每一个中国人引以为豪的东方文明标志之一。我们的祖先创造汉字，书写汉字，利用汉字和汉
语的无穷魅力创造出让人叹为观止的文学，艺术。而今天进入了计算机时代的我们，虽然不再象古人一样手持毛笔，批著简帛，但我们的生活仍然无时无刻离不开汉
字。
可以毫不夸张的讲，汉字①是世界上最为复杂和庞大的符号系统之一。早在殷商时期，我们的先人就创造出了数目巨大的甲骨文，从发掘出来的上
万片甲骨中整理出来的单字就有四千余个，而东汉许慎编撰的“说文解字”，收录汉字
9,353（一说10,516）个。至清朝康熙年间由段玉裁等人收集整理的“康熙字典”收录汉字竟达 47,035
之多。加上少数民族文字，各种古代典籍上曾经出现但并未广泛使用的古汉字和异体字，汉字总数多达十万以上。
我们是一群致力于在计算机世界中推广汉字，丰富电子汉字资源的志愿者，我们希望通过自己无私的劳动，使得无论你在世界上任何一个角落，都可以免费地获得我们的电子汉字资源，能够流畅地通过汉字进行交流。“文泉驿”是以上述目标为宗旨而自发创建的非盈利性组织。
对于制作电子汉字资源，文泉驿制定了如下子计划：
- 基于开放源代码②的点阵汉字库（优化屏幕显示）
- 基于开放源代码的矢量汉字库
- 基于开放源代码的汉字笔画笔序数据库
- 基于开放源代码的汉字图像识别系统
- 基于开放源代码的汉字笔画识别系统
- 基于开放源代码的汉字信息系统（解释，编码等）
- 开放的非官方电子汉字标准
具体来讲，我们希望完成覆盖 Unicode 4.0
所包含的7万多汉字的点阵位图(9pt,10pt,11pt,12pt等)，笔画笔顺数据库以及基于笔画笔顺数据库生成的不同字型(细宋，中宋，报宋等)
的矢量汉字库。这个工作还可以继续扩展到对所有汉字进行注音，释义，通过笔画笔顺进行汉字检索和分类，少数民族语言文字的点阵和矢量字体，以及汉字图像识
别和笔画识别算法，软件的开发。
The Rise of "Worse is Better''
By Richard Gabriel
I and just about every designer of Common Lisp and CLOS has had extreme exposure to the MIT/Stanford style of design. The essence of this style can be captured by the phrase ``the right thing.'' To such a designer it is important to get all of the following characteristics right:
* Simplicity-the design must be simple, both in implementation and interface. It is more important for the interface to be simple than the implementation.
* Correctness-the design must be correct in all observable aspects. Incorrectness is simply not allowed.
* Consistency-the design must not be inconsistent. A design is allowed to be slightly less simple and less complete to avoid inconsistency. Consistency is as important as correctness.
* Completeness-the design must cover as many important situations as is practical. All reasonably expected cases must be covered. Simplicity is not allowed to overly reduce completeness.
I believe most people would agree that these are good characteristics. I will call the use of this philosophy of design the ``MIT approach.'' Common Lisp (with CLOS) and Scheme represent the MIT approach to design and implementation.
The worse-is-better philosophy is only slightly different:
* Simplicity-the design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.
* Correctness-the design must be correct in all observable aspects. It is slightly better to be simple than correct.
* Consistency-the design must not be overly inconsistent. Consistency can be sacrificed for simplicity in some cases, but it is better to drop those parts of the design that deal with less common circumstances than to introduce either implementational complexity or inconsistency.
* Completeness-the design must cover as many important situations as is practical. All reasonably expected cases should be covered. Completeness can be sacrificed in favor of any other quality. In fact, completeness must sacrificed whenever implementation simplicity is jeopardized. Consistency can be sacrificed to achieve completeness if simplicity is retained; especially worthless is consistency of interface.
Early Unix and C are examples of the use of this school of design, and I will call the use of this design strategy the ``New Jersey approach.'' I have intentionally caricatured the worse-is-better philosophy to convince you that it is obviously a bad philosophy and that the New Jersey approach is a bad approach.
However, I believe that worse-is-better, even in its strawman form, has better survival characteristics than the-right-thing, and that the New Jersey approach when used for software is a better approach than the MIT approach.
Let me start out by retelling a story that shows that the MIT/New-Jersey distinction is valid and that proponents of each philosophy actually believe their philosophy is better.
Two famous people, one from MIT and another from Berkeley (but working on Unix) once met to discuss operating system issues. The person from MIT was knowledgeable about ITS (the MIT AI Lab operating system) and had been reading the Unix sources. He was interested in how Unix solved the PC loser-ing problem. The PC loser-ing problem occurs when a user program invokes a system routine to perform a lengthy operation that might have significant state, such as IO buffers. If an interrupt occurs during the operation, the state of the user program must be saved. Because the invocation of the system routine is usually a single instruction, the PC of the user program does not adequately capture the state of the process. The system routine must either back out or press forward. The right thing is to back out and restore the user program PC to the instruction that invoked the system routine so that resumption of the user program after the interrupt, for example, re-enters the system routine. It is called ``PC loser-ing'' because the PC is being coerced into ``loser mode,'' where ``loser'' is the affectionate name for ``user'' at MIT.
The MIT guy did not see any code that handled this case and asked the New Jersey guy how the problem was handled. The New Jersey guy said that the Unix folks were aware of the problem, but the solution was for the system routine to always finish, but sometimes an error code would be returned that signaled that the system routine had failed to complete its action. A correct user program, then, had to check the error code to determine whether to simply try the system routine again. The MIT guy did not like this solution because it was not the right thing.
The New Jersey guy said that the Unix solution was right because the design philosophy of Unix was simplicity and that the right thing was too complex. Besides, programmers could easily insert this extra test and loop. The MIT guy pointed out that the implementation was simple but the interface to the functionality was complex. The New Jersey guy said that the right tradeoff has been selected in Unix-namely, implementation simplicity was more important than interface simplicity.
The MIT guy then muttered that sometimes it takes a tough man to make a tender chicken, but the New Jersey guy didn't understand (I'm not sure I do either).
Now I want to argue that worse-is-better is better. C is a programming language designed for writing Unix, and it was designed using the New Jersey approach. C is therefore a language for which it is easy to write a decent compiler, and it requires the programmer to write text that is easy for the compiler to interpret. Some have called C a fancy assembly language. Both early Unix and C compilers had simple structures, are easy to port, require few machine resources to run, and provide about 50%--80% of what you want from an operating system and programming language.
Half the computers that exist at any point are worse than median (smaller or slower). Unix and C work fine on them. The worse-is-better philosophy means that implementation simplicity has highest priority, which means Unix and C are easy to port on such machines. Therefore, one expects that if the 50% functionality Unix and C support is satisfactory, they will start to appear everywhere. And they have, haven't they?
Unix and C are the ultimate computer viruses.
A further benefit of the worse-is-better philosophy is that the programmer is conditioned to sacrifice some safety, convenience, and hassle to get good performance and modest resource use. Programs written using the New Jersey approach will work well both in small machines and large ones, and the code will be portable because it is written on top of a virus.
It is important to remember that the initial virus has to be basically good. If so, the viral spread is assured as long as it is portable. Once the virus has spread, there will be pressure to improve it, possibly by increasing its functionality closer to 90%, but users have already been conditioned to accept worse than the right thing. Therefore, the worse-is-better software first will gain acceptance, second will condition its users to expect less, and third will be improved to a point that is almost the right thing. In concrete terms, even though Lisp compilers in 1987 were about as good as C compilers, there are many more compiler experts who want to make C compilers better than want to make Lisp compilers better.
The good news is that in 1995 we will have a good operating system and programming language; the bad news is that they will be Unix and C++.
There is a final benefit to worse-is-better. Because a New Jersey language and system are not really powerful enough to build complex monolithic software, large systems must be designed to reuse components. Therefore, a tradition of integration springs up.
How does the right thing stack up? There are two basic scenarios: the ``big complex system scenario'' and the ``diamond-like jewel'' scenario.
The ``big complex system'' scenario goes like this:
First, the right thing needs to be designed. Then its implementation needs to be designed. Finally it is implemented. Because it is the right thing, it has nearly 100% of desired functionality, and implementation simplicity was never a concern so it takes a long time to implement. It is large and complex. It requires complex tools to use properly. The last 20% takes 80% of the effort, and so the right thing takes a long time to get out, and it only runs satisfactorily on the most sophisticated hardware.
The ``diamond-like jewel'' scenario goes like this:
The right thing takes forever to design, but it is quite small at every point along the way. To implement it to run fast is either impossible or beyond the capabilities of most implementors.
The two scenarios correspond to Common Lisp and Scheme.
The first scenario is also the scenario for classic artificial intelligence software.
The right thing is frequently a monolithic piece of software, but for no reason other than that the right thing is often designed monolithically. That is, this characteristic is a happenstance.
The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads like a virus. Once people are hooked on it, take the time to improve it to 90% of the right thing.
A wrong lesson is to take the parable literally and to conclude that C is the right vehicle for AI software. The 50% solution has to be basically right, and in this case it isn't.
But, one can conclude only that the Lisp community needs to seriously rethink its position on Lisp design. I will say more about this later.
I and just about every designer of Common Lisp and CLOS has had extreme exposure to the MIT/Stanford style of design. The essence of this style can be captured by the phrase ``the right thing.'' To such a designer it is important to get all of the following characteristics right:
* Simplicity-the design must be simple, both in implementation and interface. It is more important for the interface to be simple than the implementation.
* Correctness-the design must be correct in all observable aspects. Incorrectness is simply not allowed.
* Consistency-the design must not be inconsistent. A design is allowed to be slightly less simple and less complete to avoid inconsistency. Consistency is as important as correctness.
* Completeness-the design must cover as many important situations as is practical. All reasonably expected cases must be covered. Simplicity is not allowed to overly reduce completeness.
I believe most people would agree that these are good characteristics. I will call the use of this philosophy of design the ``MIT approach.'' Common Lisp (with CLOS) and Scheme represent the MIT approach to design and implementation.
The worse-is-better philosophy is only slightly different:
* Simplicity-the design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.
* Correctness-the design must be correct in all observable aspects. It is slightly better to be simple than correct.
* Consistency-the design must not be overly inconsistent. Consistency can be sacrificed for simplicity in some cases, but it is better to drop those parts of the design that deal with less common circumstances than to introduce either implementational complexity or inconsistency.
* Completeness-the design must cover as many important situations as is practical. All reasonably expected cases should be covered. Completeness can be sacrificed in favor of any other quality. In fact, completeness must sacrificed whenever implementation simplicity is jeopardized. Consistency can be sacrificed to achieve completeness if simplicity is retained; especially worthless is consistency of interface.
Early Unix and C are examples of the use of this school of design, and I will call the use of this design strategy the ``New Jersey approach.'' I have intentionally caricatured the worse-is-better philosophy to convince you that it is obviously a bad philosophy and that the New Jersey approach is a bad approach.
However, I believe that worse-is-better, even in its strawman form, has better survival characteristics than the-right-thing, and that the New Jersey approach when used for software is a better approach than the MIT approach.
Let me start out by retelling a story that shows that the MIT/New-Jersey distinction is valid and that proponents of each philosophy actually believe their philosophy is better.
Two famous people, one from MIT and another from Berkeley (but working on Unix) once met to discuss operating system issues. The person from MIT was knowledgeable about ITS (the MIT AI Lab operating system) and had been reading the Unix sources. He was interested in how Unix solved the PC loser-ing problem. The PC loser-ing problem occurs when a user program invokes a system routine to perform a lengthy operation that might have significant state, such as IO buffers. If an interrupt occurs during the operation, the state of the user program must be saved. Because the invocation of the system routine is usually a single instruction, the PC of the user program does not adequately capture the state of the process. The system routine must either back out or press forward. The right thing is to back out and restore the user program PC to the instruction that invoked the system routine so that resumption of the user program after the interrupt, for example, re-enters the system routine. It is called ``PC loser-ing'' because the PC is being coerced into ``loser mode,'' where ``loser'' is the affectionate name for ``user'' at MIT.
The MIT guy did not see any code that handled this case and asked the New Jersey guy how the problem was handled. The New Jersey guy said that the Unix folks were aware of the problem, but the solution was for the system routine to always finish, but sometimes an error code would be returned that signaled that the system routine had failed to complete its action. A correct user program, then, had to check the error code to determine whether to simply try the system routine again. The MIT guy did not like this solution because it was not the right thing.
The New Jersey guy said that the Unix solution was right because the design philosophy of Unix was simplicity and that the right thing was too complex. Besides, programmers could easily insert this extra test and loop. The MIT guy pointed out that the implementation was simple but the interface to the functionality was complex. The New Jersey guy said that the right tradeoff has been selected in Unix-namely, implementation simplicity was more important than interface simplicity.
The MIT guy then muttered that sometimes it takes a tough man to make a tender chicken, but the New Jersey guy didn't understand (I'm not sure I do either).
Now I want to argue that worse-is-better is better. C is a programming language designed for writing Unix, and it was designed using the New Jersey approach. C is therefore a language for which it is easy to write a decent compiler, and it requires the programmer to write text that is easy for the compiler to interpret. Some have called C a fancy assembly language. Both early Unix and C compilers had simple structures, are easy to port, require few machine resources to run, and provide about 50%--80% of what you want from an operating system and programming language.
Half the computers that exist at any point are worse than median (smaller or slower). Unix and C work fine on them. The worse-is-better philosophy means that implementation simplicity has highest priority, which means Unix and C are easy to port on such machines. Therefore, one expects that if the 50% functionality Unix and C support is satisfactory, they will start to appear everywhere. And they have, haven't they?
Unix and C are the ultimate computer viruses.
A further benefit of the worse-is-better philosophy is that the programmer is conditioned to sacrifice some safety, convenience, and hassle to get good performance and modest resource use. Programs written using the New Jersey approach will work well both in small machines and large ones, and the code will be portable because it is written on top of a virus.
It is important to remember that the initial virus has to be basically good. If so, the viral spread is assured as long as it is portable. Once the virus has spread, there will be pressure to improve it, possibly by increasing its functionality closer to 90%, but users have already been conditioned to accept worse than the right thing. Therefore, the worse-is-better software first will gain acceptance, second will condition its users to expect less, and third will be improved to a point that is almost the right thing. In concrete terms, even though Lisp compilers in 1987 were about as good as C compilers, there are many more compiler experts who want to make C compilers better than want to make Lisp compilers better.
The good news is that in 1995 we will have a good operating system and programming language; the bad news is that they will be Unix and C++.
There is a final benefit to worse-is-better. Because a New Jersey language and system are not really powerful enough to build complex monolithic software, large systems must be designed to reuse components. Therefore, a tradition of integration springs up.
How does the right thing stack up? There are two basic scenarios: the ``big complex system scenario'' and the ``diamond-like jewel'' scenario.
The ``big complex system'' scenario goes like this:
First, the right thing needs to be designed. Then its implementation needs to be designed. Finally it is implemented. Because it is the right thing, it has nearly 100% of desired functionality, and implementation simplicity was never a concern so it takes a long time to implement. It is large and complex. It requires complex tools to use properly. The last 20% takes 80% of the effort, and so the right thing takes a long time to get out, and it only runs satisfactorily on the most sophisticated hardware.
The ``diamond-like jewel'' scenario goes like this:
The right thing takes forever to design, but it is quite small at every point along the way. To implement it to run fast is either impossible or beyond the capabilities of most implementors.
The two scenarios correspond to Common Lisp and Scheme.
The first scenario is also the scenario for classic artificial intelligence software.
The right thing is frequently a monolithic piece of software, but for no reason other than that the right thing is often designed monolithically. That is, this characteristic is a happenstance.
The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads like a virus. Once people are hooked on it, take the time to improve it to 90% of the right thing.
A wrong lesson is to take the parable literally and to conclude that C is the right vehicle for AI software. The 50% solution has to be basically right, and in this case it isn't.
But, one can conclude only that the Lisp community needs to seriously rethink its position on Lisp design. I will say more about this later.
Linux is obsolete
I was in the U.S. for a couple of weeks, so I haven't commented much on
LINUX (not that I would have said much had I been around), but for what
it is worth, I have a couple of comments now.
As most of you know, for me MINIX is a hobby, something that I do in the
evening when I get bored writing books and there are no major wars,
revolutions, or senate hearings being televised live on CNN. My real
job is a professor and researcher in the area of operating systems.
As a result of my occupation, I think I know a bit about where operating
are going in the next decade or so. Two aspects stand out:
1. MICROKERNEL VS MONOLITHIC SYSTEM
Most older operating systems are monolithic, that is, the whole operating
system is a single a.out file that runs in 'kernel mode.' This binary
contains the process management, memory management, file system and the
rest. Examples of such systems are UNIX, MS-DOS, VMS, MVS, OS/360,
MULTICS, and many more.
The alternative is a microkernel-based system, in which most of the OS
runs as separate processes, mostly outside the kernel. They communicate
by message passing. The kernel's job is to handle the message passing,
interrupt handling, low-level process management, and possibly the I/O.
Examples of this design are the RC4000, Amoeba, Chorus, Mach, and the
not-yet-released Windows/NT.
While I could go into a long story here about the relative merits of the
two designs, suffice it to say that among the people who actually design
operating systems, the debate is essentially over. Microkernels have won.
The only real argument for monolithic systems was performance, and there
is now enough evidence showing that microkernel systems can be just as
fast as monolithic systems (e.g., Rick Rashid has published papers comparing
Mach 3.0 to monolithic systems) that it is now all over but the shoutin`.
MINIX is a microkernel-based system. The file system and memory management
are separate processes, running outside the kernel. The I/O drivers are
also separate processes (in the kernel, but only because the brain-dead
nature of the Intel CPUs makes that difficult to do otherwise). LINUX is
a monolithic style system. This is a giant step back into the 1970s.
That is like taking an existing, working C program and rewriting it in
BASIC. To me, writing a monolithic system in 1991 is a truly poor idea.
2. PORTABILITY
Once upon a time there was the 4004 CPU. When it grew up it became an
8008. Then it underwent plastic surgery and became the 8080. It begat
the 8086, which begat the 8088, which begat the 80286, which begat the
80386, which begat the 80486, and so on unto the N-th generation. In
the meantime, RISC chips happened, and some of them are running at over
100 MIPS. Speeds of 200 MIPS and more are likely in the coming years.
These things are not going to suddenly vanish. What is going to happen
is that they will gradually take over from the 80x86 line. They will
run old MS-DOS programs by interpreting the 80386 in software. (I even
wrote my own IBM PC simulator in C, which you can get by FTP from
ftp.cs.vu.nl = 192.31.231.42 in dir minix/simulator.) I think it is a
gross error to design an OS for any specific architecture, since that is
not going to be around all that long.
MINIX was designed to be reasonably portable, and has been ported from the
Intel line to the 680x0 (Atari, Amiga, Macintosh), SPARC, and NS32016.
LINUX is tied fairly closely to the 80x86. Not the way to go.
Don`t get me wrong, I am not unhappy with LINUX. It will get all the people
who want to turn MINIX in BSD UNIX off my back. But in all honesty, I would
suggest that people who want a **MODERN** "free" OS look around for a
microkernel-based, portable OS, like maybe GNU or something like that.
Andy Tanenbaum (a...@cs.vu.nl)
P.S. Just as a random aside, Amoeba has a UNIX emulator (running in user
space), but it is far from complete. If there are any people who would
like to work on that, please let me know. To run Amoeba you need a few 386s,
one of which needs 16M, and all of which need the WD Ethernet card.
LINUX (not that I would have said much had I been around), but for what
it is worth, I have a couple of comments now.
As most of you know, for me MINIX is a hobby, something that I do in the
evening when I get bored writing books and there are no major wars,
revolutions, or senate hearings being televised live on CNN. My real
job is a professor and researcher in the area of operating systems.
As a result of my occupation, I think I know a bit about where operating
are going in the next decade or so. Two aspects stand out:
1. MICROKERNEL VS MONOLITHIC SYSTEM
Most older operating systems are monolithic, that is, the whole operating
system is a single a.out file that runs in 'kernel mode.' This binary
contains the process management, memory management, file system and the
rest. Examples of such systems are UNIX, MS-DOS, VMS, MVS, OS/360,
MULTICS, and many more.
The alternative is a microkernel-based system, in which most of the OS
runs as separate processes, mostly outside the kernel. They communicate
by message passing. The kernel's job is to handle the message passing,
interrupt handling, low-level process management, and possibly the I/O.
Examples of this design are the RC4000, Amoeba, Chorus, Mach, and the
not-yet-released Windows/NT.
While I could go into a long story here about the relative merits of the
two designs, suffice it to say that among the people who actually design
operating systems, the debate is essentially over. Microkernels have won.
The only real argument for monolithic systems was performance, and there
is now enough evidence showing that microkernel systems can be just as
fast as monolithic systems (e.g., Rick Rashid has published papers comparing
Mach 3.0 to monolithic systems) that it is now all over but the shoutin`.
MINIX is a microkernel-based system. The file system and memory management
are separate processes, running outside the kernel. The I/O drivers are
also separate processes (in the kernel, but only because the brain-dead
nature of the Intel CPUs makes that difficult to do otherwise). LINUX is
a monolithic style system. This is a giant step back into the 1970s.
That is like taking an existing, working C program and rewriting it in
BASIC. To me, writing a monolithic system in 1991 is a truly poor idea.
2. PORTABILITY
Once upon a time there was the 4004 CPU. When it grew up it became an
8008. Then it underwent plastic surgery and became the 8080. It begat
the 8086, which begat the 8088, which begat the 80286, which begat the
80386, which begat the 80486, and so on unto the N-th generation. In
the meantime, RISC chips happened, and some of them are running at over
100 MIPS. Speeds of 200 MIPS and more are likely in the coming years.
These things are not going to suddenly vanish. What is going to happen
is that they will gradually take over from the 80x86 line. They will
run old MS-DOS programs by interpreting the 80386 in software. (I even
wrote my own IBM PC simulator in C, which you can get by FTP from
ftp.cs.vu.nl = 192.31.231.42 in dir minix/simulator.) I think it is a
gross error to design an OS for any specific architecture, since that is
not going to be around all that long.
MINIX was designed to be reasonably portable, and has been ported from the
Intel line to the 680x0 (Atari, Amiga, Macintosh), SPARC, and NS32016.
LINUX is tied fairly closely to the 80x86. Not the way to go.
Don`t get me wrong, I am not unhappy with LINUX. It will get all the people
who want to turn MINIX in BSD UNIX off my back. But in all honesty, I would
suggest that people who want a **MODERN** "free" OS look around for a
microkernel-based, portable OS, like maybe GNU or something like that.
Andy Tanenbaum (a...@cs.vu.nl)
P.S. Just as a random aside, Amoeba has a UNIX emulator (running in user
space), but it is far from complete. If there are any people who would
like to work on that, please let me know. To run Amoeba you need a few 386s,
one of which needs 16M, and all of which need the WD Ethernet card.
2009年7月19日星期日
初识Lisp
翻刘汝佳大牛的课件，无意中看到一本书SICP就买了本。Lisp这个世界上还在使用的第二老的语言，显然有她的独到的魅力。
Lisp的语法相当诡异，她使用前缀表达式，这一表达式在加强了其表述能力的同时，让许多人望而却步。Lisp已经有50年的历史了，但悲剧的是这门优雅强大的语言重来就没有成为主流语言过。国内连本Lisp的书都买不到。Lisp是大师的语言，高楼大厦都是大师所设计的；C是农民工语言，摩天大楼为其所建。只看完了sicp的第一节，就感觉了他的灵活性，以及强大的表达能力。
Lisp最近又有回升趋势，
这位Java高手显然把Lisp当化石一样的研究。但事实上，我觉得Lisp更像是一个新诞生星云，在孕育未来的生命。Lisp让人更接近机器的思考，学习一门语言的同时就可以掌握解释器，编译器是如何工作的。SICP 也同时介绍了人类抽象事物的能力，将思维带到了另一个层次。下面我们看点实际的东西：
*Lisp支持内置的列表，这一点比java内置的vector成熟很多，python向他学的倒是比较像。
*自动内存管理，同样Lisp的表现比java,python更加优秀。
*支持动态类型
*支持匿名函数，这个别人都是向他学的，java匿名函数语法相当累赘。
*统一的语法，没有Lisp的程序员因为忘记语法而苦恼，Lisp帮你打破一切语法的糖衣。
在其他语言中，a+b+c+d, 而Lisp使用(+ a b c d)，几乎所有的格式都是(函数名 <参数列表>)。
*交互环境，Lisp的交互环境让很多人认为他是一个纯解释语言，但其实不然。
*可扩展性，Lisp是一个programmalbe programming language :)
既然Lisp有比java python跟强的表达能力，那么Lisp的效率如何呢？
从上表我们可以看到，Lisp几乎是Java的1.5到4倍，Python的10到50倍（当然Python还在不断进化当中），而她跟C++差不多。
说了这么多，我还是写几本打你推荐的Lisp书比较好：
Paul Graham's On Lisp and ANSI
Common Lisp
SICP(scheme), MIT PRESS
Lisp的运行环境：
scheme用MIT Scheme（Linux下有点问题）, PLT-Scheme用的蛮好
Lisp用 cmucl, sbcl, clisp都比较好,gcl传说还不是ANSI标准，我Fedora下运行还是段错误。
Lisp的语法相当诡异，她使用前缀表达式，这一表达式在加强了其表述能力的同时，让许多人望而却步。Lisp已经有50年的历史了，但悲剧的是这门优雅强大的语言重来就没有成为主流语言过。国内连本Lisp的书都买不到。Lisp是大师的语言，高楼大厦都是大师所设计的；C是农民工语言，摩天大楼为其所建。只看完了sicp的第一节，就感觉了他的灵活性，以及强大的表达能力。
Lisp最近又有回升趋势，
让我们看看其他语言高手的评价吧！据资料显示，著名Java高手、Jolt大奖获奖作者Bruce Tate在2007年发表的《编程语言的王道：Lisp之美》中这样说到：
“Lisp
长久以来一直被视为伟大的编程语言之一。其漫长的发展过程(接近五十年)中引发的追随狂潮表明：这是一门非同凡响的语言。在 MIT，Lisp
在所有程序员的课程中占了举足轻重的地位。像 Paul Graham 那样的企业家们将 Lisp
卓越的生产力用作他们事业成功起步的推动力。但令其追随者懊恼万分的是，Lisp 从未成为主流编程语言。作为一名
Java程序员，如果您花一点时间研究 Lisp 这座被人遗忘的黄金之城，就会发现许多能够改进编码方式的技术。”
这位Java高手显然把Lisp当化石一样的研究。但事实上，我觉得Lisp更像是一个新诞生星云，在孕育未来的生命。Lisp让人更接近机器的思考，学习一门语言的同时就可以掌握解释器，编译器是如何工作的。SICP 也同时介绍了人类抽象事物的能力，将思维带到了另一个层次。下面我们看点实际的东西：
*Lisp支持内置的列表，这一点比java内置的vector成熟很多，python向他学的倒是比较像。
*自动内存管理，同样Lisp的表现比java,python更加优秀。
*支持动态类型
*支持匿名函数，这个别人都是向他学的，java匿名函数语法相当累赘。
*统一的语法，没有Lisp的程序员因为忘记语法而苦恼，Lisp帮你打破一切语法的糖衣。
在其他语言中，a+b+c+d, 而Lisp使用(+ a b c d)，几乎所有的格式都是(函数名 <参数列表>)。
*交互环境，Lisp的交互环境让很多人认为他是一个纯解释语言，但其实不然。
*可扩展性，Lisp是一个programmalbe programming language :)
既然Lisp有比java python跟强的表达能力，那么Lisp的效率如何呢？
| Test | Lisp | Java | Python | Perl | C++ | ||
|---|---|---|---|---|---|---|---|
| exception handling | 0.01 | 0.90 | 1.54 | 1.73 | 1.00 | ||
| hash access | 1.06 | 3.23 | 4.01 | 1.85 | 1.00 | ||
| sum numbers from file | 7.54 | 2.63 | 8.34 | 2.49 | 1.00 | 100+ x C++ | |
| reverse lines | 1.61 | 1.22 | 1.38 | 1.25 | 1.00 | 50-100 x C++ | |
| matrix multiplication | 3.30 | 8.90 | 278.00 | 226.00 | 1.00 | 10-50 x C++ | |
| heapsort | 1.67 | 7.00 | 84.42 | 75.67 | 1.00 | 5-10 x C++ | |
| array access | 1.75 | 6.83 | 141.08 | 127.25 | 1.00 | 1-5 x C++ | |
| list processing | 0.93 | 20.47 | 20.33 | 11.27 | 1.00 | 0-1 x C++ | |
| object instantiation | 1.32 | 2.39 | 49.11 | 89.21 | 1.00 | ||
| word count | 0.73 | 4.61 | 2.57 | 1.64 | 1.00 | ||
| 25% to 75% | 0.93 to 1.67 | 2.63 to 7.00 | 2.57 to 84.42 | 1.73 to 89.21 | 1.00 to 1.00 |
从上表我们可以看到，Lisp几乎是Java的1.5到4倍，Python的10到50倍（当然Python还在不断进化当中），而她跟C++差不多。
说了这么多，我还是写几本打你推荐的Lisp书比较好：
Paul Graham's On Lisp and ANSI
Common Lisp
SICP(scheme), MIT PRESS
Lisp的运行环境：
scheme用MIT Scheme（Linux下有点问题）, PLT-Scheme用的蛮好
Lisp用 cmucl, sbcl, clisp都比较好,gcl传说还不是ANSI标准，我Fedora下运行还是段错误。
2009年7月6日星期一
Linux笔记之启动&GRUB
Linux启动并不是简单的通电断电。当电源开关被按下后存在ROM中的引导程序就将执行，这个引导程序讲解决如何载入和启动Linux内核。内核被载入后，将探测系统的硬件同时产生第一个进程init。之后，init进程将负责文件系统fs检测和挂载，系统守护进程启动。
Linux启动主要分以下5个阶段：
1.内核的载入和初始化；
2.设备的检测和配置；
3.产生内核进程；
4.执行系统启动脚本；
5.多用户操作。
下面具体介绍一下这5个阶段。
1.内核的初始化
Linux内核kernel本身也是一个程序，Linux启动的第一件事就是把这个程序添加到内存里并执行。而kernel一般放在/vmlinuz或者/boot/vmvlinuz处。引导过程主要分两步走：第一，ROM载入一个引导程序到内存里。这个程序将kernel载入到内存。接着，kernel负责内存检测RAM内核将保留一块内存为自己所用，这块内存将不能被任何用户级别的程序使用。
2.设备的检测
内核的第一个任务就是检测机器的环境，看看现在有些什么硬件啊，然后选择正确的驱动程序。当然这些必须在你编译内核的时候告诉他有哪些硬件。
3.内核的进程
初始化结束后，内核kernel将在用户空间产生几个自发生进程。
4.执行系统启动脚本（就是些一般的shell script）
5.多用户操作
执行完系统启动脚本后，系统就完全运作起来了，当然还没人登录。登录一定要被一个特定的终端接受，同时一个叫做getty的进程对其进行监听。这个进程由init直接产生，另外init还负责产生图形化登录界面xdm和gdm。
对于PC的启动有两个常用的引导程序：LILO和GRUB
LILO本来是传统的Linux引导程序，但是由于其不能很好的支持多启动，因此Red Hat ,SUSE, Fedora都将GRUB作为默认引导程序。
说一下GRUB（以下文字由ajaxhe提供）
----------------------------------------------------------------------------------------------------------------------
Fedora Linux采用GRUB作为引导程序。GRUB（Grand Unifed Bootloader，大一统引导管理器）是一个通用的引导程序，是用户能够在引导系统时选择启动的操作系统，或选择同一操作系统的不同版本。GRUB是目前应用最广的引导程序，许多Linux系统现均采用GRUB作为默认的引导程序。
GRUB提供三个功能强大的用户界面，每个界面都允许用户直接引导操作系统，在系统启动期间甚至可以在GRUB的三个界面之间切换。
第一个是菜单界面，采用GRUB的Linux系统都将GRUB菜单作为默认的引导界面。当安装完毕，计算机引导时，菜单界面就会出现在屏幕上，利用上下箭头选择需要引导的系统，按下回车键即可。如果长时间没有用户登录，GRUB会自动引导默认的操作系统。
第二个是菜单配置编辑界面，在引导操作系统的菜单中按下“e”键，便可以进入菜单编辑器。此时，可以临时性的修改操作系统引导菜单 。例如，按下“o”键便可以在当前行后面增加引导项；按下“O”键可以在当前行前面增加引导；使用“d”键可以删除引导项；使用“e”键可以编辑引导项等。修改后可以按回车键确认，或者按Esc键取消修改。
注： 在编辑操作系统引导菜单期间所作的任何修改都是临时性的 ，在下次引导时，这些修改回消失（如果想永久性地修改引导菜单，需要编辑grub.conf文件）。在测试新编译的系统内核时，这个界面比较有用。
第三个是命令行界面，在引导操作系统的菜单中按下“c”键，便可以进入命令行界面。命令行是GRUB最基本的界面，也是最基本的界面。
GRUB采用下列形式命名存储设备及其分区：
(,)
其中。“”表示设备的类型。最常用的两个设备类型是hd(表示硬盘)和fd(表示3.5英寸软盘)。其他设备还有nd(表示网络)和cd(表示CD/DVD)等。
“”是BIOS能够识别的设备号，从0开始编号。主硬盘称作hd0，第二个硬盘的编号为1，如此等等。例如，GRUB把第一个磁盘称作 hd0,第二个磁盘称作hd1。第一个软盘驱动器称作fd0。这种设备命名和编号方式等价于Linux系统内核采用的设备命名方式，例如，Linux系统内核使用的设备名/dev/hda等价于GRUB德hd0，/dev/hdb等价于hd1。
“”指定设备的分区编号。同BIOS设备号一样，设备分区编号也是从0开始编号的。例如GRUB把第一个磁盘的第一个分区称作“(hd0,0)”，第二个磁盘的第三个分区称作"(hd1,2)"。
在命名和引用设备于分区时，GRUB并不区分IDE硬盘和SCSI硬盘，所有的硬盘均以hd命名。当指定整个硬盘，且不考虑其分区时（如需要将GRUB安装到一个硬盘的主引导目录（MBR）时）只需要将逗号“,”和分号去掉即可。
--摘自《Fedora 8 Linux从入门到精通》 电子工业出版社 邢国庆 任永杰 张凯 编辑
--------------------------------------------------------------------------------------------------------------------------
因此如果要设置双启动，需进行如下配置：
打开/etc/grub.conf
Windows系统与UNIX系统不同：
title Windows XP
rootnoverify (hd0,0)
chainloader +1
chainloader表示从特定地方载入引导程序（这里是主硬盘第一分区的第一扇区）
rootnoverify 要这样看root-no-verify该选项保证grub不会试着去挂载特定的分区，这就避免了GRUB在读取其无法理解的分区时陷入泥潭。例如，ntfs格式的分区或者GRUB能够读取范围以外的分区。
(hd0,0)第一个数字值代表物理盘的编码，第二个数字表示分区号。(hd0,0)="/dev/hda1" XP必须挂在第0分区（鄙视你！）
例子：
default=0
timeout =0
splashimage=(hd0,2)/boot/grub/splash.xpm.gz
hiddenmenu
title Windows XP
rootnoverify (hd0,0)
title Red Hat
root (hd0,1)
kernel /boot/vmlinuz
title Fedora
root (hd0,2)
kernel /boot/vmlinuz
Linux启动主要分以下5个阶段：
1.内核的载入和初始化；
2.设备的检测和配置；
3.产生内核进程；
4.执行系统启动脚本；
5.多用户操作。
下面具体介绍一下这5个阶段。
1.内核的初始化
Linux内核kernel本身也是一个程序，Linux启动的第一件事就是把这个程序添加到内存里并执行。而kernel一般放在/vmlinuz或者/boot/vmvlinuz处。引导过程主要分两步走：第一，ROM载入一个引导程序到内存里。这个程序将kernel载入到内存。接着，kernel负责内存检测RAM内核将保留一块内存为自己所用，这块内存将不能被任何用户级别的程序使用。
2.设备的检测
内核的第一个任务就是检测机器的环境，看看现在有些什么硬件啊，然后选择正确的驱动程序。当然这些必须在你编译内核的时候告诉他有哪些硬件。
3.内核的进程
初始化结束后，内核kernel将在用户空间产生几个自发生进程。
4.执行系统启动脚本（就是些一般的shell script）
5.多用户操作
执行完系统启动脚本后，系统就完全运作起来了，当然还没人登录。登录一定要被一个特定的终端接受，同时一个叫做getty的进程对其进行监听。这个进程由init直接产生，另外init还负责产生图形化登录界面xdm和gdm。
对于PC的启动有两个常用的引导程序：LILO和GRUB
LILO本来是传统的Linux引导程序，但是由于其不能很好的支持多启动，因此Red Hat ,SUSE, Fedora都将GRUB作为默认引导程序。
说一下GRUB（以下文字由ajaxhe提供）
----------------------------------------------------------------------------------------------------------------------
Fedora Linux采用GRUB作为引导程序。GRUB（Grand Unifed Bootloader，大一统引导管理器）是一个通用的引导程序，是用户能够在引导系统时选择启动的操作系统，或选择同一操作系统的不同版本。GRUB是目前应用最广的引导程序，许多Linux系统现均采用GRUB作为默认的引导程序。
GRUB提供三个功能强大的用户界面，每个界面都允许用户直接引导操作系统，在系统启动期间甚至可以在GRUB的三个界面之间切换。
第一个是菜单界面，采用GRUB的Linux系统都将GRUB菜单作为默认的引导界面。当安装完毕，计算机引导时，菜单界面就会出现在屏幕上，利用上下箭头选择需要引导的系统，按下回车键即可。如果长时间没有用户登录，GRUB会自动引导默认的操作系统。
第二个是菜单配置编辑界面，在引导操作系统的菜单中按下“e”键，便可以进入菜单编辑器。此时，可以临时性的修改操作系统引导菜单 。例如，按下“o”键便可以在当前行后面增加引导项；按下“O”键可以在当前行前面增加引导；使用“d”键可以删除引导项；使用“e”键可以编辑引导项等。修改后可以按回车键确认，或者按Esc键取消修改。
注： 在编辑操作系统引导菜单期间所作的任何修改都是临时性的 ，在下次引导时，这些修改回消失（如果想永久性地修改引导菜单，需要编辑grub.conf文件）。在测试新编译的系统内核时，这个界面比较有用。
第三个是命令行界面，在引导操作系统的菜单中按下“c”键，便可以进入命令行界面。命令行是GRUB最基本的界面，也是最基本的界面。
GRUB采用下列形式命名存储设备及其分区：
(
其中。“
“
“
在命名和引用设备于分区时，GRUB并不区分IDE硬盘和SCSI硬盘，所有的硬盘均以hd命名。当指定整个硬盘，且不考虑其分区时（如需要将GRUB安装到一个硬盘的主引导目录（MBR）时）只需要将逗号“,”和分号去掉即可。
--摘自《Fedora 8 Linux从入门到精通》 电子工业出版社 邢国庆 任永杰 张凯 编辑
--------------------------------------------------------------------------------------------------------------------------
因此如果要设置双启动，需进行如下配置：
打开/etc/grub.conf
Windows系统与UNIX系统不同：
title Windows XP
rootnoverify (hd0,0)
chainloader +1
chainloader表示从特定地方载入引导程序（这里是主硬盘第一分区的第一扇区）
rootnoverify 要这样看root-no-verify该选项保证grub不会试着去挂载特定的分区，这就避免了GRUB在读取其无法理解的分区时陷入泥潭。例如，ntfs格式的分区或者GRUB能够读取范围以外的分区。
(hd0,0)第一个数字值代表物理盘的编码，第二个数字表示分区号。(hd0,0)="/dev/hda1" XP必须挂在第0分区（鄙视你！）
例子：
default=0
timeout =0
splashimage=(hd0,2)/boot/grub/splash.xpm.gz
hiddenmenu
title Windows XP
rootnoverify (hd0,0)
title Red Hat
root (hd0,1)
kernel /boot/vmlinuz
title Fedora
root (hd0,2)
kernel /boot/vmlinuz
2009年6月20日星期六
初识slab分配器
在进程描述符的调度中，涉及到slab的原理，但从其根本上说其是一个内存的分配机制。
先试探其来源、发展的历史，然后从其功能、优点、缺点等作笼统性的概括，最后以一个linux的实例来分析它。
linux的slab机制从sun的sun os5.4继承过来和发展的。
linux通过slab分配器分配task_struct结构，这样能达到对象复用和缓存着色的目的。
分配和释放数据结构是所有内核中最普遍的操作之一。为了便于数据的频繁分配和回收，编程者常常会用到一个空闲链表。该空闲链表包含可供使用的、已经分配好的数据结构块。当代码需要一个新的数据结构实例时，就可以从空闲链表中抓去一个，而不需要分配内存、再把数据放进去。以后，当不再需要这个数据结构的实例时，就把它放回空闲链表、而不是释放掉它。从这个意义上说，空闲链表相当于对象高速缓存以便快速存储频繁使用的对象类型。
在内核中，空闲链表面临的主要问题之一就是不能全局控制。当内存变的紧缺时，内核无法通知每个空闲链表，让其收缩缓存大小以便释放出一些内存来。实际上，内核根本就不知道存在任何空闲链表。为了弥补这一缺陷，也为了使代码更加稳固，linux内核提供了slab层。slab分配器扮演了通用数据结构缓存层的角色。
slab试图在几个基本原则之间寻求一种平衡：
频繁使用的数据结构也会频繁分配和释放，因此应当缓存它们。
频繁分配和回收必然会导致内存碎片。
回收的对象可以立即投入下一次分配。
如果让部分缓存专属于单个处理器，那么，分配和释放就可以在不加SMP锁的情况下进行。
对存放的对象进行着色，以防止多个对象映射到相同的高速缓存行。
1、不同的数据类型用不同的方法分配内存可能提高效率。比如需要初始化的数据结构,释放后可以暂存着,再分配时就不必初始化了
2、内核的函数常常重复地使用同一类型的内存区,缓存最近释放的对象可以加速分配和释放对内存的请求可以按照请求频率来分类,频繁使用的类型使用专门的缓存,很少使用的可以使用类似2.0中的取整到2的幂次的通用缓存
3、使用2的幂次大小的内存区域时高速缓存冲突的概率较大,有可能通过仔细安排内存区域的起始地址来减少高速缓存冲突缓存一定数量的对象可以减少对buddy系统的调用,从而节省时间并减少由此引起的高速缓存污染
Slab分配器把存储器区看作对象(object)
Slab分配器把对象按照类型分组成不同
每个Slab由一个或多个连续的页框组成,这些页框中包含已分配的对象,也包含空闲的对象
Slab分配器通过伙伴系统分配页框
先试探其来源、发展的历史，然后从其功能、优点、缺点等作笼统性的概括，最后以一个linux的实例来分析它。
linux的slab机制从sun的sun os5.4继承过来和发展的。
linux通过slab分配器分配task_struct结构，这样能达到对象复用和缓存着色的目的。
分配和释放数据结构是所有内核中最普遍的操作之一。为了便于数据的频繁分配和回收，编程者常常会用到一个空闲链表。该空闲链表包含可供使用的、已经分配好的数据结构块。当代码需要一个新的数据结构实例时，就可以从空闲链表中抓去一个，而不需要分配内存、再把数据放进去。以后，当不再需要这个数据结构的实例时，就把它放回空闲链表、而不是释放掉它。从这个意义上说，空闲链表相当于对象高速缓存以便快速存储频繁使用的对象类型。
在内核中，空闲链表面临的主要问题之一就是不能全局控制。当内存变的紧缺时，内核无法通知每个空闲链表，让其收缩缓存大小以便释放出一些内存来。实际上，内核根本就不知道存在任何空闲链表。为了弥补这一缺陷，也为了使代码更加稳固，linux内核提供了slab层。slab分配器扮演了通用数据结构缓存层的角色。
slab试图在几个基本原则之间寻求一种平衡：
频繁使用的数据结构也会频繁分配和释放，因此应当缓存它们。
频繁分配和回收必然会导致内存碎片。
回收的对象可以立即投入下一次分配。
如果让部分缓存专属于单个处理器，那么，分配和释放就可以在不加SMP锁的情况下进行。
对存放的对象进行着色，以防止多个对象映射到相同的高速缓存行。
1、不同的数据类型用不同的方法分配内存可能提高效率。比如需要初始化的数据结构,释放后可以暂存着,再分配时就不必初始化了
2、内核的函数常常重复地使用同一类型的内存区,缓存最近释放的对象可以加速分配和释放对内存的请求可以按照请求频率来分类,频繁使用的类型使用专门的缓存,很少使用的可以使用类似2.0中的取整到2的幂次的通用缓存
3、使用2的幂次大小的内存区域时高速缓存冲突的概率较大,有可能通过仔细安排内存区域的起始地址来减少高速缓存冲突缓存一定数量的对象可以减少对buddy系统的调用,从而节省时间并减少由此引起的高速缓存污染
Slab分配器把存储器区看作对象(object)
Slab分配器把对象按照类型分组成不同
每个Slab由一个或多个连续的页框组成,这些页框中包含已分配的对象,也包含空闲的对象
Slab分配器通过伙伴系统分配页框
2009年6月16日星期二
Intel 8xx series graphics card not well support KMS
1.What is kernel modesetting(KMS)?
Currently, most graphics modes are initialized during the X server startup. Kernel Modesetting (referred to as KMS hereafter) moves this process from the X server's DDX drivers to the kernel, and it enables several new features including:
* Improved Graphical Boot
* Faster fast user switching
* Seamless X server switching
* Graphical panic messages
Memory Management, while a separate feature in its own right, is included here because it is a requirement for Kernel Modesetting.
2.Fedora 11 enable this by default
3.However, Intel 8xx graphics card or earlier edition did not well support this. So KMS may produce several troubles.
4.how to find the informaiton of your video card?
>lspci | grep VGA
5.How to figure it out?
disable KMS.
To fix, disable kernel mode setting (KMS) by adding the following to the kernel parameters in /etc/grub.conf after "rhgb quiet" "nomodeset". But if you still want the graphical boot screen then add this also "vga=0x318".
Currently, most graphics modes are initialized during the X server startup. Kernel Modesetting (referred to as KMS hereafter) moves this process from the X server's DDX drivers to the kernel, and it enables several new features including:
* Improved Graphical Boot
* Faster fast user switching
* Seamless X server switching
* Graphical panic messages
Memory Management, while a separate feature in its own right, is included here because it is a requirement for Kernel Modesetting.
2.Fedora 11 enable this by default
3.However, Intel 8xx graphics card or earlier edition did not well support this. So KMS may produce several troubles.
4.how to find the informaiton of your video card?
>lspci | grep VGA
5.How to figure it out?
disable KMS.
To fix, disable kernel mode setting (KMS) by adding the following to the kernel parameters in /etc/grub.conf after "rhgb quiet" "nomodeset". But if you still want the graphical boot screen then add this also "vga=0x318".
Why IBM 360 Model 65 and 75, staggered in two separate main memory units
IN IBM 360 model 65 and 75 address are staggered in two seperate main memory units( all even number words in one unit and all odd number words in another unit)What might be the purpose of this technique?
Answers:
多体交叉存储器，使用地址交叉法，有多套读写电路并行访问，提高速度。
The memory is divided into two blocks, even and odd blocks called low order and high order blocks with odd addresses is termed as low order and the blocks with even addresses is referred as high order blocks. In odd it stores arithmetic and will come in single word and in even it stores floating point numbers and will come in two words. Also to maintain the old architecture because the old one used 8-bit register and this new one use 16-bit of 8,8 bit each.Suppose you want to read a word from location 125. Okay, the L.O. byte of the word comes from location 125 and the H.O. word comes from location 126.
The advantage of using even and odd registers is that we can access up to two words. This increase the speed and efficiency of the whole system.
Think of memory as a linear array of bytes. The address of the first byte is zero and the address of the last byte is (2**n)-1.
To execute the equivalent of the Pascal statement "Memory [125]:= 0;" the CPU places the value zero on the data bus, the address 125 on the address bus, and asserts the write line (since the CPU is writing data to memory:
The above discussion applies only when accessing a single byte in memory. So what happens when the processor accesses a word or a double word? Since memory consists of an array of bytes, how can we possibly deal with values larger than eight bits?
The 80x86 family deals with this problem by storing the L.O. byte of a word at the address specified and the H.O. byte at the next location.
The IBM Models 65 & 75 used two separate registers namely odd register & even register for odd-numbered words & even-numbered words respectively. The actual idea behind the application of this technique was that the integers at that time required only one word & hence rightly labeled as odd-numbered word, while floating points required two words & hence named as even-numbered words. Thus the two types of values were stored in two different registers as mentioned above.
The following were the major advantages: -
• Memory was greatly saved by allotting almost exactly the required space. At that time, memory was very limited & costly.
• Accessing the address was much faster mentioning the address was not required. Because on finding the integer value it will automatically go to odd register & on encountering floating point value, it will automatically go to even register.
• Parallel accessing the two registers was possible by a single clock. So processing speed was increased.
Answers:
多体交叉存储器，使用地址交叉法，有多套读写电路并行访问，提高速度。
The memory is divided into two blocks, even and odd blocks called low order and high order blocks with odd addresses is termed as low order and the blocks with even addresses is referred as high order blocks. In odd it stores arithmetic and will come in single word and in even it stores floating point numbers and will come in two words. Also to maintain the old architecture because the old one used 8-bit register and this new one use 16-bit of 8,8 bit each.Suppose you want to read a word from location 125. Okay, the L.O. byte of the word comes from location 125 and the H.O. word comes from location 126.
The advantage of using even and odd registers is that we can access up to two words. This increase the speed and efficiency of the whole system.
Think of memory as a linear array of bytes. The address of the first byte is zero and the address of the last byte is (2**n)-1.
To execute the equivalent of the Pascal statement "Memory [125]:= 0;" the CPU places the value zero on the data bus, the address 125 on the address bus, and asserts the write line (since the CPU is writing data to memory:
The above discussion applies only when accessing a single byte in memory. So what happens when the processor accesses a word or a double word? Since memory consists of an array of bytes, how can we possibly deal with values larger than eight bits?
The 80x86 family deals with this problem by storing the L.O. byte of a word at the address specified and the H.O. byte at the next location.
The IBM Models 65 & 75 used two separate registers namely odd register & even register for odd-numbered words & even-numbered words respectively. The actual idea behind the application of this technique was that the integers at that time required only one word & hence rightly labeled as odd-numbered word, while floating points required two words & hence named as even-numbered words. Thus the two types of values were stored in two different registers as mentioned above.
The following were the major advantages: -
• Memory was greatly saved by allotting almost exactly the required space. At that time, memory was very limited & costly.
• Accessing the address was much faster mentioning the address was not required. Because on finding the integer value it will automatically go to odd register & on encountering floating point value, it will automatically go to even register.
• Parallel accessing the two registers was possible by a single clock. So processing speed was increased.
2009年5月13日星期三
七大IT狂热门派，你属于哪一派？
如果你在技术圈子泡了太久，有些东西就开始进入你的骨子里——可能会是一个小发明，可能是你喜爱的一台老式电脑，或者你花了几个月才弄懂的编程语言。然后，你就会发现：生活和以前完全不一样了！它已经成为了你的一部分！你开始认同它，甚至建立起一个信仰系统;你开始定期参加会议，和其他人一起，并公开的蔑视其他团体的成员…… 在你意识到这一点时，恭喜你!你已经成为某一个IT门派的一员了。
“人 们会对他们所使用的技术产生保护性和族群性的感情，”心理学家Michael Jolkovski说，“把这种感觉称作帮派、宗教或门派是非常贴切的。”Jolkovski补充说，他属于苹果的门派，并耐心地等待购买新产品的指令。 当然，有些人不喜欢“门派”这个词，所以称为俱乐部也可以，只要它让你感觉更好。
无论哪种方式，来看看你是不是已经属于以下七个最大的门派了——当然，编者提醒您：限于国情等因素，也许您不属于以下列举的七大门派之一;但如果您已经符合了上述行为特征，那么您已经成为“道”上的人了。
技术门派之一：Palm道(The Way of the Palm)
立派时间：1996
总舵所在地：Palm论坛
掌门人：Jeff Hawkins、Donna Dubinsky
镇派之宝：Pilot 1000和Pilot 5000
1996年秋天，Jonathan Ezor走进一家音乐商店，在那里他遇到了他的第一部Pilot 1000。这并不完全是宗教的体验，但改变了他的生命。他被Pilot完美的Graffiti输入法震惊，从此成为了它忠实的拥护者。【编者 注：Pilot 1000是世界首款获得成功的PDA产品，最初发布于1996年3月。虽然Pilot 1000只有128K内存和一个绿底黑字的单色屏幕，但它是移动技术发展史上的一个标志，开启了此后轰轰烈烈的PDA市场，也使Palm Pilot成为了家喻户晓的名字。】
Ezor说他已经拥有7个Palm PDA，他估计至少有200人在他的推荐下购买了Palm。他还承认，在极少数情况下他才会使用笔和纸，有时会发现自己在用Graffiti写字。
你可以识别真正Palm门徒，因为他们经常兴高采烈的围在一起通过Palm的红外端口来共享联系信息和免费软件。另一个分辨他们的办法是看他们是不是像拿着电视遥控器一样拿着Palm。
Palm的支持者们度过了几年的困难时期。在良好的开端之后，Palm被一次次的收购和分拆。原来的Palm领袖Jeff Hawkins和Donna Dubinsky也历经了离开和重返的风波。
Palm无奈地采用Windows Mobile系统让支持者们感到沮丧，无能为力的看着BlackBerry和iPhone超过他们——而据在两周前发布的消息，谷歌也在4月发布了Android 1.5的SDK，宣告了T-Mobile G1 加入了竞争者行列。
对Palm门派的追随者而言，也许Palm Pre和WebOS的到来寄托着他们对Palm复兴的希望——正如此前报道的，2009CES 上Palm 发布了新款手机Palm pre，而且随着这部手机的发布让Palm 低迷的股价暴涨。
但评论指出，Palm pre以及Web OS诞生的意义，也许只是证明Palm 还“活着”而已。
技术门派之二：Ruby兄弟会(Brotherhood of the Ruby)
立派时间：1994
总舵所在地：RailsConf大会、RubyConf大会
掌门人：Matz、David Heinemeier Hansson(DHH)
道上切口(口号)：MINSWAN(Matz好所以我们好)
编程语言Ruby和其年轻时尚的小兄弟Ruby on Rails(RoR)，经历了多年的奋斗，Ruby的追随者们终于发现自己正在被主流接受。
“它让我们感觉高人一筹，”Ruby on Rails的开发者Obie Fernandez笑言，“另外，我们从一开始就遇到了很多阻力，这使我们更加团结。”
Ruby是1994年由Yukihiro Matsumoto开发的，人们习惯称他为“Matz”。他想创建一个脚本语言，他形容为“比Perl更强大，比Python更面向对象。”围绕着 Ruby，一个开源社区很快形成，社区的理念是MINSWAN，即“Matz好所以我们好。(Matz is nice, so we are nice.)”
2004年，David Heinemeier Hansson(DHH)开发了Ruby on Rails，以Ruby的应用框架为基础，能够快速开发美观的网站。与Matz的含蓄不同，DHH喜欢在会议上发布爆炸性的言论。不过，RoR迅速获得了 成千上万的追随者，其中包括几家财富500强的企业，其中不乏Twitter、Yellow Pages这样的大腕！而在此前公布的TIOBE 2009年4月的编程语言排行榜中，Ruby历史性地进入前十，也体现了其良好的增长态势。
技术门派之三：Ubuntu部落(The Ubuntu tribe)
立派时间：2004
总舵所在地：Ubuntu开发者峰会
开山始祖：Linus Torvalds
掌门人：Mark Shuttleworth
门派吉祥物：獾、公鸭、蜥蜴、小鹿、长臂猿、苍鹭、野山羊、野兔、考拉(Breezy badgers, dapper drakes, feisty fawns, gutsy gibbons, hardy herons, intrepid ibexes, jaunty jackalopes，依次按字母顺序排列)
作为Debian部落的一个分支Ubuntu可能是Linux信仰体系中最大的一个分支，有部分原因是因为它更容易被不那么精通技术的爱好者所接受。
“Ubuntu是更强大的更用户友好的Linux发行版，受到初级和中级用户社区的普遍接受，”出版商Scott Steinberg说。“用户的参与是值得欢迎的，社区一直在真诚的努力以确保Ubuntu的普遍流行。”
Ubuntu代码由一个120多位知名人物的理事会管理，另外还有55个神秘的核心开发人员和成千上万的底层程序员。然而，它有一个唯一的统治者，他就是Mark Shuttleworth，Ubuntu的商业赞助商Canonical的CEO。
虽然单词“Ubuntu”源于非洲的哲学，意思是“集体造就了我”——Ubuntu源于非洲祖鲁人和科萨人的语言，发作oo-boon-too的音。而在中国Ubuntu更标准的中文发音大约为“乌班图”。
虽然Ubunutu社区之间的分歧也很多，不过就总体而言，Ubuntu的社区联系紧密，管辖良好，在与Windows、Mac和其他Linux版本的追随者的斗争中丝毫不落下风。
技术门派之四：Commodore人(The Commodorians)
立派时间：1982
总舵所在地：CommVEx、C4博览会、Commodore世界
掌门人：Jack Tramiel
长老：Jim Butterfield (1936-2007)
镇派之宝：Commodore C65
Commodore人认为只有一条通向真理的道路，而且宽度是8位的。
【编者注：Commodore 64被认为是最好的计算机设计之一。1982年，Commodore International公司发行了这款8位家用计算机，价格仅595美元，具备64K的RAM以及比当时的IBM PC兼容机优胜的声音和图像。】
从1982年到1994年，Commodore 64是最成功的个人电脑，取得了超过30万台的销售，许多人甚至目前仍在使用。
有许多网站和多个会议专门为C64召开(也包括它的最后一个姐妹版Commodore 128)，Commodore社区虽小但很繁荣。
“Commodore 8位的用户是计算机世界的活化石，就如同那些老大众甲壳虫汽车的收集者，”Eric Brown说，他的网站专门为旧硬件如C64和C128提供网络接入。“信不信由你，如今仍然有人在为C64/128编写新的软件，也仍然有人通过旧的 C128上网和处理电子邮件。”
技术门派之五：Lisp追随者(The Order of the Lisp)
立派时间：1958
总舵所在地：国际Lisp会议
掌门人：John McCarthy
长老：Paul Graham、Peter Norvig
道上切口(口号)：人工智能编程的模范
已经躲藏起来的Lisp语言曾经是一个强大的力量，作为下一代计算的核心。它是与人工智能和专家系统紧密结合的语言，在70年代后期，Lisp随着人工智能的声誉下滑而步入低谷。
对专家系统的反抗导致了“AI的冬天”，国际Lisp会议主席Dan Weinreb说，“人工智能几乎成为一个反面词汇，LISP也被拖累。”
Lisp语言分裂成几十种方言，它的追随者也分散在网络上。但它在学术界仍然是一个强大的力量。
尽管已经超过了50岁，但Lisp正在日益吸引人们的兴趣。去年3月在麻省理工学院举行的国际Lisp会议有超过200个与会者，是07年的两倍。Lisp语言仍在商业使用，Weinreb说，“有些公司秘密的使用Lisp但却不敢公开，这是非常愚蠢的。”
让我们看看其他语言高手的评价吧！据资料显示，著名Java高手、Jolt大奖获奖作者Bruce Tate在2007年发表的《编程语言的王道：Lisp之美》中这样说到：
“Lisp 长久以来一直被视为伟大的编程语言之一。其漫长的发展过程(接近五十年)中引发的追随狂潮表明：这是一门非同凡响的语言。在 MIT，Lisp 在所有程序员的课程中占了举足轻重的地位。像 Paul Graham 那样的企业家们将 Lisp 卓越的生产力用作他们事业成功起步的推动力。但令其追随者懊恼万分的是，Lisp 从未成为主流编程语言。作为一名 Java程序员，如果您花一点时间研究 Lisp 这座被人遗忘的黄金之城，就会发现许多能够改进编码方式的技术。”
技术门派之六：中型机守护者(Monks of the Midrange)
立派时间：1960
总舵所在地：Common 2009
掌门人：Frank Soltis博士
门派秘笈：IBM红皮书
镇派之宝：AS/400
就像比他们还要年长的兄弟对IBM大型机的崇拜一样，IBM中型机系统的守护者们每年也要聚集在一起庆祝IBM的 i、iSeries、i5/OS和AS/400。虽然这个集团的历史几乎可以追溯到真空管的时代，但它仍然拥有超过4000个成员，每年举行一次会议，为 Power Systems系列保持着火种。
【编者注：也许已经适应了互联网时代的IT用户已经对AS/400等中型机相当陌生，但AS/400绝对可以成为 跻身计算机发展史的一款经典产品。作为IBM的中小型商用计算机系统，AS/400自问世以来在全球的安装量已经超过60万套，行销150个国家，广泛应 用于流通、金融证券、制造、运输行业。《财富》杂志排名中，前100家大企业中有93家使用AS/400，前1000名企业中有850家选择AS /400。】
虽然信仰极为坚定，但中型机守护者也是愿意合作和思想灵活的，并愿意把新技术比如AIX和Linux纳入其古老的信仰中去。
技术门派之七：牛顿道(The Tao of Newton)
立派时间：1993
总舵所在地：全球牛顿会议
掌门人：John Sculley
门派秘笈：牛顿使用指南
门派宿敌：Steve Jobs(史蒂夫·乔布斯，苹果公司CEO)
一个已死的东西怎么可能复生?
想知道答案，可以去问一下Apple的MessagePad，也就是通常说的牛顿PDA的门徒。
1993年牛顿PDA以丰富的宣传带着夺目的光环亮相，并且迅速发展了一批支持者。但是后来发生了什么事?人们开始头疼牛顿PDA的笨重和昂贵，还有它的小故障，最著名的要数屡遭嘲讽的手写识别。他很快就被个头更小，更便宜的PalmPilot占据了市场。
1997年，在重返Apple几个月后，Steve Jobs(史蒂夫·乔布斯)终止了项目，而得到的是牛顿追随者们永久的敌意，他们在Jobs演说时高举手中的PDA。
跌了一跤，但没有被打败，牛顿的追随者继续开发软件作为开源项目。MessagePad的黑客们自行添加了对 MP3、Wi-Fi、GPS以及蓝牙的支持，名为爱因斯坦的项目为夏普Zaurus系列和诺基亚770等建立起仿真的牛顿系统，包括苹果的Mac和 Windows PC。每年，牛顿的门徒都要召开全球牛顿会议，讨论各种软硬件问题，并且推广牛顿平台。（来源：网界网）
订阅：
博文 (Atom)
