int mm_mallinfo(FAR struct mm_heap_s *heap, FAR struct mallinfo *info) { struct mm_allocnode_s *node; size_t mxordblk = 0; int ordblks = 0; /* Number of non-inuse chunks */ size_t uordblks = 0; /* Total allocated space */ size_t fordblks = 0; /* Total non-inuse space */ #if CONFIG_MM_REGIONS > 1 int region; #else # define region 0 #endif DEBUGASSERT(info); /* Visit each region */ #if CONFIG_MM_REGIONS > 1 for (region = 0; region < heap->mm_nregions; region++) #endif { /* Visit each node in the region * Retake the semaphore for each region to reduce latencies */ mm_takesemaphore(heap); for (node = heap->mm_heapstart[region]; node < heap->mm_heapend[region]; node = (struct mm_allocnode_s *)((char*)node + node->size)) { mvdbg("region=%d node=%p size=%p preceding=%p (%c)\n", region, node, node->size, (node->preceding & ~MM_ALLOC_BIT), (node->preceding & MM_ALLOC_BIT) ? 'A' : 'F'); /* Check if the node corresponds to an allocated memory chunk */ if ((node->preceding & MM_ALLOC_BIT) != 0) { uordblks += node->size; } else { ordblks++; fordblks += node->size; if (node->size > mxordblk) { mxordblk = node->size; } } } mm_givesemaphore(heap); mvdbg("region=%d node=%p heapend=%p\n", region, node, heap->mm_heapend[region]); DEBUGASSERT(node == heap->mm_heapend[region]); uordblks += SIZEOF_MM_ALLOCNODE; /* account for the tail node */ } #undef region DEBUGASSERT(uordblks + fordblks == heap->mm_heapsize); info->arena = heap->mm_heapsize; info->ordblks = ordblks; info->mxordblk = mxordblk; info->uordblks = uordblks; info->fordblks = fordblks; return OK; }
void free(FAR void *mem) { FAR struct mm_freenode_s *node; FAR struct mm_freenode_s *prev; FAR struct mm_freenode_s *next; mvdbg("Freeing %p\n", mem); /* Protect against attempts to free a NULL reference */ if (!mem) { return; } /* We need to hold the MM semaphore while we muck with the * nodelist. */ mm_takesemaphore(); /* Map the memory chunk into a free node */ node = (FAR struct mm_freenode_s *)((char*)mem - SIZEOF_MM_ALLOCNODE); node->preceding &= ~MM_ALLOC_BIT; /* Check if the following node is free and, if so, merge it */ next = (FAR struct mm_freenode_s *)((char*)node + node->size); if ((next->preceding & MM_ALLOC_BIT) == 0) { FAR struct mm_allocnode_s *andbeyond; /* Get the node following the next node (which will * become the new next node). We know that we can never * index past the tail chunk because it is always allocated. */ andbeyond = (FAR struct mm_allocnode_s*)((char*)next + next->size); /* Remove the next node. There must be a predecessor, * but there may not be a successor node. */ DEBUGASSERT(next->blink); next->blink->flink = next->flink; if (next->flink) { next->flink->blink = next->blink; } /* Then merge the two chunks */ node->size += next->size; andbeyond->preceding = node->size | (andbeyond->preceding & MM_ALLOC_BIT); next = (FAR struct mm_freenode_s *)andbeyond; } /* Check if the preceding node is also free and, if so, merge * it with this node */ prev = (FAR struct mm_freenode_s *)((char*)node - node->preceding); if ((prev->preceding & MM_ALLOC_BIT) == 0) { /* Remove the node. There must be a predecessor, but there may * not be a successor node. */ DEBUGASSERT(prev->blink); prev->blink->flink = prev->flink; if (prev->flink) { prev->flink->blink = prev->blink; } /* Then merge the two chunks */ prev->size += node->size; next->preceding = prev->size | (next->preceding & MM_ALLOC_BIT); node = prev; } /* Add the merged node to the nodelist */ mm_addfreechunk(node); mm_givesemaphore(); }
FAR void *mm_malloc(FAR struct mm_heap_s *heap, size_t size) { FAR struct mm_freenode_s *node; void *ret = NULL; int ndx; /* Handle bad sizes */ if (size <= 0) { return NULL; } /* Adjust the size to account for (1) the size of the allocated node and * (2) to make sure that it is an even multiple of our granule size. */ size = MM_ALIGN_UP(size + SIZEOF_MM_ALLOCNODE); /* We need to hold the MM semaphore while we muck with the nodelist. */ mm_takesemaphore(heap); /* Get the location in the node list to start the search. Special case * really big allocations */ if (size >= MM_MAX_CHUNK) { ndx = MM_NNODES-1; } else { /* Convert the request size into a nodelist index */ ndx = mm_size2ndx(size); } /* Search for a large enough chunk in the list of nodes. This list is * ordered by size, but will have occasional zero sized nodes as we visit * other mm_nodelist[] entries. */ for (node = heap->mm_nodelist[ndx].flink; node && node->size < size; node = node->flink); /* If we found a node with non-zero size, then this is one to use. Since * the list is ordered, we know that is must be best fitting chunk * available. */ if (node) { FAR struct mm_freenode_s *remainder; FAR struct mm_freenode_s *next; size_t remaining; /* Remove the node. There must be a predecessor, but there may not be * a successor node. */ DEBUGASSERT(node->blink); node->blink->flink = node->flink; if (node->flink) { node->flink->blink = node->blink; } /* Check if we have to split the free node into one of the allocated * size and another smaller freenode. In some cases, the remaining * bytes can be smaller (they may be SIZEOF_MM_ALLOCNODE). In that * case, we will just carry the few wasted bytes at the end of the * allocation. */ remaining = node->size - size; if (remaining >= SIZEOF_MM_FREENODE) { /* Get a pointer to the next node in physical memory */ next = (FAR struct mm_freenode_s*)(((char*)node) + node->size); /* Create the remainder node */ remainder = (FAR struct mm_freenode_s*)(((char*)node) + size); remainder->size = remaining; remainder->preceding = size; /* Adjust the size of the node under consideration */ node->size = size; /* Adjust the 'preceding' size of the (old) next node, preserving * the allocated flag. */ next->preceding = remaining | (next->preceding & MM_ALLOC_BIT); /* Add the remainder back into the nodelist */ mm_addfreechunk(heap, remainder); } /* Handle the case of an exact size match */ node->preceding |= MM_ALLOC_BIT; ret = (void*)((char*)node + SIZEOF_MM_ALLOCNODE); } mm_givesemaphore(heap); /* If CONFIG_DEBUG_MM is defined, then output the result of the allocation * to the SYSLOG. */ #ifdef CONFIG_DEBUG_MM if (!ret) { mdbg("Allocation failed, size %d\n", size); } else { mvdbg("Allocated %p, size %d\n", ret, size); } #endif return ret; }