Discussion :

[chicorico]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[imperio]

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 ^^.

[chicorico]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[mith06]

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?

@+

[chicorico]

Oui.

[mith06]

voila comment j'image le schmilblick :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

[chicorico]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?