- openmp stubs

Makefile.am

@@ -2,6 +2,7 @@
 #
 # Copyright (C) 2009-2013  Université de Bordeaux 1
 # Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+# Copyright (C) 2014  Inria
 #
 # StarPU is free software; you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published by
@@ -65,6 +66,7 @@ versinclude_HEADERS = 				\
 	include/starpu_fxt.h			\
 	include/starpu_cuda.h			\
 	include/starpu_opencl.h			\
+	include/starpu_openmp.h			\
 	include/starpu_sink.h			\
 	include/starpu_mic.h			\
 	include/starpu_scc.h			\

configure.ac

@@ -3,7 +3,7 @@
 # Copyright (C) 2009-2014  Université de Bordeaux 1
 # Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
 # Copyright (C) 2011  Télécom-SudParis
-# Copyright (C) 2011, 2012  Institut National de Recherche en Informatique et Automatique
+# Copyright (C) 2011, 2012, 2014  Institut National de Recherche en Informatique et Automatique
 #
 # StarPU is free software; you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published by
@@ -2006,6 +2006,7 @@ if test x$enable_openmp = xyes; then
 	AC_DEFINE(STARPU_OPENMP, 1, [Define this to enable OpenMP runtime support])
 fi
 
+AM_CONDITIONAL([STARPU_OPENMP], [test "x$enable_openmp" = "xyes"])
 AC_MSG_RESULT($enable_openmp)
 
 ###############################################################################

include/starpu.h

@@ -2,6 +2,7 @@
  *
  * Copyright (C) 2009-2013  Université de Bordeaux 1
  * Copyright (C) 2010-2014  Centre National de la Recherche Scientifique
+ * Copyright (C) 2014  Inria
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -66,6 +67,7 @@ typedef UINT_PTR uintptr_t;
 #include <starpu_fxt.h>
 #include <starpu_driver.h>
 #include <starpu_tree.h>
+#include <starpu_openmp.h>
 
 #ifdef __cplusplus
 extern "C"

include/starpu_config.h.in

@@ -2,6 +2,7 @@
  *
  * Copyright (C) 2009-2014  Université de Bordeaux 1
  * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2014  Inria
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -28,6 +29,8 @@
 #undef STARPU_USE_MIC
 #undef STARPU_USE_SCC
 
+#undef STARPU_OPENMP
+
 #undef STARPU_SIMGRID
 
 #undef STARPU_HAVE_ICC

include/starpu_openmp.h

@@ -0,0 +1,101 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2014  Inria
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#ifndef __STARPU_OPENMP_H__
+#define __STARPU_OPENMP_H__
+
+#include <starpu_config.h>
+
+#if defined STARPU_OPENMP
+typedef void *starpu_omp_lock_t; /* TODO: select a proper type */
+typedef void *starpu_omp_nest_lock_t; /* TODO: select a proper type */
+
+typedef enum e_starpu_omp_sched
+{
+	starpu_omp_sched_undefined = 0,
+	starpu_omp_sched_static    = 1,
+	starpu_omp_sched_dynamic   = 2,
+	starpu_omp_sched_guided    = 3,
+	starpu_omp_sched_auto      = 4,
+} starpu_omp_sched_t;
+
+typedef enum e_starpu_omp_proc_bind
+{
+	starpu_omp_proc_bind_false  = 0,
+	starpu_omp_proc_bind_true   = 1,
+	starpu_omp_proc_bind_master = 2,
+	starpu_omp_proc_bind_close  = 3,
+	starpu_omp_proc_bind_spread = 4,
+} starpu_omp_proc_bind_t;
+
+#ifdef __cplusplus
+extern "C"
+{
+#define __STARPU_OMP_NOTHROW throw ()
+#else
+#define __STARPU_OMP_NOTHROW __attribute__((__nothrow__))
+#endif
+
+extern int starpu_omp_init(void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_shutdown(void) __STARPU_OMP_NOTHROW;
+
+extern void starpu_omp_set_num_threads(int threads) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_num_threads() __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_thread_num() __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_max_threads() __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_num_procs (void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_in_parallel (void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_dynamic (int dynamic_threads) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_dynamic (void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_nested (int nested) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_nested (void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_cancellation(void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_schedule (starpu_omp_sched_t kind, int modifier) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_get_schedule (starpu_omp_sched_t *kind, int *modifier) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_thread_limit (void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_max_active_levels (int max_levels) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_max_active_levels (void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_level (void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_ancestor_thread_num (int level) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_team_size (int level) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_active_level (void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_in_final(void) __STARPU_OMP_NOTHROW;
+extern starpu_omp_proc_bind_t starpu_omp_get_proc_bind(void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_default_device(int device_num) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_default_device(void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_num_devices(void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_num_teams(void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_get_team_num(void) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_is_initial_device(void) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_init_lock (starpu_omp_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_destroy_lock (starpu_omp_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_lock (starpu_omp_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_unset_lock (starpu_omp_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_test_lock (starpu_omp_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_init_nest_lock (starpu_omp_nest_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_destroy_nest_lock (starpu_omp_nest_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_set_nest_lock (starpu_omp_nest_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern void starpu_omp_unset_nest_lock (starpu_omp_nest_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern int starpu_omp_test_nest_lock (starpu_omp_nest_lock_t *lock) __STARPU_OMP_NOTHROW;
+extern double starpu_omp_get_wtime (void) __STARPU_OMP_NOTHROW;
+extern double starpu_omp_get_wtick (void) __STARPU_OMP_NOTHROW;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* STARPU_USE_OPENMP && !STARPU_DONT_INCLUDE_OPENMP_HEADERS */
+#endif /* __STARPU_OPENMP_H__ */

src/Makefile.am

@@ -2,7 +2,7 @@
 #
 # Copyright (C) 2009-2013  Université de Bordeaux 1
 # Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
-# Copyright (C) 2011  INRIA
+# Copyright (C) 2011, 2014  INRIA
 #
 # StarPU is free software; you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published by
@@ -224,6 +224,7 @@ libstarpu_@STARPU_EFFECTIVE_VERSION@_la_SOURCES = 		\
 	util/starpu_create_sync_task.c				\
 	util/file.c						\
 	util/misc.c						\
+	util/openmp_runtime_support.c				\
 	util/starpu_data_cpy.c					\
 	util/starpu_task_insert.c				\
 	util/starpu_task_insert_utils.c				\

src/util/openmp_runtime_support.c

@@ -0,0 +1,325 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2014  Inria
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#include <starpu.h>
+
+#ifdef STARPU_OPENMP
+#define __not_implemented__ do { fprintf (stderr, "omp lib function %s not implemented\n", __func__); abort(); } while (0)
+
+static double _starpu_omp_clock_ref = 0.0; /* clock reference for starpu_omp_get_wtick */
+
+/*
+ * Entry point to be called by the OpenMP runtime constructor
+ */
+int starpu_omp_init(void)
+{
+	int ret;
+
+	ret = starpu_init(0);
+	if(ret < 0)
+		return ret;
+
+	/* init clock reference for starpu_omp_get_wtick */
+	_starpu_omp_clock_ref = starpu_timing_now();
+
+	return 0;
+}
+
+void starpu_omp_shutdown(void)
+{
+	starpu_shutdown();
+}
+
+void starpu_omp_set_num_threads(int threads)
+{
+	(void) threads;
+	__not_implemented__;
+}
+
+int starpu_omp_get_num_threads()
+{
+	return starpu_cpu_worker_get_count();
+}
+
+int starpu_omp_get_thread_num()
+{
+	int tid = starpu_worker_get_id();
+	/* TODO: handle master thread case */
+	if (tid < 0)
+	{
+		fprintf(stderr, "starpu_omp_get_thread_num: no worker associated to this thread\n");
+		abort();
+	}
+	return tid;
+}
+
+int starpu_omp_get_max_threads()
+{
+	/* arbitrary limit */
+	return starpu_cpu_worker_get_count();
+}
+
+int starpu_omp_get_num_procs (void)
+{
+	/* starpu_cpu_worker_get_count defined as topology.ncpus */
+	return starpu_cpu_worker_get_count();
+}
+
+int starpu_omp_in_parallel (void)
+{
+	__not_implemented__;
+}
+
+void starpu_omp_set_dynamic (int dynamic_threads)
+{
+	(void) dynamic_threads;
+	/* TODO: dynamic adjustment of the number of threads is not supported for now */
+}
+
+int starpu_omp_get_dynamic (void)
+{
+	/* TODO: dynamic adjustment of the number of threads is not supported for now 
+	 * return false as required */
+	return 0;
+}
+
+void starpu_omp_set_nested (int nested)
+{
+	(void) nested;
+	/* TODO: nested parallelism not supported for now */
+}
+
+int starpu_omp_get_nested (void)
+{
+	/* TODO: nested parallelism not supported for now
+	 * return false as required */
+	return 0;
+}
+
+int starpu_omp_get_cancellation(void)
+{
+	/* TODO: cancellation not supported for now
+	 * return false as required */
+	return 0;
+}
+
+void starpu_omp_set_schedule (starpu_omp_sched_t kind, int modifier)
+{
+	(void) kind;
+	(void) modifier;
+	/* TODO: no starpu_omp scheduler scheme implemented for now */
+	__not_implemented__;
+	assert(kind >= 1 && kind <=4);
+}
+
+void starpu_omp_get_schedule (starpu_omp_sched_t *kind, int *modifier)
+{
+	(void) kind;
+	(void) modifier;
+	/* TODO: no starpu_omp scheduler scheme implemented for now */
+	__not_implemented__;
+}
+
+int starpu_omp_get_thread_limit (void)
+{
+	/* arbitrary limit */
+	return 1024;
+}
+
+void starpu_omp_set_max_active_levels (int max_levels)
+{
+	(void) max_levels;
+	/* TODO: nested parallelism not supported for now */
+}
+
+int starpu_omp_get_max_active_levels (void)
+{
+	/* TODO: nested parallelism not supported for now
+	 * assume a single level */
+	return 1;
+}
+
+int starpu_omp_get_level (void)
+{
+	/* TODO: nested parallelism not supported for now
+	 * assume a single level */
+	return 1;
+}
+
+int starpu_omp_get_ancestor_thread_num (int level)
+{
+	if (level == 0) {
+		return 0; /* spec required answer */
+	}
+
+	if (level == starpu_omp_get_level()) {
+		return starpu_omp_get_thread_num(); /* spec required answer */
+	}
+
+	/* TODO: nested parallelism not supported for now
+	 * assume ancestor is thread number '0' */
+	return 0;
+}
+
+int starpu_omp_get_team_size (int level)
+{
+	if (level == 0) {
+		return 1; /* spec required answer */
+	}
+
+	if (level == starpu_omp_get_level()) {
+		return starpu_omp_get_num_threads(); /* spec required answer */
+	}
+
+	/* TODO: nested parallelism not supported for now
+	 * assume the team size to be the number of cpu workers */
+	return starpu_cpu_worker_get_count();
+}
+
+int starpu_omp_get_active_level (void)
+{
+	/* TODO: nested parallelism not supported for now
+	 * assume a single active level */
+	return 1;
+}
+
+int starpu_omp_in_final(void)
+{
+	/* TODO: final not supported for now
+	 * assume not in final */
+	return 0;
+}
+
+starpu_omp_proc_bind_t starpu_omp_get_proc_bind(void)
+{
+	/* TODO: proc_bind not supported for now
+	 * assumre false */
+	return starpu_omp_proc_bind_false;
+}
+
+void starpu_omp_set_default_device(int device_num)
+{
+	(void) device_num;
+	/* TODO: set_default_device not supported for now */
+}
+
+int starpu_omp_get_default_device(void)
+{
+	/* TODO: set_default_device not supported for now
+	 * assume device 0 as default */
+	return 0;
+}
+
+int starpu_omp_get_num_devices(void)
+{
+	/* TODO: get_num_devices not supported for now
+	 * assume 1 device */
+	return 1;
+}
+
+int starpu_omp_get_num_teams(void)
+{
+	/* TODO: num_teams not supported for now
+	 * assume 1 team */
+	return 1;
+}
+
+int starpu_omp_get_team_num(void)
+{
+	/* TODO: team_num not supported for now
+	 * assume team_num 0 */
+	return 0;
+}
+
+int starpu_omp_is_initial_device(void)
+{
+	/* TODO: is_initial_device not supported for now
+	 * assume host device */
+	return 1;
+}
+
+
+void starpu_omp_init_lock (starpu_omp_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_destroy_lock (starpu_omp_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_set_lock (starpu_omp_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_unset_lock (starpu_omp_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+int starpu_omp_test_lock (starpu_omp_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_init_nest_lock (starpu_omp_nest_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_destroy_nest_lock (starpu_omp_nest_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_set_nest_lock (starpu_omp_nest_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+void starpu_omp_unset_nest_lock (starpu_omp_nest_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+int starpu_omp_test_nest_lock (starpu_omp_nest_lock_t *lock)
+{
+	(void) lock;
+	__not_implemented__;
+}
+
+double starpu_omp_get_wtime (void)
+{
+	return starpu_timing_now() - _starpu_omp_clock_ref;
+}
+
+double starpu_omp_get_wtick (void)
+{
+	/* arbitrary precision value */
+	return 1e-6;
+}
+#endif /* STARPU_OPENMP */