Discussion :

[mitmat]

Bonjour,

J'ai un soucis avec l'utilisation des conditions et des mutex. J'ai isolé le problème sous la forme du programme suivant :

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
 
#include "SDL.h"
#include "SDL_thread.h"
 
static SDL_mutex * mutex2;
static SDL_cond * cond;
static SDL_Thread * cu;
static SDL_mutex * mutex1;
static bool update = false;
 
/*
 * Cette focntion demande et attend une mise à jour.
 */
static int demandeMaj(void* unused){
  while (1){
    SDL_mutexP(mutex1);
    SDL_mutexP(mutex2);
    update = true; /* Demander la mise à jour */
    SDL_CondWait(cond, mutex2); /* attendre la mise à jour */
    SDL_mutexV(mutex2);
    SDL_mutexV(mutex1);
  }
  return 0;
}
 
/*
 * Cette fonction réalise une mise à jour d'un ensemble de donnée si elle a été
 * demandé
 */
static int maj(void* unused){
  while (1){
    SDL_mutexP(mutex2);
    /* Vérifier si une mise à jour est nécessaire */
    if (update){
      update = false;
      SDL_Delay(100); /* symbolise le temps pris par la mise à jour */
      SDL_CondSignal(cond); /* indiquer que la mise à jour est terminée */
    }
    SDL_mutexV(mutex2);
  }
  return 0;
}
 
int main() {
  mutex2 = SDL_CreateMutex();
  cond = SDL_CreateCond();
  mutex1 = SDL_CreateMutex();
 
  SDL_Thread * th1 = SDL_CreateThread(demandeMaj, NULL);
  SDL_Thread * th2 = SDL_CreateThread(maj, NULL);
 
  SDL_Delay(1000);
 
  /* Effectuer un traitement particulier uniquement lorsque "demandeMaj" n'est
   * pas en synchronisation avec "maj" */
  SDL_mutexP(mutex1);
  printf("un traitement particulier\n");
  SDL_mutexV(mutex1);
 
  return 0;
}

En gros je souhaite que 2 threads se synchronisent par l'intermédiaire d'une condition (qui utilise "mutex2") et que le programme principal effectue un traitement particulier uniquement lorsque les 2 threads ne sont pas synchronisés (d'où l'utilisation de "mutex1").
Le problème est que le programme principal n'arrive pas à prendre le mutex1 et donc n'affiche jamais "un traitement particulier". Or, si je commente le "SDL_CondWait(cond, mutex2);" et le "SDL_CondSignal(cond);" (ce qui n'est pas correct car les 2 threads n'ont plus de rdv) alors le main parvient à prendre le mutex1 et affiche le message.
Comment ce fait-il que la présence de la condition perturbe le mutex1?
Ai-je fait une erreur? Est-ce un bug de la SDL?
Comment faire pour maintenir le Rdv tout en le protégeant du programme principal?

Merci d'avance pour vos réponses...

[fearyourself]

Cond pose un problème car la l'appel à SDL_CondSignal va reveiller ton premier thread. Du coup, il reprend la main sachant qu'il a du coup un lock sur les deux mutex.

(D'ailleurs je me demande si tu le fais bien. En principe, sur le réveil d'une condition, il est supposé reprendre le contrôle du mutex mais ton thread 2 fait le unlock qu'après).

Ca veut dire que le thread principal ne pourra pas prendre la main à ce moment là. Ensuite, le thread 1 relache tout et tente tout de suite de reprendre la main sur le mutex1.

Du coup, ton main n'arrivera qu'à prendre la main si l'OS coupe le premier thread entre le unlock et le lock ce qui est peu probable.

Tu peux ajouter un petit SDL_Delay à la fin de la boucle pour forcer le premier thread a s'endormir un peu. Cela donnera l'occasion à ton main de reprendre la main de temps en temps (sachant que le thread 2 attend aussi, faudra donc attendre que c'est le main qui soit sélectionné).

Jc

[mitmat]

Tout d'abord merci pour tes réponses.

Cond pose un problème car la l'appel à SDL_CondSignal va reveiller ton premier thread. Du coup, il reprend la main sachant qu'il a du coup un lock sur les deux mutex.

(D'ailleurs je me demande si tu le fais bien. En principe, sur le réveil d'une condition, il est supposé reprendre le contrôle du mutex mais ton thread 2 fait le unlock qu'après).

En effet le thread 1 ne reprend la main que quand le thread 2 a fait son unlock (mais celà fonctionne correctement)

... Ensuite, le thread 1 relache tout et tente tout de suite de reprendre la main sur le mutex1.

Du coup, ton main n'arrivera qu'à prendre la main si l'OS coupe le premier thread entre le unlock et le lock ce qui est peu probable.

Cela n'arrive que s'il y a le "SDL_CondWait" dans le thread 1. Si tu le commentes, dans la section critique le thread 1 possède toujours les 2 mutex, puis relache tout et tente tout de suite de reprendre la main... mais là le main arrive à son tour à prendre le mutex.
Je ne comprend pas pourquoi l'utilisation de "SDL_CondWait" modifie la priorité du thread 1 sur le mutex 1 par rapport au main...

Tu peux ajouter un petit SDL_Delay

J'avais trouvé cette solution mais ça ne me plait pas trop (en théorie il ne devrait pas en avoir besoin)

[fearyourself]

Je ne comprend pas pourquoi l'utilisation de "SDL_CondWait" modifie la priorité du thread 1 sur le mutex 1 par rapport au main...

Ce n'est pas l'utilisation de SDL_CondWait qui pose problème mais SDL_CondSignal. Puisque tu redonnes explicitement la main au thread 1. Une solution serait de faire un SDL_CondSignal sur le mutex1 et laisser le main faire un SDL_CondWait sur ce mutex.

Jc

[mitmat]

Bon bin je vais utiliser un SDL_Delay pour faire une tempo, c'est le plus simple je pense.

Merci pour tes réponses...