[OpenMP] Limit number of dispatch buffers

[jlpeyton]

Summary

This patch limits the number of dispatch buffers (used for loop worksharing construct) to between 1 and 4096.

[hbae]

LGTM

openmp/runtime/src/kmp.h

 #define KMP_MIN_INTERVAL 0
 #define KMP_MAX_INTERVAL (INT_MAX - 1)
 #define KMP_DEFAULT_INTERVAL 0
 
 #define KMP_MIN_CHUNK 1
 #define KMP_MAX_CHUNK (INT_MAX - 1)
 #define KMP_DEFAULT_CHUNK 1
 
+#define KMP_MIN_DISP_NUM_BUFF 1
 #define KMP_DFLT_DISP_NUM_BUFF 7
+#define KMP_MAX_DISP_NUM_BUFF 4096
+
 #define KMP_MAX_ORDERED 8
 
 #define KMP_MAX_FIELDS 32
 
 #define KMP_MAX_BRANCH_BITS 31
 
 #define KMP_MAX_ACTIVE_LEVELS_LIMIT INT_MAX
 

openmp/runtime/src/kmp_csupport.cpp

 void kmpc_set_defaults(char const *str) {
   // __kmp_aux_set_defaults initializes the library if needed
   __kmp_aux_set_defaults(str, KMP_STRLEN(str));
 }
 
 void kmpc_set_disp_num_buffers(int arg) {
   // ignore after initialization because some teams have already
   // allocated dispatch buffers
-  if (__kmp_init_serial == 0 && arg > 0)
+  if (__kmp_init_serial == FALSE && arg >= KMP_MIN_DISP_NUM_BUFF &&
+      arg <= KMP_MAX_DISP_NUM_BUFF) {
     __kmp_dispatch_num_buffers = arg;
   }
+}
 
 int kmpc_set_affinity_mask_proc(int proc, void **mask) {
 #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
   return -1;
 #else
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }

openmp/runtime/src/kmp_ftn_entry.h

 /*
  * kmp_ftn_entry.h -- Fortran entry linkage support for OpenMP.
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FTN_STDCALL
 #error The support file kmp_ftn_entry.h should not be compiled by itself.
 #endif
 
 #ifdef KMP_STUB
 #include "kmp_stub.h"
 #endif
 
 #include "kmp_i18n.h"
 

 
 // This macro helps to reduce code duplication.
 #ifdef PASS_ARGS_BY_VALUE
 #define KMP_DEREF
 #else
 #define KMP_DEREF *
 #endif
 
 void FTN_STDCALL FTN_SET_STACKSIZE(int KMP_DEREF arg) {
 #ifdef KMP_STUB
   __kmps_set_stacksize(KMP_DEREF arg);
 #else
   // __kmp_aux_set_stacksize initializes the library if needed
   __kmp_aux_set_stacksize((size_t)KMP_DEREF arg);
 #endif
 }
 

 }
 
 void FTN_STDCALL FTN_SET_DISP_NUM_BUFFERS(int KMP_DEREF arg) {
 #ifdef KMP_STUB
   ; // empty routine
 #else
   // ignore after initialization because some teams have already
   // allocated dispatch buffers
-  if (__kmp_init_serial == 0 && (KMP_DEREF arg) > 0)
-    __kmp_dispatch_num_buffers = KMP_DEREF arg;
+  int num_buffers = KMP_DEREF arg;
+  if (__kmp_init_serial == FALSE && num_buffers >= KMP_MIN_DISP_NUM_BUFF &&
+      num_buffers <= KMP_MAX_DISP_NUM_BUFF) {
+    __kmp_dispatch_num_buffers = num_buffers;
+  }
 #endif
 }
 
 int FTN_STDCALL FTN_SET_AFFINITY(void **mask) {
 #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
   return -1;
 #else
   if (!TCR_4(__kmp_init_middle)) {
public:
   const char *get() const { return buf; }
 };
 #endif // KMP_STUB
 
 /*
  * Set the value of the affinity-format-var ICV on the current device to the
  * format specified in the argument.
 */
 void FTN_STDCALL FTN_SET_AFFINITY_FORMAT(char const *format, size_t size) {
 #ifdef KMP_STUB
   return;
 #else
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   ConvertedString cformat(format, size);
   // Since the __kmp_affinity_format variable is a C string, do not
#else
   __kmp_entry_thread()->th.th_current_task->td_icvs.default_device =
       KMP_DEREF arg;
 #endif
 }
 
 // Get number of NON-HOST devices.
 // libomptarget, if loaded, provides this function in api.cpp.
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) {
 #if KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
   return 0;
 #else
   int (*fptr)();
   if ((*(void **)(&fptr) = dlsym(RTLD_DEFAULT, "_Offload_number_of_devices"))) {
     return (*fptr)();
   } else if ((*(void **)(&fptr) = dlsym(RTLD_NEXT, "omp_get_num_devices"))) {
     return (*fptr)();
   } else { // liboffload & libomptarget don't exist
     return 0;
   }
 #endif // KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
 }
 
 // This function always returns true when called on host device.
 // Compiler/libomptarget should handle when it is called inside target region.
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) {
   return 1; // This is the host
 }
 
 // libomptarget, if loaded, provides this function
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) {
 #if KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
   // same as omp_get_num_devices()
   return 0;
 #else
   int (*fptr)();
   if ((*(void **)(&fptr) = dlsym(RTLD_NEXT, "omp_get_initial_device"))) {
     return (*fptr)();
   } else { // liboffload & libomptarget don't exist
     // same as omp_get_num_devices()
     return 0;
   }

 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_MAX_TASK_PRIORITY)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   return __kmp_max_task_priority;
 #endif
 }
 
 // This function will be defined in libomptarget. When libomptarget is not
 // loaded, we assume we are on the host and return KMP_HOST_DEVICE.
 // Compiler/libomptarget will handle this if called inside target.
 int FTN_STDCALL FTN_GET_DEVICE_NUM(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL FTN_GET_DEVICE_NUM(void) { return FTN_GET_INITIAL_DEVICE(); }
 
/* These following sections create versioned symbols for the
    retaining the default version which libomp uses: VERSION (defined in
    exports_so.txt). If you want to see the versioned symbols for libgomp.so.1
    then just type:
 
    objdump -T /path/to/libgomp.so.1 | grep omp_
 
    Example:
    Step 1) Create __kmp_api_omp_set_num_threads_10_alias which is alias of
      __kmp_api_omp_set_num_threads
    Step 2) Set __kmp_api_omp_set_num_threads_10_alias to version:
      omp_set_num_threads@OMP_1.0
    Step 2B) Set __kmp_api_omp_set_num_threads to default version:
      omp_set_num_threads@@VERSION
 */
 
 // OMP_1.0 versioned symbols
 KMP_VERSION_SYMBOL(FTN_SET_NUM_THREADS, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_NUM_THREADS, 10, "OMP_1.0");

openmp/runtime/src/kmp_settings.cpp

 // -----------------------------------------------------------------------------
 // KMP_DISP_NUM_BUFFERS
 static void __kmp_stg_parse_disp_buffers(char const *name, char const *value,
                                          void *data) {
   if (TCR_4(__kmp_init_serial)) {
     KMP_WARNING(EnvSerialWarn, name);
     return;
   } // read value before serial initialization only
-  __kmp_stg_parse_int(name, value, 1, KMP_MAX_NTH, &__kmp_dispatch_num_buffers);
+  __kmp_stg_parse_int(name, value, KMP_MIN_DISP_NUM_BUFF, KMP_MAX_DISP_NUM_BUFF,
+                      &__kmp_dispatch_num_buffers);
 } // __kmp_stg_parse_disp_buffers
 
 static void __kmp_stg_print_disp_buffers(kmp_str_buf_t *buffer,
                                          char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_dispatch_num_buffers);
 } // __kmp_stg_print_disp_buffers
 
 #if KMP_NESTED_HOT_TEAMS

openmp/runtime/test/env/kmp_dispatch_buf_range.c

+// RUN: %libomp-compile
+// RUN: env KMP_DISP_NUM_BUFFERS=0 %libomp-run 2>&1 | FileCheck --check-prefix=SMALL %s
+// RUN: env KMP_DISP_NUM_BUFFERS=4097 %libomp-run 2>&1 | FileCheck --check-prefix=LARGE %s
+// SMALL: OMP: Warning
+// SMALL-SAME: KMP_DISP_NUM_BUFFERS
+// SMALL-SAME: too small
+// LARGE: OMP: Warning
+// LARGE-SAME: KMP_DISP_NUM_BUFFERS
+// LARGE-SAME: too large
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+  int i;
+  #pragma omp parallel for
+  for (i = 0; i < 1000; i++) {}
+  return EXIT_SUCCESS;
+}