内存管理#
本页描述了Ray中内存管理的工作原理。
另请查看 内存不足调试 以了解如何排查内存不足问题。
概念#
Ray 应用程序使用内存有几种方式：
- Ray 系统内存：这是 Ray 内部使用的内存
GCS: 用于存储集群中节点和参与者列表的内存。用于这些目的的内存量通常非常小。
Raylet：每个节点上运行的 C++ raylet 进程使用的内存。这无法控制，但通常非常小。
- 应用程序内存：这是由您的应用程序使用的内存
工作堆: 应用程序使用的内存（例如，在Python代码或TensorFlow中），最好通过应用程序的*驻留集大小（RSS）*减去其*共享内存使用（SHR）*来测量，例如在``top``命令中。你需要减去*SHR*的原因是对象存储共享内存被操作系统报告为与每个工作进程共享。不减去*SHR*将导致内存使用量的重复计算。
对象存储内存：当您的应用程序通过
ray.put在对象存储中创建对象时，以及当它从远程函数返回值时使用的内存。对象是引用计数的，当它们超出作用域时会被驱逐。每个节点上运行一个对象存储服务器。默认情况下，启动实例时，Ray 会保留 30% 的可用内存。对象存储的大小可以通过 –object-store-memory 控制。默认情况下，内存分配给 Linux 的 ``/dev/shm``（共享内存）。对于 MacOS，Ray 使用 ``/tmp``（磁盘），这可能会影响与 Linux 相比的性能。在 Ray 1.3+ 中，如果对象存储满了，对象会被 溢出到磁盘。对象存储共享内存: 当您的应用程序通过
ray.get读取对象时使用的内存。请注意，如果对象已经在节点上存在，这不会导致额外的分配。这使得大型对象能够在许多参与者和任务之间高效共享。
ObjectRef 引用计数#
Ray 实现了分布式引用计数，以便集群中作用域内的任何 ObjectRef 都被固定在对象存储中。这包括本地的 Python 引用、待处理任务的参数以及其他对象内部序列化的 ID。
使用 ‘ray memory’ 进行调试#
ray memory 命令可以用来帮助追踪哪些 ObjectRef 引用在作用域内，并且可能导致了 ObjectStoreFullError。
在Ray应用程序运行时从命令行运行 ray memory 将为您提供集群中驱动程序、角色和任务当前持有的所有 ObjectRef 引用的转储。
======== Object references status: 2021-02-23 22:02:22.072221 ========
Grouping by node address... Sorting by object size...
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
287 MiB 4 0 0 1 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 6465 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 15 MiB LOCAL_REFERENCE (put object)
| test.py:
<module>:17
192.168.0.15 6465 Driver a67dc375e60ddd1affffffffffffffffffffffff0100000001000000 15 MiB LOCAL_REFERENCE (task call)
| test.py:
:<module>:18
192.168.0.15 6465 Driver ffffffffffffffffffffffffffffffffffffffff0100000002000000 18 MiB CAPTURED_IN_OBJECT (put object) |
test.py:
<module>:19
192.168.0.15 6465 Driver ffffffffffffffffffffffffffffffffffffffff0100000004000000 21 MiB LOCAL_REFERENCE (put object) |
test.py:
<module>:20
192.168.0.15 6465 Driver ffffffffffffffffffffffffffffffffffffffff0100000003000000 218 MiB LOCAL_REFERENCE (put object) |
test.py:
<module>:20
--- Aggregate object store stats across all nodes ---
Plasma memory usage 0 MiB, 4 objects, 0.0% full
此输出的每个条目对应于一个当前在对象存储中固定对象的 ObjectRef，以及引用所在的位置（在驱动程序中、在工作者中等）、引用的类型（有关引用类型的详细信息，请参见下文）、对象的大小（以字节为单位）、对象被实例化的进程ID和IP地址，以及在应用程序中创建引用的位置。
ray memory 提供了一些功能，使内存调试体验更加有效。例如，你可以添加参数 sort-by=OBJECT_SIZE 和 group-by=STACK_TRACE，这对于追踪内存泄漏发生的代码行可能特别有帮助。你可以通过运行 ray memory --help 查看所有选项。
有五种类型的引用可以保持对象固定：
1. 本地 ObjectRef 引用
import ray
@ray.remote
def f(arg):
return arg
a = ray.put(None)
b = f.remote(None)
在这个例子中，我们创建了对两个对象的引用：一个是在对象存储中的 ray.put() ，另一个是来自 f.remote() 的返回值。
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
30 MiB 2 0 0 0 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 6867 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 15 MiB LOCAL_REFERENCE (put object) |
test.py:
<module>:12
192.168.0.15 6867 Driver a67dc375e60ddd1affffffffffffffffffffffff0100000001000000 15 MiB LOCAL_REFERENCE (task call)
| test.py:
:<module>:13
在 ray memory 的输出中，我们可以看到这些都被标记为驱动进程中的 LOCAL_REFERENCE，但在“引用创建位置”的注释中，第一个被创建为“放置对象”，第二个来自“任务调用”。
2. 内存中固定的对象
import numpy as np
a = ray.put(np.zeros(1))
b = ray.get(a)
del a
在这个例子中，我们创建了一个 numpy 数组，然后将其存储在对象存储中。接着，我们从对象存储中获取相同的 numpy 数组，并删除其 ObjectRef。在这种情况下，对象仍然被固定在对象存储中，因为反序列化的副本（存储在 b 中）直接指向对象存储中的内存。
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
243 MiB 0 1 0 0 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 7066 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 243 MiB PINNED_IN_MEMORY test.
py:<module>:19
ray memory 的输出显示此对象为 PINNED_IN_MEMORY。如果我们 del b，引用可以被释放。
3. 待办任务引用
@ray.remote
def f(arg):
while True:
pass
a = ray.put(None)
b = f.remote(a)
在这个例子中，我们首先通过 ray.put() 创建一个对象，然后提交一个依赖于该对象的任务。
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
25 MiB 1 1 1 0 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 7207 Driver a67dc375e60ddd1affffffffffffffffffffffff0100000001000000 ? LOCAL_REFERENCE (task call)
| test.py:
:<module>:29
192.168.0.15 7241 Worker ffffffffffffffffffffffffffffffffffffffff0100000001000000 10 MiB PINNED_IN_MEMORY (deserialize task arg)
__main__.f
192.168.0.15 7207 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 15 MiB USED_BY_PENDING_TASK (put object) |
test.py:
<module>:28
在任务运行时，我们看到 ray memory 显示了驱动进程中对象的 LOCAL_REFERENCE 和 USED_BY_PENDING_TASK 引用。工作进程也持有对该对象的引用，因为 Python 的 arg 直接引用了 plasma 中的内存，因此它不能被驱逐；因此它是 PINNED_IN_MEMORY。
4. 序列化的 ObjectRef 引用
@ray.remote
def f(arg):
while True:
pass
a = ray.put(None)
b = f.remote([a])
在这个例子中，我们再次通过 ray.put() 创建一个对象，但随后将其传递给包装在另一个对象（在这种情况下，是一个列表）中的任务。
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
15 MiB 2 0 1 0 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 7411 Worker ffffffffffffffffffffffffffffffffffffffff0100000001000000 ? LOCAL_REFERENCE (deserialize task arg)
__main__.f
192.168.0.15 7373 Driver a67dc375e60ddd1affffffffffffffffffffffff0100000001000000 ? LOCAL_REFERENCE (task call)
| test.py:
:<module>:38
192.168.0.15 7373 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 15 MiB USED_BY_PENDING_TASK (put object)
| test.py:
<module>:37
现在，驱动程序和运行任务的工作进程除了在驱动程序上处于 USED_BY_PENDING_TASK 状态外，还持有对象的 LOCAL_REFERENCE。如果这是一个actor任务，actor甚至可以在任务完成后通过将 ObjectRef 存储在成员变量中来持有 LOCAL_REFERENCE。
5. 捕获的 ObjectRef 引用
a = ray.put(None)
b = ray.put([a])
del a
在这个例子中，我们首先通过 ray.put() 创建一个对象，然后在另一个 ray.put() 对象中捕获其 ObjectRef，并删除第一个 ObjectRef。在这种情况下，两个对象仍然被固定。
--- Summary for node address: 192.168.0.15 ---
Mem Used by Objects Local References Pinned Count Pending Tasks Captured in Objects Actor Handles
233 MiB 1 0 0 1 0
--- Object references for node address: 192.168.0.15 ---
IP Address PID Type Object Ref Size Reference Type Call Site
192.168.0.15 7473 Driver ffffffffffffffffffffffffffffffffffffffff0100000001000000 15 MiB CAPTURED_IN_OBJECT (put object) |
test.py:
<module>:41
192.168.0.15 7473 Driver ffffffffffffffffffffffffffffffffffffffff0100000002000000 218 MiB LOCAL_REFERENCE (put object) |
test.py:
<module>:42
在 ray memory 的输出中，我们看到第二个对象显示为正常的 LOCAL_REFERENCE，但第一个对象被列为 CAPTURED_IN_OBJECT。
内存感知调度#
默认情况下，Ray 在调度时不考虑任务或角色的潜在内存使用情况。这仅仅是因为它无法提前估计所需的内存量。但是，如果你知道任务或角色需要多少内存，可以在其 ray.remote 装饰器的资源需求中指定，以启用内存感知的调度：
重要
指定内存需求并不对内存使用施加任何限制。这些需求仅在调度期间用于准入控制（类似于Ray中CPU调度的方式）。任务本身有责任不使用超过其请求的内存。
要告诉 Ray 调度器一个任务或角色需要一定数量的可用内存才能运行，请设置 memory 参数。Ray 调度器在调度时将保留指定数量的可用内存，类似于它处理 CPU 和 GPU 资源的方式：
# reserve 500MiB of available memory to place this task
@ray.remote(memory=500 * 1024 * 1024)
def some_function(x):
pass
# reserve 2.5GiB of available memory to place this actor
@ray.remote(memory=2500 * 1024 * 1024)
class SomeActor:
def __init__(self, a, b):
pass
在上面的例子中，内存配额由装饰器静态指定，但你也可以在运行时使用 .options() 动态设置它们，如下所示：
# override the memory quota to 100MiB when submitting the task
some_function.options(memory=100 * 1024 * 1024).remote(x=1)
# override the memory quota to 1GiB when creating the actor
SomeActor.options(memory=1000 * 1024 * 1024).remote(a=1, b=2)
有问题或疑问吗？#
您可以通过以下渠道提出问题、发布问题或反馈：
讨论板: 用于 关于Ray使用的疑问 或 功能请求。
GitHub Issues: 用于 错误报告。
Ray Slack: 用于 联系 Ray 维护者。
StackOverflow: 使用 [ray] 标签 关于 Ray 的问题。