Ejecución de WRF con un clúster linux de HPC Pack en Azure

2024-10-25

WRF es un software de cálculo numérico para la predicción meteorológica. Tiene una gran compatibilidad con la informática en paralelo. Cuando se compila en modo DM (Distributed-Memory Paralelismo), es esencialmente un programa MPI. En la práctica, las personas ejecutan WRF en el clúster.

En este artículo se muestra cómo ejecutar WRF con HPC Pack, incluida la creación de un clúster de Linux, la creación de WPS (módulo de preprocesamiento de datos de WRF), WRF y sus bibliotecas dependientes, así como la ejecución de trabajos WRF. Las características de administración de nodos y administración de trabajos de HPC Pack pueden ayudarle a simplificar el proceso y a aumentar la eficacia.

Prerrequisitos

Prepare los nodos de proceso de Linux. Puede implementar un nuevo clúster de Linux con la plantilla de ARM o simplemente agregar nodos de Linux en el Administrador de clústeres de un clúster existente. Tenga en cuenta que si las cargas de trabajo requieren red RDMA, debe asegurarse de que las máquinas virtuales se implementan en el mismo conjunto de escalado de máquinas virtuales o conjunto de disponibilidad, y el Compute Node Image debe ser uno con sufijo HPC, así como el Compute Node VM Size debe estar en serie H para que la máquina virtual pueda ser compatible con RDMA.
- Opción 1: Use clúster de nodo principal único para cargas de trabajo de Linux para implementar un nuevo clúster de Linux.
  
  de plantilla de ARM
- Opción2: en el Administrador de clústeres de un clúster existente, agregue una nueva plantilla de nodo iaaS y agregue un nuevo nodo con la plantilla. Tenga en cuenta que el clúster puede ser un clúster para cargas de trabajo de Windows o cargas de trabajo de Linux.
  
  de tempate de nodo de IaaS
Después de implementar los nodos, es necesario crear un grupo específico para ellos. Esto será útil en los comandos clusrun de las secciones siguientes para asegurarse de que los comandos no se ejecutarán en nodos relacionados con WRF. Aquí creamos WRFNodes para los nodos recién agregados.
Preparar entornos del sistema. Debe asegurarse de que los sistemas tienen un compilador de de gfortran, así como gcc y cpp. Los lenguajes de script csh, perl y sh también son necesarios, ya que el sistema de compilación WRF usa scripts escritos en estos lenguajes como nivel superior para la interfaz de usuario. El sitio web oficial de WRF proporciona pruebas para comprobar que los compiladores son compatibles entre sí y los lenguajes de script funcionan correctamente en el sistema.

Cree una nueva carpeta WRFModel/Tests en el directorio principal, descargue los archivos de prueba y ejecute las pruebas con clusrun.
```
clusrun /nodegroup:WRFNodes "wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/Fortran_C_tests.tar; mkdir -p ~/WRFModel/Tests; tar -xf Fortran_C_tests.tar -C ~/WRFModel/Tests;"&&clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Tests;gfortran TEST_1_fortran_only_fixed.f;./a.out;gfortran TEST_2_fortran_only_free.f90;./a.out;gcc TEST_3_c_only.c;./a.out;gcc -c -m64 TEST_4_fortran+c_c.c;gfortran -c -m64 TEST_4_fortran+c_f.f90;gfortran -m64 TEST_4_fortran+c_f.o TEST_4_fortran+c_c.o;./a.out;./TEST_csh.csh;./TEST_perl.pl;./TEST_sh.sh;"
```

Descarga y compilación de WRF

Establecimiento de variables de entorno

Antes de compilar WRF o cualquier biblioteca, es necesario establecer estas opciones del compilador makefile.

Nombre Valor

CC Gcc

CXX g++

FC gfortran

FCFLAGS -m64

F77 gfortran

FFLAGS -m64
Cree una nueva carpeta WRFModel/Build_WRF/Libraries en el directorio principal y úsela como directorio primario que contiene las ubicaciones en las que se instalarán diferentes bibliotecas. Establezca su valor como una variable de entorno DIR.

Nombre	Valor
CC	Gcc
CXX	g++
FC	gfortran
FCFLAGS	-m64
F77	gfortran
FFLAGS	-m64

Use clusrun para lograr todo lo anterior.

clusrun /nodegroup:WRFNodes "mkdir -p ~/WRFModel/Build_WRF/LIBRARIES;sed -i '$a export DIR=~/WRFModel/Build_WRF/LIBRARIES \nexport CC=gcc \nexport CXX=g++ \nexport FC=gfortran \nexport FCFLAGS=-m64 \nexport F77=gfortran \nexport FFLAGS=-m64' ~/.profile;source ~/.profile"

Descarga y compilación de MPICH

En principio, cualquier implementación del estándar MPI-2 debe funcionar con el modo de paralelismo de memoria distribuida de WRF. Sin embargo, MPICH es el sitio web oficial de wrF recomienda. Debe descargar y compilar MPICH y, a continuación, agregar la carpeta bin de MPICH a PATH.

Use clusrun para lograr todo lo anterior.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF/LIBRARIES;wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/mpich-3.0.4.tar.gz; tar xzvf mpich-3.0.4.tar.gz;cd mpich-3.0.4;./configure --prefix=`echo $(dirname $PWD)`/mpich;make;make install;sed -i '$a export PATH=$DIR/mpich/bin:$PATH' ~/.profile;source ~/.profile"

Descarga y compilación de bibliotecas

Antes de compilar WRF, hay varias bibliotecas dependientes que se deben instalar. NetCDF se usa como el elemento fundamental de los cálculos de matriz. zlib,libpng y Jasper son bibliotecas de compresión necesarias para compilar WPS con funcionalidad GRIB2.

Descargue y compile NetCDF. A continuación, agregue su carpeta bin a PATHy agregue variables de entorno NETCDF. Use clusrun para lograrlos.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF/LIBRARIES;wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/netcdf-4.1.3.tar.gz; tar zxvf netcdf-4.1.3.tar.gz;cd netcdf-4.1.3;./configure --prefix=`echo $(dirname $PWD)`/netcdf --disable-dap --disable-netcdf-4 --disable-shared;make;make install;sed -i '$a export PATH=$DIR/netcdf/bin:$PATH \nexport NETCDF=$DIR/netcdf' ~/.profile;source ~/.profile"

Descargue y compile zlib. A continuación, establezca las opciones del compilador makefile LDFLAGS y CPPFLAGS. Use clusrun para lograrlos.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF/LIBRARIES;wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/zlib-1.2.11.tar.gz; tar xzvf zlib-1.2.11.tar.gz;cd zlib-1.2.11;./configure --prefix=`echo $(dirname $PWD)`/grib2;make;make install;sed -i '$a export LDFLAGS=-L$DIR/grib2/lib \nexport CPPFLAGS=-I$DIR/grib2/include \nexport LD_LIBRARY_PATH=$DIR/grib2/lib:$LD_LIBRARY_PATH ' ~/.profile;source ~/.profile"

Descargue y compile libpng con clusrun.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF/LIBRARIES;wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/libpng-1.2.50.tar.gz; tar xzvf libpng-1.2.50.tar.gz;cd libpng-1.2.50;./configure --prefix=`echo $(dirname $PWD)`/grib2;make;make install;"

Descargue y compile Jasper. A continuación, agregue variables de entorno JASPERLIB y JASPERINC= correspondientes. Use clusrun para lograrlos.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF/LIBRARIES;wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/jasper-1.900.1.tar.gz; tar xzvf jasper-1.900.1.tar.gz;cd jasper-1.900.1;./configure --prefix=`echo $(dirname $PWD)`/grib2;make;make install;sed -i '$a export JASPERLIB=$DIR/grib2/lib \nexport JASPERINC=$DIR/grib2/include' ~/.profile;source ~/.profile"

Una vez construidas las bibliotecas, debe comprobar que las bibliotecas pueden trabajar con los compiladores que se van a usar para las compilaciones WPS y WRF. Use las pruebas proporcionadas por el sitio web de WRF.

clusrun /nodegroup:WRFNodes "wget https://www2.mmm.ucar.edu/wrf/OnLineTutorial/compile_tutorial/tar_files/Fortran_C_NETCDF_MPI_tests.tar; tar -xf Fortran_C_NETCDF_MPI_tests.tar -C ~/WRFModel/Tests;"&&clusrun /nodegroup:WRFNodes "source ~/.profile;cd ~/WRFModel/Tests;cp ~/WRFModel/Build_WRF/LIBRARIES/netcdf/include/netcdf.inc .;gfortran -c 01_fortran+c+netcdf_f.f;gcc -c 01_fortran+c+netcdf_c.c;gfortran 01_fortran+c+netcdf_f.o 01_fortran+c+netcdf_c.o -L ~/WRFModel/Build_WRF/LIBRARIES/netcdf/lib -lnetcdff -lnetcdf;./a.out;mpif90 -c 02_fortran+c+netcdf+mpi_f.f;mpicc -c 02_fortran+c+netcdf+mpi_c.c;mpif90 02_fortran+c+netcdf+mpi_f.o 02_fortran+c+netcdf+mpi_c.o -L ~/WRFModel/Build_WRF/LIBRARIES/netcdf/lib -lnetcdff -lnetcdf;mpirun ./a.out"

Descarga y compilación de WRF y WPS

En Build_WRF, clone el código fuente de WRF y WPS desde GitHub.

clusrun /nodegroup:WRFNodes "cd ~/WRFModel/Build_WRF;git clone https://github.com/wrf-model/WRF;git clone https://github.com/wrf-model/WPS"

Compile WRF. Antes de compilar, debe configurar los compiladores usados y la forma en que desea compilar WRF. Dado que crearemos WRF en modo DM, elija opción 34 (compilador gfortran con gcc(dmpar)) y la opción de anidamiento debe ser "básica".

WRF adopta el modo interactivo en la configuración, por lo que inicia sesión en el nodo a través de SSH (Cluster Manager -> Resource Management -> Node Actions -> Remote Desktop/SSH) y ejecuta manualmente el programa de configuración y compila.
```
source ~/.profile;
cd ~/WRFModel/Build_WRF/WRF;
./configure #Here, you choose the compile option you want
./compile em_real >& log.compile #The compilation should take about 20-30 minutes
```
Compruebe si la compilación se ha realizado correctamente mediante la ejecución de ls -ls main/*.exe, debería ver lo siguiente:
```
wrf.exe 
real.exe  
ndown.exe 
tc.exe  
```
Compile WPS. De nuevo, debe configurar los compiladores. Elija opción 1 (serie, recomendada por el sitio web oficial de WRF). WPS consume menos CPU y se puede ejecutar como un único trabajo de procesador.

Inicie sesión en el nodo a través de SSH, ejecute el programa de configuración y compile.
```
source ~/.profile;
cd ~/WRFModel/Build_WRF/WPS;
./configure #Here, you choose the compile option you want
./compile >& log.compile #The compilation should take a few minutes
```
Si la compilación se realiza correctamente, debe haber 3 ejecutables en el directorio de nivel superior de WPS.
```
geogrid.exe -> geogrid/src/geogrid.exe
ngrib.exe -> ungrib/src/ungrib.exe
metgrid.exe -> metgrid/src/metgrid.exe
```

Ejecución de cargas de trabajo de WRF

Preparación de datos de ejemplo para el trabajo de WRF

En este artículo, usamos el caso de dominio único de Hurricane Matthew. Para obtener más información sobre el fondo, consulte este vínculo .

Descargue los de datos de geografía estáticos y datos en tiempo real. Aunque puede descargar los datos de ejemplo en cada nodo mediante clusrun, para ahorrar ancho de banda de red, se recomienda realizar la descarga solo en un nodo, configurar un clúster NFS y compartir los datos a través del servicio NFS.
- En el lado servidor:
  
  Descargar datos:
```
mkdir -p ~/WRFModel/Build_WRF/DATA;
cd ~/WRFModel/Build_WRF/DATA;
wget https://www2.mmm.ucar.edu/wrf/src/wps_files/geog_high_res_mandatory.tar.gz; #Static geography data
tar -xzvf geog_high_res_mandatory.tar.gz
wget https://www2.mmm.ucar.edu/wrf/TUTORIAL_DATA/matthew_1deg.tar.gz #Real time data
tar -xf matthew_1deg.tar.gz
```
  Ejecute sudo apt install nfs-kernel-server para instalar el servidor nfs. A continuación, compruebe el estado del servicio sudo systemctl status nfs-server. Si el servicio está activo, modifique /etc/exports para configurar qué clientes pueden acceder a la carpeta compartida DATA.
```
/home/hpcadmin/WRFModel/Build_WRF/DATA [client hostname1](rw,sync,no_subtree_check)
...
/home/hpcadmin/WRFModel/Build_WRF/DATA [client hostnamen](rw,sync,no_subtree_check)
```
  Ejecute sudo exportfs -arv para realizar los cambios efectivos y showmount -e para comprobar la lista de exportación.
- En el lado cliente:
  
  Instale el cliente nfs, monte la carpeta compartida y agregue una línea a /etc/fstab para montar automáticamente la carpeta compartida cuando se inicie el sistema Linux. Cree un grupo de nodos WRF-NFSClients para los nodos y use clusrun para lograr todo.
```
clusrun /nodegroup:WRF-NFSClients "sudo apt install nfs-common -y;mkdir -p ~/WRFModel/Build_WRF/DATA;cd ~/WRFModel/Build_WRF;sudo mount [server hostname]:/home/hpcadmin/WRFModel/Build_WRF/DATA DATA;sudo sed -i '$a [server hostname]:/home/hpcadmin/WRFModel/Build_WRF/DATA /home/hpcadmin/WRFModel/Build_WRF/DATA  nfs defaults,_netdev 0 0' /etc/fstab"
```
Nota
1. Evite usar el directorio de recursos compartidos SMB en la carga de trabajo de WRF, ya que los datos de geografía estáticos contienen subcarpetas denominadas "CON", que es uno de los nombres de archivo reservados de Windows.
2. En esta demostración, descargamos los datos en DATA directorio de un nodo, que está en el mismo nivel que los directorios de WPS y WRF. Para su trabajo, elija un nodo y directorio de servidor NFS adecuado en función de sus necesidades y asegúrese de que haya suficiente espacio en el directorio. El tamaño de los datos de geografía estáticos es 29G. El disco del sistema operativo de serie HBv2 es de 64G y los tamaños de discos de datos temporales son de 480 + 960G. Si necesita descargar los datos en el disco del sistema operativo, puede expandir discos duros virtuales conectados a una máquina virtual Windows.

Use clusrun para establecer la variable de entorno WRFDATADIR para el directorio de datos.

clusrun /nodegroup:WRFNodes "sed -i '$a export WRFDATADIR=~/WRFModel/Build_WRF/DATA' ~/.profile;source ~/.profile"

Editar archivos de configuración

WPS y WRF usan diversas variables para definir el formato de datos, el ámbito de tiempo y espacio del cálculo, etc. Para obtener explicaciones detalladas de todas las variables, vea estos vínculos: WPS, WRF.

En la tabla siguiente se muestra cómo modificar el archivo de configuración de WPS namelist.wps para que se ajuste a nuestro caso práctico. Tenga en cuenta que para las variables que tienen varios valores, solo puede modificar la primera, ya que en un solo dominio solo nos preocupamos por el primer dominio.

Nombre de variable	Valor predeterminado	Nuevo valor
max_dom	2	1
start_date	'2019-09-04_12:00:00','2019-09-04_12:00:00'	'2016-10-06_00:00:00'
end_date	'2019-09-06_12:00:00','2019-09-04_12:00:00'	'2016-10-08_00:00:00'
interval_seconds	10800	21600
e_we	150,220	91
e_sn	130,214	100
Dx	15000	27 000
Dy	15000	27 000
map_proj	'lambert'	'mercator'
ref_lat	33.00	28.00
ref_lon	-79.00	-75.00
stand_lon	-79.00	-75.00
geog_data_path	'/glade/work/wrfhelp/WPS_GEOG/'	"$WRFDATADIR/WPS_GEOG"

Use clusrun para realizar la modificación. También puede cargar sus propios archivos de configuración, descargarlos en el nodo y reemplazar el archivo de configuración predeterminado.

clusrun /nodegroup:WRFNodes "source ~/.profile;sed -i -e 's/max_dom = 2/max_dom = 1/g' -e 's/2019-09-04_12:00:00/2016-10-06_00:00:00/g' -e 's/2019-09-06_00:00:00/2016-10-08_00:00:00/g' -e 's/interval_seconds = 10800/interval_seconds = 21600/g' -e 's/e_we              =  150, 220/e_we              =  91/g' -e 's/e_sn              =  130, 214/e_sn              =  100/g' -e 's/dx = 15000/dx = 27000/g' -e 's/dy = 15000/dy = 27000/g' -e """s/map_proj = 'lambert'/map_proj = 'mercator'/g""" -e 's/ref_lat   =  33.00/ref_lat   =  28.00/g' -e 's/ref_lon   = -79.00/ref_lon   = -75.00/g' -e 's/stand_lon = -79.0/stand_lon = -75.0/g' -e """s#/glade/work/wrfhelp/WPS_GEOG/#$WRFDATADIR/WPS_GEOG#g""" ~/WRFModel/Build_WRF/WPS/namelist.wps;"

En la tabla siguiente se muestra cómo modificar el archivo de configuración de WRF namelist.input para que se ajuste a nuestro caso práctico. Tenga en cuenta que para las variables que tienen varios valores, solo puede modificar la primera, ya que en un solo dominio solo nos preocupamos por el primer dominio.

Nombre de variable	Valor predeterminado	Nuevo valor
run_hours	36	48
start_year	2019,2019	2016
start_month	09,09	10
start_day	04,04	06
start_hour	12,12	00
end_year	2019,2019	2016
end_month	09,09	10
end_day	06,06	08
interval_seconds	10800	21600
history_interval	60,60	180
restart_interval	7200	1440
time_step	90	150
max_dom	2	1
e_we	150,220	91
e_sn	130,214	100
num_metgrid_levels	34	32
Dx	15000	27 000
Dy	15000	27 000

Use clusrun para realizar la modificación. También puede cargar sus propios archivos de configuración, descargarlos en el nodo y reemplazar el archivo de configuración predeterminado.

clusrun /nodegroup:WRFNodes "sed -i -e 's/max_dom                             = 2/max_dom                             = 1/g' -e 's/run_hours                           = 36/run_hours                           = 48/g' -e 's/start_year                          = 2019, 2019/start_year                          = 2016/g' -e 's/start_month                         = 09,   09/start_month                         = 10/g' -e 's/start_day                           = 04,   04/start_day                           = 06/g' -e 's/start_hour                          = 12,   12/start_hour                          = 00/g' -e 's/end_year                            = 2019, 2019/end_year                            = 2016/g' -e 's/end_month                           = 09,   09/end_month                           = 10/g' -e 's/end_day                             = 06,   06/end_day                             = 08/g' -e 's/interval_seconds                    = 10800/interval_seconds                    = 21600/g' -e 's/history_interval                    = 60,  60/history_interval                    = 180/g' -e 's/restart_interval                    = 7200/restart_interval                    = 1440/g' -e 's/time_step                           = 90/time_step                           = 150/g' -e 's/max_dom                             = 2/max_dom                             = 1/g' -e 's/e_we                                = 150,    220/e_we                                = 91/g' -e 's/e_sn                                = 130,    214/e_sn                                = 100/g' -e 's/num_metgrid_levels                  = 34/num_metgrid_levels                  = 32/g' -e 's/dx                                  = 15000/dx                                  = 27000/g' -e 's/dy                                  = 15000/dy                                  = 27000/g' ~/WRFModel/Build_WRF/WRF/test/em_real/namelist.input"

Creación de trabajos para realizar la simulación

Cree un trabajo y agregue 2 tareas con dependencia.

Id. de tarea	Nombre de tarea	Tipo	Nodos	Corazones	Workdir	Mandar
1	Wps	NodePrep	No disponible	No disponible	source ~/.profile; ln -sf ungrib/Variable_Tables/Vtable.GFS Vtable; ./link_grib.csh $WRFDATADIR/matthew/fnl; ./ungrib.exe; ./geogrid.exe; ./metgrid.exe	~/WRFModel/Build_WRF/WPS /name:wps
2	wrf	Básico	4	64	source ~/.profile; ln -sf .. /.. /.. /WPS/met_em.d01.2016-10* .; mpirun -iface ib0 -np %CORE_NUMBER% -f $CCP_MPI_HOSTFILE ./real.exe; mpirun -iface ib0 -np %CORE_NUMBER% -f $CCP_MPI_HOSTFILE ./wrf.exe; mkdir -p $WRFDATADIR/results/matthew; cp wrfout_d01_2016-10-0* $WRFDATADIR/results/matthew; cp wrfrst_d01_2016-10-0* $WRFDATADIR/results/matthew;	~/WRFModel/Build_WRF/WRF/test/em_real

En task1, administramos la tarea de preprocesamiento de datos ejecutando los tres submódulos de WPS: ungrib, geogrid y metgrid. Dado que el resultado del preprocesamiento es la entrada de la simulación WRF, debe existir en cada nodo que participa en el trabajo WRF. Por lo tanto, agregamos las tareas como tarea de preparación de nodo para que se ejecula en cada nodo.
En task2, ejecutamos los programas MPI real.exe y wrf.exe para realizar los cálculos paralelos y copiar los archivos de salida en la carpeta results/matthew en DATA carpeta compartida. En el comando mpirun

-iface especifica la interfaz de red que se usará para la comunicación entre los procesos.

-np especifica cómo procesa mamy el programa MPI entre ellos. En esta demostración, usamos 64 procesos, es decir, todos los núcleos de los nodos necesarios.

-f especifica el nombre de archivo que contiene la lista de nodos. Consulte este para obtener información sobre $CCP_MPI_HOSTFILE.

Logre todo lo anterior con comandos:

set NODE_NUMBER=4
set CORE_NUMBER=64
job new /numnodes:%NODE_NUMBER%
job add !! /workdir:~/WRFModel/Build_WRF/WPS /name:wps /type:NodePrep "source ~/.profile; ln -sf ungrib/Variable_Tables/Vtable.GFS Vtable; ./link_grib.csh ../DATA/matthew/fnl; ./ungrib.exe; ./geogrid.exe; ./metgrid.exe"
job add !! /workdir:~/WRFModel/Build_WRF/WRF/test/em_real /name:wrf /numnodes:%NODE_NUMBER% /requirednodes:[nodelist] "source ~/.profile; ln -sf ../../../WPS/met_em.d01.2016-10* .; mpirun -iface ib0 -np %CORE_NUMBER% -f $CCP_MPI_HOSTFILE ./real.exe; mpirun -iface ib0 -np %CORE_NUMBER% -f $CCP_MPI_HOSTFILE ./wrf.exe; mkdir -p $WRFDATADIR/results/matthew; cp wrfout_d01_2016-10-0* $WRFDATADIR/results/matthew"
job submit /id:!! /jobname:WRF

Obtención del resultado

Comprobación del resultado del trabajo en el Administrador de clústeres de HPC Pack 2019
Los resultados de la simulación se generan como archivos "wrfout" en /home/hpcadmin/WRFModel/Build_WRF/DATA/results/matthew, que se pueden visualizar con NCL o python. En la misma carpeta hay archivos "wrfrst" que se pueden usar para reiniciar la simulación, más información sobre el reinicio de la simulación, consulte este.

Compartir a través de