Move is_atomic_size_supported() to base.

It's a common function between rdma and ucx, put it
somewhere both can access it.

Signed-off-by: Austen Lauria <awlauria@us.ibm.com>

Author: awlauria

ompi/mca/osc/base/base.h

@@ -7,7 +7,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
- * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
+ * Copyright (c) 2016-2021 IBM Corporation. All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -50,6 +50,17 @@ int ompi_osc_base_finalize(void);
 
 OMPI_DECLSPEC extern mca_base_framework_t ompi_osc_base_framework;
 
+
+/* Helper to check whether osc can support atomic operation on the size the operands
+ * Currently used with rdma and ucx.
+ */
+static inline __opal_attribute_always_inline__ bool ompi_osc_base_is_atomic_size_supported(uint64_t remote_addr,
+                                                                                           size_t size)
+{
+    return ((sizeof(uint32_t) == size && !(remote_addr & 0x3)) ||
+            (sizeof(uint64_t) == size && !(remote_addr & 0x7)));
+}
+
 END_C_DECLS
 
 #endif

ompi/mca/osc/rdma/osc_rdma_accumulate.c

@@ -20,6 +20,7 @@
 #include "osc_rdma_request.h"
 #include "osc_rdma_comm.h"
 
+#include "ompi/mca/osc/base/base.h"
 #include "ompi/mca/osc/base/osc_base_obj_convert.h"
 
 static inline void ompi_osc_rdma_peer_accumulate_cleanup (ompi_osc_rdma_module_t *module, ompi_osc_rdma_peer_t *peer, bool lock_acquired)
@@ -331,13 +332,6 @@ static inline int ompi_osc_rdma_gacc_amo (ompi_osc_rdma_module_t *module, ompi_o
     return OMPI_SUCCESS;
 }
 
-static inline __opal_attribute_always_inline__ bool ompi_osc_rdma_is_atomic_size_supported(uint64_t remote_addr,
-                                                                                           size_t size)
-{
-    return ((sizeof(uint32_t) == size && !(remote_addr & 0x3)) ||
-            (sizeof(uint64_t) == size && !(remote_addr & 0x7)));
-}
-
 static inline int ompi_osc_rdma_gacc_contig (ompi_osc_rdma_sync_t *sync, const void *source, int source_count,
                                              ompi_datatype_t *source_datatype, void *result, int result_count,
                                              ompi_datatype_t *result_datatype, opal_convertor_t *result_convertor,
@@ -360,7 +354,7 @@ static inline int ompi_osc_rdma_gacc_contig (ompi_osc_rdma_sync_t *sync, const v
      * the atomic operation. this should be safe in all cases as either 1) the user has assured us they will
      * never use atomics with count > 1, 2) we have the accumulate lock, or 3) we have an exclusive lock */
     if ((target_dtype_size <= 8) && (((unsigned long) target_count) <= module->network_amo_max_count) &&
-         ompi_osc_rdma_is_atomic_size_supported(target_address, target_dtype_size)) {
+         ompi_osc_base_is_atomic_size_supported(target_address, target_dtype_size)) {
         ret = ompi_osc_rdma_gacc_amo (module, sync, source, result, result_count, result_datatype, result_convertor,
                                       peer, target_address, target_handle, target_count, target_datatype, op, request);
         if (OPAL_LIKELY(OMPI_SUCCESS == ret)) {

ompi/mca/osc/ucx/osc_ucx_comm.c

@@ -2,6 +2,7 @@
  * Copyright (C) 2001-2017 Mellanox Technologies Ltd. ALL RIGHTS RESERVED.
  * Copyright (c) 2019-2020 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2021      IBM Corporation. All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,14 +27,6 @@
         return OMPI_ERROR;                                                       \
     }
 
-/* helper to check whether UCX supports atomic operation on the size the operands */
-static inline __opal_attribute_always_inline__ bool is_atomic_size_supported(uint64_t remote_addr,
-                                                                             size_t size)
-{
-    return ((sizeof(uint32_t) == size && !(remote_addr & 0x3)) ||
-            (sizeof(uint64_t) == size && !(remote_addr & 0x7)));
-}
-
 typedef struct ucx_iovec {
     void *addr;
     size_t len;
@@ -403,7 +396,7 @@ bool use_atomic_op(
         ompi_datatype_type_size(origin_dt, &origin_dt_bytes);
         ompi_datatype_type_size(target_dt, &target_dt_bytes);
         /* UCX only supports 32 and 64-bit operands atm */
-        if (is_atomic_size_supported(remote_addr, origin_dt_bytes) &&
+        if (ompi_osc_base_is_atomic_size_supported(remote_addr, origin_dt_bytes) &&
             origin_dt_bytes == target_dt_bytes && origin_count == target_count) {
             return true;
         }
@@ -796,7 +789,7 @@ int ompi_osc_ucx_compare_and_swap(const void *origin_addr, const void *compare_a
     }
 
     ompi_datatype_type_size(dt, &dt_bytes);
-    if (is_atomic_size_supported(remote_addr, dt_bytes)) {
+    if (ompi_osc_base_is_atomic_size_supported(remote_addr, dt_bytes)) {
         // fast path using UCX atomic operations
         return do_atomic_compare_and_swap(origin_addr, compare_addr,
                                           result_addr, dt, target,
@@ -852,7 +845,7 @@ int ompi_osc_ucx_fetch_and_op(const void *origin_addr, void *result_addr,
     ompi_datatype_type_size(dt, &dt_bytes);
 
     /* UCX atomics are only supported on 32 and 64 bit values */
-    if (is_atomic_size_supported(remote_addr, dt_bytes) &&
+    if (ompi_osc_base_is_atomic_size_supported(remote_addr, dt_bytes) &&
         (op == &ompi_mpi_op_no_op.op || op == &ompi_mpi_op_replace.op ||
          op == &ompi_mpi_op_sum.op)) {
         uint64_t value;