/* return -1 on error */
static
int psdapl_pz_create(DAT_PZ_HANDLE *pz_handle, DAT_IA_HANDLE ia_handle)
{
DAT_RETURN dat_rc;
dat_rc = dat_pz_create(ia_handle, pz_handle);
if (dat_rc != DAT_SUCCESS) goto err_pz_create;
return 0;
err_pz_create:
psdapl_dprint_dat_err(1, dat_rc, "dat_pz_create() failed");
return -1;
}
/*--------------------------------------------------------*/
int DT_pz_case0(Params_t * params_ptr, FFT_Cmd_t * cmd)
{
char *dev_name;
DAT_IA_HANDLE ia_handle;
DAT_PZ_HANDLE pz_handle;
DAT_EVD_HANDLE evd_handle;
DAT_RETURN rc;
int res;
DT_Tdep_Print_Head *phead;
phead = params_ptr->phead;
DT_Tdep_PT_Printf(phead, "\
Description: Test if we can normally create pz and destroy it.\n");
res = 1;
ia_handle = 0;
pz_handle = 0;
evd_handle = DAT_HANDLE_NULL;
dev_name = cmd->device_name;
rc = DT_ia_open(dev_name, &ia_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
rc = dat_pz_create(ia_handle, &pz_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
cleanup:
if (pz_handle) {
rc = dat_pz_free(pz_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
}
if (ia_handle) {
rc = dat_ia_close(ia_handle, DAT_CLOSE_ABRUPT_FLAG);
DT_assert_dat(phead, rc == DAT_SUCCESS);
}
return res;
}
int
mca_btl_udapl_init(DAT_NAME_PTR ia_name, mca_btl_udapl_module_t* btl)
{
mca_mpool_base_resources_t res;
DAT_CONN_QUAL port;
DAT_RETURN rc;
/* open the uDAPL interface */
btl->udapl_evd_async = DAT_HANDLE_NULL;
rc = dat_ia_open(ia_name, btl->udapl_async_evd_qlen,
&btl->udapl_evd_async, &btl->udapl_ia);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
#if defined(__SVR4) && defined(__sun)
if (strcmp(major, "DAT_INVALID_PARAMETER") == 0 &&
strcmp(minor, "DAT_INVALID_RO_COOKIE") == 0) {
/* Some platforms that Solaris runs on implement the PCI
* standard for relaxed ordering(RO). Using RDMA with
* polling on a memory location as the uDAPL (and openib
* by the way) BTL does for short messages with
* relaxed ordering could potentially produce silent data
* corruption. For this reason we need to take extra
* steps and this is accomplished by setting
* "ro_aware_system = 1" and handling as required.
*
* The uDAPL standard does not provide an interface to
* inform users of this scenario so Sun has implemented the
* following: If a platform supports relaxed ordering
* when the interface name is passed into the
* dat_ia_open() call, the call will return
* DAT_INVALID_PARAMETER and DAT_INVALID_RO_COOKIE.
* DAT_INVALID_RO_COOKIE is not part of the uDAPL standard
* at this time. The only way to open this interface is
* to prefix the following cookie "RO_AWARE_" to the ia
* name that was retreived from the dat registry.
*
* Example: ia_name = "ib0", new expected name will be
* "RO_AWARE_ib0".
*
* Here, since our first ia open attempt failed in the
* standard way, add the cookie and try to open again.
*/
DAT_NAME_PTR ro_ia_name;
/* prefix relaxed order cookie to ia_name */
asprintf(&ro_ia_name, "RO_AWARE_%s", ia_name);
if (NULL == ro_ia_name) {
return OMPI_ERR_OUT_OF_RESOURCE;
}
/* because this is not standard inform user in some way */
BTL_UDAPL_VERBOSE_HELP(VERBOSE_INFORM,
("help-mpi-btl-udapl.txt", "relaxed order support",
true, ia_name, ro_ia_name));
/* try and open again */
btl->udapl_evd_async = DAT_HANDLE_NULL;
rc = dat_ia_open(ro_ia_name, btl->udapl_async_evd_qlen,
&btl->udapl_evd_async, &btl->udapl_ia);
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
if (DAT_SUCCESS == rc) {
mca_btl_udapl_component.ro_aware_system = 1;
free(ro_ia_name);
} else {
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP,
("help-mpi-btl-udapl.txt",
"dat_ia_open fail RO", true, ro_ia_name,
major, minor, ia_name));
free(ro_ia_name);
return OMPI_ERROR;
}
} else {
#endif
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP, ("help-mpi-btl-udapl.txt",
"dat_ia_open fail", true, ia_name, major, minor));
return OMPI_ERROR;
#if defined(__SVR4) && defined(__sun)
}
#endif
}
/* create a protection zone */
rc = dat_pz_create(btl->udapl_ia, &btl->udapl_pz);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_pz_create",
major, minor));
goto failure;
}
/* query to get address information */
rc = dat_ia_query(btl->udapl_ia, &btl->udapl_evd_async,
DAT_IA_ALL, &(btl->udapl_ia_attr), 0, NULL);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_ia_query",
major, minor));
goto failure;
}
memcpy(&btl->udapl_addr.addr, (btl->udapl_ia_attr).ia_address_ptr,
sizeof(DAT_SOCK_ADDR));
/* determine netmask */
mca_btl_udapl_assign_netmask(btl);
/* check evd qlen against adapter max */
if (btl->udapl_dto_evd_qlen > (btl->udapl_ia_attr).max_evd_qlen) {
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP, ("help-mpi-btl-udapl.txt",
"evd_qlen adapter max",
true,
"btl_udapl_dto_evd_qlen",
btl->udapl_dto_evd_qlen,
(btl->udapl_ia_attr).max_evd_qlen));
btl->udapl_dto_evd_qlen = btl->udapl_ia_attr.max_evd_qlen;
}
if (btl->udapl_conn_evd_qlen > (btl->udapl_ia_attr).max_evd_qlen) {
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP, ("help-mpi-btl-udapl.txt",
"evd_qlen adapter max",
true,
"btl_udapl_conn_evd_qlen",
btl->udapl_conn_evd_qlen,
(btl->udapl_ia_attr).max_evd_qlen));
btl->udapl_conn_evd_qlen = btl->udapl_ia_attr.max_evd_qlen;
}
/* set up evd's */
rc = dat_evd_create(btl->udapl_ia,
btl->udapl_dto_evd_qlen, DAT_HANDLE_NULL,
DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG, &btl->udapl_evd_dto);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_evd_create (dto)",
major, minor));
goto failure;
}
rc = dat_evd_create(btl->udapl_ia,
btl->udapl_conn_evd_qlen, DAT_HANDLE_NULL,
DAT_EVD_CR_FLAG | DAT_EVD_CONNECTION_FLAG, &btl->udapl_evd_conn);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_evd_create (conn)",
major, minor));
goto failure;
}
/* create our public service point */
rc = dat_psp_create_any(btl->udapl_ia, &port, btl->udapl_evd_conn,
DAT_PSP_CONSUMER_FLAG, &btl->udapl_psp);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_psp_create_any",
major, minor));
goto failure;
}
/* establish endpoint parameters */
rc = mca_btl_udapl_endpoint_get_params(btl, &(btl->udapl_ep_param));
if(OMPI_SUCCESS != rc) {
/* by not erroring out here we can try to continue with
* the default endpoint parameter values
*/
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP, ("help-mpi-btl-udapl.txt",
"use default endpoint params",
true));
}
/* Save the port with the address information */
/* TODO - since we're doing the hack below, do we need our own port? */
btl->udapl_addr.port = port;
/* Using dat_ep_query to obtain the remote port would be ideal but
* since the current udapl implementations don't seem to support
* this we store the port in udapl_addr and explictly exchange the
* information later.
*/
((struct sockaddr_in*)&btl->udapl_addr.addr)->sin_port = htons(port);
/* initialize the memory pool */
res.pool_name = "udapl";
res.reg_data = btl;
res.sizeof_reg = sizeof(mca_btl_udapl_reg_t);
res.register_mem = udapl_reg_mr;
res.deregister_mem = udapl_dereg_mr;
btl->super.btl_mpool = mca_mpool_base_module_create(
mca_btl_udapl_component.udapl_mpool_name, &btl->super, &res);
if (NULL == btl->super.btl_mpool) {
BTL_UDAPL_VERBOSE_OUTPUT(VERBOSE_INFORM,
("WARNING: Failed to create mpool."));
goto failure;
}
/* initialize objects */
OBJ_CONSTRUCT(&btl->udapl_frag_eager, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_frag_eager_recv, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_frag_max, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_frag_max_recv, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_frag_user, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_frag_control, ompi_free_list_t);
OBJ_CONSTRUCT(&btl->udapl_lock, opal_mutex_t);
/* check buffer alignment against dat library */
if (mca_btl_udapl_component.udapl_buffer_alignment !=
DAT_OPTIMAL_ALIGNMENT) {
BTL_UDAPL_VERBOSE_HELP(VERBOSE_SHOW_HELP, ("help-mpi-btl-udapl.txt",
"optimal buffer alignment mismatch",
true,
DAT_OPTIMAL_ALIGNMENT,
mca_btl_udapl_component.udapl_buffer_alignment,
DAT_OPTIMAL_ALIGNMENT));
}
/* initialize free lists */
ompi_free_list_init_ex_new(&btl->udapl_frag_eager,
sizeof(mca_btl_udapl_frag_eager_t) +
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_eager_t),
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
mca_btl_udapl_component.udapl_free_list_num,
mca_btl_udapl_component.udapl_free_list_max,
mca_btl_udapl_component.udapl_free_list_inc,
btl->super.btl_mpool,
NULL,
NULL);
ompi_free_list_init_ex_new(&btl->udapl_frag_eager_recv,
sizeof(mca_btl_udapl_frag_eager_t) +
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_eager_t),
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
mca_btl_udapl_component.udapl_free_list_num,
mca_btl_udapl_component.udapl_free_list_max,
mca_btl_udapl_component.udapl_free_list_inc,
btl->super.btl_mpool,
NULL,
NULL);
ompi_free_list_init_ex_new(&btl->udapl_frag_max,
sizeof(mca_btl_udapl_frag_max_t) +
mca_btl_udapl_component.udapl_max_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_max_t),
mca_btl_udapl_component.udapl_max_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
mca_btl_udapl_component.udapl_free_list_num,
mca_btl_udapl_component.udapl_free_list_max,
mca_btl_udapl_component.udapl_free_list_inc,
btl->super.btl_mpool,
NULL,
NULL);
ompi_free_list_init_ex_new(&btl->udapl_frag_max_recv,
sizeof(mca_btl_udapl_frag_max_t) +
mca_btl_udapl_component.udapl_max_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_max_t),
mca_btl_udapl_component.udapl_max_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
mca_btl_udapl_component.udapl_free_list_num,
mca_btl_udapl_component.udapl_free_list_max,
mca_btl_udapl_component.udapl_free_list_inc,
btl->super.btl_mpool,
NULL,
NULL);
ompi_free_list_init_ex_new(&btl->udapl_frag_user,
sizeof(mca_btl_udapl_frag_user_t),
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_user_t),
0,0,
mca_btl_udapl_component.udapl_free_list_num,
mca_btl_udapl_component.udapl_free_list_max,
mca_btl_udapl_component.udapl_free_list_inc,
NULL,
NULL,
NULL);
ompi_free_list_init_ex_new(&btl->udapl_frag_control,
sizeof(mca_btl_udapl_frag_eager_t) +
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
OBJ_CLASS(mca_btl_udapl_frag_eager_t),
mca_btl_udapl_component.udapl_eager_frag_size,
mca_btl_udapl_component.udapl_buffer_alignment,
mca_btl_udapl_component.udapl_free_list_num,
-1,
mca_btl_udapl_component.udapl_free_list_inc,
btl->super.btl_mpool,
NULL,
NULL);
/* initialize eager rdma buffer info */
btl->udapl_eager_rdma_endpoints = OBJ_NEW(opal_pointer_array_t);
opal_pointer_array_init(btl->udapl_eager_rdma_endpoints,
mca_btl_udapl_component.udapl_max_eager_rdma_peers,
mca_btl_udapl_component.udapl_max_eager_rdma_peers,
0);
btl->udapl_eager_rdma_endpoint_count = 0;
OBJ_CONSTRUCT(&btl->udapl_eager_rdma_lock, opal_mutex_t);
/* initialize miscellaneous variables */
btl->udapl_async_events = 0;
btl->udapl_connect_inprogress = 0;
btl->udapl_num_peers = 0;
/* TODO - Set up SRQ when it is supported */
return OMPI_SUCCESS;
failure:
dat_ia_close(btl->udapl_ia, DAT_CLOSE_ABRUPT_FLAG);
return OMPI_ERROR;
}
int connect_ep(char *hostname)
{
DAT_IA_ADDRESS_PTR remote_addr = (DAT_IA_ADDRESS_PTR)&remote;
DAT_EP_ATTR ep_attr;
DAT_IA_ATTR ia_attr;
DAT_RETURN status;
DAT_REGION_DESCRIPTION region;
DAT_EVENT event;
DAT_COUNT nmore;
DAT_LMR_TRIPLET iov;
DAT_RMR_TRIPLET *r_iov;
DAT_DTO_COOKIE cookie;
DAT_CONN_QUAL conn_qual;
DAT_BOOLEAN in, out;
int i, ii, pdata, ctx;
DAT_PROVIDER_ATTR prov_attrs;
DAT_DTO_COMPLETION_EVENT_DATA *dto_event =
&event.event_data.dto_completion_event_data;
status = dat_ia_open(provider, 8, &async_evd, &ia);
_OK(status, "dat_ia_open");
memset(&prov_attrs, 0, sizeof(prov_attrs));
status = dat_ia_query(ia, NULL,
DAT_IA_FIELD_ALL, &ia_attr,
DAT_PROVIDER_FIELD_ALL, &prov_attrs);
_OK(status, "dat_ia_query");
print_ia_address(ia_attr.ia_address_ptr);
if (ucm && ud_test) {
printf("%d UD test over UCM provider not supported\n",
getpid());
exit(1);
}
/* Print provider specific attributes */
for (i = 0; i < prov_attrs.num_provider_specific_attr; i++) {
LOGPRINTF(" Provider Specific Attribute[%d] %s=%s\n",
i, prov_attrs.provider_specific_attr[i].name,
prov_attrs.provider_specific_attr[i].value);
/* check for counter support */
status = strcmp(prov_attrs.provider_specific_attr[i].name,
"DAT_COUNTERS");
if (!status)
counters_ok = 1;
}
/* make sure provider supports counters */
if ((counters) && (!counters_ok)) {
printf("Disable dat_query_counters:"
" Provider not built with counters\n");
counters = 0;
}
status = dat_pz_create(ia, &pz);
_OK(status, "dat_pz_create");
status = dat_evd_create(ia, eps * 2, DAT_HANDLE_NULL, DAT_EVD_CR_FLAG,
&cr_evd);
_OK(status, "dat_evd_create CR");
status = dat_evd_create(ia, eps * 2, DAT_HANDLE_NULL,
DAT_EVD_CONNECTION_FLAG, &con_evd);
_OK(status, "dat_evd_create CR");
status = dat_evd_create(ia, eps * 10, DAT_HANDLE_NULL, DAT_EVD_DTO_FLAG,
&dto_evd);
_OK(status, "dat_evd_create DTO");
memset(&ep_attr, 0, sizeof(ep_attr));
if (ud_test) {
msg_size += 40;
ep_attr.service_type = DAT_IB_SERVICE_TYPE_UD;
ep_attr.max_message_size = buf_size;
ep_attr.max_rdma_read_in = 0;
ep_attr.max_rdma_read_out = 0;
} else {
ep_attr.service_type = DAT_SERVICE_TYPE_RC;
ep_attr.max_rdma_size = 0x10000;
ep_attr.max_rdma_read_in = 4;
ep_attr.max_rdma_read_out = 4;
}
ep_attr.qos = 0;
ep_attr.recv_completion_flags = 0;
ep_attr.max_recv_dtos = eps * 10;
ep_attr.max_request_dtos = eps * 10;
ep_attr.max_recv_iov = 1;
ep_attr.max_request_iov = 1;
ep_attr.request_completion_flags = DAT_COMPLETION_DEFAULT_FLAG;
ep_attr.ep_transport_specific_count = 0;
ep_attr.ep_transport_specific = NULL;
ep_attr.ep_provider_specific_count = 0;
ep_attr.ep_provider_specific = NULL;
for (i = 0; i < eps; i++) {
status = dat_ep_create(ia, pz, dto_evd, dto_evd,
con_evd, &ep_attr, &ep[i]);
_OK(status, "dat_ep_create");
LOGPRINTF(" create_ep[%d]=%p\n", i, ep[i]);
}
for (i = 0; i < REG_MEM_COUNT * eps; i++) {
buf[i] = (DAT_RMR_TRIPLET *) malloc(buf_size);
region.for_va = buf[i];
status = dat_lmr_create(ia,
DAT_MEM_TYPE_VIRTUAL,
region,
buf_size,
pz,
DAT_MEM_PRIV_ALL_FLAG |
DAT_IB_MEM_PRIV_REMOTE_ATOMIC,
DAT_VA_TYPE_VA,
&lmr[i],
&lmr_context[i],
&rmr_context[i],
®_size[i], ®_addr[i]);
_OK(status, "dat_lmr_create");
}
/* register atomic return buffer for original data */
atomic_buf = (DAT_UINT64 *) malloc(BUF_SIZE_ATOMIC);
region.for_va = atomic_buf;
status = dat_lmr_create(ia,
DAT_MEM_TYPE_VIRTUAL,
region,
BUF_SIZE_ATOMIC,
pz,
DAT_MEM_PRIV_ALL_FLAG |
DAT_IB_MEM_PRIV_REMOTE_ATOMIC,
DAT_VA_TYPE_VA,
&lmr_atomic,
&lmr_atomic_context,
&rmr_atomic_context,
®_atomic_size, ®_atomic_addr);
_OK(status, "dat_lmr_create atomic");
for (ii = 0; ii < eps; ii++) {
for (i = RECV_BUF_INDEX; i < REG_MEM_COUNT; i++) {
int ep_idx = 0;
cookie.as_64 = (ii * REG_MEM_COUNT) + i;
iov.lmr_context = lmr_context[(ii * REG_MEM_COUNT) + i];
iov.virtual_address =
(DAT_VADDR) (uintptr_t) buf[(ii * REG_MEM_COUNT) +
i];
iov.segment_length = buf_size;
LOGPRINTF(" post_recv (%p) on ep[%d]=%p\n",
buf[(ii * REG_MEM_COUNT) + i], ii, ep[ii]);
/* ep[0], unless testing Server and multi EP's */
if (server && multi_eps) {
ep_idx = ii;
cookie.as_64 = i;
}
status = dat_ep_post_recv(ep[ep_idx],
1,
&iov,
cookie,
DAT_COMPLETION_DEFAULT_FLAG);
_OK(status, "dat_ep_post_recv");
}
}
/* setup receive buffer to initial string to be overwritten */
strcpy((char *)buf[RCV_RDMA_BUF_INDEX], "blah, blah, blah\n");
/* ud can resolve_ah and connect both ways, same EP */
if (server || (!server && ud_test)) {
if (server) {
conn_qual = SERVER_ID;
strcpy((char *)buf[SND_RDMA_BUF_INDEX], "Server data");
} else {
conn_qual = CLIENT_ID;
strcpy((char *)buf[SND_RDMA_BUF_INDEX], "Client data");
}
status = dat_psp_create(ia,
conn_qual,
cr_evd, DAT_PSP_CONSUMER_FLAG, &psp);
_OK(status, "dat_psp_create");
/* Server always waits for first CR from Client */
if (server)
process_cr(0);
}
/* ud can resolve_ah and connect both ways */
if (!server || (server && ud_test)) {
struct addrinfo *target;
if (ucm)
goto no_resolution;
if (getaddrinfo(hostname, NULL, NULL, &target) != 0) {
printf("Error getting remote address.\n");
exit(1);
}
printf("Remote %s Name: %s \n",
server ? "Client" : "Server", hostname);
printf("Remote %s Net Address: %s\n",
server ? "Client" : "Server",
inet_ntoa(((struct sockaddr_in *)
target->ai_addr)->sin_addr));
strcpy((char *)buf[SND_RDMA_BUF_INDEX], "Client written data");
remote_addr = (DAT_IA_ADDRESS_PTR)target->ai_addr; /* IP */
no_resolution:
/* one Client EP, multiple Server EPs, same conn_qual
* use private data to select EP on Server
*/
for (i = 0; i < eps; i++) {
/* pdata selects Server EP,
* support both muliple Server and single EP's
*/
if (multi_eps)
pdata = hton32(i);
else
pdata = 0; /* just use first EP */
status = dat_ep_connect(ep[0],
remote_addr,
(server ? CLIENT_ID :
SERVER_ID), CONN_TIMEOUT, 4,
(DAT_PVOID) & pdata, 0,
DAT_CONNECT_DEFAULT_FLAG);
_OK(status, "dat_ep_connect");
}
if (!ucm)
freeaddrinfo(target);
}
/* UD: process CR's starting with 2nd on server, 1st for client */
if (ud_test) {
for (i = (server ? 1 : 0); i < eps; i++)
process_cr(i);
}
/* RC and UD: process CONN EST events */
for (i = 0; i < eps; i++)
process_conn(i);
/* UD: CONN EST events for CONN's and CR's */
if (ud_test) {
for (i = 0; i < eps; i++)
process_conn(i);
}
printf("Connected! %d endpoints\n", eps);
/*
* Setup our remote memory and tell the other side about it
* Swap to network order.
*/
r_iov = (DAT_RMR_TRIPLET *) buf[SEND_BUF_INDEX];
r_iov->rmr_context = hton32(rmr_context[RCV_RDMA_BUF_INDEX]);
r_iov->virtual_address =
hton64((DAT_VADDR) (uintptr_t) buf[RCV_RDMA_BUF_INDEX]);
r_iov->segment_length = hton32(buf_size);
printf("Send RMR message: r_key_ctx=0x%x,va=" F64x ",len=0x%x\n",
hton32(r_iov->rmr_context),
hton64(r_iov->virtual_address), hton32(r_iov->segment_length));
send_msg(buf[SEND_BUF_INDEX],
sizeof(DAT_RMR_TRIPLET),
lmr_context[SEND_BUF_INDEX],
cookie, DAT_COMPLETION_SUPPRESS_FLAG);
dat_ep_get_status(ep[0], NULL, &in, &out);
printf("EP[0] status: posted buffers: Req=%d, Rcv=%d\n", in, out);
/*
* Wait for their RMR
*/
for (i = 0, ctx = 0; i < eps; i++, ctx++) {
/* expected cookie, recv buf idx in every mem pool */
ctx = (ctx % REG_MEM_COUNT) ? ctx : ctx + RECV_BUF_INDEX;
LOGPRINTF("Waiting for remote to send RMR data\n");
status = dat_evd_wait(dto_evd, DTO_TIMEOUT, 1, &event, &nmore);
_OK(status, "dat_evd_wait after dat_ep_post_send");
if ((event.event_number != DAT_DTO_COMPLETION_EVENT) &&
(ud_test && event.event_number != DAT_IB_DTO_EVENT)) {
printf("unexpected event waiting for RMR context "
"- 0x%x\n", event.event_number);
exit(1);
}
_OK(dto_event->status, "event status for post_recv");
/* careful when checking cookies:
* Client - receiving multi messages on a single EP
* Server - not receiving on multiple EP's
*/
if (!server || (server && !multi_eps)) {
if (dto_event->transfered_length != msg_size ||
dto_event->user_cookie.as_64 != ctx) {
printf("unexpected event data on recv: len=%d"
" cookie=" F64x " expected %d/%d\n",
(int)dto_event->transfered_length,
dto_event->user_cookie.as_64,
msg_size, ctx);
exit(1);
}
/* Server - receiving one message each across many EP's */
} else {
if (dto_event->transfered_length != msg_size ||
dto_event->user_cookie.as_64 != RECV_BUF_INDEX) {
printf("unexpected event data on recv: len=%d"
"cookie=" F64x " expected %d/%d\n",
(int)dto_event->transfered_length,
dto_event->user_cookie.as_64,
msg_size, RECV_BUF_INDEX);
exit(1);
}
}
/* swap RMR,address info to host order */
if (!server || (server && !multi_eps))
r_iov = (DAT_RMR_TRIPLET *) buf[ctx];
else
r_iov =
(DAT_RMR_TRIPLET *) buf[(i * REG_MEM_COUNT) +
RECV_BUF_INDEX];
if (ud_test)
r_iov = (DAT_RMR_TRIPLET *) ((char *)r_iov + 40);
r_iov->rmr_context = ntoh32(r_iov->rmr_context);
r_iov->virtual_address = ntoh64(r_iov->virtual_address);
r_iov->segment_length = ntoh32(r_iov->segment_length);
printf("Recv RMR message: r_iov(%p):"
" r_key_ctx=%x,va=" F64x ",len=0x%x on EP=%p\n",
r_iov, r_iov->rmr_context,
r_iov->virtual_address,
r_iov->segment_length, dto_event->ep_handle);
}
return (0);
}
/*--------------------------------------------------------*/
int DT_pz_case1(Params_t * params_ptr, FFT_Cmd_t * cmd)
{
char *dev_name;
DAT_IA_HANDLE ia_handle;
DAT_PZ_HANDLE pz_handle;
DAT_EP_HANDLE ep_handle;
DAT_EVD_HANDLE conn_evd, send_evd, recv_evd, cr_evd;
DAT_RETURN rc;
int res;
DT_Tdep_Print_Head *phead;
phead = params_ptr->phead;
DT_Tdep_PT_Printf(phead, "\
Description: try to destroy pz with vi still associated with it\n");
res = 1;
ia_handle = 0;
pz_handle = 0;
ep_handle = 0;
conn_evd = 0;
send_evd = 0;
recv_evd = 0;
cr_evd = 0;
dev_name = cmd->device_name;
rc = DT_ia_open(dev_name, &ia_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
rc = dat_pz_create(ia_handle, &pz_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
rc = DT_ep_create(params_ptr,
ia_handle,
pz_handle,
&cr_evd, &conn_evd, &send_evd, &recv_evd, &ep_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
if (pz_handle) {
rc = dat_pz_free(pz_handle);
DT_assert_dat(phead, DAT_GET_TYPE(rc) == DAT_INVALID_STATE);
}
cleanup:
/* corrrect order */
if (ep_handle) {
rc = dat_ep_free(ep_handle);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (conn_evd) {
rc = DT_Tdep_evd_free(conn_evd);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (send_evd) {
rc = DT_Tdep_evd_free(send_evd);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (recv_evd) {
rc = DT_Tdep_evd_free(recv_evd);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (pz_handle) {
rc = dat_pz_free(pz_handle);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (ia_handle) {
rc = dat_ia_close(ia_handle, DAT_CLOSE_ABRUPT_FLAG);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
return res;
}
/*--------------------------------------------------------*/
int DT_pz_case2(Params_t * params_ptr, FFT_Cmd_t * cmd)
{
char *dev_name;
DAT_IA_HANDLE ia_handle;
DAT_PZ_HANDLE pz_handle;
Bpool *bpool;
DAT_RETURN rc;
int res;
DT_Tdep_Print_Head *phead;
phead = params_ptr->phead;
DT_Tdep_PT_Printf(phead, "\
Description: try to destroy pz with registered memory still\n");
DT_Tdep_PT_Printf(phead, "\
associated with it\n");
res = 1;
ia_handle = 0;
pz_handle = 0;
bpool = 0;
dev_name = cmd->device_name;
rc = DT_ia_open(dev_name, &ia_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
rc = dat_pz_create(ia_handle, &pz_handle);
DT_assert_dat(phead, rc == DAT_SUCCESS);
/* allocate and register bpool */
bpool = DT_BpoolAlloc(0, phead, ia_handle, pz_handle, NULL,
NULL, BUFFSIZE, 1, DAT_OPTIMAL_ALIGNMENT,
false, false);
DT_assert(phead, bpool != 0);
if (pz_handle) {
rc = dat_pz_free(pz_handle);
DT_assert_dat(phead, DAT_GET_TYPE(rc) == DAT_INVALID_STATE);
}
cleanup:
/* deregister and free bpool */
if (DT_Bpool_Destroy(0, phead, bpool) == false) {
DT_Tdep_PT_Printf(phead,
"Warning: Destroy bpool fails, reboot for cleanup\n");
return 0;
}
if (pz_handle) {
rc = dat_pz_free(pz_handle);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
if (ia_handle) {
rc = dat_ia_close(ia_handle, DAT_CLOSE_ABRUPT_FLAG);
DT_assert_clean(phead, rc == DAT_SUCCESS);
}
return res;
}
/*-------------------------------------------------------------*/
void DT_pz_test(Params_t * params_ptr, FFT_Cmd_t * cmd)
{
int i;
int res;
DT_Tdep_Print_Head *phead;
FFT_Testfunc_t cases_func[] = {
{DT_pz_case0},
{DT_pz_case1},
{DT_pz_case2},
};
phead = params_ptr->phead;
for (i = 0; i < cmd->size; i++) {
if (cmd->cases_flag[i]) {
DT_Tdep_PT_Printf(phead, "\
*********************************************************************\n");
DT_Tdep_PT_Printf(phead, "\
Function feature: Protection Zone management case: %d\n", i);
res = cases_func[i].fun(params_ptr, cmd);
if (res == 1) {
DT_Tdep_PT_Printf(phead, "Result: PASS\n");
} else if (res == 0) {
DT_Tdep_PT_Printf(phead, "Result: FAIL\n");
} else if (res == -1) {
DT_Tdep_PT_Printf(phead,
"Result: use other test tool\n");
} else if (res == -2) {
DT_Tdep_PT_Printf(phead,
"Result: not support or next stage to develop\n");
}
DT_Tdep_PT_Printf(phead, "\
*********************************************************************\n");
}
}
