test203a.cpp revision 12855:588919e0e4aa 
1#define SC_INCLUDE_DYNAMIC_PROCESSES
2
3#include <systemc>
4#include <cstring>
5using namespace sc_core;
6using namespace sc_dt;
7using std::cout;
8using std::endl;
9
10// 3) Process handle methods, including invalid and terminated process
11
12void invalid_handle_check(sc_process_handle& h)
13{
14
15    sc_assert(h.valid() == false);
16    sc_assert(strcmp(h.name(), "") == 0);
17    sc_assert(h.proc_kind() == SC_NO_PROC_);
18    sc_assert(h.get_process_object() == 0);
19    std::vector<sc_object*> children = h.get_child_objects();
20    sc_assert(children.size() == 0);
21    sc_assert(h.get_parent_object() == 0);
22    sc_assert(h.terminated() == false);
23    sc_assert(h.dynamic() == false);
24    sc_assert( !(h == h) );
25    sc_assert(h != h);
26
27    cout << "There should be warning 11 messages" << endl;
28
29    h.disable();
30    h.enable();
31    h.is_unwinding();
32    h.kill();
33    h.reset();
34    h.resume();
35    h.suspend();
36    h.sync_reset_off();
37    h.sync_reset_on();
38    h.terminated_event();
39    h.throw_it(sc_user(), SC_NO_DESCENDANTS);
40
41    cout << "End of warning messages" << endl;
42}
43
44SC_MODULE(M)
45{
46  sc_in_clk clk;
47  SC_CTOR(M)
48  {
49    sc_process_handle h;
50    invalid_handle_check(h);
51
52    SC_THREAD(T);
53    SC_CTHREAD(CT, clk.pos());
54    SC_METHOD(ME);
55
56    sc_process_handle h3 = sc_spawn(sc_bind(&M::stat_thread, this), "stat_thread");
57    sc_spawn_options opt;
58    opt.spawn_method();
59    sc_process_handle h4 = sc_spawn(sc_bind(&M::stat_method, this), "stat_method", &opt);
60
61    std::vector<sc_object*> children = this->get_child_objects();
62    sc_assert(children.size() == 6);
63  }
64  void T()
65  {
66    sc_process_handle h;
67    invalid_handle_check(h);
68
69    sc_process_handle h2 = sc_get_current_process_handle();
70    sc_assert(h2.valid() == true);
71    sc_assert(strcmp(h2.name(), "top.m.T") == 0);
72    sc_assert(h2.proc_kind() == SC_THREAD_PROC_);
73    sc_assert(h2.get_process_object() != 0);
74    std::vector<sc_object*> children2 = h2.get_child_objects();
75    sc_assert(children2.size() == 0);
76    sc_assert(h2.get_parent_object() == this);
77    sc_assert(h2.terminated() == false);
78    sc_assert(h2.dynamic() == false);
79    sc_assert(h2 == h2);
80    sc_assert(h2 != h);
81
82    sc_process_handle h3 = sc_spawn(sc_bind(&M::dyn_thread, this), "dyn_thread");
83    wait(1, SC_NS);
84
85    if (h3.valid() == true)
86    {
87      sc_assert(strcmp(h3.name(), "top.m.T.dyn_thread") == 0);
88      sc_assert(h3.proc_kind() == SC_THREAD_PROC_);
89      sc_assert(h3.get_process_object() != 0);
90      std::vector<sc_object*> children3 = h3.get_child_objects();
91      sc_assert(children3.size() == 0);
92      sc_assert(h3.get_parent_object() == sc_get_current_process_handle().get_process_object());
93      sc_assert(h3.terminated() == true);
94      sc_assert(h3.dynamic() == true);
95      sc_assert(h3 == h3);
96      sc_assert( !(h3 != h3) );
97    }
98
99    sc_spawn_options opt;
100    opt.spawn_method();
101    sc_process_handle h4 = sc_spawn(sc_bind(&M::dyn_method, this), "dyn_method", &opt);
102    sc_assert(h4 != h3);
103
104    wait(10, SC_NS);
105    sc_stop();
106  }
107
108  void stat_thread()
109  {
110    sc_process_handle h;
111    invalid_handle_check(h);
112
113    wait(5, SC_NS);
114
115    sc_process_handle h3 = sc_get_current_process_handle();
116    sc_assert(h3.valid() == true);
117    sc_assert(strcmp(h3.name(), "top.m.stat_thread") == 0);
118    sc_assert(h3.proc_kind() == SC_THREAD_PROC_);
119    sc_assert(h3.get_process_object() != 0);
120    std::vector<sc_object*> children3 = h3.get_child_objects();
121    sc_assert(children3.size() == 0);
122    sc_assert(h3.get_parent_object() != 0);
123    sc_assert(h3.terminated() == false);
124    sc_assert(h3.dynamic() == false);
125    sc_assert(h3 == h3);
126    sc_assert(h3 != h);
127
128    sc_process_handle h4;
129    h4 = h3;
130    sc_assert(h4 == h3);
131    sc_assert(h4 != h);
132  }
133
134  void stat_method()
135  {
136    sc_process_handle h;
137    invalid_handle_check(h);
138
139    sc_process_handle h3 = sc_get_current_process_handle();
140    sc_assert(h3.valid() == true);
141    sc_assert(strcmp(h3.name(), "top.m.stat_method") == 0);
142    sc_assert(h3.proc_kind() == SC_METHOD_PROC_);
143    sc_assert(h3.get_process_object() != 0);
144    std::vector<sc_object*> children3 = h3.get_child_objects();
145    sc_assert(children3.size() == 0);
146    sc_assert(h3.get_parent_object() != 0);
147    sc_assert(h3.terminated() == false);
148    sc_assert(h3.dynamic() == false);
149    sc_assert(h3 == h3);
150    sc_assert(h3 != h);
151
152    sc_process_handle h4;
153    h4 = h3;
154    sc_assert(h4 == h3);
155    sc_assert(h4 != h);
156  }
157
158  void dyn_thread()
159  {
160    sc_process_handle h;
161    invalid_handle_check(h);
162
163    sc_process_handle h3 = sc_get_current_process_handle();
164    sc_assert(h3.valid() == true);
165    sc_assert(strcmp(h3.name(), "top.m.T.dyn_thread") == 0);
166    sc_assert(h3.proc_kind() == SC_THREAD_PROC_);
167    sc_assert(h3.get_process_object() != 0);
168    std::vector<sc_object*> children3 = h3.get_child_objects();
169    sc_assert(children3.size() == 0);
170    sc_assert(h3.get_parent_object() != 0);
171    sc_assert(h3.terminated() == false);
172    sc_assert(h3.dynamic() == true);
173    sc_assert(h3 == h3);
174    sc_assert(h3 != h);
175
176    sc_process_handle h4(h3);
177    sc_assert(h4 == h3);
178  }
179
180  void dyn_method()
181  {
182    sc_process_handle h;
183    invalid_handle_check(h);
184
185    sc_process_handle h3 = sc_get_current_process_handle();
186    sc_assert(h3.valid() == true);
187    sc_assert(strcmp(h3.name(), "top.m.T.dyn_method") == 0);
188    sc_assert(h3.proc_kind() == SC_METHOD_PROC_);
189    sc_assert(h3.get_process_object() != 0);
190    std::vector<sc_object*> children3 = h3.get_child_objects();
191    sc_assert(children3.size() == 0);
192    sc_assert(h3.get_parent_object() != 0);
193    sc_assert(h3.terminated() == false);
194    sc_assert(h3.dynamic() == true);
195    sc_assert(h3 == h3);
196    sc_assert(h3 != h);
197
198    sc_process_handle h4(h3);
199    sc_assert(h4 == h3);
200  }
201
202  void CT()
203  {
204    sc_process_handle h;
205    invalid_handle_check(h);
206
207    sc_process_handle h2 = sc_get_current_process_handle();
208    sc_assert(h2.valid() == true);
209    sc_assert(strcmp(h2.name(), "top.m.CT") == 0);
210    sc_assert(h2.proc_kind() == SC_CTHREAD_PROC_);
211    sc_assert(h2.get_process_object() != 0);
212    std::vector<sc_object*> children2 = h2.get_child_objects();
213    sc_assert(children2.size() == 0);
214    sc_assert(h2.get_parent_object() == this);
215    sc_assert(h2.terminated() == false);
216    sc_assert(h2.dynamic() == false);
217    sc_assert(h2 == h2);
218    sc_assert(h2 != h);
219  }
220
221  void ME()
222  {
223    sc_process_handle h;
224    invalid_handle_check(h);
225
226    sc_process_handle h2 = sc_get_current_process_handle();
227    sc_assert(h2.valid() == true);
228    sc_assert(strcmp(h2.name(), "top.m.ME") == 0);
229    sc_assert(h2.proc_kind() == SC_METHOD_PROC_);
230    sc_assert(h2.get_process_object() != 0);
231    std::vector<sc_object*> children2 = h2.get_child_objects();
232    sc_assert(children2.size() == 0);
233    sc_assert(h2.get_parent_object() == this);
234    sc_assert(h2.terminated() == false);
235    sc_assert(h2.dynamic() == false);
236    sc_assert(h2 == h2);
237    sc_assert(h2 != h);
238  }
239
240};
241
242struct Top: sc_module
243{
244  M *m;
245  sc_clock clk;
246  Top(sc_module_name)
247  {
248    m = new M("m");
249    m->clk(clk);
250  }
251};
252
253int sc_main(int argc, char* argv[])
254{
255  cout << "Should be silent except for warning messages" << endl;
256
257  sc_process_handle h;
258  invalid_handle_check(h);
259
260  Top top("top");
261  sc_start();
262
263  cout << endl << "Success" << endl;
264  return 0;
265}
266