Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-08 12:37:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Network manager implemented and relatively stable

Browse Source
This commit is contained in:
Sebastien L
2021-12-10 13:07:27 -05:00
parent 81756a7649
commit 63fbc2f645
66 changed files with 4528 additions and 2679 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
components/tools/trace.c Normal file
View File

@@ -0,0 +1,120 @@
#include <stdint.h>
#include "esp_system.h"
#include <string.h>
#include <stdbool.h>
#include "esp_log.h"
#include "freertos/xtensa_api.h"
#include "freertos/FreeRTOSConfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "globdefs.h"
#include "esp_event.h"
#include "trace.h"
static const char TAG[] = "TRACE";
// typedef struct mem_usage_trace_for_thread {
// TaskHandle_t task;
// size_t malloc_int_last;
// size_t malloc_spiram_last;
// size_t malloc_dma_last;
// const char *name;
// SLIST_ENTRY(mem_usage_trace_for_thread) next;
// } mem_usage_trace_for_thread_t;
// static EXT_RAM_ATTR SLIST_HEAD(memtrace, mem_usage_trace_for_thread) s_memtrace;
// mem_usage_trace_for_thread_t* memtrace_get_thread_entry(TaskHandle_t task) {
// if(!task) {
// ESP_LOGE(TAG, "memtrace_get_thread_entry: task is NULL");
// return NULL;
// }
// ESP_LOGD(TAG,"Looking for task %s",STR_OR_ALT(pcTaskGetName(task ), "unknown"));
// mem_usage_trace_for_thread_t* it;
// SLIST_FOREACH(it, &s_memtrace, next) {
// if ( it->task == task ) {
// ESP_LOGD(TAG,"Found task %s",STR_OR_ALT(pcTaskGetName(task ), "unknown"));
// return it;
// }
// }
// return NULL;
// }
// void memtrace_add_thread_entry(TaskHandle_t task) {
// if(!task) {
// ESP_LOGE(TAG, "memtrace_get_thread_entry: task is NULL");
// return ;
// }
// mem_usage_trace_for_thread_t* it = memtrace_get_thread_entry(task);
// if (it) {
// ESP_LOGW(TAG, "memtrace_add_thread_entry: thread already in list");
// return;
// }
// it = (mem_usage_trace_for_thread_t*)malloc_init_external(sizeof(mem_usage_trace_for_thread_t));
// if (!it) {
// ESP_LOGE(TAG, "memtrace_add_thread_entry: malloc failed");
// return;
// }
// it->task = task;
// it->malloc_int_last = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
// it->malloc_spiram_last = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
// it->malloc_dma_last = heap_caps_get_free_size(MALLOC_CAP_DMA);
// it->name = pcTaskGetName(task);
// SLIST_INSERT_HEAD(&s_memtrace, it, next);
// return;
// }
// void memtrace_print_delta(){
// TaskHandle_t task = xTaskGetCurrentTaskHandle();
// mem_usage_trace_for_thread_t* it = memtrace_get_thread_entry(task);
// if (!it) {
// memtrace_add_thread_entry(task);
// ESP_LOGW(TAG, "memtrace_print_delta: added new entry for task %s",STR_OR_ALT(pcTaskGetName(task ), "unknown"));
// return;
// }
// size_t malloc_int_delta = heap_caps_get_free_size(MALLOC_CAP_INTERNAL) - it->malloc_int_last;
// size_t malloc_spiram_delta = heap_caps_get_free_size(MALLOC_CAP_SPIRAM) - it->malloc_spiram_last;
// size_t malloc_dma_delta = heap_caps_get_free_size(MALLOC_CAP_DMA) - it->malloc_dma_last;
// ESP_LOG(TAG, "Heap internal:%zu (min:%zu) external:%zu (min:%zu) dma:%zu (min:%zu)",
// heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
// heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL),
// heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
// heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM),
// heap_caps_get_free_size(MALLOC_CAP_DMA),
// heap_caps_get_minimum_free_size(MALLOC_CAP_DMA));
// ESP_LOGW(TAG, "memtrace_print_delta: %s: malloc_int_delta=%d, malloc_spiram_delta=%d, malloc_dma_delta=%d",
// STR_OR_ALT(it->name, "unknown"),
// malloc_int_delta,
// malloc_spiram_delta,
// malloc_dma_delta);
// it->malloc_int_last = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
// it->malloc_spiram_last = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
// it->malloc_dma_last = heap_caps_get_free_size(MALLOC_CAP_DMA);
// }
size_t malloc_int = 0;
size_t malloc_spiram =0;
size_t malloc_dma = 0;
void memtrace_print_delta(const char * msg, const char * tag, const char * function){
size_t malloc_int_delta = heap_caps_get_free_size(MALLOC_CAP_INTERNAL) - malloc_int;
size_t malloc_spiram_delta = heap_caps_get_free_size(MALLOC_CAP_SPIRAM) - malloc_spiram;
size_t malloc_dma_delta = heap_caps_get_free_size(MALLOC_CAP_DMA) - malloc_dma;
ESP_LOGW(TAG, "Heap internal:%zu (min:%zu)(chg:%d)/external:%zu (min:%zu)(chg:%d)/dma:%zu (min:%zu)(chg:%d) : %s%s%s%s%s",
heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL),
malloc_int_delta,
heap_caps_get_free_size(MALLOC_CAP_SPIRAM),
heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM),
malloc_spiram_delta,
heap_caps_get_free_size(MALLOC_CAP_DMA),
heap_caps_get_minimum_free_size(MALLOC_CAP_DMA),
malloc_dma_delta,
STR_OR_BLANK(tag),
tag?" ":"",
STR_OR_BLANK(function),
function?" ":"",
STR_OR_BLANK(msg)
);
malloc_int = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
malloc_spiram = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
malloc_dma = heap_caps_get_free_size(MALLOC_CAP_DMA);
}