[项目][CMP][SizeAlignMap类设计]详细讲解

1.说明

• 此类用于计算对象大小的对齐映射规则，包括
  • 计算向上对齐
  • 计算映射的是哪一个自由链表桶
• 但不限于上述方法，因为调用此类中的函数并不需要实例化对象出来，可以直接设置为static方法，直接使用SizeAlignMap::Func()调用，所以还可以扩展使用
  • Thread Cache一次从Central Cache获取多少个对象
  • 计算一次性向系统获取几个页

2.接口设计

// 思考为什么不都按8Bytes对齐？
// 需要32768个8Bytes对齐的自由链表，浪费内存

// 整体控制在最多10%左右的内碎片浪费
// [1,128]                  8byte对齐           freelist[0,16)
// [128+1,1024]             16byte对齐       freelist[16,72)
// [1024+1,8*1024]          128byte对齐      freelist[72,128)
// [8*1024+1,64*1024]       1024byte对齐     freelist[128,184)
// [64*1024+1,256*1024]     8*1024byte对齐   freelist[184,208)

class SizeAlignMap
{
public:
    // v2.0
    static inline size_t _RoundUp(size_t size, size_t alignNum)
    {
        return (size + alignNum - 1) & ~(alignNum - 1);
    }

    // 计算向上对齐是多少
    static inline size_t RoundUp(size_t size)
    {
        if (size <= 128)
        {
            return _RoundUp(size, 8);
        }
        else if (size <= 1024)
        {
            return _RoundUp(size, 16);
        }
        else if (size <= 8 * 1024)
        {
            return _RoundUp(size, 128);
        }
        else if (size <= 64 * 1024)
        {
            return _RoundUp(size, 1024);
        }
        else if (size <= 256 * 1024)
        {
            return _RoundUp(size, 8 * 1024);
        }
        else
        {
            return _RoundUp(size, 1 << PAGE_SHIFT);
        }
    }

    static inline size_t _Index(size_t size, size_t align_shift)
    {
        return ((size + (1 << align_shift) - 1) >> align_shift) - 1;
    }

    // 计算映射的哪一个自由链表桶
    static inline size_t Index(size_t size)
    {
        assert(size <= MAX_BYTES);
        static const size_t FrontNum[4] = {16, 56, 56, 56};
        if (size <= 128)
        {
            return _Index(size, 3);
        }
        else if (size <= 1024)
        {
            return _Index(size, 4) + FrontNum[0];
        }
        else if (size <= 8 * 1024)
        {
            return _Index(size, 7) + FrontNum[0] + FrontNum[1];
        }
        else if (size <= 64 * 1024)
        {
            return _Index(size, 10) + FrontNum[0] + FrontNum[1] + FrontNum[2];
        }
        else if (size <= 256 * 1024)
        {
            return _Index(size, 13) + FrontNum[0] + FrontNum[1] + FrontNum[2] + FrontNum[3];
        }
        else
        {
            // 按理来说不会走到这里
            assert(false);
            return -1;
        }
    }

    // Thread Cache一次从Central Cache获取多少个对象
    static size_t MoveObjNum(size_t size)
    {
        assert(size <= MAX_BYTES);
        assert(size > 0);

        // [2, 512] 一次批量移动对象数量的范围，控制一次性获得对象的数量不会太多，也不会太少
        // 小对象上限高，大对象上限低
        size_t num = MAX_BYTES / size;
        if (num < 2)
        {
            num = 2;
        }

        if (num > 512)
        {
            num = 512;
        }

        return num;
    }

    // 计算一次性向系统获取几个页
    // 每个对象大小不同，获取的数量不同
    // 单个对象8Byte VS 单个对象256KB
    static size_t MovePageNum(size_t alignSize)
    {
        assert(alignSize > 0);

        size_t num = MoveObjNum(alignSize);
        size_t nPage = num * alignSize; // 总字节数
        nPage >>= PAGE_SHIFT;           // 转换出来的页数

        if (nPage == 0)
        {
            nPage = 1;
        }

        return nPage;
    }
};