Un cache de pages indexé par nom de fichier montrera les pages d’hier pour un PDF écrasé pendant la nuit par une nouvelle révision sous le même nom. Un cache indexé par un SHA-256 complet du fichier ne fait jamais cette erreur, mais sur une archive scannée de 400 Mo le haché peut prendre plus de temps que de rendre les deux pages que l’utilisateur ouvre réellement. La clé exploitable se loge entre les deux, et la choisir force une seconde décision : ce qu’une édition en mémoire doit faire aux pages déjà posées sur disque
Comment le niveau disque RenderCacheFolder se place derrière le cache mémoire
HotPDF RenderCacheFolder ajoute un niveau persistant derrière le cache de rasters en mémoire du composant HotPDF Delphi, et il n’entre en jeu que si la propriété détient un chemin non vide. Un appel à RenderLoadedPageToBitmapCached(PageIndex, DPI) consulte d’abord la mémoire, avec index de page, DPI et réglages de rendu courants comme clé. Sur un raté, il demande au disque. Un succès disque décode le PNG stocké, le remonte en mémoire et vous remet une copie. Seulement quand les deux niveaux ratent, la page passe par le moteur de rendu complet décrit dans le rendu d’une page PDF chargée vers un TBitmap, et ce bitmap frais est écrit sur disque en sortant
La disposition du dossier est assez simple pour être inspectée dans l’Explorateur. Chaque document reçoit un sous-dossier dont le nom combine une clé de document de 16 caractères hexadécimaux et une clé de réglages de rendu de 16 caractères hexadécimaux, et chaque page s’y pose comme <page>@<dpi>.png. Un index.txt à la racine liste les documents par ordre d’utilisation le plus récent sous un tag de schéma ; si le tag ne correspond pas, tout le dossier est effacé au premier usage. Les écritures PNG et index vont d’abord dans un fichier temporaire puis sont échangées avec MoveFileExW et le drapeau de remplacement, si bien qu’un crash à mi-écriture laisse le fichier précédent ou aucun fichier. Un PNG qui échoue au décodage est supprimé et compté comme un raté
Trois limites empêchent le dossier de croître sans fin :
RenderCacheMaxDocuments(défaut 20) plafonne le nombre de sous-dossiers de documents, en évinçant d’abord le moins récemment utiliséRenderCacheMaxBytes(défaut 524288000, soit 500 Mo) plafonne la taille combinée de chaque PNG sous la racine- Chaque dossier de document garde au plus 200 images de pages ; ce plafond est fixé à l’intérieur de THotPDF et n’a pas de propriété
RenderCacheCapacity (défaut 8) n’a rien à voir avec le disque. Il compte les pages détenues en mémoire
uses
SysUtils, Graphics, HPDFDoc;
procedure WarmThumbnails(const FileName: string);
var
Pdf: THotPDF;
Bmp: TBitmap;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
// Le niveau disque lit le dossier et les deux limites une fois, au premier
// rendu avec cache, alors réglez-les avant cet appel
Pdf.RenderCacheFolder := IncludeTrailingPathDelimiter(
GetEnvironmentVariable('LOCALAPPDATA')) + 'MyViewer\PageCache';
Pdf.RenderCacheMaxDocuments := 50;
Pdf.RenderCacheMaxBytes := Int64(1024) * 1024 * 1024; // 1 GiB
Pdf.RenderCacheCapacity := 16; // pages en mémoire
if Pdf.LoadFromFile(FileName) > 0 then
for I := 0 to Pdf.LoadedPageCount - 1 do
begin
Bmp := Pdf.RenderLoadedPageToBitmapCached(I, 96);
if Bmp <> nil then
try
// Remettez ici la copie à la bande de vignettes
finally
Bmp.Free; // l’appel avec cache renvoie toujours une copie dont l’appelant est propriétaire
end;
end;
finally
Pdf.Free; // les entrées disque survivent pour la session suivante
end;
end;
Exécutez cette procédure deux fois sur le même fichier et la seconde passe ne rastérise rien de ce qui tenait dans les limites. Le cache disque est créé au premier rendu avec cache et vit aussi longtemps que l’instance THotPDF, si bien que changer le dossier ou l’une des limites après ce moment ne le déplace ni ne le redimensionne. Deux conditions de plus tiennent une page hors du disque. Un bitmap au-dessus du plafond par entrée par défaut du cache mémoire (64 Mio de pixels 32 bits, une page 4096 × 4096) n’est pas stocké. Et le niveau disque n’est consulté que tant que RenderFallbackPolicy reste à son défaut rfpIgnore, puisqu’un PNG porte des pixels mais aucun des diagnostics de repli qu’une politique plus stricte rapporte
Pourquoi les clés de cache évidentes échouent-elles ?
Trois clés viennent à l’esprit d’abord, et chacune échoue différemment. Le chemin de fichier échoue sur l’écrasement. Un haché d’une copie en mémoire des octets du PDF paraît sûr jusqu’à ce que vous remarquiez qu’un analyseur lisant le fichier sur place n’a aucune raison de garder une telle copie ; hacher un tampon jamais rempli donne une clé vide, et un cache qui traite une clé vide comme « sauter le disque » laisse un dossier correctement configuré qui ne reçoit jamais de PNG. Hacher le fichier entier depuis le disque fonctionne, au prix de lire chaque octet à chaque ouverture
Le piège le plus dur est l’invalidation. Un composant pareil doit vider ses pages en mémoire au début de chaque chargement, après chaque édition et à sa destruction, et le geste tentant est de supprimer le dossier disque du document au même endroit. Faites cela et chaque session de visualiseur essuie son propre cache en sortant, si bien que le lendemain matin repart à froid. Recalculer la clé depuis la source inchangée après une édition est pire encore : les rendus édités atterrissent sous la clé du fichier d’origine et sont servis à quiconque ouvre ensuite le PDF intact. Identité et invalidation doivent être dessinées d’un seul tenant. Se tromper sur l’une et vous livrez un cache qui ne touche jamais, ou un cache qui montre des pages que le fichier ne contient pas
Comment HotPDF prend-il les empreintes d’une source PDF ?
HotPDF identifie un PDF chargé avec LoadFromFile en hachant avec SHA-256 sa taille, son instant de dernière écriture et ses premier et dernier 64 Kio, et identifie un flux ou une source à accès aléatoire par un SHA-256 du contenu entier. L’identité est capturée une fois, quand un chargement réussit, et les 16 premiers caractères hexadécimaux du condensé (64 bits) deviennent la clé de document
| Source | Identité | Coût | Capturé quand |
|---|---|---|---|
LoadFromFile | Taille + instant de dernière écriture + 64 Kio de tête et de queue, hachés en SHA-256 | Au plus 128 Kio lus, quelle que soit la taille du fichier | À chaque chargement réussi, même si RenderCacheFolder est réglé ensuite |
LoadFromStream | SHA-256 de tout le flux | Une passe complète sur la source | Seulement si RenderCacheFolder était défini avant le chargement |
LoadFromRandomAccessSource | SHA-256 de la source entière | Une passe complète sur la source | Seulement si le dossier était réglé d’abord et que chaque plage d’octets est disponible |
Toute source avec une entrée /Encrypt | Aucune | Aucun | Jamais ; le niveau disque est contourné |
Pour un visualiseur de bureau, l’empreinte échantillonnée est le bon défaut, et le haché complet à chaque ouverture est le mauvais. Les deux régions échantillonnées ont été prises dans la structure du fichier. L’en-tête se trouve au début ; le trailer et la dernière section de références croisées se trouvent à la fin (§7.5 de l’ISO 32000-1). Une mise à jour incrémentale ajoute un nouveau corps, une nouvelle section de références croisées et un nouveau trailer (§7.5.6), ce qui change la taille et la queue ensemble, et toute réécriture complète ordinaire avance l’instant de dernière écriture. Sous 128 Kio les deux échantillons se chevauchent et couvrent chaque octet, si bien que les petits documents sont de toute façon hachés en entier
Ce qui passe à travers, c’est une édition de même taille au milieu d’un gros fichier par un outil qui restaure ensuite l’horodatage d’origine. Des éditeurs qui préservent délibérément les instants de modification tout en changeant le contenu existent, mais ils sont rares, et contre un tel fichier le cache sert des pages périmées. Le cas inverse joue pour vous : une copie de fichier Windows garde l’instant de dernière écriture, si bien qu’une copie d’un document en cache touche les mêmes entrées, ce qui est juste puisque les octets correspondent
Un flux n’a pas d’horodatage. Le contenu est la seule identité honnête, si bien que HotPDF paie la passe SHA-256 complète seulement quand un cache disque était demandé avant le chargement, et du code qui appelle LoadFromStream sans dossier de cache ne paie rien de plus. Cela rend l’ordre de deux lignes important :
procedure OpenDownloadedPdf(Pdf: THotPDF; Data: TStream;
const CacheRoot: string);
begin
// Mauvais ordre pour les flux : le hash du contenu n’est calculé que
// quand le dossier est déjà défini, donc ce document contournerait le niveau disque
// Pdf.LoadFromStream(Data);
// Pdf.RenderCacheFolder := CacheRoot;
Pdf.RenderCacheFolder := CacheRoot; // défini d’abord
Data.Position := 0;
if Pdf.LoadFromStream(Data) <= 0 then
raise Exception.Create('The stream is not a loadable PDF');
end;
Une source à accès aléatoire encore en téléchargement ne reçoit aucune identité du tout, au lieu d’un haché des plages arrivées. Si le calcul de l’identité lève pour une raison quelconque, le chargement réussit quand même et le document se rend à travers la mémoire seule
Que deviennent les pages en cache après une édition ?
Éditer un document chargé ne supprime jamais rien du cache de rendu disque HotPDF. L’édition abandonne plutôt l’identité du document, si bien que le reste de ce chargement contourne le niveau disque, et les pages stockées restent valides pour le fichier non modifié depuis lequel elles ont été rendues. Les entrées quittent le disque seulement par les limites de documents et d’octets, le plafond de 200 pages, un PNG qui échoue au décodage, ou un changement de schéma
La clé décrit un fichier sur disque. Une fois que vous estampez une page ou changez une annotation, le document en mémoire ne lui correspond plus, si bien que ni lire ni écrire sous cette clé ne serait honnête. InvalidateRenderedPageCache et l’invalidation par page que les éditions déclenchent effacent tous deux l’identité et laissent le dossier tranquille. Un second contrôle couvre les chemins d’édition qui n’ont jamais rien invalidé : avant chaque consultation du disque, THotPDF demande si un objet chargé porte des changements non enregistrés et, si c’est le cas, traite le document comme sans identité
Les réglages de rendu marchent dans l’autre sens. Affecter PageRenderBackend (ce que UseNativeGDIRenderBackend fait pour vous), appeler ConfigureRenderICCWorkflow ou appeler ClearRenderICCWorkflow jette les pages en mémoire mais garde l’identité, parce que le document correspond toujours à son fichier. Ces réglages changent des pixels sans apparaître dans la clé mémoire, si bien que la clé disque replie le nom du backend, le drapeau de compensation du point noir et les condensés SHA-256 des profils d’épreuve et de sortie ICC. La clé mémoire couvre déjà l’intention de couleur, le dithering de sortie, l’aperçu de la surimpression, le mode de masque de luminosité, la politique de repli et la visibilité de chaque groupe de contenu optionnel
La visibilité des calques est un bon exemple de changement qui reste sur disque. SetLoadedOptionalContentGroupVisible enregistre la dérogation en mémoire sans toucher aucun objet PDF, si bien que le document garde son identité et que la vue basculée se rend dans son propre sous-dossier à côté du défaut :
procedure ShowLayer(Pdf: THotPDF; const LayerName: AnsiString;
PageIndex: Integer; out Bmp: TBitmap);
var
I: Integer;
begin
for I := 0 to Pdf.GetLoadedOptionalContentGroupCount - 1 do
if Pdf.GetLoadedOptionalContentGroupName(I) = LayerName then
Pdf.SetLoadedOptionalContentGroupVisible(I, True);
// Même clé de document, autre clé de réglages de rendu : cette page est lue
// depuis ou écrite vers un second dossier, et la vue par défaut reste intacte
Bmp := Pdf.RenderLoadedPageToBitmapCached(PageIndex, 150);
end;
Un document édité ne revient sur le niveau disque qu’en devenant un nouveau fichier. Enregistrez-le et chargez le résultat :
procedure CommitEditsAndRekey(Pdf: THotPDF; const EditedFile: string);
begin
// Après édition : rafraîchissez les pages en mémoire. L’identité de la source
// est déjà partie, si bien que le dossier du document d’origine n’est ni lu
// ni écrit
Pdf.InvalidateRenderedPageCache;
// Le fichier enregistré a sa propre taille et son propre instant de dernière écriture, donc sa
// propre identité ; les rendus après ce chargement sont mis en cache sous la nouvelle clé
Pdf.SaveLoadedDocument(EditedFile);
if Pdf.LoadFromFile(EditedFile) <= 0 then
raise Exception.Create('Could not reload the edited document');
end;
Le dossier du document d’origine reste où il était et vieillit à travers RenderCacheMaxDocuments et RenderCacheMaxBytes comme toute autre entrée. Rouvrez l’original intact et ses pages sont toujours là
Sources chiffrées, jonctions et racines partagées
Le cache de rendu disque HotPDF refuse deux entrées à dessein : les pages d’un PDF chiffré, et les sous-dossiers de documents qui sont des jonctions ou d’autres points de réanalyse. Les deux règles échangent des succès de cache contre de la sécurité
Les PDF chiffrés restent en mémoire
Une page rendue est du contenu déchiffré. L’écrire comme PNG simple dans un dossier de cache laisserait une copie lisible d’un document protégé par mot de passe sur le disque, hors de la protection choisie par son auteur (§7.6 de l’ISO 32000-1). HotPDF ne capture aucune identité pour toute source dont le trailer porte une entrée /Encrypt, qu’elle ait été ouverte avec un mot de passe ou avec un mot de passe utilisateur vide. Ces documents emploient toujours le niveau mémoire, qui disparaît avec le processus
Les dossiers de documents liés sont sautés
La racine du cache est à votre choix, et la pointer vers une jonction va très bien. Les sous-dossiers en dessous sont différents : le cache les crée, les touche et les supprime par lui-même pendant le nettoyage de démarrage, la consultation, le stockage et les trois limites d’éviction. Si quelqu’un ayant le droit d’écriture à la racine échangeait un dossier de document contre une jonction vers un autre répertoire, chacune de ces opérations le suivrait, et l’éviction supprimerait des fichiers ailleurs. Chaque point d’entrée lit d’abord les attributs du dossier et saute tout ce qui est marqué comme point de réanalyse. Une consultation compte un raté, un stockage compte un échec d’écriture, et l’éviction le laisse tranquille
Chemins Unicode et une racine par processus
RenderCacheFolder est une string Unicode, et le remplacement atomique appelle l’API Windows large, si bien qu’un chemin de profil hors de la page de codes du système (un nom d’utilisateur chinois sur une installation Windows anglaise, par exemple) atteint le cache intact. Plusieurs instances THotPDF dans un processus qui se résolvent vers la même racine, comparée sans tenir compte de la casse après expansion des chemins, partagent un index à comptage de références et un verrou. Cela compte pour les limites : des copies séparées de index.txt feraient respecter chacune le budget de 500 Mo contre une vue partielle et laisseraient le dossier croître plusieurs fois au-delà
Le partage s’arrête à la frontière du processus. Deux processus sur la même racine gardent des index mémoire séparés, si bien que chaque application lancée en parallèle devrait recevoir sa propre racine. Les threads workers à l’intérieur d’un processus vont très bien : PrefetchLoadedPages et la file de rendu en arrière-plan avec file de requêtes passent par le même chemin avec cache et le même verrou
Réglages à bien poser avant de livrer
- Réglez le dossier et les deux limites avant le premier rendu avec cache, et pour les chargements par flux ou à accès aléatoire avant le chargement
- Attendez-vous à un rendu mémoire seule pour les PDF chiffrés, pour les documents édités après le chargement, et chaque fois que
RenderFallbackPolicyn’est pasrfpIgnore - Donnez à chaque application lancée sa propre racine de cache sous un emplacement par utilisateur comme
%LOCALAPPDATA%
Un cache de pages persistant gagne son espace disque dans un visualiseur qui rouvre les mêmes documents toute la journée, la charge de travail derrière l’architecture de visualiseur PDF personnalisé en Delphi sur ce blog. Le niveau disque, le cache de rasters mémoire et le moteur de rendu de pages font tous partie du composant HotPDF Delphi PDF, disponible pour Delphi et C++Builder