mirror of https://github.com/SixLabors/ImageSharp
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 lines
8.2 KiB
173 lines
8.2 KiB
// Copyright (c) Six Labors.
|
|
// Licensed under the Six Labors Split License.
|
|
|
|
using System.Buffers;
|
|
using System.Numerics;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.Intrinsics;
|
|
using System.Runtime.Intrinsics.X86;
|
|
using BenchmarkDotNet.Attributes;
|
|
using SixLabors.ImageSharp.Memory;
|
|
using SixLabors.ImageSharp.PixelFormats;
|
|
|
|
// ReSharper disable InconsistentNaming
|
|
namespace SixLabors.ImageSharp.Benchmarks.Bulk;
|
|
|
|
[Config(typeof(Config.Short))]
|
|
public abstract class FromVector4<TPixel>
|
|
where TPixel : unmanaged, IPixel<TPixel>
|
|
{
|
|
protected IMemoryOwner<Vector4> Source { get; set; }
|
|
|
|
protected IMemoryOwner<TPixel> Destination { get; set; }
|
|
|
|
protected Configuration Configuration => Configuration.Default;
|
|
|
|
// [Params(64, 2048)]
|
|
[Params(64, 256, 2048)]
|
|
public int Count { get; set; }
|
|
|
|
[GlobalSetup]
|
|
public void Setup()
|
|
{
|
|
this.Destination = this.Configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
|
|
this.Source = this.Configuration.MemoryAllocator.Allocate<Vector4>(this.Count);
|
|
}
|
|
|
|
[GlobalCleanup]
|
|
public void Cleanup()
|
|
{
|
|
this.Destination.Dispose();
|
|
this.Source.Dispose();
|
|
}
|
|
|
|
// [Benchmark]
|
|
public void PerElement()
|
|
{
|
|
ref Vector4 s = ref MemoryMarshal.GetReference(this.Source.GetSpan());
|
|
ref TPixel d = ref MemoryMarshal.GetReference(this.Destination.GetSpan());
|
|
for (nuint i = 0; i < (uint)this.Count; i++)
|
|
{
|
|
Unsafe.Add(ref d, i) = TPixel.FromVector4(Unsafe.Add(ref s, i));
|
|
}
|
|
}
|
|
|
|
[Benchmark(Baseline = true)]
|
|
public void PixelOperations_Base()
|
|
=> new PixelOperations<TPixel>().FromVector4Destructive(this.Configuration, this.Source.GetSpan(), this.Destination.GetSpan());
|
|
|
|
[Benchmark]
|
|
public void PixelOperations_Specialized()
|
|
=> PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, this.Source.GetSpan(), this.Destination.GetSpan());
|
|
}
|
|
|
|
public class FromVector4Rgba32 : FromVector4<Rgba32>
|
|
{
|
|
[Benchmark]
|
|
public void FallbackIntrinsics128()
|
|
{
|
|
Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.Source.GetSpan());
|
|
Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.Destination.GetSpan());
|
|
|
|
SimdUtils.FallbackIntrinsics128.NormalizedFloatToByteSaturate(sBytes, dFloats);
|
|
}
|
|
|
|
[Benchmark]
|
|
public void ExtendedIntrinsic()
|
|
{
|
|
Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.Source.GetSpan());
|
|
Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.Destination.GetSpan());
|
|
|
|
SimdUtils.ExtendedIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
|
|
}
|
|
|
|
[Benchmark]
|
|
public void UseHwIntrinsics()
|
|
{
|
|
Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.Source.GetSpan());
|
|
Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.Destination.GetSpan());
|
|
|
|
SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
|
|
}
|
|
|
|
private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 };
|
|
|
|
[Benchmark]
|
|
public void UseAvx2_Grouped()
|
|
{
|
|
Span<float> src = MemoryMarshal.Cast<Vector4, float>(this.Source.GetSpan());
|
|
Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(this.Destination.GetSpan());
|
|
|
|
nuint n = (uint)dest.Length / (uint)Vector<byte>.Count;
|
|
|
|
ref Vector256<float> sourceBase = ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(src));
|
|
ref Vector256<byte> destBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest));
|
|
|
|
ref byte maskBase = ref MemoryMarshal.GetReference(PermuteMaskDeinterleave8x32);
|
|
Vector256<int> mask = Unsafe.As<byte, Vector256<int>>(ref maskBase);
|
|
|
|
Vector256<float> maxBytes = Vector256.Create(255f);
|
|
|
|
for (nuint i = 0; i < n; i++)
|
|
{
|
|
ref Vector256<float> s = ref Unsafe.Add(ref sourceBase, i * 4);
|
|
|
|
Vector256<float> f0 = s;
|
|
Vector256<float> f1 = Unsafe.Add(ref s, 1);
|
|
Vector256<float> f2 = Unsafe.Add(ref s, 2);
|
|
Vector256<float> f3 = Unsafe.Add(ref s, 3);
|
|
|
|
f0 = Avx.Multiply(maxBytes, f0);
|
|
f1 = Avx.Multiply(maxBytes, f1);
|
|
f2 = Avx.Multiply(maxBytes, f2);
|
|
f3 = Avx.Multiply(maxBytes, f3);
|
|
|
|
Vector256<int> w0 = Avx.ConvertToVector256Int32(f0);
|
|
Vector256<int> w1 = Avx.ConvertToVector256Int32(f1);
|
|
Vector256<int> w2 = Avx.ConvertToVector256Int32(f2);
|
|
Vector256<int> w3 = Avx.ConvertToVector256Int32(f3);
|
|
|
|
Vector256<short> u0 = Avx2.PackSignedSaturate(w0, w1);
|
|
Vector256<short> u1 = Avx2.PackSignedSaturate(w2, w3);
|
|
Vector256<byte> b = Avx2.PackUnsignedSaturate(u0, u1);
|
|
b = Avx2.PermuteVar8x32(b.AsInt32(), mask).AsByte();
|
|
|
|
Unsafe.Add(ref destBase, i) = b;
|
|
}
|
|
}
|
|
|
|
/*
|
|
BenchmarkDotNet v0.13.10, Windows 11 (10.0.22631.3085/23H2/2023Update/SunValley3)
|
|
11th Gen Intel Core i7-11370H 3.30GHz, 1 CPU, 8 logical and 4 physical cores
|
|
.NET SDK 8.0.200-preview.23624.5
|
|
[Host] : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
|
|
Job-YJYLLR : .NET 8.0.1 (8.0.123.58001), X64 RyuJIT AVX2
|
|
|
|
Runtime=.NET 8.0 Arguments=/p:DebugType=portable IterationCount=3
|
|
LaunchCount=1 WarmupCount=3
|
|
|
|
| Method | Count | Mean | Error | StdDev | Ratio | RatioSD | Allocated | Alloc Ratio |
|
|
|---------------------------- |------ |------------:|-------------:|-----------:|------:|--------:|----------:|------------:|
|
|
| PixelOperations_Base | 64 | 114.80 ns | 16.459 ns | 0.902 ns | 1.00 | 0.00 | - | NA |
|
|
| PixelOperations_Specialized | 64 | 28.91 ns | 80.482 ns | 4.411 ns | 0.25 | 0.04 | - | NA |
|
|
| FallbackIntrinsics128 | 64 | 133.60 ns | 23.750 ns | 1.302 ns | 1.16 | 0.02 | - | NA |
|
|
| ExtendedIntrinsic | 64 | 40.11 ns | 10.183 ns | 0.558 ns | 0.35 | 0.01 | - | NA |
|
|
| UseHwIntrinsics | 64 | 14.71 ns | 4.860 ns | 0.266 ns | 0.13 | 0.00 | - | NA |
|
|
| UseAvx2_Grouped | 64 | 20.23 ns | 11.619 ns | 0.637 ns | 0.18 | 0.00 | - | NA |
|
|
| | | | | | | | | |
|
|
| PixelOperations_Base | 256 | 387.94 ns | 31.591 ns | 1.732 ns | 1.00 | 0.00 | - | NA |
|
|
| PixelOperations_Specialized | 256 | 50.93 ns | 22.388 ns | 1.227 ns | 0.13 | 0.00 | - | NA |
|
|
| FallbackIntrinsics128 | 256 | 509.72 ns | 249.926 ns | 13.699 ns | 1.31 | 0.04 | - | NA |
|
|
| ExtendedIntrinsic | 256 | 140.32 ns | 9.353 ns | 0.513 ns | 0.36 | 0.00 | - | NA |
|
|
| UseHwIntrinsics | 256 | 41.99 ns | 16.000 ns | 0.877 ns | 0.11 | 0.00 | - | NA |
|
|
| UseAvx2_Grouped | 256 | 63.81 ns | 2.360 ns | 0.129 ns | 0.16 | 0.00 | - | NA |
|
|
| | | | | | | | | |
|
|
| PixelOperations_Base | 2048 | 2,979.49 ns | 2,023.706 ns | 110.926 ns | 1.00 | 0.00 | - | NA |
|
|
| PixelOperations_Specialized | 2048 | 326.19 ns | 19.077 ns | 1.046 ns | 0.11 | 0.00 | - | NA |
|
|
| FallbackIntrinsics128 | 2048 | 3,885.95 ns | 411.078 ns | 22.533 ns | 1.31 | 0.05 | - | NA |
|
|
| ExtendedIntrinsic | 2048 | 1,078.58 ns | 136.960 ns | 7.507 ns | 0.36 | 0.01 | - | NA |
|
|
| UseHwIntrinsics | 2048 | 312.07 ns | 68.662 ns | 3.764 ns | 0.10 | 0.00 | - | NA |
|
|
| UseAvx2_Grouped | 2048 | 451.83 ns | 41.742 ns | 2.288 ns | 0.15 | 0.01 | - | NA |
|
|
*/
|
|
}
|
|
|