Unreal Engine - Replication Graph

실험 구성#

측정 환경은 Push Model 포스트와 같은 테스트 프로젝트에 측정 모듈을 더한 것이다.

• 맵: 4 km × 4 km의 평평한 바닥에 PlayerStart 하나만 있는 측정 전용 레벨
• 프로세스: 에디터 바이너리를 -server로 띄운 Dedicated Server와 -game -nullrhi -nosound로 띄운 헤드리스 클라이언트. 한 PC(Ryzen 9 5950X)에서 서버와 클라이언트를 서로 다른 CCD에 고정
• 지표: 서버 프레임은 약 46 ms(초당 21 프레임)이고 그중 약 41 ms가 틱 레이트 대기라 비교는 프레임당 ServerReplicateActors 배타 시간으로 한다
• 대역폭: 클라이언트 rate 제한을 풀어 CPU만 잰다. 포화 조건 절에서만 30 KB/s로 제한한다
• 엔진: ++UE5+Release-5.8-CL-58210709

테스트 프로젝트의 서브시스템은 커맨드라인으로 조건을 받아 다음 순서로 돈다.

1. 클라이언트 N개가 붙으면 Player Pawn을 배치하고 둘씩 같은 팀으로 묶는다. 플레이어마다 owner 전용 인벤토리 액터를 하나 스폰한다.
2. 테스트 액터 5,000개를 소품(노란 상자) 60%, 루트(loot, 초록 구) 20%, AI(빨간 기둥) 15%, 탈것(파란 상자) 5%로 나눠 스폰한다. 탈것마다 dependent actor인 무기(하늘색 원뿔)를 하나 더 붙인다. 전역 액터 3개가 추가된다. 무기와 Pawn, 인벤토리까지 합치면 리플리케이션 액터는 5,265개다. 모든 테스트 액터는 리플리케이션 프로퍼티 16개를 push 기반으로 등록한다.
3. 60초 warmup. 절반 지점에서 소품의 90%를 DORM_DormantAll로 보낸다. 루트는 처음부터 dormant다.
4. 60초 측정. CSV 프로파일러 캡처와 Insights 트레이스 리전을 연다. 깨어 있는 액터의 1%가 초마다 프로퍼티 하나씩을 바꾸고 루트의 0.1%가 초마다 flush 후 쓰기를 한다. AI는 초당 3 m로 직선 이동하며 영역 경계에서 튕긴다.

클라이언트에서 본 테스트 액터다. 색은 위의 종류 구분이고 마네킹이 Player Pawn이다.

공간 분포는 세 가지다. Cull Distance는 모든 테스트 클래스에서 150 m(NetCullDistanceSquared 기본값)다.

드라이버는 셋이다.

• 기본 드라이버(Generic)
• 플러그인의 UBasicReplicationGraph. 모든 액터를 dormancy 경로로 넣는다
• 뒤의 커스텀 그래프 절에서 만드는 UOpenWorldReplicationGraph(이하 OpenWorld 그래프). 소품을 static, 루트를 dormancy, AI와 탈것을 dynamic 경로로 Grid에 넣고 dynamic 액터에 frequency bucket 3개를 쓴다

주 비교 조건은 5회, 나머지는 3회 반복해 평균을 쓴다. 실행마다 프레임 시간이 흔들리므로 프레임당 ms와 함께 Insights의 호출 수(Prioritize_InnerLoop가 검토한 액터 수, Replicate Actor Time의 호출 수)도 본다. 밀집 조건에는 보내는 횟수를 맞춘 대조군 둘을 더했다. OpenWorld 그래프의 버킷을 1개로 줄인 것과, 기본 드라이버의 NetUpdateFrequency를 10으로 낮춘 것이다.

Unreal Insights에는 리플리케이션 그래프 전용 트랙이 없지만 -statnamedevents로 띄우면 타이머가 보인다. 아래는 OpenWorld 그래프의 Cluster 런에서 서버 프레임 하나를 확대한 것이다.

① UReplicationGraph_ServerReplicateActors 4.56 ms 아래에 NET_PrepareReplication(Grid의 dynamic 액터 Cell 갱신이 여기)이 한 번 온다. 그 뒤에 연결마다 NET_ReplicateActors_GatherForConnection과 NET_ReplicateActors_ProcessGatheredLists(안에 PrioritizeForConnection과 ReplicateActorsForConnection), NET_ReplicateActors_LookForNonRelevantChannels가 이어진다. ② ③은 두 연결의 ProcessGatheredLists로 2.69 ms와 1.61 ms다. 프레임의 나머지 약 41 ms는 틱 레이트 대기다.

이 타이머 중 RG_QUICK_SCOPE_CYCLE_COUNTER로 선언된 Prioritize_InnerLoop*, NET_ReplicateActors_ReplicateSingleActor 등은 Test·Shipping에서 컴파일되지 않는다.

드라이버와 분포#

아래는 프레임당 ServerReplicateActors ms의 5회 평균과 표준편차다.

기본 드라이버의 NearPlayers와 Uniform은 런마다 서버 프레임 시간이 41–47 ms로 흔들려 편차가 ±8%이고 나머지 조건은 ±5% 안이다. 같은 기본 드라이버 Uniform 조건을 다른 측정 세트에서 다시 돌리면 2.05–2.23 ms가 나온다. 표의 2.54는 가장 높은 세트의 값이다. 아래 단계별 분해는 위의 Insights 타이머로 했다. 트레이스가 있는 첫 번째 런 하나의 값이라 표의 평균과 조금 다르다.

Uniform에서 리플리케이션 그래프는 기본 드라이버의 7분의 1이다. 단계별로 나누면 다음과 같다.

기본 드라이버는 5,265개 중 연결당 30개 남짓만 보내는데 비용의 90% 이상이 보낼지 말지를 정하는 데 든다. OpenWorld 그래프는 Grid가 viewer Cell의 리스트만 돌려주므로 나머지 5,100개는 검토 대상이 아니다.

모든 액터가 모든 연결에 관련 있는 Cluster에서도 OpenWorld 그래프가 기본 드라이버의 55%, Basic이 43%다. 다만 이 차이는 판별 비용이 아닌 보내는 횟수에서 온다.

보내는 횟수를 맞춘 대조군 둘의 결과다.

기본 드라이버의 NetUpdateFrequency를 10으로 낮추면 호출이 연결당 501회로 줄고 3.06 ms가 된다. 서버가 초당 21–23 프레임이라 10 Hz는 세 프레임에 한 번꼴이다.

반대로 OpenWorld의 버킷을 1개로 줄이면 호출 수가 1,555회로 100 Hz 기본 드라이버의 1,561회와 거의 같아진다. 이때 리플리케이션 그래프는 9.89 ms로 기본 드라이버보다 22% 느리다.

네 조건의 호출당 비용은 2.6–3.2 µs로 같은 자릿수다. 밀집 조건의 비용은 보내는 횟수가 정하고 그 횟수는 어느 드라이버든 설정으로 바꿀 수 있다.

아래 두 그림은 Cluster 조건에서 측정 구간 60초의 Callees 트리를 펼친 것이다.

① UActorChannel::ReplicateActor 안의 시간은 7.51 s와 7.22 s, 프레임당 5.80 ms와 5.55 ms로 같고 호출당 약 1.8 µs다. 후보를 고르는 단계도 비슷하다. 첫 번째 그림의 기본 드라이버는 ② 두 연결의 우선순위 1.04 s와 ③ consider list 894.94 ms(프레임당 0.69 ms)를 합쳐 프레임당 1.49 ms다. 두 번째 그림의 리플리케이션 그래프는 prepare와 gather 0.16 ms에 ③ 우선순위 계산 1.68 s를 합쳐 1.45 ms다.

NET_ReplicateActors_ReplicateSingleActor가 채널 밖에서 하는 일에서 차이가 난다. 두 번째 그림의 ② DependentActors 1.72 s와 CallPreReplication 1.1 s가 그 일부다. DependentActors는 inclusive라 그 안에서 재귀 호출되는 무기 액터의 채널 시간이 대부분이고 순회 자체(Excl 열)는 0.24 s다.

기본 드라이버에서 ReplicateActor 밖에 남는 리플리케이션 루프 시간은 0.93 ms다. PreReplication은 consider list를 만들면서 부르므로 앞의 consider list 0.69 ms 안에 들어 있다. 리플리케이션한 액터 하나당 채널 밖 비용은 기본 0.30 µs, 리플리케이션 그래프 0.85 µs다. 영속 리스트가 줄이는 것은 검토할 액터 수뿐이고 보내는 액터마다 붙는 부가 비용은 기본 드라이버보다 크다. 보낼 액터가 많을수록 그 차이가 쌓인다.

NearPlayers는 둘의 중간이어야 하는데 기본 드라이버는 6.47 ms로 Cluster에 가깝다. 보내는 양은 연결당 770회로 Cluster의 절반이다. 그런데 consider list 구성이 1.38 ms로 Cluster의 두 배이고 우선순위 계산이 1.97 ms다.

테스트 프로젝트는 소품의 90%와 루트 전부를 DORM_DormantAll로 둔다. 그런데 FNetworkObjectList는 액터가 모든 연결에서 dormant가 됐을 때만 active 목록에서 뺀다(Engine/Private/NetworkObjectList.cpp, MarkDormant의 DormantConnections.Num() == NumConnections). Cluster에서는 두 클라이언트가 모든 액터를 받으므로 3,685개가 빠져 active가 1,580개다. 흩어진 분포에서는 각 소품을 한 클라이언트만 받으므로 영영 active에 남아 매 프레임 5,265개 전부가 consider list를 거친다. Uniform의 1.7 ms도 같은 원인이다.

CSV의 NumberOfFullyDormantActors는 Cluster에서 3,685, NearPlayers에서 0, Uniform에서 60 남짓(두 플레이어가 3 m 거리라 같은 소품 일부를 본다)이다. 일부 연결에서만 dormant인 액터는 그 연결의 우선순위 계산만 건너뛰고 consider list 구성 비용은 그대로 낸다. 목록에서는 모든 연결이 그 액터를 한 번씩 본 뒤에야 빠진다. 넓은 맵에서는 그런 일이 잘 일어나지 않는다. 리플리케이션 그래프는 dormant 액터를 연결별 bDormantOnConnection으로 걸러서 이 문제가 없다.

액터 수와 연결 수#

아래는 Uniform에서 액터 수를 1,000에서 20,000으로 늘린 결과다.

기본 드라이버는 0.59에서 9.69 ms로 거의 선형으로 는다. 액터 하나당 프레임당 0.46 µs다. 20,000개 런의 분해는 consider list 5.2 ms, 우선순위 3.8 ms, 리플리케이션 0.5 ms다.

OpenWorld 그래프는 0.18에서 0.82 ms로 4.5배 늘고 그 증가분은 열린 채널 수(52 → 254)에 비례한다. 연결별 gather·prioritize·리플리케이션 비용은 맵의 액터 수와 상관없이 viewer 근처의 액터 수를 따른다. 전역 PrepareForReplication만 dynamic 액터 전체의 위치를 매 프레임 읽으므로 그 몫은 액터 수에 비례해 남는다.

연결 수는 2에서 16으로 늘렸다.

연결 수에서는 둘 다 선형이지만 기울기가 6배 다르다. 기본 드라이버는 연결당 0.78 ms, OpenWorld는 0.13 ms다. 연결 16개에서 기본 드라이버의 13.0 ms 중 9.2 ms가 16번의 우선순위 계산이다. 이 숫자는 액터 5,265개 × 연결 16개의 relevancy 검토에서 나온다. 리플리케이션 그래프의 2.14 ms는 리플리케이션 0.9 ms와 나머지 1.2 ms이고 연결마다 자기 Cell의 리스트만 본다.

dormant 비율과 Push Model#

소품의 dormant 비율과 Push Model 설정을 바꾼 결과다.

소품을 모두 깨어 있게 두면 기본 드라이버는 이 세트의 기준값 2.13 ms에서 2.56 ms로, OpenWorld는 0.36에서 0.63 ms로 늘고 기본 드라이버의 채널 수가 73에서 167로 는다. 깨어 있는 소품은 값이 바뀔 때마다 보내지고 채널이 열린 채로 유지된다. 기본 드라이버의 consider list는 앞서 본 대로 어차피 5,265개 전부라 변화는 리플리케이션 단계에만 나타난다.

Push Model은 리플리케이션 그래프 위에서 그대로 동작하지만 이 부하에서는 잴 수 있는 차이가 없다. 차트의 Push Model 두 조건(끔 2.20/0.39 ms, 켜고 skip 2.39/0.42 ms)과 기준(Push Model 켬, skip 끔)의 차이는 런 편차 안이다.

net.PushModelSkipUndirtiedReplication은 UActorChannel::ReplicateActor가 부르는 FObjectReplicator 안에서 판정된다. 리플리케이션 그래프의 ReplicateSingleActor도 같은 함수를 부르므로 리플리케이션 그래프 쪽에는 Push Model을 의식하는 코드가 없다. 프레임당 리플리케이션이 41건이고 변경률이 1%라 프로퍼티 비교 시간이 0.025 ms에서 0.013 ms로 줄어도 ServerReplicateActors의 3–6%다.

다만 리플리케이션 그래프는 채널에 들어가기 전에 주기를 소비하므로(프레임당 검사 절) Push Model이 비교를 건너뛰어 0바이트로 끝나도 NumReplicatedCleanActors로 집계된다. 두 최적화는 서로 다른 층을 줄이므로 함께 켜도 손해가 없다.

세 층의 상태#

리플리케이션 그래프는 상태를 세 층으로 나눠 둔다(Public/ReplicationGraphTypes.h).

복사이므로 나중에 윗층을 바꿔도 아래층에는 전파되지 않는다. 클래스 정보를 조회하면 TClassMap::Get이 부모 클래스를 거슬러 올라가 값을 찾은 뒤 요청한 클래스 이름으로 복사해 캐시한다. 그래서 자식 클래스가 한 번이라도 조회된 뒤에 부모 클래스에 SetClassInfo를 해도 그 자식에는 반영되지 않는다. 런타임에 Cull Distance를 바꾸려면 클래스, 액터, 모든 연결의 정보를 따로 고쳐야 한다.

• 엔진의 SetAllCullDistanceSettingsForActor는 액터와 모든 연결 두 층만 쓰고 클래스는 둔다.
• 디버그 명령 Net.RepGraph.SetClassCullDistance는 클래스와 액터, 그리고 명령을 보낸 연결 하나만 고친다.
• 공간화된 액터는 거기에 더해 Grid의 NotifyActorCullDistChange로 Cell 등록을 다시 해야 넓어진 반경의 연결에서 후보가 된다.

뒤의 설정값 절에서 런타임 SetNetUpdateFrequency가 반영되지 않는 것도 같은 구조 때문이다. 거리 검사와 Cell 계산은 액터 정보에 캐시된 WorldLocation을 쓴다.

Grid와 Cell#

UReplicationGraphNode_GridSpatialization2D가 공간 분할, 즉 거리 relevancy의 broad phase를 맡는다. 설정은 CellSize, SpatialBias, ConnectionMaxZ 셋이고 모두 생성자에서 0 또는 월드 최대로 초기화되므로 프로젝트가 채워야 한다. 액터는 세 경로로 들어온다.

액터 하나가 여러 Cell에 들어간다. GetCellInfoForActor는 위치를 중심으로 Cull Distance만큼의 정사각형을 만들어 그 사각형이 겹치는 모든 Cell에 넣는다. Cull Distance 150 m에 Cell 100 m면 사각형 한 변이 300 m라 한 액터가 4×4 Cell에 들어간다(Grid 가장자리에서만 줄어든다).

대신 gather는 viewer가 서 있는 Cell 하나만 본다. 이웃 Cell을 찾아다니지 않고 액터 쪽이 미리 퍼져 있는 구조다. 여기에 쓰이는 Cull Distance는 액터 정보의 Settings.GetCullDistance()에서 온다. 연결별 값은 쓰지 않는다.

static 액터는 추가될 때의 위치로 Cell이 정해지고 다시 계산되지 않는다. dynamic 액터만 매 프레임 PrepareForReplication에서 위치를 읽어 Cell을 옮긴다. SetBiasAndGridBounds로 경계를 정하지 않은 그래프에서는 SpatialBias보다 작은 좌표에 액터가 나타나면 Grid를 통째로 다시 만든다. 그래서 맵 밖으로 날아가는 발사체 클래스는 AddToClassRebuildDenyList에 넣어 가장자리 Cell로 클램프되게 한다. Lyra는 Lyra.RepGraph.DisableSpatialRebuilds(기본 1)로 AActor 자체를 목록에 넣어 재구축을 끈다.

Cell 노드는 자기 리스트가 곧 static 리스트다. dynamic 액터는 frequency bucket 노드로, dormant 액터는 dormancy 노드로 간다.

1
GridSpatialization2D
2
└── GridCell (Cell마다)
3
    ├── static 리스트 (자기 ReplicationActorList)
4
    ├── DynamicNode: ActorListFrequencyBuckets 또는 DynamicSpatialFrequency
5
    └── DormancyNode
6
        └── ConnectionDormancyNode (연결마다, 마스터 리스트의 사본)

static 액터가 잠들면 Cell이 자기 리스트에서 빼서 dormancy 노드로 옮기고 깨면 다시 돌려보낸다. AddActor_Dormancy로 들어온 액터는 깨어나면 dynamic 액터가 되어 위치가 갱신된다. AddActor_Static으로 들어온 액터는 깨어나도 원래 Cell에 그대로 있다. Dormancy 노드는 연결마다 마스터 리스트의 사본을 두고 gather 때마다 bDormantOnConnection인 액터를 뺀다. 그래서 사본은 그 연결이 아직 받지 못한 dormant 액터 목록이다. Cell에 dormant 액터가 많으면 새 연결마다 그만큼 복사한다. 연결이 끊겨도 사본은 저절로 사라지지 않는다.

프레임당 검사와 점수#

gather가 끝나면 ReplicateActorListsForConnections_Default가 리스트를 순회해 FPrioritizedRepList를 만든다(Private/ReplicationGraph.cpp). 아래 그림은 액터 하나가 거치는 검사 순서와 각 단계를 정하는 설정이다.

• dormant 검사가 전역 정보 조회보다 앞에 있어서 잠든 액터의 프레임당 비용은 맵 조회 하나다.
• 거리 컬링은 DistancePriorityScale > 0인 클래스만 거친다. UReplicationGraph 기본 구현(이하 베이스 그래프)은 AInfo와 APlayerController를 0으로 두지만 Basic과 Lyra식 초기화가 모든 클래스를 1로 덮어쓴다. 그래서 실제로는 Cull Distance 0이 이 액터들을 지킨다(0이면 검사를 건너뛴다). bForceCullDistanceToZero가 켜진 액터도 빠지지 않는다.
• 채널 닫힘 프레임은 리플리케이션이 아니라 거리 검사를 통과한 시점에 갱신된다.

점수는 낮을수록 먼저 리플리케이션된다. 정렬이 오름차순이고 중요도 보정이 모두 뺄셈이기 때문이다.

• AccumulatedNetPriorityBias는 클수록 덜 중요하다. 이름만 보고 양수를 넣으면 반대로 동작한다.
• 잠들려는 액터의 −1.5는 주석에 이유가 있다. dormancy는 마지막 리플리케이션이 ack돼야 완료되므로 새로 스폰된 액터들에 계속 밀리면 영영 잠들지 못한다.
• 정렬은 TArray::Sort, 즉 introsort라 같은 점수의 액터는 프레임마다 순서가 바뀔 수 있다. Epic이 포럼에서 우선순위는 고려 순서만 바꾸며 액터 간 순서는 보장되지 않는다고 답한 것과 맞는다.

정렬된 리스트는 앞에서부터 ReplicateSingleActor로 보낸다.

• 채널에 들어가기 전에 LastRepFrameNum과 NextReplicationFrameNum을 쓰므로 0바이트를 보내도 주기는 소비된다.
• PreReplication은 연결이 몇 개든 액터당 프레임당 한 번만 부른다.
• bWantsToBeDormant면 리플리케이션할 때마다 StartBecomingDormant를 다시 건다.
• dependent actor는 부모 직후에 재귀적으로 리플리케이션한다.

채널은 프레임 수로 닫힌다. UpdateActorChannelCloseFrameNum은 FrameNum + ReplicationPeriodFrame + ActorChannelFrameTimeout + GlobalActorChannelFrameNumTimeout을 계산해 기존 값보다 크면 갱신한다. 기본값은 주기 1, 타임아웃 4, 전역 여유 2이므로 마지막으로 gather된 뒤 7프레임이 지나면 닫힌다.

LookForNonRelevantChannels가 매 프레임 연결의 채널 맵을 돌며 지난 채널을 Close(Relevancy)한다. startup 액터(IsNetStartupActor)의 채널은 이 경로로 닫지 않는다. 기본 드라이버의 RelevantTimeout이 초 단위인 것과 달리 전부 프레임 단위다.

포화 조건#

위 측정은 클라이언트 rate 제한을 풀고 CPU만 쟀다. 포화가 나면 무엇이 달라지는지 보려고 AI와 탈것이 이동을 리플리케이션하게 해 Cluster에서 연결당 약 90 KB/s가 나가게 만들고 클라이언트 rate를 30 KB/s로 제한했다(엔진 기본값은 100 KB/s). 각 3회다. “5초 안 갱신”은 클라이언트에 있는 AI 중 최근 5초 안에 갱신을 받은 비율이다. “전체 수신”은 접속 뒤 액터를 다 받기까지(클라이언트가 세는 5,250여 개 중 5,200개 기준) 걸린 시간이다.

이동을 리플리케이션하면 호출당 비용이 늘어 제한 없는 조건에서도 6.76 ms가 걸린다. 앞 표에서는 4.48 ms였다. 포화되면 서버는 오히려 덜 일한다. 연결이 포화되면 ReplicateActorsForConnection이 정렬된 리스트의 앞부분만 보내고 멈추므로 호출이 735회에서 129회로, 시간이 6.76 ms에서 2.60 ms로 줄었다. 대신 클라이언트가 액터를 다 받기까지 1초에서 12초로 늘었다.

StarvationPriorityScale을 0으로 두면 가까운 액터가 매 프레임 앞자리를 차지해 나머지는 영영 밀린다. 120초 뒤에도 클라이언트는 액터의 62%만 받았고 받은 AI 중 5초 안에 갱신된 것은 약 40%였다. 1이면 12초 안에 전부 받고 모든 AI가 5초 안에 갱신된다. 포화가 있는 서버에서 이 값은 성능보다 공평성을 정한다.

Net.RepGraph.ActorDiscoveryBudget <KB/s>는 아직 클라이언트가 스폰을 ack하지 않은 채널의 트래픽을 프레임당 그 양까지 연결의 송신량에서 빼 준다. 그만큼은 포화 판정에서 면제되고 넘치는 몫은 일반 트래픽으로 센다. 상한을 거는 값은 아니다. 콘솔 명령이고 기본값 0은 끔이다. 10 KB/s를 주자 접속 직후 전체 액터를 받기까지의 시간이 12초에서 8초로 줄었고 정상 상태는 같았다. 접속 직후나 핫드롭처럼 수천 채널이 한꺼번에 열릴 때 쓰는 값이다.

기본 드라이버는 같은 제한에서 받은 AI는 거의 전부 갱신하지만 접속 뒤 120초가 지나도 액터의 80%쯤만 받았다. 새 채널을 열어야 하는 액터가 뒤로 밀리는 것인데 원인은 소스에서 따로 확인하지 않았다.

액터 범주와 라우팅#

리플리케이션 그래프를 어떻게 구성할지는 게임의 액터가 어떤 범주로 나뉘는지에 달려 있다. 아래 표는 공식 문서의 예시와 Lyra 5.8.3의 ULyraReplicationGraph, 2018년 라이브스트림의 Fortnite 그래프에서 오픈월드 멀티플레이어의 범주를 추린 것이다. 테스트 액터 종류도 이 범주를 따른다.

측정에 쓴 UOpenWorldReplicationGraph는 Lyra 5.8.3의 구조를 바탕으로 이 표를 구현한 것이다. Lyra 자체는 ULyraReplicationGraphSettings의 bDisableReplicationGraph가 기본 true라 샘플을 켜도 리플리케이션 그래프는 꺼져 있다. 켜면 Cell 100 m, 버킷 3개, 파괴 정보 거리 300 m, Fast Shared Path 켬(10 KB/s, Cull Distance의 80%)이 기본값이다. 클래스마다 Spatialize_Static, Spatialize_Dynamic, Spatialize_Dormancy, RelevantAllConnections, RelevantOwnerConnection, NotRouted 중 하나를 정한다. 레거시 플래그에서 기본값을 유도한 뒤 프로젝트 설정으로 덮어쓴다.

• bAlwaysRelevant면 RelevantAllConnections
• Lyra는 bOnlyRelevantToOwner와 bNetUseOwnerRelevancy 클래스를 NotRouted로 두고 연결별 노드가 PlayerController와 Pawn, PlayerState만 직접 끌어온다. OpenWorld 그래프는 그 대신 RelevantOwnerConnection 라우팅을 두었다
• 나머지 리플리케이션 액터는 Spatialize_Dynamic

아래 코드는 위 라우팅과 노드 구성을 공식 문서의 일반 예제에 맞춰 5.8.3에서 컴파일되게 다시 쓴 것이다. OpenWorld 그래프에 있는 스트리밍 레벨 리스트, Team Node, owner가 아직 없는 액터의 재시도 같은 게임 특화 부분은 뺐다.

1
UENUM()
2
enum class EClassRepNodeMapping : uint8
3
{
4
  NotRouted,
5
  RelevantAllConnections,
6
  RelevantOwnerConnection,
7
  Spatialize_Static,
8
  Spatialize_Dynamic,
9
  Spatialize_Dormancy,
10
};
11

12
static bool IsSpatialized(EClassRepNodeMapping Mapping) { return Mapping >= EClassRepNodeMapping::Spatialize_Static; }
13

14
UCLASS()
15
class UExampleReplicationGraph : public UReplicationGraph
16
{
17
  GENERATED_BODY()
18

19
public:
20
  virtual void InitGlobalActorClassSettings() override;
21
  virtual void InitGlobalGraphNodes() override;
22
  virtual void InitConnectionGraphNodes(UNetReplicationGraphConnection* RepGraphConnection) override;
23
  virtual void RouteAddNetworkActorToNodes(const FNewReplicatedActorInfo& ActorInfo, FGlobalActorReplicationInfo& GlobalInfo) override;
24
  virtual void RouteRemoveNetworkActorToNodes(const FNewReplicatedActorInfo& ActorInfo) override;
25

26
  EClassRepNodeMapping GetClassNodeMapping(UClass* Class) const;
27
  void InitClassReplicationInfo(FClassReplicationInfo& Info, UClass* Class, bool bSpatialize) const;
28

29
  UPROPERTY() TObjectPtr<UReplicationGraphNode_GridSpatialization2D> GridNode;
30
  UPROPERTY() TObjectPtr<UReplicationGraphNode_ActorList> AlwaysRelevantNode;
31
  TClassMap<EClassRepNodeMapping> ClassRepNodePolicies;
32
  TMap<TWeakObjectPtr<UNetConnection>, TObjectPtr<UReplicationGraphNode_AlwaysRelevant_ForConnection>> ConnectionNodes;
33
};
34

35
// 모든 PlayerState를 프레임당 TargetActorsPerFrame개씩 돌려 보내는 노드 (공식 문서의 PlayerStateFrequencyLimiter)
36
UCLASS()
37
class UExampleNode_PlayerStateFrequencyLimiter : public UReplicationGraphNode
38
{
39
  GENERATED_BODY()
40

41
public:
42
  // 이 플래그가 없으면 InitNode가 PrepareForReplication 목록에 넣지 않아 노드가 아무것도 돌려주지 않는다 (Team Node 절 참고)
43
  UExampleNode_PlayerStateFrequencyLimiter() { bRequiresPrepareForReplicationCall = true; }
44

45
  virtual void NotifyAddNetworkActor(const FNewReplicatedActorInfo& Actor) override {}
46
  virtual bool NotifyRemoveNetworkActor(const FNewReplicatedActorInfo& Actor, bool bWarnIfNotFound = true) override { return false; }
47
  virtual bool NotifyActorRenamed(const FRenamedReplicatedActorInfo& Actor, bool bWarnIfNotFound = true) override { return false; }
48
  virtual void PrepareForReplication() override;
49
  virtual void GatherActorListsForConnection(const FConnectionGatherActorListParameters& Params) override;
50

51
  int32 TargetActorsPerFrame = 2;
52
  TArray<FActorRepListRefView> ReplicationActorLists;
53
};

1
EClassRepNodeMapping UExampleReplicationGraph::GetClassNodeMapping(UClass* Class) const
2
{
3
  if (!Class) return EClassRepNodeMapping::NotRouted;
4

5
  // 명시적으로 정한 클래스는 그대로
6
  if (const EClassRepNodeMapping* Explicit = ClassRepNodePolicies.FindWithoutClassRecursion(Class)) return *Explicit;
7

8
  const AActor* CDO = Cast<AActor>(Class->GetDefaultObject());
9
  if (!CDO || !CDO->GetIsReplicated()) return EClassRepNodeMapping::NotRouted;
10

11
  // 부모와 플래그가 같으면 부모의 매핑을 따른다. NotRouted로 둔 PlayerState의 서브클래스도 여기로 온다
12
  if (const AActor* SuperCDO = Cast<AActor>(Class->GetSuperClass()->GetDefaultObject()))
13
  {
14
    if (SuperCDO->GetIsReplicated() == CDO->GetIsReplicated()
15
      && SuperCDO->bAlwaysRelevant == CDO->bAlwaysRelevant
16
      && SuperCDO->bOnlyRelevantToOwner == CDO->bOnlyRelevantToOwner
17
      && SuperCDO->bNetUseOwnerRelevancy == CDO->bNetUseOwnerRelevancy)
18
    {
19
      return GetClassNodeMapping(Class->GetSuperClass());
20
    }
21
  }
22

23
  // 레거시 플래그에서 기본값을 유도한다. 프로젝트 설정으로 덮어쓰는 부분은 생략
24
  if (CDO->bAlwaysRelevant && !CDO->bOnlyRelevantToOwner) return EClassRepNodeMapping::RelevantAllConnections;
25
  if (CDO->bOnlyRelevantToOwner) return EClassRepNodeMapping::RelevantOwnerConnection;
26
  return EClassRepNodeMapping::Spatialize_Dynamic;
27
}
28

29
void UExampleReplicationGraph::InitClassReplicationInfo(FClassReplicationInfo& Info, UClass* Class, bool bSpatialize) const
30
{
31
  const AActor* CDO = Class->GetDefaultObject<AActor>();
32
  Info.ReplicationPeriodFrame = GetReplicationPeriodFrameForFrequency(CDO->GetNetUpdateFrequency());
33
  // Cull Distance는 Grid에 들어가는 클래스에만 준다. AlwaysRelevant·owner 전용 액터는 WorldLocation이 원점에 고정이라
34
  // Cull Distance가 있으면 viewer가 원점에서 그만큼 멀어지는 순간 거리 컬링에 걸린다
35
  if (bSpatialize) Info.SetCullDistanceSquared(CDO->GetNetCullDistanceSquared());
36
}
37

38
void UExampleReplicationGraph::InitGlobalActorClassSettings()
39
{
40
  Super::InitGlobalActorClassSettings();
41

42
  // 전용 노드가 있는 엔진 클래스는 라우팅하지 않는다
43
  ClassRepNodePolicies.Set(APlayerState::StaticClass(), EClassRepNodeMapping::NotRouted);
44
  ClassRepNodePolicies.Set(ALevelScriptActor::StaticClass(), EClassRepNodeMapping::NotRouted);
45
  ClassRepNodePolicies.Set(AReplicationGraphDebugActor::StaticClass(), EClassRepNodeMapping::NotRouted);
46

47
  // 초기화 뒤에 로드되는 Blueprint 서브클래스는 첫 조회 때 이 두 람다로 온다
48
  ClassRepNodePolicies.InitNewElement = [this](UClass* Class, EClassRepNodeMapping& Mapping)
49
  {
50
    Mapping = GetClassNodeMapping(Class);
51
    return true;
52
  };
53
  GlobalActorReplicationInfoMap.SetInitClassInfoFunc([this](UClass* Class, FClassReplicationInfo& Info)
54
  {
55
    InitClassReplicationInfo(Info, Class, IsSpatialized(ClassRepNodePolicies.GetChecked(Class)));
56
    return true;
57
  });
58

59
  for (TObjectIterator<UClass> It; It; ++It)
60
  {
61
    UClass* Class = *It;
62
    const AActor* CDO = Cast<AActor>(Class->GetDefaultObject());
63
    if (!CDO || !CDO->GetIsReplicated()) continue;
64
    if (Class->GetName().StartsWith(TEXT("SKEL_")) || Class->GetName().StartsWith(TEXT("REINST_"))) continue;
65

66
    // TClassMap::Get은 부모 값을 자식 키로 복사해 돌려주므로 "없을 때만 Set"이라는 가드를 쓰면 자식이 부모 라우팅을 물려받는다. 무조건 쓴다
67
    const EClassRepNodeMapping Mapping = GetClassNodeMapping(Class);
68
    ClassRepNodePolicies.Set(Class, Mapping);
69

70
    FClassReplicationInfo Info;
71
    InitClassReplicationInfo(Info, Class, IsSpatialized(Mapping));
72
    GlobalActorReplicationInfoMap.SetClassInfo(Class, Info);
73
  }
74

75
  UReplicationGraphNode_ActorListFrequencyBuckets::DefaultSettings.NumBuckets = 3;
76
  UReplicationGraphNode_ActorListFrequencyBuckets::DefaultSettings.BucketThresholds.Reset();
77
}
78

79
void UExampleReplicationGraph::InitGlobalGraphNodes()
80
{
81
  GridNode = CreateNewNode<UReplicationGraphNode_GridSpatialization2D>();
82
  GridNode->CellSize = 10000.f;                           // 100 m
83
  GridNode->SpatialBias = FVector2D(-150000.f, -200000.f); // 맵의 최소 좌표
84
  GridNode->AddToClassRebuildDenyList(AActor::StaticClass());
85
  AddGlobalGraphNode(GridNode);
86

87
  AlwaysRelevantNode = CreateNewNode<UReplicationGraphNode_ActorList>();
88
  AddGlobalGraphNode(AlwaysRelevantNode);
89

90
  AddGlobalGraphNode(CreateNewNode<UExampleNode_PlayerStateFrequencyLimiter>());
91
}
92

93
void UExampleReplicationGraph::InitConnectionGraphNodes(UNetReplicationGraphConnection* RepGraphConnection)
94
{
95
  Super::InitConnectionGraphNodes(RepGraphConnection);
96
  // viewer(PlayerController)와 ViewTarget을 매 프레임 다시 모으는 엔진 노드. owner 전용 액터도 여기에 넣는다
97
  UReplicationGraphNode_AlwaysRelevant_ForConnection* Node = CreateNewNode<UReplicationGraphNode_AlwaysRelevant_ForConnection>();
98
  AddConnectionGraphNode(Node, RepGraphConnection);
99
  ConnectionNodes.Add(RepGraphConnection->NetConnection, Node);
100
}
101

102
void UExampleReplicationGraph::RouteAddNetworkActorToNodes(const FNewReplicatedActorInfo& ActorInfo, FGlobalActorReplicationInfo& GlobalInfo)
103
{
104
  switch (ClassRepNodePolicies.GetChecked(ActorInfo.Class))
105
  {
106
  case EClassRepNodeMapping::NotRouted:              break;
107
  case EClassRepNodeMapping::RelevantAllConnections: AlwaysRelevantNode->NotifyAddNetworkActor(ActorInfo); break;
108
  case EClassRepNodeMapping::RelevantOwnerConnection:
109
    if (UNetConnection* Connection = ActorInfo.Actor->GetNetConnection())
110
    {
111
      if (TObjectPtr<UReplicationGraphNode_AlwaysRelevant_ForConnection>* Node = ConnectionNodes.Find(Connection))
112
      {
113
        (*Node)->NotifyAddNetworkActor(ActorInfo);
114
      }
115
    }
116
    break; // owner가 아직 없으면 다음 프레임에 다시 시도하는 목록이 따로 필요하다
117
  case EClassRepNodeMapping::Spatialize_Static:      GridNode->AddActor_Static(ActorInfo, GlobalInfo);   break;
118
  case EClassRepNodeMapping::Spatialize_Dynamic:     GridNode->AddActor_Dynamic(ActorInfo, GlobalInfo);  break;
119
  case EClassRepNodeMapping::Spatialize_Dormancy:    GridNode->AddActor_Dormancy(ActorInfo, GlobalInfo); break;
120
  }
121
}
122

123
void UExampleReplicationGraph::RouteRemoveNetworkActorToNodes(const FNewReplicatedActorInfo& ActorInfo)
124
{
125
  switch (ClassRepNodePolicies.GetChecked(ActorInfo.Class))
126
  {
127
  case EClassRepNodeMapping::NotRouted:              break;
128
  case EClassRepNodeMapping::RelevantAllConnections: AlwaysRelevantNode->NotifyRemoveNetworkActor(ActorInfo); break;
129
  case EClassRepNodeMapping::RelevantOwnerConnection:
130
    if (UNetConnection* Connection = ActorInfo.Actor->GetNetConnection())
131
    {
132
      if (TObjectPtr<UReplicationGraphNode_AlwaysRelevant_ForConnection>* Node = ConnectionNodes.Find(Connection))
133
      {
134
        (*Node)->NotifyRemoveNetworkActor(ActorInfo, false);
135
      }
136
    }
137
    break;
138
  case EClassRepNodeMapping::Spatialize_Static:      GridNode->RemoveActor_Static(ActorInfo);   break;
139
  case EClassRepNodeMapping::Spatialize_Dynamic:     GridNode->RemoveActor_Dynamic(ActorInfo);  break;
140
  case EClassRepNodeMapping::Spatialize_Dormancy:    GridNode->RemoveActor_Dormancy(ActorInfo); break;
141
  }
142
}

1
// PlayerState를 프레임당 TargetActorsPerFrame개씩 나눠 돌려 보낸다
2
void UExampleNode_PlayerStateFrequencyLimiter::PrepareForReplication()
3
{
4
  ReplicationActorLists.Reset();
5
  ReplicationActorLists.AddDefaulted();
6
  for (TActorIterator<APlayerState> It(GetWorld()); It; ++It)
7
  {
8
    if (!IsActorValidForReplicationGather(*It)) continue;
9
    if (ReplicationActorLists.Last().Num() >= TargetActorsPerFrame) ReplicationActorLists.AddDefaulted();
10
    ReplicationActorLists.Last().Add(*It);
11
  }
12
}
13

14
void UExampleNode_PlayerStateFrequencyLimiter::GatherActorListsForConnection(const FConnectionGatherActorListParameters& Params)
15
{
16
  if (ReplicationActorLists.Num() == 0) return;
17
  Params.OutGatheredReplicationLists.AddReplicationActorList(ReplicationActorLists[Params.ReplicationFrameNum % ReplicationActorLists.Num()]);
18
}

라우팅 표는 RouteAddNetworkActorToNodes의 switch에 들어 있다. 노드 넷(Grid, AlwaysRelevant, 연결별 AlwaysRelevant, PlayerState 빈도 제한)은 글 첫머리 그림과 같은 구성이다. 그래프는 UReplicationDriver::CreateReplicationDriverDelegate나 ini의 ReplicationDriverClassName으로 지정한다. 노드는 전역·연결 노드면 CreateNewNode, 노드의 자식이면 CreateChildNode로만 만든다.

기본값을 dynamic으로 두는 것은 잘못 넣었을 때의 결과가 달라서다. 움직이는 액터를 static으로 넣으면 보이지 않지만 안 움직이는 액터를 dynamic으로 넣으면 비용만 든다. static과 dormancy는 클래스를 알 때만 명시한다.

탈것의 무기처럼 부모가 리플리케이션될 때만 함께 가면 되는 액터도 있다. 이런 액터는 노드에 넣지 않고 AddDependentActor로 부모에 묶는다. 기본 드라이버에서 bNetUseOwnerRelevancy로 owner를 따라가던 장비·무기 클래스가 여기 해당한다. Lyra 규칙으로는 NotRouted가 되어 그래프로 옮기면 조용히 보이지 않게 된다. 그래서 부모에 묶거나 dynamic으로 명시해야 한다.

부모와 같은 프레임에 고려된다는 것까지만 보장되고 같은 패킷에 들어간다는 보장은 없다. dependent actor 목록은 노드가 아니라 액터 정보의 배열이라 PrintAll의 노드 트리에는 나오지 않는다.

Team Node와 Cull Distance 0#

팀원을 거리와 무관하게 보여 주는 노드는 리스트만 돌려줘서는 동작하지 않는다. prioritize 단계의 거리 컬링이 리스트 출처를 가리지 않기 때문이다. 포럼에서 본 “팀원을 리스트에 직접 넣었는데도 거리 컬링된다”는 보고가 이 경우로 보인다. 노드는 gather 때 그 연결의 액터 정보에 bForceCullDistanceToZero를 세우고 팀에서 빠진 액터는 플래그를 풀어야 한다.

1
// OpenWorldReplicationGraph.cpp, UOpenWorldReplicationGraphNode_Team::GatherActorListsForConnection
2
for (FActorRepListType Actor : TeamActorList)
3
{
4
  FConnectionReplicationActorInfo& Info = Params.ConnectionManager.ActorInfoMap.FindOrAdd(Actor);
5
  if (!Info.bForceCullDistanceToZero) { Info.bForceCullDistanceToZero = 1; Forced.Add(Actor); }
6
}
7
Params.OutGatheredReplicationLists.AddReplicationActorList(TeamActorList);

Team Node는 같은 팀의 연결들이 공유하는 노드라 전역 노드 목록에는 없다. 그래도 CreateNewNode로 만들고 bRequiresPrepareForReplicationCall을 켜 두면 InitNode가 PrepareForReplicationNodes에 넣어 준다. CreateChildNode로 만든 노드만 직접 넣어야 한다. 둘 다 하면 PrepareForReplication이 프레임마다 두 번 돈다. 팀원의 Pawn은 Grid에도 있어 가까운 팀원은 두 리스트에서 돌아오지만 같은 프레임의 중복은 LastRepFrameNum == FrameNum으로 걸러진다.

만들 때 걸리는 것#

• Blueprint 서브클래스의 설정. InitGlobalActorClassSettings에서 TObjectIterator<UClass>로 클래스를 돌 때 SKEL_, REINST_로 시작하는 컴파일 중간 클래스는 건너뛰어야 한다. GlobalActorReplicationInfoMap.SetInitClassInfoFunc로 lazy init도 걸어야 한다. 리플리케이션 그래프는 BeginPlay 전에 초기화되므로 그 시점에 로드되지 않은 Blueprint 서브클래스는 순회에 나오지 않는다. lazy init이 없으면 부모 클래스 값이 복사돼 동작은 하지만 그 서브클래스에 설정을 줄 길이 없어진다.
• 설정은 엔진 초기화 전에. 같은 이유로 클래스 설정은 CDO에서만 읽을 수 있다. 게임 코드에서 CVar를 바꾸는 것도 맵 로드 뒤에 실행되는 -ExecCmds도 늦다. UDeveloperSettingsBackedByCVars로 둔 값은 -dpcvars="OpenWorld.RepGraph.DynamicActorFrequencyBuckets=1" 형식으로 줘야 초기화 때 읽힌다. 설정값 절의 측정은 이 방식으로 조건을 바꿨다.
• 드라이버 지정. ini의 ReplicationDriverClassName과 UReplicationDriver::CreateReplicationDriverDelegate 둘 다 공식 문서에 있다. 델리게이트가 ini보다 우선하고 nullptr를 돌려주면 기본 드라이버로 간다. 어느 쪽이든 NetDriverName이 NAME_GameNetDriver인지 확인해야 한다. InitBase를 지나는 서버 드라이버가 모두 같은 델리게이트를 부르므로 DemoNetDriver(리플레이)와 BeaconNetDriver도 해당된다.
• DynamicSpatialFrequency 존 표. 헤더의 MinDotProduct 주석은 이 값 이상이어야 그 존이라고 적지만 CalcFrequencyForActor는 DotP <= MinDotProduct인 첫 존을 고른다. 주석대로 {0.8 앞쪽}, {-1.0 나머지} 순으로 적으면 정면의 액터가 어느 존에도 들어가지 않아 리플리케이션에서 빠진다. 액터마다 프레임마다 “was not placed in any valid zone” 경고가 찍혀 측정 60초에 약 12,900줄, 프레임당 1.1 ms의 로그 비용이 Insights 측정값에 들어갔다. 설정값 절의 0.40 ms는 존을 고친 뒤 다시 잰 값이다. 존은 오름차순으로 적고 마지막을 1.0으로 끝낸다.
• 스트리밍 레벨. 노드의 리스트는 레벨별로 나뉘어 있고 gather는 클라이언트가 그 레벨을 로드했을 때만(ClientVisibleLevelNamesRef) 돌려준다. 로드하지 않은 레벨의 액터는 LogReplicationGraph Verbose에 “Level Not Loaded”로 남는다. 스트리밍 레벨의 bAlwaysRelevant 액터는 전역 노드 대신 Lyra의 AlwaysRelevantStreamingLevelActors처럼 레벨별 리스트에 둔다. 액터의 outer가 바뀌는 프로젝트는 5.5 업그레이드 노트대로 Net.RepGraph.HandleDynamicActorRename(기본 0)을 켠다.
• viewer는 카메라다. 리플리케이션 그래프의 viewer는 Pawn이 아니라 GetPlayerViewPoint가 돌려주는 위치다. 거리 검사도 이 위치 기준이라 Cull Distance 150 m보다 높이 띄운 관전 카메라는 바닥의 액터를 하나도 받지 못한다. 관전 카메라가 있는 게임은 viewer가 어디인지부터 확인한다.

dormant 직후의 reliable multicast가 유실된다#

• 현상: 액터를 DORM_DormantAll로 보낸 직후 reliable multicast를 보내면 네트워크 지연이 있을 때 일부 클라이언트가 받지 못한다. Epic 포럼에 2026년 5월 올라온 보고(UE-378758)다. Epic이 재현을 확인했고 2026년 7월 기준 미수정이다. 테스트 프로젝트에서는 PktLag=200에서 잠재운 지 4프레임 뒤에 보낸 reliable RPC 50개가 전부 사라졌고 기본 드라이버는 하나도 잃지 않았다.
• 원인: 잠재운 액터의 채널이 Closing인 동안 리플리케이션 그래프는 close bunch의 ack가 올 때까지 연결 정보의 채널을 비우지 않는다. multicast 경로는 그 연결을 건너뛰고 새로 열지도 않는다.
• 대처: reliable RPC를 먼저 보내고 잠재운다. 잠든 액터에 보내야 하면 그 연결의 채널이 정리된 뒤(NotifyActorChannelCleanedUp)로 미룬다.

Seamless Travel 중의 multicast#

• 현상: 클라이언트가 Seamless Travel을 끝내기 전에 서버가 Persistent Level 액터(GameState 등)에 reliable multicast를 보내면 클라이언트는 도착 후 그 액터를 파괴해 버린다. Epic이 알려진 문제(UE-361443)로 확인했고 2026년 7월 기준 미수정이다. 테스트 프로젝트에서 재현하지는 않았고 소스로만 확인했다.
• 원인: owner RPC 경로는 채널을 열기 전에 NetDriver->IsLevelInitializedForActor를 확인하지만 multicast 경로는 확인하지 않는다.
• 대처: ProcessRemoteFunction을 오버라이드해 multicast에서도 같은 검사를 넣는다.

static으로 넣은 액터를 옮기면 보이지 않는다#

• 현상: 스폰 직후 위치를 바꾸는 액터, 플레이어가 집어서 옮기는 소품을 static으로 두면 옛 Cell에 남아 끝까지 보이지 않는다. 포럼과 블로그에서 본 “static 액터가 뭉텅이로 사라진다”는 보고가 이 경우로 보인다.
• 원인: AddActor_Static은 추가 시점의 위치로 Cell을 정하고 다시 계산하지 않는다. 깨워도 소용없다. Grid는 AddActor_Dormancy로 들어온 액터의 dormancy 변화만 구독한다. Spatialize_Dormancy로 넣은 액터는 SetNetDormancy(DORM_Awake)로 깨우면 dynamic 리스트로 옮겨져 다음 PrepareForReplication에서 새 Cell에 들어간다. Spatialize_Static으로 넣은 액터는 깨워도 옛 Cell에 남는다. 액터 정보에 캐시된 WorldLocation도 갱신되지 않아 거리 검사까지 옛 위치로 한다. FlushNetDormancy는 연결별 dormancy 사본만 고치고 Cell은 옮기지 않는다.
• 대처: 옮길 수 있는 소품은 Spatialize_Dormancy로 두고 집을 때 깨웠다가 놓을 때 다시 재운다. 이미 static으로 등록한 액터를 옮겨야 하면 노드에서 빼고 다시 넣는다.

bNetTemporary는 지원되지 않는다#

• 현상: UReplicationGraph::AddNetworkActor는 bNetTemporary 액터에 대해 ensure를 내고(5.4 릴리스 노트의 “Ensure when an actor is replicated with bNetTemporary set”), 그 뒤에는 2019년 포럼의 관찰대로 bNetTemporary를 무시하고 수백 번 리플리케이션한다.
• 원인: bNetTemporary 액터의 첫 번치는 bClose가 켜져 있어 채널을 열면서 닫는다. 기본 드라이버는 SentTemporaries로 그 액터를 다시 고려하지 않는다(Engine/Private/DataChannel.cpp, NetDriver.cpp). 리플리케이션 그래프는 이 목록을 보지 않으므로 닫힌 채널이 정리되면 다음 버킷 차례에 채널을 새로 열어 다시 보낸다.
• 대처: 발사체는 bNetTemporary 대신 짧은 수명의 dynamic 액터로 두고 Cell 재구축 금지 목록에 넣는다.

1
Ensure condition failed: !Actor->bNetTemporary [File: ReplicationGraph.cpp] [Line: 790]
2
ReplicationGraph does not support bNetTemporary. Actor: RepGraphLabProjectile_0 has bNetTemporary set.

연결이 끊겨도 남는 dormancy 사본#

• 현상: 연결이 끊겨도 Cell의 dormancy 노드에는 그 연결의 사본이 남아 있다. 테스트 프로젝트에서는 재접속 8번에 사본이 3개에서 17개로 늘었고 정리를 켜면 6개까지 줄되 톱니 모양으로 오르내렸다.
• 원인: 기본값 Net.RepGraph.DormancyNodeObsoleteBehavior 0은 사본을 지우지 않는다. Epic 지원 포럼의 답변은 그 이유로 멀리 간 클라이언트의 add/remove 반복이 만드는 프레임 스파이크를 든다. 정리를 켜도 즉시는 아니다. 떼어내는 코드는 CallFunctionOnValidConnectionNodes 안에만 있어 그 Cell의 dormancy 노드에 액터가 추가·제거되거나 flush될 때만 돌고 gather 때는 돌지 않는다.
• 대처: DormancyNodeObsoleteBehavior를 1로 두면 연결 객체가 사라진 사본을 지운다. SetNumFramesUntilObsolete를 양수로 두면 살아 있지만 오래 gather되지 않은 연결의 사본까지 지운다. 접속·해제가 잦은 서버라면 두 설정을 같이 켜고 Cell마다 dormant 액터가 많다면 사본의 메모리까지 같이 본다.

멀어진 뒤 파괴된 dormant 액터가 클라이언트에 남는다#

• 현상: 클라이언트가 한 번 받은 액터(바닥 아이템)가 잠든 상태에서 그 클라이언트가 멀리 간 뒤 서버가 액터를 파괴하면 클라이언트에는 그 액터가 그대로 남는다. 테스트 프로젝트에서 플레이어를 500 m 밖으로 옮기고 원래 자리의 잠든 루트 100개를 파괴하자 리플리케이션 그래프에서는 클라이언트의 루트가 500개 그대로였고 기본 드라이버에서는 400개가 됐다. Basic 그래프도 남는다.
• 원인: 채널이 닫힐 때 relevancy 사유면 클라이언트가 액터를 지우지만 dormancy 사유면 남겨 둔다(UActorChannel::CleanUp). 그래서 잠든 액터는 채널 없이 클라이언트에 남아 있다. 그 액터가 파괴되면 기본 드라이버는 거리와 무관하게 파괴 정보를 보낸다(NotifyActorDestroyed의 DormantConnections 검사). 리플리케이션 그래프는 DestructInfoMaxDistanceSquared(기본 150 m, Lyra와 OpenWorld 그래프는 300 m, 높이를 뺀 2D 거리) 안의 viewer에게만 보낸다. 범위 밖이면 OutOfRangeDestroyedActors에 두었다가 viewer가 충분히 움직인 뒤 다시 검사해 범위 안이면 보낸다.
• 대처: 돌아오면 지워진다. 플레이어를 되돌리자 100개가 사라졌다. 멀리서도 지워져야 하는 액터는 DestructInfoMaxDistanceSquared를 늘리거나(OpenWorld 그래프의 OpenWorld.RepGraph.DestructInfo.MaxDist를 1 km로 두자 바로 사라졌다) 액터마다 SetActorDestructionInfoToIgnoreDistanceCulling을 건다. dynamic 액터가 잠든 채 Cell을 벗어나면 그 정리는 다른 경로(Net.RepGraph.DormantDynamicActorsDestruction, 기본 0)를 타므로 따로 켜야 한다.