From 9acb8b06de8c5a5f902af689acc944e3ff3a62c8 Mon Sep 17 00:00:00 2001
From: Kevin Pouget <kevin.pouget@imag.fr>
Date: Thu, 18 Feb 2016 16:40:25 +0100
Subject: [PATCH] improve
---
__init__.py | 17 +-
main.py => __main__.py | 0
mcgdb_testing/Makefile | 8 +
mcgdb_testing/benchmark.c | 76 ++
mcgdb_testing/mc_gdb.py | 39 +
mcgdb_testing/native_gdb.py | 75 ++
openmp_testing/Makefile | 53 ++
openmp_testing/__binaries__/.is_gcc | 0
.../__binaries__/.tmp/mcc_parallel-demo.c | 674 ++++++++++++++++++
openmp_testing/__binaries__/benchmark | Bin 0 -> 15440 bytes
openmp_testing/__binaries__/parallel-demo | Bin 0 -> 11600 bytes
openmp_testing/__init__.py | 4 +
openmp_testing/benchmark.c | 168 +++++
openmp_testing/benchmark.py | 36 +
openmp_testing/count.py | 37 +
openmp_testing/no_instrumentation.py | 31 +
openmp_testing/opm_seq_print.expected | 7 +
openmp_testing/opm_seq_print_all.expected | 67 ++
openmp_testing/parallel-demo.c | 69 ++
openmp_testing/sequence.py | 16 +
openmp_testing/stepping.py | 18 +
21 files changed, 1391 insertions(+), 4 deletions(-)
rename main.py => __main__.py (100%)
create mode 100644 mcgdb_testing/Makefile
create mode 100644 mcgdb_testing/benchmark.c
create mode 100644 mcgdb_testing/mc_gdb.py
create mode 100644 mcgdb_testing/native_gdb.py
create mode 100644 openmp_testing/Makefile
create mode 100644 openmp_testing/__binaries__/.is_gcc
create mode 100644 openmp_testing/__binaries__/.tmp/mcc_parallel-demo.c
create mode 100755 openmp_testing/__binaries__/benchmark
create mode 100755 openmp_testing/__binaries__/parallel-demo
create mode 100644 openmp_testing/__init__.py
create mode 100644 openmp_testing/benchmark.c
create mode 100644 openmp_testing/benchmark.py
create mode 100644 openmp_testing/count.py
create mode 100644 openmp_testing/no_instrumentation.py
create mode 100644 openmp_testing/opm_seq_print.expected
create mode 100644 openmp_testing/opm_seq_print_all.expected
create mode 100644 openmp_testing/parallel-demo.c
create mode 100644 openmp_testing/sequence.py
create mode 100644 openmp_testing/stepping.py
diff --git a/__init__.py b/__init__.py
index 2e73112..83345fb 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 0000000..28a8f03
--- /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 0000000..80b9975
--- /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 0000000..cc75133
--- /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 0000000..56c5e97
--- /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 0000000..92f6359
--- /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 0000000..e69de29
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 0000000..25aabb7
--- /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
GIT binary patch
literal 15440
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
RdQjy8(g4LE`=CrP1px08d%^$!
literal 0
HcmV?d00001
diff --git a/openmp_testing/__binaries__/parallel-demo b/openmp_testing/__binaries__/parallel-demo
new file mode 100755
index 0000000000000000000000000000000000000000..a476143a5c5cc1963a4bc2ecbdf1218b819fe2a8
GIT binary patch
literal 11600
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
literal 0
HcmV?d00001
diff --git a/openmp_testing/__init__.py b/openmp_testing/__init__.py
new file mode 100644
index 0000000..718e328
--- /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 0000000..395625f
--- /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 0000000..730e069
--- /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 0000000..8c23810
--- /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 0000000..720821f
--- /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 0000000..e683b52
--- /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 0000000..890ec82
--- /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 0000000..6f3a8a0
--- /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 0000000..7317efd
--- /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 0000000..6c4332b
--- /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()
--
GitLab