main.c

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

#include <pthread.h>
#include <semaphore.h>

#include "fonctions.h"


FILE *file_in;
FILE *file_out;
char *f_in;
char *f_out;
int number_lines;
int nthreads = 1;
buffer1 *buffer_1;
buffer2 *buffer_2;

void *reading() {
    file_in = fopen(f_in, "r");
    if (file_in == NULL) {
        printf("Error with file_in.\n");
        exit(EXIT_FAILURE);
    } else {
        printf("file_in opened with succes.\n");
    }

    int number = 0;
    while (fscanf(file_in, "%d", &number) != EOF) {
        sem_wait(&(buffer_1->free));
        pthread_mutex_lock(&(buffer_1->mutex));
        put_node_t(buffer_1->numbers, number);
        pthread_mutex_unlock(&(buffer_1->mutex));
        sem_post(&(buffer_1->full));
    }

    return EXIT_SUCCESS;
}


void *calculating() {
    sem_wait(&(buffer_1->full));
    pthread_mutex_lock(&(buffer_1->mutex));
    int number = get_node_t(buffer_1->numbers);
    //printf("nomber = %d\n", number);
    pthread_mutex_unlock(&(buffer_1->mutex));
    sem_post(&(buffer_1->free));

    list_t *list_prime = prime_list(number);
    //printf("%d, number\n", get_node_t(list_prime));
    //printf("%d, divider\n", get_node_t(list_prime));
    //printf("%d, divider2\n", get_node_t(list_prime));

    sem_wait(&(buffer_2->free));
    pthread_mutex_lock(&(buffer_2->mutex));
    put_node_lst(buffer_2->prime_numbers, list_prime);
    pthread_mutex_unlock(&(buffer_2->mutex));
    sem_post(&(buffer_2->full));

    //clear_list_t(list_prime);
    return EXIT_SUCCESS;
}

void *writing() {
    file_out = fopen(f_out, "w");
    if (file_out == NULL) {
        printf("Error with file_out.\n");
        exit(EXIT_FAILURE);
    } else {
        printf("file_out opened with succes.\n");
    }

    number_lines = count_lines(f_in);
    while(number_lines != 0) {
        number_lines--;

        sem_wait(&(buffer_2->full));
        pthread_mutex_lock(&(buffer_2->mutex));
        list_t *removed = get_node_lst(buffer_2->prime_numbers);
        pthread_mutex_unlock(&(buffer_2->mutex));
        sem_post(&(buffer_2->free));

        //fprintf(file_out, "%d : ", removed->length);
        int length = removed->length;
        for (int i = 0; i < length; i++) {
            fprintf(file_out, "%d ", get_node_t(removed));
        }
        clear_list_t(removed);
        free(removed);
        fprintf(file_out, "\n");
    }
    return EXIT_SUCCESS;
}

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "N:")) != -1) {
        switch(opt) {
            case 'N':
                nthreads = atoi(optarg);
                printf("Number of threads : %d.\n", nthreads);
                break;
            default:
                printf("Invalid number of threads.\n");
                break;
        }
        f_in = argv[optind];
        f_out = argv[optind + 1];
    }
    
    
    buffer_1 = init_buffer_1(nthreads);
    if (!buffer_1) {
//        free(buffer_1);
        printf("Error with buffer_1.\n");
        return -1;
    }

    buffer_2 = init_buffer_2(nthreads);
    if (!buffer_2) {
//        free(buffer_2);
        printf("Error with buffer_2.\n");
        return -1;
    }

    pthread_t read;
    pthread_t calc[nthreads];
    pthread_t write;

    if (pthread_create(&read, NULL, &reading, NULL) != 0) {
        printf("Error with creating reading thread.\n");
        return -1;
    }

    for (int i = 0; i < nthreads; i++) {
        if (pthread_create(&calc[i], NULL, &calculating, NULL) != 0) {
            printf("Error with creating calculating thread.\n");
            return -1;
        }
    }

    if (pthread_create(&write, NULL, &writing, NULL) != 0) {
        printf("Error with creating writing thread.\n");
        return -1;
    }

    if (pthread_join(read, NULL) != 0) {
        printf("Error with join reading thread.\n");
        return -1;
    }

//    pthread_mutex_lock(&(buffer_1->mutex));
//    buffer_1->is_running = false;
//    pthread_mutex_unlock(&(buffer_1->mutex));

    for (int i = 0; i < nthreads; i++) {
        if (pthread_join(calc[i], NULL) != 0) {
            printf("Error with join calculating thread.\n");
            return -1;
        }
    }

    if (pthread_join(write, NULL) != 0) {
        printf("Error with join writing thread.\n");
        return -1;
    }


    fclose(file_in);
    fclose(file_out);
    printf("Files close.\n");

    clear_list_t(buffer_1->numbers);
    free(buffer_1->numbers);
    clear_list_lst(buffer_2->prime_numbers);
    free(buffer_2->prime_numbers);

    free(buffer_1);
    free(buffer_2);

    return 0;
}