POC: Implement HOST_UDF aggregations

[ttnghia]

This implements HOST_UDF aggregations, allowing to call aggregations on external implemented functions.

Closes #16633.

---

Usage

1. Define a function with this signature:

std::unique_ptr<cudf::column> compute_aggregation(cudf::column_view const& values,
                                         cudf::device_span<cudf::size_type const> group_offsets,
                                         cudf::device_span<cudf::size_type const> group_labels,
                                         cudf::size_type num_groups,
                                         rmm::cuda_stream_view stream,
                                         rmm::device_async_resource_ref mr);

2. Make HOST_UDF aggregate instance with parameter is a function pointer pointing to that function:

auto agg = cudf::make_host_udf_aggregation<cudf::groupby_aggregation>(compute_aggregation);

3. Perform cudf aggregation operations on the created aggregate instance.

[ttnghia]

Working examples: https://github.com/rapidsai/cudf/pull/17249/files#diff-4997abf87c87e8b0d2382de63631f8671d484174f6bb1dc26453e49e77d395fa

[revans2]

Could we have some examples that actually do an aggregation? This is producing an output for each input value, but aggregations are supposed to produce an output for each group. Right?

[ttnghia]

Yes this is just a simple transformation. The input parameters have enough information (group offsets and labels) thus we can easily implement anything that we want on the group values.

[ttnghia]

I'm adding such examples now.

[ttnghia]

Now the examples are computing values for each individual group. For example:

For each group: compute (group_idx + 1)* values^2 * 2

[ttnghia]

This only passes group values (the first column parameter). It seems that we should better pass the group keys too, to have all the group information needed for generic computation.

[wence-]

suggestion: Why not ask the implementer of the host udf to provide hash and equality, like the other aggregations have?

[ttnghia]

Providing a name string should be enough for hashing agg here as we will hash a pair {aggregation::kind, udf_name_str}. That will be much simpler than providing a hash and equality functor.

[ttnghia]

Sorry I was wrong. Indeed, providing hash and equality operators seems to be the good way to go. I've added the interface for that in my latest idea: 57674e1