Accélération d’Excel avec Microsoft HPC Pack : création d’applications et de classeurs VBA pour un microsoft HPC Pack

Résumé

HPC Services pour Excel prend en charge un large éventail de nouveaux modèles de programmation qui vous permettent d’exécuter des calculs Excel sur un cluster HPC. Dans cet article, nous allons découvrir comment utiliser des macros VBA Excel pour créer des classeurs qui utilisent un cluster HPC pour exécuter des calculs en parallèle. Pour prendre en charge HPC Services pour Excel, votre classeur doit inclure un ensemble de macros qui implémentent les fonctions asynchrones. Cet article décrit l’infrastructure de macros et comment définir des calculs au sein de l’infrastructure. Cet article inclut un exemple de création d’un classeur à partir de zéro et d’un exemple de conversion d’un classeur existant à exécuter sur un cluster.

Présentation

Passer une heure pour que votre classeur Excel s’exécute quatre fois plus rapidement ? Qu’en est-il de huit fois plus vite, voire plus ? Si vous avez des classeurs Excel longs ou lents, vous pouvez utiliser HPC Services pour Excel avec un cluster Microsoft HPC pour améliorer considérablement les performances de calcul.

HPC Services pour Excel prend en charge un large éventail de nouveaux modèles de programmation qui vous permettent d’exécuter des calculs Excel sur un cluster HPC. Mais vous n’avez pas besoin de comprendre le développement de code, ou savoir C#, pour utiliser HPC Services pour Excel. Dans cet article, nous allons découvrir comment créer des classeurs qui utilisent un cluster HPC pour le calcul, à l’aide uniquement d’Excel VBA.

En réalité, il faudra probablement plus d’une heure pour convertir l’un de vos classeurs à exécuter sur le cluster, en fonction de la complexité du classeur. Toutefois, si vous passez une heure à parcourir les exemples de cet article, vous comprendrez les concepts impliqués et les conditions requises pour convertir uniquement un classeur à exécuter sur un cluster HPC. Vous verrez également les avantages en matière de performances que vous pouvez obtenir avec quelques modifications simples apportées à votre code VBA.

Public prévu

Cet article est destiné aux développeurs Excel qui sont familiarisés avec l’écriture de macros VBA. La connaissance de Microsoft HPC Pack est utile, mais n’est pas nécessaire.

Si vous êtes intéressé par les possibilités de performances de HPC Services pour Excel, mais que vous ne souhaitez pas suivre le processus de développement complet, les fichiers de téléchargement incluent des versions terminées des deux classeurs abordés dans cet article. Si vous souhaitez essayer d’exécuter ces classeurs sur un cluster Microsoft HPC, lisez la section « Avant de commencer » pour vous assurer que vous disposez de toutes les conditions requises avant de commencer. Pour obtenir d’autres exemples et documentation, accédez à https://github.com/Azure-Samples/hpcpack-samples.

Télécharger des fichiers

Vous trouverez certains exemples de fichiers utilisés dans les sections qui suivent à partir de l’exemple de référentiel Github HPC Pack. Les exemples de fichiers incluent des fichiers macro squelette que vous pouvez importer dans vos classeurs pour simplifier le processus de développement. Il existe également un classeur de base que nous utiliserons comme point de départ pour développer un classeur pour HPC Services pour Excel.

Structure et mise en forme

Les captures d’écran de cet article proviennent tous d’Excel et du Gestionnaire de cluster HPC. Dans les exemples pratiques inclus dans cet article, les exemples de code sont mis en forme à l’aide d’un style de code qui représente l’éditeur VBA :

'==========================================================
'
' Section 1: Variables and constants
'
'==========================================================

Dim SentRecords As Integer
Dim RcvRecords As Integer

Lorsque des lignes de code sont ajoutées ou modifiées, elles sont mises en surbrillance en vert. La plupart du code inclus ici sont importés à partir de fichiers existants ou copiés entre différents fichiers VBA. Dans ce cas, certaines longues lignes de code peuvent être tronquées pour s’adapter aux marges de ce document. Essayez de copier-coller à partir de documents existants plutôt que de cet article pour éviter d’inclure accidentellement les exemples de code tronqués.

Aperçu

HPC Services pour Excel prend en charge un certain nombre de modèles de programmation pour le développement et l’exécution de calculs Excel sur un cluster MICROSOFT HPC. La solution que vous sélectionnez doit dépendre de vos besoins particuliers et de vos compétences de développement.

Utilisation prévue	Compétences requises	Solution
Calculer des classeurs en parallèle, pour de meilleures performances (temps de calcul plus rapides) ou la possibilité de traiter davantage de données en même temps	Développement VBA (macro) Excel	Exécution de classeurs sur un cluster HPC avec Excel VBA
Créer des applications et des services personnalisés qui exécutent des classeurs Excel sur un cluster HPC et s’intègrent à des applications autonomes ou à des scripts batch	Programmation .NET utilisant C#, VBA.NET ou tout langage pris en charge par le CLR .NET	Développement de services HPC personnalisés et d’applications clientes pour Excel
Accélérer le calcul des fonctions excel User-Defined (UDF) contenues dans les bibliothèques d’extensions Excel (XLLs)	Programmation C ou C++, développement de bibliothèque d’extensions Excel (XLL)	fonctions Cluster-Enabled Excel User-Defined

Nous aborderons chacun de ces modèles de programmation dans les articles futurs. Aujourd’hui, nous allons aborder le premier modèle : calculer des classeurs Excel en parallèle à l’aide uniquement d’Excel VBA. Même si vous souhaitez passer au développement plus complexe avec Excel et Microsoft HPC Pack, il peut s’agir d’un excellent point de départ : il s’agit du moyen le plus simple et le plus rapide d’obtenir des applications Excel s’exécutant sur un cluster HPC, et il vous aidera à comprendre les exigences et les avantages de l’utilisation de HPC Services pour Excel.

Pour prendre en charge les développeurs Excel, HPC Services pour Excel inclut un ensemble de bibliothèques que vous pouvez utiliser directement à partir d’Excel sur votre bureau pour créer et exécuter des classeurs Excel sur un cluster Microsoft HPC. Avec ces bibliothèques, vous n’avez pas besoin de connaître la programmation .NET ou C#. Tout le travail peut être effectué à partir d’Excel en écrivant des macros VBA. Avec cette infrastructure, vous pouvez accélérer considérablement le calcul des classeurs Excel simplement en écrivant du code VBA et en exécutant les classeurs sur le cluster.

HPC Services pour Excel inclut une infrastructure client/service spécifiquement conçue pour être utilisée à partir d’Excel sur le bureau. Il existe deux parties importantes de cette infrastructure : une bibliothèque cliente, installée sur le bureau ; et une bibliothèque de services, qui est installée sur les nœuds de calcul du cluster. Ces bibliothèques sont installées par défaut lorsque vous installez Microsoft HPC Pack. Vous n’aurez donc pas besoin d’effectuer de configuration personnalisée pour les utiliser.

Une fois la bibliothèque cliente et de service installée, vous pouvez créer et exécuter des classeurs Excel pour le cluster en ajoutant simplement des macros VBA à votre classeur. Nous allons décrire ces nouvelles macros VBA comme infrastructure de macros. Lorsque nous faisons référence à l’infrastructure de macros, nous décrivons spécifiquement les nouvelles macros que vous ajoutez à vos classeurs pour prendre en charge le calcul sur un cluster HPC.

Avant de discuter des macros spécifiques, il est important de mettre en évidence quelques concepts clés qui affectent la façon dont les macros sont construites et leur fonctionnement.

Calcul asynchrone

Le concept le plus important à comprendre dans le développement de classeurs pour HPC Services pour Excel et l’utilisation de l’infrastructure de macros est un calcul asynchrone.

Une application Excel classique s’exécute de manière synchrone. Autrement dit, vous appuyez sur un bouton pour exécuter une macro, et la macro exécute du code VBA. Dans ce code, vous pouvez apporter des modifications à la feuille de calcul, appeler d’autres fonctions VBA, accéder aux bases de données ou tout autre élément. Toutefois, vous vous attendez à ce que les macros s’exécutent de début à fin, puis terminées.

Le modèle asynchrone est un peu différent. Dans ce modèle, vous écrivez des fonctions VBA, mais vous ne les appelez pas directement. Au lieu de cela, une bibliothèque cliente (code installé avec HPC Services pour Excel) appelle vos fonctions VBA.

Si vous connaissez les événements Excel dans VBA, vous connaissez déjà ce modèle. Par exemple, si vous écrivez une fonction VBA qui s’exécute sur l’événement Workbook.Open, vous savez que le code s’exécutera chaque fois que le classeur est ouvert. Mais vous n’appelez pas ce code directement ; Au lieu de cela, Excel appelle la fonction que vous écrivez automatiquement lorsque le classeur est ouvert.

Le modèle de programmation asynchrone fonctionne de la même façon. Vous écrivez des fonctions qui seront appelées pendant un calcul, mais au lieu de les appeler vous-même, vous attendez Excel (ou dans ce cas, la bibliothèque HPC Services pour Excel) pour appeler les fonctions.

Calcul itératif et calcul parallèle

Un autre concept important est le calcul itératif. Le calcul itératif fait référence à un type de calcul qui exécute les mêmes étapes de calcul de base sur différents jeux de données.

L’exemple le plus courant de calcul itératif est la simulation Monte Carlo. Dans une simulation Monte Carlo, vous disposez généralement d’un calcul complexe, comme la génération de prix de titres, en fonction d’une valeur d’entrée aléatoire, comme le retour attendu sur plusieurs années. Une simulation Monte Carlo exécute les mêmes milliers de calculs, chaque fois avec une valeur d’entrée aléatoire différente.

Il s’agit d’un calcul itératif, car chaque fois que le prix est calculé, avec une valeur d’entrée aléatoire différente, l’ensemble du calcul est réexécuté. Ces calculs sont indépendants ; autrement dit, dans chaque calcul individuel, il n’y a aucune référence à un calcul antérieur ou ultérieur.

Un autre exemple courant consiste à exécuter un calcul sur un ensemble d’enregistrements d’une base de données. Dans ce cas, vous pouvez avoir un calcul complexe , tel qu’un modèle d’assurance ou d’actuaire, basé sur certains paramètres, comme l’âge et le sexe d’un titulaire d’assurance. Le calcul itératif exécutera le même modèle pour des milliers de titulaires de police individuels. Chaque calcul est indépendant de tous les autres calculs.

L’infrastructure macro que nous abordons ici est conçue pour fonctionner avec ces types de calculs itératifs. Cela est important, car lorsque nous exécutons un calcul sur un cluster HPC, nous allons exécuter le calcul en parallèle . Nous allons exécuter le même calcul plusieurs fois, mais nous allons exécuter plusieurs instances du calcul en même temps sur les nœuds de calcul du cluster.

Si le calcul n’était pas indépendant -- si les résultats d’un calcul unique dépendaient des calculs précédents que nous avions exécutés- cela ne fonctionnerait pas. Par conséquent, le framework que nous abordons ici ne s’applique qu’aux calculs itératifs indépendants, qui peuvent être parallélisés.

Infrastructure de macros

Pour prendre en charge HPC Services pour Excel, votre classeur doit inclure un ensemble de macros qui implémentent les fonctions asynchrones. Il s’agit de l’infrastructure de macros. Il existe six macros utilisées dans l’infrastructure, que vous pouvez ajouter à n’importe quel classeur Excel. Les six macros, avec une brève description de ce qu’elles font, sont

Nom de la macro	Action
HPC_Initialize	Effectuer des étapes de pré-calcul ou d’initialisation
HPC_Partition	Collecter les paramètres requis pour une seule étape de calcul
HPC_Execute	Effectuer une étape de calcul, dans le cadre d’un calcul global plus large
HPC_Merge	Traiter les résultats d’une seule étape de calcul
HPC_Finalize	Effectuer un traitement post-calcul
HPC_ExecutionError	Gérer les erreurs résultant du calcul

(Ne vous inquiétez pas si ces descriptions ne sont pas immédiatement claires : nous allons décrire chacune de ces fonctions plus en détail ci-dessous).

Les mêmes macros doivent être ajoutées à n’importe quelle feuille de calcul pour prendre en charge le calcul sur le cluster, mais ce qui se trouve dans les macros ( les fonctions de calcul spécifiques) peut être différente. Pour simplifier le processus, les fichiers de téléchargement inclus dans cet article incluent un fichier macro « squelette » que vous pouvez importer dans votre classeur. Une fois les macros de base en place, vous pouvez les remplir si nécessaire pour prendre en charge votre calcul.

Chaque macro a un objectif spécifique dans l’infrastructure de macros, et chacune sera appelée par la bibliothèque cliente HPC Services pour Excel lors d’un calcul de cluster. Lorsqu’un calcul s’exécute, chaque macro est appelée à un point spécifique. Un calcul classique s’exécute comme suit :

Lorsqu’un calcul de cluster s’exécute, la bibliothèque cliente appelle d’abord la macro HPC_Initialize . Utilisé pour gérer toute initialisation requise ; par exemple, vous souhaiterez peut-être effacer les anciens résultats de votre feuille de calcul.

Ensuite, le calcul s’exécute via trois macros : HPC_Partition, HPC_Execute et HPC_Merge. Dans le diagramme ci-dessus, ceux-ci sont présentés sous forme de boucle. Ce n’est pas vraiment ce qui se passe pendant un calcul, mais logiquement vous pouvez considérer cela comme une boucle. Tout d’abord, la bibliothèque cliente appelle HPC_Partition. HPC_Partition est conçu pour collecter toutes les données requises pour une seule étape de calcul. Par exemple, si vous souhaitez calculer un ensemble de lignes un par un, HPC_Partition peut renvoyer le numéro de ligne d’une seule étape : première ligne 1, ligne 2, et ainsi de suite.

Ensuite, la macro HPC_Execute est appelée. Cette macro exécute le calcul réel. Si nous calculons une ligne par ligne, cela calcule une seule ligne. HPC_Execute retourne le résultat du calcul : par exemple, il peut renvoyer la dernière cellule de la ligne, qui est le résultat final d’un calcul plus long.

Après HPC_Execute, la bibliothèque cliente appelle HPC_Merge. Quelle que soit la HPC_Execute calculée sera envoyée à HPC_Merge. La macro HPC_Merge est conçue pour prendre ces résultats et les retourner à la feuille de calcul s’exécutant sur votre bureau. Dans la macro HPC_Merge , vous pouvez insérer les résultats de calcul dans votre feuille de calcul ou les écrire dans un fichier journal.

Ces trois macros ( HPC_Partition, HPC_Execute et HPC_Merge ) sont appelées plusieurs fois, une fois pour chaque étape de votre calcul, jusqu’à ce que l’intégralité du calcul soit terminée. Ces macros implémentent le modèle de calcul itératif décrit ci-dessus. Les macros peuvent être appelées plusieurs fois pendant un seul calcul de classeur, mais chaque fois qu’elles sont appelées représente une étape de calcul unique ou une itération.

Une fois la dernière étape de calcul terminée, la bibliothèque cliente appelle HPC_Finalize. Vous pouvez utiliser cette macro pour effectuer tout traitement post-calcul : par exemple, vous pouvez rechercher la moyenne de toutes les étapes de calcul précédentes à l’aide d’une autre macro VBA.

La sixième et dernière macro, HPC_ExecutionError, est utilisée uniquement lorsque le calcul rencontre une erreur. Si c’est le cas, cette macro est appelée et vous pouvez ajouter du code de gestion des erreurs. Par exemple, vous pouvez afficher une boîte de dialogue contextuelle à l’utilisateur qui les avertit de l’erreur.

Dans le diagramme ci-dessus, la macro HPC_Execute est mise en surbrillance en orange. C’est pour indiquer que cette macro est quelque peu inhabituelle. Toutes les autres macros s’exécutent sur le bureau, dans Excel sur votre station de travail. Quand nous exécutons un calcul sur un cluster HPC, toutefois, la macro HPC_Execute s’exécute réellement sur les nœuds de calcul du cluster.

C’est ainsi que HPC Services pour Excel et l’infrastructure de macros prennent en charge le calcul du cluster. Bien que nous écrivions toutes les macros dans le même classeur - le classeur sur votre bureau - lorsque le calcul s’exécute, le classeur sera copié sur les nœuds de calcul du cluster et la macro HPC_Execute sera exécutée sur l’un des nœuds de calcul.

Il est important de comprendre cela, car il a des implications pour la façon dont les classeurs utilisent et gèrent les données pendant le calcul. Les trois macros de calcul principales ( HPC_Partition, HPC_Execute et HPC_Merge ) transmettent les données au cours du processus de calcul. Dans une application VBA classique, il existe de nombreuses façons de partager des données entre différentes macros. Par exemple, vous pouvez utiliser des variables globales dans votre code VBA ou écrire des valeurs dans des cellules de feuille de calcul. Toutefois, lorsque nous exécutons le calcul sur un cluster HPC, nous devons envoyer des données entre les macros exécutées sur le bureau et la macro HPC_Execute s’exécutant sur les nœuds de calcul.

Pour cette raison, toutes les données dont nous avons besoin pour exécuter le calcul doivent être envoyées directement à partir de la macro HPC_Partition vers la macro HPC_Execute . Pour ce faire, nous utilisons la valeur de retour de la macro HPC_Partition . Cette valeur de retour devient l’argument (ou le paramètre) à la fonction HPC_Execute . Ainsi, les données passent directement entre ces deux macros, et vous pouvez passer n’importe quelle valeur ou ensemble de valeurs (en tant que tableau) entre ces macros. Mais là encore, vous ne pouvez pas utiliser des variables globales ou les cellules de feuille de calcul pour transmettre des informations entre les deux macros, car lorsqu’elles s’exécutent sur le cluster, il existe en fait plusieurs copies du classeur s’exécutant en même temps - une sur le bureau et une (ou plusieurs) sur les nœuds de calcul du cluster.

De la même façon, lorsque le calcul dans HPC_Execute est terminé, il retourne un résultat comme valeur de retour de la fonction macro. Ce résultat devient l’argument (ou le paramètre) à la macro suivante, HPC_Merge. Une fois de plus, tous les résultats que vous souhaitez retourner -- les résultats du calcul -- doivent être envoyés de cette façon, comme valeur de retour de la fonction.

Création de classeurs Cluster-Enabled avec Excel et HPC Services pour Excel

Dans les sections qui suivent, nous allons découvrir la création de deux classeurs qui prennent en charge le calcul sur un cluster HPC. Dans la première section, nous allons générer un classeur à partir de zéro. Cela doit vous aider à comprendre les concepts impliqués et les exigences relatives à l’utilisation de HPC Services pour Excel. Dans la deuxième section, nous allons prendre un classeur existant ( un classeur conçu pour s’exécuter sur le bureau) et le convertir afin qu’il puisse s’exécuter sur le cluster.

Avant de commencer : Conditions préalables et conditions requises

HPC Services pour Excel est un ensemble d’outils inclus dans Microsoft HPC Pack 2008 R2 Beta 2 et versions ultérieures. Vous aurez besoin d’un cluster Microsoft HPC Pack installé et configuré. L’installation d’un cluster HPC est en dehors de l’étendue de cet article ; Nous allons uniquement traiter la configuration spécifique dont vous aurez besoin pour HPC Services pour Excel. Pour plus d’informations sur l’installation et la configuration du cluster, consultez la documentation fournie avec Microsoft HPC Pack. Sur votre bureau, vous aurez besoin des utilitaires clients HPC Pack.

Sur le cluster

Une fois que vous disposez d’un cluster HPC opérationnel, vous devez installer Excel sur les nœuds de calcul du cluster. Vous pouvez utiliser le kit d’installation Office standard pour installer Excel ou consulter la documentation HPC Pack pour plus d’informations sur l’automatisation de l’installation d’Excel.

Une fois Excel installé sur vos nœuds de calcul de cluster, vous pouvez exécuter le test de diagnostic HPC pour vous assurer que tout est configuré correctement. Pour exécuter le test de diagnostic, utilisez HPC Cluster Manager (sur le nœud principal du cluster, où il est installé par défaut ou sur votre bureau si vous avez installé les utilitaires clients).

Pour vérifier que le service HPC pour Excel est correctement configuré

Dans le Gestionnaire de cluster HPC, cliquez sur Diagnostics.
Dans Tests, développez Microsoft , puis sélectionnez Excel.
Dans le volet d’affichage, double-cliquez sur Test de configuration Excel Runner.
Dans la boîte de dialogue de configuration, sélectionnez Tous les nœuds , puis cliquez sur Exécuter.
Dans le volet de navigation, cliquez sur Résultats des tests pour afficher la progression du test. Le test que vous exécutez s’affiche dans le volet d’affichage.
Une fois le test terminé, vous pouvez cliquer sur le test dans la fenêtre principale pour afficher les résultats.

Si le test affiche Échec, double-cliquez sur le test et essayez de corriger les erreurs dans la fenêtre contextuelle. Les erreurs courantes que vous pouvez constater sont qu’Excel n’est pas installé sur un nœud de calcul ou qu’Excel n’a pas été activé. Apportez les modifications dont vous avez besoin, puis réexécutez le test de diagnostic à l’aide des instructions ci-dessus.

Lorsque le test affiche La réussite, vous êtes prêt à continuer.

La dernière chose dont vous aurez besoin est un répertoire de partage. Lorsque nous calculons un classeur sur un cluster HPC, chacun des nœuds de calcul du cluster charge et exécute une copie du classeur. Pour prendre en charge cela, vous devez créer un répertoire de partage visible à la fois aux nœuds de calcul du cluster et à votre bureau.

Si vous avez accès au nœud principal du cluster, créez un répertoire de partage sur le nœud principal. Cela est pratique, car vous savez que les nœuds de calcul du cluster peuvent accéder au nœud principal. Si vous ne pouvez pas créer un répertoire de partage sur le nœud principal, créez le répertoire de partage n’importe où dans le domaine accessible à la fois à votre bureau et aux nœuds de calcul du cluster.

Sur le bureau

Sur le bureau, vous devez installer Excel et les utilitaires clients Microsoft HPC Pack (l’installation des utilitaires clients nécessite des autorisations d’administrateur). Pour installer les utilitaires clients, exécutez le programme d’installation HPC Pack sur votre bureau. Il offre une option permettant d’installer uniquement les utilitaires clients.

1539325029907

Résumé

Vous devez maintenant disposer des points suivants :

Un cluster Microsoft HPC installé et configuré.
Excel 2016 (ou version ultérieure) installé sur les nœuds de calcul du cluster.
Un répertoire de partage réseau.
Excel 2016 (ou version ultérieure) et les utilitaires clients Windows HPC Pack installés sur votre bureau.

Lorsque tout ce qui est prêt, vous pouvez commencer à créer des classeurs qui s’exécutent sur le cluster avec HPC Services pour Excel.

Partie I : Création d’un classeur à partir de zéro

Cette partie comprend les sections suivantes :

Démarrage d’un nouveau classeur
Préparation du classeur
Conception du calcul du cluster
Exécution du classeur sur le cluster
Dernières étapes : Interface utilisateur

Démarrage d’un nouveau classeur

Démarrez Excel avec un nouveau classeur. Nous allons utiliser VBA pour vous assurer que vous disposez de l’onglet Développeur disponible sur le ruban Excel.

Pour activer l’onglet Développeur

Cliquez sur l’onglet Fichier du ruban Excel.
Cliquez sur Options.
Dans la boîte de dialogue Options Excel, sélectionnez Personnaliser le ruban à gauche.
Cochez la case en regard du développeur , puis cliquez sur OK pour fermer la boîte de dialogue.

1539325069612

Préparation du classeur

Pour préparer votre classeur, vous devez importer les fichiers macro et ajouter les références HPC.

Pour générer le classeur de base, nous aurons besoin de deux ensembles de macros. Le premier ensemble de macros implémente les fonctions d’infrastructure (les fonctions décrites dans la section Vue d’ensemble ci-dessus). Ces macros sont utilisées par la bibliothèque cliente HPC Services pour Excel pendant le calcul. Le deuxième jeu de macros contient les fonctions « contrôle » : ces macros exécutent le calcul réel.

Les exemples de fichiers incluent des fichiers macros « squelette » de base pour chacun de ces fichiers que vous pouvez utiliser pour commencer. Vous n’avez pas besoin d’utiliser ces fichiers . Vous pouvez également écrire vos propres fichiers, si vous préférez , mais les macros elles-mêmes sont génériques et vous pouvez constater que l’utilisation de ces fichiers est tout ce dont vous avez besoin. Vous pouvez également modifier ces fichiers pour apporter les modifications dont vous avez besoin pour votre classeur particulier.

Nous devons ajouter deux références à ce projet pour utiliser HPC Services : Microsoft_Hpc_Excel et Microsoft_Hpc_Scheduler_Properties. Microsoft_Hpc_Excel est la bibliothèque cliente, qui fournit un objet que nous pouvons utiliser pour contrôler un calcul de cluster. Microsoft_Hpc_Scheduler_Properties a des définitions pour certains champs et types spécifiques au cluster dont nous aurons besoin.

Remarque : Dans la section Vue d’ensemble ci-dessus, nous avons décrit les outils en tant que framework client/serveur ; la bibliothèque cliente a été installée lorsque vous avez installé le Kit de développement logiciel (SDK) HPC Pack et qu’elle sera désormais disponible dans VBA.

Pour importer les fichiers macro et ajouter des références

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, cliquez avec le bouton droit sur Projet VBA en haut de l’arborescence, puis cliquez sur Importer un fichier.
Dans la boîte de dialogue, recherchez les fichiers projet que vous avez téléchargés. Accédez au répertoire « First Workbook », sélectionnez le fichier « HPC Excel Macros.bas », puis cliquez sur OK. Cela ajoute le premier fichier macro à votre projet et sera disponible dans le dossier Modules de la fenêtre du projet VBA.
Répétez les étapes 1 à 3 pour importer « HPC Control Macros.bas », puis cliquez sur OK. Cela ajoute le deuxième fichier macro à votre projet.
Vérifiez que ces deux fichiers macro apparaissent dans la fenêtre du projet VBA :
Dans la fenêtre de l’éditeur VBA, cliquez sur Outils, puis sur Références pour ouvrir la boîte de dialogue Références de projet.
Dans la liste des références disponibles, faites défiler jusqu’à ce que vous trouviez les assemblys HPC Pack Microsoft (R), puis cochez la case en regard de chacune d’elles. Lorsque vous avez coché les cases, la boîte de dialogue se présente comme suit :
Cliquez sur OK pour fermer la boîte de dialogue références de projet.

Si vous ne trouvez pas cette entrée dans la liste, cliquez sur Parcourir.. Et recherchez le fichier %CCP_HOME%\Bin\Microsoft.Hpc.Excel.tlb. Si vous ne le trouvez toujours pas, vérifiez que vous avez installé les composants du client HPC Pack. Si les fichiers sont installés, le panneau de configuration Ajouter/Supprimer des programmes affiche une entrée pour « Microsoft HPC Pack Client Components ». Si vous ne voyez pas cette entrée, essayez de réinstaller les composants clients, comme décrit dans la section ci-dessus « Avant de commencer ».

Définition des calculs dans l’infrastructure de macros

Notre objectif de création de ce classeur est d’illustrer le fonctionnement d’un calcul de cluster. Nous n’avons donc pas besoin de créer une feuille de calcul très complexe. Nous allons construire un calcul qui exécute 100 étapes individuelles. Pour ce faire, nous allons ajouter un compteur au fichier de macros EXCEL HPC et utiliser ce compteur dans les macros lorsque le calcul s’exécute.

Nous allons utiliser le compteur pour suivre le nombre d’étapes de calcul envoyées. Nous pouvons donc limiter le calcul à 100 étapes. HPC_Initialize est appelée chaque fois que nous commençons un nouveau calcul, afin de pouvoir réinitialiser le compteur dans cette fonction. Nous voulons incrémenter le compteur pour chaque étape de calcul. Nous pouvons le faire dans la macro HPC_Partition . N’oubliez pas que la macro HPC_Partition est utilisée pour collecter les données nécessaires à une étape de calcul individuelle ; et une fois le calcul terminé, la macro HPC_Partition doit retourner Null. Ainsi, pour exécuter un calcul pour 100 étapes, nous incrémenterons le compteur chaque fois que HPC_Partition est appelée ; et une fois que le compteur atteint 100, nous retournerons Null.

Pour construire un calcul qui exécute 100 étapes

Dans la fenêtre du projet VBA, dans le dossier Modules , double-cliquez sur HPCExcelMacros.

En haut du fichier, dans « Section 1 : Variables et constantes », ajoutez une variable de compteur nommée SentRecords, comme indiqué ci-dessous :

'==========================================================
'
' Section 1: Variables and constants
'
'==========================================================

Dim SentRecords As Integer

Faites défiler jusqu’à ce que vous trouviez la fonction HPC_Initialize , puis ajoutez une ligne pour réinitialiser la variable de compteur :

'----------------------------------------------------------
'
' 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 Function

Faites défiler vers le bas jusqu’à trouver la macro HPC_Partition, puis modifiez-la pour qu’elle ressemble à ceci :

Public Function HPC_Partition() As Variant

    If SentRecords = 100 Then
        HPC_Partition = Null
    Else
        SentRecords = SentRecords + 1
        HPC_Partition = SentRecords
    End If

End Function

Enregistrez le classeur.

Remarque : Étant donné que le nouveau classeur inclut des macros, vous devez l’enregistrer sous la forme d’un classeur prenant en charge les macros (fichier XLSM) ou d’un classeur binaire (fichier XLSB). L’une ou l’autre est bien. Nous vous recommandons généralement d’enregistrer des classeurs sous forme de fichiers binaires (XLSB), car ils sont plus petits et un peu plus efficaces.

Maintenant, nous avons un calcul qui exécutera 100 étapes, puis terminé. Les modifications que vous venez d’apporter sont tout ce que vous devez faire pour créer un calcul de cluster Excel.

Exécution du classeur localement et exploration des macros

Maintenant que nous avons un calcul, nous pouvons ajouter un bouton pour exécuter le classeur, puis exécuter le classeur sur le bureau. Pour voir comment fonctionnent les macros, nous allons ajouter quelques nouveaux éléments de code à notre squelette de macro et réexécuter le classeur pour voir ce que les modifications ont fait. Nous allons tester le classeur localement (sur le bureau) avant d’exécuter le classeur sur le cluster.

Ajout d’un bouton qui exécute le classeur localement

Pour ajouter un bouton qui exécute le classeur localement

Une fois votre classeur Excel ouvert, cliquez sur l’onglet Développeur du ruban.
Sous l’onglet Développeur , cliquez sur Insérer , puis sélectionnez le contrôle de bouton : le premier contrôle de la liste.
Une fois que vous avez cliqué sur le bouton, dessinez un rectangle quelque part dans la feuille de calcul pour insérer le bouton à cet emplacement. Une fois que vous avez positionner le bouton, la boîte de dialogue Affecter une macro s’affiche.
Dans la boîte de dialogue, sélectionnez la macro CalculateWorkbookOnDesktop dans la liste, puis cliquez sur OK. Veillez à sélectionner la macro de bureau : nous voulons d’abord tester le classeur et trouver des erreurs avant de l’exécuter sur le cluster.
Cliquez avec le bouton droit sur le nouveau bouton, puis sélectionnez Modifier le texte pour modifier l’étiquette.
Nommez l’étiquette « Desktop » ou quelque chose de similaire.
Si vous le souhaitez, vous pouvez vérifier que vous avez affecté la macro correcte en cliquant avec le bouton droit sur le bouton et en sélectionnant Affecter une macro. Dans la boîte de dialogue, vérifiez que CalculateWorkbookOnDesktop est sélectionné.
Enregistrez le classeur.
Cliquez sur le bouton pour exécuter le classeur sur le bureau.

S’il existe des erreurs, vous verrez une boîte de dialogue d’erreur et la partie du code VBA avec l’erreur sera mise en surbrillance . Revenez en arrière sur les sections ci-dessus et vérifiez que tout semble correct.

Si tout fonctionne, rien ne se produit parce que notre classeur ne fait rien. C’est un peu insatisfaisant. Nous allons donc apporter quelques modifications supplémentaires afin que nous puissions voir le calcul.

Modification des HPC_Excecute et des macros HPC_Merge

N’oubliez pas que le flux d’informations passe de HPC_Partition (qui collecte les paramètres nécessaires au calcul), à HPC_Execute (qui exécute le calcul), puis à HPC_Merge (qui traite le résultat). Lorsqu’un calcul s’exécute, tout ce qui est retourné à partir de la macro HPC_Partition est utilisé comme entrée de la macro HPC_Execute . La macro HPC_Execute est conçue pour utiliser ces données d’entrée, effectuer une étape de calcul, puis retourner un résultat. Le résultat passe ensuite à HPC_Merge, ce qui peut insérer les résultats dans la feuille de calcul.

Dans une étape antérieure, vous avez ajouté du code à la macro HPC_Partition pour mettre à jour une variable de compteur. Dans notre exemple, HPC_Partition retourne la valeur de la variable de compteur et passe cette valeur à HPC_Execute. Pour illustrer le flux d’informations et faire en sorte que notre classeur retourne des résultats, nous transmettons simplement cette valeur de compteur dans les macros. Nous allons ajouter une ligne de code à la macro HPC_Execute afin qu’elle accepte l’entrée et la transmet comme valeur de retour. La valeur de notre variable de compteur passe ensuite à la macro HPC_Merge , que nous allons modifier afin qu’elle insère la valeur du compteur dans notre feuille de calcul.

Pour modifier HPC_Execute et HPC_Merge

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, dans l’arborescence du projet, double-cliquez sur le module HPCExcelMacros pour ouvrir le fichier macro.
. Faites défiler jusqu’à la macro HPC_Execute et ajoutez une ligne de code qui transmet la valeur d’entrée le long de la valeur de retour. La macro doit ressembler à ceci :
```
Public Function HPC_Execute(data As Variant) As Variant

    HPC_Execute = data

End Function
```
Faites défiler jusqu’à la macro HPC_Merge et ajoutez une ligne de code pour insérer la valeur d’entrée dans la feuille de calcul. La macro doit ressembler à ceci :
```
Public Function HPC_Merge(data As Variant)

    Cells(data, 1).Value = data

End Function
```
Remarque : la valeur « data » est le compteur, qui a été retourné par HPC_Execute. Ici, dans la macro HPC_Merge , nous remplissons une cellule dans la feuille de calcul - en utilisant le compteur comme numéro de ligne - et en définissant la valeur comme compteur. L’expression VBA « Cells » signifie créer une référence dans la feuille de calcul avec les numéros de ligne et de colonne donnés. Ainsi, chaque fois que la macro HPC_Merge est appelée, elle insère une valeur dans la colonne 1 (colonne A dans la feuille de calcul), avec un numéro de ligne différent.
Revenez maintenant à la feuille de calcul et cliquez sur votre bouton « Bureau » pour exécuter le calcul.

Vous verrez la première colonne remplir les nombres compris entre 1 et 100, qui sont les valeurs du compteur. Chaque fois que vous cliquez sur le bouton, il remplira les mêmes nombres. Il est donc difficile de dire qu’il est en cours d’exécution ; nous pouvons apporter une modification plus petite pour voir les nombres renseignés.

Modification de la macro HPC_Initialize

La macro HPC_Initialize est appelée lors de la première exécution du classeur. Dans une étape antérieure, nous avons ajouté une ligne de code pour réinitialiser la variable de compteur. Nous pouvons également utiliser cette macro pour effacer les valeurs qui ont été insérées dans la feuille de calcul pendant l’exécution précédente.

Pour modifier la macro HPC_Initialize

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, dans l’arborescence du projet, double-cliquez sur le module HPCExcelMacros pour ouvrir le fichier macro.
Faites défiler jusqu’à la macro HPC_Initialize*.** Ajoutez une ligne de code qui vide la première colonne. La macro doit ressembler à ceci :
```
Public Function HPC_Initialize()

    Range("A:A").Value = ""
    SentRecords = 0

End Function
```
Revenez maintenant à la feuille de calcul et cliquez sur votre bouton « Bureau » pour exécuter le calcul.

Il doit maintenant être évident que la macro remplit la colonne avec des nombres chaque fois que vous cliquez dessus. S’il existe des erreurs, vous verrez un message d’erreur et le code VBA avec l’erreur sera mis en surbrillance. Vérifiez deux fois qu’il correspond au code répertorié ci-dessus et réessayez.

Exécution du classeur sur le cluster

Maintenant, nous avons un calcul Excel très simple à l’aide de l’infrastructure de macro HPC, et nous pouvons l’exécuter sur le cluster. Pour ce faire, nous devons d’abord définir quelques valeurs pour indiquer à Excel comment contacter le cluster. Ces valeurs sont définies dans le module HPCControlMacros **.** En haut de ce fichier, vous devez renseigner deux valeurs : le planificateur de cluster et le répertoire de partage. N’oubliez pas que vous (l’utilisateur de bureau) devez avoir un accès en écriture à ce répertoire de partage ; et les nœuds de calcul du cluster doivent disposer d’un accès en lecture au répertoire. Dans la plupart des cas, vos calculs de cluster s’exécutent sous votre compte d’utilisateur, mais il est possible d’utiliser un autre compte d’utilisateur lorsque vous vous connectez à la session de cluster (plus en un instant).

Pour spécifier le nœud principal et le répertoire de partage

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, dans l’arborescence du projet, double-cliquez sur le module HPCControlMacros pour ouvrir le fichier macro.
Pour le planificateur de cluster, utilisez le nom de votre nœud principal de cluster. Il s’agit du nom de l’ordinateur que vous utiliseriez sur le réseau. Vous pouvez utiliser un nom complet (par exemple, headnode.mynetwork.com), mais cela n’est pas nécessaire si vous êtes dans le même domaine.
Pour le répertoire de partage, utilisez le chemin complet du répertoire de partage que vous avez créé précédemment (dans la section « Avant de commencer »).

Par exemple, dans mon cluster, le nom du planificateur est « HN01 » ; et j’ai créé un répertoire de partage sur le nœud principal appelé « HPCTemp ». Mes paramètres ressemblent donc à ceci :

'----------------------------------------------------------
'
' 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"

Revenez maintenant à la feuille de calcul Excel. Nous allons ajouter un autre bouton, cette fois pour exécuter le calcul sur le cluster.

Pour ajouter un bouton qui exécute le classeur sur le cluster

Sous l’onglet Développeur , cliquez sur Insérer , puis sélectionnez le contrôle de bouton : le premier contrôle de la liste.
Une fois que vous avez cliqué sur le bouton, dessinez un rectangle quelque part dans la feuille de calcul pour insérer le bouton à cet emplacement. Une fois que vous avez positionner le bouton, la boîte de dialogue Affecter une macro s’affiche.
Dans la boîte de dialogue, sélectionnez la macro CalculateWorkbookOnCluster dans la liste, puis cliquez sur OK.
Cliquez avec le bouton droit sur le nouveau bouton, puis sélectionnez Modifier le texte pour modifier l’étiquette.
Nommez l’étiquette « Cluster » ou quelque chose de similaire.
Enregistrez le classeur.
Cliquez sur le bouton pour exécuter le classeur sur le cluster.
Si c’est la première fois que vous avez exécuté des travaux de cluster, à l’aide d’Excel ou à l’aide d’une autre application, une boîte de dialogue d’authentification utilisateur s’affiche. Tapez votre nom d’utilisateur et votre mot de passe, puis cochez la case pour enregistrer vos informations d’identification. Si vous souhaitez exécuter des calculs sur le cluster en tant qu’utilisateur différent, vous pouvez entrer différents paramètres de compte d’utilisateur.

Remarque : Assurez-vous que votre compte d’utilisateur (soit votre compte d’utilisateur standard, soit tout ce que vous souhaitez utiliser) est désigné en tant qu’utilisateur de cluster dans HPC Cluster Manager.

S’il existe des erreurs, vous verrez une boîte de message décrivant l’erreur. Si le calcul a fonctionné sur le bureau, les erreurs les plus probables que vous recevrez doivent maintenant faire avec les paramètres du cluster - le nœud principal ou le répertoire de partage. Si la zone de message décrit l’une de ces erreurs, cochez deux fois les paramètres que vous avez modifiés à la dernière étape. Vérifiez que vous disposez du nom correct pour le nœud principal du cluster et que le répertoire de partage est accessible en écriture par votre compte d’utilisateur.

Que se passe-t-il lorsqu’un classeur s’exécute sur le cluster

Examinons ce qui se passe lorsque vous exécutez le calcul du cluster. Lorsque vous cliquez sur le bouton, il appelle la macro CalculateWorkbookOnCluster. Cette macro utilise la bibliothèque cliente pour démarrer un calcul de cluster avec les paramètres que vous avez fournis pour le nœud principal du cluster et le répertoire de partage.

Au démarrage du calcul, le code client HPC Services pour Excel prend le relais. N’oubliez pas que vous avez ajouté une référence à la bibliothèque HPC dans l’éditeur VBA au début de cette partie , c’est-à-dire la bibliothèque cliente. Tout d’abord, la bibliothèque cliente crée une « session » de cluster, utilisée pour gérer le calcul. Cela prend quelques secondes, et après avoir cliqué sur le bouton, vous remarquerez un délai de quelques secondes.

Ensuite, la bibliothèque cliente appelle la macro HPC_Initialize . Cela se produit sur le bureau. Dans ce classeur, cette macro (1) réinitialise le compteur interne ; et (2) vide la colonne A dans la feuille de calcul. Par conséquent, lorsque vous cliquez sur le bouton, vous verrez d’abord le délai lors de la création de la session ; puis vous verrez la colonne A est effacée. C’est la macro HPC_Initialize .

Ensuite, la bibliothèque cliente commence à appeler la macro HPC_Partition . Cela se produit également sur le bureau. Dans notre code, la macro HPC_Partition incrémente le compteur et retourne la valeur du compteur. Chaque fois que cette macro retourne une valeur (jusqu’à ce qu’elle retourne Null, lors du dernier appel), la bibliothèque cliente envoie une requête au planificateur HPC.

Lorsque le planificateur reçoit l’une de ces demandes, il transfère la requête à l’un des nœuds de calcul du cluster pour le traitement. Lorsque le nœud de calcul reçoit la requête, il démarre Excel, charge le classeur, puis appelle la macro HPC_Execute .

Il s’agit de la macro HPC_Execute que nous avons dans notre classeur, mais lorsque le calcul s’exécute sur le cluster, la macro HPC_Execute est réellement exécutée sur les nœuds de calcul , contrairement à toutes les autres macros. C’est pourquoi nous transmettons des données d’une macro à une autre. Les informations circulent d’une macro à l’autre, mais à mesure que les données sont passées de la macro HPC_Partition à la macro HPC_Execute , elles sont envoyées à partir du bureau, via le planificateur HPC et à l’un des nœuds de calcul.

Une fois que l’un des nœuds de calcul exécute la macro HPC_Execute , lorsque la macro est terminée, le résultat du calcul -- la valeur retournée par la macro HPC_Execute -- est renvoyée au planificateur, puis retournée à la bibliothèque cliente sur le bureau. Lorsque la bibliothèque cliente reçoit le résultat du calcul, elle appelle la macro HPC_Merge sur le bureau. Par conséquent, une fois de plus, vous pouvez considérer les informations qui circulent d’une macro (HPC_Execute) à la suivante (HPC_Merge), mais cela se produit sur le réseau : du classeur en cours d’exécution sur le nœud de calcul au classeur s’exécutant sur le bureau.

Il est important de comprendre que ces appels de fonction macro - chacun des appels à HPC_Partition, lorsque nous envoyons des données au cluster, et chacun des appels à HPC_Merge, à mesure que les données sont reçues - se produisent de manière asynchrone. Autrement dit, lorsqu’un calcul est envoyé au cluster, la bibliothèque cliente n’attend pas (ou bloque) tant que ce calcul particulier n’est pas terminé avant d’envoyer le suivant. Si la macro HPC_Partition est très rapide, comme dans ce cas, il est possible que toutes les 100 demandes de calcul soient envoyées avant la fin de l’une de ces requêtes.

Il est également important de noter que, à mesure que les résultats reviennent du cluster - et que la macro HPC_Merge est appelée dans notre classeur - elles peuvent ne pas revenir dans le même ordre que celui que nous avons envoyé. Cela est dû au fait que chaque requête est envoyée au cluster, le planificateur l’transfère à un nœud de calcul particulier. Le nœud de calcul calcul calcule la requête à l’aide de la macro HPC_Execute dans le classeur, puis renvoie le résultat. Toutefois, pour plusieurs raisons, un nœud de calcul peut s’exécuter plus lentement ou plus rapidement qu’un autre nœud de calcul ; et si cela se produit, les résultats peuvent être retournés dans un ordre différent.

Vous ne remarquerez probablement pas que dans ce classeur, car les macros sont si simples. Mais c’est quelque chose que nous devrons préparer dans des classeurs plus complexes, car nous avons des fonctions de calcul plus longues et nous allons l’aborder ci-dessous lorsque nous créons un classeur « réel ».

Communication de la progression du calcul

À ce stade, vous avez créé un classeur complet qui s’exécute sur le cluster HPC ; vous devez maintenant comprendre ce que font les différentes macros et pourquoi elles sont conçues comme elles le sont. Vous devez avoir une idée de la façon dont les données se déplacent entre les macros et les parties exécutées sur le bureau et sur le cluster.

Avant de terminer avec le classeur simple, nous pouvons apporter quelques modifications finales pour ajouter des commentaires visuels, essentiellement une interface utilisateur simple. Lorsque vous avez exécuté le classeur sur le cluster, le seul commentaire que vous aviez que cela fonctionnait était les nombres renseignés dans la feuille de calcul. C’est un début, mais nous pouvons apporter des modifications qui rendent plus évidente ce que fait le classeur. Ce que nous allons faire, c’est ajouter quelques variables supplémentaires pour suivre le calcul, puis les afficher dans la barre d’état Excel.

Notre code inclut les compteurs suivants :

Nous avons déjà une variable de compteur qui suit le nombre de fois où HPC_Partition macro a été appelée. Cela représente le nombre de fois où les données ont été envoyées du bureau au cluster.
Nous pouvons ajouter un autre compteur incrémenté chaque fois que la macro HPC_Merge est appelée , qui représente le nombre de fois où les données sont renvoyées du cluster au bureau.
Nous pouvons également ajouter certaines variables pour assurer le suivi du temps : combien de temps le calcul prend. Cela peut être très utile pour vérifier si le calcul du cluster est en fait plus rapide que le bureau (et si c’est le cas, combien plus rapide).

À l’aide de ces deux premiers compteurs, nous pouvons voir le nombre de requêtes en attente et avoir une idée de la progression globale du calcul. Nous allons ajouter une nouvelle fonction VBA qui peut signaler l’état du calcul. Cette fonction comporte trois parties :

Il crée une chaîne montrant le nombre de calculs envoyés (le nombre de fois où HPC_Partition a été appelée) et le nombre de résultats reçus (le nombre de fois où HPC_Merge a été appelé).
Si la variable « CalculationComplete » a la valeur true, elle met à jour la chaîne pour afficher le temps de calcul total.
Il utilise Application.StatusBar pour définir le message de barre d’état Excel avec les informations que nous venons de créer.

Nous pouvons utiliser les macros HPC déjà en place pour mettre à jour ces valeurs et mettre à jour le message de barre d’état avec la nouvelle fonction.

La procédure suivante décrit comment incorporer ces nouveaux éléments dans notre exemple.

Pour ajouter des variables de progression aux macros et mettre à jour la barre d’état Excel

Revenez à l’éditeur VBA, puis double-cliquez sur le module HPCExcelMacros pour ouvrir le code de macro. En haut du code VBA, après le compteur d’origine, ajoutez ces nouvelles variables :

'==========================================================
'
' Section 1: Variables and constants
'
'==========================================================

Dim SentRecords As Integer
Dim RcvRecords As Integer
Dim CalculationComplete As Boolean
Dim StartTime As Double
Dim FinishTime As Double

Ensuite, nous allons ajouter une nouvelle fonction VBA appelée « UpdateStatus » qui peut signaler l’état du calcul. Faites défiler jusqu’au bas du fichier et ajoutez du code comme suit :

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 Sub

Nous devons initialiser les variables. Comme avec le compteur d’origine, nous allons le faire dans la macro HPC_Initialize . Faites défiler jusqu’à cette macro et ajoutez quelques lignes :
```
Public Function HPC_Initialize()

    Range("A:A").Value = ""
    SentRecords = 0
    RcvRecords = 0
    StartTime = Timer
    CalculationComplete = False
    UpdateStatus

End Function
```
Remarque : Ce que nous faisons ici est (1) effacer les deux compteurs, en les définissant sur zéro ; (2) la définition de la valeur « StartTime » sur l’heure actuelle (l’appel « Minuteur » dans VBA retourne l’heure actuelle, en secondes) ; et (3) définissant l’indicateur « CalculationComplete » sur false, ce qui signifie qu’il n’a pas encore terminé. Une fois ces valeurs définies, nous appelons la nouvelle macro « UpdateStatus » pour écrire le message dans la barre d’état.
Faites défiler jusqu’à la macro HPC_Partition . Dans cette macro, nous définissons déjà le premier compteur. Nous devons donc apporter une seule modification : après la mise à jour du compteur, nous ajoutons une ligne pour appeler la nouvelle macro et mettre à jour la barre d’état.
```
Public Function HPC_Partition() As Variant

    If SentRecords = 100 Then
        HPC_Partition = Null
    Else
        SentRecords = SentRecords + 1
        UpdateStatus
        HPC_Partition = SentRecords
    End If

End Function
```
Faites maintenant défiler jusqu’à la macro HPC_Merge . Ici, nous voulons mettre à jour le nouveau compteur ( celui qui représente les messages retournés au bureau) et mettez à jour à nouveau la barre d’état. Modifiez donc la macro HPC_Merge :
```
Public Function HPC_Merge(data As Variant)

    Cells(data, 1).Value = data
    RcvRecords = RcvRecords + 1
    UpdateStatus

End Function
```
Faites défiler jusqu’à la macro HPC_Finalize . Cette macro est appelée lorsque le calcul entier est terminé ; nous pouvons donc l’utiliser pour définir l’indicateur « CalculationComplete », ainsi que pour déterminer la durée pendant laquelle le calcul total a pris :
```
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 Function
```
Remarque : Lorsque nous définissons le champ « FinishTime » sur Minuteur, nous le définissons avec l’heure actuelle, en secondes. Dans la macro UpdateStatus, nous utilisons « StartTime » et « FinishTime » pour déterminer le temps de calcul total.
Enregistrer le classeur
Revenez à la feuille de calcul Excel et cliquez sur le bouton « Cluster ».

Vous verrez la mise à jour de la barre d’état avec des nombres lors de l’exécution du calcul ; tout d’abord, vous verrez le nombre de calculs envoyés (le deuxième nombre) passer à 100, puis après un bref délai, vous verrez le nombre de résultats reçus (le premier nombre) monter jusqu’à 100.

1539326872659

Ce que vous voyez ici est la messagerie asynchrone que nous avons abordée ci-dessus. Étant donné que la macro HPC_Partition est si rapide, la bibliothèque cliente peut envoyer toutes les 100 requêtes avant la fin de l’un des calculs. Il existe un bref délai : ce délai est le démarrage des nœuds de calcul par Excel et le chargement du classeur. Une fois que chaque nœud de calcul a démarré Excel, le calcul des résultats est assez rapide et le premier nombre atteint jusqu’à 100 rapidement.

Si vous cliquez sur le bouton « Bureau », vous verrez que les nombres se déplacent de manière différente. Sur le bureau, la bibliothèque cliente appelle les mêmes macros, mais elle le fait de façon synchrone (autrement dit, pas de façon asynchrone). Pour exécuter le calcul de bureau, la bibliothèque cliente appellera à son tour chaque macro - d’abord HPC_Partition, puis HPC_Execute, puis HPC_Merge - mais dans ce cas, elle attend que chaque macro se termine avant d’appeler la suivante. C’est pourquoi lorsque vous exécutez sur le bureau, vous verrez les deux numéros se déplacer ensemble.

Partie 2 : Conversion d’un classeur « bureau » à exécuter sur le cluster HPC

Dans la dernière section, nous avons construit un classeur à partir de zéro pour calculer sur un cluster HPC. Dans cette section, nous allons prendre un classeur existant et le modifier pour l’exécuter sur le cluster. Si vous avez suivi la dernière partie, vous devriez avoir une compréhension de ce qui est nécessaire - bien qu’il y ait beaucoup d’étapes individuelles, le travail réel impliqué était très simple. En résumé, nous :

Ajout de deux fichiers macro.
Ajout de deux références au projet VBA.
Apporté quelques modifications aux macros.
Ajout de boutons pour exécuter la feuille de calcul.

La conversion d’un classeur existant correspond à la même quantité de travail. Il n’y a pas beaucoup de nouveau code VBA à ajouter, et la plupart s’il peut réutiliser les mêmes fichiers macro squelette. Pour la plupart, la conversion d’un classeur existant implique le déplacement du code - copie de code à partir de macros existantes dans les macros HPC.

La partie difficile de la conversion d’un classeur existant consiste à déterminer le code à déplacer et l’emplacement où il doit aller. Excel VBA est un environnement de développement complet et il existe de nombreuses façons de créer des applications Excel : différents développeurs peuvent écrire la même application de plusieurs façons différentes.

Dans cette section, nous allons prendre un classeur existant et le convertir pour s’exécuter sur le cluster. Vous devez lire cette section en tant que guide, ou par exemple, puis essayer d’appliquer les concepts à vos propres classeurs. Nous avons un exemple assez simple dans ce cas (bien qu’il soit basé sur un classeur réel utilisé pour résoudre un problème métier réel). Pour n’importe quel classeur, le processus sera le même, mais les détails spécifiques seront différents.

Analyse du classeur

Dans Excel, ouvrez le classeur « ConvertiblePricing.xlsb » à partir du répertoire « Second Workbook ». Vous pouvez recevoir un avertissement sur les macros ; si c’est le cas, cliquez sur « Activer les macros » pour continuer. 1539326930792

Ce classeur calcule les prix des obligations convertibles, en fonction des valeurs de la section « Paramètres du modèle » à gauche. Le tableau de droite est utilisé pour comprendre quel effet les petits changements dans les paramètres -- les changements dans le prix de conversion et dans le taux de coupon -- auront sur le prix final.

Cliquez sur le bouton « Calculer la table » dans la feuille de calcul. Vous verrez le remplissage de la table, lentement, à mesure que chaque prix est calculé. Sur une station de travail classique, le remplissage de la table complète prend entre 1 et 2 minutes.

Pour déterminer ce que fait ce classeur lorsque nous cliquez sur le bouton, nous pouvons parcourir le code VBA.

Pour identifier la macro et voir le code

Cliquez avec le bouton droit sur le bouton « Calculer la table », puis sélectionnez Affecter une macro.
La boîte de dialogue macro indique quelle macro est actuellement utilisée par le bouton. Dans la boîte de dialogue, cliquez sur Modifier pour accéder au code. Vous devez voir le code de la macro « CalculateTable ». Il s’agit du code qui est exécuté lorsque vous cliquez sur le bouton dans la feuille de calcul.

En examinant cette macro, vous pouvez voir quelques sections distinctes. Tout d’abord, il existe certaines déclarations de variables. Ensuite, il y a du code d’initialisation. Enfin, il existe une section qui calcule la table . Nous pouvons identifier l’emplacement où elle effectue une boucle sur les lignes et colonnes de la table et renseigne les valeurs.

Cette macro est assez courte, mais si vous examinez la boucle, vous verrez qu’elle appelle d’autres fonctions - les fonctions « FullDiscountModel » et « BondPlusOptionModel ». Il s’agit des routines de calcul réelles, de la logique métier qui alimente ce classeur.

Dans l’éditeur VBA, vous pouvez accéder à la source de n’importe quelle fonction en cliquant avec le bouton droit sur le nom et en sélectionnant « Définition ». Si vous cliquez avec le bouton droit sur « FullDiscountModel » et sélectionnez « Définition », vous verrez que le calcul réel est plutôt complexe. Mais pour convertir le classeur à exécuter sur le cluster, nous n’avons pas besoin de modifier ou même de comprendre ce calcul. Il nous suffit de nous soucier du code de contrôle, c’est-à-dire de la fonction qui contient la boucle.

Ce classeur est très bien conçu, car la logique métier est contenue dans des fonctions distinctes. Dans d’autres cas, tout ce code peut se trouver dans une seule macro, ce qui rend le classeur plus difficile à comprendre. Mais dans les deux cas, ce que nous allons devoir faire pour convertir ce classeur est de prendre le code de contrôle -- les routines de démarrage et les fonctions de boucle -- et les déplacer vers les macros HPC.

Nous savons également que dans ce classeur, les calculs sont indépendants. Autrement dit, chaque cellule du tableau est calculée sans référence à une autre cellule du tableau. Cela signifie que le classeur est itératif et qu’il prend en charge la parallélisation (comme indiqué dans la section Vue d’ensemble, ci-dessus). Il peut ne pas toujours être évident que les calculs sont indépendants. Une façon de déterminer cela consiste à écrire certaines fonctions de test , par exemple, nous pourrions réécrire la macro « CalculateTable » (la macro appelée lorsque vous appuyez sur le bouton dans la feuille de calcul) pour exécuter un seul calcul ou une seule cellule dans le tableau. De cette façon, nous pourrions déterminer si les résultats étaient cohérents et, le cas échéant, nous pourrions déterminer si les calculs étaient en fait indépendants.

Pour résumer, les fonctionnalités les plus importantes pour tout classeur afin de prendre en charge l’exécution sur un cluster Microsoft HPC sont les suivantes :

Le classeur est itératif : il exécute le même calcul plusieurs fois, avec différents jeux de données d’entrée ; ou il exécute de nombreux calculs individuels, tels que des lignes ou des cellules d’un tableau, un par un.
Les calculs individuels sont indépendants : autrement dit, les résultats d’un seul calcul n’affectent aucun des autres calculs.

Ces deux éléments sont vrais pour ce classeur. Il s’agit donc d’un bon candidat pour l’exécution sur le cluster.

Préparation du classeur

Comme dans le dernier classeur, les premières modifications que nous allons apporter doivent faire avec la configuration de l’environnement VBA. Nous pouvons utiliser des fichiers de macro squelette pour gagner du temps , notamment les macros HPC dont nous aurons besoin pour le calcul.

Dans le dernier classeur, nous avons apporté des modifications aux fichiers macro squelettes pour ajouter des commentaires utilisateur (affichant la progression du calcul dans la barre d’état Excel). Dans ce deuxième classeur, les fichiers macro squelette incluent déjà ce code de barre d’état.

Pour importer les fichiers macro et ajouter des références

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, cliquez avec le bouton droit sur Projet VBA en haut de l’arborescence, puis cliquez sur Importer un fichier.
Dans la boîte de dialogue, recherchez les fichiers projet que vous avez téléchargés. Accédez au répertoire « Second Workbook », sélectionnez le fichier « HPCExcelMacros.bas », puis cliquez sur OK.
Répétez les étapes 1 à 3 pour importer « HPCControlMacros.bas », puis cliquez sur OK. Cela ajoute le deuxième fichier macro à votre projet.
Vérifiez que ces deux fichiers macro apparaissent dans la fenêtre du projet VBA :
Dans la fenêtre de l’éditeur VBA, cliquez sur Outils, puis sur Références pour ouvrir la boîte de dialogue Références de projet.
Dans la liste des références disponibles, faites défiler jusqu’à ce que vous trouviez les assemblys HPC Pack Microsoft (R), puis cochez la case en regard de celle-ci. Lorsque vous avez coché la case, la boîte de dialogue se présente comme suit :
Cliquez sur OK pour fermer la boîte de dialogue références de projet.

Définition des calculs dans l’infrastructure de macros

Une fois l’environnement VBA configuré, nous pouvons passer à l’étape suivante : en modifiant les macros pour exécuter le calcul. Le module HPCExcelMacros inclut les mêmes macros que dans le premier classeur, uniquement cette fois qu’ils incluent déjà les compteurs et le code pour la mise à jour de la barre d’état.

Définition de variables et copie du code d’initialisation à partir de la macro d’origine

Les premières choses dont nous aurons besoin sont des compteurs pour la ligne et la colonne. Dans ce classeur, nous divisons le calcul afin que chaque cellule du tableau soit calculée séparément. La macro d’origine a utilisé des boucles pour s’exécuter dans chaque cellule du tableau, mais dans les fonctions de macro HPC, nous utilisons l’infrastructure asynchrone afin de suivre les numéros de ligne et de colonne à mesure que nous envoyons chaque calcul individuel. Nous allons utiliser des variables de ligne et de colonne dans les macros pour parcourir chaque cellule du tableau ; ils reflètent la ligne et la colonne que nous calculons à chaque étape.

Nous allons revenir à la macro d’origine pour voir ce qu’elle a fait au démarrage, puis la déplacer vers la macro HPC_Initialize .

Pour définir des variables et modifier HPC_Initialize

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, dans l’arborescence du projet, double-cliquez sur le module HPCExcelMacros pour ouvrir le fichier macro.

En haut du fichier, dans « Section 1 : Variables et constantes », ajoutez des variables de ligne et de colonne, comme indiqué ci-dessous :

'==========================================================
'
' 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 Double

Faites défiler jusqu’à la macro HPC_Initialize et initialisez les compteurs de lignes et de colonnes que nous venons de configurer :

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 Function

Dans l’éditeur VBA, double-cliquez sur le module « ScenarioAnalysis » dans la fenêtre du projet VBA. Il s’agissait du fichier contenant le code de macro d’origine. La partie d’initialisation est la première section, qui indique la taille de la table et définit certaines variables (NumRows et 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
    Wend

Copiez le code de la macro d’origine, puis revenez au module HPCExcelMacros (double-cliquez sur HPCExcelMacros dans la fenêtre du projet VBA) et collez-le dans la macro HPC_Initialize .

Le code final dans HPC_Initialize ressemble maintenant à ceci :

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

Modification de la macro HPC_Partition

La macro suivante à modifier est la macro HPC_Partition . N’oubliez pas que cette macro collecte les données nécessaires pour exécuter un calcul unique. Dans ce cas, il s’agit du numéro de ligne et de colonne. Pour ce classeur, nous voulons calculer chaque cellule de tableau individuelle sur le cluster séparément ; et pour ce faire, nous allons utiliser le numéro de ligne et de colonne.

Toutes les macros de l’infrastructure HPC utilisent le type de données Variant pour les entrées et les sorties. Le type Variant peut être n’importe quel type primitif (entier, long, double, chaîne) ou tableau de ces types. Nous devons inclure à la fois la ligne et la colonne, afin de pouvoir utiliser un tableau.

L’autre chose que nous devons faire dans la macro HPC_Partition est de déterminer quand le calcul est terminé. Dans ce cas, le calcul est terminé lorsque nous avons atteint la fin de la table. Nous pouvons le faire en incrémentant les numéros de ligne et de colonne à mesure que nous parcourons la table. Chaque fois que nous atteignons la fin d’une colonne, nous passons à la colonne suivante. Lorsque nous avons passé la dernière colonne, la table est terminée et nous voulons que la fonction retourne Null.

Pour modifier la macro HPC_Partition

Dans le code HPCExcelMacros , faites défiler jusqu’à la section HPC_Partition et ajoutez du code pour déclarer un tableau pour la ligne et la colonne :

Public Function HPC_Partition() As Variant

    Dim data(3) As Variant

    ' update the status bar with the counters

    SentRecords = SentRecords + 1
    UpdateStatus

End Function

Ajoutez du code pour rechercher la fin de la table. Cela met fin au calcul lorsque nous avons terminé la table.

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 Function

Si nous n’avons pas encore terminé la table, la dernière partie de la fonction stocke les valeurs de ligne et de colonne et les utilise comme valeur de retour pour la fonction ; puis passez à la ligne suivante :

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

Ainsi, pour passer en revue, la macro HPC_Partition a deux objectifs : elle collecte les paramètres nécessaires pour un seul calcul (ici, c’est le numéro de ligne et de colonne) ; et lorsque le calcul est terminé, il signale qu’en retournant Null. Dans la fonction que nous avons créée, elle fait cela en parcourant la table, d’abord par ligne, puis par colonne, et quand elle a passé la dernière colonne, elle retourne Null pour indiquer que la table est terminée.

Modification de la macro HPC_Execute

La macro suivante est HPC_Execute. N’oubliez pas que cette macro est conçue pour exécuter le calcul réel ou la logique métier. Les entrées de cette fonction seront toutes les entrées retournées par la macro HPC_Partition à la dernière étape. Étant donné que nous venons d’écrire la macro HPC_Partition , nous savons que les entrées de la macro HPC_Execute seront le numéro de ligne et de colonne de la cellule de tableau que nous voulons calculer.

Le corps de la macro HPC_Execute va être copié à partir de la macro de calcul d’origine. Nous aurons besoin de deux parties de ce code : les déclarations de variables en haut et le code qui exécute la boucle. Nous avons déjà utilisé la section traitant de la taille de la table dans la macro HPC_Initialize . Nous n’avons donc pas besoin de cette nouvelle fois, mais il sera plus facile de copier l’ensemble du bloc de code, puis de supprimer les parties dont nous n’avons pas besoin. Nous allons ensuite apporter quelques modifications pour prendre en charge l’infrastructure asynchrone.

Pour modifier la macro HPC_Execute

Revenez à la macro d’origine en double-cliquant sur le module « ScenarioAnalysis » dans la fenêtre du projet VBA.
Copiez le code à partir de la première ligne :
```
Dim Prem as double
```
Jusqu’à la dernière ligne :
```
Next cols
```
Revenez au module HPCExcelMacros (en double-cliquant dans la fenêtre du projet VBA) et collez le code dans la macro HPC_Execute .
Dans la macro HPC_Execute , supprimez les lignes que nous avons déjà utilisées, en commençant par :
```
' clear values, then figure out the table size
```
Jusqu’à la ligne juste avant :
```
' set up and run through the table
```

Vérifiez que la macro HPC_Execute ressemble à ceci :

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 Function

Remarque : Dans la macro, nous avons maintenant la partie de calcul de la fonction, y compris la boucle qui s’exécute dans chaque cellule du tableau. Pour l’infrastructure asynchrone, nous ne voulons pas utiliser une boucle ici ; nous voulons simplement calculer une seule cellule. N’oubliez pas que la macro HPC_Execute est du code qui s’exécutera sur les nœuds de calcul et que nous lui donnons le numéro de ligne et de colonne que nous voulons calculer.

Supprimez les lignes qui composent la boucle (les lignes en surbrillance ci-dessous) :

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 Function

Remplacement de la boucle par le numéro de ligne et de colonne transmis à la fonction. Le code modifié doit ressembler à ceci :

    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

Au lieu de la boucle, nous utilisons maintenant les valeurs de notre tableau de données , le tableau que nous avons retourné à partir de la macro HPC_Partition , qui contient la ligne et la colonne de la cellule que nous voulons calculer. Ainsi, pour passer en revue cette dernière étape, nous avons supprimé les deux lignes de boucle,

    For cols = 1 To NumCols
        For rws = 1 To NumRows

ainsi que les lignes « Next » à la fin de la boucle,

        Next rws
    Next cols

et ajouté des lignes juste au-dessus de la boucle pour utiliser la variable de tableau de données :

    rws = data(0)
    cols = data(1)

La dernière modification que nous voulons apporter à la fonction HPC_Execute doit être liée au retour des données. N’oubliez pas que les données passent par les macros, chaque macro passant les résultats à la suivante. Le code VBA d’origine de ce classeur a été conçu pour s’exécuter sur le bureau, de sorte que chaque cellule a été calculée le résultat a été collé dans la feuille de calcul. Étant donné que ce classeur va s’exécuter sur le cluster, au lieu de coller les résultats dans la feuille de calcul, nous devons collecter le résultat de calcul et le retourner à partir de la fonction.

Et il y a une autre chose à prendre en compte : lorsque la fonction HPC_Execute s’exécute sur un nœud de calcul, elle calcule le résultat d’une cellule particulière dans le tableau. Ce résultat va ensuite être retourné au bureau et envoyé à la macro HPC_Merge . Mais n’oubliez pas que dans l’infrastructure asynchrone, les résultats peuvent être renvoyés dans n’importe quel ordre , pas nécessairement le même ordre que celui que nous avons envoyé. Nous devons donc indiquer à la macro HPC_Merge quelle cellule du tableau nous avons calculée.

Nous pouvons le faire en incluant le numéro de ligne et de colonne dans les données de résultats. Comme avec la macro HPC_Partition , nous pouvons retourner un tableau à partir de la macro HPC_Excecute. Cela permet à la fonction de retourner non seulement le résultat, mais également la cellule calculée.

En fait, nous pouvons simplement réutiliser le même tableau passé à la fonction pour retourner le résultat, car ce tableau contient déjà le numéro de ligne et de colonne.

Pour stocker le résultat, modifiez le code afin qu’il lise comme suit :

    Select Case Model
    Case 1
        data(2) = FullDiscountModel(360) / Face
    Case Else
        data(2) = BondPlusOptionModel(360) / Face
    End Select
                
    HPC_Execute = data

Nous avons modifié le code qui a inséré des valeurs dans la feuille de calcul pour stocker les valeurs de résultat dans le tableau de données. Et la dernière ligne utilise le tableau de données comme valeur de retour de la fonction, de sorte que les résultats -- et les numéros de ligne et de colonne -- sont envoyés à la macro suivante.

Par conséquent, le code final complet de la macro HPC_Execute doit ressembler à ceci :

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

Modification de la macro HPC_Merge

La dernière macro que nous devons modifier est la macro HPC_Merge . N’oubliez pas que cette macro reçoit un résultat de calcul unique du cluster. Nous voulons l’utiliser pour insérer le résultat dans la table.

L’entrée à HPC_Merge va être ce que nous revenons de HPC_Execute. Étant donné que nous venons d’écrire la macro HPC_Execute , nous savons que la valeur de retour sera un tableau contenant le numéro de ligne et de colonne et le résultat du calcul. Pour mettre à jour la table, nous pouvons utiliser du code à partir de la macro d’origine (il s’agit du code que nous venons de modifier dans la fonction HPC_Execute ).

La ligne de code d’origine, dans le module ScenarioAnalysis, ressemble à ceci :

        Range("cashtable").Cells(rws, cols).Value = FullDiscountModel(360) / Face

Nous allons réécrire cette ligne pour utiliser les valeurs transmises à la macro dans le paramètre de données. La macro HPC_Merge terminée doit ressembler à ceci :

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

Il s’agit de la même ligne de code que celle qui vient d’être supprimée de la macro HPC_Execute . Nous avons remplacé les valeurs de ligne et de colonne (rws et cols dans la ligne d’origine) par la ligne et la colonne du tableau. Nous avons également remplacé l’appel de fonction par le résultat, qui est stocké dans le même tableau.

Il s’agit de toutes les modifications que nous devons apporter pour exécuter ce classeur sur le cluster. Même s’il peut sembler beaucoup d’étapes, en particulier si c’est la première fois que vous avez utilisé HPC Services pour Excel, examinez les macros pour voir le code total qui a été modifié. C’est vraiment pas beaucoup. Pour la plupart, cela implique la copie et le collage de la macro d’origine dans les macros HPC. Pour prendre en charge le calcul asynchrone, nous avons apporté plusieurs modifications au code, mais cela était même relativement simple. Nous n’avons apporté aucune modification à la logique métier réelle dans ce classeur, et vous n’avez même pas besoin de comprendre les fonctions de logique métier pour convertir le classeur. Plus important encore, si les utilisateurs apportent des modifications à la logique métier à l’avenir, il ne nécessite pas de modifier le calcul du cluster.

Exécution du classeur

Pour tester les modifications apportées au code, nous allons d’abord l’exécuter sur le bureau. Comme dans le premier classeur, nous allons ajouter un nouveau bouton à la feuille de calcul et l’utiliser pour exécuter le calcul. Ensuite, nous allons spécifier le nœud principal et le partage de fichiers, ajouter un bouton qui exécute le classeur sur le cluster, puis exécuter le classeur sur le cluster.

Ajout d’un bouton qui exécute le classeur localement

Pour ajouter un bouton qui exécute le classeur localement

(1) Une fois votre classeur Excel ouvert, cliquez sur l’onglet Développeur du ruban.

(2) Sous l’onglet Développeur , cliquez sur Insérer , puis sélectionnez le contrôle bouton : le premier contrôle de la liste. 1539574494629

(3) Une fois que vous avez cliqué sur le bouton, dessinez un rectangle quelque part dans la feuille de calcul pour insérer le bouton à cet emplacement. Une fois que vous avez positionner le bouton, la boîte de dialogue Affecter une macro s’affiche. ! 1539574504903

(4) Dans la boîte de dialogue, sélectionnez la macro CalculateWorkbookOnDesktop dans la liste, puis cliquez sur OK. Veillez à sélectionner la macro de bureau : nous voulons d’abord tester le classeur et trouver des erreurs avant de l’exécuter sur le cluster.

(5) Cliquez avec le bouton droit sur le nouveau bouton, puis sélectionnez Modifier le texte pour modifier l’étiquette.

(6) Nommez l’étiquette « Desktop » ou quelque chose de similaire.

(7) Enregistrez le classeur.

(8) Cliquez sur le bouton pour exécuter le classeur sur le bureau.

S’il existe des erreurs, une boîte de dialogue d’erreur s’affiche et la partie du code VBA avec l’erreur est mise en surbrillance. Vérifiez deux fois le code répertorié ci-dessus pour résoudre les erreurs.

S’il n’y a aucune erreur, la table est renseignée. Les valeurs doivent être identiques lorsque vous avez cliqué sur le bouton d’origine de la feuille de calcul. Là encore, cela s’exécute sur le bureau. Il doit donc s’exécuter sur la même vitesse que le bouton d’origine - quelque part entre 1 et 2 minutes sur la plupart des stations de travail.

Étant donné que nous sommes en cours d’exécution avec le code du framework de macros, vous verrez également la progression du calcul affichée dans la barre d’état Excel. Comme avec le premier classeur, en cours d’exécution sur le bureau, vous verrez les nombres se déplacer ensemble, car sur le bureau, le classeur s’exécute de manière synchrone.

Exécution du classeur sur le cluster

Ensuite, nous allons essayer d’exécuter le classeur sur le cluster. Pour ce faire, nous devons d’abord définir quelques valeurs pour indiquer à Excel comment contacter le cluster. Ces valeurs sont définies dans le module HPCControlMacros **.** En haut de ce fichier, vous devez renseigner deux valeurs : le planificateur de cluster et le répertoire de partage. N’oubliez pas que vous (l’utilisateur de bureau) devez avoir un accès en écriture à ce répertoire de partage ; et les nœuds de calcul du cluster doivent disposer d’un accès en lecture au répertoire. Dans la plupart des cas, vos calculs de cluster s’exécutent sous votre compte d’utilisateur, mais il est possible d’utiliser un autre compte d’utilisateur lorsque vous vous connectez à la session de cluster (plus en un instant).

Pour spécifier le nœud principal et le répertoire de partage

Sous l’onglet Développeur du ruban, cliquez sur Visual Basic pour ouvrir l’éditeur VBA.
Dans l’éditeur VBA, dans l’arborescence du projet, double-cliquez sur le module HPCControlMacros pour ouvrir le fichier macro.
Pour le planificateur de cluster, utilisez le nom de votre nœud principal de cluster. Il s’agit du nom de l’ordinateur que vous utiliseriez sur le réseau. Vous pouvez utiliser un nom complet (par exemple, headnode.mynetwork.com), mais cela n’est pas nécessaire si vous êtes dans le même domaine.
Pour le répertoire de partage, utilisez le chemin complet du répertoire de partage que vous avez créé précédemment (dans la section « Avant de commencer »).

Revenez maintenant à la feuille de calcul Excel. Nous allons ajouter un autre bouton, cette fois pour exécuter le calcul sur le cluster.

Pour ajouter un bouton qui exécute le classeur sur le cluster

Sous l’onglet Développeur , cliquez sur Insérer , puis sélectionnez le contrôle de bouton : le premier contrôle de la liste.
Une fois que vous avez cliqué sur le bouton, dessinez un rectangle quelque part dans la feuille de calcul pour insérer le bouton à cet emplacement. Une fois que vous avez positionner le bouton, la boîte de dialogue Affecter une macro s’affiche.
Dans la boîte de dialogue, sélectionnez la macro CalculateWorkbookOnCluster dans la liste, puis cliquez sur OK.
Cliquez avec le bouton droit sur le nouveau bouton, puis sélectionnez Modifier le texte pour modifier l’étiquette.
Nommez l’étiquette « Cluster » ou quelque chose de similaire.
Enregistrez le classeur.
Cliquez sur le bouton pour exécuter le classeur sur le cluster.
Si c’est la première fois que vous avez exécuté des travaux de cluster, à l’aide d’Excel ou à l’aide d’une autre application, une boîte de dialogue d’authentification utilisateur s’affiche. Tapez votre nom d’utilisateur et votre mot de passe, puis cochez la case pour enregistrer vos informations d’identification. Si vous souhaitez exécuter des calculs sur le cluster en tant qu’utilisateur différent, vous pouvez entrer différents paramètres de compte d’utilisateur.

En cas d’erreur, une boîte de dialogue contextuelle s’affiche. Si le calcul du bureau a fonctionné, les erreurs les plus probables à ce stade devront être liées aux paramètres que vous avez créés pour le nœud principal du cluster et au répertoire de partage. Vérifiez ces paramètres et réessayez.

S’il n’y a pas d’erreur, le début du calcul du cluster s’affiche. Tout d’abord, il y aura une brève pause, car la bibliothèque cliente crée une session HPC pour le calcul. Ensuite, la bibliothèque cliente appelle la macro HPC_Initialize , et vous verrez que la table est effacée. Si vous examinez la barre d’état Excel, vous verrez d’abord que tous les enregistrements sont envoyés au cluster ; le deuxième nombre passe à 105 (il y a 105 cellules dans le tableau). Après cela, vous verrez une autre pause brève avant que les résultats ne soient retournés. Cette pause se produit lorsque chaque nœud de calcul démarre Excel et charge le classeur.

Après cette pause, les résultats commencent à remplir la table et la barre d’état commence à afficher le nombre de résultats retournés. Étant donné qu’il s’agit d’un calcul long, il est très probable que vous verrez les résultats retournés hors ordre ; il y aura des espaces vides dans la table, qui sont ensuite renseignés. Une fois de plus, c’est parce que le calcul est asynchrone, et certains nœuds de calcul calculent plus rapidement que d’autres. Finalement, la table est complète et la barre d’état affiche l’heure de calcul.

Même si vous n’avez que deux nœuds de calcul dans votre cluster HPC, le calcul doit être beaucoup plus rapide que l’exécution sur le bureau. Si vous avez quatre nœuds, huit nœuds ou plus, le calcul doit être extrêmement rapide. Vous pouvez toujours cliquer sur le bouton « Bureau » pour comparer les performances du calcul de bureau au calcul du cluster.

Meilleures pratiques pour Cluster-Enabled classeurs Excel

La remarque suivante décrit quelques considérations importantes à prendre en compte lorsque vous concevez des classeurs Excel à utiliser avec HPC Services pour Excel. Cette remarque s’applique aux classeurs utilisant l’infrastructure de macros HPC/Excel s’exécutant à partir de VBA ou avec la bibliothèque ExcelClient .NET.

Performances des applications de cluster

Lorsque vous concevez une application pour le calcul sur un cluster HPC, vous divisez généralement le travail nécessaire en tâches individuelles et vous envoyez ces tâches au cluster pour le calcul. Les avantages en matière de performances de l’utilisation de HPC proviennent de la parallélisation : de nombreux nœuds de calcul fonctionnent en même temps.

Il incombe au planificateur HPC (nœud principal) de distribuer ces tâches aux nœuds de calcul pour le traitement. Toutefois, pour vous assurer que les nœuds de calcul n’attendent jamais de travail, vous devez essayer de vous assurer que le planificateur HPC dispose toujours d’une liste de tâches à traiter. Si le planificateur doit attendre la tâche de traitement suivante, un ou plusieurs nœuds de calcul ne sont pas inactifs et vous n’obtiendrez pas la meilleure utilisation de votre cluster HPC.

Vous pouvez vous assurer que le planificateur et les nœuds de calcul disposent toujours d’un travail suffisant en envoyant des demandes de calcul aussi rapidement que possible. Dans l’infrastructure de macro HPC/Excel, les requêtes sont envoyées avec la macro HPC_Partition. Par conséquent, il est important de s’assurer que la macro partition est aussi rapide que possible. Si vous pouvez concevoir la macro partition pour envoyer rapidement des tâches, vous vous assurerez que le cluster est entièrement utilisé et que vous obtiendrez les meilleures performances possibles à partir de HPC.

Lorsque des calculs individuels sur les nœuds de calcul du cluster sont terminés, les résultats sont renvoyés à votre application de bureau. Dans l’infrastructure de macro HPC/Excel, les résultats sont traités à l’aide de la macro HPC_Merge. Vous souhaitez également rendre cette macro aussi rapide que possible, pour deux raisons. Tout d’abord, si la macro de fusion est lente pour traiter les résultats, cela peut avoir besoin d’attacher inutilement des ressources de cluster. Deuxièmement, le traitement lent des résultats ralentit votre calcul global , ce qui réduit les avantages de l’utilisation de HPC. Si vous vérifiez que la macro de fusion traite rapidement les résultats, vous libérerez toutes les ressources de cluster pour une autre utilisation, et vous améliorerez l’expérience utilisateur globale.

Amélioration des performances des macros HPC/Excel

Dans cette section, nous allons décrire quelques étapes que vous pouvez effectuer pour vous assurer que vos classeurs Excel compatibles HPC sont aussi efficaces que possible, afin que vous puissiez obtenir les meilleures performances possibles lorsque vous exécutez des calculs sur un cluster HPC.

Cette liste n’est pas complète, mais vous trouverez peut-être des conseils qui s’appliquent à votre classeur. N’oubliez pas qu’il s’agit d’optimisations : la meilleure approche lors de la conception de classeurs Excel compatibles HPC consiste à concevoir le calcul en premier et à le conserver aussi simple que possible ; une fois que vous avez correctement exécuté le classeur sur le cluster, apportez le type de modifications que nous décrivons ici pour améliorer les performances globales.

Éviter d’ouvrir et de fermer des ressources dans les macros partition et fusion

L’ouverture et la fermeture de ressources externes , telles que les fichiers journaux ou les connexions de base de données, peuvent prendre beaucoup de temps et ralentir les macros de partition et de fusion. En outre, vous devez éviter de lire des jeux de données volumineux dans ces macros si possible. Par exemple, vous ne souhaitez pas ouvrir une connexion de base de données, rechercher les enregistrements et rechercher un enregistrement unique pour chaque appel à la macro partition.

Une meilleure approche consiste à ouvrir ces ressources une seule fois, dans la macro Initialize et à effectuer toutes les étapes de traitement initiales. Par exemple, si vous devez charger un jeu de données volumineux à partir d’une base de données, créez la connexion de base de données et effectuez la requête dans la macro Initialize. Ensuite, dans la macro partition, vous pouvez simplement passer à l’enregistrement suivant. Vous pouvez fermer la connexion de base de données dans la macro Finalise.

De même, si vous écrivez dans un fichier journal dans la macro de fusion, envisagez d’ouvrir le fichier dans la macro Initialize. Dans la macro de fusion, vous pouvez écrire des résultats un par un, puis fermer le fichier journal dans la macro Finalise.

Évitez de recalculer la feuille de calcul dans la macro de fusion

Si vous insérez des résultats dans la feuille de calcul dans la macro de fusion, vous pouvez recalculer par inadvertance la feuille de calcul . Si la feuille de calcul est très compliquée, cela peut ralentir le traitement.

Par défaut, Excel recalcule la feuille de calcul chaque fois que vous modifiez la valeur d’une cellule, y compris si vous mettez à jour la cellule à partir d’une macro VBA. Excel recalcule uniquement les parties de la feuille de calcul qui sont affectées par la modification. Par conséquent, si la cellule se trouve elle-même, cela ne sera pas significatif. Toutefois, si la cellule est utilisée dans le cadre d’un calcul plus grand ou en tant que données de graphique, le recalcul peut être lent.

Si vous mettez à jour des cellules de feuille de calcul dans la macro de fusion, envisagez de désactiver le recalcul automatique. Vous pouvez désactiver le recalcul automatique dans la macro Initialize. Ensuite, dans la macro Finalise, vous pouvez recalculer la feuille de calcul entière et réactiver le calcul automatique.

Dans la macro Initialize, vous pouvez désactiver le calcul automatique avec

Application.Calculation = xlCalculationManual

Vous pouvez ensuite recalculer la feuille de calcul et réactiver le calcul automatique dans la macro Finalise avec

Application.Calculate
Application.Calculation = xlCalculationAutomatic

Insérer des blocs de données au lieu de valeurs individuelles

Lorsque vous mettez à jour des cellules de feuille de calcul à partir de VBA, cela implique un certain nombre d’étapes internes, et cela peut être plus lent que prévu. Il est presque toujours préférable de modifier plusieurs cellules en tant que bloc unique, au lieu d’un à la fois.

Si la macro Execute retourne un grand nombre de valeurs (un tableau de 100 nombres, par exemple), il existe deux façons d’insérer ces données dans la feuille de calcul. Vous pouvez les insérer un par un, dans une boucle :

For i = 1 To 100 Step 1
   Cells(1, i).Value2 = v(i)
Next i

Vous pouvez également insérer la plage complète sous forme de tableau :

Range(Cells(2, 1), Cells(2, 100)).Value2 = v

L’insertion d’une cellule prend environ le même temps que l’insertion d’un bloc de cellules. Par conséquent, si vous avez un tableau de 100 valeurs, la première façon de procéder , l’insertion de cellules une à la fois dans une boucle - peut prendre jusqu’à 100 fois plus longtemps que la deuxième approche, en insérant le bloc de cellules en tant que tableau.

Désactiver les mises à jour de l’écran

Si vous apportez des modifications à la feuille de calcul dans la macro de fusion , si vous mettez à jour des cellules ou si vous modifiez des données de graphique, la désactivation des mises à jour de l’écran peut réduire le temps de traitement. Cela fonctionne, car Excel consomme un certain temps pour mettre à jour l’écran et l’interface utilisateur.

Vous pouvez désactiver les mises à jour d’écran dans la macro Initialiser et réactiver les mises à jour de l’écran dans la macro Finalise. Dans la macro Initialize, utilisez

Application.ScreenUpdating = False

Dans la macro Finalise, utilisez

Application.ScreenUpdating = True

Cela désactive les mises à jour de l’écran pendant le calcul et réactive les mises à jour une fois le calcul terminé. Lorsque vous réactivez les mises à jour de l’écran dans la macro Finalise, Excel actualise automatiquement l’écran.

Utiliser des structures de données pour stocker temporairement des informations en mémoire

Si vous collectez des informations pour le traitement -- ce que vous faites dans la macro de partition -- est très long ou si vous devez effectuer un post-traitement très complexe des résultats -- dans la macro de fusion -- envisagez d’utiliser des structures de données pour stocker des informations en mémoire pendant le calcul.

Par exemple, si chacune de vos demandes de calcul dans la macro de partition nécessite une requête de base de données très complexe, cela peut ralentir le traitement et entraîner des performances médiocres. Dans ce cas, il peut être judicieux d’effectuer ce traitement complexe dans la macro Initialize avant le démarrage du calcul.

Si vous effectuez ce traitement complexe dans la macro Initialize, vous pouvez stocker chacune des demandes de calcul dans une structure de données dans VBA, telle qu’un tableau de variantes. Ensuite, dans la macro partition, vous pouvez simplement retourner l’entrée suivante dans le tableau. Cela permet de s’assurer que la macro partition est aussi rapide que possible.

De même, si vous devez effectuer un post-traitement très complexe sur les résultats à mesure qu’ils arrivent, il peut être conseillé de stocker les résultats dans une structure de données dans la macro de fusion, puis de traiter les résultats de la macro Finalise une fois le calcul terminé.

Par exemple, si vous stockez des résultats dans une base de données, mais que chaque écriture de base de données nécessite une instruction d’insertion complexe, il peut être préférable de déplacer ce traitement vers la macro Finalise. Vous pouvez créer une structure de données, telle qu’un tableau de variantes, et dans la macro de fusion, insérez simplement chaque résultat dans le tableau. Ensuite, dans la macro Finalise, vous pouvez parcourir le tableau et effectuer les opérations d’écriture de base de données nécessaires en même temps.

Notes finales

La conversion d’un classeur existant pour utiliser HPC Services pour Excel est plus d’un art qu’une science. Les détails spécifiques - quel code déplacer et où le déplacer - dépendent toujours du classeur particulier.

Toutefois, vous devez maintenant comprendre les concepts impliqués et comprendre pourquoi nous utilisons l’infrastructure de macros asynchrones. Pour convertir un classeur à utiliser HPC Services pour Excel, vous devez créer un calcul parallèle de la même façon : ajoutez les fonctions de l’infrastructure de macros à votre classeur et renseignez le code approprié.

Vous pouvez utiliser les fichiers macros « squelette » inclus dans cet article dans vos propres classeurs. Suivez les étapes que vous avez utilisées dans les exemples ci-dessus pour identifier le code itératif de votre classeur et le déplacer vers les macros appropriées. N’oubliez pas de tester le calcul sur votre bureau pour identifier les erreurs avant d’exécuter des calculs sur le cluster.

Vous devez également avoir une idée des avantages en matière de performances que vous pouvez obtenir de l’exécution de classeurs Excel sur un cluster HPC avec HPC Services pour Excel. Dans cet article, nous avons commencé avec un classeur qui était déjà assez rapide : pour calculer l’intégralité du classeur, seulement 1 à 2 minutes sur le bureau. Mais même ce classeur peut s’exécuter deux fois plus rapidement, quatre fois plus rapidement, ou plus rapidement, sur un cluster HPC. Les performances réelles dépendent du nombre de nœuds de calcul disponibles dans votre cluster, et vous pouvez toujours améliorer les performances en ajoutant davantage de nœuds de calcul au cluster.

Avec une quantité relativement faible de travail, il est possible de convertir de nombreux classeurs Excel longs à exécuter sur un cluster Microsoft HPC avec HPC Services pour Excel. Et pour les classeurs très longs ,- les classeurs qui prennent des heures ou même des jours pour calculer -- l’utilisation de HPC Services pour Excel peut entraîner une amélioration des performances vraiment spectaculaire.

Last updated on 2025-06-05

Accélération d’Excel avec Microsoft HPC Pack : création d’applications et de classeurs VBA pour un microsoft HPC Pack

Résumé

Présentation

Public prévu

Télécharger des fichiers

Structure et mise en forme

Aperçu

Calcul asynchrone

Calcul itératif et calcul parallèle

Infrastructure de macros

Création de classeurs Cluster-Enabled avec Excel et HPC Services pour Excel

Avant de commencer : Conditions préalables et conditions requises

Sur le cluster

Sur le bureau

Résumé

Partie I : Création d’un classeur à partir de zéro

Démarrage d’un nouveau classeur

Préparation du classeur

Définition des calculs dans l’infrastructure de macros

Exécution du classeur localement et exploration des macros

Ajout d’un bouton qui exécute le classeur localement

Modification des HPC_Excecute et des macros HPC_Merge

Modification de la macro HPC_Initialize

Exécution du classeur sur le cluster

Que se passe-t-il lorsqu’un classeur s’exécute sur le cluster

Communication de la progression du calcul

Partie 2 : Conversion d’un classeur « bureau » à exécuter sur le cluster HPC

Analyse du classeur

Préparation du classeur

Définition des calculs dans l’infrastructure de macros

Définition de variables et copie du code d’initialisation à partir de la macro d’origine

Modification de la macro HPC_Partition

Modification de la macro HPC_Execute

Modification de la macro HPC_Merge

Exécution du classeur

Ajout d’un bouton qui exécute le classeur localement

Exécution du classeur sur le cluster

Meilleures pratiques pour Cluster-Enabled classeurs Excel

Performances des applications de cluster

Amélioration des performances des macros HPC/Excel

Notes finales

Ressources supplémentaires