Verwenden von Tasks mit mehreren Instanzen zum Ausführen von MPI-Anwendungen (Message Passing Interface) in Batch

Tasks mit mehreren Instanzen ermöglichen die Ausführung eines Azure Batch-Tasks auf mehreren Computeknoten gleichzeitig. Diese Tasks machen High Performance Computing-Szenarien wie Message Passing Interface-Anwendungen (MPI) in Batch möglich. In diesem Artikel erfahren Sie, wie Sie Multi-Instance-Aufgaben mithilfe der Bibliothek Azure.Compute.Batch ausführen.

Hinweis

Während sich die Beispiele in diesem Artikel auf Azure.Compute.Batch, MS-MPI und Windows-Computeknoten konzentrieren, gelten die hier erläuterten Konzepte für Aufgaben mit mehreren Instanzen auch für andere Plattformen und Technologien (z. B. Python und Intel MPI auf Linux-Knoten).

Task mit mehreren Instanzen – Übersicht

In Batch wird normalerweise jede Aufgabe auf einem einzelnen Computeknoten ausgeführt – Sie senden mehrere Aufgaben an einen Auftrag, und der Batch-Dienst plant jede Aufgabe zur Ausführung auf einem Knoten ein. Indem Sie die Einstellungen für mehrere Instanzen eines Tasks konfigurieren, weisen Sie Batch aber an, stattdessen einen primären Task und mehrere Subtasks zu erstellen, die dann auf mehreren Knoten ausgeführt werden.

Diagram: Übersicht über die Einstellungen für mehrere Instanzen

Wenn Sie einen Task mit Einstellungen für mehrere Instanzen an einen Auftrag übermitteln, führt Batch mehrere für Tasks mit mehreren Instanzen eindeutige Schritte aus:

  1. Der Batch-Dienst erstellt basierend auf den Einstellungen für mehrere Instanzen einen primären Task und mehrere Subtasks. Die Gesamtzahl der Tasks (primärer Task und alle Subtasks) entspricht der Anzahl der Instanzen (Computeknoten), die Sie in den Einstellungen für mehrere Instanzen festlegen.
  2. Batch legt einen Computeknoten als Master fest und plant die Ausführung der primären Task auf dem Master. Es plant die Ausführung der Subtasks auf den restlichen Computeknoten, die dem Task mit mehreren Instanzen zugeordnet sind (eine Unteraufgabe pro Knoten).
  3. Der Primärtask und alle Subtasks laden alle gemeinsamen Ressourcendateien herunter, die Sie in den Einstellungen für mehreren Instanzen angeben.
  4. Nachdem die gemeinsamen Ressourcendateien heruntergeladen wurden, wird der in den Einstellungen für mehrere Instanzen angegebene Koordinationsbefehl vom Primärtask und von den Subtasks ausgeführt. Der Koordinationsbefehl wird in der Regel für die Vorbereitung von Knoten zum Ausführen des Tasks verwendet. Dies kann das Starten von Hintergrunddiensten (wie z. B. Microsoft MPI'ssmpd.exe) sowie die Überprüfung umfassen, dass die Knoten bereit sind, Nachrichten zwischen den Knoten zu verarbeiten.
  5. Der Primärtask führt den Anwendungsbefehl auf dem Masterknoten aus, nachdem der Koordinationsbefehl vom Primärtask und von allen Subtasks erfolgreich abgeschlossen wurde. Der Anwendungsbefehl ist die Befehlszeile des Tasks mit mehreren Instanzen und wird nur vom Primärtask ausgeführt. In einer MS-MPI-basierten Lösung führen Sie hier Ihre MPI-fähige Anwendung mit mpiexec.exe aus.

Hinweis

Obwohl sie funktionell eindeutig ist, ist die "Multiinstanzaufgabe" kein eindeutiger Aufgabentyp wie "BatchStartTask " oder "BatchJobPreparationTask". Der Vorgang mit mehreren Instanzen ist einfach eine standardmäßige Batchaufgabe (BatchTask in Azure. Compute.Batch) deren Einstellungen für mehrere Instanzen konfiguriert wurden. In diesem Artikel bezeichnen wir sie als Task mit mehreren Instanzen.

Anforderungen für Tasks mit mehreren Instanzen

Tasks mit mehreren Instanzen erfordern einen Pool, in dem die Kommunikation zwischen Knoten aktiviert und die gleichzeitige Ausführung von Tasks deaktiviert ist. Um die Ausführung gleichzeitiger Aufgaben zu deaktivieren, legen Sie die BatchAccountPoolData.TaskSlotsPerNode-Eigenschaft auf 1 fest.

Hinweis

Batch begrenzt die Größe eines Pools, für den Kommunikation zwischen den Knoten aktiviert wurde.

Dieser Codeausschnitt zeigt, wie Sie einen Pool für Aufgaben mit mehreren Instanzen mithilfe der Azure erstellen. ResourceManager.Batch library.

ArmClient armClient = new ArmClient(new DefaultAzureCredential());

ResourceIdentifier batchAccountResourceId =
    BatchAccountResource.CreateResourceIdentifier("subscriptionId", "resourceGroupName", "accountName");
BatchAccountResource batchAccount = armClient.GetBatchAccountResource(batchAccountResourceId);

BatchAccountPoolCollection poolCollection = batchAccount.GetBatchAccountPools();

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = "standard_d1_v2",
    DeploymentConfiguration = new BatchDeploymentConfiguration()
    {
        VmConfiguration = new BatchVmConfiguration(
            imageReference: new BatchImageReference()
            {
                Publisher = "MicrosoftWindowsServer",
                Offer = "WindowsServer",
                Sku = "2019-datacenter-core",
                Version = "latest"
            },
            nodeAgentSkuId: "batch.node.windows amd64")
    },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = 3 }
    },

    // Multi-instance tasks require inter-node communication, and those nodes
    // must run only one task at a time.
    InterNodeCommunication = InterNodeCommunicationState.Enabled,
    TaskSlotsPerNode = 1
};

Hinweis

Wenn Sie versuchen, einen Task mit mehreren Instanzen in einem Pool auszuführen, in dem die Kommunikation zwischen den Knoten deaktiviert ist oder der einen höheren taskSlotsPerNode-Wert als 1 aufweist, wird der Task nie geplant – er bleibt auf unbestimmte Zeit im aktiven Zustand.

Pools mit aktivierter InterComputeNodeCommunication erlauben nicht automatisch die Aufhebung der Bereitstellung des Knotens.

Verwenden eines StartTask-Elements für die MPI-Installation

Zum Ausführen von MPI-Anwendungen mit einem Task mit mehreren Instanzen müssen Sie zunächst eine MPI-Implementierung (z.B. MS-MPI oder Intel MPI) auf den Computeknoten im Pool installieren. Dies ist ein guter Zeitpunkt, um einen BatchAccountPoolStartTask zu verwenden, der immer dann ausgeführt wird, wenn ein Knoten einem Pool beitritt oder neu gestartet wird. Dieser Codeausschnitt fügt der Pooldefinition eine Startaufgabe hinzu, die das MS-MPI Setuppaket als Ressourcendatei angibt. Die Befehlszeile der Startaufgabe wird ausgeführt, nachdem die Ressourcendatei auf den Knoten heruntergeladen wurde. In diesem Fall führt die Befehlszeile eine unbeaufsichtigte Installation von MS-MPI durch.

// Add a start task to the pool which we use for installing MS-MPI on
// the nodes as they join the pool (or when they are restarted).
poolData.StartTask = new BatchAccountPoolStartTask()
{
    CommandLine = "cmd /c MSMpiSetup.exe -unattend -force",
    UserIdentity = new BatchUserIdentity()
    {
        AutoUser = new BatchAutoUserSpecification() { ElevationLevel = BatchUserAccountElevationLevel.Admin }
    },
    WaitForSuccess = true,
};
poolData.StartTask.ResourceFiles.Add(new BatchResourceFile()
{
    HttpUri = new Uri("https://mystorageaccount.blob.core.windows.net/mycontainer/MSMpiSetup.exe"),
    FilePath = "MSMpiSetup.exe"
});

// Create the fully configured pool.
ArmOperation<BatchAccountPoolResource> pool = await poolCollection.CreateOrUpdateAsync(
    WaitUntil.Completed, "MultiInstanceSamplePool", poolData);

Remotezugriff auf den direkten Speicher (Remote Direct Memory Access, RDMA)

Wenn Sie für die Computeknoten in Ihrem Batch-Pool eine für RDMA geeignete Größe wie z.B. A9 auswählen, kann die MPI-Anwendung das hochleistungsfähige RDMA-Netzwerk (Remote Direct Memory Access) mit geringer Latenz von Azure nutzen.

Suchen Sie unter Größen für virtuelle Computer in Azure (für VirtualMachineConfiguration-Pools) bzw. Größen für Cloud Services (klassisch) (für CloudServicesConfiguration-Pools) nach den mit „RDMA-fähig“ gekennzeichneten Größen.

Hinweis

Zum Nutzen von RDMA auf Linux-Computeknoten müssen Sie Intel MPI auf den Knoten verwenden.

Erstellen Sie eine Aufgabe mit mehreren Instanzen mit Azure. Compute.Batch

Nachdem wie die Poolanforderungen und die MPI-Paketinstallation jetzt behandelt haben, erstellen wir den Task mit mehreren Instanzen. In diesem Codeausschnitt erstellen wir eine standardmäßige BatchTaskCreateOptions und konfigurieren anschließend deren MultiInstanceSettings-Eigenschaft. Wie bereits erwähnt, ist der Task mit mehreren Instanzen kein eigener Tasktyp, sondern ein standardmäßiger Batch-Task, der mit Einstellungen für mehrere Instanzen konfiguriert ist.

// Create the multi-instance task. Its command line is the "application command"
// and will be executed *only* by the primary, and only after the primary and
// subtasks execute the CoordinationCommandLine.
BatchTaskCreateOptions myMultiInstanceTask = new BatchTaskCreateOptions(
    id: "mymultiinstancetask",
    commandLine: "cmd /c mpiexec.exe -wdir %AZ_BATCH_TASK_SHARED_DIR% MyMPIApplication.exe")
{
    // Configure the task's MultiInstanceSettings. The CoordinationCommandLine will be executed by
    // the primary and all subtasks.
    MultiInstanceSettings = new MultiInstanceSettings(
        @"cmd /c start cmd /c ""%MSMPI_BIN%\smpd.exe"" -d")
    {
        NumberOfInstances = numberOfNodes
    }
};

myMultiInstanceTask.MultiInstanceSettings.CommonResourceFiles.Add(new ResourceFile()
{
    HttpUri = new Uri("https://mystorageaccount.blob.core.windows.net/mycontainer/MyMPIApplication.exe"),
    FilePath = "MyMPIApplication.exe"
});

// Submit the task to the job. Batch will take care of splitting it into subtasks and
// scheduling them for execution on the nodes.
await myBatchClient.CreateTaskAsync("mybatchjob", myMultiInstanceTask);

Primäre Aufgabe und Unteraufgaben

Beim Erstellen der Einstellungen für mehrere Instanzen für einen Task geben Sie die Anzahl von Computeknoten an, auf denen der Task ausgeführt werden soll. Wenn Sie den Task an einen Auftrag übermitteln, erstellt der Batch-Dienst einen Primärtask und eine ausreichende Anzahl von Subtasks, die zusammen der festgelegten Anzahl von Knoten entsprechen.

Diesen Tasks wird eine ganzzahlige ID im Bereich von 0 bis numberOfInstances - 1 zugewiesen. Der Task mit der ID 0 ist der primäre Task, und alle anderen IDs sind Subtasks. Wenn Sie z. B. für einen Task die folgenden Einstellungen für mehrere Instanzen erstellen, erhält der Primärtask die ID 0, und die Subtasks erhalten die IDs 1 bis 9.

int numberOfNodes = 10;
myMultiInstanceTask.MultiInstanceSettings = new MultiInstanceSettings("coord-cmd")
{
    NumberOfInstances = numberOfNodes
};

Masterknoten

Wenn Sie einen Task mit mehreren Instanzen übermitteln, legt Batch einen Computeknoten als Masterknoten fest und plant die Ausführung des primären Tasks auf dem Masterknoten. Die Subtasks werden auf den restlichen Knoten ausgeführt, die dem Task mit mehreren Instanzen zugeordnet sind.

Koordinationsbefehl

Der Koordinationsbefehl wird sowohl von der primären Aufgabe als auch von den Teilaufgaben ausgeführt.

Der Aufruf des Koordinationsbefehls führt zu einer Blockierung – Batch führt den Anwendungsbefehl erst dann aus, wenn der Koordinationsbefehl für alle Subtasks erfolgreich zurückgegeben wurde. Der Koordinationsbefehl sollte daher alle erforderlichen Hintergrunddienste starten, sicherstellen, dass sie einsatzbereit sind, und dann beendet werden. Beispielsweise startet dieser Koordinationsbefehl für eine Lösung mit MS-MPI-Version 7 den SMPD-Dienst auf dem Knoten und beendet sich anschließend:

cmd /c start cmd /c ""%MSMPI_BIN%\smpd.exe"" -d

Beachten Sie die Verwendung von start in diesem Koordinationsbefehl. Dies ist erforderlich, da die smpd.exe -Anwendung nicht sofort nach der Ausführung zurückgegeben wird. Ohne die Verwendung des start-Befehls würde dieser Koordinationsbefehl nicht zurückgegeben und daher die Ausführung des Anwendungsbefehls blockieren.

Anwendungsbefehl

Nachdem der Primärtask und die Subtasks die Ausführung des Koordinationsbefehls abgeschlossen haben, wird die Befehlszeile des Tasks mit mehreren Instanzen nurvom Primärtask ausgeführt. Wir bezeichnen dies zur Unterscheidung vom Koordinationsbefehl als Anwendungsbefehl .

Verwenden Sie bei MS-MPI-Anwendungen den Anwendungsbefehl, um Ihre MPI-fähige Anwendung mit mpiexec.exe auszuführen. Zum Beispiel ist hier ein Anwendungsbefehl für eine Lösung mit MS-MPI Version 7:

cmd /c ""%MSMPI_BIN%\mpiexec.exe"" -c 1 -wdir %AZ_BATCH_TASK_SHARED_DIR% MyMPIApplication.exe

Hinweis

Da die Datei mpiexec.exe von MS-MPI standardmäßig die Variable CCP_NODES verwendet (siehe Umgebungsvariablen), wird sie in der obigen Beispielbefehlszeile der Anwendung ausgeschlossen.

Umgebungsvariablen

Batch erstellt mehrere Umgebungsvariablen für Tasks mit mehreren Instanzen auf den Computeknoten, die einem Task mit mehreren Instanzen zugeordnet sind. Ihre Anwendungs- und Koordinationsbefehlszeilen sowie die Skripts und Programme, die sie ausführen, können auf diese Umgebungsvariablen verweisen.

Die folgenden Umgebungsvariablen werden vom Batch-Dienst für die Verwendung von Tasks mit mehreren Instanzen erstellt:

  • CCP_NODES
  • AZ_BATCH_NODE_LIST
  • AZ_BATCH_HOST_LIST
  • AZ_BATCH_MASTER_NODE
  • AZ_BATCH_TASK_SHARED_DIR
  • AZ_BATCH_IS_CURRENT_NODE_MASTER

Weitere Informationen zu diesen und anderen Umgebungsvariablen der Batch-Computeknoten, ihren Inhalten und ihrer Sichtbarkeit finden Sie unter Compute node environment variables (Computeknoten-Umgebungsvariablen).

Tipp

Das Batch-Linux-MPI-Codebeispiel enthält ein Beispiel dafür, wie einige dieser Umgebungsvariablen verwendet werden können.

Ressourcendateien

Es gibt zwei Sätze von Ressourcendateien, die bei Tasks mit mehreren Instanzen berücksichtigt werden müssen: gemeinsame Ressourcendateien, die von allen Tasks (Primärtask und Subtasks) heruntergeladen werden, und die Ressourcendateien für den Task mit mehreren Instanzen selbst, die nur vom Primärtask heruntergeladen werden.

In den Einstellungen für mehrere Instanzen eines Tasks können Sie eine oder mehrere gemeinsame Ressourcendateien angeben. Diese gemeinsamen Ressourcendateien werden vom Primärtask und von den Subtasks aus Azure Storage in das freigegebene Verzeichnis des Tasks aller Knoten heruntergeladen. Sie können mithilfe der AZ_BATCH_TASK_SHARED_DIR -Umgebungsvariablen über Anwendungs- und Koordinationsbefehlszeilen auf das freigegebene Verzeichnis eines Tasks zugreifen. Da der Pfad AZ_BATCH_TASK_SHARED_DIR ist bei allen dem Task mit mehreren Instanzen zugeordneten Knoten identisch ist, können Sie für den Primärtask und alle Subtasks denselben Koordinationsbefehl verwenden. Batch wird das Verzeichnis nicht im Sinne eines Remotzugriffs „freigeben“, aber Sie können es wie im Tipp zu Umgebungsvariablen erwähnt als Bereitstellungs- oder Freigabepunkt verwenden.

Ressourcendateien, die Sie für den Task mit mehreren Instanzen angeben, werden standardmäßig in das Arbeitsverzeichnis des Tasks (AZ_BATCH_TASK_WORKING_DIR) heruntergeladen. Im Gegensatz zu gemeinsamen Ressourcendateien lädt, wie erwähnt, nur der Primärtask die für den Task mit mehreren Instanzen angegebenen Ressourcendateien herunter.

Wichtig

Verwenden Sie immer die Umgebungsvariablen AZ_BATCH_TASK_SHARED_DIR und AZ_BATCH_TASK_WORKING_DIR, um in Ihren Befehlszeilen auf diese Verzeichnisse zu verweisen. Versuchen Sie nicht, die Pfade manuell zu erstellen.

Lebensdauer einer Aufgabe

Die Gültigkeitsdauer des Primärtasks steuert die Gültigkeitsdauer des gesamten Tasks mit mehreren Instanzen. Wenn der Primärtask beendet wird, werden auch alle Subtasks beendet. Der Exit-Code des primären Prozesses ist der Exit-Code der Task und wird daher verwendet, um für Wiederholungszwecke zu bestimmen, ob die Task erfolgreich war oder fehlgeschlagen ist.

Wenn beispielsweise einer der Subtasks fehlschlägt und mit einem Rückgabecode ungleich NULL beendet wird, schlägt der gesamte Task mit mehreren Instanzen fehl. Der Task mit mehreren Instanzen wird dann beendet und wiederholt, bis die Grenze für erneute Versuche erreicht ist.

Wenn Sie einen Task mit mehreren Instanzen löschen, werden der Primärtask und alle Subtasks ebenfalls vom Batch-Dienst gelöscht. Alle Subtaskverzeichnisse und die Dateien darin werden genau wie bei einem Standardtask von den Computeknoten gelöscht.

BatchTaskConstraints für einen Vorgang mit mehreren Instanzen, z. B. die Eigenschaften MaxTaskRetryCount, MaxWallClockTime und RetentionTime , werden berücksichtigt, da sie für eine Standardaufgabe gelten und auf die primären und alle Teilvorgänge angewendet werden. Wenn Sie die RetentionTime-Eigenschaft jedoch nach dem Hinzufügen des Tasks mit mehreren Instanzen zum Auftrag ändern, wird diese Änderung nur für den Primärtask übernommen. Alle Subtasks verwenden weiterhin die ursprüngliche RetentionTime-Eigenschaft.

In der Liste der aktuellen Tasks eines Computeknotens wird die ID eines Subtasks angezeigt, wenn der aktuelle Task Teil eines Tasks mit mehreren Instanzen war.

Abrufen von Informationen zu Subtasks

Um Informationen zu Teilaufgaben mithilfe der Azure.Compute.Batch-Bibliothek abzurufen, rufen Sie die Methode BatchClient.GetTaskSubTasks auf. Diese Methode gibt Informationen zu allen Subtasks sowie zum Computeknoten zurück, auf dem die Tasks ausgeführt wurden. Anhand dieser Informationen können Sie u. a. das Stammverzeichnis, die Pool-ID, den aktuellen Zustand und den Exitcode der einzelnen Subtasks bestimmen. Sie können diese Informationen in Kombination mit der BatchClient.GetNodeFile-Methode verwenden, um die Dateien des Teilvorgangs abzurufen. Beachten Sie, dass diese Methode keine Informationen für den Primärtask (ID 0) zurückgibt.

Hinweis

Sofern nicht anders angegeben, Azure. Compute.Batch-Methoden, die auf der mehrinstanzigen BatchTask selbst ausgeführt werden, wenden only auf den primären Vorgang an. Wenn Sie beispielsweise die GetTaskFiles Methode für eine Aufgabe mit mehreren Instanzen aufrufen, werden nur die Dateien der primären Aufgabe zurückgegeben.

Der folgende Codeausschnitt zeigt das Abrufen von Informationen zu Subtasks sowie das Anfordern von Dateiinhalten von den Knoten, auf denen sie ausgeführt werden.

// Obtain the multi-instance task from the Batch service
BatchTask myMultiInstanceTask = await batchClient.GetTaskAsync("mybatchjob", "mymultiinstancetask");
_ = myMultiInstanceTask;

// Now iterate over the subtasks for the task and print their stdout and stderr
// output if the subtask has completed
await foreach (BatchSubtask subtask in batchClient.GetSubTasksAsync("mybatchjob", "mymultiinstancetask"))
{
    Console.WriteLine("subtask: {0}", subtask.Id);
    Console.WriteLine("exit code: {0}", subtask.ExitCode);

    if (subtask.State == BatchSubtaskState.Completed)
    {
        BatchNode node = await batchClient.GetNodeAsync(
            subtask.NodeInfo.PoolId,
            subtask.NodeInfo.NodeId);

        BinaryData stdOut = await batchClient.GetNodeFileAsync(
            subtask.NodeInfo.PoolId, node.Id, $"{subtask.NodeInfo.TaskRootDirectory}/stdout.txt");
        BinaryData stdErr = await batchClient.GetNodeFileAsync(
            subtask.NodeInfo.PoolId, node.Id, $"{subtask.NodeInfo.TaskRootDirectory}/stderr.txt");

        Console.WriteLine("node: {0}:", node.Id);
        Console.WriteLine("stdout.txt: {0}", stdOut);
        Console.WriteLine("stderr.txt: {0}", stdErr);
    }
    else
    {
        Console.WriteLine("\tSubtask {0} is in state {1}", subtask.Id, subtask.State);
    }
}

Codebeispiel

Im Codebeispiel MultiInstanceTasks auf GitHub wird veranschaulicht, wie Sie einen Task mit mehreren Instanzen zum Ausführen einer MS-MPI-Anwendung auf Batch-Computeknoten verwenden. Führen Sie die folgenden Schritte aus, um das Beispiel auszuführen.

Vorbereitung

  1. Laden Sie das MS-MPI SDK und die Redist-Installationsprogramme herunter, und installieren Sie sie. Nach der Installation können Sie überprüfen, ob die MS-MPI-Umgebungsvariablen festgelegt wurden.
  2. Erstellen Sie eine Freigabeversion des MPI-Beispielprogramms MPIHelloWorld. Dies ist das Programm, das vom Task mit mehreren Instanzen auf Computeknoten ausgeführt wird.
  3. Erstellen Sie eine ZIP-Datei, die MPIHelloWorld.exe (in Schritt 2 erstellt) und MSMpiSetup.exe (in Schritt 1 heruntergeladen) enthält. Im nächsten Schritt laden Sie diese ZIP-Datei als Anwendungspaket hoch.
  4. Verwenden Sie das Azure-Portal zum Erstellen einer Batch-Anwendung mit dem Namen „MPIHelloWorld“, und geben Sie die im vorherigen Schritt als Version „1.0“ des Anwendungspakets erstellte ZIP-Datei an. Weitere Informationen finden Sie unter Hochladen und Verwalten von Anwendungen.

Tipp

Durch die Erstellung einer Releaseversion von MPIHelloWorld.exe wird sichergestellt, dass Sie keine weiteren Abhängigkeiten (z. B. msvcp140d.dll oder vcruntime140d.dll) in Ihr Anwendungspaket einbinden müssen.

Ausführung

  1. Laden Sie die ZIP-Datei „azure-batch-samples“ von GitHub herunter.

  2. Öffnen Sie die MultiInstanceTasks-Projektmappe in Visual Studio 2019. Die Lösungsdatei MultiInstanceTasks.sln befindet sich hier:

    azure-batch-samples\CSharp\ArticleProjects\MultiInstanceTasks\

  3. Geben Sie die Anmeldeinformationen für Ihr Batch- und Storage-Konto in AccountSettings.settings im Projekt Microsoft.Azure.Batch.Samples.Common ein.

  4. Erstellen Sie die Lösung MultiInstanceTasks, und führen Sie sie aus, damit die MPI-Beispielanwendung auf den Computeknoten in einem Batch-Pool ausgeführt wird.

  5. Optional: Verwenden Sie das Azure-Portal oder den Batch Explorer, um Beispielpool, -auftrag und -task („MultiInstanceSamplePool“, „MultiInstanceSampleJob“, „MultiInstanceSampleTask“) vor dem Löschen der Ressourcen zu untersuchen.

Tipp

Sie können Visual Studio Community kostenlos herunterladen, falls Sie Visual Studio noch nicht erworben haben.

Die Ausgabe von MultiInstanceTasks.exe sieht etwa wie folgt aus:

Creating pool [MultiInstanceSamplePool]...
Creating job [MultiInstanceSampleJob]...
Adding task [MultiInstanceSampleTask] to job [MultiInstanceSampleJob]...
Awaiting task completion, timeout in 00:30:00...

Main task [MultiInstanceSampleTask] is in state [Completed] and ran on compute node [tvm-1219235766_1-20161017t162002z]:
---- stdout.txt ----
Rank 2 received string "Hello world" from Rank 0
Rank 1 received string "Hello world" from Rank 0

---- stderr.txt ----

Main task completed, waiting 00:00:10 for subtasks to complete...

---- Subtask information ----
subtask: 1
        exit code: 0
        node: tvm-1219235766_3-20161017t162002z
        stdout.txt:
        stderr.txt:
subtask: 2
        exit code: 0
        node: tvm-1219235766_2-20161017t162002z
        stdout.txt:
        stderr.txt:

Delete job? [yes] no: yes
Delete pool? [yes] no: yes

Sample complete, hit ENTER to exit...

Nächste Schritte

  • Last updated on