You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by ir...@apache.org on 2019/08/30 17:25:10 UTC
[ignite] branch master updated: IGNITE-12042 Atempt to remove
entries from fully populated data region may result in
IgineOutOfMemoryException - Fixes #6745.
This is an automated email from the ASF dual-hosted git repository.
irakov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git
The following commit(s) were added to refs/heads/master by this push:
new 96dd04a IGNITE-12042 Atempt to remove entries from fully populated data region may result in IgineOutOfMemoryException - Fixes #6745.
96dd04a is described below
commit 96dd04a5834e8b0ef610fab8b18e287f09ceaa89
Author: Slava Koptilin <sl...@gmail.com>
AuthorDate: Fri Aug 30 20:24:50 2019 +0300
IGNITE-12042 Atempt to remove entries from fully populated data region may result in IgineOutOfMemoryException - Fixes #6745.
Signed-off-by: Ivan Rakov <ir...@apache.org>
---
.../cache/persistence/GridCacheOffheapManager.java | 1 -
.../IgniteCacheDatabaseSharedManager.java | 68 ++++++++-
.../processors/cache/persistence/RowStore.java | 9 +-
.../cache/persistence/freelist/CacheFreeList.java | 7 +-
.../processors/cache/tree/CacheDataRowStore.java | 4 -
.../cache/CacheIgniteOutOfMemoryExceptionTest.java | 156 +++++++++++++++++++++
.../IgniteDataStorageMetricsSelfTest.java | 5 +-
.../processors/database/CacheFreeListSelfTest.java | 1 -
.../testsuites/IgniteCacheMvccTestSuite6.java | 2 +
.../ignite/testsuites/IgniteCacheTestSuite6.java | 2 +
10 files changed, 241 insertions(+), 14 deletions(-)
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
index bbddc1c..be340c4 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheOffheapManager.java
@@ -1686,7 +1686,6 @@ public class GridCacheOffheapManager extends IgniteCacheOffheapManagerImpl imple
freeListName,
grp.dataRegion().memoryMetrics(),
grp.dataRegion(),
- null,
ctx.wal(),
reuseRoot.pageId().pageId(),
reuseRoot.isAllocated(),
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IgniteCacheDatabaseSharedManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IgniteCacheDatabaseSharedManager.java
index aad30fc..bc0a5ed 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IgniteCacheDatabaseSharedManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/IgniteCacheDatabaseSharedManager.java
@@ -37,11 +37,14 @@ import org.apache.ignite.configuration.DataPageEvictionMode;
import org.apache.ignite.configuration.DataRegionConfiguration;
import org.apache.ignite.configuration.DataStorageConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.failure.FailureContext;
+import org.apache.ignite.failure.FailureType;
import org.apache.ignite.internal.GridKernalContext;
import org.apache.ignite.internal.IgniteInternalFuture;
import org.apache.ignite.internal.managers.discovery.GridDiscoveryManager;
import org.apache.ignite.internal.mem.DirectMemoryProvider;
import org.apache.ignite.internal.mem.DirectMemoryRegion;
+import org.apache.ignite.internal.mem.IgniteOutOfMemoryException;
import org.apache.ignite.internal.mem.file.MappedFileMemoryProvider;
import org.apache.ignite.internal.mem.unsafe.UnsafeMemoryProvider;
import org.apache.ignite.internal.pagemem.PageMemory;
@@ -58,6 +61,7 @@ import org.apache.ignite.internal.processors.cache.persistence.evict.PageEvictio
import org.apache.ignite.internal.processors.cache.persistence.evict.Random2LruPageEvictionTracker;
import org.apache.ignite.internal.processors.cache.persistence.evict.RandomLruPageEvictionTracker;
import org.apache.ignite.internal.processors.cache.persistence.filename.PdsFolderSettings;
+import org.apache.ignite.internal.processors.cache.persistence.freelist.AbstractFreeList;
import org.apache.ignite.internal.processors.cache.persistence.freelist.CacheFreeList;
import org.apache.ignite.internal.processors.cache.persistence.freelist.FreeList;
import org.apache.ignite.internal.processors.cache.persistence.metastorage.MetaStorage;
@@ -259,7 +263,6 @@ public class IgniteCacheDatabaseSharedManager extends GridCacheSharedManagerAdap
freeListName,
memMetrics,
memPlc,
- null,
persistenceEnabled ? cctx.wal() : null,
0L,
true,
@@ -986,6 +989,69 @@ public class IgniteCacheDatabaseSharedManager extends GridCacheSharedManagerAdap
}
/**
+ * Checks that the given {@code region} has enough space for putting a new entry.
+ *
+ * This method makes sense then and only then
+ * the data region is not persisted {@link DataRegionConfiguration#isPersistenceEnabled()}
+ * and page eviction is disabled {@link DataPageEvictionMode#DISABLED}.
+ *
+ * The non-persistent region should reserve a number of pages to support a free list {@link AbstractFreeList}.
+ * For example, removing a row from underlying store may require allocating a new data page
+ * in order to move a tracked page from one bucket to another one which does not have a free space for a new stripe.
+ * See {@link AbstractFreeList#removeDataRowByLink}.
+ * Therefore, inserting a new entry should be prevented in case of some threshold is exceeded.
+ *
+ * @param region Data region to be checked.
+ * @param dataRowSize Size of data row to be inserted.
+ * @throws IgniteOutOfMemoryException In case of the given data region does not have enough free space
+ * for putting a new entry.
+ */
+ public void ensureFreeSpaceForInsert(DataRegion region, int dataRowSize) throws IgniteOutOfMemoryException {
+ if (region == null)
+ return;
+
+ DataRegionConfiguration regCfg = region.config();
+
+ if (regCfg.getPageEvictionMode() != DataPageEvictionMode.DISABLED || regCfg.isPersistenceEnabled())
+ return;
+
+ long memorySize = regCfg.getMaxSize();
+
+ PageMemory pageMem = region.pageMemory();
+
+ CacheFreeList freeList = freeListMap.get(regCfg.getName());
+
+ long nonEmptyPages = (pageMem.loadedPages() - freeList.emptyDataPages());
+
+ // The maximum number of pages that can be allocated (memorySize / systemPageSize)
+ // should be greater or equal to pages required for inserting a new entry plus
+ // the current number of non-empty pages plus the number of pages that may be required in order to move
+ // all pages to a reuse bucket, that is equal to nonEmptyPages * 8 / pageSize, where 8 is the size of a link.
+ // Note that not the whole page can be used to storing links,
+ // see PagesListNodeIO and PagesListMetaIO#getCapacity(), so we pessimistically multiply the result on 1.5,
+ // in any way, the number of required pages is less than 1 percent.
+ boolean oomThreshold = (memorySize / pageMem.systemPageSize()) <
+ ((double)dataRowSize / pageMem.pageSize() + nonEmptyPages * (8.0 * 1.5 / pageMem.pageSize() + 1) + 256 /*one page per bucket*/);
+
+ if (oomThreshold) {
+ IgniteOutOfMemoryException oom = new IgniteOutOfMemoryException("Out of memory in data region [" +
+ "name=" + regCfg.getName() +
+ ", initSize=" + U.readableSize(regCfg.getInitialSize(), false) +
+ ", maxSize=" + U.readableSize(regCfg.getMaxSize(), false) +
+ ", persistenceEnabled=" + regCfg.isPersistenceEnabled() + "] Try the following:" + U.nl() +
+ " ^-- Increase maximum off-heap memory size (DataRegionConfiguration.maxSize)" + U.nl() +
+ " ^-- Enable Ignite persistence (DataRegionConfiguration.persistenceEnabled)" + U.nl() +
+ " ^-- Enable eviction or expiration policies"
+ );
+
+ if (cctx.kernalContext() != null)
+ cctx.kernalContext().failure().process(new FailureContext(FailureType.CRITICAL_ERROR, oom));
+
+ throw oom;
+ }
+ }
+
+ /**
* See {@link GridCacheMapEntry#ensureFreeSpace()}
*
* @param memPlc data region.
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/RowStore.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/RowStore.java
index 8601d98..d1386e7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/RowStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/RowStore.java
@@ -52,6 +52,9 @@ public class RowStore {
/** Row cache cleaner. */
private GridQueryRowCacheCleaner rowCacheCleaner;
+ /** */
+ protected final CacheGroupContext grp;
+
/**
* @param grp Cache group.
* @param freeList Free list.
@@ -60,6 +63,7 @@ public class RowStore {
assert grp != null;
assert freeList != null;
+ this.grp = grp;
this.freeList = freeList;
ctx = grp.shared();
@@ -98,8 +102,11 @@ public class RowStore {
* @throws IgniteCheckedException If failed.
*/
public void addRow(CacheDataRow row, IoStatisticsHolder statHolder) throws IgniteCheckedException {
- if (!persistenceEnabled)
+ if (!persistenceEnabled) {
+ ctx.database().ensureFreeSpaceForInsert(grp.dataRegion(), row.size());
+
freeList.insertDataRow(row, statHolder);
+ }
else {
ctx.database().checkpointReadLock();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/freelist/CacheFreeList.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/freelist/CacheFreeList.java
index ec63f21..45e0c48 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/freelist/CacheFreeList.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/freelist/CacheFreeList.java
@@ -18,14 +18,13 @@
package org.apache.ignite.internal.processors.cache.persistence.freelist;
import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.internal.metric.IoStatisticsHolder;
import org.apache.ignite.internal.pagemem.PageIdUtils;
import org.apache.ignite.internal.pagemem.wal.IgniteWriteAheadLogManager;
import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow;
import org.apache.ignite.internal.processors.cache.persistence.DataRegion;
import org.apache.ignite.internal.processors.cache.persistence.DataRegionMetricsImpl;
-import org.apache.ignite.internal.processors.cache.persistence.tree.reuse.ReuseList;
import org.apache.ignite.internal.processors.cache.persistence.tree.util.PageLockListener;
-import org.apache.ignite.internal.metric.IoStatisticsHolder;
import org.apache.ignite.internal.util.typedef.internal.U;
/**
@@ -37,7 +36,6 @@ public class CacheFreeList extends AbstractFreeList<CacheDataRow> {
* @param name Name.
* @param regionMetrics Region metrics.
* @param dataRegion Data region.
- * @param reuseList Reuse list.
* @param wal Wal.
* @param metaPageId Meta page id.
* @param initNew Initialize new.
@@ -47,7 +45,6 @@ public class CacheFreeList extends AbstractFreeList<CacheDataRow> {
String name,
DataRegionMetricsImpl regionMetrics,
DataRegion dataRegion,
- ReuseList reuseList,
IgniteWriteAheadLogManager wal,
long metaPageId,
boolean initNew,
@@ -58,7 +55,7 @@ public class CacheFreeList extends AbstractFreeList<CacheDataRow> {
name,
regionMetrics,
dataRegion,
- reuseList,
+ null,
wal,
metaPageId,
initNew,
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataRowStore.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataRowStore.java
index 197a685..1032801 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataRowStore.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/tree/CacheDataRowStore.java
@@ -50,9 +50,6 @@ public class CacheDataRowStore extends RowStore {
/** */
private final int partId;
- /** */
- private final CacheGroupContext grp;
-
/**
* @param grp Cache group.
* @param freeList Free list.
@@ -62,7 +59,6 @@ public class CacheDataRowStore extends RowStore {
super(grp, freeList);
this.partId = partId;
- this.grp = grp;
}
/**
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheIgniteOutOfMemoryExceptionTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheIgniteOutOfMemoryExceptionTest.java
new file mode 100644
index 0000000..b8cd9db
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/CacheIgniteOutOfMemoryExceptionTest.java
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.processors.cache;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.cache.CacheAtomicityMode;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.DataRegionConfiguration;
+import org.apache.ignite.configuration.DataStorageConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.failure.AbstractFailureHandler;
+import org.apache.ignite.failure.FailureContext;
+import org.apache.ignite.internal.mem.IgniteOutOfMemoryException;
+import org.apache.ignite.internal.util.typedef.X;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.junit.Test;
+
+import static org.apache.ignite.cache.CacheAtomicityMode.ATOMIC;
+import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL;
+import static org.apache.ignite.configuration.DataPageEvictionMode.DISABLED;
+
+/**
+ * Tests behavior of IgniteCache when {@link IgniteOutOfMemoryException} is thrown.
+ */
+public class CacheIgniteOutOfMemoryExceptionTest extends GridCommonAbstractTest {
+ /** */
+ private static final long DATA_REGION_SIZE = 10L * 1024 * 1024;
+
+ /** */
+ private static final int ATTEMPTS_NUM = 3;
+
+ /** Node failure occurs. */
+ private static final AtomicBoolean failure = new AtomicBoolean(false);
+
+ /** {@inheritDoc} */
+ @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+ IgniteConfiguration cfg = super.getConfiguration(gridName);
+
+ cfg.setDataStorageConfiguration(new DataStorageConfiguration()
+ .setDefaultDataRegionConfiguration(
+ new DataRegionConfiguration()
+ .setMaxSize(DATA_REGION_SIZE)
+ .setPageEvictionMode(DISABLED)
+ .setPersistenceEnabled(false)));
+
+ cfg.setFailureHandler(new AbstractFailureHandler() {
+ /** {@inheritDoc} */
+ @Override protected boolean handle(Ignite ignite, FailureContext failureCtx) {
+ failure.set(true);
+
+ // Do not invalidate a node context.
+ return false;
+ }
+ });
+
+ cfg.setCacheConfiguration(cacheConfiguration(ATOMIC), cacheConfiguration(TRANSACTIONAL));
+
+ return cfg;
+ }
+
+ /**
+ * Creates a new cache configuration with the given cache atomicity mode.
+ *
+ * @param mode Cache atomicity mode.
+ * @return Cache configuration.
+ */
+ private CacheConfiguration cacheConfiguration(CacheAtomicityMode mode) {
+ return new CacheConfiguration(mode.name())
+ .setAtomicityMode(mode)
+ .setAffinity(new RendezvousAffinityFunction(false, 32));
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTestsStarted() throws Exception {
+ startGrid(0);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTestsStopped() throws Exception {
+ stopAllGrids();
+ }
+
+ /**
+ * @throws Exception If failed.
+ */
+ @Test
+ public void testLoadAndClearAtomicCache() throws Exception {
+ loadAndClearCache(ATOMIC, ATTEMPTS_NUM);
+ }
+
+ /**
+ * @throws Exception If failed.
+ */
+ @Test
+ public void testLoadAndClearTransactionalCache() throws Exception {
+ loadAndClearCache(TRANSACTIONAL, ATTEMPTS_NUM);
+ }
+
+ /**
+ * Creates a new cache with the given atomicity node and tries to load & clear it in a loop.
+ * It is assumed that {@link IgniteOutOfMemoryException} is thrown during loading the cache,
+ * however {@link IgniteCache#clear()} should return the cache to the operable state.
+ *
+ * @param mode Cache atomicity mode.
+ * @param attempts Number of attempts to load and clear the cache.
+ */
+ private void loadAndClearCache(CacheAtomicityMode mode, int attempts) {
+ IgniteCache<Object, Object> cache = grid(0).cache(mode.name());
+
+ for (int i = 0; i < attempts; ++i) {
+ try {
+ for (int key = 0; key < 500_000; ++key)
+ cache.put(key, new byte[4000]);
+
+ fail("OutOfMemoryException hasn't been thrown");
+ }
+ catch (Exception e) {
+ assertTrue(
+ "Exception has been thrown, but the exception type is unexpected [exc=" + e + ']',
+ X.hasCause(e, IgniteOutOfMemoryException.class));
+
+ assertTrue("Failure handler should be called due to IOOM.", failure.get());
+ }
+
+ // Let's check that the cache can be cleared without any errors.
+ failure.set(false);
+
+ try {
+ cache.clear();
+ }
+ catch (Exception e) {
+ fail("Clearing the cache should not trigger any exception [exc=" + e +']');
+ }
+
+ assertFalse("Failure handler should not be called during clearing the cache.", failure.get());
+ }
+ }
+}
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
index 17fa384..8583395 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgniteDataStorageMetricsSelfTest.java
@@ -24,6 +24,7 @@ import org.apache.ignite.DataStorageMetrics;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.cache.CacheAtomicityMode;
import org.apache.ignite.cache.CacheMode;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
import org.apache.ignite.cache.query.annotations.QuerySqlField;
import org.apache.ignite.configuration.BinaryConfiguration;
import org.apache.ignite.configuration.CacheConfiguration;
@@ -91,7 +92,8 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
cfg.setBinaryConfiguration(new BinaryConfiguration().setCompactFooter(false));
- cfg.setCacheConfiguration(cacheConfiguration(GROUP1, "cache", PARTITIONED, ATOMIC, 1, null),
+ cfg.setCacheConfiguration(
+ cacheConfiguration(GROUP1, "cache", PARTITIONED, ATOMIC, 1, null),
cacheConfiguration(null, "cache-np", PARTITIONED, ATOMIC, 1, NO_PERSISTENCE));
return cfg;
@@ -131,6 +133,7 @@ public class IgniteDataStorageMetricsSelfTest extends GridCommonAbstractTest {
ccfg.setCacheMode(cacheMode);
ccfg.setWriteSynchronizationMode(FULL_SYNC);
ccfg.setDataRegionName(dataRegName);
+ ccfg.setAffinity(new RendezvousAffinityFunction(false, 32));
if (NO_PERSISTENCE.equals(dataRegName))
ccfg.setDiskPageCompression(null);
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/CacheFreeListSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/CacheFreeListSelfTest.java
index eae81c7..b9957e1 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/database/CacheFreeListSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/database/CacheFreeListSelfTest.java
@@ -526,7 +526,6 @@ public class CacheFreeListSelfTest extends GridCommonAbstractTest {
regionMetrics,
dataRegion,
null,
- null,
metaPageId,
true,
null
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheMvccTestSuite6.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheMvccTestSuite6.java
index e766e8b..7c30da0 100644
--- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheMvccTestSuite6.java
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheMvccTestSuite6.java
@@ -22,6 +22,7 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.ignite.IgniteSystemProperties;
+import org.apache.ignite.internal.processors.cache.CacheIgniteOutOfMemoryExceptionTest;
import org.apache.ignite.internal.processors.cache.PartitionedAtomicCacheGetsDistributionTest;
import org.apache.ignite.internal.processors.cache.PartitionedMvccTxPessimisticCacheGetsDistributionTest;
import org.apache.ignite.internal.processors.cache.PartitionedTransactionalOptimisticCacheGetsDistributionTest;
@@ -83,6 +84,7 @@ public class IgniteCacheMvccTestSuite6 {
ignoredTests.add(PartitionsExchangeCoordinatorFailoverTest.class);
ignoredTests.add(CacheParallelStartTest.class);
ignoredTests.add(IgniteCache150ClientsTest.class);
+ ignoredTests.add(CacheIgniteOutOfMemoryExceptionTest.class);
// Mixed local/dht tx test.
ignoredTests.add(TxLocalDhtMixedCacheModesTest.class);
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite6.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite6.java
index f2e7806..ac462f6 100644
--- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite6.java
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite6.java
@@ -20,6 +20,7 @@ package org.apache.ignite.testsuites;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import org.apache.ignite.internal.processors.cache.CacheIgniteOutOfMemoryExceptionTest;
import org.apache.ignite.internal.processors.cache.CacheNoAffinityExchangeTest;
import org.apache.ignite.internal.processors.cache.ClientFastReplyCoordinatorFailureTest;
import org.apache.ignite.internal.processors.cache.PartitionedAtomicCacheGetsDistributionTest;
@@ -111,6 +112,7 @@ public class IgniteCacheTestSuite6 {
// TODO enable this test after IGNITE-6753, now it takes too long
// GridTestUtils.addTestIfNeeded(suite, IgniteOutOfMemoryPropagationTest.class, ignoredTests);
+ GridTestUtils.addTestIfNeeded(suite, CacheIgniteOutOfMemoryExceptionTest.class, ignoredTests);
GridTestUtils.addTestIfNeeded(suite, ReplicatedAtomicCacheGetsDistributionTest.class, ignoredTests);
GridTestUtils.addTestIfNeeded(suite, ReplicatedTransactionalOptimisticCacheGetsDistributionTest.class, ignoredTests);