Vectorize TrimTransparentPixels in GifEncoderCore

[gfoidl]

Prerequisites

• I have written a descriptive pull-request title
• I have verified that there are no overlapping pull-requests open
• I have verified that I am following the existing coding patterns and practice as demonstrated in the repository. These follow strict Stylecop rules 👮.
• I have provided test coverage for my change (where applicable)

Description

See #2455 (comment)

A simple benchmark -- just for the inner loop -- yields:

| Method | Mean | Error | StdDev | Ratio |
|----------- |----------:|---------:|---------:|------:|
| Default | 102.33 ns | 2.073 ns | 2.973 ns | 1.00 |
| Vectorized | 16.53 ns | 0.065 ns | 0.055 ns | 0.16 |

This is measured with .NET 7, but the codegen for .NET 6 is very similar.

benchmark code

usingSystem.Runtime.CompilerServices;usingSystem.Runtime.InteropServices;usingSystem.Runtime.Intrinsics;usingBenchmarkDotNet.Attributes;Benchbench=new();bench.Setup();Console.WriteLine(bench.Default());Console.WriteLine(bench.Vectorized());
#if !DEBUGBenchmarkDotNet.Running.BenchmarkRunner.Run<Bench>();
#endif
publicclassBench{privatebyte[]_rowSpan=null!;privatebyte_trimmableIndex;[GlobalSetup]publicvoidSetup(){_rowSpan=newbyte[100];_rowSpan.AsSpan().Fill(42);_rowSpan.AsSpan(25,9).Clear();_trimmableIndex=42;}[Benchmark(Baseline=true)]public(intleft,intright,boolisTransparentRow)Default(){Span<byte>rowSpan=_rowSpan;bytetrimmableIndex=_trimmableIndex;intleft=int.MaxValue;intright=int.MinValue;boolisTransparentRow=true;for(intx=0;x<rowSpan.Length;++x){if(rowSpan[x]!=trimmableIndex){isTransparentRow=false;left=Math.Min(left,x);right=Math.Max(right,x);}}if(left==int.MaxValue){left=0;}if(right==int.MinValue){right=rowSpan.Length;}return(left,right,isTransparentRow);}[Benchmark]public(intleft,intright,boolisTransparentRow)Vectorized(){Span<byte>rowSpan=_rowSpan;bytetrimmableIndex=_trimmableIndex;intleft=int.MaxValue;intright=int.MinValue;boolisTransparentRow=true;refbyterowPtr=refMemoryMarshal.GetReference(rowSpan);nintrowLength=(nint)(uint)rowSpan.Length;nintx=0;if(Vector128.IsHardwareAccelerated&&rowLength>=Vector128<byte>.Count){Vector256<byte>trimmableVec256=Vector256.Create(trimmableIndex);if(Vector256.IsHardwareAccelerated&&rowLength>=Vector256<byte>.Count){do{Vector256<byte>vec=Vector256.LoadUnsafe(refrowPtr,(nuint)x);Vector256<byte>notEquals=~Vector256.Equals(vec,trimmableVec256);if(notEquals!=Vector256<byte>.Zero){isTransparentRow=false;uintmask=notEquals.ExtractMostSignificantBits();nintstart=x+(nint)uint.TrailingZeroCount(mask);nintend=(nint)uint.LeadingZeroCount(mask);// end is from the end, but we need the index from the beginningend=x+Vector256<byte>.Count-1-end;left=Math.Min(left,(int)start);right=Math.Max(right,(int)end);}x+=Vector256<byte>.Count;}while(x<=rowLength-Vector256<byte>.Count);}Vector128<byte>trimmableVec=Vector256.IsHardwareAccelerated?trimmableVec256.GetLower():Vector128.Create(trimmableIndex);while(x<=rowLength-Vector128<byte>.Count){Vector128<byte>vec=Vector128.LoadUnsafe(refrowPtr,(nuint)x);Vector128<byte>notEquals=~Vector128.Equals(vec,trimmableVec);if(notEquals!=Vector128<byte>.Zero){isTransparentRow=false;uintmask=notEquals.ExtractMostSignificantBits();nintstart=x+(nint)uint.TrailingZeroCount(mask);nintend=(nint)uint.LeadingZeroCount(mask)-Vector128<byte>.Count;// end is from the end, but we need the index from the beginningend=x+Vector128<byte>.Count-1-end;left=Math.Min(left,(int)start);right=Math.Max(right,(int)end);}x+=Vector128<byte>.Count;}}for(;x<rowLength;++x){if(Unsafe.Add(refrowPtr,x)!=trimmableIndex){isTransparentRow=false;left=Math.Min(left,(int)x);right=Math.Max(right,(int)x);}}if(left==int.MaxValue){left=0;}if(right==int.MinValue){right=(int)rowLength;}return(left,right,isTransparentRow);}}

[gfoidl]

Some notes for review.

[gfoidl]

At the moment I don't have any idea on how to make this branchless.
isTransparentRow could be tracked in a vector, but left and right not, as there's a mismatch of vector-types, namely byte and int.

A quite complicated approach would be to use VectorXYZ<byte> and track the left and right -- but just before these can overflow merge it back to the scalar left, right and start over. But I guess the book-keeping is more work, so I'm not sure if this is actually faster. For sure the code gets painful.

[gfoidl]

The remainder could be handled vectorized too, by shifting the mask of the most significant bits around by the count of elements left in the final vector.
I tried this somewhere else, the cost for that book-keeping isn't negligible, so didn't do this here and now (maybe I'll try this later).

[JimBobSquarePants]

Oof! Look at those numbers!! Thanks so much for looking at this. I'm going have a good dig through it to wrap my head round what you have done.

[gfoidl]

😃
I think the easiest way to understand / check is to use the benchmark-code (see top-comment) in a simple console app and step with the debugger through it (maybe change the size of the _rowSpan to 20 or that like.
Calculation of the correct index for end is the strangest part IMO.

PS: I'm back on Tuesday, so maybe slow to respond in the meantime.

[JimBobSquarePants]

This is fantastic stuff. I figured theoretically after reading some of the source for Span.IndexOf that masking with bit counting would be the vectorized solution I just had no idea how I'd actually implement it.

Tip of the cap to you sir.

[gfoidl]

Thanks for the kind words ❤️