Additional Perf. Optimizations

src/VCDiff.Benchmark/Program.cs

@@ -0,0 +1,14 @@
+using System;
+using BenchmarkDotNet.Running;
+
+namespace VCDiff.Benchmark
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            BenchmarkRunner.Run<RandomDataDecode>();
+            BenchmarkRunner.Run<RandomDataEncode>();
+        }
+    }
+}

src/VCDiff.Benchmark/RandomDataDecode.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using VCDiff.Decoders;
+using VCDiff.Encoders;
+
+namespace VCDiff.Benchmark
+{
+    [MemoryDiagnoser()]
+    [SimpleJob(1, 3, 8)]
+    public class RandomDataDecode
+    {
+        [Params(//1 * 1024 * 256,  // 0.25MiB
+            //1 * 1024 * 1024, // 2 MiB
+            16 * 1024 * 1024 // 16 MiB
+        )]
+        public int Bytes { get; set; }
+
+        [Params(32)] // AVX Only
+        //[Params(16, 32)] // AVX vs SSE
+        public int BlockSize { get; set; }
+
+        private const int RepeatCount = 128;
+        private byte[] _data;
+        private Stream _patchSlightModified;
+        private Stream _patchHeavyModified;
+
+        private Stream _sourceStream;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            _data = RandomDataGenerator.GetRandomBytes(Bytes);
+            RandomDataEncode.MakeRandomData(_data, out var dataSlightModified, out var dataHeavyModified);
+
+            // Make Source Stream
+            _sourceStream = new MemoryStream(_data);
+
+            // Make Slightly Mod Patch
+            CreatePatch(dataSlightModified, ref _patchSlightModified);
+            CreatePatch(dataHeavyModified, ref _patchHeavyModified);
+        }
+
+        private void CreatePatch(byte[] targetData, ref Stream receiver)
+        {
+            _sourceStream.Seek(0, SeekOrigin.Begin);
+            receiver = new MemoryStream(_data.Length);
+            using var targetStream = new MemoryStream(targetData);
+            using var encoder = new VcEncoder(_sourceStream, targetStream, receiver, 1, BlockSize);
+            encoder.Encode();
+        }
+
+        [Benchmark]
+        public void DecodeSlightlyModified()
+        {
+            using var result = new MemoryStream((int)_sourceStream.Length);
+            for (int x = 0; x < RepeatCount; x++)
+            {
+                _sourceStream.Seek(0, SeekOrigin.Begin);
+                _patchSlightModified.Seek(0, SeekOrigin.Begin);
+                result.Position = 0;
+                using var decoder = new VcDecoder(_sourceStream, _patchSlightModified, result, int.MaxValue);
+                decoder.Decode(out long written);
+            }
+        }
+
+        [Benchmark]
+        public void DecodeHeavilyModified()
+        {
+            using var result = new MemoryStream((int)_sourceStream.Length);
+            for (int x = 0; x < RepeatCount; x++)
+            {
+                _sourceStream.Seek(0, SeekOrigin.Begin);
+                _patchHeavyModified.Seek(0, SeekOrigin.Begin);
+                result.Position = 0;
+                using var decoder = new VcDecoder(_sourceStream, _patchHeavyModified, result, int.MaxValue);
+                decoder.Decode(out long written);
+            }
+        }
+    }
+}

src/VCDiff.Benchmark/RandomDataEncode.cs

@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using VCDiff.Encoders;
+
+namespace VCDiff.Benchmark
+{
+    [MemoryDiagnoser()]
+    [SimpleJob(1, 3, 8)]
+    public class RandomDataEncode
+    {
+        [Params(//1 * 1024 * 256,  // 0.25MiB
+                //1 * 1024 * 1024, // 2 MiB
+                16 * 1024 * 1024 // 16 MiB
+                )]
+        public int Bytes { get; set; }
+
+        [Params(32)] // AVX Only
+        //[Params(16, 32)] // AVX vs SSE
+        public int BlockSize { get; set; }
+
+        private byte[] _data;
+        private byte[] _dataSlightModified;
+        private byte[] _dataHeavyModified;
+
+        private Stream _sourceStream;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            _data = RandomDataGenerator.GetRandomBytes(Bytes);
+            MakeRandomData(_data, out _dataSlightModified, out _dataHeavyModified);
+            _sourceStream = new MemoryStream(_data);
+        }
+
+        [IterationSetup]
+        public void IterationSetup() => _sourceStream.Seek(0, SeekOrigin.Begin);
+
+        [Benchmark]
+        public void EncodeSlightlyModified()
+        {
+            using var targetStream = new MemoryStream(_dataSlightModified);
+            using var patchStream  = new MemoryStream(_data.Length);
+
+            using var encoder = new VcEncoder(_sourceStream, targetStream, patchStream, 1, BlockSize);
+            encoder.Encode();
+        }
+
+        [Benchmark]
+        public void EncodeHeavilyModified()
+        {
+            using var targetStream = new MemoryStream(_dataHeavyModified);
+            using var patchStream  = new MemoryStream(_data.Length);
+
+            using var encoder = new VcEncoder(_sourceStream, targetStream, patchStream, 1, BlockSize);
+            encoder.Encode();
+        }
+
+
+        // Utility Methods
+        public static void MakeRandomData(byte[] data, out byte[] dataSlightModified, out byte[] dataHeavyModified)
+        {
+            dataSlightModified = (byte[])data.Clone();
+            dataHeavyModified = (byte[])data.Clone();
+
+            var random = new Random(data.Length);
+            for (int x = 0; x < dataHeavyModified.Length; x++)
+            {
+                var next = random.Next(0, 1000);
+                if (next >= 250) // 3 / 4 chance.
+                    dataHeavyModified[x] += (byte)next;
+                if (next >= 995) // 1 / 200 chance.
+                    dataSlightModified[x] += (byte)next;
+            }
+        }
+    }
+}

src/VCDiff.Benchmark/RandomDataGenerator.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace VCDiff.Benchmark
+{
+    /// <summary>
+    /// Generates random data.
+    /// </summary>
+    public static class RandomDataGenerator
+    {
+        public static byte[] GetRandomBytes(int size)
+        {
+            var data = new byte[size];
+            var random = new Random(size);
+            for (int x = 0; x < data.Length; x++)
+                data[x] = (byte)random.Next();
+
+            return data;
+        }
+    }
+}

src/VCDiff.Benchmark/VCDiff.Benchmark.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\VCDiff\VCDiff.csproj" />
+  </ItemGroup>
+
+</Project>

src/VCDiff.Tests/FileDiffTests.cs

@@ -522,18 +522,14 @@ public void MaxFileSize_Test()
             long bytesWritten = 0;
 
             using VcDecoder decoder = new VcDecoder(srcStream, deltaStream, outputStream, -1);
-            ArgumentException ex = Assert.Throws<ArgumentException>(() => decoder.Decode(out bytesWritten));
-            Assert.Matches(@"maxWindowSize must be a positive value", ex.Message);
+            Assert.Throws<ArgumentException>(() => decoder.Decode(out bytesWritten));
 
             srcStream.Position = 0;
             targetStream.Position = 0;
             deltaStream.Position = 0;
 
-            using VcDecoder decoder1 = new VcDecoder(srcStream, deltaStream, outputStream, 2);
-            InvalidOperationException ex1 = Assert.Throws<InvalidOperationException>(() => decoder1.Decode(out bytesWritten));
-            Assert.Matches(@"Length of target window \(\d*\) exceeds limit of 2 bytes", ex1.Message);
-
-
+            using VcDecoder decoder1 = new VcDecoder(srcStream, deltaStream, outputStream, 2); 
+            Assert.Throws<InvalidOperationException>(() => decoder1.Decode(out bytesWritten));
         }
     }
 }

src/VCDiff.sln

@@ -5,7 +5,9 @@ VisualStudioVersion = 16.0.29721.120
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VCDiff", "VCDiff\VCDiff.csproj", "{4D676F4E-E66D-4A41-861F-600F0FFCD052}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VCDiff.Tests", "VCDiff.Tests\VCDiff.Tests.csproj", "{724A8CFC-F566-47BB-ABE7-2A7DF5EC4E66}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VCDiff.Tests", "VCDiff.Tests\VCDiff.Tests.csproj", "{724A8CFC-F566-47BB-ABE7-2A7DF5EC4E66}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VCDiff.Benchmark", "VCDiff.Benchmark\VCDiff.Benchmark.csproj", "{29FF95D4-B9BF-480B-B0F1-E5A0BAEAAA82}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -21,6 +23,10 @@ Global
 		{724A8CFC-F566-47BB-ABE7-2A7DF5EC4E66}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{724A8CFC-F566-47BB-ABE7-2A7DF5EC4E66}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{724A8CFC-F566-47BB-ABE7-2A7DF5EC4E66}.Release|Any CPU.Build.0 = Release|Any CPU
+		{29FF95D4-B9BF-480B-B0F1-E5A0BAEAAA82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{29FF95D4-B9BF-480B-B0F1-E5A0BAEAAA82}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{29FF95D4-B9BF-480B-B0F1-E5A0BAEAAA82}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{29FF95D4-B9BF-480B-B0F1-E5A0BAEAAA82}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE