summaryrefslogtreecommitdiff
path: root/dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h
diff options
context:
space:
mode:
Diffstat (limited to 'dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h')
-rw-r--r--dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h151
1 files changed, 91 insertions, 60 deletions
diff --git a/dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h b/dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h
index a7b9639feb..e5ba840ab9 100644
--- a/dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h
+++ b/dviware/dvisvgm/libs/brotli/enc/hash_longest_match_quickly_inc.h
@@ -5,15 +5,16 @@
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP, HASH_LEN,
+/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
USE_DICTIONARY
*/
#define HashLongestMatchQuickly HASHER()
#define BUCKET_SIZE (1 << BUCKET_BITS)
-
-#define HASH_MAP_SIZE (4 << BUCKET_BITS)
+#define BUCKET_MASK (BUCKET_SIZE - 1)
+#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
+#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
@@ -32,39 +33,50 @@ static uint32_t FN(HashBytes)(const uint8_t* data) {
/* A (forgetful) hash table to the data seen by the compressor, to
help create backward references to previous data.
- This is a hash map of fixed size (BUCKET_SIZE). Starting from the
- given index, BUCKET_SWEEP buckets are used to store values of a key. */
+ This is a hash map of fixed size (BUCKET_SIZE). */
typedef struct HashLongestMatchQuickly {
- uint32_t buckets_[BUCKET_SIZE + BUCKET_SWEEP];
-} HashLongestMatchQuickly;
+ /* Shortcuts. */
+ HasherCommon* common;
-static BROTLI_INLINE HashLongestMatchQuickly* FN(Self)(HasherHandle handle) {
- return (HashLongestMatchQuickly*)&(GetHasherCommon(handle)[1]);
-}
+ /* --- Dynamic size members --- */
+
+ uint32_t* buckets_; /* uint32_t[BUCKET_SIZE]; */
+} HashLongestMatchQuickly;
static void FN(Initialize)(
- HasherHandle handle, const BrotliEncoderParams* params) {
- BROTLI_UNUSED(handle);
+ HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ const BrotliEncoderParams* params) {
+ self->common = common;
+
BROTLI_UNUSED(params);
+ self->buckets_ = (uint32_t*)common->extra;
}
-static void FN(Prepare)(HasherHandle handle, BROTLI_BOOL one_shot,
- size_t input_size, const uint8_t* data) {
- HashLongestMatchQuickly* self = FN(Self)(handle);
+static void FN(Prepare)(
+ HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+ size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+ uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
/* Partial preparation is 100 times slower (per socket). */
- size_t partial_prepare_threshold = HASH_MAP_SIZE >> 7;
+ size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
if (one_shot && input_size <= partial_prepare_threshold) {
size_t i;
for (i = 0; i < input_size; ++i) {
const uint32_t key = FN(HashBytes)(&data[i]);
- memset(&self->buckets_[key], 0, BUCKET_SWEEP * sizeof(self->buckets_[0]));
+ if (BUCKET_SWEEP == 1) {
+ buckets[key] = 0;
+ } else {
+ uint32_t j;
+ for (j = 0; j < BUCKET_SWEEP; ++j) {
+ buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
+ }
+ }
}
} else {
/* It is not strictly necessary to fill this buffer here, but
not filling will make the results of the compression stochastic
(but correct). This is because random data would cause the
system to find accidentally good backward references here and there. */
- memset(&self->buckets_[0], 0, sizeof(self->buckets_));
+ memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
}
}
@@ -74,45 +86,53 @@ static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
BROTLI_UNUSED(params);
BROTLI_UNUSED(one_shot);
BROTLI_UNUSED(input_size);
- return sizeof(HashLongestMatchQuickly);
+ return sizeof(uint32_t) * BUCKET_SIZE;
}
/* Look at 5 bytes at &data[ix & mask].
Compute a hash from these, and store the value somewhere within
[ix .. ix+3]. */
-static BROTLI_INLINE void FN(Store)(HasherHandle handle,
- const uint8_t* data, const size_t mask, const size_t ix) {
+static BROTLI_INLINE void FN(Store)(
+ HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
const uint32_t key = FN(HashBytes)(&data[ix & mask]);
- /* Wiggle the value with the bucket sweep range. */
- const uint32_t off = (ix >> 3) % BUCKET_SWEEP;
- FN(Self)(handle)->buckets_[key + off] = (uint32_t)ix;
+ if (BUCKET_SWEEP == 1) {
+ self->buckets_[key] = (uint32_t)ix;
+ } else {
+ /* Wiggle the value with the bucket sweep range. */
+ const uint32_t off = ix & BUCKET_SWEEP_MASK;
+ self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
+ }
}
-static BROTLI_INLINE void FN(StoreRange)(HasherHandle handle,
- const uint8_t* data, const size_t mask, const size_t ix_start,
- const size_t ix_end) {
+static BROTLI_INLINE void FN(StoreRange)(
+ HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+ const size_t ix_start, const size_t ix_end) {
size_t i;
for (i = ix_start; i < ix_end; ++i) {
- FN(Store)(handle, data, mask, i);
+ FN(Store)(self, data, mask, i);
}
}
static BROTLI_INLINE void FN(StitchToPreviousBlock)(
- HasherHandle handle, size_t num_bytes, size_t position,
+ HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ size_t num_bytes, size_t position,
const uint8_t* ringbuffer, size_t ringbuffer_mask) {
if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
/* Prepare the hashes for three last bytes of the last write.
These could not be calculated before, since they require knowledge
of both the previous and the current block. */
- FN(Store)(handle, ringbuffer, ringbuffer_mask, position - 3);
- FN(Store)(handle, ringbuffer, ringbuffer_mask, position - 2);
- FN(Store)(handle, ringbuffer, ringbuffer_mask, position - 1);
+ FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
+ FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
+ FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
}
}
static BROTLI_INLINE void FN(PrepareDistanceCache)(
- HasherHandle handle, int* BROTLI_RESTRICT distance_cache) {
- BROTLI_UNUSED(handle);
+ HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ int* BROTLI_RESTRICT distance_cache) {
+ BROTLI_UNUSED(self);
BROTLI_UNUSED(distance_cache);
}
@@ -125,17 +145,19 @@ static BROTLI_INLINE void FN(PrepareDistanceCache)(
Writes the best match into |out|.
|out|->score is updated only if a better match is found. */
static BROTLI_INLINE void FN(FindLongestMatch)(
- HasherHandle handle, const BrotliEncoderDictionary* dictionary,
+ HashLongestMatchQuickly* BROTLI_RESTRICT self,
+ const BrotliEncoderDictionary* dictionary,
const uint8_t* BROTLI_RESTRICT data,
const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
const size_t cur_ix, const size_t max_length, const size_t max_backward,
- const size_t gap, const size_t max_distance,
+ const size_t dictionary_distance, const size_t max_distance,
HasherSearchResult* BROTLI_RESTRICT out) {
- HashLongestMatchQuickly* self = FN(Self)(handle);
+ uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
const size_t best_len_in = out->len;
const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
- const uint32_t key = FN(HashBytes)(&data[cur_ix_masked]);
int compare_char = data[cur_ix_masked + best_len_in];
+ size_t key = FN(HashBytes)(&data[cur_ix_masked]);
+ size_t key_out;
score_t min_score = out->score;
score_t best_score = out->score;
size_t best_len = best_len_in;
@@ -145,21 +167,21 @@ static BROTLI_INLINE void FN(FindLongestMatch)(
if (prev_ix < cur_ix) {
prev_ix &= (uint32_t)ring_buffer_mask;
if (compare_char == data[prev_ix + best_len]) {
- size_t len = FindMatchLengthWithLimit(&data[prev_ix],
- &data[cur_ix_masked],
- max_length);
+ const size_t len = FindMatchLengthWithLimit(
+ &data[prev_ix], &data[cur_ix_masked], max_length);
if (len >= 4) {
const score_t score = BackwardReferenceScoreUsingLastDistance(len);
if (best_score < score) {
- best_score = score;
- best_len = len;
out->len = len;
out->distance = cached_backward;
- out->score = best_score;
- compare_char = data[cur_ix_masked + best_len];
+ out->score = score;
if (BUCKET_SWEEP == 1) {
- self->buckets_[key] = (uint32_t)cur_ix;
+ buckets[key] = (uint32_t)cur_ix;
return;
+ } else {
+ best_len = len;
+ best_score = score;
+ compare_char = data[cur_ix_masked + len];
}
}
}
@@ -169,8 +191,8 @@ static BROTLI_INLINE void FN(FindLongestMatch)(
size_t backward;
size_t len;
/* Only one to look for, don't bother to prepare for a loop. */
- prev_ix = self->buckets_[key];
- self->buckets_[key] = (uint32_t)cur_ix;
+ prev_ix = buckets[key];
+ buckets[key] = (uint32_t)cur_ix;
backward = cur_ix - prev_ix;
prev_ix &= (uint32_t)ring_buffer_mask;
if (compare_char != data[prev_ix + best_len_in]) {
@@ -192,12 +214,17 @@ static BROTLI_INLINE void FN(FindLongestMatch)(
}
}
} else {
- uint32_t* bucket = self->buckets_ + key;
- int i;
- prev_ix = *bucket++;
- for (i = 0; i < BUCKET_SWEEP; ++i, prev_ix = *bucket++) {
- const size_t backward = cur_ix - prev_ix;
+ size_t keys[BUCKET_SWEEP];
+ size_t i;
+ for (i = 0; i < BUCKET_SWEEP; ++i) {
+ keys[i] = (key + (i << 3)) & BUCKET_MASK;
+ }
+ key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
+ for (i = 0; i < BUCKET_SWEEP; ++i) {
size_t len;
+ size_t backward;
+ prev_ix = buckets[keys[i]];
+ backward = cur_ix - prev_ix;
prev_ix &= (uint32_t)ring_buffer_mask;
if (compare_char != data[prev_ix + best_len]) {
continue;
@@ -211,25 +238,29 @@ static BROTLI_INLINE void FN(FindLongestMatch)(
if (len >= 4) {
const score_t score = BackwardReferenceScore(len, backward);
if (best_score < score) {
- best_score = score;
best_len = len;
- out->len = best_len;
- out->distance = backward;
+ out->len = len;
+ compare_char = data[cur_ix_masked + len];
+ best_score = score;
out->score = score;
- compare_char = data[cur_ix_masked + best_len];
+ out->distance = backward;
}
}
}
}
if (USE_DICTIONARY && min_score == out->score) {
SearchInStaticDictionary(dictionary,
- handle, &data[cur_ix_masked], max_length, max_backward + gap,
+ self->common, &data[cur_ix_masked], max_length, dictionary_distance,
max_distance, out, BROTLI_TRUE);
}
- self->buckets_[key + ((cur_ix >> 3) % BUCKET_SWEEP)] = (uint32_t)cur_ix;
+ if (BUCKET_SWEEP != 1) {
+ buckets[key_out] = (uint32_t)cur_ix;
+ }
}
-#undef HASH_MAP_SIZE
+#undef BUCKET_SWEEP_MASK
+#undef BUCKET_SWEEP
+#undef BUCKET_MASK
#undef BUCKET_SIZE
#undef HashLongestMatchQuickly