You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pulsar.apache.org by lh...@apache.org on 2026/10/17 08:38:23 UTC
(pulsar) branch master updated: [improve][broker] Skip the size cap estimate when there are no messages to replay (#26954)
This is an automated email from the ASF dual-hosted git repository.
lhotari pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pulsar.git
The following commit(s) were added to refs/heads/master by this push:
new 258b8fe4d4f7 [improve][broker] Skip the size cap estimate when there are no messages to replay (#26954)
258b8fe4d4f7 is described below
commit 258b8fe4d4f7d033f3399218c8f4ea513a10be70
Author: Lari Hotari <lh...@users.noreply.github.com>
AuthorDate: Sat Oct 17 01:38:14 2026 -0700
[improve][broker] Skip the size cap estimate when there are no messages to replay (#26954)
---
.../PersistentDispatcherMultipleConsumers.java | 8 +++-
...ntStickyKeyDispatcherMultipleConsumersTest.java | 55 ++++++++++++++++++++++
2 files changed, 62 insertions(+), 1 deletion(-)
diff --git a/pulsar-broker/src/main/java/org/apache/pulsar/broker/service/persistent/PersistentDispatcherMultipleConsumers.java b/pulsar-broker/src/main/java/org/apache/pulsar/broker/service/persistent/PersistentDispatcherMultipleConsumers.java
index 6c321fa4a0da..b2299308d0e8 100644
--- a/pulsar-broker/src/main/java/org/apache/pulsar/broker/service/persistent/PersistentDispatcherMultipleConsumers.java
+++ b/pulsar-broker/src/main/java/org/apache/pulsar/broker/service/persistent/PersistentDispatcherMultipleConsumers.java
@@ -1377,6 +1377,12 @@ public class PersistentDispatcherMultipleConsumers extends AbstractPersistentDis
}
protected synchronized NavigableSet<Position> getMessagesToReplayNow(int maxMessagesToRead, long bytesToRead) {
+ boolean delayedMessagesAvailable =
+ delayedDeliveryTracker.isPresent() && delayedDeliveryTracker.get().hasMessageAvailable();
+ if (!delayedMessagesAvailable && redeliveryMessages.isEmpty()) {
+ // nothing to replay, the common case: skip the size cap's estimate, which the normal read computes again
+ return Collections.emptyNavigableSet();
+ }
int cappedMaxMessagesToRead = cursor.applyMaxSizeCap(maxMessagesToRead, bytesToRead);
if (cappedMaxMessagesToRead < maxMessagesToRead) {
log.debug()
@@ -1384,7 +1390,7 @@ public class PersistentDispatcherMultipleConsumers extends AbstractPersistentDis
.attr("maxMessagesToRead", maxMessagesToRead)
.log("Capped max messages to read from redelivery list");
}
- if (delayedDeliveryTracker.isPresent() && delayedDeliveryTracker.get().hasMessageAvailable()) {
+ if (delayedMessagesAvailable) {
delayedDeliveryTracker.get().resetTickTime(topic.getDelayedDeliveryTickTimeMillis());
NavigableSet<Position> messagesAvailableNow =
delayedDeliveryTracker.get().getScheduledMessages(cappedMaxMessagesToRead);
diff --git a/pulsar-broker/src/test/java/org/apache/pulsar/broker/service/persistent/PersistentStickyKeyDispatcherMultipleConsumersTest.java b/pulsar-broker/src/test/java/org/apache/pulsar/broker/service/persistent/PersistentStickyKeyDispatcherMultipleConsumersTest.java
index 80ca02c4677e..b61ce0a34d09 100644
--- a/pulsar-broker/src/test/java/org/apache/pulsar/broker/service/persistent/PersistentStickyKeyDispatcherMultipleConsumersTest.java
+++ b/pulsar-broker/src/test/java/org/apache/pulsar/broker/service/persistent/PersistentStickyKeyDispatcherMultipleConsumersTest.java
@@ -27,6 +27,7 @@ import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.anyList;
import static org.mockito.Mockito.anyLong;
import static org.mockito.Mockito.anySet;
+import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
@@ -75,6 +76,8 @@ import org.apache.bookkeeper.mledger.impl.ManagedCursorImpl;
import org.apache.bookkeeper.mledger.impl.ManagedLedgerImpl;
import org.apache.pulsar.broker.PulsarService;
import org.apache.pulsar.broker.ServiceConfiguration;
+import org.apache.pulsar.broker.delayed.DelayedDeliveryTracker;
+import org.apache.pulsar.broker.delayed.DelayedDeliveryTrackerFactory;
import org.apache.pulsar.broker.service.BrokerService;
import org.apache.pulsar.broker.service.ConsistentHashingStickyKeyConsumerSelector;
import org.apache.pulsar.broker.service.Consumer;
@@ -627,6 +630,58 @@ public class PersistentStickyKeyDispatcherMultipleConsumersTest {
}
}
+ @Test(timeOut = 10000)
+ public void testGetMessagesToReplayNowSkipsSizeCapWithNothingToReplay() {
+ persistentDispatcher.addConsumer(consumerMock).join();
+ clearInvocations(cursorMock);
+ // nothing to replay: the size cap isn't estimated, the normal read estimates it
+ assertThat(persistentDispatcher.getMessagesToReplayNow(10, 1000)).isEmpty();
+ verify(cursorMock, never()).applyMaxSizeCap(anyInt(), anyLong());
+
+ String key = generateKeyForConsumer(persistentDispatcher.getSelector(), consumerMock);
+ EntryImpl entry = createEntry(1, 1, "message1", 1, key);
+ try {
+ entry.retain();
+ persistentDispatcher.addEntryToReplay(entry);
+ assertThat(persistentDispatcher.getMessagesToReplayNow(10, 1000)).containsExactly(entry.getPosition());
+ verify(cursorMock).applyMaxSizeCap(10, 1000);
+ } finally {
+ entry.release();
+ }
+ }
+
+ @Test(timeOut = 10000)
+ public void testGetMessagesToReplayNowChecksDelayedTrackerOnce() {
+ DelayedDeliveryTracker trackerMock = mock(DelayedDeliveryTracker.class);
+ DelayedDeliveryTrackerFactory trackerFactoryMock = mock(DelayedDeliveryTrackerFactory.class);
+ doReturn(trackerMock).when(trackerFactoryMock).newTracker(any());
+ doReturn(trackerFactoryMock).when(brokerMock).getDelayedDeliveryTrackerFactory();
+ doReturn(true).when(topicMock).isDelayedDeliveryEnabled();
+ doReturn(true).when(trackerMock).addMessage(anyLong(), anyLong(), anyLong());
+ persistentDispatcher.addConsumer(consumerMock).join();
+ assertTrue(persistentDispatcher.trackDelayedDelivery(1, 1,
+ new MessageMetadata().setDeliverAtTime(System.currentTimeMillis() + 60_000)));
+ clearInvocations(cursorMock);
+
+ // no delayed messages available: availability is checked once, the timer is kept, and the size cap isn't
+ // estimated
+ doReturn(false).when(trackerMock).hasMessageAvailable();
+ assertThat(persistentDispatcher.getMessagesToReplayNow(10, 1000)).isEmpty();
+ verify(trackerMock, times(1)).hasMessageAvailable();
+ verify(trackerMock, never()).getScheduledMessages(anyInt());
+ verify(cursorMock, never()).applyMaxSizeCap(anyInt(), anyLong());
+
+ // a delayed message is available: the size cap is estimated and bounds the scheduled messages
+ clearInvocations(trackerMock);
+ Position position = PositionFactory.create(1, 1);
+ doReturn(true).when(trackerMock).hasMessageAvailable();
+ doReturn(new TreeSet<>(List.of(position))).when(trackerMock).getScheduledMessages(anyInt());
+ assertThat(persistentDispatcher.getMessagesToReplayNow(10, 1000)).containsExactly(position);
+ verify(trackerMock, times(1)).hasMessageAvailable();
+ verify(cursorMock).applyMaxSizeCap(10, 1000);
+ verify(trackerMock).getScheduledMessages(10);
+ }
+
@Test(dataProvider = "allowOutOfOrderDelivery", timeOut = 10000)
public void testReplaySkipsUnwritableConsumerWithPermits(boolean allowOutOfOrderDelivery) {
persistentDispatcher.close();