3、RayV Lite核心概念：任务（Task）、演员（Actor）、对象（Object）、远程函数

好，咱们直接进入正题。

RayV Lite 这套框架，说白了就是一套「把单机代码变成分布式执行」的魔法工具。你写好的 Python 函数，加个装饰器，就能扔到集群上跑。听起来很爽对吧？但爽之前，你得先搞懂它的四个核心概念：任务（Task）、演员（Actor）、对象（Object）、远程函数。

这四个东西，我当年刚接触时也绕晕过。尤其是 Actor 和 Task 的区别，我花了整整一个下午才理清楚。嗯，今天咱们一次讲透。

3.1 远程函数：一切的基础

远程函数，就是 RayV Lite 的「入场券」。你想想看，普通的 Python 函数调用，是在本地进程里同步执行的。但加上 @ray.remote 装饰器后，这个函数就变成了一个「远程任务」——它会被调度到集群中的某个 Worker 节点上异步执行。

核心要点：远程函数返回的不是结果，而是一个 ObjectRef（对象引用）。你需要用 ray.get() 去拿真正的结果。

import ray

ray.init()

@ray.remote
def add(a, b):
    return a + b

# 调用远程函数，返回 ObjectRef
ref = add.remote(3, 5)
# 获取实际结果
result = ray.get(ref)
print(result)  # 输出 8

我个人习惯把 ref 理解成一个「快递单号」。你下单（调用 remote），快递员去取货（Worker 执行），你拿着单号去查物流（ray.get）。单号本身不占多少内存，但真正的包裹可能很大。

小技巧：如果你有多个远程函数要并行执行，可以一次性 ray.get([ref1, ref2, ref3])，这样会等待所有结果返回，比逐个 get 效率高得多。

3.2 任务（Task）：无状态的计算单元

任务，就是远程函数的执行实例。每个任务都是无状态的——它不保存任何中间数据，跑完就销毁。这有点像 FPGA 里的组合逻辑：输入进去，输出出来，不留痕迹。

我在项目中遇到过一个问题：有同事把一个大循环拆成 1000 个任务，每个任务只处理一行数据。结果任务调度开销比计算本身还大。嗯，这里要注意：任务粒度不能太细。我建议每个任务至少运行 100 毫秒以上，否则调度器会累死。

特性 说明
无状态 任务之间不共享内存，每次执行都是独立的
自动重试 任务失败后，RayV Lite 会自动重新调度（默认最多 3 次）
并行度 任务数量可以远超 Worker 数量，由调度器自动分配
适用场景 数据预处理、批量计算、无状态微服务

避坑指南：我曾经把一个需要读写全局变量的函数直接改成远程任务，结果发现每个 Worker 拿到的全局变量都是独立的副本，数据根本不同步。记住：任务之间不能共享状态！如果需要共享，请用 Actor。

3.3 演员（Actor）：有状态的计算节点

演员，就是带状态的远程对象。你可以把它理解成一个「常驻 Worker 上的微服务」。它有自己的内部变量，可以多次调用它的方法，每次调用都能访问和修改这些变量。

为什么叫「演员」？因为每个 Actor 就像舞台上的一个角色，有自己的「记忆」（状态），并且能响应外部的「指令」（方法调用）。

@ray.remote
class Counter:
    def __init__(self):
        self.value = 0
    
    def increment(self):
        self.value += 1
        return self.value
    
    def get_value(self):
        return self.value

# 创建 Actor 实例
counter = Counter.remote()

# 多次调用 Actor 的方法
ref1 = counter.increment.remote()
ref2 = counter.increment.remote()
ref3 = counter.increment.remote()

print(ray.get([ref1, ref2, ref3]))  # 输出 [1, 2, 3]

你想想看，如果上面这个例子用 Task 实现，每次调用 increment 都得把当前值传进去、再传回来，多麻烦。Actor 直接把状态留在 Worker 上，省去了序列化和网络传输的开销。

关键区别：Task 是无状态的，每次调用都是独立的；Actor 是有状态的，方法调用会修改内部数据。选哪个？看你的业务逻辑是否需要「记住」东西。

3.4 对象（Object）：数据流转的载体

在 RayV Lite 里，所有数据都以对象的形式存在。但这里的「对象」不是 Python 的普通对象，而是分布式对象——它们存储在共享内存中，可以被多个 Worker 访问。

每个对象都有一个唯一的 ObjectRef（对象引用），你可以把它当作一个「指针」或「句柄」。真正的数据可能在本机内存里，也可能在另一台机器的内存里，但你不必关心这些——RayV Lite 的底层会自动处理数据传输。

# 创建一个对象
data = [1, 2, 3, 4, 5]
ref = ray.put(data)  # 将数据放入对象存储，返回 ObjectRef

# 在其他任务中使用这个对象
@ray.remote
def process_data(ref):
    data = ray.get(ref)
    return sum(data)

result_ref = process_data.remote(ref)
print(ray.get(result_ref))  # 输出 15

我个人习惯把 ray.put() 理解成「把数据存到公共仓库里」，然后只把「仓库钥匙」（ObjectRef）传给各个任务。这样避免了大数据在网络上反复拷贝——尤其是当你处理几百 MB 的 FPGA 位流文件时，这个设计能省下大量时间。

操作 说明
ray.put(obj) 将对象存入共享内存，返回 ObjectRef
ray.get(ref) 根据 ObjectRef 获取实际对象（可能阻塞等待）
ray.wait(refs) 等待一组 ObjectRef 中的任意一个完成

小技巧：如果你有一个很大的数据集（比如 10GB 的仿真波形），不要把它拆成小份传给每个任务。直接用 ray.put() 存一次，然后传 ObjectRef 给所有任务。这样数据只存一份，所有 Worker 共享访问。

3.5 四个概念的关系图

说了这么多，咱们用一张图来总结一下这四个概念的关系。我画了一张 SVG 图，帮你理清思路：

RayV Lite 核心概念关系图 远程函数 @ray.remote 装饰器 任务 (Task) 无状态计算单元 演员 (Actor) 有状态计算节点 对象 (Object) 分布式数据载体 调用生成 类装饰生成 返回/读取 持有/修改 作为参数传入 远程函数是「模板」，任务和演员是「执行实例」，对象是「数据桥梁」 远程函数 任务 演员 对象

从这张图你可以看到：远程函数是「模板」，它定义了计算逻辑；任务和演员是「执行实例」，一个无状态、一个有状态；而对象则是贯穿始终的「数据桥梁」，负责在任务和演员之间传递数据。

3.6 实战中的选择建议

说了这么多理论，咱们来点实际的。你在做 RayV Lite 与 Radix ST 协同工作时，到底该怎么选？

  • 纯计算任务（比如 RTL 仿真数据的统计分析）：用 Task。无状态，简单直接，自动并行。
  • 需要维护状态的场景（比如 FPGA 布局布线的进度追踪）：用 Actor。把状态留在 Worker 上，避免反复传参。
  • 大数据共享（比如加载一个 2GB 的时序约束文件）：用 ray.put() 存入对象存储，然后传 ObjectRef。
  • 需要多次调用的服务（比如一个参数服务器）：用 Actor，因为它可以常驻内存，响应多次请求。

避坑指南：我曾经在一个项目里，把所有逻辑都写成 Actor，结果创建了上千个 Actor 实例，每个都占用独立内存，最后集群内存爆了。记住：Actor 是有开销的，不要滥用。能用 Task 解决的问题，就别用 Actor。

好了，这一章的内容就到这里。四个概念——远程函数、任务、演员、对象——你搞清楚了，RayV Lite 的大门就为你敞开了。下一章咱们会深入讲「任务依赖与 DAG 调度」，到时候你会看到这些概念如何组合成复杂的工作流。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →