SO Práctica 2

//EJERCICIO 1

//Apartado 1
#include <stdio.h>
#include <omp.h>

#define N_VISITANTES 1000000

int visitantes = 0;

int main()
{
  int i;
  #pragma omp parallel num_threads(2)
  for (i=0;i<N_VISITANTES;i++)
    visitantes++;

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


//Apartado 2
#include <stdio.h>
#include <omp.h>

#define N_VISITANTES 50
#define N 2

int visitantes = 0;
int flag[N];
volatile int turno[N];
int max;

void lock(int proceso){
    int i;
    flag[proceso] = 1;

    turno[proceso] = ++max;
    flag[proceso] = 0;
    for(i = 0; i < N; i++){
        while(i != proceso && flag[i]!=0);
        while (turno[i] != 0 && (turno[proceso] > turno[i] || (turno[proceso] == turno[i] && proceso > i)));
    }
}

void unlock(int proceso){
    turno[proceso] = 0;
}

int main()
{
  int i;
  #pragma omp parallel num_threads(N)
  for (i=0;i<N_VISITANTES;i++){
    lock(omp_get_thread_num());
    visitantes++;
    unlock(omp_get_thread_num());
  }
  printf("Hoy hubo %d visitantes!\n", visitantes);
  return 0;
}




// EJERCICIO 2
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#define N 1000

int A[N][N],B[N][N],C[N][N];

void mult(int A[N][N], int B[N][N], int C[N][N])
{
    int i, j, k;
    # pragma omp parallel num_threads(N) private(i, j, k)
    {
        k = omp_get_thread_num();
        for (i=0;i<N;i++)
            for (j=0;j<N;j++)
                C[k][i] += A[k][j]*B[j][i];
    }
}

int main()
{
    int i, j;
    for (i=0;i<N;i++)
        for (j=0;j<N;j++) {
            A[i][j] = random() % 10;
            B[i][j] = random() % 10;
        }
    mult(A, B, C);
    return 0;
}





/*
alumno@pelle010:~/Escritorio$ gcc matrixP.c -fopenmp
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.003s
user    0m0.000s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.003s
user    0m0.000s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.003s
user    0m0.004s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ gcc matrixP.c -fopenmp
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.022s
user    0m0.056s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe""
> dddd
> swds
> ^C
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m0.046s
user    0m0.044s
sys 0m0.004s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m0.046s
user    0m0.044s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.021s
user    0m0.056s
sys 0m0.004s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m0.046s
user    0m0.044s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ gcc matrixP.c -fopenmp
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m0.162s
user    0m0.600s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m0.547s
user    0m0.544s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ gcc matrixP.c -fopenmp
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"
^[[A^[[A^[[A^[[
real    0m5.363s
user    0m5.360s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./a.out"

real    0m1.228s
user    0m4.768s
sys 0m0.016s
*/


/*
La diferencia importante ocurre cuando hacemos que j sea el ultimo en iterar, lo cual es bueno por localidad de datos.



USANDO ORDEN DE FORS ijk
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m5.515s
user    0m5.512s
sys 0m0.000s

USANDO ORDEN DE FORS ikj (Es el más rápido)
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m3.627s
user    0m3.624s
sys 0m0.000s
*/



/*
No hay diferencia entre kij e ikj

ORDEN IJK
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m5.364s
user    0m5.356s
sys 0m0.008s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m5.477s
user    0m5.476s
sys 0m0.000s

ORDEN KIJ
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m2.995s
user    0m2.992s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m2.993s
user    0m2.988s
sys 0m0.004s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m2.998s
user    0m2.996s
sys 0m0.000s

ORDEN IKJ
alumno@pelle010:~/Escritorio$ gcc matrix.c -o pepe
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m2.980s
user    0m2.976s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./pepe"

real    0m2.982s
user    0m2.980s
sys 0m0.000s


*/


// EJERCICIO 3
// Usando un parallel for no es más rápido, los cambios entre threads se vuelven violentos.

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <limits.h>
#define N 500000000
#define NUM_THREADS 1

int min(int a, int b)
{
    if(a < b)
        return a;
    return b;
}

int A[N];
int MINIMO[NUM_THREADS];


int main()
{
    int i;

    for(i = 0; i < N; ++i)
        A[i] = random()%(1<<20);

    for(i = 0; i < NUM_THREADS; ++i)
        MINIMO[i] = INT_MAX;

    int total = INT_MAX;

    #pragma omp parallel for reduction(min : total) num_threads(NUM_THREADS)
    for(i = 0; i < N; ++i){
        total = min(A[i], total);
    }

    printf("%d\n", total);
    return 0;
}


// EJERCICIO 4
/*
La version original tiene el inconveniente de que la cantidad de threads generados crece exponencialmente con el tamaño del arreglo. Entonces, los cambios de contexto hacen que demore mucho más, además de que con un largo lo suficientemente grande, hay un Segmentation Fault. Modificando el código para acotar la cantidad de threads mejora el rendimiento y evita que haya errores en la ejecución.
*/


#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define N 10000000
#define ALTURA_TOTAL 2

typedef struct {
    int *v;
    int b, t, h;
} qsparams;

void swap(int *v, int i, int j)
{
    int tmp=v[i];
    v[i]=v[j];
    v[j]=tmp;
}

int colocar(int *v, int b, int t)
{
    int i;
    int pivote, valor_pivote;
    int temp;

    pivote = b;
    valor_pivote = v[pivote];
    for (i=b+1; i<=t; i++){
        if (v[i] < valor_pivote){
            pivote++;
            swap(v,i,pivote);
        }
    }
    temp=v[b];
    v[b]=v[pivote];
    v[pivote]=temp;
    return pivote;
}

void QuicksortSeq(int* v, int b, int t)
{
    int pivote;
    if(b < t){
        pivote=colocar(v, b, t);
        QuicksortSeq(v, b, pivote-1);
        QuicksortSeq(v, pivote+1, t);
    }
}

void *Quicksort(void *p)
{
    qsparams *params = (qsparams *)p;
    int *v = params->v;
    int b = params->b;
    int t = params->t;
    int h = params->h;

    int pivote;
    if(b < t){
        if (h > 0){
            pthread_t t1, t2;
            pivote=colocar(v, b, t);
            qsparams params1, params2;
            params1.v = v;
            params1.b = b;
            params1.t = pivote-1;
            params1.h = h - 1;
            params2.v = v;
            params2.b = pivote+1;
            params2.t = t;
            params2.h = h - 1;
            pthread_create(&t1, 0, Quicksort, (void *)&params1);
            pthread_create(&t2, 0, Quicksort, (void *)&params2);
            pthread_join(t1, NULL);
            pthread_join(t2, NULL);
        }
        else
            QuicksortSeq(v, b, t);

    }
}


void checker(int * a){
    int i;
    for(i=0; i < N-1; i++){
        if(a[i] > a[i+1]){
            printf("Desordenado \n");
            return;
            }
    }
        printf("Ordenado \n");

}


int main(int argc, char **argv)
{
    int *a,i;
    pthread_t t;

    a = malloc(N*sizeof(int));

    for(i=0;i<N;i++)
        a[i]=random()%N;

    checker(a);

    qsparams params;
    params.v = a;
    params.b = 0;
    params.t = N-1;
    params.h = ALTURA_TOTAL - 1;
    pthread_create(&t, 0, Quicksort, (void *)&params);
    pthread_join(t, NULL);

    checker(a);

    free(a);
    return 0;
}




/*
alumno@pelle010:~/Escritorio$ gcc qs.c
alumno@pelle010:~/Escritorio$ gcc qs_mt.c -lpthread -o a_mt.out
alumno@pelle010:~/Escritorio$ time "./a.out"
Desordenado
Ordenado

real    0m2.365s
user    0m2.364s
sys 0m0.000s
alumno@pelle010:~/Escritorio$ time "./a_mt.out"
Desordenado
Ordenado

real    0m1.503s
user    0m2.364s
sys 0m0.000s


*/



// EJERCICIO 5

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#define N 100
#define ARRLEN 100000

int arr[ARRLEN], ctos;
pthread_cond_t nadie = PTHREAD_COND_INITIALIZER;
pthread_mutex_t ml = PTHREAD_MUTEX_INITIALIZER;

int esc, lect;

void *escritor(void *arg)
{
  int i;
  int num = *((int *)arg);
  for (;;) {
    sleep(random()%3);

    pthread_mutex_lock(&ml);

    while(lect || esc)
        pthread_cond_wait(&nadie, &ml);

    //~ printf("Soy el escritor %d y me muero de hambre. Debi estudiar Lcc.\n", num);

    esc++;

    for (i=0; i<ARRLEN; i++) {
      arr[i] = num;
    }

    esc--;

    pthread_cond_signal(&nadie);
    pthread_mutex_unlock(&ml);
  }
  return NULL;
}

void *lector(void *arg)
{
  int v, i, err;
  int num = *((int *)arg);
  for (;;) {
    sleep(random()%3);

    pthread_mutex_lock(&ml);
    while(esc)
        pthread_cond_wait(&nadie, &ml);
    lect++;
    pthread_cond_signal(&nadie);
    pthread_mutex_unlock(&ml);

    printf("Soy el lector %d. Estudie Lcc y tengo dinero para libros.\n", num);

    err = 0;
    v = arr[0];
    for (i=1; i<ARRLEN; i++) {
      if (arr[i]!=v) {
        err=1;
        break;
      }
    }
    if (err) printf("Lector %d, error de lectura\n", num);
    else printf("Lector %d, dato %d\n", num, v);

    pthread_mutex_lock(&ml);
    lect--;
    pthread_mutex_unlock(&ml);
  }
  return NULL;
}

int main()
{
  int i;
  pthread_t lectores[N], escritores[N];
  int arg[N];

  for (i=0; i<ARRLEN; i++) {
    arr[i] = -1;
  }
  for (i=0; i<N; i++) {
    arg[i] = i;
    pthread_create(&lectores[i], NULL, lector, (void *)&arg[i]);
    pthread_create(&escritores[i], NULL, escritor, (void *)&arg[i]);
  }
  pthread_join(lectores[0], NULL); /* Espera para siempre */
  return 0;
}




// EJERCICIO 6

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#define N 3
#define ARRLEN 100000

int arr[ARRLEN], ctos;
pthread_cond_t nadie = PTHREAD_COND_INITIALIZER;
pthread_mutex_t ml = PTHREAD_MUTEX_INITIALIZER;

int esc, lect, shushu;

void *escritor(void *arg)
{
  int i;
  int num = *((int *)arg);
  for (;;) {
    sleep(random()%2);

    pthread_mutex_lock(&ml);

    while(lect || esc){
    //  printf("Soy escritor %d y estoy en el while\n", num);
        pthread_cond_wait(&nadie, &ml);
        shushu++;
    }
    printf("Soy el escritor %d. Entre.\n", num);
    esc++;

    for (i=0; i<ARRLEN; i++) {
      arr[i] = num;
    }

    esc--;
    shushu = 0;

    pthread_cond_signal(&nadie);
    pthread_mutex_unlock(&ml);
  }
  return NULL;
}

void *lector(void *arg)
{
  int v, i, err;
  int num = *((int *)arg);
  for (;;) {

    sleep(random()%2);

    pthread_mutex_lock(&ml);

    while(esc || shushu){
    //  printf("Soy lector %d y estoy en el while\n", num);
        pthread_cond_wait(&nadie, &ml);
    }

    lect++;
    pthread_cond_signal(&nadie);
    pthread_mutex_unlock(&ml);

    printf("Soy el lector %d. Entre.\n", num);

    err = 0;
    v = arr[0];
    for (i=1; i<ARRLEN; i++) {
      if (arr[i]!=v) {
        err=1;
        break;
      }
    }
    if (err) printf("Lector %d, error de lectura\n", num);
    else printf("Lector %d, dato %d\n", num, v);

    pthread_mutex_lock(&ml);
    lect--;
    pthread_cond_signal(&nadie);
    pthread_mutex_unlock(&ml);
  }
  return NULL;
}

int main()
{
  int i;
  pthread_t lectores[N], escritores[N];
  int arg[N];

  for (i=0; i<ARRLEN; i++) {
    arr[i] = -1;
  }
  for (i=0; i<N; i++) {
    arg[i] = i;
    pthread_create(&lectores[i], NULL, lector, (void *)&arg[i]);
    pthread_create(&escritores[i], NULL, escritor, (void *)&arg[i]);
  }
  pthread_join(lectores[0], NULL); /* Espera para siempre */
  return 0;
}




// EJERCICIO 7

/*
GUIdios
guIDios
guidIOs
guidiOS
*/


#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#define N_SILLAS 5
#define N_CLIENTES 10
#define N_BARBEROS 5
#define sleep_tight() (sleep(random() % 1))
int sillas[N_SILLAS];
int esperando, indice;

int contBarrera[N_CLIENTES];
int taken[N_CLIENTES];

pthread_cond_t llegaCliente = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lockSilla = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lockBarrera = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t esperandoEnLaSilla = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barrera[N_CLIENTES];


void init_magico(){
    int i;
    for(i = 0; i < N_CLIENTES; i++)
        pthread_cond_init(&barrera[i], 0);

    }

void funcionBarrera(int guID){
    pthread_mutex_lock(&lockBarrera);
    if(contBarrera[guID] == 0){
        contBarrera[guID] = 1;
        pthread_cond_wait(&barrera[guID], &lockBarrera);
        pthread_mutex_unlock(&lockBarrera);
    }
    else{
        pthread_cond_signal(&barrera[guID]);
        contBarrera[guID] = 0;
        pthread_mutex_unlock(&lockBarrera);
    }
}


void me_cortan(int guID)
{
    printf("Soy el cliente %d y me estan cortando el pelo.\n", guID);
    sleep_tight();
}

void cortan2(int barbID, int guID)
{
    printf("Soy el barbero %d y le corto el pelo a %d.\n", barbID, guID);
    sleep_tight();
}

void pagan2(int guID)
{
    printf("Soy el cliente %d y amo el capitalismo.\n", guID);
    sleep_tight();
}

void me_pagan(int barbID, int guID)
{
    printf("Soy el barbero %d y amo que me pague el cliente %d.\n", barbID, guID);
    sleep_tight();
}


void *barbero(void *arg)
{

    int barbID = *((int *) arg);
    int clienteActual;
    for(;;){
        ///Si no hay nadie, duermo.
        pthread_mutex_lock(&lockSilla);
        //~ pthread_cond_wait(&llegaCliente, &lockSilla);
        //~ pthread_mutex_unlock(&lockSilla);
        clienteActual = sillas[indice];
        while(esperando == 0 || taken[clienteActual]){
            printf("Barbero %d: Zzz...\n", barbID);
            pthread_cond_wait(&llegaCliente, &lockSilla);
            clienteActual = sillas[indice];
        }
        taken[clienteActual] = 1;
        pthread_mutex_unlock(&lockSilla);

        ///Llamo al proximo cliente
        funcionBarrera(clienteActual);


        ///Tengo un cliente
        funcionBarrera(clienteActual);
        cortan2(barbID, clienteActual);

        ///Ya le corte el pelo
        funcionBarrera(clienteActual);
        me_pagan(barbID, clienteActual);

        ///Ya me pagaron
        funcionBarrera(clienteActual);

        ///Fush fush
        pthread_mutex_lock(&lockSilla);
        taken[clienteActual] = 0;
        pthread_mutex_unlock(&lockSilla);
    }
  return NULL;
}

void *guido(void *arg)
{
    int guID = *((int *) arg);
    for(;;){
        sleep_tight();

        ///Si no hay lugar, me voy
        pthread_mutex_lock(&lockSilla);
        if(esperando == N_SILLAS){
            pthread_mutex_unlock(&lockSilla);
            continue;
        }

        ///Si hay lugar, me siento
        sillas[(indice + esperando) % N_SILLAS] = guID;
        esperando++;

        ///Si el barbero duerme, lo despierto
        pthread_cond_signal(&llegaCliente);
        pthread_mutex_unlock(&lockSilla);


        ///Espero a mi turno
        funcionBarrera(guID);


        ///Largando mi silla
        pthread_mutex_lock(&lockSilla);
        indice = (indice + 1) % N_SILLAS;
        esperando --;
        pthread_mutex_unlock(&lockSilla);


        ///Me atiende un barbero.
        funcionBarrera(guID);
        me_cortan(guID);

        ///Ya me corto el pelo
        funcionBarrera(guID);
        pagan2(guID);

        ///Ya le pague
        funcionBarrera(guID);
        }
  return NULL;
}


int main()
{
  int i;
  pthread_t barb[N_BARBEROS], guidos[N_CLIENTES];
  int arggu[N_CLIENTES];
  int argba[N_CLIENTES];

  init_magico();

  for (i=0; i < N_CLIENTES; i++) {
    arggu[i] = i;
    pthread_create(&guidos[i], NULL, guido, (void *)&arggu[i]);
  }

  for(i=0; i < N_BARBEROS; i++){
    argba[i] = i;
    pthread_create(&barb[i], NULL, barbero, (void *)&argba[i]);
  }

  pthread_join(barb[0], NULL);
  return 0;
}




//EJERCICIO 8

#include <stdio.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

#define BUFF_SIZE 1024
#define CANT_CLIENT 500

int id = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* handle_client(void* arg)
{
    int conn_s = *((int*) arg);
    char buffer[BUFF_SIZE],buffer2[BUFF_SIZE];
    int res;
    int clientID;
    pthread_mutex_lock(&mutex);
    clientID = ++id; // Nuevo cliente
    pthread_mutex_unlock(&mutex);
    fprintf(stderr,"New client %d connected\n",clientID);
    while(1) {
        res=read(conn_s,buffer,BUFF_SIZE);
        if (res<=0) {
            close(conn_s);
            break;
        }
        buffer[res]='\0';
        sprintf(buffer2,"Response to client %d: %s",clientID, buffer);
        write(conn_s,buffer2,strlen(buffer2));
    }
}

int main()
{
    pthread_t handler[CANT_CLIENT];
    int handlerind = 0;
    int list_s,conn_s=-1,res;
    struct sockaddr_in servaddr;
    char buffer[BUFF_SIZE],buffer2[BUFF_SIZE];
    if ( (list_s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
        fprintf(stderr, "ECHOSERV: Error creating listening socket.\n");
        return -1;
    }
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family      = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port        = htons(8000);

    if ( bind(list_s, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 ) {
        fprintf(stderr, "ECHOSERV: Error calling bind()\n");
        return -1;
    }

    if ( listen(list_s, 10) < 0 ) {
        fprintf(stderr, "ECHOSERV: Error calling listen()\n");
        return -1;
    }

    while (1) {
        if ( (conn_s = accept(list_s, NULL, NULL) ) < 0 ) {
            fprintf(stderr, "ECHOSERV: Error calling accept()\n");
            return -1;
        }

            pthread_create(&handler[handlerind], NULL, handle_client, (void*) &conn_s);
            handlerind = (handlerind + 1) % CANT_CLIENT;
    }
    return 0;
}