mpidpkt.h 31.4 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
    MPIDI_CH3_PKT_UNLOCK,
90
    MPIDI_CH3_PKT_FLUSH,
91
    MPIDI_CH3_PKT_DECR_AT_COUNTER,
92 93
    MPIDI_CH3_PKT_LOCK_GRANTED,
    MPIDI_CH3_PKT_FLUSH_ACK,
94 95
    /* RMA Packets end here */
    MPIDI_CH3_PKT_FLOW_CNTL_UPDATE,     /* FIXME: Unused */
96
    MPIDI_CH3_PKT_CLOSE,
Wesley Bland's avatar
Wesley Bland committed
97
    MPIDI_CH3_PKT_REVOKE,
Pavan Balaji's avatar
Pavan Balaji committed
98
    MPIDI_CH3_PKT_END_CH3,
99
    /* The channel can define additional types by defining the value
100
     * MPIDI_CH3_PKT_ENUM */
101
# if defined(MPIDI_CH3_PKT_ENUM)
Pavan Balaji's avatar
Pavan Balaji committed
102
    MPIDI_CH3_PKT_ENUM,
103
# endif
Pavan Balaji's avatar
Pavan Balaji committed
104
    MPIDI_CH3_PKT_END_ALL,
105
    MPIDI_CH3_PKT_INVALID = -1  /* forces a signed enum to quash warnings */
Pavan Balaji's avatar
Pavan Balaji committed
106
} MPIDI_CH3_Pkt_type_t;
107

108
/* These flags can be "OR'ed" together */
109 110 111 112 113 114
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,
115
    MPIDI_CH3_PKT_FLAG_RMA_DECR_AT_COUNTER = 16,
116 117
    MPIDI_CH3_PKT_FLAG_RMA_NOCHECK = 32,
    MPIDI_CH3_PKT_FLAG_RMA_SHARED = 64,
118
    MPIDI_CH3_PKT_FLAG_RMA_EXCLUSIVE = 128,
119 120
    MPIDI_CH3_PKT_FLAG_RMA_FLUSH_ACK = 256,
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK_ACK = 512,
121
    MPIDI_CH3_PKT_FLAG_RMA_LOCK_GRANTED = 1024,
122 123
    MPIDI_CH3_PKT_FLAG_RMA_UNLOCK_NO_ACK = 2048,
    MPIDI_CH3_PKT_FLAG_RMA_IMMED_RESP = 4096
124
} MPIDI_CH3_Pkt_flags_t;
125

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

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

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

154
typedef struct MPIDI_CH3_Pkt_eager_sync_ack {
155 156
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
157
} MPIDI_CH3_Pkt_eager_sync_ack_t;
158 159 160

typedef MPIDI_CH3_Pkt_send_t MPIDI_CH3_Pkt_rndv_req_to_send_t;

161
typedef struct MPIDI_CH3_Pkt_rndv_clr_to_send {
162 163 164
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    MPI_Request receiver_req_id;
165
} MPIDI_CH3_Pkt_rndv_clr_to_send_t;
166

167
typedef struct MPIDI_CH3_Pkt_rndv_send {
168 169
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request receiver_req_id;
170
} MPIDI_CH3_Pkt_rndv_send_t;
171

172
typedef struct MPIDI_CH3_Pkt_cancel_send_req {
173 174 175
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_Message_match match;
    MPI_Request sender_req_id;
176
} MPIDI_CH3_Pkt_cancel_send_req_t;
177

178
typedef struct MPIDI_CH3_Pkt_cancel_send_resp {
179 180 181
    MPIDI_CH3_Pkt_type_t type;
    MPI_Request sender_req_id;
    int ack;
182
} MPIDI_CH3_Pkt_cancel_send_resp_t;
183

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

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

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 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
#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):                                       \
            /* FIXME: we should deal with CAS here */                   \
            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):                                       \
            /* FIXME: we should deal with CAS here */                   \
            break;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

Xin Zhao's avatar
Xin Zhao committed
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 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
#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;                                                      \
        default:                                                        \
            MPIU_ERR_SETANDJUMP1(err_, MPI_ERR_OTHER, "**invalidpkt", "**invalidpkt %d", (pkt_).type); \
        }                                                               \
    }

379
#define MPIDI_CH3_PKT_RMA_GET_TARGET_WIN_HANDLE(pkt_, win_hdl_, err_)   \
Xin Zhao's avatar
Xin Zhao committed
380 381 382 383
    {                                                                   \
        err_ = MPI_SUCCESS;                                             \
        switch((pkt_).type) {                                           \
        case (MPIDI_CH3_PKT_PUT):                                       \
384
            win_hdl_ = (pkt_).put.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
385 386
            break;                                                      \
        case (MPIDI_CH3_PKT_GET):                                       \
387
            win_hdl_ = (pkt_).get.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
388 389
            break;                                                      \
        case (MPIDI_CH3_PKT_ACCUMULATE):                                \
390
            win_hdl_ = (pkt_).accum.target_win_handle;                  \
Xin Zhao's avatar
Xin Zhao committed
391 392
            break;                                                      \
        case (MPIDI_CH3_PKT_GET_ACCUM):                                 \
393
            win_hdl_ = (pkt_).get_accum.target_win_handle;              \
Xin Zhao's avatar
Xin Zhao committed
394 395
            break;                                                      \
        case (MPIDI_CH3_PKT_CAS):                                       \
396
            win_hdl_ = (pkt_).cas.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
397 398
            break;                                                      \
        case (MPIDI_CH3_PKT_FOP):                                       \
399
            win_hdl_ = (pkt_).fop.target_win_handle;                    \
Xin Zhao's avatar
Xin Zhao committed
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
            break;                                                      \
        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); \
        }                                                               \
    }

427 428 429 430 431
/* RMA packets start here */

/********************************************************************************/
/* RMA packet (from origin to target, including PUT, GET, ACC, GACC, CAS, FOP)  */
/********************************************************************************/
Xin Zhao's avatar
Xin Zhao committed
432

433
typedef struct MPIDI_CH3_Pkt_put {
434
    MPIDI_CH3_Pkt_type_t type;
435
    MPIDI_CH3_Pkt_flags_t flags;
436 437 438
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
    /* Followings are to describe target data */
439 440 441
    void *addr;
    int count;
    MPI_Datatype datatype;
442 443 444 445 446
    int dataloop_size;
    /* Followings are to piggyback LOCK */
    int lock_type;
    int origin_rank;
    /* Followings are to piggyback IMMED data */
447
    int immed_len;
448
    char data[MPIDI_RMA_IMMED_BYTES];
449 450 451
} MPIDI_CH3_Pkt_put_t;

typedef struct MPIDI_CH3_Pkt_get {
452
    MPIDI_CH3_Pkt_type_t type;
453
    MPIDI_CH3_Pkt_flags_t flags;
454 455 456
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
    /* Followings are to describe target data */
457 458 459
    void *addr;
    int count;
    MPI_Datatype datatype;
460 461
    int dataloop_size;
    /* Following is to complete request at origin */
462
    MPI_Request request_handle;
463 464 465
    /* Followings are to piggyback LOCK */
    int lock_type;
    int origin_rank;
466 467 468
} MPIDI_CH3_Pkt_get_t;

typedef struct MPIDI_CH3_Pkt_accum {
469
    MPIDI_CH3_Pkt_type_t type;
470
    MPIDI_CH3_Pkt_flags_t flags;
471 472 473
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
    /* Followings are to describe target data */
474 475 476
    void *addr;
    int count;
    MPI_Datatype datatype;
477 478
    int dataloop_size;
    /* Following is to specify ACC op */
479
    MPI_Op op;
480 481 482 483
    /* Followings are to piggyback LOCK */
    int lock_type;
    int origin_rank;
    /* Followings are to piggyback IMMED data */
484
    int immed_len;
485
    char data[MPIDI_RMA_IMMED_BYTES];
486 487
} MPIDI_CH3_Pkt_accum_t;

Xin Zhao's avatar
Xin Zhao committed
488 489 490
typedef struct MPIDI_CH3_Pkt_get_accum {
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
491 492 493
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
    /* Followings are to describe target data */
Xin Zhao's avatar
Xin Zhao committed
494 495 496
    void *addr;
    int count;
    MPI_Datatype datatype;
497 498
    int dataloop_size;
    /* Following is to describe ACC op */
Xin Zhao's avatar
Xin Zhao committed
499
    MPI_Op op;
500 501 502 503 504 505
    /* Following is to complete request on origin */
    MPI_Request request_handle;
    /* Followings are to piggyback LOCK */
    int lock_type;
    int origin_rank;
    /* Followings are to piggback IMMED data */
506
    int immed_len;
507
    char data[MPIDI_RMA_IMMED_BYTES];
Xin Zhao's avatar
Xin Zhao committed
508 509
} MPIDI_CH3_Pkt_get_accum_t;

510
typedef struct MPIDI_CH3_Pkt_fop {
511
    MPIDI_CH3_Pkt_type_t type;
512
    MPIDI_CH3_Pkt_flags_t flags;
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
    MPI_Win source_win_handle;
    MPI_Win target_win_handle;
    /* Followings are to describe target data */
    void *addr;
    MPI_Datatype datatype;
    /* Following is to speicfy ACC op */
    MPI_Op op;
    /* Following is to complete request at origin */
    MPI_Request request_handle;
    /* Followings are to piggyback IMMED data */
    int lock_type;
    int origin_rank;
    /* Followings are to piggyback IMMED data */
    int immed_len;
    char data[MPIDI_RMA_IMMED_BYTES];
} MPIDI_CH3_Pkt_fop_t;
529

530
typedef struct MPIDI_CH3_Pkt_cas {
531
    MPIDI_CH3_Pkt_type_t type;
532
    MPIDI_CH3_Pkt_flags_t flags;
533 534 535
    MPI_Win source_win_handle;
    MPI_Win target_win_handle;
    /* Followings are to describe target data */
536
    void *addr;
537 538
    MPI_Datatype datatype;
    /* Following is to complete request on origin */
539
    MPI_Request request_handle;
540 541 542 543
    /* Followings are to piggyback LOCK */
    int lock_type;
    int origin_rank;
    /* Followings are to piggyback IMMED data */
544 545
    MPIDI_CH3_CAS_Immed_u origin_data;
    MPIDI_CH3_CAS_Immed_u compare_data;
546
} MPIDI_CH3_Pkt_cas_t;
547

548 549 550 551 552 553 554

/*********************************************************************************/
/* RMA response packet (from target to origin, including GET_RESP, GET_ACC_RESP, */
/* CAS_RESP, FOP_RESP)                                                           */
/*********************************************************************************/

typedef struct MPIDI_CH3_Pkt_get_resp {
555
    MPIDI_CH3_Pkt_type_t type;
556 557
    MPIDI_CH3_Pkt_flags_t flags;
    /* Following is to complete request at origin */
558
    MPI_Request request_handle;
559 560
    /* TODO: we should add IMMED data here */
    /* Followings are used to decrement ack_counter at origin */
561
    MPI_Win source_win_handle;
562
    int target_rank;
563
    /* Followings are to piggyback IMMED data */
564
    int immed_len;
565
    char data[MPIDI_RMA_IMMED_BYTES];
566
} MPIDI_CH3_Pkt_get_resp_t;
567

568
typedef struct MPIDI_CH3_Pkt_get_accum_resp {
569
    MPIDI_CH3_Pkt_type_t type;
570
    MPIDI_CH3_Pkt_flags_t flags;
571
    /* Following is to complete request at origin */
572
    MPI_Request request_handle;
573 574
    /* TODO: we should add IMMED data here */
    /* Followings are used to decrement ack_counter at origin */
575
    MPI_Win source_win_handle;
576
    int target_rank;
577
    /* Followings are to piggyback IMMED data */
578
    int immed_len;
579
    char data[MPIDI_RMA_IMMED_BYTES];
580
} MPIDI_CH3_Pkt_get_accum_resp_t;
581

582
typedef struct MPIDI_CH3_Pkt_fop_resp {
583
    MPIDI_CH3_Pkt_type_t type;
584 585
    MPIDI_CH3_Pkt_flags_t flags;
    /* Following is to complete request at origin */
586
    MPI_Request request_handle;
587
    /* Followings are used to decrement ack_counter at orign */
588
    MPI_Win source_win_handle;
589 590 591 592
    int target_rank;
    /* Followings are to piggyback IMMED data */
    int immed_len;
    char data[MPIDI_RMA_IMMED_BYTES];
593
} MPIDI_CH3_Pkt_fop_resp_t;
594

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
typedef struct MPIDI_CH3_Pkt_cas_resp {
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_flags_t flags;
    /* Following is to complete request at origin */
    MPI_Request request_handle;
    /* Followings are used to decrement ack_counter at orign */
    MPI_Win source_win_handle;
    int target_rank;
    /* Following is to piggyback IMMED data */
    MPIDI_CH3_CAS_Immed_u data;
} MPIDI_CH3_Pkt_cas_resp_t;

/*********************************************************************************/
/* RMA control packet (from origin to target, including LOCK, UNLOCK, FLUSH)     */
/*********************************************************************************/

611
typedef struct MPIDI_CH3_Pkt_lock {
612 613 614
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
615
    int lock_type;
616
    int origin_rank;
617
} MPIDI_CH3_Pkt_lock_t;
618

Xin Zhao's avatar
Xin Zhao committed
619 620
typedef struct MPIDI_CH3_Pkt_unlock {
    MPIDI_CH3_Pkt_type_t type;
621
    MPIDI_CH3_Pkt_flags_t flags;
Xin Zhao's avatar
Xin Zhao committed
622 623 624 625 626 627 628 629 630 631
    MPI_Win target_win_handle;
    MPI_Win source_win_handle;
} 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;

632 633 634 635 636 637 638 639 640 641
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;

/*********************************************************************************/
/* RMA control response packet (from target to origin, including LOCK_GRANTED,   */
/* FLUSH_ACK)                                                                    */
/*********************************************************************************/

642
typedef struct MPIDI_CH3_Pkt_lock_granted {
643 644
    MPIDI_CH3_Pkt_type_t type;
    MPI_Win source_win_handle;
645
    int target_rank;
646
} MPIDI_CH3_Pkt_lock_granted_t;
647

Xin Zhao's avatar
Xin Zhao committed
648 649
typedef struct MPIDI_CH3_Pkt_flush_ack {
    MPIDI_CH3_Pkt_type_t type;
650
    MPIDI_CH3_Pkt_flags_t flags;
651 652
    MPI_Win source_win_handle;
    int target_rank;
Xin Zhao's avatar
Xin Zhao committed
653
} MPIDI_CH3_Pkt_flush_ack_t;
654

655
/* RMA packets end here */
656

657
typedef struct MPIDI_CH3_Pkt_close {
658 659
    MPIDI_CH3_Pkt_type_t type;
    int ack;
660
} MPIDI_CH3_Pkt_close_t;
661

662
typedef struct MPIDI_CH3_Pkt_revoke {
Wesley Bland's avatar
Wesley Bland committed
663 664
    MPIDI_CH3_Pkt_type_t type;
    MPIR_Context_id_t revoked_comm;
665
} MPIDI_CH3_Pkt_revoke_t;
Wesley Bland's avatar
Wesley Bland committed
666

667
typedef union MPIDI_CH3_Pkt {
668 669
    MPIDI_CH3_Pkt_type_t type;
    MPIDI_CH3_Pkt_eager_send_t eager_send;
670
#if defined(USE_EAGER_SHORT)
671
    MPIDI_CH3_Pkt_eagershort_send_t eagershort_send;
672
#endif                          /* defined(USE_EAGER_SHORT) */
673 674 675 676 677 678 679 680
    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;
681
    /* RMA packets start here */
682 683 684
    MPIDI_CH3_Pkt_put_t put;
    MPIDI_CH3_Pkt_get_t get;
    MPIDI_CH3_Pkt_accum_t accum;
Xin Zhao's avatar
Xin Zhao committed
685
    MPIDI_CH3_Pkt_get_accum_t get_accum;
686 687 688 689 690 691
    MPIDI_CH3_Pkt_fop_t fop;
    MPIDI_CH3_Pkt_cas_t cas;
    MPIDI_CH3_Pkt_get_resp_t get_resp;
    MPIDI_CH3_Pkt_get_accum_resp_t get_accum_resp;
    MPIDI_CH3_Pkt_fop_resp_t fop_resp;
    MPIDI_CH3_Pkt_cas_resp_t cas_resp;
692
    MPIDI_CH3_Pkt_lock_t lock;
693
    MPIDI_CH3_Pkt_unlock_t unlock;
694
    MPIDI_CH3_Pkt_flush_t flush;
695
    MPIDI_CH3_Pkt_decr_at_counter_t decr_at_cnt;
696 697 698
    MPIDI_CH3_Pkt_lock_granted_t lock_granted;
    MPIDI_CH3_Pkt_flush_ack_t flush_ack;
    /* RMA packets end here */
699
    MPIDI_CH3_Pkt_close_t close;
Wesley Bland's avatar
Wesley Bland committed
700
    MPIDI_CH3_Pkt_revoke_t revoke;
701
# if defined(MPIDI_CH3_PKT_DECL)
702
     MPIDI_CH3_PKT_DECL
703
# endif
704
} MPIDI_CH3_Pkt_t;
705 706

#if defined(MPID_USE_SEQUENCE_NUMBERS)
707
typedef struct MPIDI_CH3_Pkt_send_container {
708
    MPIDI_CH3_Pkt_send_t pkt;
709 710
    struct MPIDI_CH3_Pkt_send_container_s *next;
} MPIDI_CH3_Pkt_send_container_t;
711 712 713
#endif

#endif