Memmove: handle overlapping forward copies in managed code

[EgorBo]

Experiment to test with EgorBot.

SpanHelpers.Memmove currently P/Invokes the CRT memmove for any overlap at any length. Its forward copy loop is tuned for disjoint buffers, so same-array left shifts (List<T>.RemoveAt and friends) hit two separate cliffs — see #132690:

• rep movsb collapses to ~3 GB/s when the buffers are less than a cache line apart (Emerald Rapids, 40 KB copy)
• for large copies it switches to non-temporal stores, evicting the very lines the rest of the copy reads back (Zen 4, 4 MB copy: 23 GB/s)

This copies the dest < src case in managed code, in strictly ascending order with the destination aligned. Right shifts are untouched — the CRT's backward loop has neither problem.

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-memory
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

This PR changes SpanHelpers.Memmove’s handling of overlapping forward copies (dest < src) to avoid always calling into native memmove, adding a managed, strictly-forward copy strategy (including a vectorized path) intended to improve throughput for common same-buffer left-shift patterns.

Changes:

• Adds a forward-overlap fast path that routes dest < src overlapping copies to a new managed helper.
• Introduces MemmoveOverlappedForward and CopyForwardVectorized to copy in strictly ascending order and avoid the native overlap cliff.
• Chunks native memmove calls for large overlapping forward copies when the managed vectorized path isn’t taken.

[EgorBo]

@EgorBot -windows_amd -windows_intel -windows_arm -macos_arm

using System.Collections.Generic;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Bench).Assembly).Run(args);

public class Bench {
    private List<int> _list;

    [Params(4, 10, 16, 100, 1000, 10000, 100000)]
    public int Count;

    [GlobalSetup]
    public void Setup() {
        _list = new List<int>(Count);
        for (int i = 0; i < Count; i++)
            _list.Add(i);
    }

    [Benchmark]
    public void RemoveSecond() {
        List<int> list = _list;
        list.RemoveAt(1);
        CollectionsMarshal.SetCount(list, Count);
    }
}

[EgorBo]

@EgorBot -windows_amd -windows_intel -windows_arm -macos_arm

using System.Collections.Generic;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Bench).Assembly).Run(args);

public class Bench {
    private List<int> _list;

    [Params(4, 10, 16, 100, 1000, 10000, 100000)]
    public int Count;

    [GlobalSetup]
    public void Setup() {
        _list = new List<int>(Count);
        for (int i = 0; i < Count; i++)
            _list.Add(i);
    }

    [Benchmark]
    public void RemoveSecond() {
        List<int> list = _list;
        list.RemoveAt(1);
        CollectionsMarshal.SetCount(list, Count);
    }
}

[EgorBo]

@EgorBot -windows_amd -windows_intel -windows_arm -macos_arm

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Bench<>).Assembly).Run(args);

[GenericTypeArguments(typeof(byte))]
[GenericTypeArguments(typeof(int))]
[GenericTypeArguments(typeof(long))]
public class Bench<T> {
    private T[] _array;

    [Params(4, 10, 16, 100, 1000, 10000, 100000)]
    public int Count;

    [GlobalSetup]
    public void Setup() => _array = new T[Count];

    [Benchmark]
    public void ShiftLeft() {
        Span<T> span = _array;
        span.Slice(1).CopyTo(span);
    }

    [Benchmark]
    public void ShiftRight() {
        Span<T> span = _array;
        span.Slice(0, span.Length - 1).CopyTo(span.Slice(1));
    }
}

[EgorBo]

@EgorBot -windows_amd -windows_intel -windows_arm -macos_arm -linux_amd

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Bench<>).Assembly).Run(args);

[GenericTypeArguments(typeof(byte))]
[GenericTypeArguments(typeof(int))]
[GenericTypeArguments(typeof(long))]
public class Bench<T> {
    private T[] _array;

    [Params(4, 10, 16, 100, 1000, 10000, 100000)]
    public int Count;

    [GlobalSetup]
    public void Setup() => _array = new T[Count];

    [Benchmark]
    public void ShiftLeft() {
        Span<T> span = _array;
        span.Slice(1).CopyTo(span);
    }

    [Benchmark]
    public void ShiftRight() {
        Span<T> span = _array;
        span.Slice(0, span.Length - 1).CopyTo(span.Slice(1));
    }
}