📝 Lesson 5.1: Unity Performance and Memory

The GC and Frame Spikes

C# is a managed language: you allocate objects and the garbage collector (GC) frees them later. On a server that's fine. In a game rendering a frame every ~16ms, it's a trap — when the GC runs to reclaim memory, it can pause your game for several milliseconds, causing a visible stutter.

Allocations in Update

Update, FixedUpdate, and LateUpdate are the hot paths — they run constantly. An allocation that's harmless once becomes garbage-per-frame here. The usual culprits:

// ❌ Allocates every frame: a GetComponent lookup + a new string.
void Update()
{
    GetComponent<Renderer>().material.color = Color.red;   // lookup each frame
    label.text = "Time: " + Time.time;                     // new string each frame
}

// ✅ Cache the reference; only touch the string when it needs to change.
private Renderer cachedRenderer;

void Awake() => cachedRenderer = GetComponent<Renderer>();

void Start() => cachedRenderer.material.color = Color.red;   // set once, not per frame

💡 The mindset shift: in a hot path, ask of every line "does this allocate, and does it need to run this frame?" Move one-time work to Awake/Start; move change-driven work behind events; keep only the truly per-frame math in Update.

Cache Everything Reusable

Caching is the theme that has run through the whole course — now here's the complete rationale. Anything you look up or build repeatedly should be computed once and stored.

public class Enemy : MonoBehaviour
{
    // Cached component references (Lesson 1.3) — looked up once.
    private Rigidbody body;
    private Transform playerTarget;

    // Cached reusable objects (Lesson 3.3) — allocated once, reused forever.
    private readonly WaitForSeconds attackCooldown = new(1.5f);

    void Awake()
    {
        body = GetComponent<Rigidbody>();
        // Cache the player reference instead of finding it every frame.
        playerTarget = GameObject.FindWithTag("Player").transform;
    }

    void FixedUpdate()
    {
        // Use the cached refs — no lookups, no allocations here.
        Vector3 toPlayer = playerTarget.position - transform.position;
        body.AddForce(toPlayer.normalized * 5f);
    }
}

Object Pooling

Lesson 2.3 flagged this: constantly Instantiate-ing and Destroy-ing objects (bullets, enemies, effects) allocates and creates garbage. Object pooling fixes it — reuse a fixed set of objects instead of creating and destroying them.

Unity ships a ready-made pool: ObjectPool<T> in UnityEngine.Pool. You give it callbacks for create / get / release / destroy, and it manages the rest:

using UnityEngine;
using UnityEngine.Pool;

public class BulletSpawner : MonoBehaviour
{
    [SerializeField] private Bullet bulletPrefab;
    private ObjectPool<Bullet> pool;

    void Awake()
    {
        pool = new ObjectPool<Bullet>(
            createFunc: () => Instantiate(bulletPrefab),        // make one when the pool is empty
            actionOnGet: b => b.gameObject.SetActive(true),    // taken from pool
            actionOnRelease: b => b.gameObject.SetActive(false), // returned to pool
            actionOnDestroy: b => Destroy(b.gameObject),        // pool trimmed
            defaultCapacity: 20);
    }

    public Bullet Fire(Vector3 position, Quaternion rotation)
    {
        Bullet bullet = pool.Get();          // reuse instead of Instantiate
        bullet.transform.SetPositionAndRotation(position, rotation);
        return bullet;
    }

    // The bullet calls this instead of Destroy(gameObject):
    public void Return(Bullet bullet) => pool.Release(bullet);
}

Hidden Costs

Beyond allocations, a few Unity-specific calls are pricier than they look. In hot paths, watch for:

Measure First: the Profiler

The most important rule comes last, because it governs all the rest: profile before you optimize. Guessing at bottlenecks wastes time and adds complexity where it isn't needed. Unity's Profiler (Window → Analysis → Profiler) shows exactly where each frame's time and memory go.

What to look at:

• CPU Usage — which methods eat the frame; look for spikes.
• GC Alloc column — bytes allocated per frame. Your target is 0 B in steady-state gameplay. Any per-frame number here is garbage you can hunt down.
• The spikes — regular tall bars often mean a GC collection; trace them to the allocations feeding it.

Exercise & Quiz

using UnityEngine;
using TMPro;

public class BadPerf : MonoBehaviour
{
    [SerializeField] private TMP_Text label;
    [SerializeField] private Bullet bulletPrefab;

    void Update()
    {
        // 1) Camera.main every frame (hidden Find)
        Vector3 screen = Camera.main.WorldToScreenPoint(transform.position);

        // 2) GetComponent every frame
        GetComponent<Renderer>().enabled = true;

        // 3) string allocation every frame
        label.text = "Pos: " + transform.position;

        // 4) tag compare allocates
        if (gameObject.tag == "Player") { /* ... */ }

        // 5) Instantiate + Destroy churn
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Bullet b = Instantiate(bulletPrefab);
            Destroy(b.gameObject, 2f);
        }
    }
}

using UnityEngine;
using UnityEngine.Pool;
using TMPro;

public class GoodPerf : MonoBehaviour
{
    [SerializeField] private TMP_Text label;
    [SerializeField] private Bullet bulletPrefab;

    private Camera cam;
    private Renderer rend;
    private Vector3 lastPos;
    private ObjectPool<Bullet> pool;

    void Awake()
    {
        cam = Camera.main;                      // cached once
        rend = GetComponent<Renderer>();         // cached once
        rend.enabled = true;                    // set once, not per frame

        pool = new ObjectPool<Bullet>(
            () => Instantiate(bulletPrefab),
            b => b.gameObject.SetActive(true),
            b => b.gameObject.SetActive(false),
            b => Destroy(b.gameObject),
            defaultCapacity: 20);
    }

    void Update()
    {
        // Only rebuild the string when the position actually changed.
        if (transform.position != lastPos)
        {
            label.text = $"Pos: {transform.position}";
            lastPos = transform.position;
        }

        if (CompareTag("Player")) { /* ... */ }   // no string alloc

        if (Input.GetKeyDown(KeyCode.Space))
        {
            Bullet b = pool.Get();                // reused, no GC
            b.transform.position = transform.position;
        }
    }

    public void ReturnBullet(Bullet b) => pool.Release(b);
}

Summary

📚 Additional Resources

• Manual — Understanding the garbage collector
• Scripting Reference — ObjectPool<T>
• Manual — The Profiler window
• Unity — Optimize your game code (best practices)

🚀 What's Next?

Fast code still has to be correct. Lesson 5.2, Debugging and the Unity Test Framework, covers finding and fixing bugs — Debug tools, breakpoints, Gizmos — and writing automated tests with the Unity Test Framework so your systems stay reliable as the project grows.