You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by qi...@apache.org on 2021/01/19 08:15:25 UTC
[iotdb] branch master updated: Add DirectByteBufferPool for WAL
(#2488)
This is an automated email from the ASF dual-hosted git repository.
qiaojialin 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 e451dcf Add DirectByteBufferPool for WAL (#2488)
e451dcf is described below
commit e451dcf818561a8b27323379ef25aaadf51f75bb
Author: Jackie Tien <Ja...@foxmail.com>
AuthorDate: Tue Jan 19 16:15:08 2021 +0800
Add DirectByteBufferPool for WAL (#2488)
---
LICENSE-binary | 20 ++--
pom.xml | 12 +-
server/pom.xml | 5 +
.../org/apache/iotdb/db/engine/StorageEngine.java | 15 ++-
.../db/engine/storagegroup/StorageGroupInfo.java | 51 ++++++++-
.../engine/storagegroup/StorageGroupProcessor.java | 122 ++++++++++++++++++++-
.../db/engine/storagegroup/TsFileProcessor.java | 14 +--
.../virtualSg/VirtualStorageGroupManager.java | 8 ++
.../org/apache/iotdb/db/metadata/MManager.java | 89 ++++++++-------
.../java/org/apache/iotdb/db/utils/MmapUtil.java | 32 ++++++
.../writelog/manager/MultiFileLogNodeManager.java | 27 +++--
.../db/writelog/manager/WriteLogNodeManager.java | 7 +-
.../db/writelog/node/ExclusiveWriteLogNode.java | 18 ++-
.../iotdb/db/writelog/node/WriteLogNode.java | 8 +-
.../iotdb/db/writelog/recover/LogReplayer.java | 12 +-
.../writelog/recover/TsFileRecoverPerformer.java | 16 ++-
.../storagegroup/StorageGroupProcessorTest.java | 12 +-
.../db/integration/auth/IoTDBAuthorizationIT.java | 21 ----
.../iotdb/db/writelog/IoTDBLogFileSizeTest.java | 25 ++++-
.../apache/iotdb/db/writelog/PerformanceTest.java | 48 ++++++--
.../iotdb/db/writelog/WriteLogNodeManagerTest.java | 63 +++++++++--
.../apache/iotdb/db/writelog/WriteLogNodeTest.java | 71 ++++++++++--
.../iotdb/db/writelog/recover/LogReplayerTest.java | 24 +++-
.../recover/RecoverResourceFromReaderTest.java | 54 +++++++--
.../db/writelog/recover/SeqTsFileRecoverTest.java | 51 +++++++--
.../writelog/recover/UnseqTsFileRecoverTest.java | 31 +++++-
26 files changed, 670 insertions(+), 186 deletions(-)
diff --git a/LICENSE-binary b/LICENSE-binary
index adf5967..e844547 100644
--- a/LICENSE-binary
+++ b/LICENSE-binary
@@ -251,16 +251,16 @@ io.dropwizard.metrics:metrics-json:3.2.6
io.dropwizard.metrics:metrics-jvm:3.2.6
com.librato.metrics:metrics-librato:5.1.0
io.moquette:moquette-broker:0.13
-io.netty:netty-buffer:4.1.22.Final
-io.netty:netty-codec:4.1.22.Final
-io.netty:netty-codec-http:4.1.22.Final
-io.netty:netty-codec-mqtt:4.1.22.Final
-io.netty:netty-common:4.1.22.Final
-io.netty:netty-handler:4.1.22.Final
-io.netty:netty-resolver:4.1.22.Final
-io.netty:netty-transport:4.1.22.Final
-io.netty:netty-transport-native-epoll:4.1.22.Final:linux-x86_64
-io.netty:netty-transport-native-unix-common:4.1.22.Final
+io.netty:netty-buffer:4.1.27.Final
+io.netty:netty-codec:4.1.27.Final
+io.netty:netty-codec-http:4.1.27.Final
+io.netty:netty-codec-mqtt:4.1.27.Final
+io.netty:netty-common:4.1.27.Final
+io.netty:netty-handler:4.1.27.Final
+io.netty:netty-resolver:4.1.27.Final
+io.netty:netty-transport:4.1.27.Final
+io.netty:netty-transport-native-epoll:4.1.27.Final:linux-x86_64
+io.netty:netty-transport-native-unix-common:4.1.27.Final
com.nimbusds:nimbus-jose-jwt:8.14.1
com.nimbusds:oauth2-oidc-sdk:8.3
org.osgi:org.osgi.core:6.0.0
diff --git a/pom.xml b/pom.xml
index 9a8c06c..05b82bd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -229,7 +229,17 @@
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
- <version>4.1.42.Final</version>
+ <version>4.1.27.Final</version>
+ </dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty-buffer</artifactId>
+ <version>4.1.27.Final</version>
+ </dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty-common</artifactId>
+ <version>4.1.27.Final</version>
</dependency>
<dependency>
<groupId>javax.annotation</groupId>
diff --git a/server/pom.xml b/server/pom.xml
index ff38b75..2591bec 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -191,6 +191,11 @@
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty-buffer</artifactId>
+ <version>4.1.27.Final</version>
+ </dependency>
</dependencies>
<build>
<plugins>
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
index cca2510..1170733 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
@@ -335,6 +335,9 @@ public class StorageEngine implements IService {
+ "recoverAllSgThreadPool.", e);
}
}
+ for (PartialPath storageGroup : IoTDB.metaManager.getAllStorageGroupPaths()) {
+ this.releaseWalDirectByteBufferPoolInOneStorageGroup(storageGroup);
+ }
this.reset();
}
@@ -485,7 +488,7 @@ public class StorageEngine implements IService {
* This function is just for unit test.
*/
public synchronized void reset() {
- for(VirtualStorageGroupManager virtualStorageGroupManager : processorMap.values()){
+ for (VirtualStorageGroupManager virtualStorageGroupManager : processorMap.values()) {
virtualStorageGroupManager.reset();
}
}
@@ -726,6 +729,15 @@ public class StorageEngine implements IService {
}
/**
+ * release all the allocated non-heap
+ */
+ public void releaseWalDirectByteBufferPoolInOneStorageGroup(PartialPath storageGroupPath) {
+ if (processorMap.containsKey(storageGroupPath)) {
+ processorMap.get(storageGroupPath).releaseWalDirectByteBufferPool();
+ }
+ }
+
+ /**
* delete all data of storage groups' timeseries.
*/
public synchronized boolean deleteAll() {
@@ -753,6 +765,7 @@ public class StorageEngine implements IService {
}
deleteAllDataFilesInOneStorageGroup(storageGroupPath);
+ releaseWalDirectByteBufferPoolInOneStorageGroup(storageGroupPath);
VirtualStorageGroupManager virtualStorageGroupManager = processorMap.remove(storageGroupPath);
virtualStorageGroupManager
.deleteStorageGroup(systemDir + File.pathSeparator + storageGroupPath);
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupInfo.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupInfo.java
index a31d41a..340b3a2 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupInfo.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupInfo.java
@@ -18,12 +18,18 @@
*/
package org.apache.iotdb.db.engine.storagegroup;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.rescon.SystemInfo;
+import org.apache.iotdb.db.utils.MmapUtil;
+import org.apache.iotdb.db.utils.TestOnly;
/**
* The storageGroupInfo records the total memory cost of the Storage Group.
@@ -33,15 +39,15 @@ public class StorageGroupInfo {
private StorageGroupProcessor storageGroupProcessor;
/**
- * The total Storage group memory cost,
- * including unsealed TsFileResource, ChunkMetadata, WAL, primitive arrays and TEXT values
+ * The total Storage group memory cost, including unsealed TsFileResource, ChunkMetadata, WAL,
+ * primitive arrays and TEXT values
*/
private AtomicLong memoryCost;
/**
* The threshold of reporting it's size to SystemInfo
*/
- private long storageGroupSizeReportThreshold =
+ private long storageGroupSizeReportThreshold =
IoTDBDescriptor.getInstance().getConfig().getStorageGroupSizeReportThreshold();
private AtomicLong lastReportedSize = new AtomicLong();
@@ -94,13 +100,46 @@ public class StorageGroupInfo {
}
/**
- * When a TsFileProcessor is closing, remove it from reportedTsps, and report to systemInfo
- * to update SG cost.
- *
+ * When a TsFileProcessor is closing, remove it from reportedTsps, and report to systemInfo to
+ * update SG cost.
+ *
* @param tsFileProcessor
*/
public void closeTsFileProcessorAndReportToSystem(TsFileProcessor tsFileProcessor) {
reportedTsps.remove(tsFileProcessor);
SystemInfo.getInstance().resetStorageGroupStatus(this, true);
}
+
+ public Supplier<ByteBuffer[]> getWalSupplier() {
+ if (storageGroupProcessor != null) {
+ return storageGroupProcessor::getWalDirectByteBuffer;
+ } else { // only happens in test
+ return this::walSupplier;
+ }
+ }
+
+ @TestOnly
+ private ByteBuffer[] walSupplier() {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ }
+
+ public Consumer<ByteBuffer[]> getWalConsumer() {
+ if (storageGroupProcessor != null) {
+ return storageGroupProcessor::releaseWalBuffer;
+ } else { // only happens in test
+ return this::walConsumer;
+ }
+ }
+
+ @TestOnly
+ private void walConsumer(ByteBuffer[] buffers) {
+ for (ByteBuffer byteBuffer : buffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessor.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessor.java
index adeac80..ed8f199 100755
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessor.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessor.java
@@ -25,11 +25,14 @@ import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFF
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
+import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
@@ -38,7 +41,10 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
+import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.apache.commons.io.FileUtils;
@@ -84,6 +90,7 @@ import org.apache.iotdb.db.query.control.QueryFileManager;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.service.UpgradeSevice;
import org.apache.iotdb.db.utils.CopyOnReadLinkedList;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.utils.TestOnly;
import org.apache.iotdb.db.writelog.recover.TsFileRecoverPerformer;
import org.apache.iotdb.rpc.RpcUtils;
@@ -241,6 +248,100 @@ public class StorageGroupProcessor {
private List<CloseFileListener> customCloseFileListeners = Collections.emptyList();
private List<FlushListener> customFlushListeners = Collections.emptyList();
+ private static final int WAL_BUFFER_SIZE =
+ IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2;
+
+ private static final int MAX_WAL_BYTEBUFFER_NUM =
+ IoTDBDescriptor.getInstance().getConfig().getConcurrentWritingTimePartition() * 4;
+
+ private static final long DEFAULT_POOL_TRIM_INTERVAL_MILLIS = 10_000;
+
+ private final Deque<ByteBuffer> walByteBufferPool = new LinkedList<>();
+
+ private int currentWalPoolSize = 0;
+
+ // this field is used to avoid when one writer release bytebuffer back to pool,
+ // and the next writer has already arrived, but the check thread get the lock first, it find the pool
+ // is not empty, so it free the memory. When the next writer get the lock, it will apply the memory again.
+ // So our free memory strategy is only when the expected size less than the current pool size
+ // and the pool is not empty and the time interval since the pool is not empty is larger than DEFAULT_POOL_TRIM_INTERVAL_MILLIS
+ private long timeWhenPoolNotEmpty = Long.MAX_VALUE;
+
+
+ /**
+ * get the direct byte buffer from pool, each fetch contains two ByteBuffer
+ */
+ public ByteBuffer[] getWalDirectByteBuffer() {
+ ByteBuffer[] res = new ByteBuffer[2];
+ synchronized (walByteBufferPool) {
+ while (walByteBufferPool.isEmpty() && currentWalPoolSize + 2 > MAX_WAL_BYTEBUFFER_NUM) {
+ try {
+ walByteBufferPool.wait();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ logger
+ .error("getDirectByteBuffer occurs error while waiting for DirectByteBuffer"
+ + "group {}-{}", logicalStorageGroupName, virtualStorageGroupId, e);
+ }
+ }
+ // If the queue is not empty, it must have at least two.
+ if (!walByteBufferPool.isEmpty()) {
+ res[0] = walByteBufferPool.pollFirst();
+ res[1] = walByteBufferPool.pollFirst();
+ } else {
+ // if the queue is empty and current size is less than MAX_BYTEBUFFER_NUM
+ // we can construct another two more new byte buffer
+ currentWalPoolSize += 2;
+ res[0] = ByteBuffer.allocateDirect(WAL_BUFFER_SIZE);
+ res[1] = ByteBuffer.allocateDirect(WAL_BUFFER_SIZE);
+ }
+ // if the pool is empty, set the time back to MAX_VALUE
+ if (walByteBufferPool.isEmpty()) {
+ timeWhenPoolNotEmpty = Long.MAX_VALUE;
+ }
+ }
+ return res;
+ }
+
+ /**
+ * put the byteBuffer back to pool
+ */
+ public void releaseWalBuffer(ByteBuffer[] byteBuffers) {
+ for (ByteBuffer byteBuffer : byteBuffers) {
+ byteBuffer.clear();
+ }
+ synchronized (walByteBufferPool) {
+ // if the pool is empty before, update the time
+ if (walByteBufferPool.isEmpty()) {
+ timeWhenPoolNotEmpty = System.nanoTime();
+ }
+ walByteBufferPool.addLast(byteBuffers[0]);
+ walByteBufferPool.addLast(byteBuffers[1]);
+ walByteBufferPool.notifyAll();
+ }
+ }
+
+ /**
+ * trim the size of the pool and release the memory of needless direct byte buffer
+ */
+ private void trimTask() {
+ synchronized (walByteBufferPool) {
+ int expectedSize =
+ (workSequenceTsFileProcessors.size() + workUnsequenceTsFileProcessors.size()) * 2;
+ // the unit is ms
+ long poolNotEmptyIntervalInMS = (System.nanoTime() - timeWhenPoolNotEmpty) / 1_000_000;
+ // only when the expected size less than the current pool size
+ // and the pool is not empty and the time interval since the pool is not empty is larger than 10s
+ // we will trim the size to expectedSize until the pool is empty
+ while (expectedSize < currentWalPoolSize && !walByteBufferPool.isEmpty()
+ && poolNotEmptyIntervalInMS >= DEFAULT_POOL_TRIM_INTERVAL_MILLIS) {
+ MmapUtil.clean((MappedByteBuffer) walByteBufferPool.removeLast());
+ MmapUtil.clean((MappedByteBuffer) walByteBufferPool.removeLast());
+ currentWalPoolSize -= 2;
+ }
+ }
+ }
+
/**
* constrcut a storage group processor
*
@@ -267,6 +368,9 @@ public class StorageGroupProcessor {
this.tsFileManagement = IoTDBDescriptor.getInstance().getConfig().getCompactionStrategy()
.getTsFileManagement(logicalStorageGroupName, storageGroupSysDir.getAbsolutePath());
+ ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
+ executorService.scheduleWithFixedDelay(this::trimTask, DEFAULT_POOL_TRIM_INTERVAL_MILLIS,
+ DEFAULT_POOL_TRIM_INTERVAL_MILLIS, TimeUnit.MILLISECONDS);
recover();
}
@@ -552,7 +656,8 @@ public class StorageGroupProcessor {
try {
// this tsfile is not zero level, no need to perform redo wal
if (LevelCompactionTsFileManagement.getMergeLevel(tsFileResource.getTsFile()) > 0) {
- writer = recoverPerformer.recover(false);
+ writer = recoverPerformer
+ .recover(false, this::getWalDirectByteBuffer, this::releaseWalBuffer);
if (writer.hasCrashed()) {
tsFileManagement.addRecover(tsFileResource, isSeq);
} else {
@@ -561,7 +666,8 @@ public class StorageGroupProcessor {
}
continue;
} else {
- writer = recoverPerformer.recover(true);
+ writer = recoverPerformer
+ .recover(true, this::getWalDirectByteBuffer, this::releaseWalBuffer);
}
} catch (StorageGroupProcessorException e) {
logger.warn("Skip TsFile: {} because of error in recover: ", tsFileResource.getTsFilePath(),
@@ -1163,6 +1269,15 @@ public class StorageGroupProcessor {
}
}
+ public void releaseWalDirectByteBufferPool() {
+ synchronized (walByteBufferPool) {
+ while (!walByteBufferPool.isEmpty()) {
+ MmapUtil.clean((MappedByteBuffer) walByteBufferPool.removeFirst());
+ currentWalPoolSize--;
+ }
+ }
+ }
+
public void syncDeleteDataFiles() {
logger.info("{} will close all files for deleting data files", logicalStorageGroupName + "-" + virtualStorageGroupId);
writeLock();
@@ -1524,7 +1639,8 @@ public class StorageGroupProcessor {
}
private void deleteDataInFiles(Collection<TsFileResource> tsFileResourceList, Deletion deletion,
- Set<PartialPath> devicePaths, List<ModificationFile> updatedModFiles, long planIndex) throws IOException {
+ Set<PartialPath> devicePaths, List<ModificationFile> updatedModFiles, long planIndex)
+ throws IOException {
for (TsFileResource tsFileResource : tsFileResourceList) {
if (canSkipDelete(tsFileResource, devicePaths, deletion.getStartTime(),
deletion.getEndTime())) {
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
index 8160068..5878628 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
@@ -134,9 +134,7 @@ public class TsFileProcessor {
throws IOException {
this.storageGroupName = storageGroupName;
this.tsFileResource = new TsFileResource(tsfile, this, deviceNumInLastClosedTsFile);
- if (enableMemControl) {
- this.storageGroupInfo = storageGroupInfo;
- }
+ this.storageGroupInfo = storageGroupInfo;
this.writer = new RestorableTsFileIOWriter(tsfile);
this.updateLatestFlushTimeCallback = updateLatestFlushTimeCallback;
this.sequence = sequence;
@@ -152,9 +150,7 @@ public class TsFileProcessor {
RestorableTsFileIOWriter writer) {
this.storageGroupName = storageGroupName;
this.tsFileResource = tsFileResource;
- if (enableMemControl) {
- this.storageGroupInfo = storageGroupInfo;
- }
+ this.storageGroupInfo = storageGroupInfo;
this.writer = writer;
this.updateLatestFlushTimeCallback = updateLatestFlushTimeCallback;
this.sequence = sequence;
@@ -882,7 +878,8 @@ public class TsFileProcessor {
public WriteLogNode getLogNode() {
if (logNode == null) {
logNode = MultiFileLogNodeManager.getInstance()
- .getNode(storageGroupName + "-" + tsFileResource.getTsFile().getName());
+ .getNode(storageGroupName + "-" + tsFileResource.getTsFile().getName(),
+ storageGroupInfo.getWalSupplier());
}
return logNode;
}
@@ -892,7 +889,8 @@ public class TsFileProcessor {
// when closing resource file, its corresponding mod file is also closed.
tsFileResource.close();
MultiFileLogNodeManager.getInstance()
- .deleteNode(storageGroupName + "-" + tsFileResource.getTsFile().getName());
+ .deleteNode(storageGroupName + "-" + tsFileResource.getTsFile().getName(),
+ storageGroupInfo.getWalConsumer());
} catch (IOException e) {
throw new TsFileProcessorException(e);
}
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/virtualSg/VirtualStorageGroupManager.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/virtualSg/VirtualStorageGroupManager.java
index 13dec3e..dc2877c 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/virtualSg/VirtualStorageGroupManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/virtualSg/VirtualStorageGroupManager.java
@@ -417,6 +417,14 @@ public class VirtualStorageGroupManager {
}
}
+ public void releaseWalDirectByteBufferPool() {
+ for (StorageGroupProcessor storageGroupProcessor : virtualStorageGroupProcessor) {
+ if (storageGroupProcessor != null) {
+ storageGroupProcessor.releaseWalDirectByteBufferPool();
+ }
+ }
+ }
+
/**
* only for test
*/
diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
index 4683c80..4482a58 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
@@ -200,13 +200,12 @@ public class MManager {
}
};
-
if (config.isEnableMTreeSnapshot()) {
timedCreateMTreeSnapshotThread = Executors.newSingleThreadScheduledExecutor(r -> new Thread(r,
- "timedCreateMTreeSnapshotThread"));
+ "timedCreateMTreeSnapshotThread"));
timedCreateMTreeSnapshotThread
- .scheduleAtFixedRate(this::checkMTreeModified, MTREE_SNAPSHOT_THREAD_CHECK_TIME,
- MTREE_SNAPSHOT_THREAD_CHECK_TIME, TimeUnit.SECONDS);
+ .scheduleAtFixedRate(this::checkMTreeModified, MTREE_SNAPSHOT_THREAD_CHECK_TIME,
+ MTREE_SNAPSHOT_THREAD_CHECK_TIME, TimeUnit.SECONDS);
}
}
@@ -240,7 +239,8 @@ public class MManager {
logWriter.setLogNum(lineNumber);
isRecovering = false;
} catch (IOException | MetadataException e) {
- logger.error("Cannot recover all MTree from file, we try to recover as possible as we can", e);
+ logger
+ .error("Cannot recover all MTree from file, we try to recover as possible as we can", e);
}
reportedDataTypeTotalNum = 0L;
initialized = true;
@@ -271,13 +271,14 @@ public class MManager {
// init the metadata from the operation log
if (logFile.exists()) {
int idx = 0;
- try (MLogReader mLogReader = new MLogReader(config.getSchemaDir(), MetadataConstant.METADATA_LOG);) {
+ try (MLogReader mLogReader = new MLogReader(config.getSchemaDir(),
+ MetadataConstant.METADATA_LOG);) {
idx = applyMlog(mLogReader);
logger.debug("spend {} ms to deserialize mtree from mlog.bin",
System.currentTimeMillis() - time);
return idx;
} catch (Exception e) {
- throw new IOException("Failed to parser mlog.bin for err:" + e.toString());
+ throw new IOException("Failed to parser mlog.bin for err:" + e.toString());
}
} else {
return 0;
@@ -296,7 +297,8 @@ public class MManager {
operation(plan);
idx++;
} catch (Exception e) {
- logger.error("Can not operate cmd {} for err:", plan == null ? "" : plan.getOperatorType(), e);
+ logger.error("Can not operate cmd {} for err:", plan == null ? "" : plan.getOperatorType(),
+ e);
}
}
return idx;
@@ -464,8 +466,8 @@ public class MManager {
/**
* Delete all timeseries under the given path, may cross different storage group
*
- * @param prefixPath path to be deleted, could be root or a prefix path or a full path
- * TODO: directly return the failed string set
+ * @param prefixPath path to be deleted, could be root or a prefix path or a full path TODO:
+ * directly return the failed string set
* @return The String is the deletion failed Timeseries
*/
public String deleteTimeseries(PartialPath prefixPath) throws MetadataException {
@@ -474,7 +476,7 @@ public class MManager {
}
try {
List<PartialPath> allTimeseries = mtree.getAllTimeseriesPath(prefixPath);
- if(allTimeseries.isEmpty()){
+ if (allTimeseries.isEmpty()) {
throw new PathNotExistException(prefixPath.getFullPath());
}
// Monitor storage group seriesPath is not allowed to be deleted
@@ -498,6 +500,8 @@ public class MManager {
if (!isRecovering) {
if (emptyStorageGroup != null) {
StorageEngine.getInstance().deleteAllDataFilesInOneStorageGroup(emptyStorageGroup);
+ StorageEngine.getInstance()
+ .releaseWalDirectByteBufferPoolInOneStorageGroup(emptyStorageGroup);
}
deleteTimeSeriesPlan.setDeletePathList(Collections.singletonList(p));
logWriter.deleteTimeseries(deleteTimeSeriesPlan);
@@ -560,7 +564,7 @@ public class MManager {
// TODO: delete the path node and all its ancestors
mNodeCache.clear();
totalSeriesNumber.addAndGet(-1);
- if (!allowToCreateNewSeries &&
+ if (!allowToCreateNewSeries &&
totalSeriesNumber.get() * ESTIMATED_SERIES_SIZE < MTREE_SIZE_THRESHOLD) {
logger.info("Current series number {} come back to normal level", totalSeriesNumber);
allowToCreateNewSeries = true;
@@ -597,7 +601,7 @@ public class MManager {
for (PartialPath storageGroup : storageGroups) {
totalSeriesNumber.addAndGet(mtree.getAllTimeseriesCount(storageGroup));
// clear cached MNode
- if (!allowToCreateNewSeries &&
+ if (!allowToCreateNewSeries &&
totalSeriesNumber.get() * ESTIMATED_SERIES_SIZE < MTREE_SIZE_THRESHOLD) {
logger.info("Current series number {} come back to normal level", totalSeriesNumber);
allowToCreateNewSeries = true;
@@ -814,7 +818,7 @@ public class MManager {
@SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
private List<ShowTimeSeriesResult> showTimeseriesWithIndex(ShowTimeSeriesPlan plan,
- QueryContext context) throws MetadataException {
+ QueryContext context) throws MetadataException {
if (!tagIndex.containsKey(plan.getKey())) {
throw new MetadataException("The key " + plan.getKey() + " is not a tag.", true);
}
@@ -1194,14 +1198,14 @@ public class MManager {
if (tagsMap != null) {
for (Entry<String, String> entry : tagsMap.entrySet()) {
tagIndex.computeIfAbsent(entry.getKey(), k -> new ConcurrentHashMap<>())
- .computeIfAbsent(entry.getValue(), v -> new CopyOnWriteArraySet<>()).add(leafMNode);
+ .computeIfAbsent(entry.getValue(), v -> new CopyOnWriteArraySet<>()).add(leafMNode);
}
}
return;
}
Pair<Map<String, String>, Map<String, String>> pair =
- tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
+ tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
if (tagsMap != null) {
for (Entry<String, String> entry : tagsMap.entrySet()) {
@@ -1216,8 +1220,8 @@ public class MManager {
if (tagIndex.containsKey(key) && tagIndex.get(key).containsKey(beforeValue)) {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG, "Upsert" + TAG_FORMAT, leafMNode.getFullPath()),
- key, beforeValue, leafMNode.getOffset()));
+ String.format(DEBUG_MSG, "Upsert" + TAG_FORMAT, leafMNode.getFullPath()),
+ key, beforeValue, leafMNode.getOffset()));
}
tagIndex.get(key).get(beforeValue).remove(leafMNode);
@@ -1227,8 +1231,9 @@ public class MManager {
} else {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG_1, "Upsert" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
- key, beforeValue, leafMNode.getOffset(), tagIndex.containsKey(key)));
+ String
+ .format(DEBUG_MSG_1, "Upsert" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
+ key, beforeValue, leafMNode.getOffset(), tagIndex.containsKey(key)));
}
}
}
@@ -1237,7 +1242,7 @@ public class MManager {
// we should add a new key-value to inverted index map
if (beforeValue == null || !beforeValue.equals(value)) {
tagIndex.computeIfAbsent(key, k -> new ConcurrentHashMap<>())
- .computeIfAbsent(value, v -> new CopyOnWriteArraySet<>()).add(leafMNode);
+ .computeIfAbsent(value, v -> new CopyOnWriteArraySet<>()).add(leafMNode);
}
}
}
@@ -1246,7 +1251,6 @@ public class MManager {
pair.right.putAll(attributesMap);
}
-
// persist the change to disk
tagLogFile.write(pair.left, pair.right, leafMNode.getOffset());
}
@@ -1273,14 +1277,14 @@ public class MManager {
}
Pair<Map<String, String>, Map<String, String>> pair =
- tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
+ tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
for (Entry<String, String> entry : attributesMap.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
if (pair.right.containsKey(key)) {
throw new MetadataException(
- String.format("TimeSeries [%s] already has the attribute [%s].", fullPath, key));
+ String.format("TimeSeries [%s] already has the attribute [%s].", fullPath, key));
}
pair.right.put(key, value);
}
@@ -1310,20 +1314,20 @@ public class MManager {
// update inverted Index map
for (Entry<String, String> entry : tagsMap.entrySet()) {
tagIndex.computeIfAbsent(entry.getKey(), k -> new ConcurrentHashMap<>())
- .computeIfAbsent(entry.getValue(), v -> new CopyOnWriteArraySet<>()).add(leafMNode);
+ .computeIfAbsent(entry.getValue(), v -> new CopyOnWriteArraySet<>()).add(leafMNode);
}
return;
}
Pair<Map<String, String>, Map<String, String>> pair =
- tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
+ tagLogFile.read(config.getTagAttributeTotalSize(), leafMNode.getOffset());
for (Entry<String, String> entry : tagsMap.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
if (pair.left.containsKey(key)) {
throw new MetadataException(
- String.format("TimeSeries [%s] already has the tag [%s].", fullPath, key));
+ String.format("TimeSeries [%s] already has the tag [%s].", fullPath, key));
}
pair.left.put(key, value);
}
@@ -1333,7 +1337,7 @@ public class MManager {
// update tag inverted map
tagsMap.forEach((key, value) -> tagIndex.computeIfAbsent(key, k -> new ConcurrentHashMap<>())
- .computeIfAbsent(value, v -> new CopyOnWriteArraySet<>()).add(leafMNode));
+ .computeIfAbsent(value, v -> new CopyOnWriteArraySet<>()).add(leafMNode));
}
/**
@@ -1402,8 +1406,8 @@ public class MManager {
} else {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG_1, "Drop" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
- key, value, leafMNode.getOffset(), tagIndex.containsKey(key)));
+ String.format(DEBUG_MSG_1, "Drop" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
+ key, value, leafMNode.getOffset(), tagIndex.containsKey(key)));
}
}
@@ -1448,7 +1452,8 @@ public class MManager {
pair.right.put(key, value);
} else {
throw new MetadataException(
- String.format("TimeSeries [%s] does not have tag/attribute [%s].", fullPath, key), true);
+ String.format("TimeSeries [%s] does not have tag/attribute [%s].", fullPath, key),
+ true);
}
}
@@ -1464,16 +1469,16 @@ public class MManager {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG, "Set" + TAG_FORMAT, leafMNode.getFullPath()),
- entry.getKey(), beforeValue, leafMNode.getOffset()));
+ String.format(DEBUG_MSG, "Set" + TAG_FORMAT, leafMNode.getFullPath()),
+ entry.getKey(), beforeValue, leafMNode.getOffset()));
}
tagIndex.get(key).get(beforeValue).remove(leafMNode);
} else {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG_1, "Set" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
- key, beforeValue, leafMNode.getOffset(), tagIndex.containsKey(key)));
+ String.format(DEBUG_MSG_1, "Set" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
+ key, beforeValue, leafMNode.getOffset(), tagIndex.containsKey(key)));
}
}
tagIndex.computeIfAbsent(key, k -> new ConcurrentHashMap<>())
@@ -1498,7 +1503,8 @@ public class MManager {
MeasurementMNode leafMNode = (MeasurementMNode) mNode;
if (leafMNode.getOffset() < 0) {
throw new MetadataException(
- String.format("TimeSeries [%s] does not have [%s] tag/attribute.", fullPath, oldKey), true);
+ String.format("TimeSeries [%s] does not have [%s] tag/attribute.", fullPath, oldKey),
+ true);
}
// tags, attributes
Pair<Map<String, String>, Map<String, String>> pair =
@@ -1522,8 +1528,8 @@ public class MManager {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG, "Rename" + TAG_FORMAT, leafMNode.getFullPath()),
- oldKey, value, leafMNode.getOffset()));
+ String.format(DEBUG_MSG, "Rename" + TAG_FORMAT, leafMNode.getFullPath()),
+ oldKey, value, leafMNode.getOffset()));
}
tagIndex.get(oldKey).get(value).remove(leafMNode);
@@ -1531,8 +1537,8 @@ public class MManager {
} else {
if (logger.isDebugEnabled()) {
logger.debug(String.format(
- String.format(DEBUG_MSG_1, "Rename" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
- oldKey, value, leafMNode.getOffset(), tagIndex.containsKey(oldKey)));
+ String.format(DEBUG_MSG_1, "Rename" + PREVIOUS_CONDITION, leafMNode.getFullPath()),
+ oldKey, value, leafMNode.getOffset(), tagIndex.containsKey(oldKey)));
}
}
tagIndex.computeIfAbsent(newKey, k -> new ConcurrentHashMap<>())
@@ -1544,7 +1550,8 @@ public class MManager {
tagLogFile.write(pair.left, pair.right, leafMNode.getOffset());
} else {
throw new MetadataException(
- String.format("TimeSeries [%s] does not have tag/attribute [%s].", fullPath, oldKey), true);
+ String.format("TimeSeries [%s] does not have tag/attribute [%s].", fullPath, oldKey),
+ true);
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/utils/MmapUtil.java b/server/src/main/java/org/apache/iotdb/db/utils/MmapUtil.java
new file mode 100644
index 0000000..2fdc499
--- /dev/null
+++ b/server/src/main/java/org/apache/iotdb/db/utils/MmapUtil.java
@@ -0,0 +1,32 @@
+/*
+ * 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.utils;
+
+import io.netty.util.internal.PlatformDependent;
+import java.nio.MappedByteBuffer;
+
+public class MmapUtil {
+
+ public static void clean(MappedByteBuffer mappedByteBuffer) {
+ if (mappedByteBuffer == null || !mappedByteBuffer.isDirect() || mappedByteBuffer.capacity()== 0) {
+ return;
+ }
+ PlatformDependent.freeDirectBuffer(mappedByteBuffer);
+ }
+}
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/manager/MultiFileLogNodeManager.java b/server/src/main/java/org/apache/iotdb/db/writelog/manager/MultiFileLogNodeManager.java
index f07d69f..86f3bb8 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/manager/MultiFileLogNodeManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/manager/MultiFileLogNodeManager.java
@@ -19,11 +19,14 @@
package org.apache.iotdb.db.writelog.manager;
import java.io.IOException;
+import java.nio.ByteBuffer;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
import org.apache.iotdb.db.conf.IoTDBConfig;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.exception.StartupException;
@@ -35,18 +38,18 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
- * MultiFileLogNodeManager manages all ExclusiveWriteLogNodes, each manages WALs of a TsFile
- * (either seq or unseq).
+ * MultiFileLogNodeManager manages all ExclusiveWriteLogNodes, each manages WALs of a TsFile (either
+ * seq or unseq).
*/
public class MultiFileLogNodeManager implements WriteLogNodeManager, IService {
private static final Logger logger = LoggerFactory.getLogger(MultiFileLogNodeManager.class);
- private Map<String, WriteLogNode> nodeMap;
+ private final Map<String, WriteLogNode> nodeMap;
private ScheduledExecutorService executorService;
- private IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+ private final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
- private final void forceTask() {
+ private void forceTask() {
if (IoTDBDescriptor.getInstance().getConfig().isReadOnly()) {
logger.warn("system mode is read-only, the force flush WAL task is stopped");
return;
@@ -75,23 +78,25 @@ public class MultiFileLogNodeManager implements WriteLogNodeManager, IService {
@Override
- public WriteLogNode getNode(String identifier) {
+ public WriteLogNode getNode(String identifier, Supplier<ByteBuffer[]> supplier) {
WriteLogNode node = nodeMap.get(identifier);
if (node == null) {
node = new ExclusiveWriteLogNode(identifier);
WriteLogNode oldNode = nodeMap.putIfAbsent(identifier, node);
if (oldNode != null) {
return oldNode;
+ } else {
+ node.initBuffer(supplier.get());
}
}
return node;
}
@Override
- public void deleteNode(String identifier) throws IOException {
+ public void deleteNode(String identifier, Consumer<ByteBuffer[]> consumer) throws IOException {
WriteLogNode node = nodeMap.remove(identifier);
if (node != null) {
- node.delete();
+ consumer.accept(node.delete());
}
}
@@ -148,9 +153,11 @@ public class MultiFileLogNodeManager implements WriteLogNodeManager, IService {
}
private static class InstanceHolder {
- private InstanceHolder(){}
- private static MultiFileLogNodeManager instance = new MultiFileLogNodeManager();
+ private InstanceHolder() {
+ }
+
+ private static final MultiFileLogNodeManager instance = new MultiFileLogNodeManager();
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/manager/WriteLogNodeManager.java b/server/src/main/java/org/apache/iotdb/db/writelog/manager/WriteLogNodeManager.java
index 84d02fc..f46d57a 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/manager/WriteLogNodeManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/manager/WriteLogNodeManager.java
@@ -19,6 +19,9 @@
package org.apache.iotdb.db.writelog.manager;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
/**
@@ -33,14 +36,14 @@ public interface WriteLogNodeManager {
* @param identifier -identifier, the format: "{storageGroupName}-{BufferWrite/Overflow}-{
* nameOfTsFile}"
*/
- WriteLogNode getNode(String identifier);
+ WriteLogNode getNode(String identifier, Supplier<ByteBuffer[]> supplier);
/**
* Delete a log node. If the log node does not exist, this will be an empty operation.
*
* @param identifier -identifier
*/
- void deleteNode(String identifier) throws IOException;
+ void deleteNode(String identifier, Consumer<ByteBuffer[]> consumer) throws IOException;
/**
* Close all nodes.
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/node/ExclusiveWriteLogNode.java b/server/src/main/java/org/apache/iotdb/db/writelog/node/ExclusiveWriteLogNode.java
index f241db5..8ec8e7b 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/node/ExclusiveWriteLogNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/node/ExclusiveWriteLogNode.java
@@ -59,12 +59,13 @@ public class ExclusiveWriteLogNode implements WriteLogNode, Comparable<Exclusive
private IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
- private ByteBuffer logBufferWorking = ByteBuffer
- .allocate(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
- private ByteBuffer logBufferIdle = ByteBuffer
- .allocate(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ private ByteBuffer logBufferWorking;
+ private ByteBuffer logBufferIdle;
private ByteBuffer logBufferFlushing;
+ // used for the convenience of deletion
+ private ByteBuffer[] bufferArray;
+
private final Object switchBufferCondition = new Object();
private ReentrantLock lock = new ReentrantLock();
private static final ExecutorService FLUSH_BUFFER_THREAD_POOL =
@@ -92,6 +93,12 @@ public class ExclusiveWriteLogNode implements WriteLogNode, Comparable<Exclusive
}
}
+ public void initBuffer(ByteBuffer[] byteBuffers) {
+ this.logBufferWorking = byteBuffers[0];
+ this.logBufferIdle = byteBuffers[1];
+ this.bufferArray = byteBuffers;
+ }
+
@Override
public void write(PhysicalPlan plan) throws IOException {
if (deleted) {
@@ -197,12 +204,13 @@ public class ExclusiveWriteLogNode implements WriteLogNode, Comparable<Exclusive
}
@Override
- public void delete() throws IOException {
+ public ByteBuffer[] delete() throws IOException {
lock.lock();
try {
close();
FileUtils.deleteDirectory(SystemFileFactory.INSTANCE.getFile(logDirectory));
deleted = true;
+ return this.bufferArray;
} finally {
lock.unlock();
}
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/node/WriteLogNode.java b/server/src/main/java/org/apache/iotdb/db/writelog/node/WriteLogNode.java
index a93117b..7bb0dff 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/node/WriteLogNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/node/WriteLogNode.java
@@ -19,6 +19,7 @@
package org.apache.iotdb.db.writelog.node;
import java.io.IOException;
+import java.nio.ByteBuffer;
import org.apache.iotdb.db.qp.physical.PhysicalPlan;
import org.apache.iotdb.db.writelog.io.ILogReader;
@@ -76,7 +77,7 @@ public interface WriteLogNode {
* Abandon all logs in this node and delete the log directory. Calling insert() after calling
* this method is undefined.
*/
- void delete() throws IOException;
+ ByteBuffer[] delete() throws IOException;
/**
* return an ILogReader which can iterate each log in this log node.
@@ -84,4 +85,9 @@ public interface WriteLogNode {
*/
ILogReader getLogReader();
+ /**
+ * init the buffers, this should be called after this node being created.
+ */
+ void initBuffer(ByteBuffer[] byteBuffers);
+
}
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/recover/LogReplayer.java b/server/src/main/java/org/apache/iotdb/db/writelog/recover/LogReplayer.java
index 0e3b5f1..31e5c1f 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/recover/LogReplayer.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/recover/LogReplayer.java
@@ -20,9 +20,11 @@
package org.apache.iotdb.db.writelog.recover;
import java.io.IOException;
+import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.function.Supplier;
import org.apache.iotdb.db.conf.IoTDBConstant;
import org.apache.iotdb.db.engine.memtable.IMemTable;
import org.apache.iotdb.db.engine.modification.Deletion;
@@ -81,9 +83,10 @@ public class LogReplayer {
* finds the logNode of the TsFile given by insertFilePath and logNodePrefix, reads the WALs from
* the logNode and redoes them into a given MemTable and ModificationFile.
*/
- public void replayLogs() {
- WriteLogNode logNode = MultiFileLogNodeManager.getInstance().getNode(
- logNodePrefix + FSFactoryProducer.getFSFactory().getFile(insertFilePath).getName());
+ public void replayLogs(Supplier<ByteBuffer[]> supplier) {
+ WriteLogNode logNode = MultiFileLogNodeManager.getInstance()
+ .getNode(logNodePrefix + FSFactoryProducer.getFSFactory().getFile(insertFilePath).getName(),
+ supplier);
ILogReader logReader = logNode.getLogReader();
try {
@@ -169,7 +172,8 @@ public class LogReplayer {
if (plan instanceof InsertRowPlan) {
recoverMemTable.insert((InsertRowPlan) plan);
} else {
- recoverMemTable.insertTablet((InsertTabletPlan) plan, 0, ((InsertTabletPlan) plan).getRowCount());
+ recoverMemTable
+ .insertTablet((InsertTabletPlan) plan, 0, ((InsertTabletPlan) plan).getRowCount());
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/writelog/recover/TsFileRecoverPerformer.java b/server/src/main/java/org/apache/iotdb/db/writelog/recover/TsFileRecoverPerformer.java
index 2a84fd9..b2f2bcb 100644
--- a/server/src/main/java/org/apache/iotdb/db/writelog/recover/TsFileRecoverPerformer.java
+++ b/server/src/main/java/org/apache/iotdb/db/writelog/recover/TsFileRecoverPerformer.java
@@ -23,10 +23,13 @@ import static org.apache.iotdb.db.engine.storagegroup.TsFileResource.RESOURCE_SU
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
import org.apache.iotdb.db.engine.fileSystem.SystemFileFactory;
import org.apache.iotdb.db.engine.flush.MemTableFlushTask;
import org.apache.iotdb.db.engine.memtable.IMemTable;
@@ -78,8 +81,8 @@ public class TsFileRecoverPerformer {
* writing
*/
@SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
- public RestorableTsFileIOWriter recover(boolean needRedoWal)
- throws StorageGroupProcessorException {
+ public RestorableTsFileIOWriter recover(boolean needRedoWal, Supplier<ByteBuffer[]> supplier,
+ Consumer<ByteBuffer[]> consumer) throws StorageGroupProcessorException {
File file = FSFactoryProducer.getFSFactory().getFile(filePath);
if (!file.exists()) {
@@ -117,12 +120,13 @@ public class TsFileRecoverPerformer {
// redo logs
if (needRedoWal) {
- redoLogs(restorableTsFileIOWriter);
+ redoLogs(restorableTsFileIOWriter, supplier);
// clean logs
try {
MultiFileLogNodeManager.getInstance()
- .deleteNode(logNodePrefix + SystemFileFactory.INSTANCE.getFile(filePath).getName());
+ .deleteNode(logNodePrefix + SystemFileFactory.INSTANCE.getFile(filePath).getName(),
+ consumer);
} catch (IOException e) {
throw new StorageGroupProcessorException(e);
}
@@ -193,13 +197,13 @@ public class TsFileRecoverPerformer {
tsFileResource.updatePlanIndexes(restorableTsFileIOWriter.getMaxPlanIndex());
}
- private void redoLogs(RestorableTsFileIOWriter restorableTsFileIOWriter)
+ private void redoLogs(RestorableTsFileIOWriter restorableTsFileIOWriter, Supplier<ByteBuffer[]> supplier)
throws StorageGroupProcessorException {
IMemTable recoverMemTable = new PrimitiveMemTable();
LogReplayer logReplayer = new LogReplayer(
logNodePrefix, filePath, tsFileResource.getModFile(),
tsFileResource, recoverMemTable, sequence);
- logReplayer.replayLogs();
+ logReplayer.replayLogs(supplier);
try {
if (!recoverMemTable.isEmpty()) {
// flush logs
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessorTest.java b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessorTest.java
index 78dee2b..91bd4cc 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/StorageGroupProcessorTest.java
@@ -94,7 +94,6 @@ public class StorageGroupProcessorTest {
@Test
public void testUnseqUnsealedDelete()
throws WriteProcessException, IOException, MetadataException {
- System.out.println("testUnseqUnsealedDelete");
TSRecord record = new TSRecord(10000, deviceId);
record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, String.valueOf(1000)));
processor.insert(new InsertRowPlan(record));
@@ -141,7 +140,6 @@ public class StorageGroupProcessorTest {
@Test
public void testSequenceSyncClose()
throws WriteProcessException, QueryProcessException, IllegalPathException {
- System.out.println("testSequenceSyncClose");
for (int j = 1; j <= 10; j++) {
TSRecord record = new TSRecord(j, deviceId);
record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, String.valueOf(j)));
@@ -167,7 +165,6 @@ public class StorageGroupProcessorTest {
@Test
public void testIoTDBTabletWriteAndSyncClose()
throws QueryProcessException, IllegalPathException {
- System.out.println("testIoTDBTabletWriteAndSyncClose");
String[] measurements = new String[2];
measurements[0] = "s0";
measurements[1] = "s1";
@@ -236,7 +233,6 @@ public class StorageGroupProcessorTest {
@Test
public void testSeqAndUnSeqSyncClose()
throws WriteProcessException, QueryProcessException, IllegalPathException {
- System.out.println("testSeqAndUnSeqSyncClose");
for (int j = 21; j <= 30; j++) {
TSRecord record = new TSRecord(j, deviceId);
record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, String.valueOf(j)));
@@ -270,7 +266,6 @@ public class StorageGroupProcessorTest {
@Test
public void testEnableDiscardOutOfOrderDataForInsertRowPlan()
throws WriteProcessException, QueryProcessException, IllegalPathException, IOException {
- System.out.println("testEnableDiscardOutOfOrderDataForInsertRowPlan");
IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
boolean defaultValue = config.isEnableDiscardOutOfOrderData();
config.setEnableDiscardOutOfOrderData(true);
@@ -314,7 +309,6 @@ public class StorageGroupProcessorTest {
@Test
public void testEnableDiscardOutOfOrderDataForInsertTablet1()
throws QueryProcessException, IllegalPathException, IOException {
- System.out.println("testEnableDiscardOutOfOrderDataForInsertTablet1");
IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
boolean defaultEnableDiscard = config.isEnableDiscardOutOfOrderData();
long defaultTimePartition = config.getPartitionInterval();
@@ -398,7 +392,6 @@ public class StorageGroupProcessorTest {
@Test
public void testEnableDiscardOutOfOrderDataForInsertTablet2()
throws QueryProcessException, IllegalPathException, IOException {
- System.out.println("testEnableDiscardOutOfOrderDataForInsertTablet2");
IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
boolean defaultEnableDiscard = config.isEnableDiscardOutOfOrderData();
long defaultTimePartition = config.getPartitionInterval();
@@ -482,7 +475,6 @@ public class StorageGroupProcessorTest {
@Test
public void testEnableDiscardOutOfOrderDataForInsertTablet3()
throws QueryProcessException, IllegalPathException, IOException {
- System.out.println("testEnableDiscardOutOfOrderDataForInsertTablet3");
IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
boolean defaultEnableDiscard = config.isEnableDiscardOutOfOrderData();
long defaultTimePartition = config.getPartitionInterval();
@@ -566,7 +558,6 @@ public class StorageGroupProcessorTest {
@Test
public void testMerge()
throws WriteProcessException, QueryProcessException, IllegalPathException {
- System.out.println("testMerge");
for (int j = 21; j <= 30; j++) {
TSRecord record = new TSRecord(j, deviceId);
record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, String.valueOf(j)));
@@ -575,6 +566,7 @@ public class StorageGroupProcessorTest {
}
processor.syncCloseAllWorkingTsFileProcessors();
+
for (int j = 10; j >= 1; j--) {
TSRecord record = new TSRecord(j, deviceId);
record.addTuple(DataPoint.getDataPoint(TSDataType.INT32, measurementId, String.valueOf(j)));
@@ -584,11 +576,9 @@ public class StorageGroupProcessorTest {
processor.syncCloseAllWorkingTsFileProcessors();
processor.merge(true);
- System.out.println("waiting for isUnseqMerging");
while (processor.getTsFileManagement().isUnseqMerging) {
// wait
}
- System.out.println("isUnseqMerging is false");
QueryDataSource queryDataSource = processor
.query(new PartialPath(deviceId), measurementId, context,
diff --git a/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java b/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
index dc84963..92b1422 100644
--- a/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
+++ b/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
@@ -33,25 +33,12 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Notice that, all test begins with "IoTDB" is integration test. All test which will start the IoTDB server should be
* defined as integration test.
*/
public class IoTDBAuthorizationIT {
- private static Logger logger = LoggerFactory.getLogger(IoTDBAuthorizationIT.class);
-
-
- public static void main(String[] args) throws Exception {
- for (int i = 0; i < 10; i++) {
- IoTDBAuthorizationIT test = new IoTDBAuthorizationIT();
- test.setUp();
- test.authPerformanceTest();
- test.tearDown();
- }
- }
@Before
public void setUp() throws Exception {
@@ -607,10 +594,6 @@ public class IoTDBAuthorizationIT {
userStmt.executeBatch();
userStmt.clearBatch();
}
- if (logger.isInfoEnabled()) {
- logger.info("User inserted {} data points used {} ms with {} privileges.", insertCnt,
- System.currentTimeMillis() - time, privilegeCnt);
- }
time = System.currentTimeMillis();
for (int i = 0; i < insertCnt; ) {
@@ -621,10 +604,6 @@ public class IoTDBAuthorizationIT {
adminStmt.executeBatch();
adminStmt.clearBatch();
}
- if (logger.isInfoEnabled()) {
- logger.info("User inserted {} data points used {} ms with {} privileges.", insertCnt,
- System.currentTimeMillis() - time, privilegeCnt);
- }
}
}
}
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/IoTDBLogFileSizeTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/IoTDBLogFileSizeTest.java
index 2a7a5ed..8386977 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/IoTDBLogFileSizeTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/IoTDBLogFileSizeTest.java
@@ -20,12 +20,15 @@
package org.apache.iotdb.db.writelog;
import java.io.File;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import org.apache.iotdb.db.conf.IoTDBConstant;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.node.ExclusiveWriteLogNode;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
@@ -57,7 +60,7 @@ public class IoTDBLogFileSizeTest {
return;
}
groupSize = TSFileDescriptor.getInstance().getConfig().getGroupSizeInByte();
- TSFileDescriptor.getInstance().getConfig().setGroupSizeInByte( 8 * 1024 * 1024);
+ TSFileDescriptor.getInstance().getConfig().setGroupSizeInByte(8 * 1024 * 1024);
IoTDBDescriptor.getInstance().getConfig().setMemtableSizeThreshold(8 * 1024 * 1024);
EnvironmentUtils.closeStatMonitor();
EnvironmentUtils.envSetUp();
@@ -81,6 +84,11 @@ public class IoTDBLogFileSizeTest {
return;
}
final long[] maxLength = {0};
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
Thread writeThread = new Thread(() -> {
int cnt = 0;
try {
@@ -100,7 +108,7 @@ public class IoTDBLogFileSizeTest {
cnt);
statement.execute(sql);
WriteLogNode logNode = MultiFileLogNodeManager.getInstance().getNode(
- "root.logFileTest.seq" + IoTDBConstant.SEQFILE_LOG_NODE_SUFFIX);
+ "root.logFileTest.seq" + IoTDBConstant.SEQFILE_LOG_NODE_SUFFIX, () -> buffers);
File bufferWriteWALFile = new File(
logNode.getLogDirectory() + File.separator + ExclusiveWriteLogNode.WAL_FILE_NAME);
if (bufferWriteWALFile.exists() && bufferWriteWALFile.length() > maxLength[0]) {
@@ -117,6 +125,9 @@ public class IoTDBLogFileSizeTest {
while (writeThread.isAlive()) {
}
+ for (ByteBuffer byteBuffer : buffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
@Test
@@ -124,6 +135,11 @@ public class IoTDBLogFileSizeTest {
if (skip) {
return;
}
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
final long[] maxLength = {0};
Thread writeThread = new Thread(() -> {
int cnt = 0;
@@ -143,7 +159,7 @@ public class IoTDBLogFileSizeTest {
++cnt, cnt);
statement.execute(sql);
WriteLogNode logNode = MultiFileLogNodeManager.getInstance()
- .getNode("root.logFileTest.unsequence" + IoTDBConstant.UNSEQFILE_LOG_NODE_SUFFIX);
+ .getNode("root.logFileTest.unsequence" + IoTDBConstant.UNSEQFILE_LOG_NODE_SUFFIX, () -> buffers);
File WALFile = new File(
logNode.getLogDirectory() + File.separator + ExclusiveWriteLogNode.WAL_FILE_NAME);
if (WALFile.exists() && WALFile.length() > maxLength[0]) {
@@ -160,6 +176,9 @@ public class IoTDBLogFileSizeTest {
while (writeThread.isAlive()) {
}
+ for (ByteBuffer byteBuffer : buffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
private void executeSQL(String[] sqls) throws ClassNotFoundException {
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/PerformanceTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/PerformanceTest.java
index 1d6e918..a4ba417 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/PerformanceTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/PerformanceTest.java
@@ -20,6 +20,8 @@ package org.apache.iotdb.db.writelog;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.Collections;
import org.apache.iotdb.db.conf.IoTDBConfig;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -31,6 +33,7 @@ import org.apache.iotdb.db.qp.physical.crud.DeletePlan;
import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.node.ExclusiveWriteLogNode;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -82,13 +85,21 @@ public class PerformanceTest {
tempRestore.createNewFile();
tempProcessorStore.createNewFile();
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+
WriteLogNode logNode = new ExclusiveWriteLogNode("root.testLogNode");
+ logNode.initBuffer(byteBuffers);
long time = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("logTestDevice"), 100,
new String[]{"s1", "s2", "s3", "s4"},
- new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
+ new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT,
+ TSDataType.BOOLEAN},
new String[]{"1.0", "15", "str", "false"});
DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50,
new PartialPath("root.logTestDevice.s1"));
@@ -102,7 +113,10 @@ public class PerformanceTest {
3000000 + " logs use " + (System.currentTimeMillis() - time) + " ms at batch size "
+ config.getFlushWalThreshold());
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
tempRestore.delete();
tempProcessorStore.delete();
tempRestore.getParentFile().delete();
@@ -130,25 +144,38 @@ public class PerformanceTest {
} catch (MetadataException ignored) {
}
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.logTestDevice.s1"), TSDataType.DOUBLE, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.logTestDevice.s1"), TSDataType.DOUBLE,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.logTestDevice.s2"), TSDataType.INT32, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.logTestDevice.s2"), TSDataType.INT32,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.logTestDevice.s3"), TSDataType.TEXT, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.logTestDevice.s3"), TSDataType.TEXT,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.logTestDevice.s4"), TSDataType.BOOLEAN, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.logTestDevice.s4"), TSDataType.BOOLEAN,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
+
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode("root.logTestDevice");
+ logNode.initBuffer(byteBuffers);
for (int i = 0; i < 1000000; i++) {
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("root.logTestDevice"), 100,
new String[]{"s1", "s2", "s3", "s4"},
- new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
+ new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT,
+ TSDataType.BOOLEAN},
new String[]{"1.0", "15", "str", "false"});
- DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50, new PartialPath("root.logTestDevice.s1"));
+ DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50,
+ new PartialPath("root.logTestDevice.s1"));
logNode.write(bwInsertPlan);
logNode.write(deletePlan);
@@ -159,7 +186,10 @@ public class PerformanceTest {
System.out.println(
3000000 + " logs use " + (System.currentTimeMillis() - time) + "ms when recovering ");
} finally {
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
tempRestore.delete();
tempProcessorStore.delete();
tempRestore.getParentFile().delete();
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeManagerTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeManagerTest.java
index 332ee6b..cdff9cf 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeManagerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeManagerTest.java
@@ -19,12 +19,15 @@
package org.apache.iotdb.db.writelog;
import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertFalse;
import static junit.framework.TestCase.assertNotSame;
import static junit.framework.TestCase.assertSame;
import static junit.framework.TestCase.assertTrue;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import org.apache.iotdb.db.conf.IoTDBConfig;
import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.exception.metadata.IllegalPathException;
@@ -32,11 +35,11 @@ import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.physical.crud.DeletePlan;
import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.manager.WriteLogNodeManager;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
-import org.apache.iotdb.tsfile.read.common.Path;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -64,15 +67,45 @@ public class WriteLogNodeManagerTest {
public void testGetAndDelete() throws IOException {
String identifier = "testLogNode";
WriteLogNodeManager manager = MultiFileLogNodeManager.getInstance();
- WriteLogNode logNode = manager.getNode(identifier);
+ WriteLogNode logNode = manager.getNode(identifier, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
assertEquals(identifier, logNode.getIdentifier());
- WriteLogNode theSameNode = manager.getNode(identifier);
+ WriteLogNode theSameNode = manager.getNode(identifier, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
assertSame(logNode, theSameNode);
- manager.deleteNode(identifier);
- WriteLogNode anotherNode = manager.getNode(identifier);
+ manager.deleteNode(identifier, (ByteBuffer[] array) -> {
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ });
+ WriteLogNode anotherNode = manager.getNode(identifier, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
assertNotSame(logNode, anotherNode);
+ manager.deleteNode(identifier, (ByteBuffer[] array) -> {
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ });
}
@Test
@@ -84,17 +117,24 @@ public class WriteLogNodeManagerTest {
File tempProcessorStore = File.createTempFile("managerTest", "processorStore");
WriteLogNodeManager manager = MultiFileLogNodeManager.getInstance();
- WriteLogNode logNode = manager
- .getNode("root.managerTest");
+ WriteLogNode logNode = manager.getNode("root.managerTest", () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("logTestDevice"), 100,
new String[]{"s1", "s2", "s3", "s4"},
new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
new String[]{"1.0", "15", "str", "false"});
- DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50, new PartialPath("root.logTestDevice.s1"));
+ DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50,
+ new PartialPath("root.logTestDevice.s1"));
File walFile = new File(logNode.getLogDirectory() + File.separator + "wal1");
- assertTrue(!walFile.exists());
+ assertFalse(walFile.exists());
logNode.write(bwInsertPlan);
logNode.write(deletePlan);
@@ -102,7 +142,10 @@ public class WriteLogNodeManagerTest {
Thread.sleep(config.getForceWalPeriodInMs() + 1000);
assertTrue(walFile.exists());
- logNode.delete();
+ ByteBuffer[] buffers = logNode.delete();
+ for (ByteBuffer byteBuffer : buffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
config.setForceWalPeriodInMs(flushWalPeriod);
tempRestore.delete();
tempProcessorStore.delete();
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeTest.java
index fe5610c..b587e6f 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/WriteLogNodeTest.java
@@ -24,6 +24,8 @@ import static junit.framework.TestCase.assertTrue;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.ArrayList;
import java.util.List;
import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -34,6 +36,7 @@ import org.apache.iotdb.db.qp.physical.crud.DeletePlan;
import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.qp.physical.crud.InsertTabletPlan;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.io.ILogReader;
import org.apache.iotdb.db.writelog.node.ExclusiveWriteLogNode;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
@@ -68,7 +71,13 @@ public class WriteLogNodeTest {
// then reads the logs from file
String identifier = "root.logTestDevice";
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode(identifier);
+ logNode.initBuffer(byteBuffers);
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath(identifier), 100,
new String[]{"s1", "s2", "s3", "s4"},
@@ -96,7 +105,7 @@ public class WriteLogNodeTest {
}
InsertTabletPlan tabletPlan = new InsertTabletPlan(new PartialPath(identifier),
- new String[]{"s1", "s2", "s3", "s4"}, dataTypes);
+ new String[]{"s1", "s2", "s3", "s4"}, dataTypes);
tabletPlan.setTimes(times);
tabletPlan.setColumns(columns);
tabletPlan.setRowCount(times.length);
@@ -122,7 +131,10 @@ public class WriteLogNodeTest {
assertEquals(newPlan.getMeasurements().length, 3);
reader.close();
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
@Test
@@ -131,7 +143,13 @@ public class WriteLogNodeTest {
// then calls notifyStartFlush() and notifyEndFlush() to delete old file
String identifier = "root.logTestDevice";
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode(identifier);
+ logNode.initBuffer(byteBuffers);
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath(identifier), 100,
new String[]{"s1", "s2", "s3", "s4"},
@@ -159,7 +177,10 @@ public class WriteLogNodeTest {
assertFalse(logReader.hasNext());
logReader.close();
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
@Test
@@ -168,13 +189,20 @@ public class WriteLogNodeTest {
int flushWalThreshold = config.getFlushWalThreshold();
config.setFlushWalThreshold(2);
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode("root.logTestDevice");
+ logNode.initBuffer(byteBuffers);
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("root.logTestDevice"), 100,
new String[]{"s1", "s2", "s3", "s4"},
new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
new String[]{"1.0", "15", "str", "false"});
- DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50, new PartialPath("root.logTestDevice.s1"));
+ DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50,
+ new PartialPath("root.logTestDevice.s1"));
logNode.write(bwInsertPlan);
@@ -189,7 +217,10 @@ public class WriteLogNodeTest {
}
assertTrue(walFile.exists());
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
config.setFlushWalThreshold(flushWalThreshold);
}
@@ -198,13 +229,20 @@ public class WriteLogNodeTest {
// this test uses a dummy insert log node to insert a few logs and flushes them
// then deletes the node
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode("root.logTestDevice");
+ logNode.initBuffer(byteBuffers);
InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("logTestDevice"), 100,
new String[]{"s1", "s2", "s3", "s4"},
new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
new String[]{"1.0", "15", "str", "false"});
- DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50, new PartialPath("root.logTestDevice.s1"));
+ DeletePlan deletePlan = new DeletePlan(Long.MIN_VALUE, 50,
+ new PartialPath("root.logTestDevice.s1"));
logNode.write(bwInsertPlan);
logNode.write(deletePlan);
@@ -219,16 +257,26 @@ public class WriteLogNodeTest {
}
assertTrue(new File(logNode.getLogDirectory()).exists());
- logNode.delete();
- assertTrue(!new File(logNode.getLogDirectory()).exists());
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ assertFalse(new File(logNode.getLogDirectory()).exists());
}
@Test
public void testOverSizedWAL() throws IOException, IllegalPathException {
// this test uses a dummy insert log node to insert an over-sized log and assert exception caught
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
WriteLogNode logNode = new ExclusiveWriteLogNode("root.logTestDevice.oversize");
+ logNode.initBuffer(byteBuffers);
- InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("root.logTestDevice.oversize"), 100,
+ InsertRowPlan bwInsertPlan = new InsertRowPlan(new PartialPath("root.logTestDevice.oversize"),
+ 100,
new String[]{"s1", "s2", "s3", "s4"},
new TSDataType[]{TSDataType.DOUBLE, TSDataType.INT64, TSDataType.TEXT, TSDataType.BOOLEAN},
new String[]{"1.0", "15", new String(new char[65 * 1024 * 1024]), "false"});
@@ -241,6 +289,9 @@ public class WriteLogNodeTest {
}
assertTrue(caught);
- logNode.delete();
+ ByteBuffer[] array = logNode.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
}
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/recover/LogReplayerTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/recover/LogReplayerTest.java
index 9d81855..0daed08 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/recover/LogReplayerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/recover/LogReplayerTest.java
@@ -26,9 +26,12 @@ import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.engine.fileSystem.SystemFileFactory;
import org.apache.iotdb.db.engine.memtable.IMemTable;
import org.apache.iotdb.db.engine.memtable.PrimitiveMemTable;
@@ -50,6 +53,7 @@ import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.qp.physical.crud.InsertTabletPlan;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -98,7 +102,12 @@ public class LogReplayerTest {
tsFileResource, memTable, false);
WriteLogNode node =
- MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsFile.getName());
+ MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsFile.getName(), () -> {
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer.allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer.allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return byteBuffers;
+ });
node.write(
new InsertRowPlan(new PartialPath("root.sg.device0"), 100, "sensor0", TSDataType.INT64,
String.valueOf(0)));
@@ -113,7 +122,12 @@ public class LogReplayerTest {
node.write(deletePlan);
node.close();
- replayer.replayLogs();
+ replayer.replayLogs(() -> {
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer.allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer.allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return byteBuffers;
+ });
for (int i = 0; i < 5; i++) {
ReadOnlyMemChunk memChunk = memTable
@@ -164,7 +178,11 @@ public class LogReplayerTest {
}
} finally {
modFile.close();
- MultiFileLogNodeManager.getInstance().deleteNode(logNodePrefix + tsFile.getName());
+ MultiFileLogNodeManager.getInstance().deleteNode(logNodePrefix + tsFile.getName(), (ByteBuffer[] byteBuffers) -> {
+ for (ByteBuffer byteBuffer : byteBuffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ });
modF.delete();
tsFile.delete();
tsFile.getParentFile().delete();
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/recover/RecoverResourceFromReaderTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/recover/RecoverResourceFromReaderTest.java
index f093cc7..ce6bc60 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/recover/RecoverResourceFromReaderTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/recover/RecoverResourceFromReaderTest.java
@@ -21,12 +21,15 @@ package org.apache.iotdb.db.writelog.recover;
import static org.junit.Assert.assertEquals;
-import java.util.*;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.util.Collections;
import org.apache.commons.io.FileUtils;
import org.apache.iotdb.db.conf.IoTDBConstant;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.constant.TestConstant;
import org.apache.iotdb.db.engine.fileSystem.SystemFileFactory;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
@@ -38,6 +41,7 @@ import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -87,7 +91,8 @@ public class RecoverResourceFromReaderTest {
schema = new Schema();
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
- PartialPath path = new PartialPath("root.sg.device" + i + IoTDBConstant.PATH_SEPARATOR + "sensor" + j);
+ PartialPath path = new PartialPath(
+ "root.sg.device" + i + IoTDBConstant.PATH_SEPARATOR + "sensor" + j);
MeasurementSchema measurementSchema = new MeasurementSchema("sensor" + j, TSDataType.INT64,
TSEncoding.PLAIN);
schema.registerTimeseries(path.toTSFilePath(), measurementSchema);
@@ -99,17 +104,20 @@ public class RecoverResourceFromReaderTest {
schema.registerTimeseries(new Path(("root.sg.device99"), ("sensor4")),
new MeasurementSchema("sensor4", TSDataType.INT64, TSEncoding.PLAIN));
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.sg.device99.sensor4"), TSDataType.INT64, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.sg.device99.sensor4"), TSDataType.INT64,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
schema.registerTimeseries(new Path(("root.sg.device99"), ("sensor2")),
new MeasurementSchema("sensor2", TSDataType.INT64, TSEncoding.PLAIN));
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.sg.device99.sensor2"), TSDataType.INT64, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.sg.device99.sensor2"), TSDataType.INT64,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
schema.registerTimeseries(new Path(("root.sg.device99"), ("sensor1")),
new MeasurementSchema("sensor1", TSDataType.INT64, TSEncoding.PLAIN));
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.sg.device99.sensor1"), TSDataType.INT64, TSEncoding.PLAIN,
+ .createTimeseries(new PartialPath("root.sg.device99.sensor1"), TSDataType.INT64,
+ TSEncoding.PLAIN,
TSFileDescriptor.getInstance().getConfig().getCompressor(), Collections.emptyMap());
writer = new TsFileWriter(tsF, schema);
@@ -134,7 +142,14 @@ public class RecoverResourceFromReaderTest {
writer.flushAllChunkGroups();
writer.getIOWriter().close();
- node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName());
+ node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName(), () -> {
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return byteBuffers;
+ });
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
String[] measurements = new String[10];
@@ -145,16 +160,19 @@ public class RecoverResourceFromReaderTest {
types[k] = TSDataType.INT64;
values[k] = String.valueOf(k + 10);
}
- InsertRowPlan insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device" + j), i, measurements,
+ InsertRowPlan insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device" + j), i,
+ measurements,
types, values);
node.write(insertRowPlan);
}
node.notifyStartFlush();
}
- InsertRowPlan insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device99"), 1, new String[]{"sensor4"},
+ InsertRowPlan insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device99"), 1,
+ new String[]{"sensor4"},
new TSDataType[]{TSDataType.INT64}, new String[]{"4"});
node.write(insertRowPlan);
- insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device99"), 300, new String[]{"sensor2"},
+ insertRowPlan = new InsertRowPlan(new PartialPath("root.sg.device99"), 300,
+ new String[]{"sensor2"},
new TSDataType[]{TSDataType.INT64}, new String[]{"2"});
node.write(insertRowPlan);
node.close();
@@ -167,7 +185,10 @@ public class RecoverResourceFromReaderTest {
EnvironmentUtils.cleanEnv();
FileUtils.deleteDirectory(tsF.getParentFile());
resource.close();
- node.delete();
+ ByteBuffer[] array = node.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
@Test
@@ -183,7 +204,18 @@ public class RecoverResourceFromReaderTest {
TsFileRecoverPerformer performer = new TsFileRecoverPerformer(logNodePrefix,
resource, false, false);
- performer.recover(true).close();
+ performer.recover(true, () -> {
+ ByteBuffer[] byteBuffers = new ByteBuffer[2];
+ byteBuffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ byteBuffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return byteBuffers;
+ }, (ByteBuffer[] byteBuffers) -> {
+ for (ByteBuffer byteBuffer : byteBuffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ }).close();
assertEquals(1, resource.getStartTime("root.sg.device99"));
assertEquals(300, resource.getEndTime("root.sg.device99"));
for (int i = 0; i < 10; i++) {
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/recover/SeqTsFileRecoverTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/recover/SeqTsFileRecoverTest.java
index 9627d1d..be05d71 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/recover/SeqTsFileRecoverTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/recover/SeqTsFileRecoverTest.java
@@ -21,16 +21,18 @@ package org.apache.iotdb.db.writelog.recover;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.io.FileUtils;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.constant.TestConstant;
import org.apache.iotdb.db.engine.fileSystem.SystemFileFactory;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
@@ -42,6 +44,7 @@ import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.physical.crud.InsertRowPlan;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -99,7 +102,8 @@ public class SeqTsFileRecoverTest {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
IoTDB.metaManager
- .createTimeseries(new PartialPath("root.sg.device" + i + ".sensor" + j), TSDataType.INT64,
+ .createTimeseries(new PartialPath("root.sg.device" + i + ".sensor" + j),
+ TSDataType.INT64,
TSEncoding.PLAIN, TSFileDescriptor.getInstance().getConfig().getCompressor(),
Collections.emptyMap());
}
@@ -138,7 +142,14 @@ public class SeqTsFileRecoverTest {
writer.flushAllChunkGroups();
writer.getIOWriter().close();
- node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName());
+ node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName(), () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
for (int i = 10; i < 20; i++) {
for (int j = 0; j < 10; j++) {
String[] measurements = new String[10];
@@ -149,7 +160,8 @@ public class SeqTsFileRecoverTest {
types[k] = TSDataType.INT64;
values[k] = String.valueOf(k);
}
- InsertRowPlan insertPlan = new InsertRowPlan(new PartialPath("root.sg.device" + j), i, measurements, types,
+ InsertRowPlan insertPlan = new InsertRowPlan(new PartialPath("root.sg.device" + j), i,
+ measurements, types,
values);
node.write(insertPlan);
}
@@ -164,14 +176,28 @@ public class SeqTsFileRecoverTest {
EnvironmentUtils.cleanEnv();
FileUtils.deleteDirectory(tsF.getParentFile());
resource.close();
- node.delete();
+ ByteBuffer[] buffers = node.delete();
+ for (ByteBuffer byteBuffer : buffers) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
}
@Test
public void testNonLastRecovery() throws StorageGroupProcessorException, IOException {
TsFileRecoverPerformer performer = new TsFileRecoverPerformer(logNodePrefix,
resource, false, false);
- RestorableTsFileIOWriter writer = performer.recover(true);
+ RestorableTsFileIOWriter writer = performer.recover(true, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ }, (ByteBuffer[] array) -> {
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ });
assertFalse(writer.canWrite());
writer.close();
@@ -220,7 +246,18 @@ public class SeqTsFileRecoverTest {
public void testLastRecovery() throws StorageGroupProcessorException, IOException {
TsFileRecoverPerformer performer = new TsFileRecoverPerformer(logNodePrefix,
resource, false, true);
- RestorableTsFileIOWriter writer = performer.recover(true);
+ RestorableTsFileIOWriter writer = performer.recover(true, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ }, (ByteBuffer[] array) -> {
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ });
writer.makeMetadataVisible();
assertEquals(11, writer.getMetadatasForQuery().size());
diff --git a/server/src/test/java/org/apache/iotdb/db/writelog/recover/UnseqTsFileRecoverTest.java b/server/src/test/java/org/apache/iotdb/db/writelog/recover/UnseqTsFileRecoverTest.java
index 6e1351b..0bc20e1 100644
--- a/server/src/test/java/org/apache/iotdb/db/writelog/recover/UnseqTsFileRecoverTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/writelog/recover/UnseqTsFileRecoverTest.java
@@ -23,9 +23,12 @@ import static org.junit.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
import java.util.Collections;
import org.apache.commons.io.FileUtils;
import org.apache.iotdb.db.conf.IoTDBConstant;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.constant.TestConstant;
import org.apache.iotdb.db.engine.fileSystem.SystemFileFactory;
import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
@@ -39,6 +42,7 @@ import org.apache.iotdb.db.query.reader.chunk.ChunkDataIterator;
import org.apache.iotdb.db.query.reader.universal.PriorityMergeReader;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.db.utils.EnvironmentUtils;
+import org.apache.iotdb.db.utils.MmapUtil;
import org.apache.iotdb.db.writelog.manager.MultiFileLogNodeManager;
import org.apache.iotdb.db.writelog.node.WriteLogNode;
import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -142,7 +146,14 @@ public class UnseqTsFileRecoverTest {
writer.flushAllChunkGroups();
writer.getIOWriter().close();
- node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName());
+ node = MultiFileLogNodeManager.getInstance().getNode(logNodePrefix + tsF.getName(), () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ });
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
String[] measurements = new String[10];
@@ -172,7 +183,10 @@ public class UnseqTsFileRecoverTest {
public void tearDown() throws IOException, StorageEngineException {
FileUtils.deleteDirectory(tsF.getParentFile());
resource.close();
- node.delete();
+ ByteBuffer[] array = node.delete();
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
EnvironmentUtils.cleanEnv();
}
@@ -180,7 +194,18 @@ public class UnseqTsFileRecoverTest {
public void test() throws StorageGroupProcessorException, IOException {
TsFileRecoverPerformer performer = new TsFileRecoverPerformer(logNodePrefix,
resource, false, false);
- performer.recover(true).close();
+ performer.recover(true, () -> {
+ ByteBuffer[] buffers = new ByteBuffer[2];
+ buffers[0] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ buffers[1] = ByteBuffer
+ .allocateDirect(IoTDBDescriptor.getInstance().getConfig().getWalBufferSize() / 2);
+ return buffers;
+ }, (ByteBuffer[] array) -> {
+ for (ByteBuffer byteBuffer : array) {
+ MmapUtil.clean((MappedByteBuffer) byteBuffer);
+ }
+ }).close();
assertEquals(1, resource.getStartTime("root.sg.device99"));
assertEquals(300, resource.getEndTime("root.sg.device99"));