实际体验Span<T> 的惊人表现

前言


最近做了一个过滤代码块功能的接口。就是获取一些博客文章做文本处理，然后这些博客文章的代码块太多了，很多重复的代码关键词如果被拿过来处理，那么会对文本的特征表示已经特征选择会有很大的影响。所以需要将这些代码块的部分给过滤掉。过滤起来很简单，就是找代码块的html
标记，然后将html标记之间的内容给删除就可以了。代码块的html标记一般都是<pre></pre>

我使用了String,Regex,StringBuilder,Span<T>这些不同的方法来实现这个功能，利用BenchMarks比较它们之间的性能差距。

BenchMarks

要对比不同代码之间的性能差距，还是不用StopWatch来计算消耗时间，这样简单的方法，而是使用BenchMarksDotNet包：一个专业的.net
core下测试程序性能的工具包。

BenchMarksDotNet的github地址
<https://github.com/stevejgordon/BenchmarkAndSpanExample/tree/Benchmarks>

这里简短介绍下BenchMarksDotNet的使用：

首先新建一个需要测试的类：FilterCodeBlocks ，并在类中写上被测试的方法：FilterCodeBlockByString
public class FilterCodeBlocks { public string FilterCodeBlockByString(string
content) { return content; } }
然后新建一个类: FilterCodeBlocksBenchMark
using System; using System.IO; using BenchmarkDotNet.Attributes; using
BenchmarkDotNet.Order; namespace QuickSortBenchMarks { [RankColumn]
[Orderer(SummaryOrderPolicy.FastestToSlowest)] [MemoryDiagnoser] public class
FilterCodeBlocksBenchmarks { FilterCodeBlocks FilterCodeBlocks = new
FilterCodeBlocks(); [Benchmark] public void FilterByString() {
FilterCodeBlocks.FilterCodeBlockByString(s); } } }
最后在入口Progam.cs中 写上
class Program { static void Main(string[] args) { var summary =
BenchmarkRunner.Run<FilterCodeBlocksBenchmarks>(); } }
执行dotnet build -c Release 然后 dotnet yourproject.dll 就可以看见BenchMarks测试效果.

铺垫好东西，现在开始进入正题。

使用 string

首先，直接用string 操作。由于测试博文可能会比较长，会有比较多的代码块。所以我的思路是，while(true) 去寻找代码块标记，并使用string
的寻址:indexOf() , 拼接：+= 和 剪切：Substring() 完成代码块的过滤。过程也很简单。
这只是解决问题的一种方法，这篇文章的目的不是寻找最优解决方法，而是比较发现使用不同的 "工具" 之间的巨大性能差距。
private static string _startTag = "<pre"; private static string _endTag =
"</pre>"; private static int _startTagLength => _startTag.Length; private
static int _endTagLength => _endTag.Length; public FilterCodeBlocks() { }
public string FilterCodeBlockByString(string content) { string result = "";
while (true) { var startPos = content.IndexOf(_startTag,
StringComparison.CurrentCulture); if (startPos == -1) break; var content2 =
content.Substring(startPos + _startTagLength, content.Length - startPos -
_startTagLength); var endPos = content2.IndexOf(_endTag,
StringComparison.CurrentCulture); result += content.Substring(0, startPos);
content = content2.Substring(endPos + _endTagLength, content2.Length - endPos -
_endTagLength); } result += content; return result; }
一开始选取了比较短的文本进行测试 ,可以直接写在程序中：
[RankColumn] [Orderer(SummaryOrderPolicy.FastestToSlowest)] [MemoryDiagnoser]
public class FilterCodeBlocksBenchmarks { FilterCodeBlocks FilterCodeBlocks =
new FilterCodeBlocks(); public static string s = "<p>我们通过IndexWriterConfig
可以设置IndexWriter的属性，" + "已达到我们希望构建索引的需求，这里举一些属性，这些属性可以影响到IndexWriter写入索引的速度：" +
"</p>\n<div class=\"cnblogs_code\">\n<pre>IndexWriterConfig.setRAMBufferSizeMB"
+ "(<span style=\"color: #0000ff;\">double</span><span style=\"color:
#000000;\">);" + "\nIndexWriterConfig.setMaxBufferedDocs(</span><span
style=\"color: #0000ff;\">int</span><span " + "style=\"color:
#000000;\">);\nIndexWriterConfig.setMergePolicy(MergePolicy)</span></pre>\n</div>\n<p>"
+ "setRAMBufferSizeMB() 是设置"; [Benchmark] public void FilterByString() {
FilterCodeBlocks.FilterCodeBlockByString(s); } }
按照上述的方法，运行dll 得出 使用string 相关方法的性能。


平均处理时间 48微秒 分配内存 1.41kb,看来效果也是不错的，我感觉上面的代码中方法也是大家都会经常使用的方法。

接下来 .NET Core 2.1的新特性: Span 隆重登场！

Span< T >

What is a Span< T >?

Span< T > : 结构体，值类型 。相当于C++ 中的指针，它是一段连续内存的引用，也就是一段连续内存的首地址。有了Span< T >，我们就可以不在
unsafe的代码块中写指针了。Span< char > 相对于 string 也就具有很大的性能优势。

举个栗子： string.Substring() 函数，实际上是在堆中额外创建了一个新的 string 对象，把字符 copy
过去，再返回这个对象的引用。而相对应的 Span< T > 的Slice() 函数则是直接在内存中返回子串的首地址引用，此过过程几乎不分配内存，并且十分高效。

后面的优化也是使用Span< T > 的Slice() 代替了 string 的SubString() 。

简单看下 Span< T > 的源码，就可以窥见 Span< T > 的奥秘：
public readonly ref partial struct Span<T> { /// <summary>A byref or a native
ptr.</summary> internal readonly ByReference<T> _pointer; /// <summary>The
number of elements this Span contains.</summary> private readonly int _length;
.... public Span(T[] array) { if (array == null) { this = default; return; //
returns default } if (default(T) == null && array.GetType() != typeof(T[]))
ThrowHelper.ThrowArrayTypeMismatchException(); _pointer = new
ByReference<T>(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData())); _length
= array.Length; } }
Span< T > 内部主要就是一个ByReference< T > 类型的对象，实际上就是ref T: 一个类型的引用，它和C 的int* char*
如出一折。 Span < T > 也就是建立 ref 的基础上。

限定长度: _length ，就像 C 中定义指针，在使用前需要 malloc 或者 alloc 分配固定长度的内存。关于Span< T > 更多详细知识：

https://msdn.microsoft.com/en-us/magazine/mt814808.aspx
<https://msdn.microsoft.com/en-us/magazine/mt814808.aspx>

使用 Span< T > 优化

将上述 string 代码使用 Span< char > 优化一下
public string FilterCodeBlockBySpanAndToString(ReadOnlySpan<char> content) {
string result = ""; ReadOnlySpan<char> contentSpan2 = new ReadOnlySpan<char>();
int startPos = 0; int endPos = 0; ReadOnlySpan<char> startTagSpan =
_startTag.AsSpan(); ReadOnlySpan<char> endTagSpan = _endTag.AsSpan(); while
(true) { startPos = content.IndexOf(startTagSpan); if (startPos == -1) break;
contentSpan2 = content.Slice(startPos + _startTagLength, content.Length -
startPos - _startTagLength); endPos = contentSpan2.IndexOf(endTagSpan); result
+= content.Slice(0, startPos).ToString(); content = contentSpan2.Slice(endPos +
_endTagLength, contentSpan2.Length - endPos - _endTagLength); } result +=
content.ToString(); return result; }
这里 ReadOnlySpan<char> 是 Span< char > 的只读类型。使用Slice 代替SubString 。上述代码我依然返回的是
string。为了得到 string，我不惜使用Span< T > 的ToString() 函数，在我印象中，这个操作会把Span 的优势给拉回起跑线。

接下来看测试结果:



真是大吃一惊，平均消耗时间，居然少了 48000 纳秒，Span< T > 只是 string 的不到百分之一消耗。内存消耗减少了一半

Span< T >果然名不虚传，正如前面所说的SubString 和Slice 之间的性能差距。

Span< T > 的特色

虽然Span< T > 的性能十分出色 ，但是 string 有太多完善的接口，string
是为了简化你的代码让你更加舒服的使用字符串，所以牺牲了性能。因此 在对计算机消耗要求十分的严苛的情况下，尝试使用Span< T >
,大多数情况下，简短的string 已经能满足需求。我的认知下的Span< T >的特色：

*
Span< T >的定义方法多种多样，可以直接 ( i ) 像定义数组那样 : Span<int> a = new int[10]; ( ii )
在构造函数中直接传入 数组（指针+长度）Span<T> a = new Span<T>(T[]),Span<T> a = new
Span<T>(void*,length) ; ( iii )可以直接在栈中分配内存：Span<char> a = stackalloc char[10];
在C# 8.0中才可以，这样的写法真是高大上。

* Span< T > 只能存在于栈中，而不能放在堆中。因为 ( i ) GC 在堆中很难跟踪这些指针， ( ii ) 在堆中会出现多线程，
如果两个线程的两个Span< T >指向了同一个地址，那就糟了。
* 可以使用 Memory< T > 代替 Span< T >在堆中使用。
* 所有 string 的接口都可以用 Span< char > 来实现，这似乎又回到了原始的C语言时代。
*
Span < T > 有个兄弟叫 ReadOnlySpan< T > 。

到这里还不能结束Span< T >的性能评测。因为在大量字符串处理中还有个隐藏的实力派：正则表达式 Regex

正则表达式

如果我们使用正则表达式呢，它的性能会是如何呢？

正则表达式的实现：
private static Regex _codeTag = new Regex("(<pre(.*?)>)(.|\n)*?(</pre>)",
RegexOptions.Compiled); public string FilterCodeBlocByRegex(string content) {
return _codeTag.Replace(content, string.Empty); }
真是简短的让人看着就舒服。正则表达式的长处是在大文本处理，所以我决定直接将字符串变成100篇博客的内容加在一起。下面就是测试结果：



Incredible! 正则表达式 真的是一匹黑马，直逼Span< T >，时间消耗仅为10.68ms,内存消耗只有7.69MB
。难得的是它的内存消耗也比Span< T >低。

为什么Regex会有这么好的表现呢？翻阅一下源码，原来如此！
private static string Replace(MatchEvaluator evaluator, Regex regex, string
input, int count, int startat) { .... Span<char> charInitSpan = stackalloc
char[ReplaceBufferSize]; var vsb = new ValueStringBuilder(charInitSpan); }
在.net core 2.2 中，Regex的 Replace 内部用了 Span< char > 重新实现。看来，正则表达式的高性能表现 和 Span
不无关系。

根据园友的评论，Regex 以前的版本，也是通过指针来进行操作，我也实验了 .net standard的Regex , 二者效率差不多。

Span < T > 很优秀，但是为了解决 string 的性能问题，C# 早早就有了 StringBuilder
。于是我让了字符串处理界的大师：StringBuilder， 来助 Span< T > 一臂之力。

StringBuilder + Span< T >
public string FilterCodeBlockBySpanAndStringBuilder(ReadOnlySpan<char>
content) { var result = new StringBuilder(content.Length); var contentSpan2 =
new ReadOnlySpan<char>(); var startPos = 0; var endPos = 0; var startTagSpan =
_startTag.AsSpan(); var endTagSpan = _endTag.AsSpan(); while (true) { startPos
= content.IndexOf(startTagSpan); if (startPos == -1) break; contentSpan2 =
content.Slice(startPos + _startTagLength, content.Length - startPos -
_startTagLength); endPos = contentSpan2.IndexOf(endTagSpan);
result.Append(content.Slice(0, startPos)); content = contentSpan2.Slice(endPos
+ _endTagLength, contentSpan2.Length - endPos - _endTagLength); }
result.Append(content); return result.ToString(); }
将原先的 字符串拼接变成了 StringBuilder 的 append函数，而且减少了我心心念念的ToString()次数。在 .net core 2.2
中StringBuilder的内部也有 Span< T >的身影。

Append 函数可以直接接受Span< T >的参数。接下来看看武装到牙齿的Span< T >性能如何。



unbelievable ! 使用 StringBuilder 的Span< T >时间消耗居然只有 867.1微妙,内存消耗只有1.7MB
，在各个方面都技压群雄。又是百分之一的消耗。

实际上 StringBuilder的内部操作字符串的 是一个 char 数组，它的 Apend 的性能如此之高，还是因为内部使用了指针。
unsafe { fixed (char* valuePtr = value) fixed (char* destPtr =
&chunkChars[chunkLength]) { string.wstrcpy(destPtr, valuePtr, valueLen); } }
StringBuilder 只能支持字符串，但是Span< T >可是泛型的哦。不过，程序中最消耗CPU的大都是一些字符串的处理。

结语

在实际中体验了Span< T >的惊人表现。同时 .NET Core 在Span< T >加入之后，各个地方都有性能的提升，比如说Regex。
真是让开发者何其幸哉。

在Regex 中的源代码，我看到了一个 ValueStringBuilder 一个内部的结构体，只能在System/Text
的内部中使用。它是一个结构体！它的构造函数可以直接传入 Span< char >，我将它 copy 出来，代替StringBuilder ,
时间消耗不分伯仲，但是内存消耗又减少了一半！。这应该是极致的性能表现。鉴于篇幅原因就不展开了。

可以在 这里 <https://github.com/SilentCC/MyTestBenchMarks> 看到ValueStringBuilder
,以及完整的代码。

• « 上一篇：Python数据预处理-导入Excel数据存为数组
• » 下一篇：SpringBoot配置数据源DataSource