feature request: Heap traces

[jupe]

Description

• Type: Enhancement
• Related issue: Heap tracking hook #4573, ...
• Priority: Major

Enhancement

Reason to enhance or problem with existing solution
memory traces are good when analysing fragmentation or who is spending memory in very low level (caller level). But it doesn't tell anything about real heap usage or malloc overheads. memory traces are also very heavy because it prints line to stdout every time when some alloc (malloc, free, realloc,..) is called, so it cannot be activated in all cases, e.g. "end-user" applications which start failing if memory traces takes too much cpu/io time.
There is already API to fetch heap state but that is application level API - so application needs interaction to get heap state to get printed out.

Suggested enhancement
If we could have similar feature than memory-trace, which prints heap state every time when it changes so application doesn't need to care about it at all. This approach would be also much more light because heap state doesn't change so often compared to malloc calls (memory traces). Feature could be behind compile time flag so it doesn't affect performance if it is not activated.

This should be quite easy to implement in gcc at least. IAR/armcc might be more complicated.

Pros

• allows to track heap consumption using mbed-traces "in background"
• we could collect memory usage from every test applications without any changes to applications - just by activating it in compiling time (otherwise we have to create dedicated "memory" tests which tells memory consumption only for that use-case, nothing more)
  • all tests we have could benefits from this
• tells exactly how much memory is needed for certain use-case
• we could create common tools (in host side) top of this feature
• could fulfill memory-trace analyse results

Cons
some work.

[ciarmcom]

ARM Internal Ref: MBOTRIAGE-313

[SenRamakri]

Hi @jupe - Please see mbed_stats_heap_get() in https://github.com/ARMmbed/mbed-os/blob/master/platform/mbed_alloc_wrappers.cpp#L54. Is this what you are looking for? If we need to print the heap info periodically, we can use an event loop in application level to print this periodically.

[jupe]

Is this what you are looking for?

no. I'm looking for "background printer" for stats_heap.

If we need to print the heap info periodically, we can use an event loop in application level to print this periodically.

ideas is to have exactly same kind of feature than we have already for mallocs - "background printer" which prints exactly same time when heap is increased. This way we can activate it to any applications we have already just by switching compiler flag on. Note that timing matters - it cannot be separate thread/event queue because then we lose details when it really happens..

[deepikabhavnani]

Related : #7343

[deepikabhavnani]

@jupe -You essentially need combination of memory trace and heaps stats, which is available. User can write there own callback instead of default mbed_mem_trace_default_callback and pass it to mbed_mem_trace_set_callback. You can use mbed_stats_heap_get as a callback.

void mbed_mem_trace_user_callback(uint8_t op, void *res, void *caller, ...)
{
    mbed_stats_heap_t heap_stats;
    mbed_stats_heap_get(&heap_stats);
    /** log / send to nw / analyze heap_stats */
}

int main() {
    
    
    mbed_mem_trace_set_callback(mbed_mem_trace_default_callback);
    while (true) {
        void *p = malloc(50);
        wait(0.5);
        free(p);
        mbed_mem_trace_set_callback(mbed_mem_trace_user_callback);
    }
}

[jupe]

Your propose would need modifications to apps, which are not generic solution. Also it would need extra steps and logic to recognize when heap state changes which also increase cpu usage a bit. Original idea was to integrate this feature somehow to heap handler where solution would be most optimized with minimum impact to execution. Current memory tracing is relatively heavy and is not suitable for all cases but this could be suitable for all. If we could switch on heap traces in all tests we have in one shoot we could start collecting metric about how much heap different scenarios needs by free. Does this make senses?

[deepikabhavnani]

Also it would need extra steps and logic to recognize when heap state changes which also increase cpu usage a bit.

On every heap state change (alloc / free) callback is called.

Original idea was to integrate this feature somehow to heap handler

Please clarify which heap handler are you referring to here?

If we could switch on heap traces in all tests we have in one shoot we could start collecting metric about how much heap different scenarios needs by free

Heap trace is enabled in all tests in Mbed OS repo. We get heap stats at the end of each test in CI.

[deepikabhavnani]

@jupe - Do you have any more concerns with heap trace functionality?