From 0c02ecb576dd73351cc1c0fe2863ed551e7b5108 Mon Sep 17 00:00:00 2001 From: liukun4515 Date: Tue, 13 Sep 2022 11:58:53 +0800 Subject: [PATCH 1/2] add benchmark for bitwise operation --- arrow/Cargo.toml | 5 ++ arrow/benches/bitwise_kernel.rs | 96 +++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 arrow/benches/bitwise_kernel.rs diff --git a/arrow/Cargo.toml b/arrow/Cargo.toml index 2de4db64276..04d16fa71f8 100644 --- a/arrow/Cargo.toml +++ b/arrow/Cargo.toml @@ -238,3 +238,8 @@ harness = false name = "row_format" harness = false required-features = ["test_utils"] + +[[bench]] +name = "bitwise_kernel" +harness = false +required-features = ["test_utils"] diff --git a/arrow/benches/bitwise_kernel.rs b/arrow/benches/bitwise_kernel.rs new file mode 100644 index 00000000000..b1db7ec9ff1 --- /dev/null +++ b/arrow/benches/bitwise_kernel.rs @@ -0,0 +1,96 @@ +// 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. + +#[macro_use] +extern crate criterion; + +use criterion::{black_box, Criterion}; +use rand::RngCore; +use arrow::compute::kernels::bitwise::{bitwise_and, bitwise_and_scalar}; +use arrow::datatypes::Int64Type; + +extern crate arrow; + +use arrow::util::bench_util::create_primitive_array; +use arrow::util::test_util::seedable_rng; + + +fn bitwise_array_benchmark(c: &mut Criterion) { + let size = 64 * 1024_usize; + // array and + let left = create_primitive_array::(size, 0 as f32); + let right = create_primitive_array::(size, 0 as f32); + let mut group = c.benchmark_group("bench bitwise array: and"); + group.bench_function("bitwise array and, no nulls", |b| { + b.iter(|| { + black_box(bitwise_and(&left, &right).unwrap()) + }) + }); + let left = create_primitive_array::(size, 0.2 as f32); + let right = create_primitive_array::(size, 0.2 as f32); + group.bench_function("bitwise array and, 20% nulls", |b| { + b.iter(|| { + black_box(bitwise_and(&left, &right).unwrap()) + }) + }); + group.finish(); + // array or + let mut group = c.benchmark_group("bench bitwise: or"); + group.bench_function("bitwise array or, no nulls", |b| { + b.iter(|| { + black_box(bitwise_and(&left, &right).unwrap()) + }) + }); + let left = create_primitive_array::(size, 0.2 as f32); + let right = create_primitive_array::(size, 0.2 as f32); + group.bench_function("bitwise array or, 20% nulls", |b| { + b.iter(|| { + black_box(bitwise_and(&left, &right).unwrap()) + }) + }); + group.finish(); + // xor + let mut group = c.benchmark_group("bench bitwise: xor"); + // not + let mut group = c.benchmark_group("bench bitwise: not"); +} + +fn bitwise_array_scalar_benchmark(c: &mut Criterion) { + let size = 64 * 1024_usize; + // array scalar and + let array = create_primitive_array::(size, 0 as f32); + let scalar = seedable_rng().next_u64() as i64; + let mut group = c.benchmark_group("bench bitwise array scalar: and"); + group.bench_function("bitwise array scalar and, no nulls", |b| { + b.iter(|| { + black_box(bitwise_and_scalar(&array, scalar).unwrap()) + }) + }); + let array = create_primitive_array::(size, 0.2 as f32); + group.bench_function("bitwise array and, 20% nulls", |b| { + b.iter(|| { + black_box(bitwise_and_scalar(&array, scalar).unwrap()) + }) + }); + group.finish(); + // array scalar or + + // array scalar xor +} + +criterion_group!(benches, bitwise_benchmark); +criterion_main!(benches); \ No newline at end of file From 6c33a20169c2a73dd9f4677bce69d744ce84dce9 Mon Sep 17 00:00:00 2001 From: liukun4515 Date: Thu, 15 Sep 2022 22:44:20 +0800 Subject: [PATCH 2/2] add bench for bitwise or xor not --- arrow/benches/bitwise_kernel.rs | 87 +++++++++++++++++++++------------ 1 file changed, 56 insertions(+), 31 deletions(-) diff --git a/arrow/benches/bitwise_kernel.rs b/arrow/benches/bitwise_kernel.rs index b1db7ec9ff1..741eb96125a 100644 --- a/arrow/benches/bitwise_kernel.rs +++ b/arrow/benches/bitwise_kernel.rs @@ -18,79 +18,104 @@ #[macro_use] extern crate criterion; +use arrow::compute::kernels::bitwise::{ + bitwise_and, bitwise_and_scalar, bitwise_not, bitwise_or, bitwise_or_scalar, + bitwise_xor, bitwise_xor_scalar, +}; +use arrow::datatypes::Int64Type; use criterion::{black_box, Criterion}; use rand::RngCore; -use arrow::compute::kernels::bitwise::{bitwise_and, bitwise_and_scalar}; -use arrow::datatypes::Int64Type; extern crate arrow; use arrow::util::bench_util::create_primitive_array; use arrow::util::test_util::seedable_rng; - fn bitwise_array_benchmark(c: &mut Criterion) { let size = 64 * 1024_usize; + let left_without_null = create_primitive_array::(size, 0 as f32); + let right_without_null = create_primitive_array::(size, 0 as f32); + let left_with_null = create_primitive_array::(size, 0.2_f32); + let right_with_null = create_primitive_array::(size, 0.2_f32); // array and - let left = create_primitive_array::(size, 0 as f32); - let right = create_primitive_array::(size, 0 as f32); let mut group = c.benchmark_group("bench bitwise array: and"); group.bench_function("bitwise array and, no nulls", |b| { b.iter(|| { - black_box(bitwise_and(&left, &right).unwrap()) + black_box(bitwise_and(&left_without_null, &right_without_null).unwrap()) }) }); - let left = create_primitive_array::(size, 0.2 as f32); - let right = create_primitive_array::(size, 0.2 as f32); group.bench_function("bitwise array and, 20% nulls", |b| { - b.iter(|| { - black_box(bitwise_and(&left, &right).unwrap()) - }) + b.iter(|| black_box(bitwise_and(&left_with_null, &right_with_null).unwrap())) }); group.finish(); // array or let mut group = c.benchmark_group("bench bitwise: or"); group.bench_function("bitwise array or, no nulls", |b| { - b.iter(|| { - black_box(bitwise_and(&left, &right).unwrap()) - }) + b.iter(|| black_box(bitwise_or(&left_without_null, &right_without_null).unwrap())) }); - let left = create_primitive_array::(size, 0.2 as f32); - let right = create_primitive_array::(size, 0.2 as f32); group.bench_function("bitwise array or, 20% nulls", |b| { - b.iter(|| { - black_box(bitwise_and(&left, &right).unwrap()) - }) + b.iter(|| black_box(bitwise_or(&left_with_null, &right_with_null).unwrap())) }); group.finish(); // xor let mut group = c.benchmark_group("bench bitwise: xor"); + group.bench_function("bitwise array xor, no nulls", |b| { + b.iter(|| { + black_box(bitwise_xor(&left_without_null, &right_without_null).unwrap()) + }) + }); + group.bench_function("bitwise array xor, 20% nulls", |b| { + b.iter(|| black_box(bitwise_xor(&left_with_null, &right_with_null).unwrap())) + }); + group.finish(); // not let mut group = c.benchmark_group("bench bitwise: not"); + group.bench_function("bitwise array not, no nulls", |b| { + b.iter(|| black_box(bitwise_not(&left_without_null).unwrap())) + }); + group.bench_function("bitwise array not, 20% nulls", |b| { + b.iter(|| black_box(bitwise_not(&left_with_null).unwrap())) + }); + group.finish(); } fn bitwise_array_scalar_benchmark(c: &mut Criterion) { let size = 64 * 1024_usize; - // array scalar and - let array = create_primitive_array::(size, 0 as f32); + let array_without_null = create_primitive_array::(size, 0 as f32); + let array_with_null = create_primitive_array::(size, 0.2_f32); let scalar = seedable_rng().next_u64() as i64; + // array scalar and let mut group = c.benchmark_group("bench bitwise array scalar: and"); group.bench_function("bitwise array scalar and, no nulls", |b| { - b.iter(|| { - black_box(bitwise_and_scalar(&array, scalar).unwrap()) - }) + b.iter(|| black_box(bitwise_and_scalar(&array_without_null, scalar).unwrap())) }); - let array = create_primitive_array::(size, 0.2 as f32); group.bench_function("bitwise array and, 20% nulls", |b| { - b.iter(|| { - black_box(bitwise_and_scalar(&array, scalar).unwrap()) - }) + b.iter(|| black_box(bitwise_and_scalar(&array_with_null, scalar).unwrap())) }); group.finish(); // array scalar or - + let mut group = c.benchmark_group("bench bitwise array scalar: or"); + group.bench_function("bitwise array scalar or, no nulls", |b| { + b.iter(|| black_box(bitwise_or_scalar(&array_without_null, scalar).unwrap())) + }); + group.bench_function("bitwise array scalar or, 20% nulls", |b| { + b.iter(|| black_box(bitwise_or_scalar(&array_with_null, scalar).unwrap())) + }); + group.finish(); // array scalar xor + let mut group = c.benchmark_group("bench bitwise array scalar: xor"); + group.bench_function("bitwise array scalar xor, no nulls", |b| { + b.iter(|| black_box(bitwise_xor_scalar(&array_without_null, scalar).unwrap())) + }); + group.bench_function("bitwise array scalar xor, 20% nulls", |b| { + b.iter(|| black_box(bitwise_xor_scalar(&array_with_null, scalar).unwrap())) + }); + group.finish(); } -criterion_group!(benches, bitwise_benchmark); -criterion_main!(benches); \ No newline at end of file +criterion_group!( + benches, + bitwise_array_benchmark, + bitwise_array_scalar_benchmark +); +criterion_main!(benches);