Discussion :

[Baradhur]

Bonjour a tous!

Avant tout, je précise, je suis sur du linux, j'utilise les pthread POSIX, et je travail sur de l'embarquer, ce qui me coupe de la plupart des grosses librairies. Passons aux problèmes

J'ai des petits soucis de conception pour le programme que je suis en train de faire. Pour faire rapide, j'ai un processus principale (issu d'un fork, mais c'est pas l'essentiel ici) qui lance des threads avec chacun une tache bien definie. Jusque la, ca va. Ces threads sont en fait a la chaine, et doivent traiter des trames, puis les stacker dans la FIFO du prochain thread (pas toujours dans le même ordre).

Le truc, c'est que dans ma conception, je me suis dit que j'allais avoir une série de listes (qui représenteraient mes FIFO) dans mon thread principal, et que grâce a la mémoire partager entre threads, je pourrai faire des push_back pour remplir les bonnes fifos, qui seront pop_front dans le thread qui les traitent. (Je sais pas si je suis bien clair)

Je suis passe en phase de tests pour essayer de faire fonctionner l'ensemble. Et je me retrouve avec des gros problèmes pour faire passer mes listes entre mes threads! En effet, on ne peut faire passer qu'un argument a la fonction a exécuter a la création du thread (pthread_create), et ca me bloque énormément (sans compter les problèmes entrainer par l'obligation de passer par du void*).
Je dois surement m'y prendre très mal... J'ai trouver très peu de doc sur la communication inter-thread linux pour m'orienter.


Est ce que quelqu'un serait susceptible de me donner des pistes pour faire communiquer plus facilement mes threads? Un tuto, une lib vraiment légère?
Je suis preneur de n'importe quelles aides ou infos que vous pourriez me donner!

Merci d'avance!

(Si vous voyez des fautes de francais aussi, corrigez moi, j'essaye de plus en faire ^^)

[NeoKript]

Salut,

En effet, tu ne peux faire passer qu'un seul argument lorsque tu crée un thread, mais ça ne pause aucun soucis car tu peux très bien passer une structure, une classe...

D'après ce que je comprend de ton problème je pense que le mieux serait de faire une classe "Liste" par exemple qui contient un conteneur (std::vector ou autre selon ton besoin) et tu défini des méthodes Thread-Safe push pop etc..

Pour cela dans ta classe tu déclare un pthread_mutex, que tu vérouille quand tu rentre dans une méthode et que tu libères quand tu en sort.

Ainsi dans tes threads tu fait passer un pointeur sur cette classe, et tu peux faire toutes les opérations que tu veux sans soucis.

J'espère avoir bien saisis ton problème.

Cordialement,
NeoKript

[Baradhur]

Ce serait une solution, en effet! Et que penserais tu de declarer les std::list en global, et de locker leur utilisation avec les mutex? Je sens qu'il y a un danger a faire comme ca, mais ca pourrait aussi marcher, non?

[NeoKript]

C'est une solution envisageable..

Mais je pense qu'elle est en effet plus dangereuse et puis je n'aime pas trop les variables globales, tant qu'on peut éviter vaut mieux le faire.

Surtout que si tu déclare ta variable en globale, si tu as qu'une liste ça va encore mais si tu en a plusieurs tu va avoir 2 variables globales par liste (une pour le mutex et une pour la liste)...

Vu que d'après ce que tu dis, tu à plusieurs listes, je penses que le mieux est de faire une classe.

[Baradhur]

Apres le truc, c'est que les threads sont lancer pour longtemps. J'ai un controller, puis je lance 4 thread, qui vont se faire passer des trames entre eux, avec une FIFO (list) pour chaque thread, pour ne perdre aucune information.

Chaque thread doit aller chercher une trame dans sa FIFO, la traiter, et l'envoyer dans la FIFO du bon thread pour continuer le traitement (ca serait plus clair avec un schema). Et ca jusqu'a ce que la trame soit envoyer a un autre processus.

Dans ce modele la, j'ai un peu du mal a voir comment je vais pouvoir me faire passer ma classe de traitement de liste, et que les thread fonctionne entre eux de manière dynamique. Etant donner qu'une fois que les thread sont lancer, il font leurs traitements en continu, sans repasser par le controller.

C'est un cas d'utilisation un peu particulier, par ce qu'on lance pas un thread pour continuer tranquil sur le thread principal, mais on a un thread principale qui lance les threads de traitements et qui verifie que tout ce passe bien. Il ne fait pas ou peu de traitement lui meme, en dehors des threads qu'il lance.

Je veux bien un peu plus de details sur comment tu ferais ^^ Ou d'autres personnes, si jamais

Merci pour les reponses en tout cas!

[NeoKript]

Alors en fait si j'ai bien compris, ton thread principal lance plusieurs threads, chaque thread est dédié à une tâche précise et donc une trame est par exemple traitée dans le premier threads, une fois que le threads à traiter la trame il l'envoi au thread 2 qui à son tour traite la trame...Etc.. Et ce jusqu'à que la trame soit envoyer à un autre procesus ? Je suppose qu'une trame c'est un buffer de char ?

C'est ça dans l'idée ?

Du coup si c'est ça, il faut seulement faire passer la trame d'un thread à l'autre,
une méthode simple consisterait :
- Avoir une classe pour chaque traitement, toute les classes de traitements aurait une FIFO contenant les trames à traiter ainsi qu'un Mutex pour que la communication soit Thread-Safe, ainsi tu aurait juste une méthode pour ajouter une trame à la FIFO.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class Traitment
{
    private:
       pthread_mutex_t _mutex;
       std::vector<String> _fifo;
 
    public:
       void   AddTrame(String Trame);
};

Donc ça, ca pourrait être un exemple de classe type.
- Avoir une classe unique (utiliser le Design Patter Singleton). Cette classe gérerait les threads, c'est à dire qu'elle créerai les classes de traitement et les exécuterait dans un Thread, elle stockerait également les pointeurs vers les classes de traitement dans une Map par exemple au moins tu pourrais faire quelque chose comme ca MaClasseSingleton::Instance.DispatchTrame(String Trame, String TreatmentUnit); En dans cette méthode, tu aurais juste à faire this._map[TreatmentUnit].AddTrame(Trame).

Je ne sais pas si je suis très clair.

Mais ainsi à partir de n'importe quel thread (classe de traitment), tu pourrais communiquer avec n'importe quel autre, ajouter des élément dans ça FIFO etc...

Si tu ne comprend pas dis moi, je te ferais un exemple si j'ai le temps.