FreeRTOS: fix SIGSEV on shutdown by checking if heapTrackingAlive (#197)

On shutdown some global variables are cleaned up. In our case it is the
`allocatedMemory` global variable.

Check if the heap tracking is still possible by logging the bool
variable `heapTrackingAlive` to `false` on destructor. Then we can
ignore heap tracking as the `allocatedMemory` map is already freed.

Co-authored-by: https://github.com/sofar

Author: NeroBurner

sim/FreeRTOS.cpp

@@ -12,39 +12,60 @@ void APP_ERROR_HANDLER(int err) {
 }
 
 namespace {
-  std::unordered_map<void*, size_t> allocatedMemory;
-  size_t currentFreeHeap = configTOTAL_HEAP_SIZE;
-  size_t minimumEverFreeHeap = configTOTAL_HEAP_SIZE;
+  bool heapTrackingAlive = false;
+
+  struct HeapTracking {
+    std::unordered_map<void*, size_t> allocatedMemory;
+    size_t currentFreeHeap = configTOTAL_HEAP_SIZE;
+    size_t minimumEverFreeHeap = configTOTAL_HEAP_SIZE;
+
+    HeapTracking() {
+      heapTrackingAlive = true;
+    }
+
+    ~HeapTracking() {
+      heapTrackingAlive = false;
+    }
+  };
+
+  HeapTracking heapTracking;
 }
 
 void* pvPortMalloc(size_t xWantedSize) {
   void* ptr = malloc(xWantedSize);
-  allocatedMemory[ptr] = xWantedSize;
+  if (!heapTrackingAlive) {
+    return ptr;
+  }
+  heapTracking.allocatedMemory[ptr] = xWantedSize;
 
-  const size_t currentSize =
-    std::accumulate(allocatedMemory.begin(), allocatedMemory.end(), 0, [](const size_t lhs, const std::pair<void*, size_t>& item) {
-      return lhs + item.second;
-    });
+  const size_t currentSize = std::accumulate(heapTracking.allocatedMemory.begin(),
+                                             heapTracking.allocatedMemory.end(),
+                                             0,
+                                             [](const size_t lhs, const std::pair<void*, size_t>& item) {
+                                               return lhs + item.second;
+                                             });
 
-  currentFreeHeap = configTOTAL_HEAP_SIZE - currentSize;
-  minimumEverFreeHeap = std::min(currentFreeHeap, minimumEverFreeHeap);
+  heapTracking.currentFreeHeap = configTOTAL_HEAP_SIZE - currentSize;
+  heapTracking.minimumEverFreeHeap = std::min(heapTracking.currentFreeHeap, heapTracking.minimumEverFreeHeap);
 
   return ptr;
 }
 
 void vPortFree(void* pv) {
-  allocatedMemory.erase(pv);
-  return free(pv);
+  if (heapTrackingAlive) {
+    heapTracking.allocatedMemory.erase(pv);
+  }
+  free(pv);
 }
 
 size_t xPortGetHeapSize(void) {
   return configTOTAL_HEAP_SIZE;
 }
 
 size_t xPortGetFreeHeapSize(void) {
-  return currentFreeHeap;
+  return heapTracking.currentFreeHeap;
 }
 
 size_t xPortGetMinimumEverFreeHeapSize(void) {
-  return minimumEverFreeHeap;
+  return heapTracking.minimumEverFreeHeap;
 }