|
19 | 19 | #include "MemMonitoring.h"
|
20 | 20 |
|
21 | 21 | #include "AppConfig.h"
|
22 |
| -#include "FreeRTOS.h" |
| 22 | +#include <cmsis_os2.h> |
23 | 23 | #include <platform/CHIPDeviceLayer.h>
|
| 24 | +#include <sl_cmsis_os2_common.h> |
24 | 25 |
|
25 |
| -#define BLE_STACK_TASK_NAME "Bluetooth stack" |
26 |
| -#define BLE_LINK_TASK_NAME "Bluetooth linklayer" |
| 26 | +namespace chip { |
| 27 | +namespace DeviceLayer { |
| 28 | +namespace Silabs { |
27 | 29 |
|
28 |
| -static StackType_t monitoringStack[MONITORING_STACK_SIZE_byte / sizeof(StackType_t)]; |
29 |
| -static StaticTask_t monitoringTaskStruct; |
| 30 | +static osThreadId_t sMonitorThreadHandle; |
| 31 | +constexpr uint32_t kMonitorTaskSize = 1024; |
| 32 | +static uint8_t monitorStack[kMonitorTaskSize]; |
| 33 | +static osThread_t sMonitorTaskControlBlock; |
| 34 | +constexpr osThreadAttr_t kMonitorTaskAttr = { .name = "MemMonitor", |
| 35 | + .attr_bits = osThreadDetached, |
| 36 | + .cb_mem = &sMonitorTaskControlBlock, |
| 37 | + .cb_size = osThreadCbSize, |
| 38 | + .stack_mem = monitorStack, |
| 39 | + .stack_size = kMonitorTaskSize, |
| 40 | + .priority = osPriorityLow }; |
30 | 41 |
|
31 | 42 | size_t nbAllocSuccess = 0;
|
32 | 43 | size_t nbFreeSuccess = 0;
|
33 | 44 | size_t largestBlockAllocated = 0;
|
34 | 45 |
|
35 |
| -void MemMonitoring::startHeapMonitoring() |
| 46 | +void MemMonitoring::StartMonitor() |
36 | 47 | {
|
37 |
| - xTaskCreateStatic(HeapMonitoring, "Monitoring", MONITORING_STACK_SIZE_byte / sizeof(StackType_t), NULL, 1, monitoringStack, |
38 |
| - &monitoringTaskStruct); |
| 48 | + sMonitorThreadHandle = osThreadNew(MonitorTask, nullptr, &kMonitorTaskAttr); |
39 | 49 | }
|
40 | 50 |
|
41 |
| -void MemMonitoring::HeapMonitoring(void * pvParameter) |
| 51 | +void MemMonitoring::MonitorTask(void * pvParameter) |
42 | 52 | {
|
| 53 | + uint32_t threadCount = osThreadGetCount(); |
43 | 54 |
|
44 |
| - UBaseType_t appTaskValue; |
45 |
| - UBaseType_t bleEventTaskValue; |
46 |
| - UBaseType_t bleTaskValue; |
47 |
| - UBaseType_t linkLayerTaskValue; |
48 |
| - UBaseType_t openThreadTaskValue; |
49 |
| - UBaseType_t eventLoopTaskValue; |
50 |
| - |
51 |
| - TaskHandle_t eventLoopHandleStruct = xTaskGetHandle(CHIP_DEVICE_CONFIG_CHIP_TASK_NAME); |
52 |
| - TaskHandle_t otTaskHandle = xTaskGetHandle(CHIP_DEVICE_CONFIG_THREAD_TASK_NAME); |
53 |
| - TaskHandle_t appTaskHandle = xTaskGetHandle(APP_TASK_NAME); |
54 |
| - TaskHandle_t bleStackTaskHandle = xTaskGetHandle(BLE_STACK_TASK_NAME); |
55 |
| - TaskHandle_t bleLinkTaskHandle = xTaskGetHandle(BLE_LINK_TASK_NAME); |
56 |
| - TaskHandle_t bleEventTaskHandle = xTaskGetHandle(CHIP_DEVICE_CONFIG_BLE_APP_TASK_NAME); |
57 |
| - |
58 |
| -#if CHIP_SYSTEM_CONFIG_USE_LWIP |
59 |
| - UBaseType_t lwipTaskValue; |
60 |
| - TaskHandle_t lwipHandle = xTaskGetHandle(TCPIP_THREAD_NAME); |
61 |
| -#endif // CHIP_SYSTEM_CONFIG_USE_LWIP |
| 55 | + osThreadId_t * threadIdTable = new osThreadId_t[threadCount]; |
| 56 | + // Forms a table of the active thread ids |
| 57 | + osThreadEnumerate(threadIdTable, threadCount); |
62 | 58 |
|
63 | 59 | while (true)
|
64 | 60 | {
|
65 |
| - appTaskValue = uxTaskGetStackHighWaterMark(appTaskHandle); |
66 |
| - bleEventTaskValue = uxTaskGetStackHighWaterMark(bleEventTaskHandle); |
67 |
| - bleTaskValue = uxTaskGetStackHighWaterMark(bleStackTaskHandle); |
68 |
| - linkLayerTaskValue = uxTaskGetStackHighWaterMark(bleLinkTaskHandle); |
69 |
| - openThreadTaskValue = uxTaskGetStackHighWaterMark(otTaskHandle); |
70 |
| - eventLoopTaskValue = uxTaskGetStackHighWaterMark(eventLoopHandleStruct); |
71 |
| -#if CHIP_SYSTEM_CONFIG_USE_LWIP |
72 |
| - lwipTaskValue = uxTaskGetStackHighWaterMark(lwipHandle); |
73 |
| -#endif // CHIP_SYSTEM_CONFIG_USE_LWIP |
74 | 61 |
|
75 | 62 | SILABS_LOG("=============================");
|
76 |
| - SILABS_LOG(" "); |
77 |
| - SILABS_LOG("Largest Block allocated 0x%x", largestBlockAllocated); |
78 |
| - SILABS_LOG("Number Of Successful Alloc 0x%x", nbAllocSuccess); |
79 |
| - SILABS_LOG("Number Of Successful Frees 0x%x", nbFreeSuccess); |
80 |
| - SILABS_LOG(" "); |
81 |
| - SILABS_LOG("App Task most bytes ever Free 0x%x", (appTaskValue * 4)); |
82 |
| - SILABS_LOG("BLE Event most bytes ever Free 0x%x", (bleEventTaskValue * 4)); |
83 |
| - SILABS_LOG("BLE Stack most bytes ever Free 0x%x", (bleTaskValue * 4)); |
84 |
| - SILABS_LOG("Link Layer Task most bytes ever Free 0x%x", (linkLayerTaskValue * 4)); |
85 |
| - SILABS_LOG("OpenThread Task most bytes ever Free 0x%x", (openThreadTaskValue * 4)); |
86 |
| - SILABS_LOG("Event Loop Task most bytes ever Free 0x%x", (eventLoopTaskValue * 4)); |
87 |
| -#if CHIP_SYSTEM_CONFIG_USE_LWIP |
88 |
| - SILABS_LOG("LWIP Task most bytes ever Free 0x%x", (lwipTaskValue * 4)); |
89 |
| -#endif // CHIP_SYSTEM_CONFIG_USE_LWIP |
90 |
| - SILABS_LOG(" "); |
| 63 | + SILABS_LOG(" "); |
| 64 | + SILABS_LOG("Largest Block allocated %lu B", largestBlockAllocated); |
| 65 | + SILABS_LOG("Number Of Successful Alloc %lu", nbAllocSuccess); |
| 66 | + SILABS_LOG("Number Of Successful Frees %lu", nbFreeSuccess); |
| 67 | + SILABS_LOG(" "); |
| 68 | + |
| 69 | + SILABS_LOG("Thread stack highwatermark "); |
| 70 | + for (uint8_t tIdIndex = 0; tIdIndex < threadCount; tIdIndex++) |
| 71 | + { |
| 72 | + osThreadId_t tId = threadIdTable[tIdIndex]; |
| 73 | + if (tId != sMonitorThreadHandle) // don't print stats for this current debug thread. |
| 74 | + { |
| 75 | + // The smallest amount of free stack space there has been since the thread creation |
| 76 | + SILABS_LOG("\t%-10s : %6lu B", osThreadGetName(tId), osThreadGetStackSpace(tId)); |
| 77 | + } |
| 78 | + } |
| 79 | + |
| 80 | + SILABS_LOG(" "); |
91 | 81 | SILABS_LOG("=============================");
|
92 |
| - vTaskDelay(pdMS_TO_TICKS(5000)); |
| 82 | + // run loop every 5 seconds |
| 83 | + osDelay(osKernelGetTickFreq() * 5); |
93 | 84 | }
|
| 85 | + |
| 86 | + // will never get here. Still, free allocated memory before exiting |
| 87 | + delete threadIdTable; |
94 | 88 | }
|
95 | 89 |
|
| 90 | +} // namespace Silabs |
| 91 | +} // namespace DeviceLayer |
| 92 | +} // namespace chip |
| 93 | + |
96 | 94 | extern "C" void memMonitoringTrackAlloc(void * ptr, size_t size)
|
97 | 95 | {
|
98 | 96 | if (ptr != NULL)
|
99 | 97 | {
|
100 |
| - nbAllocSuccess++; |
101 |
| - if (largestBlockAllocated < size) |
| 98 | + chip::DeviceLayer::Silabs::nbAllocSuccess++; |
| 99 | + if (chip::DeviceLayer::Silabs::largestBlockAllocated < size) |
102 | 100 | {
|
103 |
| - largestBlockAllocated = size; |
| 101 | + chip::DeviceLayer::Silabs::largestBlockAllocated = size; |
104 | 102 | }
|
105 | 103 | }
|
106 | 104 | }
|
107 | 105 |
|
108 | 106 | extern "C" void memMonitoringTrackFree(void * ptr, size_t size)
|
109 | 107 | {
|
110 |
| - nbFreeSuccess++; |
| 108 | + chip::DeviceLayer::Silabs::nbFreeSuccess++; |
111 | 109 | }
|
0 commit comments