prof: merge the libprof project

CMakeLists.txt

@@ -253,6 +253,8 @@ set(SOURCES
   src/usb/write4.S
   # Video driver interface
   src/video/video.c
+  # Profiling
+  src/prof/prof.c
 )
 
 set(ASSETS_FX src/font5x7.png src/gdb/icons-i1msb.png)

README.md

@@ -38,7 +38,6 @@ The library also offers powerful higher-level features:
 
 A couple of libraries extend these features, including:
 
-* [libprof](/Lephenixnoir/libprof): Profiling and performance evaluation
 * [libimg](/Lephenixnoir/libimg): Versatile image transformations
 * [OpenLibm](/Lephenixnoir/OpenLibm): A port of the standard math library
   (actually needed by gint)

include/gint/prof.h

@@ -0,0 +1,113 @@
+//---
+//	prof: A manual profiling interface for gint
+//---
+
+#ifndef GINT_PROF
+#define GINT_PROF
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <gint/defs/attributes.h>
+#include <gint/config.h>
+
+/* This provides the old interface for <libprof.h>. */
+#define LIBPROF_LIBPROF
+/* Advertise libprof version as gint's version. */
+#define LIBPROF_VERSION GINT_VERSION
+
+//---
+//	Initialization
+//---
+
+/* prof_init(): Initialize the profiler's timer
+
+   Starts a timer to count time. The profiling interface 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
+   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 /* GINT_PROF */

src/prof/prof.c

@@ -0,0 +1,56 @@
+#include <gint/timer.h>
+#include <gint/clock.h>
+#include <gint/mpu/tmu.h>
+#include <gint/hardware.h>
+#include <gint/prof.h>
+
+/* Timer counter */
+uint32_t volatile *prof_tcnt = NULL;
+/* Timer ID */
+static int prof_timer = -1;
+
+static int callback(void)
+{
+	return TIMER_CONTINUE;
+}
+
+/* prof_init(): Initialize the profiler's timer */
+int prof_init(void)
+{
+	/* Get a TMU with the exact constant 0xffffffff */
+	int timer = -1;
+	for(int t = 2; t >= 0 && timer == -1; t--)
+	{
+		timer = timer_configure(t | TIMER_Pphi_4, 0xffffffff,
+			GINT_CALL(callback));
+	}
+	if(timer == -1)
+	{
+		prof_quit();
+		return 1;
+	}
+
+	/* Keep the address of the TCNT register */
+	prof_tcnt = isSH3()
+		? &SH7705_TMU.TMU[timer].TCNT
+		: &SH7305_TMU.TMU[timer].TCNT;
+
+	timer_start(timer);
+	prof_timer = timer;
+
+	return 0;
+}
+
+/* prof_quit(): Free the profiler's timer */
+void prof_quit(void)
+{
+	if(prof_timer >= 0) timer_stop(prof_timer);
+	prof_timer = -1;
+}
+
+/* prof_time(): Time spent in a given context, in microseconds */
+uint32_t prof_time(prof_t prof)
+{
+	int Pphi = clock_freq()->Pphi_f;
+	return ((uint64_t)prof.elapsed * 4 * 1000000) / Pphi;
+}