Jobs with struct with methods

Unity Engine
,
1

I have modified the example found in the Job API page

public struct testStruct
{
    public void doSomething(NativeArray<Vector3> velocity, NativeArray<Vector3> position, float deltaTime)
    {
        // Move the positions based on delta time and velocity
        for (var i = 0; i < position.Length; i++)
            position[i] = position[i] + velocity[i] * deltaTime;
    }

}
class ApplyVelocitySample : MonoBehaviour
{
    struct VelocityJob : IJob
    {
        // Jobs declare all data that will be accessed in the job
        // By declaring it as read only, multiple jobs are allowed to access the data in parallel
        [ReadOnly]
        public NativeArray<Vector3> velocity;

        // By default containers are assumed to be read & write
        public NativeArray<Vector3> position;

        // Delta time must be copied to the job since jobs generally don't have concept of a frame.
        // The main thread waits for the job on the same frame or the next frame, but the job should
        // perform work in a deterministic and independent way when running on worker threads.
        public float deltaTime;
        public testStruct bob;
        // The code actually running on the job
        public void Execute()
        {
            bob.doSomething(velocity, position, deltaTime);
        }
    }

    private testStruct fred;
    public void Start()
    {
        fred = new testStruct();
    }
    public void Update()
    {
        var position = new NativeArray<Vector3>(500, Allocator.Persistent);

        var velocity = new NativeArray<Vector3>(500, Allocator.Persistent);
        for (var i = 0; i < velocity.Length; i++)
            velocity[i] = new Vector3(0, 10, 0);

       
        // Initialize the job data
        var job = new VelocityJob()
        {
            deltaTime = Time.deltaTime,
            position = position,
            velocity = velocity,
            bob = fred
        };
        //job.bob = fred;
        // Schedule the job, returns the JobHandle which can be waited upon later on
        JobHandle jobHandle = job.Schedule();

        // Ensure the job has completed
        // It is not recommended to Complete a job immediately,
        // since that gives you no actual parallelism.
        // You optimally want to schedule a job early in a frame and then wait for it later in the frame.
        jobHandle.Complete();

        Debug.Log(job.position[0]);

        // Native arrays must be disposed manually
        position.Dispose();
        velocity.Dispose();

    }
}

Essentially I moved the logic from the VelocityJob.Execute to a method within a struct in VelocityJob.

The reason is ultimately want pass in unique AI planners to each job, so they can solve plans on each thread.

My question being, is this OK to do? It compiles and gives the same result. But is it still leveraging the compactness linear arrangement for high performance access?

2

It should be good, but also you should wait for ECS and do it with it.