LibraryImport conversion

.github/workflows/ci.yml

@@ -12,7 +12,6 @@ jobs:
     - uses: actions/setup-dotnet@v3
       with:
         dotnet-version: |
-          6.0.x
           7.0.x
     - name: Install dependencies
       run: dotnet restore

.github/workflows/release.yml

@@ -10,7 +10,6 @@ jobs:
     - uses: actions/setup-dotnet@v3
       with:
         dotnet-version: |
-          6.0.x
           7.0.x
     - name: Pack
       run: dotnet pack -c Release -o pkg

bench/LibDeflate.Benchmarks/CustomAllocatorBenchmarks.cs

@@ -0,0 +1,57 @@
+using BenchmarkDotNet.Attributes;
+using LibDeflate.Imports;
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LibDeflate.Benchmarks;
+
+[MemoryDiagnoser]
+[SimpleJob]
+public class CustomAllocatorBenchmarks
+{
+    [GlobalSetup(Target = nameof(CompressorAllocCustom))]
+    public void SetCustomAllocator()
+    {
+        Console.WriteLine("Custom Allocator: set");
+        CustomMemoryAllocator.libdeflate_set_memory_allocator(malloc, free);
+
+        static nint malloc(nuint len) => Marshal.AllocHGlobal((nint)len);
+
+        static void free(nint alloc) => Marshal.FreeHGlobal(alloc);
+    }
+
+    [GlobalSetup(Target = nameof(CompressorAllocCustomUnsafe))]
+    public unsafe void SetCustomAllocatorUnsafe()
+    {
+        Console.WriteLine("Custom Unsafe Allocator: set");
+        CustomMemoryAllocator.libdeflate_set_memory_allocator_unsafe(&malloc_unsafe, &free_unsafe);
+
+        [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvCdecl) })]
+        static unsafe void* malloc_unsafe(nuint len) => NativeMemory.Alloc(len);
+
+        [UnmanagedCallersOnly(CallConvs = new[] { typeof(CallConvCdecl) })]
+        static unsafe void free_unsafe(void* alloc) => NativeMemory.Free(alloc);
+    }
+
+    [Benchmark(Baseline = true)]
+    public void CompressorAlloc()
+    {
+        var compressor = Compression.libdeflate_alloc_compressor(0);
+        Compression.libdeflate_free_compressor(compressor);
+    }
+
+    [Benchmark]
+    public void CompressorAllocCustom()
+    {
+        var compressor = Compression.libdeflate_alloc_compressor(0);
+        Compression.libdeflate_free_compressor(compressor);
+    }
+
+    [Benchmark]
+    public void CompressorAllocCustomUnsafe()
+    {
+        var compressor = Compression.libdeflate_alloc_compressor(0);
+        Compression.libdeflate_free_compressor(compressor);
+    }
+}

bench/LibDeflate.Benchmarks/DeflateCompressorBenchmarks.cs

@@ -4,56 +4,98 @@
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace LibDeflate.Benchmarks;
 
 [MemoryDiagnoser]
 [SimpleJob]
 public class DeflateCompressorBenchmarks
 {
-    public static IEnumerable<object[]> Inputs => from key in TestFiles.Keys
-                                                  from level in Levels
-                                                  select new object[] { key, level };
+    private static string AssetBase
+    {
+        get
+        {
+            var cwd = Directory.GetCurrentDirectory();
 
-    private static Dictionary<string, byte[]> TestFiles { get; } = Directory.EnumerateFiles(@"texts/")
-                .Where(fn => !Path.GetExtension(fn).Equals(".gz", StringComparison.OrdinalIgnoreCase))
-                .ToDictionary(fn => Path.GetFileNameWithoutExtension(fn), File.ReadAllBytes);
+            string assetsDir;
+            while (!Directory.Exists(assetsDir = Path.Join(cwd, "assets")))
+            {
+                cwd = Path.GetDirectoryName(cwd);
+            }
+
+            return assetsDir;
+        }
+    }
 
     private static IEnumerable<int> Levels
     {
         get
         {
-            //yield return 0;
+            yield return 0;
             yield return 1;
-            //yield return 6;
-            //yield return 9;
+            yield return -1;
+            yield return 9;
         }
     }
 
-    [Benchmark(Baseline = true)]
-    [ArgumentsSource(nameof(Inputs))]
-    public void DeflateSIO(string testFile, int level)
+    [GlobalSetup]
+    public static void PrepareTestAssets()
     {
-        var compressionLevel = level switch
+        var assetsFolder = Path.Join(AssetBase, "UncompressedTestFiles");
+        var testFiles = new Dictionary<string, byte[]>();
+        foreach (var file in Directory.EnumerateFiles(assetsFolder, null, SearchOption.AllDirectories))
         {
-            0 => CompressionLevel.NoCompression,
-            1 => CompressionLevel.Fastest,
-            6 => CompressionLevel.Optimal,
-            9 => CompressionLevel.SmallestSize
-        };
+            var key = Path.GetRelativePath(assetsFolder, file);
+            testFiles.Add(key, File.ReadAllBytes(file));
+        }
+
+        TestFiles = testFiles;
+    }
+
+    public static Dictionary<string, byte[]> TestFiles { get; set; }
 
+    public static IEnumerable<object[]> GetInputs() => from key in TestFiles.Keys
+                                                       from level in Levels
+                                                       select new object[] { key, level };
+
+#pragma warning disable CS8509 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static CompressionLevel ToLevelEnum(int level) => level switch
+    {
+        0 => CompressionLevel.NoCompression,
+        1 => CompressionLevel.Fastest,
+        -1 => CompressionLevel.Optimal,
+        9 => CompressionLevel.SmallestSize
+    };
+#pragma warning restore CS8509 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
+
+    [Benchmark(Baseline = true)]
+    [ArgumentsSource(nameof(GetInputs))]
+    public void DeflateSIO(string testFile, int level)
+    {
         var input = TestFiles[testFile];
         using var outputMs = new MemoryStream(input.Length);
-        using var deflateStream = new DeflateStream(outputMs, compressionLevel);
+        using var deflateStream = new DeflateStream(outputMs, ToLevelEnum(level));
         deflateStream.Write(input);
     }
 
     [Benchmark]
-    [ArgumentsSource(nameof(Inputs))]
-    public void DeflateLibdeflate(string testFile, int level)
+    [ArgumentsSource(nameof(GetInputs))]
+    public void DeflateLibdeflate_MemoryOwner(string testFile, int level)
     {
         var input = TestFiles[testFile];
         using var compressor = new DeflateCompressor(level);
         using var owner = compressor.Compress(input);
     }
+
+    [Benchmark]
+    [ArgumentsSource(nameof(GetInputs))]
+    public void DeflateLibdeflate_Buffer(string testFile, int level)
+    {
+        var input = TestFiles[testFile];
+        using var compressor = new DeflateCompressor(level);
+        var output = new byte[input.Length];
+        var bytesWritten = compressor.Compress(input, output);
+    }
 }

bench/LibDeflate.Benchmarks/LibDeflate.Benchmarks.csproj

@@ -2,12 +2,13 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <IsPackable>false</IsPackable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
   </ItemGroup>
 
   <ItemGroup>

bench/LibDeflate.Benchmarks/Program.cs

@@ -1,8 +1,3 @@
 using BenchmarkDotNet.Running;
 
-namespace LibDeflate.Benchmarks;
-
-public class Program
-{
-    public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
-}
+BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);

src/LibDeflate/Checksums/Adler32.cs

@@ -7,25 +7,14 @@ namespace LibDeflate.Checksums;
 
 public struct Adler32
 {
-    private bool _initialized;
-    //because we have to supply 1 as the initial value
-    //we must always retrieve this through Hash
     private uint _currentAdler;
-    public uint Hash
-    {
-        get
-        {
-            if (!_initialized)
-            {
-                _currentAdler = 1;
-                _initialized = true;
-            }
-            return _currentAdler;
-        }
-    }
+
+    public Adler32() => _currentAdler = 1;
+
+    public readonly uint Hash => _currentAdler;
 
     public void Append(ReadOnlySpan<byte> input)
-        => _currentAdler = AppendCore(Hash, input);
+        => _currentAdler = AppendCore(_currentAdler, input);
 
     public uint Compute(ReadOnlySpan<byte> input)
         => _currentAdler = AppendCore(1, input);

src/LibDeflate/Checksums/Crc32.cs

@@ -9,7 +9,7 @@ public struct Crc32
 {
     private uint _currentCrc;
 
-    public uint Hash => _currentCrc;
+    public readonly uint Hash => _currentCrc;
 
     public void Append(ReadOnlySpan<byte> input)
         => _currentCrc = AppendCore(_currentCrc, input);

src/LibDeflate/Compressor.cs

@@ -51,7 +51,7 @@ protected Compressor(int compressionLevel)
                 return null;
             }
 
-            return output.Slice(0, (int)bytesWritten);
+            return output[..(int)bytesWritten];
         }
         catch
         {

src/LibDeflate/Imports/Checksums.cs

@@ -1,27 +1,29 @@
-using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace LibDeflate.Imports;
 
-using size_t = System.UIntPtr;
+using size_t = nuint;
 
-internal static class Checksums
+internal static partial class Checksums
 {
     ///<summary>
     /// libdeflate_adler32() updates a running Adler-32 checksum with 'len' bytes of
     /// data and returns the updated checksum.  When starting a new checksum, the
     /// required initial value for 'adler' is 1.  This value is also returned when
     /// 'buffer' is specified as NULL.
     ///</summary>
-    [DllImport(Constants.DllName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern UInt32 libdeflate_adler32(UInt32 adler, in byte buffer, size_t len);
+    [LibraryImport(Constants.DllName)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial uint libdeflate_adler32(uint adler, in byte buffer, size_t len);
 
     ///<summary>
     /// libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data
     /// and returns the updated checksum.  When starting a new checksum, the required
     /// initial value for 'crc' is 0.  This value is also returned when 'buffer' is
     /// specified as NULL.
     ///</summary>
-    [DllImport(Constants.DllName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern UInt32 libdeflate_crc32(UInt32 crc, in byte buffer, size_t len);
+    [LibraryImport(Constants.DllName)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial uint libdeflate_crc32(uint crc, in byte buffer, size_t len);
 }