#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <pthread.h>
#include<sys/shm.h>

int *premier, *tab, max, maxPremier;

pthread_cond_t condition = PTHREAD_COND_INITIALIZER; /* Création de la condition */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /* Création du mutex */

void* remplissage(void* arg);
void* suppression(void* arg);

int main(int argc, int argv[]){
    pthread_t thread1, thread2;
    int n, shmidRemplissage, shmidSuppression;
    printf("Donner le max : ");
    scanf("%d", &max);
    //creation d'un segment de memoire qu'on remplira
    //par 0, 1,..., max
    shmidRemplissage=shmget(IPC_PRIVATE, max*sizeof(int), IPC_CREAT|0666);
    tab=(int*)shmat(shmidRemplissage, NULL, 0);
    //remplissage de tab par thread1
    pthread_create(&thread1, NULL, remplissage, NULL);
    //Pour tester le remplissage
    for (int i = 0; i < max; i++)
    {
        printf("%d ", tab[i]);
    }
    
    shmdt(tab); //detachement du segment

    //creation d'un second segment de memoire
    shmidSuppression=shmget(IPC_PRIVATE, maxPremier*sizeof(int), IPC_CREAT|0666);
    premier=(int*)shmat(shmidSuppression, NULL, 0);
    //suppression des nombres non premiers dans la zone memoire
    pthread_create(&thread2, NULL, suppression, NULL);

    //Pour tester si la suppression s'est bien passee
    for (int i = 0; i < maxPremier; i++)
    {
        printf("%d ", premier[i]);
    }
    printf("\n");
    
    shmdt(premier);
    pthread_join (thread1, NULL);
	pthread_join (thread2, NULL); /* Attente de la fin des threads */

}


void* remplissage(void* arg)
{
    pthread_mutex_lock (&mutex); /* On verrouille le mutex */
    printf("Remplissage des nombres dans le segment\n");
    for (int i = 0; i < max; i++)
    {
        tab[i]=i;
    }
    pthread_cond_signal (&condition); /* On délivre le signal : condition remplie */
    pthread_mutex_unlock (&mutex); /* On deverrouille le mutex */
    pthread_exit(NULL); /* Fin du thread */

}

void* suppression(void* arg)
{
    int *supprimes;
    supprimes=(int*)malloc((max)*sizeof(int));
    supprimes[1]=1;
    supprimes[0]=1;
    for (int i = 2; i < max; i++)
        supprimes[i]=0;
    for (int i = 2; i < max; i++){
        for (int j = i+1; j < max; j++)
        {
            if(j%i==0)
                supprimes[j]=1;
        }
        
    }
    pthread_mutex_lock (&mutex); /* On verrouille le mutex */
    pthread_cond_wait (&condition, &mutex); /* On attend que la condition soit remplie */
    printf("Suppression des nombres non premier du" 
    "segment et copie des premier dans le deuxieme segment\n");
    for (int i = 0; i <= max; i++)
        if (!supprimes[i]){
            premier[maxPremier]=i;
            ++maxPremier;
        }
    pthread_mutex_unlock (&mutex); /* On deverrouille le mutex */
    pthread_exit(NULL); /* Fin du thread */

}

-
Edité par Kamtos 20 février 2020 à 6:14:30

Salut,

Erreur de segmentation -> utilise un debuggueur pour savoir ou !

(je ne comprends pas pourquoi on enseigne aux gens la programmation sans debuggueur, quand on voit a quel point ça simplifie la vie....)

Salut,

Je sais pas si c'est ce que tu appelles debugger mais j'ai utilisé un printf("ok") après plusieurs fonctions pour savoir à quel niveau se trouve le problème mais ça n'a pas marché. En effet, à chaque fois que j'exécute le même programme il change de comportement. Il se peut que la première fois, le printf("ok") marche et la seconde, ça ne marche pas.

C'est en fait ça mon problème. 

Merci de la réponse

Kamtos a écrit:

Salut,

Je sais pas si c'est ce que tu appelles debugger mais j'ai utilisé un printf("ok") après plusieurs fonctions pour savoir à quel niveau se trouve le problème mais ça n'a pas marché. En effet, à chaque fois que j'exécute le même programme il change de comportement. Il se peut que la première fois, le printf("ok") marche et la seconde, ça ne marche pas.

C'est en fait ça mon problème. 

Merci de la réponse

Mettre des printf décale le contexte et donc décale les potentiels débordements. Ce n'est pas un bon moyen de debugguer. C'est comme laver par terre avec du sopalin et de la salive.

Quel IDE as tu ?

-
Edité par Fvirtman 20 février 2020 à 9:06:36

Visual Studio a un tres bon debuggueur ! 

Lance ton programme en appuyant sur F5, (assure toi d'être en Debug (pas release)) quand il te dira que ça crash, la tu fais "break" et tu sauras exactement ou il a planté.

Tu pourras voir la pile d'appel. Tu pourras voir la valeur de chaque variable. 

Et tu pourras aussi voir l'état des différents threads 

-
Edité par Fvirtman 20 février 2020 à 9:21:51

Je suis désolé du retard pris.

Ça a été difficile pour moi de déboguer avec visual studio donc j'ai migré vers code blocks. Mais j'ai même  pas pu compiler le programme (je le faisais en ligne de commande avec visual, ce que je peux pas faire avec code block) du coup, le débogage n'a pas pu se faire. 

Une idée ??

Merci

-
Edité par Kamtos 20 février 2020 à 10:07:57

Kamtos a écrit:

Je suis désolé du retard pris.

Ça a été difficile pour moi de déboguer avec visual studio donc j'ai migré vers code blocks. 

Kamtos a écrit:

Ça a été difficile pour moi de déboguer avec visual studio donc j'ai migré vers code blocks

Curieux, j'aurais dit l'inverse.

PS: on parle bien de Visual Studio et pas de Visual Studio code?

-
Edité par zoup 20 février 2020 à 21:08:05

C'est plutôt Visual Studio Code

Pour plus d'informations, je suis sur Ubuntu, du coup, je ne peux pas utiliser Visual Studio

-
Edité par Kamtos 21 février 2020 à 0:41:49

bonjour svp jai  une question  en language c

décrire la les somme d'erreur de calcul  lorsqu'on ordinateur exécute  la somme successive quand i=1 jusqu’à N de 1/N quand N=16000 et quand N=16384.

merci

-
Edité par edgarjacobs 21 février 2020 à 0:57:15

desole