From 7e5ab4f2ba2220f904205d80041740a1052396d9 Mon Sep 17 00:00:00 2001 From: ViggoC Date: Tue, 10 Dec 2024 23:34:28 +0800 Subject: [PATCH 1/5] add VariableWidthViewVectorBenchmarks --- .../vector/VariableWidthVectorBenchmarks.java | 11 +- .../VariableWidthViewVectorBenchmarks.java | 130 ++++++++++++++++++ .../vector/BaseVariableWidthViewVector.java | 20 +-- 3 files changed, 150 insertions(+), 11 deletions(-) create mode 100644 performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java index 0bce6569d..3249918b4 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java @@ -23,8 +23,10 @@ import org.apache.arrow.vector.holders.NullableVarCharHolder; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Level; import org.openjdk.jmh.annotations.Mode; import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -52,8 +54,11 @@ public class VariableWidthVectorBenchmarks { private VarCharVector vector; + @Param({"1", "2", "10", "40"}) + private int step; + /** Setup benchmarks. */ - @Setup + @Setup(Level.Iteration) public void prepare() { allocator = new RootAllocator(ALLOCATOR_CAPACITY); vector = new VarCharVector("vector", allocator); @@ -63,7 +68,7 @@ public void prepare() { } /** Tear down benchmarks. */ - @TearDown + @TearDown(Level.Iteration) public void tearDown() { arrowBuff.close(); vector.close(); @@ -87,7 +92,7 @@ public int getValueCapacity() { @OutputTimeUnit(TimeUnit.MILLISECONDS) public int setSafeFromArray() { for (int i = 0; i < 500; ++i) { - vector.setSafe(i * 40, bytes); + vector.setSafe(i * step, bytes); } return vector.getBufferSize(); } diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java new file mode 100644 index 000000000..9a04f868e --- /dev/null +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java @@ -0,0 +1,130 @@ +/* + * 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.arrow.vector; + +import java.util.concurrent.TimeUnit; +import org.apache.arrow.memory.ArrowBuf; +import org.apache.arrow.memory.BufferAllocator; +import org.apache.arrow.memory.RootAllocator; +import org.apache.arrow.vector.holders.NullableViewVarCharHolder; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +/** Benchmarks for {@link BaseVariableWidthVector}. */ +@State(Scope.Benchmark) +public class VariableWidthViewVectorBenchmarks { + // checkstyle:off: MissingJavadocMethod + + private static final int VECTOR_CAPACITY = 16 * 1024; + + private static final int VECTOR_LENGTH = 1024; + + private static final int ALLOCATOR_CAPACITY = 1024 * 1024; + + private static byte[] bytes = VariableWidthVectorBenchmarks.class.getName().getBytes(); + private ArrowBuf arrowBuff; + + private BufferAllocator allocator; + + private ViewVarCharVector vector; + + @Param({"1", "2", "10", "40"}) + private int step; + + /** Setup benchmarks. */ + @Setup(Level.Iteration) + public void prepare() { + allocator = new RootAllocator(); + vector = new ViewVarCharVector("vector", allocator); + vector.allocateNew(VECTOR_CAPACITY, VECTOR_LENGTH); + arrowBuff = allocator.buffer(VECTOR_LENGTH); + arrowBuff.setBytes(0, bytes, 0, bytes.length); + } + + /** Tear down benchmarks. */ + @TearDown(Level.Iteration) + public void tearDown() { + arrowBuff.close(); + vector.close(); + allocator.close(); + } + + /** + * Test {@link BaseVariableWidthVector#getValueCapacity()}. + * + * @return useless. To avoid DCE by JIT. + */ + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int getValueCapacity() { + return vector.getValueCapacity(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromArray() { + for (int i = 0; i < 500; ++i) { + vector.setSafe(i * step, bytes); + } + return vector.getBufferSize(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromNullableVarcharHolder() { + NullableViewVarCharHolder nvch = new NullableViewVarCharHolder(); + nvch.buffer = arrowBuff; + nvch.start = 0; + nvch.end = bytes.length; + for (int i = 0; i < 50; ++i) { + nvch.isSet = 0; + for (int j = 0; j < 9; ++j) { + int idx = 10 * i + j; + vector.setSafe(idx, nvch); + } + nvch.isSet = 1; + vector.setSafe(10 * (i + 1), nvch); + } + return vector.getBufferSize(); + } + + public static void main(String[] args) throws RunnerException { + Options opt = + new OptionsBuilder() + .include(VariableWidthViewVectorBenchmarks.class.getSimpleName()) + .forks(1) + .build(); + + new Runner(opt).run(); + } + // checkstyle:on: MissingJavadocMethod +} diff --git a/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java b/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java index 15d218278..1ad2144c5 100644 --- a/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java +++ b/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java @@ -1367,11 +1367,13 @@ protected ArrowBuf allocateOrGetLastDataBuffer(int length) { protected final void setBytes(int index, byte[] value, int start, int length) { int writePosition = index * ELEMENT_SIZE; - // to clear the memory segment of view being written to - // this is helpful in case of overwriting the value - viewBuffer.setZero(writePosition, ELEMENT_SIZE); - if (length <= INLINE_SIZE) { + // to clear the memory segment of view being written to + // if it has been set + if (viewBuffer.getLong(writePosition) != 0 || viewBuffer.getLong(writePosition + 8) != 0) { + viewBuffer.setZero(writePosition, ELEMENT_SIZE); + } + // allocate inline buffer // set length viewBuffer.setInt(writePosition, length); @@ -1411,11 +1413,13 @@ protected final void setBytes(int index, byte[] value, int start, int length) { protected final void setBytes(int index, ArrowBuf valueBuf, int start, int length) { int writePosition = index * ELEMENT_SIZE; - // to clear the memory segment of view being written to - // this is helpful in case of overwriting the value - viewBuffer.setZero(writePosition, ELEMENT_SIZE); - if (length <= INLINE_SIZE) { + // to clear the memory segment of view being written to + // if it has been set + if (viewBuffer.getLong(writePosition) != 0 || viewBuffer.getLong(writePosition + 8) != 0) { + viewBuffer.setZero(writePosition, ELEMENT_SIZE); + } + // allocate inline buffer // set length viewBuffer.setInt(writePosition, length); From 44778c00fae6a2b0d7903b8a4d4f5a734c49c549 Mon Sep 17 00:00:00 2001 From: ViggoC Date: Thu, 23 Jan 2025 23:55:34 +0800 Subject: [PATCH 2/5] add VariableWidthViewVectorInlineValueBenchmarks --- ...iableWidthVectorInlineValueBenchmarks.java | 131 ++++++++++++++++++ ...eWidthViewVectorInlineValueBenchmarks.java | 131 ++++++++++++++++++ .../vector/BaseVariableWidthViewVector.java | 20 ++- 3 files changed, 270 insertions(+), 12 deletions(-) create mode 100644 performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java create mode 100644 performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java new file mode 100644 index 000000000..54433eb2f --- /dev/null +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java @@ -0,0 +1,131 @@ +/* + * 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.arrow.vector; + +import org.apache.arrow.memory.ArrowBuf; +import org.apache.arrow.memory.BufferAllocator; +import org.apache.arrow.memory.RootAllocator; +import org.apache.arrow.vector.holders.NullableVarCharHolder; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +/** Benchmarks for {@link BaseVariableWidthVector}. */ +@State(Scope.Benchmark) +public class VariableWidthVectorInlineValueBenchmarks { + // checkstyle:off: MissingJavadocMethod + + private static final int VECTOR_CAPACITY = 16 * 1024; + + private static final int VECTOR_LENGTH = 1024; + + private static final int ALLOCATOR_CAPACITY = 1024 * 1024; + + private static final byte[] bytes = "InlineValue".getBytes(); + private ArrowBuf arrowBuff; + + private BufferAllocator allocator; + + private VarCharVector vector; + + @Param({"1", "2", "10", "40"}) + private int step; + + /** Setup benchmarks. */ + @Setup(Level.Iteration) + public void prepare() { + allocator = new RootAllocator(ALLOCATOR_CAPACITY); + vector = new VarCharVector("vector", allocator); + vector.allocateNew(VECTOR_CAPACITY, VECTOR_LENGTH); + arrowBuff = allocator.buffer(VECTOR_LENGTH); + arrowBuff.setBytes(0, bytes, 0, bytes.length); + } + + /** Tear down benchmarks. */ + @TearDown(Level.Iteration) + public void tearDown() { + arrowBuff.close(); + vector.close(); + allocator.close(); + } + + /** + * Test {@link BaseVariableWidthVector#getValueCapacity()}. + * + * @return useless. To avoid DCE by JIT. + */ + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int getValueCapacity() { + return vector.getValueCapacity(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromArray() { + for (int i = 0; i < 500; ++i) { + vector.setSafe(i * step, bytes); + } + return vector.getBufferSize(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromNullableVarcharHolder() { + NullableVarCharHolder nvch = new NullableVarCharHolder(); + nvch.buffer = arrowBuff; + nvch.start = 0; + nvch.end = bytes.length; + for (int i = 0; i < 50; ++i) { + nvch.isSet = 0; + for (int j = 0; j < 9; ++j) { + int idx = 10 * i + j; + vector.setSafe(idx, nvch); + } + nvch.isSet = 1; + vector.setSafe(10 * (i + 1), nvch); + } + return vector.getBufferSize(); + } + + public static void main(String[] args) throws RunnerException { + Options opt = + new OptionsBuilder() + .include(VariableWidthVectorInlineValueBenchmarks.class.getSimpleName() + ".setSafeFromArray") + .forks(1) + .build(); + + new Runner(opt).run(); + } + // checkstyle:on: MissingJavadocMethod +} diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java new file mode 100644 index 000000000..73f4874e5 --- /dev/null +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java @@ -0,0 +1,131 @@ +/* + * 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.arrow.vector; + +import org.apache.arrow.memory.ArrowBuf; +import org.apache.arrow.memory.BufferAllocator; +import org.apache.arrow.memory.RootAllocator; +import org.apache.arrow.vector.holders.NullableViewVarCharHolder; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +/** Benchmarks for {@link BaseVariableWidthVector}. */ +@State(Scope.Benchmark) +public class VariableWidthViewVectorInlineValueBenchmarks { + // checkstyle:off: MissingJavadocMethod + + private static final int VECTOR_CAPACITY = 16 * 1024; + + private static final int VECTOR_LENGTH = 1024; + + private static final int ALLOCATOR_CAPACITY = 1024 * 1024; + + private static byte[] bytes = "InlineValue".getBytes(); + private ArrowBuf arrowBuff; + + private BufferAllocator allocator; + + private ViewVarCharVector vector; + + @Param({"1", "2", "10", "40"}) + private int step; + + /** Setup benchmarks. */ + @Setup(Level.Iteration) + public void prepare() { + allocator = new RootAllocator(); + vector = new ViewVarCharVector("vector", allocator); + vector.allocateNew(VECTOR_CAPACITY, VECTOR_LENGTH); + arrowBuff = allocator.buffer(VECTOR_LENGTH); + arrowBuff.setBytes(0, bytes, 0, bytes.length); + } + + /** Tear down benchmarks. */ + @TearDown(Level.Iteration) + public void tearDown() { + arrowBuff.close(); + vector.close(); + allocator.close(); + } + + /** + * Test {@link BaseVariableWidthVector#getValueCapacity()}. + * + * @return useless. To avoid DCE by JIT. + */ + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int getValueCapacity() { + return vector.getValueCapacity(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromArray() { + for (int i = 0; i < 500; ++i) { + vector.setSafe(i * step, bytes); + } + return vector.getBufferSize(); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.MILLISECONDS) + public int setSafeFromNullableVarcharHolder() { + NullableViewVarCharHolder nvch = new NullableViewVarCharHolder(); + nvch.buffer = arrowBuff; + nvch.start = 0; + nvch.end = bytes.length; + for (int i = 0; i < 50; ++i) { + nvch.isSet = 0; + for (int j = 0; j < 9; ++j) { + int idx = 10 * i + j; + vector.setSafe(idx, nvch); + } + nvch.isSet = 1; + vector.setSafe(10 * (i + 1), nvch); + } + return vector.getBufferSize(); + } + + public static void main(String[] args) throws RunnerException { + Options opt = + new OptionsBuilder() + .include(VariableWidthViewVectorInlineValueBenchmarks.class.getSimpleName() + ".setSafeFromArray") + .forks(1) + .build(); + + new Runner(opt).run(); + } + // checkstyle:on: MissingJavadocMethod +} diff --git a/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java b/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java index 1ad2144c5..15d218278 100644 --- a/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java +++ b/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthViewVector.java @@ -1367,13 +1367,11 @@ protected ArrowBuf allocateOrGetLastDataBuffer(int length) { protected final void setBytes(int index, byte[] value, int start, int length) { int writePosition = index * ELEMENT_SIZE; - if (length <= INLINE_SIZE) { - // to clear the memory segment of view being written to - // if it has been set - if (viewBuffer.getLong(writePosition) != 0 || viewBuffer.getLong(writePosition + 8) != 0) { - viewBuffer.setZero(writePosition, ELEMENT_SIZE); - } + // to clear the memory segment of view being written to + // this is helpful in case of overwriting the value + viewBuffer.setZero(writePosition, ELEMENT_SIZE); + if (length <= INLINE_SIZE) { // allocate inline buffer // set length viewBuffer.setInt(writePosition, length); @@ -1413,13 +1411,11 @@ protected final void setBytes(int index, byte[] value, int start, int length) { protected final void setBytes(int index, ArrowBuf valueBuf, int start, int length) { int writePosition = index * ELEMENT_SIZE; - if (length <= INLINE_SIZE) { - // to clear the memory segment of view being written to - // if it has been set - if (viewBuffer.getLong(writePosition) != 0 || viewBuffer.getLong(writePosition + 8) != 0) { - viewBuffer.setZero(writePosition, ELEMENT_SIZE); - } + // to clear the memory segment of view being written to + // this is helpful in case of overwriting the value + viewBuffer.setZero(writePosition, ELEMENT_SIZE); + if (length <= INLINE_SIZE) { // allocate inline buffer // set length viewBuffer.setInt(writePosition, length); From 5f97912f8cfef3633a924a785bbd79166feca336 Mon Sep 17 00:00:00 2001 From: ViggoC Date: Fri, 24 Jan 2025 00:01:49 +0800 Subject: [PATCH 3/5] move constants --- ...VariableWidthVectorBenchmarkConstants.java | 22 +++++++++++++++++++ .../vector/VariableWidthVectorBenchmarks.java | 2 +- ...iableWidthVectorInlineValueBenchmarks.java | 9 ++++---- .../VariableWidthViewVectorBenchmarks.java | 2 +- ...eWidthViewVectorInlineValueBenchmarks.java | 9 ++++---- 5 files changed, 34 insertions(+), 10 deletions(-) create mode 100644 performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarkConstants.java diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarkConstants.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarkConstants.java new file mode 100644 index 000000000..d4ef49d90 --- /dev/null +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarkConstants.java @@ -0,0 +1,22 @@ +/* + * 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.arrow.vector; + +public class VariableWidthVectorBenchmarkConstants { + public static final String SHORT_VALUE = "InlineValue"; + public static final String LONG_VALUE = VariableWidthVectorBenchmarks.class.getName(); +} diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java index 3249918b4..17d3ac1fe 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorBenchmarks.java @@ -47,7 +47,7 @@ public class VariableWidthVectorBenchmarks { private static final int ALLOCATOR_CAPACITY = 1024 * 1024; - private static byte[] bytes = VariableWidthVectorBenchmarks.class.getName().getBytes(); + private static byte[] bytes = VariableWidthVectorBenchmarkConstants.LONG_VALUE.getBytes(); private ArrowBuf arrowBuff; private BufferAllocator allocator; diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java index 54433eb2f..87148452a 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java @@ -16,6 +16,7 @@ */ package org.apache.arrow.vector; +import java.util.concurrent.TimeUnit; import org.apache.arrow.memory.ArrowBuf; import org.apache.arrow.memory.BufferAllocator; import org.apache.arrow.memory.RootAllocator; @@ -35,8 +36,6 @@ import org.openjdk.jmh.runner.options.Options; import org.openjdk.jmh.runner.options.OptionsBuilder; -import java.util.concurrent.TimeUnit; - /** Benchmarks for {@link BaseVariableWidthVector}. */ @State(Scope.Benchmark) public class VariableWidthVectorInlineValueBenchmarks { @@ -48,7 +47,7 @@ public class VariableWidthVectorInlineValueBenchmarks { private static final int ALLOCATOR_CAPACITY = 1024 * 1024; - private static final byte[] bytes = "InlineValue".getBytes(); + private static final byte[] bytes = VariableWidthVectorBenchmarkConstants.SHORT_VALUE.getBytes(); private ArrowBuf arrowBuff; private BufferAllocator allocator; @@ -121,7 +120,9 @@ public int setSafeFromNullableVarcharHolder() { public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() - .include(VariableWidthVectorInlineValueBenchmarks.class.getSimpleName() + ".setSafeFromArray") + .include( + VariableWidthVectorInlineValueBenchmarks.class.getSimpleName() + + ".setSafeFromArray") .forks(1) .build(); diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java index 9a04f868e..b85377dcd 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorBenchmarks.java @@ -47,7 +47,7 @@ public class VariableWidthViewVectorBenchmarks { private static final int ALLOCATOR_CAPACITY = 1024 * 1024; - private static byte[] bytes = VariableWidthVectorBenchmarks.class.getName().getBytes(); + private static byte[] bytes = VariableWidthVectorBenchmarkConstants.LONG_VALUE.getBytes(); private ArrowBuf arrowBuff; private BufferAllocator allocator; diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java index 73f4874e5..1debc6b8f 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java @@ -16,6 +16,7 @@ */ package org.apache.arrow.vector; +import java.util.concurrent.TimeUnit; import org.apache.arrow.memory.ArrowBuf; import org.apache.arrow.memory.BufferAllocator; import org.apache.arrow.memory.RootAllocator; @@ -35,8 +36,6 @@ import org.openjdk.jmh.runner.options.Options; import org.openjdk.jmh.runner.options.OptionsBuilder; -import java.util.concurrent.TimeUnit; - /** Benchmarks for {@link BaseVariableWidthVector}. */ @State(Scope.Benchmark) public class VariableWidthViewVectorInlineValueBenchmarks { @@ -48,7 +47,7 @@ public class VariableWidthViewVectorInlineValueBenchmarks { private static final int ALLOCATOR_CAPACITY = 1024 * 1024; - private static byte[] bytes = "InlineValue".getBytes(); + private static byte[] bytes = VariableWidthVectorBenchmarkConstants.SHORT_VALUE.getBytes(); private ArrowBuf arrowBuff; private BufferAllocator allocator; @@ -121,7 +120,9 @@ public int setSafeFromNullableVarcharHolder() { public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() - .include(VariableWidthViewVectorInlineValueBenchmarks.class.getSimpleName() + ".setSafeFromArray") + .include( + VariableWidthViewVectorInlineValueBenchmarks.class.getSimpleName() + + ".setSafeFromArray") .forks(1) .build(); From 0ff52481e0e6f1c3ec6ae3b3572dc12e10952cc3 Mon Sep 17 00:00:00 2001 From: "chenweiguo.vc" Date: Fri, 24 Jan 2025 00:34:36 +0800 Subject: [PATCH 4/5] remove filter --- .../vector/VariableWidthVectorInlineValueBenchmarks.java | 4 +--- .../vector/VariableWidthViewVectorInlineValueBenchmarks.java | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java index 87148452a..354d1b147 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthVectorInlineValueBenchmarks.java @@ -120,9 +120,7 @@ public int setSafeFromNullableVarcharHolder() { public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() - .include( - VariableWidthVectorInlineValueBenchmarks.class.getSimpleName() - + ".setSafeFromArray") + .include(VariableWidthVectorInlineValueBenchmarks.class.getSimpleName()) .forks(1) .build(); diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java index 1debc6b8f..09cf87006 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java @@ -120,9 +120,7 @@ public int setSafeFromNullableVarcharHolder() { public static void main(String[] args) throws RunnerException { Options opt = new OptionsBuilder() - .include( - VariableWidthViewVectorInlineValueBenchmarks.class.getSimpleName() - + ".setSafeFromArray") + .include(VariableWidthViewVectorInlineValueBenchmarks.class.getSimpleName()) .forks(1) .build(); From 374357d2264ad917af9da1585442cf325ac25939 Mon Sep 17 00:00:00 2001 From: "chenweiguo.vc" Date: Fri, 24 Jan 2025 01:23:13 +0800 Subject: [PATCH 5/5] setZero in prepare --- .../vector/VariableWidthViewVectorInlineValueBenchmarks.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java index 09cf87006..32143d477 100644 --- a/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java +++ b/performance/src/main/java/org/apache/arrow/vector/VariableWidthViewVectorInlineValueBenchmarks.java @@ -58,17 +58,18 @@ public class VariableWidthViewVectorInlineValueBenchmarks { private int step; /** Setup benchmarks. */ - @Setup(Level.Iteration) + @Setup(Level.Invocation) public void prepare() { allocator = new RootAllocator(); vector = new ViewVarCharVector("vector", allocator); vector.allocateNew(VECTOR_CAPACITY, VECTOR_LENGTH); + vector.zeroVector(); arrowBuff = allocator.buffer(VECTOR_LENGTH); arrowBuff.setBytes(0, bytes, 0, bytes.length); } /** Tear down benchmarks. */ - @TearDown(Level.Iteration) + @TearDown(Level.Invocation) public void tearDown() { arrowBuff.close(); vector.close();