Crate embedded_profiling[][src]

Expand description


A lightweight framework for profiling functions, geared towards no-std embedded environments. Initialization is very similar to how the log crate is initialized. By default, there is a no-op profiler that does nothing until you call set_profiler. Once your profiler has been installed, your profiling functionality will be in use.


You can manually start & end your snapshot:

let start = embedded_profiling::start_snapshot();
// (...) some expensive computation
if let Some(snapshot) = embedded_profiling::end_snapshot(start, "name-of-computation") {
    // Optionally, log it if we didn't overflow

Or profile some code in a closure:

embedded_profiling::profile("profile println", || {
    println!("profiling this closure");

With a Procedural Macro

With the proc-macros feature enabled, you can simply annotate the target function with the procedural macro profile_function. Note that you must first set your profiler with the set_profiler function.

fn my_long_running_function() {
    println!("Hello, world!");



Use a u64 as the time storage type instead of u32 for longer running profiling.


enables the proc-macros feature in embedded-profiling. Enables the embedded_profiling::profile_function procedural macro.


pub use fugit;


A recorded snapshot.

Indicates that setting the profiler has gone awry, probably because the profiler has already been set.


The main trait to implement. All that is required is a way to read time and a way to output our results, if desired. You can also implement functions that get called when a snapshot starts and ends.


Converts an instant of an unknown fraction NOM/DENOM to our microsecond representation.

computes the duration of the snapshot given the start time using the globally configured profiler.

Logs the given snapshot with the globally configured profiler.

Profiles the given closure target with name name.

Returns a reference to the configured profiler.

Sets the global profiler.

takes the starting snapshot of a specific trace.

Type Definitions

The underlying container of our Duration/Instant types. Can be either u32 or u64, depending on features (default: u32).

Our Duration type, representing time elapsed in microseconds.

Our Instant type, representing a snapshot in time from a clock with 1 µs precision (or at least, converted to this representation).

An Instant type but with a generic fraction. This needs to be converted into EPInstant for use in the EmbeddedProfiler::read_clock function.

Attribute Macros

profiles the annotated function using embedded_profiling.