Skip to content
Extraits de code Groupes Projets
run.c 8,41 ko
Newer Older
  • Learn to ignore specific revisions
  • Laurent Paucot's avatar
    Laurent Paucot a validé
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/stat.h>
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    #include <pthread.h>
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    #include <semaphore.h>
    
    //travailler avec des linkendList
    typedef struct node{ 
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        long value;
        struct node *next;
    }node_t;
    
    
    typedef struct queue{ 
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct node *tail;
        int size;
    }queue_t;
    
    struct buffer_rc{
        char *tab[8];
        int size;       
        int len;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        int head;
        int tail;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        int stop;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        FILE *file1;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    };
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    struct buffer_cw
    {
        queue_t *tab[8];
        int size;       
        int len;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        int head;
        int tail;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        int stop;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        FILE *file2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    struct buffer_rccw{
        struct buffer_rc *struct1;
        struct buffer_cw *struct2; 
    };
    
    /* sémaphore est une structure de donné qui contient :
        *un entier qui stocke la valeur, positive ou nulle du sémaphore.
        *une queue qui contient les pointeurs vers les threads
    */
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    pthread_mutex_t mutex1;
    sem_t empty1;
    sem_t full1;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    pthread_mutex_t mutex2;
    sem_t empty2;
    sem_t full2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    void put_in_buffer_1(char **c, struct buffer_rc *ptr){ //ajouter un element dans le buffer 1
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        //buffer_1.tab[buffer_1.head] = malloc(sizeof(c)); // on stoxke de espace 
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        //ptr->tab[ptr->head] = *c;
        strcpy(ptr->tab[ptr->head],*c); //copie
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        ptr->len++; // augmente l'espace occupé par le buffer
        ptr->head = (ptr->head + 1)%ptr->size; //chaque fois qu'un élément est ajouté, 
    
        //on augmente le pointeur de 1 mais l'espace du buffer est de 8 donc faire un modulo
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    }
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    char *get_from_buffer_1(struct buffer_rc *ptr){ // chercher dans le buffer 1
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        char *result;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        result = ptr->tab[ptr->tail]; // donne un valeur a result
        //buffer_1.tab[buffer_1.tail] = NULL;
        ptr->len--; //diminue l'espace occupé par le buffer
        ptr->tail = (ptr->tail + 1)%ptr->size;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        return result;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    }
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    void put_in_buffer_2(struct queue *ptr, struct buffer_cw *buf){ //ajouter un element dans le buffer 2
        buf->tab[buf->head] = ptr;
        buf->len++; //augmenté l'espace occupé par le buffer
        buf->head = (buf->head + 1)%buf->size;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    queue_t *get_from_buffer_2(struct buffer_cw *buf){ // trouver un element
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct queue *result;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        result = buf->tab[buf->tail]; //donne une valeur a result
        buf->len--; //diminue l'espace occupé par le buffer
        buf->tail = (buf->tail + 1)%buf->size;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        return result;
    }
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    int is_div(long number, long i) { // Vérifie si i est un diviseur de number.
        return (number % i == 0) ; // revoi 0 si le nombre n'est pas divisible par i et 1 si il est divisible
    }
    
    int is_prime(long number) { // Vérifie si number est un nombre premier. Return 1 si il est premier, 0 sinon
    
    Corentin Zgajewski Delforge's avatar
    Corentin Zgajewski Delforge a validé
        if (number != 2) {
            if (number  % 2 == 0) {
                return 0 ;
            }
        }
        for (long i = 3 ; i <= (number/2); i = i + 2) { //regarde les differents nombres pouvant etre diviser number
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            if (is_div(number,i) != 0) { // si i peut diviser number
                return 0 ; //renvoi 0 => FAUX
            }
        }
        return 1 ; //sinon => VRAI
    }
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    void enqueue(queue_t* q, long val){ 
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct node *ptr;
        ptr = malloc(sizeof(node_t));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        if (ptr == NULL){
            free(ptr);
            return;}
    
        ptr -> value = val;
        ptr -> next = malloc(sizeof(node_t));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        if (q->size == 0)
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            *q->tail = *ptr;
            *ptr->next = *ptr;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        else{
            *ptr->next = *q->tail->next;
            *q->tail->next = *ptr;
        }
        q->size++;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        //return q;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        free(ptr);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    }
    
    
    
    queue_t* prime_divs(long number){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct queue new_queue;
        new_queue.size = 0;
    
        new_queue.tail = malloc(sizeof(node_t));
        if(new_queue.tail==NULL){return NULL;}
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        struct queue *ptr;
        ptr = malloc(sizeof(queue_t));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        if (ptr == NULL){
            free(new_queue.tail);
            free(ptr);
            return NULL;}
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        *ptr = new_queue;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        for (long i = 2; i <= number/2; i++){
            if (is_div(number, i) && is_prime(i) == 1){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
                enqueue(ptr,i);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        enqueue(ptr,number);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
        return ptr;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    }
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    void *writing(void *param){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        struct buffer_cw *param1 = (struct buffer_cw *) param;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        while(param1->stop < 4 || param1->len > 0){            
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            sem_wait(&full2);
            pthread_mutex_lock(&mutex2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            queue_t *pr_divs = get_from_buffer_2(param);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pthread_mutex_unlock(&mutex2);
            sem_post(&empty2);   
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            FILE *file2 = param1->file2;   
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            //char *chaine = NULL;  //juste pour que le code compile
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            struct node *current;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            current = malloc(sizeof(node_t));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            if (current == NULL){return NULL;}
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            *current = *pr_divs->tail;
            current = current->next;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            //fprintf(file2,"%s",chaine);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            for (int i = 0; i < pr_divs->size; i++)
            {
                fprintf(file2," %ld",current->value);
                current = current->next;
            }
            fputc('\n',file2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        }
        return NULL;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    }
    
    void *calculating(void *param){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        struct buffer_rccw *param1 = (struct buffer_rccw *) param;
    
        struct buffer_rc *buffer_1 = param1->struct1;
        struct buffer_cw *buffer_2 = param1->struct2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        while(buffer_1->stop == 0 || buffer_1->len > 0){  
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            sem_wait(&full1);
            pthread_mutex_lock(&mutex1);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            char *chaine = get_from_buffer_1(buffer_1);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pthread_mutex_unlock(&mutex1);
            sem_post(&empty1);   
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
            struct queue *pr_divs;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pr_divs = malloc(sizeof(queue_t));
            if (pr_divs == NULL){return NULL;}
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pr_divs = prime_divs(strtol(chaine,NULL,0));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
            sem_wait(&empty2);
            pthread_mutex_lock(&mutex2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            put_in_buffer_2(pr_divs,buffer_2);    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pthread_mutex_unlock(&mutex2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            sem_post(&full2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        buffer_2->stop ++;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        return NULL;
    }
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    void *reading (void *param){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct buffer_rc *param1= (struct buffer_rc *) param;
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        char chaine[20];
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        FILE *input;
        //input = malloc(sizeof(FILE*));
        input = param1->file1;
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        while (fgets(chaine,20,input) != NULL){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
           char **ptr;
           ptr = malloc(sizeof(chaine));
           *ptr = chaine;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            sem_wait(&empty1);
            pthread_mutex_lock(&mutex1);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            put_in_buffer_1(ptr,param1);            //put each line in the buffer #1
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            
            pthread_mutex_unlock(&mutex1);
            sem_post(&full1);
        }
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        param1->stop = 1;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        return NULL;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    void sem_1_initializer(struct buffer_rc *buf){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_mutex_init(&mutex1,NULL);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        sem_init(&empty1,0,buf->size);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        sem_init(&full1,0,0);
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    }
    
    void sem_2_initializer (struct buffer_cw *buf){
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_mutex_init(&mutex2,NULL);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        sem_init(&empty2,0,buf->size);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        sem_init(&full2,0,0);
    
    }
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    int run (char *input,char *output){
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        FILE *file1 = NULL;
        FILE *file2 = NULL;
    
        file1 = fopen(input,"r");
        if (file1 == NULL){return -1;}
    
        file2 = fopen(output,"w+");
        if (file2 == NULL){
            fclose(file1);
            return -1;
        }
    
        struct buffer_rc buffer_1;
        //*buffer_1.tab = malloc(sizeof(char[8]));
        for (int i = 0; i < 8; i++)
        {
            buffer_1.tab[i] = malloc(sizeof(char*));
        }
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        buffer_1.size = 8;
        buffer_1.len = 0;
        buffer_1.head = 0;
        buffer_1.tail = 0;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        buffer_1.stop = 0;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        //buffer_1.file1 = malloc(sizeof(file1));
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        buffer_1.file1 = file1;
    
        struct buffer_rc *ptr1;
        ptr1 = malloc(sizeof(struct buffer_rc));
        if (ptr1 == NULL){
            free(buffer_1.file1);
            free(ptr1);
            return -1;}
        *ptr1 = buffer_1;
    
    
        struct buffer_cw buffer_2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
    
        buffer_2.size = 8;
        buffer_2.len = 0;
        buffer_2.head = 0;
        buffer_2.tail = 0;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        buffer_2.stop = 0;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        buffer_2.file2 = file2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct buffer_cw *ptr2;
        ptr2 = malloc(sizeof(struct buffer_cw));
        if (ptr2 == NULL){return -1;}
        *ptr2 = buffer_2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct buffer_rccw buffer_12;
        buffer_12.struct1 = ptr1;
        buffer_12.struct2 = ptr2;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        struct buffer_rccw *ptr3;
        ptr3 = malloc(sizeof(struct buffer_rccw));
        if (ptr3 == NULL){return -1;}
        *ptr3 = buffer_12;
        
    
        
        
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_t reader;
        pthread_t calculators[4];
        pthread_t writer;
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        sem_1_initializer(ptr1);
        sem_2_initializer(ptr2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_create(&reader,NULL,&reading,ptr1);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        for (int i = 0; i < 4; i++)
        {
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
            pthread_create(&calculators[i],NULL,&calculating,ptr3);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_create(&writer,NULL,&writing,ptr2);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        pthread_join(reader,NULL);
        for (int i = 0; i < 4; i++)
        {
            pthread_join(calculators[i],NULL);
        }
        pthread_join(writer,NULL);
    
    Laurent Paucot's avatar
    Laurent Paucot a validé
        fclose(file1);
        fclose(file2);
    
     /* int main() {
         int err = run("input.txt", "actual_output.txt");
    
         return err;
     } */