fast_cov 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 450398ffd460598ce2a3e8738705d3b36cf40763961139d88f6a003d86002c27
-  data.tar.gz: c80e01acd939edabf2eb811b8198af749f378be8ca6e3c6819238b5b7bd3aae5
+  metadata.gz: f05621dfa93b2807fd7060732bd323ddd407e9af1d80b0857d5d50d6c8667a24
+  data.tar.gz: f0cc0a9afd99fddac4e0cc263c0dc5edefb373e5da1b145f12148c2a3640aa39
 SHA512:
-  metadata.gz: c5b95fce00edd7076b5be23fce0847f597ec6feda69fb0d66ebfb5af5d2de41aa47a040cf2b11d3ce7bf13fb91dd64f6da48a13beaaf29307e180c76a81ee0e9
-  data.tar.gz: 455f38ef134a86d3e2c37524d52958d23a47e1e6b257a15fef2174b846b761b667ee457c794967fede777fb7bdef9fbe960a554109db5dde93aa2f9b8ea8c807
+  metadata.gz: 8736b3e941eb96518a55ff674429610cb429e790a4fcf67a808d5b5830d3f5110ce443ab18a8e15b657a74a4f3f69734121c8bb924b14b93f0b12eddc00745b2
+  data.tar.gz: cc856dc60b6d55b534982b1cb83e6bbf8f5b699ff7f1bbd39b9f96749a119261880ec010243a72cbddb00c535a6e47bd0582546a5288ea6370bfa89a43eea582

data/ext/fast_cov/extconf.rb

@@ -8,5 +8,6 @@ end
 
 require "mkmf"
 
-# Version-tagged so multiple Ruby versions can coexist in development
-create_makefile("fast_cov/fast_cov.#{RUBY_VERSION}")
+# Tagged with the ABI version so multiple Ruby versions can coexist in
+# development. Must stay in sync with the require in lib/fast_cov.rb.
+create_makefile("fast_cov/fast_cov.#{RbConfig::CONFIG["ruby_version"]}")

data/ext/fast_cov/fast_cov.c

@@ -17,6 +17,13 @@
 static VALUE fast_cov_stop(VALUE self);
 static VALUE fast_cov_yield_block(VALUE _arg);
 
+// Seen-set sizing. Power-of-two capacities so lookups mask instead of modulo.
+#define SEEN_INITIAL_CAPACITY 256
+// Grow at 3/4 load. Linear probing degrades sharply past that, and a full
+// table would make the insert probe loop spin forever.
+#define SEEN_LOAD_NUMERATOR 3
+#define SEEN_LOAD_DENOMINATOR 4
+
 // ---- Data structure -----------------------------------------------------
 
 struct fast_cov_data {
@@ -29,8 +36,20 @@ struct fast_cov_data {
   long *ignored_path_lens;
   long ignored_paths_count;
 
+  // Two-level cache over source file identity, both keyed on the pointer
+  // rb_sourcefile() returns (stable per file, so comparing it is one
+  // integer compare instead of a string compare):
+  //
+  //   last_filename_ptr - single slot, hits while execution stays in one file
+  //   seen_*            - open-addressed set of every file seen this session,
+  //                       so alternating between files stays on the fast path
   uintptr_t last_filename_ptr;
 
+  uintptr_t *seen_ptrs;
+  VALUE *seen_paths;
+  long seen_capacity;
+  long seen_count;
+
   bool threads;
   bool started;
   VALUE th_covered;
@@ -44,8 +63,18 @@ struct fast_cov_data {
 
 static void fast_cov_mark(void *ptr) {
   struct fast_cov_data *data = ptr;
+  long i;
+
   rb_gc_mark(data->impacted_files);
   rb_gc_mark(data->th_covered);
+
+  // Pinning the path strings is what makes the pointer cache sound: it keeps
+  // each rb_sourcefile() pointer alive and at a fixed address for the whole
+  // session. Without it a freed string's address could be reused by another
+  // file, which would read as a cache hit and silently drop that file.
+  for (i = 0; i < data->seen_capacity; i++) {
+    if (data->seen_ptrs[i]) rb_gc_mark(data->seen_paths[i]);
+  }
 }
 
 static void fast_cov_free(void *ptr) {
@@ -59,6 +88,8 @@ static void fast_cov_free(void *ptr) {
     xfree(data->ignored_paths);
   }
   if (data->ignored_path_lens) xfree(data->ignored_path_lens);
+  if (data->seen_ptrs) xfree(data->seen_ptrs);
+  if (data->seen_paths) xfree(data->seen_paths);
   xfree(data);
 }
 
@@ -92,15 +123,111 @@ static VALUE fast_cov_allocate(VALUE klass) {
   data->threads = true;
   data->started = false;
 
+  // Keep seen_capacity at 0 until both arrays are installed: xcalloc can
+  // trigger GC, and fast_cov_mark walks seen_capacity entries.
+  data->seen_capacity = 0;
+  data->seen_count = 0;
+  data->seen_ptrs = NULL;
+  data->seen_paths = NULL;
+
+  uintptr_t *seen_ptrs = xcalloc(SEEN_INITIAL_CAPACITY, sizeof(uintptr_t));
+  VALUE *seen_paths = xcalloc(SEEN_INITIAL_CAPACITY, sizeof(VALUE));
+  data->seen_ptrs = seen_ptrs;
+  data->seen_paths = seen_paths;
+  data->seen_capacity = SEEN_INITIAL_CAPACITY;
+
   return obj;
 }
 
+// ---- Seen-set -----------------------------------------------------------
+//
+// Open-addressed set of the rb_sourcefile() pointers seen this session, with
+// the corresponding path string stored alongside so it can be pinned. Linear
+// probing keeps lookups in one cache line for the common case.
+
+// The low bits of a pointer carry little entropy (allocations are aligned),
+// so shift them off before masking.
+static inline long seen_slot(uintptr_t filename_ptr, long capacity) {
+  return (long)((filename_ptr >> 3) & (uintptr_t)(capacity - 1));
+}
+
+static inline bool seen_include(const struct fast_cov_data *data,
+                                uintptr_t filename_ptr) {
+  long slot = seen_slot(filename_ptr, data->seen_capacity);
+
+  while (data->seen_ptrs[slot]) {
+    if (data->seen_ptrs[slot] == filename_ptr) return true;
+    slot = (slot + 1) & (data->seen_capacity - 1);
+  }
+
+  return false;
+}
+
+static void seen_grow(struct fast_cov_data *data) {
+  uintptr_t *old_ptrs = data->seen_ptrs;
+  VALUE *old_paths = data->seen_paths;
+  long old_capacity = data->seen_capacity;
+  long new_capacity = old_capacity * 2;
+  long i;
+
+  // Allocate both arrays before installing either. GC can run inside xcalloc,
+  // and fast_cov_mark must keep seeing a consistent capacity/arrays triple.
+  uintptr_t *new_ptrs = xcalloc(new_capacity, sizeof(uintptr_t));
+  VALUE *new_paths = xcalloc(new_capacity, sizeof(VALUE));
+
+  for (i = 0; i < old_capacity; i++) {
+    uintptr_t filename_ptr = old_ptrs[i];
+    if (!filename_ptr) continue;
+
+    long slot = seen_slot(filename_ptr, new_capacity);
+    while (new_ptrs[slot]) {
+      slot = (slot + 1) & (new_capacity - 1);
+    }
+    new_ptrs[slot] = filename_ptr;
+    new_paths[slot] = old_paths[i];
+  }
+
+  // Install, then free: the struct must never point at freed arrays, since a
+  // GC between the two would mark through them.
+  data->seen_ptrs = new_ptrs;
+  data->seen_paths = new_paths;
+  data->seen_capacity = new_capacity;
+
+  xfree(old_ptrs);
+  xfree(old_paths);
+}
+
+static void seen_add(struct fast_cov_data *data, uintptr_t filename_ptr,
+                     VALUE path) {
+  if (data->seen_count + 1 >
+      data->seen_capacity * SEEN_LOAD_NUMERATOR / SEEN_LOAD_DENOMINATOR) {
+    seen_grow(data);
+  }
+
+  long slot = seen_slot(filename_ptr, data->seen_capacity);
+  while (data->seen_ptrs[slot]) {
+    if (data->seen_ptrs[slot] == filename_ptr) return;
+    slot = (slot + 1) & (data->seen_capacity - 1);
+  }
+
+  data->seen_ptrs[slot] = filename_ptr;
+  data->seen_paths[slot] = path;
+  data->seen_count++;
+}
+
+static void seen_clear(struct fast_cov_data *data) {
+  MEMZERO(data->seen_ptrs, uintptr_t, data->seen_capacity);
+  MEMZERO(data->seen_paths, VALUE, data->seen_capacity);
+  data->seen_count = 0;
+}
+
 // ---- Internal helpers ---------------------------------------------------
 
 static bool record_impacted_file(struct fast_cov_data *data, VALUE filename) {
-  if (!fast_cov_is_path_included(RSTRING_PTR(filename), data->root,
-                                 data->root_len, data->ignored_paths,
-                                 data->ignored_path_lens,
+  // RSTRING_LEN is O(1); passing it avoids re-scanning the path with strlen.
+  if (!fast_cov_is_path_included(RSTRING_PTR(filename), RSTRING_LEN(filename),
+                                 data->root, data->root_len,
+                                 data->ignored_paths, data->ignored_path_lens,
                                  data->ignored_paths_count)) {
     return false;
   }
@@ -127,6 +254,13 @@ static void on_line_event(rb_event_flag_t event, VALUE self_data, VALUE self,
   }
   data->last_filename_ptr = current_filename_ptr;
 
+  // Execution alternates between files constantly (a method in one file
+  // calling into another), so the single slot above misses often. Anything
+  // already seen this session is resolved here without touching the VM.
+  if (seen_include(data, current_filename_ptr)) {
+    return;
+  }
+
   VALUE top_frame;
   if (rb_profile_frames(0, 1, &top_frame, NULL) != 1) {
     return;
@@ -137,6 +271,9 @@ static void on_line_event(rb_event_flag_t event, VALUE self_data, VALUE self,
     return;
   }
 
+  // Only cache pointers we hold a path string for — the pin in fast_cov_mark
+  // is what keeps the pointer valid and unambiguous.
+  seen_add(data, current_filename_ptr, filename);
   record_impacted_file(data, filename);
 }
 
@@ -265,16 +402,22 @@ static VALUE fast_cov_stop(VALUE self) {
     if (thval != data->th_covered) {
       rb_raise(rb_eRuntimeError, "Coverage was not started by this thread");
     }
-    rb_thread_remove_event_hook(data->th_covered, on_line_event);
+    // Match on the registering object, not just the callback. The plain
+    // rb_*_remove_event_hook variants match by function pointer alone, so
+    // stopping one Coverage instance would tear down the hooks belonging to
+    // every other live instance — silently, since those instances stay
+    // `started` and simply stop recording.
+    rb_thread_remove_event_hook_with_data(data->th_covered, on_line_event, self);
     data->th_covered = Qnil;
   } else {
-    rb_remove_event_hook(on_line_event);
+    rb_remove_event_hook_with_data(on_line_event, self);
   }
 
   VALUE res = data->impacted_files;
 
   data->impacted_files = rb_hash_new();
   data->last_filename_ptr = 0;
+  seen_clear(data);
   data->started = false;
 
   return res;

data/ext/fast_cov/fast_cov.h

@@ -9,9 +9,9 @@
 bool fast_cov_is_within_root(const char *path, long path_len,
                              const char *root, long root_len);
 
-bool fast_cov_is_path_included(const char *path, const char *root_path,
-                               long root_path_len, char **ignored_paths,
-                               long *ignored_path_lens,
+bool fast_cov_is_path_included(const char *path, long path_len,
+                               const char *root_path, long root_path_len,
+                               char **ignored_paths, long *ignored_path_lens,
                                long ignored_paths_count);
 
 /* ---- Utility functions -------------------------------------------------- */

data/ext/fast_cov/fast_cov_utils.c

@@ -18,8 +18,9 @@ bool fast_cov_is_within_root(const char *path, long path_len,
     return false;
   }
 
-  // Check prefix match
-  if (strncmp(path, root, effective_root_len) != 0) {
+  // Check prefix match. memcmp rather than strncmp: both lengths are known,
+  // so there is no reason to also scan for a terminator.
+  if (memcmp(path, root, (size_t)effective_root_len) != 0) {
     return false;
   }
 
@@ -33,11 +34,10 @@ bool fast_cov_is_within_root(const char *path, long path_len,
   return path[effective_root_len] == '/';
 }
 
-bool fast_cov_is_path_included(const char *path, const char *root_path,
-                               long root_path_len, char **ignored_paths,
-                               long *ignored_path_lens,
+bool fast_cov_is_path_included(const char *path, long path_len,
+                               const char *root_path, long root_path_len,
+                               char **ignored_paths, long *ignored_path_lens,
                                long ignored_paths_count) {
-  long path_len = (long)strlen(path);
   long i;
 
   if (!fast_cov_is_within_root(path, path_len, root_path, root_path_len)) {

data/lib/fast_cov/benchmark/scenarios.rb

@@ -48,6 +48,20 @@ module FastCov
           cov.stop
         end
 
+        # Every call crosses calculator.rb -> operations/*.rb and back, so this
+        # measures the per-line-event cost of file transitions rather than the
+        # start/stop overhead that dominates the scenarios above.
+        runner.scenario("Line coverage (cross-file transitions)") do
+          cov = FastCov::Coverage.new(root: root_calculator)
+          cov.start
+          200.times do
+            calculator.add(1, 2)
+            calculator.subtract(3, 1)
+            calculator.multiply(2, 3)
+          end
+          cov.stop
+        end
+
         runner.scenario("Rapid start/stop (100x)") do
           cov = FastCov::Coverage.new(root: root_calculator)
           100.times do

data/lib/fast_cov/compiler.rb

@@ -41,8 +41,11 @@ module FastCov
       stored != source_digest
     end
 
+    # Matches the ABI-version tag used by extconf.rb and lib/fast_cov.rb.
+    ABI_VERSION = RbConfig::CONFIG["ruby_version"]
+
     def self.extension_exists?
-      Dir.glob(File.join(FAST_COV_DIR, "fast_cov.#{RUBY_VERSION}.{bundle,so}")).any?
+      Dir.glob(File.join(FAST_COV_DIR, "fast_cov.#{ABI_VERSION}.{bundle,so}")).any?
     end
 
     def self.source_digest
@@ -52,8 +55,8 @@ module FastCov
     end
 
     def self.digest_path
-      # Keep version-specific so we recompile when switching Ruby versions
-      File.join(FAST_COV_DIR, ".source_digest.#{RUBY_VERSION}")
+      # Keep ABI-specific so we recompile when switching Ruby versions
+      File.join(FAST_COV_DIR, ".source_digest.#{ABI_VERSION}")
     end
 
     def self.write_digest

data/lib/fast_cov/coverage_map.rb

@@ -16,6 +16,7 @@ module FastCov
       @connected_dependencies = ConnectedDependencies.new
       @trackers = []
       @native_coverage = nil
+      @native_coverage_config = nil
       @started = false
     end
 
@@ -69,11 +70,7 @@ module FastCov
       return self if @started
 
       begin
-        @native_coverage = Coverage.new(
-          root: normalized_root,
-          ignored_paths: normalized_ignored_paths,
-          threads: @threads != false
-        )
+        @native_coverage = native_coverage
         @native_coverage.start
         @trackers.each(&:start)
         @started = true
@@ -93,7 +90,6 @@ module FastCov
       @connected_dependencies.expand(result)
       Utils.relativize_paths(result, normalized_root)
     ensure
-      @native_coverage = nil
       @started = false
     end
 
@@ -117,6 +113,20 @@ module FastCov
 
     private
 
+    # Reused across cycles: a Coverage instance rebuilds its file cache from
+    # scratch on construction, so a fresh one per cycle discards that work.
+    def native_coverage
+      config = [normalized_root, normalized_ignored_paths, @threads != false]
+      return @native_coverage if @native_coverage && @native_coverage_config == config
+
+      @native_coverage_config = config
+      @native_coverage = Coverage.new(
+        root: config[0],
+        ignored_paths: config[1],
+        threads: config[2]
+      )
+    end
+
     def normalized_root
       path = @root&.to_s
       raise ConfigurationError, "root is required" if path.nil? || path.empty?
@@ -145,10 +155,12 @@ module FastCov
       File.absolute_path?(path)
     end
 
+    # Against root, not Dir.pwd: #stop returns root-relative paths and callers
+    # pass them straight back into #connect.
     def normalize_path(path)
       return if path.nil?
 
-      File.expand_path(path.to_s)
+      File.expand_path(path.to_s, normalized_root)
     end
 
     def cleanup_failed_start

data/lib/fast_cov/test_map.rb

@@ -53,8 +53,11 @@ module FastCov
     def dump(path)
       FileUtils.mkdir_p(File.dirname(path))
 
-      lines = @mapping.map { |file, deps| "#{file}\t#{deps.to_a.join("\t")}\n" }
-      Zlib::GzipWriter.open(path) { |gz| gz.write(lines.join) }
+      Zlib::GzipWriter.open(path) do |gz|
+        @mapping.each do |file, deps|
+          gz.write("#{file}\t#{deps.to_a.join("\t")}\n")
+        end
+      end
     end
 
     # Number of unique source files mapped.

data/lib/fast_cov/trackers/const_get_tracker.rb

@@ -24,7 +24,13 @@ module FastCov
     module ConstGetPatch
       def const_get(name, inherit = true)
         result = super
-        FastCov::ConstGetTracker.record(const_source_location(name, inherit)&.first)
+
+        # The patch is permanent, so the active check has to precede the
+        # lookup — otherwise every const_get in the process pays for it.
+        if FastCov::ConstGetTracker.active
+          FastCov::ConstGetTracker.record(const_source_location(name, inherit)&.first)
+        end
+
         result
       end
     end

data/lib/fast_cov/trackers/file_tracker.rb

@@ -21,19 +21,23 @@ module FastCov
       end
     end
 
+    # The patches are permanent, so each checks active before doing any work.
+    # Paths go over raw because AbstractTracker#record normalizes them.
     module FilePatch
       def read(name, *args, **kwargs, &block)
         super.tap do
-          FastCov::FileTracker.record(File.expand_path(name))
+          FastCov::FileTracker.record(name) if FastCov::FileTracker.active
         end
       end
 
       def open(name, *args, **kwargs, &block)
-        mode = args[0]
-        is_read = mode.nil? || (mode.is_a?(String) && mode.start_with?("r")) ||
-                  (mode.is_a?(Integer) && (mode & (File::WRONLY | File::RDWR)).zero?)
         super.tap do
-          FastCov::FileTracker.record(File.expand_path(name)) if is_read
+          next unless FastCov::FileTracker.active
+
+          mode = args[0]
+          is_read = mode.nil? || (mode.is_a?(String) && mode.start_with?("r")) ||
+                    (mode.is_a?(Integer) && (mode & (File::WRONLY | File::RDWR)).zero?)
+          FastCov::FileTracker.record(name) if is_read
         end
       end
     end
@@ -41,19 +45,19 @@ module FastCov
     module YamlPatch
       def load_file(path, *args, **kwargs)
         super.tap do
-          FastCov::FileTracker.record(File.expand_path(path))
+          FastCov::FileTracker.record(path) if FastCov::FileTracker.active
         end
       end
 
       def safe_load_file(path, *args, **kwargs)
         super.tap do
-          FastCov::FileTracker.record(File.expand_path(path))
+          FastCov::FileTracker.record(path) if FastCov::FileTracker.active
         end
       end
 
       def unsafe_load_file(path, *args, **kwargs)
         super.tap do
-          FastCov::FileTracker.record(File.expand_path(path))
+          FastCov::FileTracker.record(path) if FastCov::FileTracker.active
         end
       end
     end

data/lib/fast_cov/trackers/fixture_kit_tracker.rb

@@ -41,6 +41,8 @@ module FastCov
         # When a test mounts a fixture, record the fixture definition file
         # and any parent fixture files in the chain.
         config.on_cache_mount do |event|
+          next unless tracker.class.active
+
           tracker.class.record(event.path)
           parent = event.fixture.parent
           while parent

data/lib/fast_cov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCov
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/fast_cov.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "fast_cov/fast_cov.#{RUBY_VERSION}"
+require "rbconfig"
+
+# ABI version ("3.4.0"), not RUBY_VERSION ("3.4.9"): RubyGems keys installed
+# extensions by ABI, so it will not rebuild the gem on a patch-level upgrade.
+require "fast_cov/fast_cov.#{RbConfig::CONFIG["ruby_version"]}"
 
 module FastCov
   autoload :Utils, File.expand_path("fast_cov/utils", __dir__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_cov
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Ngan Pham