Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/target-cpu/fragments/seq-main.in
ViewVC logotype

Annotation of /branches/vis15/src/compiler/target-cpu/fragments/seq-main.in

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5142 - (view) (download)

1 : jhr 3924 using namespace @PREFIX@;
2 :    
3 : jhr 3912 //! Main function for standalone sequential C target
4 :     //
5 :     int main (int argc, const char **argv)
6 :     {
7 :     bool timingFlg = false; //! true if timing computation
8 :     uint32_t stepLimit = 0; //! limit on number of execution steps (0 means unlimited)
9 : jhr 4664 std::string printFile = "-"; //! file to direct printed output into
10 : jhr 4661 #ifdef DIDEROT_EXEC_SNAPSHOT
11 : jhr 4668 uint32_t snapshotPeriod = 0; //! supersteps per snapshot; 0 means no snapshots
12 : jhr 4661 #endif
13 : jhr 4664 uint32_t nSteps = 0; //! number of supersteps taken
14 : jhr 3912
15 :     // create the world
16 : jhr 3916 world *wrld = new (std::nothrow) world();
17 : jhr 3912 if (wrld == nullptr) {
18 : jhr 3916 std::cerr << "unable to create world" << std::endl;
19 : jhr 4855 exit(1);
20 : jhr 3912 }
21 :    
22 :     #ifndef DIDEROT_NO_INPUTS
23 :     // initialize the default values for the inputs
24 : jhr 3931 cmd_line_inputs inputs;
25 : jhr 3912 init_defaults (&inputs);
26 :     #endif
27 :    
28 :     // handle command-line options
29 :     {
30 : jhr 4833 diderot::options *opts = new diderot::options ();
31 : jhr 4317 opts->add ("l,limit", "specify limit on number of super-steps (0 means unlimited)",
32 : jhr 3912 &stepLimit, true);
33 : jhr 4668 #ifdef DIDEROT_EXEC_SNAPSHOT
34 :     opts->add ("s,snapshot",
35 :     "specify number of super-steps per snapshot (0 means no snapshots)",
36 :     &snapshotPeriod, true);
37 :     #endif
38 : jhr 4664 opts->add ("print", "specify where to direct printed output", &printFile, true);
39 : jhr 4668 opts->addFlag ("v,verbose", "enable runtime-system messages", &(wrld->_verbose));
40 :     opts->addFlag ("t,timing", "enable execution timing", &timingFlg);
41 : jhr 3912 #ifndef DIDEROT_NO_INPUTS
42 :     // register options for setting global inputs
43 : jhr 4317 register_inputs (&inputs, opts);
44 : jhr 3912 #endif
45 : jhr 4317 register_outputs (opts);
46 :     opts->process (argc, argv);
47 :     delete opts;
48 : jhr 3912 }
49 :    
50 : jhr 4633 // redirect printing (if necessary)
51 :     if (printFile.compare("-") != 0) {
52 :     wrld->_printTo = new std::ofstream (printFile);
53 :     if (wrld->_printTo->fail()) {
54 :     std::cerr << "Error opening print file" << std::endl;
55 : jhr 4855 delete wrld;
56 : jhr 4633 exit(1);
57 :     }
58 : jhr 5123 diderot::__details::config_ostream (*wrld->_printTo);
59 : jhr 4633 }
60 : jhr 5116 else {
61 : jhr 5123 diderot::__details::config_ostream (std::cout);
62 : jhr 5116 }
63 : jhr 4633
64 : jhr 3912 // initialize scheduler stuff
65 : jhr 3916 if (wrld->_verbose) {
66 : jhr 3912 std::cerr << "initializing world ..." << std::endl;
67 :     }
68 :     if (wrld->init()) {
69 : jhr 4797 std::cerr << "Error initializing world:\n" << wrld->get_errors() << std::endl;
70 : jhr 4990 delete wrld;
71 : jhr 3912 exit(1);
72 :     }
73 :    
74 :     #ifndef DIDEROT_NO_INPUTS
75 :     // initialize the input globals
76 : jhr 3916 if (init_inputs (wrld, &inputs)) {
77 : jhr 4797 std::cerr << "Error initializing inputs:\n" << wrld->get_errors() << std::endl;
78 : jhr 4990 delete wrld;
79 : jhr 4317 exit(1);
80 : jhr 3912 }
81 :     #endif
82 :    
83 :     // run the generated global initialization code
84 : jhr 3916 if (wrld->_verbose) {
85 : jhr 4407 std::cerr << "initializing globals and creating strands ...\n";
86 : jhr 3912 }
87 : jhr 4407 if (wrld->create_strands()) {
88 : jhr 4063 std::cerr << "Error in global initialization:\n"
89 : jhr 4797 << wrld->get_errors() << std::endl;
90 : jhr 4990 delete wrld;
91 : jhr 3912 exit(1);
92 :     }
93 :    
94 : jhr 4661 #ifdef DIDEROT_EXEC_SNAPSHOT
95 :    
96 : jhr 4664 if (snapshotPeriod > 0) {
97 : jhr 4779 // write initial state as snapshot 0
98 : jhr 4678 write_snapshot (wrld, "-0000");
99 :     // run the program for `snapshotPeriod` steps at a time with a snapshot after each run
100 : jhr 4668 while (true) {
101 :     uint32_t n, limit;
102 :     // determine a step limit for the next run
103 :     if (stepLimit > 0) {
104 :     if (stepLimit <= nSteps) {
105 :     break;
106 :     }
107 :     limit = std::min(stepLimit - nSteps, snapshotPeriod);
108 :     }
109 :     else {
110 :     limit = snapshotPeriod;
111 :     }
112 :     // run the program for upto limit steps
113 :     if ((n = wrld->run (limit)) == 0) {
114 :     break;
115 :     }
116 : jhr 4664 nSteps += n;
117 : jhr 5142 if (wrld->_errors->errNum > 0) {
118 : jhr 4664 break;
119 :     }
120 : jhr 5142 else if (wrld->_strands.num_alive() == 0) {
121 :     wrld->error("no alive strands, so no snapshot at step %d", nSteps);
122 :     break;
123 :     }
124 : jhr 4664 // write a snapshot with the step count as a suffix
125 :     std::string suffix = std::to_string(nSteps);
126 :     if (suffix.length() < 4) {
127 :     suffix = std::string("0000").substr(0, 4 - suffix.length()) + suffix;
128 :     }
129 :     suffix = "-" + suffix;
130 :     write_snapshot (wrld, suffix);
131 :     }
132 : jhr 4661 }
133 : jhr 4664 else {
134 :     nSteps = wrld->run (stepLimit);
135 :     }
136 :    
137 : jhr 4661 #else // !DIDEROT_EXEC_SNAPSHOT
138 :    
139 : jhr 4664 nSteps = wrld->run (stepLimit);
140 : jhr 3912
141 : jhr 4661 #endif // DIDEROT_EXEC_SNAPSHOT
142 :    
143 : jhr 3916 if (wrld->_errors->errNum > 0) {
144 : jhr 4797 std::cerr << "Error during execution:\n" << wrld->get_errors() << std::endl;
145 : jhr 4990 delete wrld;
146 : jhr 3912 exit(1);
147 :     }
148 :    
149 : jhr 4753 if ((stepLimit != 0) && (wrld->_strands.num_active() > 0)) {
150 :     #ifdef DIDEROT_STRAND_ARRAY
151 :     if (wrld->_verbose) {
152 :     std::cerr << "Step limit expired; "
153 :     << wrld->_strands.num_active() << " active strands remaining" << std::endl;
154 :     }
155 :     #else
156 :     // step limit expired, so kill remaining strands
157 :     if (wrld->_verbose) {
158 :     std::cerr << "Step limit expired. Killing remaining "
159 :     << wrld->_strands.num_active() << " active strands" << std::endl;
160 :     }
161 :     wrld->kill_all();
162 :     #endif
163 :     }
164 :    
165 : jhr 3916 if (wrld->_verbose) {
166 : jhr 4990 std::cerr << "done: " << nSteps << " steps, in " << wrld->_run_time << " seconds";
167 :     #ifndef DIDEROT_STRAND_ARRAY
168 :     std::cerr << "; " << wrld->_strands.num_stable() << " stable strands" << std::endl;
169 :     #else
170 :     std::cerr << std::endl;
171 :     #endif
172 : jhr 3912 }
173 :     else if (timingFlg) {
174 : jhr 4317 std::cout << "usr=" << wrld->_run_time << std::endl;
175 : jhr 3912 }
176 :    
177 :     // output the final strand states
178 : jhr 5142 if (wrld->_strands.num_stable() > 0) {
179 :     write_output (wrld);
180 :     }
181 :     else {
182 :     std::cerr << "Error: no stable strands at termination, so no output\n";
183 :     delete wrld;
184 :     return 1;
185 :     }
186 : jhr 3912
187 : jhr 3917 delete wrld;
188 : jhr 3912
189 :     return 0;
190 :    
191 :     } // main

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0