Store window basic attributes into a struct on window.

In this patch, we gather window basic attributes of other
processes (base_addr, size, disp_unit, win_handle) using a
struct called "basic_info_table". By doing this, we can use
one contiguous memory region to store them.

Signed-off-by: Pavan Balaji <balaji@anl.gov>

src/mpid/ch3/channels/nemesis/src/ch3_rma_shm.c

@@ -34,9 +34,9 @@ int MPIDI_CH3_SHM_Win_shared_query(MPID_Win * win_ptr, int target_rank, MPI_Aint
         *((void **) baseptr) = NULL;
 
         for (i = 0; i < comm_size; i++) {
-            if (win_ptr->sizes[i] > 0) {
-                *size = win_ptr->sizes[i];
-                *disp_unit = win_ptr->disp_units[i];
+            if (win_ptr->basic_info_table[i].size > 0) {
+                *size = win_ptr->basic_info_table[i].size;
+                *disp_unit = win_ptr->basic_info_table[i].disp_unit;
                 *((void **) baseptr) = win_ptr->shm_base_addrs[i];
                 break;
             }
@@ -44,8 +44,8 @@ int MPIDI_CH3_SHM_Win_shared_query(MPID_Win * win_ptr, int target_rank, MPI_Aint
 
     }
     else {
-        *size = win_ptr->sizes[target_rank];
-        *disp_unit = win_ptr->disp_units[target_rank];
+        *size = win_ptr->basic_info_table[target_rank].size;
+        *disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
         *((void **) baseptr) = win_ptr->shm_base_addrs[target_rank];
     }
 

src/mpid/ch3/channels/nemesis/src/ch3_win_fns.c

@@ -154,7 +154,8 @@ static int MPIDI_CH3I_SHM_Wins_match(MPID_Win ** win_ptr, MPID_Win ** matched_wi
                 MPIU_Assert(i_node_rank < node_size);
 
                 if (base_shm_offs[i_node_rank] < 0 ||
-                    base_shm_offs[i_node_rank] + (*win_ptr)->sizes[i] > shm_win->shm_segment_len) {
+                    base_shm_offs[i_node_rank] + (*win_ptr)->basic_info_table[i].size >
+                    shm_win->shm_segment_len) {
                     base_diff = 1;
                     break;
                 }
@@ -274,7 +275,7 @@ static int MPIDI_CH3I_Win_allocate_shm(MPI_Aint size, int disp_unit, MPID_Info *
     MPI_Aint *tmp_buf;
     mpir_errflag_t errflag = MPIR_ERR_NONE;
     int noncontig = FALSE;
-    MPIU_CHKPMEM_DECL(6);
+    MPIU_CHKPMEM_DECL(2);
     MPIU_CHKLMEM_DECL(3);
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_WIN_ALLOCATE_SHM);
 
@@ -306,20 +307,12 @@ static int MPIDI_CH3I_Win_allocate_shm(MPI_Aint size, int disp_unit, MPID_Info *
     MPIR_T_PVAR_TIMER_START(RMA, rma_wincreate_allgather);
     /* allocate memory for the base addresses, disp_units, and
      * completion counters of all processes */
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->base_addrs, void **,
-                        comm_size * sizeof(void *), mpi_errno, "(*win_ptr)->base_addrs");
-
     MPIU_CHKPMEM_MALLOC((*win_ptr)->shm_base_addrs, void **,
                         comm_size * sizeof(void *), mpi_errno, "(*win_ptr)->shm_base_addrs");
 
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->sizes, MPI_Aint *, comm_size * sizeof(MPI_Aint),
-                        mpi_errno, "(*win_ptr)->sizes");
-
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->disp_units, int *, comm_size * sizeof(int),
-                        mpi_errno, "(*win_ptr)->disp_units");
-
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->all_win_handles, MPI_Win *,
-                        comm_size * sizeof(MPI_Win), mpi_errno, "(*win_ptr)->all_win_handles");
+    MPIU_CHKPMEM_MALLOC((*win_ptr)->basic_info_table, MPIDI_Win_basic_info_t *,
+                        comm_size * sizeof(MPIDI_Win_basic_info_t),
+                        mpi_errno, "(*win_ptr)->base_info_table");
 
     /* get the sizes of the windows and window objectsof
      * all processes.  allocate temp. buffer for communication */
@@ -575,10 +568,10 @@ static int MPIDI_CH3I_Win_allocate_shm(MPI_Aint size, int disp_unit, MPID_Info *
 
     k = 0;
     for (i = 0; i < comm_size; ++i) {
-        (*win_ptr)->base_addrs[i] = MPIU_AintToPtr(tmp_buf[k++]);
-        (*win_ptr)->sizes[i] = tmp_buf[k++];
-        (*win_ptr)->disp_units[i] = (int) tmp_buf[k++];
-        (*win_ptr)->all_win_handles[i] = (MPI_Win) tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].base_addr = MPIU_AintToPtr(tmp_buf[k++]);
+        (*win_ptr)->basic_info_table[i].size = tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].disp_unit = (int) tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].win_handle = (MPI_Win) tmp_buf[k++];
     }
 
     *base_pp = (*win_ptr)->base;

src/mpid/ch3/include/mpid_rma_shm.h

@@ -261,7 +261,7 @@ static inline int MPIDI_CH3I_Shm_put_op(const void *origin_addr, int origin_coun
 
     if (win_ptr->shm_allocated == TRUE) {
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
     }
     else {
         base = win_ptr->base;
@@ -306,7 +306,7 @@ static inline int MPIDI_CH3I_Shm_acc_op(const void *origin_addr, int origin_coun
     if (win_ptr->shm_allocated == TRUE) {
         shm_op = 1;
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
     }
     else {
         base = win_ptr->base;
@@ -460,7 +460,7 @@ static inline int MPIDI_CH3I_Shm_get_acc_op(const void *origin_addr, int origin_
 
     if (win_ptr->shm_allocated == TRUE) {
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
         MPIDI_CH3I_SHM_MUTEX_LOCK(win_ptr);
         shm_locked = 1;
     }
@@ -625,7 +625,7 @@ static inline int MPIDI_CH3I_Shm_get_op(void *origin_addr, int origin_count,
 
     if (win_ptr->shm_allocated == TRUE) {
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
     }
     else {
         base = win_ptr->base;
@@ -667,7 +667,7 @@ static inline int MPIDI_CH3I_Shm_cas_op(const void *origin_addr, const void *com
 
     if (win_ptr->shm_allocated == TRUE) {
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
 
         MPIDI_CH3I_SHM_MUTEX_LOCK(win_ptr);
         shm_locked = 1;
@@ -724,7 +724,7 @@ static inline int MPIDI_CH3I_Shm_fop_op(const void *origin_addr, void *result_ad
 
     if (win_ptr->shm_allocated == TRUE) {
         base = win_ptr->shm_base_addrs[target_rank];
-        disp_unit = win_ptr->disp_units[target_rank];
+        disp_unit = win_ptr->basic_info_table[target_rank].disp_unit;
 
         MPIDI_CH3I_SHM_MUTEX_LOCK(win_ptr);
         shm_locked = 1;

src/mpid/ch3/include/mpidpre.h

@@ -291,6 +291,13 @@ struct MPIDI_Win_info_args {
 
 struct MPIDI_RMA_op;            /* forward decl from mpidrma.h */
 
+typedef struct MPIDI_Win_basic_info {
+    void *base_addr;
+    MPI_Aint size;
+    int disp_unit;
+    MPI_Win win_handle;
+} MPIDI_Win_basic_info_t;
+
 typedef struct MPIDI_RMA_Pkt_orderings {
     int flush_remote; /* ordered FLUSH, for remote completion */
     /* FIXME: in future we should also add local completin
@@ -302,21 +309,16 @@ extern MPIDI_RMA_Pkt_orderings_t *MPIDI_RMA_Pkt_orderings;
 #define MPIDI_DEV_WIN_DECL                                               \
     volatile int at_completion_counter;  /* completion counter for operations \
                                  targeting this window */                \
-    void **base_addrs;     /* array of base addresses of the windows of  \
-                              all processes */                           \
     void **shm_base_addrs; /* shared memory windows -- array of base     \
                               addresses of the windows of all processes  \
                               in this process's address space */         \
-    int *disp_units;      /* array of displacement units of all windows */\
-    MPI_Win *all_win_handles;    /* array of handles to the window objects\
-                                          of all processes */            \
+    MPIDI_Win_basic_info_t *basic_info_table;                            \
     volatile int current_lock_type;   /* current lock type on this window (as target)   \
                               * (none, shared, exclusive) */             \
     volatile int shared_lock_ref_cnt;                                    \
     struct MPIDI_RMA_Lock_entry volatile *lock_queue;  /* list of unsatisfied locks */  \
     struct MPIDI_RMA_Lock_entry volatile *lock_queue_tail; /* tail of unstaisfied locks. */ \
                                                                          \
-    MPI_Aint *sizes;      /* array of sizes of all windows */            \
     struct MPIDI_Win_info_args info_args;                                \
     int shm_allocated; /* flag: TRUE iff this window has a shared memory \
                           region associated with it */                   \

src/mpid/ch3/include/mpidrma.h

@@ -30,7 +30,7 @@ static inline int send_lock_msg(int dest, int lock_type, MPID_Win * win_ptr)
     MPIDI_Comm_get_vc_set_active(win_ptr->comm_ptr, dest, &vc);
 
     MPIDI_Pkt_init(lock_pkt, MPIDI_CH3_PKT_LOCK);
-    lock_pkt->target_win_handle = win_ptr->all_win_handles[dest];
+    lock_pkt->target_win_handle = win_ptr->basic_info_table[dest].win_handle;
     lock_pkt->source_win_handle = win_ptr->handle;
     lock_pkt->request_handle = MPI_REQUEST_NULL;
     lock_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
@@ -80,7 +80,7 @@ static inline int send_unlock_msg(int dest, MPID_Win * win_ptr, MPIDI_CH3_Pkt_fl
      * reply. Then do all the RMA ops. */
 
     MPIDI_Pkt_init(unlock_pkt, MPIDI_CH3_PKT_UNLOCK);
-    unlock_pkt->target_win_handle = win_ptr->all_win_handles[dest];
+    unlock_pkt->target_win_handle = win_ptr->basic_info_table[dest].win_handle;
     unlock_pkt->source_win_handle = win_ptr->handle;
     unlock_pkt->flags = flags;
 
@@ -250,7 +250,7 @@ static inline int send_decr_at_cnt_msg(int dst, MPID_Win * win_ptr)
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_DECR_AT_CNT_MSG);
 
     MPIDI_Pkt_init(decr_at_cnt_pkt, MPIDI_CH3_PKT_DECR_AT_COUNTER);
-    decr_at_cnt_pkt->target_win_handle = win_ptr->all_win_handles[dst];
+    decr_at_cnt_pkt->target_win_handle = win_ptr->basic_info_table[dst].win_handle;
 
     MPIDI_Comm_get_vc_set_active(win_ptr->comm_ptr, dst, &vc);
 
@@ -292,7 +292,7 @@ static inline int send_flush_msg(int dest, MPID_Win * win_ptr)
     MPIDI_Comm_get_vc_set_active(win_ptr->comm_ptr, dest, &vc);
 
     MPIDI_Pkt_init(flush_pkt, MPIDI_CH3_PKT_FLUSH);
-    flush_pkt->target_win_handle = win_ptr->all_win_handles[dest];
+    flush_pkt->target_win_handle = win_ptr->basic_info_table[dest].win_handle;
     flush_pkt->source_win_handle = win_ptr->handle;
 
     MPIU_THREAD_CS_ENTER(CH3COMM, vc);

src/mpid/ch3/src/ch3u_rma_ops.c

@@ -188,12 +188,12 @@ int MPIDI_CH3I_Put(const void *origin_addr, int origin_count, MPI_Datatype
             MPIDI_Pkt_init(put_pkt, MPIDI_CH3_PKT_PUT);
         }
 
-        put_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-            win_ptr->disp_units[target_rank] * target_disp;
+        put_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+            win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
         put_pkt->count = target_count;
         put_pkt->datatype = target_datatype;
         put_pkt->info.dataloop_size = 0;
-        put_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+        put_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
         put_pkt->source_win_handle = win_ptr->handle;
         put_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
         if (use_immed_pkt) {
@@ -371,12 +371,12 @@ int MPIDI_CH3I_Get(void *origin_addr, int origin_count, MPI_Datatype
 
         get_pkt = &(new_ptr->pkt.get);
         MPIDI_Pkt_init(get_pkt, MPIDI_CH3_PKT_GET);
-        get_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-            win_ptr->disp_units[target_rank] * target_disp;
+        get_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+            win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
         get_pkt->count = target_count;
         get_pkt->datatype = target_datatype;
         get_pkt->info.dataloop_size = 0;
-        get_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+        get_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
         get_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
         if (use_immed_resp_pkt)
             get_pkt->flags |= MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP;
@@ -558,13 +558,13 @@ int MPIDI_CH3I_Accumulate(const void *origin_addr, int origin_count, MPI_Datatyp
             MPIDI_Pkt_init(accum_pkt, MPIDI_CH3_PKT_ACCUMULATE);
         }
 
-        accum_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-            win_ptr->disp_units[target_rank] * target_disp;
+        accum_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+            win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
         accum_pkt->count = target_count;
         accum_pkt->datatype = target_datatype;
         accum_pkt->info.dataloop_size = 0;
         accum_pkt->op = op;
-        accum_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+        accum_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
         accum_pkt->source_win_handle = win_ptr->handle;
         accum_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
         if (use_immed_pkt) {
@@ -749,12 +749,12 @@ int MPIDI_CH3I_Get_accumulate(const void *origin_addr, int origin_count,
 
             get_pkt = &(new_ptr->pkt.get);
             MPIDI_Pkt_init(get_pkt, MPIDI_CH3_PKT_GET);
-            get_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-                win_ptr->disp_units[target_rank] * target_disp;
+            get_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+                win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
             get_pkt->count = target_count;
             get_pkt->datatype = target_datatype;
             get_pkt->info.dataloop_size = 0;
-            get_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+            get_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
             get_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
             if (use_immed_resp_pkt == TRUE)
                 get_pkt->flags |= MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP;
@@ -838,13 +838,13 @@ int MPIDI_CH3I_Get_accumulate(const void *origin_addr, int origin_count,
                 MPIDI_Pkt_init(get_accum_pkt, MPIDI_CH3_PKT_GET_ACCUM);
             }
 
-            get_accum_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-                win_ptr->disp_units[target_rank] * target_disp;
+            get_accum_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+                win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
             get_accum_pkt->count = target_count;
             get_accum_pkt->datatype = target_datatype;
             get_accum_pkt->info.dataloop_size = 0;
             get_accum_pkt->op = op;
-            get_accum_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+            get_accum_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
             get_accum_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
             if (use_immed_pkt) {
                 void *src = (void *) origin_addr, *dest = (void *) (get_accum_pkt->info.data);
@@ -1095,10 +1095,10 @@ int MPIDI_Compare_and_swap(const void *origin_addr, const void *compare_addr,
 
         cas_pkt = &(new_ptr->pkt.cas);
         MPIDI_Pkt_init(cas_pkt, MPIDI_CH3_PKT_CAS_IMMED);
-        cas_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-            win_ptr->disp_units[target_rank] * target_disp;
+        cas_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+            win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
         cas_pkt->datatype = datatype;
-        cas_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+        cas_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
         cas_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
 
         /* REQUIRE: All datatype arguments must be of the same, builtin
@@ -1251,12 +1251,12 @@ int MPIDI_Fetch_and_op(const void *origin_addr, void *result_addr,
 
             get_pkt = &(new_ptr->pkt.get);
             MPIDI_Pkt_init(get_pkt, MPIDI_CH3_PKT_GET);
-            get_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-                win_ptr->disp_units[target_rank] * target_disp;
+            get_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+                win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
             get_pkt->count = 1;
             get_pkt->datatype = datatype;
             get_pkt->info.dataloop_size = 0;
-            get_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+            get_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
             get_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
             if (use_immed_resp_pkt == TRUE)
                 get_pkt->flags |= MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP;
@@ -1298,11 +1298,11 @@ int MPIDI_Fetch_and_op(const void *origin_addr, void *result_addr,
             else {
                 MPIDI_Pkt_init(fop_pkt, MPIDI_CH3_PKT_FOP);
             }
-            fop_pkt->addr = (char *) win_ptr->base_addrs[target_rank] +
-                win_ptr->disp_units[target_rank] * target_disp;
+            fop_pkt->addr = (char *) win_ptr->basic_info_table[target_rank].base_addr +
+                win_ptr->basic_info_table[target_rank].disp_unit * target_disp;
             fop_pkt->datatype = datatype;
             fop_pkt->op = op;
-            fop_pkt->target_win_handle = win_ptr->all_win_handles[target_rank];
+            fop_pkt->target_win_handle = win_ptr->basic_info_table[target_rank].win_handle;
             fop_pkt->flags = MPIDI_CH3_PKT_FLAG_NONE;
             if (use_immed_pkt) {
                 void *src = (void *) origin_addr, *dest = (void *) (fop_pkt->info.data);

src/mpid/ch3/src/ch3u_win_fns.c

@@ -42,7 +42,7 @@ int MPIDI_CH3U_Win_gather_info(void *base, MPI_Aint size, int disp_unit,
     int mpi_errno = MPI_SUCCESS, i, k, comm_size, rank;
     MPI_Aint *tmp_buf;
     mpir_errflag_t errflag = MPIR_ERR_NONE;
-    MPIU_CHKPMEM_DECL(5);
+    MPIU_CHKPMEM_DECL(1);
     MPIU_CHKLMEM_DECL(1);
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3U_WIN_GATHER_INFO);
 
@@ -54,17 +54,9 @@ int MPIDI_CH3U_Win_gather_info(void *base, MPI_Aint size, int disp_unit,
     MPIR_T_PVAR_TIMER_START(RMA, rma_wincreate_allgather);
     /* allocate memory for the base addresses, disp_units, and
      * completion counters of all processes */
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->base_addrs, void **,
-                        comm_size * sizeof(void *), mpi_errno, "(*win_ptr)->base_addrs");
-
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->sizes, MPI_Aint *, comm_size * sizeof(MPI_Aint),
-                        mpi_errno, "(*win_ptr)->sizes");
-
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->disp_units, int *, comm_size * sizeof(int),
-                        mpi_errno, "(*win_ptr)->disp_units");
-
-    MPIU_CHKPMEM_MALLOC((*win_ptr)->all_win_handles, MPI_Win *,
-                        comm_size * sizeof(MPI_Win), mpi_errno, "(*win_ptr)->all_win_handles");
+    MPIU_CHKPMEM_MALLOC((*win_ptr)->basic_info_table, MPIDI_Win_basic_info_t *,
+                        comm_size * sizeof(MPIDI_Win_basic_info_t),
+                        mpi_errno, "(*win_ptr)->basic_info_table");
 
     /* get the addresses of the windows, window objects, and completion
      * counters of all processes.  allocate temp. buffer for communication */
@@ -89,10 +81,10 @@ int MPIDI_CH3U_Win_gather_info(void *base, MPI_Aint size, int disp_unit,
 
     k = 0;
     for (i = 0; i < comm_size; i++) {
-        (*win_ptr)->base_addrs[i] = MPIU_AintToPtr(tmp_buf[k++]);
-        (*win_ptr)->sizes[i] = tmp_buf[k++];
-        (*win_ptr)->disp_units[i] = (int) tmp_buf[k++];
-        (*win_ptr)->all_win_handles[i] = (MPI_Win) tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].base_addr = MPIU_AintToPtr(tmp_buf[k++]);
+        (*win_ptr)->basic_info_table[i].size = tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].disp_unit = (int) tmp_buf[k++];
+        (*win_ptr)->basic_info_table[i].win_handle = (MPI_Win) tmp_buf[k++];
     }
 
   fn_exit:

src/mpid/ch3/src/mpid_rma.c

@@ -305,10 +305,7 @@ static int win_init(MPI_Aint size, int disp_unit, int create_flavor, int model,
     (*win_ptr)->comm_ptr = win_comm_ptr;
 
     (*win_ptr)->at_completion_counter = 0;
-    /* (*win_ptr)->base_addrs[] is set by caller; */
-    /* (*win_ptr)->sizes[] is set by caller; */
-    /* (*win_ptr)->disp_units[] is set by caller; */
-    /* (*win_ptr)->all_win_handles[] is set by caller; */
+    /* (*win_ptr)->basic_info_table[] is set by caller; */
     (*win_ptr)->current_lock_type = MPID_LOCK_NONE;
     (*win_ptr)->shared_lock_ref_cnt = 0;
     (*win_ptr)->lock_queue = NULL;

src/mpid/ch3/src/mpidi_rma.c

@@ -233,10 +233,7 @@ int MPIDI_Win_free(MPID_Win ** win_ptr)
     if (mpi_errno)
         MPIU_ERR_POP(mpi_errno);
 
-    MPIU_Free((*win_ptr)->base_addrs);
-    MPIU_Free((*win_ptr)->sizes);
-    MPIU_Free((*win_ptr)->disp_units);
-    MPIU_Free((*win_ptr)->all_win_handles);
+    MPIU_Free((*win_ptr)->basic_info_table);
     MPIU_Free((*win_ptr)->op_pool_start);
     MPIU_Free((*win_ptr)->target_pool_start);
     MPIU_Free((*win_ptr)->slots);