/*---------------------------------------------------------------------------*/ 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; }