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