/*---------------------------------------------------------------------------*/ na_class_t * NA_Test_server_init(int argc, char *argv[], na_bool_t print_ready, char ***addr_table, unsigned int *addr_table_size, unsigned int *max_number_of_peers) { na_class_t *na_class = NULL; const char *info_string = NULL; /* TODO call it once first for now to set static MPI */ na_test_gen_config(argc, argv); na_test_opt_ind_g = 1; #ifdef MERCURY_HAS_PARALLEL_TESTING /* Test run in parallel using mpirun so must intialize MPI to get * basic setup info etc */ na_test_mpi_init(NA_TRUE); #endif info_string = na_test_gen_config(argc, argv); na_class = NA_Initialize(info_string, NA_TRUE); #ifdef NA_HAS_MPI if (na_test_use_mpi_g) { na_test_set_config(NA_MPI_Get_port_name(na_class)); } else #endif #ifdef NA_HAS_CCI if (na_test_use_cci_g) { const char *uri = NA_CCI_Get_port_name(na_class); na_test_set_config(uri); } else #endif { /* Gather strings and write config */ na_test_set_config(info_string); } /* As many entries in addr table as number of server ranks */ if (addr_table_size) *addr_table_size = na_addr_table_size; /* Point addr table to NA MPI addr table */ if (addr_table) *addr_table = na_addr_table; #ifdef MERCURY_HAS_PARALLEL_TESTING if (max_number_of_peers) *max_number_of_peers = MPIEXEC_MAX_NUMPROCS; #else if (max_number_of_peers) *max_number_of_peers = 1; #endif if (print_ready) { /* Used by CTest Test Driver */ printf("Waiting for client...\n"); fflush(stdout); } return na_class; }
/*---------------------------------------------------------------------------*/ na_return_t NA_Test_init(int argc, char *argv[], struct na_test_info *na_test_info) { char *info_string = NULL; struct na_init_info na_init_info; na_return_t ret = NA_SUCCESS; na_test_parse_options(argc, argv, na_test_info); #ifdef MERCURY_HAS_PARALLEL_TESTING /* Test run in parallel using mpirun so must intialize MPI to get * basic setup info etc */ na_test_mpi_init(na_test_info); na_test_info->max_number_of_peers = MPIEXEC_MAX_NUMPROCS; #else na_test_info->mpi_comm_rank = 0; na_test_info->mpi_comm_size = 1; na_test_info->max_number_of_peers = 1; #endif /* Generate NA init string and get config options */ info_string = na_test_gen_config(na_test_info); if (!info_string) { NA_LOG_ERROR("Could not generate config string"); ret = NA_PROTOCOL_ERROR; goto done; } /* Call cleanup before doing anything */ if (na_test_info->listen && na_test_info->mpi_comm_rank == 0) NA_Cleanup(); memset(&na_init_info, 0, sizeof(struct na_init_info)); if (na_test_info->busy_wait) { na_init_info.progress_mode = NA_NO_BLOCK; printf("# Initializing NA in busy wait mode\n"); } else na_init_info.progress_mode = NA_DEFAULT; na_init_info.auth_key = na_test_info->key; na_init_info.max_contexts = na_test_info->max_contexts; printf("# Using info string: %s\n", info_string); na_test_info->na_class = NA_Initialize_opt(info_string, na_test_info->listen, &na_init_info); if (!na_test_info->na_class) { NA_LOG_ERROR("Could not initialize NA"); ret = NA_PROTOCOL_ERROR; goto done; } if (!na_test_info->extern_init) { if (na_test_info->listen) { char addr_string[NA_TEST_MAX_ADDR_NAME]; na_size_t addr_string_len = NA_TEST_MAX_ADDR_NAME; na_addr_t self_addr; na_return_t nret; /* TODO only rank 0 */ nret = NA_Addr_self(na_test_info->na_class, &self_addr); if (nret != NA_SUCCESS) { NA_LOG_ERROR("Could not get self addr"); } nret = NA_Addr_to_string(na_test_info->na_class, addr_string, &addr_string_len, self_addr); if (nret != NA_SUCCESS) { NA_LOG_ERROR("Could not convert addr to string"); } NA_Addr_free(na_test_info->na_class, self_addr); na_test_set_config(addr_string); #ifdef MERCURY_HAS_PARALLEL_TESTING /* If static client must wait for server to write config file */ if (na_test_info->mpi_static) MPI_Barrier(MPI_COMM_WORLD); #endif /* Used by CTest Test Driver to know when to launch clients */ MERCURY_TESTING_READY_MSG(); } /* Get config from file if self option is not passed */ else if (!na_test_info->self_send) { char test_addr_name[NA_TEST_MAX_ADDR_NAME] = { '\0' }; #ifdef MERCURY_HAS_PARALLEL_TESTING /* If static client must wait for server to write config file */ if (na_test_info->mpi_static) MPI_Barrier(MPI_COMM_WORLD); #endif if (na_test_info->mpi_comm_rank == 0) { na_test_get_config(test_addr_name, NA_TEST_MAX_ADDR_NAME); } #ifdef MERCURY_HAS_PARALLEL_TESTING /* Broadcast addr name */ MPI_Bcast(test_addr_name, NA_TEST_MAX_ADDR_NAME, MPI_BYTE, 0, na_test_info->mpi_comm); #endif na_test_info->target_name = strdup(test_addr_name); printf("# Target name read: %s\n", na_test_info->target_name); } } done: if (ret != NA_SUCCESS) NA_Test_finalize(na_test_info); free(info_string); return ret; }
/*---------------------------------------------------------------------------*/ hg_return_t hg_test_drc_acquire(int argc, char *argv[], struct hg_test_info *hg_test_info) { struct hg_test_info hg_test_drc_info = { 0 }; struct hg_init_info hg_test_drc_init_info = { 0 }; hg_return_t ret = HG_SUCCESS; if (!hg_test_info->credential) { /* Create an NA class with "tcp" protocol */ hg_test_drc_info.na_test_info.extern_init = NA_TRUE; hg_test_drc_info.na_test_info.protocol = strdup("tcp"); hg_test_drc_info.na_test_info.listen = hg_test_info->na_test_info.listen; if (NA_Test_init(argc, argv, &hg_test_drc_info.na_test_info) != NA_SUCCESS) { HG_LOG_ERROR("Could not initialize NA test layer"); ret = HG_NA_ERROR; goto done; } /* Assign NA class */ hg_test_drc_init_info.na_class = hg_test_drc_info.na_test_info.na_class; /* Init HG HL with init options */ ret = HG_Hl_init_opt(NULL, hg_test_drc_info.na_test_info.listen, &hg_test_drc_init_info); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not initialize HG HL"); goto done; } hg_test_drc_info.hg_class = HG_CLASS_DEFAULT; hg_test_drc_info.context = HG_CONTEXT_DEFAULT; hg_test_drc_info.request_class = HG_REQUEST_CLASS_DEFAULT; /* Attach test info to class */ HG_Class_set_data(hg_test_drc_info.hg_class, &hg_test_drc_info, NULL); /* Register routines */ hg_test_drc_register(hg_test_drc_info.hg_class); /* Acquire DRC token */ if (hg_test_drc_info.na_test_info.listen) { char addr_string[NA_TEST_MAX_ADDR_NAME]; na_size_t addr_string_len = NA_TEST_MAX_ADDR_NAME; hg_addr_t self_addr; ret = hg_test_drc_token_acquire(&hg_test_drc_info); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not acquire DRC token"); goto done; } /* TODO only rank 0 */ ret = HG_Addr_self(hg_test_drc_info.hg_class, &self_addr); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not get self addr"); goto done; } ret = HG_Addr_to_string(hg_test_drc_info.hg_class, addr_string, &addr_string_len, self_addr); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not convert addr to string"); goto done; } HG_Addr_free(hg_test_drc_info.hg_class, self_addr); na_test_set_config(addr_string); /* Used by CTest Test Driver to know when to launch clients */ MERCURY_TESTING_READY_MSG(); /* Progress */ do { unsigned int total_count = 0; unsigned int actual_count = 0; do { ret = HG_Trigger(hg_test_drc_info.context, 0, 1, &actual_count); total_count += actual_count; } while ((ret == HG_SUCCESS) && actual_count); /* Break as soon as something was triggered */ if (total_count) break; ret = HG_Progress(hg_test_drc_info.context, HG_MAX_IDLE_TIME); } while (ret == HG_SUCCESS || ret == HG_TIMEOUT); } else { char test_addr_name[NA_TEST_MAX_ADDR_NAME] = { '\0' }; if (hg_test_drc_info.na_test_info.mpi_comm_rank == 0) na_test_get_config(test_addr_name, NA_TEST_MAX_ADDR_NAME); /* Broadcast addr name */ NA_Test_bcast(test_addr_name, NA_TEST_MAX_ADDR_NAME, 0, &hg_test_drc_info.na_test_info); hg_test_drc_info.na_test_info.target_name = strdup(test_addr_name); printf("# Target name read: %s\n", hg_test_drc_info.na_test_info.target_name); ret = hg_test_drc_token_request(&hg_test_drc_info); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not request DRC token"); goto done; } } #ifdef MERCURY_HAS_PARALLEL_TESTING /* TODO bcast cookie when parallel mode */ #endif /* Finalize HG HL interface */ ret = HG_Hl_finalize(); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not finalize HG HL"); goto done; } /* Finalize NA test class interface */ #ifdef MERCURY_HAS_PARALLEL_TESTING hg_test_drc_info.na_test_info.mpi_no_finalize = NA_TRUE; #endif if (NA_Test_finalize(&hg_test_drc_info.na_test_info) != NA_SUCCESS) { HG_LOG_ERROR("Could not finalize NA test interface"); ret = HG_NA_ERROR; goto done; } hg_test_info->credential = hg_test_drc_info.credential; } else { hg_test_drc_info.credential = hg_test_info->credential; ret = hg_test_drc_token_acquire(&hg_test_drc_info); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not acquire DRC token"); goto done; } } /* Copy cookie/credential info */ hg_test_info->wlm_id = hg_test_drc_info.wlm_id; hg_test_info->credential_info = hg_test_drc_info.credential_info; hg_test_info->cookie = hg_test_drc_info.cookie; /* Sleep a few seconds to make sure listener is initialized */ if (!hg_test_drc_info.na_test_info.listen) { unsigned int sleep_sec = 5; printf("# Sleeping now for %d seconds...\n", sleep_sec); fflush(stdout); sleep(sleep_sec); } done: return ret; }