weld 0.4.0

Weld is a language and runtime for improving the performance of data-intensive applications.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::ast::ExprKind::*;
use crate::ast::*;

use crate::optimizer::transforms::vectorizer::ShouldPredicate;

#[cfg(test)]
use crate::tests::*;

pub fn short_circuit_booleans(expr: &mut Expr) {
    // For If statements annotated as predicated, do not apply the transform on the condition,
    // since it removes the predication opportunity.
    let should_predicate = expr.should_predicate();
    let applied = match expr.kind {
        If {
            ref mut on_true,
            ref mut on_false,
            ..
        } if should_predicate => {
            short_circuit_booleans(on_true);
            short_circuit_booleans(on_false);
            true
        }
        _ => false,
    };

    if applied {
        return;
    }

    let replaced = match expr.kind {
        BinOp {
            ref mut kind,
            ref mut left,
            ref mut right,
        } if *kind == BinOpKind::LogicalAnd => Some(
            Expr::new_if(
                *left.take(),
                *right.take(),
                Expr::new_literal(LiteralKind::BoolLiteral(false)).unwrap(),
            )
            .unwrap(),
        ),
        BinOp {
            ref mut kind,
            ref mut left,
            ref mut right,
        } if *kind == BinOpKind::LogicalOr => Some(
            Expr::new_if(
                *left.take(),
                Expr::new_literal(LiteralKind::BoolLiteral(true)).unwrap(),
                *right.take(),
            )
            .unwrap(),
        ),
        _ => None,
    };

    if let Some(replaced) = replaced {
        *expr = replaced;
    }

    for child in expr.children_mut() {
        short_circuit_booleans(child);
    }
}

/// Parse and perform type inference on an expression.
#[cfg(test)]
fn typed_expression(code: &str) -> Expr {
    let mut e = parse_expr(code).unwrap();
    assert!(e.infer_types().is_ok());
    e
}

#[test]
fn simple_and() {
    let mut e = typed_expression("|x:i32| (x > 5 && x < 10)");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression("|x:i32| if (x > 5, x < 10, false)");
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn simple_or() {
    let mut e = typed_expression("|x:i32| (x > 5 || x < 10)");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression("|x:i32| if (x > 5, true, x < 10)");
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn compound_and() {
    let mut e = typed_expression("|x:i32| x > 5 && x < 10 && x == 7");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression("|x:i32| if ( if (x > 5, x < 10, false),  x == 7, false)");
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn compound_or() {
    let mut e = typed_expression("|x:i32| (x > 5 || x < 10 || x == 7)");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression("|x:i32| if ( if (x > 5, true, x < 10), true, x == 7 )");
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn complex_and_or() {
    let mut e = typed_expression("|x:i32| (x > 5 || x < 10) && (x == 7 || x == 2)");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression(
        "|x:i32|
                    if(
                        if (x > 5, true, x < 10),
                        if (x == 7, true, x == 2),
                        false  
                    )",
    );
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn complex_and_or_2() {
    let mut e = typed_expression("|x:i32| (x > 5 && x < 10) || (x == 15)");
    short_circuit_booleans(&mut e);
    let expect = &typed_expression(
        "|x:i32|
                    if(
                        if (x > 5, x < 10, false),
                        true,
                        (x == 15)
                    )",
    );
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}

#[test]
fn predicated_if() {
    let mut e =
        typed_expression("|x:i32| @(predicate:true) if (x > 5 && x < 10, x > 3 || x < 4, false)");
    short_circuit_booleans(&mut e);

    // Since the If is predicated, the condition should not be short-circuited.
    let expect = &typed_expression(
        "|x:i32|
                    @(predicate:true)
                    if (
                        x > 5 && x < 10, 
                        if (x > 3, true, x < 4),
                        false
                    )",
    );
    assert!(e.compare_ignoring_symbols(expect).unwrap());
}