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 :(before "End Reset")
 52 Current_routine = NULL;
 53 
 54 :(code)
 55 void run(const recipe_ordinal r) {
 56   routine rr(r);
 57   Current_routine = &rr;
 58   run_current_routine();
 59   Current_routine = NULL;
 60 }
 61 
 62 void run_current_routine() {
 63   while (should_continue_running(Current_routine)) {  // beware: may modify Current_routine
 64     // Running One Instruction
 65     if (current_instruction().is_label) { ++current_step_index();  continue; }
 66     trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << to_string(current_instruction()) << end();
 67 //?     if (Foo) cerr << "run: " << to_string(current_instruction()) << '\n';
 68     if (get_or_insert(Memory, 0) != 0) {
 69       raise << "something wrote to location 0; this should never happen\n" << end();
 70       put(Memory, 0, 0);
 71     }
 72     // read all ingredients from memory, each potentially spanning multiple locations
 73     vector<vector<double> > ingredients;
 74     if (should_copy_ingredients()) {
 75       for (int i = 0;  i < SIZE(current_instruction().ingredients);  ++i)
 76         ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
 77     }
 78     // instructions below will write to 'products'
 79     vector<vector<double> > products;
 80     //: This will be a large switch that later layers will often insert cases
 81     //: into. Never call 'continue' within it. Instead, we'll explicitly
 82     //: control which of the following stages after the switch we run for each
 83     //: instruction.
 84     bool write_products = true;
 85     bool fall_through_to_next_instruction = true;
 86     switch (current_instruction().operation) {
 87       // Primitive Recipe Implementations
 88       case COPY: {
 89         copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
 90         break;
 91       }
 92       // End Primitive Recipe Implementations
 93       default: {
 94         raise << "not a primitive op: " << current_instruction().operation << '\n' << end();
 95       }
 96     }
 97     //: used by a later layer
 98     if (write_products) {
 99       if (SIZE(products) < SIZE(current_instruction().products)) {
100         raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products in '" << to_original_string(current_instruction()) << "'\n" << end();
101       }
102       else {
103         for (int i = 0;  i < SIZE(current_instruction().products);  ++i) {
104           // Writing Instruction Product(i)
105           write_memory(current_instruction().products.at(i), products.at(i));
106         }
107       }
108     }
109     // End Running One Instruction
110     if (fall_through_to_next_instruction)
111       ++current_step_index();
112   }
113   stop_running_current_routine:;
114 }
115 
116 :(code)
117 //: hook replaced in a later layer
118 bool should_continue_running(const routine* current_routine) {
119   assert(current_routine == Current_routine);  // argument passed in just to make caller readable above
120   return !Current_routine->completed();
121 }
122 
123 bool should_copy_ingredients() {
124   // End should_copy_ingredients Special-cases
125   return true;
126 }
127 
128 bool is_mu_scalar(reagent/*copy*/ r) {
129   return is_mu_scalar(r.type);
130 }
131 bool is_mu_scalar(const type_tree* type) {
132   if (!type) return false;
133   if (is_mu_address(type)) return false;
134   if (!type->atom) return false;
135   if (is_literal(type))
136     return type->name != "literal-string";
137   return size_of(type) == 1;
138 }
139 
140 bool is_mu_address(reagent/*copy*/ r) {
141   // End Preprocess is_mu_address(reagent r)
142   return is_mu_address(r.type);
143 }
144 bool is_mu_address(const type_tree* type) {
145   if (!type) return false;
146   if (is_literal(type)) return false;
147   if (type->atom) return false;
148   if (!type->left->atom) {
149     raise << "invalid type " << to_string(type) << '\n' << end();
150     return false;
151   }
152   return type->left->value == Address_type_ordinal;
153 }
154 
155 //: Some helpers.
156 //: Important that they return references into the current routine.
157 
158 //: hook replaced in a later layer
159 int& current_step_index() {
160   return Current_routine->running_step_index;
161 }
162 
163 //: hook replaced in a later layer
164 recipe_ordinal currently_running_recipe() {
165   return Current_routine->running_recipe;
166 }
167 
168 //: hook replaced in a later layer
169 const string& current_recipe_name() {
170   return get(Recipe, Current_routine->running_recipe).name;
171 }
172 
173 //: hook replaced in a later layer
174 const recipe& current_recipe() {
175   return get(Recipe, Current_routine->running_recipe);
176 }
177 
178 //: hook replaced in a later layer
179 const instruction& current_instruction() {
180   return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index);
181 }
182 
183 //: hook replaced in a later layer
184 bool routine::completed() const {
185   return running_step_index >= SIZE(get(Recipe, running_recipe).steps);
186 }
187 
188 //: hook replaced in a later layer
189 const vector<instruction>& routine::steps() const {
190   return get(Recipe, running_recipe).steps;
191 }
192 
193 //:: Startup flow
194 
195 :(before "End Mu Prelude")
196 load_file_or_directory("core.mu");
197 //? DUMP("");
198 //? exit(0);
199 
200 //: Step 2: load any .mu files provided at the commandline
201 :(before "End Commandline Parsing")
202 // Check For .mu Files
203 if (argc > 1) {
204   // skip argv[0]
205   ++argv;
206   --argc;
207   while (argc > 0) {
208     // ignore argv past '--'; that's commandline args for 'main'
209     if (string(*argv) == "--") break;
210     if (starts_with(*argv, "--"))
211       cerr << "treating " << *argv << " as a file rather than an option\n";
212     load_file_or_directory(*argv);
213     --argc;
214     ++argv;
215   }
216   if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main"));
217 }
218 transform_all();
219 //? cerr << to_original_string(get(Type_ordinal, "editor")) << '\n';
220 //? cerr << to_original_string(get(Recipe, get(Recipe_ordinal, "event-loop"))) << '\n';
221 //? DUMP("");
222 //? exit(0);
223 if (trace_contains_errors()) return 1;
224 if (Trace_stream && Run_tests) {
225   // We'll want a trace per test. Clear the trace.
226   delete Trace_stream;
227   Trace_stream = NULL;
228 }
229 save_snapshots();
230 
231 //: Step 3: if we aren't running tests, locate a recipe called 'main' and
232 //: start running it.
233 :(before "End Main")
234 if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) {
235   // Running Main
236   reset();
237   trace(2, "run") << "=== Starting to run" << end();
238   assert(Num_calls_to_transform_all == 1);
239   run_main(argc, argv);
240 }
241 :(code)
242 void run_main(int argc, char* argv[]) {
243   recipe_ordinal r = get(Recipe_ordinal, "main");
244   if (r) run(r);
245 }
246 
247 :(code)
248 void load_file_or_directory(string filename) {
249   if (is_directory(filename)) {
250     load_all(filename);
251     return;
252   }
253   ifstream fin(filename.c_str());
254   if (!fin) {
255     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.
256     return;
257   }
258   trace(9990, "load") << "=== " << filename << end();
259   load(fin);
260   fin.close();
261 }
262 
263 bool is_directory(string path) {
264   struct stat info;
265   if (stat(path.c_str(), &info)) return false;  // error
266   return info.st_mode & S_IFDIR;
267 }
268 
269 void load_all(string dir) {
270   dirent** files;
271   int num_files = scandir(dir.c_str(), &files, NULL, alphasort);
272   for (int i = 0;  i < num_files;  ++i) {
273     string curr_file = files[i]->d_name;
274     if (isdigit(curr_file.at(0)) && ends_with(curr_file, ".mu"))
275       load_file_or_directory(dir+'/'+curr_file);
276     free(files[i]);
277     files[i] = NULL;
278   }
279   free(files);
280 }
281 
282 bool ends_with(const string& s, const string& pat) {
283   for (string::const_reverse_iterator p = s.rbegin(), q = pat.rbegin();  q != pat.rend();  ++p, ++q) {
284     if (p == s.rend()) return false;  // pat too long
285     if (*p != *q) return false;
286   }
287   return true;
288 }
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 (x.name == "null") result.push_back(/*alloc id*/0);
301   if (is_literal(x)) {
302     result.push_back(x.value);
303     return result;
304   }
305   // End Preprocess read_memory(x)
306   int size = size_of(x);
307   for (int offset = 0;  offset < size;  ++offset) {
308     double val = get_or_insert(Memory, x.value+offset);
309     trace("mem") << "location " << x.value+offset << " is " << no_scientific(val) << end();
310     result.push_back(val);
311   }
312   return result;
313 }
314 
315 void write_memory(reagent/*copy*/ x, const vector<double>& data) {
316   assert(Current_routine);  // run-time only
317   // Begin Preprocess write_memory(x, data)
318   if (!x.type) {
319     raise << "can't write to '" << to_string(x) << "'; no type\n" << end();
320     return;
321   }
322   if (is_dummy(x)) return;
323   if (is_literal(x)) return;
324   // End Preprocess write_memory(x, data)
325   if (x.value == 0) {
326     raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
327     return;
328   }
329   if (size_mismatch(x, data)) {
330     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();
331     return;
332   }
333   // End write_memory(x) Special-cases
334   for (int offset = 0;  offset < SIZE(data);  ++offset) {
335     assert(x.value+offset > 0);
336     trace("mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << end();
337 //?     if (Foo) cerr << "mem: storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << '\n';
338     put(Memory, x.value+offset, data.at(offset));
339   }
340 }
341 
342 :(code)
343 int size_of(const reagent& r) {
344   if (!r.type) return 0;
345   // End size_of(reagent r) Special-cases
346   return size_of(r.type);
347 }
348 int size_of(const type_tree* type) {
349   if (!type) return 0;
350   if (type->atom) {
351     if (type->value == -1) return 1;  // error value, but we'll raise it elsewhere
352     if (type->value == 0) return 1;
353     // End size_of(type) Atom Special-cases
354   }
355   else {
356     if (!type->left->atom) {
357       raise << "invalid type " << to_string(type) << '\n' << end();
358       return 0;
359     }
360     if (type->left->value == Address_type_ordinal) return 2;  // address and alloc id
361     // End size_of(type) Non-atom Special-cases
362   }
363   // End size_of(type) Special-cases
364   return 1;
365 }
366 
367 bool size_mismatch(const reagent& x, const vector<double>& data) {
368   if (!x.type) return true;
369   // End size_mismatch(x) Special-cases
370 //?   if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n';
371   return size_of(x) != SIZE(data);
372 }
373 
374 bool is_literal(const reagent& r) {
375   return is_literal(r.type);
376 }
377 bool is_literal(const type_tree* type) {
378   if (!type) return false;
379   if (!type->atom) return false;
380   return type->value == 0;
381 }
382 
383 bool scalar(const vector<int>& x) {
384   return SIZE(x) == 1;
385 }
386 bool scalar(const vector<double>& x) {
387   return SIZE(x) == 1;
388 }
389 
390 // helper for tests
391 void run(const string& form) {
392   vector<recipe_ordinal> tmp = load(form);
393   transform_all();
394   if (tmp.empty()) return;
395   if (trace_contains_errors()) {
396     if (Save_trace && Trace_stream) Trace_stream->save();
397     return;
398   }
399   // if a test defines main, it probably wants to start there regardless of
400   // definition order
401   if (contains_key(Recipe, get(Recipe_ordinal, "main")))
402     run(get(Recipe_ordinal, "main"));
403   else
404     run(tmp.front());
405 }
406 
407 :(scenario run_label)
408 def main [
409   +foo
410   1:num <- copy 23
411   2:num <- copy 1:num
412 ]
413 +run: {1: "number"} <- copy {23: "literal"}
414 +run: {2: "number"} <- copy {1: "number"}
415 -run: +foo
416 
417 :(scenario run_dummy)
418 def main [
419   _ <- copy 0
420 ]
421 +run: _ <- copy {0: "literal"}
422 
423 :(scenario run_null)
424 def main [
425   1:&:num <- copy null
426 ]
427 
428 :(scenario write_to_0_disallowed)
429 % Hide_errors = true;
430 def main [
431   0:num <- copy 34
432 ]
433 -mem: storing 34 in location 0
434 
435 //: Mu is robust to various combinations of commas and spaces. You just have
436 //: to put spaces around the '<-'.
437 
438 :(scenario comma_without_space)
439 def main [
440   1:num, 2:num <- copy 2,2
441 ]
442 +mem: storing 2 in location 1
443 
444 :(scenario space_without_comma)
445 def main [
446   1:num, 2:num <- copy 2 2
447 ]
448 +mem: storing 2 in location 1
449 
450 :(scenario comma_before_space)
451 def main [
452   1:num, 2:num <- copy 2, 2
453 ]
454 +mem: storing 2 in location 1
455 
456 :(scenario comma_after_space)
457 def main [
458   1:num, 2:num <- copy 2 ,2
459 ]
460 +mem: storing 2 in location 1
461 
462 //:: Counters for trying to understand where Mu programs are spending their
463 //:: time.
464 
465 :(before "End Globals")
466 bool Run_profiler = false;
467 // We'll key profile information by recipe_ordinal rather than name because
468 // it's more efficient, and because later layers will show more than just the
469 // name of a recipe.
470 //
471 // One drawback: if you're clearing recipes your profile will be inaccurate.
472 // So far that happens in tests, and in 'run-sandboxed' in a later layer.
473 map<recipe_ordinal, int> Instructions_running;
474 :(before "End Commandline Options(*arg)")
475 else if (is_equal(*arg, "--profile")) {
476   Run_profiler = true;
477 }
478 :(after "Running One Instruction")
479 if (Run_profiler) Instructions_running[currently_running_recipe()]++;
480 :(before "End One-time Setup")
481 atexit(dump_profile);
482 :(code)
483 void dump_profile() {
484   if (!Run_profiler) return;
485   if (Run_tests) {
486     cerr << "It's not a good idea to profile a run with tests, since tests can create conflicting recipes and mislead you. To try it anyway, comment out this check in the code.\n";
487     return;
488   }
489   ofstream fout;
490   fout.open("profile.instructions");
491   if (fout) {
492     for (map<recipe_ordinal, int>::iterator p = Instructions_running.begin();  p != Instructions_running.end();  ++p) {
493       fout << std::setw(9) << p->second << ' ' << header_label(p->first) << '\n';
494     }
495   }
496   fout.close();
497   // End dump_profile
498 }
499 
500 // overridden in a later layer
501 string header_label(const recipe_ordinal r) {
502   return get(Recipe, r).name;
503 }