CPU Management User and Administrator Guide
Overview
The purpose of this guide is to assist Slurm users and administrators in selecting configuration options
and composing command lines to manage the use of CPU resources by jobs, steps and tasks.
このガイドの目的は、Slurmユーザーと管理者が構成オプションを選択し、コマンドラインを作成して、ジョブ、ステップ、およびタスクによるCPUリソースの使用を管理するのを支援することです。
The document
is divided into the following sections:
このドキュメントは、次のセクションに分かれています。
- Overview
- CPU Management Steps performed by Slurm
- Getting Information about CPU usage by Jobs/Steps/Tasks
- CPU Management and Slurm Accounting
- CPU Management Examples
CPU Management through user commands is constrained by the configuration parameters
chosen by the Slurm administrator.
ユーザーコマンドによるCPU管理は、Slurm管理者が選択した構成パラメーターによって制約されます。
The interactions between different CPU management options are complex
and often difficult to predict.
異なるCPU管理オプション間の相互作用は複雑であり、予測が難しいことがよくあります。
Some experimentation may be required to discover the exact combination
of options needed to produce a desired outcome.
望ましい結果を生み出すために必要なオプションの正確な組み合わせを見つけるには、いくつかの実験が必要になる場合があります。
Users and administrators should refer to the man pages
for slurm.conf, cgroup.conf,
salloc,
sbatch and srun for detailed explanations of each
option.
ユーザーと管理者は、各オプションの詳細な説明について、slurm.conf、cgroup.conf、salloc、sbatch、およびsrunのマニュアルページを参照する必要があります。
The following html documents may also be useful:
次のhtmlドキュメントも役立つ場合があります。
Consumable Resources in Slurm
Sharing Consumable Resources
Support for Multi-core/Multi-thread
Architectures
Plane distribution
This document describes Slurm CPU management for conventional Linux clusters only.
このドキュメントでは、従来のLinuxクラスターのみのSlurmCPU管理について説明します。
For
information on Cray ALPS systems, please refer to the appropriate documents.
Cray ALPSシステムの詳細については、該当するドキュメントを参照してください。
CPU Management Steps performed by Slurm
Slurm uses four basic steps to manage CPU resources for a job/step:
Slurmは、4つの基本的なステップを使用して、ジョブ/ステップのCPUリソースを管理します。
- Step 1: Selection of Nodes
- Step 2: Allocation of CPUs from the selected Nodes
- Step 3: Distribution of Tasks to the selected Nodes
- Step 4: Optional Distribution and Binding of Tasks to CPUs within a Node
Step 1: Selection of Nodes
In Step 1, Slurm selects the set of nodes from which CPU resources are to be allocated to a job or
job step.
ステップ1で、Slurmは、CPUリソースをジョブまたはジョブステップに割り当てるノードのセットを選択します。
Node selection is therefore influenced by many of the configuration and command line options
that control the allocation of CPUs (Step 2 below).
したがって、ノードの選択は、CPUの割り当てを制御する構成およびコマンドラインオプションの多くの影響を受けます（以下のステップ2）。
If
SelectType=select/linear is configured, all resources on the selected nodes will be allocated
to the job/step.
SelectType = select / linearが構成されている場合、選択されたノード上のすべてのリソースがジョブ/ステップに割り当てられます。
If SelectType=select/cons_res is configured,
individual sockets, cores and threads may be allocated from the selected nodes as
consumable resources.
SelectType = select / cons_resが構成されている場合、個々のソケット、コア、およびスレッドは、選択されたノードから消費可能なリソースとして割り当てられる可能性があります。
The consumable resource type is defined by
SelectTypeParameters.
消費可能なリソースタイプは、SelectTypeParametersによって定義されます。
Step 1 is performed by slurmctld and the select plugin.
ステップ1は、slurmctldとselectプラグインによって実行されます。
|
slurm.conf parameter |
Possible values |
Description |
|
<name of the node> |
Defines
a node. |
|
|
<name of the partition> |
Defines
a partition. |
|
|
config_overrides |
Controls
how the information in a node definition is used. |
|
|
select/linear | select/cons_res |
Controls
whether CPU resources are allocated to jobs and job steps in
units of whole nodes or as consumable resources (sockets, cores
or threads). |
|
|
CR_CPU | CR_CPU_Memory | CR_Core |
CR_Core_Memory | CR_Socket | CR_Socket_Memory |
Defines
the consumable resource type and controls other aspects of CPU
resource allocation by the select plugin. |
|
Command line option |
Possible values |
Description |
|
<sockets[:cores[:threads]]> |
Restricts
node selection to nodes with a specified layout of sockets, cores
and threads. |
|
|
<list> |
Restricts
node selection to nodes with specified attributes |
|
|
N/A |
Restricts
node selection to contiguous nodes |
|
|
<cores> |
Restricts
node selection to nodes with at least the specified number of cores per socket |
|
|
<ncpus> |
Controls
the number of CPUs allocated per task |
|
|
N/A |
Prevents
sharing of allocated nodes with other jobs. |
|
|
<node file> |
File
containing a list of specific nodes to be selected for the job (salloc and sbatch only) |
|
|
compute_bound | memory_bound | [no]multithread |
Additional
controls on allocation of CPU resources |
|
|
<n> |
Controls
the minimum number of CPUs allocated per node |
|
|
<minnodes[-maxnodes]> |
Controls
the minimum/maximum number of nodes allocated to the job |
|
|
<number> |
Controls
the number of tasks to be created for the job |
|
|
<number> |
Controls
the maximum number of tasks per allocated core |
|
|
<number> |
Controls
the maximum number of tasks per allocated socket |
|
|
<number> |
Controls
the maximum number of tasks per allocated node |
|
|
N/A |
Allows
fewer CPUs to be allocated than the number of tasks |
|
|
<partition_names> |
Controls
which partition is used for the job |
|
|
N/A |
Allows
sharing of allocated nodes with other jobs |
|
|
<sockets> |
Restricts
node selection to nodes with at least the specified number of sockets |
|
|
<threads> |
Restricts
node selection to nodes with at least the specified number of threads per core |
|
|
<host1,host2,... or filename> |
List
of specific nodes to be allocated to the job |
|
|
<host1,host2,... or filename> |
List
of specific nodes to be excluded from allocation to the job |
|
|
N/A |
Bypass
normal allocation (privileged option available to users
“SlurmUser” and “root” only) |
Step 2: Allocation of CPUs from the selected Nodes
In Step 2, Slurm allocates CPU resources to a job/step from the set of nodes selected
in Step 1.
ステップ2で、Slurmはステップ1で選択したノードのセットからジョブ/ステップにCPUリソースを割り当てます。
CPU allocation is therefore influenced by the configuration and command line options
that relate to node selection.
したがって、CPU割り当ては、ノードの選択に関連する構成とコマンドラインオプションの影響を受けます。
If
SelectType=select/linear is configured, all resources on the selected nodes will be allocated
to the job/step.
SelectType = select / linearが構成されている場合、選択されたノード上のすべてのリソースがジョブ/ステップに割り当てられます。
If SelectType=select/cons_res is configured,
individual sockets, cores and threads may be allocated from the selected nodes as
consumable resources.
SelectType = select / cons_resが構成されている場合、個々のソケット、コア、およびスレッドは、選択されたノードから消費可能なリソースとして割り当てられる可能性があります。
The consumable resource type is defined by
SelectTypeParameters.
消費可能なリソースタイプは、SelectTypeParametersによって定義されます。
When using SelectType=select/cons_res,
the default allocation method across nodes is block allocation (allocate all available CPUs in
a node before using another node).
SelectType = select / cons_resを使用する場合、ノード間のデフォルトの割り当て方法はブロック割り当てです（別のノードを使用する前に、ノード内の使用可能なすべてのCPUを割り当てます）。
The default allocation method within a node is cyclic
allocation (allocate available CPUs in a round-robin fashion across the sockets within a node).
ノード内のデフォルトの割り当て方法は、循環割り当てです（ノード内のソケット間でラウンドロビン方式で使用可能なCPUを割り当てます）。
Users may override the default behavior using the appropriate command
line options described below.
ユーザーは、以下で説明する適切なコマンドラインオプションを使用して、デフォルトの動作を上書きできます。
The choice of allocation methods may influence which specific
CPUs are allocated to the job/step.
割り当て方法の選択は、どの特定のCPUがジョブ/ステップに割り当てられるかに影響を与える可能性があります。
Step 2 is performed by slurmctld and the select plugin.
ステップ2は、slurmctldとselectプラグインによって実行されます。
|
slurm.conf parameter |
Possible values |
Description |
|
<name of the node> |
Defines
a node. |
|
|
<name of the partition> |
Defines
a partition. |
|
|
config_overrides |
Controls
how the information in a node definition is used. |
|
|
select/linear | select/cons_res |
Controls
whether CPU resources are allocated to jobs and job steps in
units of whole nodes or as consumable resources (sockets, cores
or threads). |
|
|
CR_CPU | CR_CPU_Memory | CR_Core |
CR_Core_Memory | CR_Socket | CR_Socket_Memory |
Defines
the consumable resource type and controls other aspects of CPU
resource allocation by the select plugin. |
|
Command line option |
Possible values |
Description |
|
<sockets[:cores[:threads]]> |
Restricts
node selection to nodes with a specified layout of sockets, cores
and threads. |
|
|
<list> |
Restricts
node selection to nodes with specified attributes |
|
|
N/A |
Restricts
node selection to contiguous nodes |
|
|
<cores> |
Restricts
node selection to nodes with at least the specified number of cores per socket |
|
|
<ncpus> |
Controls
the number of CPUs allocated per task |
|
|
block|cyclic |
The second specified distribution (after the ":")
can be used to override the default allocation method within nodes |
|
|
N/A |
Prevents
sharing of allocated nodes with other jobs |
|
|
<node file> |
File
containing a list of specific nodes to be selected for the job (salloc and sbatch only) |
|
|
compute_bound | memory_bound | [no]multithread |
Additional
controls on allocation of CPU resources |
|
|
<n> |
Controls
the minimum number of CPUs allocated per node |
|
|
<minnodes[-maxnodes]> |
Controls
the minimum/maximum number of nodes allocated to the job |
|
|
<number> |
Controls
the number of tasks to be created for the job |
|
|
<number> |
Controls
the maximum number of tasks per allocated core |
|
|
<number> |
Controls
the maximum number of tasks per allocated socket |
|
|
<number> |
Controls
the maximum number of tasks per allocated node |
|
|
N/A |
Allows
fewer CPUs to be allocated than the number of tasks |
|
|
<partition_names> |
Controls
which partition is used for the job |
|
|
N/A |
Allows
sharing of allocated nodes with other jobs |
|
|
<sockets> |
Restricts
node selection to nodes with at least the specified number of sockets |
|
|
<threads> |
Restricts
node selection to nodes with at least the specified number of threads per core |
|
|
<host1,host2,... or filename> |
List
of specific nodes to be allocated to the job |
|
|
<host1,host2,... or filename> |
List
of specific nodes to be excluded from allocation to the job |
|
|
N/A |
Bypass
normal allocation (privileged option available to users
“SlurmUser” and “root” only) |
Step 3: Distribution of Tasks to the selected Nodes
In Step 3, Slurm distributes tasks to the nodes that were selected for
the job/step in Step 1.
ステップ3で、Slurmは、ステップ1でジョブ/ステップ用に選択されたノードにタスクを分散します。
Each task is distributed to only one node, but more than one
task may be distributed to each node.
各タスクは1つのノードにのみ分散されますが、複数のタスクが各ノードに分散される場合があります。
Unless overcommitment of CPUs to tasks is
specified for the job, the number of tasks distributed to a node is
constrained by the number of CPUs allocated on the node and the number of CPUs per
task.
タスクへのCPUのオーバーコミットがジョブに指定されていない限り、ノードに分散されるタスクの数は、ノードに割り当てられたCPUの数とタスクごとのCPUの数によって制約されます。
If consumable resources is configured, or resource sharing is allowed, tasks from
more than one job/step may run on the same node concurrently.
消費可能なリソースが構成されている場合、またはリソースの共有が許可されている場合、複数のジョブ/ステップからのタスクが同じノードで同時に実行される可能性があります。
Step 3 is performed by slurmctld.
ステップ3はslurmctldによって実行されます。
|
slurm.conf parameter |
Possible values |
Description |
|
<number> |
Controls the maximum number of tasks that a job step can spawn on a single node |
|
Command line option |
Possible values |
Description |
|
block|cyclic |
The first specified distribution (before the ":")
controls the sequence in which tasks are distributed to each of the selected nodes. |
|
|
<number> |
Controls the maximum number of tasks per allocated core |
|
|
<number> |
Controls the maximum number of tasks per allocated socket |
|
|
<number> |
Controls the maximum number of tasks per allocated node |
|
|
N/A |
Controls
which node is used for a job step |
Step 4: Optional Distribution and Binding of Tasks to CPUs within a Node
In optional Step 4, Slurm distributes and binds each task to a specified subset of
the allocated CPUs on the node to which the task was distributed in Step 3.
オプションのステップ4で、Slurmは各タスクを分散し、ステップ3でタスクが分散されたノードに割り当てられたCPUの指定されたサブセットにバインドします。
Different
tasks distributed to the same node may be bound to the same subset of CPUs or to
different subsets.
同じノードに分散された異なるタスクは、CPUの同じサブセットまたは異なるサブセットにバインドされる場合があります。
This step is known as task affinity or task/CPU binding.
このステップは、タスクアフィニティまたはタスク/ CPUバインディングと呼ばれます。
Step 4 is performed by slurmd and the task plugin.
ステップ4は、slurmdとタスクプラグインによって実行されます。
|
slurm.conf parameter |
Possible values |
Description |
|
task/none | task/affinity | task/cgroup |
Controls whether this step is enabled and which task plugin to use |
|
|
See man page |
For task/affinity, controls the binding unit (sockets, cores or threads) and the
binding method (sched or cpusets) |
|
cgroup.conf parameter |
Possible values |
Description |
|
yes|no |
Controls whether jobs are constrained to their allocated CPUs |
|
|
yes|no |
Controls whether task-to-CPU binding is enabled |
|
Command line option |
Possible values |
Description |
|
See man page |
Controls binding of tasks to CPUs |
|
|
<number> |
Controls the maximum number of tasks per allocated core |
|
|
block|cyclic |
The second specified distribution (after the ":") controls the sequence in which tasks are
distributed to allocated CPUs within a node for binding of tasks to CPUs |
Additional Notes on CPU Management Steps
For consumable resources, it is important for users to understand the difference between
cpu allocation (Step 2) and task affinity/binding (Step 4).
消費可能なリソースの場合、ユーザーはCPU割り当て（ステップ2）とタスクのアフィニティ/バインディング（ステップ4）の違いを理解することが重要です。
Exclusive (unshared) allocation
of CPUs as consumable resources limits the number of jobs/steps/tasks that
can use a node concurrently.
消費可能なリソースとしてのCPUの排他的（非共有）割り当ては、ノードを同時に使用できるジョブ/ステップ/タスクの数を制限します。
But it does not limit the set of CPUs on the node that each
task distributed to the node can use.
ただし、ノードに分散された各タスクが使用できるノード上のCPUのセットを制限するものではありません。
Unless some form of CPU/task binding is used
(e.g., a task or spank plugin), all tasks distributed to a node can use all of
the CPUs on the node, including CPUs not allocated to their job/step.
何らかの形式のCPU /タスクバインディング（タスクまたはスパンクプラグインなど）が使用されていない限り、ノードに分散されたすべてのタスクは、ジョブ/ステップに割り当てられていないCPUを含め、ノード上のすべてのCPUを使用できます。
This may have
unexpected adverse effects on performance, since it allows one job to use CPUs allocated
exclusively to another job.
これにより、あるジョブが別のジョブに排他的に割り当てられたCPUを使用できるようになるため、パフォーマンスに予期しない悪影響が生じる可能性があります。
For this reason, it may not be advisable to configure
consumable resources without also configuring task affinity.
このため、タスクアフィニティも構成せずに消費可能なリソースを構成することはお勧めできません。
Note that task affinity
can also be useful when select/linear (whole node allocation) is configured, to improve
performance by restricting each task to a particular socket or other subset of CPU
resources on a node.
タスクアフィニティは、選択/線形（ノード全体の割り当て）が構成されている場合にも役立ち、各タスクをノード上の特定のソケットまたはCPUリソースの他のサブセットに制限することでパフォーマンスを向上させることができます。
Getting Information about CPU usage by Jobs/Steps/Tasks
There is no easy way to generate a comprehensive set of CPU management information
for a job/step (allocation, distribution and binding).
ジョブ/ステップ（割り当て、分散、バインド）のCPU管理情報の包括的なセットを生成する簡単な方法はありません。
However, several
commands/options provide limited information about CPU usage.
ただし、いくつかのコマンド/オプションは、CPU使用率に関する限られた情報を提供します。
|
Command/Option |
Information |
|
scontrol show job option: --details |
This option provides a list of the nodes selected for the job and the CPU ids allocated to the job on each
node. |
|
Linux command: env |
Man. |
|
srun/salloc/sbatch option: --cpu-bind=verbose |
This option provides a list of the CPU masks used by task affinity to bind tasks to CPUs. |
|
srun/salloc/sbatch option: -l |
This option adds the task id as a prefix to each line of output from a task sent to stdout/stderr. |
|
Linux command: |
Given a task's pid (or "self" if the command is executed by the task itself), this command
produces a list of the CPU ids bound to the task. |
A Note on CPU Numbering
The number and layout of logical CPUs known to Slurm is described in the node definitions in slurm.conf.
Slurmに認識されている論理CPUの数とレイアウトは、slurm.confのノード定義に記載されています。
This may
differ from the physical CPU layout on the actual hardware.
これは、実際のハードウェアの物理CPUレイアウトとは異なる場合があります。
For this reason, Slurm generates its own internal, or
"abstract", CPU numbers.
このため、Slurmは独自の内部または「抽象」CPU番号を生成します。
These numbers may not match the physical, or "machine", CPU numbers known to Linux.
これらの番号は、Linuxで認識されている物理的な「マシン」CPU番号と一致しない場合があります。
CPU Management and Slurm Accounting
CPU management by Slurm users is subject to limits imposed by Slurm Accounting.
SlurmユーザーによるCPU管理には、Slurmアカウンティングによる制限が適用されます。
Accounting limits may be applied on CPU
usage at the level of users, groups and clusters.
アカウンティング制限は、ユーザー、グループ、およびクラスターのレベルでCPU使用率に適用される場合があります。
For details, see the sacctmgr man page.
詳細については、sacctmgrのmanページを参照してください。
CPU Management Examples
The following examples illustrate some scenarios for managing CPU
resources using Slurm.
次の例は、Slurmを使用してCPUリソースを管理するためのいくつかのシナリオを示しています。
Many additional scenarios are possible.
多くの追加シナリオが可能です。
In
each example, it is assumed that all CPUs on each node are available
for allocation.
各例では、各ノードのすべてのCPUが割り当て可能であると想定されています。
- Example Node and Partition Configuration
ノードとパーティションの構成例
- Example 1: Allocation of whole nodes
例1：ノード全体の割り当て
- Example 2: Simple allocation of cores as consumable resources
例2：消費可能なリソースとしてのコアの単純な割り当て
- Example 3: Consumable resources with balanced allocation across nodes
例3：ノード間でバランスの取れた割り当てを持つ消耗品リソース
- Example 4: Consumable resources with minimization of resource fragmentation
例4：リソースの断片化を最小限に抑えた消費可能なリソース
- Example 5: Consumable resources with cyclic distribution of tasks to nodes
例5：ノードへのタスクの循環分散を伴う消費可能なリソース
- Example 6: Consumable resources with default allocation and plane distribution of tasks to nodes
例6：ノードへのタスクのデフォルトの割り当てと平面分散を使用した消費可能なリソース
- Example 7: Consumable resources with overcommitment of CPUs to tasks
例7：タスクへのCPUのオーバーコミットメントを伴う消費可能なリソース
- Example 8: Consumable resources with resource sharing between jobs
例8：ジョブ間でリソースを共有する消耗品リソース
- Example 9: Consumable resources on multithreaded node, allocating only one thread per core
例9：コアごとに1つのスレッドのみを割り当てる、マルチスレッドノード上の消費可能なリソース
- Example 10: Consumable resources with task affinity and core binding
例10：タスクアフィニティとコアバインディングを備えた消費可能なリソース
- Example 11: Consumable resources with task affinity and socket binding, Case 1
例11：タスクアフィニティとソケットバインディングを備えた消費可能なリソース、ケース1
- Example 12: Consumable resources with task affinity and socket binding, Case 2
例12：タスクアフィニティとソケットバインディングを備えた消費可能なリソース、ケース2
- Example 13: Consumable resources with task affinity and socket binding, Case 3
例13：タスクアフィニティとソケットバインディングを備えた消費可能なリソース、ケース3
- Example 14: Consumable resources with task affinity and customized allocation and distribution
例14：タスクアフィニティとカスタマイズされた割り当てと分散を備えた消費可能なリソース
- Example 15: Consumable resources with task affinity to optimize the performance of a multi-task,
multi-thread job
例15：マルチタスク、マルチスレッドジョブのパフォーマンスを最適化するためのタスクアフィニティを備えた消費可能なリソース
- Example 16: Consumable resources with task cgroup and core binding
例16：タスクcgroupとコアバインディングを使用した消費可能なリソース
Example Node and Partition Configuration
For these examples, the Slurm cluster contains the following nodes:
これらの例では、Slurmクラスターには次のノードが含まれています。
|
Nodename |
n0 |
n1 |
n2 |
n3 |
|
Number of Sockets |
2 |
2 |
2 |
2 |
|
Number of Cores per Socket |
4 |
4 |
4 |
4 |
|
Total Number of Cores |
8 |
8 |
8 |
8 |
|
Number of Threads (CPUs) per Core |
1 |
1 |
1 |
2 |
|
Total Number of CPUs |
8 |
8 |
8 |
16 |
And the following partitions:
|
PartitionName |
regnodes |
hypernode |
|
Nodes |
n0 n1 n2 |
n3 |
|
Default |
YES |
- |
These entities are defined in slurm.conf as follows:
Nodename=n0 NodeAddr=node0 Sockets=2 CoresPerSocket=4 ThreadsPerCore=1 Procs=8 Nodename=n1 NodeAddr=node1 Sockets=2 CoresPerSocket=4 ThreadsPerCore=1 Procs=8 State=IDLE Nodename=n2 NodeAddr=node2 Sockets=2 CoresPerSocket=4 ThreadsPerCore=1 Procs=8 State=IDLE Nodename=n3 NodeAddr=node3 Sockets=2 CoresPerSocket=4 ThreadsPerCore=2 Procs=16 State=IDLE PartitionName=regnodes Nodes=n0,n1,n2 OverSubscribe=YES Default=YES State=UP PartitionName=hypernode Nodes=n3 State=UP
Example 1: Allocation of whole nodes
Allocate a minimum of two whole nodes to a job.
少なくとも2つのノード全体をジョブに割り当てます。
slurm.conf options:
SelectType=select/linear
Command line:
srun --nodes=2 ...
Comments:
The SelectType=select/linear configuration option specifies allocation in units of whole nodes.SelectType = select / linear構成オプションは、ノード全体の単位で割り当てを指定します。
The --nodes=2 srun option causes Slurm to allocate at least 2 nodes to the job.
--nodes = 2 srunオプションを使用すると、Slurmは少なくとも2つのノードをジョブに割り当てます。
Example 2: Simple allocation of cores as consumable resources
A job requires 6 CPUs (2 tasks and 3 CPUs per task with no overcommitment).
ジョブには6つのCPUが必要です（オーバーコミットなしで、タスクごとに2つのタスクと3つのCPU）。
Allocate the 6 CPUs as consumable resources
from a single node in the default partition.
デフォルトのパーティションの単一ノードから、6つのCPUを消費可能なリソースとして割り当てます。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=1-1 --ntasks=2 --cpus-per-task=3 ...
Comments:
The SelectType configuration options define cores as consumable resources.
SelectType構成オプションは、コアを消費可能なリソースとして定義します。
The --nodes=1-1 srun option
restricts the job to a single node.
--nodes = 1-1 srunオプションは、ジョブを単一ノードに制限します。
The following table shows a possible pattern of allocation
for this job.
次の表は、このジョブの可能な割り当てパターンを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|
Number of Allocated CPUs |
6 |
0 |
0 |
|
Number of Tasks |
2 |
0 |
0 |
Example 3: Consumable resources with balanced allocation across nodes
A job requires 9 CPUs (3 tasks and 3 CPUs per task with no overcommitment).
ジョブには9個のCPUが必要です（オーバーコミットなしで、タスクごとに3個のタスクと3個のCPU）。
Allocate 3 CPUs from each of the 3 nodes in the default partition.
デフォルトパーティションの3つのノードのそれぞれから3つのCPUを割り当てます。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=3-3 --ntasks=3 --cpus-per-task=3 ...
Comments:
The options specify the following conditions for the job: 3 tasks, 3 unique CPUs
per task, using exactly 3 nodes.
オプションは、ジョブに次の条件を指定します。3つのタスク、タスクごとに3つの一意のCPU、正確に3つのノードを使用します。
To satisfy these conditions, Slurm must
allocate 3 CPUs from each node.
これらの条件を満たすために、Slurmは各ノードから3つのCPUを割り当てる必要があります。
The following table shows the allocation
for this job.
次の表は、このジョブの割り当てを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|
Number of Allocated CPUs |
3 |
3 |
3 |
|
Number of Tasks |
1 |
1 |
1 |
Example 4: Consumable resources with minimization of resource fragmentation
A job requires 12 CPUs (12 tasks and 1 CPU per task with no overcommitment).
ジョブには12個のCPUが必要です（オーバーコミットなしで、タスクごとに12個のタスクと1個のCPU）。
Allocate
CPUs using the minimum number of nodes and the minimum number of sockets required for
the job in order to minimize fragmentation of allocated/unallocated CPUs in the cluster.
クラスター内の割り当て済み/未割り当てCPUの断片化を最小限に抑えるために、ジョブに必要な最小数のノードと最小数のソケットを使用してCPUを割り当てます。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core,CR_CORE_DEFAULT_DIST_BLOCK
Command line:
srun --ntasks=12 ...
Comments:
The default allocation method across nodes is block.
ノード間のデフォルトの割り当て方法はブロックです。
This minimizes the number of nodes
used for the job.
これにより、ジョブに使用されるノードの数が最小限に抑えられます。
The configuration option
CR_CORE_DEFAULT_DIST_BLOCK sets the default allocation method within a
node to block.
構成オプションCR_CORE_DEFAULT_DIST_BLOCKは、ブロックするノード内のデフォルトの割り当て方法を設定します。
This minimizes the number of sockets used for the job within a node.
これにより、ノード内のジョブに使用されるソケットの数が最小限に抑えられます。
The combination of these two methods causes Slurm to allocate the 12 CPUs using the
minimum required number of nodes (2 nodes) and sockets (3 sockets).
これら2つの方法を組み合わせると、Slurmは必要最小限のノード数（2ノード）とソケット数（3ソケット）を使用して12個のCPUを割り当てます。
The following
table shows a possible pattern of allocation for this job.
次の表は、このジョブの可能な割り当てパターンを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|||
|
Socket id |
0 |
1 |
0 |
1 |
0 |
1 |
|
Number of Allocated CPUs |
4 |
4 |
4 |
0 |
0 |
0 |
|
Number of Tasks |
8 |
4 |
0 |
|||
Example 5: Consumable resources with cyclic distribution of tasks to nodes
A job requires 12 CPUs (6 tasks and 2 CPUs per task with no overcommitment).
ジョブには12個のCPUが必要です（オーバーコミットなしで、タスクごとに6個のタスクと2個のCPU）。
Allocate
6 CPUs each from 2 nodes in the default partition.
デフォルトパーティションの2つのノードからそれぞれ6つのCPUを割り当てます。
Distribute tasks to nodes cyclically.
タスクをノードに周期的に分散します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=2-2 --ntasks-per-node=3 --distribution=cyclic
--ntasks=6 --cpus-per-task=2 ...
Comments:
The options specify the following conditions for the job: 6 tasks, 2 unique CPUs per task,
using exactly 2 nodes, and with 3 tasks per node.
オプションは、ジョブの次の条件を指定します。6つのタスク、タスクごとに2つの一意のCPU、正確に2つのノードを使用し、ノードごとに3つのタスク。
To satisfy these conditions, Slurm
must allocate 6 CPUs from each of the 2 nodes.
これらの条件を満たすために、Slurmは2つのノードのそれぞれから6つのCPUを割り当てる必要があります。
The
--distribution=cyclic option causes the tasks to be distributed to the nodes in a
round-robin fashion.
--distribution = cyclicオプションを使用すると、タスクがラウンドロビン方式でノードに分散されます。
The following table shows a possible pattern of allocation and
distribution for this job.
次の表は、このジョブの割り当てと分散の可能なパターンを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|
Number of Allocated CPUs |
6 |
6 |
0 |
|
Number of Tasks |
3 |
3 |
0 |
|
Distribution of Tasks to Nodes, by Task id |
0 |
1 |
- |
Example 6: Consumable resources with default allocation and plane distribution of tasks to nodes
A job requires 16 CPUs (8 tasks and 2 CPUs per task with no overcommitment).
ジョブには16個のCPUが必要です（オーバーコミットなしで、タスクごとに8個のタスクと2個のCPU）。
Use all 3 nodes in the default partition.
デフォルトパーティションの3つのノードすべてを使用します。
Distribute tasks to each node in blocks of two in a round-robin fashion.
ラウンドロビン方式で、タスクを2つのブロックで各ノードに分散します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=3-3 --distribution=plane=2 --ntasks=8 --cpus-per-task=2 ...
Comments:
The options specify the following conditions for the job: 8 tasks, 2 unique CPUs
per task, using all 3 nodes in the partition.
オプションは、ジョブに対して次の条件を指定します。8つのタスク、タスクごとに2つの固有のCPU、パーティション内の3つのノードすべてを使用します。
To satisfy these conditions using
the default allocation method across nodes (block), Slurm allocates 8 CPUs from
the first node, 6 CPUs from the second node and 2 CPUs from the third node.
ノード（ブロック）間でデフォルトの割り当て方法を使用してこれらの条件を満たすために、Slurmは最初のノードから8 CPU、2番目のノードから6 CPU、3番目のノードから2CPUを割り当てます。
The --distribution=plane=2 option causes Slurm
to distribute tasks in blocks of two to each of the nodes in a round-robin fashion,
subject to the number of CPUs allocated on each node.
--distribution = plane = 2オプションを使用すると、Slurmは、各ノードに割り当てられたCPUの数に応じて、ラウンドロビン方式で各ノードに2つのブロックでタスクを分散します。
So, for example, only 1 task
is distributed to the third node because only 2 CPUs were allocated on that node and
each task requires 2 CPUs.
したがって、たとえば、3番目のノードには2つのCPUしか割り当てられておらず、各タスクには2つのCPUが必要であるため、1つのタスクのみが3番目のノードに分散されます。
The following table shows a possible pattern of allocation
and distribution for this job.
次の表は、このジョブの割り当てと分散の可能なパターンを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|
Number of Allocated CPUs |
8 |
6 |
2 |
|
Number of Tasks |
4 |
3 |
1 |
|
Distribution of Tasks to Nodes, by Task id |
0
1 |
2
3 |
4 |
Example 7: Consumable resources with overcommitment of CPUs to tasks
A job has 20 tasks.
ジョブには20のタスクがあります。
Run the job in a single node.
単一ノードでジョブを実行します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=1-1 --ntasks=20 --overcommit ...
Comments:
The
--overcommit option allows the job to
run in only one node by overcommitting CPUs to tasks.
--overcommitオプションを使用すると、CPUをタスクにオーバーコミットすることにより、ジョブを1つのノードでのみ実行できます。
The following table shows
a possible pattern of allocation and distribution for this job.
次の表は、このジョブの割り当てと分散の可能なパターンを示しています。
|
Nodename |
n0 |
n1 |
n2 |
|
Number of Allocated CPUs |
8 |
0 |
0 |
|
Number of Tasks |
20 |
0 |
0 |
|
Distribution of Tasks to Nodes, by Task id |
0 - 19 |
- |
- |
Example 8: Consumable resources with resource sharing between jobs
2 jobs each require 6 CPUs (6 tasks per job with no overcommitment).
2つのジョブにはそれぞれ6つのCPUが必要です（オーバーコミットなしのジョブごとに6つのタスク）。
Run both jobs simultaneously in a single node.
1つのノードで両方のジョブを同時に実行します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core
Command line:
srun --nodes=1-1 --nodelist=n0 --ntasks=6 --oversubscribe ... srun --nodes=1-1 --nodelist=n0 --ntasks=6 --oversubscribe ...
Comments:
The --nodes=1-1 and --nodelist=n0
srun options together restrict both jobs to node n0.
--nodes = 1-1および--nodelist = n0 srunオプションを一緒に使用すると、両方のジョブがノードn0に制限されます。
The
OverSubscribe=YES option in the partition definition plus
the --oversubscribe srun option allows the two
jobs to oversubscribe CPUs on the node.
パーティション定義のOverSubscribe = YESオプションと--oversubscribesrunオプションを使用すると、2つのジョブがノード上のCPUをオーバーサブスクライブできます。
Example 9: Consumable resources on multithreaded node, allocating only one thread per core
A job requires 8 CPUs (8 tasks with no overcommitment).
ジョブには8個のCPUが必要です（オーバーコミットなしの8個のタスク）。
Run the job on node n3,
allocating only one thread per core.
ノードn3でジョブを実行し、コアごとに1つのスレッドのみを割り当てます。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_CPU
Command line:
srun --partition=hypernode --ntasks=8 --hint=nomultithread ...
Comments:
The CR_CPU configuration
option enables the allocation of only one thread per core.
CR_CPU構成オプションを使用すると、コアごとに1つのスレッドのみを割り当てることができます。
The --hint=nomultithread
srun option causes Slurm to allocate only one thread from each core to
this job.
--hint = nomultithread srunオプションを使用すると、Slurmは各コアからこのジョブに1つのスレッドのみを割り当てます。
The following table shows a possible pattern of allocation
for this job.
次の表は、このジョブの可能な割り当てパターンを示しています。
|
Nodename |
n3 |
|||||||||||||||
|
Socket id |
0 |
1 |
||||||||||||||
|
Core id |
0 |
1 |
2 |
3 |
0 |
1 |
2 |
3 |
||||||||
|
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
|
Number of Allocated CPUs |
4 |
4 |
||||||||||||||
|
Allocated CPU ids |
0 2 4 6 |
8 10 12 14 |
||||||||||||||
Example 10: Consumable resources with task affinity and core binding
A job requires 6 CPUs (6 tasks with no overcommitment).
ジョブには6つのCPUが必要です（オーバーコミットなしの6つのタスク）。
Run the job in a
single node in the default partition.
デフォルトパーティションの単一ノードでジョブを実行します。
Apply core binding to each task.
各タスクにコアバインディングを適用します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --nodes=1-1 --ntasks=6 --cpu-bind=cores ...
Comments:
Using the default allocation method within nodes (cyclic), Slurm allocates
3 CPUs on each socket of 1 node.
Slurmは、ノード内のデフォルトの割り当て方法（循環）を使用して、1つのノードの各ソケットに3つのCPUを割り当てます。
Using the default distribution method
within nodes (cyclic), Slurm distributes and binds each task to an allocated
core in a round-robin fashion across the sockets.
Slurmは、ノード内のデフォルトの分散方法（循環）を使用して、ソケット全体にラウンドロビン方式で各タスクを分散し、割り当てられたコアにバインドします。
The following table shows
a possible pattern of allocation, distribution and binding for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
For example, task id 2 is bound to CPU id 1.
たとえば、タスクID2はCPUID1にバインドされています。
|
Nodename |
n0 |
||||||||
|
Socket id |
0 |
1 |
|||||||
|
Number of Allocated CPUs |
3 |
3 |
|||||||
|
Allocated CPU ids |
0 1 2 |
4 5 6 |
|||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task id |
0 |
2 |
4 |
- |
1 |
3 |
5 |
- |
|
Example 11: Consumable resources with task affinity and socket binding, Case 1
A job requires 6 CPUs (6 tasks with no overcommitment).
ジョブには6つのCPUが必要です（オーバーコミットなしの6つのタスク）。
Run the job in
a single node in the default partition.
デフォルトパーティションの単一ノードでジョブを実行します。
Apply socket binding to each task.
各タスクにソケットバインディングを適用します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --nodes=1-1 --ntasks=6 --cpu-bind=sockets ...
Comments:
Using the default allocation method within nodes (cyclic), Slurm allocates 3
CPUs on each socket of 1 node.
Slurmは、ノード内のデフォルトの割り当て方法（循環）を使用して、1つのノードの各ソケットに3つのCPUを割り当てます。
Using the default distribution method within nodes
(cyclic), Slurm distributes and binds each task to all of the allocated CPUs in
one socket in a round-robin fashion across the sockets.
Slurmは、ノード内のデフォルトの分散方法（循環）を使用して、各タスクを1つのソケット内の割り当てられたすべてのCPUに、ソケット間でラウンドロビン方式で分散およびバインドします。
The following table shows
a possible pattern of allocation, distribution and binding for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
For
example, task ids 1, 3 and 5 are all bound to CPU ids 4, 5 and 6.
たとえば、タスクID 1、3、および5はすべてCPU ID 4、5、および6にバインドされています。
|
Nodename |
n0 |
||||||||
|
Socket id |
0 |
1 |
|||||||
|
Number of Allocated CPUs |
3 |
3 |
|||||||
|
Allocated CPU ids |
0 1 2 |
4 5 6 |
|||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task ids |
0 2 4 |
- |
1 3 5 |
- |
|||||
Example 12: Consumable resources with task affinity and socket binding, Case 2
A job requires 6 CPUs (2 tasks with 3 cpus per task and no overcommitment).
ジョブには6つのCPUが必要です（タスクごとに3つのCPUを備えた2つのタスクで、オーバーコミットはありません）。
Run the job in
a single node in the default partition.
デフォルトパーティションの単一ノードでジョブを実行します。
Allocate cores using the block allocation method.
ブロック割り当て方法を使用してコアを割り当てます。
Distribute cores using the block distribution method.
ブロック分散方式を使用してコアを分散します。
Apply socket binding to each task.
各タスクにソケットバインディングを適用します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core,CR_CORE_DEFAULT_DIST_BLOCK TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --nodes=1-1 --ntasks=2 --cpus-per-task=3 --cpu-bind=sockets
--distribution=block:block ...
Comments:
Using the block allocation method, Slurm allocates 4
CPUs on one socket and 2 CPUs on the other socket of one node.
Slurmは、ブロック割り当て方式を使用して、1つのノードの一方のソケットに4つのCPUを割り当て、もう一方のソケットに2つのCPUを割り当てます。
Using the block distribution method within
nodes, Slurm distributes 3 CPUs to each task.
Slurmは、ノード内でブロック分散方式を使用して、各タスクに3つのCPUを分散します。
Applying socket binding, Slurm binds each task to all
allocated CPUs in all sockets in which the task has a distributed CPU.
ソケットバインディングを適用すると、Slurmは、タスクが分散CPUを備えているすべてのソケットに割り当てられているすべてのCPUに各タスクをバインドします。
The following table shows
a possible pattern of allocation, distribution and binding for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
In this example, using the
block allocation method CPU ids 0-3 are allocated on socket id 0 and CPU ids 4-5 are allocated on
socket id 1.
この例では、ブロック割り当て方法を使用して、CPU ID 0〜3がソケットID 0に割り当てられ、CPU ID 4〜5がソケットID1に割り当てられます。
Using the block distribution method, CPU ids 0-2 were distributed to task id 0, and CPU ids
3-5 were distributed to task id 1.
ブロック配布方法を使用して、CPU ID 0〜2がタスクID 0に配布され、CPU ID 3〜5がタスクID1に配布されました。
Applying socket binding, task id 0 is therefore bound to the allocated
CPUs on socket 0, and task id 1 is bound to the allocated CPUs on both sockets.
したがって、ソケットバインディングを適用すると、タスクID 0はソケット0に割り当てられたCPUにバインドされ、タスクID1は両方のソケットに割り当てられたCPUにバインドされます。
|
Nodename |
n0 |
||||||||
|
Socket id |
0 |
1 |
|||||||
|
Number of Allocated CPUs |
4 |
2 |
|||||||
|
Allocated CPU ids |
0 1 2 3 |
4 5 |
|||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task ids |
0 1 |
1 |
- |
||||||
Example 13: Consumable resources with task affinity and socket binding, Case 3
A job requires 6 CPUs (2 tasks with 3 cpus per task and no overcommitment).
ジョブには6つのCPUが必要です（タスクごとに3つのCPUを備えた2つのタスクで、オーバーコミットはありません）。
Run the job in
a single node in the default partition.
デフォルトパーティションの単一ノードでジョブを実行します。
Allocate cores using the block allocation method.
ブロック割り当て方法を使用してコアを割り当てます。
Distribute cores using the cyclic distribution method.
循環分散方式を使用してコアを分散します。
Apply socket binding to each task.
各タスクにソケットバインディングを適用します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core,CR_CORE_DEFAULT_DIST_BLOCK TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --nodes=1-1 --ntasks=2 --cpus-per-task=3 --cpu-bind=sockets
--distribution=block:cyclic ...
Comments:
Using the block allocation method, Slurm allocates 4
CPUs on one socket and 2 CPUs on the other socket of one node.
Slurmは、ブロック割り当て方式を使用して、1つのノードの一方のソケットに4つのCPUを割り当て、もう一方のソケットに2つのCPUを割り当てます。
Using the cyclic distribution method within
nodes, Slurm distributes 3 CPUs to each task.
Slurmは、ノード内で循環分散方式を使用して、各タスクに3つのCPUを分散します。
Applying socket binding, Slurm binds each task to all
allocated CPUs in all sockets in which the task has a distributed CPU.
ソケットバインディングを適用すると、Slurmは、タスクが分散CPUを備えているすべてのソケットに割り当てられているすべてのCPUに各タスクをバインドします。
The following table shows
a possible pattern of allocation, distribution and binding for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
In this example, using the
block allocation method CPU ids 0-3 are allocated on socket id 0 and CPU ids 4-5 are allocated on
socket id 1.
この例では、ブロック割り当て方法を使用して、CPU ID 0〜3がソケットID 0に割り当てられ、CPU ID 4〜5がソケットID1に割り当てられます。
Using the cyclic distribution method, CPU ids 0, 1 and 4 were distributed to task id 0, and CPU ids
2, 3 and 5 were distributed to task id 1.
循環配布方式を使用して、CPU ID 0、1、および4がタスクID 0に配布され、CPU ID 2、3、および5がタスクID1に配布されました。
Applying socket binding, both tasks are therefore bound to the
allocated CPUs on both sockets.
したがって、ソケットバインディングを適用すると、両方のタスクが両方のソケットに割り当てられたCPUにバインドされます。
|
Nodename |
n0 |
||||||||
|
Socket id |
0 |
1 |
|||||||
|
Number of Allocated CPUs |
4 |
2 |
|||||||
|
Allocated CPU ids |
0 1 2 3 |
4 5 |
|||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task ids |
0 1 |
0 1 |
- |
||||||
Example 14: Consumable resources with task affinity and customized allocation and distribution
A job requires 18 CPUs (18 tasks with no overcommitment).
ジョブには18個のCPUが必要です（オーバーコミットなしの18個のタスク）。
Run the job in the
default partition.
デフォルトのパーティションでジョブを実行します。
Allocate 6 CPUs on each node using block allocation within
nodes.
ノード内のブロック割り当てを使用して、各ノードに6つのCPUを割り当てます。
Use cyclic distribution of tasks to nodes and block distribution of
tasks for CPU binding.
ノードへのタスクの循環分散を使用し、CPUバインディングのためにタスクの分散をブロックします。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core,CR_CORE_DEFAULT_DIST_BLOCK TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --nodes=3-3 --ntasks=18 --ntasks-per-node=6
--distribution=cyclic:block --cpu-bind=cores ...
Comments:
This example shows the use of task affinity with customized allocation of CPUs and
distribution of tasks across nodes and within nodes for binding.
この例は、CPUのカスタマイズされた割り当てと、バインドのためのノード間およびノード内でのタスクの分散によるタスクアフィニティの使用を示しています。
The srun options
specify the following conditions for the job: 18 tasks, 1 unique CPU per task, using
all 3 nodes in the partition, with 6 tasks per node.
srunオプションは、ジョブに次の条件を指定します。18タスク、タスクごとに1つの一意のCPU、パーティション内の3つのノードすべてを使用、ノードごとに6つのタスク。
The CR_CORE_DEFAULT_DIST_BLOCK
configuration option specifies block allocation within nodes.
CR_CORE_DEFAULT_DIST_BLOCK構成オプションは、ノード内のブロック割り当てを指定します。
To satisfy these
conditions, Slurm allocates 6 CPUs on each node, with 4 CPUs allocated on one socket
and 2 CPUs on the other socket.
これらの条件を満たすために、Slurmは各ノードに6個のCPUを割り当て、一方のソケットに4個のCPUを割り当て、もう一方のソケットに2個のCPUを割り当てます。
The
--distribution=cyclic:block option specifies cyclic distribution of
tasks to nodes and block distribution of tasks to CPUs within nodes for binding.
--distribution = cyclic：blockオプションは、ノードへのタスクの循環分散と、バインドのためのノード内のCPUへのタスクのブロック分散を指定します。
The following table shows a possible pattern of allocation, distribution and binding
for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
For example, task id 10 is bound to CPU id 3 on node n1.
たとえば、タスクID10はノードn1のCPUID3にバインドされています。
|
Nodename |
n0 |
n1 |
n2 |
||||||||||||||||||||||
|
Socket id |
0 |
1 |
0 |
1 |
0 |
1 |
|||||||||||||||||||
|
Number of Allocated CPUs |
4 |
2 |
4 |
2 |
4 |
2 |
|||||||||||||||||||
|
Allocated CPU ids |
0 1 2 3 4 5 |
0 1 2 3 4 5 |
0 1 2 3 4 5 |
||||||||||||||||||||||
|
Number of Tasks |
6 |
6 |
6 |
||||||||||||||||||||||
|
Distribution of Tasks to Nodes, by Task id |
0 |
1 |
2 |
||||||||||||||||||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task id |
0 |
3 |
6 |
9 |
12 |
15 |
- |
- |
1 |
4 |
7 |
10 |
13 |
16 |
- |
- |
2 |
5 |
8 |
11 |
14 |
17 |
- |
- |
|
Example 15: Consumable resources with task affinity to optimize the performance of a multi-task, multi-thread job
A job requires 9 CPUs (3 tasks and 3 CPUs per task with no overcommitment).
ジョブには9個のCPUが必要です（オーバーコミットなしで、タスクごとに3個のタスクと3個のCPU）。
Run
the job in the default partition, managing the CPUs to optimize the performance
of the job.
デフォルトのパーティションでジョブを実行し、CPUを管理してジョブのパフォーマンスを最適化します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core,CR_CORE_DEFAULT_DIST_BLOCK TaskPlugin=task/affinity TaskPluginParam=sched
Command line:
srun --ntasks=3 --cpus-per-task=3 --ntasks-per-node=1 --cpu-bind=cores ...
Comments:
To optimize the performance of this job, the user wishes to allocate 3 CPUs from each of
3 sockets and bind each task to the 3 CPUs in a single socket.
このジョブのパフォーマンスを最適化するために、ユーザーは3つのソケットのそれぞれから3つのCPUを割り当て、各タスクを1つのソケットの3つのCPUにバインドしたいと考えています。
The
SelectTypeParameters configuration option specifies
a consumable resource type of cores and block allocation within nodes.
SelectTypeParameters構成オプションは、コアの消費可能なリソースタイプと、ノード内のブロック割り当てを指定します。
The
TaskPlugin
and TaskPluginParam
configuration options enable task affinity.
TaskPluginおよびTaskPluginParam構成オプションは、タスクアフィニティを有効にします。
The srun options specify the following
conditions for the job: 3 tasks, with 3 unique CPUs per task, with 1 task per node.
srunオプションは、ジョブに次の条件を指定します。3つのタスク、タスクごとに3つの一意のCPU、ノードごとに1つのタスク。
To satisfy
these conditions, Slurm allocates 3 CPUs from one socket in each of the 3 nodes in the default partition.
これらの条件を満たすために、Slurmはデフォルトパーティションの3つのノードのそれぞれにある1つのソケットから3つのCPUを割り当てます。
The
--cpu-bind=cores option causes Slurm to bind
each task to the 3 allocated CPUs on the node to which it is distributed.
--cpu-bind = coresオプションを使用すると、Slurmは、各タスクを、それが分散されているノードに割り当てられた3つのCPUにバインドします。
The
following table shows a possible pattern of allocation, distribution and binding
for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
For example, task id 2 is bound to CPU ids 0, 1 and 2 on socket id 0 of node n2.
たとえば、タスクID 2は、ノードn2のソケットID 0のCPU ID 0、1、および2にバインドされています。
|
Nodename |
n0 |
n1 |
n2 |
||||||||||||||||||||||
|
Socket id |
0 |
1 |
0 |
1 |
0 |
1 |
|||||||||||||||||||
|
Number of Allocated CPUs |
3 |
0 |
3 |
0 |
3 |
0 |
|||||||||||||||||||
|
Allocated CPU ids |
0 1 2 |
0 1 2 |
0 1 2 |
||||||||||||||||||||||
|
Number of Tasks |
1 |
1 |
1 |
||||||||||||||||||||||
|
Distribution of Tasks to Nodes, by Task id |
0 |
1 |
2 |
||||||||||||||||||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task id |
0 |
- |
1 |
- |
2 |
-- |
|||||||||||||||||||
Example 16: Consumable resources with task cgroup and core binding
A job requires 6 CPUs (6 tasks with no overcommitment).
ジョブには6つのCPUが必要です（オーバーコミットなしの6つのタスク）。
Run the job in a
single node in the default partition.
デフォルトパーティションの単一ノードでジョブを実行します。
Apply core binding to each task using the task/cgroup plugin.
task / cgroupプラグインを使用して、各タスクにコアバインディングを適用します。
slurm.conf options:
SelectType=select/cons_res SelectTypeParameters=CR_Core TaskPlugin=task/cgroup
cgroup.conf options:
ConstrainCores=yes TaskAffinity=yes
Command line:
srun --nodes=1-1 --ntasks=6 --cpu-bind=cores ...
Comments:
The task/cgroup plugin currently supports only the block method for
allocating cores within nodes and distributing tasks to CPUs for binding.
task / cgroupプラグインは現在、ノード内でコアを割り当て、バインドのためにタスクをCPUに分散するためのblockメソッドのみをサポートしています。
The following table shows a possible pattern of allocation, distribution
and binding for this job.
次の表は、このジョブの割り当て、配布、およびバインドの可能なパターンを示しています。
For example, task id 2 is bound to CPU id 2.
たとえば、タスクID2はCPUID2にバインドされています。
|
Nodename |
n0 |
||||||||
|
Socket id |
0 |
1 |
|||||||
|
Number of Allocated CPUs |
4 |
2 |
|||||||
|
Allocated CPU ids |
0 1 2 3 |
4 5 |
|||||||
|
Binding of Tasks to CPUs |
CPU id |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Task id |
0 |
1 |
2 |
3 |
4 |
5 |
- |
- |
|
Last modified 9 October 2019