From e69549b9165d300a825e0a2fd3d70eb290f67932 Mon Sep 17 00:00:00 2001 From: Caideyipi <87789683+Caideyipi@users.noreply.github.com> Date: Tue, 13 Oct 2026 12:52:55 +0800 Subject: [PATCH 1/3] Optimize subscription WAL acknowledgement path --- .../dataregion/wal/io/WALMetaData.java | 13 +++++-- .../consensus/ConsensusPrefetchingQueue.java | 38 ++++++++++--------- 2 files changed, 29 insertions(+), 22 deletions(-) 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 50ae0961ce1ff..1407f106dae58 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 @@ -82,12 +82,17 @@ public WALMetaData() { } public WALMetaData(long firstSearchIndex, List buffersSize, Set memTablesId) { + this(firstSearchIndex, buffersSize, memTablesId, 0); + } + + private WALMetaData( + long firstSearchIndex, List buffersSize, Set 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. */ @@ -248,7 +253,7 @@ public static WALMetaData deserialize(ByteBuffer buffer, WALFileVersion version) memTablesId.add(buffer.getLong()); } } - WALMetaData result = new WALMetaData(firstSearchIndex, buffersSize, memTablesId); + WALMetaData result = new WALMetaData(firstSearchIndex, buffersSize, memTablesId, entriesNum); // 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 dd5d204000970..cf12658a6e361 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 @@ -3108,6 +3108,7 @@ private InFlightAckResult ackInFlightEvent( 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) -> { @@ -3128,25 +3129,26 @@ private InFlightAckResult ackInFlightEvent( return null; } - final boolean committed = - commitAndRefreshWalRetention(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; + return ev; }); + final SubscriptionEvent event = eventToCommit[0]; + if (event != null) { + final boolean committed = commitAndRefreshWalRetention(commitWriterId, commitWriterProgress); + if (committed + && inFlightEvents.remove(new InFlightEventKey(consumerId, commitContext), event)) { + event.ack(); + event.recordCommittedTimestamp(); + acked.set(true); + cleanUpEvent(event, false); + } else if (!committed && !silent) { + LOGGER.warn( + DataNodePipeMessages + .PIPE_LOG_CONSENSUSPREFETCHINGQUEUE_FAILED_TO_ADVANCE_COMMIT_FRONTIER_56E606C0, + this, + commitContext); + } + } return !found.get() ? InFlightAckResult.MISSING : acked.get() ? InFlightAckResult.ACKED : InFlightAckResult.REJECTED; From abef0a8c9da3f2e187d82f8bc3a53c91df1d6aa3 Mon Sep 17 00:00:00 2001 From: Caideyipi <87789683+Caideyipi@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:07:28 +0800 Subject: [PATCH 2/3] Fix subscription ACK cleanup ordering --- .../dataregion/wal/io/WALMetaData.java | 7 ++++- .../consensus/ConsensusPrefetchingQueue.java | 27 +++++++++++-------- .../ConsensusPrefetchingQueueTest.java | 1 + 3 files changed, 23 insertions(+), 12 deletions(-) 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 ea875aefd7c21..32a1c37d08b1f 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 @@ -254,7 +254,12 @@ public static WALMetaData deserialize(ByteBuffer buffer, WALFileVersion version) memTablesId.add(buffer.getLong()); } } - WALMetaData result = new WALMetaData(firstSearchIndex, buffersSize, memTablesId, entriesNum); + 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 04e791a079368..a243a3969e438 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 @@ -4147,18 +4147,23 @@ private InFlightAckResult ackInFlightEvent( final SubscriptionEvent event = eventToCommit[0]; if (event != null) { try { - final boolean committed = - commitAndRefreshWalRetention(commitWriterId, commitWriterProgress); + final boolean committed = commitWriterProgress(commitWriterId, commitWriterProgress); if (committed) { - synchronized (event) { - event.ack(); - event.recordCommittedTimestamp(); - inFlightEvents.remove(new InFlightEventKey(consumerId, commitContext), event); - inFlightEvents.entrySet().removeIf(entry -> entry.getValue() == event); - prefetchingQueue.remove(event); - acked.set(true); - cleanUpEvent(event, false); - } + 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 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 8d7edd979c50f..c5294d2b6ba5b 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 @@ -2686,6 +2686,7 @@ ProgressWALReader openProgressWALReader(final File walFile) throws IOException { // 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()); From 279f79d5af5ba1f700f69f3861f0f4ba65df8a5b Mon Sep 17 00:00:00 2001 From: Caideyipi <87789683+Caideyipi@users.noreply.github.com> Date: Thu, 19 Nov 2026 15:27:45 +0800 Subject: [PATCH 3/3] Optimize subscription tablet batching and WAL prefetch frontier --- .../iot/WriterSafeFrontierTracker.java | 59 +++-- .../iot/WriterSafeFrontierTrackerTest.java | 21 ++ .../consensus/ConsensusPrefetchingQueue.java | 214 +++++++++++++++--- .../SubscriptionPipeTabletEventBatch.java | 147 +++++++++--- .../SubscriptionEventTabletResponse.java | 19 +- ...ConsensusPrefetchingQueueFrontierTest.java | 65 ++++++ .../SubscriptionPipeTabletEventBatchTest.java | 16 +- 7 files changed, 448 insertions(+), 93 deletions(-) create mode 100644 iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueFrontierTest.java 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 97e35ef1c3b94..fe86651525074 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 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 synchronized void observePendingWriterSafeTimeBarrier( 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 synchronized Map snapshotEffectiveSafePts() { return Collections.unmodifiableMap(snapshot); } + public synchronized Snapshot snapshotEffectiveSafePtsWithVersion() { + final Map snapshot = new HashMap<>(); + for (final Map.Entry 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 effectiveSafePts; + + private Snapshot(final long version, final Map effectiveSafePts) { + this.version = version; + this.effectiveSafePts = effectiveSafePts; + } + + public long getVersion() { + return version; + } + + public Map 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 long getLocalSeq() { } } - 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 d18aff9b95aff..c34b2bd1e5ea3 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 void testSameWriterKeepsOnlyNewestPendingWriterSafeTimeBarrier() { 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/subscription/broker/consensus/ConsensusPrefetchingQueue.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueue.java index a243a3969e438..7ee7ccb164457 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.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; @@ -81,6 +82,7 @@ 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; @@ -1433,22 +1435,24 @@ private WriterState trackWriterState(final int writerNodeId) { return writerStates.computeIfAbsent(writerNodeId, ignored -> new WriterState()); } - private void refreshWriterSafeFrontiers() { - final Map safePts = - serverImpl.getWriterSafeFrontierTracker().snapshotEffectiveSafePts(); - for (final Map.Entry entry : safePts.entrySet()) { + private WriterSafeFrontierTracker.Snapshot refreshWriterSafeFrontiers() { + final WriterSafeFrontierTracker.Snapshot safePts = + serverImpl.getWriterSafeFrontierTracker().snapshotEffectiveSafePtsWithVersion(); + for (final Map.Entry entry : safePts.getEffectiveSafePts().entrySet()) { final WriterState writerState = trackWriterState(entry.getKey()); writerState.effectiveSafePt = Math.max(writerState.effectiveSafePt, entry.getValue()); } + return safePts; } - private PriorityQueue buildWriterFrontiers( + private WriterFrontierSnapshot buildWriterFrontiers( final Map writerEntriesByWriter, final Function headSupplier) { - refreshWriterSafeFrontiers(); - final PriorityQueue frontiers = new PriorityQueue<>(); + final WriterSafeFrontierTracker.Snapshot safePts = refreshWriterSafeFrontiers(); + final Set activeWriterNodeIdsSnapshot = activeWriterNodeIds; final boolean useActiveWriterBarriers = shouldUseActiveWriterBarriers(); - final Set writerNodeIds = ConcurrentHashMap.newKeySet(); - final Set seenActiveWriterNodeIds = ConcurrentHashMap.newKeySet(); + final PriorityQueue frontiers = new PriorityQueue<>(); + final Set writerNodeIds = new HashSet<>(); + final Set seenActiveWriterNodeIds = new HashSet<>(); writerNodeIds.addAll(writerStates.keySet()); writerNodeIds.addAll(writerEntriesByWriter.keySet()); for (final int writerNodeId : writerNodeIds) { @@ -1458,29 +1462,36 @@ private PriorityQueue buildWrite } 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 activeWriterNodeIdsSnapshot) { + return activeWriterNodeIdsSnapshot.isEmpty() + || activeWriterNodeIdsSnapshot.contains(writerNodeId); } private boolean shouldUseActiveWriterBarriers() { @@ -1519,7 +1530,7 @@ private void removeRealtimeEntry(final int writerNodeId, final long localSeq) { } } - private PriorityQueue buildRealtimeWriterFrontiers() { + private WriterFrontierSnapshot buildRealtimeWriterFrontiers() { return buildWriterFrontiers(realtimeEntriesByWriter, this::peekRealtimeEntry); } @@ -2068,6 +2079,7 @@ private PrefetchRoundResult driveOrderedWriterReplay( new WriterFrontier( writerNodeId, new OrderingKey(head.getPhysicalTime(), writerNodeId, head.getProgressLocalSeq()), + false, false)); } else if (isWriterRuntimeActive(writerNodeId) || !state.caughtUp) { final SafeFrontier safe = safeFrontiers.get(writerNodeId); @@ -3868,7 +3880,7 @@ private boolean drainRealtimeWriters( private boolean drainWriterEntries( final DeliveryBatchState batchState, - final Supplier> frontierSupplier, + final Supplier frontierSupplier, final Function headSupplier, final Predicate releasePredicate, final BiConsumer removeHeadAction, @@ -3877,20 +3889,44 @@ private boolean drainWriterEntries( 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 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; @@ -3901,6 +3937,8 @@ private boolean drainWriterEntries( return false; } removeHeadAction.accept(frontier.writerNodeId, writerHead); + hasConsumedEntrySinceRefresh = true; + addNextWriterFrontier(frontiers, frontierSnapshot, frontier, headSupplier); continue; } @@ -3912,6 +3950,38 @@ private boolean drainWriterEntries( removeHeadAction.accept(frontier.writerNodeId, writerHead); batchState.append(writerHead, entryEstimatedBytes, trackLingerTime); + hasConsumedEntrySinceRefresh = true; + addNextWriterFrontier(frontiers, frontierSnapshot, frontier, headSupplier); + } + } + + private void addNextWriterFrontier( + final WriterFrontierQueue frontiers, + final WriterFrontierSnapshot frontierSnapshot, + final WriterFrontier frontier, + final Function 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 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)); } } @@ -5810,8 +5880,7 @@ public String getOrderMode() { } private boolean isWriterRuntimeActive(final int writerNodeId) { - final Set writerNodeIds = activeWriterNodeIds; - return writerNodeIds.isEmpty() || writerNodeIds.contains(writerNodeId); + return isWriterRuntimeActive(writerNodeId, activeWriterNodeIds); } public void applyRuntimeState(final ConsensusRegionRuntimeState runtimeState) { @@ -6389,25 +6458,114 @@ public OrderingKey getOrderingKey() { } } - private static final class WriterFrontier implements Comparable { + private static final class WriterFrontierSnapshot { + private final PriorityQueue frontiers; + private final long safeFrontierVersion; + private final Set activeWriterNodeIds; + private final boolean useActiveWriterBarriers; + + private WriterFrontierSnapshot( + final PriorityQueue frontiers, + final long safeFrontierVersion, + final Set activeWriterNodeIds, + final boolean useActiveWriterBarriers) { + this.frontiers = frontiers; + this.safeFrontierVersion = safeFrontierVersion; + this.activeWriterNodeIds = activeWriterNodeIds; + this.useActiveWriterBarriers = useActiveWriterBarriers; + } + } + + static final class WriterFrontierQueue { + private PriorityQueue frontiers = new PriorityQueue<>(); + private Integer unknownActiveWriterBarrierNodeId; + + WriterFrontierQueue(final PriorityQueue frontiers) { + reset(frontiers); + } + + void reset(final PriorityQueue 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 { 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 0f2653a6d12e8..06c77c7a596ea 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 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.AtomicLong; public class SubscriptionPipeTabletEventBatch extends SubscriptionPipeEventBatch - implements Iterator>> { + implements Iterator { private static final Logger LOGGER = LoggerFactory.getLogger(SubscriptionPipeTabletEventBatch.class); @@ -181,34 +180,32 @@ protected boolean shouldEmit() { >= SubscriptionConfig.getInstance().getSubscriptionMaxAllowedEventCountInTabletBatch(); } - private Pair> convertToTablets( - final TabletInsertionEvent tabletInsertionEvent) { - final Pair> result; + private TabletBatch convertToTablets(final TabletInsertionEvent tabletInsertionEvent) { + final TabletBatch result; if (tabletInsertionEvent instanceof PipeInsertNodeTabletInsertionEvent) { final List 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 @@ private Pair> convertToTablets( 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> projectTreeViewTabletsIfNecessary( - final Pair> 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 @@ private Pair> projectTreeViewTabletsIfNecessary( .EXCEPTION_TREE_VIEW_PROJECTOR_IS_UNAVAILABLE_FOR_FILTERED_SUBSCRIPTION_DATA_B5F396A5); } - final List projectedTablets = new ArrayList<>(tablets.right.size()); - for (final Tablet tablet : tablets.right) { + final List 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 @@ private Pair> projectTreeViewTabletsIfNecessary( } return projectedTablets.isEmpty() ? null - : new Pair<>(treeViewProjector.getDatabaseName(), projectedTablets); + : tablets.withTablets(treeViewProjector.getDatabaseName(), projectedTablets); } private boolean prepareTreeViewTabletProjectorForEmission() { @@ -269,25 +275,100 @@ private boolean prepareTreeViewTabletProjectorForEmission() { return prepared; } - private Pair> pruneTablets(final Pair> 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 prunedTablets = new ArrayList<>(tablets.right.size()); - for (final Tablet tablet : tablets.right) { + final List 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 tablets) { + long estimatedSizeInBytes = 0L; + for (final Tablet tablet : tablets) { + estimatedSizeInBytes += PipeMemoryWeightUtil.calculateTabletSizeInBytes(tablet); + } + return estimatedSizeInBytes; + } + + private static boolean haveSameTabletReferences( + final List left, final List 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 tablets; + private final long estimatedSizeInBytes; + private final boolean estimatedSizeMatchesTablets; + + private TabletBatch( + final String databaseName, final List tablets, final long estimatedSizeInBytes) { + this(databaseName, tablets, estimatedSizeInBytes, true); + } + + private TabletBatch( + final String databaseName, + final List 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 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 getTablets() { + return tablets; + } + + public long getEstimatedSizeInBytes() { + return estimatedSizeInBytes; + } } @Override @@ -381,8 +462,8 @@ public synchronized boolean hasNext() { } @Override - public synchronized Pair> next() { - final Pair> tablets = nextInternal(); + public synchronized TabletBatch next() { + final TabletBatch tablets = nextInternal(); if (Objects.isNull(tablets)) { return null; } @@ -399,7 +480,7 @@ public synchronized Pair> next() { return tablets; } - private Pair> 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 3bcbc888f0188..dd16e8a4785a5 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.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.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; @@ -193,20 +191,17 @@ private synchronized CachedSubscriptionPollResponse generateNextTabletResponse() // waitForResourceEnough4Parsing(SubscriptionAgent.receiver().remainingMs()); while (batch.hasNext()) { - final Pair> tablets = batch.next(); - if (Objects.isNull(tablets)) { + final SubscriptionPipeTabletEventBatch.TabletBatch tabletBatch = batch.next(); + if (Objects.isNull(tabletBatch)) { continue; } + final List 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 0000000000000..168bc8e838e25 --- /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 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 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/event/batch/SubscriptionPipeTabletEventBatchTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/event/batch/SubscriptionPipeTabletEventBatchTest.java index d6294ff227b4f..e65e23e0391f2 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.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; @@ -42,7 +43,6 @@ 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; @@ -137,7 +137,7 @@ public void testSameRegionFilesReleaseParserBeforeBatchAck() throws Exception { batch.resetForIteration(); Assert.assertTrue(batch.hasNext()); - final Pair> 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()); @@ -271,11 +271,15 @@ private static void writeTable(final TsFileWriter writer, final String tableName } private static void assertTablet( - final Pair> 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]);