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

Merge pull request #24281 from BruceForstall/CleanCorefxRuns

Disable failing corefx tests

Disable failing corefx tests

Merge pull request #24276 from briansull/revert-24229

Revert 24229

Revert "Fix for IBC profile data on Linux - Build the full command line for FEATURE_PAL"

This reverts commit 08422af33fa2026953c2e720cecf000ed4345a32.

Revert "Added method ReleaseManagedCommandLine to release memory"

This reverts commit 1f2435763926f6068fc88a36a2b8dc49c263f271.

Undo a change where we ignore the specified EventPipe sessionType.

Refactored the duplicated code into a template method pattern

Add config value for jit host slab cache maximum size (#24254)

Fix creation of the NUMA node to heap number map

The current implementation assumes that the NUMA nodes of CPUs
used for GC threads form a zero based continous range. However that
doesn't have to be true for cases when user selects only a subset of the
available CPUs for the GC heap threads using the
COMPlus_GCHeapAffinitizeMask or COMPlus_GCHeapAffinitizeRanges. The
selected CPUs may belong only to a subset of NUMA nodes that don't
necessarily start at node 0 or form a continuous range.

This change fixes the algorithm that initializes the
numa_node_to_heap_map lookup array so that it works correctly even in
such cases.

Merge pull request #24229 from briansull/ibc-linux

Fixes for IBC profile data on Linux

Helix telemetry fixes

- Enable telemetry unconditionally
- Set the `_BuildConfig` variable in `xplat-job.yml` so it is available to
  both product and test builds.
- Set the Helix `Type` parameter explicitly to distinguish product and test builds
- Set the Helix `Source` parameter for builds as well as test jobs

This includes a fix to job.yml from dotnet/arcade#2620.

[System.Globalization.Native] Fix small issues in CloneCollatorWithOptions and GetCollatorFromSortHandle (#24100)

* Fix allocation size calculation when resizing array
Allocate initial array using malloc to avoid needlessly zeroing it
Reinstate optimization for empty array returned from GetCustomRules lost in #22378

* Avoid resizing arrays in GetCustomRules by preallocating the maximum size we can consume (5648 bytes)

* Avoid creating a binary search tree for something that could be easily stored as 32-entry lookup table

* Remove obsolete comment

Null-terminate buffers that strncpy writes to (#24095)

It is possible that the string being copied is so large that strncpy
fills up the destination array and does not write any null characters to
it. That will lead to buffer overflows. Work around that by always
writing a null character at the end of the destination array.

Remove redundant tests (#24255)

Tests are technically flaky and have been determined largely redundant with CoreFx.

Fixes #24212

Added method ReleaseManagedCommandLine to release memory

Add IsFrozenObject Profiler API (#24239)

Removing EventPipe file polling (EventPipeController+Timer) (#24225)

* Remove file polling only, and leave the COMPlus_* functionality.
* Fix bug/typo introduced with https://github.com/dotnet/coreclr/pull/21718

Fix for IBC profile data on Linux - Build the full command line for FEATURE_PAL

Added public static function GetManagedCommandLine() andSaveManagedCommandLine()
Add helper method Append_Next_Item
Moved GetManagedCommandLine and SaveManagedCommandLine to ceeload to link crossgen
Cleanup, codereview feedback

Merge pull request #24242 from janvorli/fix-numa-node-for-disabled-numa

Fix NUMA node for heap when NUMA is not available

Using SList<SListElem<T>> to store the EventPipeProviderCallbackData

Add IBCMerge restore source to the restore command. (#24250)

Nullable System.Collections.EmptyReadOnlyDictionaryInternal, System.Collections.ObjectModel.* (#24221)

* annotating collections

* annotated collection.cs and readonlycollection.cs

* adding tkey constraint and comments

Merge pull request #24232 from janvorli/fix-large-version-bubble-2

Fix crossgen with large version bubble enabled

Improve the performance of the type loader (#24177)

Improve the performance of the type loader
- Disable interface ambiguity checks in Corelib
- Improve StackingAllocator perf
  - Increase size of allocation blocks
  - Cleanup allocation blocks comletely on gc suspension
- Check for presence of generic parameters to methods in a more efficient manner
  - Querying the count of GenericParameter records requires a binary search in the GenericParams table
  - Checking the generic flag on the method signature is effectively free
- Skip unnecessary checks in EnumerateClassMethods for corelib
- Use Sanity check flag where appropriate
- Use slightly faster hashtable functions in StringLiteralMap
  - Remove pointless string literal entry hash table search
- Change stacking allocator to not be allocated for the lifetime of a thread, but instead its allocated/destroyed around the first frame on the thread that needs the allocator.
  - Allocate at most 1 stacking allocator per thread
  - The allocation is on the stack via _alloca (as managed by the ACQUIRE_STACKING_ALLOCATOR macro
  - This will put an 8KB buffer on the stack, and if there is need for a larger buffer it will allocate off of the heap.
  - Stacking allocator initial block is always present, so the allocation routine for the allocator can be somewhat simpler
  - More logic has been move the the cpp file, to reduce header bloat, and improve iteration when modifying StackingAllocator code
  - Avoid use of alloca for StackingAllocator when less than 512KB of stack is available

Fix verification of 3-byte UTF-8 sequence followed by non-ASCII byte (#24235)

Return null for unexpected HW intrinsic (#24219)

Fix #17815

Fixing 23941 (#24199)

* Fixing 23941

The issue here is that in R2R code, unlike jitted IL code, the pinvoke calls are wrapped by a pair of calls to the JIT_PInvokeBegin and JIT_PInvokeEnd helpers, which link and unlink the InlinedCallFrame to the current thread. We do not initialize and link the ICF in the method prolog, and unlink it in the epilog, like jitted code does. We do this in the JIT helpers, right before/after the pinvoke call.
When an exception is thrown, the JIT_PInvokeEnd helper will be skipped since execution will resume at the nearest valid catch block, and the ICF will remain linked to the thread, which poses a problem if the method attempts another pinvoke operation (it will try to link the ICF which is already the top frame, and we'll end up in an infinite loop). Therefore, for the R2R case, we need to pop the ICF from the chain during exception unwinding.

Nullable: Contract.cs and more interop (#24193)

* Nullable: Contract.cs and more interop

* Address PR feedback

Fix NUMA node for heap when NUMA is not available

The recent refactoring of the GCToOSInterface::GetProcessorForHeap has
accidentally changed the NUMA node returned in case NUMA is disabled
(either via the COMPlus_GCNumaAware or due to the fact that there is
just a single NUMA node on the system) and the CPU groups are disabled.
Before that refactoring, the code was incorrectly returning 0 as the
NUMA node when CPU groups were disabled no matter whether NUMA was
enabled or disabled. The refactoring fixed that by returning the
current CPU group number for the case when NUMA was enabled, however
it still returned incorrect value, this time GroupProcNo::NoGroup as
the NUMA node number in case NUMA was disabled.

This change fixes it by returning the current group number in this case.

Postponing the managed callback so that they are called after the lock acquistion

Switch to workstation GC in case of constrained CPU resources (#24194)

* Switch to workstation GC in case of constrained CPU resources

Right now, if the user sets the configuration so that the server GC is
used, the server GC will be loaded even in conditions where we know the
workstation GC would fare better. An example of such conditions is
constrained environment where there is only 1 or less CPU or with very
low memory.

This can be harmful if users deploy the same projects on different kind
of platforms: deploying to a 20+ cores server and to Azure Functions
will require largely different configurations for the runtime.

There are already multiple ways for the user to specify to use the
server GC or not:
 - setting `COMPlus_gcServer` as an environment variable
 - setting `gcServer` in the configuration file
 - setting `System.GC.Server` passed to `coreclr_initialize`

Fix https://github.com/dotnet/coreclr/issues/23949

* Address review

* Address review

Remove GCToOSInterface::GetCurrentProcessCpuLimit in favor of
GCToOSInterface::GetCurrentProcessCpuCount because the CpuLimit is taken
into account in the CpuCount again.

* Address review

Do the work in src/vm/ceemain.cpp otherwise there will be a disparity
between what the VM and the GC are running. Before, only the GC would be
aware of the switch from server to workstation GC, but not the VM.

Added optional/default parameters for StreamWriter/StreamReader (#24056)

* Added optional/default parameters for StreamWriter/StreamReader

* Disabled outdated test

* Changed default encoding to UTF8NoBOM

* Made encoding parameter nullable

Unify WIN32_FIND_DATA (dotnet/corefx#37158)

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

Add Medium GC Profiling Mode & ICorProfilerInfo::GetObjectReferences (#24156)

More multi-appdomain support removal (#23921)

More multi-appdomain support removal
- Remove DomainLocalBlock
- Remove DomainModule
- Remove FindDomain(File/Module/Assembly)
- Remove GetDomainModule
- Remove variants of GetDomain(File/Assembly) that take AppDomain parameter
- Adjust contracts to be less strict
  - GetDomainFile/Assembly no longer need a complex contract as multi-domain support does not exist
- Eliminiate uses of encoded ModuleID

Fix crossgen with large version bubble enabled

This change fixes about 1483 failing Pri-1 tests when they are
crossgen-ed with large version bubble enabled. Only one failing test
remains.

60% of the test cases were failing due to a failure to find generic
interface in an interface map due to the fact that the interface type
was being passed in canonical form.
The remaining 40% were tests using constrained calls. We were missing
the ENCODE_METHOD_SIG_Constrained in the method flags.

Merge pull request #24226 from BruceForstall/Disable24224

Disable mandelbrot-7 against #24224

Merge pull request #24227 from BruceForstall/Disable24173

Disable _il_dbgu_fld under GCStress against #24173

Fixing issue where LTTng probe check disables GC events (#24198)

Update dependencies from https://github.com/dotnet/arcade build 20190423.2

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

Update dependencies from https://github.com/dotnet/arcade build 20190422.2

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

Update dependencies from https://github.com/dotnet/arcade build 20190418.7

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

Update dependencies from https://github.com/dotnet/arcade build 20190418.4

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

Update dependencies from https://github.com/dotnet/arcade build 20190418.1

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

Update dependencies from https://github.com/dotnet/arcade build 20190417.1

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

Disable _il_dbgu_fld under GCStress against #24173

Disable mandelbrot-7 against #24224

Fix ProjectN build breaks (dotnet/corert#7343)

Porting changes from the non-WinRT files.

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

Merge pull request #24222 from BruceForstall/AddCorefxExclusions

Expand corefx exclusions

Expand corefx exclusions

Update IBCMerge and ensure that it runs when in a release build and ibcoptimize is set. (#24205)

* Update IBCMerge and ensure that it runs when in a release build and ibcoptimize is set.

* Add major rollforward for ibcmerge.

Merge pull request #24206 from dotnet-maestro-bot/master-UpdateDependencies

Update CoreClr to preview6-27624-71 (master)

Merge pull request #24218 from BruceForstall/FixLinuxX64CorefxTesting

Remove extraneous percent character in Linux/x64 corefx testing command

Remove extraneous percent character in Linux/x64 corefx testing command

Update dependencies from https://dev.azure.com/dnceng/internal/_git/dotnet-optimization build 20190424.1 (#24214)

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

Update CoreClr to preview6-27624-71

Match managed DetermineLibraryNameVariations implementation to native DetermineLibNameVariations implementation. (#24203)

* Match managed DetermineLibraryNameVariations implementation to native DetermineLibNameVariations implementation.

* Update AssemblyDependencyResolver.cs

* Use ordinal comparison instead of culture-specific comparison

Delete unnecessary static and update GCSample to VS2019 (#24204)

Merge pull request #24201 from BruceForstall/AllowFineGrainedCorefxTestExclusions

Enable fine-grained and universal exclusions for CoreFX tests

Update CoreClr to preview6-27623-73 (#24200)

Revert "Dummy commit" (#24197)

Enable fine-grained and universal exclusions for CoreFX tests

One problem we've had in coreclr Jenkins when running corefx
tests (in the coreclr outerloop runs -- the ones using the
run-corefx-tests.py harness) is the inability to exclude
failing tests for x86 or x64, and the inability to have
fine-grained exclusions. This has led to problems like
https://github.com/dotnet/coreclr/issues/22442 where
virtually all Windows x86 and x64 corefx runs fail due to
timeouts. And issues like https://github.com/dotnet/coreclr/issues/24159
where all corefx test legs fail, and we have no control
over exclusions to get them all passing again quickly.

Now that the corefx RunTests.cmd/sh wrapper scripts
parse named arguments, including a response file that
is passed on to xunit, and also that the corefx used
xunit has support for this response file as well as
fine-grained exclusions (per-method/per-class/per-namespace),
we can take advantage of it.

This change adds a single, global, corefx xunit exclusion
response file, that will be used for all platforms. Since this
run-corefx-tests.py mechanism is not expected to live much longer,
this seems sufficient.

Fix failures caused by ICU regression (#24190)

Fixes https://github.com/dotnet/corefx/issues/37098

.NET Core depends on ICU when running on Linux/OSX. Recently some people raised some failure on the framework stack. After investigation we found a regression in ICU which is the root cause of this failure. The regression is, when calling ICU to get some date patterns/properties, in some cases ICU return error code U_MISSING_RESOURCE_ERROR. Although the framework code written to fallback to some invariant values at that time, but we had some wrong line of code which assumed we never fail and trying to access the returned value without checking. That cause the framework to throw NullReferenceException.

The fix here is to make the framework resilient against such cases and continue to run nicely. I have contact ICU support members and I learned there is similar issue tracked in ICU repo https://unicode-org.atlassian.net/browse/ICU-20558

Merge pull request #23932 from briansull/zero-offset-map

Fixes for tracking struct field sequences

Fix crash after unload with server GC (#24196)

When server GC is on, the DomainAssembly::EnumStaticGCRefs is called to
enumerate GC statics. For collectible assemblies, the GC statics are
stored in managed arrays and so there is no need for a special
enumeration of the GC statics. Attempt to do that was causing a crash
due to the fact that the corresponding DomainLocalModule::m_pGCStatics
is always NULL for collectible assemblies and we were trying to access
it.

Nullable : System.Diagnostics.Eventing (Directory) (#24192)

*  Eventing directory done

* adding comment and fixing unix build

Add test coverage for static members on interfaces (#23928)

This has been supported since v1 but we don't have much test coverage.

C# is going to enable interfaces to have static members and static constructors so we better start testing it.

Merge pull request #24195 from Anipik/temp

Dummy commit

Dummy commit

Added additional comment explaining ChnageOper(GT_LCL_FLD) and NotAField

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

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

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

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

Update CoreClr to preview6-27623-71 (#24152)

Fix handling of negative numbers in ThreadPool.SetMin/MaxThreads (#24163)

* Fix handling of negative numbers in ThreadPool.SetMin/MaxThreads

* Fix disabled test name

Implement APIs for some threading metrics (CoreRT) (dotnet/corert#7066)

* Implement APIs for some threading metrics (CoreRT)

- API review: https://github.com/dotnet/corefx/issues/35500
- May depend on https://github.com/dotnet/coreclr/pull/22754

* Use thread-locals for counting, use finalizer instead of runtime to detect thread exit

* Don't let the count properties throw OOM

* Remove some flushes

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

Merge pull request #24176 from BruceForstall/Fix24175

Disable 2 GC tests under HeapVerify for arm64

Merge pull request #24174 from BruceForstall/Fix24172

Disable _il_relthread-race test under GCStress

Disable 2 GC tests under HeapVerify for arm64

They fail due to timeout with `COMPlus_HeapVerify=1` on arm64.

They were already being disabled for HeapVerify for x86 and arm32.

Fixes #24175

Disable _il_relthread-race test under GCStress

It takes too long, and times out in CI.

Fixes #24172

Merge pull request #24168 from wtgodbe/p6

Update branding in master to preview6

Update branding in master to preview6

Fix `CORE_LIBRARIES` doc

Correct iterator (#24160)

Disable failing IJW tests against #23358

Remove create assembly name (#24154)

* Remove RuntimeAssembly.CreateAssemblyName

Fixes #24135

CreateAssemblyName was not compatible with AssemblyLoadContext isolation.

Assembly.Load(string)
Assembly.LoadWithPartialName(string)
Activator.CreateInstance(...)

* Remove unused AssemblyNameNative::Init arguments

* Temp disable corefx CreateInstanceAssemblyResolve

Fix Arm64 UpperVector save/restore (#24043)

* Fix Arm64 UpperVector save/restore

Change the general handling of end-of-block restores so that we always have a RefPosition on which to allocate the register needed on Arm64.

Fix #23885

Fix AssemblyName cache hash and key (#24138)

* Add ContextualReflection LoadWithPartialName case

* Remove unnecessary MethodImplOptions.NoInlining

* Remove m_assembly warning

* Fix AssemblyName hash function

* AssemblyNative::Load fix stackMark usage

Do not use the stackMark if (ptrLoadContextBinder != NULL)

* Temporarily disable DefaultContextOverrideTPA

Test is failing due to a logic error.
Fix is pending in https://github.com/dotnet/corefx/pull/37071