http://git-wip-us.apache.org/repos/asf/ignite/blob/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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/74567763/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());