Question

灵感来自this question。我创建了一个小的基准程序来比较ProtoBuf，BinaryFormatter和Json.NET。基准测试本身是一个基于https://github.com/sidshetye/SerializersCompare的小型控制台。可以随意添加/改进，添加新的串行器非常简单。无论如何，我的结果是：

        Binary Formatter         ProtoBuf          Json.NET     ServiceStackJson   ServiceStackJSV
 Loop     Size:512 bytes    Size:99 bytes    Size:205 bytes      Size:205 bytes     Size:181 bytes
    1         16.1242 ms      151.6354 ms       277.2085 ms         129.8321 ms        146.3547 ms
    2          0.0673 ms        0.0349 ms         0.0727 ms           0.0343 ms          0.0370 ms
    4          0.0292 ms        0.0085 ms         0.0303 ms           0.0145 ms          0.0148 ms
    8          0.0255 ms        0.0069 ms         0.0017 ms           0.0216 ms          0.0129 ms
   16          0.0011 ms        0.0064 ms         0.0282 ms           0.0114 ms          0.0120 ms
   32          0.0164 ms        0.0061 ms         0.0334 ms           0.0112 ms          0.0120 ms
   64          0.0347 ms        0.0073 ms         0.0296 ms           0.0121 ms          0.0013 ms
  128          0.0312 ms        0.0058 ms         0.0266 ms           0.0062 ms          0.0117 ms
  256          0.0256 ms        0.0097 ms         0.0448 ms           0.0087 ms          0.0116 ms
  512          0.0261 ms        0.0058 ms         0.0307 ms           0.0127 ms          0.0116 ms
 1024          0.0258 ms        0.0057 ms         0.0309 ms           0.0113 ms          0.0122 ms
 2048          0.0257 ms        0.0059 ms         0.0297 ms           0.0125 ms          0.0121 ms
 4096          0.0247 ms        0.0060 ms         0.0290 ms           0.0119 ms          0.0120 ms
 8192          0.0247 ms        0.0060 ms         0.0286 ms           0.0115 ms          0.0121 ms

免责声明：

上述结果来自Windows VM - 与裸机操作系统相比，非常小间隔的秒表/计时器值可能不是100％准确。因此，请忽略上表中的超低值。
对于ServiceStack，Json和JSV得分来自两个单独的运行。由于它们共享相同的底层ServiceStack库，因此在另一个之后运行一个影响下一次运行的“冷启动”1循环分数（它的“热启动”快速）

BinaryFormatter是最大的，但也是单个序列化的最快=＆gt;反序列化循环。但是，一旦我们围绕序列化紧密循环=＆gt;反序列化代码，ProtoBuf快速超级。

问题＃1 ：为什么ProtoBuf对于单个序列化要慢得多=＆gt;反序列化循环？

问题＃2 ：从实际角度来看，我们可以做些什么才能超越“冷启动”？通过它运行至少一个对象（任何类型）？通过它运行每个（关键）对象类型？

Answer 1

问题＃1：为什么ProtoBuf对于单个序列化要慢得多=＆gt;反序列化循环？

因为分析模型并制定策略需要做大量的工作;我花了很多时间让生成的策略尽可能快地完成，但可能是因为我对元编程层的优化不屑一顾。我很乐意将其作为一个项目添加，以减少第一次通过的时间。当然，另一方面，元编程层仍然是Json.NET等效预处理的两倍; p

问题2：从实际角度来看，我们能做些什么才能超越“冷启动”？通过它运行至少一个对象（任何时间）？通过它运行每个（关键）对象类型？

各种选择：

使用“预编译”工具作为构建过程的一部分，将编译后的序列化程序生成为一个单独的完全静态编译的dll，您可以像平常一样引用和使用：恰好零元编程然后发生
在启动时明确告诉模型“root”类型，并存储Compile()的输出
```
static TypeModel serializer;
...
RuntimeTypeModel.Default.Add(typeof(Foo), true);
RuntimeTypeModel.Default.Add(typeof(Bar), true);
serializer = RuntimeTypeModel.Default.Compile();
```
（Compile()方法将从根类型进行分析，添加所需的任何其他类型，返回已编译的生成实例）
在启动时明确告诉模型“root”类型，并且“几次”调用CompileInPlace(); CompileInPlace()不会完全扩展模型 - 但是调用它几次应该涵盖大多数基础，因为编译一个层会将其他类型带入模型
```
RuntimeTypeModel.Default.Add(typeof(Foo), true);
RuntimeTypeModel.Default.Add(typeof(Bar), true);
for(int i = 0 ; i < 5 ; i++) {
    RuntimeTypeModel.Default.CompileInPlace();
}
```

另外，我应该：

添加方法以完全展开CompileInPlace方案
花一些时间优化元编程层

最后的想法：Compile和CompileInPlace之间的主要区别将是如果您忘记添加某些类型会发生什么; CompileInPlace适用于现有模型，因此您仍可以稍后添加新类型（隐式或显式），它将“正常工作”; Compile更加严格：一旦你通过它生成了一个类型，它就被修复了，只能处理它在编译时可以推断出的类型。

为什么ProtoBuf在第一次调用时这么慢，但内部循环非常快？

1 个答案: