/*---------------------------------------------------------------------------*/
static void
hg_test_finalize_rpc(void)
{
hg_return_t hg_ret;
hg_handle_t handle;
hg_request_t *request_object = NULL;
request_object = hg_request_create(HG_REQUEST_CLASS_DEFAULT);
hg_ret = HG_Create(HG_CONTEXT_DEFAULT, hg_test_addr_g, hg_test_finalize_id_g,
&handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
}
/* Forward call to remote addr and get a new request */
hg_ret = HG_Forward(handle, hg_test_finalize_rpc_cb, request_object, NULL);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
}
hg_request_wait(request_object, HG_MAX_IDLE_TIME, NULL);
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
}
hg_request_destroy(request_object);
}
/*---------------------------------------------------------------------------*/
HG_TEST_RPC_CB(hg_test_nested1, handle)
{
hg_handle_t forward_handle;
struct hg_info *hg_info = NULL;
hg_return_t ret = HG_SUCCESS;
printf("In hg_test_nested1\n");
/* Get info from handle */
hg_info = HG_Get_info(handle);
ret = HG_Create(hg_info->context, hg_addr_table[1], hg_test_nested2_id_g,
&forward_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
/* Forward call to remote addr and get a new request */
printf("Forwarding call, op id: %u...\n", hg_test_nested2_id_g);
ret = HG_Forward(forward_handle, hg_test_nested1_forward_cb, handle, NULL);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
HG_Destroy(forward_handle);
done:
return ret;
}
int
main(int argc, char *argv[])
{
hg_class_t *hg_class = NULL;
hg_context_t *context = NULL;
hg_request_class_t *request_class = NULL;
hg_request_t *request = NULL;
hg_handle_t handle;
na_addr_t addr;
rpc_open_in_t rpc_open_in_struct;
hg_const_string_t rpc_open_path = MERCURY_TESTING_TEMP_DIRECTORY "/test.h5";
rpc_handle_t rpc_open_handle;
hg_return_t hg_ret;
/* Initialize the interface (for convenience, shipper_test_client_init
* initializes the network interface with the selected plugin)
*/
hg_class = HG_Test_client_init(argc, argv, &addr, NULL, &context,
&request_class);
request = hg_request_create(request_class);
hg_ret = HG_Create(hg_class, context, addr, hg_test_rpc_open_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
return EXIT_FAILURE;
}
/* Fill input structure */
rpc_open_handle.cookie = 12345;
rpc_open_in_struct.path = rpc_open_path;
rpc_open_in_struct.handle = rpc_open_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding rpc_open, op id: %u...\n", hg_test_rpc_open_id_g);
hg_ret = HG_Forward(handle, hg_test_rpc_forward_cb, request,
&rpc_open_in_struct);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
return EXIT_FAILURE;
}
hg_request_destroy(request);
HG_Test_finalize(hg_class);
return EXIT_SUCCESS;
}
void hg_engine_create_handle(na_addr_t addr, hg_id_t id,
hg_handle_t *handle)
{
hg_return_t ret;
ret = HG_Create(hg_context, addr, id, handle);
assert(ret == HG_SUCCESS);
(void)ret;
return;
}
static hg_return_t
cancel_rpc(hg_context_t *context, hg_request_class_t *request_class,
hg_addr_t addr)
{
hg_request_t *request = NULL;
hg_handle_t handle;
rpc_open_in_t rpc_open_in_struct;
hg_const_string_t rpc_open_path = MERCURY_TESTING_TEMP_DIRECTORY "/test.h5";
rpc_handle_t rpc_open_handle;
hg_return_t ret;
request = hg_request_create(request_class);
ret = HG_Create(context, addr, hg_test_rpc_open_id_g, &handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
/* Fill input structure */
rpc_open_handle.cookie = 12345;
rpc_open_in_struct.path = rpc_open_path;
rpc_open_in_struct.handle = rpc_open_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding rpc_open, op id: %u...\n", hg_test_rpc_open_id_g);
ret = HG_Forward(handle, hg_test_rpc_forward_cb, request,
&rpc_open_in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
ret = HG_Cancel(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "HG_Cancel failed: %d\n", ret);
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Complete */
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
hg_request_destroy(request);
done:
return ret;
}
int
main(int argc, char *argv[])
{
hg_class_t *hg_class = NULL;
hg_context_t *context = NULL;
hg_request_class_t *request_class = NULL;
hg_request_t *request = NULL;
hg_handle_t handle;
hg_addr_t addr;
hg_return_t hg_ret;
/* Initialize the interface (for convenience, shipper_test_client_init
* initializes the network interface with the selected plugin)
*/
hg_class = HG_Test_client_init(argc, argv, &addr, NULL, &context,
&request_class);
request = hg_request_create(request_class);
hg_ret = HG_Create(context, addr, hg_test_overflow_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
return EXIT_FAILURE;
}
/* Forward call to remote addr and get a new request */
printf("Forwarding call, op id: %u...\n", hg_test_overflow_id_g);
hg_ret = HG_Forward(handle, hg_test_rpc_forward_cb, request, NULL);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
return EXIT_FAILURE;
}
hg_request_destroy(request);
HG_Test_finalize(hg_class);
return EXIT_SUCCESS;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_overflow(hg_context_t *context, hg_request_class_t *request_class,
hg_addr_t addr, hg_id_t rpc_id, hg_cb_t callback)
{
hg_request_t *request = NULL;
hg_handle_t handle;
hg_return_t hg_ret = HG_SUCCESS;
request = hg_request_create(request_class);
/* Create RPC request */
hg_ret = HG_Create(context, addr, rpc_id, &handle);
if (hg_ret != HG_SUCCESS) {
HG_TEST_LOG_ERROR("Could not create handle");
goto done;
}
/* Forward call to remote addr and get a new request */
HG_TEST_LOG_DEBUG("Forwarding RPC, op id: %u...", rpc_id);
hg_ret = HG_Forward(handle, callback, request, NULL);
if (hg_ret != HG_SUCCESS) {
HG_TEST_LOG_ERROR("Could not forward call");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
HG_TEST_LOG_ERROR("Could not destroy handle");
goto done;
}
done:
hg_request_destroy(request);
return hg_ret;
}
/*---------------------------------------------------------------------------*/
static void
hg_test_finalize_rpc2(hg_addr_t addr)
{
hg_return_t hg_ret;
hg_handle_t handle;
hg_ret = HG_Create(HG_CONTEXT_DEFAULT, addr, hg_test_finalize2_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
}
/* Forward call to remote addr and get a new request */
hg_ret = HG_Forward(handle, hg_test_finalize_rpc_cb, NULL, NULL);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
}
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
}
}
int main(int argc, char *argv[])
{
hg_class_t *hg_class = NULL;
hg_context_t *context = NULL;
hg_request_class_t *request_class = NULL;
hg_request_t *request = NULL;
hg_handle_t handle;
hg_addr_t addr;
bulk_write_in_t bulk_write_in_struct;
int fildes = 12345;
int *bulk_buf = NULL;
void *buf_ptr[1];
size_t count = (1024 * 1024 * MERCURY_TESTING_BUFFER_SIZE) / sizeof(int);
size_t bulk_size = count * sizeof(int);
hg_bulk_t bulk_handle = HG_BULK_NULL;
hg_return_t hg_ret;
size_t i;
/* Prepare bulk_buf */
bulk_buf = (int*) malloc(bulk_size);
for (i = 0; i < count; i++) {
bulk_buf[i] = i;
}
*buf_ptr = bulk_buf;
/* Initialize the interface (for convenience, shipper_test_client_init
* initializes the network interface with the selected plugin)
*/
hg_class = HG_Test_client_init(argc, argv, &addr, NULL, &context,
&request_class);
request = hg_request_create(request_class);
hg_ret = HG_Create(context, addr, hg_test_bulk_write_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
return EXIT_FAILURE;
}
/* Register memory */
hg_ret = HG_Bulk_create(hg_class, 1, buf_ptr, &bulk_size,
HG_BULK_READ_ONLY, &bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
return EXIT_FAILURE;
}
/* Fill input structure */
bulk_write_in_struct.fildes = fildes;
bulk_write_in_struct.bulk_handle = bulk_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding bulk_write, op id: %u...\n", hg_test_bulk_write_id_g);
hg_ret = HG_Forward(handle, hg_test_bulk_forward_cb, request,
&bulk_write_in_struct);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Free memory handle */
hg_ret = HG_Bulk_free(bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
return EXIT_FAILURE;
}
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
return EXIT_FAILURE;
}
hg_request_destroy(request);
HG_Test_finalize(hg_class);
/* Free bulk data */
free(bulk_buf);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
hg_class_t *hg_class = NULL;
hg_context_t *context = NULL;
hg_request_class_t *request_class = NULL;
hg_request_t *request = NULL;
hg_handle_t handle;
hg_addr_t addr;
bulk_write_in_t bulk_write_in_struct;
int fildes = 12345;
void **bulk_buf;
size_t *bulk_sizes;
size_t bulk_size = 1024 * 1024 * MERCURY_TESTING_BUFFER_SIZE / sizeof(int);
size_t bulk_size_x = 16;
size_t bulk_size_y = 0;
size_t *bulk_size_y_var = NULL;
hg_bulk_t bulk_handle = HG_BULK_NULL;
hg_return_t hg_ret;
size_t i, j;
/* Initialize the interface (for convenience, shipper_test_client_init
* initializes the network interface with the selected plugin)
*/
hg_class = HG_Test_client_init(argc, argv, &addr, NULL, &context,
&request_class);
request = hg_request_create(request_class);
hg_ret = HG_Create(context, addr, hg_test_bulk_seg_write_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
return EXIT_FAILURE;
}
/* This will create a list of variable size segments */
if (na_test_use_variable_g) {
printf("Using variable size segments!\n");
/* bulk_size_x >= 2 */
/* 524288 + 262144 + 131072 + 65536 + 32768 + 16384 + 8192 + 8192 */
bulk_size_x = 8;
bulk_size_y_var = (size_t*) malloc(bulk_size_x * sizeof(size_t));
bulk_size_y_var[0] = bulk_size / 2;
for (i = 1; i < bulk_size_x - 1; i++) {
bulk_size_y_var[i] = bulk_size_y_var[i-1] / 2;
}
bulk_size_y_var[bulk_size_x - 1] = bulk_size_y_var[bulk_size_x - 2];
}
/* This will use an extra encoding buffer */
else if (na_test_use_extra_g) {
printf("Using large number of segments!\n");
bulk_size_x = 1024;
bulk_size_y = bulk_size / bulk_size_x;
}
else {
/* This will create a list of fixed size segments */
bulk_size_y = bulk_size / bulk_size_x;
}
/* Prepare bulk_buf */
bulk_buf = (void **) malloc(bulk_size_x * sizeof(void *));
bulk_sizes = (size_t *) malloc(bulk_size_x * sizeof(size_t));
if (bulk_size_y_var) {
int val = 0;
for (i = 0; i < bulk_size_x; i++) {
bulk_sizes[i] = bulk_size_y_var[i] * sizeof(int);
bulk_buf[i] = malloc(bulk_sizes[i]);
for (j = 0; j < bulk_size_y_var[i]; j++) {
((int **) (bulk_buf))[i][j] = val;
val++;
}
}
} else {
for (i = 0; i < bulk_size_x; i++) {
bulk_sizes[i] = bulk_size_y * sizeof(int);
bulk_buf[i] = malloc(bulk_sizes[i]);
for (j = 0; j < bulk_size_y; j++) {
((int **) (bulk_buf))[i][j] = i * bulk_size_y + j;
}
}
}
/* Register memory */
hg_ret = HG_Bulk_create(hg_class, bulk_size_x, bulk_buf, bulk_sizes,
HG_BULK_READ_ONLY, &bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
return EXIT_FAILURE;
}
free(bulk_sizes);
bulk_sizes = NULL;
if (bulk_size_y_var) free(bulk_size_y_var);
bulk_size_y_var = NULL;
/* Fill input structure */
bulk_write_in_struct.fildes = fildes;
bulk_write_in_struct.bulk_handle = bulk_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding bulk_write, op id: %u...\n", hg_test_bulk_seg_write_id_g);
hg_ret = HG_Forward(handle, hg_test_bulk_seg_forward_cb, request,
&bulk_write_in_struct);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Free memory handle */
hg_ret = HG_Bulk_free(bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
return EXIT_FAILURE;
}
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
return EXIT_FAILURE;
}
hg_request_destroy(request);
HG_Test_finalize(hg_class);
/* Free bulk_buf */
for (i = 0; i < bulk_size_x; i++) {
free(bulk_buf[i]);
bulk_buf[i] = NULL;
}
free(bulk_buf);
bulk_buf = NULL;
return EXIT_SUCCESS;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_drc_token_request(struct hg_test_info *hg_test_info)
{
hg_request_t *request = NULL;
hg_handle_t handle;
#ifdef HG_TEST_DRC_USE_TOKEN
hg_string_t token;
#else
hg_uint32_t credential;
#endif
hg_test_drc_grant_in_t in_struct;
hg_test_drc_grant_out_t out_struct;
hg_return_t ret = HG_SUCCESS;
#ifndef HG_TEST_DRC_IGNORE
int rc;
#endif
/* Look up target addr using target name info */
ret = HG_Hl_addr_lookup_wait(hg_test_info->context,
hg_test_info->request_class, hg_test_info->na_test_info.target_name,
&hg_test_info->target_addr, HG_MAX_IDLE_TIME);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not find addr for target %s",
hg_test_info->na_test_info.target_name);
goto done;
}
/* Create new request */
request = hg_request_create(hg_test_info->request_class);
/* Create request with invalid RPC id */
ret = HG_Create(hg_test_info->context, hg_test_info->target_addr,
hg_test_drc_grant_id_g, &handle);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not create handle");
goto done;
}
/* Get WLM ID and set input */
#ifndef HG_TEST_DRC_IGNORE
in_struct.wlm_id = drc_get_wlm_id();
#else
in_struct.wlm_id = 12340;
#endif
/* Forward call to target addr */
printf("# %u requesting access to remote...\n", in_struct.wlm_id);
fflush(stdout);
ret = HG_Forward(handle, hg_test_drc_token_request_cb, request, &in_struct);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not forward call with id=%d",
hg_test_drc_grant_id_g);
goto done;
}
/* Wait for completion */
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Get output */
ret = HG_Get_output(handle, &out_struct);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not get output");
goto done;
}
#ifdef HG_TEST_DRC_USE_TOKEN
/* Get token back */
token = out_struct.token;
printf("# Received token %s\n", token);
fflush(stdout);
/* Translate token */
#ifndef HG_TEST_DRC_IGNORE
rc = drc_access_with_token(token, 0, &hg_test_info->credential_info);
if (rc != DRC_SUCCESS) {/* failed to grant access to the credential */
HG_LOG_ERROR("drc_access_with_token() failed (%d, %s)", rc,
drc_strerror(-rc));
ret = HG_PROTOCOL_ERROR;
goto done;
}
#endif
#else
/* Get credential back */
credential = out_struct.credential;
printf("# Received credential %u\n", credential);
fflush(stdout);
/* Access credential */
#ifndef HG_TEST_DRC_IGNORE
drc_access_again:
rc = drc_access(credential, 0, &hg_test_info->credential_info);
if (rc != DRC_SUCCESS) { /* failed to access credential */
if (rc == -DRC_EINVAL) {
sleep(1);
goto drc_access_again;
}
HG_LOG_ERROR("drc_access() failed (%d, %s)", rc,
drc_strerror(-rc));
ret = HG_PROTOCOL_ERROR;
goto done;
}
#endif
#endif
/* Set cookie for further use */
#ifndef HG_TEST_DRC_IGNORE
hg_test_info->cookie = drc_get_first_cookie(hg_test_info->credential_info);
#else
hg_test_info->cookie = 123456789;
#endif
printf("# Cookie is %u\n", hg_test_info->cookie);
fflush(stdout);
/* Clean up resources */
ret = HG_Free_output(handle, &out_struct);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not free output");
goto done;
}
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not destroy handle");
goto done;
}
hg_request_destroy(request);
/* Free target addr */
ret = HG_Addr_free(hg_test_info->hg_class, hg_test_info->target_addr);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not free addr");
goto done;
}
done:
return ret;
}
static hg_return_t
measure_rpc(hg_class_t *hg_class, hg_context_t *context, na_addr_t addr,
hg_request_class_t *request_class)
{
int avg_iter;
double time_read = 0, min_time_read = 0, max_time_read = 0;
hg_return_t ret = HG_SUCCESS;
size_t i;
if (na_test_comm_rank_g == 0) {
printf("# Executing RPC with %d client(s) -- loop %d time(s)\n",
na_test_comm_size_g, MERCURY_TESTING_MAX_LOOP);
}
if (na_test_comm_rank_g == 0) printf("# Warming up...\n");
/* Warm up for RPC */
for (i = 0; i < RPC_SKIP; i++) {
hg_request_t *request;
hg_handle_t handle;
request = hg_request_create(request_class);
ret = HG_Create(hg_class, context, addr, hg_test_perf_rpc_id_g, &handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
ret = HG_Forward(handle, hg_test_perf_forward_cb, request, NULL);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Complete */
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
hg_request_destroy(request);
}
NA_Test_barrier();
if (na_test_comm_rank_g == 0) printf("%*s%*s%*s%*s%*s%*s",
10, "# Time (s)", 10, "Min (s)", 10, "Max (s)",
12, "Calls (c/s)", 12, "Min (c/s)", 12, "Max (c/s)");
if (na_test_comm_rank_g == 0) printf("\n");
/* RPC benchmark */
for (avg_iter = 0; avg_iter < MERCURY_TESTING_MAX_LOOP; avg_iter++) {
hg_request_t *request;
hg_handle_t handle;
hg_time_t t1, t2;
double td, part_time_read;
double calls_per_sec, min_calls_per_sec, max_calls_per_sec;
request = hg_request_create(request_class);
ret = HG_Create(hg_class, context, addr, hg_test_perf_rpc_id_g, &handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
hg_time_get_current(&t1);
ret = HG_Forward(handle, hg_test_perf_forward_cb, request, NULL);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
NA_Test_barrier();
hg_time_get_current(&t2);
td = hg_time_to_double(hg_time_subtract(t2, t1));
time_read += td;
if (!min_time_read) min_time_read = time_read;
min_time_read = (td < min_time_read) ? td : min_time_read;
max_time_read = (td > max_time_read) ? td : max_time_read;
/* Complete */
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
hg_request_destroy(request);
part_time_read = time_read / (avg_iter + 1);
calls_per_sec = na_test_comm_size_g / part_time_read;
min_calls_per_sec = na_test_comm_size_g / max_time_read;
max_calls_per_sec = na_test_comm_size_g / min_time_read;
/* At this point we have received everything so work out the bandwidth */
if (na_test_comm_rank_g == 0) {
printf("%*f%*f%*f%*.*f%*.*f%*.*f\r",
10, part_time_read, 10, min_time_read, 10, max_time_read,
12, 2, calls_per_sec, 12, 2, min_calls_per_sec, 12, 2,
max_calls_per_sec);
}
}
if (na_test_comm_rank_g == 0) printf("\n");
done:
return ret;
}
static hg_return_t
measure_bulk_transfer(hg_class_t *hg_class, hg_context_t *context,
na_addr_t addr, hg_request_class_t *request_class)
{
bulk_write_in_t in_struct;
int *bulk_buf;
void *buf_ptr[1];
size_t count = (1024 * 1024 * MERCURY_TESTING_BUFFER_SIZE) / sizeof(int);
hg_bulk_t bulk_handle = HG_BULK_NULL;
size_t nbytes;
double nmbytes;
hg_handle_t handle;
int avg_iter;
double time_read = 0, min_time_read = 0, max_time_read = 0;
struct hg_info *hg_info = NULL;
hg_return_t ret = HG_SUCCESS;
size_t i;
/* Prepare bulk_buf */
nbytes = count * sizeof(int);
nmbytes = (double) nbytes / (1024 * 1024);
if (na_test_comm_rank_g == 0) {
printf("# Reading Bulk Data (%f MB) with %d client(s) -- loop %d time(s)\n",
nmbytes, na_test_comm_size_g, MERCURY_TESTING_MAX_LOOP);
}
bulk_buf = (int *) malloc(nbytes);
for (i = 0; i < count; i++) {
bulk_buf[i] = (int) i;
}
*buf_ptr = bulk_buf;
ret = HG_Create(hg_class, context, addr, hg_test_perf_bulk_id_g,
&handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
/* Must get info to retrieve bulk class if not provided by user */
hg_info = HG_Get_info(handle);
/* Register memory */
ret = HG_Bulk_create(hg_info->hg_bulk_class, 1, buf_ptr, &nbytes,
HG_BULK_READ_ONLY, &bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
goto done;
}
/* Fill input structure */
in_struct.fildes = 0;
in_struct.bulk_handle = bulk_handle;
if (na_test_comm_rank_g == 0) printf("# Warming up...\n");
/* Warm up for bulk data */
for (i = 0; i < BULK_SKIP; i++) {
hg_request_t *request;
request = hg_request_create(request_class);
ret = HG_Forward(handle, hg_test_perf_forward_cb, request, &in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
hg_request_destroy(request);
}
NA_Test_barrier();
if (na_test_comm_rank_g == 0) printf("%*s%*s%*s%*s%*s%*s",
10, "# Time (s)", 10, "Min (s)", 10, "Max (s)",
12, "BW (MB/s)", 12, "Min (MB/s)", 12, "Max (MB/s)");
if (na_test_comm_rank_g == 0) printf("\n");
/* Bulk data benchmark */
for (avg_iter = 0; avg_iter < MERCURY_TESTING_MAX_LOOP; avg_iter++) {
hg_request_t *request;
hg_time_t t1, t2;
double td, part_time_read;
double read_bandwidth, min_read_bandwidth, max_read_bandwidth;
request = hg_request_create(request_class);
hg_time_get_current(&t1);
ret = HG_Forward(handle, hg_test_perf_forward_cb, request, &in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
NA_Test_barrier();
hg_time_get_current(&t2);
td = hg_time_to_double(hg_time_subtract(t2, t1));
time_read += td;
if (!min_time_read) min_time_read = time_read;
min_time_read = (td < min_time_read) ? td : min_time_read;
max_time_read = (td > max_time_read) ? td : max_time_read;
hg_request_destroy(request);
part_time_read = time_read / (avg_iter + 1);
read_bandwidth = nmbytes * na_test_comm_size_g / part_time_read;
min_read_bandwidth = nmbytes * na_test_comm_size_g / max_time_read;
max_read_bandwidth = nmbytes * na_test_comm_size_g / min_time_read;
/* At this point we have received everything so work out the bandwidth */
if (na_test_comm_rank_g == 0) {
printf("%*f%*f%*f%*.*f%*.*f%*.*f\r",
10, part_time_read, 10, min_time_read, 10, max_time_read,
12, 2, read_bandwidth, 12, 2, min_read_bandwidth, 12, 2,
max_read_bandwidth);
}
}
if (na_test_comm_rank_g == 0) printf("\n");
/* Free memory handle */
ret = HG_Bulk_free(bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
goto done;
}
/* Free bulk data */
free(bulk_buf);
/* Complete */
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
done:
return ret;
}
int main(int argc, char *argv[])
{
struct hg_test_info hg_test_info = { 0 };
hg_request_t *request = NULL;
hg_handle_t handle;
bulk_write_in_t bulk_write_in_struct;
int fildes = 12345;
int *bulk_buf = NULL;
void *buf_ptrs[2];
size_t buf_sizes[2];
size_t count = (1024 * 1024 * MERCURY_TESTING_BUFFER_SIZE) / sizeof(int);
size_t bulk_size = count * sizeof(int);
hg_bulk_t bulk_handle = HG_BULK_NULL;
hg_return_t hg_ret;
size_t i;
/* Prepare bulk_buf */
bulk_buf = (int *) malloc(bulk_size);
for (i = 0; i < count; i++) {
bulk_buf[i] = (int) i;
}
buf_ptrs[0] = bulk_buf;
buf_sizes[0] = bulk_size;
buf_ptrs[1] = NULL;
buf_sizes[1] = 0;
/* Initialize the interface */
HG_Test_init(argc, argv, &hg_test_info);
request = hg_request_create(hg_test_info.request_class);
hg_ret = HG_Create(hg_test_info.context, hg_test_info.target_addr,
hg_test_bulk_write_id_g, &handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
return EXIT_FAILURE;
}
/* Register memory */
hg_ret = HG_Bulk_create(hg_test_info.hg_class, 2, buf_ptrs,
(hg_size_t *) buf_sizes, HG_BULK_READ_ONLY, &bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
return EXIT_FAILURE;
}
/* Fill input structure */
bulk_write_in_struct.fildes = fildes;
bulk_write_in_struct.bulk_handle = bulk_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding bulk_write, op id: %u...\n", hg_test_bulk_write_id_g);
hg_ret = HG_Forward(handle, hg_test_bulk_forward_cb, request,
&bulk_write_in_struct);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Free memory handle */
hg_ret = HG_Bulk_free(bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
return EXIT_FAILURE;
}
/* Complete */
hg_ret = HG_Destroy(handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
return EXIT_FAILURE;
}
hg_request_destroy(request);
HG_Test_finalize(&hg_test_info);
/* Free bulk data */
free(bulk_buf);
return EXIT_SUCCESS;
}
static hg_return_t
cancel_bulk_transfer(hg_class_t *hg_class, hg_context_t *context,
hg_request_class_t *request_class, hg_addr_t addr)
{
hg_request_t *request = NULL;
hg_handle_t handle;
bulk_write_in_t bulk_write_in_struct;
int *bulk_buf = NULL;
void *buf_ptr[1];
size_t count = (1024 * 1024 * MERCURY_TESTING_BUFFER_SIZE) / sizeof(int);
size_t bulk_size = count * sizeof(int);
hg_bulk_t bulk_handle = HG_BULK_NULL;
hg_return_t ret;
size_t i;
/* Prepare bulk_buf */
bulk_buf = (int*) malloc(bulk_size);
for (i = 0; i < count; i++) {
bulk_buf[i] = (int) i;
}
*buf_ptr = bulk_buf;
request = hg_request_create(request_class);
ret = HG_Create(context, addr, hg_test_bulk_write_id_g, &handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
/* Register memory */
ret = HG_Bulk_create(hg_class, 1, buf_ptr, (hg_size_t *) &bulk_size,
HG_BULK_READ_ONLY, &bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
goto done;
}
/* Fill input structure */
bulk_write_in_struct.fildes = -1; /* To tell target to cancel bulk transfer */
bulk_write_in_struct.bulk_handle = bulk_handle;
/* Forward call to remote addr and get a new request */
printf("Forwarding bulk_write, op id: %u...\n", hg_test_bulk_write_id_g);
ret = HG_Forward(handle, hg_test_bulk_forward_cb, request,
&bulk_write_in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
/* Free memory handle */
ret = HG_Bulk_free(bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
goto done;
}
/* Complete */
ret = HG_Destroy(handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
hg_request_destroy(request);
done:
return ret;
}
static int
snappy_compress_rpc(hg_class_t *hg_class, hg_context_t *hg_context,
na_addr_t na_target_addr)
{
int *input;
size_t source_length = NR_ITEMS * sizeof(int);
hg_bulk_t input_bulk_handle;
void *compressed;
size_t max_compressed_length;
hg_bulk_t compressed_bulk_handle;
snappy_compress_in_t snappy_compress_input;
struct snappy_compress_rpc_args *snappy_compress_rpc_args;
hg_handle_t handle;
int i;
/**
* We are going to take a buffer and send it to the server for compression.
* Mercury works better when you know how much (or an uppper bound on) data
* to expect.
*/
max_compressed_length = snappy_max_compressed_length(source_length);
printf("Input buffer length is: %zu\n", source_length);
printf("Max compressed length is: %zu\n", max_compressed_length);
/* Generate input buffer */
input = (int *) malloc(source_length);
for (i = 0; i < NR_ITEMS; i++) {
input[i] = rand() % 10;
}
print_buf(20, input);
/* Allocate compressed buffer */
compressed = malloc(max_compressed_length);
memset(compressed, '\0', max_compressed_length);
/* Create HG handle bound to target */
HG_Create(hg_context, na_target_addr, snappy_compress_id_g, &handle);
/**
* Associate 'handle' with a region of memory. Mercury's bulk transfer is
* going to get/put data from this region.
*/
HG_Bulk_create(hg_class, 1, (void **) &input,
&source_length, HG_BULK_READ_ONLY, &input_bulk_handle);
HG_Bulk_create(hg_class, 1, &compressed,
&max_compressed_length, HG_BULK_READWRITE, &compressed_bulk_handle);
/* Create struct to keep arguments as the call will be executed
* asynchronously */
snappy_compress_rpc_args = (struct snappy_compress_rpc_args *) malloc(
sizeof(struct snappy_compress_rpc_args));
snappy_compress_rpc_args->input = input;
snappy_compress_rpc_args->input_length = source_length;
snappy_compress_rpc_args->input_bulk_handle = input_bulk_handle;
snappy_compress_rpc_args->compressed = compressed;
snappy_compress_rpc_args->compressed_bulk_handle = compressed_bulk_handle;
/* Set input arguments that will be passed to HG_Forward */
snappy_compress_input.input_bulk_handle = input_bulk_handle;
snappy_compress_input.compressed_bulk_handle = compressed_bulk_handle;
/* Forward the call */
printf("Sending input to target\n");
HG_Forward(handle, snappy_compress_rpc_cb, snappy_compress_rpc_args,
&snappy_compress_input);
/* Handle will be destroyed when call completes (reference count) */
HG_Destroy(handle);
return 0;
}
static hg_return_t
measure_bulk_transfer(struct hg_test_info *hg_test_info, size_t total_size,
unsigned int nhandles)
{
bulk_write_in_t in_struct;
char *bulk_buf;
void **buf_ptrs;
size_t *buf_sizes;
hg_bulk_t bulk_handle = HG_BULK_NULL;
size_t nbytes = total_size;
double nmbytes = (double) total_size / (1024 * 1024);
size_t loop = (total_size > LARGE_SIZE) ? MERCURY_TESTING_MAX_LOOP :
MERCURY_TESTING_MAX_LOOP * 10;
size_t skip = (total_size > LARGE_SIZE) ? LARGE_SKIP : SMALL_SKIP;
hg_handle_t *handles = NULL;
hg_request_t *request;
struct hg_test_perf_args args;
size_t avg_iter;
double time_read = 0, read_bandwidth;
hg_return_t ret = HG_SUCCESS;
size_t i;
/* Prepare bulk_buf */
bulk_buf = malloc(nbytes);
for (i = 0; i < nbytes; i++)
bulk_buf[i] = 1;
buf_ptrs = (void **) &bulk_buf;
buf_sizes = &nbytes;
/* Create handles */
handles = malloc(nhandles * sizeof(hg_handle_t));
for (i = 0; i < nhandles; i++) {
ret = HG_Create(hg_test_info->context, hg_test_info->target_addr,
hg_test_perf_bulk_read_id_g, &handles[i]);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not start call\n");
goto done;
}
}
request = hg_request_create(hg_test_info->request_class);
hg_atomic_init32(&args.op_completed_count, 0);
args.op_count = nhandles;
args.request = request;
/* Register memory */
ret = HG_Bulk_create(hg_test_info->hg_class, 1, buf_ptrs,
(hg_size_t *) buf_sizes, HG_BULK_READWRITE, &bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not create bulk data handle\n");
goto done;
}
/* Fill input structure */
in_struct.fildes = 0;
in_struct.bulk_handle = bulk_handle;
/* Warm up for bulk data */
for (i = 0; i < skip; i++) {
unsigned int j;
for (j = 0; j < nhandles; j++) {
ret = HG_Forward(handles[j], hg_test_perf_forward_cb, &args, &in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
hg_request_reset(request);
hg_atomic_set32(&args.op_completed_count, 0);
}
NA_Test_barrier(&hg_test_info->na_test_info);
/* Bulk data benchmark */
for (avg_iter = 0; avg_iter < loop; avg_iter++) {
hg_time_t t1, t2;
unsigned int j;
hg_time_get_current(&t1);
for (j = 0; j < nhandles; j++) {
ret = HG_Forward(handles[j], hg_test_perf_forward_cb, &args, &in_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
goto done;
}
}
hg_request_wait(request, HG_MAX_IDLE_TIME, NULL);
NA_Test_barrier(&hg_test_info->na_test_info);
hg_time_get_current(&t2);
time_read += hg_time_to_double(hg_time_subtract(t2, t1));
hg_request_reset(request);
hg_atomic_set32(&args.op_completed_count, 0);
#ifdef MERCURY_TESTING_PRINT_PARTIAL
read_bandwidth = nmbytes
* (double) (nhandles * (avg_iter + 1) *
(unsigned int) hg_test_info->na_test_info.mpi_comm_size)
/ time_read;
/* At this point we have received everything so work out the bandwidth */
if (hg_test_info->na_test_info.mpi_comm_rank == 0)
fprintf(stdout, "%-*d%*.*f\r", 10, (int) nbytes, NWIDTH,
NDIGITS, read_bandwidth);
#endif
#ifdef MERCURY_TESTING_HAS_VERIFY_DATA
for (i = 0; i < nbytes; i++) {
if (bulk_buf[i] != (char) i) {
printf("Error detected in bulk transfer, buf[%d] = %d, "
"was expecting %d!\n", (int) i, (char) bulk_buf[i],
(char) i);
break;
}
}
#endif
}
#ifndef MERCURY_TESTING_PRINT_PARTIAL
read_bandwidth = nmbytes
* (double) (nhandles * loop *
(unsigned int) hg_test_info->na_test_info.mpi_comm_size)
/ time_read;
/* At this point we have received everything so work out the bandwidth */
if (hg_test_info->na_test_info.mpi_comm_rank == 0)
fprintf(stdout, "%-*d%*.*f", 10, (int) nbytes, NWIDTH, NDIGITS,
read_bandwidth);
#endif
if (hg_test_info->na_test_info.mpi_comm_rank == 0) fprintf(stdout, "\n");
/* Free memory handle */
ret = HG_Bulk_free(bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
goto done;
}
/* Complete */
hg_request_destroy(request);
for (i = 0; i < nhandles; i++) {
ret = HG_Destroy(handles[i]);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not complete\n");
goto done;
}
}
done:
free(bulk_buf);
free(handles);
return ret;
}
