static hg_return_t
hg_test_rpc_forward_cb(const struct hg_cb_info *callback_info)
{
hg_handle_t handle = callback_info->info.forward.handle;
hg_request_t *request = (hg_request_t *) callback_info->arg;
overflow_out_t out_struct;
hg_return_t ret = HG_SUCCESS;
hg_string_t string;
size_t string_len;
if (callback_info->ret != HG_SUCCESS) {
HG_LOG_WARNING("Return from callback info is not HG_SUCCESS");
goto done;
}
/* Get output */
ret = HG_Get_output(handle, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not get output\n");
goto done;
}
/* Get output parameters */
string = out_struct.string;
string_len = out_struct.string_len;
printf("Returned string (length %zu): %s\n", string_len, string);
/* Free request */
ret = HG_Free_output(handle, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free output\n");
goto done;
}
done:
hg_request_complete(request);
return ret;
}
/*---------------------------------------------------------------------------*/
hg_return_t
HG_Bulk_deserialize(hg_class_t *hg_class, hg_bulk_t *handle, const void *buf,
hg_size_t buf_size)
{
struct hg_bulk *hg_bulk = NULL;
const char *buf_ptr = (const char *) buf;
ssize_t buf_size_left = (ssize_t) buf_size;
hg_return_t ret = HG_SUCCESS;
hg_uint32_t i;
if (!handle) {
HG_LOG_ERROR("NULL pointer to memory handle passed");
ret = HG_INVALID_PARAM;
goto done;
}
hg_bulk = (struct hg_bulk *) malloc(sizeof(struct hg_bulk));
if (!hg_bulk) {
HG_LOG_ERROR("Could not allocate handle");
ret = HG_NOMEM_ERROR;
goto done;
}
memset(hg_bulk, 0, sizeof(struct hg_bulk));
hg_bulk->hg_class = hg_class;
hg_atomic_set32(&hg_bulk->ref_count, 1);
/* Get the permission flags */
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->flags, sizeof(hg_bulk->flags));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode permission flags");
goto done;
}
/* Get the total size of the segments */
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->total_size, sizeof(hg_bulk->total_size));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode total size");
goto done;
}
/* Get the number of segments */
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->segment_count, sizeof(hg_bulk->segment_count));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode segment count");
goto done;
}
/* Get the array of segments */
hg_bulk->segments = (struct hg_bulk_segment *) malloc(
hg_bulk->segment_count * sizeof(struct hg_bulk_segment));
if (!hg_bulk->segments) {
HG_LOG_ERROR("Could not allocate segment array");
ret = HG_NOMEM_ERROR;
goto done;
}
for (i = 0; i < hg_bulk->segment_count; i++) {
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->segments[i], sizeof(hg_bulk->segments[i]));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode segment");
goto done;
}
}
/* Get the number of NA memory handles */
ret = hg_bulk_deserialize_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 decode NA memory handle count");
goto done;
}
/* Get the NA memory handles */
hg_bulk->na_mem_handles = (na_mem_handle_t *) malloc(
hg_bulk->na_mem_handle_count * sizeof(na_mem_handle_t));
if (!hg_bulk->na_mem_handles) {
HG_LOG_ERROR("Could not allocate NA memory handle array");
ret = HG_NOMEM_ERROR;
goto done;
}
for (i = 0; i < hg_bulk->na_mem_handle_count; i++) {
na_size_t serialize_size;
na_return_t na_ret;
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&serialize_size, sizeof(serialize_size));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode serialize size");
goto done;
}
if (serialize_size) {
na_ret = NA_Mem_handle_deserialize(
HG_Core_class_get_na(hg_bulk->hg_class),
&hg_bulk->na_mem_handles[i], buf_ptr,
(na_size_t) buf_size_left);
if (na_ret != NA_SUCCESS) {
HG_LOG_ERROR("Could not deserialize memory handle");
ret = HG_NA_ERROR;
goto done;
}
buf_ptr += serialize_size;
buf_size_left -= (ssize_t) serialize_size;
} else {
hg_bulk->na_mem_handles[i] = NA_MEM_HANDLE_NULL;
}
}
/* Get whether data is serialized or not */
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
&hg_bulk->eager_mode, sizeof(hg_bulk->eager_mode));
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode eager_mode bool");
goto done;
}
/* Get the serialized data */
if (hg_bulk->eager_mode) {
hg_bulk->segment_alloc = HG_TRUE;
for (i = 0; i < hg_bulk->segment_count; i++) {
if (!hg_bulk->segments[i].size)
continue;
/* Use calloc to avoid uninitialized memory used for transfer */
hg_bulk->segments[i].address = (hg_ptr_t) calloc(
hg_bulk->segments[i].size, sizeof(char));
if (!hg_bulk->segments[i].address) {
HG_LOG_ERROR("Could not allocate segment");
ret = HG_NOMEM_ERROR;
goto done;
}
ret = hg_bulk_deserialize_memcpy(&buf_ptr, &buf_size_left,
(void *) hg_bulk->segments[i].address,
hg_bulk->segments[i].size);
if (ret != HG_SUCCESS) {
HG_LOG_ERROR("Could not decode segment data");
goto done;
}
}
}
if (buf_size_left)
HG_LOG_WARNING("Buf size left greater than 0, %zd", buf_size_left);
*handle = (hg_bulk_t) hg_bulk;
done:
if (ret != HG_SUCCESS) {
hg_bulk_free(hg_bulk);
}
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;
}
