mirror of
https://git.planet-casio.com/Lephenixnoir/libprof.git
synced 2024-12-26 11:33:41 +01:00
109 lines
2.9 KiB
C
109 lines
2.9 KiB
C
//---
|
|
// libprof: A manual profiling library for gint
|
|
//---
|
|
|
|
#ifndef LIBPROF_LIBPROF
|
|
#define LIBPROF_LIBPROF
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
#include <gint/defs/attributes.h>
|
|
|
|
/* This is substituted by CMake at compile-time */
|
|
#define PROF_VERSION "@libprof_VERSION@"
|
|
|
|
//---
|
|
// Initialization
|
|
//---
|
|
|
|
/* prof_init(): Initialize the profiler's timer
|
|
|
|
Starts a timer to count time. libprof automatically selects a TMU and tries
|
|
to use TMU2 before TMU1 before TMU0 so that high-priority interrupts remain
|
|
available, and sets an accurate clock configuration.
|
|
|
|
Returns non-zero if no timer is available. */
|
|
int prof_init(void);
|
|
|
|
/* prof_quit(): Free the profiler's timer */
|
|
void prof_quit(void);
|
|
|
|
//---
|
|
// Runtime time measurement
|
|
//---
|
|
|
|
/* Context object, has an elasped delay and a recursion level. This object can
|
|
be created on the stack of a function that measures its execution time,
|
|
except if the function is recursive, in which case it should be either
|
|
static or global. */
|
|
typedef struct prof_t
|
|
{
|
|
uint32_t rec;
|
|
uint32_t elapsed;
|
|
|
|
} GPACKED(4) prof_t;
|
|
|
|
/* prof_make(): Create a new context object
|
|
A context can be cleared by assigning it prof_make() again. */
|
|
#define prof_make() ((prof_t){ 0, 0 })
|
|
|
|
/* Timer counter */
|
|
extern uint32_t volatile *prof_tcnt;
|
|
|
|
/* prof_enter(): Start counting time for a function
|
|
This macro should be called at the start of the context scope. If the
|
|
function was already executing then the deepest instance in the stack is
|
|
used instead of creating a new counter. */
|
|
#define prof_enter(prof) { \
|
|
if(!(prof).rec++) (prof).elapsed += *prof_tcnt; \
|
|
}
|
|
|
|
/* prof_leave(): Stop counting time for a function
|
|
This should be called at the end of the context scope; it only actually
|
|
stops if there is no deeper instance of the context in the stack. If there
|
|
are not as exactly as many prof_leave()'s as prof_enter()'s then the
|
|
resulting time measure will not be relevant at all. */
|
|
#define prof_leave(prof) { \
|
|
if(!--(prof).rec) (prof).elapsed -= *prof_tcnt; \
|
|
}
|
|
|
|
/* Variant of prof_enter()/prof_leave() for non-recursive contexts */
|
|
#define prof_enter_norec(prof) { \
|
|
(prof).elapsed += *prof_tcnt; \
|
|
}
|
|
#define prof_leave_norec(prof) { \
|
|
(prof).elapsed -= *prof_tcnt; \
|
|
}
|
|
|
|
/* prof_exec(): Measure a single block of code
|
|
This operation can be used when profiling is not required, and instead
|
|
libprof is used to measure the performance of a single bit of code. Use it
|
|
like this:
|
|
|
|
uint32_t elasped_us = prof_exec({
|
|
exec_code();
|
|
}); */
|
|
#define prof_exec(code) ({ \
|
|
prof_t _prof = prof_make(); \
|
|
prof_enter(_prof); \
|
|
code; \
|
|
prof_leave(_prof); \
|
|
prof_time(_prof); \
|
|
})
|
|
|
|
//---
|
|
// Post-measurement analysis
|
|
//---
|
|
|
|
/* prof_time(): Time spent in a given context, in microseconds
|
|
Should only be called when the context is not currently executing. */
|
|
uint32_t prof_time(prof_t prof);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* LIBPROF_LIBPROF */
|