generic-library/isa-l
1
0
Fork 0
mirror of https://github.com/intel/isa-l.git synced 2024-12-12 09:23:50 +01:00
Code Issues Projects Releases Wiki Activity

igzip: reformat using new code style

Browse Source 
Signed-off-by: Marcel Cornu <marcel.d.cornu@intel.com>
This commit is contained in:
Marcel Cornu 2024-04-19 17:09:21 +01:00 committed by Pablo de Lara
parent 9d99f8215d
commit 55fbfabfc6
39 changed files with 20000 additions and 22325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
igzip/aarch64/igzip_multibinary_aarch64_dispatcher.c
View File

@ -31,221 +31,215 @@
DEFINE_INTERFACE_DISPATCHER(isal_adler32) DEFINE_INTERFACE_DISPATCHER(isal_adler32)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_ASIMD) if (auxval & HWCAP_ASIMD)
return PROVIDER_INFO(adler32_neon); return PROVIDER_INFO(adler32_neon);
#elif defined(__APPLE__) #elif defined(__APPLE__)
return PROVIDER_INFO(adler32_neon); return PROVIDER_INFO(adler32_neon);
#endif #endif
return PROVIDER_BASIC(adler32); return PROVIDER_BASIC(adler32);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_body) DEFINE_INTERFACE_DISPATCHER(isal_deflate_body)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_body_aarch64); return PROVIDER_INFO(isal_deflate_body_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_body_aarch64); return PROVIDER_INFO(isal_deflate_body_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_body); return PROVIDER_BASIC(isal_deflate_body);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_finish) DEFINE_INTERFACE_DISPATCHER(isal_deflate_finish)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_finish_aarch64); return PROVIDER_INFO(isal_deflate_finish_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_finish_aarch64); return PROVIDER_INFO(isal_deflate_finish_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_finish); return PROVIDER_BASIC(isal_deflate_finish);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl1) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl1)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_icf_body_hash_hist); return PROVIDER_BASIC(isal_deflate_icf_body_hash_hist);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl1) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl1)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_icf_finish_hash_hist); return PROVIDER_BASIC(isal_deflate_icf_finish_hash_hist);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl2) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl2)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_body_hash_hist_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_icf_body_hash_hist); return PROVIDER_BASIC(isal_deflate_icf_body_hash_hist);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl2) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl2)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64); return PROVIDER_INFO(isal_deflate_icf_finish_hash_hist_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_icf_finish_hash_hist); return PROVIDER_BASIC(isal_deflate_icf_finish_hash_hist);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl3) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_body_lvl3)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy); return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy); return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy);
#endif #endif
return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy); return PROVIDER_INFO(icf_body_hash1_fillgreedy_lazy);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl3) DEFINE_INTERFACE_DISPATCHER(isal_deflate_icf_finish_lvl3)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_icf_finish_hash_map_base); return PROVIDER_INFO(isal_deflate_icf_finish_hash_map_base);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_icf_finish_hash_map_base); return PROVIDER_INFO(isal_deflate_icf_finish_hash_map_base);
#endif #endif
return PROVIDER_BASIC(isal_deflate_icf_finish_hash_map); return PROVIDER_BASIC(isal_deflate_icf_finish_hash_map);
} }
DEFINE_INTERFACE_DISPATCHER(set_long_icf_fg) DEFINE_INTERFACE_DISPATCHER(set_long_icf_fg) { return PROVIDER_INFO(set_long_icf_fg_aarch64); }
{
return PROVIDER_INFO(set_long_icf_fg_aarch64);
}
DEFINE_INTERFACE_DISPATCHER(encode_deflate_icf) DEFINE_INTERFACE_DISPATCHER(encode_deflate_icf)
{ {
return PROVIDER_INFO(encode_deflate_icf_aarch64); return PROVIDER_INFO(encode_deflate_icf_aarch64);
} }
DEFINE_INTERFACE_DISPATCHER(isal_update_histogram) DEFINE_INTERFACE_DISPATCHER(isal_update_histogram)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_update_histogram_aarch64); return PROVIDER_INFO(isal_update_histogram_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_update_histogram_aarch64); return PROVIDER_INFO(isal_update_histogram_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_update_histogram); return PROVIDER_BASIC(isal_update_histogram);
} }
DEFINE_INTERFACE_DISPATCHER(gen_icf_map_lh1) DEFINE_INTERFACE_DISPATCHER(gen_icf_map_lh1)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) { if (auxval & HWCAP_CRC32) {
return PROVIDER_INFO(gen_icf_map_h1_aarch64); return PROVIDER_INFO(gen_icf_map_h1_aarch64);
} }
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(gen_icf_map_h1_aarch64); return PROVIDER_INFO(gen_icf_map_h1_aarch64);
#endif #endif
return PROVIDER_BASIC(gen_icf_map_h1); return PROVIDER_BASIC(gen_icf_map_h1);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl0) DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl0)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_hash); return PROVIDER_BASIC(isal_deflate_hash);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl1) DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl1)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_hash); return PROVIDER_BASIC(isal_deflate_hash);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl2) DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl2)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_hash); return PROVIDER_BASIC(isal_deflate_hash);
} }
DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl3) DEFINE_INTERFACE_DISPATCHER(isal_deflate_hash_lvl3)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(isal_deflate_hash_aarch64); return PROVIDER_INFO(isal_deflate_hash_aarch64);
#endif #endif
return PROVIDER_BASIC(isal_deflate_hash); return PROVIDER_BASIC(isal_deflate_hash);
} }
DEFINE_INTERFACE_DISPATCHER(decode_huffman_code_block_stateless) DEFINE_INTERFACE_DISPATCHER(decode_huffman_code_block_stateless)
{ {
#if defined(__linux__) #if defined(__linux__)
unsigned long auxval = getauxval(AT_HWCAP); unsigned long auxval = getauxval(AT_HWCAP);
if (auxval & HWCAP_CRC32) if (auxval & HWCAP_CRC32)
return PROVIDER_INFO(decode_huffman_code_block_stateless_aarch64); return PROVIDER_INFO(decode_huffman_code_block_stateless_aarch64);
#elif defined(__APPLE__) #elif defined(__APPLE__)
if (sysctlEnabled(SYSCTL_CRC32_KEY)) if (sysctlEnabled(SYSCTL_CRC32_KEY))
return PROVIDER_INFO(decode_huffman_code_block_stateless_aarch64); return PROVIDER_INFO(decode_huffman_code_block_stateless_aarch64);
#endif #endif
return PROVIDER_BASIC(decode_huffman_code_block_stateless); return PROVIDER_BASIC(decode_huffman_code_block_stateless);
} }

47
igzip/adler32_base.c
View File

@ -30,34 +30,35 @@
#include <stdint.h> #include <stdint.h>
#include "igzip_checksums.h" #include "igzip_checksums.h"
uint32_t adler32_base(uint32_t adler32, uint8_t * start, uint32_t length) uint32_t
adler32_base(uint32_t adler32, uint8_t *start, uint32_t length)
{ {
uint8_t *end, *next = start; uint8_t *end, *next = start;
uint64_t A, B; uint64_t A, B;
A = adler32 & 0xffff; A = adler32 & 0xffff;
B = adler32 >> 16; B = adler32 >> 16;
while (length > MAX_ADLER_BUF) { while (length > MAX_ADLER_BUF) {
end = next + MAX_ADLER_BUF; end = next + MAX_ADLER_BUF;
for (; next < end; next++) { for (; next < end; next++) {
A += *next; A += *next;
B += A; B += A;
} }
A = A % ADLER_MOD; A = A % ADLER_MOD;
B = B % ADLER_MOD; B = B % ADLER_MOD;
length -= MAX_ADLER_BUF; length -= MAX_ADLER_BUF;
} }
end = next + length; end = next + length;
for (; next < end; next++) { for (; next < end; next++) {
A += *next; A += *next;
B += A; B += A;
} }
A = A % ADLER_MOD; A = A % ADLER_MOD;
B = B % ADLER_MOD; B = B % ADLER_MOD;
return B << 16 | A; return B << 16 | A;
} }

41
igzip/adler32_perf.c
View File

@ -35,40 +35,41 @@
#include "test.h" #include "test.h"
#ifndef GT_L3_CACHE #ifndef GT_L3_CACHE
# define GT_L3_CACHE 32*1024*1024 /* some number > last level cache */ #define GT_L3_CACHE 32 * 1024 * 1024 /* some number > last level cache */
#endif #endif
#if !defined(COLD_TEST) && !defined(TEST_CUSTOM) #if !defined(COLD_TEST) && !defined(TEST_CUSTOM)
// Cached test, loop many times over small dataset // Cached test, loop many times over small dataset
# define TEST_LEN 8*1024 #define TEST_LEN 8 * 1024
# define TEST_TYPE_STR "_warm" #define TEST_TYPE_STR "_warm"
#elif defined (COLD_TEST) #elif defined(COLD_TEST)
// Uncached test. Pull from large mem base. // Uncached test. Pull from large mem base.
# define TEST_LEN (2 * GT_L3_CACHE) #define TEST_LEN (2 * GT_L3_CACHE)
# define TEST_TYPE_STR "_cold" #define TEST_TYPE_STR "_cold"
#endif #endif
#ifndef TEST_SEED #ifndef TEST_SEED
#define TEST_SEED 0x1234 #define TEST_SEED 0x1234
#endif #endif
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
void *buf; void *buf;
uint32_t checksum = 0; uint32_t checksum = 0;
struct perf start; struct perf start;
printf("adler32_perf:\n"); printf("adler32_perf:\n");
if (posix_memalign(&buf, 1024, TEST_LEN)) { if (posix_memalign(&buf, 1024, TEST_LEN)) {
printf("alloc error: Fail"); printf("alloc error: Fail");
return -1; return -1;
} }
memset(buf, 0, TEST_LEN); memset(buf, 0, TEST_LEN);
BENCHMARK(&start, BENCHMARK_TIME, checksum |= isal_adler32(TEST_SEED, buf, TEST_LEN)); BENCHMARK(&start, BENCHMARK_TIME, checksum |= isal_adler32(TEST_SEED, buf, TEST_LEN));
printf("adler32" TEST_TYPE_STR ": "); printf("adler32" TEST_TYPE_STR ": ");
perf_print(start, (long long)TEST_LEN); perf_print(start, (long long) TEST_LEN);
return 0; return 0;
} }

113
igzip/bitbuf2.h
View File

@ -41,89 +41,100 @@
* state that is possible at the exit of write_bits */ * state that is possible at the exit of write_bits */
#define MAX_BITBUF_BIT_WRITE 56 #define MAX_BITBUF_BIT_WRITE 56
static inline void init(struct BitBuf2 *me) static inline void
init(struct BitBuf2 *me)
{ {
me->m_bits = 0; me->m_bits = 0;
me->m_bit_count = 0; me->m_bit_count = 0;
} }
static inline void set_buf(struct BitBuf2 *me, unsigned char *buf, unsigned int len) static inline void
set_buf(struct BitBuf2 *me, unsigned char *buf, unsigned int len)
{ {
unsigned int slop = 8; unsigned int slop = 8;
me->m_out_buf = me->m_out_start = buf; me->m_out_buf = me->m_out_start = buf;
me->m_out_end = buf + len - slop; me->m_out_end = buf + len - slop;
} }
static inline int is_full(struct BitBuf2 *me) static inline int
is_full(struct BitBuf2 *me)
{ {
return (me->m_out_buf > me->m_out_end); return (me->m_out_buf > me->m_out_end);
} }
static inline uint8_t *buffer_ptr(struct BitBuf2 *me) static inline uint8_t *
buffer_ptr(struct BitBuf2 *me)
{ {
return me->m_out_buf; return me->m_out_buf;
} }
static inline uint32_t buffer_used(struct BitBuf2 *me) static inline uint32_t
buffer_used(struct BitBuf2 *me)
{ {
return (uint32_t) (me->m_out_buf - me->m_out_start); return (uint32_t) (me->m_out_buf - me->m_out_start);
} }
static inline uint32_t buffer_bits_used(struct BitBuf2 *me) static inline uint32_t
buffer_bits_used(struct BitBuf2 *me)
{ {
return (8 * (uint32_t) (me->m_out_buf - me->m_out_start) + me->m_bit_count); return (8 * (uint32_t) (me->m_out_buf - me->m_out_start) + me->m_bit_count);
} }
static inline void flush_bits(struct BitBuf2 *me) static inline void
flush_bits(struct BitBuf2 *me)
{ {
uint32_t bits; uint32_t bits;
store_le_u64(me->m_out_buf, me->m_bits); store_le_u64(me->m_out_buf, me->m_bits);
bits = me->m_bit_count & ~7; bits = me->m_bit_count & ~7;
me->m_bit_count -= bits; me->m_bit_count -= bits;
me->m_out_buf += bits / 8; me->m_out_buf += bits / 8;
me->m_bits >>= bits; me->m_bits >>= bits;
} }
/* Can write up to 8 bytes to output buffer */ /* Can write up to 8 bytes to output buffer */
static inline void flush(struct BitBuf2 *me) static inline void
flush(struct BitBuf2 *me)
{ {
uint32_t bytes; uint32_t bytes;
if (me->m_bit_count) { if (me->m_bit_count) {
store_le_u64(me->m_out_buf, me->m_bits); store_le_u64(me->m_out_buf, me->m_bits);
bytes = (me->m_bit_count + 7) / 8; bytes = (me->m_bit_count + 7) / 8;
me->m_out_buf += bytes; me->m_out_buf += bytes;
} }
me->m_bits = 0; me->m_bits = 0;
me->m_bit_count = 0; me->m_bit_count = 0;
} }
static inline void check_space(struct BitBuf2 *me, uint32_t num_bits) static inline void
check_space(struct BitBuf2 *me, uint32_t num_bits)
{ {
/* Checks if bitbuf has num_bits extra space and flushes the bytes in /* Checks if bitbuf has num_bits extra space and flushes the bytes in
* the bitbuf if it doesn't. */ * the bitbuf if it doesn't. */
if (63 - me->m_bit_count < num_bits) if (63 - me->m_bit_count < num_bits)
flush_bits(me); flush_bits(me);
} }
static inline void write_bits_unsafe(struct BitBuf2 *me, uint64_t code, uint32_t count) static inline void
write_bits_unsafe(struct BitBuf2 *me, uint64_t code, uint32_t count)
{ {
me->m_bits |= code << me->m_bit_count; me->m_bits |= code << me->m_bit_count;
me->m_bit_count += count; me->m_bit_count += count;
} }
static inline void write_bits(struct BitBuf2 *me, uint64_t code, uint32_t count) static inline void
{ /* Assumes there is space to fit code into m_bits. */ write_bits(struct BitBuf2 *me, uint64_t code, uint32_t count)
me->m_bits |= code << me->m_bit_count; { /* Assumes there is space to fit code into m_bits. */
me->m_bit_count += count; me->m_bits |= code << me->m_bit_count;
flush_bits(me); me->m_bit_count += count;
flush_bits(me);
} }
static inline void write_bits_flush(struct BitBuf2 *me, uint64_t code, uint32_t count) static inline void
{ /* Assumes there is space to fit code into m_bits. */ write_bits_flush(struct BitBuf2 *me, uint64_t code, uint32_t count)
me->m_bits |= code << me->m_bit_count; { /* Assumes there is space to fit code into m_bits. */
me->m_bit_count += count; me->m_bits |= code << me->m_bit_count;
flush(me); me->m_bit_count += count;
flush(me);
} }
#endif //BITBUF2_H #endif // BITBUF2_H

411
igzip/checksum32_funcs_test.c
View File

@ -36,294 +36,307 @@
#include "test.h" #include "test.h"
#ifndef TEST_SEED #ifndef TEST_SEED
# define TEST_SEED 0x1234 #define TEST_SEED 0x1234
#endif #endif
#define MAX_BUF 512 #define MAX_BUF 512
#define TEST_SIZE 20 #define TEST_SIZE 20
typedef uint32_t(*checksum32_func_t) (uint32_t, const unsigned char *, uint64_t); typedef uint32_t (*checksum32_func_t)(uint32_t, const unsigned char *, uint64_t);
typedef struct func_case { typedef struct func_case {
char *note; char *note;
checksum32_func_t checksum32_func_call; checksum32_func_t checksum32_func_call;
checksum32_func_t checksum32_ref_call; checksum32_func_t checksum32_ref_call;
} func_case_t; } func_case_t;
func_case_t test_funcs[] = { func_case_t test_funcs[] = {
{"checksum32_adler", isal_adler32, adler_ref}, { "checksum32_adler", isal_adler32, adler_ref },
}; };
// Generates pseudo-random data // Generates pseudo-random data
void rand_buffer(unsigned char *buf, long buffer_size) void
rand_buffer(unsigned char *buf, long buffer_size)
{ {
long i; long i;
for (i = 0; i < buffer_size; i++) for (i = 0; i < buffer_size; i++)
buf[i] = rand(); buf[i] = rand();
} }
// Test cases // Test cases
int zeros_test(func_case_t * test_func); int
int simple_pattern_test(func_case_t * test_func); zeros_test(func_case_t *test_func);
int seeds_sizes_test(func_case_t * test_func); int
int eob_test(func_case_t * test_func); simple_pattern_test(func_case_t *test_func);
int update_test(func_case_t * test_func); int
int update_over_mod_test(func_case_t * test_func); seeds_sizes_test(func_case_t *test_func);
int
eob_test(func_case_t *test_func);
int
update_test(func_case_t *test_func);
int
update_over_mod_test(func_case_t *test_func);
void *buf_alloc = NULL; void *buf_alloc = NULL;
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
int fail = 0, fail_case; int fail = 0, fail_case;
int i, ret; int i, ret;
func_case_t *test_func; func_case_t *test_func;
// Align to MAX_BUF boundary // Align to MAX_BUF boundary
ret = posix_memalign(&buf_alloc, MAX_BUF, MAX_BUF * TEST_SIZE); ret = posix_memalign(&buf_alloc, MAX_BUF, MAX_BUF * TEST_SIZE);
if (ret) { if (ret) {
printf("alloc error: Fail"); printf("alloc error: Fail");
return -1; return -1;
} }
srand(TEST_SEED); srand(TEST_SEED);
printf("CHECKSUM32 Tests seed=0x%x\n", TEST_SEED); printf("CHECKSUM32 Tests seed=0x%x\n", TEST_SEED);
for (i = 0; i < sizeof(test_funcs) / sizeof(test_funcs[0]); i++) { for (i = 0; i < sizeof(test_funcs) / sizeof(test_funcs[0]); i++) {
fail_case = 0; fail_case = 0;
test_func = &test_funcs[i]; test_func = &test_funcs[i];
printf("Test %s ", test_func->note); printf("Test %s ", test_func->note);
fail_case += zeros_test(test_func); fail_case += zeros_test(test_func);
fail_case += simple_pattern_test(test_func); fail_case += simple_pattern_test(test_func);
fail_case += seeds_sizes_test(test_func); fail_case += seeds_sizes_test(test_func);
fail_case += eob_test(test_func); fail_case += eob_test(test_func);
fail_case += update_test(test_func); fail_case += update_test(test_func);
fail_case += update_over_mod_test(test_func); fail_case += update_over_mod_test(test_func);
printf("Test %s done: %s\n", test_func->note, fail_case ? "Fail" : "Pass"); printf("Test %s done: %s\n", test_func->note, fail_case ? "Fail" : "Pass");
if (fail_case) { if (fail_case) {
printf("\n%s Failed %d tests\n", test_func->note, fail_case); printf("\n%s Failed %d tests\n", test_func->note, fail_case);
fail++; fail++;
} }
} }
printf("CHECKSUM32 Tests all done: %s\n", fail ? "Fail" : "Pass"); printf("CHECKSUM32 Tests all done: %s\n", fail ? "Fail" : "Pass");
aligned_free(buf_alloc); aligned_free(buf_alloc);
return fail; return fail;
} }
// Test of all zeros // Test of all zeros
int zeros_test(func_case_t * test_func) int
zeros_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
unsigned char *buf = NULL; unsigned char *buf = NULL;
buf = (unsigned char *)buf_alloc; buf = (unsigned char *) buf_alloc;
memset(buf, 0, MAX_BUF * 10); memset(buf, 0, MAX_BUF * 10);
c_dut = test_func->checksum32_func_call(TEST_SEED, buf, MAX_BUF * 10); c_dut = test_func->checksum32_func_call(TEST_SEED, buf, MAX_BUF * 10);
c_ref = test_func->checksum32_ref_call(TEST_SEED, buf, MAX_BUF * 10); c_ref = test_func->checksum32_ref_call(TEST_SEED, buf, MAX_BUF * 10);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("\n opt ref\n"); printf("\n opt ref\n");
printf(" ------ ------\n"); printf(" ------ ------\n");
printf("checksum zero = 0x%8x 0x%8x \n", c_dut, c_ref); printf("checksum zero = 0x%8x 0x%8x \n", c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
return fail; return fail;
} }
// Another simple test pattern // Another simple test pattern
int simple_pattern_test(func_case_t * test_func) int
simple_pattern_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
unsigned char *buf = NULL; unsigned char *buf = NULL;
buf = (unsigned char *)buf_alloc; buf = (unsigned char *) buf_alloc;
memset(buf, 0x8a, MAX_BUF); memset(buf, 0x8a, MAX_BUF);
c_dut = test_func->checksum32_func_call(TEST_SEED, buf, MAX_BUF); c_dut = test_func->checksum32_func_call(TEST_SEED, buf, MAX_BUF);
c_ref = test_func->checksum32_ref_call(TEST_SEED, buf, MAX_BUF); c_ref = test_func->checksum32_ref_call(TEST_SEED, buf, MAX_BUF);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("fail checksum all 8a = 0x%8x 0x%8x\n", c_dut, c_ref); printf("fail checksum all 8a = 0x%8x 0x%8x\n", c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
return fail; return fail;
} }
int seeds_sizes_test(func_case_t * test_func) int
seeds_sizes_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
int i; int i;
uint32_t r, s; uint32_t r, s;
unsigned char *buf = NULL; unsigned char *buf = NULL;
// Do a few random tests // Do a few random tests
buf = (unsigned char *)buf_alloc; //reset buf buf = (unsigned char *) buf_alloc; // reset buf
r = rand(); r = rand();
rand_buffer(buf, MAX_BUF * TEST_SIZE); rand_buffer(buf, MAX_BUF * TEST_SIZE);
for (i = 0; i < TEST_SIZE; i++) { for (i = 0; i < TEST_SIZE; i++) {
c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF); c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF);
c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF); c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("fail checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref); printf("fail checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
buf += MAX_BUF; buf += MAX_BUF;
} }
// Do a few random sizes // Do a few random sizes
buf = (unsigned char *)buf_alloc; //reset buf buf = (unsigned char *) buf_alloc; // reset buf
r = rand(); r = rand();
for (i = MAX_BUF; i >= 0; i--) { for (i = MAX_BUF; i >= 0; i--) {
c_dut = test_func->checksum32_func_call(r, buf, i); c_dut = test_func->checksum32_func_call(r, buf, i);
c_ref = test_func->checksum32_ref_call(r, buf, i); c_ref = test_func->checksum32_ref_call(r, buf, i);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("fail random size%i 0x%8x 0x%8x\n", i, c_dut, c_ref); printf("fail random size%i 0x%8x 0x%8x\n", i, c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
} }
// Try different seeds // Try different seeds
for (s = 0; s < 20; s++) { for (s = 0; s < 20; s++) {
buf = (unsigned char *)buf_alloc; //reset buf buf = (unsigned char *) buf_alloc; // reset buf
r = rand(); // just to get a new seed r = rand(); // just to get a new seed
rand_buffer(buf, MAX_BUF * TEST_SIZE); // new pseudo-rand data rand_buffer(buf, MAX_BUF * TEST_SIZE); // new pseudo-rand data
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
printf("seed = 0x%x\n", r); printf("seed = 0x%x\n", r);
#endif #endif
for (i = 0; i < TEST_SIZE; i++) { for (i = 0; i < TEST_SIZE; i++) {
c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF); c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF);
c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF); c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("fail checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, printf("fail checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref);
c_ref); }
}
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
buf += MAX_BUF; buf += MAX_BUF;
} }
} }
return fail; return fail;
} }
// Run tests at end of buffer // Run tests at end of buffer
int eob_test(func_case_t * test_func) int
eob_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
int i; int i;
unsigned char *buf = NULL; unsigned char *buf = NULL;
buf = (unsigned char *)buf_alloc; //reset buf buf = (unsigned char *) buf_alloc; // reset buf
buf = buf + ((MAX_BUF - 1) * TEST_SIZE); //Line up TEST_SIZE from end buf = buf + ((MAX_BUF - 1) * TEST_SIZE); // Line up TEST_SIZE from end
for (i = 0; i < TEST_SIZE; i++) { for (i = 0; i < TEST_SIZE; i++) {
c_dut = test_func->checksum32_func_call(TEST_SEED, buf + i, TEST_SIZE - i); c_dut = test_func->checksum32_func_call(TEST_SEED, buf + i, TEST_SIZE - i);
c_ref = test_func->checksum32_ref_call(TEST_SEED, buf + i, TEST_SIZE - i); c_ref = test_func->checksum32_ref_call(TEST_SEED, buf + i, TEST_SIZE - i);
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("fail checksum eob rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref); printf("fail checksum eob rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
} }
return fail; return fail;
} }
int update_test(func_case_t * test_func) int
update_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
int i; int i;
uint32_t r; uint32_t r;
unsigned char *buf = NULL; unsigned char *buf = NULL;
buf = (unsigned char *)buf_alloc; //reset buf buf = (unsigned char *) buf_alloc; // reset buf
r = rand(); r = rand();
// Process the whole buf with reference func single call. // Process the whole buf with reference func single call.
c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF * TEST_SIZE); c_ref = test_func->checksum32_ref_call(r, buf, MAX_BUF * TEST_SIZE);
// Process buf with update method. // Process buf with update method.
for (i = 0; i < TEST_SIZE; i++) { for (i = 0; i < TEST_SIZE; i++) {
c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF); c_dut = test_func->checksum32_func_call(r, buf, MAX_BUF);
// Update checksum seeds and buf pointer. // Update checksum seeds and buf pointer.
r = c_dut; r = c_dut;
buf += MAX_BUF; buf += MAX_BUF;
} }
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref); printf("checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
return fail; return fail;
} }
int update_over_mod_test(func_case_t * test_func) int
update_over_mod_test(func_case_t *test_func)
{ {
uint32_t c_dut, c_ref; uint32_t c_dut, c_ref;
int fail = 0; int fail = 0;
int i; int i;
unsigned char *buf = NULL; unsigned char *buf = NULL;
buf = malloc(ADLER_MOD); buf = malloc(ADLER_MOD);
if (buf == NULL) if (buf == NULL)
return 1; return 1;
memset(buf, 0xff, ADLER_MOD); memset(buf, 0xff, ADLER_MOD);
c_ref = c_dut = rand(); c_ref = c_dut = rand();
// Process buf with update method. // Process buf with update method.
for (i = 0; i < 20; i++) { for (i = 0; i < 20; i++) {
c_ref = test_func->checksum32_ref_call(c_ref, buf, ADLER_MOD - 64); c_ref = test_func->checksum32_ref_call(c_ref, buf, ADLER_MOD - 64);
c_dut = test_func->checksum32_func_call(c_dut, buf, ADLER_MOD - 64); c_dut = test_func->checksum32_func_call(c_dut, buf, ADLER_MOD - 64);
} }
if (c_dut != c_ref) { if (c_dut != c_ref) {
fail++; fail++;
printf("checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref); printf("checksum rand%3d = 0x%8x 0x%8x\n", i, c_dut, c_ref);
} }
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
else else
printf("."); printf(".");
#endif #endif
free(buf); free(buf);
return fail; return fail;
} }

136
igzip/checksum_test_ref.h
View File

@ -8,95 +8,69 @@
#include <stdint.h> #include <stdint.h>
uint32_t inflate_crc_table[256] = { uint32_t inflate_crc_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, };
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
uint32_t
uint32_t crc32_gzip_refl_ref(uint32_t crc, const unsigned char *buf, uint64_t len) crc32_gzip_refl_ref(uint32_t crc, const unsigned char *buf, uint64_t len)
{ {
uint64_t i; uint64_t i;
crc = ~crc; crc = ~crc;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
crc = (crc >> 8) ^ inflate_crc_table[(crc & 0xff) ^ buf[i]]; crc = (crc >> 8) ^ inflate_crc_table[(crc & 0xff) ^ buf[i]];
return ~crc; return ~crc;
} }
#define ADLER_MOD 65521 #define ADLER_MOD 65521
uint32_t
uint32_t adler_ref(uint32_t init, const unsigned char *buf, uint64_t len) adler_ref(uint32_t init, const unsigned char *buf, uint64_t len)
{ {
uint64_t i; uint64_t i;
uint32_t a = init & 0xffff; uint32_t a = init & 0xffff;
uint32_t b = init >> 16; uint32_t b = init >> 16;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
a = (a + buf[i]) % ADLER_MOD; a = (a + buf[i]) % ADLER_MOD;
b = (b + a) % ADLER_MOD; b = (b + a) % ADLER_MOD;
} }
return (b << 16) | a; return (b << 16) | a;
} }
#endif /* CHECKSUM_TEST_REF_H */ #endif /* CHECKSUM_TEST_REF_H */

36
igzip/encode_df.c
View File

@ -4,35 +4,35 @@
#include <memory.h> #include <memory.h>
#include <assert.h> #include <assert.h>
#if __x86_64__ || __i386__ || _M_X64 || _M_IX86 #if __x86_64__ || __i386__ || _M_X64 || _M_IX86
#ifdef _MSC_VER #ifdef _MSC_VER
# include <intrin.h> #include <intrin.h>
#else #else
# include <x86intrin.h> #include <x86intrin.h>
#endif #endif
#endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86 #endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86
#include "encode_df.h" #include "encode_df.h"
#include "bitbuf2.h" #include "bitbuf2.h"
struct deflate_icf *encode_deflate_icf_base(struct deflate_icf *next_in, struct deflate_icf *
struct deflate_icf *end_in, struct BitBuf2 *bb, encode_deflate_icf_base(struct deflate_icf *next_in, struct deflate_icf *end_in, struct BitBuf2 *bb,
struct hufftables_icf *hufftables) struct hufftables_icf *hufftables)
{ {
struct huff_code lsym, dsym; struct huff_code lsym, dsym;
while (next_in < end_in && !is_full(bb)) { while (next_in < end_in && !is_full(bb)) {
lsym = hufftables->lit_len_table[next_in->lit_len]; lsym = hufftables->lit_len_table[next_in->lit_len];
dsym = hufftables->dist_lit_table[next_in->lit_dist]; dsym = hufftables->dist_lit_table[next_in->lit_dist];
// insert ll code, dist_code, and extra_bits // insert ll code, dist_code, and extra_bits
write_bits_unsafe(bb, lsym.code_and_extra, lsym.length); write_bits_unsafe(bb, lsym.code_and_extra, lsym.length);
write_bits_unsafe(bb, dsym.code, dsym.length); write_bits_unsafe(bb, dsym.code, dsym.length);
write_bits_unsafe(bb, next_in->dist_extra, dsym.extra_bit_count); write_bits_unsafe(bb, next_in->dist_extra, dsym.extra_bit_count);
flush_bits(bb); flush_bits(bb);
next_in++; next_in++;
} }
return next_in; return next_in;
} }

35
igzip/encode_df.h
View File

@ -6,31 +6,32 @@
#include "huff_codes.h" #include "huff_codes.h"
/* Deflate Intermediate Compression Format */ /* Deflate Intermediate Compression Format */
#define LIT_LEN_BIT_COUNT 10 #define LIT_LEN_BIT_COUNT 10
#define LIT_LEN_MASK ((1 << LIT_LEN_BIT_COUNT) - 1) #define LIT_LEN_MASK ((1 << LIT_LEN_BIT_COUNT) - 1)
#define DIST_LIT_BIT_COUNT 9 #define DIST_LIT_BIT_COUNT 9
#define DIST_LIT_MASK ((1 << DIST_LIT_BIT_COUNT) - 1) #define DIST_LIT_MASK ((1 << DIST_LIT_BIT_COUNT) - 1)
#define ICF_DIST_OFFSET LIT_LEN_BIT_COUNT #define ICF_DIST_OFFSET LIT_LEN_BIT_COUNT
#define NULL_DIST_SYM 30 #define NULL_DIST_SYM 30
#define LEN_START ISAL_DEF_LIT_SYMBOLS #define LEN_START ISAL_DEF_LIT_SYMBOLS
#define LEN_OFFSET (LEN_START - ISAL_DEF_MIN_MATCH) #define LEN_OFFSET (LEN_START - ISAL_DEF_MIN_MATCH)
#define LEN_MAX (LEN_OFFSET + ISAL_DEF_MAX_MATCH) #define LEN_MAX (LEN_OFFSET + ISAL_DEF_MAX_MATCH)
#define LIT_START (NULL_DIST_SYM + 1) #define LIT_START (NULL_DIST_SYM + 1)
#define ICF_CODE_LEN 32 #define ICF_CODE_LEN 32
struct deflate_icf { struct deflate_icf {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint32_t lit_len:LIT_LEN_BIT_COUNT; uint32_t lit_len : LIT_LEN_BIT_COUNT;
uint32_t lit_dist:DIST_LIT_BIT_COUNT; uint32_t lit_dist : DIST_LIT_BIT_COUNT;
uint32_t dist_extra:ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET; uint32_t dist_extra : ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET;
#else #else
uint32_t dist_extra:ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET; uint32_t dist_extra : ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET;
uint32_t lit_dist:DIST_LIT_BIT_COUNT; uint32_t lit_dist : DIST_LIT_BIT_COUNT;
uint32_t lit_len:LIT_LEN_BIT_COUNT; uint32_t lit_len : LIT_LEN_BIT_COUNT;
#endif #endif
}; };
struct deflate_icf *encode_deflate_icf(struct deflate_icf *next_in, struct deflate_icf *end_in, struct deflate_icf *
struct BitBuf2 *bb, struct hufftables_icf *hufftables); encode_deflate_icf(struct deflate_icf *next_in, struct deflate_icf *end_in, struct BitBuf2 *bb,
struct hufftables_icf *hufftables);
#endif #endif

65
igzip/flatten_ll.c
View File

@ -4,38 +4,39 @@
#include "flatten_ll.h" #include "flatten_ll.h"
void flatten_ll(uint32_t * ll_hist) void
flatten_ll(uint32_t *ll_hist)
{ {
uint32_t i, j; uint32_t i, j;
uint32_t *s = ll_hist, x, *p; uint32_t *s = ll_hist, x, *p;
s[265] += s[266]; s[265] += s[266];
s[266] = s[267] + s[268]; s[266] = s[267] + s[268];
s[267] = s[269] + s[270]; s[267] = s[269] + s[270];
s[268] = s[271] + s[272]; s[268] = s[271] + s[272];
s[269] = s[273] + s[274] + s[275] + s[276]; s[269] = s[273] + s[274] + s[275] + s[276];
s[270] = s[277] + s[278] + s[279] + s[280]; s[270] = s[277] + s[278] + s[279] + s[280];
s[271] = s[281] + s[282] + s[283] + s[284]; s[271] = s[281] + s[282] + s[283] + s[284];
s[272] = s[285] + s[286] + s[287] + s[288]; s[272] = s[285] + s[286] + s[287] + s[288];
p = s + 289; p = s + 289;
for (i = 273; i < 277; i++) { for (i = 273; i < 277; i++) {
x = *(p++); x = *(p++);
for (j = 1; j < 8; j++) for (j = 1; j < 8; j++)
x += *(p++); x += *(p++);
s[i] = x; s[i] = x;
} }
for (; i < 281; i++) { for (; i < 281; i++) {
x = *(p++); x = *(p++);
for (j = 1; j < 16; j++) for (j = 1; j < 16; j++)
x += *(p++); x += *(p++);
s[i] = x; s[i] = x;
} }
for (; i < 285; i++) { for (; i < 285; i++) {
x = *(p++); x = *(p++);
for (j = 1; j < 32; j++) for (j = 1; j < 32; j++)
x += *(p++); x += *(p++);
s[i] = x; s[i] = x;
} }
s[284] -= s[512]; s[284] -= s[512];
s[285] = s[512]; s[285] = s[512];
} }

3
igzip/flatten_ll.h
View File

@ -1,3 +1,4 @@
#include <stdint.h> #include <stdint.h>
void flatten_ll(uint32_t *ll_hist); void
flatten_ll(uint32_t *ll_hist);

619
igzip/generate_custom_hufftables.c
View File

@ -72,9 +72,9 @@
#define MAX_HEADER_SIZE ISAL_DEF_MAX_HDR_SIZE #define MAX_HEADER_SIZE ISAL_DEF_MAX_HDR_SIZE
#define GZIP_HEADER_SIZE 10 #define GZIP_HEADER_SIZE 10
#define GZIP_TRAILER_SIZE 8 #define GZIP_TRAILER_SIZE 8
#define ZLIB_HEADER_SIZE 2 #define ZLIB_HEADER_SIZE 2
#define ZLIB_TRAILER_SIZE 4 #define ZLIB_TRAILER_SIZE 4
/** /**
@ -86,26 +86,26 @@
* @param footer: footer to append at the end of the table. * @param footer: footer to append at the end of the table.
* @param begin_line: string printed at beginning of new line * @param begin_line: string printed at beginning of new line
*/ */
void fprint_uint8_table(FILE * outfile, uint8_t * table, uint64_t length, char *header, void
char *footer, char *begin_line) fprint_uint8_table(FILE *outfile, uint8_t *table, uint64_t length, char *header, char *footer,
char *begin_line)
{ {
int i; int i;
fprintf(outfile, "%s", header); fprintf(outfile, "%s", header);
for (i = 0; i < length - 1; i++) { for (i = 0; i < length - 1; i++) {
if ((i & 7) == 0) if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line); fprintf(outfile, "\n%s", begin_line);
else else
fprintf(outfile, " "); fprintf(outfile, " ");
fprintf(outfile, "0x%02x,", table[i]); fprintf(outfile, "0x%02x,", table[i]);
} }
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%02x", table[i]);
fprintf(outfile, "%s", footer);
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%02x", table[i]);
fprintf(outfile, "%s", footer);
} }
/** /**
@ -117,26 +117,26 @@ void fprint_uint8_table(FILE * outfile, uint8_t * table, uint64_t length, char *
* @param footer: footer to append at the end of the table. * @param footer: footer to append at the end of the table.
* @param begin_line: string printed at beginning of new line * @param begin_line: string printed at beginning of new line
*/ */
void fprint_uint16_table(FILE * outfile, uint16_t * table, uint64_t length, char *header, void
char *footer, char *begin_line) fprint_uint16_table(FILE *outfile, uint16_t *table, uint64_t length, char *header, char *footer,
char *begin_line)
{ {
int i; int i;
fprintf(outfile, "%s", header); fprintf(outfile, "%s", header);
for (i = 0; i < length - 1; i++) { for (i = 0; i < length - 1; i++) {
if ((i & 7) == 0) if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line); fprintf(outfile, "\n%s", begin_line);
else else
fprintf(outfile, " "); fprintf(outfile, " ");
fprintf(outfile, "0x%04x,", table[i]); fprintf(outfile, "0x%04x,", table[i]);
} }
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%04x", table[i]);
fprintf(outfile, "%s", footer);
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%04x", table[i]);
fprintf(outfile, "%s", footer);
} }
/** /**
@ -148,341 +148,348 @@ void fprint_uint16_table(FILE * outfile, uint16_t * table, uint64_t length, char
* @param footer: footer to append at the end of the table. * @param footer: footer to append at the end of the table.
* @param begin_line: string printed at beginning of new line * @param begin_line: string printed at beginning of new line
*/ */
void fprint_uint32_table(FILE * outfile, uint32_t * table, uint64_t length, char *header, void
char *footer, char *begin_line) fprint_uint32_table(FILE *outfile, uint32_t *table, uint64_t length, char *header, char *footer,
char *begin_line)
{ {
int i; int i;
fprintf(outfile, "%s", header); fprintf(outfile, "%s", header);
for (i = 0; i < length - 1; i++) { for (i = 0; i < length - 1; i++) {
if ((i & 3) == 0) if ((i & 3) == 0)
fprintf(outfile, "\n%s", begin_line); fprintf(outfile, "\n%s", begin_line);
else else
fprintf(outfile, " "); fprintf(outfile, " ");
fprintf(outfile, "0x%08x,", table[i]); fprintf(outfile, "0x%08x,", table[i]);
} }
if ((i & 3) == 0)
fprintf(outfile, "%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%08x", table[i]);
fprintf(outfile, "%s", footer);
if ((i & 3) == 0)
fprintf(outfile, "%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%08x", table[i]);
fprintf(outfile, "%s", footer);
} }
void fprint_hufftables(FILE * output_file, char *hufftables_name, void
struct isal_hufftables *hufftables) fprint_hufftables(FILE *output_file, char *hufftables_name, struct isal_hufftables *hufftables)
{ {
fprintf(output_file, "struct isal_hufftables %s = {\n\n", hufftables_name); fprintf(output_file, "struct isal_hufftables %s = {\n\n", hufftables_name);
fprint_uint8_table(output_file, hufftables->deflate_hdr, fprint_uint8_table(output_file, hufftables->deflate_hdr,
hufftables->deflate_hdr_count + hufftables->deflate_hdr_count +
(hufftables->deflate_hdr_extra_bits + 7) / 8, (hufftables->deflate_hdr_extra_bits + 7) / 8,
"\t.deflate_hdr = {", "},\n\n", "\t\t"); "\t.deflate_hdr = {", "},\n\n", "\t\t");
fprintf(output_file, "\t.deflate_hdr_count = %d,\n", hufftables->deflate_hdr_count); fprintf(output_file, "\t.deflate_hdr_count = %d,\n", hufftables->deflate_hdr_count);
fprintf(output_file, "\t.deflate_hdr_extra_bits = %d,\n\n", fprintf(output_file, "\t.deflate_hdr_extra_bits = %d,\n\n",
hufftables->deflate_hdr_extra_bits); hufftables->deflate_hdr_extra_bits);
fprint_uint32_table(output_file, hufftables->dist_table, IGZIP_DIST_TABLE_SIZE, fprint_uint32_table(output_file, hufftables->dist_table, IGZIP_DIST_TABLE_SIZE,
"\t.dist_table = {", "},\n\n", "\t\t"); "\t.dist_table = {", "},\n\n", "\t\t");
fprint_uint32_table(output_file, hufftables->len_table, IGZIP_LEN_TABLE_SIZE, fprint_uint32_table(output_file, hufftables->len_table, IGZIP_LEN_TABLE_SIZE,
"\t.len_table = {", "},\n\n", "\t\t"); "\t.len_table = {", "},\n\n", "\t\t");
fprint_uint16_table(output_file, hufftables->lit_table, IGZIP_LIT_TABLE_SIZE, fprint_uint16_table(output_file, hufftables->lit_table, IGZIP_LIT_TABLE_SIZE,
"\t.lit_table = {", "},\n\n", "\t\t"); "\t.lit_table = {", "},\n\n", "\t\t");
fprint_uint8_table(output_file, hufftables->lit_table_sizes, IGZIP_LIT_TABLE_SIZE, fprint_uint8_table(output_file, hufftables->lit_table_sizes, IGZIP_LIT_TABLE_SIZE,
"\t.lit_table_sizes = {", "},\n\n", "\t\t"); "\t.lit_table_sizes = {", "},\n\n", "\t\t");
fprint_uint16_table(output_file, hufftables->dcodes, fprint_uint16_table(output_file, hufftables->dcodes,
ISAL_DEF_DIST_SYMBOLS - IGZIP_DECODE_OFFSET, ISAL_DEF_DIST_SYMBOLS - IGZIP_DECODE_OFFSET, "\t.dcodes = {", "},\n\n",
"\t.dcodes = {", "},\n\n", "\t\t"); "\t\t");
fprint_uint8_table(output_file, hufftables->dcodes_sizes, fprint_uint8_table(output_file, hufftables->dcodes_sizes,
ISAL_DEF_DIST_SYMBOLS - IGZIP_DECODE_OFFSET, ISAL_DEF_DIST_SYMBOLS - IGZIP_DECODE_OFFSET, "\t.dcodes_sizes = {",
"\t.dcodes_sizes = {", "}\n", "\t\t"); "}\n", "\t\t");
fprintf(output_file, "};\n"); fprintf(output_file, "};\n");
} }
void fprint_header(FILE * output_file) void
fprint_header(FILE *output_file)
{ {
fprintf(output_file, "#include <stdint.h>\n"); fprintf(output_file, "#include <stdint.h>\n");
fprintf(output_file, "#include <igzip_lib.h>\n\n"); fprintf(output_file, "#include <igzip_lib.h>\n\n");
fprintf(output_file, "#if IGZIP_HIST_SIZE > %d\n" fprintf(output_file,
"# error \"Invalid history size for the custom hufftable\"\n" "#if IGZIP_HIST_SIZE > %d\n"
"#endif\n", IGZIP_HIST_SIZE); "# error \"Invalid history size for the custom hufftable\"\n"
"#endif\n",
IGZIP_HIST_SIZE);
#ifdef LONGER_HUFFTABLE #ifdef LONGER_HUFFTABLE
fprintf(output_file, "#ifndef LONGER_HUFFTABLE\n" fprintf(output_file,
"# error \"Custom hufftable requires LONGER_HUFFTABLE to be defined \"\n" "#ifndef LONGER_HUFFTABLE\n"
"#endif\n"); "# error \"Custom hufftable requires LONGER_HUFFTABLE to be defined \"\n"
"#endif\n");
#else #else
fprintf(output_file, "#ifdef LONGER_HUFFTABLE\n" fprintf(output_file,
"# error \"Custom hufftable requires LONGER_HUFFTABLE to not be defined \"\n" "#ifdef LONGER_HUFFTABLE\n"
"#endif\n"); "# error \"Custom hufftable requires LONGER_HUFFTABLE to not be defined \"\n"
"#endif\n");
#endif #endif
fprintf(output_file, "\n"); fprintf(output_file, "\n");
fprintf(output_file, "const uint8_t gzip_hdr[] = {\n" fprintf(output_file, "const uint8_t gzip_hdr[] = {\n"
"\t0x1f, 0x8b, 0x08, 0x00, 0x00,\n" "\t0x00, 0x00, 0x00, 0x00, 0xff\t};\n\n"); "\t0x1f, 0x8b, 0x08, 0x00, 0x00,\n"
"\t0x00, 0x00, 0x00, 0x00, 0xff\t};\n\n");
fprintf(output_file, "const uint32_t gzip_hdr_bytes = %d;\n", GZIP_HEADER_SIZE); fprintf(output_file, "const uint32_t gzip_hdr_bytes = %d;\n", GZIP_HEADER_SIZE);
fprintf(output_file, "const uint32_t gzip_trl_bytes = %d;\n\n", GZIP_TRAILER_SIZE); fprintf(output_file, "const uint32_t gzip_trl_bytes = %d;\n\n", GZIP_TRAILER_SIZE);
fprintf(output_file, "const uint8_t zlib_hdr[] = { 0x78, 0x01 };\n\n"); fprintf(output_file, "const uint8_t zlib_hdr[] = { 0x78, 0x01 };\n\n");
fprintf(output_file, "const uint32_t zlib_hdr_bytes = %d;\n", ZLIB_HEADER_SIZE); fprintf(output_file, "const uint32_t zlib_hdr_bytes = %d;\n", ZLIB_HEADER_SIZE);
fprintf(output_file, "const uint32_t zlib_trl_bytes = %d;\n", ZLIB_TRAILER_SIZE); fprintf(output_file, "const uint32_t zlib_trl_bytes = %d;\n", ZLIB_TRAILER_SIZE);
} }
static uint32_t convert_dist_to_dist_sym(uint32_t dist) static uint32_t
convert_dist_to_dist_sym(uint32_t dist)
{ {
assert(dist <= 32768 && dist > 0); assert(dist <= 32768 && dist > 0);
if (dist <= 32768) { if (dist <= 32768) {
uint32_t msb = dist > 4 ? bsr(dist - 1) - 2 : 0; uint32_t msb = dist > 4 ? bsr(dist - 1) - 2 : 0;
return (msb * 2) + ((dist - 1) >> msb); return (msb * 2) + ((dist - 1) >> msb);
} else { } else {
return ~0; return ~0;
} }
} }
/** /**
* @brief Returns the deflate symbol value for a repeat length. * @brief Returns the deflate symbol value for a repeat length.
*/ */
static uint32_t convert_length_to_len_sym(uint32_t length) static uint32_t
convert_length_to_len_sym(uint32_t length)
{ {
assert(length > 2 && length < 259); assert(length > 2 && length < 259);
/* Based on tables on page 11 in RFC 1951 */ /* Based on tables on page 11 in RFC 1951 */
if (length < 11) if (length < 11)
return 257 + length - 3; return 257 + length - 3;
else if (length < 19) else if (length < 19)
return 261 + (length - 3) / 2; return 261 + (length - 3) / 2;
else if (length < 35) else if (length < 35)
return 265 + (length - 3) / 4; return 265 + (length - 3) / 4;
else if (length < 67) else if (length < 67)
return 269 + (length - 3) / 8; return 269 + (length - 3) / 8;
else if (length < 131) else if (length < 131)
return 273 + (length - 3) / 16; return 273 + (length - 3) / 16;
else if (length < 258) else if (length < 258)
return 277 + (length - 3) / 32; return 277 + (length - 3) / 32;
else else
return 285; return 285;
} }
void isal_update_histogram_dict(uint8_t * start_stream, int dict_length, int length, void
struct isal_huff_histogram *histogram) isal_update_histogram_dict(uint8_t *start_stream, int dict_length, int length,
struct isal_huff_histogram *histogram)
{ {
uint32_t literal = 0, hash; uint32_t literal = 0, hash;
uint16_t seen, *last_seen = histogram->hash_table; uint16_t seen, *last_seen = histogram->hash_table;
uint8_t *current, *end_stream, *next_hash, *end, *end_dict; uint8_t *current, *end_stream, *next_hash, *end, *end_dict;
uint32_t match_length; uint32_t match_length;
uint32_t dist; uint32_t dist;
uint64_t *lit_len_histogram = histogram->lit_len_histogram; uint64_t *lit_len_histogram = histogram->lit_len_histogram;
uint64_t *dist_histogram = histogram->dist_histogram; uint64_t *dist_histogram = histogram->dist_histogram;
if (length <= 0) if (length <= 0)
return; return;
end_stream = start_stream + dict_length + length; end_stream = start_stream + dict_length + length;
end_dict = start_stream + dict_length; end_dict = start_stream + dict_length;
memset(last_seen, 0, sizeof(histogram->hash_table)); /* Initialize last_seen to be 0. */ memset(last_seen, 0, sizeof(histogram->hash_table)); /* Initialize last_seen to be 0. */
for (current = start_stream; current < end_dict - 4; current++) { for (current = start_stream; current < end_dict - 4; current++) {
literal = load_le_u32(current); literal = load_le_u32(current);
hash = compute_hash(literal) & LVL0_HASH_MASK; hash = compute_hash(literal) & LVL0_HASH_MASK;
last_seen[hash] = (current - start_stream) & 0xFFFF; last_seen[hash] = (current - start_stream) & 0xFFFF;
} }
for (current = start_stream + dict_length; current < end_stream - 3; current++) { for (current = start_stream + dict_length; current < end_stream - 3; current++) {
literal = load_le_u32(current); literal = load_le_u32(current);
hash = compute_hash(literal) & LVL0_HASH_MASK; hash = compute_hash(literal) & LVL0_HASH_MASK;
seen = last_seen[hash]; seen = last_seen[hash];
last_seen[hash] = (current - start_stream) & 0xFFFF; last_seen[hash] = (current - start_stream) & 0xFFFF;
dist = (current - start_stream - seen) & 0xFFFF; dist = (current - start_stream - seen) & 0xFFFF;
if (dist - 1 < D - 1) { if (dist - 1 < D - 1) {
assert(start_stream <= current - dist); assert(start_stream <= current - dist);
match_length = match_length = compare258(current - dist, current, end_stream - current);
compare258(current - dist, current, end_stream - current); if (match_length >= SHORTEST_MATCH) {
if (match_length >= SHORTEST_MATCH) { next_hash = current;
next_hash = current;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
if (end > end_stream - 3) if (end > end_stream - 3)
end = end_stream - 3; end = end_stream - 3;
next_hash++; next_hash++;
for (; next_hash < end; next_hash++) { for (; next_hash < end; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash(literal) & LVL0_HASH_MASK; hash = compute_hash(literal) & LVL0_HASH_MASK;
last_seen[hash] = (next_hash - start_stream) & 0xFFFF; last_seen[hash] = (next_hash - start_stream) & 0xFFFF;
} }
dist_histogram[convert_dist_to_dist_sym(dist)] += 1; dist_histogram[convert_dist_to_dist_sym(dist)] += 1;
lit_len_histogram[convert_length_to_len_sym(match_length)] += lit_len_histogram[convert_length_to_len_sym(match_length)] += 1;
1; current += match_length - 1;
current += match_length - 1; continue;
continue; }
} }
} lit_len_histogram[literal & 0xFF] += 1;
lit_len_histogram[literal & 0xFF] += 1; }
}
for (; current < end_stream; current++) for (; current < end_stream; current++)
lit_len_histogram[*current] += 1; lit_len_histogram[*current] += 1;
lit_len_histogram[256] += 1; lit_len_histogram[256] += 1;
return; return;
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
long int file_length; long int file_length;
int argi = 1; int argi = 1;
uint8_t *stream = NULL; uint8_t *stream = NULL;
struct isal_hufftables hufftables; struct isal_hufftables hufftables;
struct isal_huff_histogram histogram; struct isal_huff_histogram histogram;
struct isal_zstream tmp_stream; struct isal_zstream tmp_stream;
FILE *file = NULL; FILE *file = NULL;
FILE *dict_file = NULL; FILE *dict_file = NULL;
FILE *hist_file = NULL; FILE *hist_file = NULL;
long int dict_file_length = 0; long int dict_file_length = 0;
long int hist_file_length = 0; long int hist_file_length = 0;
uint8_t *dict_stream = NULL; uint8_t *dict_stream = NULL;
if (argc == 1) { if (argc == 1) {
printf("Error, no input file.\n"); printf("Error, no input file.\n");
return 1; return 1;
} }
if (argc > 3 && argv[1][0] == '-' && argv[1][1] == 'd') { if (argc > 3 && argv[1][0] == '-' && argv[1][1] == 'd') {
dict_file = fopen(argv[2], "r"); dict_file = fopen(argv[2], "r");
if (dict_file == NULL) { if (dict_file == NULL) {
printf("File \"%s\" open error!\n", argv[2]); printf("File \"%s\" open error!\n", argv[2]);
return 1; return 1;
} }
fseek(dict_file, 0, SEEK_END); fseek(dict_file, 0, SEEK_END);
dict_file_length = ftell(dict_file); dict_file_length = ftell(dict_file);
fseek(dict_file, 0, SEEK_SET); fseek(dict_file, 0, SEEK_SET);
dict_file_length -= ftell(dict_file); dict_file_length -= ftell(dict_file);
dict_stream = malloc(dict_file_length); dict_stream = malloc(dict_file_length);
if (dict_stream == NULL) { if (dict_stream == NULL) {
printf("Failed to allocate memory to read in dictionary file\n"); printf("Failed to allocate memory to read in dictionary file\n");
fclose(dict_file); fclose(dict_file);
return 1; return 1;
} }
if (fread(dict_stream, 1, dict_file_length, dict_file) != dict_file_length) { if (fread(dict_stream, 1, dict_file_length, dict_file) != dict_file_length) {
printf("Error occurred when reading dictionary file"); printf("Error occurred when reading dictionary file");
fclose(dict_file); fclose(dict_file);
free(dict_stream); free(dict_stream);
return 1; return 1;
} }
isal_update_histogram(dict_stream, dict_file_length, &histogram); isal_update_histogram(dict_stream, dict_file_length, &histogram);
printf("Read %ld bytes of dictionary file %s\n", dict_file_length, argv[2]); printf("Read %ld bytes of dictionary file %s\n", dict_file_length, argv[2]);
argi += 2; argi += 2;
fclose(dict_file); fclose(dict_file);
free(dict_stream); free(dict_stream);
} }
if ((argc > argi + 1) && argv[argi][0] == '-' && argv[argi][1] == 'h') { if ((argc > argi + 1) && argv[argi][0] == '-' && argv[argi][1] == 'h') {
hist_file = fopen(argv[argi + 1], "r+"); hist_file = fopen(argv[argi + 1], "r+");
if (hist_file == NULL) { if (hist_file == NULL) {
printf("File \"%s\" open error!\n", argv[argi + 1]); printf("File \"%s\" open error!\n", argv[argi + 1]);
return 1; return 1;
} }
fseek(hist_file, 0, SEEK_END); fseek(hist_file, 0, SEEK_END);
hist_file_length = ftell(hist_file); hist_file_length = ftell(hist_file);
fseek(hist_file, 0, SEEK_SET); fseek(hist_file, 0, SEEK_SET);
hist_file_length -= ftell(hist_file); hist_file_length -= ftell(hist_file);
if (hist_file_length > sizeof(histogram)) { if (hist_file_length > sizeof(histogram)) {
printf("Histogram file too long\n"); printf("Histogram file too long\n");
return 1; return 1;
} }
if (fread(&histogram, 1, hist_file_length, hist_file) != hist_file_length) { if (fread(&histogram, 1, hist_file_length, hist_file) != hist_file_length) {
printf("Error occurred when reading history file"); printf("Error occurred when reading history file");
fclose(hist_file); fclose(hist_file);
return 1; return 1;
} }
fseek(hist_file, 0, SEEK_SET); fseek(hist_file, 0, SEEK_SET);
printf("Read %ld bytes of history file %s\n", hist_file_length, printf("Read %ld bytes of history file %s\n", hist_file_length, argv[argi + 1]);
argv[argi + 1]); argi += 2;
argi += 2; } else
} else memset(&histogram, 0, sizeof(histogram)); /* Initialize histograms. */
memset(&histogram, 0, sizeof(histogram)); /* Initialize histograms. */
while (argi < argc) { while (argi < argc) {
printf("Processing %s\n", argv[argi]); printf("Processing %s\n", argv[argi]);
file = fopen(argv[argi], "r"); file = fopen(argv[argi], "r");
if (file == NULL) { if (file == NULL) {
printf("Error opening file\n"); printf("Error opening file\n");
return 1; return 1;
} }
fseek(file, 0, SEEK_END); fseek(file, 0, SEEK_END);
file_length = ftell(file); file_length = ftell(file);
fseek(file, 0, SEEK_SET); fseek(file, 0, SEEK_SET);
file_length -= ftell(file); file_length -= ftell(file);
stream = malloc(file_length + dict_file_length); stream = malloc(file_length + dict_file_length);
if (stream == NULL) { if (stream == NULL) {
printf("Failed to allocate memory to read in file\n"); printf("Failed to allocate memory to read in file\n");
fclose(file); fclose(file);
return 1; return 1;
} }
if (dict_file_length > 0) if (dict_file_length > 0)
memcpy(stream, dict_stream, dict_file_length); memcpy(stream, dict_stream, dict_file_length);
if (fread(&stream[dict_file_length], 1, file_length, file) != file_length) { if (fread(&stream[dict_file_length], 1, file_length, file) != file_length) {
printf("Error occurred when reading file"); printf("Error occurred when reading file");
fclose(file); fclose(file);
free(stream); free(stream);
return 1; return 1;
} }
/* Create a histogram of frequency of symbols found in stream to /* Create a histogram of frequency of symbols found in stream to
* generate the huffman tree.*/ * generate the huffman tree.*/
if (0 == dict_file_length) if (0 == dict_file_length)
isal_update_histogram(stream, file_length, &histogram); isal_update_histogram(stream, file_length, &histogram);
else else
isal_update_histogram_dict(stream, dict_file_length, file_length, isal_update_histogram_dict(stream, dict_file_length, file_length,
&histogram); &histogram);
fclose(file); fclose(file);
free(stream); free(stream);
argi++; argi++;
} }
isal_create_hufftables(&hufftables, &histogram); isal_create_hufftables(&hufftables, &histogram);
file = fopen("hufftables_c.c", "w"); file = fopen("hufftables_c.c", "w");
if (file == NULL) { if (file == NULL) {
printf("Error creating file hufftables_c.c\n"); printf("Error creating file hufftables_c.c\n");
return 1; return 1;
} }
fprint_header(file); fprint_header(file);
fprintf(file, "\n"); fprintf(file, "\n");
fprint_hufftables(file, "hufftables_default", &hufftables); fprint_hufftables(file, "hufftables_default", &hufftables);
fprintf(file, "\n"); fprintf(file, "\n");
isal_deflate_stateless_init(&tmp_stream); isal_deflate_stateless_init(&tmp_stream);
isal_deflate_set_hufftables(&tmp_stream, NULL, IGZIP_HUFFTABLE_STATIC); isal_deflate_set_hufftables(&tmp_stream, NULL, IGZIP_HUFFTABLE_STATIC);
fprint_hufftables(file, "hufftables_static", tmp_stream.hufftables); fprint_hufftables(file, "hufftables_static", tmp_stream.hufftables);
fclose(file); fclose(file);
if (hist_file) { if (hist_file) {
int len = fwrite(&histogram, 1, sizeof(histogram), hist_file); int len = fwrite(&histogram, 1, sizeof(histogram), hist_file);
printf("wrote %d bytes of histogram file\n", len); printf("wrote %d bytes of histogram file\n", len);
fclose(hist_file); fclose(hist_file);
} }
return 0; return 0;
} }

235
igzip/generate_static_inflate.c
View File

@ -35,7 +35,7 @@
#include "igzip_lib.h" #include "igzip_lib.h"
#define STATIC_INFLATE_FILE "static_inflate.h" #define STATIC_INFLATE_FILE "static_inflate.h"
#define DOUBLE_SYM_THRESH (4 * 1024) #define DOUBLE_SYM_THRESH (4 * 1024)
extern struct isal_hufftables hufftables_default; extern struct isal_hufftables hufftables_default;
@ -48,26 +48,26 @@ extern struct isal_hufftables hufftables_default;
* @param footer: footer to append at the end of the table. * @param footer: footer to append at the end of the table.
* @param begin_line: string printed at beginning of new line * @param begin_line: string printed at beginning of new line
*/ */
void fprint_uint16_table(FILE * outfile, uint16_t * table, uint64_t length, char *header, void
char *footer, char *begin_line) fprint_uint16_table(FILE *outfile, uint16_t *table, uint64_t length, char *header, char *footer,
char *begin_line)
{ {
int i; int i;
fprintf(outfile, "%s", header); fprintf(outfile, "%s", header);
for (i = 0; i < length - 1; i++) { for (i = 0; i < length - 1; i++) {
if ((i & 7) == 0) if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line); fprintf(outfile, "\n%s", begin_line);
else else
fprintf(outfile, " "); fprintf(outfile, " ");
fprintf(outfile, "0x%04x,", table[i]); fprintf(outfile, "0x%04x,", table[i]);
} }
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%04x", table[i]);
fprintf(outfile, "%s", footer);
if ((i & 7) == 0)
fprintf(outfile, "\n%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%04x", table[i]);
fprintf(outfile, "%s", footer);
} }
/** /**
@ -79,127 +79,130 @@ void fprint_uint16_table(FILE * outfile, uint16_t * table, uint64_t length, char
* @param footer: footer to append at the end of the table. * @param footer: footer to append at the end of the table.
* @param begin_line: string printed at beginning of new line * @param begin_line: string printed at beginning of new line
*/ */
void fprint_uint32_table(FILE * outfile, uint32_t * table, uint64_t length, char *header, void
char *footer, char *begin_line) fprint_uint32_table(FILE *outfile, uint32_t *table, uint64_t length, char *header, char *footer,
char *begin_line)
{ {
int i; int i;
fprintf(outfile, "%s", header); fprintf(outfile, "%s", header);
for (i = 0; i < length - 1; i++) { for (i = 0; i < length - 1; i++) {
if ((i & 3) == 0) if ((i & 3) == 0)
fprintf(outfile, "\n%s", begin_line); fprintf(outfile, "\n%s", begin_line);
else else
fprintf(outfile, " "); fprintf(outfile, " ");
fprintf(outfile, "0x%08x,", table[i]); fprintf(outfile, "0x%08x,", table[i]);
} }
if ((i & 3) == 0)
fprintf(outfile, "%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%08x", table[i]);
fprintf(outfile, "%s", footer);
if ((i & 3) == 0)
fprintf(outfile, "%s", begin_line);
else
fprintf(outfile, " ");
fprintf(outfile, "0x%08x", table[i]);
fprintf(outfile, "%s", footer);
} }
void fprint_header(FILE * output_file) void
fprint_header(FILE *output_file)
{ {
fprintf(output_file, "#include \"igzip_lib.h\"\n\n"); fprintf(output_file, "#include \"igzip_lib.h\"\n\n");
fprintf(output_file, "#define LONG_BITS_CHECK %d\n", ISAL_DECODE_LONG_BITS); fprintf(output_file, "#define LONG_BITS_CHECK %d\n", ISAL_DECODE_LONG_BITS);
fprintf(output_file, "#define SHORT_BITS_CHECK %d\n", ISAL_DECODE_SHORT_BITS); fprintf(output_file, "#define SHORT_BITS_CHECK %d\n", ISAL_DECODE_SHORT_BITS);
fprintf(output_file, fprintf(output_file, "#if (LONG_BITS_CHECK == ISAL_DECODE_LONG_BITS) && (SHORT_BITS_CHECK "
"#if (LONG_BITS_CHECK == ISAL_DECODE_LONG_BITS) && (SHORT_BITS_CHECK == ISAL_DECODE_SHORT_BITS)\n" "== ISAL_DECODE_SHORT_BITS)\n"
"# define ISAL_STATIC_INFLATE_TABLE\n" "# define ISAL_STATIC_INFLATE_TABLE\n"
"#else\n" "#else\n"
"# warning \"Incompatible compile time defines for optimized static inflate table.\"\n" "# warning \"Incompatible compile time defines for optimized static "
"#endif\n\n"); "inflate table.\"\n"
"#endif\n\n");
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
struct inflate_state state; struct inflate_state state;
FILE *file; FILE *file;
uint8_t static_deflate_hdr = 3; uint8_t static_deflate_hdr = 3;
uint8_t tmp_space[8], *in_buf; uint8_t tmp_space[8], *in_buf;
if (NULL == (in_buf = malloc(DOUBLE_SYM_THRESH + 1))) { if (NULL == (in_buf = malloc(DOUBLE_SYM_THRESH + 1))) {
printf("Can not allocote memory\n"); printf("Can not allocote memory\n");
return 1; return 1;
} }
isal_inflate_init(&state); isal_inflate_init(&state);
memcpy(in_buf, &static_deflate_hdr, sizeof(static_deflate_hdr)); memcpy(in_buf, &static_deflate_hdr, sizeof(static_deflate_hdr));
state.next_in = in_buf; state.next_in = in_buf;
state.avail_in = DOUBLE_SYM_THRESH + 1; state.avail_in = DOUBLE_SYM_THRESH + 1;
state.next_out = tmp_space; state.next_out = tmp_space;
state.avail_out = sizeof(tmp_space); state.avail_out = sizeof(tmp_space);
isal_inflate(&state); isal_inflate(&state);
file = fopen(STATIC_INFLATE_FILE, "w"); file = fopen(STATIC_INFLATE_FILE, "w");
if (file == NULL) { if (file == NULL) {
printf("Error creating file hufftables_c.c\n"); printf("Error creating file hufftables_c.c\n");
return 1; return 1;
} }
// Add decode tables describing a type 2 static (fixed) header // Add decode tables describing a type 2 static (fixed) header
fprintf(file, "#ifndef STATIC_HEADER_H\n" "#define STATIC_HEADER_H\n\n"); fprintf(file, "#ifndef STATIC_HEADER_H\n"
"#define STATIC_HEADER_H\n\n");
fprint_header(file); fprint_header(file);
fprintf(file, "struct inflate_huff_code_large static_lit_huff_code = {\n"); fprintf(file, "struct inflate_huff_code_large static_lit_huff_code = {\n");
fprint_uint32_table(file, state.lit_huff_code.short_code_lookup, fprint_uint32_table(file, state.lit_huff_code.short_code_lookup,
sizeof(state.lit_huff_code.short_code_lookup) / sizeof(uint32_t), sizeof(state.lit_huff_code.short_code_lookup) / sizeof(uint32_t),
"\t.short_code_lookup = {", "\t},\n\n", "\t\t"); "\t.short_code_lookup = {", "\t},\n\n", "\t\t");
fprint_uint16_table(file, state.lit_huff_code.long_code_lookup, fprint_uint16_table(file, state.lit_huff_code.long_code_lookup,
sizeof(state.lit_huff_code.long_code_lookup) / sizeof(uint16_t), sizeof(state.lit_huff_code.long_code_lookup) / sizeof(uint16_t),
"\t.long_code_lookup = {", "\t}\n", "\t\t"); "\t.long_code_lookup = {", "\t}\n", "\t\t");
fprintf(file, "};\n\n"); fprintf(file, "};\n\n");
fprintf(file, "struct inflate_huff_code_small static_dist_huff_code = {\n"); fprintf(file, "struct inflate_huff_code_small static_dist_huff_code = {\n");
fprint_uint16_table(file, state.dist_huff_code.short_code_lookup, fprint_uint16_table(file, state.dist_huff_code.short_code_lookup,
sizeof(state.dist_huff_code.short_code_lookup) / sizeof(uint16_t), sizeof(state.dist_huff_code.short_code_lookup) / sizeof(uint16_t),
"\t.short_code_lookup = {", "\t},\n\n", "\t\t"); "\t.short_code_lookup = {", "\t},\n\n", "\t\t");
fprint_uint16_table(file, state.dist_huff_code.long_code_lookup, fprint_uint16_table(file, state.dist_huff_code.long_code_lookup,
sizeof(state.dist_huff_code.long_code_lookup) / sizeof(uint16_t), sizeof(state.dist_huff_code.long_code_lookup) / sizeof(uint16_t),
"\t.long_code_lookup = {", "\t}\n", "\t\t"); "\t.long_code_lookup = {", "\t}\n", "\t\t");
fprintf(file, "};\n\n"); fprintf(file, "};\n\n");
fprintf(file, "#endif\n"); fprintf(file, "#endif\n");
// Add other tables for known dynamic headers - level 0 // Add other tables for known dynamic headers - level 0
isal_inflate_init(&state); isal_inflate_init(&state);
memcpy(in_buf, &hufftables_default.deflate_hdr, memcpy(in_buf, &hufftables_default.deflate_hdr, sizeof(hufftables_default.deflate_hdr));
sizeof(hufftables_default.deflate_hdr)); state.next_in = in_buf;
state.next_in = in_buf; state.avail_in = DOUBLE_SYM_THRESH + 1;
state.avail_in = DOUBLE_SYM_THRESH + 1; state.next_out = tmp_space;
state.next_out = tmp_space; state.avail_out = sizeof(tmp_space);
state.avail_out = sizeof(tmp_space);
isal_inflate(&state); isal_inflate(&state);
fprintf(file, "struct inflate_huff_code_large pregen_lit_huff_code = {\n"); fprintf(file, "struct inflate_huff_code_large pregen_lit_huff_code = {\n");
fprint_uint32_table(file, state.lit_huff_code.short_code_lookup, fprint_uint32_table(file, state.lit_huff_code.short_code_lookup,
sizeof(state.lit_huff_code.short_code_lookup) / sizeof(uint32_t), sizeof(state.lit_huff_code.short_code_lookup) / sizeof(uint32_t),
"\t.short_code_lookup = {", "\t},\n\n", "\t\t"); "\t.short_code_lookup = {", "\t},\n\n", "\t\t");
fprint_uint16_table(file, state.lit_huff_code.long_code_lookup, fprint_uint16_table(file, state.lit_huff_code.long_code_lookup,
sizeof(state.lit_huff_code.long_code_lookup) / sizeof(uint16_t), sizeof(state.lit_huff_code.long_code_lookup) / sizeof(uint16_t),
"\t.long_code_lookup = {", "\t}\n", "\t\t"); "\t.long_code_lookup = {", "\t}\n", "\t\t");
fprintf(file, "};\n\n"); fprintf(file, "};\n\n");
fprintf(file, "struct inflate_huff_code_small pregen_dist_huff_code = {\n"); fprintf(file, "struct inflate_huff_code_small pregen_dist_huff_code = {\n");
fprint_uint16_table(file, state.dist_huff_code.short_code_lookup, fprint_uint16_table(file, state.dist_huff_code.short_code_lookup,
sizeof(state.dist_huff_code.short_code_lookup) / sizeof(uint16_t), sizeof(state.dist_huff_code.short_code_lookup) / sizeof(uint16_t),
"\t.short_code_lookup = {", "\t},\n\n", "\t\t"); "\t.short_code_lookup = {", "\t},\n\n", "\t\t");
fprint_uint16_table(file, state.dist_huff_code.long_code_lookup, fprint_uint16_table(file, state.dist_huff_code.long_code_lookup,
sizeof(state.dist_huff_code.long_code_lookup) / sizeof(uint16_t), sizeof(state.dist_huff_code.long_code_lookup) / sizeof(uint16_t),
"\t.long_code_lookup = {", "\t}\n", "\t\t"); "\t.long_code_lookup = {", "\t}\n", "\t\t");
fprintf(file, "};\n\n"); fprintf(file, "};\n\n");
fclose(file); fclose(file);
free(in_buf); free(in_buf);
return 0; return 0;
} }

2678
igzip/huff_codes.c
View File

File diff suppressed because it is too large Load Diff

158
igzip/huff_codes.h
View File

@ -36,135 +36,135 @@
#include "igzip_lib.h" #include "igzip_lib.h"
#include "bitbuf2.h" #include "bitbuf2.h"
#if __x86_64__ || __i386__ || _M_X64 || _M_IX86 #if __x86_64__ || __i386__ || _M_X64 || _M_IX86
# include <immintrin.h> #include <immintrin.h>
#ifdef _MSC_VER #ifdef _MSC_VER
# include <intrin.h> #include <intrin.h>
#else #else
# include <x86intrin.h> #include <x86intrin.h>
#endif #endif
#endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86 #endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86
#define LIT_LEN ISAL_DEF_LIT_LEN_SYMBOLS #define LIT_LEN ISAL_DEF_LIT_LEN_SYMBOLS
#define DIST_LEN ISAL_DEF_DIST_SYMBOLS #define DIST_LEN ISAL_DEF_DIST_SYMBOLS
#define CODE_LEN_CODES 19 #define CODE_LEN_CODES 19
#define HUFF_LEN 19 #define HUFF_LEN 19
#ifdef LONGER_HUFFTABLE #ifdef LONGER_HUFFTABLE
# define DCODE_OFFSET 26 #define DCODE_OFFSET 26
#else #else
# define DCODE_OFFSET 0 #define DCODE_OFFSET 0
#endif #endif
#define DYN_HDR_START_LEN 17 #define DYN_HDR_START_LEN 17
#define MAX_HISTHEAP_SIZE LIT_LEN #define MAX_HISTHEAP_SIZE LIT_LEN
#define MAX_HUFF_TREE_DEPTH 15 #define MAX_HUFF_TREE_DEPTH 15
#define D IGZIP_HIST_SIZE /* Amount of history */ #define D IGZIP_HIST_SIZE /* Amount of history */
#define MAX_DEFLATE_CODE_LEN 15 #define MAX_DEFLATE_CODE_LEN 15
#define MAX_SAFE_LIT_CODE_LEN 13 #define MAX_SAFE_LIT_CODE_LEN 13
#define MAX_SAFE_DIST_CODE_LEN 12 #define MAX_SAFE_DIST_CODE_LEN 12
#define LONG_DIST_TABLE_SIZE 8192 #define LONG_DIST_TABLE_SIZE 8192
#define SHORT_DIST_TABLE_SIZE 2 #define SHORT_DIST_TABLE_SIZE 2
#define LEN_TABLE_SIZE 256 #define LEN_TABLE_SIZE 256
#define LIT_TABLE_SIZE 257 #define LIT_TABLE_SIZE 257
#define LAST_BLOCK 1 #define LAST_BLOCK 1
#define LEN_EXTRA_BITS_START 264 #define LEN_EXTRA_BITS_START 264
#define LEN_EXTRA_BITS_INTERVAL 4 #define LEN_EXTRA_BITS_INTERVAL 4
#define DIST_EXTRA_BITS_START 3 #define DIST_EXTRA_BITS_START 3
#define DIST_EXTRA_BITS_INTERVAL 2 #define DIST_EXTRA_BITS_INTERVAL 2
#define INVALID_LIT_LEN_HUFFCODE 1 #define INVALID_LIT_LEN_HUFFCODE 1
#define INVALID_DIST_HUFFCODE 1 #define INVALID_DIST_HUFFCODE 1
#define INVALID_HUFFCODE 1 #define INVALID_HUFFCODE 1
#define HASH8K_HASH_MASK (IGZIP_HASH8K_HASH_SIZE - 1) #define HASH8K_HASH_MASK (IGZIP_HASH8K_HASH_SIZE - 1)
#define HASH_HIST_HASH_MASK (IGZIP_HASH_HIST_SIZE - 1) #define HASH_HIST_HASH_MASK (IGZIP_HASH_HIST_SIZE - 1)
#define HASH_MAP_HASH_MASK (IGZIP_HASH_MAP_HASH_SIZE - 1) #define HASH_MAP_HASH_MASK (IGZIP_HASH_MAP_HASH_SIZE - 1)
#define LVL0_HASH_MASK (IGZIP_LVL0_HASH_SIZE - 1) #define LVL0_HASH_MASK (IGZIP_LVL0_HASH_SIZE - 1)
#define LVL1_HASH_MASK (IGZIP_LVL1_HASH_SIZE - 1) #define LVL1_HASH_MASK (IGZIP_LVL1_HASH_SIZE - 1)
#define LVL2_HASH_MASK (IGZIP_LVL2_HASH_SIZE - 1) #define LVL2_HASH_MASK (IGZIP_LVL2_HASH_SIZE - 1)
#define LVL3_HASH_MASK (IGZIP_LVL3_HASH_SIZE - 1) #define LVL3_HASH_MASK (IGZIP_LVL3_HASH_SIZE - 1)
#define SHORTEST_MATCH 4 #define SHORTEST_MATCH 4
#define LENGTH_BITS 5 #define LENGTH_BITS 5
#define FREQ_SHIFT 16 #define FREQ_SHIFT 16
#define FREQ_MASK_HI (0xFFFFFFFFFFFF0000) #define FREQ_MASK_HI (0xFFFFFFFFFFFF0000)
#define DEPTH_SHIFT 24 #define DEPTH_SHIFT 24
#define DEPTH_MASK 0x7F #define DEPTH_MASK 0x7F
#define DEPTH_MASK_HI (DEPTH_MASK << DEPTH_SHIFT) #define DEPTH_MASK_HI (DEPTH_MASK << DEPTH_SHIFT)
#define DEPTH_1 (1 << DEPTH_SHIFT) #define DEPTH_1 (1 << DEPTH_SHIFT)
#define HEAP_TREE_SIZE (3*MAX_HISTHEAP_SIZE + 1) #define HEAP_TREE_SIZE (3 * MAX_HISTHEAP_SIZE + 1)
#define HEAP_TREE_NODE_START (HEAP_TREE_SIZE-1) #define HEAP_TREE_NODE_START (HEAP_TREE_SIZE - 1)
#define MAX_BL_CODE_LEN 7 #define MAX_BL_CODE_LEN 7
/** /**
* @brief Structure used to store huffman codes * @brief Structure used to store huffman codes
*/ */
struct huff_code { struct huff_code {
union { union {
struct { struct {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint32_t code_and_extra:24; uint32_t code_and_extra : 24;
uint32_t length2:8; uint32_t length2 : 8;
#else #else
uint32_t length2:8; uint32_t length2 : 8;
uint32_t code_and_extra:24; uint32_t code_and_extra : 24;
#endif #endif
}; };
struct { struct {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint16_t code; uint16_t code;
uint8_t extra_bit_count; uint8_t extra_bit_count;
uint8_t length; uint8_t length;
#else #else
uint8_t length; uint8_t length;
uint8_t extra_bit_count; uint8_t extra_bit_count;
uint16_t code; uint16_t code;
#endif #endif
}; };
uint32_t code_and_length; uint32_t code_and_length;
}; };
}; };
struct tree_node { struct tree_node {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
uint32_t child; uint32_t child;
uint32_t depth; uint32_t depth;
#else #else
uint32_t depth; uint32_t depth;
uint32_t child; uint32_t child;
#endif #endif
}; };
struct heap_tree { struct heap_tree {
union { union {
uint64_t heap[HEAP_TREE_SIZE]; uint64_t heap[HEAP_TREE_SIZE];
uint64_t code_len_count[MAX_HUFF_TREE_DEPTH + 1]; uint64_t code_len_count[MAX_HUFF_TREE_DEPTH + 1];
struct tree_node tree[HEAP_TREE_SIZE]; struct tree_node tree[HEAP_TREE_SIZE];
}; };
}; };
struct rl_code { struct rl_code {
uint8_t code; uint8_t code;
uint8_t extra_bits; uint8_t extra_bits;
}; };
struct hufftables_icf { struct hufftables_icf {
union { union {
struct { struct {
struct huff_code dist_lit_table[288]; struct huff_code dist_lit_table[288];
struct huff_code len_table[256]; struct huff_code len_table[256];
}; };
struct { struct {
struct huff_code dist_table[31]; struct huff_code dist_table[31];
struct huff_code lit_len_table[513]; struct huff_code lit_len_table[513];
}; };
}; };
}; };
/** /**
@ -181,6 +181,6 @@ struct hufftables_icf {
*/ */
uint64_t uint64_t
create_hufftables_icf(struct BitBuf2 *bb, struct hufftables_icf *hufftables, create_hufftables_icf(struct BitBuf2 *bb, struct hufftables_icf *hufftables,
struct isal_mod_hist *hist, uint32_t end_of_block); struct isal_mod_hist *hist, uint32_t end_of_block);
#endif #endif

438
igzip/huffman.h
View File

@ -33,15 +33,15 @@
#include "igzip_lib.h" #include "igzip_lib.h"
#include "unaligned.h" #include "unaligned.h"
#if __x86_64__ || __i386__ || _M_X64 || _M_IX86 #if __x86_64__ || __i386__ || _M_X64 || _M_IX86
#ifdef _MSC_VER #ifdef _MSC_VER
# include <intrin.h> #include <intrin.h>
# define inline __inline #define inline __inline
#else #else
# include <x86intrin.h> #include <x86intrin.h>
#endif #endif
#else #else
# define inline __inline #define inline __inline
#endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86 #endif //__x86_64__ || __i386__ || _M_X64 || _M_IX86
/** /**
@ -50,195 +50,205 @@
* *
* @returns bit offset of msb starting at 1 for first bit * @returns bit offset of msb starting at 1 for first bit
*/ */
static inline uint32_t bsr(uint32_t val) static inline uint32_t
bsr(uint32_t val)
{ {
uint32_t msb; uint32_t msb;
#if defined(_MSC_VER) #if defined(_MSC_VER)
unsigned long ret = 0; unsigned long ret = 0;
if (val != 0) { if (val != 0) {
_BitScanReverse(&ret, val); _BitScanReverse(&ret, val);
msb = ret + 1; msb = ret + 1;
} else } else
msb = 0; msb = 0;
#elif defined( __LZCNT__) #elif defined(__LZCNT__)
msb = 32 - __lzcnt32(val); msb = 32 - __lzcnt32(val);
#elif defined(__x86_64__) || defined(__aarch64__) #elif defined(__x86_64__) || defined(__aarch64__)
msb = (val == 0) ? 0 : 32 - __builtin_clz(val); msb = (val == 0) ? 0 : 32 - __builtin_clz(val);
#else #else
for (msb = 0; val > 0; val >>= 1) for (msb = 0; val > 0; val >>= 1)
msb++; msb++;
#endif #endif
return msb; return msb;
} }
static inline uint32_t tzbytecnt(uint64_t val) static inline uint32_t
tzbytecnt(uint64_t val)
{ {
uint32_t cnt; uint32_t cnt;
#ifdef __BMI__ #ifdef __BMI__
cnt = __tzcnt_u64(val); cnt = __tzcnt_u64(val);
cnt = cnt / 8; cnt = cnt / 8;
#elif defined(__x86_64__) || defined(__aarch64__) #elif defined(__x86_64__) || defined(__aarch64__)
cnt = (val == 0) ? 64 : __builtin_ctzll(val); cnt = (val == 0) ? 64 : __builtin_ctzll(val);
cnt = cnt / 8; cnt = cnt / 8;
#else #else
for (cnt = 8; val > 0; val <<= 8) for (cnt = 8; val > 0; val <<= 8)
cnt -= 1; cnt -= 1;
#endif #endif
return cnt; return cnt;
} }
static void compute_dist_code(struct isal_hufftables *hufftables, uint16_t dist, static void
uint64_t * p_code, uint64_t * p_len) compute_dist_code(struct isal_hufftables *hufftables, uint16_t dist, uint64_t *p_code,
uint64_t *p_len)
{ {
assert(dist > IGZIP_DIST_TABLE_SIZE); assert(dist > IGZIP_DIST_TABLE_SIZE);
dist -= 1; dist -= 1;
uint32_t msb; uint32_t msb;
uint32_t num_extra_bits; uint32_t num_extra_bits;
uint32_t extra_bits; uint32_t extra_bits;
uint32_t sym; uint32_t sym;
uint32_t len; uint32_t len;
uint32_t code; uint32_t code;
msb = bsr(dist); msb = bsr(dist);
assert(msb >= 2); assert(msb >= 2);
num_extra_bits = msb - 2; num_extra_bits = msb - 2;
extra_bits = dist & ((1 << num_extra_bits) - 1); extra_bits = dist & ((1 << num_extra_bits) - 1);
dist >>= num_extra_bits; dist >>= num_extra_bits;
sym = dist + 2 * num_extra_bits; sym = dist + 2 * num_extra_bits;
assert(sym < 30); assert(sym < 30);
code = hufftables->dcodes[sym - IGZIP_DECODE_OFFSET]; code = hufftables->dcodes[sym - IGZIP_DECODE_OFFSET];
len = hufftables->dcodes_sizes[sym - IGZIP_DECODE_OFFSET]; len = hufftables->dcodes_sizes[sym - IGZIP_DECODE_OFFSET];
*p_code = code | (extra_bits << len); *p_code = code | (extra_bits << len);
*p_len = len + num_extra_bits; *p_len = len + num_extra_bits;
} }
static inline void get_dist_code(struct isal_hufftables *hufftables, uint32_t dist, static inline void
uint64_t * code, uint64_t * len) get_dist_code(struct isal_hufftables *hufftables, uint32_t dist, uint64_t *code, uint64_t *len)
{ {
assert(dist >= 1); assert(dist >= 1);
assert(dist <= 32768); assert(dist <= 32768);
if (dist <= IGZIP_DIST_TABLE_SIZE) { if (dist <= IGZIP_DIST_TABLE_SIZE) {
uint64_t code_len; uint64_t code_len;
code_len = hufftables->dist_table[dist - 1]; code_len = hufftables->dist_table[dist - 1];
*code = code_len >> 5; *code = code_len >> 5;
*len = code_len & 0x1F; *len = code_len & 0x1F;
} else { } else {
compute_dist_code(hufftables, dist, code, len); compute_dist_code(hufftables, dist, code, len);
} }
} }
static inline void get_len_code(struct isal_hufftables *hufftables, uint32_t length, static inline void
uint64_t * code, uint64_t * len) get_len_code(struct isal_hufftables *hufftables, uint32_t length, uint64_t *code, uint64_t *len)
{ {
assert(length >= 3); assert(length >= 3);
assert(length <= 258); assert(length <= 258);
uint64_t code_len; uint64_t code_len;
code_len = hufftables->len_table[length - 3]; code_len = hufftables->len_table[length - 3];
*code = code_len >> 5; *code = code_len >> 5;
*len = code_len & 0x1F; *len = code_len & 0x1F;
} }
static inline void get_lit_code(struct isal_hufftables *hufftables, uint32_t lit, static inline void
uint64_t * code, uint64_t * len) get_lit_code(struct isal_hufftables *hufftables, uint32_t lit, uint64_t *code, uint64_t *len)
{ {
assert(lit <= 256); assert(lit <= 256);
*code = hufftables->lit_table[lit]; *code = hufftables->lit_table[lit];
*len = hufftables->lit_table_sizes[lit]; *len = hufftables->lit_table_sizes[lit];
} }
static void compute_dist_icf_code(uint32_t dist, uint32_t * code, uint32_t * extra_bits) static void
compute_dist_icf_code(uint32_t dist, uint32_t *code, uint32_t *extra_bits)
{ {
uint32_t msb; uint32_t msb;
uint32_t num_extra_bits; uint32_t num_extra_bits;
dist -= 1; dist -= 1;
msb = bsr(dist); msb = bsr(dist);
assert(msb >= 2); assert(msb >= 2);
num_extra_bits = msb - 2; num_extra_bits = msb - 2;
*extra_bits = dist & ((1 << num_extra_bits) - 1); *extra_bits = dist & ((1 << num_extra_bits) - 1);
dist >>= num_extra_bits; dist >>= num_extra_bits;
*code = dist + 2 * num_extra_bits; *code = dist + 2 * num_extra_bits;
assert(*code < 30); assert(*code < 30);
} }
static inline void get_dist_icf_code(uint32_t dist, uint32_t * code, uint32_t * extra_bits) static inline void
get_dist_icf_code(uint32_t dist, uint32_t *code, uint32_t *extra_bits)
{ {
assert(dist >= 1); assert(dist >= 1);
assert(dist <= 32768); assert(dist <= 32768);
if (dist <= 2) { if (dist <= 2) {
*code = dist - 1; *code = dist - 1;
*extra_bits = 0; *extra_bits = 0;
} else { } else {
compute_dist_icf_code(dist, code, extra_bits); compute_dist_icf_code(dist, code, extra_bits);
} }
} }
static inline void get_len_icf_code(uint32_t length, uint32_t * code) static inline void
get_len_icf_code(uint32_t length, uint32_t *code)
{ {
assert(length >= 3); assert(length >= 3);
assert(length <= 258); assert(length <= 258);
*code = length + 254; *code = length + 254;
} }
static inline void get_lit_icf_code(uint32_t lit, uint32_t * code) static inline void
get_lit_icf_code(uint32_t lit, uint32_t *code)
{ {
assert(lit <= 256); assert(lit <= 256);
*code = lit; *code = lit;
} }
/** /**
* @brief Returns a hash of the first 3 bytes of input data. * @brief Returns a hash of the first 3 bytes of input data.
*/ */
static inline uint32_t compute_hash(uint32_t data) static inline uint32_t
compute_hash(uint32_t data)
{ {
#ifdef __SSE4_2__ #ifdef __SSE4_2__
return _mm_crc32_u32(0, data); return _mm_crc32_u32(0, data);
#else #else
uint64_t hash; uint64_t hash;
/* Use multiplication to create a hash, 0xBDD06057 is a prime number */ /* Use multiplication to create a hash, 0xBDD06057 is a prime number */
hash = data; hash = data;
hash *= 0xB2D06057; hash *= 0xB2D06057;
hash >>= 16; hash >>= 16;
hash *= 0xB2D06057; hash *= 0xB2D06057;
hash >>= 16; hash >>= 16;
return hash; return hash;
#endif /* __SSE4_2__ */ #endif /* __SSE4_2__ */
} }
#define PROD1 0xFFFFE84B #define PROD1 0xFFFFE84B
#define PROD2 0xFFFF97B1 #define PROD2 0xFFFF97B1
static inline uint32_t compute_hash_mad(uint32_t data) static inline uint32_t
compute_hash_mad(uint32_t data)
{ {
int16_t data_low; int16_t data_low;
int16_t data_high; int16_t data_high;
data_low = data; data_low = data;
data_high = data >> 16; data_high = data >> 16;
data = PROD1 * data_low + PROD2 * data_high; data = PROD1 * data_low + PROD2 * data_high;
data_low = data; data_low = data;
data_high = data >> 16; data_high = data >> 16;
data = PROD1 * data_low + PROD2 * data_high; data = PROD1 * data_low + PROD2 * data_high;
return data; return data;
} }
static inline uint32_t compute_long_hash(uint64_t data) static inline uint32_t
compute_long_hash(uint64_t data)
{ {
return compute_hash(data >> 32) ^ compute_hash(data); return compute_hash(data >> 32) ^ compute_hash(data);
} }
/** /**
@ -247,59 +257,60 @@ static inline uint32_t compute_long_hash(uint64_t data)
* @param str2: Second input string. * @param str2: Second input string.
* @param max_length: length of the smaller string. * @param max_length: length of the smaller string.
*/ */
static inline int compare258(uint8_t * str1, uint8_t * str2, uint32_t max_length) static inline int
compare258(uint8_t *str1, uint8_t *str2, uint32_t max_length)
{ {
uint32_t count; uint32_t count;
uint64_t test; uint64_t test;
uint64_t loop_length; uint64_t loop_length;
if (max_length > 258) if (max_length > 258)
max_length = 258; max_length = 258;
loop_length = max_length & ~0x7; loop_length = max_length & ~0x7;
for (count = 0; count < loop_length; count += 8) { for (count = 0; count < loop_length; count += 8) {
test = load_le_u64(str1); test = load_le_u64(str1);
test ^= load_le_u64(str2); test ^= load_le_u64(str2);
if (test != 0) if (test != 0)
return count + tzbytecnt(test); return count + tzbytecnt(test);
str1 += 8; str1 += 8;
str2 += 8; str2 += 8;
} }
switch (max_length % 8) { switch (max_length % 8) {
case 7: case 7:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 6: case 6:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 5: case 5:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 4: case 4:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 3: case 3:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 2: case 2:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 1: case 1:
if (*str1 != *str2) if (*str1 != *str2)
return count; return count;
count++; count++;
} }
return count; return count;
} }
/** /**
@ -308,54 +319,55 @@ static inline int compare258(uint8_t * str1, uint8_t * str2, uint32_t max_length
* @param str2: Second input string. * @param str2: Second input string.
* @param max_length: length of the smaller string. * @param max_length: length of the smaller string.
*/ */
static inline int compare(uint8_t * str1, uint8_t * str2, uint32_t max_length) static inline int
compare(uint8_t *str1, uint8_t *str2, uint32_t max_length)
{ {
uint32_t count; uint32_t count;
uint64_t test; uint64_t test;
uint64_t loop_length; uint64_t loop_length;
loop_length = max_length & ~0x7; loop_length = max_length & ~0x7;
for (count = 0; count < loop_length; count += 8) { for (count = 0; count < loop_length; count += 8) {
test = load_le_u64(str1); test = load_le_u64(str1);
test ^= load_le_u64(str2); test ^= load_le_u64(str2);
if (test != 0) if (test != 0)
return count + tzbytecnt(test); return count + tzbytecnt(test);
str1 += 8; str1 += 8;
str2 += 8; str2 += 8;
} }
switch (max_length % 8) { switch (max_length % 8) {
case 7: case 7:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 6: case 6:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 5: case 5:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 4: case 4:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 3: case 3:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 2: case 2:
if (*str1++ != *str2++) if (*str1++ != *str2++)
return count; return count;
count++; count++;
case 1: case 1:
if (*str1 != *str2) if (*str1 != *str2)
return count; return count;
count++; count++;
} }
return count; return count;
} }

11946
igzip/hufftables_c.c
View File

File diff suppressed because it is too large Load Diff

3047
igzip/igzip.c
View File

File diff suppressed because it is too large Load Diff

336
igzip/igzip_base.c
View File

@ -6,231 +6,229 @@
extern const struct isal_hufftables hufftables_default; extern const struct isal_hufftables hufftables_default;
static inline void update_state(struct isal_zstream *stream, uint8_t * start_in, static inline void
uint8_t * next_in, uint8_t * end_in) update_state(struct isal_zstream *stream, uint8_t *start_in, uint8_t *next_in, uint8_t *end_in)
{ {
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
uint32_t bytes_written; uint32_t bytes_written;
if (next_in - start_in > 0) if (next_in - start_in > 0)
state->has_hist = IGZIP_HIST; state->has_hist = IGZIP_HIST;
stream->next_in = next_in; stream->next_in = next_in;
stream->total_in += next_in - start_in; stream->total_in += next_in - start_in;
stream->avail_in = end_in - next_in; stream->avail_in = end_in - next_in;
bytes_written = buffer_used(&state->bitbuf);
stream->total_out += bytes_written;
stream->next_out += bytes_written;
stream->avail_out -= bytes_written;
bytes_written = buffer_used(&state->bitbuf);
stream->total_out += bytes_written;
stream->next_out += bytes_written;
stream->avail_out -= bytes_written;
} }
void isal_deflate_body_base(struct isal_zstream *stream) void
isal_deflate_body_base(struct isal_zstream *stream)
{ {
uint32_t literal, hash; uint32_t literal, hash;
uint8_t *start_in, *next_in, *end_in, *end, *next_hash; uint8_t *start_in, *next_in, *end_in, *end, *next_hash;
uint16_t match_length; uint16_t match_length;
uint32_t dist; uint32_t dist;
uint64_t code, code_len, code2, code_len2; uint64_t code, code_len, code2, code_len2;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
uint16_t *last_seen = state->head; uint16_t *last_seen = state->head;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hist_size = state->dist_mask; uint32_t hist_size = state->dist_mask;
uint32_t hash_mask = state->hash_mask; uint32_t hash_mask = state->hash_mask;
if (stream->avail_in == 0) { if (stream->avail_in == 0) {
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_FLUSH_READ_BUFFER; state->state = ZSTATE_FLUSH_READ_BUFFER;
return; return;
} }
set_buf(&state->bitbuf, stream->next_out, stream->avail_out); set_buf(&state->bitbuf, stream->next_out, stream->avail_out);
start_in = stream->next_in; start_in = stream->next_in;
end_in = start_in + stream->avail_in; end_in = start_in + stream->avail_in;
next_in = start_in; next_in = start_in;
while (next_in + ISAL_LOOK_AHEAD < end_in) { while (next_in + ISAL_LOOK_AHEAD < end_in) {
if (is_full(&state->bitbuf)) { if (is_full(&state->bitbuf)) {
update_state(stream, start_in, next_in, end_in); update_state(stream, start_in, next_in, end_in);
return; return;
} }
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
dist = (next_in - file_start - last_seen[hash]) & 0xFFFF; dist = (next_in - file_start - last_seen[hash]) & 0xFFFF;
last_seen[hash] = (uint64_t) (next_in - file_start); last_seen[hash] = (uint64_t) (next_in - file_start);
/* The -1 are to handle the case when dist = 0 */ /* The -1 are to handle the case when dist = 0 */
if (dist - 1 < hist_size) { if (dist - 1 < hist_size) {
assert(dist != 0); assert(dist != 0);
match_length = compare258(next_in - dist, next_in, 258); match_length = compare258(next_in - dist, next_in, 258);
if (match_length >= SHORTEST_MATCH) { if (match_length >= SHORTEST_MATCH) {
next_hash = next_in; next_hash = next_in;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
next_hash++; next_hash++;
for (; next_hash < end; next_hash++) { for (; next_hash < end; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
last_seen[hash] = (uint64_t) (next_hash - file_start); last_seen[hash] = (uint64_t) (next_hash - file_start);
} }
get_len_code(stream->hufftables, match_length, &code, get_len_code(stream->hufftables, match_length, &code, &code_len);
&code_len); get_dist_code(stream->hufftables, dist, &code2, &code_len2);
get_dist_code(stream->hufftables, dist, &code2, &code_len2);
code |= code2 << code_len; code |= code2 << code_len;
code_len += code_len2; code_len += code_len2;
write_bits(&state->bitbuf, code, code_len); write_bits(&state->bitbuf, code, code_len);
next_in += match_length; next_in += match_length;
continue; continue;
} }
} }
get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len); get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len);
write_bits(&state->bitbuf, code, code_len); write_bits(&state->bitbuf, code, code_len);
next_in++; next_in++;
} }
update_state(stream, start_in, next_in, end_in); update_state(stream, start_in, next_in, end_in);
assert(stream->avail_in <= ISAL_LOOK_AHEAD); assert(stream->avail_in <= ISAL_LOOK_AHEAD);
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_FLUSH_READ_BUFFER; state->state = ZSTATE_FLUSH_READ_BUFFER;
return;
return;
} }
void isal_deflate_finish_base(struct isal_zstream *stream) void
isal_deflate_finish_base(struct isal_zstream *stream)
{ {
uint32_t literal = 0, hash; uint32_t literal = 0, hash;
uint8_t *start_in, *next_in, *end_in, *end, *next_hash; uint8_t *start_in, *next_in, *end_in, *end, *next_hash;
uint16_t match_length; uint16_t match_length;
uint32_t dist; uint32_t dist;
uint64_t code, code_len, code2, code_len2; uint64_t code, code_len, code2, code_len2;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
uint16_t *last_seen = state->head; uint16_t *last_seen = state->head;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hist_size = state->dist_mask; uint32_t hist_size = state->dist_mask;
uint32_t hash_mask = state->hash_mask; uint32_t hash_mask = state->hash_mask;
set_buf(&state->bitbuf, stream->next_out, stream->avail_out); set_buf(&state->bitbuf, stream->next_out, stream->avail_out);
start_in = stream->next_in; start_in = stream->next_in;
end_in = start_in + stream->avail_in; end_in = start_in + stream->avail_in;
next_in = start_in; next_in = start_in;
if (stream->avail_in != 0) { if (stream->avail_in != 0) {
while (next_in + 3 < end_in) { while (next_in + 3 < end_in) {
if (is_full(&state->bitbuf)) { if (is_full(&state->bitbuf)) {
update_state(stream, start_in, next_in, end_in); update_state(stream, start_in, next_in, end_in);
return; return;
} }
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
dist = (next_in - file_start - last_seen[hash]) & 0xFFFF; dist = (next_in - file_start - last_seen[hash]) & 0xFFFF;
last_seen[hash] = (uint64_t) (next_in - file_start); last_seen[hash] = (uint64_t) (next_in - file_start);
if (dist - 1 < hist_size) { /* The -1 are to handle the case when dist = 0 */ if (dist - 1 <
match_length = hist_size) { /* The -1 are to handle the case when dist = 0 */
compare258(next_in - dist, next_in, end_in - next_in); match_length =
compare258(next_in - dist, next_in, end_in - next_in);
if (match_length >= SHORTEST_MATCH) { if (match_length >= SHORTEST_MATCH) {
next_hash = next_in; next_hash = next_in;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
next_hash++; next_hash++;
for (; next_hash < end - 3; next_hash++) { for (; next_hash < end - 3; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
last_seen[hash] = last_seen[hash] =
(uint64_t) (next_hash - file_start); (uint64_t) (next_hash - file_start);
} }
get_len_code(stream->hufftables, match_length, &code, get_len_code(stream->hufftables, match_length, &code,
&code_len); &code_len);
get_dist_code(stream->hufftables, dist, &code2, get_dist_code(stream->hufftables, dist, &code2, &code_len2);
&code_len2);
code |= code2 << code_len; code |= code2 << code_len;
code_len += code_len2; code_len += code_len2;
write_bits(&state->bitbuf, code, code_len); write_bits(&state->bitbuf, code, code_len);
next_in += match_length; next_in += match_length;
continue; continue;
} }
} }
get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len); get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len);
write_bits(&state->bitbuf, code, code_len); write_bits(&state->bitbuf, code, code_len);
next_in++; next_in++;
}
} while (next_in < end_in) {
if (is_full(&state->bitbuf)) {
update_state(stream, start_in, next_in, end_in);
return;
}
while (next_in < end_in) { literal = *next_in;
if (is_full(&state->bitbuf)) { get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len);
update_state(stream, start_in, next_in, end_in); write_bits(&state->bitbuf, code, code_len);
return; next_in++;
} }
}
literal = *next_in; if (!is_full(&state->bitbuf)) {
get_lit_code(stream->hufftables, literal & 0xFF, &code, &code_len); get_lit_code(stream->hufftables, 256, &code, &code_len);
write_bits(&state->bitbuf, code, code_len); write_bits(&state->bitbuf, code, code_len);
next_in++; state->has_eob = 1;
} if (stream->end_of_stream == 1)
} state->state = ZSTATE_TRL;
else
state->state = ZSTATE_SYNC_FLUSH;
}
if (!is_full(&state->bitbuf)) { update_state(stream, start_in, next_in, end_in);
get_lit_code(stream->hufftables, 256, &code, &code_len);
write_bits(&state->bitbuf, code, code_len);
state->has_eob = 1;
if (stream->end_of_stream == 1) return;
state->state = ZSTATE_TRL;
else
state->state = ZSTATE_SYNC_FLUSH;
}
update_state(stream, start_in, next_in, end_in);
return;
} }
void isal_deflate_hash_base(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_base(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
uint8_t *next_in = dict; uint8_t *next_in = dict;
uint8_t *end_in = dict + dict_len - SHORTEST_MATCH; uint8_t *end_in = dict + dict_len - SHORTEST_MATCH;
uint32_t literal; uint32_t literal;
uint32_t hash; uint32_t hash;
uint16_t index = current_index - dict_len; uint16_t index = current_index - dict_len;
while (next_in <= end_in) { while (next_in <= end_in) {
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
hash_table[hash] = index; hash_table[hash] = index;
index++; index++;
next_in++; next_in++;
} }
} }

154
igzip/igzip_base_aliases.c
View File

@ -32,122 +32,150 @@
#include "encode_df.h" #include "encode_df.h"
#include "igzip_level_buf_structs.h" #include "igzip_level_buf_structs.h"
void isal_deflate_body_base(struct isal_zstream *stream); void
void isal_deflate_finish_base(struct isal_zstream *stream); isal_deflate_body_base(struct isal_zstream *stream);
void isal_deflate_icf_body_hash_hist_base(struct isal_zstream *stream); void
void icf_body_hash1_fillgreedy_lazy(struct isal_zstream *stream); isal_deflate_finish_base(struct isal_zstream *stream);
void isal_deflate_icf_finish_hash_hist_base(struct isal_zstream *stream); void
void isal_deflate_icf_finish_hash_map_base(struct isal_zstream *stream); isal_deflate_icf_body_hash_hist_base(struct isal_zstream *stream);
void isal_update_histogram_base(uint8_t * start_stream, int length, void
struct isal_huff_histogram *histogram); icf_body_hash1_fillgreedy_lazy(struct isal_zstream *stream);
struct deflate_icf *encode_deflate_icf_base(struct deflate_icf *next_in, void
struct deflate_icf *end_in, struct BitBuf2 *bb, isal_deflate_icf_finish_hash_hist_base(struct isal_zstream *stream);
struct hufftables_icf *hufftables); void
uint32_t adler32_base(uint32_t init, const unsigned char *buf, uint64_t len); isal_deflate_icf_finish_hash_map_base(struct isal_zstream *stream);
int decode_huffman_code_block_stateless_base(struct inflate_state *s, uint8_t * start_out); void
isal_update_histogram_base(uint8_t *start_stream, int length,
struct isal_huff_histogram *histogram);
struct deflate_icf *
encode_deflate_icf_base(struct deflate_icf *next_in, struct deflate_icf *end_in, struct BitBuf2 *bb,
struct hufftables_icf *hufftables);
uint32_t
adler32_base(uint32_t init, const unsigned char *buf, uint64_t len);
int
decode_huffman_code_block_stateless_base(struct inflate_state *s, uint8_t *start_out);
extern void isal_deflate_hash_base(uint16_t *, uint32_t, uint32_t, uint8_t *, uint32_t); extern void
isal_deflate_hash_base(uint16_t *, uint32_t, uint32_t, uint8_t *, uint32_t);
void set_long_icf_fg_base(uint8_t * next_in, uint8_t * end_in, void
struct deflate_icf *match_lookup, struct level_buf *level_buf); set_long_icf_fg_base(uint8_t *next_in, uint8_t *end_in, struct deflate_icf *match_lookup,
void gen_icf_map_h1_base(struct isal_zstream *stream, struct level_buf *level_buf);
struct deflate_icf *matches_icf_lookup, uint64_t input_size); void
gen_icf_map_h1_base(struct isal_zstream *stream, struct deflate_icf *matches_icf_lookup,
uint64_t input_size);
void isal_deflate_body(struct isal_zstream *stream) void
isal_deflate_body(struct isal_zstream *stream)
{ {
isal_deflate_body_base(stream); isal_deflate_body_base(stream);
} }
void isal_deflate_finish(struct isal_zstream *stream) void
isal_deflate_finish(struct isal_zstream *stream)
{ {
isal_deflate_finish_base(stream); isal_deflate_finish_base(stream);
} }
void isal_deflate_icf_body_lvl1(struct isal_zstream *stream) void
isal_deflate_icf_body_lvl1(struct isal_zstream *stream)
{ {
isal_deflate_icf_body_hash_hist_base(stream); isal_deflate_icf_body_hash_hist_base(stream);
} }
void isal_deflate_icf_body_lvl2(struct isal_zstream *stream) void
isal_deflate_icf_body_lvl2(struct isal_zstream *stream)
{ {
isal_deflate_icf_body_hash_hist_base(stream); isal_deflate_icf_body_hash_hist_base(stream);
} }
void isal_deflate_icf_body_lvl3(struct isal_zstream *stream) void
isal_deflate_icf_body_lvl3(struct isal_zstream *stream)
{ {
icf_body_hash1_fillgreedy_lazy(stream); icf_body_hash1_fillgreedy_lazy(stream);
} }
void isal_deflate_icf_finish_lvl1(struct isal_zstream *stream) void
isal_deflate_icf_finish_lvl1(struct isal_zstream *stream)
{ {
isal_deflate_icf_finish_hash_hist_base(stream); isal_deflate_icf_finish_hash_hist_base(stream);
} }
void isal_deflate_icf_finish_lvl2(struct isal_zstream *stream) void
isal_deflate_icf_finish_lvl2(struct isal_zstream *stream)
{ {
isal_deflate_icf_finish_hash_hist_base(stream); isal_deflate_icf_finish_hash_hist_base(stream);
} }
void isal_deflate_icf_finish_lvl3(struct isal_zstream *stream) void
isal_deflate_icf_finish_lvl3(struct isal_zstream *stream)
{ {
isal_deflate_icf_finish_hash_map_base(stream); isal_deflate_icf_finish_hash_map_base(stream);
} }
void isal_update_histogram(uint8_t * start_stream, int length, void
struct isal_huff_histogram *histogram) isal_update_histogram(uint8_t *start_stream, int length, struct isal_huff_histogram *histogram)
{ {
isal_update_histogram_base(start_stream, length, histogram); isal_update_histogram_base(start_stream, length, histogram);
} }
struct deflate_icf *encode_deflate_icf(struct deflate_icf *next_in, struct deflate_icf *
struct deflate_icf *end_in, struct BitBuf2 *bb, encode_deflate_icf(struct deflate_icf *next_in, struct deflate_icf *end_in, struct BitBuf2 *bb,
struct hufftables_icf *hufftables) struct hufftables_icf *hufftables)
{ {
return encode_deflate_icf_base(next_in, end_in, bb, hufftables); return encode_deflate_icf_base(next_in, end_in, bb, hufftables);
} }
uint32_t isal_adler32(uint32_t init, const unsigned char *buf, uint64_t len) uint32_t
isal_adler32(uint32_t init, const unsigned char *buf, uint64_t len)
{ {
return adler32_base(init, buf, len); return adler32_base(init, buf, len);
} }
int decode_huffman_code_block_stateless(struct inflate_state *s, uint8_t * start_out) int
decode_huffman_code_block_stateless(struct inflate_state *s, uint8_t *start_out)
{ {
return decode_huffman_code_block_stateless_base(s, start_out); return decode_huffman_code_block_stateless_base(s, start_out);
} }
void isal_deflate_hash_lvl0(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_lvl0(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len); isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len);
} }
void isal_deflate_hash_lvl1(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_lvl1(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len); isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len);
} }
void isal_deflate_hash_lvl2(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_lvl2(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len); isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len);
} }
void isal_deflate_hash_lvl3(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_lvl3(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len); isal_deflate_hash_base(hash_table, hash_mask, current_index, dict, dict_len);
} }
void set_long_icf_fg(uint8_t * next_in, uint8_t * end_in, void
struct deflate_icf *match_lookup, struct level_buf *level_buf) set_long_icf_fg(uint8_t *next_in, uint8_t *end_in, struct deflate_icf *match_lookup,
struct level_buf *level_buf)
{ {
set_long_icf_fg_base(next_in, end_in, match_lookup, level_buf); set_long_icf_fg_base(next_in, end_in, match_lookup, level_buf);
} }
void gen_icf_map_lh1(struct isal_zstream *stream, void
struct deflate_icf *matches_icf_lookup, uint64_t input_size) gen_icf_map_lh1(struct isal_zstream *stream, struct deflate_icf *matches_icf_lookup,
uint64_t input_size)
{ {
gen_icf_map_h1_base(stream, matches_icf_lookup, input_size); gen_icf_map_h1_base(stream, matches_icf_lookup, input_size);
} }

43
igzip/igzip_build_hash_table_perf.c
View File

@ -7,34 +7,37 @@
#include "test.h" #include "test.h"
#include "huff_codes.h" #include "huff_codes.h"
#define DICT_LEN 32*1024 #define DICT_LEN 32 * 1024
extern void isal_deflate_hash(struct isal_zstream *stream, uint8_t * dict, int dict_len); extern void
isal_deflate_hash(struct isal_zstream *stream, uint8_t *dict, int dict_len);
void create_rand_data(uint8_t * data, uint32_t size) void
create_rand_data(uint8_t *data, uint32_t size)
{ {
int i; int i;
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
data[i] = rand() % 256; data[i] = rand() % 256;
} }
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
int time = BENCHMARK_TIME; int time = BENCHMARK_TIME;
struct isal_zstream stream; struct isal_zstream stream;
uint8_t dict[DICT_LEN]; uint8_t dict[DICT_LEN];
uint32_t dict_len = DICT_LEN; uint32_t dict_len = DICT_LEN;
stream.level = 0; stream.level = 0;
stream.internal_state.hash_mask = LVL0_HASH_MASK; stream.internal_state.hash_mask = LVL0_HASH_MASK;
create_rand_data(dict, dict_len); create_rand_data(dict, dict_len);
struct perf start; struct perf start;
BENCHMARK(&start, time, isal_deflate_hash(&stream, dict, dict_len)); BENCHMARK(&start, time, isal_deflate_hash(&stream, dict, dict_len));
printf("igzip_build_hash_table_perf: in_size=%u ", dict_len); printf("igzip_build_hash_table_perf: in_size=%u ", dict_len);
perf_print(start, (long long)dict_len); perf_print(start, (long long) dict_len);
return 0; return 0;
} }

8
igzip/igzip_checksums.h
View File

@ -4,9 +4,11 @@
#include <stdint.h> #include <stdint.h>
#define MAX_ADLER_BUF (1 << 28) #define MAX_ADLER_BUF (1 << 28)
#define ADLER_MOD 65521 #define ADLER_MOD 65521
uint32_t isal_adler32(uint32_t init_crc, const unsigned char *buf, uint64_t len); uint32_t
uint32_t isal_adler32_bam1(uint32_t init_crc, const unsigned char *buf, uint64_t len); isal_adler32(uint32_t init_crc, const unsigned char *buf, uint64_t len);
uint32_t
isal_adler32_bam1(uint32_t init_crc, const unsigned char *buf, uint64_t len);
#endif #endif

99
igzip/igzip_example.c
View File

@ -33,69 +33,70 @@
#define BUF_SIZE 8192 #define BUF_SIZE 8192
#ifndef LEVEL #ifndef LEVEL
# define LEVEL 0 #define LEVEL 0
#else #else
# define LEVEL 1 #define LEVEL 1
#endif #endif
struct isal_zstream stream; struct isal_zstream stream;
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
uint8_t inbuf[BUF_SIZE], outbuf[BUF_SIZE]; uint8_t inbuf[BUF_SIZE], outbuf[BUF_SIZE];
FILE *in, *out; FILE *in, *out;
if (argc != 3) { if (argc != 3) {
fprintf(stderr, "Usage: igzip_example infile outfile\n"); fprintf(stderr, "Usage: igzip_example infile outfile\n");
exit(0); exit(0);
} }
in = fopen(argv[1], "rb"); in = fopen(argv[1], "rb");
if (!in) { if (!in) {
fprintf(stderr, "Can't open %s for reading\n", argv[1]); fprintf(stderr, "Can't open %s for reading\n", argv[1]);
exit(0); exit(0);
} }
out = fopen(argv[2], "wb"); out = fopen(argv[2], "wb");
if (!out) { if (!out) {
fprintf(stderr, "Can't open %s for writing\n", argv[2]); fprintf(stderr, "Can't open %s for writing\n", argv[2]);
exit(0); exit(0);
} }
printf("igzip_example\nWindow Size: %d K\n", IGZIP_HIST_SIZE / 1024); printf("igzip_example\nWindow Size: %d K\n", IGZIP_HIST_SIZE / 1024);
fflush(0); fflush(0);
isal_deflate_init(&stream); isal_deflate_init(&stream);
stream.end_of_stream = 0; stream.end_of_stream = 0;
stream.flush = NO_FLUSH; stream.flush = NO_FLUSH;
if (LEVEL == 1) { if (LEVEL == 1) {
stream.level = 1; stream.level = 1;
stream.level_buf = malloc(ISAL_DEF_LVL1_DEFAULT); stream.level_buf = malloc(ISAL_DEF_LVL1_DEFAULT);
stream.level_buf_size = ISAL_DEF_LVL1_DEFAULT; stream.level_buf_size = ISAL_DEF_LVL1_DEFAULT;
if (stream.level_buf == 0) { if (stream.level_buf == 0) {
printf("Failed to allocate level compression buffer\n"); printf("Failed to allocate level compression buffer\n");
exit(0); exit(0);
} }
} }
do { do {
stream.avail_in = (uint32_t) fread(inbuf, 1, BUF_SIZE, in); stream.avail_in = (uint32_t) fread(inbuf, 1, BUF_SIZE, in);
stream.end_of_stream = feof(in) ? 1 : 0; stream.end_of_stream = feof(in) ? 1 : 0;
stream.next_in = inbuf; stream.next_in = inbuf;
do { do {
stream.avail_out = BUF_SIZE; stream.avail_out = BUF_SIZE;
stream.next_out = outbuf; stream.next_out = outbuf;
isal_deflate(&stream); isal_deflate(&stream);
fwrite(outbuf, 1, BUF_SIZE - stream.avail_out, out); fwrite(outbuf, 1, BUF_SIZE - stream.avail_out, out);
} while (stream.avail_out == 0); } while (stream.avail_out == 0);
assert(stream.avail_in == 0); assert(stream.avail_in == 0);
} while (stream.internal_state.state != ZSTATE_END); } while (stream.internal_state.state != ZSTATE_END);
fclose(out); fclose(out);
fclose(in); fclose(in);
printf("End of igzip_example\n\n"); printf("End of igzip_example\n\n");
return 0; return 0;
} }

462
igzip/igzip_file_perf.c
View File

@ -40,309 +40,309 @@
int level_size_buf[10] = { int level_size_buf[10] = {
#ifdef ISAL_DEF_LVL0_DEFAULT #ifdef ISAL_DEF_LVL0_DEFAULT
ISAL_DEF_LVL0_DEFAULT, ISAL_DEF_LVL0_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL1_DEFAULT #ifdef ISAL_DEF_LVL1_DEFAULT
ISAL_DEF_LVL1_DEFAULT, ISAL_DEF_LVL1_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL2_DEFAULT #ifdef ISAL_DEF_LVL2_DEFAULT
ISAL_DEF_LVL2_DEFAULT, ISAL_DEF_LVL2_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL3_DEFAULT #ifdef ISAL_DEF_LVL3_DEFAULT
ISAL_DEF_LVL3_DEFAULT, ISAL_DEF_LVL3_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL4_DEFAULT #ifdef ISAL_DEF_LVL4_DEFAULT
ISAL_DEF_LVL4_DEFAULT, ISAL_DEF_LVL4_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL5_DEFAULT #ifdef ISAL_DEF_LVL5_DEFAULT
ISAL_DEF_LVL5_DEFAULT, ISAL_DEF_LVL5_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL6_DEFAULT #ifdef ISAL_DEF_LVL6_DEFAULT
ISAL_DEF_LVL6_DEFAULT, ISAL_DEF_LVL6_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL7_DEFAULT #ifdef ISAL_DEF_LVL7_DEFAULT
ISAL_DEF_LVL7_DEFAULT, ISAL_DEF_LVL7_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL8_DEFAULT #ifdef ISAL_DEF_LVL8_DEFAULT
ISAL_DEF_LVL8_DEFAULT, ISAL_DEF_LVL8_DEFAULT,
#else #else
0, 0,
#endif #endif
#ifdef ISAL_DEF_LVL9_DEFAULT #ifdef ISAL_DEF_LVL9_DEFAULT
ISAL_DEF_LVL9_DEFAULT, ISAL_DEF_LVL9_DEFAULT,
#else #else
0, 0,
#endif #endif
}; };
int usage(void) int
usage(void)
{ {
fprintf(stderr, fprintf(stderr, "Usage: igzip_file_perf [options] <infile>\n"
"Usage: igzip_file_perf [options] <infile>\n" " -h help\n"
" -h help\n" " -X use compression level X with 0 <= X <= 1\n"
" -X use compression level X with 0 <= X <= 1\n" " -b <size> input buffer size, 0 buffers all the input\n"
" -b <size> input buffer size, 0 buffers all the input\n" " -i <time> time in seconds to benchmark (at least 0)\n"
" -i <time> time in seconds to benchmark (at least 0)\n" " -o <file> output file for compressed data\n"
" -o <file> output file for compressed data\n" " -d <file> dictionary file used by compression\n"
" -d <file> dictionary file used by compression\n" " -w <size> log base 2 size of history window, between 8 and 15\n");
" -w <size> log base 2 size of history window, between 8 and 15\n");
exit(0); exit(0);
} }
void deflate_perf(struct isal_zstream *stream, uint8_t * inbuf, size_t infile_size, void
size_t inbuf_size, uint8_t * outbuf, size_t outbuf_size, int level, deflate_perf(struct isal_zstream *stream, uint8_t *inbuf, size_t infile_size, size_t inbuf_size,
uint8_t * level_buf, int level_size, uint32_t hist_bits, uint8_t * dictbuf, uint8_t *outbuf, size_t outbuf_size, int level, uint8_t *level_buf, int level_size,
size_t dictfile_size, struct isal_dict *dict_str, uint32_t hist_bits, uint8_t *dictbuf, size_t dictfile_size, struct isal_dict *dict_str,
struct isal_hufftables *hufftables_custom) struct isal_hufftables *hufftables_custom)
{ {
int avail_in; int avail_in;
isal_deflate_init(stream); isal_deflate_init(stream);
stream->level = level; stream->level = level;
stream->level_buf = level_buf; stream->level_buf = level_buf;
stream->level_buf_size = level_size; stream->level_buf_size = level_size;
if (COMP_OK != isal_deflate_reset_dict(stream, dict_str)) if (COMP_OK != isal_deflate_reset_dict(stream, dict_str))
if (dictbuf != NULL) if (dictbuf != NULL)
isal_deflate_set_dict(stream, dictbuf, dictfile_size); isal_deflate_set_dict(stream, dictbuf, dictfile_size);
stream->end_of_stream = 0; stream->end_of_stream = 0;
stream->flush = NO_FLUSH; stream->flush = NO_FLUSH;
stream->next_out = outbuf; stream->next_out = outbuf;
stream->avail_out = outbuf_size; stream->avail_out = outbuf_size;
stream->next_in = inbuf; stream->next_in = inbuf;
if (hufftables_custom != NULL) if (hufftables_custom != NULL)
stream->hufftables = hufftables_custom; stream->hufftables = hufftables_custom;
stream->hist_bits = hist_bits; stream->hist_bits = hist_bits;
avail_in = infile_size; avail_in = infile_size;
while (avail_in > 0) { while (avail_in > 0) {
stream->avail_in = avail_in >= inbuf_size ? inbuf_size : avail_in; stream->avail_in = avail_in >= inbuf_size ? inbuf_size : avail_in;
avail_in -= inbuf_size; avail_in -= inbuf_size;
if (avail_in <= 0) if (avail_in <= 0)
stream->end_of_stream = 1; stream->end_of_stream = 1;
isal_deflate(stream); isal_deflate(stream);
if (stream->avail_in != 0) if (stream->avail_in != 0)
break; break;
} }
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
FILE *in = NULL, *out = NULL, *dict = NULL; FILE *in = NULL, *out = NULL, *dict = NULL;
unsigned char *inbuf, *outbuf, *level_buf = NULL, *dictbuf = NULL; unsigned char *inbuf, *outbuf, *level_buf = NULL, *dictbuf = NULL;
int c, time = BENCHMARK_TIME, inbuf_size = 0; int c, time = BENCHMARK_TIME, inbuf_size = 0;
size_t infile_size, outbuf_size, dictfile_size; size_t infile_size, outbuf_size, dictfile_size;
struct isal_huff_histogram histogram; struct isal_huff_histogram histogram;
struct isal_hufftables hufftables_custom; struct isal_hufftables hufftables_custom;
int level = 0, level_size = 0; int level = 0, level_size = 0;
char *in_file_name = NULL, *out_file_name = NULL, *dict_file_name = NULL; char *in_file_name = NULL, *out_file_name = NULL, *dict_file_name = NULL;
uint32_t hist_bits = 0; uint32_t hist_bits = 0;
struct isal_zstream stream; struct isal_zstream stream;
while ((c = getopt(argc, argv, "h0123456789i:b:o:d:w:")) != -1) { while ((c = getopt(argc, argv, "h0123456789i:b:o:d:w:")) != -1) {
if (c >= '0' && c <= '9') { if (c >= '0' && c <= '9') {
if (c > '0' + ISAL_DEF_MAX_LEVEL) if (c > '0' + ISAL_DEF_MAX_LEVEL)
usage(); usage();
else { else {
level = c - '0'; level = c - '0';
level_size = level_size_buf[level]; level_size = level_size_buf[level];
} }
continue; continue;
} }
switch (c) { switch (c) {
case 'o': case 'o':
out_file_name = optarg; out_file_name = optarg;
break; break;
case 'd': case 'd':
dict_file_name = optarg; dict_file_name = optarg;
break; break;
case 'i': case 'i':
time = atoi(optarg); time = atoi(optarg);
if (time < 0) if (time < 0)
usage(); usage();
break; break;
case 'b': case 'b':
inbuf_size = atoi(optarg); inbuf_size = atoi(optarg);
break; break;
case 'w': case 'w':
hist_bits = atoi(optarg); hist_bits = atoi(optarg);
if (hist_bits > 15 || hist_bits < 8) if (hist_bits > 15 || hist_bits < 8)
usage(); usage();
break; break;
case 'h': case 'h':
default: default:
usage(); usage();
break; break;
} }
} }
if (optind < argc) { if (optind < argc) {
in_file_name = argv[optind]; in_file_name = argv[optind];
in = fopen(in_file_name, "rb"); in = fopen(in_file_name, "rb");
} else } else
usage(); usage();
if (!in) { if (!in) {
fprintf(stderr, "Can't open %s for reading\n", in_file_name); fprintf(stderr, "Can't open %s for reading\n", in_file_name);
exit(0); exit(0);
} }
if (out_file_name != NULL) { if (out_file_name != NULL) {
out = fopen(out_file_name, "wb"); out = fopen(out_file_name, "wb");
if (!out) { if (!out) {
fprintf(stderr, "Can't open %s for writing\n", out_file_name); fprintf(stderr, "Can't open %s for writing\n", out_file_name);
exit(0); exit(0);
} }
printf("outfile=%s\n", out_file_name); printf("outfile=%s\n", out_file_name);
} }
if (dict_file_name != NULL) { if (dict_file_name != NULL) {
dict = fopen(dict_file_name, "rb"); dict = fopen(dict_file_name, "rb");
if (!dict) { if (!dict) {
fprintf(stderr, "Can't open %s for reading\n", dict_file_name); fprintf(stderr, "Can't open %s for reading\n", dict_file_name);
exit(0); exit(0);
} }
printf("outfile=%s\n", dict_file_name); printf("outfile=%s\n", dict_file_name);
} }
if (hist_bits == 0) if (hist_bits == 0)
printf("Window Size: %d K\n", IGZIP_HIST_SIZE / 1024); printf("Window Size: %d K\n", IGZIP_HIST_SIZE / 1024);
else if (hist_bits < 10) else if (hist_bits < 10)
printf("Window Size: %.2f K\n", 1.0 * (1 << hist_bits) / 1024); printf("Window Size: %.2f K\n", 1.0 * (1 << hist_bits) / 1024);
else else
printf("Window Size: %d K\n", (1 << hist_bits) / 1024); printf("Window Size: %d K\n", (1 << hist_bits) / 1024);
printf("igzip_file_perf: \n"); printf("igzip_file_perf: \n");
fflush(0); fflush(0);
/* Allocate space for entire input file and output /* Allocate space for entire input file and output
* (assuming some possible expansion on output size) * (assuming some possible expansion on output size)
*/ */
infile_size = get_filesize(in); infile_size = get_filesize(in);
outbuf_size = 2 * infile_size + BUF_SIZE; outbuf_size = 2 * infile_size + BUF_SIZE;
dictfile_size = (dict_file_name != NULL) ? get_filesize(dict) : 0; dictfile_size = (dict_file_name != NULL) ? get_filesize(dict) : 0;
inbuf = malloc(infile_size); inbuf = malloc(infile_size);
if (inbuf == NULL) { if (inbuf == NULL) {
fprintf(stderr, "Can't allocate input buffer memory\n"); fprintf(stderr, "Can't allocate input buffer memory\n");
exit(0); exit(0);
} }
outbuf = malloc(outbuf_size); outbuf = malloc(outbuf_size);
if (outbuf == NULL) { if (outbuf == NULL) {
fprintf(stderr, "Can't allocate output buffer memory\n"); fprintf(stderr, "Can't allocate output buffer memory\n");
exit(0); exit(0);
} }
if (dictfile_size != 0) { if (dictfile_size != 0) {
dictbuf = malloc(dictfile_size); dictbuf = malloc(dictfile_size);
if (dictbuf == NULL) { if (dictbuf == NULL) {
fprintf(stderr, "Can't allocate dictionary buffer memory\n"); fprintf(stderr, "Can't allocate dictionary buffer memory\n");
exit(0); exit(0);
} }
} }
if (level_size != 0) { if (level_size != 0) {
level_buf = malloc(level_size); level_buf = malloc(level_size);
if (level_buf == NULL) { if (level_buf == NULL) {
fprintf(stderr, "Can't allocate level buffer memory\n"); fprintf(stderr, "Can't allocate level buffer memory\n");
exit(0); exit(0);
} }
} }
inbuf_size = inbuf_size ? inbuf_size : infile_size; inbuf_size = inbuf_size ? inbuf_size : infile_size;
printf("igzip_file_perf: %s\n", in_file_name); printf("igzip_file_perf: %s\n", in_file_name);
/* Read complete input file into buffer */ /* Read complete input file into buffer */
stream.avail_in = (uint32_t) fread(inbuf, 1, infile_size, in); stream.avail_in = (uint32_t) fread(inbuf, 1, infile_size, in);
if (stream.avail_in != infile_size) { if (stream.avail_in != infile_size) {
fprintf(stderr, "Couldn't fit all of input file into buffer\n"); fprintf(stderr, "Couldn't fit all of input file into buffer\n");
exit(0); exit(0);
} }
/* Read complete dictionary into buffer */ /* Read complete dictionary into buffer */
if ((dictfile_size != 0) && (dictfile_size != fread(dictbuf, 1, dictfile_size, dict))) { if ((dictfile_size != 0) && (dictfile_size != fread(dictbuf, 1, dictfile_size, dict))) {
fprintf(stderr, "Couldn't fit all of dictionary file into buffer\n"); fprintf(stderr, "Couldn't fit all of dictionary file into buffer\n");
exit(0); exit(0);
} }
struct isal_dict dict_str; struct isal_dict dict_str;
stream.level = level; stream.level = level;
isal_deflate_process_dict(&stream, &dict_str, dictbuf, dictfile_size); isal_deflate_process_dict(&stream, &dict_str, dictbuf, dictfile_size);
struct perf start; struct perf start;
if (time > 0) { if (time > 0) {
BENCHMARK(&start, time, BENCHMARK(&start, time,
deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, outbuf_size,
outbuf_size, level, level_buf, level_size, hist_bits, level, level_buf, level_size, hist_bits, dictbuf,
dictbuf, dictfile_size, &dict_str, NULL)); dictfile_size, &dict_str, NULL));
} else { } else {
deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, outbuf_size, deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, outbuf_size, level,
level, level_buf, level_size, hist_bits, dictbuf, level_buf, level_size, hist_bits, dictbuf, dictfile_size, &dict_str,
dictfile_size, &dict_str, NULL); NULL);
} }
if (stream.avail_in != 0) { if (stream.avail_in != 0) {
fprintf(stderr, "Could not compress all of inbuf\n"); fprintf(stderr, "Could not compress all of inbuf\n");
exit(0); exit(0);
} }
printf(" file %s - in_size=%lu out_size=%d ratio=%3.1f%%", printf(" file %s - in_size=%lu out_size=%d ratio=%3.1f%%", in_file_name, infile_size,
in_file_name, infile_size, stream.total_out, stream.total_out, 100.0 * stream.total_out / infile_size);
100.0 * stream.total_out / infile_size);
if (level == 0) { if (level == 0) {
memset(&histogram, 0, sizeof(histogram)); memset(&histogram, 0, sizeof(histogram));
isal_update_histogram(inbuf, infile_size, &histogram); isal_update_histogram(inbuf, infile_size, &histogram);
isal_create_hufftables(&hufftables_custom, &histogram); isal_create_hufftables(&hufftables_custom, &histogram);
deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, outbuf_size, deflate_perf(&stream, inbuf, infile_size, inbuf_size, outbuf, outbuf_size, level,
level, level_buf, level_size, hist_bits, dictbuf, level_buf, level_size, hist_bits, dictbuf, dictfile_size, &dict_str,
dictfile_size, &dict_str, &hufftables_custom); &hufftables_custom);
printf(" ratio_custom=%3.1f%%", 100.0 * stream.total_out / infile_size); printf(" ratio_custom=%3.1f%%", 100.0 * stream.total_out / infile_size);
} }
printf("\n"); printf("\n");
if (stream.avail_in != 0) { if (stream.avail_in != 0) {
fprintf(stderr, "Could not compress all of inbuf\n"); fprintf(stderr, "Could not compress all of inbuf\n");
exit(0); exit(0);
} }
printf("igzip_file: "); printf("igzip_file: ");
perf_print(start, (long long)infile_size); perf_print(start, (long long) infile_size);
if (argc > 2 && out) { if (argc > 2 && out) {
printf("writing %s\n", out_file_name); printf("writing %s\n", out_file_name);
fwrite(outbuf, 1, stream.total_out, out); fwrite(outbuf, 1, stream.total_out, out);
fclose(out); fclose(out);
} }
fclose(in); fclose(in);
printf("End of igzip_file_perf\n\n"); printf("End of igzip_file_perf\n\n");
fflush(0); fflush(0);
return 0; return 0;
} }

147
igzip/igzip_hist_perf.c
View File

@ -35,95 +35,96 @@
#include "igzip_lib.h" #include "igzip_lib.h"
#include "test.h" #include "test.h"
#define BUF_SIZE 1024 #define BUF_SIZE 1024
#define MIN_TEST_LOOPS 8 #define MIN_TEST_LOOPS 8
#ifndef RUN_MEM_SIZE #ifndef RUN_MEM_SIZE
# define RUN_MEM_SIZE 2000000000 #define RUN_MEM_SIZE 2000000000
#endif #endif
void print_histogram(struct isal_huff_histogram *histogram) void
print_histogram(struct isal_huff_histogram *histogram)
{ {
int i; int i;
printf("Lit Len histogram"); printf("Lit Len histogram");
for (i = 0; i < ISAL_DEF_LIT_LEN_SYMBOLS; i++) { for (i = 0; i < ISAL_DEF_LIT_LEN_SYMBOLS; i++) {
if (i % 16 == 0) if (i % 16 == 0)
printf("\n"); printf("\n");
else else
printf(", "); printf(", ");
printf("%4lu", histogram->lit_len_histogram[i]); printf("%4lu", histogram->lit_len_histogram[i]);
} }
printf("\n"); printf("\n");
printf("Dist histogram"); printf("Dist histogram");
for (i = 0; i < ISAL_DEF_DIST_SYMBOLS; i++) { for (i = 0; i < ISAL_DEF_DIST_SYMBOLS; i++) {
if (i % 16 == 0) if (i % 16 == 0)
printf("\n"); printf("\n");
else else
printf(", "); printf(", ");
printf("%4lu", histogram->dist_histogram[i]); printf("%4lu", histogram->dist_histogram[i]);
} }
printf("\n"); printf("\n");
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
FILE *in; FILE *in;
unsigned char *inbuf; unsigned char *inbuf;
int iterations, avail_in; int iterations, avail_in;
uint64_t infile_size; uint64_t infile_size;
struct isal_huff_histogram histogram1, histogram2; struct isal_huff_histogram histogram1, histogram2;
memset(&histogram1, 0, sizeof(histogram1)); memset(&histogram1, 0, sizeof(histogram1));
memset(&histogram2, 0, sizeof(histogram2)); memset(&histogram2, 0, sizeof(histogram2));
if (argc > 3 || argc < 2) { if (argc > 3 || argc < 2) {
fprintf(stderr, "Usage: igzip_file_perf infile [outfile]\n" fprintf(stderr, "Usage: igzip_file_perf infile [outfile]\n"
"\t - Runs multiple iterations of igzip on a file to " "\t - Runs multiple iterations of igzip on a file to "
"get more accurate time results.\n"); "get more accurate time results.\n");
exit(0); exit(0);
} }
in = fopen(argv[1], "rb"); in = fopen(argv[1], "rb");
if (!in) { if (!in) {
fprintf(stderr, "Can't open %s for reading\n", argv[1]); fprintf(stderr, "Can't open %s for reading\n", argv[1]);
exit(0); exit(0);
} }
/* Allocate space for entire input file and output /* Allocate space for entire input file and output
* (assuming some possible expansion on output size) * (assuming some possible expansion on output size)
*/ */
infile_size = get_filesize(in); infile_size = get_filesize(in);
if (infile_size != 0) if (infile_size != 0)
iterations = RUN_MEM_SIZE / infile_size; iterations = RUN_MEM_SIZE / infile_size;
else else
iterations = MIN_TEST_LOOPS; iterations = MIN_TEST_LOOPS;
if (iterations < MIN_TEST_LOOPS) if (iterations < MIN_TEST_LOOPS)
iterations = MIN_TEST_LOOPS; iterations = MIN_TEST_LOOPS;
inbuf = malloc(infile_size); inbuf = malloc(infile_size);
if (inbuf == NULL) { if (inbuf == NULL) {
fprintf(stderr, "Can't allocate input buffer memory\n"); fprintf(stderr, "Can't allocate input buffer memory\n");
exit(0); exit(0);
} }
avail_in = fread(inbuf, 1, infile_size, in); avail_in = fread(inbuf, 1, infile_size, in);
if (avail_in != infile_size) { if (avail_in != infile_size) {
free(inbuf); free(inbuf);
fprintf(stderr, "Couldn't fit all of input file into buffer\n"); fprintf(stderr, "Couldn't fit all of input file into buffer\n");
exit(0); exit(0);
} }
struct perf start; struct perf start;
BENCHMARK(&start, BENCHMARK_TIME, BENCHMARK(&start, BENCHMARK_TIME, isal_update_histogram(inbuf, infile_size, &histogram1));
isal_update_histogram(inbuf, infile_size, &histogram1)); printf(" file %s - in_size=%lu\n", argv[1], infile_size);
printf(" file %s - in_size=%lu\n", argv[1], infile_size); printf("igzip_hist_file: ");
printf("igzip_hist_file: "); perf_print(start, (long long) infile_size);
perf_print(start, (long long)infile_size);
fclose(in); fclose(in);
fflush(0); fflush(0);
free(inbuf); free(inbuf);
return 0; return 0;
} }

550
igzip/igzip_icf_base.c
View File

@ -6,365 +6,363 @@
#include "igzip_level_buf_structs.h" #include "igzip_level_buf_structs.h"
#include "unaligned.h" #include "unaligned.h"
static inline void write_deflate_icf(struct deflate_icf *icf, uint32_t lit_len, static inline void
uint32_t lit_dist, uint32_t extra_bits) write_deflate_icf(struct deflate_icf *icf, uint32_t lit_len, uint32_t lit_dist, uint32_t extra_bits)
{ {
icf->lit_len = lit_len; icf->lit_len = lit_len;
icf->lit_dist = lit_dist; icf->lit_dist = lit_dist;
icf->dist_extra = extra_bits; icf->dist_extra = extra_bits;
} }
static inline void update_state(struct isal_zstream *stream, uint8_t * start_in, static inline void
uint8_t * next_in, uint8_t * end_in, update_state(struct isal_zstream *stream, uint8_t *start_in, uint8_t *next_in, uint8_t *end_in,
struct deflate_icf *start_out, struct deflate_icf *next_out, struct deflate_icf *start_out, struct deflate_icf *next_out,
struct deflate_icf *end_out) struct deflate_icf *end_out)
{ {
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
if (next_in - start_in > 0) if (next_in - start_in > 0)
stream->internal_state.has_hist = IGZIP_HIST; stream->internal_state.has_hist = IGZIP_HIST;
stream->next_in = next_in; stream->next_in = next_in;
stream->total_in += next_in - start_in; stream->total_in += next_in - start_in;
stream->internal_state.block_end = stream->total_in; stream->internal_state.block_end = stream->total_in;
stream->avail_in = end_in - next_in; stream->avail_in = end_in - next_in;
level_buf->icf_buf_next = next_out; level_buf->icf_buf_next = next_out;
level_buf->icf_buf_avail_out = end_out - next_out; level_buf->icf_buf_avail_out = end_out - next_out;
} }
void isal_deflate_icf_body_hash_hist_base(struct isal_zstream *stream) void
isal_deflate_icf_body_hash_hist_base(struct isal_zstream *stream)
{ {
uint32_t literal, hash; uint32_t literal, hash;
uint8_t *start_in, *next_in, *end_in, *end, *next_hash; uint8_t *start_in, *next_in, *end_in, *end, *next_hash;
struct deflate_icf *start_out, *next_out, *end_out; struct deflate_icf *start_out, *next_out, *end_out;
uint16_t match_length; uint16_t match_length;
uint32_t dist; uint32_t dist;
uint32_t code, code2, extra_bits; uint32_t code, code2, extra_bits;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint16_t *last_seen = level_buf->hash_hist.hash_table; uint16_t *last_seen = level_buf->hash_hist.hash_table;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hist_size = state->dist_mask; uint32_t hist_size = state->dist_mask;
uint32_t hash_mask = state->hash_mask; uint32_t hash_mask = state->hash_mask;
if (stream->avail_in == 0) { if (stream->avail_in == 0) {
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_FLUSH_READ_BUFFER; state->state = ZSTATE_FLUSH_READ_BUFFER;
return; return;
} }
start_in = stream->next_in; start_in = stream->next_in;
end_in = start_in + stream->avail_in; end_in = start_in + stream->avail_in;
next_in = start_in; next_in = start_in;
start_out = ((struct level_buf *)stream->level_buf)->icf_buf_next; start_out = ((struct level_buf *) stream->level_buf)->icf_buf_next;
end_out = end_out = start_out + ((struct level_buf *) stream->level_buf)->icf_buf_avail_out /
start_out + ((struct level_buf *)stream->level_buf)->icf_buf_avail_out / sizeof(struct deflate_icf);
sizeof(struct deflate_icf); next_out = start_out;
next_out = start_out;
while (next_in + ISAL_LOOK_AHEAD < end_in) { while (next_in + ISAL_LOOK_AHEAD < end_in) {
if (next_out >= end_out) { if (next_out >= end_out) {
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
update_state(stream, start_in, next_in, end_in, start_out, next_out, update_state(stream, start_in, next_in, end_in, start_out, next_out,
end_out); end_out);
return; return;
} }
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
dist = (next_in - file_start - last_seen[hash]) & 0xFFFF; dist = (next_in - file_start - last_seen[hash]) & 0xFFFF;
last_seen[hash] = (uint64_t) (next_in - file_start); last_seen[hash] = (uint64_t) (next_in - file_start);
/* The -1 are to handle the case when dist = 0 */ /* The -1 are to handle the case when dist = 0 */
if (dist - 1 < hist_size) { if (dist - 1 < hist_size) {
assert(dist != 0); assert(dist != 0);
match_length = compare258(next_in - dist, next_in, 258); match_length = compare258(next_in - dist, next_in, 258);
if (match_length >= SHORTEST_MATCH) { if (match_length >= SHORTEST_MATCH) {
next_hash = next_in; next_hash = next_in;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
next_hash++; next_hash++;
for (; next_hash < end; next_hash++) { for (; next_hash < end; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
last_seen[hash] = (uint64_t) (next_hash - file_start); last_seen[hash] = (uint64_t) (next_hash - file_start);
} }
get_len_icf_code(match_length, &code); get_len_icf_code(match_length, &code);
get_dist_icf_code(dist, &code2, &extra_bits); get_dist_icf_code(dist, &code2, &extra_bits);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
level_buf->hist.d_hist[code2]++; level_buf->hist.d_hist[code2]++;
write_deflate_icf(next_out, code, code2, extra_bits); write_deflate_icf(next_out, code, code2, extra_bits);
next_out++; next_out++;
next_in += match_length; next_in += match_length;
continue; continue;
} }
} }
get_lit_icf_code(literal & 0xFF, &code); get_lit_icf_code(literal & 0xFF, &code);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
write_deflate_icf(next_out, code, NULL_DIST_SYM, 0); write_deflate_icf(next_out, code, NULL_DIST_SYM, 0);
next_out++; next_out++;
next_in++; next_in++;
} }
update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out); update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out);
assert(stream->avail_in <= ISAL_LOOK_AHEAD); assert(stream->avail_in <= ISAL_LOOK_AHEAD);
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_FLUSH_READ_BUFFER; state->state = ZSTATE_FLUSH_READ_BUFFER;
return;
return;
} }
void isal_deflate_icf_finish_hash_hist_base(struct isal_zstream *stream) void
isal_deflate_icf_finish_hash_hist_base(struct isal_zstream *stream)
{ {
uint32_t literal = 0, hash; uint32_t literal = 0, hash;
uint8_t *start_in, *next_in, *end_in, *end, *next_hash; uint8_t *start_in, *next_in, *end_in, *end, *next_hash;
struct deflate_icf *start_out, *next_out, *end_out; struct deflate_icf *start_out, *next_out, *end_out;
uint16_t match_length; uint16_t match_length;
uint32_t dist; uint32_t dist;
uint32_t code, code2, extra_bits; uint32_t code, code2, extra_bits;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint16_t *last_seen = level_buf->hash_hist.hash_table; uint16_t *last_seen = level_buf->hash_hist.hash_table;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hist_size = state->dist_mask; uint32_t hist_size = state->dist_mask;
uint32_t hash_mask = state->hash_mask; uint32_t hash_mask = state->hash_mask;
start_in = stream->next_in; start_in = stream->next_in;
end_in = start_in + stream->avail_in; end_in = start_in + stream->avail_in;
next_in = start_in; next_in = start_in;
start_out = ((struct level_buf *)stream->level_buf)->icf_buf_next; start_out = ((struct level_buf *) stream->level_buf)->icf_buf_next;
end_out = start_out + ((struct level_buf *)stream->level_buf)->icf_buf_avail_out / end_out = start_out + ((struct level_buf *) stream->level_buf)->icf_buf_avail_out /
sizeof(struct deflate_icf); sizeof(struct deflate_icf);
next_out = start_out; next_out = start_out;
if (stream->avail_in == 0) { if (stream->avail_in == 0) {
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
return; return;
} }
while (next_in + 3 < end_in) { while (next_in + 3 < end_in) {
if (next_out >= end_out) { if (next_out >= end_out) {
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
update_state(stream, start_in, next_in, end_in, start_out, next_out, update_state(stream, start_in, next_in, end_in, start_out, next_out,
end_out); end_out);
return; return;
} }
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
dist = (next_in - file_start - last_seen[hash]) & 0xFFFF; dist = (next_in - file_start - last_seen[hash]) & 0xFFFF;
last_seen[hash] = (uint64_t) (next_in - file_start); last_seen[hash] = (uint64_t) (next_in - file_start);
if (dist - 1 < hist_size) { /* The -1 are to handle the case when dist = 0 */ if (dist - 1 < hist_size) { /* The -1 are to handle the case when dist = 0 */
match_length = compare258(next_in - dist, next_in, end_in - next_in); match_length = compare258(next_in - dist, next_in, end_in - next_in);
if (match_length >= SHORTEST_MATCH) { if (match_length >= SHORTEST_MATCH) {
next_hash = next_in; next_hash = next_in;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
next_hash++; next_hash++;
for (; next_hash < end - 3; next_hash++) { for (; next_hash < end - 3; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash(literal) & hash_mask; hash = compute_hash(literal) & hash_mask;
last_seen[hash] = (uint64_t) (next_hash - file_start); last_seen[hash] = (uint64_t) (next_hash - file_start);
} }
get_len_icf_code(match_length, &code); get_len_icf_code(match_length, &code);
get_dist_icf_code(dist, &code2, &extra_bits); get_dist_icf_code(dist, &code2, &extra_bits);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
level_buf->hist.d_hist[code2]++; level_buf->hist.d_hist[code2]++;
write_deflate_icf(next_out, code, code2, extra_bits); write_deflate_icf(next_out, code, code2, extra_bits);
next_out++; next_out++;
next_in += match_length; next_in += match_length;
continue; continue;
} }
} }
get_lit_icf_code(literal & 0xFF, &code); get_lit_icf_code(literal & 0xFF, &code);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
write_deflate_icf(next_out, code, NULL_DIST_SYM, 0); write_deflate_icf(next_out, code, NULL_DIST_SYM, 0);
next_out++; next_out++;
next_in++; next_in++;
}
} while (next_in < end_in) {
if (next_out >= end_out) {
state->state = ZSTATE_CREATE_HDR;
update_state(stream, start_in, next_in, end_in, start_out, next_out,
end_out);
return;
}
while (next_in < end_in) { literal = *next_in;
if (next_out >= end_out) { get_lit_icf_code(literal & 0xFF, &code);
state->state = ZSTATE_CREATE_HDR; level_buf->hist.ll_hist[code]++;
update_state(stream, start_in, next_in, end_in, start_out, next_out, write_deflate_icf(next_out, code, NULL_DIST_SYM, 0);
end_out); next_out++;
return; next_in++;
} }
literal = *next_in; if (next_in == end_in) {
get_lit_icf_code(literal & 0xFF, &code); if (stream->end_of_stream || stream->flush != NO_FLUSH)
level_buf->hist.ll_hist[code]++; state->state = ZSTATE_CREATE_HDR;
write_deflate_icf(next_out, code, NULL_DIST_SYM, 0); }
next_out++;
next_in++;
} update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out);
if (next_in == end_in) { return;
if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_CREATE_HDR;
}
update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out);
return;
} }
void isal_deflate_icf_finish_hash_map_base(struct isal_zstream *stream) void
isal_deflate_icf_finish_hash_map_base(struct isal_zstream *stream)
{ {
uint32_t literal = 0, hash; uint32_t literal = 0, hash;
uint8_t *start_in, *next_in, *end_in, *end, *next_hash; uint8_t *start_in, *next_in, *end_in, *end, *next_hash;
struct deflate_icf *start_out, *next_out, *end_out; struct deflate_icf *start_out, *next_out, *end_out;
uint16_t match_length; uint16_t match_length;
uint32_t dist; uint32_t dist;
uint32_t code, code2, extra_bits; uint32_t code, code2, extra_bits;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint16_t *last_seen = level_buf->hash_map.hash_table; uint16_t *last_seen = level_buf->hash_map.hash_table;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hist_size = state->dist_mask; uint32_t hist_size = state->dist_mask;
uint32_t hash_mask = state->hash_mask; uint32_t hash_mask = state->hash_mask;
start_in = stream->next_in; start_in = stream->next_in;
end_in = start_in + stream->avail_in; end_in = start_in + stream->avail_in;
next_in = start_in; next_in = start_in;
start_out = level_buf->icf_buf_next; start_out = level_buf->icf_buf_next;
end_out = start_out + level_buf->icf_buf_avail_out / sizeof(struct deflate_icf); end_out = start_out + level_buf->icf_buf_avail_out / sizeof(struct deflate_icf);
next_out = start_out; next_out = start_out;
if (stream->avail_in == 0) { if (stream->avail_in == 0) {
if (stream->end_of_stream || stream->flush != NO_FLUSH) if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
return; return;
} }
while (next_in + 3 < end_in) { while (next_in + 3 < end_in) {
if (next_out >= end_out) { if (next_out >= end_out) {
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
update_state(stream, start_in, next_in, end_in, start_out, next_out, update_state(stream, start_in, next_in, end_in, start_out, next_out,
end_out); end_out);
return; return;
} }
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash_mad(literal) & hash_mask; hash = compute_hash_mad(literal) & hash_mask;
dist = (next_in - file_start - last_seen[hash]) & 0xFFFF; dist = (next_in - file_start - last_seen[hash]) & 0xFFFF;
last_seen[hash] = (uint64_t) (next_in - file_start); last_seen[hash] = (uint64_t) (next_in - file_start);
if (dist - 1 < hist_size) { /* The -1 are to handle the case when dist = 0 */ if (dist - 1 < hist_size) { /* The -1 are to handle the case when dist = 0 */
match_length = compare258(next_in - dist, next_in, end_in - next_in); match_length = compare258(next_in - dist, next_in, end_in - next_in);
if (match_length >= SHORTEST_MATCH) { if (match_length >= SHORTEST_MATCH) {
next_hash = next_in; next_hash = next_in;
#ifdef ISAL_LIMIT_HASH_UPDATE #ifdef ISAL_LIMIT_HASH_UPDATE
end = next_hash + 3; end = next_hash + 3;
#else #else
end = next_hash + match_length; end = next_hash + match_length;
#endif #endif
next_hash++; next_hash++;
for (; next_hash < end - 3; next_hash++) { for (; next_hash < end - 3; next_hash++) {
literal = load_le_u32(next_hash); literal = load_le_u32(next_hash);
hash = compute_hash_mad(literal) & hash_mask; hash = compute_hash_mad(literal) & hash_mask;
last_seen[hash] = (uint64_t) (next_hash - file_start); last_seen[hash] = (uint64_t) (next_hash - file_start);
} }
get_len_icf_code(match_length, &code); get_len_icf_code(match_length, &code);
get_dist_icf_code(dist, &code2, &extra_bits); get_dist_icf_code(dist, &code2, &extra_bits);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
level_buf->hist.d_hist[code2]++; level_buf->hist.d_hist[code2]++;
write_deflate_icf(next_out, code, code2, extra_bits); write_deflate_icf(next_out, code, code2, extra_bits);
next_out++; next_out++;
next_in += match_length; next_in += match_length;
continue; continue;
} }
} }
get_lit_icf_code(literal & 0xFF, &code); get_lit_icf_code(literal & 0xFF, &code);
level_buf->hist.ll_hist[code]++; level_buf->hist.ll_hist[code]++;
write_deflate_icf(next_out, code, NULL_DIST_SYM, 0); write_deflate_icf(next_out, code, NULL_DIST_SYM, 0);
next_out++; next_out++;
next_in++; next_in++;
}
} while (next_in < end_in) {
if (next_out >= end_out) {
state->state = ZSTATE_CREATE_HDR;
update_state(stream, start_in, next_in, end_in, start_out, next_out,
end_out);
return;
}
while (next_in < end_in) { literal = *next_in;
if (next_out >= end_out) { get_lit_icf_code(literal & 0xFF, &code);
state->state = ZSTATE_CREATE_HDR; level_buf->hist.ll_hist[code]++;
update_state(stream, start_in, next_in, end_in, start_out, next_out, write_deflate_icf(next_out, code, NULL_DIST_SYM, 0);
end_out); next_out++;
return; next_in++;
} }
literal = *next_in; if (next_in == end_in) {
get_lit_icf_code(literal & 0xFF, &code); if (stream->end_of_stream || stream->flush != NO_FLUSH)
level_buf->hist.ll_hist[code]++; state->state = ZSTATE_CREATE_HDR;
write_deflate_icf(next_out, code, NULL_DIST_SYM, 0); }
next_out++;
next_in++;
} update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out);
if (next_in == end_in) { return;
if (stream->end_of_stream || stream->flush != NO_FLUSH)
state->state = ZSTATE_CREATE_HDR;
}
update_state(stream, start_in, next_in, end_in, start_out, next_out, end_out);
return;
} }
void isal_deflate_hash_mad_base(uint16_t * hash_table, uint32_t hash_mask, void
uint32_t current_index, uint8_t * dict, uint32_t dict_len) isal_deflate_hash_mad_base(uint16_t *hash_table, uint32_t hash_mask, uint32_t current_index,
uint8_t *dict, uint32_t dict_len)
{ {
uint8_t *next_in = dict; uint8_t *next_in = dict;
uint8_t *end_in = dict + dict_len - SHORTEST_MATCH; uint8_t *end_in = dict + dict_len - SHORTEST_MATCH;
uint32_t literal; uint32_t literal;
uint32_t hash; uint32_t hash;
uint16_t index = current_index - dict_len; uint16_t index = current_index - dict_len;
while (next_in <= end_in) { while (next_in <= end_in) {
literal = load_le_u32(next_in); literal = load_le_u32(next_in);
hash = compute_hash_mad(literal) & hash_mask; hash = compute_hash_mad(literal) & hash_mask;
hash_table[hash] = index; hash_table[hash] = index;
index++; index++;
next_in++; next_in++;
} }
} }

489
igzip/igzip_icf_body.c
View File

@ -3,335 +3,344 @@
#include "encode_df.h" #include "encode_df.h"
#include "igzip_level_buf_structs.h" #include "igzip_level_buf_structs.h"
extern uint64_t gen_icf_map_lh1(struct isal_zstream *, struct deflate_icf *, uint32_t); extern uint64_t
extern void set_long_icf_fg(uint8_t *, uint64_t, uint64_t, struct deflate_icf *); gen_icf_map_lh1(struct isal_zstream *, struct deflate_icf *, uint32_t);
extern void isal_deflate_icf_body_lvl1(struct isal_zstream *); extern void
extern void isal_deflate_icf_body_lvl2(struct isal_zstream *); set_long_icf_fg(uint8_t *, uint64_t, uint64_t, struct deflate_icf *);
extern void isal_deflate_icf_body_lvl3(struct isal_zstream *); extern void
isal_deflate_icf_body_lvl1(struct isal_zstream *);
extern void
isal_deflate_icf_body_lvl2(struct isal_zstream *);
extern void
isal_deflate_icf_body_lvl3(struct isal_zstream *);
/* /*
************************************************************* *************************************************************
* Helper functions * Helper functions
************************************************************ ************************************************************
*/ */
static inline void write_deflate_icf(struct deflate_icf *icf, uint32_t lit_len, static inline void
uint32_t lit_dist, uint32_t extra_bits) write_deflate_icf(struct deflate_icf *icf, uint32_t lit_len, uint32_t lit_dist, uint32_t extra_bits)
{ {
/* icf->lit_len = lit_len; */ /* icf->lit_len = lit_len; */
/* icf->lit_dist = lit_dist; */ /* icf->lit_dist = lit_dist; */
/* icf->dist_extra = extra_bits; */ /* icf->dist_extra = extra_bits; */
store_native_u32((uint8_t *) icf, lit_len | (lit_dist << LIT_LEN_BIT_COUNT) store_native_u32((uint8_t *) icf,
| (extra_bits << (LIT_LEN_BIT_COUNT + DIST_LIT_BIT_COUNT))); lit_len | (lit_dist << LIT_LEN_BIT_COUNT) |
(extra_bits << (LIT_LEN_BIT_COUNT + DIST_LIT_BIT_COUNT)));
} }
void set_long_icf_fg_base(uint8_t * next_in, uint64_t processed, uint64_t input_size, void
struct deflate_icf *match_lookup) set_long_icf_fg_base(uint8_t *next_in, uint64_t processed, uint64_t input_size,
struct deflate_icf *match_lookup)
{ {
uint8_t *end_processed = next_in + processed; uint8_t *end_processed = next_in + processed;
uint8_t *end_in = next_in + input_size; uint8_t *end_in = next_in + input_size;
uint32_t dist_code, dist_extra, dist, len; uint32_t dist_code, dist_extra, dist, len;
uint32_t match_len; uint32_t match_len;
uint32_t dist_start[] = { uint32_t dist_start[] = { 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d,
0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1,
0x0011, 0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01,
0x0101, 0x0181, 0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001, 0x0000, 0x0000 };
0x1001, 0x1801, 0x2001, 0x3001, 0x4001, 0x6001, 0x0000, 0x0000
};
if (end_in > end_processed + ISAL_LOOK_AHEAD) if (end_in > end_processed + ISAL_LOOK_AHEAD)
end_in = end_processed + ISAL_LOOK_AHEAD; end_in = end_processed + ISAL_LOOK_AHEAD;
while (next_in < end_processed) { while (next_in < end_processed) {
dist_code = match_lookup->lit_dist; dist_code = match_lookup->lit_dist;
dist_extra = match_lookup->dist_extra; dist_extra = match_lookup->dist_extra;
dist = dist_start[dist_code] + dist_extra; dist = dist_start[dist_code] + dist_extra;
len = match_lookup->lit_len; len = match_lookup->lit_len;
if (len >= 8 + LEN_OFFSET) { if (len >= 8 + LEN_OFFSET) {
match_len = compare((next_in + 8) - dist, next_in + 8, match_len =
end_in - (next_in + 8)) + LEN_OFFSET + 8; compare((next_in + 8) - dist, next_in + 8, end_in - (next_in + 8)) +
LEN_OFFSET + 8;
while (match_len > match_lookup->lit_len while (match_len > match_lookup->lit_len &&
&& match_len >= LEN_OFFSET + SHORTEST_MATCH) { match_len >= LEN_OFFSET + SHORTEST_MATCH) {
write_deflate_icf(match_lookup, write_deflate_icf(match_lookup,
match_len > LEN_MAX ? LEN_MAX : match_len, match_len > LEN_MAX ? LEN_MAX : match_len,
dist_code, dist_extra); dist_code, dist_extra);
match_lookup++; match_lookup++;
next_in++; next_in++;
match_len--; match_len--;
} }
} }
match_lookup++; match_lookup++;
next_in++; next_in++;
} }
} }
/* /*
************************************************************* *************************************************************
* Methods for generating one pass match lookup table * Methods for generating one pass match lookup table
************************************************************ ************************************************************
*/ */
uint64_t gen_icf_map_h1_base(struct isal_zstream *stream, uint64_t
struct deflate_icf *matches_icf_lookup, uint64_t input_size) gen_icf_map_h1_base(struct isal_zstream *stream, struct deflate_icf *matches_icf_lookup,
uint64_t input_size)
{ {
uint32_t dist, len, extra_bits; uint32_t dist, len, extra_bits;
uint8_t *next_in = stream->next_in, *end_in = stream->next_in + input_size; uint8_t *next_in = stream->next_in, *end_in = stream->next_in + input_size;
uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in); uint8_t *file_start = (uint8_t *) ((uintptr_t) stream->next_in - stream->total_in);
uint32_t hash; uint32_t hash;
uint64_t next_bytes, match_bytes; uint64_t next_bytes, match_bytes;
uint64_t match; uint64_t match;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint16_t *hash_table = level_buf->hash_map.hash_table; uint16_t *hash_table = level_buf->hash_map.hash_table;
uint32_t hist_size = stream->internal_state.dist_mask; uint32_t hist_size = stream->internal_state.dist_mask;
uint32_t hash_mask = stream->internal_state.hash_mask; uint32_t hash_mask = stream->internal_state.hash_mask;
if (input_size < ISAL_LOOK_AHEAD) if (input_size < ISAL_LOOK_AHEAD)
return 0; return 0;
if (stream->internal_state.has_hist == IGZIP_NO_HIST) { if (stream->internal_state.has_hist == IGZIP_NO_HIST) {
matches_icf_lookup->lit_len = *next_in; matches_icf_lookup->lit_len = *next_in;
matches_icf_lookup->lit_dist = 0x1e; matches_icf_lookup->lit_dist = 0x1e;
matches_icf_lookup->dist_extra = 0; matches_icf_lookup->dist_extra = 0;
hash = compute_hash(load_le_u32(next_in)) & hash_mask; hash = compute_hash(load_le_u32(next_in)) & hash_mask;
hash_table[hash] = (uint64_t) (next_in - file_start); hash_table[hash] = (uint64_t) (next_in - file_start);
next_in++; next_in++;
matches_icf_lookup++; matches_icf_lookup++;
stream->internal_state.has_hist = IGZIP_HIST; stream->internal_state.has_hist = IGZIP_HIST;
} }
while (next_in < end_in - ISAL_LOOK_AHEAD) { while (next_in < end_in - ISAL_LOOK_AHEAD) {
hash = compute_hash(load_le_u32(next_in)) & hash_mask; hash = compute_hash(load_le_u32(next_in)) & hash_mask;
dist = (next_in - file_start - hash_table[hash]); dist = (next_in - file_start - hash_table[hash]);
dist = ((dist - 1) & hist_size) + 1; dist = ((dist - 1) & hist_size) + 1;
hash_table[hash] = (uint64_t) (next_in - file_start); hash_table[hash] = (uint64_t) (next_in - file_start);
match_bytes = load_le_u64(next_in - dist); match_bytes = load_le_u64(next_in - dist);
next_bytes = load_le_u64(next_in); next_bytes = load_le_u64(next_in);
match = next_bytes ^ match_bytes; match = next_bytes ^ match_bytes;
len = tzbytecnt(match); len = tzbytecnt(match);
if (len >= SHORTEST_MATCH) { if (len >= SHORTEST_MATCH) {
len += LEN_OFFSET; len += LEN_OFFSET;
get_dist_icf_code(dist, &dist, &extra_bits); get_dist_icf_code(dist, &dist, &extra_bits);
write_deflate_icf(matches_icf_lookup, len, dist, extra_bits); write_deflate_icf(matches_icf_lookup, len, dist, extra_bits);
} else { } else {
write_deflate_icf(matches_icf_lookup, *next_in, 0x1e, 0); write_deflate_icf(matches_icf_lookup, *next_in, 0x1e, 0);
} }
next_in++; next_in++;
matches_icf_lookup++; matches_icf_lookup++;
} }
return next_in - stream->next_in; return next_in - stream->next_in;
} }
/* /*
************************************************************* *************************************************************
* One pass methods for parsing provided match lookup table * One pass methods for parsing provided match lookup table
************************************************************ ************************************************************
*/ */
static struct deflate_icf *compress_icf_map_g(struct isal_zstream *stream, static struct deflate_icf *
struct deflate_icf *matches_next, compress_icf_map_g(struct isal_zstream *stream, struct deflate_icf *matches_next,
struct deflate_icf *matches_end) struct deflate_icf *matches_end)
{ {
uint32_t lit_len, lit_len2, dist; uint32_t lit_len, lit_len2, dist;
uint64_t code; uint64_t code;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
struct deflate_icf *matches_start = matches_next; struct deflate_icf *matches_start = matches_next;
struct deflate_icf *icf_buf_end = struct deflate_icf *icf_buf_end =
level_buf->icf_buf_next + level_buf->icf_buf_next + level_buf->icf_buf_avail_out / sizeof(struct deflate_icf);
level_buf->icf_buf_avail_out / sizeof(struct deflate_icf);
while (matches_next + 1 < matches_end && level_buf->icf_buf_next + 1 < icf_buf_end) { while (matches_next + 1 < matches_end && level_buf->icf_buf_next + 1 < icf_buf_end) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
code = load_native_u64((uint8_t *) matches_next); code = load_native_u64((uint8_t *) matches_next);
#else #else
code = load_native_u32((uint8_t *) matches_next) | code = load_native_u32((uint8_t *) matches_next) |
((uint64_t) load_native_u32((uint8_t *) (matches_next + 1)) << 32); ((uint64_t) load_native_u32((uint8_t *) (matches_next + 1)) << 32);
#endif #endif
lit_len = code & LIT_LEN_MASK; lit_len = code & LIT_LEN_MASK;
lit_len2 = (code >> ICF_CODE_LEN) & LIT_LEN_MASK; lit_len2 = (code >> ICF_CODE_LEN) & LIT_LEN_MASK;
level_buf->hist.ll_hist[lit_len]++; level_buf->hist.ll_hist[lit_len]++;
if (lit_len >= LEN_START) { if (lit_len >= LEN_START) {
store_native_u32((uint8_t *) level_buf->icf_buf_next, code); store_native_u32((uint8_t *) level_buf->icf_buf_next, code);
level_buf->icf_buf_next++; level_buf->icf_buf_next++;
dist = (code >> ICF_DIST_OFFSET) & DIST_LIT_MASK; dist = (code >> ICF_DIST_OFFSET) & DIST_LIT_MASK;
level_buf->hist.d_hist[dist]++; level_buf->hist.d_hist[dist]++;
lit_len -= LEN_OFFSET; lit_len -= LEN_OFFSET;
matches_next += lit_len; matches_next += lit_len;
} else if (lit_len2 >= LEN_START) { } else if (lit_len2 >= LEN_START) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
store_native_u64((uint8_t *) level_buf->icf_buf_next, code); store_native_u64((uint8_t *) level_buf->icf_buf_next, code);
#else #else
store_native_u32((uint8_t *) level_buf->icf_buf_next, (uint32_t) code); store_native_u32((uint8_t *) level_buf->icf_buf_next, (uint32_t) code);
store_native_u32((uint8_t *) (level_buf->icf_buf_next + 1), store_native_u32((uint8_t *) (level_buf->icf_buf_next + 1),
(uint32_t) (code >> 32)); (uint32_t) (code >> 32));
#endif #endif
level_buf->icf_buf_next += 2; level_buf->icf_buf_next += 2;
level_buf->hist.ll_hist[lit_len2]++; level_buf->hist.ll_hist[lit_len2]++;
dist = (code >> (ICF_CODE_LEN + ICF_DIST_OFFSET)) & DIST_LIT_MASK; dist = (code >> (ICF_CODE_LEN + ICF_DIST_OFFSET)) & DIST_LIT_MASK;
level_buf->hist.d_hist[dist]++; level_buf->hist.d_hist[dist]++;
lit_len2 -= LEN_OFFSET - 1; lit_len2 -= LEN_OFFSET - 1;
matches_next += lit_len2; matches_next += lit_len2;
} else { } else {
code = ((lit_len2 + LIT_START) << ICF_DIST_OFFSET) | lit_len; code = ((lit_len2 + LIT_START) << ICF_DIST_OFFSET) | lit_len;
store_native_u32((uint8_t *) level_buf->icf_buf_next, code); store_native_u32((uint8_t *) level_buf->icf_buf_next, code);
level_buf->icf_buf_next++; level_buf->icf_buf_next++;
level_buf->hist.ll_hist[lit_len2]++; level_buf->hist.ll_hist[lit_len2]++;
matches_next += 2; matches_next += 2;
} }
} }
while (matches_next < matches_end && level_buf->icf_buf_next < icf_buf_end) { while (matches_next < matches_end && level_buf->icf_buf_next < icf_buf_end) {
code = load_native_u32((uint8_t *) matches_next); code = load_native_u32((uint8_t *) matches_next);
lit_len = code & LIT_LEN_MASK; lit_len = code & LIT_LEN_MASK;
store_native_u32((uint8_t *) level_buf->icf_buf_next, code); store_native_u32((uint8_t *) level_buf->icf_buf_next, code);
level_buf->icf_buf_next++; level_buf->icf_buf_next++;
level_buf->hist.ll_hist[lit_len]++; level_buf->hist.ll_hist[lit_len]++;
if (lit_len >= LEN_START) { if (lit_len >= LEN_START) {
dist = (code >> 10) & 0x1ff; dist = (code >> 10) & 0x1ff;
level_buf->hist.d_hist[dist]++; level_buf->hist.d_hist[dist]++;
lit_len -= LEN_OFFSET; lit_len -= LEN_OFFSET;
matches_next += lit_len; matches_next += lit_len;
} else { } else {
matches_next++; matches_next++;
} }
} }
level_buf->icf_buf_avail_out = level_buf->icf_buf_avail_out =
(icf_buf_end - level_buf->icf_buf_next) * sizeof(struct deflate_icf); (icf_buf_end - level_buf->icf_buf_next) * sizeof(struct deflate_icf);
state->block_end += matches_next - matches_start; state->block_end += matches_next - matches_start;
if (matches_next > matches_end && matches_start < matches_end) { if (matches_next > matches_end && matches_start < matches_end) {
stream->next_in += matches_next - matches_end; stream->next_in += matches_next - matches_end;
stream->avail_in -= matches_next - matches_end; stream->avail_in -= matches_next - matches_end;
stream->total_in += matches_next - matches_end; stream->total_in += matches_next - matches_end;
} }
return matches_next;
return matches_next;
} }
/* /*
************************************************************* *************************************************************
* Compression functions combining different methods * Compression functions combining different methods
************************************************************ ************************************************************
*/ */
static inline void icf_body_next_state(struct isal_zstream *stream) static inline void
icf_body_next_state(struct isal_zstream *stream)
{ {
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
struct isal_zstate *state = &stream->internal_state; struct isal_zstate *state = &stream->internal_state;
if (level_buf->icf_buf_avail_out <= 0) if (level_buf->icf_buf_avail_out <= 0)
state->state = ZSTATE_CREATE_HDR; state->state = ZSTATE_CREATE_HDR;
else if (stream->avail_in <= ISAL_LOOK_AHEAD else if (stream->avail_in <= ISAL_LOOK_AHEAD &&
&& (stream->end_of_stream || stream->flush != NO_FLUSH)) (stream->end_of_stream || stream->flush != NO_FLUSH))
state->state = ZSTATE_FLUSH_READ_BUFFER; state->state = ZSTATE_FLUSH_READ_BUFFER;
} }
void icf_body_hash1_fillgreedy_lazy(struct isal_zstream *stream) void
icf_body_hash1_fillgreedy_lazy(struct isal_zstream *stream)
{ {
struct deflate_icf *matches_icf, *matches_next_icf, *matches_end_icf; struct deflate_icf *matches_icf, *matches_next_icf, *matches_end_icf;
struct deflate_icf *matches_icf_lookup; struct deflate_icf *matches_icf_lookup;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint32_t input_size, processed; uint32_t input_size, processed;
matches_icf = level_buf->hash_map.matches; matches_icf = level_buf->hash_map.matches;
matches_icf_lookup = matches_icf; matches_icf_lookup = matches_icf;
matches_next_icf = level_buf->hash_map.matches_next; matches_next_icf = level_buf->hash_map.matches_next;
matches_end_icf = level_buf->hash_map.matches_end; matches_end_icf = level_buf->hash_map.matches_end;
matches_next_icf = compress_icf_map_g(stream, matches_next_icf, matches_end_icf); matches_next_icf = compress_icf_map_g(stream, matches_next_icf, matches_end_icf);
while (matches_next_icf >= matches_end_icf) { while (matches_next_icf >= matches_end_icf) {
input_size = MATCH_BUF_SIZE; input_size = MATCH_BUF_SIZE;
input_size = (input_size > stream->avail_in) ? stream->avail_in : input_size; input_size = (input_size > stream->avail_in) ? stream->avail_in : input_size;
if (input_size <= ISAL_LOOK_AHEAD) if (input_size <= ISAL_LOOK_AHEAD)
break; break;
processed = gen_icf_map_h1_base(stream, matches_icf_lookup, input_size); processed = gen_icf_map_h1_base(stream, matches_icf_lookup, input_size);
set_long_icf_fg(stream->next_in, processed, input_size, matches_icf_lookup); set_long_icf_fg(stream->next_in, processed, input_size, matches_icf_lookup);
stream->next_in += processed; stream->next_in += processed;
stream->avail_in -= processed; stream->avail_in -= processed;
stream->total_in += processed; stream->total_in += processed;
matches_end_icf = matches_icf + processed; matches_end_icf = matches_icf + processed;
matches_next_icf = compress_icf_map_g(stream, matches_icf, matches_end_icf); matches_next_icf = compress_icf_map_g(stream, matches_icf, matches_end_icf);
} }
level_buf->hash_map.matches_next = matches_next_icf; level_buf->hash_map.matches_next = matches_next_icf;
level_buf->hash_map.matches_end = matches_end_icf; level_buf->hash_map.matches_end = matches_end_icf;
icf_body_next_state(stream); icf_body_next_state(stream);
} }
void icf_body_lazyhash1_fillgreedy_greedy(struct isal_zstream *stream) void
icf_body_lazyhash1_fillgreedy_greedy(struct isal_zstream *stream)
{ {
struct deflate_icf *matches_icf, *matches_next_icf, *matches_end_icf; struct deflate_icf *matches_icf, *matches_next_icf, *matches_end_icf;
struct deflate_icf *matches_icf_lookup; struct deflate_icf *matches_icf_lookup;
struct level_buf *level_buf = (struct level_buf *)stream->level_buf; struct level_buf *level_buf = (struct level_buf *) stream->level_buf;
uint32_t input_size, processed; uint32_t input_size, processed;
matches_icf = level_buf->hash_map.matches; matches_icf = level_buf->hash_map.matches;
matches_icf_lookup = matches_icf; matches_icf_lookup = matches_icf;
matches_next_icf = level_buf->hash_map.matches_next; matches_next_icf = level_buf->hash_map.matches_next;
matches_end_icf = level_buf->hash_map.matches_end; matches_end_icf = level_buf->hash_map.matches_end;
matches_next_icf = compress_icf_map_g(stream, matches_next_icf, matches_end_icf); matches_next_icf = compress_icf_map_g(stream, matches_next_icf, matches_end_icf);
while (matches_next_icf >= matches_end_icf) { while (matches_next_icf >= matches_end_icf) {
input_size = MATCH_BUF_SIZE; input_size = MATCH_BUF_SIZE;
input_size = (input_size > stream->avail_in) ? stream->avail_in : input_size; input_size = (input_size > stream->avail_in) ? stream->avail_in : input_size;
if (input_size <= ISAL_LOOK_AHEAD) if (input_size <= ISAL_LOOK_AHEAD)
break; break;
processed = gen_icf_map_lh1(stream, matches_icf_lookup, input_size); processed = gen_icf_map_lh1(stream, matches_icf_lookup, input_size);
set_long_icf_fg(stream->next_in, processed, input_size, matches_icf_lookup); set_long_icf_fg(stream->next_in, processed, input_size, matches_icf_lookup);
stream->next_in += processed; stream->next_in += processed;
stream->avail_in -= processed; stream->avail_in -= processed;
stream->total_in += processed; stream->total_in += processed;
matches_end_icf = matches_icf + processed; matches_end_icf = matches_icf + processed;
matches_next_icf = compress_icf_map_g(stream, matches_icf, matches_end_icf); matches_next_icf = compress_icf_map_g(stream, matches_icf, matches_end_icf);
} }
level_buf->hash_map.matches_next = matches_next_icf; level_buf->hash_map.matches_next = matches_next_icf;
level_buf->hash_map.matches_end = matches_end_icf; level_buf->hash_map.matches_end = matches_end_icf;
icf_body_next_state(stream); icf_body_next_state(stream);
} }
void isal_deflate_icf_body(struct isal_zstream *stream) void
isal_deflate_icf_body(struct isal_zstream *stream)
{ {
switch (stream->level) { switch (stream->level) {
case 3: case 3:
isal_deflate_icf_body_lvl3(stream); isal_deflate_icf_body_lvl3(stream);
break; break;
case 2: case 2:
isal_deflate_icf_body_lvl2(stream); isal_deflate_icf_body_lvl2(stream);
break; break;
case 1: case 1:
default: default:
isal_deflate_icf_body_lvl1(stream); isal_deflate_icf_body_lvl1(stream);
} }
} }

3787
igzip/igzip_inflate.c
View File

File diff suppressed because it is too large Load Diff

446
igzip/igzip_inflate_test.c
View File

@ -39,272 +39,270 @@
/*Don't use file larger memory can support because compression and decompression /*Don't use file larger memory can support because compression and decompression
* are done in a stateless manner. */ * are done in a stateless manner. */
#if __WORDSIZE == 64 #if __WORDSIZE == 64
#define MAX_INPUT_FILE_SIZE 2L*1024L*1024L*1024L #define MAX_INPUT_FILE_SIZE 2L * 1024L * 1024L * 1024L
#else #else
#define MAX_INPUT_FILE_SIZE 512L*1024L*1024L #define MAX_INPUT_FILE_SIZE 512L * 1024L * 1024L
#endif #endif
int inflate_multi_pass(uint8_t * compress_buf, uint64_t compress_len, int
uint8_t * uncompress_buf, uint32_t * uncompress_len) inflate_multi_pass(uint8_t *compress_buf, uint64_t compress_len, uint8_t *uncompress_buf,
uint32_t *uncompress_len)
{ {
struct inflate_state *state = NULL; struct inflate_state *state = NULL;
int ret = 0; int ret = 0;
uint8_t *comp_tmp = NULL, *uncomp_tmp = NULL; uint8_t *comp_tmp = NULL, *uncomp_tmp = NULL;
uint32_t comp_tmp_size = 0, uncomp_tmp_size = 0; uint32_t comp_tmp_size = 0, uncomp_tmp_size = 0;
uint32_t comp_processed = 0, uncomp_processed = 0; uint32_t comp_processed = 0, uncomp_processed = 0;
state = malloc(sizeof(struct inflate_state)); state = malloc(sizeof(struct inflate_state));
if (state == NULL) { if (state == NULL) {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
exit(0); exit(0);
} }
isal_inflate_init(state); isal_inflate_init(state);
state->next_in = NULL; state->next_in = NULL;
state->next_out = NULL; state->next_out = NULL;
state->avail_in = 0; state->avail_in = 0;
state->avail_out = 0; state->avail_out = 0;
while (1) { while (1) {
if (state->avail_in == 0) { if (state->avail_in == 0) {
comp_tmp_size = rand() % (compress_len + 1); comp_tmp_size = rand() % (compress_len + 1);
if (comp_tmp_size >= compress_len - comp_processed) if (comp_tmp_size >= compress_len - comp_processed)
comp_tmp_size = compress_len - comp_processed; comp_tmp_size = compress_len - comp_processed;
if (comp_tmp_size != 0) { if (comp_tmp_size != 0) {
if (comp_tmp != NULL) if (comp_tmp != NULL)
free(comp_tmp); free(comp_tmp);
comp_tmp = malloc(comp_tmp_size); comp_tmp = malloc(comp_tmp_size);
if (comp_tmp == NULL) { if (comp_tmp == NULL) {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
exit(0); exit(0);
} }
memcpy(comp_tmp, compress_buf + comp_processed, comp_tmp_size); memcpy(comp_tmp, compress_buf + comp_processed, comp_tmp_size);
comp_processed += comp_tmp_size; comp_processed += comp_tmp_size;
state->next_in = comp_tmp; state->next_in = comp_tmp;
state->avail_in = comp_tmp_size; state->avail_in = comp_tmp_size;
} }
} }
if (state->avail_out == 0) { if (state->avail_out == 0) {
/* Save uncompressed data into uncompress_buf */ /* Save uncompressed data into uncompress_buf */
if (uncomp_tmp != NULL) { if (uncomp_tmp != NULL) {
memcpy(uncompress_buf + uncomp_processed, uncomp_tmp, memcpy(uncompress_buf + uncomp_processed, uncomp_tmp,
uncomp_tmp_size); uncomp_tmp_size);
uncomp_processed += uncomp_tmp_size; uncomp_processed += uncomp_tmp_size;
} }
uncomp_tmp_size = rand() % (*uncompress_len + 1); uncomp_tmp_size = rand() % (*uncompress_len + 1);
/* Limit size of buffer to be smaller than maximum */ /* Limit size of buffer to be smaller than maximum */
if (uncomp_tmp_size > *uncompress_len - uncomp_processed) if (uncomp_tmp_size > *uncompress_len - uncomp_processed)
uncomp_tmp_size = *uncompress_len - uncomp_processed; uncomp_tmp_size = *uncompress_len - uncomp_processed;
if (uncomp_tmp_size != 0) { if (uncomp_tmp_size != 0) {
if (uncomp_tmp != NULL) { if (uncomp_tmp != NULL) {
fflush(0); fflush(0);
free(uncomp_tmp); free(uncomp_tmp);
} }
uncomp_tmp = malloc(uncomp_tmp_size); uncomp_tmp = malloc(uncomp_tmp_size);
if (uncomp_tmp == NULL) { if (uncomp_tmp == NULL) {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
exit(0); exit(0);
} }
state->avail_out = uncomp_tmp_size; state->avail_out = uncomp_tmp_size;
state->next_out = uncomp_tmp; state->next_out = uncomp_tmp;
} }
} }
ret = isal_inflate(state); ret = isal_inflate(state);
if (state->block_state == ISAL_BLOCK_FINISH || ret != 0) { if (state->block_state == ISAL_BLOCK_FINISH || ret != 0) {
memcpy(uncompress_buf + uncomp_processed, uncomp_tmp, uncomp_tmp_size); memcpy(uncompress_buf + uncomp_processed, uncomp_tmp, uncomp_tmp_size);
*uncompress_len = state->total_out; *uncompress_len = state->total_out;
break; break;
} }
} }
if (comp_tmp != NULL) { if (comp_tmp != NULL) {
free(comp_tmp); free(comp_tmp);
comp_tmp = NULL; comp_tmp = NULL;
} }
if (uncomp_tmp != NULL) { if (uncomp_tmp != NULL) {
free(uncomp_tmp); free(uncomp_tmp);
uncomp_tmp = NULL; uncomp_tmp = NULL;
} }
free(state); free(state);
return ret; return ret;
} }
int test(uint8_t * compressed_stream, int
uint64_t * compressed_length, test(uint8_t *compressed_stream, uint64_t *compressed_length, uint8_t *uncompressed_stream,
uint8_t * uncompressed_stream, uint32_t uncompressed_length, uint32_t uncompressed_length, uint8_t *uncompressed_test_stream,
uint8_t * uncompressed_test_stream, uint32_t uncompressed_test_stream_length) uint32_t uncompressed_test_stream_length)
{ {
int ret; int ret;
ret = ret = compress2(compressed_stream, (uLongf *) compressed_length, uncompressed_stream,
compress2(compressed_stream, (uLongf *) compressed_length, uncompressed_length, 6);
uncompressed_stream, uncompressed_length, 6); if (ret) {
if (ret) { printf("Failed compressing input with exit code %d", ret);
printf("Failed compressing input with exit code %d", ret); return ret;
return ret; }
}
ret = ret = inflate_multi_pass(compressed_stream + 2, *compressed_length - 2 - 4,
inflate_multi_pass(compressed_stream + 2, uncompressed_test_stream, &uncompressed_test_stream_length);
*compressed_length - 2 - 4, switch (ret) {
uncompressed_test_stream, &uncompressed_test_stream_length); case 0:
switch (ret) { break;
case 0: case ISAL_END_INPUT:
break; printf(" did not decompress all input\n");
case ISAL_END_INPUT: return ISAL_END_INPUT;
printf(" did not decompress all input\n"); break;
return ISAL_END_INPUT; case ISAL_INVALID_BLOCK:
break; printf(" invalid header\n");
case ISAL_INVALID_BLOCK: return ISAL_INVALID_BLOCK;
printf(" invalid header\n"); break;
return ISAL_INVALID_BLOCK; case ISAL_INVALID_SYMBOL:
break; printf(" invalid symbol\n");
case ISAL_INVALID_SYMBOL: return ISAL_INVALID_SYMBOL;
printf(" invalid symbol\n"); break;
return ISAL_INVALID_SYMBOL; case ISAL_OUT_OVERFLOW:
break; printf(" out buffer overflow\n");
case ISAL_OUT_OVERFLOW: return ISAL_OUT_OVERFLOW;
printf(" out buffer overflow\n"); break;
return ISAL_OUT_OVERFLOW; case ISAL_INVALID_LOOKBACK:
break; printf("Invalid lookback distance");
case ISAL_INVALID_LOOKBACK: return ISAL_INVALID_LOOKBACK;
printf("Invalid lookback distance"); break;
return ISAL_INVALID_LOOKBACK; default:
break; printf(" error\n");
default: return -1;
printf(" error\n"); break;
return -1; }
break;
}
if (uncompressed_test_stream_length != uncompressed_length) { if (uncompressed_test_stream_length != uncompressed_length) {
printf("incorrect amount of data was decompressed from compressed data\n"); printf("incorrect amount of data was decompressed from compressed data\n");
printf("%d decompressed of %d compressed", printf("%d decompressed of %d compressed", uncompressed_test_stream_length,
uncompressed_test_stream_length, uncompressed_length); uncompressed_length);
return -1; return -1;
} }
if (memcmp(uncompressed_stream, uncompressed_test_stream, uncompressed_length)) { if (memcmp(uncompressed_stream, uncompressed_test_stream, uncompressed_length)) {
int i; int i;
for (i = 0; i < uncompressed_length; i++) { for (i = 0; i < uncompressed_length; i++) {
if (uncompressed_stream[i] != uncompressed_test_stream[i]) { if (uncompressed_stream[i] != uncompressed_test_stream[i]) {
printf("first error at %d, 0x%x != 0x%x\n", i, printf("first error at %d, 0x%x != 0x%x\n", i,
uncompressed_stream[i], uncompressed_test_stream[i]); uncompressed_stream[i], uncompressed_test_stream[i]);
} }
} }
printf(" decompressed data is not the same as the compressed data\n"); printf(" decompressed data is not the same as the compressed data\n");
return -1; return -1;
} }
return 0; return 0;
} }
int main(int argc, char **argv) int
main(int argc, char **argv)
{ {
int i, j, ret = 0, fin_ret = 0; int i, j, ret = 0, fin_ret = 0;
FILE *file = NULL; FILE *file = NULL;
uint64_t compressed_length, file_length; uint64_t compressed_length, file_length;
uint64_t uncompressed_length, uncompressed_test_stream_length; uint64_t uncompressed_length, uncompressed_test_stream_length;
uint8_t *uncompressed_stream = NULL; uint8_t *uncompressed_stream = NULL;
uint8_t *compressed_stream = NULL; uint8_t *compressed_stream = NULL;
uint8_t *uncompressed_test_stream = NULL; uint8_t *uncompressed_test_stream = NULL;
if (argc == 1) if (argc == 1)
printf("Error, no input file\n"); printf("Error, no input file\n");
for (i = 1; i < argc; i++) { for (i = 1; i < argc; i++) {
file = NULL; file = NULL;
uncompressed_stream = NULL; uncompressed_stream = NULL;
compressed_stream = NULL; compressed_stream = NULL;
uncompressed_test_stream = NULL; uncompressed_test_stream = NULL;
file = fopen(argv[i], "r"); file = fopen(argv[i], "r");
if (file == NULL) { if (file == NULL) {
printf("Error opening file %s\n", argv[i]); printf("Error opening file %s\n", argv[i]);
return 1; return 1;
} else } else
printf("Starting file %s", argv[i]); printf("Starting file %s", argv[i]);
fflush(0); fflush(0);
file_length = get_filesize(file); file_length = get_filesize(file);
if (file_length > MAX_INPUT_FILE_SIZE) { if (file_length > MAX_INPUT_FILE_SIZE) {
printf("\nFile too large to run on this test," printf("\nFile too large to run on this test,"
" Max 512MB for 32bit OS, 2GB for 64bit OS.\n"); " Max 512MB for 32bit OS, 2GB for 64bit OS.\n");
printf(" ... Fail\n"); printf(" ... Fail\n");
fclose(file); fclose(file);
continue; continue;
} }
compressed_length = compressBound(file_length); compressed_length = compressBound(file_length);
if (file_length != 0) { if (file_length != 0) {
uncompressed_stream = malloc(file_length); uncompressed_stream = malloc(file_length);
uncompressed_test_stream = malloc(file_length); uncompressed_test_stream = malloc(file_length);
} }
compressed_stream = malloc(compressed_length); compressed_stream = malloc(compressed_length);
if (uncompressed_stream == NULL && file_length != 0) { if (uncompressed_stream == NULL && file_length != 0) {
printf("\nFailed to allocate input memory\n"); printf("\nFailed to allocate input memory\n");
exit(0); exit(0);
} }
if (compressed_stream == NULL) { if (compressed_stream == NULL) {
printf("\nFailed to allocate output memory\n"); printf("\nFailed to allocate output memory\n");
exit(0); exit(0);
} }
if (uncompressed_test_stream == NULL && file_length != 0) { if (uncompressed_test_stream == NULL && file_length != 0) {
printf("\nFailed to allocate decompressed memory\n"); printf("\nFailed to allocate decompressed memory\n");
exit(0); exit(0);
} }
uncompressed_length = uncompressed_length = (uncompressed_stream == NULL)
(uncompressed_stream == NULL) ? 0 : fread(uncompressed_stream, 1, ? 0
file_length, file); : fread(uncompressed_stream, 1, file_length, file);
uncompressed_test_stream_length = uncompressed_length; uncompressed_test_stream_length = uncompressed_length;
ret = ret = test(compressed_stream, &compressed_length, uncompressed_stream,
test(compressed_stream, &compressed_length, uncompressed_stream, uncompressed_length, uncompressed_test_stream,
uncompressed_length, uncompressed_test_stream, uncompressed_test_stream_length);
uncompressed_test_stream_length); if (ret) {
if (ret) { for (j = 0; j < compressed_length; j++) {
for (j = 0; j < compressed_length; j++) { if ((j & 31) == 0)
if ((j & 31) == 0) printf("\n");
printf("\n"); else
else printf(" ");
printf(" "); printf("0x%02x,", compressed_stream[j]);
printf("0x%02x,", compressed_stream[j]); }
} printf("\n");
printf("\n"); }
}
fflush(0); fflush(0);
fclose(file); fclose(file);
if (compressed_stream != NULL) if (compressed_stream != NULL)
free(compressed_stream); free(compressed_stream);
if (uncompressed_stream != NULL) if (uncompressed_stream != NULL)
free(uncompressed_stream); free(uncompressed_stream);
if (uncompressed_test_stream != NULL) if (uncompressed_test_stream != NULL)
free(uncompressed_test_stream); free(uncompressed_test_stream);
if (ret) { if (ret) {
printf(" ... Fail with exit code %d\n", ret); printf(" ... Fail with exit code %d\n", ret);
return ret; return ret;
} else } else
printf(" ... Pass\n"); printf(" ... Pass\n");
fin_ret |= ret; fin_ret |= ret;
} }
return fin_ret; return fin_ret;
} }

46
igzip/igzip_level_buf_structs.h
View File

@ -8,41 +8,41 @@
#define MATCH_BUF_SIZE (4 * 1024) #define MATCH_BUF_SIZE (4 * 1024)
struct hash8k_buf { struct hash8k_buf {
uint16_t hash_table[IGZIP_HASH8K_HASH_SIZE]; uint16_t hash_table[IGZIP_HASH8K_HASH_SIZE];
}; };
struct hash_hist_buf { struct hash_hist_buf {
uint16_t hash_table[IGZIP_HASH_HIST_SIZE]; uint16_t hash_table[IGZIP_HASH_HIST_SIZE];
}; };
struct hash_map_buf { struct hash_map_buf {
uint16_t hash_table[IGZIP_HASH_MAP_HASH_SIZE]; uint16_t hash_table[IGZIP_HASH_MAP_HASH_SIZE];
struct deflate_icf *matches_next; struct deflate_icf *matches_next;
struct deflate_icf *matches_end; struct deflate_icf *matches_end;
struct deflate_icf matches[MATCH_BUF_SIZE]; struct deflate_icf matches[MATCH_BUF_SIZE];
struct deflate_icf overflow[ISAL_LOOK_AHEAD]; struct deflate_icf overflow[ISAL_LOOK_AHEAD];
}; };
#define MAX_LVL_BUF_SIZE sizeof(struct hash_map_buf) #define MAX_LVL_BUF_SIZE sizeof(struct hash_map_buf)
struct level_buf { struct level_buf {
struct hufftables_icf encode_tables; struct hufftables_icf encode_tables;
struct isal_mod_hist hist; struct isal_mod_hist hist;
uint32_t deflate_hdr_count; uint32_t deflate_hdr_count;
uint32_t deflate_hdr_extra_bits; uint32_t deflate_hdr_extra_bits;
uint8_t deflate_hdr[ISAL_DEF_MAX_HDR_SIZE]; uint8_t deflate_hdr[ISAL_DEF_MAX_HDR_SIZE];
struct deflate_icf *icf_buf_next; struct deflate_icf *icf_buf_next;
uint64_t icf_buf_avail_out; uint64_t icf_buf_avail_out;
struct deflate_icf *icf_buf_start; struct deflate_icf *icf_buf_start;
union { union {
struct hash8k_buf hash8k; struct hash8k_buf hash8k;
struct hash_hist_buf hash_hist; struct hash_hist_buf hash_hist;
struct hash_map_buf hash_map; struct hash_map_buf hash_map;
struct hash8k_buf lvl1; struct hash8k_buf lvl1;
struct hash_hist_buf lvl2; struct hash_hist_buf lvl2;
struct hash_map_buf lvl3; struct hash_map_buf lvl3;
}; };
}; };
#endif #endif

1379
igzip/igzip_perf.c
View File

File diff suppressed because it is too large Load Diff

4731
igzip/igzip_rand_test.c
View File

File diff suppressed because it is too large Load Diff

491
igzip/igzip_semi_dyn_file_perf.c
View File

@ -35,300 +35,303 @@
#include "igzip_lib.h" #include "igzip_lib.h"
#include "test.h" #include "test.h"
#define MIN_BUF_SIZE (4 * 1024) #define MIN_BUF_SIZE (4 * 1024)
#define MIN_TEST_LOOPS 10 #define MIN_TEST_LOOPS 10
#ifndef RUN_MEM_SIZE #ifndef RUN_MEM_SIZE
# define RUN_MEM_SIZE 500000000 #define RUN_MEM_SIZE 500000000
#endif #endif
#define DEFAULT_SEG_SIZE (512 * 1024) #define DEFAULT_SEG_SIZE (512 * 1024)
#define DEFAULT_SAMPLE_SIZE (32 * 1024) #define DEFAULT_SAMPLE_SIZE (32 * 1024)
int usage(void) int
usage(void)
{ {
fprintf(stderr, fprintf(stderr,
"Usage: igzip_semi_dynamic [options] <infile>\n" "Usage: igzip_semi_dynamic [options] <infile>\n"
" -h help\n" " -h help\n"
" -v (don't) validate output by inflate and compare\n" " -v (don't) validate output by inflate and compare\n"
" -t <type> 1:stateless 0:(default)stateful\n" " -t <type> 1:stateless 0:(default)stateful\n"
" -c <size> chunk size default=%d\n" " -c <size> chunk size default=%d\n"
" -s <size> sample size default=%d\n" " -s <size> sample size default=%d\n"
" -o <file> output file\n", DEFAULT_SEG_SIZE, DEFAULT_SAMPLE_SIZE); " -o <file> output file\n",
exit(0); DEFAULT_SEG_SIZE, DEFAULT_SAMPLE_SIZE);
exit(0);
} }
int str_to_i(char *s) int
str_to_i(char *s)
{ {
#define ARG_MAX 32 #define ARG_MAX 32
int i = atoi(s); int i = atoi(s);
int len = strnlen(s, ARG_MAX); int len = strnlen(s, ARG_MAX);
if (len < 2 || len == ARG_MAX) if (len < 2 || len == ARG_MAX)
return i; return i;
switch (s[len - 1]) { switch (s[len - 1]) {
case 'k': case 'k':
i *= 1024; i *= 1024;
break; break;
case 'K': case 'K':
i *= 1000; i *= 1000;
break; break;
case 'm': case 'm':
i *= (1024 * 1024); i *= (1024 * 1024);
break; break;
case 'M': case 'M':
i *= (1000 * 1000); i *= (1000 * 1000);
break; break;
case 'g': case 'g':
i *= (1024 * 1024 * 1024); i *= (1024 * 1024 * 1024);
break; break;
case 'G': case 'G':
i *= (1000 * 1000 * 1000); i *= (1000 * 1000 * 1000);
break; break;
} }
return i; return i;
} }
void semi_dyn_stateless_perf(struct isal_zstream *stream, uint8_t * inbuf, void
uint64_t infile_size, uint8_t * outbuf, uint64_t outbuf_size, semi_dyn_stateless_perf(struct isal_zstream *stream, uint8_t *inbuf, uint64_t infile_size,
int segment_size, int hist_size) uint8_t *outbuf, uint64_t outbuf_size, int segment_size, int hist_size)
{ {
struct isal_huff_histogram histogram; struct isal_huff_histogram histogram;
struct isal_hufftables hufftable; struct isal_hufftables hufftable;
isal_deflate_stateless_init(stream); isal_deflate_stateless_init(stream);
stream->end_of_stream = 0; stream->end_of_stream = 0;
stream->flush = FULL_FLUSH; stream->flush = FULL_FLUSH;
stream->next_in = inbuf; stream->next_in = inbuf;
stream->next_out = outbuf; stream->next_out = outbuf;
int remaining = infile_size; int remaining = infile_size;
int chunk_size = segment_size; int chunk_size = segment_size;
while (remaining > 0) { while (remaining > 0) {
// Generate custom hufftables on sample // Generate custom hufftables on sample
memset(&histogram, 0, sizeof(struct isal_huff_histogram)); memset(&histogram, 0, sizeof(struct isal_huff_histogram));
if (remaining < segment_size * 2) { if (remaining < segment_size * 2) {
chunk_size = remaining; chunk_size = remaining;
stream->end_of_stream = 1; stream->end_of_stream = 1;
} }
int hist_rem = (hist_size > chunk_size) ? chunk_size : hist_size; int hist_rem = (hist_size > chunk_size) ? chunk_size : hist_size;
isal_update_histogram(stream->next_in, hist_rem, &histogram); isal_update_histogram(stream->next_in, hist_rem, &histogram);
if (hist_rem == chunk_size) if (hist_rem == chunk_size)
isal_create_hufftables_subset(&hufftable, &histogram); isal_create_hufftables_subset(&hufftable, &histogram);
else else
isal_create_hufftables(&hufftable, &histogram); isal_create_hufftables(&hufftable, &histogram);
// Compress with custom table // Compress with custom table
stream->avail_in = chunk_size; stream->avail_in = chunk_size;
stream->avail_out = chunk_size + 8 * (1 + (chunk_size >> 16)); stream->avail_out = chunk_size + 8 * (1 + (chunk_size >> 16));
stream->hufftables = &hufftable; stream->hufftables = &hufftable;
remaining -= chunk_size; remaining -= chunk_size;
isal_deflate_stateless(stream); isal_deflate_stateless(stream);
if (stream->avail_in != 0) if (stream->avail_in != 0)
break; break;
} }
} }
void semi_dyn_stateful_perf(struct isal_zstream *stream, uint8_t * inbuf, void
uint64_t infile_size, uint8_t * outbuf, uint64_t outbuf_size, semi_dyn_stateful_perf(struct isal_zstream *stream, uint8_t *inbuf, uint64_t infile_size,
int segment_size, int hist_size) uint8_t *outbuf, uint64_t outbuf_size, int segment_size, int hist_size)
{ {
struct isal_huff_histogram histogram; struct isal_huff_histogram histogram;
struct isal_hufftables hufftable; struct isal_hufftables hufftable;
isal_deflate_init(stream); isal_deflate_init(stream);
stream->end_of_stream = 0; stream->end_of_stream = 0;
stream->flush = SYNC_FLUSH; stream->flush = SYNC_FLUSH;
stream->next_in = inbuf; stream->next_in = inbuf;
stream->next_out = outbuf; stream->next_out = outbuf;
stream->avail_out = outbuf_size; stream->avail_out = outbuf_size;
int remaining = infile_size; int remaining = infile_size;
int chunk_size = segment_size; int chunk_size = segment_size;
while (remaining > 0) { while (remaining > 0) {
// Generate custom hufftables on sample // Generate custom hufftables on sample
memset(&histogram, 0, sizeof(struct isal_huff_histogram)); memset(&histogram, 0, sizeof(struct isal_huff_histogram));
if (remaining < segment_size * 2) { if (remaining < segment_size * 2) {
chunk_size = remaining; chunk_size = remaining;
stream->end_of_stream = 1; stream->end_of_stream = 1;
} }
int hist_rem = (hist_size > chunk_size) ? chunk_size : hist_size; int hist_rem = (hist_size > chunk_size) ? chunk_size : hist_size;
isal_update_histogram(stream->next_in, hist_rem, &histogram); isal_update_histogram(stream->next_in, hist_rem, &histogram);
if (hist_rem == chunk_size) if (hist_rem == chunk_size)
isal_create_hufftables_subset(&hufftable, &histogram); isal_create_hufftables_subset(&hufftable, &histogram);
else else
isal_create_hufftables(&hufftable, &histogram); isal_create_hufftables(&hufftable, &histogram);
// Compress with custom table // Compress with custom table
stream->avail_in = chunk_size; stream->avail_in = chunk_size;
stream->hufftables = &hufftable; stream->hufftables = &hufftable;
remaining -= chunk_size; remaining -= chunk_size;
isal_deflate(stream); isal_deflate(stream);
if (stream->internal_state.state != ZSTATE_NEW_HDR) if (stream->internal_state.state != ZSTATE_NEW_HDR)
break; break;
} }
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
FILE *in = stdin, *out = NULL; FILE *in = stdin, *out = NULL;
unsigned char *inbuf, *outbuf; unsigned char *inbuf, *outbuf;
int i = 0, c; int i = 0, c;
uint64_t infile_size, outbuf_size; uint64_t infile_size, outbuf_size;
int segment_size = DEFAULT_SEG_SIZE; int segment_size = DEFAULT_SEG_SIZE;
int sample_size = DEFAULT_SAMPLE_SIZE; int sample_size = DEFAULT_SAMPLE_SIZE;
int check_output = 1; int check_output = 1;
int do_stateless = 0, do_stateful = 1; int do_stateless = 0, do_stateful = 1;
int ret = 0; int ret = 0;
char *out_file_name = NULL; char *out_file_name = NULL;
struct isal_zstream stream; struct isal_zstream stream;
while ((c = getopt(argc, argv, "vht:c:s:o:")) != -1) { while ((c = getopt(argc, argv, "vht:c:s:o:")) != -1) {
switch (c) { switch (c) {
case 'v': case 'v':
check_output ^= 1; check_output ^= 1;
break; break;
case 't': case 't':
if (atoi(optarg) == 1) { if (atoi(optarg) == 1) {
do_stateful = 0; do_stateful = 0;
do_stateless = 1; do_stateless = 1;
} }
break; break;
case 'c': case 'c':
segment_size = str_to_i(optarg); segment_size = str_to_i(optarg);
break; break;
case 's': case 's':
sample_size = str_to_i(optarg); sample_size = str_to_i(optarg);
break; break;
case 'o': case 'o':
out_file_name = optarg; out_file_name = optarg;
break; break;
case 'h': case 'h':
default: default:
usage(); usage();
break; break;
} }
} }
// Open input file // Open input file
if (optind < argc) { if (optind < argc) {
if (!(in = fopen(argv[optind], "rb"))) { if (!(in = fopen(argv[optind], "rb"))) {
fprintf(stderr, "Can't open %s for reading\n", argv[optind]); fprintf(stderr, "Can't open %s for reading\n", argv[optind]);
exit(1); exit(1);
} }
} else } else
usage(); usage();
// Optionally open output file // Optionally open output file
if (out_file_name != NULL) { if (out_file_name != NULL) {
if (!(out = fopen(out_file_name, "wb"))) { if (!(out = fopen(out_file_name, "wb"))) {
fprintf(stderr, "Can't open %s for writing\n", out_file_name); fprintf(stderr, "Can't open %s for writing\n", out_file_name);
exit(1); exit(1);
} }
} }
printf("Window Size: %d K\n", IGZIP_HIST_SIZE / 1024); printf("Window Size: %d K\n", IGZIP_HIST_SIZE / 1024);
/* /*
* Allocate space for entire input file and output * Allocate space for entire input file and output
* (assuming some possible expansion on output size) * (assuming some possible expansion on output size)
*/ */
infile_size = get_filesize(in); infile_size = get_filesize(in);
if (infile_size == 0) { if (infile_size == 0) {
printf("Input file has zero length\n"); printf("Input file has zero length\n");
usage(); usage();
} }
outbuf_size = infile_size * 1.30 > MIN_BUF_SIZE ? infile_size * 1.30 : MIN_BUF_SIZE; outbuf_size = infile_size * 1.30 > MIN_BUF_SIZE ? infile_size * 1.30 : MIN_BUF_SIZE;
if (NULL == (inbuf = malloc(infile_size))) { if (NULL == (inbuf = malloc(infile_size))) {
fprintf(stderr, "Can't allocate input buffer memory\n"); fprintf(stderr, "Can't allocate input buffer memory\n");
exit(0); exit(0);
} }
if (NULL == (outbuf = malloc(outbuf_size))) { if (NULL == (outbuf = malloc(outbuf_size))) {
fprintf(stderr, "Can't allocate output buffer memory\n"); fprintf(stderr, "Can't allocate output buffer memory\n");
exit(0); exit(0);
} }
int hist_size = sample_size > segment_size ? segment_size : sample_size; int hist_size = sample_size > segment_size ? segment_size : sample_size;
printf("semi-dynamic sample=%d segment=%d %s\n", hist_size, segment_size, printf("semi-dynamic sample=%d segment=%d %s\n", hist_size, segment_size,
do_stateful ? "stateful" : "stateless"); do_stateful ? "stateful" : "stateless");
printf("igzip_file_perf: %s\n", argv[optind]); printf("igzip_file_perf: %s\n", argv[optind]);
// Read complete input file into buffer // Read complete input file into buffer
stream.avail_in = (uint32_t) fread(inbuf, 1, infile_size, in); stream.avail_in = (uint32_t) fread(inbuf, 1, infile_size, in);
if (stream.avail_in != infile_size) { if (stream.avail_in != infile_size) {
fprintf(stderr, "Couldn't fit all of input file into buffer\n"); fprintf(stderr, "Couldn't fit all of input file into buffer\n");
exit(0); exit(0);
} }
struct perf start; struct perf start;
if (do_stateful) { if (do_stateful) {
BENCHMARK(&start, BENCHMARK_TIME, BENCHMARK(&start, BENCHMARK_TIME,
semi_dyn_stateful_perf(&stream, inbuf, infile_size, outbuf, semi_dyn_stateful_perf(&stream, inbuf, infile_size, outbuf, outbuf_size,
outbuf_size, segment_size, hist_size) segment_size, hist_size));
); }
}
if (do_stateless) { if (do_stateless) {
BENCHMARK(&start, BENCHMARK_TIME, BENCHMARK(&start, BENCHMARK_TIME,
semi_dyn_stateless_perf(&stream, inbuf, infile_size, outbuf, semi_dyn_stateless_perf(&stream, inbuf, infile_size, outbuf, outbuf_size,
outbuf_size, segment_size, hist_size)); segment_size, hist_size));
} }
if (stream.avail_in != 0) { if (stream.avail_in != 0) {
printf("Could not compress all of inbuf\n"); printf("Could not compress all of inbuf\n");
ret = 1; ret = 1;
} }
printf(" file %s - in_size=%lu out_size=%d iter=%d ratio=%3.1f%%\n", argv[optind], printf(" file %s - in_size=%lu out_size=%d iter=%d ratio=%3.1f%%\n", argv[optind],
infile_size, stream.total_out, i, 100.0 * stream.total_out / infile_size); infile_size, stream.total_out, i, 100.0 * stream.total_out / infile_size);
printf("igzip_semi_dyn_file: "); printf("igzip_semi_dyn_file: ");
perf_print(start, (long long)infile_size); perf_print(start, (long long) infile_size);
if (out != NULL) { if (out != NULL) {
printf("writing %s\n", out_file_name); printf("writing %s\n", out_file_name);
fwrite(outbuf, 1, stream.total_out, out); fwrite(outbuf, 1, stream.total_out, out);
fclose(out); fclose(out);
} }
fclose(in); fclose(in);
if (check_output) { if (check_output) {
unsigned char *inflate_buf; unsigned char *inflate_buf;
struct inflate_state istate; struct inflate_state istate;
if (NULL == (inflate_buf = malloc(infile_size))) { if (NULL == (inflate_buf = malloc(infile_size))) {
fprintf(stderr, "Can't allocate reconstruct buffer memory\n"); fprintf(stderr, "Can't allocate reconstruct buffer memory\n");
exit(0); exit(0);
} }
isal_inflate_init(&istate); isal_inflate_init(&istate);
istate.next_in = outbuf; istate.next_in = outbuf;
istate.avail_in = stream.total_out; istate.avail_in = stream.total_out;
istate.next_out = inflate_buf; istate.next_out = inflate_buf;
istate.avail_out = infile_size; istate.avail_out = infile_size;
int check = isal_inflate(&istate); int check = isal_inflate(&istate);
if (memcmp(inflate_buf, inbuf, infile_size)) { if (memcmp(inflate_buf, inbuf, infile_size)) {
printf("inflate check Fail\n"); printf("inflate check Fail\n");
printf(" ret %d total_inflate=%d\n", check, istate.total_out); printf(" ret %d total_inflate=%d\n", check, istate.total_out);
for (i = 0; i < infile_size; i++) { for (i = 0; i < infile_size; i++) {
if (inbuf[i] != inflate_buf[i]) { if (inbuf[i] != inflate_buf[i]) {
printf(" first diff at offset=%d\n", i); printf(" first diff at offset=%d\n", i);
break; break;
} }
} }
ret = 1; ret = 1;
} else } else
printf("inflate check Pass\n"); printf("inflate check Pass\n");
free(inflate_buf); free(inflate_buf);
} }
printf("End of igzip_semi_dyn_file_perf\n\n"); printf("End of igzip_semi_dyn_file_perf\n\n");
return ret; return ret;
} }

79
igzip/igzip_sync_flush_example.c
View File

@ -36,51 +36,52 @@
struct isal_zstream stream; struct isal_zstream stream;
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
uint8_t inbuf[BUF_SIZE], outbuf[BUF_SIZE]; uint8_t inbuf[BUF_SIZE], outbuf[BUF_SIZE];
FILE *in, *out; FILE *in, *out;
if (argc != 3) { if (argc != 3) {
fprintf(stderr, "Usage: igzip_sync_flush_example infile outfile\n"); fprintf(stderr, "Usage: igzip_sync_flush_example infile outfile\n");
exit(0); exit(0);
} }
in = fopen(argv[1], "rb"); in = fopen(argv[1], "rb");
if (!in) { if (!in) {
fprintf(stderr, "Can't open %s for reading\n", argv[1]); fprintf(stderr, "Can't open %s for reading\n", argv[1]);
exit(0); exit(0);
} }
out = fopen(argv[2], "wb"); out = fopen(argv[2], "wb");
if (!out) { if (!out) {
fprintf(stderr, "Can't open %s for writing\n", argv[2]); fprintf(stderr, "Can't open %s for writing\n", argv[2]);
exit(0); exit(0);
} }
printf("igzip_sync_flush_example\nWindow Size: %d K\n", IGZIP_HIST_SIZE / 1024); printf("igzip_sync_flush_example\nWindow Size: %d K\n", IGZIP_HIST_SIZE / 1024);
fflush(0); fflush(0);
isal_deflate_init(&stream); isal_deflate_init(&stream);
stream.end_of_stream = 0; stream.end_of_stream = 0;
stream.flush = SYNC_FLUSH; stream.flush = SYNC_FLUSH;
do { do {
if (stream.internal_state.state == ZSTATE_NEW_HDR) { if (stream.internal_state.state == ZSTATE_NEW_HDR) {
stream.avail_in = (uint32_t) fread(inbuf, 1, BUF_SIZE, in); stream.avail_in = (uint32_t) fread(inbuf, 1, BUF_SIZE, in);
stream.end_of_stream = feof(in) ? 1 : 0; stream.end_of_stream = feof(in) ? 1 : 0;
stream.next_in = inbuf; stream.next_in = inbuf;
} }
do { do {
stream.avail_out = BUF_SIZE; stream.avail_out = BUF_SIZE;
stream.next_out = outbuf; stream.next_out = outbuf;
isal_deflate(&stream); isal_deflate(&stream);
fwrite(outbuf, 1, BUF_SIZE - stream.avail_out, out); fwrite(outbuf, 1, BUF_SIZE - stream.avail_out, out);
} while (stream.avail_out == 0); } while (stream.avail_out == 0);
} while (stream.internal_state.state != ZSTATE_END); } while (stream.internal_state.state != ZSTATE_END);
fclose(out); fclose(out);
fclose(in); fclose(in);
printf("End of igzip_sync_flush_example\n\n"); printf("End of igzip_sync_flush_example\n\n");
return 0; return 0;
} }

24
igzip/igzip_wrapper.h
View File

@ -31,22 +31,22 @@
#define DEFLATE_METHOD 8 #define DEFLATE_METHOD 8
#define ZLIB_DICT_FLAG (1 << 5) #define ZLIB_DICT_FLAG (1 << 5)
#define TEXT_FLAG (1 << 0) #define TEXT_FLAG (1 << 0)
#define HCRC_FLAG (1 << 1) #define HCRC_FLAG (1 << 1)
#define EXTRA_FLAG (1 << 2) #define EXTRA_FLAG (1 << 2)
#define NAME_FLAG (1 << 3) #define NAME_FLAG (1 << 3)
#define COMMENT_FLAG (1 << 4) #define COMMENT_FLAG (1 << 4)
#define UNDEFINED_FLAG (-1) #define UNDEFINED_FLAG (-1)
#define GZIP_HDR_BASE 10 #define GZIP_HDR_BASE 10
#define GZIP_EXTRA_LEN 2 #define GZIP_EXTRA_LEN 2
#define GZIP_HCRC_LEN 2 #define GZIP_HCRC_LEN 2
#define GZIP_TRAILER_LEN 8 #define GZIP_TRAILER_LEN 8
#define ZLIB_HDR_BASE 2 #define ZLIB_HDR_BASE 2
#define ZLIB_DICT_LEN 4 #define ZLIB_DICT_LEN 4
#define ZLIB_INFO_OFFSET 4 #define ZLIB_INFO_OFFSET 4
#define ZLIB_LEVEL_OFFSET 6 #define ZLIB_LEVEL_OFFSET 6
#define ZLIB_TRAILER_LEN 4 #define ZLIB_TRAILER_LEN 4
#endif #endif

1363
igzip/igzip_wrapper_hdr_test.c
View File

File diff suppressed because it is too large Load Diff

2498
igzip/inflate_std_vects.h
View File

File diff suppressed because it is too large Load Diff

77
igzip/proc_heap_base.c
View File

@ -31,55 +31,56 @@
#include "huff_codes.h" #include "huff_codes.h"
#include "unaligned.h" #include "unaligned.h"
static inline void heapify(uint64_t * heap, uint64_t heap_size, uint64_t index) static inline void
heapify(uint64_t *heap, uint64_t heap_size, uint64_t index)
{ {
uint64_t child = 2 * index, tmp; uint64_t child = 2 * index, tmp;
while (child <= heap_size) { while (child <= heap_size) {
child = (heap[child] <= heap[child + 1]) ? child : child + 1; child = (heap[child] <= heap[child + 1]) ? child : child + 1;
if (heap[index] > heap[child]) { if (heap[index] > heap[child]) {
tmp = heap[index]; tmp = heap[index];
heap[index] = heap[child]; heap[index] = heap[child];
heap[child] = tmp; heap[child] = tmp;
index = child; index = child;
child = 2 * index; child = 2 * index;
} else } else
break; break;
} }
} }
void build_heap(uint64_t * heap, uint64_t heap_size) void
build_heap(uint64_t *heap, uint64_t heap_size)
{ {
uint64_t i; uint64_t i;
heap[heap_size + 1] = -1; heap[heap_size + 1] = -1;
for (i = heap_size / 2; i > 0; i--) for (i = heap_size / 2; i > 0; i--)
heapify(heap, heap_size, i); heapify(heap, heap_size, i);
} }
uint32_t build_huff_tree(struct heap_tree *heap_space, uint64_t heap_size, uint64_t node_ptr) uint32_t
build_huff_tree(struct heap_tree *heap_space, uint64_t heap_size, uint64_t node_ptr)
{ {
uint64_t *heap = (uint64_t *) heap_space; uint64_t *heap = (uint64_t *) heap_space;
uint64_t h1, h2; uint64_t h1, h2;
while (heap_size > 1) { while (heap_size > 1) {
h1 = heap[1]; h1 = heap[1];
heap[1] = heap[heap_size]; heap[1] = heap[heap_size];
heap[heap_size--] = -1; heap[heap_size--] = -1;
heapify(heap, heap_size, 1); heapify(heap, heap_size, 1);
h2 = heap[1]; h2 = heap[1];
heap[1] = ((h1 + h2) & ~0xFFFFull) | node_ptr; heap[1] = ((h1 + h2) & ~0xFFFFull) | node_ptr;
heapify(heap, heap_size, 1); heapify(heap, heap_size, 1);
store_native_u16_to_u64(&heap[node_ptr], h1); store_native_u16_to_u64(&heap[node_ptr], h1);
store_native_u16_to_u64(&heap[node_ptr - 1], h2); store_native_u16_to_u64(&heap[node_ptr - 1], h2);
node_ptr -= 2; node_ptr -= 2;
}
} h1 = heap[1];
h1 = heap[1]; store_native_u16_to_u64(&heap[node_ptr], h1);
store_native_u16_to_u64(&heap[node_ptr], h1); return node_ptr;
return node_ptr;
} }

19
igzip/repeated_char_result.h
View File

@ -30,25 +30,25 @@
#define _IGZIP_REPEATED_8K_CHAR_RESULT_H_ #define _IGZIP_REPEATED_8K_CHAR_RESULT_H_
/* The code for the literal being encoded */ /* The code for the literal being encoded */
#define CODE_LIT 0x1 #define CODE_LIT 0x1
#define CODE_LIT_LENGTH 0x2 #define CODE_LIT_LENGTH 0x2
/* The code for repeat 10. The Length includes the distance code length*/ /* The code for repeat 10. The Length includes the distance code length*/
#define CODE_10 0x3 #define CODE_10 0x3
#define CODE_10_LENGTH 0x4 #define CODE_10_LENGTH 0x4
/* The code for repeat 115-130. The Length includes the distance code length*/ /* The code for repeat 115-130. The Length includes the distance code length*/
#define CODE_280 0x0f #define CODE_280 0x0f
#define CODE_280_LENGTH 0x4 #define CODE_280_LENGTH 0x4
#define CODE_280_TOTAL_LENGTH CODE_280_LENGTH + 4 + 1 #define CODE_280_TOTAL_LENGTH CODE_280_LENGTH + 4 + 1
/* Code representing the end of block. */ /* Code representing the end of block. */
#define END_OF_BLOCK 0x7 #define END_OF_BLOCK 0x7
#define END_OF_BLOCK_LEN 0x4 #define END_OF_BLOCK_LEN 0x4
/* MIN_REPEAT_LEN currently optimizes storage space, another possibility is to /* MIN_REPEAT_LEN currently optimizes storage space, another possibility is to
* find the size which optimizes speed instead.*/ * find the size which optimizes speed instead.*/
#define MIN_REPEAT_LEN 4*1024 #define MIN_REPEAT_LEN 4 * 1024
#define HEADER_LENGTH 16 #define HEADER_LENGTH 16
@ -56,12 +56,11 @@
* smaller than 258 */ * smaller than 258 */
#define MAX_FIXUP_CODE_LENGTH 8 #define MAX_FIXUP_CODE_LENGTH 8
/* Headers for constant 0x00 and 0xFF blocks /* Headers for constant 0x00 and 0xFF blocks
* This also contains the first literal character. */ * This also contains the first literal character. */
const uint32_t repeated_char_header[2][5] = { const uint32_t repeated_char_header[2][5] = {
{ 0x0121c0ec, 0xc30c0000, 0x7d57fab0, 0x49270938}, /* Deflate header for 0x00 */ { 0x0121c0ec, 0xc30c0000, 0x7d57fab0, 0x49270938 }, /* Deflate header for 0x00 */
{ 0x0121c0ec, 0xc30c0000, 0x7baaff30, 0x49270938} /* Deflate header for 0xFF */ { 0x0121c0ec, 0xc30c0000, 0x7baaff30, 0x49270938 } /* Deflate header for 0xFF */
}; };

4887
igzip/static_inflate.h
View File

File diff suppressed because it is too large Load Diff