ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [23/50] [abbrv] ignite git commit: IGNITE-6030 Allow enabling persistence per data region
Date Tue, 24 Oct 2017 08:47:30 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/DataRegionConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/DataRegionConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/DataRegionConfiguration.java
new file mode 100644
index 0000000..50edf5c
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/DataRegionConfiguration.java
@@ -0,0 +1,406 @@
+/*
+ * 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.configuration;
+
+import java.io.Serializable;
+import org.apache.ignite.DataRegionMetrics;
+import org.apache.ignite.internal.mem.IgniteOutOfMemoryException;
+import org.apache.ignite.mxbean.DataRegionMetricsMXBean;
+
+import static org.apache.ignite.configuration.DataStorageConfiguration.DFLT_DATA_REG_DEFAULT_NAME;
+
+/**
+ * This class allows defining custom data regions' configurations with various parameters for Apache Ignite
+ * page memory (see {@link DataStorageConfiguration}. For each configured data region Apache Ignite instantiates
+ * respective memory regions with different parameters like maximum size, eviction policy, swapping options,
+ * persistent mode flag, etc.
+ * An Apache Ignite cache can be mapped to a particular region using
+ * {@link CacheConfiguration#setDataRegionName(String)} method.
+ * <p>Sample configuration below shows how to configure several data regions:</p>
+ * <pre>
+ *     {@code
+ *     <property name="memoryConfiguration">
+ *         <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
+ *             <property name="defaultRegionConfiguration">
+ *                 <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
+ *                     <property name="name" value="Default_Region"/>
+ *                     <property name="initialSize" value="#{100 * 1024 * 1024}"/>
+ *                     <property name="maxSize" value="#{5 * 1024 * 102 * 1024}"/>
+ *                 </bean>
+ *             </property>
+ *
+ *             <property name="pageSize" value="4096"/>
+ *
+ *             <property name="dataRegions">
+ *                 <list>
+ *                      <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
+ *                          <property name="name" value="20MB_Region_Eviction"/>
+ *                          <property name="initialSize" value="#{20 * 1024 * 1024}"/>
+ *                          <property name="pageEvictionMode" value="RANDOM_2_LRU"/>
+ *                      </bean>
+ *
+ *                      <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
+ *                          <property name="name" value="25MB_Region_Swapping"/>
+ *                          <property name="initialSize" value="#{25 * 1024 * 1024}"/>
+ *                          <property name="initialSize" value="#{100 * 1024 * 1024}"/>
+ *                          <property name="swapPath" value="db/swap"/>
+ *                      </bean>
+ *                  </list>
+ *              </property>
+ *     }
+ * </pre>
+ */
+public final class DataRegionConfiguration implements Serializable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Default metrics enabled flag. */
+    public static final boolean DFLT_METRICS_ENABLED = false;
+
+    /** Default amount of sub intervals to calculate {@link DataRegionMetrics#getAllocationRate()} metric. */
+    public static final int DFLT_SUB_INTERVALS = 5;
+
+    /** Default length of interval over which {@link DataRegionMetrics#getAllocationRate()} metric is calculated. */
+    public static final int DFLT_RATE_TIME_INTERVAL_MILLIS = 60_000;
+
+    /** Data region name. */
+    private String name = DFLT_DATA_REG_DEFAULT_NAME;
+
+    /** Data region maximum size in memory. */
+    private long maxSize = DataStorageConfiguration.DFLT_DATA_REGION_MAX_SIZE;
+
+    /** Data region start size. */
+    private long initSize = Math.min(
+        DataStorageConfiguration.DFLT_DATA_REGION_MAX_SIZE, DataStorageConfiguration.DFLT_DATA_REGION_INITIAL_SIZE);
+
+    /** An optional path to a memory mapped files directory for this data region. */
+    private String swapPath;
+
+    /** An algorithm for memory pages eviction. */
+    private DataPageEvictionMode pageEvictionMode = DataPageEvictionMode.DISABLED;
+
+    /**
+     * A threshold for memory pages eviction initiation. For instance, if the threshold is 0.9 it means that the page
+     * memory will start the eviction only after 90% data region is occupied.
+     */
+    private double evictionThreshold = 0.9;
+
+    /** Minimum number of empty pages in reuse lists. */
+    private int emptyPagesPoolSize = 100;
+
+    /**
+     * Flag to enable the memory metrics collection for this data region.
+     */
+    private boolean metricsEnabled = DFLT_METRICS_ENABLED;
+
+    /** Number of sub-intervals the whole {@link #setMetricsRateTimeInterval(long)} will be split into to calculate
+     * {@link DataRegionMetrics#getAllocationRate()} and {@link DataRegionMetrics#getEvictionRate()} rates (5 by default).
+     * <p>
+     * Setting it to a bigger value will result in more precise calculation and smaller drops of
+     * {@link DataRegionMetrics#getAllocationRate()} metric when next sub-interval has to be recycled but introduces bigger
+     * calculation overhead. */
+    private int metricsSubIntervalCount = DFLT_SUB_INTERVALS;
+
+    /**
+     * Time interval (in milliseconds) for {@link DataRegionMetrics#getAllocationRate()}
+     * and {@link DataRegionMetrics#getEvictionRate()} monitoring purposes.
+     * <p>
+     * For instance, after setting the interval to 60_000 milliseconds, subsequent calls to {@link DataRegionMetrics#getAllocationRate()}
+     * will return average allocation rate (pages per second) for the last minute.
+     */
+    private long metricsRateTimeInterval = DFLT_RATE_TIME_INTERVAL_MILLIS;
+
+    /**
+     * Flag to enable Ignite Native Persistence.
+     */
+    private boolean persistenceEnabled = false;
+
+    /**
+     * Gets data region name.
+     *
+     * @return Data region name.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Sets data region name. The name must be non empty and must not be equal to the reserved 'sysMemPlc' one.
+     *
+     * If not specified, {@link DataStorageConfiguration#DFLT_DATA_REG_DEFAULT_NAME} value is used.
+     *
+     * @param name Data region name.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setName(String name) {
+        this.name = name;
+
+        return this;
+    }
+
+    /**
+     * Maximum memory region size defined by this data region. If the whole data can not fit into the memory region
+     * an out of memory exception will be thrown.
+     *
+     * @return Size in bytes.
+     */
+    public long getMaxSize() {
+        return maxSize;
+    }
+
+    /**
+     * Sets maximum memory region size defined by this data region. The total size should not be less than 10 MB
+     * due to the internal data structures overhead.
+     *
+     * @param maxSize Maximum data region size in bytes.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setMaxSize(long maxSize) {
+        this.maxSize = maxSize;
+
+        return this;
+    }
+
+    /**
+     * Gets initial memory region size defined by this data region. When the used memory size exceeds this value,
+     * new chunks of memory will be allocated.
+     *
+     * @return Data region start size.
+     */
+    public long getInitialSize() {
+        return initSize;
+    }
+
+    /**
+     * Sets initial memory region size defined by this data region. When the used memory size exceeds this value,
+     * new chunks of memory will be allocated.
+     *
+     * @param initSize Data region initial size.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setInitialSize(long initSize) {
+        this.initSize = initSize;
+
+        return this;
+    }
+
+    /**
+     * A path to the memory-mapped files the memory region defined by this data region will be mapped to. Having
+     * the path set, allows relying on swapping capabilities of an underlying operating system for the memory region.
+     *
+     * @return A path to the memory-mapped files or {@code null} if this feature is not used for the memory region
+     *         defined by this data region.
+     */
+    public String getSwapPath() {
+        return swapPath;
+    }
+
+    /**
+     * Sets a path to the memory-mapped files.
+     *
+     * @param swapFilePath A Path to the memory mapped file.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setSwapPath(String swapFilePath) {
+        this.swapPath = swapFilePath;
+
+        return this;
+    }
+
+    /**
+     * Gets memory pages eviction mode. If {@link DataPageEvictionMode#DISABLED} is used (default) then an out of
+     * memory exception will be thrown if the memory region usage, defined by this data region, goes beyond its
+     * capacity which is {@link #getMaxSize()}.
+     *
+     * @return Memory pages eviction algorithm. {@link DataPageEvictionMode#DISABLED} used by default.
+     */
+    public DataPageEvictionMode getPageEvictionMode() {
+        return pageEvictionMode;
+    }
+
+    /**
+     * Sets memory pages eviction mode.
+     *
+     * @param evictionMode Eviction mode.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setPageEvictionMode(DataPageEvictionMode evictionMode) {
+        pageEvictionMode = evictionMode;
+
+        return this;
+    }
+
+    /**
+     * Gets a threshold for memory pages eviction initiation. For instance, if the threshold is 0.9 it means that the
+     * page memory will start the eviction only after 90% of the data region is occupied.
+     *
+     * @return Memory pages eviction threshold.
+     */
+    public double getEvictionThreshold() {
+        return evictionThreshold;
+    }
+
+    /**
+     * Sets memory pages eviction threshold.
+     *
+     * @param evictionThreshold Eviction threshold.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setEvictionThreshold(double evictionThreshold) {
+        this.evictionThreshold = evictionThreshold;
+
+        return this;
+    }
+
+    /**
+     * Specifies the minimal number of empty pages to be present in reuse lists for this data region.
+     * This parameter ensures that Ignite will be able to successfully evict old data entries when the size of
+     * (key, value) pair is slightly larger than page size / 2.
+     * Increase this parameter if cache can contain very big entries (total size of pages in this pool should be enough
+     * to contain largest cache entry).
+     * Increase this parameter if {@link IgniteOutOfMemoryException} occurred with enabled page eviction.
+     *
+     * @return Minimum number of empty pages in reuse list.
+     */
+    public int getEmptyPagesPoolSize() {
+        return emptyPagesPoolSize;
+    }
+
+    /**
+     * Specifies the minimal number of empty pages to be present in reuse lists for this data region.
+     * This parameter ensures that Ignite will be able to successfully evict old data entries when the size of
+     * (key, value) pair is slightly larger than page size / 2.
+     * Increase this parameter if cache can contain very big entries (total size of pages in this pool should be enough
+     * to contain largest cache entry).
+     * Increase this parameter if {@link IgniteOutOfMemoryException} occurred with enabled page eviction.
+     *
+     * @param emptyPagesPoolSize Empty pages pool size.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setEmptyPagesPoolSize(int emptyPagesPoolSize) {
+        this.emptyPagesPoolSize = emptyPagesPoolSize;
+
+        return this;
+    }
+
+    /**
+     * Gets whether memory metrics are enabled by default on node startup. Memory metrics can be enabled and disabled
+     * at runtime via memory metrics {@link DataRegionMetricsMXBean MX bean}.
+     *
+     * @return Metrics enabled flag.
+     */
+    public boolean isMetricsEnabled() {
+        return metricsEnabled;
+    }
+
+    /**
+     * Sets memory metrics enabled flag. If this flag is {@code true}, metrics will be enabled on node startup.
+     * Memory metrics can be enabled and disabled at runtime via memory metrics {@link DataRegionMetricsMXBean MX bean}.
+     *
+     * @param metricsEnabled Metrics enabled flag.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setMetricsEnabled(boolean metricsEnabled) {
+        this.metricsEnabled = metricsEnabled;
+
+        return this;
+    }
+
+    /**
+     * Gets whether persistence is enabled for this data region. All caches residing in this region will be persistent.
+     *
+     * @return Persistence enabled flag.
+     */
+    public boolean isPersistenceEnabled() {
+        return persistenceEnabled;
+    }
+
+    /**
+     * Sets persistence enabled flag.
+     *
+     * @param persistenceEnabled Persistence enabled flag.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setPersistenceEnabled(boolean persistenceEnabled) {
+        this.persistenceEnabled = persistenceEnabled;
+
+        return this;
+    }
+
+    /**
+     * Gets time interval for {@link DataRegionMetrics#getAllocationRate()}
+     * and {@link DataRegionMetrics#getEvictionRate()} monitoring purposes.
+     * <p>
+     * For instance, after setting the interval to 60_000 milliseconds,
+     * subsequent calls to {@link DataRegionMetrics#getAllocationRate()}
+     * will return average allocation rate (pages per second) for the last minute.
+     *
+     * @return Time interval over which allocation rate is calculated.
+     */
+    public long getMetricsRateTimeInterval() {
+        return metricsRateTimeInterval;
+    }
+
+    /**
+     * Sets time interval for {@link DataRegionMetrics#getAllocationRate()}
+     * and {@link DataRegionMetrics#getEvictionRate()} monitoring purposes.
+     * <p>
+     * For instance, after setting the interval to 60 seconds,
+     * subsequent calls to {@link DataRegionMetrics#getAllocationRate()}
+     * will return average allocation rate (pages per second) for the last minute.
+     *
+     * @param metricsRateTimeInterval Time interval used for allocation and eviction rates calculations.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setMetricsRateTimeInterval(long metricsRateTimeInterval) {
+        this.metricsRateTimeInterval = metricsRateTimeInterval;
+
+        return this;
+    }
+
+    /**
+     * Gets a number of sub-intervals the whole {@link #setMetricsRateTimeInterval(long)}
+     * will be split into to calculate {@link DataRegionMetrics#getAllocationRate()}
+     * and {@link DataRegionMetrics#getEvictionRate()} rates (5 by default).
+     * <p>
+     * Setting it to a bigger value will result in more precise calculation and smaller drops of
+     * {@link DataRegionMetrics#getAllocationRate()} metric when next sub-interval has to be recycled but introduces bigger
+     * calculation overhead.
+     *
+     * @return number of sub intervals.
+     */
+    public int getMetricsSubIntervalCount() {
+        return metricsSubIntervalCount;
+    }
+
+    /**
+     * Sets a number of sub-intervals the whole {@link #setMetricsRateTimeInterval(long)} will be split into to calculate
+     * {@link DataRegionMetrics#getAllocationRate()} and {@link DataRegionMetrics#getEvictionRate()} rates (5 by default).
+     * <p>
+     * Setting it to a bigger value will result in more precise calculation and smaller drops of
+     * {@link DataRegionMetrics#getAllocationRate()} metric when next sub-interval has to be recycled but introduces bigger
+     * calculation overhead.
+     *
+     * @param metricsSubIntervalCnt A number of sub-intervals.
+     * @return {@code this} for chaining.
+     */
+    public DataRegionConfiguration setMetricsSubIntervalCount(int metricsSubIntervalCnt) {
+        this.metricsSubIntervalCount = metricsSubIntervalCnt;
+
+        return this;
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/DataStorageConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/DataStorageConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/DataStorageConfiguration.java
new file mode 100644
index 0000000..bd314ab
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/DataStorageConfiguration.java
@@ -0,0 +1,882 @@
+/*
+ * 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.configuration;
+
+import java.io.Serializable;
+import org.apache.ignite.IgniteSystemProperties;
+import org.apache.ignite.internal.processors.cache.persistence.file.AsyncFileIOFactory;
+import org.apache.ignite.internal.processors.cache.persistence.file.FileIOFactory;
+import org.apache.ignite.internal.processors.cache.persistence.file.RandomAccessFileIOFactory;
+import org.apache.ignite.internal.util.typedef.internal.A;
+import org.apache.ignite.internal.util.typedef.internal.U;
+
+/**
+ * A durable memory configuration for an Apache Ignite node. The durable memory is a manageable off-heap based memory
+ * architecture that divides all expandable data regions into pages of fixed size
+ * (see {@link DataStorageConfiguration#getPageSize()}). An individual page can store one or many cache key-value entries
+ * that allows reusing the memory in the most efficient way and avoid memory fragmentation issues.
+ * <p>
+ * By default, the durable memory allocates a single expandable data region with default settings. All the caches that
+ * will be configured in an application will be mapped to this data region by default, thus, all the cache data will
+ * reside in that data region. Parameters of default data region can be changed by setting
+ * {@link DataStorageConfiguration#setDefaultDataRegionConfiguration(DataRegionConfiguration)}.
+ * Other data regions (except default) can be configured with
+ * {@link DataStorageConfiguration#setDataRegionConfigurations(DataRegionConfiguration...)}.
+ * <p>
+ * Data region can be used in memory-only mode, or in persistent mode, when memory is used as a caching layer for disk.
+ * Persistence for data region can be turned on with {@link DataRegionConfiguration#setPersistenceEnabled(boolean)}
+ * flag. To learn more about data regions refer to {@link DataRegionConfiguration} documentation.
+ * <p>Sample configuration below shows how to make 5 GB data regions the default one for Apache Ignite:</p>
+ * <pre>
+ *     {@code
+ *
+ *     <property name="dataStorageConfiguration">
+ *         <bean class="org.apache.ignite.configuration.DataStorageConfiguration">
+ *             <property name="systemCacheInitialSize" value="#{100 * 1024 * 1024}"/>
+ *
+ *             <property name="defaultDataRegionConfiguration">
+ *                 <bean class="org.apache.ignite.configuration.DataRegionConfiguration">
+ *                     <property name="name" value="default_data_region"/>
+ *                     <property name="initialSize" value="#{5 * 1024 * 1024 * 1024}"/>
+ *                 </bean>
+ *             </property>
+ *         </bean>
+ *     </property>
+ *     }
+ * </pre>
+ */
+public class DataStorageConfiguration implements Serializable {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /** Default data region start size (256 MB). */
+    @SuppressWarnings("UnnecessaryBoxing")
+    public static final long DFLT_DATA_REGION_INITIAL_SIZE = 256L * 1024 * 1024;
+
+    /** Fraction of available memory to allocate for default DataRegion. */
+    private static final double DFLT_DATA_REGION_FRACTION = 0.2;
+
+    /** Default data region's size is 20% of physical memory available on current machine. */
+    public static final long DFLT_DATA_REGION_MAX_SIZE = Math.max(
+        (long)(DFLT_DATA_REGION_FRACTION * U.getTotalMemoryAvailable()),
+        DFLT_DATA_REGION_INITIAL_SIZE);
+
+    /** Default initial size of a memory chunk for the system cache (40 MB). */
+    private static final long DFLT_SYS_CACHE_INIT_SIZE = 40 * 1024 * 1024;
+
+    /** Default max size of a memory chunk for the system cache (100 MB). */
+    private static final long DFLT_SYS_CACHE_MAX_SIZE = 100 * 1024 * 1024;
+
+    /** Default memory page size. */
+    public static final int DFLT_PAGE_SIZE = 4 * 1024;
+
+    /** This name is assigned to default Dataregion if no user-defined default MemPlc is specified */
+    public static final String DFLT_DATA_REG_DEFAULT_NAME = "default";
+
+    /** */
+    public static final int DFLT_CHECKPOINT_FREQ = 180000;
+
+    /** Lock default wait time, 10 sec. */
+    public static final int DFLT_LOCK_WAIT_TIME = 10 * 1000;
+
+    /** */
+    public static final boolean DFLT_METRICS_ENABLED = false;
+
+    /** Default amount of sub intervals to calculate rate-based metric. */
+    public static final int DFLT_SUB_INTERVALS = 5;
+
+    /** Default length of interval over which rate-based metric is calculated. */
+    public static final int DFLT_RATE_TIME_INTERVAL_MILLIS = 60_000;
+
+    /** Default number of checkpoint threads. */
+    public static final int DFLT_CHECKPOINT_THREADS = 4;
+
+    /** Default checkpoint write order. */
+    public static final CheckpointWriteOrder DFLT_CHECKPOINT_WRITE_ORDER = CheckpointWriteOrder.SEQUENTIAL;
+
+    /** Default number of checkpoints to be kept in WAL after checkpoint is finished */
+    public static final int DFLT_WAL_HISTORY_SIZE = 20;
+
+    /** */
+    public static final int DFLT_WAL_SEGMENTS = 10;
+
+    /** Default WAL file segment size, 64MBytes */
+    public static final int DFLT_WAL_SEGMENT_SIZE = 64 * 1024 * 1024;
+
+    /** Default wal mode. */
+    public static final WALMode DFLT_WAL_MODE = WALMode.DEFAULT;
+
+    /** Default thread local buffer size. */
+    public static final int DFLT_TLB_SIZE = 128 * 1024;
+
+    /** Default Wal flush frequency. */
+    public static final int DFLT_WAL_FLUSH_FREQ = 2000;
+
+    /** Default wal fsync delay. */
+    public static final int DFLT_WAL_FSYNC_DELAY = 1000;
+
+    /** Default wal record iterator buffer size. */
+    public static final int DFLT_WAL_RECORD_ITERATOR_BUFFER_SIZE = 64 * 1024 * 1024;
+
+    /** Default wal always write full pages. */
+    public static final boolean DFLT_WAL_ALWAYS_WRITE_FULL_PAGES = false;
+
+    /** Default wal directory. */
+    public static final String DFLT_WAL_PATH = "db/wal";
+
+    /** Default wal archive directory. */
+    public static final String DFLT_WAL_ARCHIVE_PATH = "db/wal/archive";
+
+    /** Default write throttling enabled. */
+    public static final boolean DFLT_WRITE_THROTTLING_ENABLED = false;
+
+    /** Size of a memory chunk reserved for system cache initially. */
+    private long sysRegionInitSize = DFLT_SYS_CACHE_INIT_SIZE;
+
+    /** Maximum size of system cache. */
+    private long sysCacheMaxSize = DFLT_SYS_CACHE_MAX_SIZE;
+
+    /** Memory page size. */
+    private int pageSize;
+
+    /** Concurrency level. */
+    private int concLvl;
+
+    /** Configuration of default data region. */
+    private DataRegionConfiguration dfltDataRegConf = new DataRegionConfiguration();
+
+    /** Data regions. */
+    private DataRegionConfiguration[] dataRegions;
+
+    /** Directory where index and partition files are stored. */
+    private String storagePath;
+
+    /** Checkpoint frequency. */
+    private long checkpointFreq = DFLT_CHECKPOINT_FREQ;
+
+    /** Lock wait time, in milliseconds. */
+    private long lockWaitTime = DFLT_LOCK_WAIT_TIME;
+
+    /** */
+    private long checkpointPageBufSize;
+
+    /** */
+    private int checkpointThreads = DFLT_CHECKPOINT_THREADS;
+
+    /** Checkpoint write order. */
+    private CheckpointWriteOrder checkpointWriteOrder = DFLT_CHECKPOINT_WRITE_ORDER;
+
+    /** Number of checkpoints to keep */
+    private int walHistSize = DFLT_WAL_HISTORY_SIZE;
+
+    /** Number of work WAL segments. */
+    private int walSegments = DFLT_WAL_SEGMENTS;
+
+    /** Size of one WAL segment in bytes. 64 Mb is used by default.  Maximum value is 2Gb */
+    private int walSegmentSize = DFLT_WAL_SEGMENT_SIZE;
+
+    /** Directory where WAL is stored (work directory) */
+    private String walPath = DFLT_WAL_PATH;
+
+    /** WAL archive path. */
+    private String walArchivePath = DFLT_WAL_ARCHIVE_PATH;
+
+    /** Metrics enabled flag. */
+    private boolean metricsEnabled = DFLT_METRICS_ENABLED;
+
+    /** Wal mode. */
+    private WALMode walMode = DFLT_WAL_MODE;
+
+    /** WAl thread local buffer size. */
+    private int walTlbSize = DFLT_TLB_SIZE;
+
+    /** Wal flush frequency in milliseconds. */
+    private long walFlushFreq = DFLT_WAL_FLUSH_FREQ;
+
+    /** Wal fsync delay. */
+    private long walFsyncDelay = DFLT_WAL_FSYNC_DELAY;
+
+    /** Wal record iterator buffer size. */
+    private int walRecordIterBuffSize = DFLT_WAL_RECORD_ITERATOR_BUFFER_SIZE;
+
+    /** Always write full pages. */
+    private boolean alwaysWriteFullPages = DFLT_WAL_ALWAYS_WRITE_FULL_PAGES;
+
+    /** Factory to provide I/O interface for files */
+    private FileIOFactory fileIOFactory =
+        IgniteSystemProperties.getBoolean(IgniteSystemProperties.IGNITE_USE_ASYNC_FILE_IO_FACTORY, false) ?
+            new AsyncFileIOFactory() : new RandomAccessFileIOFactory();
+
+    /**
+     * Number of sub-intervals the whole {@link #setMetricsRateTimeInterval(long)} will be split into to calculate
+     * rate-based metrics.
+     * <p>
+     * Setting it to a bigger value will result in more precise calculation and smaller drops of
+     * rate-based metrics when next sub-interval has to be recycled but introduces bigger
+     * calculation overhead.
+     */
+    private int metricsSubIntervalCount = DFLT_SUB_INTERVALS;
+
+    /** Time interval (in milliseconds) for rate-based metrics. */
+    private long metricsRateTimeInterval = DFLT_RATE_TIME_INTERVAL_MILLIS;
+
+    /**
+     *  Time interval (in milliseconds) for running auto archiving for incompletely WAL segment
+     */
+    private long walAutoArchiveAfterInactivity = -1;
+
+    /**
+     * If true, threads that generate dirty pages too fast during ongoing checkpoint will be throttled.
+     */
+    private boolean writeThrottlingEnabled = DFLT_WRITE_THROTTLING_ENABLED;
+
+    /**
+     * Initial size of a data region reserved for system cache.
+     *
+     * @return Size in bytes.
+     */
+    public long getSystemRegionInitialSize() {
+        return sysRegionInitSize;
+    }
+
+    /**
+     * Sets initial size of a data region reserved for system cache.
+     *
+     * Default value is {@link #DFLT_SYS_CACHE_INIT_SIZE}
+     *
+     * @param sysRegionInitSize Size in bytes.
+     *
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setSystemRegionInitialSize(long sysRegionInitSize) {
+        A.ensure(sysCacheMaxSize > 0, "System region initial size can not be less zero.");
+
+        this.sysRegionInitSize = sysRegionInitSize;
+
+        return this;
+    }
+
+    /**
+     * Maximum data region size reserved for system cache.
+     *
+     * @return Size in bytes.
+     */
+    public long getSystemRegionMaxSize() {
+        return sysCacheMaxSize;
+    }
+
+    /**
+     * Sets maximum data region size reserved for system cache. The total size should not be less than 10 MB
+     * due to internal data structures overhead.
+     *
+     * @param sysCacheMaxSize Maximum size in bytes for system cache data region.
+     *
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setSystemRegionMaxSize(long sysCacheMaxSize) {
+        A.ensure(sysCacheMaxSize > 0, "System cache max size can not be less zero.");
+
+        this.sysCacheMaxSize = sysCacheMaxSize;
+
+        return this;
+    }
+
+    /**
+     * The page memory consists of one or more expandable data regions defined by {@link DataRegionConfiguration}.
+     * Every data region is split on pages of fixed size that store actual cache entries.
+     *
+     * @return Page size in bytes.
+     */
+    public int getPageSize() {
+        return pageSize;
+    }
+
+    /**
+     * Changes the page size.
+     *
+     * @param pageSize Page size in bytes. If value is not set (or zero), {@link #DFLT_PAGE_SIZE} will be used.
+     */
+    public DataStorageConfiguration setPageSize(int pageSize) {
+        if (pageSize != 0) {
+            A.ensure(pageSize >= 1024 && pageSize <= 16 * 1024, "Page size must be between 1kB and 16kB.");
+            A.ensure(U.isPow2(pageSize), "Page size must be a power of 2.");
+        }
+
+        this.pageSize = pageSize;
+
+        return this;
+    }
+
+    /**
+     * Gets an array of all data regions configured. Apache Ignite will instantiate a dedicated data region per
+     * region. An Apache Ignite cache can be mapped to a specific region with
+     * {@link CacheConfiguration#setDataRegionName(String)} method.
+     *
+     * @return Array of configured data regions.
+     */
+    public DataRegionConfiguration[] getDataRegionConfigurations() {
+        return dataRegions;
+    }
+
+    /**
+     * Sets data regions configurations.
+     *
+     * @param dataRegionConfigurations Data regions configurations.
+     */
+    public DataStorageConfiguration setDataRegionConfigurations(DataRegionConfiguration... dataRegionConfigurations) {
+        this.dataRegions = dataRegionConfigurations;
+
+        return this;
+    }
+
+    /**
+     * Returns the number of concurrent segments in Ignite internal page mapping tables. By default equals
+     * to the number of available CPUs.
+     *
+     * @return Mapping table concurrency level.
+     */
+    public int getConcurrencyLevel() {
+        return concLvl;
+    }
+
+    /**
+     * Sets the number of concurrent segments in Ignite internal page mapping tables.
+     *
+     * @param concLvl Mapping table concurrency level.
+     */
+    public DataStorageConfiguration setConcurrencyLevel(int concLvl) {
+        this.concLvl = concLvl;
+
+        return this;
+    }
+
+    /**
+     * @return Configuration of default data region. All cache groups will reside in this data region by default.
+     * For assigning a custom data region to cache group, use {@link CacheConfiguration#setDataRegionName(String)}.
+     */
+    public DataRegionConfiguration getDefaultDataRegionConfiguration() {
+        return dfltDataRegConf;
+    }
+
+    /**
+     * Overrides configuration of default data region which is created automatically.
+     * @param dfltDataRegConf Default data region configuration.
+     */
+    public DataStorageConfiguration setDefaultDataRegionConfiguration(DataRegionConfiguration dfltDataRegConf) {
+        this.dfltDataRegConf = dfltDataRegConf;
+
+        return this;
+    }
+
+    /**
+     * Returns a path the root directory where the Persistent Store will persist data and indexes.
+     */
+    public String getStoragePath() {
+        return storagePath;
+    }
+
+    /**
+     * Sets a path to the root directory where the Persistent Store will persist data and indexes.
+     * By default the Persistent Store's files are located under Ignite work directory.
+     *
+     * @param persistenceStorePath Persistence store path.
+     */
+    public DataStorageConfiguration setStoragePath(String persistenceStorePath) {
+        this.storagePath = persistenceStorePath;
+
+        return this;
+    }
+
+    /**
+     * Gets checkpoint frequency.
+     *
+     * @return checkpoint frequency in milliseconds.
+     */
+    public long getCheckpointFrequency() {
+        return checkpointFreq <= 0 ? DFLT_CHECKPOINT_FREQ : checkpointFreq;
+    }
+
+    /**
+     * Sets the checkpoint frequency which is a minimal interval when the dirty pages will be written
+     * to the Persistent Store. If the rate is high, checkpoint will be triggered more frequently.
+     *
+     * @param checkpointFreq checkpoint frequency in milliseconds.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setCheckpointFrequency(long checkpointFreq) {
+        this.checkpointFreq = checkpointFreq;
+
+        return this;
+    }
+
+    /**
+     * Gets amount of memory allocated for a checkpoint temporary buffer.
+     *
+     * @return Checkpoint page buffer size in bytes or {@code 0} for Ignite
+     *      to choose the buffer size automatically.
+     */
+    public long getCheckpointPageBufferSize() {
+        return checkpointPageBufSize;
+    }
+
+    /**
+     * Sets amount of memory allocated for the checkpoint temporary buffer. The buffer is used to create temporary
+     * copies of pages that are being written to disk and being update in parallel while the checkpoint is in
+     * progress.
+     *
+     * @param checkpointPageBufSize Checkpoint page buffer size in bytes or {@code 0} for Ignite to
+     *      choose the buffer size automatically.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setCheckpointPageBufferSize(long checkpointPageBufSize) {
+        this.checkpointPageBufSize = checkpointPageBufSize;
+
+        return this;
+    }
+
+
+    /**
+     * Gets a number of threads to use for the checkpoint purposes.
+     *
+     * @return Number of checkpoint threads.
+     */
+    public int getCheckpointThreads() {
+        return checkpointThreads;
+    }
+
+    /**
+     * Sets a number of threads to use for the checkpoint purposes.
+     *
+     * @param checkpointThreads Number of checkpoint threads. Four threads are used by default.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setCheckpointThreads(int checkpointThreads) {
+        this.checkpointThreads = checkpointThreads;
+
+        return this;
+    }
+
+    /**
+     * Timeout in milliseconds to wait when acquiring persistence store lock file before failing the local node.
+     *
+     * @return Lock wait time in milliseconds.
+     */
+    public long getLockWaitTime() {
+        return lockWaitTime;
+    }
+
+    /**
+     * Timeout in milliseconds to wait when acquiring persistence store lock file before failing the local node.
+     *
+     * @param lockWaitTime Lock wait time in milliseconds.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setLockWaitTime(long lockWaitTime) {
+        this.lockWaitTime = lockWaitTime;
+
+        return this;
+    }
+
+    /**
+     * Gets a total number of checkpoints to keep in the WAL history.
+     *
+     * @return Number of checkpoints to keep in WAL after a checkpoint is finished.
+     */
+    public int getWalHistorySize() {
+        return walHistSize <= 0 ? DFLT_WAL_HISTORY_SIZE : walHistSize;
+    }
+
+    /**
+     * Sets a total number of checkpoints to keep in the WAL history.
+     *
+     * @param walHistSize Number of checkpoints to keep after a checkpoint is finished.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setWalHistorySize(int walHistSize) {
+        this.walHistSize = walHistSize;
+
+        return this;
+    }
+
+    /**
+     * Gets a number of WAL segments to work with.
+     *
+     * @return Number of work WAL segments.
+     */
+    public int getWalSegments() {
+        return walSegments <= 0 ? DFLT_WAL_SEGMENTS : walSegments;
+    }
+
+    /**
+     * Sets a number of WAL segments to work with. For performance reasons,
+     * the whole WAL is split into files of fixed length called segments.
+     *
+     * @param walSegments Number of WAL segments.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setWalSegments(int walSegments) {
+        this.walSegments = walSegments;
+
+        return this;
+    }
+
+    /**
+     * Gets size of a WAL segment in bytes.
+     *
+     * @return WAL segment size.
+     */
+    public int getWalSegmentSize() {
+        return walSegmentSize <= 0 ? DFLT_WAL_SEGMENT_SIZE : walSegmentSize;
+    }
+
+    /**
+     * Sets size of a WAL segment.
+     *
+     * @param walSegmentSize WAL segment size. 64 MB is used by default.  Maximum value is 2Gb
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setWalSegmentSize(int walSegmentSize) {
+        this.walSegmentSize = walSegmentSize;
+
+        return this;
+    }
+
+    /**
+     * Gets a path to the directory where WAL is stored.
+     *
+     * @return WAL persistence path, absolute or relative to Ignite work directory.
+     */
+    public String getWalPath() {
+        return walPath;
+    }
+
+    /**
+     * Sets a path to the directory where WAL is stored. If this path is relative, it will be resolved
+     * relatively to Ignite work directory.
+     *
+     * @param walStorePath WAL persistence path, absolute or relative to Ignite work directory.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setWalPath(String walStorePath) {
+        this.walPath = walStorePath;
+
+        return this;
+    }
+
+    /**
+     * Gets a path to the WAL archive directory.
+     *
+     *  @return WAL archive directory.
+     */
+    public String getWalArchivePath() {
+        return walArchivePath;
+    }
+
+    /**
+     * Sets a path for the WAL archive directory. Every WAL segment will be fully copied to this directory before
+     * it can be reused for WAL purposes.
+     *
+     * @param walArchivePath WAL archive directory.
+     * @return {@code this} for chaining.
+     */
+    public DataStorageConfiguration setWalArchivePath(String walArchivePath) {
+        this.walArchivePath = walArchivePath;
+
+        return this;
+    }
+
+    /**
+     * Gets flag indicating whether persistence metrics collection is enabled.
+     * Default value is {@link #DFLT_METRICS_ENABLED}.
+     *
+     * @return Metrics enabled flag.
+     */
+    public boolean isMetricsEnabled() {
+        return metricsEnabled;
+    }
+
+    /**
+     * Sets flag indicating whether persistence metrics collection is enabled.
+     *
+     * @param metricsEnabled Metrics enabled flag.
+     */
+    public DataStorageConfiguration setMetricsEnabled(boolean metricsEnabled) {
+        this.metricsEnabled = metricsEnabled;
+
+        return this;
+    }
+
+    /**
+     * Gets flag indicating whether write throttling is enabled.
+     */
+    public boolean isWriteThrottlingEnabled() {
+        return writeThrottlingEnabled;
+    }
+
+    /**
+     * Sets flag indicating whether write throttling is enabled.
+     *
+     * @param writeThrottlingEnabled Write throttling enabled flag.
+     */
+    public DataStorageConfiguration setWriteThrottlingEnabled(boolean writeThrottlingEnabled) {
+        this.writeThrottlingEnabled = writeThrottlingEnabled;
+
+        return this;
+    }
+
+    /**
+     * Gets the length of the time interval for rate-based metrics. This interval defines a window over which
+     * hits will be tracked. Default value is {@link #DFLT_RATE_TIME_INTERVAL_MILLIS}.
+     *
+     * @return Time interval in milliseconds.
+     */
+    public long getMetricsRateTimeInterval() {
+        return metricsRateTimeInterval;
+    }
+
+    /**
+     * Sets the length of the time interval for rate-based metrics. This interval defines a window over which
+     * hits will be tracked.
+     *
+     * @param metricsRateTimeInterval Time interval in milliseconds.
+     */
+    public DataStorageConfiguration setMetricsRateTimeInterval(long metricsRateTimeInterval) {
+        this.metricsRateTimeInterval = metricsRateTimeInterval;
+
+        return this;
+    }
+
+    /**
+     * Gets the number of sub-intervals to split the {@link #getMetricsRateTimeInterval()} into to track the update history.
+     * Default value is {@link #DFLT_SUB_INTERVALS}.
+     *
+     * @return The number of sub-intervals for history tracking.
+     */
+    public int getMetricsSubIntervalCount() {
+        return metricsSubIntervalCount;
+    }
+
+    /**
+     * Sets the number of sub-intervals to split the {@link #getMetricsRateTimeInterval()} into to track the update history.
+     *
+     * @param metricsSubIntervalCnt The number of sub-intervals for history tracking.
+     */
+    public DataStorageConfiguration setMetricsSubIntervalCount(int metricsSubIntervalCnt) {
+        this.metricsSubIntervalCount = metricsSubIntervalCnt;
+
+        return this;
+    }
+
+    /**
+     * Property that defines behavior of wal fsync.
+     * Different type provides different guarantees for consistency. See {@link WALMode} for details.
+     *
+     * @return WAL mode.
+     */
+    public WALMode getWalMode() {
+        return walMode == null ? DFLT_WAL_MODE : walMode;
+    }
+
+    /**
+     * Sets property that defines behavior of wal fsync.
+     * Different type provides different guarantees for consistency. See {@link WALMode} for details.
+     *
+     * @param walMode Wal mode.
+     */
+    public DataStorageConfiguration setWalMode(WALMode walMode) {
+        this.walMode = walMode;
+
+        return this;
+    }
+
+    /**
+     * Property for size of thread local buffer.
+     * Each thread which write to wal have thread local buffer for serialize recode before write in wal.
+     *
+     * @return Thread local buffer size (in bytes).
+     */
+    public int getWalThreadLocalBufferSize() {
+        return walTlbSize <= 0 ? DFLT_TLB_SIZE : walTlbSize;
+    }
+
+    /**
+     * Sets size of thread local buffer.
+     * Each thread which write to wal have thread local buffer for serialize recode before write in wal.
+     *
+     * @param walTlbSize Thread local buffer size (in bytes).
+     */
+    public DataStorageConfiguration setWalThreadLocalBufferSize(int walTlbSize) {
+        this.walTlbSize = walTlbSize;
+
+        return this;
+    }
+
+    /**
+     *  This property define how often WAL will be fsync-ed in {@code BACKGROUND} mode. Ignored for
+     *  all other WAL modes.
+     *
+     * @return WAL flush frequency, in milliseconds.
+     */
+    public long getWalFlushFrequency() {
+        return walFlushFreq;
+    }
+
+    /**
+     *  This property define how often WAL will be fsync-ed in {@code BACKGROUND} mode. Ignored for
+     *  all other WAL modes.
+     *
+     * @param walFlushFreq WAL flush frequency, in milliseconds.
+     */
+    public DataStorageConfiguration setWalFlushFrequency(long walFlushFreq) {
+        this.walFlushFreq = walFlushFreq;
+
+        return this;
+    }
+
+    /**
+     * Property that allows to trade latency for throughput in {@link WALMode#DEFAULT} mode.
+     * It limits minimum time interval between WAL fsyncs. First thread that initiates WAL fsync will wait for
+     * this number of nanoseconds, another threads will just wait fsync of first thread (similar to CyclicBarrier).
+     * Total throughput should increase under load as total WAL fsync rate will be limited.
+     */
+    public long getWalFsyncDelayNanos() {
+        return walFsyncDelay <= 0 ? DFLT_WAL_FSYNC_DELAY : walFsyncDelay;
+    }
+
+    /**
+     * Sets property that allows to trade latency for throughput in {@link WALMode#DEFAULT} mode.
+     * It limits minimum time interval between WAL fsyncs. First thread that initiates WAL fsync will wait for
+     * this number of nanoseconds, another threads will just wait fsync of first thread (similar to CyclicBarrier).
+     * Total throughput should increase under load as total WAL fsync rate will be limited.
+     *
+     * @param walFsyncDelayNanos Wal fsync delay, in nanoseconds.
+     */
+    public DataStorageConfiguration setWalFsyncDelayNanos(long walFsyncDelayNanos) {
+        walFsyncDelay = walFsyncDelayNanos;
+
+        return this;
+    }
+
+    /**
+     * Property define how many bytes iterator read from
+     * disk (for one reading), during go ahead wal.
+     *
+     * @return Record iterator buffer size.
+     */
+    public int getWalRecordIteratorBufferSize() {
+        return walRecordIterBuffSize <= 0 ? DFLT_WAL_RECORD_ITERATOR_BUFFER_SIZE : walRecordIterBuffSize;
+    }
+
+    /**
+     * Sets property defining how many bytes iterator read from
+     * disk (for one reading), during go ahead wal.
+     *
+     * @param walRecordIterBuffSize Wal record iterator buffer size.
+     */
+    public DataStorageConfiguration setWalRecordIteratorBufferSize(int walRecordIterBuffSize) {
+        this.walRecordIterBuffSize = walRecordIterBuffSize;
+
+        return this;
+    }
+
+    /**
+     * Gets flag that enforces writing full page to WAL on every change (instead of delta record).
+     * Can be used for debugging purposes: every version of page will be present in WAL.
+     * Note that WAL will take several times more space in this mode.
+     */
+    public boolean isAlwaysWriteFullPages() {
+        return alwaysWriteFullPages;
+    }
+
+    /**
+     * Sets flag that enforces writing full page to WAL on every change (instead of delta record).
+     * Can be used for debugging purposes: every version of page will be present in WAL.
+     * Note that WAL will take several times more space in this mode.
+     *
+     * @param alwaysWriteFullPages Always write full pages flag.
+     */
+    public DataStorageConfiguration setAlwaysWriteFullPages(boolean alwaysWriteFullPages) {
+        this.alwaysWriteFullPages = alwaysWriteFullPages;
+
+        return this;
+    }
+
+    /**
+     * Factory to provide implementation of FileIO interface
+     * which is used for any file read/write operations
+     *
+     * @return File I/O factory
+     */
+    public FileIOFactory getFileIOFactory() {
+        return fileIOFactory;
+    }
+
+    /**
+     * Sets factory to provide implementation of FileIO interface
+     * which is used for any file read/write operations
+     *
+     * @param fileIOFactory File I/O factory
+     */
+    public DataStorageConfiguration setFileIOFactory(FileIOFactory fileIOFactory) {
+        this.fileIOFactory = fileIOFactory;
+
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> setting this value with {@link WALMode#DEFAULT} may generate file size overhead for WAL segments in case
+     * grid is used rarely.
+     *
+     * @param walAutoArchiveAfterInactivity time in millis to run auto archiving segment (even if incomplete) after last
+     * record logging. <br> Positive value enables incomplete segment archiving after timeout (inactivity). <br> Zero or
+     * negative  value disables auto archiving.
+     * @return current configuration instance for chaining
+     */
+    public DataStorageConfiguration setWalAutoArchiveAfterInactivity(long walAutoArchiveAfterInactivity) {
+        this.walAutoArchiveAfterInactivity = walAutoArchiveAfterInactivity;
+
+        return this;
+    }
+
+    /**
+     * @return time in millis to run auto archiving WAL segment (even if incomplete) after last record log
+     */
+    public long getWalAutoArchiveAfterInactivity() {
+        return walAutoArchiveAfterInactivity;
+    }
+
+    /**
+     * This property defines order of writing pages to disk storage during checkpoint.
+     *
+     * @return Checkpoint write order.
+     */
+    public CheckpointWriteOrder getCheckpointWriteOrder() {
+        return checkpointWriteOrder;
+    }
+
+    /**
+     * This property defines order of writing pages to disk storage during checkpoint.
+     *
+     * @param checkpointWriteOrder Checkpoint write order.
+     */
+    public DataStorageConfiguration setCheckpointWriteOrder(CheckpointWriteOrder checkpointWriteOrder) {
+        this.checkpointWriteOrder = checkpointWriteOrder;
+
+        return this;
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
index a79d436..fc1fb6b 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
@@ -457,11 +457,16 @@ public class IgniteConfiguration {
     private ExecutorConfiguration[] execCfgs;
 
     /** Page memory configuration. */
+    @Deprecated
     private MemoryConfiguration memCfg;
 
     /** Persistence store configuration. */
+    @Deprecated
     private PersistentStoreConfiguration pstCfg;
 
+    /** Page memory configuration. */
+    private DataStorageConfiguration dsCfg;
+
     /** Active on start flag. */
     private boolean activeOnStart = DFLT_ACTIVE_ON_START;
 
@@ -510,6 +515,7 @@ public class IgniteConfiguration {
         allResolversPassReq = cfg.isAllSegmentationResolversPassRequired();
         atomicCfg = cfg.getAtomicConfiguration();
         binaryCfg = cfg.getBinaryConfiguration();
+        dsCfg = cfg.getDataStorageConfiguration();
         memCfg = cfg.getMemoryConfiguration();
         pstCfg = cfg.getPersistentStoreConfiguration();
         cacheCfg = cfg.getCacheConfiguration();
@@ -2157,6 +2163,29 @@ public class IgniteConfiguration {
      *
      * @return Memory configuration.
      */
+    public DataStorageConfiguration getDataStorageConfiguration() {
+        return dsCfg;
+    }
+
+    /**
+     * Sets durable memory configuration.
+     *
+     * @param dsCfg Data storage configuration.
+     * @return {@code this} for chaining.
+     */
+    public IgniteConfiguration setDataStorageConfiguration(DataStorageConfiguration dsCfg) {
+        this.dsCfg = dsCfg;
+
+        return this;
+    }
+
+    /**
+     * Gets page memory configuration.
+     *
+     * @return Memory configuration.
+     * @deprecated Use {@link DataStorageConfiguration} instead.
+     */
+    @Deprecated
     public MemoryConfiguration getMemoryConfiguration() {
         return memCfg;
     }
@@ -2166,7 +2195,9 @@ public class IgniteConfiguration {
      *
      * @param memCfg Memory configuration.
      * @return {@code this} for chaining.
+     * @deprecated Use {@link DataStorageConfiguration} instead.
      */
+    @Deprecated
     public IgniteConfiguration setMemoryConfiguration(MemoryConfiguration memCfg) {
         this.memCfg = memCfg;
 
@@ -2177,14 +2208,20 @@ public class IgniteConfiguration {
      * Gets persistence configuration used by Apache Ignite Persistent Store.
      *
      * @return Persistence configuration.
+     *
+     * @deprecated Part of old API. Use {@link DataStorageConfiguration} for configuring persistence instead.
      */
+    @Deprecated
     public PersistentStoreConfiguration getPersistentStoreConfiguration() {
         return pstCfg;
     }
 
     /**
-     * @return Flag {@code true} if persistent enable, {@code false} if disable.
+     * @return Flag {@code true} if persistence is enabled, {@code false} if disabled.
+     *
+     * @deprecated Part of legacy configuration API. Doesn't work if new configuration API is used.
      */
+    @Deprecated
     public boolean isPersistentStoreEnabled() {
         return pstCfg != null;
     }
@@ -2194,7 +2231,10 @@ public class IgniteConfiguration {
      *
      * @param pstCfg Persistence configuration.
      * @return {@code this} for chaining.
+     *
+     * @deprecated Part of old API. Use {@link DataStorageConfiguration} for configuring persistence instead.
      */
+    @Deprecated
     public IgniteConfiguration setPersistentStoreConfiguration(PersistentStoreConfiguration pstCfg) {
         this.pstCfg = pstCfg;
 
@@ -2208,7 +2248,7 @@ public class IgniteConfiguration {
      * <p>
      * Default value is {@link #DFLT_ACTIVE_ON_START}.
      * <p>
-     * This flag is ignored when {@link PersistentStoreConfiguration} is present:
+     * This flag is ignored when {@link DataStorageConfiguration} is present:
      * cluster is always inactive on start when Ignite Persistence is enabled.
      *
      * @return Active on start flag value.
@@ -2221,7 +2261,7 @@ public class IgniteConfiguration {
      * Sets flag indicating whether the cluster will be active on start. This value should be the same on all
      * nodes in the cluster.
      * <p>
-     * This flag is ignored when {@link PersistentStoreConfiguration} is present:
+     * This flag is ignored when {@link DataStorageConfiguration} is present:
      * cluster is always inactive on start when Ignite Persistence is enabled.
      *
      * @param activeOnStart Active on start flag value.

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/MemoryConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/MemoryConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/MemoryConfiguration.java
index 9ba26c8..c3d4e74 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/MemoryConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/MemoryConfiguration.java
@@ -57,7 +57,10 @@ import org.apache.ignite.internal.util.typedef.internal.U;
  *     </property>
  *     }
  * </pre>
+ *
+ * @deprecated Use {@link DataStorageConfiguration} instead.
  */
+@Deprecated
 public class MemoryConfiguration implements Serializable {
     /** */
     private static final long serialVersionUID = 0L;
@@ -66,7 +69,7 @@ public class MemoryConfiguration implements Serializable {
     @SuppressWarnings("UnnecessaryBoxing")
     public static final long DFLT_MEMORY_POLICY_INITIAL_SIZE = 256L * 1024 * 1024;
 
-    /** Fraction of available memory to allocate for default MemoryPolicy. */
+    /** Fraction of available memory to allocate for default DataRegion. */
     private static final double DFLT_MEMORY_POLICY_FRACTION = 0.2;
 
     /** Default memory policy's size is 20% of physical memory available on current machine. */
@@ -83,7 +86,7 @@ public class MemoryConfiguration implements Serializable {
     /** Default memory page size. */
     public static final int DFLT_PAGE_SIZE = 4 * 1024;
 
-    /** This name is assigned to default MemoryPolicy if no user-defined default MemPlc is specified */
+    /** This name is assigned to default DataRegion if no user-defined default MemPlc is specified */
     public static final String DFLT_MEM_PLC_DEFAULT_NAME = "default";
 
     /** Size of a memory chunk reserved for system cache initially. */
@@ -101,7 +104,7 @@ public class MemoryConfiguration implements Serializable {
     /** A name of the memory policy that defines the default memory region. */
     private String dfltMemPlcName = DFLT_MEM_PLC_DEFAULT_NAME;
 
-    /** Size of memory (in bytes) to use for default MemoryPolicy. */
+    /** Size of memory (in bytes) to use for default DataRegion. */
     private long dfltMemPlcSize = DFLT_MEMORY_POLICY_MAX_SIZE;
 
     /** Memory policies. */

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/MemoryPolicyConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/MemoryPolicyConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/MemoryPolicyConfiguration.java
index dff8b2b..efe7ae2 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/MemoryPolicyConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/MemoryPolicyConfiguration.java
@@ -19,7 +19,7 @@ package org.apache.ignite.configuration;
 import java.io.Serializable;
 import org.apache.ignite.MemoryMetrics;
 import org.apache.ignite.internal.mem.IgniteOutOfMemoryException;
-import org.apache.ignite.mxbean.MemoryMetricsMXBean;
+import org.apache.ignite.mxbean.DataRegionMetricsMXBean;
 
 import static org.apache.ignite.configuration.MemoryConfiguration.DFLT_MEM_PLC_DEFAULT_NAME;
 
@@ -60,7 +60,10 @@ import static org.apache.ignite.configuration.MemoryConfiguration.DFLT_MEM_PLC_D
  *              </property>
  *     }
  * </pre>
+ *
+ * @deprecated Use {@link DataRegionConfiguration} instead.
  */
+@Deprecated
 public final class MemoryPolicyConfiguration implements Serializable {
     /** */
     private static final long serialVersionUID = 0L;
@@ -121,6 +124,11 @@ public final class MemoryPolicyConfiguration implements Serializable {
     private long rateTimeInterval = DFLT_RATE_TIME_INTERVAL_MILLIS;
 
     /**
+     * Flag to enable Ignite Native Persistence.
+     */
+    private boolean persistenceEnabled = true;
+
+    /**
      * Gets memory policy name.
      *
      * @return Memory policy name.
@@ -290,7 +298,7 @@ public final class MemoryPolicyConfiguration implements Serializable {
 
     /**
      * Gets whether memory metrics are enabled by default on node startup. Memory metrics can be enabled and disabled
-     * at runtime via memory metrics {@link MemoryMetricsMXBean MX bean}.
+     * at runtime via memory metrics {@link DataRegionMetricsMXBean MX bean}.
      *
      * @return Metrics enabled flag.
      */
@@ -300,7 +308,7 @@ public final class MemoryPolicyConfiguration implements Serializable {
 
     /**
      * Sets memory metrics enabled flag. If this flag is {@code true}, metrics will be enabled on node startup.
-     * Memory metrics can be enabled and disabled at runtime via memory metrics {@link MemoryMetricsMXBean MX bean}.
+     * Memory metrics can be enabled and disabled at runtime via memory metrics {@link DataRegionMetricsMXBean MX bean}.
      *
      * @param metricsEnabled Metrics enabled flag.
      * @return {@code this} for chaining.
@@ -312,6 +320,24 @@ public final class MemoryPolicyConfiguration implements Serializable {
     }
 
     /**
+     * Gets whether Ignite Native Persistence is enabled for this memory policy.
+     *
+     * @return Persistence enabled flag.
+     */
+    public boolean isPersistenceEnabled() {
+        return persistenceEnabled;
+    }
+
+    /**
+     * Sets persistence enabled flag.
+     *
+     * @param persistenceEnabled Persistence enabled flag.
+     */
+    public void setPersistenceEnabled(boolean persistenceEnabled) {
+        this.persistenceEnabled = persistenceEnabled;
+    }
+
+    /**
      * Gets time interval for {@link MemoryMetrics#getAllocationRate()}
      * and {@link MemoryMetrics#getEvictionRate()} monitoring purposes.
      * <p>

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/configuration/PersistentStoreConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/PersistentStoreConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/PersistentStoreConfiguration.java
index c44e92d..c41721a 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/PersistentStoreConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/PersistentStoreConfiguration.java
@@ -25,7 +25,9 @@ import org.apache.ignite.internal.util.typedef.internal.S;
 
 /**
  * Configures Apache Ignite Persistent store.
+ * @deprecated Use {@link DataStorageConfiguration} instead.
  */
+@Deprecated
 public class PersistentStoreConfiguration implements Serializable {
     /** */
     private static final long serialVersionUID = 0L;
@@ -144,7 +146,7 @@ public class PersistentStoreConfiguration implements Serializable {
     /** Factory to provide I/O interface for files */
     private FileIOFactory fileIOFactory =
         IgniteSystemProperties.getBoolean(IgniteSystemProperties.IGNITE_USE_ASYNC_FILE_IO_FACTORY, false) ?
-        new AsyncFileIOFactory() : new RandomAccessFileIOFactory();
+            new AsyncFileIOFactory() : new RandomAccessFileIOFactory();
 
     /**
      * Number of sub-intervals the whole {@link #setRateTimeInterval(long)} will be split into to calculate

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/igfs/IgfsMetrics.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/igfs/IgfsMetrics.java b/modules/core/src/main/java/org/apache/ignite/igfs/IgfsMetrics.java
index 7bd27fe..794a262 100644
--- a/modules/core/src/main/java/org/apache/ignite/igfs/IgfsMetrics.java
+++ b/modules/core/src/main/java/org/apache/ignite/igfs/IgfsMetrics.java
@@ -17,6 +17,8 @@
 
 package org.apache.ignite.igfs;
 
+import org.apache.ignite.configuration.DataRegionConfiguration;
+
 /**
  * {@code IGFS} metrics snapshot for the file system. Note, that some metrics are global and
  * some are local (i.e. per each node).
@@ -33,7 +35,7 @@ public interface IgfsMetrics {
 
     /**
      * Gets maximum amount of data that can be stored on local node. This metrics is related to
-     * to the {@link org.apache.ignite.configuration.MemoryPolicyConfiguration#getMaxSize()} of the IGFS data cache.
+     * to the {@link DataRegionConfiguration#getMaxSize()} of the IGFS data cache.
      *
      * @return Maximum IGFS local space size.
      */

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/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 759bf64..8a71e1a 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
@@ -49,6 +49,10 @@ import java.util.concurrent.atomic.AtomicReference;
 import javax.cache.CacheException;
 import javax.management.JMException;
 import javax.management.ObjectName;
+import org.apache.ignite.DataRegionMetrics;
+import org.apache.ignite.DataRegionMetricsAdapter;
+import org.apache.ignite.DataStorageMetrics;
+import org.apache.ignite.DataStorageMetricsAdapter;
 import org.apache.ignite.IgniteAtomicLong;
 import org.apache.ignite.IgniteAtomicReference;
 import org.apache.ignite.IgniteAtomicSequence;
@@ -85,6 +89,7 @@ import org.apache.ignite.configuration.BinaryConfiguration;
 import org.apache.ignite.configuration.CacheConfiguration;
 import org.apache.ignite.configuration.CollectionConfiguration;
 import org.apache.ignite.configuration.ConnectorConfiguration;
+import org.apache.ignite.configuration.DataStorageConfiguration;
 import org.apache.ignite.configuration.IgniteConfiguration;
 import org.apache.ignite.configuration.MemoryConfiguration;
 import org.apache.ignite.configuration.NearCacheConfiguration;
@@ -114,7 +119,7 @@ import org.apache.ignite.internal.processors.cache.GridCacheUtilityKey;
 import org.apache.ignite.internal.processors.cache.IgniteCacheProxy;
 import org.apache.ignite.internal.processors.cache.IgniteInternalCache;
 import org.apache.ignite.internal.processors.cache.binary.CacheObjectBinaryProcessorImpl;
-import org.apache.ignite.internal.processors.cache.persistence.MemoryPolicy;
+import org.apache.ignite.internal.processors.cache.persistence.DataRegion;
 import org.apache.ignite.internal.processors.cache.persistence.filename.PdsConsistentIdProcessor;
 import org.apache.ignite.internal.processors.cacheobject.IgniteCacheObjectProcessor;
 import org.apache.ignite.internal.processors.closure.GridClosureProcessor;
@@ -176,6 +181,7 @@ import org.apache.ignite.lifecycle.LifecycleAware;
 import org.apache.ignite.lifecycle.LifecycleBean;
 import org.apache.ignite.lifecycle.LifecycleEventType;
 import org.apache.ignite.marshaller.MarshallerExclusions;
+import org.apache.ignite.marshaller.jdk.JdkMarshaller;
 import org.apache.ignite.mxbean.ClusterLocalNodeMetricsMXBean;
 import org.apache.ignite.mxbean.IgniteMXBean;
 import org.apache.ignite.mxbean.StripedExecutorMXBean;
@@ -214,6 +220,7 @@ import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_BUILD_VER;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_CLIENT_MODE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_CONSISTENCY_CHECK_SKIPPED;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_DAEMON;
+import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_DATA_STORAGE_CONFIG;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_DATA_STREAMER_POOL_SIZE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_DEPLOYMENT_MODE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_IGNITE_INSTANCE_NAME;
@@ -231,10 +238,10 @@ import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_MARSHALLER_US
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_MARSHALLER_USE_DFLT_SUID;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_MEMORY_CONFIG;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_NODE_CONSISTENT_ID;
+import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_OFFHEAP_SIZE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_PEER_CLASSLOADING;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_PHY_RAM;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_PREFIX;
-import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_OFFHEAP_SIZE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_RESTART_ENABLED;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_REST_PORT_RANGE;
 import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_SPI_CLASS;
@@ -1245,10 +1252,10 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
 
                             int loadedPages = 0;
 
-                            Collection<MemoryPolicy> policies = ctx.cache().context().database().memoryPolicies();
+                            Collection<DataRegion> policies = ctx.cache().context().database().dataRegions();
 
                             if (!F.isEmpty(policies)) {
-                                for (MemoryPolicy memPlc : policies)
+                                for (DataRegion memPlc : policies)
                                     loadedPages += memPlc.pageMemory().loadedPages();
                             }
 
@@ -1424,7 +1431,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
 
             if (total > safeToUse) {
                 U.quietAndWarn(log, "Nodes started on local machine require more than 80% of physical RAM what can " +
-                    "lead to significant slowdown due to swapping (please decrease JVM heap size, memory policy " +
+                    "lead to significant slowdown due to swapping (please decrease JVM heap size, data region " +
                     "size or checkpoint buffer size) [required=" + (total >> 20) + "MB, available=" +
                     (ram >> 20) + "MB]");
             }
@@ -1604,8 +1611,8 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
         if (cfg.getConnectorConfiguration() != null)
             add(ATTR_REST_PORT_RANGE, cfg.getConnectorConfiguration().getPortRange());
 
-        // Save database configuration.
-        add(ATTR_MEMORY_CONFIG, cfg.getMemoryConfiguration());
+        // Save data storage configuration.
+        addDataStorageConfigurationAttributes();
 
         // Save transactions configuration.
         add(ATTR_TX_CONFIG, cfg.getTransactionConfiguration());
@@ -1633,6 +1640,25 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /**
+     *
+     */
+    private void addDataStorageConfigurationAttributes() throws IgniteCheckedException {
+        MemoryConfiguration memCfg = cfg.getMemoryConfiguration();
+
+        // Save legacy memory configuration if it's present.
+        if (memCfg != null) {
+            // Page size initialization is suspended, see IgniteCacheDatabaseSharedManager#checkPageSize.
+            // We should copy initialized value from new configuration.
+            memCfg.setPageSize(cfg.getDataStorageConfiguration().getPageSize());
+
+            add(ATTR_MEMORY_CONFIG, memCfg);
+        }
+
+        // Save data storage configuration.
+        add(ATTR_DATA_STORAGE_CONFIG, new JdkMarshaller().marshal(cfg.getDataStorageConfiguration()));
+    }
+
+    /**
      * Add SPI version and class attributes into node attributes.
      *
      * @param spiList Collection of SPIs to get attributes from.
@@ -2509,14 +2535,14 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
      *
      */
     private void ackMemoryConfiguration() {
-        MemoryConfiguration memCfg = cfg.getMemoryConfiguration();
+        DataStorageConfiguration memCfg = cfg.getDataStorageConfiguration();
 
         if (memCfg == null)
             return;
 
-        U.log(log, "System cache's MemoryPolicy size is configured to " +
-            (memCfg.getSystemCacheInitialSize() / (1024 * 1024)) + " MB. " +
-            "Use MemoryConfiguration.systemCacheMemorySize property to change the setting.");
+        U.log(log, "System cache's DataRegion size is configured to " +
+            (memCfg.getSystemRegionInitialSize() / (1024 * 1024)) + " MB. " +
+            "Use DataStorageConfiguration.systemCacheMemorySize property to change the setting.");
     }
 
     /**
@@ -2535,12 +2561,12 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
             for (CacheConfiguration c : cacheCfgs) {
                 String cacheName = U.maskName(c.getName());
 
-                String memPlcName = c.getMemoryPolicyName();
+                String memPlcName = c.getDataRegionName();
 
                 if (CU.isSystemCache(cacheName))
                     memPlcName = "sysMemPlc";
-                else if (memPlcName == null && cfg.getMemoryConfiguration() != null)
-                    memPlcName = cfg.getMemoryConfiguration().getDefaultMemoryPolicyName();
+                else if (memPlcName == null && cfg.getDataStorageConfiguration() != null)
+                    memPlcName = cfg.getDataStorageConfiguration().getDefaultDataRegionConfiguration().getName();
 
                 if (!memPlcNamesMapping.containsKey(memPlcName))
                     memPlcNamesMapping.put(memPlcName, new ArrayList<String>());
@@ -2551,7 +2577,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
             }
 
             for (Map.Entry<String, ArrayList<String>> e : memPlcNamesMapping.entrySet()) {
-                sb.a("in '").a(e.getKey()).a("' memoryPolicy: [");
+                sb.a("in '").a(e.getKey()).a("' dataRegion: [");
 
                 for (String s : e.getValue())
                     sb.a("'").a(s).a("', ");
@@ -3509,7 +3535,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Override public Collection<MemoryMetrics> memoryMetrics() {
+    @Override public Collection<DataRegionMetrics> dataRegionMetrics() {
         guard();
 
         try {
@@ -3521,7 +3547,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Nullable @Override public MemoryMetrics memoryMetrics(String memPlcName) {
+    @Nullable @Override public DataRegionMetrics dataRegionMetrics(String memPlcName) {
         guard();
 
         try {
@@ -3533,7 +3559,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Override public PersistenceMetrics persistentStoreMetrics() {
+    @Override public DataStorageMetrics dataStorageMetrics() {
         guard();
 
         try {
@@ -3545,6 +3571,21 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable {
     }
 
     /** {@inheritDoc} */
+    @Override public Collection<MemoryMetrics> memoryMetrics() {
+        return DataRegionMetricsAdapter.collectionOf(dataRegionMetrics());
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public MemoryMetrics memoryMetrics(String memPlcName) {
+        return DataRegionMetricsAdapter.valueOf(dataRegionMetrics(memPlcName));
+    }
+
+    /** {@inheritDoc} */
+    @Override public PersistenceMetrics persistentStoreMetrics() {
+        return DataStorageMetricsAdapter.valueOf(dataStorageMetrics());
+    }
+
+    /** {@inheritDoc} */
     @Nullable @Override public IgniteAtomicSequence atomicSequence(String name, long initVal, boolean create) {
         return atomicSequence(name, null, initVal, create);
     }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/internal/IgniteNodeAttributes.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteNodeAttributes.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteNodeAttributes.java
index 024f339..277ed79 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteNodeAttributes.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteNodeAttributes.java
@@ -184,8 +184,12 @@ public final class IgniteNodeAttributes {
     public static final String ATTR_DATA_STREAMER_POOL_SIZE = ATTR_PREFIX + ".data.streamer.pool.size";
 
     /** Memory configuration. */
+    @Deprecated
     public static final String ATTR_MEMORY_CONFIG = ATTR_PREFIX + ".memory";
 
+    /** Data storage configuration. */
+    public static final String ATTR_DATA_STORAGE_CONFIG = ATTR_PREFIX + ".data.storage.config";
+
     /**
      * Enforces singleton.
      */

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
index 07a5c43..36257e2 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java
@@ -57,11 +57,15 @@ import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
 import org.apache.ignite.compute.ComputeJob;
 import org.apache.ignite.configuration.CacheConfiguration;
 import org.apache.ignite.configuration.ConnectorConfiguration;
+import org.apache.ignite.configuration.DataRegionConfiguration;
+import org.apache.ignite.configuration.DataStorageConfiguration;
 import org.apache.ignite.configuration.DeploymentMode;
 import org.apache.ignite.configuration.ExecutorConfiguration;
 import org.apache.ignite.configuration.FileSystemConfiguration;
 import org.apache.ignite.configuration.IgniteConfiguration;
 import org.apache.ignite.configuration.MemoryConfiguration;
+import org.apache.ignite.configuration.MemoryPolicyConfiguration;
+import org.apache.ignite.configuration.PersistentStoreConfiguration;
 import org.apache.ignite.configuration.TransactionConfiguration;
 import org.apache.ignite.internal.binary.BinaryMarshaller;
 import org.apache.ignite.internal.managers.communication.GridIoPolicy;
@@ -123,6 +127,8 @@ import static org.apache.ignite.cache.CacheMode.REPLICATED;
 import static org.apache.ignite.cache.CacheRebalanceMode.SYNC;
 import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_SYNC;
 import static org.apache.ignite.configuration.IgniteConfiguration.DFLT_THREAD_KEEP_ALIVE_TIME;
+import static org.apache.ignite.configuration.MemoryConfiguration.DFLT_MEMORY_POLICY_MAX_SIZE;
+import static org.apache.ignite.configuration.MemoryConfiguration.DFLT_MEM_PLC_DEFAULT_NAME;
 import static org.apache.ignite.internal.IgniteComponentType.SPRING;
 import static org.apache.ignite.plugin.segmentation.SegmentationPolicy.RESTART_JVM;
 
@@ -2183,15 +2189,27 @@ public class IgnitionEx {
                 myCfg.setExecutorConfiguration(clone);
             }
 
-            if (!myCfg.isClientMode() && myCfg.getMemoryConfiguration() == null) {
-                MemoryConfiguration memCfg = new MemoryConfiguration();
+            initializeDataStorageConfiguration(myCfg);
 
-                memCfg.setConcurrencyLevel(Runtime.getRuntime().availableProcessors() * 4);
+            return myCfg;
+        }
 
-                myCfg.setMemoryConfiguration(memCfg);
+        /**
+         * @param cfg Ignite configuration.
+         */
+        private void initializeDataStorageConfiguration(IgniteConfiguration cfg) throws IgniteCheckedException {
+            if (cfg.getDataStorageConfiguration() != null &&
+                (cfg.getMemoryConfiguration() != null || cfg.getPersistentStoreConfiguration() != null)) {
+                throw new IgniteCheckedException("Data storage can be configured with either legacy " +
+                    "(MemoryConfiguration, PersistentStoreConfiguration) or new (DataStorageConfiguration) classes, " +
+                    "but not both.");
             }
 
-            return myCfg;
+            if (cfg.getMemoryConfiguration() != null || cfg.getPersistentStoreConfiguration() != null)
+                convertLegacyDataStorageConfigurationToNew(cfg);
+
+            if (!cfg.isClientMode() && cfg.getDataStorageConfiguration() == null)
+                cfg.setDataStorageConfiguration(new DataStorageConfiguration());
         }
 
         /**
@@ -2755,4 +2773,108 @@ public class IgnitionEx {
             }
         }
     }
+
+    /**
+     * @param cfg Ignite Configuration with legacy data storage configuration.
+     */
+    private static void convertLegacyDataStorageConfigurationToNew(
+        IgniteConfiguration cfg) throws IgniteCheckedException {
+        boolean persistenceEnabled = cfg.getPersistentStoreConfiguration() != null;
+
+        DataStorageConfiguration dsCfg = new DataStorageConfiguration();
+
+        MemoryConfiguration memCfg = cfg.getMemoryConfiguration() != null ?
+            cfg.getMemoryConfiguration() : new MemoryConfiguration();
+
+        dsCfg.setConcurrencyLevel(memCfg.getConcurrencyLevel());
+        dsCfg.setPageSize(memCfg.getPageSize());
+        dsCfg.setSystemRegionInitialSize(memCfg.getSystemCacheInitialSize());
+        dsCfg.setSystemRegionMaxSize(memCfg.getSystemCacheMaxSize());
+
+        List<DataRegionConfiguration> optionalDataRegions = new ArrayList<>();
+
+        boolean customDfltPlc = false;
+
+        if (memCfg.getMemoryPolicies() != null) {
+            for (MemoryPolicyConfiguration mpc : memCfg.getMemoryPolicies()) {
+                DataRegionConfiguration region = new DataRegionConfiguration();
+
+                region.setPersistenceEnabled(persistenceEnabled);
+
+                if (mpc.getInitialSize() != 0L)
+                    region.setInitialSize(mpc.getInitialSize());
+
+                region.setEmptyPagesPoolSize(mpc.getEmptyPagesPoolSize());
+                region.setEvictionThreshold(mpc.getEvictionThreshold());
+                region.setMaxSize(mpc.getMaxSize());
+                region.setName(mpc.getName());
+                region.setPageEvictionMode(mpc.getPageEvictionMode());
+                region.setMetricsRateTimeInterval(mpc.getRateTimeInterval());
+                region.setMetricsSubIntervalCount(mpc.getSubIntervals());
+                region.setSwapPath(mpc.getSwapFilePath());
+                region.setMetricsEnabled(mpc.isMetricsEnabled());
+
+                if (mpc.getName() == null) {
+                    throw new IgniteCheckedException(new IllegalArgumentException(
+                        "User-defined MemoryPolicyConfiguration must have non-null and non-empty name."));
+                }
+
+                if (mpc.getName().equals(memCfg.getDefaultMemoryPolicyName())) {
+                    customDfltPlc = true;
+
+                    dsCfg.setDefaultDataRegionConfiguration(region);
+                } else
+                    optionalDataRegions.add(region);
+            }
+        }
+
+        if (!optionalDataRegions.isEmpty())
+            dsCfg.setDataRegionConfigurations(optionalDataRegions.toArray(new DataRegionConfiguration[optionalDataRegions.size()]));
+
+        if (!customDfltPlc) {
+            if (!DFLT_MEM_PLC_DEFAULT_NAME.equals(memCfg.getDefaultMemoryPolicyName())) {
+                throw new IgniteCheckedException(new IllegalArgumentException("User-defined default MemoryPolicy " +
+                    "name must be presented among configured MemoryPolices: " + memCfg.getDefaultMemoryPolicyName()));
+            }
+
+            dsCfg.setDefaultDataRegionConfiguration(new DataRegionConfiguration()
+                .setMaxSize(memCfg.getDefaultMemoryPolicySize())
+                .setName(memCfg.getDefaultMemoryPolicyName())
+                .setPersistenceEnabled(persistenceEnabled));
+        } else {
+            if (memCfg.getDefaultMemoryPolicySize() != DFLT_MEMORY_POLICY_MAX_SIZE)
+                throw new IgniteCheckedException(new IllegalArgumentException("User-defined MemoryPolicy " +
+                    "configuration and defaultMemoryPolicySize properties are set at the same time."));
+        }
+
+        if (persistenceEnabled) {
+            PersistentStoreConfiguration psCfg = cfg.getPersistentStoreConfiguration();
+
+            dsCfg.setCheckpointFrequency(psCfg.getCheckpointingFrequency());
+            dsCfg.setCheckpointPageBufferSize(psCfg.getCheckpointingPageBufferSize());
+            dsCfg.setCheckpointThreads(psCfg.getCheckpointingThreads());
+            dsCfg.setCheckpointWriteOrder(psCfg.getCheckpointWriteOrder());
+            dsCfg.setFileIOFactory(psCfg.getFileIOFactory());
+            dsCfg.setLockWaitTime(psCfg.getLockWaitTime());
+            dsCfg.setStoragePath(psCfg.getPersistentStorePath());
+            dsCfg.setMetricsRateTimeInterval(psCfg.getRateTimeInterval());
+            dsCfg.setMetricsSubIntervalCount(psCfg.getSubIntervals());
+            dsCfg.setWalThreadLocalBufferSize(psCfg.getTlbSize());
+            dsCfg.setWalArchivePath(psCfg.getWalArchivePath());
+            dsCfg.setWalAutoArchiveAfterInactivity(psCfg.getWalAutoArchiveAfterInactivity());
+            dsCfg.setWalFlushFrequency(psCfg.getWalFlushFrequency());
+            dsCfg.setWalFsyncDelayNanos(psCfg.getWalFsyncDelayNanos());
+            dsCfg.setWalHistorySize(psCfg.getWalHistorySize());
+            dsCfg.setWalMode(psCfg.getWalMode());
+            dsCfg.setWalRecordIteratorBufferSize(psCfg.getWalRecordIteratorBufferSize());
+            dsCfg.setWalSegments(psCfg.getWalSegments());
+            dsCfg.setWalSegmentSize(psCfg.getWalSegmentSize());
+            dsCfg.setWalPath(psCfg.getWalStorePath());
+            dsCfg.setAlwaysWriteFullPages(psCfg.isAlwaysWriteFullPages());
+            dsCfg.setMetricsEnabled(psCfg.isMetricsEnabled());
+            dsCfg.setWriteThrottlingEnabled(psCfg.isWriteThrottlingEnabled());
+        }
+
+        cfg.setDataStorageConfiguration(dsCfg);
+    }
 }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/internal/MarshallerContextImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/MarshallerContextImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/MarshallerContextImpl.java
index f57bda7..1e5c370 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/MarshallerContextImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/MarshallerContextImpl.java
@@ -48,6 +48,7 @@ import org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem;
 import org.apache.ignite.internal.processors.marshaller.MarshallerMappingTransport;
 import org.apache.ignite.internal.util.IgniteUtils;
 import org.apache.ignite.internal.util.future.GridFutureAdapter;
+import org.apache.ignite.internal.util.typedef.internal.CU;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.marshaller.MarshallerContext;
 import org.apache.ignite.plugin.PluginProvider;
@@ -506,7 +507,7 @@ public class MarshallerContextImpl implements MarshallerContext {
         closProc = ctx.closure();
         clientNode = ctx.clientNode();
 
-        if (ctx.config().isPersistentStoreEnabled())
+        if (CU.isPersistenceEnabled(ctx.config()))
             fileStore.restoreMappings(this);
     }
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ec41370c/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
index 14485d2..a3b157d 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
@@ -53,8 +53,8 @@ import org.apache.ignite.cache.CacheMode;
 import org.apache.ignite.cluster.ClusterMetrics;
 import org.apache.ignite.cluster.ClusterNode;
 import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.configuration.MemoryConfiguration;
-import org.apache.ignite.configuration.MemoryPolicyConfiguration;
+import org.apache.ignite.configuration.DataStorageConfiguration;
+import org.apache.ignite.configuration.DataRegionConfiguration;
 import org.apache.ignite.events.DiscoveryEvent;
 import org.apache.ignite.events.Event;
 import org.apache.ignite.internal.ClusterMetricsSnapshot;
@@ -1533,32 +1533,21 @@ public class GridDiscoveryManager extends GridManagerAdapter<DiscoverySpi> {
         if(ctx.config().isClientMode())
             return 0;
 
-        MemoryConfiguration memCfg = ctx.config().getMemoryConfiguration();
+        DataStorageConfiguration memCfg = ctx.config().getDataStorageConfiguration();
 
         assert memCfg != null;
 
-        long res = memCfg.getSystemCacheMaxSize();
+        long res = memCfg.getSystemRegionMaxSize();
 
         // Add memory policies.
-        MemoryPolicyConfiguration[] memPlcCfgs = memCfg.getMemoryPolicies();
+        DataRegionConfiguration[] dataRegions = memCfg.getDataRegionConfigurations();
 
-        if (memPlcCfgs != null) {
-            String dfltMemPlcName = memCfg.getDefaultMemoryPolicyName();
-
-            boolean customDflt = false;
-
-            for (MemoryPolicyConfiguration memPlcCfg : memPlcCfgs) {
-                if(F.eq(dfltMemPlcName, memPlcCfg.getName()))
-                    customDflt = true;
-
-                res += memPlcCfg.getMaxSize();
-            }
-
-            if(!customDflt)
-                res += memCfg.getDefaultMemoryPolicySize();
+        if (dataRegions != null) {
+            for (DataRegionConfiguration dataReg : dataRegions)
+                res += dataReg.getMaxSize();
         }
-        else
-            res += memCfg.getDefaultMemoryPolicySize();
+
+        res += memCfg.getDefaultDataRegionConfiguration().getMaxSize();
 
         // Add persistence (if any).
         res += GridCacheDatabaseSharedManager.checkpointBufferSize(ctx.config());


Mime
View raw message