comm: re-implement dynamic processes using mpir-layer lpid

dummy

@@ -0,0 +1,3 @@
+1
+1
+1

maint/local_python/binding_c.py

@@ -1106,7 +1106,7 @@ def out_can_be_undefined(p):
         G.out.append("int ret = " + static_call + ";")
         for l in post_filters:
             G.out.append(l)
-        if re.match(r'MPI_(Init|Init_thread|Session_init)$', func_name, re.IGNORECASE):
+        if re.match(r'MPI_(Init|Init_thread|Session_init)|MPI_T_init_thread$', func_name, re.IGNORECASE):
             G.out.append("ABI_init_builtins();")
         G.out.append("return ret;")
     G.out.append("DEDENT")

src/binding/abi/mpi_abi_util.h

@@ -137,6 +137,7 @@ static inline ABI_Datatype ABI_Datatype_from_mpi(MPI_Datatype in)
                 return (ABI_Datatype) ((intptr_t) ABI_DATATYPE_NULL + i);
             }
         }
+        MPIR_Assert(0);
     }
     MPIR_Datatype *ptr;
     MPIR_Datatype_get_ptr(in, ptr);

src/binding/c/group_api.txt

@@ -37,18 +37,6 @@ MPI_Group_excl:
 
 MPI_Group_free:
     .desc: Frees a group
-{ -- error_check --
-    /* Cannot free the predefined groups, but allow GROUP_EMPTY
-     * because otherwise many tests fail */
-    if ((HANDLE_IS_BUILTIN(*group)) && *group != MPI_GROUP_EMPTY) {
-        mpi_errno = MPIR_Err_create_code(MPI_SUCCESS,
-                                         MPIR_ERR_RECOVERABLE, __func__, __LINE__,
-                                         MPI_ERR_GROUP, "**groupperm", 0);
-    }
-    if (mpi_errno) {
-	goto fn_fail;
-    }
-}
 
 MPI_Group_incl:
     .desc: Produces a group by reordering an existing group and taking only listed members

src/include/mpiimpl.h

@@ -169,6 +169,7 @@ typedef struct MPIR_Stream MPIR_Stream;
 #include "mpir_errhandler.h"
 #include "mpir_attr_generic.h"
 #include "mpir_contextid.h"
+#include "mpir_lpid.h"
 #include "mpir_status.h"
 #include "mpir_debugger.h"
 #include "mpir_op.h"

src/include/mpir_comm.h

@@ -31,44 +31,6 @@ typedef enum MPIR_Comm_hierarchy_kind_t {
     MPIR_COMM_HIERARCHY_KIND__MULTI_LEADS = 4,  /* is the multi_leaders_comm for a node */
 } MPIR_Comm_hierarchy_kind_t;
 
-typedef enum {
-    MPIR_COMM_MAP_TYPE__DUP,
-    MPIR_COMM_MAP_TYPE__IRREGULAR
-} MPIR_Comm_map_type_t;
-
-/* direction of mapping: local to local, local to remote, remote to
- * local, remote to remote */
-typedef enum {
-    MPIR_COMM_MAP_DIR__L2L,
-    MPIR_COMM_MAP_DIR__L2R,
-    MPIR_COMM_MAP_DIR__R2L,
-    MPIR_COMM_MAP_DIR__R2R
-} MPIR_Comm_map_dir_t;
-
-typedef struct MPIR_Comm_map {
-    MPIR_Comm_map_type_t type;
-
-    struct MPIR_Comm *src_comm;
-
-    /* mapping direction for intercomms, which contain local and
-     * remote groups */
-    MPIR_Comm_map_dir_t dir;
-
-    /* only valid for irregular map type */
-    int src_mapping_size;
-    int *src_mapping;
-    int free_mapping;           /* we allocated the mapping */
-
-    struct MPIR_Comm_map *next;
-} MPIR_Comm_map_t;
-
-int MPIR_Comm_map_irregular(struct MPIR_Comm *newcomm, struct MPIR_Comm *src_comm,
-                            int *src_mapping, int src_mapping_size,
-                            MPIR_Comm_map_dir_t dir, MPIR_Comm_map_t ** map);
-int MPIR_Comm_map_dup(struct MPIR_Comm *newcomm, struct MPIR_Comm *src_comm,
-                      MPIR_Comm_map_dir_t dir);
-int MPIR_Comm_map_free(struct MPIR_Comm *comm);
-
 /* Communicator info hint */
 #define MPIR_COMM_HINT_TYPE_BOOL 0
 #define MPIR_COMM_HINT_TYPE_INT  1
@@ -166,9 +128,9 @@ struct MPIR_Comm {
     int rank;                   /* Value of MPI_Comm_rank */
     MPIR_Attribute *attributes; /* List of attributes */
     int local_size;             /* Value of MPI_Comm_size for local group */
-    MPIR_Group *local_group,    /* Groups in communicator. */
-    *remote_group;              /* The local and remote groups are the
-                                 * same for intra communicators */
+    MPIR_Group *local_group;    /* Groups in communicator. */
+    MPIR_Group *remote_group;   /* The remote group in a inter communicator.
+                                 * Must be NULL in a intra communicator. */
     MPIR_Comm_kind_t comm_kind; /* MPIR_COMM_KIND__INTRACOMM or MPIR_COMM_KIND__INTERCOMM */
     char name[MPI_MAX_OBJECT_NAME];     /* Required for MPI-2 */
     MPIR_Errhandler *errhandler;        /* Pointer to the error handler structure */
@@ -254,12 +216,6 @@ struct MPIR_Comm {
     hcoll_comm_priv_t hcoll_priv;
 #endif                          /* HAVE_HCOLL */
 
-    /* the mapper is temporarily filled out in order to allow the
-     * device to setup its network addresses.  it will be freed after
-     * the device has initialized the comm. */
-    MPIR_Comm_map_t *mapper_head;
-    MPIR_Comm_map_t *mapper_tail;
-
     enum { MPIR_STREAM_COMM_NONE, MPIR_STREAM_COMM_SINGLE, MPIR_STREAM_COMM_MULTIPLEX }
         stream_comm_type;
     union {
@@ -296,6 +252,15 @@ void MPIR_stream_comm_free(MPIR_Comm * comm_ptr);
 int MPIR_Comm_copy_stream(MPIR_Comm * oldcomm, MPIR_Comm * newcomm);
 int MPIR_get_local_gpu_stream(MPIR_Comm * comm_ptr, MPL_gpu_stream_t * gpu_stream);
 
+MPL_STATIC_INLINE_PREFIX MPIR_Lpid MPIR_comm_rank_to_lpid(MPIR_Comm * comm_ptr, int rank)
+{
+    if (comm_ptr->comm_kind == MPIR_COMM_KIND__INTRACOMM) {
+        return MPIR_Group_rank_to_lpid(comm_ptr->local_group, rank);
+    } else {
+        return MPIR_Group_rank_to_lpid(comm_ptr->remote_group, rank);
+    }
+}
+
 MPL_STATIC_INLINE_PREFIX MPIR_Stream *MPIR_stream_comm_get_local_stream(MPIR_Comm * comm_ptr)
 {
     if (comm_ptr->stream_comm_type == MPIR_STREAM_COMM_SINGLE) {
@@ -377,10 +342,6 @@ int MPIR_Comm_commit(MPIR_Comm *);
 
 int MPIR_Comm_is_parent_comm(MPIR_Comm *);
 
-/* peer intercomm is an internal 1-to-1 intercomm used for connecting dynamic processes */
-int MPIR_peer_intercomm_create(int context_id, int recvcontext_id,
-                               uint64_t remote_lpid, int is_low_group, MPIR_Comm ** newcomm);
-
 #define MPIR_Comm_rank(comm_ptr) ((comm_ptr)->rank)
 #define MPIR_Comm_size(comm_ptr) ((comm_ptr)->local_size)
 
@@ -420,6 +381,10 @@ int MPIR_Comm_split_type(MPIR_Comm * comm_ptr, int split_type, int key, MPIR_Inf
 int MPIR_Comm_split_type_neighborhood(MPIR_Comm * comm_ptr, int split_type, int key,
                                       MPIR_Info * info_ptr, MPIR_Comm ** newcomm_ptr);
 
+int MPIR_Intercomm_create_timeout(MPIR_Comm * local_comm_ptr, int local_leader,
+                                  MPIR_Comm * peer_comm_ptr, int remote_leader,
+                                  int tag, int timeout, MPIR_Comm ** new_intercomm_ptr);
+
 /* Preallocated comm objects.  There are 3: comm_world, comm_self, and
    a private (non-user accessible) dup of comm world that is provided
    if needed in MPI_Finalize.  Having a separate version of comm_world
@@ -449,16 +414,6 @@ int MPII_Comm_copy_data(MPIR_Comm * comm_ptr, MPIR_Info * info, MPIR_Comm ** out
 
 int MPII_Setup_intercomm_localcomm(MPIR_Comm *);
 
-/* comm_create helper functions, used by both comm_create and comm_create_group */
-int MPII_Comm_create_calculate_mapping(MPIR_Group * group_ptr,
-                                       MPIR_Comm * comm_ptr,
-                                       int **mapping_out, MPIR_Comm ** mapping_comm);
-
-int MPII_Comm_create_map(int local_n,
-                         int remote_n,
-                         int *local_mapping,
-                         int *remote_mapping, MPIR_Comm * mapping_comm, MPIR_Comm * newcomm);
-
 int MPII_Comm_set_hints(MPIR_Comm * comm_ptr, MPIR_Info * info, bool in_comm_create);
 int MPII_Comm_get_hints(MPIR_Comm * comm_ptr, MPIR_Info * info);
 int MPII_Comm_check_hints(MPIR_Comm * comm_ptr);

src/include/mpir_group.h

@@ -11,18 +11,7 @@
  * only because they are required for the group operations (e.g.,
  * MPI_Group_intersection) and for the scalable RMA synchronization
  *---------------------------------------------------------------------------*/
-/* This structure is used to implement the group operations such as
-   MPI_Group_translate_ranks */
-/* note: next_lpid (with idx_of_first_lpid in MPIR_Group) gives a linked list
- * in a sorted lpid ascending order */
-typedef struct MPII_Group_pmap_t {
-    uint64_t lpid;              /* local process id, from VCONN */
-    int next_lpid;              /* Index of next lpid (in lpid order) */
-} MPII_Group_pmap_t;
-
-/* Any changes in the MPIR_Group structure must be made to the
-   predefined value in MPIR_Group_builtin for MPI_GROUP_EMPTY in
-   src/mpi/group/grouputil.c */
+
 /*S
  MPIR_Group - Description of the Group data structure
 
@@ -53,22 +42,34 @@ typedef struct MPII_Group_pmap_t {
  Group-DS
 
  S*/
+
+/* In addition to MPI_GROUP_EMPTY, internally we have a few more builtins */
+#define MPIR_GROUP_WORLD  ((MPI_Group)0x48000001)
+#define MPIR_GROUP_SELF   ((MPI_Group)0x48000002)
+
+#define MPIR_GROUP_WORLD_PTR (MPIR_Group_builtin + 1)
+#define MPIR_GROUP_SELF_PTR  (MPIR_Group_builtin + 2)
+
+struct MPIR_Pmap {
+    bool use_map;
+    union {
+        MPIR_Lpid *map;
+        struct {
+            MPIR_Lpid offset;
+            MPIR_Lpid stride;
+        } stride;
+    } u;
+};
+
 struct MPIR_Group {
     MPIR_OBJECT_HEADER;         /* adds handle and ref_count fields */
     int size;                   /* Size of a group */
-    int rank;                   /* rank of this process relative to this
-                                 * group */
-    int idx_of_first_lpid;
-    MPII_Group_pmap_t *lrank_to_lpid;   /* Array mapping a local rank to local
-                                         * process number */
-    int is_local_dense_monotonic;       /* see NOTE-G1 */
-
-    /* We may want some additional data for the RMA syncrhonization calls */
-    /* Other, device-specific information */
+    int rank;                   /* rank of this process relative to this group */
+    struct MPIR_Pmap pmap;
+    MPIR_Session *session_ptr;  /* Pointer to session to which this group belongs */
 #ifdef MPID_DEV_GROUP_DECL
      MPID_DEV_GROUP_DECL
 #endif
-     MPIR_Session * session_ptr;        /* Pointer to session to which this group belongs */
 };
 
 /* NOTE-G1: is_local_dense_monotonic will be true iff the group meets the
@@ -97,18 +98,34 @@ extern MPIR_Group *const MPIR_Group_empty;
 #define MPIR_Group_release_ref(_group, _inuse) \
      do { MPIR_Object_release_ref(_group, _inuse); } while (0)
 
-void MPII_Group_setup_lpid_list(MPIR_Group *);
 int MPIR_Group_check_valid_ranks(MPIR_Group *, const int[], int);
 int MPIR_Group_check_valid_ranges(MPIR_Group *, int[][3], int);
-void MPIR_Group_setup_lpid_pairs(MPIR_Group *, MPIR_Group *);
 int MPIR_Group_create(int, MPIR_Group **);
 int MPIR_Group_release(MPIR_Group * group_ptr);
 
+int MPIR_Group_dup(MPIR_Group * old_group, MPIR_Session * session_ptr, MPIR_Group ** new_group_ptr);
+int MPIR_Group_create_map(int size, int rank, MPIR_Session * session_ptr, MPIR_Lpid * map,
+                          MPIR_Group ** new_group_ptr);
+int MPIR_Group_create_stride(int size, int rank, MPIR_Session * session_ptr,
+                             MPIR_Lpid offset, MPIR_Lpid stride, MPIR_Group ** new_group_ptr);
+int MPIR_Group_lpid_to_rank(MPIR_Group * group, MPIR_Lpid lpid);
+
 int MPIR_Group_check_subset(MPIR_Group * group_ptr, MPIR_Comm * comm_ptr);
 void MPIR_Group_set_session_ptr(MPIR_Group * group_ptr, MPIR_Session * session_out);
 int MPIR_Group_init(void);
-
-/* internal functions */
-void MPII_Group_setup_lpid_list(MPIR_Group *);
+int MPIR_Group_finalize(void);
+
+MPL_STATIC_INLINE_PREFIX MPIR_Lpid MPIR_Group_rank_to_lpid(MPIR_Group * group, int rank)
+{
+    if (rank < 0 || rank >= group->size) {
+        return MPI_UNDEFINED;
+    }
+
+    if (group->pmap.use_map) {
+        return group->pmap.u.map[rank];
+    } else {
+        return group->pmap.u.stride.offset + rank * group->pmap.u.stride.stride;
+    }
+}
 
 #endif /* MPIR_GROUP_H_INCLUDED */

src/include/mpir_lpid.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) by Argonne National Laboratory
+ *     See COPYRIGHT in top-level directory
+ */
+
+#ifndef MPIR_LPID_H_INCLUDED
+#define MPIR_LPID_H_INCLUDED
+
+/* Worlds -
+ * We need a device-independent way of identifying processes. Assuming the concept of
+ * "worlds", we can describe a process with (world_idx, world_rank).
+ *
+ * The world_idx is a local id because each process may not see all worlds. Thus,
+ * each process only can maintain a list of worlds as it encounters them. Thus,
+ * a process id derived from (world_idx, world_rank) is referred as LPID, or
+ * "local process id".
+ *
+ * Each process should maintain a table of worlds with sufficient information so
+ * processes can match worlds upon connection or making address exchange.
+ */
+
+#define MPIR_NAMESPACE_MAX 128
+struct MPIR_World {
+    char namespace[MPIR_NAMESPACE_MAX];
+    /* other useful fields */
+    int num_procs;
+};
+
+extern struct MPIR_World MPIR_Worlds[];
+
+int MPIR_add_world(const char *namespace, int num_procs);
+int MPIR_find_world(const char *namespace);
+
+/* Abstract the integer type for lpid (process id). It is possible to use 32-bit
+ * in principle, but 64-bit is simpler since we can trivially combine
+ * (world_idx, world_rank).
+ */
+typedef int64_t MPIR_Lpid;
+
+#define MPIR_LPID_WORLD_INDEX(lpid) ((lpid) >> 32)
+#define MPIR_LPID_WORLD_RANK(lpid)  ((lpid) & 0xffffffff)
+#define MPIR_LPID_FROM(world_idx, world_rank) (((uint64_t)(world_idx) << 32) | (world_rank))
+#define MPIR_LPID_DYNAMIC_MASK ((MPIR_Lpid)0x1 << 62)   /* MPIR_Lpid is signed, avoid using the signed bit */
+#define MPIR_LPID_INVALID      0xffffffff
+
+#endif /* MPIR_LPID_H_INCLUDED */

src/include/mpir_mem.h

@@ -110,6 +110,12 @@ extern "C" {
     int mpiu_chklmem_stk_sp_=0;                                 \
     MPIR_AssertDeclValue(const int mpiu_chklmem_stk_sz_,n_)
 
+#define MPIR_CHKLMEM_ADD(pointer_) \
+    do { \
+        MPIR_Assert(mpiu_chklmem_stk_sp_<mpiu_chklmem_stk_sz_);     \
+        mpiu_chklmem_stk_[mpiu_chklmem_stk_sp_++] = (void *) (pointer_); \
+    } while (0)
+
 #define MPIR_CHKLMEM_MALLOC_ORSTMT(pointer_,type_,nbytes_,rc_,name_,class_,stmt_) \
     {                                                                   \
         pointer_ = (type_)MPL_malloc(nbytes_,class_);                   \

src/include/mpir_objects.h

@@ -210,7 +210,7 @@ const char *MPIR_Handle_get_kind_str(int kind);
 #define MPIR_COMM_PREALLOC 8
 #endif
 
-#define MPIR_GROUP_N_BUILTIN 1
+#define MPIR_GROUP_N_BUILTIN 3
 #ifdef MPID_GROUP_PREALLOC
 #define MPIR_GROUP_PREALLOC MPID_GROUP_PREALLOC
 #else

src/mpi/coll/algorithms/treealgo/treeutil.c

@@ -504,10 +504,10 @@ static int MPII_Treeutil_hierarchy_populate(MPIR_Comm * comm, int rank, int nran
         MPIR_Assert(upper_level != NULL);
 
         /* Get wrank from the communicator as the coords are stored with wrank */
-        uint64_t temp = 0;
-        MPID_Comm_get_lpid(comm, r, &temp, FALSE);
-        int wrank = (int) temp;
-        if (wrank < 0)
+        MPIR_Lpid temp = MPIR_comm_rank_to_lpid(comm, r);
+        int world_idx = MPIR_LPID_WORLD_INDEX(temp);
+        int wrank = MPIR_LPID_WORLD_RANK(temp);
+        if (world_idx != 0)
             goto fn_fail;
         MPIR_Assert(0 <= wrank && wrank < MPIR_Process.size);
 
@@ -1129,7 +1129,7 @@ int MPII_Treeutil_tree_topology_wave_init(MPIR_Comm * comm, int k, int root, boo
     heap_vector minHeaps;
     heap_vector_init(&minHeaps);
 
-    /* To build hierarchy of ranks, swiches and groups */
+    /* To build hierarchy of ranks, switches and groups */
     int dim = MPIR_Process.coords_dims - 1;
     for (dim = MPIR_Process.coords_dims - 1; dim >= 0; --dim)
         tree_ut_hierarchy_init(&hierarchy[dim]);