perf: reads that resolve on the prototype chain (absent keys, inherited data) are 590–2,100× slower than Node (read IC caches own properties only) #10495

Found by the package performance audit (real npm packages compiled from source, profiled against Node 26.5.1) and
re-measured on Perry 7661bc0 (v0.5.1589), Linux x64. A property read whose answer is not an own data property of
the receiver — an absent key (opts.ttl on {}), an inherited data property (this.DB on a prototype), or a
primitive's inherited property (s.constructor.name) — misses the read IC on every execution and re-walks the
prototype chain by name: 7,000–9,000 instructions per read, against ~40 for an own-property read.

Reproduction

bench.ts (23 lines):

// Reads that resolve on (or fall off) the prototype chain: absent keys, inherited data constants, String.prototype
const variant = process.argv[2] || "absent3"; const N = Number(process.argv[3] || "1000000");
class D { $L: string; $d: number; $y: number; constructor(v: number) { this.$L = "en"; this.$d = v; this.$y = v % 7; } clone() { return 1; } }
(D.prototype as any).DB = 26; (D.prototype as any).DM = 67108863; (D.prototype as any).DV = 67108864;
const objs: any[] = []; for (let i = 0; i < 64; i++) objs.push(new D(i));
const bags: any[] = [{ status: undefined }, { ttl: 5 }, {}, { start: 1 }];
const strs: any[] = ["foo@bar.com", "not-an-email", "https://example.com/p", "example"];
class Cache { ttl = 3; allowStale = false; updateAgeOnGet = false; v = 0;
  get(k: number, getOptions: any = {}) { const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, status } = getOptions; this.v = (this.v + k + (allowStale ? 1 : 0) + (status ? 1 : 0)) | 0; return this.v; }
  plain(k: number) { this.v = (this.v + k + (this.allowStale ? 1 : 0)) | 0; return this.v; } }
const c = new Cache();
const V: Record<string, (n: number) => number> = {
  own3(n) { let a = 0; for (let i = 0; i < n; i++) { const o = objs[i & 63]; a += (o.$L ? 1 : 0) + (o.$d ? 1 : 0) + (o.$y ? 1 : 0); } return a; },
  absent3(n) { let a = 0; for (let i = 0; i < n; i++) { const o = objs[i & 63]; a += (o.$u ? 1 : 0) + (o.$offset ? 1 : 0) + (o.$x ? 1 : 0); } return a; },
  literal_absent3(n) { let a = 0; for (let i = 0; i < n; i++) { const o = bags[i & 3]; a += (o.ttl === undefined ? 1 : 0) + (o.start === undefined ? 1 : 0) + (o.size === undefined ? 1 : 0); } return a; },
  proto_data3(n) { let a = 0; for (let i = 0; i < n; i++) { const o = objs[i & 63]; a = ((a + o.DB) % o.DV) & o.DM; } return a; },
  str_ctor_name(n) { let a = 0; for (let i = 0; i < n; i++) { const s = strs[i & 3]; if (s.constructor.name !== "String") throw new TypeError("x"); a += s.length; } return a; },
  str_length(n) { let a = 0; for (let i = 0; i < n; i++) { const s = strs[i & 3]; a += s.length; } return a; },
  lru_get_opts(n) { let a = 0; for (let i = 0; i < n; i++) a = c.get(i); return a; },
  lru_plain(n) { let a = 0; for (let i = 0; i < n; i++) a = c.plain(i); return a; },
};
V[variant](N / 5 | 0); c.v = 0; const t0 = performance.now(); const cs = V[variant](N);
console.log(`variant=${variant} checksum=${cs} ms=${(performance.now() - t0).toFixed(2)}`);

PERRY_NO_AUTO_OPTIMIZE=1 perry compile bench.ts -o bench
for v in own3 absent3 literal_absent3 proto_data3 lru_plain lru_get_opts str_length str_ctor_name; do
  node bench.ts $v 1000000; ./bench $v 1000000; done

Measurements

Median of 3, shared host (loaded; instruction counts are the load-independent figure). N = 1,000,000; Perry
instructions per iteration = (whole-process instructions:u − 38 M startup) / 1.2 M (timed run + N/5 warm-up).
Node's loop is largely JIT-folded for these reads, so the Node-relative ratios are lower-bound-ish; the
control-vs-variant gap inside Perry is the mechanism's cost.

Checksums identical. Per read: absent ≈ 7,400–8,800 instructions, inherited data ≈ 3,850, vs ≈ 40–80 for an own read.

Impact

Audit profiles, v0.5.1587 (shares of Perry CPU in the named workload):

• lru-cache 11.5.2: get_field_ic_miss_impl 22.2 % of the whole run, 10.2 % of it prototype walks for absent keys —
  set(k, v, setOptions = {}) / get(k, getOptions = {}) destructure { ttl = this.ttl, start, status, … } from an
  options bag that usually lacks every key (objects-group report; combined with property adds ≈ 36 %).
• decimal.js ≈ 17 %, jsonwebtoken ≈ 16 %, lodash ≈ 13 % (absent-key reads + adds, objects-group report).
• dayjs 15.3 %, date-fns 12.2 % (differenceInHours 29.4 %), validator 16.0 % (isUUID 31.5 %), qs 5.5 %
  ("property GET IC miss", strings-group report). dayjs wrapper() reads instance.$u/instance.$offset (absent);
  validator assertString reads input.constructor.name on every entry point.
• node-forge (jsbn): BigInteger.prototype.DB/DM/DV read as this.DB in the multiply/reduce loops, part of the
  9–11 % property bucket (numeric-group report).

Mechanism

• get_field_ic_miss_impl (crates/perry-runtime/src/object/field_get_set/ic_miss.rs:540) primes the read PIC only
  when the key is found among the receiver's OWN keys: prime_get for an own inline slot (ic_miss.rs:980) or an own
  overflow slot (ic_miss.rs:924). Any other outcome falls through to an unprimed js_object_get_field_by_name(obj, key)
  (ic_miss.rs:995) (verified). There is no negative (absent) or holder (prototype) entry, so the next execution misses
  again.
• That call reaches get_field_by_name_object_tail
  (crates/perry-runtime/src/object/field_get_set/get_field_by_name_tail.rs:7), which resolves the key by name through
  resolve_inherited_field / ordinary_object_prototype_property_value (get_field_by_name_tail.rs:1365-1393,
  accessors.rs:280) and prototype_property_value_with_guard (accessors.rs:218, a RuntimeHandleScope with three
  roots plus a recursive js_object_get_field_by_name on the prototype) (verified).
• Profile of absent3 (perf record, symbols): get_field_ic_miss_impl 97 % inclusive → get_field_by_name_object_tail
  76 % → ordinary_object_prototype_property_value 44 %; self time spread over js_object_get_field_by_name 9 %,
  try_data_get_bytes 5 %, from_utf8 4 %, keys_find_slot_by_bytes 4 %, class-registry probes
  (class_decl_prototype_object, get_parent_class_id, lookup_prototype_method, is_class_object_ptr) and
  shape_is_url_search_params 7 % (verified by profile).
• proto_data3 takes the same path (lookup_prototype_method, resolve_proto_chain_field_inner, SipHash of &str).
• str_ctor_name goes get_field_ic_miss_impl → string_property_get_miss
  (crates/perry-runtime/src/string/char_ops.rs:164) → js_reflect_get on String.prototype, then .name on the
  String constructor through closure_get_dynamic_prop + get_accessor_descriptor + js_get_global_this_builtin_value
  (verified by profile: 70 % under string_property_get_miss, 44 % js_reflect_get).

What fast looks like

A prototype-chain-aware read IC: cache (receiver shape → holder object + slot) for inherited data and
(receiver shape → absent) for misses, guarded by a validity token for the shapes on the chain (invalidated when any
prototype on the chain gains/loses that key or is re-parented). Targets on this microbenchmark: absent3 and
literal_absent3 within 3× of own3 (≤ ~800 instructions/iteration, from 22,000–26,000); proto_data3 ≤ 500
instructions/iteration; lru_get_opts within 5× of lru_plain; str_ctor_name ≤ 1,000 instructions/iteration
(the String.prototype.constructor holder and the builtin name are both cacheable).

Notes

• Own-property reads on the same objects are already fast (own3 260 instructions/iteration), so this is purely the
  miss path.
• Related, closed: Property access past the FIRST slot misses its cache: 3 ms vs 28 ms for the same object (bench_object_property, 2.6x) #9287 (IC misses past the first slot), The #7850 probe family has moved to the property-get IC-miss tail: get_field_by_name_tail probes 4 registries before reading the GcHeader it then switches on (1.8% of pipeline_big) #7867 (probe family on the IC-miss tail), perf(runtime): gate the rare-subclass probes on the object property-miss path (asyncpipe 9.69x -> 1.76x node) #7795 (memoized
  Object.prototype on the miss path). The same missing holder/negative cache also shows up on function values —
  see perf: missing-property reads on functions are ~2,600× and Object.hasOwn/getPrototypeOf 40–90× slower than Node (Function.prototype re-resolved by name per call) #10497; the write-side counterpart (adds) is perf: adding a property with o.k = v is ~100× slower than Node (static-key write IC primes only overwrites; no add-transition cache) #10496.
• Shares above are from the v0.5.1587 audit profiles; ratios and instruction counts are re-measured on 7661bc0.