Unsafe and Span optimizations

[TimothyMakkison]

Related to #433. One of the main benefits Mapperly has over other mappers is that it generates readable code. What is Mapperly's stance on prioritizing high-performance code over readability? Furthermore, is the use of System.Runtime.CompilerServices.Unsafe code approved?

There are a couple of places in EnumerableMapping where Span could be used to boost the performance of mappings. Mainly when dealing with List and Array. Some of my proposed changes (ie operating on the array Span) are probably worth it, whereas others (mutating a Lists underlying Span) are obtuse and micro benchmarky.

// long[] -> int[]
var sourceSpan = source.AsSpan();
var target = new int[sourceSpan .Length];
var targetSpan = target.AsSpan();
for (var i = 0; i < sourceSpan.Length; i++)
{
    targetSpan[i] = (int)sourceSpan[i];
}

return target;

We can increase List iteration performance by using CollectionsMarshal.AsSpan and getting the span to the internal array. Note that this is unsafe but iirc should be safe as we are not altering the source List. This is faster than using Enumerable.ToArray but is more verbose and harder to understand.

// List<long> -> int[]
var sourceSpan = CollectionsMarshal.AsSpan(source);
var target = new int[sourceSpan.Length];
var targetSpan = target.AsSpan();
for (var i = 0; i < sourceSpan.Length; i++)
{
    targetSpan[i] = (int)sourceSpan[i];
}

return target;

Mutating a Lists underlying Array and then updating its length using a hacky Unsafe method, 33-60% or 15-40% faster for lengths 100-1,000,000 depending on the element type.

List<long> Do(List<int> source)
{
    var sourceSpan = CollectionsMarshal.AsSpan(source);
    var target = new List<long>(sourceSpan.Length);
    var targetSpan = CollectionsMarshal.AsSpan(target);

    targetSpan = MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(targetSpan), sourceSpan.Length);

    for (var i = 0; i < sourceSpan.Length; i++)
    {
        targetSpan[i] = MapToLong(sourceSpan[i]);
    }

    var internalList = Unsafe.As<InternalList<int>>(target);
    var s = internalList._size;
    var si = internalList._version;
    internalList._size = sourceSpan.Length;

    return target;
}

public class InternalList<T>
{
    internal T[] _items; // Do not rename (binary serialization)
    internal int _size; // Do not rename (binary serialization)
    internal int _version; // Do not rename (binary serialization)
}

[latonz]

Thank you for those ideas! I think the goal of Mapperly is to keep a good balance between performance and readability.
We also need to pay attention to backwards compatibility. AFAIK eg. CollectionsMarshal is only available for .NET5+, so the source generator would need to detect available classes (Mapperly does this already at other places).
Before we adjust the implementation this should be benchmarked carefully.

[TimothyMakkison]

We also need to pay attention to backwards compatibility. AFAIK eg. CollectionsMarshal is only available for .NET5+, so the source generator would need to detect available classes (Mapperly does this already at other places). Before we adjust the implementation this should be benchmarked carefully.

Yeah I'd completely forgot about older versions. 😅

It would probably be worth checking if Span is available in ArrayForMapping and using it. I'd argue the extra line is still understandable. Using Unsafe.As on List is a little too arcane too be worth using.