Coder Legion - Recent posts tagged nativearray

Your Game’s GC Spikes? Blame Yourself.

Wed, 15 Jul 2026 21:27:03 +0000

Mastering Allocation-Free Data Processing with Span and Memory in Unity

Introduction

Tired of unpredictable stuttering and frustrating garbage collection (GC) spikes in your high-performance Unity game? Those erratic frame drops often stem from subtle, repeated memory allocations, even within performance-critical systems. While Unity’s Job System and Burst Compiler aim for allocation-free execution, common C# patterns can inadvertently introduce GC pressure. This tutorial will guide you through mastering Span<T> and Memory<T>, two powerful C# features indispensable for achieving truly allocation-free, Burst-compatible code, particularly when working with NativeArray<T> and unmanaged memory within Unity’s Data-Oriented Technology Stack (DOTS).

Code Layout/Walkthrough: Eliminating GC Spikes with Zero-Allocation Views

A frequent culprit for GC spikes is the unnecessary creation of temporary arrays or sub-arrays. Functions that need to process a segment of a larger data block often resort to methods like Array.Copy or LINQ extensions like Skip().Take().ToArray(). While convenient, each of these operations allocates new memory on the heap. In a tight game loop or within high-frequency jobs, repeated allocations quickly accumulate, triggering the garbage collector and causing noticeable frame rate instability.

Enter Span<T> and Memory<T>. These types provide a modern, allocation-free way to reference existing contiguous blocks of memory, whether managed (like byte[]) or unmanaged (like NativeArray<T> elements). They allow you to define a “view” or “slice” into a larger data structure without copying any data. Span<T> is a ref struct, meaning it can only live on the stack and cannot be boxed or used in async methods, offering extreme performance for synchronous operations. Memory<T> is a managed struct that wraps a Span<T>, allowing it to be used in scenarios where Span<T>’s stack-only limitations are prohibitive (e.g., heap allocation, asynchronous operations, or when storing a reference).

For Unity developers utilizing the Job System, NativeArray<T> is fundamental. Slicing a NativeArray<T> conventionally by creating a new NativeArray<T> would involve allocations and potential safety overhead. With Span<T>, you can create a direct, zero-allocation view:

using Unity.Collections;
using Unity.Jobs;
using System; // For Span<T>

// Define a job that processes data
public struct MyDataProcessorJob : IJob
{
    [ReadOnly] public NativeArray<int> InputData;
    public NativeArray<int> OutputData;

    public void Execute()
    {
        // 1. Create a Span<int> for a specific segment of InputData.
        //    InputData.Slice() returns a NativeArray<int>, which has an implicit
        //    conversion to Span<int>. Crucially, no new int[] or NativeArray<int>
        //    is allocated for this view.
        Span<int> inputSegment = InputData.Slice(10, 20); // View elements from index 10, length 20

        // 2. Create a Span<int> for a corresponding segment of OutputData.
        Span<int> outputSegment = OutputData.Slice(0, 20);

        // 3. Process the segments using an allocation-free pure function.
        //    Passing Span<int> by 'ref' avoids copying the Span struct itself.
        ProcessDataSlice(ref inputSegment, ref outputSegment);
    }

    /// <summary>
    /// An example pure function that operates directly on memory segments
    /// without any allocations. Ideal for Burst-compiled contexts.
    /// </summary>
    /// <param name="input">A read-only view of the input data segment.</param>
    /// <param name="output">A writable view of the output data segment.</param>
    private static void ProcessDataSlice(ref Span<int> input, ref Span<int> output)
    {
        // Ensure segments are of compatible length, or handle mismatch
        int length = Math.Min(input.Length, output.Length);

        for (int i = 0; i < length; i++)
        {
            output[i] = input[i] * 2 + 5; // Example complex processing
        }
    }
}

In this example, inputSegment and outputSegment are not copies of the underlying data. They are simply lightweight, stack-allocated references pointing to specific parts of the existing InputData and OutputData memory blocks. The ProcessDataSlice function is a “pure” function in this context – it operates directly on these provided memory views without allocating anything itself. Passing Span<int> by ref further optimizes performance by preventing the Span struct from being copied on the stack during the function call. This pattern aligns perfectly with Burst’s optimization goals, leading to highly predictable and incredibly fast code execution within your jobs.

Conclusion

Embracing Span<T> and Memory<T> is more than just a “nice-to-have” optimization; it’s a fundamental shift towards writing truly high-performance, allocation-free C# code in Unity. By referencing rather than copying memory segments, especially within your Job System architecture, you effectively eliminate a major source of garbage collection pressure. This directly translates to stable frame times, significantly reduced stuttering, and a consistently smoother player experience. Stop chasing ghost allocations and start leveraging these modern C# features to unlock your game’s full, predictable performance potential.

Is Your Unity Game Still Choking on a Single Thread?

Thu, 18 Jun 2026 19:45:36 +0000

Is Your Unity Game Choking? Unlock Multithreaded Power with the Job System and Burst Compiler

Introduction

In the rapidly evolving landscape of game development, the performance ceiling of single-threaded execution has become a major bottleneck. If your Unity game grapples with stuttering frame rates, slow AI, laggy physics, or sluggish procedural generation, chances are your heaviest computations are trapped on the main thread. While fundamental optimizations like caching GetComponent are important, they’re merely the first step. To truly unlock modern hardware’s potential and create ambitious, dynamic worlds, you need to graduate to Unity’s Job System and Burst Compiler.

This isn’t about incremental gains; it’s about a paradigm shift. We’re talking about moving expensive calculations from sequential, slow Update() loops to parallel threads, leveraging low-level SIMD (Single Instruction, Multiple Data) optimizations automatically provided by Burst. It’s 2026, and clinging to single-threaded logic for performance-critical tasks is no longer an option – it’s an unforgivable sin against your game’s potential.

Code Layout and Walkthrough: Embracing Parallelism

The core principle of the Job System is to define small, atomic units of work that can be executed independently across multiple threads. This is achieved through the IJob or IJobParallelFor interfaces, combined with NativeArray for safe, high-performance data transfer.

Let’s illustrate with a common scenario: updating the positions of thousands of entities. Instead of iterating in a MonoBehaviour’s Update() loop, we offload this to a job:

1. Define Your Job Struct: First, create a struct that implements IJobParallelFor. This interface is ideal for tasks that involve processing a collection of data in parallel. Crucially, mark your struct with [BurstCompile] to enable the Burst Compiler’s magic.

using Unity.Jobs;
using Unity.Collections;
using Unity.Burst;
using UnityEngine; // For Vector3

[BurstCompile]
public struct MoveEntitiesJob : IJobParallelFor
{
    // Input and output data must be NativeArray types for thread safety
    [ReadOnly] public NativeArray<Vector3> InputPositions;
    public NativeArray<Vector3> OutputPositions;
    public float DeltaTime;
    public float Speed;

    // The Execute method runs for each index in the scheduled range
    public void Execute(int index)
    {
        Vector3 currentPos = InputPositions[index];
        // Example: Move entities forward along Z-axis
        currentPos.z += Speed * DeltaTime; 
        OutputPositions[index] = currentPos;
    }
}

[BurstCompile]: This attribute tells Unity to compile this job using the Burst Compiler. Burst automatically transforms your C# code into highly optimized machine code, often leveraging SIMD instructions to process multiple data points simultaneously.
NativeArray<T>: These are unmanaged arrays that live outside of the C# garbage collector. They are crucial for thread-safe data access and communication between jobs and the main thread. [ReadOnly] ensures the job can’t accidentally modify input data, enhancing safety and optimization.
Execute(int index): This is the core logic. For an IJobParallelFor job, this method is called for each index in the collection you’re processing. The Job System automatically distributes these calls across available threads.

2. Schedule and Complete Your Job: From a MonoBehaviour or a manager script, you’ll prepare your NativeArray data, create an instance of your job, schedule it, and then wait for its completion.

using UnityEngine;
using Unity.Jobs;
using Unity.Collections;

public class EntityMover : MonoBehaviour
{
    public int EntityCount = 10000;
    public float MovementSpeed = 5f;

    private NativeArray<Vector3> _entityPositions; // Stores current positions
    private NativeArray<Vector3> _newPositions;   // Stores results from the job
    private JobHandle _jobHandle;
    private bool _jobScheduled = false;

    void Start()
    {
        // Initialize NativeArrays. Always remember to dispose them!
        _entityPositions = new NativeArray<Vector3>(EntityCount, Allocator.Persistent);
        _newPositions = new NativeArray<Vector3>(EntityCount, Allocator.Persistent);

        // Populate initial positions (example)
        for (int i = 0; i < EntityCount; i++)
        {
            _entityPositions[i] = new Vector3(Random.Range(-50f, 50f), 0, Random.Range(-50f, 50f));
        }
    }

    void Update()
    {
        if (!_jobScheduled)
        {
            // Create and configure the job
            var job = new MoveEntitiesJob
            {
                InputPositions = _entityPositions,
                OutputPositions = _newPositions,
                DeltaTime = Time.deltaTime,
                Speed = MovementSpeed
            };

            // Schedule the job. The second parameter (64) is the innerloopBatchCount.
            // It suggests how many iterations Burst should process in a single batch.
            _jobHandle = job.Schedule(EntityCount, 64);
            _jobScheduled = true;
        }
        else if (_jobHandle.IsCompleted)
        {
            // Wait for the job to complete and retrieve results
            _jobHandle.Complete(); 

            // Copy the results back to the original array for next frame's input
            _newPositions.CopyTo(_entityPositions);

            // Now _entityPositions contains the updated data, which can be
            // used to update actual GameObjects, renderers, etc.

            _jobScheduled = false; // Ready to schedule again next frame
        }
    }

    void OnDestroy()
    {
        // Always dispose NativeArrays when no longer needed to prevent memory leaks!
        if (_entityPositions.IsCreated) _entityPositions.Dispose();
        if (_newPositions.IsCreated) _newPositions.Dispose();
    }
}

Allocator.Persistent: Specifies how the NativeArray memory is managed. Persistent means it lives until manually disposed. Other options like Temp or TempJob are for shorter-lived allocations.
job.Schedule(EntityCount, 64): This enqueues the job to be run. EntityCount is the total number of iterations. 64 is the innerloopBatchCount, which helps the Job System and Burst optimize task distribution.
_jobHandle.Complete(): This is a synchronization point. It forces the main thread to wait until the job finishes. For optimal performance, schedule jobs as early as possible and call Complete() as late as possible, allowing the main thread to perform other tasks concurrently.

Conclusion

Embracing Unity’s Job System and Burst Compiler means moving beyond basic optimizations and tapping into the full potential of modern multi-core processors. You’re not just making your existing game faster; you’re enabling entirely new possibilities: hundreds of dynamic NPCs, massive physics simulations, incredibly reactive worlds, and complex procedural elements, all without sacrificing framerate. Stop being intimidated by the shift from traditional MonoBehaviour patterns. Dive into NativeArrays and IJobParallelFor – your game, and your players, will thank you for liberating its potential. The future of high-performance Unity development is parallel; it’s time to join it.