API 参考

模块内容

class rmm.DeviceBuffer

基类: object

属性:

nbytes: 获取缓冲区的大小（字节）。
ptr: 获取指向底层数据的指针。
size: 获取缓冲区的大小（字节）。

方法

`capacity`(self)
`copy`(self)	返回 DeviceBuffer 的副本。
`copy_from_device`(self, cuda_ary, ...)	从主机上的缓冲区复制到 `self`
`copy_from_host`(self, ary, ...)	从主机上的缓冲区复制到 `self`
`copy_to_host`(self[, ary])	从 `DeviceBuffer` 复制到主机上的缓冲区。
`prefetch`(self[, device, stream])	在指定的流上，将缓冲区数据预取到指定的设备。
`reserve`(self, size_t new_capacity, ...)
`resize`(self, size_t new_size, ...)
`to_device`(const unsigned char[, ...)	对提供的参数调用 `to_device` 函数。
`tobytes`(self, Stream stream=DEFAULT_STREAM)

capacity(self) → size_t

copy(self)

返回 DeviceBuffer 的副本。

返回:

现有 DeviceBuffer 的深层副本

示例

>>> import rmm
>>> db = rmm.DeviceBuffer.to_device(b"abc")
>>> db_copy = db.copy()
>>> db.copy_to_host()
array([97, 98, 99], dtype=uint8)
>>> db_copy.copy_to_host()
array([97, 98, 99], dtype=uint8)
>>> assert db is not db_copy
>>> assert db.ptr != db_copy.ptr

copy_from_device(self, cuda_ary, Stream stream=DEFAULT_STREAM)

从主机上的缓冲区复制到 self

参数:

cuda_ary具有 __cuda_array_interface__ 接口的对象（从中复制）
stream用于复制的 CUDA 流，默认为默认流

示例

>>> import rmm
>>> db = rmm.DeviceBuffer(size=5)
>>> db2 = rmm.DeviceBuffer.to_device(b"abc")
>>> db.copy_from_device(db2)
>>> hb = db.copy_to_host()
>>> print(hb)
array([97, 98, 99,  0,  0], dtype=uint8)

copy_from_host(self, ary, Stream stream=DEFAULT_STREAM)

从主机上的缓冲区复制到 self

参数:

ary类似 bytes 的缓冲区（从中复制）
stream用于复制的 CUDA 流，默认为默认流

示例

>>> import rmm
>>> db = rmm.DeviceBuffer(size=10)
>>> hb = b"abcdef"
>>> db.copy_from_host(hb)
>>> hb = db.copy_to_host()
>>> print(hb)
array([97, 98, 99,  0,  0,  0,  0,  0,  0,  0], dtype=uint8)

copy_to_host(self, ary=None, Stream stream=DEFAULT_STREAM)

从 DeviceBuffer 复制到主机上的缓冲区。

参数:

ary类似 bytes 的缓冲区（写入目标）
stream用于复制的 CUDA 流，默认为默认流

示例

>>> import rmm
>>> db = rmm.DeviceBuffer.to_device(b"abc")
>>> hb = bytearray(db.nbytes)
>>> db.copy_to_host(hb)
>>> print(hb)
bytearray(b'abc')
>>> hb = db.copy_to_host()
>>> print(hb)
bytearray(b'abc')

nbytes: 获取缓冲区的大小（字节）。

prefetch(self, device=None, stream=None)

在指定的流上，将缓冲区数据预取到指定的设备。

假设此 DeviceBuffer 的存储空间是 CUDA 管理内存（统一内存）。如果不是，此函数将不执行任何操作（no-op）。

参数:

device可选: 要将此缓冲区的内存预取到的 CUDA 设备。默认为当前 CUDA 设备。要预取到 CPU，请将 cudaCpuDeviceId 作为 device 传入。
stream可选: 用于预取的 CUDA 流。默认为 self.stream

ptr: 获取指向底层数据的指针。

reserve(self, size_t new_capacity, Stream stream=DEFAULT_STREAM) → void

resize(self, size_t new_size, Stream stream=DEFAULT_STREAM) → void

size: 获取缓冲区的大小（字节）。

static to_device(const unsigned char[::1] b, Stream stream=DEFAULT_STREAM): 对提供的参数调用 to_device 函数。

tobytes(self, Stream stream=DEFAULT_STREAM) → bytes

exception rmm.RMMError(errcode, msg): 基类: Exception

rmm.disable_logging(): 如果之前使用 rmm.initialize() 或 rmm.enable_logging() 启用了日志记录，则禁用日志记录。

rmm.enable_logging(log_file_name=None)

为所有设备启用运行时事件的日志记录。

参数:

log_file_name: str, 可选: 日志文件的名称。如果未指定，则使用环境变量 RMM_LOG_FILE。如果两者均不可用，则抛出 ValueError。每个设备都会生成一个单独的日志文件，并且后缀 “.dev{id}” 会自动添加到日志文件名称中。

注意

请注意，如果在启用日志记录的情况下使用环境变量 CUDA_VISIBLE_DEVICES，后缀可能与您的预期不同。例如，如果设置 CUDA_VISIBLE_DEVICES=1，生成的日志文件后缀仍将是 0。类似地，如果设置 CUDA_VISIBLE_DEVICES=1,0 并使用设备 0 和 1，后缀为 0 的日志文件将对应于设备 ID 为 1 的 GPU。使用 rmm.get_log_filenames() 获取每个设备对应的日志文件名称。

rmm.flush_logger()

刷新调试日志记录器。这将导致所有缓冲的日志消息写入日志文件。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

另请参阅

set_flush_level: 设置调试日志记录器的刷新级别。
get_flush_level: 获取当前的调试日志记录刷新级别。

示例

>>> import rmm
>>> rmm.flush_logger() # flush the logger

rmm.get_flush_level()

获取 RMM 日志记录器的当前调试日志记录刷新级别。此级别或更高级别的消息将自动刷新到文件。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

返回:

logging_level: 当前刷新级别，是 logging_level 枚举的一个实例。

另请参阅

set_flush_level: 设置日志记录器的刷新级别。
flush_logger: 刷新日志记录器。

示例

>>> import rmm
>>> rmm.flush_level() # get current flush level
<logging_level.INFO: 2>

rmm.get_log_filenames()

返回正在使用的每个设备的日志文件名称（如果未写入日志，则返回 None）。

示例

>>> import rmm
>>> rmm.reinitialize(devices=[0, 1], logging=True, log_file_name="rmm.log")
>>> rmm.get_log_filenames()
{0: '/home/user/workspace/rapids/rmm/python/rmm.dev0.log',
 1: '/home/user/workspace/rapids/rmm/python/rmm.dev1.log'}

rmm.get_logging_level()

获取当前的调试日志记录级别。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

返回:

levellogging_level: 当前的调试日志记录级别，是 logging_level 枚举的一个实例。

另请参阅

set_logging_level: 设置调试日志记录级别。

示例

>>> import rmm
>>> rmm.get_logging_level() # get current logging level
<logging_level.INFO: 2>

rmm.is_initialized(): 如果 RMM 已初始化，则返回 True，否则返回 False。

class rmm.level_enum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

基类: IntEnum

属性:

denominator: 化为最简分数后的分母
imag: 复数的虚部
numerator: 化为最简分数后的分子
real: 复数的实部

方法

`as_integer_ratio`(/)	返回一对整数，其比率等于原始整数。
`bit_count`(/)	self 绝对值的二进制表示中 1 的数量。
`bit_length`(/)	在二进制中表示 self 所需的位数。
`conjugate`	返回 self，任意整数的复共轭。
`from_bytes`(/, bytes[, byteorder, signed])	返回给定字节数组表示的整数。
`is_integer`(/)	返回 True。
`to_bytes`(/[, length, byteorder, signed])	返回表示整数的字节数组。

critical = 5

debug = 1

error = 4

info = 2

n_levels = 7

off = 6

trace = 0

warn = 3

rmm.register_reinitialize_hook(func, *args, **kwargs)

将函数添加到在调用 reinitialize() 之前将被调用的函数列表（“钩子”）中。

用户或库可以注册钩子，以便在重新初始化 RMM 之前执行任何必要的清理工作。例如，一个库可能维护一个内部对象缓存，这些对象使用了 RMM 分配的设备内存。该库可以注册一个钩子，在 RMM 重新初始化之前释放这些引用，从而确保相关的设备内存资源可以被释放。

钩子按照注册的相反顺序调用。这很有用，例如，当一个库注册了多个钩子，并且需要它们以特定顺序运行以确保清理安全时。钩子不能依赖于相对于其他包注册的钩子的特定注册顺序，因为这取决于包的导入顺序。

参数:

func可调用对象: 在调用 reinitialize() 之前要调用的函数
args, kwargs: 要传递给 func 的位置参数和关键字参数

rmm.reinitialize(pool_allocator=False, managed_memory=False, initial_pool_size=None, maximum_pool_size=None, devices=0, logging=False, log_file_name=None)

使用传入的选项完成然后初始化 RMM。使用先前 RMM 初始化中的内存是未定义行为，应避免。

参数:

pool_allocatorbool, 默认为 False: 如果为 True，则使用池分配策略，这可以显著提高性能。
managed_memorybool, 默认为 False: 如果为 True，则使用管理内存进行设备内存分配
initial_pool_sizeint | str, 默认为 None: 当 pool_allocator 为 True 时，这表示初始池大小（字节）。默认情况下，使用总 GPU 内存的 1/2。当 pool_allocator 为 False 时，如果提供此参数，则将被忽略。字符串参数使用 parse_bytes 进行解析。
maximum_pool_sizeint | str, 默认为 None: 当 pool_allocator 为 True 时，这表示最大池大小（字节）。默认情况下，使用 GPU 上的总可用内存。当 pool_allocator 为 False 时，如果提供此参数，则将被忽略。字符串参数使用 parse_bytes 进行解析。
devicesint 或 List[int], 默认为 0: 要注册的 GPU 设备 ID。默认情况下仅注册 GPU 0。
loggingbool, 默认为 False: 如果为 True，则启用所有内存事件（分配、释放、重新分配）的运行时日志记录。这会对性能产生显著影响。
log_file_namestr: 日志文件的名称。如果未指定，则使用环境变量 RMM_LOG_FILE。如果两者均不可用，则抛出 ValueError。每个设备都会生成一个单独的日志文件，并且后缀 “.dev{id}” 会自动添加到日志文件名称中。

注意

请注意，如果在启用日志记录的情况下使用环境变量 CUDA_VISIBLE_DEVICES，后缀可能与您的预期不同。例如，如果设置 CUDA_VISIBLE_DEVICES=1，生成的日志文件后缀仍将是 0。类似地，如果设置 CUDA_VISIBLE_DEVICES=1,0 并使用设备 0 和 1，后缀为 0 的日志文件将对应于设备 ID 为 1 的 GPU。使用 rmm.get_log_filenames() 获取每个设备对应的日志文件名称。

rmm.set_flush_level(level)

设置调试日志记录器的刷新级别。此级别或更高级别的消息将自动刷新到文件。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

参数:

levellogging_level: 调试日志记录级别。有效值为 logging_level 枚举的实例。

抛出:

TypeError: 如果日志记录级别不是 logging_level 枚举的实例。

另请参阅

get_flush_level: 获取当前的调试日志记录刷新级别。
flush_logger: 刷新日志记录器。

示例

>>> import rmm
>>> rmm.flush_on(rmm.logging_level.WARN) # set flush level to warn

rmm.set_logging_level(level)

设置调试日志记录级别。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

参数:

levellogging_level: 调试日志记录级别。有效值为 logging_level 枚举的实例。

抛出:

TypeError: 如果日志记录级别不是 logging_level 枚举的实例。

另请参阅

get_logging_level: 获取当前的调试日志记录级别。

示例

>>> import rmm
>>> rmm.set_logging_level(rmm.logging_level.WARN) # set logging level to warn

rmm.should_log(level)

检查给定级别的一条消息是否会被记录。

如果当前调试日志记录级别设置为不低于给定级别的详细程度，并且 RMM 模块编译时的日志记录级别也不低于给定级别，则给定级别的一条消息将被记录。如果这两个条件不同时满足，此函数将返回 false。

调试日志记录将消息打印到日志文件。有关更多信息，请参见调试日志记录。

参数:

levellogging_level: 调试日志记录级别。有效值为 logging_level 枚举的实例。

返回:

should_logbool: 如果给定级别的一条消息会被记录，则为 True，否则为 False。

抛出:

TypeError: 如果日志记录级别不是 logging_level 枚举的实例。

rmm.unregister_reinitialize_hook(func)

从在调用 reinitialize() 之前将被调用的钩子列表中移除 func。

如果 func 被多次注册，它的所有实例都将从钩子列表中移除。

内存资源

class rmm.mr.ArenaMemoryResource(DeviceMemoryResource upstream_mr, arena_size=None, bool dump_log_on_failure=False)

基类： UpstreamResourceAdaptor

一个强调避免碎片和支持可扩展并发的子分配器。

参数:

upstream_mrDeviceMemoryResource: 用于为内存区域分配内存的 DeviceMemoryResource。
arena_sizeint, optional: 全局内存区域的大小，单位为字节。默认为当前设备可用内存的一半。
dump_log_on_failurebool, optional: 是否在分配失败时转储内存区域。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.BinningMemoryResource(DeviceMemoryResource upstream_mr, int8_t min_size_exponent=-1, int8_t max_size_exponent=-1)

基类： UpstreamResourceAdaptor

根据指定分配大小，从一组指定的“bin”大小中分配内存。

如果指定了 min_size_exponent 和 max_size_exponent，则初始化一个或多个 FixedSizeMemoryResource bin，范围为 [2**min_size_exponent, 2**max_size_exponent]。

调用 add_bin() 添加额外的 bin 分配器。

参数:

upstream_mrDeviceMemoryResource: 用于分配大于任何 bin 大小的内存资源的分配器。
min_size_exponentsize_t: 要创建的最小尺寸 FixedSizeMemoryResource bin 的以2为底的指数。
max_size_exponentsize_t: 要创建的最大尺寸 FixedSizeMemoryResource bin 的以2为底的指数。

属性:

bin_mrs: BinningMemoryResource.bin_mrs: list 获取分 bin 内存资源列表。
upstream_mr

方法

`add_bin`(self, size_t allocation_size, ...)	向此内存资源添加一个指定最大分配大小的 bin。
`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

add_bin(self, size_t allocation_size, DeviceMemoryResource bin_resource=None)

向此内存资源添加一个指定最大分配大小的 bin。如果指定了 bin_resource，则使用它进行此 bin 的分配。如果未指定，则为此 bin 创建并使用 FixedSizeMemoryResource 进行分配。

小于 allocation_size 且大于下一个更小 bin 大小的分配将使用此固定大小内存资源。

参数:

allocation_sizesize_t: 创建的 bin 的最大分配大小，单位为字节
bin_resourceDeviceMemoryResource: 用于此 bin 的资源（可选）

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

bin_mrs: BinningMemoryResource.bin_mrs: list 获取分 bin 内存资源列表。

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.CallbackMemoryResource(allocate_func, deallocate_func)

基类： DeviceMemoryResource

使用用户提供的可调用对象进行内存分配和释放的内存资源。

CallbackMemoryResource 实际上只应用于调试内存问题，因为为每个内存分配和释放操作使用 Python 函数会带来显著的性能损失。

参数:

allocate_func: callable: 分配函数必须接受两个参数。一个整数表示要分配的字节数，以及执行分配的 Stream；并返回一个整数，表示指向已分配内存的指针。
deallocate_func: callable: 释放函数必须接受三个参数。一个整数表示指向要释放的内存的指针，第二个整数表示要释放的字节数，以及执行释放的 Stream。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

示例

>>> import rmm
>>> base_mr = rmm.mr.CudaMemoryResource()
>>> def allocate_func(size, stream):
...     print(f"Allocating {size} bytes")
...     return base_mr.allocate(size, stream)
...
>>> def deallocate_func(ptr, size, stream):
...     print(f"Deallocating {size} bytes")
...     return base_mr.deallocate(ptr, size, stream)
...
>>> rmm.mr.set_current_device_resource(
    rmm.mr.CallbackMemoryResource(allocate_func, deallocate_func)
)
>>> dbuf = rmm.DeviceBuffer(size=256)
Allocating 256 bytes
>>> del dbuf
Deallocating 256 bytes

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.CudaAsyncMemoryResource

基类： DeviceMemoryResource

使用 cudaMallocAsync/cudaFreeAsync 进行分配/释放的内存资源。

参数:

initial_pool_sizeint | str, optional: 初始池大小，单位为字节。默认为设备可用内存的一半。字符串参数使用 parse_bytes 进行解析。
release_threshold: int, optional: 释放阈值，单位为字节。如果池大小超出此值，则池持有的未使用内存将在下一个同步点释放。
enable_ipc: bool, optional: 如果为 True，则允许导出此资源分配的内存的 POSIX 文件描述符句柄，以便可以与 CUDA IPC 一起使用。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.CudaAsyncViewMemoryResource

基类： DeviceMemoryResource

使用 cudaMallocAsync/cudaFreeAsync 与现有 CUDA 内存池进行分配/释放的内存资源。

此资源使用现有的 CUDA 内存池句柄（例如默认池），而不是创建一个新的。这对于与已使用 CUDA 内存池的现有 GPU 应用程序集成或自定义内存池使用的标志非常有用。

传入的内存池在此内存资源的生命周期内不得被销毁。

参数:

pool_handlecudaMemPool_t or CUmemoryPool: CUDA 内存池的句柄，将用于处理分配请求。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`pool_handle`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

pool_handle(self)

class rmm.mr.CudaMemoryResource

基类： DeviceMemoryResource

使用 cudaMalloc/cudaFree 进行分配/释放的内存资源。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.DeviceMemoryResource

基类: object

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.FailureCallbackResourceAdaptor(DeviceMemoryResource upstream_mr, callback)

基类： UpstreamResourceAdaptor

内存资源，在内存分配失败时调用回调函数。

参数:

upstreamDeviceMemoryResource: 上游内存资源。
callbackcallable: 内存分配失败时调用的函数。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.FixedSizeMemoryResource(DeviceMemoryResource upstream_mr, size_t block_size=0x100000, size_t blocks_to_preallocate=128)

基类： UpstreamResourceAdaptor

分配固定大小内存块的内存资源。

参数:

upstream_mrDeviceMemoryResource: 用于为池分配内存块的 DeviceMemoryResource。
block_sizeint, optional: 要分配的内存块大小（默认为 1MiB）。
blocks_to_preallocateint, optional: 初始化池时要分配的内存块数量。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

注意

仅支持小于配置的 block_size 的分配。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.LimitingResourceAdaptor(DeviceMemoryResource upstream_mr, size_t allocation_limit)

基类： UpstreamResourceAdaptor

限制上游内存资源总分配量的内存资源。

参数:

upstream_mrDeviceMemoryResource: 上游内存资源。
allocation_limitsize_t: 此分配器允许的最大内存量。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_allocated_bytes`(self)	查询已分配的字节数。
`get_allocation_limit`(self)	查询此分配器允许分配的最大字节数。
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_allocated_bytes(self) → size_t: 查询已分配的字节数。请注意，由于可能的碎片以及此分配器未跟踪的内部页面大小和对齐方式，此方法不能用于了解可能的分配大小。

get_allocation_limit(self) → size_t: 查询此分配器允许分配的最大字节数。这是对分配器的限制，而不是对底层设备的表示。设备可能无法支持此限制。

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.LoggingResourceAdaptor(DeviceMemoryResource upstream_mr, log_file_name=None)

基类： UpstreamResourceAdaptor

记录上游内存资源执行的分配/释放信息的内存资源。

参数:

upstreamDeviceMemoryResource: 上游内存资源。
log_file_namestr: 写入日志文件的路径。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`flush`(self)
`get_file_name`(self)
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

flush(self)

get_file_name(self)

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.ManagedMemoryResource

基类： DeviceMemoryResource

使用 cudaMallocManaged/cudaFree 进行分配/释放的内存资源。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.PoolMemoryResource(DeviceMemoryResource upstream_mr, initial_pool_size=None, maximum_pool_size=None)

基类： UpstreamResourceAdaptor

合并式最优适应子分配器，使用从上游内存资源分配的内存池。

参数:

upstream_mrDeviceMemoryResource: 用于为池分配内存块的 DeviceMemoryResource。
initial_pool_sizeint | str, optional: 初始池大小，单位为字节。默认为设备可用内存的一半。
maximum_pool_sizeint | str, optional: 池可以增长到的最大大小，单位为字节。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)
`pool_size`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

pool_size(self)

upstream_mr

class rmm.mr.PrefetchResourceAdaptor(DeviceMemoryResource upstream_mr)

基类： UpstreamResourceAdaptor

预取所有分配的内存资源。

参数:

upstreamDeviceMemoryResource: 上游内存资源。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

class rmm.mr.SamHeadroomMemoryResource(size_t headroom)

基类： DeviceMemoryResource

使用 malloc/free 进行分配/释放的内存资源。

参数:

headroomsize_t: 作为 headroom 保留的 GPU 内存大小

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.StatisticsResourceAdaptor(DeviceMemoryResource upstream_mr)

基类： UpstreamResourceAdaptor

跟踪上游内存资源执行的当前、峰值和总分配/释放的内存资源。包括随时查询这些统计信息的能力。

维护一个计数器堆栈。使用 push_counters() 和 pop_counters() 在不同的嵌套级别跟踪统计信息。

参数:

upstreamDeviceMemoryResource: 上游内存资源。

属性:

allocation_counts: StatisticsResourceAdaptor.allocation_counts: Statistics
upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)
`pop_counters`(self)	从堆栈中弹出一对计数器（字节数和分配次数）
`push_counters`(self)	将一对新的计数器（字节数和分配次数）压入堆栈

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

allocation_counts

StatisticsResourceAdaptor.allocation_counts: Statistics

获取当前、峰值和总分配字节数以及分配次数。

字典键包括 current_bytes, current_count, peak_bytes, peak_count, total_bytes 和 total_count。

返回: dict: 包含分配次数和字节数的字典。

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

pop_counters(self) → Statistics

从堆栈中弹出一对计数器（字节数和分配次数）

返回:

弹出的统计信息

push_counters(self) → Statistics

将一对新的计数器（字节数和分配次数）压入堆栈

返回:

压栈 _之前_ 的统计信息

upstream_mr

class rmm.mr.SystemMemoryResource

基类： DeviceMemoryResource

使用 malloc/free 进行分配/释放的内存资源。

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

class rmm.mr.TrackingResourceAdaptor(DeviceMemoryResource upstream_mr, bool capture_stacks=False)

基类： UpstreamResourceAdaptor

记录和跟踪上游内存资源执行的分配/释放的内存资源。如果需要，可以查询所有未完成的分配，并包含堆栈跟踪信息。

参数:

upstreamDeviceMemoryResource: 上游内存资源。
capture_stacksbool: 是否在每次分配时捕获堆栈跟踪。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_allocated_bytes`(self)	查询已分配的字节数。
`get_outstanding_allocations_str`(self)	返回一个字符串，其中包含当前未完成分配的信息。
`get_upstream`(self)
`log_outstanding_allocations`(self)	如果启用，则将 get_outstanding_allocations_str 的输出记录到当前的 RMM 日志文件。

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_allocated_bytes(self) → size_t: 查询已分配的字节数。请注意，由于可能的碎片以及此分配器未跟踪的内部页面大小和对齐方式，此方法不能用于了解可能的分配大小。

get_outstanding_allocations_str(self) → str: 返回一个字符串，其中包含当前未完成分配的信息。对于每个分配，将显示地址、大小和可选的堆栈跟踪信息。

get_upstream(self) → DeviceMemoryResource

log_outstanding_allocations(self): 如果启用，则将 get_outstanding_allocations_str 的输出记录到当前的 RMM 日志文件。

upstream_mr

class rmm.mr.UpstreamResourceAdaptor

基类： DeviceMemoryResource

跟踪上游资源的内存资源的父类。

上游资源跟踪需要维护对上游 mr 的引用，以便它保持活动状态，并可由任何下游资源适配器访问。

属性:

upstream_mr

方法

`allocate`(self, size_t nbytes, ...)	分配 `nbytes` 字节的内存。
`deallocate`(self, uintptr_t ptr, ...)	释放 `ptr` 指向的、大小为 `nbytes` 的内存。
`get_upstream`(self)

allocate(self, size_t nbytes, Stream stream=DEFAULT_STREAM)

分配 nbytes 字节的内存。

参数:

nbytessize_t: 分配的大小，单位为字节
streamStream: 分配的可选流

deallocate(self, uintptr_t ptr, size_t nbytes, Stream stream=DEFAULT_STREAM)

释放 ptr 指向的、大小为 nbytes 的内存。

参数:

ptruintptr_t: 要释放的指针
nbytessize_t: 分配的大小，单位为字节
streamStream: 释放的可选流

get_upstream(self) → DeviceMemoryResource

upstream_mr

rmm.mr.available_device_memory(): 返回可用和总设备内存的元组。

rmm.mr.disable_logging(): 如果之前使用 rmm.initialize() 或 rmm.enable_logging() 启用了日志记录，则禁用日志记录。

rmm.mr.enable_logging(log_file_name=None)

为所有设备启用运行时事件的日志记录。

参数:

log_file_name: str, 可选: 日志文件的名称。如果未指定，则使用环境变量 RMM_LOG_FILE。如果两者均不可用，则抛出 ValueError。每个设备都会生成一个单独的日志文件，并且后缀 “.dev{id}” 会自动添加到日志文件名称中。

注意

请注意，如果在启用日志记录的情况下使用环境变量 CUDA_VISIBLE_DEVICES，后缀可能与您的预期不同。例如，如果设置 CUDA_VISIBLE_DEVICES=1，生成的日志文件后缀仍将是 0。类似地，如果设置 CUDA_VISIBLE_DEVICES=1,0 并使用设备 0 和 1，后缀为 0 的日志文件将对应于设备 ID 为 1 的 GPU。使用 rmm.get_log_filenames() 获取每个设备对应的日志文件名称。

rmm.mr.get_current_device_resource() → DeviceMemoryResource

获取当前设备上用于 RMM 设备分配的内存资源。

如果在不同的设备是活动 CUDA 设备时使用返回的内存资源，则行为未定义。

rmm.mr.get_current_device_resource_type(): 获取当前设备上用于 RMM 设备分配的内存资源类型。

rmm.mr.get_log_filenames()

返回正在使用的每个设备的日志文件名称（如果未写入日志，则返回 None）。

示例

>>> import rmm
>>> rmm.reinitialize(devices=[0, 1], logging=True, log_file_name="rmm.log")
>>> rmm.get_log_filenames()
{0: '/home/user/workspace/rapids/rmm/python/rmm.dev0.log',
 1: '/home/user/workspace/rapids/rmm/python/rmm.dev1.log'}

rmm.mr.get_per_device_resource(int device)

获取指定设备的默认内存资源。

如果在不同的设备是活动 CUDA 设备时使用返回的内存资源，则行为未定义。

参数:

deviceint: 要获取内存资源的设备的 ID。

rmm.mr.get_per_device_resource_type(int device)

获取指定设备上用于 RMM 设备分配的内存资源类型。

参数:

deviceint: 设备 ID

rmm.mr.is_initialized(): 检查 RMM 是否已初始化

rmm.mr.set_current_device_resource(DeviceMemoryResource mr)

为当前设备设置默认内存资源。

参数:

mrDeviceMemoryResource: 要设置的内存资源。必须在当前设备是活动 CUDA 设备时创建。

rmm.mr.set_per_device_resource(int device, DeviceMemoryResource mr)

为指定设备设置默认内存资源。

参数:

deviceint: 要获取内存资源的设备的 ID。
mrDeviceMemoryResource: 要设置的内存资源。必须在设备是活动 CUDA 设备时创建。

内存分配器

rmm.allocators.cupy.rmm_cupy_allocator(nbytes)

利用 RMM 的 CuPy 分配器。

示例

>>> from rmm.allocators.cupy import rmm_cupy_allocator
>>> import cupy
>>> cupy.cuda.set_allocator(rmm_cupy_allocator)

class rmm.allocators.numba.RMMNumbaManager(*args, **kwargs)

基类： HostOnlyCUDAMemoryManager

用于 Numba 的外部内存管理插件实现。仅提供设备上分配。

有关此处实现的接口的详细信息，请参阅 https://numba.readthedocs.io/en/stable/cuda/external-memory.html。

属性:

interface_version: 返回一个整数，指定插件实现支持的 EMM Plugin 接口的版本。

方法

`defer_cleanup`()	返回一个上下文管理器，当它处于活动状态时，禁用当前上下文中映射或固定的主机内存的清理。
`get_ipc_handle`(memory)	获取 MemoryPointer 内存的 IPC 句柄，其偏移量由 RMM 内存池修改。
`get_memory_info`()	返回上下文中内存的 `(free, total)` 大小，单位为字节。
`initialize`()	执行 EMM 插件实例准备就绪所需的任何初始化操作。
`memalloc`(size)	从 RMM 池分配设备上数组。
`memhostalloc`(size[, mapped, portable, wc])	实现固定主机内存的分配。
`mempin`(owner, pointer, size[, mapped])	实现主机内存的固定（pinning）。
`reset`()	清除当前上下文中所有主机内存（映射和/或固定）。

memallocmanaged

defer_cleanup()

返回一个上下文管理器，当它处于活动状态时，禁用当前上下文中映射或固定的主机内存的清理。

覆盖此方法的 EMM 插件必须在 yield 之前从此方法获取上下文管理器，以确保主机分配的清理也被延迟。

get_ipc_handle(memory): 获取 MemoryPointer 内存的 IPC 句柄，其偏移量由 RMM 内存池修改。

get_memory_info()

返回上下文中内存的 (free, total) 大小，单位为字节。

此实现会引发 NotImplementedError，因为分配将使用 rmm 当前设置的默认 mr 执行，而该 mr 可能是一个池分配器。

initialize()

执行 EMM 插件实例准备就绪所需的任何初始化操作。

返回:: 无

property interface_version: 返回一个整数，指定插件实现支持的 EMM Plugin 接口的版本。对于此版本规范的实现，应始终返回 1。

memalloc(size): 从 RMM 池分配设备上数组。

memallocmanaged(size, attach_global)

memhostalloc(size, mapped=False, portable=False, wc=False)

实现固定主机内存的分配。

建议 EMM 插件实现不要覆盖此方法 - 而是使用 numba.cuda.BaseCUDAMemoryManager。

mempin(owner, pointer, size, mapped=False)

实现主机内存的固定（pinning）。

建议 EMM 插件实现不要覆盖此方法 - 而是使用 numba.cuda.BaseCUDAMemoryManager。

reset()

清除当前上下文中所有主机内存（映射和/或固定）。

覆盖此方法的 EMM 插件必须调用 super().reset()，以确保主机分配也被清理。

内存统计信息

class rmm.statistics.ProfilerRecords

基类: object

分析器记录的内存统计信息记录。

属性:

records: 将记录名称映射到其内存统计信息的字典。

方法

`MemoryRecord`([num_calls, memory_total, ...])	单个代码块的内存统计信息。
`add`(name, data)	将内存统计信息添加到名为 name 的记录中。
`report`([ordered_by])	美化记录的内存统计信息格式。

class MemoryRecord(num_calls: int = 0, memory_total: int = 0, memory_peak: int = 0)

基类: object

单个代码块的内存统计信息。

属性:

num_calls: 此代码块被调用的次数。
memory_total: 已分配的总字节数。
memory_peak: 分配的峰值字节数。

方法

add

add(memory_total: int, memory_peak: int)

memory_peak: int = 0

memory_total: int = 0

num_calls: int = 0

add(name: str, data: Statistics) → None

将内存统计信息添加到名为 name 的记录中。

此方法是线程安全的。

参数:

name: 记录的名称。
data: name 的内存统计信息。

property records: dict[str, MemoryRecord]: 将记录名称映射到其内存统计信息的字典。

report(ordered_by: Literal['num_calls', 'memory_peak','memory_total'] = 'memory_peak') → str

美化记录的内存统计信息格式。

参数:

ordered_by: 按此属性对统计信息进行排序。

返回:

格式化的内存统计信息字符串

class rmm.statistics.Statistics(current_bytes: int, current_count: int, peak_bytes: int, peak_count: int, total_bytes: int, total_count: int)

基类: object

{get,push,pop}_statistics() 返回的统计信息。

属性:

current_bytes: 当前分配的字节数
current_count: 当前分配的数量
peak_bytes: 分配的峰值字节数
peak_count: 分配的峰值数量
total_bytes: 已分配的总字节数
total_count: 已分配的总数量

current_bytes: int

current_count: int

peak_bytes: int

peak_count: int

total_bytes: int

total_count: int

rmm.statistics.enable_statistics() → None

启用分配统计信息。

此函数是幂等的。如果已为当前的 RMM 资源栈启用统计信息，则此操作无效。

警告

这会修改当前的 RMM 内存资源。StatisticsResourceAdaptor 会被推到当前的 RMM 内存资源栈上，并且在统计信息收集过程中必须始终保持为最顶层的资源。

rmm.statistics.get_statistics() → Statistics | None

获取当前的分配统计信息。

返回:

如果已启用，则返回当前跟踪的统计信息。
如果已禁用，则返回 None。

rmm.statistics.pop_statistics() → Statistics | None

弹出当前分配统计信息栈的计数器。

这会返回当前跟踪的统计信息的计数器，并将其从栈中弹出。

如果统计信息已禁用（当前内存资源不是 StatisticsResourceAdaptor 的实例），则此函数无效。

返回:

如果已启用，则返回弹出的计数器。
如果已禁用，则返回 None。

rmm.statistics.profiler(*, records: ProfilerRecords = ProfilerRecords({}), name: str = '')

用于分析函数或代码块的装饰器和上下文。

如果统计信息已启用（当前内存资源是 StatisticsResourceAdaptor 的实例），则此装饰器会记录被装饰函数或代码块的内存统计信息。

如果统计信息已禁用，则此装饰器/上下文无效。

参数:

records: 内存统计信息写入的分析器记录。如果未设置，则使用默认的分析器记录。
name: 内存配置的名称，当分析器用作上下文管理器时必填。如果用作装饰器，允许名称为空。在这种情况下，名称是文件名、行号和函数名。

rmm.statistics.push_statistics() → Statistics | None

在当前分配统计信息栈上压入新的计数器。

这会返回当前跟踪的统计信息，并在统计信息栈上压入一组新的零计数器。

如果统计信息已禁用（当前内存资源不是 StatisticsResourceAdaptor 的实例），则此函数无效。

返回:

如果已启用，则返回弹出*之前*当前跟踪的统计信息。
如果已禁用，则返回 None。

rmm.statistics.statistics()

启用分配统计信息的上下文。

如果统计信息已启用（当前内存资源是 StatisticsResourceAdaptor 的实例），则在进入上下文时会将新的计数器压入当前分配统计信息栈，并在退出时使用 push_statistics() 和 push_statistics() 再次弹出。

如果统计信息尚未启用，则在进入上下文时会将新的 StatisticsResourceAdaptor 设置为当前的 RMM 内存资源，并在退出时再次移除。

抛出:

ValueError: 如果在上下文中更改了当前的 RMM 内存源。