mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 16:32:11 +01:00
std/brotli: port block_splitter.c, cluster.c and metablock.c
Add the metablock_builder struct, mirroring BrotliSplitBlock (with its MyRand sampling, InitialEntropyCodes, RefineEntropyCodes, FindBlocks, RemapBlockIds, BuildBlockHistograms and ClusterBlocks), the histogram clustering functions (BrotliCompareAndPushToQueue, BrotliHistogramCombine, BrotliHistogramBitCostDistance, BrotliHistogramRemap, BrotliHistogramReindex, BrotliClusterHistograms), BrotliInitDistanceParams, BrotliBuildMetaBlock (including the distance parameter search) and BrotliOptimizeHistograms (with BrotliOptimizeHuffmanCountsForRle). All memory that the C code allocates lives in a caller-supplied workbuf, carved out by a bump allocator. bit_cost gets an optional 64Ki-entry FastLog2 cache (filled by the same softfloat log2), which makes the clustering several times faster. Extend the metablock_tester and the parity harness to compare SplitBlock, ClusterHistograms*, BuildMetaBlock and OptimizeHistograms results with libbrotlienc v1.2.1.
This commit is contained in:
7 files changed
+7141
-2
No files matched your search
@@ -247,19 +247,992 @@ test_bit_cost(int iters) {
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- InitDistanceParams
|
||||
|
||||
static void //
|
||||
test_init_distance_params(void) {
|
||||
uint32_t npostfix, ndirect_msb, lw;
|
||||
for (lw = 0; lw < 2; lw++) {
|
||||
for (npostfix = 0; npostfix <= 3; npostfix++) {
|
||||
for (ndirect_msb = 0; ndirect_msb < 16; ndirect_msb++) {
|
||||
uint32_t ndirect = ndirect_msb << npostfix;
|
||||
BrotliDistanceParams c;
|
||||
snprintf(g_config_name, sizeof(g_config_name),
|
||||
"InitDistanceParams npostfix=%u ndirect=%u lw=%u", npostfix,
|
||||
ndirect, lw);
|
||||
BrotliInitDistanceParams(&c, npostfix, ndirect, lw ? BROTLI_TRUE : 0);
|
||||
wuffs_brotli__metablock_tester__init_distance_params(g_tester, npostfix,
|
||||
ndirect, lw);
|
||||
CHECK_EQ("distance_postfix_bits", c.distance_postfix_bits,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 24));
|
||||
CHECK_EQ("num_direct_distance_codes", c.num_direct_distance_codes,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 25));
|
||||
CHECK_EQ("alphabet_size_max", c.alphabet_size_max,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 26));
|
||||
CHECK_EQ("alphabet_size_limit", c.alphabet_size_limit,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 27));
|
||||
CHECK_EQ("max_distance", c.max_distance,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 28));
|
||||
count(4, "InitDistanceParams");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Test inputs
|
||||
|
||||
typedef struct {
|
||||
const char* name;
|
||||
uint8_t* data;
|
||||
size_t len;
|
||||
} file_t;
|
||||
|
||||
#define MAX_FILES 64
|
||||
static file_t g_files[MAX_FILES];
|
||||
static size_t g_num_files = 0;
|
||||
|
||||
static void //
|
||||
load_file(const char* path) {
|
||||
FILE* f;
|
||||
long n;
|
||||
if (g_num_files >= MAX_FILES) {
|
||||
return;
|
||||
}
|
||||
f = fopen(path, "rb");
|
||||
if (!f) {
|
||||
return;
|
||||
}
|
||||
fseek(f, 0, SEEK_END);
|
||||
n = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
if (n > 0) {
|
||||
uint8_t* d = malloc((size_t)n);
|
||||
if (d && (fread(d, 1, (size_t)n, f) == (size_t)n)) {
|
||||
g_files[g_num_files].name = path;
|
||||
g_files[g_num_files].data = d;
|
||||
g_files[g_num_files].len = (size_t)n;
|
||||
g_num_files++;
|
||||
} else {
|
||||
free(d);
|
||||
}
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
// Data styles.
|
||||
enum {
|
||||
STYLE_RANDOM = 0,
|
||||
STYLE_IDENTICAL,
|
||||
STYLE_FILE,
|
||||
STYLE_UTF8,
|
||||
STYLE_FEW_SYMBOLS,
|
||||
STYLE_SHIFTING, // The byte distribution changes every few KiB.
|
||||
STYLE_BINARY, // Structured binary (little-endian integers).
|
||||
NUM_STYLES
|
||||
};
|
||||
|
||||
static const char* g_style_names[NUM_STYLES] = {
|
||||
"random", "identical", "file", "utf8", "few", "shifting", "binary",
|
||||
};
|
||||
|
||||
static const char* g_file_name = "";
|
||||
static uint32_t g_shift_max = 8192; // STYLE_SHIFTING's maximum segment size.
|
||||
static int g_dist_style = 0;
|
||||
static uint32_t g_dist_shift = 0;
|
||||
static uint32_t g_dist_residue = 0;
|
||||
|
||||
static void //
|
||||
fill_data(uint8_t* d, size_t n, int style) {
|
||||
size_t i;
|
||||
g_file_name = "";
|
||||
switch (style) {
|
||||
case STYLE_RANDOM:
|
||||
for (i = 0; i < n; i++) {
|
||||
d[i] = (uint8_t)rng64();
|
||||
}
|
||||
break;
|
||||
case STYLE_IDENTICAL: {
|
||||
uint8_t b = (uint8_t)rng64();
|
||||
memset(d, b, n);
|
||||
break;
|
||||
}
|
||||
case STYLE_FILE: {
|
||||
file_t* f = &g_files[rng_below((uint32_t)g_num_files)];
|
||||
size_t off = rng_below((uint32_t)f->len);
|
||||
g_file_name = f->name;
|
||||
for (i = 0; i < n; i++) {
|
||||
d[i] = f->data[(off + i) % f->len];
|
||||
}
|
||||
break;
|
||||
}
|
||||
case STYLE_UTF8:
|
||||
for (i = 0; i < n;) {
|
||||
uint32_t r = rng_below(10);
|
||||
if ((r < 5) || (i + 4 > n)) {
|
||||
d[i++] = (uint8_t)(0x20 + rng_below(0x5F));
|
||||
} else if (r < 7) {
|
||||
d[i++] = (uint8_t)(0xC2 + rng_below(0x1E));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
} else if (r < 9) {
|
||||
d[i++] = (uint8_t)(0xE0 + rng_below(0x10));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
} else {
|
||||
d[i++] = (uint8_t)(0xF0 + rng_below(0x5));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
d[i++] = (uint8_t)(0x80 + rng_below(0x40));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STYLE_FEW_SYMBOLS: {
|
||||
uint32_t k = 2 + rng_below(6);
|
||||
uint8_t base = (uint8_t)rng64();
|
||||
for (i = 0; i < n; i++) {
|
||||
d[i] = (uint8_t)(base + rng_below(k) * 3);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case STYLE_SHIFTING: {
|
||||
uint32_t lo = 0, span = 1;
|
||||
size_t next = 0;
|
||||
for (i = 0; i < n; i++) {
|
||||
if (i == next) {
|
||||
lo = rng_below(256);
|
||||
span = 1 + rng_below(64);
|
||||
next = i + 64 + rng_below(g_shift_max);
|
||||
}
|
||||
d[i] = (uint8_t)(lo + rng_below(span));
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
uint32_t v = (uint32_t)rng64();
|
||||
for (i = 0; i + 4 <= n; i += 4) {
|
||||
v += rng_below(300);
|
||||
memcpy(d + i, &v, 4);
|
||||
}
|
||||
for (; i < n; i++) {
|
||||
d[i] = (uint8_t)rng64();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Commands
|
||||
|
||||
typedef struct {
|
||||
uint8_t* rb; // The ring buffer, of rb_size = mask + 1 bytes (plus slack).
|
||||
size_t mask;
|
||||
size_t pos;
|
||||
size_t total; // The metablock length.
|
||||
Command* cmds;
|
||||
size_t num_cmds;
|
||||
size_t cmds_cap;
|
||||
uint8_t prev_byte;
|
||||
uint8_t prev_byte2;
|
||||
BrotliDistanceParams dist;
|
||||
bool large_window;
|
||||
} block_t;
|
||||
|
||||
static void //
|
||||
push_cmd(block_t* b, size_t insert_len, size_t copy_len, int delta,
|
||||
size_t distance_code) {
|
||||
if (b->num_cmds == b->cmds_cap) {
|
||||
b->cmds_cap = b->cmds_cap ? 2 * b->cmds_cap : 1024;
|
||||
b->cmds = realloc(b->cmds, b->cmds_cap * sizeof(Command));
|
||||
}
|
||||
if (copy_len == 0) {
|
||||
InitInsertCommand(&b->cmds[b->num_cmds++], insert_len);
|
||||
} else {
|
||||
InitCommand(&b->cmds[b->num_cmds++], &b->dist, insert_len, copy_len, delta,
|
||||
distance_code);
|
||||
}
|
||||
}
|
||||
|
||||
static size_t //
|
||||
random_distance(block_t* b) {
|
||||
uint32_t r = rng_below(16);
|
||||
size_t max = b->large_window ? 0x7FFFFFFC : ((1u << 24) - 16);
|
||||
if ((g_dist_style == 1) && (r < 12)) {
|
||||
// Distances with a fixed residue modulo (1 << g_dist_shift), which
|
||||
// favors npostfix > 0.
|
||||
return ((size_t)(1 + rng_below(r < 8 ? 64 : 100000)) << g_dist_shift) +
|
||||
g_dist_residue;
|
||||
} else if ((g_dist_style == 2) && (r < 12)) {
|
||||
// Small distances, which favor ndirect > 0.
|
||||
return 1 + rng_below(4 + rng_below(130));
|
||||
}
|
||||
if (r < 6) {
|
||||
return 1 + rng_below(64);
|
||||
} else if (r < 10) {
|
||||
return 1 + rng_below(4096);
|
||||
} else if (r < 13) {
|
||||
return 1 + rng_below(1u << 18);
|
||||
} else if (r < 15) {
|
||||
return 1 + rng_below((uint32_t)max);
|
||||
}
|
||||
return max - rng_below(1000);
|
||||
}
|
||||
|
||||
static size_t //
|
||||
random_insert_len(size_t remaining, int mode) {
|
||||
uint32_t r = rng_below(16);
|
||||
size_t n;
|
||||
if (mode == 1) { // Long inserts.
|
||||
n = rng_below(r < 8 ? 3000 : 70000);
|
||||
} else if (r < 8) {
|
||||
n = rng_below(6);
|
||||
} else if (r < 13) {
|
||||
n = rng_below(130);
|
||||
} else if (r < 15) {
|
||||
n = rng_below(2200);
|
||||
} else {
|
||||
n = rng_below(30000);
|
||||
}
|
||||
return n < remaining ? n : remaining;
|
||||
}
|
||||
|
||||
static size_t //
|
||||
random_copy_len(int mode) {
|
||||
uint32_t r = rng_below(16);
|
||||
(void)mode;
|
||||
if (r < 8) {
|
||||
return 2 + rng_below(8);
|
||||
} else if (r < 13) {
|
||||
return 2 + rng_below(134);
|
||||
} else if (r < 15) {
|
||||
return 2 + rng_below(2200);
|
||||
}
|
||||
return 2 + rng_below(100000);
|
||||
}
|
||||
|
||||
// make_synthetic_commands fills b->cmds with random (but valid) commands
|
||||
// whose insert and copy lengths add up to b->total.
|
||||
static void //
|
||||
make_synthetic_commands(block_t* b, int mode) {
|
||||
size_t remaining = b->total;
|
||||
b->num_cmds = 0;
|
||||
while (remaining > 0) {
|
||||
size_t ins = random_insert_len(remaining, mode);
|
||||
size_t copy;
|
||||
int delta = 0;
|
||||
size_t dcode;
|
||||
remaining -= ins;
|
||||
if (remaining < 2) {
|
||||
// A final insert-only command.
|
||||
push_cmd(b, ins + remaining, 0, 0, 0);
|
||||
remaining = 0;
|
||||
break;
|
||||
}
|
||||
copy = random_copy_len(mode);
|
||||
if (copy > remaining) {
|
||||
copy = remaining;
|
||||
}
|
||||
if ((rng_below(16) == 0) && (copy >= 4) && (copy <= 24)) {
|
||||
// A dictionary-like copy whose length code differs from its length.
|
||||
delta = (int)rng_below(9) - 4;
|
||||
if ((int)copy + delta < 2) {
|
||||
delta = 0;
|
||||
}
|
||||
}
|
||||
if (rng_below(4) == 0) {
|
||||
dcode = rng_below(16); // A short (distance cache) code.
|
||||
} else {
|
||||
dcode = random_distance(b) + 15;
|
||||
}
|
||||
push_cmd(b, ins, copy, delta, dcode);
|
||||
remaining -= copy;
|
||||
}
|
||||
}
|
||||
|
||||
// make_lz77_commands fills b->cmds with the commands of a simple greedy LZ77
|
||||
// parse of the metablock's bytes (with a 1-entry distance cache).
|
||||
static void //
|
||||
make_lz77_commands(block_t* b) {
|
||||
static uint32_t table[1 << 16];
|
||||
size_t i = 0, ins = 0, last_dist = 0;
|
||||
memset(table, 0xFF, sizeof(table));
|
||||
b->num_cmds = 0;
|
||||
while (i < b->total) {
|
||||
size_t cand_len = 0, cand_dist = 0;
|
||||
if (i + 4 <= b->total) {
|
||||
uint32_t v = 0;
|
||||
uint32_t h;
|
||||
size_t k;
|
||||
for (k = 0; k < 4; k++) {
|
||||
v |= (uint32_t)b->rb[(b->pos + i + k) & b->mask] << (8 * k);
|
||||
}
|
||||
h = (v * 0x1E35A7BDu) >> 16;
|
||||
if (table[h] != 0xFFFFFFFFu) {
|
||||
size_t j = table[h];
|
||||
size_t len = 0;
|
||||
while ((i + len < b->total) && (len < 1000) &&
|
||||
(b->rb[(b->pos + j + len) & b->mask] ==
|
||||
b->rb[(b->pos + i + len) & b->mask])) {
|
||||
len++;
|
||||
}
|
||||
if (len >= 4) {
|
||||
cand_len = len;
|
||||
cand_dist = i - j;
|
||||
}
|
||||
}
|
||||
table[h] = (uint32_t)i;
|
||||
}
|
||||
if (cand_len) {
|
||||
size_t dcode = (cand_dist == last_dist) ? 0 : cand_dist + 15;
|
||||
push_cmd(b, ins, cand_len, 0, dcode);
|
||||
last_dist = cand_dist;
|
||||
ins = 0;
|
||||
i += cand_len;
|
||||
} else {
|
||||
ins++;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (ins > 0) {
|
||||
push_cmd(b, ins, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// make_short_commands fills b->cmds with many short commands.
|
||||
static void //
|
||||
make_short_commands(block_t* b) {
|
||||
size_t remaining = b->total;
|
||||
b->num_cmds = 0;
|
||||
while (remaining > 0) {
|
||||
size_t ins = rng_below(4);
|
||||
size_t copy = 2 + rng_below(6);
|
||||
if (ins > remaining) {
|
||||
ins = remaining;
|
||||
}
|
||||
remaining -= ins;
|
||||
if (remaining < copy) {
|
||||
push_cmd(b, ins + remaining, 0, 0, 0);
|
||||
break;
|
||||
}
|
||||
push_cmd(b, ins, copy, 0,
|
||||
rng_below(3) ? rng_below(16) : random_distance(b) + 15);
|
||||
remaining -= copy;
|
||||
}
|
||||
}
|
||||
|
||||
// make_block sets up the ring buffer (with the metablock's total bytes at
|
||||
// position pos, possibly wrapping around) and its commands.
|
||||
static void //
|
||||
make_block(block_t* b, size_t total, int style, int cmd_mode, bool wrap) {
|
||||
size_t rb_size = 1024;
|
||||
uint8_t* tmp;
|
||||
size_t i;
|
||||
while (rb_size < total + (wrap ? 0 : 1)) {
|
||||
rb_size *= 2;
|
||||
}
|
||||
if (!wrap && (rb_size < 2 * total)) {
|
||||
rb_size *= 2;
|
||||
}
|
||||
free(b->rb);
|
||||
b->rb = malloc(rb_size + 64);
|
||||
memset(b->rb, 0, rb_size + 64);
|
||||
b->mask = rb_size - 1;
|
||||
b->pos = wrap ? (rb_size - rng_below((uint32_t)total + 1)) & b->mask
|
||||
: rng_below((uint32_t)(rb_size - total));
|
||||
b->total = total;
|
||||
tmp = malloc(total + 1);
|
||||
fill_data(tmp, total, style);
|
||||
for (i = 0; i < total; i++) {
|
||||
b->rb[(b->pos + i) & b->mask] = tmp[i];
|
||||
}
|
||||
free(tmp);
|
||||
b->prev_byte = (uint8_t)rng64();
|
||||
b->prev_byte2 = (uint8_t)rng64();
|
||||
if (cmd_mode == 2) {
|
||||
make_lz77_commands(b);
|
||||
} else if (cmd_mode == 3) {
|
||||
make_short_commands(b);
|
||||
} else {
|
||||
make_synthetic_commands(b, cmd_mode);
|
||||
}
|
||||
}
|
||||
|
||||
// Coverage statistics.
|
||||
static uint64_t g_dist_params_seen[2][4][16];
|
||||
static uint64_t g_chosen_dist_params_seen[4][16];
|
||||
static uint64_t g_context_modes_seen[4];
|
||||
static uint64_t g_max_num_types[3];
|
||||
static uint64_t g_max_num_blocks[3];
|
||||
static uint64_t g_max_literals;
|
||||
static uint64_t g_max_commands;
|
||||
|
||||
// ---------------- Workbuf
|
||||
|
||||
static uint8_t* g_workbuf = NULL;
|
||||
static size_t g_workbuf_len = 0;
|
||||
static uint64_t g_max_workbuf_used = 0;
|
||||
|
||||
static void //
|
||||
ensure_workbuf(size_t n) {
|
||||
if (g_workbuf_len < n) {
|
||||
free(g_workbuf);
|
||||
g_workbuf = malloc(n);
|
||||
g_workbuf_len = n;
|
||||
if (!g_workbuf) {
|
||||
printf("out of memory\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t //
|
||||
ld32(const uint8_t* p) {
|
||||
uint32_t v;
|
||||
memcpy(&v, p, 4);
|
||||
return v;
|
||||
}
|
||||
|
||||
// ---------------- SplitBlock
|
||||
|
||||
static void //
|
||||
compare_block_split(const char* what, const BlockSplit* c, int cat) {
|
||||
size_t n;
|
||||
size_t i;
|
||||
uint64_t num_types = wuffs_brotli__metablock_tester__get(g_tester, 4 * cat);
|
||||
uint64_t num_blocks =
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 4 * cat + 1);
|
||||
uint64_t types_off =
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 4 * cat + 2);
|
||||
uint64_t lengths_off =
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 4 * cat + 3);
|
||||
char buf[128];
|
||||
snprintf(buf, sizeof(buf), "%s.num_types", what);
|
||||
CHECK_EQ(buf, c->num_types, num_types);
|
||||
snprintf(buf, sizeof(buf), "%s.num_blocks", what);
|
||||
CHECK_EQ(buf, c->num_blocks, num_blocks);
|
||||
n = c->num_blocks < num_blocks ? c->num_blocks : (size_t)num_blocks;
|
||||
for (i = 0; i < n; i++) {
|
||||
snprintf(buf, sizeof(buf), "%s.types[%zu]", what, i);
|
||||
CHECK_EQ(buf, c->types[i], g_workbuf[types_off + i]);
|
||||
snprintf(buf, sizeof(buf), "%s.lengths[%zu]", what, i);
|
||||
CHECK_EQ(buf, c->lengths[i], ld32(g_workbuf + lengths_off + 4 * i));
|
||||
if (g_num_mismatches > 1000) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static size_t //
|
||||
workbuf_guess(const block_t* b) {
|
||||
return ((size_t)64 << 20) + 64 * b->total + 64 * b->num_cmds;
|
||||
}
|
||||
|
||||
static void //
|
||||
test_split_block(block_t* b, int quality) {
|
||||
MemoryManager m;
|
||||
BrotliEncoderParams params;
|
||||
BlockSplit ls, cs, ds;
|
||||
wuffs_base__status st;
|
||||
size_t wlen = workbuf_guess(b);
|
||||
|
||||
memset(¶ms, 0, sizeof(params));
|
||||
params.quality = quality;
|
||||
BrotliInitMemoryManager(&m, 0, 0, 0);
|
||||
BrotliInitBlockSplit(&ls);
|
||||
BrotliInitBlockSplit(&cs);
|
||||
BrotliInitBlockSplit(&ds);
|
||||
BrotliSplitBlock(&m, b->cmds, b->num_cmds, b->rb, b->pos, b->mask, ¶ms,
|
||||
&ls, &cs, &ds);
|
||||
|
||||
while (true) {
|
||||
ensure_workbuf(wlen);
|
||||
st = wuffs_brotli__metablock_tester__split_block(
|
||||
g_tester,
|
||||
wuffs_base__make_slice_u8((uint8_t*)b->cmds,
|
||||
b->num_cmds * sizeof(Command)),
|
||||
b->num_cmds, wuffs_base__make_slice_u8(b->rb, b->mask + 1), b->pos,
|
||||
b->mask, (uint32_t)quality,
|
||||
wuffs_base__make_slice_u8(g_workbuf, g_workbuf_len));
|
||||
if (st.repr != wuffs_base__error__bad_workbuf_length) {
|
||||
break;
|
||||
}
|
||||
wlen *= 2;
|
||||
}
|
||||
if (st.repr) {
|
||||
printf("split_block: %s (%s)\n", st.repr, g_config_name);
|
||||
g_num_mismatches++;
|
||||
} else {
|
||||
uint64_t used = wuffs_brotli__metablock_tester__get(g_tester, 29);
|
||||
if (g_max_workbuf_used < used) {
|
||||
g_max_workbuf_used = used;
|
||||
}
|
||||
compare_block_split("literal_split", &ls, 0);
|
||||
compare_block_split("command_split", &cs, 1);
|
||||
compare_block_split("distance_split", &ds, 2);
|
||||
}
|
||||
BrotliDestroyBlockSplit(&m, &ls);
|
||||
BrotliDestroyBlockSplit(&m, &cs);
|
||||
BrotliDestroyBlockSplit(&m, &ds);
|
||||
}
|
||||
|
||||
// ---------------- BuildMetaBlock and OptimizeHistograms
|
||||
|
||||
static void //
|
||||
compare_histograms(const char* what, const void* c_histos, size_t hsize,
|
||||
uint64_t c_n, int cat) {
|
||||
uint64_t off = wuffs_brotli__metablock_tester__get(g_tester, 18 + cat);
|
||||
uint64_t n = wuffs_brotli__metablock_tester__get(g_tester, 21 + cat);
|
||||
size_t i;
|
||||
char buf[128];
|
||||
snprintf(buf, sizeof(buf), "%s.size", what);
|
||||
CHECK_EQ(buf, c_n, n);
|
||||
if (c_n != n) {
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
const uint8_t* cp = (const uint8_t*)c_histos + i * hsize;
|
||||
const uint8_t* wp = g_workbuf + off + i * hsize;
|
||||
size_t j;
|
||||
g_num_checks++;
|
||||
if (memcmp(cp, wp, hsize)) {
|
||||
for (j = 0; j < hsize; j += 4) {
|
||||
if (memcmp(cp + j, wp + j, 4)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
snprintf(buf, sizeof(buf), "%s[%zu] at byte %zu", what, i, j);
|
||||
CHECK_EQ(buf, ld32(cp + j), ld32(wp + j));
|
||||
g_num_checks--;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
compare_context_map(const char* what, const uint32_t* c_map, size_t c_n,
|
||||
int cat) {
|
||||
uint64_t off = wuffs_brotli__metablock_tester__get(g_tester, 12 + cat);
|
||||
uint64_t n = wuffs_brotli__metablock_tester__get(g_tester, 15 + cat);
|
||||
size_t i;
|
||||
char buf[128];
|
||||
snprintf(buf, sizeof(buf), "%s.size", what);
|
||||
CHECK_EQ(buf, c_n, n);
|
||||
if (c_n != n) {
|
||||
return;
|
||||
}
|
||||
g_num_checks++;
|
||||
for (i = 0; i < n; i++) {
|
||||
if (c_map[i] != ld32(g_workbuf + off + 4 * i)) {
|
||||
snprintf(buf, sizeof(buf), "%s[%zu]", what, i);
|
||||
CHECK_EQ(buf, c_map[i], ld32(g_workbuf + off + 4 * i));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
compare_meta_block_split(const MetaBlockSplit* mb, const char* suffix) {
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "literal_histograms%s", suffix);
|
||||
compare_histograms(buf, mb->literal_histograms, sizeof(HistogramLiteral),
|
||||
mb->literal_histograms_size, 0);
|
||||
snprintf(buf, sizeof(buf), "command_histograms%s", suffix);
|
||||
compare_histograms(buf, mb->command_histograms, sizeof(HistogramCommand),
|
||||
mb->command_histograms_size, 1);
|
||||
snprintf(buf, sizeof(buf), "distance_histograms%s", suffix);
|
||||
compare_histograms(buf, mb->distance_histograms, sizeof(HistogramDistance),
|
||||
mb->distance_histograms_size, 2);
|
||||
}
|
||||
|
||||
static void //
|
||||
test_build_meta_block(block_t* b, int quality, bool disable_lcm,
|
||||
int context_mode) {
|
||||
MemoryManager m;
|
||||
BrotliEncoderParams params;
|
||||
MetaBlockSplit mb;
|
||||
wuffs_base__status st;
|
||||
size_t wlen = workbuf_guess(b);
|
||||
size_t cmds_size = b->num_cmds * sizeof(Command);
|
||||
Command* c_cmds = malloc(cmds_size + 1);
|
||||
Command* w_cmds = malloc(cmds_size + 1);
|
||||
size_t i;
|
||||
|
||||
memcpy(c_cmds, b->cmds, cmds_size);
|
||||
memset(¶ms, 0, sizeof(params));
|
||||
params.quality = quality;
|
||||
params.large_window = b->large_window ? BROTLI_TRUE : BROTLI_FALSE;
|
||||
params.disable_literal_context_modeling =
|
||||
disable_lcm ? BROTLI_TRUE : BROTLI_FALSE;
|
||||
params.dist = b->dist;
|
||||
BrotliInitMemoryManager(&m, 0, 0, 0);
|
||||
InitMetaBlockSplit(&mb);
|
||||
BrotliBuildMetaBlock(&m, b->rb, b->pos, b->mask, ¶ms, b->prev_byte,
|
||||
b->prev_byte2, c_cmds, b->num_cmds,
|
||||
(ContextType)context_mode, &mb);
|
||||
|
||||
while (true) {
|
||||
memcpy(w_cmds, b->cmds, cmds_size);
|
||||
ensure_workbuf(wlen);
|
||||
st = wuffs_brotli__metablock_tester__build_meta_block(
|
||||
g_tester, wuffs_base__make_slice_u8(g_workbuf, g_workbuf_len),
|
||||
wuffs_base__make_slice_u8(b->rb, b->mask + 1), b->pos, b->mask,
|
||||
b->prev_byte, b->prev_byte2,
|
||||
wuffs_base__make_slice_u8((uint8_t*)w_cmds, cmds_size), b->num_cmds,
|
||||
(uint32_t)context_mode, (uint32_t)quality, b->large_window ? 1 : 0,
|
||||
disable_lcm ? 1 : 0, b->dist.distance_postfix_bits,
|
||||
b->dist.num_direct_distance_codes);
|
||||
if (st.repr != wuffs_base__error__bad_workbuf_length) {
|
||||
break;
|
||||
}
|
||||
wlen *= 2;
|
||||
}
|
||||
if (st.repr) {
|
||||
printf("build_meta_block: %s (%s)\n", st.repr, g_config_name);
|
||||
g_num_mismatches++;
|
||||
goto done;
|
||||
}
|
||||
{
|
||||
uint64_t used = wuffs_brotli__metablock_tester__get(g_tester, 29);
|
||||
if (g_max_workbuf_used < used) {
|
||||
g_max_workbuf_used = used;
|
||||
}
|
||||
}
|
||||
|
||||
CHECK_EQ("dist.distance_postfix_bits", params.dist.distance_postfix_bits,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 24));
|
||||
CHECK_EQ("dist.num_direct_distance_codes",
|
||||
params.dist.num_direct_distance_codes,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 25));
|
||||
CHECK_EQ("dist.alphabet_size_max", params.dist.alphabet_size_max,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 26));
|
||||
CHECK_EQ("dist.alphabet_size_limit", params.dist.alphabet_size_limit,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 27));
|
||||
CHECK_EQ("dist.max_distance", params.dist.max_distance,
|
||||
wuffs_brotli__metablock_tester__get(g_tester, 28));
|
||||
g_num_checks++;
|
||||
if (memcmp(c_cmds, w_cmds, cmds_size)) {
|
||||
for (i = 0; i < b->num_cmds; i++) {
|
||||
if (memcmp(&c_cmds[i], &w_cmds[i], sizeof(Command))) {
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "cmds[%zu].dist_prefix_", i);
|
||||
CHECK_EQ(buf, c_cmds[i].dist_prefix_, w_cmds[i].dist_prefix_);
|
||||
snprintf(buf, sizeof(buf), "cmds[%zu].dist_extra_", i);
|
||||
CHECK_EQ(buf, c_cmds[i].dist_extra_, w_cmds[i].dist_extra_);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
g_chosen_dist_params_seen[params.dist.distance_postfix_bits & 3]
|
||||
[(params.dist.num_direct_distance_codes >>
|
||||
params.dist.distance_postfix_bits) & 15]++;
|
||||
g_context_modes_seen[context_mode & 3]++;
|
||||
if (g_max_num_types[0] < mb.literal_split.num_types) {
|
||||
g_max_num_types[0] = mb.literal_split.num_types;
|
||||
}
|
||||
if (g_max_num_types[1] < mb.command_split.num_types) {
|
||||
g_max_num_types[1] = mb.command_split.num_types;
|
||||
}
|
||||
if (g_max_num_types[2] < mb.distance_split.num_types) {
|
||||
g_max_num_types[2] = mb.distance_split.num_types;
|
||||
}
|
||||
if (g_max_num_blocks[0] < mb.literal_split.num_blocks) {
|
||||
g_max_num_blocks[0] = mb.literal_split.num_blocks;
|
||||
}
|
||||
if (g_max_num_blocks[1] < mb.command_split.num_blocks) {
|
||||
g_max_num_blocks[1] = mb.command_split.num_blocks;
|
||||
}
|
||||
if (g_max_num_blocks[2] < mb.distance_split.num_blocks) {
|
||||
g_max_num_blocks[2] = mb.distance_split.num_blocks;
|
||||
}
|
||||
if (g_max_commands < b->num_cmds) {
|
||||
g_max_commands = b->num_cmds;
|
||||
}
|
||||
{
|
||||
uint64_t nl = 0;
|
||||
for (i = 0; i < b->num_cmds; i++) {
|
||||
nl += b->cmds[i].insert_len_;
|
||||
}
|
||||
if (g_max_literals < nl) {
|
||||
g_max_literals = nl;
|
||||
}
|
||||
}
|
||||
}
|
||||
compare_block_split("mb.literal_split", &mb.literal_split, 0);
|
||||
compare_block_split("mb.command_split", &mb.command_split, 1);
|
||||
compare_block_split("mb.distance_split", &mb.distance_split, 2);
|
||||
compare_context_map("literal_context_map", mb.literal_context_map,
|
||||
mb.literal_context_map_size, 0);
|
||||
compare_context_map("distance_context_map", mb.distance_context_map,
|
||||
mb.distance_context_map_size, 2);
|
||||
compare_meta_block_split(&mb, "");
|
||||
|
||||
BrotliOptimizeHistograms(params.dist.alphabet_size_limit, &mb);
|
||||
wuffs_brotli__metablock_tester__optimize_histograms(
|
||||
g_tester, wuffs_base__make_slice_u8(g_workbuf, g_workbuf_len),
|
||||
params.dist.alphabet_size_limit);
|
||||
compare_meta_block_split(&mb, " (optimized)");
|
||||
|
||||
done:
|
||||
DestroyMetaBlockSplit(&m, &mb);
|
||||
free(c_cmds);
|
||||
free(w_cmds);
|
||||
}
|
||||
|
||||
// ---------------- ClusterHistograms
|
||||
|
||||
static void //
|
||||
test_cluster_histograms(int iters) {
|
||||
int it;
|
||||
for (it = 0; it < iters; it++) {
|
||||
int kind = (int)rng_below(3);
|
||||
size_t data_size = (kind == 0) ? 256 : (kind == 1) ? 704 : 544;
|
||||
size_t hsize = (kind == 0) ? sizeof(HistogramLiteral)
|
||||
: (kind == 1) ? sizeof(HistogramCommand)
|
||||
: sizeof(HistogramDistance);
|
||||
uint32_t r = rng_below(8);
|
||||
size_t in_size = (r < 4) ? 1 + rng_below(16)
|
||||
: (r < 7) ? 1 + rng_below(200)
|
||||
: 1 + rng_below(1100);
|
||||
size_t max_histograms = rng_below(4) ? 256 : 1 + rng_below(300);
|
||||
int style = (int)rng_below(7);
|
||||
int sharing = (int)rng_below(3);
|
||||
uint8_t* in = malloc(in_size * hsize);
|
||||
uint8_t* out = malloc(in_size * hsize);
|
||||
uint32_t* symbols = malloc(in_size * sizeof(uint32_t));
|
||||
size_t c_out_size = 0;
|
||||
uint64_t w_out_size;
|
||||
MemoryManager m;
|
||||
size_t i, j;
|
||||
snprintf(g_config_name, sizeof(g_config_name),
|
||||
"ClusterHistograms iter=%d kind=%d in_size=%zu max=%zu "
|
||||
"style=%d sharing=%d",
|
||||
it, kind, in_size, max_histograms, style, sharing);
|
||||
for (i = 0; i < in_size; i++) {
|
||||
uint32_t* data = (uint32_t*)(in + i * hsize);
|
||||
uint64_t total = 0;
|
||||
if ((sharing > 0) && (i > 0) && (rng_below(3) != 0)) {
|
||||
// Copy (and perturb) an earlier histogram, so that clustering has
|
||||
// something to merge.
|
||||
memcpy(data, in + rng_below((uint32_t)i) * hsize, data_size * 4);
|
||||
if (sharing == 2) {
|
||||
data[rng_below((uint32_t)data_size)] += rng_below(5);
|
||||
}
|
||||
} else if (rng_below(10) == 0) {
|
||||
memset(data, 0, data_size * 4); // An empty histogram.
|
||||
} else {
|
||||
fill_counts(data, data_size, style);
|
||||
}
|
||||
for (j = 0; j < data_size; j++) {
|
||||
total += data[j];
|
||||
}
|
||||
memcpy(in + i * hsize + data_size * 4, &total, 8);
|
||||
memset(in + i * hsize + data_size * 4 + 8, 0, 8);
|
||||
}
|
||||
BrotliInitMemoryManager(&m, 0, 0, 0);
|
||||
if (kind == 0) {
|
||||
BrotliClusterHistogramsLiteral(&m, (HistogramLiteral*)in, in_size,
|
||||
max_histograms, (HistogramLiteral*)out,
|
||||
&c_out_size, symbols);
|
||||
} else if (kind == 1) {
|
||||
BrotliClusterHistogramsCommand(&m, (HistogramCommand*)in, in_size,
|
||||
max_histograms, (HistogramCommand*)out,
|
||||
&c_out_size, symbols);
|
||||
} else {
|
||||
BrotliClusterHistogramsDistance(&m, (HistogramDistance*)in, in_size,
|
||||
max_histograms, (HistogramDistance*)out,
|
||||
&c_out_size, symbols);
|
||||
}
|
||||
ensure_workbuf(4 * in_size * hsize + ((size_t)16 << 20));
|
||||
w_out_size = wuffs_brotli__metablock_tester__cluster_histograms(
|
||||
g_tester, (uint32_t)data_size,
|
||||
wuffs_base__make_slice_u8(in, in_size * hsize), in_size,
|
||||
max_histograms, wuffs_base__make_slice_u8(g_workbuf, g_workbuf_len));
|
||||
CHECK_EQ("out_size", c_out_size, w_out_size);
|
||||
if (c_out_size == w_out_size) {
|
||||
uint64_t out_off = wuffs_brotli__metablock_tester__get(g_tester, 18);
|
||||
uint64_t sym_off = wuffs_brotli__metablock_tester__get(g_tester, 12);
|
||||
g_num_checks++;
|
||||
for (i = 0; i < c_out_size; i++) {
|
||||
if (memcmp(out + i * hsize, g_workbuf + out_off + i * hsize, hsize)) {
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "out[%zu]", i);
|
||||
CHECK_EQ(buf, 0, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < in_size; i++) {
|
||||
if (symbols[i] != ld32(g_workbuf + sym_off + 4 * i)) {
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "histogram_symbols[%zu]", i);
|
||||
CHECK_EQ(buf, symbols[i], ld32(g_workbuf + sym_off + 4 * i));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
count(5 + kind, kind == 0 ? "ClusterHistogramsLiteral"
|
||||
: kind == 1 ? "ClusterHistogramsCommand"
|
||||
: "ClusterHistogramsDistance");
|
||||
free(in);
|
||||
free(out);
|
||||
free(symbols);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Configurations
|
||||
|
||||
static block_t g_block;
|
||||
|
||||
|
||||
static void //
|
||||
random_dist_params(block_t* b) {
|
||||
uint32_t npostfix = rng_below(4);
|
||||
uint32_t ndirect = rng_below(16) << npostfix;
|
||||
if (rng_below(3) == 0) {
|
||||
npostfix = 0;
|
||||
ndirect = 0;
|
||||
}
|
||||
b->large_window = rng_below(4) == 0;
|
||||
BrotliInitDistanceParams(&b->dist, npostfix, ndirect,
|
||||
b->large_window ? BROTLI_TRUE : BROTLI_FALSE);
|
||||
}
|
||||
|
||||
static void //
|
||||
run_config(size_t total, int style, int cmd_mode, bool do_split,
|
||||
bool do_build) {
|
||||
bool wrap = rng_below(4) == 0;
|
||||
int quality = (rng_below(2) == 0) ? 10 : 11;
|
||||
bool disable_lcm = rng_below(4) == 0;
|
||||
int context_mode = (int)rng_below(4);
|
||||
if (rng_below(8) == 0) {
|
||||
quality = 4 + (int)rng_below(6);
|
||||
}
|
||||
g_shift_max = rng_below(2) ? 8192 : 64 + rng_below(2000);
|
||||
g_dist_style = (int)rng_below(3);
|
||||
g_dist_shift = 1 + rng_below(3);
|
||||
g_dist_residue = rng_below(1u << g_dist_shift);
|
||||
random_dist_params(&g_block);
|
||||
g_dist_params_seen[g_block.large_window ? 1 : 0]
|
||||
[g_block.dist.distance_postfix_bits]
|
||||
[g_block.dist.num_direct_distance_codes >>
|
||||
g_block.dist.distance_postfix_bits]++;
|
||||
make_block(&g_block, total, style, cmd_mode, wrap);
|
||||
snprintf(g_config_name, sizeof(g_config_name),
|
||||
"total=%zu style=%s%s%s cmds=%d(n=%zu) wrap=%d q=%d lw=%d "
|
||||
"npostfix=%u ndirect=%u nolcm=%d mode=%d rng=%016" PRIX64,
|
||||
total, g_style_names[style], *g_file_name ? ":" : "", g_file_name,
|
||||
cmd_mode, g_block.num_cmds, wrap, quality, g_block.large_window,
|
||||
g_block.dist.distance_postfix_bits,
|
||||
g_block.dist.num_direct_distance_codes, disable_lcm, context_mode,
|
||||
g_rng_state);
|
||||
if (do_split) {
|
||||
test_split_block(&g_block, quality);
|
||||
count(8, "SplitBlock");
|
||||
}
|
||||
if (do_build) {
|
||||
test_build_meta_block(&g_block, quality, disable_lcm, context_mode);
|
||||
count(9, "BuildMetaBlock+OptimizeHistograms");
|
||||
}
|
||||
}
|
||||
|
||||
static size_t //
|
||||
random_total(void) {
|
||||
uint32_t r = rng_below(16);
|
||||
if (r < 3) {
|
||||
return rng_below(130);
|
||||
} else if (r < 10) {
|
||||
return 130 + rng_below(3870);
|
||||
} else if (r < 15) {
|
||||
return 4000 + rng_below(36000);
|
||||
}
|
||||
return 40000 + rng_below(110000);
|
||||
}
|
||||
|
||||
// ---------------- Main
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
bool quick = (argc > 1) && !strcmp(argv[1], "-quick");
|
||||
bool quick = false;
|
||||
int n_bitcost = 200000, n_clusters = 3000, n_configs = 20000, n_large = 8;
|
||||
int i;
|
||||
for (i = 1; i < argc; i++) {
|
||||
if (!strcmp(argv[i], "-quick")) {
|
||||
quick = true;
|
||||
n_bitcost = 20000;
|
||||
n_clusters = 300;
|
||||
n_configs = 200;
|
||||
n_large = 1;
|
||||
} else if (!strncmp(argv[i], "-bitcost=", 9)) {
|
||||
n_bitcost = atoi(argv[i] + 9);
|
||||
} else if (!strncmp(argv[i], "-clusters=", 10)) {
|
||||
n_clusters = atoi(argv[i] + 10);
|
||||
} else if (!strncmp(argv[i], "-configs=", 9)) {
|
||||
n_configs = atoi(argv[i] + 9);
|
||||
} else if (!strncmp(argv[i], "-large=", 7)) {
|
||||
n_large = atoi(argv[i] + 7);
|
||||
} else if (!strncmp(argv[i], "-seed=", 6)) {
|
||||
g_rng_state = strtoull(argv[i] + 6, NULL, 0) | 1;
|
||||
}
|
||||
}
|
||||
(void)quick;
|
||||
g_tester = wuffs_brotli__metablock_tester__alloc();
|
||||
if (!g_tester) {
|
||||
printf("could not allocate the tester\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
test_bit_cost(quick ? 20000 : 200000);
|
||||
load_file("test/data/romeo.txt");
|
||||
load_file("test/data/midsummer.txt");
|
||||
load_file("test/data/pi.txt");
|
||||
load_file("test/data/abraca.txt");
|
||||
load_file("test/data/enwik5");
|
||||
load_file("test/data/archive.tar");
|
||||
load_file("test/data/hippopotamus.pgm");
|
||||
load_file("test/data/github-tags.json");
|
||||
load_file("test/data/json-things.formatted.json");
|
||||
load_file("test/data/256.bytes");
|
||||
if (g_num_files == 0) {
|
||||
printf("no test files (run from the Wuffs root directory)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
test_bit_cost(n_bitcost);
|
||||
test_init_distance_params();
|
||||
test_cluster_histograms(n_clusters);
|
||||
// Edge cases: no commands, one command, one literal, all identical bytes,
|
||||
// in every literal context mode.
|
||||
for (i = 0; i < 64; i++) {
|
||||
static const size_t totals[8] = {0, 1, 2, 5, 127, 128, 129, 3000};
|
||||
run_config(totals[i & 7], (i & 8) ? STYLE_IDENTICAL : STYLE_RANDOM,
|
||||
(i >> 4) % 3, true, true);
|
||||
}
|
||||
// Large configurations: at least 1 MiB of literals, and at least 100k
|
||||
// commands.
|
||||
for (i = 0; i < n_large; i++) {
|
||||
static const int styles[4] = {STYLE_FILE, STYLE_RANDOM, STYLE_SHIFTING,
|
||||
STYLE_UTF8};
|
||||
if (i & 1) {
|
||||
// Many short commands.
|
||||
run_config((size_t)1 << 20, STYLE_FEW_SYMBOLS, 3, false, true);
|
||||
} else {
|
||||
run_config(((size_t)3 << 19) + rng_below(1 << 18), styles[(i / 2) & 3],
|
||||
1, false, true);
|
||||
}
|
||||
printf("large configuration %d done, %" PRIu64 " mismatches so far\n",
|
||||
i, g_num_mismatches);
|
||||
fflush(stdout);
|
||||
}
|
||||
{
|
||||
int n = n_configs;
|
||||
for (i = 0; i < n; i++) {
|
||||
int style = (int)rng_below(NUM_STYLES);
|
||||
int cmd_mode = (int)rng_below(3);
|
||||
run_config(random_total(), style, cmd_mode, rng_below(2) == 0, true);
|
||||
if ((i % 1000) == 999) {
|
||||
printf("%d configurations, %" PRIu64 " mismatches so far\n", i + 1,
|
||||
g_num_mismatches);
|
||||
fflush(stdout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < 64; i++) {
|
||||
if (g_count_names[i]) {
|
||||
@@ -267,6 +1240,34 @@ main(int argc, char** argv) {
|
||||
g_counts[i]);
|
||||
}
|
||||
}
|
||||
{
|
||||
int lw, np, nd, seen = 0, chosen = 0;
|
||||
for (lw = 0; lw < 2; lw++) {
|
||||
for (np = 0; np < 4; np++) {
|
||||
for (nd = 0; nd < 16; nd++) {
|
||||
seen += g_dist_params_seen[lw][np][nd] ? 1 : 0;
|
||||
if (lw == 0) {
|
||||
chosen += g_chosen_dist_params_seen[np][nd] ? 1 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("input (large_window, npostfix, ndirect) combinations: %d of 128\n",
|
||||
seen);
|
||||
printf("chosen (npostfix, ndirect) combinations: %d of 64\n", chosen);
|
||||
printf("context modes: %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
|
||||
g_context_modes_seen[0], g_context_modes_seen[1],
|
||||
g_context_modes_seen[2], g_context_modes_seen[3]);
|
||||
printf("max num_types (lit, cmd, dist): %" PRIu64 " %" PRIu64 " %" PRIu64
|
||||
"\n",
|
||||
g_max_num_types[0], g_max_num_types[1], g_max_num_types[2]);
|
||||
printf("max num_blocks (lit, cmd, dist): %" PRIu64 " %" PRIu64 " %" PRIu64
|
||||
"\n",
|
||||
g_max_num_blocks[0], g_max_num_blocks[1], g_max_num_blocks[2]);
|
||||
printf("max literals: %" PRIu64 ", max commands: %" PRIu64 "\n",
|
||||
g_max_literals, g_max_commands);
|
||||
}
|
||||
printf("max workbuf used: %" PRIu64 " bytes\n", g_max_workbuf_used);
|
||||
printf("%" PRIu64 " checks, %" PRIu64 " mismatches\n", g_num_checks,
|
||||
g_num_mismatches);
|
||||
free(g_tester);
|
||||
|
||||
Reference in new issue
Block a user