diff options
author | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2012-07-14 23:31:12 +0000 |
---|---|---|
committer | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2012-07-14 23:31:12 +0000 |
commit | 57a3793bb9a43aebc7d2c0396b8c85483367d7dc (patch) | |
tree | 27bc6c7bda8a5889685481fab926aa45950651ea | |
parent | 3044a5f0f6197f3923c1229ef1974b17284f56df (diff) | |
download | px4-nuttx-57a3793bb9a43aebc7d2c0396b8c85483367d7dc.tar.gz px4-nuttx-57a3793bb9a43aebc7d2c0396b8c85483367d7dc.tar.bz2 px4-nuttx-57a3793bb9a43aebc7d2c0396b8c85483367d7dc.zip |
mm/ file clean-up
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4943 42af7a65-404d-4744-a932-0658087f49c3
-rw-r--r-- | nuttx/ChangeLog | 1 | ||||
-rw-r--r-- | nuttx/mm/Makefile | 3 | ||||
-rw-r--r-- | nuttx/mm/Makefile.test | 4 | ||||
-rw-r--r-- | nuttx/mm/mm_addfreechunk.c | 32 | ||||
-rw-r--r-- | nuttx/mm/mm_calloc.c | 29 | ||||
-rw-r--r-- | nuttx/mm/mm_environment.h | 40 | ||||
-rw-r--r-- | nuttx/mm/mm_free.c | 33 | ||||
-rw-r--r-- | nuttx/mm/mm_initialize.c | 28 | ||||
-rw-r--r-- | nuttx/mm/mm_internal.h | 71 | ||||
-rw-r--r-- | nuttx/mm/mm_mallinfo.c | 5 | ||||
-rw-r--r-- | nuttx/mm/mm_malloc.c | 93 | ||||
-rw-r--r-- | nuttx/mm/mm_memalign.c | 88 | ||||
-rw-r--r-- | nuttx/mm/mm_realloc.c | 264 | ||||
-rw-r--r-- | nuttx/mm/mm_sem.c | 46 | ||||
-rw-r--r-- | nuttx/mm/mm_shrinkchunk.c | 45 | ||||
-rw-r--r-- | nuttx/mm/mm_size2ndx.c | 26 | ||||
-rw-r--r-- | nuttx/mm/mm_test.c | 100 | ||||
-rw-r--r-- | nuttx/mm/mm_zalloc.c | 24 |
18 files changed, 493 insertions, 439 deletions
diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog index 54e2ad3a8..23d3084ae 100644 --- a/nuttx/ChangeLog +++ b/nuttx/ChangeLog @@ -2994,3 +2994,4 @@ * sched/: Stylistic clean-up of all files. Some of these files are pretty old and do not follow current NuttX coding standards in detail. * fs/: More stylistic file clean-up. + * mm/: More stylistic file clean-up. diff --git a/nuttx/mm/Makefile b/nuttx/mm/Makefile index d4ee105d5..7e6eb68a7 100644 --- a/nuttx/mm/Makefile +++ b/nuttx/mm/Makefile @@ -2,7 +2,7 @@ # mm/Makefile # # Copyright (C) 2007 Gregory Nutt. All rights reserved. -# Author: Gregory Nutt <spudmonkey@racsa.co.cr> +# Author: Gregory Nutt <gnutt@nuttx.org> # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions @@ -74,4 +74,3 @@ distclean: clean @rm -f Make.dep .depend -include Make.dep - diff --git a/nuttx/mm/Makefile.test b/nuttx/mm/Makefile.test index 26839de81..63cab910e 100644 --- a/nuttx/mm/Makefile.test +++ b/nuttx/mm/Makefile.test @@ -1,8 +1,8 @@ ############################################################################ -# Makefile.test +# mm/Makefile.test # # Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved. -# Author: Gregory Nutt <spudmonkey@racsa.co.cr> +# Author: Gregory Nutt <gnutt@nuttx.org> # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions diff --git a/nuttx/mm/mm_addfreechunk.c b/nuttx/mm/mm_addfreechunk.c index 0cf2fcf42..fdda3ed8d 100644 --- a/nuttx/mm/mm_addfreechunk.c +++ b/nuttx/mm/mm_addfreechunk.c @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_addfreechunk.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,35 +31,35 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Private Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Global Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ - * mm_addfreechunk +/**************************************************************************** + * Name: mm_addfreechunk * * Description: - * Add a free chunk to the node next - * It is assumed that the caller holds the mm semaphore + * Add a free chunk to the node next. It is assumed that the caller holds + * the mm semaphore * - ************************************************************************/ + ****************************************************************************/ void mm_addfreechunk(FAR struct mm_freenode_s *node) { diff --git a/nuttx/mm/mm_calloc.c b/nuttx/mm/mm_calloc.c index 47c75d42f..576081a16 100644 --- a/nuttx/mm/mm_calloc.c +++ b/nuttx/mm/mm_calloc.c @@ -1,8 +1,8 @@ -/************************************************************************ - * mm_calloc.c +/**************************************************************************** + * mm/mm_calloc.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,29 +31,30 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Global Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ - * calloc +/**************************************************************************** + * Name: calloc * * Descripton: - * calloc calculates the size and calls zalloc - ************************************************************************/ + * calloc calculates the size of the allocation and calls zalloc + * + ****************************************************************************/ FAR void *calloc(size_t n, size_t elem_size) { diff --git a/nuttx/mm/mm_environment.h b/nuttx/mm/mm_environment.h index ef4f14f7a..70e611116 100644 --- a/nuttx/mm/mm_environment.h +++ b/nuttx/mm/mm_environment.h @@ -2,7 +2,7 @@ * mm/mm_environment.h * * Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -40,33 +40,32 @@ * Included Files ****************************************************************************/ -/* The platform configuratioin file will not be included - * when the memory manager is built for the host-based - * test harness. +/* The platform configuratioin file will not be included when the memory + * manager is built for the host-based test harness. */ #ifndef MM_TEST -# include <nuttx/config.h> -# include <nuttx/compiler.h> -# include <sys/types.h> -# include <stdlib.h> -# include <string.h> -# include <debug.h> -# include <errno.h> -# include <assert.h> -# include <nuttx/mm.h> +# include <nuttx/config.h> +# include <nuttx/compiler.h> +# include <sys/types.h> +# include <stdlib.h> +# include <string.h> +# include <debug.h> +# include <errno.h> +# include <assert.h> +# include <nuttx/mm.h> #else -# include <sys/types.h> -# include <string.h> -# include <assert.h> +# include <sys/types.h> +# include <string.h> +# include <assert.h> #endif /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ -/* Special definitions used when the memory mnager is built - * for the host-based test harness. +/* Special definitions used when the memory mnager is built for the host- + * based test harness. */ #ifdef MM_TEST @@ -86,9 +85,8 @@ extern void mm_addregion(FAR void *heapstart, size_t heapsize); # define mm_errno errno -/* When built for the test harness, we change the names of the - * exported functions so that they do not collide with the - * host libc names. +/* When built for the test harness, we change the names of the exported + * functions so that they do not collide with the host libc names. */ # define malloc mm_malloc diff --git a/nuttx/mm/mm_free.c b/nuttx/mm/mm_free.c index 20135484b..b34b8a459 100644 --- a/nuttx/mm/mm_free.c +++ b/nuttx/mm/mm_free.c @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_free.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,36 +31,37 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include <assert.h> + #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Private Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Public Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ - * free +/**************************************************************************** + * Name: free * * Description: - * Returns a chunk of memory into the list of free nodes, - * merging with adjacent free chunks if possible. + * Returns a chunk of memory into the list of free nodes, merging with + * adjacent free chunks if possible. * - ************************************************************************/ + ****************************************************************************/ void free(FAR void *mem) { diff --git a/nuttx/mm/mm_initialize.c b/nuttx/mm/mm_initialize.c index 351948c2f..3a21d1759 100644 --- a/nuttx/mm/mm_initialize.c +++ b/nuttx/mm/mm_initialize.c @@ -2,7 +2,7 @@ * mm/mm_initialize.c * * Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -61,9 +61,9 @@ FAR struct mm_allocnode_s *g_heapend[CONFIG_MM_REGIONS]; int g_nregions; #endif -/* All free nodes are maintained in a doubly linked list. This - * array provides some hooks into the list at various points to - * speed searches for free nodes. +/* All free nodes are maintained in a doubly linked list. This array + * provides some hooks into the list at various points to speed searches for + * free nodes. */ FAR struct mm_freenode_s g_nodelist[MM_NNODES]; @@ -73,11 +73,10 @@ FAR struct mm_freenode_s g_nodelist[MM_NNODES]; ****************************************************************************/ /**************************************************************************** - * Function: mm_initialize + * Name: mm_initialize * * Description: - * This is an internal OS function called only at power-up - * boot time. + * This is an internal OS function called only at power-up boot time. * * Parameters: * heapstart - Start of the initial heap region @@ -135,11 +134,10 @@ void mm_initialize(FAR void *heapstart, size_t heapsize) } /**************************************************************************** - * Function: mm_addregion + * Name: mm_addregion * * Description: - * This function gives a region of contiguous memory to - * the memory manager + * This function gives a region of contiguous memory to the memory manager * * Parameters: * heapstart - Start of the heap region @@ -163,17 +161,17 @@ void mm_addregion(FAR void *heapstart, size_t heapsize) # define IDX 0 #endif - /* If the MCU handles wide addresses but the memory manager - * is configured for a small heap, then verify that the caller - * not doing something crazy. + /* If the MCU handles wide addresses but the memory manager is configured + * for a small heap, then verify that the caller is not doing something + * crazy. */ #if defined(CONFIG_MM_SMALL) && !defined(CONFIG_SMALL_MEMORY) DEBUGASSERT(heapsize <= MMSIZE_MAX+1); #endif - /* Adjust the provide heap start and size so that they are - * both aligned with the MM_MIN_CHUNK size. + /* Adjust the provide heap start and size so that they are both aligned + * with the MM_MIN_CHUNK size. */ heapbase = MM_ALIGN_UP((uintptr_t)heapstart); diff --git a/nuttx/mm/mm_internal.h b/nuttx/mm/mm_internal.h index 4fb2d1778..21cf253d7 100644 --- a/nuttx/mm/mm_internal.h +++ b/nuttx/mm/mm_internal.h @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_internal.h * * Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,19 +31,19 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ #ifndef __MM_MM_INTERNAL_H #define __MM_MM_INTERNAL_H -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ -/* Configuration ********************************************************/ + ****************************************************************************/ +/* Configuration ************************************************************/ /* If the MCU has a small (16-bit) address capability, then we will use * a smaller chunk header that contains 16-bit size/offset information. * We will also use the smaller header on MCUs with wider addresses if @@ -60,7 +60,7 @@ # define CONFIG_MM_SMALL 1 #endif -/* Chunk Header Definitions *********************************************/ +/* Chunk Header Definitions *************************************************/ /* These definitions define the characteristics of allocator * * MM_MIN_SHIFT is used to define MM_MIN_CHUNK. @@ -79,11 +79,11 @@ */ #ifdef CONFIG_MM_SMALL -# define MM_MIN_SHIFT 4 /* 16 bytes */ -# define MM_MAX_SHIFT 15 /* 32 Kb */ +# define MM_MIN_SHIFT 4 /* 16 bytes */ +# define MM_MAX_SHIFT 15 /* 32 Kb */ #else -# define MM_MIN_SHIFT 4 /* 16 bytes */ -# define MM_MAX_SHIFT 22 /* 4 Mb */ +# define MM_MIN_SHIFT 4 /* 16 bytes */ +# define MM_MAX_SHIFT 22 /* 4 Mb */ #endif /* All other definitions derive from these two */ @@ -109,9 +109,9 @@ #define MM_IS_ALLOCATED(n) \ ((int)((struct mm_allocnode_s*)(n)->preceding) < 0)) -/************************************************************************ +/**************************************************************************** * Public Types - ************************************************************************/ + ****************************************************************************/ /* Determine the size of the chunk size/offset type */ @@ -186,9 +186,9 @@ struct mallinfo }; #endif -/************************************************************************ +/**************************************************************************** * Global Variables - ************************************************************************/ + ****************************************************************************/ /* This is the size of the heap provided to mm */ @@ -212,35 +212,32 @@ extern int g_nregions; extern FAR struct mm_freenode_s g_nodelist[MM_NNODES]; -/************************************************************************ +/**************************************************************************** * Public Function Prototypes - ************************************************************************/ - -/* Normally defined in malloc.h */ + ****************************************************************************/ #ifdef MM_TEST - extern FAR void *mm_malloc(size_t); - extern void mm_free(void*); - extern FAR void *mm_realloc(void*, size_t); - extern FAR void *mm_memalign(size_t, size_t); - extern FAR void *mm_zalloc(size_t); - extern FAR void *mm_calloc(size_t, size_t); +FAR void *mm_malloc(size_t); +void mm_free(void*); +FAR void *mm_realloc(void*, size_t); +FAR void *mm_memalign(size_t, size_t); +FAR void *mm_zalloc(size_t); +FAR void *mm_calloc(size_t, size_t); #ifdef CONFIG_CAN_PASS_STRUCTS - extern struct mallinfo mallinfo(void); +struct mallinfo mallinfo(void); #else - extern int mallinfo(struct mallinfo *info); +int mallinfo(struct mallinfo *info); #endif #endif -extern void mm_shrinkchunk(FAR struct mm_allocnode_s *node, - size_t size); -extern void mm_addfreechunk(FAR struct mm_freenode_s *node); -extern int mm_size2ndx(size_t size); -extern void mm_seminitialize(void); -extern void mm_takesemaphore(void); -extern void mm_givesemaphore(void); +void mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size); +void mm_addfreechunk(FAR struct mm_freenode_s *node); +int mm_size2ndx(size_t size); +void mm_seminitialize(void); +void mm_takesemaphore(void); +void mm_givesemaphore(void); #ifdef MM_TEST - extern int mm_getsemaphore(void); +int mm_getsemaphore(void); #endif #endif /* __MM_MM_INTERNAL_H */ diff --git a/nuttx/mm/mm_mallinfo.c b/nuttx/mm/mm_mallinfo.c index a7f6d9df6..b725535d1 100644 --- a/nuttx/mm/mm_mallinfo.c +++ b/nuttx/mm/mm_mallinfo.c @@ -2,7 +2,7 @@ * mm/mm_mallinfo.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -38,6 +38,7 @@ ****************************************************************************/ #include <assert.h> + #include "mm_environment.h" #include "mm_internal.h" @@ -58,7 +59,7 @@ ****************************************************************************/ /**************************************************************************** - * mallinfo + * Name: mallinfo * * Description: * mallinfo returns a copy of updated current mallinfo. diff --git a/nuttx/mm/mm_malloc.c b/nuttx/mm/mm_malloc.c index dbcba33a8..8a21e7324 100644 --- a/nuttx/mm/mm_malloc.c +++ b/nuttx/mm/mm_malloc.c @@ -1,8 +1,8 @@ -/************************************************************ +/**************************************************************************** * mm/mm_malloc.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,59 +31,59 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ -/* Special definitions when we operate in the normal vs. the - * host-pc test environement. +/* Special definitions when we operate in the normal vs. the host-pc test + * environement. */ #include <assert.h> + #include "mm_environment.h" #include "mm_internal.h" -/************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************/ + ****************************************************************************/ #ifndef NULL # define NULL ((void*)0) #endif -/************************************************************ +/**************************************************************************** * Type Definitions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Data - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Public Data - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Private Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Public Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ - * malloc +/**************************************************************************** + * Name: malloc * * Description: - * Find the smallest chunk that satisfies the request. - * Take the memory from that chunk, save the remaining, - * smaller chunk (if any). + * Find the smallest chunk that satisfies the request. Take the memory from + * that chunk, save the remaining, smaller chunk (if any). * * 8-byte alignment of the allocated data is assured. * - ************************************************************/ + ****************************************************************************/ FAR void *malloc(size_t size) { @@ -98,21 +98,18 @@ FAR void *malloc(size_t size) 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. + /* 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. - */ + /* We need to hold the MM semaphore while we muck with the nodelist. */ mm_takesemaphore(); - /* Get the location in the node list to start the search. - * Special case really big alloctions + /* Get the location in the node list to start the search. Special case + * really big allocations */ if (size >= MM_MAX_CHUNK) @@ -126,18 +123,18 @@ FAR void *malloc(size_t size) 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 g_nodelist[] entries. + /* 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 g_nodelist[] entries. */ for (node = g_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 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) @@ -146,8 +143,8 @@ FAR void *malloc(size_t size) 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. + /* Remove the node. There must be a predecessor, but there may not be + * a successor node. */ DEBUGASSERT(node->blink); @@ -157,11 +154,11 @@ FAR void *malloc(size_t size) 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. + /* 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; @@ -181,8 +178,8 @@ FAR void *malloc(size_t size) node->size = size; - /* Adjust the 'preceding' size of the (old) next node, - * preserving the allocated flag. + /* Adjust the 'preceding' size of the (old) next node, preserving + * the allocated flag. */ next->preceding = remaining | (next->preceding & MM_ALLOC_BIT); diff --git a/nuttx/mm/mm_memalign.c b/nuttx/mm/mm_memalign.c index d40f72348..87547c96b 100644 --- a/nuttx/mm/mm_memalign.c +++ b/nuttx/mm/mm_memalign.c @@ -1,8 +1,8 @@ -/************************************************************ +/**************************************************************************** * mm/mm_memalign.c * * Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,37 +31,37 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include <assert.h> + #include "mm_environment.h" #include "mm_internal.h" -/************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ - * memalign +/**************************************************************************** + * Name: memalign * * Description: - * memalign requests more than enough space from malloc, - * finds a region within that chunk that meets the alignment - * request and then frees any leading or trailing space. + * memalign requests more than enough space from malloc, finds a region + * within that chunk that meets the alignment request and then frees any + * leading or trailing space. * - * The alignment argument must be a power of two (not - * checked). 8-byte alignment is guaranteed by normal - * malloc calls. + * The alignment argument must be a power of two (not checked). 8-byte + * alignment is guaranteed by normal malloc calls. * - ************************************************************/ + ****************************************************************************/ FAR void *memalign(size_t alignment, size_t size) { @@ -71,9 +71,8 @@ FAR void *memalign(size_t alignment, size_t size) size_t mask = (size_t)(alignment - 1); size_t allocsize; - /* If this requested alignement less than or equal to the - * natural alignment of malloc, then just let malloc do the - * work. + /* If this requested alignement less than or equal to the natural alignment + * of malloc, then just let malloc do the work. */ if (alignment <= MM_MIN_CHUNK) @@ -81,17 +80,16 @@ FAR void *memalign(size_t alignment, size_t size) return malloc(size); } - /* Adjust the size to account for (1) the size of the allocated - * node, (2) to make sure that it is an even multiple of - * our granule size, and to include the alignment amount. + /* Adjust the size to account for (1) the size of the allocated node, (2) + * to make sure that it is an even multiple of our granule size, and to + * include the alignment amount. * - * Notice that we increase the allocation size by twice the - * the requested alignment. We do this so that there will - * be at least two valid alignment points within the allocated - * memory. + * Notice that we increase the allocation size by twice the requested + * alignment. We do this so that there will be at least two valid + * alignment points within the allocated memory. * - * NOTE: These are sizes given to malloc and not chunk sizes. - * The do not include SIZEOF_MM_ALLOCNODE. + * NOTE: These are sizes given to malloc and not chunk sizes. They do + * not include SIZEOF_MM_ALLOCNODE. */ size = MM_ALIGN_UP(size); /* Make multiples of our granule size */ @@ -105,14 +103,14 @@ FAR void *memalign(size_t alignment, size_t size) return NULL; } - /* We need to hold the MM semaphore while we muck with the - * chunks and nodelist. + /* We need to hold the MM semaphore while we muck with the chunks and + * nodelist. */ mm_takesemaphore(); - /* Get the node associated with the allocation and the next - * node after the allocation. + /* Get the node associated with the allocation and the next node after + * the allocation. */ node = (FAR struct mm_allocnode_s*)(rawchunk - SIZEOF_MM_ALLOCNODE); @@ -147,12 +145,12 @@ FAR void *memalign(size_t alignment, size_t size) precedingsize = (size_t)newnode - (size_t)node; - /* If we were unlucky, then the alignedchunk can lie in such - * a position that precedingsize < SIZEOF_NODE_FREENODE. We - * can't let that happen because we are going to cast 'node' to - * struct mm_freenode_s below. This is why we allocated memory - * large enough to support two alignment points. In this case, - * we will simply use the second alignment point. + /* If we were unlucky, then the alignedchunk can lie in such a position + * that precedingsize < SIZEOF_NODE_FREENODE. We can't let that happen + * because we are going to cast 'node' to struct mm_freenode_s below. + * This is why we allocated memory large enough to support two + * alignment points. In this case, we will simply use the second + * alignment point. */ if (precedingsize < SIZEOF_MM_FREENODE) @@ -176,8 +174,8 @@ FAR void *memalign(size_t alignment, size_t size) next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT); - /* Convert the newnode chunk size back into malloc-compatible - * size by subtracting the header size SIZEOF_MM_ALLOCNODE. + /* Convert the newnode chunk size back into malloc-compatible size by + * subtracting the header size SIZEOF_MM_ALLOCNODE. */ allocsize = newnode->size - SIZEOF_MM_ALLOCNODE; @@ -197,9 +195,9 @@ FAR void *memalign(size_t alignment, size_t size) if (allocsize > size) { - /* Shrink the chunk by that much -- remember, mm_shrinkchunk - * wants internal chunk sizes that include SIZEOF_MM_ALLOCNODE, - * and not the malloc-compatible sizes that we have. + /* Shrink the chunk by that much -- remember, mm_shrinkchunk wants + * internal chunk sizes that include SIZEOF_MM_ALLOCNODE, and not the + * malloc-compatible sizes that we have. */ mm_shrinkchunk(node, size + SIZEOF_MM_ALLOCNODE); diff --git a/nuttx/mm/mm_realloc.c b/nuttx/mm/mm_realloc.c index d97bf53a5..b44938995 100644 --- a/nuttx/mm/mm_realloc.c +++ b/nuttx/mm/mm_realloc.c @@ -1,8 +1,8 @@ -/************************************************************ +/**************************************************************************** * mm/mm_realloc.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,47 +31,47 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Included Files - ************************************************************/ + ****************************************************************************/ #include <string.h> #include "mm_environment.h" -#include <stdio.h> /* For NULL */ +#include <stdio.h> #include "mm_internal.h" -/************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************/ + ****************************************************************************/ -/************************************************************ +/**************************************************************************** * Global Functions - ************************************************************/ + ****************************************************************************/ -/************************************************************ - * realloc +/**************************************************************************** + * Name: realloc * * Description: * If the reallocation is for less space, then: + * * (1) the current allocation is reduced in size - * (2) the remainder at the end of the allocation is - * returned to the free list. + * (2) the remainder at the end of the allocation is returned to the + * free list. + * + * If the request is for more space and the current allocation can be + * extended, it will be extended by: * - * If the request is for more space and the current - * allocation can be extended, it will be extended by: - * (1) Taking the additional space from the following - * free chunk, or - * (2) Taking the additional space from the preceding - * free chunk. + * (1) Taking the additional space from the following free chunk, or + * (2) Taking the additional space from the preceding free chunk. * (3) Or both * - * If the request is for more space but the current chunk - * cannot be extended, then malloc a new buffer, copy the - * data into the new buffer, and free the old buffer. + * If the request is for more space but the current chunk cannot be + * extended, then malloc a new buffer, copy the data into the new buffer, + * and free the old buffer. * - ************************************************************/ + ****************************************************************************/ FAR void *realloc(FAR void *oldmem, size_t size) { @@ -98,9 +98,8 @@ FAR void *realloc(FAR void *oldmem, size_t size) 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. + /* 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); @@ -109,9 +108,7 @@ FAR void *realloc(FAR void *oldmem, size_t size) oldnode = (FAR struct mm_allocnode_s *)((FAR char*)oldmem - SIZEOF_MM_ALLOCNODE); - /* We need to hold the MM semaphore while we muck with the - * nodelist. - */ + /* We need to hold the MM semaphore while we muck with the nodelist. */ mm_takesemaphore(); @@ -120,13 +117,14 @@ FAR void *realloc(FAR void *oldmem, size_t size) oldsize = oldnode->size; if (size <= oldsize) { - /* Handle the special case where we are not going to change the - * size of the allocation. + /* Handle the special case where we are not going to change the size + * of the allocation. */ + if (size < oldsize) { mm_shrinkchunk(oldnode, size); - } + } /* Then return the original address */ @@ -135,8 +133,8 @@ FAR void *realloc(FAR void *oldmem, size_t size) } /* This is a request to increase the size of the allocation, Get the - * available sizes before and after the oldnode so that we can make - * the best decision + * available sizes before and after the oldnode so that we can make the + * best decision */ next = (FAR struct mm_freenode_s *)((FAR char*)oldnode + oldnode->size); @@ -165,52 +163,52 @@ FAR void *realloc(FAR void *oldmem, size_t size) if (prevsize > 0 && (nextsize >= prevsize || nextsize <= 0)) { - /* Can we get everything we need from the previous chunk? */ - - if (needed > prevsize) - { - /* No, take the whole previous chunk and get the - * rest that we need from the next chunk. - */ - - takeprev = prevsize; - takenext = needed - prevsize; - } - else - { - /* Yes, take what we need from the previous chunk */ - - takeprev = needed; - takenext = 0; - } - - needed = 0; - } - - /* Check if we can extend into the next chunk and if we still - * need more memory. + /* Can we get everything we need from the previous chunk? */ + + if (needed > prevsize) + { + /* No, take the whole previous chunk and get the + * rest that we need from the next chunk. + */ + + takeprev = prevsize; + takenext = needed - prevsize; + } + else + { + /* Yes, take what we need from the previous chunk */ + + takeprev = needed; + takenext = 0; + } + + needed = 0; + } + + /* Check if we can extend into the next chunk and if we still need + * more memory. */ if (nextsize > 0 && needed) { - /* Can we get everything we need from the next chunk? */ - - if (needed > nextsize) - { - /* No, take the whole next chunk and get the - * rest that we need from the previous chunk. - */ - - takeprev = needed - nextsize; - takenext = nextsize; - } - else - { - /* Yes, take what we need from the previous chunk */ - - takeprev = 0; - takenext = needed; - } + /* Can we get everything we need from the next chunk? */ + + if (needed > nextsize) + { + /* No, take the whole next chunk and get the rest that we + * need from the previous chunk. + */ + + takeprev = needed - nextsize; + takenext = nextsize; + } + else + { + /* Yes, take what we need from the previous chunk */ + + takeprev = 0; + takenext = needed; + } } /* Extend into the previous free chunk */ @@ -218,55 +216,55 @@ FAR void *realloc(FAR void *oldmem, size_t size) newmem = oldmem; if (takeprev) { - FAR struct mm_allocnode_s *newnode; + FAR struct mm_allocnode_s *newnode; - /* Remove the previous node. There must be a predecessor, - * but there may not be a successor node. - */ + /* Remove the previous 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; - } + DEBUGASSERT(prev->blink); + prev->blink->flink = prev->flink; + if (prev->flink) + { + prev->flink->blink = prev->blink; + } - /* Extend the node into the previous free chunk */ + /* Extend the node into the previous free chunk */ - newnode = (FAR struct mm_allocnode_s *)((FAR char*)oldnode - takeprev); + newnode = (FAR struct mm_allocnode_s *)((FAR char*)oldnode - takeprev); - /* Did we consume the entire preceding chunk? */ + /* Did we consume the entire preceding chunk? */ - if (takeprev < prevsize) - { - /* No.. just take what we need from the previous chunk - * and put it back into the free list - */ + if (takeprev < prevsize) + { + /* No.. just take what we need from the previous chunk and put + * it back into the free list + */ - prev->size -= takeprev; - newnode->size = oldsize + takeprev; - newnode->preceding = prev->size | MM_ALLOC_BIT; - next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT); + prev->size -= takeprev; + newnode->size = oldsize + takeprev; + newnode->preceding = prev->size | MM_ALLOC_BIT; + next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT); - /* Return the previous free node to the nodelist (with the new size) */ + /* Return the previous free node to the nodelist (with the new size) */ - mm_addfreechunk(prev); + mm_addfreechunk(prev); - /* Now we want to return newnode */ + /* Now we want to return newnode */ - oldnode = newnode; - } - else - { - /* Yes.. update its size (newnode->preceding is already set) */ + oldnode = newnode; + } + else + { + /* Yes.. update its size (newnode->preceding is already set) */ - newnode->size += oldsize; - newnode->preceding |= MM_ALLOC_BIT; - next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT); - } + newnode->size += oldsize; + newnode->preceding |= MM_ALLOC_BIT; + next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT); + } - oldnode = newnode; - oldsize = newnode->size; + oldnode = newnode; + oldsize = newnode->size; /* Now we have to move the user contents 'down' in memory. memcpy should * should be save for this. @@ -283,12 +281,14 @@ FAR void *realloc(FAR void *oldmem, size_t size) FAR struct mm_freenode_s *newnode; FAR struct mm_allocnode_s *andbeyond; - /* Get the chunk following the next node (which could be the tail chunk) */ + /* Get the chunk following the next node (which could be the tail + * chunk) + */ andbeyond = (FAR struct mm_allocnode_s*)((char*)next + nextsize); - /* Remove the next node. There must be a predecessor, - * but there may not be a successor node. + /* Remove the next node. There must be a predecessor, but there + * may not be a successor node. */ DEBUGASSERT(next->blink); @@ -307,8 +307,8 @@ FAR void *realloc(FAR void *oldmem, size_t size) if (takenext < nextsize) { - /* No, take what we need from the next chunk and return it - * to the free nodelist. + /* No, take what we need from the next chunk and return it to + * the free nodelist. */ newnode->size = nextsize - takenext; @@ -335,20 +335,18 @@ FAR void *realloc(FAR void *oldmem, size_t size) else { - /* Allocate a new block. On failure, realloc must return NULL but - * leave the original memory in place. - */ - - mm_givesemaphore(); - newmem = (FAR void*)malloc(size); - if (newmem) - { - memcpy(newmem, oldmem, oldsize); - free(oldmem); - } - - return newmem; - } + /* Allocate a new block. On failure, realloc must return NULL but + * leave the original memory in place. + */ -} + mm_givesemaphore(); + newmem = (FAR void*)malloc(size); + if (newmem) + { + memcpy(newmem, oldmem, oldsize); + free(oldmem); + } + return newmem; + } +} diff --git a/nuttx/mm/mm_sem.c b/nuttx/mm/mm_sem.c index a2d9d5cd1..19fff780b 100644 --- a/nuttx/mm/mm_sem.c +++ b/nuttx/mm/mm_sem.c @@ -38,10 +38,12 @@ ****************************************************************************/ #include "mm_environment.h" + #include <unistd.h> #include <semaphore.h> #include <errno.h> #include <assert.h> + #include "mm_internal.h" /**************************************************************************** @@ -73,9 +75,9 @@ /* Mutually exclusive access to this data set is enforced with * the following (un-named) semaphore. */ -static sem_t g_mm_semaphore; -static pid_t g_holder; -static int g_counts_held; +static sem_t g_mm_semaphore; +static pid_t g_holder; +static int g_counts_held; /**************************************************************************** * Public Functions @@ -91,8 +93,8 @@ static int g_counts_held; void mm_seminitialize(void) { - /* Initialize the MM semaphore to one (to support one-at- - * a-time access to private data sets. + /* Initialize the MM semaphore to one (to support one-at-a-time access to + * private data sets. */ (void)sem_init(&g_mm_semaphore, 0, 1); @@ -105,11 +107,10 @@ void mm_seminitialize(void) * Name: mm_trysemaphore * * Description: - * Try to take the MM mutex. This is called only from the - * OS in certain conditions when it is necessary to have - * exclusive access to the memory manager but it is - * impossible to wait on a semaphore (e.g., the idle process - * when it performs its background memory cleanup). + * Try to take the MM mutex. This is called only from the OS in certain + * conditions when it is necessary to have exclusive access to the memory + * manager but it is impossible to wait on a semaphore (e.g., the idle + * process when it performs its background memory cleanup). * ****************************************************************************/ @@ -149,8 +150,8 @@ int mm_trysemaphore(void) * Name: mm_takesemaphore * * Description: - * Take the MM mutex. This is the normal action before all - * memory management actions. + * Take the MM mutex. This is the normal action before all memory + * management actions. * ****************************************************************************/ @@ -172,13 +173,13 @@ void mm_takesemaphore(void) msemdbg("PID=%d taking\n", my_pid); while (sem_wait(&g_mm_semaphore) != 0) - { - /* The only case that an error should occur here is if - * the wait was awakened by a signal. - */ + { + /* The only case that an error should occur here is if + * the wait was awakened by a signal. + */ - ASSERT(mm_errno == EINTR); - } + ASSERT(mm_errno == EINTR); + } /* We have it. Claim the stake and return */ @@ -186,8 +187,7 @@ void mm_takesemaphore(void) g_counts_held = 1; } - msemdbg("Holder=%d count=%d\n", - g_holder, g_counts_held); + msemdbg("Holder=%d count=%d\n", g_holder, g_counts_held); } /**************************************************************************** @@ -215,8 +215,7 @@ void mm_givesemaphore(void) /* Yes, just release one count and return */ g_counts_held--; - msemdbg("Holder=%d count=%d\n", - g_holder, g_counts_held); + msemdbg("Holder=%d count=%d\n", g_holder, g_counts_held); } else { @@ -233,8 +232,7 @@ void mm_givesemaphore(void) * Name: mm_getsemaphore * * Description: - * Return the current value of the MM semaphore (for test - * purposes only) + * Return the current value of the MM semaphore (for test purposes only) * ****************************************************************************/ diff --git a/nuttx/mm/mm_shrinkchunk.c b/nuttx/mm/mm_shrinkchunk.c index 9361a4f8b..e538e43ed 100644 --- a/nuttx/mm/mm_shrinkchunk.c +++ b/nuttx/mm/mm_shrinkchunk.c @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_shrinkchunk.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,38 +31,37 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Global Functions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ - * mm_shrinkchunk +/**************************************************************************** + * Name: mm_shrinkchunk * * Description: - * Reduce the size of the chunk specified by the node - * structure to the specified size. this internal logic - * is used both from memalign to dispose of any trailing - * memory in the aligned allocation and also by realloc - * when there is a request to reduce the size of an allocation. + * Reduce the size of the chunk specified by the node structure to the + * specified size. this internal logic is used both from memalign to + * dispose of any trailing memory in the aligned allocation and also by + * realloc when there is a request to reduce the size of an allocation. * * NOTES: * (1) size is the whole chunk size (payload and header) * (2) the caller must hold the MM semaphore. * - ************************************************************************/ + ****************************************************************************/ void mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size) { @@ -94,8 +93,8 @@ void mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size) next->flink->blink = next->blink; } - /* Create a new chunk that will hold both the next chunk - * and the tailing memory from the aligned chunk. + /* Create a new chunk that will hold both the next chunk and the + * tailing memory from the aligned chunk. */ newnode = (FAR struct mm_freenode_s*)((char*)node + size); @@ -112,16 +111,16 @@ void mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size) mm_addfreechunk(newnode); } - /* The next chunk is allocated. Try to free the end portion - * at the end chunk to be shrunk. + /* The next chunk is allocated. Try to free the end portion at the end + * chunk to be shrunk. */ else if (node->size >= size + SIZEOF_MM_FREENODE) { FAR struct mm_freenode_s *newnode; - /* Create a new chunk that will hold both the next chunk - * and the tailing memory from the aligned chunk. + /* Create a new chunk that will hold both the next chunk and the + * tailing memory from the aligned chunk. */ newnode = (FAR struct mm_freenode_s*)((char*)node + size); diff --git a/nuttx/mm/mm_size2ndx.c b/nuttx/mm/mm_size2ndx.c index 492dd8ba0..b2a0a8e14 100644 --- a/nuttx/mm/mm_size2ndx.c +++ b/nuttx/mm/mm_size2ndx.c @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_size2ndx.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,24 +31,30 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Public Functions - ************************************************************************/ + ****************************************************************************/ -/* Convert the size to a nodelist index */ +/**************************************************************************** + * Name: mm_size2ndx + * + * Description: + * Convert the size to a nodelist index. + * + ****************************************************************************/ int mm_size2ndx(size_t size) { diff --git a/nuttx/mm/mm_test.c b/nuttx/mm/mm_test.c index e7a44dec7..b25a24095 100644 --- a/nuttx/mm/mm_test.c +++ b/nuttx/mm/mm_test.c @@ -2,7 +2,7 @@ * mm/mm_test.c * * Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -33,10 +33,18 @@ * ************************************************************************/ +/************************************************************************ + * Included Files + ************************************************************************/ + #include <stdio.h> #include <stdlib.h> #include <string.h> +/************************************************************************ + * Pre-processor Definitions + ************************************************************************/ + /* Fake NuttX dependencies */ #define FAR @@ -56,6 +64,10 @@ /* #define STOP_ON_ERRORS do{}while(0) */ #define STOP_ON_ERRORS exit(1) +/************************************************************************ + * Private Data + ************************************************************************/ + /* Test allocations */ static const int alloc_sizes[NTEST_ALLOCS] = @@ -65,6 +77,7 @@ static const int alloc_sizes[NTEST_ALLOCS] = 4732, 28, 901, 480, 5011, 1536, 2011, 81647, 646, 1646, 69179, 194, 2590, 7, 969, 70 }; + static const int realloc_sizes[NTEST_ALLOCS] = { 18, 3088, 963, 123, 511, 11666, 3723, 42, @@ -72,6 +85,7 @@ static const int realloc_sizes[NTEST_ALLOCS] = 8663, 91255, 28, 4346, 9172, 168, 229, 4734, 59139, 221, 7830, 30421, 1666, 4, 812, 416 }; + static const int random1[NTEST_ALLOCS] = { 20, 11, 3, 31, 9, 29, 7, 17, @@ -79,6 +93,7 @@ static const int random1[NTEST_ALLOCS] = 27, 19, 22, 28, 8, 30, 12, 15, 4, 1, 24, 6, 16, 13, 5, 23 }; + static const int random2[NTEST_ALLOCS] = { 2, 19, 12, 23, 30, 11, 27, 4, @@ -86,6 +101,7 @@ static const int random2[NTEST_ALLOCS] = 10, 17, 25, 31, 8, 29, 3, 26, 9, 18, 22, 13, 1, 21, 14, 6 }; + static const int random3[NTEST_ALLOCS] = { 8, 17, 3, 18, 26, 23, 30, 11, @@ -93,18 +109,24 @@ static const int random3[NTEST_ALLOCS] = 29, 14, 19, 21, 0, 31, 7, 24, 9, 15, 2, 28, 16, 6, 13, 5 }; + static const int alignment[NTEST_ALLOCS/2] = { 128, 2048, 131072, 8192, 32, 32768, 16384 , 262144, 512, 4096, 65536, 8, 64, 1024, 16, 4 }; + static void *allocs[NTEST_ALLOCS]; static struct mallinfo alloc_info; static unsigned int g_reportedheapsize = 0; static unsigned int g_actualheapsize = 0; /************************************************************************ - * mm_showchunkinfo + * Private Functions + ************************************************************************/ + +/************************************************************************ + * Name: mm_findinfreelist ************************************************************************/ static int mm_findinfreelist(struct mm_freenode_s *node) @@ -120,9 +142,14 @@ static int mm_findinfreelist(struct mm_freenode_s *node) return 1; } } + return 0; } +/************************************************************************ + * Name: mm_showchunkinfo + ************************************************************************/ + static void mm_showchunkinfo(void) { struct mm_allocnode_s *node; @@ -146,8 +173,8 @@ static void mm_showchunkinfo(void) for (node = g_heapstart[region]; node < g_heapend[region]; node = (struct mm_allocnode_s *)((char*)node + node->size)) - { - printf(" %p 0x%08x 0x%08x %s", + { + printf(" %p 0x%08x 0x%08x %s", node, node->size, node->preceding & ~MM_ALLOC_BIT, node->preceding & MM_ALLOC_BIT ? "Allocated" : "Free "); found = mm_findinfreelist((struct mm_freenode_s *)node); @@ -168,6 +195,10 @@ static void mm_showchunkinfo(void) #undef region } +/************************************************************************ + * Name: mm_showfreelist + ************************************************************************/ + static void mm_showfreelist(void) { struct mm_freenode_s *prev; @@ -204,6 +235,10 @@ static void mm_showfreelist(void) } } +/************************************************************************ + * Name: mm_showmallinfo + ************************************************************************/ + static void mm_showmallinfo(void) { int sval; @@ -213,15 +248,15 @@ static void mm_showmallinfo(void) alloc_info = mallinfo(); printf(" mallinfo:\n"); printf(" Total space allocated from system = %ld\n", - alloc_info.arena); + alloc_info.arena); printf(" Number of non-inuse chunks = %ld\n", - alloc_info.ordblks); + alloc_info.ordblks); printf(" Largest non-inuse chunk = %ld\n", - alloc_info.mxordblk); + alloc_info.mxordblk); printf(" Total allocated space = %ld\n", - alloc_info.uordblks); + alloc_info.uordblks); printf(" Total non-inuse space = %ld\n", - alloc_info.fordblks); + alloc_info.fordblks); sval = mm_getsemaphore(); if (sval != 1) @@ -249,7 +284,12 @@ static void mm_showmallinfo(void) } } -static void do_mallocs(void **mem, const int *size, const int *rand, int n) +/************************************************************************ + * Name: do_mallocs + ************************************************************************/ + +static void do_mallocs(void **mem, const int *size, const int *rand, + int n) { int sval; int i; @@ -294,7 +334,12 @@ static void do_mallocs(void **mem, const int *size, const int *rand, int n) } } -static void do_reallocs(void **mem, const int *oldsize, const int *newsize, const int *rand, int n) +/************************************************************************ + * Name: do_reallocs + ************************************************************************/ + +static void do_reallocs(void **mem, const int *oldsize, + const int *newsize, const int *rand, int n) { int sval; int i; @@ -304,11 +349,11 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons { j = rand[i]; printf("(%d)Re-allocating at %p from %d to %d bytes\n", - i, mem[j], oldsize[j], newsize[j]); + i, mem[j], oldsize[j], newsize[j]); mem[j] = mm_realloc(mem[j], newsize[j]); printf("(%d)Memory re-allocated at %p\n", i, mem[j]); if (mem[j] == NULL) - { + { int allocsize = MM_ALIGN_UP(newsize[j] + SIZEOF_MM_ALLOCNODE); fprintf(stderr, "(%d)realloc failed for allocsize=%d\n", i, allocsize); if (allocsize > alloc_info.mxordblk) @@ -320,7 +365,7 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons fprintf(stderr, " ERROR largest free block is %ld\n", alloc_info.mxordblk); exit(1); } - } + } else { memset(mem[j], 0x55, newsize[j]); @@ -337,7 +382,12 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons } } -static void do_memaligns(void **mem, const int *size, const int *align, const int *rand, int n) +/************************************************************************ + * Name: do_memaligns + ************************************************************************/ + +static void do_memaligns(void **mem, const int *size, const int *align, + const int *rand, int n) { int sval; int i; @@ -347,11 +397,11 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in { j = rand[i]; printf("(%d)Allocating %d bytes aligned to 0x%08x\n", - i, size[j], align[i]); + i, size[j], align[i]); mem[j] = mm_memalign(align[i], size[j]); printf("(%d)Memory allocated at %p\n", i, mem[j]); if (mem[j] == NULL) - { + { int allocsize = MM_ALIGN_UP(size[j] + SIZEOF_MM_ALLOCNODE) + 2*align[i]; fprintf(stderr, "(%d)memalign failed for allocsize=%d\n", i, allocsize); if (allocsize > alloc_info.mxordblk) @@ -363,7 +413,7 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in fprintf(stderr, " ERROR largest free block is %ld\n", alloc_info.mxordblk); exit(1); } - } + } else { memset(mem[j], 0x33, size[j]); @@ -380,6 +430,10 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in } } +/************************************************************************ + * Name: do_frees + ************************************************************************/ + static void do_frees(void **mem, const int *size, const int *rand, int n) { int sval; @@ -390,7 +444,7 @@ static void do_frees(void **mem, const int *size, const int *rand, int n) { j = rand[i]; printf("(%d)Releasing memory at %p (size=%d bytes)\n", - i, mem[j], size[j]); + i, mem[j], size[j]); mm_free(mem[j]); mem[j] = NULL; @@ -405,6 +459,14 @@ static void do_frees(void **mem, const int *size, const int *rand, int n) } } +/************************************************************************ + * Public Functions + ************************************************************************/ + +/************************************************************************ + * Name: main + ************************************************************************/ + int main(int argc, char **argv, char **envp) { void *heap1_base; diff --git a/nuttx/mm/mm_zalloc.c b/nuttx/mm/mm_zalloc.c index 97f1079a6..075777d0c 100644 --- a/nuttx/mm/mm_zalloc.c +++ b/nuttx/mm/mm_zalloc.c @@ -1,8 +1,8 @@ -/************************************************************************ +/**************************************************************************** * mm/mm_zalloc.c * * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. - * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * Author: Gregory Nutt <gnutt@nuttx.org> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -31,30 +31,30 @@ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Included Files - ************************************************************************/ + ****************************************************************************/ #include "mm_environment.h" #include "mm_internal.h" -/************************************************************************ +/**************************************************************************** * Pre-processor Definitions - ************************************************************************/ + ****************************************************************************/ -/************************************************************************ - * Public: Functions - ************************************************************************/ +/**************************************************************************** + * Public Functions + ****************************************************************************/ -/************************************************************************ +/**************************************************************************** * Name: zalloc * * Description: * zalloc calls malloc, then zeroes out the allocated chunk. * - ************************************************************************/ + ****************************************************************************/ FAR void *zalloc(size_t size) { |