Qt performance - avoid crashing

Question

I have such problem with my application that´s running in real time. It´s getting values an plotting two graphs. Also is updating a few (8) QLabels and displaying them in window. The application should run for a very long time and processing data so I wanted to test it in faster regime and I set the sending values to the application for each 10ms. When I start the application everything works fine, but after some time QLabels stuck or plotting graphs stuck and in the end application crashes.

I would like to ask if 10ms is too fast for updating QLabels and graphs (QCustomPlot) and that is the reason of crashing the program or I need to search for the problem somewhere else?

void mainWnd::useDataFromPipe(double val) {

if(val<=*DOF) {
    FSOcounter=FSOcounter+1.0;

    lastRecievedFSO->saveValue(val);
    updateGraphMutex->lock();
    FSOvectorXshort->replace(1, FSOcounter);
    updateGraphMutex->unlock();

    if(!firstDataFSO()) {
        if(val>maximumRecievedFSO->loadValue()) maximumRecievedFSO->saveValue(val);
        else if(val<minimumRecievedFSO->loadValue()) minimumRecievedFSO->saveValue(val);
    }
    else {
       maximumRecievedFSO->saveValue(val);
       minimumRecievedFSO->saveValue(val);
    }
    numberOfRecievedValuesFSO->saveValue(numberOfRecievedValuesFSO->loadValue()+1.0);
}
else {
    RFcounter=RFcounter+1.0;

    lastRecievedRF->saveValue(val);
    updateGraphMutex->lock();
    RFvectorXshort->replace(1, RFcounter);
    updateGraphMutex->unlock();

    if(!firstDataRF()) {
        if(val>maximumRecievedRF->loadValue()) maximumRecievedRF->saveValue(val);
        else if(val<minimumRecievedRF->loadValue()) minimumRecievedRF->saveValue(val);
    }
    else {
       maximumRecievedRF->saveValue(val);
       minimumRecievedRF->saveValue(val);
    }
    numberOfRecievedValuesRF->saveValue(numberOfRecievedValuesRF->loadValue()+1.0);
}
}

where saveValue() and loadValue() are

void infoLine::saveValue(double val) {
*value=val;
valueLabel->setText(QString("<b>%1</b>").arg(val));
}
double infoLine::loadValue(void) {
return *value;
}

Answer 1

You're not "updating" the labels every 10ms, you're merely calling setText or similar methods on them every 10ms. The labels will be updated as dictated by how many events are in the event queue. As long as you "update" the labels by calling setText etc., you're OK - this should not be a problem.

A crash is usually due to a memory bug. A memory bug typically can be due to running out of memory, a double free, or access to deallocated memory.

What you describe seems like a memory bug due to running out of memory. The most trivial explanation is that you're leaking memory. That's an easy one - smart pointers (QScopedPointer and QSharedPointer) will help with that.

You may also not be leaking memory, but recursing too deeply if you indeed recurse into the event loop.

You may also be updating the widget(s) incorrectly, resulting in forced, repeated, expensive repaints that are not compressed into one repaint.

You'd need to show how you "update" the plot. While the labels are implemented correctly, and repeated calls to various QLabel setXxxx methods are cheap, the custom plot class may simply be implemented incorrectly.

The idiomatic, and indeed the only correct way of updating a widget in Qt is:

1. Set some data members.

2. Call update().

This is what QLabel::setText does internally, and it is what any other widget should be doing as well. This functionality should be exposed in a setXxxx-like method, and is an implementation detail, although an important one. The users of the widget don't need to be aware of it.

The update events are posted to the widget and are compressed, such that repeated updates without returning to the event loop result in only one repaint.

It's really hard to tell without seeing a self-contained, minimal example. By minimal I mean nothing that has no bearing on the issue should be left in.