mbed_stats.c

00001 #include "mbed_assert.h"
00002 #include "mbed_stats.h"
00003 #include "mbed_power_mgmt.h"
00004 #include "mbed_version.h"
00005 #include <string.h>
00006 #include <stdlib.h>
00007 
00008 #include "device.h"
00009 #ifdef MBED_CONF_RTOS_PRESENT
00010 #include "cmsis_os2.h"
00011 #include "rtos_idle.h"
00012 #elif defined(MBED_STACK_STATS_ENABLED) || defined(MBED_THREAD_STATS_ENABLED) || defined(MBED_CPU_STATS_ENABLED)
00013 #warning Statistics are currently not supported without the rtos.
00014 #endif
00015 
00016 #if defined(MBED_CPU_STATS_ENABLED) && (!DEVICE_LPTICKER || !DEVICE_SLEEP)
00017 #warning CPU statistics are not supported without low power timer support.
00018 #endif
00019 
00020 void mbed_stats_cpu_get(mbed_stats_cpu_t *stats)
00021 {
00022     MBED_ASSERT(stats != NULL);
00023     memset(stats, 0, sizeof(mbed_stats_cpu_t));
00024 #if defined(MBED_CPU_STATS_ENABLED) && DEVICE_LPTICKER && DEVICE_SLEEP
00025     stats->uptime = mbed_uptime();
00026     stats->idle_time = mbed_time_idle();
00027     stats->sleep_time = mbed_time_sleep();
00028     stats->deep_sleep_time = mbed_time_deepsleep();
00029 #endif
00030 }
00031 
00032 // note: mbed_stats_heap_get defined in mbed_alloc_wrappers.cpp
00033 void mbed_stats_stack_get(mbed_stats_stack_t *stats)
00034 {
00035     MBED_ASSERT(stats != NULL);
00036     memset(stats, 0, sizeof(mbed_stats_stack_t));
00037 
00038 #if defined(MBED_STACK_STATS_ENABLED) && defined(MBED_CONF_RTOS_PRESENT)
00039     uint32_t thread_n = osThreadGetCount();
00040     unsigned i;
00041     osThreadId_t *threads;
00042 
00043     threads = malloc(sizeof(osThreadId_t) * thread_n);
00044     // Don't fail on lack of memory
00045     if (!threads) {
00046         return;
00047     }
00048 
00049     osKernelLock();
00050     thread_n = osThreadEnumerate(threads, thread_n);
00051 
00052     for (i = 0; i < thread_n; i++) {
00053         uint32_t stack_size = osThreadGetStackSize(threads[i]);
00054         stats->max_size += stack_size - osThreadGetStackSpace(threads[i]);
00055         stats->reserved_size += stack_size;
00056         stats->stack_cnt++;
00057     }
00058     osKernelUnlock();
00059 
00060     free(threads);
00061 #endif
00062 }
00063 
00064 size_t mbed_stats_stack_get_each(mbed_stats_stack_t *stats, size_t count)
00065 {
00066     MBED_ASSERT(stats != NULL);
00067     memset(stats, 0, count * sizeof(mbed_stats_stack_t));
00068 
00069     size_t i = 0;
00070 
00071 #if defined(MBED_STACK_STATS_ENABLED) && defined(MBED_CONF_RTOS_PRESENT)
00072     osThreadId_t *threads;
00073 
00074     threads = malloc(sizeof(osThreadId_t) * count);
00075     // Don't fail on lack of memory
00076     if (!threads) {
00077         return 0;
00078     }
00079 
00080     osKernelLock();
00081     count = osThreadEnumerate(threads, count);
00082 
00083     for (i = 0; i < count; i++) {
00084         uint32_t stack_size = osThreadGetStackSize(threads[i]);
00085         stats[i].max_size = stack_size - osThreadGetStackSpace(threads[i]);
00086         stats[i].reserved_size = stack_size;
00087         stats[i].thread_id = (uint32_t)threads[i];
00088         stats[i].stack_cnt = 1;
00089     }
00090     osKernelUnlock();
00091 
00092     free(threads);
00093 #endif
00094 
00095     return i;
00096 }
00097 
00098 size_t mbed_stats_thread_get_each(mbed_stats_thread_t *stats, size_t count)
00099 {
00100     MBED_ASSERT(stats != NULL);
00101     memset(stats, 0, count * sizeof(mbed_stats_thread_t));
00102     size_t i = 0;
00103 
00104 #if defined(MBED_THREAD_STATS_ENABLED) && defined(MBED_CONF_RTOS_PRESENT)
00105     osThreadId_t *threads;
00106 
00107     threads = malloc(sizeof(osThreadId_t) * count);
00108     MBED_ASSERT(threads != NULL);
00109 
00110     osKernelLock();
00111     count = osThreadEnumerate(threads, count);
00112 
00113     for (i = 0; i < count; i++) {
00114         stats[i].id = (uint32_t)threads[i];
00115         stats[i].state = (uint32_t)osThreadGetState(threads[i]);
00116         stats[i].priority = (uint32_t)osThreadGetPriority(threads[i]);
00117         stats[i].stack_size = osThreadGetStackSize(threads[i]);
00118         stats[i].stack_space = osThreadGetStackSpace(threads[i]);
00119         stats[i].name = osThreadGetName(threads[i]);
00120     }
00121     osKernelUnlock();
00122     free(threads);
00123 #endif
00124     return i;
00125 }
00126 
00127 void mbed_stats_sys_get(mbed_stats_sys_t *stats)
00128 {
00129     MBED_ASSERT(stats != NULL);
00130     memset(stats, 0, sizeof(mbed_stats_sys_t));
00131 
00132 #if defined(MBED_SYS_STATS_ENABLED)
00133     stats->os_version = MBED_VERSION;
00134 #if defined(MBED_RAM_START) && defined(MBED_RAM_SIZE)
00135     stats->ram_start[0] = MBED_RAM_START;
00136     stats->ram_size[0] = MBED_RAM_SIZE;
00137 #endif
00138 #if defined(MBED_ROM_START) && defined(MBED_ROM_SIZE)
00139     stats->rom_start[0] = MBED_ROM_START;
00140     stats->rom_size[0] = MBED_ROM_SIZE;
00141 #endif
00142 #if defined(MBED_RAM1_START) && defined(MBED_RAM1_SIZE)
00143     stats->ram_start[1] = MBED_RAM1_START;
00144     stats->ram_size[1] = MBED_RAM1_SIZE;
00145 #endif
00146 #if defined(MBED_RAM2_START) && defined(MBED_RAM2_SIZE)
00147     stats->ram_start[2] = MBED_RAM2_START;
00148     stats->ram_size[2] = MBED_RAM2_SIZE;
00149 #endif
00150 #if defined(MBED_RAM3_START) && defined(MBED_RAM3_SIZE)
00151     stats->ram_start[3] = MBED_RAM3_START;
00152     stats->ram_size[3] = MBED_RAM3_SIZE;
00153 #endif
00154 #if defined(MBED_ROM1_START) && defined(MBED_ROM1_SIZE)
00155     stats->rom_start[1] = MBED_ROM1_START;
00156     stats->rom_size[1] = MBED_ROM1_SIZE;
00157 #endif
00158 #if defined(MBED_ROM2_START) && defined(MBED_ROM2_SIZE)
00159     stats->rom_start[2] = MBED_ROM2_START;
00160     stats->rom_size[2] = MBED_ROM2_SIZE;
00161 #endif
00162 #if defined(MBED_ROM3_START) && defined(MBED_ROM3_SIZE)
00163     stats->rom_start[3] = MBED_ROM3_START;
00164     stats->rom_size[3] = MBED_ROM3_SIZE;
00165 #endif
00166 
00167 #if defined(__CORTEX_M)
00168     stats->cpu_id = SCB->CPUID;
00169 #endif
00170 #if defined(__IAR_SYSTEMS_ICC__)
00171     stats->compiler_id = IAR;
00172     stats->compiler_version = __VER__;
00173 #elif defined(__CC_ARM)
00174     stats->compiler_id = ARM;
00175     stats->compiler_version = __ARMCC_VERSION;
00176 #elif defined(__GNUC__)
00177     stats->compiler_id = GCC_ARM;
00178     stats->compiler_version = (__GNUC__ * 10000 + __GNUC_MINOR__ * 100);
00179 #endif
00180 
00181 #endif
00182     return;
00183 }