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

mattcasters pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/hop.git


The following commit(s) were added to refs/heads/main by this push:
     new 671f59fcb9 Lock-free row sets between transforms (experimental), fixes 
#9129 (#9142)
671f59fcb9 is described below

commit 671f59fcb97fda78d8d06ae3f523fd461d4124c3
Author: Hans Van Akelyen <[email protected]>
AuthorDate: Tue Nov 3 09:23:48 2026 +0100

    Lock-free row sets between transforms (experimental), fixes #9129 (#9142)
    
    * Create a lockfree rowset, fixes #9129
    
    * implement PR suggestions
    
    add PR suggestions
    
    * fix remark
---
 .../apache/hop/core/BlockingBatchingRowSet.java    | 184 -------
 core/src/main/java/org/apache/hop/core/Const.java  |   7 -
 .../src/main/java/org/apache/hop/core/IRowSet.java |  11 +
 .../java/org/apache/hop/core/LockFreeRowSet.java   | 598 +++++++++++++++++++++
 .../hop/core/BlockingBatchingRowSetTest.java       | 331 ------------
 .../org/apache/hop/core/LockFreeRowSetTest.java    | 396 ++++++++++++++
 .../native-local-pipeline-engine.adoc              |  11 +
 .../modules/ROOT/pages/variables.adoc              |   1 -
 .../java/org/apache/hop/pipeline/Pipeline.java     |  48 +-
 .../engines/local/LocalPipelineEngine.java         |   1 +
 .../local/LocalPipelineRunConfiguration.java       |  23 +-
 .../hop/pipeline/transform/BaseTransform.java      | 368 ++++++++++---
 .../LocalPipelineEngineLockFreeRowSetsTest.java    | 235 ++++++++
 integration-tests/samples/hop-config.json          |   4 -
 .../config/PipelineRunConfigurationEditor.java     |  33 ++
 .../config/messages/messages_en_US.properties      |   2 +
 web-tests/src/test/resources/hop-config.json       |   4 -
 17 files changed, 1622 insertions(+), 635 deletions(-)

diff --git a/core/src/main/java/org/apache/hop/core/BlockingBatchingRowSet.java 
b/core/src/main/java/org/apache/hop/core/BlockingBatchingRowSet.java
deleted file mode 100644
index a05807f80a..0000000000
--- a/core/src/main/java/org/apache/hop/core/BlockingBatchingRowSet.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * 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.hop.core;
-
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.TimeUnit;
-import org.apache.hop.core.row.IRowMeta;
-
-/**
- * Contains a buffer of rows. Instead of passing rows along the chain 
immediately we will batch them
- * up to lower locking overhead. The row set will start in accepting mode 
(accepting = true) It will
- * remain there until the buffer is full. Then it will switch to delivering 
mode (accepting = false)
- * It will remain there until the buffer is empty.
- *
- * <p>When the row set is done and no more rows will be entering the row set 
we will switch to
- * delivering mode.
- */
-public class BlockingBatchingRowSet extends BaseRowSet implements 
Comparable<IRowSet>, IRowSet {
-  private BlockingQueue<Object[][]> putArray;
-  private BlockingQueue<Object[][]> getArray;
-
-  private int putIndex;
-  private int getIndex;
-
-  private Object[][] inputBuffer;
-  private Object[][] outputBuffer;
-
-  private int size;
-
-  private final int BATCHSIZE = 2;
-
-  /**
-   * Create new non-blocking-queue with maxSize capacity.
-   *
-   * @param maxSize
-   */
-  public BlockingBatchingRowSet(int maxSize) {
-    super();
-
-    // create a fixed sized queue for max performance
-    //
-    putArray = new ArrayBlockingQueue<>(BATCHSIZE, false);
-    getArray = new ArrayBlockingQueue<>(BATCHSIZE, false);
-
-    size = maxSize / BATCHSIZE; // each buffer's size
-    Object[][] buffer;
-    for (int i = 0; i < BATCHSIZE; i++) {
-      buffer = new Object[size][];
-      putArray.offer(buffer);
-    }
-    outputBuffer = null;
-    putIndex = getIndex = size;
-  }
-
-  @Override
-  public boolean putRow(IRowMeta rowMeta, Object[] rowData) {
-
-    return putRowWait(rowMeta, rowData, Const.TIMEOUT_PUT_MILLIS, 
TimeUnit.MILLISECONDS);
-  }
-
-  /** We need to wait until */
-  @Override
-  public boolean putRowWait(IRowMeta rowMeta, Object[] rowData, long time, 
TimeUnit tu) {
-
-    this.rowMeta = rowMeta;
-
-    // If we're not accepting we block until we do
-    //
-    if (inputBuffer == null) {
-      try {
-        inputBuffer = putArray.poll(time, tu);
-      } catch (InterruptedException e) {
-        return false;
-      }
-      if (inputBuffer == null) {
-        return false;
-      }
-      putIndex = 0;
-    }
-    inputBuffer[putIndex++] = rowData;
-    if (putIndex == size) {
-      try {
-        getArray.offer(inputBuffer, time, tu);
-        inputBuffer = null;
-      } catch (InterruptedException e) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  // default getRow with wait time = 100ms
-  //
-  /*
-   * (non-Javadoc)
-   *
-   * @see org.apache.hop.core.RowSetInterface#getRow()
-   */
-  @Override
-  public Object[] getRow() {
-    return getRowWait(Const.TIMEOUT_GET_MILLIS, TimeUnit.MILLISECONDS);
-  }
-
-  /*
-   * (non-Javadoc)
-   *
-   * @see org.apache.hop.core.RowSetInterface#getRowImmediate()
-   */
-  @Override
-  public Object[] getRowImmediate() {
-
-    return getRow();
-  }
-
-  @Override
-  public Object[] getRowWait(long timeout, TimeUnit tu) {
-    if (outputBuffer == null) {
-      try {
-        outputBuffer = getArray.poll(timeout, tu);
-      } catch (InterruptedException e) {
-        return null;
-      }
-      if (outputBuffer == null) {
-        return null;
-      }
-      getIndex = 0;
-    }
-
-    Object[] row = outputBuffer[getIndex];
-    outputBuffer[getIndex++] = null; // prevent any hold-up to GC
-    if (getIndex == size) {
-      putArray.offer(outputBuffer);
-      outputBuffer = null;
-    }
-
-    return row;
-  }
-
-  @Override
-  public int size() {
-    // does BlockingQueue.size() grab a lock? If so, frequent call to this 
method
-    // may stress the locking system
-    return size - getIndex + size * getArray.size();
-  }
-
-  @Override
-  public void setDone() {
-    // Enqueue the last partial batch before marking done so concurrent 
consumers that observe
-    // isDone()==true cannot exit before the final rows are available (issue 
#7742).
-    if (putIndex > 0 && putIndex < size && inputBuffer != null) {
-      inputBuffer[putIndex] = null; // signal the end of buffer
-      for (int i = putIndex + 1; i < size; i++) {
-        inputBuffer[i] = null;
-      }
-      getArray.offer(inputBuffer);
-    }
-    putArray.clear();
-    super.setDone();
-  }
-
-  @Override
-  public void clear() {
-    putArray.clear();
-    getArray.clear();
-    done.set(false);
-  }
-}
diff --git a/core/src/main/java/org/apache/hop/core/Const.java 
b/core/src/main/java/org/apache/hop/core/Const.java
index 879a29c9cc..b39521670f 100644
--- a/core/src/main/java/org/apache/hop/core/Const.java
+++ b/core/src/main/java/org/apache/hop/core/Const.java
@@ -890,13 +890,6 @@ public class Const {
           "The name of the variable that optionally contains an alternative 
rowset put timeout (in ms). This only makes a difference for extremely short 
lived pipelines.")
   public static final String HOP_ROWSET_PUT_TIMEOUT = "HOP_ROWSET_PUT_TIMEOUT";
 
-  /** Set this variable to Y if you want to test a more efficient batching row 
set. (default = N) */
-  @Variable(
-      value = "N",
-      description =
-          "Set this variable to 'Y' if you want to test a more efficient 
batching row set.")
-  public static final String HOP_BATCHING_ROWSET = "HOP_BATCHING_ROWSET";
-
   /**
    * Set this variable to limit max number of files the Text File Output 
transform can have open at
    * one time.
diff --git a/core/src/main/java/org/apache/hop/core/IRowSet.java 
b/core/src/main/java/org/apache/hop/core/IRowSet.java
index d40aba75ef..60e297130c 100644
--- a/core/src/main/java/org/apache/hop/core/IRowSet.java
+++ b/core/src/main/java/org/apache/hop/core/IRowSet.java
@@ -131,6 +131,17 @@ public interface IRowSet {
    */
   boolean isBlocking();
 
+  /**
+   * Transforms sleep briefly around a nearly full or nearly empty row set to 
spare the lock of a
+   * lock-based buffer. That costs a {@link #size()} call per row. A row set 
that waits efficiently
+   * by itself returns false here, and transforms then skip both the size() 
call and the sleep.
+   *
+   * @return true if transforms should throttle around this row set (the 
default)
+   */
+  default boolean needsThrottling() {
+    return true;
+  }
+
   /** Clear this rowset: remove all rows and remove the "done" flag. */
   void clear();
 }
diff --git a/core/src/main/java/org/apache/hop/core/LockFreeRowSet.java 
b/core/src/main/java/org/apache/hop/core/LockFreeRowSet.java
new file mode 100644
index 0000000000..7f2017b24c
--- /dev/null
+++ b/core/src/main/java/org/apache/hop/core/LockFreeRowSet.java
@@ -0,0 +1,598 @@
+/*
+ * 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.hop.core;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.LockSupport;
+import org.apache.hop.core.row.IRowMeta;
+
+/**
+ * A row buffer without locks on the hot path: a bounded multi-producer / 
single-consumer ring (the
+ * design of JCTools' MpscArrayQueue).
+ *
+ * <ul>
+ *   <li>A slot that is not null holds a row, so there is no separate sequence 
array.
+ *   <li>The slot array is rounded up to a power of two, so an index maps to a 
slot with a mask. The
+ *       row set still holds at most the configured number of rows.
+ *   <li>Producers claim a slot with one compare-and-set on the producer 
index. They keep a cached
+ *       limit (consumer index + size) and only read the consumer index again 
when they reach it, so
+ *       a producer does not touch the consumer's cache line for every row.
+ *   <li>A row set is read by exactly one transform thread, so the consumer 
moves its index with a
+ *       plain release store. (Several producers are allowed: some transforms 
call putRow from
+ *       worker threads, e.g. LanguageModelChat.)
+ *   <li>The producer fields, the consumer fields and the parked-thread fields 
each sit on their own
+ *       cache line (padding through the superclasses below, which the JVM 
lays out first).
+ * </ul>
+ *
+ * <p>When the ring is full (or empty) the thread spins briefly, then parks. 
The other side only
+ * unparks it once a batch of rows (or free slots) is ready, a quarter of the 
size, or when the row
+ * set is done, claiming the parked thread so it is woken once. That lets a 
fast consumer process
+ * runs of rows instead of waking up for every row, which is what the per-row 
size() check and
+ * Thread.sleep in BaseTransform approximate for the lock-based row sets.
+ *
+ * <p>A thread parks for {@link LockFreeRowSetFields#MAX_PARK_NANOS} at first. 
While nothing changes
+ * it parks longer, up to {@link LockFreeRowSetFields#MAX_IDLE_PARK_NANOS}, so 
an idle transform
+ * costs little CPU. A reader in such a long park is woken by the next row 
instead of a batch, so a
+ * trickle of rows is not delayed either.
+ */
+public class LockFreeRowSet extends LockFreeRowSetPad5 implements 
Comparable<IRowSet>, IRowSet {
+  private static final VarHandle SLOT = 
MethodHandles.arrayElementVarHandle(Object[][].class);
+  private static final VarHandle PRODUCER_INDEX;
+  private static final VarHandle PRODUCER_LIMIT;
+  private static final VarHandle CONSUMER_INDEX;
+  private static final VarHandle PARKED_CONSUMER;
+  private static final VarHandle PARKED_PRODUCER;
+
+  static {
+    try {
+      MethodHandles.Lookup lookup = MethodHandles.lookup();
+      PRODUCER_INDEX =
+          lookup.findVarHandle(LockFreeRowSetProducerFields.class, 
"producerIndex", long.class);
+      PRODUCER_LIMIT =
+          lookup.findVarHandle(LockFreeRowSetProducerFields.class, 
"producerLimit", long.class);
+      CONSUMER_INDEX =
+          lookup.findVarHandle(LockFreeRowSetConsumerFields.class, 
"consumerIndex", long.class);
+      PARKED_CONSUMER =
+          lookup.findVarHandle(LockFreeRowSetParkedConsumer.class, 
"parkedConsumer", Thread.class);
+      PARKED_PRODUCER =
+          lookup.findVarHandle(LockFreeRowSetParkedProducer.class, 
"parkedProducer", Thread.class);
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  /**
+   * @param maxSize the number of rows the buffer holds
+   */
+  public LockFreeRowSet(int maxSize) {
+    super(maxSize);
+  }
+
+  // ---- ring 
----------------------------------------------------------------------------------
+
+  /**
+   * @return the claimed index, or -1 when the ring is full
+   */
+  private long offer(Object[] row) {
+    long limit = (long) PRODUCER_LIMIT.getAcquire(this);
+    long index;
+    do {
+      index = producerIndex;
+      if (index >= limit) {
+        limit = consumerIndex + maxRows;
+        if (index >= limit) {
+          return -1; // full
+        }
+        PRODUCER_LIMIT.setRelease(this, limit);
+      }
+    } while (!PRODUCER_INDEX.compareAndSet(this, index, index + 1));
+    SLOT.setRelease(slots, (int) (index & mask), row);
+    return index;
+  }
+
+  private Object[] poll() {
+    long index = consumerIndex;
+    int offset = (int) (index & mask);
+    Object[] row = (Object[]) SLOT.getAcquire(slots, offset);
+    if (row == null) {
+      if (index == producerIndex) {
+        return null; // empty
+      }
+      // a producer claimed this slot and is about to fill it
+      do {
+        Thread.onSpinWait();
+        row = (Object[]) SLOT.getAcquire(slots, offset);
+      } while (row == null);
+    }
+    slots[offset] = null;
+    CONSUMER_INDEX.setRelease(this, index + 1); // publishes the null above to 
producers
+    return row;
+  }
+
+  // ---- waiting 
-------------------------------------------------------------------------------
+
+  private static void wake(Thread thread) {
+    if (thread != null) {
+      LockSupport.unpark(thread);
+    }
+  }
+
+  /**
+   * Called by a producer after it added the row at {@code index}: wake a 
consumer in a short park
+   * once a batch is queued, and one in a long park at once. Every row reads 
whether a consumer is
+   * parked, a cache line the consumer only writes when it parks. Only every 
{@code wakeCheckMask +
+   * 1}th row counts the queued rows for a short park, so that wake-up is late 
by at most that many
+   * rows.
+   */
+  private void rowAdded(long index) {
+    Thread consumer = parkedConsumer;
+    if (consumer == null) {
+      return;
+    }
+    boolean anyRow = wakeOnAnyRow; // read after parkedConsumer, which the 
consumer writes last
+    if ((index & wakeCheckMask) != 0 && !anyRow) {
+      return;
+    }
+    // claim the parked thread first, so it is unparked once and not again for 
every row added
+    // before it gets to run
+    if ((anyRow || producerIndex - consumerIndex >= wakeBatch)
+        && PARKED_CONSUMER.compareAndSet(this, consumer, null)) {
+      LockSupport.unpark(consumer);
+    }
+  }
+
+  /** Called by the consumer after it took a row: wake a parked producer once 
a batch is free. */
+  private void rowTaken() {
+    if ((consumerIndex & wakeCheckMask) != 0) {
+      return;
+    }
+    // poll() moves the consumer index with a release store, which the read 
below may overtake.
+    // The fence orders them, so a producer that parks after this check sees 
the slots freed so
+    // far, and a producer that parked before it is seen here and woken once a 
batch is free.
+    VarHandle.fullFence();
+    Thread producer = parkedProducer;
+    if (producer != null
+        && maxRows - (producerIndex - consumerIndex) >= wakeBatch
+        && PARKED_PRODUCER.compareAndSet(this, producer, null)) {
+      LockSupport.unpark(producer);
+    }
+  }
+
+  @Override
+  public void setDone() {
+    super.setDone();
+    wake(parkedConsumer); // the last rows may never fill a batch
+  }
+
+  @Override
+  public boolean putRow(IRowMeta rowMeta, Object[] rowData) {
+    return putRowWait(rowMeta, rowData, timeoutPut, TimeUnit.MILLISECONDS);
+  }
+
+  @Override
+  public boolean putRowWait(IRowMeta rowMeta, Object[] rowData, long time, 
TimeUnit tu) {
+    if (this.rowMeta != rowMeta) {
+      this.rowMeta = rowMeta; // don't dirty this cache line for every row
+    }
+    if (rowData == null) {
+      return false; // same as ArrayBlockingQueue, which refuses null
+    }
+    long index = offer(rowData);
+    if (index >= 0) {
+      rowAdded(index);
+      return true;
+    }
+    for (int i = 0; i < SPINS; i++) {
+      Thread.onSpinWait();
+      index = offer(rowData);
+      if (index >= 0) {
+        rowAdded(index);
+        return true;
+      }
+    }
+    // elapsed-time comparison: RowProducer waits Long.MAX_VALUE days, where 
now + timeout overflows
+    long timeoutNanos = tu.toNanos(time);
+    long start = System.nanoTime();
+    Thread current = Thread.currentThread();
+    long parkNanos = producerParkNanos;
+    while (true) {
+      // Only one producer is announced and woken by the consumer. With 
several producers the
+      // others park briefly and check again by themselves.
+      boolean announced =
+          parkedProducer == current || PARKED_PRODUCER.compareAndSet(this, 
null, current);
+      index = offer(rowData); // re-check after announcing ourselves, so a 
wake-up is not lost
+      if (index >= 0) {
+        PARKED_PRODUCER.compareAndSet(this, current, null);
+        if (producerParkNanos != MAX_PARK_NANOS) {
+          producerParkNanos = MAX_PARK_NANOS; // the buffer moves again
+        }
+        rowAdded(index);
+        return true;
+      }
+      long remaining = timeoutNanos - (System.nanoTime() - start);
+      if (remaining <= 0 || Thread.interrupted()) {
+        PARKED_PRODUCER.compareAndSet(this, current, null);
+        if (announced) {
+          producerParkNanos = parkNanos; // the next call goes on backing off
+        }
+        return false;
+      }
+      if (parkTimedOut(this, Math.min(remaining, announced ? parkNanos : 
MAX_PARK_NANOS))
+          && announced) {
+        parkNanos = Math.min(parkNanos * 2, MAX_IDLE_PARK_NANOS);
+      }
+    }
+  }
+
+  @Override
+  public Object[] getRow() {
+    return getRowWait(timeoutGet, TimeUnit.MILLISECONDS);
+  }
+
+  @Override
+  public Object[] getRowImmediate() {
+    Object[] row = poll();
+    if (row != null) {
+      rowTaken();
+    }
+    return row;
+  }
+
+  @Override
+  public Object[] getRowWait(long timeout, TimeUnit tu) {
+    Object[] row = poll();
+    if (row != null) {
+      rowTaken();
+      return row;
+    }
+    for (int i = 0; i < SPINS; i++) {
+      Thread.onSpinWait();
+      row = poll();
+      if (row != null) {
+        rowTaken();
+        return row;
+      }
+    }
+    long timeoutNanos = tu.toNanos(timeout);
+    long start = System.nanoTime();
+    Thread current = Thread.currentThread();
+    long parkNanos = consumerParkNanos;
+    boolean deep = false;
+    while (true) {
+      // after a while without rows park longer, and then let the next row 
wake us
+      if (!deep && parkNanos > MAX_PARK_NANOS) {
+        deep = true;
+        wakeOnAnyRow = true;
+      }
+      parkedConsumer = current;
+      row = poll();
+      if (row != null) {
+        stopWaiting(deep);
+        if (consumerParkNanos != MAX_PARK_NANOS) {
+          consumerParkNanos = MAX_PARK_NANOS; // rows flow again
+        }
+        rowTaken();
+        return row;
+      }
+      if (isDone()) {
+        // the producer may have added a last row just before it set done
+        row = poll();
+        stopWaiting(deep);
+        if (row != null) {
+          rowTaken();
+        }
+        return row;
+      }
+      long remaining = timeoutNanos - (System.nanoTime() - start);
+      if (remaining <= 0 || Thread.interrupted()) {
+        stopWaiting(deep);
+        consumerParkNanos = parkNanos; // the next call goes on backing off
+        return null;
+      }
+      if (parkTimedOut(this, Math.min(remaining, parkNanos))) {
+        parkNanos = Math.min(parkNanos * 2, MAX_IDLE_PARK_NANOS);
+      }
+    }
+  }
+
+  private void stopWaiting(boolean deep) {
+    parkedConsumer = null;
+    if (deep) {
+      wakeOnAnyRow = false;
+    }
+  }
+
+  /**
+   * Waits, as the reader of all these row sets, until one of them has rows or 
is done: spins
+   * briefly, then parks until a {@link LockFreeRowSet} among them has a batch 
of rows ready or is
+   * done, at most {@code maxNanos}. A transform with several inputs cannot 
wait on one of them with
+   * {@link #getRowWait(long, TimeUnit)}: rows arriving on another one would 
not wake it.
+   *
+   * <p>A park longer than 1 ms is only used when every input is a {@link 
LockFreeRowSet}. The next
+   * row on any of them then wakes the reader, not a batch. Other row sets 
cannot wake it, so they
+   * are checked again every 1 ms.
+   *
+   * <p>An interrupt ends the wait and is cleared, as in {@link 
#getRowWait(long, TimeUnit)}:
+   * otherwise every later park would return at once and the caller would spin.
+   *
+   * @param rowSets the input row sets of the calling transform
+   * @param maxNanos the longest time to park; row sets of another type are 
only checked again then
+   * @return true if the park ran its full time without a wake-up: the caller 
may wait longer next
+   *     time. False when it returned early, also on a wake-up left over from 
earlier, so a busy
+   *     reader keeps its short parks and its batches.
+   */
+  public static boolean awaitAny(List<IRowSet> rowSets, long maxNanos) {
+    for (int i = 0; i < SPINS; i++) {
+      if (anyReady(rowSets)) {
+        return false;
+      }
+      Thread.onSpinWait();
+    }
+    if (Thread.interrupted()) {
+      return false;
+    }
+    Thread current = Thread.currentThread();
+    // a long park only when every input can wake us; other row sets are 
polled every 1 ms
+    boolean deep = maxNanos > MAX_PARK_NANOS;
+    for (IRowSet rowSet : rowSets) {
+      if (!(rowSet instanceof LockFreeRowSet)) {
+        deep = false;
+        maxNanos = MAX_PARK_NANOS;
+        break;
+      }
+    }
+    for (IRowSet rowSet : rowSets) {
+      if (rowSet instanceof LockFreeRowSet lockFree) {
+        if (deep) {
+          lockFree.wakeOnAnyRow = true;
+        }
+        lockFree.parkedConsumer = current;
+      }
+    }
+    // check again after announcing ourselves on every input, so a wake-up is 
not lost
+    boolean timedOut = false;
+    if (!anyReady(rowSets)) {
+      timedOut = parkTimedOut(rowSets, maxNanos);
+    }
+    for (IRowSet rowSet : rowSets) {
+      if (rowSet instanceof LockFreeRowSet lockFree) {
+        PARKED_CONSUMER.compareAndSet(lockFree, current, null);
+        if (deep) {
+          lockFree.wakeOnAnyRow = false;
+        }
+      }
+    }
+    return timedOut;
+  }
+
+  /**
+   * Parks at most {@code nanos}.
+   *
+   * @return true if the park ran its full time: nothing woke the thread, not 
even a wake-up left
+   *     over from earlier
+   */
+  private static boolean parkTimedOut(Object blocker, long nanos) {
+    long start = System.nanoTime();
+    LockSupport.parkNanos(blocker, nanos);
+    return System.nanoTime() - start >= nanos;
+  }
+
+  private static boolean anyReady(List<IRowSet> rowSets) {
+    for (IRowSet rowSet : rowSets) {
+      if (rowSet.size() > 0 || rowSet.isDone()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** The ring spins and parks by itself; the transform's per-row sleep only 
adds latency. */
+  @Override
+  public boolean needsThrottling() {
+    return false;
+  }
+
+  /**
+   * The exact number of rows in the row set at one moment during the call. 
The two indexes are read
+   * separately, so the consumer index is read again: only when it did not 
move in between do the
+   * two indexes belong to the same moment. (A row a producer has claimed but 
is still writing
+   * counts as in the row set.)
+   */
+  @Override
+  public int size() {
+    long after = consumerIndex;
+    while (true) {
+      long before = after;
+      long produced = producerIndex;
+      after = consumerIndex;
+      if (before == after) {
+        return (int) (produced - after);
+      }
+    }
+  }
+
+  /** Only called when no transform reads from this row set anymore (see 
Pipeline). */
+  @Override
+  public void clear() {
+    while (poll() != null) {
+      // drain
+    }
+    done.set(false);
+    wake(parkedProducer);
+  }
+}
+
+// ---- field layout: the JVM places superclass fields first, so these classes 
keep the hot fields
+// ---- of the producer, the consumer and the parked threads on separate 
128-byte cache lines.
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad0 extends BaseRowSet {
+  long p00, p01, p02, p03, p04, p05, p06, p07, p08, p09, p0a, p0b, p0c, p0d, 
p0e, p0f;
+}
+
+/** Read-only after construction. */
+abstract class LockFreeRowSetFields extends LockFreeRowSetPad0 {
+  static final int SPINS = 16;
+  static final long MAX_PARK_NANOS = TimeUnit.MILLISECONDS.toNanos(1);
+
+  /** The longest a thread parks once nothing has changed for a while. */
+  static final long MAX_IDLE_PARK_NANOS = TimeUnit.MILLISECONDS.toNanos(20);
+
+  /** The largest power of two an array can hold. */
+  static final int MAX_CAPACITY = 1 << 30;
+
+  /** The number of rows the row set holds: the configured size, not the 
rounded-up capacity. */
+  final int maxRows;
+
+  final int capacity;
+  final int mask;
+  final int wakeBatch;
+  final int wakeCheckMask;
+  final Object[][] slots;
+  final int timeoutPut;
+  final int timeoutGet;
+
+  LockFreeRowSetFields(int maxSize) {
+    maxRows = maxRows(maxSize);
+    capacity = capacity(maxRows);
+    mask = capacity - 1;
+    slots = new Object[capacity][];
+    // A quarter of the size measured best for rowset sizes from 8k to 128k 
rows.
+    wakeBatch = Math.max(1, maxRows / 4);
+    // look at the other side every 64th row, or every row when the wake batch 
is smaller
+    wakeCheckMask = Integer.highestOneBit(Math.min(64, wakeBatch)) - 1;
+    timeoutGet =
+        Const.toInt(System.getProperty(Const.HOP_ROWSET_GET_TIMEOUT), 
Const.TIMEOUT_GET_MILLIS);
+    timeoutPut =
+        Const.toInt(System.getProperty(Const.HOP_ROWSET_PUT_TIMEOUT), 
Const.TIMEOUT_PUT_MILLIS);
+  }
+
+  /** The configured size, at least 1 and at most {@link #MAX_CAPACITY}. */
+  static int maxRows(int maxSize) {
+    // a larger size would overflow the rounded-up capacity
+    return Math.clamp(maxSize, 1, MAX_CAPACITY);
+  }
+
+  /** The power of two at or above {@code maxRows}, at least 2. */
+  static int capacity(int maxRows) {
+    return Integer.highestOneBit(Math.max(2, maxRows) - 1) << 1;
+  }
+}
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad1 extends LockFreeRowSetFields {
+  long p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p1a, p1b, p1c, p1d, 
p1e, p1f;
+
+  LockFreeRowSetPad1(int maxSize) {
+    super(maxSize);
+  }
+}
+
+/** Written by producers. */
+abstract class LockFreeRowSetProducerFields extends LockFreeRowSetPad1 {
+  volatile long producerIndex;
+
+  /**
+   * Cache of consumerIndex + maxRows. A stale value is never too large, so it 
only costs a re-read.
+   * Several producers write it, so it is only accessed through a VarHandle: a 
plain long may be
+   * written in two halves (JLS 17.7), and a value mixed from two writes can 
be too large. The
+   * release store and acquire load also pass on what the producer that read 
consumerIndex saw: the
+   * consumer clears a slot before it moves consumerIndex, so a producer that 
only reads this limit
+   * still sees the slot cleared before it writes a row into it.
+   */
+  long producerLimit;
+
+  LockFreeRowSetProducerFields(int maxSize) {
+    super(maxSize);
+  }
+}
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad2 extends LockFreeRowSetProducerFields {
+  long p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p2a, p2b, p2c, p2d, 
p2e, p2f;
+
+  LockFreeRowSetPad2(int maxSize) {
+    super(maxSize);
+  }
+}
+
+/** Written by the consumer. */
+abstract class LockFreeRowSetConsumerFields extends LockFreeRowSetPad2 {
+  volatile long consumerIndex;
+
+  LockFreeRowSetConsumerFields(int maxSize) {
+    super(maxSize);
+  }
+}
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad3 extends LockFreeRowSetConsumerFields {
+  long p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p3a, p3b, p3c, p3d, 
p3e, p3f;
+
+  LockFreeRowSetPad3(int maxSize) {
+    super(maxSize);
+  }
+}
+
+/** Written by the consumer when it parks, read by producers for every row. */
+abstract class LockFreeRowSetParkedConsumer extends LockFreeRowSetPad3 {
+  volatile Thread parkedConsumer;
+
+  /** Set during a long park: the next row wakes the consumer, not a batch. */
+  volatile boolean wakeOnAnyRow;
+
+  /** How long getRowWait parks next; only the consumer uses it. */
+  long consumerParkNanos = MAX_PARK_NANOS;
+
+  LockFreeRowSetParkedConsumer(int maxSize) {
+    super(maxSize);
+  }
+}
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad4 extends LockFreeRowSetParkedConsumer {
+  long p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p4a, p4b, p4c, p4d, 
p4e, p4f;
+
+  LockFreeRowSetPad4(int maxSize) {
+    super(maxSize);
+  }
+}
+
+/** Written by a producer when it parks, read by the consumer on every wake 
check. */
+abstract class LockFreeRowSetParkedProducer extends LockFreeRowSetPad4 {
+  volatile Thread parkedProducer;
+
+  /** How long the announced producer parks next. Only a hint, so a plain 
field is enough. */
+  long producerParkNanos = MAX_PARK_NANOS;
+
+  LockFreeRowSetParkedProducer(int maxSize) {
+    super(maxSize);
+  }
+}
+
+@SuppressWarnings("unused")
+abstract class LockFreeRowSetPad5 extends LockFreeRowSetParkedProducer {
+  long p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p5a, p5b, p5c, p5d, 
p5e, p5f;
+
+  LockFreeRowSetPad5(int maxSize) {
+    super(maxSize);
+  }
+}
diff --git 
a/core/src/test/java/org/apache/hop/core/BlockingBatchingRowSetTest.java 
b/core/src/test/java/org/apache/hop/core/BlockingBatchingRowSetTest.java
deleted file mode 100644
index e632c544ae..0000000000
--- a/core/src/test/java/org/apache/hop/core/BlockingBatchingRowSetTest.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * 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.hop.core;
-
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-import org.apache.hop.core.row.IRowMeta;
-import org.apache.hop.core.row.IValueMeta;
-import org.apache.hop.core.row.RowMeta;
-import org.apache.hop.core.row.value.ValueMetaInteger;
-import org.apache.hop.junit.rules.RestoreHopEnvironmentExtension;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-
-/** Test class for the basic functionality of the blocking & batching row set. 
*/
-@ExtendWith(RestoreHopEnvironmentExtension.class)
-class BlockingBatchingRowSetTest {
-
-  public IRowMeta createRowMetaInterface() {
-    IRowMeta rm = new RowMeta();
-
-    IValueMeta[] valuesMeta = {
-      new ValueMetaInteger("ROWNR"),
-    };
-
-    for (IValueMeta iValueMeta : valuesMeta) {
-      rm.addValueMeta(iValueMeta);
-    }
-
-    return rm;
-  }
-
-  /** The basic stuff. */
-  @Test
-  void testBasicCreation() {
-    IRowSet set = new BlockingBatchingRowSet(10);
-
-    assertFalse(set.isDone());
-    assertEquals(0, set.size());
-  }
-
-  /** Functionality test. */
-  @Test
-  void testFunctionality1() {
-    BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-
-    IRowMeta rm = createRowMetaInterface();
-
-    List<Object[]> rows = new ArrayList<>();
-    for (int i = 0; i < 5; i++) {
-      rows.add(
-          new Object[] {
-            (long) i,
-          });
-    }
-
-    assertEquals(0, set.size());
-
-    // Pop off row. This should return null (no row available: has a timeout)
-    //
-    Object[] r = set.getRow();
-    assertNull(r);
-
-    // Add rows. set doesn't report rows, batches them
-    // this batching row set has 2 buffers with 2 rows, the 5th row will cause 
the rows to be
-    // exposed.
-    //
-    int index = 0;
-    while (index < 4) {
-      set.putRow(rm, rows.get(index++));
-      assertEquals(0, set.size());
-    }
-    set.putRow(rm, rows.get(index));
-    assertEquals(5, set.size());
-
-    // Signal done...
-    //
-    set.setDone();
-    assertTrue(set.isDone());
-
-    // Get a row back...
-    //
-    r = set.getRow();
-    assertNotNull(r);
-    assertArrayEquals(rows.get(0), r);
-
-    // Get a row back...
-    //
-    r = set.getRow();
-    assertNotNull(r);
-    assertArrayEquals(rows.get(1), r);
-
-    // Get a row back...
-    //
-    r = set.getRow();
-    assertNotNull(r);
-    assertArrayEquals(rows.get(2), r);
-  }
-
-  /**
-   * Issue #7742: the last partial batch must be enqueued before the done flag 
is set, otherwise a
-   * concurrent consumer can observe isDone() and exit before the last rows 
are available.
-   */
-  @Test
-  void testSetDoneEnqueuesPartialBatchBeforeDoneFlag() throws Exception {
-    BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-    IRowMeta rm = createRowMetaInterface();
-
-    // 3 rows with buffer size 5 = partial batch (not flushed by putRow)
-    for (int i = 0; i < 3; i++) {
-      assertTrue(set.putRow(rm, new Object[] {(long) i}));
-    }
-    assertEquals(0, set.size());
-
-    AtomicBoolean offerSeen = new AtomicBoolean(false);
-    AtomicBoolean doneAtOffer = new AtomicBoolean(true); // fail closed if 
offer never checked
-    instrumentGetArrayOffers(
-        set,
-        () -> {
-          offerSeen.set(true);
-          doneAtOffer.set(set.isDone());
-        });
-
-    set.setDone();
-
-    assertTrue(offerSeen.get(), "partial batch must be offered in setDone()");
-    assertFalse(
-        doneAtOffer.get(),
-        "done flag must not be set before the last batch is offered (issue 
#7742)");
-    assertTrue(set.isDone());
-  }
-
-  /** When there is nothing left to flush, setDone() should only mark the 
rowset done. */
-  @Test
-  void testSetDoneWithNoPartialBatchOnlyMarksDone() throws Exception {
-    BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-    AtomicBoolean offerSeen = new AtomicBoolean(false);
-    instrumentGetArrayOffers(set, () -> offerSeen.set(true));
-
-    set.setDone();
-
-    assertFalse(offerSeen.get(), "no batch should be offered when nothing was 
put");
-    assertTrue(set.isDone());
-  }
-
-  /**
-   * When the last put already filled and published a full batch, setDone() 
must not re-offer; only
-   * the done flag is set.
-   */
-  @Test
-  void testSetDoneAfterFullBatchOnlyMarksDone() throws Exception {
-    BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-    IRowMeta rm = createRowMetaInterface();
-
-    // Exactly one full batch (size = maxSize / BATCHSIZE = 5)
-    for (int i = 0; i < 5; i++) {
-      assertTrue(set.putRow(rm, new Object[] {(long) i}));
-    }
-    assertEquals(5, set.size());
-
-    AtomicBoolean offerSeen = new AtomicBoolean(false);
-    instrumentGetArrayOffers(set, () -> offerSeen.set(true));
-
-    set.setDone();
-
-    assertFalse(offerSeen.get(), "full batch was already published; setDone 
must not re-offer");
-    assertTrue(set.isDone());
-  }
-
-  /**
-   * After setDone() with a partial batch, all non-null rows must be readable 
(sequential drain).
-   */
-  @Test
-  void testPartialBatchDrainableAfterSetDone() {
-    BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-    IRowMeta rm = createRowMetaInterface();
-    final int rowCount = 3;
-
-    for (int i = 0; i < rowCount; i++) {
-      assertTrue(set.putRow(rm, new Object[] {(long) i}));
-    }
-
-    set.setDone();
-    assertTrue(set.isDone());
-
-    List<Object[]> received = drainNonNullRows(set);
-    assertEquals(rowCount, received.size());
-    for (int i = 0; i < rowCount; i++) {
-      assertArrayEquals(new Object[] {(long) i}, received.get(i));
-    }
-  }
-
-  /**
-   * Concurrent producer/consumer using the same done-check pattern as 
BaseTransform.getRow().
-   * Partial batches must never be lost across repeated runs (issue #7742).
-   */
-  @Test
-  void testNoDataLossOnConcurrentSetDone() throws Exception {
-    final int iterations = 200;
-    final int rowCount = 3;
-    IRowMeta rm = createRowMetaInterface();
-
-    for (int iter = 0; iter < iterations; iter++) {
-      BlockingBatchingRowSet set = new BlockingBatchingRowSet(10);
-      List<Object[]> received = Collections.synchronizedList(new 
ArrayList<>());
-      CountDownLatch consumerStarted = new CountDownLatch(1);
-      AtomicReference<Throwable> consumerError = new AtomicReference<>();
-
-      Thread consumer =
-          new Thread(
-              () -> {
-                try {
-                  consumerStarted.countDown();
-                  // Mirrors BaseTransform handling when getRowWait returns 
null
-                  while (true) {
-                    Object[] row = set.getRowWait(20, TimeUnit.MILLISECONDS);
-                    if (row != null) {
-                      received.add(row);
-                    } else if (set.isDone()) {
-                      row = set.getRowWait(1, TimeUnit.MILLISECONDS);
-                      if (row == null) {
-                        break;
-                      }
-                      received.add(row);
-                    }
-                  }
-                } catch (Throwable t) {
-                  consumerError.set(t);
-                }
-              },
-              "batching-rowset-consumer-" + iter);
-
-      consumer.start();
-      assertTrue(consumerStarted.await(5, TimeUnit.SECONDS));
-
-      for (int i = 0; i < rowCount; i++) {
-        assertTrue(set.putRow(rm, new Object[] {(long) i}));
-      }
-      set.setDone();
-
-      consumer.join(10_000);
-      assertFalse(consumer.isAlive(), "consumer did not finish at iteration " 
+ iter);
-      assertNull(consumerError.get(), () -> "consumer failed: " + 
consumerError.get());
-      assertEquals(
-          rowCount,
-          received.size(),
-          "data loss at iteration " + iter + ", got " + received.size() + " 
rows");
-      for (int i = 0; i < rowCount; i++) {
-        assertArrayEquals(new Object[] {(long) i}, received.get(i));
-      }
-    }
-  }
-
-  /**
-   * Replace getArray with a queue that invokes {@code onOffer} for every 
subsequent offer. Existing
-   * batches are preserved without firing the callback.
-   */
-  private static void instrumentGetArrayOffers(BlockingBatchingRowSet set, 
Runnable onOffer)
-      throws Exception {
-    Field getArrayField = 
BlockingBatchingRowSet.class.getDeclaredField("getArray");
-    getArrayField.setAccessible(true);
-    @SuppressWarnings("unchecked")
-    BlockingQueue<Object[][]> originalGetArray = (BlockingQueue<Object[][]>) 
getArrayField.get(set);
-
-    AtomicBoolean logOffers = new AtomicBoolean(false);
-    BlockingQueue<Object[][]> loggingGetArray =
-        new ArrayBlockingQueue<>(Math.max(2, originalGetArray.size() + 2), 
true) {
-          @Override
-          public boolean offer(Object[][] e) {
-            if (logOffers.get()) {
-              onOffer.run();
-            }
-            return super.offer(e);
-          }
-
-          @Override
-          public boolean offer(Object[][] e, long timeout, TimeUnit unit)
-              throws InterruptedException {
-            if (logOffers.get()) {
-              onOffer.run();
-            }
-            return super.offer(e, timeout, unit);
-          }
-        };
-    // Preserve any batches already published (drainTo uses offer; logging 
still off)
-    originalGetArray.drainTo(loggingGetArray);
-    getArrayField.set(set, loggingGetArray);
-    logOffers.set(true);
-  }
-
-  private static List<Object[]> drainNonNullRows(BlockingBatchingRowSet set) {
-    List<Object[]> received = new ArrayList<>();
-    Object[] row;
-    // Partial batches pad with null sentinels; stop after the first null once 
we have started
-    // seeing data, but keep polling while empty before setDone flush 
visibility in sequential use.
-    while ((row = set.getRowWait(100, TimeUnit.MILLISECONDS)) != null) {
-      received.add(row);
-    }
-    return received;
-  }
-}
diff --git a/core/src/test/java/org/apache/hop/core/LockFreeRowSetTest.java 
b/core/src/test/java/org/apache/hop/core/LockFreeRowSetTest.java
new file mode 100644
index 0000000000..78a8e243b9
--- /dev/null
+++ b/core/src/test/java/org/apache/hop/core/LockFreeRowSetTest.java
@@ -0,0 +1,396 @@
+/*
+ * 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.hop.core;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.LockSupport;
+import org.apache.hop.core.row.RowMeta;
+import org.junit.jupiter.api.Test;
+
+class LockFreeRowSetTest {
+
+  @Test
+  void keepsOrderAndReportsSize() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(4);
+    Object[] a = {1L};
+    Object[] b = {2L};
+    assertTrue(rowSet.putRow(new RowMeta(), a));
+    assertTrue(rowSet.putRow(new RowMeta(), b));
+    assertEquals(2, rowSet.size());
+    assertSame(a, rowSet.getRowImmediate());
+    assertSame(b, rowSet.getRow());
+    assertEquals(0, rowSet.size());
+    assertNull(rowSet.getRowImmediate());
+  }
+
+  @Test
+  void timesOutWhenFullOrEmpty() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(2);
+    assertTrue(rowSet.putRowWait(new RowMeta(), new Object[] {1}, 10, 
TimeUnit.MILLISECONDS));
+    assertTrue(rowSet.putRowWait(new RowMeta(), new Object[] {2}, 10, 
TimeUnit.MILLISECONDS));
+    assertFalse(rowSet.putRowWait(new RowMeta(), new Object[] {3}, 10, 
TimeUnit.MILLISECONDS));
+    assertEquals(2, rowSet.size());
+    rowSet.clear();
+    assertEquals(0, rowSet.size());
+    assertNull(rowSet.getRowWait(10, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  void holdsTheConfiguredNumberOfRowsNotTheRoundedUpCapacity() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(10); // 16 slots
+    for (int i = 0; i < 10; i++) {
+      assertTrue(rowSet.putRowWait(new RowMeta(), new Object[] {i}, 0, 
TimeUnit.MILLISECONDS));
+    }
+    assertFalse(rowSet.putRowWait(new RowMeta(), new Object[] {10}, 0, 
TimeUnit.MILLISECONDS));
+    assertEquals(10, rowSet.size());
+    for (int i = 0; i < 10; i++) {
+      assertEquals(i, rowSet.getRowImmediate()[0]);
+      assertTrue(rowSet.putRowWait(new RowMeta(), new Object[] {10 + i}, 0, 
TimeUnit.MILLISECONDS));
+      assertEquals(10, rowSet.size());
+    }
+  }
+
+  @Test
+  void reportsTheExactNumberOfRowsWhileRowsMove() throws Exception {
+    // the writer and the reader move in step, so the row set always holds 100 
to 102 rows
+    int keep = 100;
+    LockFreeRowSet rowSet = new LockFreeRowSet(1000);
+    AtomicLong put = new AtomicLong();
+    AtomicLong taken = new AtomicLong();
+    AtomicBoolean stop = new AtomicBoolean();
+    AtomicBoolean rowMissing = new AtomicBoolean();
+    Thread writer =
+        new Thread(
+            () -> {
+              for (long i = 0; !stop.get(); i++) {
+                while (taken.get() < i - keep - 1) {
+                  if (stop.get()) {
+                    return;
+                  }
+                  Thread.yield();
+                }
+                rowSet.putRow(new RowMeta(), new Object[] {i});
+                put.set(i + 1);
+              }
+            });
+    Thread reader =
+        new Thread(
+            () -> {
+              for (long i = 0; !stop.get(); i++) {
+                while (put.get() < i + keep + 1) {
+                  if (stop.get()) {
+                    return;
+                  }
+                  Thread.yield();
+                }
+                if (rowSet.getRowImmediate() == null) {
+                  rowMissing.set(true);
+                }
+                taken.set(i + 1);
+              }
+            });
+    writer.start();
+    reader.start();
+    try {
+      while (put.get() <= keep) {
+        Thread.yield();
+      }
+      long end = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(300);
+      int checks = 0;
+      while (System.nanoTime() < end) {
+        int size = rowSet.size();
+        assertTrue(size >= keep && size <= keep + 2, "size " + size + " after 
" + checks);
+        checks++;
+      }
+    } finally {
+      stop.set(true);
+      writer.join(10_000);
+      reader.join(10_000);
+    }
+    assertFalse(rowMissing.get());
+    assertTrue(taken.get() > 0, "no rows moved");
+  }
+
+  @Test
+  void aReaderInAShortParkIsWokenByABatchOnly() {
+    // 64 rows: a wake batch of 16
+    LockFreeRowSet rowSet = new LockFreeRowSet(64);
+    Thread reader = new Thread(() -> {});
+    rowSet.parkedConsumer = reader;
+    for (int i = 0; i < 15; i++) {
+      rowSet.putRow(new RowMeta(), new Object[] {i});
+    }
+    assertSame(reader, rowSet.parkedConsumer, "woken before a batch was 
queued");
+    for (int i = 15; i < 17; i++) {
+      rowSet.putRow(new RowMeta(), new Object[] {i});
+    }
+    assertNull(rowSet.parkedConsumer, "not woken once a batch was queued");
+  }
+
+  @Test
+  void aReaderInALongParkIsWokenByTheNextRow() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(64);
+    rowSet.putRow(new RowMeta(), new Object[] {0}); // the next row is not one 
the producer checks
+    Thread reader = new Thread(() -> {});
+    rowSet.wakeOnAnyRow = true;
+    rowSet.parkedConsumer = reader;
+    rowSet.putRow(new RowMeta(), new Object[] {1});
+    assertNull(rowSet.parkedConsumer, "not woken by a single row");
+  }
+
+  @Test
+  void aParkedWriterIsWokenOnceABatchIsFree() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(64);
+    for (int i = 0; i < 64; i++) {
+      rowSet.putRow(new RowMeta(), new Object[] {i});
+    }
+    Thread writer = new Thread(() -> {});
+    rowSet.parkedProducer = writer;
+    for (int i = 0; i < 15; i++) {
+      rowSet.getRowImmediate();
+    }
+    assertSame(writer, rowSet.parkedProducer, "woken before a batch was free");
+    rowSet.getRowImmediate();
+    assertNull(rowSet.parkedProducer, "not woken once a batch was free");
+  }
+
+  @Test
+  void anIdleReaderBacksOffAndIsWokenByASingleRow() throws Exception {
+    LockFreeRowSet rowSet = new LockFreeRowSet(10_000);
+    // a reader that found nothing goes on with longer parks
+    assertNull(rowSet.getRowWait(30, TimeUnit.MILLISECONDS));
+    assertTrue(rowSet.consumerParkNanos > LockFreeRowSetFields.MAX_PARK_NANOS);
+    assertFalse(rowSet.wakeOnAnyRow);
+    assertNull(rowSet.parkedConsumer);
+
+    Object[][] received = new Object[1][];
+    Thread reader = new Thread(() -> received[0] = rowSet.getRowWait(10, 
TimeUnit.SECONDS));
+    reader.start();
+    long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+    while (!rowSet.wakeOnAnyRow && System.nanoTime() < deadline) {
+      Thread.sleep(1);
+    }
+    assertTrue(rowSet.wakeOnAnyRow, "the reader never parked long");
+    Object[] row = {1};
+    rowSet.putRow(new RowMeta(), row);
+    reader.join(5_000);
+    assertSame(row, received[0]);
+    // rows flow again: back to short parks woken by batches
+    assertEquals(LockFreeRowSetFields.MAX_PARK_NANOS, 
rowSet.consumerParkNanos);
+    assertFalse(rowSet.wakeOnAnyRow);
+    assertNull(rowSet.parkedConsumer);
+  }
+
+  @Test
+  void awaitAnyOnlyReportsAParkThatRanItsFullTime() {
+    LockFreeRowSet empty = new LockFreeRowSet(8);
+    LockFreeRowSet withRow = new LockFreeRowSet(8);
+    withRow.putRow(new RowMeta(), new Object[] {1});
+    LockSupport.parkNanos(1); // use up a wake-up an earlier test may have 
left on this thread
+
+    assertTrue(LockFreeRowSet.awaitAny(List.of(empty), 
TimeUnit.MILLISECONDS.toNanos(5)));
+    assertFalse(LockFreeRowSet.awaitAny(List.of(empty, withRow), 
TimeUnit.SECONDS.toNanos(10)));
+    // a wake-up left over from earlier ends the park at once: that is no 
reason to wait longer
+    LockSupport.unpark(Thread.currentThread());
+    assertFalse(LockFreeRowSet.awaitAny(List.of(empty), 
TimeUnit.SECONDS.toNanos(10)));
+  }
+
+  @Test
+  void anInterruptEndsAwaitAnyAndIsCleared() {
+    // otherwise every later park returns at once and the transform spins on a 
full core
+    LockFreeRowSet rowSet = new LockFreeRowSet(8);
+    Thread.currentThread().interrupt();
+    long start = System.nanoTime();
+    LockFreeRowSet.awaitAny(List.of(rowSet), TimeUnit.SECONDS.toNanos(10));
+    assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 
1000);
+    assertFalse(Thread.interrupted());
+    assertNull(rowSet.parkedConsumer);
+  }
+
+  @Test
+  void rowsPutBeforeDoneAreStillReadable() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(8);
+    rowSet.putRow(new RowMeta(), new Object[] {1});
+    rowSet.setDone();
+    assertTrue(rowSet.isDone());
+    assertEquals(1, rowSet.size());
+    assertEquals(1, rowSet.getRowImmediate()[0]);
+  }
+
+  @Test
+  void aReaderOfAnEmptyDoneRowSetDoesNotWaitForTheTimeout() {
+    LockFreeRowSet rowSet = new LockFreeRowSet(8);
+    rowSet.putRow(new RowMeta(), new Object[] {1});
+    rowSet.setDone();
+    assertEquals(1, rowSet.getRowWait(10, TimeUnit.SECONDS)[0]);
+    long start = System.nanoTime();
+    assertNull(rowSet.getRowWait(10, TimeUnit.SECONDS));
+    assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 
1000);
+    assertNull(rowSet.parkedConsumer);
+  }
+
+  @Test
+  void aParkedReaderIsEndedBySetDone() throws Exception {
+    LockFreeRowSet rowSet = new LockFreeRowSet(8);
+    AtomicBoolean returned = new AtomicBoolean();
+    Thread reader =
+        new Thread(
+            () -> {
+              assertNull(rowSet.getRowWait(30, TimeUnit.SECONDS));
+              returned.set(true);
+            });
+    reader.start();
+    long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+    while (rowSet.parkedConsumer == null && System.nanoTime() < deadline) {
+      Thread.sleep(1);
+    }
+    rowSet.setDone();
+    reader.join(5_000);
+    assertTrue(returned.get(), "the reader waited for the timeout");
+  }
+
+  @Test
+  void aHugeSizeIsClampedInsteadOfOverflowingTheCapacity() {
+    assertEquals(1 << 30, LockFreeRowSetFields.maxRows(Integer.MAX_VALUE));
+    assertEquals(1 << 30, LockFreeRowSetFields.capacity(1 << 30));
+    assertEquals(1, LockFreeRowSetFields.maxRows(0));
+    assertEquals(2, LockFreeRowSetFields.capacity(1));
+    assertEquals(16_384, LockFreeRowSetFields.capacity(10_000));
+  }
+
+  @Test
+  void waitsWithAHugeTimeoutInsteadOfGivingUp() throws Exception {
+    // RowProducer uses Long.MAX_VALUE days: the deadline must not overflow 
into "expired"
+    LockFreeRowSet rowSet = new LockFreeRowSet(2);
+    rowSet.putRow(new RowMeta(), new Object[] {1});
+    rowSet.putRow(new RowMeta(), new Object[] {2});
+    Thread consumer =
+        new Thread(
+            () -> {
+              try {
+                Thread.sleep(200);
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              }
+              rowSet.getRowImmediate();
+            });
+    consumer.start();
+    long start = System.nanoTime();
+    assertTrue(rowSet.putRowWait(new RowMeta(), new Object[] {3}, 
Long.MAX_VALUE, TimeUnit.DAYS));
+    assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) >= 
150);
+    consumer.join();
+  }
+
+  @Test
+  void awaitAnyReturnsAtOnceWhenAnInputHasRowsOrIsDone() {
+    LockFreeRowSet empty = new LockFreeRowSet(8);
+    LockFreeRowSet withRow = new LockFreeRowSet(8);
+    LockFreeRowSet done = new LockFreeRowSet(8);
+    withRow.putRow(new RowMeta(), new Object[] {1});
+    done.setDone();
+
+    long start = System.nanoTime();
+    LockFreeRowSet.awaitAny(List.of(empty, withRow), 
TimeUnit.SECONDS.toNanos(10));
+    LockFreeRowSet.awaitAny(List.of(empty, done), 
TimeUnit.SECONDS.toNanos(10));
+    assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 
1000);
+  }
+
+  @Test
+  void awaitAnyLeavesNoParkedReaderBehind() {
+    LockFreeRowSet a = new LockFreeRowSet(8);
+    LockFreeRowSet b = new LockFreeRowSet(8);
+    LockFreeRowSet.awaitAny(List.of(a, b), TimeUnit.MILLISECONDS.toNanos(5));
+    assertNull(a.parkedConsumer);
+    assertNull(b.parkedConsumer);
+  }
+
+  @Test
+  void awaitAnyIsWokenByRowsOnAnyInput() throws Exception {
+    // wake-ups come in batches of a quarter of the buffer: 2 rows for a 
buffer of 8
+    LockFreeRowSet a = new LockFreeRowSet(8);
+    LockFreeRowSet b = new LockFreeRowSet(8);
+    List<IRowSet> inputs = List.of(a, b);
+    Thread producer =
+        new Thread(
+            () -> {
+              try {
+                Thread.sleep(50);
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              }
+              b.putRow(new RowMeta(), new Object[] {1});
+              b.putRow(new RowMeta(), new Object[] {2});
+            });
+    producer.start();
+    while (b.size() == 0) {
+      LockFreeRowSet.awaitAny(inputs, TimeUnit.SECONDS.toNanos(10));
+    }
+    producer.join();
+    assertEquals(2, b.size());
+    assertEquals(0, a.size());
+  }
+
+  @Test
+  void deliversEveryRowOnceWithSeveralProducers() throws Exception {
+    LockFreeRowSet rowSet = new LockFreeRowSet(1000);
+    int producers = 4;
+    int perProducer = 250_000;
+    List<Thread> threads = new ArrayList<>();
+    for (int p = 0; p < producers; p++) {
+      long base = (long) p * perProducer;
+      Thread t =
+          new Thread(
+              () -> {
+                for (int i = 0; i < perProducer; i++) {
+                  Object[] row = {base + i};
+                  while (!rowSet.putRow(new RowMeta(), row)) {
+                    // full: retry, like BaseTransform does
+                  }
+                }
+              });
+      threads.add(t);
+      t.start();
+    }
+    boolean[] seen = new boolean[producers * perProducer];
+    int received = 0;
+    while (received < seen.length) {
+      Object[] row = rowSet.getRowWait(50, TimeUnit.MILLISECONDS);
+      if (row != null) {
+        int id = (int) (long) (Long) row[0];
+        assertFalse(seen[id], "row " + id + " delivered twice");
+        seen[id] = true;
+        received++;
+      }
+    }
+    for (Thread t : threads) {
+      t.join(10_000);
+    }
+    assertNull(rowSet.getRowImmediate());
+    assertEquals(0, rowSet.size());
+  }
+}
diff --git 
a/docs/hop-user-manual/modules/ROOT/pages/pipeline/pipeline-run-configurations/native-local-pipeline-engine.adoc
 
b/docs/hop-user-manual/modules/ROOT/pages/pipeline/pipeline-run-configurations/native-local-pipeline-engine.adoc
index 7a7e625e6e..635982b965 100644
--- 
a/docs/hop-user-manual/modules/ROOT/pages/pipeline/pipeline-run-configurations/native-local-pipeline-engine.adoc
+++ 
b/docs/hop-user-manual/modules/ROOT/pages/pipeline/pipeline-run-configurations/native-local-pipeline-engine.adoc
@@ -77,5 +77,16 @@ Note that child pipelines or workflows are also 
automatically run as a transacti
 Also be aware that while you *can* commit and rollback across multiple 
databases that this still means that you can have a successful commit on one 
database and a failure on another.
 This is not a two-phase-commit system.
 |false
+|Lock-free row sets (experimental)
+|An experimental performance option.
+Rows are passed between transforms through lock-free buffers instead of 
lock-based ones.
+The transform that reads a buffer is woken once a batch of rows is ready, 
instead of for every row.
+A transform with several inputs waits on all of them at once and is woken by 
whichever input has rows.
+A transform that has had no rows for a while waits longer between checks, up 
to 20 ms, and is then woken by the next row, so idle transforms in long-running 
pipelines use little CPU.
+This lowers the cost per row, which matters most in pipelines of fast 
transforms.
+A buffer holds at most the configured *Row set size*, as the lock-based 
buffers do, and the row counts of the transforms are exact.
+With this option the *Wait time buffer check (ms)* setting is not used: 
transforms no longer poll their inputs.
+Hops that spill to disk to avoid a buffer deadlock keep their spilling buffer.
+|false
 |===
 
diff --git a/docs/hop-user-manual/modules/ROOT/pages/variables.adoc 
b/docs/hop-user-manual/modules/ROOT/pages/variables.adoc
index b151df70ff..9304d527e2 100644
--- a/docs/hop-user-manual/modules/ROOT/pages/variables.adoc
+++ b/docs/hop-user-manual/modules/ROOT/pages/variables.adoc
@@ -245,7 +245,6 @@ Otherwise by default NULL is ignored by the MIN aggregate 
and MIN is set to the
 See also the variable HOP_AGGREGATION_ALL_NULLS_ARE_ZERO.
 |HOP_ALLOW_EMPTY_FIELD_NAMES_AND_TYPES|N|Set this variable to Y to allow your 
pipeline to pass 'null' fields and/or empty types.
 |HOP_ALLOW_UNCONSUMED_MAIN_INPUT|N|Set this variable to Y to start a pipeline 
that has main hops into transforms that do not consume input (for example 
existing files whose upstream produces no rows). Default N fails init and stops 
on leftover input. Verify still reports an error. See 
xref:pipeline/pipeline-sources.adoc[Pipeline sources].
-|HOP_BATCHING_ROWSET|N|Set this variable to 'Y' if you want to test a more 
efficient batching row set.
 |HOP_DATABASE_CONNECTION_TIMEOUT|30|Default login/connection timeout in 
**seconds** applied when opening a JDBC database connection (maps to 
`DriverManager.setLoginTimeout`).
 Defaults to `30`; set to `0` to impose no timeout (a stalled connect can then 
block indefinitely).
 The setting is advisory: some JDBC drivers ignore it in favor of their own 
connection options.
diff --git a/engine/src/main/java/org/apache/hop/pipeline/Pipeline.java 
b/engine/src/main/java/org/apache/hop/pipeline/Pipeline.java
index 737fd560b2..967f18a156 100644
--- a/engine/src/main/java/org/apache/hop/pipeline/Pipeline.java
+++ b/engine/src/main/java/org/apache/hop/pipeline/Pipeline.java
@@ -45,13 +45,13 @@ import lombok.Getter;
 import lombok.Setter;
 import org.apache.commons.vfs2.FileName;
 import org.apache.commons.vfs2.FileObject;
-import org.apache.hop.core.BlockingBatchingRowSet;
 import org.apache.hop.core.BlockingRowSet;
 import org.apache.hop.core.Const;
 import org.apache.hop.core.HopVersionProvider;
 import org.apache.hop.core.IExecutor;
 import org.apache.hop.core.IExtensionData;
 import org.apache.hop.core.IRowSet;
+import org.apache.hop.core.LockFreeRowSet;
 import org.apache.hop.core.QueueRowSet;
 import org.apache.hop.core.Result;
 import org.apache.hop.core.ResultFile;
@@ -403,6 +403,12 @@ public abstract class Pipeline
   /** Directory for {@link SpillingRowSet} temp files; blank uses the system 
temp directory. */
   @Getter @Setter protected String bufferDeadlockSpillDirectory;
 
+  /**
+   * Experimental: use {@link LockFreeRowSet} instead of {@link 
BlockingRowSet} between transforms
+   * (hops that spill to disk keep their {@link SpillingRowSet}).
+   */
+  @Getter @Setter protected boolean lockFreeRowSets;
+
   public void setBufferDeadlockSpillHops(Set<SpillHop> 
bufferDeadlockSpillHops) {
     this.bufferDeadlockSpillHops =
         bufferDeadlockSpillHops == null ? Set.of() : 
Set.copyOf(bufferDeadlockSpillHops);
@@ -857,22 +863,7 @@ public abstract class Pipeline
             IRowSet rowSet;
             switch (getPipelineType()) {
               case Normal:
-                // This is a temporary patch until the batching rowset has 
proven
-                // to be working in all situations.
-                // Currently there are stalling problems when dealing with 
small
-                // amounts of rows.
-                //
-                Boolean batchingRowSet =
-                    ValueMetaBase.convertStringToBoolean(
-                        System.getProperty(Const.HOP_BATCHING_ROWSET));
-                if (batchingRowSet != null && batchingRowSet) {
-                  rowSet = new BlockingBatchingRowSet(rowSetSize);
-                } else if (PipelineBufferDeadlockAnalyzer.shouldSpill(
-                    bufferDeadlockSpillHops, thisTransform.getName(), 
nextTransform.getName())) {
-                  rowSet = new SpillingRowSet(rowSetSize, 
bufferDeadlockSpillDirectory);
-                } else {
-                  rowSet = new BlockingRowSet(rowSetSize);
-                }
+                rowSet = newRowSet(thisTransform.getName(), 
nextTransform.getName());
                 break;
 
               case SingleThreaded:
@@ -918,13 +909,7 @@ public abstract class Pipeline
           // distribution...
           for (int s = 0; s < thisCopies; s++) {
             for (int t = 0; t < nextCopies; t++) {
-              IRowSet rowSet;
-              if (PipelineBufferDeadlockAnalyzer.shouldSpill(
-                  bufferDeadlockSpillHops, thisTransform.getName(), 
nextTransform.getName())) {
-                rowSet = new SpillingRowSet(rowSetSize, 
bufferDeadlockSpillDirectory);
-              } else {
-                rowSet = new BlockingRowSet(rowSetSize);
-              }
+              IRowSet rowSet = newRowSet(thisTransform.getName(), 
nextTransform.getName());
               rowSet.setThreadNameFromToCopy(
                   thisTransform.getName(), s, nextTransform.getName(), t);
               rowsets.add(rowSet);
@@ -2274,6 +2259,18 @@ public abstract class Pipeline
     return safeModeEnabled;
   }
 
+  /** Creates the row set of a hop in a normal (multi-threaded) pipeline. */
+  private IRowSet newRowSet(String fromTransformName, String toTransformName) {
+    if (PipelineBufferDeadlockAnalyzer.shouldSpill(
+        bufferDeadlockSpillHops, fromTransformName, toTransformName)) {
+      return new SpillingRowSet(rowSetSize, bufferDeadlockSpillDirectory);
+    }
+    if (lockFreeRowSets) {
+      return new LockFreeRowSet(rowSetSize);
+    }
+    return new BlockingRowSet(rowSetSize);
+  }
+
   /**
    * This adds a row producer to the pipeline that just got set up. It is 
preferable to run this
    * BEFORE execute() but after prepareExecution()
@@ -2296,7 +2293,8 @@ public abstract class Pipeline
     // We are going to add an extra IRowSet to this iTransform.
     IRowSet rowSet =
         switch (getPipelineType()) {
-          case Normal -> new BlockingRowSet(rowSetSize);
+          case Normal ->
+              lockFreeRowSets ? new LockFreeRowSet(rowSetSize) : new 
BlockingRowSet(rowSetSize);
           case SingleThreaded -> new QueueRowSet();
           default -> throw new HopException("Unhandled pipeline type: " + 
getPipelineType());
         };
diff --git 
a/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngine.java
 
b/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngine.java
index add8d54751..001fdf13c2 100644
--- 
a/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngine.java
+++ 
b/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngine.java
@@ -217,6 +217,7 @@ public class LocalPipelineEngine extends Pipeline 
implements IPipelineEngine<Pip
     setGatheringMetrics(config.isGatheringMetrics());
     setFeedbackShown(config.isFeedbackShown());
     setFeedbackSize(Const.toInt(resolve(config.getFeedbackSize()), 
Const.ROWS_UPDATE));
+    setLockFreeRowSets(config.isLockFreeRowSets());
 
     // Buffer deadlock detection / optional minimal spill (classic local 
engine only)
     //
diff --git 
a/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineRunConfiguration.java
 
b/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineRunConfiguration.java
index e8e1395878..591298ce66 100644
--- 
a/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineRunConfiguration.java
+++ 
b/engine/src/main/java/org/apache/hop/pipeline/engines/local/LocalPipelineRunConfiguration.java
@@ -40,6 +40,9 @@ public class LocalPipelineRunConfiguration extends 
EmptyPipelineRunConfiguration
     implements IPipelineEngineRunConfiguration,
         
org.apache.hop.pipeline.engines.IMeasuringLocalPipelineRunConfiguration {
 
+  public static final String WIDGET_ID_WAIT_TIME = "waitTime";
+  public static final String WIDGET_ID_LOCK_FREE_ROWSETS = "lockFreeRowSets";
+
   @GuiWidgetElement(
       id = "rowSetSize",
       order = "010",
@@ -104,7 +107,7 @@ public class LocalPipelineRunConfiguration extends 
EmptyPipelineRunConfiguration
 
   /** The feedback size. */
   @GuiWidgetElement(
-      id = "waitTime",
+      id = WIDGET_ID_WAIT_TIME,
       order = "070",
       parentId = PipelineRunConfiguration.GUI_PLUGIN_ELEMENT_PARENT_ID,
       type = GuiElementType.TEXT,
@@ -194,6 +197,22 @@ public class LocalPipelineRunConfiguration extends 
EmptyPipelineRunConfiguration
   @HopMetadataProperty(key = "buffer_deadlock_spill_directory")
   protected String bufferDeadlockSpillDirectory;
 
+  /**
+   * Experimental: lock-free row sets between transforms. The wait time for 
buffer checks is not
+   * used then.
+   */
+  @GuiWidgetElement(
+      id = WIDGET_ID_LOCK_FREE_ROWSETS,
+      order = "140",
+      parentId = PipelineRunConfiguration.GUI_PLUGIN_ELEMENT_PARENT_ID,
+      type = GuiElementType.CHECKBOX,
+      label =
+          
"i18n:org.apache.hop.ui.pipeline.config:PipelineRunConfigurationDialog.LockFreeRowSets.Label",
+      toolTip =
+          
"i18n:org.apache.hop.ui.pipeline.config:PipelineRunConfigurationDialog.LockFreeRowSets.ToolTip")
+  @HopMetadataProperty(key = "lock_free_rowsets")
+  protected boolean lockFreeRowSets;
+
   @SuppressWarnings("java:S115")
   public enum SampleType {
     None,
@@ -214,6 +233,7 @@ public class LocalPipelineRunConfiguration extends 
EmptyPipelineRunConfiguration
     this.detectBufferDeadlocks = true;
     this.mitigateBufferDeadlocks = true;
     this.bufferDeadlockSpillDirectory = "";
+    this.lockFreeRowSets = false;
   }
 
   public LocalPipelineRunConfiguration(LocalPipelineRunConfiguration config) {
@@ -231,6 +251,7 @@ public class LocalPipelineRunConfiguration extends 
EmptyPipelineRunConfiguration
     this.detectBufferDeadlocks = config.detectBufferDeadlocks;
     this.mitigateBufferDeadlocks = config.mitigateBufferDeadlocks;
     this.bufferDeadlockSpillDirectory = config.bufferDeadlockSpillDirectory;
+    this.lockFreeRowSets = config.lockFreeRowSets;
   }
 
   @Override
diff --git 
a/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java 
b/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
index 3a93fd0c9b..32bbf27739 100644
--- a/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
+++ b/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
@@ -21,6 +21,8 @@ import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import java.io.Closeable;
 import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -46,6 +48,7 @@ import org.apache.hop.core.BlockingRowSet;
 import org.apache.hop.core.Const;
 import org.apache.hop.core.IExtensionData;
 import org.apache.hop.core.IRowSet;
+import org.apache.hop.core.LockFreeRowSet;
 import org.apache.hop.core.ResultFile;
 import org.apache.hop.core.exception.HopException;
 import org.apache.hop.core.exception.HopRowException;
@@ -151,6 +154,46 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
 
   private final Object statusCountersLock = new Object();
 
+  /**
+   * Experimental lock-free row sets ({@link Pipeline#isLockFreeRowSets()}, an 
option of the local
+   * run configuration): the row set lists are copy-on-write and read without 
a lock on the per-row
+   * paths, the line counters are updated atomically instead of under {@link 
#statusCountersLock},
+   * row sets that wait efficiently themselves skip the per-row size() check 
and sleep, and inputs
+   * are read without the run configuration's wait times: the transform parks 
on all its inputs at
+   * once and any of them wakes it (see {@link #getRowLockFree(IRowSet)}). 
With the option off,
+   * every one of these spots runs the original code.
+   */
+  private final boolean lockFreeRowSets;
+
+  /** The longest a transform parks waiting on its lock-free inputs before it 
checks them again. */
+  private static final long LOCK_FREE_MAX_WAIT_NANOS = 
TimeUnit.MILLISECONDS.toNanos(1);
+
+  /** The longest a transform parks once its lock-free inputs have been idle 
for a while. */
+  private static final long LOCK_FREE_MAX_IDLE_NANOS = 
TimeUnit.MILLISECONDS.toNanos(20);
+
+  private static final VarHandle LINES_READ;
+  private static final VarHandle LINES_WRITTEN;
+  private static final VarHandle LINES_INPUT;
+  private static final VarHandle LINES_OUTPUT;
+  private static final VarHandle LINES_UPDATED;
+  private static final VarHandle LINES_SKIPPED;
+  private static final VarHandle LINES_REJECTED;
+
+  static {
+    try {
+      MethodHandles.Lookup lookup = MethodHandles.lookup();
+      LINES_READ = lookup.findVarHandle(BaseTransform.class, "linesRead", 
long.class);
+      LINES_WRITTEN = lookup.findVarHandle(BaseTransform.class, 
"linesWritten", long.class);
+      LINES_INPUT = lookup.findVarHandle(BaseTransform.class, "linesInput", 
long.class);
+      LINES_OUTPUT = lookup.findVarHandle(BaseTransform.class, "linesOutput", 
long.class);
+      LINES_UPDATED = lookup.findVarHandle(BaseTransform.class, 
"linesUpdated", long.class);
+      LINES_SKIPPED = lookup.findVarHandle(BaseTransform.class, 
"linesSkipped", long.class);
+      LINES_REJECTED = lookup.findVarHandle(BaseTransform.class, 
"linesRejected", long.class);
+    } catch (ReflectiveOperationException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
   protected Date initStartDate;
   protected Date executionStartDate;
   protected Date firstRowReadDate;
@@ -386,6 +429,7 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
     this.pipelineMeta = pipelineMeta;
     this.pipeline = pipeline;
     this.transformName = transformMeta.getName();
+    this.lockFreeRowSets = pipeline != null && pipeline.isLockFreeRowSets();
 
     // Sanity check
     //
@@ -425,8 +469,11 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
     }
     dataVolume = null;
 
-    inputRowSets = new ArrayList<>();
-    outputRowSets = new ArrayList<>();
+    // copy-on-write with lock-free row sets: the lists only change while the 
pipeline is wired
+    // (or when an input is done, on this transform's own thread), so the 
per-row paths read them
+    // without taking the read lock
+    inputRowSets = lockFreeRowSets ? new CopyOnWriteArrayList<>() : new 
ArrayList<>();
+    outputRowSets = lockFreeRowSets ? new CopyOnWriteArrayList<>() : new 
ArrayList<>();
     nextTransforms = null;
 
     terminator = transformMeta.hasTerminator();
@@ -679,6 +726,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesRead() {
+    if (lockFreeRowSets) {
+      return (long) LINES_READ.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesRead;
     }
@@ -693,6 +743,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return Returns the new value
    */
   public long incrementLinesRead() {
+    if (lockFreeRowSets) {
+      return (long) LINES_READ.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesRead;
     }
@@ -704,6 +757,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return Returns the new value
    */
   public long decrementLinesRead() {
+    if (lockFreeRowSets) {
+      return (long) LINES_READ.getAndAdd(this, -1L) - 1L;
+    }
     synchronized (statusCountersLock) {
       return --linesRead;
     }
@@ -716,6 +772,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #decrementLinesRead()
    */
   public void setLinesRead(long newLinesReadValue) {
+    if (lockFreeRowSets) {
+      LINES_READ.setVolatile(this, newLinesReadValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesRead = newLinesReadValue;
     }
@@ -727,6 +787,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesInput() {
+    if (lockFreeRowSets) {
+      return (long) LINES_INPUT.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesInput;
     }
@@ -740,6 +803,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return the new incremented value
    */
   public long incrementLinesInput() {
+    if (lockFreeRowSets) {
+      return (long) LINES_INPUT.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesInput;
     }
@@ -752,6 +818,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #incrementLinesInput()
    */
   public void setLinesInput(long newLinesInputValue) {
+    if (lockFreeRowSets) {
+      LINES_INPUT.setVolatile(this, newLinesInputValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesInput = newLinesInputValue;
     }
@@ -764,6 +834,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesOutput() {
+    if (lockFreeRowSets) {
+      return (long) LINES_OUTPUT.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesOutput;
     }
@@ -777,6 +850,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #setLinesOutput(long)
    */
   public long incrementLinesOutput() {
+    if (lockFreeRowSets) {
+      return (long) LINES_OUTPUT.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesOutput;
     }
@@ -789,6 +865,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #incrementLinesOutput()
    */
   public void setLinesOutput(long newLinesOutputValue) {
+    if (lockFreeRowSets) {
+      LINES_OUTPUT.setVolatile(this, newLinesOutputValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesOutput = newLinesOutputValue;
     }
@@ -803,6 +883,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesWritten() {
+    if (lockFreeRowSets) {
+      return (long) LINES_WRITTEN.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesWritten;
     }
@@ -816,6 +899,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return Returns the new value
    */
   public long incrementLinesWritten() {
+    if (lockFreeRowSets) {
+      return (long) LINES_WRITTEN.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesWritten;
     }
@@ -829,6 +915,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return Returns the new value
    */
   public long decrementLinesWritten() {
+    if (lockFreeRowSets) {
+      return (long) LINES_WRITTEN.getAndAdd(this, -1L) - 1L;
+    }
     synchronized (statusCountersLock) {
       return --linesWritten;
     }
@@ -843,6 +932,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #decrementLinesWritten()
    */
   public void setLinesWritten(long newLinesWrittenValue) {
+    if (lockFreeRowSets) {
+      LINES_WRITTEN.setVolatile(this, newLinesWrittenValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesWritten = newLinesWrittenValue;
     }
@@ -855,6 +948,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesUpdated() {
+    if (lockFreeRowSets) {
+      return (long) LINES_UPDATED.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesUpdated;
     }
@@ -868,6 +964,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #setLinesUpdated(long)
    */
   public long incrementLinesUpdated() {
+    if (lockFreeRowSets) {
+      return (long) LINES_UPDATED.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesUpdated;
     }
@@ -880,6 +979,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #incrementLinesUpdated()
    */
   public void setLinesUpdated(long newLinesUpdatedValue) {
+    if (lockFreeRowSets) {
+      LINES_UPDATED.setVolatile(this, newLinesUpdatedValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesUpdated = newLinesUpdatedValue;
     }
@@ -894,6 +997,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public long getLinesRejected() {
+    if (lockFreeRowSets) {
+      return (long) LINES_REJECTED.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesRejected;
     }
@@ -982,6 +1088,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @return the new incremented value
    */
   public long incrementLinesRejected() {
+    if (lockFreeRowSets) {
+      return (long) LINES_REJECTED.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesRejected;
     }
@@ -994,6 +1103,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @Override
   public void setLinesRejected(long newLinesRejectedValue) {
+    if (lockFreeRowSets) {
+      LINES_REJECTED.setVolatile(this, newLinesRejectedValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesRejected = newLinesRejectedValue;
     }
@@ -1005,6 +1118,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #incrementLinesSkipped()
    */
   public long getLinesSkipped() {
+    if (lockFreeRowSets) {
+      return (long) LINES_SKIPPED.getVolatile(this);
+    }
     synchronized (statusCountersLock) {
       return linesSkipped;
     }
@@ -1018,6 +1134,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #setLinesSkipped(long)
    */
   public long incrementLinesSkipped() {
+    if (lockFreeRowSets) {
+      return (long) LINES_SKIPPED.getAndAdd(this, 1L) + 1L;
+    }
     synchronized (statusCountersLock) {
       return ++linesSkipped;
     }
@@ -1029,6 +1148,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    * @see #incrementLinesSkipped()
    */
   public void setLinesSkipped(long newLinesSkippedValue) {
+    if (lockFreeRowSets) {
+      LINES_SKIPPED.setVolatile(this, newLinesSkippedValue);
+      return;
+    }
     synchronized (statusCountersLock) {
       linesSkipped = newLinesSkippedValue;
     }
@@ -1207,7 +1330,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
       }
     }
 
-    outputRowSetsLock.readLock().lock();
+    if (!lockFreeRowSets) {
+      outputRowSetsLock.readLock().lock();
+    }
     try {
       if (outputRowSets.isEmpty()) {
         // No more output rowsets!
@@ -1239,7 +1364,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
               "Internal error: invalid repartitioning type: " + 
repartitioning);
       }
     } finally {
-      outputRowSetsLock.readLock().unlock();
+      if (!lockFreeRowSets) {
+        outputRowSetsLock.readLock().unlock();
+      }
     }
   }
 
@@ -1330,7 +1457,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
         // To reduce stress on the locking system we are NOT going to allow
         // the buffer to grow to its full capacity.
 
-        if (!rs.isDone() && rs.size() >= upperBufferBoundary && !isStopped()) {
+        if ((!lockFreeRowSets || rs.needsThrottling())
+            && !rs.isDone()
+            && rs.size() >= upperBufferBoundary
+            && !isStopped()) {
           try {
             // A real 1 ms pause: sleep(0, 1) did that until JDK 21, which 
sleeps 1 ns (JDK-8305092)
             Thread.sleep(1);
@@ -1367,7 +1497,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
         // To reduce stress on the locking system we are NOT going to allow
         // the buffer to grow to its full capacity.
 
-        if (!rs.isDone() && rs.size() >= upperBufferBoundary && !isStopped()) {
+        if ((!lockFreeRowSets || rs.needsThrottling())
+            && !rs.isDone()
+            && rs.size() >= upperBufferBoundary
+            && !isStopped()) {
           try {
             // A real 1 ms pause: sleep(0, 1) did that until JDK 21, which 
sleeps 1 ns (JDK-8305092)
             Thread.sleep(1);
@@ -1615,6 +1748,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
    */
   @VisibleForTesting
   IRowSet currentInputStream() {
+    if (lockFreeRowSets) {
+      return inputRowSets.get(currentInputRowSetNr);
+    }
     inputRowSetsLock.readLock().lock();
     try {
       return inputRowSets.get(currentInputRowSetNr);
@@ -1706,7 +1842,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
     IRowSet inputRowSet = null;
     Object[] row = null;
 
-    inputRowSetsLock.readLock().lock();
+    if (!lockFreeRowSets) {
+      inputRowSetsLock.readLock().lock();
+    }
     try {
 
       // If everything is finished, we can stop immediately!
@@ -1741,7 +1879,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
       // The buffer to grow beyond "a few" entries.
       // We'll only do that if the previous transform has not ended...
 
-      if (!inputRowSet.isDone() && inputRowSet.size() <= lowerBufferBoundary 
&& !isStopped()) {
+      if ((!lockFreeRowSets || inputRowSet.needsThrottling())
+          && !inputRowSet.isDone()
+          && inputRowSet.size() <= lowerBufferBoundary
+          && !isStopped()) {
         try {
           // A real 1 ms pause: sleep(0, 1) did that until JDK 21, which 
sleeps 1 ns (JDK-8305092)
           Thread.sleep(1);
@@ -1762,71 +1903,80 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
       // rowset, then switch to another etc.
       // We can use timeouts to switch from one to another...
       //
-      if (waitingTime == null) {
-        Integer waitTime =
-            
Const.toInt(EnvUtil.getSystemProperty(Const.HOP_DEFAULT_BUFFER_POLLING_WAITTIME),
 20);
-        if (pipeline.getPipelineRunConfiguration().getEngineRunConfiguration()
-            instanceof LocalPipelineRunConfiguration runconfig) {
-          waitTime = Const.toInt(runconfig.getWaitTime(), waitTime);
+      if (lockFreeRowSets) {
+        if (row == null) {
+          row = getRowLockFree(inputRowSet);
+          if (row == null && inputRowSets.isEmpty()) {
+            return null; // We're completely done.
+          }
         }
-        waitingTime = DynamicWaitTimes.build(inputRowSets, 
this::getCurrentInputRowSetNr, waitTime);
-      }
-      while (row == null && !isStopped()) {
-        // Get a row from the input in row set ...
-        // Timeout immediately if nothing is there to read.
-        // We will then switch to the next row set to read from...
-        //
-        row = inputRowSet.getRowWait(waitingTime.get(), TimeUnit.MILLISECONDS);
-        boolean timeout = false;
-        if (row != null) {
-          obtainInputRowMeta(row, inputRowSet);
-          incrementLinesRead();
-          addDataVolumeInIfEnabled(row);
-          blockPointer++;
-          waitingTime.reset();
-        } else {
-          // Try once more...
-          // If row is still empty and the row set is done, we remove the row
-          // set from
-          // the input stream and move on to the next one...
+      } else {
+        if (waitingTime == null) {
+          Integer waitTime =
+              
Const.toInt(EnvUtil.getSystemProperty(Const.HOP_DEFAULT_BUFFER_POLLING_WAITTIME),
 20);
+          if 
(pipeline.getPipelineRunConfiguration().getEngineRunConfiguration()
+              instanceof LocalPipelineRunConfiguration runconfig) {
+            waitTime = Const.toInt(runconfig.getWaitTime(), waitTime);
+          }
+          waitingTime =
+              DynamicWaitTimes.build(inputRowSets, 
this::getCurrentInputRowSetNr, waitTime);
+        }
+        while (row == null && !isStopped()) {
+          // Get a row from the input in row set ...
+          // Timeout immediately if nothing is there to read.
+          // We will then switch to the next row set to read from...
           //
-          if (inputRowSet.isDone()) {
-            row = inputRowSet.getRowWait(1, TimeUnit.MILLISECONDS);
-            if (row == null) {
-
-              // Must release the read lock before acquisition of the write 
lock to prevent
-              // deadlocks.
-              inputRowSetsLock.readLock().unlock();
-
-              // Another thread might acquire the write lock before we do,
-              // and invalidate the data we have just read.
-              //
-              // This is actually fine, until we only want to remove the 
current rowSet - ArrayList
-              // ignores non-existing
-              // elements when removing.
-              inputRowSetsLock.writeLock().lock();
-              try {
-                removeRowSetFromInputRowSets(inputRowSet);
-                if (inputRowSets.isEmpty()) {
-                  return null; // We're completely done.
+          row = inputRowSet.getRowWait(waitingTime.get(), 
TimeUnit.MILLISECONDS);
+          boolean timeout = false;
+          if (row != null) {
+            obtainInputRowMeta(row, inputRowSet);
+            incrementLinesRead();
+            addDataVolumeInIfEnabled(row);
+            blockPointer++;
+            waitingTime.reset();
+          } else {
+            // Try once more...
+            // If row is still empty and the row set is done, we remove the row
+            // set from
+            // the input stream and move on to the next one...
+            //
+            if (inputRowSet.isDone()) {
+              row = inputRowSet.getRowWait(1, TimeUnit.MILLISECONDS);
+              if (row == null) {
+
+                // Must release the read lock before acquisition of the write 
lock to prevent
+                // deadlocks.
+                inputRowSetsLock.readLock().unlock();
+
+                // Another thread might acquire the write lock before we do,
+                // and invalidate the data we have just read.
+                //
+                // This is actually fine, until we only want to remove the 
current rowSet -
+                // ArrayList ignores non-existing elements when removing.
+                inputRowSetsLock.writeLock().lock();
+                try {
+                  removeRowSetFromInputRowSets(inputRowSet);
+                  if (inputRowSets.isEmpty()) {
+                    return null; // We're completely done.
+                  }
+                } finally {
+                  inputRowSetsLock.readLock().lock(); // downgrade to read lock
+                  inputRowSetsLock.writeLock().unlock();
                 }
-              } finally {
-                inputRowSetsLock.readLock().lock(); // downgrade to read lock
-                inputRowSetsLock.writeLock().unlock();
+              } else {
+                obtainInputRowMeta(row, inputRowSet);
+                incrementLinesRead();
+                addDataVolumeInIfEnabled(row);
               }
             } else {
-              obtainInputRowMeta(row, inputRowSet);
-              incrementLinesRead();
-              addDataVolumeInIfEnabled(row);
+              timeout = true;
             }
-          } else {
-            timeout = true;
+            nextInputStream();
+            inputRowSet = currentInputStream();
+            // only change delay time when input stream don't switch.
+            // else switch active stream and reset min delay time
+            waitingTime.adjust(timeout, inputRowSet);
           }
-          nextInputStream();
-          inputRowSet = currentInputStream();
-          // only change delay time when input stream don't switch.
-          // else switch active stream and reset min delay time
-          waitingTime.adjust(timeout, inputRowSet);
         }
       }
 
@@ -1848,7 +1998,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
         obtainInputRowMeta(row, inputRowSet);
       }
     } finally {
-      inputRowSetsLock.readLock().unlock();
+      if (!lockFreeRowSets) {
+        inputRowSetsLock.readLock().unlock();
+      }
     }
 
     if (row != null) {
@@ -1870,6 +2022,59 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
     return row;
   }
 
+  /**
+   * Reads the next row with lock-free row sets, without the wait times of 
{@link DynamicWaitTimes}:
+   * the current input first, then the next ones, without waiting. When a 
whole round over the
+   * inputs finds nothing, the transform parks until one of them has a batch 
of rows or is done (see
+   * {@link LockFreeRowSet#awaitAny(List, long)}), so rows on any input wake 
it. While nothing
+   * arrives the park grows from 1 ms to 20 ms, and the next row then wakes 
the transform, so an
+   * idle transform costs little CPU.
+   *
+   * @return the row, or null when every input is done (and removed) or the 
transform is stopped
+   */
+  private Object[] getRowLockFree(IRowSet inputRowSet) {
+    int emptyInputs = 0;
+    long idleWait = LOCK_FREE_MAX_WAIT_NANOS;
+    while (!isStopped()) {
+      Object[] row = inputRowSet.getRowImmediate();
+      if (row == null && inputRowSet.isDone()) {
+        // rows put before the row set was done are visible now: try once more
+        row = inputRowSet.getRowImmediate();
+        if (row == null) {
+          inputRowSetsLock.writeLock().lock();
+          try {
+            removeRowSetFromInputRowSets(inputRowSet);
+          } finally {
+            inputRowSetsLock.writeLock().unlock();
+          }
+          if (inputRowSets.isEmpty()) {
+            return null;
+          }
+          emptyInputs = 0;
+          inputRowSet = currentInputStream();
+          continue;
+        }
+      }
+      if (row != null) {
+        obtainInputRowMeta(row, inputRowSet);
+        incrementLinesRead();
+        addDataVolumeInIfEnabled(row);
+        blockPointer++;
+        return row;
+      }
+      if (++emptyInputs >= inputRowSets.size()) {
+        // back off while nothing arrives: lock-free inputs then wake us on 
their next row
+        if (LockFreeRowSet.awaitAny(inputRowSets, idleWait)) {
+          idleWait = Math.min(idleWait * 2, LOCK_FREE_MAX_IDLE_NANOS);
+        }
+        emptyInputs = 0;
+      }
+      nextInputStream();
+      inputRowSet = currentInputStream();
+    }
+    return null;
+  }
+
   /**
    * The first non-null row we get we'll lock in the row metadata. For 
scenarios with multiple
    * inputs, we move the metadata around (e.g. Merge Rows).
@@ -2097,7 +2302,10 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
     // The buffer to grow beyond "a few" entries.
     // We'll only do that if the previous transform has not ended...
 
-    if (!rowSet.isDone() && rowSet.size() <= lowerBufferBoundary && 
!isStopped()) {
+    if ((!lockFreeRowSets || rowSet.needsThrottling())
+        && !rowSet.isDone()
+        && rowSet.size() <= lowerBufferBoundary
+        && !isStopped()) {
       try {
         // A real 1 ms pause: sleep(0, 1) did that until JDK 21, which sleeps 
1 ns (JDK-8305092)
         Thread.sleep(1);
@@ -2135,14 +2343,15 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
       //
       rowData = rowSet.getRow();
       if (rowData == null) {
-        Integer waitTime = 20;
-        if (pipeline.getPipelineRunConfiguration().getEngineRunConfiguration()
-            instanceof LocalPipelineRunConfiguration runconfig) {
-          waitTime = Integer.parseInt(runconfig.getWaitTime());
-        }
-        if (waitTime == null) waitTime = 20;
+        // lock-free row sets do not use wait times
+        if (!lockFreeRowSets && waitingTime == null) {
+          Integer waitTime = 20;
+          if 
(pipeline.getPipelineRunConfiguration().getEngineRunConfiguration()
+              instanceof LocalPipelineRunConfiguration runconfig) {
+            waitTime = Integer.parseInt(runconfig.getWaitTime());
+          }
+          if (waitTime == null) waitTime = 20;
 
-        if (waitingTime == null) {
           waitingTime =
               DynamicWaitTimes.build(inputRowSets, 
this::getCurrentInputRowSetNr, waitTime);
         }
@@ -3246,7 +3455,9 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
 
   private void removeRowSetFromInputRowSets(IRowSet rowSet) {
     inputRowSets.remove(rowSet);
-    waitingTime.remove(rowSet);
+    if (waitingTime != null) {
+      waitingTime.remove(rowSet); // null when lock-free row sets do not use 
wait times
+    }
     if (currentInputRowSetNr > 0) {
       currentInputRowSetNr--;
     }
@@ -3294,7 +3505,7 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
   public void setInputRowSets(List<IRowSet> inputRowSets) {
     inputRowSetsLock.writeLock().lock();
     try {
-      this.inputRowSets = inputRowSets;
+      this.inputRowSets = lockFreeRowSets ? new 
CopyOnWriteArrayList<>(inputRowSets) : inputRowSets;
     } finally {
       inputRowSetsLock.writeLock().unlock();
     }
@@ -3338,7 +3549,8 @@ public class BaseTransform<Meta extends ITransformMeta, 
Data extends ITransformD
   public void setOutputRowSets(List<IRowSet> outputRowSets) {
     outputRowSetsLock.writeLock().lock();
     try {
-      this.outputRowSets = outputRowSets;
+      this.outputRowSets =
+          lockFreeRowSets ? new CopyOnWriteArrayList<>(outputRowSets) : 
outputRowSets;
     } finally {
       outputRowSetsLock.writeLock().unlock();
     }
diff --git 
a/engine/src/test/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngineLockFreeRowSetsTest.java
 
b/engine/src/test/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngineLockFreeRowSetsTest.java
new file mode 100644
index 0000000000..a75dad9807
--- /dev/null
+++ 
b/engine/src/test/java/org/apache/hop/pipeline/engines/local/LocalPipelineEngineLockFreeRowSetsTest.java
@@ -0,0 +1,235 @@
+/*
+ * 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.hop.pipeline.engines.local;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.apache.hop.core.BlockingRowSet;
+import org.apache.hop.core.HopEnvironment;
+import org.apache.hop.core.IRowSet;
+import org.apache.hop.core.LockFreeRowSet;
+import org.apache.hop.core.exception.HopException;
+import org.apache.hop.core.logging.LoggingObject;
+import org.apache.hop.core.row.IRowMeta;
+import org.apache.hop.core.row.RowMeta;
+import org.apache.hop.core.row.value.ValueMetaInteger;
+import org.apache.hop.core.variables.Variables;
+import org.apache.hop.junit.rules.RestoreHopEngineEnvironmentExtension;
+import org.apache.hop.pipeline.PipelineHopMeta;
+import org.apache.hop.pipeline.PipelineMeta;
+import org.apache.hop.pipeline.RowProducer;
+import org.apache.hop.pipeline.transform.TransformMeta;
+import org.apache.hop.pipeline.transforms.dummy.DummyMeta;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+/** The experimental lock-free row sets option of the local run configuration. 
*/
+@ExtendWith(RestoreHopEngineEnvironmentExtension.class)
+class LocalPipelineEngineLockFreeRowSetsTest {
+
+  private static final int ROWS_PER_INPUT = 50_000;
+
+  @BeforeAll
+  static void beforeClass() throws HopException {
+    HopEnvironment.init();
+  }
+
+  /** Two transforms A and C feeding into transform B, so B reads from several 
inputs. */
+  private static PipelineMeta createPipelineMeta() {
+    PipelineMeta pipelineMeta = new PipelineMeta();
+    pipelineMeta.setName("lock-free row sets test");
+    TransformMeta a = new TransformMeta("A", new DummyMeta());
+    TransformMeta c = new TransformMeta("C", new DummyMeta());
+    TransformMeta b = new TransformMeta("B", new DummyMeta());
+    pipelineMeta.addTransform(a);
+    pipelineMeta.addTransform(c);
+    pipelineMeta.addTransform(b);
+    pipelineMeta.addPipelineHop(new PipelineHopMeta(a, b));
+    pipelineMeta.addPipelineHop(new PipelineHopMeta(c, b));
+    return pipelineMeta;
+  }
+
+  private static LocalPipelineEngine createPipeline(boolean lockFreeRowSets) {
+    LocalPipelineEngine pipeline =
+        new LocalPipelineEngine(createPipelineMeta(), new Variables(), new 
LoggingObject("test"));
+    LocalPipelineRunConfiguration config =
+        (LocalPipelineRunConfiguration)
+            pipeline.getPipelineRunConfiguration().getEngineRunConfiguration();
+    // a small buffer, so producers and consumers fill it and wait on each 
other
+    config.setRowSetSize("100");
+    config.setLockFreeRowSets(lockFreeRowSets);
+    return pipeline;
+  }
+
+  @Test
+  void lockFreeRowSetsAreOffByDefault() throws Exception {
+    assertFalse(new LocalPipelineRunConfiguration().isLockFreeRowSets());
+
+    LocalPipelineEngine pipeline = createPipeline(false);
+    pipeline.prepareExecution();
+    assertFalse(pipeline.isLockFreeRowSets());
+    for (IRowSet rowSet : pipeline.getRowsets()) {
+      assertInstanceOf(BlockingRowSet.class, rowSet);
+    }
+    pipeline.addRowProducer("A", 0).finished();
+    pipeline.addRowProducer("C", 0).finished();
+    pipeline.startThreads();
+    pipeline.waitUntilFinished();
+  }
+
+  @Test
+  void everyRowArrivesThroughLockFreeRowSets() throws Exception {
+    LocalPipelineEngine pipeline = createPipeline(true);
+    pipeline.prepareExecution();
+
+    assertTrue(pipeline.isLockFreeRowSets());
+    assertEquals(2, pipeline.getRowsets().size());
+    for (IRowSet rowSet : pipeline.getRowsets()) {
+      assertInstanceOf(LockFreeRowSet.class, rowSet);
+    }
+
+    RowProducer producerA = pipeline.addRowProducer("A", 0);
+    RowProducer producerC = pipeline.addRowProducer("C", 0);
+    assertInstanceOf(LockFreeRowSet.class, producerA.getRowSet());
+
+    pipeline.startThreads();
+    IRowMeta rowMeta = new RowMeta();
+    rowMeta.addValueMeta(new ValueMetaInteger("id"));
+    Thread feedC =
+        new Thread(
+            () -> {
+              for (long i = 0; i < ROWS_PER_INPUT; i++) {
+                producerC.putRow(rowMeta, new Object[] {i});
+              }
+              producerC.finished();
+            });
+    feedC.start();
+    for (long i = 0; i < ROWS_PER_INPUT; i++) {
+      producerA.putRow(rowMeta, new Object[] {i});
+    }
+    producerA.finished();
+    feedC.join();
+    pipeline.waitUntilFinished();
+
+    assertEquals(0, pipeline.getErrors());
+    assertEquals(
+        2L * ROWS_PER_INPUT, pipeline.getTransform("B", 0).getLinesRead(), 
"rows read by B");
+    assertEquals(
+        2L * ROWS_PER_INPUT, pipeline.getTransform("B", 0).getLinesWritten(), 
"rows written by B");
+  }
+
+  /**
+   * A transform with 4 copies between two others: every copy counts each row 
it reads and writes
+   * exactly once, so the counts add up to the number of rows, not to an 
estimate.
+   */
+  @Test
+  @Timeout(60)
+  void countsEveryRowExactlyOnceAcrossCopies() throws Exception {
+    PipelineMeta pipelineMeta = new PipelineMeta();
+    pipelineMeta.setName("lock-free row sets copies test");
+    TransformMeta a = new TransformMeta("A", new DummyMeta());
+    TransformMeta b = new TransformMeta("B", new DummyMeta());
+    b.setCopies(4);
+    TransformMeta c = new TransformMeta("C", new DummyMeta());
+    pipelineMeta.addTransform(a);
+    pipelineMeta.addTransform(b);
+    pipelineMeta.addTransform(c);
+    pipelineMeta.addPipelineHop(new PipelineHopMeta(a, b));
+    pipelineMeta.addPipelineHop(new PipelineHopMeta(b, c));
+    LocalPipelineEngine pipeline =
+        new LocalPipelineEngine(pipelineMeta, new Variables(), new 
LoggingObject("test"));
+    LocalPipelineRunConfiguration config =
+        (LocalPipelineRunConfiguration)
+            pipeline.getPipelineRunConfiguration().getEngineRunConfiguration();
+    config.setRowSetSize("100");
+    config.setLockFreeRowSets(true);
+    pipeline.prepareExecution();
+    RowProducer producer = pipeline.addRowProducer("A", 0);
+    pipeline.startThreads();
+
+    IRowMeta rowMeta = new RowMeta();
+    rowMeta.addValueMeta(new ValueMetaInteger("id"));
+    long rows = 4L * ROWS_PER_INPUT + 3; // not a multiple of the copies
+    for (long i = 0; i < rows; i++) {
+      producer.putRow(rowMeta, new Object[] {i});
+    }
+    producer.finished();
+    pipeline.waitUntilFinished();
+
+    assertEquals(0, pipeline.getErrors());
+    assertEquals(rows, pipeline.getTransform("A", 0).getLinesWritten(), "rows 
written by A");
+    long readByB = 0;
+    long writtenByB = 0;
+    for (int copy = 0; copy < 4; copy++) {
+      readByB += pipeline.getTransform("B", copy).getLinesRead();
+      writtenByB += pipeline.getTransform("B", copy).getLinesWritten();
+    }
+    assertEquals(rows, readByB, "rows read by the copies of B");
+    assertEquals(rows, writtenByB, "rows written by the copies of B");
+    assertEquals(rows, pipeline.getTransform("C", 0).getLinesRead(), "rows 
read by C");
+    for (IRowSet rowSet : pipeline.getRowsets()) {
+      assertEquals(0, rowSet.size(), "rows left in " + rowSet);
+    }
+  }
+
+  /**
+   * One input finishes without rows, the other one sends bursts with idle 
gaps: the reader parks on
+   * its inputs in between and is woken by each burst and at the end.
+   */
+  @Test
+  @Timeout(60)
+  void readsBurstsWhileAnotherInputIsAlreadyDone() throws Exception {
+    LocalPipelineEngine pipeline = createPipeline(true);
+    pipeline.prepareExecution();
+    RowProducer producerA = pipeline.addRowProducer("A", 0);
+    RowProducer producerC = pipeline.addRowProducer("C", 0);
+    pipeline.startThreads();
+
+    producerC.finished();
+    IRowMeta rowMeta = new RowMeta();
+    rowMeta.addValueMeta(new ValueMetaInteger("id"));
+    int bursts = 5;
+    int rowsPerBurst = 1_000;
+    for (int b = 0; b < bursts; b++) {
+      for (long i = 0; i < rowsPerBurst; i++) {
+        producerA.putRow(rowMeta, new Object[] {i});
+      }
+      Thread.sleep(20);
+    }
+    producerA.finished();
+    pipeline.waitUntilFinished();
+
+    assertEquals(0, pipeline.getErrors());
+    assertEquals(
+        (long) bursts * rowsPerBurst,
+        pipeline.getTransform("B", 0).getLinesRead(),
+        "rows read by B");
+  }
+
+  @Test
+  void copyKeepsTheOption() {
+    LocalPipelineRunConfiguration config = new LocalPipelineRunConfiguration();
+    config.setLockFreeRowSets(true);
+    assertTrue(config.clone().isLockFreeRowSets());
+  }
+}
diff --git a/integration-tests/samples/hop-config.json 
b/integration-tests/samples/hop-config.json
index f28e08a022..d902c2b594 100644
--- a/integration-tests/samples/hop-config.json
+++ b/integration-tests/samples/hop-config.json
@@ -191,10 +191,6 @@
     "name" : "HOP_PIPELINE_ROWSET_SIZE",
     "value" : "",
     "description" : "Name of the environment variable that contains the size 
of the pipeline rowset size. This overwrites values that you set pipeline 
settings"
-  }, {
-    "name" : "HOP_BATCHING_ROWSET",
-    "value" : "N",
-    "description" : "Set this variable to 'Y' if you want to test a more 
efficient batching row set."
   }, {
     "name" : "HOP_LOG_MARK_MAPPINGS",
     "value" : "N",
diff --git 
a/ui/src/main/java/org/apache/hop/ui/pipeline/config/PipelineRunConfigurationEditor.java
 
b/ui/src/main/java/org/apache/hop/ui/pipeline/config/PipelineRunConfigurationEditor.java
index 9c8f306429..33395d0ff7 100644
--- 
a/ui/src/main/java/org/apache/hop/ui/pipeline/config/PipelineRunConfigurationEditor.java
+++ 
b/ui/src/main/java/org/apache/hop/ui/pipeline/config/PipelineRunConfigurationEditor.java
@@ -36,6 +36,7 @@ import 
org.apache.hop.pipeline.config.IPipelineEngineRunConfiguration;
 import org.apache.hop.pipeline.config.PipelineRunConfiguration;
 import org.apache.hop.pipeline.engine.IPipelineEngine;
 import org.apache.hop.pipeline.engine.PipelineEnginePluginType;
+import org.apache.hop.pipeline.engines.local.LocalPipelineRunConfiguration;
 import org.apache.hop.server.loadbalance.ILoadBalancingRunConfiguration;
 import org.apache.hop.ui.core.PropsUi;
 import org.apache.hop.ui.core.dialog.ErrorDialog;
@@ -447,6 +448,9 @@ public class PipelineRunConfigurationEditor extends 
MetadataEditor<PipelineRunCo
             @Override
             public void widgetModified(
                 GuiCompositeWidgets compositeWidgets, Control changedWidget, 
String widgetId) {
+              if 
(LocalPipelineRunConfiguration.WIDGET_ID_LOCK_FREE_ROWSETS.equals(widgetId)) {
+                enableLocalEngineWidgets();
+              }
               setChanged();
             }
           });
@@ -481,6 +485,7 @@ public class PipelineRunConfigurationEditor extends 
MetadataEditor<PipelineRunCo
                     engine,
                     wPluginSpecificComp,
                     PipelineRunConfiguration.GUI_PLUGIN_ELEMENT_PARENT_ID);
+                enableLocalEngineWidgets();
                 wPluginSpecificComp.layout(true, true);
                 updatePluginSpecificMinSize();
               }
@@ -491,6 +496,33 @@ public class PipelineRunConfigurationEditor extends 
MetadataEditor<PipelineRunCo
     updatePluginSpecificMinSize();
   }
 
+  /** The local engine does not use the wait time for buffer checks with 
lock-free row sets. */
+  private void enableLocalEngineWidgets() {
+    if (guiCompositeWidgets == null
+        || !(workingConfiguration.getEngineRunConfiguration()
+            instanceof LocalPipelineRunConfiguration)) {
+      return;
+    }
+    Control lockFree =
+        guiCompositeWidgets
+            .getWidgetsMap()
+            .get(LocalPipelineRunConfiguration.WIDGET_ID_LOCK_FREE_ROWSETS);
+    if (!(lockFree instanceof Button button) || button.isDisposed()) {
+      return;
+    }
+    boolean enabled = !button.getSelection();
+    Control waitTime =
+        
guiCompositeWidgets.getWidgetsMap().get(LocalPipelineRunConfiguration.WIDGET_ID_WAIT_TIME);
+    if (waitTime != null && !waitTime.isDisposed()) {
+      waitTime.setEnabled(enabled);
+    }
+    Control waitTimeLabel =
+        
guiCompositeWidgets.getLabelsMap().get(LocalPipelineRunConfiguration.WIDGET_ID_WAIT_TIME);
+    if (waitTimeLabel != null && !waitTimeLabel.isDisposed()) {
+      waitTimeLabel.setEnabled(enabled);
+    }
+  }
+
   private void updatePluginSpecificMinSize() {
     GuiCompositeWidgets.updateScrolledMinSize(wPluginSpecificComp);
   }
@@ -585,6 +617,7 @@ public class PipelineRunConfigurationEditor extends 
MetadataEditor<PipelineRunCo
             workingConfiguration.getEngineRunConfiguration(),
             wPluginSpecificComp,
             PipelineRunConfiguration.GUI_PLUGIN_ELEMENT_PARENT_ID);
+        enableLocalEngineWidgets();
         updatePluginSpecificMinSize();
       }
       if (loadBalancingWidgets != null
diff --git 
a/ui/src/main/resources/org/apache/hop/ui/pipeline/config/messages/messages_en_US.properties
 
b/ui/src/main/resources/org/apache/hop/ui/pipeline/config/messages/messages_en_US.properties
index 72c16f02b1..4a63f95492 100644
--- 
a/ui/src/main/resources/org/apache/hop/ui/pipeline/config/messages/messages_en_US.properties
+++ 
b/ui/src/main/resources/org/apache/hop/ui/pipeline/config/messages/messages_en_US.properties
@@ -49,6 +49,8 @@ PipelineRunConfigurationDialog.Variables.Column.Name=Variable 
name
 PipelineRunConfigurationDialog.Variables.Column.Value=Value
 PipelineRunConfigurationDialog.VariablesTab.TabTitle=Variables
 PipelineRunConfigurationDialog.WaitTime.Label=Wait time for buffer check (ms)
+PipelineRunConfigurationDialog.LockFreeRowSets.Label=Lock-free row sets 
(experimental)
+PipelineRunConfigurationDialog.LockFreeRowSets.ToolTip=Experimental 
performance option: pass rows between transforms through lock-free buffers that 
wake the reading transform once a batch of rows is ready, instead of the 
lock-based buffers. A transform with several inputs waits on all of them at 
once and is woken by whichever has rows. This lowers the cost per row for fast 
transforms. The wait time for buffer checks is not used with this option. Hops 
that spill to disk to avoid a buffer  [...]
 PipelineRunConfigurationDialog.DetectBufferDeadlocks.Label=Detect buffer 
deadlocks
 PipelineRunConfigurationDialog.DetectBufferDeadlocks.ToolTip=Analyze the 
pipeline for split-rejoin topologies that can deadlock on bounded rowsets 
(classic local engine). Findings are logged during prepare. Enabled by default.
 PipelineRunConfigurationDialog.MitigateBufferDeadlocks.Label=Mitigate buffer 
deadlocks (spill to disk)
diff --git a/web-tests/src/test/resources/hop-config.json 
b/web-tests/src/test/resources/hop-config.json
index 22a61381d3..b45a96d9b7 100644
--- a/web-tests/src/test/resources/hop-config.json
+++ b/web-tests/src/test/resources/hop-config.json
@@ -15,10 +15,6 @@
     "name" : "HOP_AUTO_CREATE_CONFIG",
     "value" : "Y",
     "description" : "Set this value to N if you don't want to automatically 
create a hop configuration file (hop-config.json) when it's missing\n    "
-  }, {
-    "name" : "HOP_BATCHING_ROWSET",
-    "value" : "",
-    "description" : "Set this variable to 'Y' if you want to test a more 
efficient batching row set."
   }, {
     "name" : "HOP_COMPATIBILITY_CALCULATION_TIMEZONE_DECOMPOSITION",
     "value" : "N",

Reply via email to