速度之王 — LZ4压缩算法（三）
LZ4 (Extremely Fast Compression algorithm)
项目：http://code.google.com/p/lz4/
作者：Yann Collet
本文作者：zhangskd @ csdn blog
实现
(3) 流操作
typedef struct {
U32 hashTable[HASHNBCELLS4]; /* 哈希表 */
const BYTE *bufferStart; /* 类似于前向缓存 */
const BYTE *base; /* 哈希表中采用的基准地址srcBase */
const BYTE *nextBlock; /* 下一个块的地址 */
} LZ4_Data_Structure;
FORCE_INLINE void LZ4_init(LZ4_Data_Structure *lz4ds, const BYTE *base)
{
MEM_INIT(lz4ds->hashTable, 0, sizeof(lz4ds->hashTable));
lz4ds->bufferStart = base;
lz4ds->base = base;
lz4ds->nextBlock = base;
}
创建和初始化LZ4_Data_Structure实例。
void *LZ4_create(const char *inputBuffer)
{
void *lz4ds = ALLOCATOR(1, sizeof(LZ4_Data_Structure));
LZ4_init((LZ4_Data_Structure *)lz4ds, (const BYTE *)inputBuffer);
return lz4ds;
}
释放LZ4_Data_Structure实例。
int LZ4_free(void *LZ4_Data)
{
FREEMEM(LZ4_Data);
return 0;
}
当输入缓存不够的时候，进行调整。
char *LZ4_slideInputBuffer(void *LZ4_Data)
{
LZ4_Data_Structure *lz4ds = (LZ4_Data_Structure *) LZ4_Data;
size_t delta = lz4ds->nextBlock - (lz4ds->bufferStart + 64KB); /* 调整后地址的偏移 */
if ((lz4ds->base - delta > lz4ds->base) || /* underflow control */
(size_t) (lz4ds->nextBlock - (lz4ds->base) > 0xE0000000)) /* close to 32-bit limit */
{
size_t deltaLimit = (lz4ds->nextBlock - 64KB) - lz4ds->base;
int nH;
for (nH = 0; nH < HASHNBCELLS4; nH++) {
if ((size_t) (lz4ds->hashTable[nH]) < deltaLimit) lz4ds->hashTable[nH] = 0;
else lz4ds->hashTable[nH] -= (U32) deltaLimit;
}
memcpy((void *)(lz4ds->bufferStart), (const void *)(lz4ds->nextBlock - 64KB), 64KB);
lz4ds->base = lz4ds->bufferStart;
lz4ds->nextBlock = lz4ds->base + 64KB;
} else {
/* 把下个块之前的64KB数据拷贝到buffer的头部 */
memcpy((void *)(lz4ds->bufferStart), (const void *)(lz4ds->nextBlock - 64KB), 64KB);
lz4ds->nextBlock -= delta; /* 更新下个块的地址 */
/* 哈希表中的value为偏移值offset。
* pos = base + offset，现在offset -= delta，但是我们又不想去更新offset (更新哈希表)。
* 可以让base -= delta，这样可以不改变offset而取得正确的pos。
* pos是真实的地址。
*/
lz4ds->base -= delta;
}
return (char *) (lz4ds->nextBlock);
}
(4) 解压
LZ4_decompress_generic()是通用的解压算法，只要符合压缩格式就可以解压，无需考虑匹配算法。
typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
typedef enum { full = 0, partial = 1 } earlyEnd_directive;
If endOnInput == endOnInputSize, outputSize is the max size of Output Buffer.
targetOutputSize only used if partialDecoding == partial.
FORCE_INLINE int LZ4_decompress_generic( const char *source, char *dest, int inputSize,
int outputSize, int endOnInput, int prefix64k, int partialDecoding, int targetOutputSize)
{
/* Local variables */
const BYTE *restrict ip = (const BYTE *) source;
const BYTE *ref;
const BYTE *const iend = ip + inputSize;
BYTE *op = (BYTE *) dest;
BYTE *const oend = op + outputSize;
BYTE *cpy;
BYTE *oexit = op + targetOutputSize;
/* static reduces speed for LZ4_compress_safe() on GCC64. */
const size_t dec32table[] = {0, 3, 2, 3, 0, 0, 0, 0};
static const size_t dec64table[] = {0, 0, 0, (size_t) - 1, 0, 1, 2, 3};
/* Special cases */
/* targetOutputSize too high => decode everything */
if ((partialDecoding) && (oexit > oend - MFLIMIT)) oexit = oend - MFLIMIT;
/* Empty output buffer */
if ((endOnInput) && unlikey(outputSize == 0)) return ((inputSize == 1) && (*ip == 0)) ? 0 : -1;
if ((! endOnInput) && unlikely(outputSize == 0)) return (*ip == 0 ? 1 : -1);
/* Main loop，每次循环解压一个序列 */
while(1) {
unsigned token;
size_t length;
/* get runlength，获取literal length */
token = *ip++;
if ((length = (token >> ML_BITS)) == RUN_MASK) {
unsigned s = 255;
while (((endOnInput) ? ip < iend : 1) && (s == 255)) {
s = *ip++;
length += s;
}
}
/* copy literals */
cpy = op + length;
if (((endOnInput) && ((cpy > (partialDecoding ? oexit : oend - MFLIMIT)) ||
(ip + length > iend - (2+1+LASTLITERALS))))
|| ((! endOnInput) && (cpy > oend - COPYLENGTH)))
{
if (partialDecoding) {
if (cpy > oend) goto _output_error; /* write attempt beyond end of output buffer */
if ((endOnInput) && (ip + length > iend)) goto _out_error; /* read attempt beyond end of input buffer */
} else {
if ((! endOnInput) && (cpy != oend)) goto _output_error; /* block decoding must stop exactly there */
if ((endOnInput) && ((ip + length != iend) || (cpy > oend))) goto _output_error; /* input must be consumed */
}
memcpy(op, ip, length);
ip += length;
op += length;
break; /* 注意，这里是退出口 */
}
LZ4_WILDCOPY(op, ip, cpy); ip -= (op - cpy); op = cpy; /* 拷贝literals */
/* get offset，获取偏移值 */
LZ4_READ_LITTLEENDIAN_16(ref, cpy, ip); ip += 2;
/* offset outside destination buffer */
if ((prefix64k == noPrefix) && unlikely(ref < (BYTE *const) dest)) goto _output_error;
/* get matchlength，获取match length */
if ((length = (token & ML_MASK)) == ML_MASK) {
/* Ensure enough bytes remain for LASTLITERALS + token */
while((! endOnInput) || (ip < iend - (LASTLITERALS + 1))) {
unsigned s = *ip++;
length += s;
if (s == 255) continue;
break;
}
}
/* copy repeated sequence，拷贝匹配match */
if unlikely((op - ref) < (int) STEPSIZE) { /* 匹配和自身重叠的情况，拷贝STEPSIZE大小 */
const size_t dec64 = dec64table[(sizeof(void *) == 4 ? 0 : op - ref];
op[0] = ref[0]; op[1] = ref[1]; op[2] = ref[2]; op[3] = ref[3];
op += 4; ref += 4;
ref -= dec32table[op - ref];
A32(op) = A32(ref);
op += STEPSIZE - 4; ref -= dec64;
} else
LZ4_COPYSTEP(op, ref);
cpy = op + length - STEPSIZE + 4; /* match length + 4才是实际match大小*/
if unlikely(cpy > oend - COPYLENGTH - (STEPSIZE - 4)) {
if (cpy > oend - LASTLITERALS) goto _output_error; /* last 5 bytes must be literals */
LZ4_SECURECOPY(op, ref, (oend - COPYLENGTH));
while(op < cpy) *op++ = *ref++;
op = cpy;
continue;
}
LZ4_WILDCOPY(op, ref, cpy);
op = cpy; /* correction */
}
/* end of decoding */
if (endOnInput)
return (int) (((char *)op) - dest); /* Nb of output bytes decoded，解压得到了多少字符 */
else
return (int) (((char *)op) - source); /* Nb of input bytes read，读了多少个压缩字符 */
/* Overflow error detected */
_output_error:
return (int) (-(((char *) ip) - source)) - 1; /* 负号表示出错，值表示Nb of input bytes read */
}
符合以下任一条件退出：
1. endOnInputSize
1.1 partial、cpy > oexit。出错情况：cpy > oend，或ip + length > iend。
1.2 full、cpy > oend - 12、ip + length == iend。出错情况：ip + length != iend，或cpy > oend。
1.3 ip + length > iend - 2 - (1 + 5)
1.3.1 partial。出错情况：cpy > oend，或ip + length > iend。
1.3.2 full、ip + length == iend。出错情况：ip + length != iend，或cpy > oend。
2. endOnOutputSize
2.1 cpy > oend - 8。
2.1.1 partial。出错情况：cpy > oend。
2.1.2 full、cpy == oend。出错情况：cpy != oend。
LZ4使用
make / make clean
得到可执行程序：lz4、lz4c
Usage:
./lz4 [arg] [input] [output]
input : a filename
Arguments :
-1 : Fast compression (default)
-9: High compression
-d : decompression (default for .lz4 extension)
-z : force compression
-f : overwrite output without prompting
-h/-H : display help/long help and exit
LZ4的输入只能为文件，不能为文件夹，毕竟一般压缩工具都不提供tar功能的。
-b file1 [file2] 可以用来测量压缩和解压速度。
比较遗憾的是，没有看可以指定线程数的参数，所以接下来没有测试多线程环境下的效果。
LZ4测试
Xeon E5504 @ 2.00GHz，X84_64，8核CPU，只用了一个。
(1) 速度
可以看到压缩速度和解压速度都很快，而且对日志文件的压缩比相当高。
(2) 压缩比
原始文件为linux-3.6.10.tar，大小为467MB。
用gzip压缩后为linux-3.6.10.tar.gz，大小为101MB，压缩比为21.62%。
用bzip2压缩后为linux-3.6.10.tar.bz2，大小为79MB，压缩比为16.91%。
用lz4压缩后为linux-3.6.10.tar.lz4，大小为166MB，压缩比为35.38%。
用lz4_HC压缩后为linux-3.6.10.tar.lz4，大小为117MB，压缩比为25.03%。
可以看到在压缩比上：lz4 < lz4_HC < gzip < bzip2。
然而在压缩过程中，笔者可以感觉到lz4的压缩时间比其它的要少一个数量级，几乎是瞬间完成：）
所以LZ4的优势在于压缩和解压速度，而不是压缩比。
