openstack/deb-libisal
Code Issues Proposed changes

igzip: Remove BITBUF8 and BITBUF_ELSE compile options

Browse Source 
Change-Id: Iad3b2e6f9a32473b6e59910494c75d82558fc28e
Signed-off-by: Roy Oursler <roy.j.oursler@intel.com>
This commit is contained in:
Roy Oursler 2017-05-25 10:06:34 -07:00 committed by Xiaodong Liu
parent edacadc8fb
commit f4a5b303e2
4 changed files with 21 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
igzip/bitbuf2.asm
View File

@ -33,156 +33,6 @@
; Clobbers RCX
; code is clobbered
; write_bits_always m_bits, m_bit_count, code, count, m_out_buf, tmp1
%macro write_bits_always 6
%define %%m_bits %1
%define %%m_bit_count %2
%define %%code %3
%define %%count %4
%define %%m_out_buf %5
%define %%tmp1 %6
%ifdef USE_HSWNI
shlx %%code, %%code, %%m_bit_count
%else
mov rcx, %%m_bit_count
shl %%code, cl
%endif
or %%m_bits, %%code
add %%m_bit_count, %%count
movnti [%%m_out_buf], %%m_bits
mov rcx, %%m_bit_count
shr rcx, 3 ; rcx = bytes
add %%m_out_buf, rcx
shl rcx, 3 ; rcx = bits
sub %%m_bit_count, rcx
%ifdef USE_HSWNI
shrx %%m_bits, %%m_bits, rcx
%else
shr %%m_bits, cl
%endif
%endm
; Assumes m_out_buf is a register
; Clobbers RCX
; code is clobbered
; write_bits_safe m_bits, m_bit_count, code, count, m_out_buf, tmp1
%macro write_bits_safe 6
%define %%m_bits %1
%define %%m_bit_count %2
%define %%code %3
%define %%count %4
%define %%m_out_buf %5
%define %%tmp1 %6
mov %%tmp1, %%code
%ifdef USE_HSWNI
shlx %%tmp1, %%tmp1, %%m_bit_count
%else
mov rcx, %%m_bit_count
shl %%tmp1, cl
%endif
or %%m_bits, %%tmp1
add %%m_bit_count, %%count
cmp %%m_bit_count, 64
jb %%not_full
sub %%m_bit_count, 64
movnti [%%m_out_buf], %%m_bits
add %%m_out_buf, 8
mov rcx, %%count
sub rcx, %%m_bit_count
mov %%m_bits, %%code
%ifdef USE_HSWNI
shrx %%m_bits, %%m_bits, rcx
%else
shr %%m_bits, cl
%endif
%%not_full:
%endm
; Assumes m_out_buf is a register
; Clobbers RCX
;; check_space num_bits, m_bits, m_bit_count, m_out_buf, tmp1
%macro check_space 5
%define %%num_bits %1
%define %%m_bits %2
%define %%m_bit_count %3
%define %%m_out_buf %4
%define %%tmp1 %5
mov %%tmp1, 63
sub %%tmp1, %%m_bit_count
cmp %%tmp1, %%num_bits
jae %%space_ok
; if (63 - m_bit_count < num_bits)
movnti [%%m_out_buf], %%m_bits
mov rcx, %%m_bit_count
shr rcx, 3 ; rcx = bytes
add %%m_out_buf, rcx
shl rcx, 3 ; rcx = bits
sub %%m_bit_count, rcx
%ifdef USE_HSWNI
shrx %%m_bits, %%m_bits, rcx
%else
shr %%m_bits, cl
%endif
%%space_ok:
%endm
; rcx is clobbered
; code is clobbered
; write_bits_unsafe m_bits, m_bit_count, code, count
%macro write_bits_unsafe 4
%define %%m_bits %1
%define %%m_bit_count %2
%define %%code %3
%define %%count %4
%ifdef USE_HSWNI
shlx %%code, %%code, %%m_bit_count
%else
mov rcx, %%m_bit_count
shl %%code, cl
%endif
or %%m_bits, %%code
add %%m_bit_count, %%count
%endm
; pad_to_byte m_bit_count, extra_bits
%macro pad_to_byte 2
%define %%m_bit_count %1
%define %%extra_bits %2
mov %%extra_bits, %%m_bit_count
neg %%extra_bits
and %%extra_bits, 7
add %%m_bit_count, %%extra_bits
%endm
; Assumes m_out_buf is a memory reference
; flush m_bits, m_bit_count, m_out_buf, tmp1
%macro flush 4
%define %%m_bits %1
%define %%m_bit_count %2
%define %%m_out_buf %3
%define %%tmp1 %4
test %%m_bit_count, %%m_bit_count
jz %%bit_count_is_zero
mov %%tmp1, %%m_out_buf
movnti [%%tmp1], %%m_bits
add %%m_bit_count, 7
shr %%m_bit_count, 3 ; bytes
add %%tmp1, %%m_bit_count
mov %%m_out_buf, %%tmp1
%%bit_count_is_zero:
xor %%m_bits, %%m_bits
xor %%m_bit_count, %%m_bit_count
%endm
%macro write_bits 6
%define %%m_bits %1
%define %%m_bit_count %2
@ -191,16 +41,25 @@
%define %%m_out_buf %5
%define %%tmp1 %6
%ifdef USE_BITBUF8
write_bits_safe %%m_bits, %%m_bit_count, %%code, %%count, %%m_out_buf, %%tmp1
%elifdef USE_BITBUFB
write_bits_always %%m_bits, %%m_bit_count, %%code, %%count, %%m_out_buf, %%tmp1
%ifdef USE_HSWNI
shlx %%code, %%code, %%m_bit_count
%else
; state->bitbuf.check_space(code_len2);
check_space %%count, %%m_bits, %%m_bit_count, %%m_out_buf, %%tmp1
; state->bitbuf.write_bits(code2, code_len2);
write_bits_unsafe %%m_bits, %%m_bit_count, %%code, %%count
; code2 is clobbered, rcx is clobbered
mov rcx, %%m_bit_count
shl %%code, cl
%endif
or %%m_bits, %%code
add %%m_bit_count, %%count
movnti [%%m_out_buf], %%m_bits
mov rcx, %%m_bit_count
shr rcx, 3 ; rcx = bytes
add %%m_out_buf, rcx
shl rcx, 3 ; rcx = bits
sub %%m_bit_count, rcx
%ifdef USE_HSWNI
shrx %%m_bits, %%m_bits, rcx
%else
shr %%m_bits, cl
%endif
%endm

44
igzip/bitbuf2.h
View File

@ -31,14 +31,6 @@
#include "igzip_lib.h"
/* bit buffer types
* BITBUF8: (e) Always write 8 bytes of data
* BITBUFB: (b) Always write data
*/
#if !(defined(USE_BITBUFB) || defined(USE_BITBUF8) || defined(USE_BITBUF_ELSE))
# define USE_BITBUFB
#endif
#if defined (__unix__) || (__APPLE__) || (__MINGW32__)
#define _mm_stream_si64x(dst, src) *((uint64_t*)dst) = src
#else
@ -57,22 +49,7 @@
/* MAX_BITBUF_BIT WRITE is the maximum number of bits than can be safely written
* by consecutive calls of write_bits. Note this assumes the bitbuf is in a
* state that is possible at the exit of write_bits */
#ifdef USE_BITBUF8 /*Write bits safe */
# define MAX_BITBUF_BIT_WRITE 63
#elif defined(USE_BITBUFB) /* Write bits always */
# define MAX_BITBUF_BIT_WRITE 56
#else /* USE_BITBUF_ELSE */
# define MAX_BITBUF_BIT_WRITE 56
#endif
static
inline void construct(struct BitBuf2 *me)
{
me->m_bits = 0;
me->m_bit_count = 0;
me->m_out_buf = me->m_out_start = me->m_out_end = NULL;
}
#define MAX_BITBUF_BIT_WRITE 56
static inline void init(struct BitBuf2 *me)
{
@ -133,27 +110,10 @@ static inline void write_bits_unsafe(struct BitBuf2 *me, uint64_t code, uint32_t
}
static inline void write_bits(struct BitBuf2 *me, uint64_t code, uint32_t count)
{
#ifdef USE_BITBUF8 /*Write bits safe */
{ /* Assumes there is space to fit code into m_bits. */
me->m_bits |= code << me->m_bit_count;
me->m_bit_count += count;
if (me->m_bit_count >= 64) {
_mm_stream_si64x((int64_t *) me->m_out_buf, me->m_bits);
me->m_out_buf += 8;
me->m_bit_count -= 64;
me->m_bits = code >> (count - me->m_bit_count);
}
#elif defined(USE_BITBUFB) /* Write bits always */
/* Assumes there is space to fit code into m_bits. */
me->m_bits |= code << me->m_bit_count;
me->m_bit_count += count;
if (me->m_bit_count >= 8)
flush_bits(me);
#else /* USE_BITBUF_ELSE */
check_space(me, count);
write_bits_unsafe(me, code, count);
#endif
}
/* Can write up to 8 bytes to output buffer */

9
igzip/igzip.c
View File

@ -158,11 +158,7 @@ void sync_flush(struct isal_zstream *stream)
bits_to_write <<= flush_size + 3;
bits_len = 32 + flush_size + 3;
#ifdef USE_BITBUFB /* Write Bits Always */
state->state = ZSTATE_NEW_HDR;
#else /* Not Write Bits Always */
state->state = ZSTATE_FLUSH_WRITE_BUFFER;
#endif
state->has_eob = 0;
write_bits(&state->bitbuf, bits_to_write, bits_len);
@ -204,11 +200,6 @@ static void flush_icf_block(struct isal_zstream *stream)
set_buf(write_buf, stream->next_out, stream->avail_out);
#if defined (USE_BITBUF8) || (USE_BITBUF_ELSE)
if (!is_full(write_buf))
flush_bits(write_buf);
#endif
icf_buf_encoded_next = encode_deflate_icf(level_buf->icf_buf_start + state->count,
level_buf->icf_buf_next, write_buf,
&level_buf->encode_tables);

9
igzip/options.asm
View File

@ -56,15 +56,6 @@ default rel
%endif
%endif
%ifdef USE_BITBUFB
%elifdef USE_BITBUF8
%elifdef USE_BITBUF_ELSE
%else
; bit buffer types
; BITBUFB: (b) Always write data
%define USE_BITBUFB
%endif
; (h) limit hash update
%define LIMIT_HASH_UPDATE