CN103294548A - 一种基于分布式文件系统的io请求调度方法和系统 - Google Patents

Abstract

本发明公开了一种基于分布式文件系统的IO请求调度方法，包括：接收来自客户端的IO请求，并根据IO请求更新全局进程表，将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾,持续监听来自于客户端的IO请求，并重复以上步骤，以生成动态的多级进程请求队列,提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数。本发明的方法能够在系统负载较大时极大程度上减少客户端请求的整体响应时间，提高系统的性能。

Description

一种基于分布式文件系统的IO请求调度方法和系统

技术领域

本发明属于计算机存储技术领域，更具体地，涉及一种基于分布式文件系统的IO请求调度方法和系统。

背景技术

随着分布式计算机集群的发展，大规模数据密集型的高性能计算都依赖于分布式并行文件系统，例如Lustre，GPFS，PVFS，pNFS等。然而，随着硬件的发展，CPU速度和IO设备速度的不匹配的矛盾越来越突出，IO瓶颈成为了限制计算机集群高性能的一个重要因素，对于有密集型数据I/O需求的应用程序而言，这种瓶颈更为突出。

并行I/O是指多个计算机节点同时对共享文件或者不同磁盘上的文件进行并行的I/O访问，主要是使用一组存储设备来存储海量数据，并提供相应的并行I/O接口来访问。并行I/O研究包括海量数据文件的分组和分割、数据的分布方式、文件的调度访问、数据块接口、缓存和预取策略、通信等方面。

实现并行I/O的一个不可或缺的手段是分布式并行文件系统。在分布式文件系统中，海量的数据文件一般是以条带化的形式分布在多个I/O节点之上，这样提高了IO聚合带宽，减少了文件I/O的响应时间，极大的缓解了I/O瓶颈。然而在大规模集群环境下，client节点数量成千上万，I/O并发度非常高，由于磁盘I/O处理速度的限制，此时的网络I/O请求队列中等待的I/O请求的长度将会非常大，这些请求按何种方式来进行调度执行对系统I/O性能以及应用的响应时间的影响是非常大的。另外，由于不同的访问需求，导致系统存在大量不同I/O特性的请求，例如可能存在小文件和大文件的混合读写请求，这些都会对系统性能造成影响。

在实际的分布式文件系统中，多采用数据和元数据分离的方法，将元数据路径和数据路径分离开，极大地提高了系统性能。然而，现有的分布式文件系统多采用单一的元数据服务器，导致在大量客户端并发访问的情况下成为系统的瓶颈。

因此，无论在元数据服务器端还是数据服务器端，均需要一个良好性能的I/O请求调度策略，以实现系统I/O性能的最大化。而现有的很多分布式文件系统对于客户端的请求仍然是传统的FCFS服务或者一些简单的改进，没有对请求做更进一步的分析，通过分析结果来进行调度。现有的研究在基于分布式文件系统上改进的算法有很多，例如在PVFS上，RobertB.Ross等设计了一种服务器端的调度机制，他通过对给定的工作流进行预测分析，动态的选择最合适的调度算法来优化性能，这种算法对于特定的工作流有很好的效果但是对于无法预测的工作流并不通用。Adrien Lebre等在SJF（最小任务优先）算法的基础上提出了一种weighted SJF（WSJF）算法，通过对虚拟请求时间的计算给出个一动态的权重，来解决SJF的请求饥饿问题。除此之外，还给出一种面向应用集群环境的并行I/O调度算法，它通过聚集来自同一应用的I/O请求来提高I/O吞吐量，同时通过一种改进的MLF算法来保证不同应用对存储设备访问的公平性。国防科技大学提出了一种基于Lustre的网络请求调度器框架NRS，基于对象的轮转调度算法OBRR，将同一对象的I/.O请求按偏移量排队执行，每一个数据对象有读写两个请求队列，每次循环中，当一个I/O队列被选中后，提供固定配额（quantum）的I/O服务，同时，对请求设置了动态的deadline解决请求的饥饿问题，保证了服务质量。这些算法一般都是针对提高IO吞吐量来做的设计，均没有针对客户端应用的平均IO等待时间做考虑。

总的来说，传统的分布式文件系统中的请求调度一层都是采用的简单的策略，比如FCFS，现有的研究提出了一些新的调度方式，比如SJF，WSJF，MLF等，但是这些调度方式都是以IO请求为单位做调度，均未考虑请求所属的客户端进程，对于有多个同步IO请求的客户端进程而言，很难减小其平均等待时间，提高系统性能。

发明内容

针对现有技术的以上缺陷或改进需求，本发明提供了一种基于分布式文件系统的IO请求调度方法，其目的在于，通过在通信层上创建多级进程请求队列来管理通信层收到的远程请求，并区分不同的客户端进程提交的请求以及请求的时间间隔来动态调整请求的处理顺序，从而能够在系统负载较大时极大程度上减少客户端请求的整体响应时间，提高系统的性能；通过设定最大截止时间间隔T_DEADLINE来保证优先级靠后的IO请求得以执行，解决了饥饿的问题；此外，自适应的参数更新机制也保证了该调度方法能够适应不同的网络环境和应用场景。

为实现上述目的，按照本发明的一个方面，提供了一种基于分布式文件系统的IO请求调度方法，包括以下步骤：

（1）接收来自客户端的IO请求，并根据IO请求更新全局进程表；本步骤具体包括以下子步骤：

（1-1）接收来自客户端的IO请求；

（1-2）查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入步骤（1-3），如果存在则转入步骤（1-4）；

（1-3）将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（2）；

（1-4）判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入步骤（1-5），否则转入步骤（1-6）；

（1-5）更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（2）；

（1-6）重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾；

（2）将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入步骤（3），否则转入步骤（4）；

（3）从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

（4）持续监听来自于客户端的IO请求，并重复以上步骤（1）至（3），以生成动态的多级进程请求队列；

（5）提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；本步骤具体包括以下子步骤：

（5-1）判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转（5-4）；若不存在，则转（5-2）；

（5-2）判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

（5-3）判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转（5-4），否则转（5-5）；

（5-4）处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转（5-6）；

（5-5）判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入步骤（5-6）；若不成立，将该进程对象删除，然后进入步骤（5-6）；

（5-6）更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长 $\mathrm{Length}=\underset{i=1}{\overset{N}{\mathrm{\&Sigma;}}}\mathrm{length}\left(i\right);$

（5-7）判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

（5-8）更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2；

（5-9）重复上述（5-1）到（5-8），直到处理完所有多级进程请求队列中的进程对象为止。

优选地，本发明的方法还包括步骤：在步骤（1）之前，初始化服务器的全局进程表和多级进程请求队列及其参数。

优选地，初始化服务器的全局进程表和多级进程请求队列及其参数的步骤具体包括以下子步骤：

初始化全局进程表为空，其包括多个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}；

初始化多级进程请求队列，队列的元素为全局进程对象；

初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数。

优选地，全局进程对象唯一标识任一客户端上的一个进程。

按照本发明的另一方面，提供了一种基于分布式文件系统的IO请求调度系统，包括：

第二模块，用于接收来自客户端的IO请求，并根据IO请求更新全局进程表；本模块具体包括以下子模块：

第四子模块，用于接收来自客户端的IO请求，该IO请求在发送到服务器之前是被客户端进行过封装，即在原始的IO请求的数据包头封装上客户端的IP地址和进程PID号作为进程标识，以标识该IO请求所属的全局进程对象；

第五子模块，用于查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入第六子模块，如果存在则转入第七子模块；

第六子模块，用于将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，其中T_当前时间表示当前时间，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（3）；

第七子模块，用于判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入第八子模块，否则转入第九子模块；

第八子模块，用于更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最 短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（3）；

第九子模块，用于重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0。将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾；

第三模块，用于将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入第四模块，否则转入第五模块；

第四模块，用于降低该全局进程对象的优先级，即从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

第五模块，用于持续监听来自于客户端的IO请求，并重复以上第二模块至第四模块，以生成动态的多级进程请求队列；

第六模块，用于提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；本模块具体包括以下子模块：

第十子模块，用于判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转第十三子模块；若不存在，则转第十一子模块；

第十一子模块，用于判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

第十二子模块，用于判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转第十三子模块，否则转第十四子模块；

第十三子模块，用于处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转第十五子模块；

第十四子模块，用于判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入第十五子模块；若不成立，将该进程对象删除，然后进入第十五子模块；

第十五子模块，用于更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长

第十六子模块，用于判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

第十七子模块，用于更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2；

第十八子模块，用于重复上述第十子模块至第十七子模块，直到处理完所有多级进程请求队列中的进程对象为止。

优选地，本发明的系统还包括第一模块，用于初始化服务器的全局进程表和多级进程请求队列及其参数。

优选地，第一模块包括：

第一子模块，用于初始化全局进程表为空，其中有五个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}。全局进程ID表示客户端进程的标识符，其是由IP：PID的形式进行表示，IP表示客户端的IP地址，PID表示客户端的进程标识号，后四项则是进程的状态信息,其中连续IO请求长度表示一段时间内进程持续的IO请求大小的总和，其单位是字节（Byte），队列L表示该进程当前所在的多级进程请求队列，T_{最 近时间}表示该进程的最近一次请求的完成时间，T_{最短间隔时间}表示两次请求到达的最短间隔时间。

第二子模块，用于初始化多级进程请求队列，队列的元素为全局进程对象，并用结构体来表示，每一个全局进程对象都有自己的IO请求队列，如图4所示，其中app1、app2等表示进程对象结构体，req表示属于该进程对象的IO请求，S1、S2、S3分别表示第一级进程请求队列、第二级进程请求队列和第三级进程请求队列；

第三子模块，用于初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数，阈值T_INTERVAL的初始值为1秒，最大截止时间T_DEADLINE为2秒。

总体而言，通过本发明所构思的以上技术方案与现有技术相比，能够取得下列有益效果：

1、将客户端进程作为服务器IO调度的对象：由于采用了步骤（1）和步骤（2），把每个IO请求所属的进程作为队列中的元素，并保存了该进程对象的一些状态信息，通过把同步IO请求较多，IO请求较大的进程对象的优先级降低，减小了同步IO请求较小的进程的两次IO时间的间隔，从而降低了进程整体的响应时间。

2、解决了饥饿的问题：由于采用了步骤（5-1），每次从队列中提取进程对象处理时都检测是否有超时的进程对象。这样就防止了某些进程长时间得不到执行。

3、动态的参数更新机制：由于采用了步骤（5-6）到（5-8），REQ_MAX(i)和T_INTERVAL是根据进程对象的状态信息来更新，这样就适应了不同的网络环境，因为不同的网络环境中网络延时有所差异。

4、时间效率较高：由于采用了步骤（5），请求入队过程和处理线程不需要每次都遍历整个队列，处理线程仅仅只在提取首个进程对象时更新进程对象的状态信息和队列的参数即可。

附图说明

图1是本发明基于分布式文件系统的IO请求调度方法的流程图。

图2是本发明方法中步骤（2）的细化流程图。

图3是本发明方法中步骤（6）的细化流程图。

图4是本发明方法中请求处理队列的框架示意图。

具体实施方式

为了使本发明的目的、技术方案及优点更加清楚明白，以下结合附图及实施例，对本发明进行进一步详细说明。应当理解，此处所描述的具体实施例仅仅用以解释本发明，并不用于限定本发明。此外，下面所描述的本发明各个实施方式中所涉及到的技术特征只要彼此之间未构成冲突就可以相互组合。

如图1所示，本发明基于分布式文件系统的IO请求调度方法包括以下步骤：

（1）初始化服务器的全局进程表和多级进程请求队列及其参数，具体包括以下子步骤：

（1-1）初始化全局进程表为空，如下表表1所示。其中有五个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}。全局进程ID表示客户端进程的标识符，其是由IP：PID的形式进行表示，IP表示客户端的IP地址，PID表示客户端的进程标识号，后四项则是进程的状态信息,其中连续IO请求长度表示一段时间内进程持续的IO请求大小的总和，其单位是字节（Byte），队列L表示该进程当前所在的多级进程请求队列，T_最近时间表示该进程的最近一次请求的完成时间，T_{最短间隔时间}表示两次请求到达的最短间隔时间。

（1-2）初始化多级进程请求队列，队列的元素为全局进程对象，并用结构体来表示，每一个全局进程对象都有自己的IO请求队列，如图4所示，其中app1、app2等表示进程对象结构体，req表示属于该进程对象的IO请求，S1、S2、S3分别表示第一级进程请求队列、第二级进程请求队列和第三级进程请求队列。

在本发明中，全局进程对象唯一标识任一客户端上的一个进程。

（1-3）初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数，阈值T_INTERVAL的初始值为1秒，最大截止时间T_DEADLINE为2秒；

（2）接收来自客户端的IO请求，并根据IO请求更新全局进程表；如图2所示，本步骤具体包括以下子步骤：

（2-1）接收来自客户端的IO请求，该IO请求在发送到服务器之前是被客户端进行过封装，即在原始的IO请求的数据包头封装上客户端的IP地址和进程PID号作为进程标识，以标识该IO请求所属的全局进程对象；

（2-2）查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入步骤（2-3），如果存在则转入步骤（2-4）；

（2-3）将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，其中T_当前时间表示当前时间，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（3）；

（2-4）判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入步骤（2-5），否则转入步骤（2-6）；

（2-5）更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（3）；

（2-6）重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0。将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾。

以下表1是一个更新后的全局进程表的例子。

表1

步骤(1)(2)的优点在于建立了面对客户端进程的全局进程表,传统的分布式文件系统都是通过服务器上的单个或多个服务进程来收取客户端请求并执行,客户端进程对其是透明的,从而无法在进程一级做优化调度。建立全局进程表并实时更新，通过请求的时间间隔来大致判断是否属于同一个进程的同步IO请求，有利于对进程的IO请求做分析调度。

（3）将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入步骤（4），否则转入步骤（5）；

（4）降低该全局进程对象的优先级，即从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

步骤（3）和（4）的优点在于降低了IO服务时间较长的客户端进程的优先级，从而减少了IO服务时间较少的客户端进程的请求等待时间，从整体上优化了IO响应时间。

（5）持续监听来自于客户端的IO请求，并重复以上步骤（2）至（4），以生成动态的多级进程请求队列。

（6）提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；如图3所示，本步骤具体包括以下子步骤：

（6-1）判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转（6-4）；若不存在，则转（6-2）；

（6-2）判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

（6-3）判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转（6-4），否则转（6-5）；

（6-4）处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转（6-6）；

（6-5）判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入步骤（6-6）；若不成立，将该进程对象删除，然后进入步骤（6-6）；

（6-6）更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长 $\mathrm{Length}=\underset{i=1}{\overset{N}{\mathrm{\&Sigma;}}}\mathrm{length}\left(i\right);$

（6-7）判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

（6-8）更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2。

（6-9）重复上述（6-1）到（6-8），直到处理完所有多级进程请求队列中的进程对象为止。

步骤（6）的优点在于动态最大截止时间（Deadline）策略以及自适应参数调整，动态最大截止时间策略能够避免可能出现的请求饥饿问题，防止某些大请求一直得不到执行，自适应参数调整主要针对2个参数：

REQ_MAX(i)和T_INTERVAL，根据系统负载动态调整这两个参数能更好的使系统适应整体负载。

本发明基于分布式文件系统的IO请求调度系统包括：

第一模块，用于初始化服务器的全局进程表和多级进程请求队列及其参数，具体包括以下子模块：

第一子模块，用于初始化全局进程表为空，其中有五个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}。全局进程ID表示客户端进程的标识符，其是由IP：PID的形式进行表示，IP表示客户端的IP地址，PID表示客户端的进程标识号，后四项则是进程的状态信息,其中连续IO请求长度表示一段时间内进程持续的IO请求大小的总和，其单位是字节（Byte），队列L表示该进程当前所在的多级进程请求队列，T_{最 近时间}表示该进程的最近一次请求的完成时间，T_{最短间隔时间}表示两次请求到达的最短间隔时间。

第二子模块，用于初始化多级进程请求队列，队列的元素为全局进程对象，并用结构体来表示，每一个全局进程对象都有自己的IO请求队列，如图4所示，其中app1、app2等表示进程对象结构体，req表示属于该进程对象的IO请求，S1、S2、S3分别表示第一级进程请求队列、第二级进程请求队列和第三级进程请求队列。

第三子模块，用于初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数，阈值T_INTERVAL的初始值为1秒，最大截止时间T_DEADLINE为2秒；

第二模块，用于接收来自客户端的IO请求，并根据IO请求更新全局进程表；本模块具体包括以下子模块：

第四子模块，用于接收来自客户端的IO请求，该IO请求在发送到服务器之前是被客户端进行过封装，即在原始的IO请求的数据包头封装上客户端的IP地址和进程PID号作为进程标识，以标识该IO请求所属的全局进程对象；

第五子模块，用于查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入第六子模块，如果存在则转入第七子模块；

第六子模块，用于将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，其中T_当前时间表示当前时间，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（3）；

第七子模块，用于判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入第八子模块，否则转入第九子模块；

第八子模块，用于更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最 短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（3）；

第九子模块，用于重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0。将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾；

第三模块，用于将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入第四模块，否则转入第五模块；

第四模块，用于降低该全局进程对象的优先级，即从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

第五模块，用于持续监听来自于客户端的IO请求，并重复以上第二模块至第四模块，以生成动态的多级进程请求队列；

第六模块，用于提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；本模块具体包括以下子模块：

第十子模块，用于判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转第十三子模块；若不存在，则转第十一子模块；

第十一子模块，用于判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

第十二子模块，用于判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转第十三子模块，否则转第十四子模块；

第十三子模块，用于处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转第十五子模块；

第十四子模块，用于判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入第十五子模块；若不成立，将该进程对象删除，然后进入第十五子模块；

第十五子模块，用于更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长 $\mathrm{Length}=\underset{i=1}{\overset{N}{\mathrm{\&Sigma;}}}\mathrm{length}\left(i\right);$

第十六子模块，用于判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

第十七子模块，用于更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2；

第十八子模块，用于重复上述第十子模块至第十七子模块，直到处理完所有多级进程请求队列中的进程对象为止。

本发明基于分布式文件系统的IO请求调度系统是存储在计算机可读存储介质中。

由于分布式文件系统多用于面向大规模应用环境，其客户端节点数量一般很多，甚至长千上万，服务器处理的IO请求队列一般非常长，传统的调度策略已经不能适应大规模的应用环境。在本发明中，通过对客户端进程信息的挖掘和实时更新，以及自适应的参数调整，使得小的IO请求能够得到优先执行，动态最大截止时间策略（deadline机制）又保证了大的IO请求不至于有饥饿现象。从而在整体上大大减少了进程的平均响应时间。

举例而言，假设有N个客户端进程并发地访问服务器，提交IO请求，这些进程的同步IO请求很多，在服务器处理一段时间后，新的客户端进程A的IO请求到达，这是个小IO进程，按照传统的方式，如果前N个进程的IO请求已经在队列中，那么这个小IO进程需要等待请求队列中的请求处理完毕，等待时间和N成正比。而按本发明的方式，前N个进程的优先级可能已经被降低至2或者更低，此时进程A直接进入1队列，而服务器处理线程可以直接处理进程A的IO请求。从整体上而言，大大降低了平均响应时间，尤其是在并发的进程数量较多的情况下。

本领域的技术人员容易理解，以上所述仅为本发明的较佳实施例而已，并不用以限制本发明，凡在本发明的精神和原则之内所作的任何修改、等同替换和改进等，均应包含在本发明的保护范围之内。

Claims (7)

1.一种基于分布式文件系统的IO请求调度方法，其特征在于，包括以下步骤：

（1）接收来自客户端的IO请求，并根据IO请求更新全局进程表；本步骤具体包括以下子步骤：

（1-1）接收来自客户端的IO请求；

（1-2）查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入步骤（1-3），如果存在则转入步骤（1-4）；

（1-3）将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（2）；

（1-4）判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入步骤（1-5），否则转入步骤（1-6）；

（1-5）更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（2）；

（1-6）重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾；

（2）将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入步骤（3），否则转入步骤（4）；

（3）从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

（4）持续监听来自于客户端的IO请求，并重复以上步骤（1）至（3），以生成动态的多级进程请求队列；

（5）提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；本步骤具体包括以下子步骤：

（5-1）判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转（5-4）；若不存在，则转（5-2）；

（5-2）判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

（5-3）判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转（5-4），否则转（5-5）；

（5-4）处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转（5-6）；

（5-5）判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入步骤（5-6）；若不成立，将该进程对象删除，然后进入步骤（5-6）；

（5-6）更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长 $\mathrm{Length}=\underset{i=1}{\overset{N}{\mathrm{\&Sigma;}}}\mathrm{length}\left(i\right);$

（5-7）判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

（5-8）更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2；

（5-9）重复上述（5-1）到（5-8），直到处理完所有多级进程请求队列中的进程对象为止。

2.根据权利要求1所述的IO请求调度方法，其特征在于，还包括步骤：在步骤（1）之前，初始化服务器的全局进程表和多级进程请求队列及其参数。

3.根据权利要求2所述的IO请求调度方法，其特征在于，初始化服务器的全局进程表和多级进程请求队列及其参数的步骤具体包括以下子步骤：

初始化全局进程表为空，其包括多个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}；

初始化多级进程请求队列，队列的元素为全局进程对象；

初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数。

4.根据权利要求1所述的IO请求调度方法，其特征在于，全局进程对象唯一标识任一客户端上的一个进程。

5.一种基于分布式文件系统的IO请求调度系统，其特征在于，包括：

第二模块，用于接收来自客户端的IO请求，并根据IO请求更新全局进程表；本模块具体包括以下子模块：

第四子模块，用于接收来自客户端的IO请求，该IO请求在发送到服务器之前是被客户端进行过封装，即在原始的IO请求的数据包头封装上客户端的IP地址和进程PID号作为进程标识，以标识该IO请求所属的全局进程对象；

第五子模块，用于查询全局进程表，并判断全局进程表中是否存在该IO请求对应的进程标识的表项，如果不存在则转入第六子模块，如果存在则转入第七子模块；

第六子模块，用于将该IO请求对应的进程添加至全局进程表，并初始化该进程的状态信息，即设定连续IO请求长度=0，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0，其中T_当前时间表示当前时间，同时创建一个新的全局进程对象，并将该全局进程对象添加至多级进程请求队列中第一级进程请求队列的末尾，然后转入步骤（3）；

第七子模块，用于判断T_当前时间-T_最近时间<T_INTERVAL是否成立，若成立，则转入第八子模块，否则转入第九子模块；

第八子模块，用于更新该IO请求对应的进程的状态信息，即设定连续IO请求长度=连续IO请求长度+IO请求的长度，T_最近时间=T_当前时间，T_{最 短间隔时间}=T_当前时间-T_最近时间，然后转入步骤（3）；

第九子模块，用于重新初始化该IO请求对应的进程的状态信息，即设定连续IO请求长度=当前IO请求的大小，队列L=1，T_最近时间=T_当前时间，T_{最短间隔时间}=0。将该进程对象从当前队列的位置删除，并插入到1级进程请求队列的末尾；

第三模块，用于将IO请求添加至其所属的全局进程对象的请求队列的末尾，并判断该全局进程对象的连续IO请求长度是否小于REQ_MAX(L)，且有L<多级请求队列的最大级数，如果是则转入第四模块，否则转入第五模块；

第四模块，用于降低该全局进程对象的优先级，即从第L级队列中删除该全局进程对象，并将其插入到第L+1级队列的末尾；

第五模块，用于持续监听来自于客户端的IO请求，并重复以上第二模块至第四模块，以生成动态的多级进程请求队列；

第六模块，用于提取当前不为空的多级进程请求队列的首个进程对象的所有IO请求，执行并更新该进程对象的状态信息和参数；本模块具体包括以下子模块：

第十子模块，用于判断多级进程请求队列中是否存在某一级进程请求队列，其T_LAST（i）<T_DEADLINE，若存在，则查看该级IO请求队列的首个进程对象，并转第十三子模块；若不存在，则转第十一子模块；

第十一子模块，用于判断多级进程请求队列中第一级进程请求队列是否为空，若为空，则判断多级进程请求队列中的第二级进程请求队列，…以此类推，直至找到一个不为空的某一级进程请求队列为止；

第十二子模块，用于判断该级进程请求队列中首个进程对象的IO请求队列中是否有IO请求等待，如果有，则转第十三子模块，否则转第十四子模块；

第十三子模块，用于处理该进程对象的IO请求队列中的所有IO请求，完成后更新该进程对象的T_最近时间，将该进程对象从当前IO请求队列的队头删除，插入到当前IO请求队列的末尾，然后转第十五子模块；

第十四子模块，用于判断T_当前时间–该进程对象的T_最近时间<T_INTERVAL是否成立，若成立，将该进程对象从当前IO请求队列的队头删除，并插入到当前IO请求队列的队尾，然后进入第十五子模块；若不成立，将该进程对象删除，然后进入第十五子模块；

第十五子模块，用于更新各级进程请求队列的队长Length(i)以及多级进程请求队列的总队长 $\mathrm{Length}=\underset{i=1}{\overset{N}{\mathrm{\&Sigma;}}}\mathrm{length}\left(i\right);$

第十六子模块，用于判断是否存在有Length(i)/Length≤1/2N，如果存在，则设定REQ_MAX(i)=2*REQ_MAX(i)，否则判断是否存在Length(i)/Length>2/N，若存在则设定REQ_MAX(i)=REQ_MAX(i)/2，否则过程结束：

第十七子模块，用于更新T_INTERVAL，T_INTERVAL=(T_INTERVAL+当前进程对象的T_{最短间隔时间})/2；

第十八子模块，用于重复上述第十子模块至第十七子模块，直到处理完所有多级进程请求队列中的进程对象为止。

6.根据权利要求5所述的IO请求调度系统，其特征在于，还包括第一模块，用于初始化服务器的全局进程表和多级进程请求队列及其参数。

7.根据权利要求6所述的IO请求调度系统，其特征在于，第一模块包括：

第一子模块，用于初始化全局进程表为空，其中有五个表项，分别是全局进程ID、连续IO请求长度、队列L、T_最近时间和T_{最短间隔时间}。全局进程ID表示客户端进程的标识符，其是由IP：PID的形式进行表示，IP表示客户端的IP地址，PID表示客户端的进程标识号，后四项则是进程的状态信息,其中连续IO请求长度表示一段时间内进程持续的IO请求大小的总和，其单位是字节（Byte），队列L表示该进程当前所在的多级进程请求队列，T_{最 近时间}表示该进程的最近一次请求的完成时间，T_{最短间隔时间}表示两次请求到达的最短间隔时间。

第二子模块，用于初始化多级进程请求队列，队列的元素为全局进程对象，并用结构体来表示，每一个全局进程对象都有自己的IO请求队列，如图4所示，其中app1、app2等表示进程对象结构体，req表示属于该进程对象的IO请求，S1、S2、S3分别表示第一级进程请求队列、第二级进程请求队列和第三级进程请求队列；

第三子模块，用于初始化多级进程请求队列的参数，多级进程请求队列的参数包括每一级进程请求队列的最大请求数目REQ_MAX(i)、最近的处理时间T_LAST（i）、阈值T_INTERVAL以及最大截止时间T_DEADLINE，其中i=1,2,…,N，N为多级进程请求队列的个数，阈值T_INTERVAL的初始值为1秒，最大截止时间T_DEADLINE为2秒。

Images