Improve RowSetBuilderSequential performance when adding keys from a…

… chunk (#2856) * hack for improving performance for RowSetBuilderSequential * refactored function calls
deephaven · Sep 16, 2022 · d9ba97e · d9ba97e
1 parent 7ec6315
commit d9ba97e
Show file tree

Hide file tree

Showing 5 changed files with 84 additions and 4 deletions.
diff --git a/engine/rowset/src/main/java/io/deephaven/engine/rowset/RowSetBuilderRandom.java b/engine/rowset/src/main/java/io/deephaven/engine/rowset/RowSetBuilderRandom.java
@@ -50,6 +50,10 @@ default void addOrderedRowKeysChunk(final LongChunk<? extends OrderedRowKeys> ch
         addRowKeysChunk(chunk);
     }
 
+    default void addOrderedRowKeysChunk(final LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+        addKeys(new LongChunkIterator(chunk, offset, length));
+    }
+
     default void addOrderedRowKeysChunk(final IntChunk<? extends OrderedRowKeys> chunk) {
         addRowKeysChunk(chunk);
     }

diff --git a/engine/rowset/src/main/java/io/deephaven/engine/rowset/RowSetBuilderSequential.java b/engine/rowset/src/main/java/io/deephaven/engine/rowset/RowSetBuilderSequential.java
@@ -43,7 +43,11 @@ default void appendKeys(PrimitiveIterator.OfLong it) {
     }
 
     default void appendOrderedRowKeysChunk(final LongChunk<OrderedRowKeys> chunk) {
-        appendKeys(new LongChunkIterator(chunk));
+        appendOrderedRowKeysChunk(chunk, 0, chunk.size());
+    }
+
+    default void appendOrderedRowKeysChunk(final LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+        appendKeys(new LongChunkIterator(chunk, offset, length));
     }
 
     default void appendRanges(final LongRangeIterator it) {

diff --git a/engine/rowset/src/main/java/io/deephaven/engine/rowset/impl/OrderedLongSet.java b/engine/rowset/src/main/java/io/deephaven/engine/rowset/impl/OrderedLongSet.java
@@ -3,6 +3,7 @@
  */
 package io.deephaven.engine.rowset.impl;
 
+import io.deephaven.chunk.util.LongChunkIterator;
 import io.deephaven.configuration.Configuration;
 import io.deephaven.engine.rowset.RowSequenceFactory;
 import io.deephaven.engine.rowset.RowSet;
@@ -489,6 +490,13 @@ default void appendOrderedLongSet(final long shiftAmount, final OrderedLongSet i
             });
         }
 
+        default void appendOrderedRowKeysChunk(LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+            LongChunkIterator it = new LongChunkIterator(chunk, offset, length);
+            while (it.hasNext()) {
+                appendKey(it.nextLong());
+            }
+        }
+
         @Override
         default void accept(final long firstKey, final long lastKey) {
             appendRange(firstKey, lastKey);

diff --git a/...rowset/src/main/java/io/deephaven/engine/rowset/impl/OrderedLongSetBuilderSequential.java b/...rowset/src/main/java/io/deephaven/engine/rowset/impl/OrderedLongSetBuilderSequential.java
@@ -3,9 +3,9 @@
  */
 package io.deephaven.engine.rowset.impl;
 
-import io.deephaven.engine.rowset.impl.singlerange.*;
-import io.deephaven.engine.rowset.impl.sortedranges.SortedRanges;
 import io.deephaven.engine.rowset.impl.rsp.RspBitmap;
+import io.deephaven.engine.rowset.impl.singlerange.SingleRange;
+import io.deephaven.engine.rowset.impl.sortedranges.SortedRanges;
 import io.deephaven.util.annotations.TestUseOnly;
 
 public class OrderedLongSetBuilderSequential extends RspBitmapBuilderSequential {

diff --git a/engine/rowset/src/main/java/io/deephaven/engine/rowset/impl/RspBitmapBuilderSequential.java b/engine/rowset/src/main/java/io/deephaven/engine/rowset/impl/RspBitmapBuilderSequential.java
@@ -3,8 +3,10 @@
  */
 package io.deephaven.engine.rowset.impl;
 
+import io.deephaven.chunk.LongChunk;
+import io.deephaven.chunk.util.LongChunkIterator;
 import io.deephaven.engine.rowset.RowSequence;
-import io.deephaven.engine.rowset.impl.OrderedLongSet;
+import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.engine.rowset.impl.rsp.DisposableRspBitmap;
 import io.deephaven.engine.rowset.impl.rsp.RspArray;
 import io.deephaven.engine.rowset.impl.rsp.RspBitmap;
@@ -119,6 +121,68 @@ public void appendOrderedLongSet(final long shiftAmount, final OrderedLongSet ix
         rb.appendShiftedUnsafeNoWriteCheck(shiftAmount, (RspBitmap) ix, acquire);
     }
 
+    @Override
+    public void appendOrderedRowKeysChunk(LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+        if (length == 0) {
+            return;
+        }
+
+        if (rb != null) {
+            appendKeyChunkRb(chunk, offset, length);
+        } else {
+            appendKeyChunk(chunk, offset, length);
+        }
+    }
+
+    private void appendKeyChunkRb(LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+        // flush to the rb before appending
+        if (pendingStart != -1) {
+            flushPendingRange();
+        }
+        if (pendingContainerKey != -1) {
+            flushPendingContainer();
+        }
+
+        // single key?
+        if (length == 1) {
+            rb.appendUnsafeNoWriteCheck(chunk.get(offset));
+            return;
+        }
+
+        // single range?
+        final int lastOffsetInclusive = offset + length - 1;
+        final long first = chunk.get(offset);
+        final long last = chunk.get(lastOffsetInclusive);
+        if (last - first + 1 == length) {
+            rb.appendRangeUnsafeNoWriteCheck(first, last);
+            return;
+        }
+
+        rb.addValuesUnsafeNoWriteCheck(chunk, offset, length);
+    }
+
+    private void appendKeyChunk(LongChunk<OrderedRowKeys> chunk, int offset, int length) {
+        // single key?
+        if (length == 1) {
+            appendKey(chunk.get(offset));
+            return;
+        }
+
+        // single range?
+        final int lastOffsetInclusive = offset + length - 1;
+        final long first = chunk.get(offset);
+        final long last = chunk.get(lastOffsetInclusive);
+        if (last - first + 1 == length) {
+            appendRange(first, last);
+            return;
+        }
+
+        final LongChunkIterator it = new LongChunkIterator(chunk, offset, length);
+        while (it.hasNext()) {
+            appendKey(it.nextLong());
+        }
+    }
+
     protected void flushPendingRange() {
         final long pendingStartOnEntry = pendingStart;
         pendingStart = -1;