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

Improve regexp kernels performance by avoiding cloning Regex #5235

Merged
merged 2 commits into from
Dec 23, 2023
Merged

Improve regexp kernels performance by avoiding cloning Regex #5235

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
17a1c24
Improve regexp_match performance by avoiding cloning Regex
viirya Dec 22, 2023
bbba7b0
For review
viirya Dec 22, 2023
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
10 changes: 4 additions & 6 deletions arrow-string/src/regexp.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,15 +81,14 @@ pub fn regexp_is_match_utf8<OffsetSize: OffsetSizeTrait>(
(Some(value), Some(pattern)) => {
let existing_pattern = patterns.get(&pattern);
let re = match existing_pattern {
Some(re) => re.clone(),
Some(re) => re,
None => {
let re = Regex::new(pattern.as_str()).map_err(|e| {
ArrowError::ComputeError(format!(
"Regular expression did not compile: {e:?}"
))
})?;
patterns.insert(pattern, re.clone());
re
patterns.entry(pattern).or_insert(re)
}
};
result.append(re.is_match(value));
Expand Down Expand Up @@ -216,15 +215,14 @@ pub fn regexp_match<OffsetSize: OffsetSizeTrait>(
(Some(value), Some(pattern)) => {
let existing_pattern = patterns.get(&pattern);
let re = match existing_pattern {
Some(re) => re.clone(),
Some(re) => re,
None => {
let re = Regex::new(pattern.as_str()).map_err(|e| {
ArrowError::ComputeError(format!(
"Regular expression did not compile: {e:?}"
))
})?;
patterns.insert(pattern, re.clone());
re
patterns.entry(pattern).or_insert(re)
Comment on lines 216 to +225
Copy link
Contributor

Choose a reason for hiding this comment

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

If you replaced the get above with this entry call, it might improve the performance further by eliminating a branch perhaps??

Copy link
Member Author

@viirya viirya Dec 22, 2023 •
edited
Loading

Choose a reason for hiding this comment

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

Hmm, then we need to use or_insert_with like

let re = patterns.entry(pattern).or_insert_with(|| {
  Regex::new(pattern.as_str()).map_err(|e| {
    ArrowError::ComputeError(format!(
      "Regular expression did not compile: {e:?}"
    ))
  }?)
});

But or_insert_with cannot propagate the error out of the function.

Tried with Result<Regex, ArrowError> as value type with the patterns HashMap, but then it doesn't work because the ? operator cannot be applied to type &mut Result<regex::Regex, arrow_schema::ArrowError> too.

So just keep it as is.

Copy link
Contributor

@tustvold tustvold Dec 22, 2023 •
edited
Loading

Choose a reason for hiding this comment

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

Entry is an enumeration you can match on, you don't have to use or_insert_with and friends, they're just utilities like on Option

Copy link
Member Author

Choose a reason for hiding this comment

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

Oh, the branch to eliminate is the one inside or_insert? Do you mean something like:

let entry = patterns.entry(pattern.clone());
let re = match entry {
  Entry::Occupied(entry) => entry.into_mut(),
  Entry::Vacant(entry) => {
    let re = Regex::new(pattern.as_str()).map_err(|e| {
      ArrowError::ComputeError(format!(
        "Regular expression did not compile: {e:?}"
      ))
    })?;
    entry.insert(re)
  }
};

Hmm, it actually gets regression a little. 🤔

regexp                  time:   [7.6891 ms 7.7210 ms 7.7511 ms]
                        change: [+14.792% +15.570% +16.321%] (p = 0.00 < 0.05)
                        Performance has regressed.

Copy link
Contributor

Choose a reason for hiding this comment

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

That is what I meant, perhaps the regression is because of the added clone (which i think can be removed)

Copy link
Member Author

Choose a reason for hiding this comment

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

clone? You mean let entry = patterns.entry(pattern.clone());? It cannot be removed.

216 |                 (Some(value), Some(pattern)) => {
    |                                    ------- move occurs because `pattern` has type `String`, which does not implement the `Copy` trait
217 |                     let entry = patterns.entry(pattern);
    |                                                ------- value moved here
...
221 |                             let re = Regex::new(pattern.as_str()).map_err(|e| {
    |                                                 ^^^^^^^ value borrowed here after move
    |
help: consider cloning the value if the performance cost is acceptable
    |
217 |                     let entry = patterns.entry(pattern.clone());
    |                                                       ++++++++

Copy link
Contributor

Choose a reason for hiding this comment

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

Oh because of the unfortunate way flags are handled... Yeah this kernel would probably do with redesigning 😅

}
};
match re.captures(value) {
Expand Down
5 changes: 5 additions & 0 deletions arrow/Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -247,6 +247,11 @@ name = "substring_kernels"
harness = false
required-features = ["test_utils"]

[[bench]]
name = "regexp_kernels"
harness = false
required-features = ["test_utils"]

[[bench]]
name = "array_data_validate"
harness = false
Expand Down
44 changes: 44 additions & 0 deletions arrow/benches/regexp_kernels.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,44 @@
// 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::Criterion;

extern crate arrow;

use arrow::array::*;
use arrow::compute::kernels::regexp::*;
use arrow::util::bench_util::*;

fn bench_regexp(arr: &GenericStringArray<i32>, regex_array: &GenericStringArray<i32>) {
regexp_match(criterion::black_box(arr), regex_array, None).unwrap();
}

fn add_benchmark(c: &mut Criterion) {
let size = 65536;
let val_len = 1000;

let arr_string = create_string_array_with_len::<i32>(size, 0.0, val_len);
let pattern_values = vec![r".*-(\d*)-.*"; size];
let pattern = GenericStringArray::<i32>::from(pattern_values);

c.bench_function("regexp", |b| b.iter(|| bench_regexp(&arr_string, &pattern)));
}

criterion_group!(benches, add_benchmark);
criterion_main!(benches);
Loading