Crate gbench

This crate provides the tools to benchmark code for further analyzation using Chrome tracing.

Examples

Examples of using gbench basic functionality

use gbench::{instantiate, scope};

fn main() {
    // Istantiation of the global variables
    // It is needed at the top of every program that uses gbench
    // The folder that is specified is the folder where the data
    // will be saved
    instantiate!("target/bench");
    {
        // This macro creates a variable that starts benchmarking
        // on creation and saves the result on drop.
        // The variable name is the first argument, the scope name
        // is the second.
        scope!(sc | "Scope");

        for _ in 0..1_000_000 {
            let _a = 1 + 1;
        }
    }
}

Example of a log! macro use

use gbench::{instantiate, log, scope};

fn main() {
    instantiate!(ginst | "target/bench");
    {
        scope!(sc | "Scope");

        for _ in 0..1_000 {
            let a = 1 + 1;

            // You can log to the file with a timestamp
            // using log! macro
            log!("A = {}", a);
        }
    }
}

Example of a count! macro use

use gbench::{count, instantiate, scope};

fn main() {
    instantiate!(ginst | "target/bench");
    {
        scope!(sc | "Scope");

        for i in 0..1000 {
            let val = i * i;

            // This statement writes val to field "val" of counter "Actual value"
            // and writes i to field "i" of counter "I"
            count! {
                "Actual value" => {
                    "val" => val
                },
                "I" => {
                    "i" => i
                }
            }
        }
    }
}

Full example

use std::thread;

use gbench::{instantiate, scope};

fn calculate(num: f32, n: u32) -> f32 {
    (0..n)
        .fold((num, 0.0), |(x, v), _| (x + v * 0.01, v - x * 0.001))
        .0
}

fn main() {
    instantiate!("target/bench");

    scope!(program_scope | "Program scope");

    // Doing the work that needs benchmarking
    for _ in 0..5 {
        scope!(main | "Main scope");

        // Spawning a thread to do work
        let thread = thread::spawn(move || {
            // This benchmarks the scope that it is in
            scope!(child | "Child");

            calculate(1.0, 1_500_000)
        });

        // You can organize your subtasks in scopes to
        // benchmark them
        scope!(imp | "An important task");

        {
            scope!(i1 | "Important subtask");
            calculate(1.0, 300_000);
        }

        {
            scope!(i2 | "Less important subtask");
            calculate(1.0, 500_000);
        }

        // If the block of code that you need to benchmark
        // has ended you can drop the guard if the scope
        // has not ended
        drop(imp);

        // Marking the start of another task
        scope!(join | "Joining thread");

        thread.join().unwrap();

        // This line of code is unnecessary but I like
        // to keep it
        drop(join);
    }
}

Macros

count	Creates a counting event
instantiate	Instantiates the global variables for benchmark logging
log	Logs data to a benchmarking file
scope	Benchmarks a scope of code

Structs

Instantiator	Instantiates global data on creation and deinstantiates it on drop
TimeScope	Starts a benchmarking scope on creation and ends it on drop