static int
test_bulk(struct na_test_params *params)
{
na_tag_t bulk_tag = NA_TEST_BULK_TAG, ack_tag = NA_TEST_BULK_ACK_TAG;
na_return_t na_ret;
/* Register memory */
printf("Registering local memory...\n");
na_ret = NA_Mem_handle_create(params->network_class, params->bulk_buf,
sizeof(int) * params->bulk_size, NA_MEM_READWRITE,
¶ms->local_mem_handle);
if (na_ret != NA_SUCCESS) {
fprintf(stderr, "Could not create bulk handle\n");
return EXIT_FAILURE;
}
na_ret = NA_Mem_register(params->network_class, params->local_mem_handle);
if (na_ret != NA_SUCCESS) {
fprintf(stderr, "Could not create bulk handle\n");
return EXIT_FAILURE;
}
/* Serialize mem handle */
printf("Serializing bulk memory handle...\n");
na_ret = NA_Mem_handle_serialize(params->network_class, params->send_buf,
params->send_buf_len, params->local_mem_handle);
if (na_ret != NA_SUCCESS) {
fprintf(stderr, "Could not serialize memory handle\n");
return EXIT_FAILURE;
}
/* Recv completion ack */
printf("Preposting recv of transfer ack...\n");
na_ret = NA_Msg_recv_expected(params->network_class, params->context,
&ack_expected_recv_cb, params, params->recv_buf,
params->recv_buf_len, params->server_addr, ack_tag,
NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
fprintf(stderr, "Could not start receive of acknowledgment\n");
return EXIT_FAILURE;
}
/* Send mem handle */
printf("Sending local memory handle...\n");
na_ret = NA_Msg_send_expected(params->network_class, params->context,
NULL, NULL, params->send_buf, params->send_buf_len,
params->server_addr, bulk_tag, NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
fprintf(stderr, "Could not start send of memory handle\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static int
test_bulk(struct na_test_params *params)
{
na_return_t na_ret;
int ret = EXIT_SUCCESS;
/* Register memory */
printf("Registering local memory...\n");
na_ret = NA_Mem_handle_create(params->na_class, params->bulk_buf,
sizeof(int) * params->bulk_size, NA_MEM_READWRITE,
¶ms->local_mem_handle);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not create NA memory handle");
ret = EXIT_FAILURE;
goto done;
}
na_ret = NA_Mem_register(params->na_class, params->local_mem_handle);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not register NA memory handle");
ret = EXIT_FAILURE;
goto done;
}
/* Serialize mem handle */
printf("Serializing bulk memory handle...\n");
na_ret = NA_Mem_handle_serialize(params->na_class, params->send_buf,
params->send_buf_len, params->local_mem_handle);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not serialize memory handle");
ret = EXIT_FAILURE;
goto done;
}
/* Recv completion ack */
printf("Preposting recv of transfer ack...\n");
na_ret = NA_Msg_recv_expected(params->na_class, params->context,
&ack_expected_recv_cb, params, params->recv_buf, params->recv_buf_len,
params->recv_buf_plugin_data, params->server_addr, 0,
NA_TEST_BULK_ACK_TAG, NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not start receive of ack");
ret = EXIT_FAILURE;
goto done;
}
/* Send mem handle */
printf("Sending local memory handle...\n");
na_ret = NA_Msg_send_expected(params->na_class, params->context, NULL,
NULL, params->send_buf, params->send_buf_len,
params->send_buf_plugin_data, params->server_addr, 0,
NA_TEST_BULK_TAG, NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not start send of memory handle");
ret = EXIT_FAILURE;
goto done;
}
done:
return ret;
}
/*---------------------------------------------------------------------------*/
hg_return_t
HG_Bulk_serialize(void *buf, hg_size_t buf_size, hg_bool_t request_eager,
hg_bulk_t handle)
{
struct hg_bulk *hg_bulk = (struct hg_bulk *) handle;
char *buf_ptr = (char *) buf;
ssize_t buf_size_left = (ssize_t) buf_size;
hg_return_t ret = HG_SUCCESS;
hg_bool_t eager_mode;
na_class_t *na_class;
hg_uint32_t i;
if (!hg_bulk) {
HG_LOG_ERROR("NULL memory handle passed");
ret = HG_INVALID_PARAM;
goto done;
}
/* Get NA class */
na_class = HG_Core_class_get_na(hg_bulk->hg_class);
/* Publish handle at this point if not published yet */
if (!hg_bulk->segment_published) {
for (i = 0; i < hg_bulk->na_mem_handle_count; i++) {
na_return_t na_ret;
if (!hg_bulk->na_mem_handles[i])
continue;
na_ret = NA_Mem_publish(na_class, hg_bulk->na_mem_handles[i]);
if (na_ret != NA_SUCCESS) {
HG_LOG_ERROR("NA_Mem_publish failed");
ret = HG_NA_ERROR;
goto done;
}
}
hg_bulk->segment_published = HG_TRUE;
}
/* Add the permission flags */
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->flags, sizeof(hg_bulk->flags));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode permission flags");
goto done;
}
/* Add the total size of the segments */
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->total_size, sizeof(hg_bulk->total_size));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode total size");
goto done;
}
/* Add the number of segments */
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->segment_count, sizeof(hg_bulk->segment_count));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode segment count");
goto done;
}
/* Add the array of segments */
for (i = 0; i < hg_bulk->segment_count; i++) {
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->segments[i], sizeof(hg_bulk->segments[i]));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode segment");
goto done;
}
}
/* Add the number of NA memory handles */
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->na_mem_handle_count, sizeof(hg_bulk->na_mem_handle_count));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode NA memory handle count");
goto done;
}
/* Add the NA memory handles */
for (i = 0; i < hg_bulk->na_mem_handle_count; i++) {
na_size_t serialize_size = 0;
na_return_t na_ret;
if (hg_bulk->na_mem_handles[i]) {
serialize_size = NA_Mem_handle_get_serialize_size(
na_class, hg_bulk->na_mem_handles[i]);
}
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left, &serialize_size,
sizeof(serialize_size));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode serialize size");
goto done;
}
if (hg_bulk->na_mem_handles[i]) {
na_ret = NA_Mem_handle_serialize(na_class, buf_ptr,
(na_size_t) buf_size_left, hg_bulk->na_mem_handles[i]);
if (na_ret != NA_SUCCESS) {
HG_LOG_ERROR("Could not serialize memory handle");
ret = HG_NA_ERROR;
goto done;
}
buf_ptr += serialize_size;
buf_size_left -= (ssize_t) serialize_size;
}
}
/* Eager mode is used only when data is set to HG_BULK_READ_ONLY */
eager_mode = (request_eager && (hg_bulk->flags == HG_BULK_READ_ONLY));
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left, &eager_mode,
sizeof(eager_mode));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode eager_mode bool");
goto done;
}
/* Add the serialized data */
if (eager_mode) {
for (i = 0; i < hg_bulk->segment_count; i++) {
if (!hg_bulk->segments[i].size)
continue;
ret = hg_bulk_serialize_memcpy(&buf_ptr, &buf_size_left,
(const void *) hg_bulk->segments[i].address,
hg_bulk->segments[i].size);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not encode segment data");
goto done;
}
}
}
if (buf_size_left)
HG_LOG_WARNING("Buf size left greater than 0, %zd", buf_size_left);
done:
return ret;
}
