Eseguire OpenFOAM con Microsoft HPC Pack in un cluster Linux RDMA su Azure

Importante

Le VM classiche verranno ritirate il 1° marzo 2023.

Se si usano risorse IaaS di ASM, completare la migrazione entro il 1° marzo 2023. Ti invitiamo a effettuare il passaggio prima per sfruttare i numerosi miglioramenti delle funzionalità in Azure Resource Manager.

Per altre informazioni, vedere Eseguire la migrazione delle risorse IaaS ad Azure Resource Manager entro il 1° marzo 2023.

Questo articolo illustra un modo per eseguire OpenFoam nelle macchine virtuali di Azure. In questo caso si distribuisce un cluster Microsoft HPC Pack con nodi di calcolo Linux in Azure ed si esegue un processo OpenFoam con Intel MPI. È possibile usare macchine virtuali di Azure con supporto per RDMA per i nodi di calcolo, in modo che i nodi di calcolo comunichino tramite la rete RDMA di Azure. Altre opzioni per eseguire OpenFoam in Azure includono immagini commerciali completamente configurate disponibili nel Marketplace, ad esempio OpenFoam 2.3 di UberCloud in CentOS 6 e in esecuzione in Azure Batch.

Nota

Azure include due diversi modelli di distribuzione per la creazione e l'uso delle risorse: Resource Manager eclassica. Questo articolo illustra l'uso di entrambi i modelli, ma Microsoft consiglia che la maggior parte delle nuove distribuzioni usi il modello di Resource Manager.

OpenFOAM (per Open Field Operation and Manipulation) è un pacchetto software di fluidodinamica computazionale open source (CFD) usato ampiamente in ingegneria e scienza, sia nelle organizzazioni commerciali che accademiche. Include strumenti per il meshing, in particolare snappyHexMesh, un mesher parallelizzato per geometrie CAD complesse, e strumenti per la pre-elaborazione e la post-elaborazione. Quasi tutti i processi vengono eseguiti in parallelo, consentendo agli utenti di sfruttare appieno l'hardware del computer a loro disposizione.

Microsoft HPC Pack offre funzionalità per eseguire applicazioni HPC e parallele su larga scala, incluse le applicazioni MPI, nei cluster di macchine virtuali di Microsoft Azure. HPC Pack supporta anche l'esecuzione di applicazioni HPC Linux in macchine virtuali del nodo di calcolo Linux distribuite in un cluster HPC Pack. Per un'introduzione all'uso dei nodi di calcolo Linux con HPC Pack, vedere Get started with Linux compute nodes in an HPC Pack cluster in Azure.

Nota

Questo articolo illustra come eseguire un carico di lavoro MPI Linux con HPC Pack. Si presuppone che si abbia familiarità con l'amministrazione del sistema Linux e con l'esecuzione di carichi di lavoro MPI in cluster Linux. Se si usano versioni di MPI e OpenFOAM diverse da quelle illustrate in questo articolo, potrebbe essere necessario modificare alcuni passaggi di installazione e configurazione.

Prerequisiti

• Cluster HPC Pack con nodi di calcolo Linux con supporto per RDMA : distribuire un cluster HPC Pack con dimensioni A8, A9, H16r o nodi di calcolo Linux H16rm usando un modello di Azure Resource Manager o uno script di Azure PowerShell. Vedere Introduzione ai nodi di calcolo Linux in un cluster HPC Pack in Azure per i prerequisiti e i passaggi per entrambe le opzioni. Se si sceglie l'opzione di distribuzione script di PowerShell, vedere il file di configurazione di esempio nei file di esempio alla fine di questo articolo. Usare questa configurazione per distribuire un cluster HPC Pack basato su Azure costituito da un nodo principale di dimensione A8 con Windows Server 2012 R2 e da 2 nodi di calcolo di dimensione A8 con SUSE Linux Enterprise Server 12. Sostituire i valori appropriati per la sottoscrizione e i nomi dei servizi.

  Altre informazioni da conoscere

  • Per i prerequisiti di rete RDMA linux in Azure, vedere Dimensioni elevate delle macchine virtuali di calcolo a prestazioni elevate.
  • Se si usa l'opzione di distribuzione script di PowerShell, distribuire tutti i nodi di calcolo Linux all'interno di un servizio cloud per usare la connessione di rete RDMA.
  • Dopo aver distribuito i nodi Linux, connettersi tramite SSH per eseguire eventuali attività amministrative aggiuntive. Trovare i dettagli della connessione SSH per ogni macchina virtuale Linux nel portale di Azure.

• Intel MPI : per eseguire OpenFOAM nei nodi di calcolo HPC SLES 12 in Azure, è necessario installare il runtime intel MPI Library 5 dal sito Intel.com. Intel MPI 5 è preinstallato nelle immagini HPC basate su CentOS. In un passaggio successivo, se necessario, installare Intel MPI nei nodi di calcolo Linux. Per prepararsi a questo passaggio, dopo la registrazione con Intel, seguire il collegamento nel messaggio di posta elettronica di conferma alla pagina Web correlata. Copiare quindi il collegamento di download per il file con estensione tgz per la versione appropriata di Intel MPI. Questo articolo si basa su Intel MPI versione 5.0.3.048.

• OpenFOAM Source Pack : scaricare il software OpenFOAM Source Pack per Linux dal sito OpenFOAM Foundation. Questo articolo si basa su Source Pack versione 2.3.1, disponibile per il download come OpenFOAM-2.3.1.tgz. Seguire le istruzioni riportate più avanti in questo articolo per decomprimere e compilare OpenFOAM nei nodi di calcolo Linux.

• EnSight (facoltativo): per visualizzare i risultati della simulazione OpenFOAM, scaricare e installare il programma di visualizzazione e analisi di EnSight . Le informazioni sulle licenze e sul download sono disponibili nel sito EnSight.

Configurare l'attendibilità reciproca tra i nodi di calcolo

L'esecuzione di un processo tra nodi in più nodi Linux richiede che i nodi si considerino attendibili tra loro (rsh o ssh). Quando si crea il cluster HPC Pack con lo script di distribuzione IaaS di Microsoft HPC Pack, lo script configura automaticamente l'attendibilità reciproca permanente per l'account amministratore specificato. Per gli utenti non amministratori che vengono creati nel dominio del cluster, è necessario configurare una fiducia reciproca temporanea tra i nodi quando viene ad essi assegnato un compito, e annullare il rapporto dopo il completamento del compito. Per stabilire un trust per ogni utente, fornire una coppia di chiavi RSA al cluster usato da HPC Pack per la relazione di trust.

Generare una coppia di chiavi RSA

È facile generare una coppia di chiavi RSA, che contiene una chiave pubblica e una chiave privata, eseguendo il comando linux ssh-keygen.

1. Accedere a un computer Linux.

2. Eseguire il comando seguente:

   ssh-keygen -t rsa
   

   Nota

   Premere INVIO per usare le impostazioni predefinite fino al completamento del comando. Non immettere una passphrase qui; quando viene richiesta una password, è sufficiente premere INVIO.

   

3. Cambia directory alla ~/.ssh. La chiave privata viene archiviata in id_rsa e la chiave pubblica in id_rsa.pub.

   

Aggiungere la coppia di chiavi al cluster HPC Pack

1. Stabilire una connessione Desktop remoto al nodo head con l'account amministratore di HPC Pack (l'account amministratore configurato durante l'esecuzione dello script di distribuzione).

2. Usare le procedure standard di Windows Server per creare un account utente di dominio nel dominio di Active Directory del cluster. Ad esempio, usare lo strumento Utenti e computer di Active Directory nel nodo principale. Gli esempi in questo articolo presuppongono che si crei un utente di dominio denominato hpclab\hpcuser.

3. Creare un file denominato C:\cred.xml e copiarvi i dati della chiave RSA. Un file di esempio cred.xml è alla fine di questo articolo.

   <ExtendedData>
     <PrivateKey>Copy the contents of private key here</PrivateKey>
     <PublicKey>Copy the contents of public key here</PublicKey>
   </ExtendedData>
   

4. Aprire un prompt dei comandi e immettere il comando seguente per impostare i dati delle credenziali per l'account hpclab\hpcuser. Usare il parametro extendeddata per passare il nome del file di C:\cred.xml creato per i dati della chiave.

   hpccred setcreds /extendeddata:c:\cred.xml /user:hpclab\hpcuser /password:<UserPassword>
   

   Questo comando si completa correttamente senza output. Dopo aver impostato le credenziali per gli account utente necessari per eseguire i processi, archiviare il file cred.xml in un percorso sicuro o eliminarlo.

5. Se è stata generata la coppia di chiavi RSA in uno dei nodi Linux, ricordarsi di eliminare le chiavi al termine dell'uso. Se HPC Pack trova un file id_rsa esistente o id_rsa.pub, non configura l'attendibilità reciproca.

Importante

Non è consigliabile eseguire un processo Linux come amministratore del cluster in un cluster condiviso, perché un processo inviato da un amministratore viene eseguito con l'account radice nei nodi Linux. Tuttavia, un processo inviato da un utente non amministratore viene eseguito con un account utente Linux locale con lo stesso nome dell'utente del processo. In questo caso, HPC Pack configura l'attendibilità reciproca per l'utente Linux tra i nodi allocati al lavoro. È possibile configurare manualmente l'utente Linux nei nodi Linux prima di eseguire il processo oppure HPC Pack crea automaticamente l'utente quando viene inviato il processo. Se HPC Pack crea l'utente, HPC Pack lo elimina al termine del processo. Per ridurre le minacce alla sicurezza, HPC Pack rimuove le chiavi dopo il completamento del processo.

Configurare una condivisione file per i nodi Linux

Configurare ora una condivisione SMB standard in una cartella nel nodo head. Per consentire ai nodi Linux di accedere ai file dell'applicazione con un percorso comune, montare la cartella condivisa nei nodi Linux. Se si vuole, è possibile usare un'altra opzione di condivisione file, ad esempio una condivisione file di Azure, consigliata per molti scenari, o una condivisione NFS. Vedere le informazioni sulla condivisione dei file e i passaggi dettagliati in Introduzione ai nodi di calcolo Linux in un cluster HPC Pack in Azure.

1. Creare una cartella nel nodo head e condividerla con Tutti impostando privilegi di lettura/scrittura. Ad esempio, condividere C:\OpenFOAM nel nodo head come \\SUSE12RDMA-HN\OpenFOAM. In questo caso , SUSE12RDMA-HN è il nome host del nodo head.

2. Aprire una finestra di Windows PowerShell ed eseguire i comandi seguenti:

   clusrun /nodegroup:LinuxNodes mkdir -p /openfoam
   
   clusrun /nodegroup:LinuxNodes mount -t cifs //SUSE12RDMA-HN/OpenFOAM /openfoam -o vers=2.1`,username=<username>`,password='<password>'`,dir_mode=0777`,file_mode=0777
   

Il primo comando crea una cartella denominata /openfoam in tutti i nodi del gruppo LinuxNodes. Il secondo comando monta la cartella condivisa //SUSE12RDMA-HN/OpenFOAM nei nodi Linux con dir_mode e file_mode bit impostati su 777. Il nome utente e la password nel comando devono essere le credenziali di un utente nel nodo head.

Nota

Il simbolo "'" nel secondo comando è un simbolo di escape per PowerShell. "'," indica che "," (carattere virgola) fa parte del comando.

Installare MPI e OpenFOAM

Per eseguire OpenFOAM come processo MPI nella rete RDMA, è necessario compilare OpenFOAM con le librerie Intel MPI.

Eseguire prima di tutto diversi comandi clusrun per installare le librerie Intel MPI (se non è già installato) e OpenFOAM nei nodi Linux. Usare la condivisione nodo head configurata in precedenza per condividere i file di installazione tra i nodi Linux.

Importante

Questi passaggi di installazione e compilazione sono esempi. È necessaria una certa conoscenza dell'amministrazione del sistema Linux per assicurarsi che i compilatori e le librerie dipendenti siano installati correttamente. Potrebbe essere necessario modificare determinate variabili di ambiente o altre impostazioni per le versioni di Intel MPI e OpenFOAM. Per informazioni dettagliate, vedere Intel MPI Library for Linux Installation Guide and OpenFOAM Source Pack Installation for your environment ( Guida all'installazione di Intel MPI Library for Linux ) e OpenFOAM Source Pack Installation for your environment (Installazione di OpenFOAM Source Pack per l'ambiente in uso).

Installare Intel MPI

Salvare il pacchetto di installazione scaricato per Intel MPI (l_mpi_p_5.0.3.048.tgz in questo esempio) in C:\OpenFoam nel nodo head in modo che i nodi Linux possano accedere a questo file da /openfoam. Quindi, eseguire clusrun per installare la libreria Intel MPI in tutti i nodi Linux.

1. I comandi seguenti, copiano il pacchetto di installazione e lo estraggono in /opt/intel per ciascun nodo.

   clusrun /nodegroup:LinuxNodes mkdir -p /opt/intel
   
   clusrun /nodegroup:LinuxNodes cp /openfoam/l_mpi_p_5.0.3.048.tgz /opt/intel/
   
   clusrun /nodegroup:LinuxNodes tar -xzf /opt/intel/l_mpi_p_5.0.3.048.tgz -C /opt/intel/
   

2. Per installare la libreria Intel MPI automaticamente, usare un file silent.cfg. È possibile trovare un esempio nei file di esempio alla fine di questo articolo. Posizionare il file nella cartella condivisa /openfoam. Per informazioni dettagliate sul file silent.cfg, vedere Guida all'installazione automatica della libreria Intel MPI per Linux.

   Suggerimento

   Assicurati di salvare il file silent.cfg come file di testo con interruzioni di riga in formato Linux (solo LF, non CR LF). Questo passaggio garantisce che venga eseguito correttamente nei nodi Linux.

3. Installare Intel MPI Library in modalità invisibile all'utente.

   clusrun /nodegroup:LinuxNodes bash /opt/intel/l_mpi_p_5.0.3.048/install.sh --silent /openfoam/silent.cfg
   

Configurare MPI

Per i test, è necessario aggiungere le righe seguenti a /etc/security/limits.conf in ognuno dei nodi Linux:

clusrun /nodegroup:LinuxNodes echo "*               hard    memlock         unlimited" `>`> /etc/security/limits.conf
clusrun /nodegroup:LinuxNodes echo "*               soft    memlock         unlimited" `>`> /etc/security/limits.conf

Riavviare i nodi Linux dopo aver aggiornato il file limits.conf. Ad esempio, usare il comando clusrun seguente:

clusrun /nodegroup:LinuxNodes systemctl reboot

Dopo il riavvio, assicurarsi che la cartella condivisa sia montata come /openfoam.

Compilare e installare OpenFOAM

Salvare il pacchetto di installazione scaricato per OpenFOAM Source Pack (OpenFOAM-2.3.1.tgz in questo esempio) in C:\OpenFoam nel nodo head in modo che i nodi Linux possano accedere a questo file da /openfoam. Eseguire quindi i comandi clusrun per compilare OpenFOAM in tutti i nodi Linux.

1. Creare una cartella /opt/OpenFOAM in ogni nodo Linux, copiare il pacchetto di origine in questa cartella ed estrarlo.

   clusrun /nodegroup:LinuxNodes mkdir -p /opt/OpenFOAM
   
   clusrun /nodegroup:LinuxNodes cp /openfoam/OpenFOAM-2.3.1.tgz /opt/OpenFOAM/
   
   clusrun /nodegroup:LinuxNodes tar -xzf /opt/OpenFOAM/OpenFOAM-2.3.1.tgz -C /opt/OpenFOAM/
   

2. Per compilare OpenFOAM con la libreria Intel MPI, configurare prima alcune variabili di ambiente per Intel MPI e OpenFOAM. Usare uno script bash denominato settings.sh per impostare le variabili. È possibile trovare un esempio nei file di esempio alla fine di questo articolo. Inserisci il file (salvato con terminazioni di riga Linux) nella cartella condivisa /openfoam. Questo file contiene anche le impostazioni per i runtime MPI e OpenFOAM usati in un secondo momento per eseguire un processo OpenFOAM.

3. Installare i pacchetti dipendenti necessari per compilare OpenFOAM. A seconda della distribuzione linux, potrebbe essere necessario prima aggiungere un repository. Eseguire comandi clusrun simili ai seguenti:

   clusrun /nodegroup:LinuxNodes zypper ar http://download.opensuse.org/distribution/13.2/repo/oss/suse/ opensuse
   
   clusrun /nodegroup:LinuxNodes zypper -n --gpg-auto-import-keys install --repo opensuse --force-resolution -t pattern devel_C_C++
   

   Se necessario, connettersi tramite SSH a ogni nodo Linux per eseguire i comandi per verificare che vengano eseguiti correttamente.

4. Eseguire il comando seguente per compilare OpenFOAM. Il processo di compilazione richiede del tempo e genera una grande quantità di informazioni di log nell'output standard, quindi usare l'opzione /interleaved per visualizzare l'output interleaved.

   clusrun /nodegroup:LinuxNodes /interleaved source /openfoam/settings.sh `&`& /opt/OpenFOAM/OpenFOAM-2.3.1/Allwmake
   

   Nota

   Il simbolo "'" nel comando è un simbolo di escape per PowerShell. "'&" indica che "&" fa parte del comando.

Preparare l'esecuzione di un processo OpenFOAM

È ora possibile eseguire un processo MPI denominato sloshingTank3D, uno degli esempi OpenFoam, in due nodi Linux.

Configurare l'ambiente di runtime

Per configurare gli ambienti di runtime per MPI e OpenFOAM nei nodi Linux, eseguire il comando seguente in una finestra di Windows PowerShell nel nodo head. Questo comando è valido solo per SUSE Linux.

clusrun /nodegroup:LinuxNodes cp /openfoam/settings.sh /etc/profile.d/

Preparare i dati di esempio

Utilizzare la condivisione del nodo principale configurata in precedenza per condividere i file tra i nodi Linux (montati come /openfoam).

1. Connettersi tramite SSH a uno dei nodi di calcolo Linux.

2. Eseguire il comando seguente per configurare l'ambiente di runtime OpenFOAM, se non è già stato fatto.

   $ source /openfoam/settings.sh
   

3. Copiare l'esempio sloshingTank3D nella cartella condivisa e spostarsi in essa.

   $ cp -r $FOAM_TUTORIALS/multiphase/interDyMFoam/ras/sloshingTank3D /openfoam/
   
   $ cd /openfoam/sloshingTank3D
   

4. Quando si usano i parametri predefiniti di questo esempio, l'esecuzione può richiedere decine di minuti, quindi potrebbe essere necessario modificare alcuni parametri per velocizzare l'esecuzione. Una semplice scelta consiste nel modificare le variabili del passaggio temporale deltaT e writeInterval nel file system/controlDict. Questo file archivia tutti i dati di input relativi al controllo del tempo e alla lettura e scrittura dei dati della soluzione. Ad esempio, è possibile modificare il valore di deltaT da 0,05 a 0,5 e il valore di writeInterval da 0,05 a 0,5.

   

5. Specificare i valori desiderati per le variabili nel file system/decomposeParDict. Questo esempio usa due nodi Linux ognuno con 8 core, quindi impostare numberOfSubdomains su 16 e n di gerarchiciCoeffs su (1 1 16), ovvero eseguire OpenFOAM in parallelo con 16 processi. Per ulteriori informazioni, vedere Guida per l'utente di OpenFOAM: 3.4 Esecuzione di applicazioni in parallelo.

   

6. Eseguire i comandi seguenti dalla directory sloshingTank3D per preparare i dati di esempio.

   $ . $WM_PROJECT_DIR/bin/tools/RunFunctions
   
   $ m4 constant/polyMesh/blockMeshDict.m4 > constant/polyMesh/blockMeshDict
   
   $ runApplication blockMesh
   
   $ cp 0/alpha.water.org 0/alpha.water
   
   $ runApplication setFields  
   

7. Nel nodo head dovrebbero essere visualizzati i file di dati di esempio copiati in C:\OpenFoam\sloshingTank3D. C:\OpenFoam è la cartella condivisa nel nodo head.

   

File degli host per mpirun

In questo passaggio viene creato un file host (un elenco di nodi di calcolo) usato dal comando mpirun .

1. In uno dei nodi Linux creare un file denominato hostfile in /openfoam, in modo che questo file possa essere raggiunto in /openfoam/hostfile in tutti i nodi Linux.

2. Scrivere i nomi dei nodi Linux in questo file. In questo esempio il file contiene i nomi seguenti:

   SUSE12RDMA-LN1
   SUSE12RDMA-LN2
   

   Suggerimento

   È anche possibile creare questo file in C:\OpenFoam\hostfile nel nodo head. Se si sceglie questa opzione, salvarla come file di testo con terminazioni di riga Linux (solo LF, non CR LF). In questo modo si garantisce che venga eseguito correttamente nei nodi Linux.

   Wrapper di script Bash

   Se si hanno molti nodi Linux e si vuole che il processo venga eseguito solo su alcuni di essi, non è consigliabile usare un file host fisso, perché non si sa quali nodi verranno allocati al processo. In questo caso, scrivere un wrapper di script bash per mpirun per creare automaticamente il file host. È possibile trovare un wrapper di script bash di esempio denominato hpcimpirun.sh alla fine di questo articolo e salvarlo come /openfoam/hpcimpirun.sh. Questo script di esempio esegue le operazioni seguenti:

   1. Configura le variabili di ambiente per mpirun e alcuni parametri di comando aggiuntivi per eseguire il processo MPI tramite la rete RDMA. In questo caso, imposta le variabili seguenti:

      • I_MPI_FABRICS=shm:dapl
      • I_MPI_DAPL_PROVIDER=ofa-v2-ib0
      • I_MPI_DYNAMIC_CONNECTION=0

   2. Crea un file host in base alla variabile di ambiente $CCP_NODES_CORES, impostata dal nodo head HPC quando il processo viene attivato.

      Il formato di $CCP_NODES_CORES segue questo modello:

      <Number of nodes> <Name of node1> <Cores of node1> <Name of node2> <Cores of node2>...`
      

      dove

      • <Number of nodes> - numero di nodi allocati a questo lavoro.
      • <Name of node_n_...> - il nome di ogni nodo allocato a questa attività.
      • <Cores of node_n_...> : numero di core nel nodo allocato a questo processo.

      Ad esempio, se il processo richiede l'esecuzione di due nodi, $CCP_NODES_CORES è simile a

      2 SUSE12RDMA-LN1 8 SUSE12RDMA-LN2 8
      

   3. Chiama il comando mpirun e aggiunge due parametri alla riga di comando.

      • --hostfile <hostfilepath>: <hostfilepath> - percorso del file host creato dallo script
      • -np ${CCP_NUMCPUS}: ${CCP_NUMCPUS} : variabile di ambiente impostata dal nodo head HPC Pack, che archivia il numero di core totali allocati a questo processo. In questo caso, specifica il numero di processi per mpirun.

Invia un compito OpenFOAM

È ora possibile inviare un lavoro in HPC Cluster Manager. È necessario passare lo script hpcimpirun.sh nella riga di comando per alcuni compiti di lavoro.

1. Connettersi al nodo principale del cluster e avviare il Gestore del Cluster HPC.

2. In Gestione risorse assicurarsi che i nodi di calcolo Linux si trovino nello stato Online . Se non lo sono, selezionali e fai clic su Bring Online.

3. In Gestione lavori, fare clic su Nuovo lavoro.

4. Immettere un nome per l'attività, ad esempio sloshingTank3D.

   

5. In Risorse di processo, scegliere il tipo di risorsa "Nodo" e impostare il minimo a 2. Questa configurazione esegue il processo in due nodi Linux, ognuno dei quali ha otto core in questo esempio.

   

6. Fare clic su Modifica attività nella barra laterale sinistra e quindi fare clic su Aggiungi per aggiungere un'attività al lavoro. Aggiungi quattro attività all'attività di lavoro con le righe di comando e le impostazioni seguenti.

   Nota

   L'esecuzione source /openfoam/settings.sh configura gli ambienti di runtime OpenFOAM e MPI, quindi ognuna delle attività seguenti la chiama prima del comando OpenFOAM.

   • Attività 1. Eseguire decomposePar per generare file di dati per l'esecuzione in parallelo di interDyMFoam .

     • Assegnare un nodo all'attività
     • Riga di comando - source /openfoam/settings.sh && decomposePar -force > /openfoam/decomposePar${CCP_JOBID}.log
     • Directory di lavoro - /openfoam/sloshingTank3D

     Vedere la figura seguente. Le attività rimanenti vengono configurate in modo analogo.

     

   • Attività 2. Eseguire interDyMFoam in parallelo per calcolare l'esempio.

     • Assegna due nodi all'attività
     • Riga di comando - source /openfoam/settings.sh && /openfoam/hpcimpirun.sh interDyMFoam -parallel > /openfoam/interDyMFoam${CCP_JOBID}.log
     • Directory di lavoro - /openfoam/sloshingTank3D

   • Attività 3. Eseguire reconstructPar per unire gli insiemi di directory temporali da ogni directory processor_N_ in un unico insieme.

     • Assegnare un nodo all'attività
     • Riga di comando - source /openfoam/settings.sh && reconstructPar > /openfoam/reconstructPar${CCP_JOBID}.log
     • Directory di lavoro - /openfoam/sloshingTank3D

   • Attività 4. Eseguire foamToEnsight in parallelo per convertire i file di risultato OpenFOAM in formato EnSight e inserire i file EnSight in una directory denominata Ensight nella directory del case.

     • Assegnare due nodi all'attività
     • Riga di comando - source /openfoam/settings.sh && /openfoam/hpcimpirun.sh foamToEnsight -parallel > /openfoam/foamToEnsight${CCP_JOBID}.log
     • Directory di lavoro - /openfoam/sloshingTank3D

7. Aggiungere dipendenze a queste attività in ordine crescente delle attività.

   

8. Fare clic su Invia per eseguire questo processo.

   Per impostazione predefinita, HPC Pack invia l'attività utilizzando l'account utente attualmente connesso. Dopo aver fatto clic su Invia, potrebbe essere visualizzata una finestra di dialogo che richiede di immettere il nome utente e la password.

   

   In alcune condizioni, HPC Pack memorizza le informazioni dell'utente immesse in precedenza e non visualizza questa finestra di dialogo. Per fare in modo che il pacchetto HPC venga visualizzato di nuovo, immettere il seguente comando nel prompt dei comandi e quindi inviare il lavoro.

   hpccred delcreds
   

9. Il processo richiede da decine di minuti a diverse ore in base ai parametri impostati per l'esempio. Nella mappa termica viene visualizzato il processo in esecuzione nei nodi Linux.

   

   In ogni nodo vengono avviati otto processi.

   

10. Al termine del processo, trovare i risultati del processo nelle cartelle in C:\OpenFoam\sloshingTank3D e i file di log in C:\OpenFoam.

Visualizzare i risultati in EnSight

Facoltativamente, usare EnSight per visualizzare e analizzare i risultati del processo OpenFOAM.

1. Dopo aver installato EnSight nel nodo head, avviarlo.

2. Aprire C:\OpenFoam\sloshingTank3D\EnSight\sloshingTank3D.case.

   Si vede un serbatoio nel visualizzatore.

   

3. Creare un isosurface da internalMesh e quindi scegliere la variabile alpha_water.

   

4. Impostare il colore per Isosurface_part creato nel passaggio precedente. Ad esempio, impostarla su blu acqua.

   

5. Creare un Iso-volume dalle pareti selezionando pareti nel pannello Parti e facendo clic sul pulsante Isosurfaces sulla barra degli strumenti.

6. Nella finestra di dialogo selezionare Tipo come Isovolume e impostare l'intervallo Min of Isovolume su 0,5. Per creare l'isovolume, fare clic su Crea con le parti selezionate.

7. Impostare il colore per Iso_volume_part creato nel passaggio precedente. Ad esempio, impostarlo su blu acqua profonda.

8. Impostare il colore per le pareti. Ad esempio, impostarla su bianco trasparente.

9. Fare clic su Riproduci per visualizzare i risultati della simulazione.

   

File di esempio

File di configurazione XML di esempio per la distribuzione del cluster tramite script di PowerShell

<?xml version="1.0" encoding="utf-8" ?>
<IaaSClusterConfig>
 <Subscription>
   <SubscriptionName>Subscription-1</SubscriptionName>
   <StorageAccount>allvhdsje</StorageAccount>
 </Subscription>
 <Location>Japan East</Location>  
 <VNet>
   <VNetName>suse12rdmavnet</VNetName>
   <SubnetName>SUSE12RDMACluster</SubnetName>
 </VNet>
 <Domain>
   <DCOption>HeadNodeAsDC</DCOption>
   <DomainFQDN>hpclab.local</DomainFQDN>
 </Domain>
 <Database>
   <DBOption>LocalDB</DBOption>
 </Database>
 <HeadNode>
   <VMName>SUSE12RDMA-HN</VMName>
   <ServiceName>suse12rdma-je</ServiceName>
   <VMSize>A8</VMSize>
   <EnableRESTAPI />
   <EnableWebPortal />
 </HeadNode>
 <LinuxComputeNodes>
   <VMNamePattern>SUSE12RDMA-LN%1%</VMNamePattern>
   <ServiceName>suse12rdma-je</ServiceName>
   <VMSize>A8</VMSize>
   <NodeCount>2</NodeCount>
     <ImageName>b4590d9e3ed742e4a1d46e5424aa335e__suse-sles-12-hpc-v20150708</ImageName>
 </LinuxComputeNodes>
</IaaSClusterConfig>

File cred.xml di esempio

<ExtendedData>
  <PrivateKey>-----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEAxJKBABhnOsE9eneGHvsjdoXKooHUxpTHI1JVunAJkVmFy8JC
qFt1pV98QCtKEHTC6kQ7tj1UT2N6nx1EY9BBHpZacnXmknpKdX4Nu0cNlSphLpru
lscKPR3XVzkTwEF00OMiNJVknq8qXJF1T3lYx3rW5EnItn6C3nQm3gQPXP0ckYCF
Jdtu/6SSgzV9kaapctLGPNp1Vjf9KeDQMrJXsQNHxnQcfiICp21NiUCiXosDqJrR
AfzePdl0XwsNngouy8t0fPlNSngZvsx+kPGh/AKakKIYS0cO9W3FmdYNW8Xehzkc
VzrtJhU8x21hXGfSC7V0ZeD7dMeTL3tQCVxCmwIDAQABAoIBAQCve8Jh3Wc6koxZ
qh43xicwhdwSGyliZisoozYZDC/ebDb/Ydq0BYIPMiDwADVMX5AqJuPPmwyLGtm6
9hu5p46aycrQ5+QA299g6DlF+PZtNbowKuvX+rRvPxagrTmupkCswjglDUEYUHPW
05wQaNoSqtzwS9Y85M/b24FfLeyxK0n8zjKFErJaHdhVxI6cxw7RdVlSmM9UHmah
wTkW8HkblbOArilAHi6SlRTNZG4gTGeDzPb7fYZo3hzJyLbcaNfJscUuqnAJ+6pT
iY6NNp1E8PQgjvHe21yv3DRoVRM4egqQvNZgUbYAMUgr30T1UoxnUXwk2vqJMfg2
Nzw0ESGRAoGBAPkfXjjGfc4HryqPkdx0kjXs0bXC3js2g4IXItK9YUFeZzf+476y
OTMQg/8DUbqd5rLv7PITIAqpGs39pkfnyohPjOe2zZzeoyaXurYIPV98hhH880uH
ZUhOxJYnlqHGxGT7p2PmmnAlmY4TSJrp12VnuiQVVVsXWOGPqHx4S4f9AoGBAMn/
vuea7hsCgwIE25MJJ55FYCJodLkioQy6aGP4NgB89Azzg527WsQ6H5xhgVMKHWyu
Q1snp+q8LyzD0i1veEvWb8EYifsMyTIPXOUTwZgzaTTCeJNHdc4gw1U22vd7OBYy
nZCU7Tn8Pe6eIMNztnVduiv+2QHuiNPgN7M73/x3AoGBAOL0IcmFgy0EsR8MBq0Z
ge4gnniBXCYDptEINNBaeVStJUnNKzwab6PGwwm6w2VI3thbXbi3lbRAlMve7fKK
B2ghWNPsJOtppKbPCek2Hnt0HUwb7qX7Zlj2cX/99uvRAjChVsDbYA0VJAxcIwQG
TxXx5pFi4g0HexCa6LrkeKMdAoGAcvRIACX7OwPC6nM5QgQDt95jRzGKu5EpdcTf
g4TNtplliblLPYhRrzokoyoaHteyxxak3ktDFCLj9eW6xoCZRQ9Tqd/9JhGwrfxw
MS19DtCzHoNNewM/135tqyD8m7pTwM4tPQqDtmwGErWKj7BaNZARUlhFxwOoemsv
R6DbZyECgYEAhjL2N3Pc+WW+8x2bbIBN3rJcMjBBIivB62AwgYZnA2D5wk5o0DKD
eesGSKS5l22ZMXJNShgzPKmv3HpH22CSVpO0sNZ6R+iG8a3oq4QkU61MT1CfGoMI
a8lxTKnZCsRXU1HexqZs+DSc+30tz50bNqLdido/l5B4EJnQP03ciO0=
-----END RSA PRIVATE KEY-----</PrivateKey>
  <PublicKey>ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDEkoEAGGc6wT16d4Ye+yN2hcqigdTGlMcjUlW6cAmRWYXLwkKoW3WlX3xAK0oQdMLqRDu2PVRPY3qfHURj0EEellpydeaSekp1fg27Rw2VKmEumu6Wxwo9HddXORPAQXTQ4yI0lWSerypckXVPeVjHetbkSci2foLedCbeBA9c/RyRgIUl227/pJKDNX2Rpqly0sY82nVWN/0p4NAyslexA0fGdBx+IgKnbU2JQKJeiwOomtEB/N492XRfCw2eCi7Ly3R8+U1KeBm+zH6Q8aH8ApqQohhLRw71bcWZ1g1bxd6HORxXOu0mFTzHbWFcZ9ILtXRl4Pt0x5Mve1AJXEKb username@servername;</PublicKey>
</ExtendedData>

File silent.cfg di esempio per installare MPI

# Patterns used to check silent configuration file
#
# anythingpat - any string
# filepat     - the file location pattern (/file/location/to/license.lic)
# lspat       - the license server address pattern (0123@hostname)
# snpat       - the serial number pattern (ABCD-01234567)

# accept EULA, valid values are: {accept, decline}
ACCEPT_EULA=accept

# optional error behavior, valid values are: {yes, no}
CONTINUE_WITH_OPTIONAL_ERROR=yes

# install location, valid values are: {/opt/intel, filepat}
PSET_INSTALL_DIR=/opt/intel

# continue with overwrite of existing installation directory, valid values are: {yes, no}
CONTINUE_WITH_INSTALLDIR_OVERWRITE=yes

# list of components to install, valid values are: {ALL, DEFAULTS, anythingpat}
COMPONENTS=DEFAULTS

# installation mode, valid values are: {install, modify, repair, uninstall}
PSET_MODE=install

# directory for non-RPM database, valid values are: {filepat}
#NONRPM_DB_DIR=filepat

# Serial number, valid values are: {snpat}
#ACTIVATION_SERIAL_NUMBER=snpat

# License file or license server, valid values are: {lspat, filepat}
#ACTIVATION_LICENSE_FILE=

# Activation type, valid values are: {exist_lic, license_server, license_file, trial_lic, serial_number}
ACTIVATION_TYPE=trial_lic

# Path to the cluster description file, valid values are: {filepat}
#CLUSTER_INSTALL_MACHINES_FILE=filepat

# Intel(R) Software Improvement Program opt-in, valid values are: {yes, no}
PHONEHOME_SEND_USAGE_DATA=no

# Perform validation of digital signatures of RPM files, valid values are: {yes, no}
SIGNING_ENABLED=yes

# Select yes to enable mpi-selector integration, valid values are: {yes, no}
ENVIRONMENT_REG_MPI_ENV=no

# Select yes to update ld.so.conf, valid values are: {yes, no}
ENVIRONMENT_LD_SO_CONF=no

Script settings.sh di esempio

#!/bin/bash

# impi
source /opt/intel/impi/5.0.3.048/bin64/mpivars.sh
export MPI_ROOT=$I_MPI_ROOT
export I_MPI_FABRICS=shm:dapl
export I_MPI_DAPL_PROVIDER=ofa-v2-ib0
export I_MPI_DYNAMIC_CONNECTION=0

# openfoam
export FOAM_INST_DIR=/opt/OpenFOAM
source /opt/OpenFOAM/OpenFOAM-2.3.1/etc/bashrc
export WM_MPLIB=INTELMPI

Script hpcimpirun.sh di esempio

#!/bin/bash

# The path of this script
SCRIPT_PATH="$( dirname "${BASH_SOURCE[0]}" )"

# Set mpirun runtime evironment
source /opt/intel/impi/5.0.3.048/bin64/mpivars.sh
export MPI_ROOT=$I_MPI_ROOT
export I_MPI_FABRICS=shm:dapl
export I_MPI_DAPL_PROVIDER=ofa-v2-ib0
export I_MPI_DYNAMIC_CONNECTION=0

# mpirun command
MPIRUN=mpirun
# Argument of "--hostfile"
NODELIST_OPT="--hostfile"
# Argument of "-np"
NUMPROCESS_OPT="-np"

# Get node information from ENVs
NODESCORES=(${CCP_NODES_CORES})
COUNT=${#NODESCORES[@]}

if [ ${COUNT} -eq 0 ]
then
    # CCP_NODES_CORES is not found or is empty, just run the mpirun without hostfile arg.
    ${MPIRUN} $*
else
    # Create the hostfile file
    NODELIST_PATH=${SCRIPT_PATH}/hostfile_$$

    # Get every node name and write into the hostfile file
    I=1
    while [ ${I} -lt ${COUNT} ]
    do
        echo "${NODESCORES[${I}]}" >> ${NODELIST_PATH}
        let "I=${I}+2"
    done

    # Run the mpirun with hostfile arg
    ${MPIRUN} ${NUMPROCESS_OPT} ${CCP_NUMCPUS} ${NODELIST_OPT} ${NODELIST_PATH} $*

    RTNSTS=$?
    rm -f ${NODELIST_PATH}
fi

exit ${RTNSTS}