[MOS-110] Statistics api for system

Gets data from freertos and prints on frequency change depending
if it's important. Gathering is not costly, printing is though.
For less intrusive checks I would rather disable names gathering
as in worst case scenario it hangs rtos context switching till
thread id is found.

Author: pholat

.gdbinit-1051

@@ -15,3 +15,7 @@ thread 2
 tb main
 b HardFault_Handler
 b _exit
+b abort
+b WDOG1_IRQHandler
+b RTWDOG_IRQHandler
+b IntDefaultHandler

.gitmodules

@@ -106,3 +106,6 @@
 	path = third-party/reedgefs/src
 	url = ../reliance-edge.git
     branch = mudita
+[submodule "third-party/msgpack11/msgpack11"]
+	path = third-party/msgpack11/msgpack11
+	url = https://github.com/ar90n/msgpack11.git

cmake/modules/ProjectConfig.cmake

@@ -24,6 +24,13 @@ else()
     set (LOG_REDIRECT "RTT_JLINK" CACHE INTERNAL "")
 endif()
 
+option(SYSTEM_PROFILE "SYSTEM_PROFILE" OFF)
+if(${SYSTEM_PROFILE} STREQUAL "ON")
+    set(PROF_ON 1 CACHE INTERNAL "")
+else()
+    set(PROF_ON 0 CACHE INTERNAL "")
+endif()
+
 # add CurrentMeasurement enable option
 option(CURRENT_MEASUREMENT "CURRENT_MEASUREMENT" OFF)
 
@@ -72,6 +79,7 @@ set(PROJECT_CONFIG_DEFINITIONS
         USBCDC_ECHO_ENABLED=${USBCDC_ECHO_ENABLED}
         LOG_LUART_ENABLED=${LOG_LUART_ENABLED}
         MAGIC_ENUM_RANGE_MAX=256
+        PROF_ON=${PROF_ON}
         CACHE INTERNAL ""
         )
 

module-bluetooth/Bluetooth/interface/profiles/SCO/SCO.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "SCO.hpp"
@@ -153,7 +153,7 @@ void SCO::SCOImpl::writeToHostEndian(int16_t *buffer, uint8_t *packet, int lengt
 void SCO::SCOImpl::receiveCvsd(uint8_t *packet, uint16_t size)
 {
 
-    std::array<int16_t, AUDIO_BUFFER_LENGTH> audioFrameOut;
+    std::array<int16_t, AUDIO_BUFFER_LENGTH> audioFrameOut{};
 
     if (size > audioFrameOut.size()) {
         LOG_WARN("SCO packet larger than local output buffer - dropping data.");

module-bsp/bsp/common.cpp

@@ -16,5 +16,26 @@ namespace bsp{
                 break;
         }
    }
+
+   uint8_t CpuMHZToLevel(enum CpuFrequencyMHz val)
+   {
+       switch (val) {
+       case CpuFrequencyMHz::Level_0:
+           return 0;
+       case CpuFrequencyMHz::Level_1:
+           return 1;
+       case CpuFrequencyMHz::Level_2:
+           return 2;
+       case CpuFrequencyMHz::Level_3:
+           return 3;
+       case CpuFrequencyMHz::Level_4:
+           return 4;
+       case CpuFrequencyMHz::Level_5:
+           return 5;
+       case CpuFrequencyMHz::Level_6:
+           return 6;
+       }
+       return -1;
+   }
 };
 

module-bsp/bsp/common.hpp

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cstdint>
 namespace bsp
 {
     enum class RetCode{
@@ -24,6 +25,8 @@ namespace bsp
         Level_6 = 528
     };
 
+    uint8_t CpuMHZToLevel(enum CpuFrequencyMHz val);
+
     constexpr auto MHz_frequency_multiplier = 1000000U;
 
     enum class Board{

module-os/CMakeLists.txt

@@ -34,6 +34,9 @@ target_sources(module-os PRIVATE ${SOURCES})
 if(NOT ${SYSTEM_VIEW_ENABLED})
         target_sources(module-os PRIVATE FreeRTOS/tasks.c)
 endif()
+if(${PROF_ON})
+        target_sources(module-os PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/FreeRTOS/prof.c)
+endif()
 
 add_board_subdirectory(board)
 
@@ -80,3 +83,7 @@ if((${PROJECT_TARGET} STREQUAL "TARGET_RT1051") AND (${SYSTEM_VIEW_ENABLED}))
 endif()
 
 target_link_libraries(${PROJECT_NAME} PUBLIC log-api board-config)
+
+if (${ENABLE_TESTS})
+    add_subdirectory(test)
+endif ()

module-os/FreeRTOS/include/task.h

@@ -1408,6 +1408,7 @@ char *pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e9
  * \ingroup TaskUtils
  */
 TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+TaskHandle_t xTaskGetByTCBNumber(UBaseType_t uxTCBNumber ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
 
 /**
  * task.h
@@ -2366,6 +2367,7 @@ void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder, UBas
  * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
  */
 UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+UBaseType_t uxTaskGetTCBNumber(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
 
 /*
  * Set the uxTaskNumber of the task referenced by the xTask parameter to

module-os/FreeRTOS/prof.c

@@ -0,0 +1,98 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "prof.h"
+#include <stdlib.h>
+#include <string.h>
+
+struct prof_pool 
+{
+    struct task_prof_data *pool;
+    unsigned int _overflow_counter;
+    unsigned int _pos;
+
+    struct prof_pool_init_data data;
+    void (*clean)();
+    void (*handle_overflow)(uint32_t id);
+    struct task_prof_data* (*get)(uint32_t id);
+};
+
+
+static struct prof_pool pool;
+
+static void _pool_clean()
+{
+    memset(pool.pool, 0, sizeof(*pool.pool)*pool.data.size);
+    pool._overflow_counter =0;
+    pool._pos = 0;
+}
+
+static void _pool_overflow(uint32_t id)
+{
+    pool._overflow_counter = id;
+}
+
+/// just meant to be fast get of element
+static struct task_prof_data* _pool_get(uint32_t id)
+{
+    if ( pool._pos == pool.data.size ) {
+        pool.handle_overflow(id);
+    }
+    for ( size_t i =0; i < pool.data.size && i != pool._pos; ++i ) {
+        if (id == pool.pool[i].task_TCB_id) {
+            return &pool.pool[i];
+        }
+    }
+    struct task_prof_data* p = &pool.pool[pool._pos];
+    pool._pos++;
+    return p;
+}
+
+
+
+void prof_pool_init(struct prof_pool_init_data init)
+{
+    pool.data = init;
+    pool.clean = _pool_clean;
+    pool.handle_overflow = _pool_overflow;
+    pool.get = _pool_get;
+
+    pool.pool = (struct task_prof_data *)(malloc(sizeof(struct task_prof_data)*pool.data.size));
+    pool.clean();
+}
+
+void prof_pool_deinit()
+{
+    free(pool.pool);
+    pool.pool = NULL;
+}
+
+
+struct prof_pool_init_data prof_pool_get_data()
+{
+    return pool.data;
+}
+
+void prof_pool_data_set(uint8_t ts, uint32_t id)
+{
+    struct task_prof_data *what = pool.get(id);
+    if ( what == NULL) {
+        return;
+    }
+    what->task_TCB_id=id;
+    what->exec_time += ts;
+    ++(what->switches);
+}
+
+unsigned int prof_pool_overflow()
+{
+    return pool._overflow_counter;
+}
+
+unsigned int prof_pool_flush(struct task_prof_data *mem, size_t cap)
+{
+    unsigned int to_ret = pool._overflow_counter;
+    memcpy(mem, pool.pool, cap * (sizeof(struct task_prof_data)));
+    pool.clean();
+    return to_ret;
+}

module-os/FreeRTOS/prof.h

@@ -0,0 +1,57 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+/// just store what's interesting
+/// 1. do not store TaskHandle_t, id is better - we normally have up to 32 id's as we do not
+///    as we tend to keep up to ~30 threads alive
+/// 2. execution time, the better granulation, the better result
+struct task_prof_data {
+    uint32_t task_TCB_id; /// task TCB id
+    uint32_t exec_time;   /// single task switch execution time summed up in TS
+    uint32_t switches;    /// count how many times it was switched out
+};
+
+/// initialization structure
+struct prof_pool_init_data
+{
+    size_t size;                /// size of the pool, use should have linear eficiency
+};
+
+#if PROF_ON
+
+/// initialization of pool to store switch data
+void prof_pool_init(struct prof_pool_init_data init);
+void prof_pool_deinit();
+struct prof_pool_init_data prof_pool_get_data();
+
+/// get next available slot from the pool
+/// struct task_prof_data* prof_pool_get_next();
+/// set the element
+void prof_pool_data_set(uint8_t ts, uint32_t id);
+
+/// mark if overflow happened
+unsigned int prof_pool_overflow();
+
+/// to `mem` flush up to `cap` data - then clean
+/// if passed:
+/// - set used count: how much data was used
+/// - returns overflow count
+/// requires sched lock before running
+unsigned int prof_pool_flush(struct task_prof_data *mem, size_t cap);
+
+#else
+#define prof_pool_data_set(...)
+#endif
+
+#ifdef __cplusplus
+}
+#endif