OMP_WAIT_POLICY changes.

[jlpeyton]

Summary

This change has OMP_WAIT_POLICY=active to mean that threads will busy-wait in spin loops and virtually never go to sleep. OMP_WAIT_POLICY=passive now means that threads will immediately go to sleep inside a spin loop. KMP_BLOCKTIME was the previous mechanism to specify this behavior via KMP_BLOCKTIME=0 or KMP_BLOCKTIME=infinite, but the standard OpenMP environment variable should also be able to specify this behavior.

[hfinkel]

This change has OMP_WAIT_POLICY=active to mean that threads will busy-wait in spin loops and virtually never go to sleep. OMP_WAIT_POLICY=passive now means that threads will immediately go to sleep inside a spin loop. KMP_BLOCKTIME was the previous mechanism to specify this behavior via KMP_BLOCKTIME=0 or KMP_BLOCKTIME=infinite, but the standard OpenMP environment variable should also be able to specify this behavior.

To clarify, is this a change in behavior for OMP_WAIT_POLICY=active, or just for OMP_WAIT_POLICY=passive?

[AndreyChurbanov]

To clarify, is this a change in behavior for OMP_WAIT_POLICY=active, or just for OMP_WAIT_POLICY=passive?

Both actually.

A bit more details: earlier the OMP_WAIT_POLICY was attributed to the KMP_LIBRARY functionality, so the difference between active and passive behavior was the presence of "yield" calls for passive. Thus the majority of applications don't see any difference because of setting OMP_WAIT_POLICY. The blocktime affects performance much stronger than yields, so we decided to make the OMP_WAIT_POLICY more sensitive and added the functionality of KMP_BLOCKTIME to it.

In summary:
Old:

OMP_WAIT_POLICY-active
  threads spin for the default blocktime, no yields, then go to sleep.
OMP_WAIT_POLICY=passive
  threads spin for the default blocktime calling yields, then go to sleep.

New:

OMP_WAIT_POLICY-active
  threads spin forever, no yields.
OMP_WAIT_POLICY=passive
  threads do not spin, go to sleep immediately.

Of cause additional setting of the KMP_BLOCKTIME will change the behavior.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp_settings.c

 } // __kmp_stg_print_inherit_fp_control
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
 // -------------------------------------------------------------------------------------------------
 // KMP_LIBRARY, OMP_WAIT_POLICY
 // -------------------------------------------------------------------------------------------------
 
+static char const *blocktime_str = NULL;
+
 static void
 __kmp_stg_parse_wait_policy( char const * name, char const * value, void * data ) {
 
     kmp_stg_wp_data_t * wait = (kmp_stg_wp_data_t *) data;
     int                 rc;
 
     rc = __kmp_stg_check_rivals( name, value, wait->rivals );
     if ( rc ) {
         return;
     }; // if
 
     if ( wait->omp ) {
         if ( __kmp_str_match( "ACTIVE", 1, value ) ) {
             __kmp_library = library_turnaround;
+            if ( blocktime_str == NULL ) {
+                // KMP_BLOCKTIME not specified, so set default to "infinite".
+                __kmp_dflt_blocktime = KMP_MAX_BLOCKTIME;
+            }
         } else if ( __kmp_str_match( "PASSIVE", 1, value ) ) {
             __kmp_library = library_throughput;
+            if ( blocktime_str == NULL ) {
+                // KMP_BLOCKTIME not specified, so set default to 0.
+                __kmp_dflt_blocktime = 0;
+            }
         } else {
             KMP_WARNING( StgInvalidValue, name, value );
         }; // if
     } else {
         if ( __kmp_str_match( "serial", 1, value ) ) {             /* S */
            __kmp_library = library_serial;
         } else if ( __kmp_str_match( "throughput", 2, value ) ) {  /* TH */
            __kmp_library = library_throughput;
for ( i = 0; i < block.count; ++ i ) {
             continue;
         }
         kmp_setting_t * setting = __kmp_stg_find( block.vars[ i ].name );
         if ( setting != NULL ) {
             setting->set = 1;
         }
     }; // for i
 
+    // We need to know if blocktime was set when processing OMP_WAIT_POLICY
+    blocktime_str = __kmp_env_blk_var( & block, "KMP_BLOCKTIME" );
+
     // Special case. If we parse environment, not a string, process KMP_WARNINGS first.
     if ( string == NULL ) {
         char const * name  = "KMP_WARNINGS";
         char const * value = __kmp_env_blk_var( & block, name );
         __kmp_stg_parse( name, value );
     }; // if
 
 #if KMP_AFFINITY_SUPPORTED

openmp/trunk/runtime/test/env/omp_wait_policy.c

+// RUN: %libomp-compile && env OMP_WAIT_POLICY=active %libomp-run active
+// RUN: %libomp-compile && env OMP_WAIT_POLICY=passive %libomp-run passive
+//
+// OMP_WAIT_POLICY=active should imply blocktime == INT_MAX 
+// i.e., threads spin-wait forever
+// OMP_WAIT_POLICY=passive should imply blocktime == 0 
+// i.e., threads immediately sleep
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include "omp_testsuite.h"
+
+void usage() {
+    fprintf(stderr, "usage: omp_wait_policy active|passive\n");
+}
+
+int main(int argc, char** argv)
+{
+  int blocktime, retval=1;
+  const char* env_var_value;
+
+  if (argc != 2) {
+    usage();
+    return 1;
+  }
+
+  blocktime = kmp_get_blocktime();
+  
+  env_var_value = argv[1];
+  if (!strcmp(env_var_value, "active")) {
+    retval = (blocktime != INT_MAX);
+  } else if (!strcmp(env_var_value, "passive")) {
+    retval = (blocktime != 0);
+  } else {
+    usage();
+    retval = 1;
+  }
+
+  return retval;
+}