This is an automated email from the ASF dual-hosted git repository.
chenyz pushed a commit to branch pbtree_page_concurrency
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/pbtree_page_concurrency by
this push:
new c9148d155a6 Add pbtree configuration and volatile size statistics
(#11958)
c9148d155a6 is described below
commit c9148d155a621f670b37f40e82c0f999d1a532a8
Author: Chen YZ <[email protected]>
AuthorDate: Thu Jan 25 13:21:09 2024 +0800
Add pbtree configuration and volatile size statistics (#11958)
* add volatile size statistics
* add config
* fix ut
---
.../java/org/apache/iotdb/db/conf/IoTDBConfig.java | 95 ++++++++++++++++++++++
.../org/apache/iotdb/db/conf/IoTDBDescriptor.java | 84 ++++++++++++++++++-
.../rescon/CachedSchemaRegionStatistics.java | 15 ++++
.../mtree/impl/pbtree/CachedMTreeStore.java | 3 +-
.../impl/pbtree/memcontrol/MemoryStatistics.java | 10 ++-
.../mtree/impl/pbtree/memory/IMemoryManager.java | 3 +-
.../mtree/impl/pbtree/memory/MemoryManager.java | 17 ++--
.../resources/conf/iotdb-common.properties | 28 +++++++
8 files changed, 243 insertions(+), 12 deletions(-)
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
index ce5c4e5796a..0c108a68461 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
@@ -998,6 +998,21 @@ public class IoTDBConfig {
/** Memory allocated for PartitionCache */
private long allocateMemoryForPartitionCache = allocateMemoryForSchema / 10;
+ private int[] schemaRegionNodePageProportion = new int[] {2, 1};
+ /** Memory allocated for SchemaRegionNode in PBTree Mode */
+ private long allocateMemoryForSchemaRegionNode =
allocateMemoryForSchemaRegion;
+
+ /** Memory allocated for SchemaRegionPage in PBTree Mode */
+ private long allocateMemoryForSchemaRegionPage = 16 * 16 * 1024; // 256KB
+
+ private int[] pagePoolCacheBufferProportion = new int[] {1, 3};
+ private int pbtreeCachePageNum = 4;
+ private int pbtreeBufferPageNum = 12;
+ private double pbtreeNodeReleaseThresholdRatio = 0.7;
+ private double pbtreeNodeFlushThresholdRatio = 0.1;
+ private int pbtreePageFlushMaxNumber = 10;
+ private double pbtreePageFlushMinDirtyRatio = 0.3;
+
/** Policy of DataNodeSchemaCache eviction */
private String dataNodeSchemaCacheEvictionPolicy = "FIFO";
@@ -3231,6 +3246,86 @@ public class IoTDBConfig {
this.allocateMemoryForPartitionCache = allocateMemoryForPartitionCache;
}
+ public int[] getSchemaRegionNodePageProportion() {
+ return schemaRegionNodePageProportion;
+ }
+
+ public void setSchemaRegionNodePageProportion(int[]
schemaRegionNodePageProportion) {
+ this.schemaRegionNodePageProportion = schemaRegionNodePageProportion;
+ }
+
+ public long getAllocateMemoryForSchemaRegionNode() {
+ return allocateMemoryForSchemaRegionNode;
+ }
+
+ public void setAllocateMemoryForSchemaRegionNode(long
allocateMemoryForSchemaRegionNode) {
+ this.allocateMemoryForSchemaRegionNode = allocateMemoryForSchemaRegionNode;
+ }
+
+ public long getAllocateMemoryForSchemaRegionPage() {
+ return allocateMemoryForSchemaRegionPage;
+ }
+
+ public void setAllocateMemoryForSchemaRegionPage(long
allocateMemoryForSchemaRegionPage) {
+ this.allocateMemoryForSchemaRegionPage = allocateMemoryForSchemaRegionPage;
+ }
+
+ public int[] getPagePoolCacheBufferProportion() {
+ return pagePoolCacheBufferProportion;
+ }
+
+ public void setPagePoolCacheBufferProportion(int[]
pagePoolCacheBufferProportion) {
+ this.pagePoolCacheBufferProportion = pagePoolCacheBufferProportion;
+ }
+
+ public int getPbtreeCachePageNum() {
+ return pbtreeCachePageNum;
+ }
+
+ public void setPbtreeCachePageNum(int pbtreeCachePageNum) {
+ this.pbtreeCachePageNum = pbtreeCachePageNum;
+ }
+
+ public int getPbtreeBufferPageNum() {
+ return pbtreeBufferPageNum;
+ }
+
+ public void setPbtreeBufferPageNum(int pbtreeBufferPageNum) {
+ this.pbtreeBufferPageNum = pbtreeBufferPageNum;
+ }
+
+ public double getPbtreeNodeReleaseThresholdRatio() {
+ return pbtreeNodeReleaseThresholdRatio;
+ }
+
+ public void setPbtreeNodeReleaseThresholdRatio(double
pbtreeNodeReleaseThresholdRatio) {
+ this.pbtreeNodeReleaseThresholdRatio = pbtreeNodeReleaseThresholdRatio;
+ }
+
+ public double getPbtreeNodeFlushThresholdRatio() {
+ return pbtreeNodeFlushThresholdRatio;
+ }
+
+ public void setPbtreeNodeFlushThresholdRatio(double
pbtreeNodeFlushThresholdRatio) {
+ this.pbtreeNodeFlushThresholdRatio = pbtreeNodeFlushThresholdRatio;
+ }
+
+ public int getPbtreePageFlushMaxNumber() {
+ return pbtreePageFlushMaxNumber;
+ }
+
+ public void setPbtreePageFlushMaxNumber(int pbtreePageFlushMaxNumber) {
+ this.pbtreePageFlushMaxNumber = pbtreePageFlushMaxNumber;
+ }
+
+ public double getPbtreePageFlushMinDirtyRatio() {
+ return pbtreePageFlushMinDirtyRatio;
+ }
+
+ public void setPbtreePageFlushMinDirtyRatio(double
pbtreePageFlushMinDirtyRatio) {
+ this.pbtreePageFlushMinDirtyRatio = pbtreePageFlushMinDirtyRatio;
+ }
+
public String getDataNodeSchemaCacheEvictionPolicy() {
return dataNodeSchemaCacheEvictionPolicy;
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
index 5f0616bc08c..8aaae6db5f0 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
@@ -212,6 +212,9 @@ public class IoTDBDescriptor {
}
public void loadProperties(Properties properties) throws
BadNodeUrlException, IOException {
+ // commons
+ commonDescriptor.loadCommonProps(properties);
+
conf.setClusterName(
properties.getProperty(IoTDBConstant.CLUSTER_NAME,
conf.getClusterName()).trim());
@@ -977,8 +980,6 @@ public class IoTDBDescriptor {
"coordinator_write_executor_size",
Integer.toString(conf.getCoordinatorWriteExecutorSize()))));
- // commons
- commonDescriptor.loadCommonProps(properties);
commonDescriptor.initCommonConfigDir(conf.getSystemDir());
// timed flush memtable
@@ -1904,6 +1905,85 @@ public class IoTDBDescriptor {
conf.setAllocateMemoryForPartitionCache(
schemaMemoryTotal * conf.getSchemaMemoryProportion()[2] /
proportionSum);
LOGGER.info("allocateMemoryForPartitionCache = {}",
conf.getAllocateMemoryForPartitionCache());
+
+ // Load PBTree mode memory configuration.
+ // Make sure common config is loaded before this.
+ if (commonDescriptor.getConfig().getSchemaEngineMode().equals("PBTree")) {
+ String nodePageProportionInput =
properties.getProperty("pbtree_node_page_proportion");
+ if (nodePageProportionInput != null) {
+ String[] proportions = nodePageProportionInput.split(":");
+ int loadedProportionSum = 0;
+ for (String proportion : proportions) {
+ loadedProportionSum += Integer.parseInt(proportion.trim());
+ }
+ if (loadedProportionSum != 0) {
+ conf.setSchemaRegionNodePageProportion(
+ new int[] {
+ Integer.parseInt(proportions[0].trim()),
Integer.parseInt(proportions[1].trim())
+ });
+ }
+ }
+ String cacheBufferProportionInput =
+ properties.getProperty("pbtree_page_pool_cache_buffer_proportion");
+ if (cacheBufferProportionInput != null) {
+ String[] proportions = cacheBufferProportionInput.split(":");
+ int loadedProportionSum = 0;
+ for (String proportion : proportions) {
+ loadedProportionSum += Integer.parseInt(proportion.trim());
+ }
+ if (loadedProportionSum != 0) {
+ conf.setPagePoolCacheBufferProportion(
+ new int[] {
+ Integer.parseInt(proportions[0].trim()),
Integer.parseInt(proportions[1].trim())
+ });
+ }
+ }
+ proportionSum = 0;
+ for (int proportion : conf.getSchemaRegionNodePageProportion()) {
+ proportionSum += proportion;
+ }
+ long pagePoolSize =
+ conf.getAllocateMemoryForSchemaRegion()
+ * conf.getSchemaRegionNodePageProportion()[1]
+ / proportionSum
+ / (16 * 1024);
+ conf.setAllocateMemoryForSchemaRegionPage(pagePoolSize * 16 * 1024);
+ LOGGER.info(
+ "allocateMemoryForSchemaRegionPage = {}",
conf.getAllocateMemoryForSchemaRegionPage());
+ conf.setAllocateMemoryForSchemaRegionNode(
+ conf.getAllocateMemoryForSchemaRegion() -
conf.getAllocateMemoryForSchemaRegionPage());
+ LOGGER.info(
+ "allocateMemoryForSchemaRegionNode = {}",
conf.getAllocateMemoryForSchemaRegionNode());
+ proportionSum = 0;
+ for (int proportion : conf.getPagePoolCacheBufferProportion()) {
+ proportionSum += proportion;
+ }
+ conf.setPbtreeCachePageNum(
+ (int) (pagePoolSize * conf.getPagePoolCacheBufferProportion()[0] /
proportionSum));
+ LOGGER.info("pbtreeCachePageNum = {}", conf.getPbtreeCachePageNum());
+ conf.setPbtreeBufferPageNum((int) (pagePoolSize -
conf.getPbtreeCachePageNum()));
+ LOGGER.info("pbtreeBufferPageNum = {}", conf.getPbtreeBufferPageNum());
+ conf.setPbtreeNodeReleaseThresholdRatio(
+ Double.parseDouble(
+ properties.getProperty(
+ "pbtree_node_release_threshold_ratio",
+
Double.toString(conf.getPbtreeNodeReleaseThresholdRatio()))));
+ conf.setPbtreeNodeFlushThresholdRatio(
+ Double.parseDouble(
+ properties.getProperty(
+ "pbtree_node_flush_threshold_ratio",
+ Double.toString(conf.getPbtreeNodeFlushThresholdRatio()))));
+ conf.setPbtreePageFlushMaxNumber(
+ Integer.parseInt(
+ properties.getProperty(
+ "pbtree_page_flush_max_number",
+ Integer.toString(conf.getPbtreePageFlushMaxNumber()))));
+ conf.setPbtreePageFlushMinDirtyRatio(
+ Double.parseDouble(
+ properties.getProperty(
+ "pbtree_page_flush_min_dirty_ratio",
+ Double.toString(conf.getPbtreePageFlushMinDirtyRatio()))));
+ }
}
@SuppressWarnings("squid:S3518") // "proportionSum" can't be zero
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/rescon/CachedSchemaRegionStatistics.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/rescon/CachedSchemaRegionStatistics.java
index 488b55da118..4b08cf12cc4 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/rescon/CachedSchemaRegionStatistics.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/rescon/CachedSchemaRegionStatistics.java
@@ -31,6 +31,7 @@ public class CachedSchemaRegionStatistics extends
MemSchemaRegionStatistics {
private final AtomicLong unpinnedMemorySize = new AtomicLong(0);
private final AtomicLong pinnedMemorySize = new AtomicLong(0);
+ private final AtomicLong volatileMNodeSize = new AtomicLong(0);
private final AtomicLong unpinnedMNodeNum = new AtomicLong(0);
private final AtomicLong pinnedMNodeNum = new AtomicLong(0);
private final AtomicLong volatileMNodeNum = new AtomicLong(0);
@@ -71,6 +72,10 @@ public class CachedSchemaRegionStatistics extends
MemSchemaRegionStatistics {
this.volatileMNodeNum.addAndGet(delta);
}
+ public void updateVolatileMNodeSize(int delta) {
+ this.volatileMNodeSize.addAndGet(delta);
+ }
+
public void setMlogCheckPoint(long mlogCheckPoint) {
this.mlogCheckPoint = mlogCheckPoint;
}
@@ -103,6 +108,10 @@ public class CachedSchemaRegionStatistics extends
MemSchemaRegionStatistics {
return volatileMNodeNum.get();
}
+ public long getVolatileMNodeSize() {
+ return volatileMNodeSize.get();
+ }
+
public long getCacheNodeNum() {
return memoryManager == null ? 0 : memoryManager.getCacheNodeNum();
}
@@ -124,5 +133,11 @@ public class CachedSchemaRegionStatistics extends
MemSchemaRegionStatistics {
cachedEngineStatistics.updateUnpinnedMNodeNum(-unpinnedMNodeNum.get());
cachedEngineStatistics.updatePinnedMemorySize(-pinnedMemorySize.get());
cachedEngineStatistics.updateUnpinnedMemorySize(-unpinnedMemorySize.get());
+ pinnedMNodeNum.set(0L);
+ unpinnedMNodeNum.set(0L);
+ pinnedMemorySize.set(0L);
+ unpinnedMemorySize.set(0L);
+ volatileMNodeNum.set(0L);
+ volatileMNodeSize.set(0L);
}
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/CachedMTreeStore.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/CachedMTreeStore.java
index d4d2e73e46c..4b894a19a23 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/CachedMTreeStore.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/CachedMTreeStore.java
@@ -373,8 +373,7 @@ public class CachedMTreeStore implements
IMTreeStore<ICachedMNode> {
lockManager.threadReadLock(node.getParent(), true);
}
try {
- operation.accept(node);
- memoryManager.updateCacheStatusAfterUpdate(node);
+ memoryManager.updateCacheStatusAndUpdate(node, operation);
} finally {
if (!node.isDatabase()) {
lockManager.threadReadUnlock(node.getParent());
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memcontrol/MemoryStatistics.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memcontrol/MemoryStatistics.java
index 3fef9dc2b26..5aa67533e7b 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memcontrol/MemoryStatistics.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memcontrol/MemoryStatistics.java
@@ -83,11 +83,17 @@ public class MemoryStatistics {
regionStatistics.updatePinnedMemorySize(deltaSize);
}
- public void addVolatileNode() {
+ public void addVolatileNode(ICachedMNode node) {
regionStatistics.updateVolatileMNodeNum(1);
+ regionStatistics.updateVolatileMNodeSize(node.estimateSize());
}
- public void removeVolatileNode() {
+ public void removeVolatileNode(ICachedMNode node) {
regionStatistics.updateVolatileMNodeNum(-1);
+ regionStatistics.updateVolatileMNodeSize(-node.estimateSize());
+ }
+
+ public void updateVolatileNodeSize(int deltaSize) {
+ regionStatistics.updateVolatileMNodeSize(deltaSize);
}
}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/IMemoryManager.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/IMemoryManager.java
index 103c3a3954e..950ca4184ea 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/IMemoryManager.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/IMemoryManager.java
@@ -26,6 +26,7 @@ import
org.apache.iotdb.db.schemaengine.schemaregion.mtree.impl.pbtree.mnode.ICa
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
/**
* This class implemented the cache management, involving the cache status
management on per MNode
@@ -59,7 +60,7 @@ public interface IMemoryManager {
void updateCacheStatusAfterAppend(ICachedMNode node);
- void updateCacheStatusAfterUpdate(ICachedMNode node);
+ void updateCacheStatusAndUpdate(ICachedMNode node, Consumer<ICachedMNode>
operation);
IDatabaseMNode<ICachedMNode> collectUpdatedStorageGroupMNodes();
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/MemoryManager.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/MemoryManager.java
index 22b3f139a20..fc6010b9ebe 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/MemoryManager.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/mtree/impl/pbtree/memory/MemoryManager.java
@@ -37,6 +37,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
import static
org.apache.iotdb.db.schemaengine.schemaregion.mtree.impl.pbtree.mnode.container.ICachedMNodeContainer.getBelongedContainer;
import static
org.apache.iotdb.db.schemaengine.schemaregion.mtree.impl.pbtree.mnode.container.ICachedMNodeContainer.getCachedMNodeContainer;
@@ -132,7 +133,7 @@ public class MemoryManager implements IMemoryManager {
pinMNodeWithMemStatusUpdate(node);
CacheEntry cacheEntry = getCacheEntry(node);
cacheEntry.setVolatile(true);
- memoryStatistics.addVolatileNode();
+ memoryStatistics.addVolatileNode(node);
// the ancestors must be processed first since the volatileDescendant
judgement is of higher
// priority than
// children container judgement
@@ -146,10 +147,12 @@ public class MemoryManager implements IMemoryManager {
* volatile subtree it belonged should be added to nodeBuffer.
*
* @param node
+ * @param operation
*/
@Override
- public void updateCacheStatusAfterUpdate(ICachedMNode node) {
+ public void updateCacheStatusAndUpdate(ICachedMNode node,
Consumer<ICachedMNode> operation) {
if (node.isDatabase()) {
+ operation.accept(node);
nodeBuffer.updateDatabaseNodeAfterStatusUpdate(node.getAsDatabaseMNode());
return;
}
@@ -157,11 +160,15 @@ public class MemoryManager implements IMemoryManager {
CacheEntry cacheEntry = getCacheEntry(node);
synchronized (cacheEntry) {
if (cacheEntry.isVolatile()) {
+ int rawSize = node.estimateSize();
+ operation.accept(node);
+ memoryStatistics.updateVolatileNodeSize(node.estimateSize() - rawSize);
return;
}
// the status change affects the subTre collect in nodeBuffer
+ operation.accept(node);
cacheEntry.setVolatile(true);
- memoryStatistics.addVolatileNode();
+ memoryStatistics.addVolatileNode(node);
if (!cacheEntry.hasVolatileDescendant()) {
nodeCache.removeFromNodeCache(cacheEntry);
removeAncestorsFromCache(node);
@@ -339,7 +346,7 @@ public class MemoryManager implements IMemoryManager {
synchronized (cacheEntry) {
cacheEntry.setVolatile(false);
- memoryStatistics.removeVolatileNode();
+ memoryStatistics.removeVolatileNode(node);
container.moveMNodeToCache(node.getName());
if (cacheEntry.hasVolatileDescendant()
@@ -388,7 +395,7 @@ public class MemoryManager implements IMemoryManager {
}
if (cacheEntry.isVolatile()) {
addAncestorsToCache(node);
- memoryStatistics.removeVolatileNode();
+ memoryStatistics.removeVolatileNode(node);
if (!getCacheEntry(node.getParent()).hasVolatileDescendant()) {
nodeBuffer.remove(getCacheEntry(node.getParent()));
}
diff --git
a/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-common.properties
b/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-common.properties
index da20238e2c7..389ba5acafe 100644
---
a/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-common.properties
+++
b/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-common.properties
@@ -298,7 +298,35 @@ data_replication_factor=1
# -1 means unlimited.
# database_limit_threshold = -1
+# Proportion of capacity allocated for node objects to page objects in
SchemaRegion. Calculated based on pbtree_page_pool_size_proportion allocated to
SchemaRegion memory.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# The parameter form is a:b, where a and b are integers.
+# pbtree_node_page_proportion = 2:1
+
+# Proportion of capacity allocated for dirty pages in the page pool buffer.
This ratio is a recommended value and will be dynamically adjusted during
runtime. For example, when dirty pages are empty, buffer pages can borrow space
from dirty pages.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# The parameter form is a:b, where a and b are integers.
+# pbtree_page_pool_cache_buffer_proportion = 1:3
+
+# Threshold for NodeCache eviction is SchemaRegion node object capacity *
pbtree_node_release_threshold_ratio.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# Datatype: double
+# pbtree_node_release_threshold_ratio = 0.7
+
+# Threshold for NodeFlush eviction is SchemaRegion node object capacity *
pbtree_node_flush_threshold_ratio.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# Datatype: double
+# pbtree_node_flush_threshold_ratio = 0.1
+# During scheduled dirty page flush, at most pbtree_page_flush_max_number
dirty pages are selected for flushing.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# Datatype: integer
+# pbtree_page_flush_max_number = 10
+
+# During scheduled dirty page flush, only dirty pages with an effective
information rate greater than pbtree_page_flush_min_dirty_ratio are selected
for flushing.
+# This parameter only takes effect when schema_engine_mode=PBTree.
+# Datatype: double
+# pbtree_page_flush_min_dirty_ratio = 0.3
####################
### Configurations for creating schema automatically
