Multiprocesadores módulo 2

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

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 paralelicen los dos bucles, para i y para j. Que se paralelice solo el bucle j. Que la matriz A se vea como un vector.

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

El código siguiente resulta en una 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] }. No si el número de hebras es 10. Falso. Verdadero.

¿Qué significa false sharing?. Que las hebras comparten variables, pero en realidad tienen una copia local privada de las mismas. Que varias hebras están accediendo a la misma línea de caché y esa línea tiene que moverse entre esas hebras lo que consume mucho tiempo. Que las variables definidas en la cláusula share() se incializan por defecto a false.

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

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

La cláusula schedule(static, chunk): Las iteraciones se 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. Chunk determina la porción más pequeña. 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, chunk es una porción de hebra.

Para evitar condiciones de carrera cuando las varias hebras modifican un dato compartido a través de un puntero: 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. Las hebras deben bloquear un mutex antes de actualizar el dato y desbloquearlo después.

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

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

La directiva #pragma omp single{ <.....bloque paralelo.....> }. Solo permite a la hebra 0 ejecutar el bloque paralelo. Solo se usa cuando tenemos un solo core. La primera hebra que llegue a la directiva ejecutará ella sola el bloque paralelo.

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 las hebras hayan hecho un signal. El main saldrá de dos wait uno en cada iteración del bucle, porque se han hecho dos signal. El main saldrá solo de un wait aunque se hayan hecho dos signal.

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

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

Si el main y las NThreads que se han creado tienen que esperar en un barrier, el comando para inicializar el barrier sería... pthread_barrier_init(&barrier, NULL, NThreads+1);. pthread_barrier_init(&barrier,NULL,NThreads);. pthread_barrieri_init(&barrier,NULL,NThreads-1);.

Cuál 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 desordenados 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.

Las hebras... Se ejecutan en un etorno de memroia distribuida y se comunican mediando paso de mensajes. Se ejecutan en un entorno de memoria compartida y se comunican mediante el acceso a esa memoria. Se ejecutan en un entorno de memoria distribuida y se comunican accediendo a esa memoria.

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

Las variables locales de la función que realizan las hebras son... compartidas por cada hebra y hay que usarlas en exclusión mutua. independientes de cada hebra. Las variables definidas en la función de la hebra son globales.

Una variable de condición. Evita el uso de mutex. 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.

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(). Si el main u otra hebra hace un pthread_cond_signal, todas las hebras saldrían 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 pthread_cond:broadcast() por cada wait.

¿Cuá es el flag que se pasa al compilar un programa pthread usando gcc?. -fopenmp. -pthread.

#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; }. "Tarea a ejecutar" se imprime NUM_THREADS veces. "Tarea a ejecutar" se imprime NUM_THREADS/2 veces. "Tarea a ejecutar" se imprime solo una vez. No se imprime "Tarea a ejecutar" hay una condición de carrera.

La hebra que llega a un pthread_mutex_lock(). Si el mutex está bloqueado, sigue la ejecución por la instrucción siguiente pthread_mutex_unlock(). Solo continua si el mutex no está bloqueado. Bloquea el programa si al pasar TIME no se desbloquea.

Entre los argumentos pasados a la API pthread pthread_create, el argumento final es: Datos que se pasan a la hebra. Número de hebras finales. Número de operaciones a realizar.

La salida del siguiente programa es: #include <stdio.h> #include <stdlib.h> #include <pthread.h> typedef struct th_params { pthread_mutex_t * pmutex1; int * pcounter; }Type_Th_Params; //------------------------------------------------------------------ void *functionC(void * param) { Type_Th_Params * MyParams; MyParams=(Type_Th_Params *) param; pthread_mutex_lock( MyParams->pmutex1 ); (*MyParams->pcounter)++; printf("Counter value: %d\n", *MyParams->pcounter); pthread_mutex_unlock( MyParams->pmutex1 ); } //---------------------------------------------------------------------- int main() { pthread_t thread1, thread2; pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; int counter=0; Type_Th_Params Th_Params; Th_Params.pcounter=&counter; Th_Params.pmutex1=&mutex1; pthread_create( &thread1, NULL, functionC, (void *)&Th_Params ); pthread_create( &thread2, NULL, functionC, (void *)&Th_Params ); pthread_join( thread1, NULL); pthread_join( thread2, NULL); exit(0); }. Counter value: 1 Counter value: 2. Counter value:2 Counter value:1. No habría salida, se produce una condición de carrera.

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

Todas las variables en la calusula shared de ua construcción OpenMP son compartidas por todas las hebras (menos los contadores de los bucles). Verdadero. Falso.

Que hay que realizar en el siguiente código para que sea correcto # pragma omp parallel for for (i=1; i<N; i++) { x = sqrt(b[i]) - 1; a[i] = x*x + 2*x + 1; } /* end of omp parallel for */. Poner la cláusula private(x) en la directiva OpenMP. Poner la cláusula share(x) en la directiva OpenMP. Poner la cláusula collapse(2) en la directiva OpenMP.

¿Cuál de las siguientes afirmaciones sobre OpenMP es incorrecta?. OpenMP se ha diseñado para systemas paralelos de memoria distribuida y garantiza el uso eficiente de la memoria. OpenMP es una API que permiett paralelismo multi-hebra explícito. Los componentes son directivas, librerias y variables de entorno. OpenMP soporta arquitecturas UMA y NUMA.

Las variables locales de la función que realizan las hebras son. Independientes a cada hebra. Dependientes a cada hebra.

Una hebra termina su ejecución de forma normal con el comando: Pthread_join(). Pthread_common(). Pthread_exit().

Cuando se compila un programa OpenMP con gcc ¿Qué flag debe incluirse?. -fopenmp. -pthread.

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

Es el siguiente código eficiente max = 0; #pragma omp parallel private(partial_max) { partial_max = 0; #pragma omp for for (i=0; i<10000; i++) { x[i] = ...; if (x[i] > partial_max) partial_max = x[i]; #pragma omp critical if (partial_max > max) max = partial_max; } }. No, porque la región crítica se ejecuta 1000/n.threads veces. La región crítica debería sacarse fuera del for y se ejecutaría solo n.threads veces. Sí, es la única forma de que las hebras no tengan conflicto. No porque hay condiciones de carrera al actualizar max.

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; }. 0. 4. 10. 24.

En la cláusula schedule(dynamic, chunk). Asgina 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. 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.

En una cláusula shcedule(guided, chunk). Se asginan 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.

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

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 una schedule guiado. Solo la hebra con identificador 0 ejecutará el bloque de código.

¿Cual es la diferencia entre concurrencia y paralelismo?. Ninguna de las otras respuestas. 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.

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. Ninguna de las otras opciones. Los procesos MPI comparten variales y las hebras OPenMP (PThreads) no.

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. 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. 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.

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

Dado el array dinámico a de 5 elementos de tipo int, queremos ampliar a 10 su número de elementos, sin perder la información que ya existía almacenada en el array original y rellenando a 0 los nuevos elementos. Suponer que no existirán problemas de falta de memoria. ¿Cuál de las secuencias de instrucciones NO hace lo especificado en el enunciado?. b = (int *)malloc(10*sizeof(int)); for (i=0; i<5; i++) b[i]=a[i]; for (i=5; i<10; i++) b[i]=0; free(a); a=b;. b = (int *)malloc(10*sizeof(int)); for (i=0; i<5; i++) b[i]=a[i]; for (i=5; i<10; i++) b[i]=0; free(a); b=a;. b = (int *)calloc(10, sizeof(int)); for (i=0; i<5; i++) b[i]=a[i]; free(a); a=b;. a = (int *)realloc(a, 10*sizeof(int)); for (i=5; i<10; i++) a[i]=0;.

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

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

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

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

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

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

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.

Cuando vamos a trabajar con números enteros, por defecto utilizamos: el tipo int. el tipo double. el tipo long.

La extensión de los programas codificados en C es: .cc. .c. .s.

¿Qué imprime el programa?. AUAN 20. AARA 21. AUAN 19. SARA 20.

14 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 *)realloc(pun,5*sizeof(struct ficha));. pun=(struct ficha *)malloc(sizeof(struct ficha *));. pun=(struct ficha *)calloc(3,sizeof(struct ficha));. pun=(struct ficha *)malloc(4*sizeof(struct ficha));.

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[0]; a[0]=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; *a = *(++a); *(++a)=aux; }. void fun(int *a){ int aux = *a; *a = *(a+1); *(a+1)=aux; }.

La función malloc() permite: inicializar arrays estáticos que hemos definido previamente y que queremos que apunten a null. 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.

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). Ambas opciones son correctas. utilizamos el operador “=”.

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

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]);.

User ¿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.

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

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

Si se ejecuta el comando cd sin argumentos en el directorio /var/log/, ¿qué espera que suceda?. Nada, se queda /var/log/. Va a la raíz del sistema de archivos. Va al directorio de inicio del usuario.

¿Qué imprime el programa ?. Luis Sanchez, 7.50. [valor basura], [valor basura]. Juan, 9.80. Juan Garcia, 9.80.

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

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]); imprime 30. La orden printf(" %d", *(p+i+1)); imprime 22. La orden printf("%d",*(p+i)); imprime 30.

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

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

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

Para que sirve la función atoi(): Convierte un solo carácter en un entero. Convierte un entero en una cadena. Convierte una cadena en un entero.

La declaración de una función en C podría ser: nombreFunción tipoResultado (void tipoResultado) ;. tipoResultado nombreFunción (tipoParametro par1, … );.

¿Quién puede cambiar los permisos de un archivo?. usuarios en el mismo grupo. el propietario de este archivo. cada usuario.

¿Quién puede cambiar los permisos de un archivo?. usuarios en el mismo grupo. el propietario de este archivo. cada usuario.

Los comentarios en C se indican con: // cuando es una sola línea la que queremos comentar. ambas opciones son correctas. /* y terminando con */ cuando queremos comentar varias líneas.

En las operaciones en C el uso del paréntesis. 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.

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

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

Los programas realizados en OpenMP y PThreads no pueden correr. 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.

Un algoritmo paralelo está muy desbalanceado. Cuando sus tareas/procesos realizan una cantidad de computación muy diferente. cuando sus tareas/procesos realizan casi la misma cantidad de computación. cuando las tareas/procesos del algoritmo realizan una cantidad de comunicaciones muy diferente.

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

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] );.

¿Qué es la función main?. Es una función que se ejecuta al final del programa y contiene la directiva return. Es una función que debemos incluir cuando vayamos a leer argumentos del programa por consola. Es la entrada del programa y por donde empieza la ejecución.

¿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 en la creación de las hebras se pasa el número de hebra que es un entero como un puntero a void. No hay problema la salida es: Hello World! It's me, thread #1! Hello World! It's me, thread #2!. Que da error de compilación porque t no se puede convertir a (void *).

Una hebra. 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. Puede crear otras hebras.

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", (*x)++); imprime 3. La instrucción printf("%d", *(x+3)); imprime 7. La instrucción printf("%d", *x+3); imprime 6. La instrucción printf("%d", *p++); imprime 3.

Los argumentos de las funciones en C se pasan por: Funciones de tipo global. Valor. La directiva #define.