def create_child_id(self, cm_event=None):
if not self.is_server:
raise PyverbsUserError(
'create_child_id can be used only in passive side')
if self.is_async:
self.child_id = CMID(creator=cm_event, listen_id=self.cmid)
else:
self.child_id = self.cmid.get_request()
def create_child_id(self, cm_event=None):
if not self.passive:
raise PyverbsUserError(
'create_child_id can be used only in passive side')
new_child_idx = len(self.child_ids)
self.child_ids[new_child_idx] = CMID(creator=cm_event,
listen_id=self.cmid)
def __init__(self, **kwargs):
"""
:param kwargs: Arguments:
* *src* (str)
Local address to bind to (for passive side)
* *dst* (str)
Destination address to connect (for active side)
* *port* (str)
Port number of the address
* *is_async* (bool)
A flag which indicates if its asynchronous RDMACM
* *with_ext_qp* (bool)
If set, an external RC QP will be created and used by RDMACM
"""
src = kwargs.get('src')
dst = kwargs.get('dst')
self.is_server = True if dst is None else False
self.qp_init_attr = None
self.is_async = kwargs.get('is_async', False)
self.with_ext_qp = kwargs.get('with_ext_qp', False)
self.connected = False
# When passive side (server) listens to incoming connection requests,
# for each new request it creates a new cmid which is used to establish
# the connection with the remote side
self.child_id = None
self.msg_size = 1024
self.num_msgs = 100
self.channel = None
self.cq = None
self.qp = None
self.port = kwargs.get('port') if kwargs.get('port') else '7471'
self.mr = None
if self.is_server:
self.ai = AddrInfo(src, None, self.port, ce.RDMA_PS_TCP,
ce.RAI_PASSIVE)
else:
self.ai = AddrInfo(src, dst, self.port, ce.RDMA_PS_TCP)
if self.is_async:
self.create_event_channel()
self.cmid = CMID(creator=self.channel)
else:
self.cmid = CMID(creator=self.ai,
qp_init_attr=self.create_qp_init_attr())
class CMResources:
"""
CMResources class is a base aggregator object which contains basic
resources for RDMA CM communication.
"""
def __init__(self, **kwargs):
"""
:param kwargs: Arguments:
* *src* (str)
Local address to bind to (for passive side)
* *dst* (str)
Destination address to connect (for active side)
* *port* (str)
Port number of the address
"""
src = kwargs.get('src')
dst = kwargs.get('dst')
self.is_server = True if dst is None else False
self.qp_init_attr = None
self.msg_size = 1024
self.num_msgs = 100
self.port = kwargs.get('port') if kwargs.get('port') else '7471'
self.mr = None
if self.is_server:
self.ai = AddrInfo(src, self.port, ce.RDMA_PS_TCP, ce.RAI_PASSIVE)
else:
self.ai = AddrInfo(dst, self.port, ce.RDMA_PS_TCP)
self.create_qp_init_attr()
self.cmid = CMID(creator=self.ai, qp_init_attr=self.qp_init_attr)
def create_mr(self, cmid):
self.mr = cmid.reg_msgs(self.msg_size)
def create_qp_init_attr(self):
self.qp_init_attr = QPInitAttr(cap=QPCap(max_recv_wr=1))
def pre_run(self):
if self.is_server:
self.cmid.listen()
else:
self.cmid.connect()
def __init__(self, **kwargs):
"""
:param kwargs: Arguments:
* *src* (str)
Local address to bind to (for passive side)
* *dst* (str)
Destination address to connect (for active side)
* *port* (str)
Port number of the address
"""
src = kwargs.get('src')
dst = kwargs.get('dst')
self.is_server = True if dst is None else False
self.qp_init_attr = None
self.msg_size = 1024
self.num_msgs = 100
self.port = kwargs.get('port') if kwargs.get('port') else '7471'
self.mr = None
if self.is_server:
self.ai = AddrInfo(src, self.port, ce.RDMA_PS_TCP, ce.RAI_PASSIVE)
else:
self.ai = AddrInfo(dst, self.port, ce.RDMA_PS_TCP)
self.create_qp_init_attr()
self.cmid = CMID(creator=self.ai, qp_init_attr=self.qp_init_attr)
class SyncCMResources(CMResources):
"""
SyncCMResources class contains resources for RDMA CM synchronous
communication.
:param addr: Local address to bind to.
:param passive: Indicate if this CM is the passive CM.
"""
def __init__(self, addr=None, passive=None, **kwargs):
super(SyncCMResources, self).__init__(addr=addr, passive=passive,
**kwargs)
self.cmid = CMID(creator=self.ai, qp_init_attr=self.qp_init_attr)
def create_child_id(self, cm_event=None):
if not self.passive:
raise PyverbsUserError('create_child_id can be used only in passive side')
self.child_id = self.cmid.get_request()
def create_cmid(self, idx=0):
self.cmids[idx] = CMID(creator=self.ai, qp_init_attr=self.qp_init_attr)
def create_cmid(self, idx=0):
self.cmids[idx] = CMID(creator=self.channel, port_space=self.port_space)
def __init__(self, addr=None, passive=None, **kwargs):
super(SyncCMResources, self).__init__(addr=addr,
passive=passive,
**kwargs)
self.cmid = CMID(creator=self.ai, qp_init_attr=self.qp_init_attr)
def __init__(self, addr=None, passive=None, **kwargs):
super(AsyncCMResources, self).__init__(addr=addr,
passive=passive,
**kwargs)
self.create_event_channel()
self.cmid = CMID(creator=self.channel, port_space=self.port_space)
class CMResources:
"""
CMResources class is a base aggregator object which contains basic
resources for RDMA CM communication.
"""
def __init__(self, **kwargs):
"""
:param kwargs: Arguments:
* *src* (str)
Local address to bind to (for passive side)
* *dst* (str)
Destination address to connect (for active side)
* *port* (str)
Port number of the address
* *is_async* (bool)
A flag which indicates if its asynchronous RDMACM
* *with_ext_qp* (bool)
If set, an external RC QP will be created and used by RDMACM
"""
src = kwargs.get('src')
dst = kwargs.get('dst')
self.is_server = True if dst is None else False
self.qp_init_attr = None
self.is_async = kwargs.get('is_async', False)
self.with_ext_qp = kwargs.get('with_ext_qp', False)
self.connected = False
# When passive side (server) listens to incoming connection requests,
# for each new request it creates a new cmid which is used to establish
# the connection with the remote side
self.child_id = None
self.msg_size = 1024
self.num_msgs = 100
self.channel = None
self.cq = None
self.qp = None
self.port = kwargs.get('port') if kwargs.get('port') else '7471'
self.mr = None
if self.is_server:
self.ai = AddrInfo(src, None, self.port, ce.RDMA_PS_TCP,
ce.RAI_PASSIVE)
else:
self.ai = AddrInfo(src, dst, self.port, ce.RDMA_PS_TCP)
if self.is_async:
self.create_event_channel()
self.cmid = CMID(creator=self.channel)
else:
self.cmid = CMID(creator=self.ai,
qp_init_attr=self.create_qp_init_attr())
def create_mr(self):
if self.is_server:
self.mr = self.child_id.reg_msgs(self.msg_size)
else:
self.mr = self.cmid.reg_msgs(self.msg_size)
def create_event_channel(self):
self.channel = CMEventChannel()
@staticmethod
def create_qp_init_attr(rcq=None, scq=None):
return QPInitAttr(qp_type=e.IBV_QPT_RC,
rcq=rcq,
scq=scq,
cap=QPCap(max_recv_wr=1))
@staticmethod
def create_conn_param(qp_num=0):
return ConnParam(qp_num=qp_num)
def create_child_id(self, cm_event=None):
if not self.is_server:
raise PyverbsUserError(
'create_child_id can be used only in passive side')
if self.is_async:
self.child_id = CMID(creator=cm_event, listen_id=self.cmid)
else:
self.child_id = self.cmid.get_request()
def create_qp(self):
"""
Create a rdmacm QP. If self.with_ext_qp is set, then an external CQ and
RC QP will be created and set in self.cq and self.qp
respectively.
"""
cmid = self.child_id if self.is_server else self.cmid
if not self.with_ext_qp:
cmid.create_qp(self.create_qp_init_attr())
else:
self.cq = CQ(cmid.context, self.num_msgs, None, None, 0)
init_attr = self.create_qp_init_attr(rcq=self.cq, scq=self.cq)
self.qp = QP(cmid.pd, init_attr, QPAttr())
def modify_ext_qp_to_rts(self):
cmid = self.child_id if self.is_server else self.cmid
attr, mask = cmid.init_qp_attr(e.IBV_QPS_INIT)
self.qp.modify(attr, mask)
attr, mask = cmid.init_qp_attr(e.IBV_QPS_RTR)
self.qp.modify(attr, mask)
attr, mask = cmid.init_qp_attr(e.IBV_QPS_RTS)
self.qp.modify(attr, mask)
class CMResources:
"""
CMResources class is a base aggregator object which contains basic
resources for RDMA CM communication.
"""
def __init__(self, **kwargs):
"""
:param kwargs: Arguments:
* *src* (str)
Local address to bind to (for passive side)
* *dst* (str)
Destination address to connect (for active side)
* *port* (str)
Port number of the address
* *is_async* (bool)
A flag which indicates if its asynchronous RDMACM
"""
src = kwargs.get('src')
dst = kwargs.get('dst')
self.is_server = True if dst is None else False
self.qp_init_attr = None
self.is_async = kwargs.get('is_async', False)
self.connected = False
# When passive side (server) listens to incoming connection requests,
# for each new request it creates a new cmid which is used to establish
# the connection with the remote side
self.child_id = None
self.msg_size = 1024
self.num_msgs = 100
self.channel = None
self.port = kwargs.get('port') if kwargs.get('port') else '7471'
self.mr = None
if self.is_server:
self.ai = AddrInfo(src, None, self.port, ce.RDMA_PS_TCP,
ce.RAI_PASSIVE)
else:
self.ai = AddrInfo(src, dst, self.port, ce.RDMA_PS_TCP)
if self.is_async:
self.create_event_channel()
self.cmid = CMID(creator=self.channel)
else:
self.cmid = CMID(creator=self.ai,
qp_init_attr=self.create_qp_init_attr())
def create_mr(self):
if self.is_server:
self.mr = self.child_id.reg_msgs(self.msg_size)
else:
self.mr = self.cmid.reg_msgs(self.msg_size)
def create_event_channel(self):
self.channel = CMEventChannel()
@staticmethod
def create_qp_init_attr():
return QPInitAttr(qp_type=e.IBV_QPT_RC, cap=QPCap(max_recv_wr=1))
@staticmethod
def create_conn_param():
return ConnParam()
def create_child_id(self, cm_event=None):
if not self.is_server:
raise PyverbsUserError(
'create_child_id can be used only in passive side')
if self.is_async:
self.child_id = CMID(creator=cm_event, listen_id=self.cmid)
else:
self.child_id = self.cmid.get_request()
def create_qp(self):
if self.is_server:
self.child_id.create_qp(self.create_qp_init_attr())
else:
self.cmid.create_qp(self.create_qp_init_attr())
