public virtual void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
{
var valueType = type.GetGenericArguments()[0];
var noValueLabel = il.DefineLabel();
MethodInfo getHasValue = type.GetProperty("HasValue").GetGetMethod();
MethodInfo getValue = type.GetProperty("Value").GetGetMethod();
var data = serializer.GetIndirectData(valueType);
il.Emit(OpCodes.Ldarg_1); // Stream
il.Emit(OpCodes.Ldarga_S, 2); // &value
il.Emit(OpCodes.Call, getHasValue);
il.Emit(OpCodes.Call, serializer.GetDirectWriter(typeof(bool)));
il.Emit(OpCodes.Ldarga_S, 2); // &value
il.Emit(OpCodes.Call, getHasValue);
il.Emit(OpCodes.Brfalse_S, noValueLabel);
if (data.WriterNeedsInstance)
il.Emit(OpCodes.Ldarg_0); // Serializer
il.Emit(OpCodes.Ldarg_1); // Stream
il.Emit(OpCodes.Ldarga_S, 2); // &value
il.Emit(OpCodes.Call, getValue);
// XXX for some reason Tailcall causes huge slowdown, at least with "decimal?"
//il.Emit(OpCodes.Tailcall);
il.Emit(OpCodes.Call, data.WriterMethodInfo);
il.MarkLabel(noValueLabel);
il.Emit(OpCodes.Ret);
}
static void Main(string[] args)
{
if (ParseArgs(args) == false)
{
return;
}
if (ShareSerializer)
{
s_sharedSerializer = Tester.CreateSerializer();
}
List <Thread> threads = new List <Thread>();
for (int i = 0; i < NumThreads; ++i)
{
var thread = new Thread(Test);
threads.Add(thread);
}
foreach (var thread in threads)
{
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
}
}
public void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
{
// arg0: Serializer, arg1: Stream, arg2: value
var fields = Helpers.GetFieldInfos(type);
foreach (var field in fields)
{
// Note: the user defined value type is not passed as reference. could cause perf problems with big structs
var fieldType = field.FieldType;
var data = serializer.GetIndirectData(fieldType);
if (data.WriterNeedsInstance)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
if (type.IsValueType)
il.Emit(OpCodes.Ldarga_S, 2);
else
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldfld, field);
il.Emit(OpCodes.Call, data.WriterMethodInfo);
}
il.Emit(OpCodes.Ret);
}
private void Initialize()
{
if (!JustInitialized) return;
var typeList = new List<Type> {_primaryType};
typeList.AddRange(_secondaryTypes);
_serializer = new Serializer(typeList);
JustInitialized = false;
}
public Tester(NS.Serializer serializer)
{
m_specimens.Add(new NetSerializerSpecimen(serializer));
if (Program.RunProtoBufTests)
{
m_specimens.Add(new ProtobufSpecimen());
}
}
static void Main(string[] args)
{
bool show_help = false;
var p = new Mono.Options.OptionSet()
{
{ "q|quick", "quick run", _ => QuickRun = true },
{ "p|protobuf", "run protobuf tests", _ => RunProtoBufTests = true },
{ "v|verify", "verify results", _ => EnableResultCheck = true },
{ "threads=", "number of threads", (int v) => NumThreads = v },
{ "share", "share serializer between threads", _ => ShareSerializer = true },
{ "h|help", "show help", _ => show_help = true },
};
List <string> extra;
try
{
extra = p.Parse(args);
}
catch (Mono.Options.OptionException e)
{
Console.WriteLine(e.Message);
return;
}
if (show_help || extra.Count > 0)
{
p.WriteOptionDescriptions(Console.Out);
return;
}
if (ShareSerializer)
{
s_sharedSerializer = Tester.CreateSerializer();
}
List <Thread> threads = new List <Thread>();
for (int i = 0; i < NumThreads; ++i)
{
var thread = new Thread(Test);
threads.Add(thread);
}
foreach (var thread in threads)
{
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
}
}
public void GenerateReaderMethod(Serializer serializer, Type type, ILGenerator il)
{
// arg0: Serializer, arg1: stream, arg2: out value
if (type.IsClass)
{
// instantiate empty class
il.Emit(OpCodes.Ldarg_2);
var gtfh = typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Public | BindingFlags.Static);
var guo = typeof(System.Runtime.Serialization.FormatterServices).GetMethod("GetUninitializedObject", BindingFlags.Public | BindingFlags.Static);
il.Emit(OpCodes.Ldtoken, type);
il.Emit(OpCodes.Call, gtfh);
il.Emit(OpCodes.Call, guo);
il.Emit(OpCodes.Castclass, type);
il.Emit(OpCodes.Stind_Ref);
}
var fields = Helpers.GetFieldInfos(type);
foreach (var field in fields)
{
var fieldType = field.FieldType;
var data = serializer.GetIndirectData(fieldType);
if (data.ReaderNeedsInstance)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
if (type.IsClass)
il.Emit(OpCodes.Ldind_Ref);
il.Emit(OpCodes.Ldflda, field);
il.Emit(OpCodes.Call, data.ReaderMethodInfo);
}
if (typeof(System.Runtime.Serialization.IDeserializationCallback).IsAssignableFrom(type))
{
var miOnDeserialization = typeof(System.Runtime.Serialization.IDeserializationCallback).GetMethod("OnDeserialization",
BindingFlags.Instance | BindingFlags.Public,
null, new[] { typeof(Object) }, null);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Constrained, type);
il.Emit(OpCodes.Callvirt, miOnDeserialization);
}
il.Emit(OpCodes.Ret);
}
public override void BeforeRuns(Test test)
{
try
{
m_Serializer = m_KnownTypes==null ? new NetSerializer.Serializer( new Type[]{test.GetPayloadRootType() })
: new NetSerializer.Serializer( new Type[]{test.GetPayloadRootType() }.Concat(m_KnownTypes));
}
catch (Exception error)
{
test.Abort(this, "Error making NetSerializer instance in serializer BeforeRun() {0}. \n Did you decorate the primary known type correctly?".Args(error.ToMessageWithType()));
}
}
public override void BeforeRuns(Test test)
{
try
{
m_Serializer = m_KnownTypes == null ? new NetSerializer.Serializer(new Type[] { test.GetPayloadRootType() })
: new NetSerializer.Serializer(new Type[] { test.GetPayloadRootType() }.Concat(m_KnownTypes));
}
catch (Exception error)
{
test.Abort(this, "Error making NetSerializer instance in serializer BeforeRun() {0}. \n Did you decorate the primary known type correctly?".Args(error.ToMessageWithType()));
}
}
public static NS.Serializer CreateSerializer()
{
var types = GetKnownTypes().ToArray();
var sw = Stopwatch.StartNew();
var serializer = new NS.Serializer(types, new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() });
sw.Stop();
Console.WriteLine("Serializer.Initialize() in {0} ms", sw.ElapsedMilliseconds);
//NS.Serializer.GenerateDebugAssembly(types, new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() });
return serializer;
}
public static NS.Serializer CreateSerializer()
{
var types = typeof(MessageBase).Assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(MessageBase)))
.Concat(new Type[] { typeof(SimpleClass), typeof(SimpleClass2) })
.ToArray();
var sw = Stopwatch.StartNew();
var serializer = new NS.Serializer(types, new NS.ITypeSerializer[] { new CustomSerializers() });
sw.Stop();
Console.WriteLine("Serializer.Initialize() in {0} ms", sw.ElapsedMilliseconds);
return serializer;
}
public static NS.Serializer CreateSerializer()
{
var types = typeof(MessageBase).Assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(MessageBase)))
.Concat(new Type[] { typeof(SimpleClass), typeof(SimpleClass2) })
.ToArray();
var sw = Stopwatch.StartNew();
var serializer = new NS.Serializer(types, new NS.ITypeSerializer[] { new CustomSerializers() });
sw.Stop();
Console.WriteLine("Serializer.Initialize() in {0} ms", sw.ElapsedMilliseconds);
return(serializer);
}
public static NS.Serializer CreateSerializer()
{
var types = GetKnownTypes().ToArray();
var sw = Stopwatch.StartNew();
var serializer = new NS.Serializer(types, new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() });
sw.Stop();
Console.WriteLine("Serializer.Initialize() in {0} ms", sw.ElapsedMilliseconds);
//NS.Serializer.GenerateDebugAssembly(types, new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() });
return(serializer);
}
public static void Deserialize(Serializer serializer, Stream stream, out object ob)
{
uint id;
Primitives.ReadPrimitive(stream, out id);
if (id == 0)
{
ob = null;
return;
}
var del = serializer.GetDeserializeTrampolineFromId(id);
del(serializer, stream, out ob);
}
static void Main(string[] args)
{
if (ParseArgs(args) == false)
{
return;
}
if (ShareSerializer)
{
s_sharedSerializer = Tester.CreateSerializer();
}
List <Thread> threads = new List <Thread>();
for (int i = 0; i < NumThreads; ++i)
{
var thread = new Thread(Test);
threads.Add(thread);
}
foreach (var thread in threads)
{
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
}
Console.WriteLine();
Console.WriteLine("Serialized objects of types:");
foreach (var type in Tester.SerializedTypes.OrderBy(x => x.FullName))
{
Console.WriteLine(type.FullName);
}
Console.WriteLine();
Console.WriteLine("Deserialized objects with type ids:");
foreach (var id in Tester.DeserializedTypeIds.OrderBy(x => x))
{
Console.WriteLine(id);
}
Console.ReadKey();
}
public static void Serialize(Serializer serializer, Stream stream, object ob)
{
if (ob == null)
{
Primitives.WritePrimitive(stream, (uint)0);
return;
}
var type = ob.GetType();
SerializeDelegate<object> del;
uint id = serializer.GetTypeIdAndSerializer(type, out del);
Primitives.WritePrimitive(stream, id);
del(serializer, stream, ob);
}
static void Main(string[] args)
{
if (ShareSerializer)
s_sharedSerializer = Tester.CreateSerializer();
List<Thread> threads = new List<Thread>();
for (int i = 0; i < NumThreads; ++i)
{
var thread = new Thread(Test);
threads.Add(thread);
}
foreach (var thread in threads)
thread.Start();
foreach (var thread in threads)
thread.Join();
}
public virtual void GenerateReaderMethod(Serializer serializer, Type type, ILGenerator il)
{
var valueType = type.GetGenericArguments()[0];
var hasValueLocal = il.DeclareLocal(typeof(bool));
var valueLocal = il.DeclareLocal(valueType);
var notNullLabel = il.DefineLabel();
var data = serializer.GetIndirectData(valueType);
// read array len
il.Emit(OpCodes.Ldarg_1); // Stream
il.Emit(OpCodes.Ldloca_S, hasValueLocal); // &hasValue
il.Emit(OpCodes.Call, serializer.GetDirectReader(typeof(bool)));
// if hasValue == 0, return null
il.Emit(OpCodes.Ldloc_S, hasValueLocal);
il.Emit(OpCodes.Brtrue_S, notNullLabel);
il.Emit(OpCodes.Ldarg_2); // &value
il.Emit(OpCodes.Initobj, type);
il.Emit(OpCodes.Ret);
// hasValue == 1
il.MarkLabel(notNullLabel);
if (data.ReaderNeedsInstance)
il.Emit(OpCodes.Ldarg_0); // Serializer
il.Emit(OpCodes.Ldarg_1); // Stream
il.Emit(OpCodes.Ldloca_S, valueLocal);
il.Emit(OpCodes.Call, data.ReaderMethodInfo);
il.Emit(OpCodes.Ldarg_2); // &value
il.Emit(OpCodes.Ldloc_S, valueLocal);
var constr = type.GetConstructor(new[] { valueType });
il.Emit(OpCodes.Newobj, constr); // new Nullable<T>(valueLocal)
il.Emit(OpCodes.Stobj, type); // store to &value
il.Emit(OpCodes.Ret);
}
public static NS.Serializer CreateSerializer()
{
var types = GetKnownTypes().ToArray();
var sw = Stopwatch.StartNew();
var settings = new NS.Settings()
{
CustomTypeSerializers = new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() },
BeforeSerializingObjectOfType = type => m_serializedTypes.Add(type),
BeforeDeserializingObjectWithTypeId = id => m_deserializedTypeIds.Add(id)
};
var serializer = new NS.Serializer(types, settings);
sw.Stop();
Console.WriteLine("Serializer.Initialize() in {0} ms", sw.ElapsedMilliseconds);
//NS.Serializer.GenerateDebugAssembly(types, new NS.ITypeSerializer[] { new TriDimArrayCustomSerializer() });
return(serializer);
}
public static void Serialize(Serializer serializer, Stream stream, object ob)
{
}
static void Serialize(Serializer serializer, Stream stream, object ob)
{
if (ob == null)
{
Primitives.WritePrimitive(stream, 0);
return;
}
var type = ob.GetType();
ushort id;
if (serializer.m_typeIDMap.TryGetValue(type, out id) == false)
throw new InvalidOperationException(String.Format("Unknown type {0}", type.FullName));
Primitives.WritePrimitive(stream, id);
serializer.m_serializerTrampolines[id](serializer, stream, ob);
}
private static string ExtractDMI(string input, string outPath, string file)
{
var ser =
new Serializer(new List<Type> {typeof (DmiImage), typeof (DMIState), typeof (DMIFrame), typeof (DMIImageData)});
DmiImage dmi = null;
try
{
dmi = new DmiImage(file);
}
catch (Exception e)
{
_log.Error("Error during extraction",e);
return null;
}
// only parse power of two
if (!IsPowerOfTwo(dmi.StateHeight) && !IsPowerOfTwo(dmi.StateWidth))
return null;
var oPath = Path.Combine(outPath, Path.GetDirectoryName(file.Replace(input + "\\", "")), dmi.DmiName);
if (!Directory.Exists(oPath))
Directory.CreateDirectory(oPath);
using (var stream = File.Create(Path.Combine(oPath, Datafile)))
{
ser.Serialize(stream, dmi);
}
var stateIndex = 0;
foreach (var dmiState in dmi.States)
{
var statePath = Path.Combine(oPath, stateIndex.ToString());
if (!Directory.Exists(statePath))
Directory.CreateDirectory(statePath);
int frameIndex = 0;
foreach (var frame in dmiState.GetFrames())
{
var framePath = Path.Combine(statePath, frameIndex.ToString());
if (!Directory.Exists(framePath))
Directory.CreateDirectory(framePath);
foreach (var image in frame.GetImages())
{
var imgPath = Path.Combine(framePath, image.Dir + ".png");
var bitmap = !use4X ? hqx.HqxSharp.Scale2(image.Bitmap) : hqx.HqxSharp.Scale4(image.Bitmap);
bitmap.Save(imgPath);
}
frameIndex++;
}
stateIndex++;
}
_log.InfoFormat("Extracted {0}",file);
return Path.Combine(oPath, Datafile);
}
public NetSerializerSpecimen(NS.Serializer serializer)
{
m_serializer = serializer;
}
public Tester(NS.Serializer serializer)
{
m_serializer = serializer;
}
public void GenerateReaderMethod(Serializer serializer, Type type, ILGenerator il)
{
var elemType = type.GetElementType();
var lenLocal = il.DeclareLocal(typeof(uint));
// read array len
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloca_S, lenLocal);
il.Emit(OpCodes.Call, serializer.GetDirectReader(typeof(uint)));
var notNullLabel = il.DefineLabel();
/* if len == 0, return null */
il.Emit(OpCodes.Ldloc_S, lenLocal);
il.Emit(OpCodes.Brtrue_S, notNullLabel);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Stind_Ref);
il.Emit(OpCodes.Ret);
il.MarkLabel(notNullLabel);
var arrLocal = il.DeclareLocal(type);
// create new array with len - 1
il.Emit(OpCodes.Ldloc_S, lenLocal);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Sub);
il.Emit(OpCodes.Newarr, elemType);
il.Emit(OpCodes.Stloc_S, arrLocal);
// declare i
var idxLocal = il.DeclareLocal(typeof(int));
// i = 0
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc_S, idxLocal);
var loopBodyLabel = il.DefineLabel();
var loopCheckLabel = il.DefineLabel();
il.Emit(OpCodes.Br_S, loopCheckLabel);
// loop body
il.MarkLabel(loopBodyLabel);
// read element to arr[i]
var data = serializer.GetIndirectData(elemType);
if (data.ReaderNeedsInstance)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloc_S, arrLocal);
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldelema, elemType);
il.Emit(OpCodes.Call, data.ReaderMethodInfo);
// i = i + 1
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc_S, idxLocal);
il.MarkLabel(loopCheckLabel);
// loop condition
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldloc_S, arrLocal);
il.Emit(OpCodes.Ldlen);
il.Emit(OpCodes.Conv_I4);
il.Emit(OpCodes.Blt_S, loopBodyLabel);
// store new array to the out value
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldloc_S, arrLocal);
il.Emit(OpCodes.Stind_Ref);
il.Emit(OpCodes.Ret);
}
static void Main(string[] args)
{
var p = new Person
{
Age = 99999,
FirstName = "Windows",
LastName = "Server",
Sex = Sex.Male,
};
IList <Person> l = Enumerable.Range(1000, 1000).Select(x => new Person {
Age = x, FirstName = "Windows", LastName = "Server", Sex = Sex.Female
}).ToArray();
var integer = 1;
// var v3 = new Vector3 { x = 12345.12345f, y = 3994.35226f, z = 325125.52426f };
var v3 = new Vector3 {
x = 12345, y = 3994, z = 325125
};
// IList<Vector3> v3List = Enumerable.Range(1, 100).Select(_ => new Vector3 { x = 12345.12345f, y = 3994.35226f, z = 325125.52426f }).ToArray();
IList <Vector3> v3List = Enumerable.Range(1, 100).Select(_ => new Vector3 {
x = 12345, y = 3994, z = 325125
}).ToArray();
var largeString = File.ReadAllText("CSharpHtml.txt");
netSerializer = new NetSerializer.Serializer(new[] { p.GetType(), typeof(Person[]), integer.GetType(), v3.GetType(), typeof(Vector3[]), largeString.GetType() });
Iteration = WarmUpIteration;
Console.WriteLine("Warming-up"); Console.WriteLine();
SerializeZeroFormatter(p); SerializeZeroFormatter(l);
SerializeZeroFormatter(integer); SerializeZeroFormatter(v3); SerializeZeroFormatter(largeString); SerializeZeroFormatter(v3List);
SerializeProtobuf(p); SerializeProtobuf(l);
SerializeProtobuf(integer); SerializeProtobuf(v3); SerializeProtobuf(largeString); SerializeProtobuf(v3List);
SerializeMsgPack(p); SerializeMsgPack(l);
SerializeMsgPack(integer); SerializeMsgPack(v3); SerializeMsgPack(largeString); SerializeMsgPack(v3List);
SerializeJsonNet(p); SerializeJsonNet(l);
SerializeJil(p); SerializeJil(l);
SerializeFsPickler(p); SerializeFsPickler(l);
SerializeBinaryFormatter(p); SerializeBinaryFormatter(l);
SerializeDataContract(p); SerializeDataContract(l);
SerializeWire(p); SerializeWire(l);
SerializeWire(integer); SerializeWire(v3); SerializeWire(largeString); SerializeWire(v3List);
SerializeNetSerializer(p); SerializeNetSerializer((Person[])(object)l);
SerializeNetSerializer(integer); SerializeNetSerializer(v3); SerializeNetSerializer(largeString); SerializeNetSerializer((Vector3[])(object)v3List);
SerializeServiceStack(p); SerializeServiceStack((Person[])(object)l);
SerializeServiceStack(integer); SerializeServiceStack(v3); SerializeServiceStack(largeString); SerializeServiceStack((Vector3[])(object)v3List);
SerializeZippySerializer(p); SerializeZippySerializer((Person[])(object)l);
SerializeZippySerializer(integer); SerializeZippySerializer(v3); SerializeZippySerializer(largeString); SerializeZippySerializer((Vector3[])(object)v3List);
dryRun = false;
Iteration = RunIteration;
Console.WriteLine();
Console.WriteLine($"Small Object(int,string,string,enum) {Iteration} Iteration"); Console.WriteLine();
var a = SerializeZeroFormatter(p); Console.WriteLine();
var b = SerializeProtobuf(p); Console.WriteLine();
var c = SerializeMsgPack(p); Console.WriteLine();
var d = SerializeJsonNet(p); Console.WriteLine();
var e = SerializeJil(p); Console.WriteLine();
var f = SerializeFsPickler(p); Console.WriteLine();
var g = SerializeBinaryFormatter(p); Console.WriteLine();
var h = SerializeDataContract(p); Console.WriteLine();
var k = SerializeWire(p); Console.WriteLine();
var l2 = SerializeNetSerializer(p); Console.WriteLine();
var m = SerializeZippySerializer(p); Console.WriteLine();
SerializeServiceStack(p); Console.WriteLine();
Console.WriteLine($"Large Array(SmallObject[1000]) {Iteration} Iteration"); Console.WriteLine();
var M = SerializeZippySerializer(l); Console.WriteLine();
var A = SerializeZeroFormatter(l); Console.WriteLine();
var B = SerializeProtobuf(l); Console.WriteLine();
var C = SerializeMsgPack(l); Console.WriteLine();
var D = SerializeJsonNet(l); Console.WriteLine();
var E = SerializeJil(l); Console.WriteLine();
var F = SerializeFsPickler(l); Console.WriteLine();
var G = SerializeBinaryFormatter(l); Console.WriteLine();
var H = SerializeDataContract(l); Console.WriteLine();
var K = SerializeWire(l); Console.WriteLine();
var L = SerializeNetSerializer((Person[])(object)l); Console.WriteLine();
SerializeServiceStack((Person[])(object)l); Console.WriteLine();
//Validate("ZeroFormatter", p, l, a, A);
//Validate("protobuf-net", p, l, b, B);
//Validate("MsgPack-CLI", p, l, c, C);
//Validate("JSON.NET", p, l, d, D);
//Validate("Jil", p, l, e, E);
//Validate("FsPickler", p, l, f, F);
//Validate("BinaryFormatter", p, l, g, G);
//Validate("DataContract", p, l, h, H);
//Validate("Wire", p, l, k, K);
//Validate("NetSerializer", p, l, l2, L);
//Validate("Zippy", p, l, m, M);
Console.WriteLine();
Console.WriteLine("Additional Benchmarks"); Console.WriteLine();
Console.WriteLine($"Int32(1) {Iteration} Iteration"); Console.WriteLine();
SerializeZeroFormatter(integer); Console.WriteLine();
SerializeProtobuf(integer); Console.WriteLine();
SerializeMsgPack(integer); Console.WriteLine();
SerializeJsonNet(integer); Console.WriteLine();
SerializeJil(integer); Console.WriteLine();
SerializeFsPickler(integer); Console.WriteLine();
SerializeBinaryFormatter(integer); Console.WriteLine();
SerializeDataContract(integer); Console.WriteLine();
SerializeWire(integer); Console.WriteLine();
SerializeNetSerializer(integer); Console.WriteLine();
SerializeZippySerializer(integer); Console.WriteLine();
SerializeServiceStack(integer); Console.WriteLine();
//var W1 = SerializeZeroFormatter(integer); Console.WriteLine();
//var W2 = SerializeMsgPack(integer); Console.WriteLine();
//var W3 = SerializeProtobuf(integer); Console.WriteLine();
//var W4 = SerializeWire(integer); Console.WriteLine();
//var W5 = SerializeNetSerializer(integer); Console.WriteLine();
//var W6 = SerializeZippySerializer(integer); Console.WriteLine();
Console.WriteLine($"Vector3(float, float, float) {Iteration} Iteration"); Console.WriteLine();
SerializeZeroFormatter(v3); Console.WriteLine();
SerializeProtobuf(v3); Console.WriteLine();
SerializeMsgPack(v3); Console.WriteLine();
SerializeJsonNet(v3); Console.WriteLine();
SerializeJil(v3); Console.WriteLine();
SerializeFsPickler(v3); Console.WriteLine();
SerializeBinaryFormatter(v3); Console.WriteLine();
SerializeDataContract(v3); Console.WriteLine();
SerializeWire(v3); Console.WriteLine();
SerializeNetSerializer(v3); Console.WriteLine();
SerializeZippySerializer(v3); Console.WriteLine();
SerializeServiceStack(v3); Console.WriteLine();
Console.WriteLine($"HtmlString({Encoding.UTF8.GetByteCount(largeString)}bytes) {Iteration} Iteration"); Console.WriteLine();
SerializeZeroFormatter(largeString); Console.WriteLine();
SerializeProtobuf(largeString); Console.WriteLine();
SerializeMsgPack(largeString); Console.WriteLine();
SerializeJsonNet(largeString); Console.WriteLine();
SerializeJil(largeString); Console.WriteLine();
SerializeFsPickler(largeString); Console.WriteLine();
SerializeBinaryFormatter(largeString); Console.WriteLine();
SerializeDataContract(largeString); Console.WriteLine();
SerializeWire(largeString); Console.WriteLine();
SerializeNetSerializer(largeString); Console.WriteLine();
SerializeZippySerializer(largeString); Console.WriteLine();
SerializeServiceStack(largeString); Console.WriteLine();
Console.WriteLine($"Vector3[100] {Iteration} Iteration"); Console.WriteLine();
SerializeZeroFormatter(v3List); Console.WriteLine();
SerializeProtobuf(v3List); Console.WriteLine();
SerializeMsgPack(v3List); Console.WriteLine();
SerializeJsonNet(v3List); Console.WriteLine();
SerializeJil(v3List); Console.WriteLine();
SerializeFsPickler(v3List); Console.WriteLine();
SerializeBinaryFormatter(v3List); Console.WriteLine();
SerializeDataContract(v3List); Console.WriteLine();
SerializeWire(v3List); Console.WriteLine();
// SerializeNetSerializer(v3List); Console.WriteLine();
SerializeZippySerializer(v3List); Console.WriteLine();
SerializeServiceStack(v3List); Console.WriteLine();
var order1 = Measure.Results.GroupBy(v => v.Key.Split('.')[1]);
foreach (var data in order1)
{
Console.WriteLine();
Console.BackgroundColor = ConsoleColor.DarkGray;
Console.WriteLine(data.Key);
Console.BackgroundColor = ConsoleColor.Black;
int i = 1;
foreach (var item in data.OrderBy(v => v.Value))
{
if (item.Key.ToLower().Contains("zippy"))
{
Console.ForegroundColor = ConsoleColor.Green;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine(i.ToString() + ") " + item.Key + " : " + item.Value.ToString("#,##0.00"));
i++;
}
}
Console.WriteLine();
Console.WriteLine();
var order = Measure.Results.OrderBy(v => v.Value);
foreach (var item in order)
{
if (item.Key.ToLower().Contains("zippy"))
{
Console.ForegroundColor = ConsoleColor.Green;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine(item.Key + " : " + item.Value.ToString("#,##0.00"));
}
//Validate2("ZeroFormatter", W1, integer); Validate2("MsgPack-Cli", W2, integer); Validate2("MsgPack", W3, integer); Validate2("Wire", W4, integer); Validate2("NetSerializer", W5, integer); Validate2("Zippy", W6, integer);
//Validate2("ZeroFormatter", X1, v3); Validate2("MsgPack-Cli", X2, v3); Validate2("MsgPack", X3, v3); Validate2("Wire", X4, v3); Validate2("NetSerializer", X5, v3); Validate2("Zippy", X6, v3);
//Validate2("ZeroFormatter", Y1, largeString); ; Validate2("MsgPack-Cli", Y2, largeString); Validate2("MsgPack", Y3, largeString); Validate2("Wire", Y4, largeString); Validate2("NetSerializer", Y5, largeString); Validate2("Zippy", Y6, largeString);
//Validate2("ZeroFormatter", Z1, v3List); Validate2("MsgPack-Cli", Z2, v3List); Validate2("MsgPack", Z3, v3List); Validate2("Wire", Z4, v3List); Validate2("NetSerializer", Z5, v3List); Validate2("Zippy", Z6, v3List);
Console.WriteLine("Press key to exit.");
Console.ReadLine();
}
public NetTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="NETSerializer"/> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
public NETSerializer(NS.Serializer serializer) {
_serializer = serializer;
}
public MemStreamTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
public static void Deserialize(Serializer serializer, Stream stream, out object ob)
{
ob = null;
}
static void Main(string[] args)
{
var p = new Person
{
Age = 99999,
FirstName = "Windows",
LastName = "Server",
Sex = Sex.Male,
};
IList <Person> l = Enumerable.Range(1000, 1000).Select(x => new Person {
Age = x, FirstName = "Windows", LastName = "Server", Sex = Sex.Female
}).ToArray();
var integer = 1;
var v3 = new Vector3 {
x = 12345.12345f, y = 3994.35226f, z = 325125.52426f
};
IList <Vector3> v3List = Enumerable.Range(1, 100).Select(_ => new Vector3 {
x = 12345.12345f, y = 3994.35226f, z = 325125.52426f
}).ToArray();
var largeString = File.ReadAllText("CSharpHtml.txt");
netSerializer = new NetSerializer.Serializer(new[] { p.GetType(), typeof(Person[]), integer.GetType(), v3.GetType(), typeof(Vector3[]), largeString.GetType() });
Console.WriteLine("Warming-up"); Console.WriteLine();
SerializeZeroFormatter(p); SerializeZeroFormatter(l);
SerializeZeroFormatter(integer); SerializeZeroFormatter(v3); SerializeZeroFormatter(largeString); SerializeZeroFormatter(v3List);
SerializeMessagePackCSharp(p); SerializeMessagePackCSharp(l);
SerializeMessagePackCSharp(integer); SerializeMessagePackCSharp(v3); SerializeMessagePackCSharp(largeString); SerializeMessagePackCSharp(v3List);
SerializeProtobuf(p); SerializeProtobuf(l);
SerializeProtobuf(integer); SerializeProtobuf(v3); SerializeProtobuf(largeString); SerializeProtobuf(v3List);
SerializeMsgPack(p); SerializeMsgPack(l);
SerializeMsgPack(integer); SerializeMsgPack(v3); SerializeMsgPack(largeString); SerializeMsgPack(v3List);
SerializeJsonNet(p); SerializeJsonNet(l);
SerializeJil(p); SerializeJil(l);
SerializeFsPickler(p); SerializeFsPickler(l);
SerializeBinaryFormatter(p); SerializeBinaryFormatter(l);
SerializeDataContract(p); SerializeDataContract(l);
SerializeSingleFlatBuffers(); SerializeArrayFlatBuffers();
SerializeSingleProto3(p); SerializeArrayProto3(l);
SerializeWire(p); SerializeWire(l);
SerializeWire(integer); SerializeWire(v3); SerializeWire(largeString); SerializeWire(v3List);
SerializeNetSerializer(p); SerializeNetSerializer((Person[])(object)l);
SerializeNetSerializer(integer); SerializeNetSerializer(v3); SerializeNetSerializer(largeString); SerializeNetSerializer((Vector3[])(object)v3List);
dryRun = false;
Console.WriteLine();
Console.WriteLine($"Small Object(int,string,string,enum) {Iteration} Iteration"); Console.WriteLine();
var a = SerializeZeroFormatter(p); Console.WriteLine();
var a2 = SerializeMessagePackCSharp(p); Console.WriteLine();
var b = SerializeProtobuf(p); Console.WriteLine();
var c = SerializeMsgPack(p); Console.WriteLine();
var d = SerializeJsonNet(p); Console.WriteLine();
var e = SerializeJil(p); Console.WriteLine();
var f = SerializeFsPickler(p); Console.WriteLine();
var g = SerializeBinaryFormatter(p); Console.WriteLine();
var h = SerializeDataContract(p); Console.WriteLine();
var i = SerializeSingleFlatBuffers(); Console.WriteLine();
var j = SerializeSingleProto3(p); Console.WriteLine();
var k = SerializeWire(p); Console.WriteLine();
var l2 = SerializeNetSerializer(p); Console.WriteLine();
Console.WriteLine($"Large Array(SmallObject[1000]) {Iteration} Iteration"); Console.WriteLine();
var A = SerializeZeroFormatter(l); Console.WriteLine();
var A2 = SerializeMessagePackCSharp(l); Console.WriteLine();
var B = SerializeProtobuf(l); Console.WriteLine();
var C = SerializeMsgPack(l); Console.WriteLine();
var D = SerializeJsonNet(l); Console.WriteLine();
var E = SerializeJil(l); Console.WriteLine();
var F = SerializeFsPickler(l); Console.WriteLine();
var G = SerializeBinaryFormatter(l); Console.WriteLine();
var H = SerializeDataContract(l); Console.WriteLine();
var I = SerializeArrayFlatBuffers(); Console.WriteLine();
var J = SerializeArrayProto3(l); Console.WriteLine();
var K = SerializeWire(l); Console.WriteLine();
var L = SerializeNetSerializer((Person[])(object)l);
Validate("ZeroFormatter", p, l, a, A);
Validate("MessagePack C#", p, l, a2, A2);
Validate("protobuf-net", p, l, b, B);
Validate("MsgPack-CLI", p, l, c, C);
Validate("JSON.NET", p, l, d, D);
Validate("Jil", p, l, e, E);
Validate("FsPickler", p, l, f, F);
Validate("BinaryFormatter", p, l, g, G);
Validate("DataContract", p, l, h, H);
ValidateFlatBuffers(p, l, i, I);
ValidateProto3(p, l, j, J);
Validate("Wire", p, l, k, K);
Validate("NetSerializer", p, l, l2, L);
Console.WriteLine();
Console.WriteLine("Additional Benchmarks"); Console.WriteLine();
Console.WriteLine($"Int32(1) {Iteration} Iteration"); Console.WriteLine();
var W1 = SerializeZeroFormatter(integer); Console.WriteLine();
var W0 = SerializeMessagePackCSharp(integer); Console.WriteLine();
var W2 = SerializeMsgPack(integer); Console.WriteLine();
var W3 = SerializeProtobuf(integer); Console.WriteLine();
var W4 = SerializeWire(integer); Console.WriteLine();
var W5 = SerializeNetSerializer(integer); Console.WriteLine();
Console.WriteLine($"Vector3(float, float, float) {Iteration} Iteration"); Console.WriteLine();
var X1 = SerializeZeroFormatter(v3); Console.WriteLine();
var X0 = SerializeMessagePackCSharp(v3); Console.WriteLine();
var X2 = SerializeMsgPack(v3); Console.WriteLine();
var X3 = SerializeProtobuf(v3); Console.WriteLine();
var X4 = SerializeWire(v3); Console.WriteLine();
var X5 = SerializeNetSerializer(v3); Console.WriteLine();
Console.WriteLine($"HtmlString({Encoding.UTF8.GetByteCount(largeString)}bytes) {Iteration} Iteration"); Console.WriteLine();
var Y1 = SerializeZeroFormatter(largeString); Console.WriteLine();
var Y0 = SerializeMessagePackCSharp(largeString); Console.WriteLine();
var Y2 = SerializeMsgPack(largeString); Console.WriteLine();
var Y3 = SerializeProtobuf(largeString); Console.WriteLine();
var Y4 = SerializeWire(largeString); Console.WriteLine();
var Y5 = SerializeNetSerializer(largeString); Console.WriteLine();
Console.WriteLine($"Vector3[100] {Iteration} Iteration"); Console.WriteLine();
var Z1 = SerializeZeroFormatter(v3List); Console.WriteLine();
var Z0 = SerializeMessagePackCSharp(v3List); Console.WriteLine();
var Z2 = SerializeMsgPack(v3List); Console.WriteLine();
var Z3 = SerializeProtobuf(v3List); Console.WriteLine();
var Z4 = SerializeWire(v3List); Console.WriteLine();
var Z5 = SerializeNetSerializer((Vector3[])(object)v3List); Console.WriteLine();
Validate2("ZeroFormatter", W1, integer); Validate2("MessagePack C#", W0, integer); Validate2("MsgPack-Cli", W2, integer); Validate2("MsgPack", W3, integer); Validate2("Wire", W4, integer); Validate2("NetSerializer", W5, integer);
Validate2("ZeroFormatter", X1, v3); Validate2("MessagePack C#", X0, v3); Validate2("MsgPack-Cli", X2, v3); Validate2("MsgPack", X3, v3); Validate2("Wire", X4, v3); Validate2("NetSerializer", X5, v3);
Validate2("ZeroFormatter", Y1, largeString); Validate2("MessagePack C#", Y0, largeString); Validate2("MsgPack-Cli", Y2, largeString); Validate2("MsgPack", Y3, largeString); Validate2("Wire", Y4, largeString); Validate2("NetSerializer", Y5, largeString);
Validate2("ZeroFormatter", Z1, v3List); Validate2("MessagePack C#", Z0, v3List); Validate2("MsgPack-Cli", Z2, v3List); Validate2("MsgPack", Z3, v3List); Validate2("Wire", Z4, v3List); Validate2("NetSerializer", Z5, v3List);
Console.WriteLine("Press key to exit.");
Console.ReadLine();
}
public void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
{
var elemType = type.GetElementType();
var notNullLabel = il.DefineLabel();
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Brtrue_S, notNullLabel);
// if value == null, write 0
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4_0);
//il.Emit(OpCodes.Tailcall);
il.Emit(OpCodes.Call, serializer.GetDirectWriter(typeof(uint)));
il.Emit(OpCodes.Ret);
il.MarkLabel(notNullLabel);
// write array len + 1
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldlen);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Call, serializer.GetDirectWriter(typeof(uint)));
// declare i
var idxLocal = il.DeclareLocal(typeof(int));
// i = 0
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc_S, idxLocal);
var loopBodyLabel = il.DefineLabel();
var loopCheckLabel = il.DefineLabel();
il.Emit(OpCodes.Br_S, loopCheckLabel);
// loop body
il.MarkLabel(loopBodyLabel);
var data = serializer.GetIndirectData(elemType);
if (data.WriterNeedsInstance)
il.Emit(OpCodes.Ldarg_0);
// write element at index i
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldelem, elemType);
il.Emit(OpCodes.Call, data.WriterMethodInfo);
// i = i + 1
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc_S, idxLocal);
il.MarkLabel(loopCheckLabel);
// loop condition
il.Emit(OpCodes.Ldloc_S, idxLocal);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldlen);
il.Emit(OpCodes.Conv_I4);
il.Emit(OpCodes.Blt_S, loopBodyLabel);
il.Emit(OpCodes.Ret);
}
public MemStreamTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
public Tester()
{
m_serializer = CreateSerializer();
}
public Tester(NS.Serializer serializer)
{
m_serializer = serializer;
}
public void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
{
// arg0: Serializer, arg1: Stream, arg2: value
if (serializer.Settings.SupportSerializationCallbacks)
{
foreach (var m in GetMethodsWithAttributes(type, typeof(System.Runtime.Serialization.OnSerializingAttribute)))
EmitCallToSerializingCallback(type, il, m);
}
var fields = Helpers.GetFieldInfos(type);
foreach (var field in fields)
{
// Note: the user defined value type is not passed as reference. could cause perf problems with big structs
var fieldType = field.FieldType;
var data = serializer.GetIndirectData(fieldType);
if (data.WriterNeedsInstance)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
if (type.IsValueType)
il.Emit(OpCodes.Ldarga_S, 2);
else
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldfld, field);
il.Emit(OpCodes.Call, data.WriterMethodInfo);
}
if (serializer.Settings.SupportSerializationCallbacks)
{
foreach (var m in GetMethodsWithAttributes(type, typeof(System.Runtime.Serialization.OnSerializedAttribute)))
EmitCallToSerializingCallback(type, il, m);
}
il.Emit(OpCodes.Ret);
}
public Tester()
{
m_serializer = CreateSerializer();
}
private static void Rebuild(string file, string outPath)
{
var ser =
new Serializer(new List<Type>
{
typeof (DmiImage),
typeof (DMIState),
typeof (DMIFrame),
typeof (DMIImageData)
});
var path = Path.GetDirectoryName(file);
var relPath = path.Replace((outPath+"\\raw"), "");
if (relPath.StartsWith("\\"))
relPath = relPath.Substring(1);
DmiImage dmi = null;
try
{
using (var stream = File.OpenRead(file))
{
dmi = (DmiImage)ser.Deserialize(stream);
}
}
catch (Exception e)
{
_log.Error("Error during rebuild",e);
throw;
}
if (!use4X)
{
dmi.StateHeight = dmi.StateHeight*2;
dmi.StateWidth = dmi.StateWidth*2;
}
else
{
dmi.StateHeight = dmi.StateHeight * 4;
dmi.StateWidth = dmi.StateWidth * 4;
}
var stateIndex = 0;
foreach (var state in dmi.States)
{
var statePath = Path.Combine(path, stateIndex.ToString());
var frameIndex = 0;
foreach (var frame in state.GetFrames())
{
var framePath = Path.Combine(statePath, frameIndex.ToString());
foreach (var image in frame.GetImages())
{
var imagePath = Path.Combine(framePath, image.Dir.ToString() + ".png");
if(File.Exists(imagePath))
image.Bitmap = new Bitmap(imagePath);
else
{
Console.WriteLine("File {0} not found!",imagePath);
}
}
frameIndex++;
}
stateIndex++;
}
DmiImage.Create(dmi, Path.Combine(outPath, "processed", relPath + ".dmi"));
}
// Start is called before the first frame update
void Start()
{
var stream = new MemoryStream();
var set = new Set();
for (int i = 0; i < 10; i++)
{
set.set.Add(new No1());
set.set.Add(new No2());
}
List <Type> types = new List <Type>();
types.Add(typeof(No1));
types.Add(typeof(No2));
types.Add(typeof(Set));
var sw = Stopwatch.StartNew();
BinaryFormatter b = new BinaryFormatter();
stream = new MemoryStream();
sw.Restart();
for (int i = 0; i < 1000; i++)
{
stream.Seek(0, SeekOrigin.Begin);
b.Serialize(stream, set);
}
sw.Stop();
Debug.LogFormat("BinaryFormatter Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
stream.Seek(0, SeekOrigin.Begin);
var newobj = b.Deserialize(stream);
}
sw.Stop();
Debug.LogFormat("BinaryFormatter Reading {0} ms", sw.ElapsedMilliseconds);
byte[] bytes = null;
sw.Restart();
for (int i = 0; i < 1000; i++)
{
bytes = SerializationUtility.SerializeValue <Set>(set, DataFormat.Binary);
}
sw.Stop();
Debug.LogFormat("OdinSerializer Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
Set newset = SerializationUtility.DeserializeValue <Set>(bytes, DataFormat.Binary);
}
sw.Stop();
Debug.LogFormat("OdinSerializer Reading {0} ms", sw.ElapsedMilliseconds);
string str = "";
sw.Restart();
for (int i = 0; i < 1000; i++)
{
str = JsonUtility.ToJson(set, true);
}
sw.Stop();
Debug.LogFormat("JsonUtility Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
Set newSet = JsonUtility.FromJson <Set>(str);
}
sw.Stop();
Debug.LogFormat("JsonUtility Reading {0} ms", sw.ElapsedMilliseconds);
#if !ENABLE_IL2CPP
sw.Restart();
for (int i = 0; i < 1000; i++)
{
bytes = MessagePack.MessagePackSerializer.Serialize <Set>(set);
}
sw.Stop();
Debug.LogFormat("MessagePack Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
Set newSet = MessagePack.MessagePackSerializer.Deserialize <Set>(bytes);
}
sw.Stop();
Debug.LogFormat("MessagePack Reading {0} ms", sw.ElapsedMilliseconds);
var ser = new NetSerializer.Serializer(types);
stream = new MemoryStream();
sw.Restart();
for (int i = 0; i < 1000; i++)
{
stream.Seek(0, SeekOrigin.Begin);
ser.Serialize(stream, set);
}
sw.Stop();
Debug.LogFormat("NetSerializer Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
stream.Seek(0, SeekOrigin.Begin);
var newobj = ser.Deserialize(stream);
}
sw.Stop();
Debug.LogFormat("NetSerializer Reading {0} ms", sw.ElapsedMilliseconds);
str = "";
sw.Restart();
for (int i = 0; i < 1000; i++)
{
str = JsonConvert.SerializeObject(set);
}
sw.Stop();
Debug.LogFormat("Newtonsoft.Json Writing {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
Set newset = JsonConvert.DeserializeObject <Set>(str);
}
sw.Stop();
Debug.LogFormat("Newtonsoft.Json Reading {0} ms", sw.ElapsedMilliseconds);
#endif
Console.ReadLine();
}
public NetTest(NS.Serializer serializer)
{
m_serializer = serializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="NETSerializer"/> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
public NETSerializer(NS.Serializer serializer)
{
_serializer = serializer;
}
static void Deserialize(Serializer serializer, Stream stream, out object ob)
{
ushort id;
Primitives.ReadPrimitive(stream, out id);
if (id == 0)
{
ob = null;
return;
}
serializer.m_deserializerTrampolines[id](serializer, stream, out ob);
}
static void Main(string[] args)
{
bool show_help = false;
var p = new Mono.Options.OptionSet() {
{ "q|quick", "quick run", _ => QuickRun = true },
{ "p|protobuf", "run protobuf tests", _ => RunProtoBufTests = true },
{ "v|verify", "verify results", _ => EnableResultCheck = true },
{ "threads=", "number of threads", (int v) => NumThreads = v },
{ "share", "share serializer between threads", _ => ShareSerializer = true },
{ "h|help", "show help", _ => show_help = true },
};
List<string> extra;
try
{
extra = p.Parse(args);
}
catch (Mono.Options.OptionException e)
{
Console.WriteLine(e.Message);
return;
}
if (show_help || extra.Count > 0)
{
p.WriteOptionDescriptions(Console.Out);
return;
}
if (ShareSerializer)
s_sharedSerializer = Tester.CreateSerializer();
List<Thread> threads = new List<Thread>();
for (int i = 0; i < NumThreads; ++i)
{
var thread = new Thread(Test);
threads.Add(thread);
}
foreach (var thread in threads)
thread.Start();
foreach (var thread in threads)
thread.Join();
}
