rtlola-streamir 0.1.0

A framework for the compilation of stream-based languages through an intermediate representation
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

use std::collections::HashMap;

use crate::{
    ir::{memory::Memory, LivetimeEquivalences, Stmt, StreamReference},
    rewrite_rules::RemoveSkip,
};

use super::{ChangeSet, RewriteError, RewriteRule};

#[derive(Debug, Clone, Copy)]
/// A rewriting rule that simplifies sequences/parallel nested inside each other.
pub struct CombineSeq;

impl RewriteRule for CombineSeq {
    fn rewrite_stmt(
        &self,
        stmt: Stmt,
        _memory: &HashMap<StreamReference, Memory>,
        _liveness_equivalences: &LivetimeEquivalences,
    ) -> Result<(Stmt, ChangeSet), RewriteError> {
        match stmt {
            Stmt::Seq(inner) => {
                let len = inner.len();
                let inner: Vec<_> = inner
                    .into_iter()
                    .flat_map(|stmt| match stmt {
                        Stmt::Seq(inner) => inner,
                        stmt => vec![stmt],
                    })
                    .collect();
                let cs = if len == inner.len() {
                    ChangeSet::default()
                } else {
                    ChangeSet::local_change()
                };
                match inner.len() {
                    2.. => Ok((Stmt::Seq(inner), cs)),
                    1 => Ok((inner.into_iter().next().unwrap(), ChangeSet::local_change())),
                    0 => Ok((Stmt::Skip, ChangeSet::local_change())),
                }
            }
            Stmt::Parallel(inner) => {
                let len = inner.len();
                let inner: Vec<_> = inner
                    .into_iter()
                    .flat_map(|stmt| match stmt {
                        Stmt::Parallel(inner) => inner,
                        stmt => vec![stmt],
                    })
                    .collect();
                let cs = if len == inner.len() {
                    ChangeSet::default()
                } else {
                    ChangeSet::local_change()
                };
                match inner.len() {
                    2.. => Ok((Stmt::Parallel(inner), cs)),
                    1 => Ok((inner.into_iter().next().unwrap(), ChangeSet::local_change())),
                    0 => Ok((Stmt::Skip, ChangeSet::local_change())),
                }
            }
            stmt => Ok((stmt, ChangeSet::default())),
        }
    }

    fn cleanup_rules(&self) -> Vec<Box<dyn RewriteRule>> {
        vec![Box::new(RemoveSkip)]
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        ir::parse::parse_ir,
        rewrite_rules::{combine_seq::CombineSeq, Rewriter},
    };

    #[test]
    fn simple() {
        let ir = parse_ir(
            "seq {
            input 0;
            seq {
                input 1;
                seq {};
                input 2
            };
            seq { seq { input 3 }}
        }",
        );
        let reference = parse_ir(
            "seq {
            input 0;
            input 1;
            input 2;
            input 3
        }",
        );
        let rewriter = Rewriter::new(vec![Box::new(CombineSeq {})]);
        let (res, changed) = rewriter.apply(ir).unwrap();
        assert!(changed);
        assert!(res.stmt.eq(&reference.stmt));
    }
}