test02.cpp revision 12855:588919e0e4aa 
1/*****************************************************************************
2
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements.  See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License.  You may obtain a copy of the License at
9
10    http://www.apache.org/licenses/LICENSE-2.0
11
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied.  See the License for the specific language governing
16  permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22  test02.cpp -- Test of resume after dynamic event completion
23
24  Original Author: Andy Goodrich
25
26 *****************************************************************************/
27
28/*****************************************************************************
29
30  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
31  changes you are making here.
32
33      Name, Affiliation, Date:
34  Description of Modification:
35
36  Revision log at end of the file to let __LINE__ give the same results
37  after a check-in.
38 *****************************************************************************/
39
40#include "systemc.h"
41
42SC_MODULE(DUT)
43{
44    SC_CTOR(DUT)
45    {
46        SC_CTHREAD(cthread,m_clk.pos());
47        reset_signal_is(m_reset, true);
48        m_cthread = sc_get_current_process_handle();
49
50        SC_METHOD(dynamic_method);
51	m_dynamic_method = sc_get_current_process_handle();
52
53        SC_THREAD(dynamic_thread);
54        m_dynamic_thread = sc_get_current_process_handle();
55
56        SC_METHOD(static_method);
57	sensitive << m_event1 << m_event2;
58	m_static_method = sc_get_current_process_handle();
59
60	SC_THREAD(static_thread);
61	sensitive << m_event1 << m_event2;
62        m_static_thread = sc_get_current_process_handle();
63
64        SC_CTHREAD(stimulus,m_clk.pos());
65        reset_signal_is(m_reset, true);
66    }
67    void cthread()
68    {
69        for (;;)
70	{
71	    wait();
72	    cout << sc_time_stamp() << ":      clocked thread (" << __LINE__
73		 << ") after wait on m_clk.pos() " << endl;
74	}
75    }
76    void dynamic_method()
77    {
78        static int state = 0;
79        switch ( state )
80        {
81          case 0:
82            next_trigger( m_clk.posedge_event() );
83            cout << sc_time_stamp() << ":      dynamic method (" << __LINE__
84                 << "," << state << ") initialization call " << endl;
85            state = 1;
86            break;
87          default:
88          case 1:
89            next_trigger( m_event1 & m_event2 );
90            cout << sc_time_stamp() << ":      dynamic method (" << __LINE__
91                 << "," << state << ") after wait on m_clk.posedge() " << endl;
92            break;
93        }
94    }
95    void dynamic_thread()
96    {
97        cout << sc_time_stamp() << ":      dynamic thread (" << __LINE__ << ")"
98             << " initialization call " << endl;
99        wait(m_clk.posedge_event());
100        cout << sc_time_stamp() << ":      dynamic thread (" << __LINE__
101             << ") after wait on m_clk.posedge_event() " << endl;
102        for (;;)
103        {
104            wait(m_event1 & m_event2 );
105            cout << sc_time_stamp() << ":      dynamic thread (" << __LINE__
106                 << ") after wait on m_event1 & m_event2 " << endl;
107        }
108    }
109    void static_method()
110    {
111        static bool initialized = false;
112	if ( !initialized )
113	{
114	    initialized = true;
115	    cout << sc_time_stamp() << ":      static method (" << __LINE__
116	         << ")" << " initialization call " << endl;
117	}
118	else
119	{
120	    cout << sc_time_stamp() << ":      static method (" << __LINE__
121		 << ") after wait on m_event1 | m_event2 " << endl;
122	}
123    }
124    void static_thread()
125    {
126        cout << sc_time_stamp() << ":      static thread (" << __LINE__ << ")"
127             << " initialization call " << endl;
128	for (;;)
129	{
130	    wait();
131            cout << sc_time_stamp() << ":      static thread (" << __LINE__
132                 << ") after wait on m_event1 | m_event2 " << endl;
133	}
134
135    }
136    void stimulus()
137    {
138        for (;;)
139        {
140            wait();
141            wait();
142            cout << sc_time_stamp() << ": stimulus ("
143                 << __LINE__ << ") - suspending all processes" << endl;
144            m_cthread.suspend();
145            m_dynamic_method.suspend();
146            m_dynamic_thread.suspend();
147            m_static_method.suspend();
148            m_static_thread.suspend();
149            wait();
150
151            m_event1.notify(SC_ZERO_TIME);
152            cout << sc_time_stamp() << ": stimulus ("
153                 << __LINE__ << ") - firing event1 " << endl;
154            wait();
155            m_event2.notify(SC_ZERO_TIME);
156            cout << sc_time_stamp() << ": stimulus ("
157                 << __LINE__ << ") - firing event2 " << endl;
158            wait();
159            wait();
160
161            m_cthread.resume();
162            m_dynamic_method.resume();
163            m_dynamic_thread.resume();
164            m_static_method.resume();
165            m_static_thread.resume();
166            cout << endl << sc_time_stamp() << ": stimulus ("
167                 << __LINE__ << ") - resuming all processes" << endl;
168            wait();
169            wait();
170            wait();
171            sc_stop();
172        }
173    }
174    sc_in<bool>       m_clk;
175    sc_process_handle m_cthread;
176    sc_process_handle m_dynamic_method;
177    sc_process_handle m_dynamic_thread;
178    sc_event          m_event1;
179    sc_event          m_event2;
180    sc_event          m_event3;
181    sc_event          m_event4;
182    sc_in<bool>       m_reset;
183    sc_process_handle m_static_method;
184    sc_process_handle m_static_thread;
185};
186
187int sc_main(int argc, char* argv[])
188{
189    sc_core::sc_allow_process_control_corners = true;
190    sc_clock        clock;
191    DUT             dut("dut");
192    sc_signal<bool> reset;
193
194    dut.m_clk(clock);
195    dut.m_reset(reset);
196
197    sc_core::sc_allow_process_control_corners = true;
198    reset = true;
199    sc_start(1, SC_NS);
200    reset = false;
201    sc_start(21, SC_NS);
202
203    cout << "Program completed" << endl;
204    return 0;
205}
206
207// $Log: test02.cpp,v $
208// Revision 1.6  2011/04/02 00:08:27  acg
209//  Andy Goodrich: turn off corner case error checking.
210//
211// Revision 1.5  2011/03/07 19:32:11  acg
212//  Andy Goodrich: addition to set sc_core::sc_allow_process_control_corners
213//  to true so that this test avoids corner case error messages.
214//
215// Revision 1.4  2011/02/20 13:43:58  acg
216//  Andy Goodrich: updates for IEEE 1666 2011.
217//
218// Revision 1.3  2011/02/14 17:00:00  acg
219//  Andy Goodrich: updated copyright and added cvs logging information inline.
220//
221// Revision 1.2  2011/01/20 16:55:23  acg
222//  Andy Goodrich: changes for IEEE 1666 2011.
223//
224// Revision 1.1.1.1  2006/12/15 20:26:03  acg
225// systemc_tests-2.3
226//
227// Revision 1.1  2006/12/14 21:40:06  acg
228//  Andy Goodrich: moving test to new directory.
229//
230// Revision 1.2  2006/04/20 19:43:34  acg
231//  Andy Goodrich: moved CVS log to end of file so that __LINE__ does not
232//  change when a checkin is done.
233//
234// Revision 1.1  2006/04/17 20:11:02  acg
235//  Andy Goodrich: First inclusion of test for suspend and resume support.
236//
237
238