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 97e35ef1c3b9..fe8665152507 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 d18aff9b95af..c34b2bd1e5ea 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/storageengine/dataregion/wal/io/WALMetaData.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/wal/io/WALMetaData.java index 0cf97ba88095..068b70a3e2ff 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 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. */ @@ -249,7 +254,12 @@ 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, + 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 8d77149264f0..643018691f88 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; @@ -82,6 +83,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; @@ -201,6 +203,10 @@ public class ConsensusPrefetchingQueue { private final Map outstandingEventsByCommitContext = new ConcurrentHashMap<>(); + /** Events whose commit is being persisted outside the in-flight map callback. */ + private final Set acknowledgementInProgressEvents = + ConcurrentHashMap.newKeySet(); + /** * Compact batch boundaries and source positions; no Tablet or serialized response is retained. */ @@ -1481,22 +1487,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) { @@ -1506,29 +1514,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() { @@ -1567,7 +1582,7 @@ private void removeRealtimeEntry(final int writerNodeId, final long localSeq) { } } - private PriorityQueue buildRealtimeWriterFrontiers() { + private WriterFrontierSnapshot buildRealtimeWriterFrontiers() { return buildWriterFrontiers(realtimeEntriesByWriter, this::peekRealtimeEntry); } @@ -1640,6 +1655,10 @@ private SubscriptionEvent pollInternal(final String consumerId, final PollTimer } 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 @@ private PrefetchRoundResult driveOrderedWriterReplay( new WriterFrontier( writerNodeId, new OrderingKey(head.getPhysicalTime(), writerNodeId, head.getProgressLocalSeq()), + false, false)); } else { final SafeFrontier safe = safeFrontiers.get(writerNodeId); @@ -3646,6 +3666,22 @@ private void onResponseDelivered( 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 @@ private boolean drainRealtimeWriters( private boolean drainWriterEntries( final DeliveryBatchState batchState, - final Supplier> frontierSupplier, + final Supplier frontierSupplier, final Function headSupplier, final Predicate releasePredicate, final BiConsumer removeHeadAction, @@ -3950,20 +3986,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; @@ -3974,6 +4034,8 @@ private boolean drainWriterEntries( return false; } removeHeadAction.accept(frontier.writerNodeId, writerHead); + hasConsumedEntrySinceRefresh = true; + addNextWriterFrontier(frontiers, frontierSnapshot, frontier, headSupplier); continue; } @@ -3985,6 +4047,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)); } } @@ -4193,6 +4287,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) -> { @@ -4213,29 +4308,40 @@ private InFlightAckResult ackInFlightEvent( 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 @@ private void recycleInFlightEvents() { cleanUpEvent(ev, false); return null; } + if (acknowledgementInProgressEvents.contains(ev)) { + detachPayloadForReplay(ev); + } prefetchingQueue.add(ev); LOGGER.debug( DataNodePipeMessages @@ -6540,25 +6649,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 0f2653a6d12e..06c77c7a596e 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 f090c75ec2a5..b0881baf7bd7 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; @@ -196,20 +194,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 000000000000..168bc8e838e2 --- /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/broker/consensus/ConsensusPrefetchingQueueTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/subscription/broker/consensus/ConsensusPrefetchingQueueTest.java index a58bba7df76e..9e92ec114fff 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 @@ 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()); @@ -3869,7 +3870,7 @@ private void assertPoisonedEventProgress( if (recycle) { CommonDescriptor.getInstance() .getConfig() - .setSubscriptionRecycleUncommittedEventIntervalMs(-1); + .setSubscriptionRecycleUncommittedEventIntervalMs(1); } final DataRegionId regionId = new DataRegionId(1); final FakeConsensusReqReader reader = new FakeConsensusReqReader(); @@ -3921,6 +3922,8 @@ private void assertPoisonedEventProgress( 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 @@ private void assertPoisonedEventProgress( 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 7dbc5b0b1888..84ed5f16c488 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; @@ -45,7 +46,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; @@ -173,7 +173,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()); @@ -307,11 +307,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]);