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