rt_malloc 申请失败

发布于 2014-08-27 10:28:40 浏览：3328 订阅该版

这是我添加打印函数后的rt_malloc代码
void *rt_malloc(rt_size_t size)
{
    rt_size_t ptr, ptr2;
    struct heap_mem *mem, *mem2;

RT_DEBUG_NOT_IN_INTERRUPT;

if (size == 0){
		rt_kprintf("rt_malloc size=0 ");
 return RT_NULL;

}

if (size != RT_ALIGN(size, RT_ALIGN_SIZE))
 RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d ",
 size, RT_ALIGN(size, RT_ALIGN_SIZE)));
 else
 RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d ", size));

/* alignment size */
    size = RT_ALIGN(size, RT_ALIGN_SIZE);

if (size > mem_size_aligned)
 {
 RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory "));

return RT_NULL;
    }

/* every data block must be at least MIN_SIZE_ALIGNED long */
 if (size < MIN_SIZE_ALIGNED)
 size = MIN_SIZE_ALIGNED;

/* take memory semaphore */
 rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
	rt_kprintf("lfree - heap_ptr = %d ",(rt_uint8_t *)lfree - heap_ptr);
rt_kprintf("mem_size_aligned - size = %d ",mem_size_aligned - size);
 for (ptr = (rt_uint8_t *)lfree - heap_ptr;
 ptr < mem_size_aligned - size;
 ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
 {
 mem = (struct heap_mem *)&heap_ptr[ptr];
		rt_kprintf("mem->used=%d,(mem->next - (ptr + SIZEOF_STRUCT_MEM)) - size=%d ",mem->used,(mem->next - (ptr + SIZEOF_STRUCT_MEM)) - size);
 if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)
 {
 /* mem is not used and at least perfect fit is possible:
 * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */

if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
                (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))
            {
                /* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing
                 * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
                 * -> split large block, create empty remainder,
                 * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
                 * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
                 * struct heap_mem would fit in but no data between mem2 and mem2->next
                 * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
                 *       region that couldn't hold data, but when mem->next gets freed,
                 *       the 2 regions would be combined, resulting in more free memory
                 */
                ptr2 = ptr + SIZEOF_STRUCT_MEM + size;

/* create mem2 struct */
                mem2       = (struct heap_mem *)&heap_ptr[ptr2];
                mem2->used = 0;
                mem2->next = mem->next;
                mem2->prev = ptr;

/* and insert it between mem and mem->next */
                mem->next = ptr2;
                mem->used = 1;

if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
 {
 ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
 }
#ifdef RT_MEM_STATS
 used_mem += (size + SIZEOF_STRUCT_MEM);
 if (max_mem < used_mem)
 max_mem = used_mem;
#endif
 }
 else
 {
 /* (a mem2 struct does no fit into the user data space of mem and mem->next will always
 * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
 * take care of this).
 * -> near fit or excact fit: do not split, no mem2 creation
 * also can't move mem->next directly behind mem, since mem->next
 * will always be used at this point!
 */
 mem->used = 1;
#ifdef RT_MEM_STATS
 used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr);
 if (max_mem < used_mem)
 max_mem = used_mem;
#endif
 }
 /* set memory block magic */
 mem->magic = HEAP_MAGIC;

if (mem == lfree)
            {
                /* Find next free block after mem and update lowest free pointer */
                while (lfree->used && lfree != heap_end)
                    lfree = (struct heap_mem *)&heap_ptr[lfree->next];

RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
            }

rt_sem_release(&heap_sem);
 RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end);
 RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
 RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0);

RT_DEBUG_LOG(RT_DEBUG_MEM,
 ("allocate memory at 0x%x, size: %d ",
 (rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
 (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));

RT_OBJECT_HOOK_CALL(rt_malloc_hook,
                                (((void *)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size));

/* return the memory data except mem struct */
            return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
        }
    }

rt_sem_release(&heap_sem);
rt_kprintf("malloc return null ") ;
 return RT_NULL;
}

申请16个字节可以申请成功
malloc size 16
lfree - heap_ptr = 0

mem_size_aligned - size = 10824

mem->used=0,(mem->next - (ptr + SIZEOF_STRUCT_MEM)) - size=10824

allocate memory at 0x2000259c, size: 28
但是第一次申请20个字节，刚好是4的整数倍
但是申请不成功
malloc size 20
lfree - heap_ptr = 28

mem_size_aligned - size = 10820

mem->used=8192,(mem->next - (ptr + SIZEOF_STRUCT_MEM)) - size=10792

malloc return null
然后再去申请20字节
for循环都不进去了
malloc size 20
lfree - heap_ptr = 10852

mem_size_aligned - size = 10820

malloc return null
但是我用malloc是可以申请成功的，不知道为什么？