fontist 3.0.21 → 3.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e1f8b3f4a8dfaf67dc6c776c7364c21a1241218946f1f7557d51c96667a1c44
-  data.tar.gz: 685fbcfad963b38344972e9e8b56bb9a2daf4863ff14a829def85ebb805e2890
+  metadata.gz: 7679ab0078523e90b72a82f1d3f9e082554161503beb83d33b623f252710efa6
+  data.tar.gz: d56a2424a86f676c7905d039b92f95498fe3413c16a3bbfce014cf9c9daffd2d
 SHA512:
-  metadata.gz: affe57c0973ee61cc2b314cd3c8332b3d068fedb59b316b9a352eb387d71a4191f1a44b4e89534cde03091fe0ce3cd806a520f7804299c92140e97c2efb500f4
-  data.tar.gz: 8714f8daa816bc0c32b09cf6c68f35ae190ccf87933a10bf4bc96281bdfcb8eec76191fec5f25e1748c9d592c702bdea87def55f72d20b2b4a58e81946dc119c
+  metadata.gz: 55250a04825526f62b2760d3e37124e5d1ce664b011f027d28d615f412abb3a75a647670ec62cf7fa466da3b620cab5fa854c21aae34a04fd2493da03ef9df62
+  data.tar.gz: 8cc7ad8c6a085ed5d9c0d2adf3deacd15f58147f5034aa25ca833e6ce89f971bf78436165ea54b380e7774c8b19c296b092a6d618932fc4cb877b2e863d9792e

data/lib/fontist/formula.rb

@@ -105,8 +105,10 @@ module Fontist
 
         # Parsing thousands of formula files dominates index rebuilds;
         # worker threads overlap the libyaml C parse, which releases
-        # the GVL
-        formulas = Parallel.map(paths) do |path|
+        # the GVL. The pool is capped like every other fontist pool, so
+        # worker counts never scale with host core counts
+        workers = [Parallel.processor_count, 8].min
+        formulas = Parallel.map(paths, in_threads: workers) do |path|
           Formula.from_file(path)
         end.compact
 

data/lib/fontist/from_file_cache.rb

@@ -1,52 +1,78 @@
 module Fontist
   # Thread-safe, mtime-validated memoization for parsed YAML artifacts
-  # (formula index, formula files), which cost hundreds of milliseconds to
-  # parse and are re-read on every font lookup.
+  # (formula index, formula files), which cost hundreds of milliseconds
+  # to parse and are re-read on every font lookup.
   #
-  # Returned instances are shared between all callers and must be treated
-  # as read-only. Entries re-resolve automatically when the file's mtime
-  # changes (e.g. after `fontist update` rewrites the formulas repo).
+  # Retention is bounded: fontist runs embedded in long-lived host
+  # processes (metanorma compiles) under memory caps, so the cache is
+  # an LRU holding at most max_entries parsed documents instead of
+  # every file the process has ever touched (~350MB for a full
+  # formulas corpus). Returned instances are shared between callers
+  # and must be treated as read-only. Entries re-resolve automatically
+  # when the file's mtime changes (e.g. after `fontist update`
+  # rewrites the formulas repo).
   module FromFileCache
-    def self.memoize(path)
-      mtime = File.mtime(path)
+    DEFAULT_MAX_ENTRIES = 64
 
-      hit = current_value(path, mtime)
-      return hit if hit
+    class << self
+      attr_writer :max_entries
 
-      # Parse without holding the lock so parallel readers (e.g.
-      # Formula.all over worker threads) overlap; concurrent misses on
-      # the same path may duplicate work but write identical values
-      value = yield
+      def max_entries
+        @max_entries ||= DEFAULT_MAX_ENTRIES
+      end
 
-      store(path, mtime, value)
+      def memoize(path)
+        mtime = File.mtime(path)
 
-      value
-    end
+        hit = mutex.synchronize { lookup(path, mtime) }
+        return hit if hit
 
-    def self.clear
-      mutex.synchronize { cache.clear }
-    end
+        # Parse without holding the lock so parallel readers (e.g.
+        # Formula.all over worker threads) overlap; concurrent misses on
+        # the same path may duplicate work but write identical values
+        value = yield
 
-    def self.current_value(path, mtime)
-      hit = mutex.synchronize { cache[path] }
-      hit&.fetch(:mtime, nil) == mtime ? hit[:value] : nil
-    end
+        store(path, mtime, value)
 
-    def self.store(path, mtime, value)
-      mutex.synchronize do
-        existing = cache[path]
-        if existing.nil? || existing[:mtime] != mtime
-          cache[path] = { mtime: mtime, value: value }
-        end
+        value
       end
-    end
 
-    def self.mutex
-      @mutex ||= Mutex.new
-    end
+      def clear
+        mutex.synchronize { cache.clear }
+      end
 
-    def self.cache
-      @cache ||= {}
+      private
+
+      attr_reader :mutex
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def cache
+        @cache ||= {}
+      end
+
+      def lookup(path, mtime)
+        entry = cache[path]
+        return nil unless entry&.fetch(:mtime, nil) == mtime
+
+        cache.delete(path)
+        cache[path] = entry
+
+        entry[:value]
+      end
+
+      def store(path, mtime, value)
+        mutex.synchronize do
+          existing = cache[path]
+          return if existing&.fetch(:mtime, nil) == mtime
+
+          cache.delete(path)
+          cache.delete(cache.each_key.first) if cache.size >= max_entries
+          cache[path] = { mtime: mtime, value: value }
+        end
+      end
     end
   end
 end

data/lib/fontist/system_index.rb

@@ -100,39 +100,6 @@ module Fontist
     end
   end
 
-  # Thread-safe progress display for parallel index scans
-  class ScanProgress
-    SPINNER_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].freeze
-
-    def initialize(total, verbose:, &on_step)
-      @total = total
-      @verbose = verbose
-      @on_step = on_step
-      @mutex = Mutex.new
-      @processed = 0
-      # Show minimal progress for large collections even in non-verbose mode
-      @minimal = !verbose && total > 100
-      @interval = total > 1000 ? 100 : 50
-    end
-
-    def step(path)
-      @mutex.synchronize do
-        @processed += 1
-        if @verbose
-          @on_step&.call(@processed, path)
-        elsif @minimal && report?
-          Fontist.ui.say("Scanning fonts: #{@processed}/#{@total}...")
-        end
-      end
-    end
-
-    private
-
-    def report?
-      (@processed % @interval).zero? || @processed == @total
-    end
-  end
-
   # {:path=>"/Library/Fonts/Arial Unicode.ttf",
   # :full_name=>"Arial Unicode MS",
   # :family_name=>"Arial Unicode MS",
@@ -514,7 +481,7 @@ module Fontist
       to_file(@path)
     end
 
-    def detect_paths(paths, verbose: false, stats: nil, parallel: true)
+    def detect_paths(paths, verbose: false, stats: nil)
       existing_fonts_by_path = fonts&.group_by(&:path) || {}
 
       # Initialize stats if not provided
@@ -523,100 +490,18 @@ module Fontist
 
       sorted_paths = paths.sort.uniq
 
-      # Disable parallel processing on Windows due to fontisan's internal tempfile GC issues
-      # Windows file locking prevents deletion of recently-accessed files, causing
-      # EACCES errors when fontisan's checksum calculator creates tempfiles that get GC'd
-      # See: https://github.com/fontist/fontist/issues/xxx
-      is_windows = Fontist::Utils::System.user_os == :windows
-
-      # Decide whether to use parallel processing
-      use_parallel = parallel && sorted_paths.size > 100 && !is_windows
-
-      if use_parallel
-        process_paths_parallel(sorted_paths, existing_fonts_by_path,
+      # The scan runs sequentially. Fontisan parsing is GVL-bound Ruby,
+      # so measured on 600 cache-miss fonts a single thread (2.3s) is
+      # faster than eight threads (3.3s), and fontisan memoizes parses
+      # per process, which bounds rescan costs anyway. Concurrency here
+      # previously meant forks, whose inherited heaps transiently
+      # multiplied host RSS up to 9x inside memory-capped metanorma
+      # compiles (fontist#510), and Marshal crashes on cached entries
+      # (fontist#508); Windows additionally suffered fontisan tempfile
+      # races under concurrent scans. Sequential serves every case
+      # Sequential serves every case
+      process_paths_sequential(sorted_paths, existing_fonts_by_path,
                                verbose: verbose, stats: stats)
-      else
-        process_paths_sequential(sorted_paths, existing_fonts_by_path,
-                                 verbose: verbose, stats: stats)
-      end
-    end
-
-    def process_paths_parallel(sorted_paths, existing_fonts_by_path, verbose:,
-stats:)
-      require "parallel"
-
-      # Auto-detect cores, cap at 8 for optimal I/O performance
-      num_cores = [Parallel.processor_count, 8].min
-
-      if verbose
-        puts Paint["Using parallel processing with #{num_cores} cores",
-                   :cyan]
-
-        # Verbose runs keep threads so live progress and per-font stats
-        # stay visible; fontisan parsing is GVL-bound, so this mode is
-        # slow, but it is the human-attended path
-        process_paths_in_threads(sorted_paths, existing_fonts_by_path,
-                                 verbose: verbose, stats: stats,
-                                 num_workers: num_cores)
-      else
-        # Threads, not forked processes: a silent scan runs from inside
-        # long-lived host processes (e.g. metanorma, whose heap reaches
-        # hundreds of MB by the time fonts are looked up). Each fork
-        # inherits that heap, and its RSS is charged to the process group
-        # while it lives, so an 8-process scan transiently multiplies the
-        # host's footprint by up to 9x — measured 3.6GB against a 0.9GB
-        # parent during a metanorma compile (OOMs under cgroup caps).
-        # The ~1s-per-600-fonts scan penalty is bounded and paid only on
-        # cache-miss rebuilds. split_paths_by_reuse keeps cached entries
-        # in the parent: see its comment for the marshal constraint.
-        to_scan, cached_results = split_paths_by_reuse(
-          sorted_paths,
-          existing_fonts_by_path)
-
-        results = Parallel.map(to_scan, in_threads: num_cores) do |path|
-          detect_fonts(path, stats: nil)
-        end.flatten.compact
-
-        stats&.total_fonts = cached_results.size + results.size
-        cached_results + results
-      end
-    end
-
-    # The stat-only reuse check runs in the parent: cached entries can
-    # carry backrefs to their SystemIndexFontCollection (whose
-    # paths_loader is a Proc), and worker results are Marshal.dump'ed
-    # back across the fork boundary — crossing it with cached
-    # collections raises "no _dump_data is defined for class Proc".
-    # Workers therefore receive only to-scan paths, and the block
-    # handed to Parallel closes over nothing but its argument.
-    def split_paths_by_reuse(sorted_paths, existing_fonts_by_path)
-      unchanged, to_scan = sorted_paths.partition do |path|
-        cached = existing_fonts_by_path[path]
-        cached&.any? && file_unchanged?(path, cached.first)
-      end
-      cached_results = unchanged.flat_map do |path|
-        existing_fonts_by_path[path].to_a
-      end
-
-      [to_scan, cached_results]
-    end
-
-    def process_paths_in_threads(sorted_paths, existing_fonts_by_path,
-verbose:, stats:, num_workers:)
-      progress = ScanProgress.new(sorted_paths.size, verbose: verbose) do |count, path|
-        display_progress(count, sorted_paths.size, path,
-                         ScanProgress::SPINNER_CHARS)
-      end
-
-      results = Parallel.map(sorted_paths, in_threads: num_workers) do |path|
-        result = detect_font_with_cache(path, existing_fonts_by_path[path],
-                                        stats: stats)
-        progress.step(path)
-        result
-      end.flatten.compact
-
-      clear_progress_line if verbose
-      results
     end
 
     def process_paths_sequential(sorted_paths, existing_fonts_by_path,

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "3.0.21".freeze
+  VERSION = "3.0.22".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontist
 version: !ruby/object:Gem::Version
-  version: 3.0.21
+  version: 3.0.22
 platform: ruby
 authors:
 - Ribose Inc.