mu - Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society.

	Commit message (Expand)	Author	Age	Files	Lines
*	5001 - drop the :(scenario) DSL	Kartik Agaram	2019-03-12	4	-583/+107
*	4980	Kartik Agaram	2019-02-18	1	-8/+8
*	4979	Kartik Agaram	2019-02-18	2	-1/+112
*	4406	Kartik Agaram	2018-07-25	2	-2/+29
*	4405	Kartik Agaram	2018-07-25	2	-25/+69
*	4404 - clean up generated code for scenarios	Kartik Agaram	2018-07-25	2	-23/+65
*	4403	Kartik Agaram	2018-07-25	2	-1/+7
*	4402	Kartik Agaram	2018-07-25	1	-19/+99
*	4401 - make unit tests for tangle a little more readable	Kartik Agaram	2018-07-25	1	-41/+200
*	4000	Kartik K. Agaram	2017-09-15	1	-0/+1
*	3839	Kartik K. Agaram	2017-04-20	2	-3/+20
*	3726	Kartik K. Agaram	2016-12-30	1	-0/+1
*	3711	Kartik K. Agaram	2016-12-26	5	-13/+3
*	3550	Kartik K. Agaram	2016-10-22	2	-2/+2
*	3450	Kartik K. Agaram	2016-10-06	1	-25/+0
*	3448	Kartik K. Agaram	2016-10-06	1	-5/+5
*	3363 - bugfix in tangle	Kartik K. Agaram	2016-09-15	2	-1/+12
*	3361	Kartik K. Agaram	2016-09-15	1	-7/+7
*	3278	Kartik K. Agaram	2016-08-29	1	-5/+2
*	3218	Kartik K. Agaram	2016-08-17	2	-0/+14
*	3217	Kartik K. Agaram	2016-08-17	1	-2/+2
*	3101 - purge .traces/ dir from repo history	Kartik K. Agaram	2016-07-05	2	-13/+0
*	3063	Kartik K. Agaram	2016-06-19	3	-6/+5
*	2768 - get working in Linux again	Kartik K. Agaram	2016-03-13	1	-0/+2
*	2760	Kartik K. Agaram	2016-03-11	2	-0/+0
*	2759	Kartik K. Agaram	2016-03-10	5	-316/+19
*	2575 - better messages on trace count failures	Kartik K. Agaram	2016-01-19	2	-3/+3
*	1746 - load file and run a single test	Kartik K. Agaram	2015-07-10	1	-1/+1
*	1676	Kartik K. Agaram	2015-06-28	1	-1/+1
*	1501	Kartik K. Agaram	2015-05-28	2	-14/+28
*	1500	Kartik K. Agaram	2015-05-28	1	-0/+5
*	1483 - really check color screens in scenarios	Kartik K. Agaram	2015-05-27	2	-17/+12
*	1439 - support clang in addition to gcc	Kartik K. Agaram	2015-05-23	1	-1/+1
*	1276 - make C++ version the default	Kartik K. Agaram	2015-05-05	8	-0/+1488

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <title>Mu - 020run.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v2"> <meta name="syntax" content="cpp"> <meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy="> <meta name="colorscheme" content="minimal"> <style type="text/css">  </style> <script type='text/javascript'>  </script> </head> <body onload='JumpToLine();'> <pre id='vimCodeElement'> 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 <a href='000organization.cc.html#L113'>main</a> [ 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 <a href='000organization.cc.html#L113'>main</a> [ 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 <a href='000organization.cc.html#L113'>main</a> [ 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 <a href='010vm.cc.html#L14'>recipe_ordinal</a> running_recipe; 43 int running_step_index; 44 routine(<a href='010vm.cc.html#L14'>recipe_ordinal</a> 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 <a href='010vm.cc.html#L14'>recipe_ordinal</a> 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 (<a href='073scheduler.cc.html#L28'>should_continue_running</a>(Current_routine)) { // beware: may modify Current_routine 64 ¦ // Running One Instruction 65 ¦ if (<a href='026call.cc.html#L85'>current_instruction</a>().is_label) { ++current_step_index(); continue; } 66 ¦ <a href='003trace.cc.html#L161'>trace</a>(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << <a href='028call_return.cc.html#L158'>to_string</a>(<a href='026call.cc.html#L85'>current_instruction</a>()) << <a href='003trace.cc.html#L197'>end</a>(); 67 ¦ if (<a href='001help.cc.html#L228'>get_or_insert</a>(Memory, 0) != 0) { 68 ¦ ¦ <a href='003trace.cc.html#L168'>raise</a> << "something wrote to location 0; this should never happen\n" << <a href='003trace.cc.html#L197'>end</a>(); 69 ¦ ¦ <a href='001help.cc.html#L221'>put</a>(Memory, 0, 0); 70 ¦ } 71 ¦ // read all ingredients from memory, each potentially spanning multiple locations 72 ¦ vector<vector<double> > ingredients; 73 ¦ if (should_copy_ingredients()) { 74 ¦ ¦ for (int i = 0; i < <a href='001help.cc.html#L141'>SIZE</a>(<a href='026call.cc.html#L85'>current_instruction</a>().ingredients); ++i) 75 ¦ ¦ ¦ ingredients.push_back(read_memory(<a href='026call.cc.html#L85'>current_instruction</a>().ingredients.at(i))); 76 ¦ } 77 ¦ // instructions below will write to 'products' 78 ¦ vector<vector<double> > products; 79 ¦ //: This will be a large switch that later layers will often insert cases 80 ¦ //: into. Never call 'continue' within it. Instead, we'll explicitly 81 ¦ //: control which of the following stages after the switch we run for each 82 ¦ //: instruction. 83 ¦ bool write_products = true; 84 ¦ bool fall_through_to_next_instruction = true; 85 ¦ switch (<a href='026call.cc.html#L85'>current_instruction</a>().operation) { 86 ¦ ¦ // Primitive Recipe Implementations 87 ¦ ¦ case <a href='010vm.cc.html#L189'>COPY</a>: { 88 ¦ ¦ ¦ copy(ingredients.begin(), ingredients.<a href='003trace.cc.html#L197'>end</a>(), inserter(products, products.begin())); 89 ¦ ¦ ¦ break; 90 ¦ ¦ } 91 ¦ ¦ // End Primitive Recipe Implementations 92 ¦ ¦ default: { 93 ¦ ¦ ¦ cout << "not a primitive op: " << <a href='026call.cc.html#L85'>current_instruction</a>().operation << '\n'; 94 ¦ ¦ } 95 ¦ } 96 ¦ //: used by a later layer 97 ¦ if (write_products) { 98 ¦ ¦ Writing_products_of_instruction = true; 99 ¦ ¦ if (<a href='001help.cc.html#L141'>SIZE</a>(products) < <a href='001help.cc.html#L141'>SIZE</a>(<a href='026call.cc.html#L85'>current_instruction</a>().products)) { 100 ¦ ¦ ¦ <a href='003trace.cc.html#L168'>raise</a> << <a href='001help.cc.html#L141'>SIZE</a>(products) << " vs " << <a href='001help.cc.html#L141'>SIZE</a>(<a href='026call.cc.html#L85'>current_instruction</a>().products) << ": failed to write to all products in '" << to_original_string(current_instruction()) << "'\n" << <a href='003trace.cc.html#L197'>end</a>(); 101 ¦ ¦ } 102 ¦ ¦ else { 103 ¦ ¦ ¦ for (int i = 0; i < <a href='001help.cc.html#L141'>SIZE</a>(<a href='026call.cc.html#L85'>current_instruction</a>().products); ++i) 104 ¦ ¦ ¦ ¦ write_memory(<a href='026call.cc.html#L85'>current_instruction</a>().products.at(i), products.at(i)); 105 ¦ ¦ } 106 ¦ ¦ Writing_products_of_instruction = false; 107 ¦ } 108 ¦ // End Running One Instruction 109 ¦ if (fall_through_to_next_instruction) 110 ¦ ¦ ++current_step_index(); 111 } 112 stop_running_current_routine:; 113 } 114 :(before "End Globals") 115 bool Writing_products_of_instruction = false; 116 117 :(code) 118 //: hook replaced in a later layer 119 bool <a href='073scheduler.cc.html#L28'>should_continue_running</a>(const routine* current_routine) { 120 assert(current_routine == Current_routine); // argument passed in just to make caller readable above 121 return !Current_routine->completed(); 122 } 123 124 bool should_copy_ingredients() { 125 // End should_copy_ingredients Special-cases 126 return true; 127 } 128 129 //: Some helpers. 130 //: Important that they return references into the current routine. 131 132 //: hook replaced in a later layer 133 int& <a href='026call.cc.html#L80'>current_step_index</a>() { 134 return Current_routine->running_step_index; 135 } 136 137 //: hook replaced in a later layer 138 <a href='010vm.cc.html#L14'>recipe_ordinal</a> <a href='026call.cc.html#L81'>currently_running_recipe</a>() { 139 return Current_routine->running_recipe; 140 } 141 142 //: hook replaced in a later layer 143 const string& <a href='026call.cc.html#L83'>current_recipe_name</a>() { 144 return get(Recipe, Current_routine->running_recipe).name; 145 } 146 147 //: hook replaced in a later layer 148 const recipe& <a href='026call.cc.html#L82'>current_recipe</a>() { 149 return get(Recipe, Current_routine->running_recipe); 150 } 151 152 //: hook replaced in a later layer 153 const instruction& <a href='026call.cc.html#L85'>current_instruction</a>() { 154 return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index); 155 } 156 157 //: hook replaced in a later layer 158 bool routine::completed() const { 159 return running_step_index >= <a href='001help.cc.html#L141'>SIZE</a>(get(Recipe, running_recipe).steps); 160 } 161 162 //: hook replaced in a later layer 163 const vector<instruction>& routine::steps() const { 164 return get(Recipe, running_recipe).steps; 165 } 166 167 //:: Startup flow 168 169 //: Step 1: load all .mu files with numeric prefixes (in order) 170 :(before "End Load Recipes") 171 // Load Mu Prelude 172 //? Save_trace = true; 173 //? START_TRACING_UNTIL_END_OF_SCOPE; 174 load_file_or_directory("core.mu"); 175 //? DUMP(""); 176 //? exit(0); 177 178 //: Step 2: load any .mu files provided at the commandline 179 :(before "End Commandline Parsing") 180 // Check For .mu Files 181 //? START_TRACING_UNTIL_END_OF_SCOPE 182 //? Dump_trace = true; 183 if (argc > 1) { 184 // skip argv[0] 185 ++argv; 186 --argc; 187 while (argc > 0) { 188 ¦ // ignore argv past '--'; that's commandline args for 'main' 189 ¦ if (string(*argv) == "--") break; 190 ¦ if (<a href='001help.cc.html#L77'>starts_with</a>(*argv, "--")) 191 ¦ ¦ cerr << "treating " << *argv << " as a file rather than an option\n"; 192 ¦ load_file_or_directory(*argv); 193 ¦ --argc; 194 ¦ ++argv; 195 } 196 if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main")); 197 } 198 <a href='012transform.cc.html#L46'>transform_all</a>(); 199 //? cerr << to_original_string(get(Type_ordinal, "editor")) << '\n'; 200 //? cerr << to_original_string(get(Recipe, get(Recipe_ordinal, "event-loop"))) << '\n'; 201 //? DUMP(""); 202 //? exit(0); 203 if (<a href='003trace.cc.html#L192'>trace_contains_errors</a>()) return 1; 204 save_snapshots(); 205 206 //: Step 3: if we aren't running tests, locate a recipe called 'main' and 207 //: start running it. 208 :(before "End Main") 209 if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) { 210 // Running Main 211 <a href='000organization.cc.html#L134'>reset</a>(); 212 if (Start_tracing) { 213 ¦ Trace_stream = new trace_stream; 214 ¦ Save_trace = true; 215 } 216 <a href='003trace.cc.html#L161'>trace</a>(2, "run") << "=== Starting to run" << <a href='003trace.cc.html#L197'>end</a>(); 217 assert(Num_calls_to_transform_all == 1); 218 <a href='073scheduler.cc.html#L122'>run_main</a>(argc, argv); 219 } 220 :(code) 221 void <a href='073scheduler.cc.html#L122'>run_main</a>(int argc, char* argv[]) { 222 <a href='010vm.cc.html#L14'>recipe_ordinal</a> r = get(Recipe_ordinal, "main"); 223 if (r) run(r); 224 } 225 226 //: By default we don't maintain the trace while running main because its 227 //: overheads can grow rapidly. However, it's useful when debugging. 228 :(before "End Globals") 229 bool Start_tracing = false; 230 :(before "End Commandline Options(*arg)") 231 else if (<a href='001help.cc.html#L73'>is_equal</a>(*arg, "--trace")) { 232 Start_tracing = true; 233 } 234 235 :(code) 236 void cleanup_main() { 237 if (Save_trace && Trace_stream) { 238 ¦ cerr << "writing <a href='003trace.cc.html#L161'>trace</a> to 'last_run'\n"; 239 ¦ ofstream fout("last_run"); 240 ¦ fout << Trace_stream-><a href='003trace.cc.html#L143'>readable_contents</a>(""); 241 ¦ fout.close(); 242 } 243 if (Trace_stream) delete Trace_stream, Trace_stream = NULL; 244 } 245 :(before "End One-time Setup") 246 atexit(cleanup_main); 247 248 :(code) 249 void load_file_or_directory(string filename) { 250 if (is_directory(filename)) { 251 ¦ load_all(filename); 252 ¦ return; 253 } 254 ifstream fin(filename.c_str()); 255 if (!fin) { 256 ¦ cerr << "no such file '" << filename << "'\n" << <a href='003trace.cc.html#L197'>end</a>(); // don't raise, just warn. just in case it's just a name for a scenario to run. 257 ¦ return; 258 } 259 <a href='003trace.cc.html#L161'>trace</a>(9990, "load") << "=== " << filename << <a href='003trace.cc.html#L197'>end</a>(); 260 load(fin); 261 fin.close(); 262 } 263 264 bool is_directory(string path) { 265 struct stat info; 266 if (stat(path.c_str(), &info)) return false; // error 267 return info.st_mode & S_IFDIR; 268 } 269 270 void load_all(string dir) { 271 dirent** files; 272 int num_files = scandir(dir.c_str(), &files, NULL, alphasort); 273 for (int i = 0; i < num_files; ++i) { 274 ¦ string curr_file = files[i]->d_name; 275 ¦ if (isdigit(curr_file.at(0))) 276 ¦ ¦ load_file_or_directory(dir+'/'+curr_file); 277 ¦ free(files[i]); 278 ¦ files[i] = NULL; 279 } 280 free(files); 281 } 282 :(before "End Includes") 283 #include <dirent.h> 284 #include <sys/stat.h> 285 286 //:: Reading from memory, writing to memory. 287 288 :(code) 289 vector<double> read_memory(reagent/*copy*/ x) { 290 // Begin Preprocess read_memory(x) 291 vector<double> result; 292 if (is_literal(x)) { 293 ¦ result.push_back(x.value); 294 ¦ return result; 295 } 296 // End Preprocess read_memory(x) 297 int size = size_of(x); 298 for (int offset = 0; offset < size; ++offset) { 299 ¦ double val = <a href='001help.cc.html#L228'>get_or_insert</a>(Memory, x.value+offset); 300 ¦ <a href='003trace.cc.html#L161'>trace</a>(9999, "mem") << "location " << x.value+offset << " is " << no_scientific(val) << <a href='003trace.cc.html#L197'>end</a>(); 301 ¦ result.push_back(val); 302 } 303 return result; 304 } 305 306 void write_memory(reagent/*copy*/ x, const vector<double>& data) { 307 assert(Current_routine); // run-time only 308 // Begin Preprocess write_memory(x, data) 309 if (!x.type) { 310 ¦ <a href='003trace.cc.html#L168'>raise</a> << "can't write to '" << <a href='028call_return.cc.html#L158'>to_string</a>(x) << "'; no type\n" << end(); 311 ¦ return; 312 } 313 if (is_dummy(x)) return; 314 if (is_literal(x)) return; 315 // End Preprocess write_memory(x, data) 316 if (x.value == 0) { 317 ¦ <a href='003trace.cc.html#L168'>raise</a> << "can't write to location 0 in '" << to_original_string(<a href='026call.cc.html#L85'>current_instruction</a>()) << "'\n" << end(); 318 ¦ return; 319 } 320 if (size_mismatch(x, data)) { 321 ¦ <a href='003trace.cc.html#L168'>raise</a> << <a href='013update_operation.cc.html#L25'>maybe</a>(<a href='026call.cc.html#L83'>current_recipe_name</a>()) << "size mismatch in storing to '" << x.original_string << "' (" << size_of(x) << " vs " << <a href='001help.cc.html#L141'>SIZE</a>(data) << ") at '" << to_original_string(current_instruction()) << "'\n" << <a href='003trace.cc.html#L197'>end</a>(); 322 ¦ return; 323 } 324 // End write_memory(x) Special-cases 325 for (int offset = 0; offset < <a href='001help.cc.html#L141'>SIZE</a>(data); ++offset) { 326 ¦ assert(x.value+offset > 0); 327 ¦ <a href='003trace.cc.html#L161'>trace</a>(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << <a href='003trace.cc.html#L197'>end</a>(); 328 ¦ <a href='001help.cc.html#L221'>put</a>(Memory, x.value+offset, data.at(offset)); 329 } 330 } 331 332 :(code) 333 int size_of(const reagent& r) { 334 if (!r.type) return 0; 335 // End size_of(reagent r) Special-cases 336 return size_of(r.type); 337 } 338 int size_of(const type_tree* type) { 339 if (!type) return 0; 340 if (type->atom) { 341 ¦ if (type->value == -1) return 1; // error value, but we'll raise it elsewhere 342 ¦ if (type->value == 0) return 1; 343 ¦ // End size_of(type) Atom Special-cases 344 } 345 else { 346 ¦ if (!type->left->atom) { 347 ¦ ¦ <a href='003trace.cc.html#L168'>raise</a> << "invalid type " << <a href='028call_return.cc.html#L158'>to_string</a>(type) << '\n' << <a href='003trace.cc.html#L197'>end</a>(); 348 ¦ ¦ return 0; 349 ¦ } 350 ¦ if (type->left->value == get(Type_ordinal, "address")) return 1; 351 ¦ // End size_of(type) Non-atom Special-cases 352 } 353 // End size_of(type) Special-cases 354 return 1; 355 } 356 357 bool size_mismatch(const reagent& x, const vector<double>& data) { 358 if (!x.type) return true; 359 // End size_mismatch(x) Special-cases 360 //? if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n'; 361 return size_of(x) != <a href='001help.cc.html#L141'>SIZE</a>(data); 362 } 363 364 bool is_literal(const reagent& r) { 365 return is_literal(r.type); 366 } 367 bool is_literal(const type_tree* type) { 368 if (!type) return false; 369 if (!type->atom) return false; 370 return type->value == 0; 371 } 372 373 bool scalar(const vector<int>& x) { 374 return <a href='001help.cc.html#L141'>SIZE</a>(x) == 1; 375 } 376 bool scalar(const vector<double>& x) { 377 return <a href='001help.cc.html#L141'>SIZE</a>(x) == 1; 378 } 379 380 // helper for tests 381 void run(const string& form) { 382 vector<recipe_ordinal> tmp = load(form); 383 <a href='012transform.cc.html#L46'>transform_all</a>(); 384 if (tmp.empty()) return; 385 if (<a href='003trace.cc.html#L192'>trace_contains_errors</a>()) return; 386 // if a test defines main, it probably wants to start there regardless of 387 // definition order 388 if (contains_key(Recipe, get(Recipe_ordinal, "main"))) 389 ¦ run(get(Recipe_ordinal, "main")); 390 else 391 ¦ run(tmp.front()); 392 } 393 394 :(scenario run_label) 395 def <a href='000organization.cc.html#L113'>main</a> [ 396 +foo 397 1:num <- copy 23 398 2:num <- copy 1:num 399 ] 400 +run: {1: "number"} <- copy {23: "literal"} 401 +run: {2: "number"} <- copy {1: "number"} 402 -run: +foo 403 404 :(scenario run_dummy) 405 def <a href='000organization.cc.html#L113'>main</a> [ 406 _ <- copy 0 407 ] 408 +run: _ <- copy {0: "literal"} 409 410 :(scenario write_to_0_disallowed) 411 % Hide_errors = true; 412 def <a href='000organization.cc.html#L113'>main</a> [ 413 0:num <- copy 34 414 ] 415 -mem: storing 34 in location 0 416 417 //: Mu is robust to various combinations of commas and spaces. You just have 418 //: to put spaces around the '<-'. 419 420 :(scenario comma_without_space) 421 def <a href='000organization.cc.html#L113'>main</a> [ 422 1:num, 2:num <- copy 2,2 423 ] 424 +mem: storing 2 in location 1 425 426 :(scenario space_without_comma) 427 def <a href='000organization.cc.html#L113'>main</a> [ 428 1:num, 2:num <- copy 2 2 429 ] 430 +mem: storing 2 in location 1 431 432 :(scenario comma_before_space) 433 def <a href='000organization.cc.html#L113'>main</a> [ 434 1:num, 2:num <- copy 2, 2 435 ] 436 +mem: storing 2 in location 1 437 438 :(scenario comma_after_space) 439 def <a href='000organization.cc.html#L113'>main</a> [ 440 1:num, 2:num <- copy 2 ,2 441 ] 442 +mem: storing 2 in location 1 443 444 //:: Counters for trying to understand where Mu programs are spending their 445 //:: time. 446 447 :(before "End Globals") 448 bool Run_profiler = false; 449 // We'll key profile information by recipe_ordinal rather than name because 450 // it's more efficient, and because later layers will show more than just the 451 // name of a recipe. 452 // 453 // One drawback: if you're clearing recipes your profile will be inaccurate. 454 // So far that happens in tests, and in 'run-sandboxed' in a later layer. 455 map<recipe_ordinal, int> Instructions_running; 456 :(before "End Commandline Options(*arg)") 457 else if (<a href='001help.cc.html#L73'>is_equal</a>(*arg, "--profile")) { 458 Run_profiler = true; 459 } 460 :(after "Running One Instruction") 461 if (Run_profiler) Instructions_running[currently_running_recipe()]++; 462 :(before "End One-time Setup") 463 atexit(dump_profile); 464 :(code) 465 void dump_profile() { 466 if (!Run_profiler) return; 467 if (Run_tests) { 468 ¦ 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"; 469 ¦ return; 470 } 471 ofstream fout; 472 fout.open("profile.instructions"); 473 if (fout) { 474 ¦ for (map<recipe_ordinal, int>::iterator p = Instructions_running.begin(); p != Instructions_running.<a href='003trace.cc.html#L197'>end</a>(); ++p) { 475 ¦ ¦ fout << std::setw(9) << p->second << ' ' << header_label(p->first) << '\n'; 476 ¦ } 477 } 478 fout.close(); 479 // End dump_profile 480 } 481 482 // overridden in a later layer 483 string header_label(const <a href='010vm.cc.html#L14'>recipe_ordinal</a> r) { 484 return get(Recipe, r).name; 485 } </pre> </body> </html>