Ускоряем IsNaN() в три раза

[ds.Dante]

Пройдясь профайлером по своей проге, я обнаружил, что аж 7% времени занимают вызовы float.IsNaN(). Вообще функция довольно тяжёлая (по сравнению с элементарными операторами сравнения), потому что NaN кодируется не одним двоичным представлением, а целым диапазоном. Покурив IEEE 754 и взяв за основу чей-то полезный класс DoubleUtil я сделал такой вот сравнятор:

using System;
using System.Runtime.InteropServices;

public static class FloatComparer
{
	// float
	[StructLayout (LayoutKind.Explicit)]
	struct FloatUnion
	{
		[FieldOffset (0)]
		public float value;

		[FieldOffset (0)]
		public UInt32 binary;
	}

	public static bool IsNaN (float value)
	{
		FloatUnion union = new FloatUnion ();
		union.value = value;

		return ((union.binary & 0x7F800000) == 0x7F800000) && ((union.binary & 0x007FFFFF) != 0);
	}

	// double
	[StructLayout (LayoutKind.Explicit)]
	struct DoubleUnion
	{
		[FieldOffset (0)]
		public double value;

		[FieldOffset (0)]
		public UInt64 binary;
	}

	public static bool IsNaN (double value)
	{
		DoubleUnion union = new DoubleUnion ();
		union.value = value;

		return ((union.binary & 0x7ff0000000000000) == 0x7ff0000000000000) && ((union.binary & 0x000fffffffffffff) != 0);
	}
}

Он перегружен для float и double. Суть том, что мы записываем в структуру float, а потом читаем с того же места как int (по аналогии с union из C++). И, посмотрев двоичное представление, делаем нужные выводы. Поскольку структура union у нас локальная, находится в стеке, то даже при многократном вызове память из кучи не забивается. Вот программа для сравнения скорости float.IsNaN() и FloatComparer.IsNaN(), также проверяющая, что результаты совпадают.

using System;
using System.Diagnostics;

class Program
{
	static void Main ()
	{
		Random rand = new Random ();
		float[] array = new float[10000000];

		for (int i=0; i<array.Length; i++)
			array[i] = (float)Math.Log (rand.Next (-1000, 1000)); // many NaN's

		// System
		bool[] systemResults = new bool[array.Length];
		Stopwatch stopwatch = new Stopwatch ();
		stopwatch.Start ();
		for (int i=0; i<array.Length; i++)
			systemResults[i] = float.IsNaN (array[i]);
		stopwatch.Stop ();
		Console.WriteLine ("System: " + stopwatch.ElapsedTicks*0.0001 + " ms");

		// My
		bool[] myResults = new bool[array.Length];
		stopwatch.Restart ();
		for (int i=0; i<array.Length; i++)
			myResults[i] = FloatComparer.IsNaN (array[i]);
		stopwatch.Stop ();
		Console.WriteLine ("My: " + stopwatch.ElapsedTicks*0.0001 + " ms");

		// Check results
		for (int i=0; i<array.Length; i++)
			if (myResults[i] != systemResults[i])
			{
				Console.WriteLine ("Error");
				break;
			}

		Console.ReadKey ();
	}
}

Если запускать в релизе, то выигрыш в скорости получается в три раза, как для float, так и для double. Для меня остаётся загадкой, почему вручную написанная функция оказывается в разы быстрее стандартной элементарной функции.

З. Ы. если убрать статики и не пересоздавать юнион, то работать будет ещё немного быстрее. А если ещё запускать напрямую, не из студии, то выигрыш получается в 4,5 раза.

[ds.Dante]

Апдейт. В исходниках дотнета IsNaN выглядит так:

        [Pure]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] 
        public static bool IsNaN(float f) {
            //Jit will generate inlineable code with this
// warning CS1718:  Comparison to same variable
#pragma warning disable 1718 
            if (f != f)
            { 
                return true; 
            }
            else 
            {
                return false;
            }
#pragma warning restore 1718 
        }

Эта элементарная проверка с собой, которая, очевидно, выполняется сопроцессором, оказывается медленнее проверки собственно процессором в несколько ходов. Как я понимаю, такая проверка if (f != f) используется и плюсовиками. Надо проверить, не окажется проверка через двоичку быстрее и в плюсах.

[Hollander]

Спасибо, как только будет возможность, дам репутацию. Отличное исследование.

[ds.Dante]

Спасибо. :) А каких-то пару лет назад (один из которых я провёл в армии) ты сам отвечал на мои бесчисленные вопросы по дотнету. :)

С unsafe код выглядит гораздо проще и работает ещё чуть быстрее.

static class NaNComparer
{
	public static unsafe bool IsNaN (float f)
	{
		int binary = *(int*)(&f);
		return ((binary & 0x7F800000) == 0x7F800000) && ((binary & 0x007FFFFF) != 0);
	}

	public static unsafe bool IsNaN (double f)
	{
		long binary = *(long*)(&f);
		return ((binary & 0x7ff0000000000000) == 0x7ff0000000000000) && ((binary & 0x000fffffffffffff) != 0);
	}
}

Примерно так в дотнете работает float.IsInfinity()