Use warp per string for long strings in cudf::strings::contains()

[davidwendt]

Improves the performance on cudf::strings::contains() for long strings. This executes a warp per string to match a target over sections of a single string in parallel. The benchmark showed this to be faster than the current implementation only for longer strings (greater than 64 bytes). It also proved somewhat faster and more consistent than a pure character-parallel approach.

This change may also help improve the performance of the regex contains_re() function in the future.

[codecov]

Codecov Report

Merging #10739 (1a63aad) into branch-22.06 (dc1435b) will increase coverage by 0.02%.
The diff coverage is n/a.

❗ Current head 1a63aad differs from pull request most recent head 669eea1. Consider uploading reports for the commit 669eea1 to get more accurate results

@@               Coverage Diff                @@
##           branch-22.06   #10739      +/-   ##
================================================
+ Coverage         86.37%   86.39%   +0.02%     
================================================
  Files               142      142              
  Lines             22306    22306              
================================================
+ Hits              19266    19272       +6     
+ Misses             3040     3034       -6     

Impacted Files	Coverage Δ
python/cudf/cudf/core/column/string.py	89.21% <0.00%> (+0.12%)	⬆️
python/cudf/cudf/core/groupby/groupby.py	91.68% <0.00%> (+0.23%)	⬆️
python/cudf/cudf/core/tools/datetimes.py	84.49% <0.00%> (+0.30%)	⬆️
python/cudf/cudf/core/column/lists.py	92.91% <0.00%> (+1.25%)	⬆️

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update dc1435b...669eea1. Read the comment docs.

[davidwendt]

Improvements to benchmarks ran locally on my dev machine:

rows/width        String    Warp     Speedup
4096/256         0.116 ms  0.050 ms   2.32x
4096/512         0.188 ms  0.056 ms   3.36x
4096/1024        0.348 ms  0.069 ms   5.04x
4096/2048        0.692 ms  0.095 ms   7.28x
4096/4096         1.25 ms  0.146 ms   8.56x
4096/8192         3.13 ms  0.238 ms  13.15x
32768/256        0.121 ms  0.071 ms   1.70x
32768/512        0.203 ms  0.098 ms   2.07x
32768/1024       0.470 ms  0.144 ms   3.26x
32768/2048        1.06 ms  0.240 ms   4.42x
32768/4096        2.00 ms  0.457 ms   4.38x
32768/8192        3.89 ms   1.09 ms   3.57x
262144/256        1.13 ms  0.238 ms   4.75x
262144/512        3.47 ms  0.402 ms   8.63x
262144/1024       8.49 ms  0.727 ms  11.68x
262144/2048       27.1 ms   1.39 ms  19.50x
262144/4096       57.3 ms   3.00 ms  19.10x
2097152/256       4.21 ms   1.61 ms   2.61x
2097152/512       16.1 ms   2.92 ms   5.51x

The rows is the size of the strings column and width is the average number of bytes per string. The String column is the benchmark time for contains() with the current implementation (thread per string). The Warp column is the implementation in this PR with a warp per string. The benchmark times not included here are where the values did not change -- the smaller row/width combinations.

[hyperbolic2346]

Very nice wins!

[bdice]

Great work. The speedups look good and the implementation/tests are clean.

[davidwendt]

@gpucibot merge