IGNITE-24992 Fix hang in put with RANDOM_LRU and RANDOM_2_LRU eviction policy - Fixes #12026.

Signed-off-by: Aleksey Plekhanov <[email protected]>

Author: skorotkov

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/FairFifoPageEvictionTracker.java

@@ -73,4 +73,14 @@ public FairFifoPageEvictionTracker(
     @Override protected synchronized boolean checkTouch(long pageId) {
         return true;
     }
+
+    /** {@inheritDoc} */
+    @Override protected void linkFragmentPages(int pageTrackingIdx, int nextPageTrackingIdx) {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override protected int getFragmentLink(int pageTrackingIdx) {
+        return 0;
+    }
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/NoOpPageEvictionTracker.java

@@ -52,4 +52,9 @@ public class NoOpPageEvictionTracker implements PageEvictionTracker {
     @Override public boolean evictionRequired() {
         return false;
     }
+
+    /** {@inheritDoc} */
+    @Override public void trackFragmentPage(long pageId, long prevPageId, boolean isHeadPage) throws IgniteCheckedException {
+        // No-op.
+    }
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/PageAbstractEvictionTracker.java

@@ -183,4 +183,55 @@ int trackingIdx(int pageIdx) {
     int pageIdx(int trackingIdx) {
         return pageMem.pageIndex(trackingIdx);
     }
+
+    /** {@inheritDoc} */
+    @Override public void trackFragmentPage(long pageId, long prevPageId, boolean isHeadPage) throws IgniteCheckedException {
+        // Do nothing if called for tail page.
+        if (prevPageId == 0)
+            return;
+
+        if (isHeadPage) {
+            // Store link to head fragment page in tail fragment page.
+            linkFragmentPages(tailPageTrackingIdx(prevPageId), trackingIdx(PageIdUtils.pageIndex(pageId)));
+        }
+        else {
+            // Store link to tail fragment page in each fragment page.
+            linkFragmentPages(trackingIdx(PageIdUtils.pageIndex(pageId)), tailPageTrackingIdx(prevPageId));
+        }
+    }
+
+    /**
+     * Determine tail page tracking index given page id of previously written fragment.
+     *
+     * @param prevPageId Page id of previously written fragment.
+     * @return tail page tracking index.
+     */
+    private int tailPageTrackingIdx(long prevPageId) {
+        int prevPageTrackingIdx = trackingIdx(PageIdUtils.pageIndex(prevPageId));
+
+        int link = getFragmentLink(prevPageTrackingIdx);
+
+        if (link == 0) {
+            // The previous page is just the tail one.
+            return prevPageTrackingIdx;
+        }
+        else
+            return link;
+    }
+
+    /**
+     * Link two pages containing fragments of row.
+     *
+     * @param pageTrackingIdx     Page tracking index.
+     * @param nextPageTrackingIdx Tracking index of page to link to.
+     */
+    protected abstract void linkFragmentPages(int pageTrackingIdx, int nextPageTrackingIdx);
+
+    /**
+     * Get tracking index of page linked to this one.
+     *
+     * @param pageTrackingIdx Page tracking index.
+     * @return Tracking index of linked page, or {@code 0} if this page is not linked to any.
+     */
+    protected abstract int getFragmentLink(int pageTrackingIdx);
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/PageEvictionTracker.java

@@ -56,4 +56,14 @@ public interface PageEvictionTracker extends LifecycleAware {
      * @throws IgniteCheckedException In case of page memory error.
      */
     public void forgetPage(long pageId) throws IgniteCheckedException;
+
+    /**
+     * Call this method when data page containing fragment of row is written.
+     *
+     * @param pageId     Page id.
+     * @param prevPageId Page id of previous fragment.  0 if called for the tail fragment (written first).
+     * @param isHeadPage True if head fragment (written last) of row is written, False otherwise.
+     * @throws IgniteCheckedException In case of page memory error.
+     */
+    public void trackFragmentPage(long pageId, long prevPageId, boolean isHeadPage) throws IgniteCheckedException;
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/Random2LruPageEvictionTracker.java

@@ -92,16 +92,22 @@ public Random2LruPageEvictionTracker(
         do {
             int trackingIdx = trackingIdx(pageIdx);
 
-            int firstTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 8L);
+            long trackingData = GridUnsafe.getLongVolatile(null, trackingArrPtr + trackingIdx * 8L);
 
-            int secondTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 8L + 4);
+            int firstTs = first(trackingData);
+
+            assert firstTs >= 0 : "[firstTs=" + firstTs + ", trackingData=" + trackingData + "]";
+
+            int secondTs = second(trackingData);
+
+            long newTrackingData;
 
             if (firstTs <= secondTs)
-                success = GridUnsafe.compareAndSwapInt(null, trackingArrPtr + trackingIdx * 8L, firstTs, (int)latestTs);
-            else {
-                success = GridUnsafe.compareAndSwapInt(
-                    null, trackingArrPtr + trackingIdx * 8L + 4, secondTs, (int)latestTs);
-            }
+                newTrackingData = U.toLong((int)latestTs, secondTs);
+            else
+                newTrackingData = U.toLong(firstTs, (int)latestTs);
+
+            success = GridUnsafe.compareAndSwapLong(null, trackingArrPtr + trackingIdx * 8L, trackingData, newTrackingData);
         } while (!success);
     }
 
@@ -123,9 +129,32 @@ public Random2LruPageEvictionTracker(
             while (dataPagesCnt < SAMPLE_SIZE) {
                 int trackingIdx = rnd.nextInt(trackingSize);
 
-                int firstTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 8L);
+                long trackingData = GridUnsafe.getLongVolatile(null, trackingArrPtr + trackingIdx * 8L);
+
+                int firstTs = first(trackingData);
+
+                if (firstTs < 0) {
+                    // For page containing fragmented row data timestamps stored in the row's head page are used.
+                    // Fragment page (other than the tail one) contains link to tail page. Tail page contains link to
+                    // head page. So head page is found no more than in two hops.
+                    trackingIdx = -firstTs;
+
+                    trackingData = GridUnsafe.getLongVolatile(null, trackingArrPtr + trackingIdx * 8L);
 
-                int secondTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 8L + 4);
+                    firstTs = first(trackingData);
+
+                    if (firstTs < 0) {
+                        trackingIdx = -firstTs;
+
+                        trackingData = GridUnsafe.getLongVolatile(null, trackingArrPtr + trackingIdx * 8L);
+
+                        firstTs = first(trackingData);
+
+                        assert firstTs >= 0 : "[firstTs=" + firstTs + ", secondTs=" + second(trackingData) + "]";
+                    }
+                }
+
+                int secondTs = second(trackingData);
 
                 int minTs = Math.min(firstTs, secondTs);
 
@@ -164,9 +193,9 @@ public Random2LruPageEvictionTracker(
     @Override protected boolean checkTouch(long pageId) {
         int trackingIdx = trackingIdx(PageIdUtils.pageIndex(pageId));
 
-        int firstTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 8L);
+        int firstTs = first(GridUnsafe.getLongVolatile(null, trackingArrPtr + trackingIdx * 8L));
 
-        return firstTs != 0;
+        return firstTs > 0;
     }
 
     /** {@inheritDoc} */
@@ -177,4 +206,41 @@ public Random2LruPageEvictionTracker(
 
         GridUnsafe.putLongVolatile(null, trackingArrPtr + trackingIdx * 8L, 0L);
     }
+
+    /**
+     * Link two pages containing fragments of row.
+     * <p>
+     * Link is stored as a negated page tracking index in the first integer in the tracking data.
+     * Second integer in the tracking data is set to 0.
+     *
+     * @param pageTrackingIdx     Page tracking index.
+     * @param nextPageTrackingIdx Tracking index of page to link to.
+     */
+    @Override protected void linkFragmentPages(int pageTrackingIdx, int nextPageTrackingIdx) {
+        GridUnsafe.putLongVolatile(null, trackingArrPtr + pageTrackingIdx * 8L,
+            U.toLong(-nextPageTrackingIdx, 0));
+    }
+
+    /** {@inheritDoc} */
+    @Override protected int getFragmentLink(int pageTrackingIdx) {
+        int link = first(GridUnsafe.getLongVolatile(null, trackingArrPtr + pageTrackingIdx * 8L));
+
+        assert link <= 0 : "[link=" + link + "]";
+
+        return -link;
+    }
+
+    /**
+     * Helper to extract first integer value.
+     */
+    private int first(long l) {
+        return (int)(l >> Integer.SIZE);
+    }
+
+    /**
+     * Helper to extract second integer value.
+     */
+    private int second(long l) {
+        return (int)l;
+    }
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/evict/RandomLruPageEvictionTracker.java

@@ -112,6 +112,23 @@ public RandomLruPageEvictionTracker(
 
                 int compactTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + sampleTrackingIdx * 4L);
 
+                if (compactTs < 0) {
+                    // For page containing fragmented row data timestamps stored in the row's head page are used.
+                    // Fragment page (other than the tail one) contains link to tail page. Tail page contains link to
+                    // head page. So head page is found no more than in two hops.
+                    sampleTrackingIdx = -compactTs;
+
+                    compactTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + sampleTrackingIdx * 4L);
+
+                    if (compactTs < 0) {
+                        sampleTrackingIdx = -compactTs;
+
+                        compactTs = GridUnsafe.getIntVolatile(null, trackingArrPtr + sampleTrackingIdx * 4L);
+
+                        assert compactTs >= 0 : "[compactTs=" + compactTs + "]";
+                    }
+                }
+
                 if (compactTs != 0) {
                     // We chose data page with at least one touch.
                     if (compactTs < lruCompactTs) {
@@ -147,7 +164,7 @@ public RandomLruPageEvictionTracker(
 
         int ts = GridUnsafe.getIntVolatile(null, trackingArrPtr + trackingIdx * 4L);
 
-        return ts != 0;
+        return ts > 0;
     }
 
     /** {@inheritDoc} */
@@ -156,4 +173,25 @@ public RandomLruPageEvictionTracker(
 
         GridUnsafe.putIntVolatile(null, trackingArrPtr + trackingIdx(pageIdx) * 4L, 0);
     }
+
+    /**
+     * Link two pages containing fragments of row.
+     * <p>
+     * Link is stored as a negated page tracking index.
+     *
+     * @param pageTrackingIdx     Page tracking index.
+     * @param nextPageTrackingIdx Tracking index of page to link to.
+     */
+    @Override protected void linkFragmentPages(int pageTrackingIdx, int nextPageTrackingIdx) {
+        GridUnsafe.putIntVolatile(null, trackingArrPtr + pageTrackingIdx * 4L, -nextPageTrackingIdx);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected int getFragmentLink(int pageTrackingIdx) {
+        int link = GridUnsafe.getIntVolatile(null, trackingArrPtr + pageTrackingIdx * 4L);
+
+        assert link <= 0 : "[link=" + link + "]";
+
+        return -link;
+    }
 }

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/freelist/AbstractFreeList.java

@@ -193,6 +193,8 @@ protected Integer addRow(
             throws IgniteCheckedException {
             AbstractDataPageIO<T> io = (AbstractDataPageIO<T>)iox;
 
+            long lastLink = row.link();
+
             int rowSize = row.size();
             int oldFreeSpace = io.getFreeSpace(pageAddr);
 
@@ -205,6 +207,8 @@ protected Integer addRow(
             if (written == rowSize)
                 evictionTracker.touchPage(pageId);
 
+            evictionTracker.trackFragmentPage(pageId, lastLink, written == rowSize);
+
             // Avoid boxing with garbage generation for usual case.
             return written == rowSize ? COMPLETE : written;
         }
@@ -340,8 +344,6 @@ private final class WriteRowsHandler extends PageHandler<GridCursor<T>, Integer>
                 written = writeRowHnd.addRow(pageId, page, pageAddr, io, row, written);
 
                 assert written == COMPLETE;
-
-                evictionTracker.touchPage(pageId);
             }
 
             writeRowHnd.putPage(io.getFreeSpace(pageAddr), pageId, page, pageAddr, statHolder);

modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/paged/PageEvictionDataStreamerTest.java renamed to modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/paged/PageEvictionDataStreamerAbstractTest.java

@@ -21,18 +21,11 @@
 import org.apache.ignite.IgniteDataStreamer;
 import org.apache.ignite.cache.CachePeekMode;
 import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.configuration.DataPageEvictionMode;
-import org.apache.ignite.configuration.IgniteConfiguration;
 
 /**
  *
  */
-public class PageEvictionDataStreamerTest extends PageEvictionMultinodeAbstractTest {
-    /** {@inheritDoc} */
-    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
-        return setEvictionMode(DataPageEvictionMode.RANDOM_LRU, super.getConfiguration(gridName));
-    }
-
+public abstract class PageEvictionDataStreamerAbstractTest extends PageEvictionMultinodeAbstractTest {
     /** {@inheritDoc} */
     @Override protected void createCacheAndTestEviction(CacheConfiguration<Object, Object> cfg) throws Exception {
         IgniteCache<Object, Object> cache = clientGrid().getOrCreateCache(cfg);

modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/paged/PageEvictionMultinodeAbstractTest.java

@@ -110,7 +110,7 @@ else if (r.nextInt() % 13 == 0)
         System.out.println(">>> Resulting size: " + resultingSize);
 
         // Eviction started, no OutOfMemory occurred, success.
-        assertTrue(resultingSize < ENTRIES * 10 / 11);
+        assertTrue(resultingSize < ENTRIES * 71 / 77);
 
         clientGrid().destroyCache(cfg.getName());
     }

modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/paged/PageEvictionMultinodeMixedRegionsTest.java renamed to modules/core/src/test/java/org/apache/ignite/internal/processors/cache/eviction/paged/PageEvictionMultinodeMixedRegionsAbstractTest.java

@@ -18,20 +18,17 @@
 package org.apache.ignite.internal.processors.cache.eviction.paged;
 
 import org.apache.ignite.cluster.ClusterState;
-import org.apache.ignite.configuration.DataPageEvictionMode;
 import org.apache.ignite.configuration.DataRegionConfiguration;
 import org.apache.ignite.configuration.IgniteConfiguration;
 
 /**
  * Enables but not touches persistent region, checks page eviction and PDS+no PDS mode.
  */
-public class PageEvictionMultinodeMixedRegionsTest extends PageEvictionMultinodeAbstractTest {
+public abstract class PageEvictionMultinodeMixedRegionsAbstractTest extends PageEvictionMultinodeAbstractTest {
     /** {@inheritDoc} */
     @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
         IgniteConfiguration cfg = super.getConfiguration(gridName);
 
-        setEvictionMode(DataPageEvictionMode.RANDOM_2_LRU, cfg);
-
         DataRegionConfiguration persReg = new DataRegionConfiguration()
             .setName("persisted")
             .setPersistenceEnabled(true)