Does pinning buffer improve performance with ClientWebSocket.ReceiveAsync?

[unsafePtr]

I'm working on optimizing WebSocket communication using ClientWebSocket and I'm trying to understand whether manually pinning the receive buffer provides any performance benefits.

Considering pinning the underlying buffer using

var buffer = GC.AllocateUninitializedArray<byte>(size, pinned: true);
var memory = MemoryMarshal.CreateFromPinnedArray(buffer, 0, size)
ValueWebSocketReceiveResult result;

while (!cts.IsCancellationRequested)
{
    result = await _webSocket.ReceiveAsync(memory, cts.Token)
        .ConfigureAwait(false);
    
    if(result.State == WebSocketState.Open)
    {
        Handle(result, buffer);
    }
}

In my opinion, it should be faster since there is dedicated pinned heap. Plus GC will skip all together inspecting such array? What are the trade-offs of keeping WebSocket buffers pinned? I see only benefits, since such buffer will be of the lifetime of the application.

[huoyaoyuan]

The main benefit of using MemoryMarshal.CreateFromPinnedArray is to skip the GC handle allocation when calling Memory<T>.Pin. However, WebSocket (as well as most I/O routines) prefer to extract the underlying array directly and doesn't use that path.

In my opinion, it should be faster since there is dedicated pinned heap.

It's dual blade. It can avoid occupying Gen 0 memory area if pinned for longer time, but also reduce memory locality for using separated heap.

Plus GC will skip all together inspecting such array?

It will be collected as usual. The only difference of pinned heap is no moving during GC collection.

What are the trade-offs of keeping WebSocket buffers pinned? I see only benefits, since such buffer will be of the lifetime of the application.

It's hard to make assertion without measurement.

[stephentoub]

It will be collected as usual. The only difference of pinned heap is no moving during GC collection.

The POH is only collected as part of gen2. Creating temporary buffers on the POH is something to be avoided.

[unsafePtr]

Thank you for more information.

Did some benchmarks, and it seems that with a pinned buffer (tried with 128kb, 256kb) it's slower than unpinned. The difference was with a margin of error. But it's also possible that I am doing something wrong

[huoyaoyuan]

If the array size reaches the threshold for LOH, I don't expect the performance characteristic to differ much. LOH behaves quite similar to POH (collected with Gen2, effectively pinned until requested for compacting).