This is an automated email from the ASF dual-hosted git repository. Caideyipi pushed a commit to branch codex/fix-parser-worker-admission in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 3d91b63fffee10ae756c414716a5fd5488d137a9 Author: Caideyipi <[email protected]> AuthorDate: Wed Nov 11 11:16:15 2026 +0800 [Pipe] Distribute parser admission across processor workers --- .../common/tsfile/PipeTsFileInsertionEvent.java | 6 +- .../db/pipe/resource/memory/PipeMemoryManager.java | 69 ++++++++++++++- .../processor/PipeProcessorSubtaskWorkerTest.java | 98 ++++++++++++++++++++++ .../resource/memory/PipeMemoryManagerTest.java | 64 ++++++++++++++ 4 files changed, 231 insertions(+), 6 deletions(-) diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/event/common/tsfile/PipeTsFileInsertionEvent.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/event/common/tsfile/PipeTsFileInsertionEvent.java index d26a9d31cf6..adc3e1d23fe 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/event/common/tsfile/PipeTsFileInsertionEvent.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/event/common/tsfile/PipeTsFileInsertionEvent.java @@ -1547,7 +1547,8 @@ public class PipeTsFileInsertionEvent extends PipeInsertionEvent synchronized (isTsFileParserMemoryReserved) { if (isTsFileParserMemoryReserved.compareAndSet(true, false)) { PipeDataNodeResourceManager.memory() - .releaseTsFileParserMemory(pipeName, creationTime, dataRegionId); + .releaseTsFileParserMemory( + pipeName, creationTime, dataRegionId, tsFileParserMemoryReservationKey); } } } @@ -1838,7 +1839,8 @@ public class PipeTsFileInsertionEvent extends PipeInsertionEvent synchronized (isTsFileParserMemoryReserved) { if (isTsFileParserMemoryReserved.compareAndSet(true, false)) { PipeDataNodeResourceManager.memory() - .releaseTsFileParserMemory(pipeName, creationTime, dataRegionId); + .releaseTsFileParserMemory( + pipeName, creationTime, dataRegionId, tsFileParserMemoryReservationKey); } } } catch (final Exception e) { diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManager.java index 34aa16d2796..16c9c366c92 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManager.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManager.java @@ -39,6 +39,7 @@ import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; +import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -79,6 +80,9 @@ public class PipeMemoryManager { private final Map<PipeIdentity, Integer> reservedTsFileParserCountByPipe = new HashMap<>(); private final Map<PipeRegionIdentity, Integer> reservedTsFileParserCountByPipeRegion = new HashMap<>(); + private final Map<PipeRegionIdentity, Map<TsFileParserMemoryReservation, Runnable>> + reservedTsFileParserWorkersByPipeRegion = new HashMap<>(); + private final Map<Runnable, Integer> reservedTsFileParserCountByWorker = new HashMap<>(); private final Map<PipeRegionIdentity, LinkedHashSet<TsFileParserMemoryReservation>> waitingTsFileParserRequestsByPipeRegion = new HashMap<>(); private final Map<PipeIdentity, ArrayDeque<PipeRegionIdentity>> @@ -261,8 +265,10 @@ public class PipeMemoryManager { 1, Math.min(globalLimit, PIPE_CONFIG.getPipeTsFileParserInFlightMaxNumPerPipeRegion())); final int reservedCountOfPipeRegion = reservedTsFileParserCountByPipeRegion.getOrDefault(pipeRegionIdentity, 0); + final Runnable worker = reservationKey.wakeUpCallback; if (reservedTsFileParserCount >= globalLimit - || reservedCountOfPipeRegion >= perPipeRegionLimit) { + || reservedCountOfPipeRegion >= perPipeRegionLimit + || (worker != null && reservedTsFileParserCountByWorker.containsKey(worker))) { PipeResourceMetrics.getInstance() .recordTsFileParserAdmissionReject(TsFileParserAdmissionRejectReason.CAP); notifyNextTsFileParserMemoryReservationInternal(); @@ -310,6 +316,12 @@ public class PipeMemoryManager { reservedTsFileParserCount++; reservedTsFileParserCountByPipe.merge(pipeIdentity, 1, Integer::sum); reservedTsFileParserCountByPipeRegion.put(pipeRegionIdentity, reservedCountOfPipeRegion + 1); + reservedTsFileParserWorkersByPipeRegion + .computeIfAbsent(pipeRegionIdentity, key -> new LinkedHashMap<>()) + .put(reservationKey, worker); + if (worker != null) { + reservedTsFileParserCountByWorker.merge(worker, 1, Integer::sum); + } notifyNextTsFileParserMemoryReservationInternal(); return true; } @@ -331,12 +343,23 @@ public class PipeMemoryManager { public synchronized void releaseTsFileParserMemory( final String pipeName, final long creationTime, final String dataRegionId) { + releaseTsFileParserMemory(pipeName, creationTime, dataRegionId, null); + } + + public synchronized void releaseTsFileParserMemory( + final String pipeName, + final long creationTime, + final String dataRegionId, + final TsFileParserMemoryReservation reservationKey) { final PipeIdentity pipeIdentity = new PipeIdentity(pipeName, creationTime); final PipeRegionIdentity pipeRegionIdentity = new PipeRegionIdentity(pipeIdentity, dataRegionId); final int reservedCountOfPipeRegion = reservedTsFileParserCountByPipeRegion.getOrDefault(pipeRegionIdentity, 0); - if (reservedCountOfPipeRegion <= 0) { + final Map<TsFileParserMemoryReservation, Runnable> workersOfPipeRegion = + reservedTsFileParserWorkersByPipeRegion.get(pipeRegionIdentity); + if (reservedCountOfPipeRegion <= 0 + || (reservationKey != null && !workersOfPipeRegion.containsKey(reservationKey))) { LOGGER.warn( DataNodePipeMessages .LOG_FAILED_TO_RELEASE_TSFILE_PARSER_MEMORY_FOR_PIPE_ARG_CREATION_TIME_ARG_IN_DATAREGION_ARG_BECAUSE_NO_RESERVATION_EXISTS_BB8321C0, @@ -346,6 +369,19 @@ public class PipeMemoryManager { return; } + final Runnable worker = + workersOfPipeRegion.remove( + reservationKey != null + ? reservationKey + : workersOfPipeRegion.keySet().iterator().next()); + if (workersOfPipeRegion.isEmpty()) { + reservedTsFileParserWorkersByPipeRegion.remove(pipeRegionIdentity); + } + if (worker != null) { + reservedTsFileParserCountByWorker.computeIfPresent( + worker, (key, count) -> count == 1 ? null : count - 1); + } + if (reservedCountOfPipeRegion == 1) { reservedTsFileParserCountByPipeRegion.remove(pipeRegionIdentity); } else { @@ -426,6 +462,7 @@ public class PipeMemoryManager { final List<TsFileParserMemoryReservation> eligibleRequests = new ArrayList<>(); final Map<PipeRegionIdentity, Integer> selectedRequestsByPipeRegion = new HashMap<>(); final Set<PipeIdentity> selectedPipes = new HashSet<>(); + final Set<Runnable> selectedWorkers = new HashSet<>(); PipeIdentity lastSelectedPipe = lastAdmittedWaitingTsFileParserPipe; // Expose one fair turn per available slot, instead of serializing all free slots behind a // single worker. Account for every earlier turn's memory even if its worker has not run yet. @@ -449,6 +486,7 @@ public class PipeMemoryManager { lastSelectedPipe, selectedRequestsByPipeRegion, selectedPipes, + selectedWorkers, true); final PipeRegionIdentity nextRegionWhenNoOtherPipeIsEligible = nextPipeRegion == null @@ -458,6 +496,7 @@ public class PipeMemoryManager { lastSelectedPipe, selectedRequestsByPipeRegion, selectedPipes, + selectedWorkers, false) : nextPipeRegion; if (nextRegionWhenNoOtherPipeIsEligible == null) { @@ -473,7 +512,11 @@ public class PipeMemoryManager { i--) { requests.next(); } - eligibleRequests.add(requests.next()); + final TsFileParserMemoryReservation request = requests.next(); + eligibleRequests.add(request); + if (request.wakeUpCallback != null) { + selectedWorkers.add(request.wakeUpCallback); + } selectedRequestsByPipeRegion.merge(nextRegionWhenNoOtherPipeIsEligible, 1, Integer::sum); selectedPipes.add(nextRegionWhenNoOtherPipeIsEligible.pipeIdentity); lastSelectedPipe = nextRegionWhenNoOtherPipeIsEligible.pipeIdentity; @@ -487,6 +530,7 @@ public class PipeMemoryManager { final PipeIdentity lastSelectedPipe, final Map<PipeRegionIdentity, Integer> selectedRequestsByPipeRegion, final Set<PipeIdentity> selectedPipes, + final Set<Runnable> selectedWorkers, final boolean requireUnselectedPipe) { PipeRegionIdentity firstEligiblePipeRegion = null; boolean hasVisitedLastAdmittedPipe = lastSelectedPipe == null; @@ -519,6 +563,20 @@ public class PipeMemoryManager { && reservedTsFileParserCountByPipeRegion.getOrDefault(pipeRegionIdentity, 0) + selectedCount < perPipeRegionLimit) { + final java.util.Iterator<TsFileParserMemoryReservation> requests = + waitingTsFileParserRequestsByPipeRegion.get(pipeRegionIdentity).iterator(); + for (int i = 0; i < selectedCount; i++) { + requests.next(); + } + final Runnable worker = requests.next().wakeUpCallback; + // A processor worker executes its subtasks serially. Leaving multiple fair turns for + // that worker strands free parser slots while other workers have runnable requests. + // Requests without a processor worker (for example subscriptions) remain independent. + if (worker != null + && (reservedTsFileParserCountByWorker.containsKey(worker) + || selectedWorkers.contains(worker))) { + continue; + } if (eligiblePipeRegion == null) { eligiblePipeRegion = pipeRegionIdentity; } @@ -599,7 +657,10 @@ public class PipeMemoryManager { // Accessed only under the PipeMemoryManager monitor while this request is queued. private long waitingStartTimeInNanos; - /** The callback must only wake the worker; it runs while the memory manager monitor is held. */ + /** + * The callback must only wake the worker; it runs while the memory manager monitor is held. + * Requests on the same serial processor worker must share the same callback instance. + */ public void setWakeUpCallback(final Runnable wakeUpCallback) { this.wakeUpCallback = wakeUpCallback; } diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/agent/task/subtask/processor/PipeProcessorSubtaskWorkerTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/agent/task/subtask/processor/PipeProcessorSubtaskWorkerTest.java index 501be89143c..5fd36c4af40 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/agent/task/subtask/processor/PipeProcessorSubtaskWorkerTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/agent/task/subtask/processor/PipeProcessorSubtaskWorkerTest.java @@ -69,6 +69,104 @@ public class PipeProcessorSubtaskWorkerTest { mock(PipeProcessorSubtask.class); } + @Test(timeout = 30000) + public void testRequestsOnOneWorkerDoNotStrandOtherWorkersParserSlots() throws Exception { + final CommonConfig config = CommonDescriptor.getInstance().getConfig(); + final PipeMemoryManager manager = PipeDataNodeResourceManager.memory(); + final long originalParserMemory = config.getPipeTsFileParserMemory(); + final int originalGlobalLimit = config.getPipeTsFileParserInFlightMaxNum(); + final int originalRegionLimit = config.getPipeTsFileParserInFlightMaxNumPerPipeRegion(); + final List<PipeProcessorSubtaskWorker> workers = new ArrayList<>(); + final List<TsFileParserMemoryReservation> requests = new ArrayList<>(); + final boolean[] reservedBlockers = new boolean[4]; + final CountDownLatch parsing = new CountDownLatch(4); + final CountDownLatch finishParsing = new CountDownLatch(1); + final ExecutorService executor = Executors.newFixedThreadPool(4); + try { + config.setPipeTsFileParserMemory(1); + config.setPipeTsFileParserInFlightMaxNum(4); + config.setPipeTsFileParserInFlightMaxNumPerPipeRegion(1); + for (int i = 0; i < 4; i++) { + reservedBlockers[i] = + manager.tryReserveTsFileParserMemory( + "blocker" + i, 0, "0", new TsFileParserMemoryReservation()); + Assert.assertTrue(reservedBlockers[i]); + workers.add(newWorker(new LinkedHashSet<>())); + } + // Queue four pipes on the same serial worker before the other workers' requests. A fair + // window based only on pipe order leaves all four free slots waiting for that one worker. + for (int i = 0; i < 7; i++) { + final String pipeName = "skewed" + i; + final TsFileParserMemoryReservation request = new TsFileParserMemoryReservation(); + requests.add(request); + final PipeProcessorSubtask subtask = createRunnableSubtask(pipeName); + final AtomicBoolean processed = new AtomicBoolean(); + when(subtask.isWaitingForTsFileParserMemory()) + .thenAnswer(ignored -> request.isWaitingForSignal()); + doAnswer( + invocation -> { + request.setWakeUpCallback(invocation.getArgument(0)); + return null; + }) + .when(subtask) + .setWorkerWakeUpCallback(any()); + when(subtask.call()) + .thenAnswer( + ignored -> { + if (processed.get()) { + return false; + } + if (!manager.tryReserveTsFileParserMemory(pipeName, 0, "0", request)) { + throw PipeProcessorSubtaskYieldException.parserNotAdmitted(); + } + try { + parsing.countDown(); + Assert.assertTrue(finishParsing.await(10, TimeUnit.SECONDS)); + processed.set(true); + return true; + } finally { + manager.releaseTsFileParserMemory(pipeName, 0, "0"); + } + }); + workers.get(i < 4 ? 0 : i - 3).schedule(subtask); + Assert.assertFalse(manager.tryReserveTsFileParserMemory(pipeName, 0, "0", request)); + } + for (int i = 0; i < 4; i++) { + manager.releaseTsFileParserMemory("blocker" + i, 0, "0"); + reservedBlockers[i] = false; + } + final List<Future<?>> rounds = new ArrayList<>(); + for (final PipeProcessorSubtaskWorker worker : workers) { + rounds.add(executor.submit(worker::runSubtasks)); + } + Assert.assertTrue( + "Free parser slots must run on distinct available workers", + parsing.await(5, TimeUnit.SECONDS)); + Assert.assertEquals(4, manager.getReservedTsFileParserCount()); + finishParsing.countDown(); + for (final Future<?> round : rounds) { + round.get(5, TimeUnit.SECONDS); + } + Assert.assertEquals(0, manager.getReservedTsFileParserCount()); + Assert.assertEquals(0, manager.getWaitingTsFileParserCount()); + } finally { + finishParsing.countDown(); + executor.shutdownNow(); + Assert.assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + for (int i = 0; i < requests.size(); i++) { + manager.cancelTsFileParserMemoryReservation("skewed" + i, 0, "0", requests.get(i)); + } + for (int i = 0; i < reservedBlockers.length; i++) { + if (reservedBlockers[i]) { + manager.releaseTsFileParserMemory("blocker" + i, 0, "0"); + } + } + config.setPipeTsFileParserMemory(originalParserMemory); + config.setPipeTsFileParserInFlightMaxNum(originalGlobalLimit); + config.setPipeTsFileParserInFlightMaxNumPerPipeRegion(originalRegionLimit); + } + } + @Test(timeout = 30000) public void testOneHundredWaitingPipesDoNotWaitForWorkerPolling() throws Exception { final CommonConfig config = CommonDescriptor.getInstance().getConfig(); diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManagerTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManagerTest.java index 0e352189b0d..1051fe80030 100644 --- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManagerTest.java +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/pipe/resource/memory/PipeMemoryManagerTest.java @@ -145,6 +145,70 @@ public class PipeMemoryManagerTest { Assert.assertEquals(96, memoryManager.getWaitingTsFileParserCount()); } + @Test + public void testReleasingParserOnlyFreesItsOwnWorker() { + commonConfig.setPipeTsFileParserInFlightMaxNum(4); + commonConfig.setPipeTsFileParserInFlightMaxNumPerPipeRegion(2); + final PipeMemoryManager manager = createTestMemoryManager(); + final Reservation firstWorker = new Reservation("pipe", 0); + final Reservation secondWorker = new Reservation("pipe", 0); + final Reservation waitingOnFirstWorker = new Reservation("otherPipe", 1); + final Reservation waitingOnSecondWorker = new Reservation("otherPipe", 2); + final Runnable firstWakeUp = new AtomicInteger()::incrementAndGet; + final Runnable secondWakeUp = new AtomicInteger()::incrementAndGet; + firstWorker.key.setWakeUpCallback(firstWakeUp); + waitingOnFirstWorker.key.setWakeUpCallback(firstWakeUp); + secondWorker.key.setWakeUpCallback(secondWakeUp); + waitingOnSecondWorker.key.setWakeUpCallback(secondWakeUp); + final List<Reservation> testReservations = + List.of(firstWorker, secondWorker, waitingOnFirstWorker, waitingOnSecondWorker); + try { + Assert.assertTrue(tryAcquire(manager, firstWorker)); + Assert.assertTrue(tryAcquire(manager, secondWorker)); + Assert.assertFalse(tryAcquire(manager, waitingOnFirstWorker)); + Assert.assertFalse(tryAcquire(manager, waitingOnSecondWorker)); + + // The two parsers share a pipe/region but finish in reverse order. Releasing the second + // reservation must wake only its worker, rather than freeing the first worker's slot. + manager.releaseTsFileParserMemory( + secondWorker.pipeName, + secondWorker.creationTime, + secondWorker.dataRegionId, + secondWorker.key); + secondWorker.acquired = false; + Assert.assertTrue(waitingOnFirstWorker.key.isWaitingForSignal()); + Assert.assertFalse(waitingOnSecondWorker.key.isWaitingForSignal()); + Assert.assertTrue(tryAcquire(manager, waitingOnSecondWorker)); + Assert.assertFalse(tryAcquire(manager, waitingOnFirstWorker)); + + manager.releaseTsFileParserMemory( + firstWorker.pipeName, + firstWorker.creationTime, + firstWorker.dataRegionId, + firstWorker.key); + firstWorker.acquired = false; + Assert.assertTrue(tryAcquire(manager, waitingOnFirstWorker)); + Assert.assertEquals(2, manager.getReservedTsFileParserCount()); + } finally { + for (final Reservation reservation : testReservations) { + manager.cancelTsFileParserMemoryReservation( + reservation.pipeName, + reservation.creationTime, + reservation.dataRegionId, + reservation.key); + if (reservation.acquired) { + manager.releaseTsFileParserMemory( + reservation.pipeName, + reservation.creationTime, + reservation.dataRegionId, + reservation.key); + } + } + } + Assert.assertEquals(0, manager.getReservedTsFileParserCount()); + Assert.assertEquals(0, manager.getWaitingTsFileParserCount()); + } + @Test public void testAdmissionWindowRespectsPipeFairnessAcrossRegions() { commonConfig.setPipeTsFileParserInFlightMaxNum(2);
