486 строки
16 KiB
C
486 строки
16 KiB
C
|
|
/*
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
|
* University Research and Technology
|
|
* Corporation. All rights reserved.
|
|
* Copyright (c) 2004-2005 The University of Tennessee and The University
|
|
* of Tennessee Research Foundation. All rights
|
|
* reserved.
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
* University of Stuttgart. All rights reserved.
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
* All rights reserved.
|
|
* $COPYRIGHT$
|
|
*
|
|
* Additional copyrights may follow
|
|
*
|
|
* $HEADER$
|
|
*/
|
|
/**
|
|
* @file
|
|
*/
|
|
#ifndef MCA_PTL_IB_H
|
|
#define MCA_PTL_IB_H
|
|
|
|
/* Standard system includes */
|
|
#include <sys/types.h>
|
|
#include <string.h>
|
|
|
|
/* Open MPI includes */
|
|
#include "ompi/class/ompi_free_list.h"
|
|
#include "ompi/class/ompi_bitmap.h"
|
|
#include "opal/event/event.h"
|
|
#include "ompi/mca/pml/pml.h"
|
|
#include "ompi/mca/btl/btl.h"
|
|
#include "opal/util/output.h"
|
|
#include "ompi/mca/mpool/mpool.h"
|
|
#include "ompi/mca/btl/base/btl_base_error.h"
|
|
|
|
#include "ompi/mca/btl/btl.h"
|
|
#include "ompi/mca/btl/base/base.h"
|
|
#include "btl_openib_endpoint.h"
|
|
|
|
#if defined(c_plusplus) || defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define MCA_BTL_IB_LEAVE_PINNED 1
|
|
|
|
/**
|
|
* Infiniband (IB) BTL component.
|
|
*/
|
|
|
|
struct mca_btl_openib_component_t {
|
|
mca_btl_base_component_1_0_0_t super; /**< base BTL component */
|
|
|
|
int ib_max_btls;
|
|
/**< maximum number of hcas available to the IB component */
|
|
|
|
uint32_t ib_num_btls;
|
|
/**< number of hcas available to the IB component */
|
|
|
|
struct mca_btl_openib_module_t *openib_btls;
|
|
/**< array of available PTLs */
|
|
|
|
int ib_free_list_num;
|
|
/**< initial size of free lists */
|
|
|
|
int ib_free_list_max;
|
|
/**< maximum size of free lists */
|
|
|
|
int ib_free_list_inc;
|
|
/**< number of elements to alloc when growing free lists */
|
|
|
|
opal_list_t ib_procs;
|
|
/**< list of ib proc structures */
|
|
|
|
opal_event_t ib_send_event;
|
|
/**< event structure for sends */
|
|
|
|
opal_event_t ib_recv_event;
|
|
/**< event structure for recvs */
|
|
|
|
opal_mutex_t ib_lock;
|
|
/**< lock for accessing module state */
|
|
|
|
char* ib_mpool_name;
|
|
/**< name of ib memory pool */
|
|
|
|
int32_t rd_num; /**< the number of receive descriptors to post to each queue pair */
|
|
int32_t rd_low; /**< low water mark to reach before posting additional receive descriptors */
|
|
int32_t rd_win; /**< ack credits when window size exceeded */
|
|
int32_t rd_rsv; /**< descriptors held in reserve for control messages */
|
|
|
|
int32_t srq_rd_max; /* maximum number of receive descriptors posted */
|
|
int32_t srq_rd_per_peer; /* number of receive descriptors to post per log2(peers) in SRQ mode */
|
|
int32_t srq_sd_max; /* maximum number of send descriptors posted */
|
|
|
|
size_t eager_limit;
|
|
size_t max_send_size;
|
|
uint32_t reg_mru_len;
|
|
uint32_t use_srq;
|
|
|
|
uint32_t ib_cq_size; /**< Max outstanding CQE on the CQ */
|
|
uint32_t ib_sg_list_size; /**< Max scatter/gather descriptor entries on the WQ*/
|
|
uint32_t ib_pkey_ix;
|
|
uint32_t ib_psn;
|
|
uint32_t ib_qp_ous_rd_atom;
|
|
uint32_t ib_mtu;
|
|
uint32_t ib_min_rnr_timer;
|
|
uint32_t ib_timeout;
|
|
uint32_t ib_retry_count;
|
|
uint32_t ib_rnr_retry;
|
|
uint32_t ib_max_rdma_dst_ops;
|
|
uint32_t ib_service_level;
|
|
uint32_t ib_static_rate;
|
|
uint32_t ib_src_path_bits;
|
|
|
|
|
|
}; typedef struct mca_btl_openib_component_t mca_btl_openib_component_t;
|
|
|
|
extern mca_btl_openib_component_t mca_btl_openib_component;
|
|
|
|
typedef mca_btl_base_recv_reg_t mca_btl_openib_recv_reg_t;
|
|
|
|
|
|
|
|
/**
|
|
* IB PTL Interface
|
|
*/
|
|
struct mca_btl_openib_module_t {
|
|
mca_btl_base_module_t super; /**< base PTL interface */
|
|
bool btl_inited;
|
|
mca_btl_openib_recv_reg_t ib_reg[256];
|
|
mca_btl_openib_port_info_t port_info; /* contains only the subnet right now */
|
|
uint8_t port_num; /**< ID of the PORT */
|
|
struct ibv_device *ib_dev; /* the ib device */
|
|
struct ibv_context *ib_dev_context;
|
|
struct ibv_pd *ib_pd;
|
|
struct ibv_cq *ib_cq_hp;
|
|
struct ibv_cq *ib_cq_lp;
|
|
struct ibv_port_attr* ib_port_attr;
|
|
struct ibv_recv_wr* rd_desc_post;
|
|
|
|
ompi_free_list_t send_free_eager; /**< free list of eager buffer descriptors */
|
|
ompi_free_list_t send_free_max; /**< free list of max buffer descriptors */
|
|
ompi_free_list_t send_free_frag; /**< free list of frags only... used for pining memory */
|
|
|
|
ompi_free_list_t recv_free_eager; /**< High priority free list of buffer descriptors */
|
|
ompi_free_list_t recv_free_max; /**< Low priority free list of buffer descriptors */
|
|
|
|
opal_list_t reg_mru_list; /**< a most recently used list of mca_mpool_openib_registration_t
|
|
entries, this allows us to keep a working set of memory pinned */
|
|
opal_mutex_t ib_lock; /**< module level lock */
|
|
|
|
|
|
/**< an array to allow posting of rr in one swoop */
|
|
size_t ib_inline_max; /**< max size of inline send*/
|
|
bool poll_cq;
|
|
|
|
|
|
#ifdef OMPI_MCA_BTL_OPENIB_HAVE_SRQ
|
|
struct ibv_srq *srq_hp;
|
|
struct ibv_srq *srq_lp;
|
|
int32_t srd_posted_hp;
|
|
int32_t srd_posted_lp;
|
|
#endif
|
|
int32_t num_peers;
|
|
int32_t rd_num;
|
|
int32_t rd_low;
|
|
|
|
int32_t sd_tokens_hp;
|
|
/**< number of high priority frags that can be outstanding (down counter) */
|
|
int32_t sd_tokens_lp;
|
|
/**< number of low priority frags that can be outstanding (down counter) */
|
|
|
|
opal_list_t pending_frags_hp;
|
|
/**< list of pending high priority frags */
|
|
|
|
opal_list_t pending_frags_lp;
|
|
/**< list of pending low priority frags */
|
|
|
|
|
|
}; typedef struct mca_btl_openib_module_t mca_btl_openib_module_t;
|
|
|
|
|
|
struct mca_btl_openib_frag_t;
|
|
extern mca_btl_openib_module_t mca_btl_openib_module;
|
|
|
|
/**
|
|
* Register IB component parameters with the MCA framework
|
|
*/
|
|
extern int mca_btl_openib_component_open(void);
|
|
|
|
/**
|
|
* Any final cleanup before being unloaded.
|
|
*/
|
|
extern int mca_btl_openib_component_close(void);
|
|
|
|
/**
|
|
* IB component initialization.
|
|
*
|
|
* @param num_btl_modules (OUT) Number of BTLs returned in BTL array.
|
|
* @param allow_multi_user_threads (OUT) Flag indicating wether BTL supports user threads (TRUE)
|
|
* @param have_hidden_threads (OUT) Flag indicating wether BTL uses threads (TRUE)
|
|
*
|
|
* (1) read interface list from kernel and compare against component parameters
|
|
* then create a BTL instance for selected interfaces
|
|
* (2) setup IB listen socket for incoming connection attempts
|
|
* (3) publish BTL addressing info
|
|
*
|
|
*/
|
|
extern mca_btl_base_module_t** mca_btl_openib_component_init(
|
|
int *num_btl_modules,
|
|
bool allow_multi_user_threads,
|
|
bool have_hidden_threads
|
|
);
|
|
|
|
|
|
/**
|
|
* IB component progress.
|
|
*/
|
|
extern int mca_btl_openib_component_progress(
|
|
void
|
|
);
|
|
|
|
|
|
/**
|
|
* Register a callback function that is called on receipt
|
|
* of a fragment.
|
|
*
|
|
* @param btl (IN) BTL module
|
|
* @return Status indicating if cleanup was successful
|
|
*
|
|
* When the process list changes, the PML notifies the BTL of the
|
|
* change, to provide the opportunity to cleanup or release any
|
|
* resources associated with the peer.
|
|
*/
|
|
|
|
int mca_btl_openib_register(
|
|
struct mca_btl_base_module_t* btl,
|
|
mca_btl_base_tag_t tag,
|
|
mca_btl_base_module_recv_cb_fn_t cbfunc,
|
|
void* cbdata
|
|
);
|
|
|
|
|
|
/**
|
|
* Cleanup any resources held by the BTL.
|
|
*
|
|
* @param btl BTL instance.
|
|
* @return OMPI_SUCCESS or error status on failure.
|
|
*/
|
|
|
|
extern int mca_btl_openib_finalize(
|
|
struct mca_btl_base_module_t* btl
|
|
);
|
|
|
|
|
|
/**
|
|
* PML->BTL notification of change in the process list.
|
|
*
|
|
* @param btl (IN)
|
|
* @param nprocs (IN) Number of processes
|
|
* @param procs (IN) Set of processes
|
|
* @param peers (OUT) Set of (optional) peer addressing info.
|
|
* @param peers (IN/OUT) Set of processes that are reachable via this BTL.
|
|
* @return OMPI_SUCCESS or error status on failure.
|
|
*
|
|
*/
|
|
|
|
extern int mca_btl_openib_add_procs(
|
|
struct mca_btl_base_module_t* btl,
|
|
size_t nprocs,
|
|
struct ompi_proc_t **procs,
|
|
struct mca_btl_base_endpoint_t** peers,
|
|
ompi_bitmap_t* reachable
|
|
);
|
|
|
|
/**
|
|
* PML->BTL notification of change in the process list.
|
|
*
|
|
* @param btl (IN) BTL instance
|
|
* @param nproc (IN) Number of processes.
|
|
* @param procs (IN) Set of processes.
|
|
* @param peers (IN) Set of peer data structures.
|
|
* @return Status indicating if cleanup was successful
|
|
*
|
|
*/
|
|
extern int mca_btl_openib_del_procs(
|
|
struct mca_btl_base_module_t* btl,
|
|
size_t nprocs,
|
|
struct ompi_proc_t **procs,
|
|
struct mca_btl_base_endpoint_t** peers
|
|
);
|
|
|
|
|
|
/**
|
|
* PML->BTL Initiate a send of the specified size.
|
|
*
|
|
* @param btl (IN) BTL instance
|
|
* @param btl_base_peer (IN) BTL peer addressing
|
|
* @param send_request (IN/OUT) Send request (allocated by PML via mca_btl_base_request_alloc_fn_t)
|
|
* @param size (IN) Number of bytes PML is requesting BTL to deliver
|
|
* @param flags (IN) Flags that should be passed to the peer via the message header.
|
|
* @param request (OUT) OMPI_SUCCESS if the BTL was able to queue one or more fragments
|
|
*/
|
|
extern int mca_btl_openib_send(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_base_endpoint_t* btl_peer,
|
|
struct mca_btl_base_descriptor_t* descriptor,
|
|
mca_btl_base_tag_t tag
|
|
);
|
|
|
|
/**
|
|
* PML->BTL Initiate a put of the specified size.
|
|
*
|
|
* @param btl (IN) BTL instance
|
|
* @param btl_base_peer (IN) BTL peer addressing
|
|
* @param send_request (IN/OUT) Send request (allocated by PML via mca_btl_base_request_alloc_fn_t)
|
|
* @param size (IN) Number of bytes PML is requesting BTL to deliver
|
|
* @param flags (IN) Flags that should be passed to the peer via the message header.
|
|
* @param request (OUT) OMPI_SUCCESS if the BTL was able to queue one or more fragments
|
|
*/
|
|
extern int mca_btl_openib_put(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_base_endpoint_t* btl_peer,
|
|
struct mca_btl_base_descriptor_t* decriptor
|
|
);
|
|
|
|
/**
|
|
* PML->BTL Initiate a get of the specified size.
|
|
*
|
|
* @param btl (IN) BTL instance
|
|
* @param btl_base_peer (IN) BTL peer addressing
|
|
* @param send_request (IN/OUT) Send request (allocated by PML via mca_btl_base_request_alloc_fn_t)
|
|
* @param size (IN) Number of bytes PML is requesting BTL to deliver
|
|
* @param flags (IN) Flags that should be passed to the peer via the message header.
|
|
* @param request (OUT) OMPI_SUCCESS if the BTL was able to queue one or more fragments
|
|
*/
|
|
extern int mca_btl_openib_get(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_base_endpoint_t* btl_peer,
|
|
struct mca_btl_base_descriptor_t* decriptor
|
|
);
|
|
|
|
|
|
/**
|
|
* Allocate a descriptor.
|
|
*
|
|
* @param btl (IN) BTL module
|
|
* @param size (IN) Requested descriptor size.
|
|
*/
|
|
extern mca_btl_base_descriptor_t* mca_btl_openib_alloc(
|
|
struct mca_btl_base_module_t* btl,
|
|
size_t size);
|
|
|
|
|
|
/**
|
|
* Return a segment allocated by this BTL.
|
|
*
|
|
* @param btl (IN) BTL module
|
|
* @param descriptor (IN) Allocated descriptor.
|
|
*/
|
|
extern int mca_btl_openib_free(
|
|
struct mca_btl_base_module_t* btl,
|
|
mca_btl_base_descriptor_t* des);
|
|
|
|
|
|
/**
|
|
* Pack data and return a descriptor that can be
|
|
* used for send/put.
|
|
*
|
|
* @param btl (IN) BTL module
|
|
* @param peer (IN) BTL peer addressing
|
|
*/
|
|
mca_btl_base_descriptor_t* mca_btl_openib_prepare_src(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_base_endpoint_t* peer,
|
|
mca_mpool_base_registration_t* registration,
|
|
struct ompi_convertor_t* convertor,
|
|
size_t reserve,
|
|
size_t* size
|
|
);
|
|
|
|
/**
|
|
* Allocate a descriptor initialized for RDMA write.
|
|
*
|
|
* @param btl (IN) BTL module
|
|
* @param peer (IN) BTL peer addressing
|
|
*/
|
|
extern mca_btl_base_descriptor_t* mca_btl_openib_prepare_dst(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_base_endpoint_t* peer,
|
|
mca_mpool_base_registration_t* registration,
|
|
struct ompi_convertor_t* convertor,
|
|
size_t reserve,
|
|
size_t* size);
|
|
/**
|
|
* Return a send fragment to the modules free list.
|
|
*
|
|
* @param btl (IN) BTL instance
|
|
* @param frag (IN) IB send fragment
|
|
*
|
|
*/
|
|
extern void mca_btl_openib_send_frag_return(
|
|
struct mca_btl_base_module_t* btl,
|
|
struct mca_btl_openib_frag_t*
|
|
);
|
|
|
|
|
|
int mca_btl_openib_module_init(mca_btl_openib_module_t* openib_btl);
|
|
|
|
|
|
#ifdef OMPI_MCA_BTL_OPENIB_HAVE_SRQ
|
|
|
|
#define MCA_BTL_OPENIB_POST_SRR_HIGH(openib_btl, additional) \
|
|
{ \
|
|
do{ \
|
|
OPAL_THREAD_LOCK(&openib_btl->ib_lock); \
|
|
if(openib_btl->srd_posted_hp <= openib_btl->rd_low+additional && \
|
|
openib_btl->srd_posted_hp < openib_btl->rd_num){ \
|
|
MCA_BTL_OPENIB_POST_SRR_SUB(openib_btl->rd_num - \
|
|
openib_btl->srd_posted_hp, \
|
|
openib_btl, \
|
|
&openib_btl->recv_free_eager, \
|
|
&openib_btl->srd_posted_hp, \
|
|
openib_btl->srq_hp); \
|
|
} \
|
|
OPAL_THREAD_UNLOCK(&openib_btl->ib_lock); \
|
|
} while(0); \
|
|
}
|
|
|
|
#define MCA_BTL_OPENIB_POST_SRR_LOW(openib_btl, additional) \
|
|
{ \
|
|
do { \
|
|
OPAL_THREAD_LOCK(&openib_btl->ib_lock); \
|
|
if(openib_btl->srd_posted_lp <= openib_btl->rd_low+additional && \
|
|
openib_btl->srd_posted_lp < openib_btl->rd_num){ \
|
|
MCA_BTL_OPENIB_POST_SRR_SUB(openib_btl->rd_num - \
|
|
openib_btl->srd_posted_lp, \
|
|
openib_btl, \
|
|
&openib_btl->recv_free_max, \
|
|
&openib_btl->srd_posted_lp, \
|
|
openib_btl->srq_lp); \
|
|
} \
|
|
OPAL_THREAD_UNLOCK(&openib_btl->ib_lock); \
|
|
} while(0); \
|
|
}
|
|
|
|
|
|
#define MCA_BTL_OPENIB_POST_SRR_SUB(cnt, \
|
|
openib_btl, \
|
|
frag_list, \
|
|
srd_posted, \
|
|
srq) \
|
|
{\
|
|
do { \
|
|
int32_t i; \
|
|
int32_t num_post = cnt; \
|
|
opal_list_item_t* item = NULL; \
|
|
mca_btl_openib_frag_t* frag = NULL; \
|
|
struct ibv_recv_wr *bad_wr; \
|
|
int32_t rc; \
|
|
for(i = 0; i < num_post; i++) { \
|
|
OMPI_FREE_LIST_WAIT(frag_list, item, rc); \
|
|
frag = (mca_btl_openib_frag_t*) item; \
|
|
frag->sg_entry.length = frag->size + \
|
|
((unsigned char*) frag->segment.seg_addr.pval- \
|
|
(unsigned char*) frag->hdr); \
|
|
if(ibv_post_srq_recv(srq, &frag->wr_desc.rd_desc, &bad_wr)) { \
|
|
BTL_ERROR(("error posting receive descriptors to shared receive queue: %s",\
|
|
strerror(errno))); \
|
|
return OMPI_ERROR; \
|
|
}\
|
|
}\
|
|
OPAL_THREAD_ADD32(srd_posted, num_post); \
|
|
} while(0);\
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(c_plusplus) || defined(__cplusplus)
|
|
}
|
|
#endif
|
|
#endif
|