Feature => Master

.github/workflows/main.yml

@@ -77,6 +77,6 @@ jobs:
       - name: Create Release
         uses: ncipollo/[email protected]
         with:
-          tag: v1.5.0
+          tag: v1.5.1
           artifacts: "artifacts/**"
           artifactContentType: application/octet-stream

.gitignore

@@ -10,6 +10,9 @@
 *.userosscache
 *.sln.docstates
 
+# Generated results file
+BenchmarkResults.txt
+
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 

Benchmark.csproj

@@ -3,7 +3,7 @@
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
 		<TargetFramework>net9.0</TargetFramework>
-		<Version>1.5.0</Version>
+		<Version>1.5.1</Version>
 		<FileVersion>$([System.DateTime]::Now.ToString('yyyyMMddHH'))</FileVersion>
 		<Author>Dom</Author>
 		<ImplicitUsings>enable</ImplicitUsings>

Benchmarks.cs → Benchmarks/Benchmarks.cs

@@ -1,22 +1,25 @@
-using BenchmarkDotNet.Attributes;
-using System;
-using System.Diagnostics;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Threading;
+using System.Diagnostics;
 using System.Security.Cryptography;
+using System.Buffers;
 
 public class HashingBenchmark
 {
-    private const int N = 2000000000;
+    private int N;
     private readonly byte[] data;
-
     private readonly SHA256 sha256 = SHA256.Create();
     private readonly SHA512 sha512 = SHA512.Create();
     private readonly MD5 md5 = MD5.Create();
 
     public HashingBenchmark()
     {
+        if (Debugger.IsAttached)
+        {
+            N = 1000000000;
+        }
+        else
+        {
+            N = 2000000000;
+        }
         data = new byte[N];
         new Random(42).NextBytes(data);
     }
@@ -27,10 +30,10 @@ public HashingBenchmark()
 
     public byte[] Md5() => md5.ComputeHash(data);
 
-    public void CombinedHashing()
+    public string CombinedHashingExport()
     {
         Console.ForegroundColor = ConsoleColor.White;
-        Console.WriteLine("Running Hashing operation...");
+        Console.WriteLine($"Running Hash on SHA256, SHA512, MD5... Hashing {N / 1_000_000_000} GB...");
         Stopwatch stopwatch = Stopwatch.StartNew();
         ConsoleSpinner.Start();
 
@@ -41,24 +44,36 @@ public void CombinedHashing()
         stopwatch.Stop();
         ConsoleSpinner.Stop();
         Console.ForegroundColor = ConsoleColor.Cyan;
-        Console.WriteLine($"Hasing completed in {stopwatch.ElapsedMilliseconds} ms.");
+        Console.WriteLine($"Hashing completed in {stopwatch.ElapsedMilliseconds} ms.");
         Console.ForegroundColor = ConsoleColor.Green;
         Console.WriteLine("-----------------------------------------------------------");
+
+        string result = $"Hashing Benchmark: {stopwatch.ElapsedMilliseconds} ms";
+        return result;
     }
 }
 
 public class EncryptionBenchmark
 {
-    private const long TotalSize = 16L * 1_000_000_000; // 16GB
+    private long TotalSize;
     private const int ChunkSize = 100_000_000; // 100MB per operation
-    private const int Iterations = (int)(TotalSize / ChunkSize); // Number of chunks needed
+    private int Iterations;
     private readonly byte[] dataChunk;
     private readonly byte[] key;
     private readonly byte[] iv;
     private readonly Aes aes;
 
     public EncryptionBenchmark()
     {
+        if (Debugger.IsAttached)
+        {
+            TotalSize = 1L * 1_000_000_000; // 1GB
+        }
+        else
+        {
+            TotalSize = 16L * 1_000_000_000; // 16GB
+        }
+        Iterations = (int)(TotalSize / ChunkSize);
         aes = Aes.Create();
         aes.KeySize = 256;
         aes.GenerateKey();
@@ -68,7 +83,7 @@ public EncryptionBenchmark()
         iv = aes.IV;
 
         dataChunk = new byte[ChunkSize];
-        new Random().NextBytes(dataChunk); // Generate random data once
+        new Random().NextBytes(dataChunk);
     }
 
     public byte[] AesEncrypt(byte[] data)
@@ -83,9 +98,9 @@ public byte[] AesDecrypt(byte[] encryptedData)
         return decryptor.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
     }
 
-    public void RunEncryptBenchmark()
+    public string RunEncryptBenchmark()
     {
-        int threadCount = Environment.ProcessorCount; // Match CPU core count
+        int threadCount = Environment.ProcessorCount;
         Console.ForegroundColor = ConsoleColor.White;
         Console.WriteLine($"Running AES-256 Encryption... processing {TotalSize / 1_000_000_000} GB with {threadCount} threads...");
 
@@ -107,15 +122,28 @@ public void RunEncryptBenchmark()
         Console.WriteLine($"Encryption completed in {stopwatch.ElapsedMilliseconds} ms.");
         Console.ForegroundColor = ConsoleColor.Green;
         Console.WriteLine("-----------------------------------------------------------");
+
+        string result = $"Encryption Benchmark: {stopwatch.ElapsedMilliseconds} ms";
+        return result;
     }
 }
 
 class CPUBenchmark
 {
-    public static void CpuPrimeCompute()
+    public static string CpuPrimeCompute()
     {
+        int iterations;
+
+        if (Debugger.IsAttached)
+        {
+            iterations = 100_000_000;
+        }
+        else
+        {
+            iterations = 400_000_000; // Default value if not debugging
+        }
+
         int taskCount = Environment.ProcessorCount;
-        int iterations = 400_000_000;
         int iterationsPerThread = iterations / taskCount;
 
         Console.ForegroundColor = ConsoleColor.White;
@@ -140,6 +168,9 @@ public static void CpuPrimeCompute()
         Console.WriteLine($"Prime compute completed in {stopwatch.ElapsedMilliseconds} ms.");
         Console.ForegroundColor = ConsoleColor.Green;
         Console.WriteLine("-----------------------------------------------------------");
+
+        string result = $"Prime Compute Benchmark: {stopwatch.ElapsedMilliseconds} ms";
+        return result;
     }
 
     private static int ComputePrimes(int limit)
@@ -168,13 +199,21 @@ private static bool IsPrime(int number)
 
 class MatrixMultiplicationBenchmark
 {
-    private const int N = 2048; // Matrix size
+    private int N; // Matrix size
     private readonly double[,] matrixA;
     private readonly double[,] matrixB;
     private readonly double[,] result;
 
     public MatrixMultiplicationBenchmark()
     {
+        if (Debugger.IsAttached)
+        {
+            N = 1024;
+        }
+        else
+        {
+            N = 2048;
+        }
         matrixA = new double[N, N];
         matrixB = new double[N, N];
         result = new double[N, N];
@@ -190,7 +229,7 @@ public MatrixMultiplicationBenchmark()
         }
     }
 
-    public void MultiplyMatrix()
+    public string MultiplyMatrix()
     {
         Console.ForegroundColor = ConsoleColor.White;
         Console.WriteLine($"Running Matrix Multiplication with {Environment.ProcessorCount} threads...");
@@ -221,5 +260,88 @@ public void MultiplyMatrix()
         Console.WriteLine($"Matrix multiplication completed in {stopwatch.ElapsedMilliseconds} ms.");
         Console.ForegroundColor = ConsoleColor.Green;
         Console.WriteLine("-----------------------------------------------------------");
+
+        string benchResult = $"Matrix Multiplication Benchmark: {stopwatch.ElapsedMilliseconds} ms";
+        return benchResult;
+    }
+}
+
+// WIP
+public class MemoryBenchmark
+{
+    public string MTMemBandwidth()
+    {
+        Console.ForegroundColor = ConsoleColor.White;
+        Console.WriteLine("Running Memory Bandwidth Benchmark...");
+
+        uint[] data = new uint[10000000 * 32];
+        List<(long Sum, double Bandwidth)> AllResults = new();
+        (long Sum, double Bandwidth) BestResult;
+
+        for (int j = 0; j < 15; j++)
+        {
+            long totalSum = 0;
+            var sw = Stopwatch.StartNew();
+            int chunkSize = data.Length / Environment.ProcessorCount;
+            object lockObj = new object();
+
+            Parallel.For(0, Environment.ProcessorCount, threadId =>
+            {
+                int start = threadId * chunkSize;
+                int end = (threadId == Environment.ProcessorCount - 1) ? data.Length : start + chunkSize;
+                uint localSum = 0;
+
+                for (int i = start; i < end; i += 64)
+                {
+                    localSum += data[i] + data[i + 16] + data[i + 32] + data[i + 48];
+                }
+
+                lock (lockObj)
+                {
+                    totalSum += localSum;
+                }
+            });
+
+            sw.Stop();
+            long dataSize = data.Length * 4;
+            double bandwidth = dataSize / sw.Elapsed.TotalSeconds / (1024 * 1024 * 1024);
+
+            //Console.WriteLine("{1:0.000} GB/s", totalSum, bandwidth);
+            AllResults.Add((totalSum, bandwidth));
+        }
+
+        BestResult = AllResults.OrderByDescending(x => x.Bandwidth).First(); // Sort for highest
+        Console.WriteLine($"Memory Bandwidth: {BestResult.Bandwidth:0.000} GB/s");
+
+        string benchResult = $"Memory Bandwidth: {BestResult.Bandwidth:0.000} GB/s";
+        return benchResult;
+    }
+
+    public string STMemBandwidth()
+    {
+        List<(long Sum, double Bandwidth)> AllResults = new();
+        (long Sum, double Bandwidth) BestResult;
+        uint[] data = new uint[10000000 * 32];
+        for (int j = 0; j < 15; j++)
+        {
+            long totalSum = 0;
+            uint sum = 0;
+            var sw = Stopwatch.StartNew();
+            for (uint i = 0; i < data.Length; i += 64)
+            {
+                sum += data[i] + data[i + 16] + data[i + 32] + data[i + 48];
+            }
+            sw.Stop();
+            long dataSize = data.Length * 4;
+            double bandwidth = dataSize / sw.Elapsed.TotalSeconds / (1024 * 1024 * 1024);
+            Console.WriteLine("{0} {1:0.000} GB/s", sum, dataSize / sw.Elapsed.TotalSeconds / (1024 * 1024 * 1024));
+            AllResults.Add((totalSum, bandwidth));
+        }
+
+        BestResult = AllResults.OrderByDescending(x => x.Bandwidth).First(); // Sort for highest
+        Console.WriteLine($"Memory Bandwidth: {BestResult.Sum} {BestResult.Bandwidth:0.000} GB/s");
+
+        string benchResult = $"Memory Bandwidth: {BestResult.Sum} {BestResult.Bandwidth:0.000} GB/s";
+        return benchResult;
     }
 }

OldBenchmark.cs → Benchmarks/OldBenchmark.cs

@@ -1,13 +1,7 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
-using System.Threading;
-using System.Timers;
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Running;
-using NvAPIWrapper;
-using NvAPIWrapper.Display;
-using NvAPIWrapper.GPU;
 using SharpDX.Direct3D11;
 using SharpDX.DXGI;
 using Device = SharpDX.Direct3D11.Device;