/*---------------------------------------------------------------------------*/ 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; }