Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Zusammenfassung
HPC Services für Excel unterstützt eine Vielzahl neuer Programmiermodelle, mit denen Sie Excel-Berechnungen auf einem HPC-Cluster ausführen können. In diesem Artikel wird erläutert, wie Sie VBA-Makros in Excel verwenden, um Arbeitsmappen zu erstellen, die einen HPC-Cluster verwenden, um Berechnungen parallel auszuführen. Um HPC Services für Excel zu unterstützen, muss Ihre Arbeitsmappe eine Reihe von Makros enthalten, die die asynchronen Funktionen implementieren. In diesem Artikel werden das Makroframework und das Definieren von Berechnungen innerhalb des Frameworks beschrieben. Dieser Artikel enthält ein Beispiel für das Erstellen einer Arbeitsmappe von Grund auf neu und ein Beispiel für die Konvertierung einer vorhandenen Arbeitsmappe, die auf einem Cluster ausgeführt werden soll.
Einleitung
Würden Sie eine Stunde damit verbringen, dass Ihre Excel-Arbeitsmappe viermal schneller ausgeführt wird? Wie geht es um acht mal schneller oder noch mehr? Wenn Sie über lange oder langsame Excel-Arbeitsmappen verfügen, können Sie HPC-Dienste für Excel mit einem Microsoft HPC-Cluster verwenden, um die Berechnungsleistung erheblich zu verbessern.
HPC Services für Excel unterstützt eine Vielzahl neuer Programmiermodelle, mit denen Sie Excel-Berechnungen auf einem HPC-Cluster ausführen können. Sie müssen jedoch nicht mit der Codeentwicklung vertraut sein oder C# kennen, um HPC Services für Excel zu verwenden. In diesem Artikel wird erläutert, wie Sie Arbeitsmappen erstellen, die einen HPC-Cluster für die Berechnung verwenden, nur mit Excel VBA.
In Wirklichkeit dauert es wahrscheinlich mehr als eine Stunde, eine Ihrer Arbeitsmappen zu konvertieren, um auf dem Cluster ausgeführt zu werden, je nachdem, wie kompliziert die Arbeitsmappe ist. Wenn Sie jedoch eine Stunde damit verbringen, die Beispiele in diesem Artikel durchzuarbeiten, verstehen Sie die konzepte und die Anforderungen für die Konvertierung nur für jede Arbeitsmappe, die auf einem HPC-Cluster ausgeführt werden soll. Außerdem werden die Leistungsvorteile angezeigt, die Sie mit einigen einfachen Änderungen an Ihrem VBA-Code erhalten können.
Beabsichtigte Zielgruppe
Dieser Artikel richtet sich an Excel-Entwickler, die mit dem Schreiben von VBA-Makros vertraut sind. Vertrautheit mit Microsoft HPC Pack ist hilfreich, ist jedoch nicht erforderlich.
Wenn Sie an den Leistungsmöglichkeiten von HPC Services für Excel interessiert sind, aber nicht den vollständigen Entwicklungsprozess durchlaufen möchten, enthalten die Downloaddateien vollständige Versionen der beiden Arbeitsmappen, die in diesem Artikel erläutert werden. Wenn Sie versuchen möchten, diese Arbeitsmappen auf einem Microsoft HPC-Cluster auszuführen, lesen Sie bitte den Abschnitt "Bevor Sie beginnen", um sicherzustellen, dass Alle Anforderungen erfüllt sind, bevor Sie beginnen. Weitere Beispiele und Dokumentationen finden Sie unter https://github.com/Azure-Samples/hpcpack-samples.
Dateien herunterladen
Sie finden einige Beispieldateien, die in den Abschnitten verwendet werden, die im HPC Pack-Beispiel-Github-Repository folgen. Die Beispieldateien enthalten Skelettmakrodateien, die Sie in Ihre Arbeitsmappen importieren können, um den Entwicklungsprozess zu vereinfachen. Es gibt auch eine einfache Arbeitsmappe, die wir als Ausgangspunkt für die Entwicklung einer Arbeitsmappe für HPC Services für Excel verwenden.
Struktur und Formatierung
Die Screenshots in diesem Artikel stammen alle aus Excel und dem HPC Cluster Manager. In den praktischen Beispielen in diesem Artikel werden Codebeispiele mithilfe einer Codeformatvorlage formatiert, die den VBA-Editor darstellt:
'==========================================================
'
' Section 1: Variables and constants
'
'==========================================================
Dim SentRecords As Integer
Dim RcvRecords As Integer
Wenn Codezeilen hinzugefügt oder geändert werden, werden sie grün hervorgehoben. Ein Großteil des hier enthaltenen Codes wird entweder aus vorhandenen Dateien importiert oder zwischen verschiedenen VBA-Dateien kopiert. In diesem Fall können einige lange Codezeilen abgeschnitten werden, damit sie in die Ränder dieses Dokuments passen. Versuchen Sie, vorhandene Dokumente anstelle dieses Artikels zu kopieren und einzufügen, um versehentlich die abgeschnittenen Codebeispiele einzufügen.
Überblick
HPC Services für Excel unterstützt eine Reihe von Programmiermodellen für die Entwicklung und Ausführung von Excel-Berechnungen auf einem Microsoft HPC-Cluster. Die von Ihnen ausgewählte Lösung sollte von Ihren speziellen Anforderungen und Ihren Entwicklungskenntnissen abhängen.
| Beabsichtigte Verwendung | Erforderliche Fähigkeiten | Lösung |
|---|---|---|
| Berechnen von Arbeitsmappen parallel, für eine bessere Leistung (schnellere Berechnungszeiten) oder die Möglichkeit, mehr Daten in derselben Zeit zu verarbeiten | Vba-Entwicklung in Excel (Makro) | Ausführen von Arbeitsmappen auf einem HPC-Cluster mit Excel VBA |
| Erstellen von benutzerdefinierten Anwendungen und Diensten, die Excel-Arbeitsmappen in einem HPC-Cluster ausführen und in eigenständige Anwendungen oder Batchskripts integriert werden | .NET-Programmierung mit C#, VBA.NET oder einer beliebigen Sprache, die von .NET CLR unterstützt wird | Entwickeln von benutzerdefinierten HPC-Diensten und Clientanwendungen für Excel |
| Beschleunigen der Berechnung von Excel-User-Defined-Funktionen (UDFs), die in Excel-Erweiterungsbibliotheken (XLLs) enthalten sind | C- oder C++-Programmierung, Entwicklung der Excel-Erweiterungsbibliothek (XLL) | Cluster-Enabled Excel-User-Defined-Funktionen |
Wir befassen uns mit jedem dieser Programmiermodelle in zukünftigen Artikeln. Heute befassen wir uns mit dem ersten Modell: Paralleles Berechnen von Excel-Arbeitsmappen mit nur Excel VBA. Auch wenn Sie sich auf eine komplexere Entwicklung mit Excel und Microsoft HPC Pack konzentrieren möchten, kann dies ein guter Ausgangspunkt sein: Es ist die einfachste und schnellste Möglichkeit, Excel-Anwendungen auf einem HPC-Cluster auszuführen, und es hilft Ihnen, die Anforderungen und Vorteile der Verwendung von HPC Services für Excel zu verstehen.
Um Excel-Entwickler zu unterstützen, enthält HPC Services für Excel eine Reihe von Bibliotheken, die Sie direkt aus Excel verwenden können – auf Ihrem Desktop – zum Erstellen und Ausführen von Excel-Arbeitsmappen auf einem Microsoft HPC-Cluster. Bei diesen Bibliotheken müssen Sie .NET-Programmierung oder C# nicht kennen. Alle Arbeiten können aus Excel ausgeführt werden, indem VBA-Makros geschrieben werden. Mit diesem Framework können Sie die Berechnung von Excel-Arbeitsmappen erheblich beschleunigen, indem Sie einfach VBA-Code schreiben und die Arbeitsmappen im Cluster ausführen.
HPC Services für Excel enthält ein Client-/Serviceframework, das speziell für die Verwendung von Excel auf dem Desktop entwickelt wurde. Für dieses Framework gibt es zwei wichtige Teile: eine Clientbibliothek, die auf dem Desktop installiert ist; und eine Dienstbibliothek, die auf den Cluster-Computeknoten installiert ist. Diese Bibliotheken werden standardmäßig installiert, wenn Sie Microsoft HPC Pack installieren, sodass Sie keine benutzerdefinierte Konfiguration ausführen müssen, um sie zu verwenden.
Nachdem der Client und die Dienstbibliothek installiert wurden, können Sie Excel-Arbeitsmappen für den Cluster erstellen und ausführen, indem Sie ihrer Arbeitsmappe einfach einige VBA-Makros hinzufügen. Diese neuen VBA-Makros werden als Makroframework beschrieben. Wenn wir auf das Makroframework verweisen, beschreiben wir speziell die neuen Makros, die Sie Zu Ihren Arbeitsmappen hinzufügen, um die Berechnung auf einem HPC-Cluster zu unterstützen.
Bevor wir die spezifischen Makros besprechen, sollten Sie einige wichtige Konzepte hervorheben, die sich auf die Konstruktion und Funktionsweise der Makros auswirken.
Asynchrone Berechnung
Das wichtigste Konzept für die Entwicklung von Arbeitsmappen für HPC Services für Excel und die Verwendung des Makroframeworks ist eine asynchrone Berechnung.
Eine typische Excel-Anwendung wird synchron ausgeführt. Das heißt, Sie drücken eine Schaltfläche, um ein Makro auszuführen, und das Makro führt einige VBA-Code aus. In diesem Code können Sie Änderungen an der Kalkulationstabelle vornehmen, andere VBA-Funktionen aufrufen, auf Datenbanken zugreifen oder etwas anderes. Sie erwarten jedoch, dass die Makros von Anfang bis Ende ausgeführt werden und dann abgeschlossen sind.
Das asynchrone Modell unterscheidet sich etwas. In diesem Modell schreiben Sie VBA-Funktionen, rufen sie aber nicht direkt auf. Stattdessen ruft eine Clientbibliothek – Code, der mit HPC Services für Excel installiert ist – Ihre VBA-Funktionen auf.
Wenn Sie mit Excel-Ereignissen in VBA vertraut sind, wissen Sie dieses Modell bereits. Wenn Sie beispielsweise eine VBA-Funktion schreiben, die auf dem Workbook.Open-Ereignis ausgeführt wird, wissen Sie, dass der Code bei jedem Öffnen der Arbeitsmappe ausgeführt wird. Sie rufen diesen Code jedoch nicht direkt auf; Stattdessen ruft Excel die Funktion auf, die Sie automatisch schreiben, wenn die Arbeitsmappe geöffnet wird.
Das asynchrone Programmiermodell funktioniert auf die gleiche Weise. Sie schreiben Funktionen, die während einer Berechnung aufgerufen werden, aber anstatt sie selbst aufzurufen, warten Sie auf Excel - oder in diesem Fall die HPC Services für Excel-Bibliothek -, um die Funktionen aufzurufen.
Iterative Berechnung und parallele Berechnung
Ein weiteres wichtiges Konzept ist iterative Berechnung. Iterative Berechnung bezieht sich auf einen Berechnungstyp, der dieselben grundlegenden Berechnungsschritte über verschiedene Datensätze ausführt.
Das häufigste Beispiel für iterative Berechnung ist die Monte Carlo-Simulation. In einer Monte Carlo-Simulation haben Sie in der Regel eine komplexe Berechnung - z. B. das Generieren von Wertpapierpreisen - basierend auf einem zufallsbedingten Eingabewert, wie die erwartete Rendite über mehrere Jahre. Eine Monte Carlo-Simulation führt tausende Male dieselbe Berechnung aus, jedes Mal mit einem anderen zufälligen Eingabewert.
Dies ist eine iterative Berechnung, da jedes Mal, wenn der Preis berechnet wird, mit einem anderen zufälligen Eingabewert die gesamte Berechnung erneut ausgeführt wird. Diese Berechnungen sind unabhängig; d. h. in jeder einzelnen Berechnung gibt es keinen Verweis auf eine vorherige oder nachfolgende Berechnung.
Ein weiteres gängiges Beispiel ist das Ausführen einer Berechnung über eine Reihe von Datensätzen aus einer Datenbank. In diesem Fall haben Sie möglicherweise eine komplexe Berechnung - z. B. eine Versicherung oder ein versicherungsmathematisches Modell -- das auf einigen Parametern basiert, z. B. das Alter und das Geschlecht eines Versicherungsnehmers. Die iterative Berechnung führt das gleiche Modell für Tausende einzelner Versicherungsnehmer aus. Jede Berechnung ist unabhängig von allen anderen Berechnungen.
Das makroframework, das wir hier besprechen, ist für die Arbeit mit diesen Arten von iterativen Berechnungen konzipiert. Das ist wichtig, denn wenn wir eine Berechnung auf einem HPC-Cluster ausführen, werden wir die Berechnung parallel ausführen – wir führen die gleiche Berechnung mehrmals aus, aber wir führen mehrere Instanzen der Berechnung gleichzeitig auf den Cluster-Computeknoten aus.
Wenn die Berechnung nicht unabhängig wäre - wenn die Ergebnisse einer einzelnen Berechnung von früheren Berechnungen abhängig waren , die wir ausgeführt haben - dann funktioniert dies nicht. Daher gilt das hier diskutierte Framework nur für iterative, unabhängige Berechnungen – Berechnungen, die parallelisiert werden können.
Das Makroframework
Um HPC Services für Excel zu unterstützen, muss Ihre Arbeitsmappe eine Reihe von Makros enthalten, die die asynchronen Funktionen implementieren. Dies ist das Makroframework. Im Framework werden sechs Makros verwendet, die Sie einer beliebigen Excel-Arbeitsmappe hinzufügen können. Die sechs Makros mit einer kurzen Beschreibung ihrer Aufgaben sind
| Makroname | Maßnahme |
|---|---|
| HPC_Initialize | Ausführen von Vorberechnungs- oder Initialisierungsschritten |
| HPC_Partition | Sammeln erforderlicher Parameter für einen einzelnen Berechnungsschritt |
| HPC_Execute | Ausführen eines Berechnungsschritts als Teil einer größeren Gesamtberechnung |
| HPC_Merge | Verarbeiten der Ergebnisse eines einzelnen Berechnungsschritts |
| HPC_Finalize | Durchführen einer nach der Berechnung durchgeführten Verarbeitung |
| HPC_ExecutionError | Behandeln von Fehlern, die sich aus der Berechnung ergeben |
(Machen Sie sich keine Sorgen, wenn diese Beschreibungen nicht sofort klar sind: Wir werden jede dieser Funktionen im Folgenden ausführlicher beschreiben).
Dieselben Makros müssen jeder Kalkulationstabelle hinzugefügt werden, um die Berechnung auf dem Cluster zu unterstützen, aber was sich in den Makros befindet – die spezifischen Berechnungsfunktionen – können unterschiedlich sein. Um den Vorgang zu vereinfachen, enthalten die in diesem Artikel enthaltenen Downloaddateien eine "Skelett"-Makrodatei, die Sie in Ihre Arbeitsmappe importieren können. Nachdem Sie die grundlegenden Makros eingerichtet haben, können Sie sie nach Bedarf ausfüllen, um Ihre Berechnung zu unterstützen.
Jedes Makro hat einen bestimmten Zweck im Makroframework, und jedes wird während einer Clusterberechnung von der HPC Services für Excel-Clientbibliothek aufgerufen. Wenn eine Berechnung ausgeführt wird, wird jedes Makro an einem bestimmten Punkt aufgerufen. Eine typische Berechnung wird wie folgt ausgeführt:
Wenn eine Clusterberechnung ausgeführt wird, ruft die Clientbibliothek zuerst das HPC_Initialize Makro auf. Dies wird verwendet, um alle erforderlichen Initialisierungen zu behandeln; Sie können beispielsweise alte Ergebnisse aus Ihrer Kalkulationstabelle löschen.
Als Nächstes durchläuft die Berechnung drei Makros: HPC_Partition, HPC_Execute und HPC_Merge. Im obigen Diagramm werden diese als Schleife angezeigt. Das ist nicht wirklich, was während einer Berechnung passiert, aber logisch können Sie sich dies als Schleife vorstellen. Zuerst ruft die Clientbibliothek HPC_Partition auf. HPC_Partition dient zum Sammeln von Daten, die für einen einzelnen Berechnungsschritt erforderlich sind. Wenn Sie z. B. eine Reihe von Zeilen einzeln berechnen möchten, kann HPC_Partition die Zeilennummer für einen einzelnen Schritt zurückgeben: erste Zeile 1, dann Zeile 2 usw.
Als Nächstes wird das HPC_Execute Makro aufgerufen. Dieses Makro führt die tatsächliche Berechnung aus. Wenn wir zeilenweise berechnen, wird dadurch eine einzelne Zeile berechnet. HPC_Execute gibt das Ergebnis der Berechnung zurück: Beispielsweise kann die letzte Zelle in der Zeile zurückgegeben werden, die das Endergebnis einer längeren Berechnung ist.
Nach HPC_Execute ruft die Clientbibliothek HPC_Merge auf. Alles , was HPC_Execute berechnet hat, wird an HPC_Merge gesendet. Das HPC_Merge-Makro ist so konzipiert, dass diese Ergebnisse verwendet werden, und sie wieder auf dem Desktop zur Kalkulationstabelle zurückkehren. Im HPC_Merge-Makro können Sie die Berechnungsergebnisse wieder in Ihr Arbeitsblatt einfügen, oder Sie schreiben sie in eine Protokolldatei.
Diese drei Makros – HPC_Partition, HPC_Execute und HPC_Merge – werden mehrmals für jeden Schritt in der Berechnung aufgerufen, bis die gesamte Berechnung abgeschlossen ist. Diese Makros implementieren das oben beschriebene iterative Berechnungsmodell. Die Makros können während einer einzelnen Arbeitsmappenberechnung oft aufgerufen werden, aber jedes Mal, wenn sie aufgerufen werden, stellt einen einzelnen Berechnungsschritt oder eine Iteration dar.
Nach Abschluss des letzten Berechnungsschritts ruft die Clientbibliothek HPC_Finalize auf. Sie können dieses Makro verwenden, um eine beliebige Verarbeitung nach der Berechnung durchzuführen: Sie können z. B. den Mittelwert aller vorherigen Berechnungsschritte mithilfe eines anderen VBA-Makros ermitteln.
Das sechste und letzte Makro, HPC_ExecutionError, wird nur verwendet, wenn bei der Berechnung ein Fehler auftritt. Wenn dies der Fall ist, wird dieses Makro aufgerufen, und Sie können Code zur Fehlerbehandlung hinzufügen, z. B. ein Popupdialogfeld, in dem der Benutzer sie vor dem Fehler warnt.
Im obigen Diagramm ist das HPC_Execute Makro orange hervorgehoben. Das soll darauf hinweisen, dass dieses Makro etwas ungewöhnlich ist. Alle anderen Makros werden auf dem Desktop in Excel auf Ihrer Arbeitsstation ausgeführt. Wenn wir jedoch eine Berechnung auf einem HPC-Cluster ausführen, wird das HPC_Execute Makro tatsächlich auf den Cluster-Computeknoten ausgeführt.
So unterstützen HPC Services für Excel und das Makroframework Clusterberechnungen. Während wir alle Makros in derselben Arbeitsmappe schreiben – die Arbeitsmappe auf dem Desktop – beim Ausführen der Berechnung wird die Arbeitsmappe in die Cluster-Computeknoten kopiert, und das HPC_Execute Makro wird auf einem der Computeknoten ausgeführt.
Es ist wichtig, dies zu verstehen, da es einige Auswirkungen darauf hat, wie Arbeitsmappen während der Berechnung Daten verwenden und verwalten. Die drei Hauptberechnungsmakros – HPC_Partition, HPC_Execute und HPC_Merge – übergeben Daten während des Berechnungsprozesses hin und her. In einer typischen VBA-Anwendung gibt es viele Möglichkeiten, Daten zwischen verschiedenen Makros freizugeben. Sie können beispielsweise globale Variablen im VBA-Code verwenden oder Werte in Tabellenkalkulationszellen schreiben. Wenn wir die Berechnung jedoch auf einem HPC-Cluster ausführen, müssen wir Daten zwischen den Makros senden, die auf dem Desktop ausgeführt werden, und dem HPC_Execute Makro, das auf den Computeknoten ausgeführt wird.
Aus diesem Grund müssen alle Daten, die zum Ausführen der Berechnung erforderlich sind, aus dem HPC_Partition Makro direkt an das HPC_Execute Makro gesendet werden. Dazu verwenden wir den Rückgabewert aus dem HPC_Partition-Makro . Dieser Rückgabewert wird zum Argument (oder Parameter) für die HPC_Execute-Funktion . Daten werden also direkt zwischen diesen beiden Makros übergeben, und Sie können einen beliebigen Wert oder wertesatz (als Array) zwischen diesen Makros übergeben. Aber auch hier können Sie keine globalen Variablen oder Tabellenkalkulationszellen verwenden, um Informationen zwischen den beiden Makros zu übergeben, da beim Ausführen auf dem Cluster mehrere Kopien der Arbeitsmappe gleichzeitig ausgeführt werden – eine auf dem Desktop und eine (oder mehrere) auf den Cluster-Computeknoten.
Auf die gleiche Weise, wenn die Berechnung in HPC_Execute abgeschlossen ist, wird ein Ergebnis als Rückgabewert der Makrofunktion zurückgegeben. Dieses Ergebnis wird zum Argument (oder Parameter) zum nächsten Makro HPC_Merge. Alle Ergebnisse, die Sie zurückgeben möchten – die Ergebnisse der Berechnung – müssen auf diese Weise als Rückgabewert der Funktion gesendet werden.
Erstellen Cluster-Enabled Arbeitsmappen mit Excel und HPC Services für Excel
In den folgenden Abschnitten werden wir durch die Erstellung von zwei Arbeitsmappen geführt, die die Berechnung in einem HPC-Cluster unterstützen. Im ersten Abschnitt erstellen wir eine Arbeitsmappe von Grund auf neu. Dies sollte Ihnen dabei helfen, die betreffenden Konzepte und die Anforderungen für die Verwendung von HPC Services für Excel zu verstehen. Im zweiten Abschnitt nehmen wir eine vorhandene Arbeitsmappe – eine Arbeitsmappe, die für die Ausführung auf dem Desktop entwickelt wurde – und konvertieren sie so, dass sie auf dem Cluster ausgeführt werden kann.
Bevor Sie beginnen: Voraussetzungen und Anforderungen
HPC Services für Excel ist eine Reihe von Tools, die in den Versionen Microsoft HPC Pack 2008 R2 Beta 2 und höher enthalten sind. Sie benötigen einen Microsoft HPC Pack-Cluster installiert und konfiguriert. Die Installation eines HPC-Clusters liegt außerhalb des Umfangs dieses Artikels; wir behandeln nur die spezifische Konfiguration, die Sie für HPC Services für Excel benötigen. Weitere Informationen zum Installieren und Konfigurieren des Clusters finden Sie in der Dokumentation, die im Lieferumfang von Microsoft HPC Pack enthalten ist. Auf Dem Desktop benötigen Sie die HPC Pack-Client-Dienstprogramme.
Auf dem Cluster
Nachdem Sie einen HPC-Cluster ausgeführt haben, müssen Sie Excel auf den Cluster-Computeknoten installieren. Sie können das Standardmäßige Office-Installationskit verwenden, um Excel zu installieren, oder in der HPC Pack-Dokumentation finden Sie weitere Informationen zum Automatisieren der Excel-Installation.
Nachdem Excel auf Ihren Cluster-Computeknoten installiert wurde, können Sie den HPC-Diagnosetest ausführen, um sicherzustellen, dass alles ordnungsgemäß konfiguriert ist. Um den Diagnosetest auszuführen, verwenden Sie HPC Cluster Manager (entweder auf dem Clusterkopfknoten, wo er standardmäßig installiert ist, oder auf Dem Desktop, wenn Sie die Client-Dienstprogramme installiert haben).
So überprüfen Sie, ob der HPC-Dienst für Excel ordnungsgemäß konfiguriert ist
Klicken Sie im HPC-Cluster-Manager auf "Diagnose".
Erweitern Sie in "Tests" Microsoft , und wählen Sie dann Excel aus.
Doppelklicken Sie im Ansichtsbereich auf den Excel Runner-Konfigurationstest.
Wählen Sie im Konfigurationsdialogfeld "Alle Knoten " aus, und klicken Sie dann auf "Ausführen".
Klicken Sie im Navigationsbereich auf "Testergebnisse", um den Fortschritt des Tests anzuzeigen. Der Test, den Sie ausführen, wird im Ansichtsbereich angezeigt.
Nachdem der Test abgeschlossen ist, können Sie im Hauptfenster auf den Test klicken, um die Ergebnisse anzuzeigen.
Wenn der Test "Fehler" anzeigt, doppelklicken Sie auf den Test, und versuchen Sie, fehler im Popupfenster zu beheben. Häufige Fehler, die Möglicherweise angezeigt werden, sind, dass Excel nicht auf einem Computeknoten installiert ist oder Excel nicht aktiviert wurde. Nehmen Sie alle benötigten Änderungen vor, und führen Sie dann den Diagnosetest mithilfe der obigen Anweisungen erneut aus.
Wenn der Test "Erfolg" anzeigt, können Sie fortfahren.
Das letzte, was Sie benötigen, ist ein Freigabeverzeichnis. Wenn wir eine Arbeitsmappe in einem HPC-Cluster berechnen, lädt jeder der Cluster-Computeknoten tatsächlich und führt eine Kopie der Arbeitsmappe aus. Um dies zu unterstützen, müssen Sie ein Freigabeverzeichnis erstellen, das sowohl für die Cluster-Computeknoten als auch für Den Desktop sichtbar ist.
Wenn Sie Zugriff auf den Clusterkopfknoten haben, erstellen Sie ein Freigabeverzeichnis auf dem Kopfknoten. Dies ist praktisch, da Sie wissen, dass die Cluster-Computeknoten auf den Kopfknoten zugreifen können. Wenn Sie kein Freigabeverzeichnis auf dem Kopfknoten erstellen können, erstellen Sie das Freigabeverzeichnis an einer beliebigen Stelle innerhalb der Domäne, auf die sowohl auf Ihren Desktop als auch auf die Cluster-Computeknoten zugegriffen werden kann.
Auf dem Desktop
Auf dem Desktop müssen Sie Excel und die Microsoft HPC Pack-Clientprogramme installieren (die Installation der Clienthilfsprogramme erfordert Administratorberechtigungen). Um die Client-Dienstprogramme zu installieren, führen Sie das HPC Pack-Installationsprogramm auf Dem Desktop aus. Sie bietet eine Option zum Installieren nur der Client-Dienstprogramme.
Zusammenfassung
Sie sollten jetzt folgendes haben:
Ein Microsoft HPC-Cluster ist installiert und konfiguriert.
Excel 2016 (oder höher) auf den Cluster-Computeknoten installiert.
Ein Netzwerkfreigabeverzeichnis.
Excel 2016 (oder höher) und die Auf dem Desktop installierten Windows HPC Pack-Clientprogramme.
Wenn alles fertig ist, können Sie mit dem Erstellen von Arbeitsmappen beginnen, die auf dem Cluster mit HPC Services für Excel ausgeführt werden.
Teil I: Erstellen einer Arbeitsmappe von Grund auf neu
Dieser Teil enthält die folgenden Abschnitte:
Starten einer neuen Arbeitsmappe
Vorbereiten der Arbeitsmappe
Entwerfen der Clusterberechnung
Ausführen der Arbeitsmappe im Cluster
Letzte Schritte: Benutzeroberfläche
Starten einer neuen Arbeitsmappe
Starten Sie Excel mit einer neuen Arbeitsmappe. Wir verwenden VBA. Stellen Sie daher sicher, dass die Registerkarte " Entwicklertools " im Excel-Menüband verfügbar ist.
So aktivieren Sie die Registerkarte "Entwicklertools"
Klicken Sie im Excel-Menüband auf die Registerkarte "Datei ".
Klicken Sie auf Optionen.
Wählen Sie im Dialogfeld "Excel-Optionen" die Option "Menüband anpassen " auf der linken Seite aus.
Aktivieren Sie das Kontrollkästchen neben "Entwicklertools ", und klicken Sie auf "OK ", um das Dialogfeld zu schließen.
Vorbereiten der Arbeitsmappe
Zum Vorbereiten der Arbeitsmappe müssen Sie die Makrodateien importieren und die HPC-Verweise hinzufügen.
Zum Erstellen der grundlegenden Arbeitsmappe benötigen wir zwei Makrogruppen. Der erste Satz von Makros implementiert die Frameworkfunktionen (die oben im Abschnitt "Übersicht" beschriebenen Funktionen). Diese Makros werden während der Berechnung von HPC Services für Excel-Clientbibliothek verwendet. Der zweite Satz von Makros enthält die "Steuerelement"-Funktionen – diese Makros führen die tatsächliche Berechnung aus.
Die Beispieldateien enthalten grundlegende "Skelett"-Makrodateien für jede dieser Dateien, die Sie für die ersten Schritte verwenden können. Sie müssen diese Dateien nicht verwenden - Sie können auch Eigene schreiben, wenn Sie es bevorzugen - aber die Makros selbst sind generisch, und Sie können feststellen, dass die Verwendung dieser Dateien alles ist, was Sie benötigen. Sie können diese Dateien auch ändern, um alle Änderungen vorzunehmen, die Sie für Ihre jeweilige Arbeitsmappe benötigen.
Wir müssen diesem Projekt zwei Verweise hinzufügen, um HPC-Dienste zu verwenden: Microsoft_Hpc_Excel und Microsoft_Hpc_Scheduler_Properties. Microsoft_Hpc_Excel ist die Clientbibliothek, die ein Objekt bereitstellt, mit dem wir eine Clusterberechnung steuern können. Microsoft_Hpc_Scheduler_Properties enthält Definitionen für einige clusterspezifische Felder und Typen, die wir benötigen.
Hinweis: Im obigen Abschnitt "Übersicht" haben wir die Tools als Client-/Server-Framework beschrieben. Die Clientbibliothek wurde installiert, als Sie das HPC Pack SDK installiert haben und jetzt in VBA verfügbar sind.
So importieren Sie die Makrodateien und fügen Verweise hinzu
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Klicken Sie im VBA-Editor oben in der Strukturansicht mit der rechten Maustaste auf VBA-Projekt , und klicken Sie dann auf "Datei importieren".
Suchen Sie im Dialogfeld die Projektdateien, die Sie heruntergeladen haben. Wechseln Sie in das Verzeichnis "Erste Arbeitsmappe", wählen Sie die Datei "HPC Excel Macros.bas" aus, und klicken Sie auf "OK". Dadurch wird dem Projekt die erste Makrodatei hinzugefügt, die im Ordner "Module" des VBA-Projektfensters verfügbar ist.
Wiederholen Sie die Schritte 1 bis 3, um "HPC-Steuerelementmakros.bas" zu importieren, und klicken Sie dann auf "OK". Dadurch wird dem Projekt die zweite Makrodatei hinzugefügt.
Stellen Sie sicher, dass diese beiden Makrodateien im VBA-Projektfenster angezeigt werden:
Klicken Sie im VBA-Editorfenster auf "Extras" und dann auf "Verweise ", um das Dialogfeld "Projektverweise" zu öffnen.
Scrollen Sie in der Liste der verfügbaren Verweise nach unten, bis Sie MICROSOFT (R) HPC Pack Assemblies finden, und aktivieren Sie das Kontrollkästchen neben den einzelnen Assemblys. Wenn Sie die Kontrollkästchen aktiviert haben, sieht das Dialogfeld wie folgt aus:
Klicken Sie auf 'OK' , um das Dialogfeld "Projektverweise" zu schließen.
Wenn Sie diesen Eintrag in der Liste nicht finden, klicken Sie auf "Durchsuchen". Und suchen Sie die Datei %CCP_HOME%\Bin\Microsoft.Hpc.Excel.tlb. Wenn Sie es immer noch nicht finden können, stellen Sie sicher, dass Sie die HPC Pack-Clientkomponenten installiert haben. Wenn die Dateien installiert sind, zeigt die Systemsteuerung "Programme hinzufügen/entfernen" einen Eintrag für "Microsoft HPC Pack Client Components" an. Wenn dieser Eintrag nicht angezeigt wird, versuchen Sie, die Clientkomponenten wie im obigen Abschnitt "Vor dem Start" beschrieben erneut zu installieren.
Definieren der Berechnungen im Makroframework
Unser Ziel beim Erstellen dieser Arbeitsmappe ist es, zu veranschaulichen, wie eine Clusterberechnung funktioniert, daher müssen wir keine sehr komplizierte Tabelle erstellen. Wir erstellen eine Berechnung, die 100 einzelne Schritte ausführt. Dazu fügen wir der HPC-Excel-Makrodatei einen Zähler hinzu und verwenden diesen Indikator in den Makros, wenn die Berechnung ausgeführt wird.
Wir verwenden den Zähler, um nachzuverfolgen, wie viele Berechnungsschritte gesendet wurden, damit wir die Berechnung auf 100 Schritte beschränken können. HPC_Initialize wird immer aufgerufen, wenn wir eine neue Berechnung starten, sodass wir den Zähler in dieser Funktion zurücksetzen können. Wir möchten den Zähler für jeden Berechnungsschritt inkrementieren. Dies ist im HPC_Partition Makro möglich. Denken Sie daran, dass das HPC_Partition Makro verwendet wird, um alle Daten zu sammeln, die für einen einzelnen Berechnungsschritt erforderlich sind; und sobald die Berechnung abgeschlossen ist, sollte das HPC_Partition Makro Null zurückgeben. Um eine Berechnung für 100 Schritte auszuführen, erhöhen wir den Zähler jedes Mal, wenn HPC_Partition aufgerufen wird; und sobald der Zähler 100 erreicht hat, geben wir Null zurück.
So erstellen Sie eine Berechnung, die 100 Schritte ausführt
Doppelklicken Sie im VBA-Projektfenster im Ordner "Module " auf HPCExcelMacros.
Fügen Sie oben in der Datei in "Abschnitt 1: Variablen und Konstanten" eine Zählervariable namens "SentRecords" hinzu, wie unten dargestellt:
'========================================================== ' ' Section 1: Variables and constants ' '========================================================== Dim SentRecords As IntegerScrollen Sie nach unten, bis Sie die HPC_Initialize-Funktion finden, und fügen Sie eine Zeile hinzu, um die Zählervariable zurückzusetzen:
'---------------------------------------------------------- ' ' HPC_Initialize will be called when the client starts ' a calculation. Put any pre-calculation steps in this ' function. ' '---------------------------------------------------------- Public Function HPC_Initialize() SentRecords = 0 End FunctionScrollen Sie nach unten, bis Sie das Makro HPC_Partition finden, und ändern Sie es so, dass es wie folgt aussieht:
Public Function HPC_Partition() As Variant If SentRecords = 100 Then HPC_Partition = Null Else SentRecords = SentRecords + 1 HPC_Partition = SentRecords End If End FunctionSpeichern Sie die Arbeitsmappe.
Hinweis: Da die neue Arbeitsmappe Makros enthält, müssen Sie sie entweder als Arbeitsmappe mit Makros (XLSM-Datei) oder als XLSB-Datei (Binärarbeitsmappe) speichern. Beides ist in Ordnung. In der Regel wird empfohlen, Arbeitsmappen als binäre Dateien (XLSB) zu speichern, da sie kleiner und etwas effizienter sind.
Jetzt haben wir eine Berechnung, die 100 Schritte ausführt und dann abgeschlossen ist. Die soeben vorgenommenen Änderungen sind alles, was Sie tun müssen, um eine Excel-Clusterberechnung zu erstellen.
Lokales Ausführen der Arbeitsmappe und Untersuchen der Makros
Nachdem wir nun eine Berechnung haben, können wir eine Schaltfläche hinzufügen, um die Arbeitsmappe auszuführen, und dann die Arbeitsmappe auf dem Desktop ausführen. Um zu sehen, wie die Makros funktionieren, fügen wir ein paar neue Codeteile zu unserer Makrovorlage hinzu und führen die Arbeitsmappe erneut aus, um zu sehen, was die Änderungen getan haben. Wir testen die Arbeitsmappe lokal (auf dem Desktop), bevor die Arbeitsmappe auf dem Cluster ausgeführt wird.
Hinzufügen einer Schaltfläche, die die Arbeitsmappe lokal ausführt
So fügen Sie eine Schaltfläche hinzu, die die Arbeitsmappe lokal ausführt
Klicken Sie bei geöffneter Excel-Arbeitsmappe auf die Registerkarte " Entwicklertools " im Menüband.
Klicken Sie auf der Registerkarte " Entwicklertools " auf "Einfügen ", und wählen Sie dann das Schaltflächensteuerelement aus – das erste Steuerelement in der Liste.
Nachdem Sie auf die Schaltfläche geklickt haben, zeichnen Sie ein Rechteck an einer beliebigen Stelle auf der Kalkulationstabelle, um die Schaltfläche an dieser Stelle einzufügen. Nachdem Sie die Schaltfläche positioniert haben, wird das Dialogfeld "Makro zuweisen " angezeigt.
Wählen Sie im Dialogfeld das Makro CalculateWorkbookOnDesktop aus der Liste aus, und klicken Sie dann auf OK. Achten Sie darauf, das Desktopmakro auszuwählen – wir möchten die Arbeitsmappe zuerst testen und alle Fehler finden, bevor sie im Cluster ausgeführt werden.
Klicken Sie mit der rechten Maustaste auf die neue Schaltfläche, und wählen Sie dann "Text bearbeiten " aus, um die Beschriftung zu ändern.
Nennen Sie die Bezeichnung "Desktop" oder etwas ähnliches.
Optional können Sie überprüfen, ob Sie das richtige Makro zugewiesen haben, indem Sie mit der rechten Maustaste auf die Schaltfläche klicken und "Makro zuweisen" auswählen. Überprüfen Sie im Dialogfeld, ob CalculateWorkbookOnDesktop ausgewählt ist.
Speichern Sie die Arbeitsmappe.
Klicken Sie auf die Schaltfläche, um die Arbeitsmappe auf dem Desktop auszuführen.
Wenn Fehler vorhanden sind, wird ein Fehlerdialogfeld angezeigt, und der Teil des VBA-Codes mit dem Fehler wird hervorgehoben . Wechseln Sie zurück zu den obigen Abschnitten, und überprüfen Sie, ob alles korrekt aussieht.
Wenn alles funktioniert, geschieht nichts, weil unsere Arbeitsmappe nichts tut. Dies ist ein wenig unbefriedigend, also nehmen wir ein paar weitere Änderungen vor, damit wir die Berechnung sehen können.
Ändern der HPC_Excecute und der HPC_Merge Makros
Denken Sie daran, dass der Informationsfluss von HPC_Partition (die die für die Berechnung erforderlichen Parameter erfasst), zu HPC_Execute (die die Berechnung ausführt) und dann zu HPC_Merge (die das Ergebnis verarbeitet). Wenn eine Berechnung ausgeführt wird, wird alles, was vom HPC_Partition Makro zurückgegeben wird, als Eingabe für das HPC_Execute Makro verwendet. Das HPC_Execute Makro ist so konzipiert, dass diese Eingabedaten verwendet werden, einige Berechnungsschritte ausgeführt und dann ein Ergebnis zurückgegeben werden. Das Ergebnis wird dann an HPC_Merge übergeben, wodurch die Ergebnisse in die Kalkulationstabelle eingefügt werden können.
In einem früheren Schritt haben Sie dem HPC_Partition Makro Code hinzugefügt, um eine Zählervariable zu aktualisieren. In unserem Beispiel gibt HPC_Partition den Wert der Zählervariable zurück und übergibt diesen Wert an HPC_Execute. Um den Informationsfluss zu veranschaulichen und unsere Arbeitsmappe einige Ergebnisse zurückzugeben, übergeben wir einfach diesen Leistungsindikatorwert durch die Makros. Wir fügen dem HPC_Execute Makro eine Codezeile hinzu, sodass die Eingabe verwendet und als Rückgabewert übergeben wird. Der Wert unserer Zählervariable übergibt dann an das HPC_Merge Makro, das wir so ändern, dass er den Wert des Zählers in unsere Kalkulationstabelle einfügt.
So ändern Sie HPC_Execute und HPC_Merge
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Doppelklicken Sie im VBA-Editor in der Projektstruktur auf das HPCExcelMacros-Modul , um die Makrodatei zu öffnen.
. Scrollen Sie zum HPC_Execute Makro, und fügen Sie eine Codezeile hinzu, die den Eingabewert als Rückgabewert übergibt. Das Makro sollte wie folgt aussehen:
Public Function HPC_Execute(data As Variant) As Variant HPC_Execute = data End FunctionScrollen Sie zum HPC_Merge Makro, und fügen Sie eine Codezeile hinzu, um den Eingabewert in die Kalkulationstabelle einzufügen. Das Makro sollte wie folgt aussehen:
Public Function HPC_Merge(data As Variant) Cells(data, 1).Value = data End FunctionHinweis: Der Wert "data" ist der Zähler, der von HPC_Execute zurückgegeben wurde. Hier im makro HPC_Merge füllen wir also eine Zelle in der Kalkulationstabelle ein , wobei der Zähler als Zeilennummer verwendet wird und der Wert als Zähler festgelegt wird. Der VBA-Ausdruck "Cells" bedeutet, einen Verweis in der Kalkulationstabelle mit den angegebenen Zeilen- und Spaltennummern zu erstellen. Jedes Mal, wenn das HPC_Merge Makro aufgerufen wird, fügt es einen Wert in Spalte 1 (Spalte A in der Kalkulationstabelle) mit einer anderen Zeilennummer ein.
Kehren Sie nun zur Kalkulationstabelle zurück, und klicken Sie auf die Schaltfläche "Desktop", um die Berechnung auszuführen.
Die erste Spalte wird mit Zahlen von 1 bis 100 gefüllt, bei denen es sich um die Gegenwerte handelt. Jedes Mal, wenn Sie auf die Schaltfläche klicken, füllt sie dieselben Zahlen aus, daher ist es schwer zu erkennen, dass sie ausgeführt wird. wir können eine weitere kleine Änderung vornehmen, um die Zahlen zu sehen, die ausgefüllt werden.
Ändern des HPC_Initialize-Makros
Das HPC_Initialize Makro wird aufgerufen, wenn die Arbeitsmappe zum ersten Mal ausgeführt wird. In einem früheren Schritt haben wir eine Codezeile hinzugefügt, um die Zählervariable zurückzusetzen. Wir können dieses Makro auch verwenden, um die Werte zu löschen, die während der vorherigen Ausführung in die Kalkulationstabelle eingefügt wurden.
So ändern Sie das HPC_Initialize-Makro
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Doppelklicken Sie im VBA-Editor in der Projektstruktur auf das HPCExcelMacros-Modul , um die Makrodatei zu öffnen.
Scrollen Sie zum HPC_Initialize makro**.** Fügen Sie eine Codezeile hinzu, die die erste Spalte geleert. Das Makro sollte wie folgt aussehen:
Public Function HPC_Initialize() Range("A:A").Value = "" SentRecords = 0 End FunctionKehren Sie nun zur Kalkulationstabelle zurück, und klicken Sie auf die Schaltfläche "Desktop", um die Berechnung auszuführen.
Es sollte jetzt offensichtlich sein, dass das Makro die Spalte bei jedem Klicken mit Zahlen einfüllt. Wenn Fehler vorhanden sind, wird eine Fehlermeldung angezeigt, und der VBA-Code mit dem Fehler wird hervorgehoben . Überprüfen Sie, ob sie dem oben aufgeführten Code entspricht, und versuchen Sie es erneut.
Ausführen der Arbeitsmappe im Cluster
Jetzt haben wir eine sehr einfache Excel-Berechnung mit dem HPC-Makroframework, und wir können sie auf dem Cluster ausführen. Dazu müssen wir zunächst einige Werte festlegen, um Excel mitzuteilen, wie der Cluster kontaktiert werden soll. Diese Werte werden im HPCControlMacros-Modul **.** Oben in dieser Datei definiert, müssen Sie zwei Werte eingeben: den Clusterplaner und das Freigabeverzeichnis. Denken Sie daran, dass Sie (der Desktopbenutzer) Schreibzugriff auf dieses Freigabeverzeichnis haben müssen; und die Cluster-Computeknoten müssen über Lesezugriff auf das Verzeichnis verfügen. In den meisten Fällen werden Ihre Clusterberechnungen unter Ihrem Benutzerkonto ausgeführt, aber es ist möglich, ein anderes Benutzerkonto zu verwenden, wenn Sie eine Verbindung mit der Clustersitzung herstellen (mehr dazu in einem Moment).
So geben Sie den Kopfknoten und das Freigabeverzeichnis an
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Doppelklicken Sie im VBA-Editor in der Projektstruktur auf das HPCControlMacros-Modul , um die Makrodatei zu öffnen.
Verwenden Sie für den Clusterplaner den Namen des Clusterkopfknotens – dies ist der Computername, den Sie im Netzwerk verwenden würden. Sie können einen vollqualifizierten Namen (z. B. headnode.mynetwork.com) verwenden, dies ist jedoch nicht erforderlich, wenn Sie sich in derselben Domäne befinden.
Verwenden Sie für das Freigabeverzeichnis den vollständigen Pfad zu dem zuvor erstellten Freigabeverzeichnis (im Abschnitt "Bevor Sie beginnen").
Beispielsweise lautet in meinem Cluster der Planername "HN01"; und ich habe ein Freigabeverzeichnis auf dem Kopfknoten namens "HPCTemp" erstellt. Meine Einstellungen sehen also wie folgt aus:
'----------------------------------------------------------
'
' This is the cluster scheduler, or head node. Fill in
' the hostname of your cluster scheduler.
'
'----------------------------------------------------------
Private Const HPC_ClusterScheduler = "HN01"
'----------------------------------------------------------
'
' This is a network share used to store a temporary copy
' of the workbook. Make sure that the directory exists,
' that you have write access to the directory, and that
' the compute nodes in the cluster have read access.
'
'----------------------------------------------------------
Private Const HPC_NetworkShare = "\\HN01\HPCTemp"
Kehren Sie nun zur Excel-Tabelle zurück. Wir fügen eine weitere Schaltfläche hinzu, diesmal zum Ausführen der Berechnung auf dem Cluster.
So fügen Sie eine Schaltfläche hinzu, mit der die Arbeitsmappe im Cluster ausgeführt wird
Klicken Sie auf der Registerkarte " Entwicklertools " auf "Einfügen ", und wählen Sie dann das Schaltflächensteuerelement aus – das erste Steuerelement in der Liste.
Nachdem Sie auf die Schaltfläche geklickt haben, zeichnen Sie ein Rechteck an einer beliebigen Stelle auf der Kalkulationstabelle, um die Schaltfläche an dieser Stelle einzufügen. Nachdem Sie die Schaltfläche positioniert haben, wird das Dialogfeld "Makro zuweisen " angezeigt.
Wählen Sie im Dialogfeld das Makro CalculateWorkbookOnCluster aus der Liste aus, und klicken Sie dann auf OK.
Klicken Sie mit der rechten Maustaste auf die neue Schaltfläche, und wählen Sie dann "Text bearbeiten " aus, um die Beschriftung zu ändern.
Benennen Sie die Bezeichnung "Cluster" oder etwas ähnliches.
Speichern Sie die Arbeitsmappe.
Klicken Sie auf die Schaltfläche, um die Arbeitsmappe auf dem Cluster auszuführen.
Wenn Sie zum ersten Mal Clusteraufträge ausführen, entweder excel oder eine andere Anwendung verwenden, wird ein Dialogfeld für die Benutzerauthentifizierung angezeigt. Geben Sie Ihren Benutzernamen und Ihr Kennwort ein, und aktivieren Sie (wenn Sie möchten) das Kontrollkästchen, um Ihre Anmeldeinformationen zu speichern. Wenn Sie Berechnungen auf dem Cluster als anderen Benutzer ausführen möchten, können Sie unterschiedliche Benutzerkontoeinstellungen eingeben.
Hinweis: Stellen Sie sicher, dass Ihr Benutzerkonto – entweder Ihr Standardbenutzerkonto oder alles, was Sie verwenden möchten – als Clusterbenutzer im HPC Cluster Manager festgelegt ist.
Wenn Fehler auftreten, wird ein Meldungsfeld angezeigt, in dem der Fehler beschrieben wird. Wenn die Berechnung auf dem Desktop funktioniert hat, müssen die wahrscheinlichsten Fehler, die Sie jetzt erhalten, mit den Clustereinstellungen zu tun haben – den Kopfknoten oder das Freigabeverzeichnis. Wenn das Meldungsfeld einen dieser Fehler beschreibt, überprüfen Sie die Einstellungen, die Sie im letzten Schritt geändert haben. Stellen Sie sicher, dass Sie über den richtigen Namen für den Clusterkopfknoten verfügen und dass das Freigabeverzeichnis von Ihrem Benutzerkonto beschreibbar ist.
Was geschieht, wenn eine Arbeitsmappe im Cluster ausgeführt wird
Sehen wir uns an, was passiert, wenn Sie die Clusterberechnung ausführen. Wenn Sie auf die Schaltfläche klicken, wird das Makro CalculateWorkbookOnCluster aufgerufen. Dieses Makro verwendet die Clientbibliothek, um eine Clusterberechnung mit den Einstellungen zu starten, die Sie für den Clusterkopfknoten und das Freigabeverzeichnis bereitgestellt haben.
Wenn die Berechnung gestartet wird, übernimmt der HPC Services für Excel-Clientcode die Übernahme. Denken Sie daran, dass Sie am Anfang dieses Teils einen Verweis auf die HPC-Bibliothek im VBA-Editor hinzugefügt haben – das ist die Clientbibliothek. Zuerst erstellt die Clientbibliothek eine Clustersitzung, die zum Verwalten der Berechnung verwendet wird. Das dauert ein paar Sekunden, und nachdem Sie auf die Schaltfläche geklickt haben, werden Sie einige Sekunden verzögerung bemerken.
Als Nächstes ruft die Clientbibliothek das HPC_Initialize Makro auf. Dies geschieht auf dem Desktop. In dieser Arbeitsmappe setzt dieses Makro (1) den internen Zähler zurück; und (2) leert Spalte A in der Kalkulationstabelle. Wenn Sie also auf die Schaltfläche klicken, sehen Sie zuerst die Verzögerung, während die Sitzung erstellt wird. und dann wird Spalte A gelöscht. Das ist das HPC_Initialize Makro.
Als Nächstes startet die Clientbibliothek mit dem Aufrufen des HPC_Partition-Makros. Dies geschieht auch auf dem Desktop. In unserem Code erhöht das HPC_Partition Makro den Zähler und gibt den Zählerwert zurück. Jedes Mal, wenn dieses Makro einen Wert zurückgibt – bis er Null zurückgibt, sendet die Clientbibliothek eine Anforderung an den HPC-Scheduler.
Wenn der Scheduler eine dieser Anforderungen empfängt, leitet er die Anforderung zur Verarbeitung an einen der Cluster-Computeknoten weiter. Wenn der Computeknoten die Anforderung empfängt, startet er Excel, lädt die Arbeitsmappe und ruft dann das HPC_Execute Makro auf.
Dies ist das HPC_Execute Makros, das wir in unserer Arbeitsmappe haben, aber wenn die Berechnung auf dem Cluster ausgeführt wird, wird das HPC_Execute Makro tatsächlich auf den Computeknoten ausgeführt – im Gegensatz zu allen anderen Makros. Deshalb übergeben wir Daten von einem Makro an ein anderes. Informationen fließen von einem Makro zum nächsten, aber wenn Daten vom HPC_Partition Makro an das HPC_Execute Makro übergeben werden, wird es vom Desktop, über den HPC-Scheduler und an einen der Computeknoten gesendet.
Nachdem eines der Computeknoten das HPC_Execute Makro ausgeführt hat, wird das Ergebnis der Berechnung abgeschlossen – der vom HPC_Execute Makro zurückgegebene Wert – zurück an den Zeitplan gesendet und dann an die Clientbibliothek auf dem Desktop zurückgegeben. Wenn die Clientbibliothek das Berechnungsergebnis empfängt, wird das HPC_Merge Makro auf dem Desktop aufgerufen. Sie können sich also wieder informationen vorstellen, die von einem Makro (HPC_Execute) zum nächsten (HPC_Merge) fließen, aber dies geschieht über das Netzwerk: von der Arbeitsmappe, die auf dem Computeknoten ausgeführt wird, zur Arbeitsmappe, die auf dem Desktop ausgeführt wird.
Es ist wichtig zu verstehen, dass diese Makrofunktion aufruft – jedes der Aufrufe an HPC_Partition, während wir Daten an den Cluster senden, und jeder Aufruf der HPC_Merge, da Daten empfangen werden – asynchron erfolgen. Das heißt, wenn eine Berechnung an den Cluster gesendet wird, wartet (oder blockiert) die Clientbibliothek erst, wenn diese bestimmte Berechnung abgeschlossen ist, bevor sie das nächste sendet. Wenn das HPC_Partition Makro sehr schnell ist, wie in diesem Fall, ist es möglich, dass alle 100 Berechnungsanforderungen gesendet werden, bevor eine dieser Anforderungen abgeschlossen ist.
Es ist auch erwähnenswert, dass die Ergebnisse aus dem Cluster zurückkommen - und das HPC_Merge Makro in unserer Arbeitsmappe aufgerufen wird - sie kommen möglicherweise nicht in der gleichen Reihenfolge zurück, in der wir sie gesendet haben. Das liegt daran, dass der Scheduler, da jede Anforderung an den Cluster gesendet wird, an einen bestimmten Computeknoten weiterleite. Der Berechnungsknoten berechnet die Anforderung mithilfe des HPC_Execute Makros in der Arbeitsmappe und sendet dann das Ergebnis zurück. Aus verschiedenen Gründen kann ein Computeknoten jedoch langsamer oder schneller ausgeführt werden als ein anderer Berechnungsknoten; and if that happens, results might be returned in a different order.
In dieser Arbeitsmappe werden Sie wahrscheinlich nicht feststellen, dass die Makros so einfach sind. Aber es ist etwas, auf das wir in komplizierteren Arbeitsmappen vorbereiten müssen, da wir längere Berechnungsfunktionen haben, und wir werden es unten behandeln, wenn wir eine "echte" Arbeitsmappe erstellen.
Kommunizieren des Berechnungsfortschritts
An diesem Punkt haben Sie eine vollständige Arbeitsmappe erstellt, die auf dem HPC-Cluster ausgeführt wird. Sie sollten nun verstehen, was die verschiedenen Makros tun und warum sie so konzipiert sind, wie sie sind. Sie sollten wissen, wie Daten zwischen den Makros verschoben werden und welche Teile auf dem Desktop und im Cluster ausgeführt werden.
Bevor wir mit der einfachen Arbeitsmappe fertig sind, können wir einige abschließende Änderungen vornehmen, um visuelles Feedback hinzuzufügen – im Grunde eine einfache Benutzeroberfläche. Wenn Sie die Arbeitsmappe auf dem Cluster ausgeführt haben, war das einzige Feedback, dass sie funktionierte, die Zahlen, die in der Tabelle ausgefüllt wurden. Das ist ein Anfang, aber wir können einige Änderungen vornehmen, die es deutlicher machen, was die Arbeitsmappe tut. Wir werden einige weitere Variablen hinzufügen, um die Berechnung nachzuverfolgen und dann in der Excel-Statusleiste anzuzeigen.
Unser Code enthält die folgenden Leistungsindikatoren:
Wir haben bereits eine Zählervariable, die nachverfolgt, wie oft HPC_Partition Makro aufgerufen wurde. Dies stellt die Häufigkeit dar, mit der Daten vom Desktop an den Cluster gesendet wurden.
Wir können einen weiteren Leistungsindikator hinzufügen, der jedes Mal erhöht wird, wenn das HPC_Merge-Makro aufgerufen wird . Dies stellt dar, wie oft Daten vom Cluster auf den Desktop zurückgesendet wurden.
Wir können auch einige Variablen hinzufügen, um die Zeit nachzuverfolgen – wie lange die Berechnung dauert. Dies kann wirklich nützlich sein, um zu überprüfen, ob die Clusterberechnung tatsächlich schneller als der Desktop ist (und wenn ja, wie viel schneller).
Anhand dieser ersten beiden Leistungsindikatoren können wir die Anzahl der ausstehenden Anforderungen sehen und einen Überblick über den gesamten Fortschritt der Berechnung erhalten. Wir fügen eine neue VBA-Funktion hinzu, die den Berechnungsstatus melden kann. Diese Funktion weist drei Teile auf:
Es erstellt eine Zeichenfolge mit der Anzahl der gesendeten Berechnungen (die Anzahl der Aufrufe HPC_Partition ) und die Anzahl der zurückgegebenen Ergebnisse (die Anzahl der HPC_Merge aufgerufen wurde).
Wenn die Variable "CalculationComplete" wahr ist, wird die Zeichenfolge aktualisiert, um die Gesamtberechnungszeit anzuzeigen.
Es verwendet Application.StatusBar, um die Excel-Statusleistenmeldung mit den soeben erstellten Informationen festzulegen.
Wir können die HPC-Makros verwenden, die bereits vorhanden sind, um diese Werte zu aktualisieren und die Statusleistenmeldung mit der neuen Funktion zu aktualisieren.
Im folgenden Verfahren wird beschrieben, wie sie diese neuen Elemente in unser Beispiel integrieren.
So fügen Sie den Makros Statusvariablen hinzu, und aktualisieren Sie die Excel-Statusleiste
Wechseln Sie zurück zum VBA-Editor, und doppelklicken Sie auf das Modul HPCExcelMacros , um den Makrocode zu öffnen. Fügen Sie oben im VBA-Code nach dem ursprünglichen Zähler die folgenden neuen Variablen hinzu:
'========================================================== ' ' Section 1: Variables and constants ' '========================================================== Dim SentRecords As Integer Dim RcvRecords As Integer Dim CalculationComplete As Boolean Dim StartTime As Double Dim FinishTime As DoubleAls Nächstes fügen wir eine neue VBA-Funktion namens "UpdateStatus" hinzu, die den Berechnungsstatus melden kann. Scrollen Sie nach unten nach unten in der Datei, und fügen Sie Code wie folgt hinzu:
Sub UpdateStatus() Dim statusMessage As String statusMessage = "Calculated " & RcvRecords & "/" & SentRecords If CalculationComplete Then statusMessage = statusMessage & "; Completed in " & _ FormatNumber(FinishTime - StartTime) & "s" End If Application.StatusBar = statusMessage End SubWir müssen die Variablen initialisieren. Wie bei dem ursprünglichen Zähler werden wir dies im HPC_Initialize-Makro tun. Scrollen Sie zu diesem Makro, und fügen Sie einige Zeilen hinzu:
Public Function HPC_Initialize() Range("A:A").Value = "" SentRecords = 0 RcvRecords = 0 StartTime = Timer CalculationComplete = False UpdateStatus End FunctionHinweis: Was wir hier tun, ist (1), die beiden Zähler zu löschen, und legen sie auf Null fest. (2) Festlegen des Werts "StartTime" auf die aktuelle Uhrzeit (der Aufruf "Timer" in VBA gibt die aktuelle Uhrzeit in Sekunden zurück); und (3) das Flag "CalculationComplete" auf "false" festlegen, was bedeutet, dass es noch nicht abgeschlossen wurde. Sobald diese Werte festgelegt wurden, rufen wir das neue "UpdateStatus"-Makro auf, um die Nachricht in die Statusleiste zu schreiben.
Scrollen Sie nach unten zum HPC_Partition Makro. In diesem Makro legen wir bereits den ersten Zähler fest, daher müssen wir nur eine Änderung vornehmen: Nach dem Aktualisieren des Zählers fügen wir eine Zeile hinzu, um das neue Makro aufzurufen und die Statusleiste zu aktualisieren.
Public Function HPC_Partition() As Variant If SentRecords = 100 Then HPC_Partition = Null Else SentRecords = SentRecords + 1 UpdateStatus HPC_Partition = SentRecords End If End FunctionScrollen Sie nun nach unten zum HPC_Merge Makro. Hier möchten wir den neuen Leistungsindikator aktualisieren – das, das Nachrichten darstellt, die zurück auf den Desktop zurückgegeben wurden - und die Statusleiste erneut aktualisieren. Ändern Sie daher das HPC_Merge-Makro :
Public Function HPC_Merge(data As Variant) Cells(data, 1).Value = data RcvRecords = RcvRecords + 1 UpdateStatus End FunctionScrollen Sie nach unten zum HPC_Finalize Makro. Dieses Makro wird aufgerufen, wenn die gesamte Berechnung abgeschlossen ist; so können wir dies verwenden, um das Flag "CalculationComplete" festzulegen, und um herauszufinden, wie lange die Gesamtberechnung dauerte:
Public Function HPC_Finalize() CalculationComplete = True FinishTime = Timer UpdateStatus ' Clean up the calculation. It's a good idea to ' leave this here, even if you make changes to ' this function. The function we call here is in ' the "HPCControlMacros" module. CleanUpClusterCalculation End FunctionHinweis: Wenn wir das Feld "FinishTime" auf "Timer" festlegen, legen wir es in Sekunden mit der aktuellen Uhrzeit fest. Im UpdateStatus-Makro verwenden wir die "StartTime" und "FinishTime", um die Gesamtberechnungszeit zu ermitteln.
Speichern der Arbeitsmappe
Wechseln Sie zurück zur Excel-Tabelle, und klicken Sie auf die Schaltfläche "Cluster".
Während der Ausführung der Berechnung wird die Statusleiste mit Zahlen aktualisiert. Zuerst sehen Sie die Anzahl der gesendeten Berechnungen (die zweite Zahl) bis zu 100, und nach einer kurzen Verzögerung wird die Anzahl der empfangenen Ergebnisse (die erste Zahl) bis zu 100 steigen.
Was Sie hier sehen, ist das asynchrone Messaging, das wir oben erläutert haben. Da das HPC_Partition Makro so schnell ist, kann die Clientbibliothek alle 100 Anforderungen senden, bevor eine der Berechnungen abgeschlossen ist. Es gibt eine kurze Verzögerung – bei dieser Verzögerung handelt es sich um die Rechenknoten, die Excel starten und die Arbeitsmappe laden. Sobald jeder Berechnungsknoten Excel gestartet hat, ist die Berechnung der Ergebnisse ziemlich schnell, und die erste Zahl wird schnell bis zu 100.
Wenn Sie auf die Schaltfläche "Desktop" klicken, sehen Sie, dass die Zahlen anders verschoben werden. Auf dem Desktop ruft die Clientbibliothek dieselben Makros auf, aber sie wird synchron ausgeführt (d. a. nicht asynchron). Zum Ausführen der Desktopberechnung ruft die Clientbibliothek jedes Makro wiederum auf – zuerst HPC_Partition, dann HPC_Execute und dann HPC_Merge – in diesem Fall wartet die Clientbibliothek jedoch, bis jedes Makro abgeschlossen ist, bevor das nächste Makro aufgerufen wird. Aus diesem Grund werden beim Ausführen auf dem Desktop beide Zahlen zusammen angezeigt.
Teil 2: Konvertieren einer "Desktop"-Arbeitsmappe für die Ausführung auf dem HPC-Cluster
Im letzten Abschnitt haben wir eine Arbeitsmappe von Grund auf erstellt, um sie auf einem HPC-Cluster zu berechnen. In diesem Abschnitt nehmen wir eine vorhandene Arbeitsmappe und ändern sie so, dass sie auf dem Cluster ausgeführt wird. Wenn Sie den letzten Teil befolgt haben, sollten Sie wissen, was erforderlich ist - obwohl es viele einzelne Schritte gab, war die eigentliche Arbeit sehr einfach. Zusammenfassend:
Es wurden zwei Makrodateien hinzugefügt.
Dem VBA-Projekt wurden zwei Verweise hinzugefügt.
Einige Änderungen an den Makros vorgenommen.
Schaltflächen zum Ausführen der Kalkulationstabelle hinzugefügt.
Das Konvertieren einer vorhandenen Arbeitsmappe ist ungefähr die gleiche Arbeitsmenge. Es gibt nicht viele neue VBA-Code zum Hinzufügen, und die meisten, wenn sie die gleichen Skelettmakrodateien wiederverwenden können. Die Konvertierung einer vorhandenen Arbeitsmappe umfasst größtenteils das Verschieben von Code – das Kopieren von Code aus vorhandenen Makros in die HPC-Makros.
Der schwierige Teil der Konvertierung einer vorhandenen Arbeitsmappe besteht darin, herauszufinden, welcher Code verschoben werden soll und wohin es gehen soll. Excel VBA ist eine umfassende Entwicklungsumgebung, und es gibt viele Möglichkeiten zum Erstellen von Excel-Anwendungen: Verschiedene Entwickler schreiben möglicherweise dieselbe Anwendung auf viele verschiedene Arten.
In diesem Abschnitt nehmen wir eine vorhandene Arbeitsmappe auf und konvertieren sie in die Ausführung auf dem Cluster. Sie sollten diesen Abschnitt als Leitfaden oder als Beispiel lesen und dann versuchen, die Konzepte auf Ihre eigenen Arbeitsmappen anzuwenden. Wir haben in diesem Fall ein ziemlich einfaches Beispiel (obwohl es auf einer echten Arbeitsmappe basiert, die zum Lösen eines echten Geschäftsproblems verwendet wurde). Bei fast jeder Arbeitsmappe ist der Prozess identisch, aber die spezifischen Details sind unterschiedlich.
Analysieren der Arbeitsmappe
Öffnen Sie in Excel die Arbeitsmappe "ConvertiblePricing.xlsb" aus dem Verzeichnis "Second Workbook". Möglicherweise erhalten Sie eine Warnung zu Makros; Klicken Sie in diesem Beispiel auf "Makros aktivieren", um den Vorgang fortzusetzen.
In dieser Arbeitsmappe werden wandelbare Schuldverschreibungen basierend auf den Werten im Abschnitt "Modellparameter" auf der linken Seite berechnet. Die Tabelle auf der rechten Seite wird verwendet, um zu verstehen, welche Auswirkungen kleine Änderungen in den Parametern haben - Änderungen des Umwandlungspreises und im Zinssatz - auf den Endpreis.
Klicken Sie in der Tabelle auf die Schaltfläche "Tabelle berechnen". Die Tabelle wird langsam ausgefüllt, da jeder Preis berechnet wird. Auf einer typischen Arbeitsstation dauert das Ausfüllen des kompletten Tisches zwischen 1 und 2 Minuten.
Um herauszufinden, was diese Arbeitsmappe bewirkt, wenn wir auf die Schaltfläche klicken, können wir den VBA-Code durchgehen.
So identifizieren Sie das Makro und sehen den Code
Klicken Sie mit der rechten Maustaste auf die Schaltfläche "Tabelle berechnen", und wählen Sie "Makro zuweisen" aus.
Das Makrodialogfeld zeigt an, welches Makro derzeit von der Schaltfläche verwendet wird. Klicken Sie im Dialogfeld auf "Bearbeiten ", um in den Code zu springen. Der Code für das Makro "CalculateTable" sollte angezeigt werden. Dies ist der Code, der ausgeführt wird, wenn Sie auf die Schaltfläche in der Kalkulationstabelle klicken.
Wenn Sie sich dieses Makro ansehen, können Sie einige unterschiedliche Abschnitte sehen. Zunächst gibt es einige Variablendeklarationen. Als Nächstes gibt es einen Initialisierungscode. Schließlich gibt es einen Abschnitt, der die Tabelle berechnet – wir können ermitteln, wo sie über die Zeilen und Spalten in der Tabelle schleift und Werte ausfüllt.
Dieses Makro ist relativ kurz, aber wenn Sie sich die Schleife ansehen, werden Sie feststellen, dass es einige andere Funktionen aufruft – die Funktionen "FullDiscountModel" und "BondPlusOptionModel". Hierbei handelt es sich um die tatsächlichen Berechnungsroutinen, die Geschäftslogik, die diese Arbeitsmappe unterstützt.
Im VBA-Editor können Sie zur Quelle einer beliebigen Funktion springen, indem Sie mit der rechten Maustaste auf den Namen klicken und "Definition" auswählen. Wenn Sie mit der rechten Maustaste auf "FullDiscountModel" klicken und "Definition" auswählen, sehen Sie, dass die tatsächliche Berechnung ziemlich komplex ist. Um die Arbeitsmappe jedoch so zu konvertieren, dass sie auf dem Cluster ausgeführt wird, müssen wir diese Berechnung nicht ändern oder sogar verstehen. Wir müssen uns nur um den Steuerelementcode kümmern – d. h. die Funktion, die die Schleife enthält.
Diese Arbeitsmappe ist sehr sauber gestaltet, da die Geschäftslogik in separaten Funktionen enthalten ist. In anderen Fällen kann sich der gesamte Code in einem einzigen Makro befinden, wodurch die Arbeitsmappe schwieriger zu verstehen wäre. Aber in beiden Fällen müssen wir tun, um diese Arbeitsmappe zu konvertieren, den Steuercode - die Startroutinen und die Schleifenfunktionen - und verschieben sie in die HPC-Makros.
Wir wissen auch, dass die Berechnungen in dieser Arbeitsmappe unabhängig sind. Das heißt, jede Zelle der Tabelle wird ohne Bezug auf eine andere Zelle in der Tabelle berechnet. Dies bedeutet, dass die Arbeitsmappe iterativ ist und die Parallelisierung unterstützt (wie im Abschnitt "Übersicht" oben beschrieben). Es ist möglicherweise nicht immer offensichtlich, dass Berechnungen unabhängig sind. Eine Möglichkeit, dies zu ermitteln, besteht darin, einige Testfunktionen zu schreiben , z. B. könnten wir das Makro "CalculateTable" erneut schreiben (das Makro, das aufgerufen wird, wenn Sie die Schaltfläche in der Kalkulationstabelle drücken) – um nur eine einzelne Berechnung oder eine Zelle in der Tabelle auszuführen. Auf diese Weise konnten wir ermitteln, ob die Ergebnisse konsistent waren, und wenn ja, könnten wir eine Entscheidung treffen, ob die Berechnungen tatsächlich unabhängig waren.
Zusammenfassend sind die Features, die für jede Arbeitsmappe für die Unterstützung der Ausführung in einem Microsoft HPC-Cluster am wichtigsten sind, wie folgt:
Die Arbeitsmappe ist iterativ: Sie führt die gleiche Berechnung mehrmals mit unterschiedlichen Eingabedatensätzen aus. oder es führt viele einzelne Berechnungen aus, z. B. Zeilen oder Zellen in einer Tabelle, jeweils einzeln.
Die einzelnen Berechnungen sind unabhängig: d. h., die Ergebnisse einer einzelnen Berechnung wirken sich nicht auf eine der anderen Berechnungen aus.
Beides gilt für diese Arbeitsmappe, daher ist es ein guter Kandidat für die Ausführung auf dem Cluster.
Vorbereiten der Arbeitsmappe
Wie in der letzten Arbeitsmappe müssen die ersten Änderungen, die wir vornehmen, die Einrichtung der VBA-Umgebung vornehmen. Wir können Skelettmakrodateien verwenden, um Zeit zu sparen – dazu gehören die HPC-Makros, die wir für die Berechnung benötigen.
In der letzten Arbeitsmappe haben wir einige Änderungen an den Skelettmakrodateien vorgenommen, um ein Benutzerfeedback hinzuzufügen (anzeigen des Berechnungsfortschritts in der Excel-Statusleiste). In dieser zweiten Arbeitsmappe enthalten die Skelettmakrodateien bereits diesen Statusleistencode.
So importieren Sie die Makrodateien und fügen Verweise hinzu
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Klicken Sie im VBA-Editor oben in der Strukturansicht mit der rechten Maustaste auf VBA-Projekt , und klicken Sie dann auf "Datei importieren".
Suchen Sie im Dialogfeld die Projektdateien, die Sie heruntergeladen haben. Wechseln Sie in das Verzeichnis "Zweite Arbeitsmappe", wählen Sie die Datei "HPCExcelMacros.bas" aus, und klicken Sie auf "OK".
Wiederholen Sie die Schritte 1-3, um "HPCControlMacros.bas" zu importieren, und klicken Sie dann auf "OK". Dadurch wird dem Projekt die zweite Makrodatei hinzugefügt.
Stellen Sie sicher, dass diese beiden Makrodateien im VBA-Projektfenster angezeigt werden:
Klicken Sie im VBA-Editorfenster auf "Extras" und dann auf "Verweise ", um das Dialogfeld "Projektverweise" zu öffnen.
Scrollen Sie in der Liste der verfügbaren Verweise nach unten, bis Sie Microsoft (R) HPC Pack Assemblies finden, und aktivieren Sie das Kontrollkästchen daneben. Wenn Sie das Kontrollkästchen aktiviert haben, sieht das Dialogfeld wie folgt aus:
Klicken Sie auf 'OK' , um das Dialogfeld "Projektverweise" zu schließen.
Definieren der Berechnungen im Makroframework
Wenn die VBA-Umgebung eingerichtet ist, können wir zum nächsten Schritt wechseln – die Makros ändern, um die Berechnung auszuführen. Das HPCExcelMacros-Modul enthält dieselben Makros wie in der ersten Arbeitsmappe, nur dieses Mal enthalten sie bereits die Indikatoren und den Code zum Aktualisieren der Statusleiste.
Definieren von Variablen und Kopieren von Initialisierungscode aus dem ursprünglichen Makro
Die ersten Dinge, die wir benötigen, sind Indikatoren für die Zeile und Spalte. In dieser Arbeitsmappe dividieren wir die Berechnung so, dass jede Zelle in der Tabelle separat berechnet wird. Das ursprüngliche Makro verwendet Schleifen, um jede Zelle in der Tabelle auszuführen, aber in den HPC-Makrofunktionen verwenden wir das asynchrone Framework, sodass wir die Zeilen- und Spaltennummern nachverfolgen müssen, während wir jede einzelne Berechnung senden. Wir verwenden Zeilen- und Spaltenvariablen in den Makros, um jede Zelle in der Tabelle zu durchlaufen. sie spiegeln die Zeile und Spalte wider, die wir bei jedem Schritt berechnen.
Wir kehren zum ursprünglichen Makro zurück, um zu sehen, was es beim Starten getan hat, und verschieben sie dann in das HPC_Initialize-Makro .
So legen Sie Variablen fest und ändern HPC_Initialize
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Doppelklicken Sie im VBA-Editor in der Projektstruktur auf das HPCExcelMacros-Modul , um die Makrodatei zu öffnen.
Fügen Sie oben in der Datei in "Abschnitt 1: Variablen und Konstanten" Zeilen- und Spaltenvariablen wie unten gezeigt hinzu:
'========================================================== ' ' Section 1: Variables and constants ' '========================================================== Dim CurrentRow As Integer Dim CurrentCol As Integer Dim SentRecords As Integer Dim RcvRecords As Integer Dim CalculationComplete As Boolean Dim StartTime As Double Dim FinishTime As DoubleScrollen Sie zum HPC_Initialize Makro, und initialisieren Sie die soeben eingerichteten Zeilen- und Spaltenzähler:
Public Function HPC_Initialize() CurrentRow = 1 CurrentCol = 1 ' clear counters, capture starting time and update status bar SentRecords = 0 RcvRecords = 0 StartTime = Timer CalculationComplete = False UpdateStatus End FunctionDoppelklicken Sie im VBA-Editor im VBA-Projektfenster auf das Modul "ScenarioAnalysis". Dies war die Datei mit dem ursprünglichen Makrocode. Der Initialisierungsteil ist der erste Abschnitt, der die Größe der Tabelle ermittelt und einige Variablen festlegt (NumRows und NumCols):
' clear values, then figure out the size of the table Range("cashtable").ClearContents NumCols = 1 While NumCols < MaxSensTblSize And CDbl(Range("table1").Offset(0, NumCols … NumCols = NumCols + 1 Wend NumRows = 1 While NumRows < MaxSensTblSize And _ CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> 0 And _ CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> … NumRows = NumRows + 1 WendKopieren Sie den Code aus dem ursprünglichen Makro, wechseln Sie dann zurück zum HPCExcelMacros-Modul (doppelklicken Sie im VBA-Projektfenster auf HPCExcelMacros ), und fügen Sie ihn in das HPC_Initialize Makro ein.
Der endgültige Code in HPC_Initialize sieht nun wie folgt aus:
Public Function HPC_Initialize()
' clear values, then figure out the size of the table
Range("cashtable").ClearContents
NumCols = 1
While NumCols < MaxSensTblSize And CDbl(Range("table1").Offset(0, NumCols + …
NumCols = NumCols + 1
Wend
NumRows = 1
While NumRows < MaxSensTblSize And _
CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> 0 And _
CDbl(Range("table1").Offset(NumRows + 1, 0).Value) <> …
NumRows = NumRows + 1
Wend
CurrentRow = 1
CurrentCol = 1
' clear counters, capture starting time and update status bar
SentRecords = 0
RcvRecords = 0
StartTime = Timer
CalculationComplete = False
UpdateStatus
End Function
Ändern des HPC_Partition-Makros
Das nächste zu ändernde Makro ist das HPC_Partition Makro. Denken Sie daran, dass dieses Makro alle Daten sammelt, die zum Ausführen einer einzelnen Berechnung erforderlich sind. In diesem Fall wird dies die Zeilen- und Spaltennummer sein. Für diese Arbeitsmappe möchten wir jede einzelne Tabellenzelle auf dem Cluster separat berechnen; dazu verwenden wir die Zeilen- und Spaltennummer.
Alle Makros im HPC-Framework verwenden den Variant-Datentyp für Eingaben und Ausgaben. Der Variant-Typ kann ein beliebiger Grundtyp (ganze Zahl, long, double, string) oder ein Array dieser Typen sein. Wir müssen sowohl die Zeile als auch die Spalte einschließen, damit wir ein Array verwenden können.
Das andere, was wir im HPC_Partition Makro tun müssen, ist festzustellen, wann die Berechnung abgeschlossen ist. In diesem Fall wird die Berechnung abgeschlossen, wenn das Ende der Tabelle erreicht ist. Dazu können wir die Zeilen- und Spaltenzahlen erhöhen, während wir durch die Tabelle navigieren. Wenn wir das Ende einer Spalte erreichen, wechseln wir zur nächsten Spalte. Wenn wir die letzte Spalte übergeben haben, ist die Tabelle fertig, und die Funktion soll Null zurückgeben.
So ändern Sie das HPC_Partition-Makro
Scrollen Sie im HPCExcelMacros-Code zum Abschnitt HPC_Partition , und fügen Sie Code hinzu, um ein Array für die Zeile und Spalte zu deklarieren:
Public Function HPC_Partition() As Variant Dim data(3) As Variant ' update the status bar with the counters SentRecords = SentRecords + 1 UpdateStatus End FunctionFügen Sie Code hinzu, um nach dem Ende der Tabelle zu suchen. Dadurch wird die Berechnung beendet, wenn wir die Tabelle abgeschlossen haben.
Public Function HPC_Partition() As Variant Dim data(3) As Variant ' first check the row; if we're past the bottom ' of the table, increment the column and set the ' row back to the top If CurrentRow > NumRows Then CurrentRow = 1 CurrentCol = CurrentCol + 1 End If ' next check the column; if we're past the last ' column, then we're done If CurrentCol > NumCols Then ' return null to indicate the end of the calculation HPC_Partition = Null ' and exit the function now, we can skip the rest Exit Function End If ' update the status bar with the counters SentRecords = SentRecords + 1 UpdateStatus End FunctionWenn wir die Tabelle noch nicht abgeschlossen haben, speichert der letzte Teil der Funktion die Zeilen- und Spaltenwerte und verwendet sie als Rückgabewert für die Funktion; und wechseln Sie dann zur nächsten Zeile:
Public Function HPC_Partition() As Variant Dim data(3) As Variant ' first check the row; if we're past the bottom ' of the table, increment the column and set the ' row back to the top If CurrentRow > NumRows Then CurrentRow = 1 CurrentCol = CurrentCol + 1 End If ' next check the column; if we're past the last ' column, then we're done If CurrentCol > NumCols Then ' return null to indicate the end of the calculation HPC_Partition = Null ' and exit the function now, we can skip the rest Exit Function End If data(0) = CurrentRow data(1) = CurrentCol HPC_Partition = data ' move to the next row CurrentRow = CurrentRow + 1 ' update the status bar with the counters SentRecords = SentRecords + 1 UpdateStatus End Function
Um dies zu überprüfen, hat das HPC_Partition Makro zwei Zwecke: Es sammelt Parameter, die für eine einzelne Berechnung erforderlich sind (hier ist die Zeilen- und Spaltennummer); und wenn die Berechnung abgeschlossen ist, signalisiert sie, dass durch Zurückgeben von Null. In der Funktion, die wir erstellt haben, wird dies ausgeführt, indem Sie die Tabelle durchlaufen, zuerst nach Zeile und dann nach Spalte, und wenn sie die letzte Spalte übergeben wird, wird Null zurückgegeben, um anzugeben, dass die Tabelle abgeschlossen ist.
Ändern des HPC_Execute-Makros
Das nächste Makro ist HPC_Execute. Denken Sie daran, dass dieses Makro so konzipiert ist, dass die tatsächliche Berechnung oder die Geschäftslogik ausgeführt wird. Die Eingaben für diese Funktion sind alles, was wir aus dem HPC_Partition Makro im letzten Schritt zurückgegeben haben. Da wir gerade das HPC_Partition Makro geschrieben haben, wissen wir, dass die Eingaben für das HPC_Execute Makro die Zeilen- und Spaltennummer der Tabellenzelle sind, die wir berechnen möchten.
Der Textkörper des HPC_Execute Makros wird Code aus dem ursprünglichen Berechnungsmakro kopiert. Wir benötigen zwei Teile dieses Codes: die Variablendeklarationen oben und den Code, der die Schleife ausführt. Wir haben bereits den Abschnitt verwendet, der die Größe der Tabelle im HPC_Initialize Makro behandelt, daher benötigen wir das nicht mehr, aber es ist einfacher, den gesamten Codeblock zu kopieren und dann die Teile zu entfernen, die wir nicht benötigen. Anschließend nehmen wir einige Änderungen vor, um das asynchrone Framework zu unterstützen.
So ändern Sie das HPC_Execute-Makro
Wechseln Sie zurück zum ursprünglichen Makro, indem Sie im VBA-Projektfenster auf das Modul "ScenarioAnalysis" doppelklicken.
Kopieren Sie den Code aus der ersten Zeile:
Dim Prem as doubleBis zur letzten Zeile:
Next colsWechseln Sie zurück zum HPCExcelMacros-Modul (indem Sie im VBA-Projektfenster doppelklicken), und fügen Sie den Code in das makro HPC_Execute ein.
Löschen Sie im HPC_Execute-Makro die bereits verwendeten Zeilen, beginnend mit:
' clear values, then figure out the table sizeDirekt vor der Zeile:
' set up and run through the tableStellen Sie sicher, dass das HPC_Execute-Makro wie folgt aussieht:
Public Function HPC_Execute(data As Variant) As Variant Dim Prem As Double Dim TempPIKdate As Date Dim TempPIKfreq As Double Dim rws As Integer Dim cols As Integer Dim Model As Integer ' set up and run through the table Call ReadSheetVariables TempPIKdate = PIKdate 'Save this value! TempPIKfreq = PIKfreq 'Save this value! Model = 1 If Range("PricingModel").Value2 = "Bond plus Option" Then Model = 2 End If For cols = 1 To NumCols For rws = 1 To NumRows Call ReadSheetVariables PIKdate = TempPIKdate PIKfreq = TempPIKfreq PIKrate = CDbl(Range("table1").Offset(rws, 0).Value) Prem = CDbl(Range("table1").Offset(0, cols).Value) If Prem = 0 Then End Ratio = CDbl(Face / Underlying / (1 + Prem)) Select Case Model Case 1 Range("cashtable").Cells(rws, cols).Value = … Case Else Range("cashtable").Cells(rws, cols).Value = … End Select Next rws Next cols End FunctionHinweis: Im Makro haben wir nun den Berechnungsteil der Funktion, einschließlich der Schleife, die durch jede Zelle der Tabelle ausgeführt wird. Für das asynchrone Framework möchten wir hier keine Schleife verwenden. wir möchten nur eine einzelne Zelle berechnen. Denken Sie daran, dass das HPC_Execute Makro Code ist, der auf den Computeknoten ausgeführt wird, und wir geben ihm die Zeilen- und Spaltennummer, die wir berechnen möchten.
Entfernen Sie die Linien, aus denen die Schleife besteht (die hervorgehobenen Zeilen unten):
Public Function HPC_Execute(data As Variant) As Variant Dim Prem As Double Dim TempPIKdate As Date Dim TempPIKfreq As Double Dim rws As Integer Dim cols As Integer Dim Model As Integer ' set up and run through the table Call ReadSheetVariables TempPIKdate = PIKdate 'Save this value! TempPIKfreq = PIKfreq 'Save this value! Model = 1 If Range("PricingModel").Value2 = "Bond plus Option" Then Model = 2 End If For cols = 1 To NumCols For rws = 1 To NumRows Call ReadSheetVariables PIKdate = TempPIKdate PIKfreq = TempPIKfreq PIKrate = CDbl(Range("table1").Offset(rws, 0).Value) Prem = CDbl(Range("table1").Offset(0, cols).Value) If Prem = 0 Then End Ratio = CDbl(Face / Underlying / (1 + Prem)) Select Case Model Case 1 Range("cashtable").Cells(rws, cols).Value = … Case Else Range("cashtable").Cells(rws, cols).Value = … End Select Next rws Next cols End FunctionErsetzen der Schleife durch die Zeilen- und Spaltennummer, die an die Funktion übergeben werden. Der geänderte Code sollte wie folgt aussehen:
rws = data(0) cols = data(1) Call ReadSheetVariables PIKdate = TempPIKdate PIKfreq = TempPIKfreq PIKrate = CDbl(Range("table1").Offset(rws, 0).Value) Prem = CDbl(Range("table1").Offset(0, cols).Value) If Prem = 0 Then End Ratio = CDbl(Face / Underlying / (1 + Prem)) Select Case Model Case 1 Range("cashtable").Cells(rws, cols).Value = FullDiscountModel(360) / Face Case Else Range("cashtable").Cells(rws, cols).Value = BondPlusOptionModel(360) … End Select
Anstelle der Schleife verwenden wir nun die Werte aus unserem Datenarray – das Array, das wir aus dem HPC_Partition Makro zurückgegeben haben - das die Zeile und Spalte der Zelle enthält, die wir berechnen möchten. Um diesen letzten Schritt zu überprüfen, haben wir die beiden Schleifenlinien entfernt,
For cols = 1 To NumCols
For rws = 1 To NumRows
sowie die "Next"-Linien am Ende der Schleife,
Next rws
Next cols
und fügt Zeilen direkt über der Schleife hinzu, um die Datenarrayvariable zu verwenden:
rws = data(0)
cols = data(1)
Die letzte Änderung, die wir an der HPC_Execute-Funktion vornehmen möchten, muss mit der Rückgabe der Daten zu tun haben. Denken Sie daran, dass Daten durch die Makros verschoben werden, wobei jedes Makro Ergebnisse an das nächste übergibt. Der ursprüngliche VBA-Code für diese Arbeitsmappe wurde für die Ausführung auf dem Desktop entwickelt, sodass jedes Zellenergebnis in die Kalkulationstabelle eingefügt wurde. Da diese Arbeitsmappe auf dem Cluster ausgeführt wird, müssen wir anstelle von Ergebnissen in die Kalkulationstabelle das Berechnungsergebnis sammeln und aus der Funktion zurückgeben.
Und es gibt eine andere Sache, die wir berücksichtigen müssen: Wenn die HPC_Execute-Funktion auf einem Berechnungsknoten ausgeführt wird, wird das Ergebnis für eine bestimmte Zelle in der Tabelle berechnet. Dieses Ergebnis wird dann an den Desktop zurückgegeben und an das HPC_Merge-Makro gesendet. Denken Sie aber daran, dass ergebnisse im asynchronen Framework in beliebiger Reihenfolge zurückgesendet werden können – nicht unbedingt die gleiche Reihenfolge, in der wir sie gesendet haben. Daher müssen wir dem HPC_Merge Makro mitteilen, welche Zelle in der Tabelle wir berechnet haben.
Dazu können wir die Zeilen- und Spaltennummer in die Ergebnisdaten einschließen. Wie beim HPC_Partition-Makro können wir ein Array aus dem HPC_Excecute-Makro zurückgeben. Dadurch kann die Funktion nicht nur das Ergebnis, sondern auch die Berechnete Zelle zurückgeben.
Tatsächlich können wir einfach dasselbe Array erneut verwenden, das an die Funktion übergeben wurde, um das Ergebnis zurückzugeben, da dieses Array bereits die Zeilen- und Spaltennummer enthält.
Um das Ergebnis zu speichern, ändern Sie den Code so, dass er wie folgt vorgelesen wird:
Select Case Model
Case 1
data(2) = FullDiscountModel(360) / Face
Case Else
data(2) = BondPlusOptionModel(360) / Face
End Select
HPC_Execute = data
Wir haben den Code geändert, der Werte in die Kalkulationstabelle eingefügt hat, um stattdessen die Ergebniswerte im Datenarray zu speichern. Und die letzte Zeile verwendet das Datenarray als Rückgabewert aus der Funktion, sodass die Ergebnisse - und die Zeilen- und Spaltennummern - an das nächste Makro gesendet werden.
Der vollständige, endgültige Code für das HPC_Execute-Makro sollte also wie folgt aussehen:
Public Function HPC_Execute(data As Variant) As Variant
Dim Prem As Double
Dim TempPIKdate As Date
Dim TempPIKfreq As Double
Dim rws As Integer
Dim cols As Integer
Dim Model As Integer
' set up and run through the table
Call ReadSheetVariables
TempPIKdate = PIKdate 'Save this value!
TempPIKfreq = PIKfreq 'Save this value!
Model = 1
If Range("PricingModel").Value2 = "Bond plus Option" Then
Model = 2
End If
rws = data(0)
cols = data(1)
Call ReadSheetVariables
PIKdate = TempPIKdate
PIKfreq = TempPIKfreq
PIKrate = CDbl(Range("table1").Offset(rws, 0).Value)
Prem = CDbl(Range("table1").Offset(0, cols).Value)
If Prem = 0 Then End
Ratio = CDbl(Face / Underlying / (1 + Prem))
Select Case Model
Case 1
data(2) = FullDiscountModel(360) / Face
Case Else
data(2) = BondPlusOptionModel(360) / Face
End Select
HPC_Execute = data
End Function
Ändern des HPC_Merge-Makros
Das letzte Makro, das geändert werden muss, ist das HPC_Merge Makro. Denken Sie daran, dass dieses Makro ein einzelnes Berechnungsergebnis aus dem Cluster empfängt. Wir möchten es verwenden, um das Ergebnis in die Tabelle einzufügen.
Die Eingabe für HPC_Merge wird alles sein, was wir von HPC_Execute zurückgeben. Da wir gerade das makro HPC_Execute geschrieben haben, wissen wir, dass der Rückgabewert ein Array ist, das die Zeilen- und Spaltennummer und das Ergebnis der Berechnung enthält. Um die Tabelle zu aktualisieren, können wir Code aus dem ursprünglichen Makro verwenden (dies ist Code, den wir gerade in der HPC_Execute-Funktion geändert haben).
Die ursprüngliche Codezeile im Modul "ScenarioAnalysis" sieht wie folgt aus:
Range("cashtable").Cells(rws, cols).Value = FullDiscountModel(360) / Face
Wir schreiben diese Zeile neu, um die werte zu verwenden, die an das Makro im Datenparameter übergeben werden. Das fertige HPC_Merge Makro sollte wie folgt aussehen:
Public Function HPC_Merge(data As Variant)
Range("cashtable").Cells(data(0), data(1)).Value = data(2)
' update the status bar with the counters
RcvRecords = RcvRecords + 1
UpdateStatus
End Function
Dies ist die gleiche Codezeile, die gerade aus dem HPC_Execute-Makro entfernt wurde. Wir haben die Zeilen- und Spaltenwerte (rws und Spalten in der ursprünglichen Zeile) durch die Zeile und Spalte aus dem Array ersetzt. Wir haben auch den Funktionsaufruf durch das Ergebnis ersetzt, das in demselben Array gespeichert ist.
Dies sind alle Änderungen, die wir vornehmen müssen, um diese Arbeitsmappe auf dem Cluster auszuführen. Obwohl es wie viele Schritte aussieht, insbesondere wenn Sie HPC Services für Excel zum ersten Mal verwendet haben, schauen Sie sich die Makros an, um den gesamt geänderten Code anzuzeigen. Es ist wirklich nicht ganz viel. In den meisten Fällen hat dies das Kopieren und Einfügen aus dem ursprünglichen Makro in die HPC-Makros involviert. Zur Unterstützung der asynchronen Berechnung haben wir eine Reihe von Änderungen am Code vorgenommen – aber auch das war relativ einfach. Wir haben in dieser Arbeitsmappe keine Änderungen an der tatsächlichen Geschäftslogik vorgenommen, und Sie müssen die Geschäftslogikfunktionen nicht einmal verstehen, um die Arbeitsmappe zu konvertieren. Wenn Benutzer zukünftig Änderungen an der Geschäftslogik vornehmen, ist es nicht erforderlich, die Clusterberechnung zu ändern.
Ausführen der Arbeitsmappe
Um Änderungen am Code zu testen, führen wir sie zuerst auf dem Desktop aus. Wie in der ersten Arbeitsmappe fügen wir dem Arbeitsblatt eine neue Schaltfläche hinzu, und verwenden sie zum Ausführen der Berechnung. Anschließend geben wir den Kopfknoten und die Dateifreigabe an, fügen eine Schaltfläche hinzu, über die die Arbeitsmappe im Cluster ausgeführt wird, und führen Sie dann die Arbeitsmappe auf dem Cluster aus.
Hinzufügen einer Schaltfläche, die die Arbeitsmappe lokal ausführt
So fügen Sie eine Schaltfläche hinzu, die die Arbeitsmappe lokal ausführt
(1) Wenn Ihre Excel-Arbeitsmappe geöffnet ist, klicken Sie im Menüband auf die Registerkarte " Entwicklertools ".
(2) Klicken Sie auf der Registerkarte " Entwicklertools " auf "Einfügen ", und wählen Sie dann das Schaltflächensteuerelement aus – das erste Steuerelement in der Liste.
(3) Nachdem Sie auf die Schaltfläche geklickt haben, zeichnen Sie ein Rechteck an einer beliebigen Stelle auf der Kalkulationstabelle, um die Schaltfläche an dieser Stelle einzufügen. Nachdem Sie die Schaltfläche positioniert haben, wird das Dialogfeld "Makro zuweisen " angezeigt. !
(4) Wählen Sie im Dialogfeld das Makro CalculateWorkbookOnDesktop aus der Liste aus, und klicken Sie dann auf OK. Achten Sie darauf, das Desktopmakro auszuwählen – wir möchten die Arbeitsmappe zuerst testen und alle Fehler finden, bevor sie im Cluster ausgeführt werden.
(5) Klicken Sie mit der rechten Maustaste auf die neue Schaltfläche, und wählen Sie dann "Text bearbeiten" aus, um die Beschriftung zu ändern.
(6) Benennen Sie die Bezeichnung "Desktop" oder etwas ähnliches.
(7) Speichern Sie die Arbeitsmappe.
(8) Klicken Sie auf die Schaltfläche, um die Arbeitsmappe auf dem Desktop auszuführen.
Wenn Fehler auftreten, wird ein Fehlerdialogfeld angezeigt, und der Teil des VBA-Codes mit dem Fehler wird hervorgehoben. Überprüfen Sie den oben aufgeführten Code, um Fehler zu beheben.
Wenn keine Fehler auftreten, wird die Tabelle angezeigt, in der die Tabelle ausgefüllt wird. Die Werte sollten mit dem übereinstimmen, wenn Sie auf die ursprüngliche Schaltfläche auf der Kalkulationstabelle geklickt haben. Dies wird wieder auf dem Desktop ausgeführt, daher sollte sie ungefähr die gleiche Geschwindigkeit wie die ursprüngliche Schaltfläche ausführen – irgendwo zwischen 1 und 2 Minuten auf den meisten Arbeitsstationen.
Da wir mit dem Makroframeworkcode ausgeführt werden, wird auch der Berechnungsfortschritt in der Excel-Statusleiste angezeigt. Wie bei der ersten Arbeitsmappe, die auf dem Desktop ausgeführt wird, werden die Zahlen zusammen verschoben, da die Arbeitsmappe auf dem Desktop synchron ausgeführt wird.
Ausführen der Arbeitsmappe im Cluster
Als Nächstes versuchen wir, die Arbeitsmappe auf dem Cluster auszuführen. Dazu müssen wir zunächst einige Werte festlegen, um Excel mitzuteilen, wie der Cluster kontaktiert werden soll. Diese Werte werden im HPCControlMacros-Modul **.** Oben in dieser Datei definiert, müssen Sie zwei Werte eingeben: den Clusterplaner und das Freigabeverzeichnis. Denken Sie daran, dass Sie (der Desktopbenutzer) Schreibzugriff auf dieses Freigabeverzeichnis haben müssen; und die Cluster-Computeknoten müssen über Lesezugriff auf das Verzeichnis verfügen. In den meisten Fällen werden Ihre Clusterberechnungen unter Ihrem Benutzerkonto ausgeführt, aber es ist möglich, ein anderes Benutzerkonto zu verwenden, wenn Sie eine Verbindung mit der Clustersitzung herstellen (mehr dazu in einem Moment).
So geben Sie den Kopfknoten und das Freigabeverzeichnis an
Klicken Sie auf der Registerkarte " Entwicklertools " des Menübands auf Visual Basic , um den VBA-Editor zu öffnen.
Doppelklicken Sie im VBA-Editor in der Projektstruktur auf das HPCControlMacros-Modul , um die Makrodatei zu öffnen.
Verwenden Sie für den Clusterplaner den Namen des Clusterkopfknotens – dies ist der Computername, den Sie im Netzwerk verwenden würden. Sie können einen vollqualifizierten Namen (z. B. headnode.mynetwork.com) verwenden, dies ist jedoch nicht erforderlich, wenn Sie sich in derselben Domäne befinden.
Verwenden Sie für das Freigabeverzeichnis den vollständigen Pfad zu dem zuvor erstellten Freigabeverzeichnis (im Abschnitt "Bevor Sie beginnen").
Kehren Sie nun zur Excel-Tabelle zurück. Wir fügen eine weitere Schaltfläche hinzu, diesmal zum Ausführen der Berechnung auf dem Cluster.
So fügen Sie eine Schaltfläche hinzu, mit der die Arbeitsmappe im Cluster ausgeführt wird
Klicken Sie auf der Registerkarte " Entwicklertools " auf "Einfügen ", und wählen Sie dann das Schaltflächensteuerelement aus – das erste Steuerelement in der Liste.
Nachdem Sie auf die Schaltfläche geklickt haben, zeichnen Sie ein Rechteck an einer beliebigen Stelle auf der Kalkulationstabelle, um die Schaltfläche an dieser Stelle einzufügen. Nachdem Sie die Schaltfläche positioniert haben, wird das Dialogfeld "Makro zuweisen " angezeigt.
Wählen Sie im Dialogfeld das Makro CalculateWorkbookOnCluster aus der Liste aus, und klicken Sie dann auf OK.
Klicken Sie mit der rechten Maustaste auf die neue Schaltfläche, und wählen Sie dann "Text bearbeiten " aus, um die Beschriftung zu ändern.
Benennen Sie die Bezeichnung "Cluster" oder etwas ähnliches.
Speichern Sie die Arbeitsmappe.
Klicken Sie auf die Schaltfläche, um die Arbeitsmappe auf dem Cluster auszuführen.
Wenn Sie zum ersten Mal Clusteraufträge ausführen, entweder excel oder eine andere Anwendung verwenden, wird ein Dialogfeld für die Benutzerauthentifizierung angezeigt. Geben Sie Ihren Benutzernamen und Ihr Kennwort ein, und aktivieren Sie (wenn Sie möchten) das Kontrollkästchen, um Ihre Anmeldeinformationen zu speichern. Wenn Sie Berechnungen auf dem Cluster als anderen Benutzer ausführen möchten, können Sie unterschiedliche Benutzerkontoeinstellungen eingeben.
Hinweis: Stellen Sie sicher, dass Ihr Benutzerkonto – entweder Ihr Standardbenutzerkonto oder alles, was Sie verwenden möchten – als Clusterbenutzer im HPC Cluster Manager festgelegt ist.
Wenn Fehler auftreten, wird ein Popupdialogfeld angezeigt. Wenn die Desktopberechnung funktioniert hat, müssen die wahrscheinlichsten Fehler an diesem Punkt mit den Einstellungen zu tun haben, die Sie für den Clusterkopfknoten und das Freigabeverzeichnis erstellt haben. Überprüfen Sie diese Einstellungen, und versuchen Sie es erneut.
Wenn keine Fehler auftreten, wird der Start der Clusterberechnung angezeigt. Zunächst wird eine kurze Pause angezeigt, wenn die Clientbibliothek eine HPC-Sitzung für die Berechnung erstellt. Als Nächstes ruft die Clientbibliothek das HPC_Initialize Makro auf, und Die Tabelle wird gelöscht. Wenn Sie sich die Excel-Statusleiste ansehen, sehen Sie, dass zuerst alle Datensätze an den Cluster gesendet werden. Die zweite Zahl springt bis zu 105 (es gibt 105 Zellen in der Tabelle). Danach wird eine weitere kurze Pause angezeigt, bevor ergebnisse zurückgegeben werden. Diese Pause tritt auf, wenn jeder Computeknoten Excel startet und die Arbeitsmappe lädt.
Nach dieser Pause werden die Ergebnisse angezeigt, um die Tabelle aufzufüllen, und die Statusleiste zeigt die Anzahl der zurückgegebenen Ergebnisse an. Da dies eine lange Berechnung ist, ist es sehr wahrscheinlich, dass Ergebnisse nicht in der Reihenfolge zurückgegeben werden. in der Tabelle sind Leerzeichen vorhanden, die dann ausgefüllt werden. Das liegt daran, dass die Berechnung asynchron ist und einige Computeknoten schneller als andere berechnen. Schließlich wird die Tabelle vollständig ausgefüllt, und die Statusleiste zeigt die Berechnungszeit an.
Selbst wenn Sie nur zwei Computeknoten in Ihrem HPC-Cluster haben, sollte die Berechnung viel schneller sein als auf dem Desktop. Wenn Sie vier Knoten, acht Knoten oder mehr haben, sollte die Berechnung extrem schnell sein. Sie können immer erneut auf die Schaltfläche "Desktop" klicken, um die Leistung der Desktopberechnung mit der Clusterberechnung zu vergleichen.
Bewährte Methoden für Cluster-Enabled Excel-Arbeitsmappen
Im folgenden Hinweis werden einige wichtige Überlegungen beschrieben, die Sie beim Entwerfen von Excel-Arbeitsmappen für die Verwendung mit HPC Services für Excel berücksichtigen sollten. Dieser Hinweis gilt für Arbeitsmappen, die das HPC/Excel-Makroframework verwenden, das aus VBA oder mit der .NET ExcelClient-Bibliothek ausgeführt wird.
Clusteranwendungsleistung
Wenn Sie eine Anwendung für die Berechnung auf einem HPC-Cluster entwerfen, teilen Sie normalerweise die erforderliche Arbeit in einzelne Vorgänge auf und senden diese Aufgaben zur Berechnung an den Cluster. Die Leistungsvorteile der Verwendung von HPC ergeben sich aus der Parallelisierung – wobei viele Computeknoten gleichzeitig funktionieren.
Es liegt in der Verantwortung des HPC Scheduler (dem Head Node), diese Aufgaben für die Verarbeitung an die Computeknoten zu verteilen. Um jedoch sicherzustellen, dass die Computeknoten nie auf Arbeit warten, sollten Sie versuchen, sicherzustellen, dass der HPC Scheduler immer eine Liste der zu verarbeitenden Aufgaben hat. Wenn der Scheduler auf den nächsten Verarbeitungsvorgang warten muss, befindet sich ein oder mehrere Computeknoten im Leerlauf - ohne Aktion - und Sie erhalten nicht die beste Auslastung Ihres HPC-Clusters.
Sie können sicherstellen, dass der Scheduler und die Computeknoten immer genügend Arbeit haben, indem Sie Berechnungsanforderungen so schnell wie möglich senden. Im HPC/Excel-Makroframework werden Anforderungen mit dem HPC_Partition Makro gesendet. Daher ist es wichtig, sicherzustellen, dass das Partitionsmakro so schnell wie möglich ist. Wenn Sie das Partitionsmakro so entwerfen können, dass Aufgaben schnell gesendet werden, stellen Sie sicher, dass der Cluster vollständig genutzt wird, und Sie erhalten die bestmögliche Leistung von HPC.
Wenn einzelne Berechnungen auf dem Cluster Compute Nodes abgeschlossen sind, werden die Ergebnisse an Ihre Desktopanwendung zurückgesendet. Im HPC/Excel-Makroframework werden Ergebnisse mithilfe des HPC_Merge-Makros verarbeitet. Sie möchten dieses Makro aus zwei Gründen so schnell wie möglich gestalten. Wenn das Zusammenführen-Makro langsam ist, um Ergebnisse zu verarbeiten, kann dies möglicherweise unnötigerweise Clusterressourcen binden. Zweitens wird die langsame Verarbeitung der Ergebnisse Ihre Gesamtberechnung verlangsamen – wodurch die Vorteile der Verwendung von HPC reduziert werden. Wenn Sie sicherstellen, dass das Zusammenführen-Makro schnell ergebnisset, geben Sie alle Clusterressourcen für andere Zwecke frei, und Sie verbessern die Allgemeine Benutzererfahrung.
Verbessern der HPC-/Excel-Makroleistung
In diesem Abschnitt werden einige Schritte beschrieben, die Sie ausführen können, um sicherzustellen, dass Ihre HPC-fähigen Excel-Arbeitsmappen so effizient wie möglich sind, damit Sie die bestmögliche Leistung erzielen können, wenn Sie Berechnungen auf einem HPC-Cluster ausführen.
Diese Liste ist nicht vollständig, aber Möglicherweise finden Sie einige Tipps, die für Ihre Arbeitsmappe gelten. Und denken Sie daran, dass dies Optimierungen sind – der beste Ansatz beim Entwerfen von HPC-fähigen Excel-Arbeitsmappen besteht darin, die Berechnung zuerst zu entwerfen und so einfach wie möglich zu halten; Wenn die Arbeitsmappe dann ordnungsgemäß auf dem Cluster ausgeführt wird, nehmen Sie die hier beschriebenen Änderungen vor, um die Gesamtleistung zu verbessern.
Vermeiden des Öffnens und Schließens von Ressourcen in den Makros "Partition" und "Zusammenführen"
Das Öffnen und Schließen externer Ressourcen – z. B. Protokolldateien oder Datenbankverbindungen – kann lange dauern und kann die Partitions- und Zusammenführungsmakros verlangsamen. Darüber hinaus sollten Sie möglichst vermeiden, große Datasets in diesen Makros zu lesen. Sie möchten beispielsweise keine Datenbankverbindung öffnen, die Datensätze durchsuchen und einen einzelnen Datensatz für jeden Aufruf des Partitionsmakros suchen.
Ein besserer Ansatz besteht darin, diese Ressourcen einmal zu öffnen, im Makro initialisieren und alle anfänglichen Verarbeitungsschritte ausführen. Wenn Sie beispielsweise einen großen Datensatz aus einer Datenbank laden müssen, erstellen Sie die Datenbankverbindung, und führen Sie die Abfrage im Makro "Initialisieren" aus. Anschließend können Sie im Partitionsmakro einfach zum nächsten Datensatz wechseln. Sie können die Datenbankverbindung im Makro "Finalize" schließen.
Wenn Sie in eine Protokolldatei im Seriendruckmakro schreiben, sollten Sie die Datei auch im Makro "Initialisieren" öffnen. Im Seriendruckmakro können Sie die Ergebnisse einzeln schreiben, und dann können Sie die Protokolldatei im Makro "Fertig stellen" schließen.
Vermeiden Sie die Neuberechnung der Kalkulationstabelle im Seriendruckmakro.
Wenn Sie Ergebnisse in die Kalkulationstabelle im Seriendruckmakro einfügen, können Sie die Kalkulationstabelle versehentlich neu berechnen – wenn die Kalkulationstabelle sehr kompliziert ist, kann dies die Verarbeitung verlangsamen.
Standardmäßig berechnet Excel die Kalkulationstabelle immer dann neu, wenn Sie den Wert einer Zelle ändern – auch wenn Sie die Zelle aus einem VBA-Makro aktualisieren. Excel berechnet nur die Teile der Kalkulationstabelle, die von der Änderung betroffen sind. Wenn sich die Zelle also selbst befindet, ist dies nicht signifikant. Wenn die Zelle jedoch als Teil einer größeren Berechnung oder als Diagrammdaten verwendet wird, kann die Neuberechnung langsam sein.
Wenn Sie Tabellenkalkulationszellen im Seriendruckmakro aktualisieren, sollten Sie die automatische Neuberechnung deaktivieren. Sie können die automatische Neuberechnung im Makro Initialisieren deaktivieren. Anschließend können Sie im Makro "Fertigstellen" die gesamte Kalkulationstabelle neu berechnen und die automatische Berechnung erneut aktivieren.
Im Makro "Initialisieren" können Sie die automatische Berechnung mit
Application.Calculation = xlCalculationManual
Anschließend können Sie die Kalkulationstabelle neu berechnen und die automatische Berechnung im Makro "Fertigstellen" erneut aktivieren.
Application.Calculate
Application.Calculation = xlCalculationAutomatic
Einfügen von Datenblöcken anstelle einzelner Werte
Wenn Sie Tabellenkalkulationszellen aus VBA aktualisieren, umfasst dies eine Reihe interner Schritte – und dies ist möglicherweise langsamer als erwartet. Es ist fast immer besser, mehrere Zellen als einzelner Block zu ändern, anstatt jeweils einzeln.
Wenn das Execute-Makro eine große Anzahl von Werten zurückgibt – z. B. ein Array von 100 Zahlen – gibt es zwei Möglichkeiten, diese Daten in die Kalkulationstabelle einzufügen. Sie können sie einzeln in eine Schleife einfügen:
For i = 1 To 100 Step 1
Cells(1, i).Value2 = v(i)
Next i
Alternativ können Sie den vollständigen Bereich als Array einfügen:
Range(Cells(2, 1), Cells(2, 100)).Value2 = v
Das Einfügen einer Zelle dauert ungefähr die gleiche Zeit wie das Einfügen eines Zellblocks. Wenn Sie also über ein Array von 100 Werten verfügen, kann die erste Möglichkeit hierfür - das einmalige Einfügen von Zellen nacheinander in eine Schleife - bis zu 100 Mal dauern, bis der zweite Ansatz, das Einfügen des Zellblocks als Array.
Deaktivieren von Bildschirmupdates
Wenn Sie Änderungen an der Tabelle im Makro "Zusammenführen" vornehmen – wenn Sie Zellen aktualisieren oder Diagrammdaten ändern – kann das Deaktivieren von Bildschirmaktualisierungen die Verarbeitungszeit verringern. Dies funktioniert, da Excel einige Zeit benötigt, um den Bildschirm und die Benutzeroberfläche zu aktualisieren.
Sie können Bildschirmaktualisierungen im Makro initialisieren und Bildschirmaktualisierungen im Makro "Fertigstellen" erneut aktivieren. Verwenden Sie im Makro "Initialisieren"
Application.ScreenUpdating = False
Verwenden Sie im Makro "Fertigstellen"
Application.ScreenUpdating = True
Dadurch werden Bildschirmaktualisierungen während der Berechnung deaktiviert und Updates nach Abschluss der Berechnung erneut aktiviert. Wenn Sie Bildschirmaktualisierungen im Makro "Fertigstellen" erneut aktivieren, wird der Bildschirm von Excel automatisch aktualisiert.
Verwenden von Datenstrukturen zum vorübergehenden Speichern von Informationen im Arbeitsspeicher
Wenn Sie Informationen für die Verarbeitung sammeln - was Sie im Partitionsmakro tun - sehr zeitaufwändig ist, oder wenn Sie sehr komplexe Nachbearbeitung von Ergebnissen durchführen müssen -- im Makro zusammenführen -- erwägen Sie die Verwendung von Datenstrukturen zum Speichern von Informationen im Arbeitsspeicher während der Berechnung.
Wenn beispielsweise jede Berechnungsanforderung im Partitionsmakro eine sehr komplizierte Datenbankabfrage erfordert, kann dies die Verarbeitung verlangsamen und zu einer schlechten Leistung führen. In diesem Fall empfiehlt es sich, diese komplexe Verarbeitung im Makro initialisieren durchzuführen, bevor die Berechnung beginnt.
Wenn Sie diese komplexe Verarbeitung im Makro "Initialize" ausführen, können Sie jede Berechnungsanforderung in einer Datenstruktur in VBA speichern, z. B. ein Array von Variants. Anschließend können Sie im Partitionsmakro einfach den nächsten Eintrag im Array zurückgeben. Dadurch wird sichergestellt, dass das Partitionsmakro so schnell wie möglich ist.
Ebenso kann es ratsam sein, die Ergebnisse in einer Datenstruktur im Zusammenführungsmakro zu speichern und die Ergebnisse dann nach Abschluss der Berechnung im Makro "Fertigstellen" zu verarbeiten.
Wenn Sie beispielsweise Ergebnisse in einer Datenbank speichern, aber für jeden Datenbankschreibvorgang eine komplexe Einfügeanweisung erforderlich ist, ist es möglicherweise besser, diese Verarbeitung in das Makro "Fertigstellen" zu verschieben. Sie können eine Datenstruktur erstellen – z. B. ein Array von Varianten – und einfach im Seriendruckmakro, einfach jedes Ergebnis in das Array einfügen. Anschließend können Sie im Makro "Finalize" das Array durchlaufen und die erforderlichen Datenbankschreibvorgänge gleichzeitig ausführen.
Endgültige Notizen
Das Konvertieren einer vorhandenen Arbeitsmappe zur Verwendung von HPC Services für Excel ist eher eine Kunst, als eine Wissenschaft. Die spezifischen Details – welcher Code verschoben werden soll und wo sie verschoben werden soll – hängt immer von der jeweiligen Arbeitsmappe ab.
Sie sollten nun jedoch die konzepte verstehen und verstehen, warum wir das asynchrone Makroframework verwenden. Zum Konvertieren einer Arbeitsmappe zur Verwendung von HPC Services für Excel muss eine parallele Berechnung im Wesentlichen auf die gleiche Weise erstellt werden: Fügen Sie der Arbeitsmappe die Makroframeworkfunktionen hinzu, und füllen Sie den entsprechenden Code aus.
Sie können die in diesem Artikel enthaltenen Makrodateien "Skelett" in Ihren eigenen Arbeitsmappen verwenden. Führen Sie die schritte aus, die Sie in den obigen Beispielen verwendet haben, um den iterativen Code in Ihrer Arbeitsmappe zu identifizieren und in die entsprechenden Makros zu verschieben. Denken Sie daran, die Berechnung auf Dem Desktop zu testen, um Fehler zu identifizieren, bevor Sie Berechnungen auf dem Cluster ausführen.
Außerdem sollten Sie über die Leistungsvorteile verfügen, die Sie von der Ausführung von Excel-Arbeitsmappen auf einem HPC-Cluster mit HPC Services für Excel erhalten können. In diesem Artikel haben wir mit einer Arbeitsmappe begonnen, die bereits relativ schnell war – zum Berechnen der gesamten Arbeitsmappe dauerte nur etwa 1-2 Minuten auf dem Desktop. Aber selbst diese Arbeitsmappe kann zweimal so schnell, viermal so schnell oder schneller auf einem HPC-Cluster ausgeführt werden. Die tatsächliche Leistung hängt von der Anzahl der verfügbaren Computeknoten in Ihrem Cluster ab, und Sie können die Leistung immer verbessern, indem Sie dem Cluster weitere Computeknoten hinzufügen.
Mit einer relativ geringen Arbeitsmenge können viele lange ausgeführte Excel-Arbeitsmappen in einen Microsoft HPC-Cluster mit HPC Services für Excel konvertiert werden. Und für wirklich lange ausgeführte Arbeitsmappen – Arbeitsmappen, die Stunden oder sogar Tage berechnen müssen - kann die Verwendung von HPC Services für Excel zu einer wirklich dramatischen Leistungsverbesserung führen.