Changeset 60 for sources/src

Timestamp:

Feb 14, 2017, 11:30:19 AM (8 years ago)

Author:

meunier

Message:

• Intégration des modifications de Clément, qui a intégré la version parallélisée de systemcass faite par Manuel.

Location:

sources/src

Files:

• casc.h (modified) (1 diff)
• entity.cc (modified) (2 diffs)
• gen_code.cc (modified) (8 diffs)
• gen_code.h (modified) (6 diffs)
• global_functions.cc (modified) (3 diffs)
• sc_main.cc (modified) (2 diffs)
• sc_module.cc (modified) (2 diffs)
• sc_module.h (modified) (1 diff)
• sc_port.cc (modified) (4 diffs)
• sc_port_ext.h (modified) (1 diff)
• sc_signal.h (modified) (10 diffs)
• sc_time.cc (modified) (1 diff)
• sc_time.h (modified) (1 diff)
• schedulers.cc (modified) (10 diffs)

sources/src/casc.h

@@ -24 +24 @@
 
 EXTERN char unstable;
-EXTERN int32 pending_write_vector_nb;
+EXTERN int32 * pending_write_vector_nb;
+#pragma omp threadprivate (pending_write_vector_nb)
 
 namespace sc_core {

sources/src/entity.cc

@@ -188 +188 @@
     }
     cerr << "Internal error : get_equi(" << pointer << ")\n";
+    abort();
     exit(11);
 }
@@ -412 +413 @@
             }
         }
+#if 0
+        sc_interface *reg = get_signal (*i);
+        sc_interface *out = get_out_port (*i);
+        if (reg) {
+            std::cerr << "binding " << *i << " to reg "
+                << reg << std::endl;
+            bind_equi_to_table (*i, reg->get_pointer ());
+        } else if (out) {
+            std::cerr << "binding " << *i << " to out "
+                << out << std::endl;
+            bind_equi_to_table (*i, out->get_pointer ());
+        } else {
+            reg = get_localvar (*i);
+            if (reg) {
+                std::cerr << "binding " << *i << " to localvar "
+                    << reg << std::endl;
+                bind_equi_to_table (*i, reg->get_pointer ());
+            } else {
+                std::cerr << "binding " << *i << " to index "
+                    << index << std::endl;
+                bind_equi_to_table (*i, &(equi_table[index]));
+                index += (i->begin()->data_size_in_bytes() - 1) / sizeof(tab_t) + 1;
+            }
+        }
+#endif
     }
 }

sources/src/gen_code.cc

@@ -49 +49 @@
 #include <iostream>
 #include <fstream>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
 
 #include "internal.h"
@@ -58 +61 @@
 #ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
-
-#ifdef _OPENMP
-#include <omp.h>
 #endif
 
@@ -246 +245 @@
         method_process_list_t &
         moore_func_list,
-        strong_component_list_t &
+        strong_component_list_t *
         strongcomponents) {
     if (dump_stage) {
@@ -277 +276 @@
     gen_transition(o, transition_func_list);
     gen_moore(o, moore_func_list);
-    gen_mealy(o, strongcomponents);
+    if (strongcomponents != NULL) {
+        gen_mealy      (o, *strongcomponents);
+    }
 
     o << " \n}\n";
@@ -575 +576 @@
  */
 
-static method_process_list_t func_list[2];
+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;
+#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)
 
 static void Call(const method_process_t & m) {
@@ -611 +619 @@
 }
 
+unsigned int expected_globaltime = 0;
+volatile unsigned int globaltime __attribute__ ((aligned (128))) = 0;
+#pragma omp shared (globaltime)
+#pragma omp threadprivate (expected_globaltime)
+
+unsigned int num_omp_threads;
 
 void quasistatic_simulate_1_cycle(void) {
-    method_process_list_t::iterator mm;
-    for (mm = func_list[0].begin(); mm != func_list[0].end(); ++mm) {
-        method_process_t & m = **mm;
-        Call(m);
-    }
+    int i;
+
+    for (i = 0; i < nb_func[0]; ++i) {
+        Call(*(func_list[0][i]));
+    }
+#define USE_BUSY_WAIT 1
     update();
-    for (mm = func_list[1].begin(); mm != func_list[1].end(); ++mm) {
-        method_process_t & m = **mm;
-        Call(m);
-    }
-    quasistatic_mealy_generation();
+#if USE_BUSY_WAIT
+    expected_globaltime += num_omp_threads;
+    if (__sync_add_and_fetch(&globaltime, 1) == expected_globaltime) {
+        last_wait_up++;
+    }
+    __asm volatile("mfence");
+    while (globaltime < expected_globaltime) {
+        busy_wait_up++;
+        __asm volatile("lfence");
+    }
+
+#else
+#pragma omp barrier
+#endif
+
+    for (i = 0; i < nb_func[1]; ++i) {
+        Call(*(func_list[1][i]));
+    }
+
+#if USE_BUSY_WAIT
+    expected_globaltime += num_omp_threads;
+    if (__sync_add_and_fetch(&globaltime, 1) == expected_globaltime) {
+        last_wait_f1++;
+    }
+    __asm volatile("mfence");
+    while (globaltime < expected_globaltime) {
+        busy_wait_f1++;
+        __asm volatile("lfence");
+    }
+#else
+#pragma omp barrier
+#endif
+    if (!quasistatic_list.empty()) {
+#pragma omp master
+        {
+            quasistatic_mealy_generation();
+        }
+#if USE_BUSY_WAIT
+        expected_globaltime += num_omp_threads;
+        if (__sync_add_and_fetch(&globaltime, 1) == expected_globaltime) {
+            last_wait_ml++;
+        }
+        __asm volatile("mfence");
+        while (globaltime < expected_globaltime) {
+            busy_wait_ml++;
+            __asm volatile("lfence");
+        }
+#else
+#pragma omp barrier
+#endif
+    }
+
 }
 
@@ -631 +693 @@
         method_process_list_t &
         moore_func_list,
-        strong_component_list_t &
+        strong_component_list_t *
         mealy_func_list) {
     if (dump_stage) {
@@ -637 +699 @@
     }
 
-    func_list[0] = transition_func_list;
-    func_list[1] = moore_func_list;
-    quasistatic_list = mealy_func_list;
+    nb_func[0] = transition_func_list.size();
+    nb_func[1] = moore_func_list.size();
+
+    func_list[0] = (method_process_t**) malloc(sizeof (method_process_t*) * nb_func[0]);
+    func_list[1] = (method_process_t**) malloc(sizeof (method_process_t*) * nb_func[1]);
+
+    unsigned int i;
+    for (i = 0; i < nb_func[0]; ++i) {
+        func_list[0][i] = (transition_func_list[i]);
+    }
+
+    for (i = 0; i < nb_func[1]; ++i) {
+        func_list[1][i] = (moore_func_list[i]);
+    }
+
+    if (mealy_func_list != NULL) {
+        quasistatic_list = *mealy_func_list;
+    }
 
     if (dump_stage) {

sources/src/gen_code.h

@@ -21 +21 @@
 #include "process_dependency.h"
 
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
 //-------------------------------------------------------------------
 #ifdef __GNUC__
@@ -40 +44 @@
       method_process_list_t   &transition_list,
       method_process_list_t   &moore_list,
-      strong_component_list_t &mealy_list);
+      strong_component_list_t *mealy_list);
 
 extern void  gen_scheduling_code_for_static_func(
@@ -55 +59 @@
       method_process_list_t   &transition_list,
       method_process_list_t   &moore_list,
-      strong_component_list_t &strongcomponents);
+      strong_component_list_t *strongcomponents);
 
 /* function when any dynamic link is impossible */
@@ -81 +85 @@
 inline void internal_sc_cycle2() {
 #ifdef DUMP_STAGE
-    std::cerr << "begin of cycle #" << sc_simulation_time () << "\n";
-#endif
-    func_simulate_1_cycle();  
-    ++nb_cycles;
+#pragma omp master
+    {
+        std::cerr << "begin of cycle #" << sc_simulation_time() << "\n";
+    }
+#endif
+
+        func_simulate_1_cycle();
+
+        ++nb_cycles;
 #ifdef DUMP_STAGE
-    std::cerr << "end of cycle\n";
+#pragma omp master
+    {
+        std::cerr << "end of cycle\n";
+    }
 #endif
 }
 
-
 inline void internal_sc_cycle1(int number_of_cycles) {  
-    //while ((! have_to_stop) && (number_of_cycles != 0)) {
-    while (!((have_to_stop) || (number_of_cycles == 0))) {
-        trace_all(false);
-        internal_sc_cycle2();
-        trace_all(true);
-        number_of_cycles = (number_of_cycles < 0) ? number_of_cycles : number_of_cycles - 1;
+    extern unsigned long long busy_wait_f0, busy_wait_f1, busy_wait_up, busy_wait_ml;
+    extern unsigned long long last_wait_f0, last_wait_f1, last_wait_up, last_wait_ml;
+    extern unsigned int nb_func[2];
+#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 shared (globaltime)
+#pragma omp threadprivate (expected_globaltime)
+
+    extern unsigned int num_omp_threads;
+
+
+#pragma omp parallel 
+    {
+//        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
+        {
+            globaltime = 0;
+#ifdef _OPENMP
+            num_omp_threads = omp_get_num_threads();
+#else
+            num_omp_threads = 1;
+#endif
+        }
+
+#pragma omp barrier
+        // while (!((have_to_stop) | (cyclecount == 0))) {
+        while (!((have_to_stop) || (number_of_cycles == 0))) {
+#pragma omp master
+            {
+                trace_all(false);
+            }
+            internal_sc_cycle2();
+#pragma omp master
+            {
+                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;
+        }
+#pragma omp barrier
+#if 0
+#ifdef _OPENMP
+#pragma omp critical
+        {
+            std::cerr << "Thread " << omp_get_thread_num() << " busy_wait " <<
+                busy_wait_f0 << " " << busy_wait_up << " " <<
+                busy_wait_f1 << " " << busy_wait_ml << std::endl;
+        }
+#pragma omp critical
+        {
+            std::cerr << "Thread " << omp_get_thread_num() << " last_wait " <<
+                last_wait_f0 << " " << last_wait_up << " " <<
+                last_wait_f1 << " " << last_wait_ml << std::endl;
+        }
+#pragma omp critical
+        {
+            std::cerr << "Thread " << omp_get_thread_num() << " nfuncs "
+                << nb_func[0] << " " << nb_func[1] << " total_assig " <<
+                total_assig << std::endl;
+        }
+#endif
+#endif
     }
 }
@@ -117 +190 @@
 
     if (is_posted_write()) {
-        // update posted value to external signals
+        // update posted value to external signals              
+#pragma omp parallel
         update();
         func_combinationals();
@@ -126 +200 @@
     // don't need to do func_combinationals since 'unstable' flag is now false
     if (is_posted_write()) {
+#pragma omp parallel
         update();
         func_combinationals();

sources/src/global_functions.cc

@@ -246 +246 @@
     pending_write_vector_capacity = get_signal_table_size();
 
-    if (pending_write_vector_capacity == 0) {
-        pending_write_vector = NULL;
-    }
-    else {
-        pending_write_vector = (pending_write_vector_t) realloc(pending_write_vector, sizeof(pending_write_t) * pending_write_vector_capacity);
-    }
+    assert(pending_write_vector_capacity != 0);
+
+#ifdef _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
+    {
+        posix_memalign((void **) &pending_write_vector, LINE_SIZE, malloc_size);
+        pending_write_vector_nb = (int32_t *) &pending_write_vector[0];
+        pending_write_vector = &pending_write_vector[1];
+        //printf("malloc 0x%x @%p, idx @0x%x\n", malloc_size, pending_write_vector, pending_write_vector_nb);
+        *pending_write_vector_nb = 0;
+    }
+#else
+    pending_write_vector = (pending_write_vector_t) malloc(sizeof(pending_write_t) * pending_write_vector_capacity);
+#endif
+
 
     // create the clock list
@@ -267 +280 @@
     }
     // Check if any constructor wrote into registers
-    if (pending_write_vector_nb != 0) {
+    if (*pending_write_vector_nb != 0) {
         cerr <<
             "Error : Register/Signal writing is not allowed before sc_initialize.\n"
@@ -285 +298 @@
     }
 
-    pending_write_vector_nb = 0;
+    *pending_write_vector_nb = 0;
 
     check_all_ports();

sources/src/sc_main.cc

@@ -37 +37 @@
 #include <sstream>
 #include <list>
+#include <omp.h>
 #include <set>
 #include <cstring> // strcmp
@@ -393 +394 @@
 
     int ret = sc_main(argc, argv);
-    free(pending_write_vector);
+    //free(pending_write_vector);
     close_systemcass();
 

sources/src/sc_module.cc

@@ -38 +38 @@
 #include <vector>
 #include <set>
+#ifdef _OPENMP
+#include <omp.h>
+#endif
 
 #include "sc_module.h"
@@ -124 +127 @@
 // ----------------------------------------------------------------------------
 method_process_t::method_process_t(const char * nm, SC_ENTRY_FUNC fn, sc_module & mod) {
-  name = nm;
-  func = fn; 
-  module = &mod;
-  dont_initialize = false;
+    name = nm;
+    func = fn; 
+    module = &mod;
+    dont_initialize = false;
+#ifdef _OPENMP
+    omp_threadnum = omp_get_thread_num();
+#endif
 }
 

sources/src/sc_module.h

@@ -70 +70 @@
     sensitivity_list_t sensitivity_list;
     bool dont_initialize;
+    int omp_threadnum;
 
     // constructors

sources/src/sc_port.cc

@@ -53 +53 @@
     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 * pending_write_vector_nb = 0;
+    unsigned long long int total_assig = 0;
+#pragma omp threadprivate (pending_write_vector_nb, total_assig)
 }
 
@@ -65 +67 @@
 unsigned int pending_write_vector_capacity = 512;
 pending_write_vector_t pending_write_vector = NULL;
+#pragma omp threadprivate (pending_write_vector)
 extern equi_list_t equi_list;
 
@@ -218 +221 @@
             // signal table sorting doesn't give any better performance
 #if defined(DUMP_STAGE)
-            cerr << "(" << pending_write_vector_nb 
+            cerr << "(" << *pending_write_vector_nb 
                 << " internal pending writings) ";
 #endif
             unsigned int i;
-            for (i = 0; i < pending_write_vector_nb; ++i) {
+            for (i = 0; i < *pending_write_vector_nb; ++i) {
 #define iter (sc_core::pending_write_vector[i])
 #ifdef CONFIG_DEBUG
@@ -240 +243 @@
             }
 #ifdef DUMP_SIGNAL_STATS
-            total_assig += pending_write_vector_nb;
-#endif
-            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)

sources/src/sc_port_ext.h

@@ -295 +295 @@
     std::cerr << "write " << value_ << " on in/out port (writing into a signal) '" << name() << "'\n";
 #endif
-    //  T& ref = *(T*)(get_pointer());
+  T *p = (T*)get_pointer();
+  if (*p != value_) {
+        *p = value_;
 #ifndef USE_PORT_DEPENDENCY
-    unstable |= (value_) != val; //ref;
-#endif
-    /*ref*/ val = (value_);
+        if (unstable == 0)
+                unstable = 1;
+#endif
+  }
 }
 

sources/src/sc_signal.h

@@ -18 +18 @@
 #include <iostream>
 #include <cstdlib>
+#include <cstring>
 #include <typeinfo> // for typeid
 
@@ -67 +68 @@
 // Pending write to register (simple stack)
 typedef pending_write_t * pending_write_vector_t;
+extern "C" int32_t * pending_write_vector_nb;
+extern "C" unsigned long long int total_assig;
+#pragma omp threadprivate(pending_write_vector_nb, total_assig)
+extern unsigned int pending_write_vector_capacity;
+
 extern pending_write_vector_t pending_write_vector;
-extern "C" unsigned int pending_write_vector_nb;
-extern unsigned int pending_write_vector_capacity;
-
+#pragma omp threadprivate(pending_write_vector)
 
 template < typename T >
@@ -92 +96 @@
     else {
 #if defined(CONFIG_DEBUG)
-        if (pending_write_vector_nb >= pending_write_vector_capacity) {
+        if (*pending_write_vector_nb >= pending_write_vector_capacity) {
             std::cerr << "Error : The array for posted writing on register is too small.\n";
             std::cerr << "Up to 1 writing per register is allowed during a cycle.\n";
@@ -99 +103 @@
         }
 #endif
-        pending_write_vector[pending_write_vector_nb].pointer = pointer_;
-        // pending_write_vector[pending_write_vector_nb++].value = *(reinterpret_cast<const base_type*const>(&value_)); => bug !
-        pending_write_vector[pending_write_vector_nb++].value = value_; // => bug avec blues !
+        pending_write_vector[*pending_write_vector_nb].pointer = pointer_;
+        // pending_write_vector[(*pending_write_vector_nb)++].value = *(reinterpret_cast<const base_type*const>(&value_)); => bug !
+        pending_write_vector[(*pending_write_vector_nb)++].value = value_; // => bug avec blues !
 
         // -> fix to use user-defined struct in sc_signal/sc_in/sc_out/sc_inout
-        // pending_write_vector[pending_write_vector_nb++].value = *((base_type*)&value_); => bug !
+        // pending_write_vector[(*pending_write_vector_nb)++].value = *((base_type*)&value_); => bug !
 #if 0
         std::cerr << "posted write : ptr = " << pointer_ << ", val = " << value_ << "\n";
@@ -119 +123 @@
 
 inline bool is_posted_write() {
-    return pending_write_vector_nb > 0;
+    return *pending_write_vector_nb > 0;
 }
 
@@ -165 +169 @@
 
     T val;
-
+    T new_val;
     typedef T data_type;
     typedef sc_signal < T > this_type;
@@ -216 +220 @@
         sc_signal< T >::write(read() + a.read());
         return *this;
+    }
+
+    inline void * operator new (size_t size, size_t align) {
+        void * p;
+        const size_t nsize = (size + align - 1) & ~(align - 1);
+        if (nsize < size) {
+            std::cerr << "sc_signal new() alignement doesn't work (" <<
+                nsize << " < " << size << ")" << std::endl;
+            abort();
+        }
+
+        if (posix_memalign(&p, align, nsize) == 0) {
+            return p;
+        }
+        else {
+            return NULL;
+        }
+    }
+
+    inline void * operator new (size_t size) {
+        return malloc(size);
+    }
+
+    inline void * operator new (size_t size, void * p) {
+        return p;
     }
 
@@ -247 +276 @@
     set_kind(kind_string);
     sc_interface::init(sizeof(data_type)); 
+#if 0
     val = (T) 0; /* The simulator initializes the signal/register to 0.    */
-    /* However, hardware initialization still has to be done. */
-    /* This kind of initialization is for trace diffing.      */
+                 /* However, hardware initialization still has to be done. */
+                 /* This kind of initialization is for trace diffing.      */
+#else
+    memset(&val, 0, sizeof(val));
+#endif
 }
 
@@ -267 +300 @@
 template < typename T >
 inline void sc_signal< T >::write(const data_type & value_) {
+    if (sc_signal< T >::val == value_ && sc_signal< T >::new_val == value_) {
+        return;
+    }
 #ifdef CONFIG_DEBUG
     if (get_pointer() == NULL) {
@@ -279 +315 @@
     std::cerr << "write (posted) " << value_ << " on sc_signal (writing into register) '" << name() << "'\n";
 #endif
-    
+    sc_signal<T>::new_val = value_;
     post_write(/*(tab_t*)&val*/ get_pointer(), value_);
 }

sources/src/sc_time.cc

@@ -55 +55 @@
 
 uint64 nb_cycles = 0;
+#pragma omp threadprivate(nb_cycles)
 
 const sc_time SC_ZERO_TIME(0, SC_NS);

sources/src/sc_time.h

@@ -43 +43 @@
 
 extern uint64 nb_cycles;
+#pragma omp threadprivate(nb_cycles)
 
 inline double sc_simulation_time() {

sources/src/schedulers.cc

@@ -49 +49 @@
 #include "graph_signals.h" // makegraph
 
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -57 +61 @@
 namespace sc_core {
 
+// sort_functions splits and sorts instances_list into three functions lists : 
+method_process_list_t * transition_func_list;
+method_process_list_t * moore_func_list;
+#pragma omp threadprivate(transition_func_list, moore_func_list)
+method_process_list_t combinational_func_list;
 /* ***************************** */
 /* Dumping functions (for debug) */
@@ -74 +83 @@
 /****************/
 
-// sort_functions splits and sorts instances_list into three functions lists : 
-method_process_list_t transition_func_list;
-method_process_list_t moore_func_list;
-method_process_list_t combinational_func_list;
 
 
@@ -115 +120 @@
 void sort_functions() {
     method_process_list_t::const_iterator m;
+#pragma omp parallel
+#pragma omp critical
+    {
+        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
+            if ((*m)->omp_threadnum == omp_get_thread_num())
+#endif
+            {
+                if ((*m)->is_transition()) {
+                    transition_func_list->push_back(*m);
+                }
+                else if ((*m)->is_genmoore()) {
+                    moore_func_list->push_back(*m);
+                }
+            }
+        }
+        // Sort transition functions by method pointer (1) and by module pointer (2)
+        std::sort(transition_func_list->begin(), transition_func_list->end(), sort_by_fct_ptr);
+        // Sort generation functions by method pointer (1) and by module pointer (2)
+        std::sort(moore_func_list->begin(), moore_func_list->end(), sort_by_fct_ptr);
+    }
+
     for (m = method_process_list.begin(); m != method_process_list.end(); ++m) {
         if ((*m)->is_combinational()) {
             combinational_func_list.push_back(*m);
         }
-        else if ((*m)->is_transition ()) {
-            transition_func_list.push_back(*m);
-        }
-        else if ((*m)->is_genmoore ()) {
-            moore_func_list.push_back(*m);
-        }
-    }
-    // Sort transition functions by method pointer (1) and by module pointer (2)
-    std::sort (transition_func_list.begin(), transition_func_list.end(), sort_by_fct_ptr);
-    // Sort generation functions by method pointer (1) and by module pointer (2)
-    std::sort (moore_func_list.begin(), moore_func_list.end(), sort_by_fct_ptr);
+    }
 }
 
@@ -203 +222 @@
 
 string get_scheduling(int scheduling_method) {
+    string base_name;
     /* marque les fonctions comme fonction de mealy ou non */
     if (dump_funclist_info) {
@@ -209 +229 @@
 
     sort_functions();
-    if (dump_funclist_info) {
-        cerr << "Transition functions : " << transition_func_list << "\n";
-        cerr << "Moore generation functions : " << moore_func_list << "\n";
-        cerr << "Mealy generation functions : " << combinational_func_list << "\n";
-    }
+#pragma omp parallel
+#pragma omp critical
+    {
+        if (dump_funclist_info) {
+#ifdef _OPENMP
+            cerr << "Thread " << omp_get_thread_num() << "\n";
+#endif
+            cerr << "  Transition functions : " << *transition_func_list << "\n";
+            cerr << "  Moore generation functions : " << *moore_func_list << "\n";
+#pragma omp master
+            {
+                if (!combinational_func_list.empty()) {
+                    cerr << "Mealy generation functions : " << combinational_func_list << "\n";
+                }
+            }
+        }
 
     /* Schedule */
-    string base_name;
     switch (scheduling_method) {
         case BUCHMANN_SCHEDULING :
@@ -225 +255 @@
             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);
+                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);
+                gen_scheduling_code_for_static_func(*transition_func_list, *moore_func_list, *process_list);
             }
             break;
@@ -242 +272 @@
             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);
+                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);
+                gen_scheduling_code_for_static_func (*transition_func_list, *moore_func_list, *process_list);
             }
             break;
@@ -255 +285 @@
             // Hommais's thesis explains this scheduling method (like CASS strategy)
             // Doesn't use port dependancies
-            Graph * g = makegraph (&combinational_func_list);
-            if (dump_all_graph && g) {
-                graph2dot("module_graph", *g);
-            }
-            strong_component_list_t * strong_list = strong_component(g);
+            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);
+                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);
+                gen_scheduling_code_for_quasistatic_func (*transition_func_list, *moore_func_list, strong_list);
             }
             break;
@@ -272 +306 @@
                     "Please select a scheduling method.\n";
             exit (35);
+    }
     }
     return base_name;