From 9542bb112419d575190a72baf7f964c3e32df223 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Sat, 25 Jul 2015 22:15:51 -0700 Subject: 1853 --- html/003trace.cc.html | 170 +++++++++++++++++++++++--------------------------- 1 file changed, 79 insertions(+), 91 deletions(-) (limited to 'html/003trace.cc.html') diff --git a/html/003trace.cc.html b/html/003trace.cc.html index 0143551b..2eabf9ff 100644 --- a/html/003trace.cc.html +++ b/html/003trace.cc.html @@ -16,6 +16,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .cSpecial { color: #008000; } .Constant { color: #00a0a0; } .PreProc { color: #c000c0; } +.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .CommentedCode { color: #6c6c6c; } @@ -114,56 +115,56 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } // End Tracing // hack to ensure most code in this layer comes before anything else :(before "End Tracing") -bool Hide_warnings = false; +bool Hide_warnings = false; :(before "End Setup") //? cerr << "AAA setup\n"; //? 2 Hide_warnings = false; :(before "End Types") -struct trace_line { - int depth; // optional field just to help browse traces later +struct trace_line { + int depth; // optional field just to help browse traces later string label; string contents; trace_line(string l, string c) :depth(0), label(l), contents(c) {} - trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {} + trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {} }; :(before "End Tracing") -struct trace_stream { +struct trace_stream { vector<trace_line> past_lines; // accumulator for current line ostringstream* curr_stream; string curr_layer; - int curr_depth; + int curr_depth; string dump_layer; string collect_layer; // if set, ignore all other layers ofstream null_stream; // never opens a file, so writes silently fail trace_stream() :curr_stream(NULL), curr_depth(0) {} - ~trace_stream() { if (curr_stream) delete curr_stream; } + ~trace_stream() { if (curr_stream) delete curr_stream; } ostream& stream(string layer) { return stream(0, layer); } - ostream& stream(int depth, string layer) { - if (!collect_layer.empty() && layer != collect_layer) return null_stream; - newline(); - curr_stream = new ostringstream; + ostream& stream(int depth, string layer) { + if (!collect_layer.empty() && layer != collect_layer) return null_stream; + curr_stream = new ostringstream; curr_layer = layer; curr_depth = depth; return *curr_stream; } // be sure to call this before messing with curr_stream or curr_layer - void newline() { - if (!curr_stream) return; + void newline() { + if (!curr_stream) return; string curr_contents = curr_stream->str(); + if (curr_contents.empty()) return; past_lines.push_back(trace_line(curr_depth, trim(curr_layer), curr_contents)); // preserve indent in contents - if (curr_layer == dump_layer || curr_layer == "dump" || dump_layer == "all" || + if (curr_layer == dump_layer || curr_layer == "dump" || dump_layer == "all" || (!Hide_warnings && curr_layer == "warn")) //? if (dump_layer == "all" && (Current_routine->id == 3 || curr_layer == "schedule")) //? 1 cerr << curr_layer << ": " << curr_contents << '\n'; - delete curr_stream; + delete curr_stream; curr_stream = NULL; curr_layer.clear(); curr_depth = 0; @@ -171,12 +172,11 @@ struct trace_stream { // Useful for debugging. string readable_contents(string layer) { // missing layer = everything - newline(); ostringstream output; layer = trim(layer); - for (vector<trace_line>::iterator p = past_lines.begin(); p != past_lines.end(); ++p) - if (layer.empty() || layer == p->label) { - if (p->depth) + for (vector<trace_line>::iterator p = past_lines.begin(); p != past_lines.end(); ++p) + if (layer.empty() || layer == p->label) { + if (p->depth) output << std::setw(4) << p->depth << ' '; output << p->label << ": " << p->contents << '\n'; } @@ -194,45 +194,35 @@ trace_stream* Trace_stream = NULL// some unfriendly constraints (they delay printing, they can't nest) #define raise ((!Trace_stream || !Hide_warnings) ? (tb_shutdown(),cerr) /*do print*/ : Trace_stream->stream("warn")) -// A separate helper for debugging. We should only trace domain-specific -// facts. For everything else use log. -#define xlog if (false) log -// To turn on logging replace 'xlog' with 'log'. -#define log cerr - :(before "End Types") -// raise << die exits after printing -- unless Hide_warnings is set. -struct die {}; +struct end {}; :(before "End Tracing") -ostream& operator<<(ostream& os, unused die) { - if (Hide_warnings) return os; - tb_shutdown(); - os << "dying"; - if (Trace_stream) Trace_stream->newline(); - exit(1); +ostream& operator<<(ostream& os, unused end) { + if (Trace_stream) Trace_stream->newline(); + return os; } -#define CLEAR_TRACE delete Trace_stream, Trace_stream = new trace_stream; +#define CLEAR_TRACE delete Trace_stream, Trace_stream = new trace_stream; -#define DUMP(layer) if (Trace_stream) cerr << Trace_stream->readable_contents(layer); +#define DUMP(layer) if (Trace_stream) cerr << Trace_stream->readable_contents(layer); // All scenarios save their traces in the repo, just like code. This gives // future readers more meat when they try to make sense of a new project. -static string Trace_dir = ".traces/"; +static string Trace_dir = ".traces/"; string Trace_file; // Trace_stream is a resource, lease_tracer uses RAII to manage it. -struct lease_tracer { - lease_tracer() { Trace_stream = new trace_stream; } +struct lease_tracer { + lease_tracer() { Trace_stream = new trace_stream; } ~lease_tracer() { //? cerr << "write to file? " << Trace_file << "$\n"; //? 2 - if (!Trace_file.empty()) { + if (!Trace_file.empty()) { //? cerr << "writing\n"; //? 2 ofstream fout((Trace_dir+Trace_file).c_str()); fout << Trace_stream->readable_contents(""); fout.close(); } - delete Trace_stream, Trace_stream = NULL, Trace_file = ""; + delete Trace_stream, Trace_stream = NULL, Trace_file = ""; } }; @@ -244,48 +234,47 @@ START_TRACING_UNTIL_END_OF_SCOPE #define CHECK_TRACE_CONTENTS(...) check_trace_contents(__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__) :(before "End Tracing") -bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) { // missing layer == anywhere +bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) { // missing layer == anywhere vector<string> expected_lines = split(expected, "^D"); - long long int curr_expected_line = 0; - while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) + long long int curr_expected_line = 0; + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == SIZE(expected_lines)) return true; - Trace_stream->newline(); + if (curr_expected_line == SIZE(expected_lines)) return true; string layer, contents; split_layer_contents(expected_lines.at(curr_expected_line), &layer, &contents); - for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { + for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { //? cerr << "AAA " << layer << ' ' << p->label << '\n'; //? 1 - if (layer != p->label) + if (layer != p->label) continue; //? cerr << "BBB ^" << contents << "$ ^" << p->contents << "$\n"; //? 1 - if (contents != trim(p->contents)) + if (contents != trim(p->contents)) continue; //? cerr << "CCC\n"; //? 1 ++curr_expected_line; - while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) + while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty()) ++curr_expected_line; - if (curr_expected_line == SIZE(expected_lines)) return true; + if (curr_expected_line == SIZE(expected_lines)) return true; split_layer_contents(expected_lines.at(curr_expected_line), &layer, &contents); } ++Num_failures; - cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n"; + cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n"; DUMP(layer); //? exit(0); //? 1 Passed = false; return false; } -void split_layer_contents(const string& s, string* layer, string* contents) { - static const string delim(": "); - size_t pos = s.find(delim); - if (pos == string::npos) { +void split_layer_contents(const string& s, string* layer, string* contents) { + static const string delim(": "); + size_t pos = s.find(delim); + if (pos == string::npos) { *layer = ""; *contents = trim(s); } - else { + else { *layer = trim(s.substr(0, pos)); *contents = trim(s.substr(pos+SIZE(delim))); } @@ -293,18 +282,17 @@ void split_layer_contents(const string& s(string layer) { +int trace_count(string layer) { return trace_count(layer, ""); } -int trace_count(string layer, string line) { - Trace_stream->newline(); - long result = 0; - for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { - if (layer == p->label) { +int trace_count(string layer, string line) { + long result = 0; + for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { + if (layer == p->label) { //? cerr << "a: " << line << "$\n"; //? 1 //? cerr << "b: " << trim(p->contents) << "$\n"; //? 1 - if (line == "" || line == trim(p->contents)) + if (line == "" || line == trim(p->contents)) ++result; } } @@ -313,7 +301,7 @@ int trace_count(string layer#define CHECK_TRACE_WARNS() CHECK(trace_count("warn") > 0) #define CHECK_TRACE_DOESNT_WARN() \ - if (trace_count("warn") > 0) { \ + if (trace_count("warn") > 0) { \ ++Num_failures; \ cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): unexpected warnings\n"; \ DUMP("warn"); \ @@ -321,11 +309,11 @@ int trace_count(string layer return; \ } -bool trace_doesnt_contain(string layer, string line) { +bool trace_doesnt_contain(string layer, string line) { return trace_count(layer, line) == 0; } -bool trace_doesnt_contain(string expected) { +bool trace_doesnt_contain(string expected) { vector<string> tmp = split(expected, ": "); return trace_doesnt_contain(tmp.at(0), tmp.at(1)); } @@ -336,9 +324,9 @@ bool trace_doesnt_contain(string expected(string s, string delim) { vector<string> result; - size_t begin=0, end=s.find(delim); - while (true) { - if (end == string::npos) { + size_t begin=0, end=s.find(delim); + while (true) { + if (end == string::npos) { result.push_back(string(s, begin, string::npos)); break; } @@ -349,14 +337,14 @@ vector<string> split(string sreturn result; } -string trim(const string& s) { +string trim(const string& s) { string::const_iterator first = s.begin(); - while (first != s.end() && isspace(*first)) + while (first != s.end() && isspace(*first)) ++first; - if (first == s.end()) return ""; + if (first == s.end()) return ""; string::const_iterator last = --s.end(); - while (last != s.begin() && isspace(*last)) + while (last != s.begin() && isspace(*last)) --last; ++last; return string(first, last); @@ -364,30 +352,30 @@ string trim(const string& s:(before "End Includes") #include<vector> -using std::vector; +using std::vector; #include<list> -using std::list; +using std::list; #include<map> -using std::map; +using std::map; #include<set> -using std::set; +using std::set; #include<algorithm> #include<iostream> -using std::istream; -using std::ostream; -using std::cin; -using std::cout; -using std::cerr; +using std::istream; +using std::ostream; +using std::cin; +using std::cout; +using std::cerr; #include<iomanip> #include<sstream> -using std::istringstream; -using std::ostringstream; +using std::istringstream; +using std::ostringstream; #include<fstream> -using std::ifstream; -using std::ofstream; +using std::ifstream; +using std::ofstream; #include"termbox/termbox.h" @@ -398,18 +386,18 @@ using std::ofstream; //: //: Mu 'applications' will be able to use depths 1-99 as they like. //: Depth 100 will be for scheduling (more on that later). -const int Scheduling_depth = 100; +const int Scheduling_depth = 100; //: Primitive statements will occupy 101-9998 -const int Initial_callstack_depth = 101; -const int Max_callstack_depth = 9998; +const int Initial_callstack_depth = 101; +const int Max_callstack_depth = 9998; //: (ignore this until the call layer) :(before "End Globals") -int Callstack_depth = 0; +int Callstack_depth = 0; :(before "End Setup") Callstack_depth = 0; //: Finally, details of primitive mu statements will occupy depth 9999 (more on that later as well) :(before "End Globals") -const int Primitive_recipe_depth = 9999; +const int Primitive_recipe_depth = 9999; //: //: This framework should help us hide some details at each level, mixing //: static ideas like layers with the dynamic notion of call-stack depth. -- cgit 1.4.1-2-gfad0