Convert rank to use to experimental row comparators

[divyegala]

Description

Converts the rank function to use experimental row comparators, which support list and struct types. Part of #11844.

Throughput benchmarks are available below. It seems like when size_bytes is constrained, the generator generates fewer rows in list types for increasing depths. That's why, depth=4 has a higher throughput than depth=1 because the number of leaf elements generated are the same, but with much fewer rows.

Checklist

• I am familiar with the Contributing Guidelines.
• New or existing tests cover these changes.
• The documentation is up to date with these changes.

[codecov]

Codecov Report

❗ No coverage uploaded for pull request base (branch-23.04@291c751). Click here to learn what that means.
Patch has no changes to coverable lines.

Additional details and impacted files

@@               Coverage Diff               @@
##             branch-23.04   #12481   +/-   ##
===============================================
  Coverage                ?   85.81%           
===============================================
  Files                   ?      158           
  Lines                   ?    25153           
  Branches                ?        0           
===============================================
  Hits                    ?    21586           
  Misses                  ?     3567           
  Partials                ?        0           

Help us with your feedback. Take ten seconds to tell us how you rate us. Have a feature suggestion? Share it here.

☔ View full report at Codecov.
📢 Do you have feedback about the report comment? Let us know in this issue.

[bdice]

Looks good overall. The actual comparator changes were fairly small, so the bulk of it is benchmarks and tests.

Can you post a benchmark result comparing the throughput (GB/s) of ranking lists of ints/floats to ranking plain ints or floats?

[divyegala]

Throughput: (GB/s)
int, rank_method::FIRST, null_frequency=0.2:

   nulls_type  size_bytes  throughput
0    no_nulls        4096    0.067143
1    no_nulls       16384    0.270018
2    no_nulls      131072    1.008052
3    no_nulls     1048576    7.954703
4    no_nulls     8388608   17.807422
5    no_nulls    67108864   17.511224
6    no_nulls   268435456   17.633304
7       nulls        4096    0.041735
8       nulls       16384    0.092360
9       nulls      131072    0.522772
10      nulls     1048576    2.862868
11      nulls     8388608    1.865691
12      nulls    67108864    1.905172
13      nulls   268435456    1.883955

List<int>, rank_method::FIRST:

    null_frequency  depth  size_bytes  throughput
0              0.0      1        1024    0.001656
1              0.0      1      262144    0.119881
2              0.0      1    16777216    0.322392
3              0.0      1   268435456    0.219398
4              0.0      4        1024    0.001183
5              0.0      4      262144    0.102692
6              0.0      4    16777216    1.481422
7              0.0      4   268435456    1.318262
8              0.2      1        1024    0.001730
9              0.2      1      262144    0.118890
10             0.2      1    16777216    0.439320
11             0.2      1   268435456    0.313680
12             0.2      4        1024    0.001368
13             0.2      4      262144    0.123197
14             0.2      4    16777216    1.981596
15             0.2      4   268435456    2.129115

[bdice]

It surprises me that lists of depth 4 achieve a higher throughput than lists of depth 1. Can you verify that result or comment on why you think that is happening? Are the "size_bytes" including list offsets, or just list contents (the leaf column of integers)?

[bdice]

All looks good -- I'll approve after we make a small tweak to the benchmark axes.

[bdice]

Looks good to me!

[bdice]

@divyegala Can you please tag the meta-issue #11844 in the description for all PRs that switch code to use experimental comparators? I edited the description for this PR.

[PointKernel]

LGTM

[divyegala]

/merge