Skip to content

JpegEncoder - Optimize Some Low Hanging Fruit #1533

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
JimBobSquarePants merged 15 commits into from
Feb 4, 2021
Merged

JpegEncoder - Optimize Some Low Hanging Fruit #1533

Changes from 1 commit
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
b3e40c1
Use less expensive update for RowOctet
JimBobSquarePants Jan 27, 2021
9d74ef4
Merge branch 'master' into js/jpeg-encoder-perf
JimBobSquarePants Feb 3, 2021
5398b40
Update RowOctet tests
JimBobSquarePants Feb 3, 2021
2a4b696
Remove bounds checks during Emit
JimBobSquarePants Feb 3, 2021
f3baa34
Add AVX Block8x8F.DivideRoundAll
JimBobSquarePants Feb 3, 2021
7e37d3d
Fix typo
JimBobSquarePants Feb 3, 2021
dee1bfc
Remove compiler conditional for static fields
JimBobSquarePants Feb 3, 2021
ca56515
Disable inlining
JimBobSquarePants Feb 3, 2021
3ff1c27
manually inline meythod
JimBobSquarePants Feb 3, 2021
a1042ce
Try explicit layout
JimBobSquarePants Feb 3, 2021
f87b38c
Move statics to local
JimBobSquarePants Feb 3, 2021
6f367ca
Update Block8x8F.cs
JimBobSquarePants Feb 3, 2021
aa8dcd9
Use a loop instead.
JimBobSquarePants Feb 3, 2021
14226ce
Cleanup
JimBobSquarePants Feb 3, 2021
461e59d
Optimize and fix warnings.
JimBobSquarePants Feb 4, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Update Block8x8F.cs
  • Loading branch information
@JimBobSquarePants
JimBobSquarePants committed Feb 3, 2021
commit 6f367caaa48086c8ced365ee0826ddf68cd86a7c
113 changes: 35 additions & 78 deletions src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -555,102 +555,59 @@ private static unsafe void Scale16X16To8X8Scalar(ref Block8x8F destination, Read
private static void DivideRoundAll(ref Block8x8F a, ref Block8x8F b)
{
#if SUPPORTS_RUNTIME_INTRINSICS

// Avx version is written inline to avoid JIT bugs on MacOS.
if (Avx.IsSupported)
{
var vneg = new Vector<float>(-1F);
var vadd = new Vector<float>(.5F);
var vnegOne = Vector256.Create(-1f);
var vadd = Vector256.Create(.5F);
var vone = Vector256.Create(1f);

// V0
Vector<float> vs = Unsafe.As<Vector4, Vector<float>>(ref a.V0L);
Vector<float> voff
= Vector.Min(Vector.Max(vneg, vs), Vector<float>.One)
* vadd;

Vector256<float> v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V0L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V0L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs0 = Unsafe.As<Vector4, Vector256<float>>(ref a.V0L);
Vector256<float> voff0 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs0), vone), vadd);
Vector256<float> v0 = Avx.Divide(vs0, Unsafe.As<Vector4, Vector256<float>>(ref b.V0L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V0L) = Avx.Add(v0, voff0);

// V1
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V1L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V1L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V1L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs1 = Unsafe.As<Vector4, Vector256<float>>(ref a.V1L);
Vector256<float> voff1 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs1), vone), vadd);
Vector256<float> v1 = Avx.Divide(vs1, Unsafe.As<Vector4, Vector256<float>>(ref b.V1L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V1L) = Avx.Add(v1, voff1);

// V2
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V2L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V2L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V2L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs2 = Unsafe.As<Vector4, Vector256<float>>(ref a.V2L);
Vector256<float> voff2 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs2), vone), vadd);
Vector256<float> v2 = Avx.Divide(vs2, Unsafe.As<Vector4, Vector256<float>>(ref b.V2L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V2L) = Avx.Add(v2, voff2);

// V3
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V3L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V3L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V3L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs3 = Unsafe.As<Vector4, Vector256<float>>(ref a.V3L);
Vector256<float> voff3 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs3), vone), vadd);
Vector256<float> v3 = Avx.Divide(vs3, Unsafe.As<Vector4, Vector256<float>>(ref b.V3L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V3L) = Avx.Add(v3, voff3);

// V4
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V4L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V4L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V4L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs4 = Unsafe.As<Vector4, Vector256<float>>(ref a.V4L);
Vector256<float> voff4 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs4), vone), vadd);
Vector256<float> v4 = Avx.Divide(vs4, Unsafe.As<Vector4, Vector256<float>>(ref b.V4L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V4L) = Avx.Add(v4, voff4);

// V5
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V5L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V5L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V5L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs5 = Unsafe.As<Vector4, Vector256<float>>(ref a.V5L);
Vector256<float> voff5 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs5), vone), vadd);
Vector256<float> v5 = Avx.Divide(vs5, Unsafe.As<Vector4, Vector256<float>>(ref b.V5L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V5L) = Avx.Add(v5, voff5);

// V6
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V6L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V6L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V6L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs6 = Unsafe.As<Vector4, Vector256<float>>(ref a.V6L);
Vector256<float> voff6 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs6), vone), vadd);
Vector256<float> v6 = Avx.Divide(vs6, Unsafe.As<Vector4, Vector256<float>>(ref b.V6L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V6L) = Avx.Add(v6, voff6);

// V7
vs = Unsafe.As<Vector4, Vector<float>>(ref a.V7L);
voff = Vector.Min(Vector.Max(vneg, vs), Vector<float>.One) * vadd;

v = Avx.Divide(
Unsafe.As<Vector<float>, Vector256<float>>(ref vs),
Unsafe.As<Vector4, Vector256<float>>(ref b.V7L));

Unsafe.As<Vector4, Vector256<float>>(ref a.V7L)
= Avx.Add(v, Unsafe.As<Vector<float>, Vector256<float>>(ref voff));
Vector256<float> vs7 = Unsafe.As<Vector4, Vector256<float>>(ref a.V7L);
Vector256<float> voff7 = Avx.Multiply(Avx.Min(Avx.Max(vnegOne, vs7), vone), vadd);
Vector256<float> v7 = Avx.Divide(vs7, Unsafe.As<Vector4, Vector256<float>>(ref b.V7L));
Unsafe.As<Vector4, Vector256<float>>(ref a.V7L) = Avx.Add(v7, voff7);
}
else
#endif
Expand Down