A proc macro to insert appropriate flame::start_guard(_) calls (for use with
flame)
This proc macro requires Rust 1.30. Because flamer is a proc macro attribute, it uses APIs stabilized in Rust 1.30.
In your Cargo.toml add flame and flamer to your dependencies:
toml
[dependencies]
flame = "0.2.2"
flamer = "0.5"
Then in your crate root, add the following:
```rust extern crate flame;
// The item to apply flame to goes here.
```
Unfortunately, currently stable Rust doesn't allow custom attributes on modules.
To use #[flame] on modules you need a nightly Rust with
#![feature(proc_macro_hygiene)] in the crate root
(related issue):
```rust
extern crate flame;
mod flamed_module { .. } ```
You may also opt for an optional dependency. In that case your Cargo.toml should have:
```toml [dependencies] flame = { version = "0.2.2", optional = true } flamer = { version = "0.3", optional = true }
[features] default = [] flame_it = ["flame", "flamer"] ```
And your crate root should contain:
```rust
extern crate flame;
// as well as the following instead of #[flame]
// The item to apply flame to goes here.
```
For nightly module support, also add
#![cfg_attr(feature = "flame_it", feature(proc_macro_hygiene))] in the crate
root:
```rust
extern crate flame;
// as well as the following instead of #[flame]
mod flamed_module { .. } ```
You should then be able to annotate every item (alas, currently not the whole
crate; see the
custom inner attribute issue
for more details) with #[flame] annotations.
You can also use #[noflame] annotations to disable instrumentations for
subitems of #[flame]d items. Note that this only instruments the annotated
methods, it does not print out the results.
The flame annotation can also take an optional parameter specifying a string
to prefix to enclosed method names.
This is especially useful when annotating multiple methods with the same name,
but in different modules.
```rust
fn methodname() { //The corresponding block on the flamegraph will be named "prefix::methodname" } ```
```rust use std::fs::File;
use flame as f; use flamer::flame;
fn makevec(size: usize) -> Vec
fn morecomputing(i: usize) { for x in 0..(i * 100) { let mut v = makevec(x); let x = Vec::from(&v[..]); for i in 0..v.len() { let flip = (v.len() - 1) - i as usize; v[i] = x[flip]; } } }
fn somecomputation() { for i in 0..15 { morecomputing(i); } }
fn main() {
somecomputation();
// in order to create the flamegraph you must call one of the
// flame::dump* functions.
f::dump_html(File::create("flamegraph.html").unwrap()).unwrap();
}
```
Refer to flame's documentation to see how output works.
License: Apache 2.0