Merge branch 'master' into gcc9.1

Author: earlephilhower

cores/esp8266/CallBackList.h

@@ -64,7 +64,7 @@ class CallBackList
 	}
 
     template<typename... Args>
-    void execute(Args... params) {
+    int execute(Args... params) {
         for(auto it = std::begin(callBackEventList); it != std::end(callBackEventList); ) {
         	CallBackHandler &handler = *it;
             if (handler->allowRemove() && handler.unique()) {
@@ -75,6 +75,7 @@ class CallBackList
                 ++it;
             }
         }
+        return callBackEventList.size();
     }
 };
 

cores/esp8266/Esp-frag.cpp

@@ -29,20 +29,28 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
     // Having getFreeHeap()=sum(hole-size), fragmentation is given by
     // 100 * (1 - sqrt(sum(hole-size²)) / sum(hole-size))
 
-    umm_info(NULL, 0);
+    umm_info(NULL, false);
     uint8_t block_size = umm_block_size();
-    uint32_t fh = ummHeapInfo.freeBlocks * block_size;
     if (hfree)
-        *hfree = fh;
+        *hfree = ummHeapInfo.freeBlocks * block_size;
     if (hmax)
-        *hmax = ummHeapInfo.maxFreeContiguousBlocks * block_size;
-    if (hfrag)
-        *hfrag = 100 - (sqrt32(ummHeapInfo.freeSize2) * 100) / fh;
+        *hmax = (uint16_t)ummHeapInfo.maxFreeContiguousBlocks * block_size;
+    if (hfrag) {
+      if (ummHeapInfo.freeBlocks) {
+        *hfrag = 100 - (sqrt32(ummHeapInfo.freeBlocksSquared) * 100) / ummHeapInfo.freeBlocks;
+      } else {
+        *hfrag = 0;
+      }
+    }
 }
 
 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
 }

cores/esp8266/core_esp8266_postmortem.cpp

@@ -93,6 +93,18 @@ static void ets_printf_P(const char *str, ...) {
     }
 }
 
+static void cut_here() {
+    ets_putc('\n');
+    for (auto i = 0; i < 15; i++ ) {
+        ets_putc('-');
+    }
+    ets_printf_P(PSTR(" CUT HERE FOR EXCEPTION DECODER "));
+    for (auto i = 0; i < 15; i++ ) {
+        ets_putc('-');
+    }
+    ets_putc('\n');
+}
+
 void __wrap_system_restart_local() {
     register uint32_t sp asm("a1");
     uint32_t sp_dump = sp;
@@ -114,6 +126,8 @@ void __wrap_system_restart_local() {
 
     ets_install_putc1(&uart_write_char_d);
 
+    cut_here();
+
     if (s_panic_line) {
         ets_printf_P(PSTR("\nPanic %S:%d %S"), s_panic_file, s_panic_line, s_panic_func);
         if (s_panic_what) {
@@ -197,6 +211,8 @@ void __wrap_system_restart_local() {
 #endif
     }
 
+    cut_here();
+
     custom_crash_callback( &rst_info, sp_dump + offset, stack_end );
 
     ets_delay_us(10000);

cores/esp8266/heap.cpp

@@ -314,7 +314,7 @@ size_t ICACHE_RAM_ATTR xPortWantedSizeAlign(size_t size)
 
 void system_show_malloc(void)
 {
-    umm_info(NULL, 1);
+    umm_info(NULL, true);
 }
 
 };

cores/esp8266/umm_malloc/dbglog/dbglog.h

@@ -11,7 +11,7 @@
  * ----------------------------------------------------------------------------
  * NOTE WELL that this file may be included multiple times - this allows you
  * to set the trace level #define DBGLOG_LEVEL x
- * 
+ *
  * To update which of the DBGLOG macros are compiled in, you must redefine the
  * DBGLOG_LEVEL macro and the inlcude the dbglog.h file again, like this:
  *
@@ -57,6 +57,8 @@
 #  define DBGLOG_FUNCTION printf
 #endif
 
+#define DBGLOG_32_BIT_PTR(x) ((uint32_t)(((uintptr_t)(x)) & 0xffffffff))
+
 /* ------------------------------------------------------------------------- */
 
 #if DBGLOG_LEVEL >= 6

cores/esp8266/umm_malloc/umm_info.c

@@ -2,6 +2,12 @@
 
 #ifdef UMM_INFO
 
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include <math.h>
+
 /* ----------------------------------------------------------------------------
  * One of the coolest things about this little library is that it's VERY
  * easy to get debug information about the memory heap by simply iterating
@@ -19,15 +25,15 @@
 
 UMM_HEAP_INFO ummHeapInfo;
 
-void *umm_info( void *ptr, int force ) {
+void *umm_info( void *ptr, bool force ) {
   UMM_CRITICAL_DECL(id_info);
 
-  unsigned short int blockNo = 0;
-
-  if (umm_heap == NULL) {
+  if(umm_heap == NULL) {
     umm_init();
   }
 
+  uint16_t blockNo = 0;
+
   /* Protect the critical section... */
   UMM_CRITICAL_ENTRY(id_info);
 
@@ -40,7 +46,7 @@ void *umm_info( void *ptr, int force ) {
   DBGLOG_FORCE( force, "\n" );
   DBGLOG_FORCE( force, "+----------+-------+--------+--------+-------+--------+--------+\n" );
   DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5d|NF %5d|PF %5d|\n",
-      (unsigned long)(&UMM_BLOCK(blockNo)),
+      DBGLOG_32_BIT_PTR(&UMM_BLOCK(blockNo)),
       blockNo,
       UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
       UMM_PBLOCK(blockNo),
@@ -67,21 +73,18 @@ void *umm_info( void *ptr, int force ) {
     if( UMM_NBLOCK(blockNo) & UMM_FREELIST_MASK ) {
       ++ummHeapInfo.freeEntries;
       ummHeapInfo.freeBlocks += curBlocks;
-      ummHeapInfo.freeSize2 += (unsigned int)curBlocks
-                              * (unsigned int)sizeof(umm_block)
-                              * (unsigned int)curBlocks
-                              * (unsigned int)sizeof(umm_block);
+      ummHeapInfo.freeBlocksSquared += (curBlocks * curBlocks);
 
       if (ummHeapInfo.maxFreeContiguousBlocks < curBlocks) {
         ummHeapInfo.maxFreeContiguousBlocks = curBlocks;
       }
 
       DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5u|NF %5d|PF %5d|\n",
-          (unsigned long)(&UMM_BLOCK(blockNo)),
+          DBGLOG_32_BIT_PTR(&UMM_BLOCK(blockNo)),
           blockNo,
           UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
           UMM_PBLOCK(blockNo),
-          (unsigned int)curBlocks,
+          (uint16_t)curBlocks,
           UMM_NFREE(blockNo),
           UMM_PFREE(blockNo) );
 
@@ -99,33 +102,25 @@ void *umm_info( void *ptr, int force ) {
       ummHeapInfo.usedBlocks += curBlocks;
 
       DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5u|\n",
-          (unsigned long)(&UMM_BLOCK(blockNo)),
+          DBGLOG_32_BIT_PTR(&UMM_BLOCK(blockNo)),
           blockNo,
           UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
           UMM_PBLOCK(blockNo),
-          (unsigned int)curBlocks );
+          (uint16_t)curBlocks );
     }
 
     blockNo = UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK;
   }
 
   /*
-   * Update the accounting totals with information from the last block, the
-   * rest must be free!
+   * The very last block is used as a placeholder to indicate that
+   * there are no more blocks in the heap, so it cannot be used
+   * for anything - at the same time, the size of this block must
+   * ALWAYS be exactly 1 !
    */
 
-  {
-    size_t curBlocks = UMM_NUMBLOCKS-blockNo;
-    ummHeapInfo.freeBlocks  += curBlocks;
-    ummHeapInfo.totalBlocks += curBlocks;
-
-    if (ummHeapInfo.maxFreeContiguousBlocks < curBlocks) {
-      ummHeapInfo.maxFreeContiguousBlocks = curBlocks;
-    }
-  }
-
   DBGLOG_FORCE( force, "|0x%08lx|B %5d|NB %5d|PB %5d|Z %5d|NF %5d|PF %5d|\n",
-      (unsigned long)(&UMM_BLOCK(blockNo)),
+      DBGLOG_32_BIT_PTR(&UMM_BLOCK(blockNo)),
       blockNo,
       UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
       UMM_PBLOCK(blockNo),
@@ -147,7 +142,13 @@ void *umm_info( void *ptr, int force ) {
 
   DBGLOG_FORCE( force, "+--------------------------------------------------------------+\n" );
 
+  DBGLOG_FORCE( force, "Usage Metric:               %5d\n", umm_usage_metric());
+  DBGLOG_FORCE( force, "Fragmentation Metric:       %5d\n", umm_fragmentation_metric());
+
+  DBGLOG_FORCE( force, "+--------------------------------------------------------------+\n" );
+
 #if defined(UMM_STATS) || defined(UMM_STATS_FULL)
+#if !defined(UMM_INLINE_METRICS)
   if (ummHeapInfo.freeBlocks == ummStats.free_blocks) {
       DBGLOG_FORCE( force, "heap info Free blocks and heap statistics Free blocks match.\n");
   } else {
@@ -156,6 +157,7 @@ void *umm_info( void *ptr, int force ) {
           ummStats.free_blocks  );
   }
   DBGLOG_FORCE( force, "+--------------------------------------------------------------+\n" );
+#endif
 
   print_stats(force);
 #endif
@@ -169,17 +171,74 @@ void *umm_info( void *ptr, int force ) {
 /* ------------------------------------------------------------------------ */
 
 size_t umm_free_heap_size( void ) {
-  umm_info(NULL, 0);
+#ifndef UMM_INLINE_METRICS
+  umm_info(NULL, false);
+#endif
   return (size_t)ummHeapInfo.freeBlocks * sizeof(umm_block);
 }
 
+//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( void ) {
-  umm_info(NULL, 0);
+  umm_info(NULL, false);
   return ummHeapInfo.maxFreeContiguousBlocks * sizeof(umm_block);
 }
 
-/* ------------------------------------------------------------------------ */
+/*
+  Without build option UMM_INLINE_METRICS, calls to umm_usage_metric() or
+  umm_fragmentation_metric() must to be preceeded by a call to umm_info(NULL, false)
+  for updated results.
+*/
+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));
 
+  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) {
+      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)));
+  }
+}
+
+#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_add( 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);
+}
+
+static void umm_fragmentation_metric_remove( 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);
+}
+#endif // UMM_INLINE_METRICS
+
+/* ------------------------------------------------------------------------ */
 #endif
 
 #endif  // defined(BUILD_UMM_MALLOC_C)