Temario

Sesiones	Tareas
1. Introducción al cómputo paralelo
2. Introducción a OpenMP     Notebook_OpenMP_HelloWorld 3. Ejemplos usando OpenMP     Notebook_OpenMP_VectorAddition 4. OpenMP Parte 2 5. Multiprocessing en Python	T1: Intro_OpenMP T2: Multiprocessing
6. Introducción a CUDA 7. Ejemplos     Notebook CUDA	T3: Intro_CUDA
8. Arquitectura de las GPUs y tipos de memoria 9. Ejemplos (Parte 2)	T4_CalculaError_OpenMPCUDA
10. CUDA en Python (CuPy) 11. Notebook CuPy
12. Introducción al Procesamiento de Imágenes 13. Ejemplos de Procesamiento de Imágenes usando CUDA	T5: IntroProcImagenesCUDA fondo.bmp greenscreen.jpg greenscreenMask.bmp pinzas_gray.png
14. Proyectos
15. OpenACC 16. OpenACC - Ejemplos

Calificaciones:

Num. Ctrl.	T1_OMP	Comentarios	T2_MTP	Comentarios	T3_CUDA	Comentarios	T4_CUDA	Comentarios	Prom. Tareas	Examen	Calif. Final 0.7T+0.3E
11010	9.5	T1_OMP_27	9	T2_MTP_1	10		10		9.625	9.5	9.59
423519	10		10		10		10		10	9.0	9.70
7	9.5	T1_OMP_27	10		10		9	T4_CUDA_24	9.625	9.25	9.51
49	8	T1_OMP_29	9	T2_MTP_2	10		8	T4_CUDA_25, T4_CUDA_26, T4_CUDA_27	8.75	7.0	8.23
1089	10		9	T2_MTP_1	0	T1_OMP_9	0	T1_OMP_9	4.75	0	3.33
01	0	T1_OMP_9	0	T1_OMP_9	0	T1_OMP_9	0	T1_OMP_9	0	8.75	2.63

 

Comentarios:

• T1_OMP_1: Falta describir en tu reporte para que sirven las directivas de openmp que utilizaste en la tarea.

• T1_OMP_2: Hay un detalle en el código de los ejercicio 2 y 4, al momento de crear la memoria para tus apuntadores dobles (float **matA), hay que modificar el argumento del malloc de matA = (float**)malloc(size * sizeof(float)) a matA = (float**)malloc(size * sizeof(float*)), si no, el compilador marca un error en tiempo de ejecución y en linux despliega un : Segmentation fault (core dumped)
  

• T1_OMP_3: En el ejercicio 3b faltó la división entre dos.

• T1_OMP_4: Entregar el reporte en formato .doc o .pdf, para entenderlo de forma más sencilla.

• T1_OMP_5: El ejercicio 1 no está implementado de forma correcta, ya que tu código lo que hace es sumar N veces el contenido de tu vector de tamaño N.

• T1_OMP_6: El ejercicio 1 no está implementado de forma correcta, ya que tu código lo que hace es sumar dos vectores.

• T1_OMP_7: Hay que tener cuidado con el uso del firstprivate, sobre todo cuando se agreguen apuntadores dentro de esta directiva. Ya que lo que va a hacer el firstprivate es hacer una copia del apuntador para cada hilo ejecutado, pero cada uno de ellos apunta a la misma localidad de memoria. De esta forma, el rendimiento debería ser el mismo si solo dejas al apuntador de tipo shared. Recuerda que las variables que asignes de tipo shared sirven tanto para leer como para escribir información en ellas. Por otro lado, si en algún momento quisieras tener un apuntador y la memoria a la que apunta de tipo privado, entonces sería mejor asignar la memoria dentro de la región paralela y dejar como private al apuntador.
  

• T1_OMP_8: Para que pruebes con valores de N muy grandes en tu ejercicio 1, te recomiendo que uses el tipo de dato long long int, en lugar de solo int.

• T1_OMP_9: No entregó tarea.

• T1_OMP_10: Hay que evitar el uso de printf o fprintf en sus regiones paralelas. Esto hace que el programa sea más lento.

• T1_OMP_11: No entregó reporte.

• T1_OMP_12: El resultado que muestras en pantalla del problema 2 de tu implementación secuencial no es correcto, pues estas imprimiendo una de las matrices de entrada en lugar de la multiplicación.

• T1_OMP_13: La implementación secuencial del problema 1 contiene instrucciones de openmp que hacen que esto se ejecute en paralelo.

• T1_OMP_14: Quizá si utilizas collapse(2) en tu código paralelo del ejercicio 2 puedas reducir un poco más el tiempo de procesamiento.

• T1_OMP_15: En la implementación paralela del ejercicio 2, te hace falta agregar la directiva "parallel", no basta con solo poner #pragma omp for.

• T1_OMP_16: En el ejercicio 2 faltó la inicialización del arreglo matP a cero antes de entrar a la región paralela.
  

• T1_OMP_17: En el ejercicio 3a, hay un error en los argumentos de la función secuencial y paralela, en lugar del arreglo crray de tamaño N-2 había que pasar el arreglo brray de tamaño N-1, para evitar accesos a memoria no definida.
  

• T1_OMP_18: En el ejercicio 3, dentro de cada función secuencial y paralela hay que poner una asignación (=) en lugar de (+=), ya que las variables no han sido inicializadas y esto podría ocacionar sumar con valores basura del arreglo. La otra opción es inicializar los arreglos en cero.
  

• T1_OMP_19: En el ejercicio 1, no basta con solo poner la variable acumuladora de tipo compartida, habría que poner también alguna sentencia de sincronización que evite que algún hilo lea desde la variable compartida un valor no actuallizado de esta. Ejecuta varias veces tu código con N=1000 y verás que en algún momento el resultado no es el esperado. Otra forma de solucionar este problema es usando la directiva reduction().
  

• T1_OMP_20: En el ejercicio 2, para cada hilo que ejecutas estás realizando la multiplicación de las matrices, si lanzas cuatro hilos, entonces realizas cuatro veces la misma multiplicación. Hace falta agregar la directiva "for" para que se paralelice por lo menos el primer ciclo más externo de la multiplicación. 
  

• T1_OMP_21: En el ejercicio 3b, hay un problema al momento de acceder a V[i-1] cuando i=0, ya que se trata de acceder a una localidad negativa V[-1]. El problema se detecta hasta el momento de ejecución.
  

• T1_OMP_22: En el ejercicio 4b, conviene que tu varible alpha sea declarada dentro de un firstprivate() en lugar de dejarla como compartida.
  

• T1_OMP_23: En el ejercicio 2 y 4, lo que mencionas en tu reporte no concuerda con lo que programaste. En el reporte mecionas que cada hilo se encarga de calcular una cuarta parte de las filas de la matriz C, pero en el código se observa que cada hilo resuleve solo una fila de la matriz C, es decir N bebe ser igual al número de hilos lanzados, lo que limita a que N sea muy pequeña.
  

• T1_OMP_24: En el ejercicio 3, tienes demás el #pragma omp parallel for. El compilador lo va a tomar como un comentario ya que no está habilitado el paralelismo anidado, pero es algo que no se requiere en tu implementación.
  

• T1_OMP_25: En el ejercicio 3b, tu implementación no es correcta, había que hacer (V[i+1]+V[i-1])/2 y tu implementaste (V[i]+V[i+1])/2.
  

• T1_OMP_26: Faltó implementar el ejercicio 3b, el que entregaste es una copia del código del ejercicio 3a.

• T1_OMP_27: El resultado del ejercicio 1a es incorrecto. Nota que y es un vector de tamaño N, que debe estar definido antes de la región paralela. Si es posible saber el resultado y depende del número de hilos a ejecutar.

• T1_OMP_28: Faltó incluir el código del ejercicio 2.

• T1_OMP_29: En los ejercicios 2 y 4 te faltó abrir una región paralela. Solo tienes la instrucción #pragma omp for, pero esta instrucción necesita de una región paralela para poder paralelizar el ciclo for.
  

• T2_OMP_1: En el problema del calculo del histograma, se podrían obtener mejores tiempos si se usa la directiva #pragma omp atomic en lugar de los locks o incluso critical. Sin embargo sigue estando mejor el tiempo del programa secuencial. Una forma de obtener mejores resultados sería considerando histogramas privados a cada hilo y después juntar el resultado en un solo histograma.

• T2_OMP_2: En tu reporte no mencionas la cantidad de datos que utilizas para realizar los experimentos.

• T2_OMP_3: En tu código del ejercicio 2, no utilizaste la directiva collapse, sin embargo en tu reporte si aparece.

• T2_OMP_4: Al compilar tu código del ejercicio 2, este no compila por que no puedes poner un #pragma omp for dentro de otro #pragma omp for. Nota que en tu ciclo más externo has habierto una región paralela con #pragma omp parallel, pero en tu ciclo más interno no has abierto alguna región paralela, solo tienes #pragma omp for, falta la directiva parallel, para que puedas usar el paralelismo aninado.

• T2_OMP_5: Tu código del ejercicio 3 tampoco compila, sin embargo, aquí si podemos solamente comentar el #pragma omp for que tienes en el ciclo más interno de tu función multiplyParallel para que compile el programa y devuelva los speedups esperados.

• T2_OMP_6: En las gráficas de tu reporte faltó definir que es el eje x y el eje y, en este momento sabemos que graficaste el speedup y la eficiencia. Pero a lo mejor de aquí a un año ya no vas a saber que estás graficando.

• T2_OMP_7: Nota que el #pragma omp critical que tienes en el ciclo más interno del ejercicio 2, inciso a), no es necesario, ya que solo estas paralelizando el ciclo más externo.

• T2_OMP_8: El resultado de las multiplicaciones de las matrices del ejercicio 3 inciso b), va a ser incorrecto, ya que estas usando paralelismo anidado para los tres ciclos. Nota: Si utilizas #pragma omp critical en el ciclo más interno, tienes que usar las llaves {} para encerrar las dos instrucciones, de lo contrario, solo la primera instrución caerá en la región critica, solo que el rendimiento es más bajo al usar critical.
  

• T2_OMP_9: La implementación en paralelo del ejercicio 1 es incorrecta, el resultado del programa paralelo no resulta lo mismo que el secuencial. Hay que tener cuidado con la parte del contador: count[ind] += 1; o histo[vec[j]] += 1; pues varios hilos van a querer realizar la misma operación de forma concurrente.

• T2_OMP_10: El ejercicio 2 inciso c), está mal implementado, pues no estas utilizando el paralelismo anidado, solo tienes una región paralela en el ciclo más externo.

• T2_OMP_11: Olvidaste el omp_set_nested(1); en el ejercicio 3 inciso b), para que las regiones paralelas que tienes dentro de cada section se ejecuten también en paralelo.

• T2_OMP_12: Para una long long N = 1000000000 ya comienzas a ver ganacia en tu implementación del ejercicio 1.

• T2_OMP_13: En el ejercicio 3 solo tienes una versión del código paralelo, te faltó considerar uno de los incisos. Para el inciso a) se puede utilizar una región sections, en donde se tenga una sección para la multiplicación de A*B y otra para la multiplicación de B*D, de esta forma tendrías las dos multiplicaciones realizandose en simultáneo. Para el inciso b), podrías aprovechar el paralelismo anidado y entonces además de usar el sections, tener dentro de cada uno, regiones paralelas que ejecuten en paralelo los ciclos de las multiplicaciones.
  

• T2_OMP_14: Para que el paralelismo anidado tenga efecto en tu programa, hay que usar omp_set_nested(1); en lugar de poner #pragma omp omp_set_nested(1).
  

• T2_OMP_15: Al funcionar el paralelismo anidado en el ejercicio 2 inciso c), el resultado de tu programa paralelo es incorrecto. Hay que eliminar #pragma omp parallel for schedule(static) de tu ciclo más interno, pues este puede causar conflicto entre los hilos para actualizar los valores del producto punto en la multiplicación de las matrices.

• T2_OMP_16: Tus implementaciones de la multiplicación de matrices están mal, tu segundo ciclo puede causar accesos a memoria no reservada. Cambia la M por la N.

• T2_OMP_17: El ejercicio 3 no está implementado de forma correcta, en los dos incisos al usar #pragma omp p a r a l l e l, le dices al compilador que quieres una región paralela en la que todos los hilos disponibles van a relizar lo que esté dentro de dicha región, por lo tanto si pones las dos multiplicaciones dentro de esta región, cada hilo va a realizar esas dos multiplicaciones.

• T2_OMP_18: Olvidaste el omp_set_nested(1); en el ejercicio 2 inciso c) y en el ejercicio 3 inciso b). Con esta instrucción le dices al compilador que quieres usar paralelismo anidado.

• T2_OMP_19: Puedes lanzar un número diferente de hilos dentro de cada ciclo usando el num_threads(), nota que en el ejercicio 2 inciso c), la región paralela interna lanza todos los hilos que tengas disponibles, quizá esto afecto el rendimiento de tu programa.
  

• T2_OMP_20: En el ejercicio 3 también puedes considerar lo siguiente para obtener un mejor rendimiento: Para el inciso a) se puede utilizar una región section, en donde se tenga una sección para la multiplicación de A*B y otra para la multiplicación de B*D, de esta forma tendrías las dos multiplicaciones realizandose en simultáneo. Para el inciso b), podrías aprovechar el paralelismo anidado y entonces además de usar el sections, tener dentro de cada uno, regiones paralelas que ejecuten en paralelo los ciclos de las multiplicaciones.
  

• T2_OMP_21: Para medir tiempos de procesamiento de tus programas es mejor tener por separado el tiempo que consume tu programa en leer o escribir los datos del tiempo que consume procesando los datos.

• T2_OMP_22: En el ejercicio 1, faltó responder los incios a) y b). Solo muestras el código, pero faltó explicar el resultado en el reporte.

• T2_OMP_23: En el ejercicio 1, es incorrecto el valor de la variable c. La formula que deduces es correcta pero están mal aplicadas las operaciones.
  

• T2_OMP_24: En el ejercicio 2a, no es correcto el uso de sections, este debe ir dentro de un #pragma omp parallel para que realice los respectivos section en paralelo.

• T2_OMP_25: En el ejercicio 2b, olvidaste poner el omp_set_nested(1), para que las regiones paralelas que tienes dentro de cada section se ejecuten también en paralelo.

• T2_OMP_26: En el ejercicio 2, están mal implementadas las multiplicaciones de las matrices. No es correcto como calculas el índice para las matrices A y B. Para A en lugar de iN = i * N; debe ser iN2 = i * K;. Para B en lugar de iM = i * M;, debe ser iM2 = i * N;. Revisalo y los resultados de la multiplicación y tiempos de procesamiento van a ser diferentes.

• T2_OMP_27: Trata de mejorar el reporte para las próximas tareas.

• T2_OMP_28: En el ejercicio 2, estas liberando dos veces la memoria apuntada por el apuntador C. En lugar de C debe ser E.

• T2_OMP_29: En el ejercicio 2b, hay que reemplazar #pragma for collapse(2) por #pragma omp for collapse(2), para que tenga efecto la instrucción. Sugiero medir tiempos usando t_ini = omp_get_wtime();, t_end = omp_get_wtime(); time_cpu_seconds = t_end - t_ini; printf("time : %f", time_cpu_seconds);
  

• T2_OMP_30: En el ejercico 2b, olvidaste el omp_set_nested(1); para que las regiones paralelas que tienes dentro de cada section se ejecuten también en paralelo.

• T2_OMP_31: En el ejercicio 2, están mal implementadas las multiplicaciones de la matrices. En particular cuando n, m y k son diferentes el programa no funciona, ya que tus dos primeros ciclos de la multiplicación son iguales, es decir tienen el mismo valor tope del ciclo.

• T2_OMP_32: En el ejercicio 3, estas grafiacando los tiempos de procesamiento y lo que se pide es el speedup, es decir, la razón que hay entre el tiempo secuencial y el tiempo paralelo.

• T2_OMP_33: En el reporte faltó describir lo que utilizaste en la paralelización de los incisos a) y b). Además, la interpretación de la gráfica del speedup es incorrecta.

• T2_OMP_34: Sugiero que pruebes con matrices más grandes y midas los tiempos de procesamiento usando t_ini = omp_get_wtime();, t_end = omp_get_wtime(); time_cpu_seconds = t_end - t_ini; printf("time : %f", time_cpu_seconds);
  

• T2_OMP_35: En el ejercicio 1, es incorrecto el valor de la variable c. La variable c siempre toma el mismo valor al finalizar la segunda región paralela. Hay que revisar bien para que sirve lastprivate.
  

• T2_OMP_36: En el ejercicio 3, estás graficando el tiempo que te resulta del inciso a) vs el tiempo del inciso b). Lo que se pide más bien es dos gráficas de speedup, una para considerar el tempo secuencial de los dos productos de matrices vs la versión paralela del inciso a); en la otra gráfica se considera otra vez el tiempo secuencial pero ahora comparado con el tiempo de la versión paralela del inciso b).
  

• T2_OMP_37: En el ejercicio 2b, la idea era usar el parelismo anidado, es decir, que dos hilos lanzaran cada uno una maultiplicación y luego usar más hilos para paralelizar cada multiplicación. Lo que hiciste fue paralelizar las dos multiplicaciones por separado, de esta forma primero se ejecuta en paralelo la primer multiplicación y ya que se termina este proceso, se lanza la siguiente mutiplicación en paralelo.

• T2_OMP_38: En el ejercicio 3, faltó que graficaras el speedup que se obtiene al considerar el tiempo secuencial vs la implementación paralela del inciso a).

• T2_OMP_39: En el ejercicio 2b, estás graficando el speedup al variar el número de hilos lanzado en la parte de las sections (en donde solo se utilizan dos hilos), en lugar de variar el número de hilos que se encargan de paralelizar las multiplicaciones.

• T2_OMP_40: En el ejercicio 2, solo tienes la implementación del inciso b), faltó el inciso a).
  

• T2_OMP_41: Faltó describir la instrucción omp_set_nested(1); en tu reporte.

• T2_OMP_42: En tu reporte faltó la descripción de las directivas e intrucciones que utilizaste de openmp.

• T2_OMP_43: En el ejercicio 3, faltaron las dos gráficas del speedup variando el número de hilos para las implementaciones paralelas del ejercicio 2.

• T2_MTP_1: La implementación del ejercicio 1b es incorrecto. La idea era que ambas multiplicaciones se estuvieran ejecutando en paralelo, no importa que cada multiplicación se realice de forma secuencial. Por eso fijamos OMP_NUM_THREADS=1, para no involucrar la paralelización que hace numpy en la multiplicación de las matrices.      

• T3_CUDA_1: Para compilar en windows, puedes abrir el x64 native Tools Command Prompt for VS 2019, entonces compilar con: nvcc -arch=sm_# helloWorld.cu -o run_helloWorld.exe, con # el número de capacidad correspondiente a tu GPU.

• T3_CUDA_2: La implementación de la multiplicación de matrices es incorrecta. Hay un detalle cuando calculas los indices globales idx y idy dentro de la función kernel. En tu código tienes: int idx = blockIdx.x * blockDim.x * threadIdx.x y debería ser: int idx = blockIdx.x * blockDim.x + threadIdx.x

• T3_CUDA_3: En la implementación de multiplicación de matrices, nota que el tamaño de tus matrices es 12x12. Configuraste bloques de 10x10 hilos y defines tu malla como dim3 n_blocks(ncol /block_size.x, nfil / block_size.y);. Si la dimensión de las matrices y el tamaño que propones no son divisibles, como es este caso, habrán filas y columnas que no se estarán procesando.

• T3_CUDA_4: En tu reporte faltó describir para que sirven las instrucciones de CUDA, no solo mostrar los resultados.
  

• T4_CUDA_1: Los tiempos que tienes en tu reporte de la multiplicación de matrices usando memoria global y compartida pueden mejorar si pruebas con un BLOCK_SIZE más grande. Vi que lo tienes en 4, puedes cambiarlo hasta 32 y observar la mejora.

• T4_CUDA_2: En el ejercicio 2 inciso b), no es necesario crear memoria de forma explicita en el GPU para el parámetro alpha, tampoco realizar de forma explicita la copia de memoria. Como se trata de un escalar, basta con pasarla como parámetro a la función kernel.

• T4_CUDA_3: El ejercicio 3, inciso c), está mal implementado, el resultado no es correcto. Al momento de llamar a la función kernel, tienes << <dimBlock, dimGrid >> > , esto debería de ser << < dimGrid,dimBlock >> >. Luego, siguiendo la lógica de la función kernel, veo que no todos los productos puntos se van a registrar en tu variable compartida p. Además realizando esto no se va a aprovechar la ventaja de usar memoria compartida, ya que la finalidad en la multiplicación de matrices es que compartas ciertas localidades de memoria para realizar los productos puntos.

• T4_CUDA_4: En el ejercicio 1, tienes <<<BLOCK_SIZE,NUM_BLOCKS>>> en la llamada a tus funciones kernel, este debería ser: <<<NUM_BLOCKS, BLOCK_SIZE >>>. Primero va el tamaño y dimensión de la malla y después el tamaño y dimensión del bloque de hilos.

• T4_CUDA_5: Faltó implementar el ejercicio 2 usando CUDA.
  

• T4_CUDA_6: En el ejercicio 3, inciso c), faltó considerar que las matrices pueden ser no cuadradas y utilizar valores en punto flotante de 64 bits (double)
  

• T4_CUDA_7: Faltó realizar el inciso d) del ejercicio 3.

• T4_CUDA_8: En el ejercicio 3, inciso c), faltó considerar que las matrices pueden ser no cuadradas. El resultado es incorrecto cuando pruebas con matrices no cuadradas.
  

• T4_CUDA_9: En el reporte faltó agregar los resultados del speedup alcanzado.
  

• T4_CUDA_10: Faltó realizar el inciso c) del ejercicio 3.
  

• T4_CUDA_11: Una mejora en la función kernel del inciso c) del ejercicio 3 sería hacer que varios hilos (la mitad de cada bloque) realicen la suma de los productos que guardaste en la memoria compartida block_IntP. 

• T4_CUDA_12: En el ejercicio 1 inciso a) de tu implementación usando CUDA, en la función kernel tienes la condición if (idx < N), lo cual permite que entren idx=[0,N-1], entonces cuando idx=N-1, la instrucción v[idx+1] trata de ir a la localidad v[N] la cual no se ha reservado. Además el vector v_1 es de tamaño N-1, por lo que acceder a la localidad v_1[N-1] también es un acceso a memoria no reservada.
  

• T4_CUDA_13: En el ejercicio 1 inciso b) de tu implementación usando CUDA, en la función kernel tienes solo la condición if (idx < N), lo cual permite que entren idx=[0,N-1], entonces cuando idx=0, la instrucción v[idx-1] trata de ir a la localidad v[-1] a la cual no es posible acceder. Cuando idx=N-1, la instrucción v[idx+1] trata de ir a la localidad v[N] la cual no se ha reservado. Además el vector v_1 es de tamaño N-1 (aunque debería ser de tamaño N-2), por lo que acceder a la localidad v_1[N-1] también es un acceso a memoria no reservada. 

• T4_CUDA_14: En el ejercicio 1 de tu implementación usando CUDA, olvidaste copiar la memoria de la GPU hacia la CPU para mostrar o validar los resultados.
  

• T4_CUDA_15: En el ejercicio 1a, la implementación con OpenMP es incorrecta. Tienes dos regiones paralelas anidadas para la multiplicación de las matrices. Como no tienes el omp_set_nested(1); el compilador solo paraleliza tu primer región paralela, entonces se realiza la multiplicación varias veces, dependiendo del número de hilos lanzados, en lugar de paralelizar la multiplicación.

• T4_CUDA_16: En el ejercicio 1c, no hace falta agregar la instrucción atomicAdd(), ya que el llenado en la matriz C es totalmente paralelo, es decir, los hilos lanzados tienen su propia localidad en la matriz C y no hay algún conflicto en donde varios hilos quieran escribir sobre la misma localidad de memoria.

• T4_CUDA_17: En tu reporte faltó describir lo que realizaste, no solo mostrar las tablas de tiempos y speedups.

• T4_CUDA_18: En tu reporte , no es claro como se obtienen los speedup con respecto a las implementaciones usando OpenMP. Por otro lado, faltó calcular los speedup con respecto a las implementaciones paralelas usando CUDA.

• T4_CUDA_19: En tu reporte los tiempos de procesamiento de tu implementación CUDA con Memoria Compartida para los dos primeros tamaños de las matrices parecen estar incorrectos, no es lógico que den casi el mismo tiempo que para el tamaño más grande de las matrices.

• T4_CUDA_20: Las mediciones de tiempos usando OpenMP no son buenas, habría que ver si fue por que los cores estaban ocupados con otros procesos.

• T4_CUDA_21: En tu reporte, no es claro como obtienes los speedups, algo falló en el cálculo, debes dividir el tiempo secuencial entre el respectivo tiempo paralelo.

• T4_CUDA_22: En tus implementaciones .cu es incorrecto tomar el tiempo de procesamiento de las funciones kernel con el clock() antes y después de la llamada a la función, ya que la llamada a la función kernel es asíncrona. Debiste haber puesto la instrucción cudaDeviceSynchronize(); antes de tomar el segundo tiempo, o medir el tiempo considerando las copias de memoria, o utilizar el profiler: nvprof.

• T4_CUDA_23: En tu implementación usando OpenMP, no era necesario usar sections, ya que solo tienes un section, esto está demás.

• T4_CUDA_24: La implementación usando CUDA con memoria compartida es incorrecta. A la variable d_error le asignaste memoria tanto con malloc como cudaMalloc. Los argumentos de la copia de memoria del DeviceToHost no están en el orden correcto.
• T4_CUDA_25: En la implementación paralela usando OpenMP, la forma de escribir el pragma es incorrecta. Cambia pragma por #pragma.
• T4_CUDA_26: Cuando consideras matrices mayores al tamaño 100x100, el resultado de la sumatoria secuencial y paralela no es la misma ya que los valores superan el número máximo que puede soportar un dato de tipo float. Por ejemplo el valor: float value = 200000000000.0f; se imprime como: value: 199999995904.000000.
• T4_CUDA_27: La implementación usando CUDA con memoria compartida es incorrecta. La idea es que por lo menos un hilo dentro de cada bloque de hilos realice la sumatoria correspondiente. En tu implmentación, la función kernel donde se calcula el error devulve una matriz del mismo tamaño que las matrices de entrada. Por lo menos, la matriz resultante debería de ser del tamaño del grid lanzado, es decir, del número de bloques lanzados en cada dimensión, esto en caso de no usar la función atómica atomicAdd().
  

• T5_CUDA_1: Mejora el resultado si aplicas un umbral al contenido de la imagen alpha (greenscreenMask).
  

• T5_CUDA_2: La lógica del código es correcta, solo faltó compilar y ejecutar los programas.
  

• T5_CUDA_3: No es correcto utilizar arreglos de tipo uchar para guardar las derivadas, aunque estés utilizando el valor absoluto, nota que se requiere tener valores mayores a 255, con el filtro de Sobel el valor máximo que podrías tener es 1*255+2*255+1*255, estos valores más grandes que 255 se van a cero cuando usas uchar. Es por esto que en tu resultado se ven huecos en donde debería verse un borde completo. Hay que guardar estos arreglos en int o float.
  

• T5_CUDA_4: No es correcto utilizar un arreglo uchar3 para guardar la magnitud del gradiente, utiliza mejor float3, para que notes el cambio en el resultado.
  

• T5_CUDA_5: Al momento de pasar los valores de las derivadas al rango [0,255] se te pasó considerar que las derivadas podrían tener valores negativos, por eso tu imagen de bordes no tiene algunos bordes que deberían observarse en tu imagen resultante. Una opción para corregir, sería aplicar el valor absoluto a las derivadas.
  

• T5_CUDA_6: Faltó implementar los ejercicios de forma secuencial y paralelo usando OpenMP.

• T5_CUDA_7: Nota que es mejor tener las matrices de convolución en memoria constante que en memoria global. Puedes cambiar tus matrices float mconv[] (que estan dentro de tus funciones kernel de derivadas) a __constant__ float mconv[] (afuera de la funciones kernel). 
  

• T5_CUDA_8: Al momento de guardar el resultado de la magnitud del gradiente, estas haciendo un cast de double a int Y[idx] = (int)( sqrt( Ix*Ix + Iy*Iy ) ), además tu arreglo Y es de tipo unsigned char, causando que haya perdida de información y el resultado de los bordes se vea afectado (se ven huecos en los bordes).
  

• T5_CUDA_9: En tu reporte la Figura 2: MGT es incorrecta, sin embargo, tu código si devuelve la imagen de forma correcta.

• T5_CUDA_10: Al realizar el cast de float a uchar en las derivadas, los valores negativos se truncan al cero, por esta razón los bordes no salen completos.
  

• T5_CUDA_11: En tus funciones MG y MGT olvidaste que tu malla y bloques de hilos son de 2D.
  

• T5_CUDA_12: Al momento de llamar a la función CUDA_MGT hay un problema, tienes CUDA_MGT(I_MGT_dev, I_MGT_dev,… y debería ser: CUDA_MGT(I_MGT_dev, I_MG_dev, …

• T5_CUDA_13: Es mejor tener las matrices de los filtros en memoria constante, en lugar de usar memoria global.
  

• T5_CUDA_14: Tu implementación usando OpenMP está incorrecta, ya que tienes la instrucción de paralelizar los ciclos que se encargan de aplicar la correlación de la ventana del filtro, pero esto requiere de acumuladores los cuales no estas considerando. Ojo: recuerda el uso de la directiva reduction.

• T5_CUDA_15: Faltó implementar el inciso b) usando OpenMP.

• T5_CUDA_16: Tu implementación usando CUDA para el inciso b) puede ser más eficiente si juntas los dos filtros en un solo par de ciclos for que recorran la ventana de 3x3.

• T5_CUDA_17: El detalle de tus implementaciones serial y paralelo usando OpenMP del inciso b) es que el resultado de los filtros de derivadas lo guardas en una variable de tipo uchar, esto no permite tener valores negativos, por eso en el resultado que obtienes no se ven algunos bordes de la imagen.

• T5_CUDA_18: Nota que el resultado de los filtros de derivadas del inciso b) puede estar en un rango diferente de [0,255], incluso puede tener valores negativos, por lo tanto es importante usar un tipo de dato que soporte dicho resultado.

• T5_CUDA_19: En tu reporte faltó describir lo que realizaste, no solo poner los tiempos de procesamiento.

• T5_CUDA_20: Faltó que implementaras la versión secuencial y paralela usando OpenMP de los incisos a) y b).
  

    

Proyectos:

• Proyectos, tesis y prácticas profesionales

Bibliografía:

• Rauber, T., & Rünger, G. (2013). Parallel Programming. Springer.
• Pacheco, P. (2011). An introduction to parallel programming. Elsevier.
• Chapman, B., Jost, G., & Van Der Pas, R. (2007). Using OpenMP. Portable Shared Memory Parallel Programming.
• Sanders, J., & Kandrot, E. (2010). CUDA by Example: An Introduction to General-Purpose GPU Programming, Portable Documents. Addison-Wesley Professional.
• Kirk, D. B., & Wen-Mei, W. H. (2009). Programming massively parallel processors: a hands-on approach. Morgan Kaufmann.
• Cook, S. (2012). CUDA programming: a developer's guide to parallel computing with GPUs. Newnes.
• Wilt, N. (2013). The cuda handbook: A comprehensive guide to gpu programming. Pearson Education.
• Zaccone, G. (2015). Python parallel programming cookbook. Packt Publishing Ltd.
• CuPy: https://docs.cupy.dev/en/stable/reference/index.html
  
• GPU Technology Conference, http://www.gputechconf.com/
• Webinars, https://developer.nvidia.com/gpu-computing-webinars