CN1776622A - 高性能计算(hpc)系统中的调度式 - Google Patents
高性能计算(hpc)系统中的调度式 Download PDFInfo
- Publication number
- CN1776622A CN1776622A CNA2005100878572A CN200510087857A CN1776622A CN 1776622 A CN1776622 A CN 1776622A CN A2005100878572 A CNA2005100878572 A CN A2005100878572A CN 200510087857 A CN200510087857 A CN 200510087857A CN 1776622 A CN1776622 A CN 1776622A
- Authority
- CN
- China
- Prior art keywords
- node
- trooping
- compact
- space
- management engine
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F15/00—Digital computers in general; Data processing equipment in general
- G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/48—Indexing scheme relating to G06F9/48
- G06F2209/483—Multiproc
Abstract
在一个实施例中，一种用于在高性能计算(HPC)系统中调度式的方法包括：接收来自在HPC系统内管理节点群集的管理引擎的调用。该调用指定了包括用于调度的作业的请求。该方法进一步包括确定该请求是否是空间的、紧凑的、或非空间和不紧凑的。该方法进一步包括，如果请求是空间的，在群集内产生一个或多个节点空间组合并且选择空间组合中可调度的一个。该方法进一步包括，如果请求是紧凑的，在群集内产生一个或多个节点紧凑组合并且选择紧凑组合中可调度的一个。该方法进一步包括，如果请求是非空间和不紧凑的，识别一个或多个可调度的节点并且在群集内产生一节点的非空间和不紧凑组合。
Description
技术领域
该公开内容一般涉及数据处理，尤其涉及HPC系统中的调度式。
背景技术
高性能计算(HPC)通常被科学家和技术人员为模拟、仿真和分析复杂的物理或算法现象而使用的计算系统所表征。目前，通常使用称为节点的一个或多个处理器的许多HPC群集来设计HPC机器。对于更大的科学和工程应用来说，主要由并行可测量性而非单个节点的速度来确定性能；所以，在构建或购买所述高性能群集的过程中可测量性是一个限制因素。通常基于以下条件来考虑可测量性：i)硬件；ii)存储器，输入/输出(I/O)，以及通信带宽；iii)软件；iv)体系结构；以及v)应用程序。在很多传统的HPC环境中的处理、存储器、以及I/O带宽通常不能很好的平衡，因此，不能很好的测量。许多HPC环境不具有满足高端数据处理需求的I/O带宽或利用安装有太多不需要的部件的叶片来构造，这样趋向于大大减少系统的可靠性。因此，许多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的高性能计算系统提交成批作业的方法的流程图；
图12是用于说明根据图1的高性能计算系统的栅格动态回填的方法的流程图；以及
图13是用于说明根据图1的高性能计算系统来动态管理节点故障的方法的流程图。
附图的详细描述
图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)、公知的全部或一部分全球计算机网络、和/或一个或多个位置上的任意其他通信系统或多个通信系统。
通常，特大容量磁盘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包括InfiniBand 4X链路，其能够在每一方向上进行大约每秒一千兆字节的通信。虽然说明和描述了具体的链路168，但是本发明适于任意合适的链路168。链路170是到节点115的I/O链路。链路170包括InfiniBand 4X链路，其能够在每一方向上进行大约每秒一千兆字节的通信。虽然说明和描述了具体的链路170，但是本发明适于任意合适的链路170。如以下所述那样，链路172将开关166耦合到其他节点115的其他开关166上。在具体的实施例中，链路172包括InfiniBand 12X链路，其能够在每一方向上进行大约每秒三千兆字节的通信。虽然说明和描述了具体的链路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是LINDENHURSTE7520 MCH 176。在具体的实施例中，存储单元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-Express 8X总线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是插座(plug in)。在具体的实施例中，响应接收作业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
οSpatialAllowed＝False
οCompactAllowed＝False
οAnyAllowed＝Ttue
·否则如果RequestedType＝SPATIAL
οSpatialAllowed＝True
οAnyAllowed＝False
ο如果AggressiveFlag＞0
·CompactAllowed＝True
ο否则
·CompactAllowed＝False
·否则如果RequestedType＝Compact
οSpatialAllowed＝False
οCompactAllowed＝True
οAnyAllowed＝False
·否则如果RequestedType＝Any
οSpatialAllowed＝False
οCompactAllowed＝False
ο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使用TryStructure记录每一种所述构造。
如果CompactAllowed是True，调度器515构建一种包含请求数量的节点115的紧凑网格。调度器515指定所述网格一种最佳匹配并且在BestFit(包括阵列)中存储所述网格。作为非限制性实例，N为所请求的节点115的数量，Q为N的立方根舍取为整数。调度器首先将BestFit设置为{Q，Q，Q}。如果N＝Q3，那么运行调度器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+10+(Sy-1)+(Sz-1)。如果两个网格具有彼此相等的最大跳跃总数，那么调度器515将接近于立方体的网格放置在另一网格之前。作为非限制性实例，M1＝{4，6，16}并且M2＝{8，9，9}具有相同的最大距离，但是调度器515将M2放置在M1之前。
即使调度器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 Rank i。
为了调度具有尺寸为{Sx，Sy，Sz}的空间请求，调度器515使用扫描算法以为所述空间请求查找NodeInUse中的起始点。接下来的实例逻辑提供了一种扫描算法实例的实例描述。PartStart是起始点，PartEnd是分区的终点，Tx，Ty以及Tz分别是x，y以及z维中环面的尺寸。
For x＝PartStart[0] to PartEnd[0]
For y＝PartStart[1] to PartEnd[1]
For z＝PartStart[2] to PartEnd[2]
Hit＝True
For i＝x to x+Sx-1
For j＝y to y+Sy-1
For k＝z to z+Sz-1
If(NodeInUse[i mod Tx，j mod Ty，k mod Tz)＝
NODE_IN_USE
Hit＝False
End If
End For
End For
End For
If(Hit＝True)
Return True
End If
End For
End For
End For
Return False
在具体的实施例中，扫描算法用如下所示的最内部循环中增加的Count值替换上述Hit标志：
Count＝0 For i＝x to x+Sx-1 For j＝y to y+Sy-1 For k＝z to z+Sz-1 If(NodeInUse[i mod Tx，j mod Ty，k mod Tz)＝NODE_NOT_IN_USE Count＝Count+1 End If End For End For 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循环的终点：
ο对于i＝0到2
如果PartWraps[i]＝True，end[i]＝PartEnd[i]
否则end[i]＝ParEnd[i]-Size[i]
ο现在x将从PartStart[0]循环到End[0]等等。
x循环
ο对于每个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的数目。
ο为以下的y循环而设置NewX＝True
y循环
ο如果NewX＝True
不做任何操作。
ο否则
更新zPlane
对于每个z＝PartStart[2]到PartEnd[2]，
在Zplane[z]中从线段{x，y-1，z}到{x+Sx-1，y-1，z}提取自由节点115。
ο利用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]。
ο利用FreeX[x，y+Sy-1，z]-FreeX[x+Sx，y+Sy-1，z]以避免x之上的循环。
ο为下一个y增量而设置NewX＝False
ο为以下的z循环而设置NewY＝True
z循环
ο如果NewY＝True
从z＝PartStart[2]到z＝PartEnd[2]总和zPlane并将结果记录在Count中。
ο否则
从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
ο如果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 Rank i的节点115的x坐标，AssignedNodeList[i，1]是MPI Rank i的节点115的y坐标，AssignedNodeList[i，2]是MPI Rank i的节点115的z坐标。FreeNodeList是基于开关的坐标中传到调度器515的可用节点115的列表。在具体的实施中，为设置FreeNodeList中的mpiRank字段，调度器515使用以下实例算法：
·对于i＝0到NumFreeNodes-1
ο将AssignedNodeList[i]转换为基于开关的坐标并将其添加到Ro[4]。
ο将反相的InverseTorusMap应用到To的第一三个部件
ο对于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_ASSUGBNENT_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 End If 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 For i＝0 to 2 For j＝i+1 to 2 If In[Rank[j]＜In[Rank[i] k＝Rank[j] Rank[j]＝Rank[i] Rank[i]＝k End If End For End For
在具体的实施例中，确定作业150在理论上是否可被调度的setSchedulable包括以下实例逻辑：
For i＝0 to 2 If TorusSize[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 For i＝0 to 2 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 Return False Else If RequestedSize[jRank[Exceed[0]]≤factor[0]× TorusSize[tRank[Exceed[0]and RequestedSize[jRank[Exceed[1]]≤factor[1]× TorusSize[tRank[Exceed[1]] Return True End If If NumJobDim＜3 and(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＝1 or 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
<!-- SIPO <DP n="35"> -->
<dp n="d35"/>
End If
factor[0]＝2
fator[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 set TorusForSpatial()＝False
Return False
End If
Else If CompactAllowed＝True
If setTorusForCompactl()＝False
Return False
End If
Else
If setTorusForAny()＝False
Return False
End If
End If
For i＝0 to 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
buildFreeMeshes()
End If
If SpatialAllowed＝True or CompactAllowed＝True
InitScan()
End If
return True
在具体的实施例中，用于将基于开关的环面映射到基于节点的环面以用于空间请求的setTorusForSpatial包括以下实例逻辑：
Rank(RequestedSize，jRank) NumDim＝0 dNdx＝0 For i＝0 to 2 If RequestedSize[i]＞1) twoD[NumDim]＝i NumDim＝NumDim+1 Else oneD[dNdx]＝i dNdx＝dNdx+1 End If End For If NumDim＝1 Return setTorusFor1D() 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＝0 to 3 ntSize[i]＝TorusSize[TorusMap[i]] End For For i＝0 to 3 TorusSize[i]＝ntSize[i] End For For i＝0 to 3 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＝0 to 2
For j＝i+1 to 3
NumMapDiminsions＝2
mapDiminsions[0]＝(i+j)mod 3
mapDiminsions[1]＝(i+j+1)mod 3
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]
<!-- SIPO <DP n="38"> -->
<dp n="d38"/>
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
End For
For i＝0 to 3
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)
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
Return setTorusForCompact()
Else
return False
End If
Else
For i＝0 to 2
ntSize[i]＝TorusSize[TorusMap[i]]
End For
For i＝0 to 2
TorusSize[i]＝ntSize[i]
End For
If maxNdx＜3
NumMapDiminsions＝2
mapDiminsions[0]＝(maxNdx+1)mod 3
mapDiminsions[1]＝(maxNdx+2)mod 3
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]
<!-- SIPO <DP n="39"> -->
<dp n="d39"/>
JobMap[jRank[2]]＝mapDiminsions[1]
JobMap[jRank[0]]＝3-mapDiminsions[0]-mapDiminsions[1]
Else
NumMod＝1
NumMapDiminsions＝1
mapDiminsions[0]＝(5-maxNdx)mod 3
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
End If
Return True
在具体的实施例中，setTorusFor3D包括以下的实例逻辑：
max＝-1
maxNdx＝-1
For i＝0 to 2
For j＝i+1 to 2
NumMapDiminsions＝2
mapDiminsiona[0]＝(i+j)mod 3
mapDiminsions[1]＝(i+j+1)mod 3
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
End For
For i＝0 to 2
<!-- SIPO <DP n="40"> -->
<dp n="d40"/>
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
Return setTorusForCompact()
Else
return False
End If
Else
For i＝0 to 2
ntSize[i]＝TorusSize[TorusMap[i]]
End For
For i＝0 to 2
TorusSize[i]＝ntSize[i]
End For
If maxNdx＜3
NumMod＝2
mod[0]＝(maxNdx+1)mod 3
mod[1]＝(maxNdx+2)mod 3
NumMapDiminsions＝2
mapDiminsions[0]＝(maxNdx+1)mod 3
mapDiminsions[1]＝(maxNdx+2)mod 3
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)
<!-- SIPO <DP n="41"> -->
<dp n="d41"/>
NumMapDiminsions＝1
mapDiminsions[0]＝(5-maxNdx)mod 3
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]＝orginalSize[jRank[0]]；
JobMap[jRank[2]]＝mapDiminsions[0]
JobMap[jRank[1]＝i
JobMap[jRank[0]]＝3-mapDiminsions[0]-i
End If
End If
Return True
在具体的实施例中，将紧凑请求的z维设置为4×1配置的setTorusForCompact包括以下的实例逻辑：
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 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 mapDiminsioms[0]＝2 mapMod[0]＝NodesperGrid Return True
在具体的实施例中，setPartion包括以下的实例逻辑：
For i＝o 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 End For End For For i＝0 to 2 PartStart[i]＝TorusSize[i] Part End[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 NumMapDimensions＝1 To[MapDimension[0]]＝To[MapDimension[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 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]-1 to 0 by-1 If NodeInUse[i，j，k]＝NODE_NOT_IN_USE Count＝Count+1 End If FreeY[i，j，k]＝Count End For End For 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 End For End For
在具体的实施例中，用于确定请求中维数的数量的buildSpatialTries包括以下的实例逻辑：
NumDim＝0 For i＝0 to 2 If RequestedSize[i]＞1) NumDim＝NumDim+1 End If End For If NumDim＝1 build1DTry() Else If NumDim＝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 NumOrient＞0 For(i＝0 to NumOrient-1 ++NumTries； For j＝0 to 2 TryList[NumberOfTries].baseSize[j]＝Try.baseSize[orient[i，j]] End For 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]； End For End For TryList[NumberOfTries].NumFoldMaps＝Try.NumFoldMaps； For j＝0 to TryList[NumberOfTries].NumFoldMaps TryList[NumberOfTries].foldLength[j]＝Try.foldLength[j] TryLiat[NumberOfTries].foldFrom[j]＝Try.fo1dFrom[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
<!-- SIPO <DP n="46"> -->
<dp n="d46"/>
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
End For
If size[0]≤PartSize[0]and size[1]≤PartSize[1]andsize[2]≤PartSize[2]
orient[NumOrient，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[NurmOrient，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
NumOrient＝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[NumOrient，2]＝0
NumOrient＝NumOrient+1
End If
Else If Try.baseSize[0]＝Try.baseSize[1]
If try.baseSize[0]＝try.baseSize[2]
<!-- SIPO <DP n="47"> -->
<dp n="d47"/>
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
<!-- SIPO <DP n="48"> -->
<dp n="d48"/>
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 Tty.baseSize[1]≤PartSize[0]and Try.baseSize[0]≤PartSize[1]and
Try.baseSize[2]≤PartSize[2]
<!-- SIPO <DP n="49"> -->
<dp n="d49"/>
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[NriOrient，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
End If
在具体的实施例中，build2Dtry包括以下实例逻辑：
Rank(PartSize，pRank)
build2DFold(PartSize，pRank，RequestedSize，NumFolds，FoldList)
For i＝0 to NumFolds-1
d1＝RequestedSize[FoldList[i].fixDimension]+FoldList[i].foldLengtht+
FoldList[i].NumFolds
If FoldList[i].remainder not equal 0
d1＝d1+1
End If
For j＝i+1 to NumFolds-1
D2＝RequestedSize[FoldList[j].fixDimension]+FoldList[j].foldLengtht+
FoldList[j].NumFolds
If FoldList[j].remainder not equal 0
D2＝d2+1
End If
If d2＜d1
<!-- SIPO <DP n="50"> -->
<dp n="d50"/>
TempFold＝FoldList[j]
FoldList[j]＝FoldList[i]
FoldList[i]＝tempFold
d1＝d2
End If
End For
End For
NumberOfTries＝0
For i＝0 to 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 equal 0
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].
fixDimension]
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＝0 to 2
If size[i]＝1 and oneD＝-1
oneD＝i
<!-- SIPO <DP n="51"> -->
<dp n="d51"/>
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
<!-- SIPO <DP n="53"> -->
<dp n="d53"/>
rank(t，tRank)
hit＝False
For i1＝0 to 2 while hit＝False
If t[tRank[i1]]＞PartSize[pRank[i1]]
hit＝True
End If
If hit＝False
foldIndex＝foldIndex+1
End If
For i＝startFoldB to endFoldB
FoldList[foldIndex].foldLength＝i
FoldList[foldIndex].NumFolds＝size[bigD]/i
FoldList[foldIndex].remainder＝size[bigD]mod i
FoldList[foldIndex].foldD＝bigD
FoldList[foldIndex].fixD＝littleD
FoldList[fodIndex].oneD＝oneD
t[littleD]＝size[littleD]
t[bigD]＝FoldList[foldIndex].foldLength
If(FoldList[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 i1＝0 to 2 while 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
If FoldList[foldIndex].remainder not equal 0
t[oneD]＝FoldList[foldIndex].NumFolds+1
Else
<!-- SIPO <DP n="54"> -->
<dp n="d54"/>
t[oneD]＝FoldList[foldIndex].NumFolds
End If
Rank(t，tRank)
hit＝False
for i1＝0 to 2 while 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
在具体的实施例中，build1 Try产生一维请求的折叠的列表，并且对于每一折叠来说，调用build2DFold以产生一个或多个附加折叠的列表。build1 Try将折叠列表记录在OneDFoldList，build1 Try包括以下实例逻辑：
Structure orneDFold
Fold Structure oneD
Fold Structure twoD[×]
integer NumTwoDFolds
integer twoDFoldSize[3]
End Structure
在具体的实施例中，oneD包括一个第一折叠。在具体的实施例中，twoD包括从所述第一折叠而产生的折叠列表。NumTwoDFold表示twoD中折叠的数量。在具体的实施例中，twoDFoldSize表示传给build2Dfold的网格尺寸。调度器515产生用于twoD元素的Try结构并且调用build3Dtry以构建每一Try结构的所有可能旋转。在具体实施例中，build1 Try包括以下实例逻辑：
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]
<!-- SIPO <DP n="56"> -->
<dp n="d56"/>
OneDFoldList[0].twoDFoldSize[jRank[2]]＝RequestedSize[jRank[2]]
OneDFoldList[0].twoDFoldSize[jRank[1]]＝1
OneDFoldList[0].twoDFoldSize[jRank[0]]＝1
hit＝False
For j＝0 to 2 while hit＝False
if RequestedSize[jRank[j]]＞PartSize[pRank[j]]
hit＝True
End If
End For
If hit＝False
build2DFold(PartSize，pRank，RequestedSize，OneDFoldList[0].twoD，
OneDFoldList[0].nTwoDFolds)
OneDFoldList[0].nTwoDFolds＝1
Num1DFolds＝1；
Else
Num1DFolds＝0
End If
gotRemZero＝False
For i＝start to end
OneDFoldList[Num1DFolds].oneD.foldLength＝i
OneDFoldList[Num1DFolds].oneD.NumFolds＝RequestedSize[jRank[2]]/i
OneDFoldList[Num1DFolds].oneD.remainder＝RequestedSize[jRank[2]]
mod i
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.foldLenth
OneDFoldList[Num1DFolds].twoDFoldSize[jRank[1]]＝
OneDFoldList[Num1DFolds].oneD.NumFolds
OneDFoldList[Num1DFolds].twoDFoldSize[jRank[0]]＝1
If OneDFoldList[Num1DFolds].oneD.remainder not equal 0 or gotRemZero＝
False
If OneDFoldList[Num1DFolds].oneD.remainder＝0
gotRemZero＝True
End If
build2DFold(PartSize，pRank，RequestedSize，
OneDFoldList[Num1DFolds].twoDFoldSize，
OneDFoldList[Num1DFolds].twoD，
OneDFoldList[Num1DFolds].nTwoDFolds)
Num1DFolds＝Num1DFolds+1
End If
End For
NumberOfTries＝0
For i＝0 to Num1DFolds
For j＝0 to OneDFoldList[i].nTwoDFolds
<!-- SIPO <DP n="57"> -->
<dp n="d57"/>
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；
if OneDFoldList[i].twoD[j].remainder not equal 0
try.NumConcats＝1
if OneDFoldList[i].twoD[j].NumFolds is odd
try.concatStartNode[0，OneDFoldList[i].twoD[j].foldD]＝
OneDFoldList[i].twoD[j].fodLength-
OneDFoldList[i].twoD[j].remainder
Else
try.concatStartNode[0，OneDFoldList[i].twoD[j].foldD]＝0
End If
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[0 OneDFoldList[i].twoD[j].oneD]＝1；
Else
try.NumConcats＝0
End If
If OneDFoldList[i].oneD.remainder not equal 0
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
<!-- SIPO <DP n="58"> -->
<dp n="d58"/>
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]＝1 mod
OneDFoldList[i].oneD.foldLength
End If
try.concatStartNode[try.NumConcats，OneDFoldList[i].oneD.oneD]
＝k/OneDFoldList[i].twoD.foldLength
oneDEnd[OneDFoldList[i].oneD.oneD]＝1/
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]＝OneDFo]dList[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
<!-- SIPO <DP n="59"> -->
<dp n="d59"/>
build3Dtry(Try，NumberOfTries)
End For
End For
NumDeleted＝0
For i＝0 to NumberOfTries-1
curMax＝TryList[i].baseSize[0]+TryList[i].baseSize[1]+
TryList[i].baseSize[2]
if TryList[i].NumConcats＞0
curMax＝curMax+1
End If
For j＝i+1 to NumberOfTries-1
duplicate＝True
For il＝0 to 2 while duplicate＝True
If TryList[j].baseSize[i1]not equal TryList[i].baseSize[i]
duplicate＝False
End If
End For
If duplicate＝True and Tryist[j].NumConcats＝TryList[i].NumConcats)
For i1＝0 to TryList[i].NumConcats while duplicate＝True
For j1＝0 to 2 while duplicate＝True
If TryList[j].concatStartNode[i1，j1]not equal
TruList[i].concatStartSode[i1，j1]
duplicate＝False
Else If TryList[j].concatSize[i1，j1]not equal
TryList[i].concatSize[i1，j1]
duplicate＝False
End For
End For
End If
If duplicate＝True
For i1＝0 to 2
TryList[j].baseSize[il]＝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 If
End For
End For
NumberOfTries＝NumberOfTries-NumDeleted
在具体的实施例中，用于构建BestFit[3]的buildCompactFit包括以下实例逻辑：
Rank(PartSize，PartRank)
l＝QubeRoot(ResuestedNodes)
hit＝False
For i＝l to l+1 while hit＝False
For j＝i to l+1 while hit＝False
For(k＝j to l+1 while hit＝False
If i×j×k≥RequestedNodes
t[0]＝i
t[1]＝j
t[2]＝k
hit＝True
End If
End For
End For
End For
If t[0]≤PartSize[PartRank[0]]
If t[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
If t[0]×t[1]xt[2]≥RequestedNodes
Hit＝True
End If
End For
End If
Else
t[0]＝PartSize[PartRank[0]]
l＝sqrt(RequestedNodes/t[0])
hit＝False；
For j＝l to l+1 while hit＝False
For(k＝j to l+1 while hit＝False
If(t[0]×j×k≥RequestedNodes
t[1]＝j
t[2]＝k
hit＝True
End If
End For
<!-- SIPO <DP n="61"> -->
<dp n="d61"/>
End For
if t[1]＞PartSize[PartRank[1]]
t[1]＝Partize[PartRank[1]]
t[2]＝RequestedNodes/(t[0]×t[1])
If t[0]×t[1]×t[2]＜RequestedNodes
t[2]＝t[2]+1
End If
End If
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(j not equal to PartSize[0])and(k not
equal to PartSize[0])
For m＝0 to NumMapDimensions While Hit＝True
If Fit[NumberOfFits，MapDimension[m]]mod MapMod[m]not
equal to 0
Hit＝False
End If
End For
End If
If Hit＝True
NumberOfFits＝NumberOfFits+1
End If
End For
End For
End For
For i＝0 to NumBerOfFits-1
d1＝Fit[i，0]+Fit[i，1]+Fit[i，2]
For j＝i+1 to 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
<!-- SIPO <DP n="62"> -->
<dp n="d62"/>
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＝0 to 2 while 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 If
End For
End For
lastMax＝0
NumMaxDistances＝0
For i＝0 NumberOfFits-1
currentMax＝Fit[i，0]+Fit[i，1]+Fit[i，2]
If currentMax not equal lastMax
MaxDistanee[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]
<!-- SIPO <DP n="64"> -->
<dp n="d64"/>
Fork＝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+1 to 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]＝0 and meshEnd[2]not equal
PartEnd[2]
inMesh＝True；
For mz＝PartEnd[2 to meshEnd[2]by-1 and 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
End If
inMesh＝True
For my＝j+1 to PartEnd[1]and inMesh＝True
For mz＝meshStart[2 tomeshEnd[2]an inMesh＝True
If NodeInUse[i，my，mz mod 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
<!-- SIPO <DP n="65"> -->
<dp n="d65"/>
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-1 and 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
End For
If inMesh＝True
My＝my+1
Else
my＝my+2
End If
if my≤PartEnd[1]
meshStart[1]＝my
meshEnd[1]＝meshEnd[1]+TorusSize[1]
End If
End If
EndFor
inMesh＝True
for mx＝i+1 to PattEnd[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]，mz mod
TorusSize[2]] not equal
NODE_NOT_IN_USE
inMesh＝False
End If
End For
End For
End For
If inMesh＝True
meshEnd[0]＝mx-1
Else
meshEnd[0]＝mx-2
End If
If partWraps[0]and meshStart[0]＝0 and meshEnd[0]not equal
PartEnd[0]
inMesh＝True
For mx＝partEnd[0]to meshEnd[0]by-1 and inMesh＝True
<!-- SIPO <DP n="66"> -->
<dp n="d66"/>
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]，mz Mod
TorusSize[2]]not equal
NODE_NOT_IN_USE
inMesh＝False
End If
End For
End For
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
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]
FreeMesh[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
End For
End For
For i＝0 to 2
FreeMesh[NumFreeMeshes].Rank[i]＝2-l；
End For
For l＝0 to 2
For m＝l+1 to 3
<!-- SIPO <DP n="67"> -->
<dp n="d67"/>
l1＝FreeMesh[NumFreeMeshes].Rank[l]
m1＝FreeMesh[NumFreeMeshes].Rank[m]
If meshEnd[m1]-meshStart[m1]＜meshEnd[l1]-
meshStart[l1]
FreeMesh[NumFreeMeshes].Rank[l]＝m1
FreeMeshRank[m]＝l1
End If
End For
End For
NumFreeMeshes＝NumFreeMeshes+1
End If
End For
End For
End For
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_ON_HOLD
NodeInUse[i，j，k]＝NODE_NOT_IN_USE
End If
End For
End For
End For
For i＝0 to NumFreeMeshes-1
For j＝i+1 to NumFreeMeshes-1
hit＝False
if FreeMesh[j].NumNodes＜freeMesh[i].NumNodes
hit＝True；
Else If FreeMesh[j].NumNodes＝freeMesh[i].NumNodes
hit＝True
For l＝0 to 2 while hit＝True
If FreeMesh[j].Rank[l]＞freeMesh[i].Rank[l])
Hit＝False
End If
End For
End If
If hit＝True
TempMesh＝FreeMesh[j]
FreeMesh[j]＝FreeMesh[i]
FreeMesh[i]＝TempMesh
End If
End For
End For
在具体的实施例中，如果调度器515成功调度作业150则返回True的ScheduleJob包括以下实例逻辑：
If SpatialAllowed＝True
If scheduleSpatialO＝True
return True
Else If CompactAllowed＝True
return scheduleCompact()
End If
Else If CompactAllowed＝True
return scheduleCompact()
Else
Return scheduleAny()
End If
在具体的实施例中，scheduleSpatial包括以下实例逻辑：
GotFit＝False
For i＝0 to NumberOfTries-1 while 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]＝0 to OriginalSize[0]-1
For cNode[1]＝0 to OriginalSize[1]-1
For cNode[2]＝0 to OriginalSize[2]-1
For i＝0 to 2
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.foldLengh[0])
<!-- SIPO <DP n="69"> -->
<dp n="d69"/>
Else
mNode[0，Try.foldFrom[0]]＝jcNode[Try.foldFrom[0]]mod
Try.foldLength[0]
End If
For i＝0 to 2
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]
If mNode[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＝0 to 2
node[i]＝mNode[1，Try.rMap[i]]
End For
End If
For i＝0 to 2
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
End For
End For
在具体的实施例中，scanSpatial包括以下实例逻辑：
For i＝0 to 2
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]；
Fo i＝PartStart[0]to End[0]
newX＝True
For(n＝PartStart[2]to PartEnd[2]
zPlane[n]＝0
End For
For l＝i to i+try.baseSize[0]
For n＝PartStart[2]to PartEnd[2]
l1＝l mod 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
End For
For j＝PartStart[1]to End[1]
if newX＝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]
For n＝PartStart[2]to PartEnd[2]
If i+Try.baseSize[0]≤PartEnd[0]
zPlane[n]＝zPlane[n]-(FreeX[l1，ml，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]))
<!-- SIPO <DP n="71"> -->
<dp n="d71"/>
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]
For n＝PartStart[2]to PartEnd[2]
If i+Try.baseSize[0]≤PartEnd[0]
ZPlane[n]＝zPlarne[n]+FreeX[l1，m1，n]-FreeX[l1，m2，n]
Else
ZPlane[n]＝zPlane[n]+FreeX[l1，mm1，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]；
while k≤End[2])
hit＝True；
For n＝k；to k+Try.baseSize[2]-1 while hit＝True
If zPlane[n mod TorusSize[2]]not equal zPlaneCnt
hit＝False；
End If
End For
if hit＝True
Start[0]＝i；
Start[1]＝j；
Start[2]＝k；
For cNdx＝0 to try.NumConcats-1 while hit＝True
For m＝0 to 2 while 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
For l＝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＝l mod TorusSize[0]
m1＝m mod TorusSize[1]
n1＝n mod TorusSize[2]
<!-- SIPO <DP n="72"> -->
<dp n="d72"/>
If NodeInUse[l1，m1，n1]not equal
NODE_NOT_IN_USE
hit＝False；
End If
End For
End For
End For
If hit＝True
Return True；
Else
K＝k+1
End If
Else
k＝n+1
End If
End If
End For
End For
Return False
在具体的实施例中，用于在Fit上运行对分检索的scheduleCompactFunction包括以下实例逻辑：
HighFit＝NumberOfFits-1
For i＝0 to 2
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
If HighFit＝LowFit+1
Return
End If
End While
Hit＝False
For i＝0 to NumMaxDistances-1 While Hit＝False
If HighFit≥MaxDistance[i，0]
HigMaxDistance＝i
Hit＝True
End If
End For
<!-- SIPO <DP n="73"> -->
<dp n="d73"/>
Hit＝True
For i＝HighMaxDistance-1 to 0 by-1
StartFit＝MaxDistance[i，0]
If i＝NumMaxDistance-1
EndFit＝NumberOfFits-1
Else
EndFit＝MaxDistance[i+1，0]-1
End If
Hit＝False
For j＝StarFit to EndFit While Hit＝Fase
If scanCompact(NumberOfNodes，Fit[J]，HighStart)＝True
HighFit＝j
HighMaxDistance＝I
Hit＝True
End If
End For
End For
setCompactNodeInUse(Fit(HighFit)，HighStart)
在具体的实施例中，setCompactNodeInUSe包括以下实例逻辑：
node＝0
For i＝0 to 2
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]
<!-- SIPO <DP n="74"> -->
<dp n="d74"/>
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]]
If NodeInUse[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
End For
End For
在具体的实施例中，ScanCompact包括以下实例逻辑：
For i＝0 to 2
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＝0 to TorusSize[2]
ZPlane[n]＝0
End For
for(l＝i to i+size[0]
for(n＝pStart[2]；n ≤pEnd[2]；n++)
l1＝l mod 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
End For
<!-- SIPO <DP n="75"> -->
<dp n="d75"/>
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]
For n＝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
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
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]
For n＝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
For n＝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
For k＝PartStart[2]to end[2]
if newY＝True
newY＝False
count＝0；
<!-- SIPO <DP n="76"> -->
<dp n="d76"/>
For n＝k to k+size[2]
count＝count+zPlane[n mod 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]
For m＝j to j+size[1]
m1＝m mod 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，m1，k1]
End For
Else
For m＝j to j+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
return True
End If
End For
End For
End For
End For
return False
在具体的实施例中，scheduleAny包括以下实例逻辑：
Node＝0 Remainder＝RequestedNodes For m＝0 to NumFreeMeshes while Remainder＞0 If FreeMesh[m].Rank[0]＝2 iNdx＝FreeMesh[m].Rank[2] jNdx＝FreeMesh[m].Rank[1] Else If FreeMesh[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 For k＝FreeMesh[m].Start[2]to FreeMesh[m].end[2]while Remainder ＞0 i1＝i mod TorusSize[iNdx] j1＝j mod TorusSize[iMod] k1＝k mod TorusSize[2] If iNdx＝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 End For End For End For
在具体的实施例中，setMpiRank包括以下实例逻辑：
For node＝0 to 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[o]
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]
<!-- SIPO <DP n="78"> -->
<dp n="d78"/>
to[3]＝(AssignedNodeList[node，MapDiminsion[0]]mod MapMod[0])×
MapMod[1]+
AssignedNodeList[node，MapDiminsion[1]]mod MapMod[1]
End If
hit＝False
for(node1＝0 to NumFreeNodes-1 while hit＝False
If to[0]＝FreeNodeList[node1]，coordinate[0]and
to[1]＝FreeNodeList[node1].coordinate[1]and
to[2]＝FreeNodeList[node1].coordinate[2]and
to[3]＝FreeNodeList[node1].coordinate[3]
FreeNodeList[node1].mpiRank＝node
Hit＝True
End If
End For
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]：按照CPU 164的栅格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[o]，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是说明根据本发明所揭示的一个实施例用于动态处理作业提交的示意性方法600的流程图。通常，图11描述了方法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可以被格式化并通过GUI 126向用户示出。
图12是说明根据本发明所揭示的一个实施例用于在栅格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所示的技术。
图13是说明根据本发明所揭示的一个实施例的用于动态管理栅格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可以使用带有额外步骤、更少步骤，以及/或者不同步骤的方法，只要方法仍是合适的。
尽管已经按照确定的实施例及通常相关的方法对所揭示的内容进行了描述，但对于本领域的技术人员来说，这些实施例和方法的改变和置换都将是显而易见的。因此，示意性实施例的上述说明不是定义或约束所揭示的内容。也可以进行其它的改变、替换和变更，而不脱离所揭示的内容的精神和范围。
Claims (35)
1、一种用于高性能计算(HPC)系统中调度的逻辑，所述逻辑编码在计算机可读介质中并且执行以下操作：
接收来自管理所述HPC系统中节点群集的管理引擎的调用，所述调用指定一包括用于调度的作业的请求，所述调度的作业包括用于在群集内一个或多个节点上执行的一个或多个过程，所述调用进一步指定了用于执行所述作业的多个节点；
确定所述请求是否是空间的、紧凑的、或非空间和不紧凑的，如果所述作业在执行作业的节点间假设为空间关系，那么所述请求是空间的，如果所述作业在执行作业的节点间假设为邻近的，那么所述请求是紧凑的，如果所述作业在执行作业的节点间假设不为空间关系或邻近的，那么所述请求是非空间和不紧凑的；
如果所述请求是空间的：
在群集内产生一个或多个节点空间组合，所述节点空间组合适应在所述调用中指定的节点数和进一步适应在执行所述作业的节点间假设的空间关系；和
根据在群集中可用于调度的节点列表，选择空间组合中可调度的一个；
如果所述请求是紧凑的：
在群集内产生一个或多个紧凑组合，所述紧凑组合适应在所述调用中指定的节点数；和
根据在群集中可用于调度的节点列表，选择紧凑组合中可调度的并且比其它可调度的紧凑组合更紧凑的一个；
如果所述请求是非空间和不紧凑的：
根据在群集中可用于调度的节点列表，识别一个或多个可调度的节点；和
在群集内产生一非空间和不紧凑组合，所述非空间和不紧凑组合适应在所述调用中指定的节点数，所述非空间和不紧凑组合包括根据在群集中可用于调度的节点列表，一个或多个可调度的已识别节点的一个或多个；和
把返回传递给管理引擎，所述引擎识别在群集内用于执行所述作业的所选的空间的、紧凑的、或非空间和不紧凑组合中的一个或多个节点。
2根据权利要求1所述的逻辑，其中调用进一步指定：
所述请求是否是空间的、紧凑的、或非空间和不紧凑；
如果所述请求是空间的，作业的尺寸；
指示用于调度所述作业的回旋余地程度的侵占性标志；
根据在群集内多个开关的群集的尺寸；
多个在群集内耦合至每个开关的节点；
多个可用于调度的节点；和
在群集内可用于调度的节点列。
3根据权利要求1所述的逻辑，其中返回管理引擎进一步识别在选择的节点空间的、紧凑的、或非空间和不紧凑的组合中每个节点的信息传递接口(MPI)级别。
4根据权利要求1所述的逻辑，如果所述请求是空间的和三维的，可操作地旋转网格适应在所述调用中指定的节点数和进一步适应在所述作业中执行过程的节点间假设的空间关系为六个方位中的一个以产生空间组合的一个。
5根据权利要求1所述的逻辑，如果所述请求是空间的和二维的，可操作地折叠所述作业中一个未使用的维数以产生网格适应来自管理引擎的在所述调用中指定的节点数和旋转网格至六个方位中的一个以产生空间组合的一个。
6根据权利要求1所述的逻辑，如果所述请求是空间的和一维的，可操作地折叠所述作业中两个未使用的维数以产生网格适应来自管理引擎的在所述调用中指定的节点数和旋转网格至六个方位中的一个以产生空间组合的一个。
7根据权要求1所述的逻辑，可操作地使用一扫描算法，所述算法搜索在节点群集内用于作业的开始点，以根据在群集中可用于调度的节点列表选择空间组合中可调度的一个。
8根据权要求1所述的逻辑，可操作地产生一个或多个在群集中适应来自管理引擎在所述调用中指定的节点数的节点紧凑组合，以：
产生在群集中适应来自管理引擎在所述调用中指定的节点数的一个第一节点紧凑组合；
产生在群集中适应来自管理引擎在所述调用中指定的节点数的一个或多个第二节点紧凑组合，每个第二紧凑组合不如第一紧凑组合紧凑；和
根据对于第一和第二紧凑组合中的一个的选择的紧凑性，对第一和第二紧凑组合排序。
9根据权利要求1所述的逻辑，可操作地产生一在群集中适应来自管理引擎在所述调用中指定的节点数的节点非空间和不紧凑组合，以；
在群集内做关于群集的第一维度的第一循环直到达到根据在群集内可用于调度的节点列表，第一节点不能用于调度；
在群集内做关于群集的第二维度的第二循环直到达到根据在群集内可用于调度的节点列表，第二节点不能用于调度；和
在群集内做关于群集的第三维度的第三循环直到达到根据在群集内可用于调度的节点列表，第三节点不能用于调度。
10根据权利要求10所述的逻辑，进一步可执行以下操作：
重复第一循环、第二循环、和第三循环直至覆盖群集内所有的节点。
11根据权要求1所述的逻辑，进一步可执行以下操作：
确定群集是否包括适应在来自管理引擎所述调用内指定的在所述作业中用于执行一个或多个过程的节点数的足够的节点；和
如果群集包括的节点少于适应在来自管理引擎所述调用内指定的在所述作业中用于执行一个或多个过程的节点数的足够的节点，指示管理引擎所述作业是不可调度的。
12根据权利要求1所述的逻辑，其中逻辑是无状态的。
13根据权利要求1所述的逻辑，其中节点是耦合至两个开关的中央处理器(CPU)。
14根据权要求1所述的逻辑，其中逻辑是管理引擎内的插座。
15根据权利要求1所述的逻辑，其中节点群集是三维环面。
16根据权利要求1所述的逻辑，其中当执行时，使用信息传递接口(MPI)使作业的过程彼此之间相通信。
17根据权利要求1所述的逻辑：
其中来自管理引擎的调用进一步指定侵略性标志，所述标志指示用于选择在群集中用于执行在所述作业里一个或多个过程的节点空间组合、紧凑组合、或非空间和不紧凑组合的所分配的回旋余地的程度；
所述逻辑可操作地根椐来自管理引擎所述调用中指定的侵略性标志，选择在群集中用于执行在所述作业里一个或多个过程的节点的空间组合、紧凑组合、或非空间和不紧凑组合。
18一种用于在高性能计算(HPC)系统内调度的方法，所述方法包括：
接收来自管理引擎的调用以管理在用℃系统中的节点群集，所述调用指定一包括用于调度的作业的请求，所述调度的作业包括用于在群集内一个或多个节点上执行的一个或多个过程，所述调用进一步指定了用于执行所述作业的多个节点；
确定所述请求是否是空间的、紧凑的、或非空间和不紧凑的，如果所述作业在执行作业的节点间假设为空间关系，那么所述请求是空间的，如果所述作业在执行作业的节点间假设为邻近，那么所述请求是紧凑的，如果所述作业在执行作业的节点间假设不为空间关系或邻近，那么所述请求是非空间和不紧凑的；
如果所述请求是空间的：
在群集内产生适应在所述调用中指定的节点数和进一步适应在执行所述作业的节点间假设的空间关系的一个或多个节点空间组合；和
根据在群集中可用于调度的节点列表，选择空间组合中可调度的一个；
如果所述请求是紧凑的：
在群集内产生适应在所述调用中指定的节点数的一个或多个紧凑组合；和
根据在群集中可用于调度的节点列表，选择紧凑组合中可调度的并且比其它可调度的紧凑组合更紧凑的一个；
如果所述请求是非空间和不紧凑的：
根据在群集中可用于调度的节点列表，识别一个或多个可调度的节点；和
在群集内产生适应在所述调用中指定节点数的非空间和不紧凑组合，所述非空间和不紧凑组合包括根据在群集中可用于调度的节点列表，一个或多个可调度的已识别的节点的一个或多个；和
把返回传递给管理引擎，所述引擎识别在群集内用于执行听述作业的选择的节点空间的、紧凑的、或非空间和不紧凑组合的一个或多个节点。
19根据权利要求18所属的方法，其中所述调用进一步指定：
所述请求是否是空间的、紧凑的、或非空间和不紧凑；
如果所述请求是空间的，作业的尺寸；
一侵占性标志，指示用于调度所述作业的回旋余地的程度；
根据在群集内多个开关的群集的尺寸；
多个在群集内耦合至每个开关的节点；
多个可用于调度的节点；和
在群集内可用于调度的节点列。
20根据权利要求18所述的方法，其中返回管理引擎进一步识别在选择的节点空间的、紧凑的、或非空间和不紧凑的组合中每个节点的信息传递接口(MPI)级别。
21根据权利要求18所述的方法，其特征在于，如果所述请求是空间的和三维的，可操作地旋转网格适应在所述调用中指定的节点数和进一步适应在所述作业中执行过程的节点间假设的空间关系为六个方位中的一个以产生空间组合的一个。
22根据权利要求18所述的方法，其特征在于，如果所述请求是空间的和二维的，可操作地折叠所述作业中一个未使用的维数以产生网格适应来自管理引擎的在所述调用中指定的节点数和旋转网格至六个方位中的一个以产生空间组合的一个。
23根据权利要求18所述的方法，其特征在于，如果所述请求是空间的和一维的，可操作地折叠所述作业中两个未使用的维数以产生网格适应来自管理引擎的在所述调用中指定的节点数和旋转网格至六个方位中的一个以产生空间组合的一个。
24根据权利要求18所述的方法，包括使用一扫描算法，所述算法搜索在节点群集内用于作业的开始处以根据在群集中可用于调度的节点列表选择空间组合中可调度的一个。
25根据权利要求18所述的方法，其中产生一个或多个在群集中适应来自管理引擎在所述调用中指定的节点数的节点紧凑组合包括：
产生在群集中适应来自管理引擎在所述调用中指定的节点数的一个第一节点紧凑组合；
产生在群集中适应来自管理引擎在所述调用中指定的节点数的一个或多个第二节点紧凑组合，每个第二紧凑组合不比第一紧凑组合紧凑；和
根据对于第一和第二紧凑组合中的一个的选择的紧凑性，对第一和第二紧凑组合排序。
26根据权利要求18所述的方法，其中产生一在群集中适应来自管理引擎在所述调用中指定的节点数的节点非空间和不紧凑组合包括
在群集内做关于群集的第一维度的第一循环直到达到根据在群集内可用于调度的节点列表，第一节点不能用于调度；
在群集内做关于群集的第二维度的第二循环直到达到根据在群集内可用于调度的节点列表，第二节点不能用于调度；和
在群集内做关于群集的第三维度的第三循环直到达到根据在群集内可用于调度的节点列表，第三节点不能用于调度。
27根据权利要求9所述的逻辑，进一步包括重复第一循环、第二循环、和第三循环直至覆盖群集内所有的节点。
28根据权利要求18所述的方法，进一步可执行以下操作：
确定群集是否包括足够的节点以适应在来自管理引擎所述调用内指定的在所述作业中用于执行一个或多个过程的节点数；和
如果群集包括的节点少于足够的可适应在来自管理引擎所述调用内指定的在所述作业中用于执行一个或多个过程的节点数，指示管理引擎所述作业是不可调度的。
29根据权利要求18所述的方法，根据无状态逻辑执行。
30根据权利要求18所述的方法，其中节点是一耦合至两个开关的中央处理器(CPU)。
31根据权利要求18所述的方法，在管理引擎的插座上执行。
32根据权利要求18所述的方法，其中节点群集是三维环面。
33根据权利要求18所述的方法，其中当执行时，使用信息传递接口(MPI)使所述作业的过程彼此之间相通信。
34根据权利要求18所述的方法：
其中来自管理引擎的调用进一步指定侵略性标志，所述标志表明用于选择在群集中用于执行在所述作业里一个或多个过程的节点的空间组合、紧凑组合、或非空间和不紧凑组合的所分配的活动余地的程度；
所述方法包括根据来自管理引擎所述调用中指定的侵略性标志，选择在群集中用于执行在所述作业里一个或多个过程的节点空间组合、紧凑组合、或非空间和不紧凑组合。
35一种用于在高性能计算(HPC)系统内调度的系统，用于在HPC系统内调度的所述系统包括：
用于接受来自可执行在HPC系统内管理节点群集的操作的管理引擎的调用，所述调用指定一包括用于调度的作业的请求，所述调度的作业包括在群集内用于在一个或多个节点上执行的一个或多个过程，所述调用进一步指定用于执行所述作业的节点数；
用于确定所述请求是否是空间的、紧凑的、或非空间和不紧凑的装置，如果所述作业在执行作业的节点间假设为空间关系，那么所述请求是空间的，如果所述作业在执行作业的节点间假设为邻近的，那么所述请求是紧凑的，如果所述作业在执行作业的节点间假设不为空间关系或邻近的，那么所述请求是非空间和不紧凑的；
如果所述请求是空间的：
在群集内产生适应在所述调用中指定的节点数和进一步适应在执行所述作业的节点间假设的空间关系的一个或多个节点空间组合；和
根据在群集中可用于调度的节点列表，选择空间组合中可调度的一个的装置；
如果所述请求是紧凑的：
在群集内产生适应在所述调用中指定的节点数的一个或多个紧凑组合；和
根据在群集中可用于调度的节点列表，选择紧凑组合中可调度的并且比其它可调度的紧凑组合更紧凑的一个的装置；
如果所述请求是非空间和不紧凑的：
根据在群集中可用于调度的节点列表，识别一个或多个可调度的节点；和
在群集内产生一适应在所述调用中指定的节点数的非空间和不紧凑组合的装置，所述非空间和不紧凑组合包括根据在群集中可用于调度的节点列表的一个或多个可调度的一个或多个已识别节点的一个或多个；和
把返回传递给管理引擎的装置，所述引擎识别一个或多个在群集内用于执行所述作业的选择的节点空间的、紧凑的、或非空间和不紧凑组合。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US10/991,598 US7433931B2 (en) | 2004-11-17 | 2004-11-17 | Scheduling in a high-performance computing (HPC) system |
| US10/991,598 | 2004-11-17 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN1776622A true CN1776622A (zh) | 2006-05-24 |
| CN100380327C CN100380327C (zh) | 2008-04-09 |
Family
ID=34862294
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNB2005100878572A Active CN100380327C (zh) | 2004-11-17 | 2005-04-15 | 用于在高性能计算系统中调度的系统和方法 |
Country Status (10)
| Country | Link |
|---|---|
| US (2) | US7433931B2 (zh) |
| EP (2) | EP3113021B1 (zh) |
| JP (1) | JP4185919B2 (zh) |
| KR (1) | KR101160721B1 (zh) |
| CN (1) | CN100380327C (zh) |
| CA (1) | CA2503776C (zh) |
| IL (1) | IL179827A (zh) |
| MY (1) | MY142928A (zh) |
| TW (1) | TWI287195B (zh) |
| WO (1) | WO2006055028A1 (zh) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102103521A (zh) * | 2011-01-31 | 2011-06-22 | 中国科学院计算技术研究所 | Hpc系统以及基于hpc系统的动态分派任务的方法 |
| CN101630275B (zh) * | 2009-07-31 | 2012-07-04 | 清华大学 | 一种实现生成循环任务配置信息的方法和装置 |
| CN102902878A (zh) * | 2012-08-17 | 2013-01-30 | 曙光信息产业(北京)有限公司 | 一种能源成本感知调度方法 |
| CN103473247A (zh) * | 2012-06-30 | 2013-12-25 | 中国地质调查局西安地质调查中心 | 地质资料信息集群机理与接口聚合模型 |
| CN105051717A (zh) * | 2013-02-13 | 2015-11-11 | 超威半导体公司 | 增强3d圆环 |
Families Citing this family (95)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8538843B2 (en) * | 2000-07-17 | 2013-09-17 | Galactic Computing Corporation Bvi/Bc | Method and system for operating an E-commerce service provider |
| US7562143B2 (en) | 2004-01-13 | 2009-07-14 | International Business Machines Corporation | Managing escalating resource needs within a grid environment |
| US7406691B2 (en) * | 2004-01-13 | 2008-07-29 | International Business Machines Corporation | Minimizing complex decisions to allocate additional resources to a job submitted to a grid environment |
| US7464159B2 (en) * | 2004-01-14 | 2008-12-09 | International Business Machines Corporation | Managing analysis of a degraded service in a grid environment |
| US7552437B2 (en) | 2004-01-14 | 2009-06-23 | International Business Machines Corporation | Maintaining application operations within a suboptimal grid environment |
| US20050235055A1 (en) * | 2004-04-15 | 2005-10-20 | Raytheon Company | Graphical user interface for managing HPC clusters |
| US8335909B2 (en) | 2004-04-15 | 2012-12-18 | Raytheon Company | Coupling processors to each other for high performance computing (HPC) |
| US9178784B2 (en) | 2004-04-15 | 2015-11-03 | Raytheon Company | System and method for cluster management based on HPC architecture |
| US7711977B2 (en) * | 2004-04-15 | 2010-05-04 | Raytheon Company | System and method for detecting and managing HPC node failure |
| US8190714B2 (en) * | 2004-04-15 | 2012-05-29 | Raytheon Company | System and method for computer cluster virtualization using dynamic boot images and virtual disk |
| US8336040B2 (en) | 2004-04-15 | 2012-12-18 | Raytheon Company | System and method for topology-aware job scheduling and backfilling in an HPC environment |
| US20060048157A1 (en) * | 2004-05-18 | 2006-03-02 | International Business Machines Corporation | Dynamic grid job distribution from any resource within a grid environment |
| US7266547B2 (en) | 2004-06-10 | 2007-09-04 | International Business Machines Corporation | Query meaning determination through a grid service |
| US7584274B2 (en) * | 2004-06-15 | 2009-09-01 | International Business Machines Corporation | Coordinating use of independent external resources within requesting grid environments |
| US20070266388A1 (en) | 2004-06-18 | 2007-11-15 | Cluster Resources, Inc. | System and method for providing advanced reservations in a compute environment |
| JP2006082262A (ja) * | 2004-09-14 | 2006-03-30 | Canon Inc | 画像処理装置およびジョブ処理方法およびコンピュータが読み取り可能なプログラムを格納した記憶媒体およびプログラム |
| US7712100B2 (en) * | 2004-09-14 | 2010-05-04 | International Business Machines Corporation | Determining a capacity of a grid environment to handle a required workload for a virtual grid job request |
| US8244882B2 (en) * | 2004-11-17 | 2012-08-14 | Raytheon Company | On-demand instantiation in a high-performance computing (HPC) system |
| US7433931B2 (en) | 2004-11-17 | 2008-10-07 | Raytheon Company | Scheduling in a high-performance computing (HPC) system |
| US7475274B2 (en) * | 2004-11-17 | 2009-01-06 | Raytheon Company | Fault tolerance and recovery in a high-performance computing (HPC) system |
| US7502850B2 (en) * | 2005-01-06 | 2009-03-10 | International Business Machines Corporation | Verifying resource functionality before use by a grid job submitted to a grid environment |
| US7707288B2 (en) | 2005-01-06 | 2010-04-27 | International Business Machines Corporation | Automatically building a locally managed virtual node grouping to handle a grid job requiring a degree of resource parallelism within a grid environment |
| US7793308B2 (en) | 2005-01-06 | 2010-09-07 | International Business Machines Corporation | Setting operation based resource utilization thresholds for resource use by a process |
| US7533170B2 (en) * | 2005-01-06 | 2009-05-12 | International Business Machines Corporation | Coordinating the monitoring, management, and prediction of unintended changes within a grid environment |
| US20060149652A1 (en) * | 2005-01-06 | 2006-07-06 | Fellenstein Craig W | Receiving bid requests and pricing bid responses for potential grid job submissions within a grid environment |
| US7590623B2 (en) | 2005-01-06 | 2009-09-15 | International Business Machines Corporation | Automated management of software images for efficient resource node building within a grid environment |
| US7761557B2 (en) | 2005-01-06 | 2010-07-20 | International Business Machines Corporation | Facilitating overall grid environment management by monitoring and distributing grid activity |
| US7668741B2 (en) | 2005-01-06 | 2010-02-23 | International Business Machines Corporation | Managing compliance with service level agreements in a grid environment |
| US7467196B2 (en) * | 2005-01-12 | 2008-12-16 | International Business Machines Corporation | Managing network errors communicated in a message transaction with error information using a troubleshooting agent |
| US7571120B2 (en) | 2005-01-12 | 2009-08-04 | International Business Machines Corporation | Computer implemented method for estimating future grid job costs by classifying grid jobs and storing results of processing grid job microcosms |
| US7472079B2 (en) * | 2005-01-12 | 2008-12-30 | International Business Machines Corporation | Computer implemented method for automatically controlling selection of a grid provider for a grid job |
| US7562035B2 (en) * | 2005-01-12 | 2009-07-14 | International Business Machines Corporation | Automating responses by grid providers to bid requests indicating criteria for a grid job |
| JP4291281B2 (ja) * | 2005-02-03 | 2009-07-08 | 富士通株式会社 | 情報処理システム、計算ノード、情報処理システムの制御方法 |
| US7827435B2 (en) * | 2005-02-15 | 2010-11-02 | International Business Machines Corporation | Method for using a priority queue to perform job scheduling on a cluster based on node rank and performance |
| US20060198386A1 (en) * | 2005-03-01 | 2006-09-07 | Tong Liu | System and method for distributed information handling system cluster active-active master node |
| US7739708B2 (en) * | 2005-07-29 | 2010-06-15 | Yahoo! Inc. | System and method for revenue based advertisement placement |
| WO2007038445A2 (en) * | 2005-09-26 | 2007-04-05 | Advanced Cluster Systems, Llc | Clustered computer system |
| US8713179B2 (en) * | 2005-10-04 | 2014-04-29 | International Business Machines Corporation | Grid computing accounting and statistics management system |
| WO2007056713A2 (en) * | 2005-11-04 | 2007-05-18 | The Trustees Of Columbia University In The City Of New York | An optical network |
| TWI314688B (en) * | 2006-06-09 | 2009-09-11 | Asustek Comp Inc | Computer and main circuit board thereof |
| US8082289B2 (en) * | 2006-06-13 | 2011-12-20 | Advanced Cluster Systems, Inc. | Cluster computing support for application programs |
| US8582972B2 (en) * | 2006-08-31 | 2013-11-12 | The Trustees Of Columbia University In The City Of New York | Systems and methods for storing optical data |
| US20080101395A1 (en) * | 2006-10-30 | 2008-05-01 | Raytheon Company | System and Method for Networking Computer Clusters |
| WO2008080122A2 (en) * | 2006-12-22 | 2008-07-03 | The Trustees Of Columbia University In The City Of New York | Systems and method for on-chip data communication |
| US8160061B2 (en) * | 2006-12-29 | 2012-04-17 | Raytheon Company | Redundant network shared switch |
| JP4806362B2 (ja) | 2007-02-14 | 2011-11-02 | 富士通株式会社 | 並列処理制御プログラム、並列処理制御システムおよび並列処理制御方法 |
| US7827266B2 (en) * | 2007-07-31 | 2010-11-02 | Hewlett-Packard Development Company, L.P. | System and method of controlling multiple computer platforms |
| US8200738B2 (en) * | 2007-09-30 | 2012-06-12 | Oracle America, Inc. | Virtual cluster based upon operating system virtualization |
| US9880970B2 (en) * | 2007-10-03 | 2018-01-30 | William L. Bain | Method for implementing highly available data parallel operations on a computational grid |
| TWI521939B (zh) | 2008-02-27 | 2016-02-11 | 恩康普丁公司 | 用於低頻寬顯示資訊傳輸之系統及方法 |
| US8151267B2 (en) * | 2008-04-08 | 2012-04-03 | Xerox Corporation | Printing system scheduler methods and systems |
| US20100023622A1 (en) * | 2008-07-25 | 2010-01-28 | Electronics And Telecommunications Research Institute | Method for assigning resource of united system |
| US8812578B2 (en) * | 2008-11-07 | 2014-08-19 | International Business Machines Corporation | Establishing future start times for jobs to be executed in a multi-cluster environment |
| EP2437170A4 (en) * | 2009-05-25 | 2013-03-13 | Panasonic Corp | MULTIPROCESSOR SYSTEM, MULTIPROCESSOR CONTROL METHOD AND INTEGRATED MULTIPROCESSOR CIRCUIT |
| US9836783B2 (en) * | 2009-07-24 | 2017-12-05 | Avago Technologies General Ip (Singapore) Pte. Ltd. | Method and system for content selection, delivery and payment |
| JP5532849B2 (ja) * | 2009-11-20 | 2014-06-25 | 富士通株式会社 | コンピュータ、プロセス間通信プログラム、およびプロセス間通信方法 |
| TWI423039B (zh) * | 2010-07-23 | 2014-01-11 | Quanta Comp Inc | 伺服器系統與其操作方法 |
| US8984519B2 (en) * | 2010-11-17 | 2015-03-17 | Nec Laboratories America, Inc. | Scheduler and resource manager for coprocessor-based heterogeneous clusters |
| US8612597B2 (en) | 2010-12-07 | 2013-12-17 | Microsoft Corporation | Computing scheduling using resource lend and borrow |
| JP5684629B2 (ja) * | 2011-03-31 | 2015-03-18 | 日本電気株式会社 | ジョブ管理システム及びジョブ管理方法 |
| US8904398B2 (en) * | 2011-03-31 | 2014-12-02 | International Business Machines Corporation | Hierarchical task mapping |
| US9405547B2 (en) * | 2011-04-07 | 2016-08-02 | Intel Corporation | Register allocation for rotation based alias protection register |
| US20120324456A1 (en) | 2011-06-16 | 2012-12-20 | Microsoft Corporation | Managing nodes in a high-performance computing system using a node registrar |
| CN102232218B (zh) | 2011-06-24 | 2013-04-24 | 华为技术有限公司 | 计算机子系统和计算机系统 |
| US8875157B2 (en) * | 2011-09-09 | 2014-10-28 | Microsoft Corporation | Deployment of pre-scheduled tasks in clusters |
| WO2013048379A1 (en) | 2011-09-27 | 2013-04-04 | Intel Corporation | Expediting execution time memory aliasing checking |
| US9063750B2 (en) | 2012-02-01 | 2015-06-23 | Hewlett-Packard Development Company, L.P. | Mapping high-performance computing applications to platforms |
| US20140047342A1 (en) * | 2012-08-07 | 2014-02-13 | Advanced Micro Devices, Inc. | System and method for allocating a cluster of nodes for a cloud computing system based on hardware characteristics |
| US8943353B2 (en) | 2013-01-31 | 2015-01-27 | Hewlett-Packard Development Company, L.P. | Assigning nodes to jobs based on reliability factors |
| JP6191332B2 (ja) * | 2013-08-22 | 2017-09-06 | 富士通株式会社 | 並列計算機システム、並列計算機システムの制御方法及び管理装置の制御プログラム |
| JP6191361B2 (ja) * | 2013-09-25 | 2017-09-06 | 富士通株式会社 | 情報処理システム、情報処理システムの制御方法及び制御プログラム |
| JP6364880B2 (ja) * | 2014-03-31 | 2018-08-01 | 富士通株式会社 | 並列計算機システム，ジョブ管理装置の制御プログラム，及び並列計算機システムの制御方法 |
| JP2016004310A (ja) * | 2014-06-13 | 2016-01-12 | 富士通株式会社 | 並列計算機システム、制御方法およびジョブ管理プログラム |
| US9405582B2 (en) * | 2014-06-20 | 2016-08-02 | International Business Machines Corporation | Dynamic parallel distributed job configuration in a shared-resource environment |
| TWI512609B (zh) * | 2014-09-05 | 2015-12-11 | Silicon Motion Inc | 讀取命令排程方法以及使用該方法的裝置 |
| US9442760B2 (en) * | 2014-10-03 | 2016-09-13 | Microsoft Technology Licensing, Llc | Job scheduling using expected server performance information |
| JP6413634B2 (ja) | 2014-10-30 | 2018-10-31 | 富士通株式会社 | ジョブ管理プログラム、ジョブ管理方法、およびジョブ管理装置 |
| US9785522B2 (en) * | 2014-11-14 | 2017-10-10 | Cisco Technology, Inc. | Adaptive datacenter topology for distributed frameworks job control through network awareness |
| US9894147B1 (en) * | 2014-12-23 | 2018-02-13 | EMC IP Holding Company LLC | Application plugin framework for big-data clusters |
| KR101656706B1 (ko) | 2015-04-02 | 2016-09-22 | 두산중공업 주식회사 | 고성능 컴퓨팅 환경에서의 작업 분배 시스템 및 방법 |
| KR102024934B1 (ko) * | 2015-12-30 | 2019-11-04 | 한국전자통신연구원 | 분산 파일 시스템 및 이의 파일 연산 처리 방법 |
| US10433025B2 (en) * | 2016-05-10 | 2019-10-01 | Jaunt Inc. | Virtual reality resource scheduling of process in a cloud-based virtual reality processing system |
| US10263909B2 (en) * | 2016-05-27 | 2019-04-16 | Lenovo Enterprise Solutions (Singapore) Pte. Ltd. | System, method, and computer program for managing network bandwidth by an endpoint |
| KR102162466B1 (ko) * | 2016-10-07 | 2020-10-08 | 한국전자통신연구원 | 분산 스토리지 서버, 그것에 포함되는 서버 장치, 및 서버 장치를 동작시키는 방법 |
| US10592280B2 (en) * | 2016-11-23 | 2020-03-17 | Amazon Technologies, Inc. | Resource allocation and scheduling for batch jobs |
| US9898347B1 (en) * | 2017-03-15 | 2018-02-20 | Sap Se | Scaling computing resources in a cluster |
| US10088643B1 (en) | 2017-06-28 | 2018-10-02 | International Business Machines Corporation | Multidimensional torus shuffle box |
| US10571983B2 (en) | 2017-06-28 | 2020-02-25 | International Business Machines Corporation | Continuously available power control system |
| US10356008B2 (en) | 2017-06-28 | 2019-07-16 | International Business Machines Corporation | Large scale fabric attached architecture |
| US10169048B1 (en) | 2017-06-28 | 2019-01-01 | International Business Machines Corporation | Preparing computer nodes to boot in a multidimensional torus fabric network |
| US10606640B2 (en) | 2017-12-23 | 2020-03-31 | International Business Machines Corporation | Rescheduling high performance computing jobs based on personalized sanity checks and job problem resolution classification |
| US11042416B2 (en) * | 2019-03-06 | 2021-06-22 | Google Llc | Reconfigurable computing pods using optical networks |
| US11256547B2 (en) | 2019-05-31 | 2022-02-22 | Altair Engineering, Inc. | Efficient allocation of cloud computing resources to job requests |
| US20200389352A1 (en) * | 2019-06-04 | 2020-12-10 | Microsoft Technology Licensing, Llc | Automated upgrade of multiple hosts |
| US11394660B2 (en) * | 2020-05-13 | 2022-07-19 | Google Llc | Processing allocation in data center fleets |
Family Cites Families (117)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US4885770A (en) | 1987-09-04 | 1989-12-05 | Digital Equipment Corporation | Boot system for distributed digital data processing system |
| US4868818A (en) * | 1987-10-29 | 1989-09-19 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Fault tolerant hypercube computer system architecture |
| US5020059A (en) * | 1989-03-31 | 1991-05-28 | At&T Bell Laboratories | Reconfigurable signal processor |
| US5396635A (en) | 1990-06-01 | 1995-03-07 | Vadem Corporation | Power conservation apparatus having multiple power reduction levels dependent upon the activity of the computer system |
| US5301104A (en) * | 1990-08-07 | 1994-04-05 | Honeywell Inc. | Method for allocating processing elements interconnected in a hypercube topology |
| US5280607A (en) * | 1991-06-28 | 1994-01-18 | International Business Machines Corporation | Method and apparatus for tolerating faults in mesh architectures |
| CA2106280C (en) * | 1992-09-30 | 2000-01-18 | Yennun Huang | Apparatus and methods for fault-tolerant computing employing a daemon monitoring process and fault-tolerant library to provide varying degrees of fault tolerance |
| US5781715A (en) * | 1992-10-13 | 1998-07-14 | International Business Machines Corporation | Fault-tolerant bridge/router with a distributed switch-over mechanism |
| US5513313A (en) * | 1993-01-19 | 1996-04-30 | International Business Machines Corporation | Method for generating hierarchical fault-tolerant mesh architectures |
| US5450578A (en) * | 1993-12-23 | 1995-09-12 | Unisys Corporation | Method and apparatus for automatically routing around faults within an interconnect system |
| AU700629B2 (en) * | 1994-03-22 | 1999-01-07 | Hyperchip Inc. | Efficient direct cell replacement fault tolerant architecture supporting completely integrated systems with means for direct communication with system operator |
| US6408402B1 (en) * | 1994-03-22 | 2002-06-18 | Hyperchip Inc. | Efficient direct replacement cell fault tolerant architecture |
| JPH08227356A (ja) | 1994-12-21 | 1996-09-03 | Tec Corp | データ処理装置 |
| US5682491A (en) * | 1994-12-29 | 1997-10-28 | International Business Machines Corporation | Selective processing and routing of results among processors controlled by decoding instructions using mask value derived from instruction tag and processor identifier |
| US5603044A (en) * | 1995-02-08 | 1997-02-11 | International Business Machines Corporation | Interconnection network for a multi-nodal data processing system which exhibits incremental scalability |
| US5872928A (en) | 1995-02-24 | 1999-02-16 | Cabletron Systems, Inc. | Method and apparatus for defining and enforcing policies for configuration management in communications networks |
| US5889953A (en) | 1995-05-25 | 1999-03-30 | Cabletron Systems, Inc. | Policy management and conflict resolution in computer networks |
| JP2940450B2 (ja) * | 1995-10-26 | 1999-08-25 | 日本電気株式会社 | クラスタ型コンピュータのジョブスケジュール方法及び装置 |
| US5805785A (en) * | 1996-02-27 | 1998-09-08 | International Business Machines Corporation | Method for monitoring and recovery of subsystems in a distributed/clustered system |
| US6006242A (en) | 1996-04-05 | 1999-12-21 | Bankers Systems, Inc. | Apparatus and method for dynamically creating a document |
| US5805786A (en) * | 1996-07-23 | 1998-09-08 | International Business Machines Corporation | Recovery of a name server managing membership of a domain of processors in a distributed computing environment |
| US6393581B1 (en) * | 1996-08-29 | 2002-05-21 | Cornell Research Foundation, Inc. | Reliable time delay-constrained cluster computing |
| US5933631A (en) | 1997-03-17 | 1999-08-03 | International Business Machines Corporation | Dynamic boot filesystem selection |
| US6029246A (en) | 1997-03-31 | 2000-02-22 | Symantec Corporation | Network distributed system for updating locally secured objects in client machines |
| US5991877A (en) | 1997-04-03 | 1999-11-23 | Lockheed Martin Corporation | Object-oriented trusted application framework |
| US6088330A (en) * | 1997-09-09 | 2000-07-11 | Bruck; Joshua | Reliable array of distributed computing nodes |
| US6167502A (en) * | 1997-10-10 | 2000-12-26 | Billions Of Operations Per Second, Inc. | Method and apparatus for manifold array processing |
| US6230252B1 (en) * | 1997-11-17 | 2001-05-08 | Silicon Graphics, Inc. | Hybrid hypercube/torus architecture |
| US6633945B1 (en) | 1997-12-07 | 2003-10-14 | Conexant Systems, Inc. | Fully connected cache coherent multiprocessing systems |
| US6477663B1 (en) * | 1998-04-09 | 2002-11-05 | Compaq Computer Corporation | Method and apparatus for providing process pair protection for complex applications |
| US6189100B1 (en) | 1998-06-30 | 2001-02-13 | Microsoft Corporation | Ensuring the integrity of remote boot client data |
| US6195760B1 (en) | 1998-07-20 | 2001-02-27 | Lucent Technologies Inc | Method and apparatus for providing failure detection and recovery with predetermined degree of replication for distributed applications in a network |
| US6466932B1 (en) | 1998-08-14 | 2002-10-15 | Microsoft Corporation | System and method for implementing group policy |
| US6683696B1 (en) | 1998-10-27 | 2004-01-27 | Hewlett-Packard Development Company, L.P. | Filter based data imaging method for an image forming device |
| US6158010A (en) | 1998-10-28 | 2000-12-05 | Crosslogix, Inc. | System and method for maintaining security in a distributed computer network |
| US6691165B1 (en) | 1998-11-10 | 2004-02-10 | Rainfinity, Inc. | Distributed server cluster for controlling network traffic |
| US6496941B1 (en) * | 1998-12-29 | 2002-12-17 | At&T Corp. | Network disaster recovery and analysis tool |
| US6480972B1 (en) * | 1999-02-24 | 2002-11-12 | International Business Machines Corporation | Data processing system and method for permitting a server to remotely perform diagnostics on a malfunctioning client computer system |
| US6453426B1 (en) * | 1999-03-26 | 2002-09-17 | Microsoft Corporation | Separately storing core boot data and cluster configuration data in a server cluster |
| US6408326B1 (en) | 1999-04-20 | 2002-06-18 | Microsoft Corporation | Method and system for applying a policy to binary data |
| US6718486B1 (en) * | 2000-01-26 | 2004-04-06 | David E. Lovejoy | Fault monitor for restarting failed instances of the fault monitor |
| US6597956B1 (en) | 1999-08-23 | 2003-07-22 | Terraspring, Inc. | Method and apparatus for controlling an extensible computing system |
| US6415323B1 (en) * | 1999-09-03 | 2002-07-02 | Fastforward Networks | Proximity-based redirection system for robust and scalable service-node location in an internetwork |
| US6741983B1 (en) * | 1999-09-28 | 2004-05-25 | John D. Birdwell | Method of indexed storage and retrieval of multidimensional information |
| US6629266B1 (en) * | 1999-11-17 | 2003-09-30 | International Business Machines Corporation | Method and system for transparent symptom-based selective software rejuvenation |
| US6748437B1 (en) * | 2000-01-10 | 2004-06-08 | Sun Microsystems, Inc. | Method for creating forwarding lists for cluster networking |
| WO2001061930A1 (fr) | 2000-02-21 | 2001-08-23 | Kabushiki Kaisha Toshiba | Dispositif de commande de moniteur et procede d'installation d'une voie de communication |
| US6460149B1 (en) * | 2000-03-03 | 2002-10-01 | International Business Machines Corporation | Suicide among well-mannered cluster nodes experiencing heartbeat failure |
| WO2001071524A1 (en) * | 2000-03-22 | 2001-09-27 | Yotta Yotta, Inc. | Method and system for providing multimedia information on demand over wide area networks |
| US6785713B1 (en) | 2000-05-08 | 2004-08-31 | Citrix Systems, Inc. | Method and apparatus for communicating among a network of servers utilizing a transport mechanism |
| US6658504B1 (en) * | 2000-05-16 | 2003-12-02 | Eurologic Systems | Storage apparatus |
| US20040034794A1 (en) | 2000-05-28 | 2004-02-19 | Yaron Mayer | System and method for comprehensive general generic protection for computers against malicious programs that may steal information and/or cause damages |
| JP4292693B2 (ja) | 2000-07-07 | 2009-07-08 | 株式会社日立製作所 | 計算機資源分割装置および資源分割方法 |
| US7032119B2 (en) | 2000-09-27 | 2006-04-18 | Amphus, Inc. | Dynamic power and workload management for multi-server system |
| JP3712654B2 (ja) | 2000-10-30 | 2005-11-02 | 三菱重工業株式会社 | 気体状況予測方法 |
| US7428583B1 (en) | 2000-10-31 | 2008-09-23 | Intel Corporation | Network policy distribution |
| US7055148B2 (en) | 2000-12-07 | 2006-05-30 | Hewlett-Packard Development Company, L.P. | System and method for updating firmware |
| US6735660B1 (en) * | 2000-12-21 | 2004-05-11 | International Business Machines Corporation | Sideband signal transmission between host and input/output adapter |
| WO2002084509A1 (en) | 2001-02-24 | 2002-10-24 | International Business Machines Corporation | A novel massively parrallel supercomputer |
| US7107337B2 (en) | 2001-06-07 | 2006-09-12 | Emc Corporation | Data storage system with integrated switching |
| JP2002259352A (ja) * | 2001-03-01 | 2002-09-13 | Handotai Rikougaku Kenkyu Center:Kk | マルチプロセッサシステム装置 |
| US6952766B2 (en) * | 2001-03-15 | 2005-10-04 | International Business Machines Corporation | Automated node restart in clustered computer system |
| US7028228B1 (en) * | 2001-03-28 | 2006-04-11 | The Shoregroup, Inc. | Method and apparatus for identifying problems in computer networks |
| US6918051B2 (en) * | 2001-04-06 | 2005-07-12 | International Business Machines Corporation | Node shutdown in clustered computer system |
| US6820221B2 (en) * | 2001-04-13 | 2004-11-16 | Hewlett-Packard Development Company, L.P. | System and method for detecting process and network failures in a distributed system |
| US7231430B2 (en) | 2001-04-20 | 2007-06-12 | Egenera, Inc. | Reconfigurable, virtual processing system, cluster, network and method |
| US6675264B2 (en) | 2001-05-07 | 2004-01-06 | International Business Machines Corporation | Method and apparatus for improving write performance in a cluster-based file system |
| EP1402355B1 (en) * | 2001-05-23 | 2018-08-29 | Tekelec Global, Inc. | Methods and systems for automatically configuring network monitoring system |
| US6950833B2 (en) | 2001-06-05 | 2005-09-27 | Silicon Graphics, Inc. | Clustered filesystem |
| US8010558B2 (en) | 2001-06-05 | 2011-08-30 | Silicon Graphics International | Relocation of metadata server with outstanding DMAPI requests |
| JP2003006175A (ja) * | 2001-06-26 | 2003-01-10 | Hitachi Ltd | プロセス実行時のプログラム動作特性に基づくプロセススケジューリング方法及びこれを用いたプログラム及びデータ処理装置 |
| US6988193B2 (en) * | 2001-06-28 | 2006-01-17 | International Business Machines Corporation | System and method for creating a definition for a target device based on an architecture configuration of the target device at a boot server |
| US8032625B2 (en) * | 2001-06-29 | 2011-10-04 | International Business Machines Corporation | Method and system for a network management framework with redundant failover methodology |
| US20030005039A1 (en) | 2001-06-29 | 2003-01-02 | International Business Machines Corporation | End node partitioning using local identifiers |
| SE0102405D0 (sv) | 2001-07-04 | 2001-07-04 | Software Run Ab | A system and a method for selecting a preconfigured operating system for a server |
| GB0116310D0 (en) | 2001-07-04 | 2001-08-29 | New Transducers Ltd | Contact sensitive device |
| US7065764B1 (en) | 2001-07-20 | 2006-06-20 | Netrendered, Inc. | Dynamically allocated cluster system |
| US7016299B2 (en) * | 2001-07-27 | 2006-03-21 | International Business Machines Corporation | Network node failover using path rerouting by manager component or switch port remapping |
| EP1283464A1 (en) | 2001-08-06 | 2003-02-12 | Hewlett-Packard Company | A boot process for a computer, a boot ROM and a computer having a boot ROM |
| US6922791B2 (en) * | 2001-08-09 | 2005-07-26 | Dell Products L.P. | Failover system and method for cluster environment |
| US7073053B1 (en) | 2001-10-11 | 2006-07-04 | Cisco Technology, Inc. | Method and apparatus for a boot progression scheme for reliably initializing a system |
| GB2381713A (en) | 2001-11-01 | 2003-05-07 | 3Com Corp | Failover mechanism involving blocking of access of a malfunctioning server and continuing monitoring to enable unblocking of access if server recovers |
| US6904482B2 (en) * | 2001-11-20 | 2005-06-07 | Intel Corporation | Common boot environment for a modular server system |
| EP1318453A1 (en) | 2001-12-07 | 2003-06-11 | Hewlett-Packard Company | Scheduling system, method and apparatus for a cluster |
| CA2365729A1 (en) * | 2001-12-20 | 2003-06-20 | Platform Computing (Barbados) Inc. | Topology aware scheduling for a multiprocessor system |
| US7046687B1 (en) | 2002-01-16 | 2006-05-16 | Tau Networks | Configurable virtual output queues in a scalable switching system |
| US6918063B2 (en) * | 2002-02-04 | 2005-07-12 | International Business Machines Corporation | System and method for fault tolerance in multi-node system |
| US7093004B2 (en) * | 2002-02-04 | 2006-08-15 | Datasynapse, Inc. | Using execution statistics to select tasks for redundant assignment in a distributed computing platform |
| US7640547B2 (en) * | 2002-02-08 | 2009-12-29 | Jpmorgan Chase & Co. | System and method for allocating computing resources of a distributed computing system |
| DE10214067B4 (de) * | 2002-03-28 | 2010-01-21 | Advanced Micro Devices, Inc., Sunnyvale | Integrierter Schaltkreischip mit Hochgeschwindigkeitsdatenschnittstelle sowie zugehöriges Southbridgebauelement und Verfahren |
| US7043539B1 (en) | 2002-03-29 | 2006-05-09 | Terraspring, Inc. | Generating a description of a configuration for a virtual network system |
| US7139798B2 (en) | 2002-05-17 | 2006-11-21 | Groove Networks, Inc. | Method and apparatus for connecting a secure peer-to-peer collaboration system to an external system |
| US7161904B2 (en) | 2002-06-04 | 2007-01-09 | Fortinet, Inc. | System and method for hierarchical metering in a virtual router based network switch |
| JP3932994B2 (ja) | 2002-06-25 | 2007-06-20 | 株式会社日立製作所 | サーバ引継システムおよびその方法 |
| DE10234992A1 (de) * | 2002-07-31 | 2004-02-19 | Advanced Micro Devices, Inc., Sunnyvale | Retry-Mechanismus für blockierende Schnittstellen |
| US7765299B2 (en) | 2002-09-16 | 2010-07-27 | Hewlett-Packard Development Company, L.P. | Dynamic adaptive server provisioning for blade architectures |
| US7127597B2 (en) | 2002-09-24 | 2006-10-24 | Novell, Inc. | Mechanism for controlling boot decisions from a network policy directory based on client profile information |
| US20040210656A1 (en) | 2003-04-16 | 2004-10-21 | Silicon Graphics, Inc. | Failsafe operation of storage area network |
| US7287179B2 (en) * | 2003-05-15 | 2007-10-23 | International Business Machines Corporation | Autonomic failover of grid-based services |
| US7007125B2 (en) * | 2003-06-24 | 2006-02-28 | International Business Machines Corporation | Pass through circuit for reduced memory latency in a multiprocessor system |
| US7379983B2 (en) | 2003-06-25 | 2008-05-27 | International Business Machines Corporation | Merging scalable nodes into single-partition merged system using service processors of nodes |
| US7644153B2 (en) | 2003-07-31 | 2010-01-05 | Hewlett-Packard Development Company, L.P. | Resource allocation management in interactive grid computing systems |
| WO2005036405A1 (en) | 2003-10-08 | 2005-04-21 | Unisys Corporation | Computer system para-virtualization using a hypervisor that is implemented in a partition of the host system |
| US7207039B2 (en) | 2003-12-24 | 2007-04-17 | Intel Corporation | Secure booting and provisioning |
| US7685597B1 (en) | 2004-02-20 | 2010-03-23 | Sun Microsystems, Inc. | System and method for management of characterized resources |
| US8484348B2 (en) | 2004-03-05 | 2013-07-09 | Rockstar Consortium Us Lp | Method and apparatus for facilitating fulfillment of web-service requests on a communication network |
| US20050256942A1 (en) * | 2004-03-24 | 2005-11-17 | Mccardle William M | Cluster management system and method |
| US8190714B2 (en) * | 2004-04-15 | 2012-05-29 | Raytheon Company | System and method for computer cluster virtualization using dynamic boot images and virtual disk |
| US7711977B2 (en) * | 2004-04-15 | 2010-05-04 | Raytheon Company | System and method for detecting and managing HPC node failure |
| US8335909B2 (en) | 2004-04-15 | 2012-12-18 | Raytheon Company | Coupling processors to each other for high performance computing (HPC) |
| US9178784B2 (en) * | 2004-04-15 | 2015-11-03 | Raytheon Company | System and method for cluster management based on HPC architecture |
| US8336040B2 (en) * | 2004-04-15 | 2012-12-18 | Raytheon Company | System and method for topology-aware job scheduling and backfilling in an HPC environment |
| US20050235055A1 (en) * | 2004-04-15 | 2005-10-20 | Raytheon Company | Graphical user interface for managing HPC clusters |
| US7475274B2 (en) * | 2004-11-17 | 2009-01-06 | Raytheon Company | Fault tolerance and recovery in a high-performance computing (HPC) system |
| US7433931B2 (en) | 2004-11-17 | 2008-10-07 | Raytheon Company | Scheduling in a high-performance computing (HPC) system |
| US8244882B2 (en) * | 2004-11-17 | 2012-08-14 | Raytheon Company | On-demand instantiation in a high-performance computing (HPC) system |
| JP2007141305A (ja) | 2005-11-16 | 2007-06-07 | Hitachi Global Storage Technologies Netherlands Bv | 磁気ディスク装置 |
-
2004
- 2004-11-17 US US10/991,598 patent/US7433931B2/en active Active
-
2005
- 2005-04-05 MY MYPI20051523A patent/MY142928A/en unknown
- 2005-04-07 CA CA002503776A patent/CA2503776C/en active Active
- 2005-04-09 EP EP16166901.5A patent/EP3113021B1/en active Active
- 2005-04-09 EP EP05252239A patent/EP1580661A1/en not_active Ceased
- 2005-04-12 TW TW094111493A patent/TWI287195B/zh not_active IP Right Cessation
- 2005-04-12 WO PCT/US2005/012500 patent/WO2006055028A1/en active Application Filing
- 2005-04-12 KR KR1020077013503A patent/KR101160721B1/ko active IP Right Grant
- 2005-04-14 JP JP2005117405A patent/JP4185919B2/ja active Active
- 2005-04-15 CN CNB2005100878572A patent/CN100380327C/zh active Active
-
2006
- 2006-12-04 IL IL179827A patent/IL179827A/en active IP Right Grant
-
2008
- 2008-10-07 US US12/246,783 patent/US8209395B2/en active Active
Cited By (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101630275B (zh) * | 2009-07-31 | 2012-07-04 | 清华大学 | 一种实现生成循环任务配置信息的方法和装置 |
| CN102103521A (zh) * | 2011-01-31 | 2011-06-22 | 中国科学院计算技术研究所 | Hpc系统以及基于hpc系统的动态分派任务的方法 |
| CN103473247A (zh) * | 2012-06-30 | 2013-12-25 | 中国地质调查局西安地质调查中心 | 地质资料信息集群机理与接口聚合模型 |
| CN103473247B (zh) * | 2012-06-30 | 2017-02-08 | 中国地质调查局西安地质调查中心 | 地质资料信息集群机理与接口聚合系统 |
| CN102902878A (zh) * | 2012-08-17 | 2013-01-30 | 曙光信息产业(北京)有限公司 | 一种能源成本感知调度方法 |
| CN102902878B (zh) * | 2012-08-17 | 2016-12-21 | 曙光信息产业(北京)有限公司 | 一种能源成本感知调度方法 |
| CN105051717A (zh) * | 2013-02-13 | 2015-11-11 | 超威半导体公司 | 增强3d圆环 |
| CN105051717B (zh) * | 2013-02-13 | 2018-05-15 | 超威半导体公司 | 并行圆环网络互连系统及在其中传播数据业务的方法 |
Also Published As
| Publication number | Publication date |
|---|---|
| US8209395B2 (en) | 2012-06-26 |
| TWI287195B (en) | 2007-09-21 |
| EP1580661A1 (en) | 2005-09-28 |
| US20060106931A1 (en) | 2006-05-18 |
| WO2006055028A1 (en) | 2006-05-26 |
| IL179827A (en) | 2012-07-31 |
| EP3113021B1 (en) | 2022-09-14 |
| EP3113021A3 (en) | 2018-02-28 |
| CA2503776A1 (en) | 2006-05-17 |
| MY142928A (en) | 2011-01-31 |
| US7433931B2 (en) | 2008-10-07 |
| JP2006146864A (ja) | 2006-06-08 |
| EP3113021A2 (en) | 2017-01-04 |
| IL179827A0 (en) | 2007-05-15 |
| KR20070086231A (ko) | 2007-08-27 |
| CN100380327C (zh) | 2008-04-09 |
| US20090031316A1 (en) | 2009-01-29 |
| KR101160721B1 (ko) | 2012-06-28 |
| JP4185919B2 (ja) | 2008-11-26 |
| TW200622673A (en) | 2006-07-01 |
| CA2503776C (en) | 2009-03-24 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1776622A (zh) | 高性能计算(hpc)系统中的调度式 | |
| CN1777107A (zh) | 高性能计算(hpc)系统中的按需式例示 | |
| CN100347696C (zh) | 企业业务过程管理的方法和系统 | |
| CN100351818C (zh) | 具有万维网服务功能的图像形成装置 | |
| CN1993674A (zh) | 多芯架构中的资源管理 | |
| CN1637710A (zh) | 用于调度数据处理基础结构中工作单元执行的方法和系统 | |
| CN1122908C (zh) | 数据处理系统用的电能管理系统 | |
| CN1608257A (zh) | 包括相关矩阵和基于量度分析的聚集系统资源分析 | |
| CN1435043A (zh) | 呼叫中心运用方法及装置 | |
| CN1221909C (zh) | 并行处理方法中的作业分配方法及并行处理方法 | |
| CN1052201A (zh) | 动态管理输入/输出(i/o)连接的方法和装置 | |
| CN1601474A (zh) | 执行实时操作的方法和系统 | |
| CN101044498A (zh) | 工作流服务体系结构 | |
| CN1172239C (zh) | 执行移动对象的方法 | |
| CN1677277A (zh) | 服务提供方法、服务提供商设备、信息处理方法和设备 | |
| CN1678997A (zh) | 网络服务装置和方法 | |
| CN1870532A (zh) | 一种信令跟踪方法和系统 | |
| CN1677979A (zh) | 通过网络在计算机之间共享对象的系统和方法 | |
| CN1276575A (zh) | 数据库存取系统 | |
| CN1828642A (zh) | 传感器网络系统、传感器数据的处理方法及程序 | |
| CN1428033A (zh) | 语义信息网络 | |
| CN1684029A (zh) | 存储系统 | |
| CN101061464A (zh) | 信息处理设备及其程序、模块化系统的运行管理系统和组件选择方法 | |
| CN1711523A (zh) | 用于管理多系统群集中资源争用的方法和装置 | |
| CN1734438A (zh) | 信息处理设备、信息处理方法和程序 |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant |