En esta página

Gestión de memoria en el motor de JavaScript

Introducción

Este documento describe la gestión dinámica de la memoria del motor de JavaScript en QML. Se trata de una descripción bastante técnica y detallada. Solo es necesario leerla si te interesan las características exactas de la gestión de la memoria de JavaScript en QML. En concreto, puede resultarte útil si estás intentando optimizar tu aplicación para obtener el máximo rendimiento.

Nota: Al compilar tu código QML a C++ utilizando el compilador «Qt Quick », puedes evitar gran parte del uso del montón de JavaScript. El código C++ generado utiliza la pila y el montón habituales de C++ para almacenar objetos y valores. Sin embargo, el entorno host de JavaScript siempre utiliza cierta memoria gestionada por JavaScript, independientemente de si la utilizas o no. No obstante, si utilizas funciones que no se pueden compilar a C++, el motor recurrirá a la interpretación o a la compilación JIT y utilizará objetos de JavaScript almacenados en el montón de JavaScript.

Principios básicos

El motor de JavaScript de QML cuenta con un gestor de memoria dedicado que solicita al sistema operativo espacio de direcciones en unidades de varias páginas. A continuación, los objetos, cadenas y otros valores gestionados creados en JavaScript se colocan en este espacio de direcciones, utilizando el propio esquema de asignación del motor de JavaScript. El motor de JavaScript no utiliza las funciones malloc() y free() de la biblioteca de C, ni las implementaciones predeterminadas de new y delete de C++ para asignar memoria a los objetos de JavaScript.

Las solicitudes de espacio de direcciones se realizan generalmente con mmap() en sistemas tipo Unix y con VirtualAlloc() en Windows. Existen varias implementaciones específicas de cada plataforma para estas funciones primitivas. El espacio de direcciones reservado de esta forma no se asigna inmediatamente a la memoria física. Más bien, el sistema operativo detecta cuándo se accede realmente a una página de memoria y solo entonces la asigna. Por lo tanto, el espacio de direcciones es prácticamente gratuito y disponer de una gran cantidad del mismo proporciona al gestor de memoria de JavaScript la flexibilidad que necesita para colocar los objetos de manera eficiente en el montón de JavaScript. Además, existen técnicas específicas de cada plataforma para indicar al sistema operativo que un fragmento de espacio de direcciones, aunque siga estando reservado, no tiene por qué asignarse a la memoria física por el momento. De este modo, el sistema operativo puede liberar la memoria según sea necesario y utilizarla para otras tareas. Es fundamental señalar que la mayoría de los sistemas operativos no garantizan una respuesta inmediata a dicha solicitud de liberación. Solo liberarán la memoria cuando sea realmente necesaria para otra cosa. En sistemas tipo Unix, solemos utilizar madvise() para ello. Windows dispone de indicadores específicos para la función VirtualFree() que permiten realizar lo mismo.

Nota: Existen herramientas de análisis de memoria que no comprenden este mecanismo y exageran el uso de memoria de JavaScript.

Todos los valores almacenados en el montón de JavaScript están sujetos a la recolección de basura. Ninguno de los valores se «elimina» inmediatamente cuando sale del ámbito o se «descartan» de cualquier otra forma. Solo el recolector de basura puede eliminar valores del montón de JavaScript y liberar memoria (véase «Recolección de basura» más abajo para saber cómo funciona).

Tipos basados en QObject

QObjectLos tipos basados en QObject —y, en particular, todo lo que se pueda expresar como un elemento QML— se asignan en el montón de C++. Solo se coloca en el montón de JavaScript un pequeño envoltorio alrededor del puntero cuando se accede a un ` QObject ` desde JavaScript. Sin embargo, dicho envoltorio puede ser propietario del ` QObject ` al que apunta. Véase QJSEngine::ObjectOwnership. Si el envoltorio es propietario del objeto, este se eliminará cuando el propio envoltorio sea recogido por el recolector de basura. También puedes provocar manualmente la eliminación llamando al método `destroy()` sobre él. `destroy()` llama internamente a ` QObject::deleteLater()`. Por lo tanto, no eliminará el objeto de forma inmediata, sino que esperará a la siguiente iteración del bucle de eventos.

Las propiedades de los objetos declaradas en QML se almacenan en el montón de JavaScript. Permanecen activas mientras el objeto al que pertenecen siga existiendo. Posteriormente, se eliminan la próxima vez que se ejecute el recolector de basura.

Asignación de objetos

En JavaScript, cualquier tipo estructurado es un objeto. Esto incluye objetos de función, matrices, expresiones regulares, objetos de fecha y mucho más. QML cuenta con varios tipos de objetos internos, como el envoltorio « QObject » mencionado anteriormente. Cada vez que se crea un objeto, el gestor de memoria le asigna espacio en el montón de JavaScript.

Las cadenas de JavaScript también son valores gestionados, pero sus datos de cadena no se asignan en el montón de JavaScript. Al igual que los envoltorios de ` QObject `, los objetos del montón para las cadenas son simplemente envoltorios ligeros que rodean un puntero a los datos de la cadena.

Al asignar memoria a un objeto, el tamaño de este se redondea primero al alza hasta una alineación de 32 bytes. Cada fragmento de espacio de direcciones de 32 bytes se denomina «ranura». Para los objetos más pequeños que un umbral de «tamaño enorme», el gestor de memoria realiza una serie de intentos para ubicar el objeto en la memoria:

  • El gestor de memoria mantiene listas enlazadas de fragmentos de montón previamente liberados, denominados «bins». Cada bin contiene fragmentos de montón con un tamaño fijo por bin en ranuras. Si el bin del tamaño adecuado no está vacío, selecciona la primera entrada y coloca allí el objeto.
  • La memoria que aún no se ha utilizado se gestiona mediante un asignador «bumper». Un puntero «bumper» apunta al byte situado más allá del espacio de direcciones ocupado. Si todavía hay suficiente espacio de direcciones sin utilizar, el «bumper» se incrementa en consecuencia y el objeto se coloca en el espacio no utilizado.
  • Se mantiene un compartimento independiente para fragmentos del montón previamente liberados de distintos tamaños, siempre que sean mayores que los tamaños específicos mencionados anteriormente. El gestor de memoria recorre esta lista e intenta encontrar un fragmento que pueda dividir para dar cabida al nuevo objeto.
  • El gestor de memoria busca en las listas de compartimentos de tamaños específicos mayores que el objeto que se va a asignar e intenta dividir uno de ellos.
  • Por último, si ninguna de las opciones anteriores funciona, el gestor de memoria reserva más espacio de direcciones y asigna el objeto utilizando el asignador «bumper».

Los objetos de gran tamaño se gestionan mediante su propio asignador. Para cada uno de ellos se obtienen del sistema operativo una o más páginas de memoria independientes, que se gestionan por separado.

Además, cada nuevo fragmento de espacio de direcciones que el gestor de memoria obtiene del sistema operativo recibe un encabezado que contiene una serie de indicadores para cada ranura:

  • objeto: La primera ranura ocupada por un objeto se marca con este bit.
  • extends: Cualquier ranura adicional ocupada por un objeto se marca con este bit.
  • marca: Cuando se ejecuta el recolector de basura, activa este bit si el objeto sigue en uso.

Clases internas

Con el fin de minimizar el almacenamiento necesario para los metadatos sobre los miembros que contiene un objeto, el motor de JavaScript asigna una «clase interna» a cada objeto. Otros motores de JavaScript denominan a esto «clase oculta» o «forma». Las clases internas se deduplican y se almacenan en un árbol. Si se añade una propiedad a un objeto, se comprueban los elementos hijos de la clase interna actual para ver si ya se ha producido antes la misma estructura de objeto. Si es así, podemos utilizar la clase interna resultante de inmediato. De lo contrario, tenemos que crear una nueva.

Las clases internas se almacenan en su propia sección del montón de JavaScript, que por lo demás funciona de la misma manera que la asignación general de objetos descrita anteriormente. Esto se debe a que las clases internas deben mantenerse activas mientras se reciclan los objetos que las utilizan. Posteriormente, las clases internas se reciclan en una pasada independiente.

Sin embargo, los atributos de propiedad reales almacenados en las clases internas no se conservan en el montón de JavaScript, sino que se gestionan mediante «new» y «delete».

Recolección de basura

El recolector de basura utilizado en el motor de JavaScript es un diseño «Mark and Sweep» (marcar y barrer) sin desplazamiento. Desde Qt 6.8, se ejecuta de forma incremental por defecto (a menos que QV4_GC_TIMELIMIT esté establecido en 0). En la fase de marcado, se recorren todos los lugares conocidos donde pueden encontrarse referencias activas a objetos. En concreto:

  • Variables globales de JavaScript
  • Partes no eliminables de las unidades de compilación de QML y JavaScript
  • La pila de JavaScript
  • El almacenamiento de valores persistentes. Aquí es donde las clases « QJSValue » y similares guardan referencias a objetos de JavaScript.

Para cualquier objeto encontrado en esos lugares, se establecen los bits de marcado de forma recursiva para todo aquello a lo que haga referencia.

En la fase de barrido, el recolector de basura recorre entonces todo el montón y libera cualquier objeto que no estuviera marcado anteriormente. La memoria liberada resultante se clasifica en los contenedores para ser utilizada en futuras asignaciones. Si un bloque de espacio de direcciones está completamente vacío, se desasigna, pero el espacio de direcciones se conserva (véanse los «Principios básicos» más arriba). Si el uso de memoria vuelve a aumentar, se reutiliza el mismo espacio de direcciones.

El recolector de basura se activa bien manualmente, llamando a la función ` gc()`, bien mediante una heurística que tiene en cuenta los siguientes aspectos:

  • La cantidad de memoria gestionada por objetos en el montón de JavaScript, pero no asignada directamente en él, como las cadenas y los datos internos de los miembros de clase. Para estos se mantiene un umbral dinámico. Si se supera, se ejecuta el recolector de basura y se aumenta el umbral. Si la cantidad de memoria externa gestionada cae muy por debajo del umbral, este se reduce.
  • El espacio de direcciones total reservado. La asignación de memoria interna en el montón de JavaScript solo se tiene en cuenta una vez que se ha reservado al menos una parte del espacio de direcciones.
  • La reserva adicional de espacio de direcciones desde la última ejecución del recolector de basura. Si la cantidad de espacio de direcciones es más del doble de la cantidad de memoria utilizada tras la última ejecución del recolector de basura, volvemos a ejecutar el recolector de basura.

Análisis del uso de la memoria

Para observar la evolución tanto del espacio de direcciones como del número de objetos asignados en él, lo mejor es utilizar una herramienta especializada. La QML Profiler ofrece una visualización que resulta útil en este sentido. Las herramientas más genéricas no pueden ver lo que hace el gestor de memoria de JavaScript dentro del espacio de direcciones que reserva y es posible que ni siquiera detecten que parte de ese espacio de direcciones no está asignado a la memoria física.

Otra forma de depurar el uso de la memoria son los logging categories `qt.qml.gc.statistics ` y `qt.qml.gc.allocatorStats`. Si activas el nivel de depuración para `qt.qml.gc.statistics`, el recolector de basura mostrará cierta información cada vez que se ejecute:

  • Cuánto espacio de direcciones total está reservado
  • Cuánta memoria estaba en uso antes y después de la recolección de basura
  • Cuántos objetos de distintos tamaños se han asignado hasta el momento

El nivel «Debug» de qt.qml.gc.allocatorStats muestra estadísticas más detalladas que incluyen también cómo se activó el recolector de basura, los tiempos de las fases de marcado y barrido, y un desglose detallado del uso de la memoria por bytes y fragmentos de espacio de direcciones.

© 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.