Internalize heap-size tracking into Tsavorite

[badrishc]

Summary

Replaces Garnet's heavyweight SubscribeEvictions observer pattern with Tsavorite-internal heap-size accounting. Previously, Garnet wired LogSizeTracker as an IObserver<ITsavoriteScanIterator> via SubscribeEvictions, which materialized a full page iterator on every eviction to sum heap sizes. Session functions (ISF) were responsible for creation-site, destruction-site, and in-place-mutation heap tracking, requiring every ISF implementation to manually call cacheSizeTracker.AddHeapSize() — fragile and error-prone.

Now, Tsavorite owns the complete heap-size lifecycle with zero ISF involvement:

Accounting	Who	How
+key at record creation	Tsavorite	CAS success sites (InternalRMW/Upsert/Delete)
+value at record creation	Tsavorite	After Post{InitialUpdater,InitialWriter,CopyUpdater} callbacks
+value on revivification	Tsavorite	In-chain revivification (InternalRMW/Upsert)
±delta on in-place update	Tsavorite	Pre/post GetValueHeapMemorySize() around InPlaceUpdater/Writer
−value on delete	Tsavorite	OnDispose(Deleted) — before tombstone is set
−value on copy-update	Tsavorite	OnDispose(CopyUpdated) — source cleared after copy
−(key+value) on eviction	Tsavorite	EvictRecordsInRange per-record walk
−key on tombstone eviction	Tsavorite	EvictRecordsInRange (value already subtracted at delete)
−remaining on elide/freelist	Tsavorite	OnDispose(Elided/RevivificationFreeList)

What Changed

Tsavorite core (libs/storage/Tsavorite/):

• InternalRMW.cs — IPU: pre/post GetValueHeapMemorySize() around InPlaceUpdater (including ExpireAndStop path). CAS success: +key after CAS, +value after PostInitialUpdater/PostCopyUpdater. In-chain revivification: +value. CopyUpdated disposal: −value + Dispose. ReinitializeExpiredRecord: +value.
• InternalUpsert.cs — IPW: pre/post GetValueHeapMemorySize() around InPlaceWriter. CAS success: +key, +value after PostInitialWriter. Revivification: +value.
• InternalDelete.cs — Mutable delete: OnDispose(Deleted) before SetTombstone(). CAS success: +key only (value becomes inline tombstone).
• ObjectAllocatorImpl.cs — OnDispose: −value for Deleted, −(key+value) for Elided/RevivificationFreeList, no-op for CASFailed/InsertAbandoned. EvictRecordsInRange: per-record −(key+value) for live, −key for tombstoned; sealed records visited (not skipped).
• IRecordTriggers.cs — New interface with DIM defaults: CallOnFlush/CallOnEvict/CallOnDiskRead (all default false), OnEvict(ref LogRecord, EvictionSource), OnFlush(ref LogRecord), OnDiskRead(ref LogRecord), OnDispose(ref LogRecord, DisposeReason), OnDisposeDiskRecord(ref DiskLogRecord, DisposeReason).
• LogSizeTracker.cs — Removed IObserver<ITsavoriteScanIterator> implementation (OnNext/OnCompleted/OnError).
• LogAccessor.cs — SubscribeEvictions no longer auto-wires logSizeTracker.
• AllocatorBase.cs — Added IsReadCache field for EvictionSource routing.
• EvictionSource.cs — New enum: MainLog, ReadCache.

Garnet server (libs/server/):

• IGarnetObject.Operate — Removed out long sizeChange parameter. All implementations updated (Hash, List, Set, SortedSet, CustomObjectBase). Tsavorite now handles heap deltas internally.
• GarnetRecordTriggers.cs — Empty readonly struct relying entirely on DIMs (no fields, no methods). Garnet objects hold no external resources requiring app-level cleanup.
• ObjectStore/RMWMethods.cs — Removed all cacheSizeTracker.AddHeapSize() calls. HasRemoveKey path now simply sets ExpireAndStop without manual delta tracking.
• MainStore/RMWMethods.cs — Removed inline guard and cacheSizeTracker calls (Tsavorite handles IPU delta).
• SessionFunctionsUtils.cs — Removed GetValueHeapMemorySize pre/post delta tracking from TryCopyAndUpdateOverflowValue.
• UnifiedStore/RMWMethods.cs — Removed out sizeChange plumbing.
• ObjectStore/ReadMethods.cs — Updated Operate call (removed out _).

Removed patterns:

• OnDisposeValueObject callback and disposer lambdas threaded through DiskLogRecord, ObjectIdMap, scan iterators
• LogSizeTracker as IObserver<ITsavoriteScanIterator> (was the SubscribeEvictions consumer)
• SubscribeEvictions auto-wire of logSizeTracker in LogAccessor
• cacheSizeTracker.AddHeapSize() calls from all ISF implementations
• IGarnetObject.Operate out sizeChange parameter and per-object previousMemorySize/memorySizeChange tracking

Key Invariants

Invariant	Mechanism
Tombstone AFTER OnDispose	OnDispose(Deleted) reads GetValueHeapMemorySize() before SetTombstone() zeroes it
Inline guard on IPU/IPW	!preInline || !postInline check — skips heap measurement for the common inline-value path
Sealed records visited by eviction	EvictRecordsInRange only skips Invalid/Tombstoned, not Sealed
CAS failure = no decrement	OnDispose(CASFailed/InsertAbandoned) does not subtract (record was never tracked)
Elided/freelist = full cleanup	OnDispose(Elided/RevivificationFreeList) subtracts remaining heap (tombstone-aware)
CopyUpdated balanced	Source −value via OnDispose(CopyUpdated), destination +value after PostCopyUpdater
Delete = +key only	Tombstone record adds only key overflow; value heap already subtracted at delete time
Revivification = re-add	Restoring tombstoned record re-adds +value (was subtracted at delete)
HasRemoveKey (IPU)	Object mutated (delta captured by Tsavorite), then ExpireAndStop → OnDispose(Deleted) subtracts remaining
HasRemoveKey (PCU)	PostCopyUpdater returns false, so +value is NOT added. Source handled by ClearSource or eviction

Heap Tracking by Tsavorite Operation

InternalRMW:
  Mutable IPU success  → ±delta (pre/post GetValueHeapMemorySize)
  Mutable ExpireAndStop → ±delta + OnDispose(Deleted) → −remaining
  Mutable ExpireAndResume → OnDispose(Deleted) → −value
  CAS new record       → +key, +value (after PostInitialUpdater)
  CAS copy-update      → +key, +value (after PostCopyUpdater), −srcValue (OnDispose CopyUpdated)
  In-chain revivify    → +value (after PostInitialUpdater)
  ReinitializeExpired  → +value (after PostInitialUpdater)

InternalUpsert:
  Mutable IPW success  → ±delta (pre/post GetValueHeapMemorySize)
  CAS new record       → +key, +value (after PostInitialWriter)
  In-chain revivify    → +value (after PostInitialWriter)

InternalDelete:
  Mutable delete       → OnDispose(Deleted) → −value, then SetTombstone
  CAS tombstone        → +key only

EvictRecordsInRange:
  Live record          → −CalculateHeapMemorySize (key + value)
  Tombstoned record    → −KeyOverflow.HeapMemorySize (key only)

OnDispose:
  Deleted              → −GetValueHeapMemorySize (value only)
  CopyUpdated          → −GetValueHeapMemorySize (value only)
  Elided               → −CalculateHeapMemorySize (key + value, tombstone-aware)
  RevivFreeList        → −CalculateHeapMemorySize (key + value, tombstone-aware)
  CASFailed            → no-op (never tracked)
  InsertAbandoned      → no-op (never tracked)

Tests

Tsavorite — RecordLifecycleTests.cs (12 tests):

• CopyUpdateDoesNotFireOnDisposeCopyUpdated — copy-update doesn't fire CopyUpdated dispose on source when no explicit cleanup needed
• CopyUpdateDisposesSourceValueExactlyOnce — source value disposed exactly once after copy-update
• DeleteFiresOnDisposeDeletedAndNoOnDisposeDiskRecord — delete fires OnDispose(Deleted), not OnDisposeDiskRecord
• ScanInMemoryFiresOnDisposeDiskRecordOncePerRecord — in-memory scan fires DiskRecord dispose once per record
• ScanDiskFiresOnDisposeDiskRecordOncePerRecord — disk scan fires DiskRecord dispose once per record
• PendingReadFromDiskFiresOnDisposeDiskRecordOnce — pending read fires DiskRecord dispose once
• PageEvictionFiresOnEvictForEveryLiveRecord — validates per-record OnEvict callback
• CallOnFlushGatesOnFlushInvocation — CallOnFlush=false suppresses OnFlush
• CallOnDiskReadGatesOnDiskReadInvocation — CallOnDiskRead=false suppresses OnDiskRead
• CallOnEvictGatingSuppressesOnEvictCallback — CallOnEvict=false suppresses OnEvict
• ReadCacheEvictionFiresOnEvictWithReadCacheSource — validates EvictionSource.ReadCache routing
• NoValueObjectIsDisposedMoreThanOnceAcrossLifecycle — no double-dispose across full lifecycle

Garnet — CacheSizeTrackerTests.cs (4 tests):

• RecordHeapSizeValidationTest — heap accounting stays balanced
• SmallMainLogFineGrainedEvictionTest — eviction triggers correct size decrements
• RemoveLastElementReturnsTrackerToZero_IPU — removing last element via IPU path returns tracker to zero
• RemoveLastElementReturnsTrackerToZero_PCU — removing last element via PCU path returns tracker to zero

Future TODO

The only residual subtlety worth flagging (and pre-existing to this PR) is that a TryCopyToTail produces two records sharing the same IHeapObject via TryCopyFrom. If a subsequent in-place RMW on the dest mutates that shared object (growing from X to Y), CalculateHeapMemorySize at source-evict time will return the current Y, not the originally-added X — so the source's eviction under-/over-decrement scales with post-copy mutation. The old observer-iterator path reads the same field at the same time, so it has exactly the same behavior.