[REVIEW] Fix cudf::strings:split logic for many columns

[davidwendt]

Closes #4885
The cudf::strings::split() and cudf::strings::rsplit() logic builds a column for each set of tokens by splitting a single string column vertically. That is, all of the first tokens for each string are placed in the first response column. The 2nd tokens in the second column, etc. The number of columns returned is based on the string with the most tokens.

The split()/rsplit() logic was creating each column individually to perhaps minimize memory usage. This means finding the strings for column 10 required parsing through 9 delimiters of each string and then finding the strings for column 11 repeated the same process to 10 delimiters.

As a baseline, I tested with 1000 rows of strings each with ~2KB of characters containing uniformly placed comma "," characters. Running split() with a ',' delimiter creates 100 columns. Pandas execution is about 50ms on my machine. The cudf::strings::split() call was 6.1s. Further details in #4885. An nsys profile showed that ~100ms was spent counting the tokens and the rest was iteratively building the columns. This included interleaved calls to make_strings_column.

The new approach for this PR is to create all the token positions for all string first and then just gather the appropriate token positions into a vector in order to call make_strings_column factory that accepts pointer/position pairs. This sped up the performance significantly since resolving each column did not need to restart searching from the beginning of each string.

Next, code was added to find delimiters by parallelizing the search over all the chars column bytes instead of just per string. Then, each delimiter was associated to its corresponding string by using upper_bound on the offsets column with the delimiter positions. Now it was a matter of computing the token positions purely from the delimiter positions. This reduced the split() time to about 150ms.

A further optimization was made by computing the number of tokens by just using the delimiters positions as well. This final solution executes in 15ms which is about 400x improvement overall. The speedup over Pandas increases with the number of strings.

rows\cols	100	200	300	400
1000	1.4x	1.4x	1.5x	1.6x
10000	12.9x	12.6x	14.3	15.3x
50000	51.8x	50.2x	54.5	63.5x
100000	73.9x	80.1x	82.9	95.1x

Additional changes in this PR

• moved the contiguous_split_record functions to their own source file (split_record.cu); no code was common and there was no practical reason for this to be in the same source file as regular split()
• fixed a bug in the column_utilities when printing strings with no validity mask
• fixed compile warning in rolling.cu because it bugged me
• added more split/rsplit tests

[codecov]

Codecov Report

Merging #4922 into branch-0.14 will not change coverage.
The diff coverage is n/a.

@@             Coverage Diff              @@
##           branch-0.14    #4922   +/-   ##
============================================
  Coverage        88.43%   88.43%           
============================================
  Files               54       54           
  Lines            10201    10201           
============================================
  Hits              9021     9021           
  Misses            1180     1180           

---

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 5bc4ede...5bc4ede. Read the comment docs.

[davidwendt]

This is not new code. This code was simply moved out of split.cu in which it shared no common code.

[davidwendt]

This simply removes a compile warning.

[kkraus14]

cmake is good

[trevorsm7]

Left some comments about comments, but mainly would like to see a test case for overlapping delimiters

[trevorsm7]

Test for overlapping separators looks good