Merge pull request #13849 from stephentoub/string_create

Add String.Create span-based method

Merge pull request #13888 from jkotas/corelib-mirror

Mirror changes from dotnet/corert

Merge pull request #13886 from ahsonkhan/SpanReadOnlyStruct

Marking {ReadOnly}Span with IsReadOnly attribute

Finish moving files to shared CoreLib partition

Move PInvoke interop related attributes to shared CoreLib partition

[tfs-changeset: 1673253]

Finish moving files to shared partition

Fix IntrinsicAttribute build break

Enable auto-update for PGO data (#13883)

Move PgoDataPackageVersion into dependencies.props, which enables auto-update functionality.
Also, update optdata version to 20170908-1805.

Cleanup Guid formatting (#13885)

Marking {ReadOnly}Span with IsReadOnly attribute.

Merge pull request #13842 from dotnet-bot/from-tfs

Merge changes from TFS

Merge pull request #13110 from pgavlin/SPMIJitOptions

Add the capability to specify JIT options on the SPMI command line.

Guid span-based APIs (ctor, TryWriteBytes, TryFormat) (#13323)

* standardized style changes

* 3 span-ified guid methods

throw null exception for readonlyspan ctor

full changes

* restructured trywritebytes

* changed writebytehelper from feedback

* changed casing of switch statement

* indentation

Merge pull request #13863 from pgavlin/DevDiv491211

Properly update GTF_{ASG,EXCEPT} in call morphing.

[Arm64] Optimize System.Buffer:Memmove (#13793)

* [Arm64] Optimize System.Buffer:Memmove

Enable HAS_BLOCKS

Disable code to fall back to native memmove until memmove
optimizations are merged to OS mainline

* Add links to issues

Move files to shared partition (#13870)

Moved pseudo-custom attribute reflection helpers from attribute definitions to reflection to prepare attribute definitions to be moved to shared partition.

Port some concurrent collection implementations with latest fixes from CoreFX into CoreCLR copies (#12939)

Add a <clear /> to packageSources in src/NuGet.Config (#13874)

Fixes #13873

Merge pull request #13845 from ViktorHofer/DBNull-Serialization

Make DBNull serializable

Non-shared changes

Delete redundant PInvokes

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

Move HResults to shared partition

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

Fix CoreLib build warnings (#13851)

Change lock used for initializing YieldProcessorNormalized from Crst to CrstStatic (#13857)

Fixes https://github.com/dotnet/coreclr/issues/13779

Address PR feedback.

Only delete agent when not succesful (#13865)

Spinup for this agent is unreliable (docker fails to start a lot).  Only delete when the build fails.

Properly update GTF_{ASG,EXCEPT} in call morphing.

The former is only necessary if it is set on any of the call's
arguments; the latter is necessary if the call may throw or if it is set
on any of the call's arguments.

Fixes DevDiv 491211.

Adding serializable attribute to type

PR feedback

Add String.Create span-based method

Fix EventProvider to build on Linux

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

Remove unused params

Add exception handling for other input and add comments

Add the capability to specify JIT options on the SPMI command line.

This change adds two new flags, `-jitoption` and `-jit2option`, to the
SuperPMI command line. These flags are cumulative, and are used to
specify JIT config options (e.g. `COMPlus_JitDisasm`, albeit without the
`COMPlus_` prefix) to the base and diff JITs, respectively.

This change also removes Smarty-specific code and support for capturing
and replaying environment variables. The former is no longer terribly
useful and the latter has been obviated by the JIT host interface.

Revert access modifier change and update its comment

Merge pull request #13838 from pgavlin/DevDiv489992

Copy `GTF_{ASG,EXCEPT}` flags in `gtCloneExpr`.

More comments and remove of corert special case

PR feedback

Make dumpmd work with tiered jitting. Now displays previous code addresses (#13805)

* Make dumpmd work with tiered jitting. Now displays previous code addresses

* add tier info and nativecodeversionnode ptr to dumpmd output

* fix warnings on non-rejit platforms

Retry linux arm legs on a new agent (#13839)

Make DBNull serializable

Merge pull request #12334 from sdmaclea/PR-Optimize-Jit-WriteBarriers

[Arm64] Optimize JIT_WriteBarriers

New jit intrinsic support (#13815)

Support for new-style intrinsics where corelib methods can have both IL
implementations and optional jit-supplied implementations.

Mark such methods with the [Intrinsic] attribute, then recognize the
intrinsic methods by name in the jit.

Jit currently has a placeholder for the Enum.HasFlag method.

Desktop changes corresponding to https://github.com/dotnet/coreclr/pull/13815

The new jit interface method is stubbed out in desktop, as we will not see any of these new style intriniscs there (at least for now).

[tfs-changeset: 1673063]

Copy `GTF_{ASG,EXCEPT}` flags in `gtCloneExpr`.

These flags from the source were being unioned with those of the copy,
which was incorrect in cases where the copy's flags were overly
conservative. This change simply copies the values of these flags from
the source.

Fixes VSO 489992.

Merge pull request #13821 from pgavlin/DevDiv487701_487702

Fix VSO 487701 and 487702.

Spelling and grammar corrections - A through L (#13683)

Merge pull request #13817 from pgavlin/DevDiv487703

Do not remove NOPs used by calls.

Update CoreClr, CoreFx to preview2-25707-02, preview2-25707-02, respectively (#13808)

Fix for #13830 issue (#13831)

Fix incorrect treatment of pointer as fixed (#13816)

Merge pull request #13797 from jashook/arm64_green_ci

Disable tests based on 13796

Segregate merged returns by constant value (#13792)

The JIT enforces a limit on the number of epilogs emitted in any given
method.  Change the logic so that when this merging kicks in, returns of
constant values are given merged return blocks distinct from each other
and from the general return block, as long as we can do so without going
over the limit.  This particularly helps avoid redundancy (while still
keeping method size down) in methods with a large number of constant
returns but only a few distinct constants, which is true of many
predicate methods with bool return type.

This is the compiler portion of #13466 and dotnet/corefx#23395.

Vendor the volatile.h header into src/gc/env for the standalone GC build (#13656)

* Vendor the volatile.h header into src/gc/env for the standalone GC build

* Repair the GC sample

* Remove some unneeded defines (fixes the sample build)

Fix VSO 487701 and 487702.

Both of these issues stem from attempting to unassign a copied interval
from the copied-to register and then reassigning the interval to the
same. This corrupts some of the bookkeeping necessary to track whether
or not the interval in the register needs to be spilled, and the RA ends
up attempting to spill the interval being allocated even though it is
not assigned a register.

Add tests for VSO 487701 and 487702.

Add a regression test.

Do not remove NOPs used by calls.

Instead of removing dead stores that are marked as late args, we replace
them with NOPs. This obviates the need to update the call's argument
table, but requires that the NOP itself not be DCE'd. This change marks
these NOPs with the `ORDER_SIDEEFF` flag s.t. DCE will not remove them.

Fixes VSO 487703.

Fix DevDiv_278523 test for r2r x86. (#13709)

* separate sources into 2 files: for 32 and for 64.

Restore Array.Empty

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

Merge pull request #13811 from jashook/fix_xarch_warning

Fix potentially uninitialized local variable 'regCount'

Jit doesn't reload shift index if it was spilled to rcx. (#13757)

Repro test. Fix and additional assert.

Merge pull request #13659 from mikedn/cast-actual-type

Fix getCastDescription to use the actual source type

Merge pull request #13800 from adiaaida/addnopgoPerf

Add nopgo option for throughput runs

Fix potentially uninitialized local variable 'regCount'

Add Memory-based Stream overloads to coreclr (#13769)

Includes adding the virtuals to Stream and then overriding on the various streams implemented in coreclr.

Removed renamed method. (#13803)

Support for not wrapping exceptions with TargetInvocationException. (#13767)

* Support for not wrapping exceptions with TargetInvocationException.

For dotnet/corefx#22866.

* Respond to PR feedback.

Mainly by making "WrapExceptions" consistently positive in FCalls.

* Remove BindingFlags.DoNotWrapExceptions tests in deference to CoreFX tests.

Update CoreClr, CoreFx to preview2-25706-01, preview2-25706-01, respectively (#13734)

Add nopgo option for throughput runs

Fix for CoreRT issue https://github.com/dotnet/corert/issues/3672 (ar… (#13777)

* Fix for CoreRT issue https://github.com/dotnet/corert/issues/3672 (armel tizen)

* Added assertion for accessType

implementing profiler ELT callbacks for AMD64 Linux (#12603)

* implement profiler ELT callbacks for AMD64 Linux

* Some formatting fixes

* Fixed profiler

* Added aligning frame option

* Added aligning stack for quad values stores

Moving the Windows Performance runs from Server 2012 to Server 2016. (#13725)

Add support for building under glibc 2.26 (#13785)

glibc 2.26 renames a number of identifiers so they are reserved under
POSIX. Specifically, `padding` becomes `__glibc_reserved1`. Add a
configure test for it and use the appropriate field name.

See https://sourceware.org/bugzilla/show_bug.cgi?id=21457 for more
information.

Resolves #13009

Disable tests based on 13796

Merge pull request #13791 from jashook/revert_13687

revert_13687

Fix SemaphoreSlim throughput (#13766)

In https://github.com/dotnet/coreclr/pull/13670, by mistake I made the spin loop infinite, that is now fixed.

As a result the numbers I had provided in that PR for SemaphoreSlim were skewed, and fixing it caused the throughput to get even lower. To compensate, I have found and fixed one culprit for the low throughput problem:
- Every release wakes up a waiter. Effectively, when there is a thread acquiring and releasing the semaphore, waiters don't get to remain in a wait state.
- Added a field to keep track of how many waiters were pulsed to wake but have not yet woken, and took that into account in Release() to not wake up more waiters than necessary.
- Retuned and increased the number of spin iterations. The total spin delay is still less than before the above PR.

revert_13687

Add Intel hardware intrinsic API (#13576)

Fix access order for double pointer (#13759)

* Fix access order for double pointer

* Reinforce test to catch more errors

Merge pull request #13747 from jashook/lst_file_updates

Lst File updates.

JIT: allow inlines of methods with calli (#13756)

Provided call sig has default callling convention. Added test case.
Continuation of #12714.

Merge pull request #13763 from shimingsg/v-shige/addtestdependencyxmlfiles

add test dependency xml files

Print zapper stats on verbose mode (#13774)

Fix uninitialized fields of ZapperStats (#13773)

update correct file path if the working folder is not test case folder

Change identifier for EventProviders from GUID to string name (#13370)

* [WIP] Changed event provider to user String identifiers

* [WIP] Remove GUID from generated code

* [WIP] Many small fixes

* [WIP] Fix error in constructing GUID

* Pass EventSource to abstract away GUID/Name references

* Fix various small errors

* Delay construction of SString objects

* Change GUIDs to names

* Change hardcoded GUID strings to names

* Revert testing changes

* Remove extra line

* Use the EventSource name

* Use provider full names

* Use full-names for Rundown

* Bump version number for eventpipe file

* Address review comments

Merge pull request #13755 from BruceForstall/AddLsraAssert

Add an assert to getRegisterRecord() that regNum is legal

need casting for size calculation (#13754)

Add an assert to getRegisterRecord() that regNum is legal

Add normalized equivalent of YieldProcessor, retune some spin loops (#13670)

* Add normalized equivalent of YieldProcessor, retune some spin loops

Part of fix for https://github.com/dotnet/coreclr/issues/13388

Normalized equivalent of YieldProcessor
- The delay incurred by YieldProcessor is measured once lazily at run-time
- Added YieldProcessorNormalized that yields for a specific duration (the duration is approximately equal to what was measured for one YieldProcessor on a Skylake processor, about 125 cycles). The measurement calculates how many YieldProcessor calls are necessary to get a delay close to the desired duration.
- Changed Thread.SpinWait to use YieldProcessorNormalized

Thread.SpinWait divide count by 7 experiment
- At this point I experimented with changing Thread.SpinWait to divide the requested number of iterations by 7, to see how it fares on perf. On my Sandy Bridge processor, 7 * YieldProcessor == YieldProcessorNormalized. See numbers in PR below.
- Not too many regressions, and the overall perf is somewhat as expected - not much change on Sandy Bridge processor, significant improvement on Skylake processor.
  - I'm discounting the SemaphoreSlim throughput score because it seems to be heavily dependent on Monitor. It would be more interesting to revisit SemaphoreSlim after retuning Monitor's spin heuristics.
  - ReaderWriterLockSlim seems to perform worse on Skylake, the current spin heuristics are not translating well

Spin tuning
- At this point, I abandoned the experiment above and tried to retune spins that use Thread.SpinWait
- General observations
  - YieldProcessor stage
    - At this stage in many places we're currently doing very long spins on YieldProcessor per iteration of the spin loop. In the last YieldProcessor iteration, it amounts to about 70 K cycles on Sandy Bridge and 512 K cycles on Skylake.
    - Long spins on YieldProcessor don't let other work run efficiently. Especially when many scheduled threads all issue a long YieldProcessor, a significant portion of the processor can go unused for a long time.
    - Long spins on YieldProcessor is in some cases helping to reduce contention in high-contention cases, effectively taking away some threads into a long delay. Sleep(1) works much better but has a much higher delay so it's not always appropriate. In other cases, I found that it's better to do more iterations with a shorter YieldProcessor. It would be even better to reduce the contention in the app or to have a proper wait in the sync object, where appropriate.
    - Updated the YieldProcessor measurement above to calculate the number of YieldProcessorNormalized calls that amount to about 900 cycles (this was tuned based on perf), and modified SpinWait's YieldProcessor stage to cap the number of iterations passed to Thread.SpinWait. Effectively, the first few iterations have a longer delay than before on Sandy Bridge and a shorter delay than before on Skylake, and the later iterations have a much shorter delay than before on both.
  - Yield/Sleep(0) stage
    - Observed a couple of issues:
      - When there are no threads to switch to, Yield and Sleep(0) become no-op and it turns the spin loop into a busy-spin that may quickly reach the max spin count and cause the thread to enter a wait state, or may just busy-spin for longer than desired before a Sleep(1). Completing the spin loop too early can cause excessive context switcing if a wait follows, and entering the Sleep(1) stage too early can cause excessive delays.
      - If there are multiple threads doing Yield and Sleep(0) (typically from the same spin loop due to contention), they may switch between one another, delaying work that can make progress.
    - I found that it works well to interleave a Yield/Sleep(0) with YieldProcessor, it enforces a minimum delay for this stage. Modified SpinWait to do this until it reaches the Sleep(1) threshold.
  - Sleep(1) stage
    - I didn't see any benefit in the tests to interleave Sleep(1) calls with some Yield/Sleep(0) calls, perf seemed to be a bit worse actually. If the Sleep(1) stage is reached, there is probably a lot of contention and the Sleep(1) stage helps to remove some threads from the equation for a while. Adding some Yield/Sleep(0) in-between seems to add back some of that contention.
      - Modified SpinWait to use a Sleep(1) threshold, after which point it only does Sleep(1) on each spin iteration
    - For the Sleep(1) threshold, I couldn't find one constant that works well in all cases
      - For spin loops that are followed by a proper wait (such as a wait on an event that is signaled when the resource becomes available), they benefit from not doing Sleep(1) at all, and spinning in other stages for longer
      - For infinite spin loops, they usually seemed to benefit from a lower Sleep(1) threshold to reduce contention, but the threshold also depends on other factors like how much work is done in each spin iteration, how efficient waiting is, and whether waiting has any negative side-effects.
      - Added an internal overload of SpinWait.SpinOnce to take the Sleep(1) threshold as a parameter
- SpinWait - Tweaked the spin strategy as mentioned above
- ManualResetEventSlim - Changed to use SpinWait, retuned the default number of iterations (total delay is still significantly less than before). Retained the previous behavior of having Sleep(1) if a higher spin count is requested.
- Task - It was using the same heuristics as ManualResetEventSlim, copied the changes here as well
- SemaphoreSlim - Changed to use SpinWait, retuned similarly to ManualResetEventSlim but with double the number of iterations because the wait path is a lot more expensive
- SpinLock - SpinLock was using very long YieldProcessor spins. Changed to use SpinWait, removed process count multiplier, simplified.
- ReaderWriterLockSlim - This one is complicated as there are many issues. The current spin heuristics performed better even after normalizing Thread.SpinWait but without changing the SpinWait iterations (the delay is longer than before), so I left this one as is.
- The perf (see numbers in PR below) seems to be much better than both the baseline and the Thread.SpinWait divide by 7 experiment
  - On Sandy Bridge, I didn't see many significant regressions. ReaderWriterLockSlim is a bit worse in some cases and a bit better in other similar cases, but at least the really low scores in the baseline got much better and not the other way around.
  - On Skylake, some significant regressions are in SemaphoreSlim throughput (which I'm discounting as I mentioned above in the experiment) and CountdownEvent add/signal throughput. The latter can probably be improved later.

JIT: fix some instruction size estimates (#13432)

The jit might double-count the REX prefix for certain reg-reg moves, and
could overestimate the size of a code-referent LEA.

While the downstream emitter code can tolerate overestimates, it is better
not to have them.

Closes #13398

Also fixes overestimates for the following:

* `call reg`
* `call [reg]`
* `call [reg + disp-byte]`
* `cmp al,byte`

Clear the init-locals bit for CoreLib to workaround #1279 (#13728)

* Clear the init-locals bit for CoreLib to workaround #1279

* Yet another place that depends on zero init locals

Update Type.GetMethods() to be generics friendly (#13745)

Update Type.GetMethods() to be generics friendly

Share four exception types (#13492)

* AE

* Move RuntimeWrappedException to shared

* Move AccessViolationException to shared

* Move IOException to shared

* nit

* assert to catch when message ought to include path

* AE feedback

* RWE feedback

* Remove most of __Error in favor of duplicate shared code in Win32Marshal

* Remove duplicated MakeHRFromErrorCode

* Extra using

* Revert RWE field rename

* Rename to wrappedException

* Make DNFE public for corefx

* Add no path case to match corefx

* Share DNFE

* Add underscore

* EOL

* Temporarily make DrNFE internal again

* Make RWE public

* Fixup __HResults

* Remove dead entries from Win32Native

* Redirect Kernel32 to PAL on Unix

* Remove dead targets file

* Unify on Interop.Libraries

* Refactor to expression-bodied property

Lst File updates.

This change includes:

1) lst_creator updates to allow adding priority tags automatically
2) arm32 lstFile updates: 29 new tests, 50 removed
3) arm64 lstFile updates: 80 new tests, 55 removed

Merge pull request #13743 from alpencolt/ryu-arm-13056-tests

[RyuJIT/ARM32] Add regression tests

[ARM64/Windows] Add JIT_Stelem_Ref helper (#13687)

* [ARM64/Windows] Add JIT_Stelem_Ref helper

* [ARM64/Windows] Modified JIT_Stelem_Ref helper to save and restore x0-x2 instead of x0-x8

* [ARM64/Windows] using EPILOG_BRANCH for correct unwind info

Initialize m_failedILStubs of ZapperStats (#13742)

Avoid StringBuilder allocation in ResourceManager (#13732)