[FEA] Throw std::overflow exception when an output column size exceeds cudf limit

[ttnghia]

In Spark, we want to handle the cases when the libcudf APIs throw exception due to their output column having sizes exceeding cudf limit. We want to differentiate if the thrown exception was really due to such reason (so we can split the input by half and try again), or due to something else (such as invalid input type or inconsistent data type etc). Unfortunately, currently only one type of exception (cudf::logic_error) is being thrown.

We want to have a new specific exception type with a name like cudf::output_size_exceed_limit. This exception type will be used to throw in the case mentioned above. Adding this new exception type is similar to #12426 which introduced a new exception type to throw when the input data type is invalid.

[vyasr]

Please raise this issue for discussion on Slack or in the next team meeting. It would be great to consider whether there should be different exceptions for compound (strings) columns than for other columns too. I am not necessarily advocating this, but it's something to consider in case there are different ways that a caller could attempt to mitigate one scenario than the other (CC @davidwendt).

Depending on what decision is made, please update #12885 accordingly.

[ttnghia]

I think it is relevant not just for strings column. For example, we have the concatenate and interleave APIs that appends columns one after another, or interleaves rows of the input columns. If the total size of the input exceeds cudf limit, we can also throw the proposed exception above, indicating the exact failure reason. The interleave API can still split retry again with half size input.

[davidwendt]

The cudf::concatenate API already uses std::overflow_error for this:
https://docs.rapids.ai/api/libcudf/nightly/group__copy__concatenate.html#ga8589afe8526e0ba8c4a149ab6cb58453

cudf/cpp/src/copying/concatenate.cu

Lines 475 to 477 in 173fde9

	CUDF_EXPECTS(total_row_count <= static_cast<size_t>(std::numeric_limits<size_type>::max()),
	"Total number of concatenated rows exceeds size_type range",
	std::overflow_error);

I would prefer we use std::overflow_error exception for the output column size limit check rather than create a new cudf exception.

[ttnghia]

That can be fine, only still a minor issue if std::overflow_error is thrown by other code rather than our check for column size. But I assume that such issue will not show up very soon so let's use that std exception.