[API Proposal]: Add some Memory API to do tricky mappings

[Stoorx]

Background and motivation

Once upon a time I decided to implement the fastest gun circular buffer on the wild West. I have found a tricky solution which maps two virtual pages to the same physical page. This thick virtually 'unwraps' the circular buffer over the page bounds. This leads to three and a half benefits:

1. There is no need to perform modulo operations to wrap elements. It is made by MMU hardware, since the second page are mapped into the same as first.
2. Since the elements are virtually unwrapped now, we can perform bulk operations in single copy operation.
3. That buffer is inherently a bipartite buffer, which can be used in APIs that expect only contigous memory region.
   3.5. This is more SIMD friendly (I am not sure)

I can easily implement that trick in C++ using mmap() or VirtualAlloc(). But it still seems impossible to me to implement it in C# without using P/Invoke or another kludges. I had an idea to use a memory mapped file and somehow pin it twice with (some help of unsafe sections), but it looks really clumsy.

Maybe it is possible to implement in more elegant way, but I did not find any good ideas. (Or it is just googling skill issue)
I am open for discussion and hope this API would be helpful not only for circular buffers. I think I can implement this API by myself after we discuss the design of it.

API Proposal

I still have no idea of the best API design. But maybe something like that...

public class Memory
{
    public static unsafe void VirtualMap(IntPtr from, IntPtr to);
    public static unsafe void VirtualUnmap(IntPtr ptr);
}

API Usage

Something like that

public class RingBuffer: IDisposable
{
    private IntPtr _buffer;
    private int _size;
    ...
    public RingBuffer(int size)
    {
        ...
        unsafe {
            _buffer = GCHandle.Alloc(size * 2);
            Memory.VirtualMap(_buffer + size, _buffer); // Map second half of the buffer to the same page
        }
        ...
    }
    public void Dispose(){
        Memory.VirtualUnmap(_buffer + _size);
        GCHandle.Free(_buffer);
    }
}

Alternative Designs

No response

Risks

It is difficult to me to predict some risks at this point. But I think there is a possible issues with JIT, GC or dotnet memory model.

[DaZombieKiller]

Related to #40892

[dotnet-policy-service]

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

[KalleOlaviNiemitalo]

Aliased mapping of a circular buffer was mentioned in #63474 (comment). According to #75790 (comment), writes cause undefined behavior.