primitiveValidateCompressedBuffer(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
char* ptr;
snappy_status status;
if (!((interpreterProxy->methodArgumentCount()) == 1)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(0);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
compressedLength = interpreterProxy->byteSizeOf(compressedObj);
status = snappy_validate_compressed_buffer(compressed, compressedLength);
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(status);
}
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;
}
primitiveRawValidateCompressedBuffer(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
sqInt num;
sqInt num1;
size_t offset;
char* ptr;
snappy_status status;
if (!((interpreterProxy->methodArgumentCount()) == 3)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(2);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
/* begin stackPositiveIntegerValue: */
num = interpreterProxy->stackValue(1);
if ((interpreterProxy->isIntegerValue(num))
&& (num < 0)) {
offset = ((sqInt) null);
goto l2;
}
offset = ((sqInt) (interpreterProxy->positive32BitValueOf(num)));
l2: /* end stackPositiveIntegerValue: */;
/* begin stackPositiveIntegerValue: */
num1 = interpreterProxy->stackValue(0);
if ((interpreterProxy->isIntegerValue(num1))
&& (num1 < 0)) {
compressedLength = ((sqInt) null);
goto l3;
}
compressedLength = ((sqInt) (interpreterProxy->positive32BitValueOf(num1)));
l3: /* end stackPositiveIntegerValue: */;
status = snappy_validate_compressed_buffer(compressed + offset, compressedLength);
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(status);
}
/* This routine gets executed after a call to HG_Trigger and
* the RPC has completed */
static hg_return_t
snappy_compress_rpc_cb(const struct hg_cb_info *callback_info)
{
struct snappy_compress_rpc_args *snappy_compress_rpc_args =
(struct snappy_compress_rpc_args *) callback_info->arg;
hg_handle_t handle = callback_info->info.forward.handle;
int *input;
size_t source_length;
void *compressed;
size_t compressed_length;
int *uncompressed;
size_t uncompressed_length;
snappy_compress_out_t snappy_compress_output;
snappy_status ret;
/* Get output */
printf("Received output from target\n");
HG_Get_output(handle, &snappy_compress_output);
/* Get Snappy output parameters */
ret = snappy_compress_output.ret;
compressed_length = snappy_compress_output.compressed_length;
compressed = snappy_compress_rpc_args->compressed;
input = snappy_compress_rpc_args->input;
source_length = snappy_compress_rpc_args->input_length;
/* Check ret */
if (ret != SNAPPY_OK) {
fprintf(stderr, "Error: snappy_compressed failed with ret %d\n", ret);
}
/* The output data is now in the bulk buffer */
printf("Compressed buffer length is: %zu\n", compressed_length);
print_buf(5, (int *)compressed);
if (snappy_validate_compressed_buffer(compressed, compressed_length) == SNAPPY_OK) {
printf("Compressed buffer validated: compressed successfully\n");
}
uncompressed_length = source_length * sizeof(int);
uncompressed = (int *) malloc(uncompressed_length);
/* Uncompress data and check uncompressed_length */
printf("Uncompressing buffer...\n");
snappy_uncompress(compressed, compressed_length,
(char *) uncompressed, &uncompressed_length);
printf("Uncompressed buffer length is: %zu\n", uncompressed_length);
print_buf(20, uncompressed);
/* Free output and handles */
HG_Free_output(handle, &snappy_compress_output);
HG_Bulk_free(snappy_compress_rpc_args->input_bulk_handle);
HG_Bulk_free(snappy_compress_rpc_args->compressed_bulk_handle);
/* Free data */
free(uncompressed);
free(compressed);
free(input);
free(snappy_compress_rpc_args);
/* We're done */
snappy_compress_done_g = HG_TRUE;
return HG_SUCCESS;
}
/*
* ./test -u uri -r request_size -a total_size
* uri: /tmp/testenv/testfs
* request_size: 4096bytes
* total_size: 409600bytes
*/
int main(int argc, char *argv[]){
if (log4c_init()) {
g_message("log4c_init error!");
}
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- hlfs test -");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
g_option_context_free(context);
g_print("TEST: uri is %s, request size is %d, total size is %d\n", uri, request_size, total_size);
char *content = (char*)g_malloc0(request_size);
HLFS_CTRL * ctrl = init_hlfs(uri);
g_assert(ctrl != NULL);
uint64_t ret = 0;
ret = hlfs_open(ctrl,1);
g_assert(ret == 0);
g_print("TEST hlfs open over \n");
g_print("test hlfs write\n");
sleep(2);
int offset = 0;
while(offset < total_size){
ret = hlfs_write(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("TEST hlfs write over \n");
g_print("test hlfs read\n");
sleep(2);
offset = 0;
while(offset < total_size){
ret = hlfs_read(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("again ------------------------\n");
offset = 0;
/******************************************************************************************************************************************/
int fdd;
int len;
int rett;
int i;
//char read_buf[409600];
char *contentt = (char*)g_malloc0(40960);
if((fdd = open("test.c", O_RDONLY )) == -1){
my_err("open", __LINE__);
} else {
g_print("Open file success\n");
}
//if(write(fd, write_buf, strlen(write_buf)) != strlen(write_buf)){
// my_err("write", __LINE__);
//}
if(lseek(fdd, 0, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
if((len = lseek(fdd, 0, SEEK_CUR)) == -1){
my_err("lseek", __LINE__);
}
if((lseek(fdd, 0, SEEK_SET)) == -1){
my_err("lseek", __LINE__);
}
printf("len: %d\n", len);
if((rett = read(fdd, contentt, len)) < 0){
my_err("lseek",__LINE__);
}
strcpy(content, contentt);
//for(i = 0; i< len; i ++){
g_print("%s ", contentt);
//}
g_print("\n");
g_print("/************************************************/");
if(lseek(fdd, 10, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
//close (fdd);
/****************************************************************************************************/
//FILE* srcFile = NULL;
int srcLength = lseek(fdd, 0, SEEK_CUR);
int SNAPPY_OK = 0;
char* pSrcBuffer = (char*)g_malloc0(srcLength);
read(fdd, pSrcBuffer, srcLength);
size_t cbOfCompressed = 32+ srcLength + srcLength/6;
char* pCompressedBuffer = (char*)g_malloc0(cbOfCompressed);
if (snappy_compress(pSrcBuffer, srcLength, pCompressedBuffer, &cbOfCompressed) == SNAPPY_OK)
{
free(pSrcBuffer);
pSrcBuffer = NULL;
if (snappy_validate_compressed_buffer(pCompressedBuffer, cbOfCompressed) == SNAPPY_OK)
{
size_t cbDecompress = 0;
snappy_uncompressed_length(pCompressedBuffer, cbOfCompressed, &cbDecompress);
assert(cbDecompress == srcLength);
char* pDecompressedBuffer = (char*)g_malloc0(cbDecompress);
snappy_uncompress(pCompressedBuffer, cbOfCompressed, pDecompressedBuffer, (size_t*)&cbDecompress);
int file;
file = open("test1.txt", O_CREAT | O_RDWR );
//_wfopen_s(&file, _T("123.pdf"), _T("ab"));
write(file, pDecompressedBuffer, cbDecompress);
close(file);
free(pDecompressedBuffer);
pDecompressedBuffer = NULL;
}
}
close (fdd);
/******************************************************************************************************************************************/
// while(offset < total_size){
// ret = hlfs_write(ctrl,content,request_size,offset);
// g_assert(ret==request_size);
// offset +=request_size;
// printf("offset:%d\n",offset);
// }
// g_print("TEST hlfs write over \n");
// g_print("test hlfs read\n");
// sleep(2);
// offset = 0;
while(offset < len+1){
ret = hlfs_read(ctrl,content,len,offset);
g_assert(ret==len);
offset +=len;
printf("offset:%d\n",offset);
}
g_free(content);
g_free(contentt);
ret = hlfs_close(ctrl);
deinit_hlfs(ctrl);
g_print("TEST hlfs test over \n");
return 0;
}