diff --git a/applications/services/cli/cli_commands.c b/applications/services/cli/cli_commands.c index 43f1c01c4..7bf86c90c 100644 --- a/applications/services/cli/cli_commands.c +++ b/applications/services/cli/cli_commands.c @@ -382,37 +382,69 @@ void cli_command_led(Cli* cli, FuriString* args, void* context) { furi_record_close(RECORD_NOTIFICATION); } -void cli_command_ps(Cli* cli, FuriString* args, void* context) { +static void cli_command_top(Cli* cli, FuriString* args, void* context) { UNUSED(cli); - UNUSED(args); UNUSED(context); - const uint8_t threads_num_max = 32; - FuriThreadId threads_ids[threads_num_max]; - uint32_t thread_num = furi_thread_enumerate(threads_ids, threads_num_max); - printf( - "%-17s %-20s %-5s %-13s %-6s %-8s %s\r\n", - "AppID", - "Name", - "Prio", - "Stack start", - "Heap", - "Stack", - "Stack min free"); - for(uint8_t i = 0; i < thread_num; i++) { - TaskControlBlock* tcb = (TaskControlBlock*)threads_ids[i]; - size_t thread_heap = memmgr_heap_get_thread_memory(threads_ids[i]); + int interval = 1000; + args_read_int_and_trim(args, &interval); + + FuriThreadList* thread_list = furi_thread_list_alloc(); + while(!cli_cmd_interrupt_received(cli)) { + uint32_t tick = furi_get_tick(); + furi_thread_enumerate(thread_list); + + if(interval) printf("\e[2J\e[0;0f"); // Clear display and return to 0 + + uint32_t uptime = tick / furi_kernel_get_tick_frequency(); printf( - "%-17s %-20s %-5d 0x%-11lx %-6zu %-8lu %-8lu\r\n", - furi_thread_get_appid(threads_ids[i]), - furi_thread_get_name(threads_ids[i]), - furi_thread_get_priority(threads_ids[i]), - (uint32_t)tcb->pxStack, - thread_heap == MEMMGR_HEAP_UNKNOWN ? 0u : thread_heap, - (uint32_t)(tcb->pxEndOfStack - tcb->pxStack + 1) * sizeof(StackType_t), - furi_thread_get_stack_space(threads_ids[i])); + "Threads: %zu, Uptime: %luh%lum%lus\r\n", + furi_thread_list_size(thread_list), + uptime / 60 / 60, + uptime / 60 % 60, + uptime % 60); + + printf( + "Heap: total %zu, free %zu, minimum %zu, max block %zu\r\n\r\n", + memmgr_get_total_heap(), + memmgr_get_free_heap(), + memmgr_get_minimum_free_heap(), + memmgr_heap_get_max_free_block()); + + printf( + "%-17s %-20s %-10s %5s %12s %6s %10s %7s %5s\r\n", + "AppID", + "Name", + "State", + "Prio", + "Stack start", + "Stack", + "Stack Min", + "Heap", + "CPU"); + + for(size_t i = 0; i < furi_thread_list_size(thread_list); i++) { + const FuriThreadListItem* item = furi_thread_list_get_at(thread_list, i); + printf( + "%-17s %-20s %-10s %5d 0x%08lx %6lu %10lu %7zu %5.1f\r\n", + item->app_id, + item->name, + item->state, + item->priority, + item->stack_address, + item->stack_size, + item->stack_min_free, + item->heap, + (double)item->cpu); + } + + if(interval > 0) { + furi_delay_ms(interval); + } else { + break; + } } - printf("\r\nTotal: %lu", thread_num); + furi_thread_list_free(thread_list); } void cli_command_free(Cli* cli, FuriString* args, void* context) { @@ -472,7 +504,7 @@ void cli_commands_init(Cli* cli) { cli_add_command(cli, "date", CliCommandFlagParallelSafe, cli_command_date, NULL); cli_add_command(cli, "log", CliCommandFlagParallelSafe, cli_command_log, NULL); cli_add_command(cli, "sysctl", CliCommandFlagDefault, cli_command_sysctl, NULL); - cli_add_command(cli, "ps", CliCommandFlagParallelSafe, cli_command_ps, NULL); + cli_add_command(cli, "top", CliCommandFlagParallelSafe, cli_command_top, NULL); cli_add_command(cli, "free", CliCommandFlagParallelSafe, cli_command_free, NULL); cli_add_command(cli, "free_blocks", CliCommandFlagParallelSafe, cli_command_free_blocks, NULL); diff --git a/documentation/AppManifests.md b/documentation/AppManifests.md index b612df1b7..98a38ffd8 100644 --- a/documentation/AppManifests.md +++ b/documentation/AppManifests.md @@ -36,7 +36,7 @@ Only two parameters are mandatory: **appid** and **apptype**. Others are optiona - **requires**: list of application IDs to include in the build configuration when the current application is referenced in the list of applications to build. - **conflicts**: list of application IDs with which the current application conflicts. If any of them is found in the constructed application list, `fbt` will abort the firmware build process. - **provides**: functionally identical to **_requires_** field. -- **stack_size**: stack size in bytes to allocate for an application on its startup. Note that allocating a stack too small for an app to run will cause a system crash due to stack overflow, and allocating too much stack space will reduce usable heap memory size for apps to process data. _Note: you can use `ps` and `free` CLI commands to profile your app's memory usage._ +- **stack_size**: stack size in bytes to allocate for an application on its startup. Note that allocating a stack too small for an app to run will cause a system crash due to stack overflow, and allocating too much stack space will reduce usable heap memory size for apps to process data. _Note: you can use `top` and `free` CLI commands to profile your app's memory usage._ - **icon**: animated icon name from built-in assets to be used when building the app as a part of the firmware. - **order**: order of an application within its group when sorting entries in it. The lower the order is, the closer to the start of the list the item is placed. _Used for ordering startup hooks and menu entries._ - **sdk_headers**: list of C header files from this app's code to include in API definitions for external applications. diff --git a/furi/core/thread.c b/furi/core/thread.c index 9d330b71b..4e9477712 100644 --- a/furi/core/thread.c +++ b/furi/core/thread.c @@ -1,4 +1,5 @@ #include "thread.h" +#include "thread_list.h" #include "kernel.h" #include "memmgr.h" #include "memmgr_heap.h" @@ -13,6 +14,8 @@ #include #include +#include + #define TAG "FuriThread" #define THREAD_NOTIFY_INDEX (1) // Index 0 is used for stream buffers @@ -547,33 +550,71 @@ uint32_t furi_thread_flags_wait(uint32_t flags, uint32_t options, uint32_t timeo return rflags; } -uint32_t furi_thread_enumerate(FuriThreadId* thread_array, uint32_t array_item_count) { - uint32_t i, count; - TaskStatus_t* task; +static const char* furi_thread_state_name(eTaskState state) { + switch(state) { + case eRunning: + return "Running"; + case eReady: + return "Ready"; + case eBlocked: + return "Blocked"; + case eSuspended: + return "Suspended"; + case eDeleted: + return "Deleted"; + case eInvalid: + return "Invalid"; + default: + return "?"; + } +} - if(FURI_IS_IRQ_MODE() || (thread_array == NULL) || (array_item_count == 0U)) { - count = 0U; - } else { - vTaskSuspendAll(); +bool furi_thread_enumerate(FuriThreadList* thread_list) { + furi_check(thread_list); + furi_check(!FURI_IS_IRQ_MODE()); + + bool result = false; + + vTaskSuspendAll(); + do { + uint32_t tick = furi_get_tick(); + uint32_t count = uxTaskGetNumberOfTasks(); + + TaskStatus_t* task = pvPortMalloc(count * sizeof(TaskStatus_t)); + + if(!task) break; - count = uxTaskGetNumberOfTasks(); - task = pvPortMalloc(count * sizeof(TaskStatus_t)); configRUN_TIME_COUNTER_TYPE total_run_time; + count = uxTaskGetSystemState(task, count, &total_run_time); + for(uint32_t i = 0U; i < count; i++) { + TaskControlBlock* tcb = (TaskControlBlock*)task[i].xHandle; - if(task != NULL) { - count = uxTaskGetSystemState(task, count, &total_run_time); + FuriThreadListItem* item = + furi_thread_list_get_or_insert(thread_list, (FuriThread*)task[i].xHandle); - for(i = 0U; (i < count) && (i < array_item_count); i++) { - thread_array[i] = (FuriThreadId)task[i].xHandle; - } - count = i; + item->thread = (FuriThreadId)task[i].xHandle; + item->app_id = furi_thread_get_appid(item->thread); + item->name = task[i].pcTaskName; + item->priority = task[i].uxCurrentPriority; + item->stack_address = (uint32_t)tcb->pxStack; + size_t thread_heap = memmgr_heap_get_thread_memory(item->thread); + item->heap = thread_heap == MEMMGR_HEAP_UNKNOWN ? 0u : thread_heap; + item->stack_size = (tcb->pxEndOfStack - tcb->pxStack + 1) * sizeof(StackType_t); + item->stack_min_free = furi_thread_get_stack_space(item->thread); + item->state = furi_thread_state_name(task[i].eCurrentState); + item->counter_previous = item->counter_current; + item->counter_current = task[i].ulRunTimeCounter; + item->tick = tick; } - (void)xTaskResumeAll(); vPortFree(task); - } + furi_thread_list_process(thread_list, total_run_time, tick); - return count; + result = true; + } while(false); + (void)xTaskResumeAll(); + + return result; } const char* furi_thread_get_name(FuriThreadId thread_id) { diff --git a/furi/core/thread.h b/furi/core/thread.h index d78272a4d..9c113bd49 100644 --- a/furi/core/thread.h +++ b/furi/core/thread.h @@ -46,6 +46,9 @@ typedef enum { */ typedef struct FuriThread FuriThread; +/** FuriThreadList type */ +typedef struct FuriThreadList FuriThreadList; + /** * @brief Unique thread identifier type (used by the OS kernel). */ @@ -379,13 +382,13 @@ uint32_t furi_thread_flags_get(void); uint32_t furi_thread_flags_wait(uint32_t flags, uint32_t options, uint32_t timeout); /** - * @brief Enumerate all threads. - * - * @param[out] thread_array pointer to the output array (must be properly allocated) - * @param[in] array_item_count output array capacity in elements (NOT bytes) - * @return total thread count (array_item_count or less) + * @brief Enumerate all threads. + * + * @param[out] thread_list pointer to the FuriThreadList container + * + * @return true on success, false otherwise */ -uint32_t furi_thread_enumerate(FuriThreadId* thread_array, uint32_t array_item_count); +bool furi_thread_enumerate(FuriThreadList* thread_list); /** * @brief Get the name of a thread based on its unique identifier. diff --git a/furi/core/thread_list.c b/furi/core/thread_list.c new file mode 100644 index 000000000..65ee11ad3 --- /dev/null +++ b/furi/core/thread_list.c @@ -0,0 +1,110 @@ +#include "thread_list.h" +#include "check.h" + +#include +#include + +ARRAY_DEF(FuriThreadListItemArray, FuriThreadListItem*, M_PTR_OPLIST) // NOLINT + +#define M_OPL_FuriThreadListItemArray_t() ARRAY_OPLIST(FuriThreadListItemArray, M_PTR_OPLIST) + +DICT_DEF2( + FuriThreadListItemDict, + uint32_t, + M_DEFAULT_OPLIST, + FuriThreadListItem*, + M_PTR_OPLIST) // NOLINT + +#define M_OPL_FuriThreadListItemDict_t() \ + DICT_OPLIST(FuriThreadListItemDict, M_DEFAULT_OPLIST, M_PTR_OPLIST) + +struct FuriThreadList { + FuriThreadListItemArray_t items; + FuriThreadListItemDict_t search; + uint32_t runtime_previous; + uint32_t runtime_current; +}; + +FuriThreadList* furi_thread_list_alloc(void) { + FuriThreadList* instance = malloc(sizeof(FuriThreadList)); + + FuriThreadListItemArray_init(instance->items); + FuriThreadListItemDict_init(instance->search); + + return instance; +} + +void furi_thread_list_free(FuriThreadList* instance) { + furi_check(instance); + + FuriThreadListItemArray_it_t it; + FuriThreadListItemArray_it(it, instance->items); + while(!FuriThreadListItemArray_end_p(it)) { + FuriThreadListItem* item = *FuriThreadListItemArray_cref(it); + free(item); + FuriThreadListItemArray_next(it); + } + + FuriThreadListItemDict_clear(instance->search); + FuriThreadListItemArray_clear(instance->items); + + free(instance); +} + +size_t furi_thread_list_size(FuriThreadList* instance) { + furi_check(instance); + return FuriThreadListItemArray_size(instance->items); +} + +FuriThreadListItem* furi_thread_list_get_at(FuriThreadList* instance, size_t position) { + furi_check(instance); + furi_check(position < furi_thread_list_size(instance)); + + return *FuriThreadListItemArray_get(instance->items, position); +} + +FuriThreadListItem* furi_thread_list_get_or_insert(FuriThreadList* instance, FuriThread* thread) { + furi_check(instance); + + FuriThreadListItem** item_ptr = FuriThreadListItemDict_get(instance->search, (uint32_t)thread); + if(item_ptr) { + return *item_ptr; + } + + FuriThreadListItem* item = malloc(sizeof(FuriThreadListItem)); + + FuriThreadListItemArray_push_back(instance->items, item); + FuriThreadListItemDict_set_at(instance->search, (uint32_t)thread, item); + + return item; +} + +void furi_thread_list_process(FuriThreadList* instance, uint32_t runtime, uint32_t tick) { + furi_check(instance); + + instance->runtime_previous = instance->runtime_current; + instance->runtime_current = runtime; + + uint32_t runtime_counter = instance->runtime_current - instance->runtime_previous; + + FuriThreadListItemArray_it_t it; + FuriThreadListItemArray_it(it, instance->items); + while(!FuriThreadListItemArray_end_p(it)) { + FuriThreadListItem* item = *FuriThreadListItemArray_cref(it); + if(item->tick != tick) { + FuriThreadListItemArray_remove(instance->items, it); + (void)FuriThreadListItemDict_erase(instance->search, (uint32_t)item->thread); + free(item); + } else { + uint32_t item_counter = item->counter_current - item->counter_previous; + if(item_counter && item->counter_previous && item->counter_current) { + item->cpu = (float)item_counter / (float)runtime_counter * 100.0f; + if(item->cpu > 200.0f) item->cpu = 0.0f; + } else { + item->cpu = 0.0f; + } + + FuriThreadListItemArray_next(it); + } + } +} diff --git a/furi/core/thread_list.h b/furi/core/thread_list.h new file mode 100644 index 000000000..bf15e4032 --- /dev/null +++ b/furi/core/thread_list.h @@ -0,0 +1,81 @@ +#pragma once + +#include "base.h" +#include "common_defines.h" +#include "thread.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + FuriThread* thread; /**< Pointer to FuriThread, valid while it is running */ + const char* app_id; /**< Thread application id, valid while it is running */ + const char* name; /**< Thread name, valid while it is running */ + FuriThreadPriority priority; /**< Thread priority */ + uint32_t stack_address; /**< Thread stack address */ + size_t heap; /**< Thread heap size if tracking enabled, 0 - otherwise */ + uint32_t stack_size; /**< Thread stack size */ + uint32_t stack_min_free; /**< Thread minimum of the stack size ever reached */ + const char* + state; /**< Thread state, can be: "Running", "Ready", "Blocked", "Suspended", "Deleted", "Invalid" */ + float cpu; /**< Thread CPU usage time in percents (including interrupts happened while running) */ + + // Service variables + uint32_t counter_previous; /**< Thread previous runtime counter */ + uint32_t counter_current; /**< Thread current runtime counter */ + uint32_t tick; /**< Thread last seen tick */ +} FuriThreadListItem; + +/** Anonymous FuriThreadList type */ +typedef struct FuriThreadList FuriThreadList; + +/** Allocate FuriThreadList instance + * + * @return FuriThreadList instance + */ +FuriThreadList* furi_thread_list_alloc(void); + +/** Free FuriThreadList instance + * + * @param instance The FuriThreadList instance to free + */ +void furi_thread_list_free(FuriThreadList* instance); + +/** Get FuriThreadList instance size + * + * @param instance The instance + * + * @return Item count + */ +size_t furi_thread_list_size(FuriThreadList* instance); + +/** Get item at position + * + * @param instance The FuriThreadList instance + * @param[in] position The position of the item + * + * @return The FuriThreadListItem instance + */ +FuriThreadListItem* furi_thread_list_get_at(FuriThreadList* instance, size_t position); + +/** Get item by thread FuriThread pointer + * + * @param instance The FuriThreadList instance + * @param thread The FuriThread pointer + * + * @return The FuriThreadListItem instance + */ +FuriThreadListItem* furi_thread_list_get_or_insert(FuriThreadList* instance, FuriThread* thread); + +/** Process items in the FuriThreadList instance + * + * @param instance The instance + * @param[in] runtime The runtime of the system since start + * @param[in] tick The tick when processing happened + */ +void furi_thread_list_process(FuriThreadList* instance, uint32_t runtime, uint32_t tick); + +#ifdef __cplusplus +} +#endif diff --git a/furi/furi.h b/furi/furi.h index 24e597acf..400cf1d64 100644 --- a/furi/furi.h +++ b/furi/furi.h @@ -16,6 +16,7 @@ #include "core/record.h" #include "core/semaphore.h" #include "core/thread.h" +#include "core/thread_list.h" #include "core/timer.h" #include "core/string.h" #include "core/stream_buffer.h" diff --git a/targets/f18/api_symbols.csv b/targets/f18/api_symbols.csv index fc5d86599..4b40107ce 100644 --- a/targets/f18/api_symbols.csv +++ b/targets/f18/api_symbols.csv @@ -1,5 +1,5 @@ entry,status,name,type,params -Version,+,64.3,, +Version,+,65.0,, Header,+,applications/services/bt/bt_service/bt.h,, Header,+,applications/services/bt/bt_service/bt_keys_storage.h,, Header,+,applications/services/cli/cli.h,, @@ -1594,7 +1594,7 @@ Function,+,furi_thread_alloc_ex,FuriThread*,"const char*, uint32_t, FuriThreadCa Function,-,furi_thread_alloc_service,FuriThread*,"const char*, uint32_t, FuriThreadCallback, void*" Function,-,furi_thread_disable_heap_trace,void,FuriThread* Function,+,furi_thread_enable_heap_trace,void,FuriThread* -Function,+,furi_thread_enumerate,uint32_t,"FuriThreadId*, uint32_t" +Function,+,furi_thread_enumerate,_Bool,FuriThreadList* Function,+,furi_thread_flags_clear,uint32_t,uint32_t Function,+,furi_thread_flags_get,uint32_t, Function,+,furi_thread_flags_set,uint32_t,"FuriThreadId, uint32_t" @@ -1614,6 +1614,12 @@ Function,+,furi_thread_get_state,FuriThreadState,FuriThread* Function,+,furi_thread_get_stdout_callback,FuriThreadStdoutWriteCallback, Function,+,furi_thread_is_suspended,_Bool,FuriThreadId Function,+,furi_thread_join,_Bool,FuriThread* +Function,+,furi_thread_list_alloc,FuriThreadList*, +Function,+,furi_thread_list_free,void,FuriThreadList* +Function,+,furi_thread_list_get_at,FuriThreadListItem*,"FuriThreadList*, size_t" +Function,+,furi_thread_list_get_or_insert,FuriThreadListItem*,"FuriThreadList*, FuriThread*" +Function,+,furi_thread_list_process,void,"FuriThreadList*, uint32_t, uint32_t" +Function,+,furi_thread_list_size,size_t,FuriThreadList* Function,+,furi_thread_resume,void,FuriThreadId Function,+,furi_thread_set_appid,void,"FuriThread*, const char*" Function,+,furi_thread_set_callback,void,"FuriThread*, FuriThreadCallback" diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv index c2e7f59e3..d64571963 100644 --- a/targets/f7/api_symbols.csv +++ b/targets/f7/api_symbols.csv @@ -1,5 +1,5 @@ entry,status,name,type,params -Version,+,64.3,, +Version,+,65.0,, Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,, Header,+,applications/services/bt/bt_service/bt.h,, Header,+,applications/services/bt/bt_service/bt_keys_storage.h,, @@ -1808,7 +1808,7 @@ Function,+,furi_thread_alloc_ex,FuriThread*,"const char*, uint32_t, FuriThreadCa Function,-,furi_thread_alloc_service,FuriThread*,"const char*, uint32_t, FuriThreadCallback, void*" Function,-,furi_thread_disable_heap_trace,void,FuriThread* Function,+,furi_thread_enable_heap_trace,void,FuriThread* -Function,+,furi_thread_enumerate,uint32_t,"FuriThreadId*, uint32_t" +Function,+,furi_thread_enumerate,_Bool,FuriThreadList* Function,+,furi_thread_flags_clear,uint32_t,uint32_t Function,+,furi_thread_flags_get,uint32_t, Function,+,furi_thread_flags_set,uint32_t,"FuriThreadId, uint32_t" @@ -1828,6 +1828,12 @@ Function,+,furi_thread_get_state,FuriThreadState,FuriThread* Function,+,furi_thread_get_stdout_callback,FuriThreadStdoutWriteCallback, Function,+,furi_thread_is_suspended,_Bool,FuriThreadId Function,+,furi_thread_join,_Bool,FuriThread* +Function,+,furi_thread_list_alloc,FuriThreadList*, +Function,+,furi_thread_list_free,void,FuriThreadList* +Function,+,furi_thread_list_get_at,FuriThreadListItem*,"FuriThreadList*, size_t" +Function,+,furi_thread_list_get_or_insert,FuriThreadListItem*,"FuriThreadList*, FuriThread*" +Function,+,furi_thread_list_process,void,"FuriThreadList*, uint32_t, uint32_t" +Function,+,furi_thread_list_size,size_t,FuriThreadList* Function,+,furi_thread_resume,void,FuriThreadId Function,+,furi_thread_set_appid,void,"FuriThread*, const char*" Function,+,furi_thread_set_callback,void,"FuriThread*, FuriThreadCallback" diff --git a/targets/f7/inc/FreeRTOSConfig.h b/targets/f7/inc/FreeRTOSConfig.h index e6233f624..37aac1eb0 100644 --- a/targets/f7/inc/FreeRTOSConfig.h +++ b/targets/f7/inc/FreeRTOSConfig.h @@ -29,13 +29,9 @@ // #define configTOTAL_HEAP_SIZE ((size_t)0) #define configMAX_TASK_NAME_LEN (32) -/* Run-time stats - broken ATM, to be fixed */ -/* #define configGENERATE_RUN_TIME_STATS 1 -#define configRUN_TIME_COUNTER_TYPE uint64_t #define portGET_RUN_TIME_COUNTER_VALUE() (DWT->CYCCNT) #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() -*/ #define configUSE_TRACE_FACILITY 1 #define configUSE_16_BIT_TICKS 0