UE 复制优化:成本模型、Iris 原理与落地

自动关联目录:UE 复制优化:成本模型、Iris 原理与落地

复制优化不是“少发几个变量”,而是在可接受的状态新鲜度下,控制每条连接的带宽、服务端复制 CPU、连接状态内存和突发延迟。

真正有效的顺序通常是:

  1. 不该联网的对象,不进入复制系统;
  2. 不该让这个连接看到的对象,不进入它的候选集;
  3. 暂时不变化的对象,不参加轮询;
  4. 允许变旧的状态,降低更新频率;
  5. 轮到发送时,只序列化必要且紧凑的状态;
  6. 最后才考虑定制序列化和更复杂的复制后端。

这篇文章先用 UE 传统复制系统建立优化方法,再用独立章节拆解 Iris 的架构、完整数据流、迁移方式与适用边界。属性复制的注册、条件和 RepNotify 细节见 属性复制条件与 RepNotify。

一、先定义“优化”到底在优化什么

网络复制至少同时消耗四类预算:

预算主要来源超预算后的表现
每连接带宽属性、RPC、Actor 初始状态、协议开销排队、丢包、更新变旧
服务端 CPU收集候选、相关性判断、脏检查、序列化DS 帧时间上涨,所有玩家一起卡
服务端内存每连接的 Channel、历史状态、Shadow State玩家数或 Actor 数上升后内存膨胀
状态新鲜度降频、排队、连接饱和、优先级竞争远端角色卡顿,交互反馈滞后

因此,“发送字节减少”不一定代表整体更快。例如把几十个字段塞进一个自定义大结构,可能降低了包头占比,却增加了脏检查和重发成本;把所有 Actor 都降到 2 Hz,CPU 和带宽会下降,但玩法已经不可接受。

更实用的目标写法是:

32 人战斗场景下:
- Dedicated Server 的复制阶段 P95 < 3 ms
- 每连接下行 P95 < 40 KB/s
- 关键战斗状态端到端 P95 < 100 ms
- 普通世界状态最大陈旧时间 < 500 ms
- 不因预算竞争让任何相关 Actor 无限饥饿

数值要根据游戏类型、机房带宽和帧率重定,但必须同时约束成本和体验。

二、理解复制流水线,才能把优化放在正确位置

传统复制系统可以简化为下面这条流水线:

服务器中的 Actor
  ↓ 是否启用复制
全局复制对象集合
  ↓ Dormancy / NetUpdateFrequency
本帧候选集合
  ↓ 按连接做 Owner / Relevancy / 距离过滤
每连接候选集合
  ↓ NetPriority 与“距离上次成功复制的时间”排序
本连接本帧尝试发送的 Actor
  ↓ 属性脏检查、条件判断、序列化、RPC
连接发送队列与数据包

越早把无用工作挡掉,收益越大:

  • SetReplicates(false) 可以同时省掉候选收集、相关性、属性比较和序列化;
  • Dormancy 可以让长期不变的 Actor 不进入常规候选检查;
  • Relevancy 主要减少某条连接上的工作与流量;
  • Push Model 主要减少属性轮询,并不会自动减少真正变化的数据;
  • 量化只压缩最后写入包的字节,不会解决候选集过大的 CPU 问题。

所以看到 ServerReplicateActors 很慢时,直接给 FVector 换成 FVector_NetQuantize 往往治错了层。

三、第一层:减少复制对象和每连接候选集

1. 不需要权威同步,就不要开启复制

最便宜的复制对象,是根本没有进入复制系统的对象。

适合只在本地存在的内容包括:

  • 纯表现粒子、镜头抖动、命中特效和环境音;
  • 可以由已有状态推导出的 UI 或动画参数;
  • 服务端不需要知道的装饰组件;
  • 客户端可根据种子、起点和时间稳定重建的短生命周期表现。

不要为了“以后可能用到”给 Actor 默认打开 bReplicates。复制资格应该是一项明确的网络契约。

2. Ownership 是最便宜、最明确的过滤语义

只对单个玩家有意义的数据,优先建模为 Owner 数据:

AMyPrivateState::AMyPrivateState()
{
    bReplicates = true;
    bOnlyRelevantToOwner = true;
}

典型内容包括背包细节、私人任务进度、输入确认和仅本人可见的调试数据。若 Actor 本身需要被所有人看到,但其中少数字段只属于拥有者,则保留 Actor 的正常相关性,对字段使用 COND_OwnerOnly。

bOnlyRelevantToOwner 和 COND_OwnerOnly 解决的是不同层的问题:前者过滤整个 Actor,后者只过滤属性。

3. Relevancy 决定“谁有资格收到”

常用开关有:

手段适用场景注意点
bOnlyRelevantToOwner私有状态Owner 链必须正确
bNetUseOwnerRelevancy附件、武器、跟随物Owner 改变后要验证路由与首次更新
NetCullDistanceSquared有空间位置的世界对象单位是厘米的平方
IsNetRelevantFor队伍、观战、特殊视野热路径,不能放昂贵查询
Replication Graph 节点大量 Actor、多人、大世界需要维护正确的节点路由
Iris Filter使用 Iris 的项目与 Replication Graph 不是叠加关系

例如 50 米剔除距离不是 50 * 50,而是 UE 单位下的 5000 * 5000:

NetCullDistanceSquared = FMath::Square(5000.f);

不要把“当前屏幕不可见”直接等同于“不相关”。掩体后的敌人虽然不可见,但脚步、伤害和随时重新出现的状态仍可能重要。相关性应来自玩法语义,而不是渲染可见性。

4. Actor 很多时,把逐对象判断改成持久化路由

传统相关性判断的风险是工作量接近 连接数 × 候选 Actor 数。当 Actor 和连接数同时增长时,应考虑:

  • Replication Graph:用空间网格、Always Relevant、Owner、Dormancy 等持久节点生成候选列表;
  • Iris:用 Filter 和 Prioritizer 表达接收者与优先级,并复用量化后的复制状态。

Replication Graph 优化的是“给每个连接找 Actor”的过程,不会自动让属性更小,也不会替你设计 Dormancy。Iris 则是另一套复制后端;项目要先确认引擎版本、平台成熟度和迁移成本,不能默认把 Iris 与 Replication Graph 同时启用。Replication Graph 的具体接入见 Replication Graph。

四、第二层:控制什么时候复制

1. NetUpdateFrequency 是尝试上限,不是到达保证

AMyActor::AMyActor()
{
    bReplicates = true;
    NetUpdateFrequency = 10.f;
    MinNetUpdateFrequency = 2.f;
}

NetUpdateFrequency = 10 表示 Actor 最多大约每秒进入 10 次更新机会,不代表客户端严格每 100 ms 收到一次。相关性、连接饱和、丢包、优先级和服务器帧率都会改变实际到达时间。

可以从业务可接受的陈旧时间倒推频率:

状态可接受陈旧时间起始频率建议
玩家战斗移动50~100 ms10~20 Hz,再配合预测与插值
普通 AI 移动100~250 ms4~10 Hz
缓慢机关250~500 ms2~4 Hz
回合状态、配置变化时发送休眠或事件驱动

这些只是压测起点,不是通用默认值。竞技射击、合作 PVE 和回合制对新鲜度的容忍完全不同。

开启 net.UseAdaptiveNetUpdateFrequency 后,传统系统可以根据 Actor 实际产生有效更新的频率,在 MinNetUpdateFrequency 与 NetUpdateFrequency 之间调整检查节奏。它适合“偶尔变化但不能直接休眠”的 Actor,但不能替代正确的休眠和事件建模。

2. Dormancy:长期不变对象的高收益优化

Dormancy 不只是“不发数据”,而是尽量让对象不再进入常规复制遍历和属性比较。它很适合门、宝箱、场景机关、可破坏物最终状态等“绝大多数时间静止,偶尔变化一次”的对象。

AMyDoor::AMyDoor()
{
    bReplicates = true;
    NetDormancy = DORM_Initial; // 仅用于地图中预放置的 Actor
}

void AMyDoor::SetOpened(bool bNewOpened)
{
    check(HasAuthority());

    // 先退出/刷新休眠,再修改复制状态。
    FlushNetDormancy();
    bOpened = bNewOpened;
    ForceNetUpdate();
}

关键规则:

  • DORM_Initial 只适合地图中预放置的 Actor;运行时 Spawn 的 Actor 不应依赖它;
  • 改复制属性前先 FlushNetDormancy() 或 SetNetDormancy(DORM_Awake);
  • ActorComponent 或复制子对象变化时,要唤醒它所属的 Actor;
  • 持续变化期间保持 DORM_Awake,稳定后再进入 DORM_DormantAll;
  • 不要频繁睡眠、唤醒,状态抖动可能比保持 Awake 更贵;
  • DORM_DormantPartial 不适合作为新方案的基础,优先用明确的每连接过滤策略。

Dormancy 与 Relevancy 的客户端生命周期不同:动态 Actor 失去相关性时通常会关闭 Channel,并可能在客户端销毁;Dormant Actor 仍然存在,只是停止接收更新。选错机制会造成“离开范围后对象还留着”或“回来时重新创建”的差异。

3. ForceNetUpdate() 只是在调度上催一次

ForceNetUpdate() 让 Actor 尽快进入下一次网络更新,并会刷新 Dormant Actor,但它不会:

  • 绕过相关性;
  • 绕过连接带宽上限;
  • 把不可靠数据变成可靠数据;
  • 保证客户端在当前帧立即收到。

它适合低频 Actor 的关键状态突变,例如门打开、Boss 阶段切换。每 Tick 调用等于主动破坏降频策略。

4. NetPriority 解决饱和时“谁先发”

连接饱和时,UE 会按 Actor 的当前优先级排序。NetPriority 只有相对比例有意义:把所有 Actor 从 1 同时改成 10,不会凭空增加带宽。

优先级还会考虑距离、视角和距离上次成功复制的时间,因此等待较久的 Actor 有机会逐渐追上。自定义 GetNetPriority() 时要避免让低优先级 Actor 永久饥饿,也不要在其中执行昂贵的世界查询。

五、第三层:减少属性数量、接收者和表示宽度

1. 先问客户端是否真的需要这个事实

每个复制字段都应该能回答三个问题:

  1. 哪些连接需要它?
  2. 允许多旧?
  3. 能否从别的权威状态推导?

例如客户端已有 StartTime、Duration 和服务器时间,就不需要每帧复制倒计时;已有武器 ID 和射击开始时间,就不一定要复制每个表现参数。

复制最小权威状态,让客户端重建表现,通常比复制每个中间结果更稳定。

2. 用条件缩小接收者

void AMyWeapon::GetLifetimeReplicatedProps(
    TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    DOREPLIFETIME_CONDITION(AMyWeapon, AmmoInMagazine, COND_OwnerOnly);
    DOREPLIFETIME_CONDITION(AMyWeapon, CosmeticId, COND_InitialOnly);
    DOREPLIFETIME_CONDITION(AMyWeapon, ThirdPersonFireState, COND_SkipOwner);
}

常见组合:

数据条件原因
弹药、私人任务COND_OwnerOnly只有本人需要完整细节
静态配置 IDCOND_InitialOnly创建时确定,后续不变
已由本地预测播放的表现COND_SkipOwner避免 Owner 重复播放
远端模拟状态COND_SimulatedOnly自主端使用预测结果

DOREPLIFETIME_ACTIVE_OVERRIDE 的开关是每个 Actor 实例级别的,不是天然的每连接条件。不要用它读取某个连接独有的状态,否则共享复制工作时可能得到错误结果。

3. 量化要从可感知误差倒推

UPROPERTY(Replicated)
FVector_NetQuantize10 ImpactPoint;

UPROPERTY(Replicated)
uint16 YawShort;

量化的正确问题不是“能省多少位”,而是“多大误差玩家看不出来”。位置、方向、速度、百分比和枚举通常都有压缩空间:

  • 世界位置根据玩法尺度选择 FVector_NetQuantize*;
  • 角度可以压成整数区间,在客户端还原;
  • 只需要有限状态时用枚举或位标记,不复制字符串;
  • RPC 中频繁传 FName、FString 或大型结构体前要看实际包内容;
  • 资产与配置优先传稳定 ID,不重复发送完整描述。

量化会把误差引入权威状态的远端表示。碰撞判定、反作弊阈值和回放一致性需要单独验证,不能只看画面“差不多”。

4. 把必须一致到达的字段组成一个状态

不同复制属性的 OnRep 调用顺序没有可靠保证。如果 State、StartTime、TargetId 必须作为同一版本被消费,应该复制一个带版本号的结构,而不是假设三个 OnRep 按声明顺序触发:

USTRUCT()
struct FReplicatedActionState
{
    GENERATED_BODY()

    UPROPERTY() uint16 Revision = 0;
    UPROPERTY() uint8 State = 0;
    UPROPERTY() float ServerStartTime = 0.f;
    UPROPERTY() TObjectPtr<AActor> Target = nullptr;
};

这不一定让字节更少,却能减少中间非法状态、额外修复 RPC 和难以复现的时序 Bug。

5. 大列表使用 Fast Array,但不要把它当事件队列

背包、Buff、任务列表和排行榜适合 FFastArraySerializer:它用稳定条目和 Dirty 标记表达增加、修改、删除,并提供对应回调。典型修改路径是:

FInventoryEntry& Entry = Entries[Index];
Entry.Count += Delta;
MarkItemDirty(Entry);

// 删除条目后必须标记数组结构变化。
Entries.RemoveAt(IndexToRemove);
MarkArrayDirty();

新增或修改条目调用 MarkItemDirty();直接删除条目后调用 MarkArrayDirty()。Fast Array 用复制 ID 识别条目,客户端数组顺序不保证始终与服务端相同,因此业务逻辑也不应把数组下标当稳定 ID。

Fast Array 的价值要从真实数据规模和变化模式验证。十个元素、每分钟改一次的数组,没有必要为了理论上的增量复制引入复杂生命周期。

另外,Dirty 表示“当前状态需要同步”,不代表每一次中间变化都会像可靠事件一样被观察到。需要逐次处理的购买、领取、扣费等行为,仍要有请求 ID、幂等和权威事务语义。

六、第四层:减少脏检查与序列化 CPU

1. Push Model 优化的是检查工作,不是网络语义

传统轮询会比较复制属性与 Shadow State。Push Model 让业务代码在修改属性时显式标脏,使系统更容易跳过未变化状态:

void AMyActor::SetHealth(float NewHealth)
{
    const float Clamped = FMath::Clamp(NewHealth, 0.f, MaxHealth);
    if (Health == Clamped)
    {
        return;
    }

    Health = Clamped;
    MARK_PROPERTY_DIRTY_FROM_NAME(AMyActor, Health, this);
}

void AMyActor::GetLifetimeReplicatedProps(
    TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    FDoRepLifetimeParams Params;
    Params.bIsPushBased = true;
    DOREPLIFETIME_WITH_PARAMS_FAST(AMyActor, Health, Params);
}

Push Model 的收益与“可轮询属性数量 × Actor 数 × 检查频率”相关。它不会自动减少已经 Dirty 的属性字节,也不会修复过大的候选集。

它的主要风险是漏标 Dirty。工程上应把字段设为私有,只允许通过统一 Setter 修改,并补充自动化测试;如果任意代码都能直接写 Health,Push Model 很难长期正确。

Push Model 的启用方式和 Iris 集成细节随 UE 版本变化,应以项目所用版本的 Target、配置和引擎源码为准,不要只复制某篇旧文章的开关。

2. 自定义 NetSerialize 之前先算清维护成本

自定义序列化适合:

  • 有明确值域,可以安全压位;
  • 多字段之间存在联合编码机会;
  • 数据处于高频热路径,Profiler 已证明它昂贵;
  • 能做协议兼容、边界值、丢包和回放测试。

不适合为了“看起来专业”给每个结构都写位流。自定义协议会增加版本迁移、调试、兼容和安全校验成本。先用条件复制、量化类型与 Fast Array,通常性价比更高。

3. 子对象与组件也会形成真实成本

一个 Actor 数量不多,不代表它便宜。首次打开 Channel 时,Actor、复制组件、动态子对象、初始属性和引用解析都会形成尖峰。

因此压测时要把“首次复制”和“增量更新”分开观察。大量玩家同时进入区域、重连、传送或流送关卡,往往比稳态战斗更容易打穿预算。

七、Iris:从玩法状态到每条连接的数据包

Iris 不是“更快的 Replication Graph”,也不是把 DOREPLIFETIME 换成一组新宏。它最重要的结构变化是:

把复制系统与 Gameplay Object 的内存解耦。先把变化状态复制并量化到 Iris 自己管理的缓冲区,后续每条连接的过滤、排序和发包尽量只读取这份网络表示。

这样,读取玩法对象、调用序列化器和量化数据等昂贵工作可以尽量只做一次,再被多个连接共享;复制系统也更容易批处理、改善缓存访问并并行执行。

1. Iris 主要解决什么问题

传统复制系统的抽象围绕 Actor、ActorChannel、属性布局和每连接复制展开。UE 已经会共享一部分变化检测结果,但随着 Actor 与连接数共同增加,下面这些成本仍会放大:

  • 复制过程频繁接触 Gameplay Object,难以与 Game Thread 解耦;
  • 每连接做相关性、优先级和 Channel 状态管理;
  • 虚函数式扩展点较多,不利于批处理和连续内存访问;
  • 同一份玩法状态要面向许多连接重复准备;
  • 大量子对象、动态对象和自定义序列化让生命周期更复杂。

Iris 的解决思路可以概括为三步:

  1. 用 Bridge 把 Gameplay Object 注册成内部 Net Object;
  2. 把变化状态复制、量化到 Iris 自己管理的缓冲区;
  3. 以这份缓冲区为输入,按连接执行 Filter、Prioritizer、Scheduler 和 Data Stream。

传统系统与 Iris 的概念对照如下:

关注点传统复制系统Iris
网络对象身份Actor、ActorChannel、对象引用Net Object、FNetRefHandle
状态描述反射属性与 Lifetime PropsDescriptor、Protocol、Fragment
发送前的数据源主要围绕 Gameplay Object 状态Iris 持有的量化状态缓冲区
谁能收到Relevancy、Owner、Replication GraphOwner/Connection/Group/Dynamic Filter
谁先发送NetPriorityStatic/Dynamic Prioritizer + Scheduler
变化发现轮询,可选 Push Model优先 Push/Change Mask,可回退轮询
子对象Channel 与 ReplicateSubobjects 等路径Registered Subobject List + Fragment
扩展序列化NetSerialize 等FNetSerializer,兼容层支持部分旧写法

Iris 并没有取消“服务端权威、属性复制、RPC、Dormancy”这些玩法概念,而是重做了复制系统内部组织状态和分配连接预算的方式。

2. 先认清九个核心概念

概念职责可以怎么理解
Replication Bridge连接 Gameplay Object 与 Iris,管理注册、销毁和实例化玩法世界与网络世界之间的桥
Net ObjectActor、Component 或 UObject 在 Iris 内部的网络表示Iris 真正调度的对象
FNetRefHandle唯一定位 Net ObjectIris API 使用的对象句柄
Replication State一组需要同步的数据一个可复制状态块
State Descriptor描述状态布局、条件、序列化等元信息状态的共享 Schema
Replication Protocol汇总一个对象类型的所有 State Descriptor对象类型的网络协议
Instance Protocol保存如何从具体实例取数据、向具体实例写数据Schema 与某个实例的绑定
Replication Fragment在 Gameplay 与 Replication State 之间搬运状态实例协议中的数据适配器
FNetSerializer量化、反量化和网络编码某种数据类型级编解码器

这里最容易混淆的是 Protocol 与 Instance Protocol:

  • Replication Protocol 按对象类型共享,例如所有 AMyCharacter 可以共用同一套状态描述;
  • Replication Instance Protocol 属于具体实例,它知道从“这个角色”的哪块内存读取,又要把接收状态写回哪个对象;
  • 量化状态缓冲区保存当前网络表示,不需要在每次给不同连接发包时重新回到 Gameplay Object 取相同数据。

可以把三者理解成:Protocol = 类的网络 Schema,Instance Protocol = 某个实例的绑定,Quantized Buffer = 这个实例当前可发送的网络快照。

3. 一次 Iris 复制的完整流程

Gameplay Object
    │ 属性变化,标记 Dirty
    ▼
Replication Bridge / Fragment
    │ Pre-Send:复制并量化一次
    ▼
Net Object 的 Quantized State + Change Mask
    │
    ├─ Connection A:Filter → Priority → Schedule → Serialize
    ├─ Connection B:Filter → Priority → Schedule → Serialize
    └─ Connection C:Filter → Priority → Schedule → Serialize
                                      │
                                      ▼
                     Replication Data Stream / Packet
                                      │
                                      ▼
                  Receiver:Read → Instantiate → Dispatch
                                      │
                                      ▼
                         Client Gameplay Object / OnRep

注册阶段

对象开始复制时,Bridge 会:

  1. 收集 Actor、Component 和子对象定义的 Replication State;
  2. 为对象类型构建可共享的 Replication Protocol;
  3. 为当前实例构建 Instance Protocol;
  4. 创建 Net Object 与量化状态缓冲区;
  5. 返回 FNetRefHandle,供过滤、优先级和生命周期 API 使用。

接收端也由 Bridge 负责创建 Actor、建立协议,并把 Net Object 映射回 Gameplay 实例。

Pre-Send Update:共享工作发生在这里

发送前更新是 Iris 的关键阶段:

  1. 如果对象仍使用兼容轮询模式,先检查 Gameplay 状态是否变化;
  2. 对 Dirty State 调用对应的 Net Serializer;
  3. 把原始类型转换成量化后的网络表示;
  4. 更新 Net Object 的状态缓冲区和 Change Mask;
  5. 更新对象的过滤状态与优先级输入;
  6. 清理本轮源状态 Dirty 标记。

“清理 Dirty”不等于“所有客户端已经收到”。Dirty 描述源状态需要被 Iris 吸收;某条连接是否已经拿到最新状态,由 Iris 的每连接跟踪和投递确认负责。把这两个状态混为一谈,会误解丢包后的重发与最终收敛。

Send Update:每连接决策发生在这里

对每条连接,Iris 依次回答:

  1. Filter:这个对象是否在连接的复制范围内?
  2. Prioritizer:相对其他 Dirty Object,它有多重要?
  3. Scheduler:结合优先级、依赖和包预算,本帧是否装得下?
  4. Data Stream:如何编码并放进包,如何处理投递通知?

整个阶段的目标是尽量不再访问 Gameplay Object,只操作 Iris 自己的 Net Object、量化状态和每连接数据,因此更容易并行,也更利于缓存。

Receiver:先建对象,再分发状态

接收端会先读取完整包和投递信息。首次出现的 Net Object 必须先实例化,因为后续协议和引用解析依赖它;随后反序列化状态,经 Fragment 写回 Gameplay Object,并触发相应的 RepNotify。

4. 量化状态副本为什么是核心

假设 32 个连接都需要同一只 Boss 的 Location、Health 和 Phase。

传统思路很容易围绕“针对每条连接,从 Boss 对象读取、比较并准备数据”展开。Iris 则尽量变成:

Boss Gameplay State
    → 一次复制与量化
    → Iris Quantized State
    → 32 条连接分别判断需不需要、何时发送

这份副本带来四个收益:

  • 共享工作:量化和源状态读取不必为每条连接重复执行;
  • 线程解耦:发包阶段不必任意访问 Gameplay 内存;
  • 缓存友好:内部状态可以批量处理,避免在大量 Gameplay Object 之间反复跳转;
  • 连接独立:每条连接可以有不同 Filter、Priority 和已知状态。

它也有代价:Iris 要为 Net Object 保存完整量化状态,并维护每连接跟踪数据。对象极少、连接极少的项目未必能抵消额外内存、配置和迁移成本。

5. Change Mask、Push Model 与轮询是什么关系

Iris 的 Replication State 会为成员分配 Change Mask。业务修改字段时,理想路径是直接标记对应 bit,并通知 Dirty Object Tracker:

Health: 100 → 80
    → Health 对应的 Change Mask bit = 1
    → Net Object 进入 Dirty 集合
    → Pre-Send 只处理需要更新的状态

因此 Iris 最适合 Push-Based 状态:没有变化的对象不需要反复扫描全部属性。

但“使用 Iris”不自动等于“项目已经完全 Push-Based”。兼容现有 Gameplay 代码时,如果某对象没有正确启用 Push Model,Iris 仍可按 NetUpdateFrequency 回退轮询。这样迁移门槛较低,但也会保留一部分旧系统的检查成本。

工程上应区分三件事:

状态含义
属性 Change Mask哪些成员发生了变化
Net Object Dirty哪些对象需要在 Pre-Send 吸收新状态
Connection Out-of-Date哪条连接尚未拥有对象的当前状态

漏掉 Push Model 的 Dirty 标记,问题通常发生在第一层;Filter 配错导致连接收不到,问题发生在第三层。两者表现都可能是“客户端没更新”,诊断路径完全不同。

6. Filtering:决定谁有资格收到

Iris 提供四类 Filter:

Filter用途典型场景
Owner跟随 Owner 的连接范围私有组件、装备子对象
Connection显式允许或拒绝某些连接观战、管理员、临时可见性
Group一组对象共享一组连接范围队伍、Party、流送区域
Dynamic每次根据运行时数据计算空间网格、自定义视野规则

优先使用 Owner、Connection 和 Group 这类结构化过滤。Dynamic Filter 灵活,但会增加 CPU 成本;官方建议把它作为最后手段。空间对象可以使用网格 Filter,把“附近有哪些对象”的计算集中在过滤系统中。

这也是 Iris 与 Replication Graph 的核心区别:Iris 没有“Actor 必须被塞进某个复制节点”的同构概念。原来 Replication Graph 节点承担的接收者集合和调频逻辑,需要重新映射到 Iris Filter、Prioritizer、Group、Poll Frequency 和依赖关系。

7. Prioritization:决定谁先占用本帧预算

Iris 同时支持静态和动态优先级:

  • Static Priority 给对象一个固定基础值;
  • Dynamic Prioritizer 按连接视角、距离、Owner 或业务数据批量计算;
  • 内置实现包括 Sphere、Sphere With Owner Boost 和 Net Object Count Limiter;
  • 优先级会随网络 Tick 累积,发送后重置,避免低优先级对象永久饿死。

官方定义中,优先级小于 1.0 的对象本帧不参与复制;达到 1.0 后,如果它确实存在待同步状态,才进入调度候选。这里的 1.0 是调度阈值,不是“每秒一次”,也不是带宽百分比。

获取一个 Actor 的 Handle 并设置静态优先级,核心调用如下:

#if UE_WITH_IRIS
#include "Net/Iris/ReplicationSystem/ActorReplicationBridge.h"
#include "Net/Iris/ReplicationSystem/ReplicationSystemUtil.h"
#include "Iris/ReplicationSystem/ReplicationSystem.h"

UReplicationSystem* ReplicationSystem =
    UE::Net::FReplicationSystemUtil::GetReplicationSystem(this);
UActorReplicationBridge* ReplicationBridge =
    UE::Net::FReplicationSystemUtil::GetActorReplicationBridge(this);

if (ReplicationSystem && ReplicationBridge)
{
    const UE::Net::FNetRefHandle Handle =
        ReplicationBridge->GetReplicatedRefHandle(this);

    if (Handle.IsValid())
    {
        ReplicationSystem->SetStaticPriority(Handle, 1.0f);
    }
}
#endif

这段代码必须在对象完成 Iris 注册后执行,否则 Handle 尚未有效。实际项目更常通过类配置或统一路由层分配策略,而不是让每个 Actor 自己零散设置。

8. Scheduler、依赖与可靠性不要混为一谈

Filter、Priority 和 Scheduler 的职责不同:

Filter       = 这个连接能不能收到
Priority     = 相比别的对象有多值得先发
Scheduler    = 本帧预算里实际选择谁、按什么依赖顺序装包
Reliability  = 已写入传输后如何确认或恢复

Iris 可以为 Net Object 建立依赖,使附件、子对象或引用对象在父对象复制时获得调度机会。但依赖不应被理解为“必定处于同一个数据包”或“业务事务原子性”。需要原子消费的字段仍应组成同一 Replication State,并带 Revision;需要恰好一次业务效果的操作仍需请求 ID 和幂等。

Iris 的 Data Stream 把不同网络数据的发送方式抽象出来:

  • Replication Data Stream 负责 Net Object 状态;
  • Net Token Data Stream 同步对象路径等 Token,让后续引用使用更紧凑的表示;
  • 投递通知用于更新发送端对包结果的认识。

属性复制仍然是“让远端最终收敛到当前状态”,不是保存每一次中间变化的事件日志。Health 在一帧内从 100 → 90 → 80,客户端不应依赖一定观察到 90。必须逐次处理的事件仍然用明确的 RPC 或事务协议表达。

9. 子对象迁移是最容易踩坑的部分

Iris 不支持以重写 ReplicateSubobjects() 为核心的旧虚函数路径,必须使用 Registered Subobject List:

AMyActor::AMyActor()
{
    bReplicates = true;
    bReplicateUsingRegisteredSubObjectList = true;
}

void AMyActor::RegisterRuntimeState(UMyRuntimeState* State)
{
    check(HasAuthority());
    AddReplicatedSubObject(State);
}

void AMyActor::UnregisterRuntimeState(UMyRuntimeState* State)
{
    RemoveReplicatedSubObject(State);
}

动态子对象销毁前必须先从 Registered List 移除,否则列表中的裸指针可能在 GC 后失效。对于既不是 AActor 也不是 UActorComponent 的自定义 UObject,还需要实现 RegisterReplicationFragments(),为其属性与 RPC 注册 Fragment。

这不是机械替换 API:迁移时要重新检查子对象的创建顺序、Owner、条件、销毁、引用解析和首次复制依赖。

10. 开启与迁移:先保证语义,再比较性能

UE 5.8 官方文档中的基本接入包括:

// MyGame.Build.cs
SetupIrisSupport(Target);

// MyGame.Target.cs / MyGameServer.Target.cs
bUseIris = true;

项目还需要启用 Iris 插件,并为目标 Net Driver 配置 Iris。开发阶段可以使用 -UseIrisReplication=1 或 -UseIrisReplication=0 做同一构建下的 A/B 验证。具体配置项可能随 UE 版本变化,应以当前项目引擎分支为准。

迁移兼容性可以这样看:

能力迁移判断
UPROPERTY(Replicated) / RepNotify基本语义保留,但要重新验证顺序与 Push Dirty
RPC 声明与执行基本语义保留
Dormancy概念保留,可用于过滤 Polling
NetPriority / IsNetRelevantFor迁移为 Iris Prioritizer / Filter 思维
Replication Graph不能与 Iris 同时作为复制后端使用
ReplicateSubobjects()改用 Registered Subobject List
Fast Array兼容旧定义,也有 FIrisFastArraySerializer
自定义 NetSerialize需要检查警告,必要时提供 Iris FNetSerializer

推荐迁移顺序:

  1. 先让现有属性和 RPC 在 Iris 下通过功能测试;
  2. 迁移所有子对象到 Registered List;
  3. 修复自定义结构、序列化器和对象引用警告;
  4. 盘点原 Replication Graph/Relevancy 规则,映射为 Filter 与 Prioritizer;
  5. 补全 Push Model Dirty 标记,减少兼容轮询;
  6. 用同一负载分别跑传统系统与 Iris,比较 CPU、带宽、内存和状态新鲜度;
  7. 最后才移除旧复制后端的兼容代码。

不要只验证“客户端最终看到了 Actor”。迁移验收还应覆盖:首次进入范围、离开后重入、Owner 切换、子对象动态增删、休眠唤醒、丢包、重连和关卡流送。

11. Iris 什么时候值得用

场景判断
Actor 少、连接少、传统复制没有瓶颈没必要仅为“更新”而迁移
Actor 与连接数同时上升Iris 的共享状态处理开始有价值
大量对象使用 Push Model更容易发挥 Dirty Tracking 优势
需要复杂的组、Owner 和空间过滤Filter 系统适合集中表达
已有成熟且深度定制的 Replication Graph迁移成本高,必须用数据证明收益
大量旧式动态子对象和自定义 NetSerialize先做兼容性盘点,不宜直接切换
引擎版本仍将 Iris 标记为 ExperimentalShipping 前评估平台、回放、热更新和长期维护风险

Iris 的价值不是让单个 Actor 的几个属性“神奇地更小”,而是让复制系统在大量对象、多个连接下少做重复工作,并把过滤、优先级和调度变成更明确的数据导向流水线。

12. Iris 调试从 Handle、Filter、Dirty 三条线入手

常用诊断命令包括:

命令用途
Net.Iris.PrintReplicatedObjects查看已经注册的 Net Object
Net.Iris.PrintRelevantObjects查看当前对任意连接相关的对象
Net.Iris.PrintRelevantObjectsToConnection查看指定连接的相关对象及 Filter
Net.Iris.PrintDynamicFilterClassConfig检查类到 Dynamic Filter 的配置
Net.Iris.PrintNetCullDistances检查当前 Cull Distance
Net.Iris.DebugNetRefHandle按 Handle 定位内部对象
net.Iris.LogReplicationProtocols输出创建出的 Replication Protocol

排查顺序:

对象是否拿到有效 NetRefHandle?
  ↓ 是
Filter 是否允许目标 Connection?
  ↓ 是
属性是否正确标 Dirty,或者是否进入兼容 Poll?
  ↓ 是
Priority 是否达到调度阈值?
  ↓ 是
包预算、依赖与 Data Stream 是否实际发送?
  ↓ 是
接收端是否实例化、反序列化并 Dispatch 到正确 Fragment?

这条链能把“客户端没看到”拆成注册、范围、变化、调度、传输和应用六类问题,而不是一上来就怀疑网络丢包。

八、RPC:优化调用语义,而不只是 Reliable 开关

RPC 适合表达动作请求和一次性通知,不适合持续同步可覆盖的状态。

场景更合适的表达
玩家请求开火Server RPC,服务端校验
当前武器、血量、阶段复制属性
高频瞄准或输入样本可丢、可合并的输入流
可由最终状态恢复的特效Unreliable RPC 或由状态推导
不能重复扣除的交易带请求 ID 的权威操作,而非只靠 Reliable

优化原则:

  • 高频且下一次会覆盖上一次的数据,优先 Unreliable;
  • Reliable 只保证传输语义,不负责业务幂等;
  • 不要每 Tick 发 RPC,优先按阈值、固定采样率或批量发送;
  • 合并前要明确是否允许丢失中间样本;
  • Multicast 不等于“免费广播”,接收者越多,总流量越大;
  • 用 RPC 连续推状态,会失去属性复制的合并与最终收敛优势。

Reliable 队列拥塞会让后续消息等待,最终表现可能不是“可靠”,而是越来越旧。RPC 的方向、所有权和可靠性详见 RPC 语义与可靠性。

九、三类典型场景怎么组合

场景 A:地图里有 2000 个可交互机关

推荐组合:

  1. 地图预放置 Actor 使用 DORM_Initial;
  2. 只复制 State + Revision,材质和动画由客户端推导;
  3. 交互时先 Flush Dormancy,再修改状态并 ForceNetUpdate();
  4. 大地图用 Replication Graph 空间节点或 Iris Filter 缩小每连接集合;
  5. 压测玩家传送到密集区域时的 Initial Channel 峰值。

常见错误是让所有机关保持 Awake,并以 10 Hz 检查一个几乎永远不变的布尔值。

场景 B:32 人战斗与大量 AI

推荐组合:

  1. 玩家和 AI 按距离、队伍、视野语义过滤;
  2. 近距离高频,远距离低频,并在客户端插值;
  3. 战斗关键状态提高优先级或触发一次 ForceNetUpdate();
  4. 自主端使用预测,第三人称表现可用 COND_SkipOwner;
  5. 不复制 AI 的感知与决策过程,只复制客户端表现需要的决策结果;
  6. 同时测稳态战斗和大量 AI 同时进入相关性的尖峰。

传统系统的 NetUpdateFrequency 是 Actor 级设置。如果需要真正的每连接、按距离调频,通常要在 Replication Graph 节点或 Iris Prioritizer 中表达,而不是每帧修改 Actor 上的全局频率。

场景 C:背包、Buff 与任务列表

推荐组合:

  1. Actor 或属性只对 Owner 相关;
  2. 列表较大且频繁局部变化时使用 Fast Array;
  3. 条目使用稳定 ID,不复制重复的静态配置;
  4. 服务端操作带请求 ID,客户端回调用于刷新表现而非执行权威逻辑;
  5. 分别统计首次全量和后续增量的字节与 CPU。

十、如何 Profile:不要凭感觉调参数

1. 先复现正确负载

至少覆盖下面几类工况:

工况暴露的问题
玩家原地不动空闲轮询、无意义属性比较
稳态战斗高频状态、RPC 与带宽竞争
集体出生/重连Initial Channel 和完整快照尖峰
大量 Actor 进入相关性路由、Channel 创建、首包预算
场景交互连锁变化Dormancy 唤醒风暴
高延迟、丢包和低带宽队列、可靠消息阻塞、状态陈旧

只在 PIE 里用 1 个客户端看平均带宽,几乎无法代表线上。

2. 工具各自回答什么

工具最适合回答的问题
stat net当前速率、包和连接是否异常
Unreal Insights CPU TraceServerReplicateActors 等阶段花了多少时间
Networking Insights哪个包、对象、属性或 RPC 占字节
Network ProfilerActor、属性、RPC 的流量汇总与对比
Replication Graph DebugActor 被路由到哪个节点、候选集是否异常
Iris Debug CommandsNet Object、Filter、Cull Distance 与 Handle 是否正确
Dormancy 日志与校验是否在休眠期间修改、是否正确唤醒
Network Emulation延迟、丢包、抖动下是否仍能收敛

Networking Insights 可通过 Net Trace 采集网络数据,例如在开发构建中使用:

-NetTrace=1 -trace=net

采集本身有成本。性能验收要区分“带完整 Trace 的诊断结果”和“接近 Shipping 配置的基准结果”。

3. 至少记录这些指标

  • 每连接 Out Bytes/s、Packets/s、丢包率和发送队列;
  • 服务端复制阶段平均值、P95、P99,而不只看平均值;
  • Considered、Relevant、Replicated、Dormant Actor 数;
  • 每类 Actor 的首次复制字节与增量字节;
  • 属性与 RPC 的 Top N 字节贡献;
  • Channel 打开/关闭速率;
  • 关键状态从服务端产生到客户端应用的延迟;
  • 最久未更新 Actor 的等待时间,用于发现饥饿。

十一、按症状排查

症状第一检查点常见根因
DS 帧时间高,但带宽不高候选 Actor、Dormancy、脏检查大量 Awake Actor 或每连接相关性遍历
带宽高,但 CPU 尚可属性/RPC Top N、初始状态字段过宽、广播过多、首包过大
远端角色一顿一顿实际到达间隔、插值缓冲频率过低、连接饱和或缺少平滑
偶发关键状态很晚才到优先级、Reliable 队列、等待年龄饱和、RPC 堆积、低优先级饥饿
机关偶尔不同步Dormancy 修改顺序休眠期间改属性,唤醒过晚
Actor 离开范围后仍留在客户端Dormancy 与 Relevancy用休眠代替了生命周期过滤
进入新区域时瞬间尖峰Initial Channel 数与初始字节同帧创建太多复杂 Actor
Push Model 开启后偶发漏同步Dirty 标记覆盖率绕过 Setter 直接写字段
Replication Graph 下客户端看不到对象节点路由新类型未加入任何有效节点
Iris 下 Actor 完全不出现Handle、Filter、Net Driver未注册、被过滤或并未启用目标 Iris Driver
Iris 下属性偶发不更新Change Mask、Push Dirty、Polling漏标 Dirty 或兼容轮询配置不符合预期
Iris 下子对象不出现Registered Subobject List、Fragment仍走旧虚函数路径或没有注册 Fragment

十二、常见“优化”为什么无效

做法问题
统一把所有频率砍半不区分关键状态,体验先坏
所有消息都改 Reliable拥塞时形成排队和旧消息阻塞
每次关键变化都 Multicast接收者集合过大,也无法表达最终状态
只看 Actor 数量做预算Actor 成本差异巨大,首包尤其昂贵
每 Tick ForceNetUpdate()抵消调频与批处理
用渲染可见性决定相关性玩法信息可能穿过遮挡仍然重要
开 Push Model 就认为带宽下降它主要优化脏检查 CPU
上 Replication Graph 就认为复制完成优化它主要缩小和组织候选集
打开 Iris 开关就认为迁移完成Filter、Prioritizer、子对象与 Dirty 路径仍需逐项迁移
大数组一律换 Fast Array小而低频的数据不一定值得复杂化
只测平均带宽尖峰、P99 延迟与饥饿仍可能失控

十三、推荐的落地顺序

一次可控的复制优化迭代可以按下面执行:

  1. 固定人数、地图、机器人脚本和网络条件,建立可重复基线;
  2. 用 Insights/Profiler 找出 CPU、字节和延迟各自的 Top N;
  3. 删除不必要的复制对象与字段;
  4. 用 Owner、距离、队伍和空间路由缩小每连接候选集;
  5. 给稳定对象加 Dormancy,按可接受陈旧度降低频率;
  6. 加条件复制、量化、Fast Array 和必要的状态聚合;
  7. Profiler 证明脏检查仍昂贵后,再引入 Push Model;
  8. Actor 与连接规模确实需要时,再评估 Replication Graph 或 Iris;
  9. 重跑同一场景,对比平均值、P95/P99 和玩家可感知延迟;
  10. 把预算与关键指标接入长期压测,防止后续内容增长把收益吃掉。

最终判断不是“用了多少 UE 网络特性”,而是:在目标玩家数和最坏场景下,关键状态按时到达,非关键状态不会挤占预算,成本随 Actor 和连接增长仍然可解释。

参考