diff --git a/__init__.py b/__init__.py
index 2e73112d01f713578d332ab886259d23b27ff974..83345fbc33b8c5ebffbdd4f9301558b5462b8fd7 100644
--- a/__init__.py
+++ b/__init__.py
@@ -20,9 +20,16 @@ def all_subpackages(pkg_prefix, verbose, what_to_run, parent, prefix=""):
if ".testing" not in modname and not ispkg:
continue
-
+
mod = importlib.import_module(modname)
-
+ try:
+ if os.path.islink(mod.__path__[0] if ispkg else mod.__file__):
+ log.warn("Skipping symbolic link to {}.".format(modname))
+ # might be better to check if it is in the path first ...
+ continue
+ except Exception as e:
+ import pdb;pdb.set_trace()
+ pass
for what in what_to_run:
if not hasattr(mod, what): continue
@@ -108,8 +115,10 @@ def run_module(verbose, modname, mod, do_that):
print(title)
print("#" * len(title))
- try: run_once()
- except FinishException: pass
+ try:
+ run_once()
+ except FinishException:
+ pass
else:
print("# "+modname)
GDB_Instance.CSV_header = True
diff --git a/main.py b/__main__.py
similarity index 100%
rename from main.py
rename to __main__.py
diff --git a/mcgdb_testing/Makefile b/mcgdb_testing/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..28a8f03ef83fc11b124916aa4d7c1c4acffeb34f
--- /dev/null
+++ b/mcgdb_testing/Makefile
@@ -0,0 +1,8 @@
+BIN_DIR ?= __binaries__
+
+CFLAGS=-g -O0
+
+benchmark : $(BIN_DIR)/benchmark
+
+$(BIN_DIR)/benchmark : benchmark.c
+ gcc -o $@ $< ${CFLAGS}
diff --git a/mcgdb_testing/benchmark.c b/mcgdb_testing/benchmark.c
new file mode 100644
index 0000000000000000000000000000000000000000..80b9975006d8e3980d9b0f48cd937f8bc8a7f0a4
--- /dev/null
+++ b/mcgdb_testing/benchmark.c
@@ -0,0 +1,76 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+/***********/
+// modified by debugging, do not change to macro.
+int repeat = 2;
+
+int it_count = 1000;
+int us_sleep_time = 100;
+
+/***********/
+
+void finish_data_ready(void) {}
+
+void finish(struct timeval x, struct timeval y) {
+
+ static float it_total;
+ static float ms_busy_time, us_busy_once;
+ static float ms_total_sleep;
+ static float ms_time;
+ {
+ static double x_us, y_us;
+
+ x_us = (double) x.tv_sec*1000000 + (double) x.tv_usec;
+ y_us = (double) y.tv_sec*1000000 + (double) y.tv_usec;
+
+ it_total = repeat * it_count;
+
+ ms_time = (y_us - x_us)/1000;
+ ms_total_sleep = us_sleep_time*(it_total/1000.0);
+ ms_busy_time = ms_time - ms_total_sleep;
+ us_busy_once = ms_busy_time * 1000 / it_total;
+ }
+
+ finish_data_ready();
+
+ printf("Repeat: %d; Loop: %d; usleep %dus (one) %1.fms (total)\n",
+ repeat, it_count, us_sleep_time, ms_total_sleep);
+ printf("------------------\n");
+ printf("Total time: %1.fms\n", ms_time);
+ printf("Busy time : %1.fms\n", ms_busy_time);
+ printf("Busy once : %1.fus\n", us_busy_once);
+}
+
+void action(int it) {
+ usleep(us_sleep_time);
+}
+
+void benchmark(void) {
+ static int i;
+
+ for (i = 0; i < it_count; ++i) {
+ action(i);
+ }
+}
+
+int main(int argc, char** argv) {
+ struct timeval before , after;
+ int i;
+
+ benchmark(); // warm-up
+
+ gettimeofday(&before , NULL);
+
+ for (i = 0; i < repeat; ++i) {
+ benchmark();
+ }
+
+ gettimeofday(&after , NULL);
+
+ finish(before, after);
+
+ return EXIT_SUCCESS;
+}
diff --git a/mcgdb_testing/mc_gdb.py b/mcgdb_testing/mc_gdb.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc751334c943bef7d0ad89c9429598d186c5532a
--- /dev/null
+++ b/mcgdb_testing/mc_gdb.py
@@ -0,0 +1,39 @@
+native_gdb = None
+gdb = None
+
+TEST_FINISH_BP = """python
+class TestFctBP(mcgdb.capture.FunctionBreakpoint):
+ do_finish = False
+
+ def __init__(self):
+ mcgdb.capture.FunctionBreakpoint.__init__(self, "action")
+
+ def prepare_before (self):
+ return (False, TestFctBP.do_finish, {})
+
+ def prepare_after(self, data):
+ return False
+TestFctBP()
+end
+"""
+
+def function_breakpoint():
+ gdb.execute(TEST_FINISH_BP)
+ native_gdb.run("Function Breakpoint")
+
+def finish_breakpoint():
+ gdb.execute(TEST_FINISH_BP)
+ gdb.execute("python TestFctBP.do_finish = True")
+
+ native_gdb.run("Finish Breakpoint")
+
+def prepare(_gdb):
+ gdb.execute("py import mcgdb")
+
+def benchmark(_gdb):
+ global native_gdb, gdb
+ from . import native_gdb
+ gdb = _gdb
+ what = [function_breakpoint, finish_breakpoint]
+
+ native_gdb.benchmark(_gdb, what, no_mcgdb=False)
diff --git a/mcgdb_testing/native_gdb.py b/mcgdb_testing/native_gdb.py
new file mode 100644
index 0000000000000000000000000000000000000000..56c5e9765f0974b264c1e924b302c9446d20a099
--- /dev/null
+++ b/mcgdb_testing/native_gdb.py
@@ -0,0 +1,75 @@
+from gdb_tester import *
+
+gdb = None
+
+def run(what, run="run"):
+ gdb.set_title(what)
+ gdb.execute("break finish_data_ready")
+ gdb.execute(run)
+ gdb.execute("up")
+
+ gdb.save_value("us_busy_once", "%1.f", "us")
+
+def nominal_time():
+ run("Nominal time")
+
+def gdb_watchpoint():
+ gdb.execute("break benchmark")
+ gdb.execute("run")
+ gdb.execute("print &i")
+ gdb.execute("watch *$1")
+ gdb.execute("""command
+silent
+continue
+end""")
+ gdb.execute("py [b for b in gdb.breakpoints() if b.location == 'benchmark'][0].delete()")
+
+ run("HW Watchpoint command", run="continue")
+
+def gdb_breakpoint():
+ gdb.execute("break action")
+ gdb.execute("""command
+silent
+continue
+end""")
+ run("Breakpoint command")
+
+PARAMETERS = [
+ 'int(gdb.parse_and_eval("it"))',
+ 'int(gdb.newest_frame().older().read_var("i"))'
+ ]
+def gdb_py_breakpoint_parameter(params_choice):
+ params = [par for i, par in enumerate(PARAMETERS) if params_choice & (1 << i)]
+
+ def to_run():
+ gdb.execute("""python
+class TestBP(gdb.Breakpoint):
+ def __init__(self):
+ gdb.Breakpoint.__init__(self, "action")
+ self.silent=True
+
+ def stop(self):
+ {params}
+ return False
+
+TestBP()
+end
+""".format(params="\n ".join(params)))
+ run("Py BP param {:02b}".format(params_choice)[2:])
+
+ return to_run
+
+def benchmark(_gdb, what=None, no_mcgdb=True):
+ global gdb
+ gdb = _gdb
+
+ if what is None:
+ what = [nominal_time, gdb_breakpoint, gdb_watchpoint] + \
+ list(map(lambda x: gdb_py_breakpoint_parameter(x), (0b0, 0b1, 0b10, 0b11)))
+
+ gdb.start(CSource("benchmark.c"), no_mcgdb)
+ for prepare_and_run in what:
+ prepare_and_run()
+ gdb.reset(hard=(not no_mcgdb))
+
+ gdb.quit()
diff --git a/openmp_testing/Makefile b/openmp_testing/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..92f635962ed9efebbd10a0012438c168c64b30c8
--- /dev/null
+++ b/openmp_testing/Makefile
@@ -0,0 +1,53 @@
+BIN_DIR ?= __binaries__
+CFLAGS=-g -O0
+
+GOMP ?= yes
+
+LLVM ?= no
+MY_CLANG_DIR = /home/kevin/travail/sample/LLVM/llvm/Debug+Asserts/bin
+
+OMPSS ?= no
+MY_OMPSS_DIR = ~/travail/tools/ompss-install/bin
+OMPSS_TMP_DBG_DIR = $(BIN_DIR)/.tmp/
+
+ifeq ($(LLVM),yes)
+ CFLAGS += -fopenmp
+ CC = ${MY_CLANG_DIR}/clang
+
+# -- -- --
+ IMPLEM_CHECK= $(BIN_DIR)/.is_llvm
+ IMPLEM_NCHECK= $(BIN_DIR)/.is_gcc IMPLEM_CHECK= $(BIN_DIR)/.is_ompss
+endif
+
+ifeq ($(GOMP),yes)
+ CFLAGS += -fdump-tree-optimized -fopenmp
+ CC = gcc
+# -- -- --
+ IMPLEM_CHECK= $(BIN_DIR)/.is_gcc
+ IMPLEM_NCHECK= $(BIN_DIR)/.is_llvm IMPLEM_CHECK= $(BIN_DIR)/.is_ompss
+endif
+
+ifeq ($(OMPSS),yes)
+ CFLAGS += --debug --keep-files --output-dir=${OMPSS_TMP_DBG_DIR} --keep-files
+ CC = ${MY_OMPSS_DIR}/mcc
+# -- -- --
+ IMPLEM_CHECK= $(BIN_DIR)/.is_ompss
+ IMPLEM_NCHECK= $(BIN_DIR)/.is_llvm $(BIN_DIR)/.is_gcc
+endif
+
+.SUFFIXES: # disable implicit rules
+
+parallel-demo : $(BIN_DIR)/parallel-demo
+
+$(BIN_DIR)/parallel-demo : parallel-demo.c $(IMPLEM_CHECK)
+ @mkdir -p ${OMPSS_TMP_DBG_DIR}
+ ${CC} -o $@ $< ${CFLAGS}
+ @rm $(IMPLEM_NCHECK) -f
+
+$(IMPLEM_CHECK) :
+ @touch $(IMPLEM_CHECK)
+
+benchmark : $(BIN_DIR)/benchmark
+
+$(BIN_DIR)/benchmark : benchmark.c
+ gcc -o $@ $< -fopenmp ${CFLAGS}
diff --git a/openmp_testing/__binaries__/.is_gcc b/openmp_testing/__binaries__/.is_gcc
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/openmp_testing/__binaries__/.tmp/mcc_parallel-demo.c b/openmp_testing/__binaries__/.tmp/mcc_parallel-demo.c
new file mode 100644
index 0000000000000000000000000000000000000000..25aabb75548e92b0b9c7dec40d8cf55ae7d20e95
--- /dev/null
+++ b/openmp_testing/__binaries__/.tmp/mcc_parallel-demo.c
@@ -0,0 +1,674 @@
+struct _IO_FILE_plus;
+extern struct _IO_FILE_plus _IO_2_1_stdin_;
+extern struct _IO_FILE_plus _IO_2_1_stdout_;
+extern struct _IO_FILE_plus _IO_2_1_stderr_;
+struct _IO_FILE;
+extern struct _IO_FILE *stdin;
+extern struct _IO_FILE *stdout;
+extern struct _IO_FILE *stderr;
+extern int sys_nerr;
+extern const char *const sys_errlist[];
+extern int printf(const char *__restrict __format, ...);
+struct mcc_struct_anon_15
+{
+ void (*outline)(void *);
+};
+typedef struct mcc_struct_anon_15 nanos_smp_args_t;
+struct nanos_args_3_t
+{
+};
+static void smp_ol_main_3(struct nanos_args_3_t *const args);
+struct mcc_struct_anon_11
+{
+ _Bool mandatory_creation:1;
+ _Bool tied:1;
+ _Bool clear_chunk:1;
+ _Bool reserved0:1;
+ _Bool reserved1:1;
+ _Bool reserved2:1;
+ _Bool reserved3:1;
+ _Bool reserved4:1;
+};
+typedef struct mcc_struct_anon_11 nanos_wd_props_t;
+typedef unsigned long int size_t;
+struct nanos_const_wd_definition_tag
+{
+ nanos_wd_props_t props;
+ size_t data_alignment;
+ size_t num_copies;
+ size_t num_devices;
+ size_t num_dimensions;
+ const char *description;
+};
+typedef struct nanos_const_wd_definition_tag nanos_const_wd_definition_t;
+struct mcc_struct_anon_14
+{
+ void *(*factory)(void *);
+ void *arg;
+};
+typedef struct mcc_struct_anon_14 nanos_device_t;
+struct nanos_const_wd_definition_1
+{
+ nanos_const_wd_definition_t base;
+ nanos_device_t devices[1L];
+};
+extern void *nanos_smp_factory(void *args);
+extern int nanos_omp_get_num_threads_next_parallel(int threads_requested);
+typedef void *nanos_team_t;
+typedef void *nanos_thread_t;
+enum mcc_enum_anon_5
+{
+ NANOS_OK = 0,
+ NANOS_UNKNOWN_ERR = 1,
+ NANOS_UNIMPLEMENTED = 2,
+ NANOS_ENOMEM = 3,
+ NANOS_INVALID_PARAM = 4,
+ NANOS_INVALID_REQUEST = 5
+};
+typedef enum mcc_enum_anon_5 nanos_err_t;
+struct mcc_struct_anon_18;
+typedef struct mcc_struct_anon_18 nanos_constraint_t;
+typedef void *nanos_sched_t;
+extern nanos_err_t nanos_create_team(nanos_team_t *team, nanos_sched_t sg, unsigned int *nthreads, nanos_constraint_t *constraints, _Bool reuse, nanos_thread_t *info, nanos_const_wd_definition_t *const_data);
+extern void nanos_handle_error(nanos_err_t err);
+struct mcc_struct_anon_12
+{
+ _Bool is_final:1;
+ _Bool is_recover:1;
+ _Bool is_implicit:1;
+ _Bool reserved3:1;
+ _Bool reserved4:1;
+ _Bool reserved5:1;
+ _Bool reserved6:1;
+ _Bool reserved7:1;
+};
+typedef struct mcc_struct_anon_12 nanos_wd_dyn_flags_t;
+struct mcc_struct_anon_13
+{
+ nanos_wd_dyn_flags_t flags;
+ nanos_thread_t tie_to;
+ int priority;
+};
+typedef struct mcc_struct_anon_13 nanos_wd_dyn_props_t;
+typedef void *nanos_wd_t;
+struct mcc_struct_anon_4;
+typedef struct mcc_struct_anon_4 nanos_copy_data_internal_t;
+typedef nanos_copy_data_internal_t nanos_copy_data_t;
+struct mcc_struct_anon_0;
+typedef struct mcc_struct_anon_0 nanos_region_dimension_internal_t;
+typedef void *nanos_wg_t;
+extern nanos_err_t nanos_create_wd_compact(nanos_wd_t *wd, nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props, size_t data_size, void **data, nanos_wg_t wg, nanos_copy_data_t **copies, nanos_region_dimension_internal_t **dimensions);
+extern nanos_wd_t nanos_current_wd(void);
+struct mcc_struct_anon_2;
+typedef struct mcc_struct_anon_2 nanos_data_access_internal_t;
+typedef nanos_data_access_internal_t nanos_data_access_t;
+extern nanos_err_t nanos_submit(nanos_wd_t wd, size_t num_data_accesses, nanos_data_access_t *data_accesses, nanos_team_t team);
+typedef void (*nanos_translate_args_t)(void *, nanos_wd_t);
+extern nanos_err_t nanos_create_wd_and_run_compact(nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props, size_t data_size, void *data, size_t num_data_accesses, nanos_data_access_t *data_accesses, nanos_copy_data_t *copies, nanos_region_dimension_internal_t *dimensions, nanos_translate_args_t translate_args);
+struct mcc_struct_anon_1
+{
+ _Bool input:1;
+ _Bool output:1;
+ _Bool can_rename:1;
+ _Bool concurrent:1;
+ _Bool commutative:1;
+};
+typedef struct mcc_struct_anon_1 nanos_access_type_internal_t;
+typedef long int ptrdiff_t;
+struct mcc_struct_anon_2
+{
+ void *address;
+ nanos_access_type_internal_t flags;
+ short int dimension_count;
+ const nanos_region_dimension_internal_t *dimensions;
+ ptrdiff_t offset;
+};
+extern nanos_err_t nanos_end_team(nanos_team_t team);
+int main()
+{
+ printf("@Base: Let\'s attack the death start !\n");
+ printf("@Base: Releash all the starfighters.\n");
+ {
+ nanos_err_t nanos_err;
+ nanos_wd_dyn_props_t dyn_props;
+ unsigned int nth_i;
+ struct nanos_args_3_t imm_args;
+ nanos_data_access_t dependences[1L];
+ static nanos_smp_args_t smp_ol_main_3_args = {.outline = (void (*)(void *))(void (*)(struct nanos_args_3_t *))&smp_ol_main_3};
+ static struct nanos_const_wd_definition_1 nanos_wd_const_data = {.base = {.props = {.mandatory_creation = 1, .tied = 1, .clear_chunk = 0, .reserved0 = 0, .reserved1 = 0, .reserved2 = 0, .reserved3 = 0, .reserved4 = 0}, .data_alignment = __alignof__(struct nanos_args_3_t), .num_copies = 0, .num_devices = 1, .num_dimensions = 0, .description = "main"}, .devices = {[0] = {.factory = &nanos_smp_factory, .arg = &smp_ol_main_3_args}}};
+ unsigned int nanos_num_threads = nanos_omp_get_num_threads_next_parallel(0);
+ nanos_team_t nanos_team = (void *)0;
+ nanos_thread_t nanos_team_threads[nanos_num_threads];
+ nanos_err = nanos_create_team(&nanos_team, (void *)0, &nanos_num_threads, (nanos_constraint_t *)0, 1, nanos_team_threads, &nanos_wd_const_data.base);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ dyn_props.tie_to = (void *)0;
+ dyn_props.priority = 0;
+ dyn_props.flags.is_final = 0;
+ dyn_props.flags.is_implicit = 1;
+ for (nth_i = 1; nth_i < nanos_num_threads; nth_i = nth_i + 1)
+ {
+ dyn_props.tie_to = nanos_team_threads[nth_i];
+ struct nanos_args_3_t *ol_args = 0;
+ nanos_wd_t nanos_wd_ = (void *)0;
+ nanos_err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &dyn_props, sizeof(struct nanos_args_3_t), (void **)&ol_args, nanos_current_wd(), (nanos_copy_data_t **)0, (nanos_region_dimension_internal_t **)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ ;
+ nanos_err = nanos_submit(nanos_wd_, 0, (nanos_data_access_t *)0, (void *)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ dyn_props.tie_to = nanos_team_threads[0];
+ ;
+ nanos_err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &dyn_props, sizeof(struct nanos_args_3_t), &imm_args, 0, dependences, (nanos_copy_data_t *)0, (nanos_region_dimension_internal_t *)0, (void (*)(void *, nanos_wd_t))0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ nanos_err = nanos_end_team(nanos_team);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ printf("@Base: Everybody\'s back to safety, great job!\n");
+}
+static void smp_ol_main_0_unpacked(int id)
+{
+ {
+ {
+ printf("@%d I cover your backs!\n", id);
+ }
+ }
+}
+struct nanos_args_0_t
+{
+ int id;
+};
+static void smp_ol_main_0(struct nanos_args_0_t *const args)
+{
+ {
+ smp_ol_main_0_unpacked((*args).id);
+ }
+}
+static void smp_ol_main_1_unpacked(int id)
+{
+ {
+ {
+ printf("@%d I cover your backs as well!\n", id);
+ }
+ }
+}
+struct nanos_args_1_t
+{
+ int id;
+};
+static void smp_ol_main_1(struct nanos_args_1_t *const args)
+{
+ {
+ smp_ol_main_1_unpacked((*args).id);
+ }
+}
+struct nanos_ws_desc;
+typedef struct nanos_ws_desc nanos_ws_desc_t;
+extern nanos_err_t nanos_omp_set_implicit(nanos_wd_t uwd);
+typedef void *nanos_ws_item_t;
+extern nanos_err_t nanos_worksharing_next_item(nanos_ws_desc_t *wsd, nanos_ws_item_t *wsi);
+struct mcc_struct_anon_10
+{
+ int lower;
+ int upper;
+ _Bool execute:1;
+ _Bool last:1;
+};
+typedef struct mcc_struct_anon_10 nanos_ws_item_loop_t;
+extern nanos_err_t nanos_omp_barrier(void);
+static void smp_ol_main_2_unpacked(nanos_ws_desc_t *wsd_1, int *const id)
+{
+ int nanos_omp_index_0;
+ {
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_set_implicit(nanos_current_wd());
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_ws_item_loop_t nanos_item_loop;
+ nanos_err = nanos_worksharing_next_item(wsd_1, (void **)&nanos_item_loop);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ while (nanos_item_loop.execute)
+ {
+ for (nanos_omp_index_0 = nanos_item_loop.lower; nanos_omp_index_0 <= nanos_item_loop.upper; nanos_omp_index_0 += 1)
+ {
+ {
+ switch (nanos_omp_index_0)
+ {
+ case 0 :
+ {
+ printf("@%d I attack the energy field!\n", (*id));
+ }
+ break;
+ case 1 :
+ {
+ printf("@%d I attack the generator!\n", (*id));
+ }
+ break;
+ case 2 :
+ {
+ printf("@%d I follow the rabits!\n", (*id));
+ }
+ break;
+ }
+ }
+ }
+ ;
+ nanos_err = nanos_worksharing_next_item(wsd_1, (void **)&nanos_item_loop);
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ }
+}
+struct nanos_args_2_t
+{
+ nanos_ws_desc_t *wsd_1;
+ int *id;
+};
+static void smp_ol_main_2(struct nanos_args_2_t *const args)
+{
+ {
+ smp_ol_main_2_unpacked((*args).wsd_1, (*args).id);
+ }
+}
+extern nanos_err_t nanos_enter_team(void);
+extern int omp_get_thread_num(void);
+extern nanos_err_t nanos_omp_single(_Bool *);
+struct nanos_lock_t;
+typedef struct nanos_lock_t nanos_lock_t;
+extern nanos_err_t nanos_set_lock(nanos_lock_t *lock);
+enum mcc_enum_anon_4
+{
+ NANOS_LOCK_FREE = 0,
+ NANOS_LOCK_BUSY = 1
+};
+typedef enum mcc_enum_anon_4 nanos_lock_state_t;
+struct nanos_lock_t
+{
+ volatile nanos_lock_state_t state_;
+};
+__attribute__((common)) nanos_lock_t nanos_default_critical_lock;
+extern nanos_err_t nanos_unset_lock(nanos_lock_t *lock);
+extern nanos_err_t nanos_in_final(_Bool *result);
+typedef void *nanos_ws_t;
+enum nanos_omp_sched_t
+{
+ nanos_omp_sched_static = 1,
+ nanos_omp_sched_dynamic = 2,
+ nanos_omp_sched_guided = 3,
+ nanos_omp_sched_auto = 4
+};
+typedef enum nanos_omp_sched_t nanos_omp_sched_t;
+extern nanos_ws_t nanos_omp_find_worksharing(nanos_omp_sched_t kind);
+struct mcc_struct_anon_9
+{
+ int lower_bound;
+ int upper_bound;
+ int loop_step;
+ int chunk_size;
+};
+typedef struct mcc_struct_anon_9 nanos_ws_info_loop_t;
+typedef void *nanos_ws_info_t;
+extern nanos_err_t nanos_worksharing_create(nanos_ws_desc_t **wsd, nanos_ws_t ws, nanos_ws_info_t *info, _Bool *b);
+extern nanos_err_t nanos_team_get_num_supporting_threads(int *n);
+extern nanos_err_t nanos_malloc(void **p, size_t size, const char *file, int line);
+typedef void *nanos_ws_data_t;
+struct nanos_ws_desc
+{
+ volatile nanos_ws_t ws;
+ nanos_ws_data_t data;
+ struct nanos_ws_desc *next;
+ nanos_thread_t *threads;
+ int nths;
+};
+extern nanos_err_t nanos_team_get_supporting_threads(int *n, nanos_thread_t *list_of_threads);
+typedef void *nanos_slicer_t;
+extern nanos_slicer_t nanos_find_slicer(const char *slicer);
+extern nanos_err_t nanos_create_sliced_wd(nanos_wd_t *uwd, size_t num_devices, nanos_device_t *devices, size_t outline_data_size, int outline_data_align, void **outline_data, nanos_wg_t uwg, nanos_slicer_t slicer, nanos_wd_props_t *props, nanos_wd_dyn_props_t *dyn_props, size_t num_copies, nanos_copy_data_t **copies, size_t num_dimensions, nanos_region_dimension_internal_t **dimensions);
+extern nanos_err_t nanos_free(void *p);
+extern int nanos_omp_get_thread_num(void);
+extern nanos_err_t nanos_leave_team(void);
+static void smp_ol_main_3_unpacked(void)
+{
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_set_implicit(nanos_current_wd());
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ nanos_err = nanos_enter_team();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ {
+ int id = omp_get_thread_num() + 1;
+ printf("@%d On the way to the combat zone.\n", id);
+ {
+ _Bool single_guard;
+ nanos_err_t nanos_err = nanos_omp_single(&single_guard);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (single_guard)
+ {
+ {
+ printf("@%d I opened a breach in the star,\n", id);
+ printf("@%d but we can only enter one by one.\n", id);
+ }
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_set_lock(&nanos_default_critical_lock);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ {
+ printf("@%d I\'m entering the breach\n", id);
+ }
+ nanos_err = nanos_unset_lock(&nanos_default_critical_lock);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ printf("\n@%d Someone needs to cover us!\n", id);
+ {
+ _Bool single_guard;
+ nanos_err_t nanos_err = nanos_omp_single(&single_guard);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (single_guard)
+ {
+ {
+ printf("@%d I give the orders\n", id);
+ {
+ _Bool mcc_is_in_final;
+ nanos_err_t mcc_err_in_final = nanos_in_final(&mcc_is_in_final);
+ if (mcc_err_in_final != NANOS_OK)
+ {
+ nanos_handle_error(mcc_err_in_final);
+ }
+ if (mcc_is_in_final)
+ {
+ {
+ printf("@%d I cover your backs!\n", id);
+ }
+ }
+ else
+ {
+ {
+ nanos_wd_dyn_props_t nanos_wd_dyn_props;
+ struct nanos_args_0_t *ol_args;
+ nanos_err_t nanos_err;
+ struct nanos_args_0_t imm_args;
+ nanos_data_access_t dependences[1L];
+ static nanos_smp_args_t smp_ol_main_0_args = {.outline = (void (*)(void *))(void (*)(struct nanos_args_0_t *))&smp_ol_main_0};
+ static struct nanos_const_wd_definition_1 nanos_wd_const_data = {.base = {.props = {.mandatory_creation = 0, .tied = 1, .clear_chunk = 0, .reserved0 = 0, .reserved1 = 0, .reserved2 = 0, .reserved3 = 0, .reserved4 = 0}, .data_alignment = __alignof__(struct nanos_args_0_t), .num_copies = 0, .num_devices = 1, .num_dimensions = 0, .description = "main"}, .devices = {[0] = {.factory = &nanos_smp_factory, .arg = &smp_ol_main_0_args}}};
+ nanos_wd_dyn_props.tie_to = 0;
+ nanos_wd_dyn_props.priority = 0;
+ nanos_wd_dyn_props.flags.is_final = 0;
+ nanos_wd_dyn_props.flags.is_implicit = 0;
+ ol_args = (struct nanos_args_0_t *)0;
+ void *nanos_wd_ = (void *)0;
+ nanos_err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_0_t), (void **)&ol_args, nanos_current_wd(), (nanos_copy_data_t **)0, (nanos_region_dimension_internal_t **)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (nanos_wd_ != (void *)0)
+ {
+ (*ol_args).id = id;
+ nanos_err = nanos_submit(nanos_wd_, 0, &dependences[0], (void *)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ else
+ {
+ imm_args.id = id;
+ nanos_err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_0_t), &imm_args, 0, &dependences[0], (nanos_copy_data_t *)0, (nanos_region_dimension_internal_t *)0, (void (*)(void *, void *))0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ }
+ }
+ }
+ {
+ _Bool mcc_is_in_final;
+ nanos_err_t mcc_err_in_final = nanos_in_final(&mcc_is_in_final);
+ if (mcc_err_in_final != NANOS_OK)
+ {
+ nanos_handle_error(mcc_err_in_final);
+ }
+ if (mcc_is_in_final)
+ {
+ {
+ printf("@%d I cover your backs as well!\n", id);
+ }
+ }
+ else
+ {
+ {
+ nanos_wd_dyn_props_t nanos_wd_dyn_props;
+ struct nanos_args_1_t *ol_args;
+ nanos_err_t nanos_err;
+ struct nanos_args_1_t imm_args;
+ nanos_data_access_t dependences[1L];
+ static nanos_smp_args_t smp_ol_main_1_args = {.outline = (void (*)(void *))(void (*)(struct nanos_args_1_t *))&smp_ol_main_1};
+ static struct nanos_const_wd_definition_1 nanos_wd_const_data = {.base = {.props = {.mandatory_creation = 0, .tied = 1, .clear_chunk = 0, .reserved0 = 0, .reserved1 = 0, .reserved2 = 0, .reserved3 = 0, .reserved4 = 0}, .data_alignment = __alignof__(struct nanos_args_1_t), .num_copies = 0, .num_devices = 1, .num_dimensions = 0, .description = "main"}, .devices = {[0] = {.factory = &nanos_smp_factory, .arg = &smp_ol_main_1_args}}};
+ nanos_wd_dyn_props.tie_to = 0;
+ nanos_wd_dyn_props.priority = 0;
+ nanos_wd_dyn_props.flags.is_final = 0;
+ nanos_wd_dyn_props.flags.is_implicit = 0;
+ ol_args = (struct nanos_args_1_t *)0;
+ void *nanos_wd_ = (void *)0;
+ nanos_err = nanos_create_wd_compact(&nanos_wd_, &nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_1_t), (void **)&ol_args, nanos_current_wd(), (nanos_copy_data_t **)0, (nanos_region_dimension_internal_t **)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (nanos_wd_ != (void *)0)
+ {
+ (*ol_args).id = id;
+ nanos_err = nanos_submit(nanos_wd_, 0, &dependences[0], (void *)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ else
+ {
+ imm_args.id = id;
+ nanos_err = nanos_create_wd_and_run_compact(&nanos_wd_const_data.base, &nanos_wd_dyn_props, sizeof(struct nanos_args_1_t), &imm_args, 0, &dependences[0], (nanos_copy_data_t *)0, (nanos_region_dimension_internal_t *)0, (void (*)(void *, void *))0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ {
+ int nanos_chunk;
+ nanos_ws_info_loop_t nanos_setup_info_loop;
+ nanos_err_t nanos_err;
+ nanos_ws_desc_t *wsd_1;
+ _Bool single_guard;
+ struct nanos_args_2_t imm_args;
+ void *current_ws_policy = nanos_omp_find_worksharing(nanos_omp_sched_static);
+ if (current_ws_policy == 0)
+ {
+ nanos_handle_error(NANOS_UNIMPLEMENTED);
+ }
+ nanos_chunk = 1;
+ nanos_setup_info_loop.lower_bound = 0;
+ nanos_setup_info_loop.upper_bound = 2;
+ nanos_setup_info_loop.loop_step = 1;
+ nanos_setup_info_loop.chunk_size = nanos_chunk;
+ nanos_err = nanos_worksharing_create(&wsd_1, current_ws_policy, (void **)&nanos_setup_info_loop, &single_guard);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (single_guard)
+ {
+ int sup_threads;
+ nanos_err = nanos_team_get_num_supporting_threads(&sup_threads);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ if (sup_threads > 0)
+ {
+ nanos_wd_dyn_props_t dyn_props;
+ nanos_err = nanos_malloc((void **)&(*wsd_1).threads, sizeof(void *) * sup_threads, "", 0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ nanos_err = nanos_team_get_supporting_threads(&(*wsd_1).nths, (*wsd_1).threads);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ struct nanos_args_2_t *ol_args = (struct nanos_args_2_t *)0;
+ static nanos_smp_args_t smp_ol_main_2_args = {.outline = (void (*)(void *))(void (*)(struct nanos_args_2_t *))&smp_ol_main_2};
+ static struct nanos_const_wd_definition_1 nanos_wd_const_data = {.base = {.props = {.mandatory_creation = 1, .tied = 1, .clear_chunk = 0, .reserved0 = 0, .reserved1 = 0, .reserved2 = 0, .reserved3 = 0, .reserved4 = 0}, .data_alignment = __alignof__(struct nanos_args_2_t), .num_copies = 0, .num_devices = 1, .num_dimensions = 0, .description = "main"}, .devices = {[0] = {.factory = &nanos_smp_factory, .arg = &smp_ol_main_2_args}}};
+ void *nanos_wd_ = (void *)0;
+ dyn_props.tie_to = (void *)0;
+ dyn_props.priority = 0;
+ dyn_props.flags.is_final = 0;
+ dyn_props.flags.is_implicit = 0;
+ static void *replicate = (void *)0;
+ if (replicate == (void *)0)
+ {
+ replicate = nanos_find_slicer("replicate");
+ }
+ if (replicate == (void *)0)
+ {
+ nanos_handle_error(NANOS_UNIMPLEMENTED);
+ }
+ nanos_err = nanos_create_sliced_wd(&nanos_wd_, nanos_wd_const_data.base.num_devices, nanos_wd_const_data.devices, (unsigned long int)sizeof(struct nanos_args_2_t), nanos_wd_const_data.base.data_alignment, (void **)&ol_args, (void **)0, replicate, &nanos_wd_const_data.base.props, &dyn_props, 0, (nanos_copy_data_t **)0, 0, (nanos_region_dimension_internal_t **)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ (*ol_args).wsd_1 = wsd_1;
+ (*ol_args).id = &id;
+ nanos_err = nanos_submit(nanos_wd_, 0, (nanos_data_access_t *)0, (void *)0);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ nanos_err = nanos_free((*wsd_1).threads);
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ }
+ imm_args.wsd_1 = wsd_1;
+ imm_args.id = &id;
+ smp_ol_main_2(&(imm_args));
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ if (nanos_omp_get_thread_num() == 0)
+ {
+ {
+ printf("@%d Now I attack the inner core...\n", id);
+ printf("@%d ... and destroy it !\n", id);
+ }
+ }
+ {
+ nanos_err_t nanos_err;
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+ printf("@%d We\'re done!!!\n", id);
+ }
+ nanos_err = nanos_omp_barrier();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ nanos_err = nanos_leave_team();
+ if (nanos_err != NANOS_OK)
+ {
+ nanos_handle_error(nanos_err);
+ }
+ }
+}
+static void smp_ol_main_3(struct nanos_args_3_t *const args)
+{
+ {
+ smp_ol_main_3_unpacked();
+ }
+}
diff --git a/openmp_testing/__binaries__/benchmark b/openmp_testing/__binaries__/benchmark
new file mode 100755
index 0000000000000000000000000000000000000000..a4c12a55c2bb10c9e53e6c90614d4876d140ab10
Binary files /dev/null and b/openmp_testing/__binaries__/benchmark differ
diff --git a/openmp_testing/__binaries__/parallel-demo b/openmp_testing/__binaries__/parallel-demo
new file mode 100755
index 0000000000000000000000000000000000000000..a476143a5c5cc1963a4bc2ecbdf1218b819fe2a8
Binary files /dev/null and b/openmp_testing/__binaries__/parallel-demo differ
diff --git a/openmp_testing/__init__.py b/openmp_testing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..718e328169ed215d7c0eee75545a82c348dce28c
--- /dev/null
+++ b/openmp_testing/__init__.py
@@ -0,0 +1,4 @@
+LD_PRELOAD = "/home/kevin/travail/Python/mcgdb/openmp/capture/preload/__binaries__/libmcgdb_omp.preload.so"
+
+from . import sequence, stepping
+
diff --git a/openmp_testing/benchmark.c b/openmp_testing/benchmark.c
new file mode 100644
index 0000000000000000000000000000000000000000..395625fac64192959f573afb59e9a5d4753a985e
--- /dev/null
+++ b/openmp_testing/benchmark.c
@@ -0,0 +1,168 @@
+#include <omp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+void do_something(int it);
+
+/***********/
+// modified by debugging, do not change to macro.
+int repeat = 2;
+
+int it_count = 50;
+int us_sleep_time = 0;
+
+int it_total = 0;
+volatile int something;
+void (*what_to_do)(int it) = NULL;
+/***********/
+
+void finish_data_ready(void) {}
+
+void finish(struct timeval x, struct timeval y) {
+
+ //static float it_total;
+ static float ms_busy_time, us_busy_once;
+ static float ms_total_sleep;
+ static float ms_time;
+ {
+ static double x_us, y_us;
+
+ x_us = (double) x.tv_sec*1000000 + (double) x.tv_usec;
+ y_us = (double) y.tv_sec*1000000 + (double) y.tv_usec;
+
+ //it_total = repeat * it_count;
+
+ ms_time = (y_us - x_us)/1000;
+ ms_total_sleep = us_sleep_time*(it_total/1000.0);
+ ms_busy_time = ms_time - ms_total_sleep;
+ us_busy_once = ms_busy_time * 1000 / it_total;
+ }
+
+ finish_data_ready();
+
+ printf("Repeat: %d; Loop: %d; usleep %dus (one) %1.fms (total)\n",
+ repeat, it_count, us_sleep_time, ms_total_sleep);
+ printf("------------------\n");
+ printf("Total time: %1.fms\n", ms_time);
+ printf("Busy time : %1.fms\n", ms_busy_time);
+ printf("Busy once : %1.fus\n", us_busy_once);
+}
+
+void do_something(int it) {
+ something = it;
+#pragma omp atomic
+ it_total++;
+ if (us_sleep_time)
+ usleep(us_sleep_time);
+}
+
+void do_nothing(int it) {
+ something = it;
+}
+
+void do_single(int it) {
+ #pragma omp single
+ {
+ do_nothing(it);
+ }
+}
+
+void do_critical(int it) {
+ #pragma omp critical
+ {
+ do_nothing(it);
+ }
+}
+
+void do_sections(int it) {
+ #pragma omp sections
+ {
+ #pragma omp section
+ {
+ do_nothing(it);
+ }
+ #pragma omp section
+ {
+ do_nothing(it+1);
+ }
+ #pragma omp section
+ {
+ do_nothing(it+2);
+ }
+ }
+}
+
+void do_barrier(int it) {
+ #pragma omp barrier
+ do_nothing(it);
+}
+
+void do_master(int it) {
+ #pragma omp master
+ {
+ do_nothing(it);
+ }
+}
+
+void do_single_task(int it) {
+ #pragma omp single
+ {
+ #pragma omp task
+ {
+ //printf("Task going %d/%d.\n", it, it_count);
+ do_something(it);
+ }
+ }
+}
+
+void benchmark(void (*action)(int)) {
+ #pragma omp parallel
+ {
+ int i;
+ for (i = 0; i < it_count; ++i) {
+ do_something(i);
+ action(i);
+ }
+ }
+}
+
+void run_once(void (*what_to_do)(int)) {
+ struct timeval before , after;
+ int i;
+
+ benchmark(what_to_do); // warm-up
+ printf("Warmup done.\n");
+
+ it_total = 0;
+ gettimeofday(&before , NULL);
+
+ for (i = 0; i < repeat; ++i) {
+ benchmark(what_to_do);
+ }
+
+ gettimeofday(&after , NULL);
+
+ finish(before, after);
+
+ return;
+}
+
+
+int main(int argc, char** argv) {
+ if (what_to_do == NULL) {
+ void (*WHAT_TO_RUN[])(int) = {do_critical, do_master, do_sections, do_barrier, do_single};
+ char *NAMES[] = {"Critical", "Master", "Sections", "Barrier", "Single"};
+
+ int NB_RUNS = sizeof(WHAT_TO_RUN)/sizeof(WHAT_TO_RUN[0]);
+
+ for (int i = 0; i < NB_RUNS; i++) {
+ printf("\n\n---- <%s> ----\n", NAMES[i]);
+ run_once(WHAT_TO_RUN[i]);
+ printf("---- </%s> ----\n", NAMES[i]);
+ }
+ } else {
+ run_once(what_to_do);
+ }
+}
diff --git a/openmp_testing/benchmark.py b/openmp_testing/benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..730e069a05288b3214b659914fda263d476caf8f
--- /dev/null
+++ b/openmp_testing/benchmark.py
@@ -0,0 +1,36 @@
+from gdb_tester import *
+from . import LD_PRELOAD
+gdb = None
+
+def prepare_and_run(what):
+ gdb.set_title(what.replace("do_", "").replace("_", " "))
+ gdb.execute('set env LD_PRELOAD={}'.format(LD_PRELOAD))
+ gdb.execute("set env OMP_NUM_THREADS=2")
+ gdb.execute_many(["autodetect_models", "start"])
+
+ gdb.execute("set what_to_do = {}".format(what))
+ gdb.execute("break finish_data_ready")
+ gdb.execute("continue")
+ gdb.execute("up")
+
+ gdb.save_value("us_busy_once", "%1.f", "us")
+
+WHAT_TO_RUN = [
+ "do_critical",
+ "do_master",
+ "do_sections",
+ "do_barrier",
+ "do_single",
+ "do_single_task"
+ ]
+
+def benchmark(_gdb):
+ global gdb
+ gdb = _gdb
+
+ gdb.start(CSource("benchmark.c"))
+ for what in WHAT_TO_RUN:
+ gdb.reset(hard=True)
+ prepare_and_run(what)
+
+ gdb.quit()
diff --git a/openmp_testing/count.py b/openmp_testing/count.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c23810b0bfa7bd9b8f124df9adbe1aa2776cad8
--- /dev/null
+++ b/openmp_testing/count.py
@@ -0,0 +1,37 @@
+from gdb_tester import *
+from . import LD_PRELOAD
+
+gdb = None
+
+def prepare_and_run(what):
+ gdb.set_title(what.replace("do_", ""))
+
+ gdb.execute('set env LD_PRELOAD={}'.format(LD_PRELOAD))
+
+ gdb.execute_many(["autodetect_models", "start"])
+
+ gdb.execute("set what_to_do = {}".format(what))
+ gdb.execute("set repeat = 0")
+ gdb.execute("set it_count = 1")
+
+ gdb.execute("break finish_data_ready")
+ gdb.execute("continue")
+ gdb.execute("python import mcgdb")
+
+ gdb.save_py_value("str(mcgdb.capture.FunctionBreakpoint.hit_count) + '+' + str( mcgdb.capture.FunctionFinishBreakpoint.hit_count)")
+
+
+def benchmark(_gdb):
+ global gdb
+ gdb = _gdb
+
+ from . import benchmark
+
+ gdb.start(CSource("benchmark.c"))
+ for what in benchmark.WHAT_TO_RUN:
+ gdb.reset(hard=True)
+ prepare_and_run(what)
+
+ gdb.quit()
+
+ raise FinishException()
diff --git a/openmp_testing/no_instrumentation.py b/openmp_testing/no_instrumentation.py
new file mode 100644
index 0000000000000000000000000000000000000000..720821f56ca70f3a6de6e8f75b715fd46f2397a2
--- /dev/null
+++ b/openmp_testing/no_instrumentation.py
@@ -0,0 +1,31 @@
+from gdb_tester import *
+from . import LD_PRELOAD
+gdb = None
+
+def prepare_and_run(what):
+ gdb.set_title(what.replace("do_", ""))
+ gdb.execute('set env LD_PRELOAD={}'.format(LD_PRELOAD))
+
+ gdb.execute("start")
+
+ gdb.execute("set what_to_do = {}".format(what))
+
+ gdb.execute("break finish_data_ready")
+ gdb.execute("continue")
+ gdb.execute("up")
+ gdb.execute("python import mcgdb")
+
+ gdb.save_value("us_busy_once", "%1.f", "us")
+
+def benchmark(_gdb):
+ global gdb
+ gdb = _gdb
+
+ from . import benchmark
+
+ gdb.start(CSource("benchmark.c"))
+ for what in benchmark.WHAT_TO_RUN:
+ gdb.reset(hard=True)
+ prepare_and_run(what)
+
+ gdb.quit()
diff --git a/openmp_testing/opm_seq_print.expected b/openmp_testing/opm_seq_print.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e683b521a7f717391a3039fb5b370fe107ed6101
--- /dev/null
+++ b/openmp_testing/opm_seq_print.expected
@@ -0,0 +1,7 @@
+{
+ 1; 2; 3; 4;
+
+ 1 -> 1 [leftnote="main"]
+ 1 -> 1 [here, label="<dead>"];
+ 1 <- 1 [narrow]
+}
\ No newline at end of file
diff --git a/openmp_testing/opm_seq_print_all.expected b/openmp_testing/opm_seq_print_all.expected
new file mode 100644
index 0000000000000000000000000000000000000000..890ec8226055ff97d75631b00fe40f22cd75afee
--- /dev/null
+++ b/openmp_testing/opm_seq_print_all.expected
@@ -0,0 +1,67 @@
+{
+ 1; 2; 3; 4;
+
+ 1 -> 1 [leftnote="main"];
+ parallel {
+ 1; 3; 4; 2;
+
+ single {
+ 1; 3; 4; 2;
+
+ 4 -> 4 [label="enter"];
+ 4 <- 4 [label="exit"];
+ === <Barrier 1> ===
+ };
+ critical {
+ 1; 3; 4; 2;
+
+ 3 -> 3 [label="enter"];
+ 3 -> 2;
+ 2 -> 4;
+ 4 -> 1;
+ 1 <- 1 [label="finish"]
+ };
+ single {
+ 1; 3; 4; 2;
+
+ 3 -> 3 [label="enter"];
+ 3 -> 3 [msg, label="Task 1"];
+ 3 -> 3 [msg, label="Task 2"];
+ 3 <- 3 [label="exit"];
+ === <Barrier 2> ===
+ task {
+ 2;
+
+ 2 -> 2 [label="Task 1"];
+ 2 <- 2
+ }
+ task {
+ 1;
+
+ 1 -> 1 [label="Task 2"];
+ 1 <- 1
+ }
+ === </Barrier 2> ===
+ };
+ section {
+ 1; 3; 4; 2;
+
+ 1 -> 1 [label="Section #1"];
+ 4 -> 4 [label="Section #3"];
+ 2 -> 2 [label="Section #2"];
+ 4 <- 4;
+ 2 <- 2;
+ 1 <- 1
+ };
+ === <Barrier 3> ===;
+ task master {
+ 1;
+
+ 1 -> 1 [label="Task 3"];
+ 1 <- 1
+ };
+ === <Barrier 4> ===
+ }
+ 1 -> 1 [here, label="<dead>"];
+ 1 <- 1 [narrow]
+}
\ No newline at end of file
diff --git a/openmp_testing/parallel-demo.c b/openmp_testing/parallel-demo.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f3a8a01706b141ba93e0f2578b4bc6f190b113a
--- /dev/null
+++ b/openmp_testing/parallel-demo.c
@@ -0,0 +1,69 @@
+#include <omp.h>
+#include <stdio.h>
+
+int main() {
+ printf("@Base: Let's attack the death start !\n");
+ printf("@Base: Releash all the starfighters.\n");
+#pragma omp parallel
+ {
+ int id = omp_get_thread_num() + 1;
+
+ printf("@%d On the way to the combat zone.\n", id);
+#pragma omp single
+ {
+ printf("@%d I opened a breach in the star,\n", id);
+ printf("@%d but we can only enter one by one.\n", id);
+ }
+
+#pragma omp critical
+ {
+ printf("@%d I'm entering the breach\n", id);
+ }
+
+ /****/
+
+ printf("\n@%d Someone needs to cover us!\n", id);
+
+#pragma omp single
+ {
+ printf("@%d I give the orders\n", id);
+
+#pragma omp task
+ {
+ printf("@%d I cover your backs!\n", id);
+ }
+#pragma omp task
+ {
+ printf("@%d I cover your backs as well!\n", id);
+ }
+ }
+
+#pragma omp sections
+ {
+#pragma omp section
+ {
+ printf("@%d I attack the energy field!\n", id);
+ }
+#pragma omp section
+ {
+ printf("@%d I attack the generator!\n", id);
+ }
+#pragma omp section
+ {
+ printf("@%d I follow the rabits!\n", id);
+ }
+ }
+
+#pragma omp barrier
+
+#pragma omp master
+ {
+ printf("@%d Now I attack the inner core...\n", id);
+ printf("@%d ... and destroy it !\n", id);
+ }
+#pragma omp barrier
+
+ printf("@%d We're done!!!\n", id);
+ }
+ printf("@Base: Everybody's back to safety, great job!\n");
+}
diff --git a/openmp_testing/sequence.py b/openmp_testing/sequence.py
new file mode 100644
index 0000000000000000000000000000000000000000..7317efd41d71d5c2788719343a3e933c0dc60c1d
--- /dev/null
+++ b/openmp_testing/sequence.py
@@ -0,0 +1,16 @@
+from gdb_tester import *
+
+expected_start = """Enable model GCC OpenMP"""
+expected_print = expected_file("opm_seq_print.expected")
+expected_print_all = expected_file("opm_seq_print_all.expected")
+
+def test(gdb):
+ print("Running :)")
+
+ gdb.start(CSource("parallel-demo.c"))
+ gdb.execute_many(["autodetect_models", "run"])
+
+ gdb.execute("opm sequence --print", expected_print, may_fail=True)
+ gdb.execute("opm sequence --print --all", expected_print_all, may_fail=True)
+
+ gdb.quit()
diff --git a/openmp_testing/stepping.py b/openmp_testing/stepping.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c4332b7563218d4aaadd5ddde088167db9dcb30
--- /dev/null
+++ b/openmp_testing/stepping.py
@@ -0,0 +1,18 @@
+from gdb_tester import *
+
+from . import LD_PRELOAD
+
+def test(gdb):
+ gdb.start(CSource("parallel-demo.c"))
+ gdb.execute('set env LD_PRELOAD={}'.format(LD_PRELOAD))
+
+ gdb.execute_many(["autodetect_models", "start"])
+ gdb.execute("opm start", "OpenMP parallel zone started")
+ gdb.execute("opm step", "in single zone")
+ gdb.execute("opm all_out", "Out of the single zone")
+ gdb.execute("opm step", "in critical zone")
+ gdb.execute("opm critical next", "in critical zone")
+ gdb.execute("opm critical next", "in critical zone")
+ gdb.execute("opm step out", "outside Critical zone")
+
+ gdb.quit()