Debian Codegraph @

rts/javascript/server.js

raw
1 // Start of server.js
2
3 class Server {
4
5 constructor(ctx) {
6 this.ctx = ctx;
7 this._vars = {};
8 this._types = {};
9 this._commands = [ 'inputs',
10 'outputs',
11 'call',
12 'restore',
13 'store',
14 'free',
15 'clear',
16 'pause_profiling',
17 'unpause_profiling',
18 'report',
19 'rename'
20 ];
21 }
22
23 _get_arg(args, i) {
24 if (i < args.length) {
25 return args[i];
26 } else {
27 throw 'Insufficient command args';
28 }
29 }
30
31 _get_entry_point(entry) {
32 if (entry in this.ctx.get_entry_points()) {
33 return this.ctx.get_entry_points()[entry];
34 } else {
35 throw "Unkown entry point: " + entry;
36 }
37 }
38
39 _check_var(vname) {
40 if (!(vname in this._vars)) {
41 throw 'Unknown variable: ' + vname;
42 }
43 }
44
45 _set_var(vname, v, t) {
46 this._vars[vname] = v;
47 this._types[vname] = t;
48 }
49
50 _get_type(vname) {
51 this._check_var(vname);
52 return this._types[vname];
53 }
54
55 _get_var(vname) {
56 this._check_var(vname);
57 return this._vars[vname];
58 }
59
60 _cmd_inputs(args) {
61 var entry = this._get_arg(args, 0);
62 var inputs = this._get_entry_point(entry)[1];
63 for (var i = 0; i < inputs.length; i++) {
64 console.log(inputs[i]);
65 }
66 }
67
68 _cmd_outputs(args) {
69 var entry = this._get_arg(args, 0);
70 var outputs = this._get_entry_point(entry)[2];
71 for (var i = 0; i < outputs.length; i++) {
72 console.log(outputs[i]);
73 }
74 }
75
76 _cmd_dummy(args) {
77 // pass
78 }
79
80 _cmd_free(args) {
81 for (var i = 0; i < args.length; i++) {
82 var vname = args[i];
83 this._check_var(vname);
84 delete this._vars[vname];
85 }
86 }
87
88 _cmd_rename(args) {
89 var oldname = this._get_arg(args, 0)
90 var newname = this._get_arg(args, 1)
91 if (newname in this._vars) {
92 throw "Variable already exists: " + newname;
93 }
94 this._vars[newname] = this._vars[oldname];
95 this._types[newname] = this._types[oldname];
96 delete this._vars[oldname];
97 delete this._types[oldname];
98 }
99
100 _cmd_call(args) {
101 var entry = this._get_entry_point(this._get_arg(args, 0));
102 var num_ins = entry[1].length;
103 var num_outs = entry[2].length;
104 var expected_len = 1 + num_outs + num_ins
105
106 if (args.length != expected_len) {
107 throw "Invalid argument count, expected " + expected_len
108 }
109
110 var out_vnames = args.slice(1, num_outs+1)
111 for (var i = 0; i < out_vnames.length; i++) {
112 var out_vname = out_vnames[i];
113 if (out_vname in this._vars) {
114 throw "Variable already exists: " + out_vname;
115 }
116 }
117 var in_vnames = args.slice(1+num_outs);
118 var ins = [];
119 for (var i = 0; i < in_vnames.length; i++) {
120 ins.push(this._get_var(in_vnames[i]));
121 }
122 // Call entry point function from string name
123 var bef = performance.now()*1000;
124 var vals = this.ctx[entry[0]].apply(this.ctx, ins);
125 var aft = performance.now()*1000;
126 if (num_outs == 1) {
127 this._set_var(out_vnames[0], vals, entry[2][0]);
128 } else {
129 for (var i = 0; i < out_vnames.length; i++) {
130 this._set_var(out_vnames[i], vals[i], entry[2][i]);
131 }
132 }
133 console.log("runtime: " + Math.round(aft-bef));
134 }
135
136 _cmd_store(args) {
137 var fname = this._get_arg(args, 0);
138 for (var i = 1; i < args.length; i++) {
139 var vname = args[i];
140 var value = this._get_var(vname);
141 var typ = this._get_type(vname);
142 var fs = require("fs");
143 var bin_val = construct_binary_value(value, typ);
144 fs.appendFileSync(fname, bin_val, 'binary')
145 }
146 }
147
148 fut_to_dim_typ(typ) {
149 var type = typ;
150 var count = 0;
151 while (type.substr(0, 2) == '[]') {
152 count = count + 1;
153 type = type.slice(2);
154 }
155 return [count, type];
156 }
157
158 _cmd_restore(args) {
159 if (args.length % 2 == 0) {
160 throw "Invalid argument count";
161 }
162
163 var fname = args[0];
164 var args = args.slice(1);
165
166 var as = args;
167 var reader = new Reader(fname);
168 while (as.length != 0) {
169 var vname = as[0];
170 var typename = as[1];
171 as = as.slice(2);
172
173 if (vname in this._vars) {
174 throw "Variable already exists: " + vname;
175 }
176 try {
177 var value = read_value(typename, reader);
178 if (typeof value == 'number' || typeof value == 'bigint') {
179 this._set_var(vname, value, typename);
180 } else {
181 // We are working with an array and need to create to convert [shape, arr] to futhark ptr
182 var shape= value[0];
183 var arr = value[1];
184 var dimtyp = this.fut_to_dim_typ(typename);
185 var dim = dimtyp[0];
186 var typ = dimtyp[1];
187 var arg_list = [arr, ...shape];
188 var fnam = "new_" + typ + "_" + dim + "d";
189 var ptr = this.ctx[fnam].apply(this.ctx, arg_list);
190 this._set_var(vname, ptr, typename);
191 }
192 } catch (err) {
193 var err_msg = "Failed to restore variable " + vname + ".\nPossibly malformed data in " + fname + ".\n" + err.toString();
194 throw err_msg;
195 }
196 }
197 skip_spaces(reader);
198 if (reader.get_buff().length != 0) {
199 throw "Expected EOF after reading values";
200 }
201 }
202
203 _process_line(line) {
204 // TODO make sure it splits on anywhite space
205 var words = line.split(" ");
206 if (words.length == 0) {
207 throw "Empty line";
208 } else {
209 var cmd = words[0];
210 var args = words.splice(1);
211 if (this._commands.includes(cmd)) {
212 switch (cmd) {
213 case 'inputs': this._cmd_inputs(args); break;
214 case 'outputs': this._cmd_outputs(args); break
215 case 'call': this._cmd_call(args); break
216 case 'restore': this._cmd_restore(args); break
217 case 'store': this._cmd_store(args); break
218 case 'free': this._cmd_free(args); break
219 case 'clear': this._cmd_dummy(args); break
220 case 'pause_profiling': this._cmd_dummy(args); break
221 case 'unpause_profiling': this._cmd_dummy(args); break
222 case 'report': this._cmd_dummy(args); break
223 case 'rename': this._cmd_rename(args); break
224 }
225 } else {
226 throw "Unknown command: " + cmd;
227 }
228 }
229 }
230
231 run() {
232 console.log('%%% OK'); // TODO figure out if flushing is neccesary for JS
233 const readline = require('readline');
234 const rl = readline.createInterface(process.stdin);
235 rl.on('line', (line) => {
236 if (line == "") {
237 rl.close();
238 }
239 try {
240 this._process_line(line);
241 console.log('%%% OK');
242 } catch (err) {
243 console.log('%%% FAILURE');
244 console.log(err);
245 console.log('%%% OK');
246 }
247 }).on('close', () => { process.exit(0); });
248 }
249 }
250
251 // End of server.js