Tema 5: El Pentium a Fondo - DAC

MICROPROCESADORES 

Tema 5: El Pentium a Fondo 

Carlos Garre y David Miraut 

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA 

INFORMÁTICA 

1

Contenidos 

Programación Eficiente 


• Programación eficiente en arquitecturas Pentium: 

– Análisis de rendimiento. 

– Programación con extensiones SIMD. 

– Introducción a programación concurrente. 


INFORMÁTICA 

2

Contenidos 

Análisis de Rendimiento 


• CPU Profiler: Herramienta que permite analizar el tiempo que 

consume una tarea, y qué funciones o threads de esa tarea son los 

que están consumiendo más tiempo de CPU. 

• Uso de un profiler: 

1. Ejecutar la aplicación que queremos analizar, lanzándola desde el 

profiler. 

2. Mientras la aplicación se ejecuta, el profiler toma muestras de tiempos y 

de llamadas entre los componentes del programa. 

3. Cuando termina la ejecución, el profiler muestra resultados estadísticos, 

informando de qué funciones son las que más recursos consumen. 

4. Teniendo localizados los cuellos de botella de nuestro código, 

optimizamos esas líneas de código concretas. 

5. Algunos profilers (Intel VTune) pueden incluso decirnos exactamente 

cómo podemos optimizar ese código. 


INFORMÁTICA 

3

Contenidos 

Intel VTune 


• Intel VTune: Es un profiler muy avanzado de Intel que permite 

aprovechar al máximo todas las características de las arquitecturas de 

Intel (IA-32, IA-32/64 bits, IA-64…). 

• Trabaja junto con el Intel Compiler, y se puede integrar totalmente con 

Visual Studio. 


INFORMÁTICA 

4

Contenidos 

Sampling Wizard 


• Sampling Configuration Wizard: Herramienta que nos permite rápidamente 

analizar el consumo de todas las tareas que se están ejecutando en el 

ordenador en ese momento. 

• Si hacemos doble-click en la tarea que corresponde a nuestro programa, 

podemos ver el código fuente (si fue compilado con información de 

depuración). 


INFORMÁTICA 

5

• Si utilizamos el botón “Get 

Advice Using Intel VTune 

Assistant”, VTune nos dará 

consejos sobre cómo optimizar 

el código seleccionado. 

Contenidos 

Assistant Advice 



INFORMÁTICA 

6

Call Graph 


• VTune nos puede mostrar gráficamente qué funciones de nuestro código están 

consumiendo más recursos. Para ello utilizamos la herramienta Call Graph. 

• Nos muestra un árbol jerárquico, en el que se desdoblan las ramas que 

corresponden a las funciones más pesadas. El color de las hojas del árbol indica el 

consumo (los colores más cercanos a rojo indican un mayor consumo). 

Contenidos 

• Desde el árbol también podemos abrir el código fuente de la función que 

queramos. 

• Vamos a ver a continuación algunos de los consejos típicos que nos puede dar 

VTune, y cómo seguirlos. 


INFORMÁTICA 

7

Conversiones de Tipos 


• Utilizar los tipos adecuados para cada variable. No basta sólo con distinguir entre 

enteros y reales, sino también entre los tipos de enteros: short, int, long. 

• Si se utilizan librerías externas (math.h), comprobar los tipos que piden las 

funciones que estemos utilizando. 

• Vigilar los tipos en las variables que iteran los bucles. 

• A veces los warning del compilador también nos pueden avisar de posibles 

problemas con los tipos. En general, deberíamos dejar el compilador sin ningún 

warning, ya que no sólo informan de errores potenciales sino también de posibles 

problemas de rendimiento. 


INFORMÁTICA 

8

Desenrollado de bucles 


• Los bucles con pocas instrucciones por iteración (pero muchas iteraciones), no 

aprovechan las posibilidades de paralelismo del procesador. 

Contenidos 

• Para aumentar el paralelismo, y evitar la sobrecarga de los continuos saltos, se 

pueden desenrollar los bucles para realizar más operaciones por cada iteración: 

for (i = 1; i > 1; 


INFORMÁTICA 

for (i = 1; i > 1; 

data [i+1] = data [i+1] >> 1; 

data [i+2] = data [i+2] >> 1; 

data [i+3] = data [i+3] >> 1; 

} 

9

Desenrollado de bucles (II) 


• Si el número de iteraciones no cuadra con el factor de desenrollamiento, se 

pueden hacer dos bucles consecutivos. 

• No se deben desenrollar bucles con pocas iteraciones o con muchas 

instrucciones. 

Contenidos 

• Otras consideraciones para optimizar bucles: 

Introducir sólo instrucciones que dependan de las iteraciones del bucle. El código 

invariante debe salir fuera del bucle. 

Si dentro de un bucle hay una sentencia condicional (if-then-else) que no depende del 

bucle, se saca fuera: 

For (i…) 

If (a == b) 

Else 

End For; 

Sentencias1; 

Sentencias2; 


INFORMÁTICA 

If (a == b) 

For (i…) 

Sentencias1; 

End For; 

Else 

For (i…) 

Sentencias2; 

End For; 

10

• Bucle sin desenrollar: 

Contenidos 

for( i = 0; i < n; i++ ) 

a[ i ] = b * c[ i ]; 

Desenrollado de bucles (III) 

• Bucle desenrollado con factor 4: 

ii = n % 4; 

for( i = 0; i < ii; i++ ) 

a[ i ] = b * c[ i ]; 

for( i = ii; i < n; i += 4 ) 

{ 

} 

a[ i ] = b * c[ i ]; 

a[ i+1 ] = b * c[ i+1 ]; 

a[ i+2 ] = b * c[ i+2 ]; 

a[ i+3 ] = b * c[ i+3 ]; 



INFORMÁTICA 

11

Manejo de Arrays 


• Cuando queremos inicializar un array con un valor fijo, es mucho más eficiente 

hacerlo con memset que con un bucle: 

for (i = 0; i < n; i++) 

salida [i] = 0; 

memset (salida, 0, n*sizeof(short)); 

• Para copiar un array sobre otro, es mucho más eficiente hacerlo con memcpy que 

con un bucle: 

for (i = 0; i

Otros consejos de Optimización 


• Precalcular todo lo que pueda ser precalculado. 

• En sentencias condicionales anidadas, poned siempre primero las que sean 

menos costosas y más probables. Las sentencias switch-case suelen ser más 

eficientes que las if-then-else anidadas. 

• Evitar la aritmética costosa siempre que sea posible: 

2*a = a + a. 

Log(a) + Log(b) = Log(a*b). 

Pot(a,2) = a*a; 

a/2 = a >> 1; 

• Utilizar estructuras de datos eficientes. Librería STL de C++: 

¿ vector a ó int a[] ?. 

• Compilar en modo debug para buscar warnings y eliminarlos. 

• Vectorización mediante extensiones SIMD (el próximo apartado): 


INFORMÁTICA 

13

Contenidos 

Programación Eficiente 


• Programación eficiente en arquitecturas Pentium: 

– Análisis de rendimiento. 

– Programación con extensiones SIMD. 

– Introducción a programación concurrente. 


INFORMÁTICA 

14

Intrinsics 


• Funciones incluidas directamente en el compilador, que te permiten acceder a 

funciones de bajo nivel sin necesidad de programar directamente en 

ensamblador. 

• Son más eficientes que una librería de funciones, ya que te ahorras realizar 

llamadas a subrutinas se genera directamente código ensamblador en el punto 

donde se encuentra la Intrinsic. 

• Son muy dependientes del compilador problema de portabilidad. 

• #include “mmintrin.h” Nos facilita Intrinsics para aprovechar la extensión 

MMX: 

– Nuevo tipo de datos para utilizar los registros MMX: 

• __m64: entero de 64 bits. __m64* p_mmx 

– Juego de instrucciones SIMD de la extensión MMX.: 

• PADDB: __m64 _mm_add_pi8 (__m64 m1 , __m64 m2); 


INFORMÁTICA 

15

MMX: Funciones Aritméticas 


• __m64 _mm_adds_pi8 (__m64 m1, __m64 m2): Suma por separado los 8 bytes 

de un registro MMX con los 8 bytes de otro registro MMX. 

• __m64 _mm_sub_pi32 (__m64 m1, __m64 m2): Resta la parte alta del registro 

m1 de la parte alta del registro m2, y la parte baja del registro m1 de la parte baja 

del registro m2. 

• __m64 _mm_madd_pi16 (__m64 m1, __m64 m2): Multiplica las 4 palabras de 16 

bits del registro m1 por las 4 palabras del registro m2. Esto produce 4 valores 

intermedios de 32 bits. Estos 4 valores se suman dos a dos, para producir 2 

valores de 32 bits. 

• __m64 _mm_mulhi_pi16 (__m64 m1, __m64 m2): Multiplica las 4 palabras de 

m1 por las de m2, y devuelve la parte alta de cada resultado. Para la parte baja 

está la función _mm_mullo_pi16. 

• __m64 _mm_add_pu8 (__m64 m1, __m64 p2): Considera que todos los valores 

son enteros sin signo (unsigned). Resultado no saturado. 

*p_mmx = _mm_adds_pi8 (*m1, *m2); 


INFORMÁTICA 

16

MMX: Funciones Lógicas y de Bit 


• __m64 _mm_sll_pi16 (__m64 m, __m64 count): Hace un desplazamiento lógico 

de bits a la izquierda por separado a las 4 palabras de 16 bits del registro m. El 

número de bits que se desplazan se especifica en count. 

• __m64 _mm_sra_pi16 (__m64 m, __m64 count): Hace un desplazamiento 

aritmético a la derecha. El desplazamiento aritmético respeta el bit de signo 

introduce bit de signo por la izquierda, en lugar de ceros. 

• __m64 _mm_and_si64 (__m64 m1, __m64 m2): Hace un AND entre todos los bits 

de los registros m1 y m2. También está el equivalente con OR y XOR. No existe 

versión con menos bits no es realmente una instrucción SIMD. 

• __m64 _mm_andnot_si64 (__m64 m1, __m64 m2): Realiza la operación NOT(m1) 

AND m2. 

• __m64 _mm_cmpeq_pi8 (__m64 m1, __m64 p2): Compara cada byte de los 2 

registros. Pone 11111111 en cada par de bytes que sean iguales, y 00000000 en 

los que sean diferentes. También existe cmpgt, y ambas con 8, 16 y 32 bits. 


INFORMÁTICA 

17

MMX: Funciones de Inicialización 


• __m64 _mm_setzero_si64 (): Carga 0 en los 64 bits de un registro MMX. 

*p_mmx = _mm_setzero_si64(); 

• __m64 _mm_set_pi32 (int i1, int i2): Carga el valor i1 sobre la parte alta del 

registro MMX, e i2 sobre la parte baja. 

• __m64 _mm_set1_pi8 (byte b): Carga el mismo valor sobre los 8 bytes que 

componen el registro MMX. 


INFORMÁTICA 

18

MMX: Otras Funciones 


• void __mm_empty (void): Instrucción EMMS. 

Vacía el contenido de los 8 registros compartidos entre la FPU y la extensión MMX. 

Sirve para realizar un cambio de contexto entre ambos. 

Es muy costosa minimizar su uso agrupando convenientemente el código. 

Si estamos utilizando MMX, se debe usar esta antes de utilizar cualquier instrucción de 

la FPU. 

• __m64 _mm_cvtsi32_si64_si64 (int i): Convierte un valor entero de 32 bits en un 

valor de 64 bits para un registro MMX. 

• int _mm_cvtsi64_si32 (__m64 m): Convierte el valor de 64 bits de un registro 

MMX a un entero de 32 bits. 

• __m64 _mm_packs_pi32 (__m64 m1, __m64 m2): Empaqueta los dos valores de 

de 32 bits de m1 en los 2x16 bits menos significativos del resultado, y los dos 

valores de 32 bits de m2 en los 2x16 bits más significativos del resultado. 

• __m64 _mm_unpackhi_pi32 (__m64 m1, __m64 m2): La parte alta del resultado 

es la parte alta de m2, y la parte baja es la parte alta de m1. 


INFORMÁTICA 

19

MMX: Ejemplos 


• Desplazamiento aritmético a la derecha (división por 2) de 4 enteros, partiendo de 

un bucle desenrollado: 

for (i = 1; i > 1; 

data [i+1] = data [i+1] >> 1; 

data [i+2] = data [i+2] >> 1; 

data [i+3] = data [i+3] >> 1; 

} 

• Operación MAC: 

r1 = wr*data[j+1] – wi*data[j]; 

r2 = wr*data[j+1] + wi*data[j]; 


INFORMÁTICA 

for (i = 1; i

• SSE: 

#include “xmmintrin.h” 

Intrinsics para SSE y SSE2 

Nuevos tipos de datos: __mm128. 


__m128 __mm_add_ps (__m128 a, __mm128 b): Suma por separado los 4 valores en 

IEEE-754 de precisión simple (32 bits) de los registros XMM a y b. 

__mm_add_pd: doble precisión. 

• SSE 2: 

#include “emmintrin.h” 

Instrucciones para carga y almacenamiento de valores en coma flotante. 

Instrucciones con enteros de 128 bits. 

Instrucciones para manejo de la caché. 

Etc… 


INFORMÁTICA 

21

float* Vector1, Vector2, Resultado; 

int dimension = 100; 

for (int i = 0; i < dimension; i++ ) 

{ 

} 

*Resultado = (float)sqrt((*Vector1) * 

(*Vector1) + (*Vector2) * (*Vector2)) + 0.5f; 

Vector1++; 

Vector2++; 

Resultado++; 

Código adaptado de: 

http://www.codeproject.com/KB/recipes/sseint 

ro.aspx 

SSE: Ejemplo 


float* Vector1, Vector2, Resultado; 

int dimension = 100; 

int n_iter = dimension/ 4; 

__m128 m1, m2, m3, m4; 

__m128* pSrc1 = (__m128*) Vector1; 

__m128* pSrc2 = (__m128*) Vector2; 

__m128* pDest = (__m128*) Resultado; 

__m128 m0_5 = _mm_set_ps1(0.5f); // m0_5[0, 1, 2, 3] = 0.5 

for ( int i = 0; i < n_iter; i++ ) 

{ 

m1 = _mm_mul_ps(*pSrc1, *pSrc1); // m1 = *pSrc1 * *pSrc1 

m2 = _mm_mul_ps(*pSrc2, *pSrc2); // m2 = *pSrc2 * *pSrc2 

m3 = _mm_add_ps(m1, m2); // m3 = m1 + m2 

m4 = _mm_sqrt_ps(m3); // m4 = sqrt(m3) 

*pDest = _mm_add_ps(m4, m0_5); // *pDest = m4 + 0.5 

} 

pSrc1++; 

pSrc2++; 

pDest++; 


INFORMÁTICA 

22

Práctica 2 


• Optimización mediante extensiones MMX 

• Segunda práctica obligatoria. 

• Práctica por parejas. 

• Campus Virtual: 

Enunciado. 

Material de apoyo. 

Ejemplos de código. 

Fechas de entrega. 

• Se os dará un código ya hecho, que debéis optimizar 

utilizando extensiones SIMD y cualquier otro tipo de 

optimización bien documentada. 

• Si se detecta copia ¡Suspensa toda la convocatoria! 


INFORMÁTICA 

23

Tema 5: El Pentium a Fondo - DAC

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?