Technisch artikel

PDF-geheugenvreters vinden met HotPDF-objectgrafen

Neem een rapport van 400 pagina's dat één font van 2 MB insluit: als elke pagina alles betaalt waarnaar ze verwijst, levert dat een vreemd totaal op, want de pagina's komen samen uit op 800 MB font in een bestand dat op schijf hooguit 30 MB meet. Verdeelt u het font eerlijk over de pagina's, dan kost het er elke pagina nog zo'n 5 KB, zodat niets duur lijkt en het geheugen uit het niets lijkt te komen. Geen van beide getallen beantwoordt de echte vraag: hoeveel bytes zouden vrijkomen als een bepaald object zou verdwijnen

In heap-analyse heeft dat getal een naam, retained size, en de graaftheorie rekent het netjes uit. Een object wordt toegerekend aan zijn dominator: het dichtstbijzijnde object dat elk pad vanaf de wortel op weg ernaartoe moet passeren. Gedeelde objecten schuiven omhoog tot ze uitkomen bij een node die ze echt in bezit heeft, exclusieve blijven waar ze staan, en de totalen tellen op zonder dubbeltelling

Shallow size, retained size en de dominatorregel in HotPDF

Voor een geladen document rekent HotPDF dit uit via THotPDF.BuildLoadedObjectDependencyGraph. De aanroep geeft één THPDFObjectDependencyNode terug per geladen indirect object en één THPDFObjectDependencyEdge per indirecte verwijzing, en voert daarna een dominatoranalyse uit met de Catalog van het document als wortel, het object dat de /Root-entry van de trailer noemt (ISO 32000-1 §7.7.2). Elke node draagt twee groottes mee. EstimatedShallowBytes is wat het object op zichzelf kost. EstimatedRetainedBytes is die eigen kost plus de shallow-kost van elk object dat hij domineert

Terug naar het font. Elke pagina verwijst ernaar, dus geen enkele pagina domineert het; de paden komen pas samen in de paginaboomnode boven die pagina's, wat bij een platte boom het /Pages-object aan de wortel is. De 2 MB van het font landt daar en rolt daarna op naar de Catalog. Een image-XObject dat op pagina 12 getekend wordt en nergens anders, is de tegengestelde zaak: elk pad ernaartoe loopt via pagina 12, dus de retained-grootte van pagina 12 omvat de hele afbeelding. De top van de retained-lijst is daarmee een lijst van objecten waarvan verwijdering geheugen zou vrijmaken

HotPDF: Afhankelijkheidsgraaf waarin een dominator retained bytes toewijst: een image-XObject dat door één pagina wordt vastgehouden belast die pagina, terwijl een font dat elke pagina deelt bij de Catalog uitkomt
De dominatorregel rekent een image-XObject dat alleen door één pagina in leven wordt gehouden toe aan die pagina, terwijl een font waarnaar elke pagina verwijst oprolt naar de Catalog — retained-totalen sommeren dus zonder dubbeltelling

Dezelfde rekenkunde levert gratis één kruiscontrole op. THPDFObjectDependencyGraphInfo.CatalogRetainedBytes is gelijk aan de som van de shallow-grootte van elk object dat vanaf de Catalog bereikbaar is, en TotalEstimatedBytes is de som van de shallow-grootte van elk geladen object, bereikbaar of niet. Het gat tussen die twee is geheugen dat door objecten wordt vastgehouden waarnaar het document niet meer wijst

De graaf draaien en een mislukt resultaat lezen

De methode geeft alleen True terug als de hele analyse is afgerond, en die returnwaarde is het eerste wat u controleert. Een False resultaat vult het info-record nog steeds, maar met de arrays valt niets zinnigs te rapporteren. Overschrijdt het objectaantal MaxObjects (standaard 250.000), dan stopt de methode nog voordat er nodes gebouwd worden en zet ze ObjectCount op één meer dan de limiet, zodat u leert dat de limiet te klein was, niet hoe groot het document is. Wordt tijdens de scan het edge-budget (standaard 2.000.000) of de nestingslimiet van 256 niveaus voor directe objecten geraakt, dan komen nodes terug met partiële shallow-groottes en helemaal geen retained-groottes of bereikbaarheid

uses
  SysUtils, HPDFDoc;

procedure ProfileLoadedPdf(const FileName: string);
var
  Pdf: THotPDF;
  Nodes: THPDFObjectDependencyNodeArray;
  Edges: THPDFObjectDependencyEdgeArray;
  Info: THPDFObjectDependencyGraphInfo;
begin
  Pdf := THotPDF.Create(nil);
  try
    // LoadFromFile geeft het aantal pagina's terug; 0 betekent dat het laden mislukte
    if Pdf.LoadFromFile(FileName) = 0 then
      Exit;

    // Verhoogde limieten voor een offline forensische run
    if not Pdf.BuildLoadedObjectDependencyGraph(Nodes, Edges, Info,
      1000000, 8000000) then
    begin
      // Log is uw eigen logroutine
      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; // rangschik of sommeer nooit een partiële array
    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;

Twee andere vlaggen verdienen in die failure-tak een blik. InvalidObjectGraph wordt gezet als het Catalog-object niet tussen de geladen objecten te vinden is, of als een direct object zichzelf blijkt te bevatten, wat alleen bij misvormde invoer voorkomt. LimitExceeded dekt ook een dominatoranalyse die na 128 passes nog niet gestabiliseerd is. Diagnostic legt elk geval in één regel uit. Geeft u voor MaxObjects nul of een negatieve waarde door, of een negatieve MaxEdges, dan volgt een EArgumentOutOfRangeException in plaats van False

Faalt de aanroep op een limiet, dan gooit u de arrays weg en draait u opnieuw met grotere grenzen. Partiële shallow-groottes zien er in een log geloofwaardig uit en zijn precies op de manier fout die mensen het verkeerde object laat najagen. Die grenzen bestaan omdat de graaf zelf ook kost: elke edge bewaart een Path-string, dus een run met acht miljoen edges alloceert acht miljoen kleine strings bovenop het document dat hij meet. Zo'n analyse hoort op een diagnostisch pad dat iemand bewust triggert

Wat telt EstimatedShallowBytes eigenlijk?

EstimatedShallowBytes schat resident geheugen, niet de bytes in het bestand. Per object telt het de instancegrootte van het geparsede object en zijn directe kinderen mee, de slots die de dictionary- en arraylijsten vasthouden, de lengte van elke sleutel, naam en string, en de payload van een stream als die payload in het RAM staat: een memorystream, of een lazy geladen stream die al in het geheugen gelezen is. Een stream waarvan de bytes nog in het bronbestand zitten of die naar een tijdelijk bestand is wegeschreven, levert alleen zijn objectoverhead in

Daar hangt een praktisch gevolg aan. Een scan-zwaar bestand dat direct na het laden geprofileerd wordt, kan bescheiden retained-groottes voor zijn afbeeldingen tonen, omdat nog niets gedecodeerd is. Draait u de graaf na de stap die het proces deed aangroeien (renderen, tekstextractie, een merge), dan verschijnen de gematerialiseerde streams met hun echte gewicht. Voor een reproduceerbare controle profileert u hetzelfde bestand twee keer, een keer direct na LoadFromFile en een keer na de dure operatie, en vergelijkt u de bovenste entries

ObjectType is grof. Het meldt het PDF-waardetype, otStream of otDictionary enzovoort, dus een afbeelding, een fontprogramma en een content stream van een pagina lezen allemaal als otStream. De binnenkomende edge verraadt de rol. THPDFObjectDependencyEdge.Path registreert waar in het bronobject de verwijzing gevonden werd, beginnend bij $, met /Key voor dictionary-entries, [n] voor array-items en /dictionary voor de dictionary van een stream. Een pad als $/Resources/XObject/Im3 vanaf een pagina, of $/XObject/Im3 vanaf een aparte resourcedictionary, betekent dat het object als XObject met de naam Im3 gebruikt wordt; $/FontFile2 vanaf een fontdescriptor betekent een ingesloten TrueType-programma; $/Contents[0] betekent pagina-inhoud

// Uw eigen helper, geen deel van de bibliotheek: rangschikt de top Count nodes op
// retained-grootte en drukt per node het pad van één binnenkomende verwijzing af
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;

Eén binnenkomend pad volstaat om de meeste objecten te classificeren. Voor een gedeeld object vertelt IncomingReferenceCount u hoeveel verwijzingen er zijn, en ImmediateDominatorObjectNumber met zijn generatienummer vertelt u welk object hem na de dominatoranalyse in bezit heeft. Dat veld is -1 voor de Catalog en voor elk object dat de Catalog niet kan bereiken. Een edge waarvan de vlag Resolved op False staat, wijst op een objectnummer dat niet geladen is; die worden meegeteld in UnresolvedReferenceCount, en een hoog aantal bij een verder gezond bestand betekent meestal een beschadigde cross-referencesectie

Waar komen onbereikbare objecten vandaan?

Een node waarvoor ReachableFromCatalog op False staat, is geladen en kost geheugen, maar geen enkele referentieketen vanaf de Catalog leidt ernaartoe, dus niets in de documentstructuur brengt een viewer erbij. Zijn retained-grootte is gelijk aan zijn shallow-grootte, want de dominatoranalyse loopt alleen over bereikbare objecten. EstimatedRetainedBytes sommeren over onbereikbare nodes geeft daarom hetzelfde antwoord als TotalEstimatedBytes - CatalogRetainedBytes

Incrementele updates zijn een veelvoorkomende bron, al niet op de manier waarop mensen doorgaans aannemen. Wanneer een latere revisie object 2120 herdefinieert, wint de nieuwste cross-reference-entry en wordt de oudere definitie nooit geladen, dus vervangen kopieën van hetzelfde objectnummer duiken niet in de graaf op. Wat wel opduikt is een object waarnaar een latere revisie simpelweg stopte met verwijzen: een annotatie die uit een herschreven /Annots-array viel, een afbeelding die door een nieuw objectnummer vervangen werd, een formulierveld dat uit de AcroForm verdween. Niets in ISO 32000-1 §7.5.6 verplicht een update om die entries vrij te markeren, en zolang de cross-referencegegevens ze als in gebruik vermelden, behandelt de loader ze als levende objecten. Het artikel over objectstromen en incrementele updates beschrijft hoe revisies stapelen

HotPDF: Incrementele update die een verwijzing naar een nieuw object omleidt en het eerder gerefereerde object geladen maar onbereikbaar vanaf de Catalog achterlaat
Een update die het document naar een nieuw object laat wijzen, laat het eerder gerefereerde object vermeld en geladen maar buiten het bereik van de Catalog achter, en zijn bytes tellen nog steeds mee in TotalEstimatedBytes

De andere twee bronnen zijn producenten die objecten wegschrijven en ze daarna niet koppelen, en beschadigde bestanden waarvan de cross-referencegegevens via een scan herbouwd moesten worden en die zo objectdefinities kunnen oppikken waarnaar niets verwijst. Zit een groot deel van het geschatte totaal in onbereikbare nodes, dan wint een schone herschrijving van het bestand het van nog een revisie toevoegen, en geeft de graaf u het byte-aantal om de tragere opslag te rechtvaardigen

Zit het geheugen bij de parser?

Voordat u het document de schuld geeft, controleert u hoe het laden zelf verliep. Twee aanroepen beschrijven de parser in plaats van de inhoud, en beide resetten aan het begin van elke LoadFromFile of LoadFromStream, dus ze beschrijven altijd de meest recente laadbeurt

GetLastParserArenaStatistics vult een record THPDFParserArenaStatistics voor de blokarena die tijdens het parsen kortlevende tokens en buffers vasthoudt. Blokken zijn 64 KiB (BlockSize), en een allocatie groter dan een blok krijgt een blok op zijn eigen grootte. AllocationCount min ReusedAllocationCount is gelijk aan BlockAllocationCount, het aantal keren dat de arena bij de memory manager voor een nieuw blok aanklopte. Blokken blijven gedurende de levensduur van het THotPDF-exemplaar bestaan en worden vrijgegeven als dat wordt vernietigd. Verwerkt één exemplaar een hele batch, dan weerspiegelt RetainedBytes grofweg de grootste working set die een bestand in die batch nodig had, wat een plateau verklaart dat duurt tot de component wordt vrijgegeven. TemporaryObjectElisionCount telt dictionary-sleutels die rechtstreeks in de arena gelezen werden in plaats van als tijdelijke naamobjecten gebouwd te worden

GetDocumentStringInternStatistics beschrijft de per-document pool die PDF-namen, content-stream-operatoren en korte strings dedupliceert. Strings van 1 tot 64 bytes komen in aanmerking. De pool bevat hooguit 65.536 entries en 4 MiB, en die plafonds komen in het record terug als MaxStringLength, MaxEntryCount en MaxRetainedBytes. Een string die leeg is, langer dan 64 bytes, of nieuw terwijl de pool vol zit, wordt geteld in BypassCount en als gewone string bewaard. Een bestand dat enorme aantallen unieke namen genereert, kost daardoor grofweg wat het ook zonder de pool zou kosten, en niet meer

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]));
    // Uw eigen controle, geen bibliotheekaanroep: vlagt een pool die zijn plafonds raakte
    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: Statistieken van parser-arena en string-internpool met allocatiehergebruik en een begrensde bypass-teller
Het arena-record toont hoeveel parserverkeer gerecyclede blokken hergebruikte, terwijl het intern-record toont dat de pool zijn brood verdiende voor zijn plafonds tot omzeilingen dwingen — hoog hergebruik met een laag bypass-aantal haalt de loader van de bank van verdachten

Typische PDF's herhalen een kleine woordenschat aan namen en operatoren, dus HitCount blijft dicht bij RequestCount en ReusedBytes groeit met het pagina-aantal. Een BypassCount die bij een bescheiden bestand naar RequestCount opklimt, is ongebruikelijk. Log het op een intakepad voor niet-vertrouwde uploads

Een triagevolgorde bij een geheugenklacht

Begin met CatalogRetainedBytes. Zit dat getal dicht bij de groei die u in het proces mat, dan zit het geheugen in het document en zal de top van de retained-lijst het benoemen. Zit het er ver onder, dan huist het geheugen ergens waar de graaf niet meet, zoals uw eigen caches, gerenderde bitmaps of de parser-arena, en is het arena-record het volgende om te lezen

  1. Rangschik nodes op EstimatedRetainedBytes en lees de binnenkomende Path van de top tien. XObject-doelen bovenaan wijzen meestal op scan-zware inhoud waar downsampling rendement oplevert; doelen als /FontFile, /FontFile2 of /FontFile3 wijzen op volledige fontprogramma's die ingesloten zijn waar subsets hadden volstaan; grote /Contents-streams komen meestal uit gegenereerde vectoruitvoer zoals kaarten of CAD-exports
  2. Trek CatalogRetainedBytes van TotalEstimatedBytes af. Een groot restant zijn gestrande objecten, dus de oplossing hoort in de opslagstap thuis
  3. Lees het arena- en intern-record als laatste. Ze verklaren zelden gigabytes, maar wel een proces dat groot blijft nadat elk document gesloten is

Doorloop die stappen in die volgorde. De eerste beslecht de meeste klachten, en voor zeer grote documenten is het structurele antwoord vaak om niet langer de hele objectgraaf tegelijk vast te houden, en daarvoor is de workflow van de direct file API gebouwd

Alledrie de diagnostieken zijn gewone methodeaanroepen die kale records teruggeven, dus ze sluiten aan bij elke logging of telemetrie die een Delphi- of C++Builder-toepassing al heeft. HotPDF wordt geleverd als native VCL-component met volledige broncode; documentatie en een proefdownload staan op de HotPDF Delphi PDF-componentpagina