Structs are great for controlling memory layout and avoiding the GC, but we can go a lot further to get even more speed out of them. Today we’ll look at a simple tweak that can dramatically speed up the code using the structs without even changing it!

Let’s start by designing a struct for a player in a game. First, we’ll use the object-oriented approach and put everything about the player in one big struct:

```struct PlayerExtras
{
public Vector3 Position;      // 3 * 4 = 12
public Vector3 Velocity;      // 3 * 4 = 12
public int Health;            //          4
public int MaxHealth;         //          4
public int NumLives;          //          4
public int Score;             //          4
public int TeamId;            //          4
public int LeftHandWeaponId;  //          4
public int RightHandWeaponId; //          4
public int NumWins;           //          4
public int NumLosses;         //          4
public int MatchmakingRank;   //          4
// Total:  64
}```

The comments to the right of the fields indicate how many bytes each field takes up. This is `4` for all the `int` fields but `12` for `Vector3` because it’s internally made up of `3` `float` fields which each take up `4` bytes.

Now let’s split off just the first four fields into their own struct. We’ll call this just the “basics” and define it like this:

```struct PlayerBasics
{
public Vector3 Position; // 3 * 4 = 12
public Vector3 Velocity; // 3 * 4 = 12
public int Health;       //          4
public int MaxHealth;    //          4
// Total:  32
}```

Now let’s consider some code that updates the position of the players in the game according to their velocity and some elapsed time: `player.Position += player.Velocity * time`. This is what we might do if the players were space ships, for example. We’ll simply loop over some arrays of them and performing this calculation and measuring the time with `Stopwatch`.

```using System.Diagnostics;
using UnityEngine;
using Unity.IL2CPP.CompilerServices;

struct PlayerBasics
{
public Vector3 Position; // 3 * 4 = 12
public Vector3 Velocity; // 3 * 4 = 12
public int Health;       //          4
public int MaxHealth;    //          4
// Total:  32
}

struct PlayerExtras
{
public Vector3 Position;      // 3 * 4 = 12
public Vector3 Velocity;      // 3 * 4 = 12
public int Health;            //          4
public int MaxHealth;         //          4
public int NumLives;          //          4
public int Score;             //          4
public int TeamId;            //          4
public int LeftHandWeaponId;  //          4
public int RightHandWeaponId; //          4
public int NumWins;           //          4
public int NumLosses;         //          4
public int MatchmakingRank;   //          4
// Total:  64
}

class TestScript : MonoBehaviour
{
[Il2CppSetOption(Option.NullChecks, false)]
[Il2CppSetOption(Option.ArrayBoundsChecks, false)]
void Start()
{
const int count = 10000000;
PlayerBasics[] basics = new PlayerBasics[count];
PlayerExtras[] extras = new PlayerExtras[count];
float time = Random.Range(0, 1);

Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < count; ++i)
{
ref PlayerBasics player = ref basics[i];
player.Position += player.Velocity * time;
}
long basicsTime = sw.ElapsedMilliseconds;

sw.Reset();
sw.Start();
for (int i = 0; i < count; ++i)
{
ref PlayerExtras player = ref extras[i];
player.Position += player.Velocity * time;
}
long extrasTime = sw.ElapsedMilliseconds;

print(
"Type,Timen" +
"Basics," + basicsTime + "n" +
"Extras," + extrasTime);
}
}```

Now letâ€™s run this code to see how each loop performed. I ran using this environment:

• 2.7 Ghz Intel Core i7-6820HQ
• macOS 10.14.3
• Unity 2018.3.1f1
• macOS Standalone
• .NET 4.x scripting runtime version and API compatibility level
• IL2CPP
• Non-development
• 640Ã—480, Fastest, Windowed

Here are the results I got:

Type Time
Basics 41
Extras 63

The “extras” version of the player struct makes the loop take 47% more CPU time! It’s the exact same code running on the exact same number of structs, so why is it so slow?

The answer lies in the size of the structs being iterated over. In order to perform the calculation, the code needs to read the `Position` and `Velocity` fields from memory. When it reads `Position`, the CPU doesn’t read just the `x`, `y`, and `z` floats but an entire “cache line” of 64 bytes. In the case of `PlayerExtras`, this means the CPU reads all the other fields of the struct that will never be used.

To illustrate, let’s assume the first `PlayerExtras` element of the `extras` array is in memory at address `100`. Here’s how that memory would look:

100 0 Position.x
104 0 Position.y
108 0 Position.z
112 0 Velocity.x
116 0 Velocity.y
120 0 Velocity.z
124 0 Health
128 0 MaxHealth
132 0 NumLives
136 0 Score
140 0 TeamId
148 0 LeftHandWeaponId
152 0 RightHandWeaponId
156 0 NumWins
160 0 NumLosses
164 0 MatchmakingRank

This one struct takes up the entire cache line, so reading the next element of the array means it isn’t in cache and a new cache line needs to be fetched from RAM.

Now let’s look at `PlayerBasics`. Since it’s half the size, we see that two of them are fetched when the first one’s `Position` is read:

100 0 Position.x
104 0 Position.y
108 0 Position.z
112 0 Velocity.x
116 0 Velocity.y
120 0 Velocity.z
124 0 Health
128 0 MaxHealth
132 1 Position.x
136 1 Position.y
140 1 Position.z
148 1 Velocity.x
152 1 Velocity.y
156 1 Velocity.z
160 1 Health
164 1 MaxHealth

This means that the second element of the array can use the struct that’s already in cache rather than reaching out to RAM to fetch it.

As this page neatly shows, using the CPU cache for half of the elements of the array means we’re only waiting 1-4 nanoseconds for that memory instead of 100 nanoseconds to fetch it from RAM. That 25-100x speedup gives us a huge speed boost that makes using the “basics” version of the struct so much faster.

In general, try to keep the size of structs small if they need to be efficiently iterated over. This will improve the performance of the code even without changing it just by making more efficient use of the CPU cache.