Qt-Leistung messen

Ich beschloss, die Artikelserie über das Aurora-Betriebssystem (bis vor kurzem Sailfish genannt) fortzusetzen. Während der Zeit, in der ich mit diesem Betriebssystem arbeite, habe ich verschiedene Beobachtungen gesammelt, die sich auf die Leistung von Anwendungen auf Qt und dem gesamten System beziehen, da es mit einer Vielzahl von Geräten wie einem Weihnachtsbaum aufgehängt ist. Ich bemerke all die kleinen Dinge beim Start. Ich denke, dass dies für Kollegen interessant und nützlich sein kann, die auch mit Qt arbeiten (oder bald arbeiten werden). Schlagen Sie vor, dass Sie mehr testen können.



Ich programmiere in Qt und diskutiere oft mit Kollegen, iOS-Entwicklern, die Ähnlichkeiten, Unterschiede und Vorteile von Ansätzen. Irgendwann beschlossen wir immer noch, von Worten zu Taten zu wechseln und Messungen vorzunehmen. Wir haben keinen Android-Programmierer gefunden, der bereit war, an unserer Unterhaltung teilzunehmen. Ein Vergleich mit der Teilnahme von Zahlen und Tabellen ist daher nur für Swift und C ++ möglich.

Ich möchte Sie daran erinnern, dass Qt / C ++ seinen Speicherverwaltungsmechanismus nicht auferlegt, und der Benutzer selbst löst dieses Problem im Rahmen der in C ++ verfügbaren Funktionen, während in Swift die Referenzzählung verwendet wird, und in Java - einem Garbage Collector. Somit hat der Programmierer die Möglichkeit, effizienter mit dem Speicher zu interagieren. Um eine http-Anfrage zu senden oder Daten aus einer Datenbank zu lesen, stützt sich Qt auf seine eigenen Stärken und verwendet nicht die vom Betriebssystem bereitgestellten vorgefertigten Frameworks. Ausnahmen - Interaktion mit der Tastatur, Zeichnen des Anwendungsstartfensters, Anzeigen von Benachrichtigungen und anderen Dingen.

Test 1

Zunächst haben wir beschlossen, einen einfachen Algorithmus (das Sieb von Eratosthenes) zu schreiben, ihn mit großen Zahlen auszuführen und die Berechnungszeit zu vergleichen. Auf dem iPhone 7 gestartet.

Schnelles Programm:

swift // // ViewController.swift // Eratosthenes // // Created by Dmitry Shadrin on 22/11/2018. // Copyright 2018 Digital Design. All rights reserved. // import UIKit class ViewController: UIViewController { @IBOutlet weak var digitTextField: UITextField! @IBOutlet weak var timeLabel: UILabel! @IBAction func startAction(_ sender: UIButton) { guard let text = digitTextField.text, let number = Int(text) else { return } prime(n: number) } func prime(n: Int) { let startTime = DispatchTime.now() let _ = PrimeSequence(upTo: n) .reduce(into: [], { $0.append($1) }) //      let endTime = DispatchTime.now() let time = (endTime.uptimeNanoseconds - startTime.uptimeNanoseconds) timeLabel.text = "\(time)" } } public struct PrimeSequence: Sequence { private let iterator: AnyIterator<Int> public init(upTo limit: Int) { self.iterator = AnyIterator(EratosthenesIterator(upTo: limit)) } public func makeIterator() -> AnyIterator<Int> { return iterator } } private struct EratosthenesIterator: IteratorProtocol { let n: Int var composite: [Bool] var current = 2 init(upTo n: Int) { self.n = n self.composite = [Bool](repeating: false, count: n + 1) } mutating func next() -> Int? { while current <= self.n { if !composite[current] { let prime = current for multiple in stride(from: current * current, through: self.n, by: current) { composite[multiple] = true } current += 1 return prime } current += 1 } return nil } } 

Ich werde nicht im Detail auf den Code eingehen, das lineare Eratosthenes ist für das Verständnis nicht offensichtlich, insbesondere wenn eine der Sprachen Ihnen nicht vertraut ist. Hier ist ein Link mit einer Beschreibung: https://e-maxx.ru/algo/prime_sieve_linear , die interessiert sind, können auf Ehrlichkeit prüfen. Übrigens stellte sich heraus, dass die schnelle Version in den kleinen Dingen etwas optimierter war (Sie können danach suchen), was die Plus-Version nicht daran hinderte, die Leistung zu gewinnen.

Qt-Programm:

 #include "eratosthenes.h" #include <stdio.h> #include <stdlib.h> #include <time.h> #include <QVector> #include <QDebug> #include <vector> #include <cmath> Eratosthenes::Eratosthenes(QObject *parent) { time = 0; } void Eratosthenes::qtFunction(int n) { clock_t start, end; start = clock(); std::vector<int> lp = std::vector<int>(n + 1, 0); std::vector<int> pr; //       pr.reserve(std::sqrt(n) / 2); for (int i = 2; i <= n; ++i) { if (lp[i] == 0) { lp[i] = i; pr.emplace_back(i); } for (int j = 0; j < pr.size() && pr[j] <= lp[i] && i * pr[j] <= n; ++j) { lp[i * pr[j]] = pr[j]; } } end = clock(); time = (end - start) / (double)CLOCKS_PER_SEC; pTimeChanged(); qDebug() << "  " << pr.size() << "" << time; } 

Führen Sie das Programm aus. Anwendungen haben ein Feld zur Eingabe der Nummer n, eine Startschaltfläche und ein Feld mit einer Gesamtzeit:


Schnell - links, Qt - rechts.

Ergebnis. Ich werde eine Maßtabelle für verschiedene n und zu verschiedenen Zeitpunkten geben:

Wie Sie sehen können, ist eine C ++ - Anwendung etwa 1,5-mal schneller als eine native Anwendung mit identischen Algorithmen.

Test 2

Natürlich ist das Rechnen im Kontext mobiler Anwendungen eine wichtige Sache, aber bei weitem nicht die einzige. Aus diesem Grund haben wir eine ListView erstellt, die aus 1000 Elementen besteht, von denen jedes Text und ein Bild enthält, um die Geschwindigkeit des Renderns grafischer Elemente zu überprüfen. Unten in den Videos sehen Sie das Ergebnis:

Qt:

Swift:


Optisch ist der Unterschied nicht spürbar.

Test 3

Im Sailfish-Betriebssystem haben wir einen Linux-Kernel und eine grafische native Shell auf Qt, und dies führt an sich zu Gedanken über die gute Leistung dieses Betriebssystems. Ich stelle oft fest, dass das Inoi R7 in Bezug auf die Geschwindigkeit einiger Aufgaben gewinnt, obwohl das Samsung Galaxy S8 dasselbe tut. So sendet, empfängt, verarbeitet, packt das Samsung Galaxy S8 beispielsweise in eine Datenbank usw. 10K http-Anfragen in ca. 3-4 Minuten, und Inoi R7 macht dasselbe für 5-6 Minuten. Angesichts der unterschiedlichen Eisenleistung ist das Ergebnis beeindruckend.

Um die Leistung des Betriebssystems ehrlicher zu testen, habe ich mich für die Reaktionsgeschwindigkeit der Schubkarre entschieden.

Test.cpp:

 #include "mypainter.h" #include <QPainter> MyPainter::MyPainter(QQuickItem *parent) : QQuickPaintedItem(parent) { } void MyPainter::paint(QPainter *painter) { QPen pen; pen.setWidth(10); pen.setColor(Qt::red); painter->setPen(pen); painter->drawPolyline(pol); } void MyPainter::xyCanged(int x, int y) { pol.append(QPoint(x, y)); update(); } 

Test.qml:

 import QtQuick 2.9 import QtQuick.Window 2.2 import Painter 1.0 Window { visible: true Painter { id: painter anchors.fill: parent MouseArea { anchors.fill: parent onPressed: { painter.xyCanged(mouseX, mouseY) } onMouseXChanged: { painter.xyCanged(mouseX, mouseY) } onMouseYChanged: { painter.xyCanged(mouseX, mouseY) } } } } 

Einfach und unprätentiös. Ich habe kein Telefon, das Sailfish und Android für den persönlichen Gebrauch unterstützt, daher musste ich bei meinen Kollegen nach einem Telefon suchen, das Inoi r7 so nahe wie möglich kommt, aber auf Android. Was sich plötzlich als sehr schwierig herausstellte, wenn man bedenkt, dass ich in einem mobilen Entwicklungsbüro sitze.

Sony Xperia Z5 compact:
Prozessor - Qualcomm Snapdragon 810 MSM8994, 2000 MHz
Die Anzahl der Prozessorkerne - 8
Videoprozessor - Adreno 430
Die Größe des internen Speichers - 32 GB
Die Größe des Arbeitsspeichers - 2 GB

Inoi R7:
Prozessor - Qualcomm Snapdragon 212 MSM8909AA, 1200 MHz
Die Anzahl der Prozessorkerne - 4
Videoprozessor - Adreno 304
Die Größe des internen Speichers - 16 GB
Die Größe des Arbeitsspeichers - 2 GB

Sony erwies sich dennoch als leistungsstärker, aber für die Odds-Gleichung aktivieren wir den Energiesparmodus, obwohl dies nicht zur vollständigen Gleichheit der Leistung der Geräte führt. Auf dem Video können Sie sehen, dass die Linie unter Android nicht so glatt ist wie bei Sailfish.

Links - Sony, rechts - Inoi:



Ich behaupte nicht, dies ist kein sehr ernstzunehmender Indikator. Sie müssen nicht nur die Fähigkeiten einer reinen Sprache vergleichen, sondern auch verschiedene Bibliotheken, native und plattformübergreifende, um deren Leistung und Benutzerfreundlichkeit zu vergleichen, da es nur sehr wenige Anwendungen gibt, die nur ListView und das Eratosthenes-Sieb verwenden. Obwohl all diese kleinen Dinge zusammen für mich sehr überzeugend aussehen.

Nachteile

Natürlich ist bei Qt nicht alles so rosig, da ich hier zu malen versuche, gibt es Nachteile. Wenn Sie beispielsweise mit TextInput unter Android arbeiten, können Sie Perfektionisten quälen, die besonders empfindlich auf Krücken reagieren, da Qt auf jedem Gerät bei der Interaktion mit der Tastatur absolut einzigartige Stöcke in die Räder steckt. Auf einem Telefon geht das Bild nach oben, auf dem anderen steht es still, aber EnterKey funktioniert nicht, auf dem dritten werden immer nur Großbuchstaben eingegeben, und es gibt keine Möglichkeit, es davon zu überzeugen, in Kleinbuchstaben zu wechseln. Sie können ad infinitum weitermachen. Und das alles verlangsamt sich auch! (Grunts sind nur für Android relevant, es gibt keine derartigen Probleme bei Sailfish, alles funktioniert gut). Darüber hinaus ist es bei Qt schwierig, das native Erscheinungsbild der Anwendung zu erreichen.

Fazit

Die wichtigste Schlussfolgerung, die gezogen werden kann: Qt ist ein plattformübergreifendes Tool, dessen Leistung den nativen Entwicklungstools nicht unterlegen ist. Es ist perfekt für Programme, in denen neben der grafischen Benutzeroberfläche noch viel Mathematik vorhanden ist, und insbesondere für Unternehmensanwendungen, in denen es viele Nuancen und wenige Mitarbeiter gibt, um nicht für jedes Betriebssystem eine unabhängige Version zu erstellen. Funktionen sind für Unternehmensbenutzer wichtiger als die native Benutzeroberfläche. Für Aurora ist Qt ein natives Tool für die Anwendungsentwicklung, das wahrscheinlich eine weitere Leistungssteigerung bietet.

Es wäre interessant, die Aurora auf einer leistungsstarken Hardware wie meinem Galaxy S8 zu testen.