Decompose some bitwise operations in HIR to allow more overall optimizations to kick in by tannergooding · Pull Request #104517 · dotnet/runtime

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

tannergooding · 2024-07-07T06:24:14Z

Doing this allows more scenarios involving CSE, morph transforms, and other optimizations to kick in. This will also longer term allow ~Compare to be optimized to the inverse comparison as well.

When such optimizations aren't feasible, we still end up getting the good codegen in lowering anyways.

…zations to kick in

…nopts

tannergooding · 2024-07-09T05:03:30Z

CC. @dotnet/jit-contrib, this is ready for review.

It gives some nice improvements on both Arm64 and x64 due to additional optimization opportunities. On xarch in particular it also gives better codegen almost anywhere vpternlog can be used and handles more (but not all) of the possible vpternlog lightups.

There are a couple methods where the code size has increased, rather than decreased, due to vpternlog but its a minority overall and typically due to 2 of the inputs being containable. These should be addressable, but I'd rather do that separately since this is still a large net improvement (generally speaking this should entail checking if two operands are containable and opting to not combine them into a vpternlog in that scenario).

tannergooding · 2024-07-09T05:03:54Z

The SPMI replay failure is #104585

tannergooding · 2024-07-10T14:38:24Z

Rerunning now that the SPMI replay issue should be fixed. This should still be ready for review and notably also fixes some issues that were found by antigen

EgorBo · 2024-07-12T21:35:52Z

+ // We specially handle this here since we're only producing a
+ // native intrinsic node in LIR
+
+ std::swap(op1, op2);


can you remind me - is it fine to do this swap here in terms of side-effect reordering?

ah, it's LIR so I guess it is

Right, in this case its fine specifically because we've validated we're in LIR already.
Otherwise, we should be applying GTF_REVERSE_OPS or have some comment about expecting the user to have already spilled side effects, etc.

EgorBo

Changes LGTM assuming CI failures are unrelated

ghost added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label Jul 7, 2024

dotnet-policy-serviceBot assigned tannergooding Jul 7, 2024

Decompose some bitwise operations in HIR to allow more overall optimi…
3a05e3b
…zations to kick in

tannergooding force-pushed the simd-andn branch from d3ba163 to 3a05e3bCompare July 7, 2024 07:03

This was referenced Jul 7, 2024
[x86] stress failure in RayTracer.GetNaturalColor with DOTNET_JitStress=2 #102590
Closed
Assertion in BigIntegerCalculator #103247
Closed
System.Numerics.Tensors.Tests.TensorSpanTests test failure #103525
Closed

JakeYallop mentioned this pull request Jul 7, 2024
Struct with self-referencing ImmutableArray static field causes TypeLoadException#104519
Closed

tannergooding added 5 commits July 7, 2024 07:12

Ensure that we actually remove the underlying op
51ece71

Ensure the AND_NOT decomposition is still folded during import for mi…
7574110
…nopts

Ensure we propagate AllBitsSet into simd GT_XOR on xarch
3ad1ec2

Ensure that we prefer AndNot over TernaryLogic
d08dcb4

Cleanup the TernaryLogic lowering code
2c93a18

tannergooding force-pushed the simd-andn branch from e2511b0 to 2c93a18Compare July 8, 2024 02:22

This was referenced Jul 8, 2024
The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#3008
Open
The job running on agent NetCore-Public ran longer than the maximum time #104044
Closed

tannergooding force-pushed the simd-andn branch from c83165c to 5e7aaeeCompare July 8, 2024 09:03

build-analysisBot mentioned this pull request Jul 8, 2024
Test failure: GC\\Features\\HeapExpansion\\Finalizer\\Finalizer.cmd #102706
Closed

tannergooding force-pushed the simd-andn branch 2 times, most recently from 5c68e29 to 5d85173Compare July 8, 2024 15:50

Ensure that TernaryLogic picks the best operand for containment
763997c

tannergooding force-pushed the simd-andn branch from 5d85173 to 763997cCompare July 8, 2024 16:08

This was referenced Jul 8, 2024
LibraryImportGenerator.Unit.Tests crashing on linux-x64 mono interpreter #100800
Open
[mono][interpreter] Mono interpreter is crashing during System.Data.Odbc.Tests (linux-x64 Release Mono_Interpreter_LibrariesTests) #101370
Closed

tannergooding added 4 commits July 8, 2024 13:21

Ensure we swap the operands that are being checked for containment
bd9f4f6

Ensure that TernaryLogic is simplified where possible
c4b0c3a

Merge remote-tracking branch 'dotnet/main' into simd-andn
c5080de

Apply formatting patch
5dfc7ed

tannergooding marked this pull request as ready for review July 9, 2024 04:59

Merge branch 'main' into simd-andn
083686c

tannergooding mentioned this pull request Jul 11, 2024
Replace use of target dependent TestZ intrinsic #104488
Merged

Merge branch 'main' into simd-andn
4e7ca77

EgorBo reviewed Jul 12, 2024
View reviewed changes

EgorBo approved these changes Jul 12, 2024
View reviewed changes

Merge branch 'main' into simd-andn
af92525

build-analysisBot mentioned this pull request Jul 13, 2024
The "RestoreTask" task returned false but did not log an error dotnet/dnceng#3100
Closed
3 tasks

tannergooding merged commit 6d3cb53 into dotnet:mainJul 13, 2024

tannergooding deleted the simd-andn branch July 13, 2024 14:01

This was referenced Jul 16, 2024
[Perf] Windows/x64: 9 Improvements on 7/10/2024 10:56:31 PM dotnet/perf-autofiling-issues#38347
Closed
[Perf] Linux/x64: 6 Improvements on 7/13/2024 3:15:31 PM dotnet/perf-autofiling-issues#38383
Closed

AndyAyersMS mentioned this pull request Jul 27, 2024
unreliable codegen around vbroadcastss in .NET 8 release builds #96156
Closed

github-actionsBot locked and limited conversation to collaborators Aug 13, 2024