#[macro_use]
extern crate criterion;
use criterion::Criterion;
extern crate arrow;
use arrow::compute::*;
use arrow::datatypes::ArrowNumericType;
use arrow::util::bench_util::*;
use arrow::{array::*, datatypes::Float32Type};
fn bench_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_neq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
neq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_neq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
neq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_lt<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
lt(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_lt_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
lt_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_lt_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
lt_eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_lt_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
lt_eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_gt<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
gt(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_gt_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
gt_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_gt_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
gt_eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
}
fn bench_gt_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
gt_eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_like_utf8_scalar(arr_a: &StringArray, value_b: &str) {
like_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
}
fn bench_nlike_utf8_scalar(arr_a: &StringArray, value_b: &str) {
nlike_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b))
.unwrap();
}
fn bench_regexp_is_match_utf8_scalar(arr_a: &StringArray, value_b: &str) {
regexp_is_match_utf8_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
None,
)
.unwrap();
}
fn add_benchmark(c: &mut Criterion) {
let size = 65536;
let arr_a = create_primitive_array_with_seed::<Float32Type>(size, 0.0, 42);
let arr_b = create_primitive_array_with_seed::<Float32Type>(size, 0.0, 43);
let arr_string = create_string_array::<i32>(size, 0.0);
c.bench_function("eq Float32", |b| b.iter(|| bench_eq(&arr_a, &arr_b)));
c.bench_function("eq scalar Float32", |b| {
b.iter(|| bench_eq_scalar(&arr_a, 1.0))
});
c.bench_function("neq Float32", |b| b.iter(|| bench_neq(&arr_a, &arr_b)));
c.bench_function("neq scalar Float32", |b| {
b.iter(|| bench_neq_scalar(&arr_a, 1.0))
});
c.bench_function("lt Float32", |b| b.iter(|| bench_lt(&arr_a, &arr_b)));
c.bench_function("lt scalar Float32", |b| {
b.iter(|| bench_lt_scalar(&arr_a, 1.0))
});
c.bench_function("lt_eq Float32", |b| b.iter(|| bench_lt_eq(&arr_a, &arr_b)));
c.bench_function("lt_eq scalar Float32", |b| {
b.iter(|| bench_lt_eq_scalar(&arr_a, 1.0))
});
c.bench_function("gt Float32", |b| b.iter(|| bench_gt(&arr_a, &arr_b)));
c.bench_function("gt scalar Float32", |b| {
b.iter(|| bench_gt_scalar(&arr_a, 1.0))
});
c.bench_function("gt_eq Float32", |b| b.iter(|| bench_gt_eq(&arr_a, &arr_b)));
c.bench_function("gt_eq scalar Float32", |b| {
b.iter(|| bench_gt_eq_scalar(&arr_a, 1.0))
});
c.bench_function("like_utf8 scalar equals", |b| {
b.iter(|| bench_like_utf8_scalar(&arr_string, "xxxx"))
});
c.bench_function("like_utf8 scalar contains", |b| {
b.iter(|| bench_like_utf8_scalar(&arr_string, "%xxxx%"))
});
c.bench_function("like_utf8 scalar ends with", |b| {
b.iter(|| bench_like_utf8_scalar(&arr_string, "xxxx%"))
});
c.bench_function("like_utf8 scalar starts with", |b| {
b.iter(|| bench_like_utf8_scalar(&arr_string, "%xxxx"))
});
c.bench_function("like_utf8 scalar complex", |b| {
b.iter(|| bench_like_utf8_scalar(&arr_string, "%xx_xx%xxx"))
});
c.bench_function("nlike_utf8 scalar equals", |b| {
b.iter(|| bench_nlike_utf8_scalar(&arr_string, "xxxx"))
});
c.bench_function("nlike_utf8 scalar contains", |b| {
b.iter(|| bench_nlike_utf8_scalar(&arr_string, "%xxxx%"))
});
c.bench_function("nlike_utf8 scalar ends with", |b| {
b.iter(|| bench_nlike_utf8_scalar(&arr_string, "xxxx%"))
});
c.bench_function("nlike_utf8 scalar starts with", |b| {
b.iter(|| bench_nlike_utf8_scalar(&arr_string, "%xxxx"))
});
c.bench_function("nlike_utf8 scalar complex", |b| {
b.iter(|| bench_nlike_utf8_scalar(&arr_string, "%xx_xx%xxx"))
});
c.bench_function("egexp_matches_utf8 scalar starts with", |b| {
b.iter(|| bench_regexp_is_match_utf8_scalar(&arr_string, "^xx"))
});
c.bench_function("egexp_matches_utf8 scalar ends with", |b| {
b.iter(|| bench_regexp_is_match_utf8_scalar(&arr_string, "xx$"))
});
}
criterion_group!(benches, add_benchmark);
criterion_main!(benches);