Index: sources/configure.ac =================================================================== --- sources/configure.ac (revision 61) +++ sources/configure.ac (revision 62) @@ -38,10 +38,14 @@ MY_ARG_ENABLE(debug, [Enable debugging], [no]) +MY_ARG_ENABLE(use_omp, [Compile with OpenMP activated], [no]) MY_ARG_ENABLE(default_runtime_compilation, [Compile scheduling code], [no]) # Also set -DNDEBUG when not debugging, this disables assert()s -AS_IF([test "x$do_debug" = "xyes"], [CXXFLAGS="-g" ], +AS_IF([test "x$do_debug" = "xyes"], [CXXFLAGS="-g"], [test "x$do_debug" != "xyes"], [CXXFLAGS="-O2 -DNDEBUG"]) + +AS_IF([test "x$do_use_omp" = "xyes"], [CXXFLAGS+=" -DUSE_OPENMP"], + [test "x$do_use_omp" != "xyes"], [CXXFLAGS+=""]) case $target_os in @@ -90,7 +94,9 @@ # OpenMP -AC_OPENMP([C]) -AC_CHECK_LIB(dl, dlopen, , ) -AC_CHECK_LIB(gomp, omp_get_thread_num, , ) +AS_IF([test "x$do_use_omp" = "xyes"], + [AC_OPENMP([C]) + AC_CHECK_LIB(dl, dlopen, , ) + AC_CHECK_LIB(gomp, omp_get_thread_num, , )] +) AM_CONDITIONAL(BUILD_DOCS, Index: sources/src/casc.h =================================================================== --- sources/src/casc.h (revision 61) +++ sources/src/casc.h (revision 62) @@ -21,9 +21,10 @@ #include -//#include EXTERN char unstable; -EXTERN int32 * pending_write_vector_nb; +EXTERN int32_t * pending_write_vector_nb; +#ifdef USE_OPENMP #pragma omp threadprivate (pending_write_vector_nb) +#endif namespace sc_core { Index: sources/src/dump_used_options.cc =================================================================== --- sources/src/dump_used_options.cc (revision 61) +++ sources/src/dump_used_options.cc (revision 62) @@ -89,6 +89,6 @@ "INIT_SIGNALS_TO_ZERO, " #endif -#ifdef _OPENMP - "_OPENMP, " +#ifdef USE_OPENMP + "USE_OPENMP, " #endif "..."; Index: sources/src/gen_code.cc =================================================================== --- sources/src/gen_code.cc (revision 61) +++ sources/src/gen_code.cc (revision 62) @@ -241,10 +241,7 @@ -char * gen_scheduling_code_for_dynamic_link(method_process_list_t & - transition_func_list, - method_process_list_t & - moore_func_list, - strong_component_list_t * - strongcomponents) { +char * gen_scheduling_code_for_dynamic_link(method_process_list_t & transition_func_list, + method_process_list_t & moore_func_list, + strong_component_list_t * strongcomponents) { if (dump_stage) { cerr << "Generating C code for scheduling...\n"; @@ -305,10 +302,7 @@ -char * gen_scheduling_code_for_dynamic_link(method_process_list_t & - transition_func_list, - method_process_list_t & - moore_func_list, - ProcessDependencyList & - mealy_func_list) { +char * gen_scheduling_code_for_dynamic_link(method_process_list_t & transition_func_list, + method_process_list_t & moore_func_list, + ProcessDependencyList & mealy_func_list) { if (dump_stage) { cerr << "Generating C code for scheduling...\n"; @@ -509,10 +503,7 @@ -void gen_scheduling_code_for_static_func(method_process_list_t & - transition_func_list, - method_process_list_t & - moore_func_list, - ProcessDependencyList & - mealy_func_list) { +void gen_scheduling_code_for_static_func(method_process_list_t & transition_func_list, + method_process_list_t & moore_func_list, + ProcessDependencyList & mealy_func_list) { if (dump_stage) { cerr << "Generating scheduling...\n"; @@ -546,5 +537,4 @@ int n = fc.func_number; int i; -#pragma omp parallel for for (i = 0; i < n; ++i) { #if 0 @@ -578,11 +568,13 @@ unsigned int nb_func[2]; static method_process_t **func_list[2]; -#pragma omp threadprivate (nb_func, func_list) static strong_component_list_t quasistatic_list; unsigned long long busy_wait_f0, busy_wait_f1, busy_wait_up, busy_wait_ml; unsigned long long last_wait_f0, last_wait_f1, last_wait_up, last_wait_ml; +#ifdef USE_OPENMP +#pragma omp threadprivate (nb_func, func_list) #pragma omp threadprivate (busy_wait_f0, busy_wait_f1, busy_wait_up,busy_wait_ml) #pragma omp threadprivate (last_wait_f0, last_wait_f1, last_wait_up,last_wait_ml) +#endif static void Call(const method_process_t & m) { @@ -621,6 +613,8 @@ unsigned int expected_globaltime = 0; volatile unsigned int globaltime __attribute__ ((aligned (128))) = 0; +#ifdef USE_OPENMP +#pragma omp threadprivate (expected_globaltime) #pragma omp shared (globaltime) -#pragma omp threadprivate (expected_globaltime) +#endif unsigned int num_omp_threads; @@ -644,7 +638,8 @@ __asm volatile("lfence"); } - #else -#pragma omp barrier + #ifdef USE_OPENMP + #pragma omp barrier + #endif #endif @@ -664,8 +659,12 @@ } #else -#pragma omp barrier + #ifdef USE_OPENMP + #pragma omp barrier + #endif #endif if (!quasistatic_list.empty()) { +#ifdef USE_OPENMP #pragma omp master +#endif { quasistatic_mealy_generation(); @@ -682,17 +681,15 @@ } #else -#pragma omp barrier -#endif - } - -} - - -void gen_scheduling_code_for_quasistatic_func(method_process_list_t & - transition_func_list, - method_process_list_t & - moore_func_list, - strong_component_list_t * - mealy_func_list) { + #ifdef USE_OPENMP + #pragma omp barrier + #endif +#endif + } +} + + +void gen_scheduling_code_for_quasistatic_func(method_process_list_t & transition_func_list, + method_process_list_t & moore_func_list, + strong_component_list_t * mealy_func_list) { if (dump_stage) { cerr << "Generating quasi static scheduling...\n"; Index: sources/src/gen_code.h =================================================================== --- sources/src/gen_code.h (revision 61) +++ sources/src/gen_code.h (revision 62) @@ -106,25 +106,30 @@ extern unsigned long long last_wait_f0, last_wait_f1, last_wait_up, last_wait_ml; extern unsigned int nb_func[2]; + extern unsigned int expected_globaltime; + extern volatile unsigned int globaltime; +#ifdef USE_OPENMP #pragma omp threadprivate (busy_wait_f0, busy_wait_f1, busy_wait_up, busy_wait_ml, nb_func) #pragma omp threadprivate (last_wait_f0, last_wait_f1, last_wait_up, last_wait_ml) - extern unsigned int expected_globaltime; - extern volatile unsigned int globaltime; +#pragma omp threadprivate (expected_globaltime) #pragma omp shared (globaltime) -#pragma omp threadprivate (expected_globaltime) - +#endif extern unsigned int num_omp_threads; +#ifdef USE_OPENMP #pragma omp parallel +#endif { -// int cyclecount = number_of_cycles; + int cyclecount = number_of_cycles; busy_wait_f0 = busy_wait_f1 = busy_wait_up = busy_wait_ml = total_assig = 0; last_wait_f0 = last_wait_f1 = last_wait_up = last_wait_ml = 0; expected_globaltime = 0; -#pragma omp master +#ifdef USE_OPENMP +#pragma omp master +#endif { globaltime = 0; -#ifdef _OPENMP +#ifdef USE_OPENMP num_omp_threads = omp_get_num_threads(); #else @@ -133,22 +138,30 @@ } +#ifdef USE_OPENMP #pragma omp barrier - // while (!((have_to_stop) | (cyclecount == 0))) { - while (!((have_to_stop) || (number_of_cycles == 0))) { -#pragma omp master +#endif + while (!(have_to_stop || cyclecount == 0)) { + //while (!(have_to_stop || number_of_cycles == 0)) { +#ifdef USE_OPENMP +#pragma omp master +#endif { trace_all(false); } internal_sc_cycle2(); -#pragma omp master +#ifdef USE_OPENMP +#pragma omp master +#endif { trace_all(true); } - // cyclecount = (number_of_cycles < 0) ? number_of_cycles : cyclecount - 1; - number_of_cycles = (number_of_cycles < 0) ? number_of_cycles : number_of_cycles - 1; - } + cyclecount = (number_of_cycles < 0) ? number_of_cycles : cyclecount - 1; + // number_of_cycles = (number_of_cycles < 0) ? number_of_cycles : number_of_cycles - 1; + } +#ifdef USE_OPENMP #pragma omp barrier +#endif #if 0 -#ifdef _OPENMP +#ifdef USE_OPENMP #pragma omp critical { @@ -191,5 +204,7 @@ if (is_posted_write()) { // update posted value to external signals +#ifdef USE_OPENMP #pragma omp parallel +#endif update(); func_combinationals(); @@ -200,5 +215,7 @@ // don't need to do func_combinationals since 'unstable' flag is now false if (is_posted_write()) { +#ifdef USE_OPENMP #pragma omp parallel +#endif update(); func_combinationals(); Index: sources/src/global_functions.cc =================================================================== --- sources/src/global_functions.cc (revision 61) +++ sources/src/global_functions.cc (revision 62) @@ -248,10 +248,10 @@ assert(pending_write_vector_capacity != 0); -#ifdef _OPENMP -#define LINE_SIZE 128L +#ifdef USE_OPENMP + #define LINE_SIZE 128L int malloc_size = (sizeof (pending_write_t) * (pending_write_vector_capacity + 1) + (LINE_SIZE - 1)) & ~(LINE_SIZE - 1); assert((sizeof(pending_write_t) * (pending_write_vector_capacity + 1)) <= malloc_size && "bad allocation size"); -#pragma omp parallel + #pragma omp parallel { posix_memalign((void **) &pending_write_vector, LINE_SIZE, malloc_size); @@ -263,4 +263,6 @@ #else pending_write_vector = (pending_write_vector_t) malloc(sizeof(pending_write_t) * pending_write_vector_capacity); + pending_write_vector_nb = (int32_t *) malloc(sizeof(int32_t)); + *pending_write_vector_nb = 0; #endif Index: sources/src/sc_main.cc =================================================================== --- sources/src/sc_main.cc (revision 61) +++ sources/src/sc_main.cc (revision 62) @@ -90,5 +90,5 @@ bool use_port_dependency = false; -#ifdef _OPENMP +#ifdef USE_OPENMP bool use_openmp = true; #else Index: sources/src/sc_module.cc =================================================================== --- sources/src/sc_module.cc (revision 61) +++ sources/src/sc_module.cc (revision 62) @@ -131,5 +131,5 @@ module = &mod; dont_initialize = false; -#ifdef _OPENMP +#ifdef USE_OPENMP omp_threadnum = omp_get_thread_num(); #endif Index: sources/src/sc_object.cc =================================================================== --- sources/src/sc_object.cc (revision 61) +++ sources/src/sc_object.cc (revision 62) @@ -106,5 +106,5 @@ const char * sc_gen_unique_name(const char * basename_) { string s; - gen_name(basename_,s); + gen_name(basename_, s); const char * ret = strdup(s.c_str()); sc_core::allocated_names.push_back(ret); Index: sources/src/sc_port.cc =================================================================== --- sources/src/sc_port.cc (revision 61) +++ sources/src/sc_port.cc (revision 62) @@ -53,7 +53,9 @@ extern char unstable; char unstable = 0; // not in sc_core namespace because dynamic link support C linkage only - int32 * pending_write_vector_nb = 0; + int32_t * pending_write_vector_nb = 0; unsigned long long int total_assig = 0; +#ifdef USE_OPENMP #pragma omp threadprivate (pending_write_vector_nb, total_assig) +#endif } @@ -65,7 +67,9 @@ const char * const sc_signal_base::kind_string = "sc_signal"; -unsigned int pending_write_vector_capacity = 512; +unsigned int pending_write_vector_capacity; pending_write_vector_t pending_write_vector = NULL; +#ifdef USE_OPENMP #pragma omp threadprivate (pending_write_vector) +#endif extern equi_list_t equi_list; @@ -215,41 +219,41 @@ void update() { #if defined(DUMP_STAGE) - cerr << "Updating... "; -#endif - // stl vectors are too slow - // memcopy is not better - // signal table sorting doesn't give any better performance + cerr << "Updating... "; +#endif + // stl vectors are too slow + // memcopy is not better + // signal table sorting doesn't give any better performance #if defined(DUMP_STAGE) - cerr << "(" << *pending_write_vector_nb - << " internal pending writings) "; -#endif - unsigned int i; - for (i = 0; i < *pending_write_vector_nb; ++i) { + cerr << "(" << *pending_write_vector_nb + << " internal pending writings) "; +#endif + unsigned int i; + for (i = 0; i < *pending_write_vector_nb; ++i) { #define iter (sc_core::pending_write_vector[i]) #ifdef CONFIG_DEBUG - if (iter.pointer == NULL) { - cerr << "Internal error : trying to apply a posted write from an unassigned signal/port\n"; - exit (8); - } + if (iter.pointer == NULL) { + cerr << "Internal error : trying to apply a posted write from an unassigned signal/port\n"; + exit (8); + } #endif #ifdef DUMP_SIGNAL_STATS - if (*(iter.pointer) == iter.value) { - unnecessary++; - } - counter[iter.pointer]++; -#endif - *(iter.pointer) = iter.value; + if (*(iter.pointer) == iter.value) { + unnecessary++; + } + counter[iter.pointer]++; +#endif + *(iter.pointer) = iter.value; #undef iter - } + } #ifdef DUMP_SIGNAL_STATS - total_assig += *pending_write_vector_nb; -#endif - total_assig += *pending_write_vector_nb; - *pending_write_vector_nb = 0; + total_assig += *pending_write_vector_nb; +#endif + total_assig += *pending_write_vector_nb; + *pending_write_vector_nb = 0; #if defined(DUMP_STAGE) - cerr << "done.\n"; -#endif - } + cerr << "done.\n"; +#endif + } } // end of extern "C" Index: sources/src/sc_port_ext.h =================================================================== --- sources/src/sc_port_ext.h (revision 61) +++ sources/src/sc_port_ext.h (revision 62) @@ -295,12 +295,13 @@ std::cerr << "write " << value_ << " on in/out port (writing into a signal) '" << name() << "'\n"; #endif - T *p = (T*)get_pointer(); - if (*p != value_) { - *p = value_; + T * p = (T *) get_pointer(); + if (*p != value_) { + *p = value_; #ifndef USE_PORT_DEPENDENCY - if (unstable == 0) - unstable = 1; -#endif - } + if (unstable == 0) { + unstable = 1; + } +#endif + } } Index: sources/src/sc_signal.h =================================================================== --- sources/src/sc_signal.h (revision 61) +++ sources/src/sc_signal.h (revision 62) @@ -70,9 +70,12 @@ extern "C" int32_t * pending_write_vector_nb; extern "C" unsigned long long int total_assig; +#ifdef USE_OPENMP #pragma omp threadprivate(pending_write_vector_nb, total_assig) +#endif extern unsigned int pending_write_vector_capacity; - extern pending_write_vector_t pending_write_vector; +#ifdef USE_OPENMP #pragma omp threadprivate(pending_write_vector) +#endif template < typename T > @@ -282,4 +285,5 @@ #else memset(&val, 0, sizeof(val)); + memset(&new_val, 0, sizeof(new_val)); #endif } Index: sources/src/sc_time.cc =================================================================== --- sources/src/sc_time.cc (revision 61) +++ sources/src/sc_time.cc (revision 62) @@ -55,5 +55,7 @@ uint64 nb_cycles = 0; +#ifdef USE_OPENMP #pragma omp threadprivate(nb_cycles) +#endif const sc_time SC_ZERO_TIME(0, SC_NS); Index: sources/src/sc_time.h =================================================================== --- sources/src/sc_time.h (revision 61) +++ sources/src/sc_time.h (revision 62) @@ -15,5 +15,4 @@ #include -//#include #include "sc_nbdefs.h" @@ -43,5 +42,7 @@ extern uint64 nb_cycles; +#ifdef USE_OPENMP #pragma omp threadprivate(nb_cycles) +#endif inline double sc_simulation_time() { Index: sources/src/sc_ver.cc =================================================================== --- sources/src/sc_ver.cc (revision 61) +++ sources/src/sc_ver.cc (revision 62) @@ -78,4 +78,7 @@ "\n" " Last change : " __DATE__ "\n" +#ifdef USE_OPENMP + " Compiled with OpenMP enabled\n" +#endif "\n"; Index: sources/src/schedulers.cc =================================================================== --- sources/src/schedulers.cc (revision 61) +++ sources/src/schedulers.cc (revision 62) @@ -64,5 +64,7 @@ method_process_list_t * transition_func_list; method_process_list_t * moore_func_list; +#ifdef USE_OPENMP #pragma omp threadprivate(transition_func_list, moore_func_list) +#endif method_process_list_t combinational_func_list; /* ***************************** */ @@ -120,11 +122,13 @@ void sort_functions() { method_process_list_t::const_iterator m; +#ifdef USE_OPENMP #pragma omp parallel #pragma omp critical +#endif { transition_func_list = new method_process_list_t; moore_func_list = new method_process_list_t; for (m = method_process_list.begin(); m != method_process_list.end(); ++m) { -#ifdef _OPENMP +#ifdef USE_OPENMP if ((*m)->omp_threadnum == omp_get_thread_num()) #endif @@ -189,4 +193,5 @@ exit (24092004); } + delete s; return sig_graph; } @@ -229,14 +234,18 @@ sort_functions(); +#ifdef USE_OPENMP #pragma omp parallel #pragma omp critical +#endif { if (dump_funclist_info) { -#ifdef _OPENMP +#ifdef USE_OPENMP cerr << "Thread " << omp_get_thread_num() << "\n"; #endif cerr << " Transition functions : " << *transition_func_list << "\n"; cerr << " Moore generation functions : " << *moore_func_list << "\n"; +#ifdef USE_OPENMP #pragma omp master +#endif { if (!combinational_func_list.empty()) { @@ -247,64 +256,76 @@ /* Schedule */ - switch (scheduling_method) { - case BUCHMANN_SCHEDULING : - { - // Generate the scheduled code, compile and link. - // Buchmann's thesis explains this scheduling method. - // Uses port dependancies like Dr. Mouchard. - ProcessDependencyList * process_list = BuchmannScheduling(); - if (dynamic_link_of_scheduling_code) { - base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, *process_list); - } - else { - gen_scheduling_code_for_static_func(*transition_func_list, *moore_func_list, *process_list); - } - break; + switch (scheduling_method) { + case BUCHMANN_SCHEDULING : + { + // Generate the scheduled code, compile and link. + // Buchmann's thesis explains this scheduling method. + // Uses port dependancies like Dr. Mouchard. + ProcessDependencyList * process_list = BuchmannScheduling(); + if (dynamic_link_of_scheduling_code) { + base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, *process_list); + } + else { + gen_scheduling_code_for_static_func(*transition_func_list, *moore_func_list, *process_list); + } + break; + } + + case MOUCHARD_SCHEDULING : + { + // Generate the scheduled code, compile and link. + // Mouchard's thesis explains this scheduling method. + // Uses port dependancies like Dr. Mouchard. + // CAUTION : unlike FastSysC, this scheduling is totally static + // and does not use an event-driven scheduler. + ProcessDependencyList * process_list = MouchardScheduling(); + if (dynamic_link_of_scheduling_code) { + base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, *process_list); + } + else { + gen_scheduling_code_for_static_func (*transition_func_list, *moore_func_list, *process_list); + } + break; + } + + case CASS_SCHEDULING : + { + // Generate the scheduled code, compile and link + // Hommais's thesis explains this scheduling method (like CASS strategy) + // Doesn't use port dependancies + strong_component_list_t * strong_list = NULL; +#ifdef USE_OPENMP +#pragma omp master +#endif + { + Graph * g = makegraph (&combinational_func_list); + if (dump_all_graph && g) { + graph2dot("module_graph", *g); + } + strong_list = strong_component(g); + } + if (dynamic_link_of_scheduling_code) { + base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, strong_list); + } + else { + gen_scheduling_code_for_quasistatic_func (*transition_func_list, *moore_func_list, strong_list); + } + // free the void_lists in strong_list + //for ( strong_component_list_t::iterator i = strong_list->begin(); i < strong_list->end(); i++) { + // delete *i; + //} +#ifdef USE_OPENMP +#pragma omp master +#endif + { + delete strong_list; + } + break; + } + default : + cerr << "Error : Unable to schedule SystemC process." + "Please select a scheduling method.\n"; + exit (35); } - - case MOUCHARD_SCHEDULING : - { - // Generate the scheduled code, compile and link. - // Mouchard's thesis explains this scheduling method. - // Uses port dependancies like Dr. Mouchard. - // CAUTION : unlike FastSysC, this scheduling is totally static - // and does not use an event-driven scheduler. - ProcessDependencyList * process_list = MouchardScheduling(); - if (dynamic_link_of_scheduling_code) { - base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, *process_list); - } - else { - gen_scheduling_code_for_static_func (*transition_func_list, *moore_func_list, *process_list); - } - break; - } - - case CASS_SCHEDULING : - { - // Generate the scheduled code, compile and link - // Hommais's thesis explains this scheduling method (like CASS strategy) - // Doesn't use port dependancies - strong_component_list_t * strong_list = NULL; -#pragma omp master - { - Graph * g = makegraph (&combinational_func_list); - if (dump_all_graph && g) { - graph2dot("module_graph", *g); - } - strong_list = strong_component(g); - } - if (dynamic_link_of_scheduling_code) { - base_name = gen_scheduling_code_for_dynamic_link(*transition_func_list, *moore_func_list, strong_list); - } - else { - gen_scheduling_code_for_quasistatic_func (*transition_func_list, *moore_func_list, strong_list); - } - break; - } - default : - cerr << "Error : Unable to schedule SystemC process." - "Please select a scheduling method.\n"; - exit (35); - } } return base_name;