En esta página

Consideraciones y sugerencias sobre el rendimiento

Consideraciones sobre la sincronización

Como desarrollador de aplicaciones, normalmente te esfuerzas por conseguir que el motor de renderizado alcance una frecuencia de actualización constante de 60 fotogramas por segundo. Dependiendo de su hardware y de sus requisitos, la cifra puede variar, pero 60 FPS es muy habitual. 60 FPS significa que hay aproximadamente 16 milisegundos entre cada fotograma en los que se puede realizar el procesamiento, lo que incluye el procesamiento necesario para cargar las primitivas de dibujo en el hardware gráfico.

En la práctica, esto significa que el desarrollador de aplicaciones debe:

  • utilizar programación asíncrona y basada en eventos siempre que sea posible
  • utilizar subprocesos de trabajo para realizar el procesamiento más exigente
  • no hacer girar nunca manualmente el bucle de eventos
  • no dedicar nunca más de un par de milisegundos por fotograma a funciones de bloqueo

De no hacerlo, se omitirán fotogramas, lo que tiene un efecto drástico en la experiencia del usuario.

Nota: Un patrón que resulta tentador, pero que nunca debe utilizarse, es crear tu propio ` QEventLoop ` o llamar a ` QCoreApplication::processEvents()` para evitar el bloqueo dentro de un bloque de código de backend, como C++, invocado desde QML. Esto es peligroso, ya que cuando se entra en un bucle de eventos en un controlador de señal o en un enlace, el motor QML sigue ejecutando otros enlaces, animaciones, transiciones, etc. Dichos enlaces pueden provocar efectos secundarios que, por ejemplo, destruyan la jerarquía que contiene el bucle de eventos.

Perfilado

El consejo más importante es: utiliza QML Profiler incluida en Qt Creator (o un visor de trazas en Qt Extension for Visual Studio Code). Saber dónde se invierte el tiempo en una aplicación te permitirá centrarte en las áreas problemáticas que realmente existen, en lugar de en aquellas que podrían existir. Consulta Qt Creator: Perfilado de aplicaciones QML y Qt Extension for Visual Studio Code: Perfilado de código QML para obtener más información.

Determinar qué enlaces se ejecutan con mayor frecuencia, o en qué funciones dedica más tiempo su aplicación, le permitirá decidir si necesita optimizar las áreas problemáticas o rediseñar algunos detalles de implementación de su aplicación para mejorar el rendimiento. Intentar optimizar el código sin realizar un perfilado probablemente dará lugar a mejoras de rendimiento muy leves, en lugar de significativas.

Código JavaScript

La mayoría de las aplicaciones QML contienen código JavaScript, en forma de expresiones de enlace de propiedades, funciones y controladores de señales. Por lo general, esto no supone ningún problema. Gracias a herramientas avanzadas como el compiladorQt Quick , las funciones y los enlaces sencillos pueden ser muy rápidos. Sin embargo, hay que tener cuidado para garantizar que no se active accidentalmente un procesamiento innecesario. La herramienta QML Profiler puede mostrar gran cantidad de detalles sobre la ejecución de JavaScript y qué la ha desencadenado.

Conversión de tipos

Uno de los principales costes del uso de JavaScript es que, en algunos casos, al acceder a una propiedad de un tipo QML, se crea un objeto JavaScript con un recurso externo que contiene los datos subyacentes en C++ (o una referencia a ellos). En la mayoría de los casos, esto tiene un coste bastante reducido, pero en otros puede resultar bastante oneroso. Hay que tener cuidado al manejar tipos de valor o tipos de secuencia grandes y complicados. El motor de QML tiene que copiarlos cada vez que se modifican in situ o se asignan a una propiedad diferente. Cuando esto se convierta en un cuello de botella, plantéate utilizar tipos de objeto en su lugar. Las listas de tipos de objeto no presentan el mismo problema que las de tipos de valor, ya que las primeras se implementan mediante QQmlListProperty.

La mayoría de las conversiones entre tipos de valor simples son baratas. Sin embargo, hay excepciones. Crear una URL a partir de una cadena puede implicar la construcción de una instancia de ` QUrl `, lo cual resulta costoso.

Resolución de propiedades

La resolución de propiedades lleva tiempo. Aunque las búsquedas suelen estar optimizadas para ejecutarse mucho más rápido en ejecuciones posteriores, siempre es mejor evitar por completo el trabajo innecesario, si es posible.

En el siguiente ejemplo, tenemos un bloque de código que se ejecuta con frecuencia (en este caso, se trata del contenido de un bucle explícito; pero podría ser, por ejemplo, una expresión de enlace evaluada habitualmente) y, en él, resolvemos el objeto con el identificador «rect» y su propiedad «color» varias veces:

// bad.qml
import QtQuick

Item {
    width: 400
    height: 200
    Rectangle {
        id: rect
        anchors.fill: parent
        color: "blue"
    }

    function printValue(which: string, value: real) {
        console.log(which + " = " + value);
    }

    Component.onCompleted: {
        var t0 = new Date();
        for (var i = 0; i < 1000; ++i) {
            printValue("red", rect.color.r);
            printValue("green", rect.color.g);
            printValue("blue", rect.color.b);
            printValue("alpha", rect.color.a);
        }
        var t1 = new Date();
        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
    }
}

Cada vez que se recupera « rect.color », el motor QML tiene que:

  • Asignar un contenedor de tipo de valor en el montón de JavaScript.
  • Ejecutar el getter de la propiedad « color » de ` Rectangle`.
  • Copiar el ` QColor ` resultante en el contenedor de tipo de valor.

No es necesario hacer esto cuatro veces. En su lugar, podemos resolver la base común una sola vez en el bloque:

// good.qml
import QtQuick

Item {
    width: 400
    height: 200
    Rectangle {
        id: rect
        anchors.fill: parent
        color: "blue"
    }

    function printValue(which: string, value: real) {
        console.log(which + " = " + value);
    }

    Component.onCompleted: {
        var t0 = new Date();
        for (var i = 0; i < 1000; ++i) {
            var rectColor = rect.color; // resolve the common base.
            printValue("red", rectColor.r);
            printValue("green", rectColor.g);
            printValue("blue", rectColor.b);
            printValue("alpha", rectColor.a);
        }
        var t1 = new Date();
        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
    }
}

Este sencillo cambio ya supone una mejora significativa del rendimiento. Ten en cuenta que el código anterior se puede mejorar aún más (dado que la propiedad que se busca nunca cambia durante el procesamiento del bucle), sacando la resolución de la propiedad fuera del bucle, de la siguiente manera:

// better.qml
import QtQuick

Item {
    width: 400
    height: 200
    Rectangle {
        id: rect
        anchors.fill: parent
        color: "blue"
    }

    function printValue(which: string, value: real) {
        console.log(which + " = " + value);
    }

    Component.onCompleted: {
        var t0 = new Date();
        var rectColor = rect.color; // resolve the common base outside the tight loop.
        for (var i = 0; i < 1000; ++i) {
            printValue("red", rectColor.r);
            printValue("green", rectColor.g);
            printValue("blue", rectColor.b);
            printValue("alpha", rectColor.a);
        }
        var t1 = new Date();
        console.log("Took: " + (t1.valueOf() - t0.valueOf()) + " milliseconds for 1000 iterations");
    }
}

Enlaces de propiedades

Una expresión de enlace de propiedades se reevaluará si se modifica cualquiera de las propiedades a las que hace referencia. Por ello, las expresiones de enlace deben mantenerse lo más sencillas posible.

Si tienes un bucle en el que realizas algún procesamiento, pero solo es importante el resultado final de dicho procesamiento, a menudo es mejor actualizar un acumulador temporal que posteriormente asignas a la propiedad que necesitas actualizar, en lugar de actualizar incrementalmente la propia propiedad, con el fin de evitar que se desencadene la reevaluación de las expresiones de enlace durante las etapas intermedias de la acumulación.

El siguiente ejemplo ficticio ilustra este punto:

// bad.qml
import QtQuick

Item {
    id: root
    width: 200
    height: 200
    property int accumulatedValue: 0

    Text {
        anchors.fill: parent
        text: root.accumulatedValue.toString()
        onTextChanged: console.log("text binding re-evaluated")
    }

    Component.onCompleted: {
        var someData = [ 1, 2, 3, 4, 5, 20 ];
        for (var i = 0; i < someData.length; ++i) {
            accumulatedValue = accumulatedValue + someData[i];
        }
    }
}

El bucle del controlador onCompleted hace que el enlace de la propiedad «text» se reevalúe seis veces (lo que, a su vez, hace que cualquier otro enlace de propiedad que dependa del valor de «text», así como el controlador de señal onTextChanged, se reevalúen cada vez, y que el texto se maquetara para su visualización en cada ocasión). Esto es claramente innecesario en este caso, ya que en realidad solo nos interesa el valor final de la acumulación.

Se podría reescribir de la siguiente manera:

// good.qml
import QtQuick

Item {
    id: root
    width: 200
    height: 200
    property int accumulatedValue: 0

    Text {
        anchors.fill: parent
        text: root.accumulatedValue.toString()
        onTextChanged: console.log("text binding re-evaluated")
    }

    Component.onCompleted: {
        var someData = [ 1, 2, 3, 4, 5, 20 ];
        var temp = accumulatedValue;
        for (var i = 0; i < someData.length; ++i) {
            temp = temp + someData[i];
        }
        accumulatedValue = temp;
    }
}

Consejos sobre secuencias

Como se ha mencionado anteriormente, las secuencias de tipos de valor deben manejarse con cuidado.

En primer lugar, los tipos de secuencia muestran un comportamiento diferente en dos escenarios distintos:

  • si la secuencia es una « Q_PROPERTY » de una « QObject » (a esto lo llamaremos «secuencia de referencia»),
  • si la secuencia se devuelve desde una función « Q_INVOKABLE » de un « QObject » (a esto lo llamaremos «secuencia de copia»).

Una secuencia de referencia se lee y se escribe a través de la QMetaObject cada vez que cambia, ya sea en tu código JavaScript o en el objeto original. Como optimización, las secuencias de referencia (al igual que los tipos de valores de referencia) pueden cargarse de forma diferida. El contenido real solo se recupera entonces cuando se utilizan por primera vez. Esto significa que cambiar el valor de cualquier elemento de la secuencia desde JavaScript dará lugar a:

  • Posiblemente, la lectura del contenido desde el « QObject » (si se ha cargado de forma diferida).
  • La modificación del elemento en el índice especificado de dicha secuencia.
  • La reescritura de toda la secuencia en el ` QObject`.

Una secuencia de copia es mucho más sencilla, ya que la secuencia real se almacena en los datos de recursos del objeto de JavaScript, por lo que no se produce ningún ciclo de lectura/modificación/escritura (en su lugar, los datos de recursos se modifican directamente).

Por lo tanto, las escrituras en elementos de una secuencia de referencia serán mucho más lentas que las escrituras en elementos de una secuencia de copia. De hecho, escribir en un único elemento de una secuencia de referencia de N elementos tiene un coste equivalente al de asignar una secuencia de copia de N elementos a esa secuencia de referencia, por lo que suele ser mejor modificar una secuencia de copia temporal y, a continuación, asignar el resultado a una secuencia de referencia durante el cálculo.

Supongamos la existencia (y el registro previo en el espacio de nombres «Qt.example») del siguiente tipo de C++:

class SequenceTypeExample : public QQuickItem
{
    Q_OBJECT
    Q_PROPERTY (QList<qreal> qrealListProperty READ qrealListProperty WRITE setQrealListProperty NOTIFY qrealListPropertyChanged)

public:
    SequenceTypeExample() : QQuickItem() { m_list << 1.1 << 2.2 << 3.3; }
    ~SequenceTypeExample() {}

    QList<qreal> qrealListProperty() const { return m_list; }
    void setQrealListProperty(const QList<qreal> &list) { m_list = list; emit qrealListPropertyChanged(); }

signals:
    void qrealListPropertyChanged();

private:
    QList<qreal> m_list;
};

El siguiente ejemplo escribe en elementos de una secuencia de referencia en un bucle apretado, lo que da lugar a un rendimiento deficiente:

// bad.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root
    width: 200
    height: 200

    Component.onCompleted: {
        var t0 = new Date();
        qrealListProperty.length = 100;
        for (var i = 0; i < 500; ++i) {
            for (var j = 0; j < 100; ++j) {
                qrealListProperty[j] = j;
            }
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

La lectura y escritura de la propiedad « QObject » en el bucle interno, provocadas por la expresión « "qrealListProperty[j] = j" », hacen que este código sea muy poco óptimo. En su lugar, algo funcionalmente equivalente pero mucho más rápido sería:

// good.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root
    width: 200
    height: 200

    Component.onCompleted: {
        var t0 = new Date();
        var someData = [1.1, 2.2, 3.3]
        someData.length = 100;
        for (var i = 0; i < 500; ++i) {
            for (var j = 0; j < 100; ++j) {
                someData[j] = j;
            }
            qrealListProperty = someData;
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

Otro patrón habitual que debe evitarse son los bucles de lectura-modificación-escritura, en los que cada elemento se lee, se modifica y se vuelve a escribir en la propiedad de la secuencia. Al igual que en el ejemplo anterior, esto provoca lecturas y escrituras de la propiedad « QObject » en cada iteración:

// bad.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root
    width: 200
    height: 200

    Component.onCompleted: {
        var t0 = new Date();
        qrealListProperty.length = 100;
        for (var i = 0; i < 500; ++i) {
            for (var j = 0; j < 100; ++j) {
                qrealListProperty[j] = qrealListProperty[j] * 2;
            }
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

En su lugar, crea una copia manual de la secuencia, modifica la copia y, a continuación, asigna el resultado de nuevo a la propiedad:

// good.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root
    width: 200
    height: 200

    Component.onCompleted: {
        var t0 = new Date();
        for (var i = 0; i < 500; ++i) {
            let data = [...qrealListProperty];
            for (var j = 0; j < 100; ++j) {
                data[j] = data[j] * 2;
            }
            qrealListProperty = data;
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

En segundo lugar, se emite una señal de cambio para la propiedad si cambia cualquier elemento de la misma. Si tienes muchos enlaces a un elemento concreto de una propiedad de secuencia, es mejor crear una propiedad dinámica vinculada a ese elemento y utilizar esa propiedad dinámica como símbolo en las expresiones de enlace, en lugar del elemento de la secuencia, ya que solo provocará la reevaluación de los enlaces si cambia su valor.

Se trata de un caso de uso poco habitual con el que la mayoría de los clientes nunca deberían encontrarse, pero conviene tenerlo en cuenta por si alguna vez te ves haciendo algo como esto:

// bad.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root

    property int firstBinding: qrealListProperty[1] + 10;
    property int secondBinding: qrealListProperty[1] + 20;
    property int thirdBinding: qrealListProperty[1] + 30;

    Component.onCompleted: {
        var t0 = new Date();
        for (var i = 0; i < 1000; ++i) {
            qrealListProperty[2] = i;
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

Ten en cuenta que, aunque en el bucle solo se modifique el elemento del índice 2, las tres vinculaciones se volverán a evaluar, ya que la granularidad de la señal de cambio indica que toda la propiedad ha cambiado. Por ello, añadir una vinculación intermedia puede resultar beneficioso en algunas ocasiones:

// good.qml
import QtQuick
import Qt.example

SequenceTypeExample {
    id: root

    property int intermediateBinding: qrealListProperty[1]
    property int firstBinding: intermediateBinding + 10;
    property int secondBinding: intermediateBinding + 20;
    property int thirdBinding: intermediateBinding + 30;

    Component.onCompleted: {
        var t0 = new Date();
        for (var i = 0; i < 1000; ++i) {
            qrealListProperty[2] = i;
        }
        var t1 = new Date();
        console.log("elapsed: " + (t1.valueOf() - t0.valueOf()) + " milliseconds");
    }
}

En el ejemplo anterior, solo se reevaluará la vinculación intermedia cada vez, lo que se traduce en un aumento significativo del rendimiento.

Consejos sobre los tipos de valor

Las propiedadesde los tipos de valor (font, color, vector3d, etc.) tienen una semántica de propiedad « QObject » y de notificación de cambios similar a la de las propiedades de los tipos de secuencia. Por lo tanto, los consejos ofrecidos anteriormente para las secuencias también son aplicables a las propiedades de los tipos de valor. Aunque suelen suponer menos problemas con los tipos de valor (ya que el número de subpropiedades de un tipo de valor suele ser mucho menor que el número de elementos de una secuencia), cualquier aumento en el número de enlaces que se reevalúan innecesariamente tendrá un impacto negativo en el rendimiento.

Consejos generales de rendimiento

Las consideraciones generales sobre el rendimiento de JavaScript derivadas del diseño del lenguaje también son aplicables a QML. Las más destacadas son:

  • Evita utilizar eval() siempre que sea posible
  • No elimines propiedades de los objetos

Elementos comunes de la interfaz

Elementos de texto

El cálculo de los diseños de texto puede ser una operación lenta. Considera la posibilidad de utilizar el formato PlainText en lugar de StyledText siempre que sea posible, ya que esto reduce la carga de trabajo del motor de maquetación. Si no puedes utilizar PlainText (por ejemplo, porque necesitas incrustar imágenes o utilizar etiquetas para especificar rangos de caracteres con un formato determinado [negrita, cursiva, etc.], en lugar de aplicar el formato a todo el texto), entonces deberías utilizar StyledText.

Solo debes utilizar AutoText si el texto pudiera ser (aunque probablemente no lo sea) StyledText, ya que este modo conlleva un coste de análisis sintáctico. No se debe utilizar el modo RichText, ya que StyledText ofrece casi todas sus características a una fracción de su coste.

Imágenes

Las imágenes son una parte fundamental de cualquier interfaz de usuario. Por desgracia, también son una gran fuente de problemas debido al tiempo que tardan en cargarse, a la cantidad de memoria que consumen y a la forma en que se utilizan.

Carga asíncrona

Las imágenes suelen ser bastante grandes, por lo que es recomendable asegurarse de que su carga no bloquee el hilo de la interfaz de usuario. Establece la propiedad «asynchronous» del elemento Image de QML en « true » para habilitar la carga asíncrona de imágenes desde el sistema de archivos local (las imágenes remotas siempre se cargan de forma asíncrona), siempre que ello no afecte negativamente a la estética de la interfaz de usuario.

Los elementos «Image» con la propiedad «asynchronous» establecida en « true » cargarán las imágenes en un hilo de trabajo de baja prioridad.

Tamaño explícito de la fuente

Si tu aplicación carga una imagen grande pero la muestra en un elemento de tamaño reducido, establece la propiedad «sourceSize» en el tamaño del elemento que se va a renderizar para garantizar que se mantenga en memoria la versión reducida de la imagen, en lugar de la grande.

Ten en cuenta que cambiar el valor de «sourceSize» provocará que la imagen se vuelva a cargar.

Evita la composición en tiempo de ejecución

Recuerda también que puedes evitar realizar tareas de composición en tiempo de ejecución proporcionando el recurso de imagen precompuesto con tu aplicación (por ejemplo, al aplicar efectos de sombra a los elementos).

Evita suavizar las imágenes

Activa la función « image.smooth » solo si es necesario. Es más lenta en algunos equipos y no tiene ningún efecto visual si la imagen se muestra en su tamaño natural.

Pintura

Evita dibujar la misma zona varias veces. Utiliza «Item» como elemento raíz en lugar de «Rectangle» para evitar dibujar el fondo varias veces.

Coloca los elementos con anclajes

Es más eficiente utilizar anclajes en lugar de enlaces para posicionar los elementos unos respecto a otros. Considera este uso de enlaces para posicionar «rect2» respecto a «rect1»:

Rectangle {
    id: rect1
    x: 20
    width: 200; height: 200
}
Rectangle {
    id: rect2
    x: rect1.x
    y: rect1.y + rect1.height
    width: rect1.width - 20
    height: 200
}

Esto se consigue de forma más eficiente utilizando anclajes:

Rectangle {
    id: rect1
    x: 20
    width: 200; height: 200
}
Rectangle {
    id: rect2
    height: 200
    anchors.left: rect1.left
    anchors.top: rect1.bottom
    anchors.right: rect1.right
    anchors.rightMargin: 20
}

El posicionamiento mediante enlaces (asignando expresiones de enlace a las propiedades x, y, width y height de los objetos visuales, en lugar de utilizar anclajes) es relativamente lento, aunque ofrece la máxima flexibilidad.

Si el diseño no es dinámico, la forma más eficaz de especificarlo es mediante la inicialización estática de las propiedades x, y, width y height. Las coordenadas de los elementos son siempre relativas a su elemento padre, por lo que, si deseas establecer un desplazamiento fijo respecto a la coordenada 0,0 de tu elemento padre, no debes utilizar anclajes. En el siguiente ejemplo, los objetos Rectangle hijos se encuentran en el mismo lugar, pero el código de anclajes que se muestra no es tan eficiente en cuanto a recursos como el código que utiliza el posicionamiento fijo mediante inicialización estática:

Rectangle {
    width: 60
    height: 60
    Rectangle {
        id: fixedPositioning
        x: 20
        y: 20
        width: 20
        height: 20
    }
    Rectangle {
        id: anchorPositioning
        anchors.fill: parent
        anchors.margins: 20
    }
}

Modelos y vistas

La mayoría de las aplicaciones contarán con al menos un modelo que proporcione datos a una vista. Hay algunos aspectos semánticos que los desarrolladores de aplicaciones deben tener en cuenta para lograr el máximo rendimiento.

Modelos personalizados en C++

A menudo resulta conveniente escribir un modelo personalizado en un lenguaje de backend, como C++, para utilizarlo con una vista en QML. Aunque la implementación óptima de cualquier modelo de este tipo dependerá en gran medida del caso de uso al que deba dar respuesta, a continuación se ofrecen algunas pautas generales:

  • Sé lo más asíncrono posible
  • Realiza todo el procesamiento en un hilo de trabajo (de baja prioridad)
  • Agrupa las operaciones del backend para minimizar las operaciones de E/S y la comunicación entre procesos (que pueden ser lentas)

Es importante señalar que se recomienda utilizar un hilo de trabajo de baja prioridad para minimizar el riesgo de que el hilo de la interfaz gráfica de usuario se quede sin recursos (lo que podría dar lugar a una peor percepción del rendimiento). Además, recuerda que los mecanismos de sincronización y bloqueo pueden ser una causa importante de lentitud en el rendimiento, por lo que hay que tener cuidado de evitar bloqueos innecesarios.

Tipo QML `ListModel`

Qt Qml Models proporciona un tipo « ListModel » que se puede utilizar para suministrar datos a un « ListView ». Resulta útil para la creación rápida de prototipos, pero no es adecuado para grandes cantidades de datos. Utiliza un « QAbstractItemModel » adecuado cuando sea necesario.

Rellenar dentro de un hilo de trabajo

ListModel Los elementos se pueden rellenar en un hilo de trabajo (de baja prioridad) en JavaScript. El desarrollador debe llamar explícitamente a ` sync() ` en el ` ListModel ` desde dentro del ` WorkerScript ` para que los cambios se sincronicen con el hilo principal. Consulte la documentación de ` WorkerScript ` para obtener más información.

Ten en cuenta que el uso de un elemento ` WorkerScript ` dará lugar a la creación de un motor de JavaScript independiente (ya que el motor de JavaScript es específico para cada hilo). Esto provocará un mayor consumo de memoria. No obstante, varios elementos ` WorkerScript ` utilizarán todos el mismo hilo de trabajo, por lo que el impacto en la memoria al utilizar un segundo o tercer elemento ` WorkerScript ` es insignificante una vez que la aplicación ya utiliza uno. Por otro lado, sin embargo, los scripts de trabajo adicionales no se ejecutan en paralelo.

No utilices roles dinámicos

El elemento ListModel asume que los tipos de roles dentro de cada elemento de un modelo determinado son estables con fines de optimización. Si el tipo puede cambiar dinámicamente de un elemento a otro, el rendimiento del modelo se verá muy mermado.

Por lo tanto, la tipificación dinámica está desactivada por defecto; el desarrollador debe establecer específicamente la propiedad booleana dynamicRoles del modelo para activar la tipificación dinámica (y sufrir la consiguiente pérdida de rendimiento). Recomendamos no utilizar la tipificación dinámica a menos que sea absolutamente necesario.

Vistas

Los delegados de vista deben mantenerse lo más sencillos posible. Incluye en el delegado solo el código QML necesario para mostrar la información requerida. Cualquier funcionalidad adicional que no sea necesaria de forma inmediata (por ejemplo, si muestra más información al hacer clic) no debe crearse hasta que sea necesaria (consulta la siguiente sección sobre la inicialización diferida).

La siguiente lista es un buen resumen de los aspectos que hay que tener en cuenta al diseñar un delegado:

  • Cuantos menos elementos haya en un delegado, más rápido se podrán crear y, por lo tanto, más rápido se podrá desplazar la vista.
  • Mantén al mínimo el número de enlaces en un delegado; en particular, utiliza anclajes en lugar de enlaces para el posicionamiento relativo dentro de un delegado.
  • Evita utilizar elementos « ShaderEffect » dentro de los delegados.
  • Nunca actives el recorte en un delegado.

Puedes establecer la propiedad « cacheBuffer » de una vista para permitir la creación asíncrona y el almacenamiento en búfer de delegados fuera del área visible. Se recomienda utilizar un « cacheBuffer » para los delegados de vista que no sean triviales y que probablemente no se creen en un solo fotograma.

Ten en cuenta que un ` cacheBuffer ` mantiene delegados adicionales en memoria. Por lo tanto, el valor obtenido al utilizar el ` cacheBuffer ` debe sopesarse con el consumo adicional de memoria. Los desarrolladores deben realizar pruebas de rendimiento para encontrar el valor óptimo para su caso de uso, ya que el aumento de la presión sobre la memoria causado por el uso de un ` cacheBuffer ` puede, en algunos casos excepcionales, provocar una reducción de la frecuencia de fotogramas al desplazarse.

Para obtener mejoras adicionales en el rendimiento, plantéate habilitar la reutilización de elementos en las vistas. Consulta Reusing Items for ListView y Reusing Items for TableView and TreeView para obtener más información.

Efectos visuales

Qt Quick incluye varias funciones que permiten a los desarrolladores y diseñadores crear interfaces de usuario excepcionalmente atractivas. La fluidez y las transiciones dinámicas, así como los efectos visuales, pueden utilizarse con gran eficacia en una aplicación, pero hay que tener cierto cuidado al utilizar algunas de las funciones de QML, ya que pueden afectar al rendimiento.

Animaciones

En general, al animar una propiedad, se reevaluarán todos los enlaces que hagan referencia a dicha propiedad. Normalmente, esto es lo que se busca, pero en otros casos puede ser mejor desactivar el enlace antes de realizar la animación y, a continuación, volver a asignarlo una vez que la animación haya finalizado.

Evita ejecutar JavaScript durante la animación. Por ejemplo, se debe evitar ejecutar una expresión compleja de JavaScript en cada fotograma de una animación de la propiedad x.

Los desarrolladores deben tener especial cuidado al utilizar animaciones por script, ya que estas se ejecutan en el hilo principal (y, por lo tanto, pueden provocar que se omitan fotogramas si tardan demasiado en completarse).

Partículas

El Qt Quick Particles permite integrar a la perfección hermosos efectos de partículas en las interfaces de usuario. Sin embargo, cada plataforma tiene unas capacidades de hardware gráfico diferentes, y el módulo Partículas no puede limitar los parámetros a lo que tu hardware pueda soportar sin problemas. Cuantas más partículas intentes renderizar (y cuanto más grandes sean), más rápido tendrá que ser tu hardware gráfico para poder renderizarlas a 60 FPS. Manejar más partículas requiere una CPU más rápida. Por lo tanto, es importante probar cuidadosamente todos los efectos de partículas en tu plataforma de destino, para calibrar el número y el tamaño de las partículas que puedes renderizar a 60 FPS.

Cabe señalar que un sistema de partículas puede desactivarse cuando no se utilice (por ejemplo, en un elemento no visible) para evitar realizar simulaciones innecesarias.

Consulta la Guía de rendimiento del sistema de partículas para obtener información más detallada.

Control de la duración de los elementos

Al dividir una aplicación en componentes sencillos y modulares, cada uno de ellos contenido en un único archivo QML, se consigue un tiempo de inicio más rápido de la aplicación, un mejor control sobre el uso de la memoria y se reduce el número de elementos activos pero invisibles en la aplicación.

Inicialización diferida

El motor QML recurre a algunas estrategias ingeniosas para intentar garantizar que la carga y la inicialización de los componentes no provoquen que se omitan fotogramas. Sin embargo, no hay mejor forma de reducir el tiempo de inicio que evitar realizar tareas innecesarias y posponer el trabajo hasta que sea necesario. Esto se puede conseguir utilizando Loader.

Uso de Loader

El Loader es un elemento que permite la carga y descarga dinámicas de componentes.

  • Mediante la propiedad «active» de un Loader, la inicialización puede posponerse hasta que sea necesario.
  • Mediante la versión sobrecargada de la función «setSource()», se pueden proporcionar valores iniciales para las propiedades.
  • Establecer la propiedad « asynchronous » del Loader en «true» también puede mejorar la fluidez mientras se instancia un componente.

Eliminar elementos no utilizados

Los elementos que están ocultos por ser hijos de un elemento no visible (por ejemplo, la segunda pestaña de un widget de pestañas, mientras que la primera está visible) deben inicializarse de forma diferida en la mayoría de los casos y eliminarse cuando ya no se utilicen, para evitar el coste continuo que supone mantenerlos activos (por ejemplo, renderizado, animaciones, evaluación de enlaces de propiedades, etc.).

Un elemento cargado con un elemento Loader puede liberarse restableciendo la propiedad «source» o «sourceComponent» del Loader, mientras que otros elementos pueden liberarse explícitamente llamando a la función destroy() sobre ellos. En algunos casos, puede ser necesario dejar el elemento activo, en cuyo caso, como mínimo, debería hacerse invisible.

Consulte la siguiente sección sobre renderizado para obtener más información sobre los elementos activos pero invisibles.

Representación

El grafo de escena utilizado para el renderizado en Qt Quick permite renderizar de forma fluida, a 60 FPS, interfaces de usuario animadas y muy dinámicas. Sin embargo, hay algunos factores que pueden reducir drásticamente el rendimiento del renderizado, por lo que los desarrolladores deben tener cuidado de evitar estos escollos siempre que sea posible.

Recorte

El recorte está desactivado por defecto y solo debe activarse cuando sea necesario.

El recorte es un efecto visual, NO una optimización. Aumenta (en lugar de reducir) la complejidad para el renderizador. Si se habilita el recorte, un elemento recortará su propia representación, así como la de sus elementos secundarios, a su rectángulo delimitador. Esto impide que el renderizador pueda reordenar libremente el orden de dibujo de los elementos, lo que da lugar a un recorrido del grafo de escena subóptimo en el mejor de los casos.

El recorte dentro de un delegado es especialmente perjudicial y debe evitarse a toda costa.

Sobredibujo y elementos invisibles

Si tienes elementos que están totalmente cubiertos por otros elementos (opacos), lo mejor es establecer su propiedad «visible» en « false », ya que, de lo contrario, se dibujarán innecesariamente.

Del mismo modo, los elementos que son invisibles (por ejemplo, la segunda pestaña de un widget de pestañas, mientras se muestra la primera) pero que deben inicializarse al inicio del programa (por ejemplo, si el coste de instanciar la segunda pestaña es demasiado elevado como para poder hacerlo solo cuando se active la pestaña), deben tener su propiedad «visible» establecida en « false », con el fin de evitar el coste de dibujarlas (aunque, como se ha explicado anteriormente, seguirán incurriendo en el coste de cualquier animación o evaluación de enlaces, ya que siguen estando activas).

Translúcido frente a opaco

El contenido opaco suele ser mucho más rápido de dibujar que el translúcido. La razón es que el contenido translúcido requiere mezcla de colores y que el renderizador puede optimizar mejor el contenido opaco.

Una imagen con un solo píxel translúcido se trata como si fuera totalmente translúcida, aunque sea mayoritariamente opaca. Lo mismo ocurre con un « BorderImage » con bordes transparentes.

Shaders

El tipo « ShaderEffect » permite insertar código GLSL en línea en una aplicación « Qt Quick » con muy poca sobrecarga. Sin embargo, es importante tener en cuenta que el programa de fragmentos debe ejecutarse para cada píxel de la forma renderizada. Al implementar en hardware de gama baja y cuando el sombreador abarca una gran cantidad de píxeles, conviene limitar el sombreador de fragmentos a unas pocas instrucciones para evitar un rendimiento deficiente.

Los sombreadores escritos en GLSL permiten crear transformaciones complejas y efectos visuales, aunque deben utilizarse con precaución. El uso de un « ShaderEffectSource » hace que la escena se prerenderice en un FBO antes de que pueda dibujarse. Esta sobrecarga adicional puede resultar bastante costosa.

Asignación y liberación de memoria

La cantidad de memoria que asignará una aplicación y la forma en que se asignará dicha memoria son aspectos muy importantes a tener en cuenta. Aparte de las evidentes preocupaciones sobre las situaciones de falta de memoria en dispositivos con recursos limitados, la asignación de memoria en el montón es una operación bastante costosa desde el punto de vista computacional, y ciertas estrategias de asignación pueden provocar una mayor fragmentación de los datos entre páginas. JavaScript utiliza un montón de memoria gestionada que se somete automáticamente a la recolección de basura, lo que presenta algunas ventajas, pero también algunas implicaciones importantes.

Una aplicación escrita en QML utiliza memoria tanto del montón de C++ como de un montón de JavaScript gestionado automáticamente. El desarrollador de la aplicación debe conocer las sutilezas de cada uno de ellos para maximizar el rendimiento.

Consejos para desarrolladores de aplicaciones QML

Los consejos y sugerencias que figuran en esta sección son meramente orientativos y pueden no ser aplicables en todas las circunstancias. Asegúrate de realizar pruebas de rendimiento y analizar tu aplicación minuciosamente utilizando métricas empíricas, con el fin de tomar las mejores decisiones posibles.

Instanciar e inicializar los componentes de forma diferida

Si tu aplicación consta de varias vistas (por ejemplo, varias pestañas), pero solo se necesita una en un momento dado, puedes utilizar la instanciación diferida para minimizar la cantidad de memoria que necesitas tener asignada en un momento dado. Consulta la sección anterior sobre «Inicialización diferida» para obtener más información.

Elimina los objetos que no se utilicen

Si carga componentes de forma diferida o crea objetos dinámicamente durante una expresión de JavaScript, suele ser mejor eliminarlos manualmente mediante « destroy() » en lugar de esperar a que la recolección automática de basura lo haga. Consulte la sección anterior sobre el control de la vida útil de los elementos para obtener más información.

No invoques manualmente el recolector de basura

En la mayoría de los casos, no es recomendable invocar manualmente el recolector de basura, ya que bloqueará el hilo de la interfaz gráfica de usuario durante un periodo de tiempo considerable. Esto puede provocar que se salten fotogramas y que las animaciones se vean entrecortadas, lo cual debe evitarse a toda costa.

Hay algunos casos en los que es aceptable invocar manualmente el recolector de basura (lo cual se explica con más detalle en una sección posterior), pero, en la mayoría de los casos, invocarlo es innecesario y contraproducente.

Evita definir varios tipos implícitos idénticos

Si un elemento QML tiene una propiedad personalizada definida en QML, se convierte en su propio tipo implícito. Esto se explica con más detalle en una sección posterior. Si se definen varios tipos implícitos idénticos en un ` Component`, se desperdiciará algo de memoria. En esa situación, suele ser mejor definir explícitamente un nuevo componente que luego se pueda reutilizar. En tal caso, plantéate definir un componente en línea utilizando la palabra clave « component ».

Definir una propiedad personalizada suele suponer una optimización beneficiosa del rendimiento (por ejemplo, para reducir el número de enlaces necesarios o que deben reevaluarse), o puede mejorar la modularidad y la facilidad de mantenimiento de un componente. En esos casos, se recomienda el uso de propiedades personalizadas. Sin embargo, si el nuevo tipo se utiliza más de una vez, debería dividirse en su propio componente (en línea o en un archivo .qml) para ahorrar memoria.

Reutilizar componentes existentes

Si estás pensando en definir un nuevo componente, vale la pena comprobar que dicho componente no exista ya en el conjunto de componentes de tu plataforma. De lo contrario, estarás obligando al motor QML a generar y almacenar datos de tipo para un tipo que es, en esencia, un duplicado de otro componente preexistente y que, posiblemente, ya esté cargado.

Utiliza tipos singleton en lugar de scripts de biblioteca «pragma»

Si estás utilizando un script de biblioteca «pragma» para almacenar datos de instancias de toda la aplicación, plantéate utilizar en su lugar un tipo singleton QObject. Esto debería traducirse en un mejor rendimiento y supondrá un menor uso de memoria del montón de JavaScript.

Asignación de memoria en una aplicación QML

El uso de memoria de una aplicación QML puede dividirse en dos partes: el uso del montón nativo y el uso del montón de JavaScript. Parte de la memoria asignada en cada uno de ellos es inevitable, ya que la asignan el motor QML o el motor de JavaScript, mientras que el resto depende de las decisiones tomadas por el desarrollador de la aplicación.

El montón nativo contendrá:

  • la sobrecarga fija e inevitable del motor QML (estructuras de datos de implementación, información de contexto, etc.);
  • datos compilados e información de tipos por componente, incluidos los metadatos de propiedades por tipo, que el motor QML genera o carga desde la caché del disco en función de los módulos y componentes que la aplicación haya cargado;
  • datos de C++ por objeto (incluidos los valores de las propiedades), además de una jerarquía de metaobjetos por elemento, dependiendo de los componentes que la aplicación instancie;
  • cualquier dato asignado específicamente por las importaciones de QML (bibliotecas).

El montón de JavaScript contendrá:

  • la sobrecarga fija e inevitable del propio motor de JavaScript (incluidos los tipos de JavaScript integrados);
  • la sobrecarga fija e inevitable de nuestra integración de JavaScript (funciones constructoras para los tipos cargados, plantillas de funciones, etc.);
  • información de diseño por tipo y otros datos internos de tipo generados por el motor de JavaScript en tiempo de ejecución, para cada tipo (véase la nota más abajo, relativa a los tipos);
  • datos de JavaScript por objeto (propiedades «var», funciones de JavaScript y controladores de señales, y expresiones de enlace no optimizadas);
  • variables asignadas durante la evaluación de expresiones.

Además, se asignará un montón de JavaScript para su uso en el hilo principal y, opcionalmente, otro montón de JavaScript para su uso en el hilo WorkerScript. Si una aplicación no utiliza un elemento WorkerScript, no se producirá esa sobrecarga. El montón de JavaScript puede tener un tamaño de varios megabytes, por lo que para las aplicaciones escritas para dispositivos con memoria limitada puede ser más recomendable evitar el elemento ` WorkerScript `.

Ten en cuenta que tanto el motor QML como el motor JavaScript generarán automáticamente sus propias cachés de datos de tipo sobre los tipos observados. Cada componente cargado por una aplicación es un tipo distinto (explícito), y cada elemento (instancia de componente) que define sus propias propiedades personalizadas en QML es un tipo implícito. Cualquier elemento (instancia de un componente) que no defina ninguna propiedad personalizada es considerado por los motores de JavaScript y QML como del tipo definido explícitamente por el componente, en lugar de su propio tipo implícito.

Consideremos el siguiente ejemplo:

import QtQuick

Item {
    id: root

    Rectangle {
        id: r0
        color: "red"
    }

    Rectangle {
        id: r1
        color: "blue"
        width: 50
    }

    Rectangle {
        id: r2
        property int customProperty: 5
    }

    Rectangle {
        id: r3
        property string customProperty: "hello"
    }

    Rectangle {
        id: r4
        property string customProperty: "hello"
    }
}

En el ejemplo anterior, los rectángulos r0 y r1 no tienen ninguna propiedad personalizada, por lo que los motores de JavaScript y QML consideran que ambos son del mismo tipo. Es decir, tanto r0 como r1 se consideran del tipo Rectangle, definido explícitamente. Los rectángulos r2, r3 y r4 tienen cada uno propiedades personalizadas y se consideran de tipos (implícitos) diferentes. Tenga en cuenta que r3 y r4 se consideran de tipos diferentes, aunque tengan una información de propiedades idéntica, simplemente porque la propiedad personalizada no se declaró en el componente del que son instancias.

Si r3 y r4 fueran ambas instancias de un componente RectangleWithString, y la definición de dicho componente incluyera la declaración de una propiedad de tipo cadena denominada customProperty, entonces r3 y r4 se considerarían del mismo tipo (es decir, serían instancias del tipo RectangleWithString, en lugar de definir su propio tipo implícito).

Consideraciones detalladas sobre la asignación de memoria

A la hora de tomar decisiones sobre la asignación de memoria o las compensaciones de rendimiento, es importante tener en cuenta el impacto del rendimiento de la caché de la CPU, la paginación del sistema operativo y la recolección de basura del motor de JavaScript. Las posibles soluciones deben someterse a pruebas de rendimiento minuciosas para garantizar que se elija la mejor.

Ningún conjunto de directrices generales puede sustituir a una sólida comprensión de los principios subyacentes de la informática, combinada con un conocimiento práctico de los detalles de implementación de la plataforma para la que el desarrollador está creando la aplicación. Además, ningún cálculo teórico puede sustituir a un buen conjunto de pruebas de rendimiento y herramientas de análisis a la hora de tomar decisiones sobre compensaciones.

Fragmentación

La fragmentación es un problema propio del desarrollo en C++. Si el desarrollador de la aplicación no define ningún tipo ni complemento en C++, puede ignorar esta sección sin problema.

Con el tiempo, una aplicación asignará grandes porciones de memoria, escribirá datos en esa memoria y, posteriormente, liberará algunas porciones de la misma una vez que haya terminado de utilizar parte de los datos. Esto puede dar lugar a que la memoria «libre» se encuentre en bloques no contiguos, que no pueden devolverse al sistema operativo para que las utilicen otras aplicaciones. También afecta a las características de almacenamiento en caché y acceso de la aplicación, ya que los datos «activos» pueden estar dispersos por muchas páginas diferentes de la memoria física. Esto, a su vez, podría obligar al sistema operativo a realizar operaciones de intercambio (swap), lo que puede provocar E/S en el sistema de archivos —una operación que, en términos comparativos, es extremadamente lenta—.

La fragmentación puede evitarse utilizando asignadores de memoria en pool (y otros asignadores de memoria contigua), reduciendo la cantidad de memoria asignada en un momento dado mediante una gestión cuidadosa de la vida útil de los objetos, limpiando y reconstruyendo periódicamente las cachés, o utilizando un entorno de ejecución con gestión de memoria y recolección de basura (como JavaScript).

Recolección de basura

JavaScript ofrece recolección de basura. La memoria asignada en el montón de JavaScript (a diferencia del montón nativo) es propiedad del motor de JavaScript. El motor recolectará periódicamente todos los datos sin referencias del montón de JavaScript.

Implicaciones de la recolección de basura

La recolección de basura tiene ventajas e inconvenientes. Significa que la gestión manual del ciclo de vida de los objetos es menos importante. Sin embargo, también implica que el motor de JavaScript puede iniciar una operación potencialmente prolongada en un momento que escapa al control del desarrollador de la aplicación. A menos que el desarrollador de la aplicación considere cuidadosamente el uso del montón de JavaScript, la frecuencia y la duración de la recolección de basura pueden tener un impacto negativo en la experiencia de la aplicación. Desde Qt 6.8, el recolector de basura es incremental, lo que significa que provocará interrupciones más breves, pero potencialmente más frecuentes.

Invocación manual del recolector de basura

Una aplicación escrita en QML requerirá (muy probablemente) que se realice la recolección de basura en algún momento. Aunque el motor de JavaScript activará automáticamente la recolección de basura según su propio calendario, en ocasiones es mejor que el desarrollador de la aplicación decida cuándo invocar manualmente el recolector de basura (aunque normalmente no es así).

Es probable que el desarrollador de la aplicación sea quien mejor conozca cuándo la aplicación va a permanecer inactiva durante períodos de tiempo considerables. Si una aplicación QML utiliza mucha memoria del montón de JavaScript, lo que provoca ciclos de recolección de basura frecuentes y perturbadores durante tareas especialmente sensibles al rendimiento (por ejemplo, el desplazamiento por listas, las animaciones, etc.), al desarrollador de la aplicación le puede resultar muy útil invocar manualmente el recolector de basura durante los periodos de actividad nula. Los periodos de inactividad son ideales para llevar a cabo la recolección de basura, ya que el usuario no notará ningún deterioro de la experiencia de usuario (fotogramas omitidos, animaciones entrecortadas, etc.) que se produciría al invocar el recolector de basura mientras hay actividad.

El recolector de basura puede invocarse manualmente llamando a ` gc() ` desde JavaScript. Esto provocará que se realice un ciclo de recolección completo y no incremental, cuya finalización puede tardar entre unos cientos y más de mil milisegundos, por lo que debe evitarse siempre que sea posible.

Compensaciones entre memoria y rendimiento

En algunas situaciones, es posible sacrificar un mayor uso de memoria a cambio de reducir el tiempo de procesamiento. Por ejemplo, almacenar en caché el resultado de una búsqueda de símbolos utilizada en un bucle cerrado en una variable temporal dentro de una expresión de JavaScript supondrá una mejora significativa del rendimiento al evaluar dicha expresión, pero implica la asignación de una variable temporal. En algunos casos, estas compensaciones son razonables (como en el caso anterior, que casi siempre lo es), pero en otros puede ser mejor permitir que el procesamiento tarde un poco más para evitar aumentar la presión sobre la memoria del sistema.

En algunos casos, el impacto del aumento de la presión sobre la memoria puede ser extremo. En determinadas situaciones, sacrificar el uso de memoria a cambio de una supuesta ganancia de rendimiento puede provocar un aumento del «page-thrash» o del «cache-thrash», lo que causa una enorme reducción del rendimiento. Siempre es necesario evaluar cuidadosamente el impacto de estas compensaciones para determinar cuál es la mejor solución en una situación determinada.

Para obtener información detallada sobre el rendimiento de la caché y las compensaciones entre memoria y tiempo, consulta los siguientes artículos:

Arranque rápido y optimización del inicio

Basándonos en la experiencia práctica en la optimización de aplicaciones de Qt Quick para un arranque rápido, ten en cuenta las siguientes prácticas recomendadas:

  • Diseña tu aplicación para que se inicie rápidamente desde el principio. Piensa en lo que quieres que el usuario vea primero.
  • Utiliza el QML Profiler para identificar cuellos de botella en el arranque.
  • Utiliza la carga en cadena. Ejecuta tantos « loaders » como núcleos tenga tu CPU (por ejemplo, dos núcleos: dos cargadores ejecutándose al mismo tiempo).
  • El primer « loader » no debe ser asíncrono, para que parte del contenido se muestre de inmediato. Activa los «loaders» asíncronos después.
  • Conéctate a los servicios de back-end solo cuando sea necesario.
  • Crea módulos QML que se importen cuando sea necesario. Mediante el uso de módulos y tipos de carga diferida, puedes hacer que los servicios no críticos estén disponibles para tu aplicación según sea necesario.
  • Optimiza tus imágenes PNG/JPG utilizando herramientas como optipng.
  • Optimiza tus modelos 3D reduciendo el número de vértices y eliminando las partes que no son visibles.
  • Optimiza la carga de modelos 3D utilizando glTF.
  • Limita el uso de «clip» y «opacity», ya que pueden afectar al rendimiento.
  • Evalúa las limitaciones de la GPU y tenlas en cuenta a la hora de diseñar la interfaz de usuario. Consulta Frame Captures and Performance Profiling para obtener más información.
  • Utiliza el compilador deQt Quick para precompilar los archivos QML.
  • Averigua si es posible el enlace estático para tu arquitectura.
  • Procura utilizar enlaces declarativos en lugar de controladores de señales imperativos.
  • Mantén sencillos los enlaces de propiedades. En general, mantén el código QML sencillo, ameno y legible. Así se consigue un buen rendimiento.
  • Sustituye los controles complejos por imágenes o sombreadores si el tiempo de creación supone un problema.

No hagas lo siguiente:

  • Excederte con QML. Aunque utilices QML, no es necesario que lo hagas absolutamente todo en QML.
  • Inicializarlo todo en tu main.cpp.
  • Crear singletons grandes que contengan todas las interfaces necesarias.
  • Crear delegados complejos para « ListView » u otras vistas.
  • Utilizar «clip» a menos que sea absolutamente necesario.
  • Caiga en la trampa habitual de abusar de los Loaders. Loader es ideal para la carga diferida de elementos grandes, como las páginas de la aplicación, pero supone una sobrecarga excesiva para cargar elementos sencillos. No es magia negra que acelere todo y cualquier cosa. Es un elemento adicional con un contexto QML adicional.

Estas prácticas ayudan a conseguir tiempos de arranque inferiores a un segundo y una experiencia de usuario fluida, especialmente en dispositivos integrados.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.