nn_map_t *
open_node_name_map(char *node_name_map)
{
nn_map_t *map;
if (!node_name_map) {
#ifdef HAVE_DEFAULT_NODENAME_MAP
struct stat buf;
node_name_map = HAVE_DEFAULT_NODENAME_MAP;
if (stat(node_name_map, &buf))
return NULL;
#else
return NULL;
#endif /* HAVE_DEFAULT_NODENAME_MAP */
}
map = malloc(sizeof(*map));
if (!map)
return NULL;
cl_qmap_init(map);
if (parse_node_map(node_name_map, map_name, map)) {
fprintf(stderr,
"WARNING failed to open node name map \"%s\" (%s)\n",
node_name_map, strerror(errno));
close_node_name_map(map);
return NULL;
}
return map;
}
static int ucast_mgr_build_lfts(osm_ucast_mgr_t * p_mgr)
{
cl_qlist_init(&p_mgr->port_order_list);
if (p_mgr->p_subn->opt.guid_routing_order_file) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Fetching guid routing order file \'%s\'\n",
p_mgr->p_subn->opt.guid_routing_order_file);
if (parse_node_map(p_mgr->p_subn->opt.guid_routing_order_file,
add_guid_to_order_list, p_mgr))
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 3A0D: "
"cannot parse guid routing order file \'%s\'\n",
p_mgr->p_subn->opt.guid_routing_order_file);
}
sort_ports_by_switch_load(p_mgr);
if (p_mgr->p_subn->opt.port_prof_ignore_file) {
cl_qmap_apply_func(&p_mgr->p_subn->sw_guid_tbl,
clear_prof_ignore_flag, NULL);
if (parse_node_map(p_mgr->p_subn->opt.port_prof_ignore_file,
mark_ignored_port, p_mgr)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 3A0E: "
"cannot parse port prof ignore file \'%s\'\n",
p_mgr->p_subn->opt.port_prof_ignore_file);
}
}
cl_qmap_apply_func(&p_mgr->p_subn->port_guid_tbl,
add_port_to_order_list, p_mgr);
cl_qmap_apply_func(&p_mgr->p_subn->sw_guid_tbl, ucast_mgr_process_tbl,
p_mgr);
cl_qlist_remove_all(&p_mgr->port_order_list);
return 0;
}
static int ucast_mgr_setup_all_switches(osm_subn_t * p_subn)
{
osm_switch_t *p_sw;
uint16_t lids;
lids = (uint16_t) cl_ptr_vector_get_size(&p_subn->port_lid_tbl);
lids = lids ? lids - 1 : 0;
for (p_sw = (osm_switch_t *) cl_qmap_head(&p_subn->sw_guid_tbl);
p_sw != (osm_switch_t *) cl_qmap_end(&p_subn->sw_guid_tbl);
p_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item)) {
if (osm_switch_prepare_path_rebuild(p_sw, lids)) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_ERROR, "ERR 3A0B: "
"cannot setup switch 0x%016" PRIx64 "\n",
cl_ntoh64(osm_node_get_node_guid
(p_sw->p_node)));
return -1;
}
if (p_sw->search_ordering_ports) {
free(p_sw->search_ordering_ports);
p_sw->search_ordering_ports = NULL;
}
}
if (p_subn->opt.port_search_ordering_file) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_DEBUG,
"Fetching dimension ports file \'%s\'\n",
p_subn->opt.port_search_ordering_file);
if (parse_node_map(p_subn->opt.port_search_ordering_file,
set_search_ordering_ports, p_subn)) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_ERROR, "ERR 3A0F: "
"cannot parse port_search_ordering_file \'%s\'\n",
p_subn->opt.port_search_ordering_file);
}
}
return 0;
}
int osm_ucast_mgr_build_lid_matrices(IN osm_ucast_mgr_t * p_mgr)
{
uint32_t i;
uint32_t iteration_max;
cl_qmap_t *p_sw_guid_tbl;
p_sw_guid_tbl = &p_mgr->p_subn->sw_guid_tbl;
OSM_LOG(p_mgr->p_log, OSM_LOG_VERBOSE,
"Starting switches' Min Hop Table Assignment\n");
/*
Set up the weighting factors for the routing.
*/
cl_qmap_apply_func(p_sw_guid_tbl, set_default_hop_wf, NULL);
if (p_mgr->p_subn->opt.hop_weights_file) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Fetching hop weight factor file \'%s\'\n",
p_mgr->p_subn->opt.hop_weights_file);
if (parse_node_map(p_mgr->p_subn->opt.hop_weights_file,
set_hop_wf, p_mgr)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 3A05: "
"cannot parse hop_weights_file \'%s\'\n",
p_mgr->p_subn->opt.hop_weights_file);
}
}
/*
Set the switch matrices for each switch's own port 0 LID(s)
then set the lid matrices for the each switch's leaf nodes.
*/
cl_qmap_apply_func(p_sw_guid_tbl, ucast_mgr_process_hop_0_1, p_mgr);
/*
Get the switch matrices for each switch's neighbors.
This process requires a number of iterations equal to
the number of switches in the subnet minus 1.
In each iteration, a switch learns the lid/port/hop
information (as contained by a switch's lid matrix) from
its immediate neighbors. After each iteration, a switch
(and it's neighbors) know more routing information than
it did on the previous iteration.
Thus, by repeatedly absorbing the routing information of
neighbor switches, every switch eventually learns how to
route all LIDs on the subnet.
Note that there may not be any switches in the subnet if
we are in simple p2p configuration.
*/
iteration_max = cl_qmap_count(p_sw_guid_tbl);
/*
If there are switches in the subnet, iterate until the lid
matrix has been constructed. Otherwise, just immediately
indicate we're done if no switches exist.
*/
if (iteration_max) {
iteration_max--;
/*
we need to find out when the propagation of
hop counts has relaxed. So this global variable
is preset to 0 on each iteration and if
if non of the switches was set will exit the
while loop
*/
p_mgr->some_hop_count_set = TRUE;
for (i = 0; (i < iteration_max) && p_mgr->some_hop_count_set;
i++) {
p_mgr->some_hop_count_set = FALSE;
cl_qmap_apply_func(p_sw_guid_tbl,
ucast_mgr_process_neighbors, p_mgr);
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Min-hop propagated in %d steps\n", i);
}
return 0;
}
/* UPDN callback function */
static int updn_lid_matrices(void *ctx)
{
updn_t *p_updn = ctx;
cl_map_item_t *item;
osm_switch_t *p_sw;
int ret = 0;
OSM_LOG_ENTER(&p_updn->p_osm->log);
for (item = cl_qmap_head(&p_updn->p_osm->subn.sw_guid_tbl);
item != cl_qmap_end(&p_updn->p_osm->subn.sw_guid_tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *)item;
p_sw->priv = create_updn_node(p_sw);
if (!p_sw->priv) {
OSM_LOG(&(p_updn->p_osm->log), OSM_LOG_ERROR, "ERR AA0C: "
"cannot create updn node\n");
OSM_LOG_EXIT(&p_updn->p_osm->log);
return -1;
}
}
/* First setup root nodes */
p_updn->num_roots = 0;
if (p_updn->p_osm->subn.opt.root_guid_file) {
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_DEBUG,
"UPDN - Fetching root nodes from file \'%s\'\n",
p_updn->p_osm->subn.opt.root_guid_file);
ret = parse_node_map(p_updn->p_osm->subn.opt.root_guid_file,
rank_root_node, p_updn);
if (ret) {
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_ERROR, "ERR AA02: "
"cannot parse root guids file \'%s\'\n",
p_updn->p_osm->subn.opt.root_guid_file);
osm_ucast_mgr_build_lid_matrices(&p_updn->p_osm->sm.ucast_mgr);
updn_find_root_nodes_by_min_hop(p_updn);
} else if (p_updn->p_osm->subn.opt.connect_roots &&
p_updn->num_roots > 1)
osm_ucast_mgr_build_lid_matrices(&p_updn->p_osm->sm.ucast_mgr);
} else {
osm_ucast_mgr_build_lid_matrices(&p_updn->p_osm->sm.ucast_mgr);
updn_find_root_nodes_by_min_hop(p_updn);
}
if (p_updn->p_osm->subn.opt.ids_guid_file) {
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_DEBUG,
"UPDN - update node ids from file \'%s\'\n",
p_updn->p_osm->subn.opt.ids_guid_file);
ret = parse_node_map(p_updn->p_osm->subn.opt.ids_guid_file,
update_id, p_updn->p_osm);
if (ret)
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_ERROR, "ERR AA03: "
"cannot parse node ids file \'%s\'\n",
p_updn->p_osm->subn.opt.ids_guid_file);
}
/* Only if there are assigned root nodes do the algorithm, otherwise perform do nothing */
if (p_updn->num_roots) {
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_DEBUG,
"activating UPDN algorithm\n");
ret = updn_build_lid_matrices(p_updn);
} else {
OSM_LOG(&p_updn->p_osm->log, OSM_LOG_INFO,
"disabling UPDN algorithm, no root nodes were found\n");
ret = -1;
}
if (OSM_LOG_IS_ACTIVE_V2(&p_updn->p_osm->log, OSM_LOG_ROUTING))
osm_dump_qmap_to_file(p_updn->p_osm, "opensm-updn-roots.dump",
&p_updn->p_osm->subn.sw_guid_tbl,
dump_roots, NULL);
for (item = cl_qmap_head(&p_updn->p_osm->subn.sw_guid_tbl);
item != cl_qmap_end(&p_updn->p_osm->subn.sw_guid_tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *) item;
delete_updn_node(p_sw->priv);
}
OSM_LOG_EXIT(&p_updn->p_osm->log);
return ret;
}
