/*---------------------------------------------------------------------------*/ int main(int argc, char *argv[]) { struct na_test_lat_info na_test_lat_info = { 0 }; na_size_t size, max_size; int ret = EXIT_SUCCESS; /* Initialize the interface */ NA_Test_init(argc, argv, &na_test_lat_info.na_test_info); na_test_lat_info.na_class = na_test_lat_info.na_test_info.na_class; na_test_lat_info.context = NA_Context_create(na_test_lat_info.na_class); na_test_lat_info.request_class = hg_request_init(na_test_request_progress, na_test_request_trigger, &na_test_lat_info); /* Lookup target addr */ na_test_target_lookup(&na_test_lat_info); /* Set max size */ max_size = NA_Msg_get_max_unexpected_size(na_test_lat_info.na_class); if (na_test_lat_info.na_test_info.mpi_comm_rank == 0) { fprintf(stdout, "# %s v%s\n", BENCHMARK_NAME, VERSION_NAME); fprintf(stdout, "# Loop %d times from size %d to %zu byte(s)\n", na_test_lat_info.na_test_info.loop, 1, max_size); #ifdef MERCURY_TESTING_HAS_VERIFY_DATA fprintf(stdout, "# WARNING verifying data, output will be slower\n"); #endif fprintf(stdout, "%-*s%*s\n", 10, "# Size", NWIDTH, "Latency (us)"); fflush(stdout); } /* Msg with different sizes */ for (size = 1; size <= max_size; size *= 2) na_test_measure_latency(&na_test_lat_info, size); /* Finalize interface */ if (na_test_lat_info.na_test_info.mpi_comm_rank == 0) na_test_send_finalize(&na_test_lat_info); NA_Addr_free(na_test_lat_info.na_class, na_test_lat_info.target_addr); hg_request_finalize(na_test_lat_info.request_class, NULL); NA_Context_destroy(na_test_lat_info.na_class, na_test_lat_info.context); NA_Test_finalize(&na_test_lat_info.na_test_info); return ret; }
int main(int argc, char *argv[]) { struct na_test_info na_test_info = { 0 }; struct na_test_params params; na_return_t na_ret; unsigned int i; int ret = EXIT_SUCCESS; /* Initialize the interface */ NA_Test_init(argc, argv, &na_test_info); params.na_class = na_test_info.na_class; params.context = NA_Context_create(params.na_class); /* Allocate send and recv bufs */ params.send_buf_len = NA_Msg_get_max_unexpected_size(params.na_class); params.recv_buf_len = params.send_buf_len; params.send_buf = (char*)NA_Msg_buf_alloc(params.na_class, params.send_buf_len, ¶ms.send_buf_plugin_data); params.recv_buf = (char*)NA_Msg_buf_alloc(params.na_class, params.recv_buf_len, ¶ms.recv_buf_plugin_data); /* Prepare bulk_buf */ params.bulk_size = NA_TEST_BULK_SIZE; params.bulk_buf = (unsigned int *) malloc( params.bulk_size * sizeof(unsigned int)); for (i = 0; i < params.bulk_size; i++) { params.bulk_buf[i] = i; } /* Perform an address lookup on the target */ na_ret = NA_Addr_lookup(params.na_class, params.context, lookup_cb, ¶ms, na_test_info.target_name, NA_OP_ID_IGNORE); if (na_ret != NA_SUCCESS) { NA_LOG_ERROR("Could not start lookup of addr %s", na_test_info.target_name); ret = EXIT_FAILURE; goto done; } while (1) { na_return_t trigger_ret; unsigned int actual_count = 0; unsigned int timeout = 0; do { trigger_ret = NA_Trigger(params.context, 0, 1, NULL, &actual_count); } while ((trigger_ret == NA_SUCCESS) && actual_count); if (test_msg_done_g && test_bulk_done_g) break; if (NA_Poll_try_wait(params.na_class, params.context)) timeout = NA_MAX_IDLE_TIME; na_ret = NA_Progress(params.na_class, params.context, timeout); if (na_ret != NA_SUCCESS) { ret = EXIT_FAILURE; goto done; } } ret = params.ret; printf("Finalizing...\n"); /* Free memory and addresses */ na_ret = NA_Addr_free(params.na_class, params.server_addr); if (na_ret != NA_SUCCESS) { NA_LOG_ERROR("Could not free addr"); ret = EXIT_FAILURE; goto done; } NA_Msg_buf_free(params.na_class, params.recv_buf, params.recv_buf_plugin_data); NA_Msg_buf_free(params.na_class, params.send_buf, params.send_buf_plugin_data); free(params.bulk_buf); NA_Context_destroy(params.na_class, params.context); NA_Test_finalize(&na_test_info); done: return ret; }
int main(int argc, char **argv) { char server_name[NA_TEST_MAX_ADDR_NAME]; struct na_test_params params; na_return_t na_ret; unsigned int i; /* Initialize the interface */ params.na_class = NA_Test_client_init(argc, argv, server_name, NA_TEST_MAX_ADDR_NAME, NULL); params.context = NA_Context_create(params.na_class); /* Allocate send and recv bufs */ params.send_buf_len = NA_Msg_get_max_unexpected_size(params.na_class); params.recv_buf_len = params.send_buf_len; params.send_buf = (char*) calloc(params.send_buf_len, sizeof(char)); params.recv_buf = (char*) calloc(params.recv_buf_len, sizeof(char)); /* Prepare bulk_buf */ params.bulk_size = NA_TEST_BULK_SIZE; params.bulk_buf = (int*) malloc(params.bulk_size * sizeof(int)); for (i = 0; i < params.bulk_size; i++) { params.bulk_buf[i] = i; } /* Perform an address lookup on the target */ na_ret = NA_Addr_lookup(params.na_class, params.context, lookup_cb, ¶ms, server_name, NA_OP_ID_IGNORE); if (na_ret != NA_SUCCESS) { fprintf(stderr, "Could not start lookup of addr %s\n", server_name); return EXIT_FAILURE; } while (!test_done_g) { na_return_t trigger_ret; unsigned int actual_count = 0; do { trigger_ret = NA_Trigger(params.context, 0, 1, &actual_count); } while ((trigger_ret == NA_SUCCESS) && actual_count); if (test_done_g) break; NA_Progress(params.na_class, params.context, NA_MAX_IDLE_TIME); } printf("Finalizing...\n"); /* Free memory and addresses */ na_ret = NA_Addr_free(params.na_class, params.server_addr); if (na_ret != NA_SUCCESS) { fprintf(stderr, "Could not free addr\n"); return EXIT_FAILURE; } free(params.recv_buf); free(params.send_buf); free(params.bulk_buf); NA_Context_destroy(params.na_class, params.context); NA_Test_finalize(params.na_class); return EXIT_SUCCESS; }
/*---------------------------------------------------------------------------*/ na_return_t NA_Addr_lookup_wait(na_class_t *na_class, const char *name, na_addr_t *addr) { na_addr_t new_addr = NULL; na_bool_t lookup_completed = NA_FALSE; na_context_t *context = NULL; na_return_t ret = NA_SUCCESS; if (!na_class) { NA_LOG_ERROR("NULL NA class"); ret = NA_INVALID_PARAM; goto done; } if (!name) { NA_LOG_ERROR("Lookup name is NULL"); ret = NA_INVALID_PARAM; goto done; } if (!addr) { NA_LOG_ERROR("NULL pointer to na_addr_t"); ret = NA_INVALID_PARAM; goto done; } context = NA_Context_create(na_class); if (!context) { NA_LOG_ERROR("Could not create context"); goto done; } ret = NA_Addr_lookup(na_class, context, &na_addr_lookup_cb, &new_addr, name, NA_OP_ID_IGNORE); if (ret != NA_SUCCESS) { NA_LOG_ERROR("Could not start NA_Addr_lookup"); goto done; } while (!lookup_completed) { na_return_t trigger_ret; unsigned int actual_count = 0; do { trigger_ret = NA_Trigger(context, 0, 1, &actual_count); } while ((trigger_ret == NA_SUCCESS) && actual_count); if (new_addr) { lookup_completed = NA_TRUE; *addr = new_addr; } if (lookup_completed) break; ret = NA_Progress(na_class, context, NA_MAX_IDLE_TIME); if (ret != NA_SUCCESS) { NA_LOG_ERROR("Could not make progress"); goto done; } } ret = NA_Context_destroy(na_class, context); if (ret != NA_SUCCESS) { NA_LOG_ERROR("Could not destroy context"); goto done; } done: return ret; }
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; }
/*---------------------------------------------------------------------------*/ hg_return_t HG_Test_finalize(hg_class_t *hg_class) { hg_return_t ret = HG_SUCCESS; na_return_t na_ret; NA_Test_barrier(); (void)hg_class; if (hg_test_is_client_g) { /* Terminate server */ if (hg_test_rank_g == 0) hg_test_finalize_rpc(); /* Free addr id */ ret = HG_Addr_free(HG_CLASS_DEFAULT, hg_test_addr_g); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not free addr\n"); goto done; } hg_test_addr_g = HG_ADDR_NULL; } else if (hg_test_addr_table_g) { unsigned int i; for (i = 0; i < hg_test_addr_table_size_g; i++) HG_Addr_free(HG_CLASS_DEFAULT, hg_test_addr_table_g[i]); free(hg_test_addr_table_g); hg_test_addr_table_g = NULL; } /* Destroy bulk handle */ HG_Bulk_free(hg_test_local_bulk_handle_g); hg_test_local_bulk_handle_g = HG_BULK_NULL; #ifdef MERCURY_TESTING_HAS_THREAD_POOL hg_thread_pool_destroy(hg_test_thread_pool_g); hg_thread_mutex_destroy(&hg_test_local_bulk_handle_mutex_g); #endif /* Finalize interface */ ret = HG_Hl_finalize(); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not finalize HG\n"); goto done; } na_ret = NA_Context_destroy(hg_test_na_class_g, hg_test_na_context_g); if (na_ret != NA_SUCCESS) { fprintf(stderr, "Could not destroy NA context\n"); goto done; } hg_test_na_context_g = NULL; na_ret = NA_Test_finalize(hg_test_na_class_g); if (na_ret != NA_SUCCESS) { fprintf(stderr, "Could not finalize NA interface\n"); goto done; } done: return ret; }