mirror of
https://github.com/lwip-tcpip/lwip.git
synced 2024-10-04 05:39:53 +00:00
mem.c: beautify converting between struct mem and heap index (add ptr_to_mem/mem_to_ptr)
This commit is contained in:
parent
1710fc1a89
commit
a61aee337b
@ -337,6 +337,17 @@ static volatile u8_t mem_free_count;
|
||||
|
||||
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
|
||||
|
||||
static struct mem *
|
||||
ptr_to_mem(mem_size_t ptr)
|
||||
{
|
||||
return (struct mem *)(void *)&ram[ptr];
|
||||
}
|
||||
|
||||
static mem_size_t
|
||||
mem_to_ptr(void *mem)
|
||||
{
|
||||
return (mem_size_t)((u8_t *)mem - ram);
|
||||
}
|
||||
|
||||
/**
|
||||
* "Plug holes" by combining adjacent empty struct mems.
|
||||
@ -362,25 +373,25 @@ plug_holes(struct mem *mem)
|
||||
/* plug hole forward */
|
||||
LWIP_ASSERT("plug_holes: mem->next <= MEM_SIZE_ALIGNED", mem->next <= MEM_SIZE_ALIGNED);
|
||||
|
||||
nmem = (struct mem *)(void *)&ram[mem->next];
|
||||
nmem = ptr_to_mem(mem->next);
|
||||
if (mem != nmem && nmem->used == 0 && (u8_t *)nmem != (u8_t *)ram_end) {
|
||||
/* if mem->next is unused and not end of ram, combine mem and mem->next */
|
||||
if (lfree == nmem) {
|
||||
lfree = mem;
|
||||
}
|
||||
mem->next = nmem->next;
|
||||
((struct mem *)(void *)&ram[nmem->next])->prev = (mem_size_t)((u8_t *)mem - ram);
|
||||
ptr_to_mem(nmem->next)->prev = mem_to_ptr(mem);
|
||||
}
|
||||
|
||||
/* plug hole backward */
|
||||
pmem = (struct mem *)(void *)&ram[mem->prev];
|
||||
pmem = ptr_to_mem(mem->prev);
|
||||
if (pmem != mem && pmem->used == 0) {
|
||||
/* if mem->prev is unused, combine mem and mem->prev */
|
||||
if (lfree == mem) {
|
||||
lfree = pmem;
|
||||
}
|
||||
pmem->next = mem->next;
|
||||
((struct mem *)(void *)&ram[mem->next])->prev = (mem_size_t)((u8_t *)pmem - ram);
|
||||
ptr_to_mem(mem->next)->prev = mem_to_ptr(pmem);
|
||||
}
|
||||
}
|
||||
|
||||
@ -403,7 +414,7 @@ mem_init(void)
|
||||
mem->prev = 0;
|
||||
mem->used = 0;
|
||||
/* initialize the end of the heap */
|
||||
ram_end = (struct mem *)(void *)&ram[MEM_SIZE_ALIGNED];
|
||||
ram_end = ptr_to_mem(MEM_SIZE_ALIGNED);
|
||||
ram_end->used = 1;
|
||||
ram_end->next = MEM_SIZE_ALIGNED;
|
||||
ram_end->prev = MEM_SIZE_ALIGNED;
|
||||
@ -426,9 +437,9 @@ mem_link_valid(struct mem *mem)
|
||||
{
|
||||
struct mem *nmem, *pmem;
|
||||
mem_size_t rmem_idx;
|
||||
rmem_idx = (mem_size_t)((u8_t *)mem - ram);
|
||||
nmem = (struct mem *)(void *)&ram[mem->next];
|
||||
pmem = (struct mem *)(void *)&ram[mem->prev];
|
||||
rmem_idx = mem_to_ptr(mem);
|
||||
nmem = ptr_to_mem(mem->next);
|
||||
pmem = ptr_to_mem(mem->prev);
|
||||
if ((mem->next > MEM_SIZE_ALIGNED) || (mem->prev > MEM_SIZE_ALIGNED) ||
|
||||
((mem->prev != rmem_idx) && (pmem->next != rmem_idx)) ||
|
||||
((nmem != ram_end) && (nmem->prev != rmem_idx))) {
|
||||
@ -555,7 +566,7 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
/* cast through void* to get rid of alignment warnings */
|
||||
mem = (struct mem *)(void *)((u8_t *)rmem - SIZEOF_STRUCT_MEM);
|
||||
/* ... and its offset pointer */
|
||||
ptr = (mem_size_t)((u8_t *)mem - ram);
|
||||
ptr = mem_to_ptr(mem);
|
||||
|
||||
size = (mem_size_t)((mem_size_t)(mem->next - ptr) - SIZEOF_STRUCT_MEM);
|
||||
LWIP_ASSERT("mem_trim can only shrink memory", newsize <= size);
|
||||
@ -571,7 +582,7 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
/* protect the heap from concurrent access */
|
||||
LWIP_MEM_FREE_PROTECT();
|
||||
|
||||
mem2 = (struct mem *)(void *)&ram[mem->next];
|
||||
mem2 = ptr_to_mem(mem->next);
|
||||
if (mem2->used == 0) {
|
||||
/* The next struct is unused, we can simply move it at little */
|
||||
mem_size_t next;
|
||||
@ -580,9 +591,9 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
/* create new struct mem which is moved directly after the shrinked mem */
|
||||
ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize);
|
||||
if (lfree == mem2) {
|
||||
lfree = (struct mem *)(void *)&ram[ptr2];
|
||||
lfree = ptr_to_mem(ptr2);
|
||||
}
|
||||
mem2 = (struct mem *)(void *)&ram[ptr2];
|
||||
mem2 = ptr_to_mem(ptr2);
|
||||
mem2->used = 0;
|
||||
/* restore the next pointer */
|
||||
mem2->next = next;
|
||||
@ -594,7 +605,7 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
* let 'mem2->next->prev' point to mem2 again. but only if mem2->next is not
|
||||
* the end of the heap */
|
||||
if (mem2->next != MEM_SIZE_ALIGNED) {
|
||||
((struct mem *)(void *)&ram[mem2->next])->prev = ptr2;
|
||||
ptr_to_mem(mem2->next)->prev = ptr2;
|
||||
}
|
||||
MEM_STATS_DEC_USED(used, (size - newsize));
|
||||
/* no need to plug holes, we've already done that */
|
||||
@ -607,7 +618,7 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
* region that couldn't hold data, but when mem->next gets freed,
|
||||
* the 2 regions would be combined, resulting in more free memory */
|
||||
ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize);
|
||||
mem2 = (struct mem *)(void *)&ram[ptr2];
|
||||
mem2 = ptr_to_mem(ptr2);
|
||||
if (mem2 < lfree) {
|
||||
lfree = mem2;
|
||||
}
|
||||
@ -616,7 +627,7 @@ mem_trim(void *rmem, mem_size_t new_size)
|
||||
mem2->prev = ptr;
|
||||
mem->next = ptr2;
|
||||
if (mem2->next != MEM_SIZE_ALIGNED) {
|
||||
((struct mem *)(void *)&ram[mem2->next])->prev = ptr2;
|
||||
ptr_to_mem(mem2->next)->prev = ptr2;
|
||||
}
|
||||
MEM_STATS_DEC_USED(used, (size - newsize));
|
||||
/* the original mem->next is used, so no need to plug holes! */
|
||||
@ -681,9 +692,9 @@ mem_malloc(mem_size_t size_in)
|
||||
/* Scan through the heap searching for a free block that is big enough,
|
||||
* beginning with the lowest free block.
|
||||
*/
|
||||
for (ptr = (mem_size_t)((u8_t *)lfree - ram); ptr < MEM_SIZE_ALIGNED - size;
|
||||
ptr = ((struct mem *)(void *)&ram[ptr])->next) {
|
||||
mem = (struct mem *)(void *)&ram[ptr];
|
||||
for (ptr = mem_to_ptr(lfree); ptr < MEM_SIZE_ALIGNED - size;
|
||||
ptr = ptr_to_mem(ptr)->next) {
|
||||
mem = ptr_to_mem(ptr);
|
||||
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
|
||||
mem_free_count = 0;
|
||||
LWIP_MEM_ALLOC_UNPROTECT();
|
||||
@ -715,7 +726,7 @@ mem_malloc(mem_size_t size_in)
|
||||
*/
|
||||
ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + size);
|
||||
/* create mem2 struct */
|
||||
mem2 = (struct mem *)(void *)&ram[ptr2];
|
||||
mem2 = ptr_to_mem(ptr2);
|
||||
mem2->used = 0;
|
||||
mem2->next = mem->next;
|
||||
mem2->prev = ptr;
|
||||
@ -724,7 +735,7 @@ mem_malloc(mem_size_t size_in)
|
||||
mem->used = 1;
|
||||
|
||||
if (mem2->next != MEM_SIZE_ALIGNED) {
|
||||
((struct mem *)(void *)&ram[mem2->next])->prev = ptr2;
|
||||
ptr_to_mem(mem2->next)->prev = ptr2;
|
||||
}
|
||||
MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM));
|
||||
} else {
|
||||
@ -736,7 +747,7 @@ mem_malloc(mem_size_t size_in)
|
||||
* will always be used at this point!
|
||||
*/
|
||||
mem->used = 1;
|
||||
MEM_STATS_INC_USED(used, mem->next - (mem_size_t)((u8_t *)mem - ram));
|
||||
MEM_STATS_INC_USED(used, mem->next - mem_to_ptr(mem));
|
||||
}
|
||||
#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
|
||||
mem_malloc_adjust_lfree:
|
||||
@ -756,7 +767,7 @@ mem_malloc_adjust_lfree:
|
||||
goto mem_malloc_adjust_lfree;
|
||||
}
|
||||
#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
|
||||
cur = (struct mem *)(void *)&ram[cur->next];
|
||||
cur = ptr_to_mem(cur->next);
|
||||
}
|
||||
lfree = cur;
|
||||
LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used)));
|
||||
|
Loading…
Reference in New Issue
Block a user