ArrayPool 原始碼解讀之 byte[] 也能池化?

一線碼農發表於2021-09-01

一:背景

1. 講故事

最近在分析一個 dump 的過程中發現其在 gen2 和 LOH 上有不少size較大的free,仔細看了下,這些free生前大多都是模板引擎生成的html片段的byte[]陣列,當然這篇我不是來分析dump的,而是來聊一下,當託管堆有很多length較大的 byte[] 陣列時,如何讓記憶體利用更高效,如何讓gc老先生壓力更小。

不知道大家有沒有發現在 .netcore 中增加了不少池化物件的東西,比如: ArrayPool,ObjectPool 等等,確實在某些場景下還是特別實用的,所以有必要對其進行較深入的理解。

二: ArrayPool 原始碼分析

1. 一圖勝千言

在我花了將近一個小時的原始碼閱讀之後,我畫了一張 ArrayPool 的池化圖,所謂:一圖在手,天下我有

有了這張圖,接下來再聊幾個概念並配上相應原始碼,我覺得應該就差不多了。

2. 池化的架構分級是什麼樣的?

ArrayPool 是由若干個 Bucket 組成, 而 Bucket 又由若干個 buffer[] 陣列組成, 有了這個概念之後,再配一下程式碼。


public abstract class ArrayPool<T>
{
    public static ArrayPool<T> Create()
    {
        return new ConfigurableArrayPool<T>();
    }
}

internal sealed class ConfigurableArrayPool<T> : ArrayPool<T>
{
    private sealed class Bucket
    {
        internal readonly int _bufferLength;
        private readonly T[][] _buffers;
        private int _index;
    }

    private readonly Bucket[] _buckets;     //bucket陣列
}

3. 為什麼每一個 bucket 裡都有 50 個 buffer[]

這個問題很好回答,初始化時做了 maxArraysPerBucket=50 設定,當然你也可以自定義,具體參考如下程式碼:


internal sealed class ConfigurableArrayPool<T> : ArrayPool<T>
{
    internal ConfigurableArrayPool() : this(1048576, 50)
    {
    }

    internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket)
    {
        int num = Utilities.SelectBucketIndex(maxArrayLength);
        Bucket[] array = new Bucket[num + 1];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
        }
        _buckets = array;
    }
}

4. bucket 中 buffer[].length 為什麼依次是 16,32,64 ...

框架做了預設假定,第一個bucket中的 buffer[].length=16, 後續 bucket 中的 buffer[].length 都是 x2 累計,涉及到程式碼就是 GetMaxSizeForBucket() 方法,參考如下:


internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket)
{
    Bucket[] array = new Bucket[num + 1];
    for (int i = 0; i < array.Length; i++)
    {
        array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
    }
}

internal static int GetMaxSizeForBucket(int binIndex)
{
    return 16 << binIndex;
}

5. 初始化時 bucket 到底有多少個?

其實在上圖中我也沒有給出 bucket 到底有多少個,那到底是多少個呢???? ,當我閱讀完原始碼之後,這演算法還挺有意思的。

先說一下結果吧,預設 17 個 bucket,你肯定會好奇怎麼算的? 先說下兩個變數:

  • maxArrayLength=1048576 = 2的20次方

  • buffer.length= 16 = 2的4次方

最後的演算法就是取次方的差值:bucket[].length= 20 - 4 + 1 = 17,換句話說最後一個 bucket 下的 buffer[].length=1048576,詳細程式碼請參考 SelectBucketIndex() 方法。


internal sealed class ConfigurableArrayPool<T> : ArrayPool<T>
{
    internal ConfigurableArrayPool(): this(1048576, 50)
    { }

    internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket)
    {
        int num = Utilities.SelectBucketIndex(maxArrayLength);
        Bucket[] array = new Bucket[num + 1];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
        }
        _buckets = array;
    }

    internal static int SelectBucketIndex(int bufferSize)
    {
        return BitOperations.Log2((uint)(bufferSize - 1) | 0xFu) - 3;
    }
}

到這裡我相信你對 ArrayPool 的池化架構思路已經搞明白了,接下來看下如何申請和歸還 buffer[]。

三:如何申請和歸還

既然 buffer[] 做了顆粒化,那就應該好借好還,反應到程式碼上就是 Rent()Return() 方法,為了方便理解,上程式碼說話:


    class Program
    {
        static void Main(string[] args)
        {
            var arrayPool = ArrayPool<int>.Create();

            var bytes = arrayPool.Rent(10);

            for (int i = 0; i < bytes.Length; i++) bytes[i] = 10;

            arrayPool.Return(bytes);

            Console.ReadLine();
        }
    }


有了程式碼和圖之後,再稍微捋一下流程。

  1. 從 ArrayPool 中借一個 byte[10] 大小的陣列,為了節省記憶體,先不備貨,臨時生成一個 byte[].size=16 的陣列出來,簡化後的程式碼如下,參考 if (flag) 處:

    internal T[] Rent()
    {
        T[][] buffers = _buffers;
        T[] array = null;
        bool lockTaken = false;
        bool flag = false;
        try
        {
            if (_index < buffers.Length)
            {
                array = buffers[_index];
                buffers[_index++] = null;
                flag = array == null;
            }
        }
        if (flag)
        {
            array = new T[_bufferLength];
        }
        return array;
    }

這裡有一個坑,那就是你以為借了 byte[10],現實給你的是 byte[16],這裡稍微注意一下。

  1. 當用 ArrayPool.Return 歸還 byte[16] 時, 很明顯看到它落到了第一個bucket的第一個buffer[]上,參考如下簡化後的程式碼:

    internal void Return(T[] array)
    {
        if (_index != 0)
        {
            _buffers[--_index] = array;
        }
    }

這裡也有一個值得注意的坑,那就是還回去的 byte[16] 裡面的資料預設是不會清掉的,從上面的程式碼也是可以看出來的,要想做清理,需要在 Return 方法中指定 clearArray=true,參考如下程式碼:


    public override void Return(T[] array, bool clearArray = false)
    {
        int num = Utilities.SelectBucketIndex(array.Length);

        if (num < _buckets.Length)
        {
            if (clearArray)
            {
                Array.Clear(array, 0, array.Length);
            }
            _buckets[num].Return(array);
        }
    }

四:總結

學習這其中的 池化架構 思想,對平時專案開發還是能提供一些靈感的,其次對那些一次性使用 byte[] 的場景,用池化是個非常不錯的方法,這也是我對朋友dump分析後提出的一個優化思路。

更多高質量乾貨:參見我的 GitHub: dotnetfly

圖片名稱

相關文章