Control Unity Game loop to sync with external hardware/software

Question

We would like to run the Unity Game Loop in sync with external hardware and applications running on a different computer. We want to arrive at something that work similar (but does not have to be identical to this).

1. Receive remote TCP packet with a list of new locations (etc.) for GameObjects [For low latency, would we put this in a FixedUpdate loop, set at a high Hz?] [Is this best done in a [Manager Singleton]1?]
2. Send these updates from this "singleton" to all game objects [One way might be to just have the object pick up the data in the Update cycle, which would happen after the fixedUpdate is done]. [Is a better idea to forget about the gameloop, and just use C# events to broadcast the updates to the gameobject attached scripts?] Each GameObject will then update its location
3. Once all is stable (step #2 is completely done by all objects), we need to do measurements (scene read only) (with Raycast and LineCast) from each object to each other to see what is occluded and what is visible [Can we rely on LateUpdate to run afterwards, or should we avoid the game loop] [How do we know that all gameobjects have finished updating?]
4. Finally we need to post the visibility results back via a TCP packet.

The overall goal here is to make all four steps run as fast (back-to-back) as possible, Best would be to be able to speed up the frame rate (or slow it down) based on when each phase is done. But we can live with a fixed 60Hz if needed.

Other questions, have to do with the Async nature of TCP (or UDP) clients inside of Unity, and the issues of not being able to use the API from a separate thread (e.g. the async results of the TCP receive]. Has anyone pointers to solutions to that?

We need no help writing the code, but the internal execution model of Unity3D at this level of detail is not clear in the manuals.

We think this has wide applicability for VR, AR, and various robot co-sync with games.

Answer 1

That's not really how Unity works, you're not intended to directly control the FixedUpdate or Update or LateUpdate methods (but you can write your own methods). Also, FixedUpdate is named the way it is because it's supposed to run at a fixed timestep. Running it once whenever a network message comes in defeats the purpose of it being a fixed update.

Additionally you can't really run 20 or so methods "in parallel". Even spawning threads for each method is only going to have some wait while others are processed. If you're just looking for a on-command line-of-sight tester, Unity probably isn't the best technology choice. You'd be better off writing something without the overhead of an entire engine.

Answer 2

As @DMGregory points out, there are some very elegant ways to chain Coroutines to guarantee syncrhornization points at phases of computation (even with a large swarm of "virtually seperate threads" of execution running in each gameObject.

I encorage folks to read: http://forum.unity3d.com/threads/the-truth-about-fixedupdate.231637/

as well as: How to not freeze the main thread in Unity?

By using Update() and waitForEndOfFrame() for my tcp work and putting the rest in co-routines and lastDone, I can effecting seperate the 4 phases the computation and get about 1500FPS of externally clocked simulation, SWIL work done. I am impressed.

public class Tools
{
    public static string timeStamp()
    {
        return string.Format("{0} - {1:H:mm:ss.ffffff}", Time.time, System.DateTime.Now);
    }
}

public class TargetScript : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(CoDo());
    }
    void Update()
    {
        Debug.Log(string.Format("{0}: {1} update: {2}", Time.frameCount, gameObject.name, Tools.timeStamp()));
    }
    IEnumerator CoDo()
    {
        while (true)
        {
            yield return null;
            Debug.Log(string.Format("{0}: {1} codo: {2}", Time.frameCount, gameObject.name, Tools.timeStamp()));
        }

    }
    void LateUpdate()
    {
        Debug.Log(string.Format("{0}: {1} late:   {2}", Time.frameCount, gameObject.name, Tools.timeStamp()));
    }
    IEnumerator Done()
    {
        while (true)
        {
            yield return new WaitForEndOfFrame();
            Debug.Log(string.Format("{0}: {1} done: {2}", Time.frameCount, gameObject.name, Tools.timeStamp()));
        }
    }
}