Multiprocesadores (OpenMP, PThreads y MPI)

¿Qué arquitectura es la más rara actualmente?. SISD. MISD. MIMD. NS/NC.

¿Cuál es la diferencia entre concurrencia y paralelismo?. Ninguna de las otras respuestas. NS/NC. Las tareas concurrentes se ejecutan en el mismo elemento de procesamiento y las paralelas en distintos. Las tareas paraleas se ejecutan en el mismo elemento de procesamiento y las concurrentes en distintos.

La lista top500. Lista los computadores actuales que son más eficientes energéticamente. Ninguna de las otras opciones. Muestra los supercomputadores actuales que ofrecen mayor número de operaciones en coma flotante por segundo. NS/NC.

Muchos de los procesadores actuales se pueden categorizar como SIMD. No, solo las GPUs se consideran procesadores vectorizados. Ninguna de las otras opciones. Si, porque tienen operaciones como las MMX, SSE o AVX que se realizan en registros especializados hardware. NS/NC.

Los programas realizados en OpenMP y PThreads no pueden correr. En una arquitectura de memoria compartida, como un PC. NS/NC. En una arquitectura de memoria distribuida, por ejemplo en varios nodos de un cluster de computadores. En una arquitectura NUMA (Non Memory Uniform Access) donde los procesadores pueden acceder a las memorias de otros procesadores.

Indicar qué sentencias hay que sustituir por el comentario para que, al ejecutar el programa imprima el valor de x. A. No sabe / No contesta. B. printf ("%d",*p);. C. printf ("%d",(int *)p);. D. printf ("%d",&x);. E. printf ("%d",&p);.

Convencionalmente, ¿con qué carácter comienzan las opciones de un comando en la línea de comandos?. el signo de guión ( - ). NS/NC. el signo de dólar ($). el signo mayor que ( > ).

Indicar qué sentencias hay que sustituir por el comentario para que, al ejecutar el siguiente programa, se tome por teclado el valor de x. No sabe / No contesta. scanf ("%d",&p);. scanf ("%d",&x );. Ninguna de las anteriores. scanf ("%f",&x);.

¿Qué pasaría en tiempo de compilación si pongo en mi código C estas dos líneas: int valor = 5; float valor = 25.1;. El compilador me daría un error. No sabe/no contesta. Podría compilar con éxito ya que se redefine automáticamente el tipo de dato.

La ganancia de velocidad observada o speed-up es: El tiempo de CPU del programa secuencial dividido el tiempo de CPU del programa paralelo. El tiempo total del programa paralelo dividido el tiempo total del programa serie. NS/NC. El tiempo total del mejor programa serie dividido el tiempo total del programa paralelo.

¿Qué sucede si las teclas de control y c (Ctrl + C) se presionan simultáneamente en la línea de comando?. el comando actual se cancela. un script comienza a ejecutarse en el shell. NS/NC. el texto resaltado se copia al portapapeles.

¿Cual de estos elementos NO aparece en el prompt de consola?. hora y fecha. nombre de usuario. nombre de host. directorio de trabajo. NS/NC.

¿Cómo puedo enumerar todos los comandos disponibles si no sé el nombre exacto del comando, por ejemplo?. leer las paginas man. presione la tecla de tabulación. presione la tecla enter. NS/NC. usa la opción --help.

¿Qué imprime el programa, si al ejecutarlo se introducen los valores 3 y 4 para las variables a y b?. No sabe / No contesta. 7.0,4.0. 3.0,4.0. 3.0,-1.0. 7.0,-1.0.

¿Cuál es el directorio raiz en Linux?. NS/NC. /home. /. C:\.

Según la ley de Amdahls, si un algoritmo tiene el 50% del código secuencial, el máximo speed-up que se puede alcanzar es. 2. NS/NC. 10. 10%.

¿Cuál de estas simplificaciones describe mejor la estructura de directorios en un sistema Linux?. Todo es un directorio. NS/NC. Todo lo anterior. Los directorios son archivos y los archivos son directorios. Todo es un archivo.

¿Cuál de las siguientes formas es la correcta para compilar el programa HolaMundo.c, generando HolaMundo?. gcc HolaMundo. gcc -o HolaMundo HolaMundo.c. gcc HolaMundo.c HolaMundo.o. No sabe/no contesta.

En una distribución de datos 2D del tipo "BLOCK,*". A cada tarea le corresponde un número de columnas consecutivas. A cada tarea le puede tocar elementos no contiguos del array 2D. A cada tarea le tocan un número de filas consecutivas. NS/NC.

¿Cuál puede ser un comodín adecuado para una lista de los archivos: test_01, test_02, test_03 y prod_02 pero NO: test_04 y debug_02. [t,p]???_0[1-3]. [t,p]*_*. *_0[1-3]. *_*. NS/NC.

Al realizar un algoritmo paralelo que necesita comunicaciones, se prefiere que. las comunicaciones afectan poco a la eficiencia de los algoritmos paralelos. lo importante es la computación que realizan. las comunicaciones sean asíncronas siempre que sean posibles. las comunicaciones sean síncronas siempre que sean posibles. NS/NC.

En una zona delimitada por “{}”,. las variables son de tipo global y pueden ser llamadas desde otras subrutinas. las variables definidas ahí quedan limitadas a esa región. Ninguna de las opciones es correcta. No sabe/no contesta.

¿Cuál es la forma correcta de redirigir stdout y stderr al mismo archivo?. NS/NC. command 2> filename. command > filename. command > filename 2>&1. command | filename.

La sobrecarga debida al paralelismo limita. la eficiencia de los algoritmos paralelos. la posible paralelización de los algoritmos. la ejecución de los algoritmos en arquitecturas con muchos cores. NS/NC.

¿Qué imprime el programa?. No sabe / No contesta. AUAN 19. AARA 21. AUAN 20. SARA 20.

En las operaciones en C el uso del paréntesis. No sabe/no contesta. está permitido sólo si los tipos de datos con los que trabajamos son dinámicos. no está permitido ya que cada operación debe ejecutarse en una línea distinta. está permitido y sirve para priorizar las operaciones de dentro de los paréntesis hacia afuera.

Los arrays estáticos en C. No se pueden asignar unos a otros. Ambas opciones son correctas. No se pueden redimensionar. No sabe/ no contesta.

¿Qué comando puede evitar que otros usuarios que no están en su grupo escriban en input.dat?. chmod u-w input.dat. chmod o-w input.dat. chmod g-w input.dat. NS/NC.

Suponiendo que se ha dado la orden de compilación gcc prog.c, indicar qué imprime el programa cuando se ejecuta la orden: ./a.out lunes_ martes_ miercoles_. No sabe / No contesta. lunes_martes_miercoles. martes_miercoles. lunes_martes_miercoles_miercoles. a. out lunes_martes_miercoles_miercoles_.

En un programa de nombre prog con argumentos en línea de órdenes, al ejecutar la orden $ ./prog lunes martes la instrucción: printf("%s", argv[1]); imprime lunes. No sabe / No contesta. printf("%c", argv[1][1]); imprime u. Todas las instrucciones anteriores son correctas. Todas las instrucciones anteriores son falsas. printf("%c", argv[2][0]); imprime m.

Dado el programa cuyo ejecutable se llamará p: Al ejecutarlo con ./p azul verde imprime: Escribimos en AZUL Escribimos en VERDE. No sabe / No contesta. Al ejecutarlo con ./p verde rojo imprime: Escribimos en VERDE. Al ejecutarlo con ./p verde rojo imprime: Escribimos en VERDE Escribimos en ROJO. E. Al ejecutarlo con ./p azul imprime: No seas aburrido, introduce argumentos.

Si quisiéramos imprimir el primer elemento del array de enteros int array2D[2][2] ={{1,2},{3,4}}; se haría de la siguiente manera: printf (“primer valor del array =%d”, array2D[0][0] );. No sabe/no contesta. printf (“primer valor del array =%d”, array2D[0]);. printf (“primer valor del array =%d”, array2D[1][1] );.

En C, las funciones: Pueden recibir parámetros y devolver resultados. Son trozos delimitados de código y etiquetados (con nombre) que realizan operaciones concretas. Ambas opciones son correctas. No sabe/ no contesta.

Encuentra el error, si lo hay, en el código. No sabe / No contesta. B. int * numero; en la declaración de tipo de la variable numero. *numero, en el scanf(). &numero, en el scanf(). No hay ningún error.

Suponiendo que el programa ejecutable que se obtiene al compilar programa se llama PROG. al dar la orden PROG examen 5 imprime c=0. al dar la orden PROG examen 5 imprime c=2. al dar la orden PROG examen 5 imprime c=5. al dar la orden PROG 5 examen imprime c=1. No sabe / No contesta.

Con la siguiente declaración: int x[ ]={3,2,8,7,5}, *p; *p=x; ¿Cuál de las respuesta es INCORRECTA?. La instrucción printf("%d", *p++); imprime 3. La instrucción printf("%d", *x+3); imprime 6. La instrucción printf("%d", (*x)++); imprime 3. La instrucción printf("%d", *(x+3)); imprime 7. No sabe / No contesta.

¿Cómo se define una variable de entorno VARTEST y se le asigna el valor 42?. env VARTEST=42. export VARTEST=42. VARTEST=42. NS/NC.

La función malloc() permite: inicializar arrays estáticos que hemos definido previamente y que queremos que apunten a null. No sabe/ no contesta. liberar un bloque de memoria que hemos pedido previamente y que no queremos volver a utilizar. pedir un bloque de memoria contiguo cuando estamos declarando arrays/matrices de forma dinámica.

La función free() permite: liberar un bloque pedido en memoria. devolver un puntero a los primeros valores de Heap para que esa memoria quede reservada. redimensionar un bloque de memoria. No sabe/no contesta.

Una forma de declarar un array utilizando memoria contigua sería: ambas opciones son correctas. int *array = malloc (sizeof (int)*2);. int *array = calloc ((size_t)2, sizeof (int));. No sabe/ no contesta.

¿Que es el estándar POSIX?. Una distribución UNIX que tuvo que cambiar de nombre debido a reclamaciones legales. Un estándar que describe interfaces que todas las variantes complicadas de UNIX necesitan implementar. Una propuesta para un nuevo sistema operativo que suceda a UNIX. NS/NC.

El hecho de que C sea un lenguaje de tipado estático, significa que en nuestros programas debemos: No sabe/no contesta. Convertir cada variable al tipo específico “int” antes de poder operar con punteros. Definir de un tipo cada variable antes de poder utilizarla. Realizar la asignación de tipos en tiempo de ejecución.

¿Cual de las siguientes afirmaciones sobre OpenMP es incorrecta?. OpenMP es una API que permite paralelismo multi-hebra explícito. OpenMP se ha diseñado para sistemas paralelos de memoria distribuida y garantiza el uso eficiente de la memoria. NS/NC. OpenMP soporta arquitecturas UMA y NUMA. Los componentes principales de OpenMP son directivas, librerias run-time y variables de entorno.

Cuando se declara una variable de tipo global, esto significa que: No sabe/no contesta. Puede ser accedida desde cualquier parte del programa. Puede ser accedida desde cualquier parte del programa siempre y cuando sea de tipo dinámico. Solo puede accederse desde el trozo de código que hay programado inmediatamente después.

¿Cuál es el flag que se pasa al compilar un programa PThread usando gcc?. -gccpthread. -lpthread. NS/NC. -pthread.

¿Qué significa GNU?. Geek necesitaba Unix. Unix general. GNU no es Unix. NS/NC. Ninguna de las anteriores.

Los programas realizados en OpenMP y PThreads no pueden correr. NS/NC. En una arquitectura de memoria distribuida, por ejemplo en varios nodos de un cluster de computadores. En una arquitectura de memoria compartida, como un PC. En una arquitectura NUMA (Non Memory Uniform Access) donde los procesadores pueden acceder a las memorias de otros procesadores.

En C es recomendable. No inicializar nunca las variables, ya que siempre contienen el valor “null” al principio del programa. Inicializar las variables antes de utilizarlas. No sabe/no contesta. Inicializar solamente las constantes.

¿Cual de estas opciones es la correcta para establecer el número de hebras disponibles en un programa OpenMP a 4?. En el programa OpenMP, hay que usar omp_max_num_threads(4) para establecer el número de hebras a 4 al principio de la función main. En el programa OpenMP, hay que usar omp_get_num_threads(4) para establecer el número de hebras a 4 al principio de la función main. NS/NC. En el programa OpenMP, hay que usar num_threads(4) para establecer el número de hebras a 4 al principio de la función main. En el bash, export OMP_NUM_THREADS=4.

¿Qué teclas se pueden utilizar para acceder al historial de comandos?. teclas de avance y retroceso de página. teclas de flecha hacia arriba y hacia abajo. NS/NC. n (next) y p (previous).

¿Qué sucede si las teclas de control y c (Ctrl + C) se presionan simultáneamente en la línea de comando?. un script comienza a ejecutarse en el shell. NS/NC. el comando actual se cancela. el texto resaltado se copia al portapapeles.

La ganancia de velocidad observada o speed-up es: A. NS/NC. El tiempo total del programa paralelo dividido el tiempo total del programa serie. El tiempo de CPU del programa secuencial dividido el tiempo de CPU del programa paralelo. El tiempo total del mejor programa serie dividido el tiempo total del programa paralelo.

El código siguiente resulta en condición de carrera cuando se ejecuta con más de una hebra #pragma omp parallel for for (i=1; i < 10; i++){ factorial[i] = i * factorial[i-1]; }. Falso. NS/NC. No si el número de hebras es 10. Verdadero.

Una hebra. Puede crear otras hebras. No puede crear otras hebras si el número de hebras ya es igual al número de cores. No puede crear otras hebras, solo lo puede hacer el proceso main. NS/NC.

Si una variable se pone en la cláusula private dentro de una construcción OpenMP, se crea una copia independiente de la misma variable para cada hebra. Verdadero. Falso. Solo si la variable no es definida como const. NS/NC.

Una hebra termina su ejecución de forma normal con el comando. NS/NC. pthread _exit(). pthread_cancel(). exit().

Un algoritmo paralelo es escalable cuando. el speed-up se incrementa de forma proporcional al añadir nuevos recursos computacionales y trabajar con más datos. Cuando no consume la memoria del sistema. Cuando se puede ejecutar en cualquier número de cores. NC/NC.

Todas las variables en la clausula shared de una construcción OpenMP son compartidas por todas las hebras (menos los contadores de los bucles). No, los contadores de los bucles hay que declararlos como private. Verdadero. NS/NC. Falso.

Cuando de compila un programa OpenMP con gcc, ¿Qué flag debe incluirse?. ./openmp. -fopenmp. #pragma omp parallel. NS/NC.

¿Cual es el problema del siguiente código? #include <stdio.h> #include <stdlib.h> #include <pthread.h> //---------------------------------- void *functionC(void * param) { int * pcounter; pcounter=(int *) param; (*pcounter)++; printf("Counter value: %d\n", *pcounter); } //----------------------------------- int main() { pthread_t thread1, thread2; int counter=0; pthread_create( &thread1, NULL, functionC, (void *)&counter ); pthread_create( &thread2, NULL, functionC, (void *)&counter ); pthread_join( thread1, NULL); pthread_join( thread2, NULL); exit(0); }. No hay ningún problema. La salida sería: Counter value: 1 Counter value: 2. NS/NC. Las hebras pueden acceder a la vez a actualizar el counter y habría que haber usado un mutex. Los printf pueden aparecer desodenados por lo que la salida podría ser: Counter value: 2 Counter value: 1.

Cual es la salida del siguiente código cuando se ejecuta con la variable de entorno OMP_NUM_THREADS=4 int main(..) { static int arr[4] = {1,2,3,4} ; int x=1, j ; #pragma omp parallel for reduction(*:x) for (j=0 ; j<4 ; j++) x *= arr[j] ; printf( “%d”, x ) ; return 0; }. NS/NC. 24. 10. 4. 0.

El programa, ¿qué imprime por pantalla?. No sabe / No contesta. a=31, b=21. a=30, b=20. a=31, b=51. a=30, b=50.

La clausula collapse(2) en el siguiente código hace que: #pragma omp paralell for collapse(2) for (int i=0;i<N; i++) for (int j=0;j<M;j++) A[i][j]=CalculaA(....);. Que se paralelice solo el bucle j. que la matriz A se vea como un vector. NS/NC. Que se paralelicen los dos bucles, para i y para j.

En el siguiente código: #include <stdio.h> #include <pthread.h> #define NUM_THREADS 4 pthread_once_t once_control = PTHREAD_ONCE_INIT; //----------------------------------------------------------------------------- void inicializacion(){ printf("Tarea a ejecutar\n"); } //----------------------------------------------------------------------------- void* cuerpo(void* arg){ pthread_once(&once_control, inicializacion); printf("Función normal\n"); return 0; } //----------------------------------------------------------------------------- int main(int argc, char* argv[]) { pthread_t thread[NUM_THREADS]; for (int i = 0; i<NUM_THREADS; i++) pthread_create(&thread[i], NULL, cuerpo, NULL); for (int i = 0; i<NUM_THREADS; i++) pthread_join(thread[i], NULL); return 0; }. Ninguna de las anteriores. "Tarea a ejecutar" se imprime NUM_THREADS veces. "Tarea a ejecutar" se imprime solo una vez. NS/NC.

Con las siguientes declaraciones, indique cual de las instrucciones es INCORRECTA: struct ficha{ char nom[40]; int edad; }; struct ficha *pun=NULL;. pun=(struct ficha *)malloc(sizeof(struct ficha *));. No sabe / No contesta. pun=(struct ficha *)malloc(4*sizeof(struct ficha));. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. pun=(struct ficha *)realloc(pun,5*sizeof(struct ficha));.

¿Cuál es el problema del siguiente código? #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NUM_THREADS 2 //----------------------------------------------------------------------------- void *PrintHello(void *threadid) { long tid; tid = (long)threadid; printf("Hello World! It's me, thread #%ld!\n", tid); pthread_exit(NULL); } //----------------------------------------------------------------------------- int main (int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; long t; for (t=0; t<NUM_THREADS; t++) pthread_create(&threads[t], NULL, PrintHello, (void *)t); pthread_exit(NULL); }. No hay problema la salida es: Hello World! It's me, thread #1! Hello World! It's me, thread #2!. Que en la creación de las hebras se pasa el número de hebra que es un entero como un puntero a void. Que da error de compilación porque t no se puede convertir a (void *). NS/NC.

En una distribución de datos 2D del tipo "BLOCK,*". NS/NC. A cada tarea le tocan un número de filas consecutivas. A cada tarea le puede tocar elementos no contiguos del array 2D. A cada tarea le corresponde un número de columnas consecutivas.

La hebra que llega a un pthread_mutex_lock(). Solo continua si el mutex no está bloqueado. NS/NC. Si el mutex está bloqueado, sigue la ejecución por la instrucción siguiente pthread_mutex_unlock(). Ninguna de las anteriores.

En una clausula schedule(guided,chunk). NS/NC. El tamaño del chunk se reduce de manera exponencial conforme se asignan porciones a las hebras. El chunk determina la porción más pequeña posible. Las iteraciones de dividen en porciones de tamaño chunk. Cuando una hebra termina su porción, obtiene la siguiente porción sin computar. El chunk por defecto es 1. Hace que las iteraciones del bucle se dividan en porciones entre las hebras con un número de iteraciones especificado en chunk. Las porciones se asignan estáticamente a las hebras siguiendo una estrategia round-robin. Por defecto el chunk es el resultado de dividir el número de iteraciones a paralelizar entre el número de hebras.

Cuando se usa pthread_cond_wait(). Antes hay que bloquear el mutex asociado. No se requieren mutex adicionales. NS/NC. Ninguna de las anteriores.

La sobrecarga debida al paralelismo limita. NS/NC. la ejecución de los algoritmos en arquitecturas con muchos cores. la posible paralelización de los algoritmos. la eficiencia de los algoritmos paralelos.

Cuando varias hebras están esperando en un pthread_cond_wait(). Si el main u otra hebra hace un pthread_cond_signal(), solo una hebra sale del wait(). Para que salgan todas habría que hacer un signal por cada wait o un pthread_cond_broadcast(). NS/NC. Ninguna de las anteriores. Si el main u otra hebra hace un pthread_cond_signal(), todas las hebras salen del wait.

Al ejecutar el programa. Si se introduce 0 seguido de <intro> se sale del programa 0. Si se introduce 1 2 3 4 0 seguido de <intro> imprime 4. No sabe / No contesta. Si se introduce 4 seguido de <intro> imprime nada 4. Si se introduce 57437436763746 seguido de <intro> imprime.

Si el main está esperando en una variable de condición en un bucle y dos hebras hacen un signal antes del siguiente wait. El main se bloquea hasta que todas has hebras hayan hecho un signal. El main saldrá solo de un wait aunqnue se hayan realizado dos signal. El main saldrá de dos wait, uno en cada iteración del bucle, porque se han hecho dos signals. NS/NC.

¿Qué significa PID?. identificador de proceso. Identificador de paquete. Identificación de protocolo. NS/NC.

¿Cual es la condición de carrera en el siguiente código? sum = 0; #pragma omp parallel for for (int i=1; i<N; i++){ sum = sum + b[i]; } /* end of omp parallel for */. No hay condición de carrera. La variable sum es por defecto compartida. Que la variable b es compartida. NS/NC.

Encuentra el error, si lo hay, en el código. int * numero; en la declaración de tipo de la variable numero. *numero, en el scanf(). No sabe / No contesta. No hay ningún error. &numero, en el scanf().

Suponiendo que el programa ejecutable que se obtiene al compilar programa se llama PROG. al dar la orden PROG examen 5 imprime c=2. al dar la orden PROG examen 5 imprime c=5. al dar la orden PROG 5 examen imprime c=1. No sabe / No contesta. al dar la orden PROG examen 5 imprime c=0.

¿Sería esta una función válida: int Restar (int, int);?. No sabe/no contesta. No, ya que una función no puede recibir argumentos sin punteros. Sí, es una función que resta dos enteros. No, ya que no se sabe cuál es el tipo del resultado de la operación.

En un array en C, por ejemplo, double array[5]; ¿Cómo se accede al último elemento del array?. array[];. array[5];. array[4];. No sabe/no contesta.

¿Cuál de las siguientes afirmaciones sobre OpenMP es incorrecta?. OpenMP se ha diseñado para sistemas paralelos de memoria distribuida. OpenMP es una API que permite paralelismo multi-hebra (multi-hilo) explícito. Los componentes son directivas, librerías y variables de entorno. OpenMP soporta arquitecturas UMA y NUMA.

Si una variable se pone en la cláusula private, se crea una copia independiente de la misma variable para cada hebra (hilo). Verdadero. Falso.

Todas las variables en la cláusula shared son compartidas por todas las hebras (menos los contadores de los bucles). Verdadero. Falso.

Cuando se compila un programa OpenMP con gcc, ¿Qué flag debe incluirse?. ./openmp. #pragma omp parallel. No podemos compilar un programa OpenMP con gcc. -fopenmp.

Cuál es la salida del siguiente código cuando se ejecuta con la variable OMP_NUM_THREADS=4. 0. 4. 10. 24.

La cláusula collaps(2) en el siguiente código hace que: Que la matriz A se vea como un vector. Que se paralelicen los dos bucles, para i y para j. Que se paralelice solo el bucle j.

La cláusula Schedule(static,chunk): Las iteraciones se dividen en “chunk” porciones entre las hebras. El tamaño del chunk se reduce conforme se asignan porciones. Se asignan chunk porciones a los hilos que van quedando libres.

En la cláusula schedule(dynamic,chunk): Asigna porciones a las hebras más rápidas y evita utilizar las más lentas. El tamaño del chunk se reduce de manera exponencial conforme se avanza. Cuando una hebra termina su porción obtiene la siguiente sin computar.

En la cláusula schedule(guided,chunk): Se asignan estáticamente las porciones. El tamaño del chunk se va reduciendo conforme se asignan porciones. El compilador toma la decisión de asignar estática o dinámicamente.

¿Cuál de los siguientes errores de programación paralela es imposible en la directiva OpenMP dada?. Conflicto de datos en #pragma omp critical. Dependencia de datos en #pragma omp for. Condiciones de carrera en #pragma omp parallel. Interbloqueo en #pragma omp parallel.

¿Qué hace la cláusula nowait?. Quita la barrera de sincronización en la siguiente construcción OpenMP. Salta la siguiente construcción OpenMP. Prioriza la siguiente construcción OpenMp. Quita la barrera de sincronización en la construcción OpenMP actual.

¿Cuál de las siguientes directivas OpenMP se usa incorrectamente?. #pragma omp for nowait. #pragma omp atomic(threadID). #pragma omp parallel private(threadID). #pragma omp parallel for if (val).

¿Cuál de estas opciones es la correcta para establecer el número de hebras disponibles en un programa OpenMP a 4?. En el programa OpenMP, hay que usar omp_get_num_threads(4). En el programa OpenMP, hay que usar num_threads(4). En el bash, export OMP_NUM_THREADS=4. En el programa OpenMP, hay que usar omp_max_num_threads(4).

Las variables definidas en la cláusula share son compartidas por todas las hebras. Verdadero. Falso. Solo si se declaran const.

La cláusula default establece el shedule por defecto en una construcción OpenMP de bucle. Verdadero. Falso. Solo si además se indica el tamaño del chunk.

El código siguiente resulta en condición de carrera cuando se ejecuta con más de una hebra. Verdadero. Falso. Esto da error en tiempo de ejecución. Esto no funciona porque i tiene que ser mayor que 100.

En la directiva single. Solo permite a la hebra 0 ejecutar el bloque paralelo. La primera hebra que llegue a la directiva ejecutará, ella sola, el bloque. Solo se usa cuando tenemos un solo core.

En la directiva master. La primera hebra que llegue a la directiva ejecutará, ella sola, el bloque. Solo se ejecutará el bloque de código si se ha definido un shedule guiado. Solo la hebra con identificador 0 ejecutará el código.

¿Es el siguiente código eficiente?. No, porque la región crítica se ejecuta 1000/n.threads veces. Si, es la única forma de que las hebras no tengan conflicto. No porque hay condiciones de carrera al actualizar max. Me he perdido profe, me he perdido.

¿Qué significa el false sharing?. Que las variables definidas en la cláusula share() se inicializan a false. Que en ciertas situaciones es necesario actualizar las cachés de cada hebra. Que las hebras comparten variables, pero en realidad es una copia privada.

Indicar qué resultado se produce al ejecutar el programa. 2,a,z. No sabe / No contesta. 2,a,a. valor basura,valor basura,z. valor basura,a,valor basura.

¿Qué se imprime al ejecutar el siguiente programa?. 3 88 6 67 99. No sabe/no contesta. Ninguna de las anteriores. 99 67 6 88 3. 3.

Si el resultado de compilar y enlazar el programa se llama prog, ¿qué imprimirá el siguiente comando? $ ./prog lunes martes. Argumentos: 2 son lunes martes. Argumentos: 3 son prog lunes. No sabe / No contesta. Argumentos: 2 son prog lunes. Argumentos: 3 son lunes martes.

Si el resultado de compilar y enlazar el programa es el ejecutable prog, ¿qué imprimirá el siguiente comando? ./prog lunes martes. lunes lunes martes. lunes lunes lunes. No sabe / No contesta. lunes prog martes. lunes prog lunes.

Encuentra el error, si lo hay, en el código. No sabe / No contesta. *numero, en el scanf(). No hay ningún error. &numero, en el scanf(). int * numero; en la declaración de tipo de la variable numero.

Dadas estas declaraciones: int a[5]={10,20,30,40,50}; int *p, i; *p=a, i=2; ¿Cuáles de las opciones siguientes es correcta?. La orden printf("%d",*p[i]); imprime 30. No sabe / no contesta. La orden printf(" %d", *(a+1)); imprime 10. La orden printf(" %d", *(p+i+1)); imprime 22. La orden printf("%d",*(p+i)); imprime 30.

Queremos que el programa permita intercambiar los dos valores del array a ¿Qué función sería incorrecta?. void fun(int *a){ int aux = *a; *a = *(a+1); *(a+1)=aux; }. void fun(int *x){ int aux = x[0]; x[0] = *(x+1); *(x+1)=aux; }. void fun(int a[ ]){ int aux = a[0]; a[0]=a[1]; a[1]=aux; }. No sabe / No contesta. void fun(int *a){ int aux = *a; *a = *(++a); *(++a)=aux; }.

Suponiendo que se ha dado la orden de compilación gcc prog.c, indicar qué imprime el programa cuando se ejecuta la orden: ./a.out lunes_ martes_ miercoles_. a. outlunes_martes_miercoles_miercoles_. No sabe / No contesta. lunes_martes_miercoles_miercoles. lunes_martes_miercoles. martes_miercoles.

¿Qué imprime programa ?. No sabe / No contesta. 11 11 21. 11 10 20. 11 10 21. 11 11 20.

Con las siguientes declaraciones, indique cual de las instrucciones es INCORRECTA: struct ficha{ char nom[40]; int edad; }; struct ficha *pun=NULL;. pun=(struct ficha *)malloc(4*sizeof(struct ficha));. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. pun=(struct ficha *)realloc(pun,5*sizeof(struct ficha));. No sabe / No contesta. pun=(struct ficha *)malloc(sizeof(struct ficha *));.

¿Cuál puede ser un comodín adecuado para una lista de los archivos: test_01, test_02, test_03 y prod_02 pero NO: test_04 y debug_02. *_0[1-3]. [t,p]*_*. [t,p]???_0[1-3]. *_*. NS/NC.

¿A qué se refiere Linux?. NS/NC. El núcleo del sistema operativo que incluye las herramientas más básicas del sistema. Solo el kernel del sistema operativo. Una instalación completa del sistema operativo con todas las herramientas y aplicaciones de apoyo.

¿Qué es el estándar POSIX?. Una propuesta para un nuevo sistema operativo que suceda a UNIX. NS/NC. Un estándar que describe interfaces que todas las variantes complicadas de UNIX necesitan implementar. Una distribución UNIX que tuvo que cambiar de nombre debido a reclamaciones legales.

¿Quién puede cambiar el propietario o el grupo de cualquier archivo?. el root. todos en este grupo. NS/NC. el dueño de ese archivo.

¿Qué significa GNU?. Ninguna de las anteriores. GNU no es Unix. NS/NC. Geek necesitaba Unix. Unix general.

¿Para qué se usa el comando watch?. Para ejecutar un comando con regularidad y ver su salida. Para ver archivos de video. NS/NC. Para abrir un archivo de formato desconocido.

¿Dónde está almacenada su configuración ssh en Linux?. ~/sshconfig. NS/NC. ~/.config/ssh. ~/.ssh.

¿Cómo es posible definir alias?. alias name='command'. 'command'=alias name. alias 'command'=name. NS/NC.

¿Cuál es la forma correcta de redirigir stdout y stderr al mismo archivo?. command > filename 2>&1. NS/NC. command > filename. command | filename. command 2> filename.

¿Qué comando se puede utilizar para añadir texto un archivo?. comando >>> fichero. NS/NC. comando >> fichero. comando > fichero.

¿Qué pasaría en tiempo de compilación si pongo en mi código C estas dos líneas: int valor = 5; float valor = 25.1;. El compilador me daría un error. Podría compilar con éxito ya que se redefine automáticamente el tipo de dato. No sabe/no contesta.

Cuando ejecuto el programa Multi utilizando dos parámetros de entrada, por ejemplo, escribo en consola: ./Multi 2 20 ¿Qué tendría que escribir en mi programa para coger el número 20?. int parametro2 = atoi (argc[1]);. int parametro2 = atoi (argv[1]);. int parametro2 = atoi (argv[2]);. No sabe/ no contesta.

Si quisiéramos imprimir el primer elemento del array de enteros int array2D[2][2] ={{1,2},{3,4}}; se haría de la siguiente manera: printf (“primer valor del array =%d”, array2D[0][0] );. printf (“primer valor del array =%d”, array2D[0]);. printf (“primer valor del array =%d”, array2D[1][1] );. No sabe/no contesta.

La función free() permite: redimensionar un bloque de memoria. devolver un puntero a los primeros valores de Heap para que esa memoria quede reservada. No sabe/no contesta. liberar un bloque pedido en memoria.

En C es recomendable. Inicializar solamente las constantes. No sabe/no contesta. No inicializar nunca las variables, ya que siempre contienen el valor “null” al principio del programa. Inicializar las variables antes de utilizarlas.

En una zona delimitada por “{}”,. Ninguna de las opciones es correcta. las variables definidas ahí quedan limitadas a esa región. las variables son de tipo global y pueden ser llamadas desde otras subrutinas. No sabe/no contesta.

¿Es posible definir varias variables del mismo tipo en la misma línea?. Sí, si las separamos por comas. No sabe/ no contesta. Sí, pero sólo cuando sean constantes. No.

Los arrays estáticos en C. No se pueden asignar unos a otros. No sabe/ no contesta. Ambas opciones son correctas. No se pueden redimensionar.

Para copiar el contenido de un array en otro en C: Ambas opciones son correctas. se debe hacer a mano o con funciones como memcpy(destino, origen,num_bytes). No sabe/ no contesta. utilizamos el operador “=”.

La extensión de los programas codificados en C es: .cc. .c. No sabe/no contesta. .s.

Muchos de los procesadores actuales se pueden categorizar como SIMD. Si, porque tienen operaciones como las MMX, SSE o AVX que se realizan en registos especializados hardware. Ninguna de las otras opciones. No, solo las GPUs se consideran procesadores vectorizados. NS/NC.

¿cual no es un tipo de sincronización?. NS/NC. Barrera. Uso de variables independientes en cada hebra/proceso. Semaforo/cerrojo.

Una granularidad computacional es fina cuando. Se realiza poco trabajo computacional entre eventos de comunicacion. Se realiza mucho trabajo computacional entre eventos de comunicación. NS/NC. Ninguna de las otras opciones es correcta.

En una distribución de datos 2D del tipo "BLOCK,*". A cada tarea le tocan un número de filas consecutivas. NS/NC. A cada tarea le corresponde un número de columnas consecutivas. A cada tarea le puede tocar elementos no contiguos del array 2D.

Según la ley de Amhdals el máximo speed-up que se puede alcanzar, si el 10% del código del algoritmo es secuencial es: 2. 10. NS/NC. 50%.

Al realizar un algoritmo paralelo que necesita comunicaciones, se prefiere que. las comunicaciones sean sincronas siempre que sean posibles. las comunicaciones sean asincronas siempre que sean posibles. las comunicaciones afectan poco a la eficiencia de los algoritmos paralelos, lo importante es la computación que realizan. NS/NC.

Se dice que un problema es embarazosamente (ideal) paralelo cuando. Se puede descomponer en tareas independientes que no necesitan coordinarse. NS/NC. Cuando alcanza el speed-up lineal. cuando no es escalable.

Un algoritmo paralelo es escalable cuando. Cuando se puede ejecutar en cualquier número de cores. el speed-up se incrementa de forma proporcional al añadir nuevos recursos computacionales y trabajar con más datos. NC/NC. Cuando no consume la memoria del sistema.

Los programas realizados en OpenMP y PThreads no pueden correr. En una arquitectura de memoria compartida, como un PC. En una arquitectura NUMA (Non Memory Uniform Access) donde los procesadores pueden acceder a las memorias de otros procesadores. NS/NC. En una arquitectura de memoria distribuida, por ejemplo en varios nodos de un clúster de computadores.

Según la ley de Amdahls, si un algoritmo tiene el 50% del código secuencial, el máximo speed-up que se puede alcanzar es. NS/NC. 10. 10%. 2.

¿Qué se imprime al ejecutar el siguiente programa?. 99 67 6 88 3. Ninguna de las anteriores. 3 88 6 67 99. No sabe/no contesta. 3.

Con la siguiente declaración: int x[ ]={3,2,8,7,5}, *p; p = (int*) malloc(sizeof(int)); *p=x; ¿Cuál de las respuesta es INCORRECTA?. La instrucción printf("%d", *(x+3)); imprime 7. No sabe / No contesta. La instrucción printf("%d", (*x)++); imprime 3. La instrucción printf("%d", *p++); imprime 3. La instrucción printf("%d", *x+3); imprime 6.

Dadas estas declaraciones: int a[5]={10,20,30,40,50}; int *p, i; *p=a, i=2; ¿Cuáles de las opciones siguientes es correcta?. La orden printf(" %d", *(a+1)); imprime 10. La orden printf(" %d", *(p+i+1)); imprime 22. La orden printf("%d",*(p+i)); imprime 30. La orden printf("%d",*p[i]); imprime 30. No sabe / no contesta.

Con las siguientes declaraciones, indique cual de las instrucciones es INCORRECTA: struct ficha{ char nom[40]; int edad; }; struct ficha *pun=NULL;. pun=(struct ficha *)malloc(sizeof(struct ficha *));. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. No sabe / No contesta. pun=(struct ficha *)realloc(pun,5*sizeof(struct ficha));. pun=(struct ficha *)malloc(4*sizeof(struct ficha));.

Indicar qué resultado se produce al ejecutar el programa. 2,a,a. 2,a,z. valor basura,a,valor basura. No sabe / No contesta. valor basura,valor basura,z.

¿Cual es la diferencia entre concurrencia y paralelismo?. Las tareas concurrentes se ejecutan en el mimo elemento de procesamiento y las paralelas en distintos. Las tareas paraleas se ejecutan en el mismo elemento de procesamiento y las concurrentes en distintos. NS/NC. Ninguna de las otras respuestas.

Los programas desarrollados en MPI pueden correr. NS/NC. Ambas respuestas son correctas. En arquitecturas de memoria compartida. En arquitecturas de memoria distribuida.

Cuando se realiza comunicaciones de datos es mejor tener. NS/NC. alta latencia y gran ancho de banda. baja latencia y gran ancho de banda. alta latencia y bajo ancho de banda.

¿Qué arquitectura es la más rara actualmente?. NS/NC. MIMD. MISD. SISD.

Una granularidad computacional es fina cuando. Ninguna de las otras opciones es correcta. NS/NC. Se realiza poco trabajo computacional entre eventos de comunicacion. Se realiza mucho trabajo computacional entre eventos de comunicación.

¿Cómo agrega el directorio /opt/bin/a la variable de entorno PATH y se asegura de que se busque en último lugar?. export PATH=/opt/bin/:$PATH. NS/NC. export PATH=/opt/bin/. export PATH=$PATH:/opt/bin/.

¿Cómo se llama al administrador de nivel superior (o superusuario) en Linux?. gurú. root. Dios. NS/NC.

¿Cuántos sistemas HPC del Top500 utilizaron alguna forma de Linux en junio de 2020?. 80%. NS/NC. 100%. 90%.

¿Quién puede cambiar el propietario o el grupo de cualquier archivo?. el root. NS/NC. el dueño de ese archivo. todos en este grupo.

¿Qué significa GNU?. Ninguna de las anteriores. Geek necesitaba Unix. GNU no es Unix. Unix general. NS/NC.

¿En cuál de las siguientes opciones se está inicializando correctamente una constante?. No sabe/no contesta. const double(myvar):24;. const double myvar= 24.2;. void const myvar=24;.

Los includes se indican con dobles comillas, es decir, #include “mylibreria.h”, cuando: El archivo a incluir está en donde se realiza la compilación. Ambas opciones son correctas. El archivo a incluir está en la ruta del compilador. No sabe/no contesta.

Si quiero acceder a todos los elementos del array puedo: Crear un bucle for que vaya pasando por todos los elementos del array. No sabe/no contesta. Crear una estructura while que vaya pasando por todos los elementos del array. Ambas opciones son correctas.

En las operaciones en C el uso del paréntesis. está permitido y sirve para priorizar las operaciones de dentro de los paréntesis hacia afuera. está permitido sólo si los tipos de datos con los que trabajamos son dinámicos. no está permitido ya que cada operación debe ejecutarse en una línea distinta. No sabe/no contesta.

Un string es. ninguna de las opciones es correcta. un array de char que termina con el carácter ‘\0’. No sabe/no contesta. una función que sirve para pasar de tipo entero a tipo carácter.

¿Cual es la condición de carrera en el siguiente código? sum = 0; #pragma omp parallel for for (int i=1; i<N; i++){ sum = sum + b[i]; } /* end of omp parallel for */. La variable sum es por defecto compartida. NS/NC. No hay condición de carrera. Que la variable b es compartida.

La clausula schedule(static,chunk). Hace que las iteraciones del bucle se dividan en porciones entre las hebras con un número de iteraciones especificado en chunk. Las porciones se asignan estáticamente a las hebras siguiendo una estrategia round-robin. Por defecto el chunk es el resultado de dividir el número de iteraciones a paralelizar entre el número de hebras. NS/NC. El tamaño del chunk se reduce de manera exponencial conforme se asignan porciones a las hebras. El chunk determina la porción más pequeña. Las iteraciones de dividen en porciones de tamaño chunk. Cuando una hebra termina su porción, obtiene la siguiente porción sin computar. El chunk por defecto es 1.

En el siguiente código: #pragma omp parallel master { <...bloque de código...> }. NS/NC. Solo se ejecutara el bloque de código, si se ha definido un schedule(master-slave, chunck) y se ejecutará por la hebra master. Solo la hebra con identificador 0 ejecutará el bloque de código. No hay sinclonización después del bloque paralelo. La primera hebra que llegue a la directiva ejecutará, ella sola, el bloque de código.

El código siguiente resulta en condición de carrera cuando se ejecuta con más de una hebra #pragma omp parallel for for (i=1; i < 10; i++){ factorial[i] = i * factorial[i-1]; }. NS/NC. Falso. No si el número de hebras es 10. Verdadero.

¿Qué hay que realizar en el siguiente código para que sea correcto? #pragma omp parallel for shared(a,b) for (int i=1; i<N; i++){ x = sqrt(b[i]) -1; a[i] = x*x + 2*x + 1; } /* end of omp parallel for */. Poner la clausula private(x) en la directiva OpenMP. Nada, el código es correcto. NS/NC. Poner la clausula private(a,b) en la directiva OpenMP.

¿Que hace la clausula nowait?. Salta la siguiente construcción OpenMP. Quita la barrera de sincronización en la siguiente construcción OpenMP. Quita la barrera de sincronización en la construcción OpenMP actual. NS/NC. Prioriza la siguiente construcción OpenMP.

¿Que significa el false sharing?. Que varias hebras están acediento a la misma línea de caché y la línea completa tiene que actualizarse en las caches privadas de las hebras cuando una hebra escribe un dato que se encuentra en esa línea de cache, lo que consume mucho tiempo. Que las variables definidas en la clausula share() se inicializan por defecto a false. NS/NC. Que las hebras comparten variables, pero en realidad tienen una copia local privada de las mismas.

Cuando de compila un programa OpenMP con gcc, ¿Qué flag debe incluirse?. NS/NC. #pragma omp parallel. ./openmp. -fopenmp.

Las variables definidas en la clausula share son compartidas por todas las hebras. Falso. Solo si se declaran const. NS/NC. Verdadero.

Todas las variables en la clausula shared de una construcción OpenMP son compartidas por todas las hebras (menos los contadores de los bucles). NS/NC. Falso. Verdadero. No, los contadores de los bucles hay que declararlos como private.

¿Cuál de las siguientes API se puede utilizar para la sincronización entre hebras?. pthread_self. NS/NC. pthread_exit. pthread_join.

Una variable de condición. Evita el uso de mutex. NS/NC. Computacionalmente es más costosa que chequear continuamente el valor de una variable para ver si se cumple la condición, posiblemente en una sección crítica. Evita que las hebras estén chequeando continuamente el valor de una variable para ver si se cumple la condición, posiblemente en una sección crítica.

¿Cual es el problema del siguiente código? #include <stdio.h> #include <stdlib.h> #include <pthread.h> //---------------------------------- void *functionC(void * param) { int * pcounter; pcounter=(int *) param; (*pcounter)++; printf("Counter value: %d\n", *pcounter); } //----------------------------------- int main() { pthread_t thread1, thread2; int counter=0; pthread_create( &thread1, NULL, functionC, (void *)&counter ); pthread_create( &thread2, NULL, functionC, (void *)&counter ); pthread_join( thread1, NULL); pthread_join( thread2, NULL); exit(0); }. No hay ningún problema. La salida sería: Counter value: 1 Counter value: 2. Los printf pueden aparecer desodenados por lo que la salida podría ser: Counter value: 2 Counter value: 1. NS/NC. Las hebras pueden acceder a la vez a actualizar el counter y habría que haber usado un mutex.

Una hebra. NS/NC. Duplica solo los recursos necesarios del proceso padre para poder ser manejada de forma independiente. Al copiar los recursos del proceso padre, su tiempo de creación es igual que el de crear un proceso. Es una copia exacta del proceso padre.

¿Cual es el problema del siguiente código? #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NUM_THREADS 2 //----------------------------------------------------------------------------- void *PrintHello(void *threadid) { long tid; tid = (long)threadid; printf("Hello World! It's me, thread #%ld!\n", tid); pthread_exit(NULL); } //----------------------------------------------------------------------------- int main (int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; long t; for (t=0; t<NUM_THREADS; t++) pthread_create(&threads[t], NULL, PrintHello, (void *)t); pthread_exit(NULL); }. Que da error de compilación porque t no se puede convertir a (void *). No hay problema la salida es: Hello World! It's me, thread #1! Hello World! It's me, thread #2!. Que en la creación de las hebras se pasa el número de hebra que es un entero como un puntero a void. NS/NC.

Cuando varias hebras están esperando en un pthread_cond_wait(). Ninguna de las anteriores. Si el main u otra hebra hace un pthread_cond_signal(), todas las hebras salen del wait. Si el main u otra hebra hace un pthread_cond_signal(), solo una hebra sale del wait(). Para que salgan todas habría que hacer un signal por cada wait o un pthread_cond_broadcast(). NS/NC.

¿Qué archivo de encabezado se debe utilizar para la programación de PThread?. p_thread.h. NS/NC. pthread.h. posix.h. pthreads.h.

Entre los argumentos pasados ​​a la API PThread pthread_create, el argumento final es. NS/NC. Atributos de la hebra. ID de la hebra. Datos que se pasan a la hebra.

Para evitar condiciones de carrera cuando varias hebras modifican un dato compartido a través de un puntero. Las hebras deben esperar en una barrera y después bloquear un mutex antes de actualizar el dato. Las hebras deben bloquear un mutex antes de actualizar el dato y desbloquearlo después. Las hebras deben esperar en una barrera antes de actualizar el dato. NS/NC.

Si el main está esperando en una variable de condición en un bucle y dos hebras hacen un signal antes del siguiente wait. El main saldrá de dos wait, uno en cada iteración del bucle, porque se han hecho dos signals. El main saldrá solo de un wait aunqnue se hayan realizado dos signal. NS/NC. El main se bloquea hasta que todas has hebras hayan hecho un signal.

Indicar qué sentencias hay que sustituir por el comentario para que, al ejecutar el programa imprima el valor de x. printf ("%d",(int *)p);. printf ("%d",&p);. No sabe / No contesta. printf ("%d",*p);. printf ("%d",&x);.

La función. Retorna la posición del mayor elemento del array x. No sabe/ No contesta. Retorna el valor del mayor elemento del array x. Retorna el valor de x[j]. Retorna el valor de x[i].

Con las siguientes declaraciones, indique cual de las instrucciones es INCORRECTA: struct ficha{ char nom[40]; int edad; }; struct ficha *pun=NULL;. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. pun=(struct ficha *)realloc(pun,5*sizeof(struct ficha));. pun=(struct ficha *)malloc(sizeof(struct ficha *));. No sabe / No contesta. pun=(struct ficha *)malloc(4*sizeof(struct ficha));.

Suponiendo que el programa ejecutable que se obtiene al compilar programa se llama PROG. No sabe / No contesta. al dar la orden PROG examen 5 imprime c=5. al dar la orden PROG examen 5 imprime c=2. al dar la orden PROG examen 5 imprime c=0. al dar la orden PROG 5 examen imprime c=1.

Al ejecutar el programa. Si se introduce 0 seguido de <intro> se sale del programa 0. No sabe / No contesta. Si se introduce 57437436763746 seguido de <intro> imprime 5. Si se introduce 1 2 3 4 0 seguido de <intro> imprime 4. Si se introduce 4 seguido de <intro> imprime nada 4.

¿Qué se imprime al ejecutar el siguiente programa?. 3. Ninguna de las anteriores. 99 67 6 88 3. No sabe/no contesta. 3 88 6 67 99.

Queremos que al compilar el programa prog.cse obtenga un fichero ejecutable prog.exe con posibilidad de argumentos en la línea de órdenes, de modo que al ejecutar la orden $ ./prog.exe 1 1 el programa imprima iguales. Indicar qué sentencia NO HARÍA lo que el enunciado indica cuando se sustituye por el comentario en el programa prog.c. if (argv[1]==argv[2]) printf(“iguales");. if ( !strcmp(argv[1], argv[2] ) ) printf (“iguales”);. if (argv[1][0]==argv[2][0]) printf (“iguales”);. No sabe / No contesta. if (*argv[1]==*argv[2]) printf (“iguales”);.

Con la siguiente declaración, ¿cómo podemos saber el número de elementos del array? int array[15]={0};. sizeof(array)*sizeof(int);. sizeof(array);. No sabe / No contesta. strlen(array);. sizeof(array)/sizeof(int);.

¿Qué imprime programa ?. 11 11 21. 11 10 20. 11 10 21. 11 11 20. No sabe / No contesta.

El programa , ¿qué imprime en pantalla?. v1=10,v2=50. v1=10,v2=20. v1=30,v2=20. v1=30,v2=50. No sabe / No contesta.

La ganancia de velocidad observada o speed-up es: El tiempo de CPU del programa secuencial dividido el tiempo de CPU del prama paralelo. NS/NC. El tiempo total del mejor programa serie dividido el tiempo total del programa paralelo. El tiempo total del programa paralelo dividido el tiempo total del programa serie.

La sobrecarga debida al paralelimo limita. la ejecución de los algoritmos en arquitecturas con muchos cores. la eficiencia de los algoritmos paralelos. la posible paralelización de los algoritmos. NS/NC.

Según la ley de Amdahls, si un algoritmo tiene el 50% del código secuencial, el máximo speed-up que se puede alcanzar es. 2. 10%. 10. NS/NC.

Una granularidad computacional es fina cuando. NS/NC. Se realiza poco trabajo computacional entre eventos de comunicacion. Se realiza mucho trabajo computacional entre eventos de comunicación. Ninguna de las otras opciones es correcta.

Cuando un proceso/tarea accede a un dato,. NS/NC. es mejor que esté en L2 que en L1. es mejor que esté en L3 que en L1. es mejor que esté en L1 que en L2.

¿cual no es un tipo de sincronización?. Uso de variables independientes en cada hebra/proceso. Semaforo/cerrojo. NS/NC. Barrera.

Cual es la diferencia entre MPI y OpenMP (PThreads): MPI se basa en procesos con variales independientes en cada proceso y debe comunicarse por mensajes. Mientras que en OpenMP (PThreads) las hebras pueden compartir variables. Los procesos MPI comparten variales y las hebras OPenMP (PThreads) no. Ninguna de las otras opciones. NS/NC.

Los programas realizados en OpenMP y PThreads no pueden correr. NS/NC. En una arquitectura de memoria distribuida, por ejemplo en varios nodos de un cluster de computadores. En una arquitectura NUMA (Non Memory Uniform Access) donde los procesadores pueden acceder a las memorias de otros procesadores. En una arquitectura de memoria compartida, como un PC.

¿Qué arquitectura es la más rara actualmente?. MIMD. SISD. MISD. NS/NC.

Cuando se realiza comunicaciones de datos es mejor tener. baja latencia y gran ancho de banda. alta latencia y gran ancho de banda. alta latencia y bajo ancho de banda. NS/NC.

¿Qué tiene que agregar al encabezado de un script para convertirlo en un script bash ejecutable ?. #!/bin/bash. #BASH. NS/NC. /bin/bash.

¿Quién puede cambiar el propietario o el grupo de cualquier archivo?. el root. todos en este grupo. el dueño de ese archivo. NS/NC.

¿Cuál es la sintaxis correcta para abrir una conexión ssh?. ssh [options] <username>@<hostname>. NS/NC. ssh [options] <username> <hostname>. ssh <username>:<hostname> [options].

Asignar a los comandos su significado correcto. fg/bg : enviando procesos a primer plano / fondo pstree: descripción general de los procesos y subprocesos en ejecución top: administrador de tareas basado en texto. fg/bg : enviando procesos a primer plano / fondo pstree: administrador de tareas basado en texto top: descripción general de los procesos y subprocesos en ejecución. cima : enviando procesos a primer plano / fondo pstree: descripción general de los procesos y subprocesos en ejecución top: administrador de tareas basado en texto. NS/NC.

¿Para qué se usa el comando watch?. Para ver archivos de video. NS/NC. Para abrir un archivo de formato desconocido. Para ejecutar un comando con regularidad y ver su salida.

¿Cuál es la forma correcta de redirigir stdout y stderr al mismo archivo?. command | filename. command 2> filename. NS/NC. command > filename 2>&1. command > filename.

¿Qué significa GNU?. NS/NC. GNU no es Unix. Unix general. Geek necesitaba Unix. Ninguna de las anteriores.

¿Qué teclas se pueden utilizar para acceder al historial de comandos?. teclas de flecha hacia arriba y hacia abajo. NS/NC. n (next) y p (previous). teclas de avance y retroceso de página.

¿Cómo se llama al administrador de nivel superior (o superusuario) en Linux?. NS/NC. Dios. gurú. root.

¿Cuál es el resultado esperado de los siguientes comandos: VARTEST="bla"; export VARTEST="BLA" ; VARTEST="blub"; env | grep VARTEST. VARTEST="". NS/NC. VARTEST="blub". VARTEST="bla".

El hecho de que C sea un lenguaje de tipado estático, significa que en nuestros programas debemos: Convertir cada variable al tipo específico “int” antes de poder operar con punteros. Definir de un tipo cada variable antes de poder utilizarla. No sabe/no contesta. Realizar la asignación de tipos en tiempo de ejecución.

Un string es. No sabe/no contesta. ninguna de las opciones es correcta. una función que sirve para pasar de tipo entero a tipo carácter. un array de char que termina con el carácter ‘\0’.

La función malloc() permite: liberar un bloque de memoria que hemos pedido previamente y que no queremos volver a utilizar. No sabe/ no contesta. inicializar arrays estáticos que hemos definido previamente y que queremos que apunten a null. pedir un bloque de memoria contiguo cuando estamos declarando arrays/matrices de forma dinámica.

Si quisiéramos imprimir el primer elemento del array de enteros int array2D[2][2] ={{1,2},{3,4}}; se haría de la siguiente manera: No sabe/no contesta. printf (“primer valor del array =%d”, array2D[0][0] );. printf (“primer valor del array =%d”, array2D[1][1] );. printf (“primer valor del array =%d”, array2D[0]);.

Para que la función rand() me devuelva números distintos en cada ejecución puedo: llamar a la función srand() justo antes de cada llamada a la función rand(). No sabe/no contesta. llamar una sola vez a la función srand(). llamar a randoms() % RAND_MAX;.

Para copiar el contenido de un array en otro en C: se debe hacer a mano o con funciones como memcpy(destino, origen,num_bytes). utilizamos el operador “=”. Ambas opciones son correctas. No sabe/ no contesta.

La principal diferencia entre las funciones malloc() y calloc() es que: malloc() nos propociona el bloque como esté, sin inicializar; mientras que calloc() lo inicializa a 0. No sabe/ No contesta. con malloc() no se recomienda el uso de la función free(). calloc() nos propociona el bloque como esté, sin inicializar; mientras que malloc() lo inicializa a 0.

La función free() permite: redimensionar un bloque de memoria. devolver un puntero a los primeros valores de Heap para que esa memoria quede reservada. No sabe/no contesta. liberar un bloque pedido en memoria.

Tras compilar, ¿cómo se ejecuta un programa en C?. ./nombredelprograma. execute nombredelprograma. No sabe/no contesta. nombredelprograma.

Siempre que utilicemos la función malloc() es recomendable después liberar la memoria con free(). No sabe/ no contesta. Verdadero. Falso. Ambas opciones son falsas.

¿En cuál de las siguientes opciones se está inicializando correctamente una constante?. void const myvar=24;. const double(myvar):24;. No sabe/no contesta. const double myvar= 24.2;.

¿Cuál de las siguientes formas es la correcta para compilar el programa HolaMundo.c, generando HolaMundo?. gcc HolaMundo. No sabe/no contesta. gcc -o HolaMundo HolaMundo.c. gcc HolaMundo.c HolaMundo.o.

Un string es. ninguna de las opciones es correcta. No sabe/no contesta. un array de char que termina con el carácter ‘\0’. una función que sirve para pasar de tipo entero a tipo carácter.

En las operaciones en C el uso del paréntesis. está permitido y sirve para priorizar las operaciones de dentro de los paréntesis hacia afuera. no está permitido ya que cada operación debe ejecutarse en una línea distinta. está permitido sólo si los tipos de datos con los que trabajamos son dinámicos. No sabe/no contesta.

En una zona delimitada por “{}”,. las variables son de tipo global y pueden ser llamadas desde otras subrutinas. Ninguna de las opciones es correcta. No sabe/no contesta. las variables definidas ahí quedan limitadas a esa región.

Muchos de los procesadores actuales se pueden categorizar como SIMD (Single Instruction Multiple Data). Si, porque tienen operaciones como las MMX, SSE o AVX que se realizan en registos especializados hardware. Ninguna de las otras opciones. No, solo las GPUs se consideran procesadores vectorizados. NS/NC.

Según la ley de Amdahls, si un algoritmo tiene el 50% del código secuencial, el máximo speed-up que se puede alcanzar es. 2. 10. 10%. NS/NC.

¿Cual es la diferencia entre concurrencia y paralelismo?. Las tareas concurrentes se ejecutan en el mimo elemento de procesamiento y las paralelas en distintos. NS/NC. Las tareas paraleas se ejecutan en el mismo elemento de procesamiento y las concurrentes en distintos. Ninguna de las otras respuestas.

La ganancia de velocidad observada o speed-up es: El tiempo total del mejor programa serie dividido el tiempo total del programa paralelo. El tiempo total del programa paralelo dividido el tiempo total del programa serie. NS/NC. El tiempo de CPU del programa secuencial dividido el tiempo de CPU del prama paralelo.

Al realizar un algoritmo paralelo que necesita comunicaciones, se prefiere que. las comunicaciones sean asincronas siempre que sean posibles. NS/NC. las comunicaciones afectan poco a la eficiencia de los algoritmos paralelos, lo importante es la computación que realizan. las comunicaciones sean sincronas siempre que sean posibles.

¿Cuál es el flag que se pasa al compilar un programa PThread usando gcc?. -lpthread. NS/NC. -pthread. -gccpthread.

Para evitar condiciones de carrera cuando varias hebras modifican un dato compartido a través de un puntero. Las hebras deben bloquear un mutex antes de actualizar el dato y desbloquearlo después. Las hebras deben esperar en una barrera antes de actualizar el dato. Las hebras deben esperar en una barrera y después bloquear un mutex antes de actualizar el dato. NS/NC.

Entre los argumentos pasados ​​a la API PThread pthread_create, el argumento final es. Atributos de la hebra. Datos que se pasan a la hebra. NS/NC. ID de la hebra.

Las variables locales de la función que realizan las hebras son. Compartidas por cada hebra y hay que usarlas en exclusión mutua. NS/NC. Las variables definidas en la función de la hebra son globales. Independientes a cada hebra.

¿Cual es el problema del siguiente código? #include <stdio.h> #include <stdlib.h> #include <pthread.h> //---------------------------------- void *functionC(void * param) { int * pcounter; pcounter=(int *) param; (*pcounter)++; printf("Counter value: %d\n", *pcounter); } //----------------------------------- int main() { pthread_t thread1, thread2; int counter=0; pthread_create( &thread1, NULL, functionC, (void *)&counter ); pthread_create( &thread2, NULL, functionC, (void *)&counter ); pthread_join( thread1, NULL); pthread_join( thread2, NULL); exit(0); }. Los printf pueden aparecer desodenados por lo que la salida podría ser: Counter value: 2 Counter value: 1. Las hebras pueden acceder a la vez a actualizar el counter y habría que haber usado un mutex. No hay ningún problema. La salida sería: Counter value: 1 Counter value: 2. NS/NC.

Una variable de condición. Computacionalmente es más costosa que chequear continuamente el valor de una variable para ver si se cumple la condición, posiblemente en una sección crítica. NS/NC. Evita que las hebras estén chequeando continuamente el valor de una variable para ver si se cumple la condición, posiblemente en una sección crítica. Evita el uso de mutex.

Si el main está esperando en una variable de condición en un bucle y dos hebras hacen un signal antes del siguiente wait. El main saldrá solo de un wait aunqnue se hayan realizado dos signal. El main saldrá de dos wait, uno en cada iteración del bucle, porque se han hecho dos signals. NS/NC. El main se bloquea hasta que todas has hebras hayan hecho un signal.

Cuando se usa pthread_cond_wait(). Antes hay que bloquear el mutex asociado. No se requieren mutex adicionales. Ninguna de las anteriores. NS7NC.

¿Qué archivo de encabezado se debe utilizar para la programación de PThread?. NS/NC. pthreads.h. p_thread.h. posix.h. pthread.h.

Cuando varias hebras están esperando en un pthread_cond_wait(). Si el main u otra hebra hace un pthread_cond_signal(), solo una hebra sale del wait(). Para que salgan todas habría que hacer un signal por cada wait o un pthread_cond_broadcast(). NS/NC. Si el main u otra hebra hace un pthread_cond_signal(), todas las hebras salen del wait. Ninguna de las anteriores.

El programa, ¿Qué imprime por pantalla?. a=30, b=20. a=30, b=50. a=31, b=51. No sabe / No contesta. a=31, b=21.

Indicar qué sentencias hay que sustituir por el comentario para que, al ejecutar el programa imprima el valor de x. printf ("%d",&p);. printf ("%d",*p);. printf ("%d",(int *)p);. printf ("%d",&x);. No sabe / No contesta.

Con las siguientes declaraciones, indique cual de las instrucciones es INCORRECTA: struct ficha{ char nom[40]; int edad; }; struct ficha *pun=NULL;. pun=(struct ficha *)malloc(sizeof(struct ficha *));. pun=(struct ficha *)realloc(pun,5*sizeof(struct ficha));. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. pun=(struct ficha *)malloc(4*sizeof(struct ficha));. No sabe / No contesta.

Dadas estas declaraciones: int a[5]={10,20,30,40,50}; int *p, i; *p=a, i=2; ¿Cuáles de las opciones siguientes es correcta?. No sabe / no contesta. La orden printf(" %d", *(a+1)); imprime 10. La orden printf(" %d", *(p+i+1)); imprime 22. La orden printf("%d",*(p+i)); imprime 30. La orden printf("%d",*p[i]); imprime 30.

Suponiendo que el programa ejecutable que se obtiene al compilar programa se llama PROG. al dar la orden PROG examen 5 imprime c=2. al dar la orden PROG 5 examen imprime c=1. al dar la orden PROG examen 5 imprime c=0. al dar la orden PROG examen 5 imprime c=5. No sabe / No contesta.

El código siguiente resulta en condición de carrera cuando se ejecuta con más de una hebra #pragma omp parallel for for (i=1; i < 10; i++){ factorial[i] = i * factorial[i-1]; }. NS/NC. Falso. Verdadero. No si el número de hebras es 10.

¿Que significa el false sharing?. Que varias hebras están acediento a la misma línea de caché y la línea completa tiene que actualizarse en las caches privadas de las hebras cuando una hebra escribe un dato que se encuentra en esa línea de cache, lo que consume mucho tiempo. NS/NC. Que las hebras comparten variables, pero en realidad tienen una copia local privada de las mismas. Que las variables definidas en la clausula share() se inicializan por defecto a false.

Cuando se compila un programa OpenMP con gcc, ¿Qué flag debe incluirse?. NS/NC. #pragma omp parallel. ./openmp. -fopenmp.

¿Cual de las siguientes directivas OpenMP se usa incorrectamente?. #pragma omp parallel for if (val). #pragma omp for nowait. NS/NC. #pragma omp atomic(threadID). #pragma omp parallel private(threadID).

¿Cual de estas opciones es la correcta para establecer el número de hebras disponibles en un programa OpenMP a 4?. En el programa OpenMP, hay que usar omp_max_num_threads(4) para establecer el número de hebras a 4 al principio de la función main. En el programa OpenMP, hay que usar omp_get_num_threads(4) para establecer el número de hebras a 4 al principio de la función main. En el programa OpenMP, hay que usar num_threads(4) para establecer el número de hebras a 4 al principio de la función main. En el bash, export OMP_NUM_THREADS=4. NS/NC.

Las variables definidas en la clausula share son compartidas por todas las hebras. Verdadero. Falso. Solo si se declaran const. NS/NC.

En el siguiente código #pragma omp parallel master { <...bloque de código...> }. Solo la hebra con identificador 0 ejecutará el bloque de código. No hay sinclonización después del bloque paralelo. Solo se ejecutara el bloque de código, si se ha definido un schedule(master-slave, chunck) y se ejecutará por la hebra master. NS/NC. La primera hebra que llegue a la directiva ejecutará, ella sola, el bloque de código.

La clausula schedule(static,chunk). Hace que las iteraciones del bucle se dividan en porciones entre las hebras con un número de iteraciones especificado en chunk. Las porciones se asignan estáticamente a las hebras siguiendo una estrategia round-robin. Por defecto el chunk es el resultado de dividir el número de iteraciones a paralelizar entre el número de hebras. Las iteraciones de dividen en porciones de tamaño chunk. Cuando una hebra termina su porción, obtiene la siguiente porción sin computar. El chunk por defecto es 1. El tamaño del chunk se reduce de manera exponencial conforme se asignan porciones a las hebras. El chunk determina la porción más pequeña. NS/NC.

¿Qué hay que realizar en el siguiente código para que sea correcto? #pragma omp parallel for shared(a,b) for (int i=1; i<N; i++){ x = sqrt(b[i]) -1; a[i] = x*x + 2*x + 1; } /* end of omp parallel for */. Poner la clausula private(a,b) en la directiva OpenMP. Poner la clausula private(x) en la directiva OpenMP. NS/NC. Nada, el código es correcto.

En una clausula schedule(guided,chunk). El tamaño del chunk se reduce de manera exponencial conforme se asignan porciones a las hebras. El chunk determina la porción más pequeña posible. Las iteraciones de dividen en porciones de tamaño chunk. Cuando una hebra termina su porción, obtiene la siguiente porción sin computar. El chunk por defecto es 1. NS/NC. Hace que las iteraciones del bucle se dividan en porciones entre las hebras con un número de iteraciones especificado en chunk. Las porciones se asignan estáticamente a las hebras siguiendo una estrategia round-robin. Por defecto el chunk es el resultado de dividir el número de iteraciones a paralelizar entre el número de hebras.

¿Cuál es el resultado esperado de los siguientes comandos: VARTEST="bla"; export VARTEST="BLA" ; VARTEST="blub"; env | grep VARTEST. VARTEST="bla". VARTEST="blub". VARTEST="". NS/NC.

¿Cuál es el directorio raiz en Linux?. /. /home. C:\. NS/NC.

¿Qué sucede si las teclas de control y c (Ctrl + C) se presionan simultáneamente en la línea de comando?. NS/NC. el comando actual se cancela. un script comienza a ejecutarse en el shell. el texto resaltado se copia al portapapeles.

¿Quién puede cambiar el propietario o el grupo de cualquier archivo?. NS/NC. el root. todos en este grupo. el dueño de ese archivo.

Convencionalmente, ¿con qué carácter comienzan las opciones de un comando en la línea de comandos?. NS/NC. el signo de dólar ($). el signo de guión ( - ). el signo mayor que ( > ).

MPI_Barrier(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para sincronizar los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del buffer de recepción que se encuentran en los procesos dentro de un comunicador.

¿Qué devuelve MPI_COMM_RANK?. El Identificador del proceso Linux. El identificador numérico del proceso actual dentro de un comunicador MPI. La prioridad del proceso actual. El número de procesos en un programa MPI.

Si el proceso 3 manda un mensaje con tag 7 antes que el proceso 2 mande otro mensaje con tag 8, ambos al proceso 5. El proceso 5 puede leer primero el mensaje con tag 8 y luego el mensaje con tag 7. El proceso 3 no puede mandar el mensaje con tag 8 si antes no ha mandado mensajes con tags del 1 al 7. El proceso 5 debe leer primero el mensaje con tag 7 y luego el mensaje con tag 8 ya que MPI garantiza que los mensajes no se adelantan unos a otros.

MPI_Reduce(). Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que aplica una operación de reducción (como la suma) en todos los procesos del comunicador y pone el resultado en un proceso del comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

¿Cuales son los principales riesgos del MPI_Ssend()?. Serialización. Interbloqueo. Todas las opciones.

Marca la rutina que no tiene un comunicador: Todas las respuestas tienen un comunicador. MPI_Send(). MPI_Bcast(). MPI_Init().

Un programa MPI es normalmente del tipo. SISD: Simple Instrucción, Simple Dato. SIMD: Simple Instrucción, Multiple Datos. SPMD: Simple Programa, Multiple Datos.

¿Qué combinación de rutinas MPI entre dos procesos vecinos que tienen que recibir y enviar datos uno del ortro es más eficiente?. MPI_Irecv + MPI_Send. No se sabe ya que MPI es portable pero no su eficiencia. MPI_Isend + MPI_Irecv.

MPI_Barrier(). Se debe usar solo después de las rutinas de comunicación MPI para asegurarse de que los datos están ya en el bufer de destino. Se debe usar después de cada rutina MPI para asegurarse de que los datos están ya en el bufer de destino. Normalmente no se necesita y se usa solo para debugging o profiling.

¿Cual de estas rutinas se bloquea hasta que se haya recibido o enviado el mensaje no bloqueante?. MPI_WAIT(). MPI_Test(). MPI_Get_count().

En el comando: MPI_Send(message, 13, MPICHAR, x, 10, MPI_COMM_WORLD); ¿Cuando puede modificarse x sin que se afecte el mensaje que se envía?. Antes de ejecutar la rutina. Cuando la rutina retorna, es decir en los comandos siguientes a este. Cualquiera de las opciones. En cualquier momento.

El parámetro status en el MPI_Recv() sirve para. Saber la fuente y la etiqueta del remitente del mensaje. Para poder realizar después un MPI_Wait() y estar seguro de que se han recibido los datos. Para poder realizar después un MPI_Test() y chequear que se han recibido los datos.

El comando MPI_Finalize(). Termina la ejecución del entorno MPI. Finaliza el programa. Todas las otras opciones son verdaderas.

MPI_Send(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD) envía un mensaje al proceso: tag. 5. 4.

¿Cual es la diferencia entre MPI_Wait() y MPI_Test()?. MPI_Wait() es no bloqueante y MPI_Test() es bloqueante. MPI_Wait() se una con MPI_Recv() y MPI_Test() con MPI_IRecv(). MPI_Wait() es bloqueante y MPI_Test() es no bloqueante.

Las rutinas de comunicación punto-a-punto bloqueantes de envío y recepción. Se pueden recibir o enviar, resp en el otro proceso con rutinas punto-a-punto solo bloqueantes. Se pueden recibir o enviar, resp. en los otros procesos con rutinas colectivas. Se pueden recibir o enviar, resp. en el otro proceso con rutinas punto-a-punto bloqueantes o no bloqueantes.

MPI_Recv(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD, &status) Describe el parámetro tag: Es tipo del método de comunicación. Es un número asignado por el usuario que debe casar en ambos, emisor y receptor. Es el tipo de grupo de procesos. Es el tipo de message en el mensaje de recepción.

¿Qué significa una rutina MPI de paso de mensaje no bloqueante (o asíncrona)?. La rutina retorna cuando se ha completado la transferencia del mensaje. La rutina retorna cuando todas las acciones MPI del proceso local se han realizado, pero la transferencia del mensaje puede no haber sido completada. La rutina retorna inmediatamente, pero la transferencia del mensaje podría no haberse realizado. La rutina bloquea las acciones MPI de otros procesos hasta que se hayan completado las acciones del proceso actual.

La función MPI_Init(). Solo debe ejecurase en el proceso root. Debe llamarse en cada programa MPI antes de usar otras fuciones MPI y solo debe llamarse una sola vez. Se puede ejecutar varias veces en un proceso MPI.

Un proceso MPI tiene que saber el proceso que le envía el mensaje y la etiqueta asociada. Puede recibir de cualquier proceso pero debe saber la etiqueta. No, puede recibir en esa rutina de cualquier proceso y con cualquier etiqueta si usa MPI_ANY_SOURCE y MPI_ANY_TAG. Si, para ponerlos en la correspondiente rutina de recepción.

¿En qué rutinas MPI se usa status o request?. El status se usa para esperar a que se haya realizado la acción y request para saber la fuente del mensaje. Status se usa en las rutinas de recepción bloquantes y request en las no bloqueantes ya sean de emisión o recepción. Request se usa en las rutinas de recepción bloquantes y status en las no bloqueantes ya sean de emisión o recepción.

¿Qué debe cumplir una comunicación colectiva?. La rutina colectiva usa el mismo tag en todos los procesos. La rutina colectiva debe recibirse con una rutina punto-a-punto en cada proceso. Todos los procesos deben llamar a la rutina colectiva.

¿Cual de los siguientes datos no es requerido en una llamada de paso de mensaje?. El tamaño de los datos del mensaje en número de bytes. El tipo de mensaje. La dirección de comienzo de los datos del mensaje. El número de elementos de datos en el mensaje.

El parámetro request en las rutinas de comunicación no bloqueantes sirve: Para conocer el emisor y el tag del mensaje. Para poder saber si el envío del mensaje se ha completado al usarlo como parámetro en un MPI_Wait o MPI_Test. Para establecer la etiqueta usada en el mensaje y poder seleccionar el mensaje a leer por esa etiqueta.

El comando MPI_Get_count() sirve para. Saber la fuente, la etiqueta y el número de elementos del tipo de datos recibido antes de leerlos. Para saber cuantos mensajes están pendientes de lectura. Para saber el número de byes recibidos en el mensaje antes de leerlo.

El comando: $ mpirun -np 4 xterm -hold -e MPI_hello. Ejecuta 4 terminales xterm en los cuales se ejecuta un proceso MPI_hello. Los terminales se mantendrán visibles y el usuario debe cerrarlos. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen desordenadas en el mismo terminal. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen ordenadas en el mismo terminal.

MPI_Isend(). Es necesario hacer un MPI_Probe() en el mismo proceso que hizo el MPI_Isend para ver si se ha completado el envío. El programa no continúa su ejecución hasta que se jaya completado el envío. El programa continua sin esperar que se haya completado el envío.

Si rank en el siguiente código es el rango del proceso actual y size es el número de procesos MPI en el comunicador, que sentencia es verdadera: for (i=0; i < size; i++) { if (rank == i) { printf("Hello from rank %d\n", rank); j = 10*i; } }. El bucle asegura que todas las operaciones se ejecutan en orden: rank 0 primero, rank 1 después,... El bucle asegura que todas las operaciones se realizan en paralelo en todos los procesos. El valor final de j es 10*(size-1) en todos los procesos. El valor final de j es 10*rank en el proceso rank.

MPI_Probe() se utiliza. Para bloquearse hasta que haya llegado un mensaje del que no se sabe el emisor ni la etiqueta. Para ver si ha llegado un mensaje del que no se sabe el emisor ni la etiqueta, sin bloquearse. Para recibir solo los mensajes que se han enviado con MPI_Isend().

El comando MPI_Get_processor_name(). Devuelve el hostname del PC donde se ejecuta el programa MPI. Devuelve el tipo de procesador, por ejemplo Intel i7-4770K. Ninguna de las opciones.

MPI_Iprobe(). Se bloquea si el mensaje que se espera no ha llegado. Se utiliza para saber si ha llegado un mensaje con cualquier fuente y tag, o con fuente y tag especificados. El proceso que lo ejecuta no se bloquea si no ha llegado el mensaje. Solo puede chequear si ha llegado un mensaje de una fuente y tag especificados.

MPI_Bcast(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador.

¿Cuál de la siguientes sentencias es incorrecta sobre MPI?. MPI usa un modelo de programación basado en memoria compartida, lo que significa que todos los procesos pueden acceder a la memoria compartida. Cualquier proceso MPI puede enviar y recibir mensajes directamente desde y hacia otro proceso. Las funciones MPI son estandarizadas, lo que significa que se comportan igual independientemente de la implementación MPI usada. Puedes compilar el código MPI usando cualquier implementación MPI que se ejecute en tu arquitectura.

¿Se puede enviar un vector donde cada elemento es una estructura con distintos tipos de datos en MPI?. No, solo si la estructura tiene elementos del mismo tipo de datos. Si, si se crea un tipo de dato derivado MPI_Type_struct. No, MPI solo permite el envío de los datos predefinidos en C.

MPI_Gather(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador.

¿Cuando retorna la rutina MPI_Recv()?. Después de que llegue el mensaje que la rutina espera y se han recopilado los datos del mensaje. Después de que llegue el mensaje que la rutina espera, pero antes de que se hayan recopilado los datos del mensaje. Después del tiempo especificado en la rutina.

¿Qué realiza la rutina MPI_Wtime()?. Devuelve el tiempo transcurrido desde un tiempo arbitrario en el pasado. Devuelve el tiempo de ejecución del proceso actual. Espera el tiempo especificado en el parámetro antes de retornar.

MPI_Irecv(). El proceso que lo ejecuta necesita realizar un MPI_Wait() para estar seguro de que se han recibido los datos. Normalmente el siguiente comando es un MPI_Wait(). Se puede usar el bufer de recepción en los siguientes comandos ya que es bloqueante.

El comando MPI_Comm_size(). Siempre devuelve el número de tareas MPI disponibles en la aplicación. Devuelve el número de procesos en el comunicador especificado. Solo funciona con el comunicador MPI_COMM_WORLD.

¿Cual es el nombre del comunicador MPI por defecto?. MPI_COMM_WORLD. COMM_WORLD. DEF_MPI_COMM_WORLD.

$ mpirun -np 4 xterm -hold -e MPI_hello. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen desordenadas en el mismo terminal. Ejecuta 4 terminales xterm en los cuales se ejecuta un proceso MPI_hello. Los terminales se mantendrán visibles y el usuario debe cerrarlos. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen ordenadas en el mismo terminal.

El parámetro status en el MPI_Recv() sirve para. Para poder realizar después un MPI_Wait() y estar seguro de que se han recibido los datos. Saber la fuente y la etiqueta del remitente del mensaje. Para poder realizar después un MPI_Test() y chequear que se han recibido los datos.

Marca la rutina que NO tiene un comunicador: Todas las respuestas tienen un comunicador. MPI_Send(). MPI_Bcast(). MPI_Init().

MPI_Reduce(). Es una rutina colectiva que aplica una operación de reducción (como la suma) en todos los procesos del comunicador y pone el resultado en un proceso del comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

MPI_Send(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD) envía un mensaje al proceso: 4. 5. tag.

¿Cuáles son los tres usos más importantes de las rutinas de comunicación punto-a-punto no bloqueantes MPI? Ordenadas de mayor importancia primero a menor importancia el último. 1) Solapar comunicación y computación. 2) Prevenir interbloqieos 3) Prevenir serializaciones. 1) Prevenir serializaciones 2) Prevenir interbloqieos 3) Solapar comunicación y computación. 1) Prevenir interbloqieos 2) Prevenir serializaciones 3) Solapar comunicación y computación.

MPI_Recv(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD, &status) Describe el parámetro tag: Es un número asignado por el usuario que debe casar en ambos, emisor y receptor. Es tipo del método de comunicación. Es el tipo de message en el mensaje de recepción. Es el tipo de grupo de procesos.

¿Qué debe cumplir una comunicación colectiva?. Todos los procesos deben llamar a la rutina colectiva. La rutina colectiva usa el mismo tag en todos los procesos. La rutina colectiva debe recibirse con una rutina punto-a-punto en cada proceso.

¿Qué realiza la rutina MPI_Wtime()?. Espera el tiempo especificado en el parámetro antes de retornar. Devuelve el tiempo de ejecución del proceso actual. Devuelve el tiempo transcurrido desde un tiempo arbitrario en el pasado.

¿Qué devuelve MPI_COMM_RANK?. El número de procesos en un programa MPI. El identificador numérico del proceso actual dentro de un comunicador MPI. El Identificador del proceso Linux. La prioridad del proceso actual.

Si rank en el siguiente código es el rango del proceso actual y size es el número de procesos MPI en el comunicador, que sentencia es verdadera: for (i=0; i < size; i++) { if (rank == i) { printf("Hello from rank %d\n", rank); j = 10*i; } }. El bucle asegura que todas las operaciones se ejecutan en orden: rank 0 primero, rank 1 después,... El valor final de j es 10*(size-1) en todos los procesos. El valor final de j es 10*rank en el proceso rank. El bucle asegura que todas las operaciones se realizan en paralelo en todos los procesos.

MPI_Probe() se utiliza. Para recibir solo los mensajes que se han enviado con MPI_Isend(). Para bloquearse hasta que haya llegado un mensaje del que no se sabe el emisor ni la etiqueta. Para ver si ha llegado un mensaje del que no se sabe el emisor ni la etiqueta, sin bloquearse.

Si el proceso 3 manda un mensaje con tag 7 antes que el proceso 2 mande otro mensaje con tag 8, ambos al proceso 5. El proceso 3 no puede mandar el mensaje con tag 8 si antes no ha mandado mensajes con tags del 1 al 7. El proceso 5 debe leer primero el mensaje con tag 7 y luego el mensaje con tag 8 ya que MPI garantiza que los mensajes no se adelantan unos a otros. El proceso 5 puede leer primero el mensaje con tag 8 y luego el mensaje con tag 7.

MPI_Isend(). El programa no continúa su ejecución hasta que se jaya completado el envío. Es necesario hacer un MPI_Probe() en el mismo proceso que hizo el MPI_Isend para ver si se ha completado el envío. El programa continua sin esperar que se haya completado el envío.

¿Cuál es el significado de una rutina MPI de paso de mensaje bloqueante?. La rutina bloquea todas las acciones MPI en los otros procesos hasta que se hayan completado sus acciones. La rutina retorna cuando la transmisión del mensaje se ha realizado completamente. La rutina retorna inmediatamente, pero la transmisión del mensaje podría no haberse completado. La rutina retorna cuando todas las acciones MPI locales se han completado, pero la transmisión del mensaje podría no haberse completado.

El comando MPI_Get_count() sirve para. Saber la fuente, la etiqueta y el número de elementos del tipo de datos recibido antes de leerlos. Para saber el número de byes recibidos en el mensaje antes de leerlo. Para saber cuantos mensajes están pendientes de lectura.

¿En qué rutinas MPI se usa status o request?. Request se usa en las rutinas de recepción bloquantes y status en las no bloqueantes ya sean de emisión o recepción. Status se usa en las rutinas de recepción bloquantes y request en las no bloqueantes ya sean de emisión o recepción. El status se usa para esperar a que se haya realizado la acción y request para saber la fuente del mensaje.

Las rutinas de comunicación punto-a-punto bloqueantes de envío y recepción. Se pueden recibir o enviar, resp en el otro proceso con rutinas punto-a-punto solo bloqueantes. Se pueden recibir o enviar, resp. en el otro proceso con rutinas punto-a-punto bloqueantes o no bloqueantes. Se pueden recibir o enviar, resp. en los otros procesos con rutinas colectivas.

MPI_Scatter(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

La función MPI_Init(). Debe llamarse en cada programa MPI antes de usar otras fuciones MPI y solo debe llamarse una sola vez. Solo debe ejecurase en el proceso root. Se puede ejecutar varias veces en un proceso MPI.

MPI_Bcast(). Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

MPI_Irecv(). Se puede usar el bufer de recepción en los siguientes comandos ya que es bloqueante. Normalmente el siguiente comando es un MPI_Wait(). El proceso que lo ejecuta necesita realizar un MPI_Wait() para estar seguro de que se han recibido los datos.

¿Cuál de estas rutinas se bloquea hasta que se haya recibido o enviado el mensaje no bloqueante?. MPI_Get_count(). MPI_Test(). MPI_WAIT().

Un programa MPI es normalmente del tipo. SPMD: Simple Programa, Multiple Datos. SIMD: Simple Instrucción, Multiple Datos. SISD: Simple Instrucción, Simple Dato.

MPI_Gather(). Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador. Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador.

¿Cuál es la diferencia entre MPI_Wait() y MPI_Test()?. MPI_Wait() es no bloqueante y MPI_Test() es bloqueante. MPI_Wait() es bloqueante y MPI_Test() es no bloqueante. MPI_Wait() se una con MPI_Recv() y MPI_Test() con MPI_IRecv().

¿Qué combinación de rutinas MPI entre dos procesos vecinos que tienen que recibir y enviar datos uno del ortro es más eficiente?. MPI_Isend + MPI_Irecv. MPI_Irecv + MPI_Send. No se sabe ya que MPI es portable pero no su eficiencia.

El parámetro request en las rutinas de comunicación no bloqueantes sirve: Para conocer el emisor y el tag del mensaje. Para establecer la etiqueta usada en el mensaje y poder seleccionar el mensaje a leer por esa etiqueta. Para poder saber si el envío del mensaje se ha completado al usarlo como parámetro en un MPI_Wait o MPI_Test.

MPI_Get_processor_name(). Devuelve el tipo de procesador, por ejemplo Intel i7-4770K. Devuelve el hostname del PC donde se ejecuta el programa MPI. Ninguna de las opciones.

¿Cual de la siguientes sentencias es incorrecta sobre MPI?. Puedes compilar el código MPI usando cualquier implementación MPI que se ejecute en tu arquitectura. MPI usa un modelo de programación basado en memoria compartida, lo que significa que todos los procesos pueden acceder a la memoria compartida. Cualquier proceso MPI puede enviar y recibir mensajes directamente desde y hacia otro proceso. Las funciones MPI son estandarizadas, lo que significa que se comportan igual independientemente de la implementación MPI usada.

¿Cuales son los principales riesgos del MPI_Ssend()?. Interbloqueo. Todas las opciones. Serialización.

MPI_Finalize(). Termina la ejecución del entorno MPI. Finaliza el programa. Todas las otras opciones son verdaderas.

¿Cuál de los siguientes datos no es requerido en una llamada de paso de mensaje?. El tamaño de los datos del mensaje en número de bytes. El número de elementos de datos en el mensaje. La dirección de comienzo de los datos del mensaje. El tipo de mensaje.

MPI_Send(message, 13, MPICHAR, x, 10, MPI_COMM_WORLD); ¿Cuándo puede modificarse x sin que se afecte el mensaje que se envía?. En cualquier momento. Cuando la rutina retorna, es decir en los comandos siguientes a este. Antes de ejecutar la rutina. Cualquiera de las opciones.

MPI_Barrier(). Se debe usar después de cada rutina MPI para asegurarse de que los datos están ya en el bufer de destino. Se debe usar solo después de las rutinas de comunicación MPI para asegurarse de que los datos están ya en el bufer de destino. Normalmente no se necesita y se usa solo para debugging o profiling.

MPI_Comm_size(). Solo funciona con el comunicador MPI_COMM_WORLD. Siempre devuelve el número de tareas MPI disponibles en la aplicación. Devuelve el número de procesos en el comunicador especificado.

¿Cuando retorna la rutina MPI_Recv()?. Después de que llegue el mensaje que la rutina espera, pero antes de que se hayan recopilado los datos del mensaje. Después de que llegue el mensaje que la rutina espera y se han recopilado los datos del mensaje. Después del tiempo especificado en la rutina.

¿Qué significa una rutina MPI de paso de mensaje no bloqueante (o asíncrona)?. La rutina bloquea las acciones MPI de otros procesos hasta que se hayan completado las acciones del proceso actual. La rutina retorna cuando se ha completado la transferencia del mensaje. La rutina retorna cuando todas las acciones MPI del proceso local se han realizado, pero la transferencia del mensaje puede no haber sido completada. La rutina retorna inmediatamente, pero la transferencia del mensaje podría no haberse realizado.

MPI_Iprobe(). Se utiliza para saber si ha llegado un mensaje con cualquier fuente y tag, o con fuente y tag especificados. El proceso que lo ejecuta no se bloquea si no ha llegado el mensaje. Solo puede chequear si ha llegado un mensaje de una fuente y tag especificados. Se bloquea si el mensaje que se espera no ha llegado.

¿Se puede enviar un vector donde cada elemento es una estructura con distintos tipos de datos en MPI?. Si, si se crea un tipo de dato derivado MPI_Type_struct. No, solo si la estructura tiene elementos del mismo tipo de datos. No, MPI solo permite el envío de los datos predefinidos en C.

Un programa MPI es normalmente del tipo. SISD: Simple Instrucción, Simple Dato. SPMD: Simple Programa, Multiple Datos. SIMD: Simple Instrucción, Multiple Datos.

Si rank en el siguiente código es el rango del proceso actual y size es el número de procesos MPI en el comunicador, que sentencia es verdadera: for (i=0; i < size; i++) { if (rank == i) { printf("Hello from rank %d\n", rank); j = 10*i; } }. El bucle asegura que todas las operaciones se realizan en paralelo en todos los procesos. El bucle asegura que todas las operaciones se ejecutan en orden: rank 0 primero, rank 1 después,... El valor final de j es 10*(size-1) en todos los procesos. El valor final de j es 10*rank en el proceso rank.

¿Cuál es el nombre del comunicador MPI por defecto?. DEF_MPI_COMM_WORLD. COMM_WORLD. MPI_COMM_WORLD.

MPI_Isend(). El programa continua sin esperar que se haya completado el envío. El programa no continúa su ejecución hasta que se jaya completado el envío. Es necesario hacer un MPI_Probe() en el mismo proceso que hizo el MPI_Isend para ver si se ha completado el envío.

MPI_Send(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD) envía un mensaje al proceso: 4. 5. tag.

¿Qué devuelve MPI_COMM_RANK?. El Identificador del proceso Linux. El número de procesos en un programa MPI. La prioridad del proceso actual. El identificador numérico del proceso actual dentro de un comunicador MPI.

¿Cuál es la diferencia entre MPI_Wait() y MPI_Test()?. MPI_Wait() se una con MPI_Recv() y MPI_Test() con MPI_IRecv(). MPI_Wait() es bloqueante y MPI_Test() es no bloqueante. MPI_Wait() es no bloqueante y MPI_Test() es bloqueante.

El parámetro request en las rutinas de comunicación NO bloqueantes sirve: Para conocer el emisor y el tag del mensaje. Para establecer la etiqueta usada en el mensaje y poder seleccionar el mensaje a leer por esa etiqueta. Para poder saber si el envío del mensaje se ha completado al usarlo como parámetro en un MPI_Wait o MPI_Test.

MPI_Bcast(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

¿Qué significa una rutina MPI de paso de mensaje no bloqueante (o asíncrona)?. La rutina retorna inmediatamente, pero la transferencia del mensaje podría no haberse realizado. La rutina retorna cuando se ha completado la transferencia del mensaje. La rutina retorna cuando todas las acciones MPI del proceso local se han realizado, pero la transferencia del mensaje puede no haber sido completada. La rutina bloquea las acciones MPI de otros procesos hasta que se hayan completado las acciones del proceso actual.

El parámetro status en MPI_Recv() sirve para. Saber la fuente y la etiqueta del remitente del mensaje. Para poder realizar después un MPI_Wait() y estar seguro de que se han recibido los datos. Para poder realizar después un MPI_Test() y chequear que se han recibido los datos.

¿Se puede enviar un vector donde cada elemento es una estructura con distintos tipos de datos en MPI?. No, MPI solo permite el envío de los datos predefinidos en C. Si, si se crea un tipo de dato derivado MPI_Type_struct. No, solo si la estructura tiene elementos del mismo tipo de datos.

MPI_Barrier(). Normalmente no se necesita y se usa solo para debugging o profiling. Se debe usar solo después de las rutinas de comunicación MPI para asegurarse de que los datos están ya en el bufer de destino. Se debe usar después de cada rutina MPI para asegurarse de que los datos están ya en el bufer de destino.

¿Cuál de estas rutinas se bloquea hasta que se haya recibido o enviado el mensaje no bloqueante?. MPI_WAIT(). MPI_Get_count(). MPI_Test().

MPI_Scatter(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador.

¿Cuál de los siguientes datos no es requerido en una llamada de paso de mensaje?. La dirección de comienzo de los datos del mensaje. El número de elementos de datos en el mensaje. El tamaño de los datos del mensaje en número de bytes. El tipo de mensaje.

MPI_Irecv(). Normalmente el siguiente comando es un MPI_Wait(). El proceso que lo ejecuta necesita realizar un MPI_Wait() para estar seguro de que se han recibido los datos. Se puede usar el bufer de recepción en los siguientes comandos ya que es bloqueante.

MPI_Barrier(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del buffer de recepción que se encuentran en los procesos dentro de un comunicador. Es una rutina colectiva que sirve para sincronizar los procesos dentro de un comunicador.

MPI_Gather(). Es una rutina colectiva que sirve para enviar el mismo mensaje desde el proceso root a los demás procesos dentro de un comunicador. Es una rutina colectiva que sirve para dividir los datos del bufer de envío entre los procesos dentro de un comunicador. Es una rutina colectiva que sirve para recoger las partes del bufer de recepción que se encuentran en los procesos dentro de un comunicador.

Marca la rutina que no tiene un comunicador: MPI_Init(). MPI_Send(). MPI_Bcast(). Todas las respuestas tienen un comunicador.

¿En qué rutinas MPI se usa status o se usa request?. El status se usa para esperar a que se haya realizado la acción y request para saber la fuente del mensaje. Status se usa en las rutinas de recepción bloquantes y request en las no bloqueantes ya sean de emisión o recepción. Request se usa en las rutinas de recepción bloquantes y status en las no bloqueantes ya sean de emisión o recepción.

¿Qué hace MPI_Comm_size()?. Solo funciona con el comunicador MPI_COMM_WORLD. Siempre devuelve el número de tareas MPI disponibles en la aplicación. Devuelve el número de procesos en el comunicador especificado.

¿Cuándo retorna la rutina MPI_Recv()?. Después de que llegue el mensaje que la rutina espera y se han recopilado los datos del mensaje. Después del tiempo especificado en la rutina. Después de que llegue el mensaje que la rutina espera, pero antes de que se hayan recopilado los datos del mensaje.

¿Cuáles son los principales riesgos del MPI_Ssend()?. Interbloqueo. Todas las opciones. Serialización.

¿Qué debe cumplir una comunicación colectiva ?. La rutina colectiva usa el mismo tag en todos los procesos. La rutina colectiva debe recibirse con una rutina punto-a-punto en cada proceso. Todos los procesos deben llamar a la rutina colectiva.

¿Qué realiza la rutina MPI_Wtime()?. Devuelve el tiempo de ejecución del proceso actual. Devuelve el tiempo transcurrido desde un tiempo arbitrario en el pasado. Espera el tiempo especificado en el parámetro antes de retornar.

MPI_Recv(message, 4, MPI_CHAR, 5, tag, MPI_COMM_WORLD, &status) Describe el parámetro tag: Es el tipo de message en el mensaje de recepción. Es tipo del método de comunicación. Es un número asignado por el usuario que debe casar en ambos, emisor y receptor. Es el tipo de grupo de procesos.

Un proceso MPI tiene que saber el proceso que le envía el mensaje y la etiqueta asociada. Puede recibir de cualquier proceso pero debe saber la etiqueta. No, puede recibir en esa rutina de cualquier proceso y con cualquier etiqueta si usa MPI_ANY_SOURCE y MPI_ANY_TAG. Si, para ponerlos en la correspondiente rutina de recepción.

¿Cuál es el significado de una rutina MPI de paso de mensaje bloqueante?. La rutina retorna cuando todas las acciones MPI locales se han completado, pero la transmisión del mensaje podría no haberse completado. La rutina bloquea todas las acciones MPI en los otros procesos hasta que se hayan completado sus acciones. La rutina retorna cuando la transmisión del mensaje se ha realizado completamente. La rutina retorna inmediatamente, pero la transmisión del mensaje podría no haberse completado.

El comando MPI_Get_count() sirve para. Para saber el número de byes recibidos en el mensaje antes de leerlo. Para saber cuantos mensajes están pendientes de lectura. Saber la fuente, la etiqueta y el número de elementos del tipo de datos recibido antes de leerlos.

MPI_Probe() se utiliza. Para recibir solo los mensajes que se han enviado con MPI_Isend(). Para ver si ha llegado un mensaje del que no se sabe el emisor ni la etiqueta, sin bloquearse. Para bloquearse hasta que haya llegado un mensaje del que no se sabe el emisor ni la etiqueta.

MPI_Iprobe(). Solo puede chequear si ha llegado un mensaje de una fuente y tag especificados. Se utiliza para saber si ha llegado un mensaje con cualquier fuente y tag, o con fuente y tag especificados. El proceso que lo ejecuta no se bloquea si no ha llegado el mensaje. Se bloquea si el mensaje que se espera no ha llegado.

Las rutinas de comunicación punto-a-punto bloqueantes de envío y recepción. Se pueden recibir o enviar, resp. en el otro proceso con rutinas punto-a-punto bloqueantes o no bloqueantes. Se pueden recibir o enviar, resp. en los otros procesos con rutinas colectivas. Se pueden recibir o enviar, resp en el otro proceso con rutinas punto-a-punto solo bloqueantes.

¿Qué hace MPI_Finalize()?. Termina la ejecución del entorno MPI. Finaliza el programa. Todas las otras opciones son verdaderas.

$ mpirun -np 4 xterm -hold -e MPI_hello. Ejecuta 4 terminales xterm en los cuales se ejecuta un proceso MPI_hello. Los terminales se mantendrán visibles y el usuario debe cerrarlos. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen ordenadas en el mismo terminal. Ejecuta 4 procesos MPI_hello. Las salidas por pantalla de los procesos MPI aparecen desordenadas en el mismo terminal.

¿Qué combinación de rutinas MPI entre dos procesos vecinos que tienen que recibir y enviar datos uno del otro es más eficiente?. MPI_Irecv + MPI_Send. No se sabe ya que MPI es portable pero no su eficiencia. MPI_Isend + MPI_Irecv.

¿Cuál de la siguientes sentencias es incorrecta sobre MPI?. Cualquier proceso MPI puede enviar y recibir mensajes directamente desde y hacia otro proceso. Las funciones MPI son estandarizadas, lo que significa que se comportan igual independientemente de la implementación MPI usada. Puedes compilar el código MPI usando cualquier implementación MPI que se ejecute en tu arquitectura. MPI usa un modelo de programación basado en memoria compartida, lo que significa que todos los procesos pueden acceder a la memoria compartida.

La función MPI_Init(). Se puede ejecutar varias veces en un proceso MPI. Debe llamarse en cada programa MPI antes de usar otras fuciones MPI y solo debe llamarse una sola vez. Solo debe ejecutarse en el proceso root.

MPI_Send(message, 13, MPICHAR, x, 10, MPI_COMM_WORLD); ¿Cuándo puede modificarse x sin que se afecte el mensaje que se envía?. Cualquiera de las opciones. En cualquier momento. Antes de ejecutar la rutina. Cuando la rutina retorna, es decir en los comandos siguientes a este.

Si el proceso 3 manda un mensaje con tag 7 antes que el proceso 2 mande otro mensaje con tag 8, ambos al proceso 5. El proceso 3 no puede mandar el mensaje con tag 8 si antes no ha mandado mensajes con tags del 1 al 7. El proceso 5 puede leer primero el mensaje con tag 8 y luego el mensaje con tag 7. El proceso 5 debe leer primero el mensaje con tag 7 y luego el mensaje con tag 8 ya que MPI garantiza que los mensajes no se adelantan unos a otros.