Fixed some declaration bugs in HugeBuffer. Added VectorVsISPC benchmark. Added float data type.

Author: allisterb

jemalloc.Api/HugeArray.cs

@@ -4,7 +4,7 @@
 
 namespace jemalloc
 {
-    public class HugeArray<T> : HugeBuffer<T> where T : struct
+    public class HugeArray<T> : HugeBuffer<T> where T : struct, IEquatable<T>
     {
         public HugeArray(ulong length, params T[] values) : base(length, values) { }
     }

jemalloc.Api/HugeBufferEnumerator.cs

@@ -7,7 +7,7 @@
 namespace jemalloc
 {
     /// <summary>Enumerates the elements of a <see cref="HugeBuffer{T}"/>.</summary>
-    public class HugeBufferEnumerator<T> : IEnumerator, IEnumerator<T> where T : struct
+    public class HugeBufferEnumerator<T> : IEnumerator, IEnumerator<T> where T : struct, IEquatable<T>
     {
         /// <summary>The span being enumerated.</summary>
         private readonly HugeBuffer<T> _buffer;

jemalloc.Api/JemUtil.cs

@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace jemalloc
 {
@@ -179,6 +180,31 @@ public static Tuple<double, string> PrintBytesToTuple(double bytes, string suffi
             string[] s = PrintBytes(bytes, suffix).Split(' ');
             return new Tuple<double, string>(Double.Parse(s[0]), s[1]);
         }
+
+        public static ulong GetWindowsThreadCycles()
+        {
+            if (Environment.OSVersion.Platform != PlatformID.Win32NT)
+            {
+                throw new PlatformNotSupportedException();
+            }
+
+            if (__Internal.QueryThreadCycleTime(__Internal.PseudoHandle, out ulong cycles))
+            {
+                return cycles;
+            }
+            else
+            {
+                throw new System.ComponentModel.Win32Exception();
+            }
+            
+        }
+
+        public partial struct __Internal
+        {
+            [DllImport("kernel32.dll", SetLastError = true)]
+            internal static extern bool QueryThreadCycleTime(in IntPtr hThread, out ulong cycles);
+            internal static readonly IntPtr PseudoHandle = (IntPtr)(-2);
+        }
         #endregion
 
         #region Fields

jemalloc.Benchmarks/Benchmarks/HugeNativeVsManagedArray.cs

@@ -21,7 +21,7 @@ public override void GlobalSetup()
             DebugInfoThis();
             base.GlobalSetup();
             Info($"Unmanaged array size is {ArraySize}.");
-            Info($"Managed array size is {ArraySize}.");
+            Info($"Managed array size is {MaxManagedArraySize}.");
             T[] managedArray = new T[MaxManagedArraySize];
             SetValue("managedArray", managedArray);
             HugeArray<T> hugeArray = new HugeArray<T>(ArraySize);
@@ -49,7 +49,7 @@ public override void GlobalSetup()
         [BenchmarkCategory("Fill")]
         public void FillManagedArray()
         {
-            InfoThis();
+            DebugInfoThis();
             T[] managedArray = GetValue<T[]>("managedArray");
             T fill = GetValue<T>("fill");
             for (int i = 0; i < managedArray.Length; i++)
@@ -62,7 +62,7 @@ public void FillManagedArray()
         [BenchmarkCategory("Fill")]
         public void FillHugeNativeArray()
         {
-            InfoThis();
+            DebugInfoThis();
             HugeArray<T> hugeArray = GetValue<HugeArray<T>>("hugeArray");
             T fill = GetValue<T>("fill");
             hugeArray.Fill(fill);
@@ -72,7 +72,7 @@ public void FillHugeNativeArray()
         [BenchmarkCategory("Fill")]
         public void FillManagedArrayWithCreate()
         {
-            InfoThis();
+            DebugInfoThis();
             T[] managedArray = new T[ArraySize];
             T fill = GetValue<T>("fill");
             for (int i = 0; i < managedArray.Length; i++)
@@ -138,6 +138,7 @@ public void CreateHugeNativeArray()
         [BenchmarkCategory("Arithmetic")]
         public void ArithmeticMultiplyManagedArray()
         {
+            DebugInfoThis();
             T mul = GetValue<T>("mul");
             T fill = GetValue<T>("fill");
             T[] managedArray = GetValue<T[]>("managedArray");
@@ -153,6 +154,7 @@ public void ArithmeticMultiplyManagedArray()
         [BenchmarkCategory("Arithmetic")]
         public void ArithmeticMultiplyHugeNativeArray()
         {
+            DebugInfoThis();
             T mul = GetValue<T>("mul");
             T fill = GetValue<T>("fill");
             HugeArray<T> hugeArray = GetValue<HugeArray<T>>("hugeArray");

jemalloc.Benchmarks/Benchmarks/VectorVsISPC.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace jemalloc.Benchmarks.Benchmarks
+{
+    public class VectorVsISPC : JemBenchmark<float, int>
+    {
+    }
+}

jemalloc.Cli/Options.cs

@@ -24,6 +24,9 @@ class Options
         [Option('l', "int64", Required = false, HelpText = "Use Int64 long integer as the underlying data type.", SetName = "type")]
         public bool Int64 { get; set; }
 
+        [Option('f', "float", Required = false, HelpText = "Use single-precision floating point as the underlying data type.", SetName = "type")]
+        public bool Float { get; set; }
+
         [Option('m', "double", Required = false, HelpText = "Use double-precision floating point as the underlying data type.", SetName = "type")]
         public bool Double { get; set; }
 

jemalloc.Cli/Program.cs

@@ -278,6 +278,10 @@ static void Benchmark(Options o)
             {
                 Benchmark<Int64>();
             }
+            else if (o.Float)
+            {
+                Benchmark<Single>();
+            }
             else if (o.Double)
             {
                 Benchmark<Double>();