/* RC - Server only, UD - Server and Client, one per EP */ void process_cr(int idx) { DAT_EVENT event; DAT_COUNT nmore; DAT_RETURN status; int pdata; DAT_CR_HANDLE cr = DAT_HANDLE_NULL; DAT_CONN_QUAL exp_qual = server ? SERVER_ID : CLIENT_ID; DAT_CR_PARAM cr_param; DAT_CR_ARRIVAL_EVENT_DATA *cr_event = &event.event_data.cr_arrival_event_data; LOGPRINTF("%s waiting for connect[%d] request\n", server ? "Server" : "Client", idx); status = dat_evd_wait(cr_evd, SERVER_TIMEOUT, 1, &event, &nmore); _OK(status, "CR dat_evd_wait"); if (event.event_number != DAT_CONNECTION_REQUEST_EVENT && (ud_test && event.event_number != DAT_IB_UD_CONNECTION_REQUEST_EVENT)) { printf("unexpected event,!conn req: 0x%x\n", event.event_number); exit(1); } if ((cr_event->conn_qual != exp_qual) || (cr_event->sp_handle.psp_handle != psp)) { printf("wrong cr event data\n"); exit(1); } cr = cr_event->cr_handle; status = dat_cr_query(cr, DAT_CSP_FIELD_ALL, &cr_param); _OK(status, "dat_cr_query"); /* use private data to select EP */ pdata = ntoh32(*((int *)cr_param.private_data)); LOGPRINTF("%s recvd pdata=0x%x, send pdata=0x%x\n", server ? "Server" : "Client", pdata, *(int *)cr_param.private_data); status = dat_cr_accept(cr, ep[pdata], 4, cr_param.private_data); _OK(status, "dat_cr_accept"); printf("%s accepted CR on EP[%d]=%p\n", server ? "Server" : "Client", pdata, ep[pdata]); }
static int _psdapl_get_con_accept(psdapl_con_info_t *ci, DAT_CR_HANDLE cr_handle, psdapl_init_msg_t *imsg) { DAT_RETURN dat_rc; int rc; rc = psdapl_init_buffers_local(ci); if (rc) goto err_init_buf; psdapl_init_buffers_remote(ci, imsg); rc = psdapl_create_ep(ci); if (rc) goto err_create_ep; psdapl_init_msg_t res_imsg; psdapl_init_init_msg(&res_imsg, ci); /* accept connect request. Send info message about my buffers: */ dat_rc = dat_cr_accept(cr_handle, ci->ep_handle,// DAT_HANDLE_NULL /* ep_handle */, sizeof(res_imsg) /* private_data_size */, &res_imsg /* private_data*/); if (dat_rc != DAT_SUCCESS) goto err_cr_accept; rc =psdapl_wait4event(ci, DAT_CONNECTION_EVENT_ESTABLISHED, "DAT_CONNECTION_EVENT_ESTABLISHED"); if (rc) goto err_con_established; return 0; /*---*/ err_cr_accept: psdapl_dprint_dat_err(0, dat_rc, "CR: dat_cr_accept() failed"); err_con_established: /* ToDo: Cleanup ci->ep_handle!! */ err_create_ep: err_init_buf: /* ToDo: Cleanup recv_evd_handle!! */ /* ToDo: Cleanup connect_evd_handle!! */ /* ToDo: Cleanup bufpairs!!!!! */ return -1; }
static int mca_btl_udapl_accept_connect(mca_btl_udapl_module_t* btl, DAT_CR_HANDLE cr_handle) { DAT_EP_HANDLE ep; int rc; mca_btl_base_endpoint_t* proc_ep; mca_btl_udapl_addr_t priv_data_in_addr; int32_t priv_data_in_conn_type; /* incoming endpoint type */ if (mca_btl_udapl_component.udapl_conn_priv_data) { DAT_CR_PARAM cr_param; /* query the connection request for incoming private data */ rc = dat_cr_query(cr_handle, DAT_CR_FIELD_ALL, &cr_param); if (rc != DAT_SUCCESS) { char* major; char* minor; dat_strerror(rc, (const char**)&major, (const char**)&minor); BTL_ERROR(("ERROR: %s %s %s\n", "dat_cr_query", major, minor)); return OMPI_ERROR; } /* retrieve data from connection request event; * cr_param contains remote_port_qual but we need to * match on the psp port and address of remote * so we get this from the private data. */ memcpy(&priv_data_in_addr, (mca_btl_udapl_addr_t *)cr_param.private_data, sizeof(mca_btl_udapl_addr_t)); priv_data_in_conn_type = *(int32_t *) ((char *)cr_param.private_data + sizeof(mca_btl_udapl_addr_t)); } /* create the endpoint for the incoming connection */ rc = mca_btl_udapl_endpoint_create(btl, &ep); if(OMPI_SUCCESS != rc) { BTL_ERROR(("ERROR: mca_btl_udapl_endpoint_create")); return OMPI_ERROR; } /* cr_param no longer valid once dat_cr_accept called */ rc = dat_cr_accept(cr_handle, ep, 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_cr_accept", major, minor)); return OMPI_ERROR; } if (mca_btl_udapl_component.udapl_conn_priv_data) { /* With accept now in process find a home for the DAT ep by * matching against the private data that came in on the * connection request event */ /* find the endpoint which matches the address in data received */ proc_ep = mca_btl_udapl_find_endpoint_address_match(btl, priv_data_in_addr); if (proc_ep == NULL) { return OMPI_ERROR; } if (BTL_UDAPL_EAGER_CONNECTION == priv_data_in_conn_type) { proc_ep->endpoint_eager = ep; } else { assert(BTL_UDAPL_MAX_CONNECTION == priv_data_in_conn_type); proc_ep->endpoint_max = ep; } } return OMPI_SUCCESS; }
bool DT_Performance_Test_Server_Connect(DT_Tdep_Print_Head * phead, Performance_Test_t * test_ptr) { DAT_RETURN ret; bool status; DAT_RSP_HANDLE rsp_handle; DAT_PSP_HANDLE psp_handle; DAT_CR_ARRIVAL_EVENT_DATA cr_stat; DAT_CR_HANDLE cr_handle; DAT_EVENT_NUMBER event_num; rsp_handle = DAT_HANDLE_NULL; psp_handle = DAT_HANDLE_NULL; #if 0 /* FIXME */ if (test_ptr->cmd->use_rsp) { /* * Server - create a single-use RSP and * await a connection for this EP */ ret = dat_rsp_create(test_ptr->ia_handle, test_ptr->ep_context.port, test_ptr->ep_context.ep_handle, test_ptr->creq_evd_hdl, &rsp_handle); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_rsp_create error: %s\n", test_ptr->base_port, DT_RetToString(ret)); status = false; goto psp_free; } DT_Tdep_PT_Debug(1, (phead, "Server[" F64x "]: Listen on RSP port 0x" F64x "\n", test_ptr->base_port, test_ptr->ep_context.port)); /* wait for the connection request */ if (!DT_cr_event_wait(test_ptr->conn_evd_hdl, &cr_stat) || !DT_cr_check(&cr_stat, DAT_HANDLE_NULL, test_ptr->ep_context.port, &cr_handle, "Server")) { status = false; goto psp_free; } /* what, me query? just try to accept the connection */ ret = dat_cr_accept(cr_handle, test_ptr->ep_context.ep_handle, 0, (DAT_PVOID) 0 /* no private data */ ); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_cr_accept error: %s\n", test_ptr->base_port, DT_RetToString(ret)); /* cr_handle consumed on failure */ status = false; goto psp_free; } /* wait for DAT_CONNECTION_EVENT_ESTABLISHED */ if (!DT_conn_event_wait(test_ptr->ep_context.ep_handle, test_ptr->conn_evd_hdl, &event_num)) { /* error message printed by DT_conn_event_wait */ status = false; goto psp_free; } } else #endif /* FIXME */ { /* * Server - use a short-lived PSP instead of an RSP */ status = true; ret = dat_psp_create(test_ptr->ia_handle, test_ptr->ep_context.port, test_ptr->creq_evd_hdl, DAT_PSP_CONSUMER_FLAG, &psp_handle); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_psp_create error: %s\n", test_ptr->base_port, DT_RetToString(ret)); status = false; psp_handle = DAT_HANDLE_NULL; return (status); } } /* * Here's where we tell the main server process that * this thread is ready to wait for a connection request * from the remote end. */ DT_Mdep_wait_object_wakeup(&test_ptr->pt_ptr->synch_wait_object); DT_Tdep_PT_Debug(1, (phead, "Server[" F64x "]: Listen on PSP port 0x" F64x "\n", test_ptr->base_port, test_ptr->ep_context.port)); /* wait for a connection request */ if (!DT_cr_event_wait(phead, test_ptr->creq_evd_hdl, &cr_stat) || !DT_cr_check(phead, &cr_stat, psp_handle, test_ptr->ep_context.port, &cr_handle, "Server")) { status = false; goto psp_free; } /* what, me query? just try to accept the connection */ ret = dat_cr_accept(cr_handle, test_ptr->ep_context.ep_handle, 0, (DAT_PVOID) 0 /* no private data */ ); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_cr_accept error: %s\n", test_ptr->base_port, DT_RetToString(ret)); /* cr_handle consumed on failure */ status = false; goto psp_free; } /* wait for DAT_CONNECTION_EVENT_ESTABLISHED */ if (!DT_conn_event_wait(phead, test_ptr->ep_context.ep_handle, test_ptr->conn_evd_hdl, &event_num)) { /* error message printed by DT_cr_event_wait */ status = false; goto psp_free; } DT_Tdep_PT_Debug(1, (phead, "Server[" F64x "]: Accept on port 0x" F64x "\n", test_ptr->base_port, test_ptr->ep_context.port)); psp_free: if (DAT_HANDLE_NULL != psp_handle) { /* throw away single-use PSP */ ret = dat_psp_free(psp_handle); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_psp_free error: %s\n", test_ptr->base_port, DT_RetToString(ret)); status = false; } } if (DAT_HANDLE_NULL != rsp_handle) { /* throw away single-use PSP */ ret = dat_rsp_free(rsp_handle); if (ret != DAT_SUCCESS) { DT_Tdep_PT_Printf(phead, "Test[" F64x "]: dat_rsp_free error: %s\n", test_ptr->base_port, DT_RetToString(ret)); status = false; } } /* end short-lived PSP */ #ifdef CM_BUSTED /***** XXX Chill out a bit to give the kludged CM a chance ... *****/ DT_Mdep_Sleep(5000); #endif return status; }