mpidpkt.h 44.2 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 13 14 15 16 17 18
#ifdef HAVE_STDINT_H
#  include <stdint.h>
#endif
#ifdef HAVE_INTTYPES_H
#  include <inttypes.h>
#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 */
Xin Zhao's avatar
Xin Zhao committed
26
#define MPIDI_RMA_IMMED_BYTES 16
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 80
    MPIDI_CH3_PKT_GET,
    MPIDI_CH3_PKT_ACCUMULATE,
Xin Zhao's avatar
Xin Zhao committed
81 82 83 84 85 86 87
    MPIDI_CH3_PKT_GET_ACCUM,
    MPIDI_CH3_PKT_FOP,
    MPIDI_CH3_PKT_CAS,
    MPIDI_CH3_PKT_GET_RESP,
    MPIDI_CH3_PKT_GET_ACCUM_RESP,
    MPIDI_CH3_PKT_FOP_RESP,
    MPIDI_CH3_PKT_CAS_RESP,
88
    MPIDI_CH3_PKT_LOCK,
89 90
    MPIDI_CH3_PKT_LOCK_ACK,
    MPIDI_CH3_PKT_LOCK_OP_ACK,
91
    MPIDI_CH3_PKT_UNLOCK,
92
    MPIDI_CH3_PKT_FLUSH,
93
    MPIDI_CH3_PKT_FLUSH_ACK,
94
    MPIDI_CH3_PKT_DECR_AT_COUNTER,
95 96
    /* RMA Packets end here */
    MPIDI_CH3_PKT_FLOW_CNTL_UPDATE,     /* FIXME: Unused */
97
    MPIDI_CH3_PKT_CLOSE,
Wesley Bland's avatar
Wesley Bland committed
98
    MPIDI_CH3_PKT_REVOKE,
Pavan Balaji's avatar
Pavan Balaji committed
99
    MPIDI_CH3_PKT_END_CH3,
100
    /* The channel can define additional types by defining the value
101
     * MPIDI_CH3_PKT_ENUM */
102
# if defined(MPIDI_CH3_PKT_ENUM)
Pavan Balaji's avatar
Pavan Balaji committed
103
    MPIDI_CH3_PKT_ENUM,
104
# endif
Pavan Balaji's avatar
Pavan Balaji committed
105
    MPIDI_CH3_PKT_END_ALL,
106
    MPIDI_CH3_PKT_INVALID = -1  /* forces a signed enum to quash warnings */
Pavan Balaji's avatar
Pavan Balaji committed
107
} MPIDI_CH3_Pkt_type_t;
108

109
/* These flags can be "OR'ed" together */
110 111 112 113 114 115
typedef enum {
    MPIDI_CH3_PKT_FLAG_NONE = 0,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK = 1,
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK = 2,
    MPIDI_CH3_PKT_FLAG_RMA_FLUSH = 4,
    MPIDI_CH3_PKT_FLAG_RMA_REQ_ACK = 8,
116
    MPIDI_CH3_PKT_FLAG_RMA_DECR_AT_COUNTER = 16,
117 118
    MPIDI_CH3_PKT_FLAG_RMA_NOCHECK = 32,
    MPIDI_CH3_PKT_FLAG_RMA_SHARED = 64,
119
    MPIDI_CH3_PKT_FLAG_RMA_EXCLUSIVE = 128,
120
    MPIDI_CH3_PKT_FLAG_RMA_FLUSH_ACK = 256,
121 122 123 124 125 126
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_GRANTED = 512,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_QUEUED_DATA_QUEUED = 1024,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_QUEUED_DATA_DISCARDED = 2048,
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_DISCARDED = 4096,
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK_NO_ACK = 8192,
    MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP = 16384
127
} MPIDI_CH3_Pkt_flags_t;
128

129
typedef struct MPIDI_CH3_Pkt_send {
130 131
    MPIDI_CH3_Pkt_type_t type;  /* XXX - uint8_t to conserve space ??? */
    MPIDI_Message_match match;
132
    MPI_Request sender_req_id;  /* needed for ssend and send cancel */
133 134 135
    MPIDI_msg_sz_t data_sz;
#if defined(MPID_USE_SEQUENCE_NUMBERS)
    MPID_Seqnum_t seqnum;
136 137
#endif
} MPIDI_CH3_Pkt_send_t;
138

139
/* NOTE: Normal and synchronous eager sends, as well as all ready-mode sends,
140 141 142 143
   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;
144 145

#if defined(USE_EAGER_SHORT)
146
typedef struct MPIDI_CH3_Pkt_eagershort_send {
147 148 149 150 151 152
    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
153 154
    int data[MPIDI_EAGER_SHORT_INTS];   /* FIXME: Experimental for now */
} MPIDI_CH3_Pkt_eagershort_send_t;
155
#endif /* defined(USE_EAGER_SHORT) */
156

157
typedef struct MPIDI_CH3_Pkt_eager_sync_ack {
158 159
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
160
} MPIDI_CH3_Pkt_eager_sync_ack_t;
161 162 163

typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_rndv_req_to_send_t;

164
typedef struct MPIDI_CH3_Pkt_rndv_clr_to_send {
165 166 167
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    MPI_Request receiver_req_id;
168
} MPIDI_CH3_Pkt_rndv_clr_to_send_t;
169

170
typedef struct MPIDI_CH3_Pkt_rndv_send {
171 172
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request receiver_req_id;
173
} MPIDI_CH3_Pkt_rndv_send_t;
174

175
typedef struct MPIDI_CH3_Pkt_cancel_send_req {
176 177 178
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_Message_match match;
    MPI_Request sender_req_id;
179
} MPIDI_CH3_Pkt_cancel_send_req_t;
180

181
typedef struct MPIDI_CH3_Pkt_cancel_send_resp {
182 183 184
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    int ack;
185
} MPIDI_CH3_Pkt_cancel_send_resp_t;
186

187 188 189
/* *INDENT-OFF* */
/* Indentation turned off because "indent" is getting confused with
 * the lack of a semi-colon in the field below */
190 191 192
#if defined(MPIDI_CH3_PKT_DEFS)
MPIDI_CH3_PKT_DEFS
#endif
193
/* *INDENT-ON* */
194

195 196 197
#define MPIDI_CH3_PKT_RMA_GET_TARGET_DATATYPE(pkt_, datatype_, err_)    \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
Xin Zhao's avatar
Xin Zhao committed
198
        switch((pkt_).type) {                                           \
199
        case (MPIDI_CH3_PKT_PUT):                                       \
Xin Zhao's avatar
Xin Zhao committed
200
            datatype_ = (pkt_).put.datatype;                            \
201 202
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
Xin Zhao's avatar
Xin Zhao committed
203
            datatype_ = (pkt_).get.datatype;                            \
204 205
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
Xin Zhao's avatar
Xin Zhao committed
206
            datatype_ = (pkt_).accum.datatype;                          \
207
            break;                                                      \
Xin Zhao's avatar
Xin Zhao committed
208
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
Xin Zhao's avatar
Xin Zhao committed
209
            datatype_ = (pkt_).get_accum.datatype;                      \
Xin Zhao's avatar
Xin Zhao committed
210
            break;                                                      \
211
        case (MPIDI_CH3_PKT_CAS):                                       \
Xin Zhao's avatar
Xin Zhao committed
212
            datatype_ = (pkt_).cas.datatype;                            \
213 214
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
Xin Zhao's avatar
Xin Zhao committed
215
            datatype_ = (pkt_).fop.datatype;                            \
216 217
            break;                                                      \
        default:                                                        \
Xin Zhao's avatar
Xin Zhao committed
218
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
219 220 221
        }                                                               \
    }

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
#define MPIDI_CH3_PKT_RMA_GET_TARGET_COUNT(pkt_, count_, err_)          \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            count_ = (pkt_).put.count;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            count_ = (pkt_).get.count;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            count_ = (pkt_).accum.count;                                \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            count_ = (pkt_).get_accum.count;                            \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
        case (MPIDI_CH3_PKT_FOP):                                       \
            count_ = 1;                                                 \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_GET_IMMED_LEN(pkt_, immed_len_, err_)         \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            immed_len_ = (pkt_).put.immed_len;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            immed_len_ = (pkt_).accum.immed_len;                        \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            immed_len_ = (pkt_).get_accum.immed_len;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            immed_len_ = (pkt_).fop.immed_len;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
            /* Note that here we return size of origin data, not        \
               size of compare data. */                                 \
            immed_len_ = sizeof(MPIDI_CH3_CAS_Immed_u);                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
            immed_len_ = (pkt_).get_resp.immed_len;                     \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
            immed_len_ = (pkt_).get_accum_resp.immed_len;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
            immed_len_ = (pkt_).fop_resp.immed_len;                     \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP):                                  \
            immed_len_ = sizeof(MPIDI_CH3_CAS_Immed_u);                 \
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
            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_)   \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            immed_data_ = (pkt_).put.data;                              \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            immed_data_ = (pkt_).accum.data;                            \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            immed_data_ = (pkt_).get_accum.data;                        \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            immed_data_ = (pkt_).fop.data;                              \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
            /* Note that here we return pointer of origin data, not     \
               pointer of compare data. */                              \
            immed_data_ = &((pkt_).cas.origin_data);                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
            immed_data_ = (pkt_).get_resp.data;                         \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
            immed_data_ = (pkt_).get_accum_resp.data;                   \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
            immed_data_ = (pkt_).fop_resp.data;                         \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP):                                  \
            immed_data_ = &((pkt_).cas_resp.data);                      \
317 318 319 320 321 322
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

Xin Zhao's avatar
Xin Zhao committed
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
#define MPIDI_CH3_PKT_RMA_GET_LOCK_TYPE(pkt_, lock_type_, err_)         \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            lock_type_ = (pkt_).put.lock_type;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            lock_type_ = (pkt_).get.lock_type;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            lock_type_ = (pkt_).accum.lock_type;                        \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            lock_type_ = (pkt_).get_accum.lock_type;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
            lock_type_ = (pkt_).cas.lock_type;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            lock_type_ = (pkt_).fop.lock_type;                          \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK):                                      \
            lock_type_ = (pkt_).lock.lock_type;                         \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_GET_ORIGIN_RANK(pkt_, origin_rank_, err_)     \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            origin_rank_ = (pkt_).put.origin_rank;                      \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            origin_rank_ = (pkt_).get.origin_rank;                      \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            origin_rank_ = (pkt_).accum.origin_rank;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            origin_rank_ = (pkt_).get_accum.origin_rank;                \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
            origin_rank_ = (pkt_).cas.origin_rank;                      \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            origin_rank_ = (pkt_).fop.origin_rank;                      \
            break;                                                      \
        case (MPIDI_CH3_PKT_LOCK):                                      \
            origin_rank_ = (pkt_).lock.origin_rank;                     \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

#define MPIDI_CH3_PKT_RMA_GET_FLAGS(pkt_, flags_, err_)                 \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            flags_ = (pkt_).put.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            flags_ = (pkt_).get.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            flags_ = (pkt_).accum.flags;                                \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            flags_ = (pkt_).get_accum.flags;                            \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
            flags_ = (pkt_).cas.flags;                                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            flags_ = (pkt_).fop.flags;                                  \
            break;                                                      \
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
            flags_ = (pkt_).get_resp.flags;                             \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
            flags_ = (pkt_).get_accum_resp.flags;                       \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
            flags_ = (pkt_).fop_resp.flags;                             \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP):                                  \
            flags_ = (pkt_).cas_resp.flags;                             \
            break;                                                      \
        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
426 427 428 429 430
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
#define MPIDI_CH3_PKT_RMA_ERASE_FLAGS(pkt_, err_)                       \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            (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):                                \
            (pkt_).accum.flags = MPIDI_CH3_PKT_FLAG_NONE;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            (pkt_).get_accum.flags = MPIDI_CH3_PKT_FLAG_NONE;           \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
            (pkt_).cas.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            (pkt_).fop.flags = MPIDI_CH3_PKT_FLAG_NONE;                 \
            break;                                                      \
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
            (pkt_).get_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
            (pkt_).get_accum_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;      \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
            (pkt_).fop_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP):                                  \
            (pkt_).cas_resp.flags = MPIDI_CH3_PKT_FLAG_NONE;            \
            break;                                                      \
        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;                                                      \
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
        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_)   \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            win_hdl_ = (pkt_).put.source_win_handle;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            win_hdl_ = (pkt_).get.source_win_handle;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            win_hdl_ = (pkt_).accum.source_win_handle;                  \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            win_hdl_ = (pkt_).get_accum.source_win_handle;              \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
            win_hdl_ = (pkt_).cas.source_win_handle;                    \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
            win_hdl_ = (pkt_).fop.source_win_handle;                    \
            break;                                                      \
501 502 503 504 505 506 507 508 509 510 511 512
        case (MPIDI_CH3_PKT_GET_RESP):                                  \
            win_hdl_ = (pkt_).get_resp.source_win_handle;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM_RESP):                            \
            win_hdl_ = (pkt_).get_accum_resp.source_win_handle;         \
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP_RESP):                                  \
            win_hdl_ = (pkt_).fop_resp.source_win_handle;               \
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS_RESP):                                  \
            win_hdl_ = (pkt_).cas_resp.source_win_handle;               \
            break;                                                      \
513 514 515
        case (MPIDI_CH3_PKT_LOCK):                                      \
            win_hdl_ = (pkt_).lock.source_win_handle;                   \
            break;                                                      \
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
        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;                                                      \
531 532 533 534 535
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

536
#define MPIDI_CH3_PKT_RMA_GET_TARGET_WIN_HANDLE(pkt_, win_hdl_, err_)   \
Xin Zhao's avatar
Xin Zhao committed
537 538 539 540
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
541
            win_hdl_ = (pkt_).put.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
542 543
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
544
            win_hdl_ = (pkt_).get.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
545 546
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
547
            win_hdl_ = (pkt_).accum.target_win_handle;                  \
Xin Zhao's avatar
Xin Zhao committed
548 549
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
550
            win_hdl_ = (pkt_).get_accum.target_win_handle;              \
Xin Zhao's avatar
Xin Zhao committed
551 552
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
553
            win_hdl_ = (pkt_).cas.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
554 555
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
556
            win_hdl_ = (pkt_).fop.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
557
            break;                                                      \
558 559 560
        case (MPIDI_CH3_PKT_LOCK):                                      \
            win_hdl_ = (pkt_).lock.target_win_handle;                   \
            break;                                                      \
561 562 563 564 565 566 567 568 569
        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
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
        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_) \
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
            (pkt_).put.dataloop_size = (dataloop_size_);                \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
            (pkt_).get.dataloop_size = (dataloop_size_);                \
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
            (pkt_).accum.dataloop_size = (dataloop_size_);              \
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
            (pkt_).get_accum.dataloop_size = (dataloop_size_);          \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }


597
typedef struct MPIDI_CH3_Pkt_put {
598
    MPIDI_CH3_Pkt_type_t type;
599
    MPIDI_CH3_Pkt_flags_t flags;
600 601 602
    void *addr;
    int count;
    MPI_Datatype datatype;
603 604 605 606 607 608 609 610
    int dataloop_size;          /* for derived datatypes */
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
    MPI_Win source_win_handle;  /* Used in the last RMA operation in an
                                 * epoch in the case of passive target rma
                                 * with shared locks. Otherwise set to NULL*/
611
    char data[MPIDI_RMA_IMMED_BYTES];
612
    int immed_len;
613 614
    int lock_type;      /* used when piggybacking LOCK message. */
    int origin_rank;    /* used when piggybacking LOCK message. */
615 616 617
} MPIDI_CH3_Pkt_put_t;

typedef struct MPIDI_CH3_Pkt_get {
618
    MPIDI_CH3_Pkt_type_t type;
619
    MPIDI_CH3_Pkt_flags_t flags;
620 621 622
    void *addr;
    int count;
    MPI_Datatype datatype;
623
    int dataloop_size;          /* for derived datatypes */
624
    MPI_Request request_handle;
625 626 627 628 629 630 631 632 633
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
    MPI_Win source_win_handle;  /* Used in the last RMA operation in an
                                 * epoch in the case of passive target rma
                                 * with shared locks. Otherwise set to NULL*/
    int lock_type;   /* used when piggybacking LOCK message. */
    int origin_rank; /* used when piggybacking LOCK message. */
634 635
} MPIDI_CH3_Pkt_get_t;

636 637 638 639 640 641 642
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;
    MPI_Win source_win_handle;
    MPIDI_CH3_Pkt_flags_t flags;
643 644 645
    /* Followings are to piggyback IMMED data */
    int immed_len;
    char data[MPIDI_RMA_IMMED_BYTES];
646 647
} MPIDI_CH3_Pkt_get_resp_t;

648
typedef struct MPIDI_CH3_Pkt_accum {
649
    MPIDI_CH3_Pkt_type_t type;
650
    MPIDI_CH3_Pkt_flags_t flags;
651 652 653
    void *addr;
    int count;
    MPI_Datatype datatype;
654
    int dataloop_size;          /* for derived datatypes */
655
    MPI_Op op;
656 657 658 659 660 661 662
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
    MPI_Win source_win_handle;  /* Used in the last RMA operation in an
                                 * epoch in the case of passive target rma
                                 * with shared locks. Otherwise set to NULL*/
663
    char data[MPIDI_RMA_IMMED_BYTES];
664
    int immed_len;
665 666
    int lock_type;    /* used when piggybacking LOCK message. */
    int origin_rank;  /* used when piggybacking LOCK message. */
667 668
} MPIDI_CH3_Pkt_accum_t;

Xin Zhao's avatar
Xin Zhao committed
669 670 671
typedef struct MPIDI_CH3_Pkt_get_accum {
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
672
    MPI_Request request_handle; /* For get_accumulate response */
Xin Zhao's avatar
Xin Zhao committed
673 674 675
    void *addr;
    int count;
    MPI_Datatype datatype;
676
    int dataloop_size;          /* for derived datatypes */
Xin Zhao's avatar
Xin Zhao committed
677
    MPI_Op op;
678 679 680 681 682 683 684
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
    MPI_Win source_win_handle;  /* Used in the last RMA operation in an
                                 * epoch in the case of passive target rma
                                 * with shared locks. Otherwise set to NULL*/
685
    char data[MPIDI_RMA_IMMED_BYTES];
686
    int immed_len;
687 688
    int lock_type;     /* used when piggybacking LOCK message. */
    int origin_rank;   /* used when piggybacking LOCK message. */
Xin Zhao's avatar
Xin Zhao committed
689 690
} MPIDI_CH3_Pkt_get_accum_t;

691
typedef struct MPIDI_CH3_Pkt_get_accum_resp {
692
    MPIDI_CH3_Pkt_type_t type;
693
    MPI_Request request_handle;
694 695 696 697
    /* followings are used to decrement ack_counter at origin */
    int target_rank;
    MPI_Win source_win_handle;
    MPIDI_CH3_Pkt_flags_t flags;
698 699 700
    /* Followings are to piggyback IMMED data */
    int immed_len;
    char data[MPIDI_RMA_IMMED_BYTES];
701
} MPIDI_CH3_Pkt_get_accum_resp_t;
702

703
typedef struct MPIDI_CH3_Pkt_cas {
704
    MPIDI_CH3_Pkt_type_t type;
705
    MPIDI_CH3_Pkt_flags_t flags;
706
    MPI_Datatype datatype;
707
    void *addr;
708
    MPI_Request request_handle;
709 710 711 712 713
    MPI_Win source_win_handle;
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
714 715
    MPIDI_CH3_CAS_Immed_u origin_data;
    MPIDI_CH3_CAS_Immed_u compare_data;
716 717
    int lock_type;     /* used when piggybacking LOCK message. */
    int origin_rank;   /* used when piggybacking LOCK message. */
718
} MPIDI_CH3_Pkt_cas_t;
719

720
typedef struct MPIDI_CH3_Pkt_cas_resp {
721 722
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request request_handle;
723 724
    MPIDI_CH3_CAS_Immed_u data;
    /* followings are used to decrement ack_counter at orign */
725
    int target_rank;
726
    MPI_Win source_win_handle;
727 728
    MPIDI_CH3_Pkt_flags_t flags;
} MPIDI_CH3_Pkt_cas_resp_t;
729

730
typedef struct MPIDI_CH3_Pkt_fop {
731
    MPIDI_CH3_Pkt_type_t type;
732
    MPIDI_CH3_Pkt_flags_t flags;
733 734 735
    MPI_Datatype datatype;
    void *addr;
    MPI_Op op;
736
    MPI_Request request_handle;
737
    MPI_Win source_win_handle;
738 739 740 741
    MPI_Win target_win_handle;  /* Used in the last RMA operation in each
                                 * epoch for decrementing rma op counter in
                                 * active target rma and for unlocking window
                                 * in passive target rma. Otherwise set to NULL*/
742
    char data[MPIDI_RMA_IMMED_BYTES];
743 744 745 746
    int immed_len;
    int lock_type;     /* used when piggybacking LOCK message. */
    int origin_rank;   /* used when piggybacking LOCK message. */
} MPIDI_CH3_Pkt_fop_t;
747

748
typedef struct MPIDI_CH3_Pkt_fop_resp {
749 750
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request request_handle;
751 752 753
    char data[MPIDI_RMA_IMMED_BYTES];
    int immed_len;
    /* followings are used to decrement ack_counter at orign */
754
    int target_rank;
755 756 757
    MPI_Win source_win_handle;
    MPIDI_CH3_Pkt_flags_t flags;
} MPIDI_CH3_Pkt_fop_resp_t;
758

759
typedef struct MPIDI_CH3_Pkt_lock {
760
    MPIDI_CH3_Pkt_type_t type;
761
    int lock_type;
762 763
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
764
    int origin_rank;
765
} MPIDI_CH3_Pkt_lock_t;
766

Xin Zhao's avatar
Xin Zhao committed
767 768 769 770
typedef struct MPIDI_CH3_Pkt_unlock {
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
771
    MPIDI_CH3_Pkt_flags_t flags;
Xin Zhao's avatar
Xin Zhao committed
772 773 774 775 776 777 778 779
} 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;

780
typedef struct MPIDI_CH3_Pkt_lock_ack {
781 782 783
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
    MPI_Win source_win_handle;
784 785
    int target_rank;            /* Used in flush_ack response to look up the
                                 * target state at the origin. */
786 787 788 789 790 791 792 793
} 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;
    MPI_Win source_win_handle;
    int target_rank;
} MPIDI_CH3_Pkt_lock_op_ack_t;
794

Xin Zhao's avatar
Xin Zhao committed
795 796
typedef struct MPIDI_CH3_Pkt_flush_ack {
    MPIDI_CH3_Pkt_type_t type;
797
    MPI_Win source_win_handle;
798 799 800
    int target_rank;            /* Used in flush_ack response to look up the
                                 * target state at the origin. */
    MPIDI_CH3_Pkt_flags_t flags;
Xin Zhao's avatar
Xin Zhao committed
801
} MPIDI_CH3_Pkt_flush_ack_t;
802

803 804 805 806
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;
807

808
typedef struct MPIDI_CH3_Pkt_close {
809 810
    MPIDI_CH3_Pkt_type_t type;
    int ack;
811
} MPIDI_CH3_Pkt_close_t;
812

813
typedef struct MPIDI_CH3_Pkt_revoke {
Wesley Bland's avatar
Wesley Bland committed
814 815
    MPIDI_CH3_Pkt_type_t type;
    MPIR_Context_id_t revoked_comm;
816
} MPIDI_CH3_Pkt_revoke_t;
Wesley Bland's avatar
Wesley Bland committed
817

818
typedef union MPIDI_CH3_Pkt {
819 820
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_eager_send_t eager_send;
821
#if defined(USE_EAGER_SHORT)
822
    MPIDI_CH3_Pkt_eagershort_send_t eagershort_send;
823
#endif                          /* defined(USE_EAGER_SHORT) */
824 825 826 827 828 829 830 831 832 833
    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;
834
    MPIDI_CH3_Pkt_get_resp_t get_resp;
835
    MPIDI_CH3_Pkt_accum_t accum;
Xin Zhao's avatar
Xin Zhao committed
836
    MPIDI_CH3_Pkt_get_accum_t get_accum;
837
    MPIDI_CH3_Pkt_lock_t lock;
838 839
    MPIDI_CH3_Pkt_lock_ack_t lock_ack;
    MPIDI_CH3_Pkt_lock_op_ack_t lock_op_ack;
840
    MPIDI_CH3_Pkt_unlock_t unlock;
841
    MPIDI_CH3_Pkt_flush_t flush;
842
    MPIDI_CH3_Pkt_flush_ack_t flush_ack;
843
    MPIDI_CH3_Pkt_decr_at_counter_t decr_at_cnt;
844
    MPIDI_CH3_Pkt_close_t close;
845 846 847 848 849
    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
850
    MPIDI_CH3_Pkt_revoke_t revoke;
851
# if defined(MPIDI_CH3_PKT_DECL)
852
     MPIDI_CH3_PKT_DECL
853
# endif
854
} MPIDI_CH3_Pkt_t;
855 856

#if defined(MPID_USE_SEQUENCE_NUMBERS)
857
typedef struct MPIDI_CH3_Pkt_send_container {
858
    MPIDI_CH3_Pkt_send_t pkt;
859 860
    struct MPIDI_CH3_Pkt_send_container_s *next;
} MPIDI_CH3_Pkt_send_container_t;
861 862 863
#endif

#endif