Looking for example how to do a long running job

Unity Engine
,
1

I found this:

and think I was somewhat able to follow it, but I get various errors trying to make it work such as: InvalidOperationException: The previously scheduled job TestAsync2System:<>c__DisplayClass_schedule_LambdaJob0 reads from the NativeArray <>c__DisplayClass_schedule_LambdaJob0.safety. You must call JobHandle.Complete() on the job TestAsync2System:<>c__DisplayClass_schedule_LambdaJob0, before you can deallocate the NativeArray safely.
and warnings like: Internal: JobTempAlloc has allocations that are more than 4 frames old - this is not allowed and likely a leak

Am I doing something wrong? I tried it without the logs and timing and saw same errors, so those aren’t causing it. It does seem to be running as expected, but all the warnings and errors are concerning.

using Unity.Entities;
using Unity.Jobs;

public class TestAsync2System : JobComponentSystem {
    int count = 0;
    JobHandle jobHandle;

    protected override void OnCreate() {
        RequireSingletonForUpdate<AsyncTag>();
    }

    protected override JobHandle OnUpdate(JobHandle inputDependencies) {
        UnityEngine.Debug.Log("OnUpdate");
        if (count == 0) {
            schedule(inputDependencies);
            UnityEngine.Debug.Log("inc count: "+count);
            count++;
        } else {
            if (jobHandle.IsCompleted) {
                UnityEngine.Debug.Log("completed: "+count);
                jobHandle.Complete();
                count = 0;
            }
        }
        return inputDependencies;
    }

    private void schedule(JobHandle inputDependencies) {
        jobHandle = Entities.WithAll<AsyncTag>().WithoutBurst().ForEach((Entity e) => {
            System.Diagnostics.Stopwatch s = System.Diagnostics.Stopwatch.StartNew();
            UnityEngine.Debug.Log("starting: " + s.ElapsedMilliseconds);
            System.Threading.Thread.Sleep(1000);
            UnityEngine.Debug.Log("finished: " + s.ElapsedMilliseconds);
        }).Schedule(inputDependencies);
    }
}
2

I think I have this figured out. The JobTempAlloc warnings were either caused by some other system I had in the project, or when you use a NativeArray for a long running job, you cannot use the TempJob allocator, but Persistent works.

And the error is probably that Entities.ForEach isn’t made for this use case because it takes care of things for you that you don’t want. Changing the “schedule” method in the above example to this works:

    private void schedule(JobHandle inputDependencies) {
            jobHandle = Job.WithoutBurst().WithCode(() => {
                    System.Threading.Thread.Sleep(1000);
        }).Schedule(inputDependencies);
    }

The "WithoutBurst is only required because of the thread.sleep. Changing it to a spin wait works with burst except you get an error:
(0,0): Burst error BC1049: Zero-size empty struct `TestAsync2System/<>c__DisplayClass_schedule_LambdaJob0` is not supported. To fix this issue, apply this attribute to the struct: `[StructLayout(LayoutKind.Sequential, Size = 1)]`.

unless you create a NativeArray in it:

    private void schedule(JobHandle inputDependencies) {
        NativeArray<bool> result = new NativeArray<bool>(1, Allocator.Persistent);
        result[0] = false;
                jobHandle = Job.WithDeallocateOnJobCompletion(result).WithCode(() => {
                    for (long i = 0; i < 100000000; i++) {
                }
            result[0] = true;
        }).Schedule(inputDependencies);
    }