Esta es la antigua web del Centro de Supercomputación de Galicia.

Nuestro nuevo web está disponible desde el 18 de Julio de 2011 en
https://www.cesga.es

Por favor, actualice sus enlaces y marcadores.


Esta web solo se mantiene con el fin de servir como histórico de noticias, cursos, ofertas de empleo publicadas, etc.. y/o documentación.

CESGA-Centro de Supercomputación de Galicia
Galego :: Español :: English
Centro de Supercomputacion de Galicia
Inicio
Destacados

Conectados
115 visitantes
Total desde 21-12-05: 48253487 visitas
ISO 9001:2008

EXCELENCIA GESTIÓN

Accesibilidad

Guía de uso HPC320 PDF E-mail
Conectando
Uso Interactivo
Sistemas de colas
Sistemas de ficheiros
Compilación
Librerias Matemáticas
Utilizando MPI
Utilizando OpenMP

Conectando

Una vez obtenida una cuenta de usuario (aquellos usuarios que ya tienen una cuenta activa en los servidores hpc4500 poseen la misma cuenta en este sistema), con los datos de login y password, se podrá conectar al sistema HPC320. El nombre del servidor es sc.cesga.es y el modo de conexión recomendado es ssh (unicamente la versión 2 del protocolo). Para obtener clientes para las distintas plataformas vease www.openssh.org. Un cliente para Windows se puede encontrar en este enlance, así como para transferir ficheros al estilo ftp.

Uso Interactivo

El sistema operativo del HPC320 es UNIX (Tru64 V5.1A). Una vez dentro del sistema, se abrirá una sesión interactiva a través de un shell que por defecto será ksh. Este shell tiene impuestos unos límites de tiempo de CPU, memoria y disco que se pueden consultar mediante el comando ulimit -a. De esta forma se favorece el uso del sistema de colas para la ejecución de trabajos con gran demanda de recursos.

Sistema de colas

Para trabajos que requieran más recursos (tiempo de cálculo, memoria o espacio en disco) que los limitados por el shell interactivo, se deberá utilizar el sistema de colas. Este sistema es el Sun Grid Engine. El modo de enviar trabajos implica conocer de antemano los valores máximos de cantidad de tiempo, número de procesadores, memoria y espacio en disco que va a requerir el cálculo. Esto permite además un mejor aprovechamiento de los recursos del sistema por parte de todos los usuarios.

El comando para enviar trabajos al sistema de colas en el HPC320 es qsub, seguido por una lista de los recursos que necesita el trabajo. Por ejemplo, supongamos que queremos enviar un trabajo Gaussian que no necesita más de 2 gigabytes de memoria y 10 gigabytes de scratch, y estimamos un tiempo de ejecución aproximado no superior a 24 horas, utilizando un procesador. Si el fichero de entrada para Gaussian se llama script.com y se encuentra en el directorio "pruebas", la forma de enviar este trabajo a la cola es:

qsub -l num_proc=1,s_rt=24:00:00,s_vmem=2G,h_fsize=10G
cd $HOME/pruebas
g98 < script.com
control+D
Si no se produce ningún error, obtendremos un mensaje de este tipo:

Your job 492 ("STDIN") has been submitted

El número 492 es lo que se llama identificador de trabajo o JOBID y nos permite identificar nuestro trabajo dentro del sistema de colas (por ejemplo, para utilizar con el comando qstat y saber si se está ejecutando, encolado, etc.). También es importante indicar este número al hacer consultas telefónicas o por correo electrónico con el personal de sistemas.

La forma de especificar recursos es con la directiva –l, seguida de los recursos que se solicitan separados con una ",". Es imprescindible dejar un espacio en blanco entre la opción "-l" y la lista de recursos. Los recursos deben ser:
 
 
Recurso
Significado
Unidades
Valor mínimo
Valor máximo
num_proc Número de CPUs (procesadores) requeridos por el trabajo --- 1 4
s_rt Máxima cantidad de tiempo real que puede durar un trabajo Tiempo  
360:00:00
s_vmem Cantidad total de memoria RAM requerida por el trabajo Tamaño   8G
h_fsize Máximo espacio requerido por un único fichero creado por el trabajo Tamaño   16G

Si necesita utilizar valores superiores a los límites de estos recursos o necesita una priorización de sus trabajos consulte la páxina de Recursos Especiales, allí se indican los pasos a seguir.

Debemos tener en cuenta que:
 
Es muy importante dejar un espacio en blanco entre la opción "-l" y el siguiente recurso, mientras que después no deberá haber ningún otro espacio en blanco separando los recursos.
1. Estos valores son máximos, por lo que no se podrán superar. Esto quiere decir que si creemos que nuestro trabajo durará unas 23 horas, debemos poner como s_rt=24:00:00 para asegurarnos de dejar un margen al trabajo. Después de 24 horas el sistema finalizará el trabajo, aunque este no haya concluido.
 
2. Cuanto más ajustados sean estos valores a los recursos que realmente consume el trabajo, mayor prioridad para entrar en ejecución tendrá el trabajo.
Si estos recursos no son suficientes para el trabajo, éste abortará por falta de recursos y será necesario indicar los valores adecuados. En general, recomendamos solicitar recursos lo más cercanos, por encima, a los valores que se estimen necesarios. El motivo es que cuantos menos recursos se soliciten, con mayor prioridad entrará el trabajo en ejecución.
 
El formato de las unidades para los recursos es el siguiente:

Tiempo: especifica el período de tiempo máximo durante el que se puede utilizar un recurso. El formato es el siguiente: [[horas:] minutos:]segundos, por ejemplo:

  • 30:00 son 30 minutos
  • 100:00:00 son 100 horas
  • 1200 son 1200 segundos (20 minutos)

Tamaño: especifica el tamaño máximo en Megabytes. Se expresa en la forma entero [sufijo]. El sufijo actúa como un multiplicador definido en la siguiente tabla:

k
Kilo (1024) bytes
m
Mega (1,048,576) bytes
g
Giga (1,073,741,824) bytes
 
Resumiendo, vamos a poner unos ejemplos para distintos trabajos:
 
1. Para un trabajo que requiere poco consumo de memoria y tiempo de ejecución:
qsub -l num_proc=1,s_rt=10:00,s_vmem=100M,h_fsize=100M trabajo.sh
 
2. Trabajo que requiere mucho tiempo de ejecución (80 horas) y poca memoria (es suficiente con 256mb):
qsub -l num_proc=1,s_rt=80:00:00,s_vmem=256M,h_fsize=10M trabajo.sh
 
3. Un trabajo con grandes requerimientos de memoria (4 Gigabytes) pero poco tiempo de ejecución:
qsub -l num_proc=1,s_rt=30:00,s_vmem=4G,h_fsize=10M trabajo.sh
 
4. Un trabajo que genera un fichero grande (hasta 20 Gigabytes) de resultados:
qsub -l num_proc=1,s_rt=30:00:00,s_vmem=500M,h_fsize=20G trabajo.sh
 
5. Un trabajo que consume 100 horas de CPU, 2 Gigabytes de memoria y genera un fichero de 5 gigabytes:
qsub -l num_proc=1,s_rt=100:00:00,s_vmem=2G,h_fsize=5G trabajo.sh
 
6. Un trabajo paralelo con 8 procesadores y 10 horas de tiempo de ejecución total, 8 Gigabytes de memoria total y genera un fichero de 10 gigabytes:
qsub -l num_proc=8,s_rt=10:00:00,s_vmem=8G,h_fsize=10G trabajo.sh
 
Si necesita utilizar valores superiores a los límites de estos recursos, se debe solicitar el acceso a la cola especial, enviando un mail a la dirección de correo
 
Una vez que ejecutamos el comando qsub, y obtenemos el identificador para el trabajo, éste pasa a una cola apropiada para su ejecución. El trabajo esperará su turno o el momento en que estén disponibles los recursos solicitados, para pasar a la ejecución, y finalmente el trabajo concluirá y desaparecerá de la cola.
 
Chequeando el estado de los trabajos:
 
Para comprobar el estado en que se encuentran los trabajos, se puede utilizar el comando qstat
 
qstat
 
Obtendremos una salida como la siguiente:
 
Job id prior name user state submit/start at Queue
489 0 STDIN carlosf r 12/29/2003 19:49:05 Cola1
 

El significado de los campos es el siguiente:

Job ID: 489 es el valor del JOB-ID que le ha asignado el sistema de colas PBS. El JobID es un identificador único para cada trabajo y permite realizar el seguimiento del mismo.

Prior: indicar la prioridad con que se está ejecutando el trabajo

Name: STDIN es el nombre del trabajo que se ha enviado a la cola. Si se ha enviado un trabajo desde la entrada estándar (es decir, escribiendo los comandos al enviar el trabajo), aparecerá STDIN. En el caso de ser un script, aparecerá el nombre del script.

User: carlosf es el login del usuario que ha enviado el trabajo a la cola

State: "r" es el estado en que se encuentra el trabajo e indica que está en ejecución (running). Los otros posibles estados de un trabajo son:

    • t: transfiriéndose el trabajo para comenzar su ejecución. R indica que el trabajo está en ejecución.
    • s: suspendido temporalmente para ejecutar trabajos más prioritarios
    • w: el trabajo está encolado en espera de que haya suficientes recursos para ser ejecutado o debido a que se han excedido los límites por el usuario.

Submit/start at: fecha y hora en la que el trabajo fue enviado a la cola o entró en ejecución.

Queue: cola 1 es el nombre de la cola a la que se envió el trabajo. La cola destino dependerá de los recursos que se hayan solicitado.

Master: indica el host desde el que se envió el trabajo.  

Sistemas de ficheros

Existen distintos sistemas de ficheros con diferentes características en función de los requerimientos de espacio y velocidad de acceso.

Directorio home

Es el directorio en el que estarán los datos y ficheros habituales de trabajo diario, y del cual se hacen backups de modo regular. Existen cuotas (límites en su utilización), por lo que su uso deberá ser moderado.

Sistema de almacenamiento

Todos los usuarios disponen de un subdirectorio SAHOME desde el cual acceden al sistema de almacenamiento masivo del CESGA. En este espacio podrán introducir todos los ficheros y datos que deseen conservar y de utilización menos frecuente. También se realiza backup regular de este sistema. No deberían utilizarse datos o ficheros dentro de este subdirectorio en los trabajos que se envían a cola, por lo que en caso de necesitarse en un momento dado, deberán moverse primeramente al directorio home de trabajo habitual.

Directorio de scratch

Es un espacio de almacenamiento para datos temporales y que se utiliza en aplicaciones como Gaussian o Gamess que requieren de un fichero grande en el que escriben gran cantidad de datos de modo continuado. Sólo es posible acceder a este directorio a través del sistema de colas y con la variable de entorno $TMPDIR. Los datos que se encuentren en este directorio desaparecerán al finalizar el trabajo. Si algún fichero contenido en este directorio fuese necesario, es responsabilidad de cada usuario el copiarlo a su directorio home antes de que finalice el trabajo.

Directorio /tmp

En este directorio de acceso común para todos lo usuarios se pueden introducir pequeños ficheros temporales, aunque su utilización está desaconsejada y su contenido podrá ser eliminado de forma periódica.

Editores de texto

Ademas del vi, estan disponibles emacs, xemacs y xedit.

Compilación

Compiladores y opciones:

1. Los compiladores de Fortran son f77, f90 y f95
2. El compilador de C es cc
3. El compilador de C++ es cxx
4. La opción de optimación recomendada es -fast, la cual selecciona un conjunto de opciones dirigidas a optimizar el código. Como cualquier otra opción de optimización, se deberá prestar atención a los resultados obtenidos con el código y comprobar que son correctos antes de utilizarla en cálculos definitivos.

Autoparalelización con los compiladores KAP

Los preprocesadores de Kuck & Associates para Fortran y C se utilizan para obtener las directivas OpenMP que se pueden insertar en un código secuencial para habilitar el paralelismo SMP.

Estos optimizadores toman un código Fortran 90, Fortran 77 o C y automáticamente lo paralelizan en aquellos lugares en los que es posible y seguro. Para utilizar los compiladores y paralelizar, es necesario llamarlos del siguiente modo:

    kf90 -fkapargs=-conc prog.f
ó
    kcc -ckapargs=-conc prog.c
 
En los ficheros prog.cmp.f ó prog.cmp.c y prog.out aparecerán las modificaciones que ha introducido el preprocesador en el código original. En las páginas man del kf90 y del kcc se puede encontrar más información sobre las distintas opciones de los compiladores.

Para ejecutar el código, es necesario primeramente fijar la variable de entorno OMP_NUM_THREADS al número de procesadores que se van a utilizar (entre 1 y 4). Por ejemplo, para utilizar 4 cpus:

    export OMP_NUM_THREADS=4
 
Y a continuación podremos ejecutar el código como haríamos normalmente.
Para más información sobre los compiladores KAP y sus opciones de optimización y paralelización, diríjanse a las páginas de documentación de Compaq.

Librerías matemáticas

Compaq Extended Math Library (CXML)
Proporcionan un conjunto de subrutinas matemáticas especialmente optimizadas para la plataforma Alpha, incluye subrutinas en las areas de:
Algebra lineal básica (BLAS): incluye BLAS1, BLAS1E, BLAS1S, BLAS2 y BLAS3
Sistemas de ecuaciones lineales y autovalores (LAPACK)
Sistemas de ecuaciones lineales dispersas: incluyes métodos directos e interactivos.
Procesado de señales: incluyes FFTs, transformadas seno/coseno, convoluciones, correlaciones y filtros digitales.
La mayoría de las rutinas incluyen versiones para números reales y complejos, además de soportar simple y doble precisión. CXML también proporciona SCIPORT, una implementación de Compaq Computer Corporation de las CRAY SCILIB. Esta librería proporciona rutinas de 64 bits y precisión simple para portar aplicaciones de sistemas CRAY a sistemas Alpha.
 
Además, la librería CXML incluye una versión paralelizada (cxmlp) con el modelo de memoria compartida de todas las subrutinas (la versión paralelizada incluye todas las subrutinas, aunque sólo algunas están paralelizadas, la lista completa de subrutinas que están paralelizadas se encuentra en este link
Para compilar y enlazar un programa que contiene llamadas a las rutinas CXML, debe utilizar:

f77 mi_programa.f -lcxml o cc mi_programa.c -lcxml
 
Para utilizar la versión paralela de la librería:

f77 mi_programa.f -lcxmlp
 
Para saber cómo ejecutar un programa linkado con la versión paralela de la librería, véase la sección "ejecutando trabajos OpenMP"
 
La documentación completa de la librería CXML se encuentra aquí
 
Compaq Portable Math Library (CPML)
Incluye una amplia variedad de funciones matemáticas: funciones trigonométricas, exponenciales, logaritmos, algebraicas, complejas, etc... Pulse aquí  para obtener más información.

Utilizando MPI

MPI es un inferface de programación paralela para el envío explícito de mensajes entre procesos paralelos (para lo cual es necesario haber añadido el código MPI necesario en el programa). Para habilitar la utilización de MPI en los programas, es necesario incluir el fichero de cabecera de MPI en el código fuente y linkar con las librerías de MPI en el momento de linkar.

Compilación y linkado

Para los códigos Fortran, es necesario incluir la siguiente directiva en el código fuente de cualquier código que utilice MPI:

     INCLUDE 'mpif.h'
y compilar con el siguiente comando:
     f90 miprograma.f -o miprograma.exe -lmpi
Para los códigos en C, es neceario utilizar la siguiente directiva:
     #include <mpi.h>
y compilar con un comando similar al siguiente:
    cc miprograma.c -o miprograma.exe -lmpi

Ejecutando códigos MPI

Es necesario utilizar la orden dmpirun al ejecutar cualquier código MPI tanto en interactivo como desde el sistema de colas. Para más detalles sobre cómo ejecutar códigos MPI desde el sistema de colas, consúltese la guía de utilización del sistema de colas.
 
 
OpenMP es un conjunto de extensiones a los estándares Fortran, C y C++ para soportar la ejecución paralela en el modelo de memoria compartida. Para su utilización es necesario añadir directivas al código fuente que paralelicen los bucles y que especifiquen ciertas propiedades de las variables (los compiladores Kap introducen automáticamente este tipo de directivas al utilizar la opción -conc).

Compilando y linkando

 Para compilar código Fortran que incluya directivas de OpenMP:
    f90 -fast -omp miprograma.f -o miprograma.exe
Para compilar código C que incluya directivas de OpenMP:
    cc -fast -omp miprograma.c -o miprograma.exe

Ejecutando trabajos OpenMP

 Para ejecutar códigos OpenMP es necesario enviar el trabajo a cola, de ese modo se fija convenientemente la variable de entorno OMP_NUM_THREADS al número de CPU que se han solicitado. Para más información consulte la utilización del sistema de colas.

Problemas frecuentes con OpenMP

 Uno de los problemas más comunes que se encuentran después de paralelizar un código con OpenMP es la generación de excepciones de punto flotante o de violación de segmentos que no se producían antes de la paralelización. Éste suele ser un problema debido a la utilización de variables sin inicializar.
Modificado ( 03.08.2009 )
Master HPC

CESGA APOYA

PRACE Award 2009

Itanium Alliance Award

Proyectos

Miembro de Gelato

Acreditación EUGridPMA

Novedades
Dominio gallego

ALERTA VIRUS MENSUAL

infoarrobacesga.es :: Telf.: +34 981 569810 - Fax: 981 594616 :: Avda. de Vigo s/n 15705, Santiago de Compostela.
CESGA