Discussion :

[Kirozen]

Bonjour à tous,

Je développe actuellement un petit projet permettant d'effectuer des filtres/transformations sur une image.

J'ai pour l'instant un QWidget contenant un QPixmap qu'on appellera QImageWidget, une GUI, un manager de thread et une classe de thread de calcul contenant les opérations a effectuer sur l'image.

Le QImageWidget est intégré dans la GUI permettant d'afficher en temps réel l'image, le manager est lui-même threadé pour ne pas bloquer l'interactivité de la GUI (zoom, scrolling, boutons d'interface, ...) et il permet de gérer dynamiquement le nombre de threads, de générer des signaux start stop pause resume aux threads de calculs.
La thread de calcul reçoit l'image ainsi que la portion d'image à calculer et renvoie le résultat pour qu'il puisse être pris en compte pour la suite des calculs.

J'ai fréquemment des blocages et des plantages d'application dûs au retour de données par les threads de calcul.

Pensez-vous que cette façon de faire est la bonne?
Auriez-vous des pistes/solutions pour m'aider à obtenir un résultat correct?

Merci d'avance!

[yan]

Salut.

Pensez-vous que cette façon de faire est la bonne?

Ca me semble tout à fait correcte.

Auriez-vous des pistes/solutions pour m'aider à obtenir un résultat correct?

Utilise tu les signal/slot pour transmettre l'image entre la GUI et les threads?
as tu utilisé des pointeur pour le paramètre de tes signaux/slots?
Utilise tu des QImage dans les threads?

Sans bout de code ca va être difficile d'en dire plus...

[Kirozen]

Salut yan,

L'image est gérée par le manager, j'utilise des signaux pour la passer vers la GUI et vers les threads, les slots n'étant apparemment pas thread-safe.

L'image qui transite est effectivement un QImage.

j'ai mis le code source en fichiers attachés, plus celui du dessous et normalement y a tout le code utile :-)

Pour le moment je fais juste de la génération d'image avec une couleur aléatoire.

rendermanager.hpp

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
 
#ifndef RENDERERMANAGER_H
#define RENDERERMANAGER_H
 
#include <QMutex>
#include <QSize>
#include <QThread>
#include <QWaitCondition>
#include <QImage>
 
class RenderChild;
class Block;
 
class RendererManager : public QThread
{
    Q_OBJECT
 
public:
    RendererManager(QObject *parent = 0);
    ~RendererManager();
 
    void process(const size_t nOfThreads, const QImage& image);
 
public slots:
    void pauseProcess();
    void stopProcess();
    void incThreads();
    void decThreads();
    void refreshPixmap();
    void childFinished();
 
signals:
    void sendBlock(const Block &block);
    void manager_up(const QString& data);
    void renderedImage(const QImage image);
    void startChildsCalc();
 
protected:
    void run();
 
private:
    void initChilds(int nb);
    void firstAssignator();
 
private:
 
    QMutex mutex;
    QWaitCondition condition;
    bool terminate;
    bool running;
    bool pause;
    QImage image;
    int threadRndSeed;
    int currentline;
 
    QVector<RenderChild*> childs;
};
 
#endif

[Kirozen]

J'ai oublié de dire, dans le code on voit un signal sendblock, il est pas utilisé, c'est juste pour usage futur :-)

[yan]

J'ai rien vue de choquant.

Au lieu des lock et unlock, utilise des QMutexLocker.
Pourquoi y as t'il une QImage partagé entre plusieurs thread?
Si on copie ton code on peux le compiler et l'exécuter?

Connais tu QtConcurrent?
http://qt.developpez.com/doc/latest/qtconcurrent.html
Car ça semble très bien correspondre à ce que tu veux faire.

[Kirozen]

Pour la QImage partagée, en fait je sais pas pourquoi je fais ça
Je vois pas trop comment reconstruire l'image après.
Ce code n'est pas compilable et utilisable dans l'état actuel (du moins je ne pense pas).

Concernant QTConcurrent, je vois pas comment l'utiliser, j'ai vu aussi QThreadPool.

En fait c'est pour ça que j'ai fais ce post, si quelqu'un me donne un moyen efficace de faire ce que je veux faire, je suis preneur!

[yan]

Les QtConcurrent sont des algorithmes au-dessus d'un pool de thread adapté à la machine.
En gros il parcoure une liste d'objet et effectue une action à partir de celui là.

si quelqu'un me donne un moyen efficace de faire ce que je veux faire, je suis preneur!

Alors qu'es ce que tu veux faire?

[Kirozen]

Alors ce que je veux faire,

Par exemple pour générer du bruit (comme je fais actuellement).

Je veux pouvoir faire travailler plusieurs threads sur la même image (pixmap), afficher le résultat en temps réel et pouvoir gérer les threads dynamiquement (pouvoir les mettre en pause, les arrêter, en ajouter ou en supprimer).

Chaque thread ayant un petit morceau de l'image à traiter, il faut que le gestionnaire puisse réutiliser une thread qui a terminé son travail pour lui assigner une nouvelle tâche.

Est-ce plus clair ainsi?

[yan]

pouvoir les mettre en pause, les arrêter, en ajouter ou en supprimer

pourquoi tu veux faire toute ces action?
Pourquoi en ajouter et supprimer?

Vue que c'est une utilisation trés trés fréquente, je ne pense pas que QtConcurrent soit adapté.

Regarde QThreadPool qui devrais bien t'aider

[Kirozen]

Il semblerait que mon code fonctionne mieux en évitant de passer l'image à chaque thread :-)

Je vais mettre ce topic en résolu et peut-être prochainement en ouvrir un autre pour un autre soucis...

Merci pour votre aide!