Unity WaitForSeconds without generating garbage

Question

In Unity you can use:

    IEnumerator WaiterRoutine() 
    {
        yield return new WaitForSeconds(<seconds as float>);
    }

To wait a number of seconds. But this generates garbage for the garbage collector. I have a routine that waits for a random number of seconds every time it runs. So it just continually creates garbage.

My question is: is there any reason not to wait like this instead:

    public static IEnumerator WaitForSeconds(float seconds)
    {
        float start = Time.time;
        while (Time.time < start + seconds)
        {
            yield return null;
        }
    }

and if not, then why the heck is this not part of Unity's libraries? Is new WaitForSeconds somehow optimized further? Like does it remove my routine from consideration rather than busy waiting?

Just trying to figure out an efficient way to handle waiting.

Here's the actual code in question:

    void OnEnable() => routine = StartCoroutine(SpiritCannon());
    void OnDisable() => StopCoroutine(routine);

    private IEnumerator SpiritCannon()
    {
        while (true)
        {
            yield return Helpers.WaitForSeconds(Random.Range(minWaitSecs, maxWaitSecs));
            animancer.Play(spiritAnimation[animationCycler.Next()]);
        }
    }

Answer 1

It sounds like the only way to use my code without consistently generating garbage is to code my example like this:

void OnEnable() => routine = StartCoroutine(SpiritCannon());
void OnDisable() => StopCoroutine(routine);

private IEnumerator SpiritCannon()
{
    while (true)
    {
        float seconds = Random.Range(minWaitSecs, maxWaitSecs);
        float start = Time.time;
        while (Time.time < start + seconds)
        {
            yield return null;
        }
        animancer.Play(spiritAnimation[animationCycler.Next()]);
    }
}

However, it should be possible to write a mutable custom yield instruction that doesn't generate garbage and can be modified/reused.

Here's unity's documentation.

And an example:

public class MutableWaitForSeconds : CustomYieldInstruction
{
    private float endTime;

    public MutableWaitForSeconds() : this(0f) { }
    public MutableWaitForSeconds(float seconds) => Reset(seconds);

    public void Reset(float seconds) => this.endTime = Time.time + seconds;

    public override bool keepWaiting => Time.time < endTime;
}

You would instantiate this custom yield instruction once, and then reuse it to avoid generating garbage.

Answer 2

Some time ago I actually found a solution for a garbage-free WaitForSeconds. Of course, as it was already mentioned, starting coroutines will always allocate memory. However, a certain fact about the WaitForSeconds class made it possible to simply reuse the same instance. The scheduler does not really store that WaitForSeconds instance internally. It just reads the wait time and forgets about the instance immediately. So all we have to do is change the internal float field of that instance.

This could be done with reflection, but since changing internal/private value type fields through reflection requires the value to be boxed, we're back to new garbage allocations. Though there's a solution. I made a small assembly over here that was simply written in IL and allowed me to manually call the constructor of the WaitForSeconds class again. This will not create a new instance, we just call the constructor which allows us to pass a new value and overwrite the current value.

So instead of:

yield return new WaitForSeconds(sec);

you can simply do:

yield return WaitForSecondsSingleton.Get(sec);

This will not allocate garbage as it uses a single WaitForSeconds instance. A bit hacky but works well.

Here's the compiled assembly and here's the IL source code.

Answer 3

With WaitForSeconds you directly queue the "resume" for its appropriate time. Haven't tested it but WaitForSeconds maybe is marginally faster (the longer the waiting period) because the checks/queuing is done "natively" by the engine and you don't do checks in addition to that it all the time. Using WaitForSeconds makes the code more straightforward to follow. When things get complex a lot of small readability issues quickly add up.

If your time is always the same you can avoid garbage by cashing WaitForSeconds as a YeldInstruction field and not generate a new one each time. BTW you can use the same cached one between multiple coroutines and that will not mess them up.

Your second example (while loop) advantage is that the time interval could change during wait. With WaitForSeconds once the wait begins you can not modify the wait time.

If you wait different amounts of time each time then the second example (with while loop) is probably better.