Arquitecturas de computadores_avanzadas

Rendimiento
de arquitecturas
multihilo
Modelos de programación
Francesc Guim
Ivan Rodero
PID_00184817

CC-BY-NC-ND • PID_00184817 Rendimiento de arquitecturas multihilo
Los textos e imágenes publicados en esta obra están sujetos –excepto que se indique lo contrario– a una licencia de
Reconocimiento-NoComercial-SinObraDerivada (BY-NC-ND) v.3.0 España de Creative Commons. Podéis copiarlos, distribuirlos
y transmitirlos públicamente siempre que citéis el autor y la fuente (FUOC. Fundación para la Universitat Oberta de Catalunya),
no hagáis de ellos un uso comercial y ni obra derivada. La licencia completa se puede consultar en http://creativecommons.org/
licenses/by-nc-nd/3.0/es/legalcode.es

CC-BY-NC-ND • PID_00184817 Rendimiento de arquitecturas multihilo
Índice
Introducción............................................................................................... 5
Objetivos....................................................................................................... 7
1. Factores importantes para la ley de Amdahl en
arquitecturas multihilo................................................................... 9
1.1. Factores vinculados al modelo de programación ....................... 10
1.1.1. Definición y creación de las tareas paralelas ................. 10
1.1.2. Mapeo de tareas a hilos ................................................. 12
1.1.3. Definición e implementación de mecanismos de
sincronización ................................................................ 15
1.1.4. Gestión de acceso concurrente en datos ....................... 19
1.1.5. Otros factores que hay que considerar .......................... 25
1.2. Factores ligados a la arquitectura ............................................... 25
1.2.1. Falsa compartición o false sharing.................................. 26
1.2.2. Penalizaciones para errores en la L1 y técnicas de
prefetch............................................................................. 29
1.2.3. Impacto del tipo de memoria caché .............................. 32
1.2.4. Arquitecturas multinúcleo y multiprocesador ............... 35
2. Entornos para la creación y gestión de hilos............................. 37
2.1. POSIX Threads ............................................................................ 37
2.1.1. Creación y destrucción de hilos .................................... 40
2.1.2. Espera entre hilos .......................................................... 41
2.1.3. Uso de memoria compartida y sincronización .............. 43
2.1.4. Señales entre hilos ......................................................... 45
2.1.5. Otras funcionalidades .................................................... 46
2.2. Modelo de programación Intel para aplicaciones paralelas ........ 46
2.2.1. Intel Cilk ........................................................................ 48
2.2.2. Intel Thread Building Blocks ......................................... 52
Resumen....................................................................................................... 62
Actividades.................................................................................................. 65
Bibliografía................................................................................................. 67

CC-BY-NC-ND • PID_00184817 5 Rendimiento de arquitecturas multihilo
Introducción
En el módulo "Arquitecturas multihilo", se han presentado diferentes arqui-
tecturas de procesadores que implementan más de un hilo de ejecución. Así
pues, existen arquitecturas que facilitan dos hilos de ejecución, como las sha-
red multithreading, y las hay que dan acceso a decenas de hilos de ejecución,
como las arquitecturas multinúcleo.
En general, una arquitectura es más compleja cuantos más hilos facilita. Las
arquitecturas multinúcleo son bastante escalables y pueden dar acceso a un
número elevado de hilos. Ahora bien, como se ha visto, para llevarlo a cabo
hay que diseñar sistemas que son más complejos. Un caso que ejemplifica este
aspecto es diseñar una red de interconexión que permita dar el ancho de banda
que los diferentes núcleos necesitan cuando se quiere acceder a una memoria
caché compartida de último nivel.
Cuanto más compleja es la arquitectura, más factores hay que tener en cuenta
a la hora de programarla. Si tenemos una aplicación que tiene una zona para-
lela que en un procesador secuencial se puede ejecutar en tiempo x, hay que
esperar que en una máquina multihilo con m hilos disponibles esta aplicación
potencialmente se pueda ejecutar en un tiempo de x/m. Sin embargo, hay cier-
tos factores inherentes al tipo de arquitectura sobre la que se está ejecutando
y al modelo de programación empleado que pueden limitar este incremento
de rendimiento. Por ejemplo, como se estudia más adelante, el acceso a los
datos que se encuentran compartidos por hilos que se están ejecutando en
diferentes núcleos.
Para obtener el máximo rendimiento de las arquitecturas sobre las que se eje-
cutan las aplicaciones paralelas, es necesario considerar las características de
estas arquitecturas. Por lo tanto, hay que considerar la jerarquía de memoria
del sistema, el tipo de interconexión sobre el que se envían datos y el ancho de
banda de memoria, entre otros. Es decir, si se quiere extraer el máximo rendi-
miento, habrá que rediseñar o adaptar los algoritmos a las características del
hardware que hay por debajo.
Si bien es cierto que hay que adaptar las aplicaciones en función de las arqui-
tecturas en las que se quieren ejecutar, también lo es que hay utilidades que
permiten no tener en cuenta algunas de las complejidades que presentan estas
arquitecturas. La mayoría aparecen en forma de modelos de programación y
bibliotecas que pueden ser empleados por las aplicaciones.
Durante este módulo, en primer lugar, se presentan los factores más impor-
tantes que pueden limitar el acceso al paralelismo que da una arquitectura,
ligados al modelo de programación. En segundo lugar, se tratan los factores

relacionados con las características de la arquitectura sobre la que se ejecutan.
Y, finalmente, se analizan algunos modelos de programación orientados a ma-
ximizar el uso de los recursos de arquitecturas de procesadores multihilo.

Objetivos
Los principales objetivos de este módulo son los siguientes:
1. Estudiar cuáles son los factores ligados al modelo de programación que
hay que tener en cuenta a la hora de desarrollar aplicaciones multihilo.
2. Estudiar cuáles son los factores ligados a la arquitectura de un procesador
multihilo que hay que considerar en el desarrollo de aplicaciones multi-
hilo.
3. Estudiar cuáles son las características del modelo de programación del
POSIX Threads y cómo hay que desarrollar aplicaciones paralelas emplean-
do su interfaz.
4. Estudiar cuáles son las características de los modelos de programación que
Intel facilita para desarrollar aplicaciones paralelas para sus arquitecturas
multihilo.
5. Profundizar en conceptos avanzados de la programación de arquitecturas
multihilo necesarios para desarrollar aplicaciones que necesiten un rendi-
miento alto.

1. Factores importantes para la ley de Amdahl en
arquitecturas multihilo
La ley de Amdahl establece que una aplicación dividida en una parte inheren-
temente secuencial (es decir, solo puede ser ejecutada por un hilo) y una parte
paralela P potencialmente podrá tener una mejora de rendimiento de S (en
inglés, speedup) solo aumentando el número de hilos de la aplicación en la
parte paralela.
Te = T x 1/(1 – P + P/S)
Ahora bien, para llegar al máximo teórico, es necesario considerar las restric-
ciones inherentes al modelo de programación y las restricciones inherentes a
la arquitectura sobre la que se está ejecutando la aplicación.
El primer conjunto de restricciones hace referencia a los límites vinculados al
algoritmo paralelo considerado, así como a las técnicas de programación em-
pleadas. Un caso en el que aparecen estas restricciones es cuando se ordena un
vector, puesto que hay limitaciones causadas por la eficiencia del algoritmo,
como por ejemplo radix sort, y por su implementación, como por ejemplo la
manera de acceder a las variables compartidas, entre otros.
El segundo conjunto hace referencia a límites ligados a las características del
procesador sobre el que se está ejecutando la aplicación. Factores como la je-
rarquía de memoria caché, el tipo de memoria caché o el tipo de red de inter-
conexión de los núcleos pueden limitar este rendimiento. Por ejemplo, puede
causar muchas ineficiencias que una variable se comparta entre dos hilos que
no se encuentran dentro del mismo núcleo.
En los dos próximos subapartados se presentan algunos de los factores más
importantes de estos dos bloques mencionados en los últimos párrafos. En el
primer conjunto no se estudian algoritmos paralelos (Gibbons y Rytte, 1988),
dado que no es el objetivo de este módulo, sino que se estudian los mecanis-
mos que usan estos algoritmos para implementar tareas paralelas y todos los
factores que hay que considerar. En el segundo bloque se tratan las caracterís-
ticas más relevantes de la arquitectura que hay que considerar en el desarrollo
de este tipo de aplicaciones.
Es importante destacar que los factores que se estudian a continuación son
una parte de los muchos que se han identificado durante las últimas décadas.
Debido a la importancia de este ámbito, se ha hecho mucha investigación cen-
trada en cómo mejorar el rendimiento de estas arquitecturas y cómo mejorar
el diseño de las aplicaciones que se ejecutan (como las aplicaciones de cálculo
numérico o las aplicaciones de cálculo del genoma humano). Para profundizar

más en los problemas y estudios llevados a cabo tanto en el ámbito académi-
co como en el empresarial, es muy recomendable extender la lectura de este
módulo didáctico con las referencias bibliográficas facilitadas.
1.1. Factores vinculados al modelo de programación
En otros módulos didácticos, se ha introducido el concepto de programación
paralela. También se han descrito las características más importantes que hay
que considerar en el desarrollo de algoritmos paralelos. En este subapartado,
se presentan los retos más importantes en este tipo de implementación y su
relación en las arquitecturas de procesadores multihilo.
1.1.1. Definición y creación de las tareas paralelas
En el diseño de algoritmos paralelos, se consideran dos tipos de paralelismo:
con relación a los datos y con relación a la función. El primero define qué par-
tes del algoritmo se ejecutan de manera concurrente y el segundo, la manera
como los datos se procesan de forma paralela.
En la creación del paralelismo con relación a la función es importante con-
siderar que las tareas que trabajen con las mismas funciones y datos tengan
localidad en el núcleo donde se van a ejecutar. De este modo, los flujos del
mismo núcleo comparten las entradas correspondientes a la memoria caché
de datos y también sus instrucciones.
El paralelismo con relación a los datos también tiene que considerar la locali-
dad comentada en el nivel de función, pero además debe tener en cuenta el
tamaño de las memorias caché del que dispone. Es decir, el flujo de instruc-
ciones tiene que trabajar con los datos de manera local en la L1 tanto como
se pueda y el resto intentarlas mantener a niveles de memoria caché tan cerca
como sea posible (L2 o L3). Por otro lado, también hay que evitar efectos ping-
pong entre los diferentes núcleos del procesador. Esto puede suceder cuando
hilos de diferentes núcleos accedan a los mismos bloques de direcciones de
forma paralela.
La figura 1 muestra un ejemplo de escenario que se debe evitar en la creación
de hilos, tanto en la asignación de tareas como en los datos. En este escenario,
los dos hilos número 0 de ambos núcleos están ejecutando la misma función
F(x). Esta función contiene un bucle interno que hace algunos cálculos sobre
el vector k y el resultado lo añade a la variable global k. Durante la ejecución
de estos hilos se observa que:
• Los dos núcleos cada vez que quieran acceder a la variable global k tendrán
que invalidar la L1 de datos del otro núcleo. Como ya se ha tratado en
el módulo "Arquitecturas multihilo", dependiendo del protocolo de cohe-

rencia puede ser extremamente costoso. Por lo tanto, este aspecto puede
bajar el rendimiento de la aplicación.
• Los dos hilos acceden potencialmente a los datos del vector l. Así pues,
las L1 de datos de ambos núcleos tendrán almacenadas los mismos datos
(asumiendo que la línea se encuentra en estado compartido). En este caso,
sería más eficiente que los dos hilos se ejecutaran en el mismo núcleo
para compartir los datos de la L1 de datos (es decir, más localidad). Esto
permitiría usar más eficientemente el espacio total del procesador.
• De modo similar, la L1 de instrucciones de ambos núcleos tendrá una copia
de las instrucciones del mismo código que ejecutan los dos hilos (F). Igual
que en el punto anterior, este aspecto provoca una utilización ineficiente
de los recursos.
Figura 1. Definición y creación de hilos
El ejemplo anterior muestra una situación bastante sencilla de solucionar.
Ahora bien, la definición, la creación de tareas y la asignación de datos no es
una tarea sencilla. Tal como se ha mencionado, hay que considerar la jerarquía
de memoria, la manera como los procesos se asignan a los núcleos o el tipo de
coherencia que el procesador facilita, entre otros.
Lecturas recomendadas
Para profundizar en este ámbito, es recomendable la lectura de:
X.Martorell;J.Corbalán;M.González;J.Labarta;N.Navarro;E.Ayguadé (1999).
Thread Fork/Join Techniques for Multi-level Parallelism Exploitation in NUMA Multi-
processors. En: 13th International Conference on Supercomputing.
B.Chapman;L.Huang;E.Biscondi;E.Stotzer;A.G.Shrivastava (2008). Implemen-
ting OpenMP on a High Performance Embedded Multicore MPSoC. IPDPS.

A pesar de la complejidad de esta tarea, hay muchos recursos que ayudan a
definir este paralelismo. Por ejemplo:
• Aplicaciones que permiten la paralelización automática de aplicaciones
secuenciales. Muchos compiladores incluyen opciones para generar códi-
go paralelo de forma automática. Ahora bien, es fácil encontrarse en situa-
ciones en las que el código generado no es óptimo o no tiene en cuenta
algunos de los aspectos introducidos.
• Aplicaciones que dan asistencia a la paralelización de los códigos secuen-
ciales. Por ejemplo, ParaWise (ParaWise, 2011) es un entorno que guía al
usuario en la paralelización de código Fortran. En cualquier caso, el resul-
tado puede ser similar a la paralelización automática.
• Finalmente, también hay bibliotecas que proporcionan interfaces para la
implementación de algoritmos paralelos. Estas interfaces acostumbran a
ser la solución más eficaz para sacar el máximo rendimiento de las apli-
caciones. Facilitan el acceso a funcionalidades que permiten definir el pa-
ralelismo con relación a los datos y funciones, afinidades de hilos a nú-
cleos o afinidades de datos a la jerarquía de memoria, entre otros. Algunas
de estas bibliotecas son, entre otras, OpenMP, Cilk (Intel, Intel Cilk Plus,
2011) y TBB (Reinders, 2007).
1.1.2. Mapeo de tareas a hilos
Una tarea es una unidad de concurrencia de una aplicación, es decir, inclu-
ye un conjunto de instrucciones que pueden ser ejecutadas de manera concu-
rrente (paralela o no) a las instrucciones de otras tareas. Un hilo es una abs-
tracción del sistema operativo que permite la ejecución paralela de diferentes
flujos de ejecución.
Una aplicación puede estar formada desde un número relativamente pequeño
de tareas hasta miles. Ejemplos claros de esto son los servidores de videojuegos
o los servidores de páginas web: pueden tener miles de tareas que atienden las
peticiones de los usuarios.
Sin embargo, el sistema operativo no puede dar acceso a un número tan ele-
vado de hilos de ejecución por la limitación de los recursos. Por un lado, la
gestión de un número tan elevado es altamente costosa (muchos cambios de
contextos, gestión de muchas interrupciones). Por otro lado, a pesar de que
potencialmente el sistema operativo puede dar acceso a un millar de hilos, el
procesador sobre el que se ejecutan las aplicaciones dará acceso a pocos hilos.
Por lo tanto, habrá que ir introduciendo cambios de contexto entre todos los
Lectura complementaria
ParaWise (2011). ParaWise:
the Computer Aided Paralleli-
zation Toolkit. [Fecha de con-
sulta: 27 de diciembre del
2011]. www.parallelsp.com/
parawise.htm

hilos disponibles en el sistema y los hilos que el hardware facilite. Este es el
motivo por el que el número de hilos del sistema estará configurado coheren-
temente con el número de hilos del procesador.
Para sacar el máximo rendimiento del procesador, la aplicación tendrá que
definir un mapeo eficiente y adecuado de las tareas que quiere ejecutar en los
diferentes hilos de los que dispone. Algunos de los algoritmos de mapeo de
tareas en hilos son los siguientes:
• Patrón máster/esclavo (master/slave): un hilo se encarga de distribuir las
tareas que quedan por ejecutar en los hilos esclavos que no estén ejecu-
tando nada. El número de hilos esclavos será variable.
• Patrón pipeline o cadena: en el que cada uno de los hilos ejecuta una ope-
ración específica en los datos que se están procesando, a la vez que facilita
el resultado en el siguiente hilo de la cadena.
• Patrón task pool: en el que hay una cola de tareas pendientes de ser eje-
cutadas y cada uno de los hilos disponibles toma una de estas tareas pen-
dientes cuando acaba de procesar el actual.
Este mapeo se podrá basar en muchos criterios diferentes. Sin embargo, los as-
pectos introducidos a lo largo de este módulo didáctico se tendrían que consi-
derar en arquitecturas multihilo heterogéneas. Dependiendo de cómo se asig-
nen las tareas en los hilos y de cómo los hilos estén asignados en los núcleos,
el rendimiento de las aplicaciones varía mucho.
Lectura recomendada
Un trabajo de investigación muy interesante en este aspecto es el presentado por Philbin
y otros en el artículo siguiente, donde los autores presentan técnicas de mapeo y gestión
de hilos para mantener la localidad en las diferentes memorias caché:
J.Philbin;J.Edler;O.J.Anshus;C.Douglas;K.Li (1996). Thread scheduling for ca-
che locality. En: Seventh International Conference on Architectural Support for Programming
Languages and Operating Systems.
Ejemplo de mapeo de tareas
Un ejemplo de esta situación se presenta en la figura 2. Una aplicación multi-
hilo se ejecuta sobre una arquitectura compuesta por dos procesadores, cada
uno de los cuales con acceso a memoria y los dos conectados por un bus. Los
hilos que se están ejecutando en el núcleo 2 y en el núcleo 3 accederán a los
datos y a la información que el máster les facilita.
Respecto a una red de interconexión local, el bus suele tener una latencia más
elevada y menos ancho de banda. Por este motivo, los hilos que se ejecutan en
el núcleo 2 y en el núcleo 3 tendrán un cierto desbalanceo respecto a los que se

ejecutan en el núcleo 0 y en el núcleo 1. Estos factores hay que considerarlos
a la hora de decidir cómo se tienen que asignar las tareas y el trabajo a cada
uno de los hilos.
En el ejemplo considerado, el rendimiento del procesador y de la aplicación
será bastante inferior al que potencialmente se podría lograr. En el instante de
tiempo T, el hilo esclavo del núcleo 1 habrá acabado de hacer el trabajo X. Los
hilos 0 y 1 del núcleo 1 tardarán un cierto tiempo (T') más en finalizar su tarea.
Y los hilos de los núcleos 2 y 3 tardarán un tiempo (T'') bastante superior a
T hasta acabar. Por lo tanto, los núcleos 0 y 1 estarán sin utilizar durante T –
T'' y T' – T'', respectivamente.
No solo la utilización del procesador será más baja, sino que este desbalanceo
hará finalizar la aplicación más tarde. En este caso, a la hora de diseñar el
reparto de tareas hay que tener en cuenta en qué arquitectura se ejecutará
la aplicación, así como cuáles son los elementos que potencialmente pueden
causar desbalanceos y qué hilos podrán llevar a cabo más trabajo por unidad
de tiempo.
Figura 2. Patrón máster/esclavo en un multinúcleo con dos procesadores

1.1.3. Definición e implementación de mecanismos de
sincronización
A menudo, las aplicaciones multihilo usan mecanismos para sincronizar las
tareas que los diferentes hilos están llevando a cabo. Un ejemplo se encuentra
en la figura presentada en el subapartado anterior (figura 2¡ErrorNoseen-
cuentraelorigendelareferencia.), en el que el hilo máster esperará a que
los esclavos acaben mediante funciones de espera.
En general, se suelen usar tres tipos de mecanismos diferentes de sincroniza-
ción:
• El uso de variables para controlar el acceso a determinadas partes de la
aplicación o a determinados datos de la aplicación (como un contador
global). Ejemplos de este tipo de variables son los semáforos o las de ex-
clusión mutua.
• El uso de barreras para controlar la sincronización entre los diferentes hilos
de ejecución. Estas nos permitirán asegurar que todos los hilos no pasan
de un determinado punto hasta que todos hayan llegado.
• El uso de mecanismos de creación y espera de hilos. Como en el ejemplo
anterior, el hilo máster esperará a la finalización de los diferentes hilos
esclavos mediante llamadas a funciones de espera.
Desde el punto de vista de las arquitecturas multihilo/núcleo, el segundo y el
tercer punto son menos intrusivos en el rendimiento de la aplicación (Villa,
Palermo y Silvano, 2008). Como se va a ver a continuación, las barreras son
mecanismos que se emplean en solo ciertas partes de la aplicación y que se
pueden implementar de forma eficiente dentro de un multihilo/núcleo. En
cambio, un uso excesivo de variables de control puede provocar un descenso
significativo del rendimiento de las aplicaciones.
Barreras en arquitecturas multinúcleo
La figura 3 presenta un ejemplo de posible implementación de barrera y cómo
se comportaría en un multinúcleo. En este caso, un hilo se encarga de controlar
el número de núcleos que han llegado a la barrera. Hay que destacar que el
núcleo 0, para acceder al vector A, tendrá todos estos datos en la L1, en estado
compartido o exclusivo.
O.Villa;G.Palermo;C.Sil-
vano (2008). Efficiency and
scalability of barrier syn-
chronization on NoC based
many-core architectures. En:
CASES '08. Proceedings of the
2008 International Conferen-
ce on Compilers, Architectures
and Synthesis for Embedded
Systems.

Figura 3. Funcionamiento de una barrera en un multinúcleo
Cada vez que un hilo i llegue a la barrera, querrá modificar la posición corres-
pondiente del vector. Por lo tanto, invalidará la línea correspondiente (la que
contiene A[i]) de todos los núcleos y la modificará. Cuando el núcleo 0 vuelva
a leer la dirección de A[i] tendrá que pedir el valor al núcleo i. En función del
tipo de protocolo de coherencia que implemente el procesador, el núcleo 0
invalidará la línea del núcleo i o bien la moverá al estado compartido.
Tal como se puede deducir de este ejemplo, el rendimiento de una barrera
podrá ser más o menos eficiente en función de su implementación y de la
arquitectura sobre la que se está ejecutando. Así, una implementación en la
que, en lugar de un vector, hay una variable global que cuenta los que han
acabado sería más ineficiente, puesto que los diferentes núcleos tendrían que
competir para coger la línea, invalidar los demás núcleos y escribir el valor
nuevo.
Mecanismos de exclusión mutua en arquitecturas multinúcleo
Tal como se ha introducido previamente, estos mecanismos se emplean para
poder acceder de manera exclusiva a ciertas partes del código o a ciertas va-
riables de la aplicación. Estos mecanismos son necesarios para mantener el
acceso coordinado a los recursos compartidos y evitar condiciones de carreras,
interbloqueos (deadlocks) o situaciones similares. Algunos de estos tipos de re-
cursos son semáforos, mutex-locks o read-writer locks.
En arquitecturas de un solo núcleo, el acceso a estos tipos de estructuras pue-
de tener un impacto relativamente inferior. Con mucha probabilidad, todos
los hilos estarán compartiendo los accesos a las mismas líneas de la L1 que

las guardarán. Sin embargo, en un sistema multinúcleo, el acceso concurrente
de diferentes hilos a estas estructuras puede comportar problemas de escala-
bilidad y de rendimientos graves. De forma similar a lo que se ha mostrado
con las barreras, el acceso a las líneas de memoria que contienen las variables
empleadas para gestionar la exclusión mutua implicará invalidaciones y mo-
vimientos de líneas entre los núcleos del procesador.
Figura 4. Adquisición de una variable de exclusión mutua
La figura 4 muestra un escenario en el que el uso frecuente de acceso a zonas
de exclusión mutua entre los diferentes hilos puede reducir sustancialmente
el rendimiento de la aplicación. En este ejemplo, se asume un protocolo de
coherencia entre los diferentes núcleos de tipo snoop, por lo tanto, cada vez
que uno de los hilos de un núcleo quiere tomar la propiedad de la variable de
exclusión mutua (lock) tiene que invalidar todo el resto de núcleos. Hay que
hacer notar que la línea de la memoria caché que contiene la variable en cues-
tión se encontrará en estado modificado siempre que el núcleo la actualice.
Cada vez que un hilo toma el lock, modifica la variable para marcarla como
propia. En el caso de que el hilo solo lo esté consultando, no habría que inva-
lidar los demás núcleos.

Se puede asumir que la variable se reenvía del núcleo que la tiene (el núcleo 0)
al núcleo que la pide (el núcleo 3) en estado modificado. Ahora bien, depen-
diendo de qué tipo de protocolo de coherencia implemente el procesador, la
línea se escribirá primero en memoria, y entonces, el núcleo 3 la podría leer.
En este caso, el rendimiento sería extremamente bajo: por cada lectura del lock
x, se invalidarían todos los núcleos, así, el que la tuviera en estado modificado
la escribiría en la memoria y finalmente el núcleo que lo estuviera pidiendo
la leería de la memoria (figura 5).
Figura 5. Lectura del lock x en estado exclusivo
Tal como se ha podido ver, es recomendable un uso moderado de este tipo de
mecanismos en arquitecturas con muchos núcleos y también en arquitecturas
heterogéneas. Así pues, a la hora de decidir qué tipo de mecanismos de sincro-
nización se usan, hay que considerar la arquitectura sobre la que se ejecuta la
aplicación (jerarquía de memoria, protocolos de coherencia e interconexiones
entre núcleos) y cómo se implementan todos estos mecanismos.
Lectura recomendada
Para profundizar en la creación de mecanismos de exclusión mutua escalables en arqui-
tecturas multinúcleo, se recomienda la lectura del artículo siguiente:
M.Chynoweth;M.Lee (2009). Implementing Scalable Atomic Locks for Multe-Core. [Fecha
de consulta: 28 de diciembre del 2011]. http://software.intel.com/en-us/articles/imple-
menting-scalable-atomic-locks-for-multi-core-intel-em64t-and-ia32-architectures/

1.1.4. Gestión de acceso concurrente en datos
En el subapartado anterior, se han estudiado las implicaciones de usar diferen-
tes técnicas de exclusión mutua en arquitecturas multiprocesador. Este tipo de
técnicas se emplean para asegurar que el acceso a los datos entre diferentes
hilos es controlado. Si no se usan estas técnicas de manera adecuada, las apli-
caciones pueden acabar teniendo carreras de acceso o race accesses.
En general, se pueden distinguir dos tipos de carreras de acceso que hay que
evitar cuando se desarrolla un código paralelo:
• Carreras de acceso a datos: estas suceden cuando diferentes hilos están ac-
cediendo de forma paralela a las mismas variables sin ningún tipo de pro-
tección. Para que suceda una carrera de este tipo, uno de los accesos tiene
que estar hecho en forma de escritura. La figura 6 muestra un código que
potencialmente puede tener un acceso a carrera de datos. Suponiendo que
los dos hilos se están ejecutando en el mismo núcleo, cuando ambos hilos
llegan a la barrera, ¿qué valor tiene a? Dado que el acceso a esta variable
no está protegido y se accede tanto en modo lectura como escritura (aña-
diendo 5 y -5), esta variable puede tener los valores siguientes: 0, 5 y -5.
• Carreras de acceso generales: este tipo de carreras suceden cuando dos hi-
los diferentes tienen que seguir un orden específico en la ejecución de
diferentes partes de su código, pero no tenemos estructuras que fuercen
este orden. La tabla muestra un ejemplo de este tipo de carreras. Ambos
hilos usan una estructura guardada en la memoria compartida, en la que
el primer hilo pone un trabajo y el segundo lo procesa. Tal como se puede
observar, si no se añade ningún tipo de control o variable de control, es
posible que el hilo 2 finalice su ejecución sin procesar el trabajo a.
Hay que mencionar que una carrera de acceso a datos es un tipo específico
de carrera de acceso general. Ambos tipos se pueden evitar usando los meca-
nismos de acceso introducidos en el subapartado anterior (como barreras o
variables de exclusión mutua). Siempre que se diseñe una aplicación multihi-
lo, hay que considerar que los accesos en modo escritura y lectura a partes
de memorias compartidas tienen que estar protegidos; si los diferentes hilos
asumen un orden específico en la ejecución de diferentes partes del código,
hay que forzarlo mediante mecanismos de sincronización y espera.

Figura 6. Carrera de acceso a datos
El primero de los dos ejemplos presentados (figura 6) se puede evitar añadien-
do una variable de exclusión mutua que controle el acceso a la variable a. De
este modo, independientemente de quién acceda primero a modificar el valor
de la variable, este valor, una vez llegado a la barrera, será 0. El segundo de los
dos ejemplos se podría evitar empleando mecanismos de espera entre hilos, es
decir, como se puede ver en la tabla 2, el segundo hilo tendría que esperar a
que el primer hilo notificara que le ha facilitado el trabajo.
Tabla 1. Ejemplo de carrera de acceso general
Hilo1 Hilo2
Trabajo a = nuevo_trabajo();
Configurar_Trabajo(a);
EncolaTrabajo(a,cola);
PostProceso();
Trabajo b = CogeTrabajo(cola);
si(b != INVALID)
ProcesaTrabajo(b);
Acaba();
Tabla 2. Evita la carrera de acceso mediante sincronización
Hilo1 Hilo2
Trabajo a = nuevo_trabajoeball();
Configurar_Trabajo(a);
EncolaTrabajo(a,cola);
NotificaTrabajoDisponible();
PostProceso();
EsperaTrabajo();
Trabajo b = CogeTrabajo(cola);
si(b != INVALID)
ProcesaTrabajo(b);
Acaba();
Condiciones de carrera en arquitecturas multinúcleo
En el subapartado anterior, se han introducido varias situaciones en las que el
uso de memoria compartida entre diferentes hilos es inadecuado. La primera,
las carreras de acceso a datos, tiene lugar cuando dos hilos diferentes están
leyendo y escribiendo de manera descontrolada en una zona de memoria. Se
ha mostrado que el valor de una variable puede ser funcionalmente incorrecto

cuando ambos hilos finalizan sus flujos de instrucciones (tabla 1). Ahora bien,
¿esta cadena de acontecimientos sucede de este modo independientemente de
la arquitectura y del mapeo de hilos sobre los que se ejecuta la aplicación?
En este subapartado, se quiere mostrar que el mismo código se puede compor-
tar de manera diferente dentro de un mismo procesador en función de cómo
se asignen los hilos a los núcleos, puesto que dependiendo de este aspecto la
condición de carrera analizada en el subapartado anterior sucederá o no.
Supongamos los dos escenarios mostrados en la figura 7.
Figura 7. Dos mapeos de hilos diferentes ejecutando el ejemplo anterior
En el primero de los dos escenarios, los dos hilos se están ejecutando en el
mismo núcleo. Tal como se muestra en la figura 8, los dos hilos acceden al
contenido de la variable a de la misma memoria caché de nivel dos. Primero
el hilo 1 lee el valor.

Figura 8. Acceso compartido a a en un mismo núcleo
A continuación, a pesar de que el hilo 1 ya está modificando la variable, el
segundo hilo lee el valor original. Finalmente, ambos hilos escribirán los va-
lores en la memoria. Sin embargo, el segundo hilo sobrescribirá el valor actual
(5) por el valor resultante de la operación aritmética que el hilo habrá aplica-
do (-5). Este flujo de acontecimientos, como se ha visto, es funcionalmente
incorrecto, es decir, el resultado de la ejecución de los diferentes hilos no es el
esperado por la aplicación en cuestión.
Asumamos ahora el segundo de los escenarios, en el que cada uno de los hilos
se ejecuta en un núcleo diferente. Tal como se ha visto en el módulo Arquitec-
turas multihilo, en las arquitecturas de procesadores con memoria coherente,
si dos núcleos diferentes están accediendo en un mismo momento a una mis-
ma línea de memoria el protocolo de coherencia asegurará que solo un núcleo
pueda modificar el valor de esa línea. Por lo tanto, en un instante de tiempo
tan solo un núcleo podrá tener la línea en estado exclusivo para modificarla.
En este escenario nuevo, y gracias al protocolo de coherencia, la carrera de
acceso mostrada en el caso anterior no sucederá. Como se puede ver en la
figura 9, el protocolo de coherencia protegerá el acceso en modo exclusivo a
la variable a. Cuando el primer hilo quiere leer el valor de la variable en modo
exclusivo para modificarlo, invalida todas las copias de los núcleos del sistema

(en este caso solo uno). Una vez el núcleo 0 notifica que tiene la línea en estado
inválido, pide el valor a la memoria caché de tercer nivel. Para simplificar el
ejemplo, supongamos que modifica el valor de a tan pronto como la recibe.
A continuación, el hilo 0 que se está ejecutando en el núcleo 1, para coger la
línea en modo exclusivo, invalida la línea de los demás núcleos del sistema
(núcleo 0). Cuando el núcleo 0 recibe la petición de invalidación, este valida
el estado. Al estar en estado modificado, escribe el valor en la memoria caché
de tercer nivel. Una vez recibe el acknowlegement
1
, responde al núcleo 1 que
la línea está en estado inválido. Llegado a este punto, el núcleo 1 pedirá el
contenido a la L3, recibirá la línea, la modificará y lo escribirá de vuelta con
el valor correcto.
Por un lado, es importante destacar que, si bien en este caso no se da la ca-
rrera de acceso, la implementación paralela sigue teniendo un problema de
sincronización. Dependiendo de qué tipo de mapeo se aplique a los hilos de
la aplicación se encontrará el error ya estudiado.
(1)
De ahora en adelante, abreviare-
mos acknowlegement como ack.

Figura 9. Acceso compartido a a en núcleos diferentes
Por el otro lado, hay que tener presente que, dependiendo de qué tipo de
protocolo de coherencia implemente el procesador, el comportamiento de la
aplicación podría variar. Por este motivo, es realmente relevante emplear las
técnicas de sincronización para hacer su ejecución determinista y no ligada a
factores arquitectónicos o de mapeo.

1.1.5. Otros factores que hay que considerar
Durante este subapartado, se han presentado diferentes factores que hay que
considerar a la hora de diseñar, desarrollar y ejecutar aplicaciones paralelas en
arquitecturas multihilo, así como las características principales y las implica-
ciones que estas aplicaciones tienen sobre las arquitecturas multihilo.
Como se ha mencionado, el diseño de aplicaciones paralelas es un campo en el
que se ha hecho mucha investigación (tanto académica como industrial). Por
lo tanto, es aconsejable profundizar en algunas de las referencias facilitadas.
Otros factores que no se han mencionado, pero que también son importantes
son los siguientes:
• Los interbloqueos. Estos suceden cuando dos hilos se bloquean esperando
un recurso que tiene el otro. Ambos hilos permanecerán bloqueados para
siempre, por lo tanto bloquearán la aplicación (Kim y Jun, 2009).
• Composición de los hilos paralelos. Es decir, la manera como se organizan
los hilos de ejecución. Esta organización depende del modelo de progra-
mación (como OpenMP o MPI) y de cómo se programa la aplicación (por
ejemplo, depende de si los hilos están gestionados por la aplicación con
POSIX Threads).
• Escalabilidad del diseño. Factores como el número de hilos, la baja con-
currencia en el diseño o bien demasiada contención en los accesos a los
mecanismos de sincronización pueden reducir sustancialmente el rendi-
miento de la aplicación (Prasad, 1996).
En el subapartado siguiente, se presentan algunos factores que pueden impac-
tar en el rendimiento de las aplicaciones paralelas que no se encuentran direc-
tamente ligados al modelo de programación. Como se verá a continuación,
algunos de estos factores aparecen dependiendo de las características del pro-
cesador multihilo sobre el que se ejecuta la aplicación.
1.2. Factores ligados a la arquitectura
Durante los subapartados siguientes se estudian algunos de los factores más
importantes que hay que tener en cuenta cuando se desarrollan aplicaciones
paralelas para arquitecturas multihilo.
Por un lado, como se ve a continuación, la compartición de recursos entre
diferentes hilos puede comportar situaciones de conflicto que degradan mu-
cho el rendimiento de las aplicaciones. Un caso de compartición es el de las
mismas entradas de una memoria caché.
Para profundizar en este as-
pecto se recomienda la lectu-
ra de:
B.-C.Kim;S.-W.H.-K.Jun
(2009). Visualizing Potential
Deadlocks in Multithreaded
Programs. En: 10th Interna-
tional Conference on Parallel
Computing Technologies.
S.Prasad (1996). Multithrea-
ding Programming Techniques.
Nueva York: McGraw-Hill,
Inc.

Por el otro lado, el diseño de las arquitecturas multihilo implica ciertas restric-
ciones que hay que considerar implementando las aplicaciones. Por ejemplo,
tal como se ha visto en el módulo Arquitecturas multihilo, un procesador
multinúcleo tiene un sistema de jerarquía de memoria en el que los niveles
inferiores (por ejemplo, la L3) se comparten entre diferentes hilos y los supe-
riores se encuentran separados por el núcleo (por ejemplo, la L1). Los errores
en los niveles superiores son bastante menos costosos que en los niveles infe-
riores. Sin embargo, el tamaño de estas memorias es bastante inferior y, por
lo tanto, hay que adaptar las aplicaciones para que tengan el máximo de local
posible en los niveles superiores.
Este subapartado está centrado en aspectos ligados a los protocolos de cohe-
rencia y gestión de memoria, a pesar de que hay otros muchos factores que de-
bemos considerar si se quiere sacar el máximo rendimiento del algoritmo que
se está diseñando. Por ejemplo, nos referimos a optimizaciones del compila-
dor (Lo, Eggers, Levy, Parekh y Tullsen, 1997), características de las memorias
caché (Hily y Seznec, 1998) o el juego de instrucciones del procesador (Kumar,
Farkas, Jouppi, Ranganathan y Tullsen, 2003). Recomendamos al estudiante
profundizar en las diferentes referencias facilitadas.
J.L.Lo;S.J.Eggers;H.M.Levy;S.S.Parekh;D.M.Tullsen (1997). Tuning Compiler
Optimizations for Simultaneous Multithreading. En: International Symposium on Micro-
architecture (págs. 114-124).
S.Hily;A.Seznec (1998). Standard Memory Hierarchy Does Not Fit Simultaneous Mul-
tithreading. En: Workshop on Multithreaded Execution, Architecture, and Compilation.
R.Kumar;K.I.Farkas;N.P.Jouppi;P.Ranganathan;D.M.Tullsen (2003). Single-ISA
Heterogeneous Multi-Core Architectures: The Potential for Processor Power Reduction (págs.
81-92).
1.2.1. Falsa compartición o false sharing
En muchas situaciones, se querrá que diferentes hilos de la aplicación compar-
tan zonas de memoria concretas. Tal como se ha visto antes, a menudo se dan
situaciones en las que diferentes hilos comparten contadores o estructuras en
las que se dejan datos resultantes de cálculos hechos por cada uno de ellos,
donde se usan variables de exclusión mutua para proteger estas zonas.
Los datos que los diferentes hilos están usando en un instante de tiempo con-
creto se encuentran guardados en las diferentes memorias caché de la jerarquía
(desde la memoria caché de último nivel hasta la memoria caché de primer
nivel del núcleo que la está usando). Por lo tanto, en los casos en los que dos
hilos están compartiendo un dato también compartirán las mismas entradas
de las diferentes memorias caché que guardan este dato. Por ejemplo, en la
figura 8 introducida antes ambos hilos acceden a la misma entrada de la L1
que guarda la variable a.

Desde el punto de vista del rendimiento, lo que se busca es que los accesos de
los diferentes hilos acierten alguna de las memorias caché (cuanto más cerca-
na al núcleo mejor), puesto que el acceso a la memoria es muy costoso. Esto
se llama mantener la localidad en los accesos (Grunwald, Zorn y Henderson,
1993).
Lecturas complementarias
D.Grunwald;B.Zorn;R.Henderson (1993). Improving the cache locality of memory
allocation. En: ACM SIGPLAN 1993, Conference on Programming Language Design and Im-
plementation.
J.Handy (1998). The cache memory book. Londres: Academic Press Limited.
A.Seznec (1993). A case for two-way skewed-associative caches. En: 20th Annual Inter-
national Symposium on Computer Architecture.
Ahora bien, se pueden dar situaciones en las que las mismas entradas de la
memoria caché sean compartidas por datos diferentes. El cálculo de qué en-
trada de una memoria caché se usa se define en función de la asociatividad y
del tipo de mapeo de la memoria (Handy, 1998). Por ejemplo, una memoria 2
asociativa (Seznec, 1993) dividirá la memoria caché en conjuntos de dos en-
tradas. Primero, se calculará a cuál de los conjuntos pertenece la dirección y
después se escogerá cuál de las dos entradas del conjunto se usa.
Se puede dar la situación en la que dos hilos estén accediendo a dos bloques
de memoria diferentes, que se mapean en el mismo conjunto de una memoria
caché. En este caso, los accesos de un hilo a su bloque de memoria invalidarán
los datos del otro hilo guardados en las mismas entradas de la memoria. A
pesar de que las direcciones coincidirán en las mismas entradas de la memoria,
los datos y las direcciones serán diferentes. Por lo tanto, para cada acceso se
invalidan los datos del otro hilo y se pide el dato en el siguiente nivel de la
jerarquía memoria (por ejemplo, la L3 o memoria principal). Como se puede
deducir, este aspecto implica una reducción importante del rendimiento de la
aplicación. Esto se denomina falsa compartición o false sharing.

Figura 10. Falsa compartición en la L3
La figura 10 muestra un ejemplo de lo que podría pasar en una arquitectura
multinúcleo en la que dos hilos de diferentes núcleos están experimentando
falsa compartición en el mismo set de la L3. Para cada acceso de uno de los hi-
los se invalida una línea del otro hilo, que se encuentra guardada en el mismo
conjunto. Como se observa, para cada acceso se generan un número impor-
tante de acciones: invalidación de dirección en el otro núcleo, lectura en la L3,
se victimiza el dato del otro hilo del otro núcleo y se escribe en la memoria si
es necesario, se lee el dato en la memoria y se envía al núcleo que la ha pedido.
En el caso de que ambos hilos no tuvieran conflicto en los mismos conjuntos
de la L3, con alta probabilidad acertarían en la L3 y se ahorrarían el resto de
transacciones que tienen lugar por culpa de la falsa compartición.

La falsa compartición se puede detectar cuándo una aplicación muestra un
rendimiento muy bajo y el número de invalidaciones de una memoria caché
concreta y permisos es mucho más elevado de lo esperado. En este caso, es
muy probable que dos hilos estén compitiendo por los mismos recursos de la
memoria caché. Hay herramientas como el VTune de Intel (Intel, Boost Perfor-
mance Optimization and Multicore Scalability, 2011), que permiten detectar este
tipo de problemas.
Evitar la falsa compartición es relativamente más sencillo de lo que puede pa-
recer. Una vez se han detectado cuáles son las estructuras que probablemente
están causando este efecto, hay que añadir un desplazamiento para que caigan
en posiciones de memoria diferente para cada uno de los hilos. De este modo,
cuando se haga el cómputo para saber a qué conjunto de la memoria caché se
asigna la variable, este set será diferente.
1.2.2. Penalizaciones para errores en la L1 y técnicas de prefetch
Muchas aplicaciones paralelas tienen una alta localidad en las memorias caché
del núcleo sobre las que se están ejecutando. Es decir, la mayoría de accesos
que se hacen a la memoria aciertan la memoria caché de primer nivel.
Ahora bien, los casos en los que las peticiones a la memoria no aciertan la me-
moria caché del núcleo tienen que hacer un proceso mucho más largo hasta
que el dato está a disposición del hilo: petición a la L3, error en la L3, petición
a memoria, etc. Evidentemente, cuanto más alto es el porcentaje de errores,
más penalizada se encuentra la aplicación. La causa es que un acceso a la me-
moria que falla en la L1 tiene una latencia mucho más elevada que uno que
acierta (una o dos órdenes de magnitudes más elevadas, dependiendo de la
arquitectura y protocolo de coherencia).
Una de las técnicas que se usan para tratar de esconder la latencia más larga
de las peticiones que fallarán en la memoria caché se denomina prefecthing.
Esta técnica consiste en pedir el dato a la memoria mucho más pronto de lo
que la aplicación lo necesita. De este modo, cuando realmente lo necesita este
ya se encontrará en la memoria local del núcleo (L1). Por lo tanto, acertará,
la latencia de la petición a la memoria será mucho más baja y la aplicación
no se bloqueará.
Hay dos tipos de técnicas de prefetching que se usan en las arquitecturas mul-
tinúcleo, el hardware prefetching y el software prefetching.
Intel (2011). Boost Performan-
ce Optimization and Multicore
Scalability. [Fecha de consul-
ta: 3 de enero del 2012].
http://software.intel.com/
en-us/articles/intel-vtu-
ne-amplifier-xe/

El hardware prefetching
Las primeras de estas técnicas se implementan en las piezas de los núcleos
que se denominan hardware prefetchers. Estos intentan predecir cuáles serán las
próximas direcciones que la aplicación pedirá y las piden de forma proactiva
antes de que la aplicación lo haga.
Este componente se basa en técnicas de predicción que no requieran una lógi-
ca muy compleja, por ejemplo cadenas de Markov (Joseph y Grunwald, 1997).
El problema principal de este tipo de técnicas es que son agnósticas respecto a
lo que la aplicación está ejecutando. Por lo tanto, a pesar de que para algunas
aplicaciones puede funcionar bastante bien, para otras las predicciones pue-
den ser erróneas y hacer que el rendimiento de la aplicación empeore.
El software prefetching
La mayoría de sistemas multinúcleo facilitan instrucciones para que las apli-
caciones puedan pedir de manera explícita los datos a la memoria, usando la
instrucción de prefetch. Por ejemplo, en la arquitectura Intel se usa la instruc-
ción vprefetch. La aplicación es responsable de pedir los datos a la memoria de
manera anticipada usando esta instrucción.
La ventaja de este mecanismo es que la aplicación sabe exactamente cuándo
necesitará los datos. Por lo tanto, basándose en la latencia de un acceso a la
memoria, tendrá que pedir los datos con el número de ciclos suficientes para
que, cuando la necesite, la tenga. El uso de este tipo de prefetch es el que suele
permitir obtener el rendimiento más elevado de la aplicación.
La desventaja principal es que el código se encuentra ligado a una arquitectura
concreta. Es decir, la mayoría de arquitecturas multinúcleo tendrán latencias
diferentes. Por lo tanto, cada vez que se quiera ejecutar esta aplicación en una
nueva plataforma, tendremos que calcular las distancias de prefetch adecuadas
en el nuevo sistema.
D.Joseph;D.Grunwald
(1997). Prefetching using
Markov predictors. En: 24th
Annual International Sympo-
sium on Computer Architecture.

Figura 11. Ejemplo de prefetch
La figura 11 presenta un ejemplo de cómo un prefetch funcionaría en un siste-
ma formado por un multinúcleo con una memoria caché de tercer nivel. En
este caso, la aplicación necesita el dato a en el ciclo X, asumiendo que, si la
latencia de un acceso a la memoria que falla en la L3 es de 400 ciclos, tendrá
que lanzar el prefetch X – 400 ciclos antes.
Sin embargo, hay que tener en cuenta las consideraciones siguientes.
• Los prefetch suelen poder ser eliminados del pipeline del procesador si no
hay bastantes recursos para llevarlo a cabo (por ejemplo, si la cola que
guarda los datos que vuelven de la L3 está llena). Por lo tanto, si el número
de prefetch que lanza una aplicación es demasiado elevado, estos pueden
ser eliminados del sistema.
• La latencia de las peticiones a memoria puede variar dependiendo del ca-
mino que sigan. Por ejemplo, un acierto en la L3 hará que un dato esté
disponible en la misma memoria L3 mucho antes de lo previsto y, en el
caso de que hubiera una víctima interna, esta sería mucho más tardía. Al
emplear este tipo de peticiones, hay que tener en cuenta el uso de toda

la jerarquía de memoria, así como las características de la aplicación que
se usa.
• Los prefetch pueden tener impactos de rendimiento tanto positivos como
negativos en la aplicación desarrollada. Hay que estudiar qué requerimien-
tos tiene la aplicación desarrollada y cómo se comportan en la arquitectu-
ra que está ejecutando la aplicación.
Lectura recomendada
El uso de técnicas de prefetch en arquitecturas multihilo es un recurso frecuente para
sacar rendimiento en aplicaciones paralelas. Por este motivo, se recomienda la lectura
del artículo:
Intel (2007). Optimizing Software for Multi-core Processors. Portland: Intel Corporation -
White Paper.
1.2.3. Impacto del tipo de memoria caché
Cada vez que un núcleo accede a una línea de memoria por primera vez, lo
tiene que pedir al siguiente nivel de memoria. En los ejemplos estudiados, los
errores en la L2 se pedirán a la L3 y los errores en la L3 se pedirán a la memoria.
Cada uno de estos errores generará un conjunto de víctimas en las diferentes
memorias caché, así es necesario liberar una entrada por la línea que se está
pidiendo.
Para obtener rendimiento de las aplicaciones paralelas que se desarrollan es
importante mantener al máximo la localidad en los accesos a las memorias
caché. Es decir, debemos maximizar el reuso (porcentaje de acierto) en las di-
ferentes memorias caché (L1, L2, L3 y demás). Por este motivo, es importante
considerar las características de la jerarquía de memoria caché: inclusiva/no
inclusiva/exclusiva, tamaños, etc.
A continuación, se tratan los diferentes puntos mencionados desde el punto
de vista de la aplicación.
Inclusividad
En el caso de que dos memorias (Lx y Lx – 1) sean inclusivas, querrá decir que
cualquier dirección @X que se encuentra en la Lx – 1 estará siempre en la Lx.
Por ejemplo, si la L1 es inclusiva con la memoria L2, esta incluirá la L1 y otras
líneas. En este caso, habrá que considerar que:
1) Cuando una línea de la Lx – 1 se victimiza, al final de la transacción esta
estará disponible en el siguiente nivel de memoria Lx.

2) Cuando una línea de la Lx se victimiza, al final de la transacción esta línea
ya no estará disponible en el nivel superior Lx – 1. Por ejemplo, en el caso de
victimizar la línea @X en L3, esta se invalidará también en las memoria caché
L2. Y si la L1 es inclusiva con la L2, la primera también invalidará la línea en
cuestión.
3) Cuando un núcleo lee una dirección @X que no se encuentra en la memoria
Lx – 1, al final de la transacción esta también se encontrará incluida en la Lx.
Por ejemplo, en el caso de que tengamos una L1, L2 y L3 inclusivas, la @X
se escribirá en todas las memorias. Hay que destacar que cada una de estas
entradas usadas potencialmente habrá generado una víctima. Es decir, una
dirección @Y que usa el way y el set en el que se ha guardado @X. La selección
de esta posición dependerá de la política de gestión de cada memoria caché,
así como de su tamaño.
Los puntos 2 y 3 pueden causar un impacto bastante importante en el rendi-
miento de la aplicación. Por lo tanto, es importante diseñar las aplicaciones
para que el número de víctimas generadas en niveles superiores sea tan peque-
ño como sea posible y maximizar el porcentaje de aciertos de las diferentes
jerarquías de memoria caché más cercanas al núcleo (por ejemplo, L1).
Exclusividad y no inclusividad
En el caso de que dos memorias caché sean exclusivas, implicará que, si la
memoria caché Lx tiene una línea @X, la memoria caché Lx – 1 no la tendrá.
No se suelen tener arquitecturas en las que todos los niveles sean exclusivos.
Habitualmente, las jerarquías que tienen memorias caché exclusivas suelen
ser híbridas.
Un ejemplo de procesador con memoria exclusiva es el AMD Athlon (AMD,
2011) y el Intel Nehalem (Intel, Nehalem Processor, 2011). El primero tiene
una L1 exclusiva con la L2. El segundo tiene una L2 y una L1 no inclusivas y
la L3 es inclusiva de la L2 y la L1.
En los casos en los que una memoria caché Lx es exclusiva con Lx – 1, habrá
que considerar que:
• Cuando se accede a una línea @Y en la memoria Lx – 1, esta se moverá
de la memoria Lx.
• Cuando una línea se victimiza de la memoria Lx – 1, esta se moverá a
la memoria caché Lx. En estos casos, por el hecho de que la memoria es
exclusiva, habrá que encontrar una entrada a la memoria Lx. Por lo tanto,
hará falta victimizar la línea que se encuentre guardada en el way y en el
set seleccionados.

• Cuando una línea se victimiza de la memoria Lx, no será necesario victi-
mizar la memoria caché Lx – 1.
Habrá ciertas situaciones en las que deberemos conocer en detalle qué tipo de
jerarquía de memoria y protocolo de coherencia implementa el procesador.
Por ejemplo, si se considera una arquitectura multinúcleo en la que la L1 es
exclusiva con la L2, en los casos en los que los diferentes hilos estén compar-
tiendo el acceso a un conjunto elevado de direcciones el rendimiento de la
aplicación se puede ver deducido. En esta situación, cada acceso a un dato @X
en un núcleo podría implicar la victimización de esta misma dirección en otro
núcleo y pedir la dirección a la memoria.
Algunas memorias caché exclusivas permiten que en ciertas situaciones algu-
nos datos se encuentren en dos memorias que son exclusivas entre ellas por
defecto. Por ejemplo, en las líneas de memoria que se encuentran compartidas
por diferentes núcleos.
El tamaño de la memoria
Como se ha tratado, el rendimiento de la aplicación dependerá en gran medida
de la localidad de los accesos de los diferentes hilos a las memorias caché.
En situaciones en las que los hilos piden varias veces las mismas líneas a la
memoria por mala praxis de programación, el rendimiento de la aplicación
caerá sustancialmente. Esto sucederá en aquellos casos en los que un núcleo
pide una dirección @X, esta línea se victimiza y se vuelve a pedir más tarde.
Un ejemplo sencillo es, al acceder a una matriz de enteros de 8 bytes por fi-
las, cuando esta se encuentra almacenada por columnas. En este caso, cada 8
enteros consecutivos de una misma columna se encontrarían mapeados en la
misma línea. Ahora bien, los elementos i e i + 1 de una fila estarían guardados
en líneas diferentes. Por lo tanto, en el caso de recorrer la matriz por columnas,
el número de errores en la L1 será mucho más elevado.
Por este motivo, es importante usar técnicas de acceso a los datos que intenten
mantener localidad en las diferentes memorias caché. De manera similar a
otros factores ya introducidos antes, se ha hecho mucha investigación en este
ámbito.
Una referencia en técnicas de partición en bloques por la multiplicación de matrices es:
K.Kourtis;G.Goumas;N.Koziris (2008). Improving the Performance of Multithrea-
ded Sparse Matrix-Vector Multiplication Using Index and Value Compression. En: 37th
International Conference on Parallel Processing.
En técnicas de compresión en el proceso de grafs, sería:
R.Jin;T.-S.Chung (2010). Node Compression Techniques Based on Cache-Sensitive B
+-Tree. En: 9th International Conference on Computer and Information Science (ICIS) (págs.
133-138).

Sin embargo, en muchos casos las aplicaciones paralelas diseñadas no siguen
ninguno de los patrones analizados en otros estudios académicos (por ejem-
plo, técnicas de partición de matrices). Para estos problemas, hay aplicaciones
disponibles que permiten analizar cómo se comportan las aplicaciones para-
lelas y ver de qué manera se pueden mejorar. Ejemplos de estas aplicaciones
son VTune y cachegrind (Valgrind, 2011).
1.2.4. Arquitecturas multinúcleo y multiprocesador
En algunas situaciones, las arquitecturas en las que se ejecutan las aplicaciones
paralelas no solamente dan acceso a múltiples hilos y múltiples núcleos, sino
que dan acceso a múltiples procesadores. En estas arquitecturas, una misma
placa contiene un conjunto de procesadores conectados con una conexión
de alta velocidad. Un ejemplo de este tipo de conexión es la Intel Quickpath
Interconnect (Intel, Intel® Quickpath Interconnect Maximizes Multi-Core Perfor-
mance, 2012), también conocida como QPI.
En estas arquitecturas, se pueden asignar los diferentes hilos de nuestra apli-
cación a cada uno de los hilos disponibles en cada uno de los núcleos de los
diferentes procesadores conectados a la placa. Todos los diferentes hilos acos-
tumbran a compartir un espacio de memoria coherente, tal como se ha estu-
diado en las secciones anteriores. Desde el punto de vista de la aplicación, esta
tiene acceso a N núcleos diferentes y a un espacio de memoria común.
Sin embargo, a pesar de que este espacio de memoria es compartido, el acceso
de un hilo a determinadas zonas de memoria puede tener latencias diferen-
tes. Cada procesador dispone de una jerarquía de memoria propia (desde la
L1 hasta la memoria principal) y este gestiona un rango de direcciones de me-
moria concreto. Así, si un procesador dispone de una memoria principal de 2
GB, este procesador gestionará el acceso del espacio de direcciones asignado a
estos 2 GB (por ejemplo, de 0x a FFFFFFFF).
Cada vez que un hilo acceda a una dirección que se encuentra asignada a un
espacio que gestiona otro procesador, tendrá que enviar la petición de lectura
de esta dirección al procesador que la gestiona por medio de la red de interco-
nexión. Estos accesos serán mucho más costosos dado que tendrán que enviar
la petición por la red, llegar al otro procesador y acceder a él (siguiendo el
protocolo de coherencia que siga la arquitectura).

Figura 12. Arquitectura multihilo
Este modelo de programación seguirá el paradigma de lo que se denomina
non-uniform memory access (NUMA), en el que un acceso de memoria puede
tener diferentes tipos de latencia dependiendo de dónde esté asignado.
Cuando se programe para este tipo de arquitectura, habrá que considerar todos
los factores que se han ido explicando pero en una escala superior. Así pues,
en el acceso a variables de exclusión mutua se tendrá que considerar que, por
cada vez que se coja el lock, se tendrá que invalidar todo el resto de núcleos del
sistema. Los que estén fuera del procesador irán por la red de interconexión y
tardarán más en devolver la respuesta. Cabe decir que el comportamiento de-
penderá del protocolo de coherencia y de la jerarquía de memoria del sistema.
Dentro del ámbito de programación multihilo para este tipo de arquitecturas se pueden
encontrar muchas referencias interesantes, algunas de las cuales son las siguientes:
G.R.Andrews (1999). Foundations of Multithreaded, Parallel, and Distributed Programming.
Addison-Wesley.
M.Herlihy;N.Shavit (2008). The Art of Multiprocessor Programming. Morgan Kaufmann.
D.E.Culler;J.PalSingh (1999). Parallel computer architecture: a hardware/software ap-
proach. Morgan Kaufmann.

2. Entornos para la creación y gestión de hilos
En el apartado anterior, se han visto algunos de los factores más importantes
que hay que tener en cuenta a la hora de desarrollar aplicaciones multihilo.
En este apartado, se introducen tres modelos de programación que han sido
pensados para explotar este paralelismo: los POSIX Threads, el Intel Cilk y los
Intel Thread Building Blocks.
2.1. POSIX Threads
Los POSIX Threads son unos de los modelos de programación orientados a
aplicaciones multihilo que más se han usado durante las últimas décadas. Ini-
cialmente, la mayoría de fabricantes de entornos que soportaban aplicaciones
multihilo facilitaban sus propios entornos y bibliotecas de desarrollo.
No obstante, para lograr unas aplicaciones más portátiles y compatibles, se
definió un estándar de programación dado que se volvió necesario. En 1995,
IEEE presentó el estándar POSIX 1003.1c (IEEE, 2011). Precisamente definía
una serie de características e interfaces para la programación de aplicaciones
paralelas.
Se desarrollaron diferentes implementaciones de este estándar para muchas de
las plataformas existentes. Todas siguen las mismas interfaces y se denominan
POSIX Threads o pthreads.

Figura 13. Modelo de hilos POSIX
La figura 13 presenta el modelo de aplicación que define los pthreads. A la
derecha de la figura se observa la visión del proceso UNE tradicional, en el que
hay un solo flujo de ejecución. Este tiene:
a) Un contexto con:
• un stack pointer, que apunta la pila de datos del proceso;
• un program counter, que apunta la parte de la sección de texto de la memo-
ria del proceso que contiene las instrucciones que se deben ejecutar.
b) Un conjunto de registros con los valores que el proceso ha ido modificando
durante su ejecución.
c) Una sección de texto que contiene las diferentes instrucciones que definen
cada una de las rutinas o funciones que el proceso potencialmente puede eje-
cutar.
d) Una sección de datos donde se guardan los datos de la aplicación.

e) Un heap donde se guarda la memoria dinámica que el proceso va pidiendo
durante su ejecución.
A la izquierda de esta misma figura se puede observar la extensión de este mo-
delo unihilo al modelo multihilo que definen los pthreads. En esta extensión,
el proceso sigue estando definido por las tres secciones (fecha, texto y heap).
Pero, en lugar de tener un solo stack y un solo contexto, tiene tantos como
hilos se han definido. Por lo tanto, cada hilo tiene su propio contexto y pila
de ejecución.
Figura 14. Modelo de memoria
Tal como muestra la figura 14, cada hilo tiene una parte de memoria que solo
es visible para él y tiene acceso a una parte de memoria que es visible para
todos los hilos. Y, como se ha destacado antes, cuando un hilo quiere acceder
a zonas de memoria que pueden ser modificadas, hay que usar mecanismos
de exclusión mutua para evitar carreras de acceso.
Durante los subapartados siguientes, se presentan las interfaces más importan-
tes de este modelo de programación. Estas se encuentran divididas en cuatro
grandes bloques:
• Gestión de hilos. Están orientadas a la creación, gestión y destrucción de
hilos.

• Gestión de zonas de exclusión mutua. Estas facilitan el acceso a determi-
nadas zonas del código o variables en las que se quiere que tan solo un
hilo de ejecución esté trabajando a la vez.
• Comunicación entre hilos. Orientada a enviar señales entre los diferentes
hilos.
• Mecanismos de sincronización. Orientados a la gestión de locks y barreras.
2.1.1. Creación y destrucción de hilos
El código 2.1 muestra las diferentes interfaces relacionadas con la creación y la
destrucción de hilos. La primera es la que permite crear un hilo de ejecución
nuevo. Lo más importante es que permite definir un conjunto de atributos que
definirán cómo se comportará el hilo, la rutina que el hilo tiene que ejecutar
y los argumentos que la rutina recibirá.
Una vez se cree el hilo, este ejecutará la rutina que se ha especificado y, una vez
acabe, invocará la rutina de salida (la segunda del código). Si algún hilo quiere
finalizar la ejecución de otro, lo puede hacer mediante la tercera función. Sin
embargo, habitualmente un hilo acabará su propia ejecución.
pthread_create (hilo,atributos,rutina,argumentos)
pthread_exit (estado)
pthread_cancel (hilo)
pthread_attr_init (atributos)
pthread_attr_destroy (atributos)
Código 2.1. Interfaces para la creación de hilos
Las dos últimas rutinas permiten destruir o configurar los atributos de un hilo
de ejecución. Del mismo modo que el pthread_create, estas proporcionarán co-
mo parámetro los atributos que se quieren configurar o destruir. Los atributos
se encuentran compartidos entre los hilos que se han creado con ellos. Los
parámetros principales que hay que especificar se describen a continuación:
• Qué tamaño se quiere que tenga la pila.
• Un puntero en la dirección de la pila que se quiere que utilice.
• Qué tamaño máximo se quiere autorizar que el hilo utilice de la pila para
evitar que se escriba en zonas de memoria incontroladamente.
• Qué tipo de política de planificación se quiere llevar a cabo entre los dife-
rentes hilos que se han creado usando el mismo conjunto de atributos.

El código 2.2 muestra un ejemplo de cómo se pueden crear diferentes hilos
de ejecución. Como se puede observar, en este caso los diferentes hilos son
creados sin ningún conjunto de atributos. En este caso, los hilos compartirán
los atributos por defecto.
#include pthread.h
#include stdio.h
#define NUM_HILOS 5
void *DiHola(void *hiloid)
{
long tid;
tid = (long)hiloid;
printf(¡Hola! Soy el hilo #%ld!n, tid);
pthread_exit(NULL);
}
int main (int argc, char *argv[])
{
pthread_t hilos[NUM_HILOS];
int rc;
long t;
for(t=0; tNUM_HILOS; t++){
printf(Soy la rutina principal y mi identificador
es %ldn, t);
rc = pthread_create(hilos[t], NULL, DiHola, (void *)t);
if (rc){
printf(ERROR: El código es %dn, rc);
exit(-1);
}
}
pthread_exit(NULL);
}
Código 2.2. Creación y destrucción de hilos
2.1.2. Espera entre hilos
En el ejemplo anterior, el hilo principal ha creado un conjunto de hilos y
ha finalizado su ejecución una vez todos se habían creado. Probablemente, la
aplicación habrá acabado cuando el último de los hilos creados haya acabado.
Sin embargo, habría que contrastarlo para comprobarlo. Por otro lado, con
mucha probabilidad, el comportamiento variaría entre ejecución y ejecución.
Por este motivo, hay mecanismos que permiten que los hilos se esperen entre
ellos. De este modo, si un hilo crea N hilos diferentes, este podrá esperar a que
acaben para seguir haciendo el trabajo. Este es el proceso que se llama de join
y se aplica a menudo en situaciones en las que se está aplicando el modelo
de programación esclavo y máster. En este modelo, un hilo hace de máster y
distribuye el trabajo entre un conjunto de esclavos. Y este esperará a que todos
los esclavos finalicen.
En el caso del pthreads, el hilo máster esperará activamente a que los hilos
acaben, usando la primera de las funciones presentadas en el código 2.3. Tal
como se puede observar, esta función tiene dos parámetros, el primero permite

especificar qué hilo quiere esperar y el segundo contendrá el estado del hilo
una vez haya acabado la llamada al pthread_join (y por lo tanto el hilo que
espera haya finalizado su ejecución).
pthread_join (hiloid,estado)
pthread_detach (hiloid)
pthread_attr_setdetachstate (attr,detachestat)
pthread_attr_getdetachstate (attr,detachestat)
Código 2.3. Espera entre hilos
No obstante, en otras situaciones no se querrá que un hilo espere a los demás
hilos. En esas situaciones, cuando se crean los hilos, se podrá especificar en
los atributos que se creen en estado detached. Este estado dirá al sistema que el
hilo que ha creado los diferentes hilos de ejecución no los esperará.
En los casos en los que esto no se especifique en la creación de los hilos, se
podrá reprogramar usando las tres últimas funciones presentadas en el código
2.3. Por ejemplo, esto se podría dar en los casos en los que se crea un hilo
y se especifica que es joinable (es decir, que el padre lo puede esperar), pero
dependiendo del flujo de la aplicación el padre no tendrá que esperar.
Un ejemplo de uso de este tipo de llamadas se muestra en el código 2.4. En
este ejemplo, se quieren mostrar dos cosas:
• Que un hilo máster crea dos hilos que inicializan un vector, los espera y
finaliza usando las llamadas introducidas en este subapartado.
• Que se pueden pasar parámetros entre el hilo máster y los hilos esclavos.
En este ejemplo, el hilo máster instancia un vector de 100 k posiciones y crea
dos hilos que inicializarán su contenido a cero. Cada hilo recibe como pará-
metro un puntero en el vector que se quiere inicializar y la cantidad de ele-
mentos que tendrá que inicializar. Hay que destacar que los dos parámetros
que los hilos necesitan se proporcionan a partir de un struct. Esto se debe al
hecho de que la creación de hilos solo permite pasar un solo puntero al pará-
metro que se facilitará al hilo creado.

typedef struct {
int *ar;
long n;
} vector_nuevo;
void *
inicializa(void *arg)
{
long i;
for (i = 0; i ((vector_nuevo *)arg)-n; i++)
((vector_nuevo *)arg)-ar[i] = 0;
}
int main(void)
{
int ar[1000000];
pthread_t th1, th2;
vector_nuevo v_nuevo_1, v_nuevo_2;
v_nuevo_1.ar = ar[0];
v_nuevo_1.n = 500000;
(void) pthread_create(th1, NULL, inicializa, v_nuevo_1);
v_nuevo_2.ar = ar[500000];
v_nuevo_2.n = 500000;
(void) pthread_create(th2, NULL, inicializa, v_nuevo_2);
(void) pthread_join(th1, NULL);
(void) pthread_join(th2, NULL);
return 0;
}
Código 2.4. Ejemplo de espera
2.1.3. Uso de memoria compartida y sincronización
Uno de los aspectos más importantes de los pthreads es el uso de memoria
compartida y la sincronización entre los diferentes hilos de ejecución.
Por un lado, hay muchas situaciones que requieren acceder de manera con-
trolada a determinadas zonas de memoria. Por ejemplo, en el caso de que dos
hilos estén sumando diferentes filas de una matriz en una variable comparti-
da. En tal caso, habrá que acceder de manera controlada o potencialmente un
hilo podrá sobrescribir el valor que el otro ha escrito perdiendo una parte de
la suma.
Por otro lado, nos encontramos en situaciones en las que será necesario que
los diferentes hilos estén sincronizados a la hora de ejecutar diferentes partes
de la aplicación. Por ejemplo, a menudo se dan situaciones en las que hay
que hacer el algoritmo paralelo en dos etapas y los hilos no pueden empezar
la segunda etapa hasta que todos hayan acabado la primera. En estos casos,
será necesario que los diferentes hilos esperen de forma coordinada a acabar
la primera etapa antes de empezar la segunda.
Como ya se ha dicho antes, este tipo de accesos se controlan a través de me-
canismos de exclusión mutua. Estas interfaces permiten sincronizar el acceso
a zonas de memoria compartida y sincronizar también la ejecución de hilos.

En particular, las interfaces que se usan en este entorno para implementar los
mecanismos descritos son los mutex. Los mutex son variables que funcionan
como un testigo. Es decir, cuando un hilo quiere acceder a una acción que
se controla con un mutex o hacerla tendrá que coger el testigo de este mutex.
Cuando este haya acabado de ejecutar la tarea en cuestión, el hilo dejará el tes-
tigo de este mutex para que otros hilos lo puedan retomar cuando lo necesiten.
Las primeras funciones del código 2.5 permiten inicializar, modificar y destruir
un mutex. Estas serán usadas por el hilo principal. Las tres últimas funciones
serán empleadas por los diferentes hilos para tomar el acceso o liberar el testigo
del mutex en cuestión.
pthread_mutex_init (mutex,atributs)
pthread_mutexattr_init (atributs)
pthread_mutexattr_destroy (atributs)
pthread_mutex_destroy (mutex)
pthread_mutex_lock (mutex)
pthread_mutex_trylock (mutex)
pthread_mutex_unlock (mutex)
Código 2.5. Interfaces para la creación de mutex
El código 2.6 muestra un ejemplo de cómo se podrían usar los mutex para
proteger un contador compartido entre dos núcleos diferentes. Como se puede
observar, se declaran dos variables globales: el contador y el mutex. El hilo
principal crea dos hilos que acceden de manera concurrente al contador. Sin
embargo, antes de modificarlo, cogen el testigo del mutex. En este caso, no se
ha usado ninguna de las llamadas de inicialización, ya que se usa el tipo de
mutex por defecto (lo más habitual). En estos casos, solo hay que declararlo
y coger/liberar el testigo con las últimas dos llamadas mostradas. Para ver los
diferentes comportamientos que un mutex puede tener, se recomienda acceder
a las referencias ya citadas.

#include stdio.h
#include stdlib.h
#include pthread.h
void *suma();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int contador = 0;
main()
{
int rc1, rc2;
pthread_t primer_hilo, segundo_hilo;
if( (rc1=pthread_create( primer_hilo, NULL, suma, NULL)) )
{
printf(No se ha podido crear: %dn, rc1);
}
if( (rc2=pthread_create( segundo_hilo, NULL, suma, NULL)) )
{
printf(No se ha podido crear: %dn, rc2);
}
pthread_join( primer_hilo, NULL);
pthread_join( segundo_hilo, NULL);
printf(Suma total: %dn,contador);
exit(0);
}
void *suma()
{
pthread_mutex_lock( mutex1 );
contador++;
printf(contador value: %dn,contador);
pthread_mutex_unlock( mutex1 );
}
Código 2.6. Ejemplo de uso de mutex
2.1.4. Señales entre hilos
El código 2.7 muestra una de las interfaces interesantes para el desarrollo de
aplicaciones paralelas que los pthreads facilitan. Estas están orientadas a la co-
municación entre diferentes hilos de ejecución. A menudo, no solo se quiere
controlar el acceso a la memoria compartida, sino también ser capaz de en-
viar señales entre hilos. Por ejemplo, para avisar de que un trabajo ya ha sido
procesado o bien de que se espera algún tipo más de información para poder
seguir trabajando.
El primer bloque de rutinas permite que dos hilos puedan estar sincronizados
de forma genérica. Es decir, empleando la primera rutina un hilo se puede
bloquear hasta recibir una señal de otro hilo. Otro hilo, usando la segunda
función, podrá desbloquear el hilo en cuestión usando la segunda rutina. La
tercera puede ser usada para enviar una señal a todo el resto de hilos de la
aplicación. Como se puede observar, una señal no tiene ningún tipo de infor-
mación extra. Simplemente, un hilo puede saber que lo han despertado, pero
no por qué lo han hecho.

pthread_cond_init (condicion,atributos)
pthread_cond_destroy (condicion)
pthread_condattr_init (atributos)
pthread_condattr_destroy (atributos)
pthread_cond_wait (condicion,mutex)
pthread_cond_signal (condicion)
pthread_cond_broadcast (condicion)
Código 2.7. Interfaces para la creación de mutex
El segundo bloque de rutinas permite hilar más fino. Cuando se envía una
señal a un hilo, se puede hacer especificando un atributo asociado a esta señal.
En terminología pthread, estas funciones permiten el uso de variables de con-
dición. El uso de estos tipos de funciones permite que los hilos se bloqueen
a la espera de que suceda una condición concreta. En la parte de actividades
se propone una actividad relacionada con las señales para profundizar en su
funcionamiento.
2.1.5. Otras funcionalidades
En este subapartado, se han presentado las interfaces más importantes que los
pthreads facilitan para definir el paralelismo y para crear mecanismos de sin-
cronización entre hilos. Sin embargo, los pthreads facilitan otros recursos que
permiten llevar a cabo acciones más complejas. Para extender el conocimien-
to de este entorno, es recomendable profundizar en la especificación de los
pthreads o acceder a otros recursos como los que se presentan a continuación.
2.2. Modelo de programación Intel para aplicaciones paralelas
Intel facilita un conjunto de entornos de desarrollo orientados a sacar rendi-
miento de arquitecturas multihilo y arquitecturas con hardware de altas pres-
taciones. Entre estos entornos destacan, por un lado, un conjunto de aplica-
ciones orientadas a analizar el rendimiento de las aplicaciones que se desa-
rrollan (como el ya mencionado VTune) y, por el otro lado, un conjunto de
modelos de programación orientados a desarrollar aplicaciones paralelas para
este tipo de entornos.
Este subapartado se centra en estudiar el segundo de los dos puntos, los mo-
delos de programación para arquitecturas multihilo. Intel facilita un familia
extensa de compiladores, lenguajes de programación y modelos de programa-
ción orientados a obtener rendimiento de las arquitecturas multihilo que la
misma empresa lanza al mercado. Un ejemplo es el procesador multinúcleo
Sandy Bridge (Intel, Intel Sandy Bridge - Intel Software Network, 2012) del que
ya hemos hablado.
Lectura recomendada
Se pueden encontrar muchos
ejemplos de cómo se pueden
emplear estas rutinas en:
Kernel.org (2010). Linux
Programmer's Manual. [Fecha
de consulta: 3 de enero del
2012].
http://www.kernel.org/doc/
man-pages/online/pages/
man7/pthreads.7.html

Dentro de esta familia de productos, destacan tres modelos de programación:
Intel Cilk (Intel, Intel Cilk Plus, 2011); Intel Thread Building Blocks (Intel, In-
tel® Threading Building Blocks Tutorial, 2007), también denominado Intel TBB,
e Intel Array Building Blocks, también denominado Intel ArBB (Intel, Intel®
Array Building Blocks 1.0 Release Notes, 2011).
Ambos modelos de programación están orientados a desarrollar aplicaciones
paralelas, es decir, facilitan mecanismos para explotar el paralelismo que ofre-
cen las arquitecturas. El primero, el Cilk, fue diseñado originariamente por
el Instituto Tecnológico de Massachussets (MIT). Este ofrece una interfaz más
sencilla que los TBB. El objetivo es facilitar un entorno más simple al desarro-
llador para que cree las aplicaciones y, como se verá más adelante, con una
semántica similar al código serial. Además, Cilk también facilita primitivas
para explotar el paralelismo con relación a los datos que algunas arquitecturas
ofrecen, conocidas como unidades vectoriales o single instruction multiple data.
Los Intel TBB, del mismo modo que el Cilk, son también un modelo de pro-
gramación orientado a desarrollar aplicaciones paralelas. Sin embargo, a dife-
rencia del anterior, facilitan una interfaz mucho más extensa y a la vez más
compleja. Así, facilitan acceso a:
• Una biblioteca de algoritmos paralelos, así como a estructuras de datos
para estos algoritmos.
• Recursos que facilitan la gestión y planificación de tareas paralelas.
• Recursos que facilitan la reserva y gestión de memoria de manera escalable.
Tal como se ha presentado en este apartado, este es un factor determinante
en el rendimiento de estas arquitecturas.
• Primitivas orientadas a la sincronización de los hilos de ejecución.
A diferencia del Cilk, los TBB no facilitan recursos orientados a la explotación
de arquitecturas vectoriales. Sin embargo, las aplicaciones que usan TBB tam-
bién pueden emplear ArBB.
El ArBB, el último de los modelos mencionados, es un modelo de programa-
ción orientado a explotar el rendimiento de arquitecturas vectoriales. De ma-
nera similar al Cilk, facilita interfaces para poder explotar el paralelismo con
relación a los datos dentro de las aplicaciones. No obstante, este modelo es
bastante más sofisticado que el anterior.
A continuación, se introducirán dos entornos orientados a explotar el parale-
lismo de las arquitecturas multihilo.

2.2.1. Intel Cilk
Tal como se ha mencionado previamente, el Cilk fue diseñado para ofrecer un
modelo sencillo de programación que permitiera paralelizar de forma sencilla
aplicaciones secuenciales o bien implementar aplicaciones paralelas emplean-
do una interfaz sencilla. Durante este subapartado, se van a introducir algunos
de los conceptos más fundamentales de este entorno.
La interfaz que Cilk facilita para definir el paralelismo está formada por tres
palabras reservadas principales: cilk_spawn, cilk_sync y cilk_for. A continuación
se presentará su uso, así como otros recursos que Cilk facilita para el desarrollo
de este tipo de aplicaciones.
cilk_spawn y cilk_sync
Para explicar estas dos llamadas se presenta la paralelización de un algoritmo
secuencial extensamente conocido, el cómputo del número de Fibonacci. El
código 2.8 contiene la implementación que consideraremos para este ejemplo.
El cómputo de este número se hace de manera recursiva. Es decir, se llama a la
misma función dos veces, una vez para n – 1 y la otra para n – 2. El cómputo
de Fibonacci de n – 1 y n – 2 se puede hacer de forma paralela, puesto que no
tienen ningún tipo de dependencia.
#include stdio.h
#include stdlib.h
int fibonnaci(int n)
{
if (n 2) return n;
int fiba = fibonnaci (n-1);
int fibb = fibonnaci (n-2);
return fiba + fibb;
}
int main(intargc, char *argv[])
{
int n = atoi(argv[1]);
int result = fib(n);
printf(El Fibonacci de %d es %d.n, n, resultado);
return 0;
}
Código 2.8. Implementación secuencial del cómputo del número de Fibonacci
Para paralelizar la función fibonnaci se emplearán las llamadas cilk_spawn y
cilk_sync. La primera de las dos funciones crea una ejecución paralela de la
función que se le pasa por parámetro. La segunda crea una barrera de control,
por lo que la ejecución del programa (el puntero de instrucción) no podrá
continuar hasta que todos los hilos creados con cilk_spawn hayan finalizado.

int fibonnaci(int n)
{
if (n 2) return n;
int fiba = cilk_spawn fibonnaci(n-1);
int fibb = cilk_spawn fibonnaci(n-2);
cilk_sync;
return fiba + fibb;
}
Código 2.9. Implementación paralela del número de Fibonacci
El código 2.9 muestra las modificaciones que hay que hacer sobre el código
presentado antes para adaptarlo a Cilk. Como se puede observar, basta con
notificar que se quiere ejecutar de forma paralela la ejecución de fibonnaci de n
– 1 y de n – 2 y que, además, la ejecución del hilo que está ejecutando la función
fibonnaci actual no puede continuar hasta que ambas llamadas paralelas no
vuelvan.
Como se puede observar, el uso de ambas interfaces es extremamente sencillo.
Solo hay que modificar el código secuencial existente añadiendo el spawn an-
te las funciones que se quieren ejecutar con un hilo paralelo y añadiendo la
sincronización donde sea adecuado.
Desde el punto de vista de la arquitectura del sistema, cada procesador o nú-
cleo tiene una cola con el conjunto de tareas que se han creado con la llamada
a cilk_spawn. Cuando un procesador o núcleo se queda sin tareas para proce-
sar, toma tareas de las colas de otros procesadores o núcleos que todavía tie-
nen trabajo pendiente. Cabe decir que, cuando la cantidad de paralelismo es
elevada, estas situaciones raramente ocurren. Sin embargo, hay que tratar de
evitarlas, dado que robar tareas de otro núcleo es costoso.
cilk_for
El código 2.10 muestra un ejemplo de cómo se podría paralelizar un bucle for
usando las llamadas introducidas en el subapartado anterior. Para cada itera-
ción, se crea una nueva tarea con la llamada cilk_spawn y, después del bucle,
la ejecución del hilo principal se bloquea hasta que todos los hilos que se han
creado hayan acabado su ejecución.
Implementaciónsecuencial:
for(int i = 0; i T; i++)
{
calcula(i);
}
Implementaciónparalela:

for(int i = 0; i T; i++)
{
cilk_spawn calcula(i);
}
cilk_sync;
Código 2.10. Implementación paralela de un bucle
La figura 15 muestra cómo se ejecutarían las diferentes tareas que el código
anterior generaría. Por simplicidad, en este ejemplo se asume una arquitectura
en la que solo hay dos hilos trabajadores en ejecución y en la que el tiempo
de ejecución de la función calcula es relativamente pequeño.
Como se puede observar, el resultado de hacer spawn en cada iteración acaba
resultando en una implementación secuencial muy similar a la actual. En los
casos en los que el cuerpo de la función que hay que ejecutar fuera más eleva-
do, este efecto sería menos importante.
Figura 15. Ejecución del bucle usando cilk_spaw
Para estas situaciones se ha diseñado la interfaz cilk_for. Esta permite aplicar
los algoritmos de dividir y vencer para ejecutar de manera más eficiente el
bucle anterior.
cick_for (int i = 0; i T; i++)
{
calcula(i);
}
Código 2.11. Implementación paralela usando el cilk_for
El código 2.11 muestra que el bucle anterior se tendría que modificar para eje-
cutar las iteraciones en la forma ya mencionada de dividir y vencer. Como se
puede observar, solo hay que emplear la directiva cilk_for en lugar del for tra-
dicional. En este caso, el compilador ya procesará que se quiere usar la versión
paralela del for para ejecutar lo que hay dentro del cuerpo de la iteración.
El resultado de ejecutar el cuerpo del cilk_for se presenta en la figura 16. tal
como se puede observar, el nivel de paralelismo aumenta de manera sustancial
respecto de la implementación con el cilk_spawn.

Figura 16. Ejecución del bucle usando cilk_for
Dentro de un cilk_for se pueden usar los llamados reducer hyperobjects. Concep-
tualmente, son bastante similares a la función gather de MPI (ya introducida
antes). Una variable puede ser definida como reducer sobre una operación aso-
ciativa (por ejemplo, suma, multiplicación o concatenación). Cada una de las
tareas generadas modificará esta variable sin considerar si otras tareas la están
modificando o no.
Sin embargo, de esta variable habrá n vistas lógicas diferentes, una por tarea
ejecutada. El runtime de Cilk será el encargado de crear la vista final una vez
hayan finalizado todas las tareas. Cuando una sola vista quede viva, el valor
deseado se puede consultar de forma segura.
El código 2.12 muestra un ejemplo de uso de un reducer sobre la operación
asociativa de la suma. En este caso, la tarea creada con la spawn incrementará
su vista de la variable y de forma concurrente el hilo principal también lo
hará. Una vez acabe la tarea creada y el hilo principal pida el valor mediante
el get_value, el runtime de Cilk devolverá la suma.
#include cilk/cilk.h
#include cilk/reducer_opadd.h
cilk::reducer_opaddint suma;
void mesun()
{ sum += 1; }
int main()
{
sum += 1;
cilk_spawn mesun();
sum += 1;
cilk_sync;
return suma.get_value();
}
Código 2.12. Ejemplo de uso de un reducer

Restricciones del cilk_for y del cilk_spawn
Como hemos visto, las interfaces de Cilk tienen un empleo sencillo. Ahora
bien, su simplicidad implica en muchos casos ciertas limitaciones. Hay que
tener en cuenta que:
• Las diferentes iteraciones de un cilk_for deben ser independientes entre
ellas.
• El código de la tarea resultante del cilk_spawn tiene que ser independiente
del código que hay entre la llamada al mismo cilk_spawn y al cilk_sync. Por
ejemplo, el código presentado en el código 2.13 puede desencadenar una
carrera de acceso en la modificación de la variable x.
• En situaciones en las que se quieran modificar concurrentemente variables
de memoria, habrá que emplear reducers o variables de sincronización para
evitar condiciones de carrera.
void incrementa(int i)
{
++i;
}
int main ()
{
int x = 0;
cilk_spawn incrementa(x);
int y = x -1;
return y;
}
Código 2.13. Implementación con una carrera de acceso potencial
Cilk facilita el entorno de evaluación de aplicaciones paralelas desarrolladas
con este modelo de programación denominado Cilkscreen. Este permite eva-
luar el rendimiento de las aplicaciones desarrolladas. Una de las utilidades más
interesantes que permite es el estudio de la escalabilidad. De este modo, faci-
lita un conjunto de funcionalidades que ayudan a entender la escalabilidad
de la aplicación que se está ejecutando.
Por otro lado, también facilita un race detector. Esta funcionalidad permite eva-
luar si la aplicación desarrollada tiene algún tipo de condición de carrera. A
pesar de no explorar todas las combinaciones posibles, es un buen inicio para
detectar errores de programación que pueden causar carreras de acceso a datos.
2.2.2. Intel Thread Building Blocks
Este entorno de desarrollo es bastante más complejo y extenso que el presen-
tado antes. De modo similar al anterior, facilita un conjunto de interfaces que
permiten declarar tareas paralelas. Sin embargo, además, añade funcionalida-

des bastante más potentes para mejorar el rendimiento de las aplicaciones pa-
ralelas, como definición de grupos de tareas o primitivas de sincronización
entre hilos.
Una de las complejidades añadidas de los Intel TBB respecto al Cilk es que
están basados en la biblioteca estándar de plantillas, más conocida como stan-
dard template library (STL). Aquí no vamos a hacer una introducción a la STL,
no obstante, se pueden encontrar muchas introducciones a ella, por ejemplo
Hewlett-Packard (1994).
Los Intel TBB se encuentran divididos en seis componentes diferentes:
1) El componente de algoritmos paralelos genéricos. Proporciona interfaces
similares al cilk_for y cilk_spawn estudiados en el subapartado anterior.
2) El componente de gestión de tareas o task scheduler. Proporciona acceso
a recursos que permiten la gestión de las tareas que el componente anterior
permite crear.
3) El componente de primitivas de sincronización. Proporciona acceso a un
conjunto de primitivas que pueden ser empleadas para sincronizar diferentes
hilos de ejecución (por ejemplo, para acceder a variables compartidas o pun-
tos de sincronización). Son bastante similares a las que facilitan los POSIX Th-
reads.
4) El componente de hilos o threads. Proporciona la abstracción del concepto
de hilo dentro de este entorno. Como se verá a continuación, esta se facilita
mediante el tipo tbb_threads.
5) El componente de contenedores paralelos. Proporciona acceso a un con-
junto de estructuras de datos que han sido diseñadas para acceder a ellos de
forma paralela.
6) El componente para la gestión de memoria. Proporciona acceso a un con-
junto de interfaces orientadas a establecer una gestión eficiente y escalable de
la memoria que la aplicación usa. Tal como se ha destacado antes, este es uno
de los factores más críticos a la hora de obtener un buen rendimiento.
A continuación, presentamos una introducción a los componentes más im-
portantes y más diferentes de los Intel TBB. Algunos, como por ejemplo las
primitivas de sincronización, no se describirán dado que son bastante simila-
res a otros sistemas (como por ejemplo los POSIX Threads).

Algoritmos paralelos
Los TBB facilitan el acceso a interfaces que permiten la definición de paralelis-
mo dentro de las aplicaciones. Estas interfaces se pueden dividir en dos grupos:
• Un bloque de algoritmos más sencillos: parallel_for, parallel_reduce,
parallel_scan.
• Un bloque de algoritmos más avanzados que permite definir el paralelis-
mo de manera más compleja: parallel_while, parallel_do, parallel_pipeline,
parallel_sort.
Ahora se presenta el uso de los algoritmos parallel_for y parallel_reduce. Cabe
decir que la metodología para emplear los algoritmos más avanzados es la
misma, pero con una semántica más compleja. Para profundizar más en el uso
de las diferentes interfaces parallel, se puede acceder a Intel (2007).
1)Elusodelparallel_for
De manera similar al cilk_for, las llamadas parallel permiten la definición de
zonas de ejecución paralela. La más sencilla de todas es la parallel_for. Esta se
comporta de manera muy similar a la ya introducida cilk_for.
void ImplementacionSecuencial( float a[], size_t n )
{
for( size_t i=0; in; ++i )
Foo(a[i]);
}
Código 2.14. Implementación secuencial
El código 2.14 muestra un código secuencial que quiere ser modificado para
ser paralelo. En el caso de Cilk, solo habría sido necesario añadir la palabra
reservada cilk_for en lugar del tradicional for.
De forma similar a Cilk, la plantilla tbb::parallel_for divide el espacio de las
diferentes iteraciones, en el ejemplo de 0 a n – 1, en k bloques diferentes y
ejecuta cada uno de ellos en un hilo diferente. Cada hilo ejecutará lo que en
terminología TBB se denomina un functor. Este es una clase que implementa el
código que se aplicará sobre un bloque en cuestión. En el caso anterior, habrá
que diseñar un functor que recorra el rango del vector que le toca procesar de
forma que, para cada posición, llame a la función Foo.
El código 2.15 muestra la redefinición del bucle anterior en un nuevo functor.
Tal como se puede observar, se ha creado una clase EjecutaFoo que define el
operador de ejecución ( ) al que se facilita un objeto de tipo bloque. Esta
Lectura recomendada
Intel (2007). Intel® Threading
Building Blocks Tutorial. Intel.

función ejecutará el bucle anterior dentro del rango que el runtime de los TBB
le facilite. Como se puede observar, al constructor de la clase se le facilita el
puntero al vector a, sobre el que se aplicará la función Fool.
La clase EjecutaFoo define cómo se procesará el bloque del vector que el sistema
o runtime le ha asignado. Hay que destacar que este código tan solo ejecuta
el procesamiento de un bloque y no de todo el vector entero. Una vez se ha
definido la ejecución paralela de este dentro del functor ya se puede crear el
código que lo usará.
#include tbb/blocked_range.h
class EjecutaFoo {
float *const my_a;
public:
void operator()( const blocked_rangesize_t r ) const
{
float *a = my_a;
for( size_t i=r.begin(); i!=r.end(); ++i )
Foo(a[i]);
}
EjecutaFoo( float a[] ) :
my_a(a)
{};
}
Código 2.15. Paralelización del recorrido del vector
El código 2.16 muestra cómo se haría la llamada a la clase EjecutaFoo usando
la interfaz del parallel_for. Esta función recibe como parámetro la definición
del rango y una instancia de la clase EjecutaFoo. El runtime de los TBB creará n/
Granularitat hilos y a cada uno le proporcionará acceso a los diferentes bloques
de datos que le toque computar.
#include tbb/parallel_for.h
void EjecucionParallelaFoo( float a[], size_t n ) {
parallel_for(blocked_rangesize_t(0,n,Granularidad),
EjecutaFoo(a) );
}
Código 2.16. Llamada a EjecutaFoo con el parallel_for
La definición de la granularidad hay que hacerla en función del tamaño del
rango global que se quiera procesar. En general, se recomienda que el número
de iteraciones que ejecutará cada bloque se encuentre entre 10.000 y 100.000.
Para valores inferiores o superiores, el rendimiento de la aplicación puede ser
peor. Por un lado, una granularidad demasiado gruesa puede implicar poco
nivel de paralelismo. Por el otro lado, una granularidad demasiado elevada
puede implicar demasiado sobrecoste a la hora de gestionar tantos hilos de
ejecución.
Una alternativa es utilizar el auto_partitioner. En el caso de que al parallel_for
no se le facilite la granularidad, el runtime usará un conjunto de heurísticas
propias para calcular el tamaño de bloque que dará más rendimiento y más

balanceo dentro de la aplicación. Es recomendable usarlo para comprobar el
rendimiento que da. Sin embargo, lo más adecuado es hacer un estudio que
varíe el nivel de granularidad para analizar el que dé el mayor rendimiento.
2)Elusodelparallel_reduce
De forma similar a los reducers de Cilk, los TBB facilitan el parallel_reduce. Los
diferentes hilos trabajan de manera concurrente con diferentes vistas de una
variable que el runtime unificará en una sola vista al final de la ejecución pa-
ralela.
El código presentado en el código 2.17 suma n veces el resultado de ejecutar
la función Foo en cada una de las posiciones del vector a. Asumiendo que ca-
da una de las iteraciones son independientes, el código se podría paralelizar
siguiendo una metodología similar a la empleada en el caso anterior. Sin em-
bargo, en este caso se usará el parallel_reduce para hacer la reducción de las
diferentes sumas.
float SumaFoo( float a[], size_t n ) {
float suma = 0;
for( size_t i =0; i!=n; ++i )
suma += Foo(a[i]);
return suma;
}
Código 2.17. Llamada a EjecutaFoo con el parallel_for
El código 2.18 muestra cómo habría que modificar el código anterior para que
el parallel_reduce lo pueda utilizar. De forma similar al parallel_for, habrá que
definir un nuevo functor para esta interfaz. A diferencia de la clase ExecutaFoo
hecha en el caso anterior, se definirá la clase SumaFoo con dos nuevos métodos
importantes:
• El primero es un nuevo constructor que recibe como parámetro una refe-
rencia a otro objeto de tipo SumaFoo y un objeto split. El segundo paráme-
tro no se usa en absoluto, pero hay que definirlo para que el compilador
distinga este constructor del constructor por copia de la misma clase.
• El segundo es un método necesario para que el map_reduce funcione. Como
se va a ver a continuación, este se usa cuando se crea una nueva subtarea
que ayuda a procesar el trabajo que la tarea actual está llevando a cabo.
Cuando un nuevo hilo trabajador está disponible, el gestor de tareas puede
crear una nueva subtarea. Esta hará el cómputo de una parte del rango que
la tarea actual está procesando. El runtime de los TBB será el responsable de
decidir qué parte se delega. La creación de esta subtarea se hará empleando
este nuevo constructor. La tarea principal esperará a que la nueva tarea acabe
y, mediante el método join, hará la suma global.

class SumaFoo {
float* my_a;
public:
float suma;
void operator()( const blocked_rangesize_t r ) {
float *a = my_a;
for( size_t i=r.begin(); i!=r.end(); ++i )
suma += Foo(a[i]);
}
SumFoo( SumFoo x, split ) : my_a(x.my_a), suma(0) {}
void join( const SumFoo y ) {suma+=y.suma;}
SumFoo(float a[] ) :
my_a(a), suma(0)
{}
};
Código 2.18. Paralelización de la suma
La figura 17 describe la secuencia de acontecimientos temporales que sucede-
rán dentro del runtime de los TBB cuando el gestor de tareas decida crear una
subtarea y dividir el trabajo que el actual está procesando en dos partes.
Figura 17. Graf de la secuencia de split y join
Del mismo modo que en el ejemplo del parallel_for, una vez se ha definido
la clase que implementará el trabajo que hay que llevar a cabo a partir de un
rango determinado, hay que implementar la llamada al parallel_reduce. Esta se
presenta en el código 2.19.
#include tbb/parallel_reduce.h
float SumaParallelaFoo( const float a[], size_t n ) {
SumaFoo sf(a);
parallel_reduce(blocked_rangesize_t(0,n,Granularidad), sf );
return sf.suma;
}
Código 2.19. Llamada a SumaFoo con el parallel_reduce

Tal como se ha podido observar, los functors son la base de los TBB. El resto de
interfaces paralelas de este entorno de programación se encuentran también
basadas en estos tipos de objetos.
Contenedores de datos
Muchos de los códigos desarrollados en C++ usan estructuras de la STL para
guardar datos y compartirlos entre las diferentes partes de la aplicación. Ejem-
plos de estas estructuras son los maps, vectors o dqueue. Son extremamente po-
tentes dado que están definidos con plantillas genéricas y tienen una eficien-
cia muy elevada.
Uno de los problemas de estas estructuras es que no acostumbran a dar apoyo
para el acceso concurrente. Por lo tanto, en muchas situaciones, si dos hilos
intentan acceder de manera concurrente a una estructura (por ejemplo, un
mapint,int), con alta probabilidad esta se corromperá. Este problema se pue-
de solucionar usando mecanismos de exclusión mutua que protejan el acce-
so simultáneo a estas estructuras. Sin embargo, esta solución reduce la concu-
rrencia de la aplicación y, por lo tanto, su rendimiento.
Los Intel TBB facilitan un conjunto de contenedores que siguen la misma fi-
losofía que los de la STL pero a los que, además, se puede acceder de forma
concurrente. Estos contenedores permiten dos tipos de accesos diferentes:
• Accesos con exclusión mutua de grano fino. Este tipo de acceso se hará
cuando diferentes hilos quieran acceder de manera simultánea a zonas del
contenedor que quieren modificar. Los hilos podrán pedir acceso exclusivo
a estas zonas del contenedor. Al resto de zonas del contenedor se podrá
acceder sin ningún tipo de restricción.
• Accesos sin ningún tipo de exclusión. En los casos en los que, por la cons-
trucción de la aplicación, el código pueda asegurar que no habrá conflic-
tos en el contenedor, los hilos podrán acceder de manera concurrente sin
tener que hacer ningún tipo de acción.
Los TBB definen cuatro tipos diferentes de contenedores: dos de tipo cola
(concurrent_queue y concurrent_bounded_queue), un contenedor de tipo vector
(concurrent_vector) y un contenedor de tipo hash (concurrent_hash_map). A mo-
do de ejemplo, a continuación se presentará el uso de las colas y de los vectores.
1)Elusodelascolas

Las colas tienen la misma semántica y el mismo funcionamiento que las de
la STL. Es decir, proporcionan un método para poner un dato en la cola, un
método para tomar el primer método de la cola si lo hay y otro método para
consultar el tamaño. La diferencia principal radica en la consulta del primer
elemento de la cola.
Tal como se puede observar en el código 2.20, la STL facilita dos métodos
diferentes. El primero devuelve el primer valor de la cola y el segundo permite
eliminarlo. En el caso de los TBB, esto no se puede hacer de este modo, dado
que entre las dos llamadas otro hilo podría haber modificado la cola.
Por este motivo, facilita el método try_pop. Este método devuelve cierto si la
cola tenía alguna valor falso. En el caso de que la cola no esté vacía, modificará
la variable pasada por referencia con el valor del último elemento de la cola
y lo eliminará de esta.
STL
void pop();
T front ();
TBB concurrent_queue
bool try_pop(T x);
void push(T x);
TBB concurrent_bounded_queue
void pop(T x);
void push(Tx) ;
bool try_push(Tx);
Código 2.20. Consulta de un elemento de la cola
Los TBB facilitan la variante concurrent_bounded_queue. Esta añade operaciones
bloqueantes y la posibilidad de configurar un límite de espacio. En estas co-
las, la función de push se bloquea si no hay espacio en la cola y la función
pop se bloquea hasta que haya algún elemento en la cola. Por otro lado, faci-
lita la función try_push, que se comporta similar a la función push, pero no
es bloqueante. En el caso de que no se pueda poner el elemento en la cola,
devolverá falso.
2)Elusodehash_maps
Uno de los contenedores más interesantes de la STL son los maps. Estos per-
miten hacer inserciones y búsquedas asociativas. El código 2.21 muestra un
ejemplo de código de la STL, en el que se usa una estructura map para guardar
la correspondencia entre DNI y nombres. Como se puede observar, se usan
iteradores para buscar dentro de la estructura y se añaden o se eliminan ele-
mentos usando el método insert/delete.

#include iostream
#include map
using namespace std;
int main ()
{
mapuint32,string::iterator iterador;
mapuint32,string map_dni_nombre;
map_dni_nom.insert(pairuint32,string(43433243,Jordi));
iterador = map_dni_nombre.find(43433243);
if(iterador != map_dni_nombre.end())
{
cout El DNI es iterador-second endl;
map_dni_nombre.erase(iterador);
}
else
cout Error debería estar endl;
}
Código 2.21. Ejemplo de uso de un map de la STL
Como ya se ha mencionado antes, estas estructuras no dan apoyo al acceso
concurrente. Por este motivo, los TBB implementan los concurrent_hash_map.
Estos maps permiten el acceso concurrente a su contenido mediante dos clases:
• La clase accessor, que permite tomar el derecho en exclusiva de modificar
una entrada determinada.
• La clase const_accessor, que permite tomar el derecho a lectura compartida
de una entrada.
A diferencia de los maps de la STL, cuando se quiere buscar o se quiere insertar
un elemento dentro de esta estructura hay que usar las clases anteriores. El
código 2.22 muestra dos ejemplos de cómo se tendrían que usar estas dos clases
a la hora de acceder a un map y modificarlo.
Insercióndeunmap
StringTable accessor a;
for( string* p=range.begin(); p!=range.end(); ++p ) {
table.insert( a, *p );
a-second += 1;
a.release();
}
Lecturadeunmap
StringTable const_accessor a;
for( string* p=range.begin(); p!=range.end(); ++p ) {
table.find ( a, *p );
a.release();
}
Código 2.22. Inserción y modificación de un map

Gestión de la memoria
Ya hemos hablado de la importancia de una buena gestión de la memoria
que la aplicación utiliza. Se han presentado situaciones como, por ejemplo,
la falsa compartición, en la que accesos a determinadas líneas pueden reducir
drásticamente el rendimiento.
La biblioteca STL proporciona la std::allocator, que es la responsable de reser-
var y gestionar la memoria que las aplicaciones piden. Los Intel TBB facilitan
dos tipos nuevos de allocators orientados a tratar de dirigir las situaciones si-
guientes:
a)Problemasdeescalabilidad. Originalmente, los allocators fueron diseñados
para ser empleados en aplicaciones secuenciales. En situaciones con diferentes
hilos de ejecución, se pueden dar situaciones en las que estos están compitien-
do para obtener recursos a los que solo puede acceder un hilo en un mismo
instante de tiempo. Evidentemente, esto implica problemas de escalabilidad
graves. Para evitar esta situación, podemos emplear la scalable_allocatorT.
b)Falsacompartición. Este problema, ya tratado con anterioridad, sucede
cuando dos variables diferentes a las que acceden hilos diferentes se encuen-
tran mapeadas en las mismas líneas de la memoria caché. Los Intel TBB pro-
porcionan el cache_aligned_allocatorT. Este asegura que dos objetos instan-
ciados que usan este gestor no se guardarán en la misma línea de memoria. Lo
que los TBB no aseguran es que dos objetos, uno creado con el allocator por
defecto y el otro creado con el cache_aligned_allocator, puedan experimentar
falsa compartición.
El código 2.23 muestra un ejemplo de cómo se podrían usar los dos allocators
que acabamos de introducir. El primero instancia a un objeto de la clase ti-
po Clase usando la scalable_allocator. El segundo declara un vector de la STL
y especifica que quiere que la memoria que este utilice se reserve usando el
cache_aligned_allocator.
Clase * s = scalable_allocatorClasse().allocate( sizeof(Classe) );
std::vectorint,cache_aligned_allocatorint ;
Código 2.23. Ejemplo de uso de los dos allocators de los TBB

Resumen
En el primer apartado, se han tratado algunos de los factores más importantes
que hay que tener en cuenta a la hora de desarrollar aplicaciones en arquitec-
turas multihilo.
En el primer subapartado, se han presentado diferentes factores asociados al
modelo de programación empleado, así como a la aplicación que se desarrolla.
Se ha tratado el impacto de la creación de tareas y del mapeo de estas en los di-
ferentes hilos de ejecución que el sistema facilita. Se ha presentado el impacto
de la gestión de datos compartidos entre los diferentes hilos y mecanismos pa-
ra la sincronización, usados para mantener un acceso coherente. Y finalmente
también se han descrito algunos otros factores importantes que hay que con-
siderar desde el punto de vista de la aplicación, a la hora de desarrollarla.
En el segundo subapartado, se han presentado aspectos que, a pesar de que
también se encuentran asociados al modelo de programación, están fuerte-
mente ligados a la arquitectura sobre la que se ejecuta la aplicación. Estos son
factores en los que el comportamiento de la aplicación paralela está fuerte-
mente ligado a la arquitectura sobre la que se está ejecutando. Se han analiza-
do cuatro factores asociados al comportamiento de la jerarquía de memoria:
falsa compartición, técnicas de prefetch, impacto en el tipo de arquitectura de
memoria y consideraciones en el ámbito de arquitecturas multiprocesador.
Durante el primer apartado, se ha destacado la gran cantidad de investigación
llevada a cabo en este ámbito, puesto que es muy elevada. Además, se han
facilitado referencias a artículos de investigación o recursos web que son rele-
vantes desde el punto de vista del modelo de programación empleado para
desarrollar de manera eficiente las aplicaciones paralelas.
En el segundo apartado, se han estudiado algunos de los factores más impor-
tantes que hay que tener en cuenta a la hora de desarrollar aplicaciones para-
lelas que se ejecutan sobre arquitecturas multihilo. Como se ha podido ver,
dependiendo del tipo de modelo de programación empleado y de las caracte-
rísticas de la arquitectura usada, el rendimiento obtenido puede variar sustan-
cialmente.
En primer lugar, se han analizado los factores asociados al modelo de progra-
mación y al estilo de programación. Junto con estos factores, se ha presenta-
do el impacto que la forma como se desarrolla la aplicación tiene en su rendi-
miento. Por ejemplo, el acceso demasiado frecuente a zonas de memoria com-
partida o un mapeo de tareas o datos erróneo.

A continuación, se han presentado factores que, a pesar de poder ser solucio-
nados mediante técnicas de programación, se encuentran ligados a las carac-
terísticas de la arquitectura sobre la que se ejecutan las aplicaciones. En par-
ticular, se ha analizado el impacto de las características de la memoria caché
(falsa compartición o false sharing).
Por último, se han presentado tres modelos de programación orientados a
desarrollar aplicaciones multihilo. Por un lado, se han analizado los POSIX
Threads. Este es un estándar de programación para arquitecturas paralelas que
fue presentado en 1995. Por el otro lado, se han presentado dos modelos de
programación propuestos por la empresa Intel, el Cilk y los Thread Control
Blocks. El primero es un modelo muy sencillo orientado a facilitar una interfaz
muy simple y fácil de emplear. El segundo es un modelo mucho más complejo
que permite obtener un rendimiento más elevado.
Aquí también hemos destacado que, dentro de este ámbito, se ha hecho mu-
cha investigación. Por lo tanto, a pesar de que se han cubierto algunos de los
aspectos más representativos, es recomendable tratar de extender los conoci-
mientos con las referencias bibliográficas facilitadas.
Asimismo, hay que tener presente que el mundo de las arquitecturas multihilo
está en evolución constante. Por lo tanto, es recomendable mantenerse al día
con las nuevas propuestas y arquitecturas disponibles, dado que, conceptos
que han sido válidos hasta un momento específico, pueden no ser aplicables
en arquitecturas o modelos de programación nuevos.

Actividades
1. Para entender más en detalle cuáles son los retos de la implementación de mecanismos de
sincronización en arquitecturas multinúcleo, elaborad un estudio del artículo siguiente:
Villa,O.;Palermo,G.;Silvano,C. (2008). Efficiency and scalability of barrier synchroni-
zation on NoC based many-core architectures. En: CASES '08 Proceedings of the 2008 Interna-
tional Conference on Compilers, Architectures and Synthesis for Embedded Systems.
2. Extended los diagramas de secuencia presentados en el subapartado 1.1.4.1 Condiciones
de carrera en arquitecturas multinúcleo, asumiendo que añadimos un tercer hilo tal como
se muestra en la figura siguiente:
Asumid que los hilos 1 y 2 se ejecutan en el núcleo 0 y el hilo 3 en el núcleo 1. Podéis asumir
la orden en los accesos que creáis conveniente.
3. En el subapartado 1.1.1 Definición y creación de las tareas paralelas se ha presentado
el uso de la localidad como uno de los factores más importantes a la hora de obtener buen
rendimiento de las aplicaciones paralelas. Escribid dos diagramas de secuencia en los que se
vea la diferencia entre el impacto de una memoria inclusiva o no inclusiva cuando se invalida
una línea de la memoria caché de nivel 1, similares al diagrama de la figura 10.
4. Un artículo de investigación bastante interesante relacionado con los efectos de la progra-
mación de arquitecturas multihilo y las memorias caché es el presentado por Kwak y otros:
Kwak,H.;Lee,B.;Hurson,A.;Suk-Han,Y.;Woo-Jong,H. (1999). Effects of multithreading
on cache performance. IEEE Transactions on Computer (págs. 176-184).
En este artículo académico, se presenta un modelo teórico para estudiar el impacto en el
rendimiento de aplicaciones multihilo de las jerarquías de memoria caché. Para profundizar
en este ámbito, os recomendamos la lectura de esta disertación.
5. Implementad un aplicación con pthreads que implemente los funcionamientos siguientes:
a) Un hilo crea un vector.
b) Crea dos hilos: uno inicializa la primera parte del vector con '12 y el segundo la segunda
parte con '22.
c) El hilo creador se espera a que acaben.
d) Crea dos hilos de ejecución: cada hilo añadirá a su parte del vector v[i] = v[i – 1]. El primer
hilo avisará con una señal condicional al segundo para que el segundo empiece una vez el
primero haya hecho la suma en cuestión.
6. Se ha presentado el modelo de programación de Intel Cilk. Por otro lado, Intel también
proporciona acceso al modelo de programación denominado Thread Building Blocks (TBB).
Enumerad diez diferencias principales con el modelo Cilk y los POSIX Threads.

7. En el último subapartado, se ha introducido el uso de los maps de la biblioteca de los TBB.
En este ejercicio, os proponemos profundizar en las referencias facilitadas de este entorno
e implementar un código que sume dos maps diferentes e inserte el resultado en un tercer
map. A pesar de que no se ha introducido, es necesario que la solución incluya la creación
e inicialización del map.

Bibliografía
AMD (2011). AMD Athlon™ Processor. [Fecha de consulta: l 4 de enero del 2012].
http://www.amd.com/us/products/desktop/processors/athlon/Pages/AMD-
athlon-processor-for-desktop.aspx
Andrews, G. R. (1999). Foundations of Multithreaded, Parallel, and Distributed Programming.
Addison-Wesley.
Chapman, B.; Huang, L.; Biscondi, E.; Stotzer, E.; Shrivastava, A. G. (2008). Im-
plementing OpenMP on a High Performance Embedded Multicore MPSoC. IPDPS.
Chynoweth, M.; Lee, M. (2009). Implementing Scalable Atomic Locks for Multi-Core. [Fecha
de consulta: 28 de diciembre del 2011].
http://software.intel.com/en-us/articles/implementing-scalable-atomic-locks-for-
multi-core-intel-em64t-and-ia32-architectures/
Culler, D. E.; Pal Singh, J. (1999). Parallel computer architecture: a hardware/software ap-
proach. Morgan Kaufmann.
Gibbons, A.; Rytte, W. (1988). Efficient Parallel Algorithms. Cambridge: Cambridge Univer-
sity Press.
Grunwald, D.; Zorn, B.; Henderson, R. (1993). Improving the cache locality of me-
mory allocation. En: ACM SIGPLAN 1993, Conference on Programming Language Design and
Implementation.
Handy, J. (1998). The cache memory book. Londres: Academic Press Limited.
Herlihy, M.; Shavit, N. (2008). The Art of Multiprocessor Programming. Morgan Kaufmann.
Hewlett-Packard (1994). Standard Template Library Programmer's Guide. [Fecha de consulta:
9 de enero del 2012].
http://www.sgi.com/tech/stl/
Hily, S.; Seznec, A. (1998). Standard Memory Hierarchy Does Not Fit Simultaneous Mul-
tithreading. En: Workshop on Multithreaded Execution, Architecture, and Compilation.
IEEE (2011). IEEE POSIX 1003.1c standard. [Fecha de consulta: 11 de enero del 2012].
http://standards.ieee.org/findstds/interps/1003-1c-95_int/index.html
Intel (2007). Intel® Threading Building Blocks Tutorial. Intel.
Intel (2007). Optimizing Software for Multi-core Processors. Portland: Intel Corporation - White
Paper.
Intel (2011). Boost Performance Optimization and Multicore Scalability. [Fecha de consulta: 3
de enero del 2012].
http://software.intel.com/en-us/articles/intel-vtune-amplifier-xe/
Intel (2011). Intel Cilk Plus. [Fecha de consulta: 21 de diciembre del 2011].
http://software.intel.com/en-us/articles/intel-cilk-plus/
Intel (2011). Intel® Array Building Blocks 1.0 Release Notes. Intel.
Intel (2011). Nehalem Processor. [Fecha de consulta: 4 de enero del 2012].
http://ark.intel.com/products/codename/33163/Nehalem-EP
Intel (2012). Intel Sandy Bridge - Intel Software Network. [Fecha de consulta: 8 de enero del
2012].
http://software.intel.com/en-us/articles/sandy-bridge/
Intel (2012). Intel® Quickpath Interconnect Maximizes Multi-Core Performance. [Fecha de con-
sulta: 8 de enero del 2012].
http://www.intel.com/content/www/us/en/io/
quickpath-technology/quickpath-technology-general.html
Jin, R.; Chung, T.-S. (2010). Node Compression Techniques Based on Cache-Sensitive
B+-Tree. En: 9th International Conference on Computer and Information Science (ICIS) (págs.
133-138).

Joseph, D.; Grunwald, D. (1997). Prefetching using Markov predictors. En: 24th Annual
International Symposium on Computer Architecture.
Kernel.org (2010). Linux Programmer's Manual. [Fecha de consulta: 3 de enero del 2012].
http://www.kernel.org/doc/man-pages/online/pages/man7/pthreads.7.html
Kim, B.-C.; Jun, S.-W. H.-K. (2009). Visualizing Potential Deadlocks in Multithreaded
Programs. En: 10th International Conference on Parallel Computing Technologies.
Kourtis, K.; Goumas, G.; Koziris, N. (2008). Improving the Performance of Multithrea-
ded Sparse Matrix-Vector Multiplication Using Index and Value Compression. En: 37th In-
ternational Conference on Parallel Processing.
Kumar, R.; Farkas, K. I.; Jouppi, N. P.; Ranganathan, P.; Tullsen, D. M. (2003). Sin-
gle-ISA Heterogeneous Multi-Core Architectures: The Potential for Processor Power Reduction (págs.
81-92).
Kwak, H.; Lee, B.; Hurson, A.; Suk-Han, Y.; Woo-Jong, H. (1999). Effects of multith-
reading on cache performance. IEEE Transactions on Computer (págs. 176-184).
Lo, J. L.; Eggers, S. J.; Levy, H. M.; Parekh, S. S.; Tullsen, D. M. (1997). Tuning
Compiler Optimizations for Simultaneous Multithreading. En: International Symposium on
Microarchitecture (págs. 114-124).
Martorell, X.; Corbalán, J.; González, M.; Labarta, J.; Navarro, N.; Ayguadé, E.
(1999). Thread Fork/Join Techniques for Multi-level Parallelism Exploitation in NUMA Mul-
tiprocessors. En: 13th International Conference on Supercomputing.
ParaWise (2011). ParaWise: the Computer Aided Parallelization Toolkit. [Fecha de consulta:
27 de diciembre del 2011].
www.parallelsp.com/parawise.htm
Philbin, J.; Edler, J.; Anshus, O. J.; Douglas, C.; Li, K. (1996). Thread scheduling for
cache locality. En: Seventh International Conference on Architectural Support for Programming
Languages and Operating Systems.
Prasad, S. (1996). Multithreading Programming Techniques. Nueva York: McGraw-Hill, Inc.
Reinders, J. (2007). Intel Threading Building Blocks. O' Reilly.
Seznec, A. (1993). A case for two-way skewed-associative caches. En: 20th Annual Interna-
tional Symposium on Computer Architecture.
Valgrind (2011). Cachegrind: a cache and branch-prediction profiler. [Fecha de consulta: 3 de
enero del 2012].
http://valgrind.org/docs/manual/cg-manual.html
Villa, O.; Palermo, G.; Silvano, C. (2008). Efficiency and scalability of barrier synchro-
nization on NoC based many-core architectures. En: CASES '08 Proceedings of the 2008 Inter-
national Conference on Compilers, Architectures and Synthesis for Embedded Systems.

Arquitecturas de computadores_avanzadas

Más contenido relacionado

Similar a Arquitecturas de computadores_avanzadas (20)

Más de Tensor (20)

Último (20)

Arquitecturas de computadores_avanzadas