static void
do_pack(const void *in, size_t in_len, size_t buf_len,
size_t offset, size_t fp_len, Byte options) {
size_t buflen = bmz_pack_buflen(in_len), out_len = buflen;
size_t worklen = bmz_pack_worklen(in_len, fp_len);
int ret, bm_only = (options & BMZ_O_BM_ONLY) || s_bm_dump;
Byte *out, *work_mem;
if (bm_only) {
out_len = in_len + 1;
if (buf_len > in_len + worklen) {
out = (Byte *)in + in_len;
work_mem = out + out_len;
}
else {
out = malloc(worklen); /* bmz_pack_worklen includes out_len for bm */
if (!out)
DIE("error allocating %lu bytes memory", (Lu)worklen);
work_mem = out + out_len;
}
/* calling internal API need to align work memory */
work_mem = BMZ_ALIGN(work_mem, 8);
}
else if (buf_len > buflen + worklen) {
work_mem = (Byte *)in + buflen;
out = (Byte *)in; /* inplace */
}
else {
out = malloc(buflen + worklen);
if (!out)
DIE("error allocating %lu bytes memory", (Lu)buflen + worklen);
work_mem = out + buflen;
}
if (bm_only) {
ret = bmz_bm_pack_mask(in, in_len, out, &out_len, offset, fp_len,
work_mem, 257);
if (ret != BMZ_E_OK)
DIE("error encoding bm output (error %d)", ret);
if (s_bm_dump) {
if ((ret = bmz_bm_dump(out, out_len)) != BMZ_E_OK)
WARN("error dumping bm encoding (ret=%d)", ret);
return;
}
}
else if ((ret = bmz_pack(in, in_len, out, &out_len, offset, fp_len,
(s_bm_hash << 24), work_mem))
!= BMZ_E_OK) {
DIE("error compressing input (error %d)", ret);
}
write_bmz_header(1, in_len, bmz_checksum(out, out_len), options);
write(1, out, out_len);
}
static void
test_from_string(const char *data, size_t len) {
char *buf, *mem;
size_t n = s_times;
int opt = s_options;
size_t out_len, out_len0, len2 = len, work_len;
if (s_show_hash) {
show_hash(data, len);
return;
}
out_len0 = out_len = bmz_pack_buflen(len);
buf = malloc(len + out_len);
work_len = bmz_bm_pack_worklen(len, s_fp_len);
mem = malloc(work_len);
LOG(1, "input length: %lu, out_len %lu, work_len: %lu\n",
(Lu)len, (Lu)out_len, (Lu)work_len);
/* memcpy/memmove for comparison */
if (opt & O_MEMCPY) {
BENCH("memcpy", memcpy(buf, data, len), len, n);
}
if (opt & O_CHECK_HASH) {
if (opt & O_HASH_MOD)
HT_CHECK(bmz_check_hash_mod(data, len, s_fp_len, s_b1, s_m) == BMZ_E_OK);
if (opt & O_HASH_MOD16X2)
HT_CHECK(bmz_check_hash_mod16x2(data, len, s_fp_len,
s_b1, s_b2, s_m1, s_m2) == BMZ_E_OK);
if (opt & O_HASH_MASK16X2)
HT_CHECK(bmz_check_hash_mask16x2(data, len, s_fp_len, s_b1, s_b2)
== BMZ_E_OK);
if (opt & O_HASH_MASK)
HT_CHECK(bmz_check_hash_mask(data, len, s_fp_len, s_b1) == BMZ_E_OK);
if (opt & O_HASH_MASK32X2)
HT_CHECK(bmz_check_hash_mask32x2(data, len, s_fp_len, s_b1, s_b2)
== BMZ_E_OK);
}
if (opt & O_BENCH_HASH) {
if (opt & O_HASH_MOD)
BENCH("hash mod", bmz_bench_hash(data, len, BMZ_HASH_MOD), len, n);
if (opt & O_HASH_MOD16X2)
BENCH("hash mod16x2", bmz_bench_hash(data, len, BMZ_HASH_MOD16X2),
len, n);
if (opt & O_HASH_MASK16X2)
BENCH("hash mask16x2", bmz_bench_hash(data, len, BMZ_HASH_MASK16X2),
len, n);
if (opt & O_HASH_MASK)
BENCH("hash mask", bmz_bench_hash(data, len, BMZ_HASH_MASK), len, n);
if (opt & O_HASH_MASK32X2)
BENCH("hash mask32x2", bmz_bench_hash(data, len, BMZ_HASH_MASK32X2),
len, n);
}
if (opt & O_BENCH_LUT) {
if (opt & O_HASH_MOD)
BENCH("lut mod", bmz_bench_lut_mod(data, len, s_fp_len, mem, s_b1, s_m),
len, n);
if (opt & O_HASH_MOD16X2)
BENCH("lut mod16x2", bmz_bench_lut_mod16x2(data, len, s_fp_len, mem,
s_b1, s_b2, s_m1, s_m2), len, n);
if (opt & O_HASH_MASK16X2)
BENCH("lut mask16x2", bmz_bench_lut_mask16x2(data, len, s_fp_len, mem,
s_b1, s_b2), len, n);
if (opt & O_HASH_MASK)
BENCH("lut mask", bmz_bench_lut_mask(data, len, s_fp_len, mem, s_b1),
len, n);
if (opt & O_HASH_MASK32X2)
BENCH("lut mask32x2", bmz_bench_lut_mask32x2(data, len, s_fp_len, mem,
s_b1, s_b2), len, n);
}
if (opt != O_DEFAULT && (opt & 0xf)) return;
if (opt & O_HASH_MOD) {
BENCH("bm pack mod", test_bm_mod(data, len, buf, &out_len, mem), len, n);
BENCH("bm unpack", test_bm_unpack(buf, out_len, buf + out_len, &len2),
len, n);
HT_CHECK(len == len2);
HT_CHECK(memcmp(data, buf + out_len, len) == 0);
}
if (opt & O_HASH_MOD16X2) {
memset(buf, 0, out_len); out_len = out_len0;
BENCH("bm pack mod16x2", test_bm_mod16x2(data, len, buf, &out_len, mem),
len, n);
BENCH("bm unpack", test_bm_unpack(buf, out_len, buf + out_len, &len2),
len, n);
HT_CHECK(len == len2);
HT_CHECK(memcmp(data, buf + out_len, len) == 0);
}
if (opt & O_HASH_MASK16X2) {
memset(buf, 0, out_len); out_len = out_len0;
BENCH("bm pack mask16x2", test_bm_mask16x2(data, len, buf, &out_len, mem),
len, n);
BENCH("bm unpack", test_bm_unpack(buf, out_len, buf + out_len, &len2),
len, n);
HT_CHECK(len == len2);
HT_CHECK(memcmp(data, buf + out_len, len) == 0);
}
if (opt & O_HASH_MASK) {
memset(buf, 0, out_len); out_len = out_len0;
BENCH("bm pack mask", test_bm_mask(data, len, buf, &out_len, mem), len, n);
BENCH("bm unpack", test_bm_unpack(buf, out_len, buf + out_len, &len2),
len, n);
HT_CHECK(len == len2);
HT_CHECK(memcmp(data, buf + out_len, len) == 0);
}
if (opt & O_HASH_MASK32X2) {
memset(buf, 0, out_len); out_len = out_len0;
BENCH("bm pack mask32x2", test_bm_mask32x2(data, len, buf, &out_len, mem),
len, n);
BENCH("bm unpack", test_bm_unpack(buf, out_len, buf + out_len, &len2),
len, n);
HT_CHECK(len == len2);
HT_CHECK(memcmp(data, buf + out_len, len) == 0);
}
}
