8

I've read several articles and questions/answers that conclude the best practice is to let the JIT compiler do all the optimization for inline function calls. Makes sense.

What about inline variable declarations? Does the compiler optimize these as well?

That is, will this:

        Dim h = (a + b + c) / 2       'Half-Perimeter

        If maxEdgeLength / (Math.Sqrt(h * (h - a) * (h - b) * (h - c)) / h) <= MaximumTriangleAspectRatio Then
           'Do stuff here.
        End If

Have better performance than this:

        Dim perimeter = a + b + c   'Perimeter
        Dim h = perimeter / 2       'Half-Perimeter

        Dim area = Math.Sqrt(h * (h - a) * (h - b) * (h - c)) 'Heron's forumula.
        Dim inradius = area / h
        Dim aspectRatio = maxEdgeLength / inradius

        If aspectRatio <= MaximumTriangleAspectRatio Then
            'Do stuff here.
        End If

Of course I prefer the latter because it's easier to read and debug, but I can't afford the performance degradation if it exists.

Note: I have already identified this code as a bottleneck -- No need for retorts about premature optimization. :-)

Improve this question
5
  • 7
    You can't afford an extra 20 bytes of RAM? This is very unlikely to be driving your app's performance, especially as if this code is run over and over again it's the same 20 bytes each time. Commented Oct 20, 2011 at 20:59
  • Wouldn't the compiler (not the JIT!) would be "responsible" for this sort of optimization during the translation to MSIL? (And if, so, to what extent the MS C# compiler optimizes.) In any case benchmark it in a relativistic environment as that is the only way "to know for certain" which is faster, and to what extent. Commented Oct 20, 2011 at 21:13
  • 4
    You're the only person here who can answer the question. You've written the code both ways. Run it both ways, measure the timing, and then you'll know which one is faster. What the jitter does or does not do is irrelevant; knowing what the jitter does in no way answers the question "which one is faster?" Commented Oct 20, 2011 at 21:24
  • @JoelCoehoorn It does not seem JRS is concerned about memory consumption, but how fast the code runs. Commented Jun 16, 2015 at 2:47
  • @user166390 I played around with/without local variable declaration, and the difference was reflected in the generated IL code when doing a Release build. So it seems that it would indeed be the JIT's job, by enregistering local variables, I guess, without having digged into it. Commented Jun 16, 2015 at 2:51

2 Answers 2

Reset to default
17

Temporary variables having names or not is a non-issue.

But you can optimize that inequality significantly.

Your code was:

If maxEdgeLength / (Math.Sqrt(h * (h - a) * (h - b) * (h - c)) / h) <= MaximumTriangleAspectRatio Then

Multiply both sides by the square root, eliminating division (inequality is preserved, because square root cannot return a negative number):

If maxEdgeLength <= (Math.Sqrt(h * (h - a) * (h - b) * (h - c)) / h) * MaximumTriangleAspectRatio Then

Now, square both sides to eliminate that expensive square root:

If maxEdgeLength * maxEdgeLength <= h * (h - a) * (h - b) * (h - c) / h / h * MaximumTriangleAspectRatio * MaximumTriangleAspectRatio Then

Cancel, and multiply by h.

If maxEdgeLength * maxEdgeLength * h <= (h - a) * (h - b) * (h - c) * MaximumTriangleAspectRatio * MaximumTriangleAspectRatio Then

This will be a lot faster. If this calculation is repeated, consider caching the results of part of this expression for even more improvement.

Use comments to explain the formula. Getting rid of a Math.Sqrt call in a bottleneck function is worth writing the expression in a less-than-simple format.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Rather than (just) using comments, refactor the calculation into a stand-alone function – it’s much too long to occur in code like that. Explain that function as needed (in particular, explain the transformation done above …).
+1 for identifying that an optimization can be found not in the code or compilation, but the algorithm itself.
5

By the way, just to play devil's advocate, also I wanted to point this out:

JIT inlining of the entire function looks at the length, in bytes of MSIL, and not the complexity of the calculation. Adding local variables (and expecting the JIT to enregister them) might increase the MSIL size of the function enough to make the whole function not a candidate for inlining.

This isn't likely to make as big a difference as unnecessary use of Math.Sqrt, but it is a possibility. As Eric Lippert said, you'll know more by actually measuring. However, such a measurement is only valid for one particular run of the program, and does not generalize to different processors or future versions of the .NET runtime (including service packs) that often tweak JIT behavior. So you want a combined analytical and empirical approach to optimization.

Improve this answer

2 Comments

You make an excellent point Ben; except in trivial cases there is actually no such thing as "optimization". Every so-called "optimization" is actually a tradeoff that we hope is better, but might not be. You trade more register use on this calculation for fewer registers available on that calculation, and hope that you picked the one that needed to be faster. Or you trade more memory usage for less time, and hope that doing so does not cause a cache miss later. And so on.
@EricLippert: Yes, absolutely optimization involves tradeoffs. But that's beside the points I'm making. When using JIT compilation, you're subject to changed optimizer algorithms, that make different tradeoffs given the same MSIL input. Even with traditional AOT native compilers, the same instruction sequence may perform differently on different processors with different CPI characteristics.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.