Remove CONFIG_GRAN_SINGLE. It adds no technical benefit (other than some minor reduction in the number of interface arguments) but adds a lot of code complexity. Better without it.

arch/z80/src/z180/z180_mmu.c

@@ -69,9 +69,7 @@
  * Private Data
  ****************************************************************************/
 
-#ifndef CONFIG_GRAN_SINGLE
 static GRAN_HANDLE g_physhandle;
-#endif
 static struct z180_cbr_s g_cbrs[CONFIG_MAX_TASKS];
 
 /****************************************************************************
@@ -166,14 +164,9 @@ int up_mmuinit(void)
    * say that 1 page is 1 byte.
    */
 
-#ifdef CONFIG_GRAN_SINGLE
-return gran_initialize((FAR void *)Z180_PHYSHEAP_STARTPAGE,
-                       Z180_PHYSHEAP_NPAGES, 0, 0);
-#else
 g_physhandle = gran_initialize((FAR void *)Z180_PHYSHEAP_STARTPAGE,
                                Z180_PHYSHEAP_NPAGES, 0, 0);
 return g_physhandle ? OK : -ENOMEM;
-#endif
 }
 
 /****************************************************************************
@@ -280,12 +273,8 @@ int up_addrenv_create(size_t textsize, size_t datasize, size_t heapsize,
 
   /* Now allocate the physical memory to back up the address environment */
 
-#ifdef CONFIG_GRAN_SINGLE
   alloc = (uintptr_t)gran_alloc(npages);
-#else
+  if (alloc == NULL)
-  alloc = (uintptr_t)gran_alloc(g_physhandle, npages);
-#endif
-  if (!alloc)
     {
       serr("ERROR: Failed to allocate %d pages\n", npages);
       ret = -ENOMEM;
@@ -337,11 +326,7 @@ int up_addrenv_destroy(FAR group_addrenv_t *addrenv)
 
   /* Free the physical address space backing up the mapping */
 
-#ifdef CONFIG_GRAN_SINGLE
-  gran_free((FAR void *)cbr->cbr, cbr->pages);
-#else
   gran_free(g_physhandle, (FAR void *)cbr->cbr, cbr->pages);
-#endif
 
   /* And make the CBR structure available for re-use */
 

configs/p112/ostest/defconfig

@@ -15,7 +15,6 @@ CONFIG_DISABLE_PTHREAD=y
 CONFIG_EXAMPLES_OSTEST_NBARRIER_THREADS=4
 CONFIG_EXAMPLES_OSTEST_STACKSIZE=1024
 CONFIG_EXAMPLES_OSTEST=y
-CONFIG_GRAN_SINGLE=y
 CONFIG_GRAN=y
 CONFIG_HOST_WINDOWS=y
 CONFIG_MAX_TASKS=8

configs/sama5d4-ek/elf/defconfig

@@ -2,7 +2,6 @@
 CONFIG_ARCH_ADDRENV=y
 CONFIG_ARCH_BOARD_SAMA5D4_EK=y
 CONFIG_ARCH_BOARD="sama5d4-ek"
-CONFIG_BOARD_INITIALIZE=y
 CONFIG_ARCH_BUTTONS=y
 CONFIG_ARCH_CHIP_ATSAMA5D44=y
 CONFIG_ARCH_CHIP_SAMA5=y
@@ -23,19 +22,20 @@ CONFIG_ARCH_TEXT_NPAGES=256
 CONFIG_ARCH_TEXT_VBASE=0x80000000
 CONFIG_ARCH="arm"
 CONFIG_ARMV7A_TOOLCHAIN_CODESOURCERYW=y
-CONFIG_DRIVERS_AUDIO=y
+CONFIG_BOARD_INITIALIZE=y
 CONFIG_BOARD_LOOPSPERMSEC=65775
 CONFIG_BOOT_RUNFROMSDRAM=y
 CONFIG_BUILTIN=y
 CONFIG_DEV_ZERO=y
-CONFIG_ELF=y
+CONFIG_DRIVERS_AUDIO=y
 CONFIG_ELF_STACKSIZE=4096
+CONFIG_ELF=y
 CONFIG_EXAMPLES_ELF_SYSCALL=y
 CONFIG_EXAMPLES_ELF=y
 CONFIG_EXECFUNCS_SYMTAB="exports"
 CONFIG_EXPERIMENTAL=y
+CONFIG_FS_PROCFS=y
 CONFIG_FS_ROMFS=y
-CONFIG_GRAN_SINGLE=y
 CONFIG_HAVE_CXX=y
 CONFIG_HAVE_CXXINITIALIZE=y
 CONFIG_HOST_WINDOWS=y

configs/sama5d4-ek/knsh/defconfig

@@ -41,7 +41,6 @@ CONFIG_FAT_LFN=y
 CONFIG_FS_FAT=y
 CONFIG_FS_PROCFS=y
 CONFIG_FS_ROMFS=y
-CONFIG_GRAN_SINGLE=y
 CONFIG_HAVE_CXX=y
 CONFIG_HAVE_CXXINITIALIZE=y
 CONFIG_HOST_WINDOWS=y

include/nuttx/mm/gran.h

@@ -2,7 +2,7 @@
  * include/nuttx/mm/gran.h
  * General purpose granule memory allocator.
  *
- *   Copyright (C) 2012, 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -51,12 +51,9 @@
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
+
 /* Configuration ************************************************************/
 /* CONFIG_GRAN - Enable granule allocator support
- * CONFIG_GRAN_SINGLE - Select if there is only one instance of the
- *   granule allocator (i.e., gran_initialize will be called only once.
- *   In this case, (1) there are a few optimizations that can can be done
- *   and (2) the GRAN_HANDLE is not needed.
  * CONFIG_GRAN_INTR - Normally mutual exclusive access to granule allocator
  *   data is assured using a semaphore.  If this option is set then, instead,
  *   mutual exclusion logic will disable interrupts.  While this options is
@@ -70,9 +67,19 @@
  * Public Types
  ****************************************************************************/
 
-#ifndef CONFIG_GRAN_SINGLE
+/* An opaque reference to an instance of a granule allocator state */
+
 typedef FAR void *GRAN_HANDLE;
-#endif
+
+/* For in which the state of the granule allocator is returned */
+
+struct graninfo_s
+{
+  uint8_t   log2gran;  /* Log base 2 of the size of one granule */
+  uint16_t  ngranules; /* The total number of (aligned) granules in the heap */
+  uint16_t  nfree;     /* The number of free granules */
+  uint16_t  mxfree;    /* The longest sequence of free granules */
+};
 
 /****************************************************************************
  * Public Function Prototypes
@@ -110,8 +117,7 @@ extern "C"
  *
  *     GRAN_HANDLE handle = gran_initialize(g_dmaheap, DMAHEAP_SIZE, 6, 4);
  *
- *   Then the GRAN_HANDLE can be used to allocate memory (There is no
+ *   Then the GRAN_HANDLE can be used to allocate memory:
- *   GRAN_HANDLE if CONFIG_GRAN_SINGLE=y):
  *
  *     FAR uint8_t *dma_memory = (FAR uint8_t *)gran_alloc(handle, 47);
  *
@@ -140,13 +146,8 @@ extern "C"
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-int gran_initialize(FAR void *heapstart, size_t heapsize, uint8_t log2gran,
-                    uint8_t log2align);
-#else
 GRAN_HANDLE gran_initialize(FAR void *heapstart, size_t heapsize,
                             uint8_t log2gran, uint8_t log2align);
-#endif
 
 /****************************************************************************
  * Name: gran_release
@@ -163,11 +164,7 @@ GRAN_HANDLE gran_initialize(FAR void *heapstart, size_t heapsize,
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-void gran_release(void);
-#else
 void gran_release(GRAN_HANDLE handle);
-#endif
 
 /****************************************************************************
  * Name: gran_reserve
@@ -191,11 +188,7 @@ void gran_release(GRAN_HANDLE handle);
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-void gran_reserve(uintptr_t start, size_t size);
-#else
 void gran_reserve(GRAN_HANDLE handle, uintptr_t start, size_t size);
-#endif
 
 /****************************************************************************
  * Name: gran_alloc
@@ -212,16 +205,12 @@ void gran_reserve(GRAN_HANDLE handle, uintptr_t start, size_t size);
  *   size   - The size of the memory region to allocate.
  *
  * Returned Value:
- *   On success, either a non-NULL pointer to the allocated memory (if
+ *   On success, a non-NULL pointer to the allocated memory is returned;
- *   CONFIG_GRAN_SINGLE) or zero  (if !CONFIG_GRAN_SINGLE) is returned.
+ *   NULL is returned on failure.
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-FAR void *gran_alloc(size_t size);
-#else
 FAR void *gran_alloc(GRAN_HANDLE handle, size_t size);
-#endif
 
 /****************************************************************************
  * Name: gran_free
@@ -238,11 +227,25 @@ FAR void *gran_alloc(GRAN_HANDLE handle, size_t size);
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-void gran_free(FAR void *memory, size_t size);
-#else
 void gran_free(GRAN_HANDLE handle, FAR void *memory, size_t size);
-#endif
+
+/****************************************************************************
+ * Name: gran_info
+ *
+ * Description:
+ *   Return memory to the granule heap.
+ *
+ * Input Parameters:
+ *   handle - The handle previously returned by gran_initialize
+ *   info   - Memory location to return the gran allocator info.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is return on
+ *   any failure.
+ *
+ ****************************************************************************/
+
+void gran_info(GRAN_HANDLE handle, FAR struct graninfo_s *info);
 
 #undef EXTERN
 #ifdef __cplusplus

include/nuttx/mm/shm.h

@@ -1,7 +1,7 @@
 /****************************************************************************
  * include/nuttx/mm/shm.h
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -65,10 +65,6 @@
 #  error CONFIG_GRAN must be selected with CONFIG_MM_SHM
 #endif
 
-#ifdef CONFIG_GRAN_SINGLE
-#  error CONFIG_GRAN_SINGLE must NOT be selected with CONFIG_MM_SHM
-#endif
-
 #ifndef CONFIG_MM_PGALLOC
 #  error CONFIG_MM_PGALLOC must be selected with CONFIG_MM_SHM
 #endif

mm/Kconfig

@@ -92,16 +92,6 @@ config GRAN
 		allocation size to 32 granaules.  That restriction could be
 		eliminated with some additional coding effort.
 
-config GRAN_SINGLE
-	bool "Single Granule Allocator"
-	default n
-	depends on GRAN
-	---help---
-		Select if there is only one instance of the granule allocator (i.e.,
-		gran_initialize will be called only once. In this case, (1) there
-		are a few optimizations that can can be done and (2) the GRAN_HANDLE
-		is not needed.
-
 config GRAN_INTR
 	bool "Interrupt level support"
 	default n

mm/README.txt

@@ -116,8 +116,7 @@ This directory contains the NuttX memory management logic.  This include:
 
        GRAN_HANDLE handle = gran_initialize(g_dmaheap, DMAHEAP_SIZE, 6, 4);
 
-     Then the GRAN_HANDLE can be used to allocate memory (There is no
+     Then the GRAN_HANDLE can be used to allocate memory:
-     GRAN_HANDLE if CONFIG_GRAN_SINGLE=y):
 
        FAR uint8_t *dma_memory = (FAR uint8_t *)gran_alloc(handle, 47);
 

mm/mm_gran/mm_gran.h

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_gran.h
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -102,16 +102,6 @@ struct gran_s
   uint32_t   gat[1];    /* Start of the granule allocation table */
 };
 
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/* State of the single GRAN allocator */
-
-#ifdef CONFIG_GRAN_SINGLE
-extern FAR struct gran_s *g_graninfo;
-#endif
-
 /****************************************************************************
  * Public Function Prototypes
  ****************************************************************************/

mm/mm_gran/mm_granalloc.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_granalloc.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -48,26 +48,32 @@
 #ifdef CONFIG_GRAN
 
 /****************************************************************************
- * Private Functions
+ * Public Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: gran_common_alloc
+ * Name: gran_alloc
  *
  * Description:
  *   Allocate memory from the granule heap.
  *
+ *   NOTE: The current implementation also restricts the maximum allocation
+ *   size to 32 granules.  That restriction could be eliminated with some
+ *   additional coding effort.
+ *
  * Input Parameters:
- *   priv - The granule heap state structure.
+ *   handle - The handle previously returned by gran_initialize
- *   size - The size of the memory region to allocate.
+ *   size   - The size of the memory region to allocate.
  *
  * Returned Value:
- *   On success, a non-NULL pointer to the allocated memory is returned.
+ *   On success, a non-NULL pointer to the allocated memory is returned;
+ *   NULL is returned on failure.
  *
  ****************************************************************************/
 
-static inline FAR void *gran_common_alloc(FAR struct gran_s *priv, size_t size)
+FAR void *gran_alloc(GRAN_HANDLE handle, size_t size)
 {
+  FAR struct gran_s *priv = (FAR struct gran_s *)handle;
   unsigned int ngranules;
   size_t       tmpmask;
   uintptr_t    alloc;
@@ -79,7 +85,7 @@ static inline FAR void *gran_common_alloc(FAR struct gran_s *priv, size_t size)
   int          bitidx;
   int          shift;
 
-  DEBUGASSERT(priv && size <= 32 * (1 << priv->log2gran));
+  DEBUGASSERT(priv != NULL && size <= 32 * (1 << priv->log2gran));
 
   if (priv && size > 0)
     {
@@ -248,40 +254,4 @@ static inline FAR void *gran_common_alloc(FAR struct gran_s *priv, size_t size)
   return NULL;
 }
 
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: gran_alloc
- *
- * Description:
- *   Allocate memory from the granule heap.
- *
- *   NOTE: The current implementation also restricts the maximum allocation
- *   size to 32 granules.  That restriction could be eliminated with some
- *   additional coding effort.
- *
- * Input Parameters:
- *   handle - The handle previously returned by gran_initialize
- *   size   - The size of the memory region to allocate.
- *
- * Returned Value:
- *   On success, either a non-NULL pointer to the allocated memory (if
- *   CONFIG_GRAN_SINGLE) or zero  (if !CONFIG_GRAN_SINGLE) is returned.
- *
- ****************************************************************************/
-
-#ifdef CONFIG_GRAN_SINGLE
-FAR void *gran_alloc(size_t size)
-{
-  return gran_common_alloc(g_graninfo, size);
-}
-#else
-FAR void *gran_alloc(GRAN_HANDLE handle, size_t size)
-{
-  return gran_common_alloc((FAR struct gran_s *)handle, size);
-}
-#endif
-
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_granfree.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_granfree.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -48,11 +48,11 @@
 #ifdef CONFIG_GRAN
 
 /****************************************************************************
- * Pre-processor Definitions
+ * Public Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: gran_common_free
+ * Name: gran_free
  *
  * Description:
  *   Return memory to the granule heap.
@@ -66,9 +66,9 @@
  *
  ****************************************************************************/
 
-static inline void gran_common_free(FAR struct gran_s *priv,
+void gran_free(GRAN_HANDLE handle, FAR void *memory, size_t size)
-                                    FAR void *memory, size_t size)
 {
+  FAR struct gran_s *priv = (FAR struct gran_s *)handle;
   unsigned int granno;
   unsigned int gatidx;
   unsigned int gatbit;
@@ -77,7 +77,7 @@ static inline void gran_common_free(FAR struct gran_s *priv,
   unsigned int avail;
   uint32_t     gatmask;
 
-  DEBUGASSERT(priv && memory && size <= 32 * (1 << priv->log2gran));
+  DEBUGASSERT(priv != NULL && memory && size <= 32 * (1 << priv->log2gran));
 
   /* Get exclusive access to the GAT */
 
@@ -136,35 +136,4 @@ static inline void gran_common_free(FAR struct gran_s *priv,
   gran_leave_critical(priv);
 }
 
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: gran_free
- *
- * Description:
- *   Return memory to the granule heap.
- *
- * Input Parameters:
- *   handle - The handle previously returned by gran_initialize
- *   memory - A pointer to memory previoiusly allocated by gran_alloc.
- *
- * Returned Value:
- *   None
- *
- ****************************************************************************/
-
-#ifdef CONFIG_GRAN_SINGLE
-void gran_free(FAR void *memory, size_t size)
-{
-  return gran_common_free(g_graninfo, memory, size);
-}
-#else
-void gran_free(GRAN_HANDLE handle, FAR void *memory, size_t size)
-{
-  return gran_common_free((FAR struct gran_s *)handle, memory, size);
-}
-#endif
-
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_graninit.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_graninit.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -50,46 +50,64 @@
 #ifdef CONFIG_GRAN
 
 /****************************************************************************
- * Public Data
+ * Public Functions
- ****************************************************************************/
-
-/* State of the single GRAN allocator */
-
-#ifdef CONFIG_GRAN_SINGLE
-FAR struct gran_s *g_graninfo;
-#endif
-
-/****************************************************************************
- * Private Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: gran_common_initialize
+ * Name: gran_initialize
  *
  * Description:
- *   Perform common GRAN initialization.
+ *   Set up one granule allocator instance.  Allocations will be aligned to
+ *   the alignment size (log2align; allocations will be in units of the
+ *   granule size (log2gran). Larger granules will give better performance
+ *   and less overhead but more losses of memory due to quantization waste.
+ *   Additional memory waste can occur from alignment; log2align should be
+ *   set to 0 unless you are using the granule allocator to manage DMA
+ *   or page-aligned memory and your hardware has specific memory alignment
+ *   requirements.
+ *
+ *   General Usage Summary.  This is an example using the GCC section
+ *   attribute to position a DMA heap in memory (logic in the linker script
+ *   would assign the section .dmaheap to the DMA memory.
+ *
+ *     FAR uint32_t g_dmaheap[DMAHEAP_SIZE] __attribute__((section(.dmaheap)));
+ *
+ *   The heap is created by calling gran_initialize().  Here the granule size
+ *   is set to 64 bytes (2**6) and the alignment to 16 bytes (2**4):
+ *
+ *     GRAN_HANDLE handle = gran_initialize(g_dmaheap, DMAHEAP_SIZE, 6, 4);
+ *
+ *   Then the GRAN_HANDLE can be used to allocate memory:
+ *
+ *     FAR uint8_t *dma_memory = (FAR uint8_t *)gran_alloc(handle, 47);
+ *
+ *   The actual memory allocates will be 64 byte (wasting 17 bytes) and
+ *   will be aligned at least to (1 << log2align).
+ *
+ *   NOTE: The current implementation also restricts the maximum allocation
+ *   size to 32 granules.  That restriction could be eliminated with some
+ *   additional coding effort.
  *
  * Input Parameters:
  *   heapstart - Start of the granule allocation heap
  *   heapsize  - Size of heap in bytes
  *   log2gran  - Log base 2 of the size of one granule.  0->1 byte,
- *               1->2 bytes, 2->4 bytes, 3-> 8 bytes, etc.
+ *               1->2 bytes, 2->4 bytes, 3->8 bytes, etc.
  *   log2align - Log base 2 of required alignment.  0->1 byte,
- *               1->2 bytes, 2->4 bytes, 3-> 8 bytes, etc.  Note that
+ *               1->2 bytes, 2->4 bytes, 3->8 bytes, etc.  Note that
  *               log2gran must be greater than or equal to log2align
  *               so that all contiguous granules in memory will meet
  *               the minimum alignment requirement. A value of zero
  *               would mean that no alignment is required.
  *
  * Returned Value:
- *   On success, a non-NULL info structure is returned that may be used with
+ *   On success, a non-NULL handle is returned that may be used with other
- *   other granule allocator interfaces.
+ *   granule allocator interfaces.
  *
  ****************************************************************************/
 
-static inline FAR struct gran_s *
+GRAN_HANDLE gran_initialize(FAR void *heapstart, size_t heapsize,
-gran_common_initialize(FAR void *heapstart, size_t heapsize, uint8_t log2gran,
+                            uint8_t log2gran, uint8_t log2align)
-                       uint8_t log2align)
 {
   FAR struct gran_s *priv;
   uintptr_t          heapend;
@@ -139,87 +157,7 @@ gran_common_initialize(FAR void *heapstart, size_t heapsize, uint8_t log2gran,
 #endif
     }
 
-  return priv;
+  return (GRAN_HANDLE)priv;
 }
 
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: gran_initialize
- *
- * Description:
- *   Set up one granule allocator instance.  Allocations will be aligned to
- *   the alignment size (log2align; allocations will be in units of the
- *   granule size (log2gran). Larger granules will give better performance
- *   and less overhead but more losses of memory due to quantization waste.
- *   Additional memory waste can occur from alignment; log2align should be
- *   set to 0 unless you are using the granule allocator to manage DMA
- *   or page-aligned memory and your hardware has specific memory alignment
- *   requirements.
- *
- *   General Usage Summary.  This is an example using the GCC section
- *   attribute to position a DMA heap in memory (logic in the linker script
- *   would assign the section .dmaheap to the DMA memory.
- *
- *     FAR uint32_t g_dmaheap[DMAHEAP_SIZE] __attribute__((section(.dmaheap)));
- *
- *   The heap is created by calling gran_initialize().  Here the granule size
- *   is set to 64 bytes (2**6) and the alignment to 16 bytes (2**4):
- *
- *     GRAN_HANDLE handle = gran_initialize(g_dmaheap, DMAHEAP_SIZE, 6, 4);
- *
- *   Then the GRAN_HANDLE can be used to allocate memory (There is no
- *   GRAN_HANDLE if CONFIG_GRAN_SINGLE=y):
- *
- *     FAR uint8_t *dma_memory = (FAR uint8_t *)gran_alloc(handle, 47);
- *
- *   The actual memory allocates will be 64 byte (wasting 17 bytes) and
- *   will be aligned at least to (1 << log2align).
- *
- *   NOTE: The current implementation also restricts the maximum allocation
- *   size to 32 granules.  That restriction could be eliminated with some
- *   additional coding effort.
- *
- * Input Parameters:
- *   heapstart - Start of the granule allocation heap
- *   heapsize  - Size of heap in bytes
- *   log2gran  - Log base 2 of the size of one granule.  0->1 byte,
- *               1->2 bytes, 2->4 bytes, 3->8 bytes, etc.
- *   log2align - Log base 2 of required alignment.  0->1 byte,
- *               1->2 bytes, 2->4 bytes, 3->8 bytes, etc.  Note that
- *               log2gran must be greater than or equal to log2align
- *               so that all contiguous granules in memory will meet
- *               the minimum alignment requirement. A value of zero
- *               would mean that no alignment is required.
- *
- * Returned Value:
- *   On success, a non-NULL handle is returned that may be used with other
- *   granule allocator interfaces.
- *
- ****************************************************************************/
-
-#ifdef CONFIG_GRAN_SINGLE
-int gran_initialize(FAR void *heapstart, size_t heapsize, uint8_t log2gran,
-                    uint8_t log2align)
-{
-  g_graninfo = gran_common_initialize(heapstart, heapsize, log2gran,
-                                      log2align);
-  if (!g_graninfo)
-    {
-      return -ENOMEM;
-    }
-
-  return OK;
-}
-#else
-GRAN_HANDLE gran_initialize(FAR void *heapstart, size_t heapsize,
-                            uint8_t log2gran, uint8_t log2align)
-{
-  return (GRAN_HANDLE)gran_common_initialize(heapstart, heapsize,
-                                             log2gran, log2align);
-}
-#endif
-
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_granrelease.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_graninit.c
  *
- *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2012, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -49,43 +49,6 @@
 
 #ifdef CONFIG_GRAN
 
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/* State of the single GRAN allocator */
-
-#ifdef CONFIG_GRAN_SINGLE
-FAR struct gran_s *g_graninfo;
-#endif
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: gran_release_common
- *
- * Description:
- *   Perform common GRAN initialization.
- *
- * Input Parameters:
- *   priv - Reference to the granule heap structure to be released.
- *
- * Returned Value:
- *   None
- *
- ****************************************************************************/
-
-static inline void gran_release_common(FAR struct gran_s *priv)
-{
-  DEBUGASSERT(priv);
-#ifndef CONFIG_GRAN_INTR
-  nxsem_destroy(&priv->exclsem);
-#endif
-  kmm_free(priv);
-}
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -105,17 +68,16 @@ static inline void gran_release_common(FAR struct gran_s *priv)
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-void gran_release(void)
-{
-  gran_release_common(g_graninfo);
-  g_graninfo = NULL;
-}
-#else
 void gran_release(GRAN_HANDLE handle)
 {
-  gran_release_common(handle);
+  FAR struct gran_s *priv = (FAR struct gran_s *)handle;
-}
+
+  DEBUGASSERT(priv != NULL);
+
+#ifndef CONFIG_GRAN_INTR
+  nxsem_destroy(&priv->exclsem);
 #endif
+  kmm_free(priv);
+}
 
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_granreserve.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_granreserve.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,58 +47,6 @@
 
 #ifdef CONFIG_GRAN
 
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: gran_common_reserve
- *
- * Description:
- *   Reserve memory in the granule heap.  This will reserve the granules
- *   that contain the start and end addresses plus all of the granules
- *   in between.  This should be done early in the initialization sequence
- *   before any other allocations are made.
- *
- *   Reserved memory can never be allocated (it can be freed however which
- *   essentially unreserves the memory).
- *
- * Input Parameters:
- *   priv  - The granule heap state structure.
- *   start - The address of the beginning of the region to be reserved.
- *   size  - The size of the region to be reserved
- *
- * Returned Value:
- *   None
- *
- ****************************************************************************/
-
-static inline void gran_common_reserve(FAR struct gran_s *priv,
-                                       uintptr_t start, size_t size)
-{
-  if (size > 0)
-    {
-      uintptr_t mask = (1 << priv->log2gran) - 1;
-      uintptr_t end  = start + size - 1;
-      unsigned int ngranules;
-
-      /* Get the aligned (down) start address and the aligned (up) end
-       * address
-       */
-
-      start &= ~mask;
-      end = (end + mask) & ~mask;
-
-      /* Calculate the new size in granules */
-
-      ngranules = ((end - start) >> priv->log2gran) + 1;
-
-      /* And reserve the granules */
-
-      gran_mark_allocated(priv, start, ngranules);
-    }
-}
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -125,16 +73,33 @@ static inline void gran_common_reserve(FAR struct gran_s *priv,
  *
  ****************************************************************************/
 
-#ifdef CONFIG_GRAN_SINGLE
-void gran_reserve(uintptr_t start, size_t size)
-{
-  return gran_common_reserve(g_graninfo, start, size);
-}
-#else
 void gran_reserve(GRAN_HANDLE handle, uintptr_t start, size_t size)
 {
-  return gran_common_reserve((FAR struct gran_s *)handle, start, size);
+  FAR struct gran_s *priv = (FAR struct gran_s *)handle;
+
+  DEBUGASSERT(priv != NULL);
+
+  if (size > 0)
+    {
+      uintptr_t mask = (1 << priv->log2gran) - 1;
+      uintptr_t end  = start + size - 1;
+      unsigned int ngranules;
+
+      /* Get the aligned (down) start address and the aligned (up) end
+       * address
+       */
+
+      start &= ~mask;
+      end = (end + mask) & ~mask;
+
+      /* Calculate the new size in granules */
+
+      ngranules = ((end - start) >> priv->log2gran) + 1;
+
+      /* And reserve the granules */
+
+      gran_mark_allocated(priv, start, ngranules);
+    }
 }
-#endif
 
 #endif /* CONFIG_GRAN */

mm/mm_gran/mm_pgalloc.c

@@ -1,7 +1,7 @@
 /****************************************************************************
  * mm/mm_gran/mm_pgalloc.c
  *
- *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2014, 2017 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -90,11 +90,9 @@
  * Private Data
  ****************************************************************************/
 
-#ifndef CONFIG_GRAN_SINGLE
 /* The state of the page allocator */
 
 static GRAN_HANDLE g_pgalloc;
-#endif
 
 /****************************************************************************
  * Private Functions
@@ -123,18 +121,8 @@ static GRAN_HANDLE g_pgalloc;
 
 void mm_pginitialize(FAR void *heap_start, size_t heap_size)
 {
-#ifdef CONFIG_GRAN_SINGLE
-  int ret;
-
-  ret = gran_initialize(heap_start, heap_size, MM_PGSHIFT, MM_PGSHIFT);
-  DEBUGASSERT(ret == OK);
-  UNUSED(ret);
-
-#else
   g_pgalloc = gran_initialize(heap_start, heap_size, MM_PGSHIFT, MM_PGSHIFT);
   DEBUGASSERT(pg_alloc != NULL);
-
-#endif
 }
 
 /****************************************************************************
@@ -160,11 +148,7 @@ void mm_pginitialize(FAR void *heap_start, size_t heap_size)
 
 void mm_pgreserve(uintptr_t start, size_t size)
 {
-#ifdef CONFIG_GRAN_SINGLE
-  gran_reserve(start, size);
-#else
   gran_reserve(g_pgalloc, start, size);
-#endif
 }
 
 /****************************************************************************
@@ -185,11 +169,7 @@ void mm_pgreserve(uintptr_t start, size_t size)
 
 uintptr_t mm_pgalloc(unsigned int npages)
 {
-#ifdef CONFIG_GRAN_SINGLE
-  return (uintptr_t)gran_alloc((size_t)1 << MM_PGSHIFT);
-#else
   return (uintptr_t)gran_alloc(g_pgalloc, (size_t)1 << MM_PGSHIFT);
-#endif
 }
 
 /****************************************************************************
@@ -211,11 +191,7 @@ uintptr_t mm_pgalloc(unsigned int npages)
 
 void mm_pgfree(uintptr_t paddr, unsigned int npages)
 {
-#ifdef CONFIG_GRAN_SINGLE
-  gran_free((FAR void *)paddr, (size_t)npages << MM_PGSHIFT);
-#else
   gran_free(g_pgalloc, (FAR void *)paddr, (size_t)npages << MM_PGSHIFT);
-#endif
 }
 
 #endif /* CONFIG_MM_PGALLOC */

mm/shm/README.txt

@@ -12,9 +12,6 @@ Prerequisites
       regions must be provided by the MMU.
     CONFIG_GRAN=y - The granule allocation is the allocation underlying all
       paged allocations.
-    CONFIG_GRAN_SINGLE=n - Multiple granule allocators are needed: One for
-      the physical page allocation and one virtual page allocator for each
-      process.
     CONFIG_MM_PGALLOC=y - Enables the physical page allocator
     CONFIG_MM_PGSIZE - Determines the size of one page that can be mapped by
       the MMU.