Enum boxing optimizations (UnitKey)

Directory.Packages.props

@@ -3,6 +3,7 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
+    <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.0" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />

UnitsNet.Benchmark/Conversions/FromString/QuantityFromStringBenchmarks.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.FromString;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityFromStringBenchmarks
+{
+    private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
+    private static readonly string ValueToParse = 123.456.ToString(Culture);
+
+    private readonly Random _random = new(42);
+    private string[] _quantitiesToParse;
+
+    [Params(1000)]
+    public int NbAbbreviations { get; set; }
+
+    [GlobalSetup(Target = nameof(FromMassString))]
+    public void PrepareMassStrings()
+    {
+        // can't have "mg" or "g" (see Acceleration.StandardGravity) and who knows what more...
+        _quantitiesToParse = _random.GetItems(["kg", "lbs", "Mlbs"], NbAbbreviations).Select(abbreviation => $"{ValueToParse} {abbreviation}").ToArray();
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeUnitAbbreviation))]
+    public void PrepareVolumeStrings()
+    {
+        _quantitiesToParse = _random.GetItems(["ml", "l", "cm³", "m³"], NbAbbreviations).Select(abbreviation => $"{ValueToParse} {abbreviation}").ToArray();;
+    }
+
+    [GlobalSetup(Target = nameof(FromPressureUnitAbbreviation))]
+    public void PreparePressureUnits()
+    {
+        _quantitiesToParse = _random.GetRandomAbbreviations<PressureUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations).Select(abbreviation => $"{ValueToParse} {abbreviation}").ToArray();;
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeFlowUnitAbbreviation))]
+    public void PrepareVolumeFlowUnits()
+    {
+        // can't have "bpm" (see Frequency)
+        _quantitiesToParse =
+            _random.GetItems(
+                UnitsNetSetup.Default.UnitAbbreviations.GetAllUnitAbbreviationsForQuantity(typeof(VolumeFlowUnit)).Where(x => x != "bpm").ToArray(),
+                NbAbbreviations).Select(abbreviation => $"{ValueToParse} {abbreviation}").ToArray();
+    }
+
+    [Benchmark(Baseline = true)]
+    public IQuantity FromMassString()
+    {
+        IQuantity quantity = null;
+        foreach (var quantityString in _quantitiesToParse)
+        {
+            quantity = Quantity.Parse(Culture, typeof(Mass), quantityString);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var quantityString in _quantitiesToParse)
+        {
+            quantity = Quantity.Parse(Culture, typeof(Volume), quantityString);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromPressureUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var quantityString in _quantitiesToParse)
+        {
+            quantity = Quantity.Parse(Culture, typeof(Pressure), quantityString);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeFlowUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var quantityString in _quantitiesToParse)
+        {
+            quantity = Quantity.Parse(Culture, typeof(VolumeFlow), quantityString);
+        }
+
+        return quantity;
+    }
+}

UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitAbbreviationBenchmarks.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.FromString;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityFromUnitAbbreviationBenchmarks
+{
+    private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
+    private readonly Random _random = new(42);
+    private string[] _massUnits;
+    private string[] _pressureUnits;
+    private string[] _volumeFlowUnits;
+    private string[] _volumeUnits = [];
+
+    [Params(1000)]
+    public int NbAbbreviations { get; set; }
+
+    [GlobalSetup(Target = nameof(FromMassUnitAbbreviation))]
+    public void PrepareMassUnits()
+    {
+        // can't have "mg" or "g" (see Acceleration.StandardGravity) and who knows what more...
+        _massUnits = _random.GetItems(["kg", "lbs", "Mlbs"], NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeUnitAbbreviation))]
+    public void PrepareVolumeUnits()
+    {
+        _volumeUnits = _random.GetItems(["ml", "l", "cm³", "m³"], NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromPressureUnitAbbreviation))]
+    public void PreparePressureUnits()
+    {
+        _pressureUnits = _random.GetRandomAbbreviations<PressureUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeFlowUnitAbbreviation))]
+    public void PrepareVolumeFlowUnits()
+    {
+        // can't have "bpm" (see Frequency)
+        _volumeFlowUnits =
+            _random.GetItems(
+                UnitsNetSetup.Default.UnitAbbreviations.GetAllUnitAbbreviationsForQuantity(typeof(VolumeFlowUnit)).Where(x => x != "bpm").ToArray(),
+                NbAbbreviations);
+    }
+
+    [Benchmark(Baseline = true)]
+    public IQuantity FromMassUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _massUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _volumeUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromPressureUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _pressureUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeFlowUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _volumeFlowUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+}

UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitNameBenchmarks.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace UnitsNet.Benchmark.Conversions.FromString;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityFromUnitNameBenchmarks
+{
+    private readonly Random _random = new(42);
+    private string[] _unitNames;
+
+    [Params(1000)]
+    public int NbAbbreviations { get; set; }
+
+    [GlobalSetup(Target = nameof(FromMassUnitName))]
+    public void PrepareMassUnits()
+    {
+        _unitNames = _random.GetItems(Mass.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeUnitName))]
+    public void PrepareVolumeUnits()
+    {
+        _unitNames = _random.GetItems(Volume.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromPressureUnitName))]
+    public void PreparePressureUnits()
+    {
+        _unitNames = _random.GetItems(Pressure.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeFlowUnitName))]
+    public void PrepareVolumeFlowUnits()
+    {
+        _unitNames = _random.GetItems(VolumeFlow.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+    }
+
+    [Benchmark(Baseline = true)]
+    public IQuantity FromMassUnitName()
+    {
+        IQuantity quantity = null;
+        foreach (var unitName in _unitNames)
+        {
+            quantity = Quantity.From(1, nameof(Mass), unitName);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeUnitName()
+    {
+        IQuantity quantity = null;
+        foreach (var unitName in _unitNames)
+        {
+            quantity = Quantity.From(1, nameof(Volume), unitName);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromPressureUnitName()
+    {
+        IQuantity quantity = null;
+        foreach (var unitName in _unitNames)
+        {
+            quantity = Quantity.From(1, nameof(Pressure), unitName);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeFlowUnitName()
+    {
+        IQuantity quantity = null;
+        foreach (var unitName in _unitNames)
+        {
+            quantity = Quantity.From(1, nameof(VolumeFlow), unitName);
+        }
+
+        return quantity;
+    }
+}

UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.ToString;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class ToStringWithDefaultPrecisionBenchmarks
+{
+    private static readonly double Value = 123.456;
+    private readonly Random _random = new(42);
+
+    private Mass[] _masses = [];
+    private VolumeFlow[] _volumeFlows = [];
+
+    [Params(1000)]
+    public int NbConversions { get; set; }
+
+    [Params("G", "S", "E", "N", "A")]
+    public string Format { get; set; }
+
+    [GlobalSetup(Target = nameof(MassToString))]
+    public void PrepareMassesToTest()
+    {
+        _masses = _random.GetRandomQuantities<Mass, MassUnit>(Value, Mass.Units, NbConversions).ToArray();
+    }
+
+    [GlobalSetup(Target = nameof(VolumeFlowToString))]
+    public void PrepareVolumeFlowsToTest()
+    {
+        _volumeFlows = _random.GetRandomQuantities<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units, NbConversions).ToArray();
+    }
+
+    [Benchmark(Baseline = true)]
+    public void MassToString()
+    {
+        foreach (Mass quantity in _masses)
+        {
+            var result = quantity.ToString(Format, CultureInfo.InvariantCulture);
+        }
+    }
+
+    [Benchmark]
+    public void VolumeFlowToString()
+    {
+        foreach (VolumeFlow quantity in _volumeFlows)
+        {
+            var result = quantity.ToString(Format, CultureInfo.InvariantCulture);
+        }
+    }
+}

UnitsNet.Benchmark/Conversions/ToValue/ConvertValueBenchmarks.cs

@@ -51,7 +51,7 @@ public double ConvertFromQuantity()
     [GlobalSetup]
     public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
     {
-        var nbQuantities = Quantity.Infos.Length;
+        var nbQuantities = Quantity.Infos.Count;
     }
 
 }