WriteInt64 micro-benchmark

Benchmark.cs

using System;
using System.Diagnostics;

namespace WriteInt64Test
{
	class Program
	{
		static void Main()
		{
			byte[] buf = new byte[8];
			var data = new[] { 0L, 1L, 0x1234567890ABCDEFL, -1L, -0x1234567890ABCDEFL };

			const int reps = 10000000;
			Stopwatch sw;

			sw = Stopwatch.StartNew();
			for (int i = 0; i < reps; i++)
			{
				foreach (long val in data)
				{
					WriteInt64A(val, buf, 0);
				}
			}
			sw.Stop();
			Console.WriteLine("A: {0}", sw.Elapsed);

			sw = Stopwatch.StartNew();
			for (int i = 0; i < reps; i++)
			{
				foreach (long val in data)
				{
					WriteInt64B(val, buf, 0);
				}
			}
			sw.Stop();
			Console.WriteLine("B: {0}", sw.Elapsed);

			sw = Stopwatch.StartNew();
			for (int i = 0; i < reps; i++)
			{
				foreach (long val in data)
				{
					WriteInt64C(val, buf, 0);
				}
			}
			sw.Stop();
			Console.WriteLine("C: {0}", sw.Elapsed);

			sw = Stopwatch.StartNew();
			for (int i = 0; i < reps; i++)
			{
				foreach (long val in data)
				{
					WriteInt64D(val, buf, 0);
				}
			}
			sw.Stop();
			Console.WriteLine("D: {0}", sw.Elapsed);
		}

		private static void WriteInt64A(long value, byte[] buf, int offset)
		{
			long valueToWrite = value < 0 ? -value : value;

			for (int byteIndex = 0; byteIndex < 8; byteIndex++)
			{
				buf[offset + byteIndex] = (byte) (valueToWrite % 256);
				valueToWrite -= buf[offset + byteIndex];
				valueToWrite /= 256;
			}

			if (value < 0)
				buf[offset + 7] |= 0x80;
		}

		private static void WriteInt64B(long value, byte[] buf, int offset)
		{
			long valueToWrite = value < 0 ? -value : value;

			for (int byteIndex = 0; byteIndex < 8; byteIndex++)
			{
				buf[offset + byteIndex] = (byte) (valueToWrite % 256);
				valueToWrite /= 256;
			}

			if (value < 0)
				buf[offset + 7] |= 0x80;
		}
		
		private static void WriteInt64C(long value, byte[] buf, int offset)
		{
			long valueToWrite = value < 0 ? -value : value;

			for (int byteIndex = 0; byteIndex < 8; byteIndex++)
			{
				buf[offset + byteIndex] = unchecked((byte) valueToWrite);
				valueToWrite >>= 8;
			}

			if (value < 0)
				buf[offset + 7] |= 0x80;
		}
		
		private static void WriteInt64D(long value, byte[] buf, int offset)
		{
            if (value < 0)
            {
                value = -value;
                for (int i = -1; ++i < 8; value >>= 8)
                    buf[offset + i] = (byte)value;
                buf[offset + 7] |= 0x80;
            }
            else
            {
                for (int i = -1; ++i < 8; value >>= 8)
                    buf[offset + i] = (byte)value;
            }
        }
	}
}

Results.md

x64

Algorithm	Time
A	00:00:01.7769031
B	00:00:00.9561566
C	00:00:00.3132730
D	00:00:00.3726404

x86

Algorithm	Time
A	00:00:08.7553011
B	00:00:06.7267457
C	00:00:01.1845580
D	00:00:00.7194639