Serialization: PooledArrayBufferWriter - AsReadOnlySequence does not return full output

[Romanx]

I ran into this problem and have reduced it down to the following repro.

It seems to be that the SequenceSegment Blocks cache for pooling on dispose of the first serialization session manages to get the same segment added twice and since it's a ConcurrentBag the set is not distinct.

This means that the second serialization attempt gets the pooled blocks and the first two requests get the same SequenceSegment which causes an odd linked list and data to be lost

using Microsoft.Extensions.DependencyInjection;
using Orleans.Serialization;
using Orleans.Serialization.Buffers;
using Orleans.Serialization.Buffers.Adaptors;
using Orleans.Serialization.Session;

namespace OrleansSerializerBug;

internal class Program
{
    static void Main(string[] args)
    {
        var serviceProvider = new ServiceCollection()
            .AddSerializer()
            .BuildServiceProvider();

        var pool = serviceProvider.GetRequiredService<SerializerSessionPool>();
        var serializer = serviceProvider.GetRequiredService<Serializer>();

        var obj = LargeObject.BuildRandom();

        // First Works Fine
        SerializeObject(pool, serializer, obj);

        // Second Fails
        SerializeObject(pool, serializer, obj);

        static void SerializeObject(SerializerSessionPool pool, Serializer serializer, LargeObject obj)
        {
            Writer<PooledArrayBufferWriter> writer = default;
            try
            {
                writer = Writer.CreatePooled(pool.GetSession());
                serializer.Serialize(obj, ref writer);

                var sequence = writer.Output.AsReadOnlySequence();
                if (sequence.Length != writer.Output.Length)
                {
                    Console.WriteLine($"""
                        Output sequence has length "{sequence.Length}" that does not match writer output length "{writer.Output.Length}"
                        """);
                }
            }
            finally
            {
                writer.Dispose();
            }
        }
    }
}

[GenerateSerializer]
public readonly record struct LargeObject(
[property: Id(0)] Guid Id,
[property: Id(1)] (Guid, Guid)[] Values)
{
    public static LargeObject BuildRandom()
    {
        var id = Guid.NewGuid();
        var values = new (Guid, Guid)[256];

        for (var i = 0; i < values.Length; i++)
        {
            values[i] = (Guid.NewGuid(), Guid.NewGuid());
        }

        return new(id, values);
    }
}

[ReubenBond]

Which version of Orleans is this? I think this was likely fixed in #8453, but we ought to include this test

[Romanx]

Sorry missed that on the original post. This is using latest at the time of posting: 7.1.2