/*---------------------------------------------------------------------------*/
na_class_t *
NA_Test_client_init(int argc, char *argv[], char *addr_name,
na_size_t max_addr_name, int *rank)
{
const char *info_string = NULL;
na_class_t *na_class = NULL;
info_string = na_test_gen_config(argc, argv);
#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_FALSE);
#endif
na_class = NA_Initialize(info_string, NA_FALSE);
/* Get config from file if self option is not passed */
if (!na_test_use_self_g) {
char test_addr_name[NA_TEST_MAX_ADDR_NAME];
na_test_get_config(test_addr_name, NA_TEST_MAX_ADDR_NAME);
strncpy(addr_name, test_addr_name,
(max_addr_name < NA_TEST_MAX_ADDR_NAME) ?
max_addr_name : NA_TEST_MAX_ADDR_NAME);
}
if (rank) *rank = na_test_comm_rank_g;
return na_class;
}
/*---------------------------------------------------------------------------*/
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;
}
void hg_engine_init(na_bool_t listen, const char* local_addr)
{
int ret;
/* boilerplate HG initialization steps */
network_class = NA_Initialize(local_addr, listen);
assert(network_class);
na_context = NA_Context_create(network_class);
assert(na_context);
hg_class = HG_Init_na(network_class, na_context);
assert(hg_class);
hg_context = HG_Context_create(hg_class);
assert(hg_context);
/* start up thread to drive progress */
ret = pthread_create(&hg_progress_tid, NULL, hg_progress_fn, NULL);
assert(ret == 0);
(void)ret;
return;
}
int
main(void)
{
const char *na_info_string = NULL;
na_class_t *na_class;
na_context_t * na_context;
char self_addr_string[PATH_MAX];
na_addr_t self_addr;
FILE *na_config = NULL;
hg_class_t *hg_class;
hg_context_t *hg_context;
unsigned major;
unsigned minor;
unsigned patch;
hg_return_t hg_ret;
na_size_t self_addr_string_size = PATH_MAX;
HG_Version_get(&major, &minor, &patch);
printf("Server running mercury version %u.%u-%u\n",
major, minor, patch);
/* Get info string */
/* bmi+tcp://localhost:port */
na_info_string = getenv(HG_PORT_NAME);
if (!na_info_string) {
fprintf(stderr, HG_PORT_NAME " environment variable must be set, e.g.:\nMERCURY_PORT_NAME=\"tcp://127.0.0.1:22222\"\n");
exit(0);
}
/* Initialize NA */
na_class = NA_Initialize(na_info_string, NA_TRUE);
/* Get self addr to tell client about */
NA_Addr_self(na_class, &self_addr);
NA_Addr_to_string(na_class, self_addr_string, &self_addr_string_size, self_addr);
NA_Addr_free(na_class, self_addr);
printf("Server address is: %s\n", self_addr_string);
/* Write addr to a file */
na_config = fopen(TEMP_DIRECTORY CONFIG_FILE_NAME, "w+");
if (!na_config) {
fprintf(stderr, "Could not open config file from: %s\n",
TEMP_DIRECTORY CONFIG_FILE_NAME);
exit(0);
}
fprintf(na_config, "%s\n", self_addr_string);
fclose(na_config);
/* Create NA context */
na_context = NA_Context_create(na_class);
/* Initialize Mercury with the desired network abstraction class */
hg_class = HG_Init_na(na_class, na_context);
/* Create HG context */
hg_context = HG_Context_create(hg_class);
/* Register RPC */
snappy_compress_register(hg_class);
/* Poke progress engine and check for events */
do {
unsigned int actual_count = 0;
do {
hg_ret = HG_Trigger(hg_context, 0 /* timeout */,
1 /* max count */, &actual_count);
} while ((hg_ret == HG_SUCCESS) && actual_count);
/* Do not try to make progress anymore if we're done */
if (snappy_compress_done_target_g) break;
hg_ret = HG_Progress(hg_context, HG_MAX_IDLE_TIME);
} while (hg_ret == HG_SUCCESS);
/* Finalize */
HG_Context_destroy(hg_context);
HG_Finalize(hg_class);
NA_Context_destroy(na_class, na_context);
NA_Finalize(na_class);
return EXIT_SUCCESS;
}
