磁盘调度

磁盘调度（精选7篇）

磁盘调度篇1

磁盘调度实践报告

姓名：董宇超班级：计算机一班学号：0906010124

 实践内容  实践目的及意义  功能设计及数据结构  调试运行及测设分析  存在的问题及改进设想  实践体会  总结  参考文献

正文：

1.实践内容：

 假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。 磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。当有多个进程提出输入输出请求而处于等待状态时，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。为此设置“驱动调度”进程。

 由于磁盘与处理器是并行工作的，所以当磁盘在为一个进程服务时，占有处理器的其它进程可以提出使用磁盘（这里我们只要求访问磁道），即动态申请访问磁道，为此设置“接受请求”进程。

要求模拟电梯调度算法，对磁盘进行移臂操作，编程实现。

2.实践目的：

磁盘是高速、大容量、旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器，担负着繁重的输入输出工作，在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。

系统可采用一种策略，尽可能按最佳次序执行访问磁盘的请求。由于磁盘访问时间主要受寻道时间T的影响，为此需要采用合适的寻道算法，以降低寻道时间。

本实验要求模拟设计一个磁盘调度程序，观察调度程序的动态运行过程。通过实验理解和掌握磁盘调度的职能。

3.功能设计：

由于程序简单，没有设计结构体，只定义了一下变量：

int m=0;//记录磁道数目

int n;//接受输入的磁道号

int disk[1000];//保存磁道序列

int currenttrack;//当前磁道号

int t;

int i=0,j=0,k=0;//循环参数

int option;//记录寻到方向

int sum=0;//统计寻道长度

源代码: #include void main(){ int m=0;//记录磁道数目

int n;//接受输入的磁道号

int disk[1000];//保存磁道序列

int currenttrack;//当前磁道号

int t;int i=0,j=0,k=0;//循环参数

int option;//记录寻到方向

int sum=0;//统计寻道长度

printf(“请输入当前的磁道号:”);scanf(“%d”,¤ttrack);

printf(“n--------------------1.向磁道号增加的方向访问--------------------”);printf(“n--------------------2.向磁道号减少的方向访问--------------------”);printf(“n请选择的当前磁头移动方向(1/2):”);scanf(“%d”,&option);

printf(“n请输入磁道请求序列(0~999并以<-1>结束):n”);scanf(“%d”,&n);while(n!=-1){

disk[i]=n;

m++;i++;

scanf(“%d”,&n);}

/* 冒泡排序使磁道请求序列从小到大排序 */ for(j=0;j

for(i=0;i

{

if(disk[i]>disk[i+1])

{

t=disk[i];

disk[i]=disk[i+1];

disk[i+1]=t;

}

} }

/* 找到当前磁道号在磁道请求序列中的排序位置 */

k=0;for(i=0;i

k++;else

break;} printf(“n--------------电梯算法调度后的磁盘调度序列-------------n”);/* 第一种: 当前磁道号先向外再向里读 */ if(option==1){ for(i=k;i

printf(“%5d”,disk[i]);} for(i=k-1;i>=0;i--){

printf(“%5d”,disk[i]);} sum=2*(disk[m-1]-disk[k])+disk[k]-disk[0];printf(“n寻道长度为：%5d”,sum);} /* 第二种: 当前磁道号先向里再向外读 */ if(option==2){

for(i=k-1;i>=0;i--){

printf(“%d ”,disk[i]);

sum+=disk[i];}

for(i=k;i

printf(“%5d”,disk[i]);

sum+=disk[i];} sum=disk[m-1]-disk[k]+2*(disk[k]-disk[0]);printf(“n寻道长度为：%5d”,sum);

} printf(“n”);}

4.调试运行：

运行开始后出现如下界面，举例输入5：

然后出现：

1.先选择1（按按磁道号增加的方向寻道）：

接着输入磁道序列，若要结束输入，输入-1即可：

然后出现如下寻道结果：

2.再选择2（按按磁道号减少的方向寻道）：

接着输入磁道序列，若要结束输入，输入-1即可：

然后出现如下寻道结果：

5.存在的问题：

由于初次做操作系统模拟实验，所以程序设计中存在很多问题，例如：由于电梯算法是从当前的磁道号开始沿着预定的方向寻道，当本方向上的请求全部满足时，再反向寻道，但是程序模拟过程中，进程不能随着寻道的同时添加新的进程，使得电梯调度算法不能更好的体现。只能预先输入一串请求，然后只对这一段请求寻道。

改进之处：添加更高级的算法，使得请求能在寻道的同时加进来。

还有一些简单的已解决的问题，不一一列举了。

6.实践心得体会：

通过这次实践学会了不少内容，更深的理解了磁道调度的几种算法，而且学会了系统的编写程序。在编程过程中，需要查阅各种资料，并且学习前人的编写方法，找出优劣，然后形成自己的思想，最终完成程序的编写。

通过模拟磁盘调度的电梯调度算法，并比较与其他调度算法的不同，懂得了各种算法在不同情况下的作用。选择一个好的调度算法可以节约很多时间。

在模拟过程中出现过好多问题，有的解决了，有的还未解决，不管如何都是一种收获。

在最初的时候，由于程序编写隐藏的错误，编译没有发现，却执行不下去，然后改正错误，修复漏洞，最终满足实验要求。

7.总结：

为期一周的操作系统实践课结束了，编写了电梯调度算法的磁盘调度模拟程序。电梯调度寻道方式就像电梯运行一样，就是沿一个方向寻道，直到满足这一方向的所有请求，便反向寻道。在程序中添加了寻道长度的显示，以便将电梯调度的效率与其他磁盘调度算法比较。

8.参考文献：

1.操作系统教程（第4版）„„„„孙钟秀主编高等教育出版社；

磁盘调度篇2

随着数字多媒体技术的发展和普及,需要大量的多媒体服务器来支持实时多媒体流。一个实时多媒体流的编码比特率可以是固定的,也可以是可变的,如当今流行的视频点播、新闻点播等。为了避免内容传送的中断,即抖动,实时多媒体流磁盘请求必须在其截止时间前完成。一个多媒体服务器还将为如文字、图像等离散数据提供服务,这种离散数据没有实时性要求,称为非实时性磁盘请求。因此对于多媒体服务器来说,必须提出一个合理的实时磁盘调度策略,一方面要保证实时请求对于实时性的要求,另一方面也要为非实时磁盘请求提供合理的响应时间。

SCAN[1] 算法选择与当前磁头距离最短并且与磁头移动方向一致的任务作为下一个调度对象,已经被证明在减小磁盘寻道时间上是最优磁盘调度策略。但由于没有考虑实时磁盘请求,SCAN导致过多的截止时间被错过,不适合于实时多媒体服务器的磁盘调度算法。

EDF(Earliest Deadline First)[1]算法是一种基于任务截止时间的实时调度算法,在任务队列中具有最小截止时间的实时任务首先得到服务。这种算法能较好地满足任务的实时性,但它只考虑任务的截止时间因素而忽略了磁盘寻道时间,极大影响了系统的吞吐量。

许多实时磁盘调度算法如SCAN-EDF[1],SCAN-RT[2],DM-SCAN[3]都对SCAN算法进行改进,使其能够将实时性考虑在内。这些算法首先以EDF顺序来调度任务,对于截止时间相同的任务,如果不会引起错过其截止时间,则用SCAN算法来调度。最坏情况下,所有这些基于优先权的算法都将退化为EDF算法,并导致过多的磁盘寻道开销。由于这些算法都没有提供接纳控制来拒绝那些会错过其截止时刻的任务。结果导致不能保证处于服务中的流的质量。

由于多媒体服务器磁盘负载还包含了非实时任务请求,实时磁盘调度算法还必须让非时任务也具有合理的响应时间。一般的做法是每个磁盘周期都为非实时任务保留固定的权值。GSS(Group Sweeping Scheduling)[4]采用了分组策略的两级调度策略,对实时任务预留带宽。为了保证已经被接受的多媒体流的服务质量,QoS-Disk[5]引入了接纳控制机制来决定是否接受一个新到达的多媒体流。WRR-SCAN (Weighted-Round-Robin-SCAN)[6]算法对非实时任务采用固定预留带宽的方式。但是,当磁盘发生过载,或者实时任务和非实时任务请求比例突发变化时,磁盘性能将严重下降。

为此,提出了动态带宽分配扫描DBA-SCAN (Dynamic-Bandwidth-Assignment-SCAN ) 算法。该算法对非实时任务采用固定预留带宽的方式,并能够根据磁盘请求的负载变化动态调整磁盘带宽的分配比例,利用接纳控制拒绝一个不能在其截止时间前完成的请求,动态回收未用带宽来提高磁盘利用率。

1 DBA-SCAN磁盘调度框架

DBA-SCAN磁盘调度框架包括以下部分:质量协调部分,带宽预留计算部分,质量监测机制,接纳控制机制和动态带宽回收机制组成。一个磁盘作业由一个实时的连续多媒体任务或非周期任务发起。实时的连续多媒体任务是有时间限制,非周期任务没有时间限制,即非实时任务。实时磁盘调度策略不仅要考虑实时实时多媒体流请求,还要处理诸如图片、文字等离散的非实时磁盘请求。DBA-SCAN的总体运行框架如图1所示。

DBA-SCAN采用带宽预留机制,将可用的磁盘带宽预留给每个任务,预留的带宽是每个磁盘调度周期中,一个任务数据传送所需要的带宽,即一个磁盘调度周期中为其服务时的数据传输的最大时间。非实时任务则排成队列,由一个虚拟服务器服务,这个虚拟服务器也被预留了带宽。接纳控制决定是否接纳一个任务。质量协调器提供了自适应质量保证。核心调度器从每个队列中提取一轮作业,并将其排序成SCAN调度队列,同时完成动态回收未用带宽。实时任务分成保证性任务和可选性任务。保证性任务的请求必须要满足,可选性任务时在满足保证性任务后去满足的。

2 磁盘模型与任务模型

DBA-SCAN每次读或者写的最小单位为块,c表示块大小(单位:比特),V表示磁盘传输速率。磁头寻道时间为tseek(d) =a×d+tstart,其中,d表示磁头从一个磁道移动到另一个磁道所走过的磁道数,a是常数,表示磁头移动相邻两个磁道的时间,tstart为磁头启动时间。

实时磁盘调度策略的磁盘请求包括了周期性的实时请求和非周期到达的非实时请求。对于非实时请求来说,将其看成一个任务,由虚拟服务器来服务,每个磁盘调度周期都为其保留了一定的带宽。对于实时请求来说,每个磁盘调度周期都为每个实时请求预留固定的带宽。

实时请求 Ti可表示为 (Ai, Bi, Di),Ai表示到达时间,Bi表示请求磁盘块数,Di 表示截止时间。非实时请求Pi可表示为 (Ai, Bi)。

DBA-SCAN首先将磁盘带宽分成磁盘周期,磁盘周期划分如图2所示。

3 实时磁盘调度策略

一个磁盘周期的时间被分解为3个部分:磁盘寻道,磁盘旋转,磁盘数据传送。DBA-SCAN为每个任务分配一个权值来指示该任务在一个磁盘周期中所占有的最大传输时间。服务器在每个调度周期内轮流为每个任务服务。令L表示每个磁盘调度周期的时间,ts表示每个磁盘周期磁头寻道时间,tr 表示每个磁盘周期磁盘旋转时间,Wi表示实时任务Ti的权值,Wrt为所有实时任务权值之和,Wp表示非实时任务的权值,于是

对于非实时任务的权值Wp不是固定的,DBA-SCAN将利用负载监测机制来动态调整Wp的值。由于每个实时请求都带有固定的权值,通过调整权值,就能相应地控制QoS。

①权值的计算

对于实时任务Ti每个磁盘调度周期必须传输bi块数,Ti的权值是:

对于非实时任务每个磁盘调度周期保留磁盘块数ba,权值是:

没有非实时性任务时,DBA-SCAN将满足每个实时任务的截止时间。建立一个虚拟非实时服务器来为非实时任务服务。为其分配权值,为在每轮中保证其权值,为非实时任务提供小量数据传输率,以避免发生饥饿现象。非实时任务的权值越大,其作业的响应时间越短。

②接纳控制

DBA-SCAN提供了自适应质量保证,每个保证任务每一磁盘周期分配一个固定权值。剩余任务为可选任务。DBA-SCAN只有当其保证任务有足够带宽时才接纳可选任务。

当一个实时任务到达,利用公式 (1) 决定是否接纳该任务。对于tr 计算主要依赖文件系统如何组织数据块。当数据块在磁盘上随机存放时,一个磁盘周期所扫描的数据块可能不在同一个磁道上。每个磁盘周期传输的总数据块为:

其中,n为实时任务个数。最坏情况下所有数据块在不同磁道上,于是有:

其中,ta为磁盘旋转一圈与磁头启动之和。于是有:

为了完全利用带宽DBA-SCAN在磁盘周期前带宽分配,在磁盘周期后动态回收未用的带宽。前者通过每个调度周期尽可能调度更多的任务来降低磁盘开销,后者通过提前下一个磁盘周期的开始时间来动态回收未用带宽。

③负载监测机制

DBA-SCAN保证处于服务中的实时任务的质量。考虑最差情况下计算实时任务权值。然而,这些考虑也导致过多的磁盘调度时间保留,引起磁盘利用率的下降。

DBA-SCAN负载监测的方法是利用一个滑动窗口监测多媒体服务器磁盘负载的变化。自适应带宽分配调整的周期为滑动窗口大小ws。每隔ws时间进行一次带宽分配调整。监测的参数包括:实时请求的数目,非实时请求的数目,磁盘利用率。磁盘利用率定义为所有实时任务权值之和Wrt和非实时任务权值wp 与L的比值。多媒体服务器磁盘负载主要是实时多媒体请求,如果监测到实时请求和非实时请求变化较大,能够及时调整实时请求和非实时请求带宽分配。

为完全利用带宽,DBA-SCAN加入了动态调度策略,包括了磁盘周期前带宽分配和磁盘周期后带宽回收。前者通过每个磁盘周期尽可能调度更多的任务来降低磁盘开销,后者通过提前下一个磁盘周期的开始时间来动态回收未用带宽。

④带宽分配比例调整

磁盘工作是存在欠载和过载两种情况,需要针对不同情况来考虑如何调整带宽分配。

第一种,欠载情况。

欠载情况发生在为非实时任务保留带宽时,实时任务带宽是过载的,而实际磁盘是欠载的,即有剩余的磁盘带宽,还有实时请求得不到服务,降低了磁盘利用率。因此,DBA-SCAN利用监测参数来调整实时任务和非实时任务带宽的比例。此时,减小为非实时任务保留的带宽,尽量优先满足实时请求,因为非实时任务是欠载的。

由于权值W是按质量保证大小所预留的,因此实际应用中,一个流整个回放过程中,处于峰值的回放时间很短,又因为多个流的峰值出现在同一时间段内的概率较小。因此,当Wa调整为较小的值时,还有很大的概率利用动态回收的带宽来为非实时任务服务。DBA-SCAN对于Wa动态调整对非实时任务平均响应时间的影响不大。

第二种,过载情况。

采用磁盘利用率可以很好地表示各类应用请求所需的带宽,但是在过负的情况下,由于磁盘是饱和的,它的利用率是100%,因此不能反映出各类应用请求所需的带宽。在短暂过载的情况下,通常到达率高的请求应该分配高比例带宽。但是在过载的情况下,已经没有足够的带宽来满足实际请求的需要。在这种情况下,带宽调整主要任务是在服务器过载时反映出实时请求和非实时请求对带宽要求的相对差异,估计每类应用请求所需要的带宽。

所有实时任务权值之和为:

非实时任务分配的权值为:

其中,W’rt和W’p分别为监测到得实时任务和非实时任务实际需求带宽。

4 实验结果

模拟仿真实验的目的是研究新提出的DBA-SCAN算法的性能,为了对比,选用WRR-SCAN算法。固定任务总数,通过调整实时任务的百分比表示实时请求到达的频繁程度。而服务时间和磁道号随机生成。参考文献[6]设置模拟实验参数如表1所示。

图3显示不同实时任务请求率向对实时任务错过截止时间率的影响。DBA-SCAN调度算法性能要优于WRR-SCAN,主要原因是该算法利用接纳控制和动态回收未用带宽来提高它们的运行质量。一个在其截止时间以后完成的磁盘请求不仅降低了流的质量也浪费了宝贵的磁盘带宽。当服务器超载时,接受还是拒绝一个磁盘请求对于处于服务中的实时流以及非实时请求的服务质量都有很大影响。DBA-SCAN拒绝一个不能在其截止时间前完成的请求。这种接纳控制在处理频繁到达的实时流时是高效的。

5 结束语

一个实时磁盘调度算法对于多媒体服务器的性能来说是非常关键的因素。本文中提出了一个新的实时磁盘调度策略DBA-SCAN。与传统的磁盘调度算法以尽力的方式服务不同,DBA-SCAN为所有处于服务中的流提供质量保证,并限定了非实时作业的响应时间。

DBA-SCAN将磁盘服务时间分成轮次,并对服务请求一SCAN顺序进行服务。DBA-SCAN通过将一个磁盘作业分成保证作业和可选作业来提供质量保证。非实时任务和实时任务在每轮调度时都被分配一个固定的权值。为了使带宽浪费最小化,DBA-SCAN引入了积极的带宽回收策略来在运行中动态回收未用带宽。回收的带宽将被用于为可选任务提供更好的质量以及减小非实时请求的响应时间。另外,通过自适应质量保证,WRR-SCAN能够灵活的对服务中的流进行质量与数量的权衡。

通过模拟程序来对比DBA-SCAN与WRR-SCAN调度算法,通过实验结果可以看出, DBA-SCAN的性能明显好于WRR-SCAN算法,而非实时请求的响应时间也能得到一定的控制。

摘要：多媒体服务器需要一个实时磁盘调度算法为具有软实时要求的连续多媒体流服务。传统的磁盘调度算法不适应实时多媒体流。提出一个新的实时磁盘调度DBA-SCAN(Dynamic-Band-width-Assignment-SCAN)算法。DBA-SCAN算法通过带宽预留和接纳控制机制为处于服务中多媒体流提供质量保证。对于非实时任务也预留了带宽以保证非实时任务具有合理的响应时间。DBA-SCAN采用一种积极策略在运行时动态回收未用的带宽。被回收的带宽被用于为可选任务或者更多的非实时任务服务。通过模拟实验对DBA-SCAN算法和WRR-SCAN算法进行对比,实验结果显示,DBA-SCAN为实时多媒体流提供了更好的质量。

关键词：实时磁盘调度,接纳控制,动态带宽分配,负载监测,SCAN

参考文献

[1]Walid G Lbrahim Kamel,Shahram Ghandeharizadeh.Disk schedu-ling in video editing systems[J].IEEE Transactions on Knowledgeand Data Engineering,2001,13(6):933-950.

[2]Kanhere S S,Sethu H,Parekh A B.Fair and efficient packetscheduling using elastic round robin[J].IEEE Transactions on Par-allel and Distributed Systems,2002,13(3):324-336.

[3]Reddy A L N,Wyllie J,Wijayaratne K B R.Disk scheduling in amultimedia I/O system[J].ACMTransactions on Multimedia Com-puting,Communications and Applications,2005,1(1):37-59.

[4]Ketil Lund,Vera Goebel.Adaptive disk scheduling in a multimediaDBMS[C].Proceedings of the eleventh ACM international confer-ence on Multimedia,2003:65-74.

[5] Myung-Sub Lee, Kwang-Jung Kim, Chang-Hyeon Park. Real-time disk scheduling algorithms based on the two-way SCAN technique[C]. Proceedings of the 2009 International Conference on Scalable Computing and Communications; Eighth International Conference on Embedded Computing, 2009:137-142.

磁盘调度篇3

但实际上，实用这个功能后的效果却和他们的想法截然相反:磁盘压缩减少了用户的配额容量。启动这个功能也会让用户的磁盘空间超出配额的限制而导致可用空间缩小。

造成这种现象的原因是因为NTFS压缩文件和执行内部空间分配记录的方式导致的。最终的结果就是在“我的电脑”中显示的文件的大小要比被压缩的文件实际使用的空间大很多，但又比分配给用户的磁盘配额空间小很多。实际上，“文件尺寸”在Windows系统中可以指代很多不同的东西，而上述的三个概念在磁盘配额和文件压缩同时存在的时候就会产生一些冲突。

“文件尺寸”这个术语通常指代的是一个文件的实际大小，也就是在未压缩状态下的字节数。但是，由于操作系统是以簇为单位来分配存储空间的，所以就造成了“分配空间”(文件在磁盘上所占用的空间)这个概念的出现，

也就是说，“分配空间”在绝大多数情况下是要比文件的实际尺寸要大的。

你可以自己试验一下，随便找到一个文件，右件点击它然后选择属性，你就可以同时看到文件的实际大小和文件“所占用的大小”，这个就是“分配空间”了。

NTFS分区格式是以“分配空间”为单位来计算磁盘配额的，对于压缩过的文件也是如此，因为压缩过的文件必须经过解压缩才能够使用。

正是由于Windows NTFS并没有以簇为单位来压缩文件，所以才导致了冲突的产生。实际上，NTFS是按照16个簇为一个单位的形式进行压缩的，而计算文件占用空间的时候同样如此。这样下来，对于每个文件来说，就相当于平均浪费了额外的8个簇的空间。而一个典型用户帐号都会拥有成百上千的文件，这样浪费的空间还会增加。而一旦这些压缩的空间分配给了用户的配额，那么用户很可能发现从系统显示来看还有很多配额空间，但实际上配额空间已经不足了。

磁盘碎片技巧篇4

关闭其它正在运行的程序

当磁盘碎片整理程序在对磁盘进行碎片整理时，计算机可以执行其他任务，但此时计算机将运行得较慢，磁盘碎片整理程序也要花费更长的时间。在碎片整理过程中，每当其他程序写磁盘后磁盘碎片整理程序必须重新启动。为避免磁盘碎片整理程序重新启动太频繁，一定要在整理磁盘碎片时关闭其他程序。

在安全模式下进行碎片整理

由于在正常启动Windows时，系统会自动加载一些自动启动程序，而有时这些自动启动程序会对磁盘进行读写操作，从而影响磁盘碎片整理程序的运行。这时，你应该重新启动Windows，并在启动时按住Ctrl键不放，直到显示Windows的启动选单，选择Safe Mode启动方式，然后按下Enter键，则系统将以安全模式进入Windows，

在安全模式中，Windows使用默认设置，此时Windows将启动所需的最少设备驱动程序，不启动任何用户设定的自动启动程序。在这种十分“干净”的环境下运行磁盘碎片整理程序，则整理过程不受任何干扰。不过，在安全模式下，你将不能访问CD－ROM驱动器、打印机或其他设备。

禁止重新安排程序

默认情况下，磁盘碎片整理程序在整理磁盘时会重新安排最常用的程序文件，以便能快速启动它们。如果禁止磁盘碎片整理程序重新安排最常用的程序文件，则可加速磁盘整理的速度。步骤如下：

1．单击“开始”→“程序”→“附件”→“系统工具”，然后单击“磁盘碎片整理程序”，此时系统弹出“选择驱动器”对话框，你可以选择需要整理的磁盘。

如何隐藏磁盘驱动器篇5

，

另在[HKEY_LOCAL_MACHINE]-->[Software]-->[Microsoft]-->[Windows]-->[CurrentVersion]-->[Policies]-->[Explorer]-->增加一个 DWORD 值，[NoDrives]的数值数据请使用十进制及如下设定：隐藏 A 盘为[1]，隐藏 B 盘为 A 盘的一倍即[2]，隐藏 C 盘为 B 盘的一倍即[4]，如此类推，如全部隐藏则为[67108863]。

磁盘阵列上虚拟磁盘的管理篇6

近年来,随着人们探索未知世界能力的增强和Internet的发展,有越来越多的重要数据存放在各种介质上,如何保护、存储和管理这些信息资源,保证它们的安全,逐渐成为研究的热点[1]。

传统的数据管理方法是一个服务器管理一种或多种业务逻辑,其产生的数据就直接保存在服务器上。这种方法存在2个问题:其一是:如果2个服务器管理的业务有很大的相关性,部分数据必须保持一致才能正常工作。但2个服务器是分离的,要随时保持数据的一致是非常困难的;其二是:如果将相关的业务都集成在一个服务器上,又存在服务器的处理能力有限,容易形成系统瓶颈的问题。为了解决这个问题,必须设计一种具备不间断运行能力、可随时扩充的、易于管理的存储基础设施。传统的数据管理方法无法达到这个要求,于是提出了存储区域网络的概念。

简单来说存储区域网络[2]就是将数据存储从业务逻辑服务器中分离出来,一个或多个磁盘阵列相互连接形成存储网络,专门管理所有服务器产生的数据;服务器从数据管理中解放出来,专注于业务逻辑的处理[3,4]。这种方法有效地解决了共享数据过程中存在的一系列问题。

磁盘阵列[5]的存储空间很大。在使用磁盘阵列时有2种方法:

(1)将磁盘阵列分成一个个小的磁盘分别进行使用,这样用户看到的是多个固定容量的磁盘。这种方法更符合传统的磁盘管理理念。但是如何估计一个磁盘需要的空间大小,如何有效地划分磁盘是一个需要认真思考的问题。

(2)将整个磁盘阵列看作是一个或多个共享存储池。当用户需要存储空间时,就提出申请,共享存储池处理用户的申请,分配空间给用户。这种方法可以有效地利用磁盘阵列上所有的空间,提高资源利用率。

在此,针对第2种磁盘阵列的管理方法进行研究,分析共享存储池管理过程中可能遇到的问题,并提出解决方案。

1 传统的磁盘阵列的架构

如何增加磁盘的存取速度,如何防止数据因磁盘的故障而丢失及如何有效地利用磁盘空间,一直是困扰计算机专业人员的问题。磁盘阵列技术的产生一举解决了这些问题。

磁盘阵列并不是简单磁盘的集合,它通过使用RAID和热冗余技术,可提供高可靠性的存储服务[6,7]。在磁盘阵列内部,首先将多个物理磁盘组成RAID,此时的磁盘组已经具有较强的性能和较高的可靠性,此时的磁盘组被称为RANK;然后在RANK的基础上划分逻辑磁盘(logic disk),这时逻辑磁盘就具有了RAID的特性[8]。从连接到存储区域网的服务器来看,每一个磁盘阵列的逻辑磁盘(LD)相当于一个SCSI硬盘,如图1所示。

这种方法中,业务服务器的物理磁盘与磁盘阵列的逻辑磁盘是一一对应的,且容量固定,磁盘之间空间是不能共享的。每个业务逻辑分别向各自的磁盘写入数据,存在有的磁盘已经写满数据,空间不够用,而有的磁盘还剩余大量空间的情况,不能有效地利用磁盘空间资源。

2 共享存储池

共享存储池是磁盘阵列的多个物理磁盘先使用RAID和热冗余技术形成RANK,然后以此为基础形成共享存储池[9,10]。根据需要一个磁盘阵列可以有一个或多个共享存储池。每个共享存储池有一个存储控制器,它负责管理各个虚拟磁盘的I/O请求。

业务服务器需要磁盘空间时向共享存储池提出申请,通过存储控制器为它分配空间形成虚拟磁盘。在进行读写操作时,虚拟磁盘将读写请求发送给存储控制器,转化为真正的I/O操作,实现读写功能。

图2是一个共享存储池的示意图。图中有3个虚拟磁盘,用于存储控制器管理所有对共享存储池的访问请求,它为每个虚拟磁盘维护一个请求队列。而后,根据调度算法从某个虚拟磁盘的请求队列中选择一个或多个访问请求发送给存储池。在这一过程中,存储控制器可能延迟部分访问请求,或者重新排列它们的执行顺序。

3 存储控制器调度算法

存储控制器接受用户的I/O请求,并将请求发送到磁盘阵列执行。但是存储控制器并不完全知道磁盘阵列内部的实现机制,而且不同磁盘阵列对同样的操作实现方法也不相同。因此存储控制器的调度算法必须是通用的,不包含存储池内部结构的任何知识。

存储控制器调度算法必须满足如下要求:

(1)独立性。存储控制器同时管理多个虚拟磁盘,有多个请求队列,必须保持各个不同虚拟磁盘访问相互独立,互不影响。

(2)顺序性。同一虚拟磁盘的请求队列中有多个I/O请求,它们往往是有一定顺序的,按不同的顺序执行可能会得到不同的结果。另一方面,不同虚拟磁盘请求之间是相互独立的,不必严格按照请求到达的时间按顺序执行。

(3)实时性。虚拟磁盘的I/O请求在真正写入共享存储池时,可以有一定的延迟,但不能影响用户的使用。必须让用户感觉像使用普通的物理硬盘一样方便,快捷。

(4)并发性。共享存储池是以磁盘阵列上的RANK为基础的,RANK是多个物理磁盘使用RAID和热冗余技术构建的。因此不同意普通的物理硬盘,它同时可以并发地执行多个I/O请求。

存储控制器对多个虚拟磁盘请求队列的调度方式如图3所示。

先对以下的讨论可能用到的变量加以说明。假定系统中有N个虚拟磁盘。每个虚拟磁盘VDi建立一个请求队列Qi,Wi为Qi中请求的数量,Ei为访问队列中虚拟磁盘VDi的请求数量。共享存储池一次最多可以同时执行K个请求,即访问队列中最多有K个请求。某一时刻访问队列Qe中有Ea个访问请求。

如果Ea等于K,执行队列已满,各请求队列处于等待状态;如果Ea小于K,并且在虚拟磁盘的请求队列中有访问请求,就从虚拟磁盘请求队列中选择K-Ea个请求加入访问队列。

选择加入访问队列的请求时,按以下原则遍历各个虚拟磁盘请求队列Qi。

(1)对于请求队列Qi,如果Ei=0,选择Qi中的第1个请求加入访问队列。

(2)对于请求队列Qi,如果Wi大于K,将Qi中的第1个请求加入访问队列。

(3)对于虚拟磁盘VDi,如果Ei小于K/N,将Qi中的第1个请求加入访问队列。

(4)如果遍历到虚拟磁盘VDi时,访问队列已满,记录i值,下一次遍历时,从这个虚拟磁盘的请求队列开始遍历。

原则1,保证每个虚拟磁盘的请求都能得到响应;原则2,保证队列长的虚拟磁盘得到更多的执行机会;原则3,保证各个等待队列都能得到一定的执行机会,避免I/O操作频繁的队列独占执行权;原则4,使各个队列处于平等的地位,以防止部分虚拟磁盘占有过多的执行时间。

4 结语

在此分析了传统磁盘阵列管理中存在的问题以此为基础,设计了一个共享存储池调度算法。在该算法中,存储控制器管理请求队列,仅仅起一个排队的工作,执行的任务并不是很多,不会形成系统瓶颈。该系统可能存在的问题在于:如果虚拟磁盘的数量很多,且同时执行多I/O请求的操作,队列中请求的数量很多,但是共享存储池的处理能力有限,不能满足要求。解决方法是控制一个共享存储池管理的虚拟磁盘数量。如果虚拟磁盘数量太多,就在磁盘阵列上增加新的共享存储池或将已存在的共享存储池一分为二,以提高性能。作者根据以上请求调度算法,实现了一个共享存储池模拟系统。结果显示,各虚拟磁盘的I/O请求可以得到很好的响应,且达到预期的效果。

参考文献

[1]MORRIS R J T,TRUSKOWSKI B J.The evolution of storage systems[J].IBM Systems Journal,2003,42(2): 205-217.

[2]彭英,刘霖,赵跃龙.基于SAN的网络存储共享系统[J].现代电子技术,2007,30(20):97-101.

[3]LALA T K.Storage area networking[J].IEEE Communications Magazine,2003,41(8):70-71.

[4]TELIKEPALLI R,DRWIEGA T,YAN J,et al.Storage area network extension solutions and their performance assessment [J].IEEE Communications Magazine,2004,42 (4):56-63.

[5]江红锋,王福源,孙江锋.基于光纤接口磁盘阵列的研[J].现代电子技术,2009,32(9):97-99.

[6]YU X,GUM B,CHEN Y.Trading capacity for performance in a disk array[C]//Proceedings of the 4th International Symposium on Operating Systems Design and Implementation. San Diego,California:USENIX Association, 2000:243-258.

[7]VARKI E,MERCHANT A,XU J,et al.Issues and challenges in the performance analysis of real disk arrays[J]. IEEE Transactions on Parallel and Distributed Systems, 2004,15(6):559-574.

[8]付长冬,舒继武.基于自主运算的自适应的SAN存储管理系统[J].软件学报,2004,15(7):1056-1063.

[9]THERESKA E,SCHINDLER J,BUCY J,et al.A framework for building unobtrusive disk maintenance applications [C]//Proceedings of the 3rd International Conference on File and Storage Technologies.San Francisco,CA,USA: USENIX Association,2004:213-226.

关于磁盘IO的总结篇7

1.IO读写：磁盘是用来存取数据的。磁盘的存数据对应IO的写操作，磁盘的取数据对应IO的读操作。

2.随机访问(Random Access)与连续访问(Sequential Access)：

随机访问指的是本次IO所给出的扇区地址和上次IO给出扇区地址相差比较大，这样的话磁头在两次IO操作之间需要做比较大的移动动作才能重新开始读/写数据。

同理，连续访问就是两次给出的扇区地址相近，磁头就能很快的进行操作，这样的多个IO操作就是连续访问。

3.顺序IO模式(Queue Mode)/并发IO模式(BurstMode)：

原理：磁盘控制器可能会一次对磁盘组发出一连串的IO命令，如果磁盘组一次只能执行一个IO命令时称为顺序IO；当磁盘组能同时执行多个IO命令时，称为并发IO。

并发IO只能发生在由多个磁盘组成的磁盘组上，单块磁盘只能一次处理一个IO命令。

4.IOPS，IO系统每秒所执行IO操作的次数

5.一次完整的磁盘IO操作：

当控制器对磁盘发出一个IO操作命令的时候，磁盘的驱动臂(ActuatorArm)带读写磁头(Head)离开着陆区(LandingZone，位于内圈没有数据的区域)，移动到要操作的初始数据块所在的磁道(Track)的正上方，这个过程被称为寻址(Seeking)，对应消耗的时间被称为寻址时间(SeekTime)；但是找到对应磁道还不能马上读取数据，这时候磁头要等到磁盘盘片(Platter)旋转到初始数据块所在的扇区(Sector)落在读写磁头正上方的之后才能开始读取数据，在这个等待盘片旋转到可操作扇区的过程中消耗的时间称为旋转延时(RotationalDelay)；接下来就随着盘片的旋转，磁头不断的读/写相应的数据块，直到完成这次IO所需要操作的全部数据，这个过程称为数据传送(DataTransfer)，对应的时间称为传送时间(TransferTime)。完成这三个步骤之后一次IO操作也就完成了。

6.传输速度(Transfer Rate)/吞吐率(Throughput)：是磁盘在实际使用的时候从磁盘系统总线上流过的数据量。

7.IO响应时间也被称为IO延时(IOLatency)，IO响应时间就是从操作系统内核发出的一个读或者写的IO命令到操作系统内核接收到IO回应的时间，注意不要和单个IO时间混淆了，单个IO时间仅仅指的是IO操作在磁盘内部处理的时间，而IO响应时间还要包括IO操作在IO等待队列中所花费的等待时间。

8.dd命令 dd：硬拷贝命令（直接在硬盘上进行数据拷贝，没有经过内存，二进制之间的协调复制）

bs=BYTES：一次读取和写入的字节数（单元大小）

count=BLOCKS：单元数量

if=FILE:源文件

of=FILE:目标文件

测试磁盘的写入：

[root@localhost ~]# /usr/bin/time dd if=/dev/zero of=/tmp/hx bs=4k count=10240 10240+0 records in 10240+0 records out 41943040 bytes(42 MB)copied, 0.0577 s, 727 MB/s 0.00user 0.05system 0:00.05elapsed 96%CPU(0avgtext+0avgdata 832maxresident)k 0inputs+81920outputs(0major+241minor)pagefaults 0swaps

测试磁盘的读取：

[root@localhost ~]# /usr/bin/time dd if=/tmp/hx of=/dev/null bs=4k 10240+0 records in 10240+0 records out 41943040 bytes(42 MB)copied, 0.014955 s, 2.8 GB/s 0.00user 0.01system 0:00.01elapsed 86%CPU(0avgtext+0avgdata 828maxresident)k 0inputs+0outputs(0major+240minor)pagefaults 0swaps

读写同时测试

[root@localhost ~]# /usr/bin/time dd if=/tmp/foo of=/tmp/foo2 bs=4k 10240+0 records in 10240+0 records out 41943040 bytes(42 MB)copied, 0.0742246 s, 565 MB/s 0.00user 0.08system 0:00.08elapsed 97%CPU(0avgtext+0avgdata 828maxresident)k 0inputs+81952outputs(0major+240minor)pagefaults 0swaps 9.[root@localhost ~]# iostat-x Linux 2.6.32-573.el6.x86_64(localhost.localdomain)03/16/2016 _x86_64_(12 CPU)

avg-cpu: %user

%nice %system %iowait %steal

%idle

0.09

0.00

0.06

0.02

0.00

99.82

Device:

rrqm/s

wrqm/s

r/s

w/s

rsec/s

wsec/s avgrq-sz avgqu-sz

await svctm %util sda

8.30

68.47

7.61

2.27

363.21

565.82

94.05

0.05

5.32

0.40

0.39 各个性能指标的简单说明。rrqm/s 每秒进行merge的读操作数目。wrqm/s 每秒进行merge的写操作数目。r/s 每秒完成的读I/O设备次数。w/s 每秒完成的写I/O设备次数。rsec/s 每秒读扇区数。wsec/s 每秒写扇区数。rkB/s 每秒读K字节数。wkB/s 每秒写K字节数。avgrq-sz平均每次设备I/O操作的数据大小(扇区)。avgqu-sz平均I/O队列长度。await平均每次设备I/O操作的等待时间(毫秒)。svctm平均每次设备I/O操作的服务时间(毫秒)。%util 一秒中有百分之多少的时间用于I/O操作，或者说一秒中有多少时间I/O队列是非空的。

平均单次IO大小(IO Chunk Size)<=>avgrq-sz

平均IO响应时间(IO Response Time)<=>await

IOPS(IO per Second)<=> r/s + w/s

吞吐率(Throughtput)<=> rkB/s + wkB/s

10.fio是一个非常灵活的io测试工具，他可以通过多线程或进程模拟各种io操作。

fio分顺序读，随机读，顺序写，随机写，混合随机读写模式。参数：

filename: 指定文件(设备)的名称。可以通过冒号分割同时指定多个文件，如filename=/dev/sda:/dev/sdb。

directory: 设置filename的路径前缀。在后面的基准测试中，采用这种方式来指定设备。

name: 指定job的名字，在命令行中表示新启动一个job。

direct: bool类型，如果设置成true(1)，表示不使用io buffer。

ioengine: I/O引擎，现在fio支持19种ioengine。默认值是sync同步阻塞I/O，libaio是Linux的native异步I/O。

iodepth: 如果ioengine采用异步方式，该参数表示一批提交保持的io单元数。

rw: I/O模式，随机读写，顺序读写等等。

bs: I/O block大小，默认是4k。

size: 指定job处理的文件的大小。

numjobs: 指定job的克隆数(线程)。

time_based: 如果在runtime指定的时间还没到时文件就被读写完成，将继续重复知道runtime时间结束。

runtime: 指定在多少秒后停止进程。如果未指定该参数，fio将执行至指定的文件读写完全完成。

group_reporting: 当同时指定了numjobs了时，输出结果按组显示。

例： #顺序读

fio-filename=/dev/sda-direct=1-iodepth 1-thread-rw=read-ioengine=psync-bs=16k-size=200G-numjobs=30-runtime=1000-group_reporting-name=mytest

#顺序写

fio-filename=/dev/sda-direct=1-iodepth 1-thread-rw=write-ioengine=psync-bs=16k-size=200G-numjobs=30-runtime=1000-group_reporting-name=mytest

#随机读

fio-filename=/dev/sda-direct=1-iodepth 1-thread-rw=randread-ioengine=psync-bs=16k-size=200G-numjobs=30-runtime=1000-group_reporting-name=mytest #随机写

fio-filename=/dev/sda-direct=1-iodepth 1-thread-rw=randwrite-ioengine=psync-bs=16k-size=200G-numjobs=30-runtime=1000-group_reporting-name=mytest

#混合随机读写

fio-filename=/dev/sda-direct=1-iodepth 1-thread-rw=randrw-rwmixread=70-ioengine=psync-bs=16k-size=200G-numjobs=30-runtime=100-group_reporting-name=mytest-ioscheduler=noop

补充：

上次测试的三块固态硬盘IO:

0.55到2K的小文件

[root@localhost 1]# fio-filename=/data/B/1/2-direct=1-iodepth 1-thread-rw=randrw-rwmixread=80-ioengine=psync-bsrange=512-2048-size=4G-numjobs=5-group_reporting-name=test-runtime=1200 test:(g=0): rw=randrw, bs=512-2K/512-2K, ioengine=psync, iodepth=1...test:(g=0): rw=randrw, bs=512-2K/512-2K, ioengine=psync, iodepth=1 fio 2.0.7 Starting 5 threads test: Laying out IO file(s)(1 file(s)/ 4096MB)Jobs: 5(f=5): [mmmmm] [100.0% done] [8319K/2060K /s] [9870 /2498 iops] [eta 00m:00s] test:(groupid=0, jobs=5): err= 0: pid=29601

read : io=11152MB, bw=9515.1KB/s, iops=9183 , runt=1200079msec

clat(usec): min=0 , max=1000.3K, avg=468.07, stdev=1981.20

lat(usec): min=0 , max=1000.3K, avg=468.42, stdev=1981.20

clat percentiles(usec):

| 1.00th=[ 189], 5.00th=[ 211], 10.00th=[ 225], 20.00th=[ 249]，| 30.00th=[ 274], 40.00th=[ 294], 50.00th=[ 318], 60.00th=[ 350]，| 70.00th=[ 382], 80.00th=[ 430], 90.00th=[ 516], 95.00th=[ 596]，| 99.00th=[ 844], 99.50th=[ 5088], 99.90th=[32128], 99.95th=[42240]，| 99.99th=[58624]

bw(KB/s): min= 159, max= 6607, per=20.03%, avg=1905.53, stdev=328.56

write: io=2789.3MB, bw=2379.2KB/s, iops=2297 , runt=1200079msec

clat(usec): min=0 , max=1000.2K, avg=283.77, stdev=1432.42

lat(usec): min=0 , max=1000.2K, avg=284.21, stdev=1432.42

clat percentiles(usec):

| 1.00th=[

89], 5.00th=[ 110], 10.00th=[ 137], 20.00th=[ 153]，| 30.00th=[ 165], 40.00th=[ 175], 50.00th=[ 189], 60.00th=[ 207]，| 70.00th=[ 239], 80.00th=[ 302], 90.00th=[ 386], 95.00th=[ 458]，| 99.00th=[ 660], 99.50th=[ 1976], 99.90th=[20352], 99.95th=[27520]，| 99.99th=[43264]

bw(KB/s): min=

60, max= 1769, per=20.03%, avg=476.50, stdev=87.73

lat(usec): 2=0.08%, 100=0.51%, 250=29.98%, 500=59.64%, 750=8.40%

lat(usec): 1000=0.63%

lat(msec): 2=0.10%, 4=0.11%, 10=0.19%, 20=0.08%, 50=0.23%

lat(msec): 100=0.03%, 250=0.01%, 500=0.01%, 1000=0.01%, 2000=0.01%

cpu

: usr=6.13%, sys=37.70%, ctx=101478124, majf=0, minf=24056

IO depths

: 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%

submit

: 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%

complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%

issued

: total=r=11021114/w=2757348/d=0, short=r=0/w=0/d=0

Run status group 0(all jobs):

READ: io=11152MB, aggrb=9515KB/s, minb=9515KB/s, maxb=9515KB/s, mint=1200079msec, maxt=1200079msec

WRITE: io=2789.3MB, aggrb=2379KB/s, minb=2379KB/s, maxb=2379KB/s, mint=1200079msec, maxt=1200079msec

Disk stats(read/write):

sda: ios=11020977/2758079, merge=0/69, ticks=4004421/515149, in_queue=4514919, util=98.00%

10M的大文件

[root@localhost 1]# fio-filename=/data/B/1/10-direct=1-iodepth 1-thread-rw=randrw-rwmixread=80-ioengine=psync-bs=10M-size=10G-numjobs=10

-group_reporting-name=test-runtime=1800 test:(g=0): rw=randrw, bs=10M-10M/10M-10M, ioengine=psync, iodepth=1...test:(g=0): rw=randrw, bs=10M-10M/10M-10M, ioengine=psync, iodepth=1 fio 2.0.7 Starting 10 threads test: Laying out IO file(s)(1 file(s)/ 10240MB)Jobs: 4(f=4): [_m___mm_m_] [99.0% done] [220.2M/104.9M /s] [21 /10 iops] [eta 00m:03s]]

test:(groupid=0, jobs=10): err= 0: pid=29618

read : io=81910MB, bw=270613KB/s, iops=26 , runt=309948msec

clat(msec): min=15 , max=1006 , avg=334.89, stdev=102.97

lat(msec): min=15 , max=1006 , avg=334.89, stdev=102.97

clat percentiles(msec):

| 1.00th=[ 123], 5.00th=[ 157], 10.00th=[ 200], 20.00th=[ 249]，| 30.00th=[ 289], 40.00th=[ 318], 50.00th=[ 343], 60.00th=[ 363]，| 70.00th=[ 383], 80.00th=[ 412], 90.00th=[ 449], 95.00th=[ 482]，| 99.00th=[ 578], 99.50th=[ 766], 99.90th=[ 963], 99.95th=[ 979]，| 99.99th=[ 1004]

bw(KB/s): min= 7076, max=64912, per=10.25%, avg=27750.67, stdev=7359.31

write: io=20490MB, bw=67694KB/s, iops=6 , runt=309948msec

clat(msec): min=24 , max=752 , avg=161.82, stdev=105.86

lat(msec): min=25 , max=753 , avg=162.61, stdev=105.84

clat percentiles(msec):

| 1.00th=[

27], 5.00th=[

33], 10.00th=[

34], 20.00th=[

51]，| 30.00th=[

54], 40.00th=[ 103], 50.00th=[ 178], 60.00th=[ 206]，| 70.00th=[ 233], 80.00th=[ 260], 90.00th=[ 297], 95.00th=[ 326]，| 99.00th=[ 392], 99.50th=[ 416], 99.90th=[ 644], 99.95th=[ 725]，| 99.99th=[ 750]

bw(KB/s): min= 7398, max=82447, per=29.87%, avg=20218.16, stdev=9671.17

lat(msec): 20=0.01%, 50=3.69%, 100=4.55%, 250=23.75%, 500=65.39%

lat(msec): 750=2.18%, 1000=0.42%, 2000=0.01%

cpu