Timing of coroutines in Unity is never precise

Question

I was looking an official example for coroutines in Unity here.

However, when I call WaitAndPrint the time taken is never exactly 5 seconds.

IEnumerator WaitAndPrint()
{
    float timeStart = Time.time;
    yield return new WaitForSeconds(5);
    Debug.Log(string.Format("Time taken = {0}", Time.time - timeStart));
}

if (Input.GetKeyDown(KeyCode.R))
    StartCoroutine(WaitAndPrint());

Instead, it varies around 5.003133.

This is most likely down to the frame rate, which makes me wonder how can I make sure that a coroutine takes the precise amount of time it should take despite the fluctuating frame rate?

Answer 1

This is most likely down to the frame rate, which makes me wonder how can I make sure that a coroutine takes the precise amount of time it should take despite the fluctuating frame rate?

I don't think you can, honestly. Coroutines are at the mercy of Update() in the same way the rest of your code is. You can't make it end between two update loops, because that's the time Unity is spending doing other stuff instead

I am kind of wondering why you need that sort of precision to begin with, though. Does it really matter if the coroutine ends when the frame starts, or 3ms before that?

Answer 2

Coroutines aren't threads or processes or anything special like that. They're just callbacks given to the engine to call when a specific condition is met. If you yield null, the coroutine will be called every frame.

Every frame, the engine calls all coroutines that are ready at that time, all together in a block (either right before or right after calling all the .Update()'s, not sure which). It will only call a WaitForSeconds routine AFTER that number of seconds has elapsed, so it will come up during the frame after that time has passed.

You can only really do things in unity in increments of frames (or physics updates), anyway. You surely can't draw something to the screen at a specific exact time, you have to wait for the next frame to happen.

Here's an in-depth article on how coroutines work, and a couple threads that I've bumped into in unity-land relating to them, which link off into other resources as well:

http://www.altdev.co/2011/07/07/unity3d-coroutines-in-detail/

http://answers.unity3d.com/questions/751178/when-using-coroutines-what-should-i-be-wary-of.html

Answer 3

Actually it is normal if the dvalue is under 0.01. And that 0.01ms won't bother your game. I've tested. That 5 second will be different each time you launch the game.

Answer 4

You can never make sure a coroutine takes a precise amount of time. As you said, it's the frame rate. You can get super close, but it'll never be spot on.

The time between frames will always differ, based on hardware. Thus you will almost always overshoot your specified time. Imagine you are at 4.89 seconds and the next frame takes 0.16 seconds to update. You'd be at 5.05 seconds on the new update. You're unable to control that.

What you can control is how you use that information given. If you had some code that needed to execute at the end of the 5 seconds. Do what you did before, get the difference in time and advance to whatever the execution would be at that time.

In your example that you would execute some code as though .003133 seconds had already passed. Now this isn't applicable in all situations - such as you wanting to just wait for an exact period of time.