Accelerazione di Excel con Microsoft HPC Pack: compilazione di applicazioni e cartelle di lavoro VBA per microsoft HPC Pack

Riassunto

HPC Services per Excel supporta un'ampia gamma di nuovi modelli di programmazione che consentono di eseguire calcoli di Excel in un cluster HPC. In questo articolo verrà illustrato come usare le macro VBA di Excel per compilare cartelle di lavoro che usano un cluster HPC per eseguire calcoli in parallelo. Per supportare HPC Services per Excel, la cartella di lavoro deve includere un set di macro che implementano le funzioni asincrone. Questo articolo descrive il framework macro e come definire i calcoli all'interno del framework. Questo articolo include un esempio di come compilare una cartella di lavoro da zero e un esempio di conversione di una cartella di lavoro esistente da eseguire in un cluster.

Introduzione

Impiegare un'ora per velocizzare l'esecuzione della cartella di lavoro di Excel quattro volte? Che ne dici di otto volte più veloce, o ancora di più? Se sono presenti cartelle di lavoro di Excel a esecuzione prolungata o lente, è possibile usare HPC Services per Excel con un cluster Microsoft HPC per migliorare notevolmente le prestazioni di calcolo.

HPC Services per Excel supporta un'ampia gamma di nuovi modelli di programmazione che consentono di eseguire calcoli di Excel in un cluster HPC. Tuttavia, non è necessario comprendere lo sviluppo di codice o conoscere C#, per usare HPC Services per Excel. In questo articolo verrà illustrato come creare cartelle di lavoro che utilizzano un cluster HPC per il calcolo, usando solo Excel VBA.

In realtà, la conversione di una delle cartelle di lavoro nel cluster richiederà probabilmente più di un'ora, a seconda della complessità della cartella di lavoro. Tuttavia, se si passa un'ora all'uso degli esempi in questo articolo, si comprenderanno i concetti coinvolti e i requisiti per la conversione di qualsiasi cartella di lavoro da eseguire in un cluster HPC. Si noteranno anche i vantaggi delle prestazioni che è possibile ottenere con alcune semplici modifiche al codice VBA.

Destinatari

Questo articolo è destinato agli sviluppatori di Excel che hanno familiarità con la scrittura di macro VBA. La familiarità con Microsoft HPC Pack è utile, ma non è necessaria.

Se si è interessati alle possibilità di prestazioni di HPC Services per Excel, ma non si vuole completare il processo di sviluppo completo, i file di download includono versioni completate delle due cartelle di lavoro descritte in questo articolo. Per provare a eseguire queste cartelle di lavoro in un cluster Microsoft HPC, leggere la sezione "Prima di iniziare" per assicurarsi di disporre di tutti i requisiti prima di iniziare. Per altri esempi e documentazione, passare a https://github.com/Azure-Samples/hpcpack-samples.

Scaricare i file

È possibile trovare alcuni file di esempio usati nelle sezioni seguenti dal repository Github di esempio hpC Pack. I file di esempio includono gli scheletri di file macro che è possibile importare nelle cartelle di lavoro per semplificare il processo di sviluppo. È disponibile anche una cartella di lavoro di base che verrà usata come punto di partenza per sviluppare una cartella di lavoro per HPC Services per Excel.

Struttura e formattazione

Gli screenshot in questo articolo provengono tutti da Excel e da HPC Cluster Manager. Negli esempi pratici inclusi in questo articolo, gli esempi di codice sono la formattazione usando uno stile di codice che rappresenta l'editor VBA:

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

Dim SentRecords As Integer
Dim RcvRecords As Integer

Quando vengono aggiunte o modificate righe di codice, verranno evidenziate in verde. Gran parte del codice incluso qui viene importato da file esistenti o copiato tra file VBA diversi. In tal caso, alcune lunghe righe di codice potrebbero essere troncate per rientrare entro i margini di questo documento. Provare a copiare e incollare da documenti esistenti anziché da questo articolo, per evitare di includere accidentalmente gli esempi di codice troncati.

Informazioni generali

HPC Services per Excel supporta diversi modelli di programmazione per lo sviluppo e l'esecuzione di calcoli di Excel in un cluster Microsoft HPC. La soluzione selezionata deve dipendere dalle specifiche esigenze e dalle competenze di sviluppo.

Uso previsto	Competenze necessarie	Soluzione
Calcolare le cartelle di lavoro in parallelo, per ottenere prestazioni migliori (tempi di calcolo più rapidi) o la possibilità di elaborare più dati nella stessa quantità di tempo	Sviluppo vba (macro) di Excel	Esecuzione di cartelle di lavoro in un cluster HPC con VBA di Excel
Creare applicazioni e servizi personalizzati che eseguono cartelle di lavoro di Excel in un cluster HPC e si integrano con applicazioni autonome o script batch	Programmazione .NET con C#, VBA.NET o qualsiasi linguaggio supportato da CLR .NET	Sviluppo di servizi HPC personalizzati e applicazioni client per Excel
Velocizzare il calcolo delle funzioni di Excel User-Defined (UDF) contenute nelle librerie di estensioni di Excel (XLLs)	Programmazione C o C++, sviluppo della libreria di estensioni di Excel (XLL)	Funzioni User-Defined di Excel Cluster-Enabled

Ognuno di questi modelli di programmazione verrà affrontato negli articoli futuri. Oggi si affronterà il primo modello: calcolo delle cartelle di lavoro di Excel in parallelo usando solo Excel VBA. Anche se si vuole passare a uno sviluppo più complesso con Excel e Microsoft HPC Pack, questo può essere un ottimo punto di partenza: è il modo più semplice e rapido per ottenere le applicazioni Excel in esecuzione in un cluster HPC e consente di comprendere i requisiti per e i vantaggi dell'uso di HPC Services per Excel.

Per supportare gli sviluppatori di Excel, HPC Services per Excel include un set di librerie che è possibile usare direttamente da Excel, sul desktop, per compilare ed eseguire cartelle di lavoro di Excel in un cluster Microsoft HPC. Con queste librerie non è necessario conoscere la programmazione .NET o C#. Tutte le operazioni possono essere eseguite da Excel scrivendo macro VBA. Con questo framework, è possibile velocizzare notevolmente il calcolo delle cartelle di lavoro di Excel semplicemente scrivendo codice VBA ed eseguendo le cartelle di lavoro nel cluster.

HPC Services per Excel include un framework client/servizio appositamente progettato per essere usato da Excel sul desktop. Esistono due parti importanti per questo framework: una libreria client, installata sul desktop; e una libreria di servizi, installata nei nodi di calcolo del cluster. Queste librerie vengono installate per impostazione predefinita quando si installa Microsoft HPC Pack, quindi non è necessario eseguire alcuna configurazione personalizzata per usarle.

Dopo aver installato il client e la libreria di servizi, è possibile compilare ed eseguire cartelle di lavoro di Excel per il cluster semplicemente aggiungendo alcune macro VBA alla cartella di lavoro. Queste nuove macro VBA verranno descritte come framework macro. Quando si fa riferimento al framework di macro, vengono descritti in modo specifico le nuove macro aggiunte alle cartelle di lavoro per supportare il calcolo in un cluster HPC.

Prima di illustrare le macro specifiche, è opportuno evidenziare alcuni concetti chiave che influiscono sul modo in cui le macro vengono costruite e su come funzionano.

Calcolo asincrono

Il concetto più importante da comprendere nello sviluppo di cartelle di lavoro per HPC Services per Excel e nell'uso del framework macro è il calcolo asincrono.

Un'applicazione excel tipica viene eseguita in modo sincrono. Vale a dire, si preme un pulsante per eseguire una macro e la macro esegue un codice VBA. All'interno di questo codice è possibile apportare modifiche al foglio di calcolo, chiamare altre funzioni VBA, accedere ai database o qualsiasi altro elemento. Tuttavia, si prevede che le macro vengano eseguite dall'inizio alla fine e quindi completate.

Il modello asincrono è leggermente diverso. In questo modello si scrivono funzioni VBA, ma non vengono chiamate direttamente. Al contrario, una libreria client, ovvero il codice installato con HPC Services per Excel, chiamerà le funzioni VBA.

Se si ha familiarità con gli eventi di Excel in VBA, si conosce già questo modello. Ad esempio, se si scrive una funzione VBA eseguita nell'evento Workbook.Open, si sa che il codice verrà eseguito ogni volta che viene aperta la cartella di lavoro. Ma non chiami direttamente il codice; Invece, Excel chiama la funzione scritta automaticamente all'apertura della cartella di lavoro.

Il modello di programmazione asincrona funziona allo stesso modo. Si scrivono funzioni che verranno chiamate durante un calcolo, ma invece di chiamarle manualmente, si attende Excel - o in questo caso, la libreria HPC Services per Excel - per chiamare le funzioni.

Calcolo iterativo e calcolo parallelo

Un altro concetto importante è il calcolo iterativo. Il calcolo iterativo fa riferimento a un tipo di calcolo che esegue gli stessi passaggi di calcolo di base su set di dati diversi.

L'esempio più comune di calcolo iterativo è la simulazione Monte Carlo. In una simulazione Monte Carlo si ha in genere un calcolo complesso , come la generazione di prezzi dei titoli - in base ad alcuni valori di input casuali, come il rendimento previsto in diversi anni. Una simulazione Monte Carlo esegue lo stesso calcolo migliaia di volte, ogni volta con un valore di input casuale diverso.

Si tratta di un calcolo iterativo perché ogni volta che viene calcolato il prezzo, con un valore di input casuale diverso, l'intero calcolo viene eseguito di nuovo. Questi calcoli sono indipendenti; ovvero, in ogni singolo calcolo non esiste alcun riferimento a alcun calcolo precedente o successivo.

Un altro esempio comune prevede l'esecuzione di un calcolo su un set di record da un database. In questo caso, si potrebbe avere un calcolo complesso, ad esempio un modello assicurativo o attuariale, basato su alcuni parametri, ad esempio l'età e il sesso di un titolare di un'assicurazione. Il calcolo iterativo eseguirà lo stesso modello per migliaia di singoli titolari di criteri. Ogni calcolo è indipendente da tutti gli altri calcoli.

Il framework macro di cui stiamo parlando è progettato per lavorare con questi tipi di calcoli iterativi. Questo è importante perché quando si esegue un calcolo in un cluster HPC, si eseguirà il calcolo in parallelo . Si eseguirà lo stesso calcolo più volte, ma verranno eseguite più istanze del calcolo contemporaneamente nei nodi di calcolo del cluster.

Se il calcolo non fosse indipendente, se i risultati di un singolo calcolo dipendevano dai calcoli precedenti eseguiti, non funzionerebbe. Di conseguenza, il framework che stiamo parlando qui è applicabile solo per calcoli iterativi e indipendenti, ovvero calcoli che possono essere parallelizzati.

The Macro Framework

Per supportare HPC Services per Excel, la cartella di lavoro deve includere un set di macro che implementano le funzioni asincrone. Si tratta del framework macro. Nel framework sono disponibili sei macro, che è possibile aggiungere a qualsiasi cartella di lavoro di Excel. Le sei macro, con una breve descrizione di ciò che fanno, sono

Nome della macro	Azione
HPC_Initialize	Eseguire qualsiasi procedura di pre-calcolo o inizializzazione
HPC_Partition	Raccogliere i parametri obbligatori per un singolo passaggio di calcolo
HPC_Execute	Eseguire un passaggio di calcolo, come parte di un calcolo complessivo più ampio
HPC_Merge	Elaborare i risultati di un singolo passaggio di calcolo
HPC_Finalize	Eseguire qualsiasi elaborazione post-calcolo
HPC_ExecutionError	Gestire gli errori derivanti dal calcolo

(Non preoccuparti se queste descrizioni non sono immediatamente chiare: ognuna di queste funzioni verrà descritta in modo più dettagliato di seguito).

Le stesse macro devono essere aggiunte a qualsiasi foglio di calcolo per supportare il calcolo nel cluster, ma le macro, ovvero le funzioni di calcolo specifiche, possono essere diverse. Per semplificare il processo, i file di download inclusi in questo articolo includono un file macro "skeleton" che è possibile importare nella cartella di lavoro. Dopo aver impostato le macro di base, è possibile compilarle in base alle esigenze per supportare il calcolo.

Ogni macro ha uno scopo specifico nel framework macro e ognuna verrà chiamata dalla libreria client HPC Services per Excel durante un calcolo del cluster. Quando viene eseguito un calcolo, ogni macro verrà chiamata in un punto specifico. Un calcolo tipico viene eseguito come segue:

Quando viene eseguito un calcolo del cluster, prima la libreria client chiamerà la macro HPC_Initialize . Viene usato per gestire qualsiasi inizializzazione necessaria; Ad esempio, è possibile cancellare i vecchi risultati dal foglio di calcolo.

Il calcolo esegue quindi tre macro: HPC_Partition, HPC_Execute e HPC_Merge. Nel diagramma precedente, questi vengono visualizzati come ciclo. Non è proprio quello che accade durante un calcolo, ma logicamente si può pensare a questo come un ciclo. Prima di tutto, la libreria client chiama HPC_Partition. HPC_Partition è progettato per raccogliere tutti i dati necessari per un singolo passaggio di calcolo. Ad esempio, se si desidera calcolare un set di righe uno alla volta, HPC_Partition potrebbe restituire il numero di riga per un singolo passaggio: prima riga 1, quindi riga 2 e così via.

Viene quindi chiamata la macro HPC_Execute . Questa macro esegue il calcolo effettivo. Se si calcola una riga per riga, verrà calcolata una singola riga. HPC_Execute restituirà il risultato del calcolo: ad esempio, potrebbe restituire l'ultima cella della riga che rappresenta il risultato finale di un calcolo più lungo.

Dopo HPC_Execute, la libreria client chiamerà HPC_Merge. Qualsiasi HPC_Execute calcolato verrà inviato a HPC_Merge. La macro HPC_Merge è progettata per portare i risultati e restituirli al foglio di calcolo in esecuzione sul desktop. Nella macro HPC_Merge è possibile inserire nuovamente i risultati di calcolo nel foglio di calcolo oppure scriverli in un file di log.

Queste tre macro, HPC_Partition, HPC_Execute e HPC_Merge , verranno chiamate più volte, una volta per ogni passaggio del calcolo, fino al completamento dell'intero calcolo. Queste macro implementano il modello di calcolo iterativo descritto in precedenza. Le macro possono essere chiamate molte volte durante un singolo calcolo della cartella di lavoro, ma ogni volta che vengono chiamate rappresenta un singolo passaggio di calcolo o iterazione.

Al termine dell'ultimo passaggio di calcolo, la libreria client chiamerà HPC_Finalize. È possibile utilizzare questa macro per eseguire qualsiasi elaborazione post-calcolo: ad esempio, è possibile trovare la media di tutti i passaggi di calcolo precedenti utilizzando un'altra macro VBA.

La sesta e ultima macro, HPC_ExecutionError, viene utilizzata solo quando il calcolo rileva un errore. In tal caso, questa macro viene chiamata ed è possibile aggiungere codice di gestione degli errori, ad esempio una finestra di dialogo popup all'utente che li avvisa dell'errore.

Nel diagramma precedente la macro HPC_Execute è evidenziata in arancione. Ciò significa che questa macro è un po' insolita. Tutte le altre macro vengono eseguite sul desktop, in Excel nella workstation. Quando si esegue un calcolo in un cluster HPC, tuttavia, la macro HPC_Execute viene effettivamente eseguita nei nodi di calcolo del cluster.

Ecco come HPC Services per Excel e il framework macro supportano il calcolo del cluster. Mentre si scrivono tutte le macro nella stessa cartella di lavoro, ovvero la cartella di lavoro sul desktop, quando viene eseguito il calcolo, la cartella di lavoro verrà copiata nei nodi di calcolo del cluster e la macro HPC_Execute verrà eseguita in uno dei nodi di calcolo.

È importante comprendere questo aspetto, perché ha alcune implicazioni per il modo in cui le cartelle di lavoro usano e gestiscono i dati durante il calcolo. Le tre macro di calcolo principali, HPC_Partition, HPC_Execute e HPC_Merge , passano i dati avanti e indietro durante il processo di calcolo. In un'applicazione VBA tipica esistono molti modi per condividere i dati tra macro diverse. Ad esempio, è possibile usare variabili globali nel codice VBA o scrivere valori nelle celle del foglio di calcolo. Tuttavia, quando si esegue il calcolo in un cluster HPC, è necessario inviare dati tra le macro in esecuzione sul desktop e la macro HPC_Execute in esecuzione nei nodi di calcolo.

Per questo motivo, tutti i dati necessari per eseguire il calcolo devono essere inviati direttamente dalla macro HPC_Partition alla macro HPC_Execute . A tale scopo, usare il valore restituito dalla macro HPC_Partition . Tale valore restituito diventa l'argomento (o il parametro) alla funzione HPC_Execute . Pertanto, i dati passeranno direttamente tra queste due macro ed è possibile passare qualsiasi valore o set di valori (come matrice) tra queste macro. Anche in questo caso, non è possibile usare variabili globali o celle del foglio di calcolo per passare informazioni tra le due macro perché quando viene eseguita nel cluster, sono effettivamente presenti più copie della cartella di lavoro in esecuzione contemporaneamente, una sul desktop e una (o più) nei nodi di calcolo del cluster.

Allo stesso modo, quando il calcolo in HPC_Execute è completo, restituirà un risultato come valore restituito della funzione macro. Questo risultato diventa l'argomento (o il parametro) alla macro successiva , HPC_Merge. Anche in questo caso, tutti i risultati da restituire, ovvero i risultati del calcolo, devono essere inviati in questo modo, come valore restituito della funzione.

Compilazione di cartelle di lavoro Cluster-Enabled con Excel e HPC Services per Excel

Nelle sezioni seguenti verrà illustrata la compilazione di due cartelle di lavoro che supportano il calcolo in un cluster HPC. Nella prima sezione verrà compilata una cartella di lavoro da zero. Questo dovrebbe aiutare a comprendere i concetti coinvolti e i requisiti per l'uso di HPC Services per Excel. Nella seconda sezione si userà una cartella di lavoro esistente, una progettata per l'esecuzione sul desktop, e la si convertirà in modo che possa essere eseguita nel cluster.

Prima di iniziare: Prerequisiti e requisiti

HPC Services per Excel è un set di strumenti incluso in Microsoft HPC Pack 2008 R2 Beta 2 e versioni successive. È necessario un cluster Microsoft HPC Pack installato e configurato. L'installazione di un cluster HPC non rientra nell'ambito di questo articolo; verrà affrontata solo la configurazione specifica necessaria per HPC Services per Excel. Per altre informazioni sull'installazione e la configurazione del cluster, vedere la documentazione inclusa in Microsoft HPC Pack. Sul desktop sono necessarie le utilità client HPC Pack.

Nel cluster

Dopo aver installato un cluster HPC in esecuzione, sarà necessario installare Excel nei nodi di calcolo del cluster. È possibile usare il kit di installazione standard di Office per installare Excel oppure vedere la documentazione di HPC Pack per altre informazioni su come automatizzare l'installazione di Excel.

Dopo l'installazione di Excel nei nodi di calcolo del cluster, è possibile eseguire il test di diagnostica HPC per assicurarsi che tutto sia configurato correttamente. Per eseguire il test di diagnostica, usare Gestione cluster HPC (nel nodo head del cluster, in cui è installato per impostazione predefinita o sul desktop se sono state installate le utilità client).

Per verificare che il servizio HPC per Excel sia configurato correttamente

1. In Gestione cluster HPC fare clic su Diagnostica.

2. In Test espandere Microsoft e quindi selezionare Excel.

3. Nel riquadro della visualizzazione fare doppio clic su Test di configurazione di Excel Runner.

4. Nella finestra di dialogo di configurazione selezionare Tutti i nodi e quindi fare clic su Esegui.

5. Nel riquadro di spostamento fare clic su Risultati test per visualizzare lo stato di avanzamento del test. Il test in esecuzione viene visualizzato nel riquadro di visualizzazione.

6. Al termine del test, è possibile fare clic sul test nella finestra principale per visualizzare i risultati.

Se il test mostra Errore, fare doppio clic sul test e provare a correggere eventuali errori nella finestra popup. Gli errori comuni che potrebbero verificarsi sono che Excel non è installato in un nodo di calcolo o che Excel non è stato attivato. Apportare le modifiche necessarie ed eseguire di nuovo il test di diagnostica seguendo le istruzioni riportate sopra.

Quando il test mostra Esito positivo, si è pronti per continuare.

L'ultima cosa necessaria è una directory di condivisione. Quando si calcola una cartella di lavoro in un cluster HPC, ognuno dei nodi di calcolo del cluster carica effettivamente ed esegue una copia della cartella di lavoro. A tale scopo, è necessario creare una directory di condivisione visibile sia ai nodi di calcolo del cluster che al desktop.

Se si ha accesso al nodo head del cluster, creare una directory di condivisione nel nodo head. Ciò è utile perché si sa che i nodi di calcolo del cluster possono accedere al nodo head. Se non è possibile creare una directory di condivisione nel nodo head, creare la directory di condivisione in qualsiasi punto del dominio accessibile sia al desktop che ai nodi di calcolo del cluster.

Sul desktop

Sul desktop sarà necessario installare Excel e le utilità client di Microsoft HPC Pack (l'installazione delle utilità client richiederà autorizzazioni di amministratore). Per installare le utilità client, eseguire il programma di installazione di HPC Pack sul desktop. Offre un'opzione per l'installazione solo delle utilità client.

Riassunto

A questo momento dovrebbe essere disponibile:

1. Un cluster Microsoft HPC installato e configurato.

2. Excel 2016 (o versione successiva) installato nei nodi di calcolo del cluster.

3. Directory di condivisione di rete.

4. Excel 2016 (o versione successiva) e le utilità client di Windows HPC Pack installate sul desktop.

Quando tutto ciò è pronto, è possibile iniziare a compilare cartelle di lavoro eseguite nel cluster con HPC Services per Excel.

Parte I: Creazione di una cartella di lavoro da zero

Questa parte include le sezioni seguenti:

1. Avvio di una nuova cartella di lavoro

2. Preparazione della cartella di lavoro

3. Progettazione del calcolo del cluster

4. Esecuzione della cartella di lavoro nel cluster

5. Ultimi passaggi: Interfaccia utente

Avvio di una nuova cartella di lavoro

Avviare Excel con una nuova cartella di lavoro. Si userà VBA, quindi assicurarsi di disporre della scheda Sviluppo disponibile sulla barra multifunzione di Excel.

Per attivare la scheda Sviluppatore

1. Fare clic sulla scheda File sulla barra multifunzione di Excel.

2. Fare clic su Opzioni.

3. Nella finestra di dialogo Opzioni di Excel selezionare Personalizza barra multifunzione a sinistra.

4. Selezionare la casella accanto a Sviluppatore e fare clic su OK per chiudere la finestra di dialogo.

Preparazione della cartella di lavoro

Per preparare la cartella di lavoro, è necessario importare i file di macro e aggiungere i riferimenti HPC.

Per compilare la cartella di lavoro di base, sono necessari due set di macro. Il primo set di macro implementa le funzioni del framework (le funzioni descritte nella sezione Panoramica precedente). Queste macro vengono utilizzate dalla libreria client HPC Services per Excel durante il calcolo. Il secondo set di macro contiene le funzioni di "controllo", ovvero queste macro eseguono il calcolo effettivo.

I file di esempio includono file di macro "scheletro" di base per ognuno di questi che è possibile usare per iniziare. Non è necessario usare questi file - è anche possibile scrivere il proprio, se si preferisce - ma le macro stesse sono generiche e si potrebbe scoprire che l'uso di questi file è tutto ciò di cui hai bisogno. È anche possibile modificare questi file per apportare eventuali modifiche necessarie per la cartella di lavoro specifica.

È necessario aggiungere due riferimenti a questo progetto per usare i servizi HPC: Microsoft_Hpc_Excel e Microsoft_Hpc_Scheduler_Properties. Microsoft_Hpc_Excel è la libreria client, che fornisce un oggetto che è possibile usare per controllare un calcolo del cluster. Microsoft_Hpc_Scheduler_Properties include definizioni per alcuni campi e tipi specifici del cluster necessari.

Nota: nella sezione Panoramica precedente sono stati descritti gli strumenti come framework client/server; La libreria client è stata installata quando è stato installato HPC Pack SDK e sarà ora disponibile in VBA.

Per importare i file di macro e aggiungere riferimenti

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA fare clic con il pulsante destro del mouse su Progetto VBA nella parte superiore della visualizzazione albero e quindi scegliere Importa file.

3. Nella finestra di dialogo individuare i file di progetto scaricati. Passare alla directory "First Workbook", selezionare il file "HPC Excel Macros.bas" e fare clic su OK. Che aggiunge il primo file di macro al progetto e sarà disponibile nella cartella Moduli della finestra del progetto VBA.

4. Ripetere i passaggi da 1 a 3 per importare "HPC Control Macros.bas" e quindi fare clic su OK. Che aggiunge il secondo file di macro al progetto.

5. Verificare che questi due file di macro siano visualizzati nella finestra del progetto VBA:

6. Nella finestra dell'editor VBA fare clic su Strumenti e quindi su Riferimenti per aprire la finestra di dialogo riferimenti al progetto.

7. Nell'elenco dei riferimenti disponibili scorrere verso il basso fino a trovare assembly HPC Pack di Microsoft (R) e selezionare la casella di controllo accanto a ognuna di esse. Dopo aver selezionato le caselle, la finestra di dialogo sarà simile alla seguente:

8. Fare clic su OK per chiudere la finestra di dialogo riferimenti al progetto.

Se questa voce non viene trovata nell'elenco, fare clic su Sfoglia. Trovare il file %CCP_HOME%\Bin\Microsoft.Hpc.Excel.tlb. Se non è ancora possibile trovarlo, verificare di aver installato i componenti client HPC Pack. Se i file sono installati, nel pannello di controllo Installazione applicazioni viene visualizzata una voce per "Componenti client microsoft HPC Pack". Se questa voce non viene visualizzata, provare a reinstallare i componenti client come descritto nella sezione precedente "Prima di iniziare".

Definizione dei calcoli nel framework macro

L'obiettivo di creare questa cartella di lavoro è illustrare il funzionamento di un calcolo del cluster, quindi non è necessario creare un foglio di calcolo molto complicato. Verrà creato un calcolo che esegue 100 singoli passaggi. A tale scopo, si aggiungerà un contatore al file di macro di Excel HPC e si userà tale contatore nelle macro quando viene eseguito il calcolo.

Si userà il contatore per tenere traccia del numero di passaggi di calcolo inviati, in modo da limitare il calcolo a 100 passaggi. HPC_Initialize viene chiamato ogni volta che si avvia un nuovo calcolo, in modo da poter reimpostare il contatore in tale funzione. Si vuole incrementare il contatore per ogni passaggio di calcolo. Questa operazione può essere eseguita nella macro HPC_Partition . Tenere presente che la macro HPC_Partition viene usata per raccogliere i dati necessari per un singolo passaggio di calcolo; e una volta completato il calcolo, la macro HPC_Partition deve restituire Null. Quindi per eseguire un calcolo per 100 passaggi, il contatore verrà incrementato ogni volta che viene chiamato HPC_Partition ; e una volta che il contatore raggiunge 100, verrà restituito Null.

Per costruire un calcolo che esegue 100 passaggi

1. Nella cartella Moduli della finestra del progetto VBA fare doppio clic su HPCExcelMacros.

2. Nella parte superiore del file, in "Sezione 1: Variabili e costanti", aggiungere una variabile del contatore denominata SentRecords, come illustrato di seguito:

   '==========================================================
   '
   ' Section 1: Variables and constants
   '
   '==========================================================
   
   Dim SentRecords As Integer
   

3. Scorrere verso il basso fino a trovare la funzione HPC_Initialize e aggiungere una riga per reimpostare la variabile del contatore:

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

4. Scorrere verso il basso fino a trovare la macro HPC_Partition, quindi modificarla in modo che abbia un aspetto simile al seguente:

   Public Function HPC_Partition() As Variant
   
       If SentRecords = 100 Then
           HPC_Partition = Null
       Else
           SentRecords = SentRecords + 1
           HPC_Partition = SentRecords
       End If
   
   End Function
   

5. Salva la cartella di lavoro.

Nota: poiché la nuova cartella di lavoro include macro, è necessario salvarla come cartella di lavoro abilitata per le macro (file XLSM) o una cartella di lavoro binaria (file XLSB). Uno va bene. In genere è consigliabile salvare le cartelle di lavoro come file binari (XLSB), perché sono più piccoli ed efficienti.

Ora è disponibile un calcolo che eseguirà 100 passaggi e quindi verrà completato. Le modifiche appena apportate sono tutte operazioni da eseguire per creare un calcolo del cluster excel.

Esecuzione della cartella di lavoro in locale ed esplorazione delle macro

Ora che è disponibile un calcolo, è possibile aggiungere un pulsante per eseguire la cartella di lavoro e quindi eseguire la cartella di lavoro sul desktop. Per verificare il funzionamento delle macro, verranno aggiunti alcuni nuovi frammenti di codice alla struttura di macro ed eseguire di nuovo la cartella di lavoro per verificare le modifiche apportate. La cartella di lavoro verrà testata localmente (sul desktop) prima di eseguire la cartella di lavoro nel cluster.

Aggiunta di un pulsante che esegue la cartella di lavoro in locale

Per aggiungere un pulsante che esegue la cartella di lavoro in locale

1. Con la cartella di lavoro di Excel aperta, fare clic sulla scheda Sviluppo sulla barra multifunzione.

2. Nella scheda Sviluppo fare clic su Inserisci e quindi selezionare il controllo pulsante , ovvero il primo controllo nell'elenco.

3. Dopo aver fatto clic sul pulsante, disegnare un rettangolo in un punto del foglio di calcolo per inserire il pulsante in tale posizione. Dopo aver posizionato il pulsante, viene visualizzata la finestra di dialogo Assegna macro .

4. Nella finestra di dialogo selezionare la macro CalculateWorkbookOnDesktop dall'elenco e quindi fare clic su OK. Assicurarsi di selezionare la macro desktop. Si vuole testare prima la cartella di lavoro e trovare eventuali errori prima di eseguirlo nel cluster.

5. Fare clic con il pulsante destro del mouse sul nuovo pulsante e quindi scegliere Modifica testo per modificare l'etichetta.

6. Denominare l'etichetta "Desktop" o qualcosa di simile.

7. Facoltativamente, è possibile verificare di avere assegnato la macro corretta facendo clic con il pulsante destro del mouse sul pulsante e scegliendo Assegna macro. Nella finestra di dialogo verificare che CalculateWorkbookOnDesktop sia selezionato.

8. Salva la cartella di lavoro.

9. Fare clic sul pulsante per eseguire la cartella di lavoro sul desktop.

In caso di errori, verrà visualizzata una finestra di dialogo di errore e la parte del codice VBA con l'errore verrà evidenziata. Tornare indietro nelle sezioni precedenti e verificare che tutto sia corretto.

Se tutto funziona, non verrà eseguita alcuna operazione perché la cartella di lavoro non esegue alcuna operazione. Si tratta di un po ' insoddisfacente, quindi apportare alcune modifiche in modo da poter vedere il calcolo.

Modifica del HPC_Excecute e delle macro HPC_Merge

Tenere presente che il flusso di informazioni passa da HPC_Partition (che raccoglie i parametri necessari per il calcolo), a HPC_Execute (che esegue il calcolo) e quindi a HPC_Merge (che elabora il risultato). Quando viene eseguito un calcolo, qualsiasi elemento restituito dalla macro HPC_Partition viene utilizzato come input per la macro HPC_Execute . La macro HPC_Execute è progettata per utilizzare i dati di input, eseguire un passaggio di calcolo e quindi restituire un risultato. Il risultato passa quindi a HPC_Merge, che può inserire i risultati nel foglio di calcolo.

In un passaggio precedente è stato aggiunto codice alla macro HPC_Partition per aggiornare una variabile del contatore. Nell'esempio HPC_Partition restituisce quindi il valore della variabile del contatore e lo passa a HPC_Execute. Per illustrare il flusso di informazioni e fare in modo che la cartella di lavoro restituisca alcuni risultati, il valore del contatore verrà semplicemente passato attraverso le macro. Verrà aggiunta una riga di codice alla macro HPC_Execute in modo da accettare l'input e passarla come valore restituito. Il valore della variabile contatore passa quindi alla macro HPC_Merge , che verrà modificata in modo da inserire il valore del contatore nel foglio di calcolo.

Per modificare HPC_Execute e HPC_Merge

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA fare doppio clic sul modulo HPCExcelMacros nell'albero del progetto per aprire il file di macro.

3. . Scorrere fino alla macro HPC_Execute e aggiungere una riga di codice che passa il valore di input come valore restituito. La macro dovrebbe essere simile alla seguente:

   Public Function HPC_Execute(data As Variant) As Variant
   
       HPC_Execute = data
   
   End Function
   

4. Scorrere fino alla macro HPC_Merge e aggiungere una riga di codice per inserire il valore di input nel foglio di calcolo. La macro dovrebbe essere simile alla seguente:

   Public Function HPC_Merge(data As Variant)
   
       Cells(data, 1).Value = data
   
   End Function
   
   

   Nota: il valore "data" è il contatore, restituito da HPC_Execute. Quindi, qui nella macro HPC_Merge , stiamo compilando una cella nel foglio di calcolo - usando il contatore come numero di riga - e impostando il valore come contatore. L'espressione VBA "Cells" indica la creazione di un riferimento nel foglio di calcolo con i numeri di riga e colonna specificati. Pertanto, ogni volta che viene chiamata la macro HPC_Merge , inserisce un valore nella colonna 1 (colonna A nel foglio di calcolo), con un numero di riga diverso.

5. Tornare al foglio di calcolo e fare clic sul pulsante "Desktop" per eseguire il calcolo.

Verrà visualizzato il riempimento della prima colonna con numeri compresi tra 1 e 100, ovvero i valori del contatore. Ogni volta che si fa clic sul pulsante si riempiono gli stessi numeri, quindi è difficile dire che è in esecuzione; possiamo apportare una modifica più piccola per vedere i numeri che compilano.

Modifica della macro HPC_Initialize

La macro HPC_Initialize viene chiamata quando si esegue per la prima volta la cartella di lavoro. In un passaggio precedente è stata aggiunta una riga di codice per reimpostare la variabile del contatore. È anche possibile utilizzare questa macro per cancellare i valori inseriti nel foglio di calcolo durante l'esecuzione precedente.

Per modificare la macro HPC_Initialize

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA fare doppio clic sul modulo HPCExcelMacros nell'albero del progetto per aprire il file di macro.

3. Scorrere fino alla macro HPC_Initialize **.** Aggiungere una riga di codice che svuota la prima colonna. La macro dovrebbe essere simile alla seguente:

   Public Function HPC_Initialize()
   
       Range("A:A").Value = ""
       SentRecords = 0
   
   End Function
   

4. Tornare al foglio di calcolo e fare clic sul pulsante "Desktop" per eseguire il calcolo.

Dovrebbe ora essere ovvio che la macro riempie la colonna con numeri ogni volta che si fa clic su di esso. Se sono presenti errori, verrà visualizzato un messaggio di errore e il codice VBA con l'errore verrà evidenziato. Verificare che corrisponda al codice elencato in precedenza e riprovare.

Esecuzione della cartella di lavoro nel cluster

Ora è disponibile un calcolo di Excel molto semplice usando il framework di macro HPC ed è possibile eseguirlo nel cluster. A tale scopo, è prima necessario impostare alcuni valori per indicare a Excel come contattare il cluster. Questi valori sono definiti nel modulo HPCControlMacros **.** Nella parte superiore di questo file sono necessari due valori: l'utilità di pianificazione del cluster e la directory di condivisione. Tenere presente che l'utente desktop deve avere accesso in scrittura a questa directory di condivisione; e i nodi di calcolo del cluster devono avere accesso in lettura alla directory. Nella maggior parte dei casi, i calcoli del cluster verranno eseguiti con l'account utente, ma è possibile usare un account utente diverso quando ci si connette alla sessione del cluster (più in un attimo).

Per specificare il nodo head e la directory di condivisione

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA, nell'albero del progetto, fare doppio clic sul modulo HPCControlMacros per aprire il file di macro.

3. Per l'utilità di pianificazione del cluster, usare il nome del nodo head del cluster, ovvero il nome del computer che si userebbe nella rete. È possibile usare un nome completo (ad esempio, headnode.mynetwork.com), ma non è necessario se si è nello stesso dominio.

4. Per la directory di condivisione, usare il percorso completo della directory di condivisione creata in precedenza (nella sezione "Prima di iniziare").

Ad esempio, nel cluster il nome dell'utilità di pianificazione è "HN01"; e ho creato una directory di condivisione nel nodo head denominato "HPCTemp". Quindi le mie impostazioni sono simili alle seguenti:

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

Tornare ora al foglio di calcolo di Excel. Verrà aggiunto un altro pulsante, questa volta per eseguire il calcolo nel cluster.

Per aggiungere un pulsante che esegue la cartella di lavoro nel cluster

1. Nella scheda Sviluppo fare clic su Inserisci e quindi selezionare il controllo pulsante , ovvero il primo controllo nell'elenco.

2. Dopo aver fatto clic sul pulsante, disegnare un rettangolo in un punto del foglio di calcolo per inserire il pulsante in tale posizione. Dopo aver posizionato il pulsante, viene visualizzata la finestra di dialogo Assegna macro .

3. Nella finestra di dialogo selezionare la macro CalculateWorkbookOnCluster dall'elenco e quindi fare clic su OK.

4. Fare clic con il pulsante destro del mouse sul nuovo pulsante e quindi scegliere Modifica testo per modificare l'etichetta.

5. Denominare l'etichetta "Cluster" o qualcosa di simile.

6. Salva la cartella di lavoro.

7. Fare clic sul pulsante per eseguire la cartella di lavoro nel cluster.

8. Se è la prima volta che si eseguono processi cluster, usando Excel o qualsiasi altra applicazione, verrà visualizzata una finestra di dialogo di autenticazione utente. Digitare il nome utente e la password e selezionare (se si vuole) la casella per salvare le credenziali. Se si desidera eseguire calcoli nel cluster come utente diverso, è possibile immettere impostazioni dell'account utente diverse.

Nota: assicurarsi che l'account utente, ovvero l'account utente standard o quello che si vuole usare, sia designato come utente cluster in HPC Cluster Manager.

In caso di errori, verrà visualizzata una finestra di messaggio che descrive l'errore. Se il calcolo ha funzionato sul desktop, gli errori più probabili che si riceveranno ora devono avere a che fare con le impostazioni del cluster, ovvero il nodo head o la directory di condivisione. Se la finestra di messaggio descrive uno di questi errori, controllare le impostazioni modificate nell'ultimo passaggio. Assicurarsi di avere il nome corretto per il nodo head del cluster e che la directory di condivisione sia scrivibile dall'account utente.

Cosa accade quando una cartella di lavoro viene eseguita nel cluster

Si esaminerà ora cosa accade quando si esegue il calcolo del cluster. Quando si fa clic sul pulsante, chiama la macro CalculateWorkbookOnCluster. Tale macro usa la libreria client per avviare un calcolo del cluster con le impostazioni specificate per il nodo head del cluster e la directory di condivisione.

All'avvio del calcolo, il codice client HPC Services per Excel assume il controllo. Tenere presente che è stato aggiunto un riferimento alla libreria HPC nell'editor VBA all'inizio di questa parte, ovvero la libreria client. Prima di tutto, la libreria client creerà una "sessione" del cluster, usata per gestire il calcolo. Questo richiede alcuni secondi e dopo aver fatto clic sul pulsante si noterà un ritardo di pochi secondi.

Successivamente, la libreria client chiamerà la macro HPC_Initialize . Questo avviene sul desktop. In questa cartella di lavoro la macro (1) reimposta il contatore interno; e (2) svuota la colonna A nel foglio di calcolo. Quindi, quando si fa clic sul pulsante, si noterà prima di tutto il ritardo quando viene creata la sessione; e quindi si noterà che la colonna A è deselezionata. Questa è la macro HPC_Initialize .

Successivamente, la libreria client inizierà a chiamare la macro HPC_Partition . Questo avviene anche sul desktop. Nel codice, la macro HPC_Partition incrementa il contatore e restituisce il valore del contatore. Ogni volta che questa macro restituisce un valore, fino a quando non restituisce Null, nell'ultima chiamata, la libreria client invierà una richiesta all'utilità di pianificazione HPC.

Quando l'utilità di pianificazione riceve una di queste richieste, inoltra la richiesta a uno dei nodi di calcolo del cluster per l'elaborazione. Quando il nodo di calcolo riceve la richiesta, avvia Excel, carica la cartella di lavoro e quindi chiama la macro HPC_Execute .

Si tratta della macro HPC_Execute presente nella cartella di lavoro, ma quando il calcolo viene eseguito nel cluster, la macro HPC_Execute viene effettivamente eseguita nei nodi di calcolo, a differenza di tutte le altre macro. Ecco perché vengono passati dati da una macro a un'altra. Le informazioni passano da una macro alla successiva, ma quando i dati vengono passati dalla macro HPC_Partition alla macro HPC_Execute , vengono inviati dal desktop, tramite l'utilità di pianificazione HPC e a uno dei nodi di calcolo.

Dopo che uno dei nodi di calcolo esegue la macro HPC_Execute , quando la macro viene completata il risultato del calcolo, ovvero il valore restituito dalla macro HPC_Execute , viene restituito all'utilità di pianificazione e quindi restituito alla libreria client sul desktop. Quando la libreria client riceve il risultato del calcolo, chiamerà la macro HPC_Merge sul desktop. Pertanto, ancora una volta è possibile pensare al flusso di informazioni da una macro (HPC_Execute) alla successiva (HPC_Merge), ma questo avviene in rete: dalla cartella di lavoro in esecuzione nel nodo di calcolo alla cartella di lavoro in esecuzione sul desktop.

È importante comprendere che queste chiamate di funzione di macro, ognuna delle chiamate a HPC_Partition, quando si inviano dati al cluster e ognuna delle chiamate a HPC_Merge, poiché i dati vengono ricevuti, vengono eseguiti in modo asincrono. Ovvero, quando un calcolo viene inviato al cluster, la libreria client non attenderà (o blocca) fino al completamento del calcolo specifico prima che invii quello successivo. Se la macro HPC_Partition è molto veloce, come in questo caso, è possibile che tutte le 100 richieste di calcolo vengano inviate prima del completamento di una di queste richieste.

Vale anche la pena notare che, poiché i risultati provengono dal cluster, e la macro HPC_Merge viene chiamata nella cartella di lavoro, potrebbero non tornare nello stesso ordine in cui sono stati inviati. Ciò è dovuto al fatto che ogni richiesta viene inviata al cluster, l'utilità di pianificazione lo invierà a un nodo di calcolo specifico. Il nodo di calcolo calcolerà la richiesta, usando la macro HPC_Execute nella cartella di lavoro e quindi restituirà il risultato. Tuttavia, per diversi motivi, un nodo di calcolo potrebbe essere eseguito più lentamente o più rapidamente rispetto a un altro nodo di calcolo; e in tal caso, i risultati potrebbero essere restituiti in un ordine diverso.

Probabilmente non si noterà che in questa cartella di lavoro, perché le macro sono così semplici. È tuttavia necessario prepararsi in cartelle di lavoro più complesse, poiché sono disponibili funzioni di calcolo più lunghe e verrà affrontato di seguito quando si compila una cartella di lavoro "reale".

Comunicazione dello stato di calcolo

A questo punto è stata creata una cartella di lavoro completa che viene eseguita nel cluster HPC; si dovrebbe ora capire cosa fanno le varie macro e perché sono progettate nel modo in cui sono. È necessario avere un'idea del modo in cui i dati si spostano tra le macro e quali parti vengono eseguite sul desktop e nel cluster.

Prima di completare la cartella di lavoro semplice, è possibile apportare alcune modifiche finali per aggiungere un feedback visivo, fondamentalmente un'interfaccia utente semplice. Quando è stata eseguita la cartella di lavoro nel cluster, l'unico feedback che si è verificato era che funzionava erano i numeri compilati nel foglio di calcolo. Si tratta di un inizio, ma è possibile apportare alcune modifiche che renderanno più ovvio cosa sta facendo la cartella di lavoro. Ciò che si intende fare è aggiungere alcune altre variabili per tenere traccia del calcolo e quindi visualizzarle nella barra di stato di Excel.

Il codice includerà i contatori seguenti:

• È già disponibile una variabile di contatore che tiene traccia del numero di volte in cui è stata chiamata la macro HPC_Partition . Che rappresenta il numero di volte in cui i dati sono stati inviati dal desktop al cluster.

• È possibile aggiungere un altro contatore incrementato ogni volta che viene chiamata la macro HPC_Merge , che rappresenta il numero di volte in cui i dati vengono restituiti dal cluster al desktop.

• È anche possibile aggiungere alcune variabili per tenere traccia del tempo, ovvero il tempo necessario per il calcolo. Questo può essere davvero utile per verificare se il calcolo del cluster è di fatto più veloce del desktop (e, in tal caso, quanto più veloce).

Usando questi primi due contatori, è possibile visualizzare il numero di richieste in sospeso e ottenere un'idea dello stato complessivo del calcolo. Verrà aggiunta una nuova funzione VBA in grado di segnalare lo stato del calcolo. Questa funzione ha tre parti:

• Crea una stringa che mostra il numero di calcoli inviati (il numero di chiamate HPC_Partition ) e il numero di risultati ricevuti (numero di volte in cui è stato chiamato HPC_Merge ).

• Se la variabile "CalculationComplete" è true, aggiorna la stringa per visualizzare il tempo di calcolo totale.

• Usa Application.StatusBar per impostare il messaggio della barra di stato di Excel con le informazioni appena create.

È possibile usare le macro HPC già disponibili per aggiornare questi valori e aggiornare il messaggio della barra di stato con la nuova funzione.

La procedura seguente descrive come incorporare questi nuovi elementi nell'esempio.

Per aggiungere variabili di stato alle macro e aggiornare la barra di stato di Excel

1. Tornare all'editor VBA e fare doppio clic sul modulo HPCExcelMacros per aprire il codice della macro. Nella parte superiore del codice VBA aggiungere queste nuove variabili dopo il contatore originale:

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

2. Verrà quindi aggiunta una nuova funzione VBA denominata "UpdateStatus" in grado di segnalare lo stato di calcolo. Scorrere verso il basso fino alla fine del file e aggiungere il codice come segue:

   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
   

3. È necessario inizializzare le variabili. Come per il contatore originale, questa operazione verrà eseguita nella macro HPC_Initialize . Scorrere fino a tale macro e aggiungere alcune righe:

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

   Nota: quello che stiamo facendo qui è (1) cancellare i due contatori, impostandoli su zero; (2) impostando il valore "StartTime" sull'ora corrente (la chiamata "Timer" in VBA restituisce l'ora corrente, in secondi); e (3) impostando il flag "CalculationComplete" su false, ovvero non è ancora stato completato. Dopo aver impostato questi valori, viene chiamata la nuova macro "UpdateStatus" per scrivere il messaggio nella barra di stato.

4. Scorrere verso il basso fino alla macro HPC_Partition . In questa macro è già in corso l'impostazione del primo contatore, quindi è sufficiente apportare una modifica: dopo l'aggiornamento del contatore, si aggiunge una riga per chiamare la nuova macro e aggiornare la barra di stato.

   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
   

5. Scorrere ora verso il basso fino alla macro HPC_Merge . In questo caso, si vuole aggiornare il nuovo contatore, ovvero quello che rappresenta i messaggi restituiti al desktop, e aggiornare di nuovo la barra di stato. Modificare quindi la macro HPC_Merge :

   Public Function HPC_Merge(data As Variant)
   
       Cells(data, 1).Value = data
       RcvRecords = RcvRecords + 1
       UpdateStatus
   
   End Function
   

6. Scorrere verso il basso fino alla macro HPC_Finalize . Questa macro viene chiamata al completamento dell'intero calcolo; è quindi possibile usarlo per impostare il flag "CalculationComplete", nonché per determinare per quanto tempo è stato impiegato il calcolo totale:

   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
   

   Nota: quando impostiamo il campo "FinishTime" su Timer, lo impostiamo con l'ora corrente, in secondi. Nella macro UpdateStatus si usano "StartTime" e "FinishTime" per determinare il tempo totale di calcolo.

7. Salvare la cartella di lavoro

8. Tornare al foglio di calcolo di Excel e fare clic sul pulsante "Cluster".

Verrà visualizzato l'aggiornamento della barra di stato con i numeri durante l'esecuzione del calcolo; prima di tutto verrà visualizzato il numero di calcoli inviati (il secondo numero) fino a 100, quindi dopo un breve ritardo si noterà che il numero di risultati ricevuti (il primo numero) sale fino a 100.

Quello che viene visualizzato qui è la messaggistica asincrona illustrata in precedenza. Poiché la macro HPC_Partition è così veloce, la libreria client è in grado di inviare tutte le 100 richieste prima del completamento di uno dei calcoli. Si verifica un breve ritardo, ovvero il ritardo è costituito dai nodi di calcolo che avviano Excel e caricano la cartella di lavoro. Dopo che ogni nodo di calcolo ha avviato Excel, il calcolo dei risultati è piuttosto veloce e il primo numero raggiunge rapidamente 100.

Se si fa clic sul pulsante "Desktop", si noterà che i numeri si spostano in modo diverso. Sul desktop, la libreria client chiama le stesse macro, ma lo esegue in modo sincrono (ovvero, non in modo asincrono). Per eseguire il calcolo desktop, la libreria client chiamerà a sua volta ogni macro, prima HPC_Partition, quindi HPC_Execute e quindi HPC_Merge , ma in questo caso, attenderà il completamento di ogni macro prima di chiamare quella successiva. Ecco perché quando si esegue sul desktop, si noteranno entrambi i numeri che si spostano insieme.

Parte 2: Conversione di una cartella di lavoro "desktop" da eseguire nel cluster HPC

Nell'ultima sezione è stata creata una cartella di lavoro da zero per calcolare in un cluster HPC. In questa sezione si userà una cartella di lavoro esistente e la si modificherà per l'esecuzione nel cluster. Se hai seguito l'ultima parte, dovresti avere una comprensione di ciò che è necessario - anche se c'erano molti passaggi individuali, il lavoro effettivo coinvolto era molto semplice. In breve:

• Aggiunta di due file di macro.

• Aggiunta di due riferimenti al progetto VBA.

• Sono state apportate alcune modifiche alle macro.

• Aggiunta di pulsanti per eseguire il foglio di calcolo.

La conversione di una cartella di lavoro esistente corrisponde alla stessa quantità di lavoro. Non è disponibile un sacco di nuovo codice VBA da aggiungere e la maggior parte se può riutilizzare gli stessi file macro scheletro. Nella maggior parte dei casi, la conversione di una cartella di lavoro esistente comporta lo spostamento del codice, ovvero la copia di codice da macro esistenti nelle macro HPC.

La parte difficile della conversione di una cartella di lavoro esistente è capire quale codice spostare e dove deve essere spostato. Excel VBA è un ambiente di sviluppo completo e esistono molti modi per compilare applicazioni Excel: diversi sviluppatori potrebbero scrivere la stessa applicazione in molti modi diversi.

In questa sezione verrà caricata una cartella di lavoro esistente e la si convertirà in esecuzione nel cluster. È consigliabile leggere questa sezione come guida o, ad esempio, e quindi provare ad applicare i concetti alle proprie cartelle di lavoro. In questo caso è disponibile un esempio abbastanza semplice (anche se si basa su una cartella di lavoro reale usata per risolvere un problema aziendale reale). Per qualsiasi cartella di lavoro, il processo sarà lo stesso, ma i dettagli specifici saranno diversi.

Analisi della cartella di lavoro

In Excel aprire la cartella di lavoro "ConvertPricing.xlsb" dalla directory "Seconda cartella di lavoro". È possibile che venga visualizzato un avviso sulle macro; in tal caso, fare clic su "Abilita macro" per continuare.

Questa cartella di lavoro calcola i prezzi delle obbligazioni convertibili, in base ai valori nella sezione "Parametri modello" a sinistra. La tabella a destra viene usata per comprendere quali effetti piccoli cambiamenti nei parametri - cambiamenti nel prezzo di conversione e nel tasso di cedola - avranno sul prezzo finale.

Fare clic sul pulsante "Calcola tabella" nel foglio di calcolo. Si noterà che la tabella viene compilata, lentamente, come viene calcolato ogni prezzo. In una workstation tipica, la compilazione della tabella completa richiederà da qualche parte tra 1 e 2 minuti.

Per capire cosa fa questa cartella di lavoro quando si fa clic sul pulsante, è possibile esaminare il codice VBA.

Per identificare la macro e visualizzare il codice

1. Fare clic con il pulsante destro del mouse sul pulsante "Calcola tabella" e scegliere Assegna macro.

2. Nella finestra di dialogo macro viene visualizzata la macro attualmente utilizzata dal pulsante . Nella finestra di dialogo fare clic su Modifica per passare al codice. Verrà visualizzato il codice per la macro "CalculateTable". Si tratta del codice eseguito quando si fa clic sul pulsante nel foglio di calcolo.

Esaminando questa macro, è possibile visualizzare alcune sezioni distinte. In primo luogo, esistono alcune dichiarazioni di variabili. Successivamente è disponibile un codice di inizializzazione. Infine, è presente una sezione che calcola la tabella. È possibile identificare dove esegue il ciclo delle righe e delle colonne nella tabella e compila i valori.

Questa macro è piuttosto breve, ma se si esamina il ciclo si noterà che chiama alcune altre funzioni, ovvero le funzioni "FullDiscountModel" e "BondPlusOptionModel". Si tratta delle routine di calcolo effettive, la logica di business che alimenta la cartella di lavoro.

Nell'editor VBA è possibile passare all'origine di qualsiasi funzione facendo clic con il pulsante destro del mouse sul nome e scegliendo "Definizione". Se si fa clic con il pulsante destro del mouse su "FullDiscountModel" e si seleziona "Definizione", si noterà che il calcolo effettivo è piuttosto complesso. Tuttavia, per convertire la cartella di lavoro da eseguire nel cluster, non è necessario modificare o addirittura comprendere tale calcolo. È sufficiente preoccuparsi del codice di controllo, ovvero la funzione che contiene il ciclo.

Questa cartella di lavoro è stata progettata in modo molto pulito, in quanto la logica di business è contenuta in funzioni separate. In altri casi, tutto questo codice potrebbe trovarsi in una singola macro, che renderebbe la cartella di lavoro più difficile da comprendere. In entrambi i casi, tuttavia, ciò che dobbiamo fare per convertire questa cartella di lavoro è prendere il codice di controllo, ovvero le routine di avvio e le funzioni del ciclo, e spostarle nelle macro HPC.

Si sa anche che in questa cartella di lavoro i calcoli sono indipendenti. Ovvero, ogni cella della tabella viene calcolata senza riferimenti ad altre celle della tabella. Ciò significa che la cartella di lavoro è iterativa e supporterà la parallelizzazione (come illustrato nella sezione Panoramica precedente). Potrebbe non essere sempre ovvio che i calcoli sono indipendenti. Un modo per capire questo è scrivere alcune funzioni di test, ad esempio è possibile riscrivire la macro "CalculateTable" (la macro chiamata quando si preme il pulsante nel foglio di calcolo) - per eseguire un solo calcolo o una cella della tabella. In questo modo è possibile determinare se i risultati erano coerenti e, in tal caso, è possibile stabilire se i calcoli erano effettivamente indipendenti.

Per riepilogare, le funzionalità più importanti per qualsiasi cartella di lavoro per supportare l'esecuzione in un cluster Microsoft HPC sono le seguenti:

• La cartella di lavoro è iterativa: esegue lo stesso calcolo molte volte, con set diversi di dati di input; oppure esegue molti singoli calcoli, ad esempio righe o celle in una tabella, uno alla volta.

• I singoli calcoli sono indipendenti, ovvero i risultati di un singolo calcolo non influiscono su nessun altro calcolo.

Entrambi sono validi per questa cartella di lavoro, quindi è un buon candidato per l'esecuzione nel cluster.

Preparazione della cartella di lavoro

Come nell'ultima cartella di lavoro, le prime modifiche che verranno apportate con la configurazione dell'ambiente VBA. È possibile usare gli scheletri di file di macro per risparmiare tempo, che includeranno le macro HPC necessarie per il calcolo.

Nell'ultima cartella di lavoro sono state apportate alcune modifiche agli scheletri di file di macro per aggiungere commenti e suggerimenti degli utenti (visualizzando lo stato di avanzamento del calcolo nella barra di stato di Excel). In questa seconda cartella di lavoro i file di macro scheletro includono già il codice della barra di stato.

Per importare i file di macro e aggiungere riferimenti

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA fare clic con il pulsante destro del mouse su Progetto VBA nella parte superiore della visualizzazione albero e quindi scegliere Importa file.

3. Nella finestra di dialogo individuare i file di progetto scaricati. Passare alla directory "Seconda cartella di lavoro", selezionare il file "HPCExcelMacros.bas" e fare clic su OK.

   

4. Ripetere i passaggi da 1 a 3 per importare "HPCControlMacros.bas" e quindi fare clic su OK. Che aggiunge il secondo file di macro al progetto.

5. Verificare che questi due file di macro siano visualizzati nella finestra del progetto VBA:

6. Nella finestra dell'editor VBA fare clic su Strumenti e quindi su Riferimenti per aprire la finestra di dialogo riferimenti al progetto.

7. Nell'elenco dei riferimenti disponibili scorrere verso il basso fino a trovare assembly HPC Pack Microsoft (R) e selezionare la casella di controllo accanto. Dopo aver selezionato la casella, la finestra di dialogo sarà simile alla seguente:

8. Fare clic su OK per chiudere la finestra di dialogo riferimenti al progetto.

Definizione dei calcoli nel framework macro

Con l'ambiente VBA configurato, è possibile passare al passaggio successivo, modificando le macro per eseguire il calcolo. Il modulo HPCExcelMacros include le stesse macro della prima cartella di lavoro, solo questa volta includono i contatori e il codice per aggiornare la barra di stato.

Definizione delle variabili e copia del codice di inizializzazione dalla macro originale

I primi elementi necessari sono i contatori per la riga e la colonna. In questa cartella di lavoro si divide il calcolo in modo che ogni cella della tabella venga calcolata separatamente. La macro originale usa cicli per eseguire ogni cella della tabella, ma nelle funzioni macro HPC viene usato il framework asincrono, quindi è necessario tenere traccia dei numeri di riga e colonna man mano che si inviano ogni singolo calcolo. Nelle macro verranno usate variabili di riga e di colonna per scorrere ogni cella della tabella; riflettono la riga e la colonna che stiamo calcolando in ogni passaggio.

Si tornerà alla macro originale per vedere cosa ha fatto all'avvio e quindi spostarlo nella macro HPC_Initialize .

Per impostare le variabili e modificare HPC_Initialize

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA fare doppio clic sul modulo HPCExcelMacros nell'albero del progetto per aprire il file di macro.

3. Nella parte superiore del file, in "Sezione 1: Variabili e costanti", aggiungere variabili di riga e colonna, come illustrato di seguito:

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

4. Scorrere fino alla macro HPC_Initialize e inizializzare i contatori di riga e colonna appena configurati:

   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
   
   

5. Nell'editor VBA fare doppio clic sul modulo "ScenarioAnalysis" nella finestra del progetto VBA. File contenente il codice macro originale. La parte di inizializzazione è la prima sezione, che determina le dimensioni della tabella e imposta alcune variabili (NumRows e 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
   

6. Copiare il codice dalla macro originale, quindi tornare al modulo HPCExcelMacros (fare doppio clic su HPCExcelMacros nella finestra del progetto VBA) e incollarlo nella macro HPC_Initialize .

Il codice finale in HPC_Initialize ora è simile al seguente:

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

Modifica della macro HPC_Partition

La macro successiva da modificare è la macro HPC_Partition . Tenere presente che questa macro raccoglie tutti i dati necessari per eseguire un singolo calcolo. In questo caso, questo sarà il numero di riga e colonna. Per questa cartella di lavoro, si vuole calcolare ogni singola cella di tabella nel cluster separatamente; a tale scopo, si useranno il numero di riga e di colonna.

Tutte le macro nel framework HPC usano il tipo di dati Variant per input e output. Il tipo Variant può essere qualsiasi tipo primitivo (integer, long, double, string) o matrice di questi tipi. È necessario includere sia la riga che la colonna, in modo da poter usare una matrice.

L'altra operazione da eseguire nella macro HPC_Partition è capire quando il calcolo è completo. In questo caso, il calcolo verrà completato al raggiungimento della fine della tabella. A tale scopo, è possibile incrementare i numeri di riga e di colonna durante lo spostamento nella tabella. Ogni volta che si raggiunge la fine di una colonna, si passa alla colonna successiva. Dopo aver passato l'ultima colonna, la tabella viene completata e si vuole che la funzione restituisca Null.

Per modificare la macro HPC_Partition

1. Nel codice HPCExcelMacros scorrere fino alla sezione HPC_Partition e aggiungere codice per dichiarare una matrice per la riga e la colonna:

   Public Function HPC_Partition() As Variant
   
       Dim data(3) As Variant
   
       ' update the status bar with the counters
   
       SentRecords = SentRecords + 1
       UpdateStatus
   
   End Function
   

2. Aggiungere il codice per verificare la fine della tabella. Questo terminerà il calcolo al termine della tabella.

   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
   

3. Se la tabella non è ancora stata completata, l'ultima parte della funzione archivierà i valori di riga e colonna e li userà come valore restituito per la funzione; e quindi passare alla riga successiva:

   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
   

Quindi, per esaminare, la macro HPC_Partition ha due scopi: raccoglie i parametri necessari per un singolo calcolo (ecco il numero di riga e colonna); e quando il calcolo viene completato, segnala che restituendo Null. Nella funzione creata esegue questa operazione eseguendo un'istruzione alla volta nella tabella, prima per riga e poi per colonna e quando viene passata l'ultima colonna, restituisce Null per indicare che la tabella è stata completata.

Modifica della macro HPC_Execute

La macro successiva è HPC_Execute. Tenere presente che questa macro è progettata per eseguire il calcolo effettivo o la logica di business. Gli input per questa funzione saranno tutti gli input restituiti dalla macro HPC_Partition nell'ultimo passaggio. Poiché è stata appena scritta la macro HPC_Partition , si sa che gli input per la macro HPC_Execute saranno il numero di riga e di colonna della cella della tabella da calcolare.

Il corpo della macro HPC_Execute verrà copiato dal codice dalla macro di calcolo originale. Saranno necessarie due parti di questo codice: le dichiarazioni di variabile nella parte superiore e il codice che esegue il ciclo. È già stata usata la sezione relativa alle dimensioni della tabella nella macro HPC_Initialize , quindi non è necessario eseguire di nuovo questa operazione, ma sarà più semplice copiare l'intero blocco di codice e quindi rimuovere le parti non necessarie. Verranno quindi apportate alcune modifiche per supportare il framework asincrono.

Per modificare la macro HPC_Execute

1. Tornare alla macro originale facendo doppio clic sul modulo "ScenarioAnalysis" nella finestra del progetto VBA.

2. Copiare il codice dalla prima riga:

   Dim Prem as double
   

   Fino all'ultima riga:

   Next cols
   

3. Tornare al modulo HPCExcelMacros (facendo doppio clic nella finestra del progetto VBA) e incollare il codice nella macro HPC_Execute .

4. Nella macro HPC_Execute eliminare le righe già usate, a partire da:

   ' clear values, then figure out the table size
   

   Fino alla riga appena prima:

   ' set up and run through the table
   

5. Verificare che la macro HPC_Execute sia simile alla seguente:

   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
   
   

   Nota: nella macro è ora disponibile la parte di calcolo della funzione, incluso il ciclo che viene eseguito attraverso ogni cella della tabella. Per il framework asincrono, non si vuole usare un ciclo qui; vogliamo solo calcolare una singola cella. Tenere presente che la macro HPC_Execute è il codice che verrà eseguito nei nodi di calcolo e viene dato il numero di riga e di colonna da calcolare.

6. Rimuovere le righe che costituiscono il ciclo (le righe evidenziate di seguito):

   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
   

7. Sostituzione del ciclo con il numero di riga e di colonna passato alla funzione. Il codice modificato dovrebbe essere simile al seguente:

       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
   
   

Invece del ciclo, ora si usano i valori della matrice di dati, ovvero la matrice restituita dalla macro HPC_Partition , che contiene la riga e la colonna della cella da calcolare. Quindi, per esaminare l'ultimo passaggio, sono state rimosse le due linee del ciclo,

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

nonché le righe "Avanti" alla fine del ciclo,

        Next rws
    Next cols

e aggiunte righe appena sopra il ciclo per usare la variabile matrice di dati:

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

L'ultima modifica da apportare alla funzione HPC_Execute ha a che fare con la restituzione dei dati. Tenere presente che i dati si spostano tra le macro, ogni macro passa i risultati a quella successiva. Il codice VBA originale per questa cartella di lavoro è stato progettato per l'esecuzione sul desktop, in modo che ogni cella sia stata calcolata il risultato è stato incollato nel foglio di calcolo. Poiché la cartella di lavoro verrà eseguita nel cluster, anziché incollare i risultati nel foglio di calcolo, è necessario raccogliere il risultato del calcolo e restituirlo dalla funzione.

E c'è un altro aspetto da considerare: quando la funzione HPC_Execute viene eseguita in un nodo di calcolo, calcola il risultato per una determinata cella della tabella. Questo risultato verrà quindi restituito al desktop e inviato alla macro HPC_Merge . Tuttavia, tenere presente che nel framework asincrono i risultati possono essere restituiti in qualsiasi ordine, non necessariamente lo stesso ordine inviato. È quindi necessario indicare alla macro HPC_Merge quale cella della tabella è stata calcolata.

È possibile farlo includendo il numero di riga e di colonna nei dati dei risultati. Come per la macro HPC_Partition , è possibile restituire una matrice dalla macro HPC_Excecute. Questa operazione consentirà alla funzione di restituire non solo il risultato, ma anche la cella calcolata.

In effetti, è sufficiente riutilizzare la stessa matrice passata alla funzione per restituire il risultato, perché tale matrice contiene già il numero di riga e colonna.

Per archiviare il risultato, modificare il codice in modo che venga letto come segue:

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

È stato modificato il codice che ha inserito valori nel foglio di calcolo in modo da archiviare invece i valori dei risultati nella matrice di dati. E l'ultima riga usa la matrice di dati come valore restituito dalla funzione, quindi i risultati , e i numeri di riga e colonna, verranno inviati alla macro successiva.

Il codice finale completo per la macro HPC_Execute avrà un aspetto simile al seguente:

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

Modifica della macro HPC_Merge

L'ultima macro da modificare è la macro HPC_Merge . Tenere presente che questa macro riceve un singolo risultato di calcolo dal cluster. Si vuole usarlo per inserire il risultato nella tabella.

L'input da HPC_Merge sarà quello restituito da HPC_Execute. Poiché è stata appena scritta la macro HPC_Execute , si sa che il valore restituito sarà una matrice contenente il numero di riga e di colonna e il risultato del calcolo. Per aggiornare la tabella, è possibile usare il codice della macro originale (questo è il codice appena modificato nella funzione HPC_Execute ).

La riga di codice originale, nel modulo ScenarioAnalysis, ha un aspetto simile al seguente:

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

Questa riga verrà riscritta per usare i valori passati alla macro nel parametro di dati. La macro HPC_Merge completata avrà un aspetto simile al seguente:

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

Si tratta della stessa riga di codice appena rimossa dalla macro HPC_Execute . I valori di riga e colonna (rws e cols nella riga originale) sono stati sostituiti con la riga e la colonna della matrice. È stata sostituita anche la chiamata di funzione con il risultato, archiviato nella stessa matrice.

Queste sono tutte le modifiche che è necessario apportare per eseguire questa cartella di lavoro nel cluster. Anche se potrebbe sembrare un sacco di passaggi, in particolare se questa è la prima volta che si è usato HPC Services per Excel, esaminare le macro per visualizzare il codice totale che è stato modificato. Non è davvero un sacco. Nella maggior parte dei casi, questa operazione comportava la copia e incollamento dalla macro originale nelle macro HPC. Per supportare il calcolo asincrono, è stata apportata una serie di modifiche al codice, ma anche relativamente semplice. Non sono state apportate modifiche alla logica di business effettiva in questa cartella di lavoro e non è nemmeno necessario comprendere le funzioni della logica di business per convertire la cartella di lavoro. Più importante, se gli utenti apportano modifiche alla logica di business in futuro, non richiederà la modifica del calcolo del cluster.

Esecuzione della cartella di lavoro

Per testare le modifiche apportate al codice, verrà prima eseguito sul desktop. Come nella prima cartella di lavoro aggiungeremo un nuovo pulsante al foglio di calcolo e lo useremo per eseguire il calcolo. Si specificheranno quindi il nodo head e la condivisione file, si aggiungerà un pulsante che esegue la cartella di lavoro nel cluster e quindi si eseguirà la cartella di lavoro nel cluster.

Aggiunta di un pulsante che esegue la cartella di lavoro in locale

Per aggiungere un pulsante che esegue la cartella di lavoro in locale

(1) Con la cartella di lavoro di Excel aperta, fare clic sulla scheda Sviluppo sulla barra multifunzione.

(2) Nella scheda Sviluppo fare clic su Inserisci e quindi selezionare il controllo pulsante , ovvero il primo controllo nell'elenco.

(3) Dopo aver fatto clic sul pulsante, disegnare un rettangolo in un punto del foglio di calcolo per inserire il pulsante in tale posizione. Dopo aver posizionato il pulsante, viene visualizzata la finestra di dialogo Assegna macro . !

(4) Nella finestra di dialogo selezionare la macro CalculateWorkbookOnDesktop dall'elenco e quindi fare clic su OK. Assicurarsi di selezionare la macro desktop. Si vuole testare prima la cartella di lavoro e trovare eventuali errori prima di eseguirlo nel cluster.

(5) Fare clic con il pulsante destro del mouse sul nuovo pulsante e quindi scegliere Modifica testo per modificare l'etichetta.

(6) Denominare l'etichetta "Desktop" o qualcosa di simile.

(7) Salvare la cartella di lavoro.

(8) Fare clic sul pulsante per eseguire la cartella di lavoro sul desktop.

In caso di errori, verrà visualizzata una finestra di dialogo di errore e la parte del codice VBA con l'errore verrà evidenziata. Eseguire un doppio controllo rispetto al codice elencato in precedenza per risolvere eventuali errori.

Se non sono presenti errori, verrà visualizzata la tabella compilata. I valori devono essere uguali a quando si fa clic sul pulsante originale nel foglio di calcolo. Anche in questo caso è in esecuzione sul desktop, quindi dovrebbe essere eseguito circa la stessa velocità del pulsante originale - da qualche parte tra 1 e 2 minuti nella maggior parte delle workstation.

Poiché è in esecuzione con il codice del framework di macro, verrà visualizzato anche lo stato di avanzamento del calcolo nella barra di stato di Excel. Come per la prima cartella di lavoro, in esecuzione sul desktop i numeri vengono spostati insieme, perché sul desktop la cartella di lavoro viene eseguita in modo sincrono.

Esecuzione della cartella di lavoro nel cluster

Successivamente si proverà a eseguire la cartella di lavoro nel cluster. A tale scopo, è prima necessario impostare alcuni valori per indicare a Excel come contattare il cluster. Questi valori sono definiti nel modulo HPCControlMacros **.** Nella parte superiore di questo file sono necessari due valori: l'utilità di pianificazione del cluster e la directory di condivisione. Tenere presente che l'utente desktop deve avere accesso in scrittura a questa directory di condivisione; e i nodi di calcolo del cluster devono avere accesso in lettura alla directory. Nella maggior parte dei casi, i calcoli del cluster verranno eseguiti con l'account utente, ma è possibile usare un account utente diverso quando ci si connette alla sessione del cluster (più in un attimo).

Per specificare il nodo head e la directory di condivisione

1. Nella scheda Sviluppo della barra multifunzione fare clic su Visual Basic per aprire l'editor VBA.

2. Nell'editor VBA, nell'albero del progetto, fare doppio clic sul modulo HPCControlMacros per aprire il file di macro.

3. Per l'utilità di pianificazione del cluster, usare il nome del nodo head del cluster, ovvero il nome del computer che si userebbe nella rete. È possibile usare un nome completo (ad esempio, headnode.mynetwork.com), ma non è necessario se si è nello stesso dominio.

4. Per la directory di condivisione, usare il percorso completo della directory di condivisione creata in precedenza (nella sezione "Prima di iniziare").

Tornare ora al foglio di calcolo di Excel. Verrà aggiunto un altro pulsante, questa volta per eseguire il calcolo nel cluster.

Per aggiungere un pulsante che esegue la cartella di lavoro nel cluster

1. Nella scheda Sviluppo fare clic su Inserisci e quindi selezionare il controllo pulsante , ovvero il primo controllo nell'elenco.

2. Dopo aver fatto clic sul pulsante, disegnare un rettangolo in un punto del foglio di calcolo per inserire il pulsante in tale posizione. Dopo aver posizionato il pulsante, viene visualizzata la finestra di dialogo Assegna macro .

3. Nella finestra di dialogo selezionare la macro CalculateWorkbookOnCluster dall'elenco e quindi fare clic su OK.

4. Fare clic con il pulsante destro del mouse sul nuovo pulsante e quindi scegliere Modifica testo per modificare l'etichetta.

5. Denominare l'etichetta "Cluster" o qualcosa di simile.

6. Salva la cartella di lavoro.

7. Fare clic sul pulsante per eseguire la cartella di lavoro nel cluster.

8. Se è la prima volta che si eseguono processi cluster, usando Excel o qualsiasi altra applicazione, verrà visualizzata una finestra di dialogo di autenticazione utente. Digitare il nome utente e la password e selezionare (se si vuole) la casella per salvare le credenziali. Se si desidera eseguire calcoli nel cluster come utente diverso, è possibile immettere impostazioni dell'account utente diverse.

Nota: assicurarsi che l'account utente, ovvero l'account utente standard o quello che si vuole usare, sia designato come utente cluster in HPC Cluster Manager.

In caso di errori, verrà visualizzata una finestra di dialogo popup. Se il calcolo del desktop ha funzionato, a questo punto gli errori più probabili avranno a che fare con le impostazioni create per il nodo head del cluster e la directory di condivisione. Verificare le impostazioni e riprovare.

Se non sono presenti errori, verrà visualizzato l'avvio del calcolo del cluster. Prima di tutto verrà eseguita una breve pausa perché la libreria client crea una sessione HPC per il calcolo. Successivamente, la libreria client chiamerà la macro HPC_Initialize e si noterà che la tabella è cancellata. Se si esamina la barra di stato di Excel, si noterà che prima tutti i record vengono inviati al cluster; il secondo numero salterà fino a 105 (nella tabella sono presenti 105 celle). Dopo di che verrà visualizzata un'altra breve pausa prima che vengano restituiti i risultati. Questa pausa si verifica quando ogni nodo di calcolo avvia Excel e carica la cartella di lavoro.

Dopo questa pausa verranno visualizzati i risultati che iniziano a popolare la tabella e la barra di stato inizierà a visualizzare il numero di risultati restituiti. Poiché si tratta di un calcolo lungo, è molto probabile che vengano visualizzati i risultati restituiti fuori ordine; ci saranno spazi vuoti nella tabella, che quindi vengono compilati. Anche in questo caso, poiché il calcolo è asincrono e alcuni nodi di calcolo calcolano più velocemente di altri. Alla fine la tabella verrà compilata completamente e la barra di stato mostrerà l'ora di calcolo.

Anche se nel cluster HPC sono presenti solo due nodi di calcolo, il calcolo dovrebbe essere molto più veloce rispetto all'esecuzione sul desktop. Se si dispone di quattro nodi, otto nodi o più, il calcolo dovrebbe essere estremamente veloce. È sempre possibile fare clic sul pulsante "Desktop" per confrontare le prestazioni del calcolo desktop con il calcolo del cluster.

Procedure consigliate per Cluster-Enabled cartelle di lavoro di Excel

La nota seguente descrive alcune considerazioni importanti da tenere presenti quando si progettano cartelle di lavoro di Excel da usare con HPC Services per Excel. Questa nota si applica alle cartelle di lavoro che usano il framework di macro HPC/Excel in esecuzione da VBA o con la libreria .NET ExcelClient.

Prestazioni dell'applicazione cluster

Quando si progetta un'applicazione per il calcolo in un cluster HPC, in genere si divide il lavoro necessario in singole attività e si inviano tali attività al cluster per il calcolo. I vantaggi delle prestazioni derivanti dall'uso di HPC derivano dalla parallelizzazione, con molti nodi di calcolo che funzionano contemporaneamente.

È responsabilità dell'utilità di pianificazione HPC (nodo head) distribuire queste attività ai nodi di calcolo per l'elaborazione. Tuttavia, per assicurarsi che i nodi di calcolo non siano mai in attesa di lavoro, è consigliabile provare a verificare che l'utilità di pianificazione HPC disponga sempre di un elenco di attività da elaborare. Se l'Utilità di pianificazione deve attendere l'attività di elaborazione successiva, uno o più nodi di calcolo rimarranno inattivi, senza eseguire alcuna operazione e non si otterrà l'utilizzo ottimale del cluster HPC.

È possibile assicurarsi che l'utilità di pianificazione e i nodi di calcolo abbiano sempre abbastanza lavoro da eseguire inviando le richieste di calcolo il più rapidamente possibile. Nel framework macro HPC/Excel le richieste vengono inviate con la macro HPC_Partition. È quindi importante assicurarsi che la macro Partition sia il più veloce possibile. Se è possibile progettare la macro Partition per inviare rapidamente le attività, si garantisce che il cluster sia completamente utilizzato e si otterranno le migliori prestazioni possibili da HPC.

Al termine dei singoli calcoli nei nodi di calcolo del cluster, i risultati vengono inviati all'applicazione desktop. Nel framework di macro HPC/Excel i risultati vengono elaborati usando la macro HPC_Merge. Si desidera rendere questa macro il più velocemente possibile, per due motivi. In primo luogo, se la macro Merge è lenta nell'elaborazione dei risultati, potrebbe non essere necessario collegare le risorse del cluster. In secondo luogo, l'elaborazione lenta dei risultati rallenterà il calcolo complessivo, riducendo i vantaggi dell'uso di HPC. Se si garantisce che i risultati della macro Merge vengano elaborati rapidamente, verranno rilasciate tutte le risorse del cluster per altri usi e si migliorerà l'esperienza utente complessiva.

Miglioramento delle prestazioni delle macro HPC/Excel

In questa sezione verranno descritti alcuni passaggi che è possibile eseguire per assicurarsi che le cartelle di lavoro di Excel abilitate per HPC siano il più efficienti possibile, in modo da ottenere le migliori prestazioni possibili quando si eseguono calcoli in un cluster HPC.

Questo elenco non è completo, ma è possibile trovare alcuni suggerimenti che si applicano alla cartella di lavoro. Tenere presente che si tratta di ottimizzazioni: l'approccio migliore quando si progettano cartelle di lavoro di Excel abilitate per HPC consiste nel progettare prima il calcolo e mantenerlo il più semplice possibile; dopo aver eseguito correttamente la cartella di lavoro nel cluster, apportare il tipo di modifiche descritte qui per migliorare le prestazioni complessive.

Evitare di aprire e chiudere le risorse nelle macro Partition and Merge

L'apertura e la chiusura di risorse esterne, ad esempio i file di log o le connessioni di database, possono richiedere molto tempo e rallentare le macro Partition e Merge. Inoltre, è consigliabile evitare di leggere set di dati di grandi dimensioni in queste macro, se possibile. Ad esempio, non si vuole aprire una connessione di database, cercare i record e individuare un singolo record per ogni chiamata alla macro Partition.

Un approccio migliore consiste nell'aprire queste risorse una sola volta, nella macro Inizializza ed eseguire eventuali passaggi di elaborazione iniziali. Ad esempio, se è necessario caricare un set di dati di grandi dimensioni da un database, creare la connessione al database ed eseguire la query nella macro Inizializza. Quindi, nella macro Partizione, è sufficiente passare al record successivo. È possibile chiudere la connessione al database nella macro Finalize.

Analogamente, se si scrive in un file di log nella macro Merge, è consigliabile aprire il file nella macro Inizializza. Nella macro Merge è possibile scrivere risultati uno alla volta e quindi chiudere il file di log nella macro Finalize.

Evitare di ricalcolare il foglio di calcolo nella macro Merge

Se si inseriscono risultati nel foglio di calcolo nella macro Merge, è possibile ricalcolare inavvertitamente il foglio di calcolo- se il foglio di calcolo è molto complicato, questo può rallentare l'elaborazione.

Per impostazione predefinita, Excel ricalcola il foglio di calcolo ogni volta che si modifica il valore di una cella, incluso se si aggiorna la cella da una macro VBA. Excel ricalcola solo le parti del foglio di calcolo interessate dalla modifica, quindi se la cella si trova da sola, questo non sarà significativo. Tuttavia, se la cella viene usata come parte di un calcolo più grande o come dati del grafico, il ricalcolo potrebbe essere lento.

Se si aggiornano celle del foglio di calcolo nella macro Merge, è consigliabile disabilitare il ricalcolo automatico. È possibile disabilitare il ricalcolo automatico nella macro Inizializza. Nella macro Finalize è quindi possibile ricalcolare l'intero foglio di calcolo e riabilitare il calcolo automatico.

Nella macro Inizializza è possibile disattivare il calcolo automatico con

Application.Calculation = xlCalculationManual

È quindi possibile ricalcolare il foglio di calcolo e riabilitare il calcolo automatico nella macro Finalize con

Application.Calculate
Application.Calculation = xlCalculationAutomatic

Inserire blocchi di dati anziché singoli valori

Quando si aggiornano le celle del foglio di calcolo da VBA, questo comporta una serie di passaggi interni- e potrebbe essere più lento del previsto. È quasi sempre meglio modificare più celle come un singolo blocco, invece di uno alla volta.

Se la macro Esegui restituisce un numero elevato di valori, ad esempio una matrice di 100 numeri, esistono due modi per inserire questi dati nel foglio di calcolo. È possibile inserirli uno alla volta, in un ciclo:

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

In alternativa, è possibile inserire l'intervallo completo come matrice:

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

L'inserimento di una cella richiede circa la stessa quantità di tempo dell'inserimento di un blocco di celle. Pertanto, se si dispone di una matrice di 100 valori, il primo modo per eseguire questa operazione, ovvero l'inserimento di celle una alla volta in un ciclo, può richiedere fino a 100 volte fino a quando il secondo approccio, inserendo il blocco di celle come matrice.

Disattivare gli aggiornamenti dello schermo

Se si apportano modifiche al foglio di calcolo nella macro Merge, se si aggiornano le celle o si modificano i dati del grafico, la disattivazione degli aggiornamenti dello schermo può ridurre il tempo di elaborazione. Questa operazione funziona perché Excel utilizza del tempo per aggiornare la schermata e l'interfaccia utente.

È possibile disabilitare gli aggiornamenti dello schermo nella macro Inizializza e riabilitare gli aggiornamenti dello schermo nella macro Finalize. Nella macro Inizializza utilizzare

Application.ScreenUpdating = False

Nella macro Finalize utilizzare

Application.ScreenUpdating = True

Ciò disabiliterà gli aggiornamenti dello schermo durante il calcolo e riabiliterà gli aggiornamenti dopo il completamento del calcolo. Quando si riabilita l'aggiornamento dello schermo nella macro Finalize, Excel aggiornerà automaticamente la schermata.

Usare strutture di dati per contenere temporaneamente le informazioni in memoria

Se si raccolgono informazioni per l'elaborazione, ovvero le operazioni eseguite nella macro Partizione, richiede molto tempo o se è necessario eseguire una post-elaborazione molto complessa dei risultati, nella macro Merge, è consigliabile usare le strutture di dati per archiviare le informazioni in memoria durante il calcolo.

Ad esempio, se ognuna delle richieste di calcolo nella macro Partizione richiede una query di database molto complessa, questa operazione può rallentare l'elaborazione e comportare prestazioni scarse. In questo caso, potrebbe essere consigliabile eseguire questa complessa elaborazione nella macro Inizializza prima dell'avvio del calcolo.

Se si esegue questa elaborazione complessa nella macro Inizializza, è possibile archiviare ognuna delle richieste di calcolo in una struttura di dati in VBA, ad esempio una matrice di varianti. Nella macro Partizione è quindi possibile restituire semplicemente la voce successiva nella matrice. Ciò consentirà di garantire che la macro Partition sia il più veloce possibile.

Analogamente, se è necessario eseguire una post-elaborazione molto complessa sui risultati in arrivo, potrebbe essere consigliabile archiviare i risultati in una struttura di dati nella macro Merge e quindi elaborare i risultati nella macro Finalize dopo il completamento del calcolo.

Ad esempio, se si archiviano i risultati in un database, ma ogni scrittura di database richiede un'istruzione insert complessa, potrebbe essere preferibile spostare questa elaborazione nella macro Finalize. È possibile creare una struttura di dati, ad esempio una matrice di varianti, e nella macro Merge, è sufficiente inserire ogni risultato nella matrice. Nella macro Finalize è quindi possibile scorrere la matrice ed eseguire tutte le operazioni di scrittura del database necessarie contemporaneamente.

Note finali

La conversione di una cartella di lavoro esistente per l'uso di HPC Services per Excel è più di un'arte, quindi una scienza. I dettagli specifici, ovvero il codice da spostare e dove spostarlo, dipenderanno sempre dalla cartella di lavoro specifica.

È tuttavia necessario comprendere i concetti coinvolti e comprendere il motivo per cui viene usato il framework di macro asincrona. Per convertire qualsiasi cartella di lavoro per l'uso di HPC Services per Excel, è necessario creare un calcolo parallelo essenzialmente nello stesso modo: aggiungere le funzioni del framework macro alla cartella di lavoro e compilare il codice appropriato.

È possibile usare i file di macro "skeleton" inclusi in questo articolo nelle proprie cartelle di lavoro. Seguire i passaggi usati negli esempi precedenti per identificare il codice iterativo nella cartella di lavoro e spostarlo nelle macro appropriate. Ricordarsi di testare il calcolo sul desktop per identificare eventuali errori prima di eseguire calcoli nel cluster.

È anche consigliabile avere un'idea dei vantaggi delle prestazioni che è possibile ottenere dall'esecuzione di cartelle di lavoro di Excel in un cluster HPC con HPC Services per Excel. In questo articolo è stata avviata una cartella di lavoro già ragionevolmente veloce, per calcolare l'intera cartella di lavoro sono richiesti solo 1-2 minuti sul desktop. Ma anche la cartella di lavoro può essere eseguita due volte più velocemente, quattro volte più veloce o più veloce in un cluster HPC. Le prestazioni effettive dipendono dal numero di nodi di calcolo disponibili nel cluster ed è sempre possibile migliorare le prestazioni aggiungendo più nodi di calcolo al cluster.

Con una quantità relativamente ridotta di lavoro, è possibile convertire molte cartelle di lavoro di Excel a esecuzione prolungata per l'esecuzione in un cluster Microsoft HPC con HPC Services per Excel. E per le cartelle di lavoro a esecuzione prolungata, ovvero cartelle di lavoro che richiedono ore o persino giorni per calcolare, l'uso di HPC Services per Excel può comportare un notevole miglioramento delle prestazioni.