Curso completo de programación con lenguaje C

#419

Cuando declaras una variable mediante

int a;

el compilador reserva espacio en memoria para almacenar el entero representado por a, pero no le asigna ningún valor, puede haber cualquier cosa ahí dentro. Si utilizas a sin inicializarla (osea, darle algún valor inicial adecuado) y tu programa necesita que su valor cumpla alguna condición, puede liarse parda.

diees una función que nos creamos para terminar el programa (exit(1) termina la ejecución del programa devolviendo 1, lo que indicaría un error) de forma cómoda, mostrando un mensaje.

EOF es lo que te ha dicho #420. Es uno de los posibles valores que puede devolver scanf. Lo almacenamos en rc y nos aseguramos que si rc == EOF, el programa termina, ya que no tiene un valor correcto para continuar.

Me puede echar alguien un cable con esta barrera de sincronización de hilos que estoy haciendo? postee paginas antes sobre una duda de este tema y ya comprendo mas o menos como funciona pero no me sale xDD

Es una barrera que usa un mutex y variable condicional, su funcionamiento es:
Si hay 4 hilos por ejemplo tienen que quedarse todos esperando hasta que llegue el último, entonces quedan sincronizados y el programa puede avanzar. Por eso eso lo que hago es si no eres el ultimo hilo (el contador no es igual al numero de hilos) quedate esperando en la variable cond. y si eres el ultimo despierta a todos y sigue.

El problema obviamente es el de siempre en la programación concurrente xD se me queda bloqueado el programa, y como no entiendo todavia mucho esta forma de programar no se si estoy haciendo alguna gilipollez en el wait.

La estructura de datos es esta:

typedef struct
{
    pthread_mutex_t mutex;  /* Cerrojo de la barrera */
    pthread_cond_t cond;    /* Variable condicional donde se bloquean los hilos */
    int nr_threads_arrived; /* Numero de hilos que han llegado a la barrera */
    int max_threads;        /* Numero de hilos que han de sincronizarse en la barrera */
}sys_barrier_t;

Codigo de la barrerA:

#include "barrier.h"
#include <errno.h>


#ifdef POSIX_BARRIER

/* Wrapper functions to use pthread barriers */

int sys_barrier_init(sys_barrier_t* barrier, unsigned int nthreads) {

return pthread_barrier_init(barrier,NULL,nthreads);
}

int sys_barrier_destroy(sys_barrier_t* barrier) {
    return pthread_barrier_destroy(barrier);
}

int sys_barrier_wait(sys_barrier_t *barrier) {
    return pthread_barrier_wait(barrier);
}

#else


/* Inicializacion de la barrera */
int sys_barrier_init(sys_barrier_t *barrier, unsigned int nr_threads)
{


barrier->nr_threads_arrived=0; //inicializamos la variable a 0
barrier->max_threads = nr_threads; //maximo de hilos de la barrera
pthread_mutex_init(&barrier->mutex, NULL); //iniciar una variable de tipo mutex dentro de nuestra estructura en la barrera
pthread_cond_init(&barrier->cond, NULL); //iniciar la variable condicional


return 0;
}

/* Destruccion de los recursos de la barrera */
int sys_barrier_destroy(sys_barrier_t *barrier)
{
	




   pthread_mutex_destroy(&barrier->mutex); //destruimos mutex
   pthread_cond_destroy(&barrier->cond); //destruimos variable condicional

   return 0;
}

/* Operacion de sincronizacion/espera en la barrera */
int sys_barrier_wait(sys_barrier_t *barrier)
{
    pthread_mutex_lock(&barrier->mutex); //el hilo que llega a la barrera adquiere el  mutex

barrier->nr_threads_arrived++; //incrementa de forma atomica el contador nr_threads_arrived


while (barrier->nr_threads_arrived != barrier->max_threads) {  //Si aun faltan mas hilos por llegar el hilo se bloquea con la V.cond
			pthread_cond_wait(&barrier->cond, &barrier->mutex);        //hilo bloqueado en la varialbe cond a la espera de que llegue el último
		}

if (barrier->nr_threads_arrived == barrier->max_threads){ //Si es el ultimo hilo en llegar...
	    barrier->nr_threads_arrived=0;  //1 resetea el estado de la barrera para la siguiente sys_barrier_wait()
		pthread_cond_broadcast(&barrier->cond); //2 despierta a todos los hilso bloqueados en la V.cond

	}



pthread_mutex_unlock(&barrier->mutex);// Liberar mutex antes de salir de la funcion
return 0;
}

#endif /* POSIX_BARRIER */

Gracias.

pd: joder se me ha descolcado un poco con los comments aunque es bastante poco codigo y lo importantes es el wait, luego si puedo lo pongo mejor sorry.

#425

Pues lo primero que te digo es que si el ejercicicio es de factorial te sobran las sumas ya que por ej factorial(3) = 123 = 6, asi que no se si pides eso pero bueno xD te digo el del factorial ya que es facil y si es otro pues supongo que se resolverá casi igual.

Una definicion rapida y no correcta del todo de factorial seria que es la multiplicacion del numero(n) que quieras por n-1 hasta que llegues a 1 por lo tanto:

n E naturales ( si quieres meter el factorial de 0 tendrias que decir que sea 1 directamente)

por lo tanto planteariamos la función así:
f(n) =
1 si n=0
n * f(n-1) si n > 1;

Pseudocodigo rapido:

factorial (int n)
si (n == 0 ) return 1;
si no n= n * factorial(n-1);

suponiendo n >=0;

escribirlo en codigo es bastante facil.

Edito poniendolo bien del todo que lo que he puesto no esta mal pero es un poco gilipollez hacerlo hasta 1 xD.

Conseguí solucionar el problema de #424 por si a alguien le pasa algo parecido, la solución era en el while despues de que los hilos se queden esperando en la var.cond hacer un unlock del mutex y un return de la función para que salgan.

#429

"Programar una función recursiva en C que proporcione el término de orden n de la serie."

Yo lo que entiendo es que tienes que hacer un programa al que le pidas el número 50 de la serie y te lo de, o el número 100 de la serie, o el que sea. Por ejemplo si le pides el 4º t tiene que dar 8, si lo pides el 6º devolverá 86, etc.