Discussion :

[ymoreau]

Bonjour,
Désolé de ce titre un peu vague. J'ai lu la doc (et le tuto de yan) sur les threads, mais jamais pratiqué. Je me demande ce qui est le plus simple dans mon cas :
J'ai un traitement à faire sur plusieurs fichiers, qui modifiera une classe au fur et à mesure de l'avancement, et lira/écrira des données dans une autre classe (interfaçant une base de données). Le traitement a ses propres données temporaires et peut être parallélisé, par contre l'accès aux autres classes non, leurs données sont partagées.
Je voudrais utiliser au maximum les capacités de la machine (potentiellement un serveur avec beaucoup de coeurs), et lancer autant de traitements en parallèle que possible.

QtConcurrent semble le plus simple à utiliser, pour gérer automatiquement le nombre de threads à créer etc. Mais je ne comprends pas bien comment créer une ressource commune.
Donc je me dis que ça n'est pas assez adaptable, et qu'il faut plutôt partir sur QThreadPool, créer mes classes de ressources avec QMutex, puis gérer les appels au mutex dans le traitement héritant de QRunnable.

Si quelqu'un avec de l'expérience pouvait brièvement m'indiquer la meilleure voie à suivre, je saurais dans quelle direction me lancer ^^
merci d'avance !

[yan]

Salut

J'ai un traitement à faire sur plusieurs fichiers, qui modifiera une classe au fur et à mesure de l'avancement, et lira/écrira des données dans une autre classe (interfaçant une base de données). Le traitement a ses propres données temporaires et peut être parallélisé, par contre l'accès aux autres classes non, leurs données sont partagées

Peut être créer un QObject par module de traitement et les répartir entre plusieur QThread? Ainsi la communication se fera par les Signal/Slot. Et tu pourra répartir les charges entre différent QThread (et ainsi limiter le nombre de thread).

Ton problème ressemble à un problème de producteur/commateur :
http://qt-project.org/doc/qt-4.8/thr...emaphores.html
http://qt-project.org/doc/qt-4.8/thr...onditions.html

Je voudrais utiliser au maximum les capacités de la machine (potentiellement un serveur avec beaucoup de coeurs), et lancer autant de traitements en parallèle que possible.

Ca va dépendre de ce que tu entend par parallèle.
Si ce sont de petit traitement, tu peut généralement les regrouper dans un même thread.
Si se sont de gros traitement, un nombre de thread au dessus du nombre de coeurs ralentira certainement tous les traitements parallèle.

[ymoreau]

Merci de ta réponse !
En fait il n'y qu'un (potentiellement gros) traitement qui travaille sur un fichier, il ne peut pas être subdivisé. Par contre, je dois traiter beaucoup de fichiers et j'aimerais dupliquer le traitement sur plusieurs threads où chaque instance s'occuperait de son propre fichier.
Donc si j'ai bien compris, il n'y a que des producteurs qui ne dépendent pas les uns des autres, mais qui ont besoin de ces ressources communes (totalement indépendantes de l'état du traitement). En pratique lire des infos dans un tampon partagé, et rajouter quelques infos à ce tampon quand il y en a de nouvelles. Pour le reste chaque instance de traitement lit son propre fichier, et écrit ses propre données de résultat.

Et je comptais justement créer autant de threads que de coeurs disponibles (moins un pour la boucle principale d'évènements).

[yan]

Par contre, je dois traiter beaucoup de fichiers et j'aimerais dupliquer le traitement sur plusieurs threads où chaque instance s'occuperait de son propre fichier.

C'est à dire?

[ymoreau]

Disons une fonction prenant un nom de fichier en argument, créant des données temporaires avec le contenu du fichier, puis envoyant tout ça dans une base de données. On peut appeler cette fonction plusieurs fois en parallèle avec à chaque fois un des fichiers de la liste à traiter, puisque les données d'entrée et les données sortantes sont propre à chaque fichier.
Sauf que ce traitement va aussi avoir besoin de données communes à tous les fichiers, en lecture et parfois en écriture.

Donc en gros, j'aurais une ressource commune avec un mutex, et plusieurs instances de la fonction de traitement.

[yan]

Pour la lecture des fichiers, c'est surtout l’accès du fichier qui va prendre du temps. Donc tu ne va pas pouvoir beaucoup (et se sera surement le contraire) accélérer la lecture en utilisant plusieurs thread.

Si j'ai bien compris, tu as un module qui ne fait que lire un fichier pour récupéré des données et un module qui exploite les données lue.
C'est bien cela?


pourquoi?

données communes à tous les fichiers

En alternative au mutex, regarde les readwritelock
http://qt-project.org/doc/qt-4.8/qreadwritelock.html

Et au lieu d'utiliser les mutex directement regarde :
http://qt-project.org/doc/qt-4.8/qmutexlocker.html
http://qt-project.org/doc/qt-4.8/qreadlocker.html
http://qt-project.org/doc/qt-4.8/qwritelocker.html