Qt Quick Performance Improvements on 64-bit ARM

One of our major goals for Qt 5.9 LTS was to improve the performance and memory consumption compared to our previous long-term-support release Qt 5.6 LTS. In this blog post, I want to highlight the performance increase in modern embedded processors that support the 64-bit ARMv8 instruction set. The result: Today, QML performance is almost twice as high, and JavaScript performance is a whopping 18 times higher compared to Qt 5.6.3.

When Qt 5.9 LTS was launched, I wrote a blog post about Qt 5.9 performance, providing an overview of some of the areas with improved performance. These improvements benefit Qt users across all operating systems and processor architectures. The different processors and operating systems have unique characteristics that cause slight variations, but performance has practically always increased overall. In other words: With a new Qt version, you get more power out of an existing system. Performance improvements benefit both the users aiming to create an even fancier UI for their high-end system, as well as those who can now run Qt on lower-end hardware than before.

Modern embedded processors increasingly offer an ARMv8 instruction set for 64bits, which enables Qt to achieve a better performance than with a 32bit ARMv7. With Qt 5.9, you can gain major increases in QML and JavaScript performance with 64-bit ARMv8 processors, as it supports just-in-time compilation of QML code and also leverages other improvements in the QML Engine. Of course, performance has also been improved for the older 32bit ARMv7 processors, but especially the modern 64bit ARMv8 stand out. The measurements shown in this blog post were taken on Embedded Linux, but other operating systems (Android, QNX, …) exhibited similar levels of improvement.

Two good benchmarks for Qt Quick applications using QML and JavaScript are QML Bench and V8 Bench (note that V8 is just the name of the benchmark, not the engine we have in Qt currently). We recently conducted a series of measurements comparing the performance of the currently supported LTS versions, Qt 5.6.3 and Qt 5.9.5, running on the same 64bit ARMv8 processor and same distribution of embedded Linux.

First, let’s look at the comparison of JavaScript performance using the test sets of the V8 Bench:

The performance of every test set has improved significantly with Qt 5.9.5 averaging out at a whopping 18 times faster than Qt 5.6.3. This is mostly due to the addition of Just-In-Time (JIT) compilation support on 64bit ARMv8 processors in Qt 5.9.5. There are also other improvements that specifically leverage the capabilities of the new instruction set which enables JavaScript and QML to run much faster than in Qt 5.6.3.

Also massively improved are the Qt Quick Controls. See the comparison between QML Bench tests of Qt Quick Controls below:

Qt 5.6.3 offers Qt Quick Controls 1, which was mainly aimed at desktop use cases. As it is a very convenient set of functionalities, many like to use Qt Quick Controls 1 in embedded devices too, which can sometimes make achieving the needed performance challenging. For this reason, we developed Qt Quick Controls 2 with embedded systems in mind. It again offers greatly improved performance in Qt 5.9.5 compared to previous versions. If there are some challenges to get Qt Quick Controls 1 running smoothly on an embedded system, using Qt Quick Controls 2 instead will most likely fix that problem as it is almost 8 times faster on average.

The third and final graph in this post summarizes all other areas of QML Bench tests:

Each of these categories contains multiple tests, and the results in the different areas as such are not directly comparable with each other. In order to see the improvements of Qt 5.9.5 relative to Qt 5.6.3, the results are normalized to show the Qt 5.6.3 results as 100. The graphs show that the improvements to all categories are quite significant and should be clearly noticeable for practically any Qt Quick / QML application.

This blog post provided an overview of how much we have improved Qt Quick performance for 64bit ARMv8 processors since our previous Qt LTS release. Measured across all QML Bench tests that compared Qt 5.9.5 to Qt 5.6.3, QML performance was increased by 95% and JavaScript performance by a whopping 1785%. The actual performance gain of an application depends upon multiple things – especially what functionality it uses and how much. In practice, all functions are faster in Qt 5.9.5 than in Qt 5.6.3. In addition to improvements to the existing functionalities, Qt 5.9 also offers new performance-increasing functionalities that.

We are continuously improving, so expect the next LTS to be even faster than the previous one. Compared with Qt 5.9, the JavaScript performance of Qt 5.11 is over 20% higher (i.e. 22x faster than Qt 5.6.3), based on initial measurements of the Qt 5.11 Beta. Generic Qt Quick QML functionality is on a similar level as Qt 5.9 or slightly better in some areas. Similarly to Qt 5.9, we will continue to improve the performance in patch releases and towards the Qt 5.12 LTS. We monitor the performance constantly in order to detect possible regressions and fix those quickly. For a good overview of how we monitor the performance of Qt Quick, please check out Eskil’s post about Performance regression testing of Qt Quick. In addition to Qt Quick, we have automated performance tests for multiple other areas and are continuing to increase those numbers too. For the current test set and results, you can check the performance benchmarks at testsresults.qt.io.

5 comments

@Alex: Yes, for the most parts performance of Qt 5.10.1 is on roughly similar level as Qt 5.9.5 when compared to Qt 5.6.3. We focused into comparison of LTS versions in this post as comparing multiple versions would make the charts less readable.

Nice post. What’s up with the delegates_label.qml test in the Qt Quick Controls 1 vs 2 test though? How come that one was already so fast in QQC 1? (or conversely, how come it didn’t show that much speedup in QQC 2?).

From looking at the sourcec, I’d say that the reason is that Label in QQC1 is a very “thin” component in comparison with the rest of the controls import. It’s just a small wrapper around a Text item with some default property bindings, so it’s not particularly heavy to start with, which means there’s also less room for improvement when moving to QQC2 compared to many of the other controls, which have significantly more complexity in implementation.