Merge pull request #24315 from dotnet/darc-master-c4cf8915-b4aa-4756-a614-aa01a76fd5cb

[master] Update dependencies from dnceng/internal/dotnet-optimization

New options --sb / --isb for binary signature dump (#24375)

Based on JanV's suggestion I have added two new options to R2RDump:

"--sb" (SignatureBinary) appends the binary signature representation
at the end of the parsed textual signature;

"--isb" (InlineSignatureBinary) inlines the signature bytes into
the parsed textual signature and makes it (somewhat) easy to correlate
the binary bytes with individual parts of the signature.

Thanks

Tomas

Merge pull request #24343 from briansull/add-hva-tests

Add two additional HVA tests:

Implement String.IsAscii in shared CoreLib and use it for [Is]Normalize[d] for all runtimes (#24373)

Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20190503.1

- optimization.IBC.CoreCLR - 99.99.99-master-20190503.1
- optimization.PGO.CoreCLR - 99.99.99-master-20190503.1

Merge pull request #24363 from sandreenko/GitHub_23199

Fix GCStress for multireg returns.

Update the comment.

Vector.CopyTo / TryCopyTo should be readonly methods (#24359)

System.GC.AllocateUninitializedArray (#24096)

* Do not expand to allocation_quantum in SOH when GC_ALLOC_ZEROING_OPTIONAL

* short-circuit short arrays to use `new T[size]`

* Clean syncblock of large-aligned objects on ARM32

* specialize single-dimensional path  AllocateSzArray

* Unit tests

* Some PR feedback. Made AllocateUninitializedArray not be trimmed away.

* PR feedback on gchelpers
- replaced use of multiple bool parameters with flags enum
- merged some methods with nearly identical implementation
- switched callers to use AllocateSzArray vs. AllocateArrayEx where appropriate.

* PR feedback. Removed X86 specific array/string allocation helpers.

Merge pull request #24339 from briansull/linux-creation-time

Fix the PAL implemention of GetProcessTimes  to write the creation time

Changes from code review

Make sure we check the second buffer's creation date before we return

Make sure the thread running EventPipe::Disable is registered with the thread store so that rundown events can be collected

Fix DoGcStress for multireg return with GC pointers.

Note: we are overprotecting registers here, for example, we always protect 2 registers even if only one is returned. GCStress infrastructure should be able to tolerate extra registers. We have had such examples before (for example when returned a struct without pointers we protected the first reg anyway).

In the PAL GetProcessTimes implement lpCreationTime using the current time returned by gettimeofday
This allows IBC profile data to record a meaningful time of when the training scenario was run.
Made EPOCH_DIFF a defined constant
Change calcTime to be an unsigned 64-bit integer
Change constants to units of 100NS instead of NS to avoid division and integer overflows.
Use the defined constants SECS_TO_100NS and USECS_TO_100NS when performing time calculations
Don't add a space after the Assembly arg when argc is zero

Add a repro test.

When QuickJit is enabled, disable it for methods that contain loops by default (#24252)

When QuickJit is enabled, disable it for methods that contain loops by default

Fixes https://github.com/dotnet/coreclr/issues/19751 by default when QuickJit is enabled
- Added config variable TC_QuickJitForLoops. When disabled (the default), the JIT identifies loops and explicit tail calls and switches to tier 1 JIT.
- This would prevent the possibility of spending too long in QuickJit code, but may decrease startup time a bit when QuickJit is enabled
- Removed TC_StartupTier_OptimizeCode, as now that there is TC_QuickJit, I didn't see a good use for it
- Removed references to "StartupTier" in config variables because we had previously decided not to call it that.
- When QuickJit is disabled, avoid creating native code slots for methods in non-R2R'ed modules, as tiering would be disabled for those anyway
- Marked TC_QuickJit config var as external

Add Series/CounterType to CounterPayload and IncrementingCounterPayload (#24349)

Merge pull request #24332 from janvorli/fix-module-override

Fix module override effect on method instantiating signature

Add using System.Diagnostics on some files

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Delete stale compilation constants from AsyncIteratorMethodBuilder (#37331)

I accidentally left these MICROSOFT_BCL_ASYNCINTERFACES_PACKAGE references in as part of some recent churn.  This compilation constant isn't set anywhere.

And the CORERT ifdef is no longer needed now that we've consolidated the code to shared.

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Add ManualResetValueTaskSourceCore / AsyncIterateMethodBuilder to Microsoft.Bcl.AsyncInterfaces (#37320)

* Add ManualResetValueTaskSourceCore / AsyncIterateMethodBuilder to Microsoft.Bcl.AsyncInterfaces

These two types needed modifications to target .NET Standard 2.0 and are the necessary pieces to enable the compiler to compile async iterators.

- Copied ManualResetValueTaskSourceCore.cs from coreclr and tweaked it.  I opted to do this rather than ifdef because the changes are not localized and I didn't want to significantly perturb the primary implementation.
- Added a few ifdefs to the shared AsyncIteratorMethodBuilder.  It already had ifdefs, so I just added to it.
- Added a test project, and included the existing ManualResetValueTaskSourceCore tests.  I had to disable two of the tests because of some of the optimization differences.
- Augmented those tests to validate that the compiler is able to successfully generate iterators and await foreach them.

* Address PR feedback

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Adding more coverage for the AES hwintrinsic tests. (#24335)

* Updating the AES tests to cover all current scenarios

* Regenerating the AES HWIntrinsic tests from the updated templates.

* Fixing a couple of typos in the Aes*OpTest.templates

* Modifying CodeGen::inst_RV_TT_IV to no longer assert when memIndir is nullptr

Re-enable all com crossgen testing (#24348)

- COM testing with crossgen was disabled due to lack of manifest support in crossgen

Update CoreClr to preview6-27702-71 (#24353)

Implement GC.RegisterMemoryLoadChangeNotification (#24202)

* Implement GC.RegisterMemoryLoadChangeNotification

This allows users to register a callback to be called whenever the
memory load is between a low and high thresholds. The idea is to allow
them to tweak their memory usage based on the available memory.

It is only internal for now because we are not confident on the shape of
the API and if it's the best we can provide users. This needs to go
through a few iterations with first party users like ASP.NET or corefx.

WIP for https://github.com/dotnet/coreclr/issues/18619

* fixup! Implement GC.RegisterMemoryLoadChangeNotification

* fixup! Implement GC.RegisterMemoryLoadChangeNotification

* fixup! Implement GC.RegisterMemoryLoadChangeNotification

Bug fix in R2RDump signature decoder w.r.t. large version bubbles (#24352)

JanV discovered a complex signature where the generic type argument
got decoded in an incorrect module context by R2RDump. Investigating
the issue I found out that the problem was caused by my slight
misunderstanding - all module override indices within a signature
are relative to the global signature context module, not to the current
context module that may change during descent into the signature tree.

Thanks

Tomas

Merge pull request #24322 from am11/libunwind-format-specifier

Unify Wformat suppression for libunwind

Add threading-related runtime counters (#24304)

* Add threadpool/contention counters

* fix build error

Adjust some terms (#24351)

Unify Wformat suppression for libunwind

Nullable: Interop and src/System remainder (#24328)

* Nullable: Interop and src/System remainder

* apply feedback

Nullable: System.Collections remainder (non-generic) (#24326)

* Nullable: System.Collections remainder (non-generic)

* apply feedback

Update CoreClr to preview6-27701-72 (#24329)

Added overloads to Path.Join (#24307)

* Added overloads to Path.Join

* Refactor Path.Join and Path.Combine to use ValueStringBuilder

* Use proper defined const for empty string

* Fix Windows-specific const

Addressing code review feedbacks

Simplifying Pop() logic

Remove the RundownThread filter

Avoid nested spin lock in WriteAllBuffersToFile and GetNextEvent

Pulling in Noah's fix in event_pipe_lock_fix branch

Update issues.targets and reduce test execution time. (#24345)

* Update issues.targets and reduce test execution time.

When large pages are enabled, only reserve/commit 1x seg size for LOH (#24320)

When large pages are enabled, we must commit everything we reserve.
Previously we reserved 2x the segment size for LOH. This is a problem
with large pages where we must commit everything we reserve.

Thanks to https://github.com/dotnet/coreclr/pull/24081 this does not
cause performance regression with large pages; but without large pages
we were seeing regressions when the loh_seg_size was reduced. So this
change will only take effect when large pages are enabled.

Copy all win32 resources (#24308)

- Add crossgen test to verify file version is preserved
- Add support for general win32 resource copying to ReadyToRun
  - Copy all resources

Move the new ConfigureAwait/WithCancellation extension methods to a new type (#24331)

We decided after all to put these on a different type, TaskAsyncEnumerableExtensions.  This commit adds the new type.  We can delete the methods in the old location once corefx consumes an updated build and switches over to using the new ones.

Add two additional HVA tests:

VectorMgdMgdStatic.cs  - Tests where we are passing and using a HVA that is stored in a static
VectorMgdMgdArray.cs   - Tests where we are passing and using a HVA that is stored in an array

Update SDK to 2.1.504

(Hopefully) Fixes #24083

Disable CallbackStressTest everywhere.

Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20190501.1

- optimization.IBC.CoreCLR - 99.99.99-master-20190501.1
- optimization.PGO.CoreCLR - 99.99.99-master-20190501.1

Updating lookupNamedIntrinsic to no longer assert for an unexpected hwintrinsic method. (#24327)

Fix module override effect on method instantiating signature

When a module override is placed on a fixup blob top level, it also
affects types in the method instantiating signature. This can cause
tokens in the signature to be resolved in a wrong module.

This change fixes it by adding module zapsig elements before each
argument of the method's instantiating signature.

Merge pull request #24258 from dotnet/NullableFeature

Merge nullable feature into master

Changing comments/names that refers to file switching to flushing instead

Support for larger version bubbles in R2RDump (#24277)

After JanV fixed basically all test failures related to larger
version bubbles originally implemented by Andon, it's high time
to fix R2RDump for its support as a prerequisite to enabling
larger version bubbles in CPAOT. This change implements this
support via the following particular changes:

1) In DumpOptions, I added a list of explicit assembly references,
another list of reference paths that are used for resolving
assembly references, a cache for repeated assembly lookups and
a new method FindAssembly for file resolution of a given simple
assembly name.

2) I have moved ECMA metadata-related logic from R2RReader to
its new base class EcmaMetadataReader. This class can represent
both R2R and MSIL binaries and adds the logic for reference
assembly lookup.

3) Large version bubble R2R PE exe's contain a special R2R header
table READYTORUN_SECTION_MANIFEST_METADATA that contains ECMA
metadata with a list of extra AssemblyRef's on top of those stored
in the original MSIL. I have added support for parsing this table
to the R2RReader constructor.

4) I have modified R2RSignature to be based off the new
EcmaMetadataReader instead of R2RReader which cannot represent
arbitrary reference assemblies. I have patched the two places
dealing with module overrides to use the new logic to temporarily
switch to a "remote module" SignatureDecoder for the purpose
of parsing an external entity.

5) I have removed temporary hacks Andon put in place to keep
R2RDump alive in some cases with larger version bubbles without
proper support for parsing module overrides.

6) I have added logic for dumping the contents of the manifest
metadata along with the standard AssemblyRef table to the
header dump as I fought with recalculation of the indices
when debugging larger version bubble code for quite some time.

7) As an extra half-forgotten bit from the past I added dumping
of unboxing and instantiation stubs.

I have noticed that the MSIL AssemblyRef count was off by one.
I have also found out that XML output has bitrotten over time.
This additional delta fixes both issues. [That forced me to
add a bunch of empty ctors even though in practice we don't
actually serialize anything into the dumper, we only use
the XML serializer to emit the XML output file.

Thanks

Tomas

Compute sizeof array instead of pointer (#24288)

* Compute sizeof array instead of pointer

* Consolidate element count in dumpStack

Make block optimized ClearWithoutReferences fully shared (#24312)

Update dependencies from https://github.com/dotnet/arcade build 20190429.8 (#24313)

- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.19229.8
- Microsoft.DotNet.Helix.Sdk - 2.0.0-beta.19229.8

Update BuildTools, CoreClr to preview4-03930-01, preview6-27630-77, respectively (#24316)

Remove FreeLibrary call to unload CoreCLR (#24317)

Merge master into NullableFeature

Fix test failures

fix build errors after merge

Disable CallbackStressTest against #24305

Add more asserts for the EventPipeBufferManager consumers

Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20190430.1

- optimization.IBC.CoreCLR - 99.99.99-master-20190430.1
- optimization.PGO.CoreCLR - 99.99.99-master-20190430.1

[master] Update dependencies from dnceng/internal/dotnet-optimization (#24245)

- optimization.IBC.CoreCLR - 99.99.99-master-20190429.1
- optimization.PGO.CoreCLR - 99.99.99-master-20190429.1

Updating System.Numerics.Vector<T> to use the readonly members feature. (#23827)

[master] Update dependencies from dotnet/arcade (#24244)

- Microsoft.DotNet.Arcade.Sdk - 1.0.0-beta.19226.3
- Microsoft.DotNet.Helix.Sdk - 2.0.0-beta.19226.3

Add more span-based Vector<T> ctors and CopyTo methods (#23333)

[master] Update dependencies from dotnet/corefx (#24292)

- Microsoft.NETCore.Platforms - 3.0.0-preview6.19229.1
- Microsoft.Private.CoreFx.NETCoreApp - 4.6.0-preview6.19229.1

Move DefaultBinder.CanConvert.cs to shared (#23931)

Move NativeLibrary to the shared partition (#24143)

I'm taking the LibraryNameVariation helper from System.Runtime.Loader for the ride as well because it's a general purpose probing logic that is useful in a managed implementation of NativeLibrary.

Update CoreClr to preview6-27629-72

Fix GetObjectReferences API when caller doesn't zero the param (#24299)

Improve pref of `Array.IndexOf()` for certain `T`. (#24293)

Applies changes to `Array.IndexOf()` and `Array.LastIndexOf()` similar
to the changes made in #20855, so that types other than `byte` and
`char` can use use the fast vectorized path.

Also allows 32-bit and 64-bit types for which
`RuntimeHelpers.IsBitwiseEquatable<T>()` returns `true` to use the
faster implementation of `IndexOf` and `LastIndexOf` from
`MemoryExtensions`.

Workaround memset alignment sensitivity (#24302)

* Workaround memset alignment sensitivity

memset is up to 2x slower on misaligned block on some types of hardware. The problem is uneven performance of "rep stosb"
used to implement the memset in some cases. The exact matrix on when it is slower and by how much is very complex.

This change workarounds the issue by aligning the memory block before it is passed to memset and filling in the potential misaligned
part manually. This workaround will regress performance by a few percent (<10%) in some cases, but we will gain up to 2x improvement
in other cases.

Fixes #24300

Resolves an assert around Sse41.ConvertToVector128Int* and Avx2.ConvertToVector256Int* (#24289)

* Adding tests for the overloads of Sse41.ConvertToVector128Int* and Avx2.ConvertToVector256Int* that take a pointer

* Fixing the handling of Sse41.ConvertToVector128* and Avx2.ConvertToVector256*

Merge pull request #24283 from briansull/ibc-linux-new

Updated fixes for IBC profile data on Linux

Improve Precision to 10 microseconds in timespan (#24279)

* Increasing precision properly and leaving the rounding of to casting operator

* disabling corefx tests in coreclr and addressing feedback

* correcting test project name

* Fix json

Fix Satellite Assembly loading (#24191)

* Fix Satellite Assembly loading

When loading satellite assemblies, we should probe next to the parent
assembly and load into the same AssemblyLoadContext as the parent
assembly.

Disable fallback probing for satellite assemblies.

Add AssemblyLoadContext.Resolving handler to probe for satellite
assemblies next to parent

Fixes #20979

* Call ResolveSatelliteAssembly from native

Only call ResolveSatelliteAssembly from native when
resolving a satellite assembly

* PR Feedback

Minimize string creation
Remove unnecessary if null checks
Eliminate corner cases by only allowing one case insensitive matching directory.

* ResolveSatelliteAssembly should ...

ResolveSatelliteAssembly should always be called on the ALC which loaded parentAssembly

Simplify code.
Add Debug.Assert

* Remove case insensitive culture search

* PR Feedback

* Fix parentAssembly logic

* Fixes from initial testing

* Add probe for lower case culture name

* PR feedback

Merge pull request #24282 from erozenfeld/Fix24253

 Fix for a jit liveness bug.

Removed method ReleaseManagedCommandLine()
jkotas - We are intentionally not doing any cleanup that is just releasing memory.
We depend on the OS to take care of releasing the memory.

Restore IBCMerge using an authenticated service connection (#24284)

* Add separate build steps to do the IBCMerge restore.

* Attempt 1 to get config picked up.

* Attempt 2 getting ibcmerge restore working.

* Fix invalid MSBuild syntax.

* Fix getting IBC package version.

Fix running JitBench on Linux (#24248)

* Fix running JitBench on Linux

* Bump to head of aspnet/JitBench:rel/2.0.0

Add missing check for UTF-16 low surrogate char at start of buffer (#24286)

Merge pull request #24261 from sandreenko/fixRegressionCoreFXx86

Fix optAssertionProp_Update.

Nullable: Comparers, Dictionary and Friends (#23971)

* Nullable: Comparers, Dictionary and Friends

* Add object constraint to Dictionary

* Fix warning from new compiler and annotating dictionary

* PR Feedback

Nullable for Type class (#23489)

System.Type, System.Reflection nullability

Nullable: System.Diagnostics.Tracing (#24070)

* Nullable: System.Diagnostics.Tracing

* apply feedback

* fix one more comment

Update dependencies from https://github.com/dotnet/corefx build 20190426.9

- Microsoft.NETCore.Platforms - 3.0.0-preview6.19226.9
- Microsoft.Private.CoreFx.NETCoreApp - 4.6.0-preview6.19226.9

Update dependencies from https://github.com/dotnet/corefx build 20190425.8

- Microsoft.NETCore.Platforms - 3.0.0-preview6.19225.8
- Microsoft.Private.CoreFx.NETCoreApp - 4.6.0-preview6.19225.8

Update dependencies from https://github.com/dotnet/corefx build 20190425.1

- Microsoft.NETCore.Platforms - 3.0.0-preview6.19225.1
- Microsoft.Private.CoreFx.NETCoreApp - 4.6.0-preview6.19225.1

Update dependencies from https://github.com/dotnet/corefx build 20190423.9

- Microsoft.NETCore.Platforms - 3.0.0-preview6.19223.9
- Microsoft.Private.CoreFx.NETCoreApp - 4.6.0-preview6.19223.9

Fix CoreLib build breaks

Add System.Resources.Extensions (dotnet/corefx#36906)

* Add System.Resources.Binary.Reader|Writer

* Fix ResourceWriter tests

* Test fixes and PR feedback

* More test fixes

* Add packages for System.Resources.Binary.*

* Suppress duplicate types in System.Resources.Binary.*

* Test refactoring and adding RuntimeResourceSet

It turns out me must have our own ResourceSet since the CoreLib resource set doesn't
expose a constructor that takes an IResourceReader.

I've shared the code since it does a bit of non-trivial caching.

* Don't use auto-property initializers for platfrom sensitive test data

For some reason I thought these lazy-initialized the properties but they don't.

As a result we were hitting the platform sensitive code even when we never
called the getter.  Switch to an expression instead.

* Only use Drawing converters on Windows

* Fix test failures

* Don't leak System.Private.CoreLib into resources

* Make sure RuntimeResourceSet doesn't call ResourceReader(IResourceReader)

* WIP

* Rename types in System.Resources.Extensions

Leave RuntimeResourceSet internal as it doesn't need to be public.

* Update packages

* Respond to API review feedback

Remove abstraction for ResourceReader/Writer: just reuse the source.

Remove non-essential members.

* Clean up

* Further cleanup

* Further cleanup

* Review feedback

* Ensure we have stable type names in Resources.Extensions

We don't want to use the runtime type identity when doing type checks or writing
types as this may change.  Instead, check-in hard-coded strings that match the
type identity.

Add a test case to ensure the resources we generate match what we
test the reader against in the resource manager case (also to track any
change to the binary format).

Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com>

Switch to non-Int Azure pool providers

Typos (#24280)

* thier -> their

* exeption -> exception

* Estbalisher -> Establisher

* neeed -> need

* neeed -> need

* neeeded -> needed

* neeeded -> needed

* facilitiate -> facilitate

* extremly -> extremely

* extry -> extra

Improve LOH heap balancing (#24081)

* Improve LOH heap balancing

Previously in `balance_heaps_loh`, we would default to `org_hp` being
`acontext->get_alloc_heap()`.

Since `alloc_large_object` is an instance method, that ultimately came
from the heap instance this was called on. In `GCHeap::Alloc` that came
from `acontext->get_alloc_heap()` (this is a different acontext). That
variable is set when we allocate a small object. So the heap we were
allocating large objects on was affected by the heap we were allocating
small objects on. This isn't necessary as small object heap and large
object heaps have separate areas. In scenarios with limited memory, we
can unnecessarily run out of memory by refusing to move away from that
hea. However, we do want to ensure that the large object heap accessed
is not on a different numa node than the small object heap.

I experimented with adding a `get_loh_alloc_heap()` to acontext similar
to the SOH alloc heap, but performance tests showed that it was usually
better to just start from the home heap. The chosen policy was:

* Start searching from the home heap -- this is the one corresponding to
our processor.

* Have a low (but non-zero) preference for that heap (dd_min_size(dd) /
2), as long as we stay within the same numa node.

* Have a higher cost of switching to a different numa node. However,
this is still much less than before; it was dd_min_size(dd) * 4, now
dd_min_size(dd) * 3 / 2.

This showed big performance improvements (over 30% less time) in a
scenario with lots of LOH allocation where there were fewer allocating
threads than GC heaps. The changes were more pronounced the more we
allocated large objects vs small objects. There was usually slight
improvement (1-2%) when there were 48 constantly allocating threads and
48 heaps. The one place we did see a slight regression was in an 800MB
container and 4 allocating threads on a 48 processor machine; however,
similar tests with less memory or more threads were prone to running out
of memory or running very slow on the master branch, so we've improved
stability. Previously the gc could get lucky by having the SOH choice
happen to be a good choice for LOH, but we shouldn't be relying on it as
it failed in some container scenarios.

One more change is in joined_generation_to_condemn: If there is a memory
limit and we are about to OOM, we should always do a compacting GC. This
helps avoid the OOM and feeds into the next change.

This PR also adds a *second* balance_heaps_loh function for when there
is a memory limit and we previously failed to allocate into the chosen
heap. `balance_heaps_loh` works based on allocation budgets, whereas
`balance_heaps_loh_hard_limit_retry` works on the actual space available
at the end of the segment. Thanks to the change to
joined_generation_to_condemn the heaps should be compact, so not looking
at free space here.

* Fix uninitialized variable

* In a container, use space available instead of budget

* Fix duplicate semicolon

Merge pull request #24270 from janvorli/fix-gc-numa-to-heap-map-creation

Fix creation of the NUMA node to heap number map

Clean up fgRemoveDeadStore.

Remove duplication and a couple of goto's from `fgRemoveDeadStore`.

This part was very confusing:

`
                /* If this is GT_CATCH_ARG saved to a local var don't bother */

                JITDUMP("removing stmt with no side effects\n");

                if (asgNode->gtFlags & GTF_ORDER_SIDEEFF)
                {
                    if (rhsNode->gtOper == GT_CATCH_ARG)
                    {
                        goto EXTRACT_SIDE_EFFECTS;
                    }
                }
`

The `goto` was to the preceding `if` and was useless since the call
to `gtExtractSideEffList(rhsNode, &sideEffList);` couldn't possibly find
side effects because we already checked that
`rhsNode->gtFlags & GTF_SIDE_EFFECT == 0`.

Added check for GetManagedCommandLine() returning a nullptr in ProfileDataAllocateScenarioInfo

Moved call to ReleaseManagedCommandLine() to EEShutDownHelper