Qwt 6.0.1 three times slower than 5.2.0

[Spitfire]

Hello,

I'm new to the forum so I would like to take this opportunity and say "Hi" to everyone.

I'm using Qt for several years now but I'm fairly new to Qwt.

At the moment I'm evaluating if it's worth moving to Qwt 6.0.1 from 5.2.0.
6.0.1 has many new and interesting features but there's a problem.
I was able to plot 2 million points in less than 1500ms but after moving to 6.0.1 the same operation takes 5000ms+!

Quick look at what's going on revealed that using QPainter:drawPolyline() in the float version seems to kill the performance (forcing qwt to use int version takes 2000ms to plot 2 million points).

Is there a way to switch qwt to use integers?
I think I know the answer, so I'll follow up with another question - why qwt is using now floats when the performance is so much poorer?

Is there anything I could do to improve the performance (except messing with qwt source)?

Best Regards!

[Uwe]

... why qwt is using now floats

Because of backends, that are float ( today PDF/SVG ) based. The main use case is PDF, where you can zoom in/out later in the PDF viewer seeing differences between points, that are mapped to the same position in default resolution.

Quick look at what's going on revealed that using QPainter:drawPolyline() in the float version seems to kill the performance (forcing qwt to use int version takes 2000ms to plot 2 million points).!

Please do more than a quick look - there are a couple of other differences between 5.2 and 6.0. F.e the default setting for polygon clipping is enabled on Qwt 6.

• Can you isolate the issue to a small demo application, where you paint your points with QPainter to a QWidget ?
• If there is really a major difference between painting QPolygon and QPolygonF I would expect to have an effect that is platform specific ?

Is there a way to switch qwt to use integers?

In the end Qt has to map the floats to integers on platforms, where the graphics system is integer based. Because this rounding is often different to what Qwt objects need almost all Qwt plot items check the graphics system first and does the rounding itself. So QwtPlotCurve has in fact integers in most cases and it would be no big deal to use QPolygon instead of QPolygonF there.

Is there anything I could do to improve the performance (except messing with qwt source)?

IMHO even 2000ms is poor.

The common way to improve performance for curves with many points is to implement different levels of detail. This has been discussed many times in this forum - check the archive.

Uwe

[Spitfire]

Hey Uwe,
Thanks for so quick reply.

I know that there's more changes than this. Like instant paint being set to false by default but none of them (I had polygon clipping enabled already) seems to affect performance in the way using floats does.

To get more information I've followed your suggestion that the problem is platform dependent.
Everything I've said till now was based on 64bit Windows 7 os.
I've build the same app on 64bit Ubuntu (same box) and it works much faster. Plotting 2m points with Qwt 5.2.0 takes 250ms.
Qwt 6.0.1 is still slower but the difference is not that noticeable - the same 2m points took 400ms to plot.
I wish I could make it work like that on windows!

I will test it further like you mentioned, but for now you can see what I mean by altering static inline void drawPolyline() function in qwt_painter.cpp to look just like this:

{
        QTime tt;
        QVector<QPoint> p;
 
        for(int i = 0; i < pointCount; ++i)
            p.append(points[i].toPoint());
 
        tt.start();
        painter->drawPolyline( points, pointCount );
        std::cout << "Float draw took " << tt.elapsed() << "ms to complete." << std::endl;
 
        tt.restart();
        painter->drawPolyline( p.data(), pointCount );
        std::cout << "Int draw took " << tt.elapsed() << "ms to complete." << std::endl;
}

{
        QTime tt;
        QVector<QPoint> p;

        for(int i = 0; i < pointCount; ++i)
            p.append(points[i].toPoint());

        tt.start();
        painter->drawPolyline( points, pointCount );
        std::cout << "Float draw took " << tt.elapsed() << "ms to complete." << std::endl;

        tt.restart();
        painter->drawPolyline( p.data(), pointCount );
        std::cout << "Int draw took " << tt.elapsed() << "ms to complete." << std::endl;
}

To copy to clipboard, switch view to plain text mode 

In my case rendering 2m points on w7 yelds this output:

Float draw took 3009ms to complete.
Int draw took 1199ms to complete.

Float draw took 3009ms to complete.
Int draw took 1199ms to complete.

To copy to clipboard, switch view to plain text mode 

Do you have any suggestions how to speed up rendering on windows (except level of details you've already mentioned)?
5.2.0 speed was acceptable where 6.0.1 is not user friendly at all.

Cheers!

[Uwe]

Like instant paint being set to false by default but none of them (I had polygon clipping enabled already) seems to affect performance in the way using floats does.

Well polygon clipping improves performance significantly, when there is something to clip. Guess in your case this is not true ( as long as you don't zoom in/out ), so you might want to disable polygon clipping. AFAIR there was another optimization in Qwt 5.x, that drops points when they are mapped to the same position as its predecessor, what does make sense for integer coordinates only.

I've build the same app on 64bit Ubuntu (same box) and it works much faster. Plotting 2m points with Qwt 5.2.0 takes 250ms.
Qwt 6.0.1 is still slower but the difference is not that noticeable - the same 2m points took 400ms to plot.
I wish I could make it work like that on windows!

Well with X11 painting is done asynchronously from the X server - so your numbers might compare apples and eggs.
But the time spent on the X server doesn't depend on doubles or ints - so the overhead of 150 ms is an interesting value.

When you start your application with "-graphicssystem raster" I would expect to see similar results on Ubuntu like on Windows ?

Do you have any suggestions how to speed up rendering on windows (except level of details you've already mentioned)?
5.2.0 speed was acceptable where 6.0.1 is not user friendly at all.

Of course Qwt ( not application ! ) code is where workarounds should to be added - but in the end it is a Qt problem and should be identified and maybe fixed there too. A small demo ( Qt only ) demonstrating the issue is always required.

At the moment there are a couple of facts missing:

• Qt version
• QPen attributes used
• QPainter render hints
• ...

Uwe

[Spitfire]

I'm using Qt 4.6.3,
Painter and pen settings are default (QPainter::TextAntialiasing, pen solid line, 1px black).

When I've launched the app on Ubuntu with -graphicssystem raster both versions are slower, but not even close to what's happening on windows.
5.2.0 plots 2m points in 340ms (as oposite to 250ms), 6.0.1 plots 2m points in 770ms (as opposite to 400ms).

I'll take your suggestion and tomorrow I'll write simple pure Qt app to verify if the issue lies with Qt or not and post it here.

Anyway, it may be worth considering adding a way of selecting which rendering system to use (int or double) as not everybody (for example me ) needs double precision.

I'll keep you updated.

[Uwe]

Painter and pen settings are default (QPainter::TextAntialiasing, pen solid line, 1px black).

The default is a pen width of 0 - a pen width of 1 is running into a different render path and might be significantly slower,

Uwe

[Spitfire]

I've done simple Qt example of painting using float and integers (attached) and on windows - the results is the same.
Floats are dead slow.

I did some search through Qt bug database and I found an issue complaining about drawpolyline being slow with antialiasing, but it's not the case here.

Any chances of getting a way of using ints instead of doubles for drawing in Qwt 6.x.x?
I can't see any other way of making it any faster

[Uwe]

Do you have a similar effects on 32bit systems - and of course with Qt 4.7.x ?

Uwe

[Spitfire]

I don't have access to any 32bit system at the moment, but I'll check it over the weekend and let you know.

[Uwe]

I've done simple Qt example of painting using float and integers (attached) and on windows - the results is the same.

I checked your code on my box ( Linux/X11, Qt 4.7.3 ):

• With basic X11 using floats is significantly faster ( about 10-30 % )
• Enabling the raster paint engine ( -graphicssystem raster ) I can confirm that doubles are much slower ( about 200-250 % )

So the "right" solution means obviously more than simply using integers instead of floats.

I will check the code of the raster paint engine why it performs so bad for floats.

Uwe

[Spitfire]

I've tested 32bit Windows XP box.

The problem is the same, with 5.2.0 plot is rendered in 1700ms, with 6.0.1 it takes 5600ms.

Let me know if you find anything interesting.
Cheers!

[Uwe]

In SVN trunk ( Qwt 6.1 ) QwtPlotCurve tries to use QPolygon instead of QPolygonF ( depending on various parameters ).

If you don't want to have this optimization you can enable the new flag QwtPlotItem::RenderFloats. Like expected setting this flag slows down the frame rate of the refreshtest example, when using the raster graphics system.

Uwe

[Uwe]

Just one more hint: in Qwt 5.2 was a flag QwtPlotCurve::PaintFiltered that removes points that are mapped to the same position as their predecessor. As long as your samples are not only noise it should have a much bigger impact on the performance than the QPolygon/QPolygonF flag.

I have reintroduced this optimization to Qwt 6.1 ( QwtPlotCurve::FilterPoints ). In situations, where the curve is rendered to an integer based paint engine ( all beside Svg and Pdf ) I would expect, that it will reduce the polygon heavily for a 2 million point series.

You can check the refreshtest example to see its effect.

Uwe

[Spitfire]

That's great to hear.

I'll grab 6.1 and build my project against it.

I'll let you know if everything works fine.

Thanks!

The QwtPlotCurve::FilterPoints flags speeds up everything very nicely but the algorithm seems to lose sudden peaks in the graph (see attached example - the same curve with QwtPlotCurve::FilterPoints enabled and disabled).

On windows box 6.1 is still slower than 5.2 but the difference is not that big now. Now it takes around 2500ms to plot 2m points.

X values on my plots are always indexes which translate to time. I did some work on algorithm that takes all points that would be rendered into one pixel wide column on the screen and creates a line out of it.
Then it renders all the lines on the screen. In worst case there will be as many lines as there is horizontal pixels on the screen.
This way rendering 2M points takes ~100ms including running the algorithm, ~250ms for 5M and ~500ms for 10M points with no loses to the details like sudden, short lived peaks (see attachment).

If you're interested I can post the code here.