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