pthread : synchronisation / schedule

Bonjour,

J'ai un pb tout bête que je n'arrive pas à résoudre surement par manque de compréhension sur la synchronisation et le "scheduling" des threads.

J'ai un programme principal qui écrit des données dans n fichiers. Ce même programme lance au début n threads qui lise chacun un fichier.

Mon problème est que quand un thread lit un fichier, il semble occuper tout le temps processeur et ne permet pas aux autres thread de s’exécuter en parallèle.
Pourtant, chaque thread lit un fichier par bloc de 10 lignes avec un sleep après le traitement.
Je pense que le problème vient du sleep qui ne libère pas correctement le temps de processeur pour un autre thread. J'ai essayé avec sched_yield mais pas plus de succès. J'ai essayé de décaler le lancement de chaque thread, pas plus de succès.

Je pense qu'il faudrait que j'utilise des sémaphores, mais j'ai du mal à comprendre comment ça fonctionne.

Voici un pseudo code de ce qui est actuellement fait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Main(){ Lancement de N Threads Pour chaque fichier lock_fichier Ecriture des données. unlock_fichier Fin Pour } Thread{ do{ lock_fichier lecture de 10 lignes unlock_fichier Traitement des 10 lignes sleep(5); }while (end); }
Quelqu'un pourrait-il m'aider à établir un pseudo algo d'une solution qui marche ?

Merci d'avance.

Tu n'as qu'à associer un mutex à un thread et tu donneras ce mutex au thread suivant. Ainsi, tu lockes le premier mutex, empêchant l'exécution du 2e thread. Quand tu as lu les 10 lignes, tu le unlockes puis tu le lockes, mais comme le thread suivant à (normalement) locker ce mutex, il va se mettre en pause en attendant que le suivant ait fini ses opérations. J'espère que c'est pas trop brouillon comme explications ^^.

Bonjour,

Merci pour ta réponse.

Si je comprend bien tu proposes de créer un mutex global aux threads.

Le code du thread sera alors :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Thread{ do{ lock_thread lock_fichier lecture de 10 lignes unlock_fichier Traitement des 10 lignes unlock_thread }while (end); }
C'est bien ça ?

Je ne pense pas que ça marchera car dès le unlock_thread la boucle recommencera sur le lock_thread avant même qu'un autre thread est pris le lock.
Si je rajoute un sleep après le unlock_thread , je reviens au même pb à mon avis, le thread est bien endormis, mais le scheduler de l'OS considère comme encore actif et ne donne donc pas la main à un autre thread.

Salut,
Dans ton algo tu parle de lock_fichier et unlock_fichier. Qu'est que tu attend par là précisément? Parles-tu de pthread_mutex_lock? et pthread_mutex_unlock?

@+

Oui.

voila comment j'image le schmilblick :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
pthread_mutex_t mutex_fichier
 
Main(){
     init mutex_fichier
     Lancement de N Threads    
     Pour chaque fichier
         lock_fichier
         Ecriture des données.
         unlock_fichier
     Fin Pour
}
 
Thread{
 
     do{
          thread_lock  mutex_fichier
          lecture de 10 lignes
          thread_unlock mutex_fichier
          Traitement des 10 lignes
     }while (end);
}

mutex_fichier est en fait le mutex lock_fichier ?
Tu me proposes donc le code du premier post sans le sleep ?

En fait je viens de me rendre compte que j'avais probablement un deadlock :( avec le fonctionnement du programme. En effet le thread peut se retrouver en attente de libération du verrou par le programme principal qui attend lui aussi la libération du verrou par le thread.

En fait, j'ai oublié de préciser que le programme principal exécute la boucle d'écriture des fichiers dès qu'il reçoit un signal d'un autre programme et pas une bonne fois pour toute.

Le code du main est plutôt :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Main(){ Pour chaque thread init lock_fichier Lancement des Threads Fin pour. do{ Dès qu un signal reçu par un autre programme Pour chaque fichier lock_fichier Ecriture des données. unlock_fichier Fin Pour }while (end) }
Du coup il faut tout revoir à mon avis. Une piste ?

Excuse j'ai mal compris le problème, j'ai cru qu'il y avait un seul fichier et non n...

Bon en fait, mon problème c'est pas ordonnancement entre les threads mais bien ce deadlock.
J'ai supprimé les locks dans le thread en lecture et ça fonctionne.

Par contre, le thread à besoin aussi d'écrire dans le fichier pour le mettre à jour une fois les données traitées.

Comment faire ?

Le fait d'expliquer mon problème me fait y voir plus clair,en fait c'est juste un problème de producteur/consommateur qui se résous avec une sémaphore et deux mutex de ce que j'ai lu.

C'est la partie sémaphore que je comprend pas bien.
Je vais faire des recherches et je reviendrais si je ne comprend pas.

Merci.

Ps : Quelqu'un a un bon lien sur ce problème avec un exemple ?

En général on évite de mélanger mutex et sémaphores. Si c'est pour synchroniser des threads, utilise un mutex.

J'ai fait des recherches sur le pb du producteur/consommateur. Mais les solutions proposées ne me conviennent pas.

Schématiquement voila ce que je fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Producteur{ do{ wait new data lock fichier Ecrit dans fichier. unlock fichier }while (end); } Consommateur{ do{ lock fichier lit 10 lignes unlock fichier Traitement des lignes Si traitement OK lock fichier Supprime les 10 lignes unlock fichier Fin si }while (end) }
Il me semble que ce code ne marche pas car il peut y avoir une race condition et un dead lock.

Il se résous en utilisant une sémaphore qui réveille le consommateur si il y a des données. Le consommateur traite donc des données seulement si le producteur le réveille.

Mais en fait ça ne me convient pas car le consommateur doit pouvoir traiter le fichier par block de 10 lignes sans attendre que le producteur ne lui mette de nouvelles données, sinon ma pile ne se dépile jamais complètement.

Je sais pas si je suis très clair ?

Avez-vous une idée pour résoudre mon problème ?

Est-ce qu'en utilisant des opérations atomiques comme pread et pwrite cela me permettrait d'évité d'utiliser des mutex et des sémaphores ?

Merci !

En fait c'était tout bête mon problème :oops:, il suffit de transformer le code en rajoutant une sémaphore qui prévient le consommateur quand de nouvelles données sont disponibles. Il faut que le consommateur lise le fichier dans son entier et mettre à jour toutes les 10 lignes le fichier. Une fois que tout le fichier est traité il se remet en attente du producteur.

Bon, il faut juste traiter les cas de synchronisation du fichier (ex: le producteur à rajouter des données alors que le consommateur n'a pas finis).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 Producteur{ do{ wait new data lock fichier Ecrit dans fichier. unlock fichier sem_post }while (end); } Consommateur{ do{ lock fichier lit tout le fichier dans data unlock fichier do{ Traitement d une ligne Si traitement KO lock fichier Met à jour avec les traitements OK unlock fichier Sortir Fin si Si 10 lignes traitées lock fichier Supprime les 10 lignes unlock fichier data -= 10 Fin si }while (data) sem_wait }while (end) }
C'est plus de l'algorithmie que du C mais qu'en pensez-vous ?