int main(int ac, char **av)
{
int failed = 0, verbose = 0;
struct snappy_env env;
snappy_init_env(&env);
if (av[1] && !strcmp(av[1], "-v")) {
verbose++;
av++;
}
while (*++av) {
size_t size;
char *map = mapfile(*av, O_RDONLY, &size);
if (!map) {
if (size > 0) {
perror(*av);
failed = 1;
}
continue;
}
size_t outlen;
int err;
char *out = xmalloc(snappy_max_compressed_length(size));
char *buf2 = xmalloc(size);
err = snappy_compress(&env, map, size, out, &outlen);
if (err) {
failed = 1;
printf("compression of %s failed: %d\n", *av, err);
goto next;
}
err = snappy_uncompress(out, outlen, buf2);
if (err) {
failed = 1;
printf("uncompression of %s failed: %d\n", *av, err);
goto next;
}
if (memcmp(buf2, map, size)) {
int o = compare(buf2, map, size);
if (o >= 0) {
failed = 1;
printf("final comparision of %s failed at %d of %lu\n",
*av, o, (unsigned long)size);
}
} else {
if (verbose)
printf("%s OK!\n", *av);
}
next:
unmap_file(map, size);
free(out);
free(buf2);
}
return failed;
}
static ssize_t compress_iov_to_buffer(struct trace_record *target, const struct iovec *iov, int iovcnt)
{
if (NULL == iov) {
errno = EFAULT;
return -1;
}
if (iovcnt < 1) {
return 0;
}
char *src_buf = iov[0].iov_base;
size_t input_len = iov[0].iov_len;
size_t compressed_length = 0;
struct snappy_env env;
int rc = snappy_init_env(&env);
if (rc < 0) {
goto finish;
}
if (iovcnt > 1) {
/* TODO: Snappy should be able to accept an input IOV directly. Since this support is currently broken we use a workaround instead. */
input_len = total_iovec_len(iov, iovcnt);
src_buf = malloc(input_len);
if ((NULL == src_buf) || (copy_iov_to_buffer(src_buf, iov, iovcnt) != (ssize_t) input_len)) {
rc = -errno;
goto finish;
}
}
if (input_len > 0) {
/* Don't bother compressing trailing padding chars. Those will be re-inserted by the reader. */
input_len -= trace_r_count_chr_occurrences(src_buf + 1, input_len - 1, TRACE_UNUSED_SPACE_FILL_VALUE);
rc = snappy_compress(&env, src_buf, input_len, (char *)target, &compressed_length);
}
finish:
snappy_free_env(&env);
if (src_buf != iov[0].iov_base) {
free(src_buf);
}
if (0 != rc) {
errno = -rc;
ERR("Buffer compression failed with err", errno, strerror(errno));
return (ssize_t) -1;
}
TRACE_ASSERT(((ssize_t) compressed_length > 0) || (0 == input_len));
return (ssize_t) compressed_length;
}
int ness_compress(ness_compress_method_t m,
const char *src,
uint32_t src_size,
char *dst,
uint32_t *dst_size)
{
int ret = NESS_OK;
switch (m) {
case NESS_NO_COMPRESS:
memcpy(dst + 1, src, src_size);
*dst_size = src_size + 1;
dst[0] = NESS_NO_COMPRESS;
break;
case NESS_SNAPPY_METHOD:
if (src_size == 0) {
*dst_size = 1;
} else {
size_t out_size;
int status;
struct snappy_env env;
snappy_init_env(&env);
status = snappy_compress(&env, src, src_size, dst + 1, &out_size);
snappy_free_env(&env);
if (status != 0) {
__ERROR("snappy compress error %d, src_size %d, dst_size %d",
status,
src_size,
dst_size);
ret = 0;
}
*dst_size = out_size + 1;
}
dst[0] = NESS_SNAPPY_METHOD;
break;
default:
ret = 0;
__ERROR("%s", "no compress method support!");
break;
}
return ret;
}
int ness_decompress(const char *src,
uint32_t src_size,
char *dst,
uint32_t dst_size)
{
int ret = NESS_OK;
/* compressed data is NULL */
if (src_size == 1)
return NESS_ERR;
switch (src[0] & 0xF) {
case NESS_NO_COMPRESS:
memcpy(dst, src + 1, src_size - 1);
break;
case NESS_SNAPPY_METHOD: {
int status;
struct snappy_env env;
snappy_init_env(&env);
status = snappy_uncompress(src + 1, src_size - 1, dst);
snappy_free_env(&env);
if (status != 0) {
__ERROR("snappy uncompress error %d", status);
ret = 0;
goto ERR;
}
(void)dst_size;
}
break;
default:
ret = 0;
__ERROR("%s", "no decompress method support!");
break;
}
ERR:
return ret;
}
SnappyImplNative::SnappyImplNative() {
__android_log_print(ANDROID_LOG_DEBUG, "sn-init", "Native build %s %s", __DATE__, __TIME__);
snappy_init_env(&this->env);
}
int main(int ac, char **av)
{
int opt;
int to_stdout = 0;
while ((opt = getopt(ac, av, "dcs")) != -1) {
switch (opt) {
case 'd':
mode = uncompress;
break;
case 'c':
mode = compress;
break;
case 's':
to_stdout = 1;
break;
default:
usage();
}
}
char *map;
size_t size;
if (!av[optind])
usage();
if (mode == undef && match_suffix(av[optind], ".snp"))
mode = uncompress;
else
mode = compress;
map = mapfile(av[optind], O_RDONLY, &size);
if (!map) {
fprintf(stderr, "Cannot open %s: %s\n", av[1], strerror(errno));
exit(1);
}
int err;
char *out;
size_t outlen;
if (mode == uncompress) {
if (!snappy_uncompressed_length(map, size, &outlen)) {
fprintf(stderr, "Cannot read length in %s\n",
av[optind]);
exit(1);
}
} else {
outlen = snappy_max_compressed_length(size);
}
out = xmalloc(outlen);
if (mode == compress) {
struct snappy_env env;
snappy_init_env(&env);
err = snappy_compress(&env, map, size, out, &outlen);
} else
err = snappy_uncompress(map, size, out);
if (err) {
fprintf(stderr, "Cannot process %s: %s\n", av[optind],
strerror(-err));
exit(1);
}
char *file;
int fd;
if (to_stdout) {
if(av[optind + 1])
usage();
fd = 1;
file = "<stdout>";
} else {
if (av[optind + 1] && av[optind + 2])
usage();
fd = open_output(av[optind], av[optind + 1], &file);
}
err = 0;
if (write(fd, out, outlen) != outlen) {
fprintf(stderr, "Cannot write to %s: %s\n",
file,
strerror(errno));
err = 1;
}
return err;
}
/* Only needed for compression actually */
static int snappy_init(struct crypto_tfm *tfm)
{
struct snappy_ctx *ctx = crypto_tfm_ctx(tfm);
return snappy_init_env(&ctx->env);
}
int main(void) {
// read data (this is outside time measurements, since the data comes from anywhere and is assumed in (virtual) memory)
Mapipbtest__QueryResult query_result;
create_result_from_csv(&query_result, DATA_FILE, DATA_COLS, DATA_ROWS,
DATA_TYPES, 1);
struct snappy_env se;
snappy_init_env(&se);
// react on queries
void *context = zmq_ctx_new();
void *socket = zmq_socket(context, ZMQ_REP);
int rc;
rc = zmq_bind(socket, SERVER_SOCKET);
if (rc != 0) {
fprintf(stderr, "Failed to bind to socket %s\n", SERVER_SOCKET);
perror("Socket error ");
return -1;
}
long s_time, c_time, req_time;
struct timeval start, req_start;
while (1) {
gettimeofday(&req_start, NULL );
// receive request
message query_msg;
message_receive(socket, &query_msg);
size_t query_msg_size = message_size(&query_msg);
void * query_msg_data = message_data(&query_msg);
if (COMPRESS) {
query_msg_data = message_uncompress(query_msg_data,
&query_msg_size);
}
Mapipbtest__ExecuteQuery * request = mapipbtest__execute_query__unpack(
NULL, query_msg_size, query_msg_data);
message_close(&query_msg);
if (COMPRESS) {
free(query_msg_data);
}
//printf("%s\n", request->sqlquery);
//mapipbtest__execute_query__free_unpacked(request, NULL );
// send response
gettimeofday(&start, NULL );
size_t query_response_msg_size =
mapipbtest__query_result__get_packed_size(&query_result);
void * query_response_msg_data = malloc(query_response_msg_size);
mapipbtest__query_result__pack(&query_result, query_response_msg_data);
s_time = end_timer_ms(&start);
gettimeofday(&start, NULL );
char * free_ptr;
if (COMPRESS) {
free_ptr = query_response_msg_data;
query_response_msg_data = message_compress(&se,
query_response_msg_data, &query_response_msg_size);
}
c_time = end_timer_ms(&start);
message_send(socket, query_response_msg_data, query_response_msg_size);
//free(query_response_msg_data);
req_time = end_timer_ms(&req_start);
//free(query_response_msg_data);
if (COMPRESS) {
free(free_ptr);
}
}
zmq_close(socket);
zmq_ctx_destroy(context);
return 0;
}
