Skip to content

ARROW-8907: [Rust] Implement scalar comparison operations #7261

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
yordan-pavlov wants to merge 6 commits into from
Closed

ARROW-8907: [Rust] Implement scalar comparison operations #7261

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
41be57f
Merge pull request #1 from apache/master
yordan-pavlov May 21, 2020
131b9ac
implemented scalar comparison operations for primitive types
yordan-pavlov May 24, 2020
838fb13
formatting changes suggested by rustfmt
yordan-pavlov May 24, 2020
fb63868
implemented scalar comparison operations for the string type
yordan-pavlov May 24, 2020
58815b9
added benchmarks for scalar comparison operations
yordan-pavlov May 24, 2020
9895bef
removed unnecessary use of apply_bin_op_to_option_bitmap in scalar co…
yordan-pavlov May 25, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
330 changes: 270 additions & 60 deletions rust/arrow/benches/comparison_kernels.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@ extern crate arrow;

use arrow::array::*;
use arrow::compute::*;
use arrow::datatypes::ArrowNumericType;

fn create_array(size: usize) -> Float32Array {
let mut builder = Float32Builder::new(size);
Expand All @@ -36,91 +37,300 @@ fn create_array(size: usize) -> Float32Array {
builder.finish()
}

pub fn eq_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a == b).unwrap());
pub fn eq_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a == b,
)
.unwrap();
}

pub fn neq_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a != b).unwrap());
pub fn eq_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a == b,
)
.unwrap();
}

pub fn lt_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a < b).unwrap());
pub fn neq_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a != b,
)
.unwrap();
}

fn lt_eq_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a <= b).unwrap());
pub fn neq_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a != b,
)
.unwrap();
}

pub fn gt_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a > b).unwrap());
pub fn lt_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a < b,
)
.unwrap();
}

fn gt_eq_no_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(no_simd_compare_op(&arr_a, &arr_b, |a, b| a >= b).unwrap());
pub fn lt_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a < b,
)
.unwrap();
}

fn eq_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(eq(&arr_a, &arr_b).unwrap());
fn lt_eq_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a <= b,
)
.unwrap();
}

fn neq_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(neq(&arr_a, &arr_b).unwrap());
fn lt_eq_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a <= b,
)
.unwrap();
}

fn lt_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(lt(&arr_a, &arr_b).unwrap());
pub fn gt_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a > b,
)
.unwrap();
}

fn lt_eq_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(lt_eq(&arr_a, &arr_b).unwrap());
pub fn gt_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a > b,
)
.unwrap();
}

fn gt_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(gt(&arr_a, &arr_b).unwrap());
fn gt_eq_no_simd<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
where
T: ArrowNumericType,
{
no_simd_compare_op(
criterion::black_box(arr_a),
criterion::black_box(arr_b),
|a, b| a >= b,
)
.unwrap();
}

fn gt_eq_simd(size: usize) {
let arr_a = create_array(size);
let arr_b = create_array(size);
criterion::black_box(gt_eq(&arr_a, &arr_b).unwrap());
fn gt_eq_no_simd_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
where
T: ArrowNumericType,
{
no_simd_compare_op_scalar(
criterion::black_box(arr_a),
criterion::black_box(value_b),
|a, b| a >= b,
)
.unwrap();
}

fn eq_simd<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 eq_simd_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 neq_simd<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 neq_simd_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 lt_simd<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 lt_simd_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 lt_eq_simd<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 lt_eq_simd_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 gt_simd<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 gt_simd_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 gt_eq_simd<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 gt_eq_simd_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 add_benchmark(c: &mut Criterion) {
c.bench_function("eq 512", |b| b.iter(|| eq_no_simd(512)));
c.bench_function("eq 512 simd", |b| b.iter(|| eq_simd(512)));
c.bench_function("neq 512", |b| b.iter(|| neq_no_simd(512)));
c.bench_function("neq 512 simd", |b| b.iter(|| neq_simd(512)));
c.bench_function("lt 512", |b| b.iter(|| lt_no_simd(512)));
c.bench_function("lt 512 simd", |b| b.iter(|| lt_simd(512)));
c.bench_function("lt_eq 512", |b| b.iter(|| lt_eq_no_simd(512)));
c.bench_function("lt_eq 512 simd", |b| b.iter(|| lt_eq_simd(512)));
c.bench_function("gt 512", |b| b.iter(|| gt_no_simd(512)));
c.bench_function("gt 512 simd", |b| b.iter(|| gt_simd(512)));
c.bench_function("gt_eq 512", |b| b.iter(|| gt_eq_no_simd(512)));
c.bench_function("gt_eq 512 simd", |b| b.iter(|| gt_eq_simd(512)));
let size = 65536;
let arr_a = create_array(size);
let arr_b = create_array(size);

c.bench_function("eq Float32", |b| b.iter(|| eq_no_simd(&arr_a, &arr_b)));
c.bench_function("eq scalar Float32", |b| {
b.iter(|| eq_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("eq Float32 simd", |b| b.iter(|| eq_simd(&arr_a, &arr_b)));
c.bench_function("eq scalar Float32 simd", |b| {
b.iter(|| eq_simd_scalar(&arr_a, 1.0))
});

c.bench_function("neq Float32", |b| b.iter(|| neq_no_simd(&arr_a, &arr_b)));
c.bench_function("neq scalar Float32", |b| {
b.iter(|| neq_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("neq Float32 simd", |b| b.iter(|| neq_simd(&arr_a, &arr_b)));
c.bench_function("neq scalar Float32 simd", |b| {
b.iter(|| neq_simd_scalar(&arr_a, 1.0))
});

c.bench_function("lt Float32", |b| b.iter(|| lt_no_simd(&arr_a, &arr_b)));
c.bench_function("lt scalar Float32", |b| {
b.iter(|| lt_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("lt Float32 simd", |b| b.iter(|| lt_simd(&arr_a, &arr_b)));
c.bench_function("lt scalar Float32 simd", |b| {
b.iter(|| lt_simd_scalar(&arr_a, 1.0))
});

c.bench_function("lt_eq Float32", |b| {
b.iter(|| lt_eq_no_simd(&arr_a, &arr_b))
});
c.bench_function("lt_eq scalar Float32", |b| {
b.iter(|| lt_eq_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("lt_eq Float32 simd", |b| {
b.iter(|| lt_eq_simd(&arr_a, &arr_b))
});
c.bench_function("lt_eq scalar Float32 simd", |b| {
b.iter(|| lt_eq_simd_scalar(&arr_a, 1.0))
});

c.bench_function("gt Float32", |b| b.iter(|| gt_no_simd(&arr_a, &arr_b)));
c.bench_function("gt scalar Float32", |b| {
b.iter(|| gt_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("gt Float32 simd", |b| b.iter(|| gt_simd(&arr_a, &arr_b)));
c.bench_function("gt scalar Float32 simd", |b| {
b.iter(|| gt_simd_scalar(&arr_a, 1.0))
});

c.bench_function("gt_eq Float32", |b| {
b.iter(|| gt_eq_no_simd(&arr_a, &arr_b))
});
c.bench_function("gt_eq scalar Float32", |b| {
b.iter(|| gt_eq_no_simd_scalar(&arr_a, 1.0))
});
c.bench_function("gt_eq Float32 simd", |b| {
b.iter(|| gt_eq_simd(&arr_a, &arr_b))
});
c.bench_function("gt_eq scalar Float32 simd", |b| {
b.iter(|| gt_eq_simd_scalar(&arr_a, 1.0))
});
}

criterion_group!(benches, add_benchmark);
Expand Down
Loading