Quelle  profiler.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use minidl::Library;

// Must match `___tracy_source_location_data` struct in TracyC.h
#[repr(C)]
pub struct SourceLocation {
    pub name: *const u8,
    pub function: *const u8,
    pub file: *const u8,
    pub line: u32,
    pub color: u32,
}

// Must match `___tracy_c_zone_context` in TracyC.h
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ZoneContext {
    id: u32,
    active: i32,
}

// Define a set of no-op implementation functions that are called if the tracy
// shared library is not loaded.
extern "C" fn unimpl_mark_frame(_: *const u8) {}
extern "C" fn unimpl_mark_frame_start(_: *const u8) {}
extern "C" fn unimpl_mark_frame_end(_: *const u8) {}
extern "C" fn unimpl_zone_begin(_: *const SourceLocation, _: i32) -> ZoneContext {
    ZoneContext {
        id: 0,
        active: 0,
    }
}
extern "C" fn unimpl_zone_end(_: ZoneContext) {}
extern "C" fn unimpl_zone_text(_: ZoneContext, _: *const u8, _: usize) {}

extern "C" fn unimpl_plot(_: *const u8, _: f64) {}

// Function pointers to the tracy API functions (if loaded), or the no-op functions above.
pub static mut MARK_FRAME: extern "C" fn(name: *const u8) = unimpl_mark_frame;
pub static mut MARK_FRAME_START: extern "C" fn(name: *const u8) = unimpl_mark_frame_start;
pub static mut MARK_FRAME_END: extern "C" fn(name: *const u8) = unimpl_mark_frame_end;
pub static mut EMIT_ZONE_BEGIN: extern "C" fn(srcloc: *const SourceLocation, active: i32) -> ZoneContext = unimpl_zone_begin;
pub static mut EMIT_ZONE_END: extern "C" fn(ctx: ZoneContext) = unimpl_zone_end;
pub static mut EMIT_ZONE_TEXT: extern "C" fn(ctx: ZoneContext, txt: *const u8, size: usize) = unimpl_zone_text;
pub static mut EMIT_PLOT: extern "C" fn(name: *const u8, val: f64) = unimpl_plot;

// Load the tracy library, and get function pointers. This is unsafe since:
// - It must not be called while other threads are calling the functions.
// - It doesn't ensure that the library is not unloaded during use.
pub unsafe fn load(path: &str) -> bool {
    match Library::load(path) {
        Ok(lib) => {
            // If lib loading succeeds, assume we can find all the symbols required.
            MARK_FRAME = lib.sym("___tracy_emit_frame_mark\0").unwrap();
            MARK_FRAME_START = lib.sym("___tracy_emit_frame_mark_start\0").unwrap();
            MARK_FRAME_END = lib.sym("___tracy_emit_frame_mark_end\0").unwrap();
            EMIT_ZONE_BEGIN = lib.sym("___tracy_emit_zone_begin\0").unwrap();
            EMIT_ZONE_END = lib.sym("___tracy_emit_zone_end\0").unwrap();
            EMIT_ZONE_TEXT = lib.sym("___tracy_emit_zone_text\0").unwrap();
            EMIT_PLOT = lib.sym("___tracy_emit_plot\0").unwrap();

            true
        }
        Err(..) => {
            println!("Failed to load the tracy profiling library!");

            false
        }
    }
}

/// A simple stack scope for tracing function execution time
pub struct ProfileScope {
    ctx: ZoneContext,
}

impl ProfileScope {
    pub fn new(callsite: &'static SourceLocation) -> Self {
        let ctx = unsafe { EMIT_ZONE_BEGIN(callsite, 1) };

        ProfileScope {
            ctx,
        }
    }

    pub fn text(&self, text: &[u8]) {
        unsafe { EMIT_ZONE_TEXT(self.ctx, text.as_ptr(), text.len()) };
    }
}

impl Drop for ProfileScope {
    fn drop(&mut self) {
        unsafe {
            EMIT_ZONE_END(self.ctx)
        }
    }
}

/// Define a profiling scope.
///
/// This macro records a Tracy 'zone' starting at the point at which the macro
/// occurs, and extending to the end of the block. More precisely, the zone ends
/// when a variable declared by this macro would be dropped, so early returns
/// exit the zone.
///
/// For example:
///
///     fn an_operation_that_may_well_take_a_long_time() {
///         profile_scope!("an_operation_that_may_well_take_a_long_time");
///         ...
///     }
///
/// The first argument to `profile_scope!` is the name of the zone, and must be
/// a string literal.
///
/// Tracy zones can also have associated 'text' values that vary from one
/// execution to the next - for example, a zone's text might record the name of
/// the file being processed. The text must be a `CStr` value. You can provide
/// zone text like this:
///
///     fn run_reftest(test_name: &str) {
///         profile_scope!("run_reftest", text: test_name);
///         ...
///     }
#[macro_export]
macro_rules! profile_scope {
    ($string:literal $(, text: $text:expr )? ) => {
        const CALLSITE: $crate::profiler::SourceLocation = $crate::profiler::SourceLocation {
            name: concat!($string, "\0").as_ptr(),
            function: concat!(module_path!(), "\0").as_ptr(),
            file: concat!(file!(), "\0").as_ptr(),
            line: line!(),
            color: 0xff0000ff,
        };

        let _profile_scope = $crate::profiler::ProfileScope::new(&CALLSITE);

        $(
            _profile_scope.text(str::as_bytes($text));
        )?
    }
}

/// Define the main frame marker, typically placed after swap_buffers or similar.
#[macro_export]
macro_rules! tracy_frame_marker {
    () => {
        unsafe {
            $crate::profiler::MARK_FRAME(std::ptr::null())
        }
    }
}

/// Define start of an explicit frame marker, typically used for sub-frames.
#[macro_export]
macro_rules! tracy_begin_frame {
    ($name:expr) => {
        unsafe {
            $crate::profiler::MARK_FRAME_START(concat!($name, "\0").as_ptr())
        }
    }
}

/// Define end of an explicit frame marker, typically used for sub-frames.
#[macro_export]
macro_rules! tracy_end_frame {
    ($name:expr) => {
        unsafe {
            $crate::profiler::MARK_FRAME_END(concat!($name, "\0").as_ptr())
        }
    }
}

#[macro_export]
macro_rules! tracy_plot {
    ($name:expr, $value:expr) => {
        unsafe {
            $crate::profiler::EMIT_PLOT(concat!($name, "\0").as_ptr(), $value)
        }
    }
}

// Provide a name for this thread to the profiler
pub fn register_thread_with_profiler(_: String) {
    // TODO(gw): Add support for passing this to the tracy api
}