Artículo técnico

Encuentre qué consume memoria PDF: grafos de HotPDF

Para un reporte de 400 páginas que incrusta una sola 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 archivo que tal vez ocupa 30 MB en disco. Divida la fuente en partes iguales y cada página cuesta unos 5 KB, así que nada parece caro y la memoria parece venir de ningún lado. Ninguno de los dos números responde la pregunta real: cuántos bytes se liberarían si un objeto dado desapareciera

Esa cifra tiene nombre en el análisis de heap, tamaño retenido, y la teoría de grafos tiene una forma limpia de calcularla. Un objeto se le factura 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 llegar a un nodo que realmente los posee, los exclusivos se quedan donde están, y los totales suman sin contar dos veces

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 una THPDFObjectDependencyEdge por cada referencia indirecta, y luego 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 carga dos tamaños. EstimatedShallowBytes es lo que el objeto cuesta por sí solo. EstimatedRetainedBytes es su propio costo más el costo superficial de cada objeto que domina

Volvamos a la fuente. Todas las páginas la referencian, así que ninguna página la domina; las rutas solo convergen en el nodo del árbol de páginas que está encima de esas páginas, que en un árbol plano es el objeto raíz /Pages. Los 2 MB de la fuente aterrizan ahí y luego se consolidan en el Catalog. Un XObject de imagen dibujado en la página 12 y en ningún otro lado es el caso contrario: toda ruta hacia él pasa por la página 12, así que el tamaño retenido de la página 12 incluye la imagen completa. La parte superior de la lista retenida es, por lo tanto, una lista de objetos cuya eliminación liberaría memoria

HotPDF: grafo de dependencias donde un dominador atribuye los bytes retenidos: un XObject de imagen mantenido por una página se le cobra a esa página mientras una fuente compartida por todas las páginas se le cobra al Catalog
La regla del dominador le factura a la página que mantiene vivo un XObject de imagen, mientras que una fuente que todas las páginas referencian se consolida en el Catalog — los totales retenidos así suman sin doble conteo

La misma aritmética regala una verificación cruzada. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes equivale a la suma de los tamaños superficiales de todos los objetos alcanzables desde el Catalog, y TotalEstimatedBytes es la suma de los tamaños superficiales de todos los objetos cargados, alcanzables o no. La brecha 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 revisar. Un resultado False igual llena el registro de información, pero los arreglos no son algo que se pueda reportar. Cuando el conteo de objetos supera MaxObjects (250,000 por defecto), el método se detiene antes de construir nodos y pone ObjectCount en uno más que el límite, así que usted se entera de que el límite era muy pequeño, no de qué tan grande es el documento. Cuando el presupuesto de aristas (2,000,000 por defecto) o el límite de anidamiento de 256 niveles para objetos directos se alcanza durante el escaneo, los nodos regresan 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 conteo de páginas; 0 significa que la carga falló
    if Pdf.LoadFromFile(FileName) = 0 then
      Exit;

    // Límites elevados para una ejecución forense fuera de línea
    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 jerarquice ni sume un arreglo 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;

Otros dos indicadores 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 entrada mal formada. LimitExceeded también cubre un análisis de dominadores que no converge 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, descarte los arreglos y vuélvala a ejecutar con cotas más grandes. Los tamaños superficiales parciales se ven plausibles en un log y están equivocados justo de la forma que manda a la gente tras el objeto equivocado. Las cotas existen porque el grafo tiene un costo propio: 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. Esto pertenece a una ruta de diagnóstico que alguien dispara a propósito

¿Qué cuenta realmente EstimatedShallowBytes?

EstimatedShallowBytes estima memoria residente, no bytes en el archivo. Para cada objeto suma el tamaño de instancia del objeto parseado y sus hijos directos, los slots que sostienen las listas de diccionarios y arreglos, la longitud de cada clave, nombre y cadena, y el payload de un stream si ese payload está en RAM: un memory stream, o un stream de carga diferida que ya fue leído a memoria. Un stream cuyos bytes aún viven en el archivo de origen, o que fue derramado a un archivo temporal, contribuye solo su overhead de objeto

Eso tiene una consecuencia práctica. Un archivo 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 aún. Ejecute el grafo después del paso que hizo crecer el proceso (renderizado, extracción de texto, una combinación) y los streams materializados aparecerán con su peso real. Para una verificación reproducible, perfile el mismo archivo dos veces, una justo después de LoadFromFile y otra después de la operación costosa, y compare las entradas superiores

ObjectType es grueso. Reporta el tipo de valor PDF, otStream u otDictionary y así sucesivamente, así que una imagen, un programa de fuente y un content stream de página se leen todos como otStream. La arista entrante es donde se ve el rol. THPDFObjectDependencyEdge.Path registra en qué parte del objeto origen se encontró la referencia, empezando en $, con /Key para entradas de diccionario, [n] para elementos de arreglo y /dictionary para el diccionario de un stream. Una ruta $/Resources/XObject/Im3 desde una página, o $/XObject/Im3 desde un diccionario de recursos aparte, 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

// Su propio helper, no parte de la librería: ordena los primeros Count nodos por
// tamaño retenido e imprime 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 es -1 para el Catalog y para todo 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 conteo alto en un archivo 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 en False está cargado y cuesta memoria, pero ninguna cadena de referencias desde el Catalog llega a él, así que nada en la estructura del documento lleva a un visor hasta él. Su tamaño retenido equivale a su tamaño superficial, porque el análisis de dominadores solo corre sobre objetos alcanzables. Sumar EstimatedRetainedBytes sobre los nodos inalcanzables da entonces la misma respuesta que TotalEstimatedBytes - CatalogRetainedBytes

Las actualizaciones incrementales son una fuente común, aunque no de la forma que la gente suele asumir. Cuando una revisión posterior redefine el objeto 2120, la entrada de referencias cruzadas más nueva gana y la definición anterior nunca se carga, así que las copias sustituidas del mismo número de objeto no aparecen en el grafo. Lo que sí aparece es un objeto que una revisión posterior simplemente dejó de referenciar: una anotación eliminada de un arreglo /Annots reescrito, una imagen reemplazada por un nuevo número de objeto, un campo de formulario quitado 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 listen como en uso, el cargador las trata como objetos vivos. El artículo sobre object streams y actualizaciones incrementales cubre cómo se apilan las revisiones

HotPDF: actualización incremental que reconecta una referencia a un objeto nuevo y deja el objeto antes referenciado cargado pero inalcanzable desde el Catalog
Una actualización que apunta el documento a un objeto nuevo deja el objeto antes 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 fallan en enlazarlos, y archivos dañados cuyos datos de referencias cruzadas tuvieron que reconstruirse escaneando, lo que puede recoger definiciones de objetos que nada referencia. Cuando una gran parte del total estimado vive en nodos inalcanzables, una reescritura limpia del archivo le gana a anexar otra revisión más, y el grafo le da el conteo de bytes para justificar el guardado más lento

¿Es el parser el que retiene la memoria?

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

GetLastParserArenaStatistics llena un registro THPDFParserArenaStatistics para la arena de bloques que sostiene tokens y búferes de vida corta durante el parseo. 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 la arena tuvo que pedirle un bloque nuevo al administrador de memoria. Los bloques se conservan durante la vida de la instancia THotPDF y se liberan cuando se destruye. Si una instancia procesa un lote completo, RetainedBytes refleja aproximadamente el mayor working set que cualquier archivo del lote necesitó, lo que explica una meseta que dura hasta que el componente se libera. TemporaryObjectElisionCount cuenta las claves de diccionario leídas directo a la arena en lugar de construirse como objetos de nombre temporales

GetDocumentStringInternStatistics describe el pool por documento que deduplica nombres PDF, operadores de content stream 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 regresan 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 archivo que genera cantidades enormes de nombres únicos cuesta entonces 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]));
    // Su propia verificación, no una llamada de la librería: marca 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 de la arena del parser y del pool de internado de cadenas con reutilización de asignaciones y un contador de bypass con tope
El registro de la arena muestra cuánto tráfico del parser reutilizó bloques reciclados mientras que el registro de intern muestra al pool ganándose su lugar antes de que sus topes fuercen desvíos — alta reutilización con un conteo bajo de bypasses descarga 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 conteo de páginas. Un BypassCount que se acerca a RequestCount en un archivo modesto es inusual. En una ruta de ingesta de subidas no confiables, regístrelo

Un orden de triaje para una queja de memoria

Comience con CatalogRetainedBytes. Si está cerca del crecimiento que midió en el proceso, la memoria está en el documento y la cima de la lista retenida lo nombrará. Si está muy por debajo, la memoria vive en algún lado que el grafo no mide, como sus propios cachés, bitmaps renderizados o la arena del parser, y el registro de la arena es lo siguiente que hay que leer

  1. Jerarquice los nodos por EstimatedRetainedBytes y lea la Path entrante de los diez primeros. Los objetivos XObject en la cima suelen apuntar a contenido cargado de escaneos donde el downsampling paga; los objetivos /FontFile, /FontFile2 o /FontFile3 apuntan a programas de fuente completos incrustados donde bastarían subconjuntos; los streams /Contents grandes suelen venir de salida vectorial generada, como mapas o exportaciones CAD
  2. Reste CatalogRetainedBytes de TotalEstimatedBytes. Un residuo grande son objetos varados, así que la corrección pertenece al paso de guardado
  3. Lea los registros de arena e intern al final. Rara vez explican gigabytes, pero sí explican un proceso que se queda grande después de cerrar cada documento

Ejecute esos pasos en ese orden. El primero zanja la mayoría de las quejas, y para documentos muy grandes la respuesta estructural suele ser dejar de sostener el grafo de objetos completo a la vez, que es para lo que está hecho el flujo de trabajo de la API de archivo directo

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