Few versus many Update() routines?

I asked a question close to this one some time ago.

here it is.

Hi Fattie,

I believe that the fewer methods that get called the better the performance, because every method that gets called carries some overhead. This is much more so, with the Update() method, because it gets called every frame (as I'm sure everybody in the Unity community knows). So, the overhead inherent on method calling occurs in every frame.

So, if it were possible to include the 1,000 lines of code originally located in each of 10 Update() methods, to 1 Update() method containing 10,000 lines of code, there would be an overall performance gain.

However, I can see 2 issues with this:

a. In order to "centralize" the code in a single Update, it would most likely be necessary to create references to decentralized code. This would probably create a performance loss that would be greater than the performance gain from centralizing.

b. If there is plenty of code inside the original Update() methods, then the majority of the workload would be in executing the code, and the performance hit for calling this Update() method would be insignificant.

Bottom of the Line: I would be concerned with centralizing Update() methods, only if I had a large number of them, with each containing only very few lines of "light" code.

need actual facts on this guys.

If you google something like "c# method call performance" you'll get some interesting links. Basically, it all comes down to testing it yourself if you want actual facts. The Stopwatch Class is useful for this:

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx

hey pako, naturally I could do the work myself - but that's no fun. better to ask here :) it's difficult to believe this isn't a well-known topic that has been well-explored