Windows Phone Performance Analysis makes game run faster. Possible reasons?

Question

A XNA game I was making was running slowly on my WP7 device. However when I started it in Windows Phone Performance Analysis to find the bottleneck, the game ran smoothly on the same device.

I figured the problem out a little later, and it was an adjacency-checking function. I have optimized the function and the game works fine now.

Why was the game magically speeding up in Perf Analysis mode? Any possible explanations?

This was the code that ran faster on the Perf Analysis mode, but slow otherwise. It is a damage-dealing function in a tower defense game.

 foreach (Target myTarget in _targets)
 {
        for (int x = -1; x <= 1; x++)
        {
                for (int y = -1; y <= 1; y++)
                {
                    if (x == 0 && y == 0) continue;
                    try
                    {
                        Tile adjacent = _tiles[(int)myTarget.CurrentTile.X + x, (int)myTarget.CurrentTile.Y + y];
                        if (adjacent.Tower != null)
                        {
                            DealDamage(myTarget, adjacent.Tower);
                        }
                    }
                    catch
                    {
                    }
                }
            }
 }

I optimized it later by checking damage for each tower instead of each target.

Answer 1

My guess is the try/catch overhead for each iteration of a potentially large nested loop was killing your performance and that the analysis tool somehow affected the exception handler overhead. You could easily test that by removing the exception handling and running normally, without the profiler.

You definitely don't want a try/catch on the inside of a tight loop. You would be much better off ensuring that you account for anything that can generate an exception within your loop via conditional checks, or at the very least put the try/catch around the loop as a whole.

Answer 2

I am not familiar with the tool itself, nor I am an expert on compiler optimization, but the reason could lie in the line:

Tile adjacent = _tiles[(int)myTarget.CurrentTile.X + x, (int)myTarget.CurrentTile.Y + y];

What could happen here is that the a Tile adjacent is created on the stack, with values copied from the the right tile in _tiles[] (you are not using what would be a reference in C++, and I don't know if they exist in C#). Therefore, you are continuously creating and destroying a Tile object, and moreover, inside 2 big nested for loop. Although it's on the stack, this could definitely affect speed. What maybe happened is that the Perf Analysis mode recognized this scenario, pre-allocated a Tile object outside the nested loop and kept on using it through the function, avoiding the overhead of creation/destruction.