[DOC] Document memory resource lifetime requirements when taking ownership of device buffers in Python

[wence-]

An rmm::device_buffer holds a (effectively) raw pointer to the memory resource used for its allocation and deallocation. On the C++ side, it is the responsibility of the constructor a device_buffer to ensure that the memory resource lives at least as long as the buffer.

When we expose a device_buffer to Python through the cython DeviceBuffer class (specifically, when we use DeviceBuffer.c_from_unique_ptr which is used in many places in cudf), we have no way of inspecting the provenance of the memory resource used to allocate that buffer, so we have no way of keeping it alive.

Right now, the way we handle this in the cython wrappers is to throw our hands up in the air, grab the current_device_resource, cross our fingers and hope.

This has worked so far because usually no-one switches out a memory resource from under us, and generally speaking in cudf we're taking ownership of buffers that have ultimately been allocated on the python side, but it's not actually safe.

Unless we're willing to make the memory resource slot in a device buffer hold a smart pointer, and I believe there are good reasons why we do not do that at the moment, the best we can do is document the requirements on the Python side and then obey them when using RMM from cudf.

[vyasr]

For a cudf-specific example and discussion, see rapidsai/cudf#14229

[jrhemstad]

When we expose a device_buffer to Python through the cython DeviceBuffer class (specifically, when we use DeviceBuffer.c_from_unique_ptr which is used in many places in cudf), we have no way of inspecting the provenance of the memory resource used to allocate that buffer

You can't inspect the provenance after the fact, no, but you control what resource is used to construct the buffer in the first place, yes?

A sketch of what I mean:

struct buffer_that_owns_resource{
   device_buffer b_;
   std::shared_ptr<device_memory_resource> mr_;
};


std::shared_ptr<device_memory_resource> mr{...};
device_buffer b = cudf::some_function(..., mr.get());

auto owning = buffer_that_owns_resource{std::move(b), mr};

This enables you to have the effective equivalent of if device_buffer owned its mr.

[wence-]

You can't inspect the provenance after the fact, no, but you control what resource is used to construct the buffer in the first place, yes?

We do, although we don't currently use what you propose (or a moral equivalent thereof) in cudf-python for (I presume) historical reasons.

However, since we're continuing to advocate for rmm as a cross-library allocator, we need to make these requirements (I think) clearer in the docs than they are currently.