use core::cell::RefCell;
use core::sync::atomic::{AtomicU64, Ordering};
use std::sync::OnceLock;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum TraceEvent {
DispatchEnter = 1,
DispatchExit = 2,
LeafStart = 3,
LeafEnd = 4,
JoinPush = 5,
JoinWaitBegin = 6,
JoinWaitEnd = 7,
WorkerWake = 8,
StealHit = 9,
}
#[derive(Copy, Clone, Debug)]
pub struct TraceRecord {
pub event: TraceEvent,
pub payload: u32,
pub tsc: u64,
}
thread_local! {
static THREAD_TRACE: RefCell<Vec<TraceRecord>> =
RefCell::new(Vec::with_capacity(16_384));
}
static TRACE_ENABLED: OnceLock<bool> = OnceLock::new();
static THREAD_ID_GEN: AtomicU64 = AtomicU64::new(0);
static WORKER_FLUSH_FLAG: core::sync::atomic::AtomicBool =
core::sync::atomic::AtomicBool::new(false);
pub fn request_worker_flush() {
WORKER_FLUSH_FLAG.store(true, core::sync::atomic::Ordering::Release);
}
thread_local! {
static FLUSH_OBSERVED: core::cell::Cell<bool> = const { core::cell::Cell::new(false) };
}
pub fn worker_loop_maybe_flush(label: &str) -> bool {
if !is_enabled() {
return false;
}
let requested = WORKER_FLUSH_FLAG.load(core::sync::atomic::Ordering::Acquire);
let already_done = FLUSH_OBSERVED.with(|c| c.get());
if requested && !already_done {
dump_to_stderr(label);
FLUSH_OBSERVED.with(|c| c.set(true));
return true;
}
if !requested && already_done {
FLUSH_OBSERVED.with(|c| c.set(false));
}
false
}
pub fn clear_worker_flush_request() {
WORKER_FLUSH_FLAG.store(false, core::sync::atomic::Ordering::Release);
}
#[inline]
pub fn is_enabled() -> bool {
*TRACE_ENABLED.get_or_init(|| {
std::env::var("FLYNNEL_TRACE")
.map(|v| v == "1" || v.eq_ignore_ascii_case("on") || v.eq_ignore_ascii_case("true"))
.unwrap_or(false)
})
}
#[inline]
fn read_tsc_local() -> u64 {
#[cfg(target_arch = "x86_64")]
unsafe {
std::arch::x86_64::_rdtsc()
}
#[cfg(not(target_arch = "x86_64"))]
{
std::time::Instant::now().elapsed().as_nanos() as u64
}
}
#[inline]
pub fn emit(event: TraceEvent, payload: u32) {
if !is_enabled() {
return;
}
let tsc = read_tsc_local();
let rec = TraceRecord { event, payload, tsc };
THREAD_TRACE.with(|buf| {
let mut v = buf.borrow_mut();
v.push(rec);
});
}
pub fn reset_current_thread() {
THREAD_TRACE.with(|buf| {
let mut v = buf.borrow_mut();
v.clear();
});
}
pub fn register_thread() -> u64 {
THREAD_ID_GEN.fetch_add(1, Ordering::Relaxed)
}
pub fn dump_to_stderr(thread_name: &str) {
if !is_enabled() {
return;
}
THREAD_TRACE.with(|buf| {
let v = buf.borrow();
for rec in v.iter() {
eprintln!(
"TRACE,{thread},{ev},{payload},{tsc}",
thread = thread_name,
ev = rec.event as u8,
payload = rec.payload,
tsc = rec.tsc,
);
}
});
}
pub fn flush_with_label(label: &str) {
dump_to_stderr(label);
reset_current_thread();
}