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_addr_t addr;
/* 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);
cancel_rpc(context, request_class, addr);
#ifdef NA_HAS_CCI
if (strcmp(HG_Class_get_name(hg_class), "cci") == 0)
cancel_bulk_transfer(hg_class, context, request_class, addr);
#endif
HG_Test_finalize(hg_class);
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;
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;
}
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;
}
int
main(int argc, char *argv[])
{
hg_class_t *hg_class = NULL;
hg_context_t *context = NULL;
hg_request_class_t *request_class = NULL;
na_addr_t addr;
hg_class = HG_Test_client_init(argc, argv, &addr, &na_test_comm_rank_g,
&context, &request_class);
/* Run RPC test */
measure_rpc(hg_class, context, addr, request_class);
NA_Test_barrier();
/* Run Bulk test */
measure_bulk_transfer(hg_class, context, addr, request_class);
HG_Test_finalize(hg_class);
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;
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;
}
int main(int argc, char *argv[])
{
na_addr_t addr;
bulk_write_in_t bulk_write_in_struct;
bulk_write_out_t bulk_write_out_struct;
hg_request_t bulk_write_request;
int fildes = 12345;
int *bulk_buf;
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;
size_t bulk_write_ret = 0;
hg_status_t bla_open_status;
hg_return_t hg_ret;
size_t i;
/* Initialize the interface (for convenience, shipper_test_client_init
* initializes the network interface with the selected plugin)
*/
HG_Test_client_init(argc, argv, &addr, NULL);
/* Prepare bulk_buf */
bulk_buf = (int*) malloc(bulk_size);
for (i = 0; i < count; i++) {
bulk_buf[i] = (int) i;
}
*buf_ptr = bulk_buf;
/* Register memory */
hg_ret = HG_Bulk_handle_create(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(addr, hg_test_pipeline_write_id_g,
&bulk_write_in_struct, &bulk_write_out_struct, &bulk_write_request);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not forward call\n");
return EXIT_FAILURE;
}
/* Wait for call to be executed and return value to be sent back
* (Request is freed when the call completes)
*/
hg_ret = HG_Wait(bulk_write_request, HG_MAX_IDLE_TIME, &bla_open_status);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Error during wait\n");
return EXIT_FAILURE;
}
if (!bla_open_status) {
fprintf(stderr, "Operation did not complete\n");
return EXIT_FAILURE;
} else {
/* printf("Call completed\n"); */
}
/* Get output parameters */
bulk_write_ret = bulk_write_out_struct.ret;
if (bulk_write_ret != bulk_size) {
fprintf(stderr, "Data not correctly processed\n");
}
/* Free request */
hg_ret = HG_Request_free(bulk_write_request);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not free request\n");
return EXIT_FAILURE;
}
/* Free memory handle */
hg_ret = HG_Bulk_handle_free(bulk_handle);
if (hg_ret != HG_SUCCESS) {
fprintf(stderr, "Could not free bulk data handle\n");
return EXIT_FAILURE;
}
/* Free bulk_buf */
free(bulk_buf);
bulk_buf = NULL;
HG_Test_finalize();
return EXIT_SUCCESS;
}
