Network Profiler - 1 Byte Variables

[TheMainStark]

I’m trying to confirm if this is a bug. When I used the Network Profiler to track how many bytes are sent for a DataTable and Actor variables they are showing up as 1 Byte. Regardless if it is a replicated variable or sent via an RPC.

This seems low or not realistic when compared to an int (4 bytes) and a vector (12 bytes). Also the outgoing bandwidth spikes with the DataTable but does not with the integer and vector?

Can anyone confirm if this is correct and not a bug in Network Profiler? If it is correct, what makes it so low in size?

In a blank level, default game mode override. On the level blueprint I run this to test. In PIE with dedicated server on.

.
DataTable:

.
Int:
.

Vector:

[TheMainStark]

It could be that the graph is showing the real value while the property byte size is not showing the correct value? Or is property byte value not the same as “bandwidth used to replicate this variable?”

[GrumbleBunny]

It’s a stably named reference so it could be doing something clever under the hood and just be replicating and index into an FName table or something.

[TheMainStark]

Could be - that does sound right. But now the question is why the Outgoing Bandwidth jumping in the graph with the DataTable compared to the others that are 4 bytes (integer) and 12 bytes (vector).

[GrumbleBunny]

Just a complete guess but since the variable is a Data Table type, potentially if you have less than 255 data tables in your project it can reference one with a single byte?

[TheMainStark]

In this screenshot, the actor variable is 1 byte but the outgoing bandwidth spikes to 7000 bytes for the one variable.

So I’m assuming it’s just the overhead of replicating these variable types that add to the bandwidth?

Any explanation on how the property byte size might relate to the bandwidth output would be helpful.

[TheMainStark]

Anyone able to answer this perhaps? To re-iterate the question:

I did Network profile tests with RPC’s (Custom Event, Run on Server).

A RPC with a DataTable variable shows as 1 byte, but the bandwidth spikes to 15,000 bytes.

A RPC with an Int variable shows as 4 bytes with no noticeable bandwidth spike.

A RPC with a Vector variable shows as 12 bytes with no noticeable bandwidth spike.

A RPC with an Actor variable shows as 1 byte with a bandwidth spike to 6,100 bytes.

I understand there is some stably named references in some cases but I am hyper-optimizing network traffic and I am curious what is occuring with the bandwidth.

[ugmoe]

if i remember correctly, you can zoom in on the graph and find out exactly what’s causing the spike. I forget how to do it though.

Also, you can use those tabs at the top to get more information.

It’s not really showing what causes the spike, it might be something else entirely (GameStateBase for example). Or it could be the fact that the graph is showing frequency, not bytes/second, so it looks crazier than it is.

[TheMainStark]

These are hyper focused tests, only recording for a few seconds with the RPC executed in-between. In an environment with nothing else replicating outside the pawn itself and in an empty world.

I ran each test several times and had the same results. I haven’t tried it on Unreal 5 however but I don’t think much has changed on this front (could be wrong).

I’m just looking to further understand the WHY versus trying to fix it, while expanding on replication knowledge.

[ugmoe]

i mean, the last screenshot you posted shows that GameStateBase sent 256 Bytes and TestLevel sent 1 Byte

[TheMainStark]

Correct, with a total of 257 bytes between the entire scene. Yet a spike of 6100 bytes in bandwidth everytime the RPC is run with an Actor variable.

Similarly a spike of 15,000 bytes for the RPC with an DataTable despite only 125 bytes through the scene.

Int and Vector tests had more bytes but less bandwidth.

I’m trying to understand the why on that

I’ll re-run a few test on Unreal 5 for the sake of updating it to make sure it is fully relevant

[ugmoe]

Personally, i would just look at the total bytes sent and ignore how the graph looks, but i’m not an expert so i could be completely wrong.

You might need to try the unrealslackers discord, maybe you could find some advice there, maybe link them to this thread

Unreal Slackers

[TheMainStark]

Update: The weird bandwidth stuff seems to be a factor of the PIE in-editor testing/profiling (big surprise) or something was fixed by 5.1. DataTables have slightly elevated bandwidth but not much.

My new test, specific RPC testing:

1 - Blank Project (UE 5.1), Blank Level (the level consisted of a Cube, Directional Light and Player Start).

2 - Created a new GameMode with accompanying assets: Character, HUD, Controller, GameState, PlayerState, Spectator left to default. Set as the GameMode Override.

2a - To isolate only RPCs, character has Replicate Movement off, Replicated off and Net Load on Client off.

3 - Packaged project for Dedicated Server and Client.

4 - LAN environment; Dedicated Server and Client on separate PCs.

5 - The test code below setup with a keybind to remotely start the test. This was repeated for Actor variables, Bools, DataTables, Vector and Integers.

6 - Code will repeat the RPC 5 times before turning off, to check for consistency.

Bool Results:

DataTable Results:

Integer Results:

Other random findings:

Some form of caching occurs. I randomized DataTable values to send to the client through an RPC. For example (set of 5):

RPC1: DataTable7
RPC2: DataTable5
RPC3: DataTable6
RPC4: DataTable7
RPC5: DataTable2

The first time an RPC sends a DataTable it will have a bandwidth spike. The second time (RPC4) will not require additional bandwidth.

Sample:

In addition, I tried a dramatically larger DataTable in non-simplified project and it did increase the bandwidth but the RPC bytes remained the same.

[TheMainStark]

Vector Results:

Actor Results:

Similar to the DataTable test above, I used a dramatically bigger Actor variable from a different project and it had elevated bandwidth (but not by much).