void close()
{
util::spinlock::scoped_lock lk(mtx_);
if(buffer_mr_)
{
ibv_dereg_mr(buffer_mr_);
buffer_mr_ = 0;
}
if(server_msg_mr_)
{
ibv_dereg_mr(server_msg_mr_);
server_msg_mr_ = 0;
}
if(client_msg_mr_)
{
ibv_dereg_mr(client_msg_mr_);
client_msg_mr_ = 0;
}
if(id_)
{
rdma_disconnect(id_);
id_ = 0;
}
size_ = 0;
}
static void
rdma_trans_destroy(void *a)
{
Rdmatrans *rdma;
struct ibv_qp_attr attr;
rdma = a;
if (rdma->connected)
rdma_disconnect(rdma->cm_id);
if (rdma->qp) {
attr.qp_state = IBV_QPS_ERR;
ibv_modify_qp(rdma->qp, &attr, IBV_QP_STATE);
ibv_destroy_qp(rdma->qp);
}
if (rdma->cq)
ibv_destroy_cq(rdma->cq);
if (rdma->ch)
ibv_destroy_comp_channel(rdma->ch);
if (rdma->snd_mr)
ibv_dereg_mr(rdma->snd_mr);
if (rdma->snd_buf)
free(rdma->snd_buf);
if (rdma->rcv_mr)
ibv_dereg_mr(rdma->rcv_mr);
if (rdma->rcv_buf)
free(rdma->rcv_buf);
if (rdma->pd)
ibv_dealloc_pd(rdma->pd);
if (rdma->cm_id)
rdma_destroy_id(rdma->cm_id);
}
void destroy_connection(rdma_conn_t *conn)
{
rdma_destroy_qp(conn->id);
ibv_dereg_mr(conn->send_mr);
ibv_dereg_mr(conn->recv_mr);
ibv_dereg_mr(conn->data_mr);
ibv_dereg_mr(conn->addr_mr);
if (conn->send_msg) {
free(conn->send_msg);
conn->send_msg = NULL;
}
if (conn->recv_msg) {
free(conn->recv_msg);
conn->recv_msg = NULL;
}
rdma_destroy_id(conn->id);
if (conn) {
free(conn);
conn = NULL;
}
}
void on_disconnect(struct rdma_cm_id *id)
{
struct timeval start, end, dt;
gettimeofday(&start, NULL);
struct connection *conn = (struct connection *)id->context;
printf("disconnected.\n");
rdma_destroy_qp(id);
ibv_dereg_mr(conn->send_region_mr);
ibv_dereg_mr(conn->recv_region_mr);
ibv_dereg_mr(conn->send_msg_mr);
ibv_dereg_mr(conn->recv_msg_mr);
free(conn->send_region);
free(conn->recv_region);
free(conn->recv_msg);
free(conn->send_msg);
rdma_destroy_id(id);
free(conn);
gettimeofday(&end, NULL);
timersub(&end, &start, &dt);
long usec = dt.tv_usec + 1000000 * dt.tv_sec;
printf("[Derigester] takes %ld micro_secs.\n", usec);
return; /* exit event loop */
}
/* De_register the allocated memory regions before exiting */
void FreeBuff(char *buff1, char *buff2)
{
int ret;
if(s_mr_hndl) {
LOGPRINTF(("Deregistering send buffer"));
ret = ibv_dereg_mr(s_mr_hndl);
if(ret) {
fprintf(stderr, "Error deregistering send mr\n");
} else {
s_mr_hndl = NULL;
}
}
if(r_mr_hndl) {
LOGPRINTF(("Deregistering recv buffer"));
ret = ibv_dereg_mr(r_mr_hndl);
if(ret) {
fprintf(stderr, "Error deregistering recv mr\n");
} else {
r_mr_hndl = NULL;
}
}
if(buff1 != NULL)
free(buff1);
if(buff2 != NULL)
free(buff2);
}
void xfer_rdma_destroy_ctx(struct xfer_context *ctx) {
rdma_destroy_qp(ctx->cm_id);
ibv_destroy_cq(ctx->cq);
ibv_destroy_comp_channel(ctx->ch);
ibv_dereg_mr(ctx->send_mr);
ibv_dereg_mr(ctx->recv_mr);
ibv_dealloc_pd(ctx->pd);
free(ctx);
}
InputChannelSender::~InputChannelSender()
{
if (mr_desc_) {
ibv_dereg_mr(mr_desc_);
mr_desc_ = nullptr;
}
if (mr_data_) {
ibv_dereg_mr(mr_data_);
mr_data_ = nullptr;
}
}
static void rping_free_buffers(struct rping_cb *cb)
{
DEBUG_LOG("rping_free_buffers called on cb %p\n", cb);
ibv_dereg_mr(cb->recv_mr);
ibv_dereg_mr(cb->send_mr);
ibv_dereg_mr(cb->rdma_mr);
free(cb->rdma_buf);
if (!cb->server) {
ibv_dereg_mr(cb->start_mr);
free(cb->start_buf);
}
}
int BClientContext::destroy_context () {
if (qp) TEST_NZ(ibv_destroy_qp (qp));
if (recv_memory_mr) TEST_NZ (ibv_dereg_mr (recv_memory_mr));
if (lock_result_mr) TEST_NZ (ibv_dereg_mr (lock_result_mr));
if (cq) TEST_NZ (ibv_destroy_cq (cq));
if (pd) TEST_NZ (ibv_dealloc_pd (pd));
if (ib_ctx) TEST_NZ (ibv_close_device (ib_ctx));
if (sockfd >= 0) TEST_NZ (close (sockfd));
return 0;
}
/**
* Register a Memory Region (MR) <-> Memory Pool (MP) association in
* txq->mp2mr[]. If mp2mr[] is full, remove an entry first.
*
* This function should only be called by txq_mp2mr().
*
* @param txq
* Pointer to TX queue structure.
* @param[in] mp
* Memory Pool for which a Memory Region lkey must be returned.
* @param idx
* Index of the next available entry.
*
* @return
* mr->lkey on success, (uint32_t)-1 on failure.
*/
uint32_t
txq_mp2mr_reg(struct txq *txq, struct rte_mempool *mp, unsigned int idx)
{
struct txq_ctrl *txq_ctrl = container_of(txq, struct txq_ctrl, txq);
struct ibv_mr *mr;
/* Add a new entry, register MR first. */
DEBUG("%p: discovered new memory pool \"%s\" (%p)",
(void *)txq_ctrl, mp->name, (void *)mp);
mr = mlx5_mp2mr(txq_ctrl->priv->pd, mp);
if (unlikely(mr == NULL)) {
DEBUG("%p: unable to configure MR, ibv_reg_mr() failed.",
(void *)txq_ctrl);
return (uint32_t)-1;
}
if (unlikely(idx == RTE_DIM(txq_ctrl->txq.mp2mr))) {
/* Table is full, remove oldest entry. */
DEBUG("%p: MR <-> MP table full, dropping oldest entry.",
(void *)txq_ctrl);
--idx;
claim_zero(ibv_dereg_mr(txq_ctrl->txq.mp2mr[0].mr));
memmove(&txq_ctrl->txq.mp2mr[0], &txq_ctrl->txq.mp2mr[1],
(sizeof(txq_ctrl->txq.mp2mr) -
sizeof(txq_ctrl->txq.mp2mr[0])));
}
/* Store the new entry. */
txq_ctrl->txq.mp2mr[idx].mp = mp;
txq_ctrl->txq.mp2mr[idx].mr = mr;
txq_ctrl->txq.mp2mr[idx].lkey = htonl(mr->lkey);
DEBUG("%p: new MR lkey for MP \"%s\" (%p): 0x%08" PRIu32,
(void *)txq_ctrl, mp->name, (void *)mp,
txq_ctrl->txq.mp2mr[idx].lkey);
return txq_ctrl->txq.mp2mr[idx].lkey;
}
int xfer_rdma_unregister_buffer(struct xfer_rdma_buf_handle_t *handle) {
ibv_dereg_mr(handle->local_mr);
if (handle->remote_mr)
free(handle->remote_mr);
return 0;
}
static void on_disconnect(struct rdma_cm_id *id)
{
struct conn_context *ctx = (struct conn_context *)id->context;
close(ctx->fd);
ibv_dereg_mr(ctx->buffer_mr);
ibv_dereg_mr(ctx->msg_mr);
free(ctx->buffer);
free(ctx->msg);
printf("finished transferring %s\n", ctx->file_name);
free(ctx);
}
/**
* Sends a buffer's memory region so that it can be mapped to it's remote end.
*/
void RDMAChannel::SendMR(ibv_mr* mr, int id) {
// Map the memory region itself so that it can be sent
ibv_mr* init = ibv_reg_mr(adapter_.pd_, mr, sizeof(ibv_mr),
IBV_ACCESS_LOCAL_WRITE);
struct ibv_sge list;
list.addr = (uint64_t) mr;
list.length = sizeof(ibv_mr);
list.lkey = init->lkey;
struct ibv_send_wr wr;
caffe_memset(sizeof(wr), 0, &wr);
wr.wr_id = (uint64_t) init;
wr.sg_list = &list;
wr.num_sge = 1;
wr.opcode = IBV_WR_SEND_WITH_IMM;
wr.send_flags = IBV_SEND_SIGNALED;
wr.imm_data = id;
struct ibv_send_wr *bad_wr;
CHECK(!ibv_post_send(qp_, &wr, &bad_wr));
for (;;) {
ibv_wc wc;
int ne = ibv_poll_cq(write_cq_, 1, &wc);
CHECK_GE(ne, 0);
if (ne && wc.wr_id == (uint64_t) init) {
break;
}
}
CHECK(!ibv_dereg_mr(init));
}
static void mca_oob_ud_req_destruct (mca_oob_ud_req_t *req)
{
int i;
if (req->req_peer) {
OBJ_RELEASE(req->req_peer);
}
if (req->req_wr.send) {
free (req->req_wr.send);
}
if (req->req_grh_mr) {
(void) ibv_dereg_mr (req->req_grh_mr);
}
if (req->req_grh) {
free (req->req_grh);
}
if (req->req_sge) {
free (req->req_sge);
}
MCA_OOB_UD_REQ_DEREG_MR(req);
}
static void destroy_node(struct cmatest_node *node)
{
if (!node->cma_id)
return;
if (node->cma_id->qp)
rdma_destroy_qp(node->cma_id);
if (node->cq[SEND_CQ_INDEX])
ibv_destroy_cq(node->cq[SEND_CQ_INDEX]);
if (node->cq[RECV_CQ_INDEX])
ibv_destroy_cq(node->cq[RECV_CQ_INDEX]);
if (node->mem) {
ibv_dereg_mr(node->mr);
free(node->mem);
}
if (node->pd)
ibv_dealloc_pd(node->pd);
/* Destroy the RDMA ID after all device resources */
rdma_destroy_id(node->cma_id);
}
static void free_sa_qp_cache(void)
{
struct mca_btl_openib_sa_qp_cache *cache, *tmp;
cache = sa_qp_cache;
while (NULL != cache) {
/* free cache data */
if (cache->device_name)
free(cache->device_name);
if (NULL != cache->qp)
ibv_destroy_qp(cache->qp);
if (NULL != cache->ah)
ibv_destroy_ah(cache->ah);
if (NULL != cache->cq)
ibv_destroy_cq(cache->cq);
if (NULL != cache->mr)
ibv_dereg_mr(cache->mr);
if (NULL != cache->pd)
ibv_dealloc_pd(cache->pd);
tmp = cache->next;
free(cache);
cache = tmp;
}
sa_qp_cache = NULL;
}
static
void psoib_vapi_free(hca_info_t *hca_info, mem_info_t *mem_info)
{
ibv_dereg_mr(/*hca_info->ctx,*/ mem_info->mr);
mem_info->mr = NULL;
free(mem_info->ptr);
mem_info->ptr = NULL;
}
int
main()
{
int ib_port = 1;
int gid_idx = 1;
int rc;
int rank, nprocs;
struct ibv_sge sge_list;
struct ibv_wc wc;
struct ibv_send_wr *sr;
unsigned long long start, end;
float time;
mypmiInit(&rank, &nprocs);
fprintf(stderr, "[%d] nprocs(%d)\n", rank, nprocs);
rc = resource_create(&res, ib_port, rank);
gid_idx = rank;
rc = connect_qp(&res, ib_port, gid_idx, rank);
create_sge(&res, buf, SIZE, &sge_list);
memset(&wc, 0, sizeof(struct ibv_wc));
sr = malloc(sizeof(*sr));
memset(sr, 0, sizeof(*sr));
mypmiBarrier();
fprintf(stderr, "[%d] START\n", rank);
memset(buf, 0, SIZE);
mypmiBarrier();
if (rank == 0) {
struct ibv_mr *mr;
for (int size = RDMA_MIN_SIZE; size < RDMA_MAX_SIZE; size += STEP) {
char *received = calloc(size, sizeof(char));
mr = ibv_reg_mr(res.pd, received, size, IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_LOCAL_WRITE);
INT_TO_BE(buf, mr->rkey);
INT_TO_BE(buf + 4, (((intptr_t)mr->addr) >> 32));
INT_TO_BE(buf + 8, (((intptr_t)mr->addr) & 0xffffffff));
if (post_ibsend(&res, IBV_WR_SEND, &sge_list, sr, 1)) {
fprintf(stderr, "[%d] failed to post SR\n", rank);
goto end;
}
while ((rc = poll_cq(&res, &wc, 1, SCQ_FLG)) == 0) {
}
/* printf("[%d] memory region is sent. key(%x) addr(%lx) rc(%d)\n", rank, mr->rkey, (intptr_t)mr->addr, rc); */
/* wait for done */
post_ibreceive(&res, &sge_list, 1);
while (poll_cq(&res, &wc, 1, RCQ_FLG) == 0) {
}
/* printf("[%d] %d byte has received (opcode=%d)\n", rank, wc.byte_len, wc.opcode); */
/* printf("[%d] Received message: %s\n", rank, buf); */
/* display_received(received, size); */
ibv_dereg_mr(mr);
free(received);
}
} else {
void network_release() {
ibv_dereg_mr(mr_data);
rdma_destroy_qp(cm_id);
ibv_destroy_cq(cq);
ibv_destroy_comp_channel(comp_chan);
rdma_destroy_id(cm_id);
rdma_destroy_event_channel(cm_channel);
}
void destroy_connection(void *context)
{
struct connection *conn = (struct connection *)context;
rdma_destroy_qp(conn->id);
ibv_dereg_mr(conn->send_mr);
ibv_dereg_mr(conn->recv_mr);
ibv_dereg_mr(conn->rdma_msg_mr);
free(conn->send_msg);
free(conn->recv_msg);
free(conn->rdma_msg_region);
rdma_destroy_id(conn->id);
free(conn);
}
void
destroy_connection(IbvConnection *conn)
{
rdma_destroy_qp(conn->id);
ibv_dereg_mr(conn->send_mr);
ibv_dereg_mr(conn->recv_mr);
ibv_dereg_mr(conn->rdma_local_mr);
ibv_dereg_mr(conn->rdma_remote_mr);
free(conn->send_msg);
free(conn->recv_msg);
free(conn->rdma_local_region);
free(conn->rdma_remote_region);
rdma_destroy_id(conn->id);
free(conn);
}
int on_disconnect(struct rdma_cm_id *id)
{
struct connection *conn = (struct connection *)id->context;
printf("disconnected.\n");
rdma_destroy_qp(id);
ibv_dereg_mr(conn->send_mr);
ibv_dereg_mr(conn->recv_mr);
free(conn->send_region);
free(conn->recv_region);
free(conn);
rdma_destroy_id(id);
return 1; /* exit event loop */
}
int __ibv_dereg_mr_1_0(struct ibv_mr_1_0 *mr)
{ fprintf(stderr, "%s:%s:%d \n", __func__, __FILE__, __LINE__);
int ret;
ret = ibv_dereg_mr(mr->real_mr);
if (ret)
return ret;
free(mr);
return 0;
}
static int fi_ibv_mr_close(fid_t fid)
{
struct fi_ibv_mem_desc *mr;
int ret;
mr = container_of(fid, struct fi_ibv_mem_desc, mr_fid.fid);
ret = -ibv_dereg_mr(mr->mr);
if (!ret)
free(mr);
return ret;
}
int __ibv_dereg_mr_1_0(struct ibv_mr_1_0 *mr)
{
int ret;
ret = ibv_dereg_mr(mr->real_mr);
if (ret)
return ret;
free(mr);
return 0;
}
RdmaBuffer::~RdmaBuffer() {
if(deregOnDelete) {
ibv_dereg_mr(this->ibvMemoryRegion);
}
if(deallocOnDelete) {
free(this->data);
}
}
static ucs_status_t uct_ib_dereg_mr(struct ibv_mr *mr)
{
int ret;
ret = ibv_dereg_mr(mr);
if (ret != 0) {
ucs_error("ibv_dereg_mr() failed: %m");
return UCS_ERR_IO_ERROR;
}
return UCS_OK;
}
void m_pi_destroy_wc_q(struct mcm_qp *m_qp)
{
mlog(2, " Destroying QP %p PI WC_q %p\n", m_qp, m_qp->wrc.wc_addr);
if (m_qp->wc_rbuf_mr) {
ibv_dereg_mr(m_qp->wc_rbuf_mr);
m_qp->wc_rbuf_mr = NULL;
}
if (m_qp->wrc.wc_addr) {
free((void*)m_qp->wrc.wc_addr);
m_qp->wrc.wc_addr = 0;
}
}
static void ibw_free_mr(char **ppbuf, struct ibv_mr **ppmr)
{
DEBUG(DEBUG_DEBUG, ("ibw_free_mr(%p %p)\n", *ppbuf, *ppmr));
if (*ppmr!=NULL) {
ibv_dereg_mr(*ppmr);
*ppmr = NULL;
}
if (*ppbuf) {
free(*ppbuf);
*ppbuf = NULL;
}
}
static MrPtr make_mr(PdPtr pd, size_t size, int access=IBV_ACCESS_LOCAL_WRITE |
IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_REMOTE_READ | IBV_ACCESS_REMOTE_ATOMIC) {
auto buf = new char[size];
auto ptr = ibv_reg_mr(pd.get(), buf, size, access);
if(!ptr) {
throw std::runtime_error("cannot create mr");
}
return MrPtr(ptr, [](ibv_mr *ptr){
ibv_dereg_mr(ptr);
delete[] reinterpret_cast<char*>(ptr->addr);
});
}
