[FEA] Remove numpy dependency

[vyasr]

Is your feature request related to a problem? Please describe.
I have thought about this issue for a while, and in light of #1760 I thought it would be worth raising. Currently rmm uses numpy in exactly one place and it's really just a shortcut to get host buffers with huge pages turned on.

Describe the solution you'd like
We should be able to trivially emulate this behavior by using madvise directly. Then we can remove numpy as a dependency altogether.

[vyasr]

@jakirkham may be able to comment on how useful this optimization even is right now since he added the relevant comment.

[bdice]

I think this is a good idea. I am first working on reducing Numba dependencies in #1760 / #1761. This would be a good follow-up.

[bdice]

It might be possible to get a buffer using huge pages on the host like this. (Snippet generated by ChatGPT o3-mini-high.)

import sys
import mmap

def allocate_buffer(size):
    """
    Allocate a memory buffer of the given size (in bytes).

    On Linux, this function attempts to allocate the buffer using huge pages
    by including the MAP_HUGETLB flag. On other platforms (e.g. Windows), it
    falls back to a standard anonymous mapping without huge pages.

    Parameters:
        size (int): Size of the buffer in bytes.

    Returns:
        tuple: (buf, mem_view) where:
            - buf is the mmap object managing the allocated memory.
            - mem_view is a memoryview for accessing the buffer as an array of unsigned bytes.

    Note:
        The memory remains allocated until the mmap object is closed. Since
        the memoryview holds a reference to the underlying buffer, do not
        close the mmap while the memoryview is still in use.
    """
    if sys.platform.startswith("linux"):
        # Linux-specific flag for huge pages.
        MAP_HUGETLB = 0x40000
        flags = mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS | MAP_HUGETLB
        buf = mmap.mmap(-1, size, flags=flags)
    else:
        # On non-Linux systems, simply create an anonymous mapping.
        buf = mmap.mmap(-1, size)
    
    mem_view = memoryview(buf)
    return buf, mem_view

# Example usage:
if __name__ == "__main__":
    size_in_bytes = 1024 * 1024  # Allocate 1 MB of memory
    buf, view = allocate_buffer(size_in_bytes)
    print(f"Allocated buffer of size: {size_in_bytes} bytes")
    
    # Use the buffer as needed...
    
    # Remember to close the mmap when you're done to free the memory.
    buf.close()

[jakirkham]

Could you please explain why this is needed? NumPy is a common dependency certainly for any users of RAPIDS.

What would removing NumPy as a dependency accomplish that is not already possible today?

[vyasr]

I'm generally a fan of slimmer dependencies for any number of reasons including smaller environments, faster package solves, faster import times, less external sources of breakage, etc. It also makes it easier to integrate into other libraries as a dependency (the same reason that @leofang has pushed so hard to keep cuda-python dependency-free). In this particular case rmm contains functionality that we'd like to be able to use in many places that don't really need numpy. To give one concrete example, once we make pyarrow an optional dependency pylibcudf will no longer need numpy. That in turn means that cudf-polars will no longer need pyarrow or numpy, which will make our Polars friends happy since keeping their dependency list as near zero as possible is an explicit goal of theirs.

[leofang]

There must be a point beyond which we push less hard about zero-dependency. If everyone thinks this is the right way to go, there is no software that we can reuse in libraries we maintain, even within NVIDIA. Same discussion was raised recently for cuda-core (NVIDIA/cuda-python#511) and I think we are reaching this point.

[vyasr]

Certainly, I agree with that. In fact I've pushed in that direction in other cases too where I think removing a dependency would be too hard and cost too much. In this case, though, we use numpy in exactly one place in all of rmm, and it's really just to get an OS-level optimization. That being said, I don't think we should invest all that much effort in this. It's only worth doing if it's easy.

[bdice]

NumPy is a library that I feel perfectly comfortable requiring in almost all cases but the use in RMM isn’t enough imo. The single usage is not enough to justify the dependency, because it’s not even for interop or array purposes. It’s just used to get huge pages on a host buffer allocation. If we can achieve this without the dependency, I think that is a good idea.