perf(builtin): derive Map's probe-sequence length instead of storing it

`Entry` carried a `mut psl : Int` alongside `hash`, `key` and `value`.
That field is not independent state: an entry's probe-sequence length is
the distance between the slot it occupies and the slot its hash asked
for, so

    psl = (idx - (hash & capacity_mask)) & capacity_mask

Every write to it happened as the entry landed in a slot and always
equalled that displacement, and every read happens inside a probe loop
that already knows the slot index. `psl_at` computes it where it is
needed and the field is gone, leaving five fields per entry instead of
six.

`shift_back` no longer decrements anything: moving an entry one slot back
lowers its derived PSL by exactly one. `push_away` and
`rehash_place_entry` likewise stop writing PSLs and just place entries.

I checked the premise before relying on it rather than reasoning about
it. Instrumenting `set_entry` and `add_entry_to_tail` -- every path that
places an entry in a slot -- to assert `psl == (idx - (hash & mask)) &
mask` on each write, the full suite passes on native, js and wasm-gc with
that assertion live: 7544, 7485 and 7544 tests, no violation.

No layout change: the table is still `FixedArray[Entry[K, V]?]`, so
nothing here shares the tradeoffs of the struct-of-arrays experiments on
#4127 and #4131.

Measured against `main`, n=50000, interleaved in one session:

| backend | op | main | this | change |
| ------- | -- | ---- | ---- | ------ |
| js      | `set`        | 3.04 ms | 2.90 ms | 5% faster |
| js      | `get` hit    | 1.01 ms | 1.00 ms | unchanged |
| js      | `get` miss   | 1.16 ms | 1.15 ms | unchanged |
| js      | `set+remove` | 4.30 ms | 4.29 ms | unchanged |
| native  | `set`        | 2.62 ms | 2.63 ms | unchanged |
| native  | `get` hit    | 855 us  | 832 us  | 3% faster |
| native  | `set+remove` | 3.82 ms | 3.73 ms | 2% faster |
| wasm-gc | `set`        | 2.46 ms | 2.42 ms | 2% faster |
| wasm-gc | `get` hit    | 1.07 ms | 1.07 ms | unchanged |

Insertion gains where the smaller entry matters most and nothing
regresses; the derivation costs two arithmetic operations per probe step
against a field read from an object already in cache, which is why
lookups come out flat.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: bobzhang

builtin/linked_hash_map.mbt

@@ -19,7 +19,6 @@
 priv struct Entry[K, V] {
   mut prev : Int
   mut next : Entry[K, V]?
-  mut psl : Int
   hash : Int
   key : K
   mut value : V
@@ -74,6 +73,16 @@ struct Map[K, V] {
 // that does not depend on the list invariant. It carries that proof at its
 // definition, and it is what makes its `set_entry` call sound.
 
+///|
+/// The probe-sequence length of the entry occupying slot `idx`: how far it
+/// sits from the slot its hash asked for. Derived rather than stored, since
+/// an entry's PSL is fully determined by where it ended up -- every write to
+/// it happened as the entry landed in a slot, always equal to this value.
+#inline
+fn[K, V] Map::psl_at(self : Map[K, V], idx : Int, entry : Entry[K, V]) -> Int {
+  (idx - (entry.hash & self.capacity_mask)) & self.capacity_mask
+}
+
 ///|
 let default_init_capacity = 8
 
@@ -173,7 +182,7 @@ fn[K : Eq, V] Map::set_with_hash(
           // Restart search with new capacity_mask
           continue 0, hash & self.capacity_mask
         }
-        let entry = { prev: self.tail, next: None, psl, key, value, hash }
+        let entry = { prev: self.tail, next: None, key, value, hash }
         self.add_entry_to_tail(idx, entry)
         return
       }
@@ -183,15 +192,15 @@ fn[K : Eq, V] Map::set_with_hash(
           curr_entry.value = value
           return
         }
-        if psl > curr_entry.psl {
+        if psl > self.psl_at(idx, curr_entry) {
           // Need to insert and push away - check if grow is needed first
           if self.size >= self.grow_at {
             self.grow()
             // Restart search with new capacity_mask
             continue 0, hash & self.capacity_mask
           }
           self.push_away(idx, curr_entry)
-          let entry = { prev: self.tail, next: None, psl, key, value, hash }
+          let entry = { prev: self.tail, next: None, key, value, hash }
           self.add_entry_to_tail(idx, entry)
           return
         }
@@ -209,20 +218,17 @@ fn[K, V] Map::push_away(
   entry : Entry[K, V],
 ) -> Unit {
   // SAFETY: masked probe index; see the note at the top of this file.
-  for psl = entry.psl + 1, idx = (idx + 1) & self.capacity_mask, entry = entry {
+  for psl = self.psl_at(idx, entry) + 1, idx = (idx + 1) & self.capacity_mask, entry = entry {
     match self.entries.unsafe_get(idx) {
       None => {
-        entry.psl = psl
         self.set_entry(entry, idx)
         break
       }
       Some(curr_entry) =>
-        if psl > curr_entry.psl {
-          entry.psl = psl
+        if psl > self.psl_at(idx, curr_entry) {
+          let displaced_psl = self.psl_at(idx, curr_entry) + 1
           self.set_entry(entry, idx)
-          continue curr_entry.psl + 1,
-            (idx + 1) & self.capacity_mask,
-            curr_entry
+          continue displaced_psl, (idx + 1) & self.capacity_mask, curr_entry
         } else {
           continue psl + 1, (idx + 1) & self.capacity_mask, entry
         }
@@ -274,7 +280,7 @@ pub fn[K : Hash + Eq, V] Map::get(self : Map[K, V], key : K) -> V? {
     if entry.hash == hash && entry.key == key {
       break Some(entry.value)
     }
-    if i > entry.psl {
+    if i > self.psl_at(idx, entry) {
       break None
     }
     continue i + 1, (idx + 1) & self.capacity_mask
@@ -292,7 +298,7 @@ pub fn[K : Hash + Eq, V] Map::at(self : Map[K, V], key : K) -> V {
     if entry.hash == hash && entry.key == key {
       return entry.value
     }
-    guard! i <= entry.psl
+    guard! i <= self.psl_at(idx, entry)
     continue i + 1, (idx + 1) & self.capacity_mask
   }
 }
@@ -333,7 +339,7 @@ pub fn[K : Hash + Eq, V] Map::get_or_default(
         if entry.hash == hash && entry.key == key {
           break entry.value
         }
-        if i > entry.psl {
+        if i > self.psl_at(idx, entry) {
           break default
         }
         continue i + 1, (idx + 1) & self.capacity_mask
@@ -352,14 +358,14 @@ pub fn[K : Hash + Eq, V] Map::get_or_init(
 ) -> V {
   let hash = Hash::hash(key)
   // SAFETY: masked probe index; see the note at the top of this file.
-  let (idx, psl, new_value, push_away) = for psl = 0, idx = hash &
-                                               self.capacity_mask {
+  let (idx, _, new_value, push_away) = for psl = 0, idx = hash &
+                                             self.capacity_mask {
     match self.entries.unsafe_get(idx) {
       Some(entry) => {
         if entry.hash == hash && entry.key == key {
           return entry.value
         }
-        if psl > entry.psl {
+        if psl > self.psl_at(idx, entry) {
           let new_value = default()
           break (idx, psl, new_value, Some(entry))
         }
@@ -379,14 +385,7 @@ pub fn[K : Hash + Eq, V] Map::get_or_init(
     if push_away is Some(entry) {
       self.push_away(idx, entry)
     }
-    let entry = {
-      prev: self.tail,
-      next: None,
-      psl,
-      hash,
-      key,
-      value: new_value,
-    }
+    let entry = { prev: self.tail, next: None, hash, key, value: new_value }
     self.add_entry_to_tail(idx, entry)
   }
   new_value
@@ -419,14 +418,14 @@ pub fn[K : Hash + Eq, V] Map::update_or_default(
 ) -> Unit {
   let hash = Hash::hash(key)
   // SAFETY: masked probe index; see the note at the top of this file.
-  let (idx, psl, push_away) = for psl = 0, idx = hash & self.capacity_mask {
+  let (idx, _, push_away) = for psl = 0, idx = hash & self.capacity_mask {
     match self.entries.unsafe_get(idx) {
       Some(entry) => {
         if entry.hash == hash && entry.key == key {
           entry.value = f(entry.value)
           return
         }
-        if psl > entry.psl {
+        if psl > self.psl_at(idx, entry) {
           break (idx, psl, Some(entry))
         }
         continue psl + 1, (idx + 1) & self.capacity_mask
@@ -441,7 +440,7 @@ pub fn[K : Hash + Eq, V] Map::update_or_default(
     if push_away is Some(entry) {
       self.push_away(idx, entry)
     }
-    let entry = { prev: self.tail, next: None, psl, hash, key, value: default }
+    let entry = { prev: self.tail, next: None, hash, key, value: default }
     self.add_entry_to_tail(idx, entry)
   }
 }
@@ -457,7 +456,7 @@ pub fn[K : Hash + Eq, V] Map::contains(self : Map[K, V], key : K) -> Bool {
     if entry.hash == hash && entry.key == key {
       break true
     }
-    if i > entry.psl {
+    if i > self.psl_at(idx, entry) {
       break false
     }
     continue i + 1, (idx + 1) & self.capacity_mask
@@ -499,7 +498,7 @@ pub fn[K : Hash + Eq, V : Eq] Map::contains_kv(
     if entry.hash == hash && entry.key == key && entry.value == value {
       break true
     }
-    if i > entry.psl {
+    if i > self.psl_at(idx, entry) {
       break false
     }
     continue i + 1, (idx + 1) & self.capacity_mask
@@ -546,7 +545,7 @@ fn[K : Eq, V] Map::remove_with_hash(
       self.size -= 1
       break
     }
-    if i > entry.psl {
+    if i > self.psl_at(idx, entry) {
       break
     }
     continue i + 1, (idx + 1) & self.capacity_mask
@@ -592,15 +591,20 @@ fn[K, V] Map::shift_back(self : Map[K, V], idx : Int) -> Unit {
   for cur = idx {
     let next = (cur + 1) & self.capacity_mask
     match self.entries.unsafe_get(next) {
-      None | Some({ psl: 0, .. }) => {
+      None => {
         self.entries.unsafe_set(cur, None)
         break
       }
-      Some(entry) => {
-        entry.psl -= 1
-        self.set_entry(entry, cur)
-        continue next
-      }
+      Some(entry) =>
+        if self.psl_at(next, entry) == 0 {
+          self.entries.unsafe_set(cur, None)
+          break
+        } else {
+          // Moving the entry one slot back drops its derived PSL by one, so
+          // nothing has to be written for it.
+          self.set_entry(entry, cur)
+          continue next
+        }
     }
   }
 }
@@ -637,15 +641,13 @@ fn[K, V] Map::rehash_place_entry(self : Map[K, V], outer : Entry[K, V]) -> Unit
   for psl = 0, idx = hash & self.capacity_mask {
     match self.entries.unsafe_get(idx) {
       None => {
-        outer.psl = psl
         outer.prev = self.tail
         self.add_entry_to_tail(idx, outer)
         return
       }
       Some(curr) =>
-        if psl > curr.psl {
+        if psl > self.psl_at(idx, curr) {
           self.push_away(idx, curr)
-          outer.psl = psl
           outer.prev = self.tail
           self.add_entry_to_tail(idx, outer)
           return
@@ -891,9 +893,9 @@ pub fn[K, V, V2] Map::map(self : Map[K, V], f : (K, V) -> V2) -> Map[K, V2] {
   }
   guard! self.entries[self.tail] is Some(last)
   for entry = last, idx = self.tail, next = (None : Entry[K, V2]?) {
-    let { prev, psl, hash, key, value, .. } = entry
+    let { prev, hash, key, value, .. } = entry
     let new_value = f(key, value)
-    let new_entry = { prev, next, psl, hash, key, value: new_value }
+    let new_entry = { prev, next, hash, key, value: new_value }
     other.entries[idx] = Some(new_entry)
     if prev != -1 {
       continue self.entries[prev].unwrap(), prev, Some(new_entry)
@@ -924,8 +926,8 @@ pub fn[K, V] Map::copy(self : Map[K, V]) -> Map[K, V] {
   }
   guard! self.entries[self.tail] is Some(last)
   for entry = last, idx = self.tail, next = (None : Entry[K, V]?) {
-    let { prev, psl, hash, key, value, .. } = entry
-    let new_entry = { prev, next, psl, hash, key, value }
+    let { prev, hash, key, value, .. } = entry
+    let new_entry = { prev, next, hash, key, value }
     other.entries[idx] = Some(new_entry)
     if prev != -1 {
       continue self.entries[prev].unwrap(), prev, Some(new_entry)
@@ -1135,8 +1137,8 @@ pub fn[K : Hash + Eq, V] Map::update(
 ) -> Unit {
   let hash = Hash::hash(key)
   // SAFETY: masked probe index; see the note at the top of this file.
-  let (idx, psl, new_value, push_away) = for psl = 0, idx = hash &
-                                               self.capacity_mask {
+  let (idx, _, new_value, push_away) = for psl = 0, idx = hash &
+                                             self.capacity_mask {
     match self.entries.unsafe_get(idx) {
       Some(entry) => {
         if entry.hash == hash && entry.key == key {
@@ -1151,7 +1153,7 @@ pub fn[K : Hash + Eq, V] Map::update(
           }
           return
         }
-        if psl > entry.psl {
+        if psl > self.psl_at(idx, entry) {
           guard f(None) is Some(new_value) else { return }
           break (idx, psl, new_value, Some(entry))
         }
@@ -1171,14 +1173,7 @@ pub fn[K : Hash + Eq, V] Map::update(
     if push_away is Some(entry) {
       self.push_away(idx, entry)
     }
-    let entry = {
-      prev: self.tail,
-      next: None,
-      psl,
-      hash,
-      key,
-      value: new_value,
-    }
+    let entry = { prev: self.tail, next: None, hash, key, value: new_value }
     self.add_entry_to_tail(idx, entry)
   }
 }
@@ -1216,7 +1211,7 @@ pub fn[V] Map::get_from_bytes(map : Self[Bytes, V], key : BytesView) -> V? {
     if entry.hash == hash && key.equal_to_bytes(entry.key) {
       break Some(entry.value)
     }
-    if i > entry.psl {
+    if i > map.psl_at(idx, entry) {
       break None
     }
     continue i + 1, (idx + 1) & map.capacity_mask
@@ -1254,7 +1249,7 @@ pub fn[V] Map::get_from_string(map : Self[String, V], key : StringView) -> V? {
     if entry.hash == hash && key.equal_to_string(entry.key) {
       break Some(entry.value)
     }
-    if i > entry.psl {
+    if i > map.psl_at(idx, entry) {
       break None
     }
     continue i + 1, (idx + 1) & map.capacity_mask

builtin/linked_hash_map_wbtest.mbt

@@ -585,7 +585,7 @@ test "remove_entry_head" {
   guard! map.head is Some(head)
   assert_true(head.prev == -1)
   assert_true(head.next is None)
-  assert_true(head.psl == 0)
+  assert_true(map.psl_at(head.hash & map.capacity_mask, head) == 0)
   assert_true(head.hash == (2).hash())
   assert_true(head.key == 2)
   assert_true(head.value == 2)
@@ -603,7 +603,7 @@ test "remove_entry_tail" {
   guard! map.entries[map.tail] is Some(tail)
   assert_true(tail.prev == -1)
   assert_true(tail.next is None)
-  assert_true(tail.psl == 0)
+  assert_true(map.psl_at(map.tail, tail) == 0)
   assert_true(tail.hash == (1).hash())
   assert_true(tail.key == 1)
   assert_true(tail.value == 1)
@@ -641,7 +641,8 @@ fn[K : Show, V : Show] Map::_debug_entries(self : Map[K, V]) -> String {
     }
     match entry {
       None => buf.write_char('_')
-      Some({ psl, key, value, .. }) => buf <+ "(\{psl},\{key},\{value})"
+      Some(entry) =>
+        buf <+ "(\{self.psl_at(i, entry)},\{entry.key},\{entry.value})"
     }
   }
   buf.to_string()