laddu-compile 0.21.2

Amplitude analysis tools for 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
62
63
64
65
66
67
68
69
70
71
72
73

use super::*;

#[test]
fn compile_option_constructors_select_explicit_normalization_boundaries() {
    assert_eq!(
        CompileOptions::default().normalization_analysis,
        NormalizationAnalysisMode::BeforeExecutionLowering
    );
    assert_eq!(
        CompileOptions::without_optimizations().normalization_analysis,
        NormalizationAnalysisMode::ExecutionGraph
    );
    assert_eq!(
        CompileOptions::with_pipeline(OptimizationPipeline::new()).normalization_analysis,
        NormalizationAnalysisMode::ExecutionGraph
    );
}

#[test]
fn compiler_phase_methods_keep_normalization_and_execution_inputs_distinct() {
    let source = (Expr::from(Parameter::fixed("scale", 2.0)) * event_scalar("x")).to_graph();
    let parameter_baked = Compiler::bake_parameters(&source);
    assert!(
        !parameter_baked
            .nodes()
            .iter()
            .any(|node| matches!(node, ExprNode::ScalarParam(_)))
    );

    let prepared = Compiler::prepare_normalization(
        parameter_baked,
        NormalizationRecipe::AnalyzeBeforeExecution(OptimizationPipeline::new()),
    )
    .unwrap();
    assert!(matches!(prepared.plan, PreparedNormalizationPlan::Ready(_)));
    assert!(!matches!(
        prepared
            .execution_input
            .node(prepared.execution_input.root()),
        Some(ExprNode::Unary {
            op: UnaryOp::Exp,
            ..
        })
    ));

    let execution_pipeline = OptimizationPipeline::new().with_pass(WrapRootInExp);
    let execution_graph =
        Compiler::lower_execution(prepared.execution_input, &execution_pipeline).unwrap();
    assert!(matches!(
        execution_graph.node(execution_graph.root()),
        Some(ExprNode::Unary {
            op: UnaryOp::Exp,
            ..
        })
    ));
}

#[test]
fn normalization_submodel_recipe_disables_analysis_after_execution_lowering() {
    let source = (event_scalar("x") + event_scalar("x")).to_graph();
    let compiled = CompiledModel::from_graph_without_normalization(source).unwrap();

    assert!(matches!(
        compiled.normalization_diagnostics().fallback_reason(),
        Some(
            crate::NormalizationFallbackReason::UnsupportedMixedOperation {
                operation: "normalization analysis disabled",
                ..
            }
        )
    ));
    assert_eq!(compiled.cache_plan().len(), 1);
}