This is an automated email from the ASF dual-hosted git repository.

jt2594838 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 86b8295299d Optimize subscription acknowledgement and WAL prefetching 
(#18845)
86b8295299d is described below

commit 86b8295299de2672aa224e9f559415ac3b896126
Author: Caideyipi <[email protected]>
AuthorDate: Fri Nov 20 10:36:39 2026 +0800

    Optimize subscription acknowledgement and WAL prefetching (#18845)
    
    * Optimize subscription WAL acknowledgement path
    
    * Fix subscription ACK cleanup ordering
    
    * Optimize subscription tablet batching and WAL prefetch frontier
---
 .../consensus/iot/WriterSafeFrontierTracker.java   |  59 ++++-
 .../iot/WriterSafeFrontierTrackerTest.java         |  21 ++
 .../dataregion/wal/io/WALMetaData.java             |  18 +-
 .../consensus/ConsensusPrefetchingQueue.java       | 294 +++++++++++++++++----
 .../batch/SubscriptionPipeTabletEventBatch.java    | 147 ++++++++---
 .../response/SubscriptionEventTabletResponse.java  |  19 +-
 .../ConsensusPrefetchingQueueFrontierTest.java     |  65 +++++
 .../consensus/ConsensusPrefetchingQueueTest.java   |   6 +-
 .../SubscriptionPipeTabletEventBatchTest.java      |  16 +-
 9 files changed, 527 insertions(+), 118 deletions(-)

diff --git 
a/iotdb-core/consensus/src/main/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTracker.java
 
b/iotdb-core/consensus/src/main/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTracker.java
index 97e35ef1c3b..fe866515250 100644
--- 
a/iotdb-core/consensus/src/main/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTracker.java
+++ 
b/iotdb-core/consensus/src/main/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTracker.java
@@ -39,16 +39,19 @@ public class WriterSafeFrontierTracker {
   private static final Logger LOGGER = 
LoggerFactory.getLogger(WriterSafeFrontierTracker.class);
 
   private final Map<Integer, WriterFrontierState> states = new HashMap<>();
+  private volatile long effectiveSafePtVersion;
 
   public synchronized void recordAppliedProgress(
       final long physicalTime, final int writerNodeId, final long 
appliedLocalSeq) {
     final WriterFrontierState state =
         states.computeIfAbsent(writerNodeId, ignored -> new 
WriterFrontierState());
     state.appliedLocalSeq = Math.max(state.appliedLocalSeq, appliedLocalSeq);
-    if (physicalTime > 0) {
-      state.effectiveSafePt = Math.max(state.effectiveSafePt, physicalTime);
+    long effectiveSafePt = Math.max(state.effectiveSafePt, physicalTime);
+    if (state.hasPendingSafeTime() && state.appliedLocalSeq >= 
state.pendingSafeLocalSeq) {
+      effectiveSafePt = Math.max(effectiveSafePt, 
state.pendingSafePhysicalTime);
+      state.clearPendingSafeTime();
     }
-    promotePendingIfReady(state);
+    advanceEffectiveSafePt(state, effectiveSafePt);
   }
 
   public synchronized void observePendingWriterSafeTimeBarrier(
@@ -59,7 +62,7 @@ public class WriterSafeFrontierTracker {
     final WriterFrontierState state =
         states.computeIfAbsent(writerNodeId, ignored -> new 
WriterFrontierState());
     if (state.appliedLocalSeq >= barrierLocalSeq) {
-      state.effectiveSafePt = Math.max(state.effectiveSafePt, 
safePhysicalTime);
+      advanceEffectiveSafePt(state, safePhysicalTime);
       state.clearPendingSafeTime();
       return;
     }
@@ -107,6 +110,44 @@ public class WriterSafeFrontierTracker {
     return Collections.unmodifiableMap(snapshot);
   }
 
+  public synchronized Snapshot snapshotEffectiveSafePtsWithVersion() {
+    final Map<Integer, Long> snapshot = new HashMap<>();
+    for (final Map.Entry<Integer, WriterFrontierState> entry : 
states.entrySet()) {
+      snapshot.put(entry.getKey(), entry.getValue().effectiveSafePt);
+    }
+    return new Snapshot(effectiveSafePtVersion, 
Collections.unmodifiableMap(snapshot));
+  }
+
+  public long getEffectiveSafePtVersion() {
+    return effectiveSafePtVersion;
+  }
+
+  private void advanceEffectiveSafePt(
+      final WriterFrontierState state, final long safePhysicalTime) {
+    if (safePhysicalTime > state.effectiveSafePt) {
+      state.effectiveSafePt = safePhysicalTime;
+      effectiveSafePtVersion++;
+    }
+  }
+
+  public static final class Snapshot {
+    private final long version;
+    private final Map<Integer, Long> effectiveSafePts;
+
+    private Snapshot(final long version, final Map<Integer, Long> 
effectiveSafePts) {
+      this.version = version;
+      this.effectiveSafePts = effectiveSafePts;
+    }
+
+    public long getVersion() {
+      return version;
+    }
+
+    public Map<Integer, Long> getEffectiveSafePts() {
+      return effectiveSafePts;
+    }
+  }
+
   /**
    * Returns each safe time together with the applied sequence it covers. A 
subscription may use the
    * safe time only after consuming that sequence; applying records to the 
state machine does not
@@ -140,16 +181,6 @@ public class WriterSafeFrontierTracker {
     }
   }
 
-  private void promotePendingIfReady(final WriterFrontierState state) {
-    if (!state.hasPendingSafeTime()) {
-      return;
-    }
-    if (state.appliedLocalSeq >= state.pendingSafeLocalSeq) {
-      state.effectiveSafePt = Math.max(state.effectiveSafePt, 
state.pendingSafePhysicalTime);
-      state.clearPendingSafeTime();
-    }
-  }
-
   private static boolean dominates(
       final long leftSafePhysicalTime,
       final long leftSafeLocalSeq,
diff --git 
a/iotdb-core/consensus/src/test/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTrackerTest.java
 
b/iotdb-core/consensus/src/test/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTrackerTest.java
index d18aff9b95a..c34b2bd1e5e 100644
--- 
a/iotdb-core/consensus/src/test/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTrackerTest.java
+++ 
b/iotdb-core/consensus/src/test/java/org/apache/iotdb/consensus/iot/WriterSafeFrontierTrackerTest.java
@@ -73,4 +73,25 @@ public class WriterSafeFrontierTrackerTest {
     tracker.recordAppliedProgress(0L, 9, 35L);
     assertEquals(220L, tracker.getEffectiveSafePt(9));
   }
+
+  @Test
+  public void testEffectiveSafePtSnapshotIncludesAtomicVersion() {
+    final WriterSafeFrontierTracker tracker = new WriterSafeFrontierTracker();
+
+    tracker.observePendingWriterSafeTimeBarrier(200L, 9, 30L);
+    assertEquals(0L, tracker.getEffectiveSafePtVersion());
+
+    tracker.recordAppliedProgress(150L, 9, 30L);
+    assertEquals(200L, tracker.getEffectiveSafePt(9));
+    assertEquals(1L, tracker.getEffectiveSafePtVersion());
+
+    tracker.recordAppliedProgress(160L, 9, 31L);
+    assertEquals(1L, tracker.getEffectiveSafePtVersion());
+
+    tracker.recordAppliedProgress(250L, 9, 32L);
+    final WriterSafeFrontierTracker.Snapshot snapshot =
+        tracker.snapshotEffectiveSafePtsWithVersion();
+    assertEquals(2L, snapshot.getVersion());
+    assertEquals(Long.valueOf(250L), snapshot.getEffectiveSafePts().get(9));
+  }
 }
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/io/WALMetaData.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/io/WALMetaData.java
index 0cf97ba8809..068b70a3e2f 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/io/WALMetaData.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/io/WALMetaData.java
@@ -83,12 +83,17 @@ public class WALMetaData implements SerializedSize {
   }
 
   public WALMetaData(long firstSearchIndex, List<Integer> buffersSize, 
Set<Long> memTablesId) {
+    this(firstSearchIndex, buffersSize, memTablesId, 0);
+  }
+
+  private WALMetaData(
+      long firstSearchIndex, List<Integer> buffersSize, Set<Long> memTablesId, 
int entriesNum) {
     this.firstSearchIndex = firstSearchIndex;
     this.buffersSize = buffersSize;
     this.memTablesId = memTablesId;
-    this.physicalTimes = new ArrayList<>();
-    this.nodeIds = new ArrayList<>();
-    this.localSeqs = new ArrayList<>();
+    this.physicalTimes = new ArrayList<>(entriesNum);
+    this.nodeIds = new ArrayList<>(entriesNum);
+    this.localSeqs = new ArrayList<>(entriesNum);
   }
 
   /** Adds an entry without explicit writer progress metadata. */
@@ -249,7 +254,12 @@ public class WALMetaData implements SerializedSize {
         memTablesId.add(buffer.getLong());
       }
     }
-    WALMetaData result = new WALMetaData(firstSearchIndex, buffersSize, 
memTablesId);
+    WALMetaData result =
+        new WALMetaData(
+            firstSearchIndex,
+            buffersSize,
+            memTablesId,
+            version == WALFileVersion.V3 ? entriesNum : 0);
     // V3 extension: file-level timestamp range + per-entry writer progress 
metadata
     if (version == WALFileVersion.V3 && buffer.hasRemaining()) {
       result.minDataTs = buffer.getLong();
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueue.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueue.java
index 8d77149264f..643018691f8 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueue.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueue.java
@@ -28,6 +28,7 @@ import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.consensus.common.request.IndexedConsensusRequest;
 import org.apache.iotdb.consensus.iot.IoTConsensusServerImpl;
 import org.apache.iotdb.consensus.iot.SubscriptionWalRetentionPolicy;
+import org.apache.iotdb.consensus.iot.WriterSafeFrontierTracker;
 import org.apache.iotdb.consensus.iot.WriterSafeFrontierTracker.SafeFrontier;
 import org.apache.iotdb.consensus.iot.log.ConsensusReqReader;
 import org.apache.iotdb.consensus.iot.logdispatcher.IoTConsensusMemoryManager;
@@ -82,6 +83,7 @@ import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -201,6 +203,10 @@ public class ConsensusPrefetchingQueue {
   private final Map<SubscriptionCommitContext, SubscriptionEvent> 
outstandingEventsByCommitContext =
       new ConcurrentHashMap<>();
 
+  /** Events whose commit is being persisted outside the in-flight map 
callback. */
+  private final Set<SubscriptionEvent> acknowledgementInProgressEvents =
+      ConcurrentHashMap.newKeySet();
+
   /**
    * Compact batch boundaries and source positions; no Tablet or serialized 
response is retained.
    */
@@ -1481,22 +1487,24 @@ public class ConsensusPrefetchingQueue {
     return writerStates.computeIfAbsent(writerNodeId, ignored -> new 
WriterState());
   }
 
-  private void refreshWriterSafeFrontiers() {
-    final Map<Integer, Long> safePts =
-        serverImpl.getWriterSafeFrontierTracker().snapshotEffectiveSafePts();
-    for (final Map.Entry<Integer, Long> entry : safePts.entrySet()) {
+  private WriterSafeFrontierTracker.Snapshot refreshWriterSafeFrontiers() {
+    final WriterSafeFrontierTracker.Snapshot safePts =
+        
serverImpl.getWriterSafeFrontierTracker().snapshotEffectiveSafePtsWithVersion();
+    for (final Map.Entry<Integer, Long> entry : 
safePts.getEffectiveSafePts().entrySet()) {
       final WriterState writerState = trackWriterState(entry.getKey());
       writerState.effectiveSafePt = Math.max(writerState.effectiveSafePt, 
entry.getValue());
     }
+    return safePts;
   }
 
-  private <T extends WriterBufferedEntry> PriorityQueue<WriterFrontier> 
buildWriterFrontiers(
+  private <T extends WriterBufferedEntry> WriterFrontierSnapshot 
buildWriterFrontiers(
       final Map<Integer, ?> writerEntriesByWriter, final Function<Integer, T> 
headSupplier) {
-    refreshWriterSafeFrontiers();
-    final PriorityQueue<WriterFrontier> frontiers = new PriorityQueue<>();
+    final WriterSafeFrontierTracker.Snapshot safePts = 
refreshWriterSafeFrontiers();
+    final Set<Integer> activeWriterNodeIdsSnapshot = activeWriterNodeIds;
     final boolean useActiveWriterBarriers = shouldUseActiveWriterBarriers();
-    final Set<Integer> writerNodeIds = ConcurrentHashMap.newKeySet();
-    final Set<Integer> seenActiveWriterNodeIds = ConcurrentHashMap.newKeySet();
+    final PriorityQueue<WriterFrontier> frontiers = new PriorityQueue<>();
+    final Set<Integer> writerNodeIds = new HashSet<>();
+    final Set<Integer> seenActiveWriterNodeIds = new HashSet<>();
     writerNodeIds.addAll(writerStates.keySet());
     writerNodeIds.addAll(writerEntriesByWriter.keySet());
     for (final int writerNodeId : writerNodeIds) {
@@ -1506,29 +1514,36 @@ public class ConsensusPrefetchingQueue {
       }
       final T head = headSupplier.apply(writerNodeId);
       if (Objects.nonNull(head)) {
-        if (isWriterRuntimeActive(writerNodeId)) {
+        if (isWriterRuntimeActive(writerNodeId, activeWriterNodeIdsSnapshot)) {
           seenActiveWriterNodeIds.add(writerNodeId);
         }
-        frontiers.add(WriterFrontier.forHead(writerNodeId, head));
+        frontiers.add(WriterFrontier.forHead(writerNodeId, 
head.getOrderingKey()));
         continue;
       }
       if (Objects.nonNull(writerState)
           && writerState.effectiveSafePt > 0
           && useActiveWriterBarriers
-          && isWriterRuntimeActive(writerNodeId)) {
+          && isWriterRuntimeActive(writerNodeId, activeWriterNodeIdsSnapshot)) 
{
         seenActiveWriterNodeIds.add(writerNodeId);
         frontiers.add(WriterFrontier.forBarrier(writerNodeId, 
writerState.effectiveSafePt));
       }
     }
     if (useActiveWriterBarriers) {
-      for (final Integer activeWriterNodeId : activeWriterNodeIds) {
+      for (final Integer activeWriterNodeId : activeWriterNodeIdsSnapshot) {
         if (!seenActiveWriterNodeIds.contains(activeWriterNodeId)) {
-          frontiers.add(WriterFrontier.forBarrier(activeWriterNodeId, 
Long.MIN_VALUE));
+          
frontiers.add(WriterFrontier.forUnknownActiveWriter(activeWriterNodeId));
           break;
         }
       }
     }
-    return frontiers;
+    return new WriterFrontierSnapshot(
+        frontiers, safePts.getVersion(), activeWriterNodeIdsSnapshot, 
useActiveWriterBarriers);
+  }
+
+  private boolean isWriterRuntimeActive(
+      final int writerNodeId, final Set<Integer> activeWriterNodeIdsSnapshot) {
+    return activeWriterNodeIdsSnapshot.isEmpty()
+        || activeWriterNodeIdsSnapshot.contains(writerNodeId);
   }
 
   private boolean shouldUseActiveWriterBarriers() {
@@ -1567,7 +1582,7 @@ public class ConsensusPrefetchingQueue {
     }
   }
 
-  private PriorityQueue<WriterFrontier> buildRealtimeWriterFrontiers() {
+  private WriterFrontierSnapshot buildRealtimeWriterFrontiers() {
     return buildWriterFrontiers(realtimeEntriesByWriter, 
this::peekRealtimeEntry);
   }
 
@@ -1640,6 +1655,10 @@ public class ConsensusPrefetchingQueue {
         }
 
         synchronized (event) {
+          if (acknowledgementInProgressEvents.contains(event)) {
+            prefetchingQueue.add(event);
+            continue;
+          }
           // ACK may have removed a recycled event while it was being claimed 
from the queue.
           if (event.isCommitted()
               || (event.getCommitContext().hasWriterProgress()
@@ -2146,6 +2165,7 @@ public class ConsensusPrefetchingQueue {
               new WriterFrontier(
                   writerNodeId,
                   new OrderingKey(head.getPhysicalTime(), writerNodeId, 
head.getProgressLocalSeq()),
+                  false,
                   false));
         } else {
           final SafeFrontier safe = safeFrontiers.get(writerNodeId);
@@ -3646,6 +3666,22 @@ public class ConsensusPrefetchingQueue {
     requestPrefetch();
   }
 
+  /** Releases a requeued event's materialized payload; it can be restored 
from its WAL record. */
+  private void detachPayloadForReplay(final SubscriptionEvent event) {
+    synchronized (event) {
+      if (Objects.isNull(deliveryBatches.get(event))
+          || event.isCommitted()
+          || outstandingEventsByCommitContext.get(event.getCommitContext()) != 
event
+          || !event.detachCurrentPayload(event.getCurrentResponse())) {
+        return;
+      }
+      final Long retainedBytes = retainedBytesByEvent.remove(event);
+      if (Objects.nonNull(retainedBytes)) {
+        releaseTabletMemory(retainedBytes);
+      }
+    }
+  }
+
   private boolean restorePayloadForDelivery(final SubscriptionEvent event) {
     if (!event.isPayloadDetached()) {
       return true;
@@ -3941,7 +3977,7 @@ public class ConsensusPrefetchingQueue {
 
   private <T extends WriterBufferedEntry> boolean drainWriterEntries(
       final DeliveryBatchState batchState,
-      final Supplier<PriorityQueue<WriterFrontier>> frontierSupplier,
+      final Supplier<WriterFrontierSnapshot> frontierSupplier,
       final Function<Integer, T> headSupplier,
       final Predicate<T> releasePredicate,
       final BiConsumer<Integer, T> removeHeadAction,
@@ -3950,20 +3986,44 @@ public class ConsensusPrefetchingQueue {
       final long maxBatchBytes,
       final boolean trackLingerTime,
       final long expectedSeekGeneration) {
+    WriterFrontierSnapshot frontierSnapshot = frontierSupplier.get();
+    final WriterFrontierQueue frontiers = new 
WriterFrontierQueue(frontierSnapshot.frontiers);
+    boolean hasConsumedEntrySinceRefresh = false;
+
     while (true) {
-      final PriorityQueue<WriterFrontier> frontiers = frontierSupplier.get();
-      if (frontiers.isEmpty()) {
-        return true;
+      if (frontierSnapshot.activeWriterNodeIds != activeWriterNodeIds
+          || frontierSnapshot.useActiveWriterBarriers != 
shouldUseActiveWriterBarriers()
+          || frontierSnapshot.safeFrontierVersion
+              != 
serverImpl.getWriterSafeFrontierTracker().getEffectiveSafePtVersion()) {
+        frontierSnapshot = frontierSupplier.get();
+        frontiers.reset(frontierSnapshot.frontiers);
+        hasConsumedEntrySinceRefresh = false;
+        continue;
       }
+
       final WriterFrontier frontier = frontiers.peek();
-      if (Objects.isNull(frontier) || frontier.isBarrier) {
+      if (Objects.isNull(frontier)) {
+        return true;
+      }
+      if (frontier.isBarrier) {
+        if (hasConsumedEntrySinceRefresh) {
+          frontierSnapshot = frontierSupplier.get();
+          frontiers.reset(frontierSnapshot.frontiers);
+          hasConsumedEntrySinceRefresh = false;
+          continue;
+        }
         lastBlockedWriterFrontier = frontier;
         lastWriterBarrierInOrderedReplay = false;
         return true;
       }
+
+      frontiers.poll();
       final T writerHead = headSupplier.apply(frontier.writerNodeId);
       if (Objects.isNull(writerHead)) {
-        return true;
+        frontierSnapshot = frontierSupplier.get();
+        frontiers.reset(frontierSnapshot.frontiers);
+        hasConsumedEntrySinceRefresh = false;
+        continue;
       }
       if (!releasePredicate.test(writerHead)) {
         return true;
@@ -3974,6 +4034,8 @@ public class ConsensusPrefetchingQueue {
           return false;
         }
         removeHeadAction.accept(frontier.writerNodeId, writerHead);
+        hasConsumedEntrySinceRefresh = true;
+        addNextWriterFrontier(frontiers, frontierSnapshot, frontier, 
headSupplier);
         continue;
       }
 
@@ -3985,6 +4047,38 @@ public class ConsensusPrefetchingQueue {
 
       removeHeadAction.accept(frontier.writerNodeId, writerHead);
       batchState.append(writerHead, entryEstimatedBytes, trackLingerTime);
+      hasConsumedEntrySinceRefresh = true;
+      addNextWriterFrontier(frontiers, frontierSnapshot, frontier, 
headSupplier);
+    }
+  }
+
+  private <T extends WriterBufferedEntry> void addNextWriterFrontier(
+      final WriterFrontierQueue frontiers,
+      final WriterFrontierSnapshot frontierSnapshot,
+      final WriterFrontier frontier,
+      final Function<Integer, T> headSupplier) {
+    final T nextWriterHead = headSupplier.apply(frontier.writerNodeId);
+    if (Objects.nonNull(nextWriterHead)) {
+      frontiers.add(WriterFrontier.forHead(frontier.writerNodeId, 
nextWriterHead.getOrderingKey()));
+      return;
+    }
+
+    if (!frontierSnapshot.useActiveWriterBarriers) {
+      return;
+    }
+    final Set<Integer> activeWriterNodeIdsSnapshot = 
frontierSnapshot.activeWriterNodeIds;
+    final WriterState writerState = writerStates.get(frontier.writerNodeId);
+    final boolean writerIsRuntimeActive =
+        isWriterRuntimeActive(frontier.writerNodeId, 
activeWriterNodeIdsSnapshot);
+    if (Objects.nonNull(writerState)
+        && !writerState.closed
+        && writerState.effectiveSafePt > 0
+        && writerIsRuntimeActive) {
+      frontiers.add(WriterFrontier.forBarrier(frontier.writerNodeId, 
writerState.effectiveSafePt));
+    } else if (!activeWriterNodeIdsSnapshot.isEmpty()
+        && activeWriterNodeIdsSnapshot.contains(frontier.writerNodeId)
+        && !frontiers.hasUnknownActiveWriterBarrier()) {
+      
frontiers.add(WriterFrontier.forUnknownActiveWriter(frontier.writerNodeId));
     }
   }
 
@@ -4193,6 +4287,7 @@ public class ConsensusPrefetchingQueue {
     final WriterProgress commitWriterProgress = 
extractCommitWriterProgress(commitContext);
     final AtomicBoolean found = new AtomicBoolean(false);
     final AtomicBoolean acked = new AtomicBoolean(false);
+    final SubscriptionEvent[] eventToCommit = new SubscriptionEvent[1];
     inFlightEvents.compute(
         new InFlightEventKey(consumerId, commitContext),
         (key, ev) -> {
@@ -4213,29 +4308,40 @@ public class ConsensusPrefetchingQueue {
             return null;
           }
 
-          final boolean committed = commitWriterProgress(commitWriterId, 
commitWriterProgress);
-          if (!committed) {
-            if (!silent) {
-              LOGGER.warn(
-                  DataNodePipeMessages
-                      
.PIPE_LOG_CONSENSUSPREFETCHINGQUEUE_FAILED_TO_ADVANCE_COMMIT_FRONTIER_56E606C0,
-                  this,
-                  commitContext);
-            }
-            return ev;
-          }
-
-          ev.ack();
-          ev.recordCommittedTimestamp();
-          acked.set(true);
-          cleanUpEvent(ev, false);
-          return null;
+          eventToCommit[0] = ev;
+          acknowledgementInProgressEvents.add(ev);
+          return ev;
         });
-    if (acked.get()) {
-      // Retention refresh can read metadata from every newly relevant WAL 
file. Keep that I/O out
-      // of ConcurrentHashMap.compute so recycling and requeueing other 
in-flight events can
-      // proceed while an ACK advances committed progress.
-      refreshCommittedWalRetentionBoundAndNotify();
+    final SubscriptionEvent event = eventToCommit[0];
+    if (event != null) {
+      try {
+        final boolean committed = commitWriterProgress(commitWriterId, 
commitWriterProgress);
+        if (committed) {
+          final InFlightEventKey key = new InFlightEventKey(consumerId, 
commitContext);
+          inFlightEvents.compute(
+              key,
+              (ignored, inFlightEvent) -> {
+                synchronized (event) {
+                  event.ack();
+                  event.recordCommittedTimestamp();
+                  acked.set(true);
+                  cleanUpEvent(event, false);
+                }
+                return inFlightEvent == event ? null : inFlightEvent;
+              });
+          inFlightEvents.entrySet().removeIf(entry -> entry.getValue() == 
event);
+          prefetchingQueue.remove(event);
+          refreshCommittedWalRetentionBoundAndNotify();
+        } else if (!silent) {
+          LOGGER.warn(
+              DataNodePipeMessages
+                  
.PIPE_LOG_CONSENSUSPREFETCHINGQUEUE_FAILED_TO_ADVANCE_COMMIT_FRONTIER_56E606C0,
+              this,
+              commitContext);
+        }
+      } finally {
+        acknowledgementInProgressEvents.remove(event);
+      }
     }
     return !found.get()
         ? InFlightAckResult.MISSING
@@ -4403,6 +4509,9 @@ public class ConsensusPrefetchingQueue {
                 cleanUpEvent(ev, false);
                 return null;
               }
+              if (acknowledgementInProgressEvents.contains(ev)) {
+                detachPayloadForReplay(ev);
+              }
               prefetchingQueue.add(ev);
               LOGGER.debug(
                   DataNodePipeMessages
@@ -6540,25 +6649,114 @@ public class ConsensusPrefetchingQueue {
     }
   }
 
-  private static final class WriterFrontier implements 
Comparable<WriterFrontier> {
+  private static final class WriterFrontierSnapshot {
+    private final PriorityQueue<WriterFrontier> frontiers;
+    private final long safeFrontierVersion;
+    private final Set<Integer> activeWriterNodeIds;
+    private final boolean useActiveWriterBarriers;
+
+    private WriterFrontierSnapshot(
+        final PriorityQueue<WriterFrontier> frontiers,
+        final long safeFrontierVersion,
+        final Set<Integer> activeWriterNodeIds,
+        final boolean useActiveWriterBarriers) {
+      this.frontiers = frontiers;
+      this.safeFrontierVersion = safeFrontierVersion;
+      this.activeWriterNodeIds = activeWriterNodeIds;
+      this.useActiveWriterBarriers = useActiveWriterBarriers;
+    }
+  }
+
+  static final class WriterFrontierQueue {
+    private PriorityQueue<WriterFrontier> frontiers = new PriorityQueue<>();
+    private Integer unknownActiveWriterBarrierNodeId;
+
+    WriterFrontierQueue(final PriorityQueue<WriterFrontier> frontiers) {
+      reset(frontiers);
+    }
+
+    void reset(final PriorityQueue<WriterFrontier> frontiers) {
+      this.frontiers = frontiers;
+      unknownActiveWriterBarrierNodeId = null;
+      for (final WriterFrontier frontier : frontiers) {
+        if (frontier.isUnknownActiveWriterBarrier) {
+          unknownActiveWriterBarrierNodeId = frontier.writerNodeId;
+          break;
+        }
+      }
+    }
+
+    void add(final WriterFrontier frontier) {
+      frontiers.add(frontier);
+      if (frontier.isUnknownActiveWriterBarrier) {
+        unknownActiveWriterBarrierNodeId = frontier.writerNodeId;
+      }
+    }
+
+    WriterFrontier peek() {
+      return frontiers.peek();
+    }
+
+    WriterFrontier poll() {
+      final WriterFrontier frontier = frontiers.poll();
+      if (frontier != null && frontier.isUnknownActiveWriterBarrier) {
+        unknownActiveWriterBarrierNodeId = null;
+      }
+      return frontier;
+    }
+
+    boolean hasUnknownActiveWriterBarrier() {
+      return unknownActiveWriterBarrierNodeId != null;
+    }
+  }
+
+  static final class WriterFrontier implements Comparable<WriterFrontier> {
     private final int writerNodeId;
     private final OrderingKey orderingKey;
     private final boolean isBarrier;
+    private final boolean isUnknownActiveWriterBarrier;
 
     private WriterFrontier(
-        final int writerNodeId, final OrderingKey orderingKey, final boolean 
isBarrier) {
+        final int writerNodeId,
+        final OrderingKey orderingKey,
+        final boolean isBarrier,
+        final boolean isUnknownActiveWriterBarrier) {
       this.writerNodeId = writerNodeId;
       this.orderingKey = orderingKey;
       this.isBarrier = isBarrier;
+      this.isUnknownActiveWriterBarrier = isUnknownActiveWriterBarrier;
     }
 
     private static WriterFrontier forHead(final int writerNodeId, final 
WriterBufferedEntry entry) {
-      return new WriterFrontier(writerNodeId, entry.getOrderingKey(), false);
+      return forHead(writerNodeId, entry.getOrderingKey());
+    }
+
+    static WriterFrontier forHead(final int writerNodeId, final OrderingKey 
orderingKey) {
+      return new WriterFrontier(writerNodeId, orderingKey, false, false);
     }
 
     private static WriterFrontier forBarrier(final int writerNodeId, final 
long effectiveSafePt) {
       return new WriterFrontier(
-          writerNodeId, new OrderingKey(effectiveSafePt, Integer.MIN_VALUE, 
Long.MIN_VALUE), true);
+          writerNodeId,
+          new OrderingKey(effectiveSafePt, Integer.MIN_VALUE, Long.MIN_VALUE),
+          true,
+          false);
+    }
+
+    static WriterFrontier forUnknownActiveWriter(final int writerNodeId) {
+      return new WriterFrontier(
+          writerNodeId,
+          new OrderingKey(Long.MIN_VALUE, Integer.MIN_VALUE, Long.MIN_VALUE),
+          true,
+          true);
+    }
+
+    int getWriterNodeId() {
+      return writerNodeId;
+    }
+
+    boolean isBarrier() {
+      return isBarrier;
     }
 
     @Override
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatch.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatch.java
index 0f2653a6d12..06c77c7a596 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatch.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatch.java
@@ -41,7 +41,6 @@ import org.apache.iotdb.rpc.subscription.config.TopicConstant;
 
 import com.codahale.metrics.Clock;
 import com.codahale.metrics.Meter;
-import org.apache.tsfile.utils.Pair;
 import org.apache.tsfile.write.record.Tablet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -55,7 +54,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
-    implements Iterator<Pair<String, List<Tablet>>> {
+    implements Iterator<SubscriptionPipeTabletEventBatch.TabletBatch> {
 
   private static final Logger LOGGER =
       LoggerFactory.getLogger(SubscriptionPipeTabletEventBatch.class);
@@ -181,34 +180,32 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
             >= 
SubscriptionConfig.getInstance().getSubscriptionMaxAllowedEventCountInTabletBatch();
   }
 
-  private Pair<String, List<Tablet>> convertToTablets(
-      final TabletInsertionEvent tabletInsertionEvent) {
-    final Pair<String, List<Tablet>> result;
+  private TabletBatch convertToTablets(final TabletInsertionEvent 
tabletInsertionEvent) {
+    final TabletBatch result;
     if (tabletInsertionEvent instanceof PipeInsertNodeTabletInsertionEvent) {
       final List<Tablet> tablets =
           ((PipeInsertNodeTabletInsertionEvent) 
tabletInsertionEvent).convertToTablets();
-      updateEstimatedInsertNodeTabletInsertionEventSize(
-          tablets.stream()
-              .map(PipeMemoryWeightUtil::calculateTabletSizeInBytes)
-              .reduce(Long::sum)
-              .orElse(0L));
+      final long estimatedSizeInBytes = calculateTabletsSizeInBytes(tablets);
+      updateEstimatedInsertNodeTabletInsertionEventSize(estimatedSizeInBytes);
       result =
-          new Pair<>(
+          new TabletBatch(
               ((PipeInsertNodeTabletInsertionEvent) 
tabletInsertionEvent).isTableModelEvent()
                   ? ((PipeInsertNodeTabletInsertionEvent) tabletInsertionEvent)
                       .getTableModelDatabaseName()
                   : null,
-              tablets);
+              tablets,
+              estimatedSizeInBytes);
     } else if (tabletInsertionEvent instanceof PipeRawTabletInsertionEvent) {
       final Tablet tablet = ((PipeRawTabletInsertionEvent) 
tabletInsertionEvent).convertToTablet();
-      updateEstimatedRawTabletInsertionEventSize(
-          PipeMemoryWeightUtil.calculateTabletSizeInBytes(tablet));
+      final long estimatedSizeInBytes = 
PipeMemoryWeightUtil.calculateTabletSizeInBytes(tablet);
+      updateEstimatedRawTabletInsertionEventSize(estimatedSizeInBytes);
       result =
-          new Pair<>(
+          new TabletBatch(
               ((PipeRawTabletInsertionEvent) 
tabletInsertionEvent).isTableModelEvent()
                   ? ((PipeRawTabletInsertionEvent) 
tabletInsertionEvent).getTableModelDatabaseName()
                   : null,
-              Collections.singletonList(tablet));
+              Collections.singletonList(tablet),
+              estimatedSizeInBytes);
     } else {
       LOGGER.warn(
           DataNodePipeMessages
@@ -218,12 +215,21 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
       return null;
     }
 
-    return pruneTablets(projectTreeViewTabletsIfNecessary(result));
+    final TabletBatch projected = projectTreeViewTabletsIfNecessary(result);
+    if (Objects.isNull(projected)) {
+      return null;
+    }
+    final TabletBatch pruned = pruneTablets(projected);
+    if (Objects.isNull(pruned) || pruned.estimatedSizeMatchesTablets) {
+      return pruned;
+    }
+    return 
pruned.withEstimatedSize(calculateTabletsSizeInBytes(pruned.tablets));
   }
 
-  private Pair<String, List<Tablet>> projectTreeViewTabletsIfNecessary(
-      final Pair<String, List<Tablet>> tablets) {
-    if (Objects.isNull(tablets) || Objects.nonNull(tablets.left) || 
Objects.isNull(tablets.right)) {
+  private TabletBatch projectTreeViewTabletsIfNecessary(final TabletBatch 
tablets) {
+    if (Objects.isNull(tablets)
+        || Objects.nonNull(tablets.databaseName)
+        || Objects.isNull(tablets.tablets)) {
       return tablets;
     }
 
@@ -236,8 +242,8 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
               
.EXCEPTION_TREE_VIEW_PROJECTOR_IS_UNAVAILABLE_FOR_FILTERED_SUBSCRIPTION_DATA_B5F396A5);
     }
 
-    final List<Tablet> projectedTablets = new 
ArrayList<>(tablets.right.size());
-    for (final Tablet tablet : tablets.right) {
+    final List<Tablet> projectedTablets = new 
ArrayList<>(tablets.tablets.size());
+    for (final Tablet tablet : tablets.tablets) {
       final Tablet projectedTablet = treeViewProjector.project(tablet);
       if (Objects.nonNull(projectedTablet)) {
         projectedTablets.add(projectedTablet);
@@ -245,7 +251,7 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
     }
     return projectedTablets.isEmpty()
         ? null
-        : new Pair<>(treeViewProjector.getDatabaseName(), projectedTablets);
+        : tablets.withTablets(treeViewProjector.getDatabaseName(), 
projectedTablets);
   }
 
   private boolean prepareTreeViewTabletProjectorForEmission() {
@@ -269,25 +275,100 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
     return prepared;
   }
 
-  private Pair<String, List<Tablet>> pruneTablets(final Pair<String, 
List<Tablet>> tablets) {
-    if (Objects.isNull(tablets) || Objects.isNull(tablets.left) || 
Objects.isNull(tablets.right)) {
+  private TabletBatch pruneTablets(final TabletBatch tablets) {
+    if (Objects.isNull(tablets)
+        || Objects.isNull(tablets.databaseName)
+        || Objects.isNull(tablets.tablets)) {
       return tablets;
     }
 
     final SubscriptionFilterSnapshot snapshot = ensureFilterSnapshot();
 
-    final List<Tablet> prunedTablets = new ArrayList<>(tablets.right.size());
-    for (final Tablet tablet : tablets.right) {
+    final List<Tablet> prunedTablets = new ArrayList<>(tablets.tablets.size());
+    for (final Tablet tablet : tablets.tablets) {
       final Tablet prunedTablet =
           TabletColumnPruner.pruneTableModelTablet(
-              TabletTagFilter.filter(tablet, snapshot.getTagFilterMatcher(), 
tablets.left),
-              tablets.left,
+              TabletTagFilter.filter(tablet, snapshot.getTagFilterMatcher(), 
tablets.databaseName),
+              tablets.databaseName,
               snapshot.getColumnFilterMatcher());
       if (Objects.nonNull(prunedTablet)) {
         prunedTablets.add(prunedTablet);
       }
     }
-    return prunedTablets.isEmpty() ? null : new Pair<>(tablets.left, 
prunedTablets);
+    return prunedTablets.isEmpty()
+        ? null
+        : tablets.withTablets(tablets.databaseName, prunedTablets);
+  }
+
+  private long calculateTabletsSizeInBytes(final List<Tablet> tablets) {
+    long estimatedSizeInBytes = 0L;
+    for (final Tablet tablet : tablets) {
+      estimatedSizeInBytes += 
PipeMemoryWeightUtil.calculateTabletSizeInBytes(tablet);
+    }
+    return estimatedSizeInBytes;
+  }
+
+  private static boolean haveSameTabletReferences(
+      final List<Tablet> left, final List<Tablet> right) {
+    if (left == right) {
+      return true;
+    }
+    if (Objects.isNull(left) || Objects.isNull(right) || left.size() != 
right.size()) {
+      return false;
+    }
+    for (int i = 0; i < left.size(); i++) {
+      if (left.get(i) != right.get(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public static final class TabletBatch {
+    private final String databaseName;
+    private final List<Tablet> tablets;
+    private final long estimatedSizeInBytes;
+    private final boolean estimatedSizeMatchesTablets;
+
+    private TabletBatch(
+        final String databaseName, final List<Tablet> tablets, final long 
estimatedSizeInBytes) {
+      this(databaseName, tablets, estimatedSizeInBytes, true);
+    }
+
+    private TabletBatch(
+        final String databaseName,
+        final List<Tablet> tablets,
+        final long estimatedSizeInBytes,
+        final boolean estimatedSizeMatchesTablets) {
+      this.databaseName = databaseName;
+      this.tablets = tablets;
+      this.estimatedSizeInBytes = estimatedSizeInBytes;
+      this.estimatedSizeMatchesTablets = estimatedSizeMatchesTablets;
+    }
+
+    private TabletBatch withTablets(final String databaseName, final 
List<Tablet> tablets) {
+      return new TabletBatch(
+          databaseName,
+          tablets,
+          estimatedSizeInBytes,
+          estimatedSizeMatchesTablets && 
haveSameTabletReferences(this.tablets, tablets));
+    }
+
+    private TabletBatch withEstimatedSize(final long estimatedSizeInBytes) {
+      return new TabletBatch(databaseName, tablets, estimatedSizeInBytes, 
true);
+    }
+
+    public String getDatabaseName() {
+      return databaseName;
+    }
+
+    public List<Tablet> getTablets() {
+      return tablets;
+    }
+
+    public long getEstimatedSizeInBytes() {
+      return estimatedSizeInBytes;
+    }
   }
 
   @Override
@@ -381,8 +462,8 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
   }
 
   @Override
-  public synchronized Pair<String, List<Tablet>> next() {
-    final Pair<String, List<Tablet>> tablets = nextInternal();
+  public synchronized TabletBatch next() {
+    final TabletBatch tablets = nextInternal();
     if (Objects.isNull(tablets)) {
       return null;
     }
@@ -399,7 +480,7 @@ public class SubscriptionPipeTabletEventBatch extends 
SubscriptionPipeEventBatch
     return tablets;
   }
 
-  private Pair<String, List<Tablet>> nextInternal() {
+  private TabletBatch nextInternal() {
     if (Objects.nonNull(currentTabletInsertionEventsIterator)) {
       if (currentTabletInsertionEventsIterator.hasNext()) {
         final TabletInsertionEvent tabletInsertionEvent =
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/response/SubscriptionEventTabletResponse.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/response/SubscriptionEventTabletResponse.java
index f090c75ec2a..b0881baf7bd 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/response/SubscriptionEventTabletResponse.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/event/response/SubscriptionEventTabletResponse.java
@@ -25,7 +25,6 @@ import org.apache.iotdb.db.i18n.DataNodePipeMessages;
 import org.apache.iotdb.db.pipe.resource.PipeDataNodeResourceManager;
 import org.apache.iotdb.db.pipe.resource.memory.PipeMemoryBlockCategory;
 import org.apache.iotdb.db.pipe.resource.memory.PipeMemoryManager;
-import org.apache.iotdb.db.pipe.resource.memory.PipeMemoryWeightUtil;
 import org.apache.iotdb.db.pipe.resource.memory.PipeTabletMemoryBlock;
 import org.apache.iotdb.db.subscription.broker.SubscriptionPrefetchingQueue;
 import org.apache.iotdb.db.subscription.columnfilter.ColumnFilterMatcher;
@@ -38,7 +37,6 @@ import 
org.apache.iotdb.rpc.subscription.payload.poll.SubscriptionCommitContext;
 import 
org.apache.iotdb.rpc.subscription.payload.poll.SubscriptionPollResponseType;
 import org.apache.iotdb.rpc.subscription.payload.poll.TabletsPayload;
 
-import org.apache.tsfile.utils.Pair;
 import org.apache.tsfile.write.record.Tablet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -196,20 +194,17 @@ public class SubscriptionEventTabletResponse extends 
SubscriptionEventExtendable
     // 
waitForResourceEnough4Parsing(SubscriptionAgent.receiver().remainingMs());
 
     while (batch.hasNext()) {
-      final Pair<String, List<Tablet>> tablets = batch.next();
-      if (Objects.isNull(tablets)) {
+      final SubscriptionPipeTabletEventBatch.TabletBatch tabletBatch = 
batch.next();
+      if (Objects.isNull(tabletBatch)) {
         continue;
       }
 
+      final List<Tablet> tablets = tabletBatch.getTablets();
       currentTablets
-          .computeIfAbsent(tablets.left, databaseName -> new ArrayList<>())
-          .addAll(tablets.right);
-      final long bufferSize =
-          tablets.right.stream()
-              .map(PipeMemoryWeightUtil::calculateTabletSizeInBytes)
-              .reduce(Long::sum)
-              .orElse(0L);
-      totalTablets += tablets.right.size();
+          .computeIfAbsent(tabletBatch.getDatabaseName(), databaseName -> new 
ArrayList<>())
+          .addAll(tablets);
+      final long bufferSize = tabletBatch.getEstimatedSizeInBytes();
+      totalTablets += tablets.size();
       totalBufferSize += bufferSize;
       currentBufferSize += bufferSize;
 
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueFrontierTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueFrontierTest.java
new file mode 100644
index 00000000000..168bc8e838e
--- /dev/null
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueFrontierTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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.subscription.broker.consensus;
+
+import 
org.apache.iotdb.db.subscription.broker.consensus.ConsensusPrefetchingQueue.OrderingKey;
+import 
org.apache.iotdb.db.subscription.broker.consensus.ConsensusPrefetchingQueue.WriterFrontier;
+import 
org.apache.iotdb.db.subscription.broker.consensus.ConsensusPrefetchingQueue.WriterFrontierQueue;
+
+import org.junit.Test;
+
+import java.util.PriorityQueue;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class ConsensusPrefetchingQueueFrontierTest {
+
+  @Test
+  public void testIncrementalHeadInsertionPreservesOrdering() {
+    final PriorityQueue<WriterFrontier> initialFrontiers = new 
PriorityQueue<>();
+    initialFrontiers.add(WriterFrontier.forHead(1, new OrderingKey(100L, 1, 
1L)));
+    initialFrontiers.add(WriterFrontier.forHead(2, new OrderingKey(90L, 2, 
1L)));
+    final WriterFrontierQueue frontiers = new 
WriterFrontierQueue(initialFrontiers);
+
+    assertEquals(2, frontiers.poll().getWriterNodeId());
+    frontiers.add(WriterFrontier.forHead(2, new OrderingKey(110L, 2, 2L)));
+
+    assertEquals(1, frontiers.poll().getWriterNodeId());
+    assertEquals(2, frontiers.poll().getWriterNodeId());
+    assertNull(frontiers.peek());
+  }
+
+  @Test
+  public void testUnknownActiveWriterBarrierBlocksKnownHeadsAndResetClearsIt() 
{
+    final PriorityQueue<WriterFrontier> initialFrontiers = new 
PriorityQueue<>();
+    initialFrontiers.add(WriterFrontier.forHead(1, new OrderingKey(1L, 1, 
1L)));
+    initialFrontiers.add(WriterFrontier.forUnknownActiveWriter(2));
+    final WriterFrontierQueue frontiers = new 
WriterFrontierQueue(initialFrontiers);
+
+    assertTrue(frontiers.hasUnknownActiveWriterBarrier());
+    assertTrue(frontiers.peek().isBarrier());
+    assertEquals(2, frontiers.peek().getWriterNodeId());
+
+    frontiers.reset(new PriorityQueue<>());
+
+    assertFalse(frontiers.hasUnknownActiveWriterBarrier());
+  }
+}
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueTest.java
index a58bba7df76..9e92ec114ff 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueTest.java
@@ -2704,6 +2704,7 @@ public class ConsensusPrefetchingQueueTest {
         // A slow retention read must not keep the event-map bucket locked by 
ACK and stall
         // a shared prefetch worker trying to recycle that event.
         executor.submit(() -> recycle.invoke(activeQueue)).get(5, 
TimeUnit.SECONDS);
+        assertTrue(event.isCommitted());
         assertEquals(0L, activeQueue.getSubscriptionUncommittedEventCount());
         assertEquals(0L, activeQueue.getRetainedTabletBytes());
         assertFalse(ack.isDone());
@@ -3869,7 +3870,7 @@ public class ConsensusPrefetchingQueueTest {
       if (recycle) {
         CommonDescriptor.getInstance()
             .getConfig()
-            .setSubscriptionRecycleUncommittedEventIntervalMs(-1);
+            .setSubscriptionRecycleUncommittedEventIntervalMs(1);
       }
       final DataRegionId regionId = new DataRegionId(1);
       final FakeConsensusReqReader reader = new FakeConsensusReqReader();
@@ -3921,6 +3922,8 @@ public class ConsensusPrefetchingQueueTest {
       assertNotNull(event);
       final long retainedBytes = queue.getRetainedTabletBytes();
       assertTrue(retainedBytes > 0L);
+      final Field timestampField = 
SubscriptionEvent.class.getDeclaredField("lastPolledTimestamp");
+      timestampField.setAccessible(true);
 
       if (failCommit) {
         final AtomicBoolean rejectFirstCommit = new AtomicBoolean(true);
@@ -3938,6 +3941,7 @@ public class ConsensusPrefetchingQueueTest {
 
       for (int retry = 1; retry <= 10; retry++) {
         if (recycle) {
+          ((AtomicLong) 
timestampField.get(event)).set(System.currentTimeMillis() - 900000L);
           queue.drivePrefetchOnce();
         } else if (silent) {
           assertTrue(queue.nackSilent("consumer", event.getCommitContext()));
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatchTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatchTest.java
index 7dbc5b0b188..84ed5f16c48 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatchTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatchTest.java
@@ -30,6 +30,7 @@ import 
org.apache.iotdb.db.pipe.event.common.tsfile.PipeTsFileInsertionEvent;
 import org.apache.iotdb.db.pipe.resource.PipeDataNodeResourceManager;
 import org.apache.iotdb.db.pipe.resource.memory.PipeMemoryManager;
 import 
org.apache.iotdb.db.pipe.resource.memory.PipeMemoryManager.TsFileParserMemoryReservation;
+import org.apache.iotdb.db.pipe.resource.memory.PipeMemoryWeightUtil;
 import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource;
 import 
org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResourceStatus;
 import org.apache.iotdb.db.subscription.agent.SubscriptionAgent;
@@ -45,7 +46,6 @@ import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.external.commons.io.FileUtils;
 import org.apache.tsfile.file.metadata.IDeviceID;
 import org.apache.tsfile.file.metadata.TableSchema;
-import org.apache.tsfile.utils.Pair;
 import org.apache.tsfile.write.TsFileWriter;
 import org.apache.tsfile.write.record.Tablet;
 import org.apache.tsfile.write.schema.MeasurementSchema;
@@ -173,7 +173,7 @@ public class SubscriptionPipeTabletEventBatchTest {
     batch.resetForIteration();
 
     Assert.assertTrue(batch.hasNext());
-    final Pair<String, List<Tablet>> first = batch.next();
+    final SubscriptionPipeTabletEventBatch.TabletBatch first = batch.next();
     assertTablet(first, "table_0", 1);
     Assert.assertTrue("The exhausted file must release its parser before ACK", 
canReserveParser());
 
@@ -307,11 +307,15 @@ public class SubscriptionPipeTabletEventBatchTest {
   }
 
   private static void assertTablet(
-      final Pair<String, List<Tablet>> tablets, final String tableName, final 
long time) {
+      final SubscriptionPipeTabletEventBatch.TabletBatch tablets,
+      final String tableName,
+      final long time) {
     Assert.assertNotNull(tablets);
-    Assert.assertEquals("test_sg_0", tablets.left);
-    Assert.assertEquals(1, tablets.right.size());
-    final Tablet tablet = tablets.right.get(0);
+    Assert.assertEquals("test_sg_0", tablets.getDatabaseName());
+    Assert.assertEquals(1, tablets.getTablets().size());
+    final Tablet tablet = tablets.getTablets().get(0);
+    Assert.assertEquals(
+        PipeMemoryWeightUtil.calculateTabletSizeInBytes(tablet), 
tablets.getEstimatedSizeInBytes());
     Assert.assertEquals(tableName, tablet.getTableName());
     Assert.assertEquals(1, tablet.getRowSize());
     Assert.assertEquals(time, tablet.getTimestamps()[0]);

Reply via email to