Este documento resume Jumpshot, una herramienta para visualizar el rendimiento de programas paralelos basada en registros de bitácoras. Explica que Jumpshot permite el análisis post mortem mediante la visualización de líneas de tiempo y histogramas generados a partir de archivos de registro CLOG. También describe los requisitos para sistemas de visualización, la historia de herramientas similares y las ventajas e inconvenientes del uso de Java para implementar Jumpshot.

1. Programación y Computación
paralela
Visualización de la Performance
Glen D. Rodríguez R.
Basado en material de Zaki, Lusk, Gropp
y Swider
1

2. Resumen
• Qué es Jumpshot y de dónde viene?
• Otros softwares relacionados
• Requisitos para un sistema de visualización de
performance basado en logs (bitácoras).
• Produciendo logs: CLOG
• Visualizando logs: Jumpshot
• Detalles con el Java
• Trabajos futuros
2

3. Qué es Jumpshot?
• Herramienta para
comprender el
comportamiento de
procesos
programas paralelos
• Análisis Post-mortem
• Basado en archivos de log CLOG
• Incluye un paquete de logs
(CLOG) LOG
• Sobretodo para programas
MPI
• Escrito en Java Jumpshot
pantalla 3

4. Pantalla Típica de Jumpshot
4

5. Ejemplo en un programa que usa PETSc
5

6. De donde vino Jumpshot?
• La historia de las herramientas para análisis de
performance basadas en logs en Argonne es también la
historia de la búsqueda de un entorno de programación
en el cuál se implementase gráficos sencillos y una GUI.
• Gist (BBN) -- sólo X11
• Gráficos blanco y negro, no portable (sólo en la BBN Butterfly)
• Upshot -- X11 más Athena widgets, usado con el formato
de logs ALOG
• fastidioso, obtener performance era difícil (1990)
• Upshot re-escrito en Tcl/Tk
• Fácil de escribir código, gráficos lentos
6

7. Historia (continuación)
• Nupshot -- Upshot reescrito en Tcl/Tk/C para más
velocidad
• Buena performance
• Interfase Tcl/C inestable
• CLOG – nuevo formato de log
• Java + Upshot = Jumpshot
• usa CLOG
• tiene nuevas funciones
• explora posibilidades tecnológicas de Java
• Que sigue: JPython?
• SLOG – nuevo formato para visualizar más fácil logs
enormes.
7

8. Esfuerzo relacionados
• Gist aún se usa en TotalView del Dolphin como
TimeScan
• PICL/ParaGraph - Pat Worley, Mike Heath, Jennifer
Etheridge, Al Geist
• VAMPIR - Pallas
• Traceview - Al Malony
• Pablo - Dan Reed, Ruth Aydt
• XPVM - Jim Kohl, Al Geist
• XMPI - Raja Daoud, ahora en Notre Dame
• Paradyne - Bart Miller, Myron Livny
• Etc.
8

9. Por qué rehacer el Upshot?
Los sistemas modernos tienen nuevos requerimientos (no
todos han sido satisfechos aún por Jumpshot):
• Ambiente estable por largo tiempo para soportar
investigaciones futuras
• Portable, no solo entre los diferentes Unix y Linux,
incluso a Windows
• Soporte de las vistas tipo upshot más útiles
• Líneas de tiempo de los procesos con scrolling y zooming
• Histogramas de la duración de estados, propiedades de los
mensajes, rangos de los picos
• Las animaciones no son tan útiles
9

10. Requerimientos (continuación)
• Formato de archivos de log flexible y extensible, listo
para incluir nuevos tipos de eventos, estados,
conceptos
• Estados definidos por el usuario final
• Performance escalable
• control del logging en el origen
• agregación
• Soportar decenas de miles de eventos
• Estados anidados y no excluyentes
• Soporte de estados anidados es más importante
• Conectar los eventos mostrados con el código fuente.
10

11. Requerimientos (continuación)
• Mayor comprensión de las capacidades del MPI
(comunicadores, semi-transparencia de operaciones
colectivas)
• Habilidad para hacer queries con detalles de eventos
específicos, mensajes, y estados.
• Habilidad para localizar automáticamente partes
“interesantes” del pantallazo (tópico de investigación)
• Etc....
11

12. Librerías de logs CLOG : Background
Características del viejo ALOG:
• Registros de formato fijo (6 ints y string)
• Bueno para parsing, almacenamiento y acceso
• Malo para meter extensiones
• Hace timestamp con resolución de microsegundos
• OK en 1990
• No es lo suficientemente preciso hoy día
• Formato ASCII en archivos
• Bueno para portabilidad, fácil de leer
• No puede guardar data binaria en forma conveniente
12

13. CLOG: Requerimientos
• Debe ser lo suficientemente eficiente para no interferir
con el comportamiento del programa; I/O sólo cuando
el programa termina
• Es más conveniente tener un solo archivo de log al
final, en vez de uno por procesador.
• No se puede asumir que los relojes de las
computadoras están sincronizados (ni los timestamps)
• Flexibilidad en el tipo de registro, pero que no sea auto
descriptivo del todo
• Portable: archivos de log se pueden leer en diferentes
máquinas que en las que los escribieron.
13

14. CLOG: Cómo trabaja?
• Depende del MPI, para portabilidad
• Llama a la función MPI_Wtime para conseguir el
timestamp
• Más o menos eficiente, pero no lo mejor, en cualquier
arquitectura/OS
• múltiples formatos de registros con tipos, más un tipo
“plano”
• El usuario puede definir sus propios tipos, estados, y
colores
• Los registros de log se acumulan en grandes buffers en
memoria hasta que el malloc (asignar espacio dinámico
a punteros) falla, luego se para.
14

15. Como crear el log?
• Siga estos pasos
1. Compilar el código en forma normal (cc –c)
2. Vincular las librerias del log en vez de las normales
del MPI. Por ejemplo, para programas en C hacer:
• cc -o myprog.log myprog.c -llmpi -lpmpi -lmpi -lrt -
pthread
• Y para fortran
• f77 -o myprog.log myprog.f -lfmpi -llmpi -lpmpi -lmpi -lrt
-pthread
3. Al correr el programa se crea una log de nombre
nombredelprograma.log, o
nombredelprograma_profile.log
4. Si quiero loger todo funcion MPI, haga
mpicc -o programa programa.c -llmpe -lmpe 15

16. Programa y registros al log
/* Sample Program with Logging Commands*/
#include "mpi.h"
#include "mpe.h"
#include <math.h>
#include <stdio.h>
double f(a)
double a;
{ return (4.0 / (1.0 + a*a));}
int main(argc,argv)
int argc;
char *argv[];
{
int done = 0, n, myid, numprocs, i, rc, repeat;
double PI25DT = 3.141592653589793238462643;
double mypi, pi, h, sum, x, a;
double startwtime, endwtime;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);
MPE_Init_log();
if (myid == 0) {
MPE_Describe_state(1, 2, "Broadcast", "red:vlines3");
MPE_Describe_state(3, 4, "Compute", "blue:gray3");
MPE_Describe_state(5, 6, "Reduce", "green:light_gray");
MPE_Describe_state(7, 8, "Sync", "yellow:gray"); 16
}

17. while (!done)
{
if (myid == 0)
{
printf("Enter the number of intervals: (0 quits) ");
scanf("%d",&n);
startwtime = MPI_Wtime();
}
MPI_Barrier(MPI_COMM_WORLD);
MPE_Start_log();
MPE_Log_event(1, 0, "start broadcast");
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPE_Log_event(2, 0, "end broadcast");
if (n == 0)
done = 1;
else
{
for (repeat=5; repeat; repeat--) {
MPE_Log_event(7,0,"Start Sync");
MPI_Barrier(MPI_COMM_WORLD);
MPE_Log_event(8,0,"End Sync");
MPE_Log_event(3, 0, "start compute");
h = 1.0 / (double) n;
sum = 0.0;
for (i = myid + 1; i <= n; i += numprocs)
{ x = h * ((double)i - 0.5);
sum += f(x); }
mypi = h * sum;
MPE_Log_event(4, 0, "end compute");
fprintf( stderr, "[%d] mypi = %lfn", myid, mypi );

18. Sigue
MPE_Log_event(5, 0, "start reduce");
MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
MPE_Log_event(6, 0, "end reduce");
if (myid == 0)
{
printf("pi is approximately %.16f, Error is %.16fn",
pi, fabs(pi - PI25DT));
endwtime = MPI_Wtime();
printf("wall clock time = %fn", endwtime-startwtime);
}
}
}
MPE_Stop_log();
}
MPE_Finish_log("cpilog.log");
MPI_Finalize();
} 18

19. Cómo trabaja CLOG? (cont.)
• Al finalizar (CLOG_Finalize es
colectivo)
• Data de proceso local se añade a
los buffers
• Los timestamps se ajustan,
usando un simple algoritmo y
comunicación con otros procesos
• Los procesos forman un árbol
binario y hacen un merge local 3-
way en paralelo hasta el
procesador 0, que escribe el file
• El file es en formato Java
(“external-32” del MPI-2)
19

20. Funcionalidad “Normal” de Jumpshot
• Scrolling y zooming en una vista a lo largo del tiempo
• Las flechas representan mensajes
• Se puede hacer click en flechas y estados para m´s
detalles
• Histogramas de las duraciones de los estados, ancho
de banda de los mensajes
• Vista de picos para resumir información de estados
• Se puede seleccionar/deseleccionar estados, mensajes
20

21. Línea de tiempo y vista de picos
21

22. Funcionalidades “Inusuales” de Jumpshot
• Scrolling y zooming en la vista de histograma
• Puede enfocarse en duraciones/anchos de banda extremos
• calcula el top/bottom 1%, 5%, ... basado en el supuesto que las
distribuciones son normales
• Parpadeo de las instancias de estados, flechas; puede ayudar a
localizar eventos “raros” en un pantallazo grande y confuso.
• Puede hacer scroll de las líneas de tiempo una por una para
afinar la sincronización del reloj
• Heredado de Java:
• portabilidad
• Se puede correr como applet
• Bonitas funcionalidades GUI
• Varios look-and-feel
• Subventanas que se desprenden
22

23. Ventajas de usar Java
• Portable (Sun, SGI, RS6000, Windows, Linux, etc)
• Se puede correr como una aplicación X11 o en un
browser como un applet
• Gráficos suficientemente rápidos
• El set de componentes gráficos es muy bueno para
construir GUI – Swing de Java.
23

24. Problemas por usar Java
• Java evoluciona muy rápido (1.0 - 1.1.2 - 1.1.6 - 1.2-
1.3 – 1.4 – 1.5)
• A veces hay cambios radicales en java (por ejemplo cuando
salió la 1.2) y hay que esperar a que reprogramen jumpshot o
evitar actualizar a nuevas versiones de java.
• Componentes también evolucionan (ej: swing)
• Comportamiento del applet a veces no es completamente igual
al de la aplicación X11
• Se originan inconvenientes debido a que el programa
Java no es auto contenido (ej: variable CLASSPATH)
• Eso se resuleve en parte con el uso del JRE (java runtime
environment)
24

25. Distribución de Jumpshot
• Las distribuciones de Jumpshot incluyen
• Librería CLOG para crear archivos de log, usa cualquier MPI
• Librería mpe con la opción de ALOG/CLOG
• Librería de perfil MPI para la instrumentación automática de
programas MPI
• Se distribuye
• Como parte del MPICH (version 1.1.1 en adelante)
• como parte de la librería mpe, para usarse con cualquier
implementación del MPI
• Jumpshot sólo y por separado
25

26. Qué mejoras debe hacerse?
• Más requerimientos:
• Conexión con el código fuente (logear __FILE__, __LINE__)
• Seleccionar por los comunicadores MPI (noes fácil, por la forma
como se crean los communicator id)
• Scroll vertical
• Escalabilidad (Jumpshot 4 ya ve algo de eso);
aglomeraciones de data útil
• Detección automática de anomalías en la performance
26