AggressiveInlining. In C# programs, the JIT compiler logically determines which methods to inline. But sometimes we may know better than it does.
With AggressiveInlining, we give the compiler a hint. We tell it that the method should be inlined. This does not guarantee inlining, but it makes is more likely.
And We apply the MethodImplOptions.AggressiveInlining option to Method2. This is an enum.
Result We see that with no options, the method calls required seven nanoseconds each.
But With inlining specified (with AggressiveInlining), the calls required less than one nanosecond each.
using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
class Program
{
const int _max = 10000000;
static void Main()
{
// ... Compile the methods.
Method1();
Method2();
int sum = 0;
var s1 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
sum += Method1();
}
s1.Stop();
var s2 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
sum += Method2();
}
s2.Stop();
Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
}
static int Method1()
{
// ... No inlining suggestion.
return "one".Length + "two".Length + "three".Length +
"four".Length + "five".Length + "six".Length +
"seven".Length + "eight".Length + "nine".Length +
"ten".Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static int Method2()
{
// ... Aggressive inlining.
return "one".Length + "two".Length + "three".Length +
"four".Length + "five".Length + "six".Length +
"seven".Length + "eight".Length + "nine".Length +
"ten".Length;
}
}7.34 ns No options
0.32 ns MethodImplOptions.AggressiveInlining
Discussion. For critical algorithms, using a micro-optimization on hot code is often worthwhile. But this is the uncommon case—most code needs little optimization.
When to use AggressiveInlining. When should we apply this option? I have found that larger methods, such as the one in the example, benefit from this sort of inlining.
And If a method is called only once in an enclosing method, it may help to inline it even if it is large.
However If a large method is called in many places in a program, inlining it will reduce locality of reference and may ruin performance.
Method calls have a cost, but also a benefit. They require an activation record, but also reduce instruction count. Our challenge is to find the best balance between these considerations.
Dot Net Perls is a collection of pages with code examples, which are updated to stay current. Programming is an art, and it can be learned from examples.
Donate to this site to help offset the costs of running the server. Sites like this will cease to exist if there is no financial support for them.
Sam Allen is passionate about computer languages, and he maintains 100% of the material available on this website. He hopes it makes the world a nicer place.
This page was last updated on Sep 24, 2022 (rewrite).