CN1777107B

CN1777107B - 用于在高性能计算（hpc）系统中按需式例示的装置和方法

Info

Publication number: CN1777107B
Application number: CN2005100878553A
Authority: CN
Inventors: S·V·戴维森
Original assignee: Raytheon Co
Current assignee: Raytheon Co
Priority date: 2004-11-17
Filing date: 2005-04-15
Publication date: 2013-07-17
Anticipated expiration: 2025-04-15
Also published as: KR20070085089A; IL178610A; EP1662388A1; US8244882B2; WO2006055027A1; JP2006146865A; MY151525A; JP4451806B2; KR101159386B1; IL178610A0; TWI285818B; CA2503781C; TW200619962A; US20060117208A1; CN1777107A; EP1662388B1; CA2503781A1

Abstract

在一个实施例中，一种用于在高性能计算(HPC)系统中按需式例示的方法包括：接收来自客户机的连接请求，该客户机指定了和包括节点群集的HPC服务器相关的、外部通告的第一端口号和第一主机名称，识别相应于该第一端口号和第一主机名称的HPC服务器上的服务，确定所识别的服务是否有效，以及，如果所识别的服务有效，就例示在群集的一个或多个节点上提供所识别的服务的主机。

Description

用于在高性能计算(HPC)系统中按需式例示的装置和方法

技术领域

该公开内容一般涉及数据处理，尤其涉及HPC系统中的按需式（on-demand）例示。

背景技术

高性能计算（HPC）通常被科学家和技术人员为模拟、仿真和分析复杂的物理或算法现象而使用的计算系统所表征。目前，通常使用称为节点的一个或多个处理器的许多HPC群集来设计HPC机器。对于更大的科学和工程应用来说，主要由并行可测量性而非单个节点的速度来确定性能；所以，在构建或购买所述高性能群集的过程中可测量性是一个限制因素。通常基于以下条件来考虑可测量性：i）硬件；ii）存储器，输入/输出（I/O），以及通信带宽；iii）软件；iv）体系结构；以及v）应用程序。在很多传统的HPC环境中的处理、存储器、以及I/O带宽通常不能很好的平衡，因此，不能很好的测量。许多HPC环境不具有满足高端数据处理需求的I/O带宽或利用安装有太多不需要的部件的叶片来构造，这样趋向于大大减少系统的可靠性。因此，许多HPC环境没有为生产导向的环境中的有效操作提供稳固的群集管理软件。

发明概述

本发明能够减少或消除HPC系统的缺陷、问题或两者皆而有之。

在一实施例中，一种用于在高性能计算（HPC）系统中用于按需式例示的方法包括：接收来自客户机的连接请求，该客户机指定了和包括节点的群集的HPC服务器相关的、外部通告的第一端口号和第一主机名称，识别相应于该第一端口号和第一主机名称的HPC服务器上的服务，确定所识别的服务是否有效，以及，如果所识别的服务有效，就例示在群集的一个或多个节点上提供所识别的服务的主机。

本发明的特定实施例可以提供一个或多个技术上的优点。例如，特定的实施例可以使客户机请求HPC服务器上的服务。在特定的实施例中，HPC服务器上的服务仅当来自客户机的访问该服务的请求与用于访问该服务的一个或多个标准相符时才对客户机有效。特定的实施例提供了虚拟群集中的主机的高可用性。特定的实施例动态地监控因特网服务请求，并将这些请求映射到提供所需服务的主机并例示这些主机。本发明的特定实施例提供了上述技术上的所有或某些优点，或者不提供上述技术上的优点。特定的实施例可提供一个或多个其它的技术上的优点，通过这里的附图、说明书和权利要求，这些优点中的一个或多个对于熟知本领域的人员来说是显而易见的。

附图的简要描述

为了完整的理解本发明及其特征和优点，参考结合附图而进行的随后描述，其中：

图1说明了根据本发明一实施例的高性能计算系统实例；

图2说明了图1所示HPC系统中的节点实例；

图3说明了节点中的中央控制单元(CPU)实例；

图4说明了节点对实例；

图5A-5D说明了图1系统中格栅的不同实施例及其使用；

图6A-6B说明了根据图1系统的图形用户接口的不同实施例；

图7说明了根据图1系统的群集管理软件的一个实施例；

图8说明了一个被折叠成y尺寸的尺寸要求的实例；

图9说明了将y轴用作内部环路而构建的两个自由网格；

图10说明了将x轴用作内部环路而构建的两个自由网格；

图11说明了图1所示HPC系统的接口实例；

图12是用于说明根据图1的高性能计算系统提交成批作业的方法的流程图；

图13是用于说明根据图1的高性能计算系统的栅格动态回填的方法的流程图；

图14是用于说明根据图1的高性能计算系统来动态管理节点故障的方法的流程图；以及

图15说明了图1所示HPC系统中用于按需式例示的方法实例。

附图的详细描述

图1是HPC系统100的结构图，所述HPC系统使用HPC技术以用于执行软件应用程序和处理，例如大气、天气、或事故模拟。系统100通过与处理性能实质相似的I/O性能而向用户提供动态定位于不同计算节点115之间的HPC功能。通常，这些节点115很容易测量，尤其因为其增加了I/O功能并且减少了组织等待时间。例如，可以通过Amdahl’s法则的导数表示分布式体系结构中的节点115的可测量性：

S(N)＝1/((FP/N)+FS)×(1-Fc×(1-RR/L))

其中S(N)＝N个处理器的加速，Fp＝并行码的分数，Fs＝非并行码的分数，Fc＝专用于通信的处理的分数，以及RR/L＝远程存储器带宽/本地存储器带宽的比率。所以，通过HPC系统100提供实质上等于或近似于处理性能的I/O性能，HPC系统100增加了HPC应用的整体效率并且提供更容易的系统管理。

HPC系统100是一种分布式客户/服务器系统，其允许用户(诸如科学家和技术人员)提交作业150以在HPC服务器102上进行处理。例如，系统100可以包括HPC服务器102，该服务器经由网络106连接到一个或多个管理工作站或本地客户120。但是系统100可以是一个独立的计算环境或任意其他合适的环境。简言之，系统100是满足以下条件的任意HPC计算环境，即包括高可测量的节点115并且允许用户提交作业150，为作业150动态定位可测量的节点115，并且使用定位的节点115自动执行作业150。作业150可以是使用HPC技术进行操作并且由任何恰当用户提供的任意批量或在线作业。例如，作业150可以是模拟、模型的请求或是其他高性能需求的请求。作业150也可以是一种运行数据中心应用程序诸如群集数据库、在线交易处理系统或群集应用程序服务器的请求。在此所使用的术语“动态”通常意指在基于一个或多个变量的运行时间上至少部分地确定某一处理。在此所使用的术语“自动”通常表示通过至少部分的HPC系统100实质上执行适当的处理。应该理解：“自动”进一步企图使任意合适的用户或管理者与系统100交互而无需脱离该公开内容的范围。

HPC服务器102包括使用多个平衡节点115和群集管理器引擎130以操作处理作业150的任意本地或远程计算机。通常，HPC服务器102包括分布式计算机诸如叶片服务器或其他分布式服务器。然而所述配置中，服务器102包括多个节点115。节点115包括任意计算或处理设备，诸如例如叶片、通用个人计算机(PC)、Macintoshes、工作站、基于Unix的计算机、或任何其他合适的设备。通常，图1仅提供可为本公开内容使用的计算机实例。例如，虽然图1说明了一个可为本公开内容使用的服务器102，但是系统100使用除了服务器之外的计算机和服务器组合来实施。换句话说，本公开内容设想除了通用计算机之外的计算机以及无需传统操作系统(OSs)的计算机。本文献所使用的术语“计算机”意指包括个人计算机、工作站、网络计算机、或任意其他合适的处理设备。HPC服务器102或所述部件节点115适于执行包括Linux、UNIX、Windows服务系统或其他合适的OS的任意OS。根据一个实施例，HPC服务器102也可以包括或通信耦合到远程web服务器。因此，服务器102可以包括具有适于动态分配节点115以处理HPC作业150的任何组合的软件和/或硬件的任意计算机。

更为详细的说，HPC服务器102包括管理节点105、包括多个节点115的网格110、以及群集管理引擎130。具体而言，服务器102可以是一种包括具有一些或全部以下部件的多个叶片(节点115的)标准的19”架(rack)：i)双处理器；ii)大的、高带宽存储器；iii)双主通道适配器(HCAs)；iv)集成组织开关；v)FPGA支架；以及vi)多余电源输入或N+1电源。这些不同的部件允许将故障限制到节点级的范围内。但是应当理解，HPC服务器102和节点115可以不包括所有的这些部件。

管理节点105包括至少一个基本上专用于管理或帮助管理者的叶片。例如，管理节点105可以包括两个叶片，该两个叶片之一是多余的(诸如主动/被动配置)。在一实施例中，管理节点105可以是与HPC节点115相同类型的叶片或计算设备。但是，管理节点105可以是包括任何数量的电路并且以任意合适方式配置的任意节点，只要其保持至少部分地管理栅格110是可行的。通常，管理节点105与多个HPC节点115物理上或逻辑上分离，共同表示为栅格110的形式。在所述说明性的实施例中，管理节点105可以经由链路108通信耦合到栅格110。参考“链路”包括实施任意合适的通信协议的任意合适的通信管道。作为一种非限制性的实例，链路可以包括一个或多个电路板上的一个或多个线路、一个或多个内部或外部总线、一个或多个局域网(LANs)、一个或多个城域网(MANs)、一个或多个广域网(WANs)、一个或多个互联网部分、或两个或多个所述链路的合适组合。在一实施例中，链路108在管理节点105和栅格110之间提供千兆位或10千兆位的以太网通信。

栅格110是为增加处理能力而互连的一组节点115。典型的，栅格110是一种3D环面，但其可以是网格、超正方体或不脱离该公开内容的其他任意形状或配置。参考“环面”可以适当包括所有的或部分的栅格110，反之亦然。以栅格110形式的节点115之间的所述链路可以是串行的或并行的模拟链路，或能够传送电子或电磁信号的任意其他类型的链路，诸如例如光纤或铜。每一节点115配置有集成的开关。这样允许节点115更容易地成为适于3D环面的基本构造并且有助于最小化其他节点115之间的XYZ距离。此外，这使得铜线工作在在某些实施例中具有小于5米的最长线缆并且等于千兆位率的较大系统中。简言之，一般优化节点115以用于最近相邻通信和增加的I/O带宽。

每一节点115可以包括与群集管理引擎130通信耦合的群集代理132。通常，代理132从管理节点105和/或群集管理引擎130接收请求或命令。代理132能够包括用于确定节点115的物理状态并且经由诸如“心跳”传递已处理数据给管理节点105的任意硬件、软件、或它们的组合。在另一实施例中，管理节点105周期地查询代理132以确定相关节点115的状态。代理132可以以合适的计算机语言进行编写，诸如C，C++，Assembler，Java，Visual Basic，和其他或它们的任意组合，只要其与群集管理引擎130的至少一部分保持一致。

群集管理引擎130包括用于动态定位和管理节点115并且使用节点115来执行作业150的任意硬件、软件、固件或它们的组合。例如，可以以包括C，C++，Java，Visual Basic，Assembler，任意合适版本的4GL，以及其他或它们的任意组合的合适计算机语言编写或描述群集管理引擎130。应该理解，尽管作为单个多任务模块而在图1中说明了群集管理引擎130，但是该引擎所执行的特征和功能可以通过多个模块诸如例如物理层模块、虚拟层模块、作业调度器、以及提示引擎来执行(如图7中详细所示那样)。此外，虽然示出了管理节点105的外形，但是管理节点105通常执行一个或多个与群集管理引擎130相关的处理并且存储群集管理引擎130。而且，在不脱离该公开内容的范围内，群集管理引擎130是另一软件模块的衍生或子模块。所以，群集管理引擎130包括用于智能管理节点115和作业150的一个或多个软件模块。在特别的实施例中，群集管理引擎包括如以下所述的将节点115分配给作业150的调度器515。如以下进一步描述那样，调度器515使用调度算法将节点115分配给作业150。

服务器102包括接口104，用于在客户服务器或其他分布式环境中通过网络106与其他计算机系统诸如客户120进行通信。在某些实施例中，服务器102 从网络106接收作业150或作业策略以存储在特大容量磁盘140中。特大容量磁盘140使用与所述节点相互连接的相同宽频带接口被直接附加到计算阵列。通常，接口104包括适当组合形式的逻辑编码软件和/或硬件并且可操作以与网络106进行通信。具体而言，接口104可以包括支持与通信网络106相关联的一个或多个通信协议的软件或用于与物理信号相通信的硬件。

网络106有利于计算机服务器102与任意其他计算机诸如客户机120之间的无线或有线通信。实际上，虽然将网络106驻留于服务器102和客户机120之间而进行描述，但是在不脱离该公开内容的范围内，网络106也可以驻留在不同的节点115之间。换句话说，网络106包括易于不同计算部件之间通信的任意网络、多个网络、或子网络。网络106例如可以在网络地址之间传送网际协议(IP)信息包、帧中继帧、异步传输模式(ATM)单元、声音、视频、数据或其他适当的信息。网络106可以包括一个或多个局域网(LANs)，无线访问网络(RANs)、城域网(MANs)、广域网(WANs)、公知的全部或一部分全球计算机网络、和/或一个或多个位置上的任意其他通信系统或多个通信系统。MAC代表适当地方的媒体访问控制。

通常，特大容量磁盘140是用于存储作业150、图表、启动图像、或其他HPC信息的任意存储器、数据库或存储区域网络(SAN)。根据所述实施例，特大容量磁盘140包括一个或多个存储客户机142。特大容量磁盘140根据多种通信协议例如InfiniBand(IB)、千兆以太网(GE)、或纤维管道(FC)之一而可以处理或发送数据包。通常数据包用于传输特大容量磁盘140内的数据。一个数据包可以包括具有源标识符和目的标识符的头部。源标识符(例如源地址)识别信息的发送器，而目的标识符(例如目的地址)识别所述信息的接收器。

客户机120是经由图形用户接口(GUI)126向用户提供作业提出屏幕或管理的任意设备。更为详细的说，所示的客户机120至少包括GUI126并且包括用于接收、发送、处理以及存储与系统100相关的任意合适数据的电子计算设备。应该理解：可能存在多个客户机120通信耦合到服务器102。此外，在不脱离该公开内容的范围内，适当地交替使用“客户机120”和“客户机120的用户”。而且，为方便说明，根据一个用户的使用来描述每一客户机。但是该公开内容设想：许多用户通过使用相同的GUI126而使用一个计算机来传送作业150。

如该公开内容中所使用的那样，客户机120用来包括个人计算机、触屏终端、工作站、网络计算机、信息站、无线数据端口、蜂窝式便携无线电话、个人数字助理(PDA)、这些或其他设备内的一个或多个处理器、或者任意其他合适的处理设备。例如，客户机120可以包括具有以下部件的计算机，即包括输入设备，诸如键盘、触摸屏、鼠标或能够接收信息的其他设备，以及一个输出设备，传输与服务器102或客户机120的操作相关的信息，包括数字数据、视觉信息，或GUI126。所述输入设备和输出设备可以包括固定的或移动的存储介质诸如磁性计算机磁盘、CD-ROM、或通过管理和作业提交显示，也就是GUI126从客户机120的用户接收或向客户机120的用户提供输出的其他合适的介质。

GUI126包括允许以下内容的图形用户接口：i)客户机120的用户与系统100相连接以提交一个或多个作业150；和/或ii)为适当的监督目的，使得使用客户机120的系统(或网络)管理者与系统100相连接。通常，GUI126使得客户机120的用户具备由HPC系统100提供的有效的和用户界面友好的数据表示。GUI126包括多个可定制结构或可由用户操作的具有交互字段、下拉菜单以及按钮的视图。在一个实施例中，GUI126提供一个作业提交显示，其提供了不同的作业参数字段并且经由一个输入设备接收客户机120的用户的命令。作为选择或结合，如图6A-6B所示那样，GUI126可以将节点115的物理和逻辑状态提供给系统管理者，并且从所述管理者接收不同的命令。管理者的命令包括标记节点为(不)可用、关闭用于维持的节点、重新启动节点、或任意其他合适的命令。而且，应该理解，可以在单数或复数中使用术语-图形用户接口，以便描述一个或多个图形用户接口和特定的图形用户接口的每一显示。所以，GUI126设想：诸如一般网页浏览器那样的任意图形用户接口处理系统100中的信息并且有效的将结果提供给用户。服务器102经由网页浏览器(例如，MicrosoftInternet Explorer或Netscape Navigator)接收客户机120的数据并且使用网络106返回合适的HTML或XML响应。

在操作的一个方面中，首先启动或引导HPC服务器102。在所述处理期间，群集管理引擎130确定栅格110中节点115的存在、状态、位置和/或其他特征。如上所述，其是以每一节点的启动或由管理节点105近似直接的查询所传输的“心跳”为基础的。接下来，群集管理引擎130例如基于预定的方法动态地将栅格110的不同部分分配给一个或多个虚拟群集220。在一实施例中，群集管理引擎130连续地监控可能出现故障的节点115，一旦确定一个节点115出现故障，就使用多种恢复技术中的任一一种技术来有效地管理所述故障。群集管理引擎130也可以管理和提供唯一的执行环境给虚拟群集220的每一被分配的节点。所述执行环境由主机名、IP地址、OS、配置服务、局部和共享文件系统、以及一组安装的应用程序和数据。所述群集管理引擎130根据相关的方法并根据内部群集方法诸如优先权而可以动态地增加或减少虚拟群集220的节点。

当用户登录到客户机120时，经由GUI126向该用户提供作业提交屏幕。一旦所述用户输入作业参数并且提交作业150，群集管理引擎130处理所述作业提交，相关的参数，以及与作业150、用户或用户组相关的一些预定的策略。群集管理引擎130至少部分地基于该信息来确定合适的虚拟群集220。然后引擎130动态地分配虚拟群集220内的作业空间230并且使用HPC技术在被分配的节点115上执行作业150。至少部分地基于增加的I/O性能，HPC服务器102能够更加迅速地完成作业150的处理。一旦完成，群集管理引擎将结果160告知用户。

图2说明了节点(叶片)115实例。节点115包括在任意方向上处理一个或多个作业150的全部或部分诸如线程或处理的任意计算设备。作为一个非限制性实例，节点115包括XEON母板、OPTERON母板、或其他计算设备。节点115具有提供集成组织的体系结构，其能够在栅格110的节点115上分配开关功能。在一具体的实施例中，在栅格110的节点115上分配所述功能可以避免栅格110中的集中开关，这样依次增加了栅格110的容错性并且能够在栅格110中的节点115之间并行通信。

节点115包括两个CPU164和一个开关(或组织fabric)166。如果合适，参考节点115可以包括两个CPU164和一个开关166。参考节点115如果合适可以仅包括一个CPU164。开关166可以是集成开关。在一个具体的实施例中，开关166具有24个端口。开关166上的两个端口能够将节点115耦合到管理节点105以对节点115进行输入和输出。另外，开关166上的两个端口都将节点115耦合到沿着栅格110的x轴的另一节点115，开关166上的两个端口都将节点115耦合到沿着栅格110的y轴的另一节点115，以及开关166上的两个端口都将节点115耦合到沿着栅格110的z轴的另一节点115以易于在栅格110中实施3D网格、3D环面、或其他拓扑结构。开关166上的另外的端口将节点115耦合到栅格110中另外的节点115以便于在栅格110中实施多维拓扑结构(诸如4D环面或多于3维的其他非传统拓扑结构)。在一个具体的实施例中，开关166上的一个或多个端口将节点115耦合到沿着栅格110的一个或多个对角线轴的一个或多个其他的节点115，这样减少了节点115与相对远离节点115的一个或多个其他节点115之间的通信跳转或跳跃。作为非限制性的实例，开关166上的端口可以将节点115耦合到沿着栅格110的东北轴线驻留的另一节点115，几个3D从节点115跳离。在具体实施例中，开关166是InfiniBand开关。虽然说明和描述了具体的开关166，但是本发明适于任意合适的开关166。

链路168a将CPU164a耦合到开关166。如下所述，链路168b将CPU164a耦合到另一节点115中的另一开关166。链路168c将CPU164b耦合到开关166。如下所述，链路168d将CPU164b耦合到其他的开关166。如以下进一步所述，链路168e和168f将开关166耦合到另一节点115中的两个其他的CPU164。在具体的实施例中，链路168包括InfiniBand4X链路，其能够在每一方向上进行大约每秒一千兆字节的通信。虽然说明和描述了具体的链路168，但是本发明适于任意合适的链路168。链路170是到节点115的I/O链路。链路170包括InfiniBand4X链路，其能够在每一方向上进行大约每秒一千兆字节的通信。虽然说明和描述了具体的链路170，但是本发明适于任意合适的链路170。如以下所述那样，链路172将开关166耦合到其他节点115的其他开关166上。在具体的实施例中，链路172包括InfiniBand12X链路，其能够在每一方向上进行大约每秒三千兆字节的通信。虽然说明和描述了具体的链路172，但是本发明适于任意合适的链路172。

图3说明了节点115中的CPU164实例。虽然说明和描述了一种CPU164实例，但是本发明适于任意合适的CPU164。CPU164包括处理器174、存储控制器集线器(MCH)176、存储单元178、以及主通道适配器(HCA)180。处理器174包括硬件、软件、或嵌入逻辑部件或两种或多种所述部件的组合。在具体的实施例中，处理器174是INTEL的NOCONA XEON处理器174。在具体的实施例中，处理器174是一种大约3.6千兆赫兹的处理器，其具有大约1兆字节的高速缓存并且具有每秒7.2千兆浮点运算次数。在具体的实施例中，处理器174提供超线程(HyperThreading)。在具体的实施例中，处理器174包括能够有效使用存储器带宽的存储器控制器。虽然说明和描述了具体的处理器174，但是本发明适合于任意合适的处理器174。

总线182将处理器174和MCH176相互耦合。在具体的实施例中，总线182是一种能够每秒通信大约6.4千兆字节的大约800MHz的前端总线(FSB)。虽然说明和描述了具体的总线182，但是本发明适合于任意合适的总线182。MCH176包括促进处理器174与HPC系统100的一个或多个其他部件诸如存储单元178之间的通信的硬件、软件、或嵌入逻辑部件或两个或多个所述部件的组合。在具体的实施例中，MCH176是CPU164的北桥，其控制处理器174与一个或多个存储单元178、总线182、2级(L2)缓存、以及一个或多个其他的CPU164的部件之间的通信。在具体的实施例中，MCH176是LINDENHURSTE7520MCH176。在具体的实施例中，存储单元178包括8千兆字节的随机存取存储器(RAM)。在具体的实施例中，存储单元178包括单独与MCH176相耦合的两个双数据速率(DDR)存储设备。作为非限制性实例，存储单元178包括具有每通道每秒大约3.2千兆字节的通信能力的两个DDR2-400存储设备。虽然说明和描述了具体的存储单元178，但是本发明适用于任意合适的存储单元178。

在具体的实施例中，一链路将MCH176耦合到I/O控制器集线器(ICH)，所述I/O控制器集线器包括有利于处理器174与HPC系统100的一个或多个其他部件诸如耦合到ICH的基本I/O系统(BIOS)、耦合到ICH的千兆位以太网(GbE)控制器或其他以太网接口、或两者之间的I/O的一个或多个硬件、软件、或嵌入逻辑部件。在具体实施例中，ICH是用于CPU164的南桥，其控制CPU164的I/O功能。耦合到ICH的以太网接口有利于ICH与耦合到以太网接口的基线板管理控制器(BMC)之间的通信。在具体的实施例中，HPC系统100的管理节点105或其他部件包括一个或多个所述BMC。在具体实施例中，以太网接口通过一链路耦合到提供对一个或多个GbE管理端口的访问的开关。

MCH176和HCA180通过总线184相互耦合。在具体实施例中，总线184是一种外设部件互连(PCI)总线184，诸如能够进行每秒大约4千兆字节通信的PCI-Express8X总线184。虽然说明和描述了具体的总线184，但是本发明适用于任意合适的总线184。HCA180包括将基于通道的I/O提供给CPU164的硬件、软件、或嵌入逻辑部件或两个或多个所述部件的组合。在具体实施例中， HCA180是一种MELLANOX InfiniBand HCA180。在具体实施例中，HCA180提供大约2.65千兆字节/每秒的带宽，这样每处理部件(PE)到节点115中开关166允许大约1.85千兆字节并且每个PE到I/O诸如基本I/O系统(BIOS)、以太网接口、或其他I/O允许大约800兆字节。在具体实施例中，HCA180允许开关166达到大约3.7千兆字节每秒到大约13.6千兆浮动运算每秒的峰值，允许开关166上的I/O速率达到大约50兆字节每千兆浮动运算到每浮点运算大约0.27字节或两者皆有。虽然说明和描述了具体的HCA180，但是本发明适用于任意合适的HCA180。每一链路168将HCA180耦合到开关166。如下所述，链路168a将HCA180耦合到第一开关166，其相对于HCA180是一个初级开关。在具体的实施例中，包括HCA180的节点115包括第一开关166。如下所述，链路168b将HCA180耦合到第二开关166，其是相对于HCA180的次级开关。如下所述，在具体的实施例中，不包括HCA180的节点115包括第二开关166。

图4说明了包括两个开关166和四个处理器174的节点对186实例。节点对186中的开关166相对于彼此之间是多余的，这样增加了节点对186的容错性。如果节点对186中的第一开关166没有适当地运行，节点对186中第二开关166可为节点对186中的四个CPU提供切换。在节点对186中，开关166a相对于CPU164a和164b是初级开关166，而相对于CPU164c和164d而言是次级开关166。开关166b相对于CPU164c和164d是初级开关166，而相对于CPU164a和164b而言是次级开关166。如果适当运行两个开关166a和166b，开关166a为CPU164a和164b提供切换并且开关166b为CPU164c和164d提供切换。如果开关166a适当地运行，而开关166b不运行，那么开关166a可为CPU164a、164b、164c和164d提供切换。如果开关166b适当地运行，而开关166a没有适当运行，那么开关166b可为CPU164a、164b、164c和164d提供切换。

链路172将节点对186中的每一节点115耦合到栅格110的节点对186之外的6个节点115上。作为非限制性的实例，开关166a处的链路172a将节点115a耦合到栅格110中节点115a北侧节点对186之外的第一节点115，开关166a处的链路172b将节点115a耦合到栅格110中节点115a南侧节点对186之外的第二节点115，开关166a处的链路172c将节点115a耦合到栅格110中节点115a东侧节点对186之外的第三节点115，开关166a处的链路172d将节点115a耦合到栅格110中节点115a北侧节点对186之外的第四节点115，开关166a处的链路172e将节点115a耦合到栅格110中节点115a上侧节点对186之外的第五节点115，以及开关166a处的链路172f将节点115a耦合到栅格110中节点115a下侧节点对186之外的第六节点115。在具体的实施例中，链路172将节点对186中节点115a和115b耦合到节点对186之外的彼此不同的节点115组。作为非限制性实例，开关166a上的链路172将节点115a耦合到节点对186之外的第一个六个节点115组，该第一六个节点组包括节点对186外部的第一节点115、节点对186外部的第二节点115、节点对186外部的第三节点115、节点对186外部的第四节点115、节点对186外部的第五节点115、节点对186外部的第六节点115。开关166b上的链路172将节点115b耦合到节点对186之外的第一个六个节点115组，该第二六个节点组包括节点对186外部的第七节点115、节点对186外部的第八节点115、节点对186外部的第九节点115、节点对186外部的第十节点115、节点对186外部的第十一节点115、节点对186外部的第十二节点115。

在具体的实施例中，一链路172将临近于栅格110的第一边沿的第一节点115耦合到与相对于第一边沿的栅格110的第二边沿临近的第二节点115。作为非限制性实例，假设第一节点115临近栅格110的左边沿，第二节点115临近于与栅格110的左边沿相对的栅格110的右边沿。第一和第二节点115通过链路172相互耦合以至于第一节点115位于第二节点115的东侧，第二节点115位于第一节点115的西侧，而不管栅格110中第一节点115和第二节点115之间的相对位置。作为另一实例，假设第一节点115临近栅格110的前边沿，第二节点115临近于与栅格110的前边沿相对的栅格110的后边沿。第一和第二节点115通过链路172相互耦合以至于第一节点115位于第二节点115的南侧，第二节点115位于第一节点115的北侧，而不管栅格110中第一节点115和第二节点115之间的相对位置。作为又一实例，假设第一节点115临近栅格110的顶部边沿，第二节点115临近于与栅格110的顶部边沿相对的栅格110的底部边沿。第一和第二节点115通过链路172相互耦合以至于第一节点115位于第二节点115的下侧，第二节点115位于第一节点115的上侧，而不管栅格110中第一节点115和第二节点115之间的相对位置。

图5A-5D说明了系统100中栅格110的不同实施例及其使用或拓扑结构。图5A说明了使用多种节点类型的栅格110的一种配置，也就是3D环面。例如，所说明的节点类型是外部I/O节点、文件系统(FS)服务器、FS元数据服务器、数据库服务器以及计算节点。图5B说明了栅格110的“折叠”实例。折叠一般允许栅格110的一个物理边沿连接到相应的轴向边沿，从而提供更加坚固或无边的拓扑结构。在该实施例中，节点115被歪曲以提供通过节点线216连接的近乎无缝拓扑结构。节点线216可以是为互连两个或多个节点115而实施任意通信协议的任意合适的硬件。例如，节点线216可以是铜线或实施千兆位以太网的光纤电缆。在具体的实施例中，如上述那样，节点线216包括一个或多个链路172。

图5C说明具有定位于此的一个虚拟群集220的栅格110。虽然说明仅具有一个虚拟群集220，但是在不脱离该公开内容的范围内，栅格110中可以存在任意数量(包括0)个虚拟群集220。虚拟群集220是一种用于处理相关作业150的节点115的逻辑分组。例如，虚拟群集220与一个研究分组、部门、实验室或可能提交相似作业150的任意其他用户组。虚拟群集220可以是任意形状并且包括任意数量个栅格110内的节点115。实际上，虽然所说明的虚拟群集220包括多个物理上临近的节点115，但是群集220是一种用于处理作业150的逻辑相关节点115的分布式群集。

可在任意合适的时间处定位虚拟群集220。例如，例如基于启动参数而一旦启动系统100就定位群集220，或例如基于改变服务器102的需要而定位群集220。而且，随着时间的过去，虚拟群集220可改变其形状和尺寸以快速响应改变请求、命令以及状态。例如，可以动态的改变虚拟群集220以包括自动定位的第一节点115，从而响应第二节点115的故障、群集220的先前部分。在一些实施例中，当处理需要时，群集220共享节点115。在具体的实施例中，如以下所述，调度器515根据调度算法将一个或多个虚拟群集220分配给一个或多个作业150。

图5D分别说明了定位在虚拟群集220实例内的不同作业空间230a和230b。通常，作业空间230是动态被分配以完成接收到的作业150的虚拟群集220内的一组节点115。典型地，每一执行作业150就存在一个作业空间230，反之亦然，但是在不脱离公开内容的范围内，作业空间230共享节点115。作业空间230的尺寸可以通过用户或管理者人工输入或基于作业参数、策略、和/或任意其他合适的特征来动态确定。在具体的实施例中，如以下所述那样，调度器515根据调度算法确定一个或多个作业空间230的尺寸。

图6A-6B说明根据系统100的管理图形用户接口400的不同实施例。通常，通过使用GUI126而将管理GUI400提供给客户机120。一般，管理GUI400将不同的管理交互屏幕或显示提供给系统管理者和/或将不同的作业提交或外观屏幕提供给用户。这些屏幕或显示由所收集的信息的、组成不同视图的图形元素组成。例如，GUI400可以提供栅格110的物理完好的显示(图6A所示)或栅格110中节点115的逻辑位置或拓扑结构(图6B所示)。

图6A说明了显示400a的实例。显示400a包括被提供给管理者以有效管理节点115的信息。该说明性实施例包括具有栅格110的逻辑“图片”或屏幕镜头的标准网页浏览器。例如，该图像提供栅格110的物理状态和组成节点115。每一节点115是任意数量的颜色之一，每一颜色表示不同的状态。例如，故障节点115是红色，使用或被分配的节点115是黑色，以及未被分配的节点115被阴蔽。此外，显示400a允许管理者移动节点115之一上的指针并且观看其不同的物理属性。例如，向管理者提供包括“节点”、“可用性”、“处理器利用”、“存储器利用”、“温度”、“物理位置”以及“地址”的信息。当然，这些仅是数据字段实例并且任意合适的物理或逻辑节点信息可以显示给管理者。显示400a也允许管理者旋转栅格110的视窗或执行任意其他适合的功能。

图6B说明了显示400b的实例。显示400b提供栅格100的逻辑状态的视图或图像。该说明性实施例提供定位在栅格110内的虚拟群集220。显示400b进一步显示定位在群集220内以执行一个或多个作业150的两个作业空间230实例。显示400b允许管理者移动图形虚拟群集220上的指针以观看通过不同状态(诸如已分配或未分配)分组的节点115的数量。此外，管理者移动作业空间230之一上的指针以至于提供合适的作业信息。例如，管理者能够观看作业名称、启动时间、节点数量、估计的终止时间、处理器使用、I/O使用以及其他。

应该理解：管理GUI126(分别通过显示400a和400b来描述)仅为了说明目的并且可以包括零、一些或所有说明的图形元件和未示出的附加的管理元件。

图7说明了根据系统100的群集管理引擎130的一个实施例。在该实施例中，群集管理引擎130包括多个子模块或部件：物理管理器505、虚拟管理器510、调度器515以及局部存储器或变量520。

物理管理器505是用于确定不同节点115的物理完好并基于所确定的完好有效管理节点115的任意软件、逻辑、固件、或其他模块。物理管理器使用该数据以有效确定并响应节点115故障。在一实施例中，物理管理器505通信耦合到多个代理132，每一个代理驻留在一个节点115上。如上所述，代理132至少收集物理信息并传送给管理器505。物理管理器505可进一步用于经由网络106将警报传送给客户机120处的系统管理者。

虚拟管理器510是用于管理虚拟群集220和节点115的逻辑状态的任意软件、逻辑、固件或其他模块。通常，虚拟管理器510将节点115的逻辑表示链接到节点115的物理状态。基于这些链接，虚拟管理器510产生虚拟群集220并且处理这些群集220的不同变化，诸如响应节点故障或增加HPC处理的(系统或用户)请求。虚拟管理器510也可以将虚拟群集220的状态诸如未分配的节点115传送给调度器515以进行未执行的动态回填、或排队、HPC处理和作业150。虚拟管理器510可以进一步利用具体的节点115来确定作业150的兼容性并且将该信息传递给调度器515。在一些实施例中，虚拟管理器510可以是表示单个虚拟群集220的对象。

在具体的实施例中，群集管理引擎130包括调度器515。调度器515包括用于根据调度算法将节点115分配到作业150的硬件、软件、或嵌入逻辑部件或一个或多个所述部件。在具体的实施例中，调度器515是插座(plugin)。在具体的实施例中，响应接收作业150的群集管理引擎130，群集管理引擎130调用调度器515以将一个或多个节点515分配给作业150。在具体的实施例中，当群集管理引擎130调用调度器515以分配一个或多个节点515给作业150时，群集管理引擎130标识栅格110中的节点115为可用于分配给作业150以告知调度器515。作为非限制性实例，当群集管理引擎130调用调度器515以分配一个或多个节点115给作业150时，群集管理引擎130将可用以分配给作业150的栅格110中所有节点115的列表传送给调度器515。在具体的实施例中，只有当可用于分配给作业队节点115的数量大于或等于作业150所请求的节点115的数量时，群集管理引擎130调用调度器515以将一个或多个节点115分配给作业150。

如上所述，在具体的实施例中，栅格110是一种三维环面开关166，每一开关耦合到四个CPU164。调度器515将栅格110逻辑配置为环面节点115。环面尺寸[x，y，z]开关166提供六种可能的逻辑配置：[4x，y，z]、[x，4y，z]、[x，y，4z]、[2x，2y，z]、[2x，y，2z]和[x，2y，2z]。当调度器515将一个或多个节点115分配给作业150时，调度器515为作业150选择最合适的逻辑配置。

信息传递接口(MPI)是一种用于作业150中的处理之间通信的标准。在具体的实施例中，调度器515将MPI Rank分配每一节点115，所述每一节点115分配给作业150。对于包括N个处理的作业150来说，调度器515将0和N-1之间的唯一整数Rank分配给每一处理。为将信息传送给作业150中的第一处理，作业150中的第二处理可以规定第一处理的Rank。同样，为从作业150的第一处理接收信息，作业150中的第二处理可以规定第一处理的Rank。调度器515也可以定义一个或多个广播组，每一广播组有利于将广播组中的处理的信息传递给该广播组中所有其他的处理。为从广播组的第一处理中接收信息，该广播组中的第二处理可以指定所述广播组。

在具体的实施例中，调度器515处理三种类型的请求：“空间的(spatial)”、“紧凑的”和“任何的”。对“请求”的引用包括适当地包括作业150，反之亦然。当用户发送作业150给HPC服务器102，所述用户可以规定请求类型。“空间的”请求包括空间描述的作业150。一级现有的MPI应用程序假设作业150中处理直接的空间关系。天气模型是一个实例。为处理包括天气模型的作业150，HPC服务器102使用包括经度和纬度(或相似的坐标系统)的两位栅格以分割地球表面并且将时区分成离散时间步。作业150的每一处理模仿具体区域的天气。在每一时间步开始处，所述处理与临近所述处理的四个处理的每一处理交换边界值并且然后计算具体区域的天气。为了处理包括天气模型的作业150，HPC服务器102可以使用包括经度、纬度和高度(或相似的坐标系统)的三维栅格而不是二维栅格以划分地球的表面。

对于假设作业150中处理之间的空间关系的MPI应用程序来说，用户可以为作业150请求节点115的三元组{Sx，Sy，Sz}。如果所有的维数S大于一，那么所述请求是一个三维请求。如果所述维数S之一等于一，那么所述请求是一个二维请求。如果所述维数S中的两个等于一，那么所述请求是一个一维请求。为了将节点115分配给所示请求，调度器515以如下方式将空间坐标映射到MPIRank：[x，y，z]→x×Sy×Sz+y×Sz+z。Sx，Sy和Sz表示所述请求的尺寸，x处于零和Sx之间，y处于零和Sy之间，以及z处于零和Sz之间。为将节点115分配给一个二维请求，调度器515以如下方式将空间坐标映射到MPI Rank：[x，y]→x×S y+y。在具体的实施例中，为将空间坐标映射到MPI Rank，调度器515首先沿着栅格110的z轴增加，然后沿着栅格110的y轴增加，然后沿着栅格110的x轴增加。为调节有关将空间坐标映射到MPI Rank的调度器515的不正确的假设，例如首先沿着栅格110的x轴增加，然后沿着栅格110的y轴增加，然后沿着栅格110的z轴增加，群集管理引擎130将一个被请求的作业150例如{Sz，Sy，Sx}提供给调度器515。

“紧凑的”请求包括非空间描述的作业150。调度器515可以将节点115分配给紧凑的请求以最小化被分配给所述紧凑请求的每一节点115对之间的通信距离(或跳跃总数)。“任何的”请求包括需要少量或没有处理间通信的作业150。调度器515分配任意节点115组以满足任意请求。所述作业150提供给调度器515一个机会以填满由栅格110中的碎裂而引起的中空。

当用户向HPC服务器102提交作业150时，所示用户也可以在作业150上规定侵占性标志。在具体的实施例中，侵占性标志是一种零和一之间的浮点数量，其表示为将节点115分配给作业150目的而被分配给调度器515的活动余地的程度。较高的数量比较低的数量能够提供给调度器515更多的活动余地。如果用户向HPC服务器102提供一个空间请求并且将该空间请求上的侵占性标志设置为零，那么只有在节点115可用于容纳所述空间请求时，调度器515调度作业150。在具体的实施例中，如果用户向HPC服务器102提供一个空间请求并且将该空间请求上的侵占性标志设置为大于零的数字，那么调度器515试图调度作业150，但是如果调度器515不能够容纳所述空间请求，那么将调度作业150以作为紧凑的请求。在具体的实施例中，紧凑的请求允许被分配给所述紧凑请求的节点115对之间的非限制的跳跃总数。调度器515能够一直传送所述请求，因为如上所述，只有当可用于分配的节点115的数量大于或等于请求的节点115的数量时，群集管理引擎130调用调度器515。在具体的实施例中，紧凑的请求上的侵占性标志表示被分配给所述紧凑请求的节点115对之间的跳跃总数的限制。在所述实施例中，跳跃总数的限制等于1/(1-α)，其中α是侵占性标志。

在具体的实施例中，当群集管理引擎130调用调度器515以将一个或多个节点115分配给作业150时，群集管理引擎130将以下的输入提供给调度器515：请求的节点115的数量；请求类型；作业150的尺寸；作业150上的侵占性标志；栅格110的基于开关的尺寸(调度器515随后调整以确定栅格110的基于节点的尺寸)；每一开关166的节点115的数量(在具体的实施例中，其等于4)；可用于分配给作业150的节点115的数量以及可用于分配给作业150的一个或多个节点115的识别(诸如例如可用于分配给作业150的所有节点115的列表)。在具体的实施例中，RequestedNodes表示所请求的节点115的数量，RequestType表示请求的类型，RequestedSize(包括阵列)表示作业150的尺寸，AggressiveFlag表示作业150上的侵占性标志，TorusSize(包括阵列)表示栅格110的基于开关的尺寸，NodesPerSwitch表示每一开关166的节点115的数量，NumFreeNodes表示可用于分配给作业150的节点115的数量，以及FreeNodeList(包括阵列)表示可用于分配给作业150的一个或多个节点115。

在具体的实施例中，当调度器515调度(或试图调度)作业150时，调度器515提供随后的输出：被分配给作业150的节点115(诸如被分配给作业150的节点115的列表)的标识；分配给作业150的每一节点的MPI Rank；以及一个返回值，该返回值表示(1)调度器515调度作业150，(2)调度器515没有调度作业150，或(3)调度器515从没有调度作业150。

在具体的实施例中，为将节点115分配给作业150，调度器515首先初始化用于调度作业150的变量，然后根据该变量调度作业150，然后转换所述调度(或结果)以在群集管理引擎130中处理。三个变量——SpatialAllowed，CompactAllowed，以及AnyAllowed——表示所允许的调度类型。调度器515使用以下的逻辑实例来初始化SpatialAllowed，CompactAllowed，以及AnyAllowed：

·如果NodesRequested＝1

o SpatialAllowed＝False

o CompactAllowed＝False

o AnyAllowed＝True

·否则如果RequestedType＝SPATIAL

o SpatialAllowed＝True

o AnyAllowed＝False

o 如果AggressiveFlag>0

·CompactAllowed＝True

o 否则

·CompactAllowed＝False

·否则如果RequestedType＝Compact

o SpatialAllowed＝False

o CompactAllowed＝True

o AnyAllowed＝False

·否则如果RequestedType＝Any

o SpatialAllowed＝False

o CompactAllowed＝False

o AnyAllowed＝True

在具体的实施例中，调度器515确定栅格110的基于开关的尺寸的方向以指示栅格110的较小维数之前的栅格110的较大维数。TorusMap(包括阵列)指示栅格110的基于开关的尺寸，所述栅格110的基于开关的尺寸被确定方向以指示栅格110的较小维数之前的栅格110的较大维数。调度器515将TorusMap施加到在FreeNodeList中标识的所有节点115。InverseTorusMap(包括阵列)是一种倒置的TorusMap，并且在将所述列表返回到群集管理引擎130以进行处理之前，调度器515将InverseTorusMap施加到被分配给作业150的节点115的列表。作为非限制性实例，如果群集管理引擎130将基于开关的环面尺寸14×16×15传送给调度器515，调度器515将TorusMap设置为{2，0，1}。所述基于开关的环面尺寸变成16×15×14，对于具有指数{x，y，z}的FreeNodeList中的节点115来说，在调度器515施加TorusMap之后，节点115的指数是{y，z，x}。上述实例的InverseTorusMap是{1，2，0}

在具体实施例中，NumMapDimension表示当将基于开关的环面转换为基于节点的环面时的用于修改的维数。MapDimsion[2]和MapMod[2]提供用于修改的维数的指数以及用于修改的维数的相应乘数。调度器515将用于修改的维数之一与4相乘或将两个用于修改的维数都与2相乘。从而，根据最初描述的开关，调度器515确定实施哪一个乘法，然后修改环面的尺寸。调度器515根据RequestType确定将应用哪一个乘法。

在具体的实施例中，调度器515将一种或多种几何变化应用到请求以产生满足所述请求的网格列表。网格包括嵌入栅格110内的框。起始点[Sx，Sy，Sz]和终点[Ex，Ey，Ez]定义一个网格。如果网格在一或多维中具有的起始点大于终点，那么网格在一或多维中“歪曲”。作为非限制性实例，具有起始点[3，7，5]和终点[2，9，4]的网格在x和y维中歪曲。如果[Sx≤x≤Ex]、[Sy≤y≤Ey]以及[Sz≤z≤Ez]，那么栅格110中的点[x，y，z]驻留在非歪曲网格中。在调度器515产生满足所述请求的网格列表之后，调度器515通过列表进行循环直到调度器515识别一个网格，该网格相对于可用于分配请求的一组节点115是可调度。通常，三维请求倾向于导致满足所述请求的六个网格，两维请求倾向于导致十个满足所述请求的网格，以及一维请求倾向于导致上百个满足所述请求的网格。在具体的实施例中，调度器515将基于节点的环面设置为两或三维请求以最小化满足所述请求的网格数量。

为初始化用于调度(将一个或多个节点115分配给)一维请求，调度器515将栅格110中开关166的y轴和z轴设置为一种2×2配置的节点115。调度器515映射作业150以至于栅格110中的开关166的z轴是一个无用的维数。然后调度器515沿着z轴将作业150折叠到y轴。所以，在具体的实施例中，将以下内容应用到一维请求中：

NumMapDimensions＝2

MapDimension[0]＝1

MapDimension[1]＝2

MapMod[0]＝2

MapMod[1]＝2

[n]表示具有取值范围为0到1-n的指数的一维阵列。作为非限制性实例，在适当情况下，α＝{4，6，2}对应于α[0]＝4，α[1]＝6，以及α[2]＝2。

在具体的实施例中，调度器515也将栅格110中开关166的y轴和z轴设置为节点115的2×2配置以初始化用于调度二维请求的参数。在具体的实施例中，调度器515将二维请求折叠成为不使用的三维以产生用于调度的更加紧凑的形状。因为许多所述的折叠是可能的，调度器515选择产生所述折叠的最大数量的配置(其不同于节点115的2×2配置)。调度器515检测用于二维请求的六种可能的配置并且计算用于六种可能配置的可能折叠的数量。在具体的实施例中，调度器515选择一种允许最大数量的可能的折叠的配置。在具体的实施例中，如果两个1×4配置之间发生关系，那么调度器515首先选择修改z轴的1×4配置，然后选择修改y轴的1×4配置。在具体的实施例中，如果1×4的配置与2×2的配置之间发生关系，那么调度器515选择所述2×2配置。在具体的实施例中，如果两个或多个2×2配置之间发生关系，那么调度器515首先选择修改y和z轴的2×2配置，然后选择修改x和z轴的2×2的配置，然后选择修改x和y轴的2×2的配置。在具体的实施例中，除了三维请求允许彼此之间相对唯一的6个方向(旋转)而不是允许折叠之外，当调度器515初始化用于调度二维请求的变量时，调度器515初始化用于调度三维请求的变量。

在具体的实施例中，为初始化用于调度紧凑请求的变量，调度器515将所述紧凑请求的z轴乘以4以产生1×4的配置。使用用于处理紧凑请求的1×4的配置有利于使用与分配给所述紧凑请求的开关166相耦合的所有节点115，这样依次减少了栅格110中开关点处的碎裂。在具体的实施例中，调度器515同样地初始化用于调度任何请求的变量。

一个分区是包括可用于调度的栅格110内所有的节点115的最小网格。PartStart[3]表示所述分区的起始坐标，PartEnd[3]表示所述分区的终点坐标，PartSize[3]表示所述分区的尺寸，以及PartWraps[3]表示所述分区是否歪曲。调度器515可以构造一个分区以减少检索满足请求的节点115的长度。分区可以小于栅格110。对于i＝0，1和2，PartStart[i]包括FreeMesh(包括阵列)中所有可能的i个坐标的最小值并且PartEnd[i]包括FreeMesh中所有可能的i个坐标的最大值。PartSize[i]＝PartEnd[i]-PartStart[i]+1。如果PartSize[i]＝TorusSize[i]，那么PartWraps[i]是True。调度器515将NodeInUse(包括阵列)设置为NODE_NOT_IN_USE以用于FreeMesh中的所有节点并且设置为NODE_IN_USE以用于其他节点。

在具体的实施例中，FreeY[i，j，k]包含沿着线{i，j，k}到{i，TorusSize[1]-1，k}的自由节点115的数量。FreeX[i，j，k]包括沿着线{i，j，k}到{TorusSize[0]-1，k}的自由节点115的数量。如下所述，调度器515使用FreeY[i，j，k]和FreeX[i，j，k]以执行扫描算法。在具体的实施例中，只有当SpatialAllowed或CompactAllowed是True时，调度器515构建FreeY[i，j，k]和FreeX[i，j，k]。

如果SpatialAllowed是True，那么调度器515尝试用于调度请求的不同的构造。尺寸为S＝{Sx，Sy，Sz}的空间作业具有六个唯一的方向：{Sx，Sy，Sz}、{Sx，Sz，Sy}、{Sy，Sx，Sz}、{Sy，Sz，Sx}、{Sz，Sx，Sy}和{Sz，Sy，Sx}。所述六个方向对应于所述调度器515可以施加到网格的4个唯一的90°旋度和两个唯一的180°旋度。如果任一二维彼此相等，那么仅三个唯一的方向是可用的。当调度器515调度一网格时，其考虑所有的可能的方向。如果作业150是二维的，也就是一维的作业150等于1，调度器515以一种可折叠的方式将作业150的两个使用的维数、也就是大于1的作业150的维数折叠成作业150未使用的维数，也就是等于1的作业150的维数，以便产生更紧凑的三维网格。如果调度器515对一个不是所述折叠的长度的整数倍的维数进行折叠，那么最后的折叠将短于所有先前的折叠，这样将导致二维网格链接到三维网格。如果作业150是一维的，那么调度器515可将作业150折叠成两个未使用的维数之一。调度器515可接着将两个结果的维数中的任意一个折叠成剩余未使用的维数。一般地讲，网格所产生的形状将是四个网格的串联。

图8说明了被折叠为y维数的一维请求的实例。在图8中，调度器515使用折叠长度为4来折叠所述一维请求{1，1，11}成为y维数以产生二维网格{1，2，4}和连接到所述二维网格的一维网格{1，1，3}。调度器515将第一折叠编号为零，将第二折叠编号为一，将第三短折叠编号为二。当调度器515沿着折叠将MPIRank分配给节点115时，随着z值沿着偶编号的折叠增加并且随着z值沿着奇数编号的折叠减少时，MPI Rank增加。作为非限制性实例，[0，0]处用于节点115的MPI Rank可以是零，[0，1]处用于节点115的MPI Rank可以是一，[0，2]处用于节点115的MPI Rank可以是二，以及[0，3]处用于节点115的MPI Rank可以是三。在[1，3]处用于节点115的MPI Rank可以是四，[1，2]处用于节点115的MPI Rank可以是五，等等。在z＝0处开始串联，由于所述折叠具有偶数。如果调度器515使用完整的折叠的奇数来折叠所述请求，那么在z＝3处开始串联，并且持续向内朝着x＝0。在具体的实施例中，调度器515可以考虑类似于坐标的折叠。存在其他类型的折叠。作为非限制性实例，折叠产生阶梯形状。调度器515可以禁止一维作业150上的某些折叠。如上所述，在具体的实施例中，调度器515对一维作业150折叠两次。第二折叠将调度器515进行第一折叠的维数进行折叠或将调度器515折叠成第一的维数进行折叠。在图8中，调度器515对z维数进行折叠并且将其折叠为y维。如果第二折叠对调度器515进行第一折叠的维数进行折叠，调度器515可以为总共4个网格产生三个串联。在具体的实施例中，调度器515只允许两个串联。结果，当调度器515对一维作业 150进行调度时，限制第二折叠以对调度器515折叠为第一的维数进行折叠，除非第一折叠不产生串联。如果作业150的尺寸是折叠长度的整数倍，则不产生串联。在具体的实施例中，所述限制确保了调度器515仅允许两个串联。在具体的实施例中，调度器515首先构建满足请求的所有可能的网格。如果所述请求是一或二维，那么调度器515构建每一种可能的类似于坐标的折叠以及每一所述折叠的可能的方向。如果所述请求是三维，那么调度器515构建所述请求的每一种可能的方向。在具体的实施例中，如下所述，调度器515使用Try

Structure记录每一种所述构造。

如果CompactAllowed是True，调度器515构建一种包含请求数量的节点115的紧凑网格。调度器515指定所述网格一种最佳匹配并且在BestFit(包括阵列)中存储所述网格。作为非限制性实例，N为所请求的节点115的数量，Q为N的立方根舍取为整数。调度器首先将BestFit设置为{Q，Q，Q}。如果N＝Q³，那么运行调度器515。否则，如下所述，调度器515根据BuildCompactFit函数将对BestFit增加一以上维数。然后调度器515构建具有大于等于BestFit的维数并小于等于栅格110的维数的所有网格，并且使用Fit(包括阵列)记录所述网格。

然后调度器515从Fit中除去不期望的网格。如上所述，在具体的实施例中，栅格110是一种三维环面开关166，每一开关耦合到四个CPU164。调度器515通过一维中的四个因数或两维中的两个因数来修改所述环面以解释每一开关166包括四个CPU164的栅格110。为增加似然性，调度器515将满足请求，以至于当开关166处的一CPU164执行处理时，开关166处的所有CPU164执行处理，调度器515仅保持具有尺寸为一个或多个修改维数的网格，所述维数是倍增因数的整数倍。作为非限制性实例，如果调度器515将y维中的开关166的环面乘以2并且将z维中开关166的环面乘以2，那么调度器515将仅保持Fit中具有偶数y和z维数的网格。

然后，调度器515根据剩余网格中最大跳跃总数分类Fit中剩余的网格。尺寸为{Sx，Sy，Sz}的网格中任意两个节点之间的最大距离是(Sx+1)+(Sy-1)+(Sz-1)。如果两个网格具有彼此相等的最大跳跃总数，那么调度器515将接近于立方体的网格放置在另一网格之前。作为非限制性实例，M₁＝{4，6，16}并且M₂＝{8，9，9}具有相同的最大距离，但是调度器515将M₂放置在 M₁之前。

即使调度器515不从Fit中删除不希望的网格，调度器515也不会产生包括至少N个节点115的所有网格。作为非限制性实例，如果N等于27并且BestFit＝{3，3，3}，那么Fit将不包括网格{1，1，27}。网格{1，1，27}将不会产生适当数量的网格并且一直产生至少一个满足请求的网格，因为Fit包括等于栅格110的网格并且只有当N小于或等于栅格110中节点115的数量时，群集管理引擎130调用调度器515。

如果AnyAllowed是true，那么为构建一个或多个自由网格，调度器515利用作为外层循环的x轴循环至NodeInUse，接下来利用y轴，以及利用作为内部循环的z轴至NodeInUse，直到调度器515识别自由节点115。自由网格包括仅含有自由节点115的网格，并且自由节点115包括可分配给作业150的节点115。调度器515构建NumFreeMeshes和FreeMesh[NumFreeMeshes]。NumFreeMeshes表示栅格110中自由网格的数量，而FreeMesh是一种为栅格110中每一自由网格识别栅格110中一个或多个自由网格结构的列表。作为非限制性实例，节点115的指数可以是{i1，j1，k1}。调度器515增加z轴，直到调度器515识别非自由节点115，诸如例如{i1，j1，k2}。调度器515将FreeMesh.start[2]设置为k1，将FreeMesh.end[2]设置为k2-1。FreeMesh.start[2]对应于沿着z轴的自由网格的起始值，FreeMesh.end[2]对应于所述自由网格的最终值。然后调度器515在开始处j1增加y轴以识别第一值j2，以致于{i1，j2，k1}到{i1，j1，k2-1}之间的线包括至少一个非自由节点。调度器515然后将FreeMesh.start[1]设置为j1，将FreeMesh.end[2]设置为j2-1。调度器515然后在起点i1处增加x轴，以识别第一值i2，以致于{i2，j1，k1}到{i2，j2-1，k2-1}的平面包括至少一个非自由节点。然后调度器515将FreeMesh.start[0]设置为i1，将FreeMesh.end[0]设置为i2-1。调度器515重复上述处理，调度器515经过栅格110中的所有节点115。上述处理不会产生唯一的自由网格组。以不同顺序而进行的循环往往产生不同的自由网格组，但是仅在两个或多个自由网格彼此之间共享边界时。全部由节点115包围的自由网格总是唯一的。图9和10说明了在两维情况中使用y轴作为内部循环和使用x轴作为内部循环之间的差别。图9说明了使用y轴作为内部循环而构建的两个自由网格，而图10说明了使用x轴作为内部循环而构建的两个自由网格。在图9中，区域530包括使用中的节点115，区域532a是第一自由网格，区域532b是第二自由网格。同样，在图10中，区域530包括使用中的节点115，区域532a是第一自由网格，区域532b是第二自由网格。

在具体的实施例中，调度器515使用第一调度算法以调度空间请求，使用第二调度算法以调度紧凑请求，以及使用第三调度算法以调度任何请求。第一和第二调度算法彼此相同，但是彼此之间使用的扫描算法相对不同。如果调度器515调度作业150，调度器515根据MPIRank将被分配给作业150的节点115列举在AssignedNodeList，也就是AssignedNodeList[i]具有MPI Ranki。

为了调度具有尺寸为{Sx，Sy，Sz}的空间请求，调度器515使用扫描算法以为所述空间请求查找NodeInUse中的起始点。接下来的实例逻辑提供了一种扫描算法实例的实例描述。PartStart是起始点，PartEnd是分区的终点，Tx，Ty以及Tz分别是x，y以及z维中环面的尺寸。

Forx＝PartStart[0]to PartEnd[0]

Fory＝PartStart[1]to PartEnd[1]

For z＝PartStart[2]to PartEnd[2]

Hit＝True

Fori＝xtox+Sx-1

Forj＝ytoy+Sy-1

Fork＝z toz+Sz-1

If(NodeInUse[i mod Tx，j modTy，k mod Tz)＝

NODE_IN_USE

Hit＝False

End If

End For

If(Hit＝True)

Return True

End If

End For

Return False

在具体的实施例中，扫描算法用如下所示的最内部循环中增加的Count值替换上述Hit标志：

Count＝0

Fori＝xtox+Sx-1

Forj＝ytoy+Sy-1

Fork＝ztoz+Sz-1

If(NodeInUse[i mod Tx，j modTy，kmodTz)＝NODE_NOT_IN_USE

Count＝Count+1

End If

End For

If(Count≥RequestedNodes)

Return True

End If

上述逻辑的效率相对低下，因为调度器515评估NodeInUse中每一点等于Sx×Sy×Sz倍。在上述紧凑请求的扫描中，即，当z循环从z1增加到z1+1时，i和j内部循环没有改变并且k循环仅在终点发生变化。结果，从{x，y，z1}到{x+Sx，y+Sy-1，z1}的二维网格从进一步的计算中排除并且调度器515将从{x，y，(z1+1)+Sz-1}到{x+Sx-1，y+Sy-1，(z1+1)+Sz-1}的二维网格添加到进一步的计算中。i，j和k内部循环沿着尺寸为{Sx，Sy，1}的z轴对二维网格序列中的自由节点115进行计数。z循环去除一个网格并且添加另一个。在y循环中，沿着y轴出现相同的效果。FreeX和FreeY(都包括阵列)有利于减少处理时间。在具体的实施例中，调度器515使用以下的算法来扫描紧凑请求：

定义一个阵列，zPlane[TorusSize[2]]以存储二维网格数量。

如下计算x，y以及z循环的终点：

o 对于i＝0到2

·如果PartWraps[i]＝True，end[i]＝PartEnd[i]

·否则end[i]＝PartEnd[i]-Size[i]

o 现在x将从PartStart[0]循环到End[0]等等。

·x循环

o 对于每个z＝PartStart[2]到PartEnd[2]，重新计算网格的zPlane

{x，PartStart[1]，z}to{x+Sx-1，PartStart[1]+Sy-1，z}

·在特定实施例中，调度器515将在此使用三个循环。此处使用的FreeY减少到2的循环的数目：对x的一个循环和对z的一个循环。FreeY[x，PartStart[1]，z]-FreeY[x，PartStart[1]+Sy，2]沿线{x，PartStart[1]，z}到{x，partStart[1]+，Sy-1，z}在内提供自由节点115的数目。

o 为以下的y循环而设置NewX＝True

y 循环

o 如果NewX＝True

·不做任何操作。

o 否则

·更新zPlane

·对于每个z＝PartStart[2]到PartEnd[2]，

·在Zplane[z]中从线段{x，y-1，z}到{x+Sx-1，y-1，z}提取自由节点115。

o 利用FreeX[x，y-1，z]-FreeX[x+Sx，y-1，z]以避免x之上的循环。

·在线段{x，y+Sy-1，z}到{x+Sx-1，y+Sy-1，z}中将自由节点115添加到zPlane[z]。

o 利用FreeX[x，y+Sy-1，z]-FreeX[x+Sx，y+Sy-1，z]以避免x之上的循环。

o 为下一个y增量而设置NewX＝False

o 为以下的z循环而设置NewY＝True

z 循环

o 如果NewY＝True

·从z＝PartStart[2]到z＝PartEnd[2]总和zPlane并将结果记录在Count中。

o 否则

·从Count中提取zPlane[z-1]

·计算zPlane[z+Sz-1]，其是如上所述的从{x，y，z+Sz-1}到{x+sX-1，y+Sy-1，z+Sz-1}的二维网格中的自由节点115的总和，利用FreeX来减少从二到一的循环的数目。

·将zPlane[z+Sz-1]添加到Count

o 如果Count≥RequestedNodes，返回True

在具体的实施例中，调度器515应用一个或多个以下的修改以访问在维数中歪曲的分区：(1)如果维数中的指数超过了阵列限度，那么调度器515将模函数应用到任意阵列参考之前的指数；以及(2)如果所述分区在x维或y维中歪曲，为计算从点a到点b的线段的自由节点115，调度器515计算两个线段的自由节点115，一个是从点α到x或y维中的分区的末端，另一是从所述分区开始到b点。

在具体的实施例中，应用到空间请求的扫描算法与应用到紧凑请求的上述扫描算法相似。在具体的实施例中，应用到空间请求的扫描算法与应用到紧凑请求的扫描算法之间的不同包括：(1)代替调度器515识别网格中具有具体数量的点，调度器515寻找其上所有的节点115是自由节点的网格中的点，这样往往减少了存储器引导；以及(2)调度器515需要处理一个或多个串联的网格，因为如上所述，调度器515可以处理一维请求或二维请求，所示二维请求被折叠以产生基本网格，该基本网格具有等于两个串联到该基本网格上的附加的网格。在具体的实施例中，用于扫描算法的所述修改有助于减少与调度器515相关联的最大运行时间，其中所述调度器515通过一个或多个数量级来调度16×16×16的配置。

为调度空间请求，调度器515使用以下调度算法，即将扫描算法应用到Try列表中每一Try结构，直到调度器515识别一个可以调度的Try Structure。如果所述列表中不存在可以调度的Try结构，并且空间请求上的侵占性标记等于0，那么调度器515返回到群集管理引擎130而不调度所述空间请求。否则，调度器515使用紧凑调度算法以试图调度所述空间请求。

在具体的实施例中，根据空间算法调度请求包括以下三个变换：两个折叠一个旋转。调度器515使用以下Try中的字段来跟踪所述变换：

·Try.rMap是用于旋转的映射函数。Try.rMap是一种具有三个元素的阵列，该阵列映射点的指数。作为非限制性实例，Try.rMap＝{1，0，2}意味着指数0映射到1，指数1映射到0，以及指数2映射到2，以至于在所述映射下，{x，y，z}→{y，x，z}。

·Try.irMap是Try.rMap的倒置。

·Try.NumFoldMaps表示产生Try结构的折叠的数量。

·Try.foldLength是指示折叠长度的阵列。

·Try.foldFrom是指示被折叠维数的指数的阵列。作为非限制性实例，Try.foldFrom[i]＝2表示i折叠折叠z轴。

·Try.foldTo是指示被折叠成的维数的指数的阵列。

·Try.foldFix是指示保持固定的维数的指数的阵列。

在具体的实施例中，在调度器515使用Try结构确定作业150在栅格110中的起始点处是可调度的之后，调度器515如下分配MPI Rank：

·调度器515将以倒置旋转映射应用到起始点以便将所述起始点映射到预变换的网格。调度器515构造折叠以脱离被固定的网格的起始点，以至于调度器515不需要施加倒置折叠。

·调度器515循环通过所述预变换的网格以产生MPI Rank。如上所述，在具体的实施例中，x轴是外部循环，y轴是中间循环，z轴是内部循环。

·调度器515根据调度器515将所述变换施加到预变换网格的顺序，也就是调度器515在所述预变换网格中折叠0，然后折叠1，然后旋转所述点以得到点{x’，y’，z’}，将被应用到所述预变换网格的变换应用到所述循环中的每一点{x，y，z}。然后调度器515将所述节点{x’，y’，z’}插入到AssignedNodeList的末端。

在具体的实施例中，紧凑调度算法将扫描算法应用到Try结构列表中的每一网格，直到所述紧凑调度算法识别出处于工作状态的Try结构。所述列表中的网格数量相对较大。作为非限制性实例，对于包括16×16×16个节点115的环面以及用于100个节点115的请求来说，BestFit＝{4，4，5}，其导致Try结构列表中超过了2000的以上网格。虽然希望将对分检索应用到Try结构列表，但Try结构列表的对分检索在具体的实施例中不起作用。包括条件C的对分检索不起作用，除非(1)如果对于元素i，C是true，那么对于大于或等于i的所有j来说，C是ture，(2)如果对于元素i，C是false，那么对于小于或等于i的所有j来说，C是false。在具体的实施例中，Try结构列表的对分检索不起作用，因为存在以下可能性，即例如使用网格M1＝{4，4，4}的二进制扫描将发现满足请求的足够的节点，同时例如使用网格M2＝{2，2，10}的扫描将不会发现满足请求的足够的节点，虽然在Try结构列表中M2高于M1。在具体的实施例中，最大距离的对分检索起作用。如果调度器515根据最大距离对Try结构列表中的网格进行分组，然后，如果调度器515识别具有最大距离i的所述列表中的网格的一个适合，那么对于所有的大于或等于i的j来说，具有最大距离j的所述列表中至少一个网格也将适合。如果具有最大距离i的所述列表中的不存在适合的网格，那么具有小于或等于i的最大距离的列表中也不存在适合的网格。作为非限制性实施例，假设{x，y，z}是一种适合的具有最大距离i的网格。所以{x，y，z+1}具有的最大距离为i+1，因为{x，y，z+1}覆盖了{x，y，z}，并且{x，y，z+1}也起作用。将归纳应用到所有大于或等于i的j。如果关于具有最大距离i-1的任意网格{x，y，z}来说，具有最大距离i的列表中没有网格起作用，那么{x，y，z+1}具有最大距离i并且不适合。{x，y，z}也不适合，因为{x，y，z+1}覆盖了{x，y，z}。因此，调度器515在初始化期间构建了MaxDistance[NumMaxDistance，2]。

在具体的实施例中，Fit中网格的对分检索并不确保最佳适合，但是在最佳适合上提供了一种合理有利的上界。在具体的实施例中，Fit中网格的对分检索是有效的，也就是，为大约1000个网格产生大约10次扫描。调度器515使用上界以在最大长度上运行对分检索并且从上界向下运行线性查找。在具体的实施例中，向下的线性查找往往是更加有效的。

调度器515运行Fit上对分检索并且返回HighFit和HighStart[3]。HighFit是满足请求的Fit的指数，HighStart是栅格110中Fit的起始点。运行向下线性查找的算法以HighFit和HighStart开始。在具体的实施例中，调度器515减少当前HighFit网格的最大距离。然后调度器515循环至包括最大距离的所有网格，直到调度器515识别了满足所述请求的网格。如果调度器515识别了满足所述请求的网格，那么调度器515将所述网格设置为HighFit，再一次减少最大距离，并且重复所述处理。如果调度器515没有识别所述网格，那么退出所述算法，当前HighFit是最佳适合。如果调度器515不能识别用于具体的最大距离的适合，那么调度器515不能识别用于较短距离的适合。

调度器515循环至Fit并且将一个或多个节点115插入到AssignedNodeList的端部。所述三个循环的顺序取决于调度器515如何将基于开关的环面映射到基于节点的环面。如果调度器使用一维中的4×1配置对基于开关的环面进行映射，那么所述一维是内部循环。如果调度器515使用二维中的2×2配置对基于开关的环面进行映射，那么所述二维是最内部循环。

为调度任意请求，调度器515循环至FreeMesh并且填充所述任意请求，直到调度器515将请求的节点115的数量分配给所述任意请求。

当调度器515循环至FreeMesh时，调度器515逐渐地将节点115插入到AssignedNodeList。在具体的实施例中，调度器515以下方式循环至FreeMesh：

z轴是最内部循环。当调度器515将基于开关的环面转换为基于节点的环面时，调度器515将z轴扩展达到4倍的因数。将z轴作为最内部循环往往能够避免与开关116相耦合的CPU164破裂。

FreeMesh中两个剩余的维数中较小的一个是中间循环，并且较大的一个是最外部循环。

调度器515根据MPI Rank将使用基于节点的坐标的选定节点115列表于AssignedNodeList。AssignedNodeList[i，0]是MPI Ranki的节点115的x坐标，AssignedNodeList[i，1]是MPI Ranki的节点115的y坐标，AssignedNodeList[i，2]是MPI Ranki的节点115的z坐标。FreeNodeList是基于开关的坐标中传到调度器515的可用节点115的列表。在具体的实施中，为设置FreeNodeList中的mpiRank字段，调度器515使用以下实例算法：

·对于i＝0到NumFreeNodes-1

o 将AssignedNodeList[i]转换为基于开关的坐标并将其添加到To[4]。

o 将反相的InverseTorusMap应用到To的第一三个部件

o 对于j＝0到NumFreeNodes-1

·如果对于所有的k＝0，1，2，3而言To[k]＝FreeNodeList[j].coordinate[k]

·FreeNodeList[j].mpiRank＝I

·退出j循环

以下的实例逻辑描述了调度器515的具体实施例。在具体实施例中，当群集管理引擎130调用调度器515以调度作业150时，群集管理引擎130将用于以下输入参数的值传递到调度器515：

RequestedNodes：表示请求的节点115的数量。

RequestType：表示请求类型。设置为SRATIAL、COMPACT或ANY。

RequestSize：具有三个元素的、表示请求尺寸的阵列。仅用于SPATIAL请求。

AggressiveFlag：0与1之间的浮点数量，表示为将节点115分配给作业150的目的而分配给调度器515的自由余地的程度。

TorusSize：具有三个元素的阵列表示栅格110的基于开关的尺寸。

NodePerSwitch：栅格110中耦合到每一开关166的CPU164的数量。

NumFreeNodes：FreeNodeList中节点115的数量。

FreeNodeList：FreeNode结构的列表，表示可用于调度的基于开关坐标的节点115。

在具体的实施例中，在调度器515试图调度作业150之后，调度器515返回以下内容之一：

PQS_ASSIGNED：表示调度器515调度作业150。

PQS_NO_ASSIGNMENT_AT_SPECIFIED_TIME：表示调度器515没有调度作业150。

PQS_NO_ASSIGNMENT_FOR_JOB_CATEGORY：表示即使栅格110中所有的节点115可用，调度器515也从不能调度作业150。

如果调度器515调度了作业150，从而调度器515相应地设置FreeNode结构的mpiRank字段。在具体的实施例中，群集管理引擎130与调度器515之间的包裹函数将来自群集管理引擎130的输入转换为调度器515希望的格式并且将调度器515的输出转换为群集管理引擎130希望的格式。

在具体的实施例中，确定作业150在理论上是否可被调度的setSchedulable包括以下实例逻辑：

If setSchedulable()＝False

Return PQS_NO_ASSIGNMENT_FOR_JOB_CATEGORY

EndIf

If initScheduler()＝False

Return PQS_NO_ASSIGNMENT_AT_SPECIFIED_TIME

End If

If RequestedNodes>NumFreeNodes

ret＝False

Else

ret＝scheduleJob()

End If

If ret＝True

setMpiRank()

Return PQS_ASSIGNED

Else

Return PQS_NO_ASSIGNMENT_AT_SPECIFIED_TIME

End If

在具体的实施例中，Rank(调度器515调用rank作业尺寸)包括以下实例逻辑。Rank的输入包括包含三个元素的一维阵列In[3]。Rank的输出包括具有三个元素的一维阵列Rank[3]，该阵列表示增加的尺寸中In的指数。In[Rank[0]≤In[Rank[1]]≤In[Rank[2]。在具体的实施例中，Rank包括气泡算法。

Rank[0]＝0

Rank[1]＝1

Rank[2]＝2

Fori＝0to2

Forj＝i+1to2

If In[Rank[j]<In[Rank[i]

k＝Rank[j]

Rank[j]＝Rank[i]

Rank[i]＝k

End If

End For

Fori＝0to2

IfTorusSize[i]≤1

Return False

End For

If RequestedNodes>TorusSize[0]×TorusSize[1]×TorusSize[2]×

NodesPerSwitch

Return False

End If

If NodesPerSwitch not equal to four

Return False；

End If

If RequestType＝SPATIAL

factor[0]＝2

factor[1]＝2

Rank(TorusSize，tRank)

Rank(RequestedSize，jRank)

NumJobDim＝0

NumExceed＝0

Fori＝0to2

If RequestedSize[i]>1)

NumJobDim＝NumJobDim+1

Else If RequestedSize[i]<1

Return False

End If

If RequestedSize[jRank[i]]>TorusSize[tRank[i]]

Exceed[NumExceed]＝i

NumExceed＝NumExceed+1

End If

End For

If NumExceed＝0

Return True

Else If NumExceed＝1

If RequestedSize[jRank[Exceed[0]]≤NodesPerSwitch×

TorusSize[tRank[Exceed[0]]

Return True

End If

If NumJobDim<3

Return True

End If

Retum False

Else

If RequestedSize[jRank[Exceed[0]]≤factor[0]×

TorusSize[tRank[Exceed[0]and

RequestedSize[jRank[Exceed[1]]≤factor[1]×

TorusSize[tRauk[Exceed[1]]

Return True

End If

If NumJobDim<3and(RequestedSize[jRank[Exceed[0]]≤

NodesPerSwitch×TorusSize[tRank[Exceed[0]]or

RequestedSize[jRank[Exceed[1]]≤NodesPerSwitch×

TorusSize[tRank[Exceed[1]])

Return True

End If

return False

End If

return True

在具体的实施例中，用于设置允许的调度类型的initScheduler包括以下实例逻辑。如果作业150仅请求一个节点115，initScheduler将一个允许的类型设置为Any，而不管原始的请求：

If RequestedNodes＝1or RequestType＝Any

AnyAllowed＝True

SpatialAllowed＝False

CompactAllowed＝False

Else If RequestType＝Compact

CompactAllowed＝True

AnyAllowed＝False

SpatialAllowed＝False

Else If RequestType＝Spatial

SpatialAllowed＝True

AnyAllowed＝False

If AggressiveFlag>0

CompactAllowed＝True

Else

Compact Allowed＝False

End If

factor[0]＝2

factor[1]＝2

Rank(TorusSize，tRank)

TorusMap[0]＝tRank[2]

TorusMap[1]＝tRank[1]

TorusMap[2]＝tRank[0]

InverseTorusMap[tRank[0]]＝2

InverseTorusMap[tRank[1]]＝1

InverseTorusMap[tRank[2]]＝0

If SpatialAllowed＝True

If setTorusForSpatial()＝False

Return False

End If

Else If CompactAllowed＝True

If setTorusForCompactl0＝False

Return False

End If

Else

If setTorusForAny()＝False

Return False

End If

Fori＝0to NumMapDimensions

TorusSize[mapDiminsions[i]]＝mapMod[i]×TorusSize[mapDiminsions[i]]

End For

SetPartition()

If SpatialAllowed＝True

buildSpatialTries()

End If

If compactAllowed＝True

buildCompactFits()

End If

If AnyAllowed＝True

buildFreeMeshes0

End If

If SpatialAllowed＝True or CompactAllowed＝True

InitScan()

End If

return True

在具体的实施例中，用于将基于开关的环面映射到基于节点的环面以用于空间请求的setTorusForSpatial包括以下实例逻辑：

Rank(RequestedSize，jRank)

NumDim＝0

dNdx＝0

Fori＝0to2

If RequestedSize[i]>1)

twoD[NumDim]＝i

NumDim＝NumDim+1

Else

oneD[dNdx]＝i

dNdx＝dNdx+1

End If

End For

If NumDim＝1

ReturnsetTorusFor1D())

Else If NumDim＝2

Return setTorusFor2D()

Else

Return setTorusFor3D()

End If

在具体的实施例中，用于在作业150的两个最大维数的即jRank[2]和jRank[1]中将栅格110乘以两个因数的setTorusFor1D包括以下实例逻辑：

NumMapDiminsions＝2

mapDiminsions[0]＝jRank[2]

mapDiminsions[1]＝jRank[1]

mapMod[0]＝factor[0]

mapMod[1]＝factor[0]

For i＝0to3

ntSize[i]＝TorusSize[TorusMap[i]]

End For

For i＝0to3

TorusSize[i]＝ntSize[i]

End For

For i＝0to3

RequestedSize[i]＝OriginalSize[jRank[i]]

JobMap[jRank[i]]＝i

End For

Return True

在具体的实施例中，setTorusFor2D以以下六种方式将基于开关的环面映射到基于节点的环面：

1.{T[0]，T[1]，T[2]}→{T[0]，2×T[1]，2×T[2]}

2.{T[0]，T[1]，T[2]}→{2×T[0]，T[1]，2×T[2]}

3.{T[0]，T[1]，T[2]}→{2×T[0]，2×T[1]，T[2]}

4.{T[0]，T[1]，T[2]}→{T[0]，T[1]，4×T[2]}

5.{T[0]，T[1]，T[2]}→{T[0]，4×T[1]，T[2]}

6.{T[0]，T[1]，T[2]}→{4×T[0]，T[1]，T[2]}

T是TorusSize。第一三种配置通过调度器515将每一开关166的节点115配置为2×2节点115而产生。最后的三种配置通过调度器515将每一开关166的节点115配置为1×1节点115而产生。在具体的实施例中，setTorusFor2D计数调度器515为每一映射而产生的Try结构并且选择将产生最大数量的Try结构的映射。如果发生关系，那么setTorusFor2D根据上述顺序选择映射。调度器515构建pSize[6，4]以包括：

pSinze[i，0]＝用于配置i的x维中分区的尺寸。

pSinze[i，1]＝用于配置i的y维中分区的尺寸。

pSinze[i，2]＝用于配置i的z维中分区的尺寸。

pSinze[i，3]用于配置i而产生的尝试的数量。

在具体的实施例中，setTorusFor2D包括以下实例逻辑：

max＝-1

maxNdx＝-1

For i＝0to2

For j＝i+1to3

NumMapDiminsions＝2

mapDiminsions[0]＝(i+j)mod3

mapDiminsions[1]＝(i+j+1)mod3

mapMod[0]＝factor[0]

mapMod[1]＝factor[1]

setTestPartSize(testPartSize)

pSizes[i+j-1，2]＝testPartSize[2]

pSizes[i+j-1，1]＝testPartSize[1]

pSizes[i+j-1，0]＝testPartSize[0]

pSizes[i+j-1][3]＝cnt2DTries(testPartSize，RequestedSize)

If pSizes[i+j-1][3]>max

max＝pSizes[i+j-1][3]

maxNdx＝i+j-1

End If

End For

For i＝0to3

NumMapDiminsions＝1

mapDiminsions[0]＝2-i

mapMod[0]＝NodesperGrid

setTestPartSize(testPartSize)

pSizes[i+3，2]＝testspSize[2]

pSizes[i+3，1]＝testspSize[1]

pSizes[i+3，0]＝testspSize[0]

pSizes[i+3][3]＝cnt2DTries(testPartSize，RequestedSize)

ifpSizes[i+3][3]>max

max＝pSizes[i+3][3]

maxNdx＝i+3

End If

End For

If max≤0

if CompactAllowed＝True

SpatialAllowed＝False

ReturnsetTorusForCompact()

Else

return False

End If

Else

For i＝0to2

ntSize[i]＝TorusSize[TorusMap[i]]

End For

For i＝0to2

TorusSize[i]＝ntSize[i]

End For

If maxNdx<3

NumMapDiminsions＝2

mapDiminsions[0]＝(maxNdx+1)mod3

mapDiminsions[1]＝(maxNdx+2)mod3

mapMod[0]＝factor[0]

mapMod[1]＝factor[1]

RequestedSize[mapDiminsions[0]]＝OriginalSize[jRank[1]]

RequestedSize[mapDiminsions[1]]＝OriginalSize[jRank[2]]

RequestedSize[3-mapDiminsions[0]-mapDiminsions[1]]＝

OriginalSize[jRank[0]]

JobMap[jRank[1]]＝mapDiminsions[0]

JobMap[jRank[2]]＝mapDiminsions[1]

JobMap[jRank[0]]＝3-mapDiminsions[0]-mapDiminsions[1]

Else

NumMod＝1

NumMapDiminsions＝1

mapDiminsions[0]＝(5-maxNdx)mod3

mapMod[0]＝NodesperGrid

If mapDiminsions[0]＝2

i＝1

Else

i＝2

End If

RequestedSize[mapDiminsions[0]]＝OriginalSize[jRank[2]]

RequestedSize[i]＝OriginalSize[jRank[1]]

RequestedSize[3-mapDiminsions[0]-i]＝OriginalSize[jRank[0]]

JobMap[jRank[2]]＝mapDiminsions[0]

JobMap[jRank[1]]＝i

JobMap[jRank[0]]＝3-mapDiminsions[0]-i

End If

Return True

在具体的实施例中，setTorusFor3D包括以下的实例逻辑：

max＝-1

maxNdx＝-1

For i＝0to2

For j＝i+1to2

NumMapDiminsions＝2

mapDiminsions[0]＝(i+j)mod3

mapDiminsions[1]＝(i+j+1)mod3

mapMod[0]＝factor[0]

mapMod[1]＝factor[1]

setTestPartSize(testPartSize)

pSizes[i+j-1，2]＝testPartSize[2]

pSizes[i+j-1，1]＝testPartSize[1]

pSizes[i+j-1，0]＝testPartSize[0]

pSizes[i+j-1，3]＝cnt2DTries(testPartSize，RequestedSize)

If(pSizes[i+j-1，3]>max)

max＝pSizes[i+j-1，3]

maxNdx＝i+j-1

End If

End For

For i＝0to2

NumMapDiminsions＝1

mapDiminsions[0]＝2-i

mapMod[0]＝NodesperGrid；

setTestPartSize(testPartSize)

pSizes[i+3，2]＝testPartSize[2]

pSizes[i+3，1]＝testPartSize[1]

pSizes[i+3，0]＝testPartSize[0]

pSizes[i+3]，3]＝cnt2DTries(testPartSize，RequestedSize

If pSizes[i+3][3]>max

max＝pSizes[i+3，3]

maxNdx＝i+3

End If

End For

If max≤0

If CompactAllowed＝True

SpatialAllowed＝False

ReturnsetTorusForCompact()

Else

return False

End If

Else

Fori＝0to2

ntSize[i]＝TorusSize[TorusMap[i]]

End For

Fori＝0to2

TorusSize[i]＝ntSize[i]

End For

If maxNdx<3

NumMod＝2

mod[0]＝(maxNdx+1)mod3

mod[1]＝(maxNdx+2)mod3

NumMapDiminsions＝2

mapDiminsions[0]＝(maxNdx+1)mod3

mapDiminsions[1]＝(maxNdx+2)mod3

mapMod[0]＝factor[0]

mapMod[1]＝factor[1]

RequestedSize[mapDiminsions[0]]＝OriginalSize[jRank[1]]

RequestedSize[mapDiminsions[1]]＝OriginalSize[jRank[2]]

RequestedSize[3-mapDiminsions[0]-mapDiminsions[1]]＝

OriginalSize[jRank[0]]

JobMap[jRank[1]]＝mapDiminsions[0]

JobMap[jRank[2]]＝mapDiminsions[1]

JobMap[jRank[0]]＝3-mapDiminsions[0]-mapDiminsions[1]

Else

NumMod＝1

mod[0]＝2-(maxNdx-3)

NumMapDiminsions＝1

mapDiminsions[0]＝(5-maxNdx)mod3

mapMod[0]＝NodesperGrid

If mapDiminsions[0]＝2

i＝1

Else

i＝2

End If

RequestedSize[mapDiminsions[0]]＝OriginalSize[jRank[2]]

RequestedSize[i]＝OriginalSize[jRank[1]]

requestedSize[3-mapDiminsions[0]-i]＝originalSize[jRank[0]]；

JobMap[jRank[2]]＝mapDiminsions[0]

JobMap[jRank[1]]＝i

JobMap[jRank[0]]＝3-mapDiminsions[0]-i

End If

Return True

在具体的实施例中，将紧凑请求的z维设置为4×1配置的setTorusForCompact包括以下的实例逻辑：

For i＝0to3

ntSize[i]＝TorusSize[tMap[i]]

End For

For i＝0 to 3

TorusSize[i]＝ntSize[i]

End For

NumMapDiminsions＝1

mapDiminsions[0]＝2

mapMod[0]＝NodesperGrid

Return True

在具体的实施例中，将任一请求的z维设置为4×1配置的setTorusForAny包括以下的实例逻辑：

For i＝0 to 3

ntSize[i]＝TorusSize[tMap[i]]

End For

For i＝0 to 3

TorusSize[i]＝ntSize[i]

End For

NumMapDiminsions＝1

mapDiminsions[0]＝2

mapMod[0]＝NodesperGrid

Retum True

在具体的实施例中，setPartion包括以下的实例逻辑：

For i＝0 to TorusSize[0]-1

For j＝0 to TorusSize[1]-1

For k＝0 to TorusSize[2]-1

NodeInUse[i，j，k]＝NODE_IN_USE

End For

For i＝0 to 2

PartStart[i]＝TorusSize[i]

PartEnd[i]＝0

End For

For i＝0 to NumFreeNodes-1

To[0]＝FreeNodes[i].coordinate[TorusMap[0]]

To[1]＝FreeNodes[i].coordinate[TorusMap[1]]

To[2]＝FreeNodes[i].coordinate[TorusMap[2]]

If Num]MapDimensions＝1

To[MapDimension[0]]＝To[MapDinension[0]]×MapMod[0]+

FreeNodes[i].coordinate[3]

Else

To[MapDimension[0]]＝To[MapDimension[0]]×MapMod[0]+

FreeNodes[i].coordinate[3]/MapMod[1]

To[MapDimension[1]]＝To[MapDimension[1]]×MapMod[1]+

FreeNodes[i].coordinate[3]mod MapMod[1]

End If

NodeInUse[To[0]]，To[1]，To[2]]＝NODE_NOT_IN_USE

For j＝0 to 2

If To[j]<PartStart[j]

PartStart]j]＝To[j]

End If

If To[j]<PartStart[j]

PartStart]j]＝To[j]

End If

End For

For i＝0 to 2

If PartStart[i]＝0 and PartEnd[i]＝TorusSize[i]-1

PartWraps[i]＝True

Else

PartWraps[i]＝False

End If

PartSize[i]＝PartEnd[i]-PartStart[i]+1

End For

在具体的实施例中，用于构建FreeY和FreeX的initScan包括以下的实例逻辑：

For i＝0 to TorusSize[0]-1

For k＝0 to TorusSize[2]-1

Count＝0

For j＝TorusSize[1]-1to0by-1

If NodeInUse[i，j，k]＝NODE_NOT_IN_USE

Count＝Count+1

End If

FreeY[i，j，k]＝Count

End For

For j＝0 to TorusSize[1]-1

For k＝0 to TorusStSize[2]-1

Count＝0

For i＝TorusSize[0]-1 to 0 by-1

If NodeInUse[i，j，k]＝NODE_NOT_IN_USE

Count＝Count+1

End If

FreeX[i，j，k]＝Count

End For

在具体的实施例中，用于确定请求中维数的数量的buildSpatialTries包括以下的实例逻辑：

NumDim＝0

For i＝0 to 2

If RequestedSize[i]>1)

NumDim＝NumDim+1

End If

End For

If NumDim＝1

buildlDTry()

Else IfNumDim＝2

build2DTry()

Else

for i＝0 to 2

Try.baseSize[i]RequestedSize[i]

End For

Try.NumConcats＝0

Try.NumFoldMaps＝0

NumberOfTries＝0

build3Dtry(Try，NumberOfTries)

End If

在具体的实施例中，为三维请求构建TryList并且为一维请求或两维请求中的每一折叠构建Try结构的build3Dtry包括以下实例逻辑：

setOrient(Try，NumOrient，orient)

if Num Orient>0

For(i＝0 to NumOrient-1

++NumTries；

For j＝0 to 2

TryList[NumberOfTries].baseSize[j]＝Try.baseSize[orient[i，j]]

EndFor

TryList[NumberOfTries].NumConcats＝Try.NumConcats；

For j＝0 to TryList[NumberOfTries].NumConcats-1

For k＝0 to 2

TryList[NumberOfTries.concatSize[j，k]＝Try.concatSize[j，orient[i，

k]]；

TryList[NumberOfTries].concatStartNode[j，k]＝

Try.concatStartNode[j，orient[i，k]]；

EndFor

End For

TryList[NumberOfTries].NumFoldMaps＝Try.NumFoldMaps；

For j＝0 to TryList[NumberOfTries].NumFoldMaps

TryList[NumberOfTries].foldLength[j]＝Try.foldLength[j]

TryList[NumberOfTries].foldFrom[j]＝Try.foldFrom[j]

TryList[NumberOfTries].foldTo[j]＝Try.foldTo[j]

TryList[NumberOfTries].foldFix[j]＝Try.foldFix[j]

End For

For k＝0 to 2

TryList[NumberOfTries].rMap[k]＝orient[i，k]

TryList[NumberOfTries].irMap[orient[i，k]]＝；

End For

NumberOfTries＝NumberOfTries+1

在具体的实施例中，计算唯一旋转NumOrient的数量以用于Try结构和用于每一旋转的指数映射的setOrient包括以下实例逻辑：

NumOrient＝0；

If try.NumberOfConcatanations>0

For i＝0 to 2

size[i]＝try.baseSize[i]；

For j＝0 to try.NumConcats-1

If try.concatStartNode[j，i]≥size[i]

size[i]＝Try.concatStartNode[j，i]+Try.concatSize[j，i]；

Else If Try.concatStartNode[j，i]<0

size[i]＝size[i]-try.concatStartNode[j，i]

End If

End For

If size[0]≤PartSize[0]and size[1]≤PartSize[1]andsize[2]≤PartSize[2]

orient[NNumOrient，0]＝0

orient[Numorient，1]＝1

orient[NumOrient，1]＝2

NumOrient＝NumOrient+1

End If

If size[0]≤PartSize[0]and size[2]≤PartSize[1]andsize[1]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝2

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

If size[1]≤PartSize[0]and size[0]≤PartSize[1]andsize[2]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝0

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If size[1]≤PartSize[0]and size[2]≤PartSize[1]andsize[0]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝2

orient[NumOrient，2]＝0

NumOrient＝NumOrient+1

End If

If size[2]≤PartSize[0]and size[0]≤PartSize[1]andsize[1]≤PartSize[2]

orient[NumOrient，0]＝2

orient[NumOrient，1]＝0

orient[NumOrient，2]＝1

NuumOrient＝NumOrient+1

End If

If size[2]≤PartSize[0]and size[1]≤PartSize[1]andsize[0]≤PartSize[2]

orient[NumOrient，0]＝2

orient[NumOrient，1]＝1

orient[NurmOrient，2]＝0

NumOrient＝NumOrient+1

End If

Else If Try.baseSize[0]＝Try.baseSize[1]

If try.baseSize[0]＝try.baseSize[2]

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝1

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

Else

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝1

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[2]≤PartSize[1]and

Try.baseSize[1]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝2

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

If Try.baseSize[2]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and

Try.baseSize[1]≤PartSize[2]

orient[NumOrient，0]＝2

orient[NumOrient，1]＝0

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

End if

Else if Try.baseSize[0]＝Try.baseSize[2]

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝1

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[2]and

Try.baseSize[1]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝2

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

If Try.baseSize[1]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝0

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

Else Tf Try.baseSize[1]＝Try≥baseSize[2])

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝1

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[1]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝0

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[1]≤PartSize[0]and Try.baseSize[2]≤PartSize[1]and

Try.baseSize[0]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝2

orient[NumOrient，2]＝0

NumOrient＝NumOrient+1

End If

Else

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝1

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[0]≤PartSize[0]and Try.baseSize[2]≤PartSize[1]and

Try.baseSize[1]≤PartSize[2]

orient[NumOrient，0]＝0

orient[NumOrient，1]＝2

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

If Try.baseSize[1]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and

Try.baseSize[2]≤PartSize[2]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝0

orient[NumOrient，2]＝2

NumOrient＝NumOrient+1

End If

If Try.baseSize[1]≤PartSize[0]and Try.baseSize[2]≤PartSize[1]and

Try.baseSize[2]≤PartSize[0]

orient[NumOrient，0]＝1

orient[NumOrient，1]＝2

orient[NumOrient，2]＝0

NumOrient＝NumOrient+1

End If

If Try.baseSize[2]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and

Try.baseSize[2]≤PartSize[1]

orient[NumOrient，0]＝2

orient[NumOrient，1]＝0

orient[NumOrient，2]＝1

NumOrient＝NumOrient+1

End If

If Try.baseSize[2]≤PartSize[0]and Try.baseSize[1]≤PartSize[1]and

Try.baseSize[2]≤PartSize[0]

orient[NumOrient，0]＝2

orient[NumOrient，1]＝1

orient[NumOrient，2]＝0

NumOrient＝NumOrient+1

End If

在具体的实施例中，build2Dtry包括以下实例逻辑：

Rank(PartSize，pRank)

build2DFold(PartSize，pRank，RequestedSize，NumFolds，FoldList)

For i＝0to NumFolds-1

d1＝RequestedSize[FoldList[i].fixDimension]+FoldList[i].foldLengtht+

FoldList[i].NumFolds

If FoldList[i].remainder not equal0

d1＝d1+1

End If

For j＝i+1to NumFolds-1

D2＝RequestedSize[FoldList[j].fixDimension]+FoldList[j].foldLengtht+

FoldList[j].NumFolds

If FoldList[j].remainder not equal0

D2＝d2+1

EndIf

Ifd2<d1

TempFold＝FoldList[j]

FoldList[j]＝FoldList[i]

FoldList[i]＝tempFold

d1＝d2

End If

End For

NumberOfTries＝0

For i＝0to NumFolds-1

try.baseSize[FoldList[i].fixDimension]＝

RequestedSize[FoldList[i].fixDimension]

try.baseSize[FoldList[i].foldDimension＝FoldList[i].foldLength

try.baseSize[FoldList[i].oneDimension]＝FoldList[i].NumFolds

If FoldList[i].remainder not equal0

try.NumConcats＝1

If FoldList[i].NumFolds is odd

Try.concatStartNode[0，FoldList[i].foldDimension]＝

FoldList[i].foldLength-FoldList[i].remainder

Else

Try.concatStartNode[0，FoldList[i].foldDimension]＝0

End If

try.concatStartNode[0，FoldList[i].fixDimension]＝0

try.concatStartNode[0，FoldList[i].oneDimension]＝FoldList[i].NumFolds

try.concatSize[0，FoldList[i].fixDimension]＝try.baseSize[FoldList[i].

fix Dimension]

try.concatSize[0，FoldList[i].foldDimension]＝FoldList[i].remainder

try.concatSize[0，FoldList[i].oneDimension]＝1

Else

try.NumConcats＝0

End If

try.NumFoldMaps＝1

try.foldLength[0]＝FoldList[i].foldLength

try.foldFrom[0]＝FoldList[i].foldDimension

try.foldTo[0]＝FoldList[i].oneDimension

try.foldFix[0]＝FoldList[i].fixDimension

build3Dtry(Try，NumberOfTries)

End For

在具体的实施例中，用于构建二维网格的所有可能的折叠的build2Dfold包括以下实例逻辑：

j＝0

oneD＝-1

For i＝0to2

If size[i]＝1and oneD＝-1

oneD＝i

Else

twoD[j]＝I

j＝j+1

End If

End For

If size[twoD[1]]≥size[twoD[0]]

bigD＝twoD[1]

littleD＝twoD[0]

Else

bigD＝twoD[0]

littleD＝twoD[1]

End If

startFoldB＝sqrt(size[bigD])

If startFoldB×startFoldB not equal size[bigD]or startFoldB＝1

StartFoldB＝startFoldB+1

End If

endFoldB＝size[bigD]/2

startFoldL＝sqrt(size[littleD])

If startFoldL×startFoldL not equal size[littleD]or startFoldL＝1

StartFoldL＝startFoldL+1

if size[bigD]not equal size[littleD]

endFoldL＝size[littleD]/2

else

endFoldL＝1

End If

NumFolds＝1

If endFoldB≥startFoldB

NumFolds＝NumFolds+(endFoldB-startFoldB+1)

End If

If endFoldL≥startFoldL

NumFolds＝NumFolds+(endFoldL-startFoldL+1)

End If

foldIndex＝0；

FoldList[foldIndex].foldLength＝size[littleD]

FoldList[foldIndex].NumFolds＝1

FoldList[foldIndex].remainder＝0

FoldList[foldIndex].foldD＝littleD

FoldList[foldIndex].fixD＝bigD

FoldList[foldIndex].oneD＝oneD

根据以下实例逻辑构建的阵列t是一种产生的Try的网格尺寸。调度器515记录阵列中t的Rank，tRank。

t[littleD]＝size[bigD]

t[bigD]＝FoldList[foldIndex].foldLength

t[oneD]＝FoldList[foldIndex].NumFolds

rank(t，tRank)

hit＝False

Foril＝0to2while hit＝False

Ift[IRank[i1]]>PartSize[pRank[i1]]

hit＝True

End If

If hit＝False

foldIndex＝foldIndex+1

End If

Fori＝startFoldB to endFoldB

FoldList[foldIndex].foldLength＝i

FoldList[foldIndex].Num???Folds＝size[bigD]/i

FoldList[foldIndex].remainder＝size[bigD]modi

FoldList[foldIndex].foldD＝bigD

FoldList[foldIndex].fixD＝littleD

FoldList[foldIndex].oneD＝oneD

t[littleD]＝size[littleD]

t[bigD]＝FoldList[foldIndex].foldLength

If(FoldList[foldIndex].remainder not equal0

t[oneD]＝FoldList[foldIndex].NumFolds+1

Else

t[oneD]＝FoldList[foldIndex].NumFolds

End If

Rank(t，tRank)

hit＝False

For il＝0to2while hit＝False

If t[tRank[i1]]>PartSize[pRank[i1]]

hit＝True

End If

End For

if hit＝False

foldIndex＝foldIndex+1

End If

End For

For i＝startFoldL to endFoldL

FoldList[foldIndex].foldLength＝i

FoldList[foldIndex].NumFolds＝size[littleD]/i

FoldList[foldIndex].remainder＝size[littleD]mod i

FoldList[foldIndex].foldD＝littleD

FoldList[foldIndex].fixD＝bigD

FoldList[foldIndex].oneD＝oneD

t[bigD]＝size[bigD]

t[littleD]＝FoldList[foldIndex].foldLength

IfFoldList[foldIndex].remainder not equal 0

t[oneD]＝FoldList[foldIndex].NumFolds+1

Else

t[oneD]＝FoldList[foldIndex].NumFolds

End If

Rank(t，tRank)

hit＝False

for il＝0to2while hit＝False

If t[tRank[i1]]>PartSize[pRank[i1]]

hit＝True

End If

End For

Ifhit＝False

FoldIndex＝foldIndex+l

End If

End For

在具体的实施例中，buildlTry产生一维请求的折叠的列表，并且对于每一折叠来说，调用build2DFold以产生一个或多个附加折叠的列表。buildlTry将折叠列表记录在OneDFoldList，buildlTry包括以下实例逻辑：

Structure oneDFold

Fold Structure oneD

Fold Structure twoD[×]

integer NumTwoDFolds

integer twoDFoldSize[3]

End Structure

在具体的实施例中，oneD包括一个第一折叠。在具体的实施例中，twoD包括从所述第一折叠而产生的折叠列表。NumTwoDFold表示twoD中折叠的数量。在具体的实施例中，twoDFoldSize表示传给build2Dfold的网格尺寸。调度器515产生用于twoD元素的Try结构并且调用build3Dtry以构建每一Try结构的所有可能旋转。在具体实施例中，buildlTry包括以下实例逻辑：

Rank(PartSize，pRank)

Rank(RequestedSize，jRank[0])

end＝sqrt(RequestedSize[jRank[2]])

start＝2

OneDFoldList[0].oneD.foldLength＝RequestedSize[jRank[2]]

OneDFoldList[0].oneD.NumFolds＝1

OneDFoldList[0].oneD.remainder＝0

OneDFoldList[0].oneD.foldD＝jRank[2]

OneDFoldList[0].oneD.oneD＝jRank[1]

OneDFoldList[0].oneD.fixD＝jRank[0]

OneDFoldList[0].twoDFoldSize[jRank[2]]＝RequestedSize[jRank[2]]

OneDFoldList[0].twoDFoldSize[jRank[1]]＝1

OneDFoldList[0].twoDFoldSize[jRank[0]]＝1

hit＝False

For j＝0to2while hit＝False

ifRequestedSize[jRank[j]]>PartSize[pRank[j]]

hit＝True

End If

End For

Ifhit＝False

build2DFo]d(PartSize，pRank，RequestedSize，OneDFoldList[0].twoD，

OneDFoldList[0].nTwoDFolds)

OneDFoldList[0].nTwoDFolds＝1

Num1DFolds＝1；

Else

Num1DFolds＝0

End lf

gotRemZero＝False

For i＝starttoend

OneDFoldList[Num1DFolds].oneD.foldLength＝i

OneDFoldList[Num1DFolds].oneD.NumFolds＝RequestedSize[jRank[2]]/i

OneDFoldList[Num1DFolds].oneD.remainder＝RequestedSize[jRank[2]]

modi

OneDFoldList[Num1DFolds].oneD.foldD＝jRank[2]

(OneDFoldList[Num1DFolds].oneD.oneD＝jRank[1]

OneDFoldList[Num1DFolds].oneD.fixD＝jRank[0]

OneDFoldList[Num1DFolds].twoDFoldSize[jRank[2]]＝

OneDFoldList[Num1DFolds].oneD.foldLength

OneDFoldList[Num1DFolds].twoDFoldSize[jRank[1]]＝

OneDFoldList[Num1DFolds].oneD.NumFolds

OneDFoldList[Num1DFolds].twoDFoldSize[jRank[0]]＝1

IfOneDFoldList[Num1DFolds].oneD.remainder not equal0or gotRemZero＝

False

IfOneDFoldList[Num1DFolds].oneD.remainder＝0

gotRemZero＝True

End If

build2DFold(PartSize，pRank，RequestedSize，

OneDFoldList[Num1DFolds].twoDFoldSize，

OneDFoldList[Nurm1DFolds].twoD，

OneDFoldList[Num1DFolds].nTwoDFolds)

Num1DFolds＝Num1DFolds+1

End If

End For

NumberOfTries＝0

For i＝0to Num1DFolds

Forj＝0to OneDFoldList[i].nTwoDFolds

If OneDFoldList[i].oneD.foldD not equal OneDFoldList[i].twoD[j].foldD

or OneDFoldList[i].oneD，remainder＝0

try.baseSize[OneDFoldList[i].twoD[j].fixD]＝

OneDFoldList[i].twoDFoldSize[OneDFoldList[i

].twoD[j].fixD]

try.baseSize[OneDFoldList[i].twoD[j].foldD]＝

OneDFoldList[i].twoD[j].foldLength

try.baseSize[OneDFoldList[i].twoD[j].oneD]＝

OneDFoldList[i].twoD[j].NumFolds；

ifOneDFoldList[i].twoD[j].remainder not equal0

try.NumConcats＝1

if OneDFoldList[i].twoD[j].NumFolds is odd

try.concatStartNode[0，OneDFoldList[i].twoD[j].foldD]＝

OneDFoldList[i].twoD[j].foldLength-

OneDFoldList[i].twoD[j].remainder

Else

try.concatStartNode[0，OneDFoldList[i].twoD[j].foldD]＝0

EndIf

try.concatStartNode[0，OneDFoldList[i].twoD[j].fixD]＝0

try.concatStartNode[0，OneDFoldList[i].twoD[j].oneD]＝

OneDFoldList[i].twoD[j].NumFolds

try.concatSize[0，OneDFoldList[i].twoD[j].fixD]＝

try.baseSize[OneDFoldList[i].twoD[j].fixD]

try.concatSize[0，OneDFoldList[i].twoD[j].foldD]＝

OneDFoldList[i].twoD[j].remainder

try.concatSize[0OneDFoldList[i].twoD[j].oneD]＝1；

Else

try.NumConcats＝0

End If

If OneDFoldList[i].oneD.remainder not equal0

if OneDFoldList[i].oneD.NumFolds is odd

try.concatStartNode[try.NumConcats，

OneDFoldList[i].oneD，foldD]＝

OneDFoldList[i].oneD.foldLength-

OneDFoldList[i].oneD.remainder

Else

try.concatStartNode[try.NumConcats，

OneDFoldList[i].oneD.foldD]＝0

End If

try.concatStartNode[try.NumConcats，OneDFoldList[i].oneD.fixD]

＝0

try.concatStartNode[try.NumConcats，OneDFoldList[i].oneD.oneD]

＝OneDFoldList[i].oneD.NumFolds

try.concatSize[try.NumConcats，OneDFoldList[i].oneD.fixD]＝1

try.concatSize[try.NumConcats，OneDFoldList[i]oneD.foldD]＝

OneDFoldList[i].oneD.remainder

try.concatSize[try.NumConcats，OneDFoldList[i].oneD.oneD]＝1

oneDEnd[0]＝try.concatStartNode[try.NumConcats，0]+

try.concatSize[try.NumConcats，0]-1

oneDEnd[1]＝try.concatStartNode[try.NumConcats，1]+

try.concatSize[try.NumConcats，1]-1

oneDEnd[2]＝try.concatStartNode[try.NumConcats，2]+

try.concatSize[try.NumConcats，2]-1

k＝try.concatStartNode[try.NumConcats，

OneDFoldList[i].twoD[j].foldD]

l＝oneDEnd[OneDFoldList[i].twoD[j].foldD]

If OneDFoldList[i].twoD[j].NumFolds is odd

try.concatStartNode[try.NumConcats，

OneDFoldList[i].twoD[j].foldD]＝

OneDFoldList[i].twoD[j].foldLength-1-(k

mod OneDFoldList[i].twoD[j].foldLength)

oneDEnd[OneDFoldList[i].twoD[j].foldD]＝

OneDFoldList[i].oneD.foldLength-1-(1mod

OneDFoldList[i].oneD.foldLength)

Else

try.concatStartNode[try.NumConcats，

OneDFoldList[i].twoD[j].foldD]＝k mod

OneDFoldList[i].twoD[j].foldLength

oneDEnd[OneDFoldList[i].twoD[j].foldD]＝1mod

OneDFoldList[i].oneD.foldLength

End If

try.concatStartNode[try.NumConcats，OneDFoldList[i].oneD.oneD]

＝k/OneDFoldList[i].twoD.foldLength

oneDEnd[OneDFoldList[j].oneD.oneD]＝l/

OneDFoldList[i].oneD.foldLength

try.concatSize[try.NumConcats，0]＝oneDEnd[0]-

try.concatStartNode[try.NumConcats，0]+1

try.concatSize[try.NumConcats，1]＝oneDEnd[1]-

try.concatStartNode[try.NumConcats，1]+1

try.concatSize[try.NumConcats，2]＝oneDEnd[2]-

try.concatStartNode[try.NumConcats，2]+1

try.NumConcats＝try.NumConcats+1

End If

try.NumFoldMaps＝2

try.foldLength[0]＝OneDFoldList[i].oneD.foldLength

try.foldFrom[0]＝OneDFoldList[i].oneD.foldD

try.foldTo[0]＝OneDFoldList[i].oneD.oneD

try.foldFix[0]＝OneDFoldList[i].oneD.fixD

try.foldLength[1]＝OneDFoldList[i].twoD[j].foldLength

try.foldFrom[1]＝OneDFoldList[i].twoD[j].foldD

try.foldTo[1]＝OneDFoldList[i].twoD[j].oneD

try.foldFix[1]＝OneDFoldList[i].twoD[j].fixD

build3Dtry(Try，NumberOfTries)

End For

NumDeleted＝0

Fori＝0to NumberOfTries-1

curMax＝TryList[i].baseSize[0]+TryList[i].baseSize[1]+

TryList[i].baseSize[2]

ifTryList[i].NumConcats>0

curMax＝curMax+1

End If

For j＝i+1toNumberOfTries-1

duplicate＝True

For i1＝0to2while duplicate＝True

If TryList[j].baseSize[i1]not equal TryList[i].baseSize[i]

duplicate＝False

End If

End For

If duplicate＝Tr ue and TryList[j].NumConcats＝TryList[i].NumConcats)

Foril＝0to TryList[i].NumConcats while duplicate＝True

For j1＝0to2while duplicate＝True

If TryList[j].concatStartNode[i1，j1]not equal

TryList[i].concatStartNode[i1，j1]

duplicate＝False

Else IfTryList[j].concatSize[il，j1]not equal

TryList[i].concatSize[i1，j1]

duplicate＝False

End For

End If

If duplicate＝True

For i1＝0to2

TryList[j].baseSize[i1]＝TorusSize[i1]+1

End For

NumDeleted＝NumDeleted+1

Else

nxtMax＝TryList[j].baseSize[0]+TryList[j].baseSize[1]+

TryList[j].baseSize[2]

If TryList[j].NumConcats>0

nxtMax＝nxtMax+1

End If

If nxtMax<curMax

TempTry＝TryList[j]

TryList[j]＝TryList[i]

TryList[i]＝tempTry

curMax＝nxtMax

End If

End For

NumberOfTries＝NumberOfTries-NumDeleted

在具体的实施例中，用于构建BestFit[3]的buildCompactFit包括以下实例逻辑：

Rank(partSize，PartRank)

l＝QubeRoot(ResuestedNodes)

hit＝False

For i＝1tol+1while hit＝False

For j＝itol+1while hit＝False

For(k＝jtol+1whilehit＝False

Ifi×j×k≥RequestedNodes

t[0]＝i

t[1]＝j

t[2]＝k

hit＝True

End If

End For

Ift[0]≤PartSize[PartRank[0]]

Ift[1]>PartSize[PartRank[1]]

t[1]＝t[1]-1

hit＝False

For t[2]＝RequestedNodes/(t[0]×t[1])to PartSize[PartRank[2]]while

hit＝False

Ift[0]×t[1]×t[2]≥RequestedNodes

Hit＝True

End If

End For

End If

Else

t[0]＝PartSize[PartRank[0]]

l＝sqrt(RequestedNodes/t[0])

hit＝Fa]se；

For j＝ltol+1whilehit＝False

For(k＝jtol+1whilehit＝False

If(t[0]×j×k≥RequestedNodes

t[1]＝j

t[2]＝k

hit＝True

End If

End For

ift[1]>PartSize[PartRank[1]]

t[1]＝PartSize[PartRank[1]]

t[2]＝RequestedNodes/(t[0]×t[1])

If t[0]×t[1]×t[2]<RequestedNodes

t[2]＝t[2]+1

End If

bestFit[pRank[0]]＝t[0]；

bestFit[pRank[1]]＝t[1]；

bestFit[pRank[2]]＝t[2]；

NumberOfFits＝0

For i＝BestFit[0]to PartSize[0]

For j＝BestFit[1]to PartSize[1]

For k＝BestFit[2]to PartSize[2]

Fit[NumberOfFits，0]＝i

Fit[NumberOfFits，1]＝j

Fit[NumberOfFits，2]＝k

Hit＝True

If(i not equal to PartSize[0])and(jnot equal to PartSize[0])and(knot

equalto PartSize[0])

For m＝0 to NumMapDimensions While Hit＝True

If Fit[NumberOfFits，MapDimension[m]]mod MapMod[m]not

equalto0

Hit＝False

End If

End For

End If

If Hit＝True

NumberOfFits＝NumberOfFits+1

End If

End For

For i＝0to NumBerOfFits-1

d1＝Fit[i，0]+Fit[i，1]+Fit[i，2]

For j＝i+1to NumBerOfFits-1

d2＝Fit[j，0]+Fit[j，1]+Fit[j，2]

if d2<d1

k＝Fit[j，0]

Fit[j，0]＝Fit[i，0]

Fit[i，0]＝k

k＝Fit[j，1]

Fit[j，1]＝Fit[i，1]

Fit[i，1]＝k

k＝Fit[j，1]

Fit[j，1]＝Fit[i，1]

Fit[i，1]＝k

d1＝d2

Else If d2＝d1

Rank(Fit[i]，iRank)

Rank(Fit[j]，jRank)

hit＝0

For(k＝0to2while hit＝0

If Fit[j，jRank[k]>Fit[i，iRank[k]

hit＝1

Else If Fit[j，jRank[k]<Fit[i，iRank[k]

Hit＝-1

End For

If hit＝1

k＝Fit[j，0]

Fit[j，0]＝Fit[i，0]

Fit[i，0]＝k

k＝Fit[j，1]

Fit[j，1]＝Fit[i，1]

Fit[i，1]＝k

k＝Fit[j，1]

Fit[j，1]＝Fit[i，1]

Fit[i，1]＝k

d1＝d2

End If

End For

lastMax＝0

NumMaxDistances＝0

Fori＝0NumberOfFits-1

currentMax＝Fit[i，0]+Fit[i，1]+Fit[i，2]

If currentMax not equal lastMax

MaxDistance[NumberOfMaxDistance，0]＝i

MaxDistance[NumberOfMaxDistance，1]＝currentMax

NumberOfMaxDistance＝NumberOfMaxDistance+1

End If

End For

在具体的实施例中，buildFreeMeshes函数包括以下实例逻辑：

NumFreeMeshes＝0

For i＝partStart[0]to PartEnd[0]

For j＝PartStart[1]to PartEnd[1]

For k＝PartStart[2]to PartEnd[2]

If NodeInUse[i，j，k]＝NODE_NOT_IN_USE

NodeInUse[i，j，k]＝NODE_ON_HOLD

meshStart[0]＝i

meshStart[1]＝j

meshStart[2]＝k

inMesh＝True

for mz＝k+1to PartEnd[2]and inMesh＝True

if NodeInUse[i，j，mz]not equal NODE_NOT_IN_USE

inMesh＝False

End If

End For

If inMesh＝True

mEnd[2]＝mz-1

Else

mEnd[2]＝mz-2

If PartWraps[2]and meshStart[2]＝0and meshEnd[2]not equal

PartEnd[2]

inMesh＝True；

For mz＝PartEnd[2to meshEnd[2]by-1and inMesh＝True

If NodeInUse[i，j，mz]not equal NODE_NOT_IN_USE

inMesh＝False

End If

End For

If inMesh＝True

mz＝mz+1

Else

mz＝mz+2

End If

if mz≤PartEnd[2]

meshStart[2]＝mz；

meshEnd[2]＝meshEnd[2]+TorusSize[2]

End If

inMesh＝True

For my＝j+1to PartEnd[1]and inMesh＝True

For mz＝meshStart[2tomeshEnd[2]an inMesh＝True

If NodeInUse[i，my，mzmod TorusSize[2]]not equal

NODE_NOT_IN_USE

inMesh＝False

End If

End For

If inMesh＝True

meshEnd[1]＝my-1

Else

meshEnd[1]＝my-2

End If

If PartWraps[1]and meshStart[1]＝0and meshEnd[1]not

equal PartEnd[1]

inMesh＝True

For my＝PartEnd[1]to meshEnd[1]by-1and inMesh＝

True

For mz＝meshStart[2]to meshEnd[2]and inMesh＝

True

If NodeInUse[i，my，mz mod Torus Size[2]not equal

NODE_NOT_IN_USE

inMesh＝False

End If

End For

IfinMesh＝True

My＝my+1

Else

my＝my+2

End If

ifmy≤PartEnd[1]

meshStart[1]＝my

meshEnd[1]＝meshEnd[1]+TorusSize[1]

End If

End For

inMesh＝True

for mx＝i+1 to PartEnd[0]and inMesh＝True

for my＝meshStart[1]to meshEnd[1]and inMesh＝True

for mz＝mStart[2]to mEnd[2]and inMesh＝True

If NodeInUse[mx，my mod TorusSize[1]，mzmod

TorusSize[2]]notequal

NODE_NOT_IN_USE

inMesh＝False

End If

End For

If inMesh＝True

meshEnd[0]＝mx-1

Else

meshEnd[0]＝mx-2

End If

If partWraps[0]and meshStart[0]＝0and meshEnd[0]not equal

PartEnd[0]

inMesh＝True

For mx＝partEnd[0]to meshEnd[0]by-1and inMesh＝True

For my＝meshStart[1]to meshEnd[1]and inMesh＝True

For mz＝meshStart[2]to meshEnd[2]and inMesh＝

True

If NodeInUse[mx，my mod TorusSize[1]，mzMod

TorusSize[2]]not equal

NODE_NOT_IN_USE

inMesh＝False

End If

End For

If inMesh＝True

Mx＝mx+1

Else

Mx＝mx+2

End If

If mx≤PartEnd[0]

meshStart[0]＝mx

meshEnd[0]＝meshEnd[0]+TorusSize[0]

End If

FreeMesh[NumFreeMeshes].Start[0]＝meshStart[0]

FreeMesh[NumFreeMeshes].Start[1]＝meshStart[1]

FreeMesh[NumFreeMeshes].Start[2]＝meshStart[2]

FreeMesh[NumFreeMeshes].end[0]＝meshEnd[0]

FreeMesh[NumFreeMeshes].end[1]＝meshEnd[1]

FreeMesh[NumFreeMeshes].end[2]＝meshEnd[2]

reeMesh[NumFreeMeshes].NumNodes＝(meshEnd[0]-

meshStart[0]+1)×(meshEnd[1]-

meshStart[1]+1)×(meshEnd[2]-

meshStart[2]+1)

For mx＝meshStart[0]to meshEnd[0]

mx1＝mx mod TorusSize[0]

For my＝meshStart[1]to meshEnd[1]

my1＝my mod TorusSize[1]

For mz＝meshStart[2]to meshEnd[2]

mz1＝mz mod TorusSize[2]

NodeInUse[mx1]，my1]，mz1]＝NODE_ON_HOLD

End For

For i＝0to2

FreeMesh[NumFreeMeshes].Rank[i]＝2-l；

End For

Forl＝0to2

For m＝l+1to3

l1＝FreeMesh[NumFreeMeshes].Rank[l]

ml＝FreeMesh[NumFreeMeshes].Rank[m]

IfmeshEnd[m1]-meshStart[m1]<meshEnd[l1]-

meshStart[l1]

FreeMesh[NurmFreeMeshes].Rank[l]＝m1

FreeMeshRank[m]＝l1

End If

End For

NumFreeMeshes＝NumFreeMeshes+1

End If

End For

For i＝partStart[0]to PartEnd[0]

Forj＝PartStart[1]to PartEnd[1]

Fork＝PartStart[2]to PartEnd[2]

If NodeInUse[i，j，k]＝NODE_ON_HOLD

NodeInUse[i，j，k]＝NODE_NOT_IN_USE

End If

End For

For i＝0to NumFreeMeshes-1

For j＝i+1toNumFreeMeshes-1

hit＝False

ifFreeMesh[j].NumNodes<freeMesh[i].NumNodes

hit＝True；

Else If FreeMesh[j].NumNodes＝freeMesh[i].NumNodes

hit＝True

Forl＝0to2while hit＝True

If FreeMesh[j].Rank[l]>freeMesh[i].Rank[l])

Hit＝False

End If

End For

End If

Ifhit＝True

TempMesh＝FreeMesh[j]

FreeMesh[j]＝FreeMesh[i]

FreeMesh[i]＝TempMesh

End If

End For

在具体的实施例中，如果调度器515成功调度作业150则返回True的ScheduleJob包括以下实例逻辑：

If SpatialAllowed＝True

If scheduleSpatial()＝True

retrnTrue

Else If CompactAllowed＝True

return scheduleCompact()

End If

Else If CompactAllowed＝True

retumscheduleCompact()

Else

ReturnscheduleAny()

End If

在具体的实施例中，scheduleSpatial包括以下实例逻辑：

GotFit＝False

For i＝0to NumberOfTries-1while GotFit＝False

If scanSpatial(TryList[i]，Start)＝True

GotFit＝True

setSpatialNodeInUse(Try，Start)

End If

End For

Return GotFit

在具体的实施例中，用于构建AssignedNodeList的setSpatialNodeInUse包括以下实例逻辑：

NodeIndex＝0

For(cNode[0]＝0to OriginalSize[0]-1

For cNode[1]＝0to OriginalSize[1]-l

For cNode[2]＝0to OriginalSize[2]-1

For i＝0to2

jcNode[jobMap[i]]＝cNode[i]

End For

If Try.NumFoldMaps＝1

mNode[0，Try.foldFix[0]]＝jcNode[Try.foldFix[0]]

mNode[0，Try.foldTo[0]]＝jcNode[Try.foldFrom[0]]/

Try.foldLength[0]

If mNode[0，Try.foldTo[0]]is odd

mNode[0，Try.foldFrom[0]]＝Try.foldLength[0]-1-

(jcNode[Try.foldFrom[0]]mod

Try.foldLength[0])

Else

mNode[0，Try.foldFrom[0]]＝jcNode[Try.foldFrom[0]]mod

Try.foldLength[0]

End If

For i＝0to2

node[i]＝mNode[0，Try.rMap[l]]

End For

Else

mNode[0，Try.foldFix[0]]＝jcNode[Try.foldFix[0]]

mNode[0，Try.foldTo[0]]＝jcNode[Try.foldFrom[0]]/

Try→foldLnt[0]

If mNode[0，Try.foldTo[0]]is odd

mNode[0，Try.foldFrom[0]]＝Try.foldLength[0]-1-

(jcNode[Try.foldFrom[0]]mod

Try.foldLength[0])

Else

mNode[0，Try.foldFrom[0]]＝jcNode[Try.foldFrom[0]]mod

Try.foldLength[0]

End If

mNode[1，Try.foldFix[1]]＝mNode[0，Try.foldFix[1]]

mNode[1，Try.foldTo[1]]＝mNode[0，Try.foldFrom[1]]/

Try.foldLength[1]

IfmNode[1，Try.foldTo[1]]is odd

mNode[1，Try.foldFrom[1]]＝Try.foldLength[1]-1-

(mNode[0，Try.foldFrom[1]]mod

Try.foldLength[1])

Else

mNode[1，Try.foldFrom[1]]＝mNode[0，Try.foldFrom[1]]

modTry→foldLnt[1]

For i＝0to2

node[i]＝mNode[]，Try.rMap[i]]

End For

end If

For i＝0to2

Node[i]＝node[i]mod TorusSize[i]

End For

NodeInUse[node[0]，node[1]，node[2]]＝NODE_IN_USE

AssignedNodeList[NodeIndex，0]＝node[0]

AssignedNodeList[NodeIndex，1]＝node[2]

AssignedNodeList[NodeIndex，2]＝node[2]

NodeIndex＝NodeIndex+1

End For

在具体的实施例中，scanSpatial包括以下实例逻辑：

For i＝0to2

If PartWraps[i])

End[i]＝PartEnd[i]

Else

End[i]＝PartEnd[i]-Try.baseSize[i]+1

End If

End For

zPlaneCnt＝Try.baseSize[0]×Try.baseSize[1]；

For i＝PartStart[0]to End[0]

newX＝True

For(n＝PartStart[2]to PartEnd[2]

zPlane[n]＝0

End For

Forl＝ito i+try.baseSize[0]

For n＝PartStart[2]to PartEnd[2]

l1＝lmod TorusSize[0]

m1＝PartStart[1]

m2＝(m1+Try.baseSize[1])mod TorusSize[1]

If PartStart[1]+Try.baseSize[1]≤PartEnd[1]

ZPlane[n]＝zPlane[n]+FreeY[l1，m1，n]-FreeY[l1，m2，n]

Else

ZPlane[n]＝zPlane[n]+FreeY[i1，m1，n]

End If

End For

Forj＝PartStart[1]to End[1]

ifnewX＝False

l1＝i mod TorusSize[0]

l2＝(i+Try.baseSize[0])mod TorusSize[0]

m1＝(j-1)mod TorusSize[1]

if PartWraps[0]＝False or i+try.baseSize[0])PartEnd[0]

Forn＝PartStart[2]to PartEnd[2]

If i+Try.baseSize[0]≤PartEnd[0]

zPlane[n]＝zPlane[n]-(FreeX[l1，m1，n]-FreeX[l2，m1，n])

Else

zPlane[n]＝zPlane[n]-FreeX[l1，m1，n]

End If

End For

Else

For n＝PartStart[2]to PartEnd[2]

zPlane[n]＝zPlane[n]-(FreeX[l1，m1，n]+(FreeX[0，m1，n]-

FreeX[l2，m1，n]))

End For

End If

l1＝i mod TorusSize[0]

l2＝(i+Try.baseSize[0])mod TorusSize[0]

m1＝(j+Try.baseSize[1])mod TorusSize[1]

If PartWraps[0]＝False or i+try.baseSize[0])≤PartEnd[0]

Forn＝PartStart[2]to PartEnd[2]

If i+Try.baseSize[0]≤PartEnd[0]

ZPlane[n]＝zPlane[n]+FreeX[l1，m1，n]-FreeX[l1，m2，n]

Else

ZPlane[n]＝zPlane[n]+FreeX[l1，ml，n]

End If

End For

Else

For n＝PartStart[2]to PartEnd[2]

ZPlane[n]＝zPlane[n]+FreeX[l1，m1，n])+FreeX[0，m2，n])-

FreeX[l1，m2，n]

End For

End If

Else

newX＝False；

k＝PartStart[2]；

whilek≤End[2])

hit＝True；

Forn＝k；tok+Try.baseSize[2]-1while hit＝True

If zPlane[nmod TorusSize[2]]not equal zPlaneCnt

hit＝False；

End If

End For

ifhit＝True

Start[0]＝i；

Start[1]＝j；

Start[2]＝k；

For cNdx＝0to try.NumConcats-1while hit＝True

Form＝0to2while hit＝True

cStart[m]＝Start[m]+Try.concatStartNode[cNdx，m]

cEnd[m]＝cStart[m]+Try.concatSize[cNdx，m]-1；

if(cEnd[m]≥TorusSize[m]&&PartWraps[m]＝False

hit＝False；

End For

For1＝cStart[0]to cEnd[0]while hit＝True

For m＝cStart[1]to cEnd[1]while hit＝True

For n＝cStart[2]to cEnd[2]while hit＝True

l1＝lmod TorusSize[0]

m1＝mmod TorusSize[1]

n1＝n mod TorusSize[2]

If NodeInUse[l1，m1，n1]not equal

NODE_NOT_IN_USE

hit＝False；

End If

End For

If hit＝True

Retum True；

Else

K＝k+1

End If

Else

k＝n+1

End If

EndFor

End For

ReturnFalse

在具体的实施例中，用于在Fit上运行对分检索的scheduleCompactFunction包括以下实例逻辑：

Hi ghFit＝NumberOfFits-1

For i＝0to2

HighStart[i]＝PartStart[i]

End For

LowFit＝-1

While True

CurrentFit＝LowFit+(HighFit-LowFit)/2

If scanCompact(NumberOfNodes，Fit[CurrentFit]，HighStart)＝True

HighFit＝CurrentFit

Else

LowFit＝CurrentFit

End If

IfHighFit＝LowFit+1

Return

End If

End While

Hit＝False

For i＝0to NumMaxDistances-1While Hit＝False

If HighFit≥MaxDistance[i，0]

HigMaxDistance＝i

Hit＝True

End If

End For

Hit＝True

For i＝HighMaxDistance-1to0by-1

StartFit＝MaxDistance[i，0]

Ifi＝NumMaxDistance-1

EndFit＝NurmberOfFits-1

Else

EndFit＝MaxDistance[i+1，0]-1

End If

Hit＝False

For j＝StartFit to EndFit While Hit＝False

If scanCompact(NumberOfNodes，Fit[j]，HighStart)＝True

HighFit＝j

HighMaxDistance＝I

Hit＝True

End If

End For

setCompactNodeInUse(Fit(HighFit)，HighStart)

在具体的实施例中，setCompactNodeInUse包括以下实例逻辑：

node＝0

For i＝0to2

if Start[i]≥TorustSize[i]

Start[i]＝Start[i]mod TorusSize[i]

End[i]＝Start[i]+Size[i]-1

End If

End For

If NumMapDiminsions＝1

If MapDiminsion[0]＝0

order[0]＝1

order[1]＝2

order[2]＝0

Else If MapDiminsion[0]＝1

order[0]＝0

order[1]＝2

order[2]＝1

Else

order[0]＝0

order[1]＝1

order[2]＝2

End If

Else

order[0]＝3-MapDiminsion[0]-MapDiminsion[1]

order[1]＝MapDiminsion[0]

order[2]＝MapDiminsion[1]

End If

count＝0

For i＝Start[order[0]]to end[order[0]]and count<RequestedNodes

index[order[0]]＝i mod TorusSize[order[0]]

For j＝Start[order[1]]to end[order[1]]and count<RequestedNodes

index[order[1]]＝j mod TorusSize[order[1]]

For k＝Start[order[2]]to end[order[2]]and count<RequestedNodes

index[order[2]]＝kmod TorusSize[order[2]]

IfNodeInUse[index[0]，index[1]，index[2]]＝NODE_NOT_IN_USE

NodeInUse[index[0]，index[1]，index[2]]＝NODE_IN_USE

AssignedNodeList[node，order[0]＝index[order[0]]

AssignedNodeList[node，order[1]＝index[order[2]]

AssignedNodeList[node，order[2]＝index[order[2]]

node＝node+1

End If

End For

在具体的实施例中，ScanCompact包括以下实例逻辑：

For i＝0to2

If PartWraps[i]＝True

end[i]＝PartEnd[i]

Else

end[i]＝PartEnd[i]-Start[i]+1

End If

For i＝PartStar[0]to end[0]

newX＝True

For n＝0to TorusSize[2]

ZPlane[n]＝0

End For

for(l＝i to i+size[0]

for(n＝pStart[2]；n≤pEnd[2]；n++)

l1＝lmod TorusSize[0]；

m1＝PartStart[1]

m2＝(PartStart[1]+size[1])mod TorusSize[1]

If PartStart[1]+size[1]≤PartEnd[1])

ZPlane[n]＝zPlane[n]+FreeY[l1，m1，n]-FreeY[l1，m2，n]

Else

ZPlane[n]＝zPlane[n]+FreeY[l1，m1，n]

End If

End For

For j＝PartStart[1]to End[1]

newY＝True

If newX＝False

l1＝i

l2＝(i+size[0])mod TorusSize[0]

m1＝j-1

If PartWraps[0]＝False or i+Start[0]≤PartEnd[0]

Forn＝PartStart[2]to PartEnd[2]

If i+size[0]≤PartEnd[0]

ZPlane[n]＝zPlane[n]-(FreeX[l1，m1，n]-

FreeX[l2，m1，n])

else

zPlane[n]＝zPlane[n]-FreeX[l1，m1，n]

End If

End For

Else

Forn＝PartStart[2]to PartEnd[2]

zPlane[n]＝zPlane[n]-(FreeX[l1，m1，n]+(FreeX[0，m1，n]

-FreeX[l2，m1，n]))

End For

End If

l1＝i

l2＝(i+Start[0])mod TorusSize[0]

m1＝(j+size[1]-1)mod TorusSize[1]

If PartWraps[0]＝False or i+Start[0])≤PartEnd[0]

Forn＝PartStart[2]to PartEnd[2]

If(i+Start[0]≤PartEnd[0])

ZPlane[n]＝zPlane[n]+(FreeX[l1，m1，n]-

FreeX[l1，m2，n]

Else

ZPlane[n]＝zPlane[n]+FreeX[l1，m1，n]

End If

End For

Else

Forn＝PartStart[2]to PartEnd[2]

ZPlane[n]＝zPlane[n]+(FreeX[l1，m1，n]+(FreeX[0，m1，n]

-FreeX[l1，m2，n]))

End For

End If

Else

newX＝False

End If

Fork＝PartStart[2]to end[2]

ifnewY＝True

newY＝False

count＝0；

Forn＝ktok+size[2]

count＝count+zPlane[nmod TorusSize[2]]

End For

Else

count＝count-zPlane[k-1]

k1＝(k+size[2]-1)mod TorusSize[2]

zPlane[k1]＝0

l1＝i

l2＝(i+size[0])mod TorusSize[0]

If PartWraps[0]＝False or i+size[0])≤PartEnd[0]

Form＝j toj+size[1]

m1＝mmod TorusSize[1]

If i+size[0]≤PartEnd[0]

ZPlane[k1]＝zPlane[k1]+(FreeX[l1，m1，k1]-

FreeX[l2，m1，k1])

Else

ZPlane[k1]＝zPlane[k1]+FreeX[l1，ml，k1]

End For

Else

Form＝j toj+size[1]

ZPlane[k1]＝zPlane[k1]+FreeX[l1，m1，k1]+

(FreeX[0，m1，k1]-FreeX[l2，m1，k1])

End For

End If

count＝count+zPlane[k1]

End If

If count≥NumberOf Nodes

Start[0]＝i

Start[1]＝j

Start[2]＝k

returnTrue

End If

End For

return False

在具体的实施例中，scheduleAny包括以下实例逻辑：

Node＝0

Remainder＝RequestedNodes

Form＝0to NumFreeMeshes while Remainder>0

If FreeMesh[m].Rank[0]＝2

iNdx＝FreeMesh[m].Rank[2]

jNdx＝FreeMesh[m].Rank[1]

Else IfFreeMesh[m].Rank[1]＝2

iNdx＝FreeMesh[m].Rank[2]

jNdx＝FreeMesh[m].Rank[0]

Else

iNdx＝FreeMesh[m].Rank[1]

jNdx＝FreeMesh[m].Rank[0]

End If

For i＝FreeMesh[m].Start[iNdx]toFreeMesh[m].end[iNdx]while Remainder

>0

For j＝FreeMesh[m].Start[jNdx]to FreeMesh[m].end[jNdx]while

Remainder>0

Fork＝FreeMesh[m].Start[2]to FreeMesh[m].end[2]while Remainder

>0

i1＝i mod TorusSize[iNdx]

j1＝j mod TorusSize[iMod]

k1＝kmod TorusSize[2]

IfiNdx＝0

NodeInUse[i1，j1，k1]＝NODE_IN_USE

Else

NodeInUse[j1，i1，k1]＝NODE_IN_USE

End If

AssignedNodeList[Node].[iNdx]＝i1

AssignedNodeList[Node].[jNdx]＝j1

AssignedNodeList[Node，2]＝k1

Node＝Node+1

End For

在具体的实施例中，setMpiRank包括以下实例逻辑：

For node＝0to RequestedNodes-1

to[0]＝AssignedNodeList[node，0]

to[1]＝AssignedNodeList[node，1]

to[2]＝AssignedNodeList[node，2]

If NumMapDiminsions＝1

to[MapDiminsion[0]]＝AssignedNodeList[node，MapDimension[0]]/

MapMod[0]

to[3]＝AssignedNodeList[node，MapDiminsion[0]]mod MapMod[0]

Else

to[MapDiminsion[0]]＝AssignedNodeList[node，MapDiminsion[0]]/

MapMod[0]

to[MapDiminsion[1]]＝AssignedNodeList[node，MapDiminsion[1]]/

MapMod[1]

to[3]＝(AssignedNodeList[node，MapDiminsion[0]]mod MapMod[0])×

MapMod[1]+

AssignedNodeList[node，MapDiminsion[1]]mod MapMod[1]

End If

hit＝False

for(nodel＝0to NumFreeNodes-1while hit＝False

If to[0]＝FreeNodeList[node1]，coordinate[0]and

to[l]＝FreeNodeList[node l].coordinate[1]and

to[2]＝FreeNodeList[nodel].coordinate[2]and

to[3]＝FreeNodeList[nodel].coordinate[3]

FreeNodeList[nodel].mpiRank＝node

Hit＝True

End If

End For

在具体的实施例中，调度器515使用如下定义的实例结构以将节点115分配给作业150。如上所述，群集管理引擎130将FreeNode结构的列表传输给与作业150一起的调度器515。该列表包括可用于调度的所有节点115。在所述列表中，基于开关的坐标识别所述列表中可用的节点115。如果调度器515调度作业150，调度器515在返回之前设置mpiRank。

Structure FreeNode

integer coordinate[4]

integer mpiRank

End Structure

在具体的实施例中，调度器515使用Fold结构以记录调度器515如何折叠一维和二维空间请求。

Structure Fold

integer foldLength

integer numFolds

integer remainder

integer foldDimension

integer fixDdimension

integer oneDimension

End Structure

在具体的实施例中，调度器515使用Try结构以记录用于调度空间作业150的网格上的信息。Try结构包括关于基本网格的信息并且等于两个连接网格。

Structure Try

integer baseSize[3]

integer numConcats

integer concatSize[2，3]

integer concatStartNode[2，3]

integer rMap[3]

integer irMap[3]

integer numFoldMaps

integer foldLength[2]

integer foldFrom[2]

integer foldTo[2]

integer foldFix[2]

End Structure

在具体的实施例中，调度器515使用FreeMesh以存储可用于调度的栅格110中的网格上的信息。调度器515使用FreeMesh以调度“任何”请求。

Structure FreeMesh

integer start[3]

integer end[3]

integer size[3]

integer rank[3]

integer numberOfNodes

End Structure

在具体的实施例中，调度器515使用如下定义的变量以将节点115分配给作业150。

·RequestedNodes：作业150所需的节点数目。

·RequestType：作业需求的类型：SPATIAL，COMPACT或者ANY。

·OriginalSize[3]：如果RequestType＝SPATIAL，就是作业150的大小。

·AggressiveFlag：零与一个数字之间的浮点数，该数字表示分配给调度器515的可允许的误差的程度，以用于将节点115分配给作业150。

·JobMap[3]：如果RequestType＝SPATIAL，OriginalSize的索引到一个更适合调度器515的序列的映射。

·RequestedSize[3]：如果RequestType＝SPATIAL，使用JobMap的调度器515 之后的作业150的大小。

·TorusSize[3]：按照CPU164的栅格110的大小。

·NodesPerSwitch：每个开关166的节点115的数目。

·NumFreeNodes：可用于调度的节点115的数目。

·FreeNodeList[NumFreeNodes]：可用于调度的传给调度器515的节点115的列表。

·SpatialAllowed：如果允许空间调度就设置为True。

·CompactAllowed：如果允许紧凑调度就设置为True。

·AnyAllowed：如果允许任意调度就设置为True。

·TorusMap[3]：从基于开关的环面索引到更适合调度器515的序列的映射。

·InverseTorusMap[3]：TorusMap的反转；应用到返回到集群管理引擎130之前的所有输出节点115。

·NumMapDimesions：从基于开关的环面到达节点基准环面的时候所修改的维数；可能的值为1和2。

·MapDimensions[2]：从基于开关的环面到达该节点基准环面的时候所修改的维数的索引。

·MapMod[2]：从基于开关的环面到达基于节点的环面的时候所使用的乘法器；NumMapDimesions＝1时其可能的值为MapMod[0]＝4，NumMapDimesions＝2时其可能的值为MapMod[0]＝2并且MapMode[1]＝2。

·PartSize[3]：分区的大小。

·PartStart[3]：分区的开始坐标。

·PartEnd[3]：分区的终止坐标。

·PartWraps[3]：如果分区在维数i中歪曲，则PartWraps[i]＝True。

·NodeInUse[TorusSize[0]，TorusSize[1]，TorusSize[2]]：NodeInUse[i，j，k]表示节点115的状态；其可能的值包括NODE_IN_USE(分配给另一作业150的节点115)，NODE_NOT_IN_USE(节点115可使用)，以及NODE_ON_HOLD(当将节点115分配给作业150的时候所使用的临时状态)。

·FreeY[TorusSize[0]，TorusSize[1]，TorusSize[2]]：FreeY[i，j，k]表示经过{i，TorusSize[1]-1，k}在内的线{i，j，k}中的自由节点115的数目。扫描例程使用FreeY。

·FreeX[TorusSize[0]，TorusSize[1]，TorusSize[2]]：FreeX[i，j，k]表示经过{TorusSize[0]-1，j，k}在内的线{i，j，k}中的自由节点115的数目。扫描例程使用FreeX。

·NumberOfTries：为空间需求所构建的Try结构的数目。

·TryList[NumberOfTries]：用于空间需求的Try结构的列表。

·NumberOfFits：为紧凑需求所构建的网格的数目。

·Fit[NumberOfFits，3]：为紧凑需求所构建的网格的列表。

·Fit[i，0]＝x维数中的网格i的大小。

·Fit[i，1]＝y维数中的网格i的大小。

·Fit[i，2]＝z维数中的网格i的大小。

·NumMaxDistances：Fit中的唯一最大距离的数目。

·MaxDistance[NumMaxDistances，2]：Fit中的唯一最大距离的列表。由于任意0≤i<NumMaxDistances，MaxDistance[i，0]＝编入具有最大距离＝MaxDistance[I，1]的第一网格的Fit之中的索引。

·NumFreeMeshes：栅格110中的自由网格的数目。自由网格是只包括自由节点115的网格。

·FreeMesh[NumFreeMeshes]：FreeMesh结构的数组。

·AssighedNodeList[RequestedNodes，3]：分配给具有MPI rank序列的作业150的节点115的列表。

群集管理引擎130，例如经过调度器515，可进一步可操作地执行有效的抽点检验。重启转储典型地包括要写入磁盘的数据的超过百分之七十五。这种I/O通常可使处理不因平台错误而失败。以此为基础，文件系统的I/O可被分解为两个部分：生产的I/O和防卫的I/O。生产的I/O是用户为科研而所要求的数据写入，例如可视化转储、超时的关键物理变量的轨迹等等。执行防卫的I/O以便管理运行了超过实际时间周期的大规模仿真。因此，改进的I/O带宽大大降低了包含在抽点检验中的时间和风险。

回到引擎130，本地存储器520包括系统100的多个特征的逻辑描述(或数据结构)。本地存储器520可以是任意由兼容的代码可操作地定义、处理或检索的物理或逻辑数据存储器。例如，本地存储器520可以包括一个或多个可扩展标记语言(XML)表格或文档。各种元件都可以按照SQL语句或脚本、虚拟存储访问方法(VSAM)文件、平面文件、二进制数据文件、Btrieve文件、数据库文件或逗号分隔值(CSV)文件来描述。可以理解，每个元件都可以包括变量、表格或任意其它合适的数据结构。本地存储器520还可以包括多个存储在服务器102上或穿过多个服务器或节点上的表格或文件。而且，虽然以驻留在引擎130内部来描述，但某些或全部的本地存储器520可以是内部或外部的，这不会背离所公开的范围。

所示的本地存储器520包括物理列表521、虚拟列表522、组文件523、策略表524以及作业队列525。但是，虽然未描述，本地存储器520可以包括其它数据结构，包括作业表格和检查日志，这也不会背离所公开的范围。回到所示的结构，物理列表521可操作地存储关于节点115的识别和物理管理信息。物理列表521可以是包括每个节点115至少具有一条记录的多维数据结构。例如，该物理记录可以包括例如“节点”、“有效性”、“处理器使用率”、“存储器使用率”、“温度”、“物理位置”、“地址”、“引导图像”等等的字段。可以理解，每个记录可包括无、一些或全部的实例字段。在一个实施例中，物理记录可以为另一表格，例如虚拟列表522提供外键码。

虚拟列表522可操作地存储关于节点115的逻辑或虚拟管理信息。虚拟列表522可以是包括每个节点115至少具有一条记录的多维数据结构。例如，该虚拟记录可以包括例如“节点”、“有效性”、“作业”、“虚拟群集”、“二级节点”、“逻辑位置”、“兼容性”等等的字段。可以理解，每个记录可包括无、一些或全部的实例字段。在一个实施例中，虚拟结论可以包括指向另一表格，例如群文件523的链接。

群文件523包括一个或多个表格或记录，用于可操作地存储用户群和安全信息，例如访问控制列表(或ACL)。例如，每个群文件可包括变量服务、节点115或用户作业的列表。每个逻辑群可以与企业集团或单位、部门、项目、保卫组或任何具有一个或多个用户的组织相结合，以能够提交作业150或管理系统100的至少一部分。基于这种信息，群集管理引擎130可确定提交作业150的用户是否是有效用户，如果是，则对作业执行最优化参数。而且，群表格523可以将每个用户群与虚拟群集220或一个或多个物理节点115来结合，其中节点115例如是驻留在特定的群的区域中的节点。这使得每个群具有单独的处理空间而不需竞争资源。然而，如上所述，虚拟群集220的形状和大小可以是动态的，并且可根据需求、时间或任意其它的参数来改变。

策略文件524包括一个或多个策略。可以理解，策略表格524和策略524可适当地交换使用。策略524通常存储关于作业150的处理和管理信息以及/或者虚拟群集220。例如，策略524可包括任意数目的参数或变量，包括问题大小、问题运行时间、时隙、优先权、节点115的用户分配共享或者虚拟群集220等等。

作业队列525呈现一个或多个等候执行的作业150的流。通常，队列525包括任意合适的数据结构，例如冒泡数组、数据库表格或指针数组，用于存储作业150的任意数目(包括零)或对此参考。可存在一个与栅格110或多个队列525相关联的队列525，其中每个队列525都与栅格110中的一个唯一的虚拟群集220相关联。

在操作的一个方面中，群集管理引擎130接收由N个任务所组成的作业150，这些任务通过执行计算和交换信息来共同解决一个问题。群集管理引擎130通过使用任意适当的技术，分配N个节点115并将N个任务中的每一个指定给一个特定的节点115，从而可使有效地解决该问题。例如，群集管理引擎130可以利用作业参数，诸如由用户提供的作业任务布局策略。无论如何，群集管理引擎130试图开发服务器102的体系结构，以便为用户按顺序提供更快的周转，并可能改善系统100的整体吞吐量。

在一个实施例中，群集管理引擎130然后根据下述实例拓扑，选择并分配节点115：

专用2D(x，y)或3D(x，y，z)-节点115被分配，并且任务可安排在专用空间中，从而保护了有效的临接点对临接点的通信。专用拓扑管理各种作业150，所希望的是物理通信拓扑与问题拓扑匹配，以使得作业150的协作任务频繁地与临接任务进行通信。例如，对2×2×2维(2，2，2)中的8个任务的需求将分配在立方体中。为了最合适的目的，2D分配可被“调入”3维中，同时保护有效的临接点对临接点的通信。群集管理引擎130在任意方向上可自由地分配专用维数形状。例如，2×2×8盒子可在有效的物理节点中垂直或水平地分配。

最合适的立方体-群集管理引擎130在立方体体积中分配N个节点115。这种拓扑有效地管理作业150，使得协作任务通过最小化任意两个节点115之间的距离，来与任意其它的任务交换数据。

最合是的球体-群集管理引擎130在球体体积中分配N个节点115。例如，第一任务可置于球体的中央节点115中，剩余的任务置于围绕该中央节点115的其它节点115上。可以理解，剩余任务的置放顺序典型地并不严格。这种拓扑可最小化第一任务和所有其它任务之间的距离。其有效地管理了一大类问题，其中任务2-N与第一任务进行通信，而不是互相通信。

随机-群集管理引擎130分配N个节点115，并较少地考虑节点115是逻辑定位还是物理定位。在一个实施例中，这种拓扑为填装的目的鼓励对栅格110的积极使用，而对其它作业150影响较小。

可以理解，之前的拓扑和所附解释都只是用于示例，也可以不为分配这种拓扑而描述实际所使用的拓扑或技术。

群集管理引擎130可以采用位置权重，并将其存储为作业150参数或策略524参数。在一个实施例中，该位置权值是0和1之间的调节器值，它表示群集管理引擎130应当有多主动地试图根据所需任务(或处理)位置策略来放置节点115。在这种实例中，值0表示仅有最优化策略(或维数)时有可能安置节点115，而值1表示只要有足够的自由度或反之惯例请求的有效节点115就立即安置节点115。典型地，位置权重会重视管理策略524，例如资源保护，以便防止大量作用150的缺乏并维持HPC系统100的作业吞吐量。

前面的示例和所附说明为实现管理节点115和作业150的逻辑方案而提供了引擎130的示意性模块图。然而，此图只是示意性的，可采用用于完成这些和其它算法的逻辑组件的任一种适当的组合和布置方式来规划系统100。这样，这些软件模块可以包括用于有效管理节点115和作业150的组件的任一种适当的组合和布置方式。而且，各种所示的模块的操作可以进行合理的组合及/或分离。

图11示出一个示例性接口104。接口104包括硬件、软件，或嵌有逻辑部件或者两个或多个这种部件的组合，以提供在网络106和HPC服务器102之间的接口。在特定的实施例中，接口104包括例示管理器534和例示数据536。例示管理器534包括硬件、软件，或嵌有逻辑部件或者两个或多个这种部件的组合，以响应于来自客户机120的连接请求动态地示出节点115的主机。在特定的实施例中，来自客户机120的连接请求是传输控制协议(TCP)连接请求。尽管这里给出的是TCP连接请求，但本发明也可以采用任一种适当的连接请求。作为实例但不是为了限制，来自客户机120的连接请求可以是用户数据报协议(UDP)或其它基于IP的连接请求。

在特定的实施例中，例示管理器534作为路由器或连接到路由器的接口，其中该路由器将关于HPC服务器102的在外部通告的主机名称和端口号映射到HPC服务器102的内部的主机名称和端口号。例示管理器534与群集管理引擎130(例如，物理管理器505、虚拟管理器510，或者两者皆有)的一个或多个部件互相作用，以便根据特定需要，响应于来自客户机120的连接请求，动态地示出一个或多个节点115上的一个或多个主机。

例示数据536包括用于响应于来自客户机120的连接请求而示出节点115上的主机的数据。在特定的实施例中，例示数据536包括关于HPC服务器102的在外部通告的一个或多个服务列表。所涉及的服务包括适当的应用程序，反之亦然。所涉及的关于HPC服务器102的在外部通告的服务列表可以包括适当的路由表，反之亦然。在特定的实施例中，例示管理器534建立并保持这种路由表。在特定的实施例中，关于HPC服务器102的在外部通告的服务列表中的条目指定了(1)服务，(2)与该服务相应的关于HPC服务器102的在外部通告的主机名称和端口号，以及(3)与在例示时提供该服务的主机相应的HPC102内部的主机名称和端口号。该条目还指定了规则、条件，或者当应该将主机设置为有效，当应该将主机示出，以及当应该将主机设置为无效的时候进行管理的上述两者。作为实例但不是为了限制，主机可以提供一台web服务器。如果例示管理器534不在上班时间内相应于web服务器而从HTTP端口接收HTTP请求，那么主机可以在上班时间内保持不例示的状态，并保留如果不例示的状态对其它主机、服务或其两者有效时该主机将会使用的一个或多个资源(例如栅格110中的节点115)。如果客户机120的用户使用一个web浏览器在上班时间内访问该web服务器，那么例示管理器534可以例示主机以便将该web服务器提供给客户机120。如果客户机120的用户使用一个web浏览器在上班时间之外访问该web服务器，那么例示管理器534就阻止HTTP端口响应该web服务器，以便防止主机将web服务器提供给客户机120。

在特定的实施例中，例示数据536包括一个或多个引导图像，用于例示节点115上的主机以提供服务。在特定的实施例中，例示数据536还包括一个或多个用于例示节点115上的主机的文件系统，以提供服务。在特定实施例中，示例数据536也包括一个或多个OS配置文件，用于例示节点115上的主机以提供服务。作为实例但不是为了限制，响应于例示管理器534接收来自客户机120的连接请求，指定一个关于HPC服务器102的在外部通告的端口号，其中该端口号是与关于HPC服务器102的在外部通告的服务相应的，例示管理器534就使用引导图像以及用于该服务的一个或多个文件系统，来引导栅格110中的一个有效节点115，以便初始化在节点115上用于该服务的主机。例示管理器534还可以更新一个或多个本地路由表以及一个或多个OS配置文件，以便将IP通信量从客户机120路由到节点115。在特定的实施例中，为了减少响应于来自客户机120的连接请求而关联HPC服务器102所需的时间，例示管理器534欺骗了目标主机的IP/MAC地址，并启动代表目标主机的TCP/IP连接序列。该位于客户机120和例示管理器534之间的TCP/IP连接序列发生在引导目标主机的过程中。尽管描述了一种TCP/IP连接序列，但本发明也可采用任一种合适的连接序列。作为实例但不是为了限制，例示管理器534可以启动代表目标主机的基于IP的用户数据报协议(UDP)(UDP/IP)或其它基于IP的连接序列。

在特定的实施例中，例示管理器534跟踪HPC服务器102上的每台主机是有效还是无效。在特定的实施例中，例示管理器534还控制HPC服务器102上的每台主机是有效还是无效。在特定的实施例中，例示管理器534可确定服务是否应当有效。如果例示管理器534确定了服务应当不再有效，那么例示管理器534就关闭、空闲，或相反使一个或多个节点115无效，其中在该节点115上例示管理器534例示主机以提供服务并因此更新一个或多个路由表。

图12是说明根据本发明所揭示的一个实施例用于动态处理作业提交的示意性方法600的流程图。通常，图12描述了方法600，其接收一批作业提交，动态地基于作业参数和相关策略524将节点115分配到作业空间230中，并使用所分配的空间执行作业150。下面的描述集中于在执行方法600的过程中群集管理模块130的操作上。但系统100试图使用逻辑部件的任意合适的组合和设置，该逻辑部件实现所描述的某些或全部功能，只要该功能是适当的。

方法600开始于步骤605，这里HPC服务器102接收来自由户的作业提交150。如上所述，在一个实施例中，用户可使用客户机120提交作业150。在另一实施例中，用户可直接使用HPC服务器102来提交作业150。接着，在步骤610中，群集管理引擎130根据用户来选择群523。用户一经验证，群集管理引擎130就在步骤615中将该用户与群访问控制列表(ACL)进行比较。但可以理解，群集管理引擎130可以使用任一种适当的安全技术来验证用户。基于所确定的群523，群集管理引擎130确定用户是否已访问所请求的服务。基于所请求的服务和主机名，群集管理引擎130在步骤620中选择虚拟群集220。典型地，虚拟群集220可被识别并由于作业150的提交而被分配。但是，如果虚拟群集220还没有建立，群集管理引擎130就可以自动地使用上述任一种技术来分配虚拟群集220。接着，在步骤625中，群集管理引擎130基于作业150的提交来检索策略524。在一个实施例中，群集管理引擎130可以确定与用户、作业150或任意其它合适的标准关联的合适的策略524。群集管理引擎130然后在步骤630中确定或相反计算作业150的维数。可以理解，适当的维数可包括长度、宽度、高度，或任意其它适当的参数或特征。如上所述，这些维数用于在虚拟群集220内确定适当的作业空间230(或节点115的子集)。在建立了初始参数之后，群集管理引擎130在步骤635至665中试图在HPC服务器102上执行作业150。

在判决步骤635中，群集管理引擎130采用已建立的参数来确定是否存在着足够有效的节点来分配所需的作业空间230。如果没有足够的节点115，群集管理引擎130就在步骤640中确定虚拟群集220中的最早有效的节点115的子集230。然后，群集管理引擎130在步骤645中将作业150添加到作业队列125中，直到子集230变成有效。处理然后回到判决步骤635。一旦有足够的有效节点115，群集管理引擎130就在步骤650中动态地从有效的节点115中确定最优化的子集230。可以理解，可以使用任一种适当的标准来确定最优化子集230，包括最快处理时间、最可靠节点115、物理或虚拟位置或者第一有效节点115。在步骤655中，群集管理引擎130从所选的虚拟群集220中选择子集230。接着，在步骤660中，群集管理引擎130使用所选的子集230为作业150分配所选的节点115。根据一个实施例，群集管理引擎130可以将虚拟节点列表522中的节点115的状态从“未分配”改变为“已分配”。由于子集230已经进行了合理分配，群集管理引擎130就在步骤665中基于作业参数、检索的策略524以及任意其它合适的参数，使用所分配的空间来执行作业150。在任意适当的时间上，群集管理引擎130可以通信或相反向用户示出作业结果160。例如，结果160可以被格式化并通过GUI126向用户示出。

图13是说明根据本发明所揭示的一个实施例用于在栅格110中动态回填虚拟群集220的示意性方法700的流程图。在较高层次中，方法700描述了在虚拟群集220中确定有效空间，确定与该空间兼容的最优化作业150，以及在有效空间内执行所确定的作业150。下面的描述将集中于执行该方法的群集管理模块130的操作。但是，与之前的流程图一样，系统100也试图使用实现某些或全部所述功能的逻辑部件的任意合适的组合及设置。

方法700开始于步骤705，这里群集管理引擎130对作业队列525进行分类。在所示的实施例中，群集管理引擎130基于存储在队列525中的作业150的优先权来分类队列525。但也可以理解，群集管理引擎130可以使用任一种合适的特征来分类队列525，以便执行合适的或最佳的作业150。接着，在步骤710中，群集管理引擎130确定一个虚拟群集220中的有效节点115的数目。当然，群集管理引擎130还可以确定栅格110中或任意一个或多个虚拟群集220中的有效节点115的数目。在步骤715，群集管理引擎130从所分类的作业队列525中选择第一作业150。接着，群集管理引擎130在步骤720中动态地确定所选的作业150的最优化形状(或其它维数)。所选的作业150的最优化形状或维数一经确定，那么群集管理引擎130就在步骤725至745中确定是否可在适当的虚拟群集220中回填作业150。

在判决步骤725中，群集管理引擎130确定是否存在着足够的有效节点115以用于所选的作业150。如果存在着足够的有效节点115，那么在步骤730中群集管理引擎130使用任一种适当的技术动态地为所选的作业150分配节点115。例如，群集管理引擎130可使用在图6中描述的技术。接着，在步骤735中，群集管理引擎130重新计算虚拟群集220中有效节点的数目。在步骤740中，群集管理引擎130在所分配的节点115上执行作业150。一旦执行了作业150(或者如果没有足够的用于所选作业150的节点115)，那么群集管理引擎130就在步骤745中在所分类的作业队列525中选择下一作业150，并且处理返回到步骤720。可以理解，虽然所示的是一个循环，但群集管理引擎130也可以在任意适当的时间启动、执行并终止方法700所示的技术。

图14是说明根据本发明所揭示的一个实施例的用于动态管理栅格110中节点115的故障的示意性方法800的流程图。在较高层次中，方法800确定节点115故障，自动执行作业恢复和管理，以及用二级节点115替代故障节点115。下面的描述将集中于在执行该方法中群集管理模块130的操作。但是，与之前的流程图一样，系统100也可以使用实现某些或全部所述功能的逻辑部件的任意合适的组合及设置。

方法800开始于步骤805，这里群集管理引擎130确定节点115已发生故障。如上所述，群集管理引擎130可以使用任一种适当的技术来确定节点115已发生故障。例如，群集管理引擎130可多次拉动节点115(或代理132)，可以基于缺乏来自节点115的响应来确定节点115已发生故障。在另一实例中，存在于节点115中的代理132可以发送“心跳”，并且缺乏该“心跳”就表示节点115故障。接着，在步骤810中，群集管理引擎130从虚拟群集220中移走故障的节点115。在一个实施例中，群集管理引擎130可以将虚拟列表522中的节点115的状态从“已分配”改变为“故障”。群集管理引擎130然后在判决步骤815中确定作业150是否与故障的节点115相关。如果不存在与节点115相关联的作业150，那么处理结束。如上所述，在处理结束之前，群集管理引擎130可以将出错消息发送给管理员，自动地确定替换节点115，或者任意其它适当的处理。如果存在着与故障节点115相关的作业150，那么群集管理引擎130就在步骤820中确定与该作业150相关的其它节点115。接着，在步骤825中，群集管理引擎130在所有适当的节点115上断开作业150。例如，群集管理引擎130可执行端口作业命令或者使用任意其它适当的技术来结束作业150。接着，在步骤830中，群集管理引擎130用虚拟列表522对节点115进行再分配。例如，群集管理引擎130可以将虚拟列表522中的节点115的状态从“已分配”改变为“有效”。一旦终止作业并且对所有适当的节点115进行了再分配，那么群集管理引擎130就在步骤835至850中试图使用有效的节点115重新执行作业150。

在步骤835中，群集管理引擎130在步骤835中检索策略524和用于断开作业150的参数。群集管理引擎130然后在步骤840中，基于所检索的策略524和作业参数，确定虚拟群集220中的节点115的最优化子集230。一旦确定节点115的子集230，群集管理引擎130就在步骤845中动态地分配节点115的子集230。例如，群集管理引擎130可以将虚拟列表522中的节点115的状态从“未分配”改变为“已分配”。可以理解，节点115的这种子集可以与正在执行作业150的节点的原始子集不同。例如，群集管理引擎130根据提示这种执行的节点故障115，可确定节点的不同子集是最佳的。在另一实例中，群集管理引擎130可能已确定二级节点115可操作地替换故障节点，并且新的子集230实质上与旧的作业空间230相似。一旦已确定所分配的子集230并进行分配，群集管理引擎130就在步骤850中执行作业150。

之前的流程图和所附说明图解了示意性的方法600、700和800。简而言之，系统100可采用任一种适当的用于实现这些和其它任务的技术。因此，该流程图中的许多步骤都是同时地并且/或者按与所示出的不同的顺序发生的。而且，系统100可以使用带有额外步骤、更少步骤，以及/或者不同步骤的方法，只要方法仍是合适的。

图15说明了在HPC系统100中用于按需式例示的示意性方法。该方法开始于步骤900，这里接口104接收来自客户机120的连接请求，该客户机120指定关于HPC服务器102的在外部通告的端口号和主机名称。在步骤902中，响应于该连接请求，例示管理器534访问提供了关于HPC服务器102的在外部通告的服务列表的例示数据536。在步骤904中，例示管理器534使用该服务列表来识别与在连接请求中指定的端口号和主机名称相应的服务。在步骤906，例示管理器534根据该服务列表，确定所识别的服务对客户机120是有效的。如上所述，所识别的服务对客户机120是否有效将依赖于与连接请求相关的时间、客户机120上的用户身份或连接请求的其它方面。在步骤906中，如果识别的服务对客户机120有效，方法就前进到步骤908。在步骤908中，例示管理器534使用例示数据536来示出栅格110中的一个或多个节点115上的主机，以便将所识别的服务提供给客户机120，其中该例示数据536表示与所识别的服务相应的HPC服务器102内部的主机名称和端口号。如上所述，例示管理器534还可以使用包括引导图像、文件系统和OS配置的例示数据536，来示出节点115上的主机，在这里该方法结束。在步骤906中，如果所识别的服务对客户机120无效，该方法前进到步骤910。在步骤910中，例示管理器534阻止在连接请求中指定的端口，以防止客户机120访问该识别的服务，在这里该方法结束。尽管图15中所示的方法中的特定步骤已被说明且被描述为根据特定顺序的发生事件，但是图15所示的方法中的任意适当的步骤也能以任意适当的顺序而发生。

尽管已经按照确定的实施例及通常相关的方法对所揭示的内容进行了描述，但对于本领域的技术人员来说，这些实施例和方法的改变和置换都将是显而易见的。因此，示意性实施例的上述说明不是定义或约束所揭示的内容。也可以进行其它的改变、替换和变更，而不脱离所揭示的内容的精神和范围。

Claims

1.一种用于在高性能计算（HPC）系统中按需式例示的装置，所述装置包括：

接收来自客户机的连接请求的装置，该连接请求指定第一端口号和第一主机名称，所述第一端口号和第一主机名称相对于多个节点是外部通告的，每个节点包括一个开关组织和两个处理器；

识别所述多个节点上的服务的装置，所识别的服务相应于该第一端口号和第一主机名称；

根据所述连接请求的一个或多个方面以及一个或多个表示所述服务是否有效的规则，确定所识别的服务是否有效的装置；

如果所识别的服务根据所述连接请求的一个或多个方面以及一个或多个表示所述服务是否有效的规则被确定为有效，就例示在所述多个节点中的一个或多个节点上提供所识别服务的主机的装置，其中例示所述主机包括：使用相应于所识别的服务的引导图像、文件系统和操作系统OS配置文件以响应于所接收的连接请求来引导所述多个节点的至少一个节点；

欺骗在群集中的一个或多个节点上提供所识别的服务的主机的地址，并启动代表正在进行引导的主机的连接序列的装置，其中所述引导是响应于所接收的连接请求执行的，

其中，所述操作系统OS配置文件由例示管理器所更新。

2.如权利要求1的装置，其中连接请求是传输控制协议（TCP）连接请求或用户数据报协议（UDP）连接请求。

3.如权利要求1的装置，还包括：

访问包括多个条目的在所述多个节点上的服务列表的装置，其中每个条目指定了一种服务，以及一个或多个表示该服务是否有效的规则；以及

根据服务列表确定所识别的服务是否有效的装置。

4.如权利要求3的装置，其中该规则基于与来自客户机的连接请求相关的时间来表示该服务是否有效。

5.如权利要求4的装置，还包括：

如果基于与来自客户机的连接请求相关的时间所识别的服务为无效，就阻止与第一端口号相应的所述多个节点上的端口，以便防止客户机访问所识别的服务的装置。

6.如权利要求1的装置，还包括：

访问所述多个节点上与在所述多个节点中的一个或多个节点上提供所识别的服务的主机相应的引导图像、文件系统和操作系统（OS）配置文件的装置；以及

使用该引导图像、文件系统和OS配置文件，以响应于所接收的连接请求例示在所述多个节点中的一个或多个节点上提供所识别的服务的主机的装置。

7.如权利要求1的装置，其中所识别的服务是web服务器的服务。

8.如权利要求1的装置，其中：

该地址是基于媒体存取控制的网际协议（IP/MAC）地址；以及

该连接序列是基于IP的传输控制协议（TCP/IP）连接序列或者基于IP的用户数据报协议（UDP）（UDP/IP）连接序列。

9.如权利要求1的装置，其中节点群集按照包括3维环面的拓扑，包括多个互相耦合的节点。

10.一种用于在高性能计算（HPC）系统中按需式例示的方法，该方法包括：

接收来自客户机的连接请求，该连接请求指定第一端口号和第一主机名称，所述第一端口号和第一主机名称相对于多个节点是外部通告的，每个节点包括一个开关组织和两个处理器；

识别所述多个节点上的服务，所识别的服务相应于该第一端口号和第一主机名称；

根据所述连接请求的一个或多个方面以及一个或多个表示所述服务是否有效的规则，确定所识别的服务是否有效；以及

如果所识别的服务根据所述连接请求的一个或多个方面以及一个或多个表示所述服务是否有效的规则被确定为有效，就例示在所述多个节点的一个或多个节点上提供所识别的服务的主机，其中例示所述主机包括：使用相应于所识别的服务的引导图像、文件系统和操作系统OS配置文件以响应于所接收的连接请求来引导所述多个节点的至少一个节点；

欺骗在所述多个节点中的一个或多个节点上提供所识别的服务的主机的地址，并启动代表正在进行引导的主机的连接序列，其中所述引导是响应于所接收的连接请求执行的，

其中，所述操作系统OS配置文件由例示管理器所更新。

11.如权利要求10的方法，其中连接请求是传输控制协议（TCP）连接请求或用户数据报协议（UDP）连接请求。

12.如权利要求10的方法，还包括：

访问包括多个条目的在多个节点上的服务列表，其中每个条目指定了一种服务，以及一个或多个表示该服务是否有效的规则；以及

根据服务列表确定所识别的服务是否有效。

13.如权利要求12的方法，其中该规则基于与来自客户机的连接请求相关的时间来表示该服务是否有效。

14.如权利要求13的方法，还包括：

如果基于连接请求相关的时间所识别的服务为无效，就阻止与第一端口号相应的多个节点上的端口，以便防止客户机访问所识别的服务。

15.如权利要求10的方法，还包括：

访问所述多个节点上与在所述多个节点中的一个或多个节点上提供所识别的服务的主机相应的引导图像、文件系统和操作系统（OS）配置文件；以及

使用该引导图像、文件系统和OS配置文件，以响应于所接收的连接请求例示在所述多个节点中的一个或多个节点上提供所识别的服务的主机。

16.如权利要求10的方法，其中所识别的服务是web服务器的服务。

17.如权利要求10的方法，其中：

该地址是基于媒体存取控制的网际协议（IP/MAC）地址；以及

18.如权利要求10的方法，其中节点群集按照包括3维环面的拓扑，包括多个互相耦合的节点。