Changeset 60 for sources/src/gen_code.cc

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.

File:

• sources/src/gen_code.cc (modified) (8 diffs)

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) {