peace 0.0.15

zero stress automation
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
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
155
156
157
158
159
160
161
162
163
164
165
166
167

# Ordering

To define the order of execution, [`fn_graph`][`fn_graph`] uses two kinds of dependencies – logical and data. Logical dependencies are defined by consumers of the crate. Data dependencies are calculated by inspecting the type and mutability of function parameters.

Using the example:

```rust ,ignore
# type Fn1 = fn(&mut i32, &mut i32, &mut i32, &mut i32);
# type Fn2 = fn(&i32, &mut i32);
# type Fn3 = fn(&i32, &mut i32);
# type Fn4 = fn(&i32, &mut i32);
# type Fn5 = fn(&i32, &i32, &i32);
#
let fn1: Fn1 = |a, b, c, d| { *a = 1; *b = 2; *c = 0; *d = 0; };
let fn2: Fn2 = |a,    c   | *c += *a;
let fn3: Fn3 = |   b, c   | *c += *b;
let fn4: Fn4 = |      c, d| *d += *c;
let fn5: Fn5 = |a, b, c   | println!("{a} + {b} = {c}");
```

Even though it is possible to order these sequentially, we also want to be able to achieve concurrency to increase performance.

```dot process
digraph {
    graph [
        penwidth  = 0
        nodesep   = 0.5
        ranksep   = 0.4
        bgcolor   = "transparent"
        fontcolor = "#555555"
        splines   = line
        rankdir   = LR
    ]
    node [
        fontcolor = "#111111"
        fontname  = "monospace"
        fontsize  = 10
        shape     = "circle"
        style     = "filled"
        width     = 0.4
        height    = 0.4
        margin    = 0.04
        color     = "#aaaabb"
        fillcolor = "#eeeef5"
    ]
    edge [
        arrowsize = 0.7
        color     = "#555555"
        fontcolor = "#555555"
    ]

    fn1 [label = <<b>fn1</b>>]
    fn2 [label = <<b>fn2</b>>]
    fn3 [label = <<b>fn3</b>>]
    fn4 [label = <<b>fn4</b>>]
    fn5 [label = <<b>fn5</b>>]

    fn1 -> fn2 -> fn3 -> fn4 -> fn5
}
```


## Logical Dependencies

To encode this into a function graph, logical dependencies can be specified through edges:

```dot process
digraph {
    graph [
        penwidth  = 0
        nodesep   = 0.5
        ranksep   = 0.4
        bgcolor   = "transparent"
        fontcolor = "#555555"
        splines   = line
        rankdir   = LR
    ]
    node [
        fontcolor = "#111111"
        fontname  = "monospace"
        fontsize  = 10
        shape     = "circle"
        style     = "filled"
        width     = 0.4
        height    = 0.4
        margin    = 0.04
        color     = "#aaaabb"
        fillcolor = "#eeeef5"
    ]
    edge [
        arrowsize = 0.7
        color     = "#555555"
        fontcolor = "#555555"
    ]

    fn1 [label = <<b>fn1</b>>]
    fn2 [label = <<b>fn2</b>>]
    fn3 [label = <<b>fn3</b>>]
    fn4 [label = <<b>fn4</b>>]
    fn5 [label = <<b>fn5</b>>]

    fn1 -> fn2
    fn1 -> fn3
    fn2 -> fn4
    fn3 -> fn4
    fn2 -> fn5
    fn3 -> fn5
}
```

For correctness, `fn1` must be executed before both `fn2` and `fn3`, and those must complete before `fn4` and `fn5` are executed.


## Data Dependencies

Note that `fn4` and `fn5` can both be executed in parallel, as there is no overlap in accessed data.

However, `fn2` and `fn3` both require mutable access to `C`. Since it is not possible to safely provide both `fn2` and `fn3` with mutable access, `fn_graph` automatically introduces a data dependency between those functions to ensure consistent ordering:

```dot process
digraph {
    graph [
        penwidth  = 0
        nodesep   = 0.25
        ranksep   = 0.3
        bgcolor   = "transparent"
        fontcolor = "#555555"
        splines   = line
        rankdir   = LR
    ]
    node [
        fontcolor = "#111111"
        fontname  = "monospace"
        fontsize  = 10
        shape     = "circle"
        style     = "filled"
        width     = 0.4
        height    = 0.4
        margin    = 0.04
        color     = "#aaaabb"
        fillcolor = "#eeeef5"
    ]
    edge [
        arrowsize = 0.7
        color     = "#5555553f"
        fontcolor = "#555555"
    ]

    fn1 [label = <<b>fn1</b>>]
    fn3 [label = <<b>fn3</b>>]
    fn2 [label = <<b>fn2</b>>]
    fn5 [label = <<b>fn5</b>>]
    fn4 [label = <<b>fn4</b>>]

    fn1 -> fn2 [weight = 2]
    fn1 -> fn3 [weight = 2, minlen = 2]
    fn2 -> fn4 [weight = 5, minlen = 2]
    fn3 -> fn4
    fn2 -> fn5
    fn3 -> fn5 [weight = 2]

    fn2 -> fn3 [style = "dashed", color = "#555555"]
}
```


[`fn_graph`]: https://github.com/azriel91/fn_graph