SO Práctica 1

// EJERCICIO 1
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main()
{
    int pip[2], i;
    char linea[1024], *prog1, *prog2, *args1[10], *args2[10];
    for(;;){
        pipe(pip);
        printf("Lo escucho, amo.\n");
        fgets(linea, sizeof linea, stdin);
        linea[strlen(linea)-1] = 0;
        if (strcmp(linea, "fin") == 0)  break;

        prog1 = strtok(linea, "|");
        prog2 = strtok(NULL, "|");
        if(fork()==0){
            close(pip[0]);
            close(1);
            dup(pip[1]);
            close(pip[1]);
            for(i = 0, args1[i] = strtok(prog1, " "); args1[i] != NULL; args1[++i] = strtok(NULL, " "));
            args1[++i] = NULL;
            execvp(args1[0], args1);
            exit(-1);
        }
        wait(NULL);
        if(fork()==0){
            close(0);
            dup(pip[0]);
            close(pip[0]);
            close(pip[1]);
            for(i = 0, args2[i] = strtok(prog2, " "); args2[i] != NULL; args2[++i] = strtok(NULL, " "));
            args2[++i] = NULL;
            execvp(args2[0], args2);
            exit(-1);
        }
        close(pip[0]);
        close(pip[1]);
        wait(NULL);
    }
    return 0;
}




// EJERCICIO 2
#include <stdio.h>
#include <pthread.h>

#define N_VISITANTES 1000000

volatile int visitantes = 0;
pthread_mutex_t bloqueo = PTHREAD_MUTEX_INITIALIZER;

void *molinete(void *arg)
{
    int i;
    for (i=0;i<N_VISITANTES;i++){
        pthread_mutex_lock(&bloqueo);
        visitantes++;
        pthread_mutex_unlock(&bloqueo);
    }
  return NULL;
}

int main()
{
    pthread_t m1, m2;
    pthread_create(&m1, NULL, molinete, NULL);
    pthread_create(&m2, NULL, molinete, NULL);
    pthread_join(m1, NULL);
    pthread_join(m2, NULL);

    printf("Hoy hubo %d visitantes!\n", visitantes);
    return 0;
}


/*
Apartado 1: La instrucción visitantes++ se divide en tres en assembler:
una carga desde memoria, un incremento del valor y un almacenamiento en memoria.
Es difícil conseguir un resultado de 2*N_VISITANTES pues pueden ocurrir
cambios de contexto en algún punto entre dichas instrucciones, por lo que
distintos resultados parciales del ciclo se irán sobreescribiendo entre sí.

Apartado 2: Al ejecutar con un N_VISITANTES bajo (10, por ejemplo), todos
los resultados fueron correctos. Creemos que esto es porque un hilo completa
su ejecución antes de que ocurra un cambio de contexto.

Apartado 3: El mínimo valor que podría imprimir el programa es 2. Teniendo
dos hilos, A y B, las circunstancias serían las siguientes:
- A carga el 0. Cambio de contexto.
- B carga el 0. Cambio de contexto.
- A se ejecuta hasta su penúltima iteración, escribiendo en memoria un N_VISITANTES - 1. Cambio de contexto.
- B aumenta el 0 a un 1 y lo guarda en memoria. Cambio de contexto.
- A carga el 1. Cambio de contexto.
- B completa su ejecución, escribiendo N_VISITANTES en memoria.
- A aumenta el 1 que había cargado y guarda 2 en memoria, completando su ejecución.
*/




// EJERCICIO 3
/*
El deadlock puede ocurrir si todos los procesos toman consecutivamente el tenedor de su derecha. Entonces, todos van a estar esperando a que se libere el tenedor de su izquierda, pero nunca se liberarán ya que ningún hilo puede continuar.
*/



/*
En este caso, dos filósofos competirán por agarrar el mismo tenedor, el que esté entre el comensal diestro y el zurdo. De esta forma, uno de ellos quedará esperando sin tener ningún tenedor en la mano, por lo que quedan cuatro filósofos entre los cuales distribuir los cinco tenedores. Así, se garantiza que al menos uno de ellos puede agarrar ambos tenedores.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

#define N_FILOSOFOS 5
#define ESPERA 5000000

pthread_mutex_t tenedor[N_FILOSOFOS];

void pensar(int i)
{
  printf("Filosofo %d pensando...\n",i);
  usleep(random() % ESPERA);
}

void comer(int i)
{
  printf("Filosofo %d comiendo...\n",i);
  usleep(random() % ESPERA);
}

void tomar_tenedores(int i)
{
  pthread_mutex_lock(&tenedor[i]); /* Toma el tenedor a su derecha */
  pthread_mutex_lock(&tenedor[(i+1)%N_FILOSOFOS]); /* Toma el tenedor a su izquierda */
}

void dejar_tenedores(int i)
{
  pthread_mutex_unlock(&tenedor[i]); /* Deja el tenedor de su derecha */
  pthread_mutex_unlock(&tenedor[(i+1)%N_FILOSOFOS]); /* Deja el tenedor de su izquierda */
}

void tomar_tenedores_zurdo(int i)
{
  pthread_mutex_lock(&tenedor[(i+1)%N_FILOSOFOS]); /* Toma el tenedor a su izquierda */
  pthread_mutex_lock(&tenedor[i]); /* Toma el tenedor a su derecha */
}

void dejar_tenedores_zurdo(int i)
{
  pthread_mutex_unlock(&tenedor[(i+1)%N_FILOSOFOS]); /* Deja el tenedor de su izquierda */
  pthread_mutex_unlock(&tenedor[i]); /* Deja el tenedor de su derecha */
}

void *filosofo(void *arg)
{
  int i = (int)arg;
  for (;;)
  {
    if(i == 0){
      tomar_tenedores_zurdo(i);
      comer(i);
      dejar_tenedores_zurdo(i);
      pensar(i);
    }else{
      tomar_tenedores(i);
      comer(i);
      dejar_tenedores(i);
      pensar(i);
    }
  }
}

int main()
{
  int i;
  pthread_t filo[N_FILOSOFOS];
  for (i=0;i<N_FILOSOFOS;i++)
    pthread_mutex_init(&tenedor[i], NULL);
  for (i=0;i<N_FILOSOFOS;i++)
    pthread_create(&filo[i], NULL, filosofo, (void *)i);
  pthread_join(filo[0], NULL);
  return 0;
}



/*
Si sólo se permite que N-1 filósofos tomen tenedores al mismo tiempo, por Principio del Palomar, uno de ellos puede tomar dos tenedores. De esta forma, se permite que al menos uno de ellos pueda comer en un momento dado, evitando un deadlock.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define N_FILOSOFOS 5
#define ESPERA 5000000

pthread_mutex_t tenedor[N_FILOSOFOS];
sem_t semaforo;

void pensar(int i)
{
  printf("Filosofo %d pensando...\n",i);
  usleep(random() % ESPERA);
}

void comer(int i)
{
  printf("Filosofo %d comiendo...\n",i);
  usleep(random() % ESPERA);
}

void tomar_tenedores(int i)
{
  pthread_mutex_lock(&tenedor[i]); /* Toma el tenedor a su derecha */
  pthread_mutex_lock(&tenedor[(i+1)%N_FILOSOFOS]); /* Toma el tenedor a su izquierda */
}

void dejar_tenedores(int i)
{
  pthread_mutex_unlock(&tenedor[i]); /* Deja el tenedor de su derecha */
  pthread_mutex_unlock(&tenedor[(i+1)%N_FILOSOFOS]); /* Deja el tenedor de su izquierda */
}

void *filosofo(void *arg)
{
  int i = (int)arg;
  for (;;)
  {
    sem_wait(&semaforo);
    tomar_tenedores(i);
    comer(i);
    dejar_tenedores(i);
    sem_post(&semaforo);
    pensar(i);
    }
}

int main()
{
  int i;
  pthread_t filo[N_FILOSOFOS];
  sem_init(&semaforo, 0, N_FILOSOFOS - 1);
  for (i=0;i<N_FILOSOFOS;i++)
    pthread_mutex_init(&tenedor[i], NULL);
  for (i=0;i<N_FILOSOFOS;i++)
    pthread_create(&filo[i], NULL, filosofo, (void *)i);
  pthread_join(filo[0], NULL);
  sem_destroy(&semaforo);
  return 0;
}




// EJERCICIO 4
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

sem_t tabaco, papel, fosforos, otra_vez, fumadores[3];

void agente()
{
    for (;;) {
        int caso = random() % 3;
        sem_wait(&otra_vez);
        switch (caso) {
            case 0:
                sem_post(&fumadores[0]);
                sem_post(&tabaco);
                sem_post(&papel);
                break;
            case 1:
                sem_post(&fumadores[1]);
                sem_post(&fosforos);
                sem_post(&tabaco);
                break;
            case 2:
                sem_post(&fumadores[2]);
                sem_post(&papel);
                sem_post(&fosforos);
                break;
        }
    }
}

void fumar(int fumador)
{
    printf("Fumador %d: Puf! Puf! Puf!\n", fumador);
    sleep(1);
}

void *fumador1(void *arg)
{
    for (;;) {
        sem_wait(&fumadores[0]);
        sem_wait(&tabaco);
        sem_wait(&papel);
        fumar(1);
        sem_post(&otra_vez);
    }
}

void *fumador2(void *arg)
{
    for (;;) {
        sem_wait(&fumadores[1]);
        sem_wait(&fosforos);
        sem_wait(&tabaco);
        fumar(2);
        sem_post(&otra_vez);
    }
}

void *fumador3(void *arg)
{
    for (;;) {
        sem_wait(&fumadores[2]);
        sem_wait(&papel);
        sem_wait(&fosforos);
        fumar(3);
        sem_post(&otra_vez);
    }
}

int main()
{
    pthread_t s1, s2, s3;
    sem_init(&tabaco, 0, 0);
    sem_init(&papel, 0, 0);
    sem_init(&fosforos, 0, 0);
    sem_init(&fumadores[0], 0, 0);
    sem_init(&fumadores[1], 0, 0);
    sem_init(&fumadores[2], 0, 0);
    sem_init(&otra_vez, 0, 1);

    pthread_create(&s1, NULL, fumador1, NULL);
    pthread_create(&s2, NULL, fumador2, NULL);
    pthread_create(&s3, NULL, fumador3, NULL);
    agente();

    return 0;
}