/*---------------------------------------------------------------------------*/
na_return_t
NA_Progress(na_class_t *na_class, na_context_t *context, unsigned int timeout)
{
struct na_private_context *na_private_context =
(struct na_private_context *) context;
double remaining = timeout / 1000.0; /* Convert timeout in ms into seconds */
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->progress) {
NA_LOG_ERROR("progress plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
/* TODO option for concurrent progress */
/* Prevent multiple threads from concurrently calling progress on the same
* context */
hg_thread_mutex_lock(&na_private_context->progress_mutex);
while (na_private_context->progressing) {
hg_time_t t1, t2;
if (remaining <= 0) {
/* Timeout is 0 so leave */
hg_thread_mutex_unlock(&na_private_context->progress_mutex);
ret = NA_TIMEOUT;
goto done;
}
hg_time_get_current(&t1);
if (hg_thread_cond_timedwait(&na_private_context->progress_cond,
&na_private_context->progress_mutex,
(unsigned int) (remaining * 1000)) != HG_UTIL_SUCCESS) {
/* Timeout occurred so leave */
hg_thread_mutex_unlock(&na_private_context->progress_mutex);
ret = NA_TIMEOUT;
goto done;
}
hg_time_get_current(&t2);
remaining -= hg_time_to_double(hg_time_subtract(t2, t1));
if (remaining < 0) {
/* Give a chance to call progress with timeout of 0 if
* progressing is NA_FALSE */
remaining = 0;
}
}
na_private_context->progressing = NA_TRUE;
hg_thread_mutex_unlock(&na_private_context->progress_mutex);
/* Try to make progress for remaining time */
ret = na_class->progress(na_class, context,
(unsigned int) (remaining * 1000));
hg_thread_mutex_lock(&na_private_context->progress_mutex);
/* At this point, either progress succeeded or failed with NA_TIMEOUT,
* meaning remaining time is now 0, so wake up other threads waiting */
na_private_context->progressing = NA_FALSE;
hg_thread_cond_signal(&na_private_context->progress_cond);
hg_thread_mutex_unlock(&na_private_context->progress_mutex);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
static na_return_t
na_test_measure_latency(struct na_test_lat_info *na_test_lat_info,
na_size_t size)
{
char *send_buf = NULL, *recv_buf = NULL;
void *send_buf_data, *recv_buf_data;
size_t loop = (size_t) na_test_lat_info->na_test_info.loop * 100;
size_t skip = SMALL_SKIP;
na_op_id_t send_op_id;
na_op_id_t recv_op_id;
hg_request_t *recv_request = NULL;
na_size_t unexpected_header_size =
NA_Msg_get_unexpected_header_size(na_test_lat_info->na_class);
na_size_t buf_size =
size < unexpected_header_size ? unexpected_header_size : size;
size_t avg_iter;
double time_read = 0, read_lat;
na_return_t ret = NA_SUCCESS;
size_t i;
/* Prepare send_buf */
if (buf_size == unexpected_header_size)
buf_size++;
send_buf = NA_Msg_buf_alloc(na_test_lat_info->na_class, buf_size,
&send_buf_data);
NA_Msg_init_unexpected(na_test_lat_info->na_class, send_buf, buf_size);
for (i = unexpected_header_size; i < buf_size; i++)
send_buf[i] = (char) i;
/* Prepare recv buf */
recv_buf = NA_Msg_buf_alloc(na_test_lat_info->na_class, buf_size,
&recv_buf_data);
memset(recv_buf, 0, buf_size);
/* Create operation IDs */
send_op_id = NA_Op_create(na_test_lat_info->na_class);
recv_op_id = NA_Op_create(na_test_lat_info->na_class);
recv_request = hg_request_create(na_test_lat_info->request_class);
/* Warm up */
for (i = 0; i < skip; i++) {
/* Post recv */
ret = NA_Msg_recv_expected(na_test_lat_info->na_class,
na_test_lat_info->context, na_test_recv_expected_cb, recv_request,
recv_buf, buf_size, recv_buf_data, na_test_lat_info->target_addr, 0,
0, &recv_op_id);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_recv_expected() failed");
goto done;
}
/* Post send */
ret = NA_Msg_send_unexpected(na_test_lat_info->na_class,
na_test_lat_info->context, NULL, NULL, send_buf, buf_size,
send_buf_data, na_test_lat_info->target_addr, 0, 0, &send_op_id);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_send_unexpected() failed");
goto done;
}
hg_request_wait(recv_request, NA_MAX_IDLE_TIME, NULL);
hg_request_reset(recv_request);
}
NA_Test_barrier(&na_test_lat_info->na_test_info);
/* Actual benchmark */
for (avg_iter = 0; avg_iter < loop; avg_iter++) {
hg_time_t t1, t2;
hg_time_get_current(&t1);
/* Post recv */
ret = NA_Msg_recv_expected(na_test_lat_info->na_class,
na_test_lat_info->context, na_test_recv_expected_cb, recv_request,
recv_buf, buf_size, recv_buf_data, na_test_lat_info->target_addr, 0,
1, &recv_op_id);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_recv_expected() failed");
goto done;
}
/* Post send */
ret = NA_Msg_send_unexpected(na_test_lat_info->na_class,
na_test_lat_info->context, NULL, NULL, send_buf, buf_size,
send_buf_data, na_test_lat_info->target_addr, 0, 1,
&send_op_id);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_send_unexpected() failed");
goto done;
}
hg_request_wait(recv_request, NA_MAX_IDLE_TIME, NULL);
NA_Test_barrier(&na_test_lat_info->na_test_info);
hg_time_get_current(&t2);
time_read += hg_time_to_double(hg_time_subtract(t2, t1));
hg_request_reset(recv_request);
#ifdef MERCURY_TESTING_HAS_VERIFY_DATA
/* Check recv buf */
const char *recv_buf_ptr = (const char*) recv_buf;
for (i = NA_Msg_get_unexpected_header_size(na_test_lat_info->na_class);
i < buf_size; i++) {
if (recv_buf_ptr[i] != (char) i) {
fprintf(stderr, "Error detected in bulk transfer, buf[%d] = %d, "
"was expecting %d!\n", (int) i, (char) recv_buf_ptr[i],
(char) i);
break;
}
}
#endif
/* At this point we have received everything so work out the bandwidth */
#ifdef MERCURY_TESTING_PRINT_PARTIAL
read_lat = time_read * 1.0e6
/ (double) ((avg_iter + 1) * 2 *
(unsigned int) na_test_lat_info->na_test_info.mpi_comm_size);
if (na_test_lat_info->na_test_info.mpi_comm_rank == 0)
fprintf(stdout, "%-*d%*.*f\r", 10, (int) size, NWIDTH,
NDIGITS, read_lat);
#endif
}
#ifndef MERCURY_TESTING_PRINT_PARTIAL
read_lat = time_read * 1.0e6
/ (double) (loop * 2 *
(unsigned int) na_test_lat_info->na_test_info.mpi_comm_size);
if (na_test_lat_info->na_test_info.mpi_comm_rank == 0)
fprintf(stdout, "%-*d%*.*f", 10, (int) size, NWIDTH, NDIGITS,
read_lat);
#endif
if (na_test_lat_info->na_test_info.mpi_comm_rank == 0)
fprintf(stdout, "\n");
done:
/* Clean up resources */
hg_request_destroy(recv_request);
NA_Op_destroy(na_test_lat_info->na_class, send_op_id);
NA_Op_destroy(na_test_lat_info->na_class, recv_op_id);
NA_Msg_buf_free(na_test_lat_info->na_class, send_buf, send_buf_data);
NA_Msg_buf_free(na_test_lat_info->na_class, recv_buf, recv_buf_data);
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(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;
}
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;
}
