基于opengl编写一个简易的2d渲染框架-12重构渲染器-blockallocator

static int blockTypeSizeTable[BLOCK_TYPE_COUNT];

        /* 设置索引数组 blockTypeSizeLookup 的 block 类型索引值 */
        if ( blockTypeSizeLookipInitialized == false ) {
            blockTypeSizeLookipInitialized = true;

            int blockTypeSizeIndex = 0;
            for ( int i = 0; i <= MAX_BLOCK_SIZE; i++ ) {
                if ( i <= blockTypeSizeTable[blockTypeSizeIndex] ) {
                    blockTypeSizeLookup[i] = blockTypeSizeIndex;
                }
                else {
                    blockTypeSizeIndex++;
                    blockTypeSizeLookup[i] = blockTypeSizeIndex;
                }
            }
        }

    void* BlockAllocator::allocate(int size)
    {
        if ( size == 0 ) return 0;
        assert(size > 0);

        /* 使用四个字节记录 block 的类型索引，free 是使用 */
        size += sizeof(int);

        /* 申请的空间大于规定的最大值，直接申请，不放到块的链表中去 */
        if ( size > MAX_BLOCK_SIZE ) {
            int* data = ( int* ) malloc(size);
            /* -1 表示这是直接分配的内存 */
            data[0] = UNKNOWN_MEMORY;        
            return (data + 1);
        }

        int index = blockTypeSizeLookup[size];
        assert(0 <= index && index < BLOCK_TYPE_COUNT);

        /* 存在同类型的未被使用的内存块？返回内存块 */
        if ( pFreeLists[index] ) {
            /* 使块头指针指向新的未被使用的 block */
            Block* block = pFreeLists[index];
            pFreeLists[index] = block->next;
            return (( int* ) block + 1);
        }
        else {
            /* 扩展 chunk 数组 */
            if ( nChunkCount == nChunkSpace ) {
                Chunk* oldChunks = pChunks;
                nChunkSpace += CHUNK_ARRAY_INCREMENT;
                pChunks = ( Chunk* ) malloc(nChunkSpace * sizeof(Chunk));
                memcpy(pChunks, oldChunks, nChunkCount * sizeof(Chunk));
                memset(pChunks + nChunkCount, 0, CHUNK_ARRAY_INCREMENT * sizeof(Chunk));
                ::free(oldChunks);
            }
            int chunkSize = chunkSizeTable[index];
            /* 获取一个未被使用的可以用来分配内存的 chunk */
            Chunk* chunk = pChunks + nChunkCount;
            chunk->blocks = ( Block* ) malloc(chunkSize);

            /* 获取当前申请的 block 类型大小 */
            int blockSize = blockTypeSizeTable[index];

            /* 计算一块 chunk 内存能够分割成 block 的数量 */
            int blockCount = chunkSize / blockSize;
            assert(blockCount * blockSize <= chunkSize);

            /* 将 chunk 分割出许多 block，再将 block 以链表的形式串起来 */
            for ( int i = 0; i < blockCount - 1; i++ ) {
                Block* block = ( Block* ) (( char* ) chunk->blocks + blockSize * i);
                Block* next  = ( Block* ) (( char* ) chunk->blocks + blockSize * (i + 1));

                block->sizeIndex = index;
                block->next  = next;
            }
            /* 将最后一个 block 的 next 指向空结点，表示这是最后一个 block */
            Block* lastBlock = ( Block* ) (( char* ) chunk->blocks + blockSize * (blockCount - 1));
            lastBlock->sizeIndex = index;
            lastBlock->next = nullptr;

            /* 将刚申请的 block 链表的第二块 block 保存到 pFreeLists 对应类型的数组中 */
            pFreeLists[index] = chunk->blocks->next;
            nChunkCount++;

            /* 返回刚申请的 block 链表的第一块 block */
            return (( int* ) chunk->blocks + 1);
        }
    }

    void BlockAllocator::free(void* ptr)
    {
        int* data = ( int* ) ptr - 1;
        int index = data[0];

        if ( index == UNKNOWN_MEMORY ) {
            ::free(data);
            return;
        }

        /* 根据内存大小获取 block 类型的索引值，并判断是否有效 */
        assert(0 <= index && index < BLOCK_TYPE_COUNT);
        int size = blockTypeSizeTable[index];

        /* 用头插法将 block 插到 pFreeLists[index] 指向的 block 链表中去 */
        Block* block = ( Block* ) data;
        block->next = pFreeLists[index];
        pFreeLists[index] = block;
    }