Esquemas iterativos en paralelo con OpenMP

CENTRO UNIVERSITARIO DE LA COSTA SUR
UNIVERSIDAD DE GUADALAJARA
DIVISIÓN DE DESARROLLO REGIONAL
DEPARTAMENTO DE INGENIERÍAS
INGENIERÍA EN TELEINFORMÁTICA
PARA OBTENER EL TÍTULO DE INGENIERO EN TELEINFORMÁTICA
BAJO LA MODALIDAD DE TITULACIÓN
TESIS
CON EL TÍTULO
“Esquemas Iterativos en Paralelo con OpenMP”
PRESENTA
Sotero Ordoñes Nogales
DIRECTOR
Dr. José Antonio Muñoz Gómez
ASESORES
Dr. Luis Isidro Aguirre Salas Dr. Omar Aguilar Loreto
Autlán de la Grana, Jalisco. Enero 2013

UNIVERSIDAD DE GUADALAJARA
CENTRO UNIVERSITARIO DE LA COSTA SUR
SECRETARÍA ACADÉMICA – COORDINACIÓN DE INGENIERÍA EN TELEINFORMÁTICA
Avenida Independencia Nacional # 151, Autlán de Navarro, Jalisco; C.P. 48900, Tels. (317) 382-50-10 Y 382-32- 00
http://www.cucsur.udg.mx
C. SOTERO ORDOÑES NOGALES
Egresado de la Carrera de Ingeniería en Teleinformática
P R E S E N T E
A través de la presente, se le informa que fue APROBADA su modalidad de
titulación de TESIS, para titularse de la carrera de Ingeniero en Teleinformática.
Así mismo, se le informa que estará asignado como Director al DR. JOSE
ANTONIO MUÑOZ GÓMEZ y DR. OMAR AGUILAR LORETO y DR. LUIS ISIDRO AGUIRRE
SALAS, como asesores.
Se anexa una guía con los temas que debe considerar para realizar dicho
documento y se le informa a su vez que tiene 8 meses a partir de la fecha del presente
para entrega del trabajo recepcional con el visto bueno del Director. Debe presentar
siete ejemplares impresos con una copia de este oficio en primer término. Además,
debe agregar portada y un formato específicos, solicitarlos antes de su entrega.
ATENTAMENTE
“PIENSA Y TRABAJA”
AUTLÁN DE NAVARRO, JAL. 04 DE DICIEMBRE DE 2012.
___________________________________________
M.T.A. CLAUDIA DIANE VACA GAVIÑO
COORDINADOR DE LA CARRERA DE INGENIERÍA Y DE TSU EN TELEINFORMÁTICA
C.C.P ARCHIVO

Dedicatorias y Agradecimientos
He llegado al final de una pequeña traves´ıa en el viaje de la vida; durante éste trayecto he
adquirido experiencias que han dejado estelas imborrables. Me permito mencionar a las dos personas
que se convirtieron en la estrella polar de este pobre marinero:
A Nora Marisol Chávez Guerrero,
...mi inspiración y motivación.
A mi padre, Luis Ordóñez D´ıaz
que siempre estará en mi recuerdo.
Hay personas que nos hablan y ni las escuchamos...
hay personas que nos hieren y no dejan ni cicatriz...
pero hay personas que simplemente aparecen en nues-
tra vida y nos marcan para siempre.
Cec´ılia Meireles

Un marinero no es nadie sin la ayuda de aquellos que lo han acompañado en el barco. Quiero
agradecer a esas personas con las que no sólo compart´ı este viaje, sino colaboraron en la toma del
rumbo, me refiero a la tripulación:
Mi familia y Dios
Por estar all´ı siempre apoyandome, toda la paciencia y esfuerzo que han realizado para ver cumplido
este sueño. Especialmente a mi señora madre a quien no me alcanzará toda una vida, ni cada una
de las palabras del mundo para agradecerte por todo lo que ha hecho por m´ı. A mis hermanos Juan,
Isabel, Angelina y Julio que sin la ayuda ésto no ser´ıa posible.
Dr Antonio
Gracias por ese apoyo incondicional no sólo durante la realización del presente documento; sino
también en el transcurso de mi formación profesional y personal dentro de ésta institución. Por la
paciencia y dedicación para aclarar los temas oscuros. Por permitirme utilizar las computadoras
para la evaluación de los resultados y la elaboración de la presente tesis.
Los doctores Luis Isidro y Omar
Gracias más que ser mis maestros ser mis amigos. Sus valiosas aportaciones y observaciones a la
presente tesis. Agradezco todas sus enseñazas que no sólo se limitaron a lecciones académicas sino
también de vida. Me es imposible citar textualmente las frases que me dijeron; pero la esencia la
conservo.
Para llevar a puerto ésta pequeña embarcación colaboraron muchas personas que por ahora me
es imposible nombrar a cada una de ellas; todos esos momentos que hicieron divertida la traves´ıa.
Como olvidar ésta tan acertada frase de uno de ellos:
...la universidad es como una espada, cuanto más la afilemos y practique-
mos...estaremos mejor preparados para enfrentar, al coyote que está al
asecho en el camino de la vida...
Luis Isidro Aguirre Salas

Índice general
Índice de figuras XI
Índice de tablas XIII
Resumen XV
1. Introducción 1
2. Marco Teórico 7
2.1. Métodos numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2. Modelación matemática . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3. Los números en la computadora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4. Tipos de error en métodos numéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5. El lenguaje de programación C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6. Programación en paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.7. OpenMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.8. Escalabilidad paralela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.8.1. Ley de Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8.2. Incremento de velocidad (speed-up) . . . . . . . . . . . . . . . . . . . . . . . 27
2.8.3. Desempeño computacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3. Producto matriz-vector Ax 31
3.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2. Loop unrolling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3. Cálculo del residual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4. Codificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.5. Incremento del desempeño . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.6. Procesamiento vectorial (SIMD) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.7. Codificación en paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.8. Evaluación de algoritmos en paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
ix

x Índice general
4. Método Iterativo de Jacobi 69
4.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.2. Codificación del método de Jacobi en C . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.2.1. Simplificando código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.2.2. Optimización de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.3. Método de Jacobi en paralelo con OpenMP . . . . . . . . . . . . . . . . . . . . . . . 87
4.4. Evaluación de algoritmo en paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5. Método de Gauss-Seidel 93
5.1. Concepto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.2. Programación en lenguaje C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.3. Codificación en paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.4. Gauss-Seidel versus Jacobi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6. Conclusiones y trabajo a futuro 109
Bibliograf´ıa 113

Índice de figuras
2.1. Distribución de números enteros con formato predefinido. . . . . . . . . . . . . . . . 10
2.2. Distribución de números reales con formato predefinido. . . . . . . . . . . . . . . . . 12
2.3. Modelo para representación de números en punto flotante IEEE 754. . . . . . . . . . 13
2.4. Cálculo de epsilón de la computadora. . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5. Rango de número IEEE-754 precisión simple. . . . . . . . . . . . . . . . . . . . . . . 15
2.6. Arquitectura de hardware CPU versus GPU. . . . . . . . . . . . . . . . . . . . . . . 21
2.7. Tipos de memoria en sistemas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.8. Modelo de OpenMP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.9. Modelo de ejecución de programas paralelos. . . . . . . . . . . . . . . . . . . . . . . 26
2.10. Speed-up con Ley de Amdahl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.1. Cálculo del residual en C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2. Implementación canónica de Ax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3. Técnica Loop Unrroll con factor 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.4. Técnica Loop Unroll con factor 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.5. Técnica Loop Unroll con factor 2, dos ciclos for. . . . . . . . . . . . . . . . . . . . . 42
3.6. Técnica Loop Unroll con factor 2, dos variables. . . . . . . . . . . . . . . . . . . . . . 42
3.7. Técnica Loop Unroll con factor 2, dos ciclos for y dos variables. . . . . . . . . . . . . 43
3.8. Técnica Loop Unroll con factor 2, cuatros ciclos for cuatro variables. . . . . . . . . . 43
3.12. Técnica Loop Unroll con factor 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.13. Técnica Loop Unroll con factor 12. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.14. Speed-up para la multiplicación de dos vectores. . . . . . . . . . . . . . . . . . . . . 48
3.15. Función general de la multiplicación Ax con Unroll. . . . . . . . . . . . . . . . . . . 50
3.16. Speed-up de Ax utilizando la técnica de Unroll. . . . . . . . . . . . . . . . . . . . . . 51
3.17. Rendimiento computacional de Ax al utilizar la técnica de Unroll. . . . . . . . . . . 52
3.18. Modelo SIMD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.19. Función en MMX que multiplica dos vectores x y y. . . . . . . . . . . . . . . . . . . 55
3.20. Desempeño de Ax al utilizar MMX con bandera de compilación -O2. . . . . . . . . . 59
3.21. Implementación canónica en paralelo de Ax. . . . . . . . . . . . . . . . . . . . . . . . 60
xi

xii Índice de figuras
3.22. Rendimiento de la versión canónica de Ax en paralelo con bandera de compilación -O2. 62
3.23. Implementación general de Ax en paralelo. . . . . . . . . . . . . . . . . . . . . . . . 62
3.24. Desempeño de la versión canónica de Ax con banderas de compilación. . . . . . . . . 63
3.25. Escalabilidad paralela de Ax en su la versión Unroll-10 con bandera -O2. . . . . . . 64
3.26. Escalabilidad paralela de Ax en su la versión MMX con bandera -O2. . . . . . . . . 65
3.27. Comparativa del rendimiento computacional de las versiones canónica, Unroll-10 y
MMX con bandera de compilación -O2. . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.1. Primera implementación del método de Jacobi en lenguaje C. . . . . . . . . . . . . . 82
4.2. Código en lenguaje C del esquema de Jacobi. . . . . . . . . . . . . . . . . . . . . . . 83
4.3. Porcentaje del tiempo de ejecución del método de Jacobi con y sin sentencia if. . . . 84
4.4. Código general de Jacobi optimizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.5. Tiempos de ejecución de Jacobi en serie, versiones [Canónica, Unroll4, MMX] para
n = 5000. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.6. Código de versión canónica en paralelo de Jacobi. . . . . . . . . . . . . . . . . . . . . 88
4.7. Speed-up del método de Jacobi en paralelo en su versión canónica. . . . . . . . . . . 89
4.8. Speed-up del método de Jacobi en paralelo en su versión MMX. . . . . . . . . . . . . 90
5.1. Método de Gauss-Seidel en lenguaje C, versión canónica. . . . . . . . . . . . . . . . . 97
5.2. Método de Gauss-Seidel con OpenMP. . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.3. Descomposición del vector solución x para dos procesadores. . . . . . . . . . . . . . . 99
5.4. Escalabilidad paralela del método Gauss-Seidel versión canónica. . . . . . . . . . . . 101
5.5. Método de Jacobi con diferencias finitas. . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.6. Método de Gauss-Seidel con diferencias finitas. . . . . . . . . . . . . . . . . . . . . . 104
5.7. Aproximación numérica a u(x, y) = sen x cos y con Gauss-Seidel. . . . . . . . . . . . . 106

Índice de tablas
2.1. Unidades de medida de FLOPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1. Producto de dos vectores: resultados de prueba de exactitud, observamos las veces
que es más exacta, mostrada en porcentaje ( %), cada función durante las iteraciones
para cada valor de n. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2. Producto de dos vectores: resultados de prueba de velocidad, observamos la tasa de
exactitud de cada función con respecto al número de iteraciones (10,000). . . . . . . 45
3.3. Producto de dos vectores: comparación de rendimiento de las funciones canónica,
MMX y Unroll-4; observamos el rendimiento que nos brinda la función en MMX
respecto a la forma tradicional y en comparación con la función con Unroll de 4. . . 58
4.1. Método iterativo de Jacobi: primera evaluación de rendimiento, observamos el por-
centaje de la reducción del tiempo en ejecución cuando se remueve la condición (if). 85
5.1. Método de Gauss-Seidel en paralelo; iteraciones para converger. . . . . . . . . . . . . 100
5.2. Convergencia de Gauss-Seidel vs Jacobi. . . . . . . . . . . . . . . . . . . . . . . . . . 105
xiii

Resumen
El presente trabajo de tesis aborda la creación de algoritmos paralelos para la solución numéri-
ca de sistemas de ecuaciones lineales mediante esquemas iterativos de tipo Jacobi y Gauss-Seidel;
con especial énfasis en el rendimiento y la escalabilidad. Este documento se centra en dos aspec-
tos principales. En un primer momento, estudiamos la implementación de técnicas avanzadas de
programación para maximizar el rendimiento en ejecuciones seriadas. Una de las técnicas permite
utilizar módulos de procesamiento vectorial del procesador con la finalidad de realizar varias ope-
raciones a la vez; es decir, conseguir paralelismo a nivel de datos (conocido como SIMD). También
se utilizan caracter´ısticas del compilador GCC para optimizar el código y catapultar el rendimiento
serial de estas primeras funciones. En un segundo momento, se realiza un estudio exhaustivo de
cada uno de los métodos que permitan escribir funciones que realmente puedan ser ejecutadas en
más de un núcleo utilizando el API llamada OpenMP apoyado con los resultados de las técnicas
utilizadas (Bandera de compilación, Loop unrolling, SIMD). En general con el estudio realizado
observamos una escalabilidad lineal de dos a cuatro procesadores. Por otro lado cuando empleamos
ocho procesadores se observa un aumento de 5.4x.
xv

Cap´ıtulo 1
Introducción
Una de las herramientas más valiosas para la resolución de problemas prácticos de Ingenier´ıa son
las computadoras digitales mediante la utilización de métodos numéricos. En un número significativo
de esos problemas sólo se puede obtener una solución aproximada, a esto se debe la importancia del
estudio de la rama de las matemáticas llamada análisis numérico. Esta rama involucra el estudio
de métodos numéricos. El desarrollo de éstos esquemas es notablemente influenciado y determinado
por las computadoras, las cuales permiten realizar los cálculos de manera veloz, confiable y sobre
todo flexible.
En la actualidad la computadora es una herramienta indispensable para las actividades coti-
dianas, escolares, de oficina y cient´ıficas. Con necesidades cada vez más complejas, es por ello que
se busca que las aplicaciones puedan realizar los cálculos lo más rápido posible aprovechando los
recursos del equipo con la mayor eficiencia posible.
En el pasado para cubrir con las necesidades del mercado se incrementaba la velocidad del
procesador, aumentando el número de transistores al circuito integrado. Como lo previó Gordon
Moore, en la actualidad, ya no es posible disminuir el tamaño de los transistores. Para compensarlo
se han construido procesadores que tienen más de un núcleo de procesamiento (2, 4, 8, 12). Las
computadoras de uso general que están en el mercado al momento de la realización del presente
trabajo cuentan con procesadores paralelos, es decir tienen más de un núcleo de procesamiento.
Esta cualidad indica que el cómputo en paralelo está a disposición de todos.
Cuando la arquitectura del hardware de las computadoras pasó a ser paralelo se creó la necesidad
de desarrollar aplicaciones que aprovechen éstas caracter´ısticas. La incorporación de núcleos de
1

2 Cap´ıtulo 1. Introducción
procesamiento tienen el fin de que las aplicaciones se ejecuten más rápido. Para ejemplificar el
problema supóngase lo siguiente: se quiere extraer el agua de un tanque que tiene 1, 000 m3 para
ello se utiliza una bomba que extrae 250 m3 del l´ıquido por cada hora de trabajo. Esta máquina
terminará su tarea en 4 horas. Si en un momento se aumenta 7 bombas más para hacer un total
de 8, la tarea será concluida en apenas 30 minutos, con ello se redujo el tiempo del proceso. Esto
refleja la importancia del cómputo en paralelo. Con lo ya mencionado el cómputo en paralelo es la
solución a problemas contemporáneos.
Cabe mencionar que en la actualidad la mayor´ıa de las aplicaciones son seriales, es decir se
ejecutan solo en uno de los núcleos; entonces estos programas no están aprovechando al máximo los
recursos con los que cuenta el equipo. Para contrarrestarlo se fomenta el deseo de escribir códigos
que puedan ejecutarse en paralelo.
Una pregunta que surge con lo mencionado; ¿En qué nos beneficia la programación en paralelo?
La respuesta es por demás sencilla. En el mundo de la industria manufacturera se realizan procesos
de control de calidad, en los cuales se recurre a la simulación de eventos mediante computadoras.
Estas medidas son cada d´ıa más frecuentes. Un ejemplo más que evidente ocurren en la industria
automotriz en la simulación de sus prototipos frente a las colisiones. Hacer estas pruebas en f´ısico
representa un costo económico muy representativo; es por ello que se recurre a la simulación del
evento con resultados fidedignos. Para obtener estos resultados tan realistas se deben tomar en
cuenta muchas variantes que influyen en los resultados del proceso, todo esto aumenta la complejidad
de operaciones en modelo del suceso. El costo computacional de un modelo depende del grado
de complejidad operacional. Con ello es concluyente que estas simulaciones deben ser resueltas
con programación en paralelo, para reducir los tiempos de simulaciones y as´ı reducir el ciclo de
lanzamiento de los nuevos modelos; lo cual es primordial para la generación de utilidades de la
industria automotriz.
Motivación
La principal motivación del presente proyecto consiste en explotar al máximo lo recursos que
ofrecen las computadoras; mediante tecnolog´ıas para la programación en paralelo.
En los labores de la ingenier´ıa y en la ciencia en general se formulan problemas mediante modelos
matemáticos y son tratados numéricamente, ello conduce frecuente a resolverlos por sistemas de

Cap´ıtulo 1. Introducción 3
ecuaciones lineales. Como es bien sabido esta tarea es muy demandante en tiempo de cálculo. En
virtud de ello y con base a la tendencia del análisis numérico es inherente que sean resueltos con
aplicaciones computacionales paralelas.
Para la resolución de sistemas de ecuaciones lineales existen dos tipos de métodos; directos e
iterativos. Los métodos directos son utilizados para sistemas hasta de pocos miles de nodos debido
a su orden de complejidad; ocasionando que sea imposible el resolverlo por cuestiones de tiempo.
Por otra parte los métodos iterativos se utilizan para sistemas con una mayor cantidad de nodos en
virtud de su orden de complejidad que es menor a la de los directos. Dentro de los métodos iterativos
se encuentran el de Jacobi y Gauss-Seidel que son los dos pilares fundamentales. En la presente tesis
se estudia el diseño de dos algoritmos paralelos que implementen los esquemas de Jacobi y Gauss-
Seidel. En la literatura existen algoritmos iterativos paralelos reportados, sin embargo no existe
código fuente por ello en el presente documento se dá énfasis al desarrollo de éstos algoritmos desde
un punto de vista práctico con la finalidad de proporcionar ese código fuente.
En la literatura hemos encontrado distintos modelos matemáticos y esquemas en paralelo con
OpenMP para la resolución de sistemas lineales de ecuaciones [21, 26, 35, 36]. Sin embargo, se
enfocan principalmente a sistemas ralos o esparcidos y tipo QR o de Cholesky. Esto se debe princi-
palmente a que las discretización de ecuaciones diferenciales parciales (EDP) esta basada principal-
mente en los métodos de elemento finito, volumen finito y diferencia finita los cuales generan este
tipo de matrices.
En el desarrollo profesional de métodos numéricos se busca la innovación para poner a disposición
el nuevo software. Existen una gran variedad de librer´ıas públicas para la optimización de código,
ejemplos son BLAS (Basic Linear Algebra Subprograms) y LAPACK (Linear Algebra Package)
que permiten la optimización para programas secuenciales. Dentro de las arquitectura multicore
encontramos en el top las librer´ıas espec´ıficas Intel R Math Kernel Library, CUBLAS y CULA de
CUDA R ; están altamente optimizadas para sus respectivas arquitecturas de hardware. En general,
el uso de estos paquetes de optimización no son utilizadas en el desarrollo del software comercial,
excepto para la construcción de programas muy especializados o en proyectos que se encargan de
aglomerar todas estas optimizaciones como por ejemplo PLASMA (Parallel Linear Algebra Software
for Multiprocessor Architectures).
Proyectos como FLAME (Formal Linear Algebra Methods Environment) y PLASMA reflejan

una fuerte tendencia de encapsular y abstraer el código lo que facilita el trabajo del programador. En
el caso de FLAME se abstrae el hardware dando mayor portabilidad a estas aplicaciones; haciendo
transparente el hardware, lo que permite ejecutar una implementación en cualquier arquitectura.
Además permite utilizar todos los recursos disponibles CPU y GPU.
Al abstraer el código se aumenta la dificultad para la optimización más espec´ıfica de las apli-
caciones. Además la falta de código fuente que pueda ser analizado y/o modificado; limita la parte
académica. Estas librer´ıas se asemejan a las “cajas negras” porque no sabemos que hay dentro y
por tanto no aprendemos de ellas.
Lo anterior dicho, motiva que el presente trabajo se dirija al estudio e implementación de los
dos pilares de los métodos iterativos, con herramientas públicas; con fines académicos. Esto se debe
a que el estudio de los métodos iterativos de Jacobi y Gauss-Seidel tiene fines didácticos y conforma
la base de estudio para las técnicas modernas de métodos numéricos. En la actualidad el software
especializado y la investigación de frontera emplean métodos proyectados sobre subespacios de tipo
Krylov[1, 2, 16, 22, 38], ejemplos de software especializado son las librer´ıas de Portable Extensible
Toolkit for Scientific computation (PETSc) con implementaciones paralelas [4, 34, 42]. El estudio
de ello está fuera del alcance de la presente memoria.
Objetivo general
La presente tesis tiene como objetivo el desarrollo de esquemas iterativos en paralelo con
OpenMP para la solución numérica de sistemas de ecuaciones lineales. Para ello emplearemos una
computadora con arquitectura de tipo multi-núcleo con memoria compartida y utilizamos el lenguaje
de programación C.
Objetivos particulares
A continuación se listan los objetivos espec´ıficos que serán tratados durante la realización del
presente documento:
1. Diseñar e implementar el método de Jacobi y Gauss-Seidel en paralelo para resolver sistemas
de ecuaciones lineales.
2. Incrementar el rendimiento computacional mediante técnicas avanzadas de programación.

Cap´ıtulo 1. Introducción 5
3. Medir el desempeño de los algoritmos diseñados para cuantificar los beneficios del paradigma
de programación.
4. Medir la escalabilidad de los algoritmos diseñados en computadoras multi-núcleo.
5. Crear un biblioteca de funciones que permitan resolver numéricamente sistemas de ecuaciones
lineales en paralelo para computadoras SMP.
Al término de la presente tesis se habrán cumplido con los objetivos planteados; los cuales
pondrán en evidencia los beneficios mediante el incremento del rendimiento por paralelizar métodos
numéricos. Con los resultados obtenidos se busca motivar la incipiente tendencia de generalizar la
programación en paralelo.
La estructura del presente trabajo de tesis está organizada en seis cap´ıtulos que se describen a
continuación.
En el primer cap´ıtulo, el presente, se describen los objetivos que permitirán llevar a buen término
el proceso de elaboración de la presente memoria. También se mencionan las razones que dan
importancia a este estudio.
Enseguida, en el tema 2 se plantea un marco teórico que le permita al lector familiarizarse
desde un punto de vista general, con los conceptos que se tratan durante el restos de los cap´ıtulos.
Aunado a ello se realiza una breve descripción de las técnicas y herramientas tecnológicas que serán
utilizadas. Se indican temas de vital importancia para la evaluación de algoritmos en paralelo como
lo son Speed-up, Ley de Amdahl y Escalabilidad paralela, as´ı como la representación de los números
reales en la computadora. También se da un breve introducción que intuye a la comprensión del
error en los métodos numéricos.
En el cap´ıtulo 3 tratamos uno de los problemas más básico pero de importancia muy relevante,
el Producto matriz-vector. Se pone un especial cuidado en el estudio de éste tema por representar
un proceso muy demandante de tiempo de cálculo. Se emplean modernas técnicas de programación
como Loop unrolling y procesamiento vectorial con Intel MMX R para explotar nuevas caracter´ısti-
cas de los microprocesadores; para determinar cual representa la mejor opción en paralelo. Cabe
señalar que en este bloque se estudia el Cálculo del residual una técnica utilizada como condición
de paro en los esquemas iterativos.
Posteriormente en el cap´ıtulo 4 se estudia el Método iterativo de Jacobi, en primer lugar se tratan
algunos de los métodos directos para la solucion de sistemas lineales de ecuaciones más conocidos,

Regla de Krammer, Eliminación de Gauss-Jordan y la Factorización LU para determinar los pros
y contras de ambas categor´ıas (métodos directos e iterativos). Después se realiza una descripción
del esquema y consecuentemente la programación. Con el único fin de aumentar el rendimiento se
realiza una serie de optimizaciones basadas en los resultados del tema anterior. Al final de este
cap´ıtulo se realiza una evaluación exhaustiva que arroja resultados muy concretos con respecto a
las modificaciones realizadas en cada uno de los subtemas.
En el cap´ıtulo 5 tratamos el Método Iterativo de Gauss-Seidel (G-S), en primer lugar se da una
descripción del método con vistas hacia la programación del mismo. En segundo lugar se implementa
OpenMP prestando especial antención en la dependencia de operaciones a las que esta sujeto G-S.
En un tercer momento se realiza una comparación con diferencias finitas para medir convergencia
de Jacobi y G-S, lo cual permita enmarcar las diferencias teóricas de ambos.
Finalmente en el cap´ıtulo 6 mostramos las conclusiones generales y el trabajo a futuro.

Cap´ıtulo 2
Marco Teórico
2.1. Métodos numéricos
En palabras de Chaillou [9] son las técnicas mediante las cuales es posible formular problemas
de manera que puedan resolverse utilizando operaciones aritméticas.
Es importante el estudio de los métodos o esquemas numéricos porque representan una herra-
mienta importante para el análisis y diseño de algoritmos que permiten la resolución de problemas
de la ciencia. Existe una extensa gama de esquemas numéricos para la resolución de gran parte de
los problemas. Sin embargo, con el mismo método no se puede resolver todos problemas; por ello es
indispensable el análisis de un grupo de candidatos con el fin de determinar cual de ellos es el más
indicado para el problema que se esté estudiando.
Como menciona Penadés [33] con la aparición de los multiprocesadores se presenta un nuevo reto,
adecuar los antiguos algoritmos para las nuevas tecnolog´ıas; entre las que destaca la computación
matricial. Pero esta nueva tendencia también sugiere y motiva la búsqueda de métodos nuevos que
se adecuen mejor a la vanguardia tecnológica con el fin de aumentar el rendimiento computacional
para la resolución de ciertos problemas.
2.2. Modelación matemática
Una definición muy simple es la proporcionada por Chaillou en [9] la cual dice: un modelo
matemático es una formulación o ecuación que expresa las caracter´ısticas fundamentales de un
7

8 Cap´ıtulo 2. Marco Teórico
sistema o proceso f´ısico en términos matématicos. Esto nos indica que un modelo corresponde a
una explicación de un proceso de un forma simple, lo cual conduce a resultados predecibles.
Los modelos matemáticos sirven para obtener cierta información de un problema que se esté estu-
diando; si bien en cierto que frecuentemente contienen errores que ponen en evidencia componentes
esenciales de una realidad compleja [9]. Existe un clasificación de tipos de modelos matemáticos en
función a su área de estudio; estos temas no son tratados con la profundidad necesaria debido que
no es la finalidad del presente trabajo.
2.3. Los números en la computadora
En el mundo real existen varios sistemas numéricos entre los que destacan los sistemas arábico,
binario, octal, hexadecimal. El más utilizado por todo ser humano es el arábico o mejor conocido
como decimal. Por otro lado el sistema numérico de las computadoras es el binario para describir los
estados encendido (1) apagado (0); as´ı un d´ıgito binario o bit es la unidad de información más básica
en la computadora. Debido a que los humanos utilizamos el sistema decimal y las computadoras
el binario se hizo necesario realizar conversiones de números entre ellos. Fue Gottfried Leibniz
(1646–1716) quien desde siglos pasados lo hab´ıa resuelto. Leibniz argumentó que cualquier número
entero puede ser representado por una serie de unos y ceros.
En documentos como [29, 37] se emplea el formato mantisa/exponente para representar números
binarios tomando la idea de la notación cient´ıfica. Como se muestra en (2.1)
1010 = 10.010 × 100 = 1.010 × 101 = 0.110 × 102
10102 = 1010.02 × 20 = 101.02 × 21 = 10.102 × 22
(2.1)
El manejo de los números en la computadora es mediante la notación cient´ıfica del sistema
binario.1 Sin embargo, los formatos que se utilizan permiten representar los números como en (2.1)
sin escribir de forma expl´ıcita el punto decimal. El formato signo/mantisa/exponente se expresa
1
El sistema numérico de la computadora se debe a la arquitectura de la misma. Recordando que existen compu-
tadoras binarias, octales y hexadecimales. Las computadoras comerciales son binarias.

2.3. Los números en la computadora 9
como una palabra con las siguientes caracter´ısticas para un valor x
x =
signo
s e1e2e3 . . . ek
exponente
mantisa
m1m2m3m4 . . . mn (2.2)
Sabiendo que cuando el bit de s esté encendido se trata de un número negativo. Tomando como
referencia (2.2) la longitud de la palabra que equivale a (1 + k + n) donde los valores de k y n
son definidos por el diseñador y 1 representa el bit s del signo; para definir los valores de k y n
es imprescindible pensar en la exactitud con lo que se representarán los número reales, as´ı como
analizar el costo computacional que representa. Para ejemplificar tomaremos un formato de 8 bits
como sigue
x =
signo
b1 b2 b3 b4
exponente
mantisa
b5 b6 b7 b8 (2.3)
Partiendo de (2.3) representemos 1010 = 10102 con cuatro bits. Con el formato en cuestión
puede ser representado como sigue
x =
sig
0 0 0 1
exp
man
1 0 1 0 = 10102 × 21
= 1010
Ahora tomando un valor mayor por ejemplo 6410 = 10000002, lo cual en notación cient´ıfica se
expresa como 1000 × 23 y se representa como sigue
x =
sig
0 0 1 1
exp
man
1 0 0 0 = 10002 × 23
= 6410
Para representar un número negativo por ejemplo −1810 se realiza lo siguiente
x =
sig
1 0 1 0
exp
man
1 0 0 1 = −1 × 10012 × 22
= −1810
Como se puede observar el valor más grande y el menor que se pueden representar son
xmax = 0 111 1111 = 1 × 11112 × 27 = 192010
xmin = 1 111 1111 = −1 × 11112 × 27 = −192010

Para exponer el formato de (2.3) ante una situación cotidiana en el cálculo intensivo tomemos
el número 2710 = 110112 como sabemos tenemos sólo cuatro bits de mantisa y este nuevo número
tiene 5 bits, lo cual tomamos los 4 bits más significativos y tenemos lo siguiente
x =
1
0 0 1 0
2
13
1 1 0 1 = 1 × 11012 × 22
= 2610
Ello no es equivalente con el número que se trata de representar y el siguiente ser´ıa
x =
1
0 0 1 0
2
14
1 1 1 0 = 1 × 11102 × 22
= 2810
Con ello es más que evidente que no se puede representar el número 27 utilizando el formato de
(2.3). Pero ésto no significa que sea el único. En la figura 2.1 se ilustra los números que se pueden
representar con éste formato. Las l´ıneas verticales (|) indican la posición en la linea recta de cada
uno de los números, por lo que no existen números en los espacios entre las l´ıneas. Como se puede
observan la mayor densidad de números está en los aledaños de cero y conforme nos alejamos la
densidad disminuye.
−2000 −1500 −1000 −500 0 500 1000 1500 2000
Figura 2.1: Distribución de números enteros con formato predefinido.
Bien, con el formato de (2.3) se han representado números enteros pero con un aspecto impor-
tante, existen números que pueden ser representados de más de una forma lo cual no es bueno.2
Con lo anterior se han representado números enteros de una forma no ortodoxa pero nos brinda
un primer acercamiento para representar números reales. Tomando la idea del formato (2.3) y con
base a Hidalgo [19, Apéndice E] se realiza una modificación simple que se expresa en (2.4)
x =
signo
b1 b2 b3 b4
exponente
bimp b5 b6 b7 b8
mantisa
(2.4)
donde la mantisa trata la parte fraccionaria del número [ver (2.1)] y bimp es un bit impl´ıcito que
2
Nota: con este formato se han representado números enteros única y exclusivamente para exponer el formato
mantiza/exponente y no representa el verdadero formato para la representación de enteros en la computadora.

actúa as´ı
si 0 < exp < 7, entonces bimp = 1.
si exp = 0 y mantisa = 0, entonces bimp = 0.
También se establece la necesidad de representar los exponentes con signo por ello se indica lo
siguiente
si 0 < exp < 7, entonces exp = exp - 3.
si exp = 0 y mantisa = 0, entonces exp = -2.
Con base a ello se establece que para un valor x se obtiene como sigue
x = (−1)s · 2exp−3 · 1.mantisa para 0 < exp < 7 y
x = (−1)s · 2−2 · 0.mantisa para exp = 0
donde exp es el valor del exponente, s el signo y [(0 : 1).mantisa] es el bit impl´ıcito (bimp) y el valor
de las mantisa (b5b6b7b8).
La idea anterior hace que el número 010110012 con el formato (2.4) se convierte en decimal de
la siguiente forma
x =
s=0
0
signo
exp=5
1 0 1
exponente
bimp.mantisa=1.5625
bimp 1 0 0 1
mantisa
= (−1)0
· 25−3
· 1.5625 = 6.2510
Ahora se convierten x1 = 111010102 y x2 = 000001102 a decimal como sigue
x1 = 11101010 = (−1)1 · 26−3 · 1.625 = −1310
x2 = 00000110 = (−1)0 · 2−2 · 0.375 = 0.0937510
Como se puede observar el cambiar el formato de representación de los números hace que los
valores al convertirlos a decimal sea distinto. En la figura 2.2 se ilustra la distribución de los números
representables con éste formato, donde se puede observar que la densidad de la ret´ıcula cercas del
cero es muy alta. Conforme nos alejamos de cero la cantidad de números representables disminuye.

−16−15.0 −10 −5 0 5 10 15 16
Figura 2.2: Distribución de números reales con formato predefinido.
Con los dos ejemplos planteados se tiene una idea más concreta de la representación de los
números mediante una serie de bits. En ambos casos se utilizó 8 bits como longitud de palabra. Sin
embargo el resultado es distinto pero con similitudes. La mayor densidad de números representables
están cercas del cero y en los extremos existe una menor densidad. En el primer ejemplo se repre-
sentaron números enteros con un rango (-1920,1920) mientras que en el segundo se representaron
números reales en un rango de (-15.5,15.5). Es evidente la imposibilidad de representar la totalidad
de los números con una longitud de palabra finita.
La representación de los numéros reales (números con fracción de entero) en la computadora
fue en su momento un tema hermético en cada una de las empresas manufactureras de las mismas.
El hermetismo era a tal grado que las empresas ten´ıan su propio protocolo, lo que limitaba la por-
tabilidad. Como menciona Severance et al.[37] esos formatos para representar números en punto
flotante se enfocaron primordialmente en la exactitud y no tanto en un balance entre exactitud y
velocidad. Con base a Null et al.[29] la solución para ello llegó en 1985 por parte del Instituto de
Ingenieros Eléctricos y Electrónicos (IEEE por sus singlás en inglés) que produjeron un estándar
para representar número en punto flotante para simple y doble precisión, el estándar se tituló “IEEE
754-1985 Standard for Binary Floating-Point Arithmetic”. El nuevo estándar tuvo sus inicios du-
rante el diseño del coprocesador para punto flotante Intel i8087 [37]. Pasaron más de 10 años para
que los grandes fabricantes adoptaran el IEEE 754 de forma generalizada en la contrucción de
computadoras.
En la figura 2.3 se ilustra como se representan dos tipos de números definidos en el estándar de
IEEE. Como se puede observa el formato es signo/exponente/mantisa al igual que en el segundo
ejemplo. (A) es un formato que en el lenguaje de programación C se le conoce como float donde
se tienen 23 bits de mantisa y 8 de exponente. (B) corresponde la primitiva double en el lenguaje
de programación C que corresponde a 52 bits de mantisa y 11 bits; es más comúnmente conocido
como doble precisión cient´ıfica.
Según Severance et al.[37] en precisión simple el menor número normalizado es 1.2E-38 y

Figura 2.3: Modelo para representación de números en punto flotante IEEE 754.
2.2E-308 con doble precisión. Mientras que el número más grande para simple y doble es 3.4 E+38
y 1.8 E+308 respectivamente. Ello nos brinda un marco de trabajo más amplio y con errores más
pequeños.
Con base en Null y Severace [29, 37] éste estándar incorpora NaNs (Not a Number, no es
número) cuando el exponente sea igual a 255 y la mantisa no sea cero (exp = 255 y mantisa = 0),
los NaNs son utilizados como indicadores de error. También incluye dos infinitos (−∞ y +∞) que
se presentan cuando el exponente es 255 y la mantisa es 0, positivo cuando el signo es 0 y negativo
cuando es 1. Al igual que en el caso de infinito, se tienen dos ceros uno positivo y otro negativo.
En el presente documento se utilizan número de precisión simple como el formato (A) de la figura
2.3 mientras no se indique lo contrario. Como se ha especificado ese formato tiene una longitud de
32 bits para la representación de los números por lo cual se pueden representar la siguiente cantidad
de números (n)
n = 232
= 4 294 967 296
De acuerdo con la definiciones anteriores para el caso donde el exponente es igual a 255 todos
los números son considerados NaNs, excepto cuando la mantisa es 0; este caso se presenta dos veces
para −∞ y +∞ respectivamente. Con base a ello podemos obtener la cantidad de NaNs que se
representan
NaNs = 2 × 223
− 2 = 16 777 214
Para obtener el total de número representables con precisión simple sustraemos lo NaNs del

total n
Total de reales representables = 4 294 967 296 − 16 777 214 = 4 278 190 082
De antemano sabemos que existe una diferencia entre el cero y el primer número que puede ser
representado, haciendo el número más pequeño posible tendremos el menor número distinto de cero
que puede ser representable como sigue
x =
signo
0
exponente
000 0000 0
mantisa
000 0000 0000 0000 0000 00012 = (−1)0 × 2−126 × 2−23 = 2−149
x 1.4 × 10−45
Como menciona Nakamura [28] al número representable inmediatamente después de la unidad se
le conoce como el epsilón de la computadora el cual nos permite calcular el número real representable
inmediatamente posterior; ésto se obtiene al multiplicar el epsilón por el real y sumarlo a ese real.
Para calcular el epsilón se puede utilizar el fragmento de código de la figura 2.4. En ese código sólo
hace falta indicar el tipo de variable que es “epsilon” (simple o doble). El último valor impreso
corresponde al epsilon de la computadora. Para una ejecución con precisión simple (float) se tiene
epsilón 1.1921 × 10−7, en el otro caso (double) epsilon 2.2204 × 10−16. Cabe señalar que el
denominador para calcular el epsilón es dos porque la computadora empleada es binaria.
Cálculo del epsilón
epsilon = 1;
while(1+epsilon>1)
{
printf("%fn",epsilon);
epsilon = epsilon/2;
}
Figura 2.4: Cálculo de epsilón de la computadora.
Para corroborar que efectivamente el epsilón de la computadora sirve para calcular la distancia
entre un número real representable y su inmediatamente consecuente tomaremos el siguiente ejemplo
x1 =
signo
0
exponente
000 0000 1
mantisa
100 0000 0000 0000 0000 00002 = (−1)0 × 21−127 × 1.5
x1 = (−1)0 × 2−126 × 1.5 1.7632415262 × 10−38

Ahora multiplicamos x1 por el epsilón para obtener la diferencia (y) tomando más cifras signi-
ficativas para disminuir el error
x1 1.7632415262 × 10−38 y epsion = 1.1921 × 10−7
y = x1 × epsilon
y 1.7632415262 × 10−38 × 1.1921 × 10−7
y 2.1019602234 × 10−45
xα
2 = x1 + y = 1.7632415262 × 10−38 + 2.1019602234 × 10−45
xα
2 = 1.7632417364 × 10−38
Posteriormente se calcula el valor para x2 tomando el siguiente número de la serie como sigue
x2 =
signo
0
exponente
000 0000 1
mantisa
100 0000 0000 0000 0000 00012 = (−1)0 × 21−127 × 1.5 + 2−23
x2 1.7632416664 × 10−38
Con estos resultados podemos decir que xα
2 = x2, donde el error se debe en gran medida a la
cantidad de cifras significativas tomadas en cuenta. Con base a los temas anteriores es concluyente
que la distancia entre un número representable y su inmediatamente posterior crece conforme se
aleje de cero.
Figura 2.5: Rango de número IEEE-754 precisión simple.
En la figura 2.5 se muestra el rango en el cual podemos representar números con el estándar
IEEE-754. Siempre pensando que la mayor densidad de números están aledaños al cero. Visualizar
el rango nos permite mapear los números para no caer en valores underflow u overflow e inclusive
elegir el tipo de precisión con la finalidad de tener una mayor exactitud.
La incapacidad para poder representar la totalidad de los números conlleva a tener resultados

numéricos aproximados. Ella es como una enfermedad con la que se nace; sino es tratada puede ser
letal.
2.4. Tipos de error en métodos numéricos
En análisis numérico un tema de vital importancia es el estudio del error en un resultado
numérico. Esto se debe principalmente a que los datos de entrada no son exactos; también influye que
los métodos numéricos introducen errores de varios tipos; por ello los resultados son aproximados.
Como menciona Chaillou [9] en muchos casos profesionales los errores son costosos y en algunos
letales. A continuación se presentan los principales errores introducidos por los esquemas numéricos.
Error de redondeo: este tipo de error se presenta debido a la cantidad de cifras significativas
que se asignan para las operaciones. En términos de computación este error es muy común y
depende de la exactitud de la primitiva utilizada (precisión simple, doble precisión, etc.), para
la representación de los números reales en la máquina. Para tener una idea más clara tomemos
en cuenta un número real x con k cifras en punto flotante, lo cual se representa como
x = 0.d1d2 . . . dk × Bn
donde B es la base del sistema
dado que únicamente se tienen t cifras significativas, siendo t < k, el número real será repre-
sentado como sigue
˜x = 0.d1d2 . . . dt × Bn
con ello se han perdido k − t cifras del valor real de x con lo cual ˜x es una aproximación de
x. A continuación se muestra un ejemplo
x = 1.2345678 con t = 4 se tiene ˜x = 1.2345
Este error es inherente a la computación como consecuencia de la imposibilidad de representar
totalmente los números reales. Para disminuir este error se aumenta el tamaño de la mantisa
de bits (aumentar k), as´ı se tendrán más cifras para la representación de los números; pero
ello repercutirá en un aumento en el costo de cálculo.
Error por truncamiento: este tipo de error aparece como consecuencia de las reglas de cifras

2.4. Tipos de error en métodos numéricos 17
significativas que se establezcan, donde a partir de t cifras el valor se redondea al extremo
próximo. Por ejemplo tomando tres cifras significativas (en punto flotante) de x para obtener
˜x como sigue
x1 = 23.333333 se redondea a ˜x1 = 23.333
x2 = 23.333690 se redondea a ˜x2 = 23.334
En problemas aplicados a métodos numéricos el error de truncamiento surge al “truncar” una
serie de operaciones. Citando textualmente a Nakamura [28] el error de truncamiento se debe
a las aproximaciones utilizadas en la fórmula matemática del modelo. Un claro ejemplo de ello
es la Serie de Taylor para mostrarlo veamos la expresión de esta serie
f(x + h) = f(x) + hf (x) +
h2
2!
f (x) +
h3
3!
f (x) + · · · +
hm
m!
f(m)
(x) + · · · (2.5)
En la práctica se trunca (2.5) debido a que es imposible utilizar un número infinito de términos.
A continuación se representa una serie truncada de Taylor hasta después del término de orden
m
f(x + h) = f(x) + hf (x) +
h2
2!
f (x) +
h3
3!
f (x) + · · · +
hm
m!
f(m)
(x) + O(hm+1
) (2.6)
donde O(hm+1) representa el error por el truncamiento.
La Serie de Taylor representa un punto de partida para la obtención de métodos numéricos.
En el polinomio de Taylor (2.6) el error de truncamiento se reducirá conforme m → ∞.
Como menciona Nakamura [28] calcular el valor exacto del error de un polinomio de Taylor es
prácticamente imposible es por ello que se representa con una aproximación que corresponde
O(hm+1). En general el error de truncamiento nace al representar una serie infinita con otra
serie finita de operaciones.
Error absoluto: este error corresponde a la diferencia absoluta entre un resultado exacto y
otro aproximado. Esto se representa como
EA = |x − ˜x| (2.7)

donde x es el resultado exacto y ˜x es el aproximado.
Error relativo: consiste en normalizar el error respecto al resultado exacto. Lo cual se expresa
como
ER =
|x − ˜x|
|x|
(2.8)
donde x es el resultado exacto y ˜x es el aproximado. Si multiplicamos el error relativo por
cien se obtiene el error porcentual del resultado aproximado.
2.5. El lenguaje de programación C
El lenguaje C es de alto nivel pero mantiene caracter´ısticas de bajo nivel. De alto nivel porque
es estructurado, fácil de aprender pero más que nada racional[15]. Y de bajo nivel porque permite
trabajar con el lenguaje máquinas los bits, registros de la CPU y registros de memoria. Algunas de
las caracter´ısticas son la siguientes tomadas del libro de Basurto et al.[6]:
Potencia y flexibilidad: C es un lenguaje no tan alejado del lenguaje máquina lo cual
puede traducirse en un mejor desempeño computacional. Otro punto a favor del lenguaje es
la flexibilidad para la creación de aplicaciones que van desde modestas aplicaciones de consola
a robustos sistemas operativos gráficos como UNIX y sus derivados.
Popularidad: como la mayor´ıa de los grandes proyectos, el lenguaje C debe su popularidad
a la variedad de recursos como compiladores, herramientas y librer´ıas.
Portabilidad: gracias al estándar ANSI C un programa escrito en C puede ser compilado y
ejecutado en diferentes arquitecturas con pocos o nulos cambios.
Sencillez: el lenguaje C es muy fácil de aprender por contar con un número muy reducido de
palabras reservadas.
Estructura y modularidad: C es el primer lenguaje de programación bien estructurado
que permite la agrupación de código en funciones; que posteriormente puede ser reutilizado.
El conjunto de cualidades anteriormente descritas coadyuvan para que este lenguaje cuente
con el soporte de varias interfaces que permitan la programación en paralelo y juntos sean una
herramienta importante para el cómputo cient´ıfico.

2.6. Programación en paralelo 19
En el presente documento se utiliza lenguaje C en su totalidad. Esto se debe a las caracter´ısticas
que son sencillez y racional para la creación de código; as´ı como la flexibilidad en el manejo de
vectores y matrices mediante los apuntadores. La compatibilidad de C con la API OpenMP es el
motivo principal por el cual se utiliza este lenguaje de programación. Cabe señalar que FORTRAN
es otro lenguaje compatible con ésta API; no se utilizó en este trabajo porque se ten´ıa un mejor
dominio del lenguaje C.
2.6. Programación en paralelo
Como menciona Pacheco [31] de 1986 a 2002 el incremento del rendimiento en los micropro-
cesadores fué de 50 % por año; el aumento de la velocidad de los procesadores estuvo sujeta a la
densidad de transistores del circuito integrado, cada año se aumentaba en ese mismo porcentaje.
Como menciona Petersen et al.[34] esto se debe a una ley formulada por Gordon Moore (uno de
los fundadores de Intel) en 1965 conocida como ley de Moore: el incremento de la velocidad de los
procesadores deberá ser duplicada cada dos años. Por problemas de diseño ya es imposible continuar
con esa tendencia, por lo cual en el lapso de 2002 a 2005 el aumento de la velocidad se redujo a
20 % anual.
Para 2005 la industria de microprocesadores acordó incrementar el rendimiento con un cambio
en el diseño; se eligió el camino del paralelismo. Esto consiste en dejar de construir procesadores
monol´ıticos más rápidos; para centrarse en la construcción de circuitos integrados que contengan
varios procesadores completos. Con base a Petersen et al.[34] actualmente las computadoras con
multiprocesadores y el desarrollo de algoritmos suman un mayor aumento en el rendimiento que el
establecido en la ley de Moore; esto habla del poder que le dota al cómputo ésta tendencia. Con las
medidas tomadas por los industriales se puede cumplir con las nuevas demandas de rendimiento en
las diferentes áreas que lo requieran.
Las nuevas tendencias en la contrucción de hardware paralelo representa un nuevo reto para
los programadores, la realización de software capaz de explotar las nuevas caracter´ısticas de éstos
recursos electrónicos. En la actualidad la mayor´ıa del software en el mercado es serial; ello indica
que esas aplicaciones únicamente explotan una fracción de los recursos de la computadora.
Durante la realización de este trabajo se ha observado una fuerte tendencia en la programación
de aplicaciones paralelas, éstos programas son divididos en múltiples instancias tantas como núcleos

contenga el sistema. Ello con la finalidad de presentar resultados en el menor tiempo posible.
Durante la traducción de aplicaciones seriales a paralelas nos encontramos con problemas de
adaptación de algoritmos y/o modelos; como menciona Pacheco [31] un algoritmo serial eficiente
puede convertirse en uno paralelo ineficiente. Por ello la tarea de los programadores para traducir
programas secuenciales en paralelos es dif´ıcil.
La programación en paralelo está influenciada directamente por la tendencia del desarrollo de
hardware denotada por la construcción de sistemas f´ısicos. Para la programación en el lenguaje
estructurado C existen tres alternativas principales; Message-Passing Interface (MPI, Interfaz de
Paso de Mensajes), POSIX threads (Pthreads) y OpenMP. El primero de ellos esta orientado a
la programación paralela para memoria distribuida. Los otros dos son utilizados en sistemas con
memoria compartida, como diferencia Pthreads al igual que MPI son librer´ıas y definiciones que
se usan dentro de programas mientras que OpenMP está constituido por una librer´ıa y algunas
modificaciones al compilador. Como menciona Petersen et al.[34] OpenMP es más fácil de programar
e implementar que Pthreads.
En tiempo más reciente ha surgido un tipo de cómputo distinto que consiste en utilizar la
tarjeta gráfica (GPU) para resolver operaciones aritméticas. Un ejemplo de ello es la interfaz de
programación CUDA propiedad de la empresa Nvidia, ésto revoluciona la fabricación de hardware
en la cual se incluyen miles de procesadores. Cada uno de ellos tiene mucho menores prestaciones
de procesamiento que un CPU; sin embargo, juntos le permiten al GPU desarrollar un incremento
sustancial de rendimiento comparable e inclusive mejor que la CPU. Al igual que las tres tecnolog´ıas
antes mencionadas CUDA trabaja con memoria compartida y distribuida. Una de sus opciones
programables es mediante el lenguaje C++. Con base al manual de Nvidia CUDA [30] el modelo de
programación de CUDA está enfocado al paralelismo masivo, el diseño del hardware permite lanzar
miles de hilos de ejecución a la vez. En la figura 2.6 extra´ıda de [30, fig.1-3 pág.3] se ilustra las
diferencias en la construcción de los dispositivos. En el caso de la CPU se cuenta con pocas unidades
de procesamiento pero con mayores capacidades y requiere mucho control y mucha memoria caché.
Por otra parte en la GPU se tiene una mayor cantidad de unidades de procesamiento con poco
control y poco caché; ésto es lo que permite la ejecución de miles de hilos a la vez. La principal
desventaja de CUDA es el marco de ejecución que sólo se limita a dispositivos compatibles de la
marca Nvidia, lo cual limita la popularidad en el uso de ésta API. Cabe señalar que un proyecto

2.7. OpenMP 21
encabezado por la marca norteamericana Apple llamado OpenCL permite la portabilidad de código
que utilice la GPU; mediante la compilación en tiempo de ejecución.
Figura 2.6: Arquitectura de hardware CPU versus GPU.
En la figura 2.7 se ilustran las arquitecturas de memoria compartida y distribuida respectiva-
mente; en (A) todos los cores-núcleos del sistema acceden a una misma memoria principal, con
ello todas las unidades de procesamiento pueden acceder a localidades de memoria donde otra uni-
dad esta trabajando. Cabe señalar que la memoria principal es de tipo UMA (Memoria de Acceso
Uniforme) que permite una comunicación intensiva entre los procesos que son ejecutados en los
diferentes núcleos. En (B) se muestra un sistema con memoria distribuida, los cuales están carac-
terizados porque cada una de las unidades-nodos de procesamiento tienen su propia memoria tipo
UMA, pero también pueden acceder a la memoria de cualquier otro nodo. Es preciso indicar que
es muy costo acceder a la memoria de un nodo desde otro en términos de tiempo. A ésto se debe
la barrera técnida para no crear secciones de aplicación que mantenga una comunicación intensa
siempre y cuando las secciones sean ejecutadas en nodos diferentes. En éste tipo de aplicaciones es
muy importante el papel que jugará el sistema de interconexión de nodos puesto que es un enorme
cuello de botella para el acceso a la memoria distribuida, generalmente se utiliza la fibra óptica.
Hasta este punto se han mencionado algunas de las principales tendencias y caracter´ısticas de la
programación en paralelo. Además se indican los motivos por los cuales este paradigma representa
el futuro de la computación de alto desempeño.
2.7. OpenMP
Como menciona Chapman et al. [11], OpenMP es una Interfaz de Programación de Aplicaciones
(API) cuyas caracter´ısticas, se basan en esfuerzos anteriores para facilitar la programación paralela

Figura 2.7: Tipos de memoria en sistemas.
de memoria compartida. Las siglas MP denotan “multiprocessing” (multiproceso) lo cual es un
sinónimo de programación paralela de memoria compartida.
OpenMP es un acuerdo alcanzado entre los miembros de la Architecture Review Board (ARB)
para dar un enfoque portátil, fácil de usar y eficaz a la programación paralela de memoria compar-
tida. Al contrario de lo que se puedr´ıa pensar OpenMP no es un lenguaje de programación nuevo;
por el contrario es la notación que se puede agregar a un programa secuencial en Fortran, C o C++,
a las cuales se le denomina directivas o pragmas que son instrucciones pre-procesador.
Una implementación adecuada de OpenMP en un programa permitirá a las aplicaciones benefi-
ciarse de la memoria compartida de las arquitecturas paralelas. En ocasiones con pocas modificacio-
nes al código se convierte una aplicación serial en una paralela; en la práctica muchas aplicaciones
tiene un cierto grado de paralelismo que debe ser explotado. Como menciona Chandra et al.[10],
todos los proveedores de computadoras de memoria compartida de alto desempeño soportan la fun-
cionalidad de OpenMP, pero la portabilidad de aplicaciones ha sido casi imposible de alcanzar.
Desde un punto de vista general, una aplicación serial se convierte en paralelo simplemente
incluyendo una directiva de OpenMP. Estas directivas van desde constructores de hilos hasta la
sincronización de los mismos para el acceso a los datos compartidos. Pero un punto muy importante
es que en la directiva se indica el tipo de reparto de las cargas de trabajo.
OpenMP utiliza el modelo fork-join, el cual consiste en que la ejecución de un programa inicia
con un hilo llamado maestro. Cuando el proceso llega a una directiva se crea una región paralela con
las especificaciones de la misma. La zona paralela se ejecuta sobre un mismo espacio de direcciones
lo cual permite compartir las variables declaradas, pero también declarar información privada [10,

2.7. OpenMP 23
Figura 2.8: Modelo de OpenMP.
11, 31, 34]. Al finalizar la fracción paralela los hilos esclavos se destruyen y continua la ejecución
del hilo maestro.
En la figura 2.8 se ilustra la ejecución de un programa con una región paralela. Cuando el hilo
maestro llega al inicio (etapa fork) de ésta zona se crean los hilos esclavos y se declaran la variables
locales de la zona. Posteriormente se realiza el reparto de cargas de trabajo, para que todos los
subprocesos ejecuten el mismo código. Después de finalizar la ejecución se destruyen las variables
locales de la región paralela y todos los hilos acepto el maestro; es la etapa join. Al finalizar la región
paralela, el proceso continua una ejecución serial; si más adelante existiese otra región paralela el
proceso se repite con las condiciones de la nueva directiva.
Soporte de compiladores
La norma industrial OpenMP es soportando por una gran variedad de compiladores; la mayor´ıa
de ellos con fines comerciales. Algunos ejemplos de ellos son: el compilador Oracle C/C++/Fortran
de Sun Microsystems Inc, el gigante de los procesadores Intel ofrece su compilador para Windows y
Linux con el nombre de Intel C/C++/Fortran, por su parte Microsoft’ brinda el soporte en Visual
C++ en su versión comercial entre otros.3 También existe el compilador GNU GCC que brinda
soporte para el API de forma gratuita el cual es propiedad de la comunidad de código abierto de
GNU Project. Por tratarse de un estándar nos garantiza que el código no debe ser re-escrito cuando
cambiemos el compilador.
El compilador GCC implementa OpenMP en la version 4.2.1 o posteriores. En su versión 4.3.2
3
La lista completa de compiladores que soporta OpenMP puede ser consultada en el sitio oficial
http://www.openmp.org.

(Agosto de 2008) comenzó a implementar OpenMP v3.0.4. Las nuevas versiones de GCC las encon-
tramos pre-cargadas en la mayor´ıa de las distribuciones Linux (recientes) por ello se convierte en el
más accesible. Por estas cuestiones los resultados que se muestren en la presente tesis corresponde
a código compilado con GCC v4.2.1.
Como se menciona en el manual oficial de GNU GCC v4.2.4 [40] el compilador lleva este nombre
por “GNU Compiler Collection” donde se engloba la posibilidad de compilar código en lenguajes
C, C++, Objective-C, Objective-C++, Java, Fortran y Ada. GCC cuenta con un gran número
de optimización para aumentar el rendimiento de las aplicaciones conocidas como banderas de
compilación, las especificaciones técnicas de estas banderas no son tratadas en el presente trabajo.
Para la evaluación de algoritmos paralelos se utilizan varios parámetros entre los cuales destacan
el La ley de Amdahl, speed-up y el rendimiento computacional. En los temas siguientes se dará una
breve explicación para llenar el contexto.
2.8. Escalabilidad paralela
La Escalabilidad paralela (Parallel Scalability) es el comportamiento de una aplicación cuando
un creciente número de hilos (threads o subprocesos) se utilizan para resolver un problema de tamaño
constante. Idealmente, aumentar el número de hilos de 1 a P dará un aceleramiento paralelo (speed-
up) de p [11]. Como menciona Pacheco [31] se dice que un programa es escalable si al aumentar el
número de hilos la eficiencia persiste. Para definir este punto, en primer lugar se toma la ecuación
de la eficiencia E
E =
T1
p · Tp
=
S
p
(2.9)
donde T1 es el tiempo de ejecución con un núcleo, p es el número de procesadores, Tp representa
el tiempo de ejecución para p-hilos y S es el speed-up (2.13). En base a lo anterior supongamos que
aumentamos k veces el número de procesadores con lo cual se tiene
Ekp =
T1
kp · Tkp
=
Skp
kp
(2.10)
Con base a (2.9) y (2.10) podemos determinar si un programa es escalable si E = Ekp. Tomando
como idea principal que un programa no puede ser paralizado de forma completa. Idealmente,
4
Esta información con base la documentación del sitio web oficial http://gcc.gnu.org/gcc-4.3/

2.8. Escalabilidad paralela 25
pensamos que la reducción en tiempo de ejecución es proporcional al aumento de hilos-procesadores,
en la práctica no es común que se presente la proporcionalidad, el principal obstáculo es el acceso a
memoria ya que ésta se encuentra compartida para todos los hilos, y por ende, se da una competencia
para el uso de la misma. Aunado a ello estas lo costos derivados por la sincronización y en general por
el manejo de las regiones paralelas. Existen ocasiones donde aumentar el número de hilos se torna
contraproducente, se dice que la aplicación tiene un l´ımite de hilos, y a partir de aqu´ı, aumentará el
tiempo de ejecución conforme aumentemos la cantidad de hilos.
Para la evaluación de la escalabilidad de la aplicación se utilizan dos métodos: el primero Ley
de Amdahl el cual no pone en un contexto real de la escalabilidad teórica que se puede obtener.
En segundo tenemos el speed-up el cual mide las veces que es más rápido un algoritmo paralelo con
respecto al serial. Mientras tanto el desempeño computacional mide la cantidad de operaciones por
segundo de un programa. En los siguientes temas se desarrolla cada uno de ellos.
2.8.1. Ley de Amdahl
Como menciona Pacheco [31] fue desarrollada por Gene Amdahl en la década de 1960. Ésta ley
indica que un programa serial sólo se puede paralelizar una fracción; ello limitará muy significati-
vamente el speed-up; independientemente del número de unidades de procesamiento.
La ley plantea la carencia de poder paralelizar un algoritmo serial de forma completa. Sólo
podemos hacer paralelo una fracción del código. Mientras más grande sea la fracción paralela, el
speed-up será mayor para un número creciente de procesadores; sin embargo, no siempre será posi-
tivo aumentar la cantidad de hilos.
En la figura 2.9 se ilustra la ejecución de un fragmento de programa con una sección en paralelo.
En ella se describe lo siguiente: en un principio el hilo maestro inicia la ejecución y crea la región
paralela. En la región paralela los hilos esclavos ejecutan el proceso, al finalizar se destruyen los
hilos. Finalmente el hilo maestro continua con la ejecución.
La ley de Amdahl nos permite calcular el speed-up máximo Sp como
Sp =
1
(1 − F) + F
p
(2.11)
donde F es la fracción de tiempo secuencial y p el número de procesadores, entonces (1 − F)
representa la fracción serial del programa.

Figura 2.9: Modelo de ejecución de programas paralelos.
Tomando un programa que se ejecuta como el de la figura 2.9 donde la región paralela es
F = 80 % del total de cálculo. Con base a (2.11) se calcula el speed-up máximo (Sp) para 2
procesadores (n = 2) como sigue
Sp =
1
(1 − 0.8) + 0.8
2
=
1
0.2 + 0.4
= 1.66x
Ahora supongamos que otro código es altamente paralelizable F = 95 %, a continuación se
calcula el nuevo Sp para éste nuevo código
Sp =
1
(1 − 0.95) + 0.95
2
=
1
0.05 + 0.475
= 1.90x
Si calculamos el speed-up máximo para 4, 5, 8, 16, 32 procesadores para los dos ejemplos
anteriores se obtiene la gráfica de la figura 2.10.
En la figura 2.10 se ilustra el speed-up de dos programas con 95 % y 80 % de paralelismo y son
comparados con el speed-up ideal. Para un número reducido de procesadores ambos están cercanos
al teórico; pero conforme el número de procesadores aumentan el speed-up de los dos programas
empeora muy drásticamente. El speed-up que se puede esperar de un programa 95 % paralelo para

5 10 15 20 25 30
5
10
15
20
25
30
Numero de procesadores
speed−up
Ideal
95%
80%
Figura 2.10: Speed-up con Ley de Amdahl.
más de 16 procesadores es muy pobre. Para otro 80 % paralelo prácticamente su l´ımite son 16
procesadores.
Con el paso del tiempo la Ley de Amdahl se volvió obsoleta y fue Gustafson quien la revalidó a
finales de la década de 1980[20]. La versión moderna de la ecuación de ésta ley en (2.12)
Smax =
1
(1 − F) + F
S
(2.12)
donde lo único que cambia es S que representa un speed-up. Cabe señalar que conforme S se
aproxime a infinito (S → ∞) se redondea el denominador de (2.12) quedando 1/(1 − F).
2.8.2. Incremento de velocidad (speed-up)
El incremento de velocidad (speed-up), es la proporción del tiempo de reloj para la ejecución
del programa en un hilo y el tiempo de reloj para la ejecución del mismo programa en varios hilos.
Teóricamente, debe ejecutar un programa en P-hilos, P veces tan rápido como se ejecute en un
hilo[11]. En la literatura existente cuando se refiere a éste tema se utiliza el término speed-up, éste
documento no será la excepción.

Con base a lo ya mencionado se define a speed-up como sigue
S =
T1
Tp
(2.13)
donde S representa el speed-up, T1 el tiempo de ejecución para un procesador y Tp el tiempo que
tarda la misma aplicación en P-procesadores. La medida del speed-up es adimensional. Por ejemplo,
si una fracción de código seriado (T1) dura 10 segundos, después cuando ese código se ejecuta en
forma paralela con dos procesadores (T2) dura 5.5 segundos. El speed-up que se tiene es el siguiente
S =
10
5.5
= 1.8x
Ahora si aumentamos el número de procesadores a cuatro y tiene un tiempo de ejecución (T4)
de 3 segundos, el speed-up entonces será
S =
10
3
= 3.3x
Con los ejemplos anteriores se representa el proceso para determinar la aceleración de ejecuciones
paralelas. En ninguno de los casos anteriores se llega al speed-up teórico 2 y 4 respectivamente. En
temas siguientes se indica el motivo por el cual no se llega a ello.
Cuando se programa en paralelo siempre se busca alcanzar la proporcionalidad entre el aumento
de la velocidad respecto al número de hilos, no siempre se alcanza dicha meta debido a los proble-
mas de acceso a memoria, los cuales depende del diseño de cada computadora. Es por ello que es
conveniente cuidar la implementación del código a fin de obtener una mayor velocidad cuando se
cambie el número de hilos.
2.8.3. Desempeño computacional
El desempeño o rendimiento computacional (en la literatura también se le conoce como perfor-
mance) se mide por las operaciones en punto flotante por segundo. Como menciona Null et al.[29]
la métrica para el rendimiento es el FLOPS (floating-point operations per second, operaciones en
punto flotante por segundo). Para calcular el desempeño se divide el número de operaciones n entre

el tiempo empleado t.
FLOPS =
n
t
(2.14)
Con las nuevas prestaciones que ofrecen las computadoras la cantidad de FLOPS es algo dif´ıcil
de manejar. Por ello se utilizan unidades de medida de FLOPS que se indican en la tabla 2.1.
Tabla 2.1: Unidades de medida de FLOPS
Nombre de la unidad Valor
KiloFlop 103
MegaFlop 106
GigaFlop 109
TeraFlop 1012
PetaFlop 1015
ExaFlop 1018
ZetaFlop 1021
YottaFlop 1024
Para obtener directamente una de las unidades de la tabla 2.1 de (2.14) basta con hacer lo
siguiente
K FLOPS =
n
t × 10e
(2.15)
donde e corresponde al exponente de la unidad, por ejemplo e = 9 si calculamos GigaFlops. Ello se
muestra a continuación
GigaFlops =
n
t × 109
FLOPS es una unidad generalizada para mostrar resultados de rendimiento. En la presente
tesis se muestran todos los resultados de rendimiento utilizando ésta unidad de medida. Para los
fines de la presente tesis únicamente se utilizan para evaluar los algoritmos paralelos el desempeño
computacional y el speed-up.
Con los temas que se han tratado durante el presente cap´ıtulo se establece un fundamento
teórico lo cual se puede resumir. Los métodos numéricos estas influenciados por las computadoras,
lo cual requiere de análisis y modelación matemática que permitan adaptar el esquema al tipo de
problema en cuestión. Las nuevas generaciones de computadoras multinúcleo permiten la ejecución
de aplicaciones paralelas; ello conlleva que se diseñen nuevos algoritmos que puedan explotar éstas
nuevas caracter´ıticas. Éstos nuevos algoritmos deben ser eficientes para ellos son evaluados a fin de

determinar su desempeño computacional as´ı como su speed-up. A diferencia de los número reales
idealmente conocidos, en las computadoras la cantidad de números es limitada y su distribución
en la l´ınea recta no es uniforme. Debido al método numérico elegido y a la representación de los
números en la computadora nace el error numérico en los problemas de análisis numérico, además
de las propias contemplaciones hacia el resultado por parte quien implementa el método.

Cap´ıtulo 3
Producto matriz-vector Ax
La multiplicación de una matriz y un vector, es una operación simple que resuelve un problema
básico, pero importante [11]. La cual se presenta de forma frecuente en esquemas iterativos como lo
son el método de Jacobi y el de Gauss-Seidel, por mencionar algunos. Estos métodos son tratados
en cap´ıtulos siguientes.
Durante este cap´ıtulo se describen formas distintas para resolver A·x utilizando la computadora;
señalando los pro y contras de cada una de ellas. Para ello se exhibe el rendimiento en speed-up y
Mflops1 con el fin de mostrar numéricamente cual de ellos es el mejor procedimiento para codificarla.
En la primera sección se definen conceptos básicos para comprender el problema. Cómo se realiza
el producto entre una matriz y un vector, cuales son la normas que deben cumplirse para que se
pueda realizar.
En el segundo apartado se da una breve introducción a un técnica de optimización de ciclos
conocida como Loop unrolling, la cual es utilizada para optimizar el producto de una matriz por
un vector.
Se estudia el cálculo del residual en la sección tres, lo cual resulta ser un tema interesante, es
utilizado como condición de paro en métodos iterativos. El residual es la diferencia que existe entre
la solución exacta y una aproximada.
La implementación canónica se realiza en la cuarta parte del cap´ıtulo.
En las secciones cinco y seis se realizan distintos procedimientos de optimización, para mejorar
1
flops (floating-point operations per second, operaciones en punto flotante por segundo) es una unidad de medida
para el desempeño de una aplicación. Mflops denota que es un millón de flops (106
).
31

32 Cap´ıtulo 3. Producto matriz-vector Ax
el desempeño de la aplicación. En primer lugar, es utilizada la técnica de Loop unrolling para
optimizar el bucle. En segunda instancia, se optimiza a nivel de datos con la Tecnolog´ıa SIMD de
Intel R
. Al final de esta quinta sección se combinan ambas (Loop unrolling y SIMD) para exponer
el resultado que se presenta al combinarlas.
En la actualidad la gran mayor´ıa de las computadoras disponibles en el mercado, tienen más de
un procesador. En cómputo es importante explotar todos los recursos de manera eficiente. Lo que
nos lleva a realizar aplicaciones que aprovechen el multinúcleo, es decir, puedan ser ejecutadas en
varios procesadores de forma simultánea, esta tarea se lleva a cabo en el séptimo apartado.
Por último se muestran los resultados obtenidos tras las optimizaciones realizadas. Ello con la
finalidad de establecer la mejor opción para implementarla en los métodos iterativos de los cap´ıtulos
siguientes.
3.1. Concepto
El producto de una matriz y un vector es un operación simple que resuelve un problema básico
pero importante [11]. En esta sección se presenta la multiplicación de una matriz por un vector
desde un punto de vista matemático.
Antes de adentrarse es preciso definir lo que son las matrices y los vectores. Un vector no es
más que un conjunto ordenado de números uniformemente espaciados, en el área de informática se
le conoce como arreglo unidimensional. Existen vectores de tipo columna y renglón dependiendo de
la orientación del mismo. A continuación se representa un vector de orden n.
X = [x1, x2, . . . , xn]T
(3.1)
En la ecuación (3.1) se describe un vector renglón, tomando ese ejemplo para convertirlo a uno
de tipo columna sólo resolvemos la transpuesta del mismo. A continuación se ilustra lo mencionado.
X =








x1
x2
...
xn








(3.2)

3.1. Concepto 33
Una matriz es un arreglo rectangular de números con m filas y n columnas, o dicho de otra forma
una matriz es un arreglo bidimensional [28]. A continuación se muestra la representación general de
cualquier matriz.
A =








a1,1 a1,2 · · · a1,n
a2,1 a2,2 · · · a2,n
...
...
...
...
am,1 am,2 · · · am,n








(3.3)
En (3.3) se describe la forma general para representar una matriz de m-renglones y n-columnas,
decimos que es una matriz de m × n. En éste documento únicamente se abordarán matrices cuyo
número de renglones es equivalente al de columnas. A este tipo de arreglo bidimensional se le conoce
como matriz cuadrada, a consecuencia cuando se mencione una matriz se supondrá que es cuadrada;
mientras no se indique lo contrario.
Para llevar a cabo la multiplicación de una matriz por un vector se requiere cumplir con dos
condiciones. La primera es que el vector tenga la forma de (3.2), es decir, sea un vector de tipo
columna o vertical. Tomando a (3.3) y (3.2), el orden del vector (número de renglones) debe ser
exactamente igual al número de columnas de la matriz; ésta es la segunda condición. Por ende no
puede realizarse la siguiente operación.
c = xA (3.4)
Cuando se cumplen las condiciones se puede realizar la operación. Como resultado de multiplicar
la matriz A por el vector x se obtiene el vector c. La operación se describe a continuación,
Ax = c (3.5)
Si se desglosa (3.5), encontramos el siguiente procedimiento con base en (3.2) y (3.3). Donde se
expone que cada renglón de la matriz se multiplica por el vector.








a1,1 a1,2 · · · a1,n
a2,1 a2,2 · · · a2,n
...
...
...
...
am,1 am,2 · · · am,n
















x1
x2
...
xn








=








a1,1x1 + a1,2x2 + · · · + a1,nxn
a2,1x2 + a1,2x2 + · · · + a2,nxn
...
am,1xn + am,2x2 + · · · + am,nxn








(3.6)

A continuación se muestra una forma compacta de (3.6). En este documento será utilizada ésta
fórmula (3.7) cuando se haga referencia a la ecuación de la mutiplicación de una matriz por un
vector, mientras la matriz no sea rectangular.
ci =
n
j=1
aijxj i = 1, 2, . . . , n (3.7)
Como se observa en (3.6) y (3.7) resolver la operación en cuestión resulta trivial. Sin embargo,
el proceso es demandante en tiempo de calculo. La demanda de cálculo aumenta conforme la matriz
A se vuelve más densa, es decir, el orden de la misma crece. Con base a (3.7) se realiza el algoritmo
que corresponde con el tema tratado lo cual permitirá crear la función para la misma ecuación.
Algoritmo 3.1 Multiplicación matriz-vector
Está definido por los siguientes seis pasos:
1. Hacer i = 0
2. Si (i < m)
Verdadero: hacer ci = 0,j = 0, posteriormente pasar al paso 3.
Falso: ir al paso 6
3. Hacer ci = ci + Aij · xj
4. Hacer j = j + 1
5. Si (j < n)
Verdadero: regresar al paso 3.
Falso: hacer i = i + 1, posteriormente regresar al paso 2.
6. Parar.
En esta sección se definieron las bases para resolver la operación c = Ax. Lo cual es indispensable
para escribir funciones en código C que resuelvan la operación en cuestión. Esta actividad se llevará a
cabo en secciones posteriores de este cap´ıtulo.
3.2. Loop unrolling
En esta sección se define una técnica de optimización de ciclos principalmente de tipo for. La
técnica llamada Loop Unroll o Loop unrolling (desdoble de ciclo). Esta técnica sirve para optimizar

3.2. Loop unrolling 35
el código de programas para reducir el tiempo de ejecución de la aplicación, los cual incrementa el
desempeño computacional de la misma.
Como menciona Page [32] esta técnica tiene como objetivo eliminar la sobrecarga asociada con
la operación de un ciclo determinado. Cuando el número de iteraciones es conocido se pueden listar
todos lo valores posibles para la variable de inducción2. Para ejemplificar, se tiene el siguiente ciclo:
for(i = 0; i < n; i++)
c[i] += a[i] * b[i];
Para ejemplificar tomemos n = 4 lo cual permite desdoblar el ciclo de forma completa quedando
como sigue
c[0] = a[0] × b[0]
c[1] = a[1] × b[1]
c[2] = a[2] × b[2]
c[3] = a[3] × b[3]
En este caso en particular la variable de inducción esta definida en el rango 0 ≤ i < n, al escribir
un código con las nuevas modificaciones se obtiene una aplicación que realiza la misma tarea que
el ciclo original (para este caso en particular), pero ahora no hay gastos asociados al ciclo. En
consecuencia el rendimiento aumenta.
Cuando el valor de n es pequeño el ciclo puede ser desdoblado en su totalidad. Sin embargo,
conforme n crece llevar a cabo un desdoble completo del bucle; será una tarea prácticamente impo-
sible de realizar. Aunado a ello, el código resultante es tosco. Una forma ingeniosa para resolverlo
es hacer un desdoble por bloques, cada uno tan grande como se desee. Esto con el fin de reducir
el número de iteraciones además de exponer las operaciones que se pueden realizar en paralelo. A
continuación se desarrolla un código general aplicable a cualquier Unroll.
r = n % k;
for(i = 0; i < n-r; i+=k)
c[i] += x[i]*y[i] + x[i+1]*y[i+1] + ... + x[i+k-1]*y[i+k-1];
for(i = n-r; i < n; i++)
c[i] += x[i]*y[i];
En el código anterior k representa el factor de unroll que se aplica; n el orden de los vectores y
r es el residual por si n no es divisible por k.
2
La variable de inducción es aquella que controla el funcionamiento del ciclo, en la mayor´ıa de los casos se representa
con i.

Como menciona Page [32] al desarrollar un desdoble parcial queda claro que el número de
operaciones dentro del cuerpo del ciclo se puede llevar a cabo de forma paralela.
La técnica de Loop Unroll permite reducir la carga en el ciclo utilizando la l´ınea de caché del
procesador utilizando los valores que recientemente han sido cargados a la memoria caliente3. Ello
hace que sea muy utilizada gracias a la fidelidad que presenta en una implementación. Aún cuando
la implementación es por demás sencilla, la elección de una regla para que esta técnica funcione
siempre no es una tarea sencilla. Este problema esta ligado directamente a las caracter´ısticas del
procesador, los procesadores no-móviles ejecutan mejor las sobre-cargas en los ciclos que los que no
lo son.
3.3. Cálculo del residual
En esta sección se aborda el tema del cálculo del residual, como un método para medir la
convergencia de los esquemas iterativos que se estudian en cap´ıtulos posteriores. Este procedimiento
mide el error entre la k-ésima iteración con respecto a la solución exacta del sistema lineal de
ecuaciones. Uno de los principales usos del cálculo del residual es durante la medición de error en
los métodos iterativos de proyección sobre subespacios de tipo Krylov[24]. Se realizará una función
que realice este procedimiento, la cual será utilizada en los siguientes cap´ıtulos.
El cálculo del residual (r) se obtiene de sustraer el producto de A y x∗ a b como se muestra a
continuación
r = b − Ax∗
(3.8)
donde, x∗ = una aproximación a la solución exacta de x, b, r, x∗ ∈ RN y, A ∈ RN×N
Para ello los vectores (b, r, x∗) tienen la forma del vector z la cual se expresa a continuación,
z = (z1, z2, . . . , zn)T
Si x∗ = x ⇒ r = ¯0 Ahora si x ≈ x∗ ⇒ r = 0
Tomando en cuenta que la solución exacta x es la suma de la aproximación más el error (x =
x∗ + e), con lo que deducimos que
x = x∗
− e
3
La memoria caliente corresponde a un tipo de almacenamiento conocido como NUMA(Non-uniform memory
access, memor´ıa de acceso no uniforme) o memoria caliente es como se le conoce a la memoria caché del procesador
debido a que es una memoria de gran velocidad.

3.3. Cálculo del residual 37
Al sustituir x∗ en (3.8) tenemos
r = b − A(x∗
− e)
con ello se intuye que el residual es equivalente al error entre la solución exacta y una aproximada
r ≈ e
Observe que el residual r es un vector de orden n, es decir, r ∈ Rn de la forma
r = (r1, r2, r3, . . . , rn)T
A continuación el cálculo del residual se traduce a código C, en la figura (3.1) se ilustra esta
tarea ya realizada.
Implementación Cálculo del Residual
double calcularResidual(float **A, float *dx, float *b, int n)
{
double *residual,normResidual;
int i,j;
double rowDot;
residual = make_dvector(n);
for(i = 0; i < n; i++)
{
rowDot = 0.0;
for(j = 0; j < n; j++)
rowDot += A[i][j] * dx[j];
residual[i] = b[i] - rowDot;
}
normResidual = normInf(residual,n);
free_svector(residual);
return normResidual;
}
Figura 3.1: Cálculo del residual en C.
En la función descrita con anterioridad, se utilizan tres métodos que se explican a continua-
ción. Cuando se llama a la función make dvector(n) se reserva la memoria para un vector, en este
caso residual. La segunda función normInf(residual,n) calcula la norma infinita de un vector con

orden n. En el último caso free dvector(residual) se libera la memoria previamente reservada con
make dvector(n).
En temas posteriores, cuando se indique el cálculo del residual (dentro de l´ıneas de código), se
hará alución a esta función cuando no se indique lo contrario.
El residual es un método que mide la diferencia entre una solución exacta y una aproximada.
Se utiliza para determinar la convergencia en esquemas iterativos como son los métodos de Jacobi
y Gauss-Seidel. Para reducir el error derivado de la gran cantidad de operaciones en los métodos
directos se utilizan técnicas iterativas de corrección del error del residual.
La función que fue implementada puede ser optimizada con temas tratados en secciones poste-
riores de este cap´ıtulo, a fin de incrementar el desempeño computacional de la misma. Cabe señalar
que esta función no será optimizada llegando a esos temas porque no es la finalidad del presente
documento.
3.4. Codificación
En esta sección se realiza una primera implementación en código C, para la ecuación que corres-
ponde a la multiplicación de una matriz por un vector, es decir, la ecuación (3.7). En esta primera
función secuencial no se utilizó ninguna de la optimizaciones. En temas posteriores se realizarán
mejoras que impacten positivamente en el rendimiento.
Como se ha mencionado con anterioridad, el producto de una matriz por un vector es una
operación muy sencilla. Traducirla a un lenguaje para computadora es también una tarea muy
simple. La fracción de código de la figura 3.2 es un primer resultado tras realizar la tarea en
cuestión.
Implementación Canónica de Ax
for(i = 0; i < n; i++)
{
c[i] = 0.0;
for(j = 0; j < n; j++)
c[i] = A[i][j] * x[j];
}
Figura 3.2: Implementación canónica de Ax.

3.5. Incremento del desempeño 39
Como puede observarse el código de la figura 3.2 está diseñado para matrices cuadradas. El
código es por demás sencillo y no existe nada extraño. Es preciso definir que en temas siguientes
cuando se mencione una implementación canónica del producto de una matriz po un vector, nos
referiremos a ésta fracción de programa alojado dentro de una función. En pocas palabras, ésta
primera implementación corresponde a una versión compacta de una función canónica que resuelve
la multiplicación de una matriz por un vector.
La implementación canónica permite tener un primer acercamiento en la realización de una
aplicación; la cual pueda ser ejecutada en forma paralela.
En esta sección se realizó una primera implementación, la canónica. Esta función no cumple
con los objetivos planteados; es decir, no presenta un buen desempleño computacional. Además
no es posible ejecutar esa aplicación en varios procesadores de manera simultánea. Tomando esto
dos puntos, y los que puedan surgir, definimos que la implementación canónica no es una opción,
en términos de cómputo de alto desempeño. En las siguientes secciones se tratan cada uno de los
puntos ya mencionados, a fin de cumplir con cada uno de ellos.
3.5. Incremento del desempeño
Muchos programas pasan gran parte de su tiempo de ejecución en bucles; en este caso es mediante
ciclos que se accede a los elementos de la matriz; con una reorganización adecuada de los bucles se
puede explotar el caché de procesador donde se guardan más de un elemento que se va a utilizar en
la siguiente operación. Los elementos que se encuentran en la l´ınea de caché en muchos casos pueden
ser procesados a la vez mediante una pila de operaciones. Esto puede mejorar el rendimiento de un
programa4. En esta sección se optimiza la versión canónica de la mutiplicación Ax con la técnica
de Loop unrolling.
Para mejorar el rendimiento de la aplicación es preciso realizar un análisis detallado de la forma
matemática, se realiza una descomposición a fin de buscar diferentes formas de programar el pro-
blema para definir las caracter´ısticas y determinar cual se adapta mejor a nuestros requerimientos.
Para ello es preciso desglosar y estudiar un gran número de posibles soluciones, as´ı como analizarlas;
para determinar aquella que permita maximizar el desempeño sin incrementar significativamente el
4
Las modificaciones en código pueden ser aplicadas si y sólo si no cambian el correcto funcionamiento de la
aplicación.

error numérico para la solución buscada. Recordemos la ecuación,
ci =
n
j=1
aijxj i = 1, 2, . . . , n (3.9)
En más de una ocasión cuando se realiza una tarea se encuentra que existen varios caminos para
realizarla; cada uno de esos caminos con distancias y obstáculos distintos. Nos encontramos justo en
uno de esos casos, para elegir el camino primero estudiaremos cada uno de ellos. Existen prácticas
utilizadas para la optimización ciclos con un número significativo de iteraciones, generalmente en
bucles for’s. Las técnicas tienen el propósito de disminuir el tiempo de ejecución del bucle; consisten
en disminuir la cantidad de iteraciones haciendo un incremento mayor a la unidad en la variable
que controla el ciclo. Una de esas prácticas es la llamada Unroll Loops.
Como menciona Chapman et al.[11] el Unroll a un bucle es una práctica poderosa para reducir
efectivamente los gastos de ejecución. Puede ayudar a mejorar la utilización de la l´ınea de caché con
la reutilización de datos. Como es sabido el compilador no es capaz de determinar las dependencias
de operaciones ni tampoco lo que respecta al acceso en los elementos dentro de ciclos; por lo que el
desarrollador suele hacer un mejor trabajo en la optimización de bucles.
Antes de resolver el producto c = Ax, se plantea lo siguiente,
ci = aix (3.10)
donde c y x son vectores verticales de orden de n-elementos, y ai es el i-ésimo vector horizontal de
la matriz A.
Partiendo de (3.10) encontramos diferentes formas de resolverlo, a continuación se listan las
variantes a tomar en cuenta, para esto todas utilizan la técnica de unroll.
1. s =
n
j=1
xjyj + xj+1yj+1 ∆ j = 2
2. s =
n
j=1
xiyj + xj+1yj+1 + xj+2yj+2 + xj+3yj+3 ∆ j = 4
3. s =
n/2
j=1
xjyj + xj+1yj+1 +
n
j=n/2
xjyj + xj+1yj+1 ∆ j = 2
4. s =
n/4
j=1
xjyj + xj+1yj+1 +
n/2
j=n/4
xjyj + xj+1yj+1 +
3n/4
j=n/2
xjyj + xj+1yj+1

+
n
j=3n/4
xjyj + xj+1yj+1 ∆ j = 2
5. s =
n
j=1
xiyj + xj+1yj+1 + xj+2yj+2 + xj+3yj+3 + xj+4yj+4 ∆ j = 5
6. s =
n
j=1
xiyj + xj+1yj+1 + xj+2yj+2 + xj+3yj+3 + xj+4yj+4 +xj+5yj+5 ∆ j = 6
7. s =
n
j=1
xiyj + xj+1yj+1 + xj+2yj+2 + xj+3yj+3 + xj+4yj+4 + xj+5yj+5 + xj+6yj+6
+xj+7yj+7 ∆ j = 8
8. s =
n
j=1
xiyj + xj+1yj+1 + xj+2yj+2 + xj+3yj+3 + xj+4yj+4 + xj+5yj+5 + xj+6yj+6
+xj+7yj+7 + xj+8yj+8 + xj+9yj+9 + xj+10yj+10 + xj+11yj+11 ∆ j = 12
Para comprender y tener una idea de como utilizar el unroll, en primera instancia se estudiarán
y compararán las primeras cinco variantes (1-5), en segunda instancia se analiza el resto. En algunos
de los casos anteriores podemos realizar dos implementaciones lo cual se expresará en su momento.
A continuación se hará la codificación de cada una de las opciones para conocer sus caracter´ısticas.
En la primera implementación (figura 3.3) corresponde a ese mismo orden de la lista de opciones
enlistadas anteriormente. Como se puede observar el número de iteraciones se reduce a la mitad, lo
cual teóricamente hace pensar que el tiempo de ejecución va a reducirse a la mitad de tiempo. Para
este caso en particular corresponde a un Unroll-2 donde se guardará el resultado obtenido a una
variable. Esta al igual del resto de las fracciones de código que corresponda con la lista de opciones,
representa la solución de la multiplicación de dos vectores.
Código Opción 1
for(i = 0; i < n; i+=2)
suma += (x[i]* y[i]) + (x[i+1] * y[i+1]);
Figura 3.3: Técnica Loop Unrroll con factor 2.
A continuación hacemos la codificación de la segunda opción (figura 3.4), que corresponde a un
Unroll-4. En ésta ocasión la cantidad de iteraciones se reduce a una cuarta parte. Al igual que en
el caso anterior el resultado es guardado dentro de una variable.

Código Opción 2
for(j = 0; j < n; j+=4)
suma += x[j]*y[j] + x[j+1]*y[j+1] + x[j+2]*y[j+2] + x[j+3]*y[j+3];
Figura 3.4: Técnica Loop Unroll con factor 4.
El siguiente código (figura 3.5) representa una forma distinta de programar la primera opción
de la figura 3.3, en ésta ocasión, primero haciendo las operaciones con los ´ındices pares del vector
y posteriormente con los impares.
Código Opción 1a
for(j = 0; j < n; j+=2){ suma += x[j]*y[j];}
for(j = 1; j < n; j+=2){ suma += x[j]*y[j];}
Figura 3.5: Técnica Loop Unroll con factor 2, dos ciclos for.
Como vemos en el código de la figura 3.6, se puede codificar de distintas formas un mismo
problema. En las implementaciones anteriores sólo utilizamos una variable para almacenar el resul-
tado, de la operación en cuestión, en las próximas codificaciones se hará uso de dos o más variables
para acumular el resultado mientras se realizan las operaciones. La siguiente fracción de programa
corresponde al mismo código anterior pero ahora haciendo uso de dos variables.
Código Opción 3
for(j = 0; j < n; j +=2){ s1 += (x[j]*y[j]);}
for(j = 1; j < n; j +=2){ s2 += (x[j]*y[j]);}
suma = s1 + s2;
Figura 3.6: Técnica Loop Unroll con factor 2, dos variables.
La cuarta opción (figura 3.7) representa una forma más sofisticada para llevar a cabo la solución
del problema ya que partimos la operación principal en dos sub-operaciones, las cuales a su vez
presentan un incremento en j de dos (∆j = 2) lo cual reduce el número de iteraciones a la mitad
e implementa dos variables, temporales, para llevar a cabo las operaciones. Ello ante los ojos del
unroll, corresponde al Unroll-2 dividido en dos mitades.

Código Opción 4
for(j = 0; j < n/2; j += 2){ s1 += x[j]*y[j] + x[j+1]*y[j+1];}
for(j = n/2; j < n; j += 2){ s2 += x[j]*y[j] + x[j+1]*y[j+1];}
suma = s1 + s2;
Figura 3.7: Técnica Loop Unroll con factor 2, dos ciclos for y dos variables.
La siguiente implementación (figura 3.8), de la quinta opción, sigue la nomenclatura a la anterior
y solamente difiere en la cantidad de partes, que para este caso son cuatro, y por ende el número
de variables temporales aumenta a igual número, a continuación se muestra lo que con anterioridad
se ha mencionado.
Código Opción 5
for(j = 0; j < n/4; j+=2) { s1 += x[j]*y[j] + x[j+1]*y[j+1];}
for(j = n/4; j > n/2; j+=2) { s2 += x[j]*y[j] + x[j+1]*y[j+1];}
for(j = n/2; j > 3*n/4; j+=2){ s3 += x[j]*y[j] + x[j+1]*y[j+1];}
for(j = 3*n/4; j > n; j+=2) { s4 += x[j]*y[j] + x[j+1]*y[j+1];}
suma = s1 + s2 + s3 + s4;
Figura 3.8: Técnica Loop Unroll con factor 2, cuatros ciclos for cuatro variables.
Todas la implementaciones anteriores tienen el fin de encontrar las ventajas y desventajas que
resulta después de desglosar el problema de distintas formas. Para cada una de las codificaciones
los resultados arrojados son distintos, aunque en teor´ıa el resultado es una constante; en la práctica
el resultado difiere en cada una de las aplicaciones.
Para hacer más evidente los resultados es necesario que los vectores x y y sean de tipo float y
llenados con número reales con signo, intercalados de preferencia.
En muchos lugares escuchamos que los nuevos diseños se deben adaptar a la necesidades, es
por ello que en todo momento nos referimos como opciones a todas las implementaciones; en esta
ocasión únicamente se someterán a pruebas de exactitud y de velocidad de ejecución.
En la tabla 3.1 podemos observar los resultados de exactitud de las funciones cuando se someten
con vectores de longitud n y con diez mil iteraciones para cada valor de n. Los resultados son
muy congruentes; para valores reducidos de n es más provechoso realizarlo con la versión canónica,

en caso contrario cuando n es grande dividir el ciclo en varias partes será mejor; en términos de
exactitud.
Tabla 3.1: Producto de dos vectores: resultados de prueba de exactitud, observamos las veces que
es más exacta, mostrada en porcentaje ( %), cada función durante las iteraciones para cada valor
de n.
Resultados de Prueba de Exactitud
Función y Exactitud ( %)
N Canónica 1 1a 2 3 4 5
16 49.90 26.26 10.63 1.27 7.10 3.50 1.34
32 39.38 29.04 11.50 1.86 10.74 5.59 1.89
64 29.20 28.17 12.00 2.99 15.35 8.52 3.77
128 22.01 23.80 12.70 4.45 18.06 12.84 6.14
256 17.42 28.17 10.73 6.01 19.26 16.10 9.76
512 13.44 20.72 10.01 7.46 18.62 19.22 13.52
1024 11.26 17.73 8.63 9.60 18.36 19.28 17.83
2048 9.68 15.04 9.08 10.18 17.30 20.76 19.53
4096 9.07 13.47 8.26 11.50 17.16 19.33 22.30
8192 8.30 12.38 7.95 12.45 16.40 20.56 22.78
16384 8.50 11.56 7.79 12.91 15.50 19.93 24.22
32768 7.67 10.55 7.98 13.57 15.06 19.62 25.55
Con base a lo que observamos en la tabla 3.1 decimos que si queremos cuidar la exactitud de la
operación, necesitamos desdoblar las operaciones en k-partes utilizando una variable distinta para
cada parte, donde k dependerá del orden de los vectores (x, y). Ello por motivo que en valores de
n pequeño es contraproducente, pero donde n tenga un valor suficientemente grande, la exactitud
mejorará conforme se implementen más desdobles.
Con base a estos resultados podemos inferir que es de vital importancia definir el grado de
exactitud que buscamos; lo cual se obtiene al aumentar la cantidad de desdobles. Por consecuencia
conforme aumentemos la cantidad de partes, el código fuente crecerá y se convertirá en tosco y
dificultará el entendimiento del mismo.
Una buena pregunta que surge con los resultados obtenidos es la siguiente: ¿Por qué los resulta-
dos son distintos para cada función?, la respuesta es muy simple, por problemas de redondeo, como
menciona Chapra et al.[12], estas diferencias son originadas porque las computadoras utilizan un
determinado número de cifras significativas para los cálculos. Es por ello que algunas operaciones

Esquemas iterativos en paralelo con OpenMP

Esquemas iterativos en paralelo con OpenMP

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (11)

Destacado

Destacado (11)

Similar a Esquemas iterativos en paralelo con OpenMP

Similar a Esquemas iterativos en paralelo con OpenMP (20)

Más de Sotero Ordones

Más de Sotero Ordones (8)

Último

Último (20)

Esquemas iterativos en paralelo con OpenMP