/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_bulk_transfer_cb(const struct hg_cb_info *hg_cb_info)
{
struct hg_test_bulk_args *bulk_args = (struct hg_test_bulk_args *)
hg_cb_info->arg;
hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle;
hg_return_t ret = HG_SUCCESS;
bulk_write_out_t out_struct;
void *buf;
size_t write_ret;
if (hg_cb_info->ret == HG_CANCELED) {
printf("HG_Bulk_transfer() was successfully canceled\n");
/* Fill output structure */
out_struct.ret = 0;
} else if (hg_cb_info->ret != HG_SUCCESS) {
HG_LOG_ERROR("Error in callback");
ret = HG_PROTOCOL_ERROR;
goto done;
}
if (hg_cb_info->ret == HG_SUCCESS) {
/* Call bulk_write */
HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes,
HG_BULK_READWRITE, 1, &buf, NULL, NULL);
write_ret = bulk_write(bulk_args->fildes, buf, 0,
bulk_args->nbytes, 1);
/* Fill output structure */
out_struct.ret = write_ret;
}
/* Free block handle */
ret = HG_Bulk_free(local_bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free HG bulk handle\n");
return ret;
}
/* Send response back */
ret = HG_Respond(bulk_args->handle, NULL, NULL, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not respond\n");
return ret;
}
done:
HG_Destroy(bulk_args->handle);
free(bulk_args);
return ret;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_posix_write_transfer_cb(const struct hg_cb_info *hg_cb_info)
{
struct hg_test_bulk_args *bulk_args = (struct hg_test_bulk_args *)
hg_cb_info->arg;
hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle;
hg_return_t ret = HG_SUCCESS;
write_out_t out_struct;
void *buf;
ssize_t write_ret;
/* for debug */
int i;
const int *buf_ptr;
/* Call bulk_write */
HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE,
1, &buf, NULL, NULL);
/* 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 in bulk transfer, buf[%d] = %d, was expecting %d!\n", i, buf_ptr[i], i);
break;
}
}
printf("Calling write with fd: %d\n", bulk_args->fildes);
write_ret = write(bulk_args->fildes, buf, bulk_args->nbytes);
/* Fill output structure */
out_struct.ret = write_ret;
/* Free block handle */
ret = HG_Bulk_free(local_bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free HG bulk handle\n");
return ret;
}
/* Send response back */
ret = HG_Respond(bulk_args->handle, NULL, NULL, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not respond\n");
return ret;
}
HG_Destroy(bulk_args->handle);
free(bulk_args);
return ret;
}
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;
}
/*---------------------------------------------------------------------------*/
static hg_return_t
hg_test_bulk_seg_transfer_cb(const struct hg_cb_info *hg_cb_info)
{
struct hg_test_bulk_args *bulk_args = (struct hg_test_bulk_args *)
hg_cb_info->arg;
hg_bulk_t local_bulk_handle = hg_cb_info->info.bulk.local_handle;
hg_return_t ret = HG_SUCCESS;
bulk_write_out_t out_struct;
void *buf;
size_t write_ret;
if (hg_atomic_incr32(&bulk_args->completed_transfers) != 2)
goto done;
/* Call bulk_write */
HG_Bulk_access(local_bulk_handle, 0, bulk_args->nbytes, HG_BULK_READWRITE,
1, &buf, NULL, NULL);
write_ret = bulk_write(bulk_args->fildes, buf, 0,
bulk_args->nbytes, 1);
/* Fill output structure */
out_struct.ret = write_ret;
/* Free block handle */
ret = HG_Bulk_free(local_bulk_handle);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not free HG bulk handle\n");
return ret;
}
/* Send response back */
ret = HG_Respond(bulk_args->handle, NULL, NULL, &out_struct);
if (ret != HG_SUCCESS) {
fprintf(stderr, "Could not respond\n");
return ret;
}
HG_Destroy(bulk_args->handle);
free(bulk_args);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
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;
}
