Technischer Artikel

HotPDF: PDF-Speicherfresser per Objektgraph finden

Ein 400-Seiten-Bericht mit einer eingebetteten 2-MB-Schriftart erzeugt, wenn man jede Seite für alles belastet, was sie referenziert, eine seltsame Summe: Die Seiten kommen zusammen auf 800 MB Schriftart in einer Datei, die auf der Platte vielleicht 30 MB hat. Teilt man die Schriftart stattdessen gleichmäßig auf, kostet jede Seite etwa 5 KB, nichts wirkt teuer, und der Speicher scheint aus dem Nichts zu kommen. Keine der beiden Zahlen beantwortet die eigentliche Frage: Wie viele Bytes würden freigegeben, wenn ein bestimmtes Objekt verschwände

Diese Zahl hat in der Heap-Analyse einen Namen: Retained Size. Und die Graphentheorie liefert eine saubere Methode, sie zu berechnen. Ein Objekt wird seinem Dominator zugerechnet, dem nächstgelegenen Objekt, durch das jeder Pfad von der Wurzel auf dem Weg zu ihm hindurch muss. Geteilte Objekte wandern nach oben, bis sie bei einem Knoten ankommen, der sie wirklich besitzt; exklusive bleiben, wo sie sind, und die Summen addieren sich ohne Doppelzählung

Shallow-Größe, Retained-Größe und die Dominator-Regel in HotPDF

HotPDF berechnet das für ein geladenes Dokument über THotPDF.BuildLoadedObjectDependencyGraph. Der Aufruf liefert einen THPDFObjectDependencyNode pro geladenem indirekten Objekt und eine THPDFObjectDependencyEdge pro indirekter Referenz, dann läuft eine Dominator-Analyse mit Wurzel im Catalog des Dokuments, dem Objekt hinter dem /Root-Eintrag des Trailers (ISO 32000-1 §7.7.2). Jeder Knoten trägt zwei Größen. EstimatedShallowBytes ist, was das Objekt allein kostet. EstimatedRetainedBytes ist diese Kostenposition plus die Shallow-Kosten jedes Objekts, das er dominiert

Zurück zur Schriftart. Jede Seite referenziert sie, also dominiert keine einzelne Seite sie; die Pfade laufen erst im Seitenbaum-Knoten über diese Seiten zusammen, der in einem flachen Baum das Wurzelobjekt /Pages ist. Die 2 MB der Schriftart landen dort und rollen dann in den Catalog auf. Ein Bild-XObject, das nur auf Seite 12 gezeichnet wird, ist der Gegenfall: Jeder Pfad zu ihm läuft über Seite 12, also enthält die Retained-Größe von Seite 12 das ganze Bild. Die Spitze der Retained-Liste ist damit eine Liste von Objekten, deren Entfernung Speicher freigeben würde

HotPDF: Abhängigkeitsgraph, in dem ein Dominator behaltene Bytes zuschreibt: ein Bild-XObject, das eine Seite hält, belastet diese Seite, während eine von jeder Seite geteilte Schrift den Catalog belastet
Die Dominator-Regel verrechnet ein von einer einzigen Seite am Leben gehaltenes Bild-XObject dieser Seite, während eine Schrift, auf die jede Seite verweist, zum Catalog aufsummiert wird — retained-Summen addieren sich so ohne Doppelzählung

Dieselbe Rechnung liefert eine Gegenprobe gratis. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes entspricht der summierten Shallow-Größe aller vom Catalog aus erreichbaren Objekte, und TotalEstimatedBytes ist die summierte Shallow-Größe aller geladenen Objekte, erreichbar oder nicht. Die Lücke zwischen beiden ist Speicher, den Objekte halten, auf die das Dokument nicht mehr zeigt

Den Graphen laufen lassen und ein fehlgeschlagenes Ergebnis lesen

Die Methode liefert nur dann True, wenn die gesamte Analyse durchgelaufen ist, und dieser Rückgabewert ist das, was man prüfen muss. Ein False-Ergebnis füllt den Info-Record trotzdem, aber die Arrays sind nichts, womit man berichten sollte. Übersteigt die Objektzahl MaxObjects (Standard 250.000), bricht die Methode ab, bevor sie irgendeinen Knoten baut, und setzt ObjectCount auf genau einen mehr als das Limit — man erfährt also, dass das Limit zu klein war, nicht, wie groß das Dokument ist. Wird während des Scans das Kantenbudget (Standard 2.000.000) oder die 256-stufige Verschachtelungsgrenze für direkte Objekte erreicht, kommen die Knoten mit teilweisen Shallow-Größen zurück und ganz ohne Retained-Größen oder Erreichbarkeitsangaben

uses
  SysUtils, HPDFDoc;

procedure ProfileLoadedPdf(const FileName: string);
var
  Pdf: THotPDF;
  Nodes: THPDFObjectDependencyNodeArray;
  Edges: THPDFObjectDependencyEdgeArray;
  Info: THPDFObjectDependencyGraphInfo;
begin
  Pdf := THotPDF.Create(nil);
  try
    // LoadFromFile liefert die Seitenzahl; 0 bedeutet, das Laden ist fehlgeschlagen
    if Pdf.LoadFromFile(FileName) = 0 then
      Exit;

    // Erhöhte Grenzen für einen forensischen Offline-Lauf
    if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
      1000000, 8000000) then
    begin
      // Log ist Ihre eigene Logging-Routine
      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; // kein teilweises Node-Array rangieren oder aufsummieren
    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;

Zwei weitere Flags verdienen in diesem Fehlerzweig einen Blick. InvalidObjectGraph wird gesetzt, wenn das Catalog-Objekt unter den geladenen Objekten nicht zu finden ist oder wenn sich ein direktes Objekt am Ende selbst enthält — das passiert nur bei fehlerhaften Eingabedateien. LimitExceeded deckt auch eine Dominator-Analyse ab, die nach 128 Durchläufen nicht zur Ruhe kommt. Diagnostic erklärt jeden dieser Fälle in einer Zeile. Null oder ein negativer Wert für MaxObjects, ein negativer MaxEdges-Wert löst dagegen EArgumentOutOfRangeException aus, statt False zurückzugeben

Schlägt der Aufruf an einem Limit fehl, werfen Sie die Arrays weg und lassen ihn mit größeren Grenzen erneut laufen. Partielle Shallow-Größen sehen in einem Log plausibel aus und sind genau auf die Art falsch, die der Fehlersuche das falsche Objekt vor die Füße wirft. Die Grenzen existieren, weil der Graph selbst Kosten hat: Jede Kante speichert einen Path-String, also allokiert ein Lauf mit acht Millionen Kanten acht Millionen kleine Strings — obendrauf zu dem Dokument, das er gerade misst. So etwas gehört in einen Diagnosepfad, den jemand bewusst anstößt

Was zählt EstimatedShallowBytes tatsächlich?

EstimatedShallowBytes schätzt residenten Speicher, nicht Bytes in der Datei. Pro Objekt kommt hinzu: die Instanzgröße des geparsten Objekts samt seiner direkten Kinder, die Slots, die Dictionary- und Array-Listen halten, die Länge jedes Schlüssels, Namens und Strings, und der Payload eines Streams, falls dieser im RAM liegt — ein Memory-Stream oder ein lazy geladener Stream, der bereits in den Speicher gelesen wurde. Ein Stream, dessen Bytes noch in der Quelldatei liegen oder der in eine temporäre Datei ausgelagert wurde, trägt nur seinen Objekt-Overhead bei

Das hat eine praktische Konsequenz. Eine scan-lastige Datei, direkt nach dem Laden profiliert, kann für ihre Bilder bescheidene Retained-Größen zeigen, weil noch nichts sie dekodiert hat. Lässt man den Graphen nach dem Schritt laufen, der den Prozess wachsen ließ (Rendering, Textextraktion, ein Merge), tauchen die materialisierten Streams mit ihrem echten Gewicht auf. Für einen reproduzierbaren Check: dieselbe Datei zweimal profilieren, einmal direkt nach LoadFromFile, einmal nach der teuren Operation, und die obersten Einträge vergleichen

ObjectType ist grob. Er meldet den PDF-Werttyp, otStream oder otDictionary und so weiter, weshalb ein Bild, ein Font-Programm und ein Seiten-Content-Stream alle als otStream durchgehen. Die eingehende Kante verrät die Rolle. THPDFObjectDependencyEdge.Path hält fest, wo im Quellobjekt die Referenz gefunden wurde, beginnend bei $, mit /Key für Dictionary-Einträge, [n] für Array-Elemente und /dictionary für das Dictionary eines Streams. Ein Pfad $/Resources/XObject/Im3 von einer Seite aus, oder $/XObject/Im3 aus einem separaten Resource-Dictionary, heißt, das Objekt dient als XObject namens Im3; $/FontFile2 von einem Font-Descriptor heißt ein eingebettetes TrueType-Programm; $/Contents[0] heißt Seiteninhalt

// Eigener Helfer, kein Bestandteil der Bibliothek: rangiert die obersten
// Count-Knoten nach Retained-Größe und gibt je Knoten einen Pfad aus
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;

Eine einzige eingehende Referenz reicht, um die meisten Objekte einzuordnen. Bei einem geteilten Objekt sagt IncomingReferenceCount, wie viele Referenzen es gibt, und ImmediateDominatorObjectNumber samt Generationsnummer sagt, welches Objekt es nach der Dominator-Analyse besitzt. Dieses Feld ist -1 für den Catalog und für jedes Objekt, das der Catalog nicht erreicht. Eine Kante mit Resolved auf False zeigt auf eine Objektnummer, die nicht geladen ist; solche zählen in UnresolvedReferenceCount, und ein hoher Wert bei einer sonst gesunden Datei bedeutet meist einen beschädigten Cross-Reference-Abschnitt

Woher kommen unerreichbare Objekte?

Ein Knoten mit ReachableFromCatalog auf False ist geladen und kostet Speicher, aber keine Referenzkette vom Catalog aus führt zu ihm, also führt auch nichts in der Dokumentstruktur einen Viewer zu ihm. Seine Retained-Größe entspricht seiner Shallow-Größe, denn die Dominator-Analyse läuft nur über erreichbare Objekte. Die Summe von EstimatedRetainedBytes über alle unerreichbaren Knoten liefert deshalb dasselbe Ergebnis wie TotalEstimatedBytes - CatalogRetainedBytes

Inkrementelle Updates sind eine häufige Quelle, nur nicht auf die Art, wie man meist annimmt. Redefiniert eine spätere Revision Objekt 2120, gewinnt der neueste Cross-Reference-Eintrag, und die ältere Definition wird nie geladen — überholte Kopien derselben Objektnummer tauchen im Graphen also nicht auf. Was auftaucht, ist ein Objekt, das eine spätere Revision schlicht nicht mehr referenziert: eine Annotation, die aus einem neu geschriebenen /Annots-Array geflogen ist, ein Bild, das eine neue Objektnummer ersetzt hat, ein Formularfeld, das aus dem AcroForm entfernt wurde. Nichts in ISO 32000-1 §7.5.6 verpflichtet ein Update, diese Einträge als frei zu markieren, und solange die Cross-Reference-Daten sie als belegt listen, behandelt der Loader sie als lebende Objekte. Der Artikel zu Object Streams und inkrementellen Updates beschreibt, wie Revisionen übereinander stapeln

HotPDF: Inkrementelles Update, das eine Referenz auf ein neues Objekt umhängt und das zuvor referenzierte Objekt geladen lässt, aber unerreichbar vom Catalog
Ein Update, das das Dokument auf ein neues Objekt zeigt, lässt das zuvor referenzierte Objekt gelistet und geladen zurück, außerhalb der Reichweite des Catalog, und seine Bytes zählen weiter in TotalEstimatedBytes

Die anderen beiden Quellen sind Producer, die Objekte schreiben und dann versäumen, sie zu verknüpfen, und beschädigte Dateien, deren Cross-Reference-Daten per Scan rekonstruiert werden mussten — dabei können Objektdefinitionen eingesammelt werden, auf die nichts verweist. Steckt ein großer Anteil der geschätzten Gesamtsumme in unerreichbaren Knoten, schlägt ein sauberes Neuschreiben der Datei jede weitere angehängte Revision, und der Graph liefert die Bytezahl, um den langsameren Save zu rechtfertigen

Ist der Parser der, der den Speicher hält?

Bevor Sie dem Dokument die Schuld geben, prüfen Sie, wie das Laden selbst gelaufen ist. Zwei Aufrufe beschreiben den Parser statt den Inhalt, und beide setzen sich zu Beginn jedes LoadFromFile oder LoadFromStream zurück — sie beschreiben also immer die zuletzt geladene Datei

GetLastParserArenaStatistics füllt einen THPDFParserArenaStatistics-Record für die Block-Arena, die während des Parsens kurzlebige Tokens und Puffer hält. Blöcke sind 64 KiB groß (BlockSize), und eine Allokation größer als ein Block bekommt einen Block in eigener Größe. AllocationCount minus ReusedAllocationCount ergibt BlockAllocationCount, die Zahl der Male, zu denen die Arena den Memory-Manager um einen neuen Block bitten musste. Blöcke bleiben über die Lebensdauer der THotPDF-Instanz erhalten und werden freigegeben, wenn sie zerstört wird. Verarbeitet eine Instanz einen ganzen Batch, spiegelt RetainedBytes ungefähr das größte Working Set, das irgendeine Datei des Batchs brauchte — das erklärt ein Plateau, das bis zur Freigabe der Komponente anhält. TemporaryObjectElisionCount zählt Dictionary-Schlüssel, die direkt in die Arena gelesen statt als temporäre Name-Objekte gebaut werden

GetDocumentStringInternStatistics beschreibt den Pool pro Dokument, der PDF-Namen, Content-Stream-Operatoren und kurze Strings dedupliziert. Strings von 1 bis 64 Bytes sind kandidierbar. Der Pool fasst höchstens 65.536 Einträge und 4 MiB, und diese Obergrenzen kommen als MaxStringLength, MaxEntryCount und MaxRetainedBytes im Record zurück. Ein String, der leer ist, länger als 64 Bytes oder neu ist, während der Pool voll ist, zählt in BypassCount und bleibt ein gewöhnlicher String. Eine Datei, die massenhaft eindeutige Namen erzeugt, kostet deshalb ungefähr das, was sie ohne den Pool kosten würde, und nicht mehr

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]));
    // Eigene Prüfung, kein Bibliotheksaufruf: markiert einen Pool an Obergrenzen
    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: Parser-Arena- und String-Intern-Pool-Statistiken mit Allokationswiederverwendung und einem gekappten Bypass-Zähler
Der Arena-Datensatz zeigt, wie viel Parser-Verkehr recycelte Blöcke wiederverwendete, während der Intern-Datensatz zeigt, wie sich der Pool verdient, bevor seine Grenzen Umgehungen erzwingen — hohe Wiederverwendung mit niedriger Bypass-Zahl entlastet den Loader vom Verdacht

Typische PDFs wiederholen einen kleinen Wortschatz aus Namen und Operatoren, deshalb liegt HitCount nahe an RequestCount, und ReusedBytes wächst mit der Seitenzahl. Ein BypassCount, der sich bei einer normalen Datei RequestCount nähert, ist ungewöhnlich. Auf einem Aufnahmepfad für nicht vertrauenswürdige Uploads: mitloggen

Eine Triage-Reihenfolge für eine Speicherbeschwerde

Beginnen Sie mit CatalogRetainedBytes. Liegt die Zahl nahe am Wachstum, das Sie im Prozess gemessen haben, steckt der Speicher im Dokument, und die Spitze der Retained-Liste nennt ihn. Liegt sie weit darunter, wohnt der Speicher irgendwo, das der Graph nicht misst — eigene Caches, gerenderte Bitmaps oder die Parser-Arena — und der Arena-Record ist der nächste, den man liest

  1. Knoten nach EstimatedRetainedBytes rangieren und die eingehenden Path-Angaben der obersten zehn lesen. XObject-Ziele an der Spitze deuten meist auf scan-lastige Inhalte, wo sich Downsampling auszahlt; /FontFile-, /FontFile2- oder /FontFile3-Ziele deuten auf komplette Font-Programme, eingebettet, wo Subsets gereicht hätten; große /Contents-Streams stammen meist aus generierter Vektorausgabe wie Karten oder CAD-Exporten
  2. CatalogRetainedBytes von TotalEstimatedBytes abziehen. Ein großer Rest sind gestrandete Objekte, also gehört die Korrektur in den Save-Schritt
  3. Arena- und Intern-Record zuletzt lesen. Sie erklären selten Gigabytes, aber sie erklären einen Prozess, der nach dem Schließen jedes Dokuments groß bleibt

Diese Schritte in dieser Reihenfolge. Der erste erledigt die meisten Beschwerden, und bei sehr großen Dokumenten lautet die strukturelle Antwort oft, den ganzen Objektgraphen nicht mehr auf einmal zu halten — genau dafür ist der Direct-File-API-Workflow gebaut

Alle drei Diagnosen sind gewöhnliche Methodenaufrufe, die schlichte Records zurückgeben, sodass sie in jedes Logging oder jede Telemetrie passen, das eine Delphi- oder C++Builder-Anwendung bereits hat. HotPDF kommt als native VCL-Komponente mit vollständigem Quellcode; Dokumentation und ein Testdownload finden sich auf der HotPDF Delphi PDF-Komponente-Seite