From 43f2bfc0135c20cec546290d83cf5a1dc7c820f5 Mon Sep 17 00:00:00 2001 From: "dzzxzz@gmail.com" Date: Sun, 3 Jun 2012 06:16:30 +0000 Subject: [PATCH] add a new command list_memheap() into finsh and unify the coding style in memheap.c git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2151 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- components/finsh/cmd.c | 138 ++++++++++++++++++++++------------- src/memheap.c | 159 +++++++++++++++++++++-------------------- 2 files changed, 169 insertions(+), 128 deletions(-) diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c index 451d80506b..4a186b0f9a 100644 --- a/components/finsh/cmd.c +++ b/components/finsh/cmd.c @@ -26,6 +26,7 @@ * 2009-05-30 Bernard add list_device * 2010-04-21 yi.qiu add list_module * 2012-04-29 goprife improve the command line auto-complete feature. + * 2012-06-02 lgnq add list_memheap */ #include @@ -35,10 +36,10 @@ rt_inline unsigned int rt_list_len(const rt_list_t *l) { unsigned int len = 0; const rt_list_t *p = l; - while( p->next != l ) + while (p->next != l) { p = p->next; - len++; + len ++; } return len; } @@ -60,15 +61,13 @@ long version(void) } FINSH_FUNCTION_EXPORT(version, show RT-Thread version information); -#define rt_list_entry(node, type, member) \ - ((type *)((char *)(node) - (unsigned long)(&((type *)0)->member))) extern struct rt_object_information rt_object_container[]; -static long _list_thread(struct rt_list_node* list) +static long _list_thread(struct rt_list_node *list) { struct rt_thread *thread; struct rt_list_node *node; - rt_uint8_t* ptr; + rt_uint8_t *ptr; rt_kprintf(" thread pri status sp stack size max used left tick error\n"); rt_kprintf("-------- ---- ------- ---------- ---------- ---------- ---------- ---\n"); @@ -91,8 +90,8 @@ static long _list_thread(struct rt_list_node* list) thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr), thread->remaining_tick, thread->error); - } + return 0; } @@ -102,7 +101,7 @@ long list_thread(void) } FINSH_FUNCTION_EXPORT(list_thread, list thread); -static void show_wait_queue(struct rt_list_node* list) +static void show_wait_queue(struct rt_list_node *list) { struct rt_thread *thread; struct rt_list_node *node; @@ -111,7 +110,9 @@ static void show_wait_queue(struct rt_list_node* list) { thread = rt_list_entry(node, struct rt_thread, tlist); rt_kprintf("%s", thread->name); - if (node->next != list) rt_kprintf("/"); + + if (node->next != list) + rt_kprintf("/"); } } @@ -125,7 +126,7 @@ static long _list_sem(struct rt_list_node *list) rt_kprintf("-------- --- --------------\n"); for (node = list->next; node != list; node = node->next) { - sem = (struct rt_semaphore*)(rt_list_entry(node, struct rt_object, list)); + sem = (struct rt_semaphore *)(rt_list_entry(node, struct rt_object, list)); if( !rt_list_isempty(&sem->parent.suspend_thread) ) { rt_kprintf("%-8.*s %03d %d:", RT_NAME_MAX, sem->parent.parent.name, sem->value, @@ -160,8 +161,8 @@ static long _list_event(struct rt_list_node *list) rt_kprintf("-------- ---------- --------------\n"); for (node = list->next; node != list; node = node->next) { - e = (struct rt_event*)(rt_list_entry(node, struct rt_object, list)); - if( !rt_list_isempty(&e->parent.suspend_thread) ) + e = (struct rt_event *)(rt_list_entry(node, struct rt_object, list)); + if (!rt_list_isempty(&e->parent.suspend_thread)) { rt_kprintf("%-8.*s 0x%08x %03d:", RT_NAME_MAX, e->parent.parent.name, e->set, rt_list_len(&e->parent.suspend_thread)); @@ -194,7 +195,7 @@ static long _list_mutex(struct rt_list_node *list) rt_kprintf("-------- -------- ---- --------------\n"); for (node = list->next; node != list; node = node->next) { - m = (struct rt_mutex*)(rt_list_entry(node, struct rt_object, list)); + m = (struct rt_mutex *)(rt_list_entry(node, struct rt_object, list)); rt_kprintf("%-8.*s %-8.*s %04d %d\n", RT_NAME_MAX, m->parent.parent.name, RT_NAME_MAX, m->owner->name, m->hold, rt_list_len(&m->parent.suspend_thread)); } @@ -219,8 +220,8 @@ static long _list_mailbox(struct rt_list_node *list) rt_kprintf("-------- ---- ---- --------------\n"); for (node = list->next; node != list; node = node->next) { - m = (struct rt_mailbox*)(rt_list_entry(node, struct rt_object, list)); - if( !rt_list_isempty(&m->parent.suspend_thread) ) + m = (struct rt_mailbox *)(rt_list_entry(node, struct rt_object, list)); + if (!rt_list_isempty(&m->parent.suspend_thread)) { rt_kprintf("%-8.*s %04d %04d %d:", RT_NAME_MAX, m->parent.parent.name, m->entry, m->size, rt_list_len(&m->parent.suspend_thread)); @@ -254,8 +255,8 @@ static long _list_msgqueue(struct rt_list_node *list) rt_kprintf("-------- ---- --------------\n"); for (node = list->next; node != list; node = node->next) { - m = (struct rt_messagequeue*)(rt_list_entry(node, struct rt_object, list)); - if( !rt_list_isempty(&m->parent.suspend_thread) ) + m = (struct rt_messagequeue *)(rt_list_entry(node, struct rt_object, list)); + if (!rt_list_isempty(&m->parent.suspend_thread)) { rt_kprintf("%-8.*s %04d %d:", RT_NAME_MAX, m->parent.parent.name, m->entry, rt_list_len(&m->parent.suspend_thread)); @@ -279,6 +280,32 @@ long list_msgqueue(void) FINSH_FUNCTION_EXPORT(list_msgqueue, list message queue in system) #endif +#ifdef RT_USING_MEMHEAP +static long _list_memheap(struct rt_list_node *list) +{ + struct rt_memheap *mh; + struct rt_list_node *node; + + rt_kprintf("memheap pool size available size\n"); + rt_kprintf("-------- --------- --------------\n"); + for (node = list->next; node != list; node = node->next) + { + mh = (struct rt_memheap *)rt_list_entry(node, struct rt_object, list); + + rt_kprintf("%-8.*s %04d %04d\n", RT_NAME_MAX, mh->parent.name, + mh->pool_size, mh->available_size); + } + + return 0; +} + +long list_memheap(void) +{ + return _list_memheap(&rt_object_container[RT_Object_Class_MemHeap].object_list); +} +FINSH_FUNCTION_EXPORT(list_memheap, list memory heap in system) +#endif + #ifdef RT_USING_MEMPOOL static long _list_mempool(struct rt_list_node *list) { @@ -289,7 +316,7 @@ static long _list_mempool(struct rt_list_node *list) rt_kprintf("-------- ---- ---- ---- --------------\n"); for (node = list->next; node != list; node = node->next) { - mp = (struct rt_mempool*)rt_list_entry(node, struct rt_object, list); + mp = (struct rt_mempool *)rt_list_entry(node, struct rt_object, list); if (mp->suspend_thread_count > 0) { rt_kprintf("%-8.*s %04d %04d %04d %d:", RT_NAME_MAX, mp->parent.name, @@ -325,10 +352,12 @@ static long _list_timer(struct rt_list_node *list) rt_kprintf("-------- ---------- ---------- -----------\n"); for (node = list->next; node != list; node = node->next) { - timer = (struct rt_timer*)(rt_list_entry(node, struct rt_object, list)); + timer = (struct rt_timer *)(rt_list_entry(node, struct rt_object, list)); rt_kprintf("%-8.*s 0x%08x 0x%08x ", RT_NAME_MAX, timer->parent.name, timer->init_tick, timer->timeout_tick); - if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED) rt_kprintf("activated\n"); - else rt_kprintf("deactivated\n"); + if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED) + rt_kprintf("activated\n"); + else + rt_kprintf("deactivated\n"); } rt_kprintf("current tick:0x%08x\n", rt_tick_get()); @@ -371,7 +400,7 @@ static long _list_device(struct rt_list_node *list) rt_kprintf("-------- ---------- \n"); for (node = list->next; node != list; node = node->next) { - device = (struct rt_device*)(rt_list_entry(node, struct rt_object, list)); + device = (struct rt_device *)(rt_list_entry(node, struct rt_object, list)); rt_kprintf("%-8.*s %-8s \n", RT_NAME_MAX, device->parent.name, (device->type <= RT_Device_Class_Unknown)? device_type_str[device->type]:device_type_str[RT_Device_Class_Unknown]); @@ -401,7 +430,7 @@ int list_module(void) rt_kprintf("------------ --------\n"); for (node = list->next; node != list; node = node->next) { - module = (struct rt_module*)(rt_list_entry(node, struct rt_object, list)); + module = (struct rt_module *)(rt_list_entry(node, struct rt_object, list)); rt_kprintf("%-16.*s %-04d\n", RT_NAME_MAX, module->parent.name, module->nref); } @@ -410,23 +439,23 @@ int list_module(void) FINSH_FUNCTION_EXPORT(list_module, list module in system) -int list_mod_detail(const char* name) +int list_mod_detail(const char *name) { int i; struct rt_module *module; /* find module */ - if((module = rt_module_find(name)) != RT_NULL) + if ((module = rt_module_find(name)) != RT_NULL) { /* module has entry point */ - if(!(module->parent.flag & RT_MODULE_FLAG_WITHOUTENTRY)) + if (!(module->parent.flag & RT_MODULE_FLAG_WITHOUTENTRY)) { struct rt_thread *thread; struct rt_list_node *tlist; - rt_uint8_t* ptr; + rt_uint8_t *ptr; /* list main thread in module */ - if(module->module_thread != RT_NULL) + if (module->module_thread != RT_NULL) { rt_kprintf("main thread pri status sp stack size max used left tick error\n"); rt_kprintf("------------- ---- ------- ---------- ---------- ---------- ---------- ---\n"); @@ -450,52 +479,57 @@ int list_mod_detail(const char* name) /* list sub thread in module */ tlist = &module->module_object[RT_Object_Class_Thread].object_list; - if(!rt_list_isempty(tlist)) _list_thread(tlist); + if (!rt_list_isempty(tlist)) _list_thread(tlist); #ifdef RT_USING_SEMAPHORE /* list semaphored in module */ tlist = &module->module_object[RT_Object_Class_Semaphore].object_list; - if(!rt_list_isempty(tlist)) _list_sem(tlist); + if (!rt_list_isempty(tlist)) _list_sem(tlist); #endif #ifdef RT_USING_MUTEX /* list mutex in module */ tlist = &module->module_object[RT_Object_Class_Mutex].object_list; - if(!rt_list_isempty(tlist)) _list_mutex(tlist); + if (!rt_list_isempty(tlist)) _list_mutex(tlist); #endif #ifdef RT_USING_EVENT /* list event in module */ tlist = &module->module_object[RT_Object_Class_Event].object_list; - if(!rt_list_isempty(tlist)) _list_event(tlist); + if (!rt_list_isempty(tlist)) _list_event(tlist); #endif #ifdef RT_USING_MAILBOX /* list mailbox in module */ tlist = &module->module_object[RT_Object_Class_MailBox].object_list; - if(!rt_list_isempty(tlist)) _list_mailbox(tlist); + if (!rt_list_isempty(tlist)) _list_mailbox(tlist); #endif #ifdef RT_USING_MESSAGEQUEUE /* list message queue in module */ tlist = &module->module_object[RT_Object_Class_MessageQueue].object_list; - if(!rt_list_isempty(tlist)) _list_msgqueue(tlist); + if (!rt_list_isempty(tlist)) _list_msgqueue(tlist); +#endif +#ifdef RT_USING_MEMHEAP + /* list memory heap in module */ + tlist = &module->module_object[RT_Object_Class_MemHeap].object_list; + if (!rt_list_isempty(tlist)) _list_memheap(tlist); #endif #ifdef RT_USING_MEMPOOL /* list memory pool in module */ tlist = &module->module_object[RT_Object_Class_MemPool].object_list; - if(!rt_list_isempty(tlist)) _list_mempool(tlist); + if (!rt_list_isempty(tlist)) _list_mempool(tlist); #endif #ifdef RT_USING_DEVICE /* list device in module */ tlist = &module->module_object[RT_Object_Class_Device].object_list; - if(!rt_list_isempty(tlist)) _list_device(tlist); + if (!rt_list_isempty(tlist)) _list_device(tlist); #endif /* list timer in module */ tlist = &module->module_object[RT_Object_Class_Timer].object_list; - if(!rt_list_isempty(tlist)) _list_timer(tlist); + if (!rt_list_isempty(tlist)) _list_timer(tlist); } rt_kprintf("symbol address \n"); rt_kprintf("-------- ----------\n"); /* list module export symbols */ - for(i=0; insym; i++) + for (i=0; insym; i++) { rt_kprintf("%s 0x%x\n", module->symtab[i].name, module->symtab[i].addr); } @@ -508,12 +542,12 @@ FINSH_FUNCTION_EXPORT(list_mod_detail, list module objects in system) long list(void) { - struct finsh_syscall_item* syscall_item; - struct finsh_sysvar_item* sysvar_item; + struct finsh_syscall_item *syscall_item; + struct finsh_sysvar_item *sysvar_item; rt_kprintf("--Function List:\n"); { - struct finsh_syscall* index; + struct finsh_syscall *index; for (index = _syscall_table_begin; index < _syscall_table_end; index ++) { #ifdef FINSH_USING_DESCRIPTION @@ -534,7 +568,7 @@ long list(void) rt_kprintf("--Variable List:\n"); { - struct finsh_sysvar* index; + struct finsh_sysvar *index; for (index = _sysvar_table_begin; index < _sysvar_table_end; index ++) { #ifdef FINSH_USING_DESCRIPTION @@ -556,7 +590,7 @@ long list(void) } FINSH_FUNCTION_EXPORT(list, list all symbol in system) -static int str_is_prefix(const char* prefix, const char* str) +static int str_is_prefix(const char *prefix, const char *str) { while ((*prefix) && (*prefix == *str)) { @@ -564,15 +598,17 @@ static int str_is_prefix(const char* prefix, const char* str) str ++; } - if (*prefix == 0) return 0; + if (*prefix == 0) + return 0; + return -1; } -static int str_common(const char * str1, const char * str2) +static int str_common(const char *str1, const char *str2) { - const char * str = str1; + const char *str = str1; - while( *str !=0 && *str2 !=0 && (*str == *str2)) + while ((*str != 0) && (*str2 != 0) && (*str == *str2)) { str ++; str2 ++; @@ -581,13 +617,13 @@ static int str_common(const char * str1, const char * str2) return (str - str1); } -void list_prefix(char* prefix) +void list_prefix(char *prefix) { - struct finsh_syscall_item* syscall_item; - struct finsh_sysvar_item* sysvar_item; + struct finsh_syscall_item *syscall_item; + struct finsh_sysvar_item *sysvar_item; rt_uint16_t func_cnt, var_cnt; int length, min_length; - const char* name_ptr; + const char *name_ptr; func_cnt = 0; var_cnt = 0; diff --git a/src/memheap.c b/src/memheap.c index e711cddb86..196028c651 100644 --- a/src/memheap.c +++ b/src/memheap.c @@ -11,6 +11,7 @@ * Date Author Notes * 2012-04-10 Bernard first implementation */ + #include #ifdef RT_USING_MEMHEAP @@ -36,7 +37,7 @@ * * The length of Used Memory Block Tailer is 0, which is prevents block merging across list */ -rt_err_t rt_memheap_init(struct rt_memheap* memheap, const char* name, +rt_err_t rt_memheap_init(struct rt_memheap *memheap, const char *name, void *start_addr, rt_uint32_t size) { @@ -53,28 +54,28 @@ rt_err_t rt_memheap_init(struct rt_memheap* memheap, const char* name, /* initialize the free list header */ item = &(memheap->free_header); - item->magic = RT_MEMHEAP_MAGIC; - item->pool_ptr = memheap; - item->next = RT_NULL; - item->prev = RT_NULL; - item->next_free = item; - item->prev_free = item; + item->magic = RT_MEMHEAP_MAGIC; + item->pool_ptr = memheap; + item->next = RT_NULL; + item->prev = RT_NULL; + item->next_free = item; + item->prev_free = item; /* set the free list to free list header */ memheap->free_list = item; /* initialize the first big memory block */ - item = (struct rt_memheap_item*) start_addr; - item->magic = RT_MEMHEAP_MAGIC; - item->pool_ptr = memheap; - item->next = RT_NULL; - item->prev = RT_NULL; - item->next_free = item; - item->prev_free = item; - - item->next = (struct rt_memheap_item *) - ((rt_uint8_t*) item + memheap->available_size + RT_MEMHEAP_SIZE); - item->prev = item->next; + item = (struct rt_memheap_item *)start_addr; + item->magic = RT_MEMHEAP_MAGIC; + item->pool_ptr = memheap; + item->next = RT_NULL; + item->prev = RT_NULL; + item->next_free = item; + item->prev_free = item; + + item->next = (struct rt_memheap_item *) + ((rt_uint8_t *)item + memheap->available_size + RT_MEMHEAP_SIZE); + item->prev = item->next; /* block list header */ memheap->block_list = item; @@ -86,30 +87,30 @@ rt_err_t rt_memheap_init(struct rt_memheap* memheap, const char* name, memheap->free_list->next_free = item; /* move to the end of memory pool to build a small tailer block, which prevents block merging */ - item = item->next; + item = item->next; /* it's a used memory block */ - item->magic = RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED; - item->pool_ptr = memheap; - item->next = (struct rt_memheap_item *) start_addr; - item->prev = (struct rt_memheap_item *) start_addr; + item->magic = RT_MEMHEAP_MAGIC | RT_MEMHEAP_USED; + item->pool_ptr = memheap; + item->next = (struct rt_memheap_item *)start_addr; + item->prev = (struct rt_memheap_item *)start_addr; /* not in free list */ - item->next_free = item->prev_free = RT_NULL; + item->next_free = item->prev_free = RT_NULL; - RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("memory heap: start addr 0x%08x, size %d, free list header 0x%08x", - start_addr, size, &(memheap->free_header))); + RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("memory heap: start addr 0x%08x, size %d, free list header 0x%08x", + start_addr, size, &(memheap->free_header))); - return RT_EOK; + return RT_EOK; } -rt_err_t rt_memheap_detach(struct rt_memheap* heap) +rt_err_t rt_memheap_detach(struct rt_memheap *heap) { rt_object_detach(&(heap->parent)); - /* Return a successful completion. */ - return RT_EOK; + /* Return a successful completion. */ + return RT_EOK; } -void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) +void *rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) { rt_uint32_t free_size; struct rt_memheap_item *header_ptr; @@ -118,7 +119,8 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) /* align allocated size */ size = RT_ALIGN(size, RT_ALIGN_SIZE); - if (size < RT_MEMHEAP_MINIALLOC) size = RT_MEMHEAP_MINIALLOC; + if (size < RT_MEMHEAP_MINIALLOC) + size = RT_MEMHEAP_MINIALLOC; RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("allocate %d", size)); @@ -140,18 +142,18 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) } } - /* determine if the memory is available. */ + /* determine if the memory is available. */ if (free_size >= size) { - /* a block that satisfies the request has been found. */ + /* a block that satisfies the request has been found. */ - /* determine if the block needs to be split. */ + /* determine if the block needs to be split. */ if (free_size >= (size + RT_MEMHEAP_SIZE + RT_MEMHEAP_MINIALLOC)) { - struct rt_memheap_item* new_ptr; + struct rt_memheap_item *new_ptr; - /* split the block. */ - new_ptr = (struct rt_memheap_item*) (((rt_uint8_t*) header_ptr) + size + RT_MEMHEAP_SIZE); + /* split the block. */ + new_ptr = (struct rt_memheap_item *)(((rt_uint8_t *)header_ptr) + size + RT_MEMHEAP_SIZE); RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("split: h[0x%08x] nm[0x%08x] pm[0x%08x] to n[0x%08x]", header_ptr, header_ptr->next, header_ptr->prev, @@ -160,7 +162,7 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) /* mark the new block as a memory block and freed. */ new_ptr->magic = RT_MEMHEAP_MAGIC; - /* put the pool pointer into the new block. */ + /* put the pool pointer into the new block. */ new_ptr->pool_ptr = pool_ptr; /* break down the block list */ @@ -189,7 +191,7 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) else { /* decrement the entire free size from the available bytes count. */ - pool_ptr->available_size = pool_ptr->available_size - free_size; + pool_ptr->available_size = pool_ptr->available_size - free_size; /* remove header_ptr from free list */ RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("one block: h[0x%08x], nf 0x%08x, pf 0x%08x", header_ptr, @@ -202,12 +204,13 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) } /* Mark the allocated block as not available. */ - header_ptr->magic |= RT_MEMHEAP_USED; + header_ptr->magic |= RT_MEMHEAP_USED; /* Return a memory address to the caller. */ RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("am: m[0x%08x], h[0x%08x], size: %d", - (void*) ((rt_uint8_t*)header_ptr + RT_MEMHEAP_SIZE), header_ptr, size); - return (void*) ((rt_uint8_t*)header_ptr + RT_MEMHEAP_SIZE)); + (void *)((rt_uint8_t *)header_ptr + RT_MEMHEAP_SIZE), header_ptr, size); + + return (void *)((rt_uint8_t *)header_ptr + RT_MEMHEAP_SIZE)); } } @@ -217,15 +220,16 @@ void* rt_memheap_alloc(struct rt_memheap *pool_ptr, rt_uint32_t size) return RT_NULL; } -void rt_memheap_free(void* ptr) +void rt_memheap_free(void *ptr) { struct rt_memheap *pool_ptr; struct rt_memheap_item *header_ptr, *new_ptr; rt_uint32_t insert_header; /* set initial status as OK */ - insert_header = 1; new_ptr = RT_NULL; - header_ptr = (struct rt_memheap_item*)((rt_uint8_t*)ptr - RT_MEMHEAP_SIZE); + insert_header = 1; + new_ptr = RT_NULL; + header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE); RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("free memory: m[0x%08x], h[0x%08x]", ptr, header_ptr)); @@ -235,50 +239,51 @@ void rt_memheap_free(void* ptr) /* get pool ptr */ pool_ptr = header_ptr->pool_ptr; - /* Mark the memory as available. */ - header_ptr->magic &= ~RT_MEMHEAP_USED; + /* Mark the memory as available. */ + header_ptr->magic &= ~RT_MEMHEAP_USED; - /* Adjust the available number of bytes. */ - pool_ptr->available_size = pool_ptr->available_size + - ((rt_uint32_t)(header_ptr->next) - - (rt_uint32_t)header_ptr) - RT_MEMHEAP_SIZE; + /* Adjust the available number of bytes. */ + pool_ptr->available_size = pool_ptr->available_size + + ((rt_uint32_t)(header_ptr->next) - + (rt_uint32_t)header_ptr) - RT_MEMHEAP_SIZE; - /* Determine if the block can be merged with the previous neighbor. */ - if (!RT_MEMHEAP_IS_USED(header_ptr->prev)) - { - RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("merge: left node 0x%08x", header_ptr->prev)); + /* Determine if the block can be merged with the previous neighbor. */ + if (!RT_MEMHEAP_IS_USED(header_ptr->prev)) + { + RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("merge: left node 0x%08x", header_ptr->prev)); - /* adjust the available number of bytes. */ - pool_ptr->available_size = pool_ptr->available_size + RT_MEMHEAP_SIZE; + /* adjust the available number of bytes. */ + pool_ptr->available_size = pool_ptr->available_size + RT_MEMHEAP_SIZE; - /* yes, merge block with previous neighbor. */ - (header_ptr->prev)->next = header_ptr->next; - (header_ptr->next)->prev = header_ptr->prev; + /* yes, merge block with previous neighbor. */ + (header_ptr->prev)->next = header_ptr->next; + (header_ptr->next)->prev = header_ptr->prev; - /* move header pointer to previous. */ - header_ptr = header_ptr->prev; - insert_header = 0; /* don't insert header to free list */ - } + /* move header pointer to previous. */ + header_ptr = header_ptr->prev; + /* don't insert header to free list */ + insert_header = 0; + } - /* determine if the block can be merged with the next neighbor. */ - if (!RT_MEMHEAP_IS_USED(header_ptr->next)) - { - /* adjust the available number of bytes. */ - pool_ptr->available_size = pool_ptr->available_size + RT_MEMHEAP_SIZE; + /* determine if the block can be merged with the next neighbor. */ + if (!RT_MEMHEAP_IS_USED(header_ptr->next)) + { + /* adjust the available number of bytes. */ + pool_ptr->available_size = pool_ptr->available_size + RT_MEMHEAP_SIZE; - /* merge block with next neighbor. */ - new_ptr = header_ptr->next; + /* merge block with next neighbor. */ + new_ptr = header_ptr->next; - RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("merge: right node 0x%08x, nf 0x%08x, pf 0x%08x", - new_ptr, new_ptr->next_free, new_ptr->prev_free)); + RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("merge: right node 0x%08x, nf 0x%08x, pf 0x%08x", + new_ptr, new_ptr->next_free, new_ptr->prev_free)); - new_ptr->next->prev = header_ptr; - header_ptr->next = new_ptr->next; + new_ptr->next->prev = header_ptr; + header_ptr->next = new_ptr->next; /* remove new ptr from free list */ new_ptr->next_free->prev_free = new_ptr->prev_free; new_ptr->prev_free->next_free = new_ptr->next_free; - } + } if (insert_header) { -- GitLab