Executar tarefas simultaneamente para maximizar o uso de nó de computação batchRun tasks concurrently to maximize usage of Batch compute nodes

Pode maximizar o uso de recursos num número menor de nós de computação na sua piscina executando mais do que uma tarefa simultaneamente em cada nó.You can maximize resource usage on a smaller number of compute nodes in your pool by running more than one task simultaneously on each node.

Embora alguns cenários funcionem melhor com todos os recursos de um nó dedicados a uma única tarefa, certas cargas de trabalho podem ver tempos de trabalho mais curtos e custos mais baixos quando várias tarefas partilham esses recursos.While some scenarios work best with all of a node's resources dedicated to a single task, certain workloads may see shorter job times and lower costs when multiple tasks share those resources. Pondere os seguintes cenários:Consider the following scenarios:

  • Minimizar a transferência de dados para tarefas que sejam capazes de partilhar dados.Minimize data transfer for tasks that are able to share data. Pode reduzir drasticamente os encargos de transferência de dados copiando dados partilhados para um número menor de nós e executando tarefas paralelamente em cada nó.You can dramatically reduce data transfer charges by copying shared data to a smaller number of nodes, then executing tasks in parallel on each node. Isto aplica-se especialmente se os dados a copiar para cada nó tão devem ser transferidos entre regiões geográficas.This especially applies if the data to be copied to each node must be transferred between geographic regions.
  • Maximize o uso da memória para tarefas que requerem uma grande quantidade de memória, mas apenas durante curtos períodos de tempo, e em tempos variáveis durante a execução.Maximize memory usage for tasks which require a large amount of memory, but only during short periods of time, and at variable times during execution. Pode empregar menos, mas maiores, nós computacional com mais memória para lidar eficientemente com esses picos.You can employ fewer, but larger, compute nodes with more memory to efficiently handle such spikes. Estes nós terão múltiplas tarefas em paralelo em cada nó, mas cada tarefa pode tirar partido da memória abundante dos nós em diferentes momentos.These nodes will have multiple tasks running in parallel on each node, but each task can take advantage of the nodes' plentiful memory at different times.
  • Atenuar os limites do número do nó quando for necessária uma comunicação inter-node dentro de uma piscina.Mitigate node number limits when inter-node communication is required within a pool. Atualmente, as piscinas configuradas para a comunicação entre nós estão limitadas a 50 nós computacional.Currently, pools configured for inter-node communication are limited to 50 compute nodes. Se cada nó em tal piscina for capaz de executar tarefas em paralelo, um maior número de tarefas pode ser executado simultaneamente.If each node in such a pool is able to execute tasks in parallel, a greater number of tasks can be executed simultaneously.
  • Replique um cluster compute no local, como quando move um ambiente computacional para Azure.Replicate an on-premises compute cluster, such as when you first move a compute environment to Azure. Se a sua solução atual no local executar múltiplas tarefas por nó de computação, pode aumentar o número máximo de tarefas de nó para espelhar mais de perto essa configuração.If your current on-premises solution executes multiple tasks per compute node, you can increase the maximum number of node tasks to more closely mirror that configuration.

Cenário de exemploExample scenario

Como exemplo, imagine uma aplicação de tarefa com CPU e requisitos de memória de modo a que os nós _ Standard D1 sejam suficientes.As an example, imagine a task application with CPU and memory requirements such that Standard_D1 nodes are sufficient. No entanto, para terminar o trabalho no tempo necessário, são necessários 1.000 destes nós.However, in order to finish the job in the required time, 1,000 of these nodes are needed.

Em vez de utilizar _ nós Standard D1 que tenham 1 núcleo CPU, pode utilizar nós Standard _ D14 que têm 16 núcleos cada, e permitir a execução paralela da tarefa.Instead of using Standard_D1 nodes that have 1 CPU core, you could use Standard_D14 nodes that have 16 cores each, and enable parallel task execution. Isto significa que 16 vezes menos nós poderiam ser usados -- em vez de 1.000 nós, apenas 63 seriam necessários.This means that 16 times fewer nodes could be used--instead of 1,000 nodes, only 63 would be required. Se forem necessários ficheiros de aplicações grandes ou dados de referência para cada nó, a duração e eficiência do trabalho são melhoradas, uma vez que os dados são copiados para apenas 63 nós.If large application files or reference data are required for each node, job duration and efficiency are improved, since the data is copied to only 63 nodes.

Permitir a execução paralela de tarefasEnable parallel task execution

Configura os nós computacional para execução paralela de tarefas ao nível da piscina.You configure compute nodes for parallel task execution at the pool level. Com a biblioteca Batch .NET, deslove a propriedade CloudPool.TaskSlotsPerNode quando criar uma piscina.With the Batch .NET library, set the CloudPool.TaskSlotsPerNode property when you create a pool. Se estiver a utilizar a API de Lote REST, desloque as tarefasSlotsPerNode elemento no corpo de pedido durante a criação da piscina.If you're using the Batch REST API, set the taskSlotsPerNode element in the request body during pool creation.

Nota

Você pode definir o taskSlotsPerNode elemento e a propriedade TaskSlotsPerNode apenas no tempo de criação da piscina.You can set the taskSlotsPerNode element and TaskSlotsPerNode property only at pool creation time. Não podem ser modificados depois de uma piscina já ter sido criada.They can't be modified after a pool has already been created.

O Azure Batch permite-lhe definir ranhuras de tarefa por nó até (4x) o número de núcleos de nó.Azure Batch allows you to set task slots per node up to (4x) the number of node cores. Por exemplo, se a piscina estiver configurada com nós de tamanho "Grande" (quatro núcleos), taskSlotsPerNode pode ser configurado para 16.For example, if the pool is configured with nodes of size "Large" (four cores), then taskSlotsPerNode may be set to 16. No entanto, independentemente de quantos núcleos o nó tem, não pode ter mais de 256 slots de tarefas por nó.However, regardless of how many cores the node has, you can't have more than 256 task slots per node. Para obter detalhes sobre o número de núcleos para cada um dos tamanhos dos nós, consulte tamanhos para serviços cloud.For details on the number of cores for each of the node sizes, see Sizes for Cloud Services. Para obter mais informações sobre os limites de serviço, consulte quotas e limites para o serviço Azure Batch.For more information on service limits, see Quotas and limits for the Azure Batch service.

Dica

Tenha em conta o taskSlotsPerNode valor quando constrói uma fórmula de autoescala para a sua piscina.Be sure to take into account the taskSlotsPerNode value when you construct an autoscale formula for your pool. Por exemplo, uma fórmula que avalia $RunningTasks pode ser drasticamente afetada pelo aumento das tarefas por nó.For example, a formula that evaluates $RunningTasks could be dramatically affected by an increase in tasks per node. Para obter mais informações, consulte os nós computacional de escala automática numa piscina Azure Batch.For more information, see Automatically scale compute nodes in an Azure Batch pool.

Especificar a distribuição de tarefasSpecify task distribution

Ao ativar tarefas simultâneas, é importante especificar como pretende que as tarefas sejam distribuídas pelos nós da piscina.When enabling concurrent tasks, it's important to specify how you want the tasks to be distributed across the nodes in the pool.

Ao utilizar a propriedade CloudPool.TaskSchedulingPolicy, pode especificar que as tarefas devem ser atribuídas uniformemente em todos os nós da piscina ("spreading").By using the CloudPool.TaskSchedulingPolicy property, you can specify that tasks should be assigned evenly across all nodes in the pool ("spreading"). Ou pode especificar que o maior número possível de tarefas deve ser atribuído a cada nó antes de as tarefas serem atribuídas a outro nó na piscina ("embalagem").Or you can specify that as many tasks as possible should be assigned to each node before tasks are assigned to another node in the pool ("packing").

Como exemplo, considere o pool de nós _ Standard D14 (no exemplo acima) que está configurado com um valor CloudPool.TaskSlotsPerNode de 16.As an example, consider the pool of Standard_D14 nodes (in the example above) that is configured with a CloudPool.TaskSlotsPerNode value of 16. Se o CloudPool.TaskSchedulingPolicy estiver configurado com um ComputeNodeFillType de Pack, maximizaria a utilização de todos os 16 núcleos de cada nó e permitiria que uma piscina auto-caling removesse nós não usados (nós sem quaisquer tarefas atribuídas) da piscina.If the CloudPool.TaskSchedulingPolicy is configured with a ComputeNodeFillType of Pack, it would maximize usage of all 16 cores of each node and allow an autoscaling pool to remove unused nodes (nodes without any tasks assigned) from the pool. Isto minimiza o uso de recursos e poupa dinheiro.This minimizes resource usage and saves money.

Definir faixas variáveis por tarefaDefine variable slots per task

Uma tarefa pode ser definida com a propriedade CloudTask.RequiredSlots, especificando quantas faixas horárias necessita para ser executada num nó de computação.A task can be defined with CloudTask.RequiredSlots property, specifying how many slots it requires to run on a compute node. O valor predefinido é 1.The default value is 1. Pode definir slots de tarefas variáveis se as suas tarefas tiverem diferentes pesos no que diz respeito à utilização de recursos no nó de computação.You can set variable task slots if your tasks have different weights regarding to resource usage on the compute node. Isto permite que cada nó de cálculo tenha um número razoável de tarefas de execução simultâneas sem sobrecarregar recursos do sistema como CPU ou memória.This lets each compute node have a reasonable number of concurrent running tasks without overwhelming system resources like CPU or memory.

Por exemplo, para uma piscina com taskSlotsPerNode = 8 propriedade, pode submeter tarefas intensivas de CPU multi-core requiredSlots = 8 com, enquanto outras tarefas podem ser definidas para requiredSlots = 1 .For example, for a pool with property taskSlotsPerNode = 8, you can submit multi-core required CPU-intensive tasks with requiredSlots = 8, while other tasks can be set to requiredSlots = 1. Quando esta carga de trabalho mista é programada, as tarefas intensivas do CPU serão executadas exclusivamente nos seus nós de computação, enquanto outras tarefas podem ser executadas simultaneamente (até oito tarefas ao mesmo tempo) em outros nós.When this mixed workload is scheduled, the CPU-intensive tasks will run exclusively on their compute nodes, while other tasks can run concurrently (up to eight tasks at once) on other nodes. Isto ajuda-o a equilibrar a sua carga de trabalho através dos nós de cálculo e a melhorar a eficiência de utilização dos recursos.This helps you balance your workload across compute nodes and improve resource usage efficiency.

Certifique-se de que não especifica que uma tarefa requiredSlots é maior do que a da taskSlotsPerNode piscina.Be sure you don't specify a task's requiredSlots to be greater than the pool's taskSlotsPerNode. Isto resultará em que a tarefa nunca seja capaz de executar.This will result in the task never being able to run. O Serviço de Lote não valida atualmente este conflito quando submete tarefas porque um trabalho pode não ter uma piscina ligada à hora de submissão, ou pode ser alterado para um pool diferente, desativando/re-habilitando.The Batch Service doesn't currently validate this conflict when you submit tasks because a job may not have a pool bound at submission time, or it could be changed to a different pool by disabling/re-enabling.

Dica

Ao utilizar slots de tarefas variáveis, é possível que grandes tarefas com slots mais necessárias possam falhar temporariamente, porque não há slots suficientes em qualquer nó de computação, mesmo quando ainda há slots inativos em alguns nós.When using variable task slots, it's possible that large tasks with more required slots can temporarily fail to be scheduled because not enough slots are available on any compute node, even when there are still idle slots on some nodes. Pode aumentar a prioridade de emprego para estas tarefas para aumentar a sua possibilidade de competir por vagas disponíveis em nós.You can raise the job priority for these tasks to increase their chance to compete for available slots on nodes.

O serviço Batch emite o TaskScheduleFailEvent quando não agenda uma tarefa a executar, e continua a executar o agendamento até que as faixas horárias necessárias estejam disponíveis.The Batch service emits the TaskScheduleFailEvent when it fails to schedule a task to run, and keeps retrying the scheduling until required slots become available. Pode ouvir esse evento para detetar potenciais problemas de agendamento de tarefas e mitigar em conformidade.You can listen to that event to detect potential task scheduling issues and mitigate accordingly.

Exemplo lote .NETBatch .NET example

Os seguintes snippets de código API do Batch .NET mostram como criar um pool com múltiplas ranhuras de tarefa por nó e como submeter uma tarefa com as ranhuras necessárias.The following Batch .NET API code snippets show how to create a pool with multiple task slots per node and how to submit a task with required slots.

Criar uma piscina com múltiplas ranhuras de tarefa por nóCreate a pool with multiple task slots per node

Este código de corte mostra um pedido para criar uma piscina que contém quatro nós, com quatro ranhuras de tarefa permitidas por nó.This code snippet shows a request to create a pool that contains four nodes, with four task slots allowed per node. Especifica uma política de agendamento de tarefas que preencherá cada nó com tarefas antes de atribuir tarefas a outro nó na piscina.It specifies a task scheduling policy that will fill each node with tasks prior to assigning tasks to another node in the pool.

Para obter mais informações sobre a adição de piscinas utilizando o Lote .NET API, consulte BatchClient.PoolOperations.CreatePool.For more information on adding pools by using the Batch .NET API, see BatchClient.PoolOperations.CreatePool.

CloudPool pool =
    batchClient.PoolOperations.CreatePool(
        poolId: "mypool",
        targetDedicatedComputeNodes: 4
        virtualMachineSize: "standard_d1_v2",
        cloudServiceConfiguration: new CloudServiceConfiguration(osFamily: "5"));

pool.TaskSlotsPerNode = 4;
pool.TaskSchedulingPolicy = new TaskSchedulingPolicy(ComputeNodeFillType.Pack);
pool.Commit();

Criar uma tarefa com slots necessáriosCreate a task with required slots

Este corte de código cria uma tarefa com o não-padrão requiredSlots .This code snippet creates a task with non-default requiredSlots. Esta tarefa só será executada quando houver slots gratuitos suficientes disponíveis num nó de computação.This task will only run when there are enough free slots available on a compute node.

CloudTask task = new CloudTask(taskId, taskCommandLine)
{
    RequiredSlots = 2
};

Listam os nó de computação com contagens para executar tarefas e slotsList compute nodes with counts for running tasks and slots

Este código de snippet lista todos os nós de computação na piscina, e imprime as contagens para executar tarefas e slots de tarefas por nó.This code snippet lists all compute nodes in the pool, and prints out the counts for running tasks and task slots per node.

ODATADetailLevel nodeDetail = new ODATADetailLevel(selectClause: "id,runningTasksCount,runningTaskSlotsCount");
IPagedEnumerable<ComputeNode> nodes = batchClient.PoolOperations.ListComputeNodes(poolId, nodeDetail);

await nodes.ForEachAsync(node =>
{
    Console.WriteLine(node.Id + " :");
    Console.WriteLine($"RunningTasks = {node.RunningTasksCount}, RunningTaskSlots = {node.RunningTaskSlotsCount}");

}).ConfigureAwait(continueOnCapturedContext: false);

A lista conta para o trabalhoList task counts for the job

Este código de corte obtém contagens de tarefas para o trabalho, que inclui tanto tarefas como slots de tarefas contando por estado de tarefa.This code snippet gets task counts for the job, which includes both tasks and task slots count per task state.

TaskCountsResult result = await batchClient.JobOperations.GetJobTaskCountsAsync(jobId);

Console.WriteLine("\t\tActive\tRunning\tCompleted");
Console.WriteLine($"TaskCounts:\t{result.TaskCounts.Active}\t{result.TaskCounts.Running}\t{result.TaskCounts.Completed}");
Console.WriteLine($"TaskSlotCounts:\t{result.TaskSlotCounts.Active}\t{result.TaskSlotCounts.Running}\t{result.TaskSlotCounts.Completed}");

Exemplo de lote RESTBatch REST example

Os seguintes snippets de código API do Lote REST mostram como criar um pool com múltiplas ranhuras de tarefa por nó e como submeter uma tarefa com as ranhuras necessárias.The following Batch REST API code snippets show how to create a pool with multiple task slots per node and how to submit a task with required slots.

Criar uma piscina com múltiplas ranhuras de tarefa por nóCreate a pool with multiple task slots per node

Este corte mostra um pedido para criar uma piscina que contém dois nós grandes com um máximo de quatro tarefas por nó.This snippet shows a request to create a pool that contains two large nodes with a maximum of four tasks per node.

Para obter mais informações sobre a adição de piscinas utilizando a API REST, consulte adicionar uma piscina a uma conta.For more information on adding pools by using the REST API, see Add a pool to an account.

{
  "odata.metadata":"https://myaccount.myregion.batch.azure.com/$metadata#pools/@Element",
  "id":"mypool",
  "vmSize":"large",
  "cloudServiceConfiguration": {
    "osFamily":"4",
    "targetOSVersion":"*",
  },
  "targetDedicatedComputeNodes":2,
  "taskSlotsPerNode":4,
  "enableInterNodeCommunication":true,
}

Criar uma tarefa com slots necessáriosCreate a task with required slots

Este corte mostra um pedido para adicionar uma tarefa com não-padrão requiredSlots .This snippet shows a request to add a task with non-default requiredSlots. Esta tarefa só será executada quando houver slots gratuitos suficientes disponíveis no nó de computação.This task will only run when there are enough free slots available on the compute node.

{
  "id": "taskId",
  "commandLine": "bash -c 'echo hello'",
  "userIdentity": {
    "autoUser": {
      "scope": "task",
      "elevationLevel": "nonadmin"
    }
  },
  "requiredSLots": 2
}

Amostra de código no GitHubCode sample on GitHub

O projeto ParallelTasks no GitHub ilustra a utilização da propriedade CloudPool.TaskSlotsPerNode.The ParallelTasks project on GitHub illustrates the use of the CloudPool.TaskSlotsPerNode property.

Esta aplicação de consola C# utiliza a biblioteca Batch .NET para criar uma piscina com um ou mais nós de computação.This C# console application uses the Batch .NET library to create a pool with one or more compute nodes. Executa um número configurável de tarefas nesses nós para simular uma carga variável.It executes a configurable number of tasks on those nodes to simulate a variable load. A saída da aplicação mostra quais os nós executados em cada tarefa.Output from the application shows which nodes executed each task. A aplicação também fornece um resumo dos parâmetros e duração do trabalho.The application also provides a summary of the job parameters and duration.

Como exemplo, abaixo está a parte sumária da saída de dois percursos diferentes da aplicação da amostra ParallelTasks.As an example, below is the summary portion of the output from two different runs of the ParallelTasks sample application. As durações do trabalho mostradas aqui não incluem o tempo de criação de piscina, uma vez que cada trabalho foi submetido a um pool previamente criado cujos nós computativos estavam no estado de Idle na hora de submissão.Job durations shown here don't include pool creation time, since each job was submitted to a previously created pool whose compute nodes were in the Idle state at submission time.

A primeira execução da aplicação da amostra mostra que com um único nó na piscina e a definição padrão de uma tarefa por nó, a duração do trabalho é superior a 30 minutos.The first execution of the sample application shows that with a single node in the pool and the default setting of one task per node, the job duration is over 30 minutes.

Nodes: 1
Node size: large
Task slots per node: 1
Max slots per task: 1
Tasks: 32
Duration: 00:30:01.4638023

A segunda parte da amostra revela uma diminuição significativa da duração do trabalho.The second run of the sample shows a significant decrease in job duration. Isto porque a piscina foi configurada com quatro tarefas por nó, permitindo que a execução paralela da tarefa completasse o trabalho em quase um quarto do tempo.This is because the pool was configured with four tasks per node, allowing for parallel task execution to complete the job in nearly a quarter of the time.

Nodes: 1
Node size: large
Task slots per node: 4
Max slots per task: 1
Tasks: 32
Duration: 00:08:48.2423500

Passos seguintesNext steps