/** * The routine that sets up the routines that actually do the work. * This 'handle' parameter is the only value passed to this callback, but * Mercury routines allow us to query information about the context in which * we are called. */ static hg_return_t snappy_compress_cb(hg_handle_t handle) { struct snappy_transfer_args *snappy_transfer_args; size_t input_length; snappy_transfer_args = (struct snappy_transfer_args *) malloc(sizeof(struct snappy_transfer_args)); snappy_transfer_args->handle = handle; /* Get input parameters sent on origin through on HG_Forward() */ HG_Get_input(handle, &snappy_transfer_args->snappy_compress_input); /* Now set up the bulk transfer and get the input length */ input_length = HG_Bulk_get_size( snappy_transfer_args->snappy_compress_input.input_bulk_handle); /* The bulk 'handle' is basically a pointer, with the addition that 'handle' * could refer to more than one memory region. */ HG_Bulk_create(HG_Get_info(handle)->hg_bulk_class, 1, NULL, &input_length, HG_BULK_READWRITE, &snappy_transfer_args->local_input_bulk_handle); /* Pull data from origin's memory into our own */ /* Another way to do this is via HG_Bulk_access, which would allow mercury, * if "co-resident" to avoid a copy of data */ HG_Bulk_transfer(HG_Get_info(handle)->bulk_context, snappy_pull_cb, snappy_transfer_args, HG_BULK_PULL, HG_Get_info(handle)->addr, snappy_transfer_args->snappy_compress_input.input_bulk_handle, 0, /* origin */ snappy_transfer_args->local_input_bulk_handle, 0, /* local */ input_length, HG_OP_ID_IGNORE); return HG_SUCCESS; }
static hg_return_t snappy_pull_cb(const struct hg_bulk_cb_info *hg_bulk_cb_info) { struct snappy_transfer_args *snappy_transfer_args = (struct snappy_transfer_args *) hg_bulk_cb_info->arg; hg_return_t ret = HG_SUCCESS; void *input; size_t input_length; size_t source_length = HG_Bulk_get_size(snappy_transfer_args->local_input_bulk_handle); /* Get pointer to input buffer from local handle */ HG_Bulk_access(hg_bulk_cb_info->local_handle, 0, source_length, HG_BULK_READ_ONLY, 1, &input, &input_length, NULL); printf("Transferred input buffer of length: %zu\n", input_length); print_buf(20, (int *) input); /* Allocate compressed buffer for compressing input data */ snappy_transfer_args->compressed_length = snappy_max_compressed_length(input_length); snappy_transfer_args->compressed = malloc(snappy_transfer_args->compressed_length); /* Compress data */ printf("Compressing buffer...\n"); snappy_transfer_args->ret = snappy_compress(input, input_length, snappy_transfer_args->compressed, &snappy_transfer_args->compressed_length); printf("Return value of snappy_compress is: %d\n", snappy_transfer_args->ret); printf("Compressed buffer length is: %zu\n", snappy_transfer_args->compressed_length); print_buf(5, (int *) snappy_transfer_args->compressed); /* Free bulk handles */ HG_Bulk_free(snappy_transfer_args->local_input_bulk_handle); if (snappy_validate_compressed_buffer(snappy_transfer_args->compressed, snappy_transfer_args->compressed_length) == SNAPPY_OK) { printf("Compressed buffer validated: compressed successfully\n"); } /* Now set up bulk transfer for "push to origin" callback */ HG_Bulk_create(HG_Get_info(snappy_transfer_args->handle)->hg_bulk_class, 1, &snappy_transfer_args->compressed, &snappy_transfer_args->compressed_length, HG_BULK_WRITE_ONLY, &snappy_transfer_args->local_compressed_bulk_handle); HG_Bulk_transfer(HG_Get_info(snappy_transfer_args->handle)->bulk_context, snappy_push_cb, snappy_transfer_args, HG_BULK_PUSH, HG_Get_info(snappy_transfer_args->handle)->addr, snappy_transfer_args->snappy_compress_input.compressed_bulk_handle, 0, /* origin */ snappy_transfer_args->local_compressed_bulk_handle, 0, /* local */ snappy_transfer_args->compressed_length, HG_OP_ID_IGNORE); return ret; }
/*---------------------------------------------------------------------------*/ HG_TEST_RPC_CB(hg_test_bulk_write, handle) { struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; struct hg_test_bulk_args *bulk_args = NULL; bulk_write_in_t in_struct; hg_return_t ret = HG_SUCCESS; int fildes; hg_op_id_t hg_bulk_op_id; bulk_args = (struct hg_test_bulk_args *) malloc( sizeof(struct hg_test_bulk_args)); /* Keep handle to pass to callback */ bulk_args->handle = handle; /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get input parameters and data */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not get input\n"); return ret; } /* Get parameters */ fildes = in_struct.fildes; origin_bulk_handle = in_struct.bulk_handle; bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->fildes = fildes; /* Create a new block handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *) &bulk_args->nbytes, HG_BULK_READWRITE, &local_bulk_handle); /* Pull bulk data */ ret = HG_Bulk_transfer(hg_info->context, hg_test_bulk_transfer_cb, bulk_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, bulk_args->nbytes, &hg_bulk_op_id); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } /* Test HG_Bulk_Cancel() */ if (fildes < 0) { ret = HG_Bulk_cancel(hg_bulk_op_id); if (ret != HG_SUCCESS){ fprintf(stderr, "Could not cancel bulk data\n"); return ret; } } HG_Free_input(handle, &in_struct); return ret; }
/*---------------------------------------------------------------------------*/ 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; }
/*---------------------------------------------------------------------------*/ HG_TEST_RPC_CB(hg_test_posix_write, handle) { hg_return_t ret = HG_SUCCESS; struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; struct hg_test_bulk_args *bulk_args = NULL; bulk_write_in_t in_struct; bulk_args = (struct hg_test_bulk_args *) malloc( sizeof(struct hg_test_bulk_args)); /* Keep handle to pass to callback */ bulk_args->handle = handle; /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get input struct */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not get input struct\n"); return ret; } origin_bulk_handle = in_struct.bulk_handle; /* Create a new block handle to read the data */ bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->fildes = in_struct.fildes; /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *) &bulk_args->nbytes, HG_BULK_READWRITE, &local_bulk_handle); /* Pull bulk data */ ret = HG_Bulk_transfer(hg_info->context, hg_test_posix_write_transfer_cb, bulk_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, bulk_args->nbytes, HG_OP_ID_IGNORE); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } HG_Free_input(handle, &in_struct); return ret; }
static hg_return_t lookup_cb(const struct hg_cb_info *callback_info) { na_addr_t svr_addr = callback_info->info.lookup.addr; my_rpc_in_t in; struct hg_info *hgi; int ret; struct my_rpc_state *my_rpc_state_p; assert(callback_info->ret == 0); /* set up state structure */ my_rpc_state_p = malloc(sizeof(*my_rpc_state_p)); my_rpc_state_p->size = 512; /* This includes allocating a src buffer for bulk transfer */ my_rpc_state_p->buffer = calloc(1, 512); assert(my_rpc_state_p->buffer); sprintf((char*)my_rpc_state_p->buffer, "Hello world!\n"); my_rpc_state_p->value = *((int*)callback_info->arg); free(callback_info->arg); /* create create handle to represent this rpc operation */ hg_engine_create_handle(svr_addr, my_rpc_id, &my_rpc_state_p->handle); /* register buffer for rdma/bulk access by server */ hgi = HG_Get_info(my_rpc_state_p->handle); assert(hgi); ret = HG_Bulk_create(hgi->hg_class, 1, &my_rpc_state_p->buffer, &my_rpc_state_p->size, HG_BULK_READ_ONLY, &in.bulk_handle); my_rpc_state_p->bulk_handle = in.bulk_handle; assert(ret == 0); /* Send rpc. Note that we are also transmitting the bulk handle in the * input struct. It was set above. */ in.input_val = my_rpc_state_p->value; ret = HG_Forward(my_rpc_state_p->handle, my_rpc_cb, my_rpc_state_p, &in); assert(ret == 0); (void)ret; return(NA_SUCCESS); }
/* HG_svrec_add_ult() -- handler */ void HG_svrec_add_ult(hg_handle_t h) { int ret; sv_rec_remove_in_t in; sv_rec_remove_out_t out; struct hg_info *hgi; margo_instance_id mid; hg_size_t sz; hg_bulk_t lbh; /* local bulk handle */ void *p; ret = HG_Get_input(h, &in); assert(ret == HG_SUCCESS); hgi = HG_Get_info(h); mid = margo_hg_class_to_instance(hgi->hg_class); assert(rec_list != NULL); assert(rec_ct < rec_list_sz); p = &rec_list[rec_ct]; sz = sizeof(hg_sv_rec_t); ret = HG_Bulk_create(hgi->hg_class, 1, (void **) &p, &sz, HG_BULK_READWRITE, &lbh); assert(ret == HG_SUCCESS); ret = margo_bulk_transfer(mid, HG_BULK_PULL, hgi->addr, in.b, 0, lbh, 0, sz); assert(!ret); printf(" added %s\n", rec_list[rec_ct].addr); rec_ct++; out.ret = 0; ret = margo_respond(mid, h, &out); assert(!ret); ret = HG_Destroy(h); assert(ret == HG_SUCCESS); return; }
/*---------------------------------------------------------------------------*/ HG_TEST_RPC_CB(hg_test_posix_read, handle) { hg_return_t ret = HG_SUCCESS; struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; struct hg_test_bulk_args *bulk_args = NULL; bulk_write_in_t in_struct; void *buf; ssize_t read_ret; /* for debug */ int i; const int *buf_ptr; bulk_args = (struct hg_test_bulk_args *) malloc( sizeof(struct hg_test_bulk_args)); /* Keep handle to pass to callback */ bulk_args->handle = handle; /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get input struct */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not get input struct\n"); return ret; } origin_bulk_handle = in_struct.bulk_handle; /* Create a new block handle to read the data */ bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->fildes = in_struct.fildes; /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *) &bulk_args->nbytes, HG_BULK_READ_ONLY, &local_bulk_handle); /* Call bulk_write */ HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE, 1, &buf, NULL, NULL); printf("Calling read with fd: %d\n", in_struct.fildes); read_ret = read(in_struct.fildes, buf, bulk_args->nbytes); /* Check bulk buf */ buf_ptr = (const int*) buf; for (i = 0; i < (int)(bulk_args->nbytes / sizeof(int)); i++) { if (buf_ptr[i] != i) { printf("Error detected after read, buf[%d] = %d, was expecting %d!\n", i, buf_ptr[i], i); break; } } /* Fill output structure */ bulk_args->ret = read_ret; /* Push bulk data */ ret = HG_Bulk_transfer(hg_info->context, hg_test_posix_read_transfer_cb, bulk_args, HG_BULK_PUSH, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, bulk_args->nbytes, HG_OP_ID_IGNORE); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } HG_Free_input(handle, &in_struct); return ret; }
/*---------------------------------------------------------------------------*/ HG_TEST_RPC_CB(hg_test_bulk_seg_write, handle) { struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; struct hg_test_bulk_args *bulk_args = NULL; size_t nbytes_read; size_t offset; hg_return_t ret = HG_SUCCESS; bulk_write_in_t in_struct; bulk_args = (struct hg_test_bulk_args *) malloc( sizeof(struct hg_test_bulk_args)); /* Keep handle to pass to callback */ bulk_args->handle = handle; /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get input parameters and data */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not get input\n"); return ret; } /* Get parameters */ origin_bulk_handle = in_struct.bulk_handle; hg_atomic_set32(&bulk_args->completed_transfers, 0); /* Create a new block handle to read the data */ bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->fildes = in_struct.fildes; /* For testing purposes try to read the data in two blocks of different sizes */ nbytes_read = bulk_args->nbytes / 2 + 16; printf("Start reading first chunk of %lu bytes...\n", nbytes_read); /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, (hg_size_t *) &bulk_args->nbytes, HG_BULK_READWRITE, &local_bulk_handle); /* Pull bulk data */ ret = HG_Bulk_transfer(hg_info->context, hg_test_bulk_seg_transfer_cb, bulk_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, nbytes_read, HG_OP_ID_IGNORE); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } offset = nbytes_read; nbytes_read = bulk_args->nbytes - nbytes_read; printf("Start reading second chunk of %lu bytes...\n", nbytes_read); ret = HG_Bulk_transfer(hg_info->context, hg_test_bulk_seg_transfer_cb, bulk_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, offset, local_bulk_handle, offset, nbytes_read, HG_OP_ID_IGNORE); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } HG_Free_input(handle, &in_struct); return ret; }
/*---------------------------------------------------------------------------*/ HG_TEST_RPC_CB(hg_test_perf_bulk, handle) { hg_return_t ret = HG_SUCCESS; struct hg_info *hg_info = NULL; hg_bulk_t origin_bulk_handle = HG_BULK_NULL; hg_bulk_t local_bulk_handle = HG_BULK_NULL; struct hg_test_bulk_args *bulk_args = NULL; bulk_write_in_t in_struct; bulk_args = (struct hg_test_bulk_args *) malloc( sizeof(struct hg_test_bulk_args)); /* Keep handle to pass to callback */ bulk_args->handle = handle; /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get input struct */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not get input struct\n"); return ret; } origin_bulk_handle = in_struct.bulk_handle; hg_atomic_set32(&bulk_args->completed_transfers, 0); /* Create a new block handle to read the data */ bulk_args->nbytes = HG_Bulk_get_size(origin_bulk_handle); bulk_args->fildes = in_struct.fildes; #ifdef MERCURY_TESTING_USE_LOCAL_BULK /* Create a new bulk handle to read the data */ HG_Bulk_create(hg_info->hg_class, 1, NULL, &bulk_args->nbytes, HG_BULK_READWRITE, &local_bulk_handle); #else #ifdef MERCURY_TESTING_HAS_THREAD_POOL hg_thread_mutex_lock(&hg_test_local_bulk_handle_mutex_g); #endif local_bulk_handle = hg_test_local_bulk_handle_g; #endif /* Pull bulk data */ ret = HG_Bulk_transfer(hg_info->context, hg_test_perf_bulk_transfer_cb, bulk_args, HG_BULK_PULL, hg_info->addr, origin_bulk_handle, 0, local_bulk_handle, 0, bulk_args->nbytes, HG_OP_ID_IGNORE); if (ret != HG_SUCCESS) { fprintf(stderr, "Could not read bulk data\n"); return ret; } #ifndef MERCURY_TESTING_USE_LOCAL_BULK #ifdef MERCURY_TESTING_HAS_THREAD_POOL hg_thread_mutex_unlock(&hg_test_local_bulk_handle_mutex_g); #endif #endif HG_Free_input(handle, &in_struct); return ret; }
/*---------------------------------------------------------------------------*/ static hg_return_t hg_test_drc_grant_cb(hg_handle_t handle) { const struct hg_info *hg_info = NULL; struct hg_test_info *hg_test_info = NULL; hg_test_drc_grant_in_t in_struct; hg_test_drc_grant_out_t out_struct; hg_return_t ret = HG_SUCCESS; #ifdef HG_TEST_DRC_USE_TOKEN hg_string_t token; #endif #ifndef HG_TEST_DRC_IGNORE int rc; #endif /* Get info from handle */ hg_info = HG_Get_info(handle); /* Get test info */ hg_test_info = (struct hg_test_info *) HG_Class_get_data(hg_info->hg_class); /* Get input buffer */ ret = HG_Get_input(handle, &in_struct); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not get input"); goto done; } /* Get parameters */ hg_test_info->wlm_id = in_struct.wlm_id; /* Grant access to another job */ printf("# Granting access to wlm_id %u...\n", hg_test_info->wlm_id); fflush(stdout); #ifndef HG_TEST_DRC_IGNORE drc_grant_again: rc = drc_grant(hg_test_info->credential, hg_test_info->wlm_id, DRC_FLAGS_TARGET_WLM); if (rc != DRC_SUCCESS && rc != -DRC_ALREADY_GRANTED) { if (rc == -DRC_EINVAL) { sleep(1); goto drc_grant_again; } HG_LOG_ERROR("drc_grant() to %d failed (%d, %s)", hg_test_info->wlm_id, rc, drc_strerror(-rc)); ret = HG_PROTOCOL_ERROR; goto done; } #endif #ifdef HG_TEST_DRC_USE_TOKEN /* Get the token to pass around to processes in other job */ #ifndef HG_TEST_DRC_IGNORE rc = drc_get_credential_token(hg_test_info->credential, &token); if (rc != DRC_SUCCESS) { HG_LOG_ERROR("drc_get_credential_token() failed (%d, %s)", rc, drc_strerror(-rc)); ret = HG_PROTOCOL_ERROR; goto done; } #else token = "my_test_token"; #endif /* Fill output structure */ printf("# Access granted, token is %s\n", token); fflush(stdout); out_struct.token = token; #else out_struct.credential = hg_test_info->credential; #endif /* Free handle and send response back */ ret = HG_Respond(handle, NULL, NULL, &out_struct); if (ret != HG_SUCCESS) { HG_LOG_ERROR("Could not respond"); goto done; } HG_Free_input(handle, &in_struct); HG_Destroy(handle); 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[]) { 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; struct hg_info *hg_info = NULL; 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(hg_class, context, addr, hg_test_bulk_write_id_g, &handle); if (hg_ret != HG_SUCCESS) { fprintf(stderr, "Could not start call\n"); return EXIT_FAILURE; } /* Must get info to retrieve bulk class if not provided by user */ hg_info = HG_Get_info(handle); /* Register memory */ hg_ret = HG_Bulk_create(hg_info->hg_bulk_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; }