Your SlideShare is downloading. ×
Paralela10
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Paralela10

1,128
views

Published on

Clase 10

Clase 10

Published in: Education, Travel, Business

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,128
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
27
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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