00001 /******************************************************************************* 00002 00003 The following code is derived, directly or indirectly, from the SystemC 00004 source code Copyright (c) 1996-2014 by all Contributors. 00005 All Rights reserved. 00006 00007 The contents of this file are subject to the restrictions and limitations 00008 set forth in the SystemC Open Source License (the "License"); 00009 You may not use this file except in compliance with such restrictions and 00010 limitations. You may obtain instructions on how to receive a copy of the 00011 License at http://www.accellera.org/. Software distributed by Contributors 00012 under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF 00013 ANY KIND, either express or implied. See the License for the specific 00014 language governing rights and limitations under the License. 00015 00016 ******************************************************************************/ 00017 00018 /******************************************************************************* 00019 00020 sc_runnable_int.h -- For inline definitions of some utility functions. 00021 DO NOT EXPORT THIS INCLUDE FILE. Include this file 00022 after "sc_process_int.h" so that we can get the base 00023 class right. 00024 00025 Original Author: Bishnupriya Bhattacharya , Cadence Design, 28th July, 2003 00026 00027 CHANGE LOG AT THE END OF THE FILE 00028 ******************************************************************************/ 00029 00030 #ifndef SC_RUNNABLE_INT_H 00031 #define SC_RUNNABLE_INT_H 00032 00033 00034 #include "sysc/kernel/sc_runnable.h" 00035 #include "sysc/kernel/sc_method_process.h" 00036 #include "sysc/kernel/sc_thread_process.h" 00037 00038 // DEBUGGING MACROS: 00039 // 00040 // DEBUG_MSG(NAME,P,MSG) 00041 // MSG = message to print 00042 // NAME = name that must match the process for the message to print, or 00043 // null if the message should be printed unconditionally. 00044 // P = pointer to process message is for, or NULL in which case the 00045 // message will not print. 00046 #if 0 00047 # define DEBUG_NAME "" 00048 # define DEBUG_MSG(NAME,P,MSG) \ 00049 { \ 00050 if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \ 00051 std::cout << "**** " << sc_time_stamp() << " (" \ 00052 << sc_get_current_process_name() << "): " << MSG \ 00053 << " - " << P->name() << std::endl; \ 00054 } 00055 #else 00056 # define DEBUG_MSG(NAME,P,MSG) 00057 #endif 00058 00059 namespace sc_core { 00060 00061 // The values below are used to indicate when a queue is empty. A non-zero 00062 // non-legal pointer value is used for this so that a zero value in the 00063 // m_execute_p field of an sc_process_b instance can be used to indicate 00064 // that is has not been queued for run. (If we did not use a non-zero 00065 // queue empty indicator then a sc_process_b instance that was queued 00066 // twice in a row might end up on the queue twice if it were the first 00067 // one that was queued!) 00068 00069 #define SC_NO_METHODS ((sc_method_handle)0xdb) 00070 #define SC_NO_THREADS ((sc_thread_handle)0xdb) 00071 00072 00073 //------------------------------------------------------------------------------ 00074 //"sc_runnable::dump" 00075 // 00076 // This method dumps the contents of this object instance. 00077 //------------------------------------------------------------------------------ 00078 inline void sc_runnable::dump() const 00079 { 00080 // Dump the thread queues: 00081 00082 std::cout << "thread pop queue: " << std::endl; 00083 for ( sc_thread_handle p = m_threads_pop; p != SC_NO_THREADS; 00084 p = p->next_runnable() ) 00085 { 00086 std::cout << " " << p << std::endl; 00087 } 00088 00089 std::cout << "thread push queue: " << std::endl; 00090 for ( sc_thread_handle p = m_threads_push_head->next_runnable(); 00091 p != SC_NO_THREADS; p = p->next_runnable() ) 00092 { 00093 std::cout << " " << p << std::endl; 00094 } 00095 } 00096 00097 //------------------------------------------------------------------------------ 00098 //"sc_runnable::execute_method_next" 00099 // 00100 // This method pushes the the supplied method to execute as the next process. 00101 // This is done by pushing it onto the front of the m_methods_pop. 00102 // method_h -> method process to add to the queue. 00103 //------------------------------------------------------------------------------ 00104 inline void sc_runnable::execute_method_next( sc_method_handle method_h ) 00105 { 00106 DEBUG_MSG(DEBUG_NAME,method_h,"pushing this method to execute next"); 00107 method_h->set_next_runnable( m_methods_pop ); 00108 m_methods_pop = method_h; 00109 } 00110 00111 //------------------------------------------------------------------------------ 00112 //"sc_runnable::execute_thread_next" 00113 // 00114 // This method pushes the the supplied thread to execute as the next process. 00115 // This is done by pushing it onto the front of the m_threads_pop. 00116 // thread_h -> thread process to add to the queue. 00117 //------------------------------------------------------------------------------ 00118 inline void sc_runnable::execute_thread_next( sc_thread_handle thread_h ) 00119 { 00120 DEBUG_MSG(DEBUG_NAME,thread_h,"pushing this thread to execute next"); 00121 thread_h->set_next_runnable( m_threads_pop ); 00122 m_threads_pop = thread_h; 00123 } 00124 00125 //------------------------------------------------------------------------------ 00126 //"sc_runnable::init" 00127 // 00128 // This method initializes this object instance. Note we allocate the queue 00129 // heads if necessary. This is done here rather than in the constructor for 00130 // this class to eliminate CTOR processing errors with gcc. 00131 //------------------------------------------------------------------------------ 00132 inline void sc_runnable::init() 00133 { 00134 m_methods_pop = SC_NO_METHODS; 00135 if ( !m_methods_push_head ) 00136 { 00137 m_methods_push_head = new sc_method_process("methods_push_head", true, 00138 (SC_ENTRY_FUNC)0, 0, 0); 00139 m_methods_push_head->dont_initialize(true); 00140 m_methods_push_head->detach(); 00141 } 00142 m_methods_push_tail = m_methods_push_head; 00143 m_methods_push_head->set_next_runnable(SC_NO_METHODS); 00144 00145 m_threads_pop = SC_NO_THREADS; 00146 if ( !m_threads_push_head ) 00147 { 00148 m_threads_push_head = new sc_thread_process("threads_push_head", true, 00149 (SC_ENTRY_FUNC)0, 0, 0); 00150 m_threads_push_head->dont_initialize(true); 00151 m_threads_push_head->detach(); 00152 } 00153 m_threads_push_head->set_next_runnable(SC_NO_THREADS); 00154 m_threads_push_tail = m_threads_push_head; 00155 } 00156 00157 00158 //------------------------------------------------------------------------------ 00159 //"sc_runnable::is_empty" 00160 // 00161 // This method returns true if the push queue is empty, or false if not. 00162 //------------------------------------------------------------------------------ 00163 inline bool sc_runnable::is_empty() const 00164 { 00165 return m_methods_push_head->next_runnable() == SC_NO_METHODS && 00166 m_methods_pop == SC_NO_METHODS && 00167 m_threads_push_head->next_runnable() == SC_NO_THREADS && 00168 m_threads_pop == SC_NO_THREADS; 00169 } 00170 00171 00172 //------------------------------------------------------------------------------ 00173 //"sc_runnable::is_initialized" 00174 // 00175 // This method returns true if the push queue is already initialized. 00176 //------------------------------------------------------------------------------ 00177 inline bool sc_runnable::is_initialized() const 00178 { 00179 return m_methods_push_head && m_threads_push_head; 00180 } 00181 00182 00183 //------------------------------------------------------------------------------ 00184 //"sc_runnable::push_back_method" 00185 // 00186 // This method pushes the supplied method process onto the back of the queue of 00187 // runnable method processes. 00188 // method_h -> method process to add to the queue. 00189 //------------------------------------------------------------------------------ 00190 inline void sc_runnable::push_back_method( sc_method_handle method_h ) 00191 { 00192 // assert( method_h->next_runnable() == 0 ); // Can't queue twice. 00193 DEBUG_MSG(DEBUG_NAME,method_h,"pushing back method"); 00194 method_h->set_next_runnable(SC_NO_METHODS); 00195 m_methods_push_tail->set_next_runnable(method_h); 00196 m_methods_push_tail = method_h; 00197 } 00198 00199 00200 //------------------------------------------------------------------------------ 00201 //"sc_runnable::push_back_thread" 00202 // 00203 // This method pushes the supplied thread process onto the back of the queue of 00204 // runnable thread processes. 00205 // thread_h -> thread process to add to the queue. 00206 //------------------------------------------------------------------------------ 00207 inline void sc_runnable::push_back_thread( sc_thread_handle thread_h ) 00208 { 00209 // assert( thread_h->next_runnable() == 0 ); // Can't queue twice. 00210 DEBUG_MSG(DEBUG_NAME,thread_h,"pushing back thread"); 00211 thread_h->set_next_runnable(SC_NO_THREADS); 00212 m_threads_push_tail->set_next_runnable(thread_h); 00213 m_threads_push_tail = thread_h; 00214 } 00215 00216 00217 //------------------------------------------------------------------------------ 00218 //"sc_runnable::push_front_method" 00219 // 00220 // This method pushes the supplied method process onto the front of the queue of 00221 // runnable method processes. If the queue is empty the process is the tail 00222 // also. 00223 // method_h -> method process to add to the queue. 00224 //------------------------------------------------------------------------------ 00225 inline void sc_runnable::push_front_method( sc_method_handle method_h ) 00226 { 00227 // assert( method_h->next_runnable() == 0 ); // Can't queue twice. 00228 DEBUG_MSG(DEBUG_NAME,method_h,"pushing front method"); 00229 method_h->set_next_runnable(m_methods_push_head->next_runnable()); 00230 if ( m_methods_push_tail == m_methods_push_head ) // Empty queue. 00231 { 00232 m_methods_push_tail->set_next_runnable(method_h); 00233 m_methods_push_tail = method_h; 00234 } 00235 else // Non-empty queue. 00236 { 00237 m_methods_push_head->set_next_runnable(method_h); 00238 } 00239 } 00240 00241 00242 //------------------------------------------------------------------------------ 00243 //"sc_runnable::push_front_thread" 00244 // 00245 // This method pushes the supplied thread process onto the front of the queue of 00246 // runnable thread processes. If the queue is empty the process is the tail 00247 // also. 00248 // thread_h -> thread process to add to the queue. 00249 //------------------------------------------------------------------------------ 00250 inline void sc_runnable::push_front_thread( sc_thread_handle thread_h ) 00251 { 00252 // assert( thread_h->next_runnable() == 0 ); // Can't queue twice. 00253 DEBUG_MSG(DEBUG_NAME,thread_h,"pushing front thread"); 00254 thread_h->set_next_runnable(m_threads_push_head->next_runnable()); 00255 if ( m_threads_push_tail == m_threads_push_head ) // Empty queue. 00256 { 00257 m_threads_push_tail->set_next_runnable(thread_h); 00258 m_threads_push_tail = thread_h; 00259 } 00260 else // Non-empty queue. 00261 { 00262 m_threads_push_head->set_next_runnable(thread_h); 00263 } 00264 } 00265 00266 //------------------------------------------------------------------------------ 00267 //"sc_runnable::pop_method" 00268 // 00269 // This method pops the next method process to be executed, or returns a null 00270 // if no method processes are available for execution. 00271 //------------------------------------------------------------------------------ 00272 inline sc_method_handle sc_runnable::pop_method() 00273 { 00274 sc_method_handle result_p; 00275 00276 result_p = m_methods_pop; 00277 if ( result_p != SC_NO_METHODS ) 00278 { 00279 m_methods_pop = result_p->next_runnable(); 00280 result_p->set_next_runnable(0); 00281 } 00282 else 00283 { 00284 result_p = 0; 00285 } 00286 DEBUG_MSG(DEBUG_NAME,result_p,"popping method"); 00287 return result_p; 00288 00289 } 00290 00291 //------------------------------------------------------------------------------ 00292 //"sc_runnable::pop_thread" 00293 // 00294 // This method pops the next thread process to be executed, or returns a null 00295 // if no thread processes are available for execution. 00296 //------------------------------------------------------------------------------ 00297 inline sc_thread_handle sc_runnable::pop_thread() 00298 { 00299 sc_thread_handle result_p; 00300 00301 result_p = m_threads_pop; 00302 if ( result_p != SC_NO_THREADS ) 00303 { 00304 m_threads_pop = result_p->next_runnable(); 00305 result_p->set_next_runnable(0); 00306 } 00307 else 00308 { 00309 result_p = 0; 00310 } 00311 DEBUG_MSG(DEBUG_NAME,result_p,"popping thread for execution"); 00312 return result_p; 00313 } 00314 00315 00316 //------------------------------------------------------------------------------ 00317 //"sc_runnable::remove_method" 00318 // 00319 // This method removes the supplied method process from the push queue if it is 00320 // present. Note we clear the method's next pointer so that it may be queued 00321 // again. 00322 // remove_p -> method process to remove from the run queue. 00323 //------------------------------------------------------------------------------ 00324 inline void sc_runnable::remove_method( sc_method_handle remove_p ) 00325 { 00326 sc_method_handle now_p; // Method now checking. 00327 sc_method_handle prior_p; // Method prior to now_p. 00328 00329 // Don't try to remove things if we have not been initialized. 00330 00331 if ( !is_initialized() ) return; 00332 00333 // Search the push queue: 00334 00335 prior_p = m_methods_push_head; 00336 for ( now_p = m_methods_push_head; now_p!= SC_NO_METHODS; 00337 now_p = now_p->next_runnable() ) 00338 { 00339 if ( remove_p == now_p ) 00340 { 00341 prior_p->set_next_runnable( now_p->next_runnable() ); 00342 if (now_p == m_methods_push_tail) { 00343 m_methods_push_tail = prior_p; 00344 } 00345 now_p->set_next_runnable(0); 00346 DEBUG_MSG(DEBUG_NAME,now_p,"removing method from push queue"); 00347 return; 00348 } 00349 prior_p = now_p; 00350 } 00351 00352 // Search the pop queue: 00353 00354 prior_p = NULL; 00355 for ( now_p = m_methods_pop; now_p != SC_NO_METHODS; 00356 now_p = now_p->next_runnable() ) 00357 { 00358 if ( remove_p == now_p ) 00359 { 00360 if ( prior_p ) 00361 prior_p->set_next_runnable( now_p->next_runnable() ); 00362 else 00363 m_methods_pop = now_p->next_runnable(); 00364 now_p->set_next_runnable(0); 00365 DEBUG_MSG(DEBUG_NAME,now_p,"removing method from pop queue"); 00366 return; 00367 } 00368 prior_p = now_p; 00369 } 00370 } 00371 00372 00373 //------------------------------------------------------------------------------ 00374 //"sc_runnable::remove_thread" 00375 // 00376 // This method removes the supplied thread process from the push or pop 00377 // queue if it is present. Note we clear the thread's next pointer so that it 00378 // may be queued again. 00379 // remove_p -> thread process to remove from the run queue. 00380 //------------------------------------------------------------------------------ 00381 inline void sc_runnable::remove_thread( sc_thread_handle remove_p ) 00382 { 00383 sc_thread_handle now_p; // Thread now checking. 00384 sc_thread_handle prior_p; // Thread prior to now_p. 00385 00386 // Don't try to remove things if we have not been initialized. 00387 00388 if ( !is_initialized() ) return; 00389 00390 // Search the push queue: 00391 00392 prior_p = m_threads_push_head; 00393 for ( now_p = m_threads_push_head; now_p != SC_NO_THREADS; 00394 now_p = now_p->next_runnable() ) 00395 { 00396 if ( remove_p == now_p ) 00397 { 00398 prior_p->set_next_runnable( now_p->next_runnable() ); 00399 if (now_p == m_threads_push_tail) { 00400 m_threads_push_tail = prior_p; 00401 } 00402 now_p->set_next_runnable(0); 00403 DEBUG_MSG(DEBUG_NAME,now_p,"removing thread from push queue"); 00404 return; 00405 } 00406 prior_p = now_p; 00407 } 00408 00409 // Search the pop queue: 00410 00411 prior_p = NULL; 00412 for ( now_p = m_threads_pop; now_p != SC_NO_THREADS; 00413 now_p = now_p->next_runnable() ) 00414 { 00415 if ( remove_p == now_p ) 00416 { 00417 if ( prior_p ) 00418 prior_p->set_next_runnable( now_p->next_runnable() ); 00419 else 00420 m_threads_pop = now_p->next_runnable(); 00421 now_p->set_next_runnable(0); 00422 DEBUG_MSG(DEBUG_NAME,now_p,"removing thread from pop queue"); 00423 return; 00424 } 00425 prior_p = now_p; 00426 } 00427 } 00428 00429 //------------------------------------------------------------------------------ 00430 //"sc_runnable::sc_runnable" 00431 // 00432 // This is the object instance constructor for this class. 00433 //------------------------------------------------------------------------------ 00434 inline sc_runnable::sc_runnable() : 00435 m_methods_push_head(0), m_methods_push_tail(0), m_methods_pop(SC_NO_METHODS), 00436 m_threads_push_head(0), m_threads_push_tail(0), m_threads_pop(SC_NO_THREADS) 00437 {} 00438 00439 //------------------------------------------------------------------------------ 00440 //"sc_runnable::~sc_runnable" 00441 // 00442 // This is the object instance destructor for this class. 00443 //------------------------------------------------------------------------------ 00444 inline sc_runnable::~sc_runnable() 00445 { 00446 delete m_methods_push_head; 00447 delete m_threads_push_head; 00448 } 00449 00450 00451 //------------------------------------------------------------------------------ 00452 //"sc_runnable::toggle_methods" 00453 // 00454 // This method moves the methods push queue to the pop queue and zeros the push 00455 // queue. This will only be done if the pop queue is presently empty. 00456 //------------------------------------------------------------------------------ 00457 inline void sc_runnable::toggle_methods() 00458 { 00459 if ( m_methods_pop == SC_NO_METHODS ) 00460 { 00461 m_methods_pop = m_methods_push_head->next_runnable(); 00462 m_methods_push_head->set_next_runnable(SC_NO_METHODS); 00463 m_methods_push_tail = m_methods_push_head; 00464 } 00465 } 00466 00467 00468 //------------------------------------------------------------------------------ 00469 //"sc_runnable::toggle_threads" 00470 // 00471 // This method moves the threads push queue to the pop queue and zeros the push 00472 // queue. This will only be done if the pop queue is presently empty. 00473 //------------------------------------------------------------------------------ 00474 inline void sc_runnable::toggle_threads() 00475 { 00476 if ( m_threads_pop == SC_NO_THREADS ) 00477 { 00478 m_threads_pop = m_threads_push_head->next_runnable(); 00479 m_threads_push_head->set_next_runnable(SC_NO_THREADS); 00480 m_threads_push_tail = m_threads_push_head; 00481 } 00482 } 00483 00484 00485 //------------------------------------------------------------------------------ 00486 //"sc_runnable::get_methods_push_first" 00487 // 00488 // This method returns the first method of methods push queue. 00489 //------------------------------------------------------------------------------ 00490 inline sc_method_handle sc_runnable::get_methods_push_first() 00491 { 00492 return m_methods_push_head->next_runnable(); 00493 } 00494 00495 00496 //------------------------------------------------------------------------------ 00497 //"sc_runnable::is_methods_push_end" 00498 // 00499 // This method checks whether method_h is the end of methods push queue. Return 00500 // true if method_h equals SC_NO_METHODS, which is right after the last method. 00501 //------------------------------------------------------------------------------ 00502 inline bool sc_runnable::is_methods_push_end( sc_method_handle method_h ) 00503 { 00504 return ( method_h == SC_NO_METHODS ); 00505 } 00506 00507 00508 //------------------------------------------------------------------------------ 00509 //"sc_runnable::get_methods_pop_first" 00510 // 00511 // This method returns the first method of methods pop queue. 00512 //------------------------------------------------------------------------------ 00513 inline sc_method_handle sc_runnable::get_methods_pop_first() 00514 { 00515 return m_methods_pop; 00516 } 00517 00518 00519 //------------------------------------------------------------------------------ 00520 //"sc_runnable::is_methods_pop_end" 00521 // 00522 // This method checks whether method_h is the end of methods pop queue. Return 00523 // true if method_h equals SC_NO_METHODS, which is right after the last method. 00524 //------------------------------------------------------------------------------ 00525 inline bool sc_runnable::is_methods_pop_end( sc_method_handle method_h ) 00526 { 00527 return ( method_h == SC_NO_METHODS ); 00528 } 00529 00530 00531 //------------------------------------------------------------------------------ 00532 //"sc_runnable::get_threads_push_first" 00533 // 00534 // This method returns the first thread of threads push queue. 00535 //------------------------------------------------------------------------------ 00536 inline sc_thread_handle sc_runnable::get_threads_push_first() 00537 { 00538 return m_threads_push_head->next_runnable(); 00539 } 00540 00541 00542 //------------------------------------------------------------------------------ 00543 //"sc_runnable::is_threads_push_end" 00544 // 00545 // This method checks whether thread_h is the end of threads push queue. Return 00546 // true if thread_h equals SC_NO_THREADS, which is right after the last thread. 00547 //------------------------------------------------------------------------------ 00548 inline bool sc_runnable::is_threads_push_end( sc_thread_handle thread_h ) 00549 { 00550 return ( thread_h == SC_NO_THREADS ); 00551 } 00552 00553 00554 //------------------------------------------------------------------------------ 00555 //"sc_runnable::get_threads_pop_first" 00556 // 00557 // This method returns the first thread of threads pop queue. 00558 //------------------------------------------------------------------------------ 00559 inline sc_thread_handle sc_runnable::get_threads_pop_first() 00560 { 00561 return m_threads_pop; 00562 } 00563 00564 00565 //------------------------------------------------------------------------------ 00566 //"sc_runnable::is_threads_pop_end" 00567 // 00568 // This method checks whether thread_h is the end of threads pop queue. Return 00569 // true if thread_h equals SC_NO_THREADS, which is right after the last thread. 00570 //------------------------------------------------------------------------------ 00571 inline bool sc_runnable::is_threads_pop_end( sc_thread_handle thread_h ) 00572 { 00573 return ( thread_h == SC_NO_THREADS ); 00574 } 00575 00576 #undef SC_NO_METHODS 00577 #undef SC_NO_THREADS 00578 #undef DEBUG_MSG 00579 00580 } // namespace sc_core 00581 00582 00583 /******************************************************************************* 00584 00585 MODIFICATION LOG - modifiers, enter your name, affiliation, date and 00586 changes you are making here. 00587 Andy Goodrich, Forte Design Systems, 2 September 2003 00588 Changed queue heads to instances to eliminate the checks for null heads. 00589 00590 ******************************************************************************/ 00591 00592 // $Log: sc_runnable_int.h,v $ 00593 // Revision 1.19 2011/08/24 22:05:51 acg 00594 // Torsten Maehne: initialization changes to remove warnings. 00595 // 00596 // Revision 1.18 2011/08/07 19:08:04 acg 00597 // Andy Goodrich: moved logs to end of file so line number synching works 00598 // better between versions. 00599 // 00600 // Revision 1.17 2011/04/13 02:45:11 acg 00601 // Andy Goodrich: eliminated warning message that occurred if the DEBUG_MSG 00602 // macro was used. 00603 // 00604 // Revision 1.16 2011/04/10 22:18:23 acg 00605 // Andy Goodrich: debugging message clean up. 00606 // 00607 // Revision 1.15 2011/04/08 18:26:07 acg 00608 // Andy Goodrich: added execute_method_next() to handle method dispatch 00609 // for asynchronous notifications that occur outside the evaluation phase. 00610 // 00611 // Revision 1.14 2011/04/01 21:31:10 acg 00612 // Andy Goodrich: turn off diagnostic messages by default. 00613 // 00614 // Revision 1.13 2011/04/01 21:30:02 acg 00615 // Andy Goodrich: inserted conditional displays for queue manipulations. 00616 // 00617 // Revision 1.12 2011/03/30 00:01:34 acg 00618 // Philip A. Hartmann: change break to return in remove_method() to short 00619 // circuit the search the way remove_thread() works. 00620 // 00621 // Revision 1.11 2011/03/28 13:02:52 acg 00622 // Andy Goodrich: Changes for disable() interactions. 00623 // 00624 // Revision 1.10 2011/03/06 15:58:17 acg 00625 // Andy Goodrich: formatting changes. 00626 // 00627 // Revision 1.9 2011/02/18 20:27:14 acg 00628 // Andy Goodrich: Updated Copyrights. 00629 // 00630 // Revision 1.8 2011/02/13 21:47:38 acg 00631 // Andy Goodrich: update copyright notice. 00632 // 00633 // Revision 1.7 2011/02/02 06:37:03 acg 00634 // Andy Goodrich: removed toggle() method since it is no longer used. 00635 // 00636 // Revision 1.6 2011/02/01 21:09:13 acg 00637 // Andy Goodrich: addition of toggle_methods() and toggle_threads() calls. 00638 // 00639 // Revision 1.5 2011/01/25 20:50:37 acg 00640 // Andy Goodrich: changes for IEEE 1666 2011. 00641 // 00642 // Revision 1.4 2010/07/22 20:02:33 acg 00643 // Andy Goodrich: bug fixes. 00644 // 00645 // Revision 1.3 2009/02/28 00:26:58 acg 00646 // Andy Goodrich: changed boost name space to sc_boost to allow use with 00647 // full boost library applications. 00648 // 00649 // Revision 1.2 2008/05/22 17:06:26 acg 00650 // Andy Goodrich: updated copyright notice to include 2008. 00651 // 00652 // Revision 1.1.1.1 2006/12/15 20:20:05 acg 00653 // SystemC 2.3 00654 // 00655 // Revision 1.4 2006/04/20 17:08:17 acg 00656 // Andy Goodrich: 3.0 style process changes. 00657 // 00658 // Revision 1.3 2006/01/13 18:44:30 acg 00659 // Added $Log to record CVS changes into the source. 00660 // 00661 00662 #endif // SC_RUNNABLE_INT_H 00663 00664 // Taf!