Taken gelijktijdig uitvoeren om het gebruik van Batch-rekenknooppunten te maximaliseren

U kunt het resourcegebruik op een kleiner aantal rekenknooppunten in uw pool maximaliseren door meer dan één taak tegelijkertijd op elk knooppunt uit te voeren.

Hoewel sommige scenario's het beste werken met alle resources van een knooppunt die zijn toegewezen aan één taak, kunnen bepaalde workloads kortere taaktijden en lagere kosten ervaren wanneer meerdere taken deze resources delen. Denk eens na over de volgende scenario's:

  • Minimaliseer de gegevensoverdracht voor taken die gegevens kunnen delen. U kunt de kosten voor gegevensoverdracht aanzienlijk verlagen door gedeelde gegevens naar een kleiner aantal knooppunten te kopiëren en vervolgens taken parallel op elk knooppunt uit te voeren. Dit geldt met name als de gegevens die naar elk knooppunt moeten worden gekopieerd, moeten worden overgedragen tussen geografische regio's.
  • Maximaliseer het geheugengebruik voor taken waarvoor een grote hoeveelheid geheugen nodig is, maar alleen tijdens korte perioden en op variabele tijden tijdens de uitvoering. U kunt minder, maar grotere rekenknooppunten met meer geheugen gebruiken om dergelijke pieken efficiënt te verwerken. Op deze knooppunten worden meerdere taken parallel uitgevoerd op elk knooppunt, maar elke taak kan op verschillende tijdstippen profiteren van het geheugen van de knooppunten.
  • Verminder de limieten voor knooppuntaantal wanneer communicatie tussen knooppunts in een pool is vereist. Momenteel zijn pools die zijn geconfigureerd voor communicatie tussen knooppunten beperkt tot 50 rekenknooppunten. Als elk knooppunt in een dergelijke pool taken parallel kan uitvoeren, kan een groter aantal taken tegelijkertijd worden uitgevoerd.
  • Repliceer een on-premises rekencluster, bijvoorbeeld wanneer u een rekenomgeving voor het eerst naar Azure verplaatst. Als uw huidige on-premises oplossing meerdere taken per rekenpunt uitvoert, kunt u het maximum aantal knooppunttaken verhogen om die configuratie beter te spiegelen.

Voorbeeldscenario

Stel u bijvoorbeeld een taaktoepassing voor met CPU- en geheugenvereisten, zodat Standard _ D1-knooppunten voldoende zijn. Als u de taak echter binnen de vereiste tijd wilt voltooien, zijn er 1000 van deze knooppunten nodig.

In plaats van Standard _ D1-knooppunten met 1 CPU-kern te gebruiken, kunt u Standard _ D14-knooppunten met elk 16 kernen gebruiken en parallelle taakuitvoering inschakelen. Dit betekent dat er 16 keer minder knooppunten kunnen worden gebruikt: in plaats van 1000 knooppunten zijn er slechts 63 vereist. Als er grote toepassingsbestanden of referentiegegevens vereist zijn voor elk knooppunt, worden de duur en efficiëntie van de taak verbeterd, omdat de gegevens naar slechts 63 knooppunten worden gekopieerd.

Parallelle taakuitvoering inschakelen

U configureert rekenknooppunten voor parallelle taakuitvoering op poolniveau. Stel met de Batch .NET-bibliotheek de eigenschap CloudPool.TaskSlotsPerNode in wanneer u een pool maakt. Als u de Batch-REST API, stelt u het element taskSlotsPerNode in de aanvraag body in tijdens het maken van de pool.

Notitie

U kunt het taskSlotsPerNode element en de eigenschap TaskSlotsPerNode alleen instellen op het moment dat de pool wordt gemaakt. Ze kunnen niet worden gewijzigd nadat een pool al is gemaakt.

Azure Batch kunt u taaksleuven per knooppunt instellen tot (4x) het aantal knooppuntkernen. Als de pool bijvoorbeeld is geconfigureerd met knooppunten van grootte 'Groot' (vier kernen), kan taskSlotsPerNode worden ingesteld op 16. Ongeacht het aantal kernen dat het knooppunt heeft, kunt u echter niet meer dan 256 taaksleuven per knooppunt hebben. Zie Grootten voor Cloud Services voor meer informatie over het aantal kernen voor elk van de knooppuntgrootten. Zie Quota en limieten voor de Azure Batch service voor meer informatie over servicelimieten.

Tip

Zorg ervoor dat u rekening houdt met de taskSlotsPerNode waarde wanneer u een formule voor automatisch schalen voor uw pool maakt. Een formule die evalueert, kan bijvoorbeeld aanzienlijk worden beïnvloed door een $RunningTasks toename van het aantal taken per knooppunt. Zie Rekenknooppunten automatisch schalen in een Azure Batch-pool voor meer informatie.

Taakdistributie opgeven

Bij het inschakelen van gelijktijdige taken is het belangrijk om op te geven hoe de taken moeten worden verdeeld over de knooppunten in de pool.

Met behulp van de eigenschap CloudPool.TaskSchedulingPolicy kunt u opgeven dat taken gelijkmatig moeten worden toegewezen aan alle knooppunten in de pool ('verspreid'). U kunt ook opgeven dat zoveel mogelijk taken aan elk knooppunt moeten worden toegewezen voordat taken worden toegewezen aan een ander knooppunt in de pool ('verpakking').

Neem bijvoorbeeld de pool met Standard _ D14-knooppunten (in het bovenstaande voorbeeld) die is geconfigureerd met de waarde CloudPool.TaskSlotsPerNode van 16. Als CloudPool.TaskSchedulingPolicy is geconfigureerd met een ComputeNodeFillType van Pack, wordt het gebruik van alle 16 kernen van elk knooppunt gemaximaliseerd en kan een pool voor automatisch schalen ongebruikte knooppunten (knooppunten zonder toegewezen taken) uit de pool verwijderen. Dit minimaliseert het resourcegebruik en bespaart geld.

Variabele sleuven per taak definiëren

Een taak kan worden gedefinieerd met de eigenschap CloudTask.RequiredSlots, waarin wordt aangegeven hoeveel sleuven er moeten worden uitgevoerd op een reken knooppunt. De standaardwaarde is 1. U kunt variabele taaksleuven instellen als uw taken verschillende gewichten hebben met betrekking tot resourcegebruik op het reken knooppunt. Hierdoor kan elk reken knooppunt een redelijk aantal gelijktijdige taken uitvoeren zonder dat de systeembronnen, zoals CPU of geheugen, worden overstelpen.

Voor een pool met eigenschap kunt u bijvoorbeeld vereiste CPU-intensieve taken met meerdere kernen verzenden, terwijl andere taken taskSlotsPerNode = 8 kunnen worden ingesteld op requiredSlots = 8 requiredSlots = 1 . Wanneer deze gemengde workload is gepland, worden de CPU-intensieve taken uitsluitend uitgevoerd op hun rekenknooppunten, terwijl andere taken gelijktijdig (maximaal acht taken tegelijk) op andere knooppunten kunnen worden uitgevoerd. Dit helpt u om uw workload te verdelen over rekenknooppunten en de efficiëntie van resourcegebruik te verbeteren.

Zorg ervoor dat u niet opgeeft dat een taak groter is requiredSlots dan die van de taskSlotsPerNode pool. Hierdoor kan de taak nooit worden uitgevoerd. De Batch-service valideert dit conflict momenteel niet wanneer u taken indient, omdat een job mogelijk geen pool heeft die is gebonden tijdens het indienen, of kan worden gewijzigd in een andere pool door het uitschakelen/opnieuw inschakelen.

Tip

Wanneer u variabele taaksleuven gebruikt, is het mogelijk dat grote taken met meer vereiste sleuven tijdelijk niet kunnen worden gepland omdat er onvoldoende sleuven beschikbaar zijn op elk rekenknooppunt, zelfs wanneer er op sommige knooppunten nog steeds niet-actieve sleuven zijn. U kunt de jobprioriteit voor deze taken verhogen om de kans te vergroten om te concurreren om beschikbare sleuven op knooppunten.

De Batch-service stuurt de TaskScheduleFailEvent wanneer het niet lukt om een taak uit te voeren en blijft de planning opnieuw proberen totdat de vereiste sleuven beschikbaar zijn. U kunt naar die gebeurtenis luisteren om potentiële problemen met de taakplanning te detecteren en dienovereenkomstig te verhelpen.

Batch .NET-voorbeeld

De volgende Batch .NET API-codefragmenten laten zien hoe u een pool met meerdere taaksleuven per knooppunt maakt en hoe u een taak met de vereiste sleuven kunt verzenden.

Een pool met meerdere taaksleuven per knooppunt maken

Dit codefragment toont een aanvraag voor het maken van een pool die vier knooppunten bevat, met vier taaksleuven toegestaan per knooppunt. Er wordt een taakplanningsbeleid opgegeven dat elk knooppunt vult met taken voordat taken worden toegewezen aan een ander knooppunt in de pool.

Zie BatchClient.PoolOperations.CreatePoolvoor meer informatie over het toevoegen van pools met behulp van de Batch .NET-API.

CloudPool pool =
    batchClient.PoolOperations.CreatePool(
        poolId: "mypool",
        targetDedicatedComputeNodes: 4
        virtualMachineSize: "standard_d1_v2",
        VirtualMachineConfiguration: new VirtualMachineConfiguration(
            imageReference: new ImageReference(
                                publisher: "MicrosoftWindowsServer",
                                offer: "WindowsServer",
                                sku: "2019-datacenter-core",
                                version: "latest"),
            nodeAgentSkuId: "batch.node.windows amd64");

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

Een taak maken met de vereiste sleuven

Met dit codefragment maakt u een taak met niet-standaard requiredSlots . Deze taak wordt alleen uitgevoerd wanneer er voldoende vrije sleuven beschikbaar zijn op een reken knooppunt.

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

Rekenknooppunten met tellingen voor het uitvoeren van taken en sleuven

In dit codefragment worden alle rekenknooppunten in de pool vermeld en worden de tellingen voor het uitvoeren van taken en taaksleuven per knooppunt afgedrukt.

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);

Lijst met taaktellingen voor de taak

Met dit codefragment worden taaktellingen voor de job, die zowel taken als taaksleuven per taaktoestand omvatten.

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}");

Batch REST-voorbeeld

De volgende Batch REST API-codefragmenten laten zien hoe u een pool met meerdere taaksleuven per knooppunt maakt en hoe u een taak met de vereiste sleuven kunt verzenden.

Een pool met meerdere taaksleuven per knooppunt maken

Dit fragment toont een aanvraag voor het maken van een pool die twee grote knooppunten bevat met maximaal vier taken per knooppunt.

Zie Een pool toevoegen aan een account voor meer informatie REST API het toevoegen van pools met behulp van de REST API.

{
  "odata.metadata":"https://myaccount.myregion.batch.azure.com/$metadata#pools/@Element",
  "id":"mypool",
  "vmSize":"large",
  "virtualMachineConfiguration": {
    "imageReference": {
      "publisher": "canonical",
      "offer": "ubuntuserver",
      "sku": "18.04-lts"
    },
    "nodeAgentSKUId": "batch.node.ubuntu 16.04"
  },
  "targetDedicatedComputeNodes":2,
  "taskSlotsPerNode":4,
  "enableInterNodeCommunication":true,
}

Een taak maken met de vereiste sleuven

Dit fragment toont een aanvraag voor het toevoegen van een taak met niet-standaard requiredSlots . Deze taak wordt alleen uitgevoerd wanneer er voldoende vrije sleuven beschikbaar zijn op het reken-knooppunt.

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

Codevoorbeeld op GitHub

Het project ParallelTasks op GitHub illustreert het gebruik van de eigenschap CloudPool.TaskSlotsPerNode.

Deze C#-consoletoepassing maakt gebruik van de Batch .NET-bibliotheek om een pool met een of meer rekenknooppunten te maken. Er wordt een configureerbaar aantal taken op deze knooppunten uitgevoerd om een variabele belasting te simuleren. Uitvoer van de toepassing toont welke knooppunten elke taak hebben uitgevoerd. De toepassing biedt ook een overzicht van de taakparameters en de duur.

Hieronder vindt u bijvoorbeeld het overzichtsgedeelte van de uitvoer van twee verschillende uitvoeringen van de voorbeeldtoepassing ParallelTasks. De duur van de taak die hier wordt weergegeven, omvat geen tijd voor het maken van een pool, omdat elke taak is verzonden naar een eerder gemaakte pool waarvan de rekenknooppunten tijdens het indienen de status Niet-actief hadden.

Bij de eerste uitvoering van de voorbeeldtoepassing ziet u dat met één knooppunt in de pool en de standaardinstelling van één taak per knooppunt, de duur van de taak meer dan 30 minuten is.

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

De tweede run van het voorbeeld toont een aanzienlijke afname in de duur van de taak. Dit komt doordat de pool is geconfigureerd met vier taken per knooppunt, waardoor parallelle taakuitvoering de job in bijna een kwart van de tijd kan voltooien.

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

Volgende stappen

  • Probeer de Batch Explorer HeatMap. Batch Explorer is een gratis, uitgebreid, zelfstandig clienthulpprogramma voor het maken, opsporen en controleren van Azure Batch toepassingen. Wanneer u de voorbeeldtoepassing ParallelTasks uitvoert, kunt u met de functie Batch Explorer HeatMap eenvoudig de uitvoering van parallelle taken op elk knooppunt visualiseren.
  • Bekijk Azure Batch voorbeelden op GitHub.
  • Meer informatie over Batch-taakafhankelijkheden.