Merge pull request #1478 from igor-ivanov/pr/oshmem-v1.3-alltoall

oshmem: Add alltoall

Author: mike-dubman

oshmem/include/shmem.h.in

@@ -101,13 +101,15 @@ enum shmem_wait_ops {
 #define _SHMEM_BCAST_SYNC_SIZE          (1 + _SHMEM_BARRIER_SYNC_SIZE)
 #define _SHMEM_COLLECT_SYNC_SIZE        (1 + _SHMEM_BCAST_SYNC_SIZE)
 #define _SHMEM_REDUCE_SYNC_SIZE         (1 + _SHMEM_BCAST_SYNC_SIZE)
+#define _SHMEM_ALLTOALL_SYNC_SIZE       (1)
 #define _SHMEM_REDUCE_MIN_WRKDATA_SIZE  (1)
 #define _SHMEM_SYNC_VALUE               (-1)
 
 #define SHMEM_BARRIER_SYNC_SIZE        _SHMEM_BARRIER_SYNC_SIZE
 #define SHMEM_BCAST_SYNC_SIZE          _SHMEM_BCAST_SYNC_SIZE
 #define SHMEM_COLLECT_SYNC_SIZE        _SHMEM_COLLECT_SYNC_SIZE
 #define SHMEM_REDUCE_SYNC_SIZE         _SHMEM_REDUCE_SYNC_SIZE
+#define SHMEM_ALLTOALL_SYNC_SIZE       _SHMEM_ALLTOALL_SYNC_SIZE
 #define SHMEM_REDUCE_MIN_WRKDATA_SIZE  _SHMEM_REDUCE_MIN_WRKDATA_SIZE
 #define SHMEM_SYNC_VALUE               _SHMEM_SYNC_VALUE
 
@@ -344,6 +346,11 @@ OSHMEM_DECLSPEC void shmem_collect32(void *target, const void *source, size_t nl
 OSHMEM_DECLSPEC void shmem_collect64(void *target, const void *source, size_t nlong, int PE_start, int logPE_stride, int PE_size, long *pSync);
 OSHMEM_DECLSPEC void shmem_fcollect32(void *target, const void *source, size_t nlong, int PE_start, int logPE_stride, int PE_size, long *pSync);
 OSHMEM_DECLSPEC void shmem_fcollect64(void *target, const void *source, size_t nlong, int PE_start, int logPE_stride, int PE_size, long *pSync);
+OSHMEM_DECLSPEC void shmem_alltoall32(void *target, const void *source, size_t nelems, int PE_start, int logPE_stride, int PE_size, long *pSync);
+OSHMEM_DECLSPEC void shmem_alltoall64(void *target, const void *source, size_t nelems, int PE_start, int logPE_stride, int PE_size, long *pSync);
+OSHMEM_DECLSPEC void shmem_alltoalls32(void *target, const void *source, ptrdiff_t dst, ptrdiff_t sst, size_t nelems, int PE_start, int logPE_stride, int PE_size, long *pSync);
+OSHMEM_DECLSPEC void shmem_alltoalls64(void *target, const void *source, ptrdiff_t dst, ptrdiff_t sst, size_t nelems, int PE_start, int logPE_stride, int PE_size, long *pSync);
+
 
 /*
  * Reduction routines

oshmem/mca/scoll/base/scoll_base_frame.c

@@ -46,6 +46,7 @@ static void scoll_base_module_construct(mca_scoll_base_module_t *m)
     m->scoll_broadcast = NULL;
     m->scoll_collect = NULL;
     m->scoll_reduce = NULL;
+    m->scoll_alltoall = NULL;
     m->scoll_module_enable = NULL;
 }
 

oshmem/mca/scoll/base/scoll_base_select.c

@@ -118,6 +118,22 @@ static int scoll_null_reduce(struct oshmem_group_t *group,
     return OSHMEM_SUCCESS;
 }
 
+static int scoll_null_alltoall(struct oshmem_group_t *group,
+                              void *target,
+                              const void *source,
+                              ptrdiff_t dst, ptrdiff_t sst,
+                              size_t nlong,
+                              long *pSync,
+                              int alg)
+{
+    if (oshmem_proc_group_is_member(group)) {
+        SCOLL_ERROR("internal error");
+        oshmem_shmem_abort(-1);
+        return OSHMEM_ERROR;
+    }
+    return OSHMEM_SUCCESS;
+}
+
 /*
  * Stuff for the OBJ interface
  */
@@ -160,6 +176,7 @@ int mca_scoll_base_group_unselect(struct oshmem_group_t * group)
     CLOSE(group, broadcast);
     CLOSE(group, collect);
     CLOSE(group, reduce);
+    CLOSE(group, alltoall);
 
     /* All done */
     return OSHMEM_SUCCESS;
@@ -184,6 +201,7 @@ int mca_scoll_base_select(struct oshmem_group_t *group)
         group->g_scoll.scoll_broadcast = scoll_null_broadcast;
         group->g_scoll.scoll_collect = scoll_null_collect;
         group->g_scoll.scoll_reduce = scoll_null_reduce;
+        group->g_scoll.scoll_alltoall = scoll_null_alltoall;
         return OSHMEM_SUCCESS;
     }
     SCOLL_VERBOSE(10,
@@ -206,10 +224,11 @@ int mca_scoll_base_select(struct oshmem_group_t *group)
         if (OSHMEM_SUCCESS != ret) {
             mca_scoll_base_group_unselect(group);
         } else {
+            COPY(avail->ac_module, group, barrier);
             COPY(avail->ac_module, group, broadcast);
             COPY(avail->ac_module, group, collect);
             COPY(avail->ac_module, group, reduce);
-            COPY(avail->ac_module, group, barrier);
+            COPY(avail->ac_module, group, alltoall);
         }
         OBJ_RELEASE(avail->ac_module);
         OBJ_RELEASE(avail);
@@ -220,16 +239,17 @@ int mca_scoll_base_select(struct oshmem_group_t *group)
     if ((NULL == group->g_scoll.scoll_barrier)
             || (NULL == group->g_scoll.scoll_broadcast)
             || (NULL == group->g_scoll.scoll_collect)
-            || (NULL == group->g_scoll.scoll_reduce)) {
+            || (NULL == group->g_scoll.scoll_reduce)
+            || (NULL == group->g_scoll.scoll_alltoall)) {
         mca_scoll_base_group_unselect(group);
         return OSHMEM_ERR_NOT_FOUND;
     }
 
     return OSHMEM_SUCCESS;
 }
 
-static int avail_coll_compare (opal_list_item_t **a,
-                               opal_list_item_t **b)
+static int avail_coll_compare(opal_list_item_t **a,
+                              opal_list_item_t **b)
 {
     avail_com_t *acom = (avail_com_t *) *a;
     avail_com_t *bcom = (avail_com_t *) *b;

oshmem/mca/scoll/basic/Makefile.am

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2013      Mellanox Technologies, Inc.
+# Copyright (c) 2013-2016 Mellanox Technologies, Inc.
 #                         All rights reserved.
 # $COPYRIGHT$
 #
@@ -15,7 +15,8 @@ sources = \
 	scoll_basic_barrier.c \
 	scoll_basic_broadcast.c \
 	scoll_basic_collect.c \
-	scoll_basic_reduce.c
+	scoll_basic_reduce.c \
+	scoll_basic_alltoall.c
 
 
 # Make the output library in this directory, and name it either

oshmem/mca/scoll/basic/scoll_basic.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013      Mellanox Technologies, Inc.
+ * Copyright (c) 2013-2016 Mellanox Technologies, Inc.
  *                         All rights reserved.
  * $COPYRIGHT$
  *
@@ -77,6 +77,14 @@ int mca_scoll_basic_reduce(struct oshmem_group_t *group,
                            long *pSync,
                            void *pWrk,
                            int alg);
+int mca_scoll_basic_alltoall(struct oshmem_group_t *group,
+                             void *target,
+                             const void *source,
+                             ptrdiff_t dst, ptrdiff_t sst,
+                             size_t nelems,
+                             size_t element_size,
+                             long *pSync,
+                             int alg);
 
 static inline unsigned int scoll_log2(unsigned long val)
 {

oshmem/mca/scoll/basic/scoll_basic_alltoall.c

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2016      Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "oshmem_config.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "oshmem/constants.h"
+#include "oshmem/op/op.h"
+#include "oshmem/mca/spml/spml.h"
+#include "oshmem/mca/scoll/scoll.h"
+#include "oshmem/mca/scoll/base/base.h"
+#include "scoll_basic.h"
+
+static int _algorithm_simple(struct oshmem_group_t *group,
+                             void *target,
+                             const void *source,
+                             ptrdiff_t dst, ptrdiff_t sst,
+                             size_t nelems,
+                             size_t element_size,
+                             long *pSync);
+
+int mca_scoll_basic_alltoall(struct oshmem_group_t *group,
+                             void *target,
+                             const void *source,
+                             ptrdiff_t dst, ptrdiff_t sst,
+                             size_t nelems,
+                             size_t element_size,
+                             long *pSync,
+                             int alg)
+{
+    int rc = OSHMEM_SUCCESS;
+
+    /* Arguments validation */
+    if (!group) {
+        SCOLL_ERROR("Active set (group) of PE is not defined");
+        rc = OSHMEM_ERR_BAD_PARAM;
+    }
+
+    /* Check if this PE is part of the group */
+    if ((rc == OSHMEM_SUCCESS) && oshmem_proc_group_is_member(group)) {
+        int i = 0;
+
+        if (pSync) {
+            rc = _algorithm_simple(group,
+                                   target,
+                                   source,
+                                   dst,
+                                   sst,
+                                   nelems,
+                                   element_size,
+                                   pSync);
+        } else {
+            SCOLL_ERROR("Incorrect argument pSync");
+            rc = OSHMEM_ERR_BAD_PARAM;
+        }
+
+        /* Restore initial values */
+        SCOLL_VERBOSE(12,
+                      "PE#%d Restore special synchronization array",
+                      group->my_pe);
+        for (i = 0; pSync && (i < _SHMEM_ALLTOALL_SYNC_SIZE); i++) {
+            pSync[i] = _SHMEM_SYNC_VALUE;
+        }
+    }
+
+    return rc;
+}
+
+static int _algorithm_simple(struct oshmem_group_t *group,
+                             void *target,
+                             const void *source,
+                             ptrdiff_t tst, ptrdiff_t sst,
+                             size_t nelems,
+                             size_t element_size,
+                             long *pSync)
+{
+    int rc = OSHMEM_SUCCESS;
+    int pe_cur;
+    int i;
+    int j;
+    int k;
+
+    SCOLL_VERBOSE(14,
+                  "[#%d] send data to all PE in the group",
+                  group->my_pe);
+    j = oshmem_proc_group_find_id(group, group->my_pe);
+    for (i = 0; i < group->proc_count; i++) {
+        /* index permutation for better distribution of traffic */
+        k = (((j)+(i))%(group->proc_count));
+        pe_cur = oshmem_proc_pe(group->proc_array[k]);
+        rc = MCA_SPML_CALL(put(
+                (void *)((char *)target + j * tst * nelems * element_size),
+                nelems * element_size,
+                (void *)((char *)source + i * sst * nelems * element_size),
+                pe_cur));
+        if (OSHMEM_SUCCESS != rc) {
+            break;
+        }
+    }
+
+    /* Wait for operation completion */
+    if (rc == OSHMEM_SUCCESS) {
+        SCOLL_VERBOSE(14, "[#%d] Wait for operation completion", group->my_pe);
+        rc = BARRIER_FUNC(group,
+                (pSync + 1),
+                SCOLL_DEFAULT_ALG);
+    }
+
+    return rc;
+}

oshmem/mca/scoll/basic/scoll_basic_module.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013      Mellanox Technologies, Inc.
+ * Copyright (c) 2013-2016 Mellanox Technologies, Inc.
  *                         All rights reserved.
  * $COPYRIGHT$
  *
@@ -52,9 +52,10 @@ mca_scoll_basic_query(struct oshmem_group_t *group, int *priority)
         module->super.scoll_broadcast = mca_scoll_basic_broadcast;
         module->super.scoll_collect = mca_scoll_basic_collect;
         module->super.scoll_reduce = mca_scoll_basic_reduce;
+        module->super.scoll_alltoall = mca_scoll_basic_alltoall;
         module->super.scoll_module_enable = mca_scoll_basic_enable;
         return &(module->super);
     }
 
-    return NULL ;
+    return NULL;
 }

oshmem/mca/scoll/fca/scoll_fca.h

@@ -93,6 +93,8 @@ struct mca_scoll_fca_module_t {
     mca_scoll_base_module_t *previous_collect_module;
     mca_scoll_base_module_reduce_fn_t previous_reduce;
     mca_scoll_base_module_t *previous_reduce_module;
+    mca_scoll_base_module_alltoall_fn_t previous_alltoall;
+    mca_scoll_base_module_t *previous_alltoall_module;
 };
 typedef struct mca_scoll_fca_module_t mca_scoll_fca_module_t;
 OBJ_CLASS_DECLARATION(mca_scoll_fca_module_t);

oshmem/mca/scoll/fca/scoll_fca_module.c

@@ -391,6 +391,7 @@ static int _save_coll_handlers(mca_scoll_fca_module_t *fca_module)
     FCA_SAVE_PREV_SCOLL_API(broadcast);
     FCA_SAVE_PREV_SCOLL_API(collect);
     FCA_SAVE_PREV_SCOLL_API(reduce);
+    FCA_SAVE_PREV_SCOLL_API(alltoall);
 
     return OSHMEM_SUCCESS;
 }
@@ -450,6 +451,7 @@ static void mca_scoll_fca_module_clear(mca_scoll_fca_module_t *fca_module)
     fca_module->previous_broadcast = NULL;
     fca_module->previous_collect = NULL;
     fca_module->previous_reduce = NULL;
+    fca_module->previous_alltoall = NULL;
 }
 
 static void mca_scoll_fca_module_construct(mca_scoll_fca_module_t *fca_module)
@@ -465,6 +467,7 @@ static void mca_scoll_fca_module_destruct(mca_scoll_fca_module_t *fca_module)
     OBJ_RELEASE(fca_module->previous_broadcast_module);
     OBJ_RELEASE(fca_module->previous_collect_module);
     OBJ_RELEASE(fca_module->previous_reduce_module);
+    OBJ_RELEASE(fca_module->previous_alltoall_module);
     if (fca_module->fca_comm)
         _destroy_fca_comm(fca_module);
     free(fca_module->local_ranks);
@@ -541,6 +544,7 @@ mca_scoll_fca_comm_query(struct oshmem_group_t *comm, int *priority)
     fca_module->super.scoll_broadcast =
             mca_scoll_fca_component.fca_enable_bcast ? mca_scoll_fca_broadcast :
                                                        NULL;
+    fca_module->super.scoll_alltoall = NULL;
 
     *priority = mca_scoll_fca_component.fca_priority;
     module = &fca_module->super;

oshmem/mca/scoll/mpi/scoll_mpi.h

@@ -69,6 +69,8 @@ struct mca_scoll_mpi_module_t {
     mca_scoll_base_module_t *previous_barrier_module;
     mca_scoll_base_module_collect_fn_t previous_collect;
     mca_scoll_base_module_t *previous_collect_module;
+    mca_scoll_base_module_alltoall_fn_t previous_alltoall;
+    mca_scoll_base_module_t *previous_alltoall_module;
 };
 typedef struct mca_scoll_mpi_module_t mca_scoll_mpi_module_t;