1 //: Phase 3: Start running a loaded and transformed recipe.
  2 //:
  3 //:   The process of running Mu code:
  4 //:     load -> transform -> run
  5 //:
  6 //: So far we've seen recipes as lists of instructions, and instructions point
  7 //: at other recipes. To kick things off Mu needs to know how to run certain
  8 //: 'primitive' recipes. That will then give the ability to run recipes
  9 //: containing these primitives.
 10 //:
 11 //: This layer defines a skeleton with just two primitive recipes: IDLE which
 12 //: does nothing, and COPY, which can copy numbers from one memory location to
 13 //: another. Later layers will add more primitives.
 14 
 15 :(scenario copy_literal)
 16 def main [
 17   1:num <- copy 23
 18 ]
 19 +run: {1: "number"} <- copy {23: "literal"}
 20 +mem: storing 23 in location 1
 21 
 22 :(scenario copy)
 23 def main [
 24   1:num <- copy 23
 25   2:num <- copy 1:num
 26 ]
 27 +run: {2: "number"} <- copy {1: "number"}
 28 +mem: location 1 is 23
 29 +mem: storing 23 in location 2
 30 
 31 :(scenario copy_multiple)
 32 def main [
 33   1:num, 2:num <- copy 23, 24
 34 ]
 35 +mem: storing 23 in location 1
 36 +mem: storing 24 in location 2
 37 
 38 :(before "End Types")
 39 // Book-keeping while running a recipe.
 40 //: Later layers will replace this to support running multiple routines at once.
 41 struct routine {
 42   recipe_ordinal running_recipe;
 43   int running_step_index;
 44   routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {}
 45   bool completed() const;
 46   const vector<instruction>& steps() const;
 47 };
 48 
 49 :(before "End Globals")
 50 routine* Current_routine = NULL;
 51 map<string, int> Instructions_running;
 52 map<string, int> Locations_read;
 53 map<string, int> Locations_read_by_instruction;
 54 :(before "End Setup")
 55 Current_routine = NULL;
 56 
 57 :(code)
 58 void run(const recipe_ordinal r) {
 59   routine rr(r);
 60   Current_routine = &rr;
 61   run_current_routine();
 62   Current_routine = NULL;
 63 }
 64 
 65 void run_current_routine() {
 66   while (should_continue_running(Current_routine)) {  // beware: may modify Current_routine
 67   ¦ // Running One Instruction
 68 //?     Instructions_running[current_recipe_name()]++;
 69   ¦ if (current_instruction().is_label) { ++current_step_index();  continue; }
 70   ¦ trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << to_string(current_instruction()) << end();
 71   ¦ if (get_or_insert(Memory, 0) != 0) {
 72   ¦ ¦ raise << "something wrote to location 0; this should never happen\n" << end();
 73   ¦ ¦ put(Memory, 0, 0);
 74   ¦ }
 75   ¦ // read all ingredients from memory, each potentially spanning multiple locations
 76   ¦ vector<vector<double> > ingredients;
 77   ¦ if (should_copy_ingredients()) {
 78   ¦ ¦ for (int i = 0;  i < SIZE(current_instruction().ingredients);  ++i)
 79   ¦ ¦ ¦ ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
 80   ¦ }
 81   ¦ // instructions below will write to 'products'
 82   ¦ vector<vector<double> > products;
 83   ¦ switch (current_instruction().operation) {
 84   ¦ ¦ // Primitive Recipe Implementations
 85   ¦ ¦ case COPY: {
 86   ¦ ¦ ¦ copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
 87   ¦ ¦ ¦ break;
 88   ¦ ¦ }
 89   ¦ ¦ // End Primitive Recipe Implementations
 90   ¦ ¦ default: {
 91   ¦ ¦ ¦ cout << "not a primitive op: " << current_instruction().operation << '\n';
 92   ¦ ¦ }
 93   ¦ }
 94   ¦ //: used by a later layer
 95   ¦ Writing_products_of_instruction = true;
 96   ¦ if (SIZE(products) < SIZE(current_instruction().products)) {
 97   ¦ ¦ raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products in '" << to_original_string(current_instruction()) << "'\n" << end();
 98   ¦ }
 99   ¦ else {
100   ¦ ¦ for (int i = 0;  i < SIZE(current_instruction().products);  ++i)
101   ¦ ¦ ¦ write_memory(current_instruction().products.at(i), products.at(i));
102   ¦ }
103   ¦ Writing_products_of_instruction = false;
104   ¦ // End Running One Instruction
105   ¦ finish_instruction:;
106   ¦ ++current_step_index();
107   }
108   stop_running_current_routine:;
109 }
110 :(before "End Globals")
111 bool Writing_products_of_instruction = false;
112 
113 :(code)
114 //: hook replaced in a later layer
115 bool should_continue_running(const routine* current_routine) {
116   assert(current_routine == Current_routine);  // argument passed in just to make caller readable above
117   return !Current_routine->completed();
118 }
119 
120 bool should_copy_ingredients() {
121   // End should_copy_ingredients Special-cases
122   return true;
123 }
124 
125 //: Some helpers.
126 //: Important that they return references into the current routine.
127 
128 //: hook replaced in a later layer
129 int& current_step_index() {
130   return Current_routine->running_step_index;
131 }
132 
133 //: hook replaced in a later layer
134 const string& current_recipe_name() {
135   return get(Recipe, Current_routine->running_recipe).name;
136 }
137 
138 //: hook replaced in a later layer
139 const recipe& current_recipe() {
140   return get(Recipe, Current_routine->running_recipe);
141 }
142 
143 //: hook replaced in a later layer
144 const instruction& current_instruction() {
145   return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index);
146 }
147 
148 //: hook replaced in a later layer
149 bool routine::completed() const {
150   return running_step_index >= SIZE(get(Recipe, running_recipe).steps);
151 }
152 
153 //: hook replaced in a later layer
154 const vector<instruction>& routine::steps() const {
155   return get(Recipe, running_recipe).steps;
156 }
157 
158 //:: Startup flow
159 
160 //: Step 1: load all .mu files with numeric prefixes (in order)
161 :(before "End Load Recipes")
162 // Load Mu Prelude
163 //? Save_trace = true;
164 //? START_TRACING_UNTIL_END_OF_SCOPE;
165 load_file_or_directory("core.mu");
166 //? DUMP("");
167 //? exit(0);
168 
169 //: Step 2: load any .mu files provided at the commandline
170 :(before "End Commandline Parsing")
171 // Check For .mu Files
172 //? START_TRACING_UNTIL_END_OF_SCOPE
173 //? Dump_trace = true;
174 if (argc > 1) {
175   // skip argv[0]
176   ++argv;
177   --argc;
178   while (argc > 0) {
179   ¦ // ignore argv past '--'; that's commandline args for 'main'
180   ¦ if (string(*argv) == "--") break;
181   ¦ if (starts_with(*argv, "--"))
182   ¦ ¦ cerr << "treating " << *argv << " as a file rather than an option\n";
183   ¦ load_file_or_directory(*argv);
184   ¦ --argc;
185   ¦ ++argv;
186   }
187   if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main"));
188 }
189 transform_all();
190 //? cerr << to_original_string(get(Recipe, get(Recipe_ordinal, "event-loop"))) << '\n';
191 //? DUMP("");
192 //? exit(0);
193 if (trace_contains_errors()) return 1;
194 save_snapshots();
195 
196 //: Step 3: if we aren't running tests, locate a recipe called 'main' and
197 //: start running it.
198 :(before "End Main")
199 if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) {
200   // Running Main
201   setup();
202   if (Start_tracing) {
203   ¦ Trace_stream = new trace_stream;
204   ¦ Save_trace = true;
205   }
206   trace(2, "run") << "=== Starting to run" << end();
207   assert(Num_calls_to_transform_all == 1);
208   run_main(argc, argv);
209   teardown();
210 }
211 :(code)
212 void run_main(int argc, char* argv[]) {
213   recipe_ordinal r = get(Recipe_ordinal, "main");
214   if (r) run(r);
215 }
216 
217 //: By default we don't maintain the trace while running main because its
218 //: overheads can grow rapidly. However, it's useful when debugging.
219 :(before "End Globals")
220 bool Start_tracing = false;
221 :(before "End Commandline Options(*arg)")
222 else if (is_equal(*arg, "--trace")) {
223   Start_tracing = true;
224 }
225 
226 :(code)
227 void dump_profile() {
228   for (map<string, int>::iterator p = Instructions_running.begin();  p != Instructions_running.end();  ++p) {
229   ¦ cerr << p->first << ": " << p->second << '\n';
230   }
231   cerr << "== locations read\n";
232   for (map<string, int>::iterator p = Locations_read.begin();  p != Locations_read.end();  ++p) {
233   ¦ cerr << p->first << ": " << p->second << '\n';
234   }
235   cerr << "== locations read by instruction\n";
236   for (map<string, int>::iterator p = Locations_read_by_instruction.begin();  p != Locations_read_by_instruction.end();  ++p) {
237   ¦ cerr << p->first << ": " << p->second << '\n';
238   }
239 }
240 :(before "End One-time Setup")
241 //? atexit(dump_profile);
242 
243 :(code)
244 void cleanup_main() {
245   if (Save_trace && Trace_stream) {
246   ¦ cerr << "writing trace to 'last_run'\n";
247   ¦ ofstream fout("last_run");
248   ¦ fout << Trace_stream->readable_contents("");
249   ¦ fout.close();
250   }
251   if (Trace_stream) delete Trace_stream, Trace_stream = NULL;
252 }
253 :(before "End One-time Setup")
254 atexit(cleanup_main);
255 
256 :(code)
257 void load_file_or_directory(string filename) {
258   if (is_directory(filename)) {
259   ¦ load_all(filename);
260   ¦ return;
261   }
262   ifstream fin(filename.c_str());
263   if (!fin) {
264   ¦ cerr << "no such file '" << filename << "'\n" << end();  // don't raise, just warn. just in case it's just a name for a scenario to run.
265   ¦ return;
266   }
267   trace(9990, "load") << "=== " << filename << end();
268   load(fin);
269   fin.close();
270 }
271 
272 bool is_directory(string path) {
273   struct stat info;
274   if (stat(path.c_str(), &info)) return false;  // error
275   return info.st_mode & S_IFDIR;
276 }
277 
278 void load_all(string dir) {
279   dirent** files;
280   int num_files = scandir(dir.c_str(), &files, NULL, alphasort);
281   for (int i = 0;  i < num_files;  ++i) {
282   ¦ string curr_file = files[i]->d_name;
283   ¦ if (isdigit(curr_file.at(0)))
284   ¦ ¦ load_file_or_directory(dir+'/'+curr_file);
285   ¦ free(files[i]);
286   ¦ files[i] = NULL;
287   }
288   free(files);
289 }
290 :(before "End Includes")
291 #include <dirent.h>
292 #include <sys/stat.h>
293 
294 //:: Reading from memory, writing to memory.
295 
296 :(code)
297 vector<double> read_memory(reagent/*copy*/ x) {
298   // Begin Preprocess read_memory(x)
299   vector<double> result;
300   if (is_literal(x)) {
301   ¦ result.push_back(x.value);
302   ¦ return result;
303   }
304   // End Preprocess read_memory(x)
305   int size = size_of(x);
306   for (int offset = 0;  offset < size;  ++offset) {
307   ¦ double val = get_or_insert(Memory, x.value+offset);
308   ¦ trace(9999, "mem") << "location " << x.value+offset << " is " << no_scientific(val) << end();
309   ¦ result.push_back(val);
310   }
311   return result;
312 }
313 
314 void write_memory(reagent/*copy*/ x, const vector<double>& data) {
315   assert(Current_routine);  // run-time only
316   // Begin Preprocess write_memory(x, data)
317   if (!x.type) {
318   ¦ raise << "can't write to '" << to_string(x) << "'; no type\n" << end();
319   ¦ return;
320   }
321   if (is_dummy(x)) return;
322   if (is_literal(x)) return;
323   // End Preprocess write_memory(x, data)
324   if (x.value == 0) {
325   ¦ raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
326   ¦ return;
327   }
328   if (size_mismatch(x, data)) {
329   ¦ raise << maybe(current_recipe_name()) << "size mismatch in storing to '" << x.original_string << "' (" << size_of(x) << " vs " << SIZE(data) << ") at '" << to_original_string(current_instruction()) << "'\n" << end();
330   ¦ return;
331   }
332   // End write_memory(x) Special-cases
333   for (int offset = 0;  offset < SIZE(data);  ++offset) {
334   ¦ assert(x.value+offset > 0);
335   ¦ trace(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << end();
336   ¦ put(Memory, x.value+offset, data.at(offset));
337   }
338 }
339 
340 :(code)
341 int size_of(const reagent& r) {
342   if (!r.type) return 0;
343   // End size_of(reagent r) Special-cases
344   return size_of(r.type);
345 }
346 int size_of(const type_tree* type) {
347   if (!type) return 0;
348   if (type->atom) {
349   ¦ if (type->value == -1) return 1;  // error value, but we'll raise it elsewhere
350   ¦ if (type->value == 0) return 1;
351   ¦ // End size_of(type) Atom Special-cases
352   }
353   else {
354   ¦ if (!type->left->atom) {
355   ¦ ¦ raise << "invalid type " << to_string(type) << '\n' << end();
356   ¦ ¦ return 0;
357   ¦ }
358   ¦ if (type->left->value == get(Type_ordinal, "address")) return 1;
359   ¦ // End size_of(type) Non-atom Special-cases
360   }
361   // End size_of(type) Special-cases
362   return 1;
363 }
364 
365 bool size_mismatch(const reagent& x, const vector<double>& data) {
366   if (!x.type) return true;
367   // End size_mismatch(x) Special-cases
368 //?   if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n';
369   return size_of(x) != SIZE(data);
370 }
371 
372 bool is_literal(const reagent& r) {
373   return is_literal(r.type);
374 }
375 bool is_literal(const type_tree* type) {
376   if (!type) return false;
377   if (!type->atom) return false;
378   return type->value == 0;
379 }
380 
381 bool scalar(const vector<int>& x) {
382   return SIZE(x) == 1;
383 }
384 bool scalar(const vector<double>& x) {
385   return SIZE(x) == 1;
386 }
387 
388 // helper for tests
389 void run(const string& form) {
390   vector<recipe_ordinal> tmp = load(form);
391   transform_all();
392   if (tmp.empty()) return;
393   if (trace_contains_errors()) return;
394   // if a test defines main, it probably wants to start there regardless of
395   // definition order
396   if (contains_key(Recipe, get(Recipe_ordinal, "main")))
397   ¦ run(get(Recipe_ordinal, "main"));
398   else
399   ¦ run(tmp.front());
400 }
401 
402 :(scenario run_label)
403 def main [
404   +foo
405   1:num <- copy 23
406   2:num <- copy 1:num
407 ]
408 +run: {1: "number"} <- copy {23: "literal"}
409 +run: {2: "number"} <- copy {1: "number"}
410 -run: +foo
411 
412 :(scenario run_dummy)
413 def main [
414   _ <- copy 0
415 ]
416 +run: _ <- copy {0: "literal"}
417 
418 :(scenario write_to_0_disallowed)
419 % Hide_errors = true;
420 def main [
421   0:num <- copy 34
422 ]
423 -mem: storing 34 in location 0
424 
425 //: Mu is robust to various combinations of commas and spaces. You just have
426 //: to put spaces around the '<-'.
427 
428 :(scenario comma_without_space)
429 def main [
430   1:num, 2:num <- copy 2,2
431 ]
432 +mem: storing 2 in location 1
433 
434 :(scenario space_without_comma)
435 def main [
436   1:num, 2:num <- copy 2 2
437 ]
438 +mem: storing 2 in location 1
439 
440 :(scenario comma_before_space)
441 def main [
442   1:num, 2:num <- copy 2, 2
443 ]
444 +mem: storing 2 in location 1
445 
446 :(scenario comma_after_space)
447 def main [
448   1:num, 2:num <- copy 2 ,2
449 ]
450 +mem: storing 2 in location 1