test05.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 test05.cpp -- Test reset_signal_is() and async_reset_signal_is() usage. 23 24 Original Author: Andy Goodrich, Forte Design Systems, 14 December 2006 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 *****************************************************************************/ 37 38#define SC_INCLUDE_DYNAMIC_PROCESSES 39#include "systemc.h" 40 41SC_MODULE(DUT) 42{ 43 SC_CTOR(DUT) 44 { 45 SC_CTHREAD(creator,m_clk.pos()); 46 SC_CTHREAD(resetter,m_clk.neg()); 47 48 // SET UP STATICALLY DEFINED PROCESSES: 49 50 SC_CTHREAD(static_cthread,m_clk.pos()); 51 async_reset_signal_is(m_areset,true); 52 reset_signal_is(m_sreset,true); 53 SC_METHOD(static_method); 54 reset_signal_is(m_areset,true); 55 SC_THREAD(static_thread_clocked); 56 sensitive << m_clk.pos(); 57 dont_initialize(); 58 async_reset_signal_is(m_areset,true); 59 reset_signal_is(m_sreset,true); 60 SC_THREAD(static_thread_event); 61 async_reset_signal_is(m_areset,true); 62 reset_signal_is(m_sreset,true); 63 SC_THREAD(static_thread_timed); 64 async_reset_signal_is(m_areset,true); 65 reset_signal_is(m_sreset,true); 66 } 67 68 // creator - create the dynamic processes after the start of simulation: 69 void creator() 70 { 71 sc_spawn_options options_method; 72 sc_spawn_options options_thread_clocked; 73 sc_spawn_options options_thread_event; 74 sc_spawn_options options_thread_timed; 75 76 wait(1); 77 78 options_method.reset_signal_is( m_areset, true ); 79 options_method.spawn_method(); 80 sc_spawn( sc_bind(&DUT::dynamic_method, this), "dynamic_method", 81 &options_method); 82 83 options_thread_clocked.async_reset_signal_is( m_areset, true ); 84 options_thread_clocked.reset_signal_is( m_sreset, true ); 85 options_thread_clocked.set_sensitivity( &m_clk.posedge_event() ); 86 sc_spawn( sc_bind(&DUT::dynamic_thread_clocked, this), 87 "dynamic_thread_clocked", &options_thread_clocked); 88 89 options_thread_event.async_reset_signal_is( m_areset, true ); 90 options_thread_event.reset_signal_is( m_sreset, true ); 91 sc_spawn( sc_bind(&DUT::dynamic_thread_event, this), 92 "dynamic_thread_event", &options_thread_event); 93 94 options_thread_timed.async_reset_signal_is( m_areset, true ); 95 options_thread_timed.reset_signal_is( m_sreset, true ); 96 sc_spawn( sc_bind(&DUT::dynamic_thread_timed, this), 97 "dynamic_thread_timed", &options_thread_timed); 98 99 } 100 101 void dynamic_method() 102 { 103 cout << sc_time_stamp() << " ... dynamic method" << endl; 104 next_trigger(m_non_event); 105 } 106 107 void dynamic_thread_clocked() 108 { 109 cout << sc_time_stamp() << " ... dynamic thread clocked" << endl; 110 for (;;) 111 { 112 wait(); 113 } 114 } 115 116 void dynamic_thread_event() 117 { 118 cout << sc_time_stamp() << " ... dynamic thread event wait" << endl; 119 for (;;) 120 { 121 wait(m_non_event); 122 } 123 } 124 125 void dynamic_thread_timed() 126 { 127 cout << sc_time_stamp() << " ... dynamic thread timed wait" << endl; 128 for (;;) 129 { 130 wait(1000, SC_NS); 131 } 132 } 133 134 135 void resetter() 136 { 137 for ( int wait_i = 1; wait_i < 3; wait_i++ ) 138 { 139 wait(2); 140 cout << endl << sc_time_stamp() << " asserting asynchronous reset" 141 << endl; 142 m_areset = true; 143 wait(wait_i); 144 cout << endl << sc_time_stamp() << " clearing asynchronous reset" 145 << endl; 146 m_areset = false; 147 wait(2); 148 cout << endl << sc_time_stamp() << " asserting synchronous reset" 149 << endl; 150 m_sreset = true; 151 wait(wait_i); 152 cout << endl << sc_time_stamp() << " clearing synchronous reset" 153 << endl; 154 m_sreset = false; 155 wait(5); 156 } 157 cout << endl << sc_time_stamp() << " terminating simulation" << endl; 158 sc_stop(); 159 } 160 161 void static_cthread() 162 { 163 cout << sc_time_stamp() << " ... static cthread" << endl; 164 for (;;) 165 { 166 wait(); 167 } 168 } 169 170 void static_method() 171 { 172 cout << sc_time_stamp() << " ... static method" << endl; 173 next_trigger(m_non_event); 174 } 175 176 void static_thread_clocked() 177 { 178 cout << sc_time_stamp() << " ... static thread clocked" << endl; 179 for (;;) 180 { 181 wait(); 182 } 183 } 184 185 void static_thread_event() 186 { 187 cout << sc_time_stamp() << " ... static thread event wait " << endl; 188 for (;;) 189 { 190 wait(m_non_event); 191 } 192 } 193 194 void static_thread_timed() 195 { 196 cout << sc_time_stamp() << " ... static thread timed wait " << endl; 197 for (;;) 198 { 199 wait(1000, SC_NS); 200 } 201 } 202 203 sc_signal<bool> m_areset; 204 sc_in<bool> m_clk; 205 sc_event m_non_event; 206 sc_signal<bool> m_sreset; 207}; 208 209int sc_main(int argc, char* argv[]) 210{ 211 sc_clock clock; 212 DUT dut("dut"); 213 214 dut.m_clk(clock); 215 216 sc_start(); 217 218 cout << "Program completed" << endl; 219 return 0; 220} 221