ompi/mca/pml/ob1/pml_ob1

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
mca_pml_ob1_common_hdr_prepare
mca_pml_ob1_match_hdr_prepare
mca_pml_ob1_rendezvous_hdr_prepare
mca_pml_ob1_rget_hdr_prepare
mca_pml_ob1_frag_hdr_prepare
mca_pml_ob1_ack_hdr_prepare
mca_pml_ob1_rdma_hdr_prepare
mca_pml_ob1_fin_hdr_prepare
ob1_hdr_ntoh
ob1_hdr_hton_intr
ob1_hdr_copy
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2005 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2009      IBM Corporation.  All rights reserved.
  14  * Copyright (c) 2012-2015 Los Alamos National Security, LLC. All rights
  15  *                         reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 /**
  23  * @file
  24  */
  25 #ifndef MCA_PML_OB1_HEADER_H
  26 #define MCA_PML_OB1_HEADER_H
  27 
  28 #include "ompi_config.h"
  29 #ifdef HAVE_SYS_TYPES_H
  30 #include <sys/types.h>
  31 #endif
  32 #ifdef HAVE_NETINET_IN_H
  33 #include <netinet/in.h>
  34 #endif
  35 
  36 #include "opal/types.h"
  37 #include "opal/util/arch.h"
  38 #include "opal/mca/btl/btl.h"
  39 #include "ompi/proc/proc.h"
  40 
  41 #define MCA_PML_OB1_HDR_TYPE_MATCH     (MCA_BTL_TAG_PML + 1)
  42 #define MCA_PML_OB1_HDR_TYPE_RNDV      (MCA_BTL_TAG_PML + 2)
  43 #define MCA_PML_OB1_HDR_TYPE_RGET      (MCA_BTL_TAG_PML + 3)
  44 #define MCA_PML_OB1_HDR_TYPE_ACK       (MCA_BTL_TAG_PML + 4)
  45 #define MCA_PML_OB1_HDR_TYPE_NACK      (MCA_BTL_TAG_PML + 5)
  46 #define MCA_PML_OB1_HDR_TYPE_FRAG      (MCA_BTL_TAG_PML + 6)
  47 #define MCA_PML_OB1_HDR_TYPE_GET       (MCA_BTL_TAG_PML + 7)
  48 #define MCA_PML_OB1_HDR_TYPE_PUT       (MCA_BTL_TAG_PML + 8)
  49 #define MCA_PML_OB1_HDR_TYPE_FIN       (MCA_BTL_TAG_PML + 9)
  50 
  51 #define MCA_PML_OB1_HDR_FLAGS_ACK     1  /* is an ack required */
  52 #define MCA_PML_OB1_HDR_FLAGS_NBO     2  /* is the hdr in network byte order */
  53 #define MCA_PML_OB1_HDR_FLAGS_PIN     4  /* is user buffer pinned */
  54 #define MCA_PML_OB1_HDR_FLAGS_CONTIG  8  /* is user buffer contiguous */
  55 #define MCA_PML_OB1_HDR_FLAGS_NORDMA  16 /* rest will be send by copy-in-out */
  56 #define MCA_PML_OB1_HDR_FLAGS_SIGNAL  32 /* message can be optionally signalling */
  57 
  58 /**
  59  * Common hdr attributes - must be first element in each hdr type
  60  */
  61 struct mca_pml_ob1_common_hdr_t {
  62     uint8_t hdr_type;  /**< type of envelope */
  63     uint8_t hdr_flags; /**< flags indicating how fragment should be processed */
  64 };
  65 typedef struct mca_pml_ob1_common_hdr_t mca_pml_ob1_common_hdr_t;
  66 
  67 static inline void mca_pml_ob1_common_hdr_prepare (mca_pml_ob1_common_hdr_t *hdr, uint8_t hdr_type,
  68                                                    uint8_t hdr_flags)
  69 {
  70     hdr->hdr_type = hdr_type;
  71     hdr->hdr_flags = hdr_flags;
  72 }
  73 
  74 #define MCA_PML_OB1_COMMON_HDR_NTOH(h)
  75 #define MCA_PML_OB1_COMMON_HDR_HTON(h)
  76 
  77 /**
  78  *  Header definition for the first fragment, contains the
  79  *  attributes required to match the corresponding posted receive.
  80  */
  81 struct mca_pml_ob1_match_hdr_t {
  82     mca_pml_ob1_common_hdr_t hdr_common;   /**< common attributes */
  83     uint16_t hdr_ctx;                      /**< communicator index */
  84     int32_t  hdr_src;                      /**< source rank */
  85     int32_t  hdr_tag;                      /**< user tag */
  86     uint16_t hdr_seq;                      /**< message sequence number */
  87 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
  88     uint8_t  hdr_padding[2];               /**< explicitly pad to 16 bytes.  Compilers seem to already prefer to do this, but make it explicit just in case */
  89 #endif
  90 };
  91 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
  92 #define OMPI_PML_OB1_MATCH_HDR_LEN  16
  93 #else
  94 #define OMPI_PML_OB1_MATCH_HDR_LEN  14
  95 #endif
  96 
  97 typedef struct mca_pml_ob1_match_hdr_t mca_pml_ob1_match_hdr_t;
  98 
  99 static inline void mca_pml_ob1_match_hdr_prepare (mca_pml_ob1_match_hdr_t *hdr, uint8_t hdr_type, uint8_t hdr_flags,
 100                                                   uint16_t hdr_ctx, int32_t hdr_src, int32_t hdr_tag, uint16_t hdr_seq)
 101 {
 102     mca_pml_ob1_common_hdr_prepare (&hdr->hdr_common, hdr_type, hdr_flags);
 103     hdr->hdr_ctx = hdr_ctx;
 104     hdr->hdr_src = hdr_src;
 105     hdr->hdr_tag = hdr_tag;
 106     hdr->hdr_seq = hdr_seq;
 107 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 108     hdr->hdr_padding[0] = 0;
 109     hdr->hdr_padding[1] = 0;
 110 #endif
 111 }
 112 
 113 #define MCA_PML_OB1_MATCH_HDR_NTOH(h) \
 114 do { \
 115     MCA_PML_OB1_COMMON_HDR_NTOH((h).hdr_common); \
 116     (h).hdr_ctx = ntohs((h).hdr_ctx); \
 117     (h).hdr_src = ntohl((h).hdr_src); \
 118     (h).hdr_tag = ntohl((h).hdr_tag); \
 119     (h).hdr_seq = ntohs((h).hdr_seq); \
 120 } while (0)
 121 
 122 #define MCA_PML_OB1_MATCH_HDR_HTON(h) \
 123 do { \
 124     MCA_PML_OB1_COMMON_HDR_HTON((h).hdr_common); \
 125     (h).hdr_ctx = htons((h).hdr_ctx); \
 126     (h).hdr_src = htonl((h).hdr_src); \
 127     (h).hdr_tag = htonl((h).hdr_tag); \
 128     (h).hdr_seq = htons((h).hdr_seq); \
 129 } while (0)
 130 
 131 /**
 132  * Header definition for the first fragment when an acknowledgment
 133  * is required. This could be the first fragment of a large message
 134  * or a short message that requires an ack (synchronous).
 135  */
 136 struct mca_pml_ob1_rendezvous_hdr_t {
 137     mca_pml_ob1_match_hdr_t hdr_match;
 138     uint64_t hdr_msg_length;            /**< message length */
 139     opal_ptr_t hdr_src_req;             /**< pointer to source request - returned in ack */
 140 };
 141 typedef struct mca_pml_ob1_rendezvous_hdr_t mca_pml_ob1_rendezvous_hdr_t;
 142 
 143 static inline void mca_pml_ob1_rendezvous_hdr_prepare (mca_pml_ob1_rendezvous_hdr_t *hdr, uint8_t hdr_type, uint8_t hdr_flags,
 144                                                        uint16_t hdr_ctx, int32_t hdr_src, int32_t hdr_tag, uint16_t hdr_seq,
 145                                                        uint64_t hdr_msg_length, void *hdr_src_req)
 146 {
 147     mca_pml_ob1_match_hdr_prepare (&hdr->hdr_match, hdr_type, hdr_flags, hdr_ctx, hdr_src, hdr_tag, hdr_seq);
 148     hdr->hdr_msg_length = hdr_msg_length;
 149     hdr->hdr_src_req.pval = hdr_src_req;
 150 }
 151 
 152 /* Note that hdr_src_req is not put in network byte order because it
 153    is never processed by the receiver, other than being copied into
 154    the ack header */
 155 #define MCA_PML_OB1_RNDV_HDR_NTOH(h) \
 156     do { \
 157         MCA_PML_OB1_MATCH_HDR_NTOH((h).hdr_match); \
 158         (h).hdr_msg_length = ntoh64((h).hdr_msg_length); \
 159     } while (0)
 160 
 161 #define MCA_PML_OB1_RNDV_HDR_HTON(h) \
 162     do { \
 163         MCA_PML_OB1_MATCH_HDR_HTON((h).hdr_match); \
 164         (h).hdr_msg_length = hton64((h).hdr_msg_length); \
 165     } while (0)
 166 
 167 /**
 168  * Header definition for a combined rdma rendezvous/get
 169  */
 170 struct mca_pml_ob1_rget_hdr_t {
 171     mca_pml_ob1_rendezvous_hdr_t hdr_rndv;
 172 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 173     uint8_t hdr_padding[4];
 174 #endif
 175     opal_ptr_t hdr_frag;                      /**< source fragment (for fin) */
 176     uint64_t   hdr_src_ptr;                   /**< source pointer */
 177     /* btl registration handle data follows */
 178 };
 179 typedef struct mca_pml_ob1_rget_hdr_t mca_pml_ob1_rget_hdr_t;
 180 
 181 static inline void mca_pml_ob1_rget_hdr_prepare (mca_pml_ob1_rget_hdr_t *hdr, uint8_t hdr_flags,
 182                                                  uint16_t hdr_ctx, int32_t hdr_src, int32_t hdr_tag, uint16_t hdr_seq,
 183                                                  uint64_t hdr_msg_length, void *hdr_src_req, void *hdr_frag,
 184                                                  void *hdr_src_ptr, void *local_handle, size_t local_handle_size)
 185 {
 186     mca_pml_ob1_rendezvous_hdr_prepare (&hdr->hdr_rndv, MCA_PML_OB1_HDR_TYPE_RGET, hdr_flags,
 187                                         hdr_ctx, hdr_src, hdr_tag, hdr_seq, hdr_msg_length, hdr_src_req);
 188 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 189     hdr->hdr_padding[0] = 0;
 190     hdr->hdr_padding[1] = 0;
 191     hdr->hdr_padding[2] = 0;
 192     hdr->hdr_padding[3] = 0;
 193 #endif
 194     hdr->hdr_frag.pval = hdr_frag;
 195     hdr->hdr_src_ptr = (uint64_t)(intptr_t) hdr_src_ptr;
 196 
 197     /* copy registration handle */
 198     memcpy (hdr + 1, local_handle, local_handle_size);
 199 }
 200 
 201 #define MCA_PML_OB1_RGET_HDR_NTOH(h)                    \
 202     do {                                                \
 203         MCA_PML_OB1_RNDV_HDR_NTOH((h).hdr_rndv);        \
 204         (h).hdr_src_ptr = ntoh64((h).hdr_src_ptr);      \
 205     } while (0)
 206 
 207 #define MCA_PML_OB1_RGET_HDR_HTON(h)                    \
 208     do {                                                \
 209         MCA_PML_OB1_RNDV_HDR_HTON((h).hdr_rndv);        \
 210         (h).hdr_src_ptr = hton64((h).hdr_src_ptr);      \
 211     } while (0)
 212 
 213 /**
 214  *  Header for subsequent fragments.
 215  */
 216 struct mca_pml_ob1_frag_hdr_t {
 217     mca_pml_ob1_common_hdr_t hdr_common;     /**< common attributes */
 218 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 219     uint8_t hdr_padding[6];
 220 #endif
 221     uint64_t hdr_frag_offset;                /**< offset into message */
 222     opal_ptr_t hdr_src_req;                  /**< pointer to source request */
 223     opal_ptr_t hdr_dst_req;                  /**< pointer to matched receive */
 224 };
 225 typedef struct mca_pml_ob1_frag_hdr_t mca_pml_ob1_frag_hdr_t;
 226 
 227 static inline void mca_pml_ob1_frag_hdr_prepare (mca_pml_ob1_frag_hdr_t *hdr, uint8_t hdr_flags,
 228                                                  uint64_t hdr_frag_offset, void *hdr_src_req,
 229                                                  uint64_t hdr_dst_req)
 230 {
 231     mca_pml_ob1_common_hdr_prepare (&hdr->hdr_common, MCA_PML_OB1_HDR_TYPE_FRAG, hdr_flags);
 232 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 233     hdr->hdr_padding[0] = 0;
 234     hdr->hdr_padding[1] = 0;
 235     hdr->hdr_padding[2] = 0;
 236     hdr->hdr_padding[3] = 0;
 237     hdr->hdr_padding[4] = 0;
 238     hdr->hdr_padding[5] = 0;
 239 #endif
 240     hdr->hdr_frag_offset = hdr_frag_offset;
 241     hdr->hdr_src_req.pval = hdr_src_req;
 242     hdr->hdr_dst_req.lval = hdr_dst_req;
 243 }
 244 
 245 #define MCA_PML_OB1_FRAG_HDR_NTOH(h) \
 246     do { \
 247         MCA_PML_OB1_COMMON_HDR_NTOH((h).hdr_common); \
 248         (h).hdr_frag_offset = ntoh64((h).hdr_frag_offset); \
 249     } while (0)
 250 
 251 #define MCA_PML_OB1_FRAG_HDR_HTON(h) \
 252     do { \
 253         MCA_PML_OB1_COMMON_HDR_HTON((h).hdr_common); \
 254         (h).hdr_frag_offset = hton64((h).hdr_frag_offset); \
 255     } while (0)
 256 
 257 /**
 258  *  Header used to acknowledgment outstanding fragment(s).
 259  */
 260 
 261 struct mca_pml_ob1_ack_hdr_t {
 262     mca_pml_ob1_common_hdr_t hdr_common;      /**< common attributes */
 263 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 264     uint8_t hdr_padding[6];
 265 #endif
 266     opal_ptr_t hdr_src_req;                   /**< source request */
 267     opal_ptr_t hdr_dst_req;                   /**< matched receive request */
 268     uint64_t hdr_send_offset;                 /**< starting point of copy in/out */
 269     uint64_t hdr_send_size;                   /**< number of bytes requested (0: all remaining) */
 270 };
 271 typedef struct mca_pml_ob1_ack_hdr_t mca_pml_ob1_ack_hdr_t;
 272 
 273 static inline void mca_pml_ob1_ack_hdr_prepare (mca_pml_ob1_ack_hdr_t *hdr, uint8_t hdr_flags,
 274                                                 uint64_t hdr_src_req, void *hdr_dst_req,
 275                                                 uint64_t hdr_send_offset, uint64_t hdr_send_size)
 276 {
 277     mca_pml_ob1_common_hdr_prepare (&hdr->hdr_common, MCA_PML_OB1_HDR_TYPE_ACK, hdr_flags);
 278 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 279     hdr->hdr_padding[0] = 0;
 280     hdr->hdr_padding[1] = 0;
 281     hdr->hdr_padding[2] = 0;
 282     hdr->hdr_padding[3] = 0;
 283     hdr->hdr_padding[4] = 0;
 284     hdr->hdr_padding[5] = 0;
 285 #endif
 286     hdr->hdr_src_req.lval = hdr_src_req;
 287     hdr->hdr_dst_req.pval = hdr_dst_req;
 288     hdr->hdr_send_offset = hdr_send_offset;
 289     hdr->hdr_send_size = hdr_send_size;
 290 }
 291 
 292 /* Note that the request headers are not put in NBO because the
 293    src_req is already in receiver's byte order and the dst_req is not
 294    used by the receiver for anything other than backpointers in return
 295    headers */
 296 #define MCA_PML_OB1_ACK_HDR_NTOH(h)                        \
 297     do {                                                   \
 298         MCA_PML_OB1_COMMON_HDR_NTOH((h).hdr_common);       \
 299         (h).hdr_send_offset = ntoh64((h).hdr_send_offset); \
 300         (h).hdr_send_size = ntoh64((h).hdr_send_size);     \
 301     } while (0)
 302 
 303 #define MCA_PML_OB1_ACK_HDR_HTON(h)                        \
 304     do {                                                   \
 305         MCA_PML_OB1_COMMON_HDR_HTON((h).hdr_common);       \
 306         (h).hdr_send_offset = hton64((h).hdr_send_offset); \
 307         (h).hdr_send_size = hton64((h).hdr_send_size);     \
 308     } while (0)
 309 
 310 /**
 311  *  Header used to initiate an RDMA operation.
 312  */
 313 
 314 struct mca_pml_ob1_rdma_hdr_t {
 315     mca_pml_ob1_common_hdr_t hdr_common;      /**< common attributes */
 316 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 317     uint8_t hdr_padding[2];                   /** two to pad out the hdr to a 4 byte alignment.  hdr_req will then be 8 byte aligned after 4 for hdr_seg_cnt */
 318 #endif
 319     /* TODO: add real support for multiple destination segments */
 320     opal_ptr_t hdr_req;                       /**< destination request */
 321     opal_ptr_t hdr_frag;                      /**< receiver fragment */
 322     opal_ptr_t hdr_recv_req;                  /**< receive request (NTH: needed for put fallback on send) */
 323     uint64_t hdr_rdma_offset;                 /**< current offset into user buffer */
 324     uint64_t hdr_dst_ptr;                     /**< destination address */
 325     uint64_t hdr_dst_size;                    /**< destination size */
 326     /* registration data follows */
 327 };
 328 typedef struct mca_pml_ob1_rdma_hdr_t mca_pml_ob1_rdma_hdr_t;
 329 
 330 static inline void mca_pml_ob1_rdma_hdr_prepare (mca_pml_ob1_rdma_hdr_t *hdr, uint8_t hdr_flags,
 331                                                  uint64_t hdr_req, void *hdr_frag, void *hdr_recv_req,
 332                                                  uint64_t hdr_rdma_offset, void *hdr_dst_ptr,
 333                                                  uint64_t hdr_dst_size, void *local_handle,
 334                                                  size_t local_handle_size)
 335 {
 336     mca_pml_ob1_common_hdr_prepare (&hdr->hdr_common, MCA_PML_OB1_HDR_TYPE_PUT, hdr_flags);
 337 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 338     hdr->hdr_padding[0] = 0;
 339     hdr->hdr_padding[1] = 0;
 340 #endif
 341     hdr->hdr_req.lval = hdr_req;
 342     hdr->hdr_frag.pval = hdr_frag;
 343     hdr->hdr_recv_req.pval = hdr_recv_req;
 344     hdr->hdr_rdma_offset = hdr_rdma_offset;
 345     hdr->hdr_dst_ptr = (uint64_t)(intptr_t) hdr_dst_ptr;
 346     hdr->hdr_dst_size = hdr_dst_size;
 347 
 348     /* copy segments */
 349     memcpy (hdr + 1, local_handle, local_handle_size);
 350 }
 351 
 352 #define MCA_PML_OB1_RDMA_HDR_NTOH(h)                       \
 353     do {                                                   \
 354         MCA_PML_OB1_COMMON_HDR_NTOH((h).hdr_common);       \
 355         (h).hdr_rdma_offset = ntoh64((h).hdr_rdma_offset); \
 356         (h).hdr_dst_ptr = ntoh64((h).hdr_dst_ptr);         \
 357         (h).hdr_dst_size = ntoh64((h).hdr_dst_size);       \
 358     } while (0)
 359 
 360 #define MCA_PML_OB1_RDMA_HDR_HTON(h)                       \
 361     do {                                                   \
 362         MCA_PML_OB1_COMMON_HDR_HTON((h).hdr_common);       \
 363         (h).hdr_rdma_offset = hton64((h).hdr_rdma_offset); \
 364         (h).hdr_dst_ptr = hton64((h).hdr_dst_ptr);         \
 365         (h).hdr_dst_size = hton64((h).hdr_dst_size);       \
 366     } while (0)
 367 
 368 /**
 369  *  Header used to complete an RDMA operation.
 370  */
 371 
 372 struct mca_pml_ob1_fin_hdr_t {
 373     mca_pml_ob1_common_hdr_t hdr_common;      /**< common attributes */
 374 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 375     uint8_t hdr_padding[2];
 376 #endif
 377     int64_t hdr_size;                         /**< number of bytes completed (positive), error code (negative) */
 378     opal_ptr_t hdr_frag;                      /**< completed RDMA fragment */
 379 };
 380 typedef struct mca_pml_ob1_fin_hdr_t mca_pml_ob1_fin_hdr_t;
 381 
 382 static inline void mca_pml_ob1_fin_hdr_prepare (mca_pml_ob1_fin_hdr_t *hdr, uint8_t hdr_flags,
 383                                                 uint64_t hdr_frag, int64_t hdr_size)
 384 {
 385     mca_pml_ob1_common_hdr_prepare (&hdr->hdr_common, MCA_PML_OB1_HDR_TYPE_FIN, hdr_flags);
 386 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT && OPAL_ENABLE_DEBUG
 387     hdr->hdr_padding[0] = 0;
 388     hdr->hdr_padding[1] = 0;
 389 #endif
 390     hdr->hdr_frag.lval = hdr_frag;
 391     hdr->hdr_size      = hdr_size;
 392 }
 393 
 394 #define MCA_PML_OB1_FIN_HDR_NTOH(h)                  \
 395     do {                                             \
 396         MCA_PML_OB1_COMMON_HDR_NTOH((h).hdr_common); \
 397         (h).hdr_size = ntoh64((h).hdr_size);         \
 398     } while (0)
 399 
 400 #define MCA_PML_OB1_FIN_HDR_HTON(h)                  \
 401     do {                                             \
 402         MCA_PML_OB1_COMMON_HDR_HTON((h).hdr_common); \
 403         (h).hdr_size = hton64((h).hdr_size);         \
 404     } while (0)
 405 
 406 /**
 407  * Union of defined hdr types.
 408  */
 409 union mca_pml_ob1_hdr_t {
 410     mca_pml_ob1_common_hdr_t hdr_common;
 411     mca_pml_ob1_match_hdr_t hdr_match;
 412     mca_pml_ob1_rendezvous_hdr_t hdr_rndv;
 413     mca_pml_ob1_rget_hdr_t hdr_rget;
 414     mca_pml_ob1_frag_hdr_t hdr_frag;
 415     mca_pml_ob1_ack_hdr_t hdr_ack;
 416     mca_pml_ob1_rdma_hdr_t hdr_rdma;
 417     mca_pml_ob1_fin_hdr_t hdr_fin;
 418 };
 419 typedef union mca_pml_ob1_hdr_t mca_pml_ob1_hdr_t;
 420 
 421 #if !defined(WORDS_BIGENDIAN) && OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 422 static inline __opal_attribute_always_inline__ void
 423 ob1_hdr_ntoh(mca_pml_ob1_hdr_t *hdr, const uint8_t hdr_type)
 424 {
 425     if(!(hdr->hdr_common.hdr_flags & MCA_PML_OB1_HDR_FLAGS_NBO))
 426         return;
 427 
 428     switch(hdr_type) {
 429         case MCA_PML_OB1_HDR_TYPE_MATCH:
 430             MCA_PML_OB1_MATCH_HDR_NTOH(hdr->hdr_match);
 431             break;
 432         case MCA_PML_OB1_HDR_TYPE_RNDV:
 433             MCA_PML_OB1_RNDV_HDR_NTOH(hdr->hdr_rndv);
 434             break;
 435         case MCA_PML_OB1_HDR_TYPE_RGET:
 436             MCA_PML_OB1_RGET_HDR_NTOH(hdr->hdr_rget);
 437             break;
 438         case MCA_PML_OB1_HDR_TYPE_ACK:
 439             MCA_PML_OB1_ACK_HDR_NTOH(hdr->hdr_ack);
 440             break;
 441         case MCA_PML_OB1_HDR_TYPE_FRAG:
 442             MCA_PML_OB1_FRAG_HDR_NTOH(hdr->hdr_frag);
 443             break;
 444         case MCA_PML_OB1_HDR_TYPE_PUT:
 445             MCA_PML_OB1_RDMA_HDR_NTOH(hdr->hdr_rdma);
 446             break;
 447         case MCA_PML_OB1_HDR_TYPE_FIN:
 448             MCA_PML_OB1_FIN_HDR_NTOH(hdr->hdr_fin);
 449             break;
 450         default:
 451             assert(0);
 452             break;
 453     }
 454 }
 455 #else
 456 #define ob1_hdr_ntoh(h, t) do{}while(0)
 457 #endif
 458 
 459 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
 460 #define ob1_hdr_hton(h, t, p) \
 461     ob1_hdr_hton_intr((mca_pml_ob1_hdr_t*)h, t, p)
 462 static inline __opal_attribute_always_inline__ void
 463 ob1_hdr_hton_intr(mca_pml_ob1_hdr_t *hdr, const uint8_t hdr_type,
 464         const ompi_proc_t *proc)
 465 {
 466 #ifdef WORDS_BIGENDIAN
 467     hdr->hdr_common.hdr_flags |= MCA_PML_OB1_HDR_FLAGS_NBO;
 468 #else
 469 
 470     if(!(proc->super.proc_arch & OPAL_ARCH_ISBIGENDIAN))
 471         return;
 472 
 473     hdr->hdr_common.hdr_flags |= MCA_PML_OB1_HDR_FLAGS_NBO;
 474     switch(hdr_type) {
 475         case MCA_PML_OB1_HDR_TYPE_MATCH:
 476             MCA_PML_OB1_MATCH_HDR_HTON(hdr->hdr_match);
 477             break;
 478         case MCA_PML_OB1_HDR_TYPE_RNDV:
 479             MCA_PML_OB1_RNDV_HDR_HTON(hdr->hdr_rndv);
 480             break;
 481         case MCA_PML_OB1_HDR_TYPE_RGET:
 482             MCA_PML_OB1_RGET_HDR_HTON(hdr->hdr_rget);
 483             break;
 484         case MCA_PML_OB1_HDR_TYPE_ACK:
 485             MCA_PML_OB1_ACK_HDR_HTON(hdr->hdr_ack);
 486             break;
 487         case MCA_PML_OB1_HDR_TYPE_FRAG:
 488             MCA_PML_OB1_FRAG_HDR_HTON(hdr->hdr_frag);
 489             break;
 490         case MCA_PML_OB1_HDR_TYPE_PUT:
 491             MCA_PML_OB1_RDMA_HDR_HTON(hdr->hdr_rdma);
 492             break;
 493         case MCA_PML_OB1_HDR_TYPE_FIN:
 494             MCA_PML_OB1_FIN_HDR_HTON(hdr->hdr_fin);
 495             break;
 496         default:
 497             assert(0);
 498             break;
 499     }
 500 #endif
 501 }
 502 #else
 503 #define ob1_hdr_hton(h, t, p) do{}while(0)
 504 #endif
 505 
 506 static inline __opal_attribute_always_inline__ void
 507 ob1_hdr_copy(mca_pml_ob1_hdr_t *src, mca_pml_ob1_hdr_t *dst)
 508 {
 509     switch(src->hdr_common.hdr_type) {
 510         case MCA_PML_OB1_HDR_TYPE_MATCH:
 511             memcpy( &(dst->hdr_match), &(src->hdr_match), sizeof(mca_pml_ob1_match_hdr_t) );
 512             break;
 513         case MCA_PML_OB1_HDR_TYPE_RNDV:
 514             memcpy( &(dst->hdr_rndv), &(src->hdr_rndv), sizeof(mca_pml_ob1_rendezvous_hdr_t) );
 515             break;
 516         case MCA_PML_OB1_HDR_TYPE_RGET:
 517             memcpy( &(dst->hdr_rget), &(src->hdr_rget), sizeof(mca_pml_ob1_rget_hdr_t) );
 518             break;
 519         case MCA_PML_OB1_HDR_TYPE_ACK:
 520             memcpy( &(dst->hdr_ack), &(src->hdr_ack), sizeof(mca_pml_ob1_ack_hdr_t) );
 521             break;
 522         case MCA_PML_OB1_HDR_TYPE_FRAG:
 523             memcpy( &(dst->hdr_frag), &(src->hdr_frag), sizeof(mca_pml_ob1_frag_hdr_t) );
 524             break;
 525         case MCA_PML_OB1_HDR_TYPE_PUT:
 526             memcpy( &(dst->hdr_rdma), &(src->hdr_rdma), sizeof(mca_pml_ob1_rdma_hdr_t) );
 527             break;
 528         case MCA_PML_OB1_HDR_TYPE_FIN:
 529             memcpy( &(dst->hdr_fin), &(src->hdr_fin), sizeof(mca_pml_ob1_fin_hdr_t) );
 530             break;
 531         default:
 532             memcpy( &(dst->hdr_common), &(src->hdr_common), sizeof(mca_pml_ob1_common_hdr_t) );
 533             break;
 534     }
 535 }
 536 
 537 #endif  /* MCA_PML_OB1_HEADER_H */
 538
/* [<][>][^][v][top][bottom][index][help] */
root/ompi/mca/pml/ob1/pml_ob1_hdr.h

INCLUDED FROM

DEFINITIONS
