Automatic startup, write to Stream, example

Author: earlephilhower

cores/rp2040/RP2040Support.cpp

@@ -18,9 +18,11 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#include <Arduino.h>
+#include <pico/runtime.h>
+
 #ifdef PICO_RP2040
 
-#include <Arduino.h>
 #include <hardware/structs/psm.h>
 
 extern "C" void boot_double_tap_check();
@@ -35,3 +37,17 @@ void RP2040::enableDoubleResetBootloader() {
 }
 
 #endif
+
+#ifdef __PROFILE
+Stream *__profileFile;
+int __writeProfileCB(const void *data, int len) {
+    return __profileFile->write((const char *)data, len);
+}
+
+#ifdef __PROFILE
+extern "C" void runtime_init_setup_profiling();
+#define PICO_RUNTIME_INIT_PROFILING "11011" // Towards the end, after PSRAM
+PICO_RUNTIME_INIT_FUNC_RUNTIME(runtime_init_setup_profiling, PICO_RUNTIME_INIT_PROFILING);
+#endif
+
+#endif

cores/rp2040/RP2040Support.h

@@ -18,6 +18,8 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#pragma once
+
 #include <hardware/clocks.h>
 #include <hardware/irq.h>
 #include <hardware/pio.h>
@@ -45,6 +47,13 @@
 
 extern "C" volatile bool __otherCoreIdled;
 
+extern "C" {
+#ifdef __PROFILE
+    typedef int (*profileWriteCB)(const void *data, int len);
+    extern void _writeProfile(profileWriteCB writeCB);
+#endif
+}
+
 class _MFIFO {
 public:
     _MFIFO() { /* noop */ };
@@ -473,6 +482,16 @@ class RP2040 {
 #endif
     }
 
+#ifdef __PROFILE
+    void writeProfiling(Stream *f) {
+        extern Stream *__profileFile;
+        extern int __writeProfileCB(const void *data, int len);
+        __profileFile = f;
+        _writeProfile(__writeProfileCB);
+    }
+#endif
+
+
 
 private:
     static void _SystickHandler() {

cores/rp2040/gprof_gmon.c

@@ -49,12 +49,17 @@
 #include <stdint.h>
 #include <string.h>
 
-
+// Frequency of sampling
+#ifndef GMON_HZ
+#define GMON_HZ 10000
+#endif
 
 /*
     fraction of text space to allocate for histogram counters here, 1/2
 */
+#ifndef HISTFRACTION
 #define HISTFRACTION    8
+#endif
 
 /*
     Fraction of text space to allocate for from hash buckets.
@@ -84,12 +89,16 @@
     profiling data structures without (in practice) sacrificing
     any granularity.
 */
+#ifndef HASHFRACTION
 #define HASHFRACTION    2
+#endif
 
 /*
     percent of text space to allocate for tostructs with a minimum.
 */
+#ifndef ARCDENSITY
 #define ARCDENSITY      2 /* this is in percentage, relative to text size! */
+#endif
 #define MINARCS          50
 #define MAXARCS          ((1 << (8 * sizeof(HISTCOUNTER))) - 2)
 
@@ -101,7 +110,7 @@
 #define GMON_PROF_ERROR 2
 #define GMON_PROF_OFF     3
 
-void _mcleanup(void); /* routine to be called to write gmon.out file */
+//void _mcleanup(void); /* routine to be called to write gmon.out file */
 
 
 
@@ -195,7 +204,6 @@ static struct profinfo prof = {
     PROFILE_NOT_INIT, 0, 0, 0, 0
 };
 extern volatile bool __otherCoreIdled;
-static int __profileHz = 0;
 
 /* convert an addr to an index */
 #define PROFIDX(pc, base, scale)  \
@@ -290,22 +298,17 @@ int __no_inline_not_in_flash_func(profil)(char *samples, size_t size, size_t off
 #define PICO_RUNTIME_INIT_PROFILING "11011" // Towards the end, after PSRAM
 #if defined(__riscv)
 void runtime_init_setup_profiling() {
-    __profileHz = 10000;
     // TODO - is there an equivalent?  Or do we need to build a timer IRQ here?
 }
 #else
 #include <hardware/exception.h>
 #include <hardware/structs/systick.h>
 void runtime_init_setup_profiling() {
-    __profileHz = 10000;
     exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
     systick_hw->csr = 0x7;
-    systick_hw->rvr = (F_CPU / __profileHz) - 1;
+    systick_hw->rvr = (F_CPU / GMON_HZ) - 1;
 }
 #endif
-#ifdef __PROFILE
-PICO_RUNTIME_INIT_FUNC_RUNTIME(runtime_init_setup_profiling, PICO_RUNTIME_INIT_PROFILING);
-#endif
 
 
 #define MINUS_ONE_P (-1)
@@ -393,54 +396,28 @@ void __no_inline_not_in_flash_func(monstartup)(size_t lowpc, size_t highpc) {
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
-extern int __profileHz;
 
-void _mcleanup(void) {
-    static const char gmon_out[] = "gmon.out";
-    int fd;
-    int hz;
+// Ensure matches definition in rp2040support
+typedef int (*profileWriteCB)(const void *data, int len);
+void _writeProfile(profileWriteCB writeCB) {
     int fromindex;
     int endfrom;
     size_t frompc;
     int toindex;
     struct rawarc rawarc;
     struct gmonparam *p = &_gmonparam;
     struct gmonhdr gmonhdr, *hdr;
-    const char *proffile;
-#ifdef DEBUG
-    int log, len;
-    char dbuf[200];
-#endif
 
-    if (p->state == GMON_PROF_ERROR) {
-        ERR("_mcleanup: tos overflow\n");
-    }
-    hz = __profileHz;//PROF_HZ;
     moncontrol(0); /* stop */
-    proffile = gmon_out;
-    fd = open(proffile, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0666);
-    if (fd < 0) {
-        perror(proffile);
-        return;
-    }
-#ifdef DEBUG
-    log = open("gmon.log", O_CREAT | O_TRUNC | O_WRONLY, 0664);
-    if (log < 0) {
-        perror("mcount: gmon.log");
-        return;
-    }
-    len = sprintf(dbuf, "[mcleanup1] kcount 0x%x ssiz %d\n",
-                  p->kcount, p->kcountsize);
-    write(log, dbuf, len);
-#endif
+
     hdr = (struct gmonhdr *)&gmonhdr;
     hdr->lpc = p->lowpc;
     hdr->hpc = p->highpc;
     hdr->ncnt = p->kcountsize + sizeof(gmonhdr);
     hdr->version = GMONVERSION;
-    hdr->profrate = hz;
-    write(fd, (char *)hdr, sizeof * hdr);
-    write(fd, p->kcount, p->kcountsize);
+    hdr->profrate = GMON_HZ;
+    writeCB((void *)hdr, sizeof * hdr);
+    writeCB((void *)p->kcount, p->kcountsize);
     endfrom = p->fromssize / sizeof(*p->froms);
     for (fromindex = 0; fromindex < endfrom; fromindex++) {
         if (p->froms[fromindex] == 0) {
@@ -449,20 +426,12 @@ void _mcleanup(void) {
         frompc = p->lowpc;
         frompc += fromindex * HASHFRACTION * sizeof(*p->froms);
         for (toindex = p->froms[fromindex]; toindex != 0; toindex = p->tos[toindex].link) {
-#ifdef DEBUG
-            len = sprintf(dbuf,
-                          "[mcleanup2] frompc 0x%x selfpc 0x%x count %d\n",
-                          frompc, p->tos[toindex].selfpc,
-                          p->tos[toindex].count);
-            write(log, dbuf, len);
-#endif
             rawarc.raw_frompc = frompc;
             rawarc.raw_selfpc = GETSELFPC(&p->tos[toindex]);
             rawarc.raw_count = GETCOUNT(&p->tos[toindex]);
-            write(fd, &rawarc, sizeof rawarc);
+            writeCB((void *)&rawarc, sizeof rawarc);
         }
     }
-    close(fd);
 }
 
 /*

keywords.txt

@@ -65,6 +65,8 @@ getUsedPSRAMHeap	KEYWORD2
 getTotalPSRAMHeap	KEYWORD2
 getTotalPSRAM	KEYWORD2
 
+writeProfiling	KEYWORD2
+
 getChipID	KEYWORD2
 
 hwrand32	KEYWORD2

libraries/rp2040/examples/Profiling/Profiling.ino

@@ -0,0 +1,93 @@
+// This example should be run with profiling enabled from the IDE and
+// under GDB/OpenOCD.  It uses semihosting to write a gmon.out file
+// the host system with the profiled application results.
+//
+// Semihosting **ONLY** works with an OpenOCD and GDB setup.  If you build
+// and run a semihosting app without GDB connected, it **WILL CRASH**
+//
+// Start OpenOCD normally, but leave the terminal window visible because
+// is it OpenOCD, not GDB, which will display the semihosting output.
+// OpenOCD will also create files in the current working directory, so
+// be sure it is a place you can find and write to.
+//
+// In GDB,connect to OpenOCD and then enable semihosting
+// (gdb) target extended-remote localhost:3333
+// (gdb) monitor arm semihosting enable
+// (gdb) file /path/to/sketch.ino.elf
+// (gdb) load
+//
+// Run the app from GDB and watch OpenOCD, it will display messages when
+// the app is done and "gmon.out" is on the host system.
+//
+// (gdb) run
+// .. pop to OpenOCD window
+// [OpenOCD] BEGIN
+// [OpenOCD] Result = 2417697592
+// [OpenOCD] Writing GMON.OUT
+// [OpenOCD] END
+//
+// From command line, decode the gmon.out using the ELF and gprof tool
+//
+// $ /path/to/arm-none-eabi/bin/arm-none-eabi-gprof /path/to/sketch.ino.elf /path/to/gmon.out | less
+// Flat profile:
+//
+// Each sample counts as 0.0001 seconds.
+//   %   cumulative   self              self     total
+//  time   seconds   seconds    calls  ms/call  ms/call  name
+//  50.56      1.74     1.74  3500020     0.00     0.00  __wrap___getreent
+//  24.05      2.57     0.83                             rand
+//   8.32      2.86     0.29        5    57.36    57.36  fcn1(unsigned long)
+// ...
+// index % time    self  children    called     name
+//                                                 <spontaneous>
+// [1]     74.6    0.83    1.74                 rand [1]
+//                 1.74    0.00 3500000/3500020     __wrap___getreent [2]
+// -----------------------------------------------
+//                 0.00    0.00       1/3500020     realloc [106]
+//                 0.00    0.00       3/3500020     vsnprintf [54]
+//                 0.00    0.00       7/3500020     srand [7]
+//                 0.00    0.00       9/3500020     malloc [105]
+//                 1.74    0.00 3500000/3500020     rand [1]
+// ...
+
+#ifdef __riscv
+void setup() {
+  // No semihosting for RISCV yet
+}
+void loop() {
+}
+#else
+
+#include <SemiFS.h>
+
+uint32_t fcn1(uint32_t st) {
+  srand(st);
+  for (int i = 0; i < 500000; i++) {
+    st += rand();
+  }
+  return st;
+}
+
+uint32_t fcn2(uint32_t st) {
+  srand(st * st);
+  for (int i = 0; i < 500000; i++) {
+    st += rand();
+  }
+  return st;
+}
+
+void setup() {
+  SerialSemi.printf("BEGIN\n");
+  SerialSemi.printf("Result = %lu\n", fcn2(fcn2(fcn1(3)) * fcn1(fcn1(fcn1(fcn1(2))))));
+  SerialSemi.printf("Writing GMON.OUT\n");
+  SemiFS.begin();
+  File gmon = SemiFS.open("gmon.out", "w");
+  rp2040.writeProfiling(&gmon);
+  gmon.close();
+  SerialSemi.printf("END\n");
+}
+
+void loop() {
+}
+
+#endif