strykelang 0.6.4

A highly parallel Perl 5 interpreter written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//! Optional stderr tracing for `mysync` mutations under `trace { ... }` and `fan`.

use std::cell::Cell;
use std::sync::atomic::{AtomicBool, Ordering};

use crate::value::PerlValue;

static TRACE_ENABLED: AtomicBool = AtomicBool::new(false);

thread_local! {
    /// Fan / parallel worker label (`$_` index). `None` when not inside a labeled parallel block.
    static WORKER_INDEX: Cell<Option<i64>> = const { Cell::new(None) };
}

/// Begin a `trace { ... }` region (all threads see the same flag).
pub fn trace_enter() {
    TRACE_ENABLED.store(true, Ordering::SeqCst);
}

pub fn trace_leave() {
    TRACE_ENABLED.store(false, Ordering::SeqCst);
}

#[inline]
pub fn is_enabled() -> bool {
    TRACE_ENABLED.load(Ordering::SeqCst)
}

/// Set the current worker index for `fan [N] { }` (typically `$_` as integer).
pub fn fan_worker_set_index(i: Option<i64>) {
    WORKER_INDEX.with(|c| c.set(i));
}

/// Emit one line for a scalar mutation (mysync / atomic scalar).
pub fn emit_scalar_mutation(var: &str, old: &PerlValue, new: &PerlValue) {
    if !is_enabled() {
        return;
    }
    match WORKER_INDEX.with(|c| c.get()) {
        Some(i) => eprintln!("[thread {}] ${}: {} → {}", i, var, old, new),
        None => eprintln!("[main] ${}: {} → {}", var, old, new),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn emit_scalar_mutation_noops_when_trace_disabled() {
        fan_worker_set_index(Some(0));
        emit_scalar_mutation("x", &PerlValue::integer(1), &PerlValue::integer(2));
        fan_worker_set_index(None);
    }

    #[test]
    fn fan_worker_set_index_none_is_safe_after_some() {
        fan_worker_set_index(Some(42));
        fan_worker_set_index(None);
    }
}