btw, some of you working on gstreamer on embedded platforms might be
interested in this:
I have been given permission by my employer to release an in-house
tracing tool that I had developed in the past for "printf()" style
traces from embedded systems:
This currently supports ARM processors running linux (although the ARM
specific parts are relatively minimal if someone has interest in
porting to other platforms). There are patches for gstreamer (and TI
This provides a replacement for printf() that is build as a shared
library and linked into the gstreamer (or whatever) application.
Compared to the default printf() traces, it has a few optimizations:
1) only the program-counter + format string ptr + arguments are
sent to the PC.. the overhead of doing the sprintf() sort of string
formatting operation is done on the host PC.
2) since the program-counter (or actually link-register) is sent to
the PC, we can omit the function name, file name, and line number.
3) the trace data (and timestamp) are simply written into a
circular buffer from the thread generating the trace. If you overload
the connection to the PC (for example, ethernet), traces will be
dropped (this is indicated in the PC tool), so the impact to real-time
behavior of the program is minimal.
On the host PC, you configure PLATO with the path to the location of
the root filesystem. PLATO reads the executable and shared libraries
to extract the .text sections (format string), symbol table (function
names), as well as debug info if present (file and line # tables)
The end result is that I can run pipelines, such as movie playback at
30fps, with more or less all traces enabled, and not drop frames or
have gaps in audio. With the default printf() traces, I cannot enable
too many traces before significant number of buffers are getting
This has been pretty helpful to me for debugging various timing
related issues, which had a tendency to disappear before when I
started enabling traces.
I hope this is useful to others. The PC side part should be pretty
portable to other platforms (at least using ELF executable/library
files), and the target side part has just a little bit of ARM
assembly... (there is actually already some minimal PPC support too.)
If someone is interested to use this on other platforms, feel free to
ping me and I'll try to point you in the right direction.