ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vkuliche...@apache.org
Subject [06/12] incubator-ignite git commit: IGNITE-575 - Renaimings
Date Wed, 25 Mar 2015 06:39:01 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/CacheFifoEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/CacheFifoEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/CacheFifoEvictionPolicyMBean.java
deleted file mode 100644
index 0ecace5..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/CacheFifoEvictionPolicyMBean.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * 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.cache.eviction.fifo;
-
-import org.apache.ignite.mxbean.*;
-
-/**
- * MBean for {@code FIFO} eviction policy.
- */
-@MXBeanDescription("MBean for FIFO cache eviction policy.")
-public interface CacheFifoEvictionPolicyMBean {
-    /**
-     * Gets maximum allowed cache size.
-     *
-     * @return Maximum allowed cache size.
-     */
-    @MXBeanDescription("Maximum allowed cache size.")
-    public int getMaxSize();
-
-    /**
-     * Sets maximum allowed cache size.
-     *
-     * @param max Maximum allowed cache size.
-     */
-    @MXBeanDescription("Set maximum allowed cache size.")
-    public void setMaxSize(int max);
-
-    /**
-     * Gets current queue size.
-     *
-     * @return Current queue size.
-     */
-    @MXBeanDescription("Current FIFO queue size.")
-    public int getCurrentSize();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicy.java
new file mode 100644
index 0000000..d32c746
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicy.java
@@ -0,0 +1,191 @@
+/*
+ * 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.cache.eviction.fifo;
+
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.jsr166.*;
+import org.jsr166.ConcurrentLinkedDeque8.*;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Eviction policy based on {@code First In First Out (FIFO)} algorithm. This
+ * implementation is very efficient since it does not create any additional
+ * table-like data structures. The {@code FIFO} ordering information is
+ * maintained by attaching ordering metadata to cache entries.
+ */
+public class FifoEvictionPolicy<K, V> implements EvictionPolicy<K, V>, FifoEvictionPolicyMBean, Externalizable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Maximum size. */
+    private volatile int max = CacheConfiguration.DFLT_CACHE_SIZE;
+
+    /** FIFO queue. */
+    private final ConcurrentLinkedDeque8<EvictableEntry<K, V>> queue =
+        new ConcurrentLinkedDeque8<>();
+
+    /**
+     * Constructs FIFO eviction policy with all defaults.
+     */
+    public FifoEvictionPolicy() {
+        // No-op.
+    }
+
+    /**
+     * Constructs FIFO eviction policy with maximum size. Empty entries are allowed.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    public FifoEvictionPolicy(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /**
+     * Gets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @return Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public int getMaxSize() {
+        return max;
+    }
+
+    /**
+     * Sets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public void setMaxSize(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getCurrentSize() {
+        return queue.size();
+    }
+
+    /**
+     * Gets read-only view on internal {@code FIFO} queue in proper order.
+     *
+     * @return Read-only view ono internal {@code 'FIFO'} queue.
+     */
+    public Collection<EvictableEntry<K, V>> queue() {
+        return Collections.unmodifiableCollection(queue);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void onEntryAccessed(boolean rmv, EvictableEntry<K, V> entry) {
+        if (!rmv) {
+            if (!entry.isCached())
+                return;
+
+            // Shrink only if queue was changed.
+            if (touch(entry))
+                shrink();
+        }
+        else {
+            Node<EvictableEntry<K, V>> node = entry.removeMeta();
+
+            if (node != null)
+                queue.unlinkx(node);
+        }
+    }
+
+    /**
+     * @param entry Entry to touch.
+     * @return {@code True} if queue has been changed by this call.
+     */
+    private boolean touch(EvictableEntry<K, V> entry) {
+        Node<EvictableEntry<K, V>> node = entry.meta();
+
+        // Entry has not been enqueued yet.
+        if (node == null) {
+            while (true) {
+                node = queue.offerLastx(entry);
+
+                if (entry.putMetaIfAbsent(node) != null) {
+                    // Was concurrently added, need to clear it from queue.
+                    queue.unlinkx(node);
+
+                    // Queue has not been changed.
+                    return false;
+                }
+                else if (node.item() != null) {
+                    if (!entry.isCached()) {
+                        // Was concurrently evicted, need to clear it from queue.
+                        queue.unlinkx(node);
+
+                        return false;
+                    }
+
+                    return true;
+                }
+                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
+                else if (!entry.removeMeta(node))
+                    return false;
+            }
+        }
+
+        // Entry is already in queue.
+        return false;
+    }
+
+    /**
+     * Shrinks FIFO queue to maximum allowed size.
+     */
+    private void shrink() {
+        int max = this.max;
+
+        int startSize = queue.sizex();
+
+        for (int i = 0; i < startSize && queue.sizex() > max; i++) {
+            EvictableEntry<K, V> entry = queue.poll();
+
+            if (entry == null)
+                break;
+
+            if (!entry.evict()) {
+                entry.removeMeta();
+
+                touch(entry);
+            }
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeInt(max);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        max = in.readInt();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(FifoEvictionPolicy.class, this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicyMBean.java
new file mode 100644
index 0000000..4827e95
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/fifo/FifoEvictionPolicyMBean.java
@@ -0,0 +1,50 @@
+/*
+ * 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.cache.eviction.fifo;
+
+import org.apache.ignite.mxbean.*;
+
+/**
+ * MBean for {@code FIFO} eviction policy.
+ */
+@MXBeanDescription("MBean for FIFO cache eviction policy.")
+public interface FifoEvictionPolicyMBean {
+    /**
+     * Gets maximum allowed cache size.
+     *
+     * @return Maximum allowed cache size.
+     */
+    @MXBeanDescription("Maximum allowed cache size.")
+    public int getMaxSize();
+
+    /**
+     * Sets maximum allowed cache size.
+     *
+     * @param max Maximum allowed cache size.
+     */
+    @MXBeanDescription("Set maximum allowed cache size.")
+    public void setMaxSize(int max);
+
+    /**
+     * Gets current queue size.
+     *
+     * @return Current queue size.
+     */
+    @MXBeanDescription("Current FIFO queue size.")
+    public int getCurrentSize();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsEvictionFilter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsEvictionFilter.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsEvictionFilter.java
deleted file mode 100644
index 47f97e5..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsEvictionFilter.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * 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.cache.eviction.igfs;
-
-import org.apache.ignite.cache.eviction.*;
-import org.apache.ignite.internal.processors.igfs.*;
-
-import javax.cache.*;
-
-/**
- * IGFS eviction filter which will not evict blocks of particular files.
- */
-public class CacheIgfsEvictionFilter implements CacheEvictionFilter {
-    /** */
-    private static final long serialVersionUID = 0L;
-
-    /** {@inheritDoc} */
-    @Override public boolean evictAllowed(Cache.Entry entry) {
-        Object key = entry.getKey();
-
-        return !(key instanceof IgfsBlockKey && ((IgfsBlockKey)key).evictExclude());
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicy.java
deleted file mode 100644
index 83b7d9b..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicy.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * 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.cache.eviction.igfs;
-
-import org.apache.ignite.*;
-import org.apache.ignite.cache.eviction.*;
-import org.apache.ignite.igfs.*;
-import org.apache.ignite.internal.processors.cache.*;
-import org.apache.ignite.internal.processors.igfs.*;
-import org.jsr166.*;
-import org.jsr166.ConcurrentLinkedDeque8.*;
-import org.jetbrains.annotations.*;
-
-import java.io.*;
-import java.util.*;
-import java.util.concurrent.atomic.*;
-import java.util.regex.*;
-
-/**
- * IGFS eviction policy which evicts particular blocks.
- */
-public class CacheIgfsPerBlockLruEvictionPolicy implements CacheEvictionPolicy<IgfsBlockKey, byte[]>,
-    CacheIgfsPerBlockLruEvictionPolicyMXBean, Externalizable {
-    /** */
-    private static final long serialVersionUID = 0L;
-
-    /** Maximum size. When reached, eviction begins. */
-    private volatile long maxSize;
-
-    /** Maximum amount of blocks. When reached, eviction begins. */
-    private volatile int maxBlocks;
-
-    /** Collection of regex for paths which must not be evicted. */
-    private volatile Collection<String> excludePaths;
-
-    /** Exclusion patterns. */
-    private volatile Collection<Pattern> excludePatterns;
-
-    /** Whether patterns must be recompiled during the next call. */
-    private final AtomicBoolean excludeRecompile = new AtomicBoolean(true);
-
-    /** Queue. */
-    private final ConcurrentLinkedDeque8<CacheEvictableEntry<IgfsBlockKey, byte[]>> queue =
-        new ConcurrentLinkedDeque8<>();
-
-    /** Current size of all enqueued blocks in bytes. */
-    private final LongAdder8 curSize = new LongAdder8();
-
-    /**
-     * Default constructor.
-     */
-    public CacheIgfsPerBlockLruEvictionPolicy() {
-        // No-op.
-    }
-
-    /**
-     * Constructor.
-     *
-     * @param maxSize Maximum size. When reached, eviction begins.
-     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
-     */
-    public CacheIgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks) {
-        this(maxSize, maxBlocks, null);
-    }
-
-    /**
-     * Constructor.
-     *
-     * @param maxSize Maximum size. When reached, eviction begins.
-     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
-     * @param excludePaths Collection of regex for path which must not be evicted.
-     */
-    public CacheIgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks,
-        @Nullable Collection<String> excludePaths) {
-        this.maxSize = maxSize;
-        this.maxBlocks = maxBlocks;
-        this.excludePaths = excludePaths;
-    }
-
-    /** {@inheritDoc} */
-    @Override public void onEntryAccessed(boolean rmv, CacheEvictableEntry<IgfsBlockKey, byte[]> entry) {
-        if (!rmv) {
-            if (!entry.isCached())
-                return;
-
-            if (touch(entry))
-                shrink();
-        }
-        else {
-            MetaEntry meta = entry.removeMeta();
-
-            if (meta != null && queue.unlinkx(meta.node()))
-                changeSize(-meta.size());
-        }
-    }
-
-    /**
-     * @param entry Entry to touch.
-     * @return {@code True} if new node has been added to queue by this call.
-     */
-    private boolean touch(CacheEvictableEntry<IgfsBlockKey, byte[]> entry) {
-        byte[] val = peek(entry);
-
-        int blockSize = val != null ? val.length : 0;
-
-        MetaEntry meta = entry.meta();
-
-        // Entry has not been enqueued yet.
-        if (meta == null) {
-            while (true) {
-                Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> node = queue.offerLastx(entry);
-
-                meta = new MetaEntry(node, blockSize);
-
-                if (entry.putMetaIfAbsent(meta) != null) {
-                    // Was concurrently added, need to clear it from queue.
-                    queue.unlinkx(node);
-
-                    // Queue has not been changed.
-                    return false;
-                }
-                else if (node.item() != null) {
-                    if (!entry.isCached()) {
-                        // Was concurrently evicted, need to clear it from queue.
-                        queue.unlinkx(node);
-
-                        return false;
-                    }
-
-                    // Increment current size.
-                    changeSize(blockSize);
-
-                    return true;
-                }
-                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
-                else if (!entry.removeMeta(node))
-                    return false;
-            }
-        }
-        else {
-            int oldBlockSize = meta.size();
-
-            Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> node = meta.node();
-
-            if (queue.unlinkx(node)) {
-                // Move node to tail.
-                Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> newNode = queue.offerLastx(entry);
-
-                int delta = blockSize - oldBlockSize;
-
-                if (!entry.replaceMeta(meta, new MetaEntry(newNode, blockSize))) {
-                    // Was concurrently added, need to clear it from queue.
-                    if (queue.unlinkx(newNode))
-                        delta -= blockSize;
-                }
-
-                if (delta != 0) {
-                    changeSize(delta);
-
-                   if (delta > 0)
-                       // Total size increased, so shrinking could be needed.
-                       return true;
-                }
-            }
-        }
-
-        // Entry is already in queue.
-        return false;
-    }
-
-    /**
-     * @param entry Entry.
-     * @return Peeked value.
-     */
-    @Nullable private byte[] peek(CacheEvictableEntry<IgfsBlockKey, byte[]> entry) {
-        return (byte[])((CacheEvictableEntryImpl)entry).peek();
-    }
-
-    /**
-     * Shrinks queue to maximum allowed size.
-     */
-    private void shrink() {
-        long maxSize = this.maxSize;
-        int maxBlocks = this.maxBlocks;
-
-        int cnt = queue.sizex();
-
-        for (int i = 0; i < cnt && (maxBlocks > 0 && queue.sizex() > maxBlocks ||
-            maxSize > 0 && curSize.longValue() > maxSize); i++) {
-            CacheEvictableEntry<IgfsBlockKey, byte[]> entry = queue.poll();
-
-            if (entry == null)
-                break; // Queue is empty.
-
-            byte[] val = peek(entry);
-
-            if (val != null)
-                changeSize(-val.length); // Change current size as we polled entry from the queue.
-
-            if (!entry.evict()) {
-                // Reorder entries which we failed to evict.
-                entry.removeMeta();
-
-                touch(entry);
-            }
-        }
-    }
-
-    /**
-     * Change current size.
-     *
-     * @param delta Delta in bytes.
-     */
-    private void changeSize(int delta) {
-        if (delta != 0)
-            curSize.add(delta);
-    }
-
-    /** {@inheritDoc} */
-    @Override public long getMaxSize() {
-        return maxSize;
-    }
-
-    /** {@inheritDoc} */
-    @Override public void setMaxSize(long maxSize) {
-        this.maxSize = maxSize;
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getMaxBlocks() {
-        return maxBlocks;
-    }
-
-    /** {@inheritDoc} */
-    @Override public void setMaxBlocks(int maxBlocks) {
-        this.maxBlocks = maxBlocks;
-    }
-
-    /** {@inheritDoc} */
-    @Override public Collection<String> getExcludePaths() {
-        return Collections.unmodifiableCollection(excludePaths);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void setExcludePaths(@Nullable Collection<String> excludePaths) {
-        this.excludePaths = excludePaths;
-
-        excludeRecompile.set(true);
-    }
-
-    /** {@inheritDoc} */
-    @Override public long getCurrentSize() {
-        return curSize.longValue();
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getCurrentBlocks() {
-        return queue.size();
-    }
-
-    /** {@inheritDoc} */
-    @Override public void writeExternal(ObjectOutput out) throws IOException {
-        out.writeLong(maxSize);
-        out.writeInt(maxBlocks);
-        out.writeObject(excludePaths);
-        out.writeObject(excludePatterns);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
-        maxSize = in.readLong();
-        maxBlocks = in.readInt();
-        excludePaths = (Collection<String>)in.readObject();
-        excludePatterns = (Collection<Pattern>)in.readObject();
-    }
-
-    /**
-     * Check whether provided path must be excluded from evictions.
-     *
-     * @param path Path.
-     * @return {@code True} in case non block of related file must be excluded.
-     * @throws IgniteCheckedException In case of faulty patterns.
-     */
-    public boolean exclude(IgfsPath path) throws IgniteCheckedException {
-        assert path != null;
-
-        Collection<Pattern> excludePatterns0;
-
-        if (excludeRecompile.compareAndSet(true, false)) {
-            // Recompile.
-            Collection<String> excludePaths0 = excludePaths;
-
-            if (excludePaths0 != null) {
-                excludePatterns0 = new HashSet<>(excludePaths0.size(), 1.0f);
-
-                for (String excludePath : excludePaths0) {
-                    try {
-                        excludePatterns0.add(Pattern.compile(excludePath));
-                    }
-                    catch (PatternSyntaxException ignore) {
-                        throw new IgniteCheckedException("Invalid regex pattern: " + excludePath);
-                    }
-                }
-
-                excludePatterns = excludePatterns0;
-            }
-            else
-                excludePatterns0 = excludePatterns = null;
-        }
-        else
-            excludePatterns0 = excludePatterns;
-
-        if (excludePatterns0 != null) {
-            String pathStr = path.toString();
-
-            for (Pattern pattern : excludePatterns0) {
-                if (pattern.matcher(pathStr).matches())
-                    return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Meta entry.
-     */
-    private static class MetaEntry {
-        /** Queue node. */
-        private final Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> node;
-
-        /** Data size. */
-        private final int size;
-
-        /**
-         * Constructor.
-         *
-         * @param node Queue node.
-         * @param size Data size.
-         */
-        private MetaEntry(Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> node, int size) {
-            assert node != null;
-            assert size >= 0;
-
-            this.node = node;
-            this.size = size;
-        }
-
-        /**
-         * @return Queue node.
-         */
-        private Node<CacheEvictableEntry<IgfsBlockKey, byte[]>> node() {
-            return node;
-        }
-
-        /**
-         * @return Data size.
-         */
-        private int size() {
-            return size;
-        }
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicyMXBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicyMXBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicyMXBean.java
deleted file mode 100644
index e3abc29..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/CacheIgfsPerBlockLruEvictionPolicyMXBean.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * 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.cache.eviction.igfs;
-
-import org.apache.ignite.mxbean.*;
-import org.jetbrains.annotations.*;
-
-import java.util.*;
-
-/**
- * MBean for {@code IGFS per-block LRU} eviction policy.
- */
-@MXBeanDescription("MBean for IGFS per-block LRU cache eviction policy.")
-public interface CacheIgfsPerBlockLruEvictionPolicyMXBean {
-    /**
-     * Gets maximum allowed size of all blocks in bytes.
-     *
-     * @return Maximum allowed size of all blocks in bytes.
-     */
-    @MXBeanDescription("Maximum allowed size of all blocks in bytes.")
-    public long getMaxSize();
-
-    /**
-     * Sets maximum allowed size of data in all blocks in bytes.
-     *
-     * @param maxSize Maximum allowed size of data in all blocks in bytes.
-     */
-    @MXBeanDescription("Sets aximum allowed size of data in all blocks in bytes.")
-    public void setMaxSize(long maxSize);
-
-    /**
-     * Gets maximum allowed amount of blocks.
-     *
-     * @return Maximum allowed amount of blocks.
-     */
-    @MXBeanDescription("Maximum allowed amount of blocks.")
-    public int getMaxBlocks();
-
-    /**
-     * Sets maximum allowed amount of blocks.
-     *
-     * @param maxBlocks Maximum allowed amount of blocks.
-     */
-    @MXBeanDescription("Sets maximum allowed amount of blocks.")
-    public void setMaxBlocks(int maxBlocks);
-
-    /**
-     * Gets collection of regex for paths whose blocks must not be evicted.
-     *
-     * @return Collection of regex for paths whose blocks must not be evicted.
-     */
-    @MXBeanDescription("Collection of regex for paths whose blocks must not be evicted.")
-    @Nullable public Collection<String> getExcludePaths();
-
-    /**
-     * Sets collection of regex for paths whose blocks must not be evicted.
-     *
-     * @param excludePaths Collection of regex for paths whose blocks must not be evicted.
-     */
-    @MXBeanDescription("Sets collection of regex for paths whose blocks must not be evicted.")
-    public void setExcludePaths(@Nullable Collection<String> excludePaths);
-
-    /**
-     * Gets current size of data in all blocks.
-     *
-     * @return Current size of data in all blocks.
-     */
-    @MXBeanDescription("Current size of data in all blocks.")
-    public long getCurrentSize();
-
-    /**
-     * Gets current amount of blocks.
-     *
-     * @return Current amount of blocks.
-     */
-    @MXBeanDescription("Current amount of blocks.")
-    public int getCurrentBlocks();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsEvictionFilter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsEvictionFilter.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsEvictionFilter.java
new file mode 100644
index 0000000..97d1dd1
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsEvictionFilter.java
@@ -0,0 +1,38 @@
+/*
+ * 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.cache.eviction.igfs;
+
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.internal.processors.igfs.*;
+
+import javax.cache.*;
+
+/**
+ * IGFS eviction filter which will not evict blocks of particular files.
+ */
+public class IgfsEvictionFilter implements EvictionFilter {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** {@inheritDoc} */
+    @Override public boolean evictAllowed(Cache.Entry entry) {
+        Object key = entry.getKey();
+
+        return !(key instanceof IgfsBlockKey && ((IgfsBlockKey)key).evictExclude());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicy.java
new file mode 100644
index 0000000..ff4aeea
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicy.java
@@ -0,0 +1,376 @@
+/*
+ * 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.cache.eviction.igfs;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.igfs.*;
+import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.igfs.*;
+import org.jsr166.*;
+import org.jsr166.ConcurrentLinkedDeque8.*;
+import org.jetbrains.annotations.*;
+
+import java.io.*;
+import java.util.*;
+import java.util.concurrent.atomic.*;
+import java.util.regex.*;
+
+/**
+ * IGFS eviction policy which evicts particular blocks.
+ */
+public class IgfsPerBlockLruEvictionPolicy implements EvictionPolicy<IgfsBlockKey, byte[]>, IgfsPerBlockLruEvictionPolicyMXBean, Externalizable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Maximum size. When reached, eviction begins. */
+    private volatile long maxSize;
+
+    /** Maximum amount of blocks. When reached, eviction begins. */
+    private volatile int maxBlocks;
+
+    /** Collection of regex for paths which must not be evicted. */
+    private volatile Collection<String> excludePaths;
+
+    /** Exclusion patterns. */
+    private volatile Collection<Pattern> excludePatterns;
+
+    /** Whether patterns must be recompiled during the next call. */
+    private final AtomicBoolean excludeRecompile = new AtomicBoolean(true);
+
+    /** Queue. */
+    private final ConcurrentLinkedDeque8<EvictableEntry<IgfsBlockKey, byte[]>> queue =
+        new ConcurrentLinkedDeque8<>();
+
+    /** Current size of all enqueued blocks in bytes. */
+    private final LongAdder8 curSize = new LongAdder8();
+
+    /**
+     * Default constructor.
+     */
+    public IgfsPerBlockLruEvictionPolicy() {
+        // No-op.
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param maxSize Maximum size. When reached, eviction begins.
+     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
+     */
+    public IgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks) {
+        this(maxSize, maxBlocks, null);
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param maxSize Maximum size. When reached, eviction begins.
+     * @param maxBlocks Maximum amount of blocks. When reached, eviction begins.
+     * @param excludePaths Collection of regex for path which must not be evicted.
+     */
+    public IgfsPerBlockLruEvictionPolicy(long maxSize, int maxBlocks, @Nullable Collection<String> excludePaths) {
+        this.maxSize = maxSize;
+        this.maxBlocks = maxBlocks;
+        this.excludePaths = excludePaths;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void onEntryAccessed(boolean rmv, EvictableEntry<IgfsBlockKey, byte[]> entry) {
+        if (!rmv) {
+            if (!entry.isCached())
+                return;
+
+            if (touch(entry))
+                shrink();
+        }
+        else {
+            MetaEntry meta = entry.removeMeta();
+
+            if (meta != null && queue.unlinkx(meta.node()))
+                changeSize(-meta.size());
+        }
+    }
+
+    /**
+     * @param entry Entry to touch.
+     * @return {@code True} if new node has been added to queue by this call.
+     */
+    private boolean touch(EvictableEntry<IgfsBlockKey, byte[]> entry) {
+        byte[] val = peek(entry);
+
+        int blockSize = val != null ? val.length : 0;
+
+        MetaEntry meta = entry.meta();
+
+        // Entry has not been enqueued yet.
+        if (meta == null) {
+            while (true) {
+                Node<EvictableEntry<IgfsBlockKey, byte[]>> node = queue.offerLastx(entry);
+
+                meta = new MetaEntry(node, blockSize);
+
+                if (entry.putMetaIfAbsent(meta) != null) {
+                    // Was concurrently added, need to clear it from queue.
+                    queue.unlinkx(node);
+
+                    // Queue has not been changed.
+                    return false;
+                }
+                else if (node.item() != null) {
+                    if (!entry.isCached()) {
+                        // Was concurrently evicted, need to clear it from queue.
+                        queue.unlinkx(node);
+
+                        return false;
+                    }
+
+                    // Increment current size.
+                    changeSize(blockSize);
+
+                    return true;
+                }
+                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
+                else if (!entry.removeMeta(node))
+                    return false;
+            }
+        }
+        else {
+            int oldBlockSize = meta.size();
+
+            Node<EvictableEntry<IgfsBlockKey, byte[]>> node = meta.node();
+
+            if (queue.unlinkx(node)) {
+                // Move node to tail.
+                Node<EvictableEntry<IgfsBlockKey, byte[]>> newNode = queue.offerLastx(entry);
+
+                int delta = blockSize - oldBlockSize;
+
+                if (!entry.replaceMeta(meta, new MetaEntry(newNode, blockSize))) {
+                    // Was concurrently added, need to clear it from queue.
+                    if (queue.unlinkx(newNode))
+                        delta -= blockSize;
+                }
+
+                if (delta != 0) {
+                    changeSize(delta);
+
+                   if (delta > 0)
+                       // Total size increased, so shrinking could be needed.
+                       return true;
+                }
+            }
+        }
+
+        // Entry is already in queue.
+        return false;
+    }
+
+    /**
+     * @param entry Entry.
+     * @return Peeked value.
+     */
+    @Nullable private byte[] peek(EvictableEntry<IgfsBlockKey, byte[]> entry) {
+        return (byte[])((CacheEvictableEntryImpl)entry).peek();
+    }
+
+    /**
+     * Shrinks queue to maximum allowed size.
+     */
+    private void shrink() {
+        long maxSize = this.maxSize;
+        int maxBlocks = this.maxBlocks;
+
+        int cnt = queue.sizex();
+
+        for (int i = 0; i < cnt && (maxBlocks > 0 && queue.sizex() > maxBlocks ||
+            maxSize > 0 && curSize.longValue() > maxSize); i++) {
+            EvictableEntry<IgfsBlockKey, byte[]> entry = queue.poll();
+
+            if (entry == null)
+                break; // Queue is empty.
+
+            byte[] val = peek(entry);
+
+            if (val != null)
+                changeSize(-val.length); // Change current size as we polled entry from the queue.
+
+            if (!entry.evict()) {
+                // Reorder entries which we failed to evict.
+                entry.removeMeta();
+
+                touch(entry);
+            }
+        }
+    }
+
+    /**
+     * Change current size.
+     *
+     * @param delta Delta in bytes.
+     */
+    private void changeSize(int delta) {
+        if (delta != 0)
+            curSize.add(delta);
+    }
+
+    /** {@inheritDoc} */
+    @Override public long getMaxSize() {
+        return maxSize;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setMaxSize(long maxSize) {
+        this.maxSize = maxSize;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getMaxBlocks() {
+        return maxBlocks;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setMaxBlocks(int maxBlocks) {
+        this.maxBlocks = maxBlocks;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<String> getExcludePaths() {
+        return Collections.unmodifiableCollection(excludePaths);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void setExcludePaths(@Nullable Collection<String> excludePaths) {
+        this.excludePaths = excludePaths;
+
+        excludeRecompile.set(true);
+    }
+
+    /** {@inheritDoc} */
+    @Override public long getCurrentSize() {
+        return curSize.longValue();
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getCurrentBlocks() {
+        return queue.size();
+    }
+
+    /** {@inheritDoc} */
+    @Override public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeLong(maxSize);
+        out.writeInt(maxBlocks);
+        out.writeObject(excludePaths);
+        out.writeObject(excludePatterns);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        maxSize = in.readLong();
+        maxBlocks = in.readInt();
+        excludePaths = (Collection<String>)in.readObject();
+        excludePatterns = (Collection<Pattern>)in.readObject();
+    }
+
+    /**
+     * Check whether provided path must be excluded from evictions.
+     *
+     * @param path Path.
+     * @return {@code True} in case non block of related file must be excluded.
+     * @throws IgniteCheckedException In case of faulty patterns.
+     */
+    public boolean exclude(IgfsPath path) throws IgniteCheckedException {
+        assert path != null;
+
+        Collection<Pattern> excludePatterns0;
+
+        if (excludeRecompile.compareAndSet(true, false)) {
+            // Recompile.
+            Collection<String> excludePaths0 = excludePaths;
+
+            if (excludePaths0 != null) {
+                excludePatterns0 = new HashSet<>(excludePaths0.size(), 1.0f);
+
+                for (String excludePath : excludePaths0) {
+                    try {
+                        excludePatterns0.add(Pattern.compile(excludePath));
+                    }
+                    catch (PatternSyntaxException ignore) {
+                        throw new IgniteCheckedException("Invalid regex pattern: " + excludePath);
+                    }
+                }
+
+                excludePatterns = excludePatterns0;
+            }
+            else
+                excludePatterns0 = excludePatterns = null;
+        }
+        else
+            excludePatterns0 = excludePatterns;
+
+        if (excludePatterns0 != null) {
+            String pathStr = path.toString();
+
+            for (Pattern pattern : excludePatterns0) {
+                if (pattern.matcher(pathStr).matches())
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Meta entry.
+     */
+    private static class MetaEntry {
+        /** Queue node. */
+        private final Node<EvictableEntry<IgfsBlockKey, byte[]>> node;
+
+        /** Data size. */
+        private final int size;
+
+        /**
+         * Constructor.
+         *
+         * @param node Queue node.
+         * @param size Data size.
+         */
+        private MetaEntry(Node<EvictableEntry<IgfsBlockKey, byte[]>> node, int size) {
+            assert node != null;
+            assert size >= 0;
+
+            this.node = node;
+            this.size = size;
+        }
+
+        /**
+         * @return Queue node.
+         */
+        private Node<EvictableEntry<IgfsBlockKey, byte[]>> node() {
+            return node;
+        }
+
+        /**
+         * @return Data size.
+         */
+        private int size() {
+            return size;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicyMXBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicyMXBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicyMXBean.java
new file mode 100644
index 0000000..76e1016
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/igfs/IgfsPerBlockLruEvictionPolicyMXBean.java
@@ -0,0 +1,93 @@
+/*
+ * 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.cache.eviction.igfs;
+
+import org.apache.ignite.mxbean.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * MBean for {@code IGFS per-block LRU} eviction policy.
+ */
+@MXBeanDescription("MBean for IGFS per-block LRU cache eviction policy.")
+public interface IgfsPerBlockLruEvictionPolicyMXBean {
+    /**
+     * Gets maximum allowed size of all blocks in bytes.
+     *
+     * @return Maximum allowed size of all blocks in bytes.
+     */
+    @MXBeanDescription("Maximum allowed size of all blocks in bytes.")
+    public long getMaxSize();
+
+    /**
+     * Sets maximum allowed size of data in all blocks in bytes.
+     *
+     * @param maxSize Maximum allowed size of data in all blocks in bytes.
+     */
+    @MXBeanDescription("Sets aximum allowed size of data in all blocks in bytes.")
+    public void setMaxSize(long maxSize);
+
+    /**
+     * Gets maximum allowed amount of blocks.
+     *
+     * @return Maximum allowed amount of blocks.
+     */
+    @MXBeanDescription("Maximum allowed amount of blocks.")
+    public int getMaxBlocks();
+
+    /**
+     * Sets maximum allowed amount of blocks.
+     *
+     * @param maxBlocks Maximum allowed amount of blocks.
+     */
+    @MXBeanDescription("Sets maximum allowed amount of blocks.")
+    public void setMaxBlocks(int maxBlocks);
+
+    /**
+     * Gets collection of regex for paths whose blocks must not be evicted.
+     *
+     * @return Collection of regex for paths whose blocks must not be evicted.
+     */
+    @MXBeanDescription("Collection of regex for paths whose blocks must not be evicted.")
+    @Nullable public Collection<String> getExcludePaths();
+
+    /**
+     * Sets collection of regex for paths whose blocks must not be evicted.
+     *
+     * @param excludePaths Collection of regex for paths whose blocks must not be evicted.
+     */
+    @MXBeanDescription("Sets collection of regex for paths whose blocks must not be evicted.")
+    public void setExcludePaths(@Nullable Collection<String> excludePaths);
+
+    /**
+     * Gets current size of data in all blocks.
+     *
+     * @return Current size of data in all blocks.
+     */
+    @MXBeanDescription("Current size of data in all blocks.")
+    public long getCurrentSize();
+
+    /**
+     * Gets current amount of blocks.
+     *
+     * @return Current amount of blocks.
+     */
+    @MXBeanDescription("Current amount of blocks.")
+    public int getCurrentBlocks();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicy.java
deleted file mode 100644
index 939b194..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicy.java
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * 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.cache.eviction.lru;
-
-import org.apache.ignite.cache.eviction.*;
-import org.apache.ignite.configuration.*;
-import org.apache.ignite.internal.util.typedef.internal.*;
-import org.jsr166.*;
-import org.jsr166.ConcurrentLinkedDeque8.*;
-
-import java.io.*;
-import java.util.*;
-
-/**
- * Eviction policy based on {@code Least Recently Used (LRU)} algorithm. This
- * implementation is very efficient since it is lock-free and does not
- * create any additional table-like data structures. The {@code LRU} ordering
- * information is maintained by attaching ordering metadata to cache entries.
- */
-public class CacheLruEvictionPolicy<K, V> implements CacheEvictionPolicy<K, V>,
-    CacheLruEvictionPolicyMBean, Externalizable {
-    /** */
-    private static final long serialVersionUID = 0L;
-
-    /** Maximum size. */
-    private volatile int max = CacheConfiguration.DFLT_CACHE_SIZE;
-
-    /** Queue. */
-    private final ConcurrentLinkedDeque8<CacheEvictableEntry<K, V>> queue =
-        new ConcurrentLinkedDeque8<>();
-
-    /**
-     * Constructs LRU eviction policy with all defaults.
-     */
-    public CacheLruEvictionPolicy() {
-        // No-op.
-    }
-
-    /**
-     * Constructs LRU eviction policy with maximum size.
-     *
-     * @param max Maximum allowed size of cache before entry will start getting evicted.
-     */
-    public CacheLruEvictionPolicy(int max) {
-        A.ensure(max > 0, "max > 0");
-
-        this.max = max;
-    }
-
-    /**
-     * Gets maximum allowed size of cache before entry will start getting evicted.
-     *
-     * @return Maximum allowed size of cache before entry will start getting evicted.
-     */
-    @Override public int getMaxSize() {
-        return max;
-    }
-
-    /**
-     * Sets maximum allowed size of cache before entry will start getting evicted.
-     *
-     * @param max Maximum allowed size of cache before entry will start getting evicted.
-     */
-    @Override public void setMaxSize(int max) {
-        A.ensure(max > 0, "max > 0");
-
-        this.max = max;
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getCurrentSize() {
-        return queue.size();
-    }
-
-    /**
-     * Gets read-only view on internal {@code FIFO} queue in proper order.
-     *
-     * @return Read-only view ono internal {@code 'FIFO'} queue.
-     */
-    public Collection<CacheEvictableEntry<K, V>> queue() {
-        return Collections.unmodifiableCollection(queue);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void onEntryAccessed(boolean rmv, CacheEvictableEntry<K, V> entry) {
-        if (!rmv) {
-            if (!entry.isCached())
-                return;
-
-            if (touch(entry))
-                shrink();
-        }
-        else {
-            Node<CacheEvictableEntry<K, V>> node = entry.removeMeta();
-
-            if (node != null)
-                queue.unlinkx(node);
-        }
-    }
-
-    /**
-     * @param entry Entry to touch.
-     * @return {@code True} if new node has been added to queue by this call.
-     */
-    private boolean touch(CacheEvictableEntry<K, V> entry) {
-        Node<CacheEvictableEntry<K, V>> node = entry.meta();
-
-        // Entry has not been enqueued yet.
-        if (node == null) {
-            while (true) {
-                node = queue.offerLastx(entry);
-
-                if (entry.putMetaIfAbsent(node) != null) {
-                    // Was concurrently added, need to clear it from queue.
-                    queue.unlinkx(node);
-
-                    // Queue has not been changed.
-                    return false;
-                }
-                else if (node.item() != null) {
-                    if (!entry.isCached()) {
-                        // Was concurrently evicted, need to clear it from queue.
-                        queue.unlinkx(node);
-
-                        return false;
-                    }
-
-                    return true;
-                }
-                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
-                else if (!entry.removeMeta(node))
-                    return false;
-            }
-        }
-        else if (queue.unlinkx(node)) {
-            // Move node to tail.
-            Node<CacheEvictableEntry<K, V>> newNode = queue.offerLastx(entry);
-
-            if (!entry.replaceMeta(node, newNode))
-                // Was concurrently added, need to clear it from queue.
-                queue.unlinkx(newNode);
-        }
-
-        // Entry is already in queue.
-        return false;
-    }
-
-    /**
-     * Shrinks queue to maximum allowed size.
-     */
-    private void shrink() {
-        int max = this.max;
-
-        int startSize = queue.sizex();
-
-        for (int i = 0; i < startSize && queue.sizex() > max; i++) {
-            CacheEvictableEntry<K, V> entry = queue.poll();
-
-            if (entry == null)
-                break;
-
-            if (!entry.evict()) {
-                entry.removeMeta();
-
-                touch(entry);
-            }
-        }
-    }
-
-    /** {@inheritDoc} */
-    @Override public void writeExternal(ObjectOutput out) throws IOException {
-        out.writeInt(max);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
-        max = in.readInt();
-    }
-
-    /** {@inheritDoc} */
-    @Override public String toString() {
-        return S.toString(CacheLruEvictionPolicy.class, this, "size", queue.sizex());
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicyMBean.java
deleted file mode 100644
index 49f0dcc..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/CacheLruEvictionPolicyMBean.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * 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.cache.eviction.lru;
-
-import org.apache.ignite.mxbean.*;
-
-/**
- * MBean for {@code LRU} eviction policy.
- */
-@MXBeanDescription("MBean for LRU cache eviction policy.")
-public interface CacheLruEvictionPolicyMBean {
-    /**
-     * Gets maximum allowed cache size.
-     *
-     * @return Maximum allowed cache size.
-     */
-    @MXBeanDescription("Maximum allowed cache size.")
-    public int getMaxSize();
-
-    /**
-     * Sets maximum allowed cache size.
-     *
-     * @param max Maximum allowed cache size.
-     */
-    @MXBeanDescription("Sets maximum allowed cache size.")
-    public void setMaxSize(int max);
-
-    /**
-     * Gets current queue size.
-     *
-     * @return Current queue size.
-     */
-    @MXBeanDescription("Current queue size.")
-    public int getCurrentSize();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicy.java
new file mode 100644
index 0000000..2ba3c41
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicy.java
@@ -0,0 +1,198 @@
+/*
+ * 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.cache.eviction.lru;
+
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.jsr166.*;
+import org.jsr166.ConcurrentLinkedDeque8.*;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Eviction policy based on {@code Least Recently Used (LRU)} algorithm. This
+ * implementation is very efficient since it is lock-free and does not
+ * create any additional table-like data structures. The {@code LRU} ordering
+ * information is maintained by attaching ordering metadata to cache entries.
+ */
+public class LruEvictionPolicy<K, V> implements EvictionPolicy<K, V>, LruEvictionPolicyMBean, Externalizable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Maximum size. */
+    private volatile int max = CacheConfiguration.DFLT_CACHE_SIZE;
+
+    /** Queue. */
+    private final ConcurrentLinkedDeque8<EvictableEntry<K, V>> queue =
+        new ConcurrentLinkedDeque8<>();
+
+    /**
+     * Constructs LRU eviction policy with all defaults.
+     */
+    public LruEvictionPolicy() {
+        // No-op.
+    }
+
+    /**
+     * Constructs LRU eviction policy with maximum size.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    public LruEvictionPolicy(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /**
+     * Gets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @return Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public int getMaxSize() {
+        return max;
+    }
+
+    /**
+     * Sets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public void setMaxSize(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /** {@inheritDoc} */
+    @Override public int getCurrentSize() {
+        return queue.size();
+    }
+
+    /**
+     * Gets read-only view on internal {@code FIFO} queue in proper order.
+     *
+     * @return Read-only view ono internal {@code 'FIFO'} queue.
+     */
+    public Collection<EvictableEntry<K, V>> queue() {
+        return Collections.unmodifiableCollection(queue);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void onEntryAccessed(boolean rmv, EvictableEntry<K, V> entry) {
+        if (!rmv) {
+            if (!entry.isCached())
+                return;
+
+            if (touch(entry))
+                shrink();
+        }
+        else {
+            Node<EvictableEntry<K, V>> node = entry.removeMeta();
+
+            if (node != null)
+                queue.unlinkx(node);
+        }
+    }
+
+    /**
+     * @param entry Entry to touch.
+     * @return {@code True} if new node has been added to queue by this call.
+     */
+    private boolean touch(EvictableEntry<K, V> entry) {
+        Node<EvictableEntry<K, V>> node = entry.meta();
+
+        // Entry has not been enqueued yet.
+        if (node == null) {
+            while (true) {
+                node = queue.offerLastx(entry);
+
+                if (entry.putMetaIfAbsent(node) != null) {
+                    // Was concurrently added, need to clear it from queue.
+                    queue.unlinkx(node);
+
+                    // Queue has not been changed.
+                    return false;
+                }
+                else if (node.item() != null) {
+                    if (!entry.isCached()) {
+                        // Was concurrently evicted, need to clear it from queue.
+                        queue.unlinkx(node);
+
+                        return false;
+                    }
+
+                    return true;
+                }
+                // If node was unlinked by concurrent shrink() call, we must repeat the whole cycle.
+                else if (!entry.removeMeta(node))
+                    return false;
+            }
+        }
+        else if (queue.unlinkx(node)) {
+            // Move node to tail.
+            Node<EvictableEntry<K, V>> newNode = queue.offerLastx(entry);
+
+            if (!entry.replaceMeta(node, newNode))
+                // Was concurrently added, need to clear it from queue.
+                queue.unlinkx(newNode);
+        }
+
+        // Entry is already in queue.
+        return false;
+    }
+
+    /**
+     * Shrinks queue to maximum allowed size.
+     */
+    private void shrink() {
+        int max = this.max;
+
+        int startSize = queue.sizex();
+
+        for (int i = 0; i < startSize && queue.sizex() > max; i++) {
+            EvictableEntry<K, V> entry = queue.poll();
+
+            if (entry == null)
+                break;
+
+            if (!entry.evict()) {
+                entry.removeMeta();
+
+                touch(entry);
+            }
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeInt(max);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        max = in.readInt();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(LruEvictionPolicy.class, this, "size", queue.sizex());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicyMBean.java
new file mode 100644
index 0000000..c243374
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/lru/LruEvictionPolicyMBean.java
@@ -0,0 +1,50 @@
+/*
+ * 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.cache.eviction.lru;
+
+import org.apache.ignite.mxbean.*;
+
+/**
+ * MBean for {@code LRU} eviction policy.
+ */
+@MXBeanDescription("MBean for LRU cache eviction policy.")
+public interface LruEvictionPolicyMBean {
+    /**
+     * Gets maximum allowed cache size.
+     *
+     * @return Maximum allowed cache size.
+     */
+    @MXBeanDescription("Maximum allowed cache size.")
+    public int getMaxSize();
+
+    /**
+     * Sets maximum allowed cache size.
+     *
+     * @param max Maximum allowed cache size.
+     */
+    @MXBeanDescription("Sets maximum allowed cache size.")
+    public void setMaxSize(int max);
+
+    /**
+     * Gets current queue size.
+     *
+     * @return Current queue size.
+     */
+    @MXBeanDescription("Current queue size.")
+    public int getCurrentSize();
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicy.java
deleted file mode 100644
index 844734d..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicy.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * 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.cache.eviction.random;
-
-import org.apache.ignite.*;
-import org.apache.ignite.cache.eviction.*;
-import org.apache.ignite.configuration.*;
-import org.apache.ignite.internal.util.typedef.internal.*;
-
-import javax.cache.*;
-import java.io.*;
-
-/**
- * Cache eviction policy which will select random cache entry for eviction if cache
- * size exceeds the {@link #getMaxSize()} parameter. This implementation is
- * extremely light weight, lock-free, and does not create any data structures to maintain
- * any order for eviction.
- * <p>
- * Random eviction will provide the best performance over any key set in which every
- * key has the same probability of being accessed.
- */
-public class CacheRandomEvictionPolicy<K, V> implements CacheEvictionPolicy<K, V>,
-    CacheRandomEvictionPolicyMBean, Externalizable {
-    /** */
-    private static final long serialVersionUID = 0L;
-
-    /** Maximum size. */
-    private volatile int max = CacheConfiguration.DFLT_CACHE_SIZE;
-
-    /**
-     * Constructs random eviction policy with all defaults.
-     */
-    public CacheRandomEvictionPolicy() {
-        // No-op.
-    }
-
-    /**
-     * Constructs random eviction policy with maximum size.
-     *
-     * @param max Maximum allowed size of cache before entry will start getting evicted.
-     */
-    public CacheRandomEvictionPolicy(int max) {
-        A.ensure(max > 0, "max > 0");
-
-        this.max = max;
-    }
-
-    /**
-     * Gets maximum allowed size of cache before entry will start getting evicted.
-     *
-     * @return Maximum allowed size of cache before entry will start getting evicted.
-     */
-    @Override public int getMaxSize() {
-        return max;
-    }
-
-    /**
-     * Sets maximum allowed size of cache before entry will start getting evicted.
-     *
-     * @param max Maximum allowed size of cache before entry will start getting evicted.
-     */
-    @Override public void setMaxSize(int max) {
-        A.ensure(max > 0, "max > 0");
-
-        this.max = max;
-    }
-
-    /** {@inheritDoc} */
-    @SuppressWarnings("unchecked")
-    @Override public void onEntryAccessed(boolean rmv, CacheEvictableEntry<K, V> entry) {
-        if (!entry.isCached())
-            return;
-
-        IgniteCache<K, V> cache = entry.unwrap(IgniteCache.class);
-
-        int size = cache.size();
-
-        for (int i = max; i < size; i++) {
-            Cache.Entry<K, V> e = cache.randomEntry();
-
-            if (e != null)
-                e.unwrap(CacheEvictableEntry.class).evict();
-        }
-    }
-
-    /** {@inheritDoc} */
-    @Override public void writeExternal(ObjectOutput out) throws IOException {
-        out.writeInt(max);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
-        max = in.readInt();
-    }
-
-    /** {@inheritDoc} */
-    @Override public String toString() {
-        return S.toString(CacheRandomEvictionPolicy.class, this);
-    }
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicyMBean.java
deleted file mode 100644
index 4ef7696..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/CacheRandomEvictionPolicyMBean.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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.cache.eviction.random;
-
-import org.apache.ignite.mxbean.*;
-
-/**
- * MBean for {@code random} eviction policy.
- */
-@MXBeanDescription("MBean for random cache eviction policy.")
-public interface CacheRandomEvictionPolicyMBean {
-    /**
-     * Gets maximum allowed cache size.
-     *
-     * @return Maximum allowed cache size.
-     */
-    @MXBeanDescription("Maximum allowed cache size.")
-    public int getMaxSize();
-
-    /**
-     * Sets maximum allowed cache size.
-     *
-     * @param max Maximum allowed cache size.
-     */
-    @MXBeanDescription("Sets maximum allowed cache size.")
-    public void setMaxSize(int max);
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicy.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicy.java
new file mode 100644
index 0000000..c88b31d
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicy.java
@@ -0,0 +1,114 @@
+/*
+ * 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.cache.eviction.random;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.eviction.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+import javax.cache.*;
+import java.io.*;
+
+/**
+ * Cache eviction policy which will select random cache entry for eviction if cache
+ * size exceeds the {@link #getMaxSize()} parameter. This implementation is
+ * extremely light weight, lock-free, and does not create any data structures to maintain
+ * any order for eviction.
+ * <p>
+ * Random eviction will provide the best performance over any key set in which every
+ * key has the same probability of being accessed.
+ */
+public class RandomEvictionPolicy<K, V> implements EvictionPolicy<K, V>, RandomEvictionPolicyMBean, Externalizable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Maximum size. */
+    private volatile int max = CacheConfiguration.DFLT_CACHE_SIZE;
+
+    /**
+     * Constructs random eviction policy with all defaults.
+     */
+    public RandomEvictionPolicy() {
+        // No-op.
+    }
+
+    /**
+     * Constructs random eviction policy with maximum size.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    public RandomEvictionPolicy(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /**
+     * Gets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @return Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public int getMaxSize() {
+        return max;
+    }
+
+    /**
+     * Sets maximum allowed size of cache before entry will start getting evicted.
+     *
+     * @param max Maximum allowed size of cache before entry will start getting evicted.
+     */
+    @Override public void setMaxSize(int max) {
+        A.ensure(max > 0, "max > 0");
+
+        this.max = max;
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override public void onEntryAccessed(boolean rmv, EvictableEntry<K, V> entry) {
+        if (!entry.isCached())
+            return;
+
+        IgniteCache<K, V> cache = entry.unwrap(IgniteCache.class);
+
+        int size = cache.size();
+
+        for (int i = max; i < size; i++) {
+            Cache.Entry<K, V> e = cache.randomEntry();
+
+            if (e != null)
+                e.unwrap(EvictableEntry.class).evict();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public void writeExternal(ObjectOutput out) throws IOException {
+        out.writeInt(max);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+        max = in.readInt();
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(RandomEvictionPolicy.class, this);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicyMBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicyMBean.java b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicyMBean.java
new file mode 100644
index 0000000..ec7fb87
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/cache/eviction/random/RandomEvictionPolicyMBean.java
@@ -0,0 +1,42 @@
+/*
+ * 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.cache.eviction.random;
+
+import org.apache.ignite.mxbean.*;
+
+/**
+ * MBean for {@code random} eviction policy.
+ */
+@MXBeanDescription("MBean for random cache eviction policy.")
+public interface RandomEvictionPolicyMBean {
+    /**
+     * Gets maximum allowed cache size.
+     *
+     * @return Maximum allowed cache size.
+     */
+    @MXBeanDescription("Maximum allowed cache size.")
+    public int getMaxSize();
+
+    /**
+     * Sets maximum allowed cache size.
+     *
+     * @param max Maximum allowed cache size.
+     */
+    @MXBeanDescription("Sets maximum allowed cache size.")
+    public void setMaxSize(int max);
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
index 6359fe6..0c253cc 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
@@ -183,7 +183,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private long ttl = DFLT_TIME_TO_LIVE;
 
     /** Cache expiration policy. */
-    private CacheEvictionPolicy evictPlc;
+    private EvictionPolicy evictPlc;
 
     /** Flag indicating whether eviction is synchronized. */
     private boolean evictSync = DFLT_EVICT_SYNCHRONIZED;
@@ -198,7 +198,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private long evictSyncTimeout = DFLT_EVICT_SYNCHRONIZED_TIMEOUT;
 
     /** Eviction filter. */
-    private CacheEvictionFilter<?, ?> evictFilter;
+    private EvictionFilter<?, ?> evictFilter;
 
     /** Maximum eviction overflow ratio. */
     private float evictMaxOverflowRatio = DFLT_MAX_EVICTION_OVERFLOW_RATIO;
@@ -228,7 +228,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private boolean loadPrevVal = DFLT_LOAD_PREV_VAL;
 
     /** Node group resolver. */
-    private CacheAffinityFunction aff;
+    private AffinityFunction aff;
 
     /** Cache mode. */
     private CacheMode cacheMode = DFLT_CACHE_MODE;
@@ -285,7 +285,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private CacheMemoryMode memMode = DFLT_MEMORY_MODE;
 
     /** */
-    private CacheAffinityKeyMapper affMapper;
+    private AffinityKeyMapper affMapper;
 
     /** */
     private long rebalanceDelay;
@@ -459,7 +459,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * @return Cache eviction policy or {@code null} if evictions should be disabled.
      */
     @SuppressWarnings({"unchecked"})
-    @Nullable public CacheEvictionPolicy<K, V> getEvictionPolicy() {
+    @Nullable public EvictionPolicy<K, V> getEvictionPolicy() {
         return evictPlc;
     }
 
@@ -468,7 +468,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      *
      * @param evictPlc Cache expiration policy.
      */
-    public void setEvictionPolicy(@Nullable CacheEvictionPolicy evictPlc) {
+    public void setEvictionPolicy(@Nullable EvictionPolicy evictPlc) {
         this.evictPlc = evictPlc;
     }
 
@@ -658,7 +658,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /**
      * Gets eviction filter to specify which entries should not be evicted
      * (except explicit evict by calling {@link IgniteCache#localEvict(Collection)}).
-     * If {@link CacheEvictionFilter#evictAllowed(Cache.Entry)} method
+     * If {@link EvictionFilter#evictAllowed(Cache.Entry)} method
      * returns {@code false} then eviction policy will not be notified and entry will
      * never be evicted.
      * <p>
@@ -668,8 +668,8 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * @return Eviction filter or {@code null}.
      */
     @SuppressWarnings("unchecked")
-    public CacheEvictionFilter<K, V> getEvictionFilter() {
-        return (CacheEvictionFilter<K, V>)evictFilter;
+    public EvictionFilter<K, V> getEvictionFilter() {
+        return (EvictionFilter<K, V>)evictFilter;
     }
 
     /**
@@ -677,7 +677,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      *
      * @param evictFilter Eviction filter.
      */
-    public void setEvictionFilter(CacheEvictionFilter<K, V> evictFilter) {
+    public void setEvictionFilter(EvictionFilter<K, V> evictFilter) {
         this.evictFilter = evictFilter;
     }
 
@@ -689,7 +689,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * <p>
      * <b>Note</b> that this flag only matters for entries expiring based on
      * {@link ExpiryPolicy} and should not be confused with entry
-     * evictions based on configured {@link CacheEvictionPolicy}.
+     * evictions based on configured {@link EvictionPolicy}.
      *
      * @return Flag indicating whether Ignite will eagerly remove expired entries.
      */
@@ -792,7 +792,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      *
      * @return Key topology resolver to provide mapping from keys to nodes.
      */
-    public CacheAffinityFunction getAffinity() {
+    public AffinityFunction getAffinity() {
         return aff;
     }
 
@@ -801,7 +801,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      *
      * @param aff Cache key affinity.
      */
-    public void setAffinity(CacheAffinityFunction aff) {
+    public void setAffinity(AffinityFunction aff) {
         this.aff = aff;
     }
 
@@ -1231,7 +1231,7 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * For better efficiency user should usually make sure that new nodes get placed on
      * the same place of consistent hash ring as the left nodes, and that nodes are
      * restarted before this delay expires. To place nodes on the same place in consistent hash ring,
-     * use {@link CacheRendezvousAffinityFunction#setHashIdResolver(CacheAffinityNodeHashResolver)}
+     * use {@link RendezvousAffinityFunction#setHashIdResolver(AffinityNodeHashResolver)}
      * to make sure that a node maps to the same hash ID event if restarted. As an example,
      * node IP address and port combination may be used in this case.
      * <p>
@@ -1296,21 +1296,21 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
      * on the same node (they will also be backed up on the same nodes as well).
      * <p>
      * If not provided, then default implementation will be used. The default behavior
-     * is described in {@link CacheAffinityKeyMapper} documentation.
+     * is described in {@link AffinityKeyMapper} documentation.
      *
      * @return Mapper to use for affinity key mapping.
      */
-    public CacheAffinityKeyMapper getAffinityMapper() {
+    public AffinityKeyMapper getAffinityMapper() {
         return affMapper;
     }
 
     /**
      * Sets custom affinity mapper. If not provided, then default implementation will be used. The default behavior is
-     * described in {@link CacheAffinityKeyMapper} documentation.
+     * described in {@link AffinityKeyMapper} documentation.
      *
      * @param affMapper Affinity mapper.
      */
-    public void setAffinityMapper(CacheAffinityKeyMapper affMapper) {
+    public void setAffinityMapper(AffinityKeyMapper affMapper) {
         this.affMapper = affMapper;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/configuration/NearCacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/NearCacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/NearCacheConfiguration.java
index c77b352..0593601 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/NearCacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/NearCacheConfiguration.java
@@ -33,7 +33,7 @@ public class NearCacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     private static final long serialVersionUID = 0L;
 
     /** Near cache eviction policy. */
-    private CacheEvictionPolicy<K, V> nearEvictPlc;
+    private EvictionPolicy<K, V> nearEvictPlc;
 
     /** Default near cache start size. */
     private int nearStartSize = DFLT_NEAR_START_SIZE;
@@ -58,14 +58,14 @@ public class NearCacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /**
      * @return Near eviction policy.
      */
-    public CacheEvictionPolicy<K, V> getNearEvictionPolicy() {
+    public EvictionPolicy<K, V> getNearEvictionPolicy() {
         return nearEvictPlc;
     }
 
     /**
      * @param nearEvictPlc Near eviction policy.
      */
-    public void setNearEvictionPolicy(CacheEvictionPolicy<K, V> nearEvictPlc) {
+    public void setNearEvictionPolicy(EvictionPolicy<K, V> nearEvictPlc) {
         this.nearEvictPlc = nearEvictPlc;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4ba0b01a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
index 4422af7..c9c3b8d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
@@ -2575,7 +2575,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Override public <K> CacheAffinity<K> affinity(String cacheName) {
+    @Override public <K> Affinity<K> affinity(String cacheName) {
         GridCacheAdapter<K, ?> cache = ctx.cache().internalCache(cacheName);
 
         if (cache != null)


Mime
View raw message