private T RoundTripThroughCodec <T>(T original)
{
T result;
var pipe = new Pipe();
using (var readerSession = _sessionPool.GetSession())
using (var writeSession = _sessionPool.GetSession())
{
var writer = Writer.Create(pipe.Writer, writeSession);
var codec = _codecProvider.GetCodec <T>();
codec.WriteField(
ref writer,
0,
null,
original);
writer.Commit();
_ = pipe.Writer.FlushAsync().AsTask().GetAwaiter().GetResult();
pipe.Writer.Complete();
_ = pipe.Reader.TryRead(out var readResult);
var reader = Reader.Create(readResult.Buffer, readerSession);
var previousPos = reader.Position;
var initialHeader = reader.ReadFieldHeader();
Assert.True(reader.Position > previousPos);
result = codec.ReadValue(ref reader, initialHeader);
pipe.Reader.AdvanceTo(readResult.Buffer.End);
pipe.Reader.Complete();
}
return(result);
}
public MessageSerializer(
Serializer <object> bodySerializer,
SerializerSessionPool sessionPool,
SharedMemoryPool memoryPool,
IServiceProvider services,
Serializer <GrainAddress> activationAddressSerializer,
ICodecProvider codecProvider,
int maxHeaderSize,
int maxBodySize)
{
_readerSiloAddressCodec = new CachingSiloAddressCodec();
_writerSiloAddressCodec = new CachingSiloAddressCodec();
_readerIdSpanCodec = new CachingIdSpanCodec();
_writerIdSpanCodec = new CachingIdSpanCodec();
_serializer = ActivatorUtilities.CreateInstance <Serializer>(services);
_activationAddressCodec = activationAddressSerializer;
_serializationSession = sessionPool.GetSession();
_deserializationSession = sessionPool.GetSession();
_memoryPool = memoryPool.Pool;
_bodySerializer = bodySerializer;
_maxHeaderLength = maxHeaderSize;
_maxBodyLength = maxBodySize;
_sessionPool = sessionPool;
_requestContextCodec = OrleansGeneratedCodeHelper.GetService <DictionaryCodec <string, object> >(this, codecProvider);
}
public IOutputBuffer Serialize(TValue input)
{
using var session = _sessionPool.GetSession();
var writer = Writer.Create(CreateBufferWriter(), session);
_serializer.Serialize(input, ref writer);
return(writer.Output);
}
private async Task ReceivePump(CancellationToken cancellation)
{
using (var session = _serializerSessionPool.GetSession())
{
var input = _connection.Input;
while (!cancellation.IsCancellationRequested)
{
ReadResult result;
while (true)
{
if (!input.TryRead(out result))
{
result = await input.ReadAsync(cancellation);
}
if (result.IsCanceled)
{
break;
}
if (result.Buffer.IsEmpty && result.IsCompleted)
{
break;
}
var message = ReadMessage(result.Buffer, session, out var consumedTo);
session.PartialReset();
input.AdvanceTo(consumedTo);
if (!_incoming.TryWrite(message))
{
await _incoming.WriteAsync(message, cancellation);
}
}
if (result.IsCanceled)
{
break;
}
if (result.Buffer.IsEmpty && result.IsCompleted)
{
break;
}
}
}
Message ReadMessage(ReadOnlySequence <byte> payload, SerializerSession session, out SequencePosition consumedTo)
{
var reader = Reader.Create(payload, session);
var result = _messageSerializer.Deserialize(ref reader);
consumedTo = payload.GetPosition(reader.Position);
return(result);
}
}
public ComplexTypeBenchmarks()
{
_orleansSerializer = new ClientBuilder()
.ConfigureDefaults()
.UseLocalhostClustering()
.ConfigureServices(s => s.ToList().ForEach(r =>
{
if (r.ServiceType == typeof(IConfigurationValidator))
{
_ = s.Remove(r);
}
}))
.Configure <ClusterOptions>(o => o.ClusterId = o.ServiceId = "test")
.ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(SimpleClass).Assembly).WithCodeGeneration())
.Build().ServiceProvider.GetRequiredService <SerializationManager>();
var services = new ServiceCollection();
_ = services
.AddHagar(hagar => hagar.AddISerializableSupport().AddAssembly(typeof(Program).Assembly));
var serviceProvider = services.BuildServiceProvider();
_hagarSerializer = serviceProvider.GetRequiredService <Serializer <ComplexClass> >();
_structSerializer = serviceProvider.GetRequiredService <Serializer <SimpleStruct> >();
_sessionPool = serviceProvider.GetRequiredService <SerializerSessionPool>();
_value = new ComplexClass
{
BaseInt = 192,
Int = 501,
String = "bananas",
//Array = Enumerable.Range(0, 60).ToArray(),
//MultiDimensionalArray = new[,] {{0, 2, 4}, {1, 5, 6}}
};
_value.AlsoSelf = _value.BaseSelf = _value.Self = _value;
_structValue = new SimpleStruct
{
Int = 42,
Bool = true,
Guid = Guid.NewGuid()
};
_session = _sessionPool.GetSession();
var writer = HagarBuffer.CreateWriter(_session);
_hagarSerializer.Serialize(_value, ref writer);
var bytes = new byte[writer.Output.GetMemory().Length];
writer.Output.GetReadOnlySequence().CopyTo(bytes);
_hagarBytes = new ReadOnlySequence <byte>(bytes);
HagarBuffer.Reset();
var writer2 = new BinaryTokenStreamWriter();
_orleansSerializer.Serialize(_value, writer2);
_orleansBytes = writer2.ToBytes();
_readBytesLength = Math.Min(bytes.Length, _orleansBytes.Sum(x => x.Count));
}
public void CorrectlyAdvancesReferenceCounterStream()
{
var stream = new MemoryStream();
using var writerSession = _sessionPool.GetSession();
using var readerSession = _sessionPool.GetSession();
var writer = Writer.Create(stream, writerSession);
var writerCodec = CreateCodec();
// Write the field. This should involve marking at least one reference in the session.
Assert.Equal(0, writer.Position);
foreach (var value in TestValues)
{
var beforeReference = writer.Session.ReferencedObjects.CurrentReferenceId;
writerCodec.WriteField(ref writer, 0, typeof(TValue), value);
Assert.True(writer.Position > 0);
writer.Commit();
var afterReference = writer.Session.ReferencedObjects.CurrentReferenceId;
Assert.True(beforeReference < afterReference, $"Writing a field should result in at least one reference being marked in the session. Before: {beforeReference}, After: {afterReference}");
if (value is null)
{
Assert.True(beforeReference + 1 == afterReference, $"Writing a null field should result in exactly one reference being marked in the session. Before: {beforeReference}, After: {afterReference}");
}
stream.Flush();
stream.Position = 0;
var reader = Reader.Create(stream, readerSession);
var previousPos = reader.Position;
Assert.Equal(0, previousPos);
var readerCodec = CreateCodec();
var readField = reader.ReadFieldHeader();
Assert.True(reader.Position > previousPos);
previousPos = reader.Position;
beforeReference = reader.Session.ReferencedObjects.CurrentReferenceId;
var readValue = readerCodec.ReadValue(ref reader, readField);
Assert.True(reader.Position > previousPos);
afterReference = reader.Session.ReferencedObjects.CurrentReferenceId;
Assert.True(beforeReference < afterReference, $"Reading a field should result in at least one reference being marked in the session. Before: {beforeReference}, After: {afterReference}");
if (readValue is null)
{
Assert.True(beforeReference + 1 == afterReference, $"Reading a null field should result in at exactly one reference being marked in the session. Before: {beforeReference}, After: {afterReference}");
}
}
}
