System.IO.Pipelines: .NET高性能IO
https://www.cnblogs.com/xxfy1/p/9290235.html
System.IO.Pipelines是一個新的庫，旨在簡化在.NET中執行高性能IO的過程。它是一個依賴.NET Standard的庫，適用於所有.NET實現。
Pipelines誕生於.NET Core團隊，為使Kestrel成為業界最快的Web服務器之一。最初從作為Kestrel內部的實現細節發展成為可重用的API，它在.Net Core 2.1中作為可用於所有.NET開發人員的最高級BCL API（System.IO.Pipelines）提供。
它解決了什么問題？
為了正確解析Stream或Socket中的數據，代碼有固定的樣板，並且有許多極端情況，為了處理他們，不得不編寫難以維護的復雜代碼。
實現高性能和正確性，同時也難以處理這種復雜性。Pipelines旨在解決這種復雜性。
有多復雜？
讓我們從一個簡單的問題開始吧。我們想編寫一個TCP服務器，它接收來自客戶端的用行分隔的消息（由\n分隔）。（譯者注：即一行為一條消息）
使用NetworkStream的TCP服務器
聲明：與所有對性能敏感的工作一樣，應在應用程序中測量每個方案的實際情況。根據您的網絡應用程序需要處理的規模，可能不需要在乎的各種技術的開銷。
在Pipelines之前用.NET編寫的典型代碼如下所示：
async Task ProcessLinesAsync(NetworkStream stream)
{
var buffer = new byte[1024];
await stream.ReadAsync(buffer, 0, buffer.Length);
// 在buffer中處理一行消息
ProcessLine(buffer);
}
此代碼可能在本地測試時正確工作，但它有幾個潛在錯誤：
一次ReadAsync調用可能沒有收到整個消息（行尾）。
它忽略了stream.ReadAsync()返回值中實際填充到buffer中的數據量。（譯者注：即不一定將buffer填充滿）
一次ReadAsync調用不能處理多條消息。
這些是讀取流數據時常見的一些缺陷。為了解決這個問題，我們需要做一些改變：
我們需要緩沖傳入的數據，直到找到新的行。
我們需要解析緩沖區中返回的所有行
async Task ProcessLinesAsync(NetworkStream stream)
{
var buffer = new byte[1024];
var bytesBuffered = 0;
var bytesConsumed = 0;
while (true)
{
var bytesRead = await stream.ReadAsync(buffer, bytesBuffered, buffer.Length - bytesBuffered);
if (bytesRead == 0)
{
// EOF 已經到末尾
break;
}
// 跟蹤已緩沖的字節數
bytesBuffered += bytesRead;
var linePosition = -1;
do
{
// 在緩沖數據中查找找一個行末尾
linePosition = Array.IndexOf(buffer, (byte)'\n', bytesConsumed, bytesBuffered - bytesConsumed);
if (linePosition >= 0)
{
// 根據偏移量計算一行的長度
var lineLength = linePosition - bytesConsumed;
// 處理這一行
ProcessLine(buffer, bytesConsumed, lineLength);
// 移動bytesConsumed為了跳過我們已經處理掉的行 (包括\n)
bytesConsumed += lineLength + 1;
}
}
while (linePosition >= 0);
}
}
這一次，這可能適用於本地開發，但一行可能大於1KiB（1024字節）。我們需要調整輸入緩沖區的大小，直到找到新行。
因此，我們可以在堆上分配緩沖區去處理更長的一行。我們從客戶端解析較長的一行時，可以通過使用ArrayPool
async Task ProcessLinesAsync(NetworkStream stream)
{
byte[] buffer = ArrayPool
var bytesBuffered = 0;
var bytesConsumed = 0;
while (true)
{
// 在buffer中計算中剩余的字節數
var bytesRemaining = buffer.Length - bytesBuffered;
if (bytesRemaining == 0)
{
// 將buffer size翻倍 並且將之前緩沖的數據復制到新的緩沖區
var newBuffer = ArrayPool<byte>.Shared.Rent(buffer.Length * 2);
Buffer.BlockCopy(buffer, 0, newBuffer, 0, buffer.Length);
// 將舊的buffer丟回池中
ArrayPool<byte>.Shared.Return(buffer);
buffer = newBuffer;
bytesRemaining = buffer.Length - bytesBuffered;
}
var bytesRead = await stream.ReadAsync(buffer, bytesBuffered, bytesRemaining);
if (bytesRead == 0)
{
// EOF 末尾
break;
}
// 跟蹤已緩沖的字節數
bytesBuffered += bytesRead;
do
{
// 在緩沖數據中查找找一個行末尾
linePosition = Array.IndexOf(buffer, (byte)'\n', bytesConsumed, bytesBuffered - bytesConsumed);
if (linePosition >= 0)
{
// 根據偏移量計算一行的長度
var lineLength = linePosition - bytesConsumed;
// 處理這一行
ProcessLine(buffer, bytesConsumed, lineLength);
// 移動bytesConsumed為了跳過我們已經處理掉的行 (包括\n)
bytesConsumed += lineLength + 1;
}
}
while (linePosition >= 0);
}
}
這段代碼有效，但現在我們正在重新調整緩沖區大小，從而產生更多緩沖區副本。它將使用更多內存，因為根據代碼在處理一行行后不會縮緩沖區的大小。為避免這種情況，我們可以存儲緩沖區序列，而不是每次超過1KiB大小時調整大小。
此外，我們不會增長1KiB的 緩沖區，直到它完全為空。這意味着我們最終傳遞給ReadAsync越來越小的緩沖區，這將導致對操作系統的更多調用。
為了緩解這種情況，我們將在現有緩沖區中剩余少於512個字節時分配一個新緩沖區：
譯者注：這段代碼太復雜了，懶得翻譯注釋了，大家將就看吧
public class BufferSegment
{
public byte[] Buffer { get; set; }
public int Count { get; set; }
public int Remaining => Buffer.Length - Count;
}
async Task ProcessLinesAsync(NetworkStream stream)
{
const int minimumBufferSize = 512;
var segments = new List<BufferSegment>();
var bytesConsumed = 0;
var bytesConsumedBufferIndex = 0;
var segment = new BufferSegment { Buffer = ArrayPool<byte>.Shared.Rent(1024) };
segments.Add(segment);
while (true)
{
// Calculate the amount of bytes remaining in the buffer
if (segment.Remaining < minimumBufferSize)
{
// Allocate a new segment
segment = new BufferSegment { Buffer = ArrayPool<byte>.Shared.Rent(1024) };
segments.Add(segment);
}
var bytesRead = await stream.ReadAsync(segment.Buffer, segment.Count, segment.Remaining);
if (bytesRead == 0)
{
break;
}
// Keep track of the amount of buffered bytes
segment.Count += bytesRead;
while (true)
{
// Look for a EOL in the list of segments
var (segmentIndex, segmentOffset) = IndexOf(segments, (byte)'\n', bytesConsumedBufferIndex, bytesConsumed);
if (segmentIndex >= 0)
{
// Process the line
ProcessLine(segments, segmentIndex, segmentOffset);
bytesConsumedBufferIndex = segmentOffset;
bytesConsumed = segmentOffset + 1;
}
else
{
break;
}
}
// Drop fully consumed segments from the list so we don't look at them again
for (var i = bytesConsumedBufferIndex; i >= 0; --i)
{
var consumedSegment = segments[i];
// Return all segments unless this is the current segment
if (consumedSegment != segment)
{
ArrayPool<byte>.Shared.Return(consumedSegment.Buffer);
segments.RemoveAt(i);
}
}
}
}
(int segmentIndex, int segmentOffest) IndexOf(List
{
var first = true;
for (var i = startBufferIndex; i < segments.Count; ++i)
{
var segment = segments[i];
// Start from the correct offset
var offset = first ? startSegmentOffset : 0;
var index = Array.IndexOf(segment.Buffer, value, offset, segment.Count - offset);
if (index >= 0)
{
// Return the buffer index and the index within that segment where EOL was found
return (i, index);
}
first = false;
}
return (-1, -1);
}
此代碼只是得到很多更加復雜。當我們正在尋找分隔符時，我們同時跟蹤已填充的緩沖區序列。為此，我們此處使用List
我們的服務器現在處理部分消息，它使用池化內存來減少總體內存消耗，但我們還需要進行更多更改：
我們使用的byte[]和ArrayPool
可以通過解耦讀取邏輯和處理邏輯來優化吞吐量。這會創建一個批處理效果，使解析邏輯可以使用更大的緩沖區塊，而不是僅在解析單個行后才讀取更多數據。這引入了一些額外的復雜性
我們需要兩個彼此獨立運行的循環。一個讀取Socket和一個解析緩沖區。
當數據可用時，我們需要一種方法來向解析邏輯發出信號。
我們需要決定如果循環讀取Socket“太快”會發生什么。如果解析邏輯無法跟上，我們需要一種方法來限制讀取循環（邏輯）。這通常被稱為“流量控制”或“背壓”。
我們需要確保事情是線程安全的。我們現在在讀取循環和解析循環之間共享多個緩沖區，並且這些緩沖區在不同的線程上獨立運行。
內存管理邏輯現在分布在兩個不同的代碼段中，從填充緩沖區池的代碼是從套接字讀取的，而從緩沖區池取數據的代碼是解析邏輯。
我們需要非常小心在解析邏輯完成之后我們如何處理緩沖區序列。如果我們不小心，我們可能會返回一個仍由Socket讀取邏輯寫入的緩沖區序列。
復雜性已經到了極端（我們甚至沒有涵蓋所有案例）。高性能網絡應用通常意味着編寫非常復雜的代碼，以便從系統中獲得更高的性能。
System.IO.Pipelines的目標是使這種類型的代碼更容易編寫。
使用System.IO.Pipelines的TCP服務器
讓我們來看看這個例子的樣子System.IO.Pipelines：
async Task ProcessLinesAsync(Socket socket)
{
var pipe = new Pipe();
Task writing = FillPipeAsync(socket, pipe.Writer);
Task reading = ReadPipeAsync(pipe.Reader);
return Task.WhenAll(reading, writing);
}
async Task FillPipeAsync(Socket socket, PipeWriter writer)
{
const int minimumBufferSize = 512;
while (true)
{
// 從PipeWriter至少分配512字節
Memory<byte> memory = writer.GetMemory(minimumBufferSize);
try
{
int bytesRead = await socket.ReceiveAsync(memory, SocketFlags.None);
if (bytesRead == 0)
{
break;
}
// 告訴PipeWriter從套接字讀取了多少
writer.Advance(bytesRead);
}
catch (Exception ex)
{
LogError(ex);
break;
}
// 標記數據可用，讓PipeReader讀取
FlushResult result = await writer.FlushAsync();
if (result.IsCompleted)
{
break;
}
}
// 告訴PipeReader沒有更多的數據
writer.Complete();
}
async Task ReadPipeAsync(PipeReader reader)
{
while (true)
{
ReadResult result = await reader.ReadAsync();
ReadOnlySequence<byte> buffer = result.Buffer;
SequencePosition? position = null;
do
{
// 在緩沖數據中查找找一個行末尾
position = buffer.PositionOf((byte)'\n');
if (position != null)
{
// 處理這一行
ProcessLine(buffer.Slice(0, position.Value));
// 跳過 這一行+\n (basically position 主要位置？)
buffer = buffer.Slice(buffer.GetPosition(1, position.Value));
}
}
while (position != null);
// 告訴PipeReader我們以及處理多少緩沖
reader.AdvanceTo(buffer.Start, buffer.End);
// 如果沒有更多的數據，停止都去
if (result.IsCompleted)
{
break;
}
}
// 將PipeReader標記為完成
reader.Complete();
}
我們的行讀取器的pipelines版本有2個循環：
FillPipeAsync從Socket讀取並寫入PipeWriter。
ReadPipeAsync從PipeReader中讀取並解析傳入的行。
與原始示例不同，在任何地方都沒有分配顯式緩沖區。這是管道的核心功能之一。所有緩沖區管理都委托給PipeReader/PipeWriter實現。
這使得使用代碼更容易專注於業務邏輯而不是復雜的緩沖區管理。
在第一個循環中，我們首先調用PipeWriter.GetMemory(int)從底層編寫器獲取一些內存; 然后我們調用PipeWriter.Advance(int)告訴PipeWriter我們實際寫入緩沖區的數據量。然后我們調用PipeWriter.FlushAsync()來提供數據給PipeReader。
在第二個循環中，我們正在使用PipeWriter最終來自的緩沖區Socket。當調用PipeReader.ReadAsync()返回時，我們得到一個ReadResult包含2條重要信息，包括以ReadOnlySequence
在每個循環結束時，我們完成了reader和writer。這允許底層Pipe釋放它分配的所有內存。
System.IO.Pipelines
除了處理內存管理之外，其他核心管道功能還包括能夠在Pipe不實際消耗數據的情況下查看數據。
PipeReader有兩個核心API ReadAsync和AdvanceTo。ReadAsync獲取Pipe數據，AdvanceTo告訴PipeReader不再需要這些緩沖區，以便可以丟棄它們（例如返回到底層緩沖池）。
這是一個http解析器的示例，它在接收Pipe到有效起始行之前讀取部分數據緩沖區數據。
此處輸入圖片的描述
ReadOnlySequence
該Pipe實現存儲了在PipeWriter和PipeReader之間傳遞的緩沖區的鏈接列表。PipeReader.ReadAsync暴露一個ReadOnlySequence
此處輸入圖片的描述
該Pipe內部維護指向reader和writer可以分配或更新它們的數據集合，。SequencePosition表示緩沖區鏈表中的單個點，可用於有效地對ReadOnlySequence
這段實在翻譯困難，給出原文
The Pipe internally maintains pointers to where the reader and writer are in the overall set of allocated data and updates them as data is written or read. The SequencePosition represents a single point in the linked list of buffers and can be used to efficiently slice the ReadOnlySequence
由於ReadOnlySequence
例如，這是一個將ASCII ReadOnlySequence
string GetAsciiString(ReadOnlySequence
{
if (buffer.IsSingleSegment)
{
return Encoding.ASCII.GetString(buffer.First.Span);
}
return string.Create((int)buffer.Length, buffer, (span, sequence) =>
{
foreach (var segment in sequence)
{
Encoding.ASCII.GetChars(segment.Span, span);
span = span.Slice(segment.Length);
}
});
}
背壓和流量控制
在一個完美的世界中，讀取和解析工作是一個團隊：讀取線程消耗來自網絡的數據並將其放入緩沖區，而解析線程負責構建適當的數據結構。通常，解析將比僅從網絡復制數據塊花費更多時間。結果，讀取線程可以輕易地壓倒解析線程。結果是讀取線程必須減慢或分配更多內存來存儲解析線程的數據。為獲得最佳性能，在頻繁暫停和分配更多內存之間存在平衡。
為了解決這個問題，管道有兩個設置來控制數據的流量，PauseWriterThreshold和ResumeWriterThreshold。PauseWriterThreshold決定有多少數據應該在調用PipeWriter.FlushAsync之前進行緩沖停頓。ResumeWriterThreshold控制reader消耗多少后寫入可以恢復。
此處輸入圖片的描述
當Pipe的數據量超過PauseWriterThreshold，PipeWriter.FlushAsync會異步阻塞。數據量變得低於ResumeWriterThreshold，它會解鎖時。兩個值用於防止在極限附近發生反復阻塞和解鎖。
IO調度
通常在使用async / await時，會在線程池線程或當前線程上調用continuation SynchronizationContext。
在執行IO時，對執行IO的位置進行細粒度控制非常重要，這樣可以更有效地利用CPU緩存，這對於Web服務器等高性能應用程序至關重要。Pipelines公開了一個PipeScheduler確定異步回調運行位置的方法。這使得調用者可以精確控制用於IO的線程。
實踐中的一個示例是在Kestrel Libuv傳輸中，其中IO回調在專用事件循環線程上運行。
PipeReader模式的其他好處：
一些底層系統支持“無緩沖等待”，即，在底層系統中實際可用數據之前，永遠不需要分配緩沖區。例如，在帶有epoll的Linux上，可以等到數據准備好之后再實際提供緩沖區來進行讀取。這避免了具有大量線程等待數據的問題不會立即需要保留大量內存。
默認情況下Pipe，可以輕松地針對網絡代碼編寫單元測試，因為解析邏輯與網絡代碼分離，因此單元測試僅針對內存緩沖區運行解析邏輯，而不是直接從網絡中消耗。它還可以輕松測試那些難以測試發送部分數據的模式。ASP.NET Core使用它來測試Kestrel的http解析器的各個方面。
允許將底層OS緩沖區（如Windows上的Registered IO API）暴露給用戶代碼的系統非常適合管道，因為緩沖區始終由PipeReader實現提供。
其他相關類型
作為制作System.IO.Pipelines的一部分，我們還添加了許多新的原始BCL類型：
MemoryPool
IBufferWriter
IValueTaskSource - ValueTask
我如何使用管道？
API存在於System.IO.Pipelines nuget包中。
以下是使用管道處理基於行的消息的.NET Core 2.1服務器應用程序的示例（上面的示例）https://github.com/davidfowl/TcpEcho。它應該運行dotnet run（或通過在Visual Studio中運行）。它偵聽端口8087上的套接字並將收到的消息寫入控制台。您可以使用netcat或putty等客戶端建立與8087的連接，並發送基於行的消息以使其正常工作。
今天Pipelines為Kestrel和SignalR提供支持，我們希望看見它作為.NET社區中許多網絡庫和組件的核心。
資料：
轉載自System.IO.Pipelines: High performance IO in .NET
Pipelines - a guided tour of the new IO API in .NET, part 1
Pipelines - a guided tour of the new IO API in .NET, part 2
2號資料的中文翻譯 Pipelines - .NET中的新IO API指引(一)
System.IO.Pipelines-Nuget包
PS: 首次翻譯英文文章，不足錯漏請指出，多謝支持
標簽: .Net, .Net Core