[NativeAOT] Make casting logic closer to CoreCLR #89548

VSadov · 2023-07-27T06:19:06Z

The actual changes are not as big here as might seem. For the most part this is a refactoring of existing code to have a shape closer to CoreCLR cast helpers, so that similar patterns could be used - in a few places where that has not been done already in earlier changes.
For example cases like CheckCastAny - could start with a cache lookup, since uncached code path can be complex and thus relatively slow. (also addresses some old TODOs in this area)

ghost · 2023-07-27T06:19:23Z

Tagging subscribers to this area: @agocke, @MichalStrehovsky, @jkotas
See info in area-owners.md if you want to be subscribed.

Issue Details

Fixes: #84464

In progress.

For the most part this is a refactoring of existing code to have a shape closer to CoreCLR. In particular to do cache lookups earlier.
Cases like CheckCastAny - we should basically start with a cache lookup, since uncached path can be relatively slow.

Author:	VSadov
Assignees:	-
Labels:	`area-NativeAOT-coreclr`
Milestone:	-

VSadov · 2023-07-27T06:55:10Z

/azp run runtime-extra-platforms

azure-pipelines · 2023-07-27T06:55:22Z

Azure Pipelines successfully started running 1 pipeline(s).

VSadov · 2023-08-01T17:55:28Z

I think this is ready for a review.

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs

jkotas · 2023-08-01T18:45:16Z

Could you please collect numbers for casting microbenchmarks before/after this change?

jkotas · 2023-08-01T18:51:18Z

src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs

@@ -694,32 +694,29 @@ private ISymbolNode GetHelperFtnUncached(CorInfoHelpFunc ftnNum)
                    break;

                case CorInfoHelpFunc.CORINFO_HELP_CHKCASTANY:
+                case CorInfoHelpFunc.CORINFO_HELP_CHKCASTARRAY:


You can delete CORINFO_HELP_CHKCASTARRAY and CORINFO_HELP_ISINSTANCEOFARRAY from JIT/EE interface. They are unnecessary now.

VSadov · 2023-08-01T18:53:11Z

One possible question here would be - Why not just port/share the CoreCLR casting helpers in their entirety and implement the internal calls in managed code - to have nearly the same implementation?

I think one of the factors for the design of CoreCLR managed casting helpers was to avoid complicated API with the native type system. As a result that API is basically 2 internal calls methods - IsInstanceOfAny_NoCacheLookup and ChkCastAny_NoCacheLookup.

In NativeAOT the type system APIs are easily accessible, so we do not need to minimize the use of those APIs. On the other hand there are some differences, like the way we fetch the base type for arrays, that may stand in the way of code sharing.
Thus I did not consider it is as a goal to share the code or making it maximally similar when possible, but I think it can be done.

VSadov · 2023-08-01T18:55:29Z

Also in NativeAOT these casting helpers have more users with additional needs, while in CoreClr it is really just type system facade for object casting.

VSadov · 2023-08-01T19:15:14Z

Could you please collect numbers for casting microbenchmarks before/after this change?

I was thinking of what we could measure here.
The most common cases of casting like regular object/interfaces casts did not change, so unlikely to see any differences. We may see differences in more complex cases - like casting to variant interfaces or arrays.

Perhaps just running the regular casting benchmarks that perf lab uses would be informative enough about what changed perf-wise.

VSadov · 2023-08-01T20:50:52Z

I have run the same benchmark as in #84430 (comment)

 internal class Program
    {
        const int iters = 1000000;

        static void Main(string[] args)
        {
            for(; ; )
            {
                Time(TestLStringToIROCstring);
            }
        }
        
        static void Time(Action a)
        {
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < 100; i++)
            {
                a();
            }

            sw.Stop();
            System.Console.WriteLine(sw.ElapsedMilliseconds);
        }

        static object o = new List<string>();

        static void TestLStringToIROCstring()
        {
            for (int i = 0; i < iters; i++)
            {
                if (o as IReadOnlyCollection<object> == null)
                    throw null;

                if (o as IReadOnlyCollection<string> == null)
                    throw null;

                if (o as IEnumerable<object> == null)
                    throw null;

                if (o as IEnumerable<string> == null)
                    throw null;
            }
        }
    }

=== before the change

=== after the change:

The reason for the difference is that original code makes a number of calls. Profiler shows:
TypeCast__IsInstanceOf
MethodTable_get_IsArray
TypeCast__IsInstanceOfVariantType - this one does the cache lookup

making calls and additional checks adds up.

In the new implementation there is only one helper call in the profile:
TypeCast__IsInstanceOfAny - this one does the cache lookup

VSadov · 2023-08-01T21:04:58Z

For comparison the CoreCLR is a bit faster.

The same benchmark as above produces (smaller is better):

As I see in the debugger the native code that we run after this change is nearly the same between CoreCLR and NativeAOT.
There are minor differences like loading of type pointers/handles.
In JIT code they look like:

mov         rcx,7FFCA19E79E8h

In NativeAOT loading a type looks like:

lea         rcx, [rip + 0x73d65]

I do not see any other significant differences. Maybe it is just these little diffs and some indirect impact on code size or alignment that makes the difference.

VSadov · 2023-08-01T21:23:03Z

Another thing to notice is that compared to #84430 (comment) and prior to this change it looks like the benchmark in the comment has regressed.

That was possibly caused by #86029 . I suspect it made common/simple cases faster, which is good, but regressed complex cases that rely on caching as more checks like MethodTable_get_IsArray could run before eventually hitting the cache. Just a guess though.

Anyways, it looks like after this PR the complex/cached case is faster than in #84430 (comment)

src/coreclr/inc/corinfo.h

src/coreclr/jit/importer.cpp

VSadov · 2023-08-02T06:41:43Z

There are some superpmi failures. I can't tell if that simply tells that there are codegen diffs or something is crashing.

jkotas · 2023-08-06T22:14:55Z

/azp run runtime-extra-platforms

azure-pipelines · 2023-08-06T22:15:18Z

Azure Pipelines successfully started running 1 pipeline(s).

src/libraries/System.Reflection/tests/GetTypeTests.cs

This reverts commit 0dbd156.

VSadov · 2023-08-08T04:22:04Z

I'd be ok with merging this now. I think all concerns have been resolved. Let me know if there is something that may be missing.

src/coreclr/vm/jitinterface.cpp

jkotas · 2023-08-08T05:17:44Z

src/coreclr/vm/jitinterface.cpp

@@ -6058,8 +6061,7 @@ CorInfoHelpFunc CEEInfo::getCastingHelperStatic(TypeHandle clsHnd, bool fThrowin
            *pfClassMustBeRestored = true;
        }

-        // If it is an array, use the fast array helper
-        helper = CORINFO_HELP_ISINSTANCEOFARRAY;
+        _ASSERTE(helper == CORINFO_HELP_ISINSTANCEOFANY);
    }
    else
    if (!clsHnd.IsTypeDesc() && !Nullable::IsNullableType(clsHnd))


The native AOT implementation does not checks for Nullable. Is this check redundant here or is the check for Nullable missing in native AOT?

The difference is that JIT tries to transform simple cases like o is int? into o is int, but can't do that when needs a type lookup. As I understand that is due to limitations of IR.

runtime/src/coreclr/jit/importer.cpp

Lines 5387 to 5391 in 40b39ff

// ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T

// We can convert constant-ish tokens of nullable to its underlying type.

// However, when the type is shared generic parameter like Nullable<Struct<__Canon>>, the actual type will require

// runtime lookup. It's too complex to add another level of indirection in op2, fallback to the cast helper instead.

if (isClassExact && !(info.compCompHnd->getClassAttribs(pResolvedToken->hClass) & CORINFO_FLG_SHAREDINST))

NativeAOT does not seem to have a problem with expressing such lookup, so we always cast with nullable stripped

runtime/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs

Lines 301 to 306 in 17d13fa

case ReadyToRunHelperId.TypeHandleForCasting:

{

var type = (TypeDesc)targetOfLookup;

if (type.IsNullable)

targetOfLookup = type.Instantiation[0];

return NecessaryTypeSymbolIfPossible((TypeDesc)targetOfLookup);

In other words in NativeAOT the type check will always be to an unboxed underlying type, thus CLASS variant is correct, and also optimizable, since T? is isClassExact.

In CoreCLR the type check in complex cases could be to the actual Nullable<SomeStruct<string>>, thus it should use ANY variant. It also means that we may be introducing an optimization bug, since such IsInst cannot be lowered to a type/handle compare.

I will check if that is a case, or if there are some mitigating reasons why it still works correctly.

Sadly that is the case. The following works incorrectly

===== Prints: True False using System.Runtime.CompilerServices; namespace ConsoleApp34 { struct S1<T> { public T value; } internal class Program { static object o; static void Main(string[] args) { Test<int>(); Test<string>(); } [MethodImpl(MethodImplOptions.AggressiveOptimization)] private static void Test<T>() { o = new S1<T>(); Console.WriteLine(o is S1<T>?); } } }

This PR indirectly enabled casting optimizations for cases like o is int?, but we need to suppress it, since in more general cases it does not work correctly.

Unless there are better ideas, I am thinking of constraining isinst optimization for CORINFO_HELP_ISINSTANCEOFANY only if converting to an array type. So we do not keep finding more broken cases.

That may be too conservative, but we should probably stay closer to the preexisting behavior for now and consider if more cases can work in 9.0

I am thinking that this PR as a whole is too risky for 8.0. Are there parts that we think are critical to get into .NET 8?

I think the actual casting helper change was low risk as that is mostly refactoring to get more cases to hit the cache earlier. Touching the JIT appears to be a lot more fragile.

There is nothing really "critical" for 8.0, as in - we are not fixing some complete showstoppers here.

I have created a "reduced" version of this. I think that is what we can consider for 8.0 - #90234

I have removed all the JIT changes, but kept the added codegen test.

Sounds good.

jkotas · 2023-08-08T05:35:25Z

src/coreclr/jit/importer.cpp

@@ -13612,7 +13612,7 @@ methodPointerInfo* Compiler::impAllocateMethodPointerInfo(const CORINFO_RESOLVED
 bool Compiler::impIsClassExact(CORINFO_CLASS_HANDLE classHnd)
 {
    DWORD flags     = info.compCompHnd->getClassAttribs(classHnd);
-    DWORD flagsMask = CORINFO_FLG_FINAL | CORINFO_FLG_VARIANCE | CORINFO_FLG_ARRAY;
+    DWORD flagsMask = CORINFO_FLG_FINAL | CORINFO_FLG_VARIANCE | CORINFO_FLG_TYPE_EQUIVALENCE | CORINFO_FLG_ARRAY;


Both CORINFO_FLG_VARIANCE and CORINFO_FLG_TYPE_EQUIVALENCE are only computed to make the impIsClassExact work. Computing these flags is a waste in all other cases. It is the kind of pattern that calls for introduction of dedicated JIT/EE interface API that replaces the flags.

VSadov · 2023-08-23T20:27:53Z

A reduced version of this affecting only run time behavior has been merged.
For the further improvements for the JIT API in this area a tracking bug has been added - #91016

dotnet-issue-labeler bot added the area-NativeAOT-coreclr label Jul 27, 2023

ghost assigned VSadov Jul 27, 2023

VSadov force-pushed the casts branch from 8e8aad2 to 4a7bdc5 Compare July 31, 2023 06:26

VSadov marked this pull request as ready for review July 31, 2023 06:47

VSadov requested a review from MichalStrehovsky as a code owner July 31, 2023 06:47

VSadov commented Aug 1, 2023

View reviewed changes

src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs Show resolved Hide resolved

VSadov requested a review from jkotas August 1, 2023 18:33

jkotas reviewed Aug 1, 2023

View reviewed changes

jkotas reviewed Aug 2, 2023

View reviewed changes

src/coreclr/inc/corinfo.h Show resolved Hide resolved

jkotas reviewed Aug 2, 2023

View reviewed changes

src/coreclr/jit/importer.cpp Show resolved Hide resolved

VSadov added 2 commits August 6, 2023 14:47

removed CORINFO_HELP_ISINSTANCEOFARRAY and CORINFO_HELP_CHKCASTARRAY

2c287d8

right helper and formatting

b814698

VSadov force-pushed the casts branch 2 times, most recently from c3672cb to ac36d4e Compare August 6, 2023 21:51

VSadov added 2 commits August 6, 2023 14:57

Updated JIT version GUID

7913942

simpler selection of runtime helpers for casts

e7b30dd

VSadov force-pushed the casts branch from ac36d4e to e7b30dd Compare August 6, 2023 21:57

This was referenced Aug 7, 2023

[mono][ios] System.Formats.Tar.Tests are failing with System.ArgumentException #88049

Closed

[Android][Test Failure] System.Net.Http.Functional.Tests.HttpMetricsTest_Http11_Async.AllSocketsHttpHandlerCounters_Success_Recorded #89237

Closed

VSadov added 2 commits August 7, 2023 12:51

consider CORINFO_FLG_TYPE_EQUIVALENCE in impIsClassExact

3a38456

add a test scenario for IsInst with type equivalence

0dbd156

jkotas reviewed Aug 7, 2023

View reviewed changes

src/libraries/System.Reflection/tests/GetTypeTests.cs Outdated Show resolved Hide resolved

jkotas reviewed Aug 7, 2023

View reviewed changes

src/libraries/System.Reflection/tests/GetTypeTests.cs Outdated Show resolved Hide resolved

VSadov added 2 commits August 7, 2023 16:46

Revert "add a test scenario for IsInst with type equivalence"

3515468

This reverts commit 0dbd156.

add a codegen test

3be5c28

jkotas reviewed Aug 8, 2023

View reviewed changes

src/coreclr/vm/jitinterface.cpp Outdated Show resolved Hide resolved

jkotas reviewed Aug 8, 2023

View reviewed changes

remove unnecessary fClassMustBeRestored

5ee7cd7

VSadov mentioned this pull request Aug 9, 2023

[NativeAOT][8.0] Make casting logic closer to CoreCLR #90234

Merged

VSadov marked this pull request as draft August 9, 2023 14:58

VSadov added this to the 9.0.0 milestone Aug 14, 2023

VSadov mentioned this pull request Aug 23, 2023

Consider removing CORINFO_HELP_CHKCASTARRAY and CORINFO_HELP_ISINSTANCEOFARRAY from JIT/EE interface #91016

Open

VSadov closed this Aug 23, 2023

jkotas mentioned this pull request Aug 23, 2023

Delete some dead code` #91018

Merged

ghost locked as resolved and limited conversation to collaborators Sep 23, 2023

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[NativeAOT] Make casting logic closer to CoreCLR #89548

[NativeAOT] Make casting logic closer to CoreCLR #89548

VSadov commented Jul 27, 2023 •

edited

Loading

ghost commented Jul 27, 2023

VSadov commented Jul 27, 2023

azure-pipelines bot commented Jul 27, 2023

VSadov commented Aug 1, 2023

jkotas commented Aug 1, 2023

jkotas Aug 1, 2023

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 2, 2023

jkotas commented Aug 6, 2023

azure-pipelines bot commented Aug 6, 2023

VSadov commented Aug 8, 2023

jkotas Aug 8, 2023

VSadov Aug 8, 2023 •

edited

Loading

VSadov Aug 9, 2023 •

edited

Loading

VSadov Aug 9, 2023

VSadov Aug 9, 2023

jkotas Aug 9, 2023

VSadov Aug 9, 2023

VSadov Aug 9, 2023

jkotas Aug 9, 2023

jkotas Aug 8, 2023

VSadov commented Aug 23, 2023

	// ECMA-335 III.4.3: If typeTok is a nullable type, Nullable<T>, it is interpreted as "boxed" T
	// We can convert constant-ish tokens of nullable to its underlying type.
	// However, when the type is shared generic parameter like Nullable<Struct<__Canon>>, the actual type will require
	// runtime lookup. It's too complex to add another level of indirection in op2, fallback to the cast helper instead.
	if (isClassExact && !(info.compCompHnd->getClassAttribs(pResolvedToken->hClass) & CORINFO_FLG_SHAREDINST))

	case ReadyToRunHelperId.TypeHandleForCasting:
	{
	var type = (TypeDesc)targetOfLookup;
	if (type.IsNullable)
	targetOfLookup = type.Instantiation[0];
	return NecessaryTypeSymbolIfPossible((TypeDesc)targetOfLookup);

[NativeAOT] Make casting logic closer to CoreCLR #89548

[NativeAOT] Make casting logic closer to CoreCLR #89548

Conversation

VSadov commented Jul 27, 2023 • edited Loading

ghost commented Jul 27, 2023

VSadov commented Jul 27, 2023

azure-pipelines bot commented Jul 27, 2023

VSadov commented Aug 1, 2023

jkotas commented Aug 1, 2023

Choose a reason for hiding this comment

VSadov commented Aug 1, 2023 • edited Loading

VSadov commented Aug 1, 2023 • edited Loading

VSadov commented Aug 1, 2023 • edited Loading

VSadov commented Aug 1, 2023 • edited Loading

VSadov commented Aug 1, 2023

VSadov commented Aug 1, 2023 • edited Loading

VSadov commented Aug 2, 2023

jkotas commented Aug 6, 2023

azure-pipelines bot commented Aug 6, 2023

VSadov commented Aug 8, 2023

Choose a reason for hiding this comment

VSadov Aug 8, 2023 • edited Loading

Choose a reason for hiding this comment

VSadov Aug 9, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

VSadov commented Aug 23, 2023

VSadov commented Jul 27, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov commented Aug 1, 2023 •

edited

Loading

VSadov Aug 8, 2023 •

edited

Loading

VSadov Aug 9, 2023 •

edited

Loading