1
0
Fork 0
mirror of https://git.tukaani.org/xz.git synced 2024-04-04 12:36:23 +02:00

liblzma: Optimize literal_subcoder() macro slightly.

This commit is contained in:
Lasse Collin 2024-02-12 17:09:10 +02:00
parent 5938f6de4d
commit 88276f9f2c
5 changed files with 24 additions and 22 deletions

View file

@ -125,31 +125,33 @@ typedef enum {
/// ///
/// Match byte is used when the previous LZMA symbol was something else than /// Match byte is used when the previous LZMA symbol was something else than
/// a literal (that is, it was some kind of match). /// a literal (that is, it was some kind of match).
#define LITERAL_CODER_SIZE 0x300 #define LITERAL_CODER_SIZE UINT32_C(0x300)
/// Maximum number of literal coders /// Maximum number of literal coders
#define LITERAL_CODERS_MAX (1 << LZMA_LCLP_MAX) #define LITERAL_CODERS_MAX (1 << LZMA_LCLP_MAX)
/// Calculates the literal_mask that literal_subcoder() needs.
#define literal_mask_calc(lc, lp) \
((UINT32_C(0x100) << (lp)) - (UINT32_C(0x100) >> (lc)))
/// Locate the literal coder for the next literal byte. The choice depends on /// Locate the literal coder for the next literal byte. The choice depends on
/// - the lowest literal_pos_bits bits of the position of the current /// - the lowest literal_pos_bits bits of the position of the current
/// byte; and /// byte; and
/// - the highest literal_context_bits bits of the previous byte. /// - the highest literal_context_bits bits of the previous byte.
#define literal_subcoder(probs, lc, lp_mask, pos, prev_byte) \ #define literal_subcoder(probs, lc, literal_mask, pos, prev_byte) \
((probs)[(((pos) & (lp_mask)) << (lc)) \ ((probs) + UINT32_C(3) * \
+ ((uint32_t)(prev_byte) >> (8U - (lc)))]) (((((pos) << 8) + (prev_byte)) & (literal_mask)) << (lc)))
static inline void static inline void
literal_init(probability (*probs)[LITERAL_CODER_SIZE], literal_init(probability *probs, uint32_t lc, uint32_t lp)
uint32_t lc, uint32_t lp)
{ {
assert(lc + lp <= LZMA_LCLP_MAX); assert(lc + lp <= LZMA_LCLP_MAX);
const uint32_t coders = 1U << (lc + lp); const size_t coders = LITERAL_CODER_SIZE << (lc + lp);
for (uint32_t i = 0; i < coders; ++i) for (size_t i = 0; i < coders; ++i)
for (uint32_t j = 0; j < LITERAL_CODER_SIZE; ++j) bit_reset(probs[i]);
bit_reset(probs[i][j]);
return; return;
} }

View file

@ -109,7 +109,7 @@ typedef struct {
/////////////////// ///////////////////
/// Literals; see comments in lzma_common.h. /// Literals; see comments in lzma_common.h.
probability literal[LITERAL_CODERS_MAX][LITERAL_CODER_SIZE]; probability literal[LITERAL_CODERS_MAX * LITERAL_CODER_SIZE];
/// If 1, it's a match. Otherwise it's a single 8-bit literal. /// If 1, it's a match. Otherwise it's a single 8-bit literal.
probability is_match[STATES][POS_STATES_MAX]; probability is_match[STATES][POS_STATES_MAX];
@ -168,7 +168,7 @@ typedef struct {
uint32_t pos_mask; // (1U << pb) - 1 uint32_t pos_mask; // (1U << pb) - 1
uint32_t literal_context_bits; uint32_t literal_context_bits;
uint32_t literal_pos_mask; uint32_t literal_mask;
/// Uncompressed size as bytes, or LZMA_VLI_UNKNOWN if end of /// Uncompressed size as bytes, or LZMA_VLI_UNKNOWN if end of
/// payload marker is expected. /// payload marker is expected.
@ -280,7 +280,7 @@ lzma_decode(void *coder_ptr, lzma_dict *restrict dictptr,
uint32_t offset = coder->offset; uint32_t offset = coder->offset;
uint32_t len = coder->len; uint32_t len = coder->len;
const uint32_t literal_pos_mask = coder->literal_pos_mask; const uint32_t literal_mask = coder->literal_mask;
const uint32_t literal_context_bits = coder->literal_context_bits; const uint32_t literal_context_bits = coder->literal_context_bits;
// Temporary variables // Temporary variables
@ -359,7 +359,7 @@ lzma_decode(void *coder_ptr, lzma_dict *restrict dictptr,
// Get the correct probability array from lp and // Get the correct probability array from lp and
// lc params. // lc params.
probs = literal_subcoder(coder->literal, probs = literal_subcoder(coder->literal,
literal_context_bits, literal_pos_mask, literal_context_bits, literal_mask,
dict.pos, dict_get0(&dict)); dict.pos, dict_get0(&dict));
if (is_literal_state(state)) { if (is_literal_state(state)) {
@ -684,7 +684,7 @@ slow:
rc_update_0(coder->is_match[state][pos_state]); rc_update_0(coder->is_match[state][pos_state]);
probs = literal_subcoder(coder->literal, probs = literal_subcoder(coder->literal,
literal_context_bits, literal_pos_mask, literal_context_bits, literal_mask,
dict.pos, dict_get0(&dict)); dict.pos, dict_get0(&dict));
symbol = 1; symbol = 1;
@ -1034,7 +1034,7 @@ lzma_decoder_reset(void *coder_ptr, const void *opt)
literal_init(coder->literal, options->lc, options->lp); literal_init(coder->literal, options->lc, options->lp);
coder->literal_context_bits = options->lc; coder->literal_context_bits = options->lc;
coder->literal_pos_mask = (1U << options->lp) - 1; coder->literal_mask = literal_mask_calc(options->lc, options->lp);
// State // State
coder->state = STATE_LIT_LIT; coder->state = STATE_LIT_LIT;

View file

@ -48,7 +48,7 @@ literal(lzma_lzma1_encoder *coder, lzma_mf *mf, uint32_t position)
const uint8_t cur_byte = mf->buffer[ const uint8_t cur_byte = mf->buffer[
mf->read_pos - mf->read_ahead]; mf->read_pos - mf->read_ahead];
probability *subcoder = literal_subcoder(coder->literal, probability *subcoder = literal_subcoder(coder->literal,
coder->literal_context_bits, coder->literal_pos_mask, coder->literal_context_bits, coder->literal_mask,
position, mf->buffer[mf->read_pos - mf->read_ahead - 1]); position, mf->buffer[mf->read_pos - mf->read_ahead - 1]);
if (is_literal_state(coder->state)) { if (is_literal_state(coder->state)) {
@ -282,7 +282,7 @@ encode_init(lzma_lzma1_encoder *coder, lzma_mf *mf)
mf_skip(mf, 1); mf_skip(mf, 1);
mf->read_ahead = 0; mf->read_ahead = 0;
rc_bit(&coder->rc, &coder->is_match[0][0], 0); rc_bit(&coder->rc, &coder->is_match[0][0], 0);
rc_bittree(&coder->rc, coder->literal[0], 8, mf->buffer[0]); rc_bittree(&coder->rc, coder->literal + 0, 8, mf->buffer[0]);
++coder->uncomp_size; ++coder->uncomp_size;
} }
@ -534,7 +534,7 @@ lzma_lzma_encoder_reset(lzma_lzma1_encoder *coder,
coder->pos_mask = (1U << options->pb) - 1; coder->pos_mask = (1U << options->pb) - 1;
coder->literal_context_bits = options->lc; coder->literal_context_bits = options->lc;
coder->literal_pos_mask = (1U << options->lp) - 1; coder->literal_mask = literal_mask_calc(options->lc, options->lp);
// Range coder // Range coder
rc_reset(&coder->rc); rc_reset(&coder->rc);

View file

@ -23,7 +23,7 @@ get_literal_price(const lzma_lzma1_encoder *const coder, const uint32_t pos,
uint32_t match_byte, uint32_t symbol) uint32_t match_byte, uint32_t symbol)
{ {
const probability *const subcoder = literal_subcoder(coder->literal, const probability *const subcoder = literal_subcoder(coder->literal,
coder->literal_context_bits, coder->literal_pos_mask, coder->literal_context_bits, coder->literal_mask,
pos, prev_byte); pos, prev_byte);
uint32_t price = 0; uint32_t price = 0;

View file

@ -115,10 +115,10 @@ struct lzma_lzma1_encoder_s {
uint32_t pos_mask; ///< (1 << pos_bits) - 1 uint32_t pos_mask; ///< (1 << pos_bits) - 1
uint32_t literal_context_bits; uint32_t literal_context_bits;
uint32_t literal_pos_mask; uint32_t literal_mask;
// These are the same as in lzma_decoder.c. See comments there. // These are the same as in lzma_decoder.c. See comments there.
probability literal[LITERAL_CODERS_MAX][LITERAL_CODER_SIZE]; probability literal[LITERAL_CODERS_MAX * LITERAL_CODER_SIZE];
probability is_match[STATES][POS_STATES_MAX]; probability is_match[STATES][POS_STATES_MAX];
probability is_rep[STATES]; probability is_rep[STATES];
probability is_rep0[STATES]; probability is_rep0[STATES];