opy-rs 0.1.61

Standalone OverPy-compatible .opy implementation with parsing, tooling, and bounded Workshop compilation.
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::sync::atomic::{AtomicUsize, Ordering};

use serde::Serialize;
use workshop_rs::Value;

static LOWERING_VALUES_PEAK: AtomicUsize = AtomicUsize::new(0);
static LOWERING_VALUE_CLONE_NODES: AtomicUsize = AtomicUsize::new(0);
static LOWERING_VALUE_MATERIALIZATION_NODES: AtomicUsize = AtomicUsize::new(0);
static LOWERING_ACTION_CLONE_EVENTS: AtomicUsize = AtomicUsize::new(0);
static COMPILER_CONTRACT_CHECKS: AtomicUsize = AtomicUsize::new(0);
static SETTINGS_CHARS_MATERIALIZED: AtomicUsize = AtomicUsize::new(0);
static MACRO_ENGINE_CREATIONS: AtomicUsize = AtomicUsize::new(0);
static MACRO_RUNTIME_CREATION_NS: AtomicUsize = AtomicUsize::new(0);
static MACRO_HOST_REGISTRATION_NS: AtomicUsize = AtomicUsize::new(0);
static MACRO_BUILTIN_EVALUATION_NS: AtomicUsize = AtomicUsize::new(0);
static MACRO_SCRIPT_EVALUATION_NS: AtomicUsize = AtomicUsize::new(0);
static MACRO_RUNTIME_TEARDOWN_NS: AtomicUsize = AtomicUsize::new(0);

#[derive(Debug, Default, Serialize, serde::Deserialize)]
pub(crate) struct ResourceMetrics {
    pub(crate) lowering_values_peak: usize,
    pub(crate) lowering_value_clone_nodes: usize,
    pub(crate) lowering_value_materialization_nodes: usize,
    pub(crate) lowering_action_clone_events: usize,
    pub(crate) compiler_contract_checks: usize,
    pub(crate) settings_chars_materialized: usize,
    pub(crate) macro_engine_creations: usize,
    pub(crate) macro_runtime_creation_ns: usize,
    pub(crate) macro_host_registration_ns: usize,
    pub(crate) macro_builtin_evaluation_ns: usize,
    pub(crate) macro_script_evaluation_ns: usize,
    pub(crate) macro_runtime_teardown_ns: usize,
}

pub(crate) fn reset() {
    for counter in [
        &LOWERING_VALUES_PEAK,
        &LOWERING_VALUE_CLONE_NODES,
        &LOWERING_VALUE_MATERIALIZATION_NODES,
        &LOWERING_ACTION_CLONE_EVENTS,
        &COMPILER_CONTRACT_CHECKS,
        &SETTINGS_CHARS_MATERIALIZED,
        &MACRO_ENGINE_CREATIONS,
        &MACRO_RUNTIME_CREATION_NS,
        &MACRO_HOST_REGISTRATION_NS,
        &MACRO_BUILTIN_EVALUATION_NS,
        &MACRO_SCRIPT_EVALUATION_NS,
        &MACRO_RUNTIME_TEARDOWN_NS,
    ] {
        counter.store(0, Ordering::Relaxed);
    }
}

pub(crate) fn snapshot() -> ResourceMetrics {
    ResourceMetrics {
        lowering_values_peak: LOWERING_VALUES_PEAK.load(Ordering::Relaxed),
        lowering_value_clone_nodes: LOWERING_VALUE_CLONE_NODES.load(Ordering::Relaxed),
        lowering_value_materialization_nodes: LOWERING_VALUE_MATERIALIZATION_NODES
            .load(Ordering::Relaxed),
        lowering_action_clone_events: LOWERING_ACTION_CLONE_EVENTS.load(Ordering::Relaxed),
        compiler_contract_checks: COMPILER_CONTRACT_CHECKS.load(Ordering::Relaxed),
        settings_chars_materialized: SETTINGS_CHARS_MATERIALIZED.load(Ordering::Relaxed),
        macro_engine_creations: MACRO_ENGINE_CREATIONS.load(Ordering::Relaxed),
        macro_runtime_creation_ns: MACRO_RUNTIME_CREATION_NS.load(Ordering::Relaxed),
        macro_host_registration_ns: MACRO_HOST_REGISTRATION_NS.load(Ordering::Relaxed),
        macro_builtin_evaluation_ns: MACRO_BUILTIN_EVALUATION_NS.load(Ordering::Relaxed),
        macro_script_evaluation_ns: MACRO_SCRIPT_EVALUATION_NS.load(Ordering::Relaxed),
        macro_runtime_teardown_ns: MACRO_RUNTIME_TEARDOWN_NS.load(Ordering::Relaxed),
    }
}

pub(crate) fn record_lowering_values(len: usize) {
    LOWERING_VALUES_PEAK.fetch_max(len, Ordering::Relaxed);
}

pub(crate) fn record_value_materialization(value: &Value) {
    LOWERING_VALUE_MATERIALIZATION_NODES.fetch_add(value_node_count(value), Ordering::Relaxed);
}

pub(crate) fn record_contract_check() {
    COMPILER_CONTRACT_CHECKS.fetch_add(1, Ordering::Relaxed);
}

pub(crate) fn record_macro_engine_creation() {
    MACRO_ENGINE_CREATIONS.fetch_add(1, Ordering::Relaxed);
}

#[derive(Debug, Clone, Copy)]
pub(crate) enum MacroPhase {
    RuntimeCreation,
    HostRegistration,
    BuiltinEvaluation,
    ScriptEvaluation,
    RuntimeTeardown,
}

pub(crate) fn record_macro_phase(phase: MacroPhase, elapsed_ns: u128) {
    let elapsed_ns = usize::try_from(elapsed_ns).unwrap_or(usize::MAX);
    let counter = match phase {
        MacroPhase::RuntimeCreation => &MACRO_RUNTIME_CREATION_NS,
        MacroPhase::HostRegistration => &MACRO_HOST_REGISTRATION_NS,
        MacroPhase::BuiltinEvaluation => &MACRO_BUILTIN_EVALUATION_NS,
        MacroPhase::ScriptEvaluation => &MACRO_SCRIPT_EVALUATION_NS,
        MacroPhase::RuntimeTeardown => &MACRO_RUNTIME_TEARDOWN_NS,
    };
    counter.fetch_add(elapsed_ns, Ordering::Relaxed);
}

fn value_node_count(value: &Value) -> usize {
    1 + match value {
        Value::Call { args, .. } | Value::Array(args) => args.iter().map(value_node_count).sum(),
        Value::Vector { x, y, z } => {
            value_node_count(x) + value_node_count(y) + value_node_count(z)
        }
        Value::PlayerVariable { player, .. } => value_node_count(player),
        Value::Number(_)
        | Value::String(_)
        | Value::LocalizedString(_)
        | Value::Bool(_)
        | Value::Null
        | Value::Enum { .. }
        | Value::GlobalVariable(_)
        | Value::Subroutine(_)
        | Value::EventPlayer => 0,
    }
}