ucs_status_t ucp_ep_new(ucp_worker_h worker, uint64_t dest_uuid,
const char *peer_name, const char *message,
ucp_ep_h *ep_p)
{
ucs_status_t status;
ucp_ep_config_key_t key;
ucp_ep_h ep;
khiter_t hash_it;
int hash_extra_status = 0;
ep = ucs_calloc(1, sizeof(*ep), "ucp ep");
if (ep == NULL) {
ucs_error("Failed to allocate ep");
status = UCS_ERR_NO_MEMORY;
goto err;
}
/* EP configuration without any lanes */
memset(&key, 0, sizeof(key));
key.rma_lane_map = 0;
key.amo_lane_map = 0;
key.reachable_md_map = 0;
key.am_lane = UCP_NULL_RESOURCE;
key.rndv_lane = UCP_NULL_RESOURCE;
key.wireup_msg_lane = UCP_NULL_LANE;
key.num_lanes = 0;
memset(key.amo_lanes, UCP_NULL_LANE, sizeof(key.amo_lanes));
ep->worker = worker;
ep->dest_uuid = dest_uuid;
ep->cfg_index = ucp_worker_get_ep_config(worker, &key);
ep->am_lane = UCP_NULL_LANE;
ep->flags = 0;
#if ENABLE_DEBUG_DATA
ucs_snprintf_zero(ep->peer_name, UCP_WORKER_NAME_MAX, "%s", peer_name);
#endif
hash_it = kh_put(ucp_worker_ep_hash, &worker->ep_hash, dest_uuid,
&hash_extra_status);
if (ucs_unlikely(hash_it == kh_end(&worker->ep_hash))) {
ucs_error("Hash failed with ep %p to %s 0x%"PRIx64"->0x%"PRIx64" %s "
"with status %d", ep, peer_name, worker->uuid, ep->dest_uuid,
message, hash_extra_status);
status = UCS_ERR_NO_RESOURCE;
goto err_free_ep;
}
kh_value(&worker->ep_hash, hash_it) = ep;
*ep_p = ep;
ucs_debug("created ep %p to %s 0x%"PRIx64"->0x%"PRIx64" %s", ep, peer_name,
worker->uuid, ep->dest_uuid, message);
return UCS_OK;
err_free_ep:
ucs_free(ep);
err:
return status;
}
ucs_status_t ucp_ep_create_stub(ucp_worker_h worker, uint64_t dest_uuid,
const char *message, ucp_ep_h *ep_p)
{
ucs_status_t status;
ucp_ep_config_key_t key;
ucp_ep_h ep = NULL;
status = ucp_ep_new(worker, dest_uuid, "??", message, &ep);
if (status != UCS_OK) {
goto err;
}
/* all operations will use the first lane, which is a stub endpoint */
memset(&key, 0, sizeof(key));
key.rma_lane_map = 1;
key.amo_lane_map = 1;
key.reachable_md_map = 0; /* TODO */
key.am_lane = 0;
key.rndv_lane = 0;
key.wireup_msg_lane = 0;
key.lanes[0] = UCP_NULL_RESOURCE;
key.num_lanes = 1;
memset(key.amo_lanes, UCP_NULL_LANE, sizeof(key.amo_lanes));
ep->cfg_index = ucp_worker_get_ep_config(worker, &key);
ep->am_lane = 0;
status = ucp_stub_ep_create(ep, &ep->uct_eps[0]);
if (status != UCS_OK) {
goto err_destroy_uct_eps;
}
*ep_p = ep;
return UCS_OK;
err_destroy_uct_eps:
uct_ep_destroy(ep->uct_eps[0]);
ucp_ep_delete(ep);
err:
return status;
}
ucs_status_t ucp_wireup_init_lanes(ucp_ep_h ep, unsigned address_count,
const ucp_address_entry_t *address_list,
uint8_t *addr_indices)
{
ucp_worker_h worker = ep->worker;
ucp_ep_config_key_t key;
uint16_t new_cfg_index;
ucp_lane_index_t lane;
ucs_status_t status;
uint8_t conn_flag;
char str[32];
ucs_trace("ep %p: initialize lanes", ep);
status = ucp_wireup_select_lanes(ep, address_count, address_list,
addr_indices, &key);
if (status != UCS_OK) {
goto err;
}
key.reachable_md_map |= ucp_ep_config(ep)->key.reachable_md_map;
new_cfg_index = ucp_worker_get_ep_config(worker, &key);
if ((ep->cfg_index == new_cfg_index)) {
return UCS_OK; /* No change */
}
if ((ep->cfg_index != 0) && !ucp_ep_is_stub(ep)) {
/*
* TODO handle a case where we have to change lanes and reconfigure the ep:
*
* - if we already have uct ep connected to an address - move it to the new lane index
* - if we don't yet have connection to an address - create it
* - if an existing lane is not connected anymore - delete it (possibly)
* - if the configuration has changed - replay all pending operations on all lanes -
* need that every pending callback would return, in case of failure, the number
* of lane it wants to be queued on.
*/
ucs_debug("cannot reconfigure ep %p from [%d] to [%d]", ep, ep->cfg_index,
new_cfg_index);
ucp_wireup_print_config(worker->context, &ucp_ep_config(ep)->key, "old", NULL);
ucp_wireup_print_config(worker->context, &key, "new", NULL);
ucs_fatal("endpoint reconfiguration not supported yet");
}
ep->cfg_index = new_cfg_index;
ep->am_lane = key.am_lane;
snprintf(str, sizeof(str), "ep %p", ep);
ucp_wireup_print_config(worker->context, &ucp_ep_config(ep)->key, str,
addr_indices);
ucs_trace("ep %p: connect lanes", ep);
/* establish connections on all underlying endpoints */
conn_flag = UCP_EP_FLAG_LOCAL_CONNECTED;
for (lane = 0; lane < ucp_ep_num_lanes(ep); ++lane) {
status = ucp_wireup_connect_lane(ep, lane, address_count, address_list,
addr_indices[lane]);
if (status != UCS_OK) {
goto err;
}
if (ucp_worker_is_tl_p2p(worker, ucp_ep_get_rsc_index(ep, lane))) {
conn_flag = 0; /* If we have a p2p transport, we're not connected */
}
}
ep->flags |= conn_flag;
return UCS_OK;
err:
for (lane = 0; lane < ucp_ep_num_lanes(ep); ++lane) {
if (ep->uct_eps[lane] != NULL) {
uct_ep_destroy(ep->uct_eps[lane]);
ep->uct_eps[lane] = NULL;
}
}
return status;
}
