Statistics Module

The statistics module allows application, libraries, or drivers to record statistics that can be shown via the Newtmgr tool and console.

This allows easy integration of statistics for troubleshooting, maintenance, and usage monitoring.

By creating and registering your statistics, they are automatically included in the Newtmgr shell and console APIs.

Implementation Details

A statistic is an unsigned integer that can be set by the code. When building stats, the implementer chooses the size of the statistic depending on the frequency of the statistic and the resolution required before the counter wraps.

Typically the stats are incremented upon code events; however, they are not limted to that purpose.

Stats are organized into sections. Each section of stats has its own name and can be queried separately through the API. Each section of stats also has its own statistic size, allowing the user to separate large (64-bit) statistics from small (16 bit statistics). NOTE: It is not currently possible to group different size stats into the same section. Please ensure all stats in a section have the same size.

Stats sections are currently stored in a single global stats group.

Statistics are stored in a simple structure which contains a small stats header followed by a list of stats. The stats header contains:

struct stats_hdr {
     char *s_name;
     uint8_t s_size;
     uint8_t s_cnt;
     uint16_t s_pad1;
#if MYNEWT_VAL(STATS_NAMES)
     const struct stats_name_map *s_map;
     int s_map_cnt;
#endif
     STAILQ_ENTRY(stats_hdr) s_next;
 };

The fields define with in the #if MYNEWT_VAL(STATS_NAME) directive are only inincluded when the STATS_NAMES syscfg setting is set to 1 and enables use statistic names.

Enabling Statistic Names

By default, statistics are queried by number. You can use the STATS_NAMES syscfg setting to enable statistic names and view the results by name. Enabling statistic names provides better descriptions in the reported statistics, but takes code space to store the strings within the image.

To enable statistic names, set the STATS_NAMES value to 1 in the application syscfg.yml file or use the newt target set command to set the syscfg setting value. Here are examples for each method:

Method 1 - Set the value in the application syscfg.yml files:

# Package: apps/myapp

syscfg.vals:
    STATS_NAMES: 1

Method 2 - Set the target syscfg variable:

newt target set myapp syscfg=STATS_NAMES=1

Note: This newt target set command only sets the syscfg variable for the STATS_NAMES setting as an example. For your target, you should set the syscfg variable with the other settings that you want to override.

Adding Stats to your code.

Creating new stats table requires the following steps.

• Include the stats header file

• Define a stats section

• Declare an instance of the section

• Define the stat sections names table

• Implement stat in your code

• Initialize the stats

• Register the stats

Include the stats header file

Add the stats library to your pkg.yml file for your package or app by adding this line to your package dependencies.

pkg.deps:
    - "@apache-mynewt-core/sys/stats"

Add this include directive to code files using the stats library.

#include <stats/stats.h>

Define a stats section

You must use the stats.h macros to define your stats table. A stats section definition looks like this.

STATS_SECT_START(my_stat_section)
    STATS_SECT_ENTRY(attempt_stat)
    STATS_SECT_ENTRY(error_stat)
STATS_SECT_END

In this case we chose to make the stats 32-bits each. stats.h supports three different stats sizes through the following macros:

• STATS_SIZE_16 – stats are 16 bits (wraps at 65536)

• STATS_SIZE_32 – stats are 32 bits (wraps at 4294967296)

• STATS_SIZE_64 – stats are 64-bits

When this compiles/pre-processes, it produces a structure definition like this

struct stats_my_stat_section {
    struct stats_hdr s_hdr;
    uint32_t sattempt_stat;
    uint32_t serror_stat;
};

You can see that the defined structure has a small stats structure header and the two stats we have defined.

Depending on whether these stats are used in multiple modules, you may need to include this definition in a header file.

Declaring a variable to hold the stats

Declare the global variable to hold your statistics. Since it is possible to have multiple copies of the same section (for example a stat section for each of 5 identical peripherals), the variable name of the stats section must be unique.

STATS_SECT_DECL(my_stat_section) g_mystat;

Again, if your stats section is used in multiple C files you will need to include the above definition in one of the C files and ‘extern’ this declaration in your header file.

extern STATS_SECT_DECL(my_stat_section) g_mystat;

Define the stats section name table

Whether or not you have STATS_NAMES enabled, you must define a stats name table. If STATS_NAMES is not enabled, this will not take any code space or image size.

/* define a few stats for querying */
STATS_NAME_START(my_stat_section)
    STATS_NAME(my_stat_section, attempt_stat)
    STATS_NAME(my_stat_section, error_stat)
STATS_NAME_END(my_stat_section)

When compiled by the preprocessor, it creates a structure that looks like this.

struct stats_name_map g_stats_map_my_stat_section[] = {
    { __builtin_offsetof (struct stats_my_stat_section, sattempt_stat), "attempt_stat" },
    { __builtin_offsetof (struct stats_my_stat_section, serror_stat), "error_stat" },
};

This table will allow the UI components to find a nice string name for the stat.

Implement stats in your code.

You can use the STATS_INC or STATS_INCN macros to increment your statistics within your C-code. For example, your code may do this:

STATS_INC(g_mystat, attempt_stat);
rc = do_task();
if(rc == ERR) {
    STATS_INC(g_mystat, error_stat);
}

Initialize the statistics

You must initialize the stats so they can be operated on by the stats library. As per our example above, it would look like the following.

This tells the system how large each statistic is and the number of statistics in the section. It also initialize the name information for the statistics if enabled as shown above.

rc = stats_init(
    STATS_HDR(g_mystat),
    STATS_SIZE_INIT_PARMS(g_mystat, STATS_SIZE_32),
    STATS_NAME_INIT_PARMS(my_stat_section));
assert(rc == 0);

Register the statistic section

If you want the system to know about your stats, you must register them.

rc = stats_register("my_stats", STATS_HDR(g_mystat));
assert(rc == 0);

There is also a method that does initialization and registration at the same time, called stats_init_and_reg.

Retrieving stats through console or Newtmgr

If you enable console in your project you can see stats through the serial port defined.

This is the stats as shown from the example above with names enabled.

stat my_stats
12274:attempt_stat: 3
12275:error_stat: 0

This is the stats as shown from the example without names enabled.

stat my_stats
29149:s0: 3
29150:s1: 0

A note on multiple stats sections

If you are implementing a device with multiple instances, you may want multiple stats sections with the exact same format.

For example, suppose I write a driver for an external distance sensor. My driver supports up to 5 sensors and I want to record the stats of each device separately.

This works identically to the example above, except you would need to register each one separately with a unique name. The stats system will not let two sections be entered with the same name.

API

Defines

STATS_SECT_DECL(__name)

STATS_SECT_START(__name)

STATS_SECT_END

STATS_SECT_VAR(__var)

STATS_HDR(__sectname)

STATS_SIZE_16

STATS_SIZE_32

STATS_SIZE_64

STATS_SECT_ENTRY(__var)

STATS_SECT_ENTRY16(__var)

STATS_SECT_ENTRY32(__var)

STATS_SECT_ENTRY64(__var)

STATS_RESET(__var)

STATS_SIZE_INIT_PARMS(__sectvarname, __size)

STATS_GET(__sectvarname, __var)

STATS_INC(__sectvarname, __var)

STATS_INCN(__sectvarname, __var, __n)

STATS_CLEAR(__sectvarname, __var)

STATS_NAME_MAP_NAME(__sectname)

STATS_NAME_START(__sectname)

STATS_NAME(__sectname, __entry)

STATS_NAME_END(__sectname)

STATS_NAME_INIT_PARMS(__name)

Typedefs

typedef int (*stats_walk_func_t)(struct stats_hdr*, void*, char*, uint16_t)

typedef int (*stats_group_walk_func_t)(struct stats_hdr*, void*)

Functions

int stats_init(struct stats_hdr *shdr, uint8_t size, uint8_t cnt, const struct stats_name_map *map, uint8_t map_cnt)

int stats_register(char *name, struct stats_hdr *shdr)

int stats_init_and_reg(struct stats_hdr *shdr, uint8_t size, uint8_t cnt, const struct stats_name_map *map, uint8_t map_cnt, char *name)

void stats_reset(struct stats_hdr *shdr)

int stats_walk(struct stats_hdr*, stats_walk_func_t, void*)

int stats_group_walk(stats_group_walk_func_t, void*)

struct stats_hdr *stats_group_find(char *name)

int stats_nmgr_register_group(void)

int stats_shell_register(void)

Variables

uint16_t snm_off

char *snm_name

struct stats_name_map

#include <stats.h>

Public Members

uint16_t snm_off

char *snm_name

struct stats_hdr

#include <stats.h>

Public Functions

STAILQ_ENTRY (stats_hdr) s_next

Public Members

char *s_name

uint8_t s_size

uint8_t s_cnt

uint16_t s_pad1

const struct stats_name_map *s_map

int s_map_cnt