- Fix InternalDelete elision from HashBucketEntry (set entire word to 0) (#866)

TedHartMS · web-flow · commit 7e41e49a7f31 · 2023-08-22T13:04:39.000-07:00
- Fix iterators to jump ahead to BeginAddress if they're below it, rather than throw
- Remove unused HashBucketEntry.Pending
- Remove unnecessary ReadCacheEvictChain call in DetachAndReattachReadCacheChain
diff --git a/cs/src/core/Allocator/BlittableScanIterator.cs b/cs/src/core/Allocator/BlittableScanIterator.cs
@@ -93,10 +93,7 @@ public unsafe bool GetNext(out RecordInfo recordInfo)
                 var headAddress = hlog.HeadAddress;
 
                 if (currentAddress < hlog.BeginAddress && !forceInMemory)
-                {
-                    epoch?.Suspend();
-                    throw new FasterException("Iterator address is less than log BeginAddress " + hlog.BeginAddress);
-                }
+                    currentAddress = hlog.BeginAddress;
 
                 // If currentAddress < headAddress and we're not buffering and not guaranteeing the records are in memory, fail.
                 if (frameSize == 0 && currentAddress < headAddress && !forceInMemory)
diff --git a/cs/src/core/Allocator/GenericScanIterator.cs b/cs/src/core/Allocator/GenericScanIterator.cs
@@ -90,10 +90,7 @@ public unsafe bool GetNext(out RecordInfo recordInfo)
                 var headAddress = hlog.HeadAddress;
 
                 if (currentAddress < hlog.BeginAddress)
-                {
-                    epoch?.Suspend();
-                    throw new FasterException("Iterator address is less than log BeginAddress " + hlog.BeginAddress);
-                }
+                    currentAddress = hlog.BeginAddress;
 
                 // If currentAddress < headAddress and we're not buffering, fail.
                 if (frameSize == 0 && currentAddress < headAddress)
diff --git a/cs/src/core/Allocator/VarLenBlittableScanIterator.cs b/cs/src/core/Allocator/VarLenBlittableScanIterator.cs
@@ -96,10 +96,7 @@ public unsafe bool GetNext(out RecordInfo recordInfo)
                 long headAddress = hlog.HeadAddress;
 
                 if (currentAddress < hlog.BeginAddress && !forceInMemory)
-                {
-                    epoch?.Suspend();
-                    throw new FasterException("Iterator address is less than log BeginAddress " + hlog.BeginAddress);
-                }
+                    currentAddress = hlog.BeginAddress;
 
                 // If currentAddress < headAddress and we're not buffering and not guaranteeing the records are in memory, fail.
                 if (frameSize == 0 && currentAddress < headAddress && !forceInMemory)
diff --git a/cs/src/core/Index/FASTER/FASTERBase.cs b/cs/src/core/Index/FASTER/FASTERBase.cs
@@ -6,7 +6,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
-using FASTER.core;
 using Microsoft.Extensions.Logging;
 
 namespace FASTER.core
@@ -251,18 +250,6 @@ public ushort Tag
             }
         }
 
-        public bool Pending
-        {
-            readonly get => (word & Constants.kPendingBitMask) != 0;
-            set
-            {
-                if (value)
-                    word |= Constants.kPendingBitMask;
-                else
-                    word &= ~Constants.kPendingBitMask;
-            }
-        }
-
         public bool Tentative
         {
             readonly get => (word & Constants.kTentativeBitMask) != 0;
@@ -291,7 +278,7 @@ public override string ToString()
         {
             var addrRC = this.ReadCache ? "(rc)" : string.Empty;
             static string bstr(bool value) => value ? "T" : "F";
-            return $"addr {this.AbsoluteAddress}{addrRC}, tag {Tag}, tent {bstr(Tentative)}, pend {bstr(Pending)}";
+            return $"addr {this.AbsoluteAddress}{addrRC}, tag {Tag}, tent {bstr(Tentative)}";
         }
     }
 
@@ -486,7 +473,6 @@ internal void FindOrCreateTag(ref HashEntryInfo hei, long BeginAddress)
                 hei.entry = default;
                 hei.entry.Tag = hei.tag;
                 hei.entry.Address = Constants.kTempInvalidAddress;
-                hei.entry.Pending = false;
                 hei.entry.Tentative = true;
 
                 // Insert the tag into this slot. Failure means another session inserted a key into that slot, so continue the loop to find another free slot.
diff --git a/cs/src/core/Index/FASTER/Implementation/HashEntryInfo.cs b/cs/src/core/Index/FASTER/Implementation/HashEntryInfo.cs
@@ -86,7 +86,6 @@ internal bool TryCAS(long newLogicalAddress, ushort tag)
             {
                 Tag = tag,
                 Address = newLogicalAddress & Constants.kAddressMask,
-                Pending = this.entry.Pending,
                 Tentative = false
                 // .ReadCache is included in newLogicalAddress
             };
diff --git a/cs/src/core/Index/FASTER/Implementation/InternalDelete.cs b/cs/src/core/Index/FASTER/Implementation/InternalDelete.cs
@@ -111,13 +111,12 @@ internal OperationStatus InternalDelete<Input, Output, Context, FasterSession>(r
                         if (WriteDefaultOnDelete)
                             recordValue = default;
 
-                        // Try to update hash chain and completely elide record iff previous address points to invalid address, to avoid re-enabling a prior version of this record.
-                        if (stackCtx.hei.Address == stackCtx.recSrc.LogicalAddress && !fasterSession.IsManualLocking && srcRecordInfo.PreviousAddress < hlog.BeginAddress)
+                        // Try to update hash chain to elide record iff previous address points to invalid address, to avoid re-enabling a prior version of this record.
+                        if (stackCtx.hei.Address == stackCtx.recSrc.LogicalAddress && srcRecordInfo.PreviousAddress < hlog.BeginAddress)
                         {
                             // Ignore return value; this is a performance optimization to keep the hash table clean if we can, so if we fail it just means
-                            // the hashtable entry has already been updated by someone else.
-                            var address = (srcRecordInfo.PreviousAddress == Constants.kTempInvalidAddress) ? Constants.kInvalidAddress : srcRecordInfo.PreviousAddress;
-                            stackCtx.hei.TryCAS(address, tag: 0);
+                            // the hashtable entry has already been updated by someone else. Set the entry.word to zero.
+                            stackCtx.hei.TryCAS(Constants.kInvalidAddress, tag: 0);
                         }
 
                         status = OperationStatusUtils.AdvancedOpCode(OperationStatus.SUCCESS, StatusCode.InPlaceUpdatedRecord);
diff --git a/cs/src/core/Index/FASTER/Implementation/ReadCache.cs b/cs/src/core/Index/FASTER/Implementation/ReadCache.cs
@@ -127,32 +127,30 @@ private bool DetachAndReattachReadCacheChain(ref Key key, ref OperationStackCont
                 goto Success;
 
             // Traverse from highestRcAddress to the splice point, invalidating any record matching the key.
-            for (bool found = false; /* tested in loop */; /* incremented in loop */)
+            for (bool foundKey = false; /* tested in loop */; /* incremented in loop */)
             {
                 var physicalAddress = readcache.GetPhysicalAddress(AbsoluteAddress(lowestRcAddress));
                 ref RecordInfo recordInfo = ref readcache.GetInfo(physicalAddress);
-                if (!found && !recordInfo.Invalid && comparer.Equals(ref key, ref readcache.GetKey(physicalAddress)))
+                if (!foundKey && !recordInfo.Invalid && comparer.Equals(ref key, ref readcache.GetKey(physicalAddress)))
                 {
-                    found = true;
+                    foundKey = true;
                     recordInfo.SetInvalidAtomic();      // Atomic needed due to other threads (e.g. ReadCacheEvict) possibly being in this chain before we detached it.
                 }
 
                 // See if we're at the last entry in the readcache prefix.
                 if (!IsReadCache(recordInfo.PreviousAddress) || AbsoluteAddress(recordInfo.PreviousAddress) < readcache.HeadAddress)
                 {
                     // Splice the new recordInfo into the local chain. Use atomic due to other threads (e.g. ReadCacheEvict) possibly being in this
-                    // before we detached it, and setting the record to Invalid (no other thread will be updating anything else in the chain, though).
+                    // before we detached it, and setting the record to Invalid (no other thread will be updating anything else in the chain, though;
+                    // we own the chain by virtue of the CAS above, and nobody else can change recordInfo.PreviousAddress).
                     while (!recordInfo.TryUpdateAddress(recordInfo.PreviousAddress, newLogicalAddress))
                         Thread.Yield();
 
-                    // Now try to CAS the chain into the HashBucketEntry. If it fails, give up; we lose those readcache records.
-                    // Trying to handle conflicts would require evaluating whether other threads had inserted keys in our chain, and it's too rare to worry about.
-                    if (stackCtx.hei.TryCAS(highestRcAddress))
-                    {
-                        // If we go below readcache.HeadAddress ReadCacheEvict may race past us, so make sure the lowest address is still in range.
-                        while (lowestRcAddress < readcache.HeadAddress)
-                            lowestRcAddress = ReadCacheEvictChain(readcache.HeadAddress, ref stackCtx.hei);
-                    }
+                    // Now try to CAS the chain into the HashBucketEntry. Ignore the result; if it fails, we just lose these readcache records.
+                    // Conflict handling would require evaluating whether other threads had inserted keys in our chain, and it's too rare to worry about.
+                    // We have ensured all records in this readcache prefix chain are >= readcache.HeadAddress, so even if readcache.HeadAddress changes,
+                    // ReadCacheEvict will not be called for any records in this readcache prefix chain until we return from here and release the epoch.
+                    stackCtx.hei.TryCAS(highestRcAddress);
                     goto Success;
                 }
                 lowestRcAddress = recordInfo.PreviousAddress;
@@ -347,14 +345,13 @@ internal void ReadCacheEvict(long rcLogicalAddress, long rcToLogicalAddress)
             }
         }
 
-        private long ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)
+        private void ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)
         {
             // Traverse the chain of readcache entries for this key, looking "ahead" to .PreviousAddress to see if it is less than readcache.HeadAddress.
             // nextPhysicalAddress remains Constants.kInvalidAddress if hei.Address is < HeadAddress; othrwise, it is the lowest-address readcache record
             // remaining following this eviction, and its .PreviousAddress is updated to each lower record in turn until we hit a non-readcache record.
             long nextPhysicalAddress = Constants.kInvalidAddress;
             HashBucketEntry entry = new() { word = hei.entry.word };
-            long lowestAddress = entry.Address;
             while (entry.ReadCache)
             {
                 var la = entry.AbsoluteAddress;
@@ -393,10 +390,8 @@ private long ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)
                     ri.PreviousAddress = Constants.kTempInvalidAddress;     // The record is no longer in the chain
                 else
                     hei.SetToCurrent();
-                lowestAddress = entry.Address;
                 entry.word = hei.entry.word;
             }
-            return lowestAddress;
         }
     }
 }
diff --git a/cs/src/core/Index/FASTER/Implementation/RecordSource.cs b/cs/src/core/Index/FASTER/Implementation/RecordSource.cs
@@ -30,7 +30,7 @@ internal struct RecordSource<Key, Value>
         internal long PhysicalAddress;
 
         /// <summary>
-        /// The highest logical address (in the main log, i.e. below readcache) for this key; if we have a readcache prefix chain, this is the splice point.
+        /// The highest logical address in the main log (i.e. below readcache) for this key; if we have a readcache prefix chain, this is the splice point.
         /// </summary>
         internal long LatestLogicalAddress;
 
diff --git a/cs/src/core/Index/Recovery/Recovery.cs b/cs/src/core/Index/Recovery/Recovery.cs
@@ -971,7 +971,6 @@ private unsafe bool RecoverFromPage(long startRecoveryAddress,
                     {
                         hei.entry.Address = pageLogicalAddress + pointer;
                         hei.entry.Tag = hei.tag;
-                        hei.entry.Pending = false;
                         hei.entry.Tentative = false;
                         hei.bucket->bucket_entries[hei.slot] = hei.entry.word;
                     }
@@ -983,7 +982,6 @@ private unsafe bool RecoverFromPage(long startRecoveryAddress,
                         {
                             hei.entry.Address = info.PreviousAddress;
                             hei.entry.Tag = hei.tag;
-                            hei.entry.Pending = false;
                             hei.entry.Tentative = false;
                             hei.bucket->bucket_entries[hei.slot] = hei.entry.word;
                         }
diff --git a/cs/test/BlittableLogScanTests.cs b/cs/test/BlittableLogScanTests.cs
@@ -4,7 +4,6 @@
 using System;
 using FASTER.core;
 using NUnit.Framework;
-using static FASTER.test.BlittableIterationTests;
 using static FASTER.test.TestUtils;
 
 namespace FASTER.test
@@ -20,7 +19,7 @@ internal class BlittableFASTERScanTests
         public void Setup()
         {
             DeleteDirectory(MethodTestDir, wait:true);
-            log = Devices.CreateLogDevice(MethodTestDir + "/BlittableFASTERScanTests.log", deleteOnClose: true);
+            log = Devices.CreateLogDevice(MethodTestDir + "/test.log", deleteOnClose: true);
             fht = new FasterKV<KeyStruct, ValueStruct>
                 (1L << 20, new LogSettings { LogDevice = log, MemorySizeBits = 15, PageSizeBits = 9 }, lockingMode: LockingMode.None);
         }
@@ -100,6 +99,52 @@ void scanAndVerify(ScanBufferingMode sbm)
             scanAndVerify(ScanBufferingMode.DoublePageBuffering);
         }
 
+        [Test]
+        [Category("FasterKV")]
+        [Category("Smoke")]
+
+        public void BlittableScanJumpToBeginAddressTest()
+        {
+            using var session = fht.For(new Functions()).NewSession<Functions>();
+
+            const int numRecords = 200;
+            const int numTailRecords = 10;
+            long shiftBeginAddressTo = 0;
+            int shiftToKey = 0;
+            for (int i = 0; i < numRecords; i++)
+            {
+                if (i == numRecords - numTailRecords)
+                {
+                    shiftBeginAddressTo = fht.Log.TailAddress;
+                    shiftToKey = i;
+                }
+                var key = new KeyStruct { kfield1 = i, kfield2 = i + 1 };
+                var value = new ValueStruct { vfield1 = i, vfield2 = i + 1 };
+                session.Upsert(ref key, ref value, Empty.Default, 0);
+            }
+
+            using var iter = fht.Log.Scan(fht.Log.HeadAddress, fht.Log.TailAddress);
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Assert.IsTrue(iter.GetNext(out var recordInfo));
+                Assert.AreEqual(i, iter.GetKey().kfield1);
+                Assert.AreEqual(i, iter.GetValue().vfield1);
+            }
+
+            fht.Log.ShiftBeginAddress(shiftBeginAddressTo);
+
+            for (int i = 0; i < numTailRecords; ++i)
+            { 
+                Assert.IsTrue(iter.GetNext(out var recordInfo));
+                if (i == 0)
+                    Assert.AreEqual(fht.Log.BeginAddress, iter.CurrentAddress);
+                var expectedKey = numRecords - numTailRecords + i;
+                Assert.AreEqual(expectedKey, iter.GetKey().kfield1);
+                Assert.AreEqual(expectedKey, iter.GetValue().vfield1);
+            }
+        }
+
         class LogObserver : IObserver<IFasterScanIterator<KeyStruct, ValueStruct>>
         {
             int val = 0;
diff --git a/cs/test/GenericLogScanTests.cs b/cs/test/GenericLogScanTests.cs
@@ -134,5 +134,58 @@ public void OnNext(IFasterScanIterator<MyKey, MyValue> iter)
                 }
             }
         }
+
+        [Test]
+        [Category("FasterKV")]
+        [Category("Smoke")]
+
+        public void BlittableScanJumpToBeginAddressTest()
+        {
+            log = Devices.CreateLogDevice($"{MethodTestDir}/test.log");
+            objlog = Devices.CreateLogDevice($"{MethodTestDir}/test.obj.log");
+            fht = new(128,
+                      logSettings: new LogSettings { LogDevice = log, ObjectLogDevice = objlog, MutableFraction = 0.1, MemorySizeBits = 20, PageSizeBits = 15, SegmentSizeBits = 18 },
+                      serializerSettings: new SerializerSettings<MyKey, MyValue> { keySerializer = () => new MyKeySerializer(), valueSerializer = () => new MyValueSerializer() },
+                      lockingMode: LockingMode.None);
+
+            using var session = fht.For(new MyFunctions()).NewSession<MyFunctions>();
+
+            const int numRecords = 200;
+            const int numTailRecords = 10;
+            long shiftBeginAddressTo = 0;
+            int shiftToKey = 0;
+            for (int i = 0; i < numRecords; i++)
+            {
+                if (i == numRecords - numTailRecords)
+                {
+                    shiftBeginAddressTo = fht.Log.TailAddress;
+                    shiftToKey = i;
+                }
+                var key = new MyKey { key = i };
+                var value = new MyValue { value = i };
+                session.Upsert(ref key, ref value, Empty.Default, 0);
+            }
+
+            using var iter = fht.Log.Scan(fht.Log.HeadAddress, fht.Log.TailAddress);
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Assert.IsTrue(iter.GetNext(out var recordInfo));
+                Assert.AreEqual(i, iter.GetKey().key);
+                Assert.AreEqual(i, iter.GetValue().value);
+            }
+
+            fht.Log.ShiftBeginAddress(shiftBeginAddressTo);
+
+            for (int i = 0; i < numTailRecords; ++i)
+            {
+                Assert.IsTrue(iter.GetNext(out var recordInfo));
+                if (i == 0)
+                    Assert.AreEqual(fht.Log.BeginAddress, iter.CurrentAddress);
+                var expectedKey = numRecords - numTailRecords + i;
+                Assert.AreEqual(expectedKey, iter.GetKey().key);
+                Assert.AreEqual(expectedKey, iter.GetValue().value);
+            }
+        }
     }
 }
diff --git a/cs/test/RecoverContinueTests.cs b/cs/test/RecoverContinueTests.cs
@@ -8,7 +8,7 @@
 using NUnit.Framework;
 using System.Threading.Tasks;
 
-namespace FASTER.test.recovery.sumstore.recover_continue
+namespace FASTER.test.recovery.sumstore.cntinue
 {
     [TestFixture]
     internal class RecoverContinueTests
@@ -24,7 +24,7 @@ internal class RecoverContinueTests
         public void Setup()
         {
             TestUtils.DeleteDirectory(TestUtils.MethodTestDir, wait: true);
-            log = Devices.CreateLogDevice(TestUtils.MethodTestDir + "/RecoverContinueTests.log", deleteOnClose: true);
+            log = Devices.CreateLogDevice(TestUtils.MethodTestDir + "/test.log", deleteOnClose: true);
             checkpointDir = TestUtils.MethodTestDir + "/checkpoints3";
             Directory.CreateDirectory(checkpointDir);
 
diff --git a/cs/test/SpanByteLogScanTests.cs b/cs/test/SpanByteLogScanTests.cs

Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,6 @@ internal bool TryCAS(long newLogicalAddress, ushort tag)`
`86`	`86`	`{`
`87`	`87`	`Tag = tag,`
`88`	`88`	`Address = newLogicalAddress & Constants.kAddressMask,`
`89`		`- Pending = this.entry.Pending,`
`90`	`89`	`Tentative = false`
`91`	`90`	`// .ReadCache is included in newLogicalAddress`
`92`	`91`	`};`
Original file line number	Diff line number	Diff line change
`@@ -127,32 +127,30 @@ private bool DetachAndReattachReadCacheChain(ref Key key, ref OperationStackCont`
`127`	`127`	`goto Success;`
`128`	`128`
`129`	`129`	`// Traverse from highestRcAddress to the splice point, invalidating any record matching the key.`
`130`		`- for (bool found = false; /* tested in loop /; / incremented in loop */)`
	`130`	`+ for (bool foundKey = false; /* tested in loop /; / incremented in loop */)`
`131`	`131`	`{`
`132`	`132`	`var physicalAddress = readcache.GetPhysicalAddress(AbsoluteAddress(lowestRcAddress));`
`133`	`133`	`ref RecordInfo recordInfo = ref readcache.GetInfo(physicalAddress);`
`134`		`- if (!found && !recordInfo.Invalid && comparer.Equals(ref key, ref readcache.GetKey(physicalAddress)))`
	`134`	`+ if (!foundKey && !recordInfo.Invalid && comparer.Equals(ref key, ref readcache.GetKey(physicalAddress)))`
`135`	`135`	`{`
`136`		`- found = true;`
	`136`	`+ foundKey = true;`
`137`	`137`	`recordInfo.SetInvalidAtomic(); // Atomic needed due to other threads (e.g. ReadCacheEvict) possibly being in this chain before we detached it.`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`// See if we're at the last entry in the readcache prefix.`
`141`	`141`	`if (!IsReadCache(recordInfo.PreviousAddress) \|\| AbsoluteAddress(recordInfo.PreviousAddress) < readcache.HeadAddress)`
`142`	`142`	`{`
`143`	`143`	`// Splice the new recordInfo into the local chain. Use atomic due to other threads (e.g. ReadCacheEvict) possibly being in this`
`144`		`- // before we detached it, and setting the record to Invalid (no other thread will be updating anything else in the chain, though).`
	`144`	`+ // before we detached it, and setting the record to Invalid (no other thread will be updating anything else in the chain, though;`
	`145`	`+ // we own the chain by virtue of the CAS above, and nobody else can change recordInfo.PreviousAddress).`
`145`	`146`	`while (!recordInfo.TryUpdateAddress(recordInfo.PreviousAddress, newLogicalAddress))`
`146`	`147`	`Thread.Yield();`
`147`	`148`
`148`		`- // Now try to CAS the chain into the HashBucketEntry. If it fails, give up; we lose those readcache records.`
`149`		`- // Trying to handle conflicts would require evaluating whether other threads had inserted keys in our chain, and it's too rare to worry about.`
`150`		`- if (stackCtx.hei.TryCAS(highestRcAddress))`
`151`		`- {`
`152`		`- // If we go below readcache.HeadAddress ReadCacheEvict may race past us, so make sure the lowest address is still in range.`
`153`		`- while (lowestRcAddress < readcache.HeadAddress)`
`154`		`- lowestRcAddress = ReadCacheEvictChain(readcache.HeadAddress, ref stackCtx.hei);`
`155`		`- }`
	`149`	`+ // Now try to CAS the chain into the HashBucketEntry. Ignore the result; if it fails, we just lose these readcache records.`
	`150`	`+ // Conflict handling would require evaluating whether other threads had inserted keys in our chain, and it's too rare to worry about.`
	`151`	`+ // We have ensured all records in this readcache prefix chain are >= readcache.HeadAddress, so even if readcache.HeadAddress changes,`
	`152`	`+ // ReadCacheEvict will not be called for any records in this readcache prefix chain until we return from here and release the epoch.`
	`153`	`+ stackCtx.hei.TryCAS(highestRcAddress);`
`156`	`154`	`goto Success;`
`157`	`155`	`}`
`158`	`156`	`lowestRcAddress = recordInfo.PreviousAddress;`
`@@ -347,14 +345,13 @@ internal void ReadCacheEvict(long rcLogicalAddress, long rcToLogicalAddress)`
`347`	`345`	`}`
`348`	`346`	`}`
`349`	`347`
`350`		`- private long ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)`
	`348`	`+ private void ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)`
`351`	`349`	`{`
`352`	`350`	`// Traverse the chain of readcache entries for this key, looking "ahead" to .PreviousAddress to see if it is less than readcache.HeadAddress.`
`353`	`351`	`// nextPhysicalAddress remains Constants.kInvalidAddress if hei.Address is < HeadAddress; othrwise, it is the lowest-address readcache record`
`354`	`352`	`// remaining following this eviction, and its .PreviousAddress is updated to each lower record in turn until we hit a non-readcache record.`
`355`	`353`	`long nextPhysicalAddress = Constants.kInvalidAddress;`
`356`	`354`	`HashBucketEntry entry = new() { word = hei.entry.word };`
`357`		`- long lowestAddress = entry.Address;`
`358`	`355`	`while (entry.ReadCache)`
`359`	`356`	`{`
`360`	`357`	`var la = entry.AbsoluteAddress;`
`@@ -393,10 +390,8 @@ private long ReadCacheEvictChain(long rcToLogicalAddress, ref HashEntryInfo hei)`
`393`	`390`	`ri.PreviousAddress = Constants.kTempInvalidAddress; // The record is no longer in the chain`
`394`	`391`	`else`
`395`	`392`	`hei.SetToCurrent();`
`396`		`- lowestAddress = entry.Address;`
`397`	`393`	`entry.word = hei.entry.word;`
`398`	`394`	`}`
`399`		`- return lowestAddress;`
`400`	`395`	`}`
`401`	`396`	`}`
`402`	`397`	`}`
Original file line number	Diff line number	Diff line change
`@@ -971,7 +971,6 @@ private unsafe bool RecoverFromPage(long startRecoveryAddress,`
`971`	`971`	`{`
`972`	`972`	`hei.entry.Address = pageLogicalAddress + pointer;`
`973`	`973`	`hei.entry.Tag = hei.tag;`
`974`		`- hei.entry.Pending = false;`
`975`	`974`	`hei.entry.Tentative = false;`
`976`	`975`	`hei.bucket->bucket_entries[hei.slot] = hei.entry.word;`
`977`	`976`	`}`
`@@ -983,7 +982,6 @@ private unsafe bool RecoverFromPage(long startRecoveryAddress,`
`983`	`982`	`{`
`984`	`983`	`hei.entry.Address = info.PreviousAddress;`
`985`	`984`	`hei.entry.Tag = hei.tag;`
`986`		`- hei.entry.Pending = false;`
`987`	`985`	`hei.entry.Tentative = false;`
`988`	`986`	`hei.bucket->bucket_entries[hei.slot] = hei.entry.word;`
`989`	`987`	`}`