内存对齐的malloc、realloc、free

最近需要用到内存对齐的内存分配函数，参考网上的一些实现，自己也试着写了一个，经过测试可以使用。欢迎拍砖，微笑。
0.内存对齐的大小

#define CACHE_LINE_SIZE 64  /*内存对齐的大小，我们选用一个cache line的大小*/
#define CACHE_LINE_MASK (CACHE_LINE_SIZE - 1)  /*用于计算对齐的掩码*/

1.内存对齐的malloc()

void *al_malloc(size_t size)
{
    void *aligned_memory = NULL;
    void *malloced_memory = NULL;
    int tmp = 0;

    if (size == 0)
    {
        return NULL;
    }
    /*如果申请内存的大小小于CACHE_LINE_SIZE，则不进行对齐，以节省空间。*/
    if (size < CACHE_LINE_SIZE) 
    {
        /*多申请一个指针大小的空间，用于保存对齐前的地址*/
        malloced_memory = malloc(size + sizeof(void *));         
        /*得到对齐后的地址*/
        aligned_memory = (void *)((char *)malloced_memory + sizeof(void *)); 
        /*保存对齐前的地址*/
        ((void **)aligned_memory)[-1] = malloced_memory; 

        return aligned_memory;
    }
    /*多申请一个cache line大小的空间，用于对齐操作，或者保存对齐前的地址*/
    malloced_memory = malloc(size + CACHE_LINE_SIZE); 
    /*判断申请到的地址是否已经对齐*/
    tmp = (uint64_t)malloced_memory & CACHE_LINE_MASK; 
    if (tmp == 0) 
    {
        /*如果地址本身已经对齐，则只需保存该地址即可，
        但申请到的地址要保存到对齐地址的前一个单元，
        因此要将本身已经对齐的地址后移cache line个单元，
        那么在申请的时候就应该多申请cache line个单元*/
        aligned_memory = (void *)((char *)malloced_memory + CACHE_LINE_SIZE);
    }
    else
    {
        /*得到对齐后的地址*/
        aligned_memory = (void *)(((uint64_t)malloced_memory + CACHE_LINE_MASK) 
        & ~CACHE_LINE_MASK); 
    }
    /*保存对齐前的地址*/
    ((void **)aligned_memory)[-1] = malloced_memory; 

    return aligned_memory;
}

2.内存对齐的realloc()

void *al_realloc(void *addr, size_t size)
{
    void *real_addr = NULL; 
    void *malloced_addr = NULL; 
    void *aligned_addr = NULL;  
    char *p = NULL;     
    char *q = NULL;     
    int delt = 0;       
    int new_size = 0;  

    if (addr == NULL) 
    {
        /*如果传入内存首地址为空，则相当于调用malloc()*/
        return al_malloc(size);
    }
    if (size == 0) 
    {
        /*如果传入申请内存大小为0，则相当于调用free()*/
        al_free(addr);
        return NULL;
    }
    /*多申请cache line大小的空间*/
    new_size = size + CACHE_LINE_SIZE;
    /*addr是使用al_malloc()或al_realloc()分配得到的一个对齐地址，
    real_addr为addr所指向的内存块对齐前的真实起址*/
    real_addr = ((void **)addr)[-1];  
    /*以内存块的真实首地址为起址，重新申请内存*/
    malloced_addr = realloc(real_addr, new_size); 
    if (malloced_addr == real_addr)  
    {
            /*如果新申请的内存是原内存块的扩展, 则直接返回原来对齐的地址*/
            return addr;
    }
    /*得到原内存块中第一个数据在新内存块中的存储位置*/
    addr = (void *)((char *)malloced_addr + ((char *)addr - (char *)real_addr)); 
    /*得到对齐后的地址*/
    aligned_addr = (void *)(((uint64_t)malloced_addr + CACHE_LINE_MASK) 
    & ~CACHE_LINE_MASK); 
    if (aligned_addr < addr)   
    {
            /*对齐后的地址在第一个数据的前面，则将所有数据向前移动delt个单元*/
            delt = addr - aligned_addr;
            q = (char *)malloced_addr + new_size - 1;
            for (p = (char *)addr; p <= q; p++)
            {
                    *(p - delt) = *p;
            }
    } else if (addr < aligned_addr) 
    {
            /*对齐后的地址在第一个数据的后面，则将所有数据向后移动delt个单元*/
            delt = aligned_addr - addr;
            q = (char *)addr;
            for (p = (char *)malloced_addr + new_size - delt - 1; p >= q; p--)
            {
                    *(p + delt) = *p;
            }
    }
    /*保存对齐前的地址*/
    ((void **)aligned_addr)[-1] = malloced_addr; 

    return aligned_addr;

}

3.内存对齐的free()

void al_free (void *p)
{
    if(p) 
    {
        /*传入要释放的内存块的真实首地址*/
        free(((void **)p)[-1]); 
    }

}