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"));