[FEA] Support reading "chunks" of large text files w/ cudf.read_text

[randerzander]

While using cudf's read_text API, I've come across datasets w/ single files that are much larger (200gb+) than any single GPU's memory.

I can parse and split them into smaller pieces on the CPU first, but that is slow and expensive.

Ideally, read_text would support parameters like read_csv's nrows & skiprows parameters so I can either read serially in batches (or parallely with multiple GPUs).

For example, with input
file.txt:

0somestring*EOR*
1someotherstring*EOR*
2someotherhugeVERYlongstring*EOR*

I could do:

import cudf

delim = '*EOR*\n'
ser1 = cudf.read_txt('file.txt', delimiter=delim, nrows=2)
process_data(ser1)

del ser1
ser2 = cudf.read_txt('file.txt', delimiter=delim, skiprows=2)
process_data(ser2)

I think implementing this correctly without corrupting or dropping records would depend on reading an arbitrary number of bytes in chunks, and detecting that:

1. At the end of one chunk, a partial record (no EOR was seen) and should be dropped
2. At the beginning of one chunk, a partial record was read and I should read backwards an additional number of bytes (to the next EOR)

cc @quasiben , @cwharris

[cwharris]

I think implementing this correctly without corrupting or dropping records would depend on reading an arbitrary number of bytes in chunks, and detecting that:
At the end of one chunk, a partial record (no EOR was seen) and should be dropped
At the beginning of one chunk, a partial record was read and I should read backwards an additional number of bytes (to the next EOR)

I think this is a good understanding of the problem, and a viable solution. It is similar to how we handle CSV parsing today. However, this approach is limited in that each GPU must read from the beginning of the file up through the relevant byte range. Whereas ideally, each GPU only needs to read the relevant byte range.

@randerzander and I discussed breaking the API in to multiple (two) phases to reduce the overall number of bytes each GPU needs to read from the input file.

1. each GPU reads the relevant byte range, and uses it to produce a GPU-partial aggregation of the machine state.
2. inclusive scan the GPU-partial machine states to produce true starting state seeds for each GPU.
3. each GPU uses the true starting state to begin parsing records, ignoring all characters up to the first record start, and greedily taking the last record, regardless of whether it extends past the byte range end. In this way, if a record begins on a GPU, it is read to that GPU.

NOTE:

Both this approach and the current CSV approach read the file multiple times. The primary difference is that by sharing information across GPUs, we eliminate the need for each GPU to read from the beginning of the file.

[github-actions]

This issue has been labeled inactive-30d due to no recent activity in the past 30 days. Please close this issue if no further response or action is needed. Otherwise, please respond with a comment indicating any updates or changes to the original issue and/or confirm this issue still needs to be addressed. This issue will be labeled inactive-90d if there is no activity in the next 60 days.