Move yield capability to opal thread component

This adds three new mca parameters:
threads_pthreads_yield_strategy to choose the strategy (sched_yield, usleep, nanosleep),
threads_pthreads_usleep_time (time passed to usleep), and
threads_pthreads_nanosleep_time (time passed to nanosleep)

A thread component may also signal that yield-when-idle should be the default.

Signed-off-by: Joseph Schuchart <[email protected]>

Author: devreal

ompi/runtime/ompi_mpi_params.c

@@ -43,6 +43,8 @@
 #include "opal/util/show_help.h"
 #include "opal/runtime/opal.h"
 #include "opal/runtime/opal_params.h"
+#include "opal/mca/threads/threads.h"
+
 /*
  * Global variables
  *
@@ -62,7 +64,7 @@ bool ompi_mpi_keep_fqdn_hostnames = false;
 bool ompi_have_sparse_group_storage = OPAL_INT_TO_BOOL(OMPI_GROUP_SPARSE);
 bool ompi_use_sparse_group_storage = OPAL_INT_TO_BOOL(OMPI_GROUP_SPARSE);
 
-bool ompi_mpi_yield_when_idle = false;
+bool ompi_mpi_yield_when_idle;
 int ompi_mpi_event_tick_rate = -1;
 char *ompi_mpi_show_mca_params_string = NULL;
 bool ompi_mpi_have_sparse_group_storage = !!(OMPI_GROUP_SPARSE);
@@ -118,7 +120,9 @@ int ompi_mpi_register_params(void)
                                  OPAL_INFO_LVL_9,
                                  MCA_BASE_VAR_SCOPE_READONLY,
                                  &ompi_mpi_oversubscribe);
-    ompi_mpi_yield_when_idle = ompi_mpi_oversubscribe;
+
+    /* if the threads module requires yielding we use that as default but allow it to be overridden */
+    ompi_mpi_yield_when_idle = (OPAL_THREAD_YIELD_WHEN_IDLE_DEFAULT) ? OPAL_THREAD_YIELD_WHEN_IDLE_DEFAULT : ompi_mpi_oversubscribe;
     (void) mca_base_var_register("ompi", "mpi", NULL, "yield_when_idle",
                                  "Yield the processor when waiting for MPI communication (for MPI processes, will default to 1 when oversubscribing nodes)",
                                  MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,

opal/mca/threads/argobots/threads_argobots_threads.h

@@ -6,7 +6,7 @@
  * Copyright (c) 2004-2005 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ * Copyright (c) 2004-2020 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
@@ -37,4 +37,14 @@ struct opal_thread_t {
     void *t_ret;
 };
 
+
+/* Argobots are cooperatively scheduled so yield when idle */
+#define OPAL_THREAD_YIELD_WHEN_IDLE_DEFAULT true
+
+static inline
+void opal_thread_yield(void)
+{
+    ABT_thread_yield();
+}
+
 #endif /* OPAL_MCA_THREADS_ARGOBOTS_THREADS_ARGOBOTS_THREADS_H */

opal/mca/threads/pthreads/Makefile.am

@@ -29,4 +29,6 @@ libmca_threads_pthreads_la_SOURCES = \
     threads_pthreads_threads.h \
     threads_pthreads_tsd.h \
     threads_pthreads_wait_sync.c \
-    threads_pthreads_wait_sync.h
+    threads_pthreads_wait_sync.h \
+    threads_pthreads_yield.c \
+    threads_pthreads.h

opal/mca/threads/pthreads/threads_pthreads.h

@@ -0,0 +1,35 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2020      High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+
+#ifndef OPAL_MCA_THREADS_PTHREADS_THREADS_PTHREADS_H
+#define OPAL_MCA_THREADS_PTHREADS_THREADS_PTHREADS_H
+
+#include "opal_config.h"
+#include <stdint.h>
+
+typedef enum {
+    OPAL_PTHREADS_YIELD_SCHED_YIELD = 0,
+    OPAL_PTHREADS_YIELD_USLEEP      = 1,
+    OPAL_PTHREADS_YIELD_NANOSLEEP   = 2
+} opal_threads_pthreads_yield_strategy_t;
+
+/* The yield strategy to use */
+OPAL_DECLSPEC extern opal_threads_pthreads_yield_strategy_t opal_threads_pthreads_yield_strategy;
+
+/* The length to usleep, if enabled */
+OPAL_DECLSPEC extern uint64_t opal_threads_pthreads_yield_usleep;
+
+/* The length to nanosleep, if enabled */
+OPAL_DECLSPEC extern uint64_t opal_threads_pthreads_yield_nsleep;
+
+#endif /* OPAL_MCA_THREADS_PTHREADS_THREADS_PTHREADS_H */

opal/mca/threads/pthreads/threads_pthreads_component.c

@@ -23,11 +23,15 @@
 
 #include "opal_config.h"
 
+#include "opal/mca/threads/pthreads/threads_pthreads.h"
 #include "opal/mca/threads/thread.h"
 #include "opal/mca/threads/threads.h"
 #include "opal/constants.h"
+#include "opal/util/printf.h"
+
 
 static int opal_threads_pthreads_open(void);
+static int opal_threads_pthreads_register(void);
 
 const opal_threads_base_component_1_0_0_t mca_threads_pthreads_component = {
     /* First, the mca_component_t struct containing meta information
@@ -41,13 +45,41 @@ const opal_threads_base_component_1_0_0_t mca_threads_pthreads_component = {
                               OPAL_RELEASE_VERSION),
 
         .mca_open_component = opal_threads_pthreads_open,
+        .mca_register_component_params = opal_threads_pthreads_register
     },
     .threadsc_data = {
         /* The component is checkpoint ready */
         MCA_BASE_METADATA_PARAM_CHECKPOINT
     },
 };
 
+int opal_threads_pthreads_register(void)
+{
+    char * description_str;
+    opal_asprintf(&description_str, "Pthread yield strategy to use (0: sched_yield, 1: usleep, 2: nanosleep (default: %d)",
+                  opal_threads_pthreads_yield_strategy);
+    (void) mca_base_component_var_register(&mca_threads_pthreads_component.threadsc_version, "yield_strategy", description_str,
+                                           MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0, OPAL_INFO_LVL_3,
+                                           MCA_BASE_VAR_SCOPE_CONSTANT, &opal_threads_pthreads_yield_strategy);
+    free(description_str);
+
+    opal_asprintf(&description_str, "Number of microseconds to sleep when using usleep as the pthread yield strategy (default: %ld)",
+                  opal_threads_pthreads_yield_usleep);
+    (void) mca_base_component_var_register(&mca_threads_pthreads_component.threadsc_version, "usleep_time", description_str,
+                                           MCA_BASE_VAR_TYPE_UINT64_T, NULL, 0, 0, OPAL_INFO_LVL_3,
+                                           MCA_BASE_VAR_SCOPE_CONSTANT, &opal_threads_pthreads_yield_usleep);
+    free(description_str);
+
+    opal_asprintf(&description_str, "Number of nanoseconds to sleep when using nanosleep as the pthread yield strategy (default: %ld)",
+                  opal_threads_pthreads_yield_nsleep);
+    (void) mca_base_component_var_register(&mca_threads_pthreads_component.threadsc_version, "nanosleep_time", description_str,
+                                           MCA_BASE_VAR_TYPE_UINT64_T, NULL, 0, 0, OPAL_INFO_LVL_3,
+                                           MCA_BASE_VAR_SCOPE_CONSTANT, &opal_threads_pthreads_yield_nsleep);
+    free(description_str);
+
+    return OPAL_SUCCESS;
+}
+
 int opal_threads_pthreads_open(void)
 {
     return OPAL_SUCCESS;

opal/mca/threads/pthreads/threads_pthreads_threads.h

@@ -6,7 +6,7 @@
  * Copyright (c) 2004-2006 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ * Copyright (c) 2004-2020 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
@@ -37,4 +37,7 @@ struct opal_thread_t {
     pthread_t t_handle;
 };
 
+/* Pthreads do not need to yield when idle */
+#define OPAL_THREAD_YIELD_WHEN_IDLE_DEFAULT false
+
 #endif /* OPAL_MCA_THREADS_PTHREADS_THREADS_PTHREADS_THREADS_H */

opal/mca/threads/pthreads/threads_pthreads_yield.c

@@ -0,0 +1,54 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2020      High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <unistd.h>
+#include <time.h>
+#ifdef HAVE_SCHED_H
+#include <sched.h>
+#endif
+
+#include "opal/mca/threads/threads.h"
+#include "opal/mca/threads/pthreads/threads_pthreads.h"
+#include "opal/sys/atomic.h"
+
+
+opal_threads_pthreads_yield_strategy_t opal_threads_pthreads_yield_strategy = OPAL_PTHREADS_YIELD_SCHED_YIELD;
+uint64_t opal_threads_pthreads_yield_usleep = 1;
+uint64_t opal_threads_pthreads_yield_nsleep = 100;
+
+
+void opal_thread_yield(void)
+{
+    switch (opal_threads_pthreads_yield_strategy) {
+    case OPAL_PTHREADS_YIELD_SCHED_YIELD:
+#ifdef HAVE_SCHED_H
+        sched_yield();
+        break;
+#endif
+        /* fall-through if sched_yield is not available */
+    case OPAL_PTHREADS_YIELD_USLEEP:
+        usleep(opal_threads_pthreads_yield_usleep);
+        break;
+    case OPAL_PTHREADS_YIELD_NANOSLEEP:
+    {
+        static struct timespec sleeptime = {.tv_sec = -1, .tv_nsec = -1};
+        if (OPAL_UNLIKELY(-1 == sleeptime.tv_nsec)) {
+            sleeptime.tv_sec  = opal_threads_pthreads_yield_nsleep / 1E9;
+            opal_atomic_wmb();
+            sleeptime.tv_nsec = opal_threads_pthreads_yield_nsleep - (sleeptime.tv_sec*(uint64_t)1E9);
+        }
+        nanosleep(&sleeptime, NULL);
+        break;
+    }
+    }
+}
+

opal/mca/threads/qthreads/threads_qthreads_threads.h

@@ -6,7 +6,7 @@
  * Copyright (c) 2004-2005 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ * Copyright (c) 2004-2020 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
@@ -37,4 +37,13 @@ struct opal_thread_t {
     void *t_ret;
 };
 
+/* Qthreads are cooperatively scheduled so yield when idle */
+#define OPAL_THREAD_YIELD_WHEN_IDLE_DEFAULT true
+
+static inline
+void opal_thread_yield(void)
+{
+    qthread_yield();
+}
+
 #endif /* OPAL_MCA_THREADS_QTHREADS_THREADS_QTHREADS_THREADS_H */

opal/mca/threads/threads.h

@@ -132,6 +132,7 @@ OPAL_DECLSPEC bool opal_thread_self_compare(opal_thread_t *);
 OPAL_DECLSPEC opal_thread_t *opal_thread_get_self(void);
 OPAL_DECLSPEC void opal_thread_kill(opal_thread_t *, int sig);
 OPAL_DECLSPEC void opal_thread_set_main(void);
+OPAL_DECLSPEC void opal_thread_yield(void);
 
 END_C_DECLS
 

opal/runtime/opal_progress.c

@@ -25,10 +25,6 @@
 
 #include "opal_config.h"
 
-#ifdef HAVE_SCHED_H
-#include <sched.h>
-#endif
-
 #include "opal/runtime/opal_progress.h"
 #include "opal/mca/event/event.h"
 #include "opal/mca/base/mca_base_var.h"
@@ -37,6 +33,7 @@
 #include "opal/util/output.h"
 #include "opal/runtime/opal_params.h"
 #include "opal/runtime/opal.h"
+#include "opal/mca/threads/threads.h"
 
 #define OPAL_PROGRESS_USE_TIMERS (OPAL_TIMER_CYCLE_SUPPORTED || OPAL_TIMER_USEC_SUPPORTED)
 #define OPAL_PROGRESS_ONLY_USEC_NATIVE (OPAL_TIMER_USEC_NATIVE && !OPAL_TIMER_CYCLE_NATIVE)
@@ -66,7 +63,7 @@ static volatile opal_progress_callback_t *callbacks_lp = NULL;
 static size_t callbacks_lp_len = 0;
 static size_t callbacks_lp_size = 0;
 
-/* do we want to call sched_yield() if nothing happened */
+/* do we want to yield() if nothing happened */
 bool opal_progress_yield_when_idle = false;
 
 #if OPAL_PROGRESS_USE_TIMERS
@@ -213,7 +210,7 @@ static int opal_progress_events(void)
  * be called.  We don't propogate errors from the progress functions,
  * so no action is taken if they return failures.  The functions are
  * expected to return the number of events progressed, to determine
- * whether or not we should call sched_yield() during MPI progress.
+ * whether or not we should yield the CPU during MPI progress.
  * This is only losely tracked, as an error return can cause the number
  * of progressed events to appear lower than it actually is.  We don't
  * care, as the cost of that happening is far outweighed by the cost
@@ -247,16 +244,16 @@ opal_progress(void)
         opal_progress_events();
     }
 
-#if OPAL_HAVE_SCHED_YIELD
     if (opal_progress_yield_when_idle && events <= 0) {
         /* If there is nothing to do - yield the processor - otherwise
          * we could consume the processor for the entire time slice. If
          * the processor is oversubscribed - this will result in a best-case
          * latency equivalent to the time-slice.
+         * With some thread implementations, yielding might be required
+         * to ensure correct scheduling of all communicating threads.
          */
-        sched_yield();
+        opal_thread_yield();
     }
-#endif  /* defined(HAVE_SCHED_YIELD) */
 }