Optimización de aplicaciones

1. Optimización de aplicaciones Para PDAs basados en Intel Xscale Arquitecturas Especializadas

2. Dispositivos PDA • Diversa funcionalidad • Agenda telefónica, calendario. • Procesar textos y documentos Word,Excel… • Enviar e-mails. • Reproducir vídeos,películas y MP3. • Sistema de navegación GPS. • Usos educativos. • Usos en medicina.

3. Dispositivos SmartPhone • Son un teléfono móvil con capacidades de procesamiento adicionales. • Menor tamaño, menores prestaciones.

4. Características propias de un PDA • Pantalla táctil (Teclado opcional) • Memoria externa SD o Flash. • Conexiones IrDa, BlueTooth, WiFi. • Sistema Operativo • Windows CE • Linux • Symbian (sobre todo SmartPhones).

5. Windows CE • Interfaces directas con dispositivos usuales como GPS, BlueTooth..etc. • Soporte gráficos Direct Draw. • Servidor SQL integrado.

6. Linux • OpenZaurus – Sharp. • Basadas en Devian: • Familiar Linux. • Intimate (+ requisitos memoria)

7. Familia Intel Xscale • Implementación de la versión 5 de ARM sin coma flotante. • Familia de 4 procesadores: • PXA: Procesadores de aplicaciones. • IXC: Controladores alto rendimiento. • IXP: Controladores para redes. • IOP: Procesadores Entrada / Salida.

8. Procesadores Intel Xscale • Muy utilizados en PDAs. • Características: • Alta velocidad 400Mhz – 800Mhz • Bajo consumo (escalado dinámico). • Controladores integrados para pantalla táctil, sistema de sonido…etc. • Optimización para aplicaciones usuales: códecs audio/video, instrucciones MMX…

9. Diagrama de bloques de procesadores actuales

10. Elementos del núcleo

11. Arquitectura Xscale PXA

12. Elementos de la arquitectura • 16 registros de 32 bits • Multiplicador Acumulador de 40 bits • Cachés de instrucciones y de datos de 32Kb. • Mini-caché de datos 2Kb. • Unidades de gestión de memoria para instrucciones y para datos.(IMMU y DMMU). • Buffer de escritura. (WB)

13. IMMU y DMMU • Realizan la translación de direcciones lógica a física. • Gestionan los permisos de acceso a memoria. • Constan de buffers de 32 entradas asociativas (ITLB y DTLB). • Política de reemplazo Round-Robin.

14. IMMU y DMMU 2 • Si una instrucción o dato no se encuentra en su buffer ITLB o DTLB, se invoca un algoritmo basado en tabla. • Estas dos unidades pueden ser habilitadas o deshabilitadas conjuntamente.

15. Caché de Instrucciones • Permite acceder a la velocidad del núcleo a las instrucciones. • Caché asociativa de 32 conjuntos / 32 vías. • Cada vía contiene: • Una dirección. • Una línea de caché (8 palabras de 32 bits) • Bits de paridad y validez.

16. Caché de Instrucciones - 2

17. Caché de Datos • Estructura idéntica a la caché de instrucciones.(32 conjuntos 32 vías) • Funcionamiento conjunto con 2 buffers de carga y de pendientes: • Se pretende traer datos a la caché antes que se produzca una falta. • Escritura utilizando Buffer de Escritura.

18. Caché de datos 2

19. Mini caché de datos • Diseñada para contener flujos de datos que cambian constantemente.(MPEG) • Trata de evitar la paginación causada en la caché de datos por el constante cambio de datos. • 32 conjuntos / 2 vías.

20. Mini caché de datos - 2

21. Buffers FB y PB • Ambos trabajan con la DMMU. • Poseen 4 entradas. • El buffer FB trabaja con el núcleo para manejar datos no cacheables. • El buffer PB trata de evitar las faltas de datos. • Su misión es evitar que el núcleo se atasque esperando los datos de memoria.

22. Buffer de escritura • 8 entradas de 16 bytes cada una. • Puede ser utilizado directamente por: • El núcleo. • La caché de datos. • La mini caché. • Tecnología de escritura en bloque

23. Tecnología de escritura en bloque del buffer de escritura WB

24. Optimización de aplicaciones • Como mejorar el rendimiento: • Utilizando el sistema de memoria. • A través de las primitivas de Intel IPP.

25. Estructura de la caché • Rendimiento de nuestra aplicación condicionado fuertemente por: • Impacto de las funciones Inline. • La alineación de datos.

26. Impacto de funciones Inline • Utilizamos funciones inline dentro de bucles largos para evitar sobrecarga de la llamada. • El aumento del tamaño de código puede causar que no quepa en la caché. • Solución: • Generar un archivo de mapa del binario para saber si cabe en caché nuestra función.

27. Alineación de datos • Hemos de tratar de alinear las estructuras de datos en bloques de 32 bytes. • Ejemplo typedef struct { long x; // suponemos que long son 4 bytes long y; long z; long t; long color; } point_t; // estructura que representa un punto point_t my_pt;

28. Alineación de datos - 2 • Si no alineamos los datos:

29. Alineación de datos - 3 • Alinear los datos depende del compilador. • Para el compilador de Microsoft: __declspec(align(32)) struct foo { long a, b, c, d; };

30. Uso de la escritura en bloques • A la hora de la escritura podemos escribir en bloques para optimizar el rendimiento. • Ejemplo: // bucle original // No utiliza la ventaja que proporciona // write coalescing for(int X=0;X<cCoord.rRadius;X++) for(int Y=0;Y<cCoord.rRadius;Y++) *(TempBuff)++ = PixelCol;

31. Uso de la escritura en bloques - 2 • Haciendo uso de la escritura en bloques: • Desenrollamos 4 iteraciones del bucle. // optimizado para tomar ventaja de write coalescing for(int X=0;X<(cCoord.rRadius);X++) { for(int Y=0;Y<(cCoord.rRadius)/4;Y++) { *(TempBuff)++ = PixelCol; *(TempBuff)++ = PixelCol; *(TempBuff)++ = PixelCol; *(TempBuff)++ = PixelCol; } }

32. Primitivas de Intel IPP v 5.1 • Proveen funcionalidad diversa y optimizada:

33. IPP - 2 • Soporte para los procesadores actuales

34. IPP - 3 • Soporte para los sistemas operativos: • Windows ME, 2000, XP, Server 2003 • Linux. • Mac OS. 10.4.3 • Soporte para los procesadores: • Pentium 4 en adelante. • Xscale a partir del modelo PXA27x. • Xscale IPX4xx en adelante.

35. Aplicación propuesta • Aplicación que dibuja en pantalla círculos de radio y posición aleatoria.

36. Aplicación propuesta • Código de la rutina principal void DibujaCirculo(unsigned short *buffer,int x,int y,int radio,COLORREF rGB) { float rad=0; int X,Y; while (rad <= 2*M_PI){ X = (int) (radio * cos(rad)); Y = (int) (radio * sin(rad)); PlotPixel(buffer, X +x, Y+y,rGB); rad += (float)0.005; } El cálculo del seno y del coseno pretendo que sea un cuello de botella Para dibujar un círculo hemos de calcular 1256 senos y cosenos.

37. Tiempos de ejecución

38. Optimización utilizando IPP • Si usamos las primitivas de Intel, el código es el siguiente: void DibujaCirculo(unsigned short *buffer,int x,int y,int radio,COLORREF rGB) { float rad=0,ret=0; int X,Y; while (rad <= CPI){ gppCosHP_16_32s (rad, &ret); X = gppRound_Fixed_16_To_Int(ret * radio); gppSinHP_16_32s (rad, &ret); Y = gppRound_Fixed_16_To_Int(ret * radio); PlotPixel(buffer, X +x, Y+y,rGB); rad += (float)0.005; } Reescribimos sólo 4 líneas de código que se corresponden con el cálculo del seno y coseno

39. Tiempos de ejecución

40. Una última optimización • Utilizar escritura en bloque WB: • Podemos aumentar el rendimiento si escribimos de 4 en 4 píxeles. • Problema: • Para realizar la escritura en bloque, hemos de asegurarnos que las cuatro escrituras son consecutivas. Tenemos que integrar la función que dibuja un píxel con nuestra rutina

41. Una última optimización • Escribimos 11 líneas de código para una ganancia en velocidad de 20 ms.

42. Conclusiones • Podemos optimizar aplicaciones sin utilizar el ensamblador: • Utilizando las primitivas de Intel IPP. • Conociendo la arquitectura: • Usando el buffer de escritura. • Precargando los datos en la caché. • Alineando nuestras estructuras en memoria.

43. Conclusiones - 2 • Si queremos optimizar una aplicación sin aumentar el tiempo de desarrollo: • Utilizando las primitivas de Intel, he incrementado el rendimiento en 12 veces. • Modificamos 4 instrucciones frente 558 que consta nuestro programa.