Paralelización de tareas para el análisis de imágenes médicas con aplicaciones a la segmentación del higado

Capítulos Liver-Segm Comparativa entre ITK & MATLAB Segmentación con apariencia y forma Computación paralela con MPI Computación paralela en MATLAB Computación distribuida en MATLAB OpenMP

Capitulo 2: Liver-Segm Introducción Modificación de ITK-SNAP introduciendo algoritmos de segmentación del hígado y lesiones hepáticas mediante la utilización de las librerías ITK. ITK-SNAP es una aplicación “Open Source” para la visualización y segmentación de estructuras en 3D de imágenes biomédicas. Utiliza las librerías ITK para la segmentación de las imágenes, VTK para el renderizado y FLTK para el entorno gráfico.

Segmentación del hígado Etapas en la segmentación del hígado: Expansión del histograma Filtrado: Difusión anisotrópica en 3D Umbralización Detección de bordes Post-Procesado morfológico Evolución del contorno activo 3D

Expansión del histograma Se realiza una expansión del histograma de la imagen 3D del hígado para un mejor aprovechamiento de la información. El hecho de expandir el histograma hace que se explote mejor la información ya que más niveles de grises participan en la imagen.

Difusión anisotrópica Las imágenes de MRI presentan grandes dificultades de segmentación por umbral de intensidad debido a que en su captación existe falta de homogeneidad del campo magnético, esto hace que la señal de MRI tenga ruido tanto multiplicativo como gaussiano. El resultado de la aplicación del filtro de difusión anisotrópica es el suavizado de la imagen y de sus zonas homogéneas.

Umbralización Para hallar los umbrales inferior y superior para la posterior binarización de la imagen se ha dividido la imagen 3D en 27 cubos de igual dimensión y para cada cubo se ha calculado la media y la desviación típica de las intensidades de los pixeles. Después para hallar los umbrales utilizamos la media y desviación típica mínima del cubo correspondiente.

Detección de bordes Después de haber binarizado la imagen se procede a detectar sus bordes mediante el detector de bordes de Canny con umbral inferior 0.08, umbral superior 0.2 y desviación típica 2. Se realiza una dilatación de los bordes con un elemento estructurante de una matriz de unos de 3x3 para resaltar los bordes.

Post-procesado Morfológico Se realiza una operación AND pixel a pixel entre la imagen umbralizada y el negativo de la imagen de los bordes. Se realiza un “opening” con elemento estructurante de una matriz en 3D de unos de 5x5x3. Se etiqueta los objetos de la imagen y se busca el objeto mas cercano y grande al centroide de la imagen que sería el objeto que correspondería a la solución inicial de la que partiría el contorno activo.

Evolución del contorno activo 3D Se ha aplicado una implementación de los contornos activos de Chan-Vesse. El objetivo de este método es minimizar la energía de una curva que evoluciona en 3D. La idea básica de un modelo de contornos activos es hacer evolucionar una superficie sujeta a las limitaciones de la imagen dada con el fin de detectar los objetos de la misma.

Segmentación de lesiones hepáticas Etapas en la segmentación de lesiones hepáticas: Filtrado: Difusión anisotrópica en 3D Análisis del histograma Umbralización Detección de bordes Post-Procesado morfológico Evolución del contorno activo 3D

Difusión anisotrópica Las imágenes de MRI presentan grandes dificultades de segmentación por umbral de intensidad debido a que en su captación existe falta de homogeneidad del campo magnético, esto hace que la señal de MRI tenga ruido tanto multiplicativo como gaussiano. El resultado de la aplicación del filtro de difusión anisotrópica es el suavizado de la imagen y de sus zonas homogéneas.

Análisis del histograma Se realiza una umbralización de la imagen analizando el histograma de la imagen, esto es, hallando su media y su desviación típica para hallar los umbrales. La imagen binarizada estará constituida por los pixeles mayores del umbral inferior y los pixeles menores del umbral superior.

Detección de bordes Después de haber binarizado la imagen se procede a detectar sus bordes mediante el detector de bordes de Canny con umbral inferior 0.08, umbral superior 0.2 y desviación típica 2.

Post-procesado Morfológico Se realiza dilatación con elemento estructurante de una matriz de unos de 3x3a la imagen de los bordes. Se realiza una puerta AND entre la imagen umbralizada y el negativo de la imagen con los bordes dilatados. Se realiza un “opening” con elemento estructurante de 3D una matriz 3x3x3 de unos y se etiqueta la imagen. Opening

Evolución del contorno activo 3D Se ha aplicado una implementación de los contornos activos de Chan-Vesse. El objetivo de este método es minimizar la energía de una curva que evoluciona en 3D. La idea básica de un modelo de contornos activos es hacer evolucionar una superficie sujeta a las limitaciones de la imagen dada con el fin de detectar los objetos de la misma.

Clases de ITK utilizadas Representación de imágenes Itk::Image Itk::Index Itk::Size Umbralización Itk::BinaryThresholdFilter Detección de bordes Itk::CannyEdgeDetectionImageFilter Operaciones lógicas Itk::NotImageFilter Itk::AndImageFilter Operaciones morfológicas Itk::BinaryBallStructurig Element Itk::BinaryErodeImageFilter Itk::BinaryDilateImageFilter Itk::ConnectedComponentImageFilter

Capitulo 3: Comparativa entre ITK & MATLAB Introducción Se ha desarrollado una pequeña aplicación utilizando las librerías de ITK que estaba implementada en MATLAB sobre la elección del mejor modelo para la segmentación de un objeto en 2D. Las funciones de la aplicación realizan unas transformaciones a los modelos previamente conocidos del objeto a segmentar y después hallan las distancias de los modelos con el objeto a segmentar.

Comparativa funciones Tiempo Release Tiempo Matlab Ejecuciones AdaptModelImg2D 0,016 s 0,000000 s 0.148439 s 0.086710 s. 0.028216 s 1ª ejecución 2ª ejecución 3ª ejecución CalculateMeanCov 0,047 s 0.271573 s 0.091853 s 0.078722 s 3ª ejecución. NormalizeShape 0,031 s 0.007320 s 0.007496 s 0.008355 s TransfGeomStatistics 0.077467 s 0.080049 s 0.080963 s Distancia 0.003965 s 0.003602 s 0.003392 s Se observa claramente que las mismas funciones implementadas con ITK son más rápidas que con Matlab. Esto es debido a que ITK al estar escrito en C++ aprovecha más los recursos del microprocesador, por el contrario Matlab al ser un lenguaje interpretado su ejecución es más lenta ya que el código es ejecutado por la maquina virtual de Matlab.

Capitulo 4: Segmentación con apariencia y forma Introducción Se basa en un conocimiento a priori del objeto a segmentar y se incorpora dicho conocimiento a la segmentación. Hay que obtener el modelo que se adapta mejor al objeto a segmentar de los distintos modelos a priori conocidos. El modelo que mejor se adapte al objeto a segmentar será el que se utilizará para la segmentación, incorporando su información de forma al contorno activo 3D.

Obtención del mejor modelo Etapas en la obtención del mejor modelo: Adaptación del modelo a la imagen del contorno activo. Normalización del modelo realizando un análisis en componentes principales. Registro de la imagen realizando una transformación geométrica estadística. Distancia entre el modelo transformado y el contorno activo.

Adaptación del modelo a la imagen En 3D Se hallan las escalas en los tres ejes XYZ, dividiendo las filas, columnas y rodajas de la imagen que contiene el contorno activo, entre las del modelo. Se elige la escala menor que será utilizada para el redimensionamiento. Traslación hasta el centro del contorno activo.

Normalización del modelo Análisis en componentes principales Se hallan las coordenadas de la función Heaviside del modelo para las distintas dimensiones que tenga la imagen. Con la media de las coordenadas se construye una matriz de covarianzas que es simétrica: Se halla los valores propios y vectores propios de la matriz. Con estos vectores propios se construye la matriz de rotación. Se aplica la rotación del modelo para su normalización

Registro de la imagen Transformación geométrica estadística Deformación del modelo que intenta adaptarse lo mas posible al contorno activo. Para ello se calculan las nuevas coordenadas que deberá de tener. Se construye la matriz de covarianzas del contorno activo. A esta matriz se le halla los valores propios y vectores propios, con estos vectores se construye una matriz ( ) . Se realizan los siguientes cálculos: Autovalores Nuevas coordenadas

Distancia entre el modelo y el contorno activo Determinación de la distancia de cada modelo: Se realiza una resta binaria pixel a pixel entre las dos imágenes, si el pixel coincide se aumenta la suma. El modelo que tenga la mínima distancia (suma) será el que mejor se adapte al contorno activo y el que se utilizará para realizar la segmentación. Una vez hallado el modelo se incorpora un nuevo término de energía al contorno activo basado en la forma a la que debe de evolucionar.

Resultados en 2D

Resultados en 3D

Clases de ITK utilizadas Transformaciones: Escalar, rotar y trasladar Itk::Transform Itk::Similarity2DTransform Itk::Similarity3DTransform Representación de matrices y vectores Itk::Matrix Itk::FixedArray Coordenadas e intensidad de los píxeles Itk::Statics::JointDomainImageToListAdaptor Autovalores y autovectores de matrices simétricas Vnl_symmetric_eigensystem Cálculos estadísticos: media, varianza, mín, máx,... Itk::StaticsImageFilter

Capitulo 5: Computación paralela con MPI Introducción MPI ("Message Passing Interface") es un estándar que define la sintaxis y la semántica de las funciones contenidas en una biblioteca de paso de mensajes diseñada para ser usada en programas que exploten la existencia de múltiples procesadores de forma distribuida. Las implementaciones en MPI consisten en un conjunto de bibliotecas de rutinas que pueden ser utilizadas en programas escritos en los lenguajes de programación C, C++, Fortran y Ada.

Objetivos de MPI Escalabilidad Portabilidad Heterogeneidad Rendimiento Existen implementaciones de MPI eficientes para una amplia variedad de sistemas. Heterogeneidad MPI debe ser capaz de ejecutarse en sistemas heterogéneos de manera transparente. Rendimiento Permitir implementaciones eficientes para máquinas de diferentes características. Formalidad Define el comportamiento de las implementaciones de manera concisa.

Conceptos básicos Fundamentos de MPI #include “mpi.h” ... main(int argc, char** argv){ /*Ninguna llamada a función MPI anterior a esta*/ MPI_Init(&argc, &argv); MPI_Finalize(); /*Ninguna llamada a función MPI posterior a esta*/ }/*main*/

Inicializar, administrar y finalizar comunicaciones int MPI_Init(int *argc, char ***argv); Permite inicializar una sesión MPI. Esta función debe ser utilizada antes de llamar a cualquier otra función de MPI. Comunicador: MPI_COMM_WORLD int MPI_Comm_size(MPI_Comm comunicador, int* numprocs) Permite determinar el número total de procesos que pertenecen a un comunicador. int MPI_Comm_rank(MPI_Comm comunicador, int* identificador) Permite determinar el identificador (rank) del proceso actual. int MPI_Finalize() Permite terminar una sesión MPI. Esta función debe ser la última llamada a MPI que un programa realice. int MPI_Get_processor_name(char* nombre, int* longnombre) Permite conocer el nombre del procesador donde está ubicado cada proceso

Paso de mensajes int MPI_Send(void* mensaje, int contador, MPI_Datatype tipo_datos, int destino, int etiqueta, MPI_Comm comunicador) Permite enviar información desde un proceso a otro. Función bloqueante. Versión no bloqueante: MPI_Isend int MPI_Recv(void* mensaje, int contador, MPI_Datatype tipo_datos, int origen, int etiqueta, MPI_Comm comunicador, MPI_Status* status) Permite recibir información desde otro proceso. Función bloqueante. Versión no bloqueante: MPI_Irecv Origen: MPI_ANY_SOURCE Etiqueta: MPI_ANY_TAG

Tipos de datos MPI MPI_CHAR signed char MPI_SHORT signed short int MPI_INT signed int MPI_LONG signed long int MPI_UNSIGNED_CHAR unsigned char MPI_UNSIGNED_SHOT unsigned short int MPI_UNSIGNED unsigned int MPI_UNSIGNED_LONG unsigned long int MPI_FLOAT float MPI_DOUBLE double MPI_LONG_DOUBLE long double MPI_BYTE MPI_PACKED

Transferir datos entre varios procesos int MPI_Barrier(MPI_Comm comm) Permite realizar operaciones de sincronización. Se utiliza para dar por finalizada una etapa del programa, asegurándose de que todos los procesos han terminado antes de dar comienzo a la siguiente int MPI_Bcast(void* mensaje, int contador, MPI_Datatype tipo_datos, int raiz, MPI_Comm com) Permite a un proceso enviar una copia de sus datos a otros procesos dentro de un grupo definido por un comunicador.

Capítulo 6: Computación paralela con MATLAB Introducción Utilización de Parallel Computing Toolbox™ de Matlab2008b. Esta toolbox se utiliza para: Descargar de trabajo a una sesión de MATLAB (el cliente) hacia otras sesiones (trabajadores). Crear versiones paralelizadas de tus aplicaciones con un cambio mínimo de código. Ejecutar hasta cuatro trabajadores de forma local, además de la sesión del cliente. Se utiliza MATLAB® Distributed Computing Server™ para ejecutar tantos trabajadores como nodos tenga el cluster.

Casos de uso Paralelización de bucles for (parfor) Trabajos por lotes Aplicaciones con muchas repeticiones. Aplicaciones con largas iteraciones. Trabajos por lotes Descargar de trabajo hacia una sesión trabajador (worker) para que se ejecute como un trabajo por lotes. Grandes conjuntos de datos Distribuir una matriz muy grande entre varios trabajadores de modo que cada trabajador sólo contiene una parte de la matriz.

Paralelización bucles for Introducción Cuando ejecutamos en MATLAB el comando parfor parte del cuerpo del bucle se ejecuta en el cliente y parte se ejecuta en paralelo en los trabajadores. Un bucle parfor proporciona un rendimiento significativamente mejor que un bucle for sin paralelizar.

Ejecución bucle for en paralelo Bucle for normal for i=1:1024 A(i) = sin(i*2*pi/1024); end plot(A) Bucle for paralelo matlabpool open parfor i=1:1024 A(i) = sin(i*2*pi/1024); end plot(A) matlabpool close Se utiliza la función matlabpool para reservar un número concreto de trabajadores para la posterior ejecución de un bucle parfor. Dependiendo de la configuración, los trabajadores podrían estar ejecutándose de forma remota en un cluster o bien de forma local.

Limitaciones Nombres de variables que no sean ambiguas Transpariencia Uso de funciones que violan la transparencia: eval, evalc, evalin, assigin. Funciones no distribuibles por ejemplo, input, plot, keyboard. Funciones anidadas Bucles anidados parfor Declaraciones break y return Variables global y persistent

Single Program Multiple Data (spmd) Introducción Las declaraciones spmd permiten definir un bloque de código que se ejecuta simultáneamente en varios laboratorios. Casos de uso: Programas que tardan mucho tiempo en ejecutarse. Programas que operan con grandes conjuntos de datos

Declaración spmd Definición spmd (m,n) spmd spmd (n) El bloque de código representado por <statements> se ejecuta en paralelo simultáneamente en todos los laboratorios configurados en matlabpool. Si se desea limitar la ejecución a sólo una parte de estos laboratorios, se utiliza el argumento n. Si se requiere un mínimo y máximo de laboratorios, se utiliza el argumento m (mínimo) y n (máximo). spmd (m,n) <statements> end spmd <statements> end spmd (n) <statements> end

Ejemplos matlabpool spmd (3) R=rand(4,4); end matlabpool close Crear una matriz aleatoria en tres laboratorios Utilizar una matriz codistribuida en una declaración spmd. Crear matrices dependiendo del labindex. matlabpool spmd (3) R=rand(4,4); end matlabpool close spmd (3) if labindex==1 R=rand(9,9); else R=rand(4,4); end end spmd (3) RR = rand (30, codistributor ()); end

Objetos Composite Creación de objetos Composite spmd MM = magic(labindex+2); % MM is a variable on each lab end MM{1} %In the client, MM is a Composite with one element per lab 8 1 6 3 5 7 4 9 2 MM{2} 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1

Secuencias spmd Los valores almacenados en los laboratorios se conservan entre declaraciones spmd. spmd AA = labindex; %Initial setting (labindex=4) end AA(:) % Composite [1] [2] [3] [4] AA = AA * 2; %Multiply existing value in all the labs [6] [8] clear AA %Clearing in client also clears on labs

Limitaciones Transpariencia Funciones anidadas Uso de funciones que violan la transparencia: eval, evalc, evalin, assigin. Funciones anidadas Declaraciones spmd anidadas Declaraciones break y return Variables global y persistent

Computación paralela interactiva con pmode Introducción pmode te permite trabajar interactivamente con un trabajo paralelo ejecutándose simultáneamente en varios laboratorios. Los comandos que se escriban en el prompt de pmode (Parallel Comand Window) se ejecutan en todos los laboratorios al mismo tiempo Cada laboratorio ejecuta los comandos en su propio en su propio espacio de trabajo en sus propias variables.

Primero pasos con pmode Para empezar pmode se utiliza el comando pmode pmode start local 4 Si se establece una variable en el prompt del pmode se observa que el valor se establece en todos los laboratorios P>> x = pi La función labindex devuelve el ID particular a cada uno de los laboratorios que estén ejecutando el trabajo paralelo. Para saber el número total de laboratorios que trabajan en el actual trabajo paralelo utilizamos la función numlabs. Se puede distribuir una matriz en todos los laboratorios utilizando la función codistributed(). Se puede usar la función localPart para acceder a la porción de la matriz codistribuida de un determinado laboratorio. Si se necesita la matriz entera en un workspace determinado, se utiliza la función gather.

Parallel Comand Window

Matrices codistribuidas Introducción Todos los tipos de datos soportados y estructuras soportadas por MATLAB son también soportados por el entorno de computación paralelo. Tipos de matrices: Matrices no distribuidas Matrices replicadas Matrices variantes Matrices privadas Matrices codistribuidas

Matrices codistribuidas Las matrices codistribuidas se dividen en segmentos, y cada uno de ellos reside en un entorno de trabajo de diferentes laboratorios. P>> A = [11:20; 21:30; 31:40]; P>> D = codistributed(A, 'convert')   LAB 1 LAB 2 LAB 3 LAB 4 | | | 11 12 13 | 14 15 16 | 17 18 | 19 20 21 22 23 | 24 25 26 | 27 28 | 29 30 31 32 33 | 34 35 36 | 37 38 | 39 40

Trabajando con matrices codistribuidas Cómo MATLAB distribuye matrices Si la dimensión de la matriz es no uniformemente divisible por el número de laboratorios, MATLAB particiona la matriz lo más uniformemente posible La distribución por defecto es con la última dimensión: A = zeros(80, 1000); D = codistributed(A, 'convert') 1: localPart(D) is 80-by-250 2: localPart(D) is 80-by-250 3: localPart(D) is 80-by-250 4: localPart(D) is 80-by-250

Matrices locales Creación de una matriz local a partir de una matriz codistribuida La función localPart copia los segmentos de una matriz codistribuida a una matriz variante por separado. Creación de una matriz codistribuida desde matrices locales Se utiliza la función codistributed para realizar la operación inversa. P>> A = [1:80; 81:160; 161:240]; P>> D = codistributed(A, 'convert'); P>> size(D) ans = 3 80 P>> L = localPart(D); P>> size(L) ans = 3 20 P>> X = codistributed(L); P>> size(X) ans = 3 80

Capítulo 7: Computación distribuida con MATLAB Introducción y conceptos La sesión de MATLAB en la que el trabajo y las tareas son definidas se llama la sesión cliente. El job manager (administrador del trabajo) es la parte del software del servidor que coordina la ejecución de los trabajos y la evaluación de sus tareas

Configuración básica para la computación paralela

Administradores de trabajo, trabajadores y clientes Administradores de trabajo (job manager) El job manager ejecuta trabajos en el orden en que son enviados Trabajadores Cada trabajador recibe una tarea del trabajo que se este ejecutando del job manager, ejecuta la tarea, devuelve el resultado al job manager y, a continuación, se le asigna otra tarea. Clientes Cualquier cliente puede crear, ejecutar, y enviar trabajos a cualquier job manager, pero una sesión trabajador esta registrada y dedicada a sólo un job manager al mismo tiempo.

Interacciones de las sesiones de computación paralela

Múltiples clientes y administradores de trabajo

Componentes del servidor Servicio mdce El servicio mdce recupera sesiones trabajador y job manager de posibles accidentes El servicio reinicia automáticamente el job manager y los trabajadores reanudando sus sesiones. Uso de la toolbox de procesamiento en paralelo Encontrar un administrador de trabajo (job manager) o planificador. Crear un trabajo. Crear tareas. Enviar un trabajo a la cola de ejecución. Recuperar los resultados del trabajo. Destruir el trabajo.

Ejemplo: Programación con un planificador local sched = findResource('scheduler', 'type', 'local') j = createJob(sched) createTask(j, @sum, 1, {[1 1]}) createTask(j, @sum, 1, {[2 2]}) createTask(j, @sum, 1, {[3 3]}) submit(j); waitForState(j) results = getAllOutputArguments(j) results = [2] [4] [6] destroy(j)

Planificación de la red

Capítulo 8: OpenMP Introducción OpenMP (Open Multi Processing) es una API (Application Programming Interface) que permite añadir concurrencia a las aplicaciones mediante paralelismo con memoria compartida. Se basa en la creación de hilos de ejecución paralelos compartiendo las variables del proceso padre que los crea. Esta compuesta de los tres principales componentes de una API: Directivas de Compilador. Bibliotecas de rutinas en tiempo de ejecución. Variables de entorno.

Objetivos de OpenMP Estandarización Simplicidad Facilidad de uso Estándar entre una gran variedad de arquitecturas y plataformas para el uso de la memoria compartida . Simplicidad Un paralelismo significativo puede ser implementado mediante el uso de sólo 3 o 4 directivas . Facilidad de uso Paralelización incremental de un programa en serie. Portabilidad Soporte para Fortran (77, 90 y 95), C y C++.

Modelo de Programación Modelo fork-join Los programas OpenMP comienzan como un proceso único: el hilo principal (master thread). FORK: El hilo principal crea un grupo de hilos paralelos. JOIN: Cuando el grupo de hilos completa las declaraciones en la región paralela, se sincronizan y terminan, dejando sólo el hilo principal.

#pragma omp parallel default(shared) private(beta,pi) Directivas OpenMP Introducción Las directivas OpenMP permiten al usuario decirle al compilador que instrucciones se van a ejecutar en paralelo y cómo se distribuirán entre los hilos que ejecuten el código. Ejemplo #pragma omp parallel default(shared) private(beta,pi) Reglas generales Son sensibles a mayúsculas y minúsculas Las directivas siguen las convenciones de las normas de C / C + + para su compilación. Sólo un de nombre puede ser especificado por directiva Las directivas largas pueden ser "continuadas“ con el carácter de nueva línea que es una barra invertida ("\").

Características del lenguaje OpenMP Rutinas de la librería OpenMP Constructor de región paralela (omp parallel) Constructor de trabajo compartido Constructor de bucle paralelo (omp for) Constructor de secciones paralelas (omp sections) Constructor de región única (omp single) Claúsulas Data-Sharing, No Wait, y Schedule. Constructor de barrera (omp barrier) Constructor de región crítica (omp critical) Constructor maestro (omp master)

Constructor de región paralela Introducción #pragma omp parallel [clause ...] newline if (scalar_expression) private (list) shared (list) default (shared | none) firstprivate (list) reduction (operator: list) copyin (list) num_threads (integer-expression) structured_block

Constructor de región paralela #pragma omp parallel [clause ...] newline if (scalar_expression) private (list) shared (list) default (shared | none) firstprivate (list) reduction (operator: list) copyin (list) num_threads (integer) structured_block #include <omp.h> main () { int var1, var2, var3; // Codigo secuencial // ... //Comienza la seccion paralela. //El hilo maestro expande un conjunto de hilos //Especifica el ambito de las variables #pragma omp parallel private(var1, var2) shared(var3) { //Seccion paralela ejecutada por todos los hilos //... //Todos los hilos se unen al hilo maestro }

Constructor de bucle for paralelo #pragma omp for [clause ...] newline schedule (type [,chunk]) ordered private (list) firstprivate (list) lastprivate (list) shared (list) reduction (operator: list) collapse (n) nowait for_loop Ejemplo: #pragma omp for schedule(dynamic,chunk) for (i=0; i < N; i++) c[i] = a[i] + b[i];

Constructor de secciones paralelas #pragma omp sections [clause ...] newline private (list) firstprivate (list) lastprivate (list) reduction (operator: list) nowait {   #pragma omp section newline structured_block }

Constructor de región única #pragma omp single [clause ...] newline private (list) firstprivate (list) nowait structured_block

Cláusulas constructores de región paralela y de trabajo compartido Cláusula shared Sintaxis: shared(list). Especifica cuales datos serán compartidos entre los hilos que ejecutan la región a la que están asociados. Cláusula private Sintaxis: private(list). Crea tipos de datos privados en una región paralela en donde los hilos tienen sus propias copias de las variables. Cláusula lastprivate Sintaxis: lastprivate(list). Crea tipos de datos privados, accesibles después de que la correspondiente región paralela finaliza. Cláusula firstprivate Sintaxis: firstprivate(list). Crea tipos de datos privados, iniciando el valor de la variable antes de la región paralela donde se utilizará.

Cláusula schedule Sintaxis: schedule (kind [, chunk_size]). Hay cuatro tipos diferentes de distribución en la cláusula schedule: Static: Las iteraciones se dividen en trozos de tamaño chunk_size. Los trozos se asignan estáticamente a los hilos de la forma round-robin Dynamic: Las iteraciones se asignan a los hilos cuando ellos lo solicitan. Cada hilo ejecuta su subespacio de iteraciones (controlado por el parámetro chunk_size) y, a continuación, pide otro subespacio hasta que no haya más iteraciones que trabajar. Guided = Dynamic pero el tamaño de cada parte es proporcional al número de iteraciones sin asignar, dividido por el número de hilos menos uno. Runtime: La decisión relativa al tipo de distribución se realiza en tiempo de ejecución.

Constructores de sincronización Constructor de barrera La barrera es un punto en la ejecución de un programa donde los hilos se esperan mutuamente: ningún hilo del grupo procederá más allá de la barrera hasta que todos los hilos hayan llegado a ese punto. #pragma omp barrier Constructor ordered Permite la ejecución de un bucle paralelo en orden secuencial #pragma omp ordered structured block Constructor critical Medio para asegurar que múltiples hilos no intentan actualizar los mismos datos compartidos al mismo tiempo #pragma omp critical [(name)]

Constructor atomic Constructor master Múltiples hilos para actualizar los datos compartidos sin interferencias. #pragma omp atomic statement Constructor master Define un bloque de código que garantiza que va a ser ejecutado sólo por el hilo principal. #pragma omp master structured block

Algunas rutinas de OpenMP void omp_set_num_threads (int num_threads ) int omp_get_num_threads(void) int omp_get_thread_num(void) int omp_get_num_procs(void) int omp_in_parallel(void) void omp_set_dynamic(int dynamic_threads) int omp_get_dynamic(void) void omp_set_nested(int nested) int omp_get_nested (void)

Capítulo 9: Resultados Resultados comparativos de la paralelización de la difusión anisotrópica La ejecución ha sido realizada sobre un ordenador de cuatro núcleos en XP-64 bits. Imagen DICOM Matlab sin paralelizar Matlab paralelo C++ sin paralelizar C++ paralelo con OpenMP 1 63.06 55.83 85.31 33.12 2 43.78 37.69 58.96 23.30 3 31.53 27.66 43.13 16.64 4 80.67 68.63 109.17 43.59 5 99.57 85.58 135.19 53.21 6 40.58 34.37 53.37 21.14 7 75.94 65.63 102.70 41.52 8 124.65 105.60 167.51 68.44 9 85.20 73.43 118.42 46.82 10 134.73 113.81 181.61 75.41 11 95.12 82.16 132.15 52.60 12 61.34 52.96 82.43 33.97 13 22.21 19.82 29.70 11.91 14 90.99 77.94 130.05 50.32 15 88.44 75.42 120.75 48.74 16 42.70 36.71 55.49 21.15 17 174.63 147.40 240.37 101.26 18 34.86 30.02 44.49 18.20

FIN