From 5db2b064a611de7c96b73775df82009642982a3c Mon Sep 17 00:00:00 2001 From: Nhat Nguyen Date: Fri, 8 Mar 2024 18:10:12 -0800 Subject: [PATCH] Reduce internal states of Block (#106145) Currently, all Blocks inherit from AbstractBlock, resulting in every Block having fields such as positionCount, firstValueIndexes, and nullsMask, which are specific to array blocks.. This change moves these fields to AbstractArrayBlock and removes AbstractBlock. --- .../compute/data/BooleanArrayBlock.java | 19 +-- .../compute/data/BooleanBigArrayBlock.java | 19 +-- .../compute/data/BooleanVectorBlock.java | 3 +- .../compute/data/BytesRefArrayBlock.java | 19 +-- .../compute/data/BytesRefVectorBlock.java | 3 +- .../compute/data/DoubleArrayBlock.java | 19 +-- .../compute/data/DoubleBigArrayBlock.java | 19 +-- .../compute/data/DoubleVectorBlock.java | 3 +- .../compute/data/IntArrayBlock.java | 19 +-- .../compute/data/IntBigArrayBlock.java | 19 +-- .../compute/data/IntVectorBlock.java | 3 +- .../compute/data/LongArrayBlock.java | 19 +-- .../compute/data/LongBigArrayBlock.java | 19 +-- .../compute/data/LongVectorBlock.java | 3 +- .../compute/data/AbstractArrayBlock.java | 97 ++++++++++--- .../compute/data/AbstractBlock.java | 127 ------------------ .../data/AbstractNonThreadSafeRefCounted.java | 4 + .../compute/data/AbstractVector.java | 5 - .../compute/data/AbstractVectorBlock.java | 23 ++-- .../compute/data/ConstantNullBlock.java | 43 +++++- .../elasticsearch/compute/data/DocBlock.java | 11 +- .../compute/data/X-ArrayBlock.java.st | 19 +-- .../compute/data/X-BigArrayBlock.java.st | 19 +-- .../compute/data/X-VectorBlock.java.st | 3 +- 24 files changed, 261 insertions(+), 276 deletions(-) delete mode 100644 x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlock.java diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java index 666f1ad926eeb..45b5c09fdc01e 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanArrayBlock.java @@ -35,20 +35,18 @@ final class BooleanArrayBlock extends AbstractArrayBlock implements BooleanBlock positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private BooleanArrayBlock( - BooleanArrayVector vector, + BooleanArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -115,8 +113,7 @@ public BooleanBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -160,10 +157,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBigArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBigArrayBlock.java index a19ed24302b65..890e6b6a59acd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBigArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanBigArrayBlock.java @@ -36,20 +36,18 @@ public BooleanBigArrayBlock( positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private BooleanBigArrayBlock( - BooleanBigArrayVector vector, + BooleanBigArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -116,8 +114,7 @@ public BooleanBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -161,10 +158,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBlock.java index d707e3cf901c1..a42e9b148064d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BooleanVectorBlock.java @@ -21,7 +21,6 @@ public final class BooleanVectorBlock extends AbstractVectorBlock implements Boo * @param vector considered owned by the current block; must not be used in any other {@code Block} */ BooleanVectorBlock(BooleanVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -36,7 +35,7 @@ public boolean getBoolean(int valueIndex) { } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java index 69e5499eaba46..d71afdbdee2df 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefArrayBlock.java @@ -38,20 +38,18 @@ final class BytesRefArrayBlock extends AbstractArrayBlock implements BytesRefBlo positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private BytesRefArrayBlock( - BytesRefArrayVector vector, + BytesRefArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -119,8 +117,7 @@ public BytesRefBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -164,10 +161,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBlock.java index 92f93d5d23a49..1a077f38385e3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/BytesRefVectorBlock.java @@ -22,7 +22,6 @@ public final class BytesRefVectorBlock extends AbstractVectorBlock implements By * @param vector considered owned by the current block; must not be used in any other {@code Block} */ BytesRefVectorBlock(BytesRefVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -37,7 +36,7 @@ public BytesRef getBytesRef(int valueIndex, BytesRef dest) { } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java index b5f5c69e0508a..e9ddabb878b8d 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleArrayBlock.java @@ -35,20 +35,18 @@ final class DoubleArrayBlock extends AbstractArrayBlock implements DoubleBlock { positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private DoubleArrayBlock( - DoubleArrayVector vector, + DoubleArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -115,8 +113,7 @@ public DoubleBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -160,10 +157,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBigArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBigArrayBlock.java index 39f959edf5ee3..702499513a0c3 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBigArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleBigArrayBlock.java @@ -36,20 +36,18 @@ public DoubleBigArrayBlock( positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private DoubleBigArrayBlock( - DoubleBigArrayVector vector, + DoubleBigArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -116,8 +114,7 @@ public DoubleBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -161,10 +158,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBlock.java index 2aa8e07c25604..647849a968df9 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/DoubleVectorBlock.java @@ -21,7 +21,6 @@ public final class DoubleVectorBlock extends AbstractVectorBlock implements Doub * @param vector considered owned by the current block; must not be used in any other {@code Block} */ DoubleVectorBlock(DoubleVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -36,7 +35,7 @@ public double getDouble(int valueIndex) { } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java index 2afefbff16117..1470a85f615d1 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntArrayBlock.java @@ -35,20 +35,18 @@ final class IntArrayBlock extends AbstractArrayBlock implements IntBlock { positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private IntArrayBlock( - IntArrayVector vector, + IntArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -115,8 +113,7 @@ public IntBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -160,10 +157,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBigArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBigArrayBlock.java index dc60ce43c04cc..5e29dace7449c 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBigArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntBigArrayBlock.java @@ -36,20 +36,18 @@ public IntBigArrayBlock( positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private IntBigArrayBlock( - IntBigArrayVector vector, + IntBigArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -116,8 +114,7 @@ public IntBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -161,10 +158,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBlock.java index 97a4a48533e3a..4f9bb236dfa80 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/IntVectorBlock.java @@ -21,7 +21,6 @@ public final class IntVectorBlock extends AbstractVectorBlock implements IntBloc * @param vector considered owned by the current block; must not be used in any other {@code Block} */ IntVectorBlock(IntVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -36,7 +35,7 @@ public int getInt(int valueIndex) { } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); } diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java index 7491d6519fc57..2406196ba8bdd 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongArrayBlock.java @@ -35,20 +35,18 @@ final class LongArrayBlock extends AbstractArrayBlock implements LongBlock { positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private LongArrayBlock( - LongArrayVector vector, + LongArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -115,8 +113,7 @@ public LongBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -160,10 +157,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBigArrayBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBigArrayBlock.java index 3ff9a12991d43..f4b1f16566d24 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBigArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongBigArrayBlock.java @@ -36,20 +36,18 @@ public LongBigArrayBlock( positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private LongBigArrayBlock( - LongBigArrayVector vector, + LongBigArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -116,8 +114,7 @@ public LongBlock expand() { expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -161,10 +158,14 @@ public String toString() { @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBlock.java b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBlock.java index 1f4565fec5a8d..0d7d1f691837f 100644 --- a/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/data/LongVectorBlock.java @@ -21,7 +21,6 @@ public final class LongVectorBlock extends AbstractVectorBlock implements LongBl * @param vector considered owned by the current block; must not be used in any other {@code Block} */ LongVectorBlock(LongVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -36,7 +35,7 @@ public long getLong(int valueIndex) { } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractArrayBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractArrayBlock.java index d6046f0bda085..46e1ee1fc8983 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractArrayBlock.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractArrayBlock.java @@ -11,34 +11,30 @@ import java.util.BitSet; -abstract class AbstractArrayBlock extends AbstractBlock { - +abstract class AbstractArrayBlock extends AbstractNonThreadSafeRefCounted implements Block { private final MvOrdering mvOrdering; + protected final int positionCount; - /** - * @param positionCount the number of values in this block - */ - protected AbstractArrayBlock(int positionCount, MvOrdering mvOrdering, BlockFactory blockFactory) { - super(positionCount, blockFactory); - this.mvOrdering = mvOrdering; - } + @Nullable + protected final int[] firstValueIndexes; + + @Nullable + protected final BitSet nullsMask; /** * @param positionCount the number of values in this block */ - protected AbstractArrayBlock( - int positionCount, - @Nullable int[] firstValueIndexes, - @Nullable BitSet nullsMask, - MvOrdering mvOrdering, - BlockFactory blockFactory - ) { - super(positionCount, firstValueIndexes, nullsMask, blockFactory); + protected AbstractArrayBlock(int positionCount, @Nullable int[] firstValueIndexes, @Nullable BitSet nullsMask, MvOrdering mvOrdering) { + this.positionCount = positionCount; + this.firstValueIndexes = firstValueIndexes; this.mvOrdering = mvOrdering; + this.nullsMask = nullsMask == null || nullsMask.isEmpty() ? null : nullsMask; + assert nullsMask != null || firstValueIndexes != null : "Create VectorBlock instead"; + assert assertInvariants(); } @Override - public boolean mayHaveMultivaluedFields() { + public final boolean mayHaveMultivaluedFields() { /* * This could return a false positive if all the indices are one away from * each other. But we will try to avoid that. @@ -51,7 +47,7 @@ public final MvOrdering mvOrdering() { return mvOrdering; } - protected BitSet shiftNullsToExpandedPositions() { + protected final BitSet shiftNullsToExpandedPositions() { BitSet expanded = new BitSet(nullsMask.size()); int next = -1; while ((next = nullsMask.nextSetBit(next + 1)) != -1) { @@ -59,4 +55,67 @@ protected BitSet shiftNullsToExpandedPositions() { } return expanded; } + + private boolean assertInvariants() { + if (firstValueIndexes != null) { + assert firstValueIndexes.length == getPositionCount() + 1; + for (int i = 0; i < getPositionCount(); i++) { + assert (firstValueIndexes[i + 1] - firstValueIndexes[i]) >= 0; + } + } + if (nullsMask != null) { + assert nullsMask.nextSetBit(getPositionCount() + 1) == -1; + } + if (firstValueIndexes != null && nullsMask != null) { + for (int i = 0; i < getPositionCount(); i++) { + // Either we have multi-values or a null but never both. + assert ((nullsMask.get(i) == false) || (firstValueIndexes[i + 1] - firstValueIndexes[i]) == 1); + } + } + return true; + } + + @Override + public final int getTotalValueCount() { + if (firstValueIndexes == null) { + return positionCount - nullValuesCount(); + } + return firstValueIndexes[positionCount] - nullValuesCount(); + } + + @Override + public final int getPositionCount() { + return positionCount; + } + + /** Gets the index of the first value for the given position. */ + public final int getFirstValueIndex(int position) { + return firstValueIndexes == null ? position : firstValueIndexes[position]; + } + + /** Gets the number of values for the given position, possibly 0. */ + @Override + public final int getValueCount(int position) { + return isNull(position) ? 0 : firstValueIndexes == null ? 1 : firstValueIndexes[position + 1] - firstValueIndexes[position]; + } + + @Override + public final boolean isNull(int position) { + return mayHaveNulls() && nullsMask.get(position); + } + + @Override + public final boolean mayHaveNulls() { + return nullsMask != null; + } + + @Override + public final int nullValuesCount() { + return mayHaveNulls() ? nullsMask.cardinality() : 0; + } + + @Override + public final boolean areAllValuesNull() { + return nullValuesCount() == getPositionCount(); + } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlock.java deleted file mode 100644 index 0c5207133f71d..0000000000000 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractBlock.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License - * 2.0; you may not use this file except in compliance with the Elastic License - * 2.0. - */ - -package org.elasticsearch.compute.data; - -import org.elasticsearch.core.Nullable; - -import java.util.BitSet; - -abstract class AbstractBlock extends AbstractNonThreadSafeRefCounted implements Block { - private final int positionCount; - - @Nullable - protected final int[] firstValueIndexes; - - @Nullable - protected final BitSet nullsMask; - - private BlockFactory blockFactory; - - /** - * @param positionCount the number of values in this block - */ - protected AbstractBlock(int positionCount, BlockFactory blockFactory) { - assert positionCount >= 0; - this.positionCount = positionCount; - this.blockFactory = blockFactory; - this.firstValueIndexes = null; - this.nullsMask = null; - assert assertInvariants(); - } - - /** - * @param positionCount the number of values in this block - */ - protected AbstractBlock(int positionCount, @Nullable int[] firstValueIndexes, @Nullable BitSet nullsMask, BlockFactory blockFactory) { - assert positionCount >= 0; - this.positionCount = positionCount; - this.blockFactory = blockFactory; - this.firstValueIndexes = firstValueIndexes; - this.nullsMask = nullsMask == null || nullsMask.isEmpty() ? null : nullsMask; - assert nullsMask != null || firstValueIndexes != null : "Create VectorBlock instead"; - assert assertInvariants(); - } - - private boolean assertInvariants() { - if (firstValueIndexes != null) { - assert firstValueIndexes.length == getPositionCount() + 1; - for (int i = 0; i < getPositionCount(); i++) { - assert (firstValueIndexes[i + 1] - firstValueIndexes[i]) >= 0; - } - } - if (nullsMask != null) { - assert nullsMask.nextSetBit(getPositionCount() + 1) == -1; - } - if (firstValueIndexes != null && nullsMask != null) { - for (int i = 0; i < getPositionCount(); i++) { - // Either we have multi-values or a null but never both. - assert ((nullsMask.get(i) == false) || (firstValueIndexes[i + 1] - firstValueIndexes[i]) == 1); - } - } - return true; - } - - @Override - public int getTotalValueCount() { - if (firstValueIndexes == null) { - return positionCount - nullValuesCount(); - } - return firstValueIndexes[positionCount] - nullValuesCount(); - } - - @Override - public final int getPositionCount() { - return positionCount; - } - - /** Gets the index of the first value for the given position. */ - public int getFirstValueIndex(int position) { - return firstValueIndexes == null ? position : firstValueIndexes[position]; - } - - /** Gets the number of values for the given position, possibly 0. */ - @Override - public int getValueCount(int position) { - return isNull(position) ? 0 : firstValueIndexes == null ? 1 : firstValueIndexes[position + 1] - firstValueIndexes[position]; - } - - @Override - public boolean isNull(int position) { - return mayHaveNulls() && nullsMask.get(position); - } - - @Override - public boolean mayHaveNulls() { - return nullsMask != null; - } - - @Override - public int nullValuesCount() { - return mayHaveNulls() ? nullsMask.cardinality() : 0; - } - - @Override - public boolean areAllValuesNull() { - return nullValuesCount() == getPositionCount(); - } - - @Override - public BlockFactory blockFactory() { - return blockFactory; - } - - @Override - public void allowPassingToDifferentDriver() { - blockFactory = blockFactory.parent(); - } - - @Override - public final boolean isReleased() { - return hasReferences() == false; - } -} diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractNonThreadSafeRefCounted.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractNonThreadSafeRefCounted.java index 2dfd8c3eca5ac..ea023c6b46d9e 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractNonThreadSafeRefCounted.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractNonThreadSafeRefCounted.java @@ -59,6 +59,10 @@ public final void close() { decRef(); } + public final boolean isReleased() { + return hasReferences() == false; + } + /** * This is called when the number of references reaches zero. * This is where resources should be released (adjusting circuit breakers if needed). diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVector.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVector.java index 1eb2c09f78511..1e1f8bbf2f8df 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVector.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVector.java @@ -43,9 +43,4 @@ public void allowPassingToDifferentDriver() { protected void closeInternal() { blockFactory.adjustBreaker(-ramBytesUsed()); } - - @Override - public final boolean isReleased() { - return hasReferences() == false; - } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java index d33d1a1afda41..452bdad1ab192 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/AbstractVectorBlock.java @@ -10,43 +10,44 @@ /** * A Block view of a Vector. */ -abstract class AbstractVectorBlock extends AbstractBlock { +abstract class AbstractVectorBlock extends AbstractNonThreadSafeRefCounted implements Block { - AbstractVectorBlock(int positionCount, BlockFactory blockFactory) { - super(positionCount, blockFactory); + @Override + public final int getFirstValueIndex(int position) { + return position; } @Override - public int getFirstValueIndex(int position) { - return position; + public final int getTotalValueCount() { + return getPositionCount(); } - public int getValueCount(int position) { + public final int getValueCount(int position) { return 1; } @Override - public boolean isNull(int position) { + public final boolean isNull(int position) { return false; } @Override - public int nullValuesCount() { + public final int nullValuesCount() { return 0; } @Override - public boolean mayHaveNulls() { + public final boolean mayHaveNulls() { return false; } @Override - public boolean areAllValuesNull() { + public final boolean areAllValuesNull() { return false; } @Override - public boolean mayHaveMultivaluedFields() { + public final boolean mayHaveMultivaluedFields() { return false; } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java index b093e3edd5884..eb86d01fbdf3c 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/ConstantNullBlock.java @@ -18,12 +18,21 @@ /** * Block implementation representing a constant null value. */ -final class ConstantNullBlock extends AbstractBlock implements BooleanBlock, IntBlock, LongBlock, DoubleBlock, BytesRefBlock { +final class ConstantNullBlock extends AbstractNonThreadSafeRefCounted + implements + BooleanBlock, + IntBlock, + LongBlock, + DoubleBlock, + BytesRefBlock { private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(ConstantNullBlock.class); + private final int positionCount; + private BlockFactory blockFactory; ConstantNullBlock(int positionCount, BlockFactory blockFactory) { - super(positionCount, blockFactory); + this.positionCount = positionCount; + this.blockFactory = blockFactory; } @Override @@ -222,4 +231,34 @@ public long getLong(int valueIndex) { assert false : "null block"; throw new UnsupportedOperationException("null block"); } + + @Override + public int getTotalValueCount() { + return 0; + } + + @Override + public int getPositionCount() { + return positionCount; + } + + @Override + public int getFirstValueIndex(int position) { + return 0; + } + + @Override + public int getValueCount(int position) { + return 0; + } + + @Override + public BlockFactory blockFactory() { + return blockFactory; + } + + @Override + public void allowPassingToDifferentDriver() { + blockFactory = blockFactory.parent(); + } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java index 8c75c8216c59e..a58b8c34b17d5 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/DocBlock.java @@ -20,7 +20,6 @@ public class DocBlock extends AbstractVectorBlock implements Block { private final DocVector vector; DocBlock(DocVector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -190,4 +189,14 @@ public void close() { public void allowPassingToDifferentDriver() { vector.allowPassingToDifferentDriver(); } + + @Override + public int getPositionCount() { + return vector.getPositionCount(); + } + + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } } diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st index 20395ff27b1b4..019379821dbaf 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-ArrayBlock.java.st @@ -46,20 +46,18 @@ final class $Type$ArrayBlock extends AbstractArrayBlock implements $Type$Block { positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private $Type$ArrayBlock( - $Type$ArrayVector vector, + $Type$ArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -134,8 +132,7 @@ $endif$ expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -179,10 +176,14 @@ $endif$ @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BigArrayBlock.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BigArrayBlock.java.st index d65c54b5e2b24..14ec5382f282c 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BigArrayBlock.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-BigArrayBlock.java.st @@ -36,20 +36,18 @@ public final class $Type$BigArrayBlock extends AbstractArrayBlock implements $Ty positionCount, firstValueIndexes, nulls, - mvOrdering, - blockFactory + mvOrdering ); } private $Type$BigArrayBlock( - $Type$BigArrayVector vector, + $Type$BigArrayVector vector, // stylecheck int positionCount, int[] firstValueIndexes, BitSet nulls, - MvOrdering mvOrdering, - BlockFactory blockFactory + MvOrdering mvOrdering ) { - super(positionCount, firstValueIndexes, nulls, mvOrdering, blockFactory); + super(positionCount, firstValueIndexes, nulls, mvOrdering); this.vector = vector; assert firstValueIndexes == null ? vector.getPositionCount() == getPositionCount() @@ -116,8 +114,7 @@ public final class $Type$BigArrayBlock extends AbstractArrayBlock implements $Ty expandedPositionCount, null, shiftNullsToExpandedPositions(), - MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING, - blockFactory() + MvOrdering.DEDUPLICATED_AND_SORTED_ASCENDING ); blockFactory().adjustBreaker(expanded.ramBytesUsedOnlyBlock() - bitSetRamUsedEstimate); // We need to incRef after adjusting any breakers, otherwise we might leak the vector if the breaker trips. @@ -161,10 +158,14 @@ public final class $Type$BigArrayBlock extends AbstractArrayBlock implements $Ty @Override public void allowPassingToDifferentDriver() { - super.allowPassingToDifferentDriver(); vector.allowPassingToDifferentDriver(); } + @Override + public BlockFactory blockFactory() { + return vector.blockFactory(); + } + @Override public void closeInternal() { blockFactory().adjustBreaker(-ramBytesUsedOnlyBlock()); diff --git a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBlock.java.st b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBlock.java.st index 4bc3c66b65743..e3d696ddf9120 100644 --- a/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBlock.java.st +++ b/x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/X-VectorBlock.java.st @@ -24,7 +24,6 @@ public final class $Type$VectorBlock extends AbstractVectorBlock implements $Typ * @param vector considered owned by the current block; must not be used in any other {@code Block} */ $Type$VectorBlock($Type$Vector vector) { - super(vector.getPositionCount(), vector.blockFactory()); this.vector = vector; } @@ -44,7 +43,7 @@ $endif$ } @Override - public int getTotalValueCount() { + public int getPositionCount() { return vector.getPositionCount(); }