├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── examples
    ├── basic.rs
    └── logging-recv2.rs
├── html
    ├── dashboard.html
    ├── graph.html
    └── schedule.html
└── src
    ├── bin
        ├── dashboard.rs
        ├── graph.rs
        └── schedule.rs
    ├── lib.rs
    └── server.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | **/*.rs.bk
3 | Cargo.lock
4 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "timely-viz"
 3 | version = "0.1.0"
 4 | authors = ["Andrea Lattuada <andrea.lattuada@inf.ethz.ch>"]
 5 | 
 6 | 
 7 | [dependencies]
 8 | abomonation = "0.7"
 9 | abomonation_derive = "0.3"
10 | timely_communication = "^0.8"
11 | #timely = "^0.8"
12 | timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
13 | #differential-dataflow = "^0.8"
14 | differential-dataflow = { git = "https://github.com/TimelyDataflow/differential-dataflow" }
15 | fnv="1.0.2"
16 | futures = "^0.1"
17 | actix = "^0.5"
18 | actix-web = "^0.6"
19 | serde = "^1"
20 | serde_derive = "^1"
21 | serde_json = "^1"
22 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Andrea Lattuada, ETH Zürich
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | **NOTE: These tools are deprecated in favour of [timelydataflow/diagnostics](https://github.com/timelydataflow/diagnostics).**
2 | 
3 | # [→ timelydataflow/diagnostics](https://github.com/timelydataflow/diagnostics)
4 | 


--------------------------------------------------------------------------------
/examples/basic.rs:
--------------------------------------------------------------------------------
 1 | extern crate timely;
 2 | extern crate differential_dataflow;
 3 | extern crate timely_viz;
 4 | 
 5 | extern crate abomonation;
 6 | 
 7 | use std::time::Duration;
 8 | 
 9 | use timely::dataflow::operators::{Map, capture::Replay};
10 | use timely::logging::TimelyEvent::{Operates, Channels};
11 | 
12 | use differential_dataflow::collection::AsCollection;
13 | 
14 | fn main() {
15 |     let mut args = ::std::env::args();
16 |     args.next().unwrap();
17 | 
18 |     // the number of workers in the computation we're examining
19 |     let source_peers = args.next().unwrap().parse::<usize>().unwrap();
20 |     // one socket per worker in the computation we're examining
21 |     let sockets = timely_viz::open_sockets(source_peers);
22 | 
23 |     timely::execute_from_args(args, move |worker| {
24 |         let sockets = sockets.clone();
25 | 
26 |         let replayers = timely_viz::make_replayers(sockets, worker.index(), worker.peers());
27 | 
28 |         worker.dataflow::<Duration,_,_>(|scope| {
29 |             let stream =
30 |             replayers
31 |                 .replay_into(scope);
32 | 
33 |             let _operates =
34 |             stream
35 |                 .flat_map(|(t,_,x)| {
36 |                     if let Operates(event) = x {
37 |                         Some((event, t, 1 as isize))
38 |                     } else {
39 |                         None
40 |                     }
41 |                 })
42 |                 .as_collection()
43 |                 // only keep elements that came from worker 0
44 |                 // (the first element of "addr" is the worker id)
45 |                 .filter(|x| *x.addr.first().unwrap() == 0)
46 |                 .inspect(|x| println!("Operates: {:?}", x));
47 | 
48 |             let _channels =
49 |             stream
50 |                 .flat_map(|(t,_,x)| {
51 |                     if let Channels(event) = x {
52 |                         Some((event, t, 1 as isize))
53 |                     } else {
54 |                         None
55 |                     }
56 |                 })
57 |                 .as_collection()
58 |                 .filter(|x| *x.scope_addr.first().unwrap() == 0)
59 |                 .inspect(|x| println!("Channels: {:?}", x));
60 |         });
61 |     }).unwrap();
62 | }
63 | 


--------------------------------------------------------------------------------
/examples/logging-recv2.rs:
--------------------------------------------------------------------------------
  1 | extern crate timely;
  2 | extern crate differential_dataflow;
  3 | 
  4 | use std::sync::{Arc, Mutex};
  5 | use std::net::TcpListener;
  6 | use std::time::Duration;
  7 | 
  8 | use timely::dataflow::operators::Map;
  9 | use timely::logging::TimelyEvent;
 10 | use timely::communication::logging::{CommunicationEvent, CommunicationSetup};
 11 | use timely::dataflow::operators::Filter;
 12 | use timely::dataflow::operators::capture::{EventReader, Replay};
 13 | 
 14 | use differential_dataflow::AsCollection;
 15 | use differential_dataflow::operators::Consolidate;
 16 | 
 17 | fn main() {
 18 | 
 19 |     let mut args = ::std::env::args();
 20 |     args.next().unwrap();
 21 | 
 22 |     let work_peers: usize = args.next().expect("Must provide number of source peers").parse().expect("Source peers must be an unsigned integer");
 23 |     let comm_peers: usize = args.next().expect("Must provide number of source peers").parse().expect("Comms peers must be an unsigned integer");
 24 |     let granularity: u64  = args.next().expect("Must provide report granularity in seconds").parse().expect("Granularity must be an unsigned integer");
 25 | 
 26 |     println!("starting with work peers: {}, comm peers: {}, granularity: {}", work_peers, comm_peers, granularity);
 27 | 
 28 |     let t_listener = TcpListener::bind("127.0.0.1:8000").unwrap();
 29 |     let d_listener = TcpListener::bind("127.0.0.1:9000").unwrap();
 30 |     let t_sockets =
 31 |     Arc::new(Mutex::new((0..work_peers).map(|_| {
 32 |             let socket = t_listener.incoming().next().unwrap().unwrap();
 33 |             socket.set_nonblocking(true).expect("failed to set nonblocking");
 34 |             Some(socket)
 35 |         }).collect::<Vec<_>>()));
 36 |     let d_sockets =
 37 |     Arc::new(Mutex::new((0..comm_peers).map(|_| {
 38 |             let socket = d_listener.incoming().next().unwrap().unwrap();
 39 |             socket.set_nonblocking(true).expect("failed to set nonblocking");
 40 |             Some(socket)
 41 |         }).collect::<Vec<_>>()));
 42 | 
 43 |     timely::execute_from_args(std::env::args(), move |worker| {
 44 | 
 45 |         let index = worker.index();
 46 |         let peers = worker.peers();
 47 | 
 48 |         let t_streams =
 49 |         t_sockets
 50 |             .lock()
 51 |             .unwrap()
 52 |             .iter_mut()
 53 |             .enumerate()
 54 |             .filter(|(i, _)| *i % peers == index)
 55 |             .map(move |(_, s)| s.take().unwrap())
 56 |             .map(|r| EventReader::<Duration, (Duration, usize, TimelyEvent),_>::new(r))
 57 |             .collect::<Vec<_>>();
 58 | 
 59 |         let d_streams =
 60 |         d_sockets
 61 |             .lock()
 62 |             .unwrap()
 63 |             .iter_mut()
 64 |             .enumerate()
 65 |             .filter(|(i, _)| *i % peers == index)
 66 |             .map(move |(_, s)| s.take().unwrap())
 67 |             .map(|r| EventReader::<Duration, (Duration, CommunicationSetup, CommunicationEvent),_>::new(r))
 68 |             .collect::<Vec<_>>();
 69 | 
 70 |         worker.dataflow::<_,_,_>(|scope| {
 71 | 
 72 |             let t_events = t_streams.replay_into(scope);
 73 |             let d_events = d_streams.replay_into(scope);
 74 | 
 75 |             // println!("SIZEOF: {}", ::std::mem::size_of::<(Duration, usize, TimelyEvent)>());
 76 | 
 77 |             t_events
 78 |                 .flat_map(move |(ts, _worker, datum)| {
 79 |                     let ts = Duration::from_secs((ts.as_secs()/granularity + 1) * granularity);
 80 |                     Some((datum, ts, 1))
 81 |                 })
 82 |                 .as_collection()
 83 |                 .map(|x| ())
 84 |                 .consolidate()
 85 |                 .inspect(|x| println!("TIMELY\t{:?}", x));
 86 | 
 87 |             // d_events
 88 |             //     .flat_map(move |(ts, _worker, datum)| {
 89 |             //         let ts = Duration::from_secs((ts.as_secs()/granularity + 1) * granularity);
 90 |             //         Some((datum, ts, 1))
 91 |             //     })
 92 |             //     .as_collection()
 93 |             //     .consolidate()
 94 |             //     .inspect(|x| println!("COMMS\t{:?}", x));
 95 | 
 96 |         });
 97 | 
 98 |     }).unwrap(); // asserts error-free execution
 99 | }
100 | 


--------------------------------------------------------------------------------
/html/dashboard.html:
--------------------------------------------------------------------------------
  1 | <head>
  2 |   <script src="https://vega.github.io/vega/vega.js"></script>
  3 |   <script src="https://d3js.org/d3.v5.min.js"></script>
  4 |   <script src="https://dagrejs.github.io/project/dagre-d3/latest/dagre-d3.js"></script>
  5 | </head>
  6 | <body>
  7 | 
  8 | <div id="container">
  9 | 
 10 |   <div id="view-lhs"></div>
 11 |   <div id="view-rhs">
 12 |     <button id="back">back</button>
 13 |     <div id="details-list">
 14 |       <h2 class="title"> Description </h2>
 15 |         <ul>
 16 |           <li>
 17 |             <span class="name">Operator name: </span>
 18 |             <span class="operate_name_update"> </span>
 19 |           </li>
 20 |           <li>
 21 |             <span class="elapsed">Elapsed time in ns: </span>
 22 |             <span class="elapsed_ns_update"> </span>
 23 |           </li>
 24 |           <li>
 25 |             <span class="total_count">Total count: </span>
 26 |             <span class="total_count_update"></span>
 27 |           </li>
 28 |           <ul id="update">
 29 |           </ul>
 30 |         </ul>
 31 |     </div>
 32 |     <div id="graph">
 33 |     </div>
 34 |   </div>
 35 | </div>
 36 | 
 37 | <style>
 38 |   #container{
 39 |     display:flex;
 40 |     flex-direction: row;
 41 |     justify-content: center;
 42 |   }
 43 |   #back{
 44 |     padding: 5px 15px;
 45 |     font-size: 24px;
 46 |     text-align: center;
 47 |     outline: none;
 48 |     color: #fff;
 49 |     background-color: #42c2f4;
 50 |     border: none;
 51 |     border-radius: 10px;
 52 |     box-shadow: 0 4px #999;
 53 |     position:relative;
 54 |     left:-100;
 55 |     top: 80;
 56 |   }
 57 |   #back:hover {
 58 |     background-color: #4192f4
 59 |   }
 60 |   #back:active {
 61 |     background-color: #3e8e41;
 62 |   }
 63 |   #details-list{
 64 |     margin: 30px;
 65 |   }
 66 |   #details-list ul{
 67 |     list-style-type: none;
 68 |     padding: 0;
 69 |   }
 70 |   #details-list li{
 71 |     padding: 10px;
 72 |     border-left: 10px solid #ddd;
 73 |     margin: 10px 10px;
 74 |     font-size: 20px;
 75 |   }
 76 |   .operate_name_update, .input_update, .output_update, .elapsed_ns_update, .total_count_update{
 77 |     padding-left: 5px;
 78 |     padding-right: 10px;
 79 |   }
 80 |   #graph {
 81 |     border: 1px solid black;
 82 |   }
 83 |   .graph_node {
 84 |     stroke: #000; stroke-width: 1px;
 85 |     fill: white;
 86 |   }
 87 |   .graph_node .label {
 88 |     stroke-width: 0;
 89 |     fill: black;
 90 |   }
 91 |   #graph .edgePath {
 92 |     stroke: #000; stroke-width: 1px;
 93 |   }
 94 | 
 95 | </style>
 96 | 
 97 | <script type="text/javascript">
 98 |   let my_spec = {
 99 |     "$schema": "https://vega.github.io/schema/vega/v4.json",
100 |     "width": 500,
101 |     "height": 1000,
102 |     "padding": 50,
103 |     "autosize": "fit",
104 |     "data": [
105 |       {
106 |         "name": "tree",
107 |         "values":[]
108 |       },
109 |       {
110 |         "name": "sunburst",
111 |         "source": "tree",
112 |         "transform": [
113 |           {
114 |             "type": "stratify",
115 |             "key": "addr",
116 |             "parentKey": "parent"
117 |           },
118 |           {
119 |             "type": "partition",
120 |             "field": "elapsed_ns",
121 |             "sort": {"field": "value"},
122 |             "size": [1,1],
123 |             "as": ["start", "inner", "end", "outer", "depth", "children"]
124 |           }
125 |         ]
126 |       },
127 |       {
128 |         "name": "table",
129 |         "source": "tree",
130 |         "transform": [
131 |           {
132 |             "type": "filter",
133 |             "expr": "datum.parent == filterlist"
134 |           }
135 |         ]
136 |       }
137 |     ],
138 |     "signals": [
139 |       {
140 |         "name": "filterlist",
141 |         "value": "[0,0]",
142 |         "on": [{"events": "rect:click", "update": "invert('yscale', y())"}]
143 |       },
144 |       {
145 |         "name": "miny",
146 |         "value": 0,
147 |         "on": [{"events": "arc:click", "update": "datum.inner"}
148 |         ]
149 |       },
150 |       {
151 |         "name": "minx",
152 |         "value": 0,
153 |         "on": [{"events": "arc:click", "update": "datum.start"}
154 |         ]
155 |       },
156 |       {
157 |         "name": "maxx",
158 |         "on": [{"events": "arc:click", "update": "datum.end"}
159 |         ]
160 |       },
161 |       {
162 |         "name": "sunburst_data",
163 |         "value": "datum",
164 |         "on": [{"events": "arc:click", "update": "datum"},{"events": "rect:click", "update": "datum"}
165 |         ]
166 |       }
167 |     ],
168 |     "scales": [
169 |       {
170 |         "name": "color",
171 |         "type": "ordinal",
172 |         "range": {"scheme": "accent"}
173 |       },
174 |       {
175 |         "name": "x",
176 |         "type": "linear",
177 |         "domain": [0,1],
178 |         "domainMin": {"signal": "minx"},
179 |         "domainMax": {"signal": "maxx"},
180 |         "range": [0, {"signal": "2 * PI"}]
181 |       },
182 |       {
183 |         "name": "y",
184 |         "type": "sqrt",
185 |         "domain": [0, 1],
186 |         "domainMin": {"signal": "miny"},
187 |         "range": [{"signal": "miny != 0 ? 20 : 0"}, {"signal": "(min(width, height )/2.5) - 10"}]
188 |       },
189 |       {
190 |         "name": "yscale",
191 |         "type": "band",
192 |         "domain": {"data": "table", "field": "addr"},
193 |         "range": [960,400],
194 |         "padding": 0.03,
195 |         "round": true
196 |       },
197 |       {
198 |         "name": "xscale",
199 |         "domain": {"data": "table", "field": "elapsed_ns"},
200 |         "nice": true,
201 |         "range": "width"
202 |       }
203 |     ],
204 |     "axes": [
205 |       {
206 |         "orient": "left",
207 |         "scale": "yscale",
208 |         "titlePadding": 15,
209 |         "title": "address",
210 |         "titleFontSize": 16,
211 |         "labelFontSize": 14
212 |       },
213 |       {
214 |         "orient": "bottom",
215 |         "scale": "xscale",
216 |         "labelOverlap": "parity",
217 |         "title": "elapsed time in ns",
218 |         "titleFontSize": 16,
219 |         "labelFontSize": 14
220 |       }
221 |     ],
222 |     "marks": [
223 |       {
224 |         "type": "arc",
225 |         "from": {"data": "sunburst"},
226 |         "encode": {
227 |           "enter": {
228 |             "x": {"signal": "width / 4"},
229 |             "y": {"signal": "height / 6"},
230 |             "fill": {"scale": "color", "field": "depth"}
231 |           },
232 |           "update": {
233 |             "x": {"signal": "width / 4"},
234 |             "y": {"signal": "height / 6"},
235 |             "startAngle": {"signal": "max(0, min(2*PI, scale('x', datum.start)))"},
236 |             "endAngle": {"signal": "max(0, min(2*PI, scale('x', datum.end)))"},
237 |             "innerRadius": { "signal": "max(0, scale('y', datum.inner))"},
238 |             "outerRadius": {"scale": "y", "field": "outer"},
239 |             "stroke": {"value": "white"},
240 |             "strokeWidth": {"value": 0.5},
241 |             "zindex": {"value": 0},
242 |             "tooltip": {
243 |               "signal": "{\"addr\":datum['addr'] + '', \"name\": datum['name'], \"elapsed\": datum['elapsed_ns'] + 'ns' }"
244 |             }
245 |           },
246 |           "hover": {
247 |             "stroke": {"value": "white"},
248 |             "strokeWidth": {"value": 1},
249 |             "zindex": {"value": 1}
250 |           }
251 |         }
252 |       },
253 |       {
254 |         "type": "rect",
255 |         "from": {"data":"table"},
256 |         "encode": {
257 |           "enter": {
258 |             "y": {"scale": "yscale", "field": "addr"},
259 |             "height": {"scale": "yscale", "band": 1},
260 |             "x": {"scale": "xscale", "field": "elapsed_ns"},
261 |             "x2": {"scale": "xscale", "value": 0}
262 |           },
263 |           "update": {
264 |             "fill": {"value": "steelblue"},
265 |             "x": {"scale": "xscale", "field": "elapsed_ns"},
266 |             "height": {"scale": "yscale", "band": 1},
267 |             "y": {"scale": "yscale", "field": "addr"},
268 |             "x2": {"scale": "xscale", "value": 0}
269 |           },
270 |           "hover": {
271 |             "fill": {"value": "#4192f4"}
272 |           }
273 |         }
274 |       },
275 |       {
276 |         "type": "text",
277 |         "encode": {
278 |           "enter": {
279 |             "fill": {"value": "black"},
280 |             "fontSize": {"value": 20},
281 |             "align": {"value": "right"},
282 |             "x":{"value": 180},
283 |             "y":{"value": 400}
284 |           },
285 |           "update": {
286 |             "text": {"signal": "'current filter: ' + filterlist"}
287 |           }
288 |         }
289 |       }
290 |     ]
291 |   };
292 | 
293 |     const back_button = document.getElementById('back');
294 | 
295 |     var view = new
296 |     vega.View(vega.parse(my_spec))
297 |     .logLevel(vega.Warn)
298 |     .renderer('canvas')  // set renderer (canvas or svg)
299 |     .initialize('#view-lhs') // initialize view within parent DOM container
300 |     .hover()             // enable hover encode set processing
301 |     .run();
302 | 
303 | 
304 |     view.insert('tree', {"addr": "[0]", "parent": null, "name": "Dataflow", "elapsed_ns": 0}).run();
305 | 
306 |     let map_operates = new Map();
307 |     let map_channels = new Map();
308 |     let map_schedule = new Map();
309 |     let map_messages = new Map();
310 | 
311 |     view.addSignalListener('sunburst_data', function (name, value){
312 |       view.runAfter(function (view) {view.signal('filterlist', value.addr); view.run();});
313 |     });
314 | 
315 |     view.addSignalListener('sunburst_data', function (name, value){
316 |       let operates = [];
317 |       let channels = [];
318 |       for(let [id, o] of map_operates){
319 |         let parent ='[' + o.addr.toString().substring(0, o.addr.toString().lastIndexOf(',')) + ']';
320 |         if(parent == value.addr){
321 |           operates.push(o);
322 |         }
323 |       }
324 |       for (let [id, o] of map_channels){
325 |         let parent ='[' + o.from_addr.toString().substring(0, o.from_addr.toString().lastIndexOf(',')) + ']';
326 |         if(value.addr == parent){
327 |           channels.push(o);
328 |         }
329 |       }
330 |       update_graph(operates, channels);
331 |     });
332 | 
333 | 
334 |     back_button.onclick = () => {
335 |       let cur = view.signal('filterlist');
336 |       view.signal('filterlist', cur.substring(0, cur.lastIndexOf(',')) + "]");
337 |     };
338 | 
339 |     let websocket = new WebSocket("ws://localhost:9000/ws/");
340 |     websocket.addEventListener('message', (ev) => {
341 | 
342 |       let updates = JSON.parse(ev.data).updates;
343 | 
344 |       let changeset = vega.changeset();
345 |       let changeset_msgs = vega.changeset();
346 | 
347 |       console.log(updates);
348 | 
349 |       let map_temp_ops = new Map();
350 |       let map_temp_chs = new Map();
351 |       let map_temp_sch = new Map();
352 |       let map_temp_msg = new Map();
353 | 
354 |       for (let update of updates) {
355 |         if(!!update.event.Operate){
356 |           if(!map_temp_ops.has(update.event.Operate.id)){
357 |             map_temp_ops.set(update.event.Operate.id, []);
358 |           }
359 |           map_temp_ops.get(update.event.Operate.id).push(update);
360 |         }
361 | 
362 |         else if(!!update.event.Channel){
363 |           if(!map_temp_chs.has(update.event.Channel.id)){
364 |             map_temp_chs.set(update.event.Channel.id, []);
365 |           }
366 |           map_temp_chs.get(update.event.Channel.id).push(update);
367 | 
368 |         }
369 |         else if(!!update.event.Schedule){
370 |           if(!map_temp_sch.has(update.event.Schedule.operate_id)){
371 |             map_temp_sch.set(update.event.Schedule.operate_id, []);
372 |           }
373 |           map_temp_sch.get(update.event.Schedule.operate_id).push(update);
374 |         }
375 | 
376 |         else if (!!update.event.Messages){
377 |           if(!map_temp_msg.has(update.event.Messages.channel_id)){
378 |             map_temp_msg.set(update.event.Messages.channel_id, []);
379 |           }
380 |           map_temp_msg.get(update.event.Messages.channel_id).push(update);
381 |         }
382 |       }
383 | 
384 |       for(let [id,list] of map_temp_ops){
385 |         if(list.length == 1){
386 |           if(list[0].delta == 1){
387 |             map_operates.set(id, list[0].event.Operate);
388 |           }else {
389 |             map_operates.delete(id);
390 |           }
391 |         }else if(list.length == 2){
392 |           if(list[0].delta == 1){
393 |             map_operates.set(id, list[0].event.Operate);
394 |           }else {
395 |             map_operates.delete(id);
396 |           }
397 | 
398 |         }else {
399 |           console.error("More than 2 updates");
400 |         }
401 |       }
402 | 
403 |       for(let [id,list] of map_temp_chs){
404 |         if(list.length == 1){
405 | 
406 |           if(list[0].delta == 1){
407 |             map_channels.set(id, list[0].event.Channel);
408 | 
409 |           }else {
410 |             map_channels.delete(id);
411 |           }
412 | 
413 |         }else if(list.length == 2){
414 |           if(list[0].delta == 1){
415 |             map_channels.set(id, list[0].event.Channel)
416 |           }else {
417 |             map_channels.set(id, list[1].event.Channel)
418 |           }
419 |         }else {
420 |           console.error("More than 2 updates");
421 |          }
422 |       }
423 | 
424 |       for(let [id,o] of map_operates){
425 |         let obj = {
426 |           "addr": '[' + o.addr.toString() + ']',
427 |           "parent": '[' + o.addr.toString().substring(0, o.addr.toString().lastIndexOf(',')) + ']',
428 |           "elapsed_ns": 0,
429 |           "count":0,
430 |           "name": o.name,
431 |           "id": id
432 |         }
433 |         if(!map_schedule.has(id)){
434 |           map_schedule.set(id, obj);
435 |           changeset.insert(obj);
436 |         }
437 |       }
438 | 
439 |       for(let [id,list] of map_temp_sch){
440 |         if(list.length == 1){
441 |           if(list[0].delta == 1){
442 |             changeset.modify((x) => x.id == list[0].event.Schedule.operate_id, "elapsed_ns", list[0].event.Schedule.elapsed_ns);
443 |             map_schedule.set(id, list[0].event.Schedule);
444 |           }else {
445 |             map_schedule.delete(id);
446 |             changeset.remove((x) => x.id == list[0].event.Schedule.operate_id);
447 |           }
448 |         }else if(list.length == 2){
449 |           if(list[0].delta == 1){
450 |             changeset.modify((x) => x.id == list[0].event.Schedule.operate_id, "elapsed_ns", list[0].event.Schedule.elapsed_ns);
451 |             map_schedule.set(id, list[0].event.Schedule);
452 |           }else {
453 |             changeset.modify((x) => x.id == list[1].event.Schedule.operate_id, "elapsed_ns", list[1].event.Schedule.elapsed_ns);
454 |             map_schedule.set(id, list[1].event.Schedule);
455 |           }
456 |         }else {
457 |           console.error("More than 2 updates");
458 |         }
459 |       }
460 | 
461 |       for(let [id,list] of map_temp_msg){
462 |         if(list.length == 1){
463 |           if(list[0].delta == 1){
464 |             map_messages.set(id, list[0].event.Messages);
465 |           }else {
466 |             map_messages.delete(id);
467 |           }
468 |         }else if(list.length == 2){
469 |           if(list[0].delta == 1){
470 |             map_messages.set(id, list[0].event.Messages)
471 |           }else {
472 |             map_messages.set(id, list[1].event.Messages)
473 |           }
474 |         }else {
475 |           console.error("More than 2 updates");
476 |         }
477 |       }
478 |     document.querySelector('#view-rhs li .elapsed_ns_update').innerHTML = view.signal('sunburst_data').elapsed_ns;
479 |     view.change('tree', changeset).run();
480 | 
481 |     });
482 | 
483 |   document.querySelector('#view-rhs li .operate_name_update').innerHTML = "Dataflow";
484 |   document.querySelector('#view-rhs li .elapsed_ns_update').innerHTML = "0";
485 |   document.querySelector('#view-rhs li .total_count_update').innerHTML = "0";
486 | 
487 |   view.addSignalListener('sunburst_data', function (name, value){
488 | 
489 |     document.querySelector('#view-rhs li .operate_name_update').innerHTML = value.name;
490 |     document.querySelector('#view-rhs li .elapsed_ns_update').innerHTML = value.elapsed_ns;
491 | 
492 |     //to erase previous input & output data
493 |     let input_out = document.getElementById("update");
494 |     while (input_out.firstChild) {
495 |       input_out.removeChild(input_out.firstChild);
496 |     }
497 | 
498 |     let input_output = [];
499 |     for (let [id, o] of map_channels){
500 |       let from_addr = '[' + o.from_addr.toString() + ']';
501 |       let to_addr = '[' + o.to_addr.toString() + ']';
502 | 
503 |       if(value.addr == to_addr){
504 |         let inp = "Input "  + o.to_port + " : " +  o.from_addr;
505 |         input_output.push(inp);
506 |       }
507 |       else if(value.addr == from_addr ){
508 |         let out = "Output " + o.from_port + " : " + o.to_addr;
509 |         input_output.push(out);
510 |         let total_cnt = map_messages.get(id).total_count;
511 |         document.querySelector('#view-rhs li .total_count_update').innerHTML = total_cnt;
512 | 
513 | 
514 |       }
515 | 
516 |     }
517 | 
518 |     //create list elements dynamically based on the input_output array
519 |     let update_list = document.querySelector("ul #update");
520 |       for (let o of input_output) {
521 |         list_value = document.createElement("li");
522 |         list_value.textContent = o;
523 |         update_list.appendChild(list_value);
524 |       }
525 | 
526 |   });
527 | 
528 |   view.addSignalListener('sunburst_data', function (name, value) {
529 |     console.log(value);
530 |   });
531 | 
532 |   let render = new dagreD3.render();
533 |   let svg_parent = d3.select("#graph").append("svg").attr("width", 600).attr("height", 400);
534 |   let svg = svg_parent.append("g");
535 | 
536 |   var zoom = d3.zoom()
537 |       .on("zoom", function() {
538 |         svg.attr("transform", d3.event.transform);
539 |         return false;
540 |       });
541 |   svg_parent.call(zoom);
542 | 
543 |   function update_graph(operates, channels){
544 |     let g = new dagreD3.graphlib.Graph({});
545 |     g.setGraph({
546 |       nodesep: 5,
547 |       ranksep: 5,
548 |     });
549 |     for (let operator of operates) {
550 |       // let html = "<div class=\"graph_node\">";
551 |       // html += "<span class=\"graph_operator_name\">" + operator.name + "</span>";
552 |       // html += " (<span class=\"graph_operator_addr\">" + operator.addr + "</span>)";
553 |       // html += "</div>";
554 |       g.setNode("" + operator.addr, {
555 |         label: operator.name + " (" + operator.addr + ")",
556 |         class: "graph_node",
557 |         rx: 5,
558 |         ry: 5,
559 |       });
560 |     }
561 |     let nodes = g.nodes();
562 |     for (let channel of channels) {
563 |       if (nodes.indexOf("" + channel.from_addr) >= 0 && nodes.indexOf("" + channel.to_addr) >= 0) {
564 |         g.setEdge("" + channel.from_addr, "" + channel.to_addr, {
565 |           label: channel.id,
566 |         });
567 |       }
568 |     }
569 | 
570 |     svg.call(render, g);
571 |   }
572 | 
573 | 
574 | </script>
575 | </body>
576 | 


--------------------------------------------------------------------------------
/html/graph.html:
--------------------------------------------------------------------------------
  1 | <body>
  2 | 
  3 |   <script src="https://d3js.org/d3.v5.min.js"></script>
  4 |   <script src="https://rawgit.com/kawanet/msgpack-lite/master/dist/msgpack.min.js"></script>
  5 |   <script src="https://dagrejs.github.io/project/dagre-d3/latest/dagre-d3.js"></script>
  6 |   <script type="text/javascript">
  7 |   let width = 960,
  8 |       height = 1080;
  9 | 
 10 |   let svg_parent = d3.select("body").append("svg")
 11 |       .attr("width", width) 
 12 |       .attr("height", height);
 13 | 
 14 |   let svg = svg_parent.append("g");
 15 | 
 16 |   var zoom = d3.zoom()
 17 |       .on("zoom", function() {
 18 |           svg.attr("transform", d3.event.transform);
 19 |       });
 20 |   svg_parent.call(zoom);
 21 | 
 22 |   let g = new dagreD3.graphlib.Graph({compound:true});
 23 |   g.setGraph({
 24 |     nodesep: 10,
 25 |     ranksep: 10,
 26 |   });
 27 | 
 28 |   let render = new dagreD3.render();
 29 | 
 30 |   function update() {
 31 |     for (let o in all_operate) {
 32 |       let operator = all_operate[o];
 33 |       let html = "<div style=\"background-color: white;\">";
 34 |       html += "<span class=name>" + operator.name + "</span>";
 35 |       html += " (<span class=addr>" + operator.addr + "</span>)";
 36 |       html += "</div>";
 37 |       g.setNode("" + operator.addr, {
 38 |         labelType: "html",
 39 |         label: html,
 40 |         rx: 5,
 41 |         ry: 5,
 42 |       });
 43 |       function make_parent(is_g, addr) {
 44 |         if (addr.length > 2) {
 45 |           let parent_addr = addr.slice(0, -1);
 46 |           if (g.nodes().indexOf("" + parent_addr) == -1) {
 47 |             console.log("-> " + parent_addr);
 48 |             g.setNode("g" + parent_addr, { label: "Subgraph: " + parent_addr, style: 'fill: none; stroke: #000; stroke-width: 2px; stroke-dasharray: 2, 2;' });
 49 |             make_parent(true, parent_addr);
 50 |           }
 51 |           g.setParent((is_g ? "g" : "") + addr, "g" + parent_addr);
 52 |           console.log((is_g ? "g" : "") + addr + " parent: " + parent_addr);
 53 |         }
 54 |       }
 55 |       make_parent(false, operator.addr);
 56 |     }
 57 |     let nodes = g.nodes();
 58 |     for (let c in all_channel) {
 59 |       let channel = all_channel[c];
 60 |       if (nodes.indexOf("" + channel.from_addr) >= 0 && nodes.indexOf("" + channel.to_addr) >= 0) {
 61 |         g.setEdge("" + channel.from_addr, "" + channel.to_addr, {
 62 |           label: channel.id,
 63 |           style: channel.subgraph ? "stroke: #33f; stroke-width: 1px; stroke-dasharray: 5, 2; fill:none; " : "",
 64 |         });
 65 |       }
 66 |     }
 67 |     g.nodes().forEach(function(v) {
 68 |       var node = g.node(v);
 69 |       // Round the corners of the nodes
 70 |       node.rx = node.ry = 5;
 71 |     });
 72 |     console.log("RENDER: ");
 73 |     console.log(g._nodes);
 74 |     console.log(g._edges);
 75 |     svg.call(render, g);
 76 |   }
 77 | 
 78 |   </script>
 79 |   <script type="text/javascript">
 80 |     let websocket = new WebSocket("ws://localhost:9000/ws/");
 81 |     all_operate = [];
 82 |     all_channel = [];
 83 |     websocket.addEventListener('message', (event) => {
 84 |       let data = JSON.parse(event.data);
 85 |       console.log(data);
 86 |       for (let u in data.updates) {
 87 |         let update = data.updates[u];
 88 |         if (!!update.ChannelMessages) {
 89 | 
 90 |         } else if (!!update.Operate) {
 91 |           all_operate.push(update.Operate);
 92 |         } else if (!!update.Channel) {
 93 |           all_channel.push(update.Channel);
 94 |         }
 95 |       }
 96 |       update();
 97 |     });
 98 | 
 99 |   </script>
100 | 
101 | <style>
102 | text {
103 |   font-weight: 300;
104 |   font-family: "Helvetica Neue", Helvetica, Arial, sans-serf;
105 |   font-size: 14px;
106 | }
107 | 
108 | .node rect {
109 |   stroke: #333;
110 |   fill: #fff;
111 | }
112 | 
113 | .edgePath path {
114 |   stroke: #333;
115 |   fill: #333;
116 |   stroke-width: 1.5px;
117 | }
118 | 
119 | .node text {
120 |   pointer-events: none;
121 | }
122 | </style>
123 | </body>
124 | 
125 | 


--------------------------------------------------------------------------------
/html/schedule.html:
--------------------------------------------------------------------------------
  1 | <head>
  2 |   <script src="https://vega.github.io/vega/vega.js"></script>
  3 | </head>
  4 | <body>
  5 |  
  6 |   <button id="back">back</button>
  7 |   <div id="view"></div>
  8 |   
  9 |   <style>
 10 |   #back{
 11 |   padding: 10px 25px;
 12 |   font-size: 24px;
 13 |   text-align: center;
 14 |   outline: none;
 15 |   color: #fff;
 16 |   background-color: #42c2f4;
 17 |   border: none;
 18 |   border-radius: 10px;
 19 |   box-shadow: 0 4px #999;
 20 |   position:relative;
 21 |   }
 22 | 
 23 |  #back:hover {background-color: #4192f4}
 24 | 
 25 |  #back:active {
 26 |   background-color: #3e8e41;
 27 |  
 28 |  }
 29 |  </style>
 30 | 
 31 | 
 32 |   <script type="text/javascript">
 33 |     let my_spec = {
 34 |       "$schema": "https://vega.github.io/schema/vega/v4.json",
 35 |       "width": 700,
 36 |       "height": 600,
 37 |       "padding": 60,
 38 |     
 39 |       "data": [
 40 |       {
 41 |         "name": "table",
 42 |         "values": [
 43 |         ],
 44 |         "transform": [
 45 |           {
 46 |             "type": "filter",
 47 |             "expr": "datum.prefix == filterlist"
 48 |           }
 49 |         ]
 50 |       }
 51 |       ],
 52 |       "signals": [
 53 |         {
 54 |           "name": "filterlist",
 55 |           "value": "[0, 0]",
 56 |           "on": [{"events": "click", "update": "invert('yscale', y())"}]
 57 |         }
 58 |       ],
 59 |       "scales": [
 60 |       {
 61 |         "name": "yscale",
 62 |         "type": "band",
 63 |         "domain": {"data": "table", "field": "category"},
 64 |         "range": "height",
 65 |         "padding": 0.05,
 66 |         "round": true
 67 |       },
 68 |       {
 69 |         "name": "xscale",
 70 |         "domain": {"data": "table", "field": "value"},
 71 |         "nice": true,
 72 |         "range": "width"
 73 |       }
 74 |       ],
 75 |       "axes": [
 76 |       { "orient": "left", 
 77 |         "scale": "yscale",
 78 |         "titlePadding": 15,
 79 |         "title": "Category",
 80 |         "titleFontSize": 16,
 81 |         "labelFontSize": 14
 82 |       },
 83 |       {
 84 |         "orient": "bottom",
 85 |         "scale": "xscale",
 86 |         "labelOverlap": "parity",
 87 |         "title": "Time in ns",
 88 |         "titleFontSize": 16,
 89 |         "labelFontSize": 14
 90 |       }
 91 |       ],
 92 |       "marks": [
 93 |       {
 94 |         "type": "rect",
 95 |         "from": {"data":"table"},
 96 |         "encode": {
 97 |           "enter": {
 98 |             "y": {"scale": "yscale", "field": "category"},
 99 |             "height": {"scale": "yscale", "band": 1},
100 |             "x": {"scale": "xscale", "field": "value"},
101 |             "x2": {"scale": "xscale", "value": 0}
102 |           },
103 |           "update": {
104 |             "fill": {"value": "steelblue"},
105 |             "x": {"scale": "xscale", "field": "value"},
106 |             "height": {"scale": "yscale", "band": 1},
107 |             "y": {"scale": "yscale", "field": "category"},
108 |             "x2": {"scale": "xscale", "value": 0}
109 |           },
110 |           "hover": {
111 |             "fill": {"value": "#4192f4"}
112 |           }
113 |         }
114 |       },
115 |       {
116 |         "type": "text",
117 |         "encode": {
118 |           "enter": {
119 |             "fill": {"value": "black"},
120 |             "fontSize": {"value": 20},
121 |             "align": {"value": "right"}
122 |           },
123 |           "update": {
124 |             "text": {"signal": "'current filter: ' + filterlist"}
125 | 
126 |           }
127 |         }
128 |       }
129 |       ]
130 |     };
131 | 
132 |     const back_button = document.getElementById('back');
133 |    
134 |     var view = new
135 |     vega.View(vega.parse(my_spec))
136 |     .logLevel(vega.Warn)
137 |     .renderer('canvas')  // set renderer (canvas or svg)
138 |     .initialize('#view') // initialize view within parent DOM container
139 |     .hover()             // enable hover encode set processing
140 |     .run();
141 |     
142 |     let map1 = new Map();
143 |     let websocket = new WebSocket("ws://localhost:9000/ws/");
144 |     websocket.addEventListener('message', (event) => {
145 | 
146 |       let changeset = vega.changeset();
147 |       let updates = JSON.parse(event.data).updates;
148 |       
149 |       // view.addSignalListener('filterlist', (name, value) => {
150 |       //   console.log(value);
151 |       // });
152 | 
153 |       back_button.onclick = () => {
154 |         let cur = view.signal('filterlist');
155 |         view.signal('filterlist', cur.substring(0, cur.lastIndexOf(',')) + "]");
156 |       };
157 | 
158 |       let map_temp = new Map();
159 |       for (let update of updates) {
160 |          if (!map_temp.has(update.name)) {
161 |           map_temp.set(update.name, []);
162 |         }
163 |         map_temp.get(update.name).push(update);
164 |       }
165 | 
166 |       for (let [name, list] of map_temp) {
167 |         if (list.length == 1) {
168 | 
169 |           let obj = {
170 |             "category": list[0].name,
171 |             "value": list[0].size,
172 |             "prefix": list[0].name.substring(0, list[0].name.lastIndexOf(',')) + "]"
173 |           };
174 | 
175 |           if (list[0].diff == 1 ) {
176 |             changeset.insert(obj);
177 |             map1.set(list[0].name, obj);
178 |           }
179 |           else if (list[0].diff == -1) {
180 |             // NOTE: Intent is:
181 |             // changeset.remove(map1.get(list[0].name));
182 |             changeset.remove((x) => x.category == list[0].name);
183 |             map1.delete(list[0].name);
184 |           }
185 |         } else {
186 |           console.assert(list.length == 2,list );
187 |           for(let i=0; i<list.length; i++) {
188 |             if(list[i].diff == 1) {
189 |               let o = { "category": list[i].name, "value": list[i].size};
190 |               changeset.modify((x) => x.category == list[i].name, "value", list[i].size);
191 |               map1.set(list[i].name,o);
192 |             }
193 |           }
194 |         }
195 |       }
196 |       view.change('table', changeset).run();
197 | 
198 |         
199 |     });
200 |   </script>
201 | </body>


--------------------------------------------------------------------------------
/src/bin/dashboard.rs:
--------------------------------------------------------------------------------
  1 | extern crate timely;
  2 | extern crate differential_dataflow;
  3 | extern crate actix;
  4 | extern crate actix_web;
  5 | extern crate futures;
  6 | extern crate timely_viz;
  7 | 
  8 | extern crate abomonation;
  9 | #[macro_use] extern crate abomonation_derive;
 10 | 
 11 | extern crate serde;
 12 | #[macro_use] extern crate serde_derive;
 13 | extern crate serde_json;
 14 | 
 15 | use std::sync::{Arc, Mutex};
 16 | use std::time::Duration;
 17 | 
 18 | use timely::dataflow::operators::{Map, capture::Replay};
 19 | use timely::logging::TimelyEvent::{Operates, Schedule, Channels, Messages};
 20 | use timely::dataflow::operators::{Operator, Concat, Filter};
 21 | 
 22 | use differential_dataflow::AsCollection;
 23 | use differential_dataflow::operators::{Count, Consolidate};
 24 | 
 25 | use actix::*;
 26 | use actix_web::*;
 27 | use actix_web::{App, HttpRequest, Result, http::Method, fs::NamedFile};
 28 | 
 29 | use futures::future::Future;
 30 | 
 31 | // ==== Web-server setup ====
 32 | use timely_viz::server::Ws;
 33 | 
 34 | // #[derive(Serialize, Clone, Ord, PartialOrd, Eq, PartialEq)]
 35 | // struct Update {
 36 | //     data: String,   // name of data source.
 37 | //     name: String,
 38 | //     addr: String,
 39 | //     parent_addr: String,
 40 | //     size: isize,
 41 | //     diff: isize,
 42 | // }
 43 | 
 44 | 
 45 | #[derive(Serialize, Abomonation, Clone, PartialOrd, PartialEq, Eq, Ord, Debug)]
 46 | struct Update {
 47 |     event: Event,
 48 |     delta: isize,
 49 | }
 50 | 
 51 | #[derive(Serialize, Abomonation, Clone, PartialOrd, PartialEq, Eq, Ord, Debug)]
 52 | enum Event {
 53 |     // Largely static
 54 |     Operate {
 55 |         id: usize,              // unique identifier
 56 |         addr: Vec<usize>,       // (x, .., y, z)
 57 |         name: String,           // Helpful name
 58 |     },
 59 |     // Largely static
 60 |     Channel {
 61 |         id: usize,              // unique identifier
 62 |         from_addr: Vec<usize>,  // (x, .., y, z1)
 63 |         from_port: usize,       // port1
 64 |         to_addr: Vec<usize>,    // (x, .., y, z2)
 65 |         to_port: usize,         // port2
 66 |     },
 67 |     Schedule {
 68 |         operate_id: usize,
 69 |         elapsed_ns: isize,      // total elapsed ns
 70 |     },
 71 |     Messages {
 72 |         channel_id: usize,
 73 |         total_count: isize,     // total typed records
 74 |     }
 75 | }
 76 | 
 77 | 
 78 | #[derive(Serialize, Clone)]
 79 | struct Updates {
 80 |     updates: Vec<Update>,
 81 | }
 82 | 
 83 | impl actix::Message for Updates {
 84 |     type Result = ();
 85 | }
 86 | 
 87 | impl Handler<Updates> for Ws {
 88 |     type Result = ();
 89 | 
 90 |     fn handle(&mut self, msg: Updates, ctx: &mut Self::Context) {
 91 |         let text = serde_json::to_string(&msg).unwrap();
 92 |         // println!("Sending: {}", text);
 93 |         ctx.text(text);
 94 |     }
 95 | }
 96 | // ==========================
 97 | 
 98 | fn main() {
 99 |     let endpoint: Arc<Mutex<Vec<Addr<Syn, Ws>>>> = Arc::new(Mutex::new(Vec::new()));
100 |     let endpoint_actix = endpoint.clone();
101 | 
102 |     ::std::mem::drop(::std::thread::spawn(move || {
103 | 
104 |     let mut args = ::std::env::args();
105 |     args.next().unwrap();
106 | 
107 |     // the number of workers in the computation we're examining
108 |     let source_peers = args.next().expect("Must provide number of source peers").parse::<usize>().expect("Source peers must be an unsigned integer");
109 |     let frequency_ns = args.next().expect("Must provide nanoseconds frequency").parse::<u32>().expect("Frequency must be an unsigned integer");
110 |     let sockets = timely_viz::open_sockets(source_peers);
111 | 
112 |     timely::execute_from_args(std::env::args(), move |worker| {
113 | 
114 |         let endpoint = endpoint.clone();
115 | 
116 |         let sockets = sockets.clone();
117 | 
118 |         // create replayers from disjoint partition of source worker identifiers
119 |         let replayers = timely_viz::make_replayers(sockets, worker.index(), worker.peers());
120 | 
121 |         worker.dataflow::<Duration,_,_>(|scope| {
122 | 
123 |             let replayed = replayers.replay_into(scope);
124 | 
125 |             let operates =
126 |             replayed
127 |                 .flat_map(move |(mut ts, _setup, datum)|
128 |                     if let Operates(mut event) = datum {
129 |                         event.addr.insert(0, _setup);
130 |                         ts = round_duration_up_to_ns(ts, frequency_ns);
131 |                         Some((event, ts, 1))
132 |                     }
133 |                     else { None }
134 |                 )
135 |                 .as_collection()
136 |                 .filter(|x| x.addr[0] == 0)
137 |                 .map(|x| (x.id, x.addr, x.name))
138 |                 .consolidate()
139 |                 .inner
140 |                 .map(|((id, addr, name), _time, diff)| {
141 | 
142 |                     Update {
143 |                         event: Event::Operate {
144 |                             id,
145 |                             addr,
146 |                             name,
147 |                         },
148 |                         delta: diff,
149 |                     }
150 |                 });
151 | 
152 |             let channels =
153 |             replayed
154 |                 .flat_map(move |(mut ts,_setup,x)|
155 |                     if let Channels(mut event) = x {
156 |                         event.scope_addr.insert(0, _setup);
157 |                         ts = round_duration_up_to_ns(ts, frequency_ns);
158 |                         Some(((event.id, event.scope_addr, event.source, event.target), ts, 1 as isize))
159 |                     }
160 |                     else {
161 |                         None
162 |                     }
163 |                 )
164 |                 .as_collection()
165 |                 .consolidate()
166 |                 .inner
167 |                 .filter(|x| (x.0).1[0] == 0)
168 |                 .map(|((id, scope_addr, source, target), _time, diff)| {
169 | 
170 |                     let mut from_addr = scope_addr.clone();
171 |                     from_addr.push(source.0);
172 | 
173 |                     let mut to_addr = scope_addr.clone();
174 |                     to_addr.push(target.0);
175 | 
176 |                     Update {
177 |                         event: Event::Channel {
178 |                             id,
179 |                             from_addr,
180 |                             from_port: source.1,
181 |                             to_addr,
182 |                             to_port: target.1,
183 |                         },
184 |                         delta: diff,
185 |                     }
186 |                 });
187 | 
188 |             let messages =
189 |             replayed
190 |                 .flat_map(move |(mut ts,_,x)| {
191 |                     if let Messages(event) = x {
192 |                         ts = round_duration_up_to_ns(ts, frequency_ns);
193 |                         Some((event.channel, ts, event.length as isize))
194 |                     }
195 |                     else {
196 |                         None
197 |                     }
198 |                 })
199 |                 .as_collection()
200 |                 .count()
201 |                 .inner
202 |                 .map(|((channel_id, total_count), _time, diff)| {
203 |                     Update {
204 |                         event: Event::Messages {
205 |                             channel_id,
206 |                             total_count,
207 |                         },
208 |                         delta: diff,
209 |                     }
210 |                 });
211 | 
212 |             let schedule =
213 |             replayed
214 |                 .flat_map(move |(ts, worker, x)| if let Schedule(event) = x { Some((ts, worker, event)) } else { None })
215 |                 .unary(timely::dataflow::channels::pact::Pipeline, "Schedules", |_,_| {
216 | 
217 |                     let mut map = std::collections::HashMap::new();
218 |                     let mut vec = Vec::new();
219 | 
220 |                     move |input, output| {
221 | 
222 |                         input.for_each(|time, data| {
223 |                             data.swap(&mut vec);
224 |                             let mut session = output.session(&time);
225 |                             for (ts, worker, event) in vec.drain(..) {
226 |                                 let key = (worker, event.id);
227 |                                 match event.start_stop {
228 |                                     timely::logging::StartStop::Start => {
229 |                                         assert!(!map.contains_key(&key));
230 |                                         map.insert(key, ts);
231 |                                     },
232 |                                     timely::logging::StartStop::Stop => {
233 |                                         assert!(map.contains_key(&key));
234 |                                         let start = map.remove(&key).unwrap();
235 |                                         let mut ts_clip = round_duration_up_to_ns(ts, frequency_ns);
236 |                                         let elapsed = ts - start;
237 |                                         let elapsed_ns = (elapsed.as_secs() as isize) * 1_000_000_000 + (elapsed.subsec_nanos() as isize);
238 |                                         session.give((key.1, ts_clip, elapsed_ns));
239 |                                     }
240 |                                 }
241 |                             }
242 |                         });
243 |                     }
244 |                 })
245 |                 .as_collection()
246 |                 .count()
247 |                 .inner
248 |                 .map(|((operate_id, elapsed_ns), _time, diff)| {
249 |                     Update {
250 |                         event: Event::Schedule {
251 |                             operate_id,
252 |                             elapsed_ns,
253 |                         },
254 |                         delta: diff,
255 |                     }
256 |                 });
257 | 
258 |             operates
259 |                 .concat(&channels)
260 |                 .concat(&messages)
261 |                 .concat(&schedule)
262 |                 .sink(timely::dataflow::channels::pact::Pipeline, "ToVega", move |input| {
263 | 
264 |                     let mut updates = Vec::new();
265 | 
266 |                     input.for_each(|_time, dataz| {
267 |                         for update in dataz.iter().cloned() {
268 |                             updates.push(update);
269 |                         }
270 |                     });
271 | 
272 |                     updates.sort();
273 |                     for i in 1 .. updates.len() {
274 |                         if updates[i-1].event == updates[i].event {
275 |                             updates[i].delta += updates[i-1].delta;
276 |                             updates[i-1].delta = 0;
277 |                         }
278 |                     }
279 |                     updates.retain(|x| x.delta != 0);
280 | 
281 |                     if !updates.is_empty() {
282 |                         for chan in endpoint.lock().unwrap().iter_mut() {
283 |                             let updates = Updates { updates: updates.clone() };
284 |                             chan.send(updates).wait().unwrap();
285 |                         }
286 |                     }
287 |                 });
288 |         });
289 | 
290 |     }).unwrap(); // asserts error-free execution
291 | 
292 |     }));
293 | 
294 |     fn index(_req: HttpRequest) -> Result<NamedFile> {
295 |         let html_file = ::std::env::args().nth(3).expect("Must provide path to html file");
296 |         Ok(NamedFile::open(html_file)?)
297 |     }
298 | 
299 |     server::new(move || {
300 |         let endpoint_actix = endpoint_actix.clone();
301 |         App::new()
302 |             .resource("/ws/", move |r| {
303 |                 let endpoint_actix = endpoint_actix.clone();
304 |                 r.f(move |req| ws::start(req, Ws { addr: endpoint_actix.clone() }))
305 |             })
306 |             .resource("/", |r| r.method(Method::GET).f(index))
307 |     }).bind("0.0.0.0:9000").unwrap().run();
308 | }
309 | 
310 | fn round_duration_up_to_ns(mut duration: Duration, nanos: u32) -> Duration {
311 |     duration += Duration::from_nanos(nanos as u64);
312 |     duration /= nanos;
313 |     duration *= nanos;
314 |     duration
315 | }
316 | 


--------------------------------------------------------------------------------
/src/bin/graph.rs:
--------------------------------------------------------------------------------
  1 | extern crate timely;
  2 | extern crate differential_dataflow;
  3 | extern crate timely_viz;
  4 | 
  5 | extern crate abomonation;
  6 | #[macro_use] extern crate abomonation_derive;
  7 | 
  8 | extern crate actix;
  9 | extern crate actix_web;
 10 | extern crate futures;
 11 | 
 12 | extern crate serde;
 13 | #[macro_use] extern crate serde_derive;
 14 | extern crate serde_json;
 15 | 
 16 | use std::sync::{Arc, Mutex};
 17 | 
 18 | use timely::dataflow::operators::{Map, capture::Replay, Concat, Inspect};
 19 | use timely::logging::TimelyEvent::{Operates, Channels};
 20 | 
 21 | use differential_dataflow::collection::AsCollection;
 22 | use differential_dataflow::operators::{Consolidate, Join, Threshold};
 23 | 
 24 | use actix::*;
 25 | use actix_web::*;
 26 | use actix_web::{App, HttpRequest, Result, http::Method, fs::NamedFile};
 27 | 
 28 | use futures::future::Future;
 29 | 
 30 | #[derive(Serialize, Abomonation, Clone, PartialOrd, PartialEq, Eq, Ord, Debug)]
 31 | enum Update {
 32 |     Operate {
 33 |         addr: Vec<usize>,
 34 |         name: String,
 35 |     },
 36 |     Channel {
 37 |         id: usize,
 38 |         from_addr: Vec<usize>,
 39 |         to_addr: Vec<usize>,
 40 |         subgraph: bool,
 41 |     },
 42 | }
 43 | 
 44 | // ==== Web-server setup ====
 45 | use timely_viz::server::Ws;
 46 | 
 47 | #[derive(Serialize, Clone)]
 48 | struct Updates {
 49 |     updates: Vec<Update>,
 50 | }
 51 | 
 52 | impl actix::Message for Update {
 53 |     type Result = ();
 54 | }
 55 | 
 56 | impl actix::Message for Updates {
 57 |     type Result = ();
 58 | }
 59 | 
 60 | impl Handler<Updates> for Ws {
 61 |     type Result = ();
 62 | 
 63 |     fn handle(&mut self, msg: Updates, ctx: &mut Self::Context) {
 64 |         ctx.text(serde_json::to_string(&msg).unwrap());
 65 |     }
 66 | }
 67 | // ==========================
 68 | 
 69 | fn main() {
 70 |     let endpoint: Arc<Mutex<Vec<Addr<Syn, Ws>>>> = Arc::new(Mutex::new(Vec::new()));
 71 |     let endpoint_actix = endpoint.clone();
 72 | 
 73 |     ::std::mem::drop(::std::thread::spawn(move || {
 74 | 
 75 |     let mut args = ::std::env::args();
 76 |     args.next().unwrap();
 77 | 
 78 |     // the number of workers in the computation we're examining
 79 |     let source_peers = args.next().unwrap().parse::<usize>().unwrap();
 80 |     // one socket per worker in the computation we're examining
 81 |     let sockets = timely_viz::open_sockets(source_peers);
 82 | 
 83 |     timely::execute_from_args(args, move |worker| {
 84 |         let endpoint = endpoint.clone();
 85 |         let sockets = sockets.clone();
 86 | 
 87 |         // create replayers from disjoint partition of source worker identifiers.
 88 |         let replayers = timely_viz::make_replayers(sockets, worker.index(), worker.peers());
 89 | 
 90 |         worker.dataflow(|scope| {
 91 |             let stream =
 92 |             replayers
 93 |                 .replay_into(scope);
 94 | 
 95 |             let operates =
 96 |             stream
 97 |                 .flat_map(|(t,_,x)| if let Operates(event) = x { Some((event, t, 1 as isize)) } else { None })
 98 |                 .as_collection();
 99 | 
100 |             let channels =
101 |             stream
102 |                 .flat_map(|(t,_,x)| if let Channels(event) = x { Some((event, t, 1 as isize)) } else { None })
103 |                 .as_collection();
104 | 
105 |             // == Fix addresses so we can connect operators outside and inside subgraphs ==
106 | 
107 |             let operates = operates.map(|event| (event.addr, event.name)).inspect(|x| println!("Operates: {:?}", x.0));
108 | 
109 |             let operates_anti = operates.map(|(mut addr, _)| {
110 |                 addr.pop();
111 |                 addr
112 |             });
113 | 
114 |             let operates_without_subg = operates.antijoin(&operates_anti.distinct());
115 | 
116 |             let channels = channels.map(
117 |                 |event| (event.id, (event.scope_addr, event.source, event.target))).inspect(|x| println!("Channels: {:?}", x.0));
118 | 
119 |             ({
120 |                 operates_without_subg
121 |                     .filter(|(addr, _)| addr[0] == 0)
122 |                     .consolidate()
123 |                     .inner
124 |                     .map(move |((addr, name), _, _)| {
125 |                         let mut addr = addr.clone();
126 |                         addr.remove(0);
127 |                         Update::Operate {
128 |                             addr: addr.clone(),
129 |                             name: name.clone(),
130 |                         }
131 |                     })
132 |             }).concat(&{
133 |                 let worker_0 = channels
134 |                     .filter(|(_, (scope_addr, _, _))| scope_addr[0] == 0)
135 |                     .map(|(id, (scope_addr, from, to))| {
136 |                         let mut scope_addr = scope_addr.clone();
137 |                         scope_addr.remove(0);
138 |                         (id, (scope_addr, from, to))
139 |                     });
140 | 
141 |                 let subg_edges = worker_0
142 |                     .filter(|(_, (_, from, to))| from.0 == 0 || to.0 == 0)
143 |                     .flat_map(|(id, (scope_addr, from, to))| vec![
144 |                               ((scope_addr.clone(), from.1), (id, (scope_addr.clone(), from, to))),
145 |                               ((scope_addr.clone(), to.1), (id, (scope_addr.clone(), from, to)))].into_iter());
146 | 
147 |                 let subg_incoming = subg_edges
148 |                     .join_map(&worker_0.map(|(id, (scope_addr, from, to))| {
149 |                         let mut from_addr = scope_addr.clone();
150 |                         from_addr.push(from.0);
151 |                         ((from_addr, from.1), (id, (scope_addr, from, to)))
152 |                     }), |(_from_addr, _), (id, (scope_addr_from, from, _)), (_, (scope_addr_to, _, to))| {
153 |                         let mut from_addr = scope_addr_from.clone();
154 |                         from_addr.push(from.0);
155 |                         let mut to_addr = scope_addr_to.clone();
156 |                         to_addr.push(to.0);
157 |                         Update::Channel {
158 |                             id: *id,
159 |                             subgraph: true,
160 |                             from_addr,
161 |                             to_addr,
162 |                         }
163 |                     });
164 | 
165 |                 let subg_outgoing = subg_edges
166 |                     .join_map(&worker_0.map(|(id, (scope_addr, from, to))| {
167 |                         let mut to_addr = scope_addr.clone();
168 |                         to_addr.push(to.0);
169 |                         ((to_addr, to.1), (id, (scope_addr, from, to)))
170 |                     }), |(_to_addr, _), (id, (scope_addr_to, _, to)), (_, (scope_addr_from, from, _))| {
171 |                         let mut from_addr = scope_addr_from.clone();
172 |                         from_addr.push(from.0);
173 |                         let mut to_addr = scope_addr_to.clone();
174 |                         to_addr.push(to.0);
175 |                         Update::Channel {
176 |                             id: *id,
177 |                             subgraph: true,
178 |                             from_addr,
179 |                             to_addr,
180 |                         }
181 |                     });
182 | 
183 |                 worker_0
184 |                     .filter(|(_, (_, from, to))| from.0 != 0 && to.0 != 0)
185 |                     .consolidate()
186 |                     .inner
187 |                     .map(move |((id, (scope_addr, (from, _), (to, _))), _, _)| {
188 |                         let mut from_addr = scope_addr.clone();
189 |                         from_addr.push(from);
190 |                         let mut to_addr = scope_addr.clone();
191 |                         to_addr.push(to);
192 |                         Update::Channel {
193 |                             id,
194 |                             subgraph: false,
195 |                             from_addr,
196 |                             to_addr,
197 |                         }
198 |                     })
199 |                     .concat(&subg_incoming.inner.map(|(x, _, _)| x))
200 |                     .concat(&subg_outgoing.inner.map(|(x, _, _)| x))
201 |             // Push the updates to the browser
202 |             }).inspect_batch(move |_, x| {
203 |                 for chan in endpoint.lock().unwrap().iter_mut() {
204 |                     chan.send(Updates { updates: x.to_vec() }).wait().unwrap();
205 |                 }
206 |             });
207 |         })
208 |     }).unwrap(); // asserts error-free execution
209 | 
210 |     }));
211 | 
212 | 
213 |     // == Start the web-server ==
214 |     fn index(_req: HttpRequest) -> Result<NamedFile> {
215 |         Ok(NamedFile::open("html/graph.html")?)
216 |     }
217 | 
218 |     server::new(move || {
219 |         let endpoint_actix = endpoint_actix.clone();
220 |         App::new()
221 |             .resource("/ws/", move |r| {
222 |                 let endpoint_actix = endpoint_actix.clone();
223 |                 r.f(move |req| ws::start(req, Ws { addr: endpoint_actix.clone() }))
224 |             })
225 |             .resource("/", |r| r.method(Method::GET).f(index))
226 |     }).bind("0.0.0.0:9000").unwrap().disable_signals().run();
227 | }
228 | 


--------------------------------------------------------------------------------
/src/bin/schedule.rs:
--------------------------------------------------------------------------------
  1 | extern crate timely;
  2 | extern crate differential_dataflow;
  3 | extern crate actix;
  4 | extern crate actix_web;
  5 | extern crate futures;
  6 | extern crate timely_viz;
  7 | 
  8 | extern crate serde;
  9 | #[macro_use] extern crate serde_derive;
 10 | extern crate serde_json;
 11 | 
 12 | use std::time::Duration;
 13 | use std::sync::{Arc, Mutex};
 14 | 
 15 | use timely::dataflow::operators::{Map, capture::Replay};
 16 | use timely::logging::TimelyEvent::{Operates, Schedule};
 17 | use timely::dataflow::operators::Operator;
 18 | 
 19 | use differential_dataflow::AsCollection;
 20 | use differential_dataflow::operators::{Join, Count};
 21 | 
 22 | use actix::*;
 23 | use actix_web::*;
 24 | use actix_web::{App, HttpRequest, Result, http::Method, fs::NamedFile};
 25 | 
 26 | use futures::future::Future;
 27 | 
 28 | // ==== Web-server setup ====
 29 | use timely_viz::server::Ws;
 30 | 
 31 | #[derive(Serialize, Clone, Ord, PartialOrd, Eq, PartialEq)]
 32 | struct Update {
 33 |     data: String,   // name of data source.
 34 |     name: String,
 35 |     id: String,
 36 |     parent_id: String,
 37 |     size: isize,
 38 |     diff: isize,
 39 | }
 40 | 
 41 | #[derive(Serialize, Clone)]
 42 | struct Updates {
 43 |     updates: Vec<Update>,
 44 | }
 45 | 
 46 | impl actix::Message for Updates {
 47 |     type Result = ();
 48 | }
 49 | 
 50 | impl Handler<Updates> for Ws{
 51 |     type Result = ();
 52 | 
 53 |     fn handle(&mut self, msg: Updates, ctx: &mut Self::Context) {
 54 |         let text = serde_json::to_string(&msg).unwrap();
 55 |         println!("Sending: {}", text);
 56 |         ctx.text(text);
 57 |     }
 58 | }
 59 | // ==========================
 60 | 
 61 | fn main() {
 62 |     let endpoint: Arc<Mutex<Vec<Addr<Syn, Ws>>>> = Arc::new(Mutex::new(Vec::new()));
 63 |     let endpoint_actix = endpoint.clone();
 64 | 
 65 |     ::std::mem::drop(::std::thread::spawn(move || {
 66 | 
 67 |     let mut args = ::std::env::args();
 68 |     args.next().unwrap();
 69 | 
 70 |     // the number of workers in the computation we're examining
 71 |     let source_peers = args.next().unwrap().parse::<usize>().unwrap();
 72 |     let sockets = timely_viz::open_sockets(source_peers);
 73 | 
 74 |     timely::execute_from_args(std::env::args(), move |worker| {
 75 | 
 76 |         let endpoint = endpoint.clone();
 77 | 
 78 |         let sockets = sockets.clone();
 79 | 
 80 |         // create replayers from disjoint partition of source worker identifiers
 81 |         let replayers = timely_viz::make_replayers(sockets, worker.index(), worker.peers());
 82 | 
 83 |         worker.dataflow(|scope| {
 84 | 
 85 |             let replayed = replayers.replay_into(scope);
 86 | 
 87 |             let operates =
 88 |             replayed
 89 |                 .flat_map(|(ts, _setup, datum)|
 90 |                     if let Operates(event) = datum {
 91 |                         let ts = Duration::from_secs(ts.as_secs() + 1);
 92 |                         Some((event, ts, 1))
 93 |                     }
 94 |                     else {
 95 |                         None
 96 |                     }
 97 |                 )
 98 |                 .as_collection();
 99 | 
100 |             let schedule =
101 |             replayed
102 |                 .flat_map(|(ts, worker, x)| if let Schedule(event) = x { Some((ts, worker, event)) } 
103 |                     else { None })
104 |                 .unary(timely::dataflow::channels::pact::Pipeline, "Schedules", |_,_| {
105 | 
106 |                     let mut map = std::collections::HashMap::new();
107 |                     let mut vec = Vec::new();
108 |                     
109 |                     move |input, output| {
110 | 
111 |                         input.for_each(|time, data| {
112 |                             data.swap(&mut vec);
113 |                             let mut session = output.session(&time);
114 |                             for (ts, worker, event) in vec.drain(..) {
115 |                                 let key = (worker, event.id);
116 |                                 match event.start_stop {
117 |                                     timely::logging::StartStop::Start => {
118 |                                         assert!(!map.contains_key(&key));
119 |                                         map.insert(key, ts);
120 |                                     },
121 |                                     timely::logging::StartStop::Stop => {
122 |                                         assert!(map.contains_key(&key));
123 |                                         let end = map.remove(&key).unwrap();
124 | //                                        if work {
125 |                                             let ts_clip = Duration::from_secs(ts.as_secs() + 1);
126 |                                             let elapsed = ts - end;
127 |                                             let elapsed_ns = (elapsed.as_secs() as isize) * 1_000_000_000 + (elapsed.subsec_nanos() as isize);
128 |                                             session.give((key.1, ts_clip, elapsed_ns));
129 | //                                        }
130 |                                     }
131 |                                 }
132 |                             }
133 |                         });
134 |                     }
135 |                 })
136 |                 .as_collection();
137 | 
138 |             operates
139 |                 .map(|x| (x.id, x.addr))
140 |                 .filter(|x| x.1[0] == 0)
141 |                 .semijoin(&schedule)
142 |                 .map(|(_id, addr)| addr)
143 |                 .count()
144 |                 .inner
145 |                 .sink(timely::dataflow::channels::pact::Pipeline, "ToVega", move |input| {
146 |                     let mut updates = Updates { updates: Vec::new() };
147 | 
148 |                     input.for_each(|_time, dataz| {
149 |                         for ((ref addr, count), _time, diff) in dataz.iter() {
150 |                             if addr.len() > 0 {
151 |                                 updates.updates.push(
152 |                                     Update {
153 |                                         data: "tree".to_string(),
154 |                                         name: format!("{:?}", &addr[..]),
155 |                                         id: format!("{:?}", &addr[..]),
156 |                                         parent_id: format!("{:?}", &addr[.. addr.len()-1]),
157 |                                         size: *count,
158 |                                         diff: *diff,
159 |                                     }
160 |                                 );
161 |                             }
162 |                         }
163 |                     });
164 | 
165 |                     updates.updates.sort();
166 |                     for i in 1 .. updates.updates.len() {
167 |                         if updates.updates[i-1].id == updates.updates[i].id && updates.updates[i-1].size == updates.updates[i].size {
168 |                             updates.updates[i].diff += updates.updates[i-1].diff;
169 |                             updates.updates[i-1].diff = 0;
170 |                         }
171 |                     }
172 |                     updates.updates.retain(|x| x.diff != 0);
173 |                     if !updates.updates.is_empty() {
174 |                         for chan in endpoint.lock().unwrap().iter_mut() {
175 |                             chan.send(updates.clone()).wait().unwrap();
176 |                         }
177 |                     }
178 |                 });
179 |         });
180 | 
181 |     }).unwrap(); // asserts error-free execution
182 |     }));
183 | 
184 |     fn index(_req: HttpRequest) -> Result<NamedFile> {
185 |         Ok(NamedFile::open("html/schedule.html")?)
186 |     }
187 | 
188 |     server::new(move || {
189 |         let endpoint_actix = endpoint_actix.clone();
190 |         App::new()
191 |             .resource("/ws/", move |r| {
192 |                 let endpoint_actix = endpoint_actix.clone();
193 |                 r.f(move |req| ws::start(req, Ws { addr: endpoint_actix.clone() }))
194 |             })
195 |             .resource("/", |r| r.method(Method::GET).f(index))
196 |     }).bind("0.0.0.0:9000").unwrap().run();
197 | }
198 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | extern crate timely;
 2 | extern crate differential_dataflow;
 3 | 
 4 | extern crate actix;
 5 | extern crate actix_web;
 6 | 
 7 | pub mod server;
 8 | 
 9 | use std::time::Duration;
10 | use std::sync::{Arc, Mutex};
11 | use std::net::{TcpStream, TcpListener};
12 | 
13 | use timely::dataflow::operators::capture::EventReader;
14 | use timely::logging::{WorkerIdentifier, TimelyEvent};
15 | 
16 | /// Listens on 127.0.0.1:8000 and opens `source_peers` sockets from the
17 | /// computations we're examining.
18 | pub fn open_sockets(source_peers: usize) -> Arc<Mutex<Vec<Option<TcpStream>>>> {
19 |     let listener = TcpListener::bind("127.0.0.1:8000").unwrap();
20 |     Arc::new(Mutex::new(
21 |             (0..source_peers).map(|_| {
22 |                 Some(listener.incoming().next().unwrap().unwrap())
23 |             }).collect::<Vec<_>>()))
24 | }
25 | 
26 | /// Construct replayers that read data from sockets and can stream it into
27 | /// timely dataflow.
28 | pub fn make_replayers(sockets: Arc<Mutex<Vec<Option<TcpStream>>>>, index: usize, peers: usize) -> Vec<EventReader<Duration, (Duration, WorkerIdentifier, TimelyEvent), TcpStream>> {
29 | 
30 |     sockets.lock().unwrap()
31 |         .iter_mut().enumerate()
32 |         .filter(|(i, _)| *i % peers == index)
33 |         .map(move |(_, s)| s.take().unwrap())
34 |         .map(|r| EventReader::<Duration, (Duration, WorkerIdentifier, TimelyEvent),_>::new(r))
35 |         .collect::<Vec<_>>()
36 | }
37 | 


--------------------------------------------------------------------------------
/src/server.rs:
--------------------------------------------------------------------------------
 1 | /// Web-server
 2 | 
 3 | use actix::*;
 4 | use actix_web::*;
 5 | 
 6 | use std::sync::{Arc, Mutex};
 7 | 
 8 | pub struct Ws {
 9 |     pub addr: Arc<Mutex<Vec<Addr<Syn, Ws>>>>,
10 | }
11 | 
12 | impl Actor for Ws {
13 |     type Context = ws::WebsocketContext<Self>;
14 | 
15 |     fn started(&mut self, ctx: &mut Self::Context) {
16 |         let addr: Addr<Syn, Ws> = ctx.address();
17 |         self.addr.lock().unwrap().push(addr);
18 |     }
19 | }
20 | 
21 | impl StreamHandler<ws::Message, ws::ProtocolError> for Ws {
22 |     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
23 |         match msg {
24 |             ws::Message::Ping(msg) => ctx.pong(&msg),
25 |             _ => (),
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------