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/09/10 23:56:35 UTC

(pulsar) 13/18: [improve][ml] Share read-permit release callbacks within a batch (#26523)

This is an automated email from the ASF dual-hosted git repository.

lhotari pushed a commit to branch branch-4.2
in repository https://gitbox.apache.org/repos/asf/pulsar.git

commit 86f1e0ef441b1d46e804851ceaa1ee1324e1be8c
Author: Lari Hotari <lh...@users.noreply.github.com>
AuthorDate: Thu Sep 10 20:56:12 2026 +0300

    [improve][ml] Share read-permit release callbacks within a batch (#26523)
    
    (cherry picked from commit 30b975a6856e54647465eb97a37bdfdef74eab1a)
---
 .../mledger/impl/cache/RangeEntryCacheImpl.java    |  11 +-
 .../impl/cache/RangeEntryCacheImplTest.java        |  41 +++++++-
 .../impl/cache/ReadBatchCallbackBenchmark.java     | 114 +++++++++++++++++++++
 3 files changed, 160 insertions(+), 6 deletions(-)

diff --git a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImpl.java b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImpl.java
index 56fa9a93876d..2c1e9ee98d78 100644
--- a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImpl.java
+++ b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImpl.java
@@ -365,12 +365,13 @@ public class RangeEntryCacheImpl implements EntryCache {
                 if (!entries.isEmpty()) {
                     // release permits only when entries have been handled
                     AtomicInteger remainingCount = new AtomicInteger(entries.size());
+                    Runnable releasePermits = () -> {
+                        if (remainingCount.decrementAndGet() <= 0) {
+                            pendingReadsLimiter.release(handle);
+                        }
+                    };
                     for (Entry entry : entries) {
-                        ((EntryImpl) entry).onDeallocate(() -> {
-                            if (remainingCount.decrementAndGet() <= 0) {
-                                pendingReadsLimiter.release(handle);
-                            }
-                        });
+                        ((EntryImpl) entry).onDeallocate(releasePermits);
                     }
                 } else {
                     pendingReadsLimiter.release(handle);
diff --git a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImplTest.java b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImplTest.java
index 5ca6c7e21fd1..cd9f0cabc55b 100644
--- a/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImplTest.java
+++ b/managed-ledger/src/test/java/org/apache/bookkeeper/mledger/impl/cache/RangeEntryCacheImplTest.java
@@ -107,6 +107,45 @@ public class RangeEntryCacheImplTest {
         expectedReadCount = () -> 1;
     }
 
+    @Test
+    public void testReadPermitsReleasedOnlyAfterLastEntryReference() {
+        InflightReadsLimiter limiter = mockEntryCacheManager.getInflightReadsLimiter();
+        InflightReadsLimiter.Handle handle = new InflightReadsLimiter.Handle(300, 0, true);
+        CompletableFuture<List<Entry>> result = new CompletableFuture<>();
+        rangeEntryCache.doAsyncReadEntriesWithAcquiredPermits(lh,
+                PositionFactory.create(1, 0), PositionFactory.create(1, 2), 3, expectedReadCount,
+                new AsyncCallbacks.ReadEntriesCallback() {
+                    @Override
+                    public void readEntriesComplete(List<Entry> entries, Object ctx) {
+                        result.complete(entries);
+                    }
+
+                    @Override
+                    public void readEntriesFailed(ManagedLedgerException exception, Object ctx) {
+                        result.completeExceptionally(exception);
+                    }
+                }, null, handle, 300);
+        assertThat(result).isCompleted();
+        List<Entry> entries = result.getNow(null);
+        try {
+            assertThat(entries).hasSize(3);
+            ((ReferenceCountedEntry) entries.get(0)).retain();
+            entries.get(2).release();
+            entries.get(0).release();
+            entries.get(1).release();
+            verify(limiter, never()).release(any());
+            entries.get(0).release();
+            verify(limiter, times(1)).release(handle);
+        } finally {
+            for (Entry entry : entries) {
+                ReferenceCountedEntry referenceCountedEntry = (ReferenceCountedEntry) entry;
+                if (referenceCountedEntry.refCnt() > 0) {
+                    referenceCountedEntry.release(referenceCountedEntry.refCnt());
+                }
+            }
+        }
+    }
+
     private RangeEntryCacheImpl createRangeEntryCache(boolean copyEntries) {
         return new RangeEntryCacheImpl(mockEntryCacheManager, mockManagedLedger, copyEntries,
                 mockRangeCacheRemovalQueue, EntryLengthFunction.DEFAULT, pendingReadsManager);
@@ -528,4 +567,4 @@ public class RangeEntryCacheImplTest {
             }
         });
     }
-}
\ No newline at end of file
+}
diff --git a/microbench/src/main/java/org/apache/bookkeeper/mledger/impl/cache/ReadBatchCallbackBenchmark.java b/microbench/src/main/java/org/apache/bookkeeper/mledger/impl/cache/ReadBatchCallbackBenchmark.java
new file mode 100644
index 000000000000..a7a525d6e311
--- /dev/null
+++ b/microbench/src/main/java/org/apache/bookkeeper/mledger/impl/cache/ReadBatchCallbackBenchmark.java
@@ -0,0 +1,114 @@
+/*
+ * 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.bookkeeper.mledger.impl.cache;
+
+import io.opentelemetry.api.OpenTelemetry;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.apache.bookkeeper.mledger.impl.EntryImpl;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+
+/** Measures real entry-copy/release and read-permit accounting with per-entry or per-batch callbacks. */
+@State(Scope.Thread)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 5, time = 1)
+@Fork(2)
+public class ReadBatchCallbackBenchmark {
+    private static final long LIMIT_BYTES = 16 * 1024 * 1024;
+
+    @Param({"1", "100", "1000"})
+    public int batchSize;
+
+    @Param({"false", "true"})
+    public boolean sharedCallback;
+
+    private EntryImpl[] cachedEntries;
+    private EntryImpl[] readEntries;
+    private InflightReadsLimiter limiter;
+    private ScheduledExecutorService executor;
+
+    @Setup
+    public void setup() {
+        executor = Executors.newSingleThreadScheduledExecutor();
+        limiter = new InflightReadsLimiter(LIMIT_BYTES, 1, 0, executor, OpenTelemetry.noop());
+        cachedEntries = new EntryImpl[batchSize];
+        readEntries = new EntryImpl[batchSize];
+        for (int i = 0; i < batchSize; i++) {
+            cachedEntries[i] = EntryImpl.create(1, i, new byte[128]);
+            cachedEntries[i].getPosition();
+        }
+    }
+
+    @Benchmark
+    public long readAndReleaseBatch() {
+        InflightReadsLimiter batchLimiter = limiter;
+        InflightReadsLimiter.Handle handle = batchLimiter.acquire(batchSize * 128L, null).orElseThrow();
+        AtomicInteger remainingCount = new AtomicInteger(batchSize);
+        Runnable shared = sharedCallback ? releaseCallback(remainingCount, batchLimiter, handle) : null;
+        for (int i = 0; i < batchSize; i++) {
+            EntryImpl entry = EntryImpl.create(cachedEntries[i]);
+            entry.onDeallocate(sharedCallback ? shared : releaseCallback(remainingCount, batchLimiter, handle));
+            readEntries[i] = entry;
+        }
+        for (int i = batchSize - 1; i >= 0; i--) {
+            readEntries[i].release();
+            readEntries[i] = null;
+        }
+        return batchLimiter.getRemainingBytes();
+    }
+
+    private static Runnable releaseCallback(AtomicInteger remainingCount, InflightReadsLimiter limiter,
+                                            InflightReadsLimiter.Handle handle) {
+        return () -> {
+            if (remainingCount.decrementAndGet() <= 0) {
+                limiter.release(handle);
+            }
+        };
+    }
+
+    @TearDown
+    public void tearDown() {
+        try {
+            if (limiter.getRemainingBytes() != LIMIT_BYTES) {
+                throw new IllegalStateException("Read permits were not released exactly once per batch");
+            }
+        } finally {
+            for (EntryImpl entry : cachedEntries) {
+                entry.release();
+            }
+            limiter.close();
+            executor.shutdownNow();
+        }
+    }
+}