Is foreach around 9% slower than old-school for-loop?
Thanks to #covid19, I've been trying to find ways to kill the lock-down boredom. I decided to investigate the performance of the traditional "for" loop compared to the somewhat more modern (well, modern in the last 20 years, haha) "foreach" loop.
I remember back in the day when I was actually writing critical-path production code when a co-worker told me: don't use foreach, always use old-school for-loop because the former is much slower
The hypothesis is that the foreach requires use of reflection by the compiler to determine the exact data type of the element in the foreach, and that extra computation results in a slightly less optimized iteration than the traditional loop. True? Well...
I ran the code below for 100s of time. The result? Yeah, anywhere between 8.5% and 10% in favor of the old-school for-loop. Guess my co-worker was right... Cheers, stay safe, love, ACC.
for each: 35720075
old-school for: 32380036
old-school is 9.35059346879871% faster than foreach
public void TestFors()
{
Random rd = new Random();
string test = new string((char)(rd.Next(0, 26) + 'a'), 1000000000);
char t = ' ';
long ticksBefore = DateTime.Now.Ticks;
foreach (char c in test) t = c;
long tickAfter = DateTime.Now.Ticks;
long x = tickAfter - ticksBefore;
Console.WriteLine("for each: {0}", x);
t = ' ';
ticksBefore = DateTime.Now.Ticks;
for (int i = 0; i < test.Length; i++) t = test[i];
tickAfter = DateTime.Now.Ticks;
long y = tickAfter - ticksBefore;
Console.WriteLine("old-school for: {0}", y);
Console.WriteLine("old-school is {0}% faster than foreach", 100.0 * (x - y) / x);
}
Not sure if I agree with the methodology :-)
ReplyDeleteHere are my results using a more pragmatic approach(*):
End of warm-up phase: 0
End of collection phase: 0
For loop
Average: 20781.5728
P50: 20000
P90: 20035
P95: 29997
P99: 30025
End of warm-up phase: 0
End of collection phase: 0
Foreach loop
Average: 20551.2984
P50: 20000
P90: 20033
P95: 20211
P99: 30028
Based on that, I'd say the difference is insignificant.
*Approach:
1. Instead of a single 1 billion entry loop (is that common?) I did 1000 loops over 1 million entries.
2. Full GC before running each test (for or foreach).
3. Ran 1000 loops for warm-up caches before running 1000 loops collecting time information.
Source code:
Deleteclass PerformanceTests
{
private static Random random = new Random(0);
private static int[] randomData = BuildRandomData(1000000);
private static int[] BuildRandomData(int length)
{
int[] result = new int[length];
for (int i = 0; i < length; i++)
{
result[i] = random.Next();
}
return result;
}
private static void FullGC()
{
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true, true);
GC.WaitForPendingFinalizers();
}
private static void WriteReport(string context, long[] ticks)
{
Console.WriteLine(context);
double[] durations = new double[ticks.Length - 1];
for (int i = 0; i < durations.Length; i++)
{
durations[i] = ticks[i + 1] - ticks[i];
}
Array.Sort(durations);
Console.WriteLine("Average: " + durations.Average());
Console.WriteLine("P50: " + durations[(int)(durations.Length * .50)]);
Console.WriteLine("P90: " + durations[(int)(durations.Length * .90)]);
Console.WriteLine("P95: " + durations[(int)(durations.Length * .95)]);
Console.WriteLine("P99: " + durations[(int)(durations.Length * .99)]);
}
public static void ForLoop(int iterations)
{
var ticks = new long[iterations + 1];
int limit = randomData.Length;
int dummy = 0;
for (int it = 0; it < iterations; it++)
{
for (int i = 0; i < limit; i++)
{
dummy = dummy ^ randomData[i];
}
}
Console.WriteLine("End of warm-up phase: " + dummy);
ticks[0] = DateTime.UtcNow.Ticks;
iterations++;
for (int it = 1; it < iterations; it++)
{
for (int i = 0; i < limit; i++)
{
dummy = dummy ^ randomData[i];
}
ticks[it] = DateTime.UtcNow.Ticks;
}
Console.WriteLine("End of collection phase: " + dummy);
WriteReport("For loop", ticks);
}
public static void ForeachLoop(int iterations)
{
var ticks = new long[iterations + 1];
int limit = randomData.Length;
int dummy = 0;
for (int it = 0; it < iterations; it++)
{
foreach (int value in randomData)
{
dummy = dummy ^ value;
}
}
Console.WriteLine("End of warm-up phase: " + dummy);
ticks[0] = DateTime.UtcNow.Ticks;
iterations++;
for (int it = 1; it < iterations; it++)
{
foreach (int value in randomData)
{
dummy = dummy ^ value;
}
ticks[it] = DateTime.UtcNow.Ticks;
}
Console.WriteLine("End of collection phase: " + dummy);
WriteReport("Foreach loop", ticks);
}
public static void Run()
{
FullGC();
ForLoop(10000);
FullGC();
ForeachLoop(10000);
}
}
Sorry, I ran 10,000 iterations over 1,000,000 elements, not 1,000 iterations.
Delete