Upcoming F# struct tuples: are they always faster?

Don Syme has been working on struct tuples for F# language. Let's see if they are more performant than "old" (heap allocated) tuples in simple scenario: returning tuple from function. The code is very simple:

	open System
	open System.Diagnostics
	[<EntryPoint>]
	let main _ =
	let foo x = (x, Math.Sin x)
	let sw = Stopwatch.StartNew()
	for n in 1..100000000 do
	let (x, sinx) = foo (float n / 1000.)
	()
	sw.Stop()
	printfn "Run: %O" sw.Elapsed
	sw.Restart()
	GC.Collect 2
	sw.Stop()
	printfn "GC.Collect: %O" sw.Elapsed
	Console.ReadKey() |> ignore
	0
	// Debug
	// Run: 00:00:03.6734753
	// GC.Collect: 00:00:00.0008279
	// Release
	// Run: 00:00:00.3454602
	// GC.Collect 2: 00:00:00.0000765

view raw struct_tuples.fs hosted with ❤ by GitHub

Decompiled code in Release configuration:

	[EntryPoint]
	public static int main(string[] _arg1)
	{
	Stopwatch sw = Stopwatch.StartNew();
	for (int i = 1; i < 100000001; i++)
	{
	double a = (double)i / 1000.0;
	double num = Math.Sin(a);
	}
	sw.Stop();
	PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit> format = new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("Run: %O");
	PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, format).Invoke(sw.Elapsed);
	sw.Restart();
	GC.Collect(2);
	sw.Stop();
	format = new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("GC.Collect 2: %O");
	PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, format).Invoke(sw.Elapsed);
	ConsoleKeyInfo consoleKeyInfo = Console.ReadKey();
	return 0;
	}

view raw tuples_decompiled.cs hosted with ❤ by GitHub

Everything we need to change to switch to struct tuples, is adding "struct" keyword in front of constructor and pattern matching:

	let foo x = struct (x, Math.Sin x)
	...
	for n in 1..100000000 do
	let struct (x, sinx) = foo (float n / 1000.)
	...
	// Debug
	// Run: 00:00:03.5127102
	// GC.Collect 2: 00:00:00.0001495
	// Release
	// Run: 00:00:00.3443932
	// GC.Collect 2: 00:00:00.0000796

view raw struct_tuples_1.fs hosted with ❤ by GitHub

Decompiled code in Release configuration:

	[EntryPoint]
	public static int main(string[] _arg1)
	{
	Stopwatch sw = Stopwatch.StartNew();
	for (int i = 1; i < 100000001; i++)
	{
	double num = (double)i / 1000.0;
	StructTuple<double, double> structTuple = new StructTuple<double, double>(num, Math.Sin(num));
	}
	sw.Stop();
	PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit> format = new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("Run: %O");
	PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, format).Invoke(sw.Elapsed);
	sw.Restart();
	GC.Collect(2);
	sw.Stop();
	format = new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("GC.Collect 2: %O");
	PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, format).Invoke(sw.Elapsed);
	ConsoleKeyInfo consoleKeyInfo = Console.ReadKey();
	return 0;
	}

view raw struct_tuples_decompiled.cs hosted with ❤ by GitHub

I don't know about you, but I was surprised with those results. The performance roughly the same. GC is not a bottleneck as no objects were promoted to generation 1.

Conclusions:

• Using struct tuples as a faster or "GC-friendly" alternative to return multiple values from functions does not make sense.
• Building in release mode erases away heap allocated tuples, but not struct tuples.
• Building in release mode inlines the "foo" function, which makes the code 10x faster.
• You can fearlessly allocate tens of millions of short-living object per second, performance will be great.