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

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

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

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

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

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

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

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

                m_bBitsDirty = true;

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

优化后的位运算：

const int nLLLeng = 64;
class NewBitSet
{
    public:
        NewBitSet():llLow(0ull),llHight(0ull)
    {
    }
        void Set(size_t i)
        {
            if(i > 0 && i < nLLLeng)
            {
                llLow |= 1ull << i;
            }
            else if (i < nLLLeng * 2)
            {
                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 = -1;
            while (nllLowTemp)
            {
                arrDirty[++nMaxCount] = __builtin_ffsll(nllLowTemp) - 1;
                nllLowTemp &= (nllLowTemp - 1);
            }
            while (nllHightTemp)
            {
                arrDirty[++nMaxCount] = __builtin_ffsll(nllHightTemp) - 1 + nLLLeng;
                nllHightTemp &= (nllHightTemp - 1);
            }
        }
        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 = 128;
class BitSet
{
    public:
        BitSet()
        {
            memset(m_szBits,0,sizeof(m_szBits));
            m_bBitsDirty = false;
        }
        int Set(size_t i)
        {
            if(i >= 0 && i < N)
            {
                ++m_szBits[i];

                m_bBitsDirty = true;

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


const int nLLLeng = 64;
class NewBitSet
{
    public:
        NewBitSet():llLow(0ull),llHight(0ull)
    {
    }
        void Set(size_t i)
        {
            if(i > 0 && i < nLLLeng)
            {
                llLow |= 1ull << i;
            }
            else if (i < nLLLeng * 2)
            {
                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 = -1;
            while (nllLowTemp)
            {
                arrDirty[++nMaxCount] = __builtin_ffsll(nllLowTemp) - 1;
                nllLowTemp &= (nllLowTemp - 1);
            }
            while (nllHightTemp)
            {
                arrDirty[++nMaxCount] = __builtin_ffsll(nllHightTemp) - 1 + nLLLeng;
                nllHightTemp &= (nllHightTemp - 1);
            }
        }
        void Clean()
        {
            llLow = llHight = 0ull;
        }

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

int nPrintCount = 1;

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

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

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

    tDirty.Clean();
}

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

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

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

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

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

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