This is an automated email from the ASF dual-hosted git repository.
tanxinyu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new a81c5c6ac70 Load: Support multi-disks awareness for IoTV2 and Pipe
(#15181)
a81c5c6ac70 is described below
commit a81c5c6ac70c551302c741ea18162e3e7adb6047
Author: Peng Junzhi <[email protected]>
AuthorDate: Thu Mar 27 16:48:26 2025 +0800
Load: Support multi-disks awareness for IoTV2 and Pipe (#15181)
* multi-disk aware
* get mount point
* enhance log
* fix up
* fix up
* fix import
* add test code
* use file store
* add strategy for load disk selector
* fix description
* fix review
* fix default
* spotless
* fix review
* adopt to multi-layer storage
---
.../java/org/apache/iotdb/db/conf/IoTDBConfig.java | 21 ++++
.../org/apache/iotdb/db/conf/IoTDBDescriptor.java | 17 +++-
.../db/storageengine/dataregion/DataRegion.java | 60 +++++++++--
.../storageengine/load/disk/ILoadDiskSelector.java | 66 ++++++++++++
.../InheritSystemMultiDisksStrategySelector.java | 58 +++++++++++
.../db/storageengine/load/disk/MinIOSelector.java | 112 +++++++++++++++++++++
.../apache/iotdb/metrics/utils/FileStoreUtils.java | 2 +-
.../conf/iotdb-system.properties.template | 21 ++++
8 files changed, 344 insertions(+), 13 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 f4c62d33585..b4fd0b78117 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
@@ -1128,6 +1128,10 @@ public class IoTDBConfig {
private boolean loadActiveListeningVerifyEnable = true;
+ private String loadDiskSelectStrategy;
+
+ private String loadDiskSelectStrategyForIoTV2AndPipe;
+
/** Pipe related */
/** initialized as empty, updated based on the latest `systemDir` during
querying */
private String[] pipeReceiverFileDirs = new String[0];
@@ -3849,6 +3853,23 @@ public class IoTDBConfig {
this.loadActiveListeningVerifyEnable = loadActiveListeningVerifyEnable;
}
+ public String getLoadDiskSelectStrategy() {
+ return loadDiskSelectStrategy;
+ }
+
+ public void setLoadDiskSelectStrategy(String loadDiskSelectStrategy) {
+ this.loadDiskSelectStrategy = loadDiskSelectStrategy;
+ }
+
+ public String getLoadDiskSelectStrategyForIoTV2AndPipe() {
+ return loadDiskSelectStrategyForIoTV2AndPipe;
+ }
+
+ public void setLoadDiskSelectStrategyForIoTV2AndPipe(
+ String loadDiskSelectStrategyForIoTV2AndPipe) {
+ this.loadDiskSelectStrategyForIoTV2AndPipe =
loadDiskSelectStrategyForIoTV2AndPipe;
+ }
+
public long getLoadActiveListeningCheckIntervalSeconds() {
return loadActiveListeningCheckIntervalSeconds;
}
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 98b80de001d..7c4b7bbb5f7 100755
---
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
@@ -32,6 +32,7 @@ import org.apache.iotdb.commons.utils.NodeUrlUtils;
import org.apache.iotdb.confignode.rpc.thrift.TCQConfig;
import org.apache.iotdb.confignode.rpc.thrift.TGlobalConfig;
import org.apache.iotdb.confignode.rpc.thrift.TRatisConfig;
+import org.apache.iotdb.consensus.config.PipeConsensusConfig;
import org.apache.iotdb.db.consensus.DataRegionConsensusImpl;
import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.service.metrics.IoTDBInternalLocalReporter;
@@ -47,6 +48,7 @@ import
org.apache.iotdb.db.storageengine.dataregion.compaction.selector.constant
import
org.apache.iotdb.db.storageengine.dataregion.compaction.selector.constant.InnerUnsequenceCompactionSelector;
import org.apache.iotdb.db.storageengine.dataregion.wal.WALManager;
import org.apache.iotdb.db.storageengine.dataregion.wal.utils.WALMode;
+import org.apache.iotdb.db.storageengine.load.disk.ILoadDiskSelector;
import org.apache.iotdb.db.storageengine.rescon.disk.TierManager;
import org.apache.iotdb.db.storageengine.rescon.memory.SystemInfo;
import org.apache.iotdb.db.utils.DateTimeUtils;
@@ -1152,8 +1154,7 @@ public class IoTDBDescriptor {
}
conf.setIotConsensusV2Mode(
properties.getProperty(
- "iot_consensus_v2_mode",
-
ConfigurationFileUtils.getConfigurationDefaultValue("iot_consensus_v2_mode")));
+ "iot_consensus_v2_mode",
PipeConsensusConfig.ReplicateMode.BATCH.getValue()));
int deletionAheadLogBufferQueueCapacity =
Integer.parseInt(
properties.getProperty(
@@ -2144,7 +2145,7 @@ public class IoTDBDescriptor {
}
}
- private void loadLoadTsFileProps(TrimProperties properties) {
+ private void loadLoadTsFileProps(TrimProperties properties) throws
IOException {
conf.setMaxAllocateMemoryRatioForLoad(
Double.parseDouble(
properties.getProperty(
@@ -2247,6 +2248,16 @@ public class IoTDBDescriptor {
properties.getProperty(
"load_active_listening_verify_enable",
Boolean.toString(conf.isLoadActiveListeningVerifyEnable()))));
+
+ conf.setLoadDiskSelectStrategy(
+ properties.getProperty(
+ "load_disk_select_strategy",
+ ILoadDiskSelector.LoadDiskSelectorType.MIN_IO_FIRST.getValue()));
+
+ conf.setLoadDiskSelectStrategyForIoTV2AndPipe(
+ properties.getProperty(
+ "load_disk_select_strategy_for_pipe_and_iotv2",
+ ILoadDiskSelector.LoadDiskSelectorType.INHERIT_LOAD.getValue()));
}
private void loadLoadTsFileHotModifiedProp(TrimProperties properties) throws
IOException {
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java
index 287939bedea..ee09a7c381c 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java
@@ -125,6 +125,9 @@ import
org.apache.iotdb.db.storageengine.dataregion.wal.recover.file.UnsealedTsF
import org.apache.iotdb.db.storageengine.dataregion.wal.utils.WALMode;
import
org.apache.iotdb.db.storageengine.dataregion.wal.utils.listener.WALFlushListener;
import
org.apache.iotdb.db.storageengine.dataregion.wal.utils.listener.WALRecoverListener;
+import org.apache.iotdb.db.storageengine.load.disk.ILoadDiskSelector;
+import
org.apache.iotdb.db.storageengine.load.disk.InheritSystemMultiDisksStrategySelector;
+import org.apache.iotdb.db.storageengine.load.disk.MinIOSelector;
import org.apache.iotdb.db.storageengine.load.limiter.LoadTsFileRateLimiter;
import org.apache.iotdb.db.storageengine.rescon.disk.TierManager;
import org.apache.iotdb.db.storageengine.rescon.memory.SystemInfo;
@@ -326,6 +329,9 @@ public class DataRegion implements IDataRegionForQuery {
private final DataRegionMetrics metrics;
+ private ILoadDiskSelector ordinaryLoadDiskSelector;
+ private ILoadDiskSelector pipeAndIoTV2LoadDiskSelector;
+
/**
* Construct a database processor.
*
@@ -389,6 +395,8 @@ public class DataRegion implements IDataRegionForQuery {
recover();
}
+ initDiskSelector();
+
this.metrics = new DataRegionMetrics(this);
MetricService.getInstance().addMetricSet(metrics);
}
@@ -402,6 +410,32 @@ public class DataRegion implements IDataRegionForQuery {
partitionMaxFileVersions.put(0L, 0L);
upgradeModFileThreadPool = null;
this.metrics = new DataRegionMetrics(this);
+
+ initDiskSelector();
+ }
+
+ private void initDiskSelector() {
+ switch
(ILoadDiskSelector.LoadDiskSelectorType.fromValue(config.getLoadDiskSelectStrategy()))
{
+ case INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY:
+ ordinaryLoadDiskSelector = new
InheritSystemMultiDisksStrategySelector();
+ break;
+ case MIN_IO_FIRST:
+ default:
+ ordinaryLoadDiskSelector = new MinIOSelector();
+ }
+
+ switch (ILoadDiskSelector.LoadDiskSelectorType.fromValue(
+ config.getLoadDiskSelectStrategyForIoTV2AndPipe())) {
+ case MIN_IO_FIRST:
+ pipeAndIoTV2LoadDiskSelector = new MinIOSelector();
+ break;
+ case INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY:
+ pipeAndIoTV2LoadDiskSelector = new
InheritSystemMultiDisksStrategySelector();
+ break;
+ case INHERIT_LOAD:
+ default:
+ pipeAndIoTV2LoadDiskSelector = ordinaryLoadDiskSelector;
+ }
}
@Override
@@ -3061,16 +3095,24 @@ public class DataRegion implements IDataRegionForQuery {
final boolean deleteOriginFile,
boolean isGeneratedByPipe)
throws LoadFileException, DiskSpaceInsufficientException {
+ final int targetTierLevel = 0;
final File targetFile =
- fsFactory.getFile(
- TierManager.getInstance().getNextFolderForTsFile(0, false),
- databaseName
- + File.separatorChar
- + dataRegionId
- + File.separatorChar
- + filePartitionId
- + File.separator
- + tsFileResource.getTsFile().getName());
+ (tsFileResource.isGeneratedByPipeConsensus() ||
tsFileResource.isGeneratedByPipe())
+ ? pipeAndIoTV2LoadDiskSelector.getTargetFile(
+ tsFileToLoad,
+ databaseName,
+ dataRegionId,
+ filePartitionId,
+ tsFileResource.getTsFile().getName(),
+ targetTierLevel)
+ : ordinaryLoadDiskSelector.getTargetFile(
+ tsFileToLoad,
+ databaseName,
+ dataRegionId,
+ filePartitionId,
+ tsFileResource.getTsFile().getName(),
+ targetTierLevel);
+
tsFileResource.setFile(targetFile);
if (tsFileManager.contains(tsFileResource, false)) {
logger.warn("The file {} has already been loaded in unsequence list",
tsFileResource);
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/ILoadDiskSelector.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/ILoadDiskSelector.java
new file mode 100644
index 00000000000..b14f0c4b5df
--- /dev/null
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/ILoadDiskSelector.java
@@ -0,0 +1,66 @@
+/*
+ * 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.iotdb.db.storageengine.load.disk;
+
+import org.apache.iotdb.db.exception.DiskSpaceInsufficientException;
+
+import java.io.File;
+
+public interface ILoadDiskSelector {
+
+ File getTargetFile(
+ File fileToLoad,
+ String databaseName,
+ String dataRegionId,
+ long filePartitionId,
+ String tsfileName,
+ int tierLevel)
+ throws DiskSpaceInsufficientException;
+
+ enum LoadDiskSelectorType {
+ MIN_IO_FIRST("MIN_IO_FIRST"),
+
INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY("INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY"),
+ // This type is specially designed for IoTV2 and Pipe, which means IoTV2
and Pipe will follow
+ // the same strategy as ordinary load.
+ INHERIT_LOAD("INHERIT_LOAD");
+
+ private final String value;
+
+ LoadDiskSelectorType(String value) {
+ this.value = value;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public static LoadDiskSelectorType fromValue(String value) {
+ if (value.equalsIgnoreCase(MIN_IO_FIRST.getValue())) {
+ return MIN_IO_FIRST;
+ } else if
(value.equalsIgnoreCase(INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY.getValue()))
{
+ return INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY;
+ } else if (value.equalsIgnoreCase(INHERIT_LOAD.getValue())) {
+ return INHERIT_LOAD;
+ }
+ // return MIN_IO_FIRST by default
+ return MIN_IO_FIRST;
+ }
+ }
+}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/InheritSystemMultiDisksStrategySelector.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/InheritSystemMultiDisksStrategySelector.java
new file mode 100644
index 00000000000..16e420c5e2f
--- /dev/null
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/InheritSystemMultiDisksStrategySelector.java
@@ -0,0 +1,58 @@
+/*
+ * 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.iotdb.db.storageengine.load.disk;
+
+import org.apache.iotdb.db.exception.DiskSpaceInsufficientException;
+import org.apache.iotdb.db.storageengine.rescon.disk.TierManager;
+
+import org.apache.tsfile.fileSystem.FSFactoryProducer;
+import org.apache.tsfile.fileSystem.fsFactory.FSFactory;
+
+import java.io.File;
+
+public class InheritSystemMultiDisksStrategySelector implements
ILoadDiskSelector {
+
+ protected final FSFactory fsFactory = FSFactoryProducer.getFSFactory();
+
+ public InheritSystemMultiDisksStrategySelector() {
+ // empty body
+ }
+
+ @Override
+ public File getTargetFile(
+ File fileToLoad,
+ String databaseName,
+ String dataRegionId,
+ long filePartitionId,
+ String tsfileName,
+ int tierLevel)
+ throws DiskSpaceInsufficientException {
+ // inherit system multi-disks select strategy, see configuration
`dn_multi_dir_strategy`
+ return fsFactory.getFile(
+ TierManager.getInstance().getNextFolderForTsFile(tierLevel, false),
+ databaseName
+ + File.separatorChar
+ + dataRegionId
+ + File.separatorChar
+ + filePartitionId
+ + File.separator
+ + tsfileName);
+ }
+}
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/MinIOSelector.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/MinIOSelector.java
new file mode 100644
index 00000000000..f6fac586700
--- /dev/null
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/disk/MinIOSelector.java
@@ -0,0 +1,112 @@
+/*
+ * 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.iotdb.db.storageengine.load.disk;
+
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.db.conf.IoTDBConfig;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.db.exception.DiskSpaceInsufficientException;
+import org.apache.iotdb.metrics.utils.FileStoreUtils;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.nio.file.FileStore;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+public class MinIOSelector extends InheritSystemMultiDisksStrategySelector {
+
+ private static final Logger logger =
LoggerFactory.getLogger(MinIOSelector.class);
+ private static final IoTDBConfig config =
IoTDBDescriptor.getInstance().getConfig();
+ private final Map<String, String> rootDisks2DataDirsMapForLoad;
+
+ public MinIOSelector() {
+ // init data dirs' root disks
+ this.rootDisks2DataDirsMapForLoad = new
HashMap<>(config.getTierDataDirs()[0].length);
+ Arrays.stream(config.getTierDataDirs()[0])
+ .filter(Objects::nonNull)
+ .map(v -> fsFactory.getFile(v,
IoTDBConstant.UNSEQUENCE_FOLDER_NAME).getPath())
+ .forEach(
+ dataDirPath -> {
+ File dataDirFile = new File(dataDirPath);
+ try {
+ FileStore fileStore =
FileStoreUtils.getFileStore(dataDirFile.getCanonicalPath());
+ if (fileStore != null) {
+ String mountPoint = fileStore.toString();
+ this.rootDisks2DataDirsMapForLoad.put(mountPoint,
dataDirPath);
+ logger.info("Add {}'s mount point {}", dataDirPath,
mountPoint);
+ } else {
+ logger.info(
+ "Failed to find mount point {}, skip register it to
map", dataDirPath);
+ }
+ } catch (Exception e) {
+ logger.warn(
+ "Exception occurs when reading data dir's mount point {}",
dataDirPath, e);
+ }
+ });
+ }
+
+ @Override
+ public File getTargetFile(
+ File fileToLoad,
+ String databaseName,
+ String dataRegionId,
+ long filePartitionId,
+ String tsfileName,
+ int tierLevel)
+ throws DiskSpaceInsufficientException {
+ File targetFile;
+ String fileDirRoot = null;
+ try {
+ fileDirRoot =
+
Optional.ofNullable(FileStoreUtils.getFileStore(fileToLoad.getCanonicalPath()))
+ .map(Object::toString)
+ .orElse(null);
+ } catch (Exception e) {
+ logger.warn("Exception occurs when reading target file's mount point
{}", filePartitionId, e);
+ }
+
+ if (rootDisks2DataDirsMapForLoad.containsKey(fileDirRoot)) {
+ // if there is an overlap between firDirRoot and data directories' disk
roots, try to get
+ // targetFile in the same disk
+ targetFile =
+ fsFactory.getFile(
+ rootDisks2DataDirsMapForLoad.get(fileDirRoot),
+ databaseName
+ + File.separatorChar
+ + dataRegionId
+ + File.separatorChar
+ + filePartitionId
+ + File.separator
+ + tsfileName);
+
+ return targetFile;
+ }
+
+ // if there isn't an overlap, downgrade to storage balance(sequence)
strategy.
+ return super.getTargetFile(
+ fileToLoad, databaseName, dataRegionId, filePartitionId, tsfileName,
tierLevel);
+ }
+}
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/utils/FileStoreUtils.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/utils/FileStoreUtils.java
index 1698f7d0ac1..5b41da6f673 100644
---
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/utils/FileStoreUtils.java
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/utils/FileStoreUtils.java
@@ -32,7 +32,7 @@ import java.nio.file.Paths;
public class FileStoreUtils {
private static final Logger logger =
LoggerFactory.getLogger(FileStoreUtils.class);
- // get the FileStore of dir .if current dir is not exists, check parent dir.
+ // get the FileStore of dir. if current dir is not exists, check parent dir.
// for example, the dn_wal_dirs default value is data/datanode/wal and
system will save the
// data in the relative path directory it indicates under the IoTDB folder.
// it will check the parent dir until find the existing dir.
diff --git
a/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-system.properties.template
b/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-system.properties.template
index e3ab5cdf39e..4318cf128aa 100644
---
a/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-system.properties.template
+++
b/iotdb-core/node-commons/src/assembly/resources/conf/iotdb-system.properties.template
@@ -242,6 +242,27 @@ dn_data_dirs=data/datanode/data
# Datatype: String
dn_multi_dir_strategy=SequenceStrategy
+# load_disk_select_strategy
+# The strategy is used to choose a proper disk for loading tsfile.
+# The info of the two strategies are as follows:
+# 1. MIN_IO_FIRST: the system will try to choose the same disk as tsFileToLoad
for loading.
+# 2. INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY: the system will choose one
disk according to dn_multi_dir_strategy.
+# If this property is unset, system will use MIN_IO_FIRST as default strategy.
+# effectiveMode: restart
+# Datatype: String
+load_disk_select_strategy=MIN_IO_FIRST
+
+# load_disk_select_strategy_for_pipe_and_iotv2
+# The strategy is used to choose a proper disk for loading tsfile.
+# The info of the three strategies are as follows:
+# 1. MIN_IO_FIRST: the system will try to choose the same disk as tsFileToLoad
for loading.
+# 2. INHERIT_SYSTEM_MULTI_DISKS_SELECT_STRATEGY: the system will choose one
disk according to dn_multi_dir_strategy.
+$ 3. INHERIT_LOAD: the system will use the same strategy as
load_disk_select_strategy.
+# If this property is unset, system will use INHERIT_LOAD as default strategy.
+# effectiveMode: restart
+# Datatype: String
+load_disk_select_strategy_for_pipe_and_iotv2=INHERIT_LOAD
+
# consensus dir
# If this property is unset, system will save the data in the default relative
path directory under the IoTDB folder(i.e., %IOTDB_HOME%/data/datanode).
# If it is absolute, system will save the data in the exact location it points
to.
