J'ai un projet en programmation système en c dans lequel je dois réaliser le crible d'Eratosthène à l'aide des mémoire partagée. Pour cela, je décide de créer deux threads, et deux fonction : le premier thread exécute la fonction remplissage permettant de remplir les nombres de 0 à max dans la première zone mémoire et le second supprime tous les nombres non premiers. Le problème, je suis débutant en proggrammation système et je ne trouve pas assez de documentations sur la mémoire partagée. J'ai pu écrire un code mais j'ai une erreur de segmentation que je ne comprends pas. Voici le code complet :
#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 */
}
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.
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.
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
Ç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.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent