Use struct-wrapped C11 atomics with explicit ordering

Author: devreal

ompi/communicator/comm_cid.c

@@ -58,7 +58,7 @@
 #include "pmix.h"
 
 /* for use when we don't have a PMIx that supports CID generation */
-opal_atomic_int64_t ompi_comm_next_base_cid = 1;
+opal_atomic_int64_t ompi_comm_next_base_cid = OPAL_ATOMIC_INIT(1);
 
 /* A macro comparing two CIDs */
 #define OMPI_COMM_CID_IS_LOWER(comm1,comm2) ( ((comm1)->c_index < (comm2)->c_index)? 1:0)

ompi/communicator/comm_request.c

@@ -18,6 +18,7 @@
  */
 
 #include "comm_request.h"
+#include "opal/sys/atomic.h"
 
 #include "opal/class/opal_free_list.h"
 #include "opal/include/opal/sys/atomic.h"
@@ -109,7 +110,7 @@ int ompi_comm_request_schedule_append_w_flags(ompi_comm_request_t *request, ompi
 static int ompi_comm_request_progress (void)
 {
     ompi_comm_request_t *request, *next;
-    static opal_atomic_int32_t progressing = 0;
+    static opal_atomic_int32_t progressing = OPAL_ATOMIC_INIT(0);
     int completed = 0;
 
     /* don't allow re-entry */
@@ -175,7 +176,7 @@ static int ompi_comm_request_progress (void)
     }
 
     opal_mutex_unlock (&ompi_comm_request_mutex);
-    progressing = 0;
+    opal_atomic_store_32(&progressing, 0);
 
     return completed;
 }

ompi/communicator/ft/comm_ft_detector.c

@@ -18,6 +18,7 @@
 #include "opal/mca/threads/threads.h"
 
 #include "ompi/runtime/params.h"
+#include "opal/sys/atomic.h"
 #include "ompi/communicator/communicator.h"
 #include "ompi/mca/pml/pml.h"
 #include "ompi/mca/bml/bml.h"
@@ -94,7 +95,7 @@ static opal_event_base_t* fd_event_base = NULL;
 static void fd_event_cb(int fd, short flags, void* pdetector);
 
 static bool comm_detector_use_thread = false;
-static opal_atomic_int32_t fd_thread_active = 0;
+static opal_atomic_int32_t fd_thread_active = OPAL_ATOMIC_INIT(0);
 static opal_thread_t fd_thread;
 static void* fd_progress(opal_object_t* obj);
 
@@ -168,8 +169,9 @@ int ompi_comm_failure_detector_init(void) {
         fd_thread.t_arg = NULL;
         ret = opal_thread_start(&fd_thread);
         if( OPAL_SUCCESS != ret ) goto cleanup;
-        while( 0 == fd_thread_active ); /* wait for the fd thread initialization */
-        if( 0 > fd_thread_active ) goto cleanup;
+        while (0 == opal_atomic_load_32(&fd_thread_active)) { /* wait for the fd thread initialization */
+        }
+        if (0 > opal_atomic_load_32(&fd_thread_active)) goto cleanup;
     }
 
     return OMPI_SUCCESS;
@@ -218,18 +220,19 @@ int ompi_comm_failure_detector_finalize(void) {
 #endif
         while( observing == detector->hb_observing ) {
             /* If observed process changed, recheck if local*/
-            if( !(0 < fd_thread_active) )
+            if (!(0 < opal_atomic_load_32(&fd_thread_active)))
             {
                 opal_progress();
             }
         }
     }
 
-    if( 0 < fd_thread_active ) {
+    if (0 < opal_atomic_load_32(&fd_thread_active)) {
         void* tret;
         /* this is not a race condition. Accesses are serialized, we use the
          * atomic for the mfence part of it. */
-        OPAL_THREAD_ADD_FETCH32(&fd_thread_active, -fd_thread_active);
+        int32_t active = opal_atomic_load_32(&fd_thread_active);
+        OPAL_THREAD_ADD_FETCH32(&fd_thread_active, -active);
         opal_event_base_loopbreak(fd_event_base);
         opal_thread_join(&fd_thread, &tret);
     }
@@ -587,9 +590,10 @@ void* fd_progress(opal_object_t* obj) {
         return OPAL_THREAD_CANCELLED;
     }
     OPAL_THREAD_ADD_FETCH32(&fd_thread_active, 1);
-    while( 1 == fd_thread_active ); /* wait for init stage 2: start_detector */
+    while (1 == opal_atomic_load_32(&fd_thread_active)) { /* wait for init stage 2: start_detector */
+    }
     ret = MCA_PML_CALL(irecv(NULL, 0, MPI_BYTE, 0, MCA_COLL_BASE_TAG_FT_END, &ompi_mpi_comm_self.comm, &req));
-    while( fd_thread_active ) {
+    while (opal_atomic_load_32(&fd_thread_active)) {
         opal_event_loop(fd_event_base, OPAL_EVLOOP_ONCE);
 #if 0
         /* This test disabled because rdma emulation over TCP would not work without

ompi/communicator/ft/comm_ft_reliable_bcast.c

@@ -18,6 +18,7 @@
 #include "ompi/mca/pml/pml.h"
 #include "ompi/mca/bml/bml.h"
 #include "ompi/mca/bml/base/base.h"
+#include "opal/sys/atomic.h"
 #include "ompi/mca/coll/base/base.h"
 #include "ompi/mca/coll/base/coll_tags.h"
 
@@ -208,7 +209,7 @@ static void ompi_comm_rbcast_bml_recv_cb(
          * that we keep receiving messages after we deregistered the type.
          * Any other time, this is indicative of a problem.
          */
-        assert(ompi_mpi_state >= OMPI_MPI_STATE_FINALIZE_STARTED);
+        assert(opal_atomic_load_32(&ompi_mpi_state) >= OMPI_MPI_STATE_FINALIZE_STARTED);
     }
 }
 

ompi/errhandler/errhandler.h

@@ -213,7 +213,7 @@ extern opal_atomic_int32_t ompi_instance_count;
  */
 #define OMPI_ERR_INIT_FINALIZE(name)                                       \
     {                                                                      \
-        if (OPAL_UNLIKELY(0 == ompi_instance_count)) {                     \
+        if (OPAL_UNLIKELY(0 == opal_atomic_load_32(&ompi_instance_count))) { \
             ompi_errhandler_invoke(NULL, NULL, -1,                         \
                                    ompi_errcode_get_mpi_code(MPI_ERR_ARG), \
                                    name);                                  \

ompi/errhandler/errhandler_invoke.c

@@ -47,7 +47,7 @@ int ompi_errhandler_invoke(ompi_errhandler_t *errhandler, void *mpi_object,
     /* If we got no errorhandler, then route the error to the appropriate
      * predefined error handler */
     if (NULL == errhandler) {
-        int32_t state = ompi_mpi_state;
+        int32_t state = opal_atomic_load_32(&ompi_mpi_state);
         if (state >= OMPI_MPI_STATE_INIT_COMPLETED &&
             state < OMPI_MPI_STATE_FINALIZE_PAST_COMM_SELF_DESTRUCT) {
             comm = (ompi_mpi_compat_mpi3)? &ompi_mpi_comm_world.comm: &ompi_mpi_comm_self.comm;

ompi/errhandler/errhandler_predefined.c

@@ -266,7 +266,7 @@ void ompi_mpi_errors_return_instance_handler (struct ompi_instance_t **instance,
 static void out(char *str, char *arg)
 {
     if (ompi_rte_initialized &&
-        ompi_mpi_state < OMPI_MPI_STATE_FINALIZE_PAST_COMM_SELF_DESTRUCT) {
+        opal_atomic_load_32(&ompi_mpi_state) < OMPI_MPI_STATE_FINALIZE_PAST_COMM_SELF_DESTRUCT) {
         if (NULL != arg) {
             opal_output(0, str, arg);
         } else {
@@ -400,7 +400,7 @@ static void backend_abort_no_aggregate(int fatal, char *type,
 {
     char *arg;
 
-    int32_t state = ompi_mpi_state;
+    int32_t state = opal_atomic_load_32(&ompi_mpi_state);
     assert(state < OMPI_MPI_STATE_INIT_COMPLETED ||
            state >= OMPI_MPI_STATE_FINALIZE_PAST_COMM_SELF_DESTRUCT);
 

ompi/instance/instance.c

@@ -90,7 +90,7 @@ enum {
     OMPI_INSTANCE_FINALIZING   = -2,
 };
 
-opal_atomic_int32_t ompi_instance_count = 0;
+opal_atomic_int32_t ompi_instance_count = OPAL_ATOMIC_INIT(0);
 
 static const char *ompi_instance_builtin_psets[] = {
     "mpi://WORLD",

ompi/mca/coll/hcoll/coll_hcoll_ops.c

@@ -16,13 +16,14 @@
 #include "hcoll/api/hcoll_constants.h"
 #include "coll_hcoll_dtypes.h"
 #include "hcoll/api/hcoll_dte.h"
+#include "opal/sys/atomic.h"
 int mca_coll_hcoll_barrier(struct ompi_communicator_t *comm,
                          mca_coll_base_module_t *module){
     int rc;
     mca_coll_hcoll_module_t *hcoll_module = (mca_coll_hcoll_module_t*)module;
     HCOL_VERBOSE(20,"RUNNING HCOL BARRIER");
 
-    if (OPAL_UNLIKELY(ompi_mpi_state >= OMPI_MPI_STATE_FINALIZE_STARTED)) {
+    if (OPAL_UNLIKELY(opal_atomic_load_32(&ompi_mpi_state) >= OMPI_MPI_STATE_FINALIZE_STARTED)) {
         HCOL_VERBOSE(5, "In finalize, reverting to previous barrier");
         goto orig_barrier;
     }

ompi/mca/common/monitoring/common_monitoring.c

@@ -39,7 +39,7 @@
 
 /*** Monitoring specific variables ***/
 /* Keep tracks of how many components are currently using the common part */
-static opal_atomic_int32_t mca_common_monitoring_hold = 0;
+static opal_atomic_int32_t mca_common_monitoring_hold = OPAL_ATOMIC_INIT(0);
 /* Output parameters */
 int mca_common_monitoring_output_stream_id = -1;
 static opal_output_stream_t mca_common_monitoring_output_stream_obj = {