ntk 8.12.4 → 8.12.5

package/lib/text/fontmanager.js

@@ -63,6 +63,60 @@ function shapingKeyOf(style) {
   return `${feats}|${language ?? ''}|${letterSpacing || 0}`;
 }
 
+/**
+ * How many shaped words a generation of the memo holds. Two are kept, so a
+ * working set up to twice this survives a relayout; what was asked for in
+ * neither generation is dropped when the current one fills.
+ */
+const SHAPE_GENERATION = 4000;
+
+// The part of a shaping key a style decides, per style object. Built once a
+// span rather than once a word: TextLayout asks for every word of a span with
+// the same object, and the 2D context builds one object per `font` it is
+// given. Neither changes an object after handing it over, so the only field
+// checked again is the resolved face, the one a caller sets after building
+// the rest.
+const shapePrefixes = new WeakMap();
+
+/** The key a style's words are memoized under, with the embedding levels
+ *  they were shaped at: one string per style and level, kept, so a lookup
+ *  hashes nothing it has not hashed before. */
+function shapeGroupOf(style, levelsKey) {
+  const font = style.font;
+  let known = shapePrefixes.get(style);
+  if (known === undefined || known.font !== font) {
+    known = { font, prefix: shapePrefixOf(style), levels: new Map() };
+    shapePrefixes.set(style, known);
+  }
+  // a fragment's levels are one number in the common case, a list only
+  // for mixed-direction text; a list is not worth keeping
+  if (levelsKey.length > 2) return `${known.prefix}|${levelsKey}`;
+  let group = known.levels.get(levelsKey);
+  if (group === undefined) {
+    group = `${known.prefix}|${levelsKey}`;
+    known.levels.set(levelsKey, group);
+  }
+  return group;
+}
+
+function shapePrefixOf(style) {
+  const font = style.font;
+  // A resolved `font` already carries its coordinates in its key, so the
+  // variations and optical-size fragments only earn their keep on the
+  // family path — where two points of one axis would otherwise share a
+  // shaped run, and the second would be drawn with the first's advances.
+  // Features, language and spacing change the glyphs a word shapes to, so
+  // they are part of the key on both paths: without them a word shaped once
+  // plain answered every later request for it with the plain glyphs, and a
+  // `tnum` asked for after that point was silently ignored.
+  const shaping = shapingKeyOf(style);
+  return font
+    ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}`
+    : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
+        style.variations
+      )}|${opticalKeyOf(style)}|${shaping}`;
+}
+
 /** Cache-key fragment for the optical size, `''` when the axis is left alone. */
 function opticalKeyOf(style) {
   return opticalSizeFor(style) ?? '';
@@ -136,7 +190,11 @@ export default class FontManager {
     this._matches = new Map(); // family|weight|style -> Font
     this._fallbacks = new Map(); // family|weight|style -> Map(codepoint -> Font|null)
     this._registered = []; // { font, family (lowercase), weight, italic }
-    this._shapeCache = new Map(); // word-level shaping memo (bounded, LRU)
+    // word-level shaping memo, in two generations (`_shapeCached`): each a
+    // map from a style's key to the words shaped in it
+    this._shapeCache = new Map();
+    this._shapeCacheBefore = new Map();
+    this._shapeCount = 0;
   }
 
   /** the FontSource in effect (explicit, else the process-wide default) */
@@ -355,53 +413,45 @@ export default class FontManager {
   }
 
   /**
-   * Memoized shaping used by TextLayout and the canvas text path (bounded
-   * LRU). `levelsKey` is a compact embedding-levels encoding: a single
-   * number when uniform for the whole fragment (the common case), else
-   * comma-separated per-char levels.
+   * Memoized shaping used by TextLayout and the canvas text path, bounded at
+   * two generations of `SHAPE_GENERATION` words. `levelsKey` is a compact
+   * embedding-levels encoding: a single number when uniform for the whole
+   * fragment (the common case), else comma-separated per-char levels.
    */
   _shapeCached(text, style, levelsKey = '0') {
-    const font = style.font;
-    // A resolved `font` already carries its coordinates in its key, so the
-    // variations and optical-size fragments only earn their keep on the
-    // family path — where two points of one axis would otherwise share a
-    // shaped run, and the second would be drawn with the first's advances.
-    // Features, language and spacing change the glyphs a word shapes to, so
-    // they are part of the key on both paths: without them a word shaped once
-    // plain answered every later request for it with the plain glyphs, and a
-    // `tnum` asked for after that point was silently ignored.
-    const shaping = shapingKeyOf(style);
-    const key = font
-      ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}|${levelsKey}|${text}`
-      : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
-          style.variations
-        )}|${opticalKeyOf(style)}|${shaping}|${levelsKey}|${text}`;
-    let shaped = this._shapeCache.get(key);
-    if (shaped) {
-      // Map iterates in insertion order: re-inserting a hit moves it to the
-      // tail, so the eviction sweep below walks least-recently-used first
-      this._shapeCache.delete(key);
-      this._shapeCache.set(key, shaped);
-      return shaped;
+    // A hit in this generation is the whole cost of a word a paragraph has
+    // shaped before — a relayout at a new width asks for every word again,
+    // a hundred thousand of them in a long document — so it is two lookups
+    // and nothing built: the style's key is the same string every time
+    // (`shapeGroupOf`), and the word is the only thing hashed. What the
+    // generation before holds is carried over when asked for; what neither
+    // was asked for goes when the generation turns.
+    const group = shapeGroupOf(style, levelsKey);
+    let words = this._shapeCache.get(group);
+    let shaped = words?.get(text);
+    if (shaped) return shaped;
+    shaped = this._shapeCacheBefore.get(group)?.get(text);
+    if (!shaped) {
+      let levels;
+      if (levelsKey.includes(',')) {
+        levels = levelsKey.split(',').map(Number);
+      } else {
+        levels = new Uint8Array(text.length).fill(Number(levelsKey));
+      }
+      shaped = shapeText(this, text, style, levels);
     }
-    let levels;
-    if (levelsKey.includes(',')) {
-      levels = levelsKey.split(',').map(Number);
-    } else {
-      levels = new Uint8Array(text.length).fill(Number(levelsKey));
+    if (this._shapeCount >= SHAPE_GENERATION) {
+      this._shapeCacheBefore = this._shapeCache;
+      this._shapeCache = new Map();
+      this._shapeCount = 0;
+      words = undefined;
     }
-    shaped = shapeText(this, text, style, levels);
-    if (this._shapeCache.size > 4000) {
-      // drop the stale half in one sweep rather than one entry per insert —
-      // a live UI's working set sits at the recent end and survives, where
-      // the old wholesale clear() re-shaped everything on screen
-      let drop = this._shapeCache.size >> 1;
-      for (const k of this._shapeCache.keys()) {
-        if (drop-- <= 0) break;
-        this._shapeCache.delete(k);
-      }
+    if (!words) {
+      words = new Map();
+      this._shapeCache.set(group, words);
     }
-    this._shapeCache.set(key, shaped);
+    words.set(text, shaped);
+    this._shapeCount++;
     return shaped;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.12.4",
+  "version": "8.12.5",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",