Skip to content
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

Jump to bottom

Add specialized filter kernels in compute module (up to 10x faster) #1248

Merged
merged 21 commits into from
Feb 9, 2022
Merged

Add specialized filter kernels in compute module (up to 10x faster) #1248

Show file tree
Hide file tree
Changes from 9 commits
Commits
Show all changes
21 commits
Select commit Hold shift + click to select a range
3a05ebb
Add specialized primitive filter kernels
tustvold Jan 29, 2022
ba5df9b
Filter context
tustvold Jan 30, 2022
f233909
Optimize null buffer construction
tustvold Jan 30, 2022
31d606a
Clippy
tustvold Jan 30, 2022
272e7a6
Benchmark filter construction
tustvold Jan 30, 2022
19cc6ee
Review feedback
tustvold Feb 2, 2022
c5912ef
Specialized string filter
tustvold Feb 2, 2022
3ed6b60
Specialized dictionary filter kernel
tustvold Feb 2, 2022
17f3d80
Use trusted_len_iter
tustvold Feb 3, 2022
63019f3
Review feedback
tustvold Feb 3, 2022
d587a46
Add fuzz filter test
tustvold Feb 3, 2022
3cae739
Clarify selective vs selectivity confusion
tustvold Feb 4, 2022
b4fe5dd
Revert change to MutableBuffer::from_trusted_len_iter_bool
tustvold Feb 4, 2022
3241417
Fix filter_bits offset handling
tustvold Feb 4, 2022
0918e83
Review feedback
tustvold Feb 4, 2022
1e7481a
Use i64 for chunk offset
tustvold Feb 4, 2022
395f6b3
Only optimize filter when filtering multiple columns
tustvold Feb 5, 2022
37fa7f2
Test truncated filter
tustvold Feb 6, 2022
2aa46b0
Review feedback
tustvold Feb 6, 2022
7b4a2f1
Add IterationStrategy::None
tustvold Feb 7, 2022
9fc5fac
Remove selective / selectivity docs confusion
tustvold Feb 7, 2022
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
84 changes: 76 additions & 8 deletions arrow/benches/filter_kernels.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,22 +18,22 @@ extern crate arrow;

use std::sync::Arc;

use arrow::compute::{filter_record_batch, Filter};
use arrow::compute::{filter_record_batch, FilterBuilder, FilterPredicate};
use arrow::record_batch::RecordBatch;
use arrow::util::bench_util::*;

use arrow::array::*;
use arrow::compute::{build_filter, filter};
use arrow::datatypes::{Field, Float32Type, Schema, UInt8Type};
use arrow::compute::filter;
use arrow::datatypes::{Field, Float32Type, Int32Type, Schema, UInt8Type};

use criterion::{criterion_group, criterion_main, Criterion};

fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) {
criterion::black_box(filter(data_array, filter_array).unwrap());
}

fn bench_built_filter<'a>(filter: &Filter<'a>, data: &impl Array) {
criterion::black_box(filter(data.data()));
fn bench_built_filter(filter: &FilterPredicate, array: &dyn Array) {
criterion::black_box(filter.filter(array).unwrap());
}

fn add_benchmark(c: &mut Criterion) {
Expand All @@ -42,12 +42,24 @@ fn add_benchmark(c: &mut Criterion) {
let dense_filter_array = create_boolean_array(size, 0.0, 1.0 - 1.0 / 1024.0);
let sparse_filter_array = create_boolean_array(size, 0.0, 1.0 / 1024.0);

let filter = build_filter(&filter_array).unwrap();
let dense_filter = build_filter(&dense_filter_array).unwrap();
let sparse_filter = build_filter(&sparse_filter_array).unwrap();
let filter = FilterBuilder::new(&filter_array).optimize().build();
let dense_filter = FilterBuilder::new(&dense_filter_array).optimize().build();
let sparse_filter = FilterBuilder::new(&sparse_filter_array).optimize().build();

let data_array = create_primitive_array::<UInt8Type>(size, 0.0);

c.bench_function("filter optimize", |b| {
tustvold marked this conversation as resolved.
Show resolved Hide resolved
b.iter(|| FilterBuilder::new(&filter_array).optimize().build())
});

c.bench_function("filter optimize high selectivity", |b| {
tustvold marked this conversation as resolved.
Show resolved Hide resolved
b.iter(|| FilterBuilder::new(&dense_filter_array).optimize().build())
});

c.bench_function("filter optimize low selectivity", |b| {
tustvold marked this conversation as resolved.
Show resolved Hide resolved
b.iter(|| FilterBuilder::new(&sparse_filter_array).optimize().build())
});

c.bench_function("filter u8", |b| {
b.iter(|| bench_filter(&data_array, &filter_array))
});
Expand All @@ -68,6 +80,38 @@ fn add_benchmark(c: &mut Criterion) {
b.iter(|| bench_built_filter(&sparse_filter, &data_array))
});

let data_array = create_primitive_array::<Int32Type>(size, 0.0);
c.bench_function("filter i32", |b| {
b.iter(|| bench_filter(&data_array, &filter_array))
});
c.bench_function("filter i32 high selectivity", |b| {
b.iter(|| bench_filter(&data_array, &dense_filter_array))
});
c.bench_function("filter i32 low selectivity", |b| {
b.iter(|| bench_filter(&data_array, &sparse_filter_array))
});

c.bench_function("filter context i32", |b| {
b.iter(|| bench_built_filter(&filter, &data_array))
});
c.bench_function("filter context i32 high selectivity", |b| {
b.iter(|| bench_built_filter(&dense_filter, &data_array))
});
c.bench_function("filter context i32 low selectivity", |b| {
b.iter(|| bench_built_filter(&sparse_filter, &data_array))
});

let data_array = create_primitive_array::<Int32Type>(size, 0.5);
c.bench_function("filter context i32 w NULLs", |b| {
b.iter(|| bench_built_filter(&filter, &data_array))
});
c.bench_function("filter context i32 w NULLs high selectivity", |b| {
b.iter(|| bench_built_filter(&dense_filter, &data_array))
});
c.bench_function("filter context i32 w NULLs low selectivity", |b| {
b.iter(|| bench_built_filter(&sparse_filter, &data_array))
});

let data_array = create_primitive_array::<UInt8Type>(size, 0.5);
c.bench_function("filter context u8 w NULLs", |b| {
b.iter(|| bench_built_filter(&filter, &data_array))
Expand Down Expand Up @@ -104,6 +148,30 @@ fn add_benchmark(c: &mut Criterion) {
b.iter(|| bench_built_filter(&sparse_filter, &data_array))
});

let data_array = create_string_dict_array::<Int32Type>(size, 0.0);
c.bench_function("filter context string dictionary", |b| {
b.iter(|| bench_built_filter(&filter, &data_array))
});
c.bench_function("filter context string dictionary high selectivity", |b| {
b.iter(|| bench_built_filter(&dense_filter, &data_array))
});
c.bench_function("filter context string dictionary low selectivity", |b| {
b.iter(|| bench_built_filter(&sparse_filter, &data_array))
});

let data_array = create_string_dict_array::<Int32Type>(size, 0.5);
c.bench_function("filter context string dictionary w NULLs", |b| {
b.iter(|| bench_built_filter(&filter, &data_array))
});
c.bench_function(
"filter context string dictionary w NULLs high selectivity",
|b| b.iter(|| bench_built_filter(&dense_filter, &data_array)),
);
c.bench_function(
"filter context string dictionary w NULLs low selectivity",
|b| b.iter(|| bench_built_filter(&sparse_filter, &data_array)),
);

let data_array = create_primitive_array::<Float32Type>(size, 0.0);

let field = Field::new("c1", data_array.data_type().clone(), true);
Expand Down
23 changes: 12 additions & 11 deletions arrow/src/buffer/mutable.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -475,35 +475,36 @@ impl MutableBuffer {
let (_, upper) = iterator.size_hint();
let upper = upper.expect("from_trusted_len_iter requires an upper limit");

let mut result = {
let byte_capacity: usize = upper.saturating_add(7) / 8;
MutableBuffer::new(byte_capacity)
};
let aligned_len = bit_util::ceil(upper, 64) * 8;
let mut result = MutableBuffer::new(aligned_len);

'a: loop {
let mut byte_accum: u8 = 0;
let mut mask: u8 = 1;
let mut accum: u64 = 0;
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

that's interesting - I am curious @tustvold have you measured the impact just from this change (from u8 to u64 accumulator) ?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I was sure this improved the benchmarks at one point, but it would appear to now make them worse 😱

Great catch 👍

let mut mask: u64 = 1;

//collect (up to) 8 bits into a byte
//collect (up to) 64 bits into a u64
while mask != 0 {
if let Some(value) = iterator.next() {
byte_accum |= match value {
accum |= match value {
true => mask,
false => 0,
};
mask <<= 1;
} else {
if mask != 1 {
// Add last byte
result.push_unchecked(byte_accum);
// Add accumulator
result.push_unchecked(accum);
}
break 'a;
}
}

// Soundness: from_trusted_len
result.push_unchecked(byte_accum);
result.push_unchecked(accum);
}

// Truncate to byte length - technically not necessary but cannot hurt
result.resize(bit_util::ceil(upper, 8), 0);
result
}

Expand Down
Loading