Unity3D游戲GC優化總結---protobuf-net無GC版本優化實踐

一　　protobuf-net優化效果圖

　　protobuf-net是Unity3D游戲開發中被廣泛使用的Google Protocol Buffer庫的c#版本，之所以c#版本被廣泛使用，是因為c++版本的源代碼不支持Unity3D游戲在各個平台上的動態庫構建。它是一個網絡傳輸層協議，對應的lua版本有兩個可用的庫：一個是proto-gen-lua，由tolua作者開發，另外一個是protoc，由雲風開發。protobuf-net在GC上有很大的問題，在一個高頻率網絡通訊的狀態同步游戲中使用發現GC過高，所以對它進行了一次比較徹底的GC優化。下面是優化前后的對比圖：

 

 

protobuf-net優化前GC和性能效果圖

 

protobuf-net優化后GC和性能效果圖

 

 

二　　Unity3D游戲GC優化概述

　　有關Unity3D垃圾回收的基本概念和優化策略Unity官網有發布過文章：Optimizing garbage collection in Unity games。這篇文章講述了Unity3D垃圾回收機制，和一些簡單的優化策略，討論的不是特別深入，但是廣度基本上算是夠了。我羅列一下這篇文章的一些要點，如果你對其中的一些點不太熟悉，建議仔細閱讀下這篇文章：

　　1、C#變量分為兩種類型：值類型和引用類型，值類型分配在棧區，引用類型分配在堆區，GC關注引用類型

　　2、GC卡頓原因：堆內存垃圾回收，向系統申請新的堆內存

　　3、GC觸發條件：堆內存分配而當內存不足時、按頻率自動觸發、手動強行觸發（一般用在場景切換）

　　4、GC負面效果：內存碎片（導致內存變大，GC觸發更加頻繁）、游戲頓卡

　　5、GC優化方向：減少GC次數、降低單次GC運行時間、場景切換時主動GC

　　6、GC優化策略：減少對內存分配次數和引用次數、降低堆內存分配和回收頻率

　　7、善用緩存：對有堆內存分配的函數，緩存其調用結果，不要反復去調用

　　8、清除列表：而不要每次都去new一個新的列表

　　9、用對象池：必用

　　10、慎用串拼接：緩存、Text組件拆分、使用StringBuild、Debug.Log接口封裝（打Conditional標簽）

　　11、警惕Unity函數調用：GameObject.name、GameObject.tag、FindObjectsOfType<T>()等眾多函數都有堆內存分配，實測為准

　　12、避免裝箱：慎用object形參、多用泛型版本（如List<T>）等，這里的細節問題很多，實測為准

　　13、警惕協程：StartCoroutine有GC、yield return帶返回值有GC、yield return new xxx有GC（最好自己做一套協程管理）

　　14、foreach：unity5.5之前版本有GC，使用for循環或者獲取迭代器

　　15、減少引用：建立管理類統一管理，使用ID作為訪問token

　　16、慎用LINQ：這東西最好不用，GC很高

　　17、結構體數組：如果結構體中含有引用類型變量，對結構體數組進行拆分，避免GC時遍歷所有結構體成員

　　18、在游戲空閑（如場景切換時）強制執行GC

 

 

三　　protobuf-net GC分析

3.1　　protobuf-net序列化

　　先分析下序列化GC，deep profile如下：

　　打開PropertyDecorator.cs腳本，找到Write函數如下：

        public override void Write(object value, ProtoWriter dest)
        {
            Helpers.DebugAssert(value != null);
            value = property.GetValue(value, null);
            if(value != null) Tail.Write(value, dest);
        }

　　可以看到這里MonoProperty.GetValue產生GC的原因是因為反射的使用；而ListDecorator.Write對應於代碼Tail.Write，繼續往下看：

　　找到對應源代碼：

        public override void Write(object value, ProtoWriter dest)
        {
            SubItemToken token;
            bool writePacked = WritePacked;
            if (writePacked)
            {
                ProtoWriter.WriteFieldHeader(fieldNumber, WireType.String, dest);
                token = ProtoWriter.StartSubItem(value, dest);
                ProtoWriter.SetPackedField(fieldNumber, dest);
            }
            else
            {
                token = new SubItemToken(); // default
            }
            bool checkForNull = !SupportNull;
            foreach (object subItem in (IEnumerable)value)
            {
                if (checkForNull && subItem == null) { throw new NullReferenceException(); }
                Tail.Write(subItem, dest);
            }
            if (writePacked)
            {
                ProtoWriter.EndSubItem(token, dest);
            }
        }

　　可以看到這里的GC是由list遍歷的foreach引起的。繼續往內展開，產生GC的點全部是這兩個原因上。

 

3.2　　protobuf-net反序列化

　　找到第一個產生GC的分支：

　　同上述分析，MonoProperty.GetValue、MonoProperty.SetValue產生GC原因是反射。而Int32Serializer.Read()代碼如下：

        public object Read(object value, ProtoReader source)
        {
            Helpers.DebugAssert(value == null); // since replaces
            return source.ReadInt32();
        }

　　可見產生GC的原因是因為裝箱。繼續往下展開ListDecorateor.Read函數：

　　由Activator.CreateInstance得出這里產生GC的原因是實例的創建。繼續往下展開：

 

　　GC的產生發生在List.Add的GrowIfNeeded，可見是列表擴容。這里本質上是因為上一步創建了新對象，如果不創建新對象，那么這里的list可以用Clear而無須新建，那么就不會有擴容的問題。繼續往下面追：

　　反射和裝箱產生GC上面已經提到，看ProtoReader.AppendBytes代碼：

        public static byte[] AppendBytes(byte[] value, ProtoReader reader)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            switch (reader.wireType)
            {
                case WireType.String:
                    int len = (int)reader.ReadUInt32Variant(false);
                    reader.wireType = WireType.None;
                    if (len == 0) return value == null ? EmptyBlob : value;
                    int offset;
                    if (value == null || value.Length == 0)
                    {
                        offset = 0;
                        value = new byte[len];
                    }
                    else
                    {
                        offset = value.Length;
                        byte[] tmp = new byte[value.Length + len];
                        Helpers.BlockCopy(value, 0, tmp, 0, value.Length);
                        value = tmp;
                    }
                    // value is now sized with the final length, and (if necessary)
                    // contains the old data up to "offset"
                    reader.position += len; // assume success
                    while (len > reader.available)
                    {
                        if (reader.available > 0)
                        {
                            // copy what we *do* have
                            Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, offset, reader.available);
                            len -= reader.available;
                            offset += reader.available;
                            reader.ioIndex = reader.available = 0; // we've drained the buffer
                        }
                        //  now refill the buffer (without overflowing it)
                        int count = len > reader.ioBuffer.Length ? reader.ioBuffer.Length : len;
                        if (count > 0) reader.Ensure(count, true);
                    }
                    // at this point, we know that len <= available
                    if (len > 0)
                    {   // still need data, but we have enough buffered
                        Helpers.BlockCopy(reader.ioBuffer, reader.ioIndex, value, offset, len);
                        reader.ioIndex += len;
                        reader.available -= len;
                    }
                    return value;
                default:
                    throw reader.CreateWireTypeException();
            }
        }

　　可見，這里產生GC的原因是因為new byte[]操作。

 

 

四　　Protobuf-net GC優化方案

　　protobuf-net在本次協議測試中GC產生的原因總結如下：

　　1、反射

　　2、forearch

　　3、裝箱

　　4、創建新的pb對象

　　5、創建新的字節數組

　　下面對症下葯。

 

4.1　　去反射

　　用過lua的人都知道，不管是tolua還是xlua，去反射的方式是生成wrap文件，這里去反射可以借鑒同樣的思想。

using CustomDataStruct;
using ProtoBuf.Serializers;

namespace battle
{
    public sealed class NtfBattleFrameDataDecorator : ICustomProtoSerializer
    {
        public void SetValue(object target, object value, int fieldNumber)
        {
            ntf_battle_frame_data data = target as ntf_battle_frame_data;
            if (data == null)
            {
                return;
            }

            switch (fieldNumber)
            {
                case 1:
                    data.time = ValueObject.Value<int>(value);
                    break;
                case 3:
                    data.slot_list.Add((ntf_battle_frame_data.one_slot)value);
                    break;
                case 5:
                    data.server_from_slot = ValueObject.Value<int>(value);
                    break;
                case 6:
                    data.server_to_slot = ValueObject.Value<int>(value);
                    break;
                case 7:
                    data.server_curr_frame = ValueObject.Value<int>(value);
                    break;
                case 8:
                    data.is_check_frame = ValueObject.Value<int>(value);
                    break;
                default:
                    break;
            }
        }

        public object GetValue(object target, int fieldNumber)
        {
            ntf_battle_frame_data data = target as ntf_battle_frame_data;
            if (data == null)
            {
                return null;
            }

            switch (fieldNumber)
            {
                case 1:
                    return ValueObject.Get(data.time);
                case 3:
                    return data.slot_list;
                case 5:
                    return ValueObject.Get(data.server_from_slot);
                case 6:
                    return ValueObject.Get(data.server_to_slot);
                case 7:
                    return ValueObject.Get(data.server_curr_frame);
            }

            return null;
        }
    }
}

　　反射產生的地方在protobuf-net的裝飾類中，具體是PropertyDecorator，我這里並沒有去寫工具自動生成Wrap文件，而是對指定的協議進行了Hook。

 

4.2　　foreach

　　foreach對列表來說改寫遍歷方式就好了，我這里沒有對它進行優化，因為Unity5.5以后版本這個問題就不存在了。篇首優化后的效果圖中還有一點殘留就是因為這里搗鬼。

 

4.3　　無GC裝箱

　　要消除這里的裝箱操作，需要重構代碼，而protobuf-net內部大量使用了object進行參數傳遞，這使得用泛型編程來消除GC變得不太現實。我這里是自己實現了一個無GC版本的裝箱拆箱類ValueObject，使用方式十分簡單，類似：

        public object Read(object value, ProtoReader source)
        {
            Helpers.DebugAssert(value == null); // since replaces
            return ValueObject.Get(source.ReadInt32());
        }
        public void Write(object value, ProtoWriter dest)
        {
            ProtoWriter.WriteInt32(ValueObject.Value<int>(value), dest);
        }

　　其中ValueObject.Get是裝箱，而ValueObject.Value<T>是拆箱，裝箱和拆箱的步驟必須一一對應。

 

4.4　　使用對象池

　　對於protobuf-net反序列化的時候會創建pb對象這一點，最合理的方式是使用對象池，Hook住protobuf-net創建對象的地方，從對象池中取對象，而不是新建對象，用完以后再執行回收。池接口如下：

/// <summary>
/// 說明：proto網絡數據緩存池需要實現的接口
/// 
/// @by wsh 2017-07-01
/// </summary>

public interface IProtoPool
{
    // 獲取數據
    object Get();

    // 回收數據
    void Recycle(object data);

    // 清除指定數據
    void ClearData(object data);
    
    // 深拷貝指定數據
    object DeepCopy(object data);
    
    // 釋放緩存池
    void Dispose();
}

 

4.5　　使用字節緩存池

　　對於new byte[]操作的GC優化也是一樣的，只不過這里使用的緩存池是針對字節數組而非pb對象，我這里是自己實現了一套通用的字節流與字節buffer緩存池StreamBufferPool，每次需要字節buffer時從中取，用完以后放回。

 

 

五　　protobuf-net GC優化實踐

　　以上關鍵的優化方案都已經有了，具體怎么部署到protobuf-net的細節問題這里不再多說，有興趣的朋友自己去看下源代碼。這里就優化以后的protobuf-net使用方式做下介紹，首先是目錄結構：

 

 

protobuf-net-gc-optimization工程結構

 

　　1、CustomDatastruct：自定義的數據結構

　　2、Protobuf-extension/Protocol：測試協議

　　3、Protobuf-extension/ProtoFactory：包含兩個部分，其中ProtoPool是pb對象池，而ProtoSerializer是對protobuf-net裝飾器的擴展，用於特定協議的去反射

　　4、ProtoBufSerializer：Protobuf-net對外接口的封裝。

　　主要看下ProtoBufSerializer腳本：

using battle;
using CustomDataStruct;
using ProtoBuf.Serializers;
using System.IO;

/// <summary>
/// 說明：ProtoBuf初始化、緩存等管理；序列化、反序列化等封裝
/// 
/// @by wsh 2017-07-01
/// </summary>

public class ProtoBufSerializer : Singleton<ProtoBufSerializer>
{
    ProtoBuf.Meta.RuntimeTypeModel model;

    public override void Init()
    {
        base.Init();

        model = ProtoBuf.Meta.RuntimeTypeModel.Default;
        AddCustomSerializer();
        AddProtoPool();
        model.netDataPoolDelegate = ProtoFactory.Get;
        model.bufferPoolDelegate = StreamBufferPool.GetBuffer;
    }

    public override void Dispose()
    {
        model = null;
        ClearCustomSerializer();
        ClearProtoPool();
    }

    static public void Serialize(Stream dest, object instance)
    {
        ProtoBufSerializer.instance.model.Serialize(dest, instance);
    }

    static public object Deserialize(Stream source, System.Type type, int length = -1)
    {
        return ProtoBufSerializer.instance.model.Deserialize(source, null, type, length, null);
    }

    void AddCustomSerializer()
    {
        // 自定義Serializer以避免ProtoBuf反射
        CustomSetting.AddCustomSerializer(typeof(ntf_battle_frame_data), new NtfBattleFrameDataDecorator());
        CustomSetting.AddCustomSerializer(typeof(ntf_battle_frame_data.one_slot), new OneSlotDecorator());
        CustomSetting.AddCustomSerializer(typeof(ntf_battle_frame_data.cmd_with_frame), new CmdWithFrameDecorator());
        CustomSetting.AddCustomSerializer(typeof(one_cmd), new OneCmdDecorator());
    }

    void ClearCustomSerializer()
    {
        CustomSetting.CrearCustomSerializer();
    }


    void AddProtoPool()
    {
        // 自定義緩存池以避免ProtoBuf創建實例
        ProtoFactory.AddProtoPool(typeof(ntf_battle_frame_data), new NtfBattleFrameDataPool());
        ProtoFactory.AddProtoPool(typeof(ntf_battle_frame_data.one_slot), new OneSlotPool());
        ProtoFactory.AddProtoPool(typeof(ntf_battle_frame_data.cmd_with_frame), new CmdWithFramePool());
        ProtoFactory.AddProtoPool(typeof(one_cmd), new OneCmdPool());
    }

    void ClearProtoPool()
    {
        ProtoFactory.ClearProtoPool();
    }
}

　　其中：

　　1、AddCustomSerializer：用於添加自定義的裝飾器到protobuf-net

　　2、AddProtoPool：用於添加自定義對象池到protobuf-net

　　3、Serialize：提供給邏輯層使用的序列化接口

　　4、Deserialize：提供給邏輯層使用的反序列化接口

　　使用示例：

const int SENF_BUFFER_LEN = 64 * 1024;
const int REVIVE_BUFFER_LEN = 128 * 1024;
MemoryStream msSend = new MemoryStream(sendBuffer, 0, SENF_BUFFER_LEN, true, true);;
MemoryStream msRecive = new MemoryStream(reciveBuffer, 0, REVIVE_BUFFER_LEN, true, true);;

msSend.SetLength(SENF_BUFFER_LEN);
msSend.Seek(0, SeekOrigin.Begin);

ntf_battle_frame_data dataTmp = ProtoFactory.Get<ntf_battle_frame_data>();
ntf_battle_frame_data.one_slot oneSlot = ProtoFactory.Get<ntf_battle_frame_data.one_slot>();
ntf_battle_frame_data.cmd_with_frame cmdWithFrame = ProtoFactory.Get<ntf_battle_frame_data.cmd_with_frame>();
one_cmd oneCmd = ProtoFactory.Get<one_cmd>();
cmdWithFrame.cmd = oneCmd;
oneSlot.cmd_list.Add(cmdWithFrame);
dataTmp.slot_list.Add(oneSlot);
DeepCopyData(data, dataTmp);
ProtoBufSerializer.Serialize(msSend, dataTmp);
ProtoFactory.Recycle(dataTmp);//*************回收，很重要

msSend.SetLength(msSend.Position);//長度一定要設置對
msSend.Seek(0, SeekOrigin.Begin);//指針一定要復位
//msRecive.SetLength(msSend.Length);//同理，但是如果Deserialize指定長度，則不需要設置流長度
msRecive.Seek(0, SeekOrigin.Begin);//同理

Buffer.BlockCopy(msSend.GetBuffer(), 0, msRecive.GetBuffer(), 0, (int)msSend.Length);

dataTmp = ProtoBufSerializer.Deserialize(msRecive, typeof(ntf_battle_frame_data), (int)msSend.Length) as ntf_battle_frame_data;

PrintData(dataTmp);
ProtoFactory.Recycle(dataTmp);//*************回收，很重要

 

 

六　　Unity3D游戲GC優化實踐

　　protobuf-net的GC優化實踐要說的就這么多，其實做GC優化的大概步驟就是這些：GC分析，優化方案，最后再重構代碼。這里再補充一些其它的內容，CustomDatastruct中包含了：

　　1、BetterDelegate：泛型委托包裝類，針對深層函數調用樹中使用泛型委托作為函數參數進行傳遞時代碼編寫困難的問題。

　　2、BetterLinkedList：無GC鏈表

　　3、BetterStringBuilder：無GC版StrigBuilder

　　4、StreamBufferPool：字節流與字節buffer緩存池

　　5、ValueObject：無GC裝箱拆箱

　　6、ObjPool：通用對象池

　　其中protobuf-net的無GC優化用到了StreamBufferPool、ValueObject與ObjPool，主要是對象池和免GC裝箱，其它的在源代碼中有詳細注釋。TestScenes下包含了各種測試場景：

 

測試場景

 

　　這里對其中關鍵的幾個結論給下說明：

　　1、LinkedList當自定義結構做鏈表節點，必須實現IEquatable<T>、IComparable<T>接口，否則Roemove、Cotains、Find、FindLast每次都有GC產生

// 重要：對於自定義結構一定要繼承IEquatable<T>接口並實現它
// 此外：對於Sort，實現IComparable<T>接口，則在傳入委托的時候可以和系統簡單值類型一樣
public struct CustomStruct : IEquatable<CustomStruct>, IComparable<CustomStruct>
{
    public int a;
    public string b;

    public CustomStruct(int a, string b)
    {
        this.a = a;
        this.b = b;
    }

    public bool Equals(CustomStruct other)
    {
        return a == other.a && b == other.b;
    }

    public int CompareTo(CustomStruct other)
    {
        if (a != other.a)
        {
            return a.CompareTo(other.a);
        }

        if (b != other.b)
        {
            return b.CompareTo(other.b);
        }

        return 0;
    }

    // 說明：測試正確性用的，不是必須
    public override string ToString()
    {
        return string.Format("<a = {0}, b = {1}>", a, b);
    }
}

　　2、所有委托必須緩存，產生GC的測試一律是因為每次調用都生成了一個新的委托

public class TestDelegateGC : MonoBehaviour
{
    public delegate void TestDelegate(GameObject go, string str, int num);
    public delegate void TestTDelegate<T,U,V>(T go, U str, V num);

    Delegate mDelegate1;
    Delegate mDelegate2;
    TestDelegate mDelegate3;
    TestTDelegate<GameObject, string, int> mDelegate4;
    TestDelegate mDelegate5;
    Comparison<int> mDelegate6;
    Comparison<int> mDelegate7;

    int mTestPriviteData = 100; 
    List<int> mTestList = new List<int>();

    // Use this for initialization
    void Start () {
        mDelegate1 = (TestDelegate)DelegateFun;
        mDelegate2 = Delegate.CreateDelegate(typeof(TestDelegate), this, "DelegateFun");
        mDelegate3 = DelegateFun;
        mDelegate4 = TDelegateFun;

        //static
        mDelegate5 = new TestDelegate(StaticDelegateFun);
        mDelegate6 = SortByXXX;
        mDelegate7 = TSortByXXX<int>;

        mTestList.Add(1);
        mTestList.Add(2);
        mTestList.Add(3);
    }
    
    // Update is called once per frame
    void Update () {
        // 不使用泛型
        TestFun(DelegateFun); 
        TestFun(mDelegate1 as TestDelegate); //無GC
        TestFun(mDelegate2 as TestDelegate); //無GC
        TestFun(mDelegate3); //無GC，推薦
        TestFun(mDelegate5); //無GC
        // 使用泛型，更加通用
        TestTFun(TDelegateFun, gameObject, "test", 1000);//每次調用產生104B垃圾
        TestTFun(mDelegate4, gameObject, "test", 1000);// 無GC，更通用，極力推薦***********
        // Sort測試
        mTestList.Sort();//無GC
        TestSort(SortByXXX);//每次調用產生104B垃圾
        TestSort(mDelegate6);//無GC
        TestSort(TSortByXXX);//每次調用產生104B垃圾
        TestSort(TSortByXXX);//每次調用產生104B垃圾
        TestSort(mDelegate7);//無GC
    }

    private void TestFun(TestDelegate de)
    {
        de(gameObject, "test", 1000);
    }

    private void TestTFun<T, U, V>(TestTDelegate<T, U, V> de, T arg0, U arg1, V arg2)
    {
        de(arg0, arg1, arg2);
    }

    private void TestSort<T>(List<T> list, Comparison<T> sortFunc)
    {
        list.Sort(sortFunc);
    }

    private void TestSort(Comparison<int> sortFunc)
    {
        mTestList.Sort(sortFunc);
    }

    private void DelegateFun(GameObject go, string str, int num)
    {
    }

    private void TDelegateFun<T, U, V>(T go, U str, V num)
    {
    }

    private static void StaticDelegateFun(GameObject go, string str, int num)
    {
    }

    private int SortByXXX(int x, int y)
    {
        return x.CompareTo(y);
    }

    private int TSortByXXX<T>(T x, T y) where T : IComparable<T>
    {
        return x.CompareTo(y);
    }
}

　　3、List<T>對於自定義結構做列表項，必須實現IEquatable<T>、IComparable<T>接口，否則Roemove、Cotains、IndexOf、sort每次都有GC產生；對於Sort，需要傳遞一個委托。這兩點的實踐上面都已經說明。

　　其它的測試自行參考源代碼。

 

 

七　　項目工程地址

　　gitbub地址為：https://github.com/smilehao/protobuf-net-gc-optimization。