玩家属性同步优化-脏数据标记（位运算、数组、stl之bitset）

把大神的帖子中一部分摘抄出来，结合自己写的位运算代码和循环代码（数组遍历）进行性能测试分析并给出结果。 摘自： https://www.gameres.com/827195.html

本文适用于所有脏标记遍历功能，提升性能几倍，本文以游戏中玩家的属性同步作为例子进行介绍。

先说性能分析结果：一般玩家属性列表也就120个够用了，其中常用的攻击，防御，血蓝等，不超过20个。每0.5秒同步一次，那么变化的常用属性更少。

当变化10个属性，位运算性能提升6倍，20个时4倍，如图所示：

总结：位运算效率高，并且把常用属性定义为低位效率更高。 其次是数组（原因是遍历），再其次是set（影响原因是hash函数、hash扩容、二叉树节点转换），最差是stl之bitset（原因：本质也是数组）

优化前的循环算法（数组）：

 const int N = ;
 class BitSet
 {
     public:
         BitSet()
         {
             memset(m_szBits,,sizeof(m_szBits));
             m_bBitsDirty = false;
         }
         int Set(size_t i)
         {
             if(i >=  && i < N)
             {
                 ++m_szBits[i];

                 m_bBitsDirty = true;

             }
             return ;
         }
         int Get(size_t i) const
         {
             if(i >=  && i < N)
             {
                 return m_szBits[i] > ;
             }
             return ;
         }
         void Clean()
         {
             memset(m_szBits,,sizeof(m_szBits));
             m_bBitsDirty = false;
         }
         bool IsDirty() const
         {
             return m_bBitsDirty;
         }
     private:
         char * m_szBits[N];
         bool m_bBitsDirty;
 };

优化后的位运算：

 const int nLLLeng = ;
 class NewBitSet
 {
     public:
         NewBitSet():llLow(0ull),llHight(0ull)
     {
     }
         void Set(size_t i)
         {
             if(i >  && i < nLLLeng)
             {
                 llLow |= 1ull << i;
             }
             else if (i < nLLLeng * )
             {
                 llHight |= 1ull << (i & 0x3F);    // 0x3F 是64的16进制，这样做是相当于减64
             }
         }
         void GetAllDirty(int * arrDirty, int & nMaxCount) const
         {
             unsigned long long nllLowTemp = llLow;
             unsigned long long nllHightTemp = llHight;
             nMaxCount = -;
             while (nllLowTemp)
             {
                 arrDirty[++nMaxCount] = __builtin_ffsll(nllLowTemp) - ;
                 nllLowTemp &= (nllLowTemp - );
             }
             while (nllHightTemp)
             {
                 arrDirty[++nMaxCount] = __builtin_ffsll(nllHightTemp) -  + nLLLeng;
                 nllHightTemp &= (nllHightTemp - );
             }
         }
         void Clean()
         {
             llLow = llHight = 0ull;
         }

         bool IsDirty() const
         {
             return llLow || llHight;
         }
     private:
         unsigned long long int llLow;
         unsigned long long int llHight;
 };

测试用例：

 #include <iostream>
 #include <sys/time.h>
 #include<stdlib.h>
 #include <algorithm>
 #include <math.h>
 #include <stdio.h>
 #include<vector>
 #include<map>
 #include <string.h>
 using namespace std;
 const int N = ;
 class BitSet
 {
     public:
         BitSet()
         {
             memset(m_szBits,,sizeof(m_szBits));
             m_bBitsDirty = false;
         }
         int Set(size_t i)
         {
             if(i >=  && i < N)
             {
                 ++m_szBits[i];

                 m_bBitsDirty = true;

             }
             return ;
         }
         int Get(size_t i) const
         {
             if(i >=  && i < N)
             {
                 return m_szBits[i] > ;
             }
             return ;
         }
         void Clean()
         {
             memset(m_szBits,,sizeof(m_szBits));
             m_bBitsDirty = false;
         }
         bool IsDirty() const
         {
             return m_bBitsDirty;
         }
     private:
         char * m_szBits[N];
         bool m_bBitsDirty;
 };

 const int nLLLeng = ;
 class NewBitSet
 {
     public:
         NewBitSet():llLow(0ull),llHight(0ull)
     {
     }
         void Set(size_t i)
         {
             if(i >  && i < nLLLeng)
             {
                 llLow |= 1ull << i;
             }
             else if (i < nLLLeng * )
             {
                 llHight |= 1ull << (i & 0x3F);    // 0x3F 是64的16进制，这样做是相当于减64
             }
         }
         void GetAllDirty(int * arrDirty, int & nMaxCount) const
         {
             unsigned long long nllLowTemp = llLow;
             unsigned long long nllHightTemp = llHight;
             nMaxCount = -;
             while (nllLowTemp)
             {
                 arrDirty[++nMaxCount] = __builtin_ffsll(nllLowTemp) - ;
                 nllLowTemp &= (nllLowTemp - );
             }
             while (nllHightTemp)
             {
                 arrDirty[++nMaxCount] = __builtin_ffsll(nllHightTemp) -  + nLLLeng;
                 nllHightTemp &= (nllHightTemp - );
             }
         }
         void Clean()
         {
             llLow = llHight = 0ull;
         }

         bool IsDirty() const
         {
             return llLow || llHight;
         }
     private:
         unsigned long long int llLow;
         unsigned long long int llHight;
 };

 int nPrintCount = ;

 void DirtyBit(int nRandCount)
 {
     NewBitSet tDirty;
     int nRand = ;
     //srand((unsigned)time(0));
     for (int i = ; i < nRandCount;i++)
     {
     //    nRand = rand()%126 + 1;
         tDirty.Set(i+);
     }
     if (!tDirty.IsDirty())
     {
         return;
     }
     int arrDirty[nLLLeng * ] = {};
     //同步自己执行次数
     int nMaxCount = ;
     tDirty.GetAllDirty(arrDirty, nMaxCount);
     nMaxCount = ;
     //同步WS执行次数
     tDirty.GetAllDirty(arrDirty, nMaxCount);

     int nNotPrint = ;
     for (int i = ; i< nMaxCount; i++)
     {
         nNotPrint = arrDirty[i];
     }
     tDirty.Clean();
 }

 void DirtyArr(int nRandCount)
 {
     BitSet tDirty;
     int nRand = ;
 //    srand((unsigned)time(0));
     for (int i = ; i < nRandCount;i++)
     {
 //        nRand = rand()%126 + 1;
         tDirty.Set(i+);
     }
     if (tDirty.IsDirty())
     {
         int arrDirty[N] = {};
         int nMaxCount = -;
         //同步自己执行次数
         for (int i = ; i< N; ++i)
         {
             if (tDirty.Get(i))
             {
                 arrDirty[++nMaxCount] = i;
             }
         }
         //同步WS执行次数
         nMaxCount = -;
         for (int i = ; i< N; ++i)
         {
             if (tDirty.Get(i))
             {
                 arrDirty[++nMaxCount] = i;
             }
         }
         int nNotPrint = ;
         for (int i = ; i< nMaxCount + ; i++)
         {
             nNotPrint = arrDirty[i];
         }
     }

     tDirty.Clean();
 }

 int main()
 {
     float time_use=;
     struct timeval start;
     struct timeval end;
     int nTestCount = ;
     gettimeofday(&start,NULL);

     nPrintCount = ;
     //处理过程--开始
     for (int i = ; i< ; ++i)
     {
         DirtyBit(nTestCount);
     }
     //处理过程--结束

     cout<<endl;
     gettimeofday(&end,NULL);
     time_use=(end.tv_sec-start.tv_sec)*+(end.tv_usec-start.tv_usec);//微秒
     printf("time_use is %.10f\n",time_use);

     nPrintCount = ;
     gettimeofday(&start,NULL);
     //处理过程--开始
     for (int i = ; i< ; ++i)
     {
         DirtyArr(nTestCount);
     }
     //处理过程--结束

     cout<<endl;
     gettimeofday(&end,NULL);

     time_use=(end.tv_sec-start.tv_sec)*+(end.tv_usec-start.tv_usec);//微秒
     printf("time_use is %.10f\n",time_use);
     return ;
 }