C# byte [ ] operations - shall I use ArrayPool or MemoryPool? - sockets

Question

I am writing a server application. It accepts thousands of incoming socket connections, each sending and receiving messages.
Every time a message is received or sent over the socket, I used to allocate new byte[] buffers, then they are garbage collected:
byte[] receivingBuffer = new byte[bufferSize];
To improve the performance, I want to reuse the byte[] buffers. Shall I use ArrayPool or MemoryPool?
Or shall I create an ObjectPool of fixed-length byte[] buffers? For example, if the messages I send and receive never exceed 100 KB, then I create an ObjectPool of 100 KB byte[] buffers. Every time I need to send or receive a message, I get one of these buffers.

Answer 1

Did some research and testing. ArrayPool is the right thing to use and will dramatically increase performance.
class Program
{
private static ManualResetEvent m_event = new ManualResetEvent(false);
private static DateTime m_dtStart;
private static int m_iNumOfIterations = 0;
private static int m_iNumOfExceptions = 0;
private static double m_dAvgSizeRatio = 0;
private static object m_lock = new object();
private static void ReportSizeRatio(double dRatio)
{
lock (m_lock)
{
m_dAvgSizeRatio = (m_dAvgSizeRatio * m_iNumOfIterations + dRatio) / (m_iNumOfIterations + 1);
m_iNumOfIterations++;
}
}
/// <summary>
/// When using ArrayPool:
/// - CPU: 1 ~ 1.5%
/// - Memory: 67 MB
/// - Speed: 9130 runs/sec
/// - Given buffer is 1.56 times bigger than asked for.
///
/// When NOT using ArrayPool:
/// - CPU: 20 ~ 25%
/// - Memory: 500 ~ 1000 MB
/// - Speed: 5300 runs/sec
///
/// Conclusion: huge improvement in performance.
/// </summary>
/// <param name="obj"></param>
private static void Test(object obj)
{
TrueRandom random = new TrueRandom(500, 800);
m_event.WaitOne();
while (true)
{
int iDesiredSize = random.GetRandomInteger() * 1000;
byte[] buffer = null;
try
{
//buffer = ArrayPool<byte>.Shared.Rent(iDesiredSize);
buffer = new byte[iDesiredSize];
ReportSizeRatio((double)buffer.Length / (double)iDesiredSize);
}
catch
{
Interlocked.Increment(ref m_iNumOfExceptions);
}
Thread.Sleep(100);
//ArrayPool<byte>.Shared.Return(buffer);
}
}
static void Main(string[] args)
{
for (int i = 0; i < 1000; i++)
{
Thread thread = new Thread(Test);
thread.Start();
}
Console.WriteLine("All threads fired.");
m_dtStart = DateTime.Now;
m_event.Set();
while (true)
{
Thread.Sleep(1000);
Console.Clear();
Console.WriteLine($"Iterations/sec: { (int)(m_iNumOfIterations / (DateTime.Now - m_dtStart).TotalSeconds) }, Ave rented size: { (m_dAvgSizeRatio * 100d).ToString("0.0") }%, exceptions: { m_iNumOfExceptions }.");
}
}
}