Artículo técnico

Encuentre qué acapara memoria PDF con grafos de HotPDF

Para un informe de 400 páginas que incrusta una única fuente de 2 MB, cobrarle a cada página todo lo que referencia produce un total extraño: las páginas suman 800 MB de fuente en un fichero que quizá ocupe 30 MB en disco. Reparta en cambio la fuente a partes iguales y cada página cuesta unos 5 KB, con lo que nada parece caro y la memoria parece salir de ninguna parte. Ninguno de los dos números responde a la pregunta real: cuántos bytes se liberarían si un objeto concreto desapareciera

Esa cifra tiene nombre en el análisis de heap, tamaño retenido, y la teoría de grafos ofrece una forma limpia de calcularla. Un objeto se le imputa a su dominador, el objeto más cercano por el que toda ruta desde la raíz tiene que pasar para llegar a él. Los objetos compartidos flotan hacia arriba hasta alcanzar un nodo que de verdad los posee, los exclusivos se quedan donde están, y los totales cuadran sin contabilizaciones dobles

Tamaño superficial, tamaño retenido y la regla del dominador en HotPDF

HotPDF calcula esto para un documento cargado mediante THotPDF.BuildLoadedObjectDependencyGraph. La llamada devuelve un THPDFObjectDependencyNode por cada objeto indirecto cargado y un THPDFObjectDependencyEdge por cada referencia indirecta, y después ejecuta un análisis de dominadores con raíz en el Catalog del documento, el objeto nombrado por la entrada /Root del trailer (ISO 32000-1 §7.7.2). Cada nodo lleva dos tamaños. EstimatedShallowBytes es lo que el objeto cuesta por sí solo. EstimatedRetainedBytes es su propio coste más el coste superficial de cada objeto que domina

Volvamos a la fuente. Cada página la referencia, así que ninguna página la domina por sí sola; las rutas solo convergen en el nodo del árbol de páginas situado sobre esas páginas, que en un árbol plano es el objeto /Pages raíz. Los 2 MB de la fuente caen ahí y luego ascienden hasta el Catalog. Un XObject de imagen dibujado en la página 12 y en ninguna otra es el caso contrario: toda ruta hacia él pasa por la página 12, de modo que el tamaño retenido de la página 12 incluye la imagen entera. Por eso, lo más alto de la lista de retenidos es una lista de objetos cuya eliminación liberaría memoria

HotPDF: grafo de dependencias donde un dominador imputa los bytes retenidos: un XObject de imagen que mantiene una sola página se le imputa a esa página mientras una fuente compartida por todas las páginas se le imputa al Catalog
La regla del dominador imputa a esa página un XObject de imagen que mantiene viva una única página, mientras que una fuente que referencian todas las páginas asciende hasta el Catalog — los totales retenidos por tanto suman sin contabilizaciones dobles

La misma aritmética regala una comprobación cruzada. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes equivale a la suma de tamaños superficiales de todos los objetos alcanzables desde el Catalog, y TotalEstimatedBytes es la suma de tamaños superficiales de todos los objetos cargados, alcanzables o no. La diferencia entre ambos es memoria retenida por objetos a los que el documento ya no apunta

Ejecutar el grafo y leer un resultado fallido

El método devuelve True solo cuando el análisis completo terminó, y ese valor de retorno es lo que hay que comprobar. Un resultado False también rellena el registro de información, pero los arrays no son algo de lo que informar. Cuando el recuento de objetos supera MaxObjects (por defecto 250.000), el método se detiene antes de construir nodos y fija ObjectCount en uno más que el límite, de modo que usted se entera de que el límite era demasiado pequeño, no de lo grande que es el documento. Cuando se alcanza el presupuesto de aristas (por defecto 2.000.000) o el límite de anidamiento de 256 niveles para objetos directos durante el barrido, los nodos vuelven con tamaños superficiales parciales y sin tamaños retenidos ni alcanzabilidad

uses
  SysUtils, HPDFDoc;

procedure ProfileLoadedPdf(const FileName: string);
var
  Pdf: THotPDF;
  Nodes: THPDFObjectDependencyNodeArray;
  Edges: THPDFObjectDependencyEdgeArray;
  Info: THPDFObjectDependencyGraphInfo;
begin
  Pdf := THotPDF.Create(nil);
  try
    // LoadFromFile devuelve el número de páginas; 0 significa que la carga falló
    if Pdf.LoadFromFile(FileName) = 0 then
      Exit;

    // Límites elevados para una ejecución forense sin conexión
    if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
      1000000, 8000000) then
    begin
      // Log es su propia rutina de registro
      Log(Format('graph incomplete: %s (limit %s, invalid %s, objects %d)',
        [string(Info.Diagnostic), BoolToStr(Info.LimitExceeded, True),
         BoolToStr(Info.InvalidObjectGraph, True), Info.ObjectCount]));
      Exit; // no ordene ni sume un array de nodos parcial
    end;

    Log(Format('%d objects, %d edges (%d unresolved), %d reachable',
      [Info.ObjectCount, Info.EdgeCount, Info.UnresolvedReferenceCount,
       Info.ReachableObjectCount]));
    Log(Format('estimated %d bytes, Catalog retains %d, unreachable %d',
      [Info.TotalEstimatedBytes, Info.CatalogRetainedBytes,
       Info.TotalEstimatedBytes - Info.CatalogRetainedBytes]));

    LogTopRetained(Nodes, Edges, 10);
  finally
    Pdf.Free;
  end;
end;

Dos indicadores más merecen una mirada en esa rama de fallo. InvalidObjectGraph se activa cuando el objeto Catalog no se encuentra entre los objetos cargados, o cuando un objeto directo resulta contenerse a sí mismo, lo que solo ocurre en entradas mal formadas. LimitExceeded cubre también un análisis de dominadores que no ha convergido tras 128 pasadas. Diagnostic explica cada caso en una línea. Pasar cero o un valor negativo en MaxObjects, o un MaxEdges negativo, lanza EArgumentOutOfRangeException en lugar de devolver False

Cuando la llamada falla por un límite, tire los arrays y ejecútela de nuevo con límites mayores. Los tamaños superficiales parciales parecen verosímiles en un registro y están equivocados exactamente de la manera que manda a la gente tras el objeto equivocado. Los límites existen porque el grafo tiene su propio coste: cada arista guarda una cadena Path, así que una ejecución de ocho millones de aristas asigna ocho millones de cadenas pequeñas encima del documento que está midiendo. Su sitio es una ruta de diagnóstico que alguien lanza a propósito

¿Qué cuenta realmente EstimatedShallowBytes?

EstimatedShallowBytes estima memoria residente, no bytes en el fichero. Para cada objeto suma el tamaño de instancia del objeto analizado y de sus hijos directos, las ranuras que mantienen las listas de diccionarios y arrays, la longitud de cada clave, nombre y cadena, y la carga útil de un flujo si esa carga está en RAM: un flujo de memoria, o un flujo de carga diferida que ya se ha leído a memoria. Un flujo cuyos bytes siguen en el fichero de origen, o que se ha derramado a un fichero temporal, solo aporta su sobrecarga de objeto

Eso tiene una consecuencia práctica. Un fichero cargado de escaneos perfilado justo después de la carga puede mostrar tamaños retenidos modestos para sus imágenes, porque nada las ha decodificado todavía. Ejecute el grafo después del paso que hizo crecer el proceso (renderizado, extracción de texto, una fusión) y los flujos materializados aparecerán con su peso real. Para una comprobación reproducible, perfile el mismo fichero dos veces, una justo tras LoadFromFile y otra tras la operación cara, y compare las entradas superiores

ObjectType es grueso. Informa del tipo de valor PDF, otStream o otDictionary y demás, así que una imagen, un programa de fuente y un flujo de contenido de página se leen todos como otStream. La arista entrante es donde se ve el papel. THPDFObjectDependencyEdge.Path registra dónde se encontró la referencia en el objeto de origen, empezando por $, con /Key para entradas de diccionario, [n] para elementos de array y /dictionary para el diccionario de un flujo. Una ruta $/Resources/XObject/Im3 desde una página, o $/XObject/Im3 desde un diccionario de recursos separado, significa que el objeto se usa como un XObject llamado Im3; $/FontFile2 viniendo de un descriptor de fuente significa un programa TrueType incrustado; $/Contents[0] significa contenido de página

// Ayudante propio, no forma parte de la biblioteca: ordena los primeros Count nodos por
// tamaño retenido y muestra la ruta de una referencia entrante de cada uno
procedure LogTopRetained(const Nodes: THPDFObjectDependencyNodeArray;
  const Edges: THPDFObjectDependencyEdgeArray; Count: Integer);
var
  Taken: array of Boolean;
  I, J, Best: Integer;
  Via: AnsiString;
begin
  SetLength(Taken, Length(Nodes));
  for I := 1 to Count do
  begin
    Best := -1;
    for J := 0 to High(Nodes) do
      if (not Taken[J]) and ((Best < 0) or
         (Nodes[J].EstimatedRetainedBytes >
          Nodes[Best].EstimatedRetainedBytes)) then
        Best := J;
    if Best < 0 then
      Break;
    Taken[Best] := True;

    Via := '(no incoming reference)';
    for J := 0 to High(Edges) do
      if Edges[J].Resolved and
         (Edges[J].TargetObjectNumber = Nodes[Best].ObjectNumber) and
         (Edges[J].TargetGenerationNumber = Nodes[Best].GenerationNumber) then
      begin
        Via := Edges[J].Path;
        Break;
      end;

    Log(Format('%d %d obj  shallow %d  retained %d  refs in %d  via %s',
      [Nodes[Best].ObjectNumber, Nodes[Best].GenerationNumber,
       Nodes[Best].EstimatedShallowBytes, Nodes[Best].EstimatedRetainedBytes,
       Nodes[Best].IncomingReferenceCount, string(Via)]));
  end;
end;

Una ruta entrante basta para clasificar la mayoría de los objetos. Para un objeto compartido, IncomingReferenceCount le dice cuántas referencias hay, y ImmediateDominatorObjectNumber con su número de generación le dice qué objeto lo posee tras el análisis de dominadores. Ese campo vale -1 para el Catalog y para cada objeto que el Catalog no puede alcanzar. Una arista cuyo indicador Resolved es False apunta a un número de objeto que no está cargado; esas se cuentan en UnresolvedReferenceCount, y un recuento alto en un fichero por lo demás sano suele significar una sección de referencias cruzadas dañada

¿De dónde salen los objetos inalcanzables?

Un nodo con ReachableFromCatalog a False está cargado y cuesta memoria, pero ninguna cadena de referencias desde el Catalog conduce a él, así que nada en la estructura del documento lleva un visor hasta él. Su tamaño retenido equivale a su tamaño superficial, porque el análisis de dominadores solo se ejecuta sobre objetos alcanzables. Sumar EstimatedRetainedBytes sobre los nodos inalcanzables da por tanto la misma respuesta que TotalEstimatedBytes - CatalogRetainedBytes

Las actualizaciones incrementales son una fuente habitual, aunque no de la manera que la gente suele asumir. Cuando una revisión posterior redefine el objeto 2120, gana la entrada más nueva de la tabla de referencias cruzadas y la definición antigua nunca se carga, así que las copias sustituidas de un mismo número de objeto no aparecen en el grafo. Lo que sí aparece es un objeto al que una revisión posterior simplemente dejó de referenciar: una anotación retirada de un array /Annots reescrito, una imagen reemplazada por un número de objeto nuevo, un campo de formulario eliminado del AcroForm. Nada en ISO 32000-1 §7.5.6 obliga a una actualización a marcar esas entradas como libres, y mientras los datos de referencias cruzadas las mantengan como en uso, el cargador las trata como objetos vivos. El artículo sobre flujos de objetos y actualizaciones incrementales explica cómo se apilan las revisiones

HotPDF: una actualización incremental reenruta una referencia hacia un objeto nuevo y deja el objeto previamente referenciado cargado pero inalcanzable desde el Catalog
Una actualización que apunta el documento a un objeto nuevo deja el objeto previamente referenciado listado y cargado pero fuera del alcance del Catalog, y sus bytes siguen contando en TotalEstimatedBytes

Las otras dos fuentes son productores que escriben objetos y luego no llegan a enlazarlos, y ficheros dañados cuyos datos de referencias cruzadas hubo que reconstruir barriendo, lo cual puede recoger definiciones de objeto que nada referencia. Cuando una parte grande del total estimado está en nodos inalcanzables, reescribir el fichero limpiamente gana a añadir otra revisión más, y el grafo le da el recuento de bytes que justifica el guardado más lento

¿Es el analizador quien retiene la memoria?

Antes de culpar al documento, compruebe cómo se comportó la carga. Dos llamadas describen al analizador en lugar del contenido, y ambas se reinician al principio de cada LoadFromFile o LoadFromStream, así que siempre describen la carga más reciente

GetLastParserArenaStatistics rellena un registro THPDFParserArenaStatistics para el área de bloques que guarda tokens y búferes de vida corta durante el análisis. Los bloques son de 64 KiB (BlockSize), y una asignación mayor que un bloque recibe un bloque de su propio tamaño. AllocationCount menos ReusedAllocationCount equivale a BlockAllocationCount, el número de veces que el área tuvo que pedir un bloque nuevo al gestor de memoria. Los bloques se conservan durante la vida de la instancia THotPDF y se liberan al destruirla. Si una instancia procesa un lote entero, RetainedBytes refleja aproximadamente el mayor conjunto de trabajo que cualquier fichero del lote necesitó, lo que explica una meseta que dura hasta que se libera el componente. TemporaryObjectElisionCount cuenta las claves de diccionario leídas directamente en el área en lugar de construirse como objetos de nombre temporales

GetDocumentStringInternStatistics describe el pool por documento que deduplica nombres PDF, operadores de flujo de contenido y cadenas cortas. Las cadenas de 1 a 64 bytes son elegibles. El pool retiene como máximo 65.536 entradas y 4 MiB, y esos topes vuelven en el registro como MaxStringLength, MaxEntryCount y MaxRetainedBytes. Una cadena vacía, de más de 64 bytes, o nueva cuando el pool está lleno se cuenta en BypassCount y se conserva como cadena ordinaria. Un fichero que genera enormes cantidades de nombres únicos cuesta por tanto aproximadamente lo que costaría sin el pool, y no más

var
  Arena: THPDFParserArenaStatistics;
  Intern: THPDFDocumentStringInternStatistics;
begin
  if Pdf.GetLastParserArenaStatistics(Arena) then
    Log(Format('arena: %d blocks, %d bytes held, peak %d, ' +
      '%d new blocks for %d allocations, %d tokens',
      [Arena.RetainedBlockCount, Arena.RetainedBytes, Arena.PeakUsedBytes,
       Arena.BlockAllocationCount, Arena.AllocationCount, Arena.TokenCount]));

  if Pdf.GetDocumentStringInternStatistics(Intern) then
  begin
    Log(Format('intern: %d of %d requests hit, %d bypassed, %d bytes reused',
      [Intern.HitCount, Intern.RequestCount, Intern.BypassCount,
       Intern.ReusedBytes]));
    // Comprobación propia, no es una llamada de la biblioteca: avisa de un pool que alcanzó sus topes
    if (Intern.EntryCount >= Intern.MaxEntryCount) or
       (Intern.RetainedBytes + Intern.MaxStringLength >
        Intern.MaxRetainedBytes) then
      Log('intern pool at its cap: later strings were not deduplicated');
  end;
end;
HotPDF: estadísticas del área del analizador y del pool de internado de cadenas con reutilización de asignaciones y un contador de bypass limitado
El registro del área muestra cuánto tráfico del analizador reutilizó bloques reciclados mientras que el registro del intern muestra al pool ganándose su puesto antes de que sus topes fuercen desvíos — una reutilización alta con un recuento de desvíos bajo absuelve de sospecha al cargador

Los PDF típicos repiten un vocabulario pequeño de nombres y operadores, así que HitCount se queda cerca de RequestCount y ReusedBytes crece con el número de páginas. Un BypassCount que se acerca a RequestCount en un fichero modesto es inusual. En una ruta de ingesta para subidas no confiables, regístrelo

Un orden de triaje para una queja de memoria

Empiece por CatalogRetainedBytes. Si está cerca del crecimiento que midió en el proceso, la memoria está en el documento y lo más alto de la lista de retenidos lo nombrará. Si está muy por debajo, la memoria vive en algún sitio que el grafo no mide, como sus propias cachés, mapas de bits renderizados o el área del analizador, y el registro del área es lo siguiente que hay que leer

  1. Ordene los nodos por EstimatedRetainedBytes y lea la Path entrante de los diez primeros. Los destinos XObject en lo alto suelen apuntar a contenido cargado de escaneos donde el submuestreo compensa; los destinos /FontFile, /FontFile2 o /FontFile3 apuntan a programas de fuente completos incrustados donde bastarían subconjuntos; los flujos /Contents grandes suelen venir de salida vectorial generada, como mapas o exportaciones de CAD
  2. Reste CatalogRetainedBytes a TotalEstimatedBytes. Un resto grande son objetos abandonados, así que la corrección va en el paso de guardado
  3. Lea los registros del área y del intern al final. Rara vez explican gigabytes, pero sí explican un proceso que sigue grande después de cerrar cada documento

Ejecute esos pasos en ese orden. El primero resuelve la mayoría de las quejas, y para documentos muy grandes la respuesta estructural suele ser dejar de mantener el grafo de objetos completo de una vez, que es para lo que está pensado el flujo de trabajo de la API directa de ficheros

Los tres diagnósticos son llamadas de método ordinarias que devuelven registros planos, así que encajan en cualquier registro o telemetría que una aplicación Delphi o C++Builder ya tenga. HotPDF se distribuye como componente VCL nativo con código fuente completo; la documentación y una descarga de prueba están en la página del componente HotPDF Delphi PDF