mpidpkt.h 41.3 KB
Newer Older
1
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2 3 4 5 6 7 8
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#ifndef HAVE_MPIDPKT_H
#define HAVE_MPIDPKT_H
9

10 11
#include "oputil.h"

12
#ifdef HAVE_STDINT_H
13
#include <stdint.h>
14 15
#endif
#ifdef HAVE_INTTYPES_H
16
#include <inttypes.h>
17 18
#endif

19 20 21
/* Enable the use of data within the message packet for small messages */
#define USE_EAGER_SHORT
#define MPIDI_EAGER_SHORT_INTS 4
22
/* FIXME: This appears to assume that sizeof(int) == 4 (or at least >= 4) */
23 24
#define MPIDI_EAGER_SHORT_SIZE 16

25
/* This is the number of ints that can be carried within an RMA packet */
26
#define MPIDI_RMA_IMMED_BYTES 8
27

28 29 30
/* Union over all types (integer, logical, and multi-language types) that are
   allowed in a CAS operation.  This is used to allocate enough space in the
   packet header for immediate data.  */
31
typedef union {
32
#define MPIR_OP_TYPE_MACRO(mpi_type_, c_type_, type_name_) c_type_ cas_##type_name_;
33 34 35 36 37 38 39 40
    MPIR_OP_TYPE_GROUP(C_INTEGER)
    MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER)
    MPIR_OP_TYPE_GROUP(LOGICAL)
    MPIR_OP_TYPE_GROUP(BYTE)
    MPIR_OP_TYPE_GROUP(C_INTEGER_EXTRA)
    MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA)
    MPIR_OP_TYPE_GROUP(LOGICAL_EXTRA)
    MPIR_OP_TYPE_GROUP(BYTE_EXTRA)
41
#undef MPIR_OP_TYPE_MACRO
42 43
} MPIDI_CH3_CAS_Immed_u;

44 45 46 47
/* Union over all types (all predefined types) that are allowed in a
   Fetch-and-op operation.  This can be too large for the packet header, so we
   limit the immediate space in the header to FOP_IMMED_INTS. */

48 49 50
/* *INDENT-OFF* */
/* Indentation turned off because "indent" is getting confused with
 * the lack of a semi-colon in the fields below */
51
typedef union {
52
#define MPIR_OP_TYPE_MACRO(mpi_type_, c_type_, type_name_) c_type_ fop##type_name_;
53 54
    MPIR_OP_TYPE_GROUP_ALL_BASIC
    MPIR_OP_TYPE_GROUP_ALL_EXTRA
55
#undef MPIR_OP_TYPE_MACRO
56
} MPIDI_CH3_FOP_Immed_u;
57
/* *INDENT-ON* */
58

59
/*
60
 * Predefined packet types.  This simplifies some of the code.
61
 */
62 63
/* FIXME: Having predefined names makes it harder to add new message types,
   such as different RMA types. */
64
typedef enum {
Xin Zhao's avatar
Xin Zhao committed
65
    MPIDI_CH3_PKT_EAGER_SEND = 0,
66
#if defined(USE_EAGER_SHORT)
67
    MPIDI_CH3_PKT_EAGERSHORT_SEND,
68
#endif /* defined(USE_EAGER_SHORT) */
69
    MPIDI_CH3_PKT_EAGER_SYNC_SEND,      /* FIXME: no sync eager */
70 71 72 73
    MPIDI_CH3_PKT_EAGER_SYNC_ACK,
    MPIDI_CH3_PKT_READY_SEND,
    MPIDI_CH3_PKT_RNDV_REQ_TO_SEND,
    MPIDI_CH3_PKT_RNDV_CLR_TO_SEND,
74
    MPIDI_CH3_PKT_RNDV_SEND,    /* FIXME: should be stream put */
75 76
    MPIDI_CH3_PKT_CANCEL_SEND_REQ,
    MPIDI_CH3_PKT_CANCEL_SEND_RESP,
Xin Zhao's avatar
Xin Zhao committed
77 78
    /* RMA Packets begin here */
    MPIDI_CH3_PKT_PUT,
79
    MPIDI_CH3_PKT_PUT_IMMED,
80 81
    MPIDI_CH3_PKT_GET,
    MPIDI_CH3_PKT_ACCUMULATE,
82
    MPIDI_CH3_PKT_ACCUMULATE_IMMED,
Xin Zhao's avatar
Xin Zhao committed
83
    MPIDI_CH3_PKT_GET_ACCUM,
84
    MPIDI_CH3_PKT_GET_ACCUM_IMMED,
Xin Zhao's avatar
Xin Zhao committed
85
    MPIDI_CH3_PKT_FOP,
86 87
    MPIDI_CH3_PKT_FOP_IMMED,
    MPIDI_CH3_PKT_CAS_IMMED,
Xin Zhao's avatar
Xin Zhao committed
88
    MPIDI_CH3_PKT_GET_RESP,
89
    MPIDI_CH3_PKT_GET_RESP_IMMED,
Xin Zhao's avatar
Xin Zhao committed
90
    MPIDI_CH3_PKT_GET_ACCUM_RESP,
91
    MPIDI_CH3_PKT_GET_ACCUM_RESP_IMMED,
Xin Zhao's avatar
Xin Zhao committed
92
    MPIDI_CH3_PKT_FOP_RESP,
93 94
    MPIDI_CH3_PKT_FOP_RESP_IMMED,
    MPIDI_CH3_PKT_CAS_RESP_IMMED,
95
    MPIDI_CH3_PKT_LOCK,
96 97
    MPIDI_CH3_PKT_LOCK_ACK,
    MPIDI_CH3_PKT_LOCK_OP_ACK,
98
    MPIDI_CH3_PKT_UNLOCK,
99
    MPIDI_CH3_PKT_FLUSH,
100
    MPIDI_CH3_PKT_FLUSH_ACK,
101
    MPIDI_CH3_PKT_DECR_AT_COUNTER,
102 103
    /* RMA Packets end here */
    MPIDI_CH3_PKT_FLOW_CNTL_UPDATE,     /* FIXME: Unused */
104
    MPIDI_CH3_PKT_CLOSE,
Wesley Bland's avatar
Wesley Bland committed
105
    MPIDI_CH3_PKT_REVOKE,
Pavan Balaji's avatar
Pavan Balaji committed
106
    MPIDI_CH3_PKT_END_CH3,
107
    /* The channel can define additional types by defining the value
108
     * MPIDI_CH3_PKT_ENUM */
109
#if defined(MPIDI_CH3_PKT_ENUM)
Pavan Balaji's avatar
Pavan Balaji committed
110
    MPIDI_CH3_PKT_ENUM,
111
#endif
Pavan Balaji's avatar
Pavan Balaji committed
112
    MPIDI_CH3_PKT_END_ALL,
113
    MPIDI_CH3_PKT_INVALID = -1  /* forces a signed enum to quash warnings */
Pavan Balaji's avatar
Pavan Balaji committed
114
} MPIDI_CH3_Pkt_type_t;
115

116
/* These flags can be "OR'ed" together */
117 118
typedef enum {
    MPIDI_CH3_PKT_FLAG_NONE = 0,
119 120 121 122 123 124 125 126 127 128 129 130 131
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_SHARED = 1,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_EXCLUSIVE = 2,
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK = 4,
    MPIDI_CH3_PKT_FLAG_RMA_FLUSH = 8,
    MPIDI_CH3_PKT_FLAG_RMA_REQ_ACK = 16,
    MPIDI_CH3_PKT_FLAG_RMA_DECR_AT_COUNTER = 32,
    MPIDI_CH3_PKT_FLAG_RMA_NOCHECK = 64,
    MPIDI_CH3_PKT_FLAG_RMA_FLUSH_ACK = 128,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_GRANTED = 256,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_QUEUED_DATA_QUEUED = 512,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_QUEUED_DATA_DISCARDED = 1024,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_DISCARDED = 2048,
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK_NO_ACK = 4096,
132 133
    MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP = 8192,
    MPIDI_CH3_PKT_FLAG_RMA_STREAM = 16384
134
} MPIDI_CH3_Pkt_flags_t;
135

136
typedef struct MPIDI_CH3_Pkt_send {
137 138
    MPIDI_CH3_Pkt_type_t type;  /* XXX - uint8_t to conserve space ??? */
    MPIDI_Message_match match;
139
    MPI_Request sender_req_id;  /* needed for ssend and send cancel */
140 141 142
    MPIDI_msg_sz_t data_sz;
#if defined(MPID_USE_SEQUENCE_NUMBERS)
    MPID_Seqnum_t seqnum;
143 144
#endif
} MPIDI_CH3_Pkt_send_t;
145

146
/* NOTE: Normal and synchronous eager sends, as well as all ready-mode sends,
147 148 149 150
   use the same structure but have a different type value. */
typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_eager_send_t;
typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_eager_sync_send_t;
typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_ready_send_t;
151 152

#if defined(USE_EAGER_SHORT)
153
typedef struct MPIDI_CH3_Pkt_eagershort_send {
154 155 156 157 158 159
    MPIDI_CH3_Pkt_type_t type;  /* XXX - uint8_t to conserve space ??? */
    MPIDI_Message_match match;
    MPIDI_msg_sz_t data_sz;
#if defined(MPID_USE_SEQUENCE_NUMBERS)
    MPID_Seqnum_t seqnum;
#endif
160 161
    int data[MPIDI_EAGER_SHORT_INTS];   /* FIXME: Experimental for now */
} MPIDI_CH3_Pkt_eagershort_send_t;
162
#endif /* defined(USE_EAGER_SHORT) */
163

164
typedef struct MPIDI_CH3_Pkt_eager_sync_ack {
165 166
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
167
} MPIDI_CH3_Pkt_eager_sync_ack_t;
168 169 170

typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_rndv_req_to_send_t;

171
typedef struct MPIDI_CH3_Pkt_rndv_clr_to_send {
172 173 174
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    MPI_Request receiver_req_id;
175
} MPIDI_CH3_Pkt_rndv_clr_to_send_t;
176

177
typedef struct MPIDI_CH3_Pkt_rndv_send {
178 179
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request receiver_req_id;
180
} MPIDI_CH3_Pkt_rndv_send_t;
181

182
typedef struct MPIDI_CH3_Pkt_cancel_send_req {
183 184 185
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_Message_match match;
    MPI_Request sender_req_id;
186
} MPIDI_CH3_Pkt_cancel_send_req_t;
187

188
typedef struct MPIDI_CH3_Pkt_cancel_send_resp {
189 190 191
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    int ack;
192
} MPIDI_CH3_Pkt_cancel_send_resp_t;
193

194 195 196
/* *INDENT-OFF* */
/* Indentation turned off because "indent" is getting confused with
 * the lack of a semi-colon in the field below */
197 198 199
#if defined(MPIDI_CH3_PKT_DEFS)
MPIDI_CH3_PKT_DEFS
#endif
200
/* *INDENT-ON* */
201

202 203
#define MPIDI_CH3_PKT_RMA_GET_TARGET_DATATYPE(pkt_, datatype_, err_)    \
    {                                                                   \
204 205
        /* This macro returns target_datatype in RMA operation          \
           packets. (PUT, GET, ACC, GACC, CAS, FOP) */                  \
206
        err_ = MPI_SUCCESS;                                             \
Xin Zhao's avatar
Xin Zhao committed
207
        switch((pkt_).type) {                                           \
208
        case (MPIDI_CH3_PKT_PUT):                                       \
209
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
210
            datatype_ = (pkt_).put.datatype;                            \
211 212
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
Xin Zhao's avatar
Xin Zhao committed
213
            datatype_ = (pkt_).get.datatype;                            \
214 215
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
216
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
Xin Zhao's avatar
Xin Zhao committed
217
            datatype_ = (pkt_).accum.datatype;                          \
218
            break;                                                      \
Xin Zhao's avatar
Xin Zhao committed
219
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
220
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
Xin Zhao's avatar
Xin Zhao committed
221
            datatype_ = (pkt_).get_accum.datatype;                      \
Xin Zhao's avatar
Xin Zhao committed
222
            break;                                                      \
223
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
224
            datatype_ = (pkt_).cas.datatype;                            \
225 226
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
227
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
228
            datatype_ = (pkt_).fop.datatype;                            \
229 230
            break;                                                      \
        default:                                                        \
Xin Zhao's avatar
Xin Zhao committed
231
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
232 233 234
        }                                                               \
    }

235 236
#define MPIDI_CH3_PKT_RMA_GET_TARGET_COUNT(pkt_, count_, err_)          \
    {                                                                   \
237 238
        /* This macro returns target_count in RMA operation             \
           packets. (PUT, GET, ACC, GACC, CAS, FOP) */                  \
239 240 241
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
242
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
243 244 245 246 247 248
            count_ = (pkt_).put.count;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            count_ = (pkt_).get.count;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
249
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
250 251 252
            count_ = (pkt_).accum.count;                                \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
253
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
254 255
            count_ = (pkt_).get_accum.count;                            \
            break;                                                      \
256
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
257
        case (MPIDI_CH3_PKT_FOP):                                       \
258
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
259 260 261 262 263 264 265 266 267
            count_ = 1;                                                 \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_GET_IMMED_DATA_PTR(pkt_, immed_data_, err_)   \
    {                                                                   \
268 269 270
        /* This macro returns pointer to immed data in RMA operation    \
           packets (PUT, ACC, GACC, FOP, CAS) and RMA response          \
           packets (GET_RESP, GACC_RESP, FOP_RESP, CAS_RESP). */        \
271 272
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
273 274
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
            immed_data_ = (pkt_).put.info.data;                         \
275
            break;                                                      \
276 277
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
            immed_data_ = (pkt_).accum.info.data;                       \
278
            break;                                                      \
279 280
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
            immed_data_ = (pkt_).get_accum.info.data;                   \
281
            break;                                                      \
282 283
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
            immed_data_ = (pkt_).fop.info.data;                         \
284
            break;                                                      \
285
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
286 287 288 289
            /* Note that here we return pointer of origin data, not     \
               pointer of compare data. */                              \
            immed_data_ = &((pkt_).cas.origin_data);                    \
            break;                                                      \
290 291
        case (MPIDI_CH3_PKT_GET_RESP_IMMED):                            \
            immed_data_ = (pkt_).get_resp.info.data;                    \
292
            break;                                                      \
293 294
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP_IMMED):                      \
            immed_data_ = (pkt_).get_accum_resp.info.data;              \
295
            break;                                                      \
296 297
        case (MPIDI_CH3_PKT_FOP_RESP_IMMED):                            \
            immed_data_ = (pkt_).fop_resp.info.data;                    \
298
            break;                                                      \
299 300
        case (MPIDI_CH3_PKT_CAS_RESP_IMMED):                            \
            immed_data_ = &((pkt_).cas_resp.info.data);                 \
301 302 303 304 305 306
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

Xin Zhao's avatar
Xin Zhao committed
307 308
#define MPIDI_CH3_PKT_RMA_GET_FLAGS(pkt_, flags_, err_)                 \
    {                                                                   \
309 310 311 312 313
        /* This macro returns flags in RMA operation packets (PUT, GET, \
           ACC, GACC, FOP, CAS), RMA operation response packets         \
           (GET_RESP, GET_ACCUM_RESP, FOP_RESP, CAS_RESP), RMA control  \
           packets (UNLOCK) and RMA control response packets (LOCK_ACK, \
           LOCK_OP_ACK) */                                              \
Xin Zhao's avatar
Xin Zhao committed
314 315 316
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
317
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
318 319 320 321 322 323
            flags_ = (pkt_).put.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            flags_ = (pkt_).get.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
324
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
Xin Zhao's avatar
Xin Zhao committed
325 326 327
            flags_ = (pkt_).accum.flags;                                \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
328
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
Xin Zhao's avatar
Xin Zhao committed
329 330
            flags_ = (pkt_).get_accum.flags;                            \
            break;                                                      \
331
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
332 333 334
            flags_ = (pkt_).cas.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
335
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
Xin Zhao's avatar
Xin Zhao committed
336 337
            flags_ = (pkt_).fop.flags;                                  \
            break;                                                      \
338
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
339
        case (MPIDI_CH3_PKT_GET_RESP_IMMED):                            \
340 341 342
            flags_ = (pkt_).get_resp.flags;                             \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
343
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP_IMMED):                      \
344 345 346
            flags_ = (pkt_).get_accum_resp.flags;                       \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
347
        case (MPIDI_CH3_PKT_FOP_RESP_IMMED):                            \
348 349
            flags_ = (pkt_).fop_resp.flags;                             \
            break;                                                      \
350
        case (MPIDI_CH3_PKT_CAS_RESP_IMMED):                            \
351 352
            flags_ = (pkt_).cas_resp.flags;                             \
            break;                                                      \
353 354 355
        case (MPIDI_CH3_PKT_LOCK):                                      \
            flags_ = (pkt_).lock.flags;                                 \
            break;                                                      \
356 357 358 359 360 361 362 363 364
        case (MPIDI_CH3_PKT_UNLOCK):                                    \
            flags_ = (pkt_).unlock.flags;                               \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_ACK):                                  \
            flags_ = (pkt_).lock_ack.flags;                             \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_OP_ACK):                               \
            flags_ = (pkt_).lock_op_ack.flags;                          \
            break;                                                      \
Xin Zhao's avatar
Xin Zhao committed
365 366 367 368 369
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

370 371
#define MPIDI_CH3_PKT_RMA_ERASE_FLAGS(pkt_, err_)                       \
    {                                                                   \
372 373 374 375 376
        /* This macro erases flags in RMA operation packets (PUT, GET,  \
           ACC, GACC, FOP, CAS), RMA operation response packets         \
           (GET_RESP, GET_ACCUM_RESP, FOP_RESP, CAS_RESP), RMA control  \
           packets (UNLOCK) and RMA control response packets (LOCK_ACK, \
           LOCK_OP_ACK) */                                              \
377 378 379
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
380
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
381 382 383 384 385 386
            (pkt_).put.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            (pkt_).get.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
387
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
388 389 390
            (pkt_).accum.flags = MPIDI_CH3_PKT_FLAG_NONE;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
391
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
392 393
            (pkt_).get_accum.flags = MPIDI_CH3_PKT_FLAG_NONE;           \
            break;                                                      \
394
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
395 396 397
            (pkt_).cas.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
398
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
399 400
            (pkt_).fop.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
401
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
402
        case (MPIDI_CH3_PKT_GET_RESP_IMMED):                            \
403 404 405
            (pkt_).get_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
406
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP_IMMED):                      \
407 408 409
            (pkt_).get_accum_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;      \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
410
        case (MPIDI_CH3_PKT_FOP_RESP_IMMED):                            \
411 412
            (pkt_).fop_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
413
        case (MPIDI_CH3_PKT_CAS_RESP_IMMED):                            \
414 415
            (pkt_).cas_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
416 417 418
        case (MPIDI_CH3_PKT_LOCK):                                      \
            (pkt_).lock.flags = MPIDI_CH3_PKT_FLAG_NONE;                \
            break;                                                      \
419 420 421 422 423 424 425 426 427
        case (MPIDI_CH3_PKT_UNLOCK):                                    \
            (pkt_).unlock.flags = MPIDI_CH3_PKT_FLAG_NONE;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_ACK):                                  \
            (pkt_).lock_ack.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_OP_ACK):                               \
            (pkt_).lock_op_ack.flags = MPIDI_CH3_PKT_FLAG_NONE;         \
            break;                                                      \
428 429 430 431 432 433 434
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_GET_SOURCE_WIN_HANDLE(pkt_, win_hdl_, err_)   \
    {                                                                   \
435 436 437 438 439
        /* This macro returns source_win_handle in RMA operation        \
           packets (PUT, GET, ACC, GACC, CAS, FOP), RMA operation       \
           response packets (GET_RESP, GACC_RESP, CAS_RESP, FOP_RESP),  \
           RMA control packets (LOCK, UNLOCK, FLUSH), and RMA control   \
           response packets (LOCK_ACK, LOCK_OP_ACK, FLUSH_ACK). */      \
440 441 442
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
443
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
444 445 446
            win_hdl_ = (pkt_).put.source_win_handle;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
447
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
448 449 450 451 452
            win_hdl_ = (pkt_).accum.source_win_handle;                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK):                                      \
            win_hdl_ = (pkt_).lock.source_win_handle;                   \
            break;                                                      \
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
        case (MPIDI_CH3_PKT_UNLOCK):                                    \
            win_hdl_ = (pkt_).unlock.source_win_handle;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_FLUSH):                                     \
            win_hdl_ = (pkt_).flush.source_win_handle;                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_ACK):                                  \
            win_hdl_ = (pkt_).lock_ack.source_win_handle;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_OP_ACK):                               \
            win_hdl_ = (pkt_).lock_op_ack.source_win_handle;            \
            break;                                                      \
        case (MPIDI_CH3_PKT_FLUSH_ACK):                                 \
            win_hdl_ = (pkt_).flush_ack.source_win_handle;              \
            break;                                                      \
468 469 470 471 472
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

473
#define MPIDI_CH3_PKT_RMA_GET_TARGET_WIN_HANDLE(pkt_, win_hdl_, err_)   \
Xin Zhao's avatar
Xin Zhao committed
474
    {                                                                   \
475 476 477
        /* This macro returns target_win_handle in RMA operation        \
           packets (PUT, GET, ACC, GACC, CAS, FOP) and RMA control      \
           packets (LOCK, UNLOCK, FLUSH, DECR_AT_CNT) */                \
Xin Zhao's avatar
Xin Zhao committed
478 479 480
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
481
        case (MPIDI_CH3_PKT_PUT_IMMED):                                 \
482
            win_hdl_ = (pkt_).put.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
483 484
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
485
            win_hdl_ = (pkt_).get.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
486 487
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
488
        case (MPIDI_CH3_PKT_ACCUMULATE_IMMED):                          \
489
            win_hdl_ = (pkt_).accum.target_win_handle;                  \
Xin Zhao's avatar
Xin Zhao committed
490 491
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
492
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
493
            win_hdl_ = (pkt_).get_accum.target_win_handle;              \
Xin Zhao's avatar
Xin Zhao committed
494
            break;                                                      \
495
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
496
            win_hdl_ = (pkt_).cas.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
497 498
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
499
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
500
            win_hdl_ = (pkt_).fop.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
501
            break;                                                      \
502 503 504
        case (MPIDI_CH3_PKT_LOCK):                                      \
            win_hdl_ = (pkt_).lock.target_win_handle;                   \
            break;                                                      \
505 506 507 508 509 510 511 512 513
        case (MPIDI_CH3_PKT_UNLOCK):                                    \
            win_hdl_ = (pkt_).unlock.target_win_handle;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_FLUSH):                                     \
            win_hdl_ = (pkt_).flush.target_win_handle;                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_DECR_AT_COUNTER):                           \
            win_hdl_ = (pkt_).decr_at_cnt.target_win_handle;            \
            break;                                                      \
Xin Zhao's avatar
Xin Zhao committed
514 515 516 517 518 519 520
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_SET_DATALOOP_SIZE(pkt_, dataloop_size_, err_) \
    {                                                                   \
521 522
        /* This macro sets dataloop_size in RMA operation packets       \
           (PUT, GET, ACC, GACC) */                                     \
Xin Zhao's avatar
Xin Zhao committed
523 524 525
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
526
            (pkt_).put.info.dataloop_size = (dataloop_size_);           \
Xin Zhao's avatar
Xin Zhao committed
527 528
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
529
            (pkt_).get.info.dataloop_size = (dataloop_size_);           \
Xin Zhao's avatar
Xin Zhao committed
530 531
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
532
            (pkt_).accum.info.dataloop_size = (dataloop_size_);         \
Xin Zhao's avatar
Xin Zhao committed
533 534
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
535
            (pkt_).get_accum.info.dataloop_size = (dataloop_size_);     \
536 537 538 539 540 541
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
#define MPIDI_CH3_PKT_RMA_GET_REQUEST_HANDLE(pkt_, request_hdl_, err_)  \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_GET):                                       \
            request_hdl_ = (pkt_).get.request_handle;                   \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
        case (MPIDI_CH3_PKT_GET_ACCUM_IMMED):                           \
            request_hdl_ = (pkt_).get_accum.request_handle;             \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_IMMED):                                 \
            request_hdl_ = (pkt_).cas.request_handle;                   \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
        case (MPIDI_CH3_PKT_FOP_IMMED):                                 \
            request_hdl_ = (pkt_).fop.request_handle;                   \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
        case (MPIDI_CH3_PKT_GET_RESP_IMMED):                            \
            request_hdl_ = (pkt_).get_resp.request_handle;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP_IMMED):                      \
            request_hdl_ = (pkt_).get_accum_resp.request_handle;        \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
        case (MPIDI_CH3_PKT_FOP_RESP_IMMED):                            \
            request_hdl_ = (pkt_).fop_resp.request_handle;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP_IMMED):                            \
            request_hdl_ = (pkt_).cas_resp.request_handle;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK):                                      \
            request_hdl_ = (pkt_).lock.request_handle;                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_ACK):                                  \
            request_hdl_ = (pkt_).lock_ack.request_handle;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK_OP_ACK):                               \
            request_hdl_ = (pkt_).lock_op_ack.request_handle;           \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

589
typedef struct MPIDI_CH3_Pkt_put {
590
    MPIDI_CH3_Pkt_type_t type;
591
    MPIDI_CH3_Pkt_flags_t flags;
592 593 594
    void *addr;
    int count;
    MPI_Datatype datatype;
595 596
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
597
    union {
598
        int dataloop_size;
599 600
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
601 602 603
} MPIDI_CH3_Pkt_put_t;

typedef struct MPIDI_CH3_Pkt_get {
604
    MPIDI_CH3_Pkt_type_t type;
605
    MPIDI_CH3_Pkt_flags_t flags;
606 607 608
    void *addr;
    int count;
    MPI_Datatype datatype;
609
    struct {
610
        int dataloop_size;      /* for derived datatypes */
611
    } info;
612
    MPI_Request request_handle;
613
    MPI_Win target_win_handle;
614 615
} MPIDI_CH3_Pkt_get_t;

616 617 618 619 620 621
typedef struct MPIDI_CH3_Pkt_get_resp {
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request request_handle;
    /* followings are used to decrement ack_counter at origin */
    int target_rank;
    MPIDI_CH3_Pkt_flags_t flags;
622
    /* Followings are to piggyback IMMED data */
623 624
    struct {
        /* note that we use struct here in order
625 626
         * to consistently access data
         * by "pkt->info.data". */
627 628
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
629 630
} MPIDI_CH3_Pkt_get_resp_t;

631
typedef struct MPIDI_CH3_Pkt_accum {
632
    MPIDI_CH3_Pkt_type_t type;
633
    MPIDI_CH3_Pkt_flags_t flags;
634 635 636 637
    void *addr;
    int count;
    MPI_Datatype datatype;
    MPI_Op op;
638 639
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
640
    union {
641
        int dataloop_size;
642 643
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
644 645
} MPIDI_CH3_Pkt_accum_t;

Xin Zhao's avatar
Xin Zhao committed
646 647 648
typedef struct MPIDI_CH3_Pkt_get_accum {
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
649
    MPI_Request request_handle; /* For get_accumulate response */
Xin Zhao's avatar
Xin Zhao committed
650 651 652 653
    void *addr;
    int count;
    MPI_Datatype datatype;
    MPI_Op op;
654
    MPI_Win target_win_handle;
655
    union {
656
        int dataloop_size;
657 658
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
Xin Zhao's avatar
Xin Zhao committed
659 660
} MPIDI_CH3_Pkt_get_accum_t;

661
typedef struct MPIDI_CH3_Pkt_get_accum_resp {
662
    MPIDI_CH3_Pkt_type_t type;
663
    MPI_Request request_handle;
664 665 666
    /* followings are used to decrement ack_counter at origin */
    int target_rank;
    MPIDI_CH3_Pkt_flags_t flags;
667
    /* Followings are to piggyback IMMED data */
668 669
    struct {
        /* note that we use struct here in order
670 671
         * to consistently access data
         * by "pkt->info.data". */
672 673
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
674
} MPIDI_CH3_Pkt_get_accum_resp_t;
675

676
typedef struct MPIDI_CH3_Pkt_cas {
677
    MPIDI_CH3_Pkt_type_t type;
678
    MPIDI_CH3_Pkt_flags_t flags;
679
    MPI_Datatype datatype;
680
    void *addr;
681
    MPI_Request request_handle;
682
    MPI_Win target_win_handle;
683 684
    MPIDI_CH3_CAS_Immed_u origin_data;
    MPIDI_CH3_CAS_Immed_u compare_data;
685
} MPIDI_CH3_Pkt_cas_t;
686

687
typedef struct MPIDI_CH3_Pkt_cas_resp {
688 689
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request request_handle;
690 691
    struct {
        /* note that we use struct here in order
692 693
         * to consistently access data
         * by "pkt->info.data". */
694 695
        MPIDI_CH3_CAS_Immed_u data;
    } info;
696
    /* followings are used to decrement ack_counter at orign */
697
    int target_rank;
698 699
    MPIDI_CH3_Pkt_flags_t flags;
} MPIDI_CH3_Pkt_cas_resp_t;
700

701
typedef struct MPIDI_CH3_Pkt_fop {
702
    MPIDI_CH3_Pkt_type_t type;
703
    MPIDI_CH3_Pkt_flags_t flags;
704 705 706
    MPI_Datatype datatype;
    void *addr;
    MPI_Op op;
707
    MPI_Request request_handle;
708
    MPI_Win target_win_handle;
709 710
    struct {
        /* note that we use struct here in order
711 712
         * to consistently access data
         * by "pkt->info.data". */
713 714
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
715
} MPIDI_CH3_Pkt_fop_t;
716

717
typedef struct MPIDI_CH3_Pkt_fop_resp {
718 719
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request request_handle;
720 721
    struct {
        /* note that we use struct here in order
722 723
         * to consistently access data
         * by "pkt->info.data". */
724 725
        char data[MPIDI_RMA_IMMED_BYTES];
    } info;
726
    /* followings are used to decrement ack_counter at orign */
727
    int target_rank;
728 729
    MPIDI_CH3_Pkt_flags_t flags;
} MPIDI_CH3_Pkt_fop_resp_t;
730

731
typedef struct MPIDI_CH3_Pkt_lock {
732
    MPIDI_CH3_Pkt_type_t type;
733
    MPIDI_CH3_Pkt_flags_t flags;
734
    MPI_Win target_win_handle;
735
    /* Note that either source_win_handle
736 737 738 739 740
     * or request_handle will be used. Here
     * we need both of them because PUT/GET
     * may be converted to LOCK packet,
     * PUT has source_win_handle area and
     * GET has request_handle area. */
741
    MPI_Win source_win_handle;
742
    MPI_Request request_handle;
743
} MPIDI_CH3_Pkt_lock_t;
744

Xin Zhao's avatar
Xin Zhao committed
745 746 747 748
typedef struct MPIDI_CH3_Pkt_unlock {
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
749
    MPIDI_CH3_Pkt_flags_t flags;
Xin Zhao's avatar
Xin Zhao committed
750 751 752 753 754 755 756 757
} MPIDI_CH3_Pkt_unlock_t;

typedef struct MPIDI_CH3_Pkt_flush {
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
} MPIDI_CH3_Pkt_flush_t;

758
typedef struct MPIDI_CH3_Pkt_lock_ack {
759 760
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
761
    /* note that either source_win_handle
762
     * or request_handle is used. */
763
    MPI_Win source_win_handle;
764
    MPI_Request request_handle;
765
    int target_rank;
766 767 768 769 770
} MPIDI_CH3_Pkt_lock_ack_t;

typedef struct MPIDI_CH3_Pkt_lock_op_ack {
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
771
    /* note that either source_win_handle
772
     * or request_handle is used. */
773
    MPI_Win source_win_handle;
774
    MPI_Request request_handle;
775 776
    int target_rank;
} MPIDI_CH3_Pkt_lock_op_ack_t;
777

Xin Zhao's avatar
Xin Zhao committed
778 779
typedef struct MPIDI_CH3_Pkt_flush_ack {
    MPIDI_CH3_Pkt_type_t type;
780
    MPI_Win source_win_handle;
781
    int target_rank;
782
    MPIDI_CH3_Pkt_flags_t flags;
Xin Zhao's avatar
Xin Zhao committed
783
} MPIDI_CH3_Pkt_flush_ack_t;
784

785 786 787 788
typedef struct MPIDI_CH3_Pkt_decr_at_counter {
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win target_win_handle;
} MPIDI_CH3_Pkt_decr_at_counter_t;
789

790
typedef struct MPIDI_CH3_Pkt_close {
791 792
    MPIDI_CH3_Pkt_type_t type;
    int ack;
793
} MPIDI_CH3_Pkt_close_t;
794

795
typedef struct MPIDI_CH3_Pkt_revoke {
Wesley Bland's avatar
Wesley Bland committed
796 797
    MPIDI_CH3_Pkt_type_t type;
    MPIR_Context_id_t revoked_comm;
798
} MPIDI_CH3_Pkt_revoke_t;
Wesley Bland's avatar
Wesley Bland committed
799

800
typedef union MPIDI_CH3_Pkt {
801 802
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_eager_send_t eager_send;
803
#if defined(USE_EAGER_SHORT)
804
    MPIDI_CH3_Pkt_eagershort_send_t eagershort_send;
805
#endif                          /* defined(USE_EAGER_SHORT) */
806 807 808 809 810 811 812 813 814 815
    MPIDI_CH3_Pkt_eager_sync_send_t eager_sync_send;
    MPIDI_CH3_Pkt_eager_sync_ack_t eager_sync_ack;
    MPIDI_CH3_Pkt_eager_send_t ready_send;
    MPIDI_CH3_Pkt_rndv_req_to_send_t rndv_req_to_send;
    MPIDI_CH3_Pkt_rndv_clr_to_send_t rndv_clr_to_send;
    MPIDI_CH3_Pkt_rndv_send_t rndv_send;
    MPIDI_CH3_Pkt_cancel_send_req_t cancel_send_req;
    MPIDI_CH3_Pkt_cancel_send_resp_t cancel_send_resp;
    MPIDI_CH3_Pkt_put_t put;
    MPIDI_CH3_Pkt_get_t get;
816
    MPIDI_CH3_Pkt_get_resp_t get_resp;
817
    MPIDI_CH3_Pkt_accum_t accum;
Xin Zhao's avatar
Xin Zhao committed
818
    MPIDI_CH3_Pkt_get_accum_t get_accum;
819
    MPIDI_CH3_Pkt_lock_t lock;
820 821
    MPIDI_CH3_Pkt_lock_ack_t lock_ack;
    MPIDI_CH3_Pkt_lock_op_ack_t lock_op_ack;
822
    MPIDI_CH3_Pkt_unlock_t unlock;
823
    MPIDI_CH3_Pkt_flush_t flush;
824
    MPIDI_CH3_Pkt_flush_ack_t flush_ack;
825
    MPIDI_CH3_Pkt_decr_at_counter_t decr_at_cnt;
826
    MPIDI_CH3_Pkt_close_t close;
827 828 829 830 831
    MPIDI_CH3_Pkt_cas_t cas;
    MPIDI_CH3_Pkt_cas_resp_t cas_resp;
    MPIDI_CH3_Pkt_fop_t fop;
    MPIDI_CH3_Pkt_fop_resp_t fop_resp;
    MPIDI_CH3_Pkt_get_accum_resp_t get_accum_resp;
Wesley Bland's avatar
Wesley Bland committed
832
    MPIDI_CH3_Pkt_revoke_t revoke;
833
#if defined(MPIDI_CH3_PKT_DECL)
834
     MPIDI_CH3_PKT_DECL
835
#endif
836
} MPIDI_CH3_Pkt_t;
837

838 839 840 841 842 843 844 845
typedef struct MPIDI_CH3_Ext_pkt_accum {
    MPI_Aint stream_offset;
} MPIDI_CH3_Ext_pkt_accum_t;

typedef struct MPIDI_CH3_Ext_pkt_get_accum {
    MPI_Aint stream_offset;
} MPIDI_CH3_Ext_pkt_get_accum_t;

846
#if defined(MPID_USE_SEQUENCE_NUMBERS)