blob: 0991e67aba96c9e68d31347ddbb8f59090ff133b [file] [edit]
// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use fuchsia_async as fasync;
use fuchsia_trace as trace;
use fuchsia_trace::TraceFutureExt;
use fuchsia_trace_observer as trace_observer;
use std::future::{Future, poll_fn};
use std::sync::{Barrier, Condvar, Mutex};
use std::task::Poll;
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_enabled() -> bool {
return trace::is_enabled();
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_category_disabled_cstr() -> bool {
return trace::category_enabled(c"-disabled");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_category_disabled_str() -> bool {
return trace::category_enabled("-disabled");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_category_enabled_cstr() -> bool {
return trace::category_enabled(c"+enabled");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_category_enabled_str() -> bool {
return trace::category_enabled("+enabled");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_counter_macro_cstr() {
trace::counter!(c"+enabled", c"name", 42, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_counter_macro_str() {
trace::counter!("+enabled", "name", 42, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_counter_macro_str_and_string() {
trace::counter!("+enabled", "name".to_string(), 42, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_instant_macro_cstr() {
trace::instant!(c"+enabled", c"name", trace::Scope::Process, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_instant_macro_str() {
trace::instant!("+enabled", "name", trace::Scope::Process, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_instant_macro_str_and_string() {
trace::instant!("+enabled", "name".to_string(), trace::Scope::Process, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_macro_cstr() {
trace::duration!(c"+enabled", c"name", "x" => 5, "y" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_macro_str() {
trace::duration!("+enabled", "name", "x" => 5, "y" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_macro_str_and_string() {
trace::duration!("+enabled", "name".to_string(), "x" => 5, "y" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_macro_with_scope() {
// N.B. The ordering here is intentional. The duration! macro emits a trace
// event when the scoped object is dropped. From an output perspective,
// that means we are looking to see that the instant event occurs first.
trace::duration!(c"+enabled", c"name", "x" => 5, "y" => 10);
trace::instant!(c"+enabled", c"name", trace::Scope::Process, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_begin_end_macros_cstr() {
trace::duration_begin!(c"+enabled", c"name", "x" => 5);
trace::instant!(c"+enabled", c"name", trace::Scope::Process, "arg" => 10);
trace::duration_end!(c"+enabled", c"name", "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_begin_end_macros_str() {
trace::duration_begin!("+enabled", "name", "x" => 5);
trace::instant!("+enabled", "name", trace::Scope::Process, "arg" => 10);
trace::duration_end!("+enabled", "name", "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_duration_begin_end_macros_str_and_string() {
let name = "name".to_string();
trace::duration_begin!("+enabled", &name, "x" => 5);
trace::instant!("+enabled", &name, trace::Scope::Process, "arg" => 10);
trace::duration_end!("+enabled", &name, "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_vthread_duration_begin_end_macros() {
trace::vthread_duration_begin!(c"+enabled", c"name", "vthread_name", 12u64, "x" => 5);
trace::instant!(c"+enabled", c"name", trace::Scope::Process, "arg" => 10);
trace::vthread_duration_end!(c"+enabled", c"name", "vthread_name", 12u64, "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_blob_macro_cstr() {
trace::blob!(c"+enabled", c"name", "blob contents".as_bytes().to_vec().as_slice(), "x" => 5);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_blob_macro_str() {
trace::blob!("+enabled", "name", "blob contents".as_bytes().to_vec().as_slice(), "x" => 5);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_blob_macro_str_and_string() {
trace::blob!("+enabled", "name".to_string(), "blob contents".as_bytes().to_vec().as_slice(), "x" => 5);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_flow_begin_step_end_macros_cstr() {
trace::flow_begin!(c"+enabled", c"name", 123.into(), "x" => 5);
trace::flow_step!(c"+enabled", c"step", 123.into(), "z" => 42);
trace::flow_end!(c"+enabled", c"name", 123.into(), "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_flow_begin_step_end_macros_str() {
trace::flow_begin!("+enabled", "name", 123.into(), "x" => 5);
trace::flow_step!("+enabled", "step", 123.into(), "z" => 42);
trace::flow_end!("+enabled", "name", 123.into(), "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_flow_begin_step_end_macros_str_and_string() {
let name = "name".to_string();
trace::flow_begin!("+enabled", &name, 123.into(), "x" => 5);
trace::flow_step!("+enabled", "step".to_string(), 123.into(), "z" => 42);
trace::flow_end!("+enabled", &name, 123.into(), "y" => "foo");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_arglimit() {
trace::duration!(c"+enabled", c"name",
"1" => 1,
"2" => 2,
"3" => 3,
"4" => 4,
"5" => 5,
"6" => 6,
"7" => 7,
"8" => 8,
"9" => 9,
"10" => 10,
"11" => 11,
"12" => 12,
"13" => 13,
"14" => 14,
"15" => 15
);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_async_event_with_scope() {
// N.B. The ordering here is intentional. The async_enter! macro emits a trace event when the
// scoped object is instantiated and when it is dropped. From an output perspective, that means
// we are looking to see that the instant event occurs sandwiched between the two.
let _guard = trace::async_enter!(1.into(), c"+enabled", c"name", "x" => 5, "y" => 10);
trace::instant!(c"+enabled", c"name", trace::Scope::Process, "arg" => 10);
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_alert_cstr() {
trace::alert!(c"+enabled", c"alert_name");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_alert_str() {
trace::alert!("+enabled", "alert_name");
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_alert_str_and_string() {
let name = "alert_name".to_string();
trace::alert!("+enabled", &name);
}
fn run_future(fut: impl Future<Output = ()>) {
fasync::TestExecutor::new().run_singlethreaded(fut);
}
fn multi_poll_future(mut ready_after: u64) -> impl Future<Output = ()> {
poll_fn(move |cx| {
if ready_after > 0 {
ready_after -= 1;
cx.waker().clone().wake();
Poll::Pending
} else {
Poll::Ready(())
}
})
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_enabled_cstr() {
// The future is immediately ready. There will be a single duration event around the poll call.
// No flow events will be generated.
run_future(multi_poll_future(0).trace(trace::trace_future_args!(
c"+enabled",
c"name",
3.into()
)));
// The future will return pending once followed by ready. There will be 2 duration events. The
// 1st duration will contain a flow begin, and the 2nd duration will contain a flow end.
run_future(multi_poll_future(1).trace(trace::trace_future_args!(
c"+enabled",
c"name",
4.into()
)));
// The future will return pending twice followed by ready. There will be 3 duration events. The
// 1st duration will contain a flow begin, the 2nd duration will contain a flow step, and the
// 3rd duration will contain a flow end.
run_future(multi_poll_future(2).trace(trace::trace_future_args!(
c"+enabled",
c"name",
5.into()
)));
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_enabled_str() {
// The future is immediately ready. There will be a single duration event around the poll call.
// No flow events will be generated.
run_future(multi_poll_future(0).trace(trace::trace_future_args!("+enabled", "name", 3.into())));
// The future will return pending once followed by ready. There will be 2 duration events. The
// 1st duration will contain a flow begin, and the 2nd duration will contain a flow end.
run_future(multi_poll_future(1).trace(trace::trace_future_args!("+enabled", "name", 4.into())));
// The future will return pending twice followed by ready. There will be 3 duration events. The
// 1st duration will contain a flow begin, the 2nd duration will contain a flow step, and the
// 3rd duration will contain a flow end.
run_future(multi_poll_future(2).trace(trace::trace_future_args!("+enabled", "name", 5.into())));
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_enabled_str_and_string() {
let name = "name".to_string();
// The future is immediately ready. There will be a single duration event around the poll call.
// No flow events will be generated.
run_future(multi_poll_future(0).trace(trace::trace_future_args!("+enabled", &name, 3.into())));
// The future will return pending once followed by ready. There will be 2 duration events. The
// 1st duration will contain a flow begin, and the 2nd duration will contain a flow end.
run_future(multi_poll_future(1).trace(trace::trace_future_args!("+enabled", &name, 4.into())));
// The future will return pending twice followed by ready. There will be 3 duration events. The
// 1st duration will contain a flow begin, the 2nd duration will contain a flow step, and the
// 3rd duration will contain a flow end.
run_future(multi_poll_future(2).trace(trace::trace_future_args!("+enabled", &name, 5.into())));
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_enabled_with_arg() {
run_future(multi_poll_future(1).trace(trace::trace_future_args!(
c"+enabled",
c"name",
3.into(),
"arg" => 10,
)));
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_disabled() {
run_future(multi_poll_future(1).trace(trace::trace_future_args!(
c"-disabled",
c"name",
3.into(),
)));
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_trace_future_disabled_with_arg() {
#[allow(unreachable_code)]
run_future(multi_poll_future(1).trace(trace::trace_future_args!(
c"-disabled",
c"name",
3.into(),
"arg" => {
panic!("arg should not be evaluated");
()
}
)));
}
static STATE_CV: Condvar = Condvar::new();
static TRACE_STATE: Mutex<fuchsia_trace::TraceState> =
Mutex::new(fuchsia_trace::TraceState::Stopped);
#[unsafe(no_mangle)]
pub extern "C" fn rs_check_trace_state() -> u32 {
*TRACE_STATE.lock().unwrap() as u32
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_wait_trace_state_is(expected: u32) {
let mut state = TRACE_STATE.lock().unwrap();
while *state as u32 != expected {
state = STATE_CV.wait(state).unwrap();
}
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_setup_trace_observer() {
static BARRIER: Barrier = Barrier::new(2);
std::thread::spawn(|| {
let mut executor = fasync::LocalExecutor::default();
executor.run_singlethreaded(async move {
let observer = trace_observer::TraceObserver::new();
BARRIER.wait();
while let Ok(new_state) = observer.on_state_changed().await {
let mut state = TRACE_STATE.lock().unwrap();
*state = new_state;
STATE_CV.notify_all();
}
});
});
// Ensure that we've registered our trace_observer in the spawned thread before continuing on
// and potentially starting the trace session.
BARRIER.wait();
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_custom_track_and_async_events() {
// 1. Existing Async Events
let async_id = 42.into();
trace::async_instant!(async_id, c"+enabled", c"async_instant_name", "x" => 1);
{
let _guard = trace::async_enter!(async_id, c"+enabled", c"async_duration_name", "y" => 2);
trace::instant!(c"+enabled", c"instant_in_between", trace::Scope::Process, "arg" => 10);
}
// 2. New Custom Track Events
let track = trace::Track::new("my_custom_track");
trace::track_instant!(c"+enabled", track, c"track_instant_name", "a" => 10);
// Manual begin/end
trace::track_duration_begin!(c"+enabled", track, c"track_manual_duration", "b" => 20);
trace::instant!(c"+enabled", c"instant_in_between_track", trace::Scope::Process, "arg" => 20);
trace::track_duration_end!(c"+enabled", track, c"track_manual_duration", "c" => 30);
// RAII Scoped duration
{
trace::track_duration!(c"+enabled", track, c"track_scoped_duration", "d" => 40);
}
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_custom_track_concurrent_usage() {
let track = trace::Track::new("concurrent_custom_track");
let barrier = std::sync::Arc::new(std::sync::Barrier::new(4));
let mut handles = vec![];
for i in 0..4 {
let track = track.clone();
let barrier = barrier.clone();
handles.push(std::thread::spawn(move || {
barrier.wait();
for j in 0..50 {
trace::track_duration!(c"+enabled", track, c"concurrent_duration", "thread" => i, "iter" => j);
trace::track_instant!(c"+enabled", track, c"concurrent_instant", "thread" => i);
}
}));
}
for handle in handles {
handle.join().unwrap();
}
}
#[unsafe(no_mangle)]
pub extern "C" fn rs_test_flush_buffer() -> i32 {
match trace::flush_buffer() {
Ok(()) => 0,
Err(status) => status.into_raw(),
}
}