diff --git a/src/mpi/group/group_impl.c b/src/mpi/group/group_impl.c
index 848996c7d8c..a347dd0b3fc 100644
--- a/src/mpi/group/group_impl.c
+++ b/src/mpi/group/group_impl.c
@@ -166,34 +166,29 @@ int MPIR_Group_excl_impl(MPIR_Group * group_ptr, int n, const int ranks[],
 
     size = group_ptr->size;
 
-    /* Allocate a new group and lrank_to_lpid array */
-    mpi_errno = MPIR_Group_create(size - n, new_group_ptr);
-    MPIR_ERR_CHECK(mpi_errno);
+    MPIR_Lpid *map = MPL_malloc((size - n) * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
 
-    (*new_group_ptr)->rank = MPI_UNDEFINED;
     /* Use flag fields to mark the members to *exclude* . */
-
     flags = MPL_calloc(size, sizeof(int), MPL_MEM_OTHER);
 
     for (i = 0; i < n; i++) {
         flags[ranks[i]] = 1;
     }
 
+    int myrank = MPI_UNDEFINED;
     newi = 0;
     for (i = 0; i < size; i++) {
         if (flags[i] == 0) {
-            (*new_group_ptr)->lrank_to_lpid[newi].lpid = group_ptr->lrank_to_lpid[i].lpid;
+            map[newi] = MPIR_Group_lookup(group_ptr, i);
             if (group_ptr->rank == i)
-                (*new_group_ptr)->rank = newi;
+                myrank = newi;
             newi++;
         }
     }
 
-    (*new_group_ptr)->size = size - n;
-    (*new_group_ptr)->idx_of_first_lpid = -1;
-    /* TODO calculate is_local_dense_monotonic */
-
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr->session_ptr);
+    mpi_errno = MPIR_Group_create_map(size - n, myrank, group_ptr->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPL_free(flags);
@@ -207,8 +202,6 @@ int MPIR_Group_incl_impl(MPIR_Group * group_ptr, int n, const int ranks[],
                          MPIR_Group ** new_group_ptr)
 {
     int mpi_errno = MPI_SUCCESS;
-    int i;
-
     MPIR_FUNC_ENTER;
 
     if (n == 0) {
@@ -216,23 +209,18 @@ int MPIR_Group_incl_impl(MPIR_Group * group_ptr, int n, const int ranks[],
         goto fn_exit;
     }
 
-    /* Allocate a new group and lrank_to_lpid array */
-    mpi_errno = MPIR_Group_create(n, new_group_ptr);
-    if (mpi_errno)
-        goto fn_fail;
+    MPIR_Lpid *map = MPL_malloc(n * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
 
-    (*new_group_ptr)->rank = MPI_UNDEFINED;
-    for (i = 0; i < n; i++) {
-        (*new_group_ptr)->lrank_to_lpid[i].lpid = group_ptr->lrank_to_lpid[ranks[i]].lpid;
+    int myrank = MPI_UNDEFINED;
+    for (int i = 0; i < n; i++) {
+        map[i] = MPIR_Group_lookup(group_ptr, i);
         if (ranks[i] == group_ptr->rank)
-            (*new_group_ptr)->rank = i;
+            myrank = i;
     }
-    (*new_group_ptr)->size = n;
-    (*new_group_ptr)->idx_of_first_lpid = -1;
-    /* TODO calculate is_local_dense_monotonic */
-
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr->session_ptr);
 
+    mpi_errno = MPIR_Group_create_map(n, myrank, group_ptr->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPIR_FUNC_EXIT;
@@ -267,14 +255,9 @@ int MPIR_Group_range_excl_impl(MPIR_Group * group_ptr, int n, int ranges[][3],
         goto fn_exit;
     }
 
-    /* Allocate a new group and lrank_to_lpid array */
-    mpi_errno = MPIR_Group_create(nnew, new_group_ptr);
-    /* --BEGIN ERROR HANDLING-- */
-    if (mpi_errno) {
-        goto fn_fail;
-    }
-    /* --END ERROR HANDLING-- */
-    (*new_group_ptr)->rank = MPI_UNDEFINED;
+    MPIR_Lpid *map = MPL_malloc(nnew * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
+    int myrank = MPI_UNDEFINED;
 
     /* Group members are taken in rank order from the original group,
      * with the specified members removed. Use the flag array for that
@@ -304,17 +287,16 @@ int MPIR_Group_range_excl_impl(MPIR_Group * group_ptr, int n, int ranges[][3],
     k = 0;
     for (i = 0; i < size; i++) {
         if (!flags[i]) {
-            (*new_group_ptr)->lrank_to_lpid[k].lpid = group_ptr->lrank_to_lpid[i].lpid;
+            map[k] = MPIR_Group_lookup(group_ptr, i);
             if (group_ptr->rank == i) {
-                (*new_group_ptr)->rank = k;
+                myrank = k;
             }
             k++;
         }
     }
 
-    /* TODO calculate is_local_dense_monotonic */
-
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr->session_ptr);
+    mpi_errno = MPIR_Group_create_map(nnew, myrank, group_ptr->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPL_free(flags);
@@ -348,11 +330,9 @@ int MPIR_Group_range_incl_impl(MPIR_Group * group_ptr, int n, int ranges[][3],
         goto fn_exit;
     }
 
-    /* Allocate a new group and lrank_to_lpid array */
-    mpi_errno = MPIR_Group_create(nnew, new_group_ptr);
-    if (mpi_errno)
-        goto fn_fail;
-    (*new_group_ptr)->rank = MPI_UNDEFINED;
+    MPIR_Lpid *map = MPL_malloc(nnew * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
+    int myrank = MPI_UNDEFINED;
 
     /* Group members taken in order specified by the range array */
     /* This could be integrated with the error checking, but since this
@@ -379,9 +359,8 @@ int MPIR_Group_range_incl_impl(MPIR_Group * group_ptr, int n, int ranges[][3],
         }
     }
 
-    /* TODO calculate is_local_dense_monotonic */
-
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr->session_ptr);
+    mpi_errno = MPIR_Group_create_map(nnew, myrank, group_ptr->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPIR_FUNC_EXIT;
@@ -434,27 +413,24 @@ int MPIR_Group_difference_impl(MPIR_Group * group_ptr1, MPIR_Group * group_ptr2,
         *new_group_ptr = MPIR_Group_empty;
         goto fn_exit;
     } else {
-        mpi_errno = MPIR_Group_create(nnew, new_group_ptr);
-        /* --BEGIN ERROR HANDLING-- */
-        if (mpi_errno) {
-            goto fn_fail;
-        }
-        /* --END ERROR HANDLING-- */
-        (*new_group_ptr)->rank = MPI_UNDEFINED;
+        MPIR_Lpid *map = MPL_malloc(nnew * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+        MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
+        int myrank = MPI_UNDEFINED;
+
         k = 0;
         for (i = 0; i < size1; i++) {
             if (!flags[i]) {
-                (*new_group_ptr)->lrank_to_lpid[k].lpid = group_ptr1->lrank_to_lpid[i].lpid;
+                map[k] = MPIR_Group_lookup(group_ptr1, i);
                 if (i == group_ptr1->rank)
-                    (*new_group_ptr)->rank = k;
+                    myrank = k;
                 k++;
             }
         }
-        /* TODO calculate is_local_dense_monotonic */
+        mpi_errno = MPIR_Group_create_map(nnew, myrank, group_ptr1->session_ptr, map,
+                                          new_group_ptr);
+        MPIR_ERR_CHECK(mpi_errno);
     }
 
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr1->session_ptr);
-
   fn_exit:
     MPL_free(flags);
     MPIR_FUNC_EXIT;
@@ -505,28 +481,22 @@ int MPIR_Group_intersection_impl(MPIR_Group * group_ptr1, MPIR_Group * group_ptr
         goto fn_exit;
     }
 
-    mpi_errno = MPIR_Group_create(nnew, new_group_ptr);
-    MPIR_ERR_CHECK(mpi_errno);
+    MPIR_Lpid *map = MPL_malloc(nnew * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
+    int myrank = MPI_UNDEFINED;
 
-    (*new_group_ptr)->rank = MPI_UNDEFINED;
-    (*new_group_ptr)->is_local_dense_monotonic = TRUE;
     k = 0;
     for (i = 0; i < size1; i++) {
         if (flags[i]) {
-            uint64_t lpid = group_ptr1->lrank_to_lpid[i].lpid;
-            (*new_group_ptr)->lrank_to_lpid[k].lpid = lpid;
+            map[k] = MPIR_Group_lookup(group_ptr1, i);
             if (i == group_ptr1->rank)
-                (*new_group_ptr)->rank = k;
-            if (lpid > MPIR_Process.size ||
-                (k > 0 && (*new_group_ptr)->lrank_to_lpid[k - 1].lpid != (lpid - 1))) {
-                (*new_group_ptr)->is_local_dense_monotonic = FALSE;
-            }
-
+                myrank = k;
             k++;
         }
     }
 
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr1->session_ptr);
+    mpi_errno = MPIR_Group_create_map(nnew, myrank, group_ptr1->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPL_free(flags);
@@ -599,19 +569,18 @@ int MPIR_Group_union_impl(MPIR_Group * group_ptr1, MPIR_Group * group_ptr2,
         goto fn_exit;
     }
 
-    /* Allocate a new group and lrank_to_lpid array */
-    mpi_errno = MPIR_Group_create(nnew, new_group_ptr);
-    MPIR_ERR_CHECK(mpi_errno);
+    MPIR_Lpid *map = MPL_malloc(nnew * sizeof(MPIR_Lpid), MPL_MEM_GROUP);
+    MPIR_ERR_CHKANDJUMP(!map, mpi_errno, MPI_ERR_OTHER, "**nomem");
 
     /* If this process is in group1, then we can set the rank now.
      * If we are not in this group, this assignment will set the
      * current rank to MPI_UNDEFINED */
-    (*new_group_ptr)->rank = group_ptr1->rank;
+    int myrank = group_ptr1->rank;
 
     /* Add group1 */
     size1 = group_ptr1->size;
     for (i = 0; i < size1; i++) {
-        (*new_group_ptr)->lrank_to_lpid[i].lpid = group_ptr1->lrank_to_lpid[i].lpid;
+        map[i] = MPIR_Group_lookup(group_ptr1, i);
     }
 
     /* Add members of group2 that are not in group 1 */
@@ -624,17 +593,16 @@ int MPIR_Group_union_impl(MPIR_Group * group_ptr1, MPIR_Group * group_ptr2,
     k = size1;
     for (i = 0; i < size2; i++) {
         if (flags[i]) {
-            (*new_group_ptr)->lrank_to_lpid[k].lpid = group_ptr2->lrank_to_lpid[i].lpid;
-            if ((*new_group_ptr)->rank == MPI_UNDEFINED &&
-                group_ptr2->lrank_to_lpid[i].lpid == mylpid)
-                (*new_group_ptr)->rank = k;
+            map[k] = MPIR_Group_lookup(group_ptr2, i);
+            if (myrank == MPI_UNDEFINED && i == group_ptr2->rank) {
+                myrank = k;
+            }
             k++;
         }
     }
 
-    /* TODO calculate is_local_dense_monotonic */
-
-    MPIR_Group_set_session_ptr(*new_group_ptr, group_ptr1->session_ptr);
+    mpi_errno = MPIR_Group_create_map(nnew, myrank, group_ptr1->session_ptr, map, new_group_ptr);
+    MPIR_ERR_CHECK(mpi_errno);
 
   fn_exit:
     MPL_free(flags);
@@ -648,40 +616,19 @@ int MPIR_Group_from_session_pset_impl(MPIR_Session * session_ptr, const char *ps
                                       MPIR_Group ** new_group_ptr)
 {
     int mpi_errno = MPI_SUCCESS;
-    MPIR_Group *group_ptr;
 
     if (MPL_stricmp(pset_name, "mpi://WORLD") == 0) {
-        mpi_errno = MPIR_Group_create(MPIR_Process.size, &group_ptr);
+        mpi_errno = MPIR_Group_create_stride(MPIR_Process.size, MPIR_Process.rank, session_ptr,
+                                             0, 1, 1, new_group_ptr);
         MPIR_ERR_CHECK(mpi_errno);
-
-        group_ptr->size = MPIR_Process.size;
-        group_ptr->rank = MPIR_Process.rank;
-        group_ptr->is_local_dense_monotonic = TRUE;
-        for (int i = 0; i < group_ptr->size; i++) {
-            group_ptr->lrank_to_lpid[i].lpid = i;
-            group_ptr->lrank_to_lpid[i].next_lpid = i + 1;
-        }
-        group_ptr->lrank_to_lpid[group_ptr->size - 1].next_lpid = -1;
-        group_ptr->idx_of_first_lpid = 0;
     } else if (MPL_stricmp(pset_name, "mpi://SELF") == 0) {
-        mpi_errno = MPIR_Group_create(1, &group_ptr);
+        mpi_errno = MPIR_Group_create_stride(1, 0, session_ptr, 0, 1, 1, new_group_ptr);
         MPIR_ERR_CHECK(mpi_errno);
-
-        group_ptr->size = 1;
-        group_ptr->rank = 0;
-        group_ptr->is_local_dense_monotonic = TRUE;
-        group_ptr->lrank_to_lpid[0].lpid = MPIR_Process.rank;
-        group_ptr->lrank_to_lpid[0].next_lpid = -1;
-        group_ptr->idx_of_first_lpid = 0;
     } else {
         /* TODO: Implement pset struct, locate pset struct ptr */
         MPIR_ERR_SETANDSTMT(mpi_errno, MPI_ERR_ARG, goto fn_fail, "**psetinvalidname");
     }
 
-    MPIR_Group_set_session_ptr(group_ptr, session_ptr);
-
-    *new_group_ptr = group_ptr;
-
   fn_exit:
     return mpi_errno;
   fn_fail: