Added additional _context for support of use of UMM_INLINE_METRICS.

Corrected some UMM_POSION missed edits.
esp8266 · d-a-v · Dec 6, 2020 · Feb 4, 2020 · Feb 4, 2020 · Feb 7, 2020
commit d3ace64113b25f6162b65c9c4c6f897714d86e9d
diff --git a/cores/esp8266/Esp-frag.cpp b/cores/esp8266/Esp-frag.cpp
@@ -30,14 +30,15 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
     // 100 * (1 - sqrt(sum(hole-size²)) / sum(hole-size))
 
     umm_info(NULL, false);
-    uint8_t block_size = umm_block_size();
+
+    uint32_t free_size = umm_free_heap_size_core();
     if (hfree)
-        *hfree = ummHeapInfo.freeBlocks * block_size;
+        *hfree = free_size;
     if (hmax)
-        *hmax = (uint16_t)ummHeapInfo.maxFreeContiguousBlocks * block_size;
+        *hmax = (uint16_t)umm_max_block_size_core();
     if (hfrag) {
-      if (ummHeapInfo.freeBlocks) {
-        *hfrag = 100 - (sqrt32(ummHeapInfo.freeBlocksSquared) * 100) / ummHeapInfo.freeBlocks;
+      if (free_size) {
+        *hfrag = umm_fragmentation_metric_core();
       } else {
         *hfrag = 0;
       }
@@ -46,11 +47,5 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
 
 uint8_t EspClass::getHeapFragmentation()
 {
-#ifdef UMM_INLINE_METRICS
-    return (uint8_t)umm_fragmentation_metric();
-#else
-    uint8_t hfrag;
-    getHeapStats(nullptr, nullptr, &hfrag);
-    return hfrag;
-#endif
+  return (uint8_t)umm_fragmentation_metric();
 }
diff --git a/cores/esp8266/umm_malloc/umm_info.c b/cores/esp8266/umm_malloc/umm_info.c
@@ -23,7 +23,7 @@
  * ----------------------------------------------------------------------------
  */
 
-UMM_HEAP_INFO ummHeapInfo;
+// UMM_HEAP_INFO ummHeapInfo;
 
 void *umm_info( void *ptr, bool force ) {
   UMM_CRITICAL_DECL(id_info);
@@ -41,7 +41,7 @@ void *umm_info( void *ptr, bool force ) {
    * Clear out all of the entries in the ummHeapInfo structure before doing
    * any calculations..
    */
-  memset( &ummHeapInfo, 0, sizeof( ummHeapInfo ) );
+  memset( &_context->info, 0, sizeof( _context->info ) );
 
   DBGLOG_FORCE( force, "\n" );
   DBGLOG_FORCE( force, "+----------+-------+--------+--------+-------+--------+--------+\n" );
@@ -65,18 +65,18 @@ void *umm_info( void *ptr, bool force ) {
   while( UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK ) {
     size_t curBlocks = (UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo;
 
-    ++ummHeapInfo.totalEntries;
-    ummHeapInfo.totalBlocks += curBlocks;
+    ++_context->info.totalEntries;
+    _context->info.totalBlocks += curBlocks;
 
     /* Is this a free block? */
 
     if( UMM_NBLOCK(blockNo) & UMM_FREELIST_MASK ) {
-      ++ummHeapInfo.freeEntries;
-      ummHeapInfo.freeBlocks += curBlocks;
-      ummHeapInfo.freeBlocksSquared += (curBlocks * curBlocks);
+      ++_context->info.freeEntries;
+      _context->info.freeBlocks += curBlocks;
+      _context->info.freeBlocksSquared += (curBlocks * curBlocks);
 
-      if (ummHeapInfo.maxFreeContiguousBlocks < curBlocks) {
-        ummHeapInfo.maxFreeContiguousBlocks = curBlocks;
+      if (_context->info.maxFreeContiguousBlocks < curBlocks) {
+        _context->info.maxFreeContiguousBlocks = curBlocks;
       }
 
       DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5u|NF %5d|PF %5d|\n",
@@ -98,8 +98,8 @@ void *umm_info( void *ptr, bool force ) {
         return( ptr );
       }
     } else {
-      ++ummHeapInfo.usedEntries;
-      ummHeapInfo.usedBlocks += curBlocks;
+      ++_context->info.usedEntries;
+      _context->info.usedBlocks += curBlocks;
 
       DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5u|\n",
           DBGLOG_32_BIT_PTR(&UMM_BLOCK(blockNo)),
@@ -131,14 +131,14 @@ void *umm_info( void *ptr, bool force ) {
   DBGLOG_FORCE( force, "+----------+-------+--------+--------+-------+--------+--------+\n" );
 
   DBGLOG_FORCE( force, "Total Entries %5d    Used Entries %5d    Free Entries %5d\n",
-      ummHeapInfo.totalEntries,
-      ummHeapInfo.usedEntries,
-      ummHeapInfo.freeEntries );
+      _context->info.totalEntries,
+      _context->info.usedEntries,
+      _context->info.freeEntries );
 
   DBGLOG_FORCE( force, "Total Blocks  %5d    Used Blocks  %5d    Free Blocks  %5d\n",
-      ummHeapInfo.totalBlocks,
-      ummHeapInfo.usedBlocks,
-      ummHeapInfo.freeBlocks  );
+      _context->info.totalBlocks,
+      _context->info.usedBlocks,
+      _context->info.freeBlocks  );
 
   DBGLOG_FORCE( force, "+--------------------------------------------------------------+\n" );
 
@@ -149,11 +149,11 @@ void *umm_info( void *ptr, bool force ) {
 
 #if defined(UMM_STATS) || defined(UMM_STATS_FULL)
 #if !defined(UMM_INLINE_METRICS)
-  if (ummHeapInfo.freeBlocks == _context->stats.free_blocks) {
+  if (_context->info.freeBlocks == _context->stats.free_blocks) {
       DBGLOG_FORCE( force, "heap info Free blocks and heap statistics Free blocks match.\n");
   } else {
       DBGLOG_FORCE( force, "\nheap info Free blocks  %5d != heap statistics Free Blocks  %5d\n\n",
-          ummHeapInfo.freeBlocks,
+          _context->info.freeBlocks,
           _context->stats.free_blocks  );
   }
   DBGLOG_FORCE( force, "+--------------------------------------------------------------+\n" );
@@ -170,20 +170,31 @@ void *umm_info( void *ptr, bool force ) {
 
 /* ------------------------------------------------------------------------ */
 
+size_t umm_free_heap_size_core( void ) {
+  umm_heap_context_t *_context = umm_get_current_heap();
+  return (size_t)_context->info.freeBlocks * sizeof(umm_block);
+}
+
 size_t umm_free_heap_size( void ) {
 #ifndef UMM_INLINE_METRICS
   umm_info(NULL, false);
 #endif
-  return (size_t)ummHeapInfo.freeBlocks * sizeof(umm_block);
+
+  return umm_free_heap_size_core();
 }
 
 //C Breaking change in upstream umm_max_block_size() was changed to
 //C umm_max_free_block_size() keeping old function name for (dot) releases.
 //C TODO: update at next major release.
 //C size_t umm_max_free_block_size( void ) {
+size_t umm_max_block_size_core( void ) {
+  umm_heap_context_t *_context = umm_get_current_heap();
+  return _context->info.maxFreeContiguousBlocks * sizeof(umm_block);
+}
+
 size_t umm_max_block_size( void ) {
   umm_info(NULL, false);
-  return ummHeapInfo.maxFreeContiguousBlocks * sizeof(umm_block);
+  return umm_max_block_size_core();
 }
 
 /*
@@ -195,46 +206,58 @@ int umm_usage_metric( void ) {
 #ifndef UMM_INLINE_METRICS
   umm_info(NULL, false);
 #endif
-  DBGLOG_DEBUG( "usedBlocks %d totalBlocks %d\n", umm_metrics.usedBlocks, ummHeapInfo.totalBlocks);
-  if (ummHeapInfo.freeBlocks)
-    return (int)((ummHeapInfo.usedBlocks * 100)/(ummHeapInfo.freeBlocks));
+
+  umm_heap_context_t *_context = umm_get_current_heap();
+
+//C Note, umm_metrics also appears in the upstrean w/o definition. I suspect it is suppose to be ummHeapInfo.
+  // DBGLOG_DEBUG( "usedBlocks %d totalBlocks %d\n", umm_metrics.usedBlocks, ummHeapInfo.totalBlocks);
+  DBGLOG_DEBUG( "usedBlocks %d totalBlocks %d\n", _context->info.usedBlocks, _context->info.totalBlocks);
+  if (_context->info.freeBlocks)
+    return (int)((_context->info.usedBlocks * 100)/(_context->info.freeBlocks));
 
   return -1;  // no freeBlocks
 }
 
 uint32_t sqrt32 (uint32_t n);
 
-int umm_fragmentation_metric( void ) {
-#ifndef UMM_INLINE_METRICS
-  umm_info(NULL, false);
-#endif
-  DBGLOG_DEBUG( "freeBlocks %d freeBlocksSquared %d\n", umm_metrics.freeBlocks, ummHeapInfo.freeBlocksSquared);
-  if (0 == ummHeapInfo.freeBlocks) {
+int umm_fragmentation_metric_core( void ) {
+  umm_heap_context_t *_context = umm_get_current_heap();
+  // DBGLOG_DEBUG( "freeBlocks %d freeBlocksSquared %d\n", umm_metrics.freeBlocks, ummHeapInfo.freeBlocksSquared);
+  DBGLOG_DEBUG( "freeBlocks %d freeBlocksSquared %d\n", _context->info.freeBlocks, _context->info.freeBlocksSquared);
+  if (0 == _context->info.freeBlocks) {
       return 0;
   } else {
       //upstream version: return (100 - (((uint32_t)(sqrtf(ummHeapInfo.freeBlocksSquared)) * 100)/(ummHeapInfo.freeBlocks)));
-      return (100 - (((uint32_t)(sqrt32(ummHeapInfo.freeBlocksSquared)) * 100)/(ummHeapInfo.freeBlocks)));
+      return (100 - (((uint32_t)(sqrt32(_context->info.freeBlocksSquared)) * 100)/(_context->info.freeBlocks)));
   }
 }
 
+int umm_fragmentation_metric( void ) {
+#ifndef UMM_INLINE_METRICS
+  umm_info(NULL, false);
+#endif
+
+  return umm_fragmentation_metric_core();
+}
+
 #ifdef UMM_INLINE_METRICS
-static void umm_fragmentation_metric_init( void ) {
-    ummHeapInfo.freeBlocks = UMM_NUMBLOCKS - 2;
-    ummHeapInfo.freeBlocksSquared = ummHeapInfo.freeBlocks * ummHeapInfo.freeBlocks;
+static void umm_fragmentation_metric_init( umm_heap_context_t *_context ) {
+    _context->info.freeBlocks = UMM_NUMBLOCKS - 2;
+    _context->info.freeBlocksSquared = _context->info.freeBlocks * _context->info.freeBlocks;
 }
 
-static void umm_fragmentation_metric_add( uint16_t c ) {
+static void umm_fragmentation_metric_add( umm_heap_context_t *_context, uint16_t c ) {
     uint16_t blocks = (UMM_NBLOCK(c) & UMM_BLOCKNO_MASK) - c;
     DBGLOG_DEBUG( "Add block %d size %d to free metric\n", c, blocks);
-    ummHeapInfo.freeBlocks += blocks;
-    ummHeapInfo.freeBlocksSquared += (blocks * blocks);
+    _context->info.freeBlocks += blocks;
+    _context->info.freeBlocksSquared += (blocks * blocks);
 }
 
-static void umm_fragmentation_metric_remove( uint16_t c ) {
+static void umm_fragmentation_metric_remove( umm_heap_context_t *_context, uint16_t c ) {
     uint16_t blocks = (UMM_NBLOCK(c) & UMM_BLOCKNO_MASK) - c;
     DBGLOG_DEBUG( "Remove block %d size %d from free metric\n", c, blocks);
-    ummHeapInfo.freeBlocks -= blocks;
-    ummHeapInfo.freeBlocksSquared -= (blocks * blocks);
+    _context->info.freeBlocks -= blocks;
+    _context->info.freeBlocksSquared -= (blocks * blocks);
 }
 #endif // UMM_INLINE_METRICS
 

diff --git a/cores/esp8266/umm_malloc/umm_local.c b/cores/esp8266/umm_malloc/umm_local.c
@@ -15,7 +15,7 @@ UMM_TIME_STATS time_stats = {
 #ifdef UMM_INFO
     {0xFFFFFFFF, 0U, 0U, 0U},
 #endif
-#ifdef UMM_POISON_CHECK
+#if defined(UMM_POISON_CHECK) || defined(UMM_POISON_CHECK_LITE)
     {0xFFFFFFFF, 0U, 0U, 0U},
 #endif
 #ifdef UMM_INTEGRITY_CHECK
@@ -96,7 +96,7 @@ static void *get_unpoisoned_check_neighbors( void *vptr, const char* file, int l
     UMM_CRITICAL_DECL(id_poison);
     uint16_t c;
     bool poison = false;
-    umm_heap_context_t *_context = umm_get_ptr_context( v_ptr );
+    umm_heap_context_t *_context = umm_get_ptr_context( vptr );
     if (NULL == _context) {
       panic();
       return NULL;

diff --git a/cores/esp8266/umm_malloc/umm_local.h b/cores/esp8266/umm_malloc/umm_local.h
@@ -59,6 +59,9 @@ struct UMM_HEAP_CONTEXT {
   void *heap_end;
 #if (!defined(UMM_INLINE_METRICS) && defined(UMM_STATS)) || defined(UMM_STATS_FULL)
   UMM_STATISTICS stats;
+#endif
+#ifdef UMM_INFO
+  UMM_HEAP_INFO info;
 #endif
   unsigned short int numblocks;
   unsigned char id;

diff --git a/cores/esp8266/umm_malloc/umm_malloc.cpp b/cores/esp8266/umm_malloc/umm_malloc.cpp
@@ -449,7 +449,7 @@ void umm_init_common( size_t id, void *start_addr, size_t size, bool zero ) {
   // post-crash discovery.
   if (zero) {
   	memset(_context->heap, 0x00, size);
-#if defined(UMM_STATS) || defined(UMM_STATS_FULL)
+#if (!defined(UMM_INLINE_METRICS) && defined(UMM_STATS)) || defined(UMM_STATS_FULL)
     memset(&_context->stats, 0x00, sizeof(_context->stats));
 #endif
 

diff --git a/cores/esp8266/umm_malloc/umm_malloc_cfg.h b/cores/esp8266/umm_malloc/umm_malloc_cfg.h
@@ -195,9 +195,9 @@ extern char _heap_start[];
 /* -------------------------------------------------------------------------- */
 
 #ifdef UMM_INLINE_METRICS
-  #define UMM_FRAGMENTATION_METRIC_INIT() umm_fragmentation_metric_init()
-  #define UMM_FRAGMENTATION_METRIC_ADD(c) umm_fragmentation_metric_add(c)
-  #define UMM_FRAGMENTATION_METRIC_REMOVE(c) umm_fragmentation_metric_remove(c)
+  #define UMM_FRAGMENTATION_METRIC_INIT() umm_fragmentation_metric_init(_context)
+  #define UMM_FRAGMENTATION_METRIC_ADD(c) umm_fragmentation_metric_add(_context, c)
+  #define UMM_FRAGMENTATION_METRIC_REMOVE(c) umm_fragmentation_metric_remove(_context, c)
   #ifndef UMM_INFO
   #define UMM_INFO
   #endif
@@ -231,14 +231,14 @@ extern char _heap_start[];
     unsigned int freeBlocksSquared;
 #ifdef UMM_INLINE_METRICS
     size_t oom_count;
-    #define UMM_OOM_COUNT ummHeapInfo.oom_count
-    #define UMM_FREE_BLOCKS ummHeapInfo.freeBlocks
+    #define UMM_OOM_COUNT info.oom_count
+    #define UMM_FREE_BLOCKS info.freeBlocks
 #endif
     unsigned int maxFreeContiguousBlocks;
   }
   UMM_HEAP_INFO;
 
-  extern UMM_HEAP_INFO ummHeapInfo;
+  // extern UMM_HEAP_INFO ummHeapInfo;
 
   extern ICACHE_FLASH_ATTR void *umm_info( void *ptr, bool force );
 #ifdef UMM_INLINE_METRICS
@@ -250,12 +250,18 @@ extern char _heap_start[];
   extern ICACHE_FLASH_ATTR size_t umm_max_block_size( void );
   extern ICACHE_FLASH_ATTR int umm_usage_metric( void );
   extern ICACHE_FLASH_ATTR int umm_fragmentation_metric( void );
+  extern ICACHE_FLASH_ATTR size_t umm_free_heap_size_core( void );
+  extern ICACHE_FLASH_ATTR size_t umm_max_block_size_core( void );
+  extern ICACHE_FLASH_ATTR int umm_fragmentation_metric_core( void );
 #else
   #define umm_info(p,b)
   #define umm_free_heap_size() (0)
   #define umm_max_block_size() (0)
   #define umm_fragmentation_metric() (0)
   #define umm_usage_metric() (0)
+  #define umm_free_heap_size_core() (0)
+  #define umm_max_block_size_core() (0)
+  #define umm_fragmentation_metric_core() (0)
 #endif
 
 struct UMM_HEAP_CONTEXT;