api reworked, +example

Author: d-a-v

cores/esp8266/Esp-frag.cpp

@@ -23,18 +23,26 @@
 #include "coredecls.h"
 #include "Esp.h"
 
-uint8_t EspClass::getHeapFragmentation (uint32_t* freeHeap, uint16_t* maxBlock)
+void EspClass::getHeapStats(uint32_t* free, uint16_t* max, uint8_t* frag)
 {
     // L2 / Euclidian norm of free block sizes.
-    // Having getFreeHeap()=sum(hole-size), un-fragmentation is given by
-    // sqrt(sum(hole-size²)) / sum(hole-size)
+    // Having getFreeHeap()=sum(hole-size), fragmentation is given by
+    // 100 * (1 - sqrt(sum(hole-size²)) / sum(hole-size))
 
     umm_info(NULL, 0);
-    uint32_t block_size = umm_block_size();
+    uint8_t block_size = umm_block_size();
     uint32_t fh = ummHeapInfo.freeBlocks * block_size;
-    if (freeHeap)
-        *freeHeap = fh;
-    if (maxBlock)
-        *maxBlock = ummHeapInfo.maxFreeContiguousBlocks * block_size;
-    return 100 - (sqrt32(ummHeapInfo.ummFreeSize2) * 100) / fh;
+    if (free)
+        *free = fh;
+    if (max)
+        *max = ummHeapInfo.maxFreeContiguousBlocks * block_size;
+    if (frag)
+        *frag = 100 - (sqrt32(ummHeapInfo.ummFreeSize2) * 100) / fh;
+}
+
+uint8_t EspClass::getHeapFragmentation()
+{
+    uint8_t frag;
+    getHeapStats(nullptr, nullptr, &frag);
+    return frag;
 }

cores/esp8266/Esp.cpp

@@ -24,6 +24,7 @@
 #include <memory>
 #include "interrupts.h"
 #include "MD5Builder.h"
+#include "umm_malloc/umm_malloc.h"
 
 extern "C" {
 #include "user_interface.h"
@@ -173,7 +174,7 @@ uint32_t EspClass::getFreeHeap(void)
 
 uint16_t EspClass::getMaxFreeBlockSize(void)
 {
-    return system_get_free_heap_size();
+    return umm_max_block_size();
 }
 
 uint32_t EspClass::getChipId(void)

cores/esp8266/Esp.h

@@ -103,11 +103,12 @@ class EspClass {
         void restart();
 
         uint16_t getVcc();
+        uint32_t getChipId();
+
         uint32_t getFreeHeap();
         uint16_t getMaxFreeBlockSize();
-        uint8_t getHeapFragmentation(uint32_t* freeHeap = nullptr, uint16_t* maxBlock = nullptr); // in %
-
-        uint32_t getChipId();
+        uint8_t getHeapFragmentation(); // in %
+        void getHeapStats(uint32_t* free = nullptr, uint16_t* max = nullptr, uint8_t* frag = nullptr);
 
         const char * getSdkVersion();
         String getCoreVersion();

cores/esp8266/sqrt32.c

@@ -5,8 +5,7 @@
 uint32_t sqrt32 (uint32_t n)
 {
     // http://www.codecodex.com/wiki/Calculate_an_integer_square_root#C
-    // Another very fast algorithm donated by Tristan Muntsinger
-    // ([email protected]) is below.
+    // Another very fast algorithm donated by [email protected]
     // (note: tested across the full 32 bits range, see comment below)
 
     // 15 iterations (c=1<<15)
@@ -25,7 +24,9 @@ uint32_t sqrt32 (uint32_t n)
     }
 }
 
-/* tested with:
+/*
+ * tested with:
+ *
 
 #include <stdio.h>
 #include <stdint.h>
@@ -50,4 +51,6 @@ int main (void)
 
     printf("\n");
 }
-*/
+
+ *
+ */

libraries/esp8266/examples/HeapMetric/HeapMetric.ino

@@ -0,0 +1,80 @@
+
+// nothing else than showing heap metric usage
+// released to public domain
+
+#include <ESP8266WiFi.h>
+
+void stats (const char* what)
+{
+  // we could use getFreeHeap() getMaxFreeBlockSize() and getHeapFragmentation()
+  // or all at once:
+  uint32_t free;
+  uint16_t max;
+  uint8_t frag;
+  ESP.getHeapStats(&free, &max, &frag);
+  
+  Serial.printf("free: %5d - max: %5d - frag: %3d%% <- ", free, max, frag);
+  // %s requires a malloc that could fail, using println instead:
+  Serial.println(what);
+}
+
+void tryit (int blocksize)
+{
+  void** p;
+  int blocks;
+
+  // heap-used ~= blocks*sizeof(void*) + blocks*blocksize
+  blocks = ((ESP.getMaxFreeBlockSize() / (blocksize + sizeof(void*))) + 3) & ~3; // rounded up, multiple of 4
+
+  Serial.printf("\nFilling memory with blocks of %d bytes each\n", blocksize);
+  stats("before");
+
+  p = (void**)malloc(sizeof(void*) * blocks);
+  for (int i = 0; i < blocks; i++)
+    p[i] = malloc(blocksize);
+  stats("array and blocks allocation");
+
+  for (int i = 0; i < blocks; i += 2)
+  {
+    if (p[i])
+      free(p[i]);
+    p[i] = nullptr;
+  }
+  stats("freeing every other blocks");
+
+  for (int i = 0; i < blocks; i += 4)
+  {
+    if (p[i + 1])
+      free(p[i + 1]);
+    p[i + 1] = nullptr;
+  }
+  stats("freeing every other remaining blocks");
+
+  for (int i = 0; i < blocks; i++)
+    if (p[i])
+      free(p[i]);
+  stats("freeing array");
+
+  free(p);
+  stats("after");
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  WiFi.mode(WIFI_OFF);
+
+  tryit(8000);
+  tryit(4000);
+  tryit(2000);
+  tryit(1000);
+  tryit(500);
+  tryit(200);
+  tryit(100);
+  tryit(50);
+  tryit(15);
+}
+
+void loop ()
+{
+}