Mise à jour de la progression d'une tâche

Version imprimable

Bonjour,

Je vous explique mon petit problème :)

J'ai une liste contenant une grande quantité de messages:

Code:

std::deque<ProviderMessage*> pending_;

Et j'ai une classe Logic avec une méthode processMessages() qui se simplifie en:
Code:

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 void Logic::processMessages() { // Connect the addQuote signal to the addQuote slot to update GUI QObject::connect( this, SIGNAL( addQuote(const timestamp_t&, const price_t&, const quantity_t&, const price_t&, const quantity_t&) ), quotes_, SLOT ( addQuote(const timestamp_t&, const price_t&, const quantity_t&, const price_t&, const quantity_t&) ) ); // Connect the addTrade signal to the addTrade slot to update GUI QObject::connect( this, SIGNAL( addTrade(const timestamp_t&, const price_t&, const quantity_t&) ), trades_, SLOT ( addTrade(const timestamp_t&, const price_t&, const quantity_t&) ) ); // Connect the progress signal to the logicProgress slot to update the progress bar QObject::connect( this, SIGNAL( progress (datetime_t) ), simulation_, SLOT ( logicProgress(datetime_t) ) ); // For each pending message std::deque<ProviderMessage*>::iterator it = pendingMessages_.begin(); for (; it!=pendingMessages_.end(); ++it ) { // Emit message to update GUI switch ( (*it)->type() ) { case ProviderMessage::QUOTE: { const QuoteItem* quote = static_cast<const QuoteMessage*>(*it)->quote(); // Update GUI emit addQuote( quote->timestamp(), quote->bidPrice(), quote->bidQuantity(), quote->askPrice(), quote->askQuantity() ); // Update progress emit progress( quote->timestamp() ); break; } case ProviderMessage::TRADE: { const TradeItem* trade = static_cast<const TradeMessage*>(*it)->trade(); // Update GUI emit addTrade( trade->timestamp(), trade->price(), trade->quantity() ); // Update progress emit progress( trade->timestamp() ); break; } } } pendingMessages_.clear(); }
Le signal progress(datetime_t) est connecté à un slot logicProgress qui met à jour une barre de progression.
Les signaux addX() sont connectés à des modèles (des dérivés de QAbstractListModel) pour ajouter l'item et les visualiser dans des vues.

Cette méthode processMessages() est lancée dans un thread séparé du principal.

Si je commente les émissions de signaux d'update de la GUI ( addX() ) tout se passe bien: la barre de progression est mise-à-jour fréquemment.
Mais lorsque ces signaux sont envoyés, c'est comme si tous mes signaux de progress étaient relayés la fin de la pile des signaux. La barre de progression n'avance plus, jusqu'à ce que processMessage finisse et la *boum* ma barre de progression saute à 100%.

Je me doute que je n'ai pas du respecter/comprendre quelquechose avec les signaux :)
Ils sont pourtant bien sensés être ordonnés par ordre d'envoi ?

Après quelques tatonnements, ce qui semble causer le souci, c'est le slot d'ajout de données dans les modèles.

Voici leur forme:
Code:

1 2 3 4 5 6 7 8 void TradeListModel::addTrade( const timestamp_t& timestamp, const price_t& price, const quantity_t& quantity ) { beginInsertRows( QModelIndex(), 0, 0 ); items_.push_front( new TradeItem(timestamp, price, quantity) ); endInsertRows(); }
Plus particulièrement, ce sont les beginInsertRows/endInsertRows qui causent le problème.

Je viens de batcher les envois de messages, l'update de la GUI et de la progression se fait maintenant tous les 100 messages (plutot qu'à chaque message)

Ca donne donc quelquechose comme :

Code:

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
66
67
68
69
void Logic::processMessages()
{
  QObject::connect( this,    SIGNAL( addQuotes(const QuoteList&) ),
                    quotes_, SLOT  ( addQuotes(const QuoteList&) ) );
 
  QObject::connect( this,    SIGNAL( addTrades(const TradeList&) ),
                    trades_, SLOT  ( addTrades(const TradeList&) ) );
 
  QObject::connect( this,        SIGNAL( progress     (datetime_t) ),
                    simulation_, SLOT  ( logicProgress(datetime_t) ) );
 
  // Size of messages sent to the GUI to batch updates
  const static unsigned int batch_size = 100;
 
  QuoteList quoteList;
  TradeList tradeList;
 
  std::deque<ProviderMessage*>::iterator it = pendingMessages_.begin();
  for (; it!=pendingMessages_.end(); ++it )
  {
    switch ( (*it)->type() )
    {  
      case ProviderMessage::QUOTE:
      {
        const QuoteItem* quote = static_cast<const QuoteMessage*>(*it)->quote();
 
        quoteList << quote;
 
        if ( quoteList.size() >= batch_size )
        {
          emit progress( quote->timestamp() );
          emit addQuotes( quoteList );
          quoteList.clear();
        }
 
        break;
      }
      case ProviderMessage::TRADE:
      {
        const TradeItem* trade = static_cast<const TradeMessage*>(*it)->trade();
 
        tradeList << trade;
 
        if ( tradeList.size() >= batch_size )
        {
          emit progress( trade->timestamp() );
          emit addTrades( tradeList );
          tradeList.clear();
        }
 
        break;
      }
    }
  }
 
  if ( quoteList.size() > 0 )
  {
    emit addQuotes( quoteList );
    quoteList.clear();
  }
 
  if ( tradeList.size() > 0 )
  {
    emit addTrades( tradeList );
    tradeList.clear();
  }
 
  pendingMessages_.clear();
}

Code:

1
2
3
4
5
6
7
8
9
void TradeListModel::addTrades( const TradeList& list )
{
  beginInsertRows( QModelIndex(), 0, list.size()-1 );
 
  for (TradeList::const_iterator it = list.begin(); it!=list.end(); ++it )
    items_.push_front( new TradeItem( (*it)->timestamp(), (*it)->price(), (*it)->quantity() ) );
 
  endInsertRows();
}

Certes l'update est plus rapide, mais ca n'a rien changé au problème du _lag_ de mise-à-jour de la progress bar :(

14/12/2009, 21h51
yan

Citation:

Envoyé par NewbiZ

Certes l'update est plus rapide, mais ca n'a rien changé au problème du _lag_ de mise-à-jour de la progress bar :(

C'est a dire?
14/12/2009, 22h47
NewbiZ

Par update, je veux dire le temps de mise-à-jour des QListView.
100 ajouts de 1 million d'items, sont plus rapides que 100 millions d'ajouts d'1 item.

Je pense que le problème, c'est que ce qui prend du temps, ce n'est pas le dispatch que je fais dans le processMessages(), c'est l'insertion des items dans les modèles (et la mise-à-jour des vues). Et bien que l'appel de ces méthodes d'ajout soient passées par signaux depuis le thread de calcul, elles se font dans le thread principal de GUI, ce qui a pour conséquence la lenteur de rafraichissement de la barre de progression, et la perte de réponse des widgets.

Enfin, ce n'est que la conclusion que j'en tire, je ne connais pas assez Qt pour l'affirmer.

Si c'est ca, ca me pose un souci, puisque j'imagine (s'il vous plait détrompez moi :)) que les widgets Qt ne peuvent pas être updatés directement depuis un autre thread que le principal.
La question deviendrait donc "comment ajouter d'énormes quantités de données dans des widgets Qt sans que la GUI perde en réactivité".
14/12/2009, 23h17
yan

Citation:

Envoyé par NewbiZ

Enfin, ce n'est que la conclusion que j'en tire, je ne connais pas assez Qt pour l'affirmer.

Je pense que c'est bien cela. 1 million d'item cela commence a faire pas mal.

Citation:

Envoyé par NewbiZ

Si c'est ca, ca me pose un souci, puisque j'imagine (s'il vous plait détrompez moi :)) que les widgets Qt ne peuvent pas être updatés directement depuis un autre thread que le principal.

exactement

Citation:

Envoyé par NewbiZ

La question deviendrait donc "comment ajouter d'énormes quantités de données dans des widgets Qt sans que la GUI perde en réactivité".

En faite, cela dépend fortement de ce qu'affiche ta view. Par contre je suis etnné qu'il dit faire un update globale. Normalement le *view sont optimisé et ne s'occupe que des item ce qui sont affiché. Je vien de voir que tu fait items_.push_front. Es ce que faire un push_back est embêtant?
Es ce que c'est nécessaire d'updater le treeview aussi souvent?

Il me semble que c'est le endInsertRows(); qui provoque l'update. Peut être faire

Code:

beginInsertRows( QModelIndex(), 0, list.size()-1 );

avant le premier ajout
et

Code:

endInsertRows();

aprés le dernier ajout

Citation:

Par contre je suis etnné qu'il dit faire un update globale. Normalement le *view sont optimisé et ne s'occupe que des item ce qui sont affiché. Je vien de voir que tu fait items_.push_front. Es ce que faire un push_back est embêtant?

Ah, je me suis dit la même chose ! :) J'ai déjà tenté de rajouter les items dans la partie *masquée* de la vue, mais encore une fois, ca n'a fait que rendre les insertions plus rapides, mais la GUI reste toujours en partie bloquée, ainsi que la barre de progression.
Code:

1 2 3 4 5 6 7 8 9 void TradeListModel::addTrades( const TradeList& list ) { beginInsertRows( QModelIndex(), items_.size(), items_.size()+list.size()-1 ); for (TradeList::const_iterator it = list.begin(); it!=list.end(); ++it ) items_.push_back( new TradeItem( (*it)->timestamp(), (*it)->price(), (*it)->quantity() ) ); endInsertRows(); }
J'ai déjà essayé de jouer avec les xInsertRows(), mais Qt se plaint immdiatement que le modèle est corrompu :/

14/12/2009, 23h30
yan

Juste pour tester, tu pourrais appeler http://qt.developpez.com/doc/4.6-sna...#processevents dans le boucle for lors que tu ajoute tes items.
14/12/2009, 23h57
NewbiZ

Je viens de l'ajouter...
... et ca marche IMPECCABLE :ccool: !

Si tu avais quelques éclaircissements sur le pourquoi du comment, je suis preneur :)

Encore merci! Voilà deux jours que je tapotais sur "refresh" devant ce post, je commencais à désespérer.
15/12/2009, 09h34
yan

Citation:

Envoyé par NewbiZ

Je viens de l'ajouter...
... et ca marche IMPECCABLE :ccool: !

Si tu avais quelques éclaircissements sur le pourquoi du comment, je suis preneur :)

Encore merci! Voilà deux jours que je tapotais sur "refresh" devant ce post, je commencais à désespérer.

ok. Donc c'est bien l'ajout de la view qui bloque tous. Qu'es ce qu'il est sensé afficher??
Es tu sur d'avoir bien lancé le thread? et que c'est lui qui emet ton signal avec les item à rajouter?

sinon regarde
http://qt.developpez.com/faq/?page=qt4Gui#de-geler-ihm

Par contre, a chaque iteration, cela fait vraiment beaucoup.Ce qui est bizzare, c'est que la mise a jour devrais s'effectuer qua la fin de tes ajouts.

Pour la vue, elle est je pense assez classique, inspirée des exemples de Qt: J'ai un modèle de liste et je l'assigne à une QTreeView :

Code:

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
class TradeListModel : public QAbstractListModel
{
  Q_OBJECT
 
public:
  TradeListModel( QObject* parent=0 );
  ~TradeListModel();
 
public:
    int rowCount   ( const QModelIndex& parent=QModelIndex() ) const;
    int columnCount( const QModelIndex& parent=QModelIndex() ) const;
 
    QVariant data( const QModelIndex& index, int role ) const;
 
    QVariant headerData( int             section,
                         Qt::Orientation orientation,
                         int             role=Qt::DisplayRole ) const;
 
public slots:
  void addTrade ( const timestamp_t& timestamp,
                  const price_t&     price,
                  const quantity_t&  quantity );
  void addTrades( const TradeList&   list );
 
private:
    std::deque<TradeItem*> items_;
};

Code:

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
TradeListModel::TradeListModel( QObject* parent )
  : QAbstractListModel(parent)
{
}
 
TradeListModel::~TradeListModel()
{
  std::deque<TradeItem*>::iterator it = items_.begin();
  for (; it!=items_.end(); ++it )
    delete *it;
}
 
int TradeListModel::rowCount( const QModelIndex& parent ) const
{
  return items_.size();
}
 
int TradeListModel::columnCount( const QModelIndex& parent ) const
{
  return 3;
}
 
QVariant TradeListModel::data( const QModelIndex& index, int role ) const
{
  // sanity check
  if ( !index.isValid() )
    return QVariant();
 
  // row out of bounds
  if ( index.row()>=items_.size() )
    return QVariant();
 
  // unknown value
  if ( index.column()>2 )
    return QVariant();
 
  // Don't care of other roles
  if ( !(role==Qt::DisplayRole) )
    return QVariant();
 
  switch ( index.column() )
  {
    case 0 : return items_.at(index.row())->timestamp();
    case 1 : return items_.at(index.row())->price();
    case 2 : return items_.at(index.row())->quantity();
  };
}
 
QVariant TradeListModel::headerData( int             section,
                                     Qt::Orientation orientation,
                                     int             role ) const
{
  if ( role!=Qt::DisplayRole )
    return QVariant();
 
  switch (section)
  {
    case 0 : return QString( "Timestamp" );
    case 1 : return QString( "Price"     );
    case 2 : return QString( "Quantity"  );
  };
}
 
void TradeListModel::addTrade( const timestamp_t& timestamp,
                               const price_t&     price,
                               const quantity_t&  quantity )
{
  beginInsertRows( QModelIndex(), items_.size(), items_.size() );
 
  items_.push_back( new TradeItem(timestamp, price, quantity) );
 
  endInsertRows();
}
 
void TradeListModel::addTrades( const TradeList& list )
{
  beginInsertRows( QModelIndex(), items_.size(), items_.size()+list.size()-1 );
 
  for (TradeList::const_iterator it = list.begin(); it!=list.end(); ++it )
    items_.push_back( new TradeItem( (*it)->timestamp(),
                                     (*it)->price(), 
                                     (*it)->quantity() ) );
 
  endInsertRows();
}

Code:

1
2
3
QTreeView* list = new QTreeView;
list->setAlternatingRowColors( true );
list->setModel( new TradeListModel );