Read OMP_TARGET_OFFLOAD and provide API to access ICV

[tlwilmar]

Summary

Added settings code to read OMP_TARGET_OFFLOAD environment variable. Added target-offload-var ICV as kmp_target_offload, set via OMP_TARGET_OFFLOAD, if available, otherwise defaulting to DEFAULT. Valid values for the ICV are specified as enum values {0,1,2} for disabled, default, and mandatory. An internal API access function kmpc_get_target_offload is provided.

[tlwilmar]

runtime/src/dllexports

406 ↗

(On Diff #138747)

I know this looks a bit funny, but we have another patch on the way to clean this up and put this properly under 5.0. %ifdef.

[grokos]

Question: If the ICV is set to DEFAULT, then libomptarget must change it to either MANDATORY (if there are available devices in the system) or DISABLED (if there are no devices). Should libomptarget notify libomp about this change?

[RaviNarayanaswamy]

DEFAULT implies MANDATORY or DISABLED. Don't need to communicate to libomp

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/dllexports

 kmpc_set_disp_num_buffers                   267
 
 # OpenMP 5.0 entry points
 # TODO: change to OMP_50 once it is implemented
 %ifndef stub
     %ifdef OMP_45
         __kmpc_task_reduction_init          268
         __kmpc_task_reduction_get_th_data   269
+        __kmpc_get_target_offload           271
     %endif
 %endif
 
 # User API entry points that have both lower- and upper- case versions for Fortran.
 # Number for lowercase version is indicated.  Number for uppercase is obtained by adding 1000.
 # User API entry points are entry points that start with 'kmp_' or 'omp_'.
 
 omp_destroy_lock                            700

openmp/trunk/runtime/src/kmp.h

 kmpc_get_affinity_mask_proc(int, kmp_affinity_mask_t *);
 
 KMP_EXPORT void KMPC_CONVENTION kmpc_set_stacksize(int);
 KMP_EXPORT void KMPC_CONVENTION kmpc_set_stacksize_s(size_t);
 KMP_EXPORT void KMPC_CONVENTION kmpc_set_library(int);
 KMP_EXPORT void KMPC_CONVENTION kmpc_set_defaults(char const *);
 KMP_EXPORT void KMPC_CONVENTION kmpc_set_disp_num_buffers(int);
 
+#if OMP_50_ENABLED
+enum kmp_target_offload_kind {
+  tgt_disabled = 0,
+  tgt_default = 1,
+  tgt_mandatory = 2
+};
+typedef enum kmp_target_offload_kind kmp_target_offload_kind_t;
+// Set via OMP_TARGET_OFFLOAD if specified, defaults to tgt_default otherwise
+extern kmp_target_offload_kind_t __kmp_target_offload;
+extern int __kmpc_get_target_offload();
+#endif
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* KMP_H */

openmp/trunk/runtime/src/kmp_csupport.cpp

void __kmpc_doacross_fini(ident_t *loc, int gtid) {
   }
   // free private resources (need to keep buffer index forever)
   __kmp_thread_free(th, (void *)pr_buf->th_doacross_info);
   pr_buf->th_doacross_info = NULL;
   KA_TRACE(20, ("__kmpc_doacross_fini() exit: T#%d\n", gtid));
 }
 #endif
 
+#if OMP_50_ENABLED
+int __kmpc_get_target_offload(void) { return __kmp_target_offload; }
+#endif // OMP_50_ENABLED
+
 // end of file //

openmp/trunk/runtime/src/kmp_global.cpp

 
 // Symbols for MS mutual detection.
 int _You_must_link_with_exactly_one_OpenMP_library = 1;
 int _You_must_link_with_Intel_OpenMP_library = 1;
 #if KMP_OS_WINDOWS && (KMP_VERSION_MAJOR > 4)
 int _You_must_link_with_Microsoft_OpenMP_library = 1;
 #endif
 
+#if OMP_50_ENABLED
+kmp_target_offload_kind_t __kmp_target_offload = tgt_default;
+#endif
 // end of file //

openmp/trunk/runtime/src/kmp_settings.cpp

 } // __kmp_stg_parse_default_device
 
 static void __kmp_stg_print_default_device(kmp_str_buf_t *buffer,
                                            char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_default_device);
 } // __kmp_stg_print_default_device
 #endif
 
+#if OMP_50_ENABLED
+// -----------------------------------------------------------------------------
+// OpenMP 5.0: OMP_TARGET_OFFLOAD
+static void __kmp_stg_parse_target_offload(char const *name, char const *value,
+                                           void *data) {
+  const char *next = value;
+  const char *scan = next;
+
+  __kmp_target_offload = tgt_default;
+  SKIP_WS(next);
+  if (*next == '\0')
+    return;
+  scan = next;
+  if (__kmp_match_str("MANDATORY", scan, &next)) {
+    __kmp_target_offload = tgt_mandatory;
+  } else if (__kmp_match_str("DISABLED", scan, &next)) {
+    __kmp_target_offload = tgt_disabled;
+  } else if (__kmp_match_str("DEFAULT", scan, &next)) {
+    __kmp_target_offload = tgt_default;
+  } else {
+    KMP_WARNING(SyntaxErrorUsing, name, "DEFAULT");
+  }
+
+} // __kmp_stg_parse_target_offload
+
+static void __kmp_stg_print_target_offload(kmp_str_buf_t *buffer,
+                                           char const *name, void *data) {
+  const char *value = NULL;
+  if (__kmp_target_offload == tgt_default)
+    value = "DEFAULT";
+  else if (__kmp_target_offload == tgt_mandatory)
+    value = "MANDATORY";
+  else if (__kmp_target_offload == tgt_disabled)
+    value = "DISABLED";
+  if (value) {
+    __kmp_str_buf_print(buffer, "   %s=%s\n", name, value);
+  }
+} // __kmp_stg_print_target_offload
+#endif
+
 #if OMP_45_ENABLED
 // -----------------------------------------------------------------------------
 // OpenMP 4.5: OMP_MAX_TASK_PRIORITY
 static void __kmp_stg_parse_max_task_priority(char const *name,
                                               char const *value, void *data) {
   __kmp_stg_parse_int(name, value, 0, KMP_MAX_TASK_PRIORITY_LIMIT,
                       &__kmp_max_task_priority);
 } // __kmp_stg_parse_max_task_priority
#endif
     {"KMP_TASK_STEALING_CONSTRAINT", __kmp_stg_parse_task_stealing,
      __kmp_stg_print_task_stealing, NULL, 0, 0},
     {"OMP_MAX_ACTIVE_LEVELS", __kmp_stg_parse_max_active_levels,
      __kmp_stg_print_max_active_levels, NULL, 0, 0},
 #if OMP_40_ENABLED
     {"OMP_DEFAULT_DEVICE", __kmp_stg_parse_default_device,
      __kmp_stg_print_default_device, NULL, 0, 0},
 #endif
+#if OMP_50_ENABLED
+    {"OMP_TARGET_OFFLOAD", __kmp_stg_parse_target_offload,
+     __kmp_stg_print_target_offload, NULL, 0, 0},
+#endif
 #if OMP_45_ENABLED
     {"OMP_MAX_TASK_PRIORITY", __kmp_stg_parse_max_task_priority,
      __kmp_stg_print_max_task_priority, NULL, 0, 0},
     {"KMP_TASKLOOP_MIN_TASKS", __kmp_stg_parse_taskloop_min_tasks,
      __kmp_stg_print_taskloop_min_tasks, NULL, 0, 0},
 #endif
     {"OMP_THREAD_LIMIT", __kmp_stg_parse_thread_limit,
      __kmp_stg_print_thread_limit, NULL, 0, 0},